1 /*- 2 * Copyright (c) 2004 Sam Leffler, Errno Consulting 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * Alternatively, this software may be distributed under the terms of the 17 * GNU General Public License ("GPL") version 2 as published by the Free 18 * Software Foundation. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 * 31 * $FreeBSD$ 32 */ 33 34 /* 35 * WEP test module. 36 * 37 * Test vectors come from section I.7.2 of P802.11i/D7.0, October 2003. 38 * 39 * To use this tester load the net80211 layer (either as a module or 40 * by statically configuring it into your kernel), then insmod this 41 * module. It should automatically run all test cases and print 42 * information for each. To run one or more tests you can specify a 43 * tests parameter to the module that is a bit mask of the set of tests 44 * you want; e.g. insmod wep_test tests=7 will run only test mpdu's 45 * 1, 2, and 3. 46 */ 47 #include <sys/param.h> 48 #include <sys/kernel.h> 49 #include <sys/systm.h> 50 #include <sys/mbuf.h> 51 #include <sys/module.h> 52 53 #include <sys/socket.h> 54 55 #include <net/if.h> 56 #include <net/if_media.h> 57 58 #include <net80211/ieee80211_var.h> 59 60 /* 61 MPDU data 62 aa aa 03 00 00 00 08 00 45 00 00 4e 66 1a 00 00 80 11 be 64 0a 00 01 22 63 0a ff ff ff 00 89 00 89 00 3a 00 00 80 a6 01 10 00 01 00 00 00 00 00 00 64 20 45 43 45 4a 45 48 45 43 46 43 45 50 46 45 45 49 45 46 46 43 43 41 43 65 41 43 41 43 41 43 41 41 41 00 00 20 00 01 66 67 RC4 encryption is performed as follows: 68 17 69 18 Key fb 02 9e 30 31 32 33 34 70 Plaintext 71 aa aa 03 00 00 00 08 00 45 00 00 4e 66 1a 00 00 80 11 be 64 0a 00 01 72 22 0a ff ff ff 00 89 00 89 00 3a 00 00 80 a6 01 10 00 01 00 00 00 00 73 00 00 20 45 43 45 4a 45 48 45 43 46 43 45 50 46 45 45 49 45 46 46 43 74 43 41 43 41 43 41 43 41 43 41 41 41 00 00 20 00 01 1b d0 b6 04 75 Ciphertext 76 f6 9c 58 06 bd 6c e8 46 26 bc be fb 94 74 65 0a ad 1f 79 09 b0 f6 4d 77 5f 58 a5 03 a2 58 b7 ed 22 eb 0e a6 49 30 d3 a0 56 a5 57 42 fc ce 14 78 1d 48 5f 8a a8 36 de a1 8d f4 2c 53 80 80 5a d0 c6 1a 5d 6f 58 f4 10 79 40 b2 4b 7d 1a 69 38 56 ed 0d 43 98 e7 ae e3 bf 0e 2a 2c a8 f7 80 The plaintext consists of the MPDU data, followed by a 4-octet CRC-32 81 calculated over the MPDU data. 82 19 The expanded MPDU, after WEP encapsulation, is as follows: 83 20 84 21 IV fb 02 9e 80 85 MPDU data 86 f6 9c 58 06 bd 6c e8 46 26 bc be fb 94 74 65 0a ad 1f 79 09 b0 f6 4d 5f 58 a5 87 03 a2 58 b7 ed 22 eb 0e a6 49 30 d3 a0 56 a5 57 42 fc ce 14 1d 48 5f 8a a8 36 88 de a1 8d f4 2c 53 80 80 5a d0 c6 1a 5d 6f 58 f4 10 40 b2 4b 7d 1a 69 38 56 ed 89 0d 43 98 e7 ae e3 bf 0e 90 ICV 2a 2c a8 f7 91 */ 92 static const u_int8_t test1_key[] = { /* TK (w/o IV) */ 93 0x30, 0x31, 0x32, 0x33, 0x34, 94 }; 95 static const u_int8_t test1_plaintext[] = { /* Plaintext MPDU */ 96 0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28, /* 802.11 Header */ 97 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08, 98 0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33, 99 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, /* Plaintext data */ 100 0x45, 0x00, 0x00, 0x4e, 0x66, 0x1a, 0x00, 0x00, 101 0x80, 0x11, 0xbe, 0x64, 0x0a, 0x00, 0x01, 0x22, 102 0x0a, 0xff, 0xff, 0xff, 0x00, 0x89, 0x00, 0x89, 103 0x00, 0x3a, 0x00, 0x00, 0x80, 0xa6, 0x01, 0x10, 104 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 105 0x20, 0x45, 0x43, 0x45, 0x4a, 0x45, 0x48, 0x45, 106 0x43, 0x46, 0x43, 0x45, 0x50, 0x46, 0x45, 0x45, 107 0x49, 0x45, 0x46, 0x46, 0x43, 0x43, 0x41, 0x43, 108 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x41, 109 0x41, 0x00, 0x00, 0x20, 0x00, 0x01, 110 }; 111 static const u_int8_t test1_encrypted[] = { /* Encrypted MPDU */ 112 0x08, 0x48, 0xc3, 0x2c, 0x0f, 0xd2, 0xe1, 0x28, 113 0xa5, 0x7c, 0x50, 0x30, 0xf1, 0x84, 0x44, 0x08, 114 0xab, 0xae, 0xa5, 0xb8, 0xfc, 0xba, 0x80, 0x33, 115 0xfb, 0x02, 0x9e, 0x80, 0xf6, 0x9c, 0x58, 0x06, 116 0xbd, 0x6c, 0xe8, 0x46, 0x26, 0xbc, 0xbe, 0xfb, 117 0x94, 0x74, 0x65, 0x0a, 0xad, 0x1f, 0x79, 0x09, 118 0xb0, 0xf6, 0x4d, 0x5f, 0x58, 0xa5, 0x03, 0xa2, 119 0x58, 0xb7, 0xed, 0x22, 0xeb, 0x0e, 0xa6, 0x49, 120 0x30, 0xd3, 0xa0, 0x56, 0xa5, 0x57, 0x42, 0xfc, 121 0xce, 0x14, 0x1d, 0x48, 0x5f, 0x8a, 0xa8, 0x36, 122 0xde, 0xa1, 0x8d, 0xf4, 0x2c, 0x53, 0x80, 0x80, 123 0x5a, 0xd0, 0xc6, 0x1a, 0x5d, 0x6f, 0x58, 0xf4, 124 0x10, 0x40, 0xb2, 0x4b, 0x7d, 0x1a, 0x69, 0x38, 125 0x56, 0xed, 0x0d, 0x43, 0x98, 0xe7, 0xae, 0xe3, 126 0xbf, 0x0e, 0x2a, 0x2c, 0xa8, 0xf7, 127 }; 128 129 /* XXX fix byte order of iv */ 130 #define TEST(n,name,cipher,keyix,iv0,iv1,iv2,iv3) { \ 131 name, IEEE80211_CIPHER_##cipher,keyix, { iv2,iv1,iv0,iv3 }, \ 132 test##n##_key, sizeof(test##n##_key), \ 133 test##n##_plaintext, sizeof(test##n##_plaintext), \ 134 test##n##_encrypted, sizeof(test##n##_encrypted) \ 135 } 136 137 struct ciphertest { 138 const char *name; 139 int cipher; 140 int keyix; 141 u_int8_t iv[4]; 142 const u_int8_t *key; 143 size_t key_len; 144 const u_int8_t *plaintext; 145 size_t plaintext_len; 146 const u_int8_t *encrypted; 147 size_t encrypted_len; 148 } weptests[] = { 149 TEST(1, "WEP test mpdu 1", WEP, 2, 0xfb, 0x02, 0x9e, 0x80), 150 }; 151 152 static void 153 dumpdata(const char *tag, const void *p, size_t len) 154 { 155 int i; 156 157 printf("%s: 0x%p len %u", tag, p, len); 158 for (i = 0; i < len; i++) { 159 if ((i % 16) == 0) 160 printf("\n%03d:", i); 161 printf(" %02x", ((const u_int8_t *)p)[i]); 162 } 163 printf("\n"); 164 } 165 166 static void 167 cmpfail(const void *gen, size_t genlen, const void *ref, size_t reflen) 168 { 169 int i; 170 171 for (i = 0; i < genlen; i++) 172 if (((const u_int8_t *)gen)[i] != ((const u_int8_t *)ref)[i]) { 173 printf("first difference at byte %u\n", i); 174 break; 175 } 176 dumpdata("Generated", gen, genlen); 177 dumpdata("Reference", ref, reflen); 178 } 179 180 struct wep_ctx_hw { /* for use with h/w support */ 181 struct ieee80211com *wc_ic; /* for diagnostics */ 182 u_int32_t wc_iv; /* initial vector for crypto */ 183 }; 184 185 static int 186 runtest(struct ieee80211com *ic, struct ciphertest *t) 187 { 188 struct ieee80211_key key; 189 struct mbuf *m = NULL; 190 const struct ieee80211_cipher *cip; 191 u_int8_t mac[IEEE80211_ADDR_LEN]; 192 struct wep_ctx_hw *ctx; 193 194 printf("%s: ", t->name); 195 196 /* 197 * Setup key. 198 */ 199 memset(&key, 0, sizeof(key)); 200 key.wk_flags = IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV; 201 key.wk_cipher = &ieee80211_cipher_none; 202 if (!ieee80211_crypto_newkey(ic, t->cipher, &key)) { 203 printf("FAIL: ieee80211_crypto_newkey failed\n"); 204 goto bad; 205 } 206 207 memcpy(key.wk_key, t->key, t->key_len); 208 key.wk_keylen = t->key_len; 209 if (!ieee80211_crypto_setkey(ic, &key, mac)) { 210 printf("FAIL: ieee80211_crypto_setkey failed\n"); 211 goto bad; 212 } 213 cip = key.wk_cipher; 214 215 /* 216 * Craft frame from plaintext data. 217 */ 218 cip = key.wk_cipher; 219 m = m_getcl(M_NOWAIT, MT_HEADER, M_PKTHDR); 220 memcpy(mtod(m, void *), t->encrypted, t->encrypted_len); 221 m->m_len = t->encrypted_len; 222 m->m_pkthdr.len = m->m_len; 223 224 /* 225 * Decrypt frame. 226 */ 227 if (!cip->ic_decap(&key, m)) { 228 printf("FAIL: wep decap failed\n"); 229 cmpfail(mtod(m, const void *), m->m_pkthdr.len, 230 t->plaintext, t->plaintext_len); 231 goto bad; 232 } 233 /* 234 * Verify: frame length, frame contents. 235 */ 236 if (m->m_pkthdr.len != t->plaintext_len) { 237 printf("FAIL: decap botch; length mismatch\n"); 238 cmpfail(mtod(m, const void *), m->m_pkthdr.len, 239 t->plaintext, t->plaintext_len); 240 goto bad; 241 } else if (memcmp(mtod(m, const void *), t->plaintext, t->plaintext_len)) { 242 printf("FAIL: decap botch; data does not compare\n"); 243 cmpfail(mtod(m, const void *), m->m_pkthdr.len, 244 t->plaintext, sizeof(t->plaintext)); 245 goto bad; 246 } 247 248 /* 249 * Encrypt frame. 250 */ 251 ctx = (struct wep_ctx_hw *) key.wk_private; 252 memcpy(&ctx->wc_iv, t->iv, sizeof(t->iv)); /* for encap/encrypt */ 253 if (!cip->ic_encap(&key, m, t->keyix<<6)) { 254 printf("FAIL: wep encap failed\n"); 255 goto bad; 256 } 257 /* 258 * Verify: frame length, frame contents. 259 */ 260 if (m->m_pkthdr.len != t->encrypted_len) { 261 printf("FAIL: encap data length mismatch\n"); 262 cmpfail(mtod(m, const void *), m->m_pkthdr.len, 263 t->encrypted, t->encrypted_len); 264 goto bad; 265 } else if (memcmp(mtod(m, const void *), t->encrypted, m->m_pkthdr.len)) { 266 printf("FAIL: encrypt data does not compare\n"); 267 cmpfail(mtod(m, const void *), m->m_pkthdr.len, 268 t->encrypted, t->encrypted_len); 269 dumpdata("Plaintext", t->plaintext, t->plaintext_len); 270 goto bad; 271 } 272 m_freem(m); 273 ieee80211_crypto_delkey(ic, &key); 274 printf("PASS\n"); 275 return 1; 276 bad: 277 if (m != NULL) 278 m_freem(m); 279 ieee80211_crypto_delkey(ic, &key); 280 return 0; 281 } 282 283 /* 284 * Module glue. 285 */ 286 287 static int tests = -1; 288 static int debug = 0; 289 290 static int 291 init_crypto_wep_test(void) 292 { 293 #define N(a) (sizeof(a)/sizeof(a[0])) 294 struct ieee80211com ic; 295 int i, pass, total; 296 297 memset(&ic, 0, sizeof(ic)); 298 if (debug) 299 ic.ic_debug = IEEE80211_MSG_CRYPTO; 300 ieee80211_crypto_attach(&ic); 301 pass = 0; 302 total = 0; 303 for (i = 0; i < N(weptests); i++) 304 if (tests & (1<<i)) { 305 total++; 306 pass += runtest(&ic, &weptests[i]); 307 } 308 printf("%u of %u 802.11i WEP test vectors passed\n", pass, total); 309 ieee80211_crypto_detach(&ic); 310 return (pass == total ? 0 : -1); 311 #undef N 312 } 313 314 static int 315 test_wep_modevent(module_t mod, int type, void *unused) 316 { 317 switch (type) { 318 case MOD_LOAD: 319 (void) init_crypto_wep_test(); 320 return 0; 321 case MOD_UNLOAD: 322 return 0; 323 } 324 return EINVAL; 325 } 326 327 static moduledata_t test_wep_mod = { 328 "test_wep", 329 test_wep_modevent, 330 0 331 }; 332 DECLARE_MODULE(test_wep, test_wep_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 333 MODULE_VERSION(test_wep, 1); 334 MODULE_DEPEND(test_wep, wlan, 1, 1, 1); 335