err.no Git - linux-2.6/blob - net/ieee80211/ieee80211_crypt_tkip.c

   1 /*
   2  * Host AP crypt: host-based TKIP encryption implementation for Host AP driver
   3  *
   4  * Copyright (c) 2003-2004, Jouni Malinen <jkmaline@cc.hut.fi>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation. See README and COPYING for
   9  * more details.
  10  */
  11
  12 #include <linux/config.h>
  13 #include <linux/version.h>
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/slab.h>
  17 #include <linux/random.h>
  18 #include <linux/skbuff.h>
  19 #include <linux/netdevice.h>
  20 #include <linux/if_ether.h>
  21 #include <linux/if_arp.h>
  22 #include <asm/string.h>
  23
  24 #include <net/ieee80211.h>
  25
  26
  27 #include <linux/crypto.h>
  28 #include <asm/scatterlist.h>
  29 #include <linux/crc32.h>
  30
  31 MODULE_AUTHOR("Jouni Malinen");
  32 MODULE_DESCRIPTION("Host AP crypt: TKIP");
  33 MODULE_LICENSE("GPL");
  34
  35 struct ieee80211_tkip_data {
  36 #define TKIP_KEY_LEN 32
  37         u8 key[TKIP_KEY_LEN];
  38         int key_set;
  39
  40         u32 tx_iv32;
  41         u16 tx_iv16;
  42         u16 tx_ttak[5];
  43         int tx_phase1_done;
  44
  45         u32 rx_iv32;
  46         u16 rx_iv16;
  47         u16 rx_ttak[5];
  48         int rx_phase1_done;
  49         u32 rx_iv32_new;
  50         u16 rx_iv16_new;
  51
  52         u32 dot11RSNAStatsTKIPReplays;
  53         u32 dot11RSNAStatsTKIPICVErrors;
  54         u32 dot11RSNAStatsTKIPLocalMICFailures;
  55
  56         int key_idx;
  57
  58         struct crypto_tfm *tfm_arc4;
  59         struct crypto_tfm *tfm_michael;
  60
  61         /* scratch buffers for virt_to_page() (crypto API) */
  62         u8 rx_hdr[16], tx_hdr[16];
  63 };
  64
  65 static void * ieee80211_tkip_init(int key_idx)
  66 {
  67         struct ieee80211_tkip_data *priv;
  68
  69         priv = kmalloc(sizeof(*priv), GFP_ATOMIC);
  70         if (priv == NULL)
  71                 goto fail;
  72         memset(priv, 0, sizeof(*priv));
  73         priv->key_idx = key_idx;
  74
  75         priv->tfm_arc4 = crypto_alloc_tfm("arc4", 0);
  76         if (priv->tfm_arc4 == NULL) {
  77                 printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
  78                        "crypto API arc4\n");
  79                 goto fail;
  80         }
  81
  82         priv->tfm_michael = crypto_alloc_tfm("michael_mic", 0);
  83         if (priv->tfm_michael == NULL) {
  84                 printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
  85                        "crypto API michael_mic\n");
  86                 goto fail;
  87         }
  88
  89         return priv;
  90
  91 fail:
  92         if (priv) {
  93                 if (priv->tfm_michael)
  94                         crypto_free_tfm(priv->tfm_michael);
  95                 if (priv->tfm_arc4)
  96                         crypto_free_tfm(priv->tfm_arc4);
  97                 kfree(priv);
  98         }
  99
 100         return NULL;
 101 }
 102
 103
 104 static void ieee80211_tkip_deinit(void *priv)
 105 {
 106         struct ieee80211_tkip_data *_priv = priv;
 107         if (_priv && _priv->tfm_michael)
 108                 crypto_free_tfm(_priv->tfm_michael);
 109         if (_priv && _priv->tfm_arc4)
 110                 crypto_free_tfm(_priv->tfm_arc4);
 111         kfree(priv);
 112 }
 113
 114
 115 static inline u16 RotR1(u16 val)
 116 {
 117         return (val >> 1) | (val << 15);
 118 }
 119
 120
 121 static inline u8 Lo8(u16 val)
 122 {
 123         return val & 0xff;
 124 }
 125
 126
 127 static inline u8 Hi8(u16 val)
 128 {
 129         return val >> 8;
 130 }
 131
 132
 133 static inline u16 Lo16(u32 val)
 134 {
 135         return val & 0xffff;
 136 }
 137
 138
 139 static inline u16 Hi16(u32 val)
 140 {
 141         return val >> 16;
 142 }
 143
 144
 145 static inline u16 Mk16(u8 hi, u8 lo)
 146 {
 147         return lo | (((u16) hi) << 8);
 148 }
 149
 150
 151 static inline u16 Mk16_le(u16 *v)
 152 {
 153         return le16_to_cpu(*v);
 154 }
 155
 156
 157 static const u16 Sbox[256] =
 158 {
 159         0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
 160         0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
 161         0x8F45, 0x1F9D, 0x8940, 0xFA87, 0xEF15, 0xB2EB, 0x8EC9, 0xFB0B,
 162         0x41EC, 0xB367, 0x5FFD, 0x45EA, 0x23BF, 0x53F7, 0xE496, 0x9B5B,
 163         0x75C2, 0xE11C, 0x3DAE, 0x4C6A, 0x6C5A, 0x7E41, 0xF502, 0x834F,
 164         0x685C, 0x51F4, 0xD134, 0xF908, 0xE293, 0xAB73, 0x6253, 0x2A3F,
 165         0x080C, 0x9552, 0x4665, 0x9D5E, 0x3028, 0x37A1, 0x0A0F, 0x2FB5,
 166         0x0E09, 0x2436, 0x1B9B, 0xDF3D, 0xCD26, 0x4E69, 0x7FCD, 0xEA9F,
 167         0x121B, 0x1D9E, 0x5874, 0x342E, 0x362D, 0xDCB2, 0xB4EE, 0x5BFB,
 168         0xA4F6, 0x764D, 0xB761, 0x7DCE, 0x527B, 0xDD3E, 0x5E71, 0x1397,
 169         0xA6F5, 0xB968, 0x0000, 0xC12C, 0x4060, 0xE31F, 0x79C8, 0xB6ED,
 170         0xD4BE, 0x8D46, 0x67D9, 0x724B, 0x94DE, 0x98D4, 0xB0E8, 0x854A,
 171         0xBB6B, 0xC52A, 0x4FE5, 0xED16, 0x86C5, 0x9AD7, 0x6655, 0x1194,
 172         0x8ACF, 0xE910, 0x0406, 0xFE81, 0xA0F0, 0x7844, 0x25BA, 0x4BE3,
 173         0xA2F3, 0x5DFE, 0x80C0, 0x058A, 0x3FAD, 0x21BC, 0x7048, 0xF104,
 174         0x63DF, 0x77C1, 0xAF75, 0x4263, 0x2030, 0xE51A, 0xFD0E, 0xBF6D,
 175         0x814C, 0x1814, 0x2635, 0xC32F, 0xBEE1, 0x35A2, 0x88CC, 0x2E39,
 176         0x9357, 0x55F2, 0xFC82, 0x7A47, 0xC8AC, 0xBAE7, 0x322B, 0xE695,
 177         0xC0A0, 0x1998, 0x9ED1, 0xA37F, 0x4466, 0x547E, 0x3BAB, 0x0B83,
 178         0x8CCA, 0xC729, 0x6BD3, 0x283C, 0xA779, 0xBCE2, 0x161D, 0xAD76,
 179         0xDB3B, 0x6456, 0x744E, 0x141E, 0x92DB, 0x0C0A, 0x486C, 0xB8E4,
 180         0x9F5D, 0xBD6E, 0x43EF, 0xC4A6, 0x39A8, 0x31A4, 0xD337, 0xF28B,
 181         0xD532, 0x8B43, 0x6E59, 0xDAB7, 0x018C, 0xB164, 0x9CD2, 0x49E0,
 182         0xD8B4, 0xACFA, 0xF307, 0xCF25, 0xCAAF, 0xF48E, 0x47E9, 0x1018,
 183         0x6FD5, 0xF088, 0x4A6F, 0x5C72, 0x3824, 0x57F1, 0x73C7, 0x9751,
 184         0xCB23, 0xA17C, 0xE89C, 0x3E21, 0x96DD, 0x61DC, 0x0D86, 0x0F85,
 185         0xE090, 0x7C42, 0x71C4, 0xCCAA, 0x90D8, 0x0605, 0xF701, 0x1C12,
 186         0xC2A3, 0x6A5F, 0xAEF9, 0x69D0, 0x1791, 0x9958, 0x3A27, 0x27B9,
 187         0xD938, 0xEB13, 0x2BB3, 0x2233, 0xD2BB, 0xA970, 0x0789, 0x33A7,
 188         0x2DB6, 0x3C22, 0x1592, 0xC920, 0x8749, 0xAAFF, 0x5078, 0xA57A,
 189         0x038F, 0x59F8, 0x0980, 0x1A17, 0x65DA, 0xD731, 0x84C6, 0xD0B8,
 190         0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A,
 191 };
 192
 193
 194 static inline u16 _S_(u16 v)
 195 {
 196         u16 t = Sbox[Hi8(v)];
 197         return Sbox[Lo8(v)] ^ ((t << 8) | (t >> 8));
 198 }
 199
 200
 201 #define PHASE1_LOOP_COUNT 8
 202
 203 static void tkip_mixing_phase1(u16 *TTAK, const u8 *TK, const u8 *TA, u32 IV32)
 204 {
 205         int i, j;
 206
 207         /* Initialize the 80-bit TTAK from TSC (IV32) and TA[0..5] */
 208         TTAK[0] = Lo16(IV32);
 209         TTAK[1] = Hi16(IV32);
 210         TTAK[2] = Mk16(TA[1], TA[0]);
 211         TTAK[3] = Mk16(TA[3], TA[2]);
 212         TTAK[4] = Mk16(TA[5], TA[4]);
 213
 214         for (i = 0; i < PHASE1_LOOP_COUNT; i++) {
 215                 j = 2 * (i & 1);
 216                 TTAK[0] += _S_(TTAK[4] ^ Mk16(TK[1 + j], TK[0 + j]));
 217                 TTAK[1] += _S_(TTAK[0] ^ Mk16(TK[5 + j], TK[4 + j]));
 218                 TTAK[2] += _S_(TTAK[1] ^ Mk16(TK[9 + j], TK[8 + j]));
 219                 TTAK[3] += _S_(TTAK[2] ^ Mk16(TK[13 + j], TK[12 + j]));
 220                 TTAK[4] += _S_(TTAK[3] ^ Mk16(TK[1 + j], TK[0 + j])) + i;
 221         }
 222 }
 223
 224
 225 static void tkip_mixing_phase2(u8 *WEPSeed, const u8 *TK, const u16 *TTAK,
 226                                u16 IV16)
 227 {
 228         /* Make temporary area overlap WEP seed so that the final copy can be
 229          * avoided on little endian hosts. */
 230         u16 *PPK = (u16 *) &WEPSeed[4];
 231
 232         /* Step 1 - make copy of TTAK and bring in TSC */
 233         PPK[0] = TTAK[0];
 234         PPK[1] = TTAK[1];
 235         PPK[2] = TTAK[2];
 236         PPK[3] = TTAK[3];
 237         PPK[4] = TTAK[4];
 238         PPK[5] = TTAK[4] + IV16;
 239
 240         /* Step 2 - 96-bit bijective mixing using S-box */
 241         PPK[0] += _S_(PPK[5] ^ Mk16_le((u16 *) &TK[0]));
 242         PPK[1] += _S_(PPK[0] ^ Mk16_le((u16 *) &TK[2]));
 243         PPK[2] += _S_(PPK[1] ^ Mk16_le((u16 *) &TK[4]));
 244         PPK[3] += _S_(PPK[2] ^ Mk16_le((u16 *) &TK[6]));
 245         PPK[4] += _S_(PPK[3] ^ Mk16_le((u16 *) &TK[8]));
 246         PPK[5] += _S_(PPK[4] ^ Mk16_le((u16 *) &TK[10]));
 247
 248         PPK[0] += RotR1(PPK[5] ^ Mk16_le((u16 *) &TK[12]));
 249         PPK[1] += RotR1(PPK[0] ^ Mk16_le((u16 *) &TK[14]));
 250         PPK[2] += RotR1(PPK[1]);
 251         PPK[3] += RotR1(PPK[2]);
 252         PPK[4] += RotR1(PPK[3]);
 253         PPK[5] += RotR1(PPK[4]);
 254
 255         /* Step 3 - bring in last of TK bits, assign 24-bit WEP IV value
 256          * WEPSeed[0..2] is transmitted as WEP IV */
 257         WEPSeed[0] = Hi8(IV16);
 258         WEPSeed[1] = (Hi8(IV16) | 0x20) & 0x7F;
 259         WEPSeed[2] = Lo8(IV16);
 260         WEPSeed[3] = Lo8((PPK[5] ^ Mk16_le((u16 *) &TK[0])) >> 1);
 261
 262 #ifdef __BIG_ENDIAN
 263         {
 264                 int i;
 265                 for (i = 0; i < 6; i++)
 266                         PPK[i] = (PPK[i] << 8) | (PPK[i] >> 8);
 267         }
 268 #endif
 269 }
 270
 271 static int ieee80211_tkip_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
 272 {
 273         struct ieee80211_tkip_data *tkey = priv;
 274         int len;
 275         u8 rc4key[16], *pos, *icv;
 276         struct ieee80211_hdr *hdr;
 277         u32 crc;
 278         struct scatterlist sg;
 279
 280         if (skb_headroom(skb) < 8 || skb_tailroom(skb) < 4 ||
 281             skb->len < hdr_len)
 282                 return -1;
 283
 284         hdr = (struct ieee80211_hdr *) skb->data;
 285         if (!tkey->tx_phase1_done) {
 286                 tkip_mixing_phase1(tkey->tx_ttak, tkey->key, hdr->addr2,
 287                                    tkey->tx_iv32);
 288                 tkey->tx_phase1_done = 1;
 289         }
 290         tkip_mixing_phase2(rc4key, tkey->key, tkey->tx_ttak, tkey->tx_iv16);
 291
 292         len = skb->len - hdr_len;
 293         pos = skb_push(skb, 8);
 294         memmove(pos, pos + 8, hdr_len);
 295         pos += hdr_len;
 296         icv = skb_put(skb, 4);
 297
 298         *pos++ = rc4key[0];
 299         *pos++ = rc4key[1];
 300         *pos++ = rc4key[2];
 301         *pos++ = (tkey->key_idx << 6) | (1 << 5) /* Ext IV included */;
 302         *pos++ = tkey->tx_iv32 & 0xff;
 303         *pos++ = (tkey->tx_iv32 >> 8) & 0xff;
 304         *pos++ = (tkey->tx_iv32 >> 16) & 0xff;
 305         *pos++ = (tkey->tx_iv32 >> 24) & 0xff;
 306
 307         crc = ~crc32_le(~0, pos, len);
 308         icv[0] = crc;
 309         icv[1] = crc >> 8;
 310         icv[2] = crc >> 16;
 311         icv[3] = crc >> 24;
 312
 313         crypto_cipher_setkey(tkey->tfm_arc4, rc4key, 16);
 314         sg.page = virt_to_page(pos);
 315         sg.offset = offset_in_page(pos);
 316         sg.length = len + 4;
 317         crypto_cipher_encrypt(tkey->tfm_arc4, &sg, &sg, len + 4);
 318
 319         tkey->tx_iv16++;
 320         if (tkey->tx_iv16 == 0) {
 321                 tkey->tx_phase1_done = 0;
 322                 tkey->tx_iv32++;
 323         }
 324
 325         return 0;
 326 }
 327
 328 static int ieee80211_tkip_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
 329 {
 330         struct ieee80211_tkip_data *tkey = priv;
 331         u8 rc4key[16];
 332         u8 keyidx, *pos;
 333         u32 iv32;
 334         u16 iv16;
 335         struct ieee80211_hdr *hdr;
 336         u8 icv[4];
 337         u32 crc;
 338         struct scatterlist sg;
 339         int plen;
 340
 341         if (skb->len < hdr_len + 8 + 4)
 342                 return -1;
 343
 344         hdr = (struct ieee80211_hdr *) skb->data;
 345         pos = skb->data + hdr_len;
 346         keyidx = pos[3];
 347         if (!(keyidx & (1 << 5))) {
 348                 if (net_ratelimit()) {
 349                         printk(KERN_DEBUG "TKIP: received packet without ExtIV"
 350                                " flag from " MAC_FMT "\n", MAC_ARG(hdr->addr2));
 351                 }
 352                 return -2;
 353         }
 354         keyidx >>= 6;
 355         if (tkey->key_idx != keyidx) {
 356                 printk(KERN_DEBUG "TKIP: RX tkey->key_idx=%d frame "
 357                        "keyidx=%d priv=%p\n", tkey->key_idx, keyidx, priv);
 358                 return -6;
 359         }
 360         if (!tkey->key_set) {
 361                 if (net_ratelimit()) {
 362                         printk(KERN_DEBUG "TKIP: received packet from " MAC_FMT
 363                                " with keyid=%d that does not have a configured"
 364                                " key\n", MAC_ARG(hdr->addr2), keyidx);
 365                 }
 366                 return -3;
 367         }
 368         iv16 = (pos[0] << 8) | pos[2];
 369         iv32 = pos[4] | (pos[5] << 8) | (pos[6] << 16) | (pos[7] << 24);
 370         pos += 8;
 371
 372         if (iv32 < tkey->rx_iv32 ||
 373             (iv32 == tkey->rx_iv32 && iv16 <= tkey->rx_iv16)) {
 374                 if (net_ratelimit()) {
 375                         printk(KERN_DEBUG "TKIP: replay detected: STA=" MAC_FMT
 376                                " previous TSC %08x%04x received TSC "
 377                                "%08x%04x\n", MAC_ARG(hdr->addr2),
 378                                tkey->rx_iv32, tkey->rx_iv16, iv32, iv16);
 379                 }
 380                 tkey->dot11RSNAStatsTKIPReplays++;
 381                 return -4;
 382         }
 383
 384         if (iv32 != tkey->rx_iv32 || !tkey->rx_phase1_done) {
 385                 tkip_mixing_phase1(tkey->rx_ttak, tkey->key, hdr->addr2, iv32);
 386                 tkey->rx_phase1_done = 1;
 387         }
 388         tkip_mixing_phase2(rc4key, tkey->key, tkey->rx_ttak, iv16);
 389
 390         plen = skb->len - hdr_len - 12;
 391
 392         crypto_cipher_setkey(tkey->tfm_arc4, rc4key, 16);
 393         sg.page = virt_to_page(pos);
 394         sg.offset = offset_in_page(pos);
 395         sg.length = plen + 4;
 396         crypto_cipher_decrypt(tkey->tfm_arc4, &sg, &sg, plen + 4);
 397
 398         crc = ~crc32_le(~0, pos, plen);
 399         icv[0] = crc;
 400         icv[1] = crc >> 8;
 401         icv[2] = crc >> 16;
 402         icv[3] = crc >> 24;
 403         if (memcmp(icv, pos + plen, 4) != 0) {
 404                 if (iv32 != tkey->rx_iv32) {
 405                         /* Previously cached Phase1 result was already lost, so
 406                          * it needs to be recalculated for the next packet. */
 407                         tkey->rx_phase1_done = 0;
 408                 }
 409                 if (net_ratelimit()) {
 410                         printk(KERN_DEBUG "TKIP: ICV error detected: STA="
 411                                MAC_FMT "\n", MAC_ARG(hdr->addr2));
 412                 }
 413                 tkey->dot11RSNAStatsTKIPICVErrors++;
 414                 return -5;
 415         }
 416
 417         /* Update real counters only after Michael MIC verification has
 418          * completed */
 419         tkey->rx_iv32_new = iv32;
 420         tkey->rx_iv16_new = iv16;
 421
 422         /* Remove IV and ICV */
 423         memmove(skb->data + 8, skb->data, hdr_len);
 424         skb_pull(skb, 8);
 425         skb_trim(skb, skb->len - 4);
 426
 427         return keyidx;
 428 }
 429
 430
 431 static int michael_mic(struct ieee80211_tkip_data *tkey, u8 *key, u8 *hdr,
 432                        u8 *data, size_t data_len, u8 *mic)
 433 {
 434         struct scatterlist sg[2];
 435
 436         if (tkey->tfm_michael == NULL) {
 437                 printk(KERN_WARNING "michael_mic: tfm_michael == NULL\n");
 438                 return -1;
 439         }
 440         sg[0].page = virt_to_page(hdr);
 441         sg[0].offset = offset_in_page(hdr);
 442         sg[0].length = 16;
 443
 444         sg[1].page = virt_to_page(data);
 445         sg[1].offset = offset_in_page(data);
 446         sg[1].length = data_len;
 447
 448         crypto_digest_init(tkey->tfm_michael);
 449         crypto_digest_setkey(tkey->tfm_michael, key, 8);
 450         crypto_digest_update(tkey->tfm_michael, sg, 2);
 451         crypto_digest_final(tkey->tfm_michael, mic);
 452
 453         return 0;
 454 }
 455
 456 static void michael_mic_hdr(struct sk_buff *skb, u8 *hdr)
 457 {
 458         struct ieee80211_hdr *hdr11;
 459
 460         hdr11 = (struct ieee80211_hdr *) skb->data;
 461         switch (le16_to_cpu(hdr11->frame_ctl) &
 462                 (IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS)) {
 463         case IEEE80211_FCTL_TODS:
 464                 memcpy(hdr, hdr11->addr3, ETH_ALEN); /* DA */
 465                 memcpy(hdr + ETH_ALEN, hdr11->addr2, ETH_ALEN); /* SA */
 466                 break;
 467         case IEEE80211_FCTL_FROMDS:
 468                 memcpy(hdr, hdr11->addr1, ETH_ALEN); /* DA */
 469                 memcpy(hdr + ETH_ALEN, hdr11->addr3, ETH_ALEN); /* SA */
 470                 break;
 471         case IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS:
 472                 memcpy(hdr, hdr11->addr3, ETH_ALEN); /* DA */
 473                 memcpy(hdr + ETH_ALEN, hdr11->addr4, ETH_ALEN); /* SA */
 474                 break;
 475         case 0:
 476                 memcpy(hdr, hdr11->addr1, ETH_ALEN); /* DA */
 477                 memcpy(hdr + ETH_ALEN, hdr11->addr2, ETH_ALEN); /* SA */
 478                 break;
 479         }
 480
 481         hdr[12] = 0; /* priority */
 482         hdr[13] = hdr[14] = hdr[15] = 0; /* reserved */
 483 }
 484
 485
 486 static int ieee80211_michael_mic_add(struct sk_buff *skb, int hdr_len, void *priv)
 487 {
 488         struct ieee80211_tkip_data *tkey = priv;
 489         u8 *pos;
 490
 491         if (skb_tailroom(skb) < 8 || skb->len < hdr_len) {
 492                 printk(KERN_DEBUG "Invalid packet for Michael MIC add "
 493                        "(tailroom=%d hdr_len=%d skb->len=%d)\n",
 494                        skb_tailroom(skb), hdr_len, skb->len);
 495                 return -1;
 496         }
 497
 498         michael_mic_hdr(skb, tkey->tx_hdr);
 499         pos = skb_put(skb, 8);
 500         if (michael_mic(tkey, &tkey->key[16], tkey->tx_hdr,
 501                         skb->data + hdr_len, skb->len - 8 - hdr_len, pos))
 502                 return -1;
 503
 504         return 0;
 505 }
 506
 507
 508 #if WIRELESS_EXT >= 18
 509 static void ieee80211_michael_mic_failure(struct net_device *dev,
 510                                        struct ieee80211_hdr *hdr,
 511                                        int keyidx)
 512 {
 513         union iwreq_data wrqu;
 514         struct iw_michaelmicfailure ev;
 515
 516         /* TODO: needed parameters: count, keyid, key type, TSC */
 517         memset(&ev, 0, sizeof(ev));
 518         ev.flags = keyidx & IW_MICFAILURE_KEY_ID;
 519         if (hdr->addr1[0] & 0x01)
 520                 ev.flags |= IW_MICFAILURE_GROUP;
 521         else
 522                 ev.flags |= IW_MICFAILURE_PAIRWISE;
 523         ev.src_addr.sa_family = ARPHRD_ETHER;
 524         memcpy(ev.src_addr.sa_data, hdr->addr2, ETH_ALEN);
 525         memset(&wrqu, 0, sizeof(wrqu));
 526         wrqu.data.length = sizeof(ev);
 527         wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, (char *) &ev);
 528 }
 529 #elif WIRELESS_EXT >= 15
 530 static void ieee80211_michael_mic_failure(struct net_device *dev,
 531                                        struct ieee80211_hdr *hdr,
 532                                        int keyidx)
 533 {
 534         union iwreq_data wrqu;
 535         char buf[128];
 536
 537         /* TODO: needed parameters: count, keyid, key type, TSC */
 538         sprintf(buf, "MLME-MICHAELMICFAILURE.indication(keyid=%d %scast addr="
 539                 MAC_FMT ")", keyidx, hdr->addr1[0] & 0x01 ? "broad" : "uni",
 540                 MAC_ARG(hdr->addr2));
 541         memset(&wrqu, 0, sizeof(wrqu));
 542         wrqu.data.length = strlen(buf);
 543         wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
 544 }
 545 #else /* WIRELESS_EXT >= 15 */
 546 static inline void ieee80211_michael_mic_failure(struct net_device *dev,
 547                                               struct ieee80211_hdr *hdr,
 548                                               int keyidx)
 549 {
 550 }
 551 #endif /* WIRELESS_EXT >= 15 */
 552
 553
 554 static int ieee80211_michael_mic_verify(struct sk_buff *skb, int keyidx,
 555                                      int hdr_len, void *priv)
 556 {
 557         struct ieee80211_tkip_data *tkey = priv;
 558         u8 mic[8];
 559
 560         if (!tkey->key_set)
 561                 return -1;
 562
 563         michael_mic_hdr(skb, tkey->rx_hdr);
 564         if (michael_mic(tkey, &tkey->key[24], tkey->rx_hdr,
 565                         skb->data + hdr_len, skb->len - 8 - hdr_len, mic))
 566                 return -1;
 567         if (memcmp(mic, skb->data + skb->len - 8, 8) != 0) {
 568                 struct ieee80211_hdr *hdr;
 569                 hdr = (struct ieee80211_hdr *) skb->data;
 570                 printk(KERN_DEBUG "%s: Michael MIC verification failed for "
 571                        "MSDU from " MAC_FMT " keyidx=%d\n",
 572                        skb->dev ? skb->dev->name : "N/A", MAC_ARG(hdr->addr2),
 573                        keyidx);
 574                 if (skb->dev)
 575                         ieee80211_michael_mic_failure(skb->dev, hdr, keyidx);
 576                 tkey->dot11RSNAStatsTKIPLocalMICFailures++;
 577                 return -1;
 578         }
 579
 580         /* Update TSC counters for RX now that the packet verification has
 581          * completed. */
 582         tkey->rx_iv32 = tkey->rx_iv32_new;
 583         tkey->rx_iv16 = tkey->rx_iv16_new;
 584
 585         skb_trim(skb, skb->len - 8);
 586
 587         return 0;
 588 }
 589
 590
 591 static int ieee80211_tkip_set_key(void *key, int len, u8 *seq, void *priv)
 592 {
 593         struct ieee80211_tkip_data *tkey = priv;
 594         int keyidx;
 595         struct crypto_tfm *tfm = tkey->tfm_michael;
 596         struct crypto_tfm *tfm2 = tkey->tfm_arc4;
 597
 598         keyidx = tkey->key_idx;
 599         memset(tkey, 0, sizeof(*tkey));
 600         tkey->key_idx = keyidx;
 601         tkey->tfm_michael = tfm;
 602         tkey->tfm_arc4 = tfm2;
 603         if (len == TKIP_KEY_LEN) {
 604                 memcpy(tkey->key, key, TKIP_KEY_LEN);
 605                 tkey->key_set = 1;
 606                 tkey->tx_iv16 = 1; /* TSC is initialized to 1 */
 607                 if (seq) {
 608                         tkey->rx_iv32 = (seq[5] << 24) | (seq[4] << 16) |
 609                                 (seq[3] << 8) | seq[2];
 610                         tkey->rx_iv16 = (seq[1] << 8) | seq[0];
 611                 }
 612         } else if (len == 0)
 613                 tkey->key_set = 0;
 614         else
 615                 return -1;
 616
 617         return 0;
 618 }
 619
 620
 621 static int ieee80211_tkip_get_key(void *key, int len, u8 *seq, void *priv)
 622 {
 623         struct ieee80211_tkip_data *tkey = priv;
 624
 625         if (len < TKIP_KEY_LEN)
 626                 return -1;
 627
 628         if (!tkey->key_set)
 629                 return 0;
 630         memcpy(key, tkey->key, TKIP_KEY_LEN);
 631
 632         if (seq) {
 633                 /* Return the sequence number of the last transmitted frame. */
 634                 u16 iv16 = tkey->tx_iv16;
 635                 u32 iv32 = tkey->tx_iv32;
 636                 if (iv16 == 0)
 637                         iv32--;
 638                 iv16--;
 639                 seq[0] = tkey->tx_iv16;
 640                 seq[1] = tkey->tx_iv16 >> 8;
 641                 seq[2] = tkey->tx_iv32;
 642                 seq[3] = tkey->tx_iv32 >> 8;
 643                 seq[4] = tkey->tx_iv32 >> 16;
 644                 seq[5] = tkey->tx_iv32 >> 24;
 645         }
 646
 647         return TKIP_KEY_LEN;
 648 }
 649
 650
 651 static char * ieee80211_tkip_print_stats(char *p, void *priv)
 652 {
 653         struct ieee80211_tkip_data *tkip = priv;
 654         p += sprintf(p, "key[%d] alg=TKIP key_set=%d "
 655                      "tx_pn=%02x%02x%02x%02x%02x%02x "
 656                      "rx_pn=%02x%02x%02x%02x%02x%02x "
 657                      "replays=%d icv_errors=%d local_mic_failures=%d\n",
 658                      tkip->key_idx, tkip->key_set,
 659                      (tkip->tx_iv32 >> 24) & 0xff,
 660                      (tkip->tx_iv32 >> 16) & 0xff,
 661                      (tkip->tx_iv32 >> 8) & 0xff,
 662                      tkip->tx_iv32 & 0xff,
 663                      (tkip->tx_iv16 >> 8) & 0xff,
 664                      tkip->tx_iv16 & 0xff,
 665                      (tkip->rx_iv32 >> 24) & 0xff,
 666                      (tkip->rx_iv32 >> 16) & 0xff,
 667                      (tkip->rx_iv32 >> 8) & 0xff,
 668                      tkip->rx_iv32 & 0xff,
 669                      (tkip->rx_iv16 >> 8) & 0xff,
 670                      tkip->rx_iv16 & 0xff,
 671                      tkip->dot11RSNAStatsTKIPReplays,
 672                      tkip->dot11RSNAStatsTKIPICVErrors,
 673                      tkip->dot11RSNAStatsTKIPLocalMICFailures);
 674         return p;
 675 }
 676
 677
 678 static struct ieee80211_crypto_ops ieee80211_crypt_tkip = {
 679         .name                   = "TKIP",
 680         .init                   = ieee80211_tkip_init,
 681         .deinit                 = ieee80211_tkip_deinit,
 682         .encrypt_mpdu           = ieee80211_tkip_encrypt,
 683         .decrypt_mpdu           = ieee80211_tkip_decrypt,
 684         .encrypt_msdu           = ieee80211_michael_mic_add,
 685         .decrypt_msdu           = ieee80211_michael_mic_verify,
 686         .set_key                = ieee80211_tkip_set_key,
 687         .get_key                = ieee80211_tkip_get_key,
 688         .print_stats            = ieee80211_tkip_print_stats,
 689         .extra_prefix_len       = 4 + 4, /* IV + ExtIV */
 690         .extra_postfix_len      = 8 + 4, /* MIC + ICV */
 691         .owner                  = THIS_MODULE,
 692 };
 693
 694
 695 static int __init ieee80211_crypto_tkip_init(void)
 696 {
 697         return ieee80211_register_crypto_ops(&ieee80211_crypt_tkip);
 698 }
 699
 700
 701 static void __exit ieee80211_crypto_tkip_exit(void)
 702 {
 703         ieee80211_unregister_crypto_ops(&ieee80211_crypt_tkip);
 704 }
 705
 706
 707 module_init(ieee80211_crypto_tkip_init);
 708 module_exit(ieee80211_crypto_tkip_exit);