2 * Copyright 2002-2004, Instant802 Networks, Inc.
3 * Copyright 2008, Jouni Malinen <j@w1.fi>
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.
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>
20 #include "ieee80211_i.h"
29 ieee80211_tx_h_michael_mic_add(struct ieee80211_tx_data
*tx
)
34 struct ieee80211_hdr
*hdr
;
35 struct sk_buff
*skb
= tx
->skb
;
36 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
39 hdr
= (struct ieee80211_hdr
*)skb
->data
;
40 if (!tx
->key
|| tx
->key
->conf
.cipher
!= WLAN_CIPHER_SUITE_TKIP
||
41 skb
->len
< 24 || !ieee80211_is_data_present(hdr
->frame_control
))
44 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
45 if (skb
->len
< hdrlen
)
48 data
= skb
->data
+ hdrlen
;
49 data_len
= skb
->len
- hdrlen
;
51 if (unlikely(info
->flags
& IEEE80211_TX_INTFL_TKIP_MIC_FAILURE
)) {
52 /* Need to use software crypto for the test */
53 info
->control
.hw_key
= NULL
;
56 if (info
->control
.hw_key
&&
57 (info
->flags
& IEEE80211_TX_CTL_DONTFRAG
||
58 tx
->local
->ops
->set_frag_threshold
) &&
59 !(tx
->key
->conf
.flags
& IEEE80211_KEY_FLAG_GENERATE_MMIC
)) {
60 /* hwaccel - with no need for SW-generated MMIC */
64 tail
= MICHAEL_MIC_LEN
;
65 if (!info
->control
.hw_key
)
66 tail
+= IEEE80211_TKIP_ICV_LEN
;
68 if (WARN(skb_tailroom(skb
) < tail
||
69 skb_headroom(skb
) < IEEE80211_TKIP_IV_LEN
,
70 "mmic: not enough head/tail (%d/%d,%d/%d)\n",
71 skb_headroom(skb
), IEEE80211_TKIP_IV_LEN
,
72 skb_tailroom(skb
), tail
))
75 key
= &tx
->key
->conf
.key
[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY
];
76 mic
= skb_put(skb
, MICHAEL_MIC_LEN
);
77 michael_mic(key
, hdr
, data
, data_len
, mic
);
78 if (unlikely(info
->flags
& IEEE80211_TX_INTFL_TKIP_MIC_FAILURE
))
86 ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data
*rx
)
88 u8
*data
, *key
= NULL
;
91 u8 mic
[MICHAEL_MIC_LEN
];
92 struct sk_buff
*skb
= rx
->skb
;
93 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
94 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
97 * it makes no sense to check for MIC errors on anything other
100 if (!ieee80211_is_data_present(hdr
->frame_control
))
104 * No way to verify the MIC if the hardware stripped it or
105 * the IV with the key index. In this case we have solely rely
106 * on the driver to set RX_FLAG_MMIC_ERROR in the event of a
107 * MIC failure report.
109 if (status
->flag
& (RX_FLAG_MMIC_STRIPPED
| RX_FLAG_IV_STRIPPED
)) {
110 if (status
->flag
& RX_FLAG_MMIC_ERROR
)
111 goto mic_fail_no_key
;
113 if (!(status
->flag
& RX_FLAG_IV_STRIPPED
) && rx
->key
&&
114 rx
->key
->conf
.cipher
== WLAN_CIPHER_SUITE_TKIP
)
121 * Some hardware seems to generate Michael MIC failure reports; even
122 * though, the frame was not encrypted with TKIP and therefore has no
123 * MIC. Ignore the flag them to avoid triggering countermeasures.
125 if (!rx
->key
|| rx
->key
->conf
.cipher
!= WLAN_CIPHER_SUITE_TKIP
||
126 !(status
->flag
& RX_FLAG_DECRYPTED
))
129 if (rx
->sdata
->vif
.type
== NL80211_IFTYPE_AP
&& rx
->key
->conf
.keyidx
) {
131 * APs with pairwise keys should never receive Michael MIC
132 * errors for non-zero keyidx because these are reserved for
133 * group keys and only the AP is sending real multicast
136 return RX_DROP_UNUSABLE
;
139 if (status
->flag
& RX_FLAG_MMIC_ERROR
)
142 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
143 if (skb
->len
< hdrlen
+ MICHAEL_MIC_LEN
)
144 return RX_DROP_UNUSABLE
;
146 if (skb_linearize(rx
->skb
))
147 return RX_DROP_UNUSABLE
;
148 hdr
= (void *)skb
->data
;
150 data
= skb
->data
+ hdrlen
;
151 data_len
= skb
->len
- hdrlen
- MICHAEL_MIC_LEN
;
152 key
= &rx
->key
->conf
.key
[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY
];
153 michael_mic(key
, hdr
, data
, data_len
, mic
);
154 if (memcmp(mic
, data
+ data_len
, MICHAEL_MIC_LEN
) != 0)
157 /* remove Michael MIC from payload */
158 skb_trim(skb
, skb
->len
- MICHAEL_MIC_LEN
);
161 /* update IV in key information to be able to detect replays */
162 rx
->key
->u
.tkip
.rx
[rx
->security_idx
].iv32
= rx
->tkip_iv32
;
163 rx
->key
->u
.tkip
.rx
[rx
->security_idx
].iv16
= rx
->tkip_iv16
;
168 rx
->key
->u
.tkip
.mic_failures
++;
172 * In some cases the key can be unset - e.g. a multicast packet, in
173 * a driver that supports HW encryption. Send up the key idx only if
176 mac80211_ev_michael_mic_failure(rx
->sdata
,
177 rx
->key
? rx
->key
->conf
.keyidx
: -1,
178 (void *) skb
->data
, NULL
, GFP_ATOMIC
);
179 return RX_DROP_UNUSABLE
;
183 static int tkip_encrypt_skb(struct ieee80211_tx_data
*tx
, struct sk_buff
*skb
)
185 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
186 struct ieee80211_key
*key
= tx
->key
;
187 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
192 if (info
->control
.hw_key
&&
193 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_GENERATE_IV
) &&
194 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
)) {
195 /* hwaccel - with no need for software-generated IV */
199 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
200 len
= skb
->len
- hdrlen
;
202 if (info
->control
.hw_key
)
205 tail
= IEEE80211_TKIP_ICV_LEN
;
207 if (WARN_ON(skb_tailroom(skb
) < tail
||
208 skb_headroom(skb
) < IEEE80211_TKIP_IV_LEN
))
211 pos
= skb_push(skb
, IEEE80211_TKIP_IV_LEN
);
212 memmove(pos
, pos
+ IEEE80211_TKIP_IV_LEN
, hdrlen
);
215 /* the HW only needs room for the IV, but not the actual IV */
216 if (info
->control
.hw_key
&&
217 (info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
))
220 /* Increase IV for the frame */
221 spin_lock(&key
->u
.tkip
.txlock
);
222 key
->u
.tkip
.tx
.iv16
++;
223 if (key
->u
.tkip
.tx
.iv16
== 0)
224 key
->u
.tkip
.tx
.iv32
++;
225 pos
= ieee80211_tkip_add_iv(pos
, key
);
226 spin_unlock(&key
->u
.tkip
.txlock
);
228 /* hwaccel - with software IV */
229 if (info
->control
.hw_key
)
232 /* Add room for ICV */
233 skb_put(skb
, IEEE80211_TKIP_ICV_LEN
);
235 return ieee80211_tkip_encrypt_data(tx
->local
->wep_tx_tfm
,
241 ieee80211_crypto_tkip_encrypt(struct ieee80211_tx_data
*tx
)
245 ieee80211_tx_set_protected(tx
);
247 skb_queue_walk(&tx
->skbs
, skb
) {
248 if (tkip_encrypt_skb(tx
, skb
) < 0)
257 ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data
*rx
)
259 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) rx
->skb
->data
;
260 int hdrlen
, res
, hwaccel
= 0;
261 struct ieee80211_key
*key
= rx
->key
;
262 struct sk_buff
*skb
= rx
->skb
;
263 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
265 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
267 if (!ieee80211_is_data(hdr
->frame_control
))
270 if (!rx
->sta
|| skb
->len
- hdrlen
< 12)
271 return RX_DROP_UNUSABLE
;
273 /* it may be possible to optimize this a bit more */
274 if (skb_linearize(rx
->skb
))
275 return RX_DROP_UNUSABLE
;
276 hdr
= (void *)skb
->data
;
279 * Let TKIP code verify IV, but skip decryption.
280 * In the case where hardware checks the IV as well,
281 * we don't even get here, see ieee80211_rx_h_decrypt()
283 if (status
->flag
& RX_FLAG_DECRYPTED
)
286 res
= ieee80211_tkip_decrypt_data(rx
->local
->wep_rx_tfm
,
287 key
, skb
->data
+ hdrlen
,
288 skb
->len
- hdrlen
, rx
->sta
->sta
.addr
,
289 hdr
->addr1
, hwaccel
, rx
->security_idx
,
292 if (res
!= TKIP_DECRYPT_OK
)
293 return RX_DROP_UNUSABLE
;
296 skb_trim(skb
, skb
->len
- IEEE80211_TKIP_ICV_LEN
);
299 memmove(skb
->data
+ IEEE80211_TKIP_IV_LEN
, skb
->data
, hdrlen
);
300 skb_pull(skb
, IEEE80211_TKIP_IV_LEN
);
306 static void ccmp_special_blocks(struct sk_buff
*skb
, u8
*pn
, u8
*b_0
, u8
*aad
)
309 int a4_included
, mgmt
;
313 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
316 * Mask FC: zero subtype b4 b5 b6 (if not mgmt)
317 * Retry, PwrMgt, MoreData; set Protected
319 mgmt
= ieee80211_is_mgmt(hdr
->frame_control
);
320 mask_fc
= hdr
->frame_control
;
321 mask_fc
&= ~cpu_to_le16(IEEE80211_FCTL_RETRY
|
322 IEEE80211_FCTL_PM
| IEEE80211_FCTL_MOREDATA
);
324 mask_fc
&= ~cpu_to_le16(0x0070);
325 mask_fc
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
327 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
329 a4_included
= ieee80211_has_a4(hdr
->frame_control
);
331 if (ieee80211_is_data_qos(hdr
->frame_control
))
332 qos_tid
= *ieee80211_get_qos_ctl(hdr
) & IEEE80211_QOS_CTL_TID_MASK
;
336 /* In CCM, the initial vectors (IV) used for CTR mode encryption and CBC
337 * mode authentication are not allowed to collide, yet both are derived
338 * from this vector b_0. We only set L := 1 here to indicate that the
339 * data size can be represented in (L+1) bytes. The CCM layer will take
340 * care of storing the data length in the top (L+1) bytes and setting
341 * and clearing the other bits as is required to derive the two IVs.
345 /* Nonce: Nonce Flags | A2 | PN
346 * Nonce Flags: Priority (b0..b3) | Management (b4) | Reserved (b5..b7)
348 b_0
[1] = qos_tid
| (mgmt
<< 4);
349 memcpy(&b_0
[2], hdr
->addr2
, ETH_ALEN
);
350 memcpy(&b_0
[8], pn
, IEEE80211_CCMP_PN_LEN
);
352 /* AAD (extra authenticate-only data) / masked 802.11 header
353 * FC | A1 | A2 | A3 | SC | [A4] | [QC] */
354 put_unaligned_be16(len_a
, &aad
[0]);
355 put_unaligned(mask_fc
, (__le16
*)&aad
[2]);
356 memcpy(&aad
[4], &hdr
->addr1
, 3 * ETH_ALEN
);
358 /* Mask Seq#, leave Frag# */
359 aad
[22] = *((u8
*) &hdr
->seq_ctrl
) & 0x0f;
363 memcpy(&aad
[24], hdr
->addr4
, ETH_ALEN
);
367 memset(&aad
[24], 0, ETH_ALEN
+ IEEE80211_QOS_CTL_LEN
);
373 static inline void ccmp_pn2hdr(u8
*hdr
, u8
*pn
, int key_id
)
378 hdr
[3] = 0x20 | (key_id
<< 6);
386 static inline void ccmp_hdr2pn(u8
*pn
, u8
*hdr
)
397 static int ccmp_encrypt_skb(struct ieee80211_tx_data
*tx
, struct sk_buff
*skb
,
398 unsigned int mic_len
)
400 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
401 struct ieee80211_key
*key
= tx
->key
;
402 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
403 int hdrlen
, len
, tail
;
407 u8 aad
[2 * AES_BLOCK_SIZE
];
408 u8 b_0
[AES_BLOCK_SIZE
];
410 if (info
->control
.hw_key
&&
411 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_GENERATE_IV
) &&
412 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
) &&
413 !((info
->control
.hw_key
->flags
&
414 IEEE80211_KEY_FLAG_GENERATE_IV_MGMT
) &&
415 ieee80211_is_mgmt(hdr
->frame_control
))) {
417 * hwaccel has no need for preallocated room for CCMP
418 * header or MIC fields
423 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
424 len
= skb
->len
- hdrlen
;
426 if (info
->control
.hw_key
)
431 if (WARN_ON(skb_tailroom(skb
) < tail
||
432 skb_headroom(skb
) < IEEE80211_CCMP_HDR_LEN
))
435 pos
= skb_push(skb
, IEEE80211_CCMP_HDR_LEN
);
436 memmove(pos
, pos
+ IEEE80211_CCMP_HDR_LEN
, hdrlen
);
438 /* the HW only needs room for the IV, but not the actual IV */
439 if (info
->control
.hw_key
&&
440 (info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
))
443 hdr
= (struct ieee80211_hdr
*) pos
;
446 pn64
= atomic64_inc_return(&key
->u
.ccmp
.tx_pn
);
455 ccmp_pn2hdr(pos
, pn
, key
->conf
.keyidx
);
457 /* hwaccel - with software CCMP header */
458 if (info
->control
.hw_key
)
461 pos
+= IEEE80211_CCMP_HDR_LEN
;
462 ccmp_special_blocks(skb
, pn
, b_0
, aad
);
463 ieee80211_aes_ccm_encrypt(key
->u
.ccmp
.tfm
, b_0
, aad
, pos
, len
,
464 skb_put(skb
, mic_len
), mic_len
);
471 ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data
*tx
,
472 unsigned int mic_len
)
476 ieee80211_tx_set_protected(tx
);
478 skb_queue_walk(&tx
->skbs
, skb
) {
479 if (ccmp_encrypt_skb(tx
, skb
, mic_len
) < 0)
488 ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data
*rx
,
489 unsigned int mic_len
)
491 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)rx
->skb
->data
;
493 struct ieee80211_key
*key
= rx
->key
;
494 struct sk_buff
*skb
= rx
->skb
;
495 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
496 u8 pn
[IEEE80211_CCMP_PN_LEN
];
500 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
502 if (!ieee80211_is_data(hdr
->frame_control
) &&
503 !ieee80211_is_robust_mgmt_frame(skb
))
506 data_len
= skb
->len
- hdrlen
- IEEE80211_CCMP_HDR_LEN
- mic_len
;
507 if (!rx
->sta
|| data_len
< 0)
508 return RX_DROP_UNUSABLE
;
510 if (status
->flag
& RX_FLAG_DECRYPTED
) {
511 if (!pskb_may_pull(rx
->skb
, hdrlen
+ IEEE80211_CCMP_HDR_LEN
))
512 return RX_DROP_UNUSABLE
;
514 if (skb_linearize(rx
->skb
))
515 return RX_DROP_UNUSABLE
;
518 ccmp_hdr2pn(pn
, skb
->data
+ hdrlen
);
520 queue
= rx
->security_idx
;
522 if (memcmp(pn
, key
->u
.ccmp
.rx_pn
[queue
], IEEE80211_CCMP_PN_LEN
) <= 0) {
523 key
->u
.ccmp
.replays
++;
524 return RX_DROP_UNUSABLE
;
527 if (!(status
->flag
& RX_FLAG_DECRYPTED
)) {
528 u8 aad
[2 * AES_BLOCK_SIZE
];
529 u8 b_0
[AES_BLOCK_SIZE
];
530 /* hardware didn't decrypt/verify MIC */
531 ccmp_special_blocks(skb
, pn
, b_0
, aad
);
533 if (ieee80211_aes_ccm_decrypt(
534 key
->u
.ccmp
.tfm
, b_0
, aad
,
535 skb
->data
+ hdrlen
+ IEEE80211_CCMP_HDR_LEN
,
537 skb
->data
+ skb
->len
- mic_len
, mic_len
))
538 return RX_DROP_UNUSABLE
;
541 memcpy(key
->u
.ccmp
.rx_pn
[queue
], pn
, IEEE80211_CCMP_PN_LEN
);
543 /* Remove CCMP header and MIC */
544 if (pskb_trim(skb
, skb
->len
- mic_len
))
545 return RX_DROP_UNUSABLE
;
546 memmove(skb
->data
+ IEEE80211_CCMP_HDR_LEN
, skb
->data
, hdrlen
);
547 skb_pull(skb
, IEEE80211_CCMP_HDR_LEN
);
552 static void gcmp_special_blocks(struct sk_buff
*skb
, u8
*pn
, u8
*j_0
, u8
*aad
)
556 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
558 memcpy(j_0
, hdr
->addr2
, ETH_ALEN
);
559 memcpy(&j_0
[ETH_ALEN
], pn
, IEEE80211_GCMP_PN_LEN
);
562 j_0
[AES_BLOCK_SIZE
- 1] = 0x01;
564 /* AAD (extra authenticate-only data) / masked 802.11 header
565 * FC | A1 | A2 | A3 | SC | [A4] | [QC]
567 put_unaligned_be16(ieee80211_hdrlen(hdr
->frame_control
) - 2, &aad
[0]);
568 /* Mask FC: zero subtype b4 b5 b6 (if not mgmt)
569 * Retry, PwrMgt, MoreData; set Protected
571 mask_fc
= hdr
->frame_control
;
572 mask_fc
&= ~cpu_to_le16(IEEE80211_FCTL_RETRY
|
573 IEEE80211_FCTL_PM
| IEEE80211_FCTL_MOREDATA
);
574 if (!ieee80211_is_mgmt(hdr
->frame_control
))
575 mask_fc
&= ~cpu_to_le16(0x0070);
576 mask_fc
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
578 put_unaligned(mask_fc
, (__le16
*)&aad
[2]);
579 memcpy(&aad
[4], &hdr
->addr1
, 3 * ETH_ALEN
);
581 /* Mask Seq#, leave Frag# */
582 aad
[22] = *((u8
*)&hdr
->seq_ctrl
) & 0x0f;
585 if (ieee80211_is_data_qos(hdr
->frame_control
))
586 qos_tid
= *ieee80211_get_qos_ctl(hdr
) &
587 IEEE80211_QOS_CTL_TID_MASK
;
591 if (ieee80211_has_a4(hdr
->frame_control
)) {
592 memcpy(&aad
[24], hdr
->addr4
, ETH_ALEN
);
596 memset(&aad
[24], 0, ETH_ALEN
+ IEEE80211_QOS_CTL_LEN
);
601 static inline void gcmp_pn2hdr(u8
*hdr
, const u8
*pn
, int key_id
)
606 hdr
[3] = 0x20 | (key_id
<< 6);
613 static inline void gcmp_hdr2pn(u8
*pn
, const u8
*hdr
)
623 static int gcmp_encrypt_skb(struct ieee80211_tx_data
*tx
, struct sk_buff
*skb
)
625 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
626 struct ieee80211_key
*key
= tx
->key
;
627 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
628 int hdrlen
, len
, tail
;
632 u8 aad
[2 * AES_BLOCK_SIZE
];
633 u8 j_0
[AES_BLOCK_SIZE
];
635 if (info
->control
.hw_key
&&
636 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_GENERATE_IV
) &&
637 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
) &&
638 !((info
->control
.hw_key
->flags
&
639 IEEE80211_KEY_FLAG_GENERATE_IV_MGMT
) &&
640 ieee80211_is_mgmt(hdr
->frame_control
))) {
641 /* hwaccel has no need for preallocated room for GCMP
642 * header or MIC fields
647 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
648 len
= skb
->len
- hdrlen
;
650 if (info
->control
.hw_key
)
653 tail
= IEEE80211_GCMP_MIC_LEN
;
655 if (WARN_ON(skb_tailroom(skb
) < tail
||
656 skb_headroom(skb
) < IEEE80211_GCMP_HDR_LEN
))
659 pos
= skb_push(skb
, IEEE80211_GCMP_HDR_LEN
);
660 memmove(pos
, pos
+ IEEE80211_GCMP_HDR_LEN
, hdrlen
);
661 skb_set_network_header(skb
, skb_network_offset(skb
) +
662 IEEE80211_GCMP_HDR_LEN
);
664 /* the HW only needs room for the IV, but not the actual IV */
665 if (info
->control
.hw_key
&&
666 (info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
))
669 hdr
= (struct ieee80211_hdr
*)pos
;
672 pn64
= atomic64_inc_return(&key
->u
.gcmp
.tx_pn
);
681 gcmp_pn2hdr(pos
, pn
, key
->conf
.keyidx
);
683 /* hwaccel - with software GCMP header */
684 if (info
->control
.hw_key
)
687 pos
+= IEEE80211_GCMP_HDR_LEN
;
688 gcmp_special_blocks(skb
, pn
, j_0
, aad
);
689 ieee80211_aes_gcm_encrypt(key
->u
.gcmp
.tfm
, j_0
, aad
, pos
, len
,
690 skb_put(skb
, IEEE80211_GCMP_MIC_LEN
));
696 ieee80211_crypto_gcmp_encrypt(struct ieee80211_tx_data
*tx
)
700 ieee80211_tx_set_protected(tx
);
702 skb_queue_walk(&tx
->skbs
, skb
) {
703 if (gcmp_encrypt_skb(tx
, skb
) < 0)
711 ieee80211_crypto_gcmp_decrypt(struct ieee80211_rx_data
*rx
)
713 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)rx
->skb
->data
;
715 struct ieee80211_key
*key
= rx
->key
;
716 struct sk_buff
*skb
= rx
->skb
;
717 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
718 u8 pn
[IEEE80211_GCMP_PN_LEN
];
722 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
724 if (!ieee80211_is_data(hdr
->frame_control
) &&
725 !ieee80211_is_robust_mgmt_frame(skb
))
728 data_len
= skb
->len
- hdrlen
- IEEE80211_GCMP_HDR_LEN
-
729 IEEE80211_GCMP_MIC_LEN
;
730 if (!rx
->sta
|| data_len
< 0)
731 return RX_DROP_UNUSABLE
;
733 if (status
->flag
& RX_FLAG_DECRYPTED
) {
734 if (!pskb_may_pull(rx
->skb
, hdrlen
+ IEEE80211_GCMP_HDR_LEN
))
735 return RX_DROP_UNUSABLE
;
737 if (skb_linearize(rx
->skb
))
738 return RX_DROP_UNUSABLE
;
741 gcmp_hdr2pn(pn
, skb
->data
+ hdrlen
);
743 queue
= rx
->security_idx
;
745 if (memcmp(pn
, key
->u
.gcmp
.rx_pn
[queue
], IEEE80211_GCMP_PN_LEN
) <= 0) {
746 key
->u
.gcmp
.replays
++;
747 return RX_DROP_UNUSABLE
;
750 if (!(status
->flag
& RX_FLAG_DECRYPTED
)) {
751 u8 aad
[2 * AES_BLOCK_SIZE
];
752 u8 j_0
[AES_BLOCK_SIZE
];
753 /* hardware didn't decrypt/verify MIC */
754 gcmp_special_blocks(skb
, pn
, j_0
, aad
);
756 if (ieee80211_aes_gcm_decrypt(
757 key
->u
.gcmp
.tfm
, j_0
, aad
,
758 skb
->data
+ hdrlen
+ IEEE80211_GCMP_HDR_LEN
,
760 skb
->data
+ skb
->len
- IEEE80211_GCMP_MIC_LEN
))
761 return RX_DROP_UNUSABLE
;
764 memcpy(key
->u
.gcmp
.rx_pn
[queue
], pn
, IEEE80211_GCMP_PN_LEN
);
766 /* Remove GCMP header and MIC */
767 if (pskb_trim(skb
, skb
->len
- IEEE80211_GCMP_MIC_LEN
))
768 return RX_DROP_UNUSABLE
;
769 memmove(skb
->data
+ IEEE80211_GCMP_HDR_LEN
, skb
->data
, hdrlen
);
770 skb_pull(skb
, IEEE80211_GCMP_HDR_LEN
);
775 static ieee80211_tx_result
776 ieee80211_crypto_cs_encrypt(struct ieee80211_tx_data
*tx
,
779 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
780 struct ieee80211_key
*key
= tx
->key
;
781 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
782 const struct ieee80211_cipher_scheme
*cs
= key
->sta
->cipher_scheme
;
786 if (info
->control
.hw_key
&&
787 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
)) {
788 /* hwaccel has no need for preallocated head room */
792 if (unlikely(skb_headroom(skb
) < cs
->hdr_len
&&
793 pskb_expand_head(skb
, cs
->hdr_len
, 0, GFP_ATOMIC
)))
796 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
798 pos
= skb_push(skb
, cs
->hdr_len
);
799 memmove(pos
, pos
+ cs
->hdr_len
, hdrlen
);
804 static inline int ieee80211_crypto_cs_pn_compare(u8
*pn1
, u8
*pn2
, int len
)
808 /* pn is little endian */
809 for (i
= len
- 1; i
>= 0; i
--) {
812 else if (pn1
[i
] > pn2
[i
])
819 static ieee80211_rx_result
820 ieee80211_crypto_cs_decrypt(struct ieee80211_rx_data
*rx
)
822 struct ieee80211_key
*key
= rx
->key
;
823 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)rx
->skb
->data
;
824 const struct ieee80211_cipher_scheme
*cs
= NULL
;
825 int hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
826 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(rx
->skb
);
832 if (!rx
->sta
|| !rx
->sta
->cipher_scheme
||
833 !(status
->flag
& RX_FLAG_DECRYPTED
))
834 return RX_DROP_UNUSABLE
;
836 if (!ieee80211_is_data(hdr
->frame_control
))
839 cs
= rx
->sta
->cipher_scheme
;
841 data_len
= rx
->skb
->len
- hdrlen
- cs
->hdr_len
;
844 return RX_DROP_UNUSABLE
;
846 if (ieee80211_is_data_qos(hdr
->frame_control
))
847 qos_tid
= *ieee80211_get_qos_ctl(hdr
) &
848 IEEE80211_QOS_CTL_TID_MASK
;
852 if (skb_linearize(rx
->skb
))
853 return RX_DROP_UNUSABLE
;
855 hdr
= (struct ieee80211_hdr
*)rx
->skb
->data
;
857 rx_pn
= key
->u
.gen
.rx_pn
[qos_tid
];
858 skb_pn
= rx
->skb
->data
+ hdrlen
+ cs
->pn_off
;
860 if (ieee80211_crypto_cs_pn_compare(skb_pn
, rx_pn
, cs
->pn_len
) <= 0)
861 return RX_DROP_UNUSABLE
;
863 memcpy(rx_pn
, skb_pn
, cs
->pn_len
);
865 /* remove security header and MIC */
866 if (pskb_trim(rx
->skb
, rx
->skb
->len
- cs
->mic_len
))
867 return RX_DROP_UNUSABLE
;
869 memmove(rx
->skb
->data
+ cs
->hdr_len
, rx
->skb
->data
, hdrlen
);
870 skb_pull(rx
->skb
, cs
->hdr_len
);
875 static void bip_aad(struct sk_buff
*skb
, u8
*aad
)
878 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
880 /* BIP AAD: FC(masked) || A1 || A2 || A3 */
882 /* FC type/subtype */
883 /* Mask FC Retry, PwrMgt, MoreData flags to zero */
884 mask_fc
= hdr
->frame_control
;
885 mask_fc
&= ~cpu_to_le16(IEEE80211_FCTL_RETRY
| IEEE80211_FCTL_PM
|
886 IEEE80211_FCTL_MOREDATA
);
887 put_unaligned(mask_fc
, (__le16
*) &aad
[0]);
889 memcpy(aad
+ 2, &hdr
->addr1
, 3 * ETH_ALEN
);
893 static inline void bip_ipn_set64(u8
*d
, u64 pn
)
903 static inline void bip_ipn_swap(u8
*d
, const u8
*s
)
915 ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data
*tx
)
918 struct ieee80211_tx_info
*info
;
919 struct ieee80211_key
*key
= tx
->key
;
920 struct ieee80211_mmie
*mmie
;
924 if (WARN_ON(skb_queue_len(&tx
->skbs
) != 1))
927 skb
= skb_peek(&tx
->skbs
);
929 info
= IEEE80211_SKB_CB(skb
);
931 if (info
->control
.hw_key
)
934 if (WARN_ON(skb_tailroom(skb
) < sizeof(*mmie
)))
937 mmie
= (struct ieee80211_mmie
*) skb_put(skb
, sizeof(*mmie
));
938 mmie
->element_id
= WLAN_EID_MMIE
;
939 mmie
->length
= sizeof(*mmie
) - 2;
940 mmie
->key_id
= cpu_to_le16(key
->conf
.keyidx
);
943 pn64
= atomic64_inc_return(&key
->u
.aes_cmac
.tx_pn
);
945 bip_ipn_set64(mmie
->sequence_number
, pn64
);
950 * MIC = AES-128-CMAC(IGTK, AAD || Management Frame Body || MMIE, 64)
952 ieee80211_aes_cmac(key
->u
.aes_cmac
.tfm
, aad
,
953 skb
->data
+ 24, skb
->len
- 24, mmie
->mic
);
960 ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data
*rx
)
962 struct sk_buff
*skb
= rx
->skb
;
963 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
964 struct ieee80211_key
*key
= rx
->key
;
965 struct ieee80211_mmie
*mmie
;
966 u8 aad
[20], mic
[8], ipn
[6];
967 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
969 if (!ieee80211_is_mgmt(hdr
->frame_control
))
972 /* management frames are already linear */
974 if (skb
->len
< 24 + sizeof(*mmie
))
975 return RX_DROP_UNUSABLE
;
977 mmie
= (struct ieee80211_mmie
*)
978 (skb
->data
+ skb
->len
- sizeof(*mmie
));
979 if (mmie
->element_id
!= WLAN_EID_MMIE
||
980 mmie
->length
!= sizeof(*mmie
) - 2)
981 return RX_DROP_UNUSABLE
; /* Invalid MMIE */
983 bip_ipn_swap(ipn
, mmie
->sequence_number
);
985 if (memcmp(ipn
, key
->u
.aes_cmac
.rx_pn
, 6) <= 0) {
986 key
->u
.aes_cmac
.replays
++;
987 return RX_DROP_UNUSABLE
;
990 if (!(status
->flag
& RX_FLAG_DECRYPTED
)) {
991 /* hardware didn't decrypt/verify MIC */
993 ieee80211_aes_cmac(key
->u
.aes_cmac
.tfm
, aad
,
994 skb
->data
+ 24, skb
->len
- 24, mic
);
995 if (memcmp(mic
, mmie
->mic
, sizeof(mmie
->mic
)) != 0) {
996 key
->u
.aes_cmac
.icverrors
++;
997 return RX_DROP_UNUSABLE
;
1001 memcpy(key
->u
.aes_cmac
.rx_pn
, ipn
, 6);
1004 skb_trim(skb
, skb
->len
- sizeof(*mmie
));
1010 ieee80211_crypto_hw_encrypt(struct ieee80211_tx_data
*tx
)
1012 struct sk_buff
*skb
;
1013 struct ieee80211_tx_info
*info
= NULL
;
1014 ieee80211_tx_result res
;
1016 skb_queue_walk(&tx
->skbs
, skb
) {
1017 info
= IEEE80211_SKB_CB(skb
);
1019 /* handle hw-only algorithm */
1020 if (!info
->control
.hw_key
)
1023 if (tx
->key
->sta
->cipher_scheme
) {
1024 res
= ieee80211_crypto_cs_encrypt(tx
, skb
);
1025 if (res
!= TX_CONTINUE
)
1030 ieee80211_tx_set_protected(tx
);
1036 ieee80211_crypto_hw_decrypt(struct ieee80211_rx_data
*rx
)
1038 if (rx
->sta
&& rx
->sta
->cipher_scheme
)
1039 return ieee80211_crypto_cs_decrypt(rx
);
1041 return RX_DROP_UNUSABLE
;