contrib/hostapd/wpa.c

   1 /*
   2  * hostapd - IEEE 802.11i-2004 / WPA Authenticator
   3  * Copyright (c) 2004-2007, 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 #ifndef CONFIG_NATIVE_WINDOWS
  18
  19 #include "hostapd.h"
  20 #include "eapol_sm.h"
  21 #include "wpa.h"
  22 #include "wme.h"
  23 #include "sha1.h"
  24 #include "md5.h"
  25 #include "rc4.h"
  26 #include "aes_wrap.h"
  27 #include "crypto.h"
  28 #include "eloop.h"
  29 #include "ieee802_11.h"
  30 #include "pmksa_cache.h"
  31 #include "state_machine.h"
  32
  33 #define STATE_MACHINE_DATA struct wpa_state_machine
  34 #define STATE_MACHINE_DEBUG_PREFIX "WPA"
  35 #define STATE_MACHINE_ADDR sm->addr
  36
  37
  38 #define RSN_NUM_REPLAY_COUNTERS_1 0
  39 #define RSN_NUM_REPLAY_COUNTERS_2 1
  40 #define RSN_NUM_REPLAY_COUNTERS_4 2
  41 #define RSN_NUM_REPLAY_COUNTERS_16 3
  42
  43
  44 struct wpa_group;
  45
  46 struct wpa_stsl_negotiation {
  47         struct wpa_stsl_negotiation *next;
  48         u8 initiator[ETH_ALEN];
  49         u8 peer[ETH_ALEN];
  50 };
  51
  52
  53 struct wpa_state_machine {
  54         struct wpa_authenticator *wpa_auth;
  55         struct wpa_group *group;
  56
  57         u8 addr[ETH_ALEN];
  58
  59         enum {
  60                 WPA_PTK_INITIALIZE, WPA_PTK_DISCONNECT, WPA_PTK_DISCONNECTED,
  61                 WPA_PTK_AUTHENTICATION, WPA_PTK_AUTHENTICATION2,
  62                 WPA_PTK_INITPMK, WPA_PTK_INITPSK, WPA_PTK_PTKSTART,
  63                 WPA_PTK_PTKCALCNEGOTIATING, WPA_PTK_PTKCALCNEGOTIATING2,
  64                 WPA_PTK_PTKINITNEGOTIATING, WPA_PTK_PTKINITDONE
  65         } wpa_ptk_state;
  66
  67         enum {
  68                 WPA_PTK_GROUP_IDLE = 0,
  69                 WPA_PTK_GROUP_REKEYNEGOTIATING,
  70                 WPA_PTK_GROUP_REKEYESTABLISHED,
  71                 WPA_PTK_GROUP_KEYERROR
  72         } wpa_ptk_group_state;
  73
  74         Boolean Init;
  75         Boolean DeauthenticationRequest;
  76         Boolean AuthenticationRequest;
  77         Boolean ReAuthenticationRequest;
  78         Boolean Disconnect;
  79         int TimeoutCtr;
  80         int GTimeoutCtr;
  81         Boolean TimeoutEvt;
  82         Boolean EAPOLKeyReceived;
  83         Boolean EAPOLKeyPairwise;
  84         Boolean EAPOLKeyRequest;
  85         Boolean MICVerified;
  86         Boolean GUpdateStationKeys;
  87         u8 ANonce[WPA_NONCE_LEN];
  88         u8 SNonce[WPA_NONCE_LEN];
  89         u8 PMK[WPA_PMK_LEN];
  90         struct wpa_ptk PTK;
  91         Boolean PTK_valid;
  92         Boolean pairwise_set;
  93         int keycount;
  94         Boolean Pair;
  95         u8 key_replay_counter[WPA_REPLAY_COUNTER_LEN];
  96         Boolean key_replay_counter_valid;
  97         Boolean PInitAKeys; /* WPA only, not in IEEE 802.11i */
  98         Boolean PTKRequest; /* not in IEEE 802.11i state machine */
  99         Boolean has_GTK;
 100
 101         u8 *last_rx_eapol_key; /* starting from IEEE 802.1X header */
 102         size_t last_rx_eapol_key_len;
 103
 104         unsigned int changed:1;
 105         unsigned int in_step_loop:1;
 106         unsigned int pending_deinit:1;
 107         unsigned int started:1;
 108         unsigned int sta_counted:1;
 109         unsigned int mgmt_frame_prot:1;
 110
 111         u8 req_replay_counter[WPA_REPLAY_COUNTER_LEN];
 112         int req_replay_counter_used;
 113
 114         u8 *wpa_ie;
 115         size_t wpa_ie_len;
 116
 117         enum {
 118                 WPA_VERSION_NO_WPA = 0 /* WPA not used */,
 119                 WPA_VERSION_WPA = 1 /* WPA / IEEE 802.11i/D3.0 */,
 120                 WPA_VERSION_WPA2 = 2 /* WPA2 / IEEE 802.11i */
 121         } wpa;
 122         int pairwise; /* Pairwise cipher suite, WPA_CIPHER_* */
 123         int wpa_key_mgmt; /* the selected WPA_KEY_MGMT_* */
 124         struct rsn_pmksa_cache_entry *pmksa;
 125
 126         u32 dot11RSNAStatsTKIPLocalMICFailures;
 127         u32 dot11RSNAStatsTKIPRemoteMICFailures;
 128 };
 129
 130
 131 /* per group key state machine data */
 132 struct wpa_group {
 133         struct wpa_group *next;
 134         int vlan_id;
 135
 136         Boolean GInit;
 137         int GNoStations;
 138         int GKeyDoneStations;
 139         Boolean GTKReKey;
 140         int GTK_len;
 141         int GN, GM;
 142         Boolean GTKAuthenticator;
 143         u8 Counter[WPA_NONCE_LEN];
 144
 145         enum {
 146                 WPA_GROUP_GTK_INIT = 0,
 147                 WPA_GROUP_SETKEYS, WPA_GROUP_SETKEYSDONE
 148         } wpa_group_state;
 149
 150         u8 GMK[WPA_GMK_LEN];
 151         u8 GTK[2][WPA_GTK_MAX_LEN];
 152         u8 GNonce[WPA_NONCE_LEN];
 153         Boolean changed;
 154 #ifdef CONFIG_IEEE80211W
 155         u8 DGTK[WPA_DGTK_LEN];
 156         u8 IGTK[2][WPA_IGTK_LEN];
 157 #endif /* CONFIG_IEEE80211W */
 158 };
 159
 160
 161 /* per authenticator data */
 162 struct wpa_authenticator {
 163         struct wpa_group *group;
 164
 165         unsigned int dot11RSNAStatsTKIPRemoteMICFailures;
 166         u8 dot11RSNAAuthenticationSuiteSelected[4];
 167         u8 dot11RSNAPairwiseCipherSelected[4];
 168         u8 dot11RSNAGroupCipherSelected[4];
 169         u8 dot11RSNAPMKIDUsed[PMKID_LEN];
 170         u8 dot11RSNAAuthenticationSuiteRequested[4]; /* FIX: update */
 171         u8 dot11RSNAPairwiseCipherRequested[4]; /* FIX: update */
 172         u8 dot11RSNAGroupCipherRequested[4]; /* FIX: update */
 173         unsigned int dot11RSNATKIPCounterMeasuresInvoked;
 174         unsigned int dot11RSNA4WayHandshakeFailures;
 175
 176         struct wpa_stsl_negotiation *stsl_negotiations;
 177
 178         struct wpa_auth_config conf;
 179         struct wpa_auth_callbacks cb;
 180
 181         u8 *wpa_ie;
 182         size_t wpa_ie_len;
 183
 184         u8 addr[ETH_ALEN];
 185
 186         struct rsn_pmksa_cache *pmksa;
 187 };
 188
 189
 190 static void wpa_send_eapol_timeout(void *eloop_ctx, void *timeout_ctx);
 191 static void wpa_sm_step(struct wpa_state_machine *sm);
 192 static int wpa_verify_key_mic(struct wpa_ptk *PTK, u8 *data, size_t data_len);
 193 static void wpa_sm_call_step(void *eloop_ctx, void *timeout_ctx);
 194 static void wpa_group_sm_step(struct wpa_authenticator *wpa_auth,
 195                               struct wpa_group *group);
 196 static int wpa_stsl_remove(struct wpa_authenticator *wpa_auth,
 197                            struct wpa_stsl_negotiation *neg);
 198 static void __wpa_send_eapol(struct wpa_authenticator *wpa_auth,
 199                              struct wpa_state_machine *sm, int key_info,
 200                              const u8 *key_rsc, const u8 *nonce,
 201                              const u8 *kde, size_t kde_len,
 202                              int keyidx, int encr, int force_version);
 203
 204 /* Default timeouts are 100 ms, but this seems to be a bit too fast for most
 205  * WPA Supplicants, so use a bit longer timeout. */
 206 static const u32 dot11RSNAConfigGroupUpdateTimeOut = 1000; /* ms */
 207 static const u32 dot11RSNAConfigGroupUpdateCount = 3;
 208 static const u32 dot11RSNAConfigPairwiseUpdateTimeOut = 1000; /* ms */
 209 static const u32 dot11RSNAConfigPairwiseUpdateCount = 3;
 210
 211 /* TODO: make these configurable */
 212 static const int dot11RSNAConfigPMKLifetime = 43200;
 213 static const int dot11RSNAConfigPMKReauthThreshold = 70;
 214 static const int dot11RSNAConfigSATimeout = 60;
 215
 216
 217 static const int WPA_SELECTOR_LEN = 4;
 218 static const u8 WPA_OUI_TYPE[] = { 0x00, 0x50, 0xf2, 1 };
 219 static const u16 WPA_VERSION = 1;
 220 static const u8 WPA_AUTH_KEY_MGMT_UNSPEC_802_1X[] = { 0x00, 0x50, 0xf2, 1 };
 221 static const u8 WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X[] = { 0x00, 0x50, 0xf2, 2 };
 222 static const u8 WPA_CIPHER_SUITE_NONE[] = { 0x00, 0x50, 0xf2, 0 };
 223 static const u8 WPA_CIPHER_SUITE_WEP40[] = { 0x00, 0x50, 0xf2, 1 };
 224 static const u8 WPA_CIPHER_SUITE_TKIP[] = { 0x00, 0x50, 0xf2, 2 };
 225 static const u8 WPA_CIPHER_SUITE_WRAP[] = { 0x00, 0x50, 0xf2, 3 };
 226 static const u8 WPA_CIPHER_SUITE_CCMP[] = { 0x00, 0x50, 0xf2, 4 };
 227 static const u8 WPA_CIPHER_SUITE_WEP104[] = { 0x00, 0x50, 0xf2, 5 };
 228 #ifdef CONFIG_IEEE80211W
 229 static const u8 RSN_CIPHER_SUITE_AES_128_CMAC[] = { 0x00, 0x0f, 0xac, 6 };
 230 #endif /* CONFIG_IEEE80211W */
 231
 232 static const int RSN_SELECTOR_LEN = 4;
 233 static const u16 RSN_VERSION = 1;
 234 static const u8 RSN_AUTH_KEY_MGMT_UNSPEC_802_1X[] = { 0x00, 0x0f, 0xac, 1 };
 235 static const u8 RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X[] = { 0x00, 0x0f, 0xac, 2 };
 236 static const u8 RSN_CIPHER_SUITE_NONE[] = { 0x00, 0x0f, 0xac, 0 };
 237 static const u8 RSN_CIPHER_SUITE_WEP40[] = { 0x00, 0x0f, 0xac, 1 };
 238 static const u8 RSN_CIPHER_SUITE_TKIP[] = { 0x00, 0x0f, 0xac, 2 };
 239 static const u8 RSN_CIPHER_SUITE_WRAP[] = { 0x00, 0x0f, 0xac, 3 };
 240 static const u8 RSN_CIPHER_SUITE_CCMP[] = { 0x00, 0x0f, 0xac, 4 };
 241 static const u8 RSN_CIPHER_SUITE_WEP104[] = { 0x00, 0x0f, 0xac, 5 };
 242
 243 /* EAPOL-Key Key Data Encapsulation
 244  * GroupKey and PeerKey require encryption, otherwise, encryption is optional.
 245  */
 246 static const u8 RSN_KEY_DATA_GROUPKEY[] = { 0x00, 0x0f, 0xac, 1 };
 247 #if 0
 248 static const u8 RSN_KEY_DATA_STAKEY[] = { 0x00, 0x0f, 0xac, 2 };
 249 #endif
 250 static const u8 RSN_KEY_DATA_MAC_ADDR[] = { 0x00, 0x0f, 0xac, 3 };
 251 static const u8 RSN_KEY_DATA_PMKID[] = { 0x00, 0x0f, 0xac, 4 };
 252 #ifdef CONFIG_PEERKEY
 253 static const u8 RSN_KEY_DATA_SMK[] = { 0x00, 0x0f, 0xac, 5 };
 254 static const u8 RSN_KEY_DATA_NONCE[] = { 0x00, 0x0f, 0xac, 6 };
 255 static const u8 RSN_KEY_DATA_LIFETIME[] = { 0x00, 0x0f, 0xac, 7 };
 256 static const u8 RSN_KEY_DATA_ERROR[] = { 0x00, 0x0f, 0xac, 8 };
 257 #endif /* CONFIG_PEERKEY */
 258 #ifdef CONFIG_IEEE80211W
 259 /* FIX: IEEE 802.11w/D1.0 is using subtypes 5 and 6 for these, but they were
 260  * already taken by 802.11ma (PeerKey). Need to update the values here once
 261  * IEEE 802.11w fixes these. */
 262 static const u8 RSN_KEY_DATA_DHV[] = { 0x00, 0x0f, 0xac, 9 };
 263 static const u8 RSN_KEY_DATA_IGTK[] = { 0x00, 0x0f, 0xac, 10 };
 264 #endif /* CONFIG_IEEE80211W */
 265
 266 #ifdef CONFIG_PEERKEY
 267 enum {
 268         STK_MUI_4WAY_STA_AP = 1,
 269         STK_MUI_4WAY_STAT_STA = 2,
 270         STK_MUI_GTK = 3,
 271         STK_MUI_SMK = 4
 272 };
 273
 274 enum {
 275         STK_ERR_STA_NR = 1,
 276         STK_ERR_STA_NRSN = 2,
 277         STK_ERR_CPHR_NS = 3,
 278         STK_ERR_NO_STSL = 4
 279 };
 280 #endif /* CONFIG_PEERKEY */
 281
 282 #define GENERIC_INFO_ELEM 0xdd
 283 #define RSN_INFO_ELEM 0x30
 284
 285 #ifdef _MSC_VER
 286 #pragma pack(push, 1)
 287 #endif /* _MSC_VER */
 288
 289 /* WPA IE version 1
 290  * 00-50-f2:1 (OUI:OUI type)
 291  * 0x01 0x00 (version; little endian)
 292  * (all following fields are optional:)
 293  * Group Suite Selector (4 octets) (default: TKIP)
 294  * Pairwise Suite Count (2 octets, little endian) (default: 1)
 295  * Pairwise Suite List (4 * n octets) (default: TKIP)
 296  * Authenticated Key Management Suite Count (2 octets, little endian)
 297  *    (default: 1)
 298  * Authenticated Key Management Suite List (4 * n octets)
 299  *    (default: unspec 802.1X)
 300  * WPA Capabilities (2 octets, little endian) (default: 0)
 301  */
 302
 303 struct wpa_ie_hdr {
 304         u8 elem_id;
 305         u8 len;
 306         u8 oui[3];
 307         u8 oui_type;
 308         u16 version;
 309 } STRUCT_PACKED;
 310
 311
 312 /* RSN IE version 1
 313  * 0x01 0x00 (version; little endian)
 314  * (all following fields are optional:)
 315  * Group Suite Selector (4 octets) (default: CCMP)
 316  * Pairwise Suite Count (2 octets, little endian) (default: 1)
 317  * Pairwise Suite List (4 * n octets) (default: CCMP)
 318  * Authenticated Key Management Suite Count (2 octets, little endian)
 319  *    (default: 1)
 320  * Authenticated Key Management Suite List (4 * n octets)
 321  *    (default: unspec 802.1X)
 322  * RSN Capabilities (2 octets, little endian) (default: 0)
 323  * PMKID Count (2 octets) (default: 0)
 324  * PMKID List (16 * n octets)
 325  * Management Group Cipher Suite (4 octets) (default: AES-128-CMAC)
 326  */
 327
 328 struct rsn_ie_hdr {
 329         u8 elem_id; /* WLAN_EID_RSN */
 330         u8 len;
 331         u16 version;
 332 } STRUCT_PACKED;
 333
 334
 335 struct rsn_error_kde {
 336         u16 mui;
 337         u16 error_type;
 338 } STRUCT_PACKED;
 339
 340
 341 #ifdef CONFIG_IEEE80211W
 342 struct wpa_dhv_kde {
 343         u8 dhv[WPA_DHV_LEN];
 344 } STRUCT_PACKED;
 345
 346 struct wpa_igtk_kde {
 347         u8 keyid[2];
 348         u8 pn[6];
 349         u8 igtk[WPA_IGTK_LEN];
 350 } STRUCT_PACKED;
 351 #endif /* CONFIG_IEEE80211W */
 352
 353 #ifdef _MSC_VER
 354 #pragma pack(pop)
 355 #endif /* _MSC_VER */
 356
 357
 358 static inline void wpa_auth_mic_failure_report(
 359         struct wpa_authenticator *wpa_auth, const u8 *addr)
 360 {
 361         if (wpa_auth->cb.mic_failure_report)
 362                 wpa_auth->cb.mic_failure_report(wpa_auth->cb.ctx, addr);
 363 }
 364
 365
 366 static inline void wpa_auth_set_eapol(struct wpa_authenticator *wpa_auth,
 367                                       const u8 *addr, wpa_eapol_variable var,
 368                                       int value)
 369 {
 370         if (wpa_auth->cb.set_eapol)
 371                 wpa_auth->cb.set_eapol(wpa_auth->cb.ctx, addr, var, value);
 372 }
 373
 374
 375 static inline int wpa_auth_get_eapol(struct wpa_authenticator *wpa_auth,
 376                                      const u8 *addr, wpa_eapol_variable var)
 377 {
 378         if (wpa_auth->cb.get_eapol == NULL)
 379                 return -1;
 380         return wpa_auth->cb.get_eapol(wpa_auth->cb.ctx, addr, var);
 381 }
 382
 383
 384 static inline const u8 * wpa_auth_get_psk(struct wpa_authenticator *wpa_auth,
 385                                           const u8 *addr, const u8 *prev_psk)
 386 {
 387         if (wpa_auth->cb.get_psk == NULL)
 388                 return NULL;
 389         return wpa_auth->cb.get_psk(wpa_auth->cb.ctx, addr, prev_psk);
 390 }
 391
 392
 393 static inline int wpa_auth_get_pmk(struct wpa_authenticator *wpa_auth,
 394                                    const u8 *addr, u8 *pmk, size_t *len)
 395 {
 396         if (wpa_auth->cb.get_pmk == NULL)
 397                 return -1;
 398         return wpa_auth->cb.get_pmk(wpa_auth->cb.ctx, addr, pmk, len);
 399 }
 400
 401
 402 static inline int wpa_auth_set_key(struct wpa_authenticator *wpa_auth,
 403                                    int vlan_id,
 404                                    const char *alg, const u8 *addr, int idx,
 405                                    u8 *key, size_t key_len)
 406 {
 407         if (wpa_auth->cb.set_key == NULL)
 408                 return -1;
 409         return wpa_auth->cb.set_key(wpa_auth->cb.ctx, vlan_id, alg, addr, idx,
 410                                     key, key_len);
 411 }
 412
 413
 414 static inline int wpa_auth_get_seqnum(struct wpa_authenticator *wpa_auth,
 415                                       const u8 *addr, int idx, u8 *seq)
 416 {
 417         if (wpa_auth->cb.get_seqnum == NULL)
 418                 return -1;
 419         return wpa_auth->cb.get_seqnum(wpa_auth->cb.ctx, addr, idx, seq);
 420 }
 421
 422
 423 static inline int wpa_auth_get_seqnum_igtk(struct wpa_authenticator *wpa_auth,
 424                                            const u8 *addr, int idx, u8 *seq)
 425 {
 426         if (wpa_auth->cb.get_seqnum_igtk == NULL)
 427                 return -1;
 428         return wpa_auth->cb.get_seqnum_igtk(wpa_auth->cb.ctx, addr, idx, seq);
 429 }
 430
 431
 432 static inline int
 433 wpa_auth_send_eapol(struct wpa_authenticator *wpa_auth, const u8 *addr,
 434                     const u8 *data, size_t data_len, int encrypt)
 435 {
 436         if (wpa_auth->cb.send_eapol == NULL)
 437                 return -1;
 438         return wpa_auth->cb.send_eapol(wpa_auth->cb.ctx, addr, data, data_len,
 439                                        encrypt);
 440 }
 441
 442
 443 static inline int wpa_auth_for_each_sta(struct wpa_authenticator *wpa_auth,
 444                                         int (*cb)(struct wpa_state_machine *sm,
 445                                                   void *ctx),
 446                                         void *cb_ctx)
 447 {
 448         if (wpa_auth->cb.for_each_sta == NULL)
 449                 return 0;
 450         return wpa_auth->cb.for_each_sta(wpa_auth->cb.ctx, cb, cb_ctx);
 451 }
 452
 453
 454 static void wpa_auth_logger(struct wpa_authenticator *wpa_auth, const u8 *addr,
 455                             logger_level level, const char *txt)
 456 {
 457         if (wpa_auth->cb.logger == NULL)
 458                 return;
 459         wpa_auth->cb.logger(wpa_auth->cb.ctx, addr, level, txt);
 460 }
 461
 462
 463 static void wpa_auth_vlogger(struct wpa_authenticator *wpa_auth,
 464                              const u8 *addr, logger_level level,
 465                              const char *fmt, ...)
 466 {
 467         char *format;
 468         int maxlen;
 469         va_list ap;
 470
 471         if (wpa_auth->cb.logger == NULL)
 472                 return;
 473
 474         maxlen = strlen(fmt) + 100;
 475         format = malloc(maxlen);
 476         if (!format)
 477                 return;
 478
 479         va_start(ap, fmt);
 480         vsnprintf(format, maxlen, fmt, ap);
 481         va_end(ap);
 482
 483         wpa_auth_logger(wpa_auth, addr, level, format);
 484
 485         free(format);
 486 }
 487
 488
 489 static int wpa_write_wpa_ie(struct wpa_auth_config *conf, u8 *buf, size_t len)
 490 {
 491         struct wpa_ie_hdr *hdr;
 492         int num_suites;
 493         u8 *pos, *count;
 494
 495         hdr = (struct wpa_ie_hdr *) buf;
 496         hdr->elem_id = WLAN_EID_GENERIC;
 497         memcpy(&hdr->oui, WPA_OUI_TYPE, WPA_SELECTOR_LEN);
 498         hdr->version = host_to_le16(WPA_VERSION);
 499         pos = (u8 *) (hdr + 1);
 500
 501         if (conf->wpa_group == WPA_CIPHER_CCMP) {
 502                 memcpy(pos, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN);
 503         } else if (conf->wpa_group == WPA_CIPHER_TKIP) {
 504                 memcpy(pos, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN);
 505         } else if (conf->wpa_group == WPA_CIPHER_WEP104) {
 506                 memcpy(pos, WPA_CIPHER_SUITE_WEP104, WPA_SELECTOR_LEN);
 507         } else if (conf->wpa_group == WPA_CIPHER_WEP40) {
 508                 memcpy(pos, WPA_CIPHER_SUITE_WEP40, WPA_SELECTOR_LEN);
 509         } else {
 510                 wpa_printf(MSG_DEBUG, "Invalid group cipher (%d).",
 511                            conf->wpa_group);
 512                 return -1;
 513         }
 514         pos += WPA_SELECTOR_LEN;
 515
 516         num_suites = 0;
 517         count = pos;
 518         pos += 2;
 519
 520         if (conf->wpa_pairwise & WPA_CIPHER_CCMP) {
 521                 memcpy(pos, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN);
 522                 pos += WPA_SELECTOR_LEN;
 523                 num_suites++;
 524         }
 525         if (conf->wpa_pairwise & WPA_CIPHER_TKIP) {
 526                 memcpy(pos, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN);
 527                 pos += WPA_SELECTOR_LEN;
 528                 num_suites++;
 529         }
 530         if (conf->wpa_pairwise & WPA_CIPHER_NONE) {
 531                 memcpy(pos, WPA_CIPHER_SUITE_NONE, WPA_SELECTOR_LEN);
 532                 pos += WPA_SELECTOR_LEN;
 533                 num_suites++;
 534         }
 535
 536         if (num_suites == 0) {
 537                 wpa_printf(MSG_DEBUG, "Invalid pairwise cipher (%d).",
 538                            conf->wpa_pairwise);
 539                 return -1;
 540         }
 541         *count++ = num_suites & 0xff;
 542         *count = (num_suites >> 8) & 0xff;
 543
 544         num_suites = 0;
 545         count = pos;
 546         pos += 2;
 547
 548         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
 549                 memcpy(pos, WPA_AUTH_KEY_MGMT_UNSPEC_802_1X, WPA_SELECTOR_LEN);
 550                 pos += WPA_SELECTOR_LEN;
 551                 num_suites++;
 552         }
 553         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
 554                 memcpy(pos, WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X,
 555                        WPA_SELECTOR_LEN);
 556                 pos += WPA_SELECTOR_LEN;
 557                 num_suites++;
 558         }
 559
 560         if (num_suites == 0) {
 561                 wpa_printf(MSG_DEBUG, "Invalid key management type (%d).",
 562                            conf->wpa_key_mgmt);
 563                 return -1;
 564         }
 565         *count++ = num_suites & 0xff;
 566         *count = (num_suites >> 8) & 0xff;
 567
 568         /* WPA Capabilities; use defaults, so no need to include it */
 569
 570         hdr->len = (pos - buf) - 2;
 571
 572         return pos - buf;
 573 }
 574
 575
 576 static int wpa_write_rsn_ie(struct wpa_auth_config *conf, u8 *buf, size_t len)
 577 {
 578         struct rsn_ie_hdr *hdr;
 579         int num_suites;
 580         u8 *pos, *count;
 581         u16 capab;
 582
 583         hdr = (struct rsn_ie_hdr *) buf;
 584         hdr->elem_id = WLAN_EID_RSN;
 585         pos = (u8 *) &hdr->version;
 586         *pos++ = RSN_VERSION & 0xff;
 587         *pos++ = RSN_VERSION >> 8;
 588         pos = (u8 *) (hdr + 1);
 589
 590         if (conf->wpa_group == WPA_CIPHER_CCMP) {
 591                 memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
 592         } else if (conf->wpa_group == WPA_CIPHER_TKIP) {
 593                 memcpy(pos, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN);
 594         } else if (conf->wpa_group == WPA_CIPHER_WEP104) {
 595                 memcpy(pos, RSN_CIPHER_SUITE_WEP104, RSN_SELECTOR_LEN);
 596         } else if (conf->wpa_group == WPA_CIPHER_WEP40) {
 597                 memcpy(pos, RSN_CIPHER_SUITE_WEP40, RSN_SELECTOR_LEN);
 598         } else {
 599                 wpa_printf(MSG_DEBUG, "Invalid group cipher (%d).",
 600                            conf->wpa_group);
 601                 return -1;
 602         }
 603         pos += RSN_SELECTOR_LEN;
 604
 605         num_suites = 0;
 606         count = pos;
 607         pos += 2;
 608
 609         if (conf->wpa_pairwise & WPA_CIPHER_CCMP) {
 610                 memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
 611                 pos += RSN_SELECTOR_LEN;
 612                 num_suites++;
 613         }
 614         if (conf->wpa_pairwise & WPA_CIPHER_TKIP) {
 615                 memcpy(pos, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN);
 616                 pos += RSN_SELECTOR_LEN;
 617                 num_suites++;
 618         }
 619         if (conf->wpa_pairwise & WPA_CIPHER_NONE) {
 620                 memcpy(pos, RSN_CIPHER_SUITE_NONE, RSN_SELECTOR_LEN);
 621                 pos += RSN_SELECTOR_LEN;
 622                 num_suites++;
 623         }
 624
 625         if (num_suites == 0) {
 626                 wpa_printf(MSG_DEBUG, "Invalid pairwise cipher (%d).",
 627                            conf->wpa_pairwise);
 628                 return -1;
 629         }
 630         *count++ = num_suites & 0xff;
 631         *count = (num_suites >> 8) & 0xff;
 632
 633         num_suites = 0;
 634         count = pos;
 635         pos += 2;
 636
 637         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
 638                 memcpy(pos, RSN_AUTH_KEY_MGMT_UNSPEC_802_1X, RSN_SELECTOR_LEN);
 639                 pos += RSN_SELECTOR_LEN;
 640                 num_suites++;
 641         }
 642         if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
 643                 memcpy(pos, RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X,
 644                        RSN_SELECTOR_LEN);
 645                 pos += RSN_SELECTOR_LEN;
 646                 num_suites++;
 647         }
 648
 649         if (num_suites == 0) {
 650                 wpa_printf(MSG_DEBUG, "Invalid key management type (%d).",
 651                            conf->wpa_key_mgmt);
 652                 return -1;
 653         }
 654         *count++ = num_suites & 0xff;
 655         *count = (num_suites >> 8) & 0xff;
 656
 657         /* RSN Capabilities */
 658         capab = 0;
 659         if (conf->rsn_preauth)
 660                 capab |= WPA_CAPABILITY_PREAUTH;
 661         if (conf->peerkey)
 662                 capab |= WPA_CAPABILITY_PEERKEY_ENABLED;
 663         if (conf->wme_enabled) {
 664                 /* 4 PTKSA replay counters when using WME */
 665                 capab |= (RSN_NUM_REPLAY_COUNTERS_16 << 2);
 666         }
 667 #ifdef CONFIG_IEEE80211W
 668         if (conf->ieee80211w != WPA_NO_IEEE80211W)
 669                 capab |= WPA_CAPABILITY_MGMT_FRAME_PROTECTION;
 670 #endif /* CONFIG_IEEE80211W */
 671         *pos++ = capab & 0xff;
 672         *pos++ = capab >> 8;
 673
 674 #ifdef CONFIG_IEEE80211W
 675         if (conf->ieee80211w != WPA_NO_IEEE80211W) {
 676                 if (pos + 2 + 4 > buf + len)
 677                         return -1;
 678                 /* PMKID Count */
 679                 WPA_PUT_LE16(pos, 0);
 680                 pos += 2;
 681
 682                 /* Management Group Cipher Suite */
 683                 memcpy(pos, RSN_CIPHER_SUITE_AES_128_CMAC, RSN_SELECTOR_LEN);
 684                 pos += RSN_SELECTOR_LEN;
 685         }
 686 #endif /* CONFIG_IEEE80211W */
 687
 688         hdr->len = (pos - buf) - 2;
 689
 690         return pos - buf;
 691 }
 692
 693
 694 static int wpa_gen_wpa_ie(struct wpa_authenticator *wpa_auth)
 695 {
 696         u8 *pos, buf[100];
 697         int res;
 698
 699         pos = buf;
 700
 701         if (wpa_auth->conf.wpa & HOSTAPD_WPA_VERSION_WPA2) {
 702                 res = wpa_write_rsn_ie(&wpa_auth->conf,
 703                                        pos, buf + sizeof(buf) - pos);
 704                 if (res < 0)
 705                         return res;
 706                 pos += res;
 707         }
 708         if (wpa_auth->conf.wpa & HOSTAPD_WPA_VERSION_WPA) {
 709                 res = wpa_write_wpa_ie(&wpa_auth->conf,
 710                                        pos, buf + sizeof(buf) - pos);
 711                 if (res < 0)
 712                         return res;
 713                 pos += res;
 714         }
 715
 716         free(wpa_auth->wpa_ie);
 717         wpa_auth->wpa_ie = malloc(pos - buf);
 718         if (wpa_auth->wpa_ie == NULL)
 719                 return -1;
 720         memcpy(wpa_auth->wpa_ie, buf, pos - buf);
 721         wpa_auth->wpa_ie_len = pos - buf;
 722
 723         return 0;
 724 }
 725
 726
 727 static void wpa_sta_disconnect(struct wpa_authenticator *wpa_auth,
 728                                const u8 *addr)
 729 {
 730         if (wpa_auth->cb.disconnect == NULL)
 731                 return;
 732         wpa_auth->cb.disconnect(wpa_auth->cb.ctx, addr,
 733                                 WLAN_REASON_PREV_AUTH_NOT_VALID);
 734 }
 735
 736
 737 static void wpa_rekey_gmk(void *eloop_ctx, void *timeout_ctx)
 738 {
 739         struct wpa_authenticator *wpa_auth = eloop_ctx;
 740
 741         if (hostapd_get_rand(wpa_auth->group->GMK, WPA_GMK_LEN)) {
 742                 wpa_printf(MSG_ERROR, "Failed to get random data for WPA "
 743                            "initialization.");
 744         } else {
 745                 wpa_auth_logger(wpa_auth, NULL, LOGGER_DEBUG, "GMK rekeyd");
 746         }
 747
 748         if (wpa_auth->conf.wpa_gmk_rekey) {
 749                 eloop_register_timeout(wpa_auth->conf.wpa_gmk_rekey, 0,
 750                                        wpa_rekey_gmk, wpa_auth, NULL);
 751         }
 752 }
 753
 754
 755 static void wpa_rekey_gtk(void *eloop_ctx, void *timeout_ctx)
 756 {
 757         struct wpa_authenticator *wpa_auth = eloop_ctx;
 758         struct wpa_group *group;
 759
 760         wpa_auth_logger(wpa_auth, NULL, LOGGER_DEBUG, "rekeying GTK");
 761         for (group = wpa_auth->group; group; group = group->next) {
 762                 group->GTKReKey = TRUE;
 763                 do {
 764                         group->changed = FALSE;
 765                         wpa_group_sm_step(wpa_auth, group);
 766                 } while (group->changed);
 767         }
 768
 769         if (wpa_auth->conf.wpa_group_rekey) {
 770                 eloop_register_timeout(wpa_auth->conf.wpa_group_rekey,
 771                                        0, wpa_rekey_gtk, wpa_auth, NULL);
 772         }
 773 }
 774
 775
 776 static int wpa_auth_pmksa_clear_cb(struct wpa_state_machine *sm, void *ctx)
 777 {
 778         if (sm->pmksa == ctx)
 779                 sm->pmksa = NULL;
 780         return 0;
 781 }
 782
 783
 784 static void wpa_auth_pmksa_free_cb(struct rsn_pmksa_cache_entry *entry,
 785                                    void *ctx)
 786 {
 787         struct wpa_authenticator *wpa_auth = ctx;
 788         wpa_auth_for_each_sta(wpa_auth, wpa_auth_pmksa_clear_cb, entry);
 789 }
 790
 791
 792 static struct wpa_group * wpa_group_init(struct wpa_authenticator *wpa_auth,
 793                                          int vlan_id)
 794 {
 795         struct wpa_group *group;
 796         u8 buf[ETH_ALEN + 8 + sizeof(group)];
 797         u8 rkey[32];
 798
 799         group = wpa_zalloc(sizeof(struct wpa_group));
 800         if (group == NULL)
 801                 return NULL;
 802
 803         group->GTKAuthenticator = TRUE;
 804         group->vlan_id = vlan_id;
 805
 806         switch (wpa_auth->conf.wpa_group) {
 807         case WPA_CIPHER_CCMP:
 808                 group->GTK_len = 16;
 809                 break;
 810         case WPA_CIPHER_TKIP:
 811                 group->GTK_len = 32;
 812                 break;
 813         case WPA_CIPHER_WEP104:
 814                 group->GTK_len = 13;
 815                 break;
 816         case WPA_CIPHER_WEP40:
 817                 group->GTK_len = 5;
 818                 break;
 819         }
 820
 821         /* Counter = PRF-256(Random number, "Init Counter",
 822          *                   Local MAC Address || Time)
 823          */
 824         memcpy(buf, wpa_auth->addr, ETH_ALEN);
 825         wpa_get_ntp_timestamp(buf + ETH_ALEN);
 826         memcpy(buf + ETH_ALEN + 8, &group, sizeof(group));
 827         if (hostapd_get_rand(rkey, sizeof(rkey)) ||
 828             hostapd_get_rand(group->GMK, WPA_GMK_LEN)) {
 829                 wpa_printf(MSG_ERROR, "Failed to get random data for WPA "
 830                            "initialization.");
 831                 free(group);
 832                 return NULL;
 833         }
 834
 835         sha1_prf(rkey, sizeof(rkey), "Init Counter", buf, sizeof(buf),
 836                  group->Counter, WPA_NONCE_LEN);
 837
 838         group->GInit = TRUE;
 839         wpa_group_sm_step(wpa_auth, group);
 840         group->GInit = FALSE;
 841         wpa_group_sm_step(wpa_auth, group);
 842
 843         return group;
 844 }
 845
 846
 847 /**
 848  * wpa_init - Initialize WPA authenticator
 849  * @addr: Authenticator address
 850  * @conf: Configuration for WPA authenticator
 851  * Returns: Pointer to WPA authenticator data or %NULL on failure
 852  */
 853 struct wpa_authenticator * wpa_init(const u8 *addr,
 854                                     struct wpa_auth_config *conf,
 855                                     struct wpa_auth_callbacks *cb)
 856 {
 857         struct wpa_authenticator *wpa_auth;
 858
 859         wpa_auth = wpa_zalloc(sizeof(struct wpa_authenticator));
 860         if (wpa_auth == NULL)
 861                 return NULL;
 862         memcpy(wpa_auth->addr, addr, ETH_ALEN);
 863         memcpy(&wpa_auth->conf, conf, sizeof(*conf));
 864         memcpy(&wpa_auth->cb, cb, sizeof(*cb));
 865
 866         if (wpa_gen_wpa_ie(wpa_auth)) {
 867                 wpa_printf(MSG_ERROR, "Could not generate WPA IE.");
 868                 free(wpa_auth);
 869                 return NULL;
 870         }
 871
 872         wpa_auth->group = wpa_group_init(wpa_auth, 0);
 873         if (wpa_auth->group == NULL) {
 874                 free(wpa_auth->wpa_ie);
 875                 free(wpa_auth);
 876                 return NULL;
 877         }
 878
 879         wpa_auth->pmksa = pmksa_cache_init(wpa_auth_pmksa_free_cb, wpa_auth);
 880         if (wpa_auth->pmksa == NULL) {
 881                 wpa_printf(MSG_ERROR, "PMKSA cache initialization failed.");
 882                 free(wpa_auth->wpa_ie);
 883                 free(wpa_auth);
 884                 return NULL;
 885         }
 886
 887         if (wpa_auth->conf.wpa_gmk_rekey) {
 888                 eloop_register_timeout(wpa_auth->conf.wpa_gmk_rekey, 0,
 889                                        wpa_rekey_gmk, wpa_auth, NULL);
 890         }
 891
 892         if (wpa_auth->conf.wpa_group_rekey) {
 893                 eloop_register_timeout(wpa_auth->conf.wpa_group_rekey, 0,
 894                                        wpa_rekey_gtk, wpa_auth, NULL);
 895         }
 896
 897         return wpa_auth;
 898 }
 899
 900
 901 /**
 902  * wpa_deinit - Deinitialize WPA authenticator
 903  * @wpa_auth: Pointer to WPA authenticator data from wpa_init()
 904  */
 905 void wpa_deinit(struct wpa_authenticator *wpa_auth)
 906 {
 907         struct wpa_group *group, *prev;
 908
 909         eloop_cancel_timeout(wpa_rekey_gmk, wpa_auth, NULL);
 910         eloop_cancel_timeout(wpa_rekey_gtk, wpa_auth, NULL);
 911
 912         while (wpa_auth->stsl_negotiations)
 913                 wpa_stsl_remove(wpa_auth, wpa_auth->stsl_negotiations);
 914
 915         pmksa_cache_deinit(wpa_auth->pmksa);
 916
 917         free(wpa_auth->wpa_ie);
 918
 919         group = wpa_auth->group;
 920         while (group) {
 921                 prev = group;
 922                 group = group->next;
 923                 free(prev);
 924         }
 925
 926         free(wpa_auth);
 927 }
 928
 929
 930 /**
 931  * wpa_reconfig - Update WPA authenticator configuration
 932  * @wpa_auth: Pointer to WPA authenticator data from wpa_init()
 933  * @conf: Configuration for WPA authenticator
 934  */
 935 int wpa_reconfig(struct wpa_authenticator *wpa_auth,
 936                  struct wpa_auth_config *conf)
 937 {
 938         if (wpa_auth == NULL)
 939                 return 0;
 940
 941         memcpy(&wpa_auth->conf, conf, sizeof(*conf));
 942         /*
 943          * TODO:
 944          * Disassociate stations if configuration changed
 945          * Update WPA/RSN IE
 946          */
 947         return 0;
 948 }
 949
 950
 951 static int wpa_selector_to_bitfield(u8 *s)
 952 {
 953         if (memcmp(s, WPA_CIPHER_SUITE_NONE, WPA_SELECTOR_LEN) == 0)
 954                 return WPA_CIPHER_NONE;
 955         if (memcmp(s, WPA_CIPHER_SUITE_WEP40, WPA_SELECTOR_LEN) == 0)
 956                 return WPA_CIPHER_WEP40;
 957         if (memcmp(s, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN) == 0)
 958                 return WPA_CIPHER_TKIP;
 959         if (memcmp(s, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN) == 0)
 960                 return WPA_CIPHER_CCMP;
 961         if (memcmp(s, WPA_CIPHER_SUITE_WEP104, WPA_SELECTOR_LEN) == 0)
 962                 return WPA_CIPHER_WEP104;
 963         return 0;
 964 }
 965
 966
 967 static int wpa_key_mgmt_to_bitfield(u8 *s)
 968 {
 969         if (memcmp(s, WPA_AUTH_KEY_MGMT_UNSPEC_802_1X, WPA_SELECTOR_LEN) == 0)
 970                 return WPA_KEY_MGMT_IEEE8021X;
 971         if (memcmp(s, WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X, WPA_SELECTOR_LEN) ==
 972             0)
 973                 return WPA_KEY_MGMT_PSK;
 974         return 0;
 975 }
 976
 977
 978 static int rsn_selector_to_bitfield(u8 *s)
 979 {
 980         if (memcmp(s, RSN_CIPHER_SUITE_NONE, RSN_SELECTOR_LEN) == 0)
 981                 return WPA_CIPHER_NONE;
 982         if (memcmp(s, RSN_CIPHER_SUITE_WEP40, RSN_SELECTOR_LEN) == 0)
 983                 return WPA_CIPHER_WEP40;
 984         if (memcmp(s, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN) == 0)
 985                 return WPA_CIPHER_TKIP;
 986         if (memcmp(s, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN) == 0)
 987                 return WPA_CIPHER_CCMP;
 988         if (memcmp(s, RSN_CIPHER_SUITE_WEP104, RSN_SELECTOR_LEN) == 0)
 989                 return WPA_CIPHER_WEP104;
 990 #ifdef CONFIG_IEEE80211W
 991         if (memcmp(s, RSN_CIPHER_SUITE_AES_128_CMAC, RSN_SELECTOR_LEN) == 0)
 992                 return WPA_CIPHER_AES_128_CMAC;
 993 #endif /* CONFIG_IEEE80211W */
 994         return 0;
 995 }
 996
 997
 998 static int rsn_key_mgmt_to_bitfield(u8 *s)
 999 {
1000         if (memcmp(s, RSN_AUTH_KEY_MGMT_UNSPEC_802_1X, RSN_SELECTOR_LEN) == 0)
1001                 return WPA_KEY_MGMT_IEEE8021X;
1002         if (memcmp(s, RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X, RSN_SELECTOR_LEN) ==
1003             0)
1004                 return WPA_KEY_MGMT_PSK;
1005         return 0;
1006 }
1007
1008
1009 static u8 * wpa_add_kde(u8 *pos, const u8 *kde, const u8 *data,
1010                         size_t data_len, const u8 *data2, size_t data2_len)
1011 {
1012         *pos++ = GENERIC_INFO_ELEM;
1013         *pos++ = RSN_SELECTOR_LEN + data_len + data2_len;
1014         memcpy(pos, kde, RSN_SELECTOR_LEN);
1015         pos += RSN_SELECTOR_LEN;
1016         memcpy(pos, data, data_len);
1017         pos += data_len;
1018         if (data2) {
1019                 memcpy(pos, data2, data2_len);
1020                 pos += data2_len;
1021         }
1022         return pos;
1023 }
1024
1025
1026 struct wpa_ie_data {
1027         int pairwise_cipher;
1028         int group_cipher;
1029         int key_mgmt;
1030         int capabilities;
1031         size_t num_pmkid;
1032         u8 *pmkid;
1033         int mgmt_group_cipher;
1034 };
1035
1036
1037 static int wpa_parse_wpa_ie_wpa(const u8 *wpa_ie, size_t wpa_ie_len,
1038                                 struct wpa_ie_data *data)
1039 {
1040         struct wpa_ie_hdr *hdr;
1041         u8 *pos;
1042         int left;
1043         int i, count;
1044
1045         memset(data, 0, sizeof(*data));
1046         data->pairwise_cipher = WPA_CIPHER_TKIP;
1047         data->group_cipher = WPA_CIPHER_TKIP;
1048         data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1049         data->mgmt_group_cipher = 0;
1050
1051         if (wpa_ie_len < sizeof(struct wpa_ie_hdr))
1052                 return -1;
1053
1054         hdr = (struct wpa_ie_hdr *) wpa_ie;
1055
1056         if (hdr->elem_id != WLAN_EID_GENERIC ||
1057             hdr->len != wpa_ie_len - 2 ||
1058             memcmp(&hdr->oui, WPA_OUI_TYPE, WPA_SELECTOR_LEN) != 0 ||
1059             le_to_host16(hdr->version) != WPA_VERSION) {
1060                 return -2;
1061         }
1062
1063         pos = (u8 *) (hdr + 1);
1064         left = wpa_ie_len - sizeof(*hdr);
1065
1066         if (left >= WPA_SELECTOR_LEN) {
1067                 data->group_cipher = wpa_selector_to_bitfield(pos);
1068                 pos += WPA_SELECTOR_LEN;
1069                 left -= WPA_SELECTOR_LEN;
1070         } else if (left > 0)
1071                   return -3;
1072
1073         if (left >= 2) {
1074                 data->pairwise_cipher = 0;
1075                 count = pos[0] | (pos[1] << 8);
1076                 pos += 2;
1077                 left -= 2;
1078                 if (count == 0 || left < count * WPA_SELECTOR_LEN)
1079                         return -4;
1080                 for (i = 0; i < count; i++) {
1081                         data->pairwise_cipher |= wpa_selector_to_bitfield(pos);
1082                         pos += WPA_SELECTOR_LEN;
1083                         left -= WPA_SELECTOR_LEN;
1084                 }
1085         } else if (left == 1)
1086                 return -5;
1087
1088         if (left >= 2) {
1089                 data->key_mgmt = 0;
1090                 count = pos[0] | (pos[1] << 8);
1091                 pos += 2;
1092                 left -= 2;
1093                 if (count == 0 || left < count * WPA_SELECTOR_LEN)
1094                         return -6;
1095                 for (i = 0; i < count; i++) {
1096                         data->key_mgmt |= wpa_key_mgmt_to_bitfield(pos);
1097                         pos += WPA_SELECTOR_LEN;
1098                         left -= WPA_SELECTOR_LEN;
1099                 }
1100         } else if (left == 1)
1101                 return -7;
1102
1103         if (left >= 2) {
1104                 data->capabilities = pos[0] | (pos[1] << 8);
1105                 pos += 2;
1106                 left -= 2;
1107         }
1108
1109         if (left > 0) {
1110                 return -8;
1111         }
1112
1113         return 0;
1114 }
1115
1116
1117 static int wpa_parse_wpa_ie_rsn(const u8 *rsn_ie, size_t rsn_ie_len,
1118                                 struct wpa_ie_data *data)
1119 {
1120         struct rsn_ie_hdr *hdr;
1121         u8 *pos;
1122         int left;
1123         int i, count;
1124
1125         memset(data, 0, sizeof(*data));
1126         data->pairwise_cipher = WPA_CIPHER_CCMP;
1127         data->group_cipher = WPA_CIPHER_CCMP;
1128         data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1129 #ifdef CONFIG_IEEE80211W
1130         data->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1131 #else /* CONFIG_IEEE80211W */
1132         data->mgmt_group_cipher = 0;
1133 #endif /* CONFIG_IEEE80211W */
1134
1135         if (rsn_ie_len < sizeof(struct rsn_ie_hdr))
1136                 return -1;
1137
1138         hdr = (struct rsn_ie_hdr *) rsn_ie;
1139
1140         if (hdr->elem_id != WLAN_EID_RSN ||
1141             hdr->len != rsn_ie_len - 2 ||
1142             le_to_host16(hdr->version) != RSN_VERSION) {
1143                 return -2;
1144         }
1145
1146         pos = (u8 *) (hdr + 1);
1147         left = rsn_ie_len - sizeof(*hdr);
1148
1149         if (left >= RSN_SELECTOR_LEN) {
1150                 data->group_cipher = rsn_selector_to_bitfield(pos);
1151                 pos += RSN_SELECTOR_LEN;
1152                 left -= RSN_SELECTOR_LEN;
1153         } else if (left > 0)
1154                   return -3;
1155
1156         if (left >= 2) {
1157                 data->pairwise_cipher = 0;
1158                 count = pos[0] | (pos[1] << 8);
1159                 pos += 2;
1160                 left -= 2;
1161                 if (count == 0 || left < count * RSN_SELECTOR_LEN)
1162                         return -4;
1163                 for (i = 0; i < count; i++) {
1164                         data->pairwise_cipher |= rsn_selector_to_bitfield(pos);
1165                         pos += RSN_SELECTOR_LEN;
1166                         left -= RSN_SELECTOR_LEN;
1167                 }
1168         } else if (left == 1)
1169                 return -5;
1170
1171         if (left >= 2) {
1172                 data->key_mgmt = 0;
1173                 count = pos[0] | (pos[1] << 8);
1174                 pos += 2;
1175                 left -= 2;
1176                 if (count == 0 || left < count * RSN_SELECTOR_LEN)
1177                         return -6;
1178                 for (i = 0; i < count; i++) {
1179                         data->key_mgmt |= rsn_key_mgmt_to_bitfield(pos);
1180                         pos += RSN_SELECTOR_LEN;
1181                         left -= RSN_SELECTOR_LEN;
1182                 }
1183         } else if (left == 1)
1184                 return -7;
1185
1186         if (left >= 2) {
1187                 data->capabilities = pos[0] | (pos[1] << 8);
1188                 pos += 2;
1189                 left -= 2;
1190         }
1191
1192         if (left >= 2) {
1193                 data->num_pmkid = pos[0] | (pos[1] << 8);
1194                 pos += 2;
1195                 left -= 2;
1196                 if (left < (int) data->num_pmkid * PMKID_LEN) {
1197                         wpa_printf(MSG_DEBUG, "RSN: too short RSN IE for "
1198                                    "PMKIDs (num=%lu, left=%d)",
1199                                    (unsigned long) data->num_pmkid, left);
1200                         return -9;
1201                 }
1202                 data->pmkid = pos;
1203                 pos += data->num_pmkid * PMKID_LEN;
1204                 left -= data->num_pmkid * PMKID_LEN;
1205         }
1206
1207 #ifdef CONFIG_IEEE80211W
1208         if (left >= 4) {
1209                 data->mgmt_group_cipher = rsn_selector_to_bitfield(pos);
1210                 if (data->mgmt_group_cipher != WPA_CIPHER_AES_128_CMAC) {
1211                         wpa_printf(MSG_DEBUG, "RSN: Unsupported management "
1212                                    "group cipher 0x%x",
1213                                    data->mgmt_group_cipher);
1214                         return -10;
1215                 }
1216                 pos += RSN_SELECTOR_LEN;
1217                 left -= RSN_SELECTOR_LEN;
1218         }
1219 #endif /* CONFIG_IEEE80211W */
1220
1221         if (left > 0) {
1222                 return -8;
1223         }
1224
1225         return 0;
1226 }
1227
1228
1229 int wpa_validate_wpa_ie(struct wpa_authenticator *wpa_auth,
1230                         struct wpa_state_machine *sm,
1231                         const u8 *wpa_ie, size_t wpa_ie_len)
1232 {
1233         struct wpa_ie_data data;
1234         int ciphers, key_mgmt, res, version;
1235         const u8 *selector;
1236         size_t i;
1237
1238         if (wpa_auth == NULL || sm == NULL)
1239                 return WPA_NOT_ENABLED;
1240
1241         if (wpa_ie == NULL || wpa_ie_len < 1)
1242                 return WPA_INVALID_IE;
1243
1244         if (wpa_ie[0] == WLAN_EID_RSN)
1245                 version = HOSTAPD_WPA_VERSION_WPA2;
1246         else
1247                 version = HOSTAPD_WPA_VERSION_WPA;
1248
1249         if (version == HOSTAPD_WPA_VERSION_WPA2) {
1250                 res = wpa_parse_wpa_ie_rsn(wpa_ie, wpa_ie_len, &data);
1251
1252                 selector = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
1253                 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X)
1254                         selector = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
1255                 else if (data.key_mgmt & WPA_KEY_MGMT_PSK)
1256                         selector = RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X;
1257                 memcpy(wpa_auth->dot11RSNAAuthenticationSuiteSelected,
1258                        selector, RSN_SELECTOR_LEN);
1259
1260                 selector = RSN_CIPHER_SUITE_CCMP;
1261                 if (data.pairwise_cipher & WPA_CIPHER_CCMP)
1262                         selector = RSN_CIPHER_SUITE_CCMP;
1263                 else if (data.pairwise_cipher & WPA_CIPHER_TKIP)
1264                         selector = RSN_CIPHER_SUITE_TKIP;
1265                 else if (data.pairwise_cipher & WPA_CIPHER_WEP104)
1266                         selector = RSN_CIPHER_SUITE_WEP104;
1267                 else if (data.pairwise_cipher & WPA_CIPHER_WEP40)
1268                         selector = RSN_CIPHER_SUITE_WEP40;
1269                 else if (data.pairwise_cipher & WPA_CIPHER_NONE)
1270                         selector = RSN_CIPHER_SUITE_NONE;
1271                 memcpy(wpa_auth->dot11RSNAPairwiseCipherSelected,
1272                        selector, RSN_SELECTOR_LEN);
1273
1274                 selector = RSN_CIPHER_SUITE_CCMP;
1275                 if (data.group_cipher & WPA_CIPHER_CCMP)
1276                         selector = RSN_CIPHER_SUITE_CCMP;
1277                 else if (data.group_cipher & WPA_CIPHER_TKIP)
1278                         selector = RSN_CIPHER_SUITE_TKIP;
1279                 else if (data.group_cipher & WPA_CIPHER_WEP104)
1280                         selector = RSN_CIPHER_SUITE_WEP104;
1281                 else if (data.group_cipher & WPA_CIPHER_WEP40)
1282                         selector = RSN_CIPHER_SUITE_WEP40;
1283                 else if (data.group_cipher & WPA_CIPHER_NONE)
1284                         selector = RSN_CIPHER_SUITE_NONE;
1285                 memcpy(wpa_auth->dot11RSNAGroupCipherSelected,
1286                        selector, RSN_SELECTOR_LEN);
1287         } else {
1288                 res = wpa_parse_wpa_ie_wpa(wpa_ie, wpa_ie_len, &data);
1289
1290                 selector = WPA_AUTH_KEY_MGMT_UNSPEC_802_1X;
1291                 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X)
1292                         selector = WPA_AUTH_KEY_MGMT_UNSPEC_802_1X;
1293                 else if (data.key_mgmt & WPA_KEY_MGMT_PSK)
1294                         selector = WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X;
1295                 memcpy(wpa_auth->dot11RSNAAuthenticationSuiteSelected,
1296                        selector, WPA_SELECTOR_LEN);
1297
1298                 selector = WPA_CIPHER_SUITE_TKIP;
1299                 if (data.pairwise_cipher & WPA_CIPHER_CCMP)
1300                         selector = WPA_CIPHER_SUITE_CCMP;
1301                 else if (data.pairwise_cipher & WPA_CIPHER_TKIP)
1302                         selector = WPA_CIPHER_SUITE_TKIP;
1303                 else if (data.pairwise_cipher & WPA_CIPHER_WEP104)
1304                         selector = WPA_CIPHER_SUITE_WEP104;
1305                 else if (data.pairwise_cipher & WPA_CIPHER_WEP40)
1306                         selector = WPA_CIPHER_SUITE_WEP40;
1307                 else if (data.pairwise_cipher & WPA_CIPHER_NONE)
1308                         selector = WPA_CIPHER_SUITE_NONE;
1309                 memcpy(wpa_auth->dot11RSNAPairwiseCipherSelected,
1310                        selector, WPA_SELECTOR_LEN);
1311
1312                 selector = WPA_CIPHER_SUITE_TKIP;
1313                 if (data.group_cipher & WPA_CIPHER_CCMP)
1314                         selector = WPA_CIPHER_SUITE_CCMP;
1315                 else if (data.group_cipher & WPA_CIPHER_TKIP)
1316                         selector = WPA_CIPHER_SUITE_TKIP;
1317                 else if (data.group_cipher & WPA_CIPHER_WEP104)
1318                         selector = WPA_CIPHER_SUITE_WEP104;
1319                 else if (data.group_cipher & WPA_CIPHER_WEP40)
1320                         selector = WPA_CIPHER_SUITE_WEP40;
1321                 else if (data.group_cipher & WPA_CIPHER_NONE)
1322                         selector = WPA_CIPHER_SUITE_NONE;
1323                 memcpy(wpa_auth->dot11RSNAGroupCipherSelected,
1324                        selector, WPA_SELECTOR_LEN);
1325         }
1326         if (res) {
1327                 wpa_printf(MSG_DEBUG, "Failed to parse WPA/RSN IE from "
1328                            MACSTR " (res=%d)", MAC2STR(sm->addr), res);
1329                 wpa_hexdump(MSG_DEBUG, "WPA/RSN IE", wpa_ie, wpa_ie_len);
1330                 return WPA_INVALID_IE;
1331         }
1332
1333         if (data.group_cipher != wpa_auth->conf.wpa_group) {
1334                 wpa_printf(MSG_DEBUG, "Invalid WPA group cipher (0x%x) from "
1335                            MACSTR, data.group_cipher, MAC2STR(sm->addr));
1336                 return WPA_INVALID_GROUP;
1337         }
1338
1339         key_mgmt = data.key_mgmt & wpa_auth->conf.wpa_key_mgmt;
1340         if (!key_mgmt) {
1341                 wpa_printf(MSG_DEBUG, "Invalid WPA key mgmt (0x%x) from "
1342                            MACSTR, data.key_mgmt, MAC2STR(sm->addr));
1343                 return WPA_INVALID_AKMP;
1344         }
1345         if (key_mgmt & WPA_KEY_MGMT_IEEE8021X)
1346                 sm->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1347         else
1348                 sm->wpa_key_mgmt = WPA_KEY_MGMT_PSK;
1349
1350         ciphers = data.pairwise_cipher & wpa_auth->conf.wpa_pairwise;
1351         if (!ciphers) {
1352                 wpa_printf(MSG_DEBUG, "Invalid WPA pairwise cipher (0x%x) "
1353                            "from " MACSTR,
1354                            data.pairwise_cipher, MAC2STR(sm->addr));
1355                 return WPA_INVALID_PAIRWISE;
1356         }
1357
1358 #ifdef CONFIG_IEEE80211W
1359         if (wpa_auth->conf.ieee80211w == WPA_IEEE80211W_REQUIRED) {
1360                 if (!(data.capabilities &
1361                       WPA_CAPABILITY_MGMT_FRAME_PROTECTION)) {
1362                         wpa_printf(MSG_DEBUG, "Management frame protection "
1363                                    "required, but client did not enable it");
1364                         return WPA_MGMT_FRAME_PROTECTION_VIOLATION;
1365                 }
1366
1367                 if (ciphers & WPA_CIPHER_TKIP) {
1368                         wpa_printf(MSG_DEBUG, "Management frame protection "
1369                                    "cannot use TKIP");
1370                         return WPA_MGMT_FRAME_PROTECTION_VIOLATION;
1371                 }
1372
1373                 if (data.mgmt_group_cipher != WPA_CIPHER_AES_128_CMAC) {
1374                         wpa_printf(MSG_DEBUG, "Unsupported management group "
1375                                    "cipher %d", data.mgmt_group_cipher);
1376                         return WPA_INVALID_MGMT_GROUP_CIPHER;
1377                 }
1378         }
1379
1380         if (wpa_auth->conf.ieee80211w == WPA_NO_IEEE80211W ||
1381             !(data.capabilities & WPA_CAPABILITY_MGMT_FRAME_PROTECTION))
1382                 sm->mgmt_frame_prot = 0;
1383         else
1384                 sm->mgmt_frame_prot = 1;
1385 #endif /* CONFIG_IEEE80211W */
1386
1387         if (ciphers & WPA_CIPHER_CCMP)
1388                 sm->pairwise = WPA_CIPHER_CCMP;
1389         else
1390                 sm->pairwise = WPA_CIPHER_TKIP;
1391
1392         /* TODO: clear WPA/WPA2 state if STA changes from one to another */
1393         if (wpa_ie[0] == WLAN_EID_RSN)
1394                 sm->wpa = WPA_VERSION_WPA2;
1395         else
1396                 sm->wpa = WPA_VERSION_WPA;
1397
1398         for (i = 0; i < data.num_pmkid; i++) {
1399                 wpa_hexdump(MSG_DEBUG, "RSN IE: STA PMKID",
1400                             &data.pmkid[i * PMKID_LEN], PMKID_LEN);
1401                 sm->pmksa = pmksa_cache_get(wpa_auth->pmksa, sm->addr,
1402                                             &data.pmkid[i * PMKID_LEN]);
1403                 if (sm->pmksa) {
1404                         wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
1405                                          "PMKID found from PMKSA cache "
1406                                          "eap_type=%d vlan_id=%d",
1407                                          sm->pmksa->eap_type_authsrv,
1408                                          sm->pmksa->vlan_id);
1409                         memcpy(wpa_auth->dot11RSNAPMKIDUsed,
1410                                sm->pmksa->pmkid, PMKID_LEN);
1411                         break;
1412                 }
1413         }
1414
1415         if (sm->wpa_ie == NULL || sm->wpa_ie_len < wpa_ie_len) {
1416                 free(sm->wpa_ie);
1417                 sm->wpa_ie = malloc(wpa_ie_len);
1418                 if (sm->wpa_ie == NULL)
1419                         return WPA_ALLOC_FAIL;
1420         }
1421         memcpy(sm->wpa_ie, wpa_ie, wpa_ie_len);
1422         sm->wpa_ie_len = wpa_ie_len;
1423
1424         return WPA_IE_OK;
1425 }
1426
1427
1428 struct wpa_eapol_ie_parse {
1429         const u8 *wpa_ie;
1430         size_t wpa_ie_len;
1431         const u8 *rsn_ie;
1432         size_t rsn_ie_len;
1433         const u8 *pmkid;
1434         const u8 *gtk;
1435         size_t gtk_len;
1436         const u8 *mac_addr;
1437         size_t mac_addr_len;
1438 #ifdef CONFIG_PEERKEY
1439         const u8 *smk;
1440         size_t smk_len;
1441         const u8 *nonce;
1442         size_t nonce_len;
1443         const u8 *lifetime;
1444         size_t lifetime_len;
1445         const u8 *error;
1446         size_t error_len;
1447 #endif /* CONFIG_PEERKEY */
1448 };
1449
1450
1451 /**
1452  * wpa_parse_generic - Parse EAPOL-Key Key Data Generic IEs
1453  * @pos: Pointer to the IE header
1454  * @end: Pointer to the end of the Key Data buffer
1455  * @ie: Pointer to parsed IE data
1456  * Returns: 0 on success, 1 if end mark is found, -1 on failure
1457  */
1458 static int wpa_parse_generic(const u8 *pos, const u8 *end,
1459                              struct wpa_eapol_ie_parse *ie)
1460 {
1461         if (pos[1] == 0)
1462                 return 1;
1463
1464         if (pos[1] >= 6 &&
1465             memcmp(pos + 2, WPA_OUI_TYPE, WPA_SELECTOR_LEN) == 0 &&
1466             pos[2 + WPA_SELECTOR_LEN] == 1 &&
1467             pos[2 + WPA_SELECTOR_LEN + 1] == 0) {
1468                 ie->wpa_ie = pos;
1469                 ie->wpa_ie_len = pos[1] + 2;
1470                 return 0;
1471         }
1472
1473         if (pos + 1 + RSN_SELECTOR_LEN < end &&
1474             pos[1] >= RSN_SELECTOR_LEN + PMKID_LEN &&
1475             memcmp(pos + 2, RSN_KEY_DATA_PMKID, RSN_SELECTOR_LEN) == 0) {
1476                 ie->pmkid = pos + 2 + RSN_SELECTOR_LEN;
1477                 return 0;
1478         }
1479
1480         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1481             memcmp(pos + 2, RSN_KEY_DATA_GROUPKEY, RSN_SELECTOR_LEN) == 0) {
1482                 ie->gtk = pos + 2 + RSN_SELECTOR_LEN;
1483                 ie->gtk_len = pos[1] - RSN_SELECTOR_LEN;
1484                 return 0;
1485         }
1486
1487         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1488             memcmp(pos + 2, RSN_KEY_DATA_MAC_ADDR, RSN_SELECTOR_LEN) == 0) {
1489                 ie->mac_addr = pos + 2 + RSN_SELECTOR_LEN;
1490                 ie->mac_addr_len = pos[1] - RSN_SELECTOR_LEN;
1491                 return 0;
1492         }
1493
1494 #ifdef CONFIG_PEERKEY
1495         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1496             memcmp(pos + 2, RSN_KEY_DATA_SMK, RSN_SELECTOR_LEN) == 0) {
1497                 ie->smk = pos + 2 + RSN_SELECTOR_LEN;
1498                 ie->smk_len = pos[1] - RSN_SELECTOR_LEN;
1499                 return 0;
1500         }
1501
1502         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1503             memcmp(pos + 2, RSN_KEY_DATA_NONCE, RSN_SELECTOR_LEN) == 0) {
1504                 ie->nonce = pos + 2 + RSN_SELECTOR_LEN;
1505                 ie->nonce_len = pos[1] - RSN_SELECTOR_LEN;
1506                 return 0;
1507         }
1508
1509         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1510             memcmp(pos + 2, RSN_KEY_DATA_LIFETIME, RSN_SELECTOR_LEN) == 0) {
1511                 ie->lifetime = pos + 2 + RSN_SELECTOR_LEN;
1512                 ie->lifetime_len = pos[1] - RSN_SELECTOR_LEN;
1513                 return 0;
1514         }
1515
1516         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1517             memcmp(pos + 2, RSN_KEY_DATA_ERROR, RSN_SELECTOR_LEN) == 0) {
1518                 ie->error = pos + 2 + RSN_SELECTOR_LEN;
1519                 ie->error_len = pos[1] - RSN_SELECTOR_LEN;
1520                 return 0;
1521         }
1522 #endif /* CONFIG_PEERKEY */
1523
1524         return 0;
1525 }
1526
1527
1528 /**
1529  * wpa_parse_kde_ies - Parse EAPOL-Key Key Data IEs
1530  * @buf: Pointer to the Key Data buffer
1531  * @len: Key Data Length
1532  * @ie: Pointer to parsed IE data
1533  * Returns: 0 on success, -1 on failure
1534  */
1535 static int wpa_parse_kde_ies(const u8 *buf, size_t len,
1536                              struct wpa_eapol_ie_parse *ie)
1537 {
1538         const u8 *pos, *end;
1539         int ret = 0;
1540
1541         memset(ie, 0, sizeof(*ie));
1542         for (pos = buf, end = pos + len; pos + 1 < end; pos += 2 + pos[1]) {
1543                 if (pos[0] == 0xdd &&
1544                     ((pos == buf + len - 1) || pos[1] == 0)) {
1545                         /* Ignore padding */
1546                         break;
1547                 }
1548                 if (pos + 2 + pos[1] > end) {
1549                         wpa_printf(MSG_DEBUG, "WPA: EAPOL-Key Key Data "
1550                                    "underflow (ie=%d len=%d)", pos[0], pos[1]);
1551                         ret = -1;
1552                         break;
1553                 }
1554                 if (*pos == RSN_INFO_ELEM) {
1555                         ie->rsn_ie = pos;
1556                         ie->rsn_ie_len = pos[1] + 2;
1557                 } else if (*pos == GENERIC_INFO_ELEM) {
1558                         ret = wpa_parse_generic(pos, end, ie);
1559                         if (ret < 0)
1560                                 break;
1561                         if (ret > 0) {
1562                                 ret = 0;
1563                                 break;
1564                         }
1565                 } else {
1566                         wpa_hexdump(MSG_DEBUG, "WPA: Unrecognized EAPOL-Key "
1567                                     "Key Data IE", pos, 2 + pos[1]);
1568                 }
1569         }
1570
1571         return ret;
1572 }
1573
1574
1575 struct wpa_state_machine *
1576 wpa_auth_sta_init(struct wpa_authenticator *wpa_auth, const u8 *addr)
1577 {
1578         struct wpa_state_machine *sm;
1579
1580         sm = wpa_zalloc(sizeof(struct wpa_state_machine));
1581         if (sm == NULL)
1582                 return NULL;
1583         memcpy(sm->addr, addr, ETH_ALEN);
1584
1585         sm->wpa_auth = wpa_auth;
1586         sm->group = wpa_auth->group;
1587
1588         return sm;
1589 }
1590
1591
1592 void wpa_auth_sta_associated(struct wpa_authenticator *wpa_auth,
1593                              struct wpa_state_machine *sm)
1594 {
1595         if (wpa_auth == NULL || !wpa_auth->conf.wpa || sm == NULL)
1596                 return;
1597
1598         if (sm->started) {
1599                 memset(sm->key_replay_counter, 0, WPA_REPLAY_COUNTER_LEN);
1600                 sm->ReAuthenticationRequest = TRUE;
1601                 wpa_sm_step(sm);
1602                 return;
1603         }
1604
1605         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_DEBUG,
1606                         "start authentication");
1607         sm->started = 1;
1608
1609         sm->Init = TRUE;
1610         wpa_sm_step(sm);
1611         sm->Init = FALSE;
1612         sm->AuthenticationRequest = TRUE;
1613         wpa_sm_step(sm);
1614 }
1615
1616
1617 static void wpa_free_sta_sm(struct wpa_state_machine *sm)
1618 {
1619         free(sm->last_rx_eapol_key);
1620         free(sm->wpa_ie);
1621         free(sm);
1622 }
1623
1624
1625 void wpa_auth_sta_deinit(struct wpa_state_machine *sm)
1626 {
1627         if (sm == NULL)
1628                 return;
1629
1630         if (sm->wpa_auth->conf.wpa_strict_rekey && sm->has_GTK) {
1631                 wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
1632                                 "strict rekeying - force GTK rekey since STA "
1633                                 "is leaving");
1634                 eloop_cancel_timeout(wpa_rekey_gtk, sm->wpa_auth, NULL);
1635                 eloop_register_timeout(0, 500000, wpa_rekey_gtk, sm->wpa_auth,
1636                                        NULL);
1637         }
1638
1639         eloop_cancel_timeout(wpa_send_eapol_timeout, sm->wpa_auth, sm);
1640         eloop_cancel_timeout(wpa_sm_call_step, sm, NULL);
1641         if (sm->in_step_loop) {
1642                 /* Must not free state machine while wpa_sm_step() is running.
1643                  * Freeing will be completed in the end of wpa_sm_step(). */
1644                 wpa_printf(MSG_DEBUG, "WPA: Registering pending STA state "
1645                            "machine deinit for " MACSTR, MAC2STR(sm->addr));
1646                 sm->pending_deinit = 1;
1647         } else
1648                 wpa_free_sta_sm(sm);
1649 }
1650
1651
1652 static void wpa_request_new_ptk(struct wpa_state_machine *sm)
1653 {
1654         if (sm == NULL)
1655                 return;
1656
1657         sm->PTKRequest = TRUE;
1658         sm->PTK_valid = 0;
1659 }
1660
1661
1662 #ifdef CONFIG_PEERKEY
1663 static void wpa_stsl_step(void *eloop_ctx, void *timeout_ctx)
1664 {
1665 #if 0
1666         struct wpa_authenticator *wpa_auth = eloop_ctx;
1667         struct wpa_stsl_negotiation *neg = timeout_ctx;
1668 #endif
1669
1670         /* TODO: ? */
1671 }
1672
1673
1674 struct wpa_stsl_search {
1675         const u8 *addr;
1676         struct wpa_state_machine *sm;
1677 };
1678
1679
1680 static int wpa_stsl_select_sta(struct wpa_state_machine *sm, void *ctx)
1681 {
1682         struct wpa_stsl_search *search = ctx;
1683         if (memcmp(search->addr, sm->addr, ETH_ALEN) == 0) {
1684                 search->sm = sm;
1685                 return 1;
1686         }
1687         return 0;
1688 }
1689
1690
1691 static void wpa_smk_send_error(struct wpa_authenticator *wpa_auth,
1692                                struct wpa_state_machine *sm, const u8 *peer,
1693                                u16 mui, u16 error_type)
1694 {
1695         u8 kde[2 + RSN_SELECTOR_LEN + ETH_ALEN +
1696                2 + RSN_SELECTOR_LEN + sizeof(struct rsn_error_kde)];
1697         size_t kde_len;
1698         u8 *pos;
1699         struct rsn_error_kde error;
1700
1701         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_DEBUG,
1702                         "Sending SMK Error");
1703
1704         kde_len = 2 + RSN_SELECTOR_LEN + sizeof(struct rsn_error_kde);
1705         pos = kde;
1706
1707         if (peer) {
1708                 pos = wpa_add_kde(pos, RSN_KEY_DATA_MAC_ADDR, peer, ETH_ALEN,
1709                                   NULL, 0);
1710                 kde_len += 2 + RSN_SELECTOR_LEN + ETH_ALEN;
1711         }
1712
1713         error.mui = host_to_be16(mui);
1714         error.error_type = host_to_be16(error_type);
1715         pos = wpa_add_kde(pos, RSN_KEY_DATA_ERROR,
1716                           (u8 *) &error, sizeof(error), NULL, 0);
1717
1718         __wpa_send_eapol(wpa_auth, sm,
1719                          WPA_KEY_INFO_SECURE | WPA_KEY_INFO_MIC |
1720                          WPA_KEY_INFO_SMK_MESSAGE | WPA_KEY_INFO_ERROR,
1721                          NULL, NULL, kde, kde_len, 0, 0, 0);
1722 }
1723
1724
1725 static void wpa_smk_m1(struct wpa_authenticator *wpa_auth,
1726                        struct wpa_state_machine *sm,
1727                        struct wpa_eapol_key *key)
1728 {
1729         struct wpa_eapol_ie_parse kde;
1730         struct wpa_stsl_search search;
1731         u8 *buf, *pos;
1732         size_t buf_len;
1733
1734         if (wpa_parse_kde_ies((const u8 *) (key + 1),
1735                               ntohs(key->key_data_length), &kde) < 0) {
1736                 wpa_printf(MSG_INFO, "RSN: Failed to parse KDEs in SMK M1");
1737                 return;
1738         }
1739
1740         if (kde.rsn_ie == NULL || kde.mac_addr == NULL ||
1741             kde.mac_addr_len < ETH_ALEN) {
1742                 wpa_printf(MSG_INFO, "RSN: No RSN IE or MAC address KDE in "
1743                            "SMK M1");
1744                 return;
1745         }
1746
1747         /* Initiator = sm->addr; Peer = kde.mac_addr */
1748
1749         search.addr = kde.mac_addr;
1750         search.sm = NULL;
1751         if (wpa_auth_for_each_sta(wpa_auth, wpa_stsl_select_sta, &search) ==
1752             0 || search.sm == NULL) {
1753                 wpa_printf(MSG_DEBUG, "RSN: SMK handshake with " MACSTR
1754                            " aborted - STA not associated anymore",
1755                            MAC2STR(kde.mac_addr));
1756                 wpa_smk_send_error(wpa_auth, sm, kde.mac_addr, STK_MUI_SMK,
1757                                    STK_ERR_STA_NR);
1758                 /* FIX: wpa_stsl_remove(wpa_auth, neg); */
1759                 return;
1760         }
1761
1762         buf_len = kde.rsn_ie_len + 2 + RSN_SELECTOR_LEN + ETH_ALEN;
1763         buf = malloc(buf_len);
1764         if (buf == NULL)
1765                 return;
1766         /* Initiator RSN IE */
1767         memcpy(buf, kde.rsn_ie, kde.rsn_ie_len);
1768         pos = buf + kde.rsn_ie_len;
1769         /* Initiator MAC Address */
1770         pos = wpa_add_kde(pos, RSN_KEY_DATA_MAC_ADDR, sm->addr, ETH_ALEN,
1771                           NULL, 0);
1772
1773         /* SMK M2:
1774          * EAPOL-Key(S=1, M=1, A=1, I=0, K=0, SM=1, KeyRSC=0, Nonce=INonce,
1775          *           MIC=MIC, DataKDs=(RSNIE_I, MAC_I KDE)
1776          */
1777
1778         wpa_auth_logger(wpa_auth, search.sm->addr, LOGGER_DEBUG,
1779                         "Sending SMK M2");
1780
1781         __wpa_send_eapol(wpa_auth, search.sm,
1782                          WPA_KEY_INFO_SECURE | WPA_KEY_INFO_MIC |
1783                          WPA_KEY_INFO_ACK | WPA_KEY_INFO_SMK_MESSAGE,
1784                          NULL, key->key_nonce, buf, buf_len, 0, 0, 0);
1785
1786         free(buf);
1787
1788 }
1789
1790
1791 static void wpa_send_smk_m4(struct wpa_authenticator *wpa_auth,
1792                             struct wpa_state_machine *sm,
1793                             struct wpa_eapol_key *key,
1794                             struct wpa_eapol_ie_parse *kde,
1795                             const u8 *smk)
1796 {
1797         u8 *buf, *pos;
1798         size_t buf_len;
1799         u32 lifetime;
1800
1801         /* SMK M4:
1802          * EAPOL-Key(S=1, M=1, A=0, I=1, K=0, SM=1, KeyRSC=0, Nonce=PNonce,
1803          *           MIC=MIC, DataKDs=(MAC_I KDE, INonce KDE, SMK KDE,
1804          *           Lifetime KDE)
1805          */
1806
1807         buf_len = 2 + RSN_SELECTOR_LEN + ETH_ALEN +
1808                 2 + RSN_SELECTOR_LEN + WPA_NONCE_LEN +
1809                 2 + RSN_SELECTOR_LEN + WPA_PMK_LEN + WPA_NONCE_LEN +
1810                 2 + RSN_SELECTOR_LEN + sizeof(lifetime);
1811         pos = buf = malloc(buf_len);
1812         if (buf == NULL)
1813                 return;
1814
1815         /* Initiator MAC Address */
1816         pos = wpa_add_kde(pos, RSN_KEY_DATA_MAC_ADDR, kde->mac_addr, ETH_ALEN,
1817                           NULL, 0);
1818
1819         /* Initiator Nonce */
1820         pos = wpa_add_kde(pos, RSN_KEY_DATA_NONCE, kde->nonce, WPA_NONCE_LEN,
1821                           NULL, 0);
1822
1823         /* SMK with PNonce */
1824         pos = wpa_add_kde(pos, RSN_KEY_DATA_SMK, smk, WPA_PMK_LEN,
1825                           key->key_nonce, WPA_NONCE_LEN);
1826
1827         /* Lifetime */
1828         lifetime = htonl(43200); /* dot11RSNAConfigSMKLifetime */
1829         pos = wpa_add_kde(pos, RSN_KEY_DATA_LIFETIME,
1830                           (u8 *) &lifetime, sizeof(lifetime), NULL, 0);
1831
1832         wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
1833                         "Sending SMK M4");
1834
1835         __wpa_send_eapol(wpa_auth, sm,
1836                          WPA_KEY_INFO_SECURE | WPA_KEY_INFO_MIC |
1837                          WPA_KEY_INFO_INSTALL | WPA_KEY_INFO_SMK_MESSAGE,
1838                          NULL, key->key_nonce, buf, buf_len, 0, 1, 0);
1839
1840         free(buf);
1841 }
1842
1843
1844 static void wpa_send_smk_m5(struct wpa_authenticator *wpa_auth,
1845                             struct wpa_state_machine *sm,
1846                             struct wpa_eapol_key *key,
1847                             struct wpa_eapol_ie_parse *kde,
1848                             const u8 *smk, const u8 *peer)
1849 {
1850         u8 *buf, *pos;
1851         size_t buf_len;
1852         u32 lifetime;
1853
1854         /* SMK M5:
1855          * EAPOL-Key(S=1, M=1, A=0, I=0, K=0, SM=1, KeyRSC=0, Nonce=INonce,
1856          *           MIC=MIC, DataKDs=(RSNIE_P, MAC_P KDE, PNonce, SMK KDE,
1857          *                             Lifetime KDE))
1858          */
1859
1860         buf_len = kde->rsn_ie_len +
1861                 2 + RSN_SELECTOR_LEN + ETH_ALEN +
1862                 2 + RSN_SELECTOR_LEN + WPA_NONCE_LEN +
1863                 2 + RSN_SELECTOR_LEN + WPA_PMK_LEN + WPA_NONCE_LEN +
1864                 2 + RSN_SELECTOR_LEN + sizeof(lifetime);
1865         pos = buf = malloc(buf_len);
1866         if (buf == NULL)
1867                 return;
1868
1869         /* Peer RSN IE */
1870         memcpy(buf, kde->rsn_ie, kde->rsn_ie_len);
1871         pos = buf + kde->rsn_ie_len;
1872
1873         /* Peer MAC Address */
1874         pos = wpa_add_kde(pos, RSN_KEY_DATA_MAC_ADDR, peer, ETH_ALEN, NULL, 0);
1875
1876         /* PNonce */
1877         pos = wpa_add_kde(pos, RSN_KEY_DATA_NONCE, key->key_nonce,
1878                           WPA_NONCE_LEN, NULL, 0);
1879
1880         /* SMK and INonce */
1881         pos = wpa_add_kde(pos, RSN_KEY_DATA_SMK, smk, WPA_PMK_LEN,
1882                           kde->nonce, WPA_NONCE_LEN);
1883
1884         /* Lifetime */
1885         lifetime = htonl(43200); /* dot11RSNAConfigSMKLifetime */
1886         pos = wpa_add_kde(pos, RSN_KEY_DATA_LIFETIME,
1887                           (u8 *) &lifetime, sizeof(lifetime), NULL, 0);
1888
1889         wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
1890                         "Sending SMK M5");
1891
1892         __wpa_send_eapol(wpa_auth, sm,
1893                          WPA_KEY_INFO_SECURE | WPA_KEY_INFO_MIC |
1894                          WPA_KEY_INFO_SMK_MESSAGE,
1895                          NULL, kde->nonce, buf, buf_len, 0, 1, 0);
1896
1897         free(buf);
1898 }
1899
1900
1901 static void wpa_smk_m3(struct wpa_authenticator *wpa_auth,
1902                        struct wpa_state_machine *sm,
1903                        struct wpa_eapol_key *key)
1904 {
1905         struct wpa_eapol_ie_parse kde;
1906         struct wpa_stsl_search search;
1907         u8 smk[32], buf[ETH_ALEN + 8 + 2 * WPA_NONCE_LEN], *pos;
1908
1909         if (wpa_parse_kde_ies((const u8 *) (key + 1),
1910                               ntohs(key->key_data_length), &kde) < 0) {
1911                 wpa_printf(MSG_INFO, "RSN: Failed to parse KDEs in SMK M3");
1912                 return;
1913         }
1914
1915         if (kde.rsn_ie == NULL ||
1916             kde.mac_addr == NULL || kde.mac_addr_len < ETH_ALEN ||
1917             kde.nonce == NULL || kde.nonce_len < WPA_NONCE_LEN) {
1918                 wpa_printf(MSG_INFO, "RSN: No RSN IE, MAC address KDE, or "
1919                            "Nonce KDE in SMK M3");
1920                 return;
1921         }
1922
1923         /* Peer = sm->addr; Initiator = kde.mac_addr;
1924          * Peer Nonce = key->key_nonce; Initiator Nonce = kde.nonce */
1925
1926         search.addr = kde.mac_addr;
1927         search.sm = NULL;
1928         if (wpa_auth_for_each_sta(wpa_auth, wpa_stsl_select_sta, &search) ==
1929             0 || search.sm == NULL) {
1930                 wpa_printf(MSG_DEBUG, "RSN: SMK handshake with " MACSTR
1931                            " aborted - STA not associated anymore",
1932                            MAC2STR(kde.mac_addr));
1933                 wpa_smk_send_error(wpa_auth, sm, kde.mac_addr, STK_MUI_SMK,
1934                                    STK_ERR_STA_NR);
1935                 /* FIX: wpa_stsl_remove(wpa_auth, neg); */
1936                 return;
1937         }
1938
1939         if (hostapd_get_rand(smk, WPA_PMK_LEN)) {
1940                 wpa_printf(MSG_DEBUG, "RSN: Failed to generate SMK");
1941                 return;
1942         }
1943
1944         /* SMK = PRF-256(Random number, "SMK Derivation",
1945          *               AA || Time || INonce || PNonce)
1946          */
1947         memcpy(buf, wpa_auth->addr, ETH_ALEN);
1948         pos = buf + ETH_ALEN;
1949         wpa_get_ntp_timestamp(pos);
1950         pos += 8;
1951         memcpy(pos, kde.nonce, WPA_NONCE_LEN);
1952         pos += WPA_NONCE_LEN;
1953         memcpy(pos, key->key_nonce, WPA_NONCE_LEN);
1954         sha1_prf(smk, WPA_PMK_LEN, "SMK Derivation", buf, sizeof(buf),
1955                  smk, WPA_PMK_LEN);
1956
1957         wpa_hexdump_key(MSG_DEBUG, "RSN: SMK", smk, WPA_PMK_LEN);
1958
1959         wpa_send_smk_m4(wpa_auth, sm, key, &kde, smk);
1960         wpa_send_smk_m5(wpa_auth, search.sm, key, &kde, smk, sm->addr);
1961
1962         /* Authenticator does not need SMK anymore and it is required to forget
1963          * it. */
1964         memset(smk, 0, sizeof(*smk));
1965 }
1966
1967
1968 static void wpa_smk_error(struct wpa_authenticator *wpa_auth,
1969                           struct wpa_state_machine *sm,
1970                           struct wpa_eapol_key *key)
1971 {
1972         struct wpa_eapol_ie_parse kde;
1973         struct wpa_stsl_search search;
1974         struct rsn_error_kde error;
1975         u16 mui, error_type;
1976
1977         if (wpa_parse_kde_ies((const u8 *) (key + 1),
1978                               ntohs(key->key_data_length), &kde) < 0) {
1979                 wpa_printf(MSG_INFO, "RSN: Failed to parse KDEs in SMK Error");
1980                 return;
1981         }
1982
1983         if (kde.mac_addr == NULL || kde.mac_addr_len < ETH_ALEN ||
1984             kde.error == NULL || kde.error_len < sizeof(error)) {
1985                 wpa_printf(MSG_INFO, "RSN: No MAC address or Error KDE in "
1986                            "SMK Error");
1987                 return;
1988         }
1989
1990         search.addr = kde.mac_addr;
1991         search.sm = NULL;
1992         if (wpa_auth_for_each_sta(wpa_auth, wpa_stsl_select_sta, &search) ==
1993             0 || search.sm == NULL) {
1994                 wpa_printf(MSG_DEBUG, "RSN: Peer STA " MACSTR " not "
1995                            "associated for SMK Error message from " MACSTR,
1996                            MAC2STR(kde.mac_addr), MAC2STR(sm->addr));
1997                 return;
1998         }
1999
2000         memcpy(&error, kde.error, sizeof(error));
2001         mui = be_to_host16(error.mui);
2002         error_type = be_to_host16(error.error_type);
2003         wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_INFO,
2004                          "STA reported SMK Error: Peer " MACSTR
2005                          " MUI %d Error Type %d",
2006                          MAC2STR(kde.mac_addr), mui, error_type);
2007
2008         wpa_smk_send_error(wpa_auth, search.sm, sm->addr, mui, error_type);
2009 }
2010 #endif /* CONFIG_PEERKEY */
2011
2012
2013 static int wpa_stsl_remove(struct wpa_authenticator *wpa_auth,
2014                            struct wpa_stsl_negotiation *neg)
2015 {
2016 #ifdef CONFIG_PEERKEY
2017         struct wpa_stsl_negotiation *pos, *prev;
2018
2019         if (wpa_auth == NULL)
2020                 return -1;
2021         pos = wpa_auth->stsl_negotiations;
2022         prev = NULL;
2023         while (pos) {
2024                 if (pos == neg) {
2025                         if (prev)
2026                                 prev->next = pos->next;
2027                         else
2028                                 wpa_auth->stsl_negotiations = pos->next;
2029
2030                         eloop_cancel_timeout(wpa_stsl_step, wpa_auth, pos);
2031                         free(pos);
2032                         return 0;
2033                 }
2034                 prev = pos;
2035                 pos = pos->next;
2036         }
2037 #endif /* CONFIG_PEERKEY */
2038
2039         return -1;
2040 }
2041
2042
2043 void wpa_receive(struct wpa_authenticator *wpa_auth,
2044                  struct wpa_state_machine *sm,
2045                  u8 *data, size_t data_len)
2046 {
2047         struct ieee802_1x_hdr *hdr;
2048         struct wpa_eapol_key *key;
2049         u16 key_info, key_data_length;
2050         enum { PAIRWISE_2, PAIRWISE_4, GROUP_2, REQUEST,
2051                SMK_M1, SMK_M3, SMK_ERROR } msg;
2052         char *msgtxt;
2053         struct wpa_eapol_ie_parse kde;
2054
2055         if (wpa_auth == NULL || !wpa_auth->conf.wpa || sm == NULL)
2056                 return;
2057
2058         if (data_len < sizeof(*hdr) + sizeof(*key))
2059                 return;
2060
2061         hdr = (struct ieee802_1x_hdr *) data;
2062         key = (struct wpa_eapol_key *) (hdr + 1);
2063         key_info = ntohs(key->key_info);
2064         key_data_length = ntohs(key->key_data_length);
2065         if (key_data_length > data_len - sizeof(*hdr) - sizeof(*key)) {
2066                 wpa_printf(MSG_INFO, "WPA: Invalid EAPOL-Key frame - "
2067                            "key_data overflow (%d > %lu)",
2068                            key_data_length,
2069                            (unsigned long) (data_len - sizeof(*hdr) -
2070                                             sizeof(*key)));
2071                 return;
2072         }
2073
2074         /* FIX: verify that the EAPOL-Key frame was encrypted if pairwise keys
2075          * are set */
2076
2077         if ((key_info & (WPA_KEY_INFO_SMK_MESSAGE | WPA_KEY_INFO_REQUEST)) ==
2078             (WPA_KEY_INFO_SMK_MESSAGE | WPA_KEY_INFO_REQUEST)) {
2079                 if (key_info & WPA_KEY_INFO_ERROR) {
2080                         msg = SMK_ERROR;
2081                         msgtxt = "SMK Error";
2082                 } else {
2083                         msg = SMK_M1;
2084                         msgtxt = "SMK M1";
2085                 }
2086         } else if (key_info & WPA_KEY_INFO_SMK_MESSAGE) {
2087                 msg = SMK_M3;
2088                 msgtxt = "SMK M3";
2089         } else if (key_info & WPA_KEY_INFO_REQUEST) {
2090                 msg = REQUEST;
2091                 msgtxt = "Request";
2092         } else if (!(key_info & WPA_KEY_INFO_KEY_TYPE)) {
2093                 msg = GROUP_2;
2094                 msgtxt = "2/2 Group";
2095         } else if (key_data_length == 0) {
2096                 msg = PAIRWISE_4;
2097                 msgtxt = "4/4 Pairwise";
2098         } else {
2099                 msg = PAIRWISE_2;
2100                 msgtxt = "2/4 Pairwise";
2101         }
2102
2103         if (key_info & WPA_KEY_INFO_REQUEST) {
2104                 if (sm->req_replay_counter_used &&
2105                     memcmp(key->replay_counter, sm->req_replay_counter,
2106                            WPA_REPLAY_COUNTER_LEN) <= 0) {
2107                         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_WARNING,
2108                                         "received EAPOL-Key request with "
2109                                         "replayed counter");
2110                         return;
2111                 }
2112         }
2113
2114         if (!(key_info & WPA_KEY_INFO_REQUEST) &&
2115             (!sm->key_replay_counter_valid ||
2116              memcmp(key->replay_counter, sm->key_replay_counter,
2117                     WPA_REPLAY_COUNTER_LEN) != 0)) {
2118                 wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_INFO,
2119                                  "received EAPOL-Key %s with unexpected "
2120                                  "replay counter", msgtxt);
2121                 wpa_hexdump(MSG_DEBUG, "expected replay counter",
2122                             sm->key_replay_counter, WPA_REPLAY_COUNTER_LEN);
2123                 wpa_hexdump(MSG_DEBUG, "received replay counter",
2124                             key->replay_counter, WPA_REPLAY_COUNTER_LEN);
2125                 return;
2126         }
2127
2128         switch (msg) {
2129         case PAIRWISE_2:
2130                 if (sm->wpa_ptk_state != WPA_PTK_PTKSTART &&
2131                     sm->wpa_ptk_state != WPA_PTK_PTKCALCNEGOTIATING) {
2132                         wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_INFO,
2133                                          "received EAPOL-Key msg 2/4 in "
2134                                          "invalid state (%d) - dropped",
2135                                          sm->wpa_ptk_state);
2136                         return;
2137                 }
2138                 if (sm->wpa_ie == NULL ||
2139                     sm->wpa_ie_len != key_data_length ||
2140                     memcmp(sm->wpa_ie, key + 1, key_data_length) != 0) {
2141                         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_INFO,
2142                                         "WPA IE from (Re)AssocReq did not "
2143                                         "match with msg 2/4");
2144                         if (sm->wpa_ie) {
2145                                 wpa_hexdump(MSG_DEBUG, "WPA IE in AssocReq",
2146                                             sm->wpa_ie, sm->wpa_ie_len);
2147                         }
2148                         wpa_hexdump(MSG_DEBUG, "WPA IE in msg 2/4",
2149                                     (u8 *) (key + 1), key_data_length);
2150                         /* MLME-DEAUTHENTICATE.request */
2151                         wpa_sta_disconnect(wpa_auth, sm->addr);
2152                         return;
2153                 }
2154                 break;
2155         case PAIRWISE_4:
2156                 if (sm->wpa_ptk_state != WPA_PTK_PTKINITNEGOTIATING ||
2157                     !sm->PTK_valid) {
2158                         wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_INFO,
2159                                          "received EAPOL-Key msg 4/4 in "
2160                                          "invalid state (%d) - dropped",
2161                                          sm->wpa_ptk_state);
2162                         return;
2163                 }
2164                 break;
2165         case GROUP_2:
2166                 if (sm->wpa_ptk_group_state != WPA_PTK_GROUP_REKEYNEGOTIATING
2167                     || !sm->PTK_valid) {
2168                         wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_INFO,
2169                                          "received EAPOL-Key msg 2/2 in "
2170                                          "invalid state (%d) - dropped",
2171                                          sm->wpa_ptk_group_state);
2172                         return;
2173                 }
2174                 break;
2175 #ifdef CONFIG_PEERKEY
2176         case SMK_M1:
2177         case SMK_M3:
2178         case SMK_ERROR:
2179                 if (!wpa_auth->conf.peerkey) {
2180                         wpa_printf(MSG_DEBUG, "RSN: SMK M1/M3/Error, but "
2181                                    "PeerKey use disabled - ignoring message");
2182                         return;
2183                 }
2184                 if (!sm->PTK_valid) {
2185                         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_INFO,
2186                                         "received EAPOL-Key msg SMK in "
2187                                         "invalid state - dropped");
2188                         return;
2189                 }
2190                 break;
2191 #else /* CONFIG_PEERKEY */
2192         case SMK_M1:
2193         case SMK_M3:
2194         case SMK_ERROR:
2195                 return; /* STSL disabled - ignore SMK messages */
2196 #endif /* CONFIG_PEERKEY */
2197         case REQUEST:
2198                 break;
2199         }
2200
2201         wpa_auth_vlogger(wpa_auth, sm->addr, LOGGER_DEBUG,
2202                          "received EAPOL-Key frame (%s)", msgtxt);
2203
2204         if (key_info & WPA_KEY_INFO_ACK) {
2205                 wpa_auth_logger(wpa_auth, sm->addr, LOGGER_INFO,
2206                                 "received invalid EAPOL-Key: Key Ack set");
2207                 return;
2208         }
2209
2210         if (!(key_info & WPA_KEY_INFO_MIC)) {
2211                 wpa_auth_logger(wpa_auth, sm->addr, LOGGER_INFO,
2212                                 "received invalid EAPOL-Key: Key MIC not set");
2213                 return;
2214         }
2215
2216         sm->MICVerified = FALSE;
2217         if (sm->PTK_valid) {
2218                 if (wpa_verify_key_mic(&sm->PTK, data, data_len)) {
2219                         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_INFO,
2220                                         "received EAPOL-Key with invalid MIC");
2221                         return;
2222                 }
2223                 sm->MICVerified = TRUE;
2224                 eloop_cancel_timeout(wpa_send_eapol_timeout, wpa_auth, sm);
2225         }
2226
2227         if (key_info & WPA_KEY_INFO_REQUEST) {
2228                 if (sm->MICVerified) {
2229                         sm->req_replay_counter_used = 1;
2230                         memcpy(sm->req_replay_counter, key->replay_counter,
2231                                WPA_REPLAY_COUNTER_LEN);
2232                 } else {
2233                         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_INFO,
2234                                         "received EAPOL-Key request with "
2235                                         "invalid MIC");
2236                         return;
2237                 }
2238
2239                 /*
2240                  * TODO: should decrypt key data field if encryption was used;
2241                  * even though MAC address KDE is not normally encrypted,
2242                  * supplicant is allowed to encrypt it.
2243                  */
2244                 if (msg == SMK_ERROR) {
2245 #ifdef CONFIG_PEERKEY
2246                         wpa_smk_error(wpa_auth, sm, key);
2247 #endif /* CONFIG_PEERKEY */
2248                         return;
2249                 } else if (key_info & WPA_KEY_INFO_ERROR) {
2250                         /* Supplicant reported a Michael MIC error */
2251                         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_INFO,
2252                                         "received EAPOL-Key Error Request "
2253                                         "(STA detected Michael MIC failure)");
2254                         wpa_auth_mic_failure_report(wpa_auth, sm->addr);
2255                         sm->dot11RSNAStatsTKIPRemoteMICFailures++;
2256                         wpa_auth->dot11RSNAStatsTKIPRemoteMICFailures++;
2257                         /* Error report is not a request for a new key
2258                          * handshake, but since Authenticator may do it, let's
2259                          * change the keys now anyway. */
2260                         wpa_request_new_ptk(sm);
2261                 } else if (key_info & WPA_KEY_INFO_KEY_TYPE) {
2262                         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_INFO,
2263                                         "received EAPOL-Key Request for new "
2264                                         "4-Way Handshake");
2265                         wpa_request_new_ptk(sm);
2266 #ifdef CONFIG_PEERKEY
2267                 } else if (msg == SMK_M1) {
2268                         wpa_smk_m1(wpa_auth, sm, key);
2269 #endif /* CONFIG_PEERKEY */
2270                 } else if (key_data_length > 0 &&
2271                            wpa_parse_kde_ies((const u8 *) (key + 1),
2272                                              key_data_length, &kde) == 0 &&
2273                            kde.mac_addr) {
2274                 } else {
2275                         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_INFO,
2276                                         "received EAPOL-Key Request for GTK "
2277                                         "rekeying");
2278                         /* FIX: why was this triggering PTK rekeying for the
2279                          * STA that requested Group Key rekeying?? */
2280                         /* wpa_request_new_ptk(sta->wpa_sm); */
2281                         eloop_cancel_timeout(wpa_rekey_gtk, wpa_auth, NULL);
2282                         wpa_rekey_gtk(wpa_auth, NULL);
2283                 }
2284         } else {
2285                 /* Do not allow the same key replay counter to be reused. */
2286                 sm->key_replay_counter_valid = FALSE;
2287         }
2288
2289 #ifdef CONFIG_PEERKEY
2290         if (msg == SMK_M3) {
2291                 wpa_smk_m3(wpa_auth, sm, key);
2292                 return;
2293         }
2294 #endif /* CONFIG_PEERKEY */
2295
2296         free(sm->last_rx_eapol_key);
2297         sm->last_rx_eapol_key = malloc(data_len);
2298         if (sm->last_rx_eapol_key == NULL)
2299                 return;
2300         memcpy(sm->last_rx_eapol_key, data, data_len);
2301         sm->last_rx_eapol_key_len = data_len;
2302
2303         sm->EAPOLKeyReceived = TRUE;
2304         sm->EAPOLKeyPairwise = !!(key_info & WPA_KEY_INFO_KEY_TYPE);
2305         sm->EAPOLKeyRequest = !!(key_info & WPA_KEY_INFO_REQUEST);
2306         memcpy(sm->SNonce, key->key_nonce, WPA_NONCE_LEN);
2307         wpa_sm_step(sm);
2308 }
2309
2310
2311 static void wpa_pmk_to_ptk(const u8 *pmk, const u8 *addr1, const u8 *addr2,
2312                            const u8 *nonce1, const u8 *nonce2,
2313                            u8 *ptk, size_t ptk_len)
2314 {
2315         u8 data[2 * ETH_ALEN + 2 * WPA_NONCE_LEN];
2316
2317         /* PTK = PRF-X(PMK, "Pairwise key expansion",
2318          *             Min(AA, SA) || Max(AA, SA) ||
2319          *             Min(ANonce, SNonce) || Max(ANonce, SNonce)) */
2320
2321         if (memcmp(addr1, addr2, ETH_ALEN) < 0) {
2322                 memcpy(data, addr1, ETH_ALEN);
2323                 memcpy(data + ETH_ALEN, addr2, ETH_ALEN);
2324         } else {
2325                 memcpy(data, addr2, ETH_ALEN);
2326                 memcpy(data + ETH_ALEN, addr1, ETH_ALEN);
2327         }
2328
2329         if (memcmp(nonce1, nonce2, WPA_NONCE_LEN) < 0) {
2330                 memcpy(data + 2 * ETH_ALEN, nonce1, WPA_NONCE_LEN);
2331                 memcpy(data + 2 * ETH_ALEN + WPA_NONCE_LEN, nonce2,
2332                        WPA_NONCE_LEN);
2333         } else {
2334                 memcpy(data + 2 * ETH_ALEN, nonce2, WPA_NONCE_LEN);
2335                 memcpy(data + 2 * ETH_ALEN + WPA_NONCE_LEN, nonce1,
2336                        WPA_NONCE_LEN);
2337         }
2338
2339         sha1_prf(pmk, WPA_PMK_LEN, "Pairwise key expansion",
2340                  data, sizeof(data), ptk, ptk_len);
2341
2342         wpa_hexdump_key(MSG_DEBUG, "PMK", pmk, WPA_PMK_LEN);
2343         wpa_hexdump_key(MSG_DEBUG, "PTK", ptk, ptk_len);
2344 }
2345
2346
2347 static void wpa_gmk_to_gtk(const u8 *gmk, const u8 *addr, const u8 *gnonce,
2348                            u8 *gtk, size_t gtk_len)
2349 {
2350         u8 data[ETH_ALEN + WPA_NONCE_LEN];
2351
2352         /* GTK = PRF-X(GMK, "Group key expansion", AA || GNonce) */
2353         memcpy(data, addr, ETH_ALEN);
2354         memcpy(data + ETH_ALEN, gnonce, WPA_NONCE_LEN);
2355
2356         sha1_prf(gmk, WPA_GMK_LEN, "Group key expansion",
2357                  data, sizeof(data), gtk, gtk_len);
2358
2359         wpa_hexdump_key(MSG_DEBUG, "GMK", gmk, WPA_GMK_LEN);
2360         wpa_hexdump_key(MSG_DEBUG, "GTK", gtk, gtk_len);
2361 }
2362
2363
2364 static void wpa_send_eapol_timeout(void *eloop_ctx, void *timeout_ctx)
2365 {
2366         struct wpa_authenticator *wpa_auth = eloop_ctx;
2367         struct wpa_state_machine *sm = timeout_ctx;
2368
2369         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_DEBUG, "EAPOL-Key timeout");
2370         sm->TimeoutEvt = TRUE;
2371         wpa_sm_step(sm);
2372 }
2373
2374
2375 static int wpa_calc_eapol_key_mic(int ver, u8 *key, u8 *data, size_t len,
2376                                   u8 *mic)
2377 {
2378         u8 hash[SHA1_MAC_LEN];
2379
2380         switch (ver) {
2381         case WPA_KEY_INFO_TYPE_HMAC_MD5_RC4:
2382                 hmac_md5(key, 16, data, len, mic);
2383                 break;
2384         case WPA_KEY_INFO_TYPE_HMAC_SHA1_AES:
2385                 hmac_sha1(key, 16, data, len, hash);
2386                 memcpy(mic, hash, MD5_MAC_LEN);
2387                 break;
2388         default:
2389                 return -1;
2390         }
2391         return 0;
2392 }
2393
2394
2395 static void __wpa_send_eapol(struct wpa_authenticator *wpa_auth,
2396                              struct wpa_state_machine *sm, int key_info,
2397                              const u8 *key_rsc, const u8 *nonce,
2398                              const u8 *kde, size_t kde_len,
2399                              int keyidx, int encr, int force_version)
2400 {
2401         struct ieee802_1x_hdr *hdr;
2402         struct wpa_eapol_key *key;
2403         size_t len;
2404         int alg;
2405         int key_data_len, pad_len = 0;
2406         u8 *buf, *pos;
2407         int version, pairwise;
2408
2409         len = sizeof(struct ieee802_1x_hdr) + sizeof(struct wpa_eapol_key);
2410
2411         if (force_version)
2412                 version = force_version;
2413         else if (sm->pairwise == WPA_CIPHER_CCMP)
2414                 version = WPA_KEY_INFO_TYPE_HMAC_SHA1_AES;
2415         else
2416                 version = WPA_KEY_INFO_TYPE_HMAC_MD5_RC4;
2417
2418         pairwise = key_info & WPA_KEY_INFO_KEY_TYPE;
2419
2420         wpa_printf(MSG_DEBUG, "WPA: Send EAPOL(secure=%d mic=%d ack=%d "
2421                    "install=%d pairwise=%d kde_len=%lu keyidx=%d encr=%d)",
2422                    (key_info & WPA_KEY_INFO_SECURE) ? 1 : 0,
2423                    (key_info & WPA_KEY_INFO_MIC) ? 1 : 0,
2424                    (key_info & WPA_KEY_INFO_ACK) ? 1 : 0,
2425                    (key_info & WPA_KEY_INFO_INSTALL) ? 1 : 0,
2426                    pairwise, (unsigned long) kde_len, keyidx, encr);
2427
2428         key_data_len = kde_len;
2429
2430         if (version == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES && encr) {
2431                 pad_len = key_data_len % 8;
2432                 if (pad_len)
2433                         pad_len = 8 - pad_len;
2434                 key_data_len += pad_len + 8;
2435         }
2436
2437         len += key_data_len;
2438
2439         hdr = wpa_zalloc(len);
2440         if (hdr == NULL)
2441                 return;
2442         hdr->version = wpa_auth->conf.eapol_version;
2443         hdr->type = IEEE802_1X_TYPE_EAPOL_KEY;
2444         hdr->length = htons(len  - sizeof(*hdr));
2445         key = (struct wpa_eapol_key *) (hdr + 1);
2446
2447         key->type = sm->wpa == WPA_VERSION_WPA2 ?
2448                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
2449         key_info |= version;
2450         if (encr && sm->wpa == WPA_VERSION_WPA2)
2451                 key_info |= WPA_KEY_INFO_ENCR_KEY_DATA;
2452         if (sm->wpa != WPA_VERSION_WPA2)
2453                 key_info |= keyidx << WPA_KEY_INFO_KEY_INDEX_SHIFT;
2454         key->key_info = htons(key_info);
2455
2456         alg = pairwise ? sm->pairwise : wpa_auth->conf.wpa_group;
2457         switch (alg) {
2458         case WPA_CIPHER_CCMP:
2459                 key->key_length = htons(16);
2460                 break;
2461         case WPA_CIPHER_TKIP:
2462                 key->key_length = htons(32);
2463                 break;
2464         case WPA_CIPHER_WEP40:
2465                 key->key_length = htons(5);
2466                 break;
2467         case WPA_CIPHER_WEP104:
2468                 key->key_length = htons(13);
2469                 break;
2470         }
2471         if (key_info & WPA_KEY_INFO_SMK_MESSAGE)
2472                 key->key_length = htons(0);
2473
2474         /* FIX: STSL: what to use as key_replay_counter? */
2475         inc_byte_array(sm->key_replay_counter, WPA_REPLAY_COUNTER_LEN);
2476         memcpy(key->replay_counter, sm->key_replay_counter,
2477                WPA_REPLAY_COUNTER_LEN);
2478         sm->key_replay_counter_valid = TRUE;
2479
2480         if (nonce)
2481                 memcpy(key->key_nonce, nonce, WPA_NONCE_LEN);
2482
2483         if (key_rsc)
2484                 memcpy(key->key_rsc, key_rsc, WPA_KEY_RSC_LEN);
2485
2486         if (kde && !encr) {
2487                 memcpy(key + 1, kde, kde_len);
2488                 key->key_data_length = htons(kde_len);
2489         } else if (encr && kde) {
2490                 buf = wpa_zalloc(key_data_len);
2491                 if (buf == NULL) {
2492                         free(hdr);
2493                         return;
2494                 }
2495                 pos = buf;
2496                 memcpy(pos, kde, kde_len);
2497                 pos += kde_len;
2498
2499                 if (pad_len)
2500                         *pos++ = 0xdd;
2501
2502                 wpa_hexdump_key(MSG_DEBUG, "Plaintext EAPOL-Key Key Data",
2503                                 buf, key_data_len);
2504                 if (version == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
2505                         aes_wrap(sm->PTK.encr_key, (key_data_len - 8) / 8, buf,
2506                                  (u8 *) (key + 1));
2507                         key->key_data_length = htons(key_data_len);
2508                 } else {
2509                         u8 ek[32];
2510                         memcpy(key->key_iv,
2511                                sm->group->Counter + WPA_NONCE_LEN - 16, 16);
2512                         inc_byte_array(sm->group->Counter, WPA_NONCE_LEN);
2513                         memcpy(ek, key->key_iv, 16);
2514                         memcpy(ek + 16, sm->PTK.encr_key, 16);
2515                         memcpy(key + 1, buf, key_data_len);
2516                         rc4_skip(ek, 32, 256, (u8 *) (key + 1), key_data_len);
2517                         key->key_data_length = htons(key_data_len);
2518                 }
2519                 free(buf);
2520         }
2521
2522         if (key_info & WPA_KEY_INFO_MIC) {
2523                 if (!sm->PTK_valid) {
2524                         wpa_auth_logger(wpa_auth, sm->addr, LOGGER_DEBUG,
2525                                         "PTK not valid when sending EAPOL-Key "
2526                                         "frame");
2527                         free(hdr);
2528                         return;
2529                 }
2530                 wpa_calc_eapol_key_mic(version,
2531                                        sm->PTK.mic_key, (u8 *) hdr, len,
2532                                        key->key_mic);
2533         }
2534
2535         wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_inc_EapolFramesTx,
2536                            1);
2537         wpa_auth_send_eapol(wpa_auth, sm->addr, (u8 *) hdr, len,
2538                             sm->pairwise_set);
2539         free(hdr);
2540 }
2541
2542
2543 static void wpa_send_eapol(struct wpa_authenticator *wpa_auth,
2544                            struct wpa_state_machine *sm, int key_info,
2545                            const u8 *key_rsc, const u8 *nonce,
2546                            const u8 *kde, size_t kde_len,
2547                            int keyidx, int encr)
2548 {
2549         int timeout_ms;
2550         int pairwise = key_info & WPA_KEY_INFO_KEY_TYPE;
2551
2552         if (sm == NULL)
2553                 return;
2554
2555         __wpa_send_eapol(wpa_auth, sm, key_info, key_rsc, nonce, kde, kde_len,
2556                          keyidx, encr, 0);
2557
2558         timeout_ms = pairwise ? dot11RSNAConfigPairwiseUpdateTimeOut :
2559                 dot11RSNAConfigGroupUpdateTimeOut;
2560         eloop_register_timeout(timeout_ms / 1000, (timeout_ms % 1000) * 1000,
2561                                wpa_send_eapol_timeout, wpa_auth, sm);
2562 }
2563
2564
2565 static int wpa_verify_key_mic(struct wpa_ptk *PTK, u8 *data, size_t data_len)
2566 {
2567         struct ieee802_1x_hdr *hdr;
2568         struct wpa_eapol_key *key;
2569         u16 key_info;
2570         int ret = 0;
2571         u8 mic[16];
2572
2573         if (data_len < sizeof(*hdr) + sizeof(*key))
2574                 return -1;
2575
2576         hdr = (struct ieee802_1x_hdr *) data;
2577         key = (struct wpa_eapol_key *) (hdr + 1);
2578         key_info = ntohs(key->key_info);
2579         memcpy(mic, key->key_mic, 16);
2580         memset(key->key_mic, 0, 16);
2581         if (wpa_calc_eapol_key_mic(key_info & WPA_KEY_INFO_TYPE_MASK,
2582                                    PTK->mic_key, data, data_len, key->key_mic)
2583             || memcmp(mic, key->key_mic, 16) != 0)
2584                 ret = -1;
2585         memcpy(key->key_mic, mic, 16);
2586         return ret;
2587 }
2588
2589
2590 void wpa_remove_ptk(struct wpa_state_machine *sm)
2591 {
2592         sm->PTK_valid = FALSE;
2593         memset(&sm->PTK, 0, sizeof(sm->PTK));
2594         wpa_auth_set_key(sm->wpa_auth, 0, "none", sm->addr, 0, (u8 *) "", 0);
2595         sm->pairwise_set = FALSE;
2596 }
2597
2598
2599 void wpa_auth_sm_event(struct wpa_state_machine *sm, wpa_event event)
2600 {
2601         if (sm == NULL)
2602                 return;
2603
2604         wpa_auth_vlogger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
2605                          "event %d notification", event);
2606
2607         switch (event) {
2608         case WPA_AUTH:
2609         case WPA_ASSOC:
2610                 break;
2611         case WPA_DEAUTH:
2612         case WPA_DISASSOC:
2613                 sm->DeauthenticationRequest = TRUE;
2614                 break;
2615         case WPA_REAUTH:
2616         case WPA_REAUTH_EAPOL:
2617                 sm->ReAuthenticationRequest = TRUE;
2618                 break;
2619         }
2620
2621         sm->PTK_valid = FALSE;
2622         memset(&sm->PTK, 0, sizeof(sm->PTK));
2623
2624         if (event != WPA_REAUTH_EAPOL)
2625                 wpa_remove_ptk(sm);
2626
2627         wpa_sm_step(sm);
2628 }
2629
2630
2631 static const char * wpa_alg_txt(int alg)
2632 {
2633         switch (alg) {
2634         case WPA_CIPHER_CCMP:
2635                 return "CCMP";
2636         case WPA_CIPHER_TKIP:
2637                 return "TKIP";
2638         case WPA_CIPHER_WEP104:
2639         case WPA_CIPHER_WEP40:
2640                 return "WEP";
2641         default:
2642                 return "";
2643         }
2644 }
2645
2646
2647 SM_STATE(WPA_PTK, INITIALIZE)
2648 {
2649         SM_ENTRY_MA(WPA_PTK, INITIALIZE, wpa_ptk);
2650         if (sm->Init) {
2651                 /* Init flag is not cleared here, so avoid busy
2652                  * loop by claiming nothing changed. */
2653                 sm->changed = FALSE;
2654         }
2655
2656         sm->keycount = 0;
2657         if (sm->GUpdateStationKeys)
2658                 sm->group->GKeyDoneStations--;
2659         sm->GUpdateStationKeys = FALSE;
2660         if (sm->wpa == WPA_VERSION_WPA)
2661                 sm->PInitAKeys = FALSE;
2662         if (1 /* Unicast cipher supported AND (ESS OR ((IBSS or WDS) and
2663                * Local AA > Remote AA)) */) {
2664                 sm->Pair = TRUE;
2665         }
2666         wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_portEnabled, 0);
2667         wpa_remove_ptk(sm);
2668         wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_portValid, 0);
2669         sm->TimeoutCtr = 0;
2670         if (sm->wpa_key_mgmt == WPA_KEY_MGMT_PSK) {
2671                 wpa_auth_set_eapol(sm->wpa_auth, sm->addr,
2672                                    WPA_EAPOL_authorized, 0);
2673         }
2674 }
2675
2676
2677 SM_STATE(WPA_PTK, DISCONNECT)
2678 {
2679         SM_ENTRY_MA(WPA_PTK, DISCONNECT, wpa_ptk);
2680         sm->Disconnect = FALSE;
2681         wpa_sta_disconnect(sm->wpa_auth, sm->addr);
2682 }
2683
2684
2685 SM_STATE(WPA_PTK, DISCONNECTED)
2686 {
2687         SM_ENTRY_MA(WPA_PTK, DISCONNECTED, wpa_ptk);
2688         if (sm->sta_counted) {
2689                 sm->group->GNoStations--;
2690                 sm->sta_counted = 0;
2691         } else {
2692                 wpa_printf(MSG_DEBUG, "WPA: WPA_PTK::DISCONNECTED - did not "
2693                            "decrease GNoStations (STA " MACSTR ")",
2694                            MAC2STR(sm->addr));
2695         }
2696         sm->DeauthenticationRequest = FALSE;
2697 }
2698
2699
2700 SM_STATE(WPA_PTK, AUTHENTICATION)
2701 {
2702         SM_ENTRY_MA(WPA_PTK, AUTHENTICATION, wpa_ptk);
2703         if (!sm->sta_counted) {
2704                 sm->group->GNoStations++;
2705                 sm->sta_counted = 1;
2706         } else {
2707                 wpa_printf(MSG_DEBUG, "WPA: WPA_PTK::DISCONNECTED - did not "
2708                            "increase GNoStations (STA " MACSTR ")",
2709                            MAC2STR(sm->addr));
2710         }
2711         memset(&sm->PTK, 0, sizeof(sm->PTK));
2712         sm->PTK_valid = FALSE;
2713         wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_portControl_Auto,
2714                            1);
2715         wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_portEnabled, 1);
2716         sm->AuthenticationRequest = FALSE;
2717 }
2718
2719
2720 SM_STATE(WPA_PTK, AUTHENTICATION2)
2721 {
2722         SM_ENTRY_MA(WPA_PTK, AUTHENTICATION2, wpa_ptk);
2723         memcpy(sm->ANonce, sm->group->Counter, WPA_NONCE_LEN);
2724         inc_byte_array(sm->group->Counter, WPA_NONCE_LEN);
2725         sm->ReAuthenticationRequest = FALSE;
2726         /* IEEE 802.11i does not clear TimeoutCtr here, but this is more
2727          * logical place than INITIALIZE since AUTHENTICATION2 can be
2728          * re-entered on ReAuthenticationRequest without going through
2729          * INITIALIZE. */
2730         sm->TimeoutCtr = 0;
2731 }
2732
2733
2734 SM_STATE(WPA_PTK, INITPMK)
2735 {
2736         size_t len = WPA_PMK_LEN;
2737
2738         SM_ENTRY_MA(WPA_PTK, INITPMK, wpa_ptk);
2739         if (sm->pmksa) {
2740                 wpa_printf(MSG_DEBUG, "WPA: PMK from PMKSA cache");
2741                 memcpy(sm->PMK, sm->pmksa->pmk, WPA_PMK_LEN);
2742         } else if (wpa_auth_get_pmk(sm->wpa_auth, sm->addr, sm->PMK, &len) ==
2743                    0) {
2744                 wpa_printf(MSG_DEBUG, "WPA: PMK from EAPOL state machine "
2745                            "(len=%lu)", (unsigned long) len);
2746         } else {
2747                 wpa_printf(MSG_DEBUG, "WPA: Could not get PMK");
2748         }
2749
2750         sm->req_replay_counter_used = 0;
2751         /* IEEE 802.11i does not set keyRun to FALSE, but not doing this
2752          * will break reauthentication since EAPOL state machines may not be
2753          * get into AUTHENTICATING state that clears keyRun before WPA state
2754          * machine enters AUTHENTICATION2 state and goes immediately to INITPMK
2755          * state and takes PMK from the previously used AAA Key. This will
2756          * eventually fail in 4-Way Handshake because Supplicant uses PMK
2757          * derived from the new AAA Key. Setting keyRun = FALSE here seems to
2758          * be good workaround for this issue. */
2759         wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_keyRun, 0);
2760 }
2761
2762
2763 SM_STATE(WPA_PTK, INITPSK)
2764 {
2765         const u8 *psk;
2766         SM_ENTRY_MA(WPA_PTK, INITPSK, wpa_ptk);
2767         psk = wpa_auth_get_psk(sm->wpa_auth, sm->addr, NULL);
2768         if (psk)
2769                 memcpy(sm->PMK, psk, WPA_PMK_LEN);
2770         sm->req_replay_counter_used = 0;
2771 }
2772
2773
2774 SM_STATE(WPA_PTK, PTKSTART)
2775 {
2776         u8 buf[2 + RSN_SELECTOR_LEN + PMKID_LEN], *pmkid = NULL;
2777         size_t pmkid_len = 0;
2778
2779         SM_ENTRY_MA(WPA_PTK, PTKSTART, wpa_ptk);
2780         sm->PTKRequest = FALSE;
2781         sm->TimeoutEvt = FALSE;
2782         wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
2783                         "sending 1/4 msg of 4-Way Handshake");
2784         /*
2785          * TODO: Could add PMKID even with WPA2-PSK, but only if there is only
2786          * one possible PSK for this STA.
2787          */
2788         if (sm->wpa == WPA_VERSION_WPA2 &&
2789             sm->wpa_key_mgmt != WPA_KEY_MGMT_PSK) {
2790                 pmkid = buf;
2791                 pmkid_len = 2 + RSN_SELECTOR_LEN + PMKID_LEN;
2792                 pmkid[0] = WLAN_EID_GENERIC;
2793                 pmkid[1] = RSN_SELECTOR_LEN + PMKID_LEN;
2794                 memcpy(&pmkid[2], RSN_KEY_DATA_PMKID, RSN_SELECTOR_LEN);
2795                 if (sm->pmksa)
2796                         memcpy(&pmkid[2 + RSN_SELECTOR_LEN], sm->pmksa->pmkid,
2797                                PMKID_LEN);
2798                 else {
2799                         /*
2800                          * Calculate PMKID since no PMKSA cache entry was
2801                          * available with pre-calculated PMKID.
2802                          */
2803                         rsn_pmkid(sm->PMK, WPA_PMK_LEN, sm->wpa_auth->addr,
2804                                   sm->addr, &pmkid[2 + RSN_SELECTOR_LEN]);
2805                 }
2806         }
2807         wpa_send_eapol(sm->wpa_auth, sm,
2808                        WPA_KEY_INFO_ACK | WPA_KEY_INFO_KEY_TYPE, NULL,
2809                        sm->ANonce, pmkid, pmkid_len, 0, 0);
2810         sm->TimeoutCtr++;
2811 }
2812
2813
2814 SM_STATE(WPA_PTK, PTKCALCNEGOTIATING)
2815 {
2816         struct wpa_ptk PTK;
2817         int ok = 0;
2818         const u8 *pmk = NULL;
2819
2820         SM_ENTRY_MA(WPA_PTK, PTKCALCNEGOTIATING, wpa_ptk);
2821         sm->EAPOLKeyReceived = FALSE;
2822
2823         /* WPA with IEEE 802.1X: use the derived PMK from EAP
2824          * WPA-PSK: iterate through possible PSKs and select the one matching
2825          * the packet */
2826         for (;;) {
2827                 if (sm->wpa_key_mgmt == WPA_KEY_MGMT_PSK) {
2828                         pmk = wpa_auth_get_psk(sm->wpa_auth, sm->addr, pmk);
2829                         if (pmk == NULL)
2830                                 break;
2831                 } else
2832                         pmk = sm->PMK;
2833
2834                 wpa_pmk_to_ptk(pmk, sm->wpa_auth->addr, sm->addr,
2835                                sm->ANonce, sm->SNonce,
2836                                (u8 *) &PTK, sizeof(PTK));
2837
2838                 if (wpa_verify_key_mic(&PTK, sm->last_rx_eapol_key,
2839                                        sm->last_rx_eapol_key_len) == 0) {
2840                         ok = 1;
2841                         break;
2842                 }
2843
2844                 if (sm->wpa_key_mgmt != WPA_KEY_MGMT_PSK)
2845                         break;
2846         }
2847
2848         if (!ok) {
2849                 wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
2850                                 "invalid MIC in msg 2/4 of 4-Way Handshake");
2851                 return;
2852         }
2853
2854         eloop_cancel_timeout(wpa_send_eapol_timeout, sm->wpa_auth, sm);
2855
2856         if (sm->wpa_key_mgmt == WPA_KEY_MGMT_PSK) {
2857                 /* PSK may have changed from the previous choice, so update
2858                  * state machine data based on whatever PSK was selected here.
2859                  */
2860                 memcpy(sm->PMK, pmk, WPA_PMK_LEN);
2861         }
2862
2863         sm->MICVerified = TRUE;
2864
2865         memcpy(&sm->PTK, &PTK, sizeof(PTK));
2866         sm->PTK_valid = TRUE;
2867 }
2868
2869
2870 SM_STATE(WPA_PTK, PTKCALCNEGOTIATING2)
2871 {
2872         SM_ENTRY_MA(WPA_PTK, PTKCALCNEGOTIATING2, wpa_ptk);
2873         sm->TimeoutCtr = 0;
2874 }
2875
2876
2877 #ifdef CONFIG_IEEE80211W
2878
2879 static int ieee80211w_kde_len(struct wpa_state_machine *sm)
2880 {
2881         if (sm->mgmt_frame_prot) {
2882                 return 2 + RSN_SELECTOR_LEN + sizeof(struct wpa_dhv_kde) +
2883                         2 + RSN_SELECTOR_LEN + sizeof(struct wpa_igtk_kde);
2884         }
2885
2886         return 0;
2887 }
2888
2889
2890 static u8 * ieee80211w_kde_add(struct wpa_state_machine *sm, u8 *pos)
2891 {
2892         struct wpa_dhv_kde dhv;
2893         struct wpa_igtk_kde igtk;
2894         struct wpa_group *gsm = sm->group;
2895         u8 mac[32];
2896         const u8 *addr[3];
2897         size_t len[3];
2898
2899         if (!sm->mgmt_frame_prot)
2900                 return pos;
2901
2902         addr[0] = sm->wpa_auth->addr;
2903         len[0] = ETH_ALEN;
2904         addr[1] = sm->addr;
2905         len[1] = ETH_ALEN;
2906         addr[2] = gsm->DGTK;
2907         len[2] = WPA_DGTK_LEN;
2908         sha256_vector(3, addr, len, mac);
2909         memcpy(dhv.dhv, mac, WPA_DHV_LEN);
2910         wpa_hexdump_key(MSG_DEBUG, "WPA: DHV", dhv.dhv, WPA_DHV_LEN);
2911         pos = wpa_add_kde(pos, RSN_KEY_DATA_DHV,
2912                           (const u8 *) &dhv, sizeof(dhv), NULL, 0);
2913
2914         igtk.keyid[0] = gsm->GN;
2915         igtk.keyid[1] = 0;
2916         if (wpa_auth_get_seqnum_igtk(sm->wpa_auth, NULL, gsm->GN, igtk.pn) < 0)
2917                 memset(igtk.pn, 0, sizeof(igtk.pn));
2918         memcpy(igtk.igtk, gsm->IGTK[gsm->GN - 1], WPA_IGTK_LEN);
2919         pos = wpa_add_kde(pos, RSN_KEY_DATA_IGTK,
2920                           (const u8 *) &igtk, sizeof(igtk), NULL, 0);
2921
2922         return pos;
2923 }
2924
2925 #else /* CONFIG_IEEE80211W */
2926
2927 static int ieee80211w_kde_len(struct wpa_state_machine *sm)
2928 {
2929         return 0;
2930 }
2931
2932
2933 static u8 * ieee80211w_kde_add(struct wpa_state_machine *sm, u8 *pos)
2934 {
2935         return pos;
2936 }
2937
2938 #endif /* CONFIG_IEEE80211W */
2939
2940
2941 SM_STATE(WPA_PTK, PTKINITNEGOTIATING)
2942 {
2943         u8 rsc[WPA_KEY_RSC_LEN], *_rsc, *gtk, *kde, *pos;
2944         size_t gtk_len, kde_len;
2945         struct wpa_group *gsm = sm->group;
2946         u8 *wpa_ie;
2947         int wpa_ie_len, secure, keyidx, encr = 0;
2948
2949         SM_ENTRY_MA(WPA_PTK, PTKINITNEGOTIATING, wpa_ptk);
2950         sm->TimeoutEvt = FALSE;
2951         /* Send EAPOL(1, 1, 1, Pair, P, RSC, ANonce, MIC(PTK), RSNIE, GTK[GN])
2952          */
2953         memset(rsc, 0, WPA_KEY_RSC_LEN);
2954         wpa_auth_get_seqnum(sm->wpa_auth, NULL, gsm->GN, rsc);
2955         wpa_ie = sm->wpa_auth->wpa_ie;
2956         wpa_ie_len = sm->wpa_auth->wpa_ie_len;
2957         if (sm->wpa == WPA_VERSION_WPA &&
2958             (sm->wpa_auth->conf.wpa & HOSTAPD_WPA_VERSION_WPA2) &&
2959             wpa_ie_len > wpa_ie[1] + 2 && wpa_ie[0] == WLAN_EID_RSN) {
2960                 /* WPA-only STA, remove RSN IE */
2961                 wpa_ie = wpa_ie + wpa_ie[1] + 2;
2962                 wpa_ie_len = wpa_ie[1] + 2;
2963         }
2964         wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
2965                         "sending 3/4 msg of 4-Way Handshake");
2966         if (sm->wpa == WPA_VERSION_WPA2) {
2967                 /* WPA2 send GTK in the 4-way handshake */
2968                 secure = 1;
2969                 gtk = gsm->GTK[gsm->GN - 1];
2970                 gtk_len = gsm->GTK_len;
2971                 keyidx = gsm->GN;
2972                 _rsc = rsc;
2973                 encr = 1;
2974         } else {
2975                 /* WPA does not include GTK in msg 3/4 */
2976                 secure = 0;
2977                 gtk = NULL;
2978                 gtk_len = 0;
2979                 keyidx = 0;
2980                 _rsc = NULL;
2981         }
2982
2983         kde_len = wpa_ie_len + ieee80211w_kde_len(sm);
2984         if (gtk)
2985                 kde_len += 2 + RSN_SELECTOR_LEN + 2 + gtk_len;
2986         kde = malloc(kde_len);
2987         if (kde == NULL)
2988                 return;
2989
2990         pos = kde;
2991         memcpy(pos, wpa_ie, wpa_ie_len);
2992         pos += wpa_ie_len;
2993         if (gtk) {
2994                 u8 hdr[2];
2995                 hdr[0] = keyidx & 0x03;
2996                 hdr[1] = 0;
2997                 pos = wpa_add_kde(pos, RSN_KEY_DATA_GROUPKEY, hdr, 2,
2998                                   gtk, gtk_len);
2999         }
3000         pos = ieee80211w_kde_add(sm, pos);
3001
3002         wpa_send_eapol(sm->wpa_auth, sm,
3003                        (secure ? WPA_KEY_INFO_SECURE : 0) | WPA_KEY_INFO_MIC |
3004                        WPA_KEY_INFO_ACK | WPA_KEY_INFO_INSTALL |
3005                        WPA_KEY_INFO_KEY_TYPE,
3006                        _rsc, sm->ANonce, kde, pos - kde, keyidx, encr);
3007         free(kde);
3008         sm->TimeoutCtr++;
3009 }
3010
3011
3012 SM_STATE(WPA_PTK, PTKINITDONE)
3013 {
3014         SM_ENTRY_MA(WPA_PTK, PTKINITDONE, wpa_ptk);
3015         sm->EAPOLKeyReceived = FALSE;
3016         if (sm->Pair) {
3017                 char *alg;
3018                 int klen;
3019                 if (sm->pairwise == WPA_CIPHER_TKIP) {
3020                         alg = "TKIP";
3021                         klen = 32;
3022                 } else {
3023                         alg = "CCMP";
3024                         klen = 16;
3025                 }
3026                 if (wpa_auth_set_key(sm->wpa_auth, 0, alg, sm->addr, 0,
3027                                      sm->PTK.tk1, klen)) {
3028                         wpa_sta_disconnect(sm->wpa_auth, sm->addr);
3029                         return;
3030                 }
3031                 /* FIX: MLME-SetProtection.Request(TA, Tx_Rx) */
3032                 sm->pairwise_set = TRUE;
3033
3034                 if (sm->wpa_key_mgmt == WPA_KEY_MGMT_PSK) {
3035                         wpa_auth_set_eapol(sm->wpa_auth, sm->addr,
3036                                            WPA_EAPOL_authorized, 1);
3037                 }
3038         }
3039
3040         if (0 /* IBSS == TRUE */) {
3041                 sm->keycount++;
3042                 if (sm->keycount == 2) {
3043                         wpa_auth_set_eapol(sm->wpa_auth, sm->addr,
3044                                            WPA_EAPOL_portValid, 1);
3045                 }
3046         } else {
3047                 wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_portValid,
3048                                    1);
3049         }
3050         wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_keyAvailable, 0);
3051         wpa_auth_set_eapol(sm->wpa_auth, sm->addr, WPA_EAPOL_keyDone, 1);
3052         if (sm->wpa == WPA_VERSION_WPA)
3053                 sm->PInitAKeys = TRUE;
3054         else
3055                 sm->has_GTK = TRUE;
3056         wpa_auth_vlogger(sm->wpa_auth, sm->addr, LOGGER_INFO,
3057                          "pairwise key handshake completed (%s)",
3058                          sm->wpa == WPA_VERSION_WPA ? "WPA" : "RSN");
3059 }
3060
3061
3062 SM_STEP(WPA_PTK)
3063 {
3064         struct wpa_authenticator *wpa_auth = sm->wpa_auth;
3065
3066         if (sm->Init)
3067                 SM_ENTER(WPA_PTK, INITIALIZE);
3068         else if (sm->Disconnect
3069                  /* || FIX: dot11RSNAConfigSALifetime timeout */)
3070                 SM_ENTER(WPA_PTK, DISCONNECT);
3071         else if (sm->DeauthenticationRequest)
3072                 SM_ENTER(WPA_PTK, DISCONNECTED);
3073         else if (sm->AuthenticationRequest)
3074                 SM_ENTER(WPA_PTK, AUTHENTICATION);
3075         else if (sm->ReAuthenticationRequest)
3076                 SM_ENTER(WPA_PTK, AUTHENTICATION2);
3077         else if (sm->PTKRequest)
3078                 SM_ENTER(WPA_PTK, PTKSTART);
3079         else switch (sm->wpa_ptk_state) {
3080         case WPA_PTK_INITIALIZE:
3081                 break;
3082         case WPA_PTK_DISCONNECT:
3083                 SM_ENTER(WPA_PTK, DISCONNECTED);
3084                 break;
3085         case WPA_PTK_DISCONNECTED:
3086                 SM_ENTER(WPA_PTK, INITIALIZE);
3087                 break;
3088         case WPA_PTK_AUTHENTICATION:
3089                 SM_ENTER(WPA_PTK, AUTHENTICATION2);
3090                 break;
3091         case WPA_PTK_AUTHENTICATION2:
3092                 if ((sm->wpa_key_mgmt == WPA_KEY_MGMT_IEEE8021X) &&
3093                     wpa_auth_get_eapol(sm->wpa_auth, sm->addr,
3094                                        WPA_EAPOL_keyRun) > 0)
3095                         SM_ENTER(WPA_PTK, INITPMK);
3096                 else if ((sm->wpa_key_mgmt == WPA_KEY_MGMT_PSK)
3097                          /* FIX: && 802.1X::keyRun */)
3098                         SM_ENTER(WPA_PTK, INITPSK);
3099                 break;
3100         case WPA_PTK_INITPMK:
3101                 if (wpa_auth_get_eapol(sm->wpa_auth, sm->addr,
3102                                        WPA_EAPOL_keyAvailable) > 0)
3103                         SM_ENTER(WPA_PTK, PTKSTART);
3104                 else {
3105                         wpa_auth->dot11RSNA4WayHandshakeFailures++;
3106                         SM_ENTER(WPA_PTK, DISCONNECT);
3107                 }
3108                 break;
3109         case WPA_PTK_INITPSK:
3110                 if (wpa_auth_get_psk(sm->wpa_auth, sm->addr, NULL))
3111                         SM_ENTER(WPA_PTK, PTKSTART);
3112                 else {
3113                         wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_INFO,
3114                                         "no PSK configured for the STA");
3115                         wpa_auth->dot11RSNA4WayHandshakeFailures++;
3116                         SM_ENTER(WPA_PTK, DISCONNECT);
3117                 }
3118                 break;
3119         case WPA_PTK_PTKSTART:
3120                 if (sm->EAPOLKeyReceived && !sm->EAPOLKeyRequest &&
3121                     sm->EAPOLKeyPairwise)
3122                         SM_ENTER(WPA_PTK, PTKCALCNEGOTIATING);
3123                 else if (sm->TimeoutCtr >
3124                          (int) dot11RSNAConfigPairwiseUpdateCount) {
3125                         wpa_auth->dot11RSNA4WayHandshakeFailures++;
3126                         SM_ENTER(WPA_PTK, DISCONNECT);
3127                 } else if (sm->TimeoutEvt)
3128                         SM_ENTER(WPA_PTK, PTKSTART);
3129                 break;
3130         case WPA_PTK_PTKCALCNEGOTIATING:
3131                 if (sm->MICVerified)
3132                         SM_ENTER(WPA_PTK, PTKCALCNEGOTIATING2);
3133                 else if (sm->EAPOLKeyReceived && !sm->EAPOLKeyRequest &&
3134                          sm->EAPOLKeyPairwise)
3135                         SM_ENTER(WPA_PTK, PTKCALCNEGOTIATING);
3136                 else if (sm->TimeoutEvt)
3137                         SM_ENTER(WPA_PTK, PTKSTART);
3138                 break;
3139         case WPA_PTK_PTKCALCNEGOTIATING2:
3140                 SM_ENTER(WPA_PTK, PTKINITNEGOTIATING);
3141                 break;
3142         case WPA_PTK_PTKINITNEGOTIATING:
3143                 if (sm->EAPOLKeyReceived && !sm->EAPOLKeyRequest &&
3144                     sm->EAPOLKeyPairwise && sm->MICVerified)
3145                         SM_ENTER(WPA_PTK, PTKINITDONE);
3146                 else if (sm->TimeoutCtr >
3147                          (int) dot11RSNAConfigPairwiseUpdateCount) {
3148                         wpa_auth->dot11RSNA4WayHandshakeFailures++;
3149                         SM_ENTER(WPA_PTK, DISCONNECT);
3150                 } else if (sm->TimeoutEvt)
3151                         SM_ENTER(WPA_PTK, PTKINITNEGOTIATING);
3152                 break;
3153         case WPA_PTK_PTKINITDONE:
3154                 break;
3155         }
3156 }
3157
3158
3159 SM_STATE(WPA_PTK_GROUP, IDLE)
3160 {
3161         SM_ENTRY_MA(WPA_PTK_GROUP, IDLE, wpa_ptk_group);
3162         if (sm->Init) {
3163                 /* Init flag is not cleared here, so avoid busy
3164                  * loop by claiming nothing changed. */
3165                 sm->changed = FALSE;
3166         }
3167         sm->GTimeoutCtr = 0;
3168 }
3169
3170
3171 SM_STATE(WPA_PTK_GROUP, REKEYNEGOTIATING)
3172 {
3173         u8 rsc[WPA_KEY_RSC_LEN];
3174         struct wpa_group *gsm = sm->group;
3175         u8 *kde, *pos, hdr[2];
3176         size_t kde_len;
3177
3178         SM_ENTRY_MA(WPA_PTK_GROUP, REKEYNEGOTIATING, wpa_ptk_group);
3179         if (sm->wpa == WPA_VERSION_WPA)
3180                 sm->PInitAKeys = FALSE;
3181         sm->TimeoutEvt = FALSE;
3182         /* Send EAPOL(1, 1, 1, !Pair, G, RSC, GNonce, MIC(PTK), GTK[GN]) */
3183         memset(rsc, 0, WPA_KEY_RSC_LEN);
3184         if (gsm->wpa_group_state == WPA_GROUP_SETKEYSDONE)
3185                 wpa_auth_get_seqnum(sm->wpa_auth, NULL, gsm->GN, rsc);
3186         wpa_auth_logger(sm->wpa_auth, sm->addr, LOGGER_DEBUG,
3187                         "sending 1/2 msg of Group Key Handshake");
3188
3189         if (sm->wpa == WPA_VERSION_WPA2) {
3190                 kde_len = 2 + RSN_SELECTOR_LEN + 2 + gsm->GTK_len +
3191                         ieee80211w_kde_len(sm);
3192                 kde = malloc(kde_len);
3193                 if (kde == NULL)
3194                         return;
3195
3196                 pos = kde;
3197                 hdr[0] = gsm->GN & 0x03;
3198                 hdr[1] = 0;
3199                 pos = wpa_add_kde(pos, RSN_KEY_DATA_GROUPKEY, hdr, 2,
3200                                   gsm->GTK[gsm->GN - 1], gsm->GTK_len);
3201                 pos = ieee80211w_kde_add(sm, pos);
3202         } else {
3203                 kde = gsm->GTK[gsm->GN - 1];
3204                 pos = kde + gsm->GTK_len;
3205         }
3206
3207         wpa_send_eapol(sm->wpa_auth, sm,
3208                        WPA_KEY_INFO_SECURE | WPA_KEY_INFO_MIC |
3209                        WPA_KEY_INFO_ACK |
3210                        (!sm->Pair ? WPA_KEY_INFO_INSTALL : 0),
3211                        rsc, gsm->GNonce, kde, pos - kde, gsm->GN, 1);
3212         if (sm->wpa == WPA_VERSION_WPA2)
3213                 free(kde);
3214         sm->GTimeoutCtr++;
3215 }
3216
3217
3218 SM_STATE(WPA_PTK_GROUP, REKEYESTABLISHED)
3219 {
3220         SM_ENTRY_MA(WPA_PTK_GROUP, REKEYESTABLISHED, wpa_ptk_group);
3221         sm->EAPOLKeyReceived = FALSE;
3222         sm->GUpdateStationKeys = FALSE;
3223         sm->group->GKeyDoneStations--;
3224         sm->GTimeoutCtr = 0;
3225         /* FIX: MLME.SetProtection.Request(TA, Tx_Rx) */
3226         wpa_auth_vlogger(sm->wpa_auth, sm->addr, LOGGER_INFO,
3227                          "group key handshake completed (%s)",
3228                          sm->wpa == WPA_VERSION_WPA ? "WPA" : "RSN");
3229         sm->has_GTK = TRUE;
3230 }
3231
3232
3233 SM_STATE(WPA_PTK_GROUP, KEYERROR)
3234 {
3235         SM_ENTRY_MA(WPA_PTK_GROUP, KEYERROR, wpa_ptk_group);
3236         sm->group->GKeyDoneStations--;
3237         sm->GUpdateStationKeys = FALSE;
3238         sm->Disconnect = TRUE;
3239 }
3240
3241
3242 SM_STEP(WPA_PTK_GROUP)
3243 {
3244         if (sm->Init)
3245                 SM_ENTER(WPA_PTK_GROUP, IDLE);
3246         else switch (sm->wpa_ptk_group_state) {
3247         case WPA_PTK_GROUP_IDLE:
3248                 if (sm->GUpdateStationKeys ||
3249                     (sm->wpa == WPA_VERSION_WPA && sm->PInitAKeys))
3250                         SM_ENTER(WPA_PTK_GROUP, REKEYNEGOTIATING);
3251                 break;
3252         case WPA_PTK_GROUP_REKEYNEGOTIATING:
3253                 if (sm->EAPOLKeyReceived && !sm->EAPOLKeyRequest &&
3254                     !sm->EAPOLKeyPairwise && sm->MICVerified)
3255                         SM_ENTER(WPA_PTK_GROUP, REKEYESTABLISHED);
3256                 else if (sm->GTimeoutCtr >
3257                          (int) dot11RSNAConfigGroupUpdateCount)
3258                         SM_ENTER(WPA_PTK_GROUP, KEYERROR);
3259                 else if (sm->TimeoutEvt)
3260                         SM_ENTER(WPA_PTK_GROUP, REKEYNEGOTIATING);
3261                 break;
3262         case WPA_PTK_GROUP_KEYERROR:
3263                 SM_ENTER(WPA_PTK_GROUP, IDLE);
3264                 break;
3265         case WPA_PTK_GROUP_REKEYESTABLISHED:
3266                 SM_ENTER(WPA_PTK_GROUP, IDLE);
3267                 break;
3268         }
3269 }
3270
3271
3272 static void wpa_gtk_update(struct wpa_authenticator *wpa_auth,
3273                            struct wpa_group *group)
3274 {
3275         /* FIX: is this the correct way of getting GNonce? */
3276         memcpy(group->GNonce, group->Counter, WPA_NONCE_LEN);
3277         inc_byte_array(group->Counter, WPA_NONCE_LEN);
3278         wpa_gmk_to_gtk(group->GMK, wpa_auth->addr, group->GNonce,
3279                        group->GTK[group->GN - 1], group->GTK_len);
3280
3281 #ifdef CONFIG_IEEE80211W
3282         if (wpa_auth->conf.ieee80211w != WPA_NO_IEEE80211W) {
3283                 hostapd_get_rand(group->DGTK, WPA_DGTK_LEN);
3284                 wpa_hexdump_key(MSG_DEBUG, "DGTK", group->DGTK, WPA_DGTK_LEN);
3285                 hostapd_get_rand(group->IGTK[group->GN - 1], WPA_IGTK_LEN);
3286                 wpa_hexdump_key(MSG_DEBUG, "IGTK",
3287                                 group->IGTK[group->GN - 1], WPA_IGTK_LEN);
3288         }
3289 #endif /* CONFIG_IEEE80211W */
3290 }
3291
3292
3293 static void wpa_group_gtk_init(struct wpa_authenticator *wpa_auth,
3294                                struct wpa_group *group)
3295 {
3296         wpa_printf(MSG_DEBUG, "WPA: group state machine entering state "
3297                    "GTK_INIT (VLAN-ID %d)", group->vlan_id);
3298         group->changed = FALSE; /* GInit is not cleared here; avoid loop */
3299         group->wpa_group_state = WPA_GROUP_GTK_INIT;
3300
3301         /* GTK[0..N] = 0 */
3302         memset(group->GTK, 0, sizeof(group->GTK));
3303         group->GN = 1;
3304         group->GM = 2;
3305         /* GTK[GN] = CalcGTK() */
3306         wpa_gtk_update(wpa_auth, group);
3307 }
3308
3309
3310 static int wpa_group_update_sta(struct wpa_state_machine *sm, void *ctx)
3311 {
3312         sm->GUpdateStationKeys = TRUE;
3313         wpa_sm_step(sm);
3314         return 0;
3315 }
3316
3317
3318 static void wpa_group_setkeys(struct wpa_authenticator *wpa_auth,
3319                               struct wpa_group *group)
3320 {
3321         int tmp;
3322
3323         wpa_printf(MSG_DEBUG, "WPA: group state machine entering state "
3324                    "SETKEYS (VLAN-ID %d)", group->vlan_id);
3325         group->changed = TRUE;
3326         group->wpa_group_state = WPA_GROUP_SETKEYS;
3327         group->GTKReKey = FALSE;
3328         tmp = group->GM;
3329         group->GM = group->GN;
3330         group->GN = tmp;
3331         group->GKeyDoneStations = group->GNoStations;
3332         wpa_gtk_update(wpa_auth, group);
3333
3334         wpa_auth_for_each_sta(wpa_auth, wpa_group_update_sta, NULL);
3335 }
3336
3337
3338 static void wpa_group_setkeysdone(struct wpa_authenticator *wpa_auth,
3339                                   struct wpa_group *group)
3340 {
3341         wpa_printf(MSG_DEBUG, "WPA: group state machine entering state "
3342                    "SETKEYSDONE (VLAN-ID %d)", group->vlan_id);
3343         group->changed = TRUE;
3344         group->wpa_group_state = WPA_GROUP_SETKEYSDONE;
3345         wpa_auth_set_key(wpa_auth, group->vlan_id,
3346                          wpa_alg_txt(wpa_auth->conf.wpa_group),
3347                          NULL, group->GN, group->GTK[group->GN - 1],
3348                          group->GTK_len);
3349
3350 #ifdef CONFIG_IEEE80211W
3351         if (wpa_auth->conf.ieee80211w != WPA_NO_IEEE80211W) {
3352                 wpa_auth_set_key(wpa_auth, group->vlan_id, "IGTK",
3353                                  NULL, group->GN, group->IGTK[group->GN - 1],
3354                                  WPA_IGTK_LEN);
3355                 wpa_auth_set_key(wpa_auth, group->vlan_id, "DGTK",
3356                                  NULL, 0, group->DGTK, WPA_DGTK_LEN);
3357         }
3358 #endif /* CONFIG_IEEE80211W */
3359 }
3360
3361
3362 static void wpa_group_sm_step(struct wpa_authenticator *wpa_auth,
3363                               struct wpa_group *group)
3364 {
3365         if (group->GInit) {
3366                 wpa_group_gtk_init(wpa_auth, group);
3367         } else if (group->wpa_group_state == WPA_GROUP_GTK_INIT &&
3368                    group->GTKAuthenticator) {
3369                 wpa_group_setkeysdone(wpa_auth, group);
3370         } else if (group->wpa_group_state == WPA_GROUP_SETKEYSDONE &&
3371                    group->GTKReKey) {
3372                 wpa_group_setkeys(wpa_auth, group);
3373         } else if (group->wpa_group_state == WPA_GROUP_SETKEYS) {
3374                 if (group->GKeyDoneStations == 0)
3375                         wpa_group_setkeysdone(wpa_auth, group);
3376                 else if (group->GTKReKey)
3377                         wpa_group_setkeys(wpa_auth, group);
3378         }
3379 }
3380
3381
3382 static void wpa_sm_step(struct wpa_state_machine *sm)
3383 {
3384         if (sm == NULL)
3385                 return;
3386
3387         if (sm->in_step_loop) {
3388                 /* This should not happen, but if it does, make sure we do not
3389                  * end up freeing the state machine too early by exiting the
3390                  * recursive call. */
3391                 wpa_printf(MSG_ERROR, "WPA: wpa_sm_step() called recursively");
3392                 return;
3393         }
3394
3395         sm->in_step_loop = 1;
3396         do {
3397                 if (sm->pending_deinit)
3398                         break;
3399
3400                 sm->changed = FALSE;
3401                 sm->wpa_auth->group->changed = FALSE;
3402
3403                 SM_STEP_RUN(WPA_PTK);
3404                 if (sm->pending_deinit)
3405                         break;
3406                 SM_STEP_RUN(WPA_PTK_GROUP);
3407                 if (sm->pending_deinit)
3408                         break;
3409                 wpa_group_sm_step(sm->wpa_auth, sm->group);
3410         } while (sm->changed || sm->wpa_auth->group->changed);
3411         sm->in_step_loop = 0;
3412
3413         if (sm->pending_deinit) {
3414                 wpa_printf(MSG_DEBUG, "WPA: Completing pending STA state "
3415                            "machine deinit for " MACSTR, MAC2STR(sm->addr));
3416                 wpa_free_sta_sm(sm);
3417         }
3418 }
3419
3420
3421 static void wpa_sm_call_step(void *eloop_ctx, void *timeout_ctx)
3422 {
3423         struct wpa_state_machine *sm = eloop_ctx;
3424         wpa_sm_step(sm);
3425 }
3426
3427
3428 void wpa_auth_sm_notify(struct wpa_state_machine *sm)
3429 {
3430         if (sm == NULL)
3431                 return;
3432         eloop_register_timeout(0, 0, wpa_sm_call_step, sm, NULL);
3433 }
3434
3435
3436 void wpa_gtk_rekey(struct wpa_authenticator *wpa_auth)
3437 {
3438         int tmp, i;
3439         struct wpa_group *group;
3440
3441         if (wpa_auth == NULL)
3442                 return;
3443
3444         group = wpa_auth->group;
3445
3446         for (i = 0; i < 2; i++) {
3447                 tmp = group->GM;
3448                 group->GM = group->GN;
3449                 group->GN = tmp;
3450                 wpa_gtk_update(wpa_auth, group);
3451         }
3452 }
3453
3454
3455 static const char * wpa_bool_txt(int bool)
3456 {
3457         return bool ? "TRUE" : "FALSE";
3458 }
3459
3460
3461 static int wpa_cipher_bits(int cipher)
3462 {
3463         switch (cipher) {
3464         case WPA_CIPHER_CCMP:
3465                 return 128;
3466         case WPA_CIPHER_TKIP:
3467                 return 256;
3468         case WPA_CIPHER_WEP104:
3469                 return 104;
3470         case WPA_CIPHER_WEP40:
3471                 return 40;
3472         default:
3473                 return 0;
3474         }
3475 }
3476
3477
3478 #define RSN_SUITE "%02x-%02x-%02x-%d"
3479 #define RSN_SUITE_ARG(s) (s)[0], (s)[1], (s)[2], (s)[3]
3480
3481 int wpa_get_mib(struct wpa_authenticator *wpa_auth, char *buf, size_t buflen)
3482 {
3483         int len = 0, ret;
3484         char pmkid_txt[PMKID_LEN * 2 + 1];
3485
3486         if (wpa_auth == NULL)
3487                 return len;
3488
3489         ret = snprintf(buf + len, buflen - len,
3490                        "dot11RSNAOptionImplemented=TRUE\n"
3491 #ifdef CONFIG_RSN_PREAUTH
3492                        "dot11RSNAPreauthenticationImplemented=TRUE\n"
3493 #else /* CONFIG_RSN_PREAUTH */
3494                        "dot11RSNAPreauthenticationImplemented=FALSE\n"
3495 #endif /* CONFIG_RSN_PREAUTH */
3496                        "dot11RSNAEnabled=%s\n"
3497                        "dot11RSNAPreauthenticationEnabled=%s\n",
3498                        wpa_bool_txt(wpa_auth->conf.wpa &
3499                                     HOSTAPD_WPA_VERSION_WPA2),
3500                        wpa_bool_txt(wpa_auth->conf.rsn_preauth));
3501         if (ret < 0 || (size_t) ret >= buflen - len)
3502                 return len;
3503         len += ret;
3504
3505         wpa_snprintf_hex(pmkid_txt, sizeof(pmkid_txt),
3506                          wpa_auth->dot11RSNAPMKIDUsed, PMKID_LEN);
3507
3508         ret = snprintf(buf + len, buflen - len,
3509                        "dot11RSNAConfigVersion=%u\n"
3510                        "dot11RSNAConfigPairwiseKeysSupported=9999\n"
3511                        /* FIX: dot11RSNAConfigGroupCipher */
3512                        /* FIX: dot11RSNAConfigGroupRekeyMethod */
3513                        /* FIX: dot11RSNAConfigGroupRekeyTime */
3514                        /* FIX: dot11RSNAConfigGroupRekeyPackets */
3515                        "dot11RSNAConfigGroupRekeyStrict=%u\n"
3516                        "dot11RSNAConfigGroupUpdateCount=%u\n"
3517                        "dot11RSNAConfigPairwiseUpdateCount=%u\n"
3518                        "dot11RSNAConfigGroupCipherSize=%u\n"
3519                        "dot11RSNAConfigPMKLifetime=%u\n"
3520                        "dot11RSNAConfigPMKReauthThreshold=%u\n"
3521                        "dot11RSNAConfigNumberOfPTKSAReplayCounters=0\n"
3522                        "dot11RSNAConfigSATimeout=%u\n"
3523                        "dot11RSNAAuthenticationSuiteSelected=" RSN_SUITE "\n"
3524                        "dot11RSNAPairwiseCipherSelected=" RSN_SUITE "\n"
3525                        "dot11RSNAGroupCipherSelected=" RSN_SUITE "\n"
3526                        "dot11RSNAPMKIDUsed=%s\n"
3527                        "dot11RSNAAuthenticationSuiteRequested=" RSN_SUITE "\n"
3528                        "dot11RSNAPairwiseCipherRequested=" RSN_SUITE "\n"
3529                        "dot11RSNAGroupCipherRequested=" RSN_SUITE "\n"
3530                        "dot11RSNATKIPCounterMeasuresInvoked=%u\n"
3531                        "dot11RSNA4WayHandshakeFailures=%u\n"
3532                        "dot11RSNAConfigNumberOfGTKSAReplayCounters=0\n",
3533                        RSN_VERSION,
3534                        !!wpa_auth->conf.wpa_strict_rekey,
3535                        dot11RSNAConfigGroupUpdateCount,
3536                        dot11RSNAConfigPairwiseUpdateCount,
3537                        wpa_cipher_bits(wpa_auth->conf.wpa_group),
3538                        dot11RSNAConfigPMKLifetime,
3539                        dot11RSNAConfigPMKReauthThreshold,
3540                        dot11RSNAConfigSATimeout,
3541                        RSN_SUITE_ARG(wpa_auth->
3542                                      dot11RSNAAuthenticationSuiteSelected),
3543                        RSN_SUITE_ARG(wpa_auth->
3544                                      dot11RSNAPairwiseCipherSelected),
3545                        RSN_SUITE_ARG(wpa_auth->dot11RSNAGroupCipherSelected),
3546                        pmkid_txt,
3547                        RSN_SUITE_ARG(wpa_auth->
3548                                      dot11RSNAAuthenticationSuiteRequested),
3549                        RSN_SUITE_ARG(wpa_auth->
3550                                      dot11RSNAPairwiseCipherRequested),
3551                        RSN_SUITE_ARG(wpa_auth->dot11RSNAGroupCipherRequested),
3552                        wpa_auth->dot11RSNATKIPCounterMeasuresInvoked,
3553                        wpa_auth->dot11RSNA4WayHandshakeFailures);
3554         if (ret < 0 || (size_t) ret >= buflen - len)
3555                 return len;
3556         len += ret;
3557
3558         /* TODO: dot11RSNAConfigPairwiseCiphersTable */
3559         /* TODO: dot11RSNAConfigAuthenticationSuitesTable */
3560
3561         /* Private MIB */
3562         ret = snprintf(buf + len, buflen - len, "hostapdWPAGroupState=%d\n",
3563                        wpa_auth->group->wpa_group_state);
3564         if (ret < 0 || (size_t) ret >= buflen - len)
3565                 return len;
3566         len += ret;
3567
3568         return len;
3569 }
3570
3571
3572 int wpa_get_mib_sta(struct wpa_state_machine *sm, char *buf, size_t buflen)
3573 {
3574         int len = 0, ret;
3575         u8 not_used[4] = { 0, 0, 0, 0 };
3576         const u8 *pairwise = not_used;
3577
3578         if (sm == NULL)
3579                 return 0;
3580
3581         /* TODO: FF-FF-FF-FF-FF-FF entry for broadcast/multicast stats */
3582
3583         /* dot11RSNAStatsEntry */
3584
3585         if (sm->wpa == WPA_VERSION_WPA) {
3586                 if (sm->pairwise == WPA_CIPHER_CCMP)
3587                         pairwise = WPA_CIPHER_SUITE_CCMP;
3588                 else if (sm->pairwise == WPA_CIPHER_TKIP)
3589                         pairwise = WPA_CIPHER_SUITE_TKIP;
3590                 else if (sm->pairwise == WPA_CIPHER_WEP104)
3591                         pairwise = WPA_CIPHER_SUITE_WEP104;
3592                 else if (sm->pairwise == WPA_CIPHER_WEP40)
3593                         pairwise = WPA_CIPHER_SUITE_WEP40;
3594                 else if (sm->pairwise == WPA_CIPHER_NONE)
3595                         pairwise = WPA_CIPHER_SUITE_NONE;
3596         } else if (sm->wpa == WPA_VERSION_WPA2) {
3597                 if (sm->pairwise == WPA_CIPHER_CCMP)
3598                         pairwise = RSN_CIPHER_SUITE_CCMP;
3599                 else if (sm->pairwise == WPA_CIPHER_TKIP)
3600                         pairwise = RSN_CIPHER_SUITE_TKIP;
3601                 else if (sm->pairwise == WPA_CIPHER_WEP104)
3602                         pairwise = RSN_CIPHER_SUITE_WEP104;
3603                 else if (sm->pairwise == WPA_CIPHER_WEP40)
3604                         pairwise = RSN_CIPHER_SUITE_WEP40;
3605                 else if (sm->pairwise == WPA_CIPHER_NONE)
3606                         pairwise = RSN_CIPHER_SUITE_NONE;
3607         } else
3608                 return 0;
3609
3610         ret = snprintf(buf + len, buflen - len,
3611                        /* TODO: dot11RSNAStatsIndex */
3612                        "dot11RSNAStatsSTAAddress=" MACSTR "\n"
3613                        "dot11RSNAStatsVersion=1\n"
3614                        "dot11RSNAStatsSelectedPairwiseCipher=" RSN_SUITE "\n"
3615                        /* TODO: dot11RSNAStatsTKIPICVErrors */
3616                        "dot11RSNAStatsTKIPLocalMICFailures=%u\n"
3617                        "dot11RSNAStatsTKIPRemoveMICFailures=%u\n"
3618                        /* TODO: dot11RSNAStatsCCMPReplays */
3619                        /* TODO: dot11RSNAStatsCCMPDecryptErrors */
3620                        /* TODO: dot11RSNAStatsTKIPReplays */,
3621                        MAC2STR(sm->addr),
3622                        RSN_SUITE_ARG(pairwise),
3623                        sm->dot11RSNAStatsTKIPLocalMICFailures,
3624                        sm->dot11RSNAStatsTKIPRemoteMICFailures);
3625         if (ret < 0 || (size_t) ret >= buflen - len)
3626                 return len;
3627         len += ret;
3628
3629         /* Private MIB */
3630         ret = snprintf(buf + len, buflen - len,
3631                        "hostapdWPAPTKState=%d\n"
3632                        "hostapdWPAPTKGroupState=%d\n",
3633                        sm->wpa_ptk_state,
3634                        sm->wpa_ptk_group_state);
3635         if (ret < 0 || (size_t) ret >= buflen - len)
3636                 return len;
3637         len += ret;
3638
3639         return len;
3640 }
3641
3642
3643 void wpa_auth_countermeasures_start(struct wpa_authenticator *wpa_auth)
3644 {
3645         if (wpa_auth)
3646                 wpa_auth->dot11RSNATKIPCounterMeasuresInvoked++;
3647 }
3648
3649
3650 int wpa_auth_pairwise_set(struct wpa_state_machine *sm)
3651 {
3652         return sm && sm->pairwise_set;
3653 }
3654
3655
3656 int wpa_auth_sta_key_mgmt(struct wpa_state_machine *sm)
3657 {
3658         if (sm == NULL)
3659                 return -1;
3660         return sm->wpa_key_mgmt;
3661 }
3662
3663
3664 int wpa_auth_sta_wpa_version(struct wpa_state_machine *sm)
3665 {
3666         if (sm == NULL)
3667                 return 0;
3668         return sm->wpa;
3669 }
3670
3671
3672 int wpa_auth_sta_clear_pmksa(struct wpa_state_machine *sm,
3673                              struct rsn_pmksa_cache_entry *entry)
3674 {
3675         if (sm == NULL || sm->pmksa != entry)
3676                 return -1;
3677         sm->pmksa = NULL;
3678         return 0;
3679 }
3680
3681
3682 struct rsn_pmksa_cache_entry *
3683 wpa_auth_sta_get_pmksa(struct wpa_state_machine *sm)
3684 {
3685         return sm ? sm->pmksa : NULL;
3686 }
3687
3688
3689 void wpa_auth_sta_local_mic_failure_report(struct wpa_state_machine *sm)
3690 {
3691         if (sm)
3692                 sm->dot11RSNAStatsTKIPLocalMICFailures++;
3693 }
3694
3695
3696 const u8 * wpa_auth_get_wpa_ie(struct wpa_authenticator *wpa_auth, size_t *len)
3697 {
3698         if (wpa_auth == NULL)
3699                 return NULL;
3700         *len = wpa_auth->wpa_ie_len;
3701         return wpa_auth->wpa_ie;
3702 }
3703
3704
3705 int wpa_auth_pmksa_add(struct wpa_state_machine *sm, const u8 *pmk,
3706                        int session_timeout, struct eapol_state_machine *eapol)
3707 {
3708         if (sm == NULL || sm->wpa != WPA_VERSION_WPA2)
3709                 return -1;
3710
3711         if (pmksa_cache_add(sm->wpa_auth->pmksa, pmk, WPA_PMK_LEN,
3712                             sm->wpa_auth->addr, sm->addr, session_timeout,
3713                             eapol))
3714                 return 0;
3715
3716         return -1;
3717 }
3718
3719
3720 int wpa_auth_pmksa_add_preauth(struct wpa_authenticator *wpa_auth,
3721                                const u8 *pmk, size_t len, const u8 *sta_addr,
3722                                int session_timeout,
3723                                struct eapol_state_machine *eapol)
3724 {
3725         if (wpa_auth == NULL)
3726                 return -1;
3727
3728         if (pmksa_cache_add(wpa_auth->pmksa, pmk, len, wpa_auth->addr,
3729                             sta_addr, session_timeout, eapol))
3730                 return 0;
3731
3732         return -1;
3733 }
3734
3735
3736 static struct wpa_group *
3737 wpa_auth_add_group(struct wpa_authenticator *wpa_auth, int vlan_id)
3738 {
3739         struct wpa_group *group;
3740
3741         if (wpa_auth == NULL || wpa_auth->group == NULL)
3742                 return NULL;
3743
3744         wpa_printf(MSG_DEBUG, "WPA: Add group state machine for VLAN-ID %d",
3745                    vlan_id);
3746         group = wpa_group_init(wpa_auth, vlan_id);
3747         if (group == NULL)
3748                 return NULL;
3749
3750         group->next = wpa_auth->group->next;
3751         wpa_auth->group->next = group;
3752
3753         return group;
3754 }
3755
3756
3757 int wpa_auth_sta_set_vlan(struct wpa_state_machine *sm, int vlan_id)
3758 {
3759         struct wpa_group *group;
3760
3761         if (sm == NULL || sm->wpa_auth == NULL)
3762                 return 0;
3763
3764         group = sm->wpa_auth->group;
3765         while (group) {
3766                 if (group->vlan_id == vlan_id)
3767                         break;
3768                 group = group->next;
3769         }
3770
3771         if (group == NULL) {
3772                 group = wpa_auth_add_group(sm->wpa_auth, vlan_id);
3773                 if (group == NULL)
3774                         return -1;
3775         }
3776
3777         if (sm->group == group)
3778                 return 0;
3779
3780         wpa_printf(MSG_DEBUG, "WPA: Moving STA " MACSTR " to use group state "
3781                    "machine for VLAN ID %d", MAC2STR(sm->addr), vlan_id);
3782
3783         if (sm->group && sm->group != group && sm->sta_counted) {
3784                 sm->group->GNoStations--;
3785                 sm->sta_counted = 0;
3786                 wpa_printf(MSG_DEBUG, "WLA: Decreased GNoStations for the "
3787                            "previously used group state machine");
3788         }
3789
3790         sm->group = group;
3791         return 0;
3792 }
3793
3794 #endif /* CONFIG_NATIVE_WINDOWS */