wlantest/test_vectors.c

   1 /*
   2  * test_vectors - IEEE 802.11 test vector generator
   3  * Copyright (c) 2012, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10
  11 #include "utils/common.h"
  12 #include "utils/eloop.h"
  13 #include "common/ieee802_11_defs.h"
  14 #include "wlantest.h"
  15
  16
  17 static void test_vector_tkip(void)
  18 {
  19         u8 tk[] = {
  20                 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
  21                 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12,
  22                 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78,
  23                 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34
  24         };
  25         u8 pn[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
  26         u8 frame[] = {
  27                 0x08, 0x42, 0x2c, 0x00, 0x02, 0x03, 0x04, 0x05,
  28                 0x06, 0x08, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  29                 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xd0, 0x02,
  30                 /* 0x00, 0x20, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, */
  31                 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00,
  32                 0x45, 0x00, 0x00, 0x54, 0x00, 0x00, 0x40, 0x00,
  33                 0x40, 0x01, 0xa5, 0x55, 0xc0, 0xa8, 0x0a, 0x02,
  34                 0xc0, 0xa8, 0x0a, 0x01, 0x08, 0x00, 0x3a, 0xb0,
  35                 0x00, 0x00, 0x00, 0x00, 0xcd, 0x4c, 0x05, 0x00,
  36                 0x00, 0x00, 0x00, 0x00, 0x08, 0x09, 0x0a, 0x0b,
  37                 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
  38                 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
  39                 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
  40                 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
  41                 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33,
  42                 0x34, 0x35, 0x36, 0x37,
  43                 /* 0x68, 0x81, 0xa3, 0xf3, 0xd6, 0x48, 0xd0, 0x3c */
  44         };
  45         u8 *enc, *plain;
  46         size_t enc_len, plain_len;
  47
  48         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.6.3 TKIP test "
  49                    "vector\n");
  50
  51         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
  52         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
  53         wpa_hexdump(MSG_INFO, "Plaintext MPDU", frame, sizeof(frame));
  54
  55         enc = tkip_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0, &enc_len);
  56         if (enc == NULL) {
  57                 wpa_printf(MSG_ERROR, "Failed to encrypt TKIP frame");
  58                 return;
  59         }
  60
  61         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
  62
  63         wpa_debug_level = MSG_INFO;
  64         plain = tkip_decrypt(tk, (const struct ieee80211_hdr *) enc,
  65                              enc + 24, enc_len - 24, &plain_len);
  66         wpa_debug_level = MSG_EXCESSIVE;
  67         os_free(enc);
  68
  69         if (plain == NULL) {
  70                 wpa_printf(MSG_ERROR, "Failed to decrypt TKIP frame");
  71                 return;
  72         }
  73
  74         if (plain_len != sizeof(frame) - 24 ||
  75             os_memcmp(plain, frame + 24, plain_len) != 0) {
  76                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
  77                             plain, plain_len);
  78         }
  79
  80         os_free(plain);
  81 }
  82
  83
  84 static void test_vector_ccmp(void)
  85 {
  86         u8 tk[] = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
  87                     0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f };
  88         u8 pn[] = { 0xB5, 0x03, 0x97, 0x76, 0xE7, 0x0C };
  89         u8 frame[] = {
  90                 0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
  91                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
  92                 0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
  93                 0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
  94                 0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
  95                 0x7e, 0x78, 0xa0, 0x50
  96         };
  97         u8 *enc, *plain;
  98         size_t enc_len, plain_len;
  99         u8 fcs[4];
 100
 101         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.6.4 CCMP test "
 102                    "vector\n");
 103
 104         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 105         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 106         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 24);
 107         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 24, sizeof(frame) - 24);
 108
 109         enc = ccmp_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0, &enc_len);
 110         if (enc == NULL) {
 111                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 112                 return;
 113         }
 114
 115         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 116         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 117         wpa_hexdump(MSG_INFO, "FCS", fcs, sizeof(fcs));
 118
 119         wpa_debug_level = MSG_INFO;
 120         plain = ccmp_decrypt(tk, (const struct ieee80211_hdr *) enc,
 121                              enc + 24, enc_len - 24, &plain_len);
 122         wpa_debug_level = MSG_EXCESSIVE;
 123         os_free(enc);
 124
 125         if (plain == NULL) {
 126                 wpa_printf(MSG_ERROR, "Failed to decrypt CCMP frame");
 127                 return;
 128         }
 129
 130         if (plain_len != sizeof(frame) - 24 ||
 131             os_memcmp(plain, frame + 24, plain_len) != 0) {
 132                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 133                             plain, plain_len);
 134         }
 135
 136         os_free(plain);
 137 }
 138
 139
 140 static void test_vector_ccmp_pv1(void)
 141 {
 142         u8 tk[] = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
 143                     0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f };
 144         u8 pn[8];
 145         u8 frame1[] = {
 146                 0x61, 0x00, 0xa2, 0xae, 0xa5, 0xb8, 0xfc, 0xba,
 147                 0x07, 0x00, 0x80, 0x33,
 148                 0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
 149                 0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
 150                 0x7e, 0x78, 0xa0, 0x50
 151         };
 152         u8 frame2[] = {
 153                 0x61, 0x00, 0xa2, 0xae, 0xa5, 0xb8, 0xfc, 0xba,
 154                 0x07, 0x20, 0x80, 0x33, 0x02, 0xd2, 0xe1, 0x28,
 155                 0xa5, 0x7c,
 156                 0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
 157                 0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
 158                 0x7e, 0x78, 0xa0, 0x50
 159         };
 160         u8 frame3[] = {
 161                 0x6d, 0x00, 0xa2, 0xae, 0xa5, 0xb8, 0xfc, 0xba,
 162                 0x52, 0x30, 0xf1, 0x84, 0x44, 0x08, 0x80, 0x33,
 163                 0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
 164                 0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
 165                 0x7e, 0x78, 0xa0, 0x50
 166         };
 167         u8 *enc;
 168         size_t enc_len;
 169         u8 fcs[4];
 170         u8 bssid[ETH_ALEN] = { 0xa2, 0xae, 0xa5, 0xb8, 0xfc, 0xba };
 171         u8 da[ETH_ALEN] = { 0x02, 0xd2, 0xe1, 0x28, 0xa5, 0x7c };
 172         u8 sa[ETH_ALEN] = { 0x52, 0x30, 0xf1, 0x84, 0x44, 0x08 };
 173         u16 aid = 7;
 174         u32 bpn = 123;
 175         u16 sc = 0x3380;
 176         int key_id = 0;
 177         u16 fc;
 178         int tid = 3;
 179         u16 sid;
 180
 181         wpa_printf(MSG_INFO,
 182                    "\nIEEE P802.11ah/D10.0, J.6.4 CCMP PV1 test vectors\n");
 183
 184         wpa_printf(MSG_INFO, "BSSID: " MACSTR, MAC2STR(bssid));
 185         wpa_printf(MSG_INFO, "DA: " MACSTR, MAC2STR(da));
 186         wpa_printf(MSG_INFO, "SA: " MACSTR, MAC2STR(sa));
 187         wpa_printf(MSG_INFO, "Association ID: %u", aid);
 188         wpa_printf(MSG_INFO, "Base PN: %u (0x%08x)", bpn, bpn);
 189         wpa_printf(MSG_INFO, "SC = 0x%04x (FragNum=%u SeqNum=%u)",
 190                    sc, WLAN_GET_SEQ_FRAG(sc), WLAN_GET_SEQ_SEQ(sc));
 191         wpa_printf(MSG_INFO, "TID = %u", tid);
 192         wpa_printf(MSG_INFO, "Key ID: %u", key_id);
 193         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 194         wpa_printf(MSG_INFO, "PN = SC||BPN");
 195         WPA_PUT_LE16(&pn[0], sc);
 196         WPA_PUT_LE32(&pn[2], bpn);
 197         wpa_hexdump(MSG_INFO, "PN (PN0..PN5)", pn, sizeof(pn));
 198
 199         wpa_printf(MSG_INFO,
 200                    "\nPV1 test vector #1:\nHeader compression used and A3 was previously stored at the receiver\n");
 201         fc = WPA_GET_LE16(frame1);
 202         wpa_printf(MSG_INFO,
 203                    "FC=0x%04x (PV=%u Type=%u PTID/Subtype=%u From_DS=%u More_Fragments=%u Power_Management=%u More_Data=%u Protected_Frame=%u End_of_SP=%u Relayed_Frame=%u Ack_Policy=%u)",
 204                    fc,
 205                    fc & WLAN_FC_PVER,
 206                    (fc & (BIT(2) | BIT(3) | BIT(4))) >> 2,
 207                    (fc & (BIT(5) | BIT(6) | BIT(7))) >> 5,
 208                    !!(fc & BIT(8)),
 209                    !!(fc & BIT(9)),
 210                    !!(fc & BIT(10)),
 211                    !!(fc & BIT(11)),
 212                    !!(fc & BIT(12)),
 213                    !!(fc & BIT(13)),
 214                    !!(fc & BIT(14)),
 215                    !!(fc & BIT(15)));
 216         wpa_printf(MSG_INFO, "A1=" MACSTR, MAC2STR(&frame1[2]));
 217         sid = WPA_GET_LE16(&frame1[8]);
 218         wpa_printf(MSG_INFO,
 219                    "A2=%02x %02x (SID: AID=%u A3_Present=%u A4_Present=%u A-MSDU=%u); corresponds to 52:30:f1:84:44:08 in uncompressed header",
 220                    frame1[8], frame1[9],
 221                    sid & ~(BIT(13) | BIT(14) | BIT(15)),
 222                    !!(sid & BIT(13)),
 223                    !!(sid & BIT(14)),
 224                    !!(sid & BIT(15)));
 225         sc = WPA_GET_LE16(&frame1[10]);
 226         wpa_printf(MSG_INFO, "Sequence Control: %02x %02x (FN=%u SN=%u)",
 227                    frame1[10], frame1[11],
 228                    WLAN_GET_SEQ_FRAG(sc), WLAN_GET_SEQ_SEQ(sc));
 229         wpa_printf(MSG_INFO, "A3 not present; corresponds to 02:d2:e1:28:a5:7c in uncompressed header");
 230         wpa_printf(MSG_INFO, "A4 not present");
 231         wpa_hexdump(MSG_INFO, "Plaintext Frame Header", frame1, 12);
 232         wpa_hexdump(MSG_INFO, "Plaintext Frame Body",
 233                     frame1 + 12, sizeof(frame1) - 12);
 234
 235         enc = ccmp_encrypt_pv1(tk, &frame1[2], sa, da, frame1, sizeof(frame1),
 236                                12, pn, key_id, &enc_len);
 237         if (enc == NULL) {
 238                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 239                 return;
 240         }
 241
 242         wpa_hexdump(MSG_INFO, "Encrypted Frame Header", enc, 12);
 243         wpa_hexdump(MSG_INFO, "Encrypted Frame Frame Body",
 244                     enc + 12, enc_len - 12);
 245         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 246         wpa_hexdump(MSG_INFO, "Encrypted Frame FCS", fcs, sizeof(fcs));
 247
 248         wpa_printf(MSG_INFO,
 249                    "\nPV1 test vector #2:\nHeader compression used and A3 was not previously stored at the receiver\n");
 250         fc = WPA_GET_LE16(frame2);
 251         wpa_printf(MSG_INFO,
 252                    "FC=0x%04x (PV=%u Type=%u PTID/Subtype=%u From_DS=%u More_Fragments=%u Power_Management=%u More_Data=%u Protected_Frame=%u End_of_SP=%u Relayed_Frame=%u Ack_Policy=%u)",
 253                    fc,
 254                    fc & WLAN_FC_PVER,
 255                    (fc & (BIT(2) | BIT(3) | BIT(4))) >> 2,
 256                    (fc & (BIT(5) | BIT(6) | BIT(7))) >> 5,
 257                    !!(fc & BIT(8)),
 258                    !!(fc & BIT(9)),
 259                    !!(fc & BIT(10)),
 260                    !!(fc & BIT(11)),
 261                    !!(fc & BIT(12)),
 262                    !!(fc & BIT(13)),
 263                    !!(fc & BIT(14)),
 264                    !!(fc & BIT(15)));
 265         wpa_printf(MSG_INFO, "A1=" MACSTR, MAC2STR(&frame2[2]));
 266         sid = WPA_GET_LE16(&frame2[8]);
 267         wpa_printf(MSG_INFO,
 268                    "A2=%02x %02x (SID: AID=%u A3_Present=%u A4_Present=%u A-MSDU=%u); corresponds to 52:30:f1:84:44:08 in uncompressed header",
 269                    frame2[8], frame2[9],
 270                    sid & ~(BIT(13) | BIT(14) | BIT(15)),
 271                    !!(sid & BIT(13)),
 272                    !!(sid & BIT(14)),
 273                    !!(sid & BIT(15)));
 274         sc = WPA_GET_LE16(&frame2[10]);
 275         wpa_printf(MSG_INFO, "Sequence Control: %02x %02x (FN=%u SN=%u)",
 276                    frame2[10], frame2[11],
 277                    WLAN_GET_SEQ_FRAG(sc), WLAN_GET_SEQ_SEQ(sc));
 278         wpa_printf(MSG_INFO, "A3=" MACSTR, MAC2STR(&frame2[12]));
 279         wpa_printf(MSG_INFO, "A4 not present");
 280         wpa_hexdump(MSG_INFO, "Plaintext Frame Header", frame2, 18);
 281         wpa_hexdump(MSG_INFO, "Plaintext Frame Body",
 282                     frame2 + 18, sizeof(frame2) - 18);
 283
 284         enc = ccmp_encrypt_pv1(tk, &frame2[2], sa, &frame2[12],
 285                                frame2, sizeof(frame2), 18, pn, key_id,
 286                                &enc_len);
 287         if (enc == NULL) {
 288                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 289                 return;
 290         }
 291
 292         wpa_hexdump(MSG_INFO, "Encrypted Frame Header", enc, 18);
 293         wpa_hexdump(MSG_INFO, "Encrypted Frame Frame Body",
 294                     enc + 18, enc_len - 18);
 295         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 296         wpa_hexdump(MSG_INFO, "Encrypted Frame FCS", fcs, sizeof(fcs));
 297
 298         wpa_printf(MSG_INFO,
 299                    "\nPV1 test vector #3:\nType 3 frame from SA to DA(=BSSID) (i.e., no separate DA in this example)\n");
 300         fc = WPA_GET_LE16(frame3);
 301         wpa_printf(MSG_INFO,
 302                    "FC=0x%04x (PV=%u Type=%u PTID/Subtype=%u From_DS=%u More_Fragments=%u Power_Management=%u More_Data=%u Protected_Frame=%u End_of_SP=%u Relayed_Frame=%u Ack_Policy=%u)",
 303                    fc,
 304                    fc & WLAN_FC_PVER,
 305                    (fc & (BIT(2) | BIT(3) | BIT(4))) >> 2,
 306                    (fc & (BIT(5) | BIT(6) | BIT(7))) >> 5,
 307                    !!(fc & BIT(8)),
 308                    !!(fc & BIT(9)),
 309                    !!(fc & BIT(10)),
 310                    !!(fc & BIT(11)),
 311                    !!(fc & BIT(12)),
 312                    !!(fc & BIT(13)),
 313                    !!(fc & BIT(14)),
 314                    !!(fc & BIT(15)));
 315         wpa_printf(MSG_INFO, "A1=" MACSTR, MAC2STR(&frame3[2]));
 316         wpa_printf(MSG_INFO, "A2=" MACSTR, MAC2STR(&frame3[8]));
 317         sc = WPA_GET_LE16(&frame3[14]);
 318         wpa_printf(MSG_INFO, "Sequence Control: %02x %02x (FN=%u SN=%u)",
 319                    frame3[14], frame3[15],
 320                    WLAN_GET_SEQ_FRAG(sc), WLAN_GET_SEQ_SEQ(sc));
 321         wpa_printf(MSG_INFO,
 322                    "A3 not present; corresponds to 02:d2:e1:28:a5:7c in uncompressed header");
 323         wpa_printf(MSG_INFO, "A4 not present");
 324         wpa_hexdump(MSG_INFO, "Plaintext Frame Header", frame3, 16);
 325         wpa_hexdump(MSG_INFO, "Plaintext Frame Body",
 326                     frame3 + 16, sizeof(frame3) - 16);
 327
 328         enc = ccmp_encrypt_pv1(tk, &frame3[2], &frame3[8], da,
 329                                frame3, sizeof(frame3), 16, pn, key_id,
 330                                &enc_len);
 331         if (enc == NULL) {
 332                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 333                 return;
 334         }
 335
 336         wpa_hexdump(MSG_INFO, "Encrypted Frame Header", enc, 16);
 337         wpa_hexdump(MSG_INFO, "Encrypted Frame Frame Body",
 338                     enc + 16, enc_len - 16);
 339         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 340         wpa_hexdump(MSG_INFO, "Encrypted Frame FCS", fcs, sizeof(fcs));
 341
 342         wpa_debug_level = MSG_INFO;
 343 }
 344
 345
 346 static void test_vector_bip(void)
 347 {
 348         u8 igtk[] = {
 349                 0x4e, 0xa9, 0x54, 0x3e, 0x09, 0xcf, 0x2b, 0x1e,
 350                 0xca, 0x66, 0xff, 0xc5, 0x8b, 0xde, 0xcb, 0xcf
 351         };
 352         u8 ipn[] = { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 };
 353         u8 frame[] = {
 354                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 355                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 356                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 357                 0x02, 0x00
 358         };
 359         u8 *prot;
 360         size_t prot_len;
 361
 362         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.9.1 BIP with broadcast "
 363                    "Deauthentication frame\n");
 364
 365         wpa_hexdump(MSG_INFO, "IGTK", igtk, sizeof(igtk));
 366         wpa_hexdump(MSG_INFO, "IPN", ipn, sizeof(ipn));
 367         wpa_hexdump(MSG_INFO, "Plaintext frame", frame, sizeof(frame));
 368
 369         prot = bip_protect(igtk, sizeof(igtk), frame, sizeof(frame),
 370                            ipn, 4, &prot_len);
 371         if (prot == NULL) {
 372                 wpa_printf(MSG_ERROR, "Failed to protect BIP frame");
 373                 return;
 374         }
 375
 376         wpa_hexdump(MSG_INFO, "Protected MPDU (without FCS)", prot, prot_len);
 377         os_free(prot);
 378 }
 379
 380
 381 static void test_vector_ccmp_mgmt(void)
 382 {
 383         u8 tk[] = { 0x66, 0xed, 0x21, 0x04, 0x2f, 0x9f, 0x26, 0xd7,
 384                     0x11, 0x57, 0x06, 0xe4, 0x04, 0x14, 0xcf, 0x2e };
 385         u8 pn[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
 386         u8 frame[] = {
 387                 0xc0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
 388                 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 389                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00,
 390                 0x02, 0x00
 391         };
 392         u8 *enc, *plain;
 393         size_t enc_len, plain_len;
 394
 395         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.9.2 CCMP with unicast "
 396                    "Deauthentication frame\n");
 397
 398         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 399         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 400         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 24);
 401         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 24, sizeof(frame) - 24);
 402
 403         enc = ccmp_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0, &enc_len);
 404         if (enc == NULL) {
 405                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 406                 return;
 407         }
 408
 409         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 410
 411         wpa_debug_level = MSG_INFO;
 412         plain = ccmp_decrypt(tk, (const struct ieee80211_hdr *) enc,
 413                              enc + 24, enc_len - 24, &plain_len);
 414         wpa_debug_level = MSG_EXCESSIVE;
 415         os_free(enc);
 416
 417         if (plain == NULL) {
 418                 wpa_printf(MSG_ERROR, "Failed to decrypt CCMP frame");
 419                 return;
 420         }
 421
 422         if (plain_len != sizeof(frame) - 24 ||
 423             os_memcmp(plain, frame + 24, plain_len) != 0) {
 424                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 425                             plain, plain_len);
 426         }
 427
 428         os_free(plain);
 429 }
 430
 431
 432 struct gcmp_test {
 433         u8 tk[16];
 434         u8 pn[6];
 435         u8 frame[300];
 436         size_t hdr_len;
 437         size_t payload_len;
 438         u8 mic[16];
 439         u8 encr[300];
 440 };
 441
 442 static const struct gcmp_test gcmp_vectors[] =
 443 {
 444         {
 445                 .tk = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 446                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa },
 447                 .pn = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
 448                 .frame = {
 449                         0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 450                         0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 451                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
 452
 453                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 454                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 455                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 456                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 457                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 458                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 459                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 460                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 461                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 462                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 463                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 464                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 465                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 466                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 467                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 468                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 469                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 470                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 471                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 472                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 473                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 474                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 475                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 476                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 477                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 478                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 479                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 480                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 481                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 482                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 483                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 484                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 485                 },
 486                 .hdr_len = 24,
 487                 .payload_len = 256,
 488                 .mic = {
 489                         0x80, 0xCB, 0x06, 0x62, 0xEA, 0x71, 0xAB, 0xFD,
 490                         0x9F, 0x04, 0xC7, 0xF8, 0x72, 0xF5, 0x80, 0x90 },
 491                 .encr = {
 492                         0x5F, 0x55, 0x78, 0xC1, 0x8F, 0x13, 0x7A, 0xD2,
 493                         0x79, 0xBF, 0x3F, 0x2B, 0x24, 0xC7, 0xBD, 0x8F,
 494                         0x27, 0x7A, 0x1B, 0xE6, 0x77, 0x0D, 0xA1, 0xD9,
 495                         0x8B, 0x70, 0xC6, 0xD2, 0x8A, 0xE0, 0x1C, 0x55,
 496                         0x9E, 0xCB, 0xA6, 0xA0, 0x1D, 0xB0, 0x67, 0xC5,
 497                         0xA2, 0x7E, 0x4D, 0xB0, 0x8C, 0xDA, 0xDC, 0x77,
 498                         0x52, 0xAD, 0x63, 0x7E, 0xAF, 0x0A, 0x18, 0xED,
 499                         0x13, 0xFB, 0xAA, 0x14, 0x3B, 0xAF, 0xEF, 0x18,
 500                         0xF8, 0xFB, 0xCE, 0x4C, 0x65, 0xE8, 0x6B, 0xD0,
 501                         0x2A, 0x87, 0xB6, 0x01, 0xB7, 0xEA, 0xB9, 0x3F,
 502                         0x2B, 0xBC, 0x87, 0x4C, 0x8A, 0x71, 0x05, 0x80,
 503                         0xF5, 0x02, 0x34, 0x1A, 0x6A, 0x53, 0x39, 0x31,
 504                         0x43, 0xDE, 0x4C, 0x9E, 0xC6, 0xA2, 0x86, 0xF1,
 505                         0x25, 0x71, 0x83, 0x78, 0xAE, 0xDC, 0x84, 0xEB,
 506                         0xA2, 0xB3, 0x0F, 0x5C, 0x28, 0xBB, 0x5D, 0x75,
 507                         0xC6, 0xB0, 0x25, 0x46, 0x6D, 0x06, 0x51, 0xC7,
 508                         0x22, 0xDC, 0x71, 0x15, 0x1F, 0x21, 0x2D, 0x68,
 509                         0x87, 0x82, 0x8A, 0x03, 0x82, 0xE9, 0x28, 0x8A,
 510                         0x7F, 0x43, 0xD5, 0x2B, 0x7D, 0x25, 0x08, 0x61,
 511                         0x57, 0x64, 0x69, 0x54, 0xBB, 0x43, 0xB5, 0x7E,
 512                         0xA5, 0x87, 0xA0, 0x25, 0xF4, 0x0C, 0xE7, 0x45,
 513                         0x11, 0xE4, 0xDD, 0x22, 0x85, 0xB4, 0x0B, 0xA3,
 514                         0xF3, 0xB9, 0x62, 0x62, 0xCB, 0xC2, 0x8C, 0x6A,
 515                         0xA7, 0xBE, 0x44, 0x3E, 0x7B, 0x41, 0xE1, 0xEB,
 516                         0xFF, 0x52, 0x48, 0x57, 0xA6, 0x81, 0x68, 0x97,
 517                         0x75, 0x01, 0x15, 0xB0, 0x23, 0x1A, 0xB7, 0xC2,
 518                         0x84, 0x72, 0xC0, 0x6D, 0xD0, 0xB4, 0x9B, 0xE9,
 519                         0xF3, 0x69, 0xA8, 0xC3, 0x9C, 0xCD, 0x0D, 0xB7,
 520                         0x98, 0x35, 0x10, 0xE1, 0xAE, 0x8F, 0x05, 0xD7,
 521                         0x75, 0x45, 0xE0, 0x23, 0x5C, 0xDB, 0xD6, 0x12,
 522                         0xF3, 0x15, 0x07, 0x54, 0xCE, 0xE5, 0xCE, 0x6A,
 523                         0x12, 0x25, 0xD9, 0x95, 0x25, 0x02, 0x6F, 0x74
 524                 }
 525         },
 526         {
 527                 .tk = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
 528                         0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f },
 529                 .pn = { 0x00, 0x89, 0x5F, 0x5F, 0x2B, 0x08 },
 530                 .frame = {
 531                         0x88, 0x48, 0x0b, 0x00, 0x0f, 0xd2, 0xe1, 0x28,
 532                         0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 533                         0x50, 0x30, 0xf1, 0x84, 0x44, 0x08, 0x80, 0x33,
 534                         0x03, 0x00,
 535
 536                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 537                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 538                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 539                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 540                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27
 541                 },
 542                 .hdr_len = 26,
 543                 .payload_len = 40,
 544                 .mic = {
 545                         0xde, 0xf6, 0x19, 0xc2, 0xa3, 0x74, 0xb6, 0xdf,
 546                         0x66, 0xff, 0xa5, 0x3b, 0x6c, 0x69, 0xd7, 0x9e },
 547                 .encr = {
 548                         0x60, 0xe9, 0x70, 0x0c, 0xc4, 0xd4, 0x0a, 0xc6,
 549                         0xd2, 0x88, 0xb2, 0x01, 0xc3, 0x8f, 0x5b, 0xf0,
 550                         0x8b, 0x80, 0x74, 0x42, 0x64, 0x0a, 0x15, 0x96,
 551                         0xe5, 0xdb, 0xda, 0xd4, 0x1d, 0x1f, 0x36, 0x23,
 552                         0xf4, 0x5d, 0x7a, 0x12, 0xdb, 0x7a, 0xfb, 0x23
 553                 }
 554         }
 555 };
 556
 557
 558 static int run_gcmp(int idx, const struct gcmp_test *vector)
 559 {
 560         u8 *enc, *plain;
 561         size_t enc_len, plain_len;
 562         u8 fcs[4];
 563         int err = 0;
 564
 565         wpa_printf(MSG_INFO,
 566                    "\nIEEE Std 802.11ad-2012, M.11.1 GCMP test mpdu #%d\n",
 567                    idx);
 568
 569         wpa_hexdump(MSG_INFO, "TK", vector->tk, sizeof(vector->tk));
 570         wpa_hexdump(MSG_INFO, "PN", vector->pn, sizeof(vector->pn));
 571         wpa_hexdump(MSG_INFO, "802.11 Header", vector->frame, vector->hdr_len);
 572         wpa_hexdump(MSG_INFO, "Plaintext Data",
 573                     vector->frame + vector->hdr_len,
 574                     vector->payload_len);
 575
 576         enc = gcmp_encrypt(vector->tk, sizeof(vector->tk),
 577                            vector->frame,
 578                            vector->hdr_len + vector->payload_len,
 579                            vector->hdr_len,
 580                            vector->hdr_len == 26 ?
 581                            vector->frame + vector->hdr_len - 2 : NULL,
 582                            vector->pn, 0, &enc_len);
 583         if (enc == NULL) {
 584                 wpa_printf(MSG_ERROR, "Failed to encrypt GCMP frame");
 585                 return 1;
 586         }
 587
 588         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 589         if (os_memcmp(vector->encr, enc + vector->hdr_len + 8,
 590                       vector->payload_len) != 0) {
 591                 wpa_printf(MSG_ERROR, "GCMP test mpdu #%d enctypted data mismatch",
 592                            idx);
 593                 err++;
 594         }
 595         if (os_memcmp(vector->mic, enc + enc_len - sizeof(vector->mic),
 596                       sizeof(vector->mic)) != 0) {
 597                 wpa_printf(MSG_ERROR, "GCMP test mpdu #%d MIC mismatch", idx);
 598                 err++;
 599         }
 600         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 601         wpa_hexdump(MSG_INFO, "FCS", fcs, sizeof(fcs));
 602
 603         wpa_debug_level = MSG_INFO;
 604         plain = gcmp_decrypt(vector->tk, sizeof(vector->tk),
 605                              (const struct ieee80211_hdr *) enc,
 606                              enc + vector->hdr_len,
 607                              enc_len - vector->hdr_len, &plain_len);
 608         wpa_debug_level = MSG_EXCESSIVE;
 609         os_free(enc);
 610
 611         if (plain == NULL) {
 612                 wpa_printf(MSG_ERROR, "Failed to decrypt GCMP frame");
 613                 return 1;
 614         }
 615
 616         if (plain_len != vector->payload_len ||
 617             os_memcmp(plain, vector->frame + vector->hdr_len, plain_len) != 0) {
 618                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 619                             plain, plain_len);
 620                 err++;
 621         }
 622
 623         os_free(plain);
 624
 625         return err;
 626 }
 627
 628
 629 static int test_vector_gcmp(void)
 630 {
 631         int err = 0;
 632         int i;
 633
 634         for (i = 0; i < ARRAY_SIZE(gcmp_vectors); i++) {
 635                 if (run_gcmp(i + 1, &gcmp_vectors[i]))
 636                         err++;
 637
 638         }
 639
 640         return err;
 641 }
 642
 643
 644 static int test_vector_gcmp_256(void)
 645 {
 646         u8 tk[] = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
 647                     0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f,
 648                     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 649                     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 650         u8 pn[] = {
 651                 0x00, 0x89, 0x5F, 0x5F, 0x2B, 0x08
 652         };
 653         u8 frame[] = {
 654                 0x88, 0x48, 0x0b, 0x00, 0x0f, 0xd2, 0xe1, 0x28,
 655                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 656                 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08, 0x80, 0x33,
 657                 0x03, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
 658                 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
 659                 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
 660                 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
 661                 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
 662                 0x26, 0x27
 663         };
 664         u8 encr[] = {
 665                 0x88, 0x48, 0x0b, 0x00, 0x0f, 0xd2, 0xe1, 0x28,
 666                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 667                 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08, 0x80, 0x33,
 668                 0x03, 0x00, 0x08, 0x2b, 0x00, 0x20, 0x5f, 0x5f,
 669                 0x89, 0x00, 0x65, 0x83, 0x43, 0xc8, 0xb1, 0x44,
 670                 0x47, 0xd9, 0x21, 0x1d, 0xef, 0xd4, 0x6a, 0xd8,
 671                 0x9c, 0x71, 0x0c, 0x6f, 0xc3, 0x33, 0x33, 0x23,
 672                 0x6e, 0x39, 0x97, 0xb9, 0x17, 0x6a, 0x5a, 0x8b,
 673                 0xe7, 0x79, 0xb2, 0x12, 0x66, 0x55, 0x5e, 0x70,
 674                 0xad, 0x79, 0x11, 0x43, 0x16, 0x85, 0x90, 0x95,
 675                 0x47, 0x3d, 0x5b, 0x1b, 0xd5, 0x96, 0xb3, 0xde,
 676                 0xa3, 0xbf
 677         };
 678         u8 *enc, *plain;
 679         size_t enc_len, plain_len;
 680         u8 fcs[4];
 681         int err = 0;
 682
 683         wpa_printf(MSG_INFO, "\nIEEE P802.11ac/D7.0, M.11.1 GCMP-256 test vector\n");
 684
 685         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 686         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 687         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 26);
 688         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 26, sizeof(frame) - 26);
 689
 690         enc = gcmp_encrypt(tk, sizeof(tk), frame, sizeof(frame), 26, frame + 24,
 691                            pn, 0, &enc_len);
 692         if (enc == NULL) {
 693                 wpa_printf(MSG_ERROR, "Failed to encrypt GCMP frame");
 694                 return 1;
 695         }
 696
 697         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 698         if (enc_len != sizeof(encr) || os_memcmp(enc, encr, enc_len) != 0) {
 699                 wpa_printf(MSG_ERROR, "GCMP-256 test vector mismatch");
 700                 err++;
 701         }
 702         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 703         wpa_hexdump(MSG_INFO, "FCS", fcs, sizeof(fcs));
 704
 705         wpa_debug_level = MSG_INFO;
 706         plain = gcmp_decrypt(tk, sizeof(tk), (const struct ieee80211_hdr *) enc,
 707                              enc + 26, enc_len - 26, &plain_len);
 708         wpa_debug_level = MSG_EXCESSIVE;
 709         os_free(enc);
 710
 711         if (plain == NULL) {
 712                 wpa_printf(MSG_ERROR, "Failed to decrypt GCMP frame");
 713                 return 1;
 714         }
 715
 716         if (plain_len != sizeof(frame) - 26 ||
 717             os_memcmp(plain, frame + 26, plain_len) != 0) {
 718                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 719                             plain, plain_len);
 720                 err++;
 721         }
 722
 723         os_free(plain);
 724
 725         return err;
 726 }
 727
 728
 729 static int test_vector_ccmp_256(void)
 730 {
 731         u8 tk[] = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
 732                     0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f,
 733                     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 734                     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 735         u8 pn[] = { 0xB5, 0x03, 0x97, 0x76, 0xE7, 0x0C };
 736         u8 frame[] = {
 737                 0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
 738                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 739                 0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
 740                 0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
 741                 0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
 742                 0x7e, 0x78, 0xa0, 0x50
 743         };
 744         u8 encr[] = {
 745                 0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
 746                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 747                 0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
 748                 0x0c, 0xe7, 0x00, 0x20, 0x76, 0x97, 0x03, 0xb5,
 749                 0x6d, 0x15, 0x5d, 0x88, 0x32, 0x66, 0x82, 0x56,
 750                 0xd6, 0xa9, 0x2b, 0x78, 0xe1, 0x1d, 0x8e, 0x54,
 751                 0x49, 0x5d, 0xd1, 0x74, 0x80, 0xaa, 0x56, 0xc9,
 752                 0x49, 0x2e, 0x88, 0x2b, 0x97, 0x64, 0x2f, 0x80,
 753                 0xd5, 0x0f, 0xe9, 0x7b
 754
 755         };
 756         u8 *enc, *plain;
 757         size_t enc_len, plain_len;
 758         u8 fcs[4];
 759         int err = 0;
 760
 761         wpa_printf(MSG_INFO, "\nIEEE P802.11ac/D7.0, M.6.4 CCMP-256 test vector\n");
 762
 763         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 764         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 765         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 24);
 766         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 24, sizeof(frame) - 24);
 767
 768         enc = ccmp_256_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0,
 769                                &enc_len);
 770         if (enc == NULL) {
 771                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 772                 return 1;
 773         }
 774
 775         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 776         if (enc_len != sizeof(encr) || os_memcmp(enc, encr, enc_len) != 0) {
 777                 wpa_printf(MSG_ERROR, "CCMP-256 test vector mismatch");
 778                 err++;
 779         }
 780         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 781         wpa_hexdump(MSG_INFO, "FCS", fcs, sizeof(fcs));
 782
 783         wpa_debug_level = MSG_INFO;
 784         plain = ccmp_256_decrypt(tk, (const struct ieee80211_hdr *) enc,
 785                                  enc + 24, enc_len - 24, &plain_len);
 786         wpa_debug_level = MSG_EXCESSIVE;
 787         os_free(enc);
 788
 789         if (plain == NULL) {
 790                 wpa_printf(MSG_ERROR, "Failed to decrypt CCMP-256 frame");
 791                 return 1;
 792         }
 793
 794         if (plain_len != sizeof(frame) - 24 ||
 795             os_memcmp(plain, frame + 24, plain_len) != 0) {
 796                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 797                             plain, plain_len);
 798                 err++;
 799         }
 800
 801         os_free(plain);
 802
 803         return err;
 804 }
 805
 806
 807 static int test_vector_bip_gmac_128(void)
 808 {
 809         u8 igtk[] = {
 810                 0x4e, 0xa9, 0x54, 0x3e, 0x09, 0xcf, 0x2b, 0x1e,
 811                 0xca, 0x66, 0xff, 0xc5, 0x8b, 0xde, 0xcb, 0xcf
 812         };
 813         u8 ipn[] = { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 };
 814         u8 frame[] = {
 815                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 816                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 817                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 818                 0x02, 0x00
 819         };
 820         u8 res[] = {
 821                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 822                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 823                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 824                 0x02, 0x00, 0x4c, 0x18, 0x04, 0x00, 0x04, 0x00,
 825                 0x00, 0x00, 0x00, 0x00, 0x3e, 0xd8, 0x62, 0xfb,
 826                 0x0f, 0x33, 0x38, 0xdd, 0x33, 0x86, 0xc8, 0x97,
 827                 0xe2, 0xed, 0x05, 0x3d
 828         };
 829         u8 *prot;
 830         size_t prot_len;
 831         int err = 0;
 832
 833         wpa_printf(MSG_INFO, "\nIEEE P802.11ac/D7.0, M.9.1 BIP-GMAC-128 with broadcast "
 834                    "Deauthentication frame\n");
 835
 836         wpa_hexdump(MSG_INFO, "IGTK", igtk, sizeof(igtk));
 837         wpa_hexdump(MSG_INFO, "IPN", ipn, sizeof(ipn));
 838         wpa_hexdump(MSG_INFO, "Plaintext frame", frame, sizeof(frame));
 839
 840         prot = bip_gmac_protect(igtk, sizeof(igtk), frame, sizeof(frame),
 841                                 ipn, 4, &prot_len);
 842         if (prot == NULL) {
 843                 wpa_printf(MSG_ERROR, "Failed to protect BIP-GMAC-128 frame");
 844                 return 1;
 845         }
 846
 847         wpa_hexdump(MSG_INFO, "Protected MPDU (without FCS)", prot, prot_len);
 848         if (prot_len != sizeof(res) || os_memcmp(res, prot, prot_len) != 0) {
 849                 wpa_printf(MSG_ERROR, "BIP-GMAC-128 test vector mismatch");
 850                 err++;
 851         }
 852         os_free(prot);
 853
 854         return err;
 855 }
 856
 857
 858 static int test_vector_bip_gmac_256(void)
 859 {
 860         u8 igtk[] = {
 861                 0x4e, 0xa9, 0x54, 0x3e, 0x09, 0xcf, 0x2b, 0x1e,
 862                 0xca, 0x66, 0xff, 0xc5, 0x8b, 0xde, 0xcb, 0xcf,
 863                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 864                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
 865         };
 866         u8 ipn[] = { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 };
 867         u8 frame[] = {
 868                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 869                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 870                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 871                 0x02, 0x00
 872         };
 873         u8 res[] = {
 874                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 875                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 876                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 877                 0x02, 0x00, 0x4c, 0x18, 0x04, 0x00, 0x04, 0x00,
 878                 0x00, 0x00, 0x00, 0x00, 0x23, 0xbe, 0x59, 0xdc,
 879                 0xc7, 0x02, 0x2e, 0xe3, 0x83, 0x62, 0x7e, 0xbb,
 880                 0x10, 0x17, 0xdd, 0xfc
 881         };
 882         u8 *prot;
 883         size_t prot_len;
 884         int err = 0;
 885
 886         wpa_printf(MSG_INFO, "\nIEEE P802.11ac/D7.0, M.9.1 BIP-GMAC-256 with broadcast Deauthentication frame\n");
 887
 888         wpa_hexdump(MSG_INFO, "IGTK", igtk, sizeof(igtk));
 889         wpa_hexdump(MSG_INFO, "IPN", ipn, sizeof(ipn));
 890         wpa_hexdump(MSG_INFO, "Plaintext frame", frame, sizeof(frame));
 891
 892         prot = bip_gmac_protect(igtk, sizeof(igtk), frame, sizeof(frame),
 893                                 ipn, 4, &prot_len);
 894         if (prot == NULL) {
 895                 wpa_printf(MSG_ERROR, "Failed to protect BIP-GMAC-256 frame");
 896                 return 1;
 897         }
 898
 899         wpa_hexdump(MSG_INFO, "Protected MPDU (without FCS)", prot, prot_len);
 900         if (prot_len != sizeof(res) || os_memcmp(res, prot, prot_len) != 0) {
 901                 wpa_printf(MSG_ERROR, "BIP-GMAC-128 test vector mismatch");
 902                 err++;
 903         }
 904         os_free(prot);
 905
 906         return err;
 907 }
 908
 909
 910 int main(int argc, char *argv[])
 911 {
 912         int errors = 0;
 913
 914         wpa_debug_level = MSG_EXCESSIVE;
 915         wpa_debug_show_keys = 1;
 916
 917         if (os_program_init())
 918                 return -1;
 919
 920         test_vector_tkip();
 921         test_vector_ccmp();
 922         test_vector_ccmp_pv1();
 923         test_vector_bip();
 924         test_vector_ccmp_mgmt();
 925         errors += test_vector_gcmp();
 926         errors += test_vector_gcmp_256();
 927         errors += test_vector_ccmp_256();
 928         errors += test_vector_bip_gmac_128();
 929         errors += test_vector_bip_gmac_256();
 930
 931         if (errors)
 932                 wpa_printf(MSG_INFO, "One or more test vectors failed");
 933         os_program_deinit();
 934
 935         return errors ? -1 : 0;
 936 }