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 extern int wpa_debug_level;
  17 extern int wpa_debug_show_keys;
  18
  19
  20 static void test_vector_tkip(void)
  21 {
  22         u8 tk[] = {
  23                 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
  24                 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12,
  25                 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78,
  26                 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34
  27         };
  28         u8 pn[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
  29         u8 frame[] = {
  30                 0x08, 0x42, 0x2c, 0x00, 0x02, 0x03, 0x04, 0x05,
  31                 0x06, 0x08, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  32                 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0xd0, 0x02,
  33                 /* 0x00, 0x20, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, */
  34                 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00,
  35                 0x45, 0x00, 0x00, 0x54, 0x00, 0x00, 0x40, 0x00,
  36                 0x40, 0x01, 0xa5, 0x55, 0xc0, 0xa8, 0x0a, 0x02,
  37                 0xc0, 0xa8, 0x0a, 0x01, 0x08, 0x00, 0x3a, 0xb0,
  38                 0x00, 0x00, 0x00, 0x00, 0xcd, 0x4c, 0x05, 0x00,
  39                 0x00, 0x00, 0x00, 0x00, 0x08, 0x09, 0x0a, 0x0b,
  40                 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
  41                 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
  42                 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
  43                 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
  44                 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33,
  45                 0x34, 0x35, 0x36, 0x37,
  46                 /* 0x68, 0x81, 0xa3, 0xf3, 0xd6, 0x48, 0xd0, 0x3c */
  47         };
  48         u8 *enc, *plain;
  49         size_t enc_len, plain_len;
  50
  51         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.6.3 TKIP test "
  52                    "vector\n");
  53
  54         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
  55         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
  56         wpa_hexdump(MSG_INFO, "Plaintext MPDU", frame, sizeof(frame));
  57
  58         enc = tkip_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0, &enc_len);
  59         if (enc == NULL) {
  60                 wpa_printf(MSG_ERROR, "Failed to encrypt TKIP frame");
  61                 return;
  62         }
  63
  64         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
  65
  66         wpa_debug_level = MSG_INFO;
  67         plain = tkip_decrypt(tk, (const struct ieee80211_hdr *) enc,
  68                              enc + 24, enc_len - 24, &plain_len);
  69         wpa_debug_level = MSG_EXCESSIVE;
  70         os_free(enc);
  71
  72         if (plain == NULL) {
  73                 wpa_printf(MSG_ERROR, "Failed to decrypt TKIP frame");
  74                 return;
  75         }
  76
  77         if (plain_len != sizeof(frame) - 24 ||
  78             os_memcmp(plain, frame + 24, plain_len) != 0) {
  79                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
  80                             plain, plain_len);
  81         }
  82
  83         os_free(plain);
  84 }
  85
  86
  87 static void test_vector_ccmp(void)
  88 {
  89         u8 tk[] = { 0xc9, 0x7c, 0x1f, 0x67, 0xce, 0x37, 0x11, 0x85,
  90                     0x51, 0x4a, 0x8a, 0x19, 0xf2, 0xbd, 0xd5, 0x2f };
  91         u8 pn[] = { 0xB5, 0x03, 0x97, 0x76, 0xE7, 0x0C };
  92         u8 frame[] = {
  93                 0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28,
  94                 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08,
  95                 0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33,
  96                 0xf8, 0xba, 0x1a, 0x55, 0xd0, 0x2f, 0x85, 0xae,
  97                 0x96, 0x7b, 0xb6, 0x2f, 0xb6, 0xcd, 0xa8, 0xeb,
  98                 0x7e, 0x78, 0xa0, 0x50
  99         };
 100         u8 *enc, *plain;
 101         size_t enc_len, plain_len;
 102         u8 fcs[4];
 103
 104         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.6.4 CCMP test "
 105                    "vector\n");
 106
 107         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 108         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 109         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 24);
 110         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 24, sizeof(frame) - 24);
 111
 112         enc = ccmp_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0, &enc_len);
 113         if (enc == NULL) {
 114                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 115                 return;
 116         }
 117
 118         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 119         WPA_PUT_LE32(fcs, crc32(enc, enc_len));
 120         wpa_hexdump(MSG_INFO, "FCS", fcs, sizeof(fcs));
 121
 122         wpa_debug_level = MSG_INFO;
 123         plain = ccmp_decrypt(tk, (const struct ieee80211_hdr *) enc,
 124                              enc + 24, enc_len - 24, &plain_len);
 125         wpa_debug_level = MSG_EXCESSIVE;
 126         os_free(enc);
 127
 128         if (plain == NULL) {
 129                 wpa_printf(MSG_ERROR, "Failed to decrypt CCMP frame");
 130                 return;
 131         }
 132
 133         if (plain_len != sizeof(frame) - 24 ||
 134             os_memcmp(plain, frame + 24, plain_len) != 0) {
 135                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 136                             plain, plain_len);
 137         }
 138
 139         os_free(plain);
 140 }
 141
 142
 143 static void test_vector_bip(void)
 144 {
 145         u8 igtk[] = {
 146                 0x4e, 0xa9, 0x54, 0x3e, 0x09, 0xcf, 0x2b, 0x1e,
 147                 0xca, 0x66, 0xff, 0xc5, 0x8b, 0xde, 0xcb, 0xcf
 148         };
 149         u8 ipn[] = { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00 };
 150         u8 frame[] = {
 151                 0xc0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 152                 0xff, 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 153                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
 154                 0x02, 0x00
 155         };
 156         u8 *prot;
 157         size_t prot_len;
 158
 159         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.9.1 BIP with broadcast "
 160                    "Deauthentication frame\n");
 161
 162         wpa_hexdump(MSG_INFO, "IGTK", igtk, sizeof(igtk));
 163         wpa_hexdump(MSG_INFO, "IPN", ipn, sizeof(ipn));
 164         wpa_hexdump(MSG_INFO, "Plaintext frame", frame, sizeof(frame));
 165
 166         prot = bip_protect(igtk, frame, sizeof(frame), ipn, 4, &prot_len);
 167         if (prot == NULL) {
 168                 wpa_printf(MSG_ERROR, "Failed to protect BIP frame");
 169                 return;
 170         }
 171
 172         wpa_hexdump(MSG_INFO, "Protected MPDU (without FCS)", prot, prot_len);
 173         os_free(prot);
 174 }
 175
 176
 177 static void test_vector_ccmp_mgmt(void)
 178 {
 179         u8 tk[] = { 0x66, 0xed, 0x21, 0x04, 0x2f, 0x9f, 0x26, 0xd7,
 180                     0x11, 0x57, 0x06, 0xe4, 0x04, 0x14, 0xcf, 0x2e };
 181         u8 pn[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
 182         u8 frame[] = {
 183                 0xc0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
 184                 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
 185                 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00,
 186                 0x02, 0x00
 187         };
 188         u8 *enc, *plain;
 189         size_t enc_len, plain_len;
 190
 191         wpa_printf(MSG_INFO, "\nIEEE Std 802.11-2012, M.9.2 CCMP with unicast "
 192                    "Deauthentication frame\n");
 193
 194         wpa_hexdump(MSG_INFO, "TK", tk, sizeof(tk));
 195         wpa_hexdump(MSG_INFO, "PN", pn, sizeof(pn));
 196         wpa_hexdump(MSG_INFO, "802.11 Header", frame, 24);
 197         wpa_hexdump(MSG_INFO, "Plaintext Data", frame + 24, sizeof(frame) - 24);
 198
 199         enc = ccmp_encrypt(tk, frame, sizeof(frame), 24, NULL, pn, 0, &enc_len);
 200         if (enc == NULL) {
 201                 wpa_printf(MSG_ERROR, "Failed to encrypt CCMP frame");
 202                 return;
 203         }
 204
 205         wpa_hexdump(MSG_INFO, "Encrypted MPDU (without FCS)", enc, enc_len);
 206
 207         wpa_debug_level = MSG_INFO;
 208         plain = ccmp_decrypt(tk, (const struct ieee80211_hdr *) enc,
 209                              enc + 24, enc_len - 24, &plain_len);
 210         wpa_debug_level = MSG_EXCESSIVE;
 211         os_free(enc);
 212
 213         if (plain == NULL) {
 214                 wpa_printf(MSG_ERROR, "Failed to decrypt CCMP frame");
 215                 return;
 216         }
 217
 218         if (plain_len != sizeof(frame) - 24 ||
 219             os_memcmp(plain, frame + 24, plain_len) != 0) {
 220                 wpa_hexdump(MSG_ERROR, "Decryption result did not match",
 221                             plain, plain_len);
 222         }
 223
 224         os_free(plain);
 225 }
 226
 227
 228 int main(int argc, char *argv[])
 229 {
 230         wpa_debug_level = MSG_EXCESSIVE;
 231         wpa_debug_show_keys = 1;
 232
 233         if (os_program_init())
 234                 return -1;
 235
 236         test_vector_tkip();
 237         test_vector_ccmp();
 238         test_vector_bip();
 239         test_vector_ccmp_mgmt();
 240
 241         os_program_deinit();
 242
 243         return 0;
 244 }