wlantest/rx_mgmt.c

   1 /*
   2  * Received Management frame processing
   3  * Copyright (c) 2010, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "utils/includes.h"
  16
  17 #include "utils/common.h"
  18 #include "common/ieee802_11_defs.h"
  19 #include "common/ieee802_11_common.h"
  20 #include "crypto/aes_wrap.h"
  21 #include "wlantest.h"
  22
  23
  24 static const char * mgmt_stype(u16 stype)
  25 {
  26         switch (stype) {
  27         case WLAN_FC_STYPE_ASSOC_REQ:
  28                 return "ASSOC-REQ";
  29         case WLAN_FC_STYPE_ASSOC_RESP:
  30                 return "ASSOC-RESP";
  31         case WLAN_FC_STYPE_REASSOC_REQ:
  32                 return "REASSOC-REQ";
  33         case WLAN_FC_STYPE_REASSOC_RESP:
  34                 return "REASSOC-RESP";
  35         case WLAN_FC_STYPE_PROBE_REQ:
  36                 return "PROBE-REQ";
  37         case WLAN_FC_STYPE_PROBE_RESP:
  38                 return "PROBE-RESP";
  39         case WLAN_FC_STYPE_BEACON:
  40                 return "BEACON";
  41         case WLAN_FC_STYPE_ATIM:
  42                 return "ATIM";
  43         case WLAN_FC_STYPE_DISASSOC:
  44                 return "DISASSOC";
  45         case WLAN_FC_STYPE_AUTH:
  46                 return "AUTH";
  47         case WLAN_FC_STYPE_DEAUTH:
  48                 return "DEAUTH";
  49         case WLAN_FC_STYPE_ACTION:
  50                 return "ACTION";
  51         }
  52         return "??";
  53 }
  54
  55
  56 static void rx_mgmt_beacon(struct wlantest *wt, const u8 *data, size_t len)
  57 {
  58         const struct ieee80211_mgmt *mgmt;
  59         struct wlantest_bss *bss;
  60         struct ieee802_11_elems elems;
  61
  62         mgmt = (const struct ieee80211_mgmt *) data;
  63         bss = bss_get(wt, mgmt->bssid);
  64         if (bss == NULL)
  65                 return;
  66         if (bss->proberesp_seen)
  67                 return; /* do not override with Beacon data */
  68         bss->capab_info = le_to_host16(mgmt->u.beacon.capab_info);
  69         if (ieee802_11_parse_elems(mgmt->u.beacon.variable,
  70                                    len - (mgmt->u.beacon.variable - data),
  71                                    &elems, 0) == ParseFailed) {
  72                 if (bss->parse_error_reported)
  73                         return;
  74                 wpa_printf(MSG_INFO, "Invalid IEs in a Beacon frame from "
  75                            MACSTR, MAC2STR(mgmt->sa));
  76                 bss->parse_error_reported = 1;
  77                 return;
  78         }
  79
  80         bss_update(wt, bss, &elems);
  81 }
  82
  83
  84 static void rx_mgmt_probe_resp(struct wlantest *wt, const u8 *data, size_t len)
  85 {
  86         const struct ieee80211_mgmt *mgmt;
  87         struct wlantest_bss *bss;
  88         struct ieee802_11_elems elems;
  89
  90         mgmt = (const struct ieee80211_mgmt *) data;
  91         bss = bss_get(wt, mgmt->bssid);
  92         if (bss == NULL)
  93                 return;
  94
  95         bss->capab_info = le_to_host16(mgmt->u.probe_resp.capab_info);
  96         if (ieee802_11_parse_elems(mgmt->u.probe_resp.variable,
  97                                    len - (mgmt->u.probe_resp.variable - data),
  98                                    &elems, 0) == ParseFailed) {
  99                 if (bss->parse_error_reported)
 100                         return;
 101                 wpa_printf(MSG_INFO, "Invalid IEs in a Probe Response frame "
 102                            "from " MACSTR, MAC2STR(mgmt->sa));
 103                 bss->parse_error_reported = 1;
 104                 return;
 105         }
 106
 107         bss_update(wt, bss, &elems);
 108 }
 109
 110
 111 static void rx_mgmt_auth(struct wlantest *wt, const u8 *data, size_t len)
 112 {
 113         const struct ieee80211_mgmt *mgmt;
 114         struct wlantest_bss *bss;
 115         struct wlantest_sta *sta;
 116         u16 alg, trans, status;
 117
 118         mgmt = (const struct ieee80211_mgmt *) data;
 119         bss = bss_get(wt, mgmt->bssid);
 120         if (bss == NULL)
 121                 return;
 122         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 123                 sta = sta_get(bss, mgmt->da);
 124         else
 125                 sta = sta_get(bss, mgmt->sa);
 126         if (sta == NULL)
 127                 return;
 128
 129         if (len < 24 + 6) {
 130                 wpa_printf(MSG_INFO, "Too short Authentication frame from "
 131                            MACSTR, MAC2STR(mgmt->sa));
 132                 return;
 133         }
 134
 135         alg = le_to_host16(mgmt->u.auth.auth_alg);
 136         trans = le_to_host16(mgmt->u.auth.auth_transaction);
 137         status = le_to_host16(mgmt->u.auth.status_code);
 138
 139         wpa_printf(MSG_DEBUG, "AUTH " MACSTR " -> " MACSTR
 140                    " (alg=%u trans=%u status=%u)",
 141                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), alg, trans, status);
 142
 143         if (alg == 0 && trans == 2 && status == 0) {
 144                 if (sta->state == STATE1) {
 145                         wpa_printf(MSG_DEBUG, "STA " MACSTR
 146                                    " moved to State 2 with " MACSTR,
 147                                    MAC2STR(sta->addr), MAC2STR(bss->bssid));
 148                         sta->state = STATE2;
 149                 }
 150         }
 151 }
 152
 153
 154 static void rx_mgmt_deauth(struct wlantest *wt, const u8 *data, size_t len,
 155                            int valid)
 156 {
 157         const struct ieee80211_mgmt *mgmt;
 158         struct wlantest_bss *bss;
 159         struct wlantest_sta *sta;
 160
 161         mgmt = (const struct ieee80211_mgmt *) data;
 162         bss = bss_get(wt, mgmt->bssid);
 163         if (bss == NULL)
 164                 return;
 165         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 166                 sta = sta_get(bss, mgmt->da);
 167         else
 168                 sta = sta_get(bss, mgmt->sa);
 169         if (sta == NULL)
 170                 return;
 171
 172         if (len < 24 + 2) {
 173                 wpa_printf(MSG_INFO, "Too short Deauthentication frame from "
 174                            MACSTR, MAC2STR(mgmt->sa));
 175                 return;
 176         }
 177
 178         wpa_printf(MSG_DEBUG, "DEAUTH " MACSTR " -> " MACSTR
 179                    " (reason=%u)",
 180                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 181                    le_to_host16(mgmt->u.deauth.reason_code));
 182         wpa_hexdump(MSG_MSGDUMP, "DEAUTH payload", data + 24, len - 24);
 183
 184         if (!valid) {
 185                 wpa_printf(MSG_INFO, "Do not change STA " MACSTR " State "
 186                            "since Disassociation frame was not protected "
 187                            "correctly", MAC2STR(sta->addr));
 188                 return;
 189         }
 190
 191         if (sta->state != STATE1) {
 192                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 193                            " moved to State 1 with " MACSTR,
 194                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 195                 sta->state = STATE1;
 196         }
 197 }
 198
 199
 200 static void rx_mgmt_assoc_req(struct wlantest *wt, const u8 *data, size_t len)
 201 {
 202         const struct ieee80211_mgmt *mgmt;
 203         struct wlantest_bss *bss;
 204         struct wlantest_sta *sta;
 205         struct ieee802_11_elems elems;
 206
 207         mgmt = (const struct ieee80211_mgmt *) data;
 208         bss = bss_get(wt, mgmt->bssid);
 209         if (bss == NULL)
 210                 return;
 211         sta = sta_get(bss, mgmt->sa);
 212         if (sta == NULL)
 213                 return;
 214
 215         if (len < 24 + 4) {
 216                 wpa_printf(MSG_INFO, "Too short Association Request frame "
 217                            "from " MACSTR, MAC2STR(mgmt->sa));
 218                 return;
 219         }
 220
 221         wpa_printf(MSG_DEBUG, "ASSOCREQ " MACSTR " -> " MACSTR
 222                    " (capab=0x%x listen_int=%u)",
 223                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 224                    le_to_host16(mgmt->u.assoc_req.capab_info),
 225                    le_to_host16(mgmt->u.assoc_req.listen_interval));
 226
 227         if (ieee802_11_parse_elems(mgmt->u.assoc_req.variable,
 228                                    len - (mgmt->u.assoc_req.variable - data),
 229                                    &elems, 0) == ParseFailed) {
 230                 wpa_printf(MSG_INFO, "Invalid IEs in Association Request "
 231                            "frame from " MACSTR, MAC2STR(mgmt->sa));
 232                 return;
 233         }
 234
 235         sta_update_assoc(sta, &elems);
 236 }
 237
 238
 239 static void rx_mgmt_assoc_resp(struct wlantest *wt, const u8 *data, size_t len)
 240 {
 241         const struct ieee80211_mgmt *mgmt;
 242         struct wlantest_bss *bss;
 243         struct wlantest_sta *sta;
 244         u16 capab, status, aid;
 245
 246         mgmt = (const struct ieee80211_mgmt *) data;
 247         bss = bss_get(wt, mgmt->bssid);
 248         if (bss == NULL)
 249                 return;
 250         sta = sta_get(bss, mgmt->da);
 251         if (sta == NULL)
 252                 return;
 253
 254         if (len < 24 + 6) {
 255                 wpa_printf(MSG_INFO, "Too short Association Response frame "
 256                            "from " MACSTR, MAC2STR(mgmt->sa));
 257                 return;
 258         }
 259
 260         capab = le_to_host16(mgmt->u.assoc_resp.capab_info);
 261         status = le_to_host16(mgmt->u.assoc_resp.status_code);
 262         aid = le_to_host16(mgmt->u.assoc_resp.aid);
 263
 264         wpa_printf(MSG_DEBUG, "ASSOCRESP " MACSTR " -> " MACSTR
 265                    " (capab=0x%x status=%u aid=%u)",
 266                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), capab, status,
 267                    aid & 0x3fff);
 268
 269         if (status)
 270                 return;
 271
 272         if ((aid & 0xc000) != 0xc000) {
 273                 wpa_printf(MSG_DEBUG, "Two MSBs of the AID were not set to 1 "
 274                            "in Association Response from " MACSTR,
 275                            MAC2STR(mgmt->sa));
 276         }
 277         sta->aid = aid & 0xc000;
 278
 279         if (sta->state < STATE2) {
 280                 wpa_printf(MSG_DEBUG, "STA " MACSTR " was not in State 2 when "
 281                            "getting associated", MAC2STR(sta->addr));
 282         }
 283
 284         if (sta->state < STATE3) {
 285                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 286                            " moved to State 3 with " MACSTR,
 287                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 288                 sta->state = STATE3;
 289         }
 290 }
 291
 292
 293 static void rx_mgmt_reassoc_req(struct wlantest *wt, const u8 *data,
 294                                 size_t len)
 295 {
 296         const struct ieee80211_mgmt *mgmt;
 297         struct wlantest_bss *bss;
 298         struct wlantest_sta *sta;
 299         struct ieee802_11_elems elems;
 300
 301         mgmt = (const struct ieee80211_mgmt *) data;
 302         bss = bss_get(wt, mgmt->bssid);
 303         if (bss == NULL)
 304                 return;
 305         sta = sta_get(bss, mgmt->sa);
 306         if (sta == NULL)
 307                 return;
 308
 309         if (len < 24 + 4 + ETH_ALEN) {
 310                 wpa_printf(MSG_INFO, "Too short Reassociation Request frame "
 311                            "from " MACSTR, MAC2STR(mgmt->sa));
 312                 return;
 313         }
 314
 315         wpa_printf(MSG_DEBUG, "REASSOCREQ " MACSTR " -> " MACSTR
 316                    " (capab=0x%x listen_int=%u current_ap=" MACSTR ")",
 317                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 318                    le_to_host16(mgmt->u.reassoc_req.capab_info),
 319                    le_to_host16(mgmt->u.reassoc_req.listen_interval),
 320                    MAC2STR(mgmt->u.reassoc_req.current_ap));
 321
 322         if (ieee802_11_parse_elems(mgmt->u.reassoc_req.variable,
 323                                    len - (mgmt->u.reassoc_req.variable - data),
 324                                    &elems, 0) == ParseFailed) {
 325                 wpa_printf(MSG_INFO, "Invalid IEs in Reassociation Request "
 326                            "frame from " MACSTR, MAC2STR(mgmt->sa));
 327                 return;
 328         }
 329
 330         sta_update_assoc(sta, &elems);
 331 }
 332
 333
 334 static void rx_mgmt_reassoc_resp(struct wlantest *wt, const u8 *data,
 335                                  size_t len)
 336 {
 337         const struct ieee80211_mgmt *mgmt;
 338         struct wlantest_bss *bss;
 339         struct wlantest_sta *sta;
 340         u16 capab, status, aid;
 341
 342         mgmt = (const struct ieee80211_mgmt *) data;
 343         bss = bss_get(wt, mgmt->bssid);
 344         if (bss == NULL)
 345                 return;
 346         sta = sta_get(bss, mgmt->da);
 347         if (sta == NULL)
 348                 return;
 349
 350         if (len < 24 + 6) {
 351                 wpa_printf(MSG_INFO, "Too short Reassociation Response frame "
 352                            "from " MACSTR, MAC2STR(mgmt->sa));
 353                 return;
 354         }
 355
 356         capab = le_to_host16(mgmt->u.reassoc_resp.capab_info);
 357         status = le_to_host16(mgmt->u.reassoc_resp.status_code);
 358         aid = le_to_host16(mgmt->u.reassoc_resp.aid);
 359
 360         wpa_printf(MSG_DEBUG, "REASSOCRESP " MACSTR " -> " MACSTR
 361                    " (capab=0x%x status=%u aid=%u)",
 362                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), capab, status,
 363                    aid & 0x3fff);
 364
 365         if (status)
 366                 return;
 367
 368         if ((aid & 0xc000) != 0xc000) {
 369                 wpa_printf(MSG_DEBUG, "Two MSBs of the AID were not set to 1 "
 370                            "in Reassociation Response from " MACSTR,
 371                            MAC2STR(mgmt->sa));
 372         }
 373         sta->aid = aid & 0xc000;
 374
 375         if (sta->state < STATE2) {
 376                 wpa_printf(MSG_DEBUG, "STA " MACSTR " was not in State 2 when "
 377                            "getting associated", MAC2STR(sta->addr));
 378         }
 379
 380         if (sta->state < STATE3) {
 381                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 382                            " moved to State 3 with " MACSTR,
 383                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 384                 sta->state = STATE3;
 385         }
 386 }
 387
 388
 389 static void rx_mgmt_disassoc(struct wlantest *wt, const u8 *data, size_t len,
 390                              int valid)
 391 {
 392         const struct ieee80211_mgmt *mgmt;
 393         struct wlantest_bss *bss;
 394         struct wlantest_sta *sta;
 395
 396         mgmt = (const struct ieee80211_mgmt *) data;
 397         bss = bss_get(wt, mgmt->bssid);
 398         if (bss == NULL)
 399                 return;
 400         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 401                 sta = sta_get(bss, mgmt->da);
 402         else
 403                 sta = sta_get(bss, mgmt->sa);
 404         if (sta == NULL)
 405                 return;
 406
 407         if (len < 24 + 2) {
 408                 wpa_printf(MSG_INFO, "Too short Disassociation frame from "
 409                            MACSTR, MAC2STR(mgmt->sa));
 410                 return;
 411         }
 412
 413         wpa_printf(MSG_DEBUG, "DISASSOC " MACSTR " -> " MACSTR
 414                    " (reason=%u)",
 415                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 416                    le_to_host16(mgmt->u.disassoc.reason_code));
 417         wpa_hexdump(MSG_MSGDUMP, "DISASSOC payload", data + 24, len - 24);
 418
 419         if (!valid) {
 420                 wpa_printf(MSG_INFO, "Do not change STA " MACSTR " State "
 421                            "since Disassociation frame was not protected "
 422                            "correctly", MAC2STR(sta->addr));
 423                 return;
 424         }
 425
 426         if (sta->state < STATE2) {
 427                 wpa_printf(MSG_DEBUG, "STA " MACSTR " was not in State 2 or 3 "
 428                            "when getting disassociated", MAC2STR(sta->addr));
 429         }
 430
 431         if (sta->state > STATE2) {
 432                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 433                            " moved to State 2 with " MACSTR,
 434                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 435                 sta->state = STATE2;
 436         }
 437 }
 438
 439
 440 static void rx_mgmt_action_sa_query(struct wlantest *wt,
 441                                     struct wlantest_sta *sta,
 442                                     const struct ieee80211_mgmt *mgmt,
 443                                     size_t len, int valid)
 444 {
 445         const u8 *rx_id;
 446         u8 *id;
 447
 448         if (len < 24 + 2 + WLAN_SA_QUERY_TR_ID_LEN) {
 449                 wpa_printf(MSG_INFO, "Too short SA Query frame from " MACSTR,
 450                            MAC2STR(mgmt->sa));
 451                 return;
 452         }
 453
 454         if (len > 24 + 2 + WLAN_SA_QUERY_TR_ID_LEN) {
 455                 size_t elen = len - (24 + 2 + WLAN_SA_QUERY_TR_ID_LEN);
 456                 wpa_printf(MSG_INFO, "Unexpected %u octets of extra data at "
 457                            "the end of SA Query frame from " MACSTR,
 458                            (unsigned) elen, MAC2STR(mgmt->sa));
 459                 wpa_hexdump(MSG_INFO, "SA Query extra data",
 460                             ((const u8 *) mgmt) + len - elen, elen);
 461         }
 462
 463         switch (mgmt->u.action.u.sa_query_req.action) {
 464         case WLAN_SA_QUERY_REQUEST:
 465                 rx_id = (const u8 *) mgmt->u.action.u.sa_query_req.trans_id;
 466                 if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 467                         id = sta->ap_sa_query_tr;
 468                 else
 469                         id = sta->sta_sa_query_tr;
 470                 wpa_printf(MSG_INFO, "SA Query Request " MACSTR " -> " MACSTR
 471                            " (trans_id=%02x%02x)%s",
 472                            MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 473                            rx_id[0], rx_id[1],
 474                            valid ? "" : " (invalid protection)");
 475                 os_memcpy(id, mgmt->u.action.u.sa_query_req.trans_id, 2);
 476                 break;
 477         case WLAN_SA_QUERY_RESPONSE:
 478                 rx_id = (const u8 *) mgmt->u.action.u.sa_query_resp.trans_id;
 479                 if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 480                         id = sta->sta_sa_query_tr;
 481                 else
 482                         id = sta->ap_sa_query_tr;
 483                 wpa_printf(MSG_INFO, "SA Query Response " MACSTR " -> " MACSTR
 484                            " (trans_id=%02x%02x; %s)%s",
 485                            MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 486                            rx_id[0], rx_id[1],
 487                            os_memcmp(rx_id, id, 2) == 0 ?
 488                            "match" : "mismatch",
 489                            valid ? "" : " (invalid protection)");
 490                 break;
 491         default:
 492                 wpa_printf(MSG_INFO, "Unexpected SA Query action value %u "
 493                            "from " MACSTR,
 494                            mgmt->u.action.u.sa_query_req.action,
 495                            MAC2STR(mgmt->sa));
 496         }
 497 }
 498
 499
 500 static void rx_mgmt_action(struct wlantest *wt, const u8 *data, size_t len,
 501                            int valid)
 502 {
 503         const struct ieee80211_mgmt *mgmt;
 504         struct wlantest_bss *bss;
 505         struct wlantest_sta *sta;
 506
 507         mgmt = (const struct ieee80211_mgmt *) data;
 508         if (mgmt->da[0] & 0x01)
 509                 return; /* Ignore group addressed Action frames for now */
 510         bss = bss_get(wt, mgmt->bssid);
 511         if (bss == NULL)
 512                 return;
 513         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 514                 sta = sta_get(bss, mgmt->da);
 515         else
 516                 sta = sta_get(bss, mgmt->sa);
 517         if (sta == NULL)
 518                 return;
 519
 520         if (len < 24 + 1) {
 521                 wpa_printf(MSG_INFO, "Too short Action frame from "
 522                            MACSTR, MAC2STR(mgmt->sa));
 523                 return;
 524         }
 525
 526         wpa_printf(MSG_DEBUG, "ACTION " MACSTR " -> " MACSTR
 527                    " (category=%u) (valid=%d)",
 528                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 529                    mgmt->u.action.category, valid);
 530         wpa_hexdump(MSG_MSGDUMP, "ACTION payload", data + 24, len - 24);
 531
 532         if (mgmt->u.action.category != WLAN_ACTION_PUBLIC &&
 533             sta->state < STATE3) {
 534                 wpa_printf(MSG_INFO, "Action frame sent when STA is not in "
 535                            "State 3 (SA=" MACSTR " DATA=" MACSTR ")",
 536                            MAC2STR(mgmt->sa), MAC2STR(mgmt->da));
 537         }
 538
 539         switch (mgmt->u.action.category) {
 540         case WLAN_ACTION_SA_QUERY:
 541                 rx_mgmt_action_sa_query(wt, sta, mgmt, len, valid);
 542                 break;
 543         }
 544 }
 545
 546
 547 static int check_mmie_mic(const u8 *igtk, const u8 *data, size_t len)
 548 {
 549         u8 *buf;
 550         u8 mic[16];
 551         u16 fc;
 552         const struct ieee80211_hdr *hdr;
 553
 554         buf = os_malloc(len + 20 - 24);
 555         if (buf == NULL)
 556                 return -1;
 557
 558         /* BIP AAD: FC(masked) A1 A2 A3 */
 559         hdr = (const struct ieee80211_hdr *) data;
 560         fc = le_to_host16(hdr->frame_control);
 561         fc &= ~(WLAN_FC_RETRY | WLAN_FC_PWRMGT | WLAN_FC_MOREDATA);
 562         WPA_PUT_LE16(buf, fc);
 563         os_memcpy(buf + 2, hdr->addr1, 3 * ETH_ALEN);
 564
 565         /* Frame body with MMIE MIC masked to zero */
 566         os_memcpy(buf + 20, data + 24, len - 24 - 8);
 567         os_memset(buf + 20 + len - 24 - 8, 0, 8);
 568
 569         wpa_hexdump(MSG_MSGDUMP, "BIP: AAD|Body(masked)", buf, len + 20 - 24);
 570         /* MIC = L(AES-128-CMAC(AAD || Frame Body(masked)), 0, 64) */
 571         if (omac1_aes_128(igtk, buf, len + 20 - 24, mic) < 0) {
 572                 os_free(buf);
 573                 return -1;
 574         }
 575
 576         os_free(buf);
 577
 578         if (os_memcmp(data + len - 8, mic, 8) != 0)
 579                 return -1;
 580
 581         return 0;
 582 }
 583
 584
 585 static int check_bip(struct wlantest *wt, const u8 *data, size_t len)
 586 {
 587         const struct ieee80211_mgmt *mgmt;
 588         u16 fc, stype;
 589         const u8 *mmie;
 590         int keyid;
 591         struct wlantest_bss *bss;
 592
 593         mgmt = (const struct ieee80211_mgmt *) data;
 594         fc = le_to_host16(mgmt->frame_control);
 595         stype = WLAN_FC_GET_STYPE(fc);
 596
 597         if (stype == WLAN_FC_STYPE_ACTION) {
 598                 if (len < 24 + 1)
 599                         return 0;
 600                 if (mgmt->u.action.category == WLAN_ACTION_PUBLIC)
 601                         return 0; /* Not a robust management frame */
 602         }
 603
 604         bss = bss_get(wt, mgmt->bssid);
 605         if (bss == NULL)
 606                 return 0; /* No key known yet */
 607
 608         if (len < 24 + 18 || data[len - 18] != WLAN_EID_MMIE ||
 609             data[len - 17] != 16) {
 610                 /* No MMIE */
 611                 if (bss->rsn_capab & WPA_CAPABILITY_MFPC) {
 612                         wpa_printf(MSG_INFO, "Robust group-addressed "
 613                                    "management frame sent without BIP by "
 614                                    MACSTR, MAC2STR(mgmt->sa));
 615                         return -1;
 616                 }
 617                 return 0;
 618         }
 619
 620         mmie = data + len - 16;
 621         keyid = WPA_GET_LE16(mmie);
 622         if (keyid < 4 || keyid > 5) {
 623                 wpa_printf(MSG_INFO, "Unexpected MMIE KeyID %u from " MACSTR,
 624                            keyid, MAC2STR(mgmt->sa));
 625                 return 0;
 626         }
 627         wpa_printf(MSG_DEBUG, "MMIE KeyID %u", keyid);
 628         wpa_hexdump(MSG_MSGDUMP, "MMIE IPN", mmie + 2, 6);
 629         wpa_hexdump(MSG_MSGDUMP, "MMIE MIC", mmie + 8, 8);
 630
 631         if (!bss->igtk_set[keyid]) {
 632                 wpa_printf(MSG_DEBUG, "No IGTK known to validate BIP frame");
 633                 return 0;
 634         }
 635
 636         if (os_memcmp(mmie + 2, bss->ipn[keyid], 6) <= 0) {
 637                 wpa_printf(MSG_INFO, "BIP replay detected: SA=" MACSTR,
 638                            MAC2STR(mgmt->sa));
 639                 wpa_hexdump(MSG_INFO, "RX IPN", mmie + 2, 6);
 640                 wpa_hexdump(MSG_INFO, "Last RX IPN", bss->ipn[keyid], 6);
 641         }
 642
 643         if (check_mmie_mic(bss->igtk[keyid], data, len) < 0) {
 644                 wpa_printf(MSG_INFO, "Invalid MMIE MIC in a frame from "
 645                            MACSTR, MAC2STR(mgmt->sa));
 646                 return -1;
 647         }
 648
 649         wpa_printf(MSG_DEBUG, "Valid MMIE MIC");
 650         os_memcpy(bss->ipn[keyid], mmie + 2, 6);
 651
 652         return 0;
 653 }
 654
 655
 656 static u8 * mgmt_ccmp_decrypt(struct wlantest *wt, const u8 *data, size_t len,
 657                               size_t *dlen)
 658 {
 659         struct wlantest_bss *bss;
 660         struct wlantest_sta *sta;
 661         const struct ieee80211_hdr *hdr;
 662         int keyid;
 663         u8 *decrypted, *frame = NULL;
 664         u8 pn[6], *rsc;
 665
 666         hdr = (const struct ieee80211_hdr *) data;
 667         bss = bss_get(wt, hdr->addr3);
 668         if (bss == NULL)
 669                 return NULL;
 670         if (os_memcmp(hdr->addr1, hdr->addr3, ETH_ALEN) == 0)
 671                 sta = sta_get(bss, hdr->addr2);
 672         else
 673                 sta = sta_get(bss, hdr->addr1);
 674         if (sta == NULL || !sta->ptk_set) {
 675                 wpa_printf(MSG_MSGDUMP, "No PTK known to decrypt the frame");
 676                 return NULL;
 677         }
 678
 679         if (len < 24 + 4)
 680                 return NULL;
 681
 682         if (!(data[24 + 3] & 0x20)) {
 683                 wpa_printf(MSG_INFO, "Expected CCMP frame from " MACSTR
 684                            " did not have ExtIV bit set to 1",
 685                            MAC2STR(hdr->addr2));
 686                 return NULL;
 687         }
 688
 689         keyid = data[24 + 3] >> 6;
 690         if (keyid != 0) {
 691                 wpa_printf(MSG_INFO, "Unexpected non-zero KeyID %d in "
 692                            "individually addressed Management frame from "
 693                            MACSTR, keyid, MAC2STR(hdr->addr2));
 694         }
 695
 696         if (os_memcmp(hdr->addr1, hdr->addr3, ETH_ALEN) == 0)
 697                 rsc = sta->rsc_tods[16];
 698         else
 699                 rsc = sta->rsc_fromds[16];
 700
 701         ccmp_get_pn(pn, data + 24);
 702         if (os_memcmp(pn, rsc, 6) <= 0) {
 703                 wpa_printf(MSG_INFO, "CCMP/TKIP replay detected: SA=" MACSTR,
 704                            MAC2STR(hdr->addr2));
 705                 wpa_hexdump(MSG_INFO, "RX PN", pn, 6);
 706                 wpa_hexdump(MSG_INFO, "RSC", rsc, 6);
 707         }
 708
 709         decrypted = ccmp_decrypt(sta->ptk.tk1, hdr, data + 24, len - 24, dlen);
 710         if (decrypted) {
 711                 os_memcpy(rsc, pn, 6);
 712                 frame = os_malloc(24 + *dlen);
 713                 if (frame) {
 714                         os_memcpy(frame, data, 24);
 715                         os_memcpy(frame + 24, decrypted, *dlen);
 716                         *dlen += 24;
 717                 }
 718         }
 719
 720         os_free(decrypted);
 721
 722         return frame;
 723 }
 724
 725
 726 static int check_mgmt_ccmp(struct wlantest *wt, const u8 *data, size_t len)
 727 {
 728         const struct ieee80211_mgmt *mgmt;
 729         u16 fc;
 730         struct wlantest_bss *bss;
 731         struct wlantest_sta *sta;
 732
 733         mgmt = (const struct ieee80211_mgmt *) data;
 734         fc = le_to_host16(mgmt->frame_control);
 735
 736         if (WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) {
 737                 if (len > 24 &&
 738                     mgmt->u.action.category == WLAN_ACTION_PUBLIC)
 739                         return 0; /* Not a robust management frame */
 740         }
 741
 742         bss = bss_get(wt, mgmt->bssid);
 743         if (bss == NULL)
 744                 return 0;
 745         if (os_memcmp(mgmt->da, mgmt->bssid, ETH_ALEN) == 0)
 746                 sta = sta_get(bss, mgmt->sa);
 747         else
 748                 sta = sta_get(bss, mgmt->da);
 749         if (sta == NULL)
 750                 return 0;
 751
 752         if (sta->rsn_capab & WPA_CAPABILITY_MFPC) {
 753                 wpa_printf(MSG_INFO, "Robust individually-addressed "
 754                            "management frame sent without CCMP by "
 755                            MACSTR, MAC2STR(mgmt->sa));
 756                 return -1;
 757         }
 758
 759         return 0;
 760 }
 761
 762
 763 void rx_mgmt(struct wlantest *wt, const u8 *data, size_t len)
 764 {
 765         const struct ieee80211_hdr *hdr;
 766         u16 fc, stype;
 767         int valid = 1;
 768         u8 *decrypted = NULL;
 769         size_t dlen;
 770
 771         if (len < 24)
 772                 return;
 773
 774         hdr = (const struct ieee80211_hdr *) data;
 775         fc = le_to_host16(hdr->frame_control);
 776         wt->rx_mgmt++;
 777         stype = WLAN_FC_GET_STYPE(fc);
 778
 779         if ((hdr->addr1[0] & 0x01) &&
 780             (stype == WLAN_FC_STYPE_DEAUTH ||
 781              stype == WLAN_FC_STYPE_DISASSOC ||
 782              stype == WLAN_FC_STYPE_ACTION)) {
 783                 if (check_bip(wt, data, len) < 0)
 784                         valid = 0;
 785         }
 786
 787         wpa_printf((stype == WLAN_FC_STYPE_BEACON ||
 788                     stype == WLAN_FC_STYPE_PROBE_RESP ||
 789                     stype == WLAN_FC_STYPE_PROBE_REQ) ?
 790                    MSG_EXCESSIVE : MSG_MSGDUMP,
 791                    "MGMT %s%s%s DA=" MACSTR " SA=" MACSTR " BSSID=" MACSTR,
 792                    mgmt_stype(stype),
 793                    fc & WLAN_FC_PWRMGT ? " PwrMgt" : "",
 794                    fc & WLAN_FC_ISWEP ? " Prot" : "",
 795                    MAC2STR(hdr->addr1), MAC2STR(hdr->addr2),
 796                    MAC2STR(hdr->addr3));
 797
 798         if ((fc & WLAN_FC_ISWEP) &&
 799             !(hdr->addr1[0] & 0x01) &&
 800             (stype == WLAN_FC_STYPE_DEAUTH ||
 801              stype == WLAN_FC_STYPE_DISASSOC ||
 802              stype == WLAN_FC_STYPE_ACTION)) {
 803                 decrypted = mgmt_ccmp_decrypt(wt, data, len, &dlen);
 804                 if (decrypted) {
 805                         write_pcap_decrypted(wt, decrypted, dlen, NULL, 0);
 806                         data = decrypted;
 807                         len = dlen;
 808                 } else
 809                         valid = 0;
 810         }
 811
 812         if (!(fc & WLAN_FC_ISWEP) &&
 813             !(hdr->addr1[0] & 0x01) &&
 814             (stype == WLAN_FC_STYPE_DEAUTH ||
 815              stype == WLAN_FC_STYPE_DISASSOC ||
 816              stype == WLAN_FC_STYPE_ACTION)) {
 817                 if (check_mgmt_ccmp(wt, data, len) < 0)
 818                         valid = 0;
 819         }
 820
 821         switch (stype) {
 822         case WLAN_FC_STYPE_BEACON:
 823                 rx_mgmt_beacon(wt, data, len);
 824                 break;
 825         case WLAN_FC_STYPE_PROBE_RESP:
 826                 rx_mgmt_probe_resp(wt, data, len);
 827                 break;
 828         case WLAN_FC_STYPE_AUTH:
 829                 rx_mgmt_auth(wt, data, len);
 830                 break;
 831         case WLAN_FC_STYPE_DEAUTH:
 832                 rx_mgmt_deauth(wt, data, len, valid);
 833                 break;
 834         case WLAN_FC_STYPE_ASSOC_REQ:
 835                 rx_mgmt_assoc_req(wt, data, len);
 836                 break;
 837         case WLAN_FC_STYPE_ASSOC_RESP:
 838                 rx_mgmt_assoc_resp(wt, data, len);
 839                 break;
 840         case WLAN_FC_STYPE_REASSOC_REQ:
 841                 rx_mgmt_reassoc_req(wt, data, len);
 842                 break;
 843         case WLAN_FC_STYPE_REASSOC_RESP:
 844                 rx_mgmt_reassoc_resp(wt, data, len);
 845                 break;
 846         case WLAN_FC_STYPE_DISASSOC:
 847                 rx_mgmt_disassoc(wt, data, len, valid);
 848                 break;
 849         case WLAN_FC_STYPE_ACTION:
 850                 rx_mgmt_action(wt, data, len, valid);
 851                 break;
 852         }
 853
 854         os_free(decrypted);
 855 }