Subject: [eap] EAP.states.txt/ state strawman converted to txt

From: [email-masked] (Bernard Aboba)
Date: Fri, 25 Oct 2002 19:54:02 -0700 (PDT)

---------- Forwarded message ----------
Date: Fri, 25 Oct 2002 15:38:14 -0400
From: [email-masked]
To: EAP-Design <[email-masked]>
Subject: [eap-design] EAP.states.txt/ state strawman converted to txt

The following is a first pass at a state diagram that includes an EAP
switch and multiple
methods.  It needs more work, and I am willing to fill it in more, but I
am curious about
whether this is seen as helpful.

The policy in the switch seems the most interesting.  Another thing that
might be
interesting is to talk about what can be passed between methods, and
whether this should
also go through the EAP switch or be left to local implementation
methods.

I think this sort of model could be helpful in understanding state
transitions, and in
defining requirements for EAP methods.

      Peer                                         Auth
      Method                                       Method
             \                                  /
               \                              /
                Peer                      Auth
                EAP    -----------------  EAP

The model is that there are two EAP switches, one at the Peer and one at
the authenticator.
These each have the ability to support some internal policy, the details
of which are not
included.

At both the peer and authenticator one or more EAP method exists.  The
EAP switches select
which methods each is willing to use, and negotiate between themselves
to pick a method or
sequence of methods.

The main thrust of this initial description is give an idea of how the
state machines on
each of the switches will work.  Note that the methods may also have
state machines, but the
details of these are out of scope for this paper.

The peer EAP has the following states

1.	inactive/not authenticated    - waiting for an EAP request
2.	active/waiting-method=x       - waiting for response from method
3.	active/method=x               - waiting for next EAP request
4.	active/nocurrent method       - waiting for request for next method
5.	active/failed method          - waiting for EAP Fail
6.	inactive/authenticated        - authenticated possible reauth
required

Events recognized by the peer EAP are

1.	EAP-Req/ok                    - EAP request acceptable to peer policy
2.	EAP-Req/notok                 - EAP request not acceptable to peer
policy
3.	EAP- Success
4.	EAP- Fail
5.	Method-resp.final .good       - good termination from method
6.	Method-resp.final .fail       - failure termination from method
7.	Method-resp-cont              - continuing response from method

Actions initiated by peer EAP are

1.	Send EAP-NAK
2.	Send EAP-Resp
3.	Forward EAP-req to method
4.	Send method terminate to method
5.	Signal accept or reject to system

State - peer EAP     Event	         Next State	           Action

Inactive/not auth    EAP-Req/ok	        active/waiting-mth=x	Forw req to
method
	             EAP-Req/not ok	Inactive/not auth	Send NAK
	             EAP-Success/ok	inactive/auth	        Signal - accept
	             EAP-Success/not ok Inactive/not auth	Signal-reject
	              *	                Inactive/not auth	silent discard

active/wait-mth=x   mth-rsp.final.good  active/no mth	        Send EAP
Resp
	            mth-rsp.final.fail  active/fail-mth	        Send EAP Resp
	            mth-rsp-cont	active/mth=x	        Send EAP Resp
	            *		        active/wait-mth=x       silent discard

active/mth=x	   EAP-Req/mth=x	active/waiting-mth=x	Forw req to method
	           EAP-Req/meth.ne.x	Inactive/not auth	Send NAK
	                                                        Send Term to
mth=x
	           *		        active/mth=x            silent discard

active/no mth	   EAP-Req/ok	        active/mth=x	        Forw req to
method
	           EAP-Req/not ok	active/no mth	        Send NAK
	           EAP-Success	        inactive/auth	        Signal - accept
	           EAP-Fail	        Inactive/not auth	Signal-reject
	           *	                active/no mth	        silent discard

active/fail-mth	   EAP-Fail	        Inactive/not auth	Signal-reject
	           EAP-Success	        Inactive/not auth	Signal-reject
	           EAP-Req	        active/fail-mth 	Send NAK
	           *	                active/fail-mth	        silent discard

inactive/auth	  EAP-Req/ok	        active/mth=x	         Forw req to
method
	          EAP-Req/not ok	inactive/auth	         Send NAK
	          *	                inactive/auth	         silent discard

--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------
--------------------------------

For authenticator the following states exist

1.	inactive                 - waiting for start indication
2.	 active/method=x.1       - first message of method x sent
3.	active/method=x.c        - continuing message of  method x sent
4.	active/method=x.a        - method x active on authenticator

For authenticator the following events are defined

1.	initiate EAP            - external signal (e.g. from RADIUS) to start
EAP
2.	receive EAP-NAK
3.	receive EAP-Resp.method.eq.x
4.	receive EAP-Resp.method.ne.x
5.	receive EAP-req.1 from method
6.	receive EAP-req.c from method
7.	receive meth-Success or meth-Fail from method

The following actions

1.	initiate method (with parameters)
2.	forward EAP-Req
3.	send EAP Success or Failure
4.	terminate method
5.	signal accept or reject to system

State - authenticator EAP

inactive	initiate EAP	   active/mth=x.a	start method x
	        *	           inactive

active/mth=x.a	rcv EAP-req.1	   active/mth=x.c	forward EAP-req
	        rcv  Meth-Success  active/no mth
	        rcv  Meth-Fail	   active/no mth
	        *

active/mth=x.1	rcv-NAK	actv/nomth
	        rcv-EAP-resp-x	   actv/mth=x.a	forw response to method x
	        rcv-EAP-resp-not-x inactive	        terminate method
	        *

active/mth=x.c	receive-NAK	   inactive	        terminate method
	        rcv-EAP-resp-x	   active/mth=x.c	forw response to method x
	        rcv-EAP-resp-not-x inactive	        terminate method
	        *

active/nomth	(no policy)	    inactive	        Send EAP Success/Failure
	        (more policy)	    active/mth=x.a	start method x