contrib/hostapd-0.4.9/wpa.c

   1 /*
   2  * Host AP (software wireless LAN access point) user space daemon for
   3  * Host AP kernel driver / WPA Authenticator
   4  * Copyright (c) 2004-2005, Jouni Malinen <jkmaline@cc.hut.fi>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * Alternatively, this software may be distributed under the terms of BSD
  11  * license.
  12  *
  13  * See README and COPYING for more details.
  14  */
  15
  16 #include <stdlib.h>
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <netinet/in.h>
  20 #include <sys/time.h>
  21 #include <time.h>
  22 #include <unistd.h>
  23
  24 #include "hostapd.h"
  25 #include "eapol_sm.h"
  26 #include "wpa.h"
  27 #include "driver.h"
  28 #include "sha1.h"
  29 #include "md5.h"
  30 #include "rc4.h"
  31 #include "aes_wrap.h"
  32 #include "ieee802_1x.h"
  33 #include "ieee802_11.h"
  34 #include "eloop.h"
  35 #include "sta_info.h"
  36 #include "l2_packet.h"
  37 #include "accounting.h"
  38 #include "hostap_common.h"
  39
  40
  41 static void wpa_send_eapol_timeout(void *eloop_ctx, void *timeout_ctx);
  42 static void wpa_sm_step(struct wpa_state_machine *sm);
  43 static int wpa_verify_key_mic(struct wpa_ptk *PTK, u8 *data, size_t data_len);
  44 static void wpa_sm_call_step(void *eloop_ctx, void *timeout_ctx);
  45 static void wpa_group_sm_step(struct hostapd_data *hapd);
  46 static void pmksa_cache_free(struct hostapd_data *hapd);
  47 static struct rsn_pmksa_cache * pmksa_cache_get(struct hostapd_data *hapd,
  48                                                 u8 *spa, u8 *pmkid);
  49
  50
  51 /* Default timeouts are 100 ms, but this seems to be a bit too fast for most
  52  * WPA Supplicants, so use a bit longer timeout. */
  53 static const u32 dot11RSNAConfigGroupUpdateTimeOut = 1000; /* ms */
  54 static const u32 dot11RSNAConfigGroupUpdateCount = 3;
  55 static const u32 dot11RSNAConfigPairwiseUpdateTimeOut = 1000; /* ms */
  56 static const u32 dot11RSNAConfigPairwiseUpdateCount = 3;
  57
  58 /* TODO: make these configurable */
  59 static const int dot11RSNAConfigPMKLifetime = 43200;
  60 static const int dot11RSNAConfigPMKReauthThreshold = 70;
  61 static const int dot11RSNAConfigSATimeout = 60;
  62 static const int pmksa_cache_max_entries = 1024;
  63
  64
  65 static const int WPA_SELECTOR_LEN = 4;
  66 static const u8 WPA_OUI_TYPE[] = { 0x00, 0x50, 0xf2, 1 };
  67 static const u16 WPA_VERSION = 1;
  68 static const u8 WPA_AUTH_KEY_MGMT_UNSPEC_802_1X[] = { 0x00, 0x50, 0xf2, 1 };
  69 static const u8 WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X[] = { 0x00, 0x50, 0xf2, 2 };
  70 static const u8 WPA_CIPHER_SUITE_NONE[] = { 0x00, 0x50, 0xf2, 0 };
  71 static const u8 WPA_CIPHER_SUITE_WEP40[] = { 0x00, 0x50, 0xf2, 1 };
  72 static const u8 WPA_CIPHER_SUITE_TKIP[] = { 0x00, 0x50, 0xf2, 2 };
  73 static const u8 WPA_CIPHER_SUITE_WRAP[] = { 0x00, 0x50, 0xf2, 3 };
  74 static const u8 WPA_CIPHER_SUITE_CCMP[] = { 0x00, 0x50, 0xf2, 4 };
  75 static const u8 WPA_CIPHER_SUITE_WEP104[] = { 0x00, 0x50, 0xf2, 5 };
  76
  77 static const int RSN_SELECTOR_LEN = 4;
  78 static const u16 RSN_VERSION = 1;
  79 static const u8 RSN_AUTH_KEY_MGMT_UNSPEC_802_1X[] = { 0x00, 0x0f, 0xac, 1 };
  80 static const u8 RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X[] = { 0x00, 0x0f, 0xac, 2 };
  81 static const u8 RSN_CIPHER_SUITE_NONE[] = { 0x00, 0x0f, 0xac, 0 };
  82 static const u8 RSN_CIPHER_SUITE_WEP40[] = { 0x00, 0x0f, 0xac, 1 };
  83 static const u8 RSN_CIPHER_SUITE_TKIP[] = { 0x00, 0x0f, 0xac, 2 };
  84 static const u8 RSN_CIPHER_SUITE_WRAP[] = { 0x00, 0x0f, 0xac, 3 };
  85 static const u8 RSN_CIPHER_SUITE_CCMP[] = { 0x00, 0x0f, 0xac, 4 };
  86 static const u8 RSN_CIPHER_SUITE_WEP104[] = { 0x00, 0x0f, 0xac, 5 };
  87
  88 /* EAPOL-Key Key Data Encapsulation
  89  * GroupKey and STAKey require encryption, otherwise, encryption is optional.
  90  */
  91 static const u8 RSN_KEY_DATA_GROUPKEY[] = { 0x00, 0x0f, 0xac, 1 };
  92 static const u8 RSN_KEY_DATA_STAKEY[] = { 0x00, 0x0f, 0xac, 2 };
  93 static const u8 RSN_KEY_DATA_MAC_ADDR[] = { 0x00, 0x0f, 0xac, 3 };
  94 static const u8 RSN_KEY_DATA_PMKID[] = { 0x00, 0x0f, 0xac, 4 };
  95
  96 /* WPA IE version 1
  97  * 00-50-f2:1 (OUI:OUI type)
  98  * 0x01 0x00 (version; little endian)
  99  * (all following fields are optional:)
 100  * Group Suite Selector (4 octets) (default: TKIP)
 101  * Pairwise Suite Count (2 octets, little endian) (default: 1)
 102  * Pairwise Suite List (4 * n octets) (default: TKIP)
 103  * Authenticated Key Management Suite Count (2 octets, little endian)
 104  *    (default: 1)
 105  * Authenticated Key Management Suite List (4 * n octets)
 106  *    (default: unspec 802.1X)
 107  * WPA Capabilities (2 octets, little endian) (default: 0)
 108  */
 109
 110 struct wpa_ie_hdr {
 111         u8 elem_id;
 112         u8 len;
 113         u8 oui[3];
 114         u8 oui_type;
 115         u16 version;
 116 } __attribute__ ((packed));
 117
 118
 119 /* RSN IE version 1
 120  * 0x01 0x00 (version; little endian)
 121  * (all following fields are optional:)
 122  * Group Suite Selector (4 octets) (default: CCMP)
 123  * Pairwise Suite Count (2 octets, little endian) (default: 1)
 124  * Pairwise Suite List (4 * n octets) (default: CCMP)
 125  * Authenticated Key Management Suite Count (2 octets, little endian)
 126  *    (default: 1)
 127  * Authenticated Key Management Suite List (4 * n octets)
 128  *    (default: unspec 802.1X)
 129  * RSN Capabilities (2 octets, little endian) (default: 0)
 130  * PMKID Count (2 octets) (default: 0)
 131  * PMKID List (16 * n octets)
 132  */
 133
 134 struct rsn_ie_hdr {
 135         u8 elem_id; /* WLAN_EID_RSN */
 136         u8 len;
 137         u16 version;
 138 } __attribute__ ((packed));
 139
 140
 141 static int wpa_write_wpa_ie(struct hostapd_data *hapd, u8 *buf, size_t len)
 142 {
 143         struct wpa_ie_hdr *hdr;
 144         int num_suites;
 145         u8 *pos, *count;
 146
 147         hdr = (struct wpa_ie_hdr *) buf;
 148         hdr->elem_id = WLAN_EID_GENERIC;
 149         memcpy(&hdr->oui, WPA_OUI_TYPE, WPA_SELECTOR_LEN);
 150         hdr->version = host_to_le16(WPA_VERSION);
 151         pos = (u8 *) (hdr + 1);
 152
 153         if (hapd->conf->wpa_group == WPA_CIPHER_CCMP) {
 154                 memcpy(pos, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN);
 155         } else if (hapd->conf->wpa_group == WPA_CIPHER_TKIP) {
 156                 memcpy(pos, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN);
 157         } else if (hapd->conf->wpa_group == WPA_CIPHER_WEP104) {
 158                 memcpy(pos, WPA_CIPHER_SUITE_WEP104, WPA_SELECTOR_LEN);
 159         } else if (hapd->conf->wpa_group == WPA_CIPHER_WEP40) {
 160                 memcpy(pos, WPA_CIPHER_SUITE_WEP40, WPA_SELECTOR_LEN);
 161         } else {
 162                 printf("Invalid group cipher (%d).\n", hapd->conf->wpa_group);
 163                 return -1;
 164         }
 165         pos += WPA_SELECTOR_LEN;
 166
 167         num_suites = 0;
 168         count = pos;
 169         pos += 2;
 170
 171         if (hapd->conf->wpa_pairwise & WPA_CIPHER_CCMP) {
 172                 memcpy(pos, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN);
 173                 pos += WPA_SELECTOR_LEN;
 174                 num_suites++;
 175         }
 176         if (hapd->conf->wpa_pairwise & WPA_CIPHER_TKIP) {
 177                 memcpy(pos, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN);
 178                 pos += WPA_SELECTOR_LEN;
 179                 num_suites++;
 180         }
 181         if (hapd->conf->wpa_pairwise & WPA_CIPHER_NONE) {
 182                 memcpy(pos, WPA_CIPHER_SUITE_NONE, WPA_SELECTOR_LEN);
 183                 pos += WPA_SELECTOR_LEN;
 184                 num_suites++;
 185         }
 186
 187         if (num_suites == 0) {
 188                 printf("Invalid pairwise cipher (%d).\n",
 189                        hapd->conf->wpa_pairwise);
 190                 return -1;
 191         }
 192         *count++ = num_suites & 0xff;
 193         *count = (num_suites >> 8) & 0xff;
 194
 195         num_suites = 0;
 196         count = pos;
 197         pos += 2;
 198
 199         if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
 200                 memcpy(pos, WPA_AUTH_KEY_MGMT_UNSPEC_802_1X, WPA_SELECTOR_LEN);
 201                 pos += WPA_SELECTOR_LEN;
 202                 num_suites++;
 203         }
 204         if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
 205                 memcpy(pos, WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X,
 206                        WPA_SELECTOR_LEN);
 207                 pos += WPA_SELECTOR_LEN;
 208                 num_suites++;
 209         }
 210
 211         if (num_suites == 0) {
 212                 printf("Invalid key management type (%d).\n",
 213                        hapd->conf->wpa_key_mgmt);
 214                 return -1;
 215         }
 216         *count++ = num_suites & 0xff;
 217         *count = (num_suites >> 8) & 0xff;
 218
 219         /* WPA Capabilities; use defaults, so no need to include it */
 220
 221         hdr->len = (pos - buf) - 2;
 222
 223         return pos - buf;
 224 }
 225
 226
 227 static int wpa_write_rsn_ie(struct hostapd_data *hapd, u8 *buf, size_t len)
 228 {
 229         struct rsn_ie_hdr *hdr;
 230         int num_suites;
 231         u8 *pos, *count;
 232
 233         hdr = (struct rsn_ie_hdr *) buf;
 234         hdr->elem_id = WLAN_EID_RSN;
 235         pos = (u8 *) &hdr->version;
 236         *pos++ = RSN_VERSION & 0xff;
 237         *pos++ = RSN_VERSION >> 8;
 238         pos = (u8 *) (hdr + 1);
 239
 240         if (hapd->conf->wpa_group == WPA_CIPHER_CCMP) {
 241                 memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
 242         } else if (hapd->conf->wpa_group == WPA_CIPHER_TKIP) {
 243                 memcpy(pos, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN);
 244         } else if (hapd->conf->wpa_group == WPA_CIPHER_WEP104) {
 245                 memcpy(pos, RSN_CIPHER_SUITE_WEP104, RSN_SELECTOR_LEN);
 246         } else if (hapd->conf->wpa_group == WPA_CIPHER_WEP40) {
 247                 memcpy(pos, RSN_CIPHER_SUITE_WEP40, RSN_SELECTOR_LEN);
 248         } else {
 249                 printf("Invalid group cipher (%d).\n", hapd->conf->wpa_group);
 250                 return -1;
 251         }
 252         pos += RSN_SELECTOR_LEN;
 253
 254         num_suites = 0;
 255         count = pos;
 256         pos += 2;
 257
 258         if (hapd->conf->wpa_pairwise & WPA_CIPHER_CCMP) {
 259                 memcpy(pos, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN);
 260                 pos += RSN_SELECTOR_LEN;
 261                 num_suites++;
 262         }
 263         if (hapd->conf->wpa_pairwise & WPA_CIPHER_TKIP) {
 264                 memcpy(pos, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN);
 265                 pos += RSN_SELECTOR_LEN;
 266                 num_suites++;
 267         }
 268         if (hapd->conf->wpa_pairwise & WPA_CIPHER_NONE) {
 269                 memcpy(pos, RSN_CIPHER_SUITE_NONE, RSN_SELECTOR_LEN);
 270                 pos += RSN_SELECTOR_LEN;
 271                 num_suites++;
 272         }
 273
 274         if (num_suites == 0) {
 275                 printf("Invalid pairwise cipher (%d).\n",
 276                        hapd->conf->wpa_pairwise);
 277                 return -1;
 278         }
 279         *count++ = num_suites & 0xff;
 280         *count = (num_suites >> 8) & 0xff;
 281
 282         num_suites = 0;
 283         count = pos;
 284         pos += 2;
 285
 286         if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
 287                 memcpy(pos, RSN_AUTH_KEY_MGMT_UNSPEC_802_1X, RSN_SELECTOR_LEN);
 288                 pos += RSN_SELECTOR_LEN;
 289                 num_suites++;
 290         }
 291         if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
 292                 memcpy(pos, RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X,
 293                        RSN_SELECTOR_LEN);
 294                 pos += RSN_SELECTOR_LEN;
 295                 num_suites++;
 296         }
 297
 298         if (num_suites == 0) {
 299                 printf("Invalid key management type (%d).\n",
 300                        hapd->conf->wpa_key_mgmt);
 301                 return -1;
 302         }
 303         *count++ = num_suites & 0xff;
 304         *count = (num_suites >> 8) & 0xff;
 305
 306         /* RSN Capabilities */
 307         *pos++ = hapd->conf->rsn_preauth ? BIT(0) : 0;
 308         *pos++ = 0;
 309
 310         hdr->len = (pos - buf) - 2;
 311
 312         return pos - buf;
 313 }
 314
 315
 316 static int wpa_gen_wpa_ie(struct hostapd_data *hapd)
 317 {
 318         u8 *pos, buf[100];
 319         int res;
 320
 321         pos = buf;
 322
 323         if (hapd->conf->wpa & HOSTAPD_WPA_VERSION_WPA2) {
 324                 res = wpa_write_rsn_ie(hapd, pos, buf + sizeof(buf) - pos);
 325                 if (res < 0)
 326                         return res;
 327                 pos += res;
 328         }
 329         if (hapd->conf->wpa & HOSTAPD_WPA_VERSION_WPA) {
 330                 res = wpa_write_wpa_ie(hapd, pos, buf + sizeof(buf) - pos);
 331                 if (res < 0)
 332                         return res;
 333                 pos += res;
 334         }
 335
 336         free(hapd->wpa_ie);
 337         hapd->wpa_ie = malloc(pos - buf);
 338         if (hapd->wpa_ie == NULL)
 339                 return -1;
 340         memcpy(hapd->wpa_ie, buf, pos - buf);
 341         hapd->wpa_ie_len = pos - buf;
 342
 343         return 0;
 344 }
 345
 346
 347 static void wpa_sta_disconnect(struct hostapd_data *hapd, struct sta_info *sta)
 348 {
 349         hostapd_sta_deauth(hapd, sta->addr, WLAN_REASON_PREV_AUTH_NOT_VALID);
 350         sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC | WLAN_STA_AUTHORIZED);
 351         eloop_cancel_timeout(ap_handle_timer, hapd, sta);
 352         eloop_register_timeout(0, 0, ap_handle_timer, hapd, sta);
 353         sta->timeout_next = STA_REMOVE;
 354 }
 355
 356
 357 static void wpa_rekey_gmk(void *eloop_ctx, void *timeout_ctx)
 358 {
 359         struct hostapd_data *hapd = eloop_ctx;
 360
 361         if (hapd->wpa_auth) {
 362                 if (hostapd_get_rand(hapd->wpa_auth->GMK, WPA_GMK_LEN)) {
 363                         printf("Failed to get random data for WPA "
 364                                "initialization.\n");
 365                 } else {
 366                         hostapd_logger(hapd, NULL, HOSTAPD_MODULE_WPA,
 367                                        HOSTAPD_LEVEL_DEBUG,
 368                                        "GMK rekeyd");
 369                 }
 370         }
 371
 372         if (hapd->conf->wpa_gmk_rekey) {
 373                 eloop_register_timeout(hapd->conf->wpa_gmk_rekey, 0,
 374                                        wpa_rekey_gmk, hapd, NULL);
 375         }
 376 }
 377
 378
 379 static void wpa_rekey_gtk(void *eloop_ctx, void *timeout_ctx)
 380 {
 381         struct hostapd_data *hapd = eloop_ctx;
 382
 383         if (hapd->wpa_auth) {
 384                 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_WPA,
 385                                HOSTAPD_LEVEL_DEBUG, "rekeying GTK");
 386                 hapd->wpa_auth->GTKReKey = TRUE;
 387                 do {
 388                         hapd->wpa_auth->changed = FALSE;
 389                         wpa_group_sm_step(hapd);
 390                 } while (hapd->wpa_auth->changed);
 391         }
 392         if (hapd->conf->wpa_group_rekey) {
 393                 eloop_register_timeout(hapd->conf->wpa_group_rekey, 0,
 394                                        wpa_rekey_gtk, hapd, NULL);
 395         }
 396 }
 397
 398
 399 #ifdef CONFIG_RSN_PREAUTH
 400
 401 static void rsn_preauth_receive(void *ctx, const u8 *src_addr,
 402                                 const u8 *buf, size_t len)
 403 {
 404         struct rsn_preauth_interface *piface = ctx;
 405         struct hostapd_data *hapd = piface->hapd;
 406         struct ieee802_1x_hdr *hdr;
 407         struct sta_info *sta;
 408         struct l2_ethhdr *ethhdr;
 409
 410         HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "RSN: receive pre-auth packet "
 411                       "from interface '%s'\n", piface->ifname);
 412         if (len < sizeof(*ethhdr) + sizeof(*hdr)) {
 413                 HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "RSN: too short pre-auth "
 414                               "packet (len=%lu)\n", (unsigned long) len);
 415                 return;
 416         }
 417
 418         ethhdr = (struct l2_ethhdr *) buf;
 419         hdr = (struct ieee802_1x_hdr *) (ethhdr + 1);
 420
 421         if (memcmp(ethhdr->h_dest, hapd->own_addr, ETH_ALEN) != 0) {
 422                 HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "RSN: pre-auth for "
 423                               "foreign address " MACSTR "\n",
 424                               MAC2STR(ethhdr->h_dest));
 425                 return;
 426         }
 427
 428         sta = ap_get_sta(hapd, ethhdr->h_source);
 429         if (sta && (sta->flags & WLAN_STA_ASSOC)) {
 430                 HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "RSN: pre-auth for "
 431                               "already association STA " MACSTR "\n",
 432                               MAC2STR(sta->addr));
 433                 return;
 434         }
 435         if (!sta && hdr->type == IEEE802_1X_TYPE_EAPOL_START) {
 436                 sta = (struct sta_info *) malloc(sizeof(struct sta_info));
 437                 if (sta == NULL)
 438                         return;
 439                 memset(sta, 0, sizeof(*sta));
 440                 memcpy(sta->addr, ethhdr->h_source, ETH_ALEN);
 441                 sta->flags = WLAN_STA_PREAUTH;
 442                 sta->next = hapd->sta_list;
 443                 sta->wpa = WPA_VERSION_WPA2;
 444                 hapd->sta_list = sta;
 445                 hapd->num_sta++;
 446                 ap_sta_hash_add(hapd, sta);
 447
 448                 ieee802_1x_new_station(hapd, sta);
 449                 if (sta->eapol_sm == NULL) {
 450                         ap_free_sta(hapd, sta);
 451                         sta = NULL;
 452                 } else {
 453                         sta->eapol_sm->radius_identifier = -1;
 454                         sta->eapol_sm->portValid = TRUE;
 455                         sta->eapol_sm->flags |= EAPOL_SM_PREAUTH;
 456                 }
 457         }
 458         if (sta == NULL)
 459                 return;
 460         sta->preauth_iface = piface;
 461         ieee802_1x_receive(hapd, ethhdr->h_source, (u8 *) (ethhdr + 1),
 462                            len - sizeof(*ethhdr));
 463 }
 464
 465
 466 static int rsn_preauth_iface_add(struct hostapd_data *hapd, const char *ifname)
 467 {
 468         struct rsn_preauth_interface *piface;
 469
 470         HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "RSN pre-auth interface '%s'\n",
 471                       ifname);
 472
 473         piface = malloc(sizeof(*piface));
 474         if (piface == NULL)
 475                 return -1;
 476         memset(piface, 0, sizeof(*piface));
 477         piface->hapd = hapd;
 478
 479         piface->ifname = strdup(ifname);
 480         if (piface->ifname == NULL) {
 481                 goto fail1;
 482         }
 483
 484         piface->l2 = l2_packet_init(piface->ifname, NULL, ETH_P_PREAUTH,
 485                                     rsn_preauth_receive, piface, 1);
 486         if (piface->l2 == NULL) {
 487                 printf("Failed to open register layer 2 access to "
 488                        "ETH_P_PREAUTH\n");
 489                 goto fail2;
 490         }
 491
 492         piface->next = hapd->preauth_iface;
 493         hapd->preauth_iface = piface;
 494         return 0;
 495
 496 fail2:
 497         free(piface->ifname);
 498 fail1:
 499         free(piface);
 500         return -1;
 501 }
 502
 503
 504 static void rsn_preauth_iface_deinit(struct hostapd_data *hapd)
 505 {
 506         struct rsn_preauth_interface *piface, *prev;
 507
 508         piface = hapd->preauth_iface;
 509         hapd->preauth_iface = NULL;
 510         while (piface) {
 511                 prev = piface;
 512                 piface = piface->next;
 513                 l2_packet_deinit(prev->l2);
 514                 free(prev->ifname);
 515                 free(prev);
 516         }
 517 }
 518
 519
 520 static int rsn_preauth_iface_init(struct hostapd_data *hapd)
 521 {
 522         char *tmp, *start, *end;
 523
 524         if (hapd->conf->rsn_preauth_interfaces == NULL)
 525                 return 0;
 526
 527         tmp = strdup(hapd->conf->rsn_preauth_interfaces);
 528         if (tmp == NULL)
 529                 return -1;
 530         start = tmp;
 531         for (;;) {
 532                 while (*start == ' ')
 533                         start++;
 534                 if (*start == '\0')
 535                         break;
 536                 end = strchr(start, ' ');
 537                 if (end)
 538                         *end = '\0';
 539
 540                 if (rsn_preauth_iface_add(hapd, start)) {
 541                         rsn_preauth_iface_deinit(hapd);
 542                         return -1;
 543                 }
 544
 545                 if (end)
 546                         start = end + 1;
 547                 else
 548                         break;
 549         }
 550         free(tmp);
 551         return 0;
 552 }
 553
 554
 555 static void rsn_preauth_finished_cb(void *eloop_ctx, void *timeout_ctx)
 556 {
 557         struct hostapd_data *hapd = eloop_ctx;
 558         struct sta_info *sta = timeout_ctx;
 559         wpa_printf(MSG_DEBUG, "RSN: Removing pre-authentication STA entry for "
 560                    MACSTR, MAC2STR(sta->addr));
 561         ap_free_sta(hapd, sta);
 562 }
 563
 564
 565 void rsn_preauth_finished(struct hostapd_data *hapd, struct sta_info *sta,
 566                           int success)
 567 {
 568         u8 *key;
 569         size_t len;
 570         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
 571                        HOSTAPD_LEVEL_INFO, "pre-authentication %s",
 572                        success ? "succeeded" : "failed");
 573
 574         key = ieee802_1x_get_key_crypt(sta->eapol_sm, &len);
 575         if (success && key) {
 576                 pmksa_cache_add(hapd, sta, key, dot11RSNAConfigPMKLifetime);
 577         }
 578
 579         /*
 580          * Finish STA entry removal from timeout in order to avoid freeing
 581          * STA data before the caller has finished processing.
 582          */
 583         eloop_register_timeout(0, 0, rsn_preauth_finished_cb, hapd, sta);
 584 }
 585
 586
 587 void rsn_preauth_send(struct hostapd_data *hapd, struct sta_info *sta,
 588                       u8 *buf, size_t len)
 589 {
 590         struct rsn_preauth_interface *piface;
 591         struct l2_ethhdr *ethhdr;
 592
 593         piface = hapd->preauth_iface;
 594         while (piface) {
 595                 if (piface == sta->preauth_iface)
 596                         break;
 597                 piface = piface->next;
 598         }
 599
 600         if (piface == NULL) {
 601                 HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "RSN: Could not find "
 602                               "pre-authentication interface for " MACSTR "\n",
 603                               MAC2STR(sta->addr));
 604                 return;
 605         }
 606
 607         ethhdr = malloc(sizeof(*ethhdr) + len);
 608         if (ethhdr == NULL)
 609                 return;
 610
 611         memcpy(ethhdr->h_dest, sta->addr, ETH_ALEN);
 612         memcpy(ethhdr->h_source, hapd->own_addr, ETH_ALEN);
 613         ethhdr->h_proto = htons(ETH_P_PREAUTH);
 614         memcpy(ethhdr + 1, buf, len);
 615
 616         if (l2_packet_send(piface->l2, sta->addr, ETH_P_PREAUTH, (u8 *) ethhdr,
 617                            sizeof(*ethhdr) + len) < 0) {
 618                 printf("Failed to send preauth packet using l2_packet_send\n");
 619         }
 620         free(ethhdr);
 621 }
 622
 623 #else /* CONFIG_RSN_PREAUTH */
 624
 625 static inline int rsn_preauth_iface_init(struct hostapd_data *hapd)
 626 {
 627         return 0;
 628 }
 629
 630 static inline void rsn_preauth_iface_deinit(struct hostapd_data *hapd)
 631 {
 632 }
 633
 634 static void rsn_preauth_finished_cb(void *eloop_ctx, void *timeout_ctx)
 635 {
 636 }
 637
 638 void rsn_preauth_finished(struct hostapd_data *hapd, struct sta_info *sta,
 639                           int success)
 640 {
 641 }
 642
 643 void rsn_preauth_send(struct hostapd_data *hapd, struct sta_info *sta,
 644                       u8 *buf, size_t len)
 645 {
 646 }
 647
 648 #endif /* CONFIG_RSN_PREAUTH */
 649
 650
 651 int wpa_init(struct hostapd_data *hapd)
 652 {
 653         u8 rkey[32];
 654         u8 buf[ETH_ALEN + 8];
 655
 656         if (rsn_preauth_iface_init(hapd))
 657                 return -1;
 658
 659         if (hostapd_set_privacy(hapd, 1)) {
 660                 printf("Could not set PrivacyInvoked for interface %s\n",
 661                        hapd->conf->iface);
 662                 return -1;
 663         }
 664
 665         if (wpa_gen_wpa_ie(hapd)) {
 666                 printf("Could not generate WPA IE.\n");
 667                 return -1;
 668         }
 669
 670         if (hostapd_set_generic_elem(hapd, hapd->wpa_ie, hapd->wpa_ie_len)) {
 671                 printf("Failed to configure WPA IE for the kernel driver.\n");
 672                 return -1;
 673         }
 674
 675         hapd->wpa_auth = malloc(sizeof(struct wpa_authenticator));
 676         if (hapd->wpa_auth == NULL)
 677                 return -1;
 678         memset(hapd->wpa_auth, 0, sizeof(struct wpa_authenticator));
 679         hapd->wpa_auth->GTKAuthenticator = TRUE;
 680         switch (hapd->conf->wpa_group) {
 681         case WPA_CIPHER_CCMP:
 682                 hapd->wpa_auth->GTK_len = 16;
 683                 break;
 684         case WPA_CIPHER_TKIP:
 685                 hapd->wpa_auth->GTK_len = 32;
 686                 break;
 687         case WPA_CIPHER_WEP104:
 688                 hapd->wpa_auth->GTK_len = 13;
 689                 break;
 690         case WPA_CIPHER_WEP40:
 691                 hapd->wpa_auth->GTK_len = 5;
 692                 break;
 693         }
 694
 695         /* Counter = PRF-256(Random number, "Init Counter",
 696          *                   Local MAC Address || Time)
 697          */
 698         memcpy(buf, hapd->own_addr, ETH_ALEN);
 699         hostapd_get_ntp_timestamp(buf + ETH_ALEN);
 700         if (hostapd_get_rand(rkey, sizeof(rkey)) ||
 701             hostapd_get_rand(hapd->wpa_auth->GMK, WPA_GMK_LEN)) {
 702                 printf("Failed to get random data for WPA initialization.\n");
 703                 free(hapd->wpa_auth);
 704                 hapd->wpa_auth = NULL;
 705                 return -1;
 706         }
 707
 708         sha1_prf(rkey, sizeof(rkey), "Init Counter", buf, sizeof(buf),
 709                  hapd->wpa_auth->Counter, WPA_NONCE_LEN);
 710
 711         if (hapd->conf->wpa_gmk_rekey) {
 712                 eloop_register_timeout(hapd->conf->wpa_gmk_rekey, 0,
 713                                        wpa_rekey_gmk, hapd, NULL);
 714         }
 715
 716         if (hapd->conf->wpa_group_rekey) {
 717                 eloop_register_timeout(hapd->conf->wpa_group_rekey, 0,
 718                                        wpa_rekey_gtk, hapd, NULL);
 719         }
 720
 721         hapd->wpa_auth->GInit = TRUE;
 722         wpa_group_sm_step(hapd);
 723         hapd->wpa_auth->GInit = FALSE;
 724         wpa_group_sm_step(hapd);
 725
 726         return 0;
 727 }
 728
 729
 730 void wpa_deinit(struct hostapd_data *hapd)
 731 {
 732         rsn_preauth_iface_deinit(hapd);
 733
 734         eloop_cancel_timeout(wpa_rekey_gmk, hapd, NULL);
 735         eloop_cancel_timeout(wpa_rekey_gtk, hapd, NULL);
 736
 737         if (hostapd_set_privacy(hapd, 0)) {
 738                 printf("Could not disable PrivacyInvoked for interface %s\n",
 739                        hapd->conf->iface);
 740         }
 741
 742         if (hostapd_set_generic_elem(hapd, (u8 *) "", 0)) {
 743                 printf("Could not remove generic information element from "
 744                        "interface %s\n", hapd->conf->iface);
 745         }
 746
 747         free(hapd->wpa_ie);
 748         hapd->wpa_ie = NULL;
 749         free(hapd->wpa_auth);
 750         hapd->wpa_auth = NULL;
 751
 752         pmksa_cache_free(hapd);
 753 }
 754
 755
 756 static int wpa_selector_to_bitfield(u8 *s)
 757 {
 758         if (memcmp(s, WPA_CIPHER_SUITE_NONE, WPA_SELECTOR_LEN) == 0)
 759                 return WPA_CIPHER_NONE;
 760         if (memcmp(s, WPA_CIPHER_SUITE_WEP40, WPA_SELECTOR_LEN) == 0)
 761                 return WPA_CIPHER_WEP40;
 762         if (memcmp(s, WPA_CIPHER_SUITE_TKIP, WPA_SELECTOR_LEN) == 0)
 763                 return WPA_CIPHER_TKIP;
 764         if (memcmp(s, WPA_CIPHER_SUITE_CCMP, WPA_SELECTOR_LEN) == 0)
 765                 return WPA_CIPHER_CCMP;
 766         if (memcmp(s, WPA_CIPHER_SUITE_WEP104, WPA_SELECTOR_LEN) == 0)
 767                 return WPA_CIPHER_WEP104;
 768         return 0;
 769 }
 770
 771
 772 static int wpa_key_mgmt_to_bitfield(u8 *s)
 773 {
 774         if (memcmp(s, WPA_AUTH_KEY_MGMT_UNSPEC_802_1X, WPA_SELECTOR_LEN) == 0)
 775                 return WPA_KEY_MGMT_IEEE8021X;
 776         if (memcmp(s, WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X, WPA_SELECTOR_LEN) ==
 777             0)
 778                 return WPA_KEY_MGMT_PSK;
 779         return 0;
 780 }
 781
 782
 783 static int rsn_selector_to_bitfield(u8 *s)
 784 {
 785         if (memcmp(s, RSN_CIPHER_SUITE_NONE, RSN_SELECTOR_LEN) == 0)
 786                 return WPA_CIPHER_NONE;
 787         if (memcmp(s, RSN_CIPHER_SUITE_WEP40, RSN_SELECTOR_LEN) == 0)
 788                 return WPA_CIPHER_WEP40;
 789         if (memcmp(s, RSN_CIPHER_SUITE_TKIP, RSN_SELECTOR_LEN) == 0)
 790                 return WPA_CIPHER_TKIP;
 791         if (memcmp(s, RSN_CIPHER_SUITE_CCMP, RSN_SELECTOR_LEN) == 0)
 792                 return WPA_CIPHER_CCMP;
 793         if (memcmp(s, RSN_CIPHER_SUITE_WEP104, RSN_SELECTOR_LEN) == 0)
 794                 return WPA_CIPHER_WEP104;
 795         return 0;
 796 }
 797
 798
 799 static int rsn_key_mgmt_to_bitfield(u8 *s)
 800 {
 801         if (memcmp(s, RSN_AUTH_KEY_MGMT_UNSPEC_802_1X, RSN_SELECTOR_LEN) == 0)
 802                 return WPA_KEY_MGMT_IEEE8021X;
 803         if (memcmp(s, RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X, RSN_SELECTOR_LEN) ==
 804             0)
 805                 return WPA_KEY_MGMT_PSK;
 806         return 0;
 807 }
 808
 809
 810 static void rsn_pmkid(const u8 *pmk, const u8 *aa, const u8 *spa, u8 *pmkid)
 811 {
 812         char *title = "PMK Name";
 813         const u8 *addr[3];
 814         const size_t len[3] = { 8, ETH_ALEN, ETH_ALEN };
 815         unsigned char hash[SHA1_MAC_LEN];
 816
 817         addr[0] = (u8 *) title;
 818         addr[1] = aa;
 819         addr[2] = spa;
 820
 821         hmac_sha1_vector(pmk, PMK_LEN, 3, addr, len, hash);
 822         memcpy(pmkid, hash, PMKID_LEN);
 823 }
 824
 825
 826 static void pmksa_cache_set_expiration(struct hostapd_data *hapd);
 827
 828
 829 static void _pmksa_cache_free_entry(struct rsn_pmksa_cache *entry)
 830 {
 831         if (entry == NULL)
 832                 return;
 833         free(entry->identity);
 834         ieee802_1x_free_radius_class(&entry->radius_class);
 835         free(entry);
 836 }
 837
 838
 839 static void pmksa_cache_free_entry(struct hostapd_data *hapd,
 840                                    struct rsn_pmksa_cache *entry)
 841 {
 842         struct sta_info *sta;
 843         struct rsn_pmksa_cache *pos, *prev;
 844         hapd->pmksa_count--;
 845         for (sta = hapd->sta_list; sta != NULL; sta = sta->next) {
 846                 if (sta->pmksa == entry)
 847                         sta->pmksa = NULL;
 848         }
 849         pos = hapd->pmkid[PMKID_HASH(entry->pmkid)];
 850         prev = NULL;
 851         while (pos) {
 852                 if (pos == entry) {
 853                         if (prev != NULL) {
 854                                 prev->hnext = pos->hnext;
 855                         } else {
 856                                 hapd->pmkid[PMKID_HASH(entry->pmkid)] =
 857                                         pos->hnext;
 858                         }
 859                         break;
 860                 }
 861                 prev = pos;
 862                 pos = pos->hnext;
 863         }
 864
 865         pos = hapd->pmksa;
 866         prev = NULL;
 867         while (pos) {
 868                 if (pos == entry) {
 869                         if (prev != NULL)
 870                                 prev->next = pos->next;
 871                         else
 872                                 hapd->pmksa = pos->next;
 873                         break;
 874                 }
 875                 prev = pos;
 876                 pos = pos->next;
 877         }
 878         _pmksa_cache_free_entry(entry);
 879 }
 880
 881
 882 static void pmksa_cache_expire(void *eloop_ctx, void *timeout_ctx)
 883 {
 884         struct hostapd_data *hapd = eloop_ctx;
 885         time_t now;
 886
 887         time(&now);
 888         while (hapd->pmksa && hapd->pmksa->expiration <= now) {
 889                 struct rsn_pmksa_cache *entry = hapd->pmksa;
 890                 hapd->pmksa = entry->next;
 891                 HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL,
 892                               "RSN: expired PMKSA cache entry for "
 893                               MACSTR, MAC2STR(entry->spa));
 894                 pmksa_cache_free_entry(hapd, entry);
 895         }
 896
 897         pmksa_cache_set_expiration(hapd);
 898 }
 899
 900
 901 static void pmksa_cache_set_expiration(struct hostapd_data *hapd)
 902 {
 903         int sec;
 904         eloop_cancel_timeout(pmksa_cache_expire, hapd, NULL);
 905         if (hapd->pmksa == NULL)
 906                 return;
 907         sec = hapd->pmksa->expiration - time(NULL);
 908         if (sec < 0)
 909                 sec = 0;
 910         eloop_register_timeout(sec + 1, 0, pmksa_cache_expire, hapd, NULL);
 911 }
 912
 913
 914 static void pmksa_cache_from_eapol_data(struct rsn_pmksa_cache *entry,
 915                                         struct eapol_state_machine *eapol)
 916 {
 917         if (eapol == NULL)
 918                 return;
 919
 920         if (eapol->identity) {
 921                 entry->identity = malloc(eapol->identity_len);
 922                 if (entry->identity) {
 923                         entry->identity_len = eapol->identity_len;
 924                         memcpy(entry->identity, eapol->identity,
 925                                eapol->identity_len);
 926                 }
 927         }
 928
 929         ieee802_1x_copy_radius_class(&entry->radius_class,
 930                                      &eapol->radius_class);
 931 }
 932
 933
 934 static void pmksa_cache_to_eapol_data(struct rsn_pmksa_cache *entry,
 935                                       struct eapol_state_machine *eapol)
 936 {
 937         if (entry == NULL || eapol == NULL)
 938                 return;
 939
 940         if (entry->identity) {
 941                 free(eapol->identity);
 942                 eapol->identity = malloc(entry->identity_len);
 943                 if (eapol->identity) {
 944                         eapol->identity_len = entry->identity_len;
 945                         memcpy(eapol->identity, entry->identity,
 946                                entry->identity_len);
 947                 }
 948                 wpa_hexdump_ascii(MSG_DEBUG, "STA identity from PMKSA",
 949                                   eapol->identity, eapol->identity_len);
 950         }
 951
 952         ieee802_1x_free_radius_class(&eapol->radius_class);
 953         ieee802_1x_copy_radius_class(&eapol->radius_class,
 954                                      &entry->radius_class);
 955         if (eapol->radius_class.attr) {
 956                 wpa_printf(MSG_DEBUG, "Copied %lu Class attribute(s) from "
 957                            "PMKSA", (unsigned long) eapol->radius_class.count);
 958         }
 959 }
 960
 961
 962 void pmksa_cache_add(struct hostapd_data *hapd, struct sta_info *sta, u8 *pmk,
 963                      int session_timeout)
 964 {
 965         struct rsn_pmksa_cache *entry, *pos, *prev;
 966
 967         if (sta->wpa != WPA_VERSION_WPA2)
 968                 return;
 969
 970         entry = malloc(sizeof(*entry));
 971         if (entry == NULL)
 972                 return;
 973         memset(entry, 0, sizeof(*entry));
 974         memcpy(entry->pmk, pmk, PMK_LEN);
 975         rsn_pmkid(pmk, hapd->own_addr, sta->addr, entry->pmkid);
 976         time(&entry->expiration);
 977         if (session_timeout > 0)
 978                 entry->expiration += session_timeout;
 979         else
 980                 entry->expiration += dot11RSNAConfigPMKLifetime;
 981         entry->akmp = WPA_KEY_MGMT_IEEE8021X;
 982         memcpy(entry->spa, sta->addr, ETH_ALEN);
 983         pmksa_cache_from_eapol_data(entry, sta->eapol_sm);
 984
 985         /* Replace an old entry for the same STA (if found) with the new entry
 986          */
 987         pos = pmksa_cache_get(hapd, sta->addr, NULL);
 988         if (pos)
 989                 pmksa_cache_free_entry(hapd, pos);
 990
 991         if (hapd->pmksa_count >= pmksa_cache_max_entries && hapd->pmksa) {
 992                 /* Remove the oldest entry to make room for the new entry */
 993                 HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL,
 994                               "RSN: removed the oldest PMKSA cache entry (for "
 995                               MACSTR ") to make room for new one",
 996                               MAC2STR(hapd->pmksa->spa));
 997                 pmksa_cache_free_entry(hapd, hapd->pmksa);
 998         }
 999
1000         /* Add the new entry; order by expiration time */
1001         pos = hapd->pmksa;
1002         prev = NULL;
1003         while (pos) {
1004                 if (pos->expiration > entry->expiration)
1005                         break;
1006                 prev = pos;
1007                 pos = pos->next;
1008         }
1009         if (prev == NULL) {
1010                 entry->next = hapd->pmksa;
1011                 hapd->pmksa = entry;
1012         } else {
1013                 entry->next = prev->next;
1014                 prev->next = entry;
1015         }
1016         entry->hnext = hapd->pmkid[PMKID_HASH(entry->pmkid)];
1017         hapd->pmkid[PMKID_HASH(entry->pmkid)] = entry;
1018
1019         hapd->pmksa_count++;
1020         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1021                        HOSTAPD_LEVEL_DEBUG,
1022                        "added PMKSA cache entry");
1023         if (HOSTAPD_DEBUG_COND(HOSTAPD_DEBUG_MINIMAL)) {
1024                 hostapd_hexdump("RSN: added PMKID", entry->pmkid, PMKID_LEN);
1025         }
1026 }
1027
1028
1029 static void pmksa_cache_free(struct hostapd_data *hapd)
1030 {
1031         struct rsn_pmksa_cache *entry, *prev;
1032         int i;
1033         struct sta_info *sta;
1034
1035         entry = hapd->pmksa;
1036         hapd->pmksa = NULL;
1037         while (entry) {
1038                 prev = entry;
1039                 entry = entry->next;
1040                 _pmksa_cache_free_entry(prev);
1041         }
1042         eloop_cancel_timeout(pmksa_cache_expire, hapd, NULL);
1043         for (i = 0; i < PMKID_HASH_SIZE; i++)
1044                 hapd->pmkid[i] = NULL;
1045         for (sta = hapd->sta_list; sta; sta = sta->next)
1046                 sta->pmksa = NULL;
1047 }
1048
1049
1050 static struct rsn_pmksa_cache * pmksa_cache_get(struct hostapd_data *hapd,
1051                                                 u8 *spa, u8 *pmkid)
1052 {
1053         struct rsn_pmksa_cache *entry;
1054
1055         if (pmkid)
1056                 entry = hapd->pmkid[PMKID_HASH(pmkid)];
1057         else
1058                 entry = hapd->pmksa;
1059         while (entry) {
1060                 if ((spa == NULL || memcmp(entry->spa, spa, ETH_ALEN) == 0) &&
1061                     (pmkid == NULL ||
1062                      memcmp(entry->pmkid, pmkid, PMKID_LEN) == 0))
1063                         return entry;
1064                 entry = pmkid ? entry->hnext : entry->next;
1065         }
1066         return NULL;
1067 }
1068
1069
1070 struct wpa_ie_data {
1071         int pairwise_cipher;
1072         int group_cipher;
1073         int key_mgmt;
1074         int capabilities;
1075         size_t num_pmkid;
1076         u8 *pmkid;
1077 };
1078
1079
1080 static int wpa_parse_wpa_ie_wpa(const u8 *wpa_ie, size_t wpa_ie_len,
1081                                 struct wpa_ie_data *data)
1082 {
1083         struct wpa_ie_hdr *hdr;
1084         u8 *pos;
1085         int left;
1086         int i, count;
1087
1088         memset(data, 0, sizeof(*data));
1089         data->pairwise_cipher = WPA_CIPHER_TKIP;
1090         data->group_cipher = WPA_CIPHER_TKIP;
1091         data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1092
1093         if (wpa_ie_len < sizeof(struct wpa_ie_hdr))
1094                 return -1;
1095
1096         hdr = (struct wpa_ie_hdr *) wpa_ie;
1097
1098         if (hdr->elem_id != WLAN_EID_GENERIC ||
1099             hdr->len != wpa_ie_len - 2 ||
1100             memcmp(&hdr->oui, WPA_OUI_TYPE, WPA_SELECTOR_LEN) != 0 ||
1101             le_to_host16(hdr->version) != WPA_VERSION) {
1102                 return -2;
1103         }
1104
1105         pos = (u8 *) (hdr + 1);
1106         left = wpa_ie_len - sizeof(*hdr);
1107
1108         if (left >= WPA_SELECTOR_LEN) {
1109                 data->group_cipher = wpa_selector_to_bitfield(pos);
1110                 pos += WPA_SELECTOR_LEN;
1111                 left -= WPA_SELECTOR_LEN;
1112         } else if (left > 0)
1113                   return -3;
1114
1115         if (left >= 2) {
1116                 data->pairwise_cipher = 0;
1117                 count = pos[0] | (pos[1] << 8);
1118                 pos += 2;
1119                 left -= 2;
1120                 if (count == 0 || left < count * WPA_SELECTOR_LEN)
1121                         return -4;
1122                 for (i = 0; i < count; i++) {
1123                         data->pairwise_cipher |= wpa_selector_to_bitfield(pos);
1124                         pos += WPA_SELECTOR_LEN;
1125                         left -= WPA_SELECTOR_LEN;
1126                 }
1127         } else if (left == 1)
1128                 return -5;
1129
1130         if (left >= 2) {
1131                 data->key_mgmt = 0;
1132                 count = pos[0] | (pos[1] << 8);
1133                 pos += 2;
1134                 left -= 2;
1135                 if (count == 0 || left < count * WPA_SELECTOR_LEN)
1136                         return -6;
1137                 for (i = 0; i < count; i++) {
1138                         data->key_mgmt |= wpa_key_mgmt_to_bitfield(pos);
1139                         pos += WPA_SELECTOR_LEN;
1140                         left -= WPA_SELECTOR_LEN;
1141                 }
1142         } else if (left == 1)
1143                 return -7;
1144
1145         if (left >= 2) {
1146                 data->capabilities = pos[0] | (pos[1] << 8);
1147                 pos += 2;
1148                 left -= 2;
1149         }
1150
1151         if (left > 0) {
1152                 return -8;
1153         }
1154
1155         return 0;
1156 }
1157
1158
1159 static int wpa_parse_wpa_ie_rsn(const u8 *rsn_ie, size_t rsn_ie_len,
1160                                 struct wpa_ie_data *data)
1161 {
1162         struct rsn_ie_hdr *hdr;
1163         u8 *pos;
1164         int left;
1165         int i, count;
1166
1167         memset(data, 0, sizeof(*data));
1168         data->pairwise_cipher = WPA_CIPHER_CCMP;
1169         data->group_cipher = WPA_CIPHER_CCMP;
1170         data->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1171
1172         if (rsn_ie_len < sizeof(struct rsn_ie_hdr))
1173                 return -1;
1174
1175         hdr = (struct rsn_ie_hdr *) rsn_ie;
1176
1177         if (hdr->elem_id != WLAN_EID_RSN ||
1178             hdr->len != rsn_ie_len - 2 ||
1179             le_to_host16(hdr->version) != RSN_VERSION) {
1180                 return -2;
1181         }
1182
1183         pos = (u8 *) (hdr + 1);
1184         left = rsn_ie_len - sizeof(*hdr);
1185
1186         if (left >= RSN_SELECTOR_LEN) {
1187                 data->group_cipher = rsn_selector_to_bitfield(pos);
1188                 pos += RSN_SELECTOR_LEN;
1189                 left -= RSN_SELECTOR_LEN;
1190         } else if (left > 0)
1191                   return -3;
1192
1193         if (left >= 2) {
1194                 data->pairwise_cipher = 0;
1195                 count = pos[0] | (pos[1] << 8);
1196                 pos += 2;
1197                 left -= 2;
1198                 if (count == 0 || left < count * RSN_SELECTOR_LEN)
1199                         return -4;
1200                 for (i = 0; i < count; i++) {
1201                         data->pairwise_cipher |= rsn_selector_to_bitfield(pos);
1202                         pos += RSN_SELECTOR_LEN;
1203                         left -= RSN_SELECTOR_LEN;
1204                 }
1205         } else if (left == 1)
1206                 return -5;
1207
1208         if (left >= 2) {
1209                 data->key_mgmt = 0;
1210                 count = pos[0] | (pos[1] << 8);
1211                 pos += 2;
1212                 left -= 2;
1213                 if (count == 0 || left < count * RSN_SELECTOR_LEN)
1214                         return -6;
1215                 for (i = 0; i < count; i++) {
1216                         data->key_mgmt |= rsn_key_mgmt_to_bitfield(pos);
1217                         pos += RSN_SELECTOR_LEN;
1218                         left -= RSN_SELECTOR_LEN;
1219                 }
1220         } else if (left == 1)
1221                 return -7;
1222
1223         if (left >= 2) {
1224                 data->capabilities = pos[0] | (pos[1] << 8);
1225                 pos += 2;
1226                 left -= 2;
1227         }
1228
1229         if (left >= 2) {
1230                 data->num_pmkid = pos[0] | (pos[1] << 8);
1231                 pos += 2;
1232                 left -= 2;
1233                 if (left < data->num_pmkid * PMKID_LEN) {
1234                         printf("RSN: too short RSN IE for PMKIDs "
1235                                "(num=%lu, left=%d)\n",
1236                                (unsigned long) data->num_pmkid, left);
1237                         return -9;
1238                 }
1239                 data->pmkid = pos;
1240                 pos += data->num_pmkid * PMKID_LEN;
1241                 left -= data->num_pmkid * PMKID_LEN;
1242         }
1243
1244         if (left > 0) {
1245                 return -8;
1246         }
1247
1248         return 0;
1249 }
1250
1251
1252 int wpa_validate_wpa_ie(struct hostapd_data *hapd, struct sta_info *sta,
1253                         const u8 *wpa_ie, size_t wpa_ie_len, int version)
1254 {
1255         struct wpa_ie_data data;
1256         int ciphers, key_mgmt, res, i;
1257         const u8 *selector;
1258
1259         if (version == HOSTAPD_WPA_VERSION_WPA2) {
1260                 res = wpa_parse_wpa_ie_rsn(wpa_ie, wpa_ie_len, &data);
1261
1262                 selector = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
1263                 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X)
1264                         selector = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
1265                 else if (data.key_mgmt & WPA_KEY_MGMT_PSK)
1266                         selector = RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X;
1267                 memcpy(hapd->wpa_auth->dot11RSNAAuthenticationSuiteSelected,
1268                        selector, RSN_SELECTOR_LEN);
1269
1270                 selector = RSN_CIPHER_SUITE_CCMP;
1271                 if (data.pairwise_cipher & WPA_CIPHER_CCMP)
1272                         selector = RSN_CIPHER_SUITE_CCMP;
1273                 else if (data.pairwise_cipher & WPA_CIPHER_TKIP)
1274                         selector = RSN_CIPHER_SUITE_TKIP;
1275                 else if (data.pairwise_cipher & WPA_CIPHER_WEP104)
1276                         selector = RSN_CIPHER_SUITE_WEP104;
1277                 else if (data.pairwise_cipher & WPA_CIPHER_WEP40)
1278                         selector = RSN_CIPHER_SUITE_WEP40;
1279                 else if (data.pairwise_cipher & WPA_CIPHER_NONE)
1280                         selector = RSN_CIPHER_SUITE_NONE;
1281                 memcpy(hapd->wpa_auth->dot11RSNAPairwiseCipherSelected,
1282                        selector, RSN_SELECTOR_LEN);
1283
1284                 selector = RSN_CIPHER_SUITE_CCMP;
1285                 if (data.group_cipher & WPA_CIPHER_CCMP)
1286                         selector = RSN_CIPHER_SUITE_CCMP;
1287                 else if (data.group_cipher & WPA_CIPHER_TKIP)
1288                         selector = RSN_CIPHER_SUITE_TKIP;
1289                 else if (data.group_cipher & WPA_CIPHER_WEP104)
1290                         selector = RSN_CIPHER_SUITE_WEP104;
1291                 else if (data.group_cipher & WPA_CIPHER_WEP40)
1292                         selector = RSN_CIPHER_SUITE_WEP40;
1293                 else if (data.group_cipher & WPA_CIPHER_NONE)
1294                         selector = RSN_CIPHER_SUITE_NONE;
1295                 memcpy(hapd->wpa_auth->dot11RSNAGroupCipherSelected,
1296                        selector, RSN_SELECTOR_LEN);
1297         } else {
1298                 res = wpa_parse_wpa_ie_wpa(wpa_ie, wpa_ie_len, &data);
1299
1300                 selector = WPA_AUTH_KEY_MGMT_UNSPEC_802_1X;
1301                 if (data.key_mgmt & WPA_KEY_MGMT_IEEE8021X)
1302                         selector = WPA_AUTH_KEY_MGMT_UNSPEC_802_1X;
1303                 else if (data.key_mgmt & WPA_KEY_MGMT_PSK)
1304                         selector = WPA_AUTH_KEY_MGMT_PSK_OVER_802_1X;
1305                 memcpy(hapd->wpa_auth->dot11RSNAAuthenticationSuiteSelected,
1306                        selector, WPA_SELECTOR_LEN);
1307
1308                 selector = WPA_CIPHER_SUITE_TKIP;
1309                 if (data.pairwise_cipher & WPA_CIPHER_CCMP)
1310                         selector = WPA_CIPHER_SUITE_CCMP;
1311                 else if (data.pairwise_cipher & WPA_CIPHER_TKIP)
1312                         selector = WPA_CIPHER_SUITE_TKIP;
1313                 else if (data.pairwise_cipher & WPA_CIPHER_WEP104)
1314                         selector = WPA_CIPHER_SUITE_WEP104;
1315                 else if (data.pairwise_cipher & WPA_CIPHER_WEP40)
1316                         selector = WPA_CIPHER_SUITE_WEP40;
1317                 else if (data.pairwise_cipher & WPA_CIPHER_NONE)
1318                         selector = WPA_CIPHER_SUITE_NONE;
1319                 memcpy(hapd->wpa_auth->dot11RSNAPairwiseCipherSelected,
1320                        selector, WPA_SELECTOR_LEN);
1321
1322                 selector = WPA_CIPHER_SUITE_TKIP;
1323                 if (data.group_cipher & WPA_CIPHER_CCMP)
1324                         selector = WPA_CIPHER_SUITE_CCMP;
1325                 else if (data.group_cipher & WPA_CIPHER_TKIP)
1326                         selector = WPA_CIPHER_SUITE_TKIP;
1327                 else if (data.group_cipher & WPA_CIPHER_WEP104)
1328                         selector = WPA_CIPHER_SUITE_WEP104;
1329                 else if (data.group_cipher & WPA_CIPHER_WEP40)
1330                         selector = WPA_CIPHER_SUITE_WEP40;
1331                 else if (data.group_cipher & WPA_CIPHER_NONE)
1332                         selector = WPA_CIPHER_SUITE_NONE;
1333                 memcpy(hapd->wpa_auth->dot11RSNAGroupCipherSelected,
1334                        selector, WPA_SELECTOR_LEN);
1335         }
1336         if (res) {
1337                 printf("Failed to parse WPA/RSN IE from " MACSTR " (res=%d)\n",
1338                        MAC2STR(sta->addr), res);
1339                 hostapd_hexdump("WPA/RSN IE", wpa_ie, wpa_ie_len);
1340                 return WPA_INVALID_IE;
1341         }
1342
1343         if (data.group_cipher != hapd->conf->wpa_group) {
1344                 printf("Invalid WPA group cipher (0x%x) from " MACSTR "\n",
1345                        data.group_cipher, MAC2STR(sta->addr));
1346                 return WPA_INVALID_GROUP;
1347         }
1348
1349         key_mgmt = data.key_mgmt & hapd->conf->wpa_key_mgmt;
1350         if (!key_mgmt) {
1351                 printf("Invalid WPA key mgmt (0x%x) from " MACSTR "\n",
1352                        data.key_mgmt, MAC2STR(sta->addr));
1353                 return WPA_INVALID_AKMP;
1354         }
1355         if (key_mgmt & WPA_KEY_MGMT_IEEE8021X)
1356                 sta->wpa_key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1357         else
1358                 sta->wpa_key_mgmt = WPA_KEY_MGMT_PSK;
1359
1360         ciphers = data.pairwise_cipher & hapd->conf->wpa_pairwise;
1361         if (!ciphers) {
1362                 printf("Invalid WPA pairwise cipher (0x%x) from " MACSTR "\n",
1363                        data.pairwise_cipher, MAC2STR(sta->addr));
1364                 return WPA_INVALID_PAIRWISE;
1365         }
1366
1367         if (ciphers & WPA_CIPHER_CCMP)
1368                 sta->pairwise = WPA_CIPHER_CCMP;
1369         else
1370                 sta->pairwise = WPA_CIPHER_TKIP;
1371
1372         /* TODO: clear WPA/WPA2 state if STA changes from one to another */
1373         if (wpa_ie[0] == WLAN_EID_RSN)
1374                 sta->wpa = WPA_VERSION_WPA2;
1375         else
1376                 sta->wpa = WPA_VERSION_WPA;
1377
1378         for (i = 0; i < data.num_pmkid; i++) {
1379                 if (HOSTAPD_DEBUG_COND(HOSTAPD_DEBUG_MINIMAL)) {
1380                         hostapd_hexdump("RSN IE: STA PMKID",
1381                                         &data.pmkid[i * PMKID_LEN], PMKID_LEN);
1382                 }
1383                 sta->pmksa = pmksa_cache_get(hapd, sta->addr,
1384                                              &data.pmkid[i * PMKID_LEN]);
1385                 if (sta->pmksa) {
1386                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1387                                        HOSTAPD_LEVEL_DEBUG,
1388                                        "PMKID found from PMKSA cache");
1389                         if (hapd->wpa_auth) {
1390                                 memcpy(hapd->wpa_auth->dot11RSNAPMKIDUsed,
1391                                        sta->pmksa->pmkid, PMKID_LEN);
1392                         }
1393                         break;
1394                 }
1395         }
1396
1397         return WPA_IE_OK;
1398 }
1399
1400
1401 void wpa_new_station(struct hostapd_data *hapd, struct sta_info *sta)
1402 {
1403         struct wpa_state_machine *sm;
1404
1405         if (!hapd->conf->wpa)
1406                 return;
1407
1408         if (sta->wpa_sm) {
1409                 sm = sta->wpa_sm;
1410                 memset(sm->key_replay_counter, 0, WPA_REPLAY_COUNTER_LEN);
1411                 sm->ReAuthenticationRequest = TRUE;
1412                 wpa_sm_step(sm);
1413                 return;
1414         }
1415
1416         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1417                        HOSTAPD_LEVEL_DEBUG, "start authentication");
1418         sm = malloc(sizeof(struct wpa_state_machine));
1419         if (sm == NULL)
1420                 return;
1421         memset(sm, 0, sizeof(struct wpa_state_machine));
1422
1423         sm->hapd = hapd;
1424         sm->sta = sta;
1425         sta->wpa_sm = sm;
1426
1427         sm->Init = TRUE;
1428         wpa_sm_step(sm);
1429         sm->Init = FALSE;
1430         sm->AuthenticationRequest = TRUE;
1431         wpa_sm_step(sm);
1432 }
1433
1434
1435 void wpa_free_station(struct sta_info *sta)
1436 {
1437         struct wpa_state_machine *sm = sta->wpa_sm;
1438
1439         if (sm == NULL)
1440                 return;
1441
1442         if (sm->hapd->conf->wpa_strict_rekey && sm->has_GTK) {
1443                 hostapd_logger(sm->hapd, sta->addr, HOSTAPD_MODULE_WPA,
1444                                HOSTAPD_LEVEL_DEBUG, "strict rekeying - force "
1445                                "GTK rekey since STA is leaving");
1446                 eloop_cancel_timeout(wpa_rekey_gtk, sm->hapd, NULL);
1447                 eloop_register_timeout(0, 500000, wpa_rekey_gtk, sm->hapd,
1448                                        NULL);
1449         }
1450
1451         eloop_cancel_timeout(wpa_send_eapol_timeout, sm->hapd, sta);
1452         eloop_cancel_timeout(wpa_sm_call_step, sm->hapd, sta->wpa_sm);
1453         eloop_cancel_timeout(rsn_preauth_finished_cb, sm->hapd, sta);
1454         free(sm->last_rx_eapol_key);
1455         free(sm);
1456         sta->wpa_sm = NULL;
1457 }
1458
1459
1460 static void wpa_request_new_ptk(struct hostapd_data *hapd,
1461                                 struct sta_info *sta)
1462 {
1463         struct wpa_state_machine *sm = sta->wpa_sm;
1464
1465         if (sm == NULL)
1466                 return;
1467
1468         sm->PTKRequest = TRUE;
1469         sm->PTK_valid = 0;
1470 }
1471
1472
1473 void wpa_receive(struct hostapd_data *hapd, struct sta_info *sta,
1474                  u8 *data, size_t data_len)
1475 {
1476         struct wpa_state_machine *sm = sta->wpa_sm;
1477         struct ieee802_1x_hdr *hdr;
1478         struct wpa_eapol_key *key;
1479         u16 key_info, key_data_length;
1480         enum { PAIRWISE_2, PAIRWISE_4, GROUP_2, REQUEST } msg;
1481         char *msgtxt;
1482
1483         if (!hapd->conf->wpa)
1484                 return;
1485
1486         if (sm == NULL)
1487                 return;
1488
1489         if (data_len < sizeof(*hdr) + sizeof(*key))
1490                 return;
1491
1492         hdr = (struct ieee802_1x_hdr *) data;
1493         key = (struct wpa_eapol_key *) (hdr + 1);
1494         key_info = ntohs(key->key_info);
1495         key_data_length = ntohs(key->key_data_length);
1496         if (key_data_length > data_len - sizeof(*hdr) - sizeof(*key)) {
1497                 wpa_printf(MSG_INFO, "WPA: Invalid EAPOL-Key frame - "
1498                            "key_data overflow (%d > %lu)",
1499                            key_data_length,
1500                            (unsigned long) (data_len - sizeof(*hdr) -
1501                                             sizeof(*key)));
1502                 return;
1503         }
1504
1505         /* FIX: verify that the EAPOL-Key frame was encrypted if pairwise keys
1506          * are set */
1507
1508         if (key_info & WPA_KEY_INFO_REQUEST) {
1509                 msg = REQUEST;
1510                 msgtxt = "Request";
1511         } else if (!(key_info & WPA_KEY_INFO_KEY_TYPE)) {
1512                 msg = GROUP_2;
1513                 msgtxt = "2/2 Group";
1514         } else if (key_data_length == 0) {
1515                 msg = PAIRWISE_4;
1516                 msgtxt = "4/4 Pairwise";
1517         } else {
1518                 msg = PAIRWISE_2;
1519                 msgtxt = "2/4 Pairwise";
1520         }
1521
1522         if (key_info & WPA_KEY_INFO_REQUEST) {
1523                 if (sta->req_replay_counter_used &&
1524                     memcmp(key->replay_counter, sta->req_replay_counter,
1525                            WPA_REPLAY_COUNTER_LEN) <= 0) {
1526                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1527                                        HOSTAPD_LEVEL_WARNING,
1528                                        "received EAPOL-Key request with "
1529                                        "replayed counter");
1530                         return;
1531                 }
1532         }
1533
1534         if (!(key_info & WPA_KEY_INFO_REQUEST) &&
1535             (!sm->key_replay_counter_valid ||
1536              memcmp(key->replay_counter, sm->key_replay_counter,
1537                     WPA_REPLAY_COUNTER_LEN) != 0)) {
1538                 hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1539                                HOSTAPD_LEVEL_INFO,
1540                                "received EAPOL-Key %s with unexpected replay "
1541                                "counter", msgtxt);
1542                 if (HOSTAPD_DEBUG_COND(HOSTAPD_DEBUG_MINIMAL)) {
1543                         hostapd_hexdump("expected replay counter",
1544                                         sm->key_replay_counter,
1545                                         WPA_REPLAY_COUNTER_LEN);
1546                         hostapd_hexdump("received replay counter",
1547                                         key->replay_counter,
1548                                         WPA_REPLAY_COUNTER_LEN);
1549                 }
1550                 return;
1551         }
1552
1553         switch (msg) {
1554         case PAIRWISE_2:
1555                 if (sm->wpa_ptk_state != WPA_PTK_PTKSTART &&
1556                     sm->wpa_ptk_state != WPA_PTK_PTKCALCNEGOTIATING) {
1557                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1558                                        HOSTAPD_LEVEL_INFO,
1559                                        "received EAPOL-Key msg 2/4 in invalid"
1560                                        " state (%d) - dropped",
1561                                        sm->wpa_ptk_state);
1562                         return;
1563                 }
1564                 if (sta->wpa_ie == NULL ||
1565                     sta->wpa_ie_len != key_data_length ||
1566                     memcmp(sta->wpa_ie, key + 1, key_data_length) != 0) {
1567                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1568                                        HOSTAPD_LEVEL_INFO,
1569                                        "WPA IE from (Re)AssocReq did not match"
1570                                        " with msg 2/4");
1571                         if (HOSTAPD_DEBUG_COND(HOSTAPD_DEBUG_MINIMAL)) {
1572                                 if (sta->wpa_ie) {
1573                                         hostapd_hexdump("WPA IE in AssocReq",
1574                                                         sta->wpa_ie,
1575                                                         sta->wpa_ie_len);
1576                                 }
1577                                 hostapd_hexdump("WPA IE in msg 2/4",
1578                                                 (u8 *) (key + 1),
1579                                                 key_data_length);
1580                         }
1581                         /* MLME-DEAUTHENTICATE.request */
1582                         wpa_sta_disconnect(hapd, sta);
1583                         return;
1584                 }
1585                 break;
1586         case PAIRWISE_4:
1587                 if (sm->wpa_ptk_state != WPA_PTK_PTKINITNEGOTIATING ||
1588                     !sm->PTK_valid) {
1589                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1590                                        HOSTAPD_LEVEL_INFO,
1591                                        "received EAPOL-Key msg 4/4 in invalid"
1592                                        " state (%d) - dropped",
1593                                        sm->wpa_ptk_state);
1594                         return;
1595                 }
1596                 break;
1597         case GROUP_2:
1598                 if (sm->wpa_ptk_group_state != WPA_PTK_GROUP_REKEYNEGOTIATING
1599                     || !sm->PTK_valid) {
1600                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1601                                        HOSTAPD_LEVEL_INFO,
1602                                        "received EAPOL-Key msg 2/2 in invalid"
1603                                        " state (%d) - dropped",
1604                                        sm->wpa_ptk_group_state);
1605                         return;
1606                 }
1607                 break;
1608         case REQUEST:
1609                 break;
1610         }
1611
1612         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1613                        HOSTAPD_LEVEL_DEBUG, "received EAPOL-Key frame (%s)",
1614                        msgtxt);
1615
1616         if (key_info & WPA_KEY_INFO_ACK) {
1617                 hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1618                                HOSTAPD_LEVEL_INFO,
1619                                "received invalid EAPOL-Key: Key Ack set");
1620                 return;
1621         }
1622
1623         if (!(key_info & WPA_KEY_INFO_MIC)) {
1624                 hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1625                                HOSTAPD_LEVEL_INFO,
1626                                "received invalid EAPOL-Key: Key MIC not set");
1627                 return;
1628         }
1629
1630         sm->MICVerified = FALSE;
1631         if (sm->PTK_valid) {
1632                 if (wpa_verify_key_mic(&sm->PTK, data, data_len)) {
1633                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1634                                        HOSTAPD_LEVEL_INFO,
1635                                        "received EAPOL-Key with invalid MIC");
1636                         return;
1637                 }
1638                 sm->MICVerified = TRUE;
1639                 eloop_cancel_timeout(wpa_send_eapol_timeout, sta->wpa_sm->hapd,
1640                                      sta);
1641         }
1642
1643         if (key_info & WPA_KEY_INFO_REQUEST) {
1644                 if (sm->MICVerified) {
1645                         sta->req_replay_counter_used = 1;
1646                         memcpy(sta->req_replay_counter, key->replay_counter,
1647                                WPA_REPLAY_COUNTER_LEN);
1648                 } else {
1649                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1650                                        HOSTAPD_LEVEL_INFO,
1651                                        "received EAPOL-Key request with "
1652                                        "invalid MIC");
1653                         return;
1654                 }
1655
1656                 if (key_info & WPA_KEY_INFO_ERROR) {
1657                         /* Supplicant reported a Michael MIC error */
1658                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1659                                        HOSTAPD_LEVEL_INFO,
1660                                        "received EAPOL-Key Error Request "
1661                                        "(STA detected Michael MIC failure)");
1662                         ieee80211_michael_mic_failure(hapd, sta->addr, 0);
1663                         sta->dot11RSNAStatsTKIPRemoteMICFailures++;
1664                         hapd->wpa_auth->dot11RSNAStatsTKIPRemoteMICFailures++;
1665                         /* Error report is not a request for a new key
1666                          * handshake, but since Authenticator may do it, let's
1667                          * change the keys now anyway. */
1668                         wpa_request_new_ptk(hapd, sta);
1669                 } else if (key_info & WPA_KEY_INFO_KEY_TYPE) {
1670                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1671                                        HOSTAPD_LEVEL_INFO,
1672                                        "received EAPOL-Key Request for new "
1673                                        "4-Way Handshake");
1674                         wpa_request_new_ptk(hapd, sta);
1675                 } else {
1676                         /* TODO: this could also be a request for STAKey
1677                          * if Key Data fields contains peer MAC address KDE.
1678                          * STAKey request should have 0xdd <len> 00-0F-AC:2 in
1679                          * the beginning of Key Data */
1680                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1681                                        HOSTAPD_LEVEL_INFO,
1682                                        "received EAPOL-Key Request for GTK "
1683                                        "rekeying");
1684                         wpa_request_new_ptk(hapd, sta);
1685                         eloop_cancel_timeout(wpa_rekey_gtk, hapd, NULL);
1686                         wpa_rekey_gtk(hapd, NULL);
1687                 }
1688         } else {
1689                 /* Do not allow the same key replay counter to be reused. */
1690                 sm->key_replay_counter_valid = FALSE;
1691         }
1692
1693         free(sm->last_rx_eapol_key);
1694         sm->last_rx_eapol_key = malloc(data_len);
1695         if (sm->last_rx_eapol_key == NULL)
1696                 return;
1697         memcpy(sm->last_rx_eapol_key, data, data_len);
1698         sm->last_rx_eapol_key_len = data_len;
1699
1700         sm->EAPOLKeyReceived = TRUE;
1701         sm->EAPOLKeyPairwise = !!(key_info & WPA_KEY_INFO_KEY_TYPE);
1702         sm->EAPOLKeyRequest = !!(key_info & WPA_KEY_INFO_REQUEST);
1703         memcpy(sm->SNonce, key->key_nonce, WPA_NONCE_LEN);
1704         wpa_sm_step(sm);
1705 }
1706
1707
1708 static void wpa_pmk_to_ptk(struct hostapd_data *hapd, const u8 *pmk,
1709                            const u8 *addr1, const u8 *addr2,
1710                            const u8 *nonce1, const u8 *nonce2,
1711                            u8 *ptk, size_t ptk_len)
1712 {
1713         u8 data[2 * ETH_ALEN + 2 * WPA_NONCE_LEN];
1714
1715         /* PTK = PRF-X(PMK, "Pairwise key expansion",
1716          *             Min(AA, SA) || Max(AA, SA) ||
1717          *             Min(ANonce, SNonce) || Max(ANonce, SNonce)) */
1718
1719         if (memcmp(addr1, addr2, ETH_ALEN) < 0) {
1720                 memcpy(data, addr1, ETH_ALEN);
1721                 memcpy(data + ETH_ALEN, addr2, ETH_ALEN);
1722         } else {
1723                 memcpy(data, addr2, ETH_ALEN);
1724                 memcpy(data + ETH_ALEN, addr1, ETH_ALEN);
1725         }
1726
1727         if (memcmp(nonce1, nonce2, WPA_NONCE_LEN) < 0) {
1728                 memcpy(data + 2 * ETH_ALEN, nonce1, WPA_NONCE_LEN);
1729                 memcpy(data + 2 * ETH_ALEN + WPA_NONCE_LEN, nonce2,
1730                        WPA_NONCE_LEN);
1731         } else {
1732                 memcpy(data + 2 * ETH_ALEN, nonce2, WPA_NONCE_LEN);
1733                 memcpy(data + 2 * ETH_ALEN + WPA_NONCE_LEN, nonce1,
1734                        WPA_NONCE_LEN);
1735         }
1736
1737         sha1_prf(pmk, WPA_PMK_LEN, "Pairwise key expansion",
1738                  data, sizeof(data), ptk, ptk_len);
1739
1740         if (HOSTAPD_DEBUG_COND(HOSTAPD_DEBUG_MINIMAL)) {
1741                 hostapd_hexdump("PMK", pmk, WPA_PMK_LEN);
1742                 hostapd_hexdump("PTK", ptk, ptk_len);
1743         }
1744 }
1745
1746
1747 static void wpa_gmk_to_gtk(struct hostapd_data *hapd, u8 *gmk,
1748                            u8 *addr, u8 *gnonce, u8 *gtk, size_t gtk_len)
1749 {
1750         u8 data[ETH_ALEN + WPA_NONCE_LEN];
1751
1752         /* GTK = PRF-X(GMK, "Group key expansion", AA || GNonce) */
1753         memcpy(data, addr, ETH_ALEN);
1754         memcpy(data + ETH_ALEN, gnonce, WPA_NONCE_LEN);
1755
1756         sha1_prf(gmk, WPA_GMK_LEN, "Group key expansion",
1757                  data, sizeof(data), gtk, gtk_len);
1758
1759         if (HOSTAPD_DEBUG_COND(HOSTAPD_DEBUG_MINIMAL)) {
1760                 hostapd_hexdump("GMK", gmk, WPA_GMK_LEN);
1761                 hostapd_hexdump("GTK", gtk, gtk_len);
1762         }
1763 }
1764
1765
1766 static void wpa_send_eapol_timeout(void *eloop_ctx, void *timeout_ctx)
1767 {
1768         struct hostapd_data *hapd = eloop_ctx;
1769         struct sta_info *sta = timeout_ctx;
1770
1771         if (!sta->wpa_sm || !(sta->flags & WLAN_STA_ASSOC))
1772                 return;
1773
1774         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1775                        HOSTAPD_LEVEL_DEBUG, "EAPOL-Key timeout");
1776         sta->wpa_sm->TimeoutEvt = TRUE;
1777         wpa_sm_step(sta->wpa_sm);
1778 }
1779
1780
1781 static int wpa_calc_eapol_key_mic(int ver, u8 *key, u8 *data, size_t len,
1782                                   u8 *mic)
1783 {
1784         u8 hash[SHA1_MAC_LEN];
1785
1786         switch (ver) {
1787         case WPA_KEY_INFO_TYPE_HMAC_MD5_RC4:
1788                 hmac_md5(key, 16, data, len, mic);
1789                 break;
1790         case WPA_KEY_INFO_TYPE_HMAC_SHA1_AES:
1791                 hmac_sha1(key, 16, data, len, hash);
1792                 memcpy(mic, hash, MD5_MAC_LEN);
1793                 break;
1794         default:
1795                 return -1;
1796         }
1797         return 0;
1798 }
1799
1800
1801 static void wpa_send_eapol(struct hostapd_data *hapd, struct sta_info *sta,
1802                            int secure, int mic, int ack, int install,
1803                            int pairwise, u8 *key_rsc, u8 *nonce,
1804                            u8 *ie, size_t ie_len, u8 *gtk, size_t gtk_len,
1805                            int keyidx)
1806 {
1807         struct wpa_state_machine *sm = sta->wpa_sm;
1808         struct ieee802_1x_hdr *hdr;
1809         struct wpa_eapol_key *key;
1810         size_t len;
1811         int key_info, alg;
1812         int timeout_ms;
1813         int key_data_len, pad_len = 0;
1814         u8 *buf, *pos;
1815
1816         if (sm == NULL)
1817                 return;
1818
1819         len = sizeof(struct ieee802_1x_hdr) + sizeof(struct wpa_eapol_key);
1820
1821         if (sta->wpa == WPA_VERSION_WPA2) {
1822                 key_data_len = ie_len + gtk_len;
1823                 if (gtk_len)
1824                         key_data_len += 2 + RSN_SELECTOR_LEN + 2;
1825         } else {
1826                 if (pairwise) {
1827                         /* WPA does not include GTK in 4-Way Handshake */
1828                         gtk = NULL;
1829                         gtk_len = 0;
1830
1831                         /* key_rsc is for group key, so mask it out in case of
1832                          * WPA Pairwise key negotiation. */
1833                         key_rsc = NULL;
1834                 }
1835                 key_data_len = ie_len + gtk_len;
1836         }
1837
1838         if (sta->pairwise == WPA_CIPHER_CCMP) {
1839                 key_info = WPA_KEY_INFO_TYPE_HMAC_SHA1_AES;
1840                 if (gtk) {
1841                         pad_len = key_data_len % 8;
1842                         if (pad_len)
1843                                 pad_len = 8 - pad_len;
1844                         key_data_len += pad_len + 8;
1845                 }
1846         } else {
1847                 key_info = WPA_KEY_INFO_TYPE_HMAC_MD5_RC4;
1848         }
1849
1850         len += key_data_len;
1851
1852         hdr = malloc(len);
1853         if (hdr == NULL)
1854                 return;
1855         memset(hdr, 0, len);
1856         hdr->version = hapd->conf->eapol_version;
1857         hdr->type = IEEE802_1X_TYPE_EAPOL_KEY;
1858         hdr->length = htons(len  - sizeof(*hdr));
1859         key = (struct wpa_eapol_key *) (hdr + 1);
1860
1861         key->type = sta->wpa == WPA_VERSION_WPA2 ?
1862                 EAPOL_KEY_TYPE_RSN : EAPOL_KEY_TYPE_WPA;
1863         if (secure)
1864                 key_info |= WPA_KEY_INFO_SECURE;
1865         if (mic)
1866                 key_info |= WPA_KEY_INFO_MIC;
1867         if (ack)
1868                 key_info |= WPA_KEY_INFO_ACK;
1869         if (install)
1870                 key_info |= WPA_KEY_INFO_INSTALL;
1871         if (pairwise)
1872                 key_info |= WPA_KEY_INFO_KEY_TYPE;
1873         if (gtk && sta->wpa == WPA_VERSION_WPA2)
1874                 key_info |= WPA_KEY_INFO_ENCR_KEY_DATA;
1875         if (sta->wpa != WPA_VERSION_WPA2) {
1876                 if (pairwise)
1877                         keyidx = 0;
1878                 key_info |= keyidx << WPA_KEY_INFO_KEY_INDEX_SHIFT;
1879         }
1880         key->key_info = htons(key_info);
1881
1882         alg = pairwise ? sta->pairwise : hapd->conf->wpa_group;
1883         switch (alg) {
1884         case WPA_CIPHER_CCMP:
1885                 key->key_length = htons(16);
1886                 break;
1887         case WPA_CIPHER_TKIP:
1888                 key->key_length = htons(32);
1889                 break;
1890         case WPA_CIPHER_WEP40:
1891                 key->key_length = htons(5);
1892                 break;
1893         case WPA_CIPHER_WEP104:
1894                 key->key_length = htons(13);
1895                 break;
1896         }
1897
1898         inc_byte_array(sm->key_replay_counter, WPA_REPLAY_COUNTER_LEN);
1899         memcpy(key->replay_counter, sm->key_replay_counter,
1900                WPA_REPLAY_COUNTER_LEN);
1901         sm->key_replay_counter_valid = TRUE;
1902
1903         if (nonce)
1904                 memcpy(key->key_nonce, nonce, WPA_NONCE_LEN);
1905
1906         if (key_rsc)
1907                 memcpy(key->key_rsc, key_rsc, WPA_KEY_RSC_LEN);
1908
1909         if (ie && !gtk) {
1910                 memcpy(key + 1, ie, ie_len);
1911                 key->key_data_length = htons(ie_len);
1912         } else if (gtk) {
1913                 buf = malloc(key_data_len);
1914                 if (buf == NULL) {
1915                         free(hdr);
1916                         return;
1917                 }
1918                 memset(buf, 0, key_data_len);
1919                 pos = buf;
1920                 if (ie) {
1921                         memcpy(pos, ie, ie_len);
1922                         pos += ie_len;
1923                 }
1924                 if (sta->wpa == WPA_VERSION_WPA2) {
1925                         *pos++ = WLAN_EID_GENERIC;
1926                         *pos++ = RSN_SELECTOR_LEN + 2 + gtk_len;
1927                         memcpy(pos, RSN_KEY_DATA_GROUPKEY, RSN_SELECTOR_LEN);
1928                         pos += RSN_SELECTOR_LEN;
1929                         *pos++ = keyidx & 0x03;
1930                         *pos++ = 0;
1931                 }
1932                 memcpy(pos, gtk, gtk_len);
1933                 pos += gtk_len;
1934                 if (pad_len)
1935                         *pos++ = 0xdd;
1936
1937                 if (HOSTAPD_DEBUG_COND(HOSTAPD_DEBUG_MINIMAL)) {
1938                         hostapd_hexdump("Plaintext EAPOL-Key Key Data",
1939                                         buf, key_data_len);
1940                 }
1941                 if (key_info & WPA_KEY_INFO_TYPE_HMAC_SHA1_AES) {
1942                         aes_wrap(sm->PTK.encr_key, (key_data_len - 8) / 8, buf,
1943                                  (u8 *) (key + 1));
1944                         key->key_data_length = htons(key_data_len);
1945                 } else {
1946                         u8 ek[32];
1947                         memcpy(key->key_iv,
1948                                hapd->wpa_auth->Counter + WPA_NONCE_LEN - 16,
1949                                16);
1950                         inc_byte_array(hapd->wpa_auth->Counter, WPA_NONCE_LEN);
1951                         memcpy(ek, key->key_iv, 16);
1952                         memcpy(ek + 16, sm->PTK.encr_key, 16);
1953                         memcpy(key + 1, buf, key_data_len);
1954                         rc4_skip(ek, 32, 256, (u8 *) (key + 1), key_data_len);
1955                         key->key_data_length = htons(key_data_len);
1956                 }
1957                 free(buf);
1958         }
1959
1960         if (mic) {
1961                 if (!sm->PTK_valid) {
1962                         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
1963                                        HOSTAPD_LEVEL_DEBUG, "PTK not valid "
1964                                        "when sending EAPOL-Key frame");
1965                         free(hdr);
1966                         return;
1967                 }
1968                 wpa_calc_eapol_key_mic(key_info & WPA_KEY_INFO_TYPE_MASK,
1969                                        sm->PTK.mic_key, (u8 *) hdr, len,
1970                                        key->key_mic);
1971         }
1972
1973         if (sta->eapol_sm)
1974                 sta->eapol_sm->dot1xAuthEapolFramesTx++;
1975         hostapd_send_eapol(hapd, sta->addr, (u8 *) hdr, len, sm->pairwise_set);
1976         free(hdr);
1977
1978         timeout_ms = pairwise ? dot11RSNAConfigPairwiseUpdateTimeOut :
1979                 dot11RSNAConfigGroupUpdateTimeOut;
1980         eloop_register_timeout(timeout_ms / 1000, (timeout_ms % 1000) * 1000,
1981                                wpa_send_eapol_timeout, hapd, sta);
1982 }
1983
1984
1985 static int wpa_verify_key_mic(struct wpa_ptk *PTK, u8 *data, size_t data_len)
1986 {
1987         struct ieee802_1x_hdr *hdr;
1988         struct wpa_eapol_key *key;
1989         u16 key_info;
1990         int type, ret = 0;
1991         u8 mic[16];
1992
1993         if (data_len < sizeof(*hdr) + sizeof(*key))
1994                 return -1;
1995
1996         hdr = (struct ieee802_1x_hdr *) data;
1997         key = (struct wpa_eapol_key *) (hdr + 1);
1998         key_info = ntohs(key->key_info);
1999         type = key_info & WPA_KEY_INFO_TYPE_MASK;
2000         memcpy(mic, key->key_mic, 16);
2001         memset(key->key_mic, 0, 16);
2002         if (wpa_calc_eapol_key_mic(key_info & WPA_KEY_INFO_TYPE_MASK,
2003                                    PTK->mic_key, data, data_len, key->key_mic)
2004             || memcmp(mic, key->key_mic, 16) != 0)
2005                 ret = -1;
2006         memcpy(key->key_mic, mic, 16);
2007         return ret;
2008 }
2009
2010
2011 void wpa_sm_event(struct hostapd_data *hapd, struct sta_info *sta,
2012                   wpa_event event)
2013 {
2014         struct wpa_state_machine *sm = sta->wpa_sm;
2015         hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_WPA,
2016                        HOSTAPD_LEVEL_DEBUG,
2017                        "event %d notification", event);
2018         if (sm == NULL)
2019                 return;
2020
2021         switch (event) {
2022         case WPA_AUTH:
2023         case WPA_ASSOC:
2024                 break;
2025         case WPA_DEAUTH:
2026         case WPA_DISASSOC:
2027                 sm->DeauthenticationRequest = TRUE;
2028                 break;
2029         case WPA_REAUTH:
2030         case WPA_REAUTH_EAPOL:
2031                 sm->ReAuthenticationRequest = TRUE;
2032                 break;
2033         }
2034
2035         sm->PTK_valid = FALSE;
2036         memset(&sm->PTK, 0, sizeof(sm->PTK));
2037
2038         if (event != WPA_REAUTH_EAPOL) {
2039                 sm->pairwise_set = FALSE;
2040                 hostapd_set_encryption(sm->hapd, "none", sm->sta->addr, 0,
2041                                        (u8 *) "", 0);
2042         }
2043
2044         wpa_sm_step(sm);
2045 }
2046
2047
2048 static const char * wpa_alg_txt(int alg)
2049 {
2050         switch (alg) {
2051         case WPA_CIPHER_CCMP:
2052                 return "CCMP";
2053         case WPA_CIPHER_TKIP:
2054                 return "TKIP";
2055         case WPA_CIPHER_WEP104:
2056         case WPA_CIPHER_WEP40:
2057                 return "WEP";
2058         default:
2059                 return "";
2060         }
2061 }
2062
2063
2064 /* Definitions for clarifying state machine implementation */
2065 #define SM_STATE(machine, state) \
2066 static void sm_ ## machine ## _ ## state ## _Enter(struct wpa_state_machine \
2067 *sm)
2068
2069 #define SM_ENTRY(machine, _state, _data) \
2070 sm->changed = TRUE; \
2071 sm->_data ## _ ## state = machine ## _ ## _state; \
2072 if (sm->hapd->conf->debug >= HOSTAPD_DEBUG_MINIMAL) \
2073         printf("WPA: " MACSTR " " #machine " entering state " #_state \
2074                 "\n", MAC2STR(sm->sta->addr));
2075
2076 #define SM_ENTER(machine, state) sm_ ## machine ## _ ## state ## _Enter(sm)
2077
2078 #define SM_STEP(machine) \
2079 static void sm_ ## machine ## _Step(struct wpa_state_machine *sm)
2080
2081 #define SM_STEP_RUN(machine) sm_ ## machine ## _Step(sm)
2082
2083
2084 SM_STATE(WPA_PTK, INITIALIZE)
2085 {
2086         struct hostapd_data *hapd = sm->hapd;
2087
2088         SM_ENTRY(WPA_PTK, INITIALIZE, wpa_ptk);
2089         if (sm->Init) {
2090                 /* Init flag is not cleared here, so avoid busy
2091                  * loop by claiming nothing changed. */
2092                 sm->changed = FALSE;
2093         }
2094
2095         sm->keycount = 0;
2096         if (sm->GUpdateStationKeys)
2097                 hapd->wpa_auth->GKeyDoneStations--;
2098         sm->GUpdateStationKeys = FALSE;
2099         if (sm->sta->wpa == WPA_VERSION_WPA)
2100                 sm->PInitAKeys = FALSE;
2101         if (1 /* Unicast cipher supported AND (ESS OR ((IBSS or WDS) and
2102                * Local AA > Remote AA)) */) {
2103                 sm->Pair = TRUE;
2104         }
2105         ieee802_1x_notify_port_enabled(sm->sta->eapol_sm, 0);
2106         hostapd_set_encryption(sm->hapd, "none", sm->sta->addr, 0, (u8 *) "",
2107                                0);
2108         sm->pairwise_set = FALSE;
2109         sm->PTK_valid = FALSE;
2110         memset(&sm->PTK, 0, sizeof(sm->PTK));
2111         ieee802_1x_notify_port_valid(sm->sta->eapol_sm, 0);
2112         sm->TimeoutCtr = 0;
2113         if (sm->sta->wpa_key_mgmt == WPA_KEY_MGMT_PSK)
2114                 ieee802_1x_set_sta_authorized(sm->hapd, sm->sta, 0);
2115 }
2116
2117
2118 SM_STATE(WPA_PTK, DISCONNECT)
2119 {
2120         SM_ENTRY(WPA_PTK, DISCONNECT, wpa_ptk);
2121         sm->Disconnect = FALSE;
2122         wpa_sta_disconnect(sm->hapd, sm->sta);
2123 }
2124
2125
2126 SM_STATE(WPA_PTK, DISCONNECTED)
2127 {
2128         SM_ENTRY(WPA_PTK, DISCONNECTED, wpa_ptk);
2129         sm->hapd->wpa_auth->GNoStations--;
2130         sm->DeauthenticationRequest = FALSE;
2131 }
2132
2133
2134 SM_STATE(WPA_PTK, AUTHENTICATION)
2135 {
2136         SM_ENTRY(WPA_PTK, AUTHENTICATION, wpa_ptk);
2137         sm->hapd->wpa_auth->GNoStations++;
2138         memset(&sm->PTK, 0, sizeof(sm->PTK));
2139         sm->PTK_valid = FALSE;
2140         if (sm->sta->eapol_sm) {
2141                 sm->sta->eapol_sm->portControl = Auto;
2142                 sm->sta->eapol_sm->portEnabled = TRUE;
2143         }
2144         sm->AuthenticationRequest = FALSE;
2145 }
2146
2147
2148 SM_STATE(WPA_PTK, AUTHENTICATION2)
2149 {
2150         SM_ENTRY(WPA_PTK, AUTHENTICATION2, wpa_ptk);
2151         memcpy(sm->ANonce, sm->hapd->wpa_auth->Counter, WPA_NONCE_LEN);
2152         inc_byte_array(sm->hapd->wpa_auth->Counter, WPA_NONCE_LEN);
2153         sm->ReAuthenticationRequest = FALSE;
2154         /* IEEE 802.11i/D9.0 does not clear TimeoutCtr here, but this is more
2155          * logical place than INITIALIZE since AUTHENTICATION2 can be
2156          * re-entered on ReAuthenticationRequest without going through
2157          * INITIALIZE. */
2158         sm->TimeoutCtr = 0;
2159 }
2160
2161
2162 SM_STATE(WPA_PTK, INITPMK)
2163 {
2164         u8 *key;
2165         size_t len;
2166         SM_ENTRY(WPA_PTK, INITPMK, wpa_ptk);
2167         if (sm->sta->pmksa) {
2168                 wpa_printf(MSG_DEBUG, "WPA: PMK from PMKSA cache");
2169                 memcpy(sm->PMK, sm->sta->pmksa->pmk, WPA_PMK_LEN);
2170                 pmksa_cache_to_eapol_data(sm->sta->pmksa, sm->sta->eapol_sm);
2171         } else if ((key = ieee802_1x_get_key_crypt(sm->sta->eapol_sm, &len))) {
2172                 wpa_printf(MSG_DEBUG, "WPA: PMK from EAPOL state machine "
2173                            "(len=%lu)", (unsigned long) len);
2174                 if (len > WPA_PMK_LEN)
2175                         len = WPA_PMK_LEN;
2176                 memcpy(sm->PMK, key, len);
2177         } else {
2178                 wpa_printf(MSG_DEBUG, "WPA: Could not get PMK");
2179         }
2180         sm->sta->req_replay_counter_used = 0;
2181         /* IEEE 802.11i/D9.0 does not set keyRun to FALSE, but not doing this
2182          * will break reauthentication since EAPOL state machines may not be
2183          * get into AUTHENTICATING state that clears keyRun before WPA state
2184          * machine enters AUTHENTICATION2 state and goes immediately to INITPMK
2185          * state and takes PMK from the previously used AAA Key. This will
2186          * eventually fail in 4-Way Handshake because Supplicant uses PMK
2187          * derived from the new AAA Key. Setting keyRun = FALSE here seems to
2188          * be good workaround for this issue. */
2189         if (sm->sta->eapol_sm)
2190                 sm->sta->eapol_sm->keyRun = FALSE;
2191 }
2192
2193
2194 SM_STATE(WPA_PTK, INITPSK)
2195 {
2196         const u8 *psk;
2197         SM_ENTRY(WPA_PTK, INITPSK, wpa_ptk);
2198         psk = hostapd_get_psk(sm->hapd->conf, sm->sta->addr, NULL);
2199         if (psk)
2200                 memcpy(sm->PMK, psk, WPA_PMK_LEN);
2201         sm->sta->req_replay_counter_used = 0;
2202 }
2203
2204
2205 SM_STATE(WPA_PTK, PTKSTART)
2206 {
2207         u8 *pmkid = NULL;
2208         size_t pmkid_len = 0;
2209
2210         SM_ENTRY(WPA_PTK, PTKSTART, wpa_ptk);
2211         sm->PTKRequest = FALSE;
2212         sm->TimeoutEvt = FALSE;
2213         hostapd_logger(sm->hapd, sm->sta->addr, HOSTAPD_MODULE_WPA,
2214                        HOSTAPD_LEVEL_DEBUG,
2215                        "sending 1/4 msg of 4-Way Handshake");
2216         if (sm->sta->pmksa &&
2217             (pmkid = malloc(2 + RSN_SELECTOR_LEN + PMKID_LEN))) {
2218                 pmkid_len = 2 + RSN_SELECTOR_LEN + PMKID_LEN;
2219                 pmkid[0] = WLAN_EID_GENERIC;
2220                 pmkid[1] = RSN_SELECTOR_LEN + PMKID_LEN;
2221                 memcpy(&pmkid[2], RSN_KEY_DATA_PMKID, RSN_SELECTOR_LEN);
2222                 memcpy(&pmkid[2 + RSN_SELECTOR_LEN], sm->sta->pmksa->pmkid,
2223                        PMKID_LEN);
2224         }
2225         wpa_send_eapol(sm->hapd, sm->sta, 0, 0, 1, 0, 1, NULL, sm->ANonce,
2226                        pmkid, pmkid_len, NULL, 0, 0);
2227         free(pmkid);
2228         sm->TimeoutCtr++;
2229 }
2230
2231
2232 SM_STATE(WPA_PTK, PTKCALCNEGOTIATING)
2233 {
2234         struct wpa_ptk PTK;
2235         int ok = 0;
2236         const u8 *pmk = NULL;
2237
2238         SM_ENTRY(WPA_PTK, PTKCALCNEGOTIATING, wpa_ptk);
2239         sm->EAPOLKeyReceived = FALSE;
2240
2241         /* WPA with IEEE 802.1X: use the derived PMK from EAP
2242          * WPA-PSK: iterate through possible PSKs and select the one matching
2243          * the packet */
2244         for (;;) {
2245                 if (sm->sta->wpa_key_mgmt == WPA_KEY_MGMT_PSK) {
2246                         pmk = hostapd_get_psk(sm->hapd->conf, sm->sta->addr,
2247                                               pmk);
2248                         if (pmk == NULL)
2249                                 break;
2250                 } else
2251                         pmk = sm->PMK;
2252
2253                 wpa_pmk_to_ptk(sm->hapd, pmk, sm->hapd->own_addr,
2254                                sm->sta->addr, sm->ANonce, sm->SNonce,
2255                                (u8 *) &PTK, sizeof(PTK));
2256
2257                 if (wpa_verify_key_mic(&PTK, sm->last_rx_eapol_key,
2258                                        sm->last_rx_eapol_key_len) == 0) {
2259                         ok = 1;
2260                         break;
2261                 }
2262
2263                 if (sm->sta->wpa_key_mgmt != WPA_KEY_MGMT_PSK)
2264                         break;
2265         }
2266
2267         if (!ok) {
2268                 hostapd_logger(sm->hapd, sm->sta->addr, HOSTAPD_MODULE_WPA,
2269                                HOSTAPD_LEVEL_DEBUG, "invalid MIC in msg 2/4 "
2270                                "of 4-Way Handshake");
2271                 return;
2272         }
2273
2274         eloop_cancel_timeout(wpa_send_eapol_timeout, sm->hapd, sm->sta);
2275
2276         if (sm->sta->wpa_key_mgmt == WPA_KEY_MGMT_PSK) {
2277                 /* PSK may have changed from the previous choice, so update
2278                  * state machine data based on whatever PSK was selected here.
2279                  */
2280                 memcpy(sm->PMK, pmk, WPA_PMK_LEN);
2281         }
2282
2283         sm->MICVerified = TRUE;
2284
2285         memcpy(&sm->PTK, &PTK, sizeof(PTK));
2286         sm->PTK_valid = TRUE;
2287 }
2288
2289
2290 SM_STATE(WPA_PTK, PTKCALCNEGOTIATING2)
2291 {
2292         SM_ENTRY(WPA_PTK, PTKCALCNEGOTIATING2, wpa_ptk);
2293         sm->TimeoutCtr = 0;
2294 }
2295
2296
2297 SM_STATE(WPA_PTK, PTKINITNEGOTIATING)
2298 {
2299         u8 rsc[WPA_KEY_RSC_LEN];
2300         struct wpa_authenticator *gsm = sm->hapd->wpa_auth;
2301         u8 *wpa_ie;
2302         int wpa_ie_len;
2303
2304         SM_ENTRY(WPA_PTK, PTKINITNEGOTIATING, wpa_ptk);
2305         sm->TimeoutEvt = FALSE;
2306         /* Send EAPOL(1, 1, 1, Pair, P, RSC, ANonce, MIC(PTK), RSNIE, GTK[GN])
2307          */
2308         memset(rsc, 0, WPA_KEY_RSC_LEN);
2309         hostapd_get_seqnum(sm->hapd, NULL, gsm->GN, rsc);
2310         wpa_ie = sm->hapd->wpa_ie;
2311         wpa_ie_len = sm->hapd->wpa_ie_len;
2312         if (sm->sta->wpa == WPA_VERSION_WPA &&
2313             (sm->hapd->conf->wpa & HOSTAPD_WPA_VERSION_WPA2) &&
2314             wpa_ie_len > wpa_ie[1] + 2 && wpa_ie[0] == WLAN_EID_RSN) {
2315                 /* WPA-only STA, remove RSN IE */
2316                 wpa_ie = wpa_ie + wpa_ie[1] + 2;
2317                 wpa_ie_len = wpa_ie[1] + 2;
2318         }
2319         hostapd_logger(sm->hapd, sm->sta->addr, HOSTAPD_MODULE_WPA,
2320                        HOSTAPD_LEVEL_DEBUG,
2321                        "sending 3/4 msg of 4-Way Handshake");
2322         wpa_send_eapol(sm->hapd, sm->sta,
2323                        sm->sta->wpa == WPA_VERSION_WPA2 ? 1 : 0,
2324                        1, 1, 1, 1, rsc, sm->ANonce,
2325                        wpa_ie, wpa_ie_len,
2326                        gsm->GTK[gsm->GN - 1], gsm->GTK_len, gsm->GN);
2327         sm->TimeoutCtr++;
2328 }
2329
2330
2331 SM_STATE(WPA_PTK, PTKINITDONE)
2332 {
2333         SM_ENTRY(WPA_PTK, PTKINITDONE, wpa_ptk);
2334         sm->EAPOLKeyReceived = FALSE;
2335         if (sm->Pair) {
2336                 char *alg;
2337                 int klen;
2338                 if (sm->sta->pairwise == WPA_CIPHER_TKIP) {
2339                         alg = "TKIP";
2340                         klen = 32;
2341                 } else {
2342                         alg = "CCMP";
2343                         klen = 16;
2344                 }
2345                 if (hostapd_set_encryption(sm->hapd, alg, sm->sta->addr, 0,
2346                                            sm->PTK.tk1, klen)) {
2347                         wpa_sta_disconnect(sm->hapd, sm->sta);
2348                         return;
2349                 }
2350                 /* FIX: MLME-SetProtection.Request(TA, Tx_Rx) */
2351                 sm->pairwise_set = TRUE;
2352
2353                 if (sm->sta->wpa_key_mgmt == WPA_KEY_MGMT_PSK)
2354                         ieee802_1x_set_sta_authorized(sm->hapd, sm->sta, 1);
2355         }
2356
2357         if (0 /* IBSS == TRUE */) {
2358                 sm->keycount++;
2359                 if (sm->keycount == 2) {
2360                         ieee802_1x_notify_port_valid(sm->sta->eapol_sm, 1);
2361                 }
2362         } else {
2363                 ieee802_1x_notify_port_valid(sm->sta->eapol_sm, 1);
2364         }
2365         if (sm->sta->eapol_sm) {
2366                 sm->sta->eapol_sm->keyAvailable = FALSE;
2367                 sm->sta->eapol_sm->keyDone = TRUE;
2368         }
2369         if (sm->sta->wpa == WPA_VERSION_WPA)
2370                 sm->PInitAKeys = TRUE;
2371         else
2372                 sm->has_GTK = TRUE;
2373         hostapd_logger(sm->hapd, sm->sta->addr, HOSTAPD_MODULE_WPA,
2374                        HOSTAPD_LEVEL_INFO, "pairwise key handshake completed "
2375                        "(%s)",
2376                        sm->sta->wpa == WPA_VERSION_WPA ? "WPA" : "RSN");
2377         if (sm->sta->wpa_key_mgmt == WPA_KEY_MGMT_PSK)
2378                 accounting_sta_start(sm->hapd, sm->sta);
2379 }
2380
2381
2382 SM_STEP(WPA_PTK)
2383 {
2384         struct wpa_authenticator *wpa_auth = sm->hapd->wpa_auth;
2385
2386         if (sm->Init)
2387                 SM_ENTER(WPA_PTK, INITIALIZE);
2388         else if (sm->Disconnect
2389                  /* || FIX: dot11RSNAConfigSALifetime timeout */)
2390                 SM_ENTER(WPA_PTK, DISCONNECT);
2391         else if (sm->DeauthenticationRequest)
2392                 SM_ENTER(WPA_PTK, DISCONNECTED);
2393         else if (sm->AuthenticationRequest)
2394                 SM_ENTER(WPA_PTK, AUTHENTICATION);
2395         else if (sm->ReAuthenticationRequest)
2396                 SM_ENTER(WPA_PTK, AUTHENTICATION2);
2397         else if (sm->PTKRequest)
2398                 SM_ENTER(WPA_PTK, PTKSTART);
2399         else switch (sm->wpa_ptk_state) {
2400         case WPA_PTK_INITIALIZE:
2401                 break;
2402         case WPA_PTK_DISCONNECT:
2403                 SM_ENTER(WPA_PTK, DISCONNECTED);
2404                 break;
2405         case WPA_PTK_DISCONNECTED:
2406                 SM_ENTER(WPA_PTK, INITIALIZE);
2407                 break;
2408         case WPA_PTK_AUTHENTICATION:
2409                 SM_ENTER(WPA_PTK, AUTHENTICATION2);
2410                 break;
2411         case WPA_PTK_AUTHENTICATION2:
2412                 if ((sm->sta->wpa_key_mgmt == WPA_KEY_MGMT_IEEE8021X) &&
2413                     sm->sta->eapol_sm && sm->sta->eapol_sm->keyRun)
2414                         SM_ENTER(WPA_PTK, INITPMK);
2415                 else if ((sm->sta->wpa_key_mgmt == WPA_KEY_MGMT_PSK)
2416                          /* FIX: && 802.1X::keyRun */)
2417                         SM_ENTER(WPA_PTK, INITPSK);
2418                 break;
2419         case WPA_PTK_INITPMK:
2420                 if (sm->sta->eapol_sm && sm->sta->eapol_sm->keyAvailable)
2421                         SM_ENTER(WPA_PTK, PTKSTART);
2422                 else {
2423                         wpa_auth->dot11RSNA4WayHandshakeFailures++;
2424                         SM_ENTER(WPA_PTK, DISCONNECT);
2425                 }
2426                 break;
2427         case WPA_PTK_INITPSK:
2428                 if (hostapd_get_psk(sm->hapd->conf, sm->sta->addr, NULL))
2429                         SM_ENTER(WPA_PTK, PTKSTART);
2430                 else {
2431                         hostapd_logger(sm->hapd, sm->sta->addr,
2432                                        HOSTAPD_MODULE_WPA,
2433                                        HOSTAPD_LEVEL_INFO,
2434                                        "no PSK configured for the STA");
2435                         wpa_auth->dot11RSNA4WayHandshakeFailures++;
2436                         SM_ENTER(WPA_PTK, DISCONNECT);
2437                 }
2438                 break;
2439         case WPA_PTK_PTKSTART:
2440                 if (sm->EAPOLKeyReceived && !sm->EAPOLKeyRequest &&
2441                     sm->EAPOLKeyPairwise)
2442                         SM_ENTER(WPA_PTK, PTKCALCNEGOTIATING);
2443                 else if (sm->TimeoutCtr > dot11RSNAConfigPairwiseUpdateCount) {
2444                         wpa_auth->dot11RSNA4WayHandshakeFailures++;
2445                         SM_ENTER(WPA_PTK, DISCONNECT);
2446                 } else if (sm->TimeoutEvt)
2447                         SM_ENTER(WPA_PTK, PTKSTART);
2448                 break;
2449         case WPA_PTK_PTKCALCNEGOTIATING:
2450                 if (sm->MICVerified)
2451                         SM_ENTER(WPA_PTK, PTKCALCNEGOTIATING2);
2452                 else if (sm->EAPOLKeyReceived && !sm->EAPOLKeyRequest &&
2453                          sm->EAPOLKeyPairwise)
2454                         SM_ENTER(WPA_PTK, PTKCALCNEGOTIATING);
2455                 else if (sm->TimeoutEvt)
2456                         SM_ENTER(WPA_PTK, PTKSTART);
2457                 break;
2458         case WPA_PTK_PTKCALCNEGOTIATING2:
2459                 SM_ENTER(WPA_PTK, PTKINITNEGOTIATING);
2460                 break;
2461         case WPA_PTK_PTKINITNEGOTIATING:
2462                 if (sm->EAPOLKeyReceived && !sm->EAPOLKeyRequest &&
2463                     sm->EAPOLKeyPairwise && sm->MICVerified)
2464                         SM_ENTER(WPA_PTK, PTKINITDONE);
2465                 else if (sm->TimeoutCtr > dot11RSNAConfigPairwiseUpdateCount) {
2466                         wpa_auth->dot11RSNA4WayHandshakeFailures++;
2467                         SM_ENTER(WPA_PTK, DISCONNECT);
2468                 } else if (sm->TimeoutEvt)
2469                         SM_ENTER(WPA_PTK, PTKINITNEGOTIATING);
2470                 break;
2471         case WPA_PTK_PTKINITDONE:
2472                 break;
2473         }
2474 }
2475
2476
2477 SM_STATE(WPA_PTK_GROUP, IDLE)
2478 {
2479         SM_ENTRY(WPA_PTK_GROUP, IDLE, wpa_ptk_group);
2480         if (sm->Init) {
2481                 /* Init flag is not cleared here, so avoid busy
2482                  * loop by claiming nothing changed. */
2483                 sm->changed = FALSE;
2484         }
2485         sm->GTimeoutCtr = 0;
2486 }
2487
2488
2489 SM_STATE(WPA_PTK_GROUP, REKEYNEGOTIATING)
2490 {
2491         u8 rsc[WPA_KEY_RSC_LEN];
2492         struct wpa_authenticator *gsm = sm->hapd->wpa_auth;
2493
2494         SM_ENTRY(WPA_PTK_GROUP, REKEYNEGOTIATING, wpa_ptk_group);
2495         if (sm->sta->wpa == WPA_VERSION_WPA)
2496                 sm->PInitAKeys = FALSE;
2497         sm->TimeoutEvt = FALSE;
2498         /* Send EAPOL(1, 1, 1, !Pair, G, RSC, GNonce, MIC(PTK), GTK[GN]) */
2499         memset(rsc, 0, WPA_KEY_RSC_LEN);
2500         if (gsm->wpa_group_state == WPA_GROUP_SETKEYSDONE)
2501                 hostapd_get_seqnum(sm->hapd, NULL, gsm->GN, rsc);
2502         hostapd_logger(sm->hapd, sm->sta->addr, HOSTAPD_MODULE_WPA,
2503                        HOSTAPD_LEVEL_DEBUG,
2504                        "sending 1/2 msg of Group Key Handshake");
2505         wpa_send_eapol(sm->hapd, sm->sta, 1, 1, 1, !sm->Pair, 0, rsc,
2506                        gsm->GNonce, NULL, 0,
2507                        gsm->GTK[gsm->GN - 1], gsm->GTK_len, gsm->GN);
2508         sm->GTimeoutCtr++;
2509 }
2510
2511
2512 SM_STATE(WPA_PTK_GROUP, REKEYESTABLISHED)
2513 {
2514         SM_ENTRY(WPA_PTK_GROUP, REKEYESTABLISHED, wpa_ptk_group);
2515         sm->EAPOLKeyReceived = FALSE;
2516         sm->GUpdateStationKeys = FALSE;
2517         sm->hapd->wpa_auth->GKeyDoneStations--;
2518         sm->GTimeoutCtr = 0;
2519         /* FIX: MLME.SetProtection.Request(TA, Tx_Rx) */
2520         hostapd_logger(sm->hapd, sm->sta->addr, HOSTAPD_MODULE_WPA,
2521                        HOSTAPD_LEVEL_INFO, "group key handshake completed "
2522                        "(%s)",
2523                        sm->sta->wpa == WPA_VERSION_WPA ? "WPA" : "RSN");
2524         sm->has_GTK = TRUE;
2525 }
2526
2527
2528 SM_STATE(WPA_PTK_GROUP, KEYERROR)
2529 {
2530         SM_ENTRY(WPA_PTK_GROUP, KEYERROR, wpa_ptk_group);
2531         sm->hapd->wpa_auth->GKeyDoneStations--;
2532         sm->GUpdateStationKeys = FALSE;
2533         sm->Disconnect = TRUE;
2534 }
2535
2536
2537 SM_STEP(WPA_PTK_GROUP)
2538 {
2539         if (sm->Init)
2540                 SM_ENTER(WPA_PTK_GROUP, IDLE);
2541         else switch (sm->wpa_ptk_group_state) {
2542         case WPA_PTK_GROUP_IDLE:
2543                 if (sm->GUpdateStationKeys ||
2544                     (sm->sta->wpa == WPA_VERSION_WPA && sm->PInitAKeys))
2545                         SM_ENTER(WPA_PTK_GROUP, REKEYNEGOTIATING);
2546                 break;
2547         case WPA_PTK_GROUP_REKEYNEGOTIATING:
2548                 if (sm->EAPOLKeyReceived && !sm->EAPOLKeyRequest &&
2549                     !sm->EAPOLKeyPairwise && sm->MICVerified)
2550                         SM_ENTER(WPA_PTK_GROUP, REKEYESTABLISHED);
2551                 else if (sm->GTimeoutCtr > dot11RSNAConfigGroupUpdateCount)
2552                         SM_ENTER(WPA_PTK_GROUP, KEYERROR);
2553                 else if (sm->TimeoutEvt)
2554                         SM_ENTER(WPA_PTK_GROUP, REKEYNEGOTIATING);
2555                 break;
2556         case WPA_PTK_GROUP_KEYERROR:
2557                 SM_ENTER(WPA_PTK_GROUP, IDLE);
2558                 break;
2559         case WPA_PTK_GROUP_REKEYESTABLISHED:
2560                 SM_ENTER(WPA_PTK_GROUP, IDLE);
2561                 break;
2562         }
2563 }
2564
2565
2566 static void wpa_group_gtk_init(struct hostapd_data *hapd)
2567 {
2568         struct wpa_authenticator *sm = hapd->wpa_auth;
2569         HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "WPA: group state machine "
2570                       "entering state GTK_INIT\n");
2571         sm->changed = FALSE; /* GInit is not cleared here; avoid loop */
2572         sm->wpa_group_state = WPA_GROUP_GTK_INIT;
2573
2574         /* GTK[0..N] = 0 */
2575         memset(sm->GTK, 0, sizeof(sm->GTK));
2576         sm->GN = 1;
2577         sm->GM = 2;
2578         /* GTK[GN] = CalcGTK() */
2579         /* FIX: is this the correct way of getting GNonce? */
2580         memcpy(sm->GNonce, sm->Counter, WPA_NONCE_LEN);
2581         inc_byte_array(sm->Counter, WPA_NONCE_LEN);
2582         wpa_gmk_to_gtk(hapd, sm->GMK, hapd->own_addr, sm->GNonce,
2583                        sm->GTK[sm->GN - 1], sm->GTK_len);
2584 }
2585
2586
2587 static void wpa_group_setkeys(struct hostapd_data *hapd)
2588 {
2589         struct wpa_authenticator *sm = hapd->wpa_auth;
2590         struct sta_info *sta;
2591         int tmp;
2592
2593         HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "WPA: group state machine "
2594                       "entering state SETKEYS\n");
2595         sm->changed = TRUE;
2596         sm->wpa_group_state = WPA_GROUP_SETKEYS;
2597         sm->GTKReKey = FALSE;
2598         tmp = sm->GM;
2599         sm->GM = sm->GN;
2600         sm->GN = tmp;
2601         sm->GKeyDoneStations = sm->GNoStations;
2602         /* FIX: is this the correct way of getting GNonce? */
2603         memcpy(sm->GNonce, sm->Counter, WPA_NONCE_LEN);
2604         inc_byte_array(sm->Counter, WPA_NONCE_LEN);
2605         wpa_gmk_to_gtk(hapd, sm->GMK, hapd->own_addr, sm->GNonce,
2606                        sm->GTK[sm->GN - 1], sm->GTK_len);
2607
2608         sta = hapd->sta_list;
2609         while (sta) {
2610                 if (sta->wpa_sm) {
2611                         sta->wpa_sm->GUpdateStationKeys = TRUE;
2612                         wpa_sm_step(sta->wpa_sm);
2613                 }
2614                 sta = sta->next;
2615         }
2616 }
2617
2618
2619 static void wpa_group_setkeysdone(struct hostapd_data *hapd)
2620 {
2621         struct wpa_authenticator *sm = hapd->wpa_auth;
2622
2623         HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "WPA: group state machine "
2624                       "entering state SETKEYSDONE\n");
2625         sm->changed = TRUE;
2626         sm->wpa_group_state = WPA_GROUP_SETKEYSDONE;
2627         hostapd_set_encryption(hapd, wpa_alg_txt(hapd->conf->wpa_group),
2628                                NULL, sm->GN, sm->GTK[sm->GN - 1], sm->GTK_len);
2629 }
2630
2631
2632 static void wpa_group_sm_step(struct hostapd_data *hapd)
2633 {
2634         struct wpa_authenticator *sm = hapd->wpa_auth;
2635
2636         if (sm->GInit) {
2637                 wpa_group_gtk_init(hapd);
2638         } else if (sm->wpa_group_state == WPA_GROUP_GTK_INIT &&
2639                    sm->GTKAuthenticator) {
2640                 wpa_group_setkeysdone(hapd);
2641         } else if (sm->wpa_group_state == WPA_GROUP_SETKEYSDONE &&
2642                    sm->GTKReKey) {
2643                 wpa_group_setkeys(hapd);
2644         } else if (sm->wpa_group_state == WPA_GROUP_SETKEYS) {
2645                 if (sm->GKeyDoneStations == 0)
2646                         wpa_group_setkeysdone(hapd);
2647                 else if (sm->GTKReKey)
2648                         wpa_group_setkeys(hapd);
2649         }
2650 }
2651
2652
2653 static int wpa_sm_sta_entry_alive(struct hostapd_data *hapd, u8 *addr)
2654 {
2655         struct sta_info *sta;
2656         sta = ap_get_sta(hapd, addr);
2657         if (sta == NULL || sta->wpa_sm == NULL)
2658                 return 0;
2659         return 1;
2660 }
2661
2662
2663 static void wpa_sm_step(struct wpa_state_machine *sm)
2664 {
2665         struct hostapd_data *hapd;
2666         u8 addr[6];
2667         if (sm == NULL || sm->sta == NULL || sm->sta->wpa_sm == NULL)
2668                 return;
2669         hapd = sm->hapd;
2670
2671         memcpy(addr, sm->sta->addr, 6);
2672         do {
2673                 sm->changed = FALSE;
2674                 sm->hapd->wpa_auth->changed = FALSE;
2675
2676                 SM_STEP_RUN(WPA_PTK);
2677                 if (!wpa_sm_sta_entry_alive(hapd, addr))
2678                         break;
2679                 SM_STEP_RUN(WPA_PTK_GROUP);
2680                 if (!wpa_sm_sta_entry_alive(hapd, addr))
2681                         break;
2682                 wpa_group_sm_step(sm->hapd);
2683                 if (!wpa_sm_sta_entry_alive(hapd, addr))
2684                         break;
2685         } while (sm->changed || sm->hapd->wpa_auth->changed);
2686 }
2687
2688
2689 static void wpa_sm_call_step(void *eloop_ctx, void *timeout_ctx)
2690 {
2691         struct wpa_state_machine *sm = timeout_ctx;
2692         wpa_sm_step(sm);
2693 }
2694
2695
2696 void wpa_sm_notify(struct hostapd_data *hapd, struct sta_info *sta)
2697 {
2698         if (sta->wpa_sm == NULL)
2699                 return;
2700         eloop_register_timeout(0, 0, wpa_sm_call_step, hapd, sta->wpa_sm);
2701 }
2702
2703
2704 void wpa_gtk_rekey(struct hostapd_data *hapd)
2705 {
2706         struct wpa_authenticator *sm = hapd->wpa_auth;
2707         int tmp, i;
2708
2709         if (sm == NULL)
2710                 return;
2711
2712         for (i = 0; i < 2; i++) {
2713                 tmp = sm->GM;
2714                 sm->GM = sm->GN;
2715                 sm->GN = tmp;
2716                 memcpy(sm->GNonce, sm->Counter, WPA_NONCE_LEN);
2717                 inc_byte_array(sm->Counter, WPA_NONCE_LEN);
2718                 wpa_gmk_to_gtk(hapd, sm->GMK, hapd->own_addr, sm->GNonce,
2719                                sm->GTK[sm->GN - 1], sm->GTK_len);
2720         }
2721 }
2722
2723
2724 static const char * wpa_bool_txt(int bool)
2725 {
2726         return bool ? "TRUE" : "FALSE";
2727 }
2728
2729
2730 static int wpa_cipher_bits(int cipher)
2731 {
2732         switch (cipher) {
2733         case WPA_CIPHER_CCMP:
2734                 return 128;
2735         case WPA_CIPHER_TKIP:
2736                 return 256;
2737         case WPA_CIPHER_WEP104:
2738                 return 104;
2739         case WPA_CIPHER_WEP40:
2740                 return 40;
2741         default:
2742                 return 0;
2743         }
2744 }
2745
2746
2747 #define RSN_SUITE "%02x-%02x-%02x-%d"
2748 #define RSN_SUITE_ARG(s) (s)[0], (s)[1], (s)[2], (s)[3]
2749
2750 int wpa_get_mib(struct hostapd_data *hapd, char *buf, size_t buflen)
2751 {
2752         int len = 0, i;
2753         char pmkid_txt[PMKID_LEN * 2 + 1], *pos;
2754
2755         len += snprintf(buf + len, buflen - len,
2756                         "dot11RSNAOptionImplemented=TRUE\n"
2757                         "dot11RSNAPreauthenticationImplemented=TRUE\n"
2758                         "dot11RSNAEnabled=%s\n"
2759                         "dot11RSNAPreauthenticationEnabled=%s\n",
2760                         wpa_bool_txt(hapd->conf->wpa &
2761                                      HOSTAPD_WPA_VERSION_WPA2),
2762                         wpa_bool_txt(hapd->conf->rsn_preauth));
2763
2764         if (hapd->wpa_auth == NULL)
2765                 return len;
2766
2767         pos = pmkid_txt;
2768         for (i = 0; i < PMKID_LEN; i++) {
2769                 pos += sprintf(pos, "%02x",
2770                                hapd->wpa_auth->dot11RSNAPMKIDUsed[i]);
2771         }
2772
2773         len += snprintf(buf + len, buflen - len,
2774                         "dot11RSNAConfigVersion=%u\n"
2775                         "dot11RSNAConfigPairwiseKeysSupported=9999\n"
2776                         /* FIX: dot11RSNAConfigGroupCipher */
2777                         /* FIX: dot11RSNAConfigGroupRekeyMethod */
2778                         /* FIX: dot11RSNAConfigGroupRekeyTime */
2779                         /* FIX: dot11RSNAConfigGroupRekeyPackets */
2780                         "dot11RSNAConfigGroupRekeyStrict=%u\n"
2781                         "dot11RSNAConfigGroupUpdateCount=%u\n"
2782                         "dot11RSNAConfigPairwiseUpdateCount=%u\n"
2783                         "dot11RSNAConfigGroupCipherSize=%u\n"
2784                         "dot11RSNAConfigPMKLifetime=%u\n"
2785                         "dot11RSNAConfigPMKReauthThreshold=%u\n"
2786                         "dot11RSNAConfigNumberOfPTKSAReplayCounters=0\n"
2787                         "dot11RSNAConfigSATimeout=%u\n"
2788                         "dot11RSNAAuthenticationSuiteSelected=" RSN_SUITE "\n"
2789                         "dot11RSNAPairwiseCipherSelected=" RSN_SUITE "\n"
2790                         "dot11RSNAGroupCipherSelected=" RSN_SUITE "\n"
2791                         "dot11RSNAPMKIDUsed=%s\n"
2792                         "dot11RSNAAuthenticationSuiteRequested=" RSN_SUITE "\n"
2793                         "dot11RSNAPairwiseCipherRequested=" RSN_SUITE "\n"
2794                         "dot11RSNAGroupCipherRequested=" RSN_SUITE "\n"
2795                         "dot11RSNATKIPCounterMeasuresInvoked=%u\n"
2796                         "dot11RSNA4WayHandshakeFailures=%u\n"
2797                         "dot11RSNAConfigNumberOfGTKSAReplayCounters=0\n",
2798                         RSN_VERSION,
2799                         !!hapd->conf->wpa_strict_rekey,
2800                         dot11RSNAConfigGroupUpdateCount,
2801                         dot11RSNAConfigPairwiseUpdateCount,
2802                         wpa_cipher_bits(hapd->conf->wpa_group),
2803                         dot11RSNAConfigPMKLifetime,
2804                         dot11RSNAConfigPMKReauthThreshold,
2805                         dot11RSNAConfigSATimeout,
2806                         RSN_SUITE_ARG(hapd->wpa_auth->
2807                                       dot11RSNAAuthenticationSuiteSelected),
2808                         RSN_SUITE_ARG(hapd->wpa_auth->
2809                                       dot11RSNAPairwiseCipherSelected),
2810                         RSN_SUITE_ARG(hapd->wpa_auth->
2811                                       dot11RSNAGroupCipherSelected),
2812                         pmkid_txt,
2813                         RSN_SUITE_ARG(hapd->wpa_auth->
2814                                       dot11RSNAAuthenticationSuiteRequested),
2815                         RSN_SUITE_ARG(hapd->wpa_auth->
2816                                       dot11RSNAPairwiseCipherRequested),
2817                         RSN_SUITE_ARG(hapd->wpa_auth->
2818                                       dot11RSNAGroupCipherRequested),
2819                         hapd->wpa_auth->dot11RSNATKIPCounterMeasuresInvoked,
2820                         hapd->wpa_auth->dot11RSNA4WayHandshakeFailures);
2821
2822         /* TODO: dot11RSNAConfigPairwiseCiphersTable */
2823         /* TODO: dot11RSNAConfigAuthenticationSuitesTable */
2824
2825         /* Private MIB */
2826         len += snprintf(buf + len, buflen - len,
2827                         "hostapdWPAGroupState=%d\n",
2828                         hapd->wpa_auth->wpa_group_state);
2829
2830         return len;
2831 }
2832
2833
2834 int wpa_get_mib_sta(struct hostapd_data *hapd, struct sta_info *sta,
2835                     char *buf, size_t buflen)
2836 {
2837         int len = 0;
2838         u8 not_used[4] = { 0, 0, 0, 0 };
2839         const u8 *pairwise = not_used;
2840
2841         /* TODO: FF-FF-FF-FF-FF-FF entry for broadcast/multicast stats */
2842
2843         /* dot11RSNAStatsEntry */
2844
2845         if (sta->wpa == WPA_VERSION_WPA) {
2846                 if (sta->pairwise == WPA_CIPHER_CCMP)
2847                         pairwise = WPA_CIPHER_SUITE_CCMP;
2848                 else if (sta->pairwise == WPA_CIPHER_TKIP)
2849                         pairwise = WPA_CIPHER_SUITE_TKIP;
2850                 else if (sta->pairwise == WPA_CIPHER_WEP104)
2851                         pairwise = WPA_CIPHER_SUITE_WEP104;
2852                 else if (sta->pairwise == WPA_CIPHER_WEP40)
2853                         pairwise = WPA_CIPHER_SUITE_WEP40;
2854                 else if (sta->pairwise == WPA_CIPHER_NONE)
2855                         pairwise = WPA_CIPHER_SUITE_NONE;
2856         } else if (sta->wpa == WPA_VERSION_WPA2) {
2857                 if (sta->pairwise == WPA_CIPHER_CCMP)
2858                         pairwise = RSN_CIPHER_SUITE_CCMP;
2859                 else if (sta->pairwise == WPA_CIPHER_TKIP)
2860                         pairwise = RSN_CIPHER_SUITE_TKIP;
2861                 else if (sta->pairwise == WPA_CIPHER_WEP104)
2862                         pairwise = RSN_CIPHER_SUITE_WEP104;
2863                 else if (sta->pairwise == WPA_CIPHER_WEP40)
2864                         pairwise = RSN_CIPHER_SUITE_WEP40;
2865                 else if (sta->pairwise == WPA_CIPHER_NONE)
2866                         pairwise = RSN_CIPHER_SUITE_NONE;
2867         } else
2868                 return 0;
2869
2870         len += snprintf(buf + len, buflen - len,
2871                         /* TODO: dot11RSNAStatsIndex */
2872                         "dot11RSNAStatsSTAAddress=" MACSTR "\n"
2873                         "dot11RSNAStatsVersion=1\n"
2874                         "dot11RSNAStatsSelectedPairwiseCipher=" RSN_SUITE "\n"
2875                         /* TODO: dot11RSNAStatsTKIPICVErrors */
2876                         "dot11RSNAStatsTKIPLocalMICFailures=%u\n"
2877                         "dot11RSNAStatsTKIPRemoveMICFailures=%u\n"
2878                         /* TODO: dot11RSNAStatsCCMPReplays */
2879                         /* TODO: dot11RSNAStatsCCMPDecryptErrors */
2880                         /* TODO: dot11RSNAStatsTKIPReplays */,
2881                         MAC2STR(sta->addr),
2882                         RSN_SUITE_ARG(pairwise),
2883                         sta->dot11RSNAStatsTKIPLocalMICFailures,
2884                         sta->dot11RSNAStatsTKIPRemoteMICFailures);
2885
2886         if (sta->wpa_sm == NULL)
2887                 return len;
2888
2889         /* Private MIB */
2890         len += snprintf(buf + len, buflen - len,
2891                         "hostapdWPAPTKState=%d\n"
2892                         "hostapdWPAPTKGroupState=%d\n",
2893                         sta->wpa_sm->wpa_ptk_state,
2894                         sta->wpa_sm->wpa_ptk_group_state);
2895
2896         return len;
2897 }