?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI / bus: Leave modalias empty for devices which are not present
[linux/fpc-iii.git] / net / mac80211 / wpa.c
blobe19ea1c53afa13ef4aa15bcb592e6247c81a916b
1 /*
2 * Copyright 2002-2004, Instant802 Networks, Inc.
3 * Copyright 2008, Jouni Malinen <j@w1.fi>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 */
9
10 #include <linux/netdevice.h>
11 #include <linux/types.h>
12 #include <linux/skbuff.h>
13 #include <linux/compiler.h>
14 #include <linux/ieee80211.h>
15 #include <linux/gfp.h>
16 #include <asm/unaligned.h>
17 #include <net/mac80211.h>
18 #include <crypto/aes.h>
19 #include <crypto/algapi.h>
20
21 #include "ieee80211_i.h"
22 #include "michael.h"
23 #include "tkip.h"
24 #include "aes_ccm.h"
25 #include "aes_cmac.h"
26 #include "aes_gmac.h"
27 #include "aes_gcm.h"
28 #include "wpa.h"
29
30 ieee80211_tx_result
31 ieee80211_tx_h_michael_mic_add(struct ieee80211_tx_data *tx)
32 {
33 u8 *data, *key, *mic;
34 size_t data_len;
35 unsigned int hdrlen;
36 struct ieee80211_hdr *hdr;
37 struct sk_buff *skb = tx->skb;
38 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
39 int tail;
40
41 hdr = (struct ieee80211_hdr *)skb->data;
42 if (!tx->key || tx->key->conf.cipher != WLAN_CIPHER_SUITE_TKIP ||
43 skb->len < 24 || !ieee80211_is_data_present(hdr->frame_control))
44 return TX_CONTINUE;
45
46 hdrlen = ieee80211_hdrlen(hdr->frame_control);
47 if (skb->len < hdrlen)
48 return TX_DROP;
49
50 data = skb->data + hdrlen;
51 data_len = skb->len - hdrlen;
52
53 if (unlikely(info->flags & IEEE80211_TX_INTFL_TKIP_MIC_FAILURE)) {
54 /* Need to use software crypto for the test */
55 info->control.hw_key = NULL;
56 }
57
58 if (info->control.hw_key &&
59 (info->flags & IEEE80211_TX_CTL_DONTFRAG ||
60 tx->local->ops->set_frag_threshold) &&
61 !(tx->key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC)) {
62 /* hwaccel - with no need for SW-generated MMIC */
63 return TX_CONTINUE;
64 }
65
66 tail = MICHAEL_MIC_LEN;
67 if (!info->control.hw_key)
68 tail += IEEE80211_TKIP_ICV_LEN;
69
70 if (WARN(skb_tailroom(skb) < tail ||
71 skb_headroom(skb) < IEEE80211_TKIP_IV_LEN,
72 "mmic: not enough head/tail (%d/%d,%d/%d)\n",
73 skb_headroom(skb), IEEE80211_TKIP_IV_LEN,
74 skb_tailroom(skb), tail))
75 return TX_DROP;
76
77 key = &tx->key->conf.key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY];
78 mic = skb_put(skb, MICHAEL_MIC_LEN);
79 michael_mic(key, hdr, data, data_len, mic);
80 if (unlikely(info->flags & IEEE80211_TX_INTFL_TKIP_MIC_FAILURE))
81 mic[0]++;
82
83 return TX_CONTINUE;
84 }
85
86
87 ieee80211_rx_result
88 ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data *rx)
89 {
90 u8 *data, *key = NULL;
91 size_t data_len;
92 unsigned int hdrlen;
93 u8 mic[MICHAEL_MIC_LEN];
94 struct sk_buff *skb = rx->skb;
95 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
96 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
97
98 /*
99 * it makes no sense to check for MIC errors on anything other
100 * than data frames.
101 */
102 if (!ieee80211_is_data_present(hdr->frame_control))
103 return RX_CONTINUE;
104
105 /*
106 * No way to verify the MIC if the hardware stripped it or
107 * the IV with the key index. In this case we have solely rely
108 * on the driver to set RX_FLAG_MMIC_ERROR in the event of a
109 * MIC failure report.
110 */
111 if (status->flag & (RX_FLAG_MMIC_STRIPPED | RX_FLAG_IV_STRIPPED)) {
112 if (status->flag & RX_FLAG_MMIC_ERROR)
113 goto mic_fail_no_key;
114
115 if (!(status->flag & RX_FLAG_IV_STRIPPED) && rx->key &&
116 rx->key->conf.cipher == WLAN_CIPHER_SUITE_TKIP)
117 goto update_iv;
118
119 return RX_CONTINUE;
120 }
121
122 /*
123 * Some hardware seems to generate Michael MIC failure reports; even
124 * though, the frame was not encrypted with TKIP and therefore has no
125 * MIC. Ignore the flag them to avoid triggering countermeasures.
126 */
127 if (!rx->key || rx->key->conf.cipher != WLAN_CIPHER_SUITE_TKIP ||
128 !(status->flag & RX_FLAG_DECRYPTED))
129 return RX_CONTINUE;
130
131 if (rx->sdata->vif.type == NL80211_IFTYPE_AP && rx->key->conf.keyidx) {
132 /*
133 * APs with pairwise keys should never receive Michael MIC
134 * errors for non-zero keyidx because these are reserved for
135 * group keys and only the AP is sending real multicast
136 * frames in the BSS.
137 */
138 return RX_DROP_UNUSABLE;
139 }
140
141 if (status->flag & RX_FLAG_MMIC_ERROR)
142 goto mic_fail;
143
144 hdrlen = ieee80211_hdrlen(hdr->frame_control);
145 if (skb->len < hdrlen + MICHAEL_MIC_LEN)
146 return RX_DROP_UNUSABLE;
147
148 if (skb_linearize(rx->skb))
149 return RX_DROP_UNUSABLE;
150 hdr = (void *)skb->data;
151
152 data = skb->data + hdrlen;
153 data_len = skb->len - hdrlen - MICHAEL_MIC_LEN;
154 key = &rx->key->conf.key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY];
155 michael_mic(key, hdr, data, data_len, mic);
156 if (crypto_memneq(mic, data + data_len, MICHAEL_MIC_LEN))
157 goto mic_fail;
158
159 /* remove Michael MIC from payload */
160 skb_trim(skb, skb->len - MICHAEL_MIC_LEN);
161
162 update_iv:
163 /* update IV in key information to be able to detect replays */
164 rx->key->u.tkip.rx[rx->security_idx].iv32 = rx->tkip_iv32;
165 rx->key->u.tkip.rx[rx->security_idx].iv16 = rx->tkip_iv16;
166
167 return RX_CONTINUE;
168
169 mic_fail:
170 rx->key->u.tkip.mic_failures++;
171
172 mic_fail_no_key:
173 /*
174 * In some cases the key can be unset - e.g. a multicast packet, in
175 * a driver that supports HW encryption. Send up the key idx only if
176 * the key is set.
177 */
178 cfg80211_michael_mic_failure(rx->sdata->dev, hdr->addr2,
179 is_multicast_ether_addr(hdr->addr1) ?
180 NL80211_KEYTYPE_GROUP :
181 NL80211_KEYTYPE_PAIRWISE,
182 rx->key ? rx->key->conf.keyidx : -1,
183 NULL, GFP_ATOMIC);
184 return RX_DROP_UNUSABLE;
185 }
186
187
188 static int tkip_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
189 {
190 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
191 struct ieee80211_key *key = tx->key;
192 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
193 unsigned int hdrlen;
194 int len, tail;
195 u8 *pos;
196
197 if (info->control.hw_key &&
198 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) &&
199 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) {
200 /* hwaccel - with no need for software-generated IV */
201 return 0;
202 }
203
204 hdrlen = ieee80211_hdrlen(hdr->frame_control);
205 len = skb->len - hdrlen;
206
207 if (info->control.hw_key)
208 tail = 0;
209 else
210 tail = IEEE80211_TKIP_ICV_LEN;
211
212 if (WARN_ON(skb_tailroom(skb) < tail ||
213 skb_headroom(skb) < IEEE80211_TKIP_IV_LEN))
214 return -1;
215
216 pos = skb_push(skb, IEEE80211_TKIP_IV_LEN);
217 memmove(pos, pos + IEEE80211_TKIP_IV_LEN, hdrlen);
218 pos += hdrlen;
219
220 /* the HW only needs room for the IV, but not the actual IV */
221 if (info->control.hw_key &&
222 (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE))
223 return 0;
224
225 /* Increase IV for the frame */
226 spin_lock(&key->u.tkip.txlock);
227 key->u.tkip.tx.iv16++;
228 if (key->u.tkip.tx.iv16 == 0)
229 key->u.tkip.tx.iv32++;
230 pos = ieee80211_tkip_add_iv(pos, key);
231 spin_unlock(&key->u.tkip.txlock);
232
233 /* hwaccel - with software IV */
234 if (info->control.hw_key)
235 return 0;
236
237 /* Add room for ICV */
238 skb_put(skb, IEEE80211_TKIP_ICV_LEN);
239
240 return ieee80211_tkip_encrypt_data(tx->local->wep_tx_tfm,
241 key, skb, pos, len);
242 }
243
244
245 ieee80211_tx_result
246 ieee80211_crypto_tkip_encrypt(struct ieee80211_tx_data *tx)
247 {
248 struct sk_buff *skb;
249
250 ieee80211_tx_set_protected(tx);
251
252 skb_queue_walk(&tx->skbs, skb) {
253 if (tkip_encrypt_skb(tx, skb) < 0)
254 return TX_DROP;
255 }
256
257 return TX_CONTINUE;
258 }
259
260
261 ieee80211_rx_result
262 ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data *rx)
263 {
264 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) rx->skb->data;
265 int hdrlen, res, hwaccel = 0;
266 struct ieee80211_key *key = rx->key;
267 struct sk_buff *skb = rx->skb;
268 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
269
270 hdrlen = ieee80211_hdrlen(hdr->frame_control);
271
272 if (!ieee80211_is_data(hdr->frame_control))
273 return RX_CONTINUE;
274
275 if (!rx->sta || skb->len - hdrlen < 12)
276 return RX_DROP_UNUSABLE;
277
278 /* it may be possible to optimize this a bit more */
279 if (skb_linearize(rx->skb))
280 return RX_DROP_UNUSABLE;
281 hdr = (void *)skb->data;
282
283 /*
284 * Let TKIP code verify IV, but skip decryption.
285 * In the case where hardware checks the IV as well,
286 * we don't even get here, see ieee80211_rx_h_decrypt()
287 */
288 if (status->flag & RX_FLAG_DECRYPTED)
289 hwaccel = 1;
290
291 res = ieee80211_tkip_decrypt_data(rx->local->wep_rx_tfm,
292 key, skb->data + hdrlen,
293 skb->len - hdrlen, rx->sta->sta.addr,
294 hdr->addr1, hwaccel, rx->security_idx,
295 &rx->tkip_iv32,
296 &rx->tkip_iv16);
297 if (res != TKIP_DECRYPT_OK)
298 return RX_DROP_UNUSABLE;
299
300 /* Trim ICV */
301 skb_trim(skb, skb->len - IEEE80211_TKIP_ICV_LEN);
302
303 /* Remove IV */
304 memmove(skb->data + IEEE80211_TKIP_IV_LEN, skb->data, hdrlen);
305 skb_pull(skb, IEEE80211_TKIP_IV_LEN);
306
307 return RX_CONTINUE;
308 }
309
310
311 static void ccmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *b_0, u8 *aad)
312 {
313 __le16 mask_fc;
314 int a4_included, mgmt;
315 u8 qos_tid;
316 u16 len_a;
317 unsigned int hdrlen;
318 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
319
320 /*
321 * Mask FC: zero subtype b4 b5 b6 (if not mgmt)
322 * Retry, PwrMgt, MoreData; set Protected
323 */
324 mgmt = ieee80211_is_mgmt(hdr->frame_control);
325 mask_fc = hdr->frame_control;
326 mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY |
327 IEEE80211_FCTL_PM | IEEE80211_FCTL_MOREDATA);
328 if (!mgmt)
329 mask_fc &= ~cpu_to_le16(0x0070);
330 mask_fc |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
331
332 hdrlen = ieee80211_hdrlen(hdr->frame_control);
333 len_a = hdrlen - 2;
334 a4_included = ieee80211_has_a4(hdr->frame_control);
335
336 if (ieee80211_is_data_qos(hdr->frame_control))
337 qos_tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
338 else
339 qos_tid = 0;
340
341 /* In CCM, the initial vectors (IV) used for CTR mode encryption and CBC
342 * mode authentication are not allowed to collide, yet both are derived
343 * from this vector b_0. We only set L := 1 here to indicate that the
344 * data size can be represented in (L+1) bytes. The CCM layer will take
345 * care of storing the data length in the top (L+1) bytes and setting
346 * and clearing the other bits as is required to derive the two IVs.
347 */
348 b_0[0] = 0x1;
349
350 /* Nonce: Nonce Flags | A2 | PN
351 * Nonce Flags: Priority (b0..b3) | Management (b4) | Reserved (b5..b7)
352 */
353 b_0[1] = qos_tid | (mgmt << 4);
354 memcpy(&b_0[2], hdr->addr2, ETH_ALEN);
355 memcpy(&b_0[8], pn, IEEE80211_CCMP_PN_LEN);
356
357 /* AAD (extra authenticate-only data) / masked 802.11 header
358 * FC | A1 | A2 | A3 | SC | [A4] | [QC] */
359 put_unaligned_be16(len_a, &aad[0]);
360 put_unaligned(mask_fc, (__le16 *)&aad[2]);
361 memcpy(&aad[4], &hdr->addr1, 3 * ETH_ALEN);
362
363 /* Mask Seq#, leave Frag# */
364 aad[22] = *((u8 *) &hdr->seq_ctrl) & 0x0f;
365 aad[23] = 0;
366
367 if (a4_included) {
368 memcpy(&aad[24], hdr->addr4, ETH_ALEN);
369 aad[30] = qos_tid;
370 aad[31] = 0;
371 } else {
372 memset(&aad[24], 0, ETH_ALEN + IEEE80211_QOS_CTL_LEN);
373 aad[24] = qos_tid;
374 }
375 }
376
377
378 static inline void ccmp_pn2hdr(u8 *hdr, u8 *pn, int key_id)
379 {
380 hdr[0] = pn[5];
381 hdr[1] = pn[4];
382 hdr[2] = 0;
383 hdr[3] = 0x20 | (key_id << 6);
384 hdr[4] = pn[3];
385 hdr[5] = pn[2];
386 hdr[6] = pn[1];
387 hdr[7] = pn[0];
388 }
389
390
391 static inline void ccmp_hdr2pn(u8 *pn, u8 *hdr)
392 {
393 pn[0] = hdr[7];
394 pn[1] = hdr[6];
395 pn[2] = hdr[5];
396 pn[3] = hdr[4];
397 pn[4] = hdr[1];
398 pn[5] = hdr[0];
399 }
400
401
402 static int ccmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb,
403 unsigned int mic_len)
404 {
405 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
406 struct ieee80211_key *key = tx->key;
407 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
408 int hdrlen, len, tail;
409 u8 *pos;
410 u8 pn[6];
411 u64 pn64;
412 u8 aad[2 * AES_BLOCK_SIZE];
413 u8 b_0[AES_BLOCK_SIZE];
414
415 if (info->control.hw_key &&
416 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) &&
417 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) &&
418 !((info->control.hw_key->flags &
419 IEEE80211_KEY_FLAG_GENERATE_IV_MGMT) &&
420 ieee80211_is_mgmt(hdr->frame_control))) {
421 /*
422 * hwaccel has no need for preallocated room for CCMP
423 * header or MIC fields
424 */
425 return 0;
426 }
427
428 hdrlen = ieee80211_hdrlen(hdr->frame_control);
429 len = skb->len - hdrlen;
430
431 if (info->control.hw_key)
432 tail = 0;
433 else
434 tail = mic_len;
435
436 if (WARN_ON(skb_tailroom(skb) < tail ||
437 skb_headroom(skb) < IEEE80211_CCMP_HDR_LEN))
438 return -1;
439
440 pos = skb_push(skb, IEEE80211_CCMP_HDR_LEN);
441 memmove(pos, pos + IEEE80211_CCMP_HDR_LEN, hdrlen);
442
443 /* the HW only needs room for the IV, but not the actual IV */
444 if (info->control.hw_key &&
445 (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE))
446 return 0;
447
448 hdr = (struct ieee80211_hdr *) pos;
449 pos += hdrlen;
450
451 pn64 = atomic64_inc_return(&key->conf.tx_pn);
452
453 pn[5] = pn64;
454 pn[4] = pn64 >> 8;
455 pn[3] = pn64 >> 16;
456 pn[2] = pn64 >> 24;
457 pn[1] = pn64 >> 32;
458 pn[0] = pn64 >> 40;
459
460 ccmp_pn2hdr(pos, pn, key->conf.keyidx);
461
462 /* hwaccel - with software CCMP header */
463 if (info->control.hw_key)
464 return 0;
465
466 pos += IEEE80211_CCMP_HDR_LEN;
467 ccmp_special_blocks(skb, pn, b_0, aad);
468 ieee80211_aes_ccm_encrypt(key->u.ccmp.tfm, b_0, aad, pos, len,
469 skb_put(skb, mic_len), mic_len);
470
471 return 0;
472 }
473
474
475 ieee80211_tx_result
476 ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data *tx,
477 unsigned int mic_len)
478 {
479 struct sk_buff *skb;
480
481 ieee80211_tx_set_protected(tx);
482
483 skb_queue_walk(&tx->skbs, skb) {
484 if (ccmp_encrypt_skb(tx, skb, mic_len) < 0)
485 return TX_DROP;
486 }
487
488 return TX_CONTINUE;
489 }
490
491
492 ieee80211_rx_result
493 ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx,
494 unsigned int mic_len)
495 {
496 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
497 int hdrlen;
498 struct ieee80211_key *key = rx->key;
499 struct sk_buff *skb = rx->skb;
500 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
501 u8 pn[IEEE80211_CCMP_PN_LEN];
502 int data_len;
503 int queue;
504
505 hdrlen = ieee80211_hdrlen(hdr->frame_control);
506
507 if (!ieee80211_is_data(hdr->frame_control) &&
508 !ieee80211_is_robust_mgmt_frame(skb))
509 return RX_CONTINUE;
510
511 data_len = skb->len - hdrlen - IEEE80211_CCMP_HDR_LEN - mic_len;
512 if (!rx->sta || data_len < 0)
513 return RX_DROP_UNUSABLE;
514
515 if (status->flag & RX_FLAG_DECRYPTED) {
516 if (!pskb_may_pull(rx->skb, hdrlen + IEEE80211_CCMP_HDR_LEN))
517 return RX_DROP_UNUSABLE;
518 } else {
519 if (skb_linearize(rx->skb))
520 return RX_DROP_UNUSABLE;
521 }
522
523 if (!(status->flag & RX_FLAG_PN_VALIDATED)) {
524 ccmp_hdr2pn(pn, skb->data + hdrlen);
525
526 queue = rx->security_idx;
527
528 if (memcmp(pn, key->u.ccmp.rx_pn[queue],
529 IEEE80211_CCMP_PN_LEN) <= 0) {
530 key->u.ccmp.replays++;
531 return RX_DROP_UNUSABLE;
532 }
533
534 if (!(status->flag & RX_FLAG_DECRYPTED)) {
535 u8 aad[2 * AES_BLOCK_SIZE];
536 u8 b_0[AES_BLOCK_SIZE];
537 /* hardware didn't decrypt/verify MIC */
538 ccmp_special_blocks(skb, pn, b_0, aad);
539
540 if (ieee80211_aes_ccm_decrypt(
541 key->u.ccmp.tfm, b_0, aad,
542 skb->data + hdrlen + IEEE80211_CCMP_HDR_LEN,
543 data_len,
544 skb->data + skb->len - mic_len, mic_len))
545 return RX_DROP_UNUSABLE;
546 }
547
548 memcpy(key->u.ccmp.rx_pn[queue], pn, IEEE80211_CCMP_PN_LEN);
549 }
550
551 /* Remove CCMP header and MIC */
552 if (pskb_trim(skb, skb->len - mic_len))
553 return RX_DROP_UNUSABLE;
554 memmove(skb->data + IEEE80211_CCMP_HDR_LEN, skb->data, hdrlen);
555 skb_pull(skb, IEEE80211_CCMP_HDR_LEN);
556
557 return RX_CONTINUE;
558 }
559
560 static void gcmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *j_0, u8 *aad)
561 {
562 __le16 mask_fc;
563 u8 qos_tid;
564 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
565
566 memcpy(j_0, hdr->addr2, ETH_ALEN);
567 memcpy(&j_0[ETH_ALEN], pn, IEEE80211_GCMP_PN_LEN);
568 j_0[13] = 0;
569 j_0[14] = 0;
570 j_0[AES_BLOCK_SIZE - 1] = 0x01;
571
572 /* AAD (extra authenticate-only data) / masked 802.11 header
573 * FC | A1 | A2 | A3 | SC | [A4] | [QC]
574 */
575 put_unaligned_be16(ieee80211_hdrlen(hdr->frame_control) - 2, &aad[0]);
576 /* Mask FC: zero subtype b4 b5 b6 (if not mgmt)
577 * Retry, PwrMgt, MoreData; set Protected
578 */
579 mask_fc = hdr->frame_control;
580 mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY |
581 IEEE80211_FCTL_PM | IEEE80211_FCTL_MOREDATA);
582 if (!ieee80211_is_mgmt(hdr->frame_control))
583 mask_fc &= ~cpu_to_le16(0x0070);
584 mask_fc |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
585
586 put_unaligned(mask_fc, (__le16 *)&aad[2]);
587 memcpy(&aad[4], &hdr->addr1, 3 * ETH_ALEN);
588
589 /* Mask Seq#, leave Frag# */
590 aad[22] = *((u8 *)&hdr->seq_ctrl) & 0x0f;
591 aad[23] = 0;
592
593 if (ieee80211_is_data_qos(hdr->frame_control))
594 qos_tid = *ieee80211_get_qos_ctl(hdr) &
595 IEEE80211_QOS_CTL_TID_MASK;
596 else
597 qos_tid = 0;
598
599 if (ieee80211_has_a4(hdr->frame_control)) {
600 memcpy(&aad[24], hdr->addr4, ETH_ALEN);
601 aad[30] = qos_tid;
602 aad[31] = 0;
603 } else {
604 memset(&aad[24], 0, ETH_ALEN + IEEE80211_QOS_CTL_LEN);
605 aad[24] = qos_tid;
606 }
607 }
608
609 static inline void gcmp_pn2hdr(u8 *hdr, const u8 *pn, int key_id)
610 {
611 hdr[0] = pn[5];
612 hdr[1] = pn[4];
613 hdr[2] = 0;
614 hdr[3] = 0x20 | (key_id << 6);
615 hdr[4] = pn[3];
616 hdr[5] = pn[2];
617 hdr[6] = pn[1];
618 hdr[7] = pn[0];
619 }
620
621 static inline void gcmp_hdr2pn(u8 *pn, const u8 *hdr)
622 {
623 pn[0] = hdr[7];
624 pn[1] = hdr[6];
625 pn[2] = hdr[5];
626 pn[3] = hdr[4];
627 pn[4] = hdr[1];
628 pn[5] = hdr[0];
629 }
630
631 static int gcmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
632 {
633 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
634 struct ieee80211_key *key = tx->key;
635 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
636 int hdrlen, len, tail;
637 u8 *pos;
638 u8 pn[6];
639 u64 pn64;
640 u8 aad[2 * AES_BLOCK_SIZE];
641 u8 j_0[AES_BLOCK_SIZE];
642
643 if (info->control.hw_key &&
644 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) &&
645 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) &&
646 !((info->control.hw_key->flags &
647 IEEE80211_KEY_FLAG_GENERATE_IV_MGMT) &&
648 ieee80211_is_mgmt(hdr->frame_control))) {
649 /* hwaccel has no need for preallocated room for GCMP
650 * header or MIC fields
651 */
652 return 0;
653 }
654
655 hdrlen = ieee80211_hdrlen(hdr->frame_control);
656 len = skb->len - hdrlen;
657
658 if (info->control.hw_key)
659 tail = 0;
660 else
661 tail = IEEE80211_GCMP_MIC_LEN;
662
663 if (WARN_ON(skb_tailroom(skb) < tail ||
664 skb_headroom(skb) < IEEE80211_GCMP_HDR_LEN))
665 return -1;
666
667 pos = skb_push(skb, IEEE80211_GCMP_HDR_LEN);
668 memmove(pos, pos + IEEE80211_GCMP_HDR_LEN, hdrlen);
669 skb_set_network_header(skb, skb_network_offset(skb) +
670 IEEE80211_GCMP_HDR_LEN);
671
672 /* the HW only needs room for the IV, but not the actual IV */
673 if (info->control.hw_key &&
674 (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE))
675 return 0;
676
677 hdr = (struct ieee80211_hdr *)pos;
678 pos += hdrlen;
679
680 pn64 = atomic64_inc_return(&key->conf.tx_pn);
681
682 pn[5] = pn64;
683 pn[4] = pn64 >> 8;
684 pn[3] = pn64 >> 16;
685 pn[2] = pn64 >> 24;
686 pn[1] = pn64 >> 32;
687 pn[0] = pn64 >> 40;
688
689 gcmp_pn2hdr(pos, pn, key->conf.keyidx);
690
691 /* hwaccel - with software GCMP header */
692 if (info->control.hw_key)
693 return 0;
694
695 pos += IEEE80211_GCMP_HDR_LEN;
696 gcmp_special_blocks(skb, pn, j_0, aad);
697 ieee80211_aes_gcm_encrypt(key->u.gcmp.tfm, j_0, aad, pos, len,
698 skb_put(skb, IEEE80211_GCMP_MIC_LEN));
699
700 return 0;
701 }
702
703 ieee80211_tx_result
704 ieee80211_crypto_gcmp_encrypt(struct ieee80211_tx_data *tx)
705 {
706 struct sk_buff *skb;
707
708 ieee80211_tx_set_protected(tx);
709
710 skb_queue_walk(&tx->skbs, skb) {
711 if (gcmp_encrypt_skb(tx, skb) < 0)
712 return TX_DROP;
713 }
714
715 return TX_CONTINUE;
716 }
717
718 ieee80211_rx_result
719 ieee80211_crypto_gcmp_decrypt(struct ieee80211_rx_data *rx)
720 {
721 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
722 int hdrlen;
723 struct ieee80211_key *key = rx->key;
724 struct sk_buff *skb = rx->skb;
725 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
726 u8 pn[IEEE80211_GCMP_PN_LEN];
727 int data_len;
728 int queue;
729
730 hdrlen = ieee80211_hdrlen(hdr->frame_control);
731
732 if (!ieee80211_is_data(hdr->frame_control) &&
733 !ieee80211_is_robust_mgmt_frame(skb))
734 return RX_CONTINUE;
735
736 data_len = skb->len - hdrlen - IEEE80211_GCMP_HDR_LEN -
737 IEEE80211_GCMP_MIC_LEN;
738 if (!rx->sta || data_len < 0)
739 return RX_DROP_UNUSABLE;
740
741 if (status->flag & RX_FLAG_DECRYPTED) {
742 if (!pskb_may_pull(rx->skb, hdrlen + IEEE80211_GCMP_HDR_LEN))
743 return RX_DROP_UNUSABLE;
744 } else {
745 if (skb_linearize(rx->skb))
746 return RX_DROP_UNUSABLE;
747 }
748
749 if (!(status->flag & RX_FLAG_PN_VALIDATED)) {
750 gcmp_hdr2pn(pn, skb->data + hdrlen);
751
752 queue = rx->security_idx;
753
754 if (memcmp(pn, key->u.gcmp.rx_pn[queue],
755 IEEE80211_GCMP_PN_LEN) <= 0) {
756 key->u.gcmp.replays++;
757 return RX_DROP_UNUSABLE;
758 }
759
760 if (!(status->flag & RX_FLAG_DECRYPTED)) {
761 u8 aad[2 * AES_BLOCK_SIZE];
762 u8 j_0[AES_BLOCK_SIZE];
763 /* hardware didn't decrypt/verify MIC */
764 gcmp_special_blocks(skb, pn, j_0, aad);
765
766 if (ieee80211_aes_gcm_decrypt(
767 key->u.gcmp.tfm, j_0, aad,
768 skb->data + hdrlen + IEEE80211_GCMP_HDR_LEN,
769 data_len,
770 skb->data + skb->len -
771 IEEE80211_GCMP_MIC_LEN))
772 return RX_DROP_UNUSABLE;
773 }
774
775 memcpy(key->u.gcmp.rx_pn[queue], pn, IEEE80211_GCMP_PN_LEN);
776 }
777
778 /* Remove GCMP header and MIC */
779 if (pskb_trim(skb, skb->len - IEEE80211_GCMP_MIC_LEN))
780 return RX_DROP_UNUSABLE;
781 memmove(skb->data + IEEE80211_GCMP_HDR_LEN, skb->data, hdrlen);
782 skb_pull(skb, IEEE80211_GCMP_HDR_LEN);
783
784 return RX_CONTINUE;
785 }
786
787 static ieee80211_tx_result
788 ieee80211_crypto_cs_encrypt(struct ieee80211_tx_data *tx,
789 struct sk_buff *skb)
790 {
791 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
792 struct ieee80211_key *key = tx->key;
793 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
794 int hdrlen;
795 u8 *pos, iv_len = key->conf.iv_len;
796
797 if (info->control.hw_key &&
798 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) {
799 /* hwaccel has no need for preallocated head room */
800 return TX_CONTINUE;
801 }
802
803 if (unlikely(skb_headroom(skb) < iv_len &&
804 pskb_expand_head(skb, iv_len, 0, GFP_ATOMIC)))
805 return TX_DROP;
806
807 hdrlen = ieee80211_hdrlen(hdr->frame_control);
808
809 pos = skb_push(skb, iv_len);
810 memmove(pos, pos + iv_len, hdrlen);
811
812 return TX_CONTINUE;
813 }
814
815 static inline int ieee80211_crypto_cs_pn_compare(u8 *pn1, u8 *pn2, int len)
816 {
817 int i;
818
819 /* pn is little endian */
820 for (i = len - 1; i >= 0; i--) {
821 if (pn1[i] < pn2[i])
822 return -1;
823 else if (pn1[i] > pn2[i])
824 return 1;
825 }
826
827 return 0;
828 }
829
830 static ieee80211_rx_result
831 ieee80211_crypto_cs_decrypt(struct ieee80211_rx_data *rx)
832 {
833 struct ieee80211_key *key = rx->key;
834 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
835 const struct ieee80211_cipher_scheme *cs = NULL;
836 int hdrlen = ieee80211_hdrlen(hdr->frame_control);
837 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
838 int data_len;
839 u8 *rx_pn;
840 u8 *skb_pn;
841 u8 qos_tid;
842
843 if (!rx->sta || !rx->sta->cipher_scheme ||
844 !(status->flag & RX_FLAG_DECRYPTED))
845 return RX_DROP_UNUSABLE;
846
847 if (!ieee80211_is_data(hdr->frame_control))
848 return RX_CONTINUE;
849
850 cs = rx->sta->cipher_scheme;
851
852 data_len = rx->skb->len - hdrlen - cs->hdr_len;
853
854 if (data_len < 0)
855 return RX_DROP_UNUSABLE;
856
857 if (ieee80211_is_data_qos(hdr->frame_control))
858 qos_tid = *ieee80211_get_qos_ctl(hdr) &
859 IEEE80211_QOS_CTL_TID_MASK;
860 else
861 qos_tid = 0;
862
863 if (skb_linearize(rx->skb))
864 return RX_DROP_UNUSABLE;
865
866 hdr = (struct ieee80211_hdr *)rx->skb->data;
867
868 rx_pn = key->u.gen.rx_pn[qos_tid];
869 skb_pn = rx->skb->data + hdrlen + cs->pn_off;
870
871 if (ieee80211_crypto_cs_pn_compare(skb_pn, rx_pn, cs->pn_len) <= 0)
872 return RX_DROP_UNUSABLE;
873
874 memcpy(rx_pn, skb_pn, cs->pn_len);
875
876 /* remove security header and MIC */
877 if (pskb_trim(rx->skb, rx->skb->len - cs->mic_len))
878 return RX_DROP_UNUSABLE;
879
880 memmove(rx->skb->data + cs->hdr_len, rx->skb->data, hdrlen);
881 skb_pull(rx->skb, cs->hdr_len);
882
883 return RX_CONTINUE;
884 }
885
886 static void bip_aad(struct sk_buff *skb, u8 *aad)
887 {
888 __le16 mask_fc;
889 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
890
891 /* BIP AAD: FC(masked) || A1 || A2 || A3 */
892
893 /* FC type/subtype */
894 /* Mask FC Retry, PwrMgt, MoreData flags to zero */
895 mask_fc = hdr->frame_control;
896 mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY | IEEE80211_FCTL_PM |
897 IEEE80211_FCTL_MOREDATA);
898 put_unaligned(mask_fc, (__le16 *) &aad[0]);
899 /* A1 || A2 || A3 */
900 memcpy(aad + 2, &hdr->addr1, 3 * ETH_ALEN);
901 }
902
903
904 static inline void bip_ipn_set64(u8 *d, u64 pn)
905 {
906 *d++ = pn;
907 *d++ = pn >> 8;
908 *d++ = pn >> 16;
909 *d++ = pn >> 24;
910 *d++ = pn >> 32;
911 *d = pn >> 40;
912 }
913
914 static inline void bip_ipn_swap(u8 *d, const u8 *s)
915 {
916 *d++ = s[5];
917 *d++ = s[4];
918 *d++ = s[3];
919 *d++ = s[2];
920 *d++ = s[1];
921 *d = s[0];
922 }
923
924
925 ieee80211_tx_result
926 ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data *tx)
927 {
928 struct sk_buff *skb;
929 struct ieee80211_tx_info *info;
930 struct ieee80211_key *key = tx->key;
931 struct ieee80211_mmie *mmie;
932 u8 aad[20];
933 u64 pn64;
934
935 if (WARN_ON(skb_queue_len(&tx->skbs) != 1))
936 return TX_DROP;
937
938 skb = skb_peek(&tx->skbs);
939
940 info = IEEE80211_SKB_CB(skb);
941
942 if (info->control.hw_key)
943 return TX_CONTINUE;
944
945 if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie)))
946 return TX_DROP;
947
948 mmie = (struct ieee80211_mmie *) skb_put(skb, sizeof(*mmie));
949 mmie->element_id = WLAN_EID_MMIE;
950 mmie->length = sizeof(*mmie) - 2;
951 mmie->key_id = cpu_to_le16(key->conf.keyidx);
952
953 /* PN = PN + 1 */
954 pn64 = atomic64_inc_return(&key->conf.tx_pn);
955
956 bip_ipn_set64(mmie->sequence_number, pn64);
957
958 bip_aad(skb, aad);
959
960 /*
961 * MIC = AES-128-CMAC(IGTK, AAD || Management Frame Body || MMIE, 64)
962 */
963 ieee80211_aes_cmac(key->u.aes_cmac.tfm, aad,
964 skb->data + 24, skb->len - 24, mmie->mic);
965
966 return TX_CONTINUE;
967 }
968
969 ieee80211_tx_result
970 ieee80211_crypto_aes_cmac_256_encrypt(struct ieee80211_tx_data *tx)
971 {
972 struct sk_buff *skb;
973 struct ieee80211_tx_info *info;
974 struct ieee80211_key *key = tx->key;
975 struct ieee80211_mmie_16 *mmie;
976 u8 aad[20];
977 u64 pn64;
978
979 if (WARN_ON(skb_queue_len(&tx->skbs) != 1))
980 return TX_DROP;
981
982 skb = skb_peek(&tx->skbs);
983
984 info = IEEE80211_SKB_CB(skb);
985
986 if (info->control.hw_key)
987 return TX_CONTINUE;
988
989 if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie)))
990 return TX_DROP;
991
992 mmie = (struct ieee80211_mmie_16 *)skb_put(skb, sizeof(*mmie));
993 mmie->element_id = WLAN_EID_MMIE;
994 mmie->length = sizeof(*mmie) - 2;
995 mmie->key_id = cpu_to_le16(key->conf.keyidx);
996
997 /* PN = PN + 1 */
998 pn64 = atomic64_inc_return(&key->conf.tx_pn);
999
1000 bip_ipn_set64(mmie->sequence_number, pn64);
1001
1002 bip_aad(skb, aad);
1003
1004 /* MIC = AES-256-CMAC(IGTK, AAD || Management Frame Body || MMIE, 128)
1005 */
1006 ieee80211_aes_cmac_256(key->u.aes_cmac.tfm, aad,
1007 skb->data + 24, skb->len - 24, mmie->mic);
1008
1009 return TX_CONTINUE;
1010 }
1011
1012 ieee80211_rx_result
1013 ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data *rx)
1014 {
1015 struct sk_buff *skb = rx->skb;
1016 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1017 struct ieee80211_key *key = rx->key;
1018 struct ieee80211_mmie *mmie;
1019 u8 aad[20], mic[8], ipn[6];
1020 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1021
1022 if (!ieee80211_is_mgmt(hdr->frame_control))
1023 return RX_CONTINUE;
1024
1025 /* management frames are already linear */
1026
1027 if (skb->len < 24 + sizeof(*mmie))
1028 return RX_DROP_UNUSABLE;
1029
1030 mmie = (struct ieee80211_mmie *)
1031 (skb->data + skb->len - sizeof(*mmie));
1032 if (mmie->element_id != WLAN_EID_MMIE ||
1033 mmie->length != sizeof(*mmie) - 2)
1034 return RX_DROP_UNUSABLE; /* Invalid MMIE */
1035
1036 bip_ipn_swap(ipn, mmie->sequence_number);
1037
1038 if (memcmp(ipn, key->u.aes_cmac.rx_pn, 6) <= 0) {
1039 key->u.aes_cmac.replays++;
1040 return RX_DROP_UNUSABLE;
1041 }
1042
1043 if (!(status->flag & RX_FLAG_DECRYPTED)) {
1044 /* hardware didn't decrypt/verify MIC */
1045 bip_aad(skb, aad);
1046 ieee80211_aes_cmac(key->u.aes_cmac.tfm, aad,
1047 skb->data + 24, skb->len - 24, mic);
1048 if (crypto_memneq(mic, mmie->mic, sizeof(mmie->mic))) {
1049 key->u.aes_cmac.icverrors++;
1050 return RX_DROP_UNUSABLE;
1051 }
1052 }
1053
1054 memcpy(key->u.aes_cmac.rx_pn, ipn, 6);
1055
1056 /* Remove MMIE */
1057 skb_trim(skb, skb->len - sizeof(*mmie));
1058
1059 return RX_CONTINUE;
1060 }
1061
1062 ieee80211_rx_result
1063 ieee80211_crypto_aes_cmac_256_decrypt(struct ieee80211_rx_data *rx)
1064 {
1065 struct sk_buff *skb = rx->skb;
1066 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1067 struct ieee80211_key *key = rx->key;
1068 struct ieee80211_mmie_16 *mmie;
1069 u8 aad[20], mic[16], ipn[6];
1070 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1071
1072 if (!ieee80211_is_mgmt(hdr->frame_control))
1073 return RX_CONTINUE;
1074
1075 /* management frames are already linear */
1076
1077 if (skb->len < 24 + sizeof(*mmie))
1078 return RX_DROP_UNUSABLE;
1079
1080 mmie = (struct ieee80211_mmie_16 *)
1081 (skb->data + skb->len - sizeof(*mmie));
1082 if (mmie->element_id != WLAN_EID_MMIE ||
1083 mmie->length != sizeof(*mmie) - 2)
1084 return RX_DROP_UNUSABLE; /* Invalid MMIE */
1085
1086 bip_ipn_swap(ipn, mmie->sequence_number);
1087
1088 if (memcmp(ipn, key->u.aes_cmac.rx_pn, 6) <= 0) {
1089 key->u.aes_cmac.replays++;
1090 return RX_DROP_UNUSABLE;
1091 }
1092
1093 if (!(status->flag & RX_FLAG_DECRYPTED)) {
1094 /* hardware didn't decrypt/verify MIC */
1095 bip_aad(skb, aad);
1096 ieee80211_aes_cmac_256(key->u.aes_cmac.tfm, aad,
1097 skb->data + 24, skb->len - 24, mic);
1098 if (crypto_memneq(mic, mmie->mic, sizeof(mmie->mic))) {
1099 key->u.aes_cmac.icverrors++;
1100 return RX_DROP_UNUSABLE;
1101 }
1102 }
1103
1104 memcpy(key->u.aes_cmac.rx_pn, ipn, 6);
1105
1106 /* Remove MMIE */
1107 skb_trim(skb, skb->len - sizeof(*mmie));
1108
1109 return RX_CONTINUE;
1110 }
1111
1112 ieee80211_tx_result
1113 ieee80211_crypto_aes_gmac_encrypt(struct ieee80211_tx_data *tx)
1114 {
1115 struct sk_buff *skb;
1116 struct ieee80211_tx_info *info;
1117 struct ieee80211_key *key = tx->key;
1118 struct ieee80211_mmie_16 *mmie;
1119 struct ieee80211_hdr *hdr;
1120 u8 aad[20];
1121 u64 pn64;
1122 u8 nonce[12];
1123
1124 if (WARN_ON(skb_queue_len(&tx->skbs) != 1))
1125 return TX_DROP;
1126
1127 skb = skb_peek(&tx->skbs);
1128
1129 info = IEEE80211_SKB_CB(skb);
1130
1131 if (info->control.hw_key)
1132 return TX_CONTINUE;
1133
1134 if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie)))
1135 return TX_DROP;
1136
1137 mmie = (struct ieee80211_mmie_16 *)skb_put(skb, sizeof(*mmie));
1138 mmie->element_id = WLAN_EID_MMIE;
1139 mmie->length = sizeof(*mmie) - 2;
1140 mmie->key_id = cpu_to_le16(key->conf.keyidx);
1141
1142 /* PN = PN + 1 */
1143 pn64 = atomic64_inc_return(&key->conf.tx_pn);
1144
1145 bip_ipn_set64(mmie->sequence_number, pn64);
1146
1147 bip_aad(skb, aad);
1148
1149 hdr = (struct ieee80211_hdr *)skb->data;
1150 memcpy(nonce, hdr->addr2, ETH_ALEN);
1151 bip_ipn_swap(nonce + ETH_ALEN, mmie->sequence_number);
1152
1153 /* MIC = AES-GMAC(IGTK, AAD || Management Frame Body || MMIE, 128) */
1154 if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce,
1155 skb->data + 24, skb->len - 24, mmie->mic) < 0)
1156 return TX_DROP;
1157
1158 return TX_CONTINUE;
1159 }
1160
1161 ieee80211_rx_result
1162 ieee80211_crypto_aes_gmac_decrypt(struct ieee80211_rx_data *rx)
1163 {
1164 struct sk_buff *skb = rx->skb;
1165 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1166 struct ieee80211_key *key = rx->key;
1167 struct ieee80211_mmie_16 *mmie;
1168 u8 aad[20], mic[16], ipn[6], nonce[12];
1169 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1170
1171 if (!ieee80211_is_mgmt(hdr->frame_control))
1172 return RX_CONTINUE;
1173
1174 /* management frames are already linear */
1175
1176 if (skb->len < 24 + sizeof(*mmie))
1177 return RX_DROP_UNUSABLE;
1178
1179 mmie = (struct ieee80211_mmie_16 *)
1180 (skb->data + skb->len - sizeof(*mmie));
1181 if (mmie->element_id != WLAN_EID_MMIE ||
1182 mmie->length != sizeof(*mmie) - 2)
1183 return RX_DROP_UNUSABLE; /* Invalid MMIE */
1184
1185 bip_ipn_swap(ipn, mmie->sequence_number);
1186
1187 if (memcmp(ipn, key->u.aes_gmac.rx_pn, 6) <= 0) {
1188 key->u.aes_gmac.replays++;
1189 return RX_DROP_UNUSABLE;
1190 }
1191
1192 if (!(status->flag & RX_FLAG_DECRYPTED)) {
1193 /* hardware didn't decrypt/verify MIC */
1194 bip_aad(skb, aad);
1195
1196 memcpy(nonce, hdr->addr2, ETH_ALEN);
1197 memcpy(nonce + ETH_ALEN, ipn, 6);
1198
1199 if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce,
1200 skb->data + 24, skb->len - 24,
1201 mic) < 0 ||
1202 crypto_memneq(mic, mmie->mic, sizeof(mmie->mic))) {
1203 key->u.aes_gmac.icverrors++;
1204 return RX_DROP_UNUSABLE;
1205 }
1206 }
1207
1208 memcpy(key->u.aes_gmac.rx_pn, ipn, 6);
1209
1210 /* Remove MMIE */
1211 skb_trim(skb, skb->len - sizeof(*mmie));
1212
1213 return RX_CONTINUE;
1214 }
1215
1216 ieee80211_tx_result
1217 ieee80211_crypto_hw_encrypt(struct ieee80211_tx_data *tx)
1218 {
1219 struct sk_buff *skb;
1220 struct ieee80211_tx_info *info = NULL;
1221 ieee80211_tx_result res;
1222
1223 skb_queue_walk(&tx->skbs, skb) {
1224 info = IEEE80211_SKB_CB(skb);
1225
1226 /* handle hw-only algorithm */
1227 if (!info->control.hw_key)
1228 return TX_DROP;
1229
1230 if (tx->key->flags & KEY_FLAG_CIPHER_SCHEME) {
1231 res = ieee80211_crypto_cs_encrypt(tx, skb);
1232 if (res != TX_CONTINUE)
1233 return res;
1234 }
1235 }
1236
1237 ieee80211_tx_set_protected(tx);
1238
1239 return TX_CONTINUE;
1240 }
1241
1242 ieee80211_rx_result
1243 ieee80211_crypto_hw_decrypt(struct ieee80211_rx_data *rx)
1244 {
1245 if (rx->sta && rx->sta->cipher_scheme)
1246 return ieee80211_crypto_cs_decrypt(rx);
1247
1248 return RX_DROP_UNUSABLE;
1249 }
Linux with added FPC-III support