contrib/wpa_supplicant-0.5.8/wpa.c

   1 /*
   2  * WPA Supplicant - WPA state machine and EAPOL-Key processing
   3  * Copyright (c) 2003-2006, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16
  17 #include "common.h"
  18 #include "md5.h"
  19 #include "sha1.h"
  20 #include "rc4.h"
  21 #include "aes_wrap.h"
  22 #include "wpa.h"
  23 #include "eloop.h"
  24 #include "config.h"
  25 #include "l2_packet.h"
  26 #include "eapol_sm.h"
  27 #include "preauth.h"
  28 #include "pmksa_cache.h"
  29 #include "wpa_i.h"
  30
  31
  32 static const int WPA_SELECTOR_LEN = 4;
  33 static const u8 WPA_OUI_TYPE[] = { 0x00, 0x50, 0xf2, 1 };
  34 static const u16 WPA_VERSION = 1;
  35 static const u8 WPA_AUTH_KEY_MGMT_NONE[] = { 0x00, 0x50, 0xf2, 0 };
  36 static const u8 WPA_AUTH_KEY_MGMT_UNSPEC_802_1X[] = { 0x00, 0x50, 0xf2, 1 };
  37 static const u8 WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X[] = { 0x00, 0x50, 0xf2, 2 };
  38 static const u8 WPA_CIPHER_SUITE_NONE[] = { 0x00, 0x50, 0xf2, 0 };
  39 static const u8 WPA_CIPHER_SUITE_WEP40[] = { 0x00, 0x50, 0xf2, 1 };
  40 static const u8 WPA_CIPHER_SUITE_TKIP[] = { 0x00, 0x50, 0xf2, 2 };
  41 #if 0
  42 static const u8 WPA_CIPHER_SUITE_WRAP[] = { 0x00, 0x50, 0xf2, 3 };
  43 #endif
  44 static const u8 WPA_CIPHER_SUITE_CCMP[] = { 0x00, 0x50, 0xf2, 4 };
  45 static const u8 WPA_CIPHER_SUITE_WEP104[] = { 0x00, 0x50, 0xf2, 5 };
  46
  47 /* WPA IE version 1
  48  * 00-50-f2:1 (OUI:OUI type)
  49  * 0x01 0x00 (version; little endian)
  50  * (all following fields are optional:)
  51  * Group Suite Selector (4 octets) (default: TKIP)
  52  * Pairwise Suite Count (2 octets, little endian) (default: 1)
  53  * Pairwise Suite List (4 * n octets) (default: TKIP)
  54  * Authenticated Key Management Suite Count (2 octets, little endian)
  55  *    (default: 1)
  56  * Authenticated Key Management Suite List (4 * n octets)
  57  *    (default: unspec 802.1X)
  58  * WPA Capabilities (2 octets, little endian) (default: 0)
  59  */
  60
  61 #ifdef _MSC_VER
  62 #pragma pack(push, 1)
  63 #endif /* _MSC_VER */
  64
  65 struct wpa_ie_hdr {
  66         u8 elem_id;
  67         u8 len;
  68         u8 oui[3];
  69         u8 oui_type;
  70         u8 version[2];
  71 } STRUCT_PACKED;
  72
  73 #ifdef _MSC_VER
  74 #pragma pack(pop)
  75 #endif /* _MSC_VER */
  76
  77
  78 static const int RSN_SELECTOR_LEN = 4;
  79 static const u16 RSN_VERSION = 1;
  80 static const u8 RSN_AUTH_KEY_MGMT_UNSPEC_802_1X[] = { 0x00, 0x0f, 0xac, 1 };
  81 static const u8 RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X[] = { 0x00, 0x0f, 0xac, 2 };
  82 static const u8 RSN_CIPHER_SUITE_NONE[] = { 0x00, 0x0f, 0xac, 0 };
  83 static const u8 RSN_CIPHER_SUITE_WEP40[] = { 0x00, 0x0f, 0xac, 1 };
  84 static const u8 RSN_CIPHER_SUITE_TKIP[] = { 0x00, 0x0f, 0xac, 2 };
  85 #if 0
  86 static const u8 RSN_CIPHER_SUITE_WRAP[] = { 0x00, 0x0f, 0xac, 3 };
  87 #endif
  88 static const u8 RSN_CIPHER_SUITE_CCMP[] = { 0x00, 0x0f, 0xac, 4 };
  89 static const u8 RSN_CIPHER_SUITE_WEP104[] = { 0x00, 0x0f, 0xac, 5 };
  90 #ifdef CONFIG_IEEE80211W
  91 static const u8 RSN_CIPHER_SUITE_AES_128_CMAC[] = { 0x00, 0x0f, 0xac, 6 };
  92 #endif /* CONFIG_IEEE80211W */
  93
  94 /* EAPOL-Key Key Data Encapsulation
  95  * GroupKey and PeerKey require encryption, otherwise, encryption is optional.
  96  */
  97 static const u8 RSN_KEY_DATA_GROUPKEY[] = { 0x00, 0x0f, 0xac, 1 };
  98 #if 0
  99 static const u8 RSN_KEY_DATA_STAKEY[] = { 0x00, 0x0f, 0xac, 2 };
 100 #endif
 101 static const u8 RSN_KEY_DATA_MAC_ADDR[] = { 0x00, 0x0f, 0xac, 3 };
 102 static const u8 RSN_KEY_DATA_PMKID[] = { 0x00, 0x0f, 0xac, 4 };
 103 #ifdef CONFIG_PEERKEY
 104 static const u8 RSN_KEY_DATA_SMK[] = { 0x00, 0x0f, 0xac, 5 };
 105 static const u8 RSN_KEY_DATA_NONCE[] = { 0x00, 0x0f, 0xac, 6 };
 106 static const u8 RSN_KEY_DATA_LIFETIME[] = { 0x00, 0x0f, 0xac, 7 };
 107 static const u8 RSN_KEY_DATA_ERROR[] = { 0x00, 0x0f, 0xac, 8 };
 108 #endif /* CONFIG_PEERKEY */
 109 #ifdef CONFIG_IEEE80211W
 110 /* FIX: IEEE 802.11w/D1.0 is using subtypes 5 and 6 for these, but they were
 111  * already taken by 802.11ma (PeerKey). Need to update the values here once
 112  * IEEE 802.11w fixes these. */
 113 static const u8 RSN_KEY_DATA_DHV[] = { 0x00, 0x0f, 0xac, 9 };
 114 static const u8 RSN_KEY_DATA_IGTK[] = { 0x00, 0x0f, 0xac, 10 };
 115 #endif /* CONFIG_IEEE80211W */
 116
 117 #ifdef CONFIG_PEERKEY
 118 enum {
 119         STK_MUI_4WAY_STA_AP = 1,
 120         STK_MUI_4WAY_STAT_STA = 2,
 121         STK_MUI_GTK = 3,
 122         STK_MUI_SMK = 4
 123 };
 124
 125 enum {
 126         STK_ERR_STA_NR = 1,
 127         STK_ERR_STA_NRSN = 2,
 128         STK_ERR_CPHR_NS = 3,
 129         STK_ERR_NO_STSL = 4
 130 };
 131 #endif /* CONFIG_PEERKEY */
 132
 133 /* 1/4: PMKID
 134  * 2/4: RSN IE
 135  * 3/4: one or two RSN IEs + GTK IE (encrypted)
 136  * 4/4: empty
 137  * 1/2: GTK IE (encrypted)
 138  * 2/2: empty
 139  */
 140
 141 /* RSN IE version 1
 142  * 0x01 0x00 (version; little endian)
 143  * (all following fields are optional:)
 144  * Group Suite Selector (4 octets) (default: CCMP)
 145  * Pairwise Suite Count (2 octets, little endian) (default: 1)
 146  * Pairwise Suite List (4 * n octets) (default: CCMP)
 147  * Authenticated Key Management Suite Count (2 octets, little endian)
 148  *    (default: 1)
 149  * Authenticated Key Management Suite List (4 * n octets)
 150  *    (default: unspec 802.1X)
 151  * RSN Capabilities (2 octets, little endian) (default: 0)
 152  * PMKID Count (2 octets) (default: 0)
 153  * PMKID List (16 * n octets)
 154  * Management Group Cipher Suite (4 octets) (default: AES-128-CMAC)
 155  */
 156
 157 #ifdef _MSC_VER
 158 #pragma pack(push, 1)
 159 #endif /* _MSC_VER */
 160
 161 struct rsn_ie_hdr {
 162         u8 elem_id; /* WLAN_EID_RSN */
 163         u8 len;
 164         u8 version[2];
 165 } STRUCT_PACKED;
 166
 167
 168 struct wpa_eapol_key {
 169         u8 type;
 170         /* Note: key_info, key_length, and key_data_length are unaligned */
 171         u8 key_info[2];
 172         u8 key_length[2];
 173         u8 replay_counter[WPA_REPLAY_COUNTER_LEN];
 174         u8 key_nonce[WPA_NONCE_LEN];
 175         u8 key_iv[16];
 176         u8 key_rsc[8];
 177         u8 key_id[8]; /* Reserved in IEEE 802.11i/RSN */
 178         u8 key_mic[16];
 179         u8 key_data_length[2];
 180         /* followed by key_data_length bytes of key_data */
 181 } STRUCT_PACKED;
 182
 183
 184 struct rsn_error_kde {
 185         u16 mui;
 186         u16 error_type;
 187 } STRUCT_PACKED;
 188
 189 #ifdef CONFIG_IEEE80211W
 190 struct wpa_dhv_kde {
 191         u8 dhv[WPA_DHV_LEN];
 192 } STRUCT_PACKED;
 193
 194 struct wpa_igtk_kde {
 195         u8 keyid[2];
 196         u8 pn[6];
 197         u8 igtk[WPA_IGTK_LEN];
 198 } STRUCT_PACKED;
 199 #endif /* CONFIG_IEEE80211W */
 200
 201 #ifdef _MSC_VER
 202 #pragma pack(pop)
 203 #endif /* _MSC_VER */
 204
 205 #define WPA_KEY_INFO_TYPE_MASK ((u16) (BIT(0) | BIT(1) | BIT(2)))
 206 #define WPA_KEY_INFO_TYPE_HMAC_MD5_RC4 BIT(0)
 207 #define WPA_KEY_INFO_TYPE_HMAC_SHA1_AES BIT(1)
 208 #define WPA_KEY_INFO_KEY_TYPE BIT(3) /* 1 = Pairwise, 0 = Group key */
 209 /* bit4..5 is used in WPA, but is reserved in IEEE 802.11i/RSN */
 210 #define WPA_KEY_INFO_KEY_INDEX_MASK (BIT(4) | BIT(5))
 211 #define WPA_KEY_INFO_KEY_INDEX_SHIFT 4
 212 #define WPA_KEY_INFO_INSTALL BIT(6) /* pairwise */
 213 #define WPA_KEY_INFO_TXRX BIT(6) /* group */
 214 #define WPA_KEY_INFO_ACK BIT(7)
 215 #define WPA_KEY_INFO_MIC BIT(8)
 216 #define WPA_KEY_INFO_SECURE BIT(9)
 217 #define WPA_KEY_INFO_ERROR BIT(10)
 218 #define WPA_KEY_INFO_REQUEST BIT(11)
 219 #define WPA_KEY_INFO_ENCR_KEY_DATA BIT(12) /* IEEE 802.11i/RSN only */
 220 #define WPA_KEY_INFO_SMK_MESSAGE BIT(13)
 221
 222
 223 #ifdef CONFIG_PEERKEY
 224 static void wpa_supplicant_peerkey_free(struct wpa_sm *sm,
 225                                         struct wpa_peerkey *peerkey);
 226 #endif /* CONFIG_PEERKEY */
 227
 228
 229 /**
 230  * wpa_cipher_txt - Convert cipher suite to a text string
 231  * @cipher: Cipher suite (WPA_CIPHER_* enum)
 232  * Returns: Pointer to a text string of the cipher suite name
 233  */
 234 static const char * wpa_cipher_txt(int cipher)
 235 {
 236         switch (cipher) {
 237         case WPA_CIPHER_NONE:
 238                 return "NONE";
 239         case WPA_CIPHER_WEP40:
 240                 return "WEP-40";
 241         case WPA_CIPHER_WEP104:
 242                 return "WEP-104";
 243         case WPA_CIPHER_TKIP:
 244                 return "TKIP";
 245         case WPA_CIPHER_CCMP:
 246                 return "CCMP";
 247         default:
 248                 return "UNKNOWN";
 249         }
 250 }
 251
 252
 253 /**
 254  * wpa_key_mgmt_txt - Convert key management suite to a text string
 255  * @key_mgmt: Key management suite (WPA_KEY_MGMT_* enum)
 256  * @proto: WPA/WPA2 version (WPA_PROTO_*)
 257  * Returns: Pointer to a text string of the key management suite name
 258  */
 259 static const char * wpa_key_mgmt_txt(int key_mgmt, int proto)
 260 {
 261         switch (key_mgmt) {
 262         case WPA_KEY_MGMT_IEEE8021X:
 263                 return proto == WPA_PROTO_RSN ?
 264                         "WPA2/IEEE 802.1X/EAP" : "WPA/IEEE 802.1X/EAP";
 265         case WPA_KEY_MGMT_PSK:
 266                 return proto == WPA_PROTO_RSN ?
 267                         "WPA2-PSK" : "WPA-PSK";
 268         case WPA_KEY_MGMT_NONE:
 269                 return "NONE";
 270         case WPA_KEY_MGMT_IEEE8021X_NO_WPA:
 271                 return "IEEE 802.1X (no WPA)";
 272         default:
 273                 return "UNKNOWN";
 274         }
 275 }
 276
 277
 278 static int wpa_selector_to_bitfield(const u8 *s)
 279 {
 280         if (os_memcmp(s, WPA_CIPHER_SUITE_NONE, WPA_SELECTOR_LEN) == 0)
 281                 return WPA_CIPHER_NONE;
 282         if (os_memcmp(s, WPA_CIPHER_SUITE_WEP40, WPA_SELECTOR_LEN) == 0)
 283                 return WPA_CIPHER_WEP40;
 284         if (os_memcmp(s, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN) == 0)
 285                 return WPA_CIPHER_TKIP;
 286         if (os_memcmp(s, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN) == 0)
 287                 return WPA_CIPHER_CCMP;
 288         if (os_memcmp(s, WPA_CIPHER_SUITE_WEP104, WPA_SELECTOR_LEN) == 0)
 289                 return WPA_CIPHER_WEP104;
 290         return 0;
 291 }
 292
 293
 294 static int wpa_key_mgmt_to_bitfield(const u8 *s)
 295 {
 296         if (os_memcmp(s, WPA_AUTH_KEY_MGMT_UNSPEC_802_1X, WPA_SELECTOR_LEN) ==
 297             0)
 298                 return WPA_KEY_MGMT_IEEE8021X;
 299         if (os_memcmp(s, WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X, WPA_SELECTOR_LEN)
 300             == 0)
 301                 return WPA_KEY_MGMT_PSK;
 302         if (os_memcmp(s, WPA_AUTH_KEY_MGMT_NONE, WPA_SELECTOR_LEN) == 0)
 303                 return WPA_KEY_MGMT_WPA_NONE;
 304         return 0;
 305 }
 306
 307
 308 #ifndef CONFIG_NO_WPA2
 309 static int rsn_selector_to_bitfield(const u8 *s)
 310 {
 311         if (os_memcmp(s, RSN_CIPHER_SUITE_NONE, RSN_SELECTOR_LEN) == 0)
 312                 return WPA_CIPHER_NONE;
 313         if (os_memcmp(s, RSN_CIPHER_SUITE_WEP40, RSN_SELECTOR_LEN) == 0)
 314                 return WPA_CIPHER_WEP40;
 315         if (os_memcmp(s, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN) == 0)
 316                 return WPA_CIPHER_TKIP;
 317         if (os_memcmp(s, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN) == 0)
 318                 return WPA_CIPHER_CCMP;
 319         if (os_memcmp(s, RSN_CIPHER_SUITE_WEP104, RSN_SELECTOR_LEN) == 0)
 320                 return WPA_CIPHER_WEP104;
 321 #ifdef CONFIG_IEEE80211W
 322         if (os_memcmp(s, RSN_CIPHER_SUITE_AES_128_CMAC, RSN_SELECTOR_LEN) == 0)
 323                 return WPA_CIPHER_AES_128_CMAC;
 324 #endif /* CONFIG_IEEE80211W */
 325         return 0;
 326 }
 327
 328
 329 static int rsn_key_mgmt_to_bitfield(const u8 *s)
 330 {
 331         if (os_memcmp(s, RSN_AUTH_KEY_MGMT_UNSPEC_802_1X, RSN_SELECTOR_LEN) ==
 332             0)
 333                 return WPA_KEY_MGMT_IEEE8021X;
 334         if (os_memcmp(s, RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X, RSN_SELECTOR_LEN)
 335             == 0)
 336                 return WPA_KEY_MGMT_PSK;
 337         return 0;
 338 }
 339 #endif /* CONFIG_NO_WPA2 */
 340
 341
 342 #ifdef CONFIG_PEERKEY
 343 static u8 * wpa_add_ie(u8 *pos, const u8 *ie, size_t ie_len)
 344 {
 345         os_memcpy(pos, ie, ie_len);
 346         return pos + ie_len;
 347 }
 348
 349
 350 static u8 * wpa_add_kde(u8 *pos, const u8 *kde, const u8 *data,
 351                         size_t data_len)
 352 {
 353         *pos++ = GENERIC_INFO_ELEM;
 354         *pos++ = RSN_SELECTOR_LEN + data_len;
 355         os_memcpy(pos, kde, RSN_SELECTOR_LEN);
 356         pos += RSN_SELECTOR_LEN;
 357         os_memcpy(pos, data, data_len);
 358         pos += data_len;
 359         return pos;
 360 }
 361 #endif /* CONFIG_PEERKEY */
 362
 363
 364 static int wpa_parse_wpa_ie_wpa(const u8 *wpa_ie, size_t wpa_ie_len,
 365                                 struct wpa_ie_data *data)
 366 {
 367         const struct wpa_ie_hdr *hdr;
 368         const u8 *pos;
 369         int left;
 370         int i, count;
 371
 372         data->proto = WPA_PROTO_WPA;
 373         data->pairwise_cipher = WPA_CIPHER_TKIP;
 374         data->group_cipher = WPA_CIPHER_TKIP;
 375         data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
 376         data->capabilities = 0;
 377         data->pmkid = NULL;
 378         data->num_pmkid = 0;
 379         data->mgmt_group_cipher = 0;
 380
 381         if (wpa_ie_len == 0) {
 382                 /* No WPA IE - fail silently */
 383                 return -1;
 384         }
 385
 386         if (wpa_ie_len < sizeof(struct wpa_ie_hdr)) {
 387                 wpa_printf(MSG_DEBUG, "%s: ie len too short %lu",
 388                            __func__, (unsigned long) wpa_ie_len);
 389                 return -1;
 390         }
 391
 392         hdr = (const struct wpa_ie_hdr *) wpa_ie;
 393
 394         if (hdr->elem_id != GENERIC_INFO_ELEM ||
 395             hdr->len != wpa_ie_len - 2 ||
 396             os_memcmp(hdr->oui, WPA_OUI_TYPE, WPA_SELECTOR_LEN) != 0 ||
 397             WPA_GET_LE16(hdr->version) != WPA_VERSION) {
 398                 wpa_printf(MSG_DEBUG, "%s: malformed ie or unknown version",
 399                            __func__);
 400                 return -1;
 401         }
 402
 403         pos = (const u8 *) (hdr + 1);
 404         left = wpa_ie_len - sizeof(*hdr);
 405
 406         if (left >= WPA_SELECTOR_LEN) {
 407                 data->group_cipher = wpa_selector_to_bitfield(pos);
 408                 pos += WPA_SELECTOR_LEN;
 409                 left -= WPA_SELECTOR_LEN;
 410         } else if (left > 0) {
 411                 wpa_printf(MSG_DEBUG, "%s: ie length mismatch, %u too much",
 412                            __func__, left);
 413                 return -1;
 414         }
 415
 416         if (left >= 2) {
 417                 data->pairwise_cipher = 0;
 418                 count = WPA_GET_LE16(pos);
 419                 pos += 2;
 420                 left -= 2;
 421                 if (count == 0 || left < count * WPA_SELECTOR_LEN) {
 422                         wpa_printf(MSG_DEBUG, "%s: ie count botch (pairwise), "
 423                                    "count %u left %u", __func__, count, left);
 424                         return -1;
 425                 }
 426                 for (i = 0; i < count; i++) {
 427                         data->pairwise_cipher |= wpa_selector_to_bitfield(pos);
 428                         pos += WPA_SELECTOR_LEN;
 429                         left -= WPA_SELECTOR_LEN;
 430                 }
 431         } else if (left == 1) {
 432                 wpa_printf(MSG_DEBUG, "%s: ie too short (for key mgmt)",
 433                            __func__);
 434                 return -1;
 435         }
 436
 437         if (left >= 2) {
 438                 data->key_mgmt = 0;
 439                 count = WPA_GET_LE16(pos);
 440                 pos += 2;
 441                 left -= 2;
 442                 if (count == 0 || left < count * WPA_SELECTOR_LEN) {
 443                         wpa_printf(MSG_DEBUG, "%s: ie count botch (key mgmt), "
 444                                    "count %u left %u", __func__, count, left);
 445                         return -1;
 446                 }
 447                 for (i = 0; i < count; i++) {
 448                         data->key_mgmt |= wpa_key_mgmt_to_bitfield(pos);
 449                         pos += WPA_SELECTOR_LEN;
 450                         left -= WPA_SELECTOR_LEN;
 451                 }
 452         } else if (left == 1) {
 453                 wpa_printf(MSG_DEBUG, "%s: ie too short (for capabilities)",
 454                            __func__);
 455                 return -1;
 456         }
 457
 458         if (left >= 2) {
 459                 data->capabilities = WPA_GET_LE16(pos);
 460                 pos += 2;
 461                 left -= 2;
 462         }
 463
 464         if (left > 0) {
 465                 wpa_printf(MSG_DEBUG, "%s: ie has %u trailing bytes - ignored",
 466                            __func__, left);
 467         }
 468
 469         return 0;
 470 }
 471
 472
 473 static int wpa_parse_wpa_ie_rsn(const u8 *rsn_ie, size_t rsn_ie_len,
 474                                 struct wpa_ie_data *data)
 475 {
 476 #ifndef CONFIG_NO_WPA2
 477         const struct rsn_ie_hdr *hdr;
 478         const u8 *pos;
 479         int left;
 480         int i, count;
 481
 482         data->proto = WPA_PROTO_RSN;
 483         data->pairwise_cipher = WPA_CIPHER_CCMP;
 484         data->group_cipher = WPA_CIPHER_CCMP;
 485         data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
 486         data->capabilities = 0;
 487         data->pmkid = NULL;
 488         data->num_pmkid = 0;
 489 #ifdef CONFIG_IEEE80211W
 490         data->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
 491 #else /* CONFIG_IEEE80211W */
 492         data->mgmt_group_cipher = 0;
 493 #endif /* CONFIG_IEEE80211W */
 494
 495
 496         if (rsn_ie_len == 0) {
 497                 /* No RSN IE - fail silently */
 498                 return -1;
 499         }
 500
 501         if (rsn_ie_len < sizeof(struct rsn_ie_hdr)) {
 502                 wpa_printf(MSG_DEBUG, "%s: ie len too short %lu",
 503                            __func__, (unsigned long) rsn_ie_len);
 504                 return -1;
 505         }
 506
 507         hdr = (const struct rsn_ie_hdr *) rsn_ie;
 508
 509         if (hdr->elem_id != RSN_INFO_ELEM ||
 510             hdr->len != rsn_ie_len - 2 ||
 511             WPA_GET_LE16(hdr->version) != RSN_VERSION) {
 512                 wpa_printf(MSG_DEBUG, "%s: malformed ie or unknown version",
 513                            __func__);
 514                 return -1;
 515         }
 516
 517         pos = (const u8 *) (hdr + 1);
 518         left = rsn_ie_len - sizeof(*hdr);
 519
 520         if (left >= RSN_SELECTOR_LEN) {
 521                 data->group_cipher = rsn_selector_to_bitfield(pos);
 522 #ifdef CONFIG_IEEE80211W
 523                 if (data->group_cipher == WPA_CIPHER_AES_128_CMAC) {
 524                         wpa_printf(MSG_DEBUG, "%s: AES-128-CMAC used as group "
 525                                    "cipher", __func__);
 526                         return -1;
 527                 }
 528 #endif /* CONFIG_IEEE80211W */
 529                 pos += RSN_SELECTOR_LEN;
 530                 left -= RSN_SELECTOR_LEN;
 531         } else if (left > 0) {
 532                 wpa_printf(MSG_DEBUG, "%s: ie length mismatch, %u too much",
 533                            __func__, left);
 534                 return -1;
 535         }
 536
 537         if (left >= 2) {
 538                 data->pairwise_cipher = 0;
 539                 count = WPA_GET_LE16(pos);
 540                 pos += 2;
 541                 left -= 2;
 542                 if (count == 0 || left < count * RSN_SELECTOR_LEN) {
 543                         wpa_printf(MSG_DEBUG, "%s: ie count botch (pairwise), "
 544                                    "count %u left %u", __func__, count, left);
 545                         return -1;
 546                 }
 547                 for (i = 0; i < count; i++) {
 548                         data->pairwise_cipher |= rsn_selector_to_bitfield(pos);
 549                         pos += RSN_SELECTOR_LEN;
 550                         left -= RSN_SELECTOR_LEN;
 551                 }
 552 #ifdef CONFIG_IEEE80211W
 553                 if (data->pairwise_cipher & WPA_CIPHER_AES_128_CMAC) {
 554                         wpa_printf(MSG_DEBUG, "%s: AES-128-CMAC used as "
 555                                    "pairwise cipher", __func__);
 556                         return -1;
 557                 }
 558 #endif /* CONFIG_IEEE80211W */
 559         } else if (left == 1) {
 560                 wpa_printf(MSG_DEBUG, "%s: ie too short (for key mgmt)",
 561                            __func__);
 562                 return -1;
 563         }
 564
 565         if (left >= 2) {
 566                 data->key_mgmt = 0;
 567                 count = WPA_GET_LE16(pos);
 568                 pos += 2;
 569                 left -= 2;
 570                 if (count == 0 || left < count * RSN_SELECTOR_LEN) {
 571                         wpa_printf(MSG_DEBUG, "%s: ie count botch (key mgmt), "
 572                                    "count %u left %u", __func__, count, left);
 573                         return -1;
 574                 }
 575                 for (i = 0; i < count; i++) {
 576                         data->key_mgmt |= rsn_key_mgmt_to_bitfield(pos);
 577                         pos += RSN_SELECTOR_LEN;
 578                         left -= RSN_SELECTOR_LEN;
 579                 }
 580         } else if (left == 1) {
 581                 wpa_printf(MSG_DEBUG, "%s: ie too short (for capabilities)",
 582                            __func__);
 583                 return -1;
 584         }
 585
 586         if (left >= 2) {
 587                 data->capabilities = WPA_GET_LE16(pos);
 588                 pos += 2;
 589                 left -= 2;
 590         }
 591
 592         if (left >= 2) {
 593                 data->num_pmkid = WPA_GET_LE16(pos);
 594                 pos += 2;
 595                 left -= 2;
 596                 if (left < data->num_pmkid * PMKID_LEN) {
 597                         wpa_printf(MSG_DEBUG, "%s: PMKID underflow "
 598                                    "(num_pmkid=%d left=%d)",
 599                                    __func__, data->num_pmkid, left);
 600                         data->num_pmkid = 0;
 601                 } else {
 602                         data->pmkid = pos;
 603                         pos += data->num_pmkid * PMKID_LEN;
 604                         left -= data->num_pmkid * PMKID_LEN;
 605                 }
 606         }
 607
 608 #ifdef CONFIG_IEEE80211W
 609         if (left >= 4) {
 610                 data->mgmt_group_cipher = rsn_selector_to_bitfield(pos);
 611                 if (data->mgmt_group_cipher != WPA_CIPHER_AES_128_CMAC) {
 612                         wpa_printf(MSG_DEBUG, "%s: Unsupported management "
 613                                    "group cipher 0x%x", __func__,
 614                                    data->mgmt_group_cipher);
 615                         return -1;
 616                 }
 617                 pos += RSN_SELECTOR_LEN;
 618                 left -= RSN_SELECTOR_LEN;
 619         }
 620 #endif /* CONFIG_IEEE80211W */
 621
 622         if (left > 0) {
 623                 wpa_printf(MSG_DEBUG, "%s: ie has %u trailing bytes - ignored",
 624                            __func__, left);
 625         }
 626
 627         return 0;
 628 #else /* CONFIG_NO_WPA2 */
 629         return -1;
 630 #endif /* CONFIG_NO_WPA2 */
 631 }
 632
 633
 634 /**
 635  * wpa_parse_wpa_ie - Parse WPA/RSN IE
 636  * @wpa_ie: Pointer to WPA or RSN IE
 637  * @wpa_ie_len: Length of the WPA/RSN IE
 638  * @data: Pointer to data area for parsing results
 639  * Returns: 0 on success, -1 on failure
 640  *
 641  * Parse the contents of WPA or RSN IE and write the parsed data into data.
 642  */
 643 int wpa_parse_wpa_ie(const u8 *wpa_ie, size_t wpa_ie_len,
 644                      struct wpa_ie_data *data)
 645 {
 646         if (wpa_ie_len >= 1 && wpa_ie[0] == RSN_INFO_ELEM)
 647                 return wpa_parse_wpa_ie_rsn(wpa_ie, wpa_ie_len, data);
 648         else
 649                 return wpa_parse_wpa_ie_wpa(wpa_ie, wpa_ie_len, data);
 650 }
 651
 652
 653 static int wpa_gen_wpa_ie_wpa(u8 *wpa_ie, size_t wpa_ie_len,
 654                               int pairwise_cipher, int group_cipher,
 655                               int key_mgmt)
 656 {
 657         u8 *pos;
 658         struct wpa_ie_hdr *hdr;
 659
 660         if (wpa_ie_len < sizeof(*hdr) + WPA_SELECTOR_LEN +
 661             2 + WPA_SELECTOR_LEN + 2 + WPA_SELECTOR_LEN)
 662                 return -1;
 663
 664         hdr = (struct wpa_ie_hdr *) wpa_ie;
 665         hdr->elem_id = GENERIC_INFO_ELEM;
 666         os_memcpy(hdr->oui, WPA_OUI_TYPE, WPA_SELECTOR_LEN);
 667         WPA_PUT_LE16(hdr->version, WPA_VERSION);
 668         pos = (u8 *) (hdr + 1);
 669
 670         if (group_cipher == WPA_CIPHER_CCMP) {
 671                 os_memcpy(pos, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN);
 672         } else if (group_cipher == WPA_CIPHER_TKIP) {
 673                 os_memcpy(pos, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN);
 674         } else if (group_cipher == WPA_CIPHER_WEP104) {
 675                 os_memcpy(pos, WPA_CIPHER_SUITE_WEP104, WPA_SELECTOR_LEN);
 676         } else if (group_cipher == WPA_CIPHER_WEP40) {
 677                 os_memcpy(pos, WPA_CIPHER_SUITE_WEP40, WPA_SELECTOR_LEN);
 678         } else {
 679                 wpa_printf(MSG_WARNING, "Invalid group cipher (%d).",
 680                            group_cipher);
 681                 return -1;
 682         }
 683         pos += WPA_SELECTOR_LEN;
 684
 685         *pos++ = 1;
 686         *pos++ = 0;
 687         if (pairwise_cipher == WPA_CIPHER_CCMP) {
 688                 os_memcpy(pos, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN);
 689         } else if (pairwise_cipher == WPA_CIPHER_TKIP) {
 690                 os_memcpy(pos, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN);
 691         } else if (pairwise_cipher == WPA_CIPHER_NONE) {
 692                 os_memcpy(pos, WPA_CIPHER_SUITE_NONE, WPA_SELECTOR_LEN);
 693         } else {
 694                 wpa_printf(MSG_WARNING, "Invalid pairwise cipher (%d).",
 695                            pairwise_cipher);
 696                 return -1;
 697         }
 698         pos += WPA_SELECTOR_LEN;
 699
 700         *pos++ = 1;
 701         *pos++ = 0;
 702         if (key_mgmt == WPA_KEY_MGMT_IEEE8021X) {
 703                 os_memcpy(pos, WPA_AUTH_KEY_MGMT_UNSPEC_802_1X,
 704                           WPA_SELECTOR_LEN);
 705         } else if (key_mgmt == WPA_KEY_MGMT_PSK) {
 706                 os_memcpy(pos, WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X,
 707                           WPA_SELECTOR_LEN);
 708         } else if (key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
 709                 os_memcpy(pos, WPA_AUTH_KEY_MGMT_NONE, WPA_SELECTOR_LEN);
 710         } else {
 711                 wpa_printf(MSG_WARNING, "Invalid key management type (%d).",
 712                            key_mgmt);
 713                 return -1;
 714         }
 715         pos += WPA_SELECTOR_LEN;
 716
 717         /* WPA Capabilities; use defaults, so no need to include it */
 718
 719         hdr->len = (pos - wpa_ie) - 2;
 720
 721         WPA_ASSERT((size_t) (pos - wpa_ie) <= wpa_ie_len);
 722
 723         return pos - wpa_ie;
 724 }
 725
 726
 727 static int wpa_gen_wpa_ie_rsn(u8 *rsn_ie, size_t rsn_ie_len,
 728                               int pairwise_cipher, int group_cipher,
 729                               int key_mgmt, int mgmt_group_cipher,
 730                               struct wpa_sm *sm)
 731 {
 732 #ifndef CONFIG_NO_WPA2
 733         u8 *pos;
 734         struct rsn_ie_hdr *hdr;
 735         u16 capab;
 736
 737         if (rsn_ie_len < sizeof(*hdr) + RSN_SELECTOR_LEN +
 738             2 + RSN_SELECTOR_LEN + 2 + RSN_SELECTOR_LEN + 2 +
 739             (sm->cur_pmksa ? 2 + PMKID_LEN : 0))
 740                 return -1;
 741
 742         hdr = (struct rsn_ie_hdr *) rsn_ie;
 743         hdr->elem_id = RSN_INFO_ELEM;
 744         WPA_PUT_LE16(hdr->version, RSN_VERSION);
 745         pos = (u8 *) (hdr + 1);
 746
 747         if (group_cipher == WPA_CIPHER_CCMP) {
 748                 os_memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
 749         } else if (group_cipher == WPA_CIPHER_TKIP) {
 750                 os_memcpy(pos, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN);
 751         } else if (group_cipher == WPA_CIPHER_WEP104) {
 752                 os_memcpy(pos, RSN_CIPHER_SUITE_WEP104, RSN_SELECTOR_LEN);
 753         } else if (group_cipher == WPA_CIPHER_WEP40) {
 754                 os_memcpy(pos, RSN_CIPHER_SUITE_WEP40, RSN_SELECTOR_LEN);
 755         } else {
 756                 wpa_printf(MSG_WARNING, "Invalid group cipher (%d).",
 757                            group_cipher);
 758                 return -1;
 759         }
 760         pos += RSN_SELECTOR_LEN;
 761
 762         *pos++ = 1;
 763         *pos++ = 0;
 764         if (pairwise_cipher == WPA_CIPHER_CCMP) {
 765                 os_memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
 766         } else if (pairwise_cipher == WPA_CIPHER_TKIP) {
 767                 os_memcpy(pos, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN);
 768         } else if (pairwise_cipher == WPA_CIPHER_NONE) {
 769                 os_memcpy(pos, RSN_CIPHER_SUITE_NONE, RSN_SELECTOR_LEN);
 770         } else {
 771                 wpa_printf(MSG_WARNING, "Invalid pairwise cipher (%d).",
 772                            pairwise_cipher);
 773                 return -1;
 774         }
 775         pos += RSN_SELECTOR_LEN;
 776
 777         *pos++ = 1;
 778         *pos++ = 0;
 779         if (key_mgmt == WPA_KEY_MGMT_IEEE8021X) {
 780                 os_memcpy(pos, RSN_AUTH_KEY_MGMT_UNSPEC_802_1X,
 781                           RSN_SELECTOR_LEN);
 782         } else if (key_mgmt == WPA_KEY_MGMT_PSK) {
 783                 os_memcpy(pos, RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X,
 784                           RSN_SELECTOR_LEN);
 785         } else {
 786                 wpa_printf(MSG_WARNING, "Invalid key management type (%d).",
 787                            key_mgmt);
 788                 return -1;
 789         }
 790         pos += RSN_SELECTOR_LEN;
 791
 792         /* RSN Capabilities */
 793         capab = 0;
 794 #ifdef CONFIG_IEEE80211W
 795         if (mgmt_group_cipher == WPA_CIPHER_AES_128_CMAC)
 796                 capab |= WPA_CAPABILITY_MGMT_FRAME_PROTECTION;
 797 #endif /* CONFIG_IEEE80211W */
 798         WPA_PUT_LE16(pos, capab);
 799         pos += 2;
 800
 801         if (sm->cur_pmksa) {
 802                 /* PMKID Count (2 octets, little endian) */
 803                 *pos++ = 1;
 804                 *pos++ = 0;
 805                 /* PMKID */
 806                 os_memcpy(pos, sm->cur_pmksa->pmkid, PMKID_LEN);
 807                 pos += PMKID_LEN;
 808         }
 809
 810 #ifdef CONFIG_IEEE80211W
 811         if (mgmt_group_cipher == WPA_CIPHER_AES_128_CMAC) {
 812                 if (!sm->cur_pmksa) {
 813                         /* PMKID Count */
 814                         WPA_PUT_LE16(pos, 0);
 815                         pos += 2;
 816
 817                         /* Management Group Cipher Suite */
 818                         memcpy(pos, RSN_CIPHER_SUITE_AES_128_CMAC,
 819                                RSN_SELECTOR_LEN);
 820                         pos += RSN_SELECTOR_LEN;
 821                 }
 822         }
 823 #endif /* CONFIG_IEEE80211W */
 824
 825         hdr->len = (pos - rsn_ie) - 2;
 826
 827         WPA_ASSERT((size_t) (pos - rsn_ie) <= rsn_ie_len);
 828
 829         return pos - rsn_ie;
 830 #else /* CONFIG_NO_WPA2 */
 831         return -1;
 832 #endif /* CONFIG_NO_WPA2 */
 833 }
 834
 835
 836 /**
 837  * wpa_gen_wpa_ie - Generate WPA/RSN IE based on current security policy
 838  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 839  * @wpa_ie: Pointer to memory area for the generated WPA/RSN IE
 840  * @wpa_ie_len: Maximum length of the generated WPA/RSN IE
 841  * Returns: Length of the generated WPA/RSN IE or -1 on failure
 842  */
 843 static int wpa_gen_wpa_ie(struct wpa_sm *sm, u8 *wpa_ie, size_t wpa_ie_len)
 844 {
 845         if (sm->proto == WPA_PROTO_RSN)
 846                 return wpa_gen_wpa_ie_rsn(wpa_ie, wpa_ie_len,
 847                                           sm->pairwise_cipher,
 848                                           sm->group_cipher,
 849                                           sm->key_mgmt, sm->mgmt_group_cipher,
 850                                           sm);
 851         else
 852                 return wpa_gen_wpa_ie_wpa(wpa_ie, wpa_ie_len,
 853                                           sm->pairwise_cipher,
 854                                           sm->group_cipher,
 855                                           sm->key_mgmt);
 856 }
 857
 858
 859 /**
 860  * wpa_pmk_to_ptk - Calculate PTK from PMK, addresses, and nonces
 861  * @pmk: Pairwise master key
 862  * @pmk_len: Length of PMK
 863  * @label: Label to use in derivation
 864  * @addr1: AA or SA
 865  * @addr2: SA or AA
 866  * @nonce1: ANonce or SNonce
 867  * @nonce2: SNonce or ANonce
 868  * @ptk: Buffer for pairwise transient key
 869  * @ptk_len: Length of PTK
 870  *
 871  * IEEE Std 802.11i-2004 - 8.5.1.2 Pairwise key hierarchy
 872  * PTK = PRF-X(PMK, "Pairwise key expansion",
 873  *             Min(AA, SA) || Max(AA, SA) ||
 874  *             Min(ANonce, SNonce) || Max(ANonce, SNonce))
 875  *
 876  * STK = PRF-X(SMK, "Peer key expansion",
 877  *             Min(MAC_I, MAC_P) || Max(MAC_I, MAC_P) ||
 878  *             Min(INonce, PNonce) || Max(INonce, PNonce))
 879  */
 880 static void wpa_pmk_to_ptk(const u8 *pmk, size_t pmk_len,
 881                            const char *label,
 882                            const u8 *addr1, const u8 *addr2,
 883                            const u8 *nonce1, const u8 *nonce2,
 884                            u8 *ptk, size_t ptk_len)
 885 {
 886         u8 data[2 * ETH_ALEN + 2 * 32];
 887
 888         if (os_memcmp(addr1, addr2, ETH_ALEN) < 0) {
 889                 os_memcpy(data, addr1, ETH_ALEN);
 890                 os_memcpy(data + ETH_ALEN, addr2, ETH_ALEN);
 891         } else {
 892                 os_memcpy(data, addr2, ETH_ALEN);
 893                 os_memcpy(data + ETH_ALEN, addr1, ETH_ALEN);
 894         }
 895
 896         if (os_memcmp(nonce1, nonce2, 32) < 0) {
 897                 os_memcpy(data + 2 * ETH_ALEN, nonce1, 32);
 898                 os_memcpy(data + 2 * ETH_ALEN + 32, nonce2, 32);
 899         } else {
 900                 os_memcpy(data + 2 * ETH_ALEN, nonce2, 32);
 901                 os_memcpy(data + 2 * ETH_ALEN + 32, nonce1, 32);
 902         }
 903
 904         sha1_prf(pmk, pmk_len, label, data, sizeof(data), ptk, ptk_len);
 905
 906         wpa_hexdump_key(MSG_DEBUG, "WPA: PMK", pmk, pmk_len);
 907         wpa_hexdump_key(MSG_DEBUG, "WPA: PTK", ptk, ptk_len);
 908 }
 909
 910
 911 /**
 912  * wpa_eapol_key_mic - Calculate EAPOL-Key MIC
 913  * @key: EAPOL-Key Key Confirmation Key (KCK)
 914  * @ver: Key descriptor version (WPA_KEY_INFO_TYPE_*)
 915  * @buf: Pointer to the beginning of the EAPOL header (version field)
 916  * @len: Length of the EAPOL frame (from EAPOL header to the end of the frame)
 917  * @mic: Pointer to the buffer to which the EAPOL-Key MIC is written
 918  *
 919  * Calculate EAPOL-Key MIC for an EAPOL-Key packet. The EAPOL-Key MIC field has
 920  * to be cleared (all zeroes) when calling this function.
 921  *
 922  * Note: 'IEEE Std 802.11i-2004 - 8.5.2 EAPOL-Key frames' has an error in the
 923  * description of the Key MIC calculation. It includes packet data from the
 924  * beginning of the EAPOL-Key header, not EAPOL header. This incorrect change
 925  * happened during final editing of the standard and the correct behavior is
 926  * defined in the last draft (IEEE 802.11i/D10).
 927  */
 928 static void wpa_eapol_key_mic(const u8 *key, int ver,
 929                               const u8 *buf, size_t len, u8 *mic)
 930 {
 931         if (ver == WPA_KEY_INFO_TYPE_HMAC_MD5_RC4) {
 932                 hmac_md5(key, 16, buf, len, mic);
 933         } else if (ver == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
 934                 u8 hash[SHA1_MAC_LEN];
 935                 hmac_sha1(key, 16, buf, len, hash);
 936                 os_memcpy(mic, hash, MD5_MAC_LEN);
 937         }
 938 }
 939
 940
 941 static void wpa_eapol_key_send(struct wpa_sm *sm, const u8 *kck,
 942                                int ver, const u8 *dest, u16 proto,
 943                                u8 *msg, size_t msg_len, u8 *key_mic)
 944 {
 945         if (os_memcmp(dest, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) == 0 &&
 946             os_memcmp(sm->bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) == 0) {
 947                 /*
 948                  * Association event was not yet received; try to fetch
 949                  * BSSID from the driver.
 950                  */
 951                 if (wpa_sm_get_bssid(sm, sm->bssid) < 0) {
 952                         wpa_printf(MSG_DEBUG, "WPA: Failed to read BSSID for "
 953                                    "EAPOL-Key destination address");
 954                 } else {
 955                         dest = sm->bssid;
 956                         wpa_printf(MSG_DEBUG, "WPA: Use BSSID (" MACSTR
 957                                    ") as the destination for EAPOL-Key",
 958                                    MAC2STR(dest));
 959                 }
 960         }
 961         if (key_mic) {
 962                 wpa_eapol_key_mic(kck, ver, msg, msg_len, key_mic);
 963         }
 964         wpa_hexdump(MSG_MSGDUMP, "WPA: TX EAPOL-Key", msg, msg_len);
 965         wpa_sm_ether_send(sm, dest, proto, msg, msg_len);
 966         eapol_sm_notify_tx_eapol_key(sm->eapol);
 967         os_free(msg);
 968 }
 969
 970
 971 /**
 972  * wpa_sm_key_request - Send EAPOL-Key Request
 973  * @sm: Pointer to WPA state machine data from wpa_sm_init()
 974  * @error: Indicate whether this is an Michael MIC error report
 975  * @pairwise: 1 = error report for pairwise packet, 0 = for group packet
 976  * Returns: Pointer to the current network structure or %NULL on failure
 977  *
 978  * Send an EAPOL-Key Request to the current authenticator. This function is
 979  * used to request rekeying and it is usually called when a local Michael MIC
 980  * failure is detected.
 981  */
 982 void wpa_sm_key_request(struct wpa_sm *sm, int error, int pairwise)
 983 {
 984         size_t rlen;
 985         struct wpa_eapol_key *reply;
 986         int key_info, ver;
 987         u8 bssid[ETH_ALEN], *rbuf;
 988
 989         if (sm->pairwise_cipher == WPA_CIPHER_CCMP)
 990                 ver = WPA_KEY_INFO_TYPE_HMAC_SHA1_AES;
 991         else
 992                 ver = WPA_KEY_INFO_TYPE_HMAC_MD5_RC4;
 993
 994         if (wpa_sm_get_bssid(sm, bssid) < 0) {
 995                 wpa_printf(MSG_WARNING, "Failed to read BSSID for EAPOL-Key "
 996                            "request");
 997                 return;
 998         }
 999
1000         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY, NULL,
1001                                   sizeof(*reply), &rlen, (void *) &reply);
1002         if (rbuf == NULL)
1003                 return;
1004
1005         reply->type = sm->proto == WPA_PROTO_RSN ?
1006                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
1007         key_info = WPA_KEY_INFO_REQUEST | ver;
1008         if (sm->ptk_set)
1009                 key_info |= WPA_KEY_INFO_MIC;
1010         if (error)
1011                 key_info |= WPA_KEY_INFO_ERROR;
1012         if (pairwise)
1013                 key_info |= WPA_KEY_INFO_KEY_TYPE;
1014         WPA_PUT_BE16(reply->key_info, key_info);
1015         WPA_PUT_BE16(reply->key_length, 0);
1016         os_memcpy(reply->replay_counter, sm->request_counter,
1017                   WPA_REPLAY_COUNTER_LEN);
1018         inc_byte_array(sm->request_counter, WPA_REPLAY_COUNTER_LEN);
1019
1020         WPA_PUT_BE16(reply->key_data_length, 0);
1021
1022         wpa_printf(MSG_INFO, "WPA: Sending EAPOL-Key Request (error=%d "
1023                    "pairwise=%d ptk_set=%d len=%lu)",
1024                    error, pairwise, sm->ptk_set, (unsigned long) rlen);
1025         wpa_eapol_key_send(sm, sm->ptk.kck, ver, bssid, ETH_P_EAPOL,
1026                            rbuf, rlen, key_info & WPA_KEY_INFO_MIC ?
1027                            reply->key_mic : NULL);
1028 }
1029
1030
1031 /**
1032  * wpa_sm_stkstart - Send EAPOL-Key Request for STK handshake (STK M1)
1033  * @sm: Pointer to WPA state machine data from wpa_sm_init()
1034  * @peer: MAC address of the peer STA
1035  * Returns: 0 on success, or -1 on failure
1036  *
1037  * Send an EAPOL-Key Request to the current authenticator to start STK
1038  * handshake with the peer.
1039  */
1040 int wpa_sm_stkstart(struct wpa_sm *sm, const u8 *peer)
1041 {
1042 #ifdef CONFIG_PEERKEY
1043         size_t rlen, kde_len;
1044         struct wpa_eapol_key *req;
1045         int key_info, ver;
1046         u8 bssid[ETH_ALEN], *rbuf, *pos, *count_pos;
1047         u16 count;
1048         struct wpa_ssid *ssid = sm->cur_ssid;
1049         struct rsn_ie_hdr *hdr;
1050         struct wpa_peerkey *peerkey;
1051         struct wpa_ie_data ie;
1052
1053         if (sm->proto != WPA_PROTO_RSN || !sm->ptk_set ||
1054             ssid == NULL || !ssid->peerkey)
1055                 return -1;
1056
1057         if (sm->ap_rsn_ie &&
1058             wpa_parse_wpa_ie_rsn(sm->ap_rsn_ie, sm->ap_rsn_ie_len, &ie) == 0 &&
1059             !(ie.capabilities & WPA_CAPABILITY_PEERKEY_ENABLED)) {
1060                 wpa_printf(MSG_DEBUG, "RSN: Current AP does not support STK");
1061                 return -1;
1062         }
1063
1064         if (sm->pairwise_cipher == WPA_CIPHER_CCMP)
1065                 ver = WPA_KEY_INFO_TYPE_HMAC_SHA1_AES;
1066         else
1067                 ver = WPA_KEY_INFO_TYPE_HMAC_MD5_RC4;
1068
1069         if (wpa_sm_get_bssid(sm, bssid) < 0) {
1070                 wpa_printf(MSG_WARNING, "Failed to read BSSID for EAPOL-Key "
1071                            "SMK M1");
1072                 return -1;
1073         }
1074
1075         /* TODO: find existing entry and if found, use that instead of adding
1076          * a new one */
1077         peerkey = os_malloc(sizeof(*peerkey));
1078         if (peerkey == NULL)
1079                 return -1;
1080         os_memset(peerkey, 0, sizeof(*peerkey));
1081         peerkey->initiator = 1;
1082         os_memcpy(peerkey->addr, peer, ETH_ALEN);
1083
1084         /* SMK M1:
1085          * EAPOL-Key(S=1, M=1, A=0, I=0, K=0, SM=1, KeyRSC=0, Nonce=INonce,
1086          *           MIC=MIC, DataKDs=(RSNIE_I, MAC_P KDE))
1087          */
1088
1089         hdr = (struct rsn_ie_hdr *) peerkey->rsnie_i;
1090         hdr->elem_id = RSN_INFO_ELEM;
1091         WPA_PUT_LE16(hdr->version, RSN_VERSION);
1092         pos = (u8 *) (hdr + 1);
1093         /* Group Suite can be anything for SMK RSN IE; receiver will just
1094          * ignore it. */
1095         os_memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
1096         pos += RSN_SELECTOR_LEN;
1097         count_pos = pos;
1098         pos += 2;
1099
1100         count = 0;
1101         if (ssid->pairwise_cipher & WPA_CIPHER_CCMP) {
1102                 os_memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
1103                 pos += RSN_SELECTOR_LEN;
1104                 count++;
1105         }
1106         if (ssid->pairwise_cipher & WPA_CIPHER_TKIP) {
1107                 os_memcpy(pos, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN);
1108                 pos += RSN_SELECTOR_LEN;
1109                 count++;
1110         }
1111         WPA_PUT_LE16(count_pos, count);
1112
1113         hdr->len = (pos - peerkey->rsnie_i) - 2;
1114         peerkey->rsnie_i_len = pos - peerkey->rsnie_i;
1115         wpa_hexdump(MSG_DEBUG, "WPA: RSN IE for SMK handshake",
1116                     peerkey->rsnie_i, peerkey->rsnie_i_len);
1117
1118         kde_len = peerkey->rsnie_i_len + 2 + RSN_SELECTOR_LEN + ETH_ALEN;
1119
1120         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY, NULL,
1121                                   sizeof(*req) + kde_len, &rlen,
1122                                   (void *) &req);
1123         if (rbuf == NULL) {
1124                 wpa_supplicant_peerkey_free(sm, peerkey);
1125                 return -1;
1126         }
1127
1128         req->type = EAPOL_KEY_TYPE_RSN;
1129         key_info = WPA_KEY_INFO_SMK_MESSAGE | WPA_KEY_INFO_MIC |
1130                 WPA_KEY_INFO_SECURE | WPA_KEY_INFO_REQUEST | ver;
1131         WPA_PUT_BE16(req->key_info, key_info);
1132         WPA_PUT_BE16(req->key_length, 0);
1133         os_memcpy(req->replay_counter, sm->request_counter,
1134                   WPA_REPLAY_COUNTER_LEN);
1135         inc_byte_array(sm->request_counter, WPA_REPLAY_COUNTER_LEN);
1136
1137         if (hostapd_get_rand(peerkey->inonce, WPA_NONCE_LEN)) {
1138                 wpa_msg(sm->ctx->ctx, MSG_WARNING,
1139                         "WPA: Failed to get random data for INonce");
1140                 os_free(rbuf);
1141                 wpa_supplicant_peerkey_free(sm, peerkey);
1142                 return -1;
1143         }
1144         os_memcpy(req->key_nonce, peerkey->inonce, WPA_NONCE_LEN);
1145         wpa_hexdump(MSG_DEBUG, "WPA: INonce for SMK handshake",
1146                     req->key_nonce, WPA_NONCE_LEN);
1147
1148         WPA_PUT_BE16(req->key_data_length, (u16) kde_len);
1149         pos = (u8 *) (req + 1);
1150
1151         /* Initiator RSN IE */
1152         pos = wpa_add_ie(pos, peerkey->rsnie_i, peerkey->rsnie_i_len);
1153         /* Peer MAC address KDE */
1154         pos = wpa_add_kde(pos, RSN_KEY_DATA_MAC_ADDR, peer, ETH_ALEN);
1155
1156         wpa_printf(MSG_INFO, "RSN: Sending EAPOL-Key SMK M1 Request (peer "
1157                    MACSTR ")", MAC2STR(peer));
1158         wpa_eapol_key_send(sm, sm->ptk.kck, ver, bssid, ETH_P_EAPOL,
1159                            rbuf, rlen, req->key_mic);
1160
1161         peerkey->next = sm->peerkey;
1162         sm->peerkey = peerkey;
1163
1164         return 0;
1165
1166 #else /* CONFIG_PEERKEY */
1167
1168         return -1;
1169
1170 #endif /* CONFIG_PEERKEY */
1171 }
1172
1173
1174 struct wpa_eapol_ie_parse {
1175         const u8 *wpa_ie;
1176         size_t wpa_ie_len;
1177         const u8 *rsn_ie;
1178         size_t rsn_ie_len;
1179         const u8 *pmkid;
1180         const u8 *gtk;
1181         size_t gtk_len;
1182         const u8 *mac_addr;
1183         size_t mac_addr_len;
1184 #ifdef CONFIG_PEERKEY
1185         const u8 *smk;
1186         size_t smk_len;
1187         const u8 *nonce;
1188         size_t nonce_len;
1189         const u8 *lifetime;
1190         size_t lifetime_len;
1191         const u8 *error;
1192         size_t error_len;
1193 #endif /* CONFIG_PEERKEY */
1194 #ifdef CONFIG_IEEE80211W
1195         const u8 *dhv;
1196         size_t dhv_len;
1197         const u8 *igtk;
1198         size_t igtk_len;
1199 #endif /* CONFIG_IEEE80211W */
1200 };
1201
1202
1203 /**
1204  * wpa_supplicant_parse_generic - Parse EAPOL-Key Key Data Generic IEs
1205  * @pos: Pointer to the IE header
1206  * @end: Pointer to the end of the Key Data buffer
1207  * @ie: Pointer to parsed IE data
1208  * Returns: 0 on success, 1 if end mark is found, -1 on failure
1209  */
1210 static int wpa_supplicant_parse_generic(const u8 *pos, const u8 *end,
1211                                         struct wpa_eapol_ie_parse *ie)
1212 {
1213         if (pos[1] == 0)
1214                 return 1;
1215
1216         if (pos[1] >= 6 &&
1217             os_memcmp(pos + 2, WPA_OUI_TYPE, WPA_SELECTOR_LEN) == 0 &&
1218             pos[2 + WPA_SELECTOR_LEN] == 1 &&
1219             pos[2 + WPA_SELECTOR_LEN + 1] == 0) {
1220                 ie->wpa_ie = pos;
1221                 ie->wpa_ie_len = pos[1] + 2;
1222                 return 0;
1223         }
1224
1225         if (pos + 1 + RSN_SELECTOR_LEN < end &&
1226             pos[1] >= RSN_SELECTOR_LEN + PMKID_LEN &&
1227             os_memcmp(pos + 2, RSN_KEY_DATA_PMKID, RSN_SELECTOR_LEN) == 0) {
1228                 ie->pmkid = pos + 2 + RSN_SELECTOR_LEN;
1229                 return 0;
1230         }
1231
1232         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1233             os_memcmp(pos + 2, RSN_KEY_DATA_GROUPKEY, RSN_SELECTOR_LEN) == 0) {
1234                 ie->gtk = pos + 2 + RSN_SELECTOR_LEN;
1235                 ie->gtk_len = pos[1] - RSN_SELECTOR_LEN;
1236                 return 0;
1237         }
1238
1239         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1240             os_memcmp(pos + 2, RSN_KEY_DATA_MAC_ADDR, RSN_SELECTOR_LEN) == 0) {
1241                 ie->mac_addr = pos + 2 + RSN_SELECTOR_LEN;
1242                 ie->mac_addr_len = pos[1] - RSN_SELECTOR_LEN;
1243                 return 0;
1244         }
1245
1246 #ifdef CONFIG_PEERKEY
1247         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1248             os_memcmp(pos + 2, RSN_KEY_DATA_SMK, RSN_SELECTOR_LEN) == 0) {
1249                 ie->smk = pos + 2 + RSN_SELECTOR_LEN;
1250                 ie->smk_len = pos[1] - RSN_SELECTOR_LEN;
1251                 return 0;
1252         }
1253
1254         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1255             os_memcmp(pos + 2, RSN_KEY_DATA_NONCE, RSN_SELECTOR_LEN) == 0) {
1256                 ie->nonce = pos + 2 + RSN_SELECTOR_LEN;
1257                 ie->nonce_len = pos[1] - RSN_SELECTOR_LEN;
1258                 return 0;
1259         }
1260
1261         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1262             os_memcmp(pos + 2, RSN_KEY_DATA_LIFETIME, RSN_SELECTOR_LEN) == 0) {
1263                 ie->lifetime = pos + 2 + RSN_SELECTOR_LEN;
1264                 ie->lifetime_len = pos[1] - RSN_SELECTOR_LEN;
1265                 return 0;
1266         }
1267
1268         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1269             os_memcmp(pos + 2, RSN_KEY_DATA_ERROR, RSN_SELECTOR_LEN) == 0) {
1270                 ie->error = pos + 2 + RSN_SELECTOR_LEN;
1271                 ie->error_len = pos[1] - RSN_SELECTOR_LEN;
1272                 return 0;
1273         }
1274 #endif /* CONFIG_PEERKEY */
1275
1276 #ifdef CONFIG_IEEE80211W
1277         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1278             os_memcmp(pos + 2, RSN_KEY_DATA_DHV, RSN_SELECTOR_LEN) == 0) {
1279                 ie->dhv = pos + 2 + RSN_SELECTOR_LEN;
1280                 ie->dhv_len = pos[1] - RSN_SELECTOR_LEN;
1281                 return 0;
1282         }
1283
1284         if (pos[1] > RSN_SELECTOR_LEN + 2 &&
1285             os_memcmp(pos + 2, RSN_KEY_DATA_IGTK, RSN_SELECTOR_LEN) == 0) {
1286                 ie->igtk = pos + 2 + RSN_SELECTOR_LEN;
1287                 ie->igtk_len = pos[1] - RSN_SELECTOR_LEN;
1288                 return 0;
1289         }
1290 #endif /* CONFIG_IEEE80211W */
1291
1292         return 0;
1293 }
1294
1295
1296 /**
1297  * wpa_supplicant_parse_ies - Parse EAPOL-Key Key Data IEs
1298  * @buf: Pointer to the Key Data buffer
1299  * @len: Key Data Length
1300  * @ie: Pointer to parsed IE data
1301  * Returns: 0 on success, -1 on failure
1302  */
1303 static int wpa_supplicant_parse_ies(const u8 *buf, size_t len,
1304                                     struct wpa_eapol_ie_parse *ie)
1305 {
1306         const u8 *pos, *end;
1307         int ret = 0;
1308
1309         os_memset(ie, 0, sizeof(*ie));
1310         for (pos = buf, end = pos + len; pos + 1 < end; pos += 2 + pos[1]) {
1311                 if (pos[0] == 0xdd &&
1312                     ((pos == buf + len - 1) || pos[1] == 0)) {
1313                         /* Ignore padding */
1314                         break;
1315                 }
1316                 if (pos + 2 + pos[1] > end) {
1317                         wpa_printf(MSG_DEBUG, "WPA: EAPOL-Key Key Data "
1318                                    "underflow (ie=%d len=%d pos=%d)",
1319                                    pos[0], pos[1], (int) (pos - buf));
1320                         wpa_hexdump_key(MSG_DEBUG, "WPA: Key Data",
1321                                         buf, len);
1322                         ret = -1;
1323                         break;
1324                 }
1325                 if (*pos == RSN_INFO_ELEM) {
1326                         ie->rsn_ie = pos;
1327                         ie->rsn_ie_len = pos[1] + 2;
1328                 } else if (*pos == GENERIC_INFO_ELEM) {
1329                         ret = wpa_supplicant_parse_generic(pos, end, ie);
1330                         if (ret < 0)
1331                                 break;
1332                         if (ret > 0) {
1333                                 ret = 0;
1334                                 break;
1335                         }
1336                 } else {
1337                         wpa_hexdump(MSG_DEBUG, "WPA: Unrecognized EAPOL-Key "
1338                                     "Key Data IE", pos, 2 + pos[1]);
1339                 }
1340         }
1341
1342         return ret;
1343 }
1344
1345
1346 static int wpa_supplicant_get_pmk(struct wpa_sm *sm,
1347                                   const unsigned char *src_addr,
1348                                   const u8 *pmkid)
1349 {
1350         int abort_cached = 0;
1351
1352         if (pmkid && !sm->cur_pmksa) {
1353                 /* When using drivers that generate RSN IE, wpa_supplicant may
1354                  * not have enough time to get the association information
1355                  * event before receiving this 1/4 message, so try to find a
1356                  * matching PMKSA cache entry here. */
1357                 sm->cur_pmksa = pmksa_cache_get(sm->pmksa, src_addr, pmkid);
1358                 if (sm->cur_pmksa) {
1359                         wpa_printf(MSG_DEBUG, "RSN: found matching PMKID from "
1360                                    "PMKSA cache");
1361                 } else {
1362                         wpa_printf(MSG_DEBUG, "RSN: no matching PMKID found");
1363                         abort_cached = 1;
1364                 }
1365         }
1366
1367         if (pmkid && sm->cur_pmksa &&
1368             os_memcmp(pmkid, sm->cur_pmksa->pmkid, PMKID_LEN) == 0) {
1369                 wpa_hexdump(MSG_DEBUG, "RSN: matched PMKID", pmkid, PMKID_LEN);
1370                 wpa_sm_set_pmk_from_pmksa(sm);
1371                 wpa_hexdump_key(MSG_DEBUG, "RSN: PMK from PMKSA cache",
1372                                 sm->pmk, sm->pmk_len);
1373                 eapol_sm_notify_cached(sm->eapol);
1374         } else if (sm->key_mgmt == WPA_KEY_MGMT_IEEE8021X && sm->eapol) {
1375                 int res, pmk_len;
1376                 pmk_len = PMK_LEN;
1377                 res = eapol_sm_get_key(sm->eapol, sm->pmk, PMK_LEN);
1378                 if (res) {
1379                         /*
1380                          * EAP-LEAP is an exception from other EAP methods: it
1381                          * uses only 16-byte PMK.
1382                          */
1383                         res = eapol_sm_get_key(sm->eapol, sm->pmk, 16);
1384                         pmk_len = 16;
1385                 }
1386                 if (res == 0) {
1387                         wpa_hexdump_key(MSG_DEBUG, "WPA: PMK from EAPOL state "
1388                                         "machines", sm->pmk, pmk_len);
1389                         sm->pmk_len = pmk_len;
1390                         pmksa_cache_add(sm->pmksa, sm->pmk, pmk_len, src_addr,
1391                                         sm->own_addr, sm->cur_ssid);
1392                         if (!sm->cur_pmksa && pmkid &&
1393                             pmksa_cache_get(sm->pmksa, src_addr, pmkid)) {
1394                                 wpa_printf(MSG_DEBUG, "RSN: the new PMK "
1395                                            "matches with the PMKID");
1396                                 abort_cached = 0;
1397                         }
1398                 } else {
1399                         wpa_msg(sm->ctx->ctx, MSG_WARNING,
1400                                 "WPA: Failed to get master session key from "
1401                                 "EAPOL state machines");
1402                         wpa_msg(sm->ctx->ctx, MSG_WARNING,
1403                                 "WPA: Key handshake aborted");
1404                         if (sm->cur_pmksa) {
1405                                 wpa_printf(MSG_DEBUG, "RSN: Cancelled PMKSA "
1406                                            "caching attempt");
1407                                 sm->cur_pmksa = NULL;
1408                                 abort_cached = 1;
1409                         } else {
1410                                 return -1;
1411                         }
1412                 }
1413         }
1414
1415         if (abort_cached && sm->key_mgmt == WPA_KEY_MGMT_IEEE8021X) {
1416                 /* Send EAPOL-Start to trigger full EAP authentication. */
1417                 u8 *buf;
1418                 size_t buflen;
1419
1420                 wpa_printf(MSG_DEBUG, "RSN: no PMKSA entry found - trigger "
1421                            "full EAP authentication");
1422                 buf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_START,
1423                                          NULL, 0, &buflen, NULL);
1424                 if (buf) {
1425                         wpa_sm_ether_send(sm, sm->bssid, ETH_P_EAPOL,
1426                                           buf, buflen);
1427                         os_free(buf);
1428                 }
1429
1430                 return -1;
1431         }
1432
1433         return 0;
1434 }
1435
1436
1437 static int wpa_supplicant_send_2_of_4(struct wpa_sm *sm,
1438                                       const unsigned char *dst,
1439                                       const struct wpa_eapol_key *key,
1440                                       int ver, const u8 *nonce,
1441                                       const u8 *wpa_ie, size_t wpa_ie_len,
1442                                       struct wpa_ptk *ptk)
1443 {
1444         size_t rlen;
1445         struct wpa_eapol_key *reply;
1446         u8 *rbuf;
1447
1448         if (wpa_ie == NULL) {
1449                 wpa_printf(MSG_WARNING, "WPA: No wpa_ie set - cannot "
1450                            "generate msg 2/4");
1451                 return -1;
1452         }
1453
1454         wpa_hexdump(MSG_DEBUG, "WPA: WPA IE for msg 2/4", wpa_ie, wpa_ie_len);
1455
1456         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY,
1457                                   NULL, sizeof(*reply) + wpa_ie_len,
1458                                   &rlen, (void *) &reply);
1459         if (rbuf == NULL)
1460                 return -1;
1461
1462         reply->type = sm->proto == WPA_PROTO_RSN ?
1463                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
1464         WPA_PUT_BE16(reply->key_info,
1465                      ver | WPA_KEY_INFO_KEY_TYPE | WPA_KEY_INFO_MIC);
1466         if (sm->proto == WPA_PROTO_RSN)
1467                 WPA_PUT_BE16(reply->key_length, 0);
1468         else
1469                 os_memcpy(reply->key_length, key->key_length, 2);
1470         os_memcpy(reply->replay_counter, key->replay_counter,
1471                   WPA_REPLAY_COUNTER_LEN);
1472
1473         WPA_PUT_BE16(reply->key_data_length, wpa_ie_len);
1474         os_memcpy(reply + 1, wpa_ie, wpa_ie_len);
1475
1476         os_memcpy(reply->key_nonce, nonce, WPA_NONCE_LEN);
1477
1478         wpa_printf(MSG_DEBUG, "WPA: Sending EAPOL-Key 2/4");
1479         wpa_eapol_key_send(sm, ptk->kck, ver, dst, ETH_P_EAPOL,
1480                            rbuf, rlen, reply->key_mic);
1481
1482         return 0;
1483 }
1484
1485
1486 static void wpa_supplicant_process_1_of_4(struct wpa_sm *sm,
1487                                           const unsigned char *src_addr,
1488                                           const struct wpa_eapol_key *key,
1489                                           u16 ver)
1490 {
1491         struct wpa_eapol_ie_parse ie;
1492         struct wpa_ptk *ptk;
1493         u8 buf[8];
1494
1495         if (wpa_sm_get_ssid(sm) == NULL) {
1496                 wpa_printf(MSG_WARNING, "WPA: No SSID info found (msg 1 of "
1497                            "4).");
1498                 return;
1499         }
1500
1501         wpa_sm_set_state(sm, WPA_4WAY_HANDSHAKE);
1502         wpa_printf(MSG_DEBUG, "WPA: RX message 1 of 4-Way Handshake from "
1503                    MACSTR " (ver=%d)", MAC2STR(src_addr), ver);
1504
1505         os_memset(&ie, 0, sizeof(ie));
1506
1507 #ifndef CONFIG_NO_WPA2
1508         if (sm->proto == WPA_PROTO_RSN) {
1509                 /* RSN: msg 1/4 should contain PMKID for the selected PMK */
1510                 const u8 *_buf = (const u8 *) (key + 1);
1511                 size_t len = WPA_GET_BE16(key->key_data_length);
1512                 wpa_hexdump(MSG_DEBUG, "RSN: msg 1/4 key data", _buf, len);
1513                 wpa_supplicant_parse_ies(_buf, len, &ie);
1514                 if (ie.pmkid) {
1515                         wpa_hexdump(MSG_DEBUG, "RSN: PMKID from "
1516                                     "Authenticator", ie.pmkid, PMKID_LEN);
1517                 }
1518         }
1519 #endif /* CONFIG_NO_WPA2 */
1520
1521         if (wpa_supplicant_get_pmk(sm, src_addr, ie.pmkid))
1522                 return;
1523
1524         if (sm->renew_snonce) {
1525                 if (hostapd_get_rand(sm->snonce, WPA_NONCE_LEN)) {
1526                         wpa_msg(sm->ctx->ctx, MSG_WARNING,
1527                                 "WPA: Failed to get random data for SNonce");
1528                         return;
1529                 }
1530                 sm->renew_snonce = 0;
1531                 wpa_hexdump(MSG_DEBUG, "WPA: Renewed SNonce",
1532                             sm->snonce, WPA_NONCE_LEN);
1533         }
1534
1535         /* Calculate PTK which will be stored as a temporary PTK until it has
1536          * been verified when processing message 3/4. */
1537         ptk = &sm->tptk;
1538         wpa_pmk_to_ptk(sm->pmk, sm->pmk_len, "Pairwise key expansion",
1539                        sm->own_addr, sm->bssid, sm->snonce, key->key_nonce,
1540                        (u8 *) ptk, sizeof(*ptk));
1541         /* Supplicant: swap tx/rx Mic keys */
1542         os_memcpy(buf, ptk->u.auth.tx_mic_key, 8);
1543         os_memcpy(ptk->u.auth.tx_mic_key, ptk->u.auth.rx_mic_key, 8);
1544         os_memcpy(ptk->u.auth.rx_mic_key, buf, 8);
1545         sm->tptk_set = 1;
1546
1547         if (wpa_supplicant_send_2_of_4(sm, sm->bssid, key, ver, sm->snonce,
1548                                        sm->assoc_wpa_ie, sm->assoc_wpa_ie_len,
1549                                        ptk))
1550                 return;
1551
1552         os_memcpy(sm->anonce, key->key_nonce, WPA_NONCE_LEN);
1553 }
1554
1555
1556 static void wpa_sm_start_preauth(void *eloop_ctx, void *timeout_ctx)
1557 {
1558         struct wpa_sm *sm = eloop_ctx;
1559         rsn_preauth_candidate_process(sm);
1560 }
1561
1562
1563 static void wpa_supplicant_key_neg_complete(struct wpa_sm *sm,
1564                                             const u8 *addr, int secure)
1565 {
1566         wpa_msg(sm->ctx->ctx, MSG_INFO, "WPA: Key negotiation completed with "
1567                 MACSTR " [PTK=%s GTK=%s]", MAC2STR(addr),
1568                 wpa_cipher_txt(sm->pairwise_cipher),
1569                 wpa_cipher_txt(sm->group_cipher));
1570         eloop_cancel_timeout(sm->ctx->scan, sm->ctx->ctx, NULL);
1571         wpa_sm_cancel_auth_timeout(sm);
1572         wpa_sm_set_state(sm, WPA_COMPLETED);
1573
1574         if (secure) {
1575                 wpa_sm_mlme_setprotection(
1576                         sm, addr, MLME_SETPROTECTION_PROTECT_TYPE_RX_TX,
1577                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
1578                 eapol_sm_notify_portValid(sm->eapol, TRUE);
1579                 if (sm->key_mgmt == WPA_KEY_MGMT_PSK)
1580                         eapol_sm_notify_eap_success(sm->eapol, TRUE);
1581                 /*
1582                  * Start preauthentication after a short wait to avoid a
1583                  * possible race condition between the data receive and key
1584                  * configuration after the 4-Way Handshake. This increases the
1585                  * likelyhood of the first preauth EAPOL-Start frame getting to
1586                  * the target AP.
1587                  */
1588                 eloop_register_timeout(1, 0, wpa_sm_start_preauth, sm, NULL);
1589         }
1590
1591         if (sm->cur_pmksa && sm->cur_pmksa->opportunistic) {
1592                 wpa_printf(MSG_DEBUG, "RSN: Authenticator accepted "
1593                            "opportunistic PMKSA entry - marking it valid");
1594                 sm->cur_pmksa->opportunistic = 0;
1595         }
1596 }
1597
1598
1599 static int wpa_supplicant_install_ptk(struct wpa_sm *sm,
1600                                       const struct wpa_eapol_key *key)
1601 {
1602         int keylen, rsclen;
1603         wpa_alg alg;
1604         const u8 *key_rsc;
1605         u8 null_rsc[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
1606
1607         wpa_printf(MSG_DEBUG, "WPA: Installing PTK to the driver.");
1608
1609         switch (sm->pairwise_cipher) {
1610         case WPA_CIPHER_CCMP:
1611                 alg = WPA_ALG_CCMP;
1612                 keylen = 16;
1613                 rsclen = 6;
1614                 break;
1615         case WPA_CIPHER_TKIP:
1616                 alg = WPA_ALG_TKIP;
1617                 keylen = 32;
1618                 rsclen = 6;
1619                 break;
1620         case WPA_CIPHER_NONE:
1621                 wpa_printf(MSG_DEBUG, "WPA: Pairwise Cipher Suite: "
1622                            "NONE - do not use pairwise keys");
1623                 return 0;
1624         default:
1625                 wpa_printf(MSG_WARNING, "WPA: Unsupported pairwise cipher %d",
1626                            sm->pairwise_cipher);
1627                 return -1;
1628         }
1629
1630         if (sm->proto == WPA_PROTO_RSN) {
1631                 key_rsc = null_rsc;
1632         } else {
1633                 key_rsc = key->key_rsc;
1634                 wpa_hexdump(MSG_DEBUG, "WPA: RSC", key_rsc, rsclen);
1635         }
1636
1637         if (wpa_sm_set_key(sm, alg, sm->bssid, 0, 1, key_rsc, rsclen,
1638                            (u8 *) sm->ptk.tk1, keylen) < 0) {
1639                 wpa_printf(MSG_WARNING, "WPA: Failed to set PTK to the "
1640                            "driver.");
1641                 return -1;
1642         }
1643         return 0;
1644 }
1645
1646
1647 static int wpa_supplicant_check_group_cipher(int group_cipher,
1648                                              int keylen, int maxkeylen,
1649                                              int *key_rsc_len, wpa_alg *alg)
1650 {
1651         int ret = 0;
1652
1653         switch (group_cipher) {
1654         case WPA_CIPHER_CCMP:
1655                 if (keylen != 16 || maxkeylen < 16) {
1656                         ret = -1;
1657                         break;
1658                 }
1659                 *key_rsc_len = 6;
1660                 *alg = WPA_ALG_CCMP;
1661                 break;
1662         case WPA_CIPHER_TKIP:
1663                 if (keylen != 32 || maxkeylen < 32) {
1664                         ret = -1;
1665                         break;
1666                 }
1667                 *key_rsc_len = 6;
1668                 *alg = WPA_ALG_TKIP;
1669                 break;
1670         case WPA_CIPHER_WEP104:
1671                 if (keylen != 13 || maxkeylen < 13) {
1672                         ret = -1;
1673                         break;
1674                 }
1675                 *key_rsc_len = 0;
1676                 *alg = WPA_ALG_WEP;
1677                 break;
1678         case WPA_CIPHER_WEP40:
1679                 if (keylen != 5 || maxkeylen < 5) {
1680                         ret = -1;
1681                         break;
1682                 }
1683                 *key_rsc_len = 0;
1684                 *alg = WPA_ALG_WEP;
1685                 break;
1686         default:
1687                 wpa_printf(MSG_WARNING, "WPA: Unsupported Group Cipher %d",
1688                            group_cipher);
1689                 return -1;
1690         }
1691
1692         if (ret < 0 ) {
1693                 wpa_printf(MSG_WARNING, "WPA: Unsupported %s Group Cipher key "
1694                            "length %d (%d).",
1695                            wpa_cipher_txt(group_cipher), keylen, maxkeylen);
1696         }
1697
1698         return ret;
1699 }
1700
1701
1702 struct wpa_gtk_data {
1703         wpa_alg alg;
1704         int tx, key_rsc_len, keyidx;
1705         u8 gtk[32];
1706         int gtk_len;
1707 };
1708
1709
1710 static int wpa_supplicant_install_gtk(struct wpa_sm *sm,
1711                                       const struct wpa_gtk_data *gd,
1712                                       const u8 *key_rsc)
1713 {
1714         const u8 *_gtk = gd->gtk;
1715         u8 gtk_buf[32];
1716
1717         wpa_hexdump_key(MSG_DEBUG, "WPA: Group Key", gd->gtk, gd->gtk_len);
1718         wpa_printf(MSG_DEBUG, "WPA: Installing GTK to the driver "
1719                    "(keyidx=%d tx=%d).", gd->keyidx, gd->tx);
1720         wpa_hexdump(MSG_DEBUG, "WPA: RSC", key_rsc, gd->key_rsc_len);
1721         if (sm->group_cipher == WPA_CIPHER_TKIP) {
1722                 /* Swap Tx/Rx keys for Michael MIC */
1723                 os_memcpy(gtk_buf, gd->gtk, 16);
1724                 os_memcpy(gtk_buf + 16, gd->gtk + 24, 8);
1725                 os_memcpy(gtk_buf + 24, gd->gtk + 16, 8);
1726                 _gtk = gtk_buf;
1727         }
1728         if (sm->pairwise_cipher == WPA_CIPHER_NONE) {
1729                 if (wpa_sm_set_key(sm, gd->alg,
1730                                    (u8 *) "\xff\xff\xff\xff\xff\xff",
1731                                    gd->keyidx, 1, key_rsc, gd->key_rsc_len,
1732                                    _gtk, gd->gtk_len) < 0) {
1733                         wpa_printf(MSG_WARNING, "WPA: Failed to set "
1734                                    "GTK to the driver (Group only).");
1735                         return -1;
1736                 }
1737         } else if (wpa_sm_set_key(sm, gd->alg,
1738                                   (u8 *) "\xff\xff\xff\xff\xff\xff",
1739                                   gd->keyidx, gd->tx, key_rsc, gd->key_rsc_len,
1740                                   _gtk, gd->gtk_len) < 0) {
1741                 wpa_printf(MSG_WARNING, "WPA: Failed to set GTK to "
1742                            "the driver.");
1743                 return -1;
1744         }
1745
1746         return 0;
1747 }
1748
1749
1750 static int wpa_supplicant_gtk_tx_bit_workaround(const struct wpa_sm *sm,
1751                                                 int tx)
1752 {
1753         if (tx && sm->pairwise_cipher != WPA_CIPHER_NONE) {
1754                 /* Ignore Tx bit for GTK if a pairwise key is used. One AP
1755                  * seemed to set this bit (incorrectly, since Tx is only when
1756                  * doing Group Key only APs) and without this workaround, the
1757                  * data connection does not work because wpa_supplicant
1758                  * configured non-zero keyidx to be used for unicast. */
1759                 wpa_printf(MSG_INFO, "WPA: Tx bit set for GTK, but pairwise "
1760                            "keys are used - ignore Tx bit");
1761                 return 0;
1762         }
1763         return tx;
1764 }
1765
1766
1767 static int wpa_supplicant_pairwise_gtk(struct wpa_sm *sm,
1768                                        const struct wpa_eapol_key *key,
1769                                        const u8 *gtk, size_t gtk_len,
1770                                        int key_info)
1771 {
1772 #ifndef CONFIG_NO_WPA2
1773         struct wpa_gtk_data gd;
1774
1775         /*
1776          * IEEE Std 802.11i-2004 - 8.5.2 EAPOL-Key frames - Figure 43x
1777          * GTK KDE format:
1778          * KeyID[bits 0-1], Tx [bit 2], Reserved [bits 3-7]
1779          * Reserved [bits 0-7]
1780          * GTK
1781          */
1782
1783         os_memset(&gd, 0, sizeof(gd));
1784         wpa_hexdump_key(MSG_DEBUG, "RSN: received GTK in pairwise handshake",
1785                         gtk, gtk_len);
1786
1787         if (gtk_len < 2 || gtk_len - 2 > sizeof(gd.gtk))
1788                 return -1;
1789
1790         gd.keyidx = gtk[0] & 0x3;
1791         gd.tx = wpa_supplicant_gtk_tx_bit_workaround(sm,
1792                                                      !!(gtk[0] & BIT(2)));
1793         gtk += 2;
1794         gtk_len -= 2;
1795
1796         os_memcpy(gd.gtk, gtk, gtk_len);
1797         gd.gtk_len = gtk_len;
1798
1799         if (wpa_supplicant_check_group_cipher(sm->group_cipher,
1800                                               gtk_len, gtk_len,
1801                                               &gd.key_rsc_len, &gd.alg) ||
1802             wpa_supplicant_install_gtk(sm, &gd, key->key_rsc)) {
1803                 wpa_printf(MSG_DEBUG, "RSN: Failed to install GTK");
1804                 return -1;
1805         }
1806
1807         wpa_supplicant_key_neg_complete(sm, sm->bssid,
1808                                         key_info & WPA_KEY_INFO_SECURE);
1809         return 0;
1810 #else /* CONFIG_NO_WPA2 */
1811         return -1;
1812 #endif /* CONFIG_NO_WPA2 */
1813 }
1814
1815
1816 static int ieee80211w_set_keys(struct wpa_sm *sm,
1817                                struct wpa_eapol_ie_parse *ie)
1818 {
1819 #ifdef CONFIG_IEEE80211W
1820         if (sm->mgmt_group_cipher != WPA_CIPHER_AES_128_CMAC)
1821                 return 0;
1822
1823         if (ie->igtk) {
1824                 const struct wpa_igtk_kde *igtk;
1825                 u16 keyidx;
1826                 if (ie->igtk_len != sizeof(*igtk))
1827                         return -1;
1828                 igtk = (const struct wpa_igtk_kde *) ie->igtk;
1829                 keyidx = WPA_GET_LE16(igtk->keyid);
1830                 wpa_printf(MSG_DEBUG, "WPA: IGTK keyid %d "
1831                            "pn %02x%02x%02x%02x%02x%02x",
1832                            keyidx, MAC2STR(igtk->pn));
1833                 wpa_hexdump_key(MSG_DEBUG, "WPA: IGTK",
1834                                 igtk->igtk, WPA_IGTK_LEN);
1835                 if (keyidx > 4095) {
1836                         wpa_printf(MSG_WARNING, "WPA: Invalid IGTK KeyID %d",
1837                                    keyidx);
1838                         return -1;
1839                 }
1840                 if (wpa_sm_set_key(sm, WPA_ALG_IGTK,
1841                                    (u8 *) "\xff\xff\xff\xff\xff\xff",
1842                                    keyidx, 0, igtk->pn, sizeof(igtk->pn),
1843                                    igtk->igtk, WPA_IGTK_LEN) < 0) {
1844                         wpa_printf(MSG_WARNING, "WPA: Failed to configure IGTK"
1845                                    " to the driver");
1846                         return -1;
1847                 }
1848         }
1849
1850         if (ie->dhv) {
1851                 const struct wpa_dhv_kde *dhv;
1852                 if (ie->dhv_len != sizeof(*dhv))
1853                         return -1;
1854                 dhv = (const struct wpa_dhv_kde *) ie->dhv;
1855                 wpa_hexdump_key(MSG_DEBUG, "WPA: DHV", dhv->dhv, WPA_DHV_LEN);
1856                 if (wpa_sm_set_key(sm, WPA_ALG_DHV,
1857                                    (u8 *) "\xff\xff\xff\xff\xff\xff", 0, 0,
1858                                    NULL, 0, dhv->dhv, WPA_DHV_LEN) < 0) {
1859                         wpa_printf(MSG_WARNING, "WPA: Failed to configure DHV "
1860                                    "to the driver");
1861                         return -1;
1862                 }
1863         }
1864
1865         return 0;
1866 #else /* CONFIG_IEEE80211W */
1867         return 0;
1868 #endif /* CONFIG_IEEE80211W */
1869 }
1870
1871
1872 static void wpa_report_ie_mismatch(struct wpa_sm *sm,
1873                                    const char *reason, const u8 *src_addr,
1874                                    const u8 *wpa_ie, size_t wpa_ie_len,
1875                                    const u8 *rsn_ie, size_t rsn_ie_len)
1876 {
1877         wpa_msg(sm->ctx->ctx, MSG_WARNING, "WPA: %s (src=" MACSTR ")",
1878                 reason, MAC2STR(src_addr));
1879
1880         if (sm->ap_wpa_ie) {
1881                 wpa_hexdump(MSG_INFO, "WPA: WPA IE in Beacon/ProbeResp",
1882                             sm->ap_wpa_ie, sm->ap_wpa_ie_len);
1883         }
1884         if (wpa_ie) {
1885                 if (!sm->ap_wpa_ie) {
1886                         wpa_printf(MSG_INFO, "WPA: No WPA IE in "
1887                                    "Beacon/ProbeResp");
1888                 }
1889                 wpa_hexdump(MSG_INFO, "WPA: WPA IE in 3/4 msg",
1890                             wpa_ie, wpa_ie_len);
1891         }
1892
1893         if (sm->ap_rsn_ie) {
1894                 wpa_hexdump(MSG_INFO, "WPA: RSN IE in Beacon/ProbeResp",
1895                             sm->ap_rsn_ie, sm->ap_rsn_ie_len);
1896         }
1897         if (rsn_ie) {
1898                 if (!sm->ap_rsn_ie) {
1899                         wpa_printf(MSG_INFO, "WPA: No RSN IE in "
1900                                    "Beacon/ProbeResp");
1901                 }
1902                 wpa_hexdump(MSG_INFO, "WPA: RSN IE in 3/4 msg",
1903                             rsn_ie, rsn_ie_len);
1904         }
1905
1906         wpa_sm_disassociate(sm, REASON_IE_IN_4WAY_DIFFERS);
1907         wpa_sm_req_scan(sm, 0, 0);
1908 }
1909
1910
1911 static int wpa_supplicant_validate_ie(struct wpa_sm *sm,
1912                                       const unsigned char *src_addr,
1913                                       struct wpa_eapol_ie_parse *ie)
1914 {
1915         struct wpa_ssid *ssid = sm->cur_ssid;
1916
1917         if (sm->ap_wpa_ie == NULL && sm->ap_rsn_ie == NULL) {
1918                 wpa_printf(MSG_DEBUG, "WPA: No WPA/RSN IE for this AP known. "
1919                            "Trying to get from scan results");
1920                 if (wpa_sm_get_beacon_ie(sm) < 0) {
1921                         wpa_printf(MSG_WARNING, "WPA: Could not find AP from "
1922                                    "the scan results");
1923                 } else {
1924                         wpa_printf(MSG_DEBUG, "WPA: Found the current AP from "
1925                                    "updated scan results");
1926                 }
1927         }
1928
1929         if (ie->wpa_ie == NULL && ie->rsn_ie == NULL &&
1930             (sm->ap_wpa_ie || sm->ap_rsn_ie)) {
1931                 wpa_report_ie_mismatch(sm, "IE in 3/4 msg does not match "
1932                                        "with IE in Beacon/ProbeResp (no IE?)",
1933                                        src_addr, ie->wpa_ie, ie->wpa_ie_len,
1934                                        ie->rsn_ie, ie->rsn_ie_len);
1935                 return -1;
1936         }
1937
1938         if ((ie->wpa_ie && sm->ap_wpa_ie &&
1939              (ie->wpa_ie_len != sm->ap_wpa_ie_len ||
1940               os_memcmp(ie->wpa_ie, sm->ap_wpa_ie, ie->wpa_ie_len) != 0)) ||
1941             (ie->rsn_ie && sm->ap_rsn_ie &&
1942              (ie->rsn_ie_len != sm->ap_rsn_ie_len ||
1943               os_memcmp(ie->rsn_ie, sm->ap_rsn_ie, ie->rsn_ie_len) != 0))) {
1944                 wpa_report_ie_mismatch(sm, "IE in 3/4 msg does not match "
1945                                        "with IE in Beacon/ProbeResp",
1946                                        src_addr, ie->wpa_ie, ie->wpa_ie_len,
1947                                        ie->rsn_ie, ie->rsn_ie_len);
1948                 return -1;
1949         }
1950
1951         if (sm->proto == WPA_PROTO_WPA &&
1952             ie->rsn_ie && sm->ap_rsn_ie == NULL &&
1953             ssid && (ssid->proto & WPA_PROTO_RSN)) {
1954                 wpa_report_ie_mismatch(sm, "Possible downgrade attack "
1955                                        "detected - RSN was enabled and RSN IE "
1956                                        "was in msg 3/4, but not in "
1957                                        "Beacon/ProbeResp",
1958                                        src_addr, ie->wpa_ie, ie->wpa_ie_len,
1959                                        ie->rsn_ie, ie->rsn_ie_len);
1960                 return -1;
1961         }
1962
1963         return 0;
1964 }
1965
1966
1967 static int wpa_supplicant_send_4_of_4(struct wpa_sm *sm,
1968                                       const unsigned char *dst,
1969                                       const struct wpa_eapol_key *key,
1970                                       u16 ver, u16 key_info,
1971                                       const u8 *kde, size_t kde_len,
1972                                       struct wpa_ptk *ptk)
1973 {
1974         size_t rlen;
1975         struct wpa_eapol_key *reply;
1976         u8 *rbuf;
1977
1978         if (kde)
1979                 wpa_hexdump(MSG_DEBUG, "WPA: KDE for msg 4/4", kde, kde_len);
1980
1981         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY, NULL,
1982                                   sizeof(*reply) + kde_len,
1983                                   &rlen, (void *) &reply);
1984         if (rbuf == NULL)
1985                 return -1;
1986
1987         reply->type = sm->proto == WPA_PROTO_RSN ?
1988                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
1989         key_info &= WPA_KEY_INFO_SECURE;
1990         key_info |= ver | WPA_KEY_INFO_KEY_TYPE | WPA_KEY_INFO_MIC;
1991         WPA_PUT_BE16(reply->key_info, key_info);
1992         if (sm->proto == WPA_PROTO_RSN)
1993                 WPA_PUT_BE16(reply->key_length, 0);
1994         else
1995                 os_memcpy(reply->key_length, key->key_length, 2);
1996         os_memcpy(reply->replay_counter, key->replay_counter,
1997                   WPA_REPLAY_COUNTER_LEN);
1998
1999         WPA_PUT_BE16(reply->key_data_length, kde_len);
2000         if (kde)
2001                 os_memcpy(reply + 1, kde, kde_len);
2002
2003         wpa_printf(MSG_DEBUG, "WPA: Sending EAPOL-Key 4/4");
2004         wpa_eapol_key_send(sm, ptk->kck, ver, dst, ETH_P_EAPOL,
2005                            rbuf, rlen, reply->key_mic);
2006
2007         return 0;
2008 }
2009
2010
2011 static void wpa_supplicant_process_3_of_4(struct wpa_sm *sm,
2012                                           const struct wpa_eapol_key *key,
2013                                           u16 ver)
2014 {
2015         u16 key_info, keylen, len;
2016         const u8 *pos;
2017         struct wpa_eapol_ie_parse ie;
2018
2019         wpa_sm_set_state(sm, WPA_4WAY_HANDSHAKE);
2020         wpa_printf(MSG_DEBUG, "WPA: RX message 3 of 4-Way Handshake from "
2021                    MACSTR " (ver=%d)", MAC2STR(sm->bssid), ver);
2022
2023         key_info = WPA_GET_BE16(key->key_info);
2024
2025         pos = (const u8 *) (key + 1);
2026         len = WPA_GET_BE16(key->key_data_length);
2027         wpa_hexdump(MSG_DEBUG, "WPA: IE KeyData", pos, len);
2028         wpa_supplicant_parse_ies(pos, len, &ie);
2029         if (ie.gtk && !(key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) {
2030                 wpa_printf(MSG_WARNING, "WPA: GTK IE in unencrypted key data");
2031                 return;
2032         }
2033 #ifdef CONFIG_IEEE80211W
2034         if ((ie.dhv || ie.igtk) && !(key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) {
2035                 wpa_printf(MSG_WARNING, "WPA: DHV/IGTK KDE in unencrypted key "
2036                            "data");
2037                 return;
2038         }
2039
2040         if (ie.dhv && ie.dhv_len != sizeof(struct wpa_dhv_kde)) {
2041                 wpa_printf(MSG_WARNING, "WPA: Invalid DHV KDE length %lu",
2042                            (unsigned long) ie.dhv_len);
2043                 return;
2044         }
2045
2046         if (ie.igtk && ie.igtk_len != sizeof(struct wpa_igtk_kde)) {
2047                 wpa_printf(MSG_WARNING, "WPA: Invalid IGTK KDE length %lu",
2048                            (unsigned long) ie.igtk_len);
2049                 return;
2050         }
2051 #endif /* CONFIG_IEEE80211W */
2052
2053         if (wpa_supplicant_validate_ie(sm, sm->bssid, &ie) < 0)
2054                 return;
2055
2056         if (os_memcmp(sm->anonce, key->key_nonce, WPA_NONCE_LEN) != 0) {
2057                 wpa_printf(MSG_WARNING, "WPA: ANonce from message 1 of 4-Way "
2058                            "Handshake differs from 3 of 4-Way Handshake - drop"
2059                            " packet (src=" MACSTR ")", MAC2STR(sm->bssid));
2060                 return;
2061         }
2062
2063         keylen = WPA_GET_BE16(key->key_length);
2064         switch (sm->pairwise_cipher) {
2065         case WPA_CIPHER_CCMP:
2066                 if (keylen != 16) {
2067                         wpa_printf(MSG_WARNING, "WPA: Invalid CCMP key length "
2068                                    "%d (src=" MACSTR ")",
2069                                    keylen, MAC2STR(sm->bssid));
2070                         return;
2071                 }
2072                 break;
2073         case WPA_CIPHER_TKIP:
2074                 if (keylen != 32) {
2075                         wpa_printf(MSG_WARNING, "WPA: Invalid TKIP key length "
2076                                    "%d (src=" MACSTR ")",
2077                                    keylen, MAC2STR(sm->bssid));
2078                         return;
2079                 }
2080                 break;
2081         }
2082
2083         if (wpa_supplicant_send_4_of_4(sm, sm->bssid, key, ver, key_info,
2084                                        NULL, 0, &sm->ptk))
2085                 return;
2086
2087         /* SNonce was successfully used in msg 3/4, so mark it to be renewed
2088          * for the next 4-Way Handshake. If msg 3 is received again, the old
2089          * SNonce will still be used to avoid changing PTK. */
2090         sm->renew_snonce = 1;
2091
2092         if (key_info & WPA_KEY_INFO_INSTALL) {
2093                 wpa_supplicant_install_ptk(sm, key);
2094         }
2095
2096         if (key_info & WPA_KEY_INFO_SECURE) {
2097                 wpa_sm_mlme_setprotection(
2098                         sm, sm->bssid, MLME_SETPROTECTION_PROTECT_TYPE_RX,
2099                         MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
2100                 eapol_sm_notify_portValid(sm->eapol, TRUE);
2101         }
2102         wpa_sm_set_state(sm, WPA_GROUP_HANDSHAKE);
2103
2104         if (ie.gtk &&
2105             wpa_supplicant_pairwise_gtk(sm, key,
2106                                         ie.gtk, ie.gtk_len, key_info) < 0) {
2107                 wpa_printf(MSG_INFO, "RSN: Failed to configure GTK");
2108         }
2109
2110         if (ieee80211w_set_keys(sm, &ie) < 0)
2111                 wpa_printf(MSG_INFO, "RSN: Failed to configure DHV/IGTK");
2112 }
2113
2114
2115 #ifdef CONFIG_PEERKEY
2116 static void wpa_supplicant_smk_timeout(void *eloop_ctx, void *timeout_ctx)
2117 {
2118 #if 0
2119         struct wpa_sm *sm = eloop_ctx;
2120         struct wpa_peerkey *peerkey = timeout_ctx;
2121 #endif
2122         /* TODO: time out SMK and any STK that was generated using this SMK */
2123 }
2124
2125
2126 static void wpa_supplicant_peerkey_free(struct wpa_sm *sm,
2127                                         struct wpa_peerkey *peerkey)
2128 {
2129         eloop_cancel_timeout(wpa_supplicant_smk_timeout, sm, peerkey);
2130         os_free(peerkey);
2131 }
2132
2133
2134 static int wpa_supplicant_send_smk_error(struct wpa_sm *sm, const u8 *dst,
2135                                          const u8 *peer,
2136                                          u16 mui, u16 error_type, int ver)
2137 {
2138 #ifndef CONFIG_NO_WPA2
2139         size_t rlen;
2140         struct wpa_eapol_key *err;
2141         struct rsn_error_kde error;
2142         u8 *rbuf, *pos;
2143         size_t kde_len;
2144         u16 key_info;
2145
2146         kde_len = 2 + RSN_SELECTOR_LEN + sizeof(error);
2147         if (peer)
2148                 kde_len += 2 + RSN_SELECTOR_LEN + ETH_ALEN;
2149
2150         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY,
2151                                   NULL, sizeof(*err) + kde_len, &rlen,
2152                                   (void *) &err);
2153         if (rbuf == NULL)
2154                 return -1;
2155
2156         err->type = EAPOL_KEY_TYPE_RSN;
2157         key_info = ver | WPA_KEY_INFO_SMK_MESSAGE | WPA_KEY_INFO_MIC |
2158                 WPA_KEY_INFO_SECURE | WPA_KEY_INFO_ERROR |
2159                 WPA_KEY_INFO_REQUEST;
2160         WPA_PUT_BE16(err->key_info, key_info);
2161         WPA_PUT_BE16(err->key_length, 0);
2162         os_memcpy(err->replay_counter, sm->request_counter,
2163                   WPA_REPLAY_COUNTER_LEN);
2164         inc_byte_array(sm->request_counter, WPA_REPLAY_COUNTER_LEN);
2165
2166         WPA_PUT_BE16(err->key_data_length, (u16) kde_len);
2167         pos = (u8 *) (err + 1);
2168
2169         if (peer) {
2170                 /* Peer MAC Address KDE */
2171                 pos = wpa_add_kde(pos, RSN_KEY_DATA_MAC_ADDR, peer, ETH_ALEN);
2172         }
2173
2174         /* Error KDE */
2175         error.mui = host_to_be16(mui);
2176         error.error_type = host_to_be16(error_type);
2177         pos = wpa_add_kde(pos, RSN_KEY_DATA_ERROR,
2178                           (u8 *) &error, sizeof(error));
2179
2180         if (peer) {
2181                 wpa_printf(MSG_DEBUG, "RSN: Sending EAPOL-Key SMK Error (peer "
2182                            MACSTR " mui %d error_type %d)",
2183                            MAC2STR(peer), mui, error_type);
2184         } else {
2185                 wpa_printf(MSG_DEBUG, "RSN: Sending EAPOL-Key SMK Error "
2186                            "(mui %d error_type %d)", mui, error_type);
2187         }
2188
2189         wpa_eapol_key_send(sm, sm->ptk.kck, ver, dst, ETH_P_EAPOL,
2190                            rbuf, rlen, err->key_mic);
2191
2192         return 0;
2193 #else /* CONFIG_NO_WPA2 */
2194         return -1;
2195 #endif /* CONFIG_NO_WPA2 */
2196 }
2197
2198
2199 static int wpa_supplicant_send_smk_m3(struct wpa_sm *sm,
2200                                       const unsigned char *src_addr,
2201                                       const struct wpa_eapol_key *key,
2202                                       int ver, struct wpa_peerkey *peerkey)
2203 {
2204         size_t rlen;
2205         struct wpa_eapol_key *reply;
2206         u8 *rbuf, *pos;
2207         size_t kde_len;
2208         u16 key_info;
2209
2210         /* KDEs: Peer RSN IE, Initiator MAC Address, Initiator Nonce */
2211         kde_len = peerkey->rsnie_p_len +
2212                 2 + RSN_SELECTOR_LEN + ETH_ALEN +
2213                 2 + RSN_SELECTOR_LEN + WPA_NONCE_LEN;
2214
2215         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY,
2216                                   NULL, sizeof(*reply) + kde_len, &rlen,
2217                                   (void *) &reply);
2218         if (rbuf == NULL)
2219                 return -1;
2220
2221         reply->type = EAPOL_KEY_TYPE_RSN;
2222         key_info = ver | WPA_KEY_INFO_SMK_MESSAGE | WPA_KEY_INFO_MIC |
2223                 WPA_KEY_INFO_SECURE;
2224         WPA_PUT_BE16(reply->key_info, key_info);
2225         WPA_PUT_BE16(reply->key_length, 0);
2226         os_memcpy(reply->replay_counter, key->replay_counter,
2227                   WPA_REPLAY_COUNTER_LEN);
2228
2229         os_memcpy(reply->key_nonce, peerkey->pnonce, WPA_NONCE_LEN);
2230
2231         WPA_PUT_BE16(reply->key_data_length, (u16) kde_len);
2232         pos = (u8 *) (reply + 1);
2233
2234         /* Peer RSN IE */
2235         pos = wpa_add_ie(pos, peerkey->rsnie_p, peerkey->rsnie_p_len);
2236
2237         /* Initiator MAC Address KDE */
2238         pos = wpa_add_kde(pos, RSN_KEY_DATA_MAC_ADDR, peerkey->addr, ETH_ALEN);
2239
2240         /* Initiator Nonce */
2241         pos = wpa_add_kde(pos, RSN_KEY_DATA_NONCE,
2242                           peerkey->inonce, WPA_NONCE_LEN);
2243
2244         wpa_printf(MSG_DEBUG, "RSN: Sending EAPOL-Key SMK M3");
2245         wpa_eapol_key_send(sm, sm->ptk.kck, ver, src_addr, ETH_P_EAPOL,
2246                            rbuf, rlen, reply->key_mic);
2247
2248         return 0;
2249 }
2250
2251
2252 static int wpa_supplicant_process_smk_m2(
2253         struct wpa_sm *sm, const unsigned char *src_addr,
2254         const struct wpa_eapol_key *key, size_t extra_len, int ver)
2255 {
2256         struct wpa_ssid *ssid = sm->cur_ssid;
2257         struct wpa_peerkey *peerkey;
2258         struct wpa_eapol_ie_parse kde;
2259         struct wpa_ie_data ie;
2260         int cipher;
2261         struct rsn_ie_hdr *hdr;
2262         u8 *pos;
2263
2264         wpa_printf(MSG_DEBUG, "RSN: Received SMK M2");
2265
2266         if (ssid == NULL || !ssid->peerkey || sm->proto != WPA_PROTO_RSN) {
2267                 wpa_printf(MSG_INFO, "RSN: SMK handshake not allowed for "
2268                            "the current network");
2269                 return -1;
2270         }
2271
2272         if (wpa_supplicant_parse_ies((const u8 *) (key + 1), extra_len, &kde) <
2273             0) {
2274                 wpa_printf(MSG_INFO, "RSN: Failed to parse KDEs in SMK M2");
2275                 return -1;
2276         }
2277
2278         if (kde.rsn_ie == NULL || kde.mac_addr == NULL ||
2279             kde.mac_addr_len < ETH_ALEN) {
2280                 wpa_printf(MSG_INFO, "RSN: No RSN IE or MAC address KDE in "
2281                            "SMK M2");
2282                 return -1;
2283         }
2284
2285         wpa_printf(MSG_DEBUG, "RSN: SMK M2 - SMK initiator " MACSTR,
2286                    MAC2STR(kde.mac_addr));
2287
2288         if (kde.rsn_ie_len > PEERKEY_MAX_IE_LEN) {
2289                 wpa_printf(MSG_INFO, "RSN: Too long Initiator RSN IE in SMK "
2290                            "M2");
2291                 return -1;
2292         }
2293
2294         if (wpa_parse_wpa_ie_rsn(kde.rsn_ie, kde.rsn_ie_len, &ie) < 0) {
2295                 wpa_printf(MSG_INFO, "RSN: Failed to parse RSN IE in SMK M2");
2296                 return -1;
2297         }
2298
2299         cipher = ie.pairwise_cipher & ssid->pairwise_cipher;
2300         if (cipher & WPA_CIPHER_CCMP) {
2301                 wpa_printf(MSG_DEBUG, "RSN: Using CCMP for PeerKey");
2302                 cipher = WPA_CIPHER_CCMP;
2303         } else if (cipher & WPA_CIPHER_TKIP) {
2304                 wpa_printf(MSG_DEBUG, "RSN: Using TKIP for PeerKey");
2305                 cipher = WPA_CIPHER_TKIP;
2306         } else {
2307                 wpa_printf(MSG_INFO, "RSN: No acceptable cipher in SMK M2");
2308                 wpa_supplicant_send_smk_error(sm, src_addr, kde.mac_addr,
2309                                               STK_MUI_SMK, STK_ERR_CPHR_NS,
2310                                               ver);
2311                 return -1;
2312         }
2313
2314         /* TODO: find existing entry and if found, use that instead of adding
2315          * a new one; how to handle the case where both ends initiate at the
2316          * same time? */
2317         peerkey = os_malloc(sizeof(*peerkey));
2318         if (peerkey == NULL)
2319                 return -1;
2320         os_memset(peerkey, 0, sizeof(*peerkey));
2321         os_memcpy(peerkey->addr, kde.mac_addr, ETH_ALEN);
2322         os_memcpy(peerkey->inonce, key->key_nonce, WPA_NONCE_LEN);
2323         os_memcpy(peerkey->rsnie_i, kde.rsn_ie, kde.rsn_ie_len);
2324         peerkey->rsnie_i_len = kde.rsn_ie_len;
2325         peerkey->cipher = cipher;
2326
2327         if (hostapd_get_rand(peerkey->pnonce, WPA_NONCE_LEN)) {
2328                 wpa_msg(sm->ctx->ctx, MSG_WARNING,
2329                         "WPA: Failed to get random data for PNonce");
2330                 wpa_supplicant_peerkey_free(sm, peerkey);
2331                 return -1;
2332         }
2333
2334         hdr = (struct rsn_ie_hdr *) peerkey->rsnie_p;
2335         hdr->elem_id = RSN_INFO_ELEM;
2336         WPA_PUT_LE16(hdr->version, RSN_VERSION);
2337         pos = (u8 *) (hdr + 1);
2338         /* Group Suite can be anything for SMK RSN IE; receiver will just
2339          * ignore it. */
2340         os_memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
2341         pos += RSN_SELECTOR_LEN;
2342         /* Include only the selected cipher in pairwise cipher suite */
2343         WPA_PUT_LE16(pos, 1);
2344         pos += 2;
2345         if (cipher == WPA_CIPHER_CCMP)
2346                 os_memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
2347         else if (cipher == WPA_CIPHER_TKIP)
2348                 os_memcpy(pos, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN);
2349         pos += RSN_SELECTOR_LEN;
2350
2351         hdr->len = (pos - peerkey->rsnie_p) - 2;
2352         peerkey->rsnie_p_len = pos - peerkey->rsnie_p;
2353         wpa_hexdump(MSG_DEBUG, "WPA: RSN IE for SMK handshake",
2354                     peerkey->rsnie_p, peerkey->rsnie_p_len);
2355
2356         wpa_supplicant_send_smk_m3(sm, src_addr, key, ver, peerkey);
2357
2358         peerkey->next = sm->peerkey;
2359         sm->peerkey = peerkey;
2360
2361         return 0;
2362 }
2363
2364
2365 /**
2366  * rsn_smkid - Derive SMK identifier
2367  * @smk: Station master key (32 bytes)
2368  * @pnonce: Peer Nonce
2369  * @mac_p: Peer MAC address
2370  * @inonce: Initiator Nonce
2371  * @mac_i: Initiator MAC address
2372  *
2373  * 8.5.1.4 Station to station (STK) key hierarchy
2374  * SMKID = HMAC-SHA1-128(SMK, "SMK Name" || PNonce || MAC_P || INonce || MAC_I)
2375  */
2376 static void rsn_smkid(const u8 *smk, const u8 *pnonce, const u8 *mac_p,
2377                       const u8 *inonce, const u8 *mac_i, u8 *smkid)
2378 {
2379         char *title = "SMK Name";
2380         const u8 *addr[5];
2381         const size_t len[5] = { 8, WPA_NONCE_LEN, ETH_ALEN, WPA_NONCE_LEN,
2382                                 ETH_ALEN };
2383         unsigned char hash[SHA1_MAC_LEN];
2384
2385         addr[0] = (u8 *) title;
2386         addr[1] = pnonce;
2387         addr[2] = mac_p;
2388         addr[3] = inonce;
2389         addr[4] = mac_i;
2390
2391         hmac_sha1_vector(smk, PMK_LEN, 5, addr, len, hash);
2392         os_memcpy(smkid, hash, PMKID_LEN);
2393 }
2394
2395
2396 static void wpa_supplicant_send_stk_1_of_4(struct wpa_sm *sm,
2397                                            struct wpa_peerkey *peerkey)
2398 {
2399         size_t mlen;
2400         struct wpa_eapol_key *msg;
2401         u8 *mbuf;
2402         size_t kde_len;
2403         u16 key_info, ver;
2404
2405         kde_len = 2 + RSN_SELECTOR_LEN + PMKID_LEN;
2406
2407         mbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY, NULL,
2408                                   sizeof(*msg) + kde_len, &mlen,
2409                                   (void *) &msg);
2410         if (mbuf == NULL)
2411                 return;
2412
2413         msg->type = EAPOL_KEY_TYPE_RSN;
2414
2415         if (peerkey->cipher == WPA_CIPHER_CCMP)
2416                 ver = WPA_KEY_INFO_TYPE_HMAC_SHA1_AES;
2417         else
2418                 ver = WPA_KEY_INFO_TYPE_HMAC_MD5_RC4;
2419
2420         key_info = ver | WPA_KEY_INFO_KEY_TYPE | WPA_KEY_INFO_ACK;
2421         WPA_PUT_BE16(msg->key_info, key_info);
2422
2423         if (peerkey->cipher == WPA_CIPHER_CCMP)
2424                 WPA_PUT_BE16(msg->key_length, 16);
2425         else
2426                 WPA_PUT_BE16(msg->key_length, 32);
2427
2428         os_memcpy(msg->replay_counter, peerkey->replay_counter,
2429                   WPA_REPLAY_COUNTER_LEN);
2430         inc_byte_array(peerkey->replay_counter, WPA_REPLAY_COUNTER_LEN);
2431
2432         WPA_PUT_BE16(msg->key_data_length, kde_len);
2433         wpa_add_kde((u8 *) (msg + 1), RSN_KEY_DATA_PMKID,
2434                     peerkey->smkid, PMKID_LEN);
2435
2436         if (hostapd_get_rand(peerkey->inonce, WPA_NONCE_LEN)) {
2437                 wpa_msg(sm->ctx->ctx, MSG_WARNING,
2438                         "RSN: Failed to get random data for INonce (STK)");
2439                 os_free(mbuf);
2440                 return;
2441         }
2442         wpa_hexdump(MSG_DEBUG, "RSN: INonce for STK 4-Way Handshake",
2443                     peerkey->inonce, WPA_NONCE_LEN);
2444         os_memcpy(msg->key_nonce, peerkey->inonce, WPA_NONCE_LEN);
2445
2446         wpa_printf(MSG_DEBUG, "RSN: Sending EAPOL-Key STK 1/4 to " MACSTR,
2447                    MAC2STR(peerkey->addr));
2448         wpa_eapol_key_send(sm, NULL, ver, peerkey->addr, ETH_P_EAPOL,
2449                            mbuf, mlen, NULL);
2450 }
2451
2452
2453 static void wpa_supplicant_send_stk_3_of_4(struct wpa_sm *sm,
2454                                            struct wpa_peerkey *peerkey)
2455 {
2456         size_t mlen;
2457         struct wpa_eapol_key *msg;
2458         u8 *mbuf, *pos;
2459         size_t kde_len;
2460         u16 key_info, ver;
2461         u32 lifetime;
2462
2463         kde_len = peerkey->rsnie_i_len +
2464                 2 + RSN_SELECTOR_LEN + sizeof(lifetime);
2465
2466         mbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY, NULL,
2467                                   sizeof(*msg) + kde_len, &mlen,
2468                                   (void *) &msg);
2469         if (mbuf == NULL)
2470                 return;
2471
2472         msg->type = EAPOL_KEY_TYPE_RSN;
2473
2474         if (peerkey->cipher == WPA_CIPHER_CCMP)
2475                 ver = WPA_KEY_INFO_TYPE_HMAC_SHA1_AES;
2476         else
2477                 ver = WPA_KEY_INFO_TYPE_HMAC_MD5_RC4;
2478
2479         key_info = ver | WPA_KEY_INFO_KEY_TYPE | WPA_KEY_INFO_ACK |
2480                 WPA_KEY_INFO_MIC | WPA_KEY_INFO_SECURE;
2481         WPA_PUT_BE16(msg->key_info, key_info);
2482
2483         if (peerkey->cipher == WPA_CIPHER_CCMP)
2484                 WPA_PUT_BE16(msg->key_length, 16);
2485         else
2486                 WPA_PUT_BE16(msg->key_length, 32);
2487
2488         os_memcpy(msg->replay_counter, peerkey->replay_counter,
2489                   WPA_REPLAY_COUNTER_LEN);
2490         inc_byte_array(peerkey->replay_counter, WPA_REPLAY_COUNTER_LEN);
2491
2492         WPA_PUT_BE16(msg->key_data_length, kde_len);
2493         pos = (u8 *) (msg + 1);
2494         pos = wpa_add_ie(pos, peerkey->rsnie_i, peerkey->rsnie_i_len);
2495         lifetime = host_to_be32(peerkey->lifetime);
2496         pos = wpa_add_kde(pos, RSN_KEY_DATA_LIFETIME,
2497                           (u8 *) &lifetime, sizeof(lifetime));
2498
2499         os_memcpy(msg->key_nonce, peerkey->inonce, WPA_NONCE_LEN);
2500
2501         wpa_printf(MSG_DEBUG, "RSN: Sending EAPOL-Key STK 3/4 to " MACSTR,
2502                    MAC2STR(peerkey->addr));
2503         wpa_eapol_key_send(sm, peerkey->stk.kck, ver, peerkey->addr,
2504                            ETH_P_EAPOL, mbuf, mlen, msg->key_mic);
2505 }
2506
2507
2508 static int wpa_supplicant_process_smk_m45(
2509         struct wpa_sm *sm, const unsigned char *src_addr,
2510         const struct wpa_eapol_key *key, size_t extra_len, int ver)
2511 {
2512         struct wpa_ssid *ssid = sm->cur_ssid;
2513         struct wpa_peerkey *peerkey;
2514         struct wpa_eapol_ie_parse kde;
2515         u32 lifetime;
2516         struct os_time now;
2517         struct wpa_ie_data ie;
2518
2519         if (ssid == NULL || !ssid->peerkey || sm->proto != WPA_PROTO_RSN) {
2520                 wpa_printf(MSG_DEBUG, "RSN: SMK handshake not allowed for "
2521                            "the current network");
2522                 return -1;
2523         }
2524
2525         if (wpa_supplicant_parse_ies((const u8 *) (key + 1), extra_len, &kde) <
2526             0) {
2527                 wpa_printf(MSG_INFO, "RSN: Failed to parse KDEs in SMK M4/M5");
2528                 return -1;
2529         }
2530
2531         if (kde.mac_addr == NULL || kde.mac_addr_len < ETH_ALEN ||
2532             kde.nonce == NULL || kde.nonce_len < WPA_NONCE_LEN ||
2533             kde.smk == NULL || kde.smk_len < PMK_LEN + WPA_NONCE_LEN ||
2534             kde.lifetime == NULL || kde.lifetime_len < 4) {
2535                 wpa_printf(MSG_INFO, "RSN: No MAC Address, Nonce, SMK, or "
2536                            "Lifetime KDE in SMK M4/M5");
2537                 return -1;
2538         }
2539
2540         for (peerkey = sm->peerkey; peerkey; peerkey = peerkey->next) {
2541                 if (os_memcmp(peerkey->addr, kde.mac_addr, ETH_ALEN) == 0 &&
2542                     os_memcmp(peerkey->initiator ? peerkey->inonce :
2543                            peerkey->pnonce,
2544                            key->key_nonce, WPA_NONCE_LEN) == 0)
2545                         break;
2546         }
2547         if (peerkey == NULL) {
2548                 wpa_printf(MSG_INFO, "RSN: No matching SMK handshake found "
2549                            "for SMK M4/M5: peer " MACSTR,
2550                            MAC2STR(kde.mac_addr));
2551                 return -1;
2552         }
2553
2554         if (peerkey->initiator) {
2555                 int cipher;
2556                 wpa_printf(MSG_DEBUG, "RSN: Received SMK M5 (Peer " MACSTR ")",
2557                            MAC2STR(kde.mac_addr));
2558                 if (kde.rsn_ie == NULL || kde.rsn_ie_len > PEERKEY_MAX_IE_LEN
2559                     || wpa_parse_wpa_ie_rsn(kde.rsn_ie, kde.rsn_ie_len, &ie) <
2560                     0) {
2561                         wpa_printf(MSG_INFO, "RSN: No RSN IE in SMK M5");
2562                         /* TODO: abort negotiation */
2563                         return -1;
2564                 }
2565
2566                 if (os_memcmp(key->key_nonce, peerkey->inonce, WPA_NONCE_LEN)
2567                     != 0) {
2568                         wpa_printf(MSG_INFO, "RSN: Key Nonce in SMK M5 does "
2569                                    "not match with INonce used in SMK M1");
2570                         return -1;
2571                 }
2572
2573                 if (os_memcmp(kde.smk + PMK_LEN, peerkey->inonce,
2574                               WPA_NONCE_LEN) != 0) {
2575                         wpa_printf(MSG_INFO, "RSN: INonce in SMK KDE does not "
2576                                    "match with the one used in SMK M1");
2577                         return -1;
2578                 }
2579
2580                 os_memcpy(peerkey->rsnie_p, kde.rsn_ie, kde.rsn_ie_len);
2581                 peerkey->rsnie_p_len = kde.rsn_ie_len;
2582                 os_memcpy(peerkey->pnonce, kde.nonce, WPA_NONCE_LEN);
2583
2584                 cipher = ie.pairwise_cipher & ssid->pairwise_cipher;
2585                 if (cipher & WPA_CIPHER_CCMP) {
2586                         wpa_printf(MSG_DEBUG, "RSN: Using CCMP for PeerKey");
2587                         peerkey->cipher = WPA_CIPHER_CCMP;
2588                 } else if (cipher & WPA_CIPHER_TKIP) {
2589                         wpa_printf(MSG_DEBUG, "RSN: Using TKIP for PeerKey");
2590                         peerkey->cipher = WPA_CIPHER_TKIP;
2591                 } else {
2592                         wpa_printf(MSG_INFO, "RSN: SMK Peer STA " MACSTR
2593                                    " selected unacceptable cipher",
2594                                    MAC2STR(kde.mac_addr));
2595                         wpa_supplicant_send_smk_error(
2596                                 sm, src_addr, kde.mac_addr,
2597                                 STK_MUI_SMK, STK_ERR_CPHR_NS, ver);
2598                         /* TODO: abort negotiation */
2599                         return -1;
2600                 }
2601         } else {
2602                 wpa_printf(MSG_DEBUG, "RSN: Received SMK M4 (Initiator "
2603                            MACSTR ")", MAC2STR(kde.mac_addr));
2604
2605                 if (os_memcmp(kde.smk + PMK_LEN, peerkey->pnonce,
2606                               WPA_NONCE_LEN) != 0) {
2607                         wpa_printf(MSG_INFO, "RSN: PNonce in SMK KDE does not "
2608                                    "match with the one used in SMK M3");
2609                         return -1;
2610                 }
2611
2612                 if (os_memcmp(kde.nonce, peerkey->inonce, WPA_NONCE_LEN) != 0)
2613                 {
2614                         wpa_printf(MSG_INFO, "RSN: INonce in SMK M5 did not "
2615                                    "match with the one received in SMK M2");
2616                         return -1;
2617                 }
2618         }
2619
2620         os_memcpy(peerkey->smk, kde.smk, PMK_LEN);
2621         peerkey->smk_complete = 1;
2622         wpa_hexdump_key(MSG_DEBUG, "RSN: SMK", peerkey->smk, PMK_LEN);
2623         lifetime = WPA_GET_BE32(kde.lifetime);
2624         wpa_printf(MSG_DEBUG, "RSN: SMK lifetime %u seconds", lifetime);
2625         if (lifetime > 1000000000)
2626                 lifetime = 1000000000; /* avoid overflowing expiration time */
2627         peerkey->lifetime = lifetime;
2628         os_get_time(&now);
2629         peerkey->expiration = now.sec + lifetime;
2630         eloop_register_timeout(lifetime, 0, wpa_supplicant_smk_timeout,
2631                                sm, peerkey);
2632
2633         if (peerkey->initiator) {
2634                 rsn_smkid(peerkey->smk, peerkey->pnonce, peerkey->addr,
2635                           peerkey->inonce, sm->own_addr, peerkey->smkid);
2636                 wpa_supplicant_send_stk_1_of_4(sm, peerkey);
2637         } else {
2638                 rsn_smkid(peerkey->smk, peerkey->pnonce, sm->own_addr,
2639                           peerkey->inonce, peerkey->addr, peerkey->smkid);
2640         }
2641         wpa_hexdump(MSG_DEBUG, "RSN: SMKID", peerkey->smkid, PMKID_LEN);
2642
2643         return 0;
2644 }
2645
2646
2647 static int wpa_supplicant_process_smk_error(
2648         struct wpa_sm *sm, const unsigned char *src_addr,
2649         const struct wpa_eapol_key *key, size_t extra_len)
2650 {
2651         struct wpa_ssid *ssid = sm->cur_ssid;
2652         struct wpa_eapol_ie_parse kde;
2653         struct rsn_error_kde error;
2654         u8 peer[ETH_ALEN];
2655         u16 error_type;
2656
2657         wpa_printf(MSG_DEBUG, "RSN: Received SMK Error");
2658
2659         if (ssid == NULL || !ssid->peerkey || sm->proto != WPA_PROTO_RSN) {
2660                 wpa_printf(MSG_DEBUG, "RSN: SMK handshake not allowed for "
2661                            "the current network");
2662                 return -1;
2663         }
2664
2665         if (wpa_supplicant_parse_ies((const u8 *) (key + 1), extra_len, &kde) <
2666             0) {
2667                 wpa_printf(MSG_INFO, "RSN: Failed to parse KDEs in SMK Error");
2668                 return -1;
2669         }
2670
2671         if (kde.error == NULL || kde.error_len < sizeof(error)) {
2672                 wpa_printf(MSG_INFO, "RSN: No Error KDE in SMK Error");
2673                 return -1;
2674         }
2675
2676         if (kde.mac_addr && kde.mac_addr_len >= ETH_ALEN)
2677                 os_memcpy(peer, kde.mac_addr, ETH_ALEN);
2678         os_memcpy(&error, kde.error, sizeof(error));
2679         error_type = be_to_host16(error.error_type);
2680         wpa_msg(sm->ctx->ctx, MSG_INFO,
2681                 "RSN: SMK Error KDE received: MUI %d error_type %d peer "
2682                 MACSTR,
2683                 be_to_host16(error.mui), error_type,
2684                 MAC2STR(peer));
2685
2686         if (kde.mac_addr &&
2687             (error_type == STK_ERR_STA_NR || error_type == STK_ERR_STA_NRSN ||
2688              error_type == STK_ERR_CPHR_NS)) {
2689                 struct wpa_peerkey *peerkey;
2690
2691                 for (peerkey = sm->peerkey; peerkey; peerkey = peerkey->next) {
2692                         if (os_memcmp(peerkey->addr, kde.mac_addr, ETH_ALEN) ==
2693                             0)
2694                                 break;
2695                 }
2696                 if (peerkey == NULL) {
2697                         wpa_printf(MSG_DEBUG, "RSN: No matching SMK handshake "
2698                                    "found for SMK Error");
2699                         return -1;
2700                 }
2701                 /* TODO: abort SMK/STK handshake and remove all related keys */
2702         }
2703
2704         return 0;
2705 }
2706
2707
2708 static void wpa_supplicant_process_stk_1_of_4(struct wpa_sm *sm,
2709                                               struct wpa_peerkey *peerkey,
2710                                               const struct wpa_eapol_key *key,
2711                                               u16 ver)
2712 {
2713         struct wpa_eapol_ie_parse ie;
2714         const u8 *kde;
2715         size_t len, kde_buf_len;
2716         struct wpa_ptk *stk;
2717         u8 buf[8], *kde_buf, *pos;
2718         u32 lifetime;
2719
2720         wpa_printf(MSG_DEBUG, "RSN: RX message 1 of STK 4-Way Handshake from "
2721                    MACSTR " (ver=%d)", MAC2STR(peerkey->addr), ver);
2722
2723         os_memset(&ie, 0, sizeof(ie));
2724
2725         /* RSN: msg 1/4 should contain SMKID for the selected SMK */
2726         kde = (const u8 *) (key + 1);
2727         len = WPA_GET_BE16(key->key_data_length);
2728         wpa_hexdump(MSG_DEBUG, "RSN: msg 1/4 key data", kde, len);
2729         if (wpa_supplicant_parse_ies(kde, len, &ie) < 0 || ie.pmkid == NULL) {
2730                 wpa_printf(MSG_DEBUG, "RSN: No SMKID in STK 1/4");
2731                 return;
2732         }
2733         if (os_memcmp(ie.pmkid, peerkey->smkid, PMKID_LEN) != 0) {
2734                 wpa_hexdump(MSG_DEBUG, "RSN: Unknown SMKID in STK 1/4",
2735                             ie.pmkid, PMKID_LEN);
2736                 return;
2737         }
2738
2739         if (hostapd_get_rand(peerkey->pnonce, WPA_NONCE_LEN)) {
2740                 wpa_msg(sm->ctx->ctx, MSG_WARNING,
2741                         "RSN: Failed to get random data for PNonce");
2742                 return;
2743         }
2744         wpa_hexdump(MSG_DEBUG, "WPA: Renewed PNonce",
2745                     peerkey->pnonce, WPA_NONCE_LEN);
2746
2747         /* Calculate STK which will be stored as a temporary STK until it has
2748          * been verified when processing message 3/4. */
2749         stk = &peerkey->tstk;
2750         wpa_pmk_to_ptk(peerkey->smk, PMK_LEN, "Peer key expansion",
2751                        sm->own_addr, peerkey->addr,
2752                        peerkey->pnonce, key->key_nonce,
2753                        (u8 *) stk, sizeof(*stk));
2754         /* Supplicant: swap tx/rx Mic keys */
2755         os_memcpy(buf, stk->u.auth.tx_mic_key, 8);
2756         os_memcpy(stk->u.auth.tx_mic_key, stk->u.auth.rx_mic_key, 8);
2757         os_memcpy(stk->u.auth.rx_mic_key, buf, 8);
2758         peerkey->tstk_set = 1;
2759
2760         kde_buf_len = peerkey->rsnie_p_len +
2761                 2 + RSN_SELECTOR_LEN + sizeof(lifetime) +
2762                 2 + RSN_SELECTOR_LEN + PMKID_LEN;
2763         kde_buf = os_malloc(kde_buf_len);
2764         if (kde_buf == NULL)
2765                 return;
2766         pos = kde_buf;
2767         pos = wpa_add_ie(pos, peerkey->rsnie_p, peerkey->rsnie_p_len);
2768         lifetime = host_to_be32(peerkey->lifetime);
2769         pos = wpa_add_kde(pos, RSN_KEY_DATA_LIFETIME,
2770                           (u8 *) &lifetime, sizeof(lifetime));
2771         pos = wpa_add_kde(pos, RSN_KEY_DATA_PMKID, peerkey->smkid, PMKID_LEN);
2772
2773         if (wpa_supplicant_send_2_of_4(sm, peerkey->addr, key, ver,
2774                                        peerkey->pnonce, kde_buf, kde_buf_len,
2775                                        stk)) {
2776                 os_free(kde_buf);
2777                 return;
2778         }
2779         os_free(kde_buf);
2780
2781         os_memcpy(peerkey->inonce, key->key_nonce, WPA_NONCE_LEN);
2782 }
2783
2784
2785 static void wpa_supplicant_update_smk_lifetime(struct wpa_sm *sm,
2786                                                struct wpa_peerkey *peerkey,
2787                                                struct wpa_eapol_ie_parse *kde)
2788 {
2789         u32 lifetime;
2790         struct os_time now;
2791
2792         if (kde->lifetime == NULL || kde->lifetime_len < sizeof(lifetime))
2793                 return;
2794
2795         lifetime = WPA_GET_BE32(kde->lifetime);
2796
2797         if (lifetime >= peerkey->lifetime) {
2798                 wpa_printf(MSG_DEBUG, "RSN: Peer used SMK lifetime %u seconds "
2799                            "which is larger than or equal to own value %u "
2800                            "seconds - ignored", lifetime, peerkey->lifetime);
2801                 return;
2802         }
2803
2804         wpa_printf(MSG_DEBUG, "RSN: Peer used shorter SMK lifetime %u seconds "
2805                    "(own was %u seconds) - updated",
2806                    lifetime, peerkey->lifetime);
2807         peerkey->lifetime = lifetime;
2808
2809         os_get_time(&now);
2810         peerkey->expiration = now.sec + lifetime;
2811         eloop_cancel_timeout(wpa_supplicant_smk_timeout, sm, peerkey);
2812         eloop_register_timeout(lifetime, 0, wpa_supplicant_smk_timeout,
2813                                sm, peerkey);
2814 }
2815
2816
2817 static void wpa_supplicant_process_stk_2_of_4(struct wpa_sm *sm,
2818                                               struct wpa_peerkey *peerkey,
2819                                               const struct wpa_eapol_key *key,
2820                                               u16 ver)
2821 {
2822         struct wpa_eapol_ie_parse kde;
2823         const u8 *keydata;
2824         size_t len;
2825
2826         wpa_printf(MSG_DEBUG, "RSN: RX message 2 of STK 4-Way Handshake from "
2827                    MACSTR " (ver=%d)", MAC2STR(peerkey->addr), ver);
2828
2829         os_memset(&kde, 0, sizeof(kde));
2830
2831         /* RSN: msg 2/4 should contain SMKID for the selected SMK and RSN IE
2832          * from the peer. It may also include Lifetime KDE. */
2833         keydata = (const u8 *) (key + 1);
2834         len = WPA_GET_BE16(key->key_data_length);
2835         wpa_hexdump(MSG_DEBUG, "RSN: msg 2/4 key data", keydata, len);
2836         if (wpa_supplicant_parse_ies(keydata, len, &kde) < 0 ||
2837             kde.pmkid == NULL || kde.rsn_ie == NULL) {
2838                 wpa_printf(MSG_DEBUG, "RSN: No SMKID or RSN IE in STK 2/4");
2839                 return;
2840         }
2841
2842         if (os_memcmp(kde.pmkid, peerkey->smkid, PMKID_LEN) != 0) {
2843                 wpa_hexdump(MSG_DEBUG, "RSN: Unknown SMKID in STK 2/4",
2844                             kde.pmkid, PMKID_LEN);
2845                 return;
2846         }
2847
2848         if (kde.rsn_ie_len != peerkey->rsnie_p_len ||
2849             os_memcmp(kde.rsn_ie, peerkey->rsnie_p, kde.rsn_ie_len) != 0) {
2850                 wpa_printf(MSG_INFO, "RSN: Peer RSN IE in SMK and STK "
2851                            "handshakes did not match");
2852                 wpa_hexdump(MSG_DEBUG, "RSN: Peer RSN IE in SMK handshake",
2853                             peerkey->rsnie_p, peerkey->rsnie_p_len);
2854                 wpa_hexdump(MSG_DEBUG, "RSN: Peer RSN IE in STK handshake",
2855                             kde.rsn_ie, kde.rsn_ie_len);
2856                 return;
2857         }
2858
2859         wpa_supplicant_update_smk_lifetime(sm, peerkey, &kde);
2860
2861         wpa_supplicant_send_stk_3_of_4(sm, peerkey);
2862         os_memcpy(peerkey->pnonce, key->key_nonce, WPA_NONCE_LEN);
2863 }
2864
2865
2866 static void wpa_supplicant_process_stk_3_of_4(struct wpa_sm *sm,
2867                                               struct wpa_peerkey *peerkey,
2868                                               const struct wpa_eapol_key *key,
2869                                               u16 ver)
2870 {
2871         struct wpa_eapol_ie_parse kde;
2872         const u8 *keydata;
2873         size_t len, key_len;
2874         const u8 *_key;
2875         u8 key_buf[32], rsc[6];
2876
2877         wpa_printf(MSG_DEBUG, "RSN: RX message 3 of STK 4-Way Handshake from "
2878                    MACSTR " (ver=%d)", MAC2STR(peerkey->addr), ver);
2879
2880         os_memset(&kde, 0, sizeof(kde));
2881
2882         /* RSN: msg 3/4 should contain Initiator RSN IE. It may also include
2883          * Lifetime KDE. */
2884         keydata = (const u8 *) (key + 1);
2885         len = WPA_GET_BE16(key->key_data_length);
2886         wpa_hexdump(MSG_DEBUG, "RSN: msg 3/4 key data", keydata, len);
2887         if (wpa_supplicant_parse_ies(keydata, len, &kde) < 0) {
2888                 wpa_printf(MSG_DEBUG, "RSN: Failed to parse key data in "
2889                            "STK 3/4");
2890                 return;
2891         }
2892
2893         if (kde.rsn_ie_len != peerkey->rsnie_i_len ||
2894             os_memcmp(kde.rsn_ie, peerkey->rsnie_i, kde.rsn_ie_len) != 0) {
2895                 wpa_printf(MSG_INFO, "RSN: Initiator RSN IE in SMK and STK "
2896                            "handshakes did not match");
2897                 wpa_hexdump(MSG_DEBUG, "RSN: Initiator RSN IE in SMK "
2898                             "handshake",
2899                             peerkey->rsnie_i, peerkey->rsnie_i_len);
2900                 wpa_hexdump(MSG_DEBUG, "RSN: Initiator RSN IE in STK "
2901                             "handshake",
2902                             kde.rsn_ie, kde.rsn_ie_len);
2903                 return;
2904         }
2905
2906         if (os_memcmp(peerkey->inonce, key->key_nonce, WPA_NONCE_LEN) != 0) {
2907                 wpa_printf(MSG_WARNING, "RSN: INonce from message 1 of STK "
2908                            "4-Way Handshake differs from 3 of STK 4-Way "
2909                            "Handshake - drop packet (src=" MACSTR ")",
2910                            MAC2STR(peerkey->addr));
2911                 return;
2912         }
2913
2914         wpa_supplicant_update_smk_lifetime(sm, peerkey, &kde);
2915
2916         if (wpa_supplicant_send_4_of_4(sm, peerkey->addr, key, ver,
2917                                        WPA_GET_BE16(key->key_info),
2918                                        NULL, 0, &peerkey->stk))
2919                 return;
2920
2921         _key = (u8 *) peerkey->stk.tk1;
2922         if (peerkey->cipher == WPA_CIPHER_TKIP) {
2923                 /* Swap Tx/Rx keys for Michael MIC */
2924                 os_memcpy(key_buf, _key, 16);
2925                 os_memcpy(key_buf + 16, _key + 24, 8);
2926                 os_memcpy(key_buf + 24, _key + 16, 8);
2927                 _key = key_buf;
2928                 key_len = 32;
2929         } else
2930                 key_len = 16;
2931
2932         os_memset(rsc, 0, 6);
2933         if (wpa_sm_set_key(sm, peerkey->cipher, peerkey->addr, 0, 1,
2934                            rsc, sizeof(rsc), _key, key_len) < 0) {
2935                 wpa_printf(MSG_WARNING, "RSN: Failed to set STK to the "
2936                            "driver.");
2937                 return;
2938         }
2939 }
2940
2941
2942 static void wpa_supplicant_process_stk_4_of_4(struct wpa_sm *sm,
2943                                               struct wpa_peerkey *peerkey,
2944                                               const struct wpa_eapol_key *key,
2945                                               u16 ver)
2946 {
2947         u8 rsc[6];
2948
2949         wpa_printf(MSG_DEBUG, "RSN: RX message 4 of STK 4-Way Handshake from "
2950                    MACSTR " (ver=%d)", MAC2STR(peerkey->addr), ver);
2951
2952         os_memset(rsc, 0, 6);
2953         if (wpa_sm_set_key(sm, peerkey->cipher, peerkey->addr, 0, 1,
2954                            rsc, sizeof(rsc), (u8 *) peerkey->stk.tk1,
2955                            peerkey->cipher == WPA_CIPHER_TKIP ? 32 : 16) < 0) {
2956                 wpa_printf(MSG_WARNING, "RSN: Failed to set STK to the "
2957                            "driver.");
2958                 return;
2959         }
2960 }
2961 #endif /* CONFIG_PEERKEY */
2962
2963
2964 static int wpa_supplicant_process_1_of_2_rsn(struct wpa_sm *sm,
2965                                              const u8 *keydata,
2966                                              size_t keydatalen,
2967                                              u16 key_info,
2968                                              struct wpa_gtk_data *gd)
2969 {
2970         int maxkeylen;
2971         struct wpa_eapol_ie_parse ie;
2972
2973         wpa_hexdump(MSG_DEBUG, "RSN: msg 1/2 key data", keydata, keydatalen);
2974         wpa_supplicant_parse_ies(keydata, keydatalen, &ie);
2975         if (ie.gtk && !(key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) {
2976                 wpa_printf(MSG_WARNING, "WPA: GTK IE in unencrypted key data");
2977                 return -1;
2978         }
2979         if (ie.gtk == NULL) {
2980                 wpa_printf(MSG_INFO, "WPA: No GTK IE in Group Key msg 1/2");
2981                 return -1;
2982         }
2983         maxkeylen = gd->gtk_len = ie.gtk_len - 2;
2984
2985         if (wpa_supplicant_check_group_cipher(sm->group_cipher,
2986                                               gd->gtk_len, maxkeylen,
2987                                               &gd->key_rsc_len, &gd->alg))
2988                 return -1;
2989
2990         wpa_hexdump(MSG_DEBUG, "RSN: received GTK in group key handshake",
2991                     ie.gtk, ie.gtk_len);
2992         gd->keyidx = ie.gtk[0] & 0x3;
2993         gd->tx = wpa_supplicant_gtk_tx_bit_workaround(sm,
2994                                                       !!(ie.gtk[0] & BIT(2)));
2995         if (ie.gtk_len - 2 > sizeof(gd->gtk)) {
2996                 wpa_printf(MSG_INFO, "RSN: Too long GTK in GTK IE "
2997                            "(len=%lu)", (unsigned long) ie.gtk_len - 2);
2998                 return -1;
2999         }
3000         os_memcpy(gd->gtk, ie.gtk + 2, ie.gtk_len - 2);
3001
3002         if (ieee80211w_set_keys(sm, &ie) < 0)
3003                 wpa_printf(MSG_INFO, "RSN: Failed to configure DHV/IGTK");
3004
3005         return 0;
3006 }
3007
3008
3009 static int wpa_supplicant_process_1_of_2_wpa(struct wpa_sm *sm,
3010                                              const struct wpa_eapol_key *key,
3011                                              size_t keydatalen, int key_info,
3012                                              size_t extra_len, u16 ver,
3013                                              struct wpa_gtk_data *gd)
3014 {
3015         size_t maxkeylen;
3016         u8 ek[32];
3017
3018         gd->gtk_len = WPA_GET_BE16(key->key_length);
3019         maxkeylen = keydatalen;
3020         if (keydatalen > extra_len) {
3021                 wpa_printf(MSG_INFO, "WPA: Truncated EAPOL-Key packet:"
3022                            " key_data_length=%lu > extra_len=%lu",
3023                            (unsigned long) keydatalen,
3024                            (unsigned long) extra_len);
3025                 return -1;
3026         }
3027         if (ver == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
3028                 if (maxkeylen < 8) {
3029                         wpa_printf(MSG_INFO, "WPA: Too short maxkeylen (%lu)",
3030                                    (unsigned long) maxkeylen);
3031                         return -1;
3032                 }
3033                 maxkeylen -= 8;
3034         }
3035
3036         if (wpa_supplicant_check_group_cipher(sm->group_cipher,
3037                                               gd->gtk_len, maxkeylen,
3038                                               &gd->key_rsc_len, &gd->alg))
3039                 return -1;
3040
3041         gd->keyidx = (key_info & WPA_KEY_INFO_KEY_INDEX_MASK) >>
3042                 WPA_KEY_INFO_KEY_INDEX_SHIFT;
3043         if (ver == WPA_KEY_INFO_TYPE_HMAC_MD5_RC4) {
3044                 os_memcpy(ek, key->key_iv, 16);
3045                 os_memcpy(ek + 16, sm->ptk.kek, 16);
3046                 if (keydatalen > sizeof(gd->gtk)) {
3047                         wpa_printf(MSG_WARNING, "WPA: RC4 key data "
3048                                    "too long (%lu)",
3049                                    (unsigned long) keydatalen);
3050                         return -1;
3051                 }
3052                 os_memcpy(gd->gtk, key + 1, keydatalen);
3053                 rc4_skip(ek, 32, 256, gd->gtk, keydatalen);
3054         } else if (ver == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
3055                 if (keydatalen % 8) {
3056                         wpa_printf(MSG_WARNING, "WPA: Unsupported AES-WRAP "
3057                                    "len %lu", (unsigned long) keydatalen);
3058                         return -1;
3059                 }
3060                 if (maxkeylen > sizeof(gd->gtk)) {
3061                         wpa_printf(MSG_WARNING, "WPA: AES-WRAP key data "
3062                                    "too long (keydatalen=%lu maxkeylen=%lu)",
3063                                    (unsigned long) keydatalen,
3064                                    (unsigned long) maxkeylen);
3065                         return -1;
3066                 }
3067                 if (aes_unwrap(sm->ptk.kek, maxkeylen / 8,
3068                                (const u8 *) (key + 1), gd->gtk)) {
3069                         wpa_printf(MSG_WARNING, "WPA: AES unwrap "
3070                                    "failed - could not decrypt GTK");
3071                         return -1;
3072                 }
3073         }
3074         gd->tx = wpa_supplicant_gtk_tx_bit_workaround(
3075                 sm, !!(key_info & WPA_KEY_INFO_TXRX));
3076         return 0;
3077 }
3078
3079
3080 static int wpa_supplicant_send_2_of_2(struct wpa_sm *sm,
3081                                       const struct wpa_eapol_key *key,
3082                                       int ver, u16 key_info)
3083 {
3084         size_t rlen;
3085         struct wpa_eapol_key *reply;
3086         u8 *rbuf;
3087
3088         rbuf = wpa_sm_alloc_eapol(sm, IEEE802_1X_TYPE_EAPOL_KEY, NULL,
3089                                   sizeof(*reply), &rlen, (void *) &reply);
3090         if (rbuf == NULL)
3091                 return -1;
3092
3093         reply->type = sm->proto == WPA_PROTO_RSN ?
3094                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
3095         key_info &= WPA_KEY_INFO_KEY_INDEX_MASK;
3096         key_info |= ver | WPA_KEY_INFO_MIC | WPA_KEY_INFO_SECURE;
3097         WPA_PUT_BE16(reply->key_info, key_info);
3098         if (sm->proto == WPA_PROTO_RSN)
3099                 WPA_PUT_BE16(reply->key_length, 0);
3100         else
3101                 os_memcpy(reply->key_length, key->key_length, 2);
3102         os_memcpy(reply->replay_counter, key->replay_counter,
3103                   WPA_REPLAY_COUNTER_LEN);
3104
3105         WPA_PUT_BE16(reply->key_data_length, 0);
3106
3107         wpa_printf(MSG_DEBUG, "WPA: Sending EAPOL-Key 2/2");
3108         wpa_eapol_key_send(sm, sm->ptk.kck, ver, sm->bssid, ETH_P_EAPOL,
3109                            rbuf, rlen, reply->key_mic);
3110
3111         return 0;
3112 }
3113
3114
3115 static void wpa_supplicant_process_1_of_2(struct wpa_sm *sm,
3116                                           const unsigned char *src_addr,
3117                                           const struct wpa_eapol_key *key,
3118                                           int extra_len, u16 ver)
3119 {
3120         u16 key_info, keydatalen;
3121         int rekey, ret;
3122         struct wpa_gtk_data gd;
3123
3124         os_memset(&gd, 0, sizeof(gd));
3125
3126         rekey = wpa_sm_get_state(sm) == WPA_COMPLETED;
3127         wpa_printf(MSG_DEBUG, "WPA: RX message 1 of Group Key Handshake from "
3128                    MACSTR " (ver=%d)", MAC2STR(src_addr), ver);
3129
3130         key_info = WPA_GET_BE16(key->key_info);
3131         keydatalen = WPA_GET_BE16(key->key_data_length);
3132
3133         if (sm->proto == WPA_PROTO_RSN) {
3134                 ret = wpa_supplicant_process_1_of_2_rsn(sm,
3135                                                         (const u8 *) (key + 1),
3136                                                         keydatalen, key_info,
3137                                                         &gd);
3138         } else {
3139                 ret = wpa_supplicant_process_1_of_2_wpa(sm, key, keydatalen,
3140                                                         key_info, extra_len,
3141                                                         ver, &gd);
3142         }
3143
3144         wpa_sm_set_state(sm, WPA_GROUP_HANDSHAKE);
3145
3146         if (ret)
3147                 return;
3148
3149         if (wpa_supplicant_install_gtk(sm, &gd, key->key_rsc) ||
3150             wpa_supplicant_send_2_of_2(sm, key, ver, key_info))
3151                 return;
3152
3153         if (rekey) {
3154                 wpa_msg(sm->ctx->ctx, MSG_INFO, "WPA: Group rekeying "
3155                         "completed with " MACSTR " [GTK=%s]",
3156                         MAC2STR(sm->bssid), wpa_cipher_txt(sm->group_cipher));
3157                 wpa_sm_set_state(sm, WPA_COMPLETED);
3158         } else {
3159                 wpa_supplicant_key_neg_complete(sm, sm->bssid,
3160                                                 key_info &
3161                                                 WPA_KEY_INFO_SECURE);
3162         }
3163 }
3164
3165
3166 static int wpa_supplicant_verify_eapol_key_mic(struct wpa_sm *sm,
3167                                                struct wpa_eapol_key *key,
3168                                                u16 ver,
3169                                                const u8 *buf, size_t len)
3170 {
3171         u8 mic[16];
3172         int ok = 0;
3173
3174         os_memcpy(mic, key->key_mic, 16);
3175         if (sm->tptk_set) {
3176                 os_memset(key->key_mic, 0, 16);
3177                 wpa_eapol_key_mic(sm->tptk.kck, ver, buf, len,
3178                                   key->key_mic);
3179                 if (os_memcmp(mic, key->key_mic, 16) != 0) {
3180                         wpa_printf(MSG_WARNING, "WPA: Invalid EAPOL-Key MIC "
3181                                    "when using TPTK - ignoring TPTK");
3182                 } else {
3183                         ok = 1;
3184                         sm->tptk_set = 0;
3185                         sm->ptk_set = 1;
3186                         os_memcpy(&sm->ptk, &sm->tptk, sizeof(sm->ptk));
3187                 }
3188         }
3189
3190         if (!ok && sm->ptk_set) {
3191                 os_memset(key->key_mic, 0, 16);
3192                 wpa_eapol_key_mic(sm->ptk.kck, ver, buf, len,
3193                                   key->key_mic);
3194                 if (os_memcmp(mic, key->key_mic, 16) != 0) {
3195                         wpa_printf(MSG_WARNING, "WPA: Invalid EAPOL-Key MIC "
3196                                    "- dropping packet");
3197                         return -1;
3198                 }
3199                 ok = 1;
3200         }
3201
3202         if (!ok) {
3203                 wpa_printf(MSG_WARNING, "WPA: Could not verify EAPOL-Key MIC "
3204                            "- dropping packet");
3205                 return -1;
3206         }
3207
3208         os_memcpy(sm->rx_replay_counter, key->replay_counter,
3209                   WPA_REPLAY_COUNTER_LEN);
3210         sm->rx_replay_counter_set = 1;
3211         return 0;
3212 }
3213
3214
3215 #ifdef CONFIG_PEERKEY
3216 static int wpa_supplicant_verify_eapol_key_mic_peerkey(
3217         struct wpa_sm *sm, struct wpa_peerkey *peerkey,
3218         struct wpa_eapol_key *key, u16 ver, const u8 *buf, size_t len)
3219 {
3220         u8 mic[16];
3221         int ok = 0;
3222
3223         if (peerkey->initiator && !peerkey->stk_set) {
3224                 wpa_pmk_to_ptk(peerkey->smk, PMK_LEN, "Peer key expansion",
3225                                sm->own_addr, peerkey->addr,
3226                                peerkey->inonce, key->key_nonce,
3227                                (u8 *) &peerkey->stk, sizeof(peerkey->stk));
3228                 peerkey->stk_set = 1;
3229         }
3230
3231         os_memcpy(mic, key->key_mic, 16);
3232         if (peerkey->tstk_set) {
3233                 os_memset(key->key_mic, 0, 16);
3234                 wpa_eapol_key_mic(peerkey->tstk.kck, ver, buf, len,
3235                                   key->key_mic);
3236                 if (os_memcmp(mic, key->key_mic, 16) != 0) {
3237                         wpa_printf(MSG_WARNING, "RSN: Invalid EAPOL-Key MIC "
3238                                    "when using TSTK - ignoring TSTK");
3239                 } else {
3240                         ok = 1;
3241                         peerkey->tstk_set = 0;
3242                         peerkey->stk_set = 1;
3243                         os_memcpy(&peerkey->stk, &peerkey->tstk,
3244                                   sizeof(peerkey->stk));
3245                 }
3246         }
3247
3248         if (!ok && peerkey->stk_set) {
3249                 os_memset(key->key_mic, 0, 16);
3250                 wpa_eapol_key_mic(peerkey->stk.kck, ver, buf, len,
3251                                   key->key_mic);
3252                 if (os_memcmp(mic, key->key_mic, 16) != 0) {
3253                         wpa_printf(MSG_WARNING, "RSN: Invalid EAPOL-Key MIC "
3254                                    "- dropping packet");
3255                         return -1;
3256                 }
3257                 ok = 1;
3258         }
3259
3260         if (!ok) {
3261                 wpa_printf(MSG_WARNING, "RSN: Could not verify EAPOL-Key MIC "
3262                            "- dropping packet");
3263                 return -1;
3264         }
3265
3266         os_memcpy(peerkey->replay_counter, key->replay_counter,
3267                   WPA_REPLAY_COUNTER_LEN);
3268         peerkey->replay_counter_set = 1;
3269         return 0;
3270 }
3271 #endif /* CONFIG_PEERKEY */
3272
3273
3274 /* Decrypt RSN EAPOL-Key key data (RC4 or AES-WRAP) */
3275 static int wpa_supplicant_decrypt_key_data(struct wpa_sm *sm,
3276                                            struct wpa_eapol_key *key, u16 ver)
3277 {
3278         u16 keydatalen = WPA_GET_BE16(key->key_data_length);
3279
3280         wpa_hexdump(MSG_DEBUG, "RSN: encrypted key data",
3281                     (u8 *) (key + 1), keydatalen);
3282         if (!sm->ptk_set) {
3283                 wpa_printf(MSG_WARNING, "WPA: PTK not available, "
3284                            "cannot decrypt EAPOL-Key key data.");
3285                 return -1;
3286         }
3287
3288         /* Decrypt key data here so that this operation does not need
3289          * to be implemented separately for each message type. */
3290         if (ver == WPA_KEY_INFO_TYPE_HMAC_MD5_RC4) {
3291                 u8 ek[32];
3292                 os_memcpy(ek, key->key_iv, 16);
3293                 os_memcpy(ek + 16, sm->ptk.kek, 16);
3294                 rc4_skip(ek, 32, 256, (u8 *) (key + 1), keydatalen);
3295         } else if (ver == WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
3296                 u8 *buf;
3297                 if (keydatalen % 8) {
3298                         wpa_printf(MSG_WARNING, "WPA: Unsupported "
3299                                    "AES-WRAP len %d", keydatalen);
3300                         return -1;
3301                 }
3302                 keydatalen -= 8; /* AES-WRAP adds 8 bytes */
3303                 buf = os_malloc(keydatalen);
3304                 if (buf == NULL) {
3305                         wpa_printf(MSG_WARNING, "WPA: No memory for "
3306                                    "AES-UNWRAP buffer");
3307                         return -1;
3308                 }
3309                 if (aes_unwrap(sm->ptk.kek, keydatalen / 8,
3310                                (u8 *) (key + 1), buf)) {
3311                         os_free(buf);
3312                         wpa_printf(MSG_WARNING, "WPA: AES unwrap failed - "
3313                                    "could not decrypt EAPOL-Key key data");
3314                         return -1;
3315                 }
3316                 os_memcpy(key + 1, buf, keydatalen);
3317                 os_free(buf);
3318                 WPA_PUT_BE16(key->key_data_length, keydatalen);
3319         }
3320         wpa_hexdump_key(MSG_DEBUG, "WPA: decrypted EAPOL-Key key data",
3321                         (u8 *) (key + 1), keydatalen);
3322         return 0;
3323 }
3324
3325
3326 /**
3327  * wpa_sm_aborted_cached - Notify WPA that PMKSA caching was aborted
3328  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3329  */
3330 void wpa_sm_aborted_cached(struct wpa_sm *sm)
3331 {
3332         if (sm && sm->cur_pmksa) {
3333                 wpa_printf(MSG_DEBUG, "RSN: Cancelling PMKSA caching attempt");
3334                 sm->cur_pmksa = NULL;
3335         }
3336 }
3337
3338
3339 static void wpa_eapol_key_dump(const struct wpa_eapol_key *key)
3340 {
3341 #ifndef CONFIG_NO_STDOUT_DEBUG
3342         u16 key_info = WPA_GET_BE16(key->key_info);
3343
3344         wpa_printf(MSG_DEBUG, "  EAPOL-Key type=%d", key->type);
3345         wpa_printf(MSG_DEBUG, "  key_info 0x%x (ver=%d keyidx=%d rsvd=%d %s"
3346                    "%s%s%s%s%s%s%s)",
3347                    key_info, key_info & WPA_KEY_INFO_TYPE_MASK,
3348                    (key_info & WPA_KEY_INFO_KEY_INDEX_MASK) >>
3349                    WPA_KEY_INFO_KEY_INDEX_SHIFT,
3350                    (key_info & (BIT(13) | BIT(14) | BIT(15))) >> 13,
3351                    key_info & WPA_KEY_INFO_KEY_TYPE ? "Pairwise" : "Group",
3352                    key_info & WPA_KEY_INFO_INSTALL ? " Install" : "",
3353                    key_info & WPA_KEY_INFO_ACK ? " Ack" : "",
3354                    key_info & WPA_KEY_INFO_MIC ? " MIC" : "",
3355                    key_info & WPA_KEY_INFO_SECURE ? " Secure" : "",
3356                    key_info & WPA_KEY_INFO_ERROR ? " Error" : "",
3357                    key_info & WPA_KEY_INFO_REQUEST ? " Request" : "",
3358                    key_info & WPA_KEY_INFO_ENCR_KEY_DATA ? " Encr" : "");
3359         wpa_printf(MSG_DEBUG, "  key_length=%u key_data_length=%u",
3360                    WPA_GET_BE16(key->key_length),
3361                    WPA_GET_BE16(key->key_data_length));
3362         wpa_hexdump(MSG_DEBUG, "  replay_counter",
3363                     key->replay_counter, WPA_REPLAY_COUNTER_LEN);
3364         wpa_hexdump(MSG_DEBUG, "  key_nonce", key->key_nonce, WPA_NONCE_LEN);
3365         wpa_hexdump(MSG_DEBUG, "  key_iv", key->key_iv, 16);
3366         wpa_hexdump(MSG_DEBUG, "  key_rsc", key->key_rsc, 8);
3367         wpa_hexdump(MSG_DEBUG, "  key_id (reserved)", key->key_id, 8);
3368         wpa_hexdump(MSG_DEBUG, "  key_mic", key->key_mic, 16);
3369 #endif /* CONFIG_NO_STDOUT_DEBUG */
3370 }
3371
3372
3373 /**
3374  * wpa_sm_rx_eapol - Process received WPA EAPOL frames
3375  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3376  * @src_addr: Source MAC address of the EAPOL packet
3377  * @buf: Pointer to the beginning of the EAPOL data (EAPOL header)
3378  * @len: Length of the EAPOL frame
3379  * Returns: 1 = WPA EAPOL-Key processed, 0 = not a WPA EAPOL-Key, -1 failure
3380  *
3381  * This function is called for each received EAPOL frame. Other than EAPOL-Key
3382  * frames can be skipped if filtering is done elsewhere. wpa_sm_rx_eapol() is
3383  * only processing WPA and WPA2 EAPOL-Key frames.
3384  *
3385  * The received EAPOL-Key packets are validated and valid packets are replied
3386  * to. In addition, key material (PTK, GTK) is configured at the end of a
3387  * successful key handshake.
3388  */
3389 int wpa_sm_rx_eapol(struct wpa_sm *sm, const u8 *src_addr,
3390                     const u8 *buf, size_t len)
3391 {
3392         size_t plen, data_len, extra_len;
3393         struct ieee802_1x_hdr *hdr;
3394         struct wpa_eapol_key *key;
3395         u16 key_info, ver;
3396         u8 *tmp;
3397         int ret = -1;
3398         struct wpa_peerkey *peerkey = NULL;
3399
3400         if (len < sizeof(*hdr) + sizeof(*key)) {
3401                 wpa_printf(MSG_DEBUG, "WPA: EAPOL frame too short to be a WPA "
3402                            "EAPOL-Key (len %lu, expecting at least %lu)",
3403                            (unsigned long) len,
3404                            (unsigned long) sizeof(*hdr) + sizeof(*key));
3405                 return 0;
3406         }
3407
3408         tmp = os_malloc(len);
3409         if (tmp == NULL)
3410                 return -1;
3411         os_memcpy(tmp, buf, len);
3412
3413         hdr = (struct ieee802_1x_hdr *) tmp;
3414         key = (struct wpa_eapol_key *) (hdr + 1);
3415         plen = be_to_host16(hdr->length);
3416         data_len = plen + sizeof(*hdr);
3417         wpa_printf(MSG_DEBUG, "IEEE 802.1X RX: version=%d type=%d length=%lu",
3418                    hdr->version, hdr->type, (unsigned long) plen);
3419
3420         if (hdr->version < EAPOL_VERSION) {
3421                 /* TODO: backwards compatibility */
3422         }
3423         if (hdr->type != IEEE802_1X_TYPE_EAPOL_KEY) {
3424                 wpa_printf(MSG_DEBUG, "WPA: EAPOL frame (type %u) discarded, "
3425                         "not a Key frame", hdr->type);
3426                 ret = 0;
3427                 goto out;
3428         }
3429         if (plen > len - sizeof(*hdr) || plen < sizeof(*key)) {
3430                 wpa_printf(MSG_DEBUG, "WPA: EAPOL frame payload size %lu "
3431                            "invalid (frame size %lu)",
3432                            (unsigned long) plen, (unsigned long) len);
3433                 ret = 0;
3434                 goto out;
3435         }
3436
3437         if (key->type != EAPOL_KEY_TYPE_WPA && key->type != EAPOL_KEY_TYPE_RSN)
3438         {
3439                 wpa_printf(MSG_DEBUG, "WPA: EAPOL-Key type (%d) unknown, "
3440                            "discarded", key->type);
3441                 ret = 0;
3442                 goto out;
3443         }
3444         wpa_eapol_key_dump(key);
3445
3446         eapol_sm_notify_lower_layer_success(sm->eapol);
3447         wpa_hexdump(MSG_MSGDUMP, "WPA: RX EAPOL-Key", tmp, len);
3448         if (data_len < len) {
3449                 wpa_printf(MSG_DEBUG, "WPA: ignoring %lu bytes after the IEEE "
3450                            "802.1X data", (unsigned long) len - data_len);
3451         }
3452         key_info = WPA_GET_BE16(key->key_info);
3453         ver = key_info & WPA_KEY_INFO_TYPE_MASK;
3454         if (ver != WPA_KEY_INFO_TYPE_HMAC_MD5_RC4 &&
3455             ver != WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
3456                 wpa_printf(MSG_INFO, "WPA: Unsupported EAPOL-Key descriptor "
3457                            "version %d.", ver);
3458                 goto out;
3459         }
3460
3461         if (sm->pairwise_cipher == WPA_CIPHER_CCMP &&
3462             ver != WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
3463                 wpa_printf(MSG_INFO, "WPA: CCMP is used, but EAPOL-Key "
3464                            "descriptor version (%d) is not 2.", ver);
3465                 if (sm->group_cipher != WPA_CIPHER_CCMP &&
3466                     !(key_info & WPA_KEY_INFO_KEY_TYPE)) {
3467                         /* Earlier versions of IEEE 802.11i did not explicitly
3468                          * require version 2 descriptor for all EAPOL-Key
3469                          * packets, so allow group keys to use version 1 if
3470                          * CCMP is not used for them. */
3471                         wpa_printf(MSG_INFO, "WPA: Backwards compatibility: "
3472                                    "allow invalid version for non-CCMP group "
3473                                    "keys");
3474                 } else
3475                         goto out;
3476         }
3477
3478 #ifdef CONFIG_PEERKEY
3479         for (peerkey = sm->peerkey; peerkey; peerkey = peerkey->next) {
3480                 if (os_memcmp(peerkey->addr, src_addr, ETH_ALEN) == 0)
3481                         break;
3482         }
3483
3484         if (!(key_info & WPA_KEY_INFO_SMK_MESSAGE) && peerkey) {
3485                 if (!peerkey->initiator && peerkey->replay_counter_set &&
3486                     os_memcmp(key->replay_counter, peerkey->replay_counter,
3487                               WPA_REPLAY_COUNTER_LEN) <= 0) {
3488                         wpa_printf(MSG_WARNING, "RSN: EAPOL-Key Replay "
3489                                    "Counter did not increase (STK) - dropping "
3490                                    "packet");
3491                         goto out;
3492                 } else if (peerkey->initiator) {
3493                         u8 _tmp[WPA_REPLAY_COUNTER_LEN];
3494                         os_memcpy(_tmp, key->replay_counter,
3495                                   WPA_REPLAY_COUNTER_LEN);
3496                         inc_byte_array(_tmp, WPA_REPLAY_COUNTER_LEN);
3497                         if (os_memcmp(_tmp, peerkey->replay_counter,
3498                                       WPA_REPLAY_COUNTER_LEN) != 0) {
3499                                 wpa_printf(MSG_DEBUG, "RSN: EAPOL-Key Replay "
3500                                            "Counter did not match (STK) - "
3501                                            "dropping packet");
3502                                 goto out;
3503                         }
3504                 }
3505         }
3506
3507         if (peerkey && peerkey->initiator && (key_info & WPA_KEY_INFO_ACK)) {
3508                 wpa_printf(MSG_INFO, "RSN: Ack bit in key_info from STK peer");
3509                 goto out;
3510         }
3511 #endif /* CONFIG_PEERKEY */
3512
3513         if (!peerkey && sm->rx_replay_counter_set &&
3514             os_memcmp(key->replay_counter, sm->rx_replay_counter,
3515                       WPA_REPLAY_COUNTER_LEN) <= 0) {
3516                 wpa_printf(MSG_WARNING, "WPA: EAPOL-Key Replay Counter did not"
3517                            " increase - dropping packet");
3518                 goto out;
3519         }
3520
3521         if (!(key_info & (WPA_KEY_INFO_ACK | WPA_KEY_INFO_SMK_MESSAGE))
3522 #ifdef CONFIG_PEERKEY
3523             && (peerkey == NULL || !peerkey->initiator)
3524 #endif /* CONFIG_PEERKEY */
3525                 ) {
3526                 wpa_printf(MSG_INFO, "WPA: No Ack bit in key_info");
3527                 goto out;
3528         }
3529
3530         if (key_info & WPA_KEY_INFO_REQUEST) {
3531                 wpa_printf(MSG_INFO, "WPA: EAPOL-Key with Request bit - "
3532                            "dropped");
3533                 goto out;
3534         }
3535
3536         if ((key_info & WPA_KEY_INFO_MIC) && !peerkey &&
3537             wpa_supplicant_verify_eapol_key_mic(sm, key, ver, tmp, data_len))
3538                 goto out;
3539
3540 #ifdef CONFIG_PEERKEY
3541         if ((key_info & WPA_KEY_INFO_MIC) && peerkey &&
3542             wpa_supplicant_verify_eapol_key_mic_peerkey(
3543                     sm, peerkey, key, ver, tmp, data_len))
3544                 goto out;
3545 #endif /* CONFIG_PEERKEY */
3546
3547         extra_len = data_len - sizeof(*hdr) - sizeof(*key);
3548
3549         if (WPA_GET_BE16(key->key_data_length) > extra_len) {
3550                 wpa_msg(sm->ctx->ctx, MSG_INFO, "WPA: Invalid EAPOL-Key "
3551                         "frame - key_data overflow (%d > %lu)",
3552                         WPA_GET_BE16(key->key_data_length),
3553                         (unsigned long) extra_len);
3554                 goto out;
3555         }
3556         extra_len = WPA_GET_BE16(key->key_data_length);
3557
3558         if (sm->proto == WPA_PROTO_RSN &&
3559             (key_info & WPA_KEY_INFO_ENCR_KEY_DATA)) {
3560                 if (wpa_supplicant_decrypt_key_data(sm, key, ver))
3561                         goto out;
3562                 extra_len = WPA_GET_BE16(key->key_data_length);
3563         }
3564
3565         if (key_info & WPA_KEY_INFO_KEY_TYPE) {
3566                 if (key_info & WPA_KEY_INFO_KEY_INDEX_MASK) {
3567                         wpa_printf(MSG_WARNING, "WPA: Ignored EAPOL-Key "
3568                                    "(Pairwise) with non-zero key index");
3569                         goto out;
3570                 }
3571 #ifdef CONFIG_PEERKEY
3572                 if (peerkey) {
3573                         if ((key_info & (WPA_KEY_INFO_MIC | WPA_KEY_INFO_ACK))
3574                             == (WPA_KEY_INFO_MIC | WPA_KEY_INFO_ACK)) {
3575                                 /* 3/4 STK 4-Way Handshake */
3576                                 wpa_supplicant_process_stk_3_of_4(sm, peerkey,
3577                                                                   key, ver);
3578                         } else if (key_info & WPA_KEY_INFO_ACK) {
3579                                 /* 1/4 STK 4-Way Handshake */
3580                                 wpa_supplicant_process_stk_1_of_4(sm, peerkey,
3581                                                                   key, ver);
3582                         } else if (key_info & WPA_KEY_INFO_SECURE) {
3583                                 /* 4/4 STK 4-Way Handshake */
3584                                 wpa_supplicant_process_stk_4_of_4(sm, peerkey,
3585                                                                   key, ver);
3586                         } else {
3587                                 /* 2/4 STK 4-Way Handshake */
3588                                 wpa_supplicant_process_stk_2_of_4(sm, peerkey,
3589                                                                   key, ver);
3590                         }
3591                 } else
3592 #endif /* CONFIG_PEERKEY */
3593                 if (key_info & WPA_KEY_INFO_MIC) {
3594                         /* 3/4 4-Way Handshake */
3595                         wpa_supplicant_process_3_of_4(sm, key, ver);
3596                 } else {
3597                         /* 1/4 4-Way Handshake */
3598                         wpa_supplicant_process_1_of_4(sm, src_addr, key,
3599                                                       ver);
3600                 }
3601         } else if (key_info & WPA_KEY_INFO_SMK_MESSAGE) {
3602 #ifdef CONFIG_PEERKEY
3603                 if (key_info & WPA_KEY_INFO_ERROR) {
3604                         /* SMK Error */
3605                         wpa_supplicant_process_smk_error(sm, src_addr, key,
3606                                                          extra_len);
3607                 } else if (key_info & WPA_KEY_INFO_ACK) {
3608                         /* SMK M2 */
3609                         wpa_supplicant_process_smk_m2(sm, src_addr, key,
3610                                                       extra_len, ver);
3611                 } else {
3612                         /* SMK M4 or M5 */
3613                         wpa_supplicant_process_smk_m45(sm, src_addr, key,
3614                                                        extra_len, ver);
3615                 }
3616 #endif /* CONFIG_PEERKEY */
3617         } else {
3618                 if (key_info & WPA_KEY_INFO_MIC) {
3619                         /* 1/2 Group Key Handshake */
3620                         wpa_supplicant_process_1_of_2(sm, src_addr, key,
3621                                                       extra_len, ver);
3622                 } else {
3623                         wpa_printf(MSG_WARNING, "WPA: EAPOL-Key (Group) "
3624                                    "without Mic bit - dropped");
3625                 }
3626         }
3627
3628         ret = 1;
3629
3630 out:
3631         os_free(tmp);
3632         return ret;
3633 }
3634
3635
3636 #ifdef CONFIG_CTRL_IFACE
3637 static int wpa_cipher_bits(int cipher)
3638 {
3639         switch (cipher) {
3640         case WPA_CIPHER_CCMP:
3641                 return 128;
3642         case WPA_CIPHER_TKIP:
3643                 return 256;
3644         case WPA_CIPHER_WEP104:
3645                 return 104;
3646         case WPA_CIPHER_WEP40:
3647                 return 40;
3648         default:
3649                 return 0;
3650         }
3651 }
3652
3653
3654 static const u8 * wpa_key_mgmt_suite(struct wpa_sm *sm)
3655 {
3656         static const u8 *dummy = (u8 *) "\x00\x00\x00\x00";
3657         switch (sm->key_mgmt) {
3658         case WPA_KEY_MGMT_IEEE8021X:
3659                 return (sm->proto == WPA_PROTO_RSN ?
3660                         RSN_AUTH_KEY_MGMT_UNSPEC_802_1X :
3661                         WPA_AUTH_KEY_MGMT_UNSPEC_802_1X);
3662         case WPA_KEY_MGMT_PSK:
3663                 return (sm->proto == WPA_PROTO_RSN ?
3664                         RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X :
3665                         WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X);
3666         case WPA_KEY_MGMT_WPA_NONE:
3667                 return WPA_AUTH_KEY_MGMT_NONE;
3668         default:
3669                 return dummy;
3670         }
3671 }
3672
3673
3674 static const u8 * wpa_cipher_suite(struct wpa_sm *sm, int cipher)
3675 {
3676         static const u8 *dummy = (u8 *) "\x00\x00\x00\x00";
3677         switch (cipher) {
3678         case WPA_CIPHER_CCMP:
3679                 return (sm->proto == WPA_PROTO_RSN ?
3680                         RSN_CIPHER_SUITE_CCMP : WPA_CIPHER_SUITE_CCMP);
3681         case WPA_CIPHER_TKIP:
3682                 return (sm->proto == WPA_PROTO_RSN ?
3683                         RSN_CIPHER_SUITE_TKIP : WPA_CIPHER_SUITE_TKIP);
3684         case WPA_CIPHER_WEP104:
3685                 return (sm->proto == WPA_PROTO_RSN ?
3686                         RSN_CIPHER_SUITE_WEP104 : WPA_CIPHER_SUITE_WEP104);
3687         case WPA_CIPHER_WEP40:
3688                 return (sm->proto == WPA_PROTO_RSN ?
3689                         RSN_CIPHER_SUITE_WEP40 : WPA_CIPHER_SUITE_WEP40);
3690         case WPA_CIPHER_NONE:
3691                 return (sm->proto == WPA_PROTO_RSN ?
3692                         RSN_CIPHER_SUITE_NONE : WPA_CIPHER_SUITE_NONE);
3693         default:
3694                 return dummy;
3695         }
3696 }
3697
3698
3699 #define RSN_SUITE "%02x-%02x-%02x-%d"
3700 #define RSN_SUITE_ARG(s) (s)[0], (s)[1], (s)[2], (s)[3]
3701
3702 /**
3703  * wpa_sm_get_mib - Dump text list of MIB entries
3704  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3705  * @buf: Buffer for the list
3706  * @buflen: Length of the buffer
3707  * Returns: Number of bytes written to buffer
3708  *
3709  * This function is used fetch dot11 MIB variables.
3710  */
3711 int wpa_sm_get_mib(struct wpa_sm *sm, char *buf, size_t buflen)
3712 {
3713         char pmkid_txt[PMKID_LEN * 2 + 1];
3714         int rsna, ret;
3715         size_t len;
3716
3717         if (sm->cur_pmksa) {
3718                 wpa_snprintf_hex(pmkid_txt, sizeof(pmkid_txt),
3719                                  sm->cur_pmksa->pmkid, PMKID_LEN);
3720         } else
3721                 pmkid_txt[0] = '\0';
3722
3723         if ((sm->key_mgmt == WPA_KEY_MGMT_PSK ||
3724              sm->key_mgmt == WPA_KEY_MGMT_IEEE8021X) &&
3725             sm->proto == WPA_PROTO_RSN)
3726                 rsna = 1;
3727         else
3728                 rsna = 0;
3729
3730         ret = os_snprintf(buf, buflen,
3731                           "dot11RSNAOptionImplemented=TRUE\n"
3732                           "dot11RSNAPreauthenticationImplemented=TRUE\n"
3733                           "dot11RSNAEnabled=%s\n"
3734                           "dot11RSNAPreauthenticationEnabled=%s\n"
3735                           "dot11RSNAConfigVersion=%d\n"
3736                           "dot11RSNAConfigPairwiseKeysSupported=5\n"
3737                           "dot11RSNAConfigGroupCipherSize=%d\n"
3738                           "dot11RSNAConfigPMKLifetime=%d\n"
3739                           "dot11RSNAConfigPMKReauthThreshold=%d\n"
3740                           "dot11RSNAConfigNumberOfPTKSAReplayCounters=1\n"
3741                           "dot11RSNAConfigSATimeout=%d\n",
3742                           rsna ? "TRUE" : "FALSE",
3743                           rsna ? "TRUE" : "FALSE",
3744                           RSN_VERSION,
3745                           wpa_cipher_bits(sm->group_cipher),
3746                           sm->dot11RSNAConfigPMKLifetime,
3747                           sm->dot11RSNAConfigPMKReauthThreshold,
3748                           sm->dot11RSNAConfigSATimeout);
3749         if (ret < 0 || (size_t) ret >= buflen)
3750                 return 0;
3751         len = ret;
3752
3753         ret = os_snprintf(
3754                 buf + len, buflen - len,
3755                 "dot11RSNAAuthenticationSuiteSelected=" RSN_SUITE "\n"
3756                 "dot11RSNAPairwiseCipherSelected=" RSN_SUITE "\n"
3757                 "dot11RSNAGroupCipherSelected=" RSN_SUITE "\n"
3758                 "dot11RSNAPMKIDUsed=%s\n"
3759                 "dot11RSNAAuthenticationSuiteRequested=" RSN_SUITE "\n"
3760                 "dot11RSNAPairwiseCipherRequested=" RSN_SUITE "\n"
3761                 "dot11RSNAGroupCipherRequested=" RSN_SUITE "\n"
3762                 "dot11RSNAConfigNumberOfGTKSAReplayCounters=0\n"
3763                 "dot11RSNA4WayHandshakeFailures=%u\n",
3764                 RSN_SUITE_ARG(wpa_key_mgmt_suite(sm)),
3765                 RSN_SUITE_ARG(wpa_cipher_suite(sm, sm->pairwise_cipher)),
3766                 RSN_SUITE_ARG(wpa_cipher_suite(sm, sm->group_cipher)),
3767                 pmkid_txt,
3768                 RSN_SUITE_ARG(wpa_key_mgmt_suite(sm)),
3769                 RSN_SUITE_ARG(wpa_cipher_suite(sm, sm->pairwise_cipher)),
3770                 RSN_SUITE_ARG(wpa_cipher_suite(sm, sm->group_cipher)),
3771                 sm->dot11RSNA4WayHandshakeFailures);
3772         if (ret >= 0 && (size_t) ret < buflen)
3773                 len += ret;
3774
3775         return (int) len;
3776 }
3777 #endif /* CONFIG_CTRL_IFACE */
3778
3779
3780 static void wpa_sm_pmksa_free_cb(struct rsn_pmksa_cache_entry *entry,
3781                                  void *ctx, int replace)
3782 {
3783         struct wpa_sm *sm = ctx;
3784
3785         if (sm->cur_pmksa == entry ||
3786             (sm->pmk_len == entry->pmk_len &&
3787              os_memcmp(sm->pmk, entry->pmk, sm->pmk_len) == 0)) {
3788                 wpa_printf(MSG_DEBUG, "RSN: removed current PMKSA entry");
3789                 sm->cur_pmksa = NULL;
3790
3791                 if (replace) {
3792                         /* A new entry is being added, so no need to
3793                          * deauthenticate in this case. This happens when EAP
3794                          * authentication is completed again (reauth or failed
3795                          * PMKSA caching attempt). */
3796                         return;
3797                 }
3798
3799                 os_memset(sm->pmk, 0, sizeof(sm->pmk));
3800                 wpa_sm_deauthenticate(sm, REASON_UNSPECIFIED);
3801                 wpa_sm_req_scan(sm, 0, 0);
3802         }
3803 }
3804
3805
3806 /**
3807  * wpa_sm_init - Initialize WPA state machine
3808  * @ctx: Context pointer for callbacks; this needs to be an allocated buffer
3809  * Returns: Pointer to the allocated WPA state machine data
3810  *
3811  * This function is used to allocate a new WPA state machine and the returned
3812  * value is passed to all WPA state machine calls.
3813  */
3814 struct wpa_sm * wpa_sm_init(struct wpa_sm_ctx *ctx)
3815 {
3816         struct wpa_sm *sm;
3817
3818         sm = os_zalloc(sizeof(*sm));
3819         if (sm == NULL)
3820                 return NULL;
3821         sm->renew_snonce = 1;
3822         sm->ctx = ctx;
3823
3824         sm->dot11RSNAConfigPMKLifetime = 43200;
3825         sm->dot11RSNAConfigPMKReauthThreshold = 70;
3826         sm->dot11RSNAConfigSATimeout = 60;
3827
3828         sm->pmksa = pmksa_cache_init(wpa_sm_pmksa_free_cb, sm, sm);
3829         if (sm->pmksa == NULL) {
3830                 wpa_printf(MSG_ERROR, "RSN: PMKSA cache initialization "
3831                            "failed");
3832                 os_free(sm);
3833                 return NULL;
3834         }
3835
3836         return sm;
3837 }
3838
3839
3840 /**
3841  * wpa_sm_deinit - Deinitialize WPA state machine
3842  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3843  */
3844 void wpa_sm_deinit(struct wpa_sm *sm)
3845 {
3846         if (sm == NULL)
3847                 return;
3848         pmksa_cache_deinit(sm->pmksa);
3849         eloop_cancel_timeout(wpa_sm_start_preauth, sm, NULL);
3850         os_free(sm->assoc_wpa_ie);
3851         os_free(sm->ap_wpa_ie);
3852         os_free(sm->ap_rsn_ie);
3853         os_free(sm->ctx);
3854 #ifdef CONFIG_PEERKEY
3855         {
3856                 struct wpa_peerkey *prev, *peerkey = sm->peerkey;
3857                 while (peerkey) {
3858                         prev = peerkey;
3859                         peerkey = peerkey->next;
3860                         os_free(prev);
3861                 }
3862         }
3863 #endif /* CONFIG_PEERKEY */
3864         os_free(sm);
3865 }
3866
3867
3868 /**
3869  * wpa_sm_notify_assoc - Notify WPA state machine about association
3870  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3871  * @bssid: The BSSID of the new association
3872  *
3873  * This function is called to let WPA state machine know that the connection
3874  * was established.
3875  */
3876 void wpa_sm_notify_assoc(struct wpa_sm *sm, const u8 *bssid)
3877 {
3878         if (sm == NULL)
3879                 return;
3880
3881         wpa_printf(MSG_DEBUG, "WPA: Association event - clear replay counter");
3882         os_memcpy(sm->bssid, bssid, ETH_ALEN);
3883         os_memset(sm->rx_replay_counter, 0, WPA_REPLAY_COUNTER_LEN);
3884         sm->rx_replay_counter_set = 0;
3885         sm->renew_snonce = 1;
3886         if (os_memcmp(sm->preauth_bssid, bssid, ETH_ALEN) == 0)
3887                 rsn_preauth_deinit(sm);
3888 }
3889
3890
3891 /**
3892  * wpa_sm_notify_disassoc - Notify WPA state machine about disassociation
3893  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3894  *
3895  * This function is called to let WPA state machine know that the connection
3896  * was lost. This will abort any existing pre-authentication session.
3897  */
3898 void wpa_sm_notify_disassoc(struct wpa_sm *sm)
3899 {
3900         rsn_preauth_deinit(sm);
3901         if (wpa_sm_get_state(sm) == WPA_4WAY_HANDSHAKE)
3902                 sm->dot11RSNA4WayHandshakeFailures++;
3903 }
3904
3905
3906 /**
3907  * wpa_sm_set_pmk - Set PMK
3908  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3909  * @pmk: The new PMK
3910  * @pmk_len: The length of the new PMK in bytes
3911  *
3912  * Configure the PMK for WPA state machine.
3913  */
3914 void wpa_sm_set_pmk(struct wpa_sm *sm, const u8 *pmk, size_t pmk_len)
3915 {
3916         if (sm == NULL)
3917                 return;
3918
3919         sm->pmk_len = pmk_len;
3920         os_memcpy(sm->pmk, pmk, pmk_len);
3921 }
3922
3923
3924 /**
3925  * wpa_sm_set_pmk_from_pmksa - Set PMK based on the current PMKSA
3926  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3927  *
3928  * Take the PMK from the current PMKSA into use. If no PMKSA is active, the PMK
3929  * will be cleared.
3930  */
3931 void wpa_sm_set_pmk_from_pmksa(struct wpa_sm *sm)
3932 {
3933         if (sm == NULL)
3934                 return;
3935
3936         if (sm->cur_pmksa) {
3937                 sm->pmk_len = sm->cur_pmksa->pmk_len;
3938                 os_memcpy(sm->pmk, sm->cur_pmksa->pmk, sm->pmk_len);
3939         } else {
3940                 sm->pmk_len = PMK_LEN;
3941                 os_memset(sm->pmk, 0, PMK_LEN);
3942         }
3943 }
3944
3945
3946 /**
3947  * wpa_sm_set_fast_reauth - Set fast reauthentication (EAP) enabled/disabled
3948  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3949  * @fast_reauth: Whether fast reauthentication (EAP) is allowed
3950  */
3951 void wpa_sm_set_fast_reauth(struct wpa_sm *sm, int fast_reauth)
3952 {
3953         if (sm)
3954                 sm->fast_reauth = fast_reauth;
3955 }
3956
3957
3958 /**
3959  * wpa_sm_set_scard_ctx - Set context pointer for smartcard callbacks
3960  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3961  * @scard_ctx: Context pointer for smartcard related callback functions
3962  */
3963 void wpa_sm_set_scard_ctx(struct wpa_sm *sm, void *scard_ctx)
3964 {
3965         if (sm == NULL)
3966                 return;
3967         sm->scard_ctx = scard_ctx;
3968         if (sm->preauth_eapol)
3969                 eapol_sm_register_scard_ctx(sm->preauth_eapol, scard_ctx);
3970 }
3971
3972
3973 /**
3974  * wpa_sm_set_config - Notification of current configration change
3975  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3976  * @config: Pointer to current network configuration
3977  *
3978  * Notify WPA state machine that configuration has changed. config will be
3979  * stored as a backpointer to network configuration. This can be %NULL to clear
3980  * the stored pointed.
3981  */
3982 void wpa_sm_set_config(struct wpa_sm *sm, struct wpa_ssid *config)
3983 {
3984         if (sm) {
3985                 sm->cur_ssid = config;
3986                 pmksa_cache_notify_reconfig(sm->pmksa);
3987         }
3988 }
3989
3990
3991 /**
3992  * wpa_sm_set_own_addr - Set own MAC address
3993  * @sm: Pointer to WPA state machine data from wpa_sm_init()
3994  * @addr: Own MAC address
3995  */
3996 void wpa_sm_set_own_addr(struct wpa_sm *sm, const u8 *addr)
3997 {
3998         if (sm)
3999                 os_memcpy(sm->own_addr, addr, ETH_ALEN);
4000 }
4001
4002
4003 /**
4004  * wpa_sm_set_ifname - Set network interface name
4005  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4006  * @ifname: Interface name
4007  * @bridge_ifname: Optional bridge interface name (for pre-auth)
4008  */
4009 void wpa_sm_set_ifname(struct wpa_sm *sm, const char *ifname,
4010                        const char *bridge_ifname)
4011 {
4012         if (sm) {
4013                 sm->ifname = ifname;
4014                 sm->bridge_ifname = bridge_ifname;
4015         }
4016 }
4017
4018
4019 /**
4020  * wpa_sm_set_eapol - Set EAPOL state machine pointer
4021  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4022  * @eapol: Pointer to EAPOL state machine allocated with eapol_sm_init()
4023  */
4024 void wpa_sm_set_eapol(struct wpa_sm *sm, struct eapol_sm *eapol)
4025 {
4026         if (sm)
4027                 sm->eapol = eapol;
4028 }
4029
4030
4031 /**
4032  * wpa_sm_set_param - Set WPA state machine parameters
4033  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4034  * @param: Parameter field
4035  * @value: Parameter value
4036  * Returns: 0 on success, -1 on failure
4037  */
4038 int wpa_sm_set_param(struct wpa_sm *sm, enum wpa_sm_conf_params param,
4039                      unsigned int value)
4040 {
4041         int ret = 0;
4042
4043         if (sm == NULL)
4044                 return -1;
4045
4046         switch (param) {
4047         case RSNA_PMK_LIFETIME:
4048                 if (value > 0)
4049                         sm->dot11RSNAConfigPMKLifetime = value;
4050                 else
4051                         ret = -1;
4052                 break;
4053         case RSNA_PMK_REAUTH_THRESHOLD:
4054                 if (value > 0 && value <= 100)
4055                         sm->dot11RSNAConfigPMKReauthThreshold = value;
4056                 else
4057                         ret = -1;
4058                 break;
4059         case RSNA_SA_TIMEOUT:
4060                 if (value > 0)
4061                         sm->dot11RSNAConfigSATimeout = value;
4062                 else
4063                         ret = -1;
4064                 break;
4065         case WPA_PARAM_PROTO:
4066                 sm->proto = value;
4067                 break;
4068         case WPA_PARAM_PAIRWISE:
4069                 sm->pairwise_cipher = value;
4070                 break;
4071         case WPA_PARAM_GROUP:
4072                 sm->group_cipher = value;
4073                 break;
4074         case WPA_PARAM_KEY_MGMT:
4075                 sm->key_mgmt = value;
4076                 break;
4077 #ifdef CONFIG_IEEE80211W
4078         case WPA_PARAM_MGMT_GROUP:
4079                 sm->mgmt_group_cipher = value;
4080                 break;
4081 #endif /* CONFIG_IEEE80211W */
4082         default:
4083                 break;
4084         }
4085
4086         return ret;
4087 }
4088
4089
4090 /**
4091  * wpa_sm_get_param - Get WPA state machine parameters
4092  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4093  * @param: Parameter field
4094  * Returns: Parameter value
4095  */
4096 unsigned int wpa_sm_get_param(struct wpa_sm *sm, enum wpa_sm_conf_params param)
4097 {
4098         if (sm == NULL)
4099                 return 0;
4100
4101         switch (param) {
4102         case RSNA_PMK_LIFETIME:
4103                 return sm->dot11RSNAConfigPMKLifetime;
4104         case RSNA_PMK_REAUTH_THRESHOLD:
4105                 return sm->dot11RSNAConfigPMKReauthThreshold;
4106         case RSNA_SA_TIMEOUT:
4107                 return sm->dot11RSNAConfigSATimeout;
4108         case WPA_PARAM_PROTO:
4109                 return sm->proto;
4110         case WPA_PARAM_PAIRWISE:
4111                 return sm->pairwise_cipher;
4112         case WPA_PARAM_GROUP:
4113                 return sm->group_cipher;
4114         case WPA_PARAM_KEY_MGMT:
4115                 return sm->key_mgmt;
4116 #ifdef CONFIG_IEEE80211W
4117         case WPA_PARAM_MGMT_GROUP:
4118                 return sm->mgmt_group_cipher;
4119 #endif /* CONFIG_IEEE80211W */
4120         default:
4121                 return 0;
4122         }
4123 }
4124
4125
4126 /**
4127  * wpa_sm_get_status - Get WPA state machine
4128  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4129  * @buf: Buffer for status information
4130  * @buflen: Maximum buffer length
4131  * @verbose: Whether to include verbose status information
4132  * Returns: Number of bytes written to buf.
4133  *
4134  * Query WPA state machine for status information. This function fills in
4135  * a text area with current status information. If the buffer (buf) is not
4136  * large enough, status information will be truncated to fit the buffer.
4137  */
4138 int wpa_sm_get_status(struct wpa_sm *sm, char *buf, size_t buflen,
4139                       int verbose)
4140 {
4141         char *pos = buf, *end = buf + buflen;
4142         int ret;
4143
4144         ret = os_snprintf(pos, end - pos,
4145                           "pairwise_cipher=%s\n"
4146                           "group_cipher=%s\n"
4147                           "key_mgmt=%s\n",
4148                           wpa_cipher_txt(sm->pairwise_cipher),
4149                           wpa_cipher_txt(sm->group_cipher),
4150                           wpa_key_mgmt_txt(sm->key_mgmt, sm->proto));
4151         if (ret < 0 || ret >= end - pos)
4152                 return pos - buf;
4153         pos += ret;
4154         return pos - buf;
4155 }
4156
4157
4158 /**
4159  * wpa_sm_set_assoc_wpa_ie_default - Generate own WPA/RSN IE from configuration
4160  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4161  * @wpa_ie: Pointer to buffer for WPA/RSN IE
4162  * @wpa_ie_len: Pointer to the length of the wpa_ie buffer
4163  * Returns: 0 on success, -1 on failure
4164  *
4165  * Inform WPA state machine about the WPA/RSN IE used in (Re)Association
4166  * Request frame. The IE will be used to override the default value generated
4167  * with wpa_sm_set_assoc_wpa_ie_default().
4168  */
4169 int wpa_sm_set_assoc_wpa_ie_default(struct wpa_sm *sm, u8 *wpa_ie,
4170                                     size_t *wpa_ie_len)
4171 {
4172         int res;
4173
4174         if (sm == NULL)
4175                 return -1;
4176
4177         res = wpa_gen_wpa_ie(sm, wpa_ie, *wpa_ie_len);
4178         if (res < 0)
4179                 return -1;
4180         *wpa_ie_len = res;
4181
4182         wpa_hexdump(MSG_DEBUG, "WPA: Set own WPA IE default",
4183                     wpa_ie, *wpa_ie_len);
4184
4185         if (sm->assoc_wpa_ie == NULL) {
4186                 /*
4187                  * Make a copy of the WPA/RSN IE so that 4-Way Handshake gets
4188                  * the correct version of the IE even if PMKSA caching is
4189                  * aborted (which would remove PMKID from IE generation).
4190                  */
4191                 sm->assoc_wpa_ie = os_malloc(*wpa_ie_len);
4192                 if (sm->assoc_wpa_ie == NULL)
4193                         return -1;
4194
4195                 os_memcpy(sm->assoc_wpa_ie, wpa_ie, *wpa_ie_len);
4196                 sm->assoc_wpa_ie_len = *wpa_ie_len;
4197         }
4198
4199         return 0;
4200 }
4201
4202
4203 /**
4204  * wpa_sm_set_assoc_wpa_ie - Set own WPA/RSN IE from (Re)AssocReq
4205  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4206  * @ie: Pointer to IE data (starting from id)
4207  * @len: IE length
4208  * Returns: 0 on success, -1 on failure
4209  *
4210  * Inform WPA state machine about the WPA/RSN IE used in (Re)Association
4211  * Request frame. The IE will be used to override the default value generated
4212  * with wpa_sm_set_assoc_wpa_ie_default().
4213  */
4214 int wpa_sm_set_assoc_wpa_ie(struct wpa_sm *sm, const u8 *ie, size_t len)
4215 {
4216         if (sm == NULL)
4217                 return -1;
4218
4219         os_free(sm->assoc_wpa_ie);
4220         if (ie == NULL || len == 0) {
4221                 wpa_printf(MSG_DEBUG, "WPA: clearing own WPA/RSN IE");
4222                 sm->assoc_wpa_ie = NULL;
4223                 sm->assoc_wpa_ie_len = 0;
4224         } else {
4225                 wpa_hexdump(MSG_DEBUG, "WPA: set own WPA/RSN IE", ie, len);
4226                 sm->assoc_wpa_ie = os_malloc(len);
4227                 if (sm->assoc_wpa_ie == NULL)
4228                         return -1;
4229
4230                 os_memcpy(sm->assoc_wpa_ie, ie, len);
4231                 sm->assoc_wpa_ie_len = len;
4232         }
4233
4234         return 0;
4235 }
4236
4237
4238 /**
4239  * wpa_sm_set_ap_wpa_ie - Set AP WPA IE from Beacon/ProbeResp
4240  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4241  * @ie: Pointer to IE data (starting from id)
4242  * @len: IE length
4243  * Returns: 0 on success, -1 on failure
4244  *
4245  * Inform WPA state machine about the WPA IE used in Beacon / Probe Response
4246  * frame.
4247  */
4248 int wpa_sm_set_ap_wpa_ie(struct wpa_sm *sm, const u8 *ie, size_t len)
4249 {
4250         if (sm == NULL)
4251                 return -1;
4252
4253         os_free(sm->ap_wpa_ie);
4254         if (ie == NULL || len == 0) {
4255                 wpa_printf(MSG_DEBUG, "WPA: clearing AP WPA IE");
4256                 sm->ap_wpa_ie = NULL;
4257                 sm->ap_wpa_ie_len = 0;
4258         } else {
4259                 wpa_hexdump(MSG_DEBUG, "WPA: set AP WPA IE", ie, len);
4260                 sm->ap_wpa_ie = os_malloc(len);
4261                 if (sm->ap_wpa_ie == NULL)
4262                         return -1;
4263
4264                 os_memcpy(sm->ap_wpa_ie, ie, len);
4265                 sm->ap_wpa_ie_len = len;
4266         }
4267
4268         return 0;
4269 }
4270
4271
4272 /**
4273  * wpa_sm_set_ap_rsn_ie - Set AP RSN IE from Beacon/ProbeResp
4274  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4275  * @ie: Pointer to IE data (starting from id)
4276  * @len: IE length
4277  * Returns: 0 on success, -1 on failure
4278  *
4279  * Inform WPA state machine about the RSN IE used in Beacon / Probe Response
4280  * frame.
4281  */
4282 int wpa_sm_set_ap_rsn_ie(struct wpa_sm *sm, const u8 *ie, size_t len)
4283 {
4284         if (sm == NULL)
4285                 return -1;
4286
4287         os_free(sm->ap_rsn_ie);
4288         if (ie == NULL || len == 0) {
4289                 wpa_printf(MSG_DEBUG, "WPA: clearing AP RSN IE");
4290                 sm->ap_rsn_ie = NULL;
4291                 sm->ap_rsn_ie_len = 0;
4292         } else {
4293                 wpa_hexdump(MSG_DEBUG, "WPA: set AP RSN IE", ie, len);
4294                 sm->ap_rsn_ie = os_malloc(len);
4295                 if (sm->ap_rsn_ie == NULL)
4296                         return -1;
4297
4298                 os_memcpy(sm->ap_rsn_ie, ie, len);
4299                 sm->ap_rsn_ie_len = len;
4300         }
4301
4302         return 0;
4303 }
4304
4305
4306 /**
4307  * wpa_sm_parse_own_wpa_ie - Parse own WPA/RSN IE
4308  * @sm: Pointer to WPA state machine data from wpa_sm_init()
4309  * @data: Pointer to data area for parsing results
4310  * Returns: 0 on success, -1 if IE is not known, or -2 on parsing failure
4311  *
4312  * Parse the contents of the own WPA or RSN IE from (Re)AssocReq and write the
4313  * parsed data into data.
4314  */
4315 int wpa_sm_parse_own_wpa_ie(struct wpa_sm *sm, struct wpa_ie_data *data)
4316 {
4317         if (sm == NULL || sm->assoc_wpa_ie == NULL) {
4318                 wpa_printf(MSG_DEBUG, "WPA: No WPA/RSN IE available from "
4319                            "association info");
4320                 return -1;
4321         }
4322         if (wpa_parse_wpa_ie(sm->assoc_wpa_ie, sm->assoc_wpa_ie_len, data))
4323                 return -2;
4324         return 0;
4325 }