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