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