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 "wlantest.h"
  14
  15
  16 static void test_vector_tkip(void)
  17 {
  18         u8 tk[] = {
  19                 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
  20                 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12,
  21                 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78,
  22                 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34
  23         };
  24         u8 pn[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
  25         u8 frame[] = {
  26                 0x08, 0x42, 0x2c, 0x00, 0x02, 0x03, 0x04, 0x05,
  27                 0x06, 0x08, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  28                 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xd0, 0x02,
  29                 /* 0x00, 0x20, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, */
  30                 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00,
  31                 0x45, 0x00, 0x00, 0x54, 0x00, 0x00, 0x40, 0x00,
  32                 0x40, 0x01, 0xa5, 0x55, 0xc0, 0xa8, 0x0a, 0x02,
  33                 0xc0, 0xa8, 0x0a, 0x01, 0x08, 0x00, 0x3a, 0xb0,
  34                 0x00, 0x00, 0x00, 0x00, 0xcd, 0x4c, 0x05, 0x00,
  35                 0x00, 0x00, 0x00, 0x00, 0x08, 0x09, 0x0a, 0x0b,
  36                 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
  37                 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
  38                 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
  39                 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
  40                 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33,
  41                 0x34, 0x35, 0x36, 0x37,
  42                 /* 0x68, 0x81, 0xa3, 0xf3, 0xd6, 0x48, 0xd0, 0x3c */
  43         };
  44         u8 *enc, *plain;
  45         size_t enc_len, plain_len;
  46
  47         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.6.3 TKIP test "
  48                    "vector\n");
  49
  50         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
  51         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
  52         wpa_hexdump(MSG_INFO, "Plaintext MPDU", frame, sizeof(frame));
  53
  54         enc = tkip_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0, &enc_len);
  55         if (enc == NULL) {
  56                 wpa_printf(MSG_ERROR, "Failed to encrypt TKIP frame");
  57                 return;
  58         }
  59
  60         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
  61
  62         wpa_debug_level = MSG_INFO;
  63         plain = tkip_decrypt(tk, (const struct ieee80211_hdr *) enc,
  64                              enc + 24, enc_len - 24, &plain_len);
  65         wpa_debug_level = MSG_EXCESSIVE;
  66         os_free(enc);
  67
  68         if (plain == NULL) {
  69                 wpa_printf(MSG_ERROR, "Failed to decrypt TKIP frame");
  70                 return;
  71         }
  72
  73         if (plain_len != sizeof(frame) - 24 ||
  74             os_memcmp(plain, frame + 24, plain_len) != 0) {
  75                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
  76                             plain, plain_len);
  77         }
  78
  79         os_free(plain);
  80 }
  81
  82
  83 static void test_vector_ccmp(void)
  84 {
  85         u8 tk[] = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
  86                     0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f };
  87         u8 pn[] = { 0xB5, 0x03, 0x97, 0x76, 0xE7, 0x0C };
  88         u8 frame[] = {
  89                 0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
  90                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
  91                 0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
  92                 0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
  93                 0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
  94                 0x7e, 0x78, 0xa0, 0x50
  95         };
  96         u8 *enc, *plain;
  97         size_t enc_len, plain_len;
  98         u8 fcs[4];
  99
 100         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.6.4 CCMP test "
 101                    "vector\n");
 102
 103         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 104         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 105         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 24);
 106         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 24, sizeof(frame) - 24);
 107
 108         enc = ccmp_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0, &enc_len);
 109         if (enc == NULL) {
 110                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 111                 return;
 112         }
 113
 114         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 115         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 116         wpa_hexdump(MSG_INFO, "FCS", fcs, sizeof(fcs));
 117
 118         wpa_debug_level = MSG_INFO;
 119         plain = ccmp_decrypt(tk, (const struct ieee80211_hdr *) enc,
 120                              enc + 24, enc_len - 24, &plain_len);
 121         wpa_debug_level = MSG_EXCESSIVE;
 122         os_free(enc);
 123
 124         if (plain == NULL) {
 125                 wpa_printf(MSG_ERROR, "Failed to decrypt CCMP frame");
 126                 return;
 127         }
 128
 129         if (plain_len != sizeof(frame) - 24 ||
 130             os_memcmp(plain, frame + 24, plain_len) != 0) {
 131                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 132                             plain, plain_len);
 133         }
 134
 135         os_free(plain);
 136 }
 137
 138
 139 static void test_vector_bip(void)
 140 {
 141         u8 igtk[] = {
 142                 0x4e, 0xa9, 0x54, 0x3e, 0x09, 0xcf, 0x2b, 0x1e,
 143                 0xca, 0x66, 0xff, 0xc5, 0x8b, 0xde, 0xcb, 0xcf
 144         };
 145         u8 ipn[] = { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 };
 146         u8 frame[] = {
 147                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 148                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 149                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 150                 0x02, 0x00
 151         };
 152         u8 *prot;
 153         size_t prot_len;
 154
 155         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.9.1 BIP with broadcast "
 156                    "Deauthentication frame\n");
 157
 158         wpa_hexdump(MSG_INFO, "IGTK", igtk, sizeof(igtk));
 159         wpa_hexdump(MSG_INFO, "IPN", ipn, sizeof(ipn));
 160         wpa_hexdump(MSG_INFO, "Plaintext frame", frame, sizeof(frame));
 161
 162         prot = bip_protect(igtk, sizeof(igtk), frame, sizeof(frame),
 163                            ipn, 4, &prot_len);
 164         if (prot == NULL) {
 165                 wpa_printf(MSG_ERROR, "Failed to protect BIP frame");
 166                 return;
 167         }
 168
 169         wpa_hexdump(MSG_INFO, "Protected MPDU (without FCS)", prot, prot_len);
 170         os_free(prot);
 171 }
 172
 173
 174 static void test_vector_ccmp_mgmt(void)
 175 {
 176         u8 tk[] = { 0x66, 0xed, 0x21, 0x04, 0x2f, 0x9f, 0x26, 0xd7,
 177                     0x11, 0x57, 0x06, 0xe4, 0x04, 0x14, 0xcf, 0x2e };
 178         u8 pn[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
 179         u8 frame[] = {
 180                 0xc0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
 181                 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 182                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00,
 183                 0x02, 0x00
 184         };
 185         u8 *enc, *plain;
 186         size_t enc_len, plain_len;
 187
 188         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.9.2 CCMP with unicast "
 189                    "Deauthentication frame\n");
 190
 191         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 192         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 193         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 24);
 194         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 24, sizeof(frame) - 24);
 195
 196         enc = ccmp_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0, &enc_len);
 197         if (enc == NULL) {
 198                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 199                 return;
 200         }
 201
 202         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 203
 204         wpa_debug_level = MSG_INFO;
 205         plain = ccmp_decrypt(tk, (const struct ieee80211_hdr *) enc,
 206                              enc + 24, enc_len - 24, &plain_len);
 207         wpa_debug_level = MSG_EXCESSIVE;
 208         os_free(enc);
 209
 210         if (plain == NULL) {
 211                 wpa_printf(MSG_ERROR, "Failed to decrypt CCMP frame");
 212                 return;
 213         }
 214
 215         if (plain_len != sizeof(frame) - 24 ||
 216             os_memcmp(plain, frame + 24, plain_len) != 0) {
 217                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 218                             plain, plain_len);
 219         }
 220
 221         os_free(plain);
 222 }
 223
 224
 225 struct gcmp_test {
 226         u8 tk[16];
 227         u8 pn[6];
 228         u8 frame[300];
 229         size_t hdr_len;
 230         size_t payload_len;
 231         u8 mic[16];
 232         u8 encr[300];
 233 };
 234
 235 static const struct gcmp_test gcmp_vectors[] =
 236 {
 237         {
 238                 .tk = { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 239                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa },
 240                 .pn = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
 241                 .frame = {
 242                         0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 243                         0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 244                         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
 245
 246                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 247                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 248                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 249                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 250                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 251                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 252                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 253                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 254                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 255                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 256                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 257                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 258                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 259                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 260                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 261                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 262                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 263                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 264                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 265                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 266                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 267                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 268                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 269                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 270                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 271                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 272                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 273                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 274                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 275                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 276                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 277                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 278                 },
 279                 .hdr_len = 24,
 280                 .payload_len = 256,
 281                 .mic = {
 282                         0x80, 0xCB, 0x06, 0x62, 0xEA, 0x71, 0xAB, 0xFD,
 283                         0x9F, 0x04, 0xC7, 0xF8, 0x72, 0xF5, 0x80, 0x90 },
 284                 .encr = {
 285                         0x5F, 0x55, 0x78, 0xC1, 0x8F, 0x13, 0x7A, 0xD2,
 286                         0x79, 0xBF, 0x3F, 0x2B, 0x24, 0xC7, 0xBD, 0x8F,
 287                         0x27, 0x7A, 0x1B, 0xE6, 0x77, 0x0D, 0xA1, 0xD9,
 288                         0x8B, 0x70, 0xC6, 0xD2, 0x8A, 0xE0, 0x1C, 0x55,
 289                         0x9E, 0xCB, 0xA6, 0xA0, 0x1D, 0xB0, 0x67, 0xC5,
 290                         0xA2, 0x7E, 0x4D, 0xB0, 0x8C, 0xDA, 0xDC, 0x77,
 291                         0x52, 0xAD, 0x63, 0x7E, 0xAF, 0x0A, 0x18, 0xED,
 292                         0x13, 0xFB, 0xAA, 0x14, 0x3B, 0xAF, 0xEF, 0x18,
 293                         0xF8, 0xFB, 0xCE, 0x4C, 0x65, 0xE8, 0x6B, 0xD0,
 294                         0x2A, 0x87, 0xB6, 0x01, 0xB7, 0xEA, 0xB9, 0x3F,
 295                         0x2B, 0xBC, 0x87, 0x4C, 0x8A, 0x71, 0x05, 0x80,
 296                         0xF5, 0x02, 0x34, 0x1A, 0x6A, 0x53, 0x39, 0x31,
 297                         0x43, 0xDE, 0x4C, 0x9E, 0xC6, 0xA2, 0x86, 0xF1,
 298                         0x25, 0x71, 0x83, 0x78, 0xAE, 0xDC, 0x84, 0xEB,
 299                         0xA2, 0xB3, 0x0F, 0x5C, 0x28, 0xBB, 0x5D, 0x75,
 300                         0xC6, 0xB0, 0x25, 0x46, 0x6D, 0x06, 0x51, 0xC7,
 301                         0x22, 0xDC, 0x71, 0x15, 0x1F, 0x21, 0x2D, 0x68,
 302                         0x87, 0x82, 0x8A, 0x03, 0x82, 0xE9, 0x28, 0x8A,
 303                         0x7F, 0x43, 0xD5, 0x2B, 0x7D, 0x25, 0x08, 0x61,
 304                         0x57, 0x64, 0x69, 0x54, 0xBB, 0x43, 0xB5, 0x7E,
 305                         0xA5, 0x87, 0xA0, 0x25, 0xF4, 0x0C, 0xE7, 0x45,
 306                         0x11, 0xE4, 0xDD, 0x22, 0x85, 0xB4, 0x0B, 0xA3,
 307                         0xF3, 0xB9, 0x62, 0x62, 0xCB, 0xC2, 0x8C, 0x6A,
 308                         0xA7, 0xBE, 0x44, 0x3E, 0x7B, 0x41, 0xE1, 0xEB,
 309                         0xFF, 0x52, 0x48, 0x57, 0xA6, 0x81, 0x68, 0x97,
 310                         0x75, 0x01, 0x15, 0xB0, 0x23, 0x1A, 0xB7, 0xC2,
 311                         0x84, 0x72, 0xC0, 0x6D, 0xD0, 0xB4, 0x9B, 0xE9,
 312                         0xF3, 0x69, 0xA8, 0xC3, 0x9C, 0xCD, 0x0D, 0xB7,
 313                         0x98, 0x35, 0x10, 0xE1, 0xAE, 0x8F, 0x05, 0xD7,
 314                         0x75, 0x45, 0xE0, 0x23, 0x5C, 0xDB, 0xD6, 0x12,
 315                         0xF3, 0x15, 0x07, 0x54, 0xCE, 0xE5, 0xCE, 0x6A,
 316                         0x12, 0x25, 0xD9, 0x95, 0x25, 0x02, 0x6F, 0x74
 317                 }
 318         },
 319         {
 320                 .tk = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
 321                         0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f },
 322                 .pn = { 0x00, 0x89, 0x5F, 0x5F, 0x2B, 0x08 },
 323                 .frame = {
 324                         0x88, 0x48, 0x0b, 0x00, 0x0f, 0xd2, 0xe1, 0x28,
 325                         0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 326                         0x50, 0x30, 0xf1, 0x84, 0x44, 0x08, 0x80, 0x33,
 327                         0x03, 0x00,
 328
 329                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 330                         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 331                         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 332                         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 333                         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27
 334                 },
 335                 .hdr_len = 26,
 336                 .payload_len = 40,
 337                 .mic = {
 338                         0xde, 0xf6, 0x19, 0xc2, 0xa3, 0x74, 0xb6, 0xdf,
 339                         0x66, 0xff, 0xa5, 0x3b, 0x6c, 0x69, 0xd7, 0x9e },
 340                 .encr = {
 341                         0x60, 0xe9, 0x70, 0x0c, 0xc4, 0xd4, 0x0a, 0xc6,
 342                         0xd2, 0x88, 0xb2, 0x01, 0xc3, 0x8f, 0x5b, 0xf0,
 343                         0x8b, 0x80, 0x74, 0x42, 0x64, 0x0a, 0x15, 0x96,
 344                         0xe5, 0xdb, 0xda, 0xd4, 0x1d, 0x1f, 0x36, 0x23,
 345                         0xf4, 0x5d, 0x7a, 0x12, 0xdb, 0x7a, 0xfb, 0x23
 346                 }
 347         }
 348 };
 349
 350
 351 static int run_gcmp(int idx, const struct gcmp_test *vector)
 352 {
 353         u8 *enc, *plain;
 354         size_t enc_len, plain_len;
 355         u8 fcs[4];
 356         int err = 0;
 357
 358         wpa_printf(MSG_INFO,
 359                    "\nIEEE Std 802.11ad-2012, M.11.1 GCMP test mpdu #%d\n",
 360                    idx);
 361
 362         wpa_hexdump(MSG_INFO, "TK", vector->tk, sizeof(vector->tk));
 363         wpa_hexdump(MSG_INFO, "PN", vector->pn, sizeof(vector->pn));
 364         wpa_hexdump(MSG_INFO, "802.11 Header", vector->frame, vector->hdr_len);
 365         wpa_hexdump(MSG_INFO, "Plaintext Data",
 366                     vector->frame + vector->hdr_len,
 367                     vector->payload_len);
 368
 369         enc = gcmp_encrypt(vector->tk, sizeof(vector->tk),
 370                            vector->frame,
 371                            vector->hdr_len + vector->payload_len,
 372                            vector->hdr_len,
 373                            vector->hdr_len == 26 ?
 374                            vector->frame + vector->hdr_len - 2 : NULL,
 375                            vector->pn, 0, &enc_len);
 376         if (enc == NULL) {
 377                 wpa_printf(MSG_ERROR, "Failed to encrypt GCMP frame");
 378                 return 1;
 379         }
 380
 381         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 382         if (os_memcmp(vector->encr, enc + vector->hdr_len + 8,
 383                       vector->payload_len) != 0) {
 384                 wpa_printf(MSG_ERROR, "GCMP test mpdu #%d enctypted data mismatch",
 385                            idx);
 386                 err++;
 387         }
 388         if (os_memcmp(vector->mic, enc + enc_len - sizeof(vector->mic),
 389                       sizeof(vector->mic)) != 0) {
 390                 wpa_printf(MSG_ERROR, "GCMP test mpdu #%d MIC mismatch", idx);
 391                 err++;
 392         }
 393         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 394         wpa_hexdump(MSG_INFO, "FCS", fcs, sizeof(fcs));
 395
 396         wpa_debug_level = MSG_INFO;
 397         plain = gcmp_decrypt(vector->tk, sizeof(vector->tk),
 398                              (const struct ieee80211_hdr *) enc,
 399                              enc + vector->hdr_len,
 400                              enc_len - vector->hdr_len, &plain_len);
 401         wpa_debug_level = MSG_EXCESSIVE;
 402         os_free(enc);
 403
 404         if (plain == NULL) {
 405                 wpa_printf(MSG_ERROR, "Failed to decrypt GCMP frame");
 406                 return 1;
 407         }
 408
 409         if (plain_len != vector->payload_len ||
 410             os_memcmp(plain, vector->frame + vector->hdr_len, plain_len) != 0) {
 411                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 412                             plain, plain_len);
 413                 err++;
 414         }
 415
 416         os_free(plain);
 417
 418         return err;
 419 }
 420
 421
 422 static int test_vector_gcmp(void)
 423 {
 424         int err = 0;
 425         int i;
 426
 427         for (i = 0; i < ARRAY_SIZE(gcmp_vectors); i++) {
 428                 if (run_gcmp(i + 1, &gcmp_vectors[i]))
 429                         err++;
 430
 431         }
 432
 433         return err;
 434 }
 435
 436
 437 static int test_vector_gcmp_256(void)
 438 {
 439         u8 tk[] = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
 440                     0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f,
 441                     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 442                     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 443         u8 pn[] = {
 444                 0x00, 0x89, 0x5F, 0x5F, 0x2B, 0x08
 445         };
 446         u8 frame[] = {
 447                 0x88, 0x48, 0x0b, 0x00, 0x0f, 0xd2, 0xe1, 0x28,
 448                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 449                 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08, 0x80, 0x33,
 450                 0x03, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
 451                 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
 452                 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
 453                 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
 454                 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
 455                 0x26, 0x27
 456         };
 457         u8 encr[] = {
 458                 0x88, 0x48, 0x0b, 0x00, 0x0f, 0xd2, 0xe1, 0x28,
 459                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 460                 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08, 0x80, 0x33,
 461                 0x03, 0x00, 0x08, 0x2b, 0x00, 0x20, 0x5f, 0x5f,
 462                 0x89, 0x00, 0x65, 0x83, 0x43, 0xc8, 0xb1, 0x44,
 463                 0x47, 0xd9, 0x21, 0x1d, 0xef, 0xd4, 0x6a, 0xd8,
 464                 0x9c, 0x71, 0x0c, 0x6f, 0xc3, 0x33, 0x33, 0x23,
 465                 0x6e, 0x39, 0x97, 0xb9, 0x17, 0x6a, 0x5a, 0x8b,
 466                 0xe7, 0x79, 0xb2, 0x12, 0x66, 0x55, 0x5e, 0x70,
 467                 0xad, 0x79, 0x11, 0x43, 0x16, 0x85, 0x90, 0x95,
 468                 0x47, 0x3d, 0x5b, 0x1b, 0xd5, 0x96, 0xb3, 0xde,
 469                 0xa3, 0xbf
 470         };
 471         u8 *enc, *plain;
 472         size_t enc_len, plain_len;
 473         u8 fcs[4];
 474         int err = 0;
 475
 476         wpa_printf(MSG_INFO, "\nIEEE P802.11ac/D7.0, M.11.1 GCMP-256 test vector\n");
 477
 478         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 479         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 480         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 26);
 481         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 26, sizeof(frame) - 26);
 482
 483         enc = gcmp_encrypt(tk, sizeof(tk), frame, sizeof(frame), 26, frame + 24,
 484                            pn, 0, &enc_len);
 485         if (enc == NULL) {
 486                 wpa_printf(MSG_ERROR, "Failed to encrypt GCMP frame");
 487                 return 1;
 488         }
 489
 490         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 491         if (enc_len != sizeof(encr) || os_memcmp(enc, encr, enc_len) != 0) {
 492                 wpa_printf(MSG_ERROR, "GCMP-256 test vector mismatch");
 493                 err++;
 494         }
 495         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 496         wpa_hexdump(MSG_INFO, "FCS", fcs, sizeof(fcs));
 497
 498         wpa_debug_level = MSG_INFO;
 499         plain = gcmp_decrypt(tk, sizeof(tk), (const struct ieee80211_hdr *) enc,
 500                              enc + 26, enc_len - 26, &plain_len);
 501         wpa_debug_level = MSG_EXCESSIVE;
 502         os_free(enc);
 503
 504         if (plain == NULL) {
 505                 wpa_printf(MSG_ERROR, "Failed to decrypt GCMP frame");
 506                 return 1;
 507         }
 508
 509         if (plain_len != sizeof(frame) - 26 ||
 510             os_memcmp(plain, frame + 26, plain_len) != 0) {
 511                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 512                             plain, plain_len);
 513                 err++;
 514         }
 515
 516         os_free(plain);
 517
 518         return err;
 519 }
 520
 521
 522 static int test_vector_ccmp_256(void)
 523 {
 524         u8 tk[] = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
 525                     0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f,
 526                     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 527                     0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
 528         u8 pn[] = { 0xB5, 0x03, 0x97, 0x76, 0xE7, 0x0C };
 529         u8 frame[] = {
 530                 0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
 531                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 532                 0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
 533                 0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
 534                 0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
 535                 0x7e, 0x78, 0xa0, 0x50
 536         };
 537         u8 encr[] = {
 538                 0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
 539                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
 540                 0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
 541                 0x0c, 0xe7, 0x00, 0x20, 0x76, 0x97, 0x03, 0xb5,
 542                 0x6d, 0x15, 0x5d, 0x88, 0x32, 0x66, 0x82, 0x56,
 543                 0xd6, 0xa9, 0x2b, 0x78, 0xe1, 0x1d, 0x8e, 0x54,
 544                 0x49, 0x5d, 0xd1, 0x74, 0x80, 0xaa, 0x56, 0xc9,
 545                 0x49, 0x2e, 0x88, 0x2b, 0x97, 0x64, 0x2f, 0x80,
 546                 0xd5, 0x0f, 0xe9, 0x7b
 547
 548         };
 549         u8 *enc, *plain;
 550         size_t enc_len, plain_len;
 551         u8 fcs[4];
 552         int err = 0;
 553
 554         wpa_printf(MSG_INFO, "\nIEEE P802.11ac/D7.0, M.6.4 CCMP-256 test vector\n");
 555
 556         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 557         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 558         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 24);
 559         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 24, sizeof(frame) - 24);
 560
 561         enc = ccmp_256_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0,
 562                                &enc_len);
 563         if (enc == NULL) {
 564                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 565                 return 1;
 566         }
 567
 568         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 569         if (enc_len != sizeof(encr) || os_memcmp(enc, encr, enc_len) != 0) {
 570                 wpa_printf(MSG_ERROR, "CCMP-256 test vector mismatch");
 571                 err++;
 572         }
 573         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 574         wpa_hexdump(MSG_INFO, "FCS", fcs, sizeof(fcs));
 575
 576         wpa_debug_level = MSG_INFO;
 577         plain = ccmp_256_decrypt(tk, (const struct ieee80211_hdr *) enc,
 578                                  enc + 24, enc_len - 24, &plain_len);
 579         wpa_debug_level = MSG_EXCESSIVE;
 580         os_free(enc);
 581
 582         if (plain == NULL) {
 583                 wpa_printf(MSG_ERROR, "Failed to decrypt CCMP-256 frame");
 584                 return 1;
 585         }
 586
 587         if (plain_len != sizeof(frame) - 24 ||
 588             os_memcmp(plain, frame + 24, plain_len) != 0) {
 589                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 590                             plain, plain_len);
 591                 err++;
 592         }
 593
 594         os_free(plain);
 595
 596         return err;
 597 }
 598
 599
 600 static int test_vector_bip_gmac_128(void)
 601 {
 602         u8 igtk[] = {
 603                 0x4e, 0xa9, 0x54, 0x3e, 0x09, 0xcf, 0x2b, 0x1e,
 604                 0xca, 0x66, 0xff, 0xc5, 0x8b, 0xde, 0xcb, 0xcf
 605         };
 606         u8 ipn[] = { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 };
 607         u8 frame[] = {
 608                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 609                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 610                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 611                 0x02, 0x00
 612         };
 613         u8 res[] = {
 614                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 615                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 616                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 617                 0x02, 0x00, 0x4c, 0x18, 0x04, 0x00, 0x04, 0x00,
 618                 0x00, 0x00, 0x00, 0x00, 0x3e, 0xd8, 0x62, 0xfb,
 619                 0x0f, 0x33, 0x38, 0xdd, 0x33, 0x86, 0xc8, 0x97,
 620                 0xe2, 0xed, 0x05, 0x3d
 621         };
 622         u8 *prot;
 623         size_t prot_len;
 624         int err = 0;
 625
 626         wpa_printf(MSG_INFO, "\nIEEE P802.11ac/D7.0, M.9.1 BIP-GMAC-128 with broadcast "
 627                    "Deauthentication frame\n");
 628
 629         wpa_hexdump(MSG_INFO, "IGTK", igtk, sizeof(igtk));
 630         wpa_hexdump(MSG_INFO, "IPN", ipn, sizeof(ipn));
 631         wpa_hexdump(MSG_INFO, "Plaintext frame", frame, sizeof(frame));
 632
 633         prot = bip_gmac_protect(igtk, sizeof(igtk), frame, sizeof(frame),
 634                                 ipn, 4, &prot_len);
 635         if (prot == NULL) {
 636                 wpa_printf(MSG_ERROR, "Failed to protect BIP-GMAC-128 frame");
 637                 return 1;
 638         }
 639
 640         wpa_hexdump(MSG_INFO, "Protected MPDU (without FCS)", prot, prot_len);
 641         if (prot_len != sizeof(res) || os_memcmp(res, prot, prot_len) != 0) {
 642                 wpa_printf(MSG_ERROR, "BIP-GMAC-128 test vector mismatch");
 643                 err++;
 644         }
 645         os_free(prot);
 646
 647         return err;
 648 }
 649
 650
 651 static int test_vector_bip_gmac_256(void)
 652 {
 653         u8 igtk[] = {
 654                 0x4e, 0xa9, 0x54, 0x3e, 0x09, 0xcf, 0x2b, 0x1e,
 655                 0xca, 0x66, 0xff, 0xc5, 0x8b, 0xde, 0xcb, 0xcf,
 656                 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 657                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
 658         };
 659         u8 ipn[] = { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 };
 660         u8 frame[] = {
 661                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 662                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 663                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 664                 0x02, 0x00
 665         };
 666         u8 res[] = {
 667                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 668                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 669                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 670                 0x02, 0x00, 0x4c, 0x18, 0x04, 0x00, 0x04, 0x00,
 671                 0x00, 0x00, 0x00, 0x00, 0x23, 0xbe, 0x59, 0xdc,
 672                 0xc7, 0x02, 0x2e, 0xe3, 0x83, 0x62, 0x7e, 0xbb,
 673                 0x10, 0x17, 0xdd, 0xfc
 674         };
 675         u8 *prot;
 676         size_t prot_len;
 677         int err = 0;
 678
 679         wpa_printf(MSG_INFO, "\nIEEE P802.11ac/D7.0, M.9.1 BIP-GMAC-256 with broadcast Deauthentication frame\n");
 680
 681         wpa_hexdump(MSG_INFO, "IGTK", igtk, sizeof(igtk));
 682         wpa_hexdump(MSG_INFO, "IPN", ipn, sizeof(ipn));
 683         wpa_hexdump(MSG_INFO, "Plaintext frame", frame, sizeof(frame));
 684
 685         prot = bip_gmac_protect(igtk, sizeof(igtk), frame, sizeof(frame),
 686                                 ipn, 4, &prot_len);
 687         if (prot == NULL) {
 688                 wpa_printf(MSG_ERROR, "Failed to protect BIP-GMAC-256 frame");
 689                 return 1;
 690         }
 691
 692         wpa_hexdump(MSG_INFO, "Protected MPDU (without FCS)", prot, prot_len);
 693         if (prot_len != sizeof(res) || os_memcmp(res, prot, prot_len) != 0) {
 694                 wpa_printf(MSG_ERROR, "BIP-GMAC-128 test vector mismatch");
 695                 err++;
 696         }
 697         os_free(prot);
 698
 699         return err;
 700 }
 701
 702
 703 int main(int argc, char *argv[])
 704 {
 705         int errors = 0;
 706
 707         wpa_debug_level = MSG_EXCESSIVE;
 708         wpa_debug_show_keys = 1;
 709
 710         if (os_program_init())
 711                 return -1;
 712
 713         test_vector_tkip();
 714         test_vector_ccmp();
 715         test_vector_bip();
 716         test_vector_ccmp_mgmt();
 717         errors += test_vector_gcmp();
 718         errors += test_vector_gcmp_256();
 719         errors += test_vector_ccmp_256();
 720         errors += test_vector_bip_gmac_128();
 721         errors += test_vector_bip_gmac_256();
 722
 723         if (errors)
 724                 wpa_printf(MSG_INFO, "One or more test vectors failed");
 725         os_program_deinit();
 726
 727         return errors ? -1 : 0;
 728 }