contrib/hostapd/src/eapol_supp/eapol_supp_sm.c

   1 /*
   2  * EAPOL supplicant state machines
   3  * Copyright (c) 2004-2008, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16
  17 #include "common.h"
  18 #include "eapol_supp_sm.h"
  19 #include "eap_peer/eap.h"
  20 #include "eloop.h"
  21 #include "eapol_common.h"
  22 #include "md5.h"
  23 #include "rc4.h"
  24 #include "state_machine.h"
  25 #include "wpabuf.h"
  26
  27 #define STATE_MACHINE_DATA struct eapol_sm
  28 #define STATE_MACHINE_DEBUG_PREFIX "EAPOL"
  29
  30
  31 /* IEEE 802.1X-2004 - Supplicant - EAPOL state machines */
  32
  33 /**
  34  * struct eapol_sm - Internal data for EAPOL state machines
  35  */
  36 struct eapol_sm {
  37         /* Timers */
  38         unsigned int authWhile;
  39         unsigned int heldWhile;
  40         unsigned int startWhen;
  41         unsigned int idleWhile; /* for EAP state machine */
  42         int timer_tick_enabled;
  43
  44         /* Global variables */
  45         Boolean eapFail;
  46         Boolean eapolEap;
  47         Boolean eapSuccess;
  48         Boolean initialize;
  49         Boolean keyDone;
  50         Boolean keyRun;
  51         PortControl portControl;
  52         Boolean portEnabled;
  53         PortStatus suppPortStatus;  /* dot1xSuppControlledPortStatus */
  54         Boolean portValid;
  55         Boolean suppAbort;
  56         Boolean suppFail;
  57         Boolean suppStart;
  58         Boolean suppSuccess;
  59         Boolean suppTimeout;
  60
  61         /* Supplicant PAE state machine */
  62         enum {
  63                 SUPP_PAE_UNKNOWN = 0,
  64                 SUPP_PAE_DISCONNECTED = 1,
  65                 SUPP_PAE_LOGOFF = 2,
  66                 SUPP_PAE_CONNECTING = 3,
  67                 SUPP_PAE_AUTHENTICATING = 4,
  68                 SUPP_PAE_AUTHENTICATED = 5,
  69                 /* unused(6) */
  70                 SUPP_PAE_HELD = 7,
  71                 SUPP_PAE_RESTART = 8,
  72                 SUPP_PAE_S_FORCE_AUTH = 9,
  73                 SUPP_PAE_S_FORCE_UNAUTH = 10
  74         } SUPP_PAE_state; /* dot1xSuppPaeState */
  75         /* Variables */
  76         Boolean userLogoff;
  77         Boolean logoffSent;
  78         unsigned int startCount;
  79         Boolean eapRestart;
  80         PortControl sPortMode;
  81         /* Constants */
  82         unsigned int heldPeriod; /* dot1xSuppHeldPeriod */
  83         unsigned int startPeriod; /* dot1xSuppStartPeriod */
  84         unsigned int maxStart; /* dot1xSuppMaxStart */
  85
  86         /* Key Receive state machine */
  87         enum {
  88                 KEY_RX_UNKNOWN = 0,
  89                 KEY_RX_NO_KEY_RECEIVE, KEY_RX_KEY_RECEIVE
  90         } KEY_RX_state;
  91         /* Variables */
  92         Boolean rxKey;
  93
  94         /* Supplicant Backend state machine */
  95         enum {
  96                 SUPP_BE_UNKNOWN = 0,
  97                 SUPP_BE_INITIALIZE = 1,
  98                 SUPP_BE_IDLE = 2,
  99                 SUPP_BE_REQUEST = 3,
 100                 SUPP_BE_RECEIVE = 4,
 101                 SUPP_BE_RESPONSE = 5,
 102                 SUPP_BE_FAIL = 6,
 103                 SUPP_BE_TIMEOUT = 7,
 104                 SUPP_BE_SUCCESS = 8
 105         } SUPP_BE_state; /* dot1xSuppBackendPaeState */
 106         /* Variables */
 107         Boolean eapNoResp;
 108         Boolean eapReq;
 109         Boolean eapResp;
 110         /* Constants */
 111         unsigned int authPeriod; /* dot1xSuppAuthPeriod */
 112
 113         /* Statistics */
 114         unsigned int dot1xSuppEapolFramesRx;
 115         unsigned int dot1xSuppEapolFramesTx;
 116         unsigned int dot1xSuppEapolStartFramesTx;
 117         unsigned int dot1xSuppEapolLogoffFramesTx;
 118         unsigned int dot1xSuppEapolRespFramesTx;
 119         unsigned int dot1xSuppEapolReqIdFramesRx;
 120         unsigned int dot1xSuppEapolReqFramesRx;
 121         unsigned int dot1xSuppInvalidEapolFramesRx;
 122         unsigned int dot1xSuppEapLengthErrorFramesRx;
 123         unsigned int dot1xSuppLastEapolFrameVersion;
 124         unsigned char dot1xSuppLastEapolFrameSource[6];
 125
 126         /* Miscellaneous variables (not defined in IEEE 802.1X-2004) */
 127         Boolean changed;
 128         struct eap_sm *eap;
 129         struct eap_peer_config *config;
 130         Boolean initial_req;
 131         u8 *last_rx_key;
 132         size_t last_rx_key_len;
 133         struct wpabuf *eapReqData; /* for EAP */
 134         Boolean altAccept; /* for EAP */
 135         Boolean altReject; /* for EAP */
 136         Boolean replay_counter_valid;
 137         u8 last_replay_counter[16];
 138         struct eapol_config conf;
 139         struct eapol_ctx *ctx;
 140         enum { EAPOL_CB_IN_PROGRESS = 0, EAPOL_CB_SUCCESS, EAPOL_CB_FAILURE }
 141                 cb_status;
 142         Boolean cached_pmk;
 143
 144         Boolean unicast_key_received, broadcast_key_received;
 145 };
 146
 147
 148 #define IEEE8021X_REPLAY_COUNTER_LEN 8
 149 #define IEEE8021X_KEY_SIGN_LEN 16
 150 #define IEEE8021X_KEY_IV_LEN 16
 151
 152 #define IEEE8021X_KEY_INDEX_FLAG 0x80
 153 #define IEEE8021X_KEY_INDEX_MASK 0x03
 154
 155 #ifdef _MSC_VER
 156 #pragma pack(push, 1)
 157 #endif /* _MSC_VER */
 158
 159 struct ieee802_1x_eapol_key {
 160         u8 type;
 161         /* Note: key_length is unaligned */
 162         u8 key_length[2];
 163         /* does not repeat within the life of the keying material used to
 164          * encrypt the Key field; 64-bit NTP timestamp MAY be used here */
 165         u8 replay_counter[IEEE8021X_REPLAY_COUNTER_LEN];
 166         u8 key_iv[IEEE8021X_KEY_IV_LEN]; /* cryptographically random number */
 167         u8 key_index; /* key flag in the most significant bit:
 168                        * 0 = broadcast (default key),
 169                        * 1 = unicast (key mapping key); key index is in the
 170                        * 7 least significant bits */
 171         /* HMAC-MD5 message integrity check computed with MS-MPPE-Send-Key as
 172          * the key */
 173         u8 key_signature[IEEE8021X_KEY_SIGN_LEN];
 174
 175         /* followed by key: if packet body length = 44 + key length, then the
 176          * key field (of key_length bytes) contains the key in encrypted form;
 177          * if packet body length = 44, key field is absent and key_length
 178          * represents the number of least significant octets from
 179          * MS-MPPE-Send-Key attribute to be used as the keying material;
 180          * RC4 key used in encryption = Key-IV + MS-MPPE-Recv-Key */
 181 } STRUCT_PACKED;
 182
 183 #ifdef _MSC_VER
 184 #pragma pack(pop)
 185 #endif /* _MSC_VER */
 186
 187
 188 static void eapol_sm_txLogoff(struct eapol_sm *sm);
 189 static void eapol_sm_txStart(struct eapol_sm *sm);
 190 static void eapol_sm_processKey(struct eapol_sm *sm);
 191 static void eapol_sm_getSuppRsp(struct eapol_sm *sm);
 192 static void eapol_sm_txSuppRsp(struct eapol_sm *sm);
 193 static void eapol_sm_abortSupp(struct eapol_sm *sm);
 194 static void eapol_sm_abort_cached(struct eapol_sm *sm);
 195 static void eapol_sm_step_timeout(void *eloop_ctx, void *timeout_ctx);
 196
 197
 198 /* Port Timers state machine - implemented as a function that will be called
 199  * once a second as a registered event loop timeout */
 200 static void eapol_port_timers_tick(void *eloop_ctx, void *timeout_ctx)
 201 {
 202         struct eapol_sm *sm = timeout_ctx;
 203
 204         if (sm->authWhile > 0) {
 205                 sm->authWhile--;
 206                 if (sm->authWhile == 0)
 207                         wpa_printf(MSG_DEBUG, "EAPOL: authWhile --> 0");
 208         }
 209         if (sm->heldWhile > 0) {
 210                 sm->heldWhile--;
 211                 if (sm->heldWhile == 0)
 212                         wpa_printf(MSG_DEBUG, "EAPOL: heldWhile --> 0");
 213         }
 214         if (sm->startWhen > 0) {
 215                 sm->startWhen--;
 216                 if (sm->startWhen == 0)
 217                         wpa_printf(MSG_DEBUG, "EAPOL: startWhen --> 0");
 218         }
 219         if (sm->idleWhile > 0) {
 220                 sm->idleWhile--;
 221                 if (sm->idleWhile == 0)
 222                         wpa_printf(MSG_DEBUG, "EAPOL: idleWhile --> 0");
 223         }
 224
 225         if (sm->authWhile | sm->heldWhile | sm->startWhen | sm->idleWhile) {
 226                 eloop_register_timeout(1, 0, eapol_port_timers_tick, eloop_ctx,
 227                                        sm);
 228         } else {
 229                 wpa_printf(MSG_DEBUG, "EAPOL: disable timer tick");
 230                 sm->timer_tick_enabled = 0;
 231         }
 232         eapol_sm_step(sm);
 233 }
 234
 235
 236 static void eapol_enable_timer_tick(struct eapol_sm *sm)
 237 {
 238         if (sm->timer_tick_enabled)
 239                 return;
 240         wpa_printf(MSG_DEBUG, "EAPOL: enable timer tick");
 241         sm->timer_tick_enabled = 1;
 242         eloop_cancel_timeout(eapol_port_timers_tick, NULL, sm);
 243         eloop_register_timeout(1, 0, eapol_port_timers_tick, NULL, sm);
 244 }
 245
 246
 247 SM_STATE(SUPP_PAE, LOGOFF)
 248 {
 249         SM_ENTRY(SUPP_PAE, LOGOFF);
 250         eapol_sm_txLogoff(sm);
 251         sm->logoffSent = TRUE;
 252         sm->suppPortStatus = Unauthorized;
 253 }
 254
 255
 256 SM_STATE(SUPP_PAE, DISCONNECTED)
 257 {
 258         SM_ENTRY(SUPP_PAE, DISCONNECTED);
 259         sm->sPortMode = Auto;
 260         sm->startCount = 0;
 261         sm->logoffSent = FALSE;
 262         sm->suppPortStatus = Unauthorized;
 263         sm->suppAbort = TRUE;
 264
 265         sm->unicast_key_received = FALSE;
 266         sm->broadcast_key_received = FALSE;
 267 }
 268
 269
 270 SM_STATE(SUPP_PAE, CONNECTING)
 271 {
 272         int send_start = sm->SUPP_PAE_state == SUPP_PAE_CONNECTING;
 273         SM_ENTRY(SUPP_PAE, CONNECTING);
 274         if (send_start) {
 275                 sm->startWhen = sm->startPeriod;
 276                 sm->startCount++;
 277         } else {
 278                 /*
 279                  * Do not send EAPOL-Start immediately since in most cases,
 280                  * Authenticator is going to start authentication immediately
 281                  * after association and an extra EAPOL-Start is just going to
 282                  * delay authentication. Use a short timeout to send the first
 283                  * EAPOL-Start if Authenticator does not start authentication.
 284                  */
 285 #ifdef CONFIG_WPS
 286                 /* Reduce latency on starting WPS negotiation. */
 287                 sm->startWhen = 1;
 288 #else /* CONFIG_WPS */
 289                 sm->startWhen = 3;
 290 #endif /* CONFIG_WPS */
 291         }
 292         eapol_enable_timer_tick(sm);
 293         sm->eapolEap = FALSE;
 294         if (send_start)
 295                 eapol_sm_txStart(sm);
 296 }
 297
 298
 299 SM_STATE(SUPP_PAE, AUTHENTICATING)
 300 {
 301         SM_ENTRY(SUPP_PAE, AUTHENTICATING);
 302         sm->startCount = 0;
 303         sm->suppSuccess = FALSE;
 304         sm->suppFail = FALSE;
 305         sm->suppTimeout = FALSE;
 306         sm->keyRun = FALSE;
 307         sm->keyDone = FALSE;
 308         sm->suppStart = TRUE;
 309 }
 310
 311
 312 SM_STATE(SUPP_PAE, HELD)
 313 {
 314         SM_ENTRY(SUPP_PAE, HELD);
 315         sm->heldWhile = sm->heldPeriod;
 316         eapol_enable_timer_tick(sm);
 317         sm->suppPortStatus = Unauthorized;
 318         sm->cb_status = EAPOL_CB_FAILURE;
 319 }
 320
 321
 322 SM_STATE(SUPP_PAE, AUTHENTICATED)
 323 {
 324         SM_ENTRY(SUPP_PAE, AUTHENTICATED);
 325         sm->suppPortStatus = Authorized;
 326         sm->cb_status = EAPOL_CB_SUCCESS;
 327 }
 328
 329
 330 SM_STATE(SUPP_PAE, RESTART)
 331 {
 332         SM_ENTRY(SUPP_PAE, RESTART);
 333         sm->eapRestart = TRUE;
 334 }
 335
 336
 337 SM_STATE(SUPP_PAE, S_FORCE_AUTH)
 338 {
 339         SM_ENTRY(SUPP_PAE, S_FORCE_AUTH);
 340         sm->suppPortStatus = Authorized;
 341         sm->sPortMode = ForceAuthorized;
 342 }
 343
 344
 345 SM_STATE(SUPP_PAE, S_FORCE_UNAUTH)
 346 {
 347         SM_ENTRY(SUPP_PAE, S_FORCE_UNAUTH);
 348         sm->suppPortStatus = Unauthorized;
 349         sm->sPortMode = ForceUnauthorized;
 350         eapol_sm_txLogoff(sm);
 351 }
 352
 353
 354 SM_STEP(SUPP_PAE)
 355 {
 356         if ((sm->userLogoff && !sm->logoffSent) &&
 357             !(sm->initialize || !sm->portEnabled))
 358                 SM_ENTER_GLOBAL(SUPP_PAE, LOGOFF);
 359         else if (((sm->portControl == Auto) &&
 360                   (sm->sPortMode != sm->portControl)) ||
 361                  sm->initialize || !sm->portEnabled)
 362                 SM_ENTER_GLOBAL(SUPP_PAE, DISCONNECTED);
 363         else if ((sm->portControl == ForceAuthorized) &&
 364                  (sm->sPortMode != sm->portControl) &&
 365                  !(sm->initialize || !sm->portEnabled))
 366                 SM_ENTER_GLOBAL(SUPP_PAE, S_FORCE_AUTH);
 367         else if ((sm->portControl == ForceUnauthorized) &&
 368                  (sm->sPortMode != sm->portControl) &&
 369                  !(sm->initialize || !sm->portEnabled))
 370                 SM_ENTER_GLOBAL(SUPP_PAE, S_FORCE_UNAUTH);
 371         else switch (sm->SUPP_PAE_state) {
 372         case SUPP_PAE_UNKNOWN:
 373                 break;
 374         case SUPP_PAE_LOGOFF:
 375                 if (!sm->userLogoff)
 376                         SM_ENTER(SUPP_PAE, DISCONNECTED);
 377                 break;
 378         case SUPP_PAE_DISCONNECTED:
 379                 SM_ENTER(SUPP_PAE, CONNECTING);
 380                 break;
 381         case SUPP_PAE_CONNECTING:
 382                 if (sm->startWhen == 0 && sm->startCount < sm->maxStart)
 383                         SM_ENTER(SUPP_PAE, CONNECTING);
 384                 else if (sm->startWhen == 0 &&
 385                          sm->startCount >= sm->maxStart &&
 386                          sm->portValid)
 387                         SM_ENTER(SUPP_PAE, AUTHENTICATED);
 388                 else if (sm->eapSuccess || sm->eapFail)
 389                         SM_ENTER(SUPP_PAE, AUTHENTICATING);
 390                 else if (sm->eapolEap)
 391                         SM_ENTER(SUPP_PAE, RESTART);
 392                 else if (sm->startWhen == 0 &&
 393                          sm->startCount >= sm->maxStart &&
 394                          !sm->portValid)
 395                         SM_ENTER(SUPP_PAE, HELD);
 396                 break;
 397         case SUPP_PAE_AUTHENTICATING:
 398                 if (sm->eapSuccess && !sm->portValid &&
 399                     sm->conf.accept_802_1x_keys &&
 400                     sm->conf.required_keys == 0) {
 401                         wpa_printf(MSG_DEBUG, "EAPOL: IEEE 802.1X for "
 402                                    "plaintext connection; no EAPOL-Key frames "
 403                                    "required");
 404                         sm->portValid = TRUE;
 405                         if (sm->ctx->eapol_done_cb)
 406                                 sm->ctx->eapol_done_cb(sm->ctx->ctx);
 407                 }
 408                 if (sm->eapSuccess && sm->portValid)
 409                         SM_ENTER(SUPP_PAE, AUTHENTICATED);
 410                 else if (sm->eapFail || (sm->keyDone && !sm->portValid))
 411                         SM_ENTER(SUPP_PAE, HELD);
 412                 else if (sm->suppTimeout)
 413                         SM_ENTER(SUPP_PAE, CONNECTING);
 414                 break;
 415         case SUPP_PAE_HELD:
 416                 if (sm->heldWhile == 0)
 417                         SM_ENTER(SUPP_PAE, CONNECTING);
 418                 else if (sm->eapolEap)
 419                         SM_ENTER(SUPP_PAE, RESTART);
 420                 break;
 421         case SUPP_PAE_AUTHENTICATED:
 422                 if (sm->eapolEap && sm->portValid)
 423                         SM_ENTER(SUPP_PAE, RESTART);
 424                 else if (!sm->portValid)
 425                         SM_ENTER(SUPP_PAE, DISCONNECTED);
 426                 break;
 427         case SUPP_PAE_RESTART:
 428                 if (!sm->eapRestart)
 429                         SM_ENTER(SUPP_PAE, AUTHENTICATING);
 430                 break;
 431         case SUPP_PAE_S_FORCE_AUTH:
 432                 break;
 433         case SUPP_PAE_S_FORCE_UNAUTH:
 434                 break;
 435         }
 436 }
 437
 438
 439 SM_STATE(KEY_RX, NO_KEY_RECEIVE)
 440 {
 441         SM_ENTRY(KEY_RX, NO_KEY_RECEIVE);
 442 }
 443
 444
 445 SM_STATE(KEY_RX, KEY_RECEIVE)
 446 {
 447         SM_ENTRY(KEY_RX, KEY_RECEIVE);
 448         eapol_sm_processKey(sm);
 449         sm->rxKey = FALSE;
 450 }
 451
 452
 453 SM_STEP(KEY_RX)
 454 {
 455         if (sm->initialize || !sm->portEnabled)
 456                 SM_ENTER_GLOBAL(KEY_RX, NO_KEY_RECEIVE);
 457         switch (sm->KEY_RX_state) {
 458         case KEY_RX_UNKNOWN:
 459                 break;
 460         case KEY_RX_NO_KEY_RECEIVE:
 461                 if (sm->rxKey)
 462                         SM_ENTER(KEY_RX, KEY_RECEIVE);
 463                 break;
 464         case KEY_RX_KEY_RECEIVE:
 465                 if (sm->rxKey)
 466                         SM_ENTER(KEY_RX, KEY_RECEIVE);
 467                 break;
 468         }
 469 }
 470
 471
 472 SM_STATE(SUPP_BE, REQUEST)
 473 {
 474         SM_ENTRY(SUPP_BE, REQUEST);
 475         sm->authWhile = 0;
 476         sm->eapReq = TRUE;
 477         eapol_sm_getSuppRsp(sm);
 478 }
 479
 480
 481 SM_STATE(SUPP_BE, RESPONSE)
 482 {
 483         SM_ENTRY(SUPP_BE, RESPONSE);
 484         eapol_sm_txSuppRsp(sm);
 485         sm->eapResp = FALSE;
 486 }
 487
 488
 489 SM_STATE(SUPP_BE, SUCCESS)
 490 {
 491         SM_ENTRY(SUPP_BE, SUCCESS);
 492         sm->keyRun = TRUE;
 493         sm->suppSuccess = TRUE;
 494
 495         if (eap_key_available(sm->eap)) {
 496                 /* New key received - clear IEEE 802.1X EAPOL-Key replay
 497                  * counter */
 498                 sm->replay_counter_valid = FALSE;
 499         }
 500 }
 501
 502
 503 SM_STATE(SUPP_BE, FAIL)
 504 {
 505         SM_ENTRY(SUPP_BE, FAIL);
 506         sm->suppFail = TRUE;
 507 }
 508
 509
 510 SM_STATE(SUPP_BE, TIMEOUT)
 511 {
 512         SM_ENTRY(SUPP_BE, TIMEOUT);
 513         sm->suppTimeout = TRUE;
 514 }
 515
 516
 517 SM_STATE(SUPP_BE, IDLE)
 518 {
 519         SM_ENTRY(SUPP_BE, IDLE);
 520         sm->suppStart = FALSE;
 521         sm->initial_req = TRUE;
 522 }
 523
 524
 525 SM_STATE(SUPP_BE, INITIALIZE)
 526 {
 527         SM_ENTRY(SUPP_BE, INITIALIZE);
 528         eapol_sm_abortSupp(sm);
 529         sm->suppAbort = FALSE;
 530 }
 531
 532
 533 SM_STATE(SUPP_BE, RECEIVE)
 534 {
 535         SM_ENTRY(SUPP_BE, RECEIVE);
 536         sm->authWhile = sm->authPeriod;
 537         eapol_enable_timer_tick(sm);
 538         sm->eapolEap = FALSE;
 539         sm->eapNoResp = FALSE;
 540         sm->initial_req = FALSE;
 541 }
 542
 543
 544 SM_STEP(SUPP_BE)
 545 {
 546         if (sm->initialize || sm->suppAbort)
 547                 SM_ENTER_GLOBAL(SUPP_BE, INITIALIZE);
 548         else switch (sm->SUPP_BE_state) {
 549         case SUPP_BE_UNKNOWN:
 550                 break;
 551         case SUPP_BE_REQUEST:
 552                 /*
 553                  * IEEE Std 802.1X-2004 has transitions from REQUEST to FAIL
 554                  * and SUCCESS based on eapFail and eapSuccess, respectively.
 555                  * However, IEEE Std 802.1X-2004 is also specifying that
 556                  * eapNoResp should be set in conjuction with eapSuccess and
 557                  * eapFail which would mean that more than one of the
 558                  * transitions here would be activated at the same time.
 559                  * Skipping RESPONSE and/or RECEIVE states in these cases can
 560                  * cause problems and the direct transitions to do not seem
 561                  * correct. Because of this, the conditions for these
 562                  * transitions are verified only after eapNoResp. They are
 563                  * unlikely to be used since eapNoResp should always be set if
 564                  * either of eapSuccess or eapFail is set.
 565                  */
 566                 if (sm->eapResp && sm->eapNoResp) {
 567                         wpa_printf(MSG_DEBUG, "EAPOL: SUPP_BE REQUEST: both "
 568                                    "eapResp and eapNoResp set?!");
 569                 }
 570                 if (sm->eapResp)
 571                         SM_ENTER(SUPP_BE, RESPONSE);
 572                 else if (sm->eapNoResp)
 573                         SM_ENTER(SUPP_BE, RECEIVE);
 574                 else if (sm->eapFail)
 575                         SM_ENTER(SUPP_BE, FAIL);
 576                 else if (sm->eapSuccess)
 577                         SM_ENTER(SUPP_BE, SUCCESS);
 578                 break;
 579         case SUPP_BE_RESPONSE:
 580                 SM_ENTER(SUPP_BE, RECEIVE);
 581                 break;
 582         case SUPP_BE_SUCCESS:
 583                 SM_ENTER(SUPP_BE, IDLE);
 584                 break;
 585         case SUPP_BE_FAIL:
 586                 SM_ENTER(SUPP_BE, IDLE);
 587                 break;
 588         case SUPP_BE_TIMEOUT:
 589                 SM_ENTER(SUPP_BE, IDLE);
 590                 break;
 591         case SUPP_BE_IDLE:
 592                 if (sm->eapFail && sm->suppStart)
 593                         SM_ENTER(SUPP_BE, FAIL);
 594                 else if (sm->eapolEap && sm->suppStart)
 595                         SM_ENTER(SUPP_BE, REQUEST);
 596                 else if (sm->eapSuccess && sm->suppStart)
 597                         SM_ENTER(SUPP_BE, SUCCESS);
 598                 break;
 599         case SUPP_BE_INITIALIZE:
 600                 SM_ENTER(SUPP_BE, IDLE);
 601                 break;
 602         case SUPP_BE_RECEIVE:
 603                 if (sm->eapolEap)
 604                         SM_ENTER(SUPP_BE, REQUEST);
 605                 else if (sm->eapFail)
 606                         SM_ENTER(SUPP_BE, FAIL);
 607                 else if (sm->authWhile == 0)
 608                         SM_ENTER(SUPP_BE, TIMEOUT);
 609                 else if (sm->eapSuccess)
 610                         SM_ENTER(SUPP_BE, SUCCESS);
 611                 break;
 612         }
 613 }
 614
 615
 616 static void eapol_sm_txLogoff(struct eapol_sm *sm)
 617 {
 618         wpa_printf(MSG_DEBUG, "EAPOL: txLogoff");
 619         sm->ctx->eapol_send(sm->ctx->eapol_send_ctx,
 620                             IEEE802_1X_TYPE_EAPOL_LOGOFF, (u8 *) "", 0);
 621         sm->dot1xSuppEapolLogoffFramesTx++;
 622         sm->dot1xSuppEapolFramesTx++;
 623 }
 624
 625
 626 static void eapol_sm_txStart(struct eapol_sm *sm)
 627 {
 628         wpa_printf(MSG_DEBUG, "EAPOL: txStart");
 629         sm->ctx->eapol_send(sm->ctx->eapol_send_ctx,
 630                             IEEE802_1X_TYPE_EAPOL_START, (u8 *) "", 0);
 631         sm->dot1xSuppEapolStartFramesTx++;
 632         sm->dot1xSuppEapolFramesTx++;
 633 }
 634
 635
 636 #define IEEE8021X_ENCR_KEY_LEN 32
 637 #define IEEE8021X_SIGN_KEY_LEN 32
 638
 639 struct eap_key_data {
 640         u8 encr_key[IEEE8021X_ENCR_KEY_LEN];
 641         u8 sign_key[IEEE8021X_SIGN_KEY_LEN];
 642 };
 643
 644
 645 static void eapol_sm_processKey(struct eapol_sm *sm)
 646 {
 647         struct ieee802_1x_hdr *hdr;
 648         struct ieee802_1x_eapol_key *key;
 649         struct eap_key_data keydata;
 650         u8 orig_key_sign[IEEE8021X_KEY_SIGN_LEN], datakey[32];
 651         u8 ekey[IEEE8021X_KEY_IV_LEN + IEEE8021X_ENCR_KEY_LEN];
 652         int key_len, res, sign_key_len, encr_key_len;
 653         u16 rx_key_length;
 654
 655         wpa_printf(MSG_DEBUG, "EAPOL: processKey");
 656         if (sm->last_rx_key == NULL)
 657                 return;
 658
 659         if (!sm->conf.accept_802_1x_keys) {
 660                 wpa_printf(MSG_WARNING, "EAPOL: Received IEEE 802.1X EAPOL-Key"
 661                            " even though this was not accepted - "
 662                            "ignoring this packet");
 663                 return;
 664         }
 665
 666         hdr = (struct ieee802_1x_hdr *) sm->last_rx_key;
 667         key = (struct ieee802_1x_eapol_key *) (hdr + 1);
 668         if (sizeof(*hdr) + be_to_host16(hdr->length) > sm->last_rx_key_len) {
 669                 wpa_printf(MSG_WARNING, "EAPOL: Too short EAPOL-Key frame");
 670                 return;
 671         }
 672         rx_key_length = WPA_GET_BE16(key->key_length);
 673         wpa_printf(MSG_DEBUG, "EAPOL: RX IEEE 802.1X ver=%d type=%d len=%d "
 674                    "EAPOL-Key: type=%d key_length=%d key_index=0x%x",
 675                    hdr->version, hdr->type, be_to_host16(hdr->length),
 676                    key->type, rx_key_length, key->key_index);
 677
 678         eapol_sm_notify_lower_layer_success(sm, 1);
 679         sign_key_len = IEEE8021X_SIGN_KEY_LEN;
 680         encr_key_len = IEEE8021X_ENCR_KEY_LEN;
 681         res = eapol_sm_get_key(sm, (u8 *) &keydata, sizeof(keydata));
 682         if (res < 0) {
 683                 wpa_printf(MSG_DEBUG, "EAPOL: Could not get master key for "
 684                            "decrypting EAPOL-Key keys");
 685                 return;
 686         }
 687         if (res == 16) {
 688                 /* LEAP derives only 16 bytes of keying material. */
 689                 res = eapol_sm_get_key(sm, (u8 *) &keydata, 16);
 690                 if (res) {
 691                         wpa_printf(MSG_DEBUG, "EAPOL: Could not get LEAP "
 692                                    "master key for decrypting EAPOL-Key keys");
 693                         return;
 694                 }
 695                 sign_key_len = 16;
 696                 encr_key_len = 16;
 697                 os_memcpy(keydata.sign_key, keydata.encr_key, 16);
 698         } else if (res) {
 699                 wpa_printf(MSG_DEBUG, "EAPOL: Could not get enough master key "
 700                            "data for decrypting EAPOL-Key keys (res=%d)", res);
 701                 return;
 702         }
 703
 704         /* The key replay_counter must increase when same master key */
 705         if (sm->replay_counter_valid &&
 706             os_memcmp(sm->last_replay_counter, key->replay_counter,
 707                       IEEE8021X_REPLAY_COUNTER_LEN) >= 0) {
 708                 wpa_printf(MSG_WARNING, "EAPOL: EAPOL-Key replay counter did "
 709                            "not increase - ignoring key");
 710                 wpa_hexdump(MSG_DEBUG, "EAPOL: last replay counter",
 711                             sm->last_replay_counter,
 712                             IEEE8021X_REPLAY_COUNTER_LEN);
 713                 wpa_hexdump(MSG_DEBUG, "EAPOL: received replay counter",
 714                             key->replay_counter, IEEE8021X_REPLAY_COUNTER_LEN);
 715                 return;
 716         }
 717
 718         /* Verify key signature (HMAC-MD5) */
 719         os_memcpy(orig_key_sign, key->key_signature, IEEE8021X_KEY_SIGN_LEN);
 720         os_memset(key->key_signature, 0, IEEE8021X_KEY_SIGN_LEN);
 721         hmac_md5(keydata.sign_key, sign_key_len,
 722                  sm->last_rx_key, sizeof(*hdr) + be_to_host16(hdr->length),
 723                  key->key_signature);
 724         if (os_memcmp(orig_key_sign, key->key_signature,
 725                       IEEE8021X_KEY_SIGN_LEN) != 0) {
 726                 wpa_printf(MSG_DEBUG, "EAPOL: Invalid key signature in "
 727                            "EAPOL-Key packet");
 728                 os_memcpy(key->key_signature, orig_key_sign,
 729                           IEEE8021X_KEY_SIGN_LEN);
 730                 return;
 731         }
 732         wpa_printf(MSG_DEBUG, "EAPOL: EAPOL-Key key signature verified");
 733
 734         key_len = be_to_host16(hdr->length) - sizeof(*key);
 735         if (key_len > 32 || rx_key_length > 32) {
 736                 wpa_printf(MSG_WARNING, "EAPOL: Too long key data length %d",
 737                            key_len ? key_len : rx_key_length);
 738                 return;
 739         }
 740         if (key_len == rx_key_length) {
 741                 os_memcpy(ekey, key->key_iv, IEEE8021X_KEY_IV_LEN);
 742                 os_memcpy(ekey + IEEE8021X_KEY_IV_LEN, keydata.encr_key,
 743                           encr_key_len);
 744                 os_memcpy(datakey, key + 1, key_len);
 745                 rc4_skip(ekey, IEEE8021X_KEY_IV_LEN + encr_key_len, 0,
 746                          datakey, key_len);
 747                 wpa_hexdump_key(MSG_DEBUG, "EAPOL: Decrypted(RC4) key",
 748                                 datakey, key_len);
 749         } else if (key_len == 0) {
 750                 /*
 751                  * IEEE 802.1X-2004 specifies that least significant Key Length
 752                  * octets from MS-MPPE-Send-Key are used as the key if the key
 753                  * data is not present. This seems to be meaning the beginning
 754                  * of the MS-MPPE-Send-Key. In addition, MS-MPPE-Send-Key in
 755                  * Supplicant corresponds to MS-MPPE-Recv-Key in Authenticator.
 756                  * Anyway, taking the beginning of the keying material from EAP
 757                  * seems to interoperate with Authenticators.
 758                  */
 759                 key_len = rx_key_length;
 760                 os_memcpy(datakey, keydata.encr_key, key_len);
 761                 wpa_hexdump_key(MSG_DEBUG, "EAPOL: using part of EAP keying "
 762                                 "material data encryption key",
 763                                 datakey, key_len);
 764         } else {
 765                 wpa_printf(MSG_DEBUG, "EAPOL: Invalid key data length %d "
 766                            "(key_length=%d)", key_len, rx_key_length);
 767                 return;
 768         }
 769
 770         sm->replay_counter_valid = TRUE;
 771         os_memcpy(sm->last_replay_counter, key->replay_counter,
 772                   IEEE8021X_REPLAY_COUNTER_LEN);
 773
 774         wpa_printf(MSG_DEBUG, "EAPOL: Setting dynamic WEP key: %s keyidx %d "
 775                    "len %d",
 776                    key->key_index & IEEE8021X_KEY_INDEX_FLAG ?
 777                    "unicast" : "broadcast",
 778                    key->key_index & IEEE8021X_KEY_INDEX_MASK, key_len);
 779
 780         if (sm->ctx->set_wep_key &&
 781             sm->ctx->set_wep_key(sm->ctx->ctx,
 782                                  key->key_index & IEEE8021X_KEY_INDEX_FLAG,
 783                                  key->key_index & IEEE8021X_KEY_INDEX_MASK,
 784                                  datakey, key_len) < 0) {
 785                 wpa_printf(MSG_WARNING, "EAPOL: Failed to set WEP key to the "
 786                            " driver.");
 787         } else {
 788                 if (key->key_index & IEEE8021X_KEY_INDEX_FLAG)
 789                         sm->unicast_key_received = TRUE;
 790                 else
 791                         sm->broadcast_key_received = TRUE;
 792
 793                 if ((sm->unicast_key_received ||
 794                      !(sm->conf.required_keys & EAPOL_REQUIRE_KEY_UNICAST)) &&
 795                     (sm->broadcast_key_received ||
 796                      !(sm->conf.required_keys & EAPOL_REQUIRE_KEY_BROADCAST)))
 797                 {
 798                         wpa_printf(MSG_DEBUG, "EAPOL: all required EAPOL-Key "
 799                                    "frames received");
 800                         sm->portValid = TRUE;
 801                         if (sm->ctx->eapol_done_cb)
 802                                 sm->ctx->eapol_done_cb(sm->ctx->ctx);
 803                 }
 804         }
 805 }
 806
 807
 808 static void eapol_sm_getSuppRsp(struct eapol_sm *sm)
 809 {
 810         wpa_printf(MSG_DEBUG, "EAPOL: getSuppRsp");
 811         /* EAP layer processing; no special code is needed, since Supplicant
 812          * Backend state machine is waiting for eapNoResp or eapResp to be set
 813          * and these are only set in the EAP state machine when the processing
 814          * has finished. */
 815 }
 816
 817
 818 static void eapol_sm_txSuppRsp(struct eapol_sm *sm)
 819 {
 820         struct wpabuf *resp;
 821
 822         wpa_printf(MSG_DEBUG, "EAPOL: txSuppRsp");
 823         resp = eap_get_eapRespData(sm->eap);
 824         if (resp == NULL) {
 825                 wpa_printf(MSG_WARNING, "EAPOL: txSuppRsp - EAP response data "
 826                            "not available");
 827                 return;
 828         }
 829
 830         /* Send EAP-Packet from the EAP layer to the Authenticator */
 831         sm->ctx->eapol_send(sm->ctx->eapol_send_ctx,
 832                             IEEE802_1X_TYPE_EAP_PACKET, wpabuf_head(resp),
 833                             wpabuf_len(resp));
 834
 835         /* eapRespData is not used anymore, so free it here */
 836         wpabuf_free(resp);
 837
 838         if (sm->initial_req)
 839                 sm->dot1xSuppEapolReqIdFramesRx++;
 840         else
 841                 sm->dot1xSuppEapolReqFramesRx++;
 842         sm->dot1xSuppEapolRespFramesTx++;
 843         sm->dot1xSuppEapolFramesTx++;
 844 }
 845
 846
 847 static void eapol_sm_abortSupp(struct eapol_sm *sm)
 848 {
 849         /* release system resources that may have been allocated for the
 850          * authentication session */
 851         os_free(sm->last_rx_key);
 852         sm->last_rx_key = NULL;
 853         wpabuf_free(sm->eapReqData);
 854         sm->eapReqData = NULL;
 855         eap_sm_abort(sm->eap);
 856 }
 857
 858
 859 static void eapol_sm_step_timeout(void *eloop_ctx, void *timeout_ctx)
 860 {
 861         eapol_sm_step(timeout_ctx);
 862 }
 863
 864
 865 /**
 866  * eapol_sm_step - EAPOL state machine step function
 867  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
 868  *
 869  * This function is called to notify the state machine about changed external
 870  * variables. It will step through the EAPOL state machines in loop to process
 871  * all triggered state changes.
 872  */
 873 void eapol_sm_step(struct eapol_sm *sm)
 874 {
 875         int i;
 876
 877         /* In theory, it should be ok to run this in loop until !changed.
 878          * However, it is better to use a limit on number of iterations to
 879          * allow events (e.g., SIGTERM) to stop the program cleanly if the
 880          * state machine were to generate a busy loop. */
 881         for (i = 0; i < 100; i++) {
 882                 sm->changed = FALSE;
 883                 SM_STEP_RUN(SUPP_PAE);
 884                 SM_STEP_RUN(KEY_RX);
 885                 SM_STEP_RUN(SUPP_BE);
 886                 if (eap_peer_sm_step(sm->eap))
 887                         sm->changed = TRUE;
 888                 if (!sm->changed)
 889                         break;
 890         }
 891
 892         if (sm->changed) {
 893                 /* restart EAPOL state machine step from timeout call in order
 894                  * to allow other events to be processed. */
 895                 eloop_cancel_timeout(eapol_sm_step_timeout, NULL, sm);
 896                 eloop_register_timeout(0, 0, eapol_sm_step_timeout, NULL, sm);
 897         }
 898
 899         if (sm->ctx->cb && sm->cb_status != EAPOL_CB_IN_PROGRESS) {
 900                 int success = sm->cb_status == EAPOL_CB_SUCCESS ? 1 : 0;
 901                 sm->cb_status = EAPOL_CB_IN_PROGRESS;
 902                 sm->ctx->cb(sm, success, sm->ctx->cb_ctx);
 903         }
 904 }
 905
 906
 907 #ifdef CONFIG_CTRL_IFACE
 908 static const char *eapol_supp_pae_state(int state)
 909 {
 910         switch (state) {
 911         case SUPP_PAE_LOGOFF:
 912                 return "LOGOFF";
 913         case SUPP_PAE_DISCONNECTED:
 914                 return "DISCONNECTED";
 915         case SUPP_PAE_CONNECTING:
 916                 return "CONNECTING";
 917         case SUPP_PAE_AUTHENTICATING:
 918                 return "AUTHENTICATING";
 919         case SUPP_PAE_HELD:
 920                 return "HELD";
 921         case SUPP_PAE_AUTHENTICATED:
 922                 return "AUTHENTICATED";
 923         case SUPP_PAE_RESTART:
 924                 return "RESTART";
 925         default:
 926                 return "UNKNOWN";
 927         }
 928 }
 929
 930
 931 static const char *eapol_supp_be_state(int state)
 932 {
 933         switch (state) {
 934         case SUPP_BE_REQUEST:
 935                 return "REQUEST";
 936         case SUPP_BE_RESPONSE:
 937                 return "RESPONSE";
 938         case SUPP_BE_SUCCESS:
 939                 return "SUCCESS";
 940         case SUPP_BE_FAIL:
 941                 return "FAIL";
 942         case SUPP_BE_TIMEOUT:
 943                 return "TIMEOUT";
 944         case SUPP_BE_IDLE:
 945                 return "IDLE";
 946         case SUPP_BE_INITIALIZE:
 947                 return "INITIALIZE";
 948         case SUPP_BE_RECEIVE:
 949                 return "RECEIVE";
 950         default:
 951                 return "UNKNOWN";
 952         }
 953 }
 954
 955
 956 static const char * eapol_port_status(PortStatus status)
 957 {
 958         if (status == Authorized)
 959                 return "Authorized";
 960         else
 961                 return "Unauthorized";
 962 }
 963 #endif /* CONFIG_CTRL_IFACE */
 964
 965
 966 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
 967 static const char * eapol_port_control(PortControl ctrl)
 968 {
 969         switch (ctrl) {
 970         case Auto:
 971                 return "Auto";
 972         case ForceUnauthorized:
 973                 return "ForceUnauthorized";
 974         case ForceAuthorized:
 975                 return "ForceAuthorized";
 976         default:
 977                 return "Unknown";
 978         }
 979 }
 980 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
 981
 982
 983 /**
 984  * eapol_sm_configure - Set EAPOL variables
 985  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
 986  * @heldPeriod: dot1xSuppHeldPeriod
 987  * @authPeriod: dot1xSuppAuthPeriod
 988  * @startPeriod: dot1xSuppStartPeriod
 989  * @maxStart: dot1xSuppMaxStart
 990  *
 991  * Set configurable EAPOL state machine variables. Each variable can be set to
 992  * the given value or ignored if set to -1 (to set only some of the variables).
 993  */
 994 void eapol_sm_configure(struct eapol_sm *sm, int heldPeriod, int authPeriod,
 995                         int startPeriod, int maxStart)
 996 {
 997         if (sm == NULL)
 998                 return;
 999         if (heldPeriod >= 0)
1000                 sm->heldPeriod = heldPeriod;
1001         if (authPeriod >= 0)
1002                 sm->authPeriod = authPeriod;
1003         if (startPeriod >= 0)
1004                 sm->startPeriod = startPeriod;
1005         if (maxStart >= 0)
1006                 sm->maxStart = maxStart;
1007 }
1008
1009
1010 #ifdef CONFIG_CTRL_IFACE
1011 /**
1012  * eapol_sm_get_status - Get EAPOL state machine status
1013  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1014  * @buf: Buffer for status information
1015  * @buflen: Maximum buffer length
1016  * @verbose: Whether to include verbose status information
1017  * Returns: Number of bytes written to buf.
1018  *
1019  * Query EAPOL state machine for status information. This function fills in a
1020  * text area with current status information from the EAPOL state machine. If
1021  * the buffer (buf) is not large enough, status information will be truncated
1022  * to fit the buffer.
1023  */
1024 int eapol_sm_get_status(struct eapol_sm *sm, char *buf, size_t buflen,
1025                         int verbose)
1026 {
1027         int len, ret;
1028         if (sm == NULL)
1029                 return 0;
1030
1031         len = os_snprintf(buf, buflen,
1032                           "Supplicant PAE state=%s\n"
1033                           "suppPortStatus=%s\n",
1034                           eapol_supp_pae_state(sm->SUPP_PAE_state),
1035                           eapol_port_status(sm->suppPortStatus));
1036         if (len < 0 || (size_t) len >= buflen)
1037                 return 0;
1038
1039         if (verbose) {
1040                 ret = os_snprintf(buf + len, buflen - len,
1041                                   "heldPeriod=%u\n"
1042                                   "authPeriod=%u\n"
1043                                   "startPeriod=%u\n"
1044                                   "maxStart=%u\n"
1045                                   "portControl=%s\n"
1046                                   "Supplicant Backend state=%s\n",
1047                                   sm->heldPeriod,
1048                                   sm->authPeriod,
1049                                   sm->startPeriod,
1050                                   sm->maxStart,
1051                                   eapol_port_control(sm->portControl),
1052                                   eapol_supp_be_state(sm->SUPP_BE_state));
1053                 if (ret < 0 || (size_t) ret >= buflen - len)
1054                         return len;
1055                 len += ret;
1056         }
1057
1058         len += eap_sm_get_status(sm->eap, buf + len, buflen - len, verbose);
1059
1060         return len;
1061 }
1062
1063
1064 /**
1065  * eapol_sm_get_mib - Get EAPOL state machine MIBs
1066  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1067  * @buf: Buffer for MIB information
1068  * @buflen: Maximum buffer length
1069  * Returns: Number of bytes written to buf.
1070  *
1071  * Query EAPOL state machine for MIB information. This function fills in a
1072  * text area with current MIB information from the EAPOL state machine. If
1073  * the buffer (buf) is not large enough, MIB information will be truncated to
1074  * fit the buffer.
1075  */
1076 int eapol_sm_get_mib(struct eapol_sm *sm, char *buf, size_t buflen)
1077 {
1078         size_t len;
1079         int ret;
1080
1081         if (sm == NULL)
1082                 return 0;
1083         ret = os_snprintf(buf, buflen,
1084                           "dot1xSuppPaeState=%d\n"
1085                           "dot1xSuppHeldPeriod=%u\n"
1086                           "dot1xSuppAuthPeriod=%u\n"
1087                           "dot1xSuppStartPeriod=%u\n"
1088                           "dot1xSuppMaxStart=%u\n"
1089                           "dot1xSuppSuppControlledPortStatus=%s\n"
1090                           "dot1xSuppBackendPaeState=%d\n",
1091                           sm->SUPP_PAE_state,
1092                           sm->heldPeriod,
1093                           sm->authPeriod,
1094                           sm->startPeriod,
1095                           sm->maxStart,
1096                           sm->suppPortStatus == Authorized ?
1097                           "Authorized" : "Unauthorized",
1098                           sm->SUPP_BE_state);
1099
1100         if (ret < 0 || (size_t) ret >= buflen)
1101                 return 0;
1102         len = ret;
1103
1104         ret = os_snprintf(buf + len, buflen - len,
1105                           "dot1xSuppEapolFramesRx=%u\n"
1106                           "dot1xSuppEapolFramesTx=%u\n"
1107                           "dot1xSuppEapolStartFramesTx=%u\n"
1108                           "dot1xSuppEapolLogoffFramesTx=%u\n"
1109                           "dot1xSuppEapolRespFramesTx=%u\n"
1110                           "dot1xSuppEapolReqIdFramesRx=%u\n"
1111                           "dot1xSuppEapolReqFramesRx=%u\n"
1112                           "dot1xSuppInvalidEapolFramesRx=%u\n"
1113                           "dot1xSuppEapLengthErrorFramesRx=%u\n"
1114                           "dot1xSuppLastEapolFrameVersion=%u\n"
1115                           "dot1xSuppLastEapolFrameSource=" MACSTR "\n",
1116                           sm->dot1xSuppEapolFramesRx,
1117                           sm->dot1xSuppEapolFramesTx,
1118                           sm->dot1xSuppEapolStartFramesTx,
1119                           sm->dot1xSuppEapolLogoffFramesTx,
1120                           sm->dot1xSuppEapolRespFramesTx,
1121                           sm->dot1xSuppEapolReqIdFramesRx,
1122                           sm->dot1xSuppEapolReqFramesRx,
1123                           sm->dot1xSuppInvalidEapolFramesRx,
1124                           sm->dot1xSuppEapLengthErrorFramesRx,
1125                           sm->dot1xSuppLastEapolFrameVersion,
1126                           MAC2STR(sm->dot1xSuppLastEapolFrameSource));
1127
1128         if (ret < 0 || (size_t) ret >= buflen - len)
1129                 return len;
1130         len += ret;
1131
1132         return len;
1133 }
1134 #endif /* CONFIG_CTRL_IFACE */
1135
1136
1137 /**
1138  * eapol_sm_rx_eapol - Process received EAPOL frames
1139  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1140  * @src: Source MAC address of the EAPOL packet
1141  * @buf: Pointer to the beginning of the EAPOL data (EAPOL header)
1142  * @len: Length of the EAPOL frame
1143  * Returns: 1 = EAPOL frame processed, 0 = not for EAPOL state machine,
1144  * -1 failure
1145  */
1146 int eapol_sm_rx_eapol(struct eapol_sm *sm, const u8 *src, const u8 *buf,
1147                       size_t len)
1148 {
1149         const struct ieee802_1x_hdr *hdr;
1150         const struct ieee802_1x_eapol_key *key;
1151         int data_len;
1152         int res = 1;
1153         size_t plen;
1154
1155         if (sm == NULL)
1156                 return 0;
1157         sm->dot1xSuppEapolFramesRx++;
1158         if (len < sizeof(*hdr)) {
1159                 sm->dot1xSuppInvalidEapolFramesRx++;
1160                 return 0;
1161         }
1162         hdr = (const struct ieee802_1x_hdr *) buf;
1163         sm->dot1xSuppLastEapolFrameVersion = hdr->version;
1164         os_memcpy(sm->dot1xSuppLastEapolFrameSource, src, ETH_ALEN);
1165         if (hdr->version < EAPOL_VERSION) {
1166                 /* TODO: backwards compatibility */
1167         }
1168         plen = be_to_host16(hdr->length);
1169         if (plen > len - sizeof(*hdr)) {
1170                 sm->dot1xSuppEapLengthErrorFramesRx++;
1171                 return 0;
1172         }
1173 #ifdef CONFIG_WPS
1174         if (sm->conf.workaround &&
1175             plen < len - sizeof(*hdr) &&
1176             hdr->type == IEEE802_1X_TYPE_EAP_PACKET &&
1177             len - sizeof(*hdr) > sizeof(struct eap_hdr)) {
1178                 const struct eap_hdr *ehdr =
1179                         (const struct eap_hdr *) (hdr + 1);
1180                 u16 elen;
1181
1182                 elen = be_to_host16(ehdr->length);
1183                 if (elen > plen && elen <= len - sizeof(*hdr)) {
1184                         /*
1185                          * Buffalo WHR-G125 Ver.1.47 seems to send EAP-WPS
1186                          * packets with too short EAPOL header length field
1187                          * (14 octets). This is fixed in firmware Ver.1.49.
1188                          * As a workaround, fix the EAPOL header based on the
1189                          * correct length in the EAP packet.
1190                          */
1191                         wpa_printf(MSG_DEBUG, "EAPOL: Workaround - fix EAPOL "
1192                                    "payload length based on EAP header: "
1193                                    "%d -> %d", (int) plen, elen);
1194                         plen = elen;
1195                 }
1196         }
1197 #endif /* CONFIG_WPS */
1198         data_len = plen + sizeof(*hdr);
1199
1200         switch (hdr->type) {
1201         case IEEE802_1X_TYPE_EAP_PACKET:
1202                 if (sm->cached_pmk) {
1203                         /* Trying to use PMKSA caching, but Authenticator did
1204                          * not seem to have a matching entry. Need to restart
1205                          * EAPOL state machines.
1206                          */
1207                         eapol_sm_abort_cached(sm);
1208                 }
1209                 wpabuf_free(sm->eapReqData);
1210                 sm->eapReqData = wpabuf_alloc_copy(hdr + 1, plen);
1211                 if (sm->eapReqData) {
1212                         wpa_printf(MSG_DEBUG, "EAPOL: Received EAP-Packet "
1213                                    "frame");
1214                         sm->eapolEap = TRUE;
1215                         eapol_sm_step(sm);
1216                 }
1217                 break;
1218         case IEEE802_1X_TYPE_EAPOL_KEY:
1219                 if (plen < sizeof(*key)) {
1220                         wpa_printf(MSG_DEBUG, "EAPOL: Too short EAPOL-Key "
1221                                    "frame received");
1222                         break;
1223                 }
1224                 key = (const struct ieee802_1x_eapol_key *) (hdr + 1);
1225                 if (key->type == EAPOL_KEY_TYPE_WPA ||
1226                     key->type == EAPOL_KEY_TYPE_RSN) {
1227                         /* WPA Supplicant takes care of this frame. */
1228                         wpa_printf(MSG_DEBUG, "EAPOL: Ignoring WPA EAPOL-Key "
1229                                    "frame in EAPOL state machines");
1230                         res = 0;
1231                         break;
1232                 }
1233                 if (key->type != EAPOL_KEY_TYPE_RC4) {
1234                         wpa_printf(MSG_DEBUG, "EAPOL: Ignored unknown "
1235                                    "EAPOL-Key type %d", key->type);
1236                         break;
1237                 }
1238                 os_free(sm->last_rx_key);
1239                 sm->last_rx_key = os_malloc(data_len);
1240                 if (sm->last_rx_key) {
1241                         wpa_printf(MSG_DEBUG, "EAPOL: Received EAPOL-Key "
1242                                    "frame");
1243                         os_memcpy(sm->last_rx_key, buf, data_len);
1244                         sm->last_rx_key_len = data_len;
1245                         sm->rxKey = TRUE;
1246                         eapol_sm_step(sm);
1247                 }
1248                 break;
1249         default:
1250                 wpa_printf(MSG_DEBUG, "EAPOL: Received unknown EAPOL type %d",
1251                            hdr->type);
1252                 sm->dot1xSuppInvalidEapolFramesRx++;
1253                 break;
1254         }
1255
1256         return res;
1257 }
1258
1259
1260 /**
1261  * eapol_sm_notify_tx_eapol_key - Notification about transmitted EAPOL packet
1262  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1263  *
1264  * Notify EAPOL state machine about transmitted EAPOL packet from an external
1265  * component, e.g., WPA. This will update the statistics.
1266  */
1267 void eapol_sm_notify_tx_eapol_key(struct eapol_sm *sm)
1268 {
1269         if (sm)
1270                 sm->dot1xSuppEapolFramesTx++;
1271 }
1272
1273
1274 /**
1275  * eapol_sm_notify_portEnabled - Notification about portEnabled change
1276  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1277  * @enabled: New portEnabled value
1278  *
1279  * Notify EAPOL state machine about new portEnabled value.
1280  */
1281 void eapol_sm_notify_portEnabled(struct eapol_sm *sm, Boolean enabled)
1282 {
1283         if (sm == NULL)
1284                 return;
1285         wpa_printf(MSG_DEBUG, "EAPOL: External notification - "
1286                    "portEnabled=%d", enabled);
1287         sm->portEnabled = enabled;
1288         eapol_sm_step(sm);
1289 }
1290
1291
1292 /**
1293  * eapol_sm_notify_portValid - Notification about portValid change
1294  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1295  * @valid: New portValid value
1296  *
1297  * Notify EAPOL state machine about new portValid value.
1298  */
1299 void eapol_sm_notify_portValid(struct eapol_sm *sm, Boolean valid)
1300 {
1301         if (sm == NULL)
1302                 return;
1303         wpa_printf(MSG_DEBUG, "EAPOL: External notification - "
1304                    "portValid=%d", valid);
1305         sm->portValid = valid;
1306         eapol_sm_step(sm);
1307 }
1308
1309
1310 /**
1311  * eapol_sm_notify_eap_success - Notification of external EAP success trigger
1312  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1313  * @success: %TRUE = set success, %FALSE = clear success
1314  *
1315  * Notify the EAPOL state machine that external event has forced EAP state to
1316  * success (success = %TRUE). This can be cleared by setting success = %FALSE.
1317  *
1318  * This function is called to update EAP state when WPA-PSK key handshake has
1319  * been completed successfully since WPA-PSK does not use EAP state machine.
1320  */
1321 void eapol_sm_notify_eap_success(struct eapol_sm *sm, Boolean success)
1322 {
1323         if (sm == NULL)
1324                 return;
1325         wpa_printf(MSG_DEBUG, "EAPOL: External notification - "
1326                    "EAP success=%d", success);
1327         sm->eapSuccess = success;
1328         sm->altAccept = success;
1329         if (success)
1330                 eap_notify_success(sm->eap);
1331         eapol_sm_step(sm);
1332 }
1333
1334
1335 /**
1336  * eapol_sm_notify_eap_fail - Notification of external EAP failure trigger
1337  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1338  * @fail: %TRUE = set failure, %FALSE = clear failure
1339  *
1340  * Notify EAPOL state machine that external event has forced EAP state to
1341  * failure (fail = %TRUE). This can be cleared by setting fail = %FALSE.
1342  */
1343 void eapol_sm_notify_eap_fail(struct eapol_sm *sm, Boolean fail)
1344 {
1345         if (sm == NULL)
1346                 return;
1347         wpa_printf(MSG_DEBUG, "EAPOL: External notification - "
1348                    "EAP fail=%d", fail);
1349         sm->eapFail = fail;
1350         sm->altReject = fail;
1351         eapol_sm_step(sm);
1352 }
1353
1354
1355 /**
1356  * eapol_sm_notify_config - Notification of EAPOL configuration change
1357  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1358  * @config: Pointer to current network EAP configuration
1359  * @conf: Pointer to EAPOL configuration data
1360  *
1361  * Notify EAPOL state machine that configuration has changed. config will be
1362  * stored as a backpointer to network configuration. This can be %NULL to clear
1363  * the stored pointed. conf will be copied to local EAPOL/EAP configuration
1364  * data. If conf is %NULL, this part of the configuration change will be
1365  * skipped.
1366  */
1367 void eapol_sm_notify_config(struct eapol_sm *sm,
1368                             struct eap_peer_config *config,
1369                             const struct eapol_config *conf)
1370 {
1371         if (sm == NULL)
1372                 return;
1373
1374         sm->config = config;
1375
1376         if (conf == NULL)
1377                 return;
1378
1379         sm->conf.accept_802_1x_keys = conf->accept_802_1x_keys;
1380         sm->conf.required_keys = conf->required_keys;
1381         sm->conf.fast_reauth = conf->fast_reauth;
1382         sm->conf.workaround = conf->workaround;
1383         if (sm->eap) {
1384                 eap_set_fast_reauth(sm->eap, conf->fast_reauth);
1385                 eap_set_workaround(sm->eap, conf->workaround);
1386                 eap_set_force_disabled(sm->eap, conf->eap_disabled);
1387         }
1388 }
1389
1390
1391 /**
1392  * eapol_sm_get_key - Get master session key (MSK) from EAP
1393  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1394  * @key: Pointer for key buffer
1395  * @len: Number of bytes to copy to key
1396  * Returns: 0 on success (len of key available), maximum available key len
1397  * (>0) if key is available but it is shorter than len, or -1 on failure.
1398  *
1399  * Fetch EAP keying material (MSK, eapKeyData) from EAP state machine. The key
1400  * is available only after a successful authentication.
1401  */
1402 int eapol_sm_get_key(struct eapol_sm *sm, u8 *key, size_t len)
1403 {
1404         const u8 *eap_key;
1405         size_t eap_len;
1406
1407         if (sm == NULL || !eap_key_available(sm->eap)) {
1408                 wpa_printf(MSG_DEBUG, "EAPOL: EAP key not available");
1409                 return -1;
1410         }
1411         eap_key = eap_get_eapKeyData(sm->eap, &eap_len);
1412         if (eap_key == NULL) {
1413                 wpa_printf(MSG_DEBUG, "EAPOL: Failed to get eapKeyData");
1414                 return -1;
1415         }
1416         if (len > eap_len) {
1417                 wpa_printf(MSG_DEBUG, "EAPOL: Requested key length (%lu) not "
1418                            "available (len=%lu)",
1419                            (unsigned long) len, (unsigned long) eap_len);
1420                 return eap_len;
1421         }
1422         os_memcpy(key, eap_key, len);
1423         wpa_printf(MSG_DEBUG, "EAPOL: Successfully fetched key (len=%lu)",
1424                    (unsigned long) len);
1425         return 0;
1426 }
1427
1428
1429 /**
1430  * eapol_sm_notify_logoff - Notification of logon/logoff commands
1431  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1432  * @logoff: Whether command was logoff
1433  *
1434  * Notify EAPOL state machines that user requested logon/logoff.
1435  */
1436 void eapol_sm_notify_logoff(struct eapol_sm *sm, Boolean logoff)
1437 {
1438         if (sm) {
1439                 sm->userLogoff = logoff;
1440                 eapol_sm_step(sm);
1441         }
1442 }
1443
1444
1445 /**
1446  * eapol_sm_notify_pmkid_attempt - Notification of successful PMKSA caching
1447  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1448  *
1449  * Notify EAPOL state machines that PMKSA caching was successful. This is used
1450  * to move EAPOL and EAP state machines into authenticated/successful state.
1451  */
1452 void eapol_sm_notify_cached(struct eapol_sm *sm)
1453 {
1454         if (sm == NULL)
1455                 return;
1456         wpa_printf(MSG_DEBUG, "EAPOL: PMKSA caching was used - skip EAPOL");
1457         sm->SUPP_PAE_state = SUPP_PAE_AUTHENTICATED;
1458         sm->suppPortStatus = Authorized;
1459         sm->portValid = TRUE;
1460         eap_notify_success(sm->eap);
1461         eapol_sm_step(sm);
1462 }
1463
1464
1465 /**
1466  * eapol_sm_notify_pmkid_attempt - Notification of PMKSA caching
1467  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1468  * @attempt: Whether PMKSA caching is tried
1469  *
1470  * Notify EAPOL state machines whether PMKSA caching is used.
1471  */
1472 void eapol_sm_notify_pmkid_attempt(struct eapol_sm *sm, int attempt)
1473 {
1474         if (sm == NULL)
1475                 return;
1476         if (attempt) {
1477                 wpa_printf(MSG_DEBUG, "RSN: Trying to use cached PMKSA");
1478                 sm->cached_pmk = TRUE;
1479         } else {
1480                 wpa_printf(MSG_DEBUG, "RSN: Do not try to use cached PMKSA");
1481                 sm->cached_pmk = FALSE;
1482         }
1483 }
1484
1485
1486 static void eapol_sm_abort_cached(struct eapol_sm *sm)
1487 {
1488         wpa_printf(MSG_DEBUG, "RSN: Authenticator did not accept PMKID, "
1489                    "doing full EAP authentication");
1490         if (sm == NULL)
1491                 return;
1492         sm->cached_pmk = FALSE;
1493         sm->SUPP_PAE_state = SUPP_PAE_CONNECTING;
1494         sm->suppPortStatus = Unauthorized;
1495
1496         /* Make sure we do not start sending EAPOL-Start frames first, but
1497          * instead move to RESTART state to start EAPOL authentication. */
1498         sm->startWhen = 3;
1499         eapol_enable_timer_tick(sm);
1500
1501         if (sm->ctx->aborted_cached)
1502                 sm->ctx->aborted_cached(sm->ctx->ctx);
1503 }
1504
1505
1506 /**
1507  * eapol_sm_register_scard_ctx - Notification of smart card context
1508  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1509  * @ctx: Context data for smart card operations
1510  *
1511  * Notify EAPOL state machines of context data for smart card operations. This
1512  * context data will be used as a parameter for scard_*() functions.
1513  */
1514 void eapol_sm_register_scard_ctx(struct eapol_sm *sm, void *ctx)
1515 {
1516         if (sm) {
1517                 sm->ctx->scard_ctx = ctx;
1518                 eap_register_scard_ctx(sm->eap, ctx);
1519         }
1520 }
1521
1522
1523 /**
1524  * eapol_sm_notify_portControl - Notification of portControl changes
1525  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1526  * @portControl: New value for portControl variable
1527  *
1528  * Notify EAPOL state machines that portControl variable has changed.
1529  */
1530 void eapol_sm_notify_portControl(struct eapol_sm *sm, PortControl portControl)
1531 {
1532         if (sm == NULL)
1533                 return;
1534         wpa_printf(MSG_DEBUG, "EAPOL: External notification - "
1535                    "portControl=%s", eapol_port_control(portControl));
1536         sm->portControl = portControl;
1537         eapol_sm_step(sm);
1538 }
1539
1540
1541 /**
1542  * eapol_sm_notify_ctrl_attached - Notification of attached monitor
1543  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1544  *
1545  * Notify EAPOL state machines that a monitor was attached to the control
1546  * interface to trigger re-sending of pending requests for user input.
1547  */
1548 void eapol_sm_notify_ctrl_attached(struct eapol_sm *sm)
1549 {
1550         if (sm == NULL)
1551                 return;
1552         eap_sm_notify_ctrl_attached(sm->eap);
1553 }
1554
1555
1556 /**
1557  * eapol_sm_notify_ctrl_response - Notification of received user input
1558  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1559  *
1560  * Notify EAPOL state machines that a control response, i.e., user
1561  * input, was received in order to trigger retrying of a pending EAP request.
1562  */
1563 void eapol_sm_notify_ctrl_response(struct eapol_sm *sm)
1564 {
1565         if (sm == NULL)
1566                 return;
1567         if (sm->eapReqData && !sm->eapReq) {
1568                 wpa_printf(MSG_DEBUG, "EAPOL: received control response (user "
1569                            "input) notification - retrying pending EAP "
1570                            "Request");
1571                 sm->eapolEap = TRUE;
1572                 sm->eapReq = TRUE;
1573                 eapol_sm_step(sm);
1574         }
1575 }
1576
1577
1578 /**
1579  * eapol_sm_request_reauth - Request reauthentication
1580  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1581  *
1582  * This function can be used to request EAPOL reauthentication, e.g., when the
1583  * current PMKSA entry is nearing expiration.
1584  */
1585 void eapol_sm_request_reauth(struct eapol_sm *sm)
1586 {
1587         if (sm == NULL || sm->SUPP_PAE_state != SUPP_PAE_AUTHENTICATED)
1588                 return;
1589         eapol_sm_txStart(sm);
1590 }
1591
1592
1593 /**
1594  * eapol_sm_notify_lower_layer_success - Notification of lower layer success
1595  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1596  * @in_eapol_sm: Whether the caller is already running inside EAPOL state
1597  * machine loop (eapol_sm_step())
1598  *
1599  * Notify EAPOL (and EAP) state machines that a lower layer has detected a
1600  * successful authentication. This is used to recover from dropped EAP-Success
1601  * messages.
1602  */
1603 void eapol_sm_notify_lower_layer_success(struct eapol_sm *sm, int in_eapol_sm)
1604 {
1605         if (sm == NULL)
1606                 return;
1607         eap_notify_lower_layer_success(sm->eap);
1608         if (!in_eapol_sm)
1609                 eapol_sm_step(sm);
1610 }
1611
1612
1613 /**
1614  * eapol_sm_invalidate_cached_session - Mark cached EAP session data invalid
1615  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1616  */
1617 void eapol_sm_invalidate_cached_session(struct eapol_sm *sm)
1618 {
1619         if (sm)
1620                 eap_invalidate_cached_session(sm->eap);
1621 }
1622
1623
1624 static struct eap_peer_config * eapol_sm_get_config(void *ctx)
1625 {
1626         struct eapol_sm *sm = ctx;
1627         return sm ? sm->config : NULL;
1628 }
1629
1630
1631 static struct wpabuf * eapol_sm_get_eapReqData(void *ctx)
1632 {
1633         struct eapol_sm *sm = ctx;
1634         if (sm == NULL || sm->eapReqData == NULL)
1635                 return NULL;
1636
1637         return sm->eapReqData;
1638 }
1639
1640
1641 static Boolean eapol_sm_get_bool(void *ctx, enum eapol_bool_var variable)
1642 {
1643         struct eapol_sm *sm = ctx;
1644         if (sm == NULL)
1645                 return FALSE;
1646         switch (variable) {
1647         case EAPOL_eapSuccess:
1648                 return sm->eapSuccess;
1649         case EAPOL_eapRestart:
1650                 return sm->eapRestart;
1651         case EAPOL_eapFail:
1652                 return sm->eapFail;
1653         case EAPOL_eapResp:
1654                 return sm->eapResp;
1655         case EAPOL_eapNoResp:
1656                 return sm->eapNoResp;
1657         case EAPOL_eapReq:
1658                 return sm->eapReq;
1659         case EAPOL_portEnabled:
1660                 return sm->portEnabled;
1661         case EAPOL_altAccept:
1662                 return sm->altAccept;
1663         case EAPOL_altReject:
1664                 return sm->altReject;
1665         }
1666         return FALSE;
1667 }
1668
1669
1670 static void eapol_sm_set_bool(void *ctx, enum eapol_bool_var variable,
1671                               Boolean value)
1672 {
1673         struct eapol_sm *sm = ctx;
1674         if (sm == NULL)
1675                 return;
1676         switch (variable) {
1677         case EAPOL_eapSuccess:
1678                 sm->eapSuccess = value;
1679                 break;
1680         case EAPOL_eapRestart:
1681                 sm->eapRestart = value;
1682                 break;
1683         case EAPOL_eapFail:
1684                 sm->eapFail = value;
1685                 break;
1686         case EAPOL_eapResp:
1687                 sm->eapResp = value;
1688                 break;
1689         case EAPOL_eapNoResp:
1690                 sm->eapNoResp = value;
1691                 break;
1692         case EAPOL_eapReq:
1693                 sm->eapReq = value;
1694                 break;
1695         case EAPOL_portEnabled:
1696                 sm->portEnabled = value;
1697                 break;
1698         case EAPOL_altAccept:
1699                 sm->altAccept = value;
1700                 break;
1701         case EAPOL_altReject:
1702                 sm->altReject = value;
1703                 break;
1704         }
1705 }
1706
1707
1708 static unsigned int eapol_sm_get_int(void *ctx, enum eapol_int_var variable)
1709 {
1710         struct eapol_sm *sm = ctx;
1711         if (sm == NULL)
1712                 return 0;
1713         switch (variable) {
1714         case EAPOL_idleWhile:
1715                 return sm->idleWhile;
1716         }
1717         return 0;
1718 }
1719
1720
1721 static void eapol_sm_set_int(void *ctx, enum eapol_int_var variable,
1722                              unsigned int value)
1723 {
1724         struct eapol_sm *sm = ctx;
1725         if (sm == NULL)
1726                 return;
1727         switch (variable) {
1728         case EAPOL_idleWhile:
1729                 sm->idleWhile = value;
1730                 eapol_enable_timer_tick(sm);
1731                 break;
1732         }
1733 }
1734
1735
1736 static void eapol_sm_set_config_blob(void *ctx, struct wpa_config_blob *blob)
1737 {
1738 #ifndef CONFIG_NO_CONFIG_BLOBS
1739         struct eapol_sm *sm = ctx;
1740         if (sm && sm->ctx && sm->ctx->set_config_blob)
1741                 sm->ctx->set_config_blob(sm->ctx->ctx, blob);
1742 #endif /* CONFIG_NO_CONFIG_BLOBS */
1743 }
1744
1745
1746 static const struct wpa_config_blob *
1747 eapol_sm_get_config_blob(void *ctx, const char *name)
1748 {
1749 #ifndef CONFIG_NO_CONFIG_BLOBS
1750         struct eapol_sm *sm = ctx;
1751         if (sm && sm->ctx && sm->ctx->get_config_blob)
1752                 return sm->ctx->get_config_blob(sm->ctx->ctx, name);
1753         else
1754                 return NULL;
1755 #else /* CONFIG_NO_CONFIG_BLOBS */
1756         return NULL;
1757 #endif /* CONFIG_NO_CONFIG_BLOBS */
1758 }
1759
1760
1761 static void eapol_sm_notify_pending(void *ctx)
1762 {
1763         struct eapol_sm *sm = ctx;
1764         if (sm == NULL)
1765                 return;
1766         if (sm->eapReqData && !sm->eapReq) {
1767                 wpa_printf(MSG_DEBUG, "EAPOL: received notification from EAP "
1768                            "state machine - retrying pending EAP Request");
1769                 sm->eapolEap = TRUE;
1770                 sm->eapReq = TRUE;
1771                 eapol_sm_step(sm);
1772         }
1773 }
1774
1775
1776 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
1777 static void eapol_sm_eap_param_needed(void *ctx, const char *field,
1778                                       const char *txt)
1779 {
1780         struct eapol_sm *sm = ctx;
1781         wpa_printf(MSG_DEBUG, "EAPOL: EAP parameter needed");
1782         if (sm->ctx->eap_param_needed)
1783                 sm->ctx->eap_param_needed(sm->ctx->ctx, field, txt);
1784 }
1785 #else /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
1786 #define eapol_sm_eap_param_needed NULL
1787 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
1788
1789
1790 static struct eapol_callbacks eapol_cb =
1791 {
1792         eapol_sm_get_config,
1793         eapol_sm_get_bool,
1794         eapol_sm_set_bool,
1795         eapol_sm_get_int,
1796         eapol_sm_set_int,
1797         eapol_sm_get_eapReqData,
1798         eapol_sm_set_config_blob,
1799         eapol_sm_get_config_blob,
1800         eapol_sm_notify_pending,
1801         eapol_sm_eap_param_needed
1802 };
1803
1804
1805 /**
1806  * eapol_sm_init - Initialize EAPOL state machine
1807  * @ctx: Pointer to EAPOL context data; this needs to be an allocated buffer
1808  * and EAPOL state machine will free it in eapol_sm_deinit()
1809  * Returns: Pointer to the allocated EAPOL state machine or %NULL on failure
1810  *
1811  * Allocate and initialize an EAPOL state machine.
1812  */
1813 struct eapol_sm *eapol_sm_init(struct eapol_ctx *ctx)
1814 {
1815         struct eapol_sm *sm;
1816         struct eap_config conf;
1817         sm = os_zalloc(sizeof(*sm));
1818         if (sm == NULL)
1819                 return NULL;
1820         sm->ctx = ctx;
1821
1822         sm->portControl = Auto;
1823
1824         /* Supplicant PAE state machine */
1825         sm->heldPeriod = 60;
1826         sm->startPeriod = 30;
1827         sm->maxStart = 3;
1828
1829         /* Supplicant Backend state machine */
1830         sm->authPeriod = 30;
1831
1832         os_memset(&conf, 0, sizeof(conf));
1833 #ifdef EAP_TLS_OPENSSL
1834         conf.opensc_engine_path = ctx->opensc_engine_path;
1835         conf.pkcs11_engine_path = ctx->pkcs11_engine_path;
1836         conf.pkcs11_module_path = ctx->pkcs11_module_path;
1837 #endif /* EAP_TLS_OPENSSL */
1838         conf.wps = ctx->wps;
1839
1840         sm->eap = eap_peer_sm_init(sm, &eapol_cb, sm->ctx->msg_ctx, &conf);
1841         if (sm->eap == NULL) {
1842                 os_free(sm);
1843                 return NULL;
1844         }
1845
1846         /* Initialize EAPOL state machines */
1847         sm->initialize = TRUE;
1848         eapol_sm_step(sm);
1849         sm->initialize = FALSE;
1850         eapol_sm_step(sm);
1851
1852         sm->timer_tick_enabled = 1;
1853         eloop_register_timeout(1, 0, eapol_port_timers_tick, NULL, sm);
1854
1855         return sm;
1856 }
1857
1858
1859 /**
1860  * eapol_sm_deinit - Deinitialize EAPOL state machine
1861  * @sm: Pointer to EAPOL state machine allocated with eapol_sm_init()
1862  *
1863  * Deinitialize and free EAPOL state machine.
1864  */
1865 void eapol_sm_deinit(struct eapol_sm *sm)
1866 {
1867         if (sm == NULL)
1868                 return;
1869         eloop_cancel_timeout(eapol_sm_step_timeout, NULL, sm);
1870         eloop_cancel_timeout(eapol_port_timers_tick, NULL, sm);
1871         eap_peer_sm_deinit(sm->eap);
1872         os_free(sm->last_rx_key);
1873         wpabuf_free(sm->eapReqData);
1874         os_free(sm->ctx);
1875         os_free(sm);
1876 }