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         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 153                 sta->counters[WLANTEST_STA_COUNTER_AUTH_RX]++;
 154         else
 155                 sta->counters[WLANTEST_STA_COUNTER_AUTH_TX]++;
 156 }
 157
 158
 159 static void rx_mgmt_deauth(struct wlantest *wt, const u8 *data, size_t len,
 160                            int valid)
 161 {
 162         const struct ieee80211_mgmt *mgmt;
 163         struct wlantest_bss *bss;
 164         struct wlantest_sta *sta;
 165
 166         mgmt = (const struct ieee80211_mgmt *) data;
 167         bss = bss_get(wt, mgmt->bssid);
 168         if (bss == NULL)
 169                 return;
 170         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 171                 sta = sta_get(bss, mgmt->da);
 172         else
 173                 sta = sta_get(bss, mgmt->sa);
 174         if (sta == NULL)
 175                 return;
 176
 177         if (len < 24 + 2) {
 178                 wpa_printf(MSG_INFO, "Too short Deauthentication frame from "
 179                            MACSTR, MAC2STR(mgmt->sa));
 180                 return;
 181         }
 182
 183         wpa_printf(MSG_DEBUG, "DEAUTH " MACSTR " -> " MACSTR
 184                    " (reason=%u)",
 185                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 186                    le_to_host16(mgmt->u.deauth.reason_code));
 187         wpa_hexdump(MSG_MSGDUMP, "DEAUTH payload", data + 24, len - 24);
 188
 189         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 190                 sta->counters[valid ? WLANTEST_STA_COUNTER_VALID_DEAUTH_RX :
 191                               WLANTEST_STA_COUNTER_INVALID_DEAUTH_RX]++;
 192         else
 193                 sta->counters[valid ? WLANTEST_STA_COUNTER_VALID_DEAUTH_TX :
 194                               WLANTEST_STA_COUNTER_INVALID_DEAUTH_TX]++;
 195
 196         if (!valid) {
 197                 wpa_printf(MSG_INFO, "Do not change STA " MACSTR " State "
 198                            "since Disassociation frame was not protected "
 199                            "correctly", MAC2STR(sta->addr));
 200                 return;
 201         }
 202
 203         if (sta->state != STATE1) {
 204                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 205                            " moved to State 1 with " MACSTR,
 206                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 207                 sta->state = STATE1;
 208         }
 209 }
 210
 211
 212 static void rx_mgmt_assoc_req(struct wlantest *wt, const u8 *data, size_t len)
 213 {
 214         const struct ieee80211_mgmt *mgmt;
 215         struct wlantest_bss *bss;
 216         struct wlantest_sta *sta;
 217         struct ieee802_11_elems elems;
 218
 219         mgmt = (const struct ieee80211_mgmt *) data;
 220         bss = bss_get(wt, mgmt->bssid);
 221         if (bss == NULL)
 222                 return;
 223         sta = sta_get(bss, mgmt->sa);
 224         if (sta == NULL)
 225                 return;
 226
 227         if (len < 24 + 4) {
 228                 wpa_printf(MSG_INFO, "Too short Association Request frame "
 229                            "from " MACSTR, MAC2STR(mgmt->sa));
 230                 return;
 231         }
 232
 233         wpa_printf(MSG_DEBUG, "ASSOCREQ " MACSTR " -> " MACSTR
 234                    " (capab=0x%x listen_int=%u)",
 235                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 236                    le_to_host16(mgmt->u.assoc_req.capab_info),
 237                    le_to_host16(mgmt->u.assoc_req.listen_interval));
 238
 239         sta->counters[WLANTEST_STA_COUNTER_ASSOCREQ_TX]++;
 240
 241         if (ieee802_11_parse_elems(mgmt->u.assoc_req.variable,
 242                                    len - (mgmt->u.assoc_req.variable - data),
 243                                    &elems, 0) == ParseFailed) {
 244                 wpa_printf(MSG_INFO, "Invalid IEs in Association Request "
 245                            "frame from " MACSTR, MAC2STR(mgmt->sa));
 246                 return;
 247         }
 248
 249         sta->assocreq_capab_info = le_to_host16(mgmt->u.assoc_req.capab_info);
 250         sta->assocreq_listen_int =
 251                 le_to_host16(mgmt->u.assoc_req.listen_interval);
 252         os_free(sta->assocreq_ies);
 253         sta->assocreq_ies_len = len - (mgmt->u.assoc_req.variable - data);
 254         sta->assocreq_ies = os_malloc(sta->assocreq_ies_len);
 255         if (sta->assocreq_ies)
 256                 os_memcpy(sta->assocreq_ies, mgmt->u.assoc_req.variable,
 257                           sta->assocreq_ies_len);
 258
 259         sta_update_assoc(sta, &elems);
 260 }
 261
 262
 263 static void rx_mgmt_assoc_resp(struct wlantest *wt, const u8 *data, size_t len)
 264 {
 265         const struct ieee80211_mgmt *mgmt;
 266         struct wlantest_bss *bss;
 267         struct wlantest_sta *sta;
 268         u16 capab, status, aid;
 269
 270         mgmt = (const struct ieee80211_mgmt *) data;
 271         bss = bss_get(wt, mgmt->bssid);
 272         if (bss == NULL)
 273                 return;
 274         sta = sta_get(bss, mgmt->da);
 275         if (sta == NULL)
 276                 return;
 277
 278         if (len < 24 + 6) {
 279                 wpa_printf(MSG_INFO, "Too short Association Response frame "
 280                            "from " MACSTR, MAC2STR(mgmt->sa));
 281                 return;
 282         }
 283
 284         capab = le_to_host16(mgmt->u.assoc_resp.capab_info);
 285         status = le_to_host16(mgmt->u.assoc_resp.status_code);
 286         aid = le_to_host16(mgmt->u.assoc_resp.aid);
 287
 288         wpa_printf(MSG_DEBUG, "ASSOCRESP " MACSTR " -> " MACSTR
 289                    " (capab=0x%x status=%u aid=%u)",
 290                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), capab, status,
 291                    aid & 0x3fff);
 292
 293         if (status == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY) {
 294                 struct ieee802_11_elems elems;
 295                 const u8 *ies = mgmt->u.assoc_resp.variable;
 296                 size_t ies_len = len - (mgmt->u.assoc_resp.variable - data);
 297                 if (ieee802_11_parse_elems(ies, ies_len, &elems, 0) ==
 298                     ParseFailed) {
 299                         wpa_printf(MSG_INFO, "Failed to parse IEs in "
 300                                    "AssocResp from " MACSTR,
 301                                    MAC2STR(mgmt->sa));
 302                 } else if (elems.timeout_int == 0 ||
 303                            elems.timeout_int_len != 5) {
 304                         wpa_printf(MSG_INFO, "No valid Timeout Interval IE in "
 305                                    "AssocResp (status=30) from " MACSTR,
 306                                    MAC2STR(mgmt->sa));
 307                 } else {
 308                         sta->counters[
 309                                 WLANTEST_STA_COUNTER_ASSOCRESP_COMEBACK]++;
 310                 }
 311         }
 312
 313         if (status)
 314                 return;
 315
 316         if ((aid & 0xc000) != 0xc000) {
 317                 wpa_printf(MSG_DEBUG, "Two MSBs of the AID were not set to 1 "
 318                            "in Association Response from " MACSTR,
 319                            MAC2STR(mgmt->sa));
 320         }
 321         sta->aid = aid & 0xc000;
 322
 323         if (sta->state < STATE2) {
 324                 wpa_printf(MSG_DEBUG, "STA " MACSTR " was not in State 2 when "
 325                            "getting associated", MAC2STR(sta->addr));
 326         }
 327
 328         if (sta->state < STATE3) {
 329                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 330                            " moved to State 3 with " MACSTR,
 331                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 332                 sta->state = STATE3;
 333         }
 334 }
 335
 336
 337 static void rx_mgmt_reassoc_req(struct wlantest *wt, const u8 *data,
 338                                 size_t len)
 339 {
 340         const struct ieee80211_mgmt *mgmt;
 341         struct wlantest_bss *bss;
 342         struct wlantest_sta *sta;
 343         struct ieee802_11_elems elems;
 344
 345         mgmt = (const struct ieee80211_mgmt *) data;
 346         bss = bss_get(wt, mgmt->bssid);
 347         if (bss == NULL)
 348                 return;
 349         sta = sta_get(bss, mgmt->sa);
 350         if (sta == NULL)
 351                 return;
 352
 353         if (len < 24 + 4 + ETH_ALEN) {
 354                 wpa_printf(MSG_INFO, "Too short Reassociation Request frame "
 355                            "from " MACSTR, MAC2STR(mgmt->sa));
 356                 return;
 357         }
 358
 359         wpa_printf(MSG_DEBUG, "REASSOCREQ " MACSTR " -> " MACSTR
 360                    " (capab=0x%x listen_int=%u current_ap=" MACSTR ")",
 361                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 362                    le_to_host16(mgmt->u.reassoc_req.capab_info),
 363                    le_to_host16(mgmt->u.reassoc_req.listen_interval),
 364                    MAC2STR(mgmt->u.reassoc_req.current_ap));
 365
 366         sta->counters[WLANTEST_STA_COUNTER_REASSOCREQ_TX]++;
 367
 368         if (ieee802_11_parse_elems(mgmt->u.reassoc_req.variable,
 369                                    len - (mgmt->u.reassoc_req.variable - data),
 370                                    &elems, 0) == ParseFailed) {
 371                 wpa_printf(MSG_INFO, "Invalid IEs in Reassociation Request "
 372                            "frame from " MACSTR, MAC2STR(mgmt->sa));
 373                 return;
 374         }
 375
 376         sta->assocreq_capab_info =
 377                 le_to_host16(mgmt->u.reassoc_req.capab_info);
 378         sta->assocreq_listen_int =
 379                 le_to_host16(mgmt->u.reassoc_req.listen_interval);
 380         os_free(sta->assocreq_ies);
 381         sta->assocreq_ies_len = len - (mgmt->u.reassoc_req.variable - data);
 382         sta->assocreq_ies = os_malloc(sta->assocreq_ies_len);
 383         if (sta->assocreq_ies)
 384                 os_memcpy(sta->assocreq_ies, mgmt->u.reassoc_req.variable,
 385                           sta->assocreq_ies_len);
 386
 387         sta_update_assoc(sta, &elems);
 388 }
 389
 390
 391 static void rx_mgmt_reassoc_resp(struct wlantest *wt, const u8 *data,
 392                                  size_t len)
 393 {
 394         const struct ieee80211_mgmt *mgmt;
 395         struct wlantest_bss *bss;
 396         struct wlantest_sta *sta;
 397         u16 capab, status, aid;
 398
 399         mgmt = (const struct ieee80211_mgmt *) data;
 400         bss = bss_get(wt, mgmt->bssid);
 401         if (bss == NULL)
 402                 return;
 403         sta = sta_get(bss, mgmt->da);
 404         if (sta == NULL)
 405                 return;
 406
 407         if (len < 24 + 6) {
 408                 wpa_printf(MSG_INFO, "Too short Reassociation Response frame "
 409                            "from " MACSTR, MAC2STR(mgmt->sa));
 410                 return;
 411         }
 412
 413         capab = le_to_host16(mgmt->u.reassoc_resp.capab_info);
 414         status = le_to_host16(mgmt->u.reassoc_resp.status_code);
 415         aid = le_to_host16(mgmt->u.reassoc_resp.aid);
 416
 417         wpa_printf(MSG_DEBUG, "REASSOCRESP " MACSTR " -> " MACSTR
 418                    " (capab=0x%x status=%u aid=%u)",
 419                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), capab, status,
 420                    aid & 0x3fff);
 421
 422         if (status == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY) {
 423                 struct ieee802_11_elems elems;
 424                 const u8 *ies = mgmt->u.reassoc_resp.variable;
 425                 size_t ies_len = len - (mgmt->u.reassoc_resp.variable - data);
 426                 if (ieee802_11_parse_elems(ies, ies_len, &elems, 0) ==
 427                     ParseFailed) {
 428                         wpa_printf(MSG_INFO, "Failed to parse IEs in "
 429                                    "ReassocResp from " MACSTR,
 430                                    MAC2STR(mgmt->sa));
 431                 } else if (elems.timeout_int == 0 ||
 432                            elems.timeout_int_len != 5) {
 433                         wpa_printf(MSG_INFO, "No valid Timeout Interval IE in "
 434                                    "ReassocResp (status=30) from " MACSTR,
 435                                    MAC2STR(mgmt->sa));
 436                 } else {
 437                         sta->counters[
 438                                 WLANTEST_STA_COUNTER_REASSOCRESP_COMEBACK]++;
 439                 }
 440         }
 441
 442         if (status)
 443                 return;
 444
 445         if ((aid & 0xc000) != 0xc000) {
 446                 wpa_printf(MSG_DEBUG, "Two MSBs of the AID were not set to 1 "
 447                            "in Reassociation Response from " MACSTR,
 448                            MAC2STR(mgmt->sa));
 449         }
 450         sta->aid = aid & 0xc000;
 451
 452         if (sta->state < STATE2) {
 453                 wpa_printf(MSG_DEBUG, "STA " MACSTR " was not in State 2 when "
 454                            "getting associated", MAC2STR(sta->addr));
 455         }
 456
 457         if (sta->state < STATE3) {
 458                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 459                            " moved to State 3 with " MACSTR,
 460                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 461                 sta->state = STATE3;
 462         }
 463 }
 464
 465
 466 static void rx_mgmt_disassoc(struct wlantest *wt, const u8 *data, size_t len,
 467                              int valid)
 468 {
 469         const struct ieee80211_mgmt *mgmt;
 470         struct wlantest_bss *bss;
 471         struct wlantest_sta *sta;
 472
 473         mgmt = (const struct ieee80211_mgmt *) data;
 474         bss = bss_get(wt, mgmt->bssid);
 475         if (bss == NULL)
 476                 return;
 477         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 478                 sta = sta_get(bss, mgmt->da);
 479         else
 480                 sta = sta_get(bss, mgmt->sa);
 481         if (sta == NULL)
 482                 return;
 483
 484         if (len < 24 + 2) {
 485                 wpa_printf(MSG_INFO, "Too short Disassociation frame from "
 486                            MACSTR, MAC2STR(mgmt->sa));
 487                 return;
 488         }
 489
 490         wpa_printf(MSG_DEBUG, "DISASSOC " MACSTR " -> " MACSTR
 491                    " (reason=%u)",
 492                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 493                    le_to_host16(mgmt->u.disassoc.reason_code));
 494         wpa_hexdump(MSG_MSGDUMP, "DISASSOC payload", data + 24, len - 24);
 495
 496         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 497                 sta->counters[valid ? WLANTEST_STA_COUNTER_VALID_DISASSOC_RX :
 498                               WLANTEST_STA_COUNTER_INVALID_DISASSOC_RX]++;
 499         else
 500                 sta->counters[valid ? WLANTEST_STA_COUNTER_VALID_DISASSOC_TX :
 501                               WLANTEST_STA_COUNTER_INVALID_DISASSOC_TX]++;
 502
 503         if (!valid) {
 504                 wpa_printf(MSG_INFO, "Do not change STA " MACSTR " State "
 505                            "since Disassociation frame was not protected "
 506                            "correctly", MAC2STR(sta->addr));
 507                 return;
 508         }
 509
 510         if (sta->state < STATE2) {
 511                 wpa_printf(MSG_DEBUG, "STA " MACSTR " was not in State 2 or 3 "
 512                            "when getting disassociated", MAC2STR(sta->addr));
 513         }
 514
 515         if (sta->state > STATE2) {
 516                 wpa_printf(MSG_DEBUG, "STA " MACSTR
 517                            " moved to State 2 with " MACSTR,
 518                            MAC2STR(sta->addr), MAC2STR(bss->bssid));
 519                 sta->state = STATE2;
 520         }
 521 }
 522
 523
 524 static void rx_mgmt_action_sa_query_req(struct wlantest *wt,
 525                                         struct wlantest_sta *sta,
 526                                         const struct ieee80211_mgmt *mgmt,
 527                                         size_t len, int valid)
 528 {
 529         const u8 *rx_id;
 530         u8 *id;
 531
 532         rx_id = (const u8 *) mgmt->u.action.u.sa_query_req.trans_id;
 533         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 534                 id = sta->ap_sa_query_tr;
 535         else
 536                 id = sta->sta_sa_query_tr;
 537         wpa_printf(MSG_INFO, "SA Query Request " MACSTR " -> " MACSTR
 538                    " (trans_id=%02x%02x)%s",
 539                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), rx_id[0], rx_id[1],
 540                    valid ? "" : " (invalid protection)");
 541         os_memcpy(id, mgmt->u.action.u.sa_query_req.trans_id, 2);
 542         if (os_memcmp(mgmt->sa, sta->addr, ETH_ALEN) == 0)
 543                 sta->counters[valid ?
 544                               WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_TX :
 545                               WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_TX]++;
 546         else
 547                 sta->counters[valid ?
 548                               WLANTEST_STA_COUNTER_VALID_SAQUERYREQ_RX :
 549                               WLANTEST_STA_COUNTER_INVALID_SAQUERYREQ_RX]++;
 550 }
 551
 552
 553 static void rx_mgmt_action_sa_query_resp(struct wlantest *wt,
 554                                          struct wlantest_sta *sta,
 555                                          const struct ieee80211_mgmt *mgmt,
 556                                          size_t len, int valid)
 557 {
 558         const u8 *rx_id;
 559         u8 *id;
 560         int match;
 561
 562         rx_id = (const u8 *) mgmt->u.action.u.sa_query_resp.trans_id;
 563         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 564                 id = sta->sta_sa_query_tr;
 565         else
 566                 id = sta->ap_sa_query_tr;
 567         match = os_memcmp(rx_id, id, 2) == 0;
 568         wpa_printf(MSG_INFO, "SA Query Response " MACSTR " -> " MACSTR
 569                    " (trans_id=%02x%02x; %s)%s",
 570                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da), rx_id[0], rx_id[1],
 571                    match ? "match" : "mismatch",
 572                    valid ? "" : " (invalid protection)");
 573         if (os_memcmp(mgmt->sa, sta->addr, ETH_ALEN) == 0)
 574                 sta->counters[(valid && match) ?
 575                               WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_TX :
 576                               WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_TX]++;
 577         else
 578                 sta->counters[(valid && match) ?
 579                               WLANTEST_STA_COUNTER_VALID_SAQUERYRESP_RX :
 580                               WLANTEST_STA_COUNTER_INVALID_SAQUERYRESP_RX]++;
 581 }
 582
 583
 584 static void rx_mgmt_action_sa_query(struct wlantest *wt,
 585                                     struct wlantest_sta *sta,
 586                                     const struct ieee80211_mgmt *mgmt,
 587                                     size_t len, int valid)
 588 {
 589         if (len < 24 + 2 + WLAN_SA_QUERY_TR_ID_LEN) {
 590                 wpa_printf(MSG_INFO, "Too short SA Query frame from " MACSTR,
 591                            MAC2STR(mgmt->sa));
 592                 return;
 593         }
 594
 595         if (len > 24 + 2 + WLAN_SA_QUERY_TR_ID_LEN) {
 596                 size_t elen = len - (24 + 2 + WLAN_SA_QUERY_TR_ID_LEN);
 597                 wpa_printf(MSG_INFO, "Unexpected %u octets of extra data at "
 598                            "the end of SA Query frame from " MACSTR,
 599                            (unsigned) elen, MAC2STR(mgmt->sa));
 600                 wpa_hexdump(MSG_INFO, "SA Query extra data",
 601                             ((const u8 *) mgmt) + len - elen, elen);
 602         }
 603
 604         switch (mgmt->u.action.u.sa_query_req.action) {
 605         case WLAN_SA_QUERY_REQUEST:
 606                 rx_mgmt_action_sa_query_req(wt, sta, mgmt, len, valid);
 607                 break;
 608         case WLAN_SA_QUERY_RESPONSE:
 609                 rx_mgmt_action_sa_query_resp(wt, sta, mgmt, len, valid);
 610                 break;
 611         default:
 612                 wpa_printf(MSG_INFO, "Unexpected SA Query action value %u "
 613                            "from " MACSTR,
 614                            mgmt->u.action.u.sa_query_req.action,
 615                            MAC2STR(mgmt->sa));
 616         }
 617 }
 618
 619
 620 static void rx_mgmt_action(struct wlantest *wt, const u8 *data, size_t len,
 621                            int valid)
 622 {
 623         const struct ieee80211_mgmt *mgmt;
 624         struct wlantest_bss *bss;
 625         struct wlantest_sta *sta;
 626
 627         mgmt = (const struct ieee80211_mgmt *) data;
 628         if (mgmt->da[0] & 0x01) {
 629                 wpa_printf(MSG_DEBUG, "Group addressed Action frame: DA="
 630                            MACSTR " SA=" MACSTR " BSSID=" MACSTR
 631                            " category=%u",
 632                            MAC2STR(mgmt->da), MAC2STR(mgmt->sa),
 633                            MAC2STR(mgmt->bssid), mgmt->u.action.category);
 634                 return; /* Ignore group addressed Action frames for now */
 635         }
 636         bss = bss_get(wt, mgmt->bssid);
 637         if (bss == NULL)
 638                 return;
 639         if (os_memcmp(mgmt->sa, mgmt->bssid, ETH_ALEN) == 0)
 640                 sta = sta_get(bss, mgmt->da);
 641         else
 642                 sta = sta_get(bss, mgmt->sa);
 643         if (sta == NULL)
 644                 return;
 645
 646         if (len < 24 + 1) {
 647                 wpa_printf(MSG_INFO, "Too short Action frame from "
 648                            MACSTR, MAC2STR(mgmt->sa));
 649                 return;
 650         }
 651
 652         wpa_printf(MSG_DEBUG, "ACTION " MACSTR " -> " MACSTR
 653                    " (category=%u) (valid=%d)",
 654                    MAC2STR(mgmt->sa), MAC2STR(mgmt->da),
 655                    mgmt->u.action.category, valid);
 656         wpa_hexdump(MSG_MSGDUMP, "ACTION payload", data + 24, len - 24);
 657
 658         if (mgmt->u.action.category != WLAN_ACTION_PUBLIC &&
 659             sta->state < STATE3) {
 660                 wpa_printf(MSG_INFO, "Action frame sent when STA is not in "
 661                            "State 3 (SA=" MACSTR " DATA=" MACSTR ")",
 662                            MAC2STR(mgmt->sa), MAC2STR(mgmt->da));
 663         }
 664
 665         switch (mgmt->u.action.category) {
 666         case WLAN_ACTION_SA_QUERY:
 667                 rx_mgmt_action_sa_query(wt, sta, mgmt, len, valid);
 668                 break;
 669         }
 670 }
 671
 672
 673 static int check_mmie_mic(const u8 *igtk, const u8 *data, size_t len)
 674 {
 675         u8 *buf;
 676         u8 mic[16];
 677         u16 fc;
 678         const struct ieee80211_hdr *hdr;
 679
 680         buf = os_malloc(len + 20 - 24);
 681         if (buf == NULL)
 682                 return -1;
 683
 684         /* BIP AAD: FC(masked) A1 A2 A3 */
 685         hdr = (const struct ieee80211_hdr *) data;
 686         fc = le_to_host16(hdr->frame_control);
 687         fc &= ~(WLAN_FC_RETRY | WLAN_FC_PWRMGT | WLAN_FC_MOREDATA);
 688         WPA_PUT_LE16(buf, fc);
 689         os_memcpy(buf + 2, hdr->addr1, 3 * ETH_ALEN);
 690
 691         /* Frame body with MMIE MIC masked to zero */
 692         os_memcpy(buf + 20, data + 24, len - 24 - 8);
 693         os_memset(buf + 20 + len - 24 - 8, 0, 8);
 694
 695         wpa_hexdump(MSG_MSGDUMP, "BIP: AAD|Body(masked)", buf, len + 20 - 24);
 696         /* MIC = L(AES-128-CMAC(AAD || Frame Body(masked)), 0, 64) */
 697         if (omac1_aes_128(igtk, buf, len + 20 - 24, mic) < 0) {
 698                 os_free(buf);
 699                 return -1;
 700         }
 701
 702         os_free(buf);
 703
 704         if (os_memcmp(data + len - 8, mic, 8) != 0)
 705                 return -1;
 706
 707         return 0;
 708 }
 709
 710
 711 static int check_bip(struct wlantest *wt, const u8 *data, size_t len)
 712 {
 713         const struct ieee80211_mgmt *mgmt;
 714         u16 fc, stype;
 715         const u8 *mmie;
 716         u16 keyid;
 717         struct wlantest_bss *bss;
 718
 719         mgmt = (const struct ieee80211_mgmt *) data;
 720         fc = le_to_host16(mgmt->frame_control);
 721         stype = WLAN_FC_GET_STYPE(fc);
 722
 723         if (stype == WLAN_FC_STYPE_ACTION) {
 724                 if (len < 24 + 1)
 725                         return 0;
 726                 if (mgmt->u.action.category == WLAN_ACTION_PUBLIC)
 727                         return 0; /* Not a robust management frame */
 728         }
 729
 730         bss = bss_get(wt, mgmt->bssid);
 731         if (bss == NULL)
 732                 return 0; /* No key known yet */
 733
 734         if (len < 24 + 18 || data[len - 18] != WLAN_EID_MMIE ||
 735             data[len - 17] != 16) {
 736                 /* No MMIE */
 737                 if (bss->rsn_capab & WPA_CAPABILITY_MFPC) {
 738                         wpa_printf(MSG_INFO, "Robust group-addressed "
 739                                    "management frame sent without BIP by "
 740                                    MACSTR, MAC2STR(mgmt->sa));
 741                         bss->counters[WLANTEST_BSS_COUNTER_MISSING_BIP_MMIE]++;
 742                         return -1;
 743                 }
 744                 return 0;
 745         }
 746
 747         mmie = data + len - 16;
 748         keyid = WPA_GET_LE16(mmie);
 749         if (keyid & 0xf000) {
 750                 wpa_printf(MSG_INFO, "MMIE KeyID reserved bits not zero "
 751                            "(%04x) from " MACSTR, keyid, MAC2STR(mgmt->sa));
 752                 keyid &= 0x0fff;
 753         }
 754         if (keyid < 4 || keyid > 5) {
 755                 wpa_printf(MSG_INFO, "Unexpected MMIE KeyID %u from " MACSTR,
 756                            keyid, MAC2STR(mgmt->sa));
 757                 bss->counters[WLANTEST_BSS_COUNTER_INVALID_BIP_MMIE]++;
 758                 return 0;
 759         }
 760         wpa_printf(MSG_DEBUG, "MMIE KeyID %u", keyid);
 761         wpa_hexdump(MSG_MSGDUMP, "MMIE IPN", mmie + 2, 6);
 762         wpa_hexdump(MSG_MSGDUMP, "MMIE MIC", mmie + 8, 8);
 763
 764         if (!bss->igtk_set[keyid]) {
 765                 wpa_printf(MSG_DEBUG, "No IGTK known to validate BIP frame");
 766                 return 0;
 767         }
 768
 769         if (os_memcmp(mmie + 2, bss->ipn[keyid], 6) <= 0) {
 770                 wpa_printf(MSG_INFO, "BIP replay detected: SA=" MACSTR,
 771                            MAC2STR(mgmt->sa));
 772                 wpa_hexdump(MSG_INFO, "RX IPN", mmie + 2, 6);
 773                 wpa_hexdump(MSG_INFO, "Last RX IPN", bss->ipn[keyid], 6);
 774         }
 775
 776         if (check_mmie_mic(bss->igtk[keyid], data, len) < 0) {
 777                 wpa_printf(MSG_INFO, "Invalid MMIE MIC in a frame from "
 778                            MACSTR, MAC2STR(mgmt->sa));
 779                 bss->counters[WLANTEST_BSS_COUNTER_INVALID_BIP_MMIE]++;
 780                 return -1;
 781         }
 782
 783         wpa_printf(MSG_DEBUG, "Valid MMIE MIC");
 784         os_memcpy(bss->ipn[keyid], mmie + 2, 6);
 785         bss->counters[WLANTEST_BSS_COUNTER_VALID_BIP_MMIE]++;
 786
 787         return 0;
 788 }
 789
 790
 791 static u8 * mgmt_ccmp_decrypt(struct wlantest *wt, const u8 *data, size_t len,
 792                               size_t *dlen)
 793 {
 794         struct wlantest_bss *bss;
 795         struct wlantest_sta *sta;
 796         const struct ieee80211_hdr *hdr;
 797         int keyid;
 798         u8 *decrypted, *frame = NULL;
 799         u8 pn[6], *rsc;
 800
 801         hdr = (const struct ieee80211_hdr *) data;
 802         bss = bss_get(wt, hdr->addr3);
 803         if (bss == NULL)
 804                 return NULL;
 805         if (os_memcmp(hdr->addr1, hdr->addr3, ETH_ALEN) == 0)
 806                 sta = sta_get(bss, hdr->addr2);
 807         else
 808                 sta = sta_get(bss, hdr->addr1);
 809         if (sta == NULL || !sta->ptk_set) {
 810                 wpa_printf(MSG_MSGDUMP, "No PTK known to decrypt the frame");
 811                 return NULL;
 812         }
 813
 814         if (len < 24 + 4)
 815                 return NULL;
 816
 817         if (!(data[24 + 3] & 0x20)) {
 818                 wpa_printf(MSG_INFO, "Expected CCMP frame from " MACSTR
 819                            " did not have ExtIV bit set to 1",
 820                            MAC2STR(hdr->addr2));
 821                 return NULL;
 822         }
 823
 824         if (data[24 + 2] != 0 || (data[24 + 3] & 0x1f) != 0) {
 825                 wpa_printf(MSG_INFO, "CCMP mgmt frame from " MACSTR " used "
 826                            "non-zero reserved bit", MAC2STR(hdr->addr2));
 827         }
 828
 829         keyid = data[24 + 3] >> 6;
 830         if (keyid != 0) {
 831                 wpa_printf(MSG_INFO, "Unexpected non-zero KeyID %d in "
 832                            "individually addressed Management frame from "
 833                            MACSTR, keyid, MAC2STR(hdr->addr2));
 834         }
 835
 836         if (os_memcmp(hdr->addr1, hdr->addr3, ETH_ALEN) == 0)
 837                 rsc = sta->rsc_tods[16];
 838         else
 839                 rsc = sta->rsc_fromds[16];
 840
 841         ccmp_get_pn(pn, data + 24);
 842         if (os_memcmp(pn, rsc, 6) <= 0) {
 843                 wpa_printf(MSG_INFO, "CCMP/TKIP replay detected: SA=" MACSTR,
 844                            MAC2STR(hdr->addr2));
 845                 wpa_hexdump(MSG_INFO, "RX PN", pn, 6);
 846                 wpa_hexdump(MSG_INFO, "RSC", rsc, 6);
 847         }
 848
 849         decrypted = ccmp_decrypt(sta->ptk.tk1, hdr, data + 24, len - 24, dlen);
 850         if (decrypted) {
 851                 os_memcpy(rsc, pn, 6);
 852                 frame = os_malloc(24 + *dlen);
 853                 if (frame) {
 854                         os_memcpy(frame, data, 24);
 855                         os_memcpy(frame + 24, decrypted, *dlen);
 856                         *dlen += 24;
 857                 }
 858         }
 859
 860         os_free(decrypted);
 861
 862         return frame;
 863 }
 864
 865
 866 static int check_mgmt_ccmp(struct wlantest *wt, const u8 *data, size_t len)
 867 {
 868         const struct ieee80211_mgmt *mgmt;
 869         u16 fc;
 870         struct wlantest_bss *bss;
 871         struct wlantest_sta *sta;
 872
 873         mgmt = (const struct ieee80211_mgmt *) data;
 874         fc = le_to_host16(mgmt->frame_control);
 875
 876         if (WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) {
 877                 if (len > 24 &&
 878                     mgmt->u.action.category == WLAN_ACTION_PUBLIC)
 879                         return 0; /* Not a robust management frame */
 880         }
 881
 882         bss = bss_get(wt, mgmt->bssid);
 883         if (bss == NULL)
 884                 return 0;
 885         if (os_memcmp(mgmt->da, mgmt->bssid, ETH_ALEN) == 0)
 886                 sta = sta_get(bss, mgmt->sa);
 887         else
 888                 sta = sta_get(bss, mgmt->da);
 889         if (sta == NULL)
 890                 return 0;
 891
 892         if (sta->rsn_capab & WPA_CAPABILITY_MFPC) {
 893                 wpa_printf(MSG_INFO, "Robust individually-addressed "
 894                            "management frame sent without CCMP by "
 895                            MACSTR, MAC2STR(mgmt->sa));
 896                 return -1;
 897         }
 898
 899         return 0;
 900 }
 901
 902
 903 void rx_mgmt(struct wlantest *wt, const u8 *data, size_t len)
 904 {
 905         const struct ieee80211_hdr *hdr;
 906         u16 fc, stype;
 907         int valid = 1;
 908         u8 *decrypted = NULL;
 909         size_t dlen;
 910
 911         if (len < 24)
 912                 return;
 913
 914         hdr = (const struct ieee80211_hdr *) data;
 915         fc = le_to_host16(hdr->frame_control);
 916         wt->rx_mgmt++;
 917         stype = WLAN_FC_GET_STYPE(fc);
 918
 919         if ((hdr->addr1[0] & 0x01) &&
 920             (stype == WLAN_FC_STYPE_DEAUTH ||
 921              stype == WLAN_FC_STYPE_DISASSOC ||
 922              stype == WLAN_FC_STYPE_ACTION)) {
 923                 if (check_bip(wt, data, len) < 0)
 924                         valid = 0;
 925         }
 926
 927         wpa_printf((stype == WLAN_FC_STYPE_BEACON ||
 928                     stype == WLAN_FC_STYPE_PROBE_RESP ||
 929                     stype == WLAN_FC_STYPE_PROBE_REQ) ?
 930                    MSG_EXCESSIVE : MSG_MSGDUMP,
 931                    "MGMT %s%s%s DA=" MACSTR " SA=" MACSTR " BSSID=" MACSTR,
 932                    mgmt_stype(stype),
 933                    fc & WLAN_FC_PWRMGT ? " PwrMgt" : "",
 934                    fc & WLAN_FC_ISWEP ? " Prot" : "",
 935                    MAC2STR(hdr->addr1), MAC2STR(hdr->addr2),
 936                    MAC2STR(hdr->addr3));
 937
 938         if ((fc & WLAN_FC_ISWEP) &&
 939             !(hdr->addr1[0] & 0x01) &&
 940             (stype == WLAN_FC_STYPE_DEAUTH ||
 941              stype == WLAN_FC_STYPE_DISASSOC ||
 942              stype == WLAN_FC_STYPE_ACTION)) {
 943                 decrypted = mgmt_ccmp_decrypt(wt, data, len, &dlen);
 944                 if (decrypted) {
 945                         write_pcap_decrypted(wt, decrypted, dlen, NULL, 0);
 946                         data = decrypted;
 947                         len = dlen;
 948                 } else
 949                         valid = 0;
 950         }
 951
 952         if (!(fc & WLAN_FC_ISWEP) &&
 953             !(hdr->addr1[0] & 0x01) &&
 954             (stype == WLAN_FC_STYPE_DEAUTH ||
 955              stype == WLAN_FC_STYPE_DISASSOC ||
 956              stype == WLAN_FC_STYPE_ACTION)) {
 957                 if (check_mgmt_ccmp(wt, data, len) < 0)
 958                         valid = 0;
 959         }
 960
 961         switch (stype) {
 962         case WLAN_FC_STYPE_BEACON:
 963                 rx_mgmt_beacon(wt, data, len);
 964                 break;
 965         case WLAN_FC_STYPE_PROBE_RESP:
 966                 rx_mgmt_probe_resp(wt, data, len);
 967                 break;
 968         case WLAN_FC_STYPE_AUTH:
 969                 rx_mgmt_auth(wt, data, len);
 970                 break;
 971         case WLAN_FC_STYPE_DEAUTH:
 972                 rx_mgmt_deauth(wt, data, len, valid);
 973                 break;
 974         case WLAN_FC_STYPE_ASSOC_REQ:
 975                 rx_mgmt_assoc_req(wt, data, len);
 976                 break;
 977         case WLAN_FC_STYPE_ASSOC_RESP:
 978                 rx_mgmt_assoc_resp(wt, data, len);
 979                 break;
 980         case WLAN_FC_STYPE_REASSOC_REQ:
 981                 rx_mgmt_reassoc_req(wt, data, len);
 982                 break;
 983         case WLAN_FC_STYPE_REASSOC_RESP:
 984                 rx_mgmt_reassoc_resp(wt, data, len);
 985                 break;
 986         case WLAN_FC_STYPE_DISASSOC:
 987                 rx_mgmt_disassoc(wt, data, len, valid);
 988                 break;
 989         case WLAN_FC_STYPE_ACTION:
 990                 rx_mgmt_action(wt, data, len, valid);
 991                 break;
 992         }
 993
 994         os_free(decrypted);
 995 }