2 * Copyright 2002-2004, Instant802 Networks, Inc.
3 * Copyright 2008, Jouni Malinen <j@w1.fi>
4 * Copyright (C) 2016 Intel Deutschland GmbH
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.
11 #include <linux/netdevice.h>
12 #include <linux/types.h>
13 #include <linux/skbuff.h>
14 #include <linux/compiler.h>
15 #include <linux/ieee80211.h>
16 #include <linux/gfp.h>
17 #include <asm/unaligned.h>
18 #include <net/mac80211.h>
19 #include <crypto/aes.h>
21 #include "ieee80211_i.h"
31 ieee80211_tx_h_michael_mic_add(struct ieee80211_tx_data
*tx
)
36 struct ieee80211_hdr
*hdr
;
37 struct sk_buff
*skb
= tx
->skb
;
38 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
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
))
46 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
47 if (skb
->len
< hdrlen
)
50 data
= skb
->data
+ hdrlen
;
51 data_len
= skb
->len
- hdrlen
;
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
;
58 if (info
->control
.hw_key
&&
59 (info
->flags
& IEEE80211_TX_CTL_DONTFRAG
||
60 ieee80211_hw_check(&tx
->local
->hw
, SUPPORTS_TX_FRAG
)) &&
61 !(tx
->key
->conf
.flags
& IEEE80211_KEY_FLAG_GENERATE_MMIC
)) {
62 /* hwaccel - with no need for SW-generated MMIC */
66 tail
= MICHAEL_MIC_LEN
;
67 if (!info
->control
.hw_key
)
68 tail
+= IEEE80211_TKIP_ICV_LEN
;
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
))
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
))
88 ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data
*rx
)
90 u8
*data
, *key
= NULL
;
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
;
99 * it makes no sense to check for MIC errors on anything other
102 if (!ieee80211_is_data_present(hdr
->frame_control
))
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.
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
;
115 if (!(status
->flag
& RX_FLAG_IV_STRIPPED
) && rx
->key
&&
116 rx
->key
->conf
.cipher
== WLAN_CIPHER_SUITE_TKIP
)
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.
127 if (!rx
->key
|| rx
->key
->conf
.cipher
!= WLAN_CIPHER_SUITE_TKIP
||
128 !(status
->flag
& RX_FLAG_DECRYPTED
))
131 if (rx
->sdata
->vif
.type
== NL80211_IFTYPE_AP
&& rx
->key
->conf
.keyidx
) {
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
138 return RX_DROP_UNUSABLE
;
141 if (status
->flag
& RX_FLAG_MMIC_ERROR
)
144 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
145 if (skb
->len
< hdrlen
+ MICHAEL_MIC_LEN
)
146 return RX_DROP_UNUSABLE
;
148 if (skb_linearize(rx
->skb
))
149 return RX_DROP_UNUSABLE
;
150 hdr
= (void *)skb
->data
;
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 (memcmp(mic
, data
+ data_len
, MICHAEL_MIC_LEN
) != 0)
159 /* remove Michael MIC from payload */
160 skb_trim(skb
, skb
->len
- MICHAEL_MIC_LEN
);
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
;
170 rx
->key
->u
.tkip
.mic_failures
++;
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
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,
184 return RX_DROP_UNUSABLE
;
187 static int tkip_encrypt_skb(struct ieee80211_tx_data
*tx
, struct sk_buff
*skb
)
189 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
190 struct ieee80211_key
*key
= tx
->key
;
191 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
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 */
204 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
205 len
= skb
->len
- hdrlen
;
207 if (info
->control
.hw_key
)
210 tail
= IEEE80211_TKIP_ICV_LEN
;
212 if (WARN_ON(skb_tailroom(skb
) < tail
||
213 skb_headroom(skb
) < IEEE80211_TKIP_IV_LEN
))
216 pos
= skb_push(skb
, IEEE80211_TKIP_IV_LEN
);
217 memmove(pos
, pos
+ IEEE80211_TKIP_IV_LEN
, hdrlen
);
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
))
225 /* Increase IV for the frame */
226 pn
= atomic64_inc_return(&key
->conf
.tx_pn
);
227 pos
= ieee80211_tkip_add_iv(pos
, &key
->conf
, pn
);
229 /* hwaccel - with software IV */
230 if (info
->control
.hw_key
)
233 /* Add room for ICV */
234 skb_put(skb
, IEEE80211_TKIP_ICV_LEN
);
236 return ieee80211_tkip_encrypt_data(tx
->local
->wep_tx_tfm
,
242 ieee80211_crypto_tkip_encrypt(struct ieee80211_tx_data
*tx
)
246 ieee80211_tx_set_protected(tx
);
248 skb_queue_walk(&tx
->skbs
, skb
) {
249 if (tkip_encrypt_skb(tx
, skb
) < 0)
258 ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data
*rx
)
260 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) rx
->skb
->data
;
261 int hdrlen
, res
, hwaccel
= 0;
262 struct ieee80211_key
*key
= rx
->key
;
263 struct sk_buff
*skb
= rx
->skb
;
264 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
266 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
268 if (!ieee80211_is_data(hdr
->frame_control
))
271 if (!rx
->sta
|| skb
->len
- hdrlen
< 12)
272 return RX_DROP_UNUSABLE
;
274 /* it may be possible to optimize this a bit more */
275 if (skb_linearize(rx
->skb
))
276 return RX_DROP_UNUSABLE
;
277 hdr
= (void *)skb
->data
;
280 * Let TKIP code verify IV, but skip decryption.
281 * In the case where hardware checks the IV as well,
282 * we don't even get here, see ieee80211_rx_h_decrypt()
284 if (status
->flag
& RX_FLAG_DECRYPTED
)
287 res
= ieee80211_tkip_decrypt_data(rx
->local
->wep_rx_tfm
,
288 key
, skb
->data
+ hdrlen
,
289 skb
->len
- hdrlen
, rx
->sta
->sta
.addr
,
290 hdr
->addr1
, hwaccel
, rx
->security_idx
,
293 if (res
!= TKIP_DECRYPT_OK
)
294 return RX_DROP_UNUSABLE
;
297 if (!(status
->flag
& RX_FLAG_ICV_STRIPPED
))
298 skb_trim(skb
, skb
->len
- IEEE80211_TKIP_ICV_LEN
);
301 memmove(skb
->data
+ IEEE80211_TKIP_IV_LEN
, skb
->data
, hdrlen
);
302 skb_pull(skb
, IEEE80211_TKIP_IV_LEN
);
308 static void ccmp_special_blocks(struct sk_buff
*skb
, u8
*pn
, u8
*b_0
, u8
*aad
)
311 int a4_included
, mgmt
;
315 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
318 * Mask FC: zero subtype b4 b5 b6 (if not mgmt)
319 * Retry, PwrMgt, MoreData; set Protected
321 mgmt
= ieee80211_is_mgmt(hdr
->frame_control
);
322 mask_fc
= hdr
->frame_control
;
323 mask_fc
&= ~cpu_to_le16(IEEE80211_FCTL_RETRY
|
324 IEEE80211_FCTL_PM
| IEEE80211_FCTL_MOREDATA
);
326 mask_fc
&= ~cpu_to_le16(0x0070);
327 mask_fc
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
329 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
331 a4_included
= ieee80211_has_a4(hdr
->frame_control
);
333 if (ieee80211_is_data_qos(hdr
->frame_control
))
334 qos_tid
= *ieee80211_get_qos_ctl(hdr
) & IEEE80211_QOS_CTL_TID_MASK
;
338 /* In CCM, the initial vectors (IV) used for CTR mode encryption and CBC
339 * mode authentication are not allowed to collide, yet both are derived
340 * from this vector b_0. We only set L := 1 here to indicate that the
341 * data size can be represented in (L+1) bytes. The CCM layer will take
342 * care of storing the data length in the top (L+1) bytes and setting
343 * and clearing the other bits as is required to derive the two IVs.
347 /* Nonce: Nonce Flags | A2 | PN
348 * Nonce Flags: Priority (b0..b3) | Management (b4) | Reserved (b5..b7)
350 b_0
[1] = qos_tid
| (mgmt
<< 4);
351 memcpy(&b_0
[2], hdr
->addr2
, ETH_ALEN
);
352 memcpy(&b_0
[8], pn
, IEEE80211_CCMP_PN_LEN
);
354 /* AAD (extra authenticate-only data) / masked 802.11 header
355 * FC | A1 | A2 | A3 | SC | [A4] | [QC] */
356 put_unaligned_be16(len_a
, &aad
[0]);
357 put_unaligned(mask_fc
, (__le16
*)&aad
[2]);
358 memcpy(&aad
[4], &hdr
->addr1
, 3 * ETH_ALEN
);
360 /* Mask Seq#, leave Frag# */
361 aad
[22] = *((u8
*) &hdr
->seq_ctrl
) & 0x0f;
365 memcpy(&aad
[24], hdr
->addr4
, ETH_ALEN
);
369 memset(&aad
[24], 0, ETH_ALEN
+ IEEE80211_QOS_CTL_LEN
);
375 static inline void ccmp_pn2hdr(u8
*hdr
, u8
*pn
, int key_id
)
380 hdr
[3] = 0x20 | (key_id
<< 6);
388 static inline void ccmp_hdr2pn(u8
*pn
, u8
*hdr
)
399 static int ccmp_encrypt_skb(struct ieee80211_tx_data
*tx
, struct sk_buff
*skb
,
400 unsigned int mic_len
)
402 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
403 struct ieee80211_key
*key
= tx
->key
;
404 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
405 int hdrlen
, len
, tail
;
410 u8 b_0
[AES_BLOCK_SIZE
];
412 if (info
->control
.hw_key
&&
413 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_GENERATE_IV
) &&
414 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
) &&
415 !((info
->control
.hw_key
->flags
&
416 IEEE80211_KEY_FLAG_GENERATE_IV_MGMT
) &&
417 ieee80211_is_mgmt(hdr
->frame_control
))) {
419 * hwaccel has no need for preallocated room for CCMP
420 * header or MIC fields
425 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
426 len
= skb
->len
- hdrlen
;
428 if (info
->control
.hw_key
)
433 if (WARN_ON(skb_tailroom(skb
) < tail
||
434 skb_headroom(skb
) < IEEE80211_CCMP_HDR_LEN
))
437 pos
= skb_push(skb
, IEEE80211_CCMP_HDR_LEN
);
438 memmove(pos
, pos
+ IEEE80211_CCMP_HDR_LEN
, hdrlen
);
440 /* the HW only needs room for the IV, but not the actual IV */
441 if (info
->control
.hw_key
&&
442 (info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
))
445 hdr
= (struct ieee80211_hdr
*) pos
;
448 pn64
= atomic64_inc_return(&key
->conf
.tx_pn
);
457 ccmp_pn2hdr(pos
, pn
, key
->conf
.keyidx
);
459 /* hwaccel - with software CCMP header */
460 if (info
->control
.hw_key
)
463 pos
+= IEEE80211_CCMP_HDR_LEN
;
464 ccmp_special_blocks(skb
, pn
, b_0
, aad
);
465 return ieee80211_aes_ccm_encrypt(key
->u
.ccmp
.tfm
, b_0
, aad
, pos
, len
,
466 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 if (status
->flag
& RX_FLAG_DECRYPTED
) {
507 if (!pskb_may_pull(rx
->skb
, hdrlen
+ IEEE80211_CCMP_HDR_LEN
))
508 return RX_DROP_UNUSABLE
;
509 if (status
->flag
& RX_FLAG_MIC_STRIPPED
)
512 if (skb_linearize(rx
->skb
))
513 return RX_DROP_UNUSABLE
;
516 data_len
= skb
->len
- hdrlen
- IEEE80211_CCMP_HDR_LEN
- mic_len
;
517 if (!rx
->sta
|| data_len
< 0)
518 return RX_DROP_UNUSABLE
;
520 if (!(status
->flag
& RX_FLAG_PN_VALIDATED
)) {
523 ccmp_hdr2pn(pn
, skb
->data
+ hdrlen
);
525 queue
= rx
->security_idx
;
527 res
= memcmp(pn
, key
->u
.ccmp
.rx_pn
[queue
],
528 IEEE80211_CCMP_PN_LEN
);
530 (!res
&& !(status
->flag
& RX_FLAG_ALLOW_SAME_PN
))) {
531 key
->u
.ccmp
.replays
++;
532 return RX_DROP_UNUSABLE
;
535 if (!(status
->flag
& RX_FLAG_DECRYPTED
)) {
536 u8 aad
[2 * AES_BLOCK_SIZE
];
537 u8 b_0
[AES_BLOCK_SIZE
];
538 /* hardware didn't decrypt/verify MIC */
539 ccmp_special_blocks(skb
, pn
, b_0
, aad
);
541 if (ieee80211_aes_ccm_decrypt(
542 key
->u
.ccmp
.tfm
, b_0
, aad
,
543 skb
->data
+ hdrlen
+ IEEE80211_CCMP_HDR_LEN
,
545 skb
->data
+ skb
->len
- mic_len
, mic_len
))
546 return RX_DROP_UNUSABLE
;
549 memcpy(key
->u
.ccmp
.rx_pn
[queue
], pn
, IEEE80211_CCMP_PN_LEN
);
552 /* Remove CCMP header and MIC */
553 if (pskb_trim(skb
, skb
->len
- mic_len
))
554 return RX_DROP_UNUSABLE
;
555 memmove(skb
->data
+ IEEE80211_CCMP_HDR_LEN
, skb
->data
, hdrlen
);
556 skb_pull(skb
, IEEE80211_CCMP_HDR_LEN
);
561 static void gcmp_special_blocks(struct sk_buff
*skb
, u8
*pn
, u8
*j_0
, u8
*aad
)
565 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
567 memcpy(j_0
, hdr
->addr2
, ETH_ALEN
);
568 memcpy(&j_0
[ETH_ALEN
], pn
, IEEE80211_GCMP_PN_LEN
);
571 j_0
[AES_BLOCK_SIZE
- 1] = 0x01;
573 /* AAD (extra authenticate-only data) / masked 802.11 header
574 * FC | A1 | A2 | A3 | SC | [A4] | [QC]
576 put_unaligned_be16(ieee80211_hdrlen(hdr
->frame_control
) - 2, &aad
[0]);
577 /* Mask FC: zero subtype b4 b5 b6 (if not mgmt)
578 * Retry, PwrMgt, MoreData; set Protected
580 mask_fc
= hdr
->frame_control
;
581 mask_fc
&= ~cpu_to_le16(IEEE80211_FCTL_RETRY
|
582 IEEE80211_FCTL_PM
| IEEE80211_FCTL_MOREDATA
);
583 if (!ieee80211_is_mgmt(hdr
->frame_control
))
584 mask_fc
&= ~cpu_to_le16(0x0070);
585 mask_fc
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
587 put_unaligned(mask_fc
, (__le16
*)&aad
[2]);
588 memcpy(&aad
[4], &hdr
->addr1
, 3 * ETH_ALEN
);
590 /* Mask Seq#, leave Frag# */
591 aad
[22] = *((u8
*)&hdr
->seq_ctrl
) & 0x0f;
594 if (ieee80211_is_data_qos(hdr
->frame_control
))
595 qos_tid
= *ieee80211_get_qos_ctl(hdr
) &
596 IEEE80211_QOS_CTL_TID_MASK
;
600 if (ieee80211_has_a4(hdr
->frame_control
)) {
601 memcpy(&aad
[24], hdr
->addr4
, ETH_ALEN
);
605 memset(&aad
[24], 0, ETH_ALEN
+ IEEE80211_QOS_CTL_LEN
);
610 static inline void gcmp_pn2hdr(u8
*hdr
, const u8
*pn
, int key_id
)
615 hdr
[3] = 0x20 | (key_id
<< 6);
622 static inline void gcmp_hdr2pn(u8
*pn
, const u8
*hdr
)
632 static int gcmp_encrypt_skb(struct ieee80211_tx_data
*tx
, struct sk_buff
*skb
)
634 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
635 struct ieee80211_key
*key
= tx
->key
;
636 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
637 int hdrlen
, len
, tail
;
642 u8 j_0
[AES_BLOCK_SIZE
];
644 if (info
->control
.hw_key
&&
645 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_GENERATE_IV
) &&
646 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
) &&
647 !((info
->control
.hw_key
->flags
&
648 IEEE80211_KEY_FLAG_GENERATE_IV_MGMT
) &&
649 ieee80211_is_mgmt(hdr
->frame_control
))) {
650 /* hwaccel has no need for preallocated room for GCMP
651 * header or MIC fields
656 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
657 len
= skb
->len
- hdrlen
;
659 if (info
->control
.hw_key
)
662 tail
= IEEE80211_GCMP_MIC_LEN
;
664 if (WARN_ON(skb_tailroom(skb
) < tail
||
665 skb_headroom(skb
) < IEEE80211_GCMP_HDR_LEN
))
668 pos
= skb_push(skb
, IEEE80211_GCMP_HDR_LEN
);
669 memmove(pos
, pos
+ IEEE80211_GCMP_HDR_LEN
, hdrlen
);
670 skb_set_network_header(skb
, skb_network_offset(skb
) +
671 IEEE80211_GCMP_HDR_LEN
);
673 /* the HW only needs room for the IV, but not the actual IV */
674 if (info
->control
.hw_key
&&
675 (info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
))
678 hdr
= (struct ieee80211_hdr
*)pos
;
681 pn64
= atomic64_inc_return(&key
->conf
.tx_pn
);
690 gcmp_pn2hdr(pos
, pn
, key
->conf
.keyidx
);
692 /* hwaccel - with software GCMP header */
693 if (info
->control
.hw_key
)
696 pos
+= IEEE80211_GCMP_HDR_LEN
;
697 gcmp_special_blocks(skb
, pn
, j_0
, aad
);
698 return ieee80211_aes_gcm_encrypt(key
->u
.gcmp
.tfm
, j_0
, aad
, pos
, len
,
699 skb_put(skb
, IEEE80211_GCMP_MIC_LEN
));
703 ieee80211_crypto_gcmp_encrypt(struct ieee80211_tx_data
*tx
)
707 ieee80211_tx_set_protected(tx
);
709 skb_queue_walk(&tx
->skbs
, skb
) {
710 if (gcmp_encrypt_skb(tx
, skb
) < 0)
718 ieee80211_crypto_gcmp_decrypt(struct ieee80211_rx_data
*rx
)
720 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)rx
->skb
->data
;
722 struct ieee80211_key
*key
= rx
->key
;
723 struct sk_buff
*skb
= rx
->skb
;
724 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
725 u8 pn
[IEEE80211_GCMP_PN_LEN
];
726 int data_len
, queue
, mic_len
= IEEE80211_GCMP_MIC_LEN
;
728 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
730 if (!ieee80211_is_data(hdr
->frame_control
) &&
731 !ieee80211_is_robust_mgmt_frame(skb
))
734 if (status
->flag
& RX_FLAG_DECRYPTED
) {
735 if (!pskb_may_pull(rx
->skb
, hdrlen
+ IEEE80211_GCMP_HDR_LEN
))
736 return RX_DROP_UNUSABLE
;
737 if (status
->flag
& RX_FLAG_MIC_STRIPPED
)
740 if (skb_linearize(rx
->skb
))
741 return RX_DROP_UNUSABLE
;
744 data_len
= skb
->len
- hdrlen
- IEEE80211_GCMP_HDR_LEN
- mic_len
;
745 if (!rx
->sta
|| data_len
< 0)
746 return RX_DROP_UNUSABLE
;
748 if (!(status
->flag
& RX_FLAG_PN_VALIDATED
)) {
751 gcmp_hdr2pn(pn
, skb
->data
+ hdrlen
);
753 queue
= rx
->security_idx
;
755 res
= memcmp(pn
, key
->u
.gcmp
.rx_pn
[queue
],
756 IEEE80211_GCMP_PN_LEN
);
758 (!res
&& !(status
->flag
& RX_FLAG_ALLOW_SAME_PN
))) {
759 key
->u
.gcmp
.replays
++;
760 return RX_DROP_UNUSABLE
;
763 if (!(status
->flag
& RX_FLAG_DECRYPTED
)) {
764 u8 aad
[2 * AES_BLOCK_SIZE
];
765 u8 j_0
[AES_BLOCK_SIZE
];
766 /* hardware didn't decrypt/verify MIC */
767 gcmp_special_blocks(skb
, pn
, j_0
, aad
);
769 if (ieee80211_aes_gcm_decrypt(
770 key
->u
.gcmp
.tfm
, j_0
, aad
,
771 skb
->data
+ hdrlen
+ IEEE80211_GCMP_HDR_LEN
,
773 skb
->data
+ skb
->len
-
774 IEEE80211_GCMP_MIC_LEN
))
775 return RX_DROP_UNUSABLE
;
778 memcpy(key
->u
.gcmp
.rx_pn
[queue
], pn
, IEEE80211_GCMP_PN_LEN
);
781 /* Remove GCMP header and MIC */
782 if (pskb_trim(skb
, skb
->len
- mic_len
))
783 return RX_DROP_UNUSABLE
;
784 memmove(skb
->data
+ IEEE80211_GCMP_HDR_LEN
, skb
->data
, hdrlen
);
785 skb_pull(skb
, IEEE80211_GCMP_HDR_LEN
);
790 static ieee80211_tx_result
791 ieee80211_crypto_cs_encrypt(struct ieee80211_tx_data
*tx
,
794 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
795 struct ieee80211_key
*key
= tx
->key
;
796 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
798 u8
*pos
, iv_len
= key
->conf
.iv_len
;
800 if (info
->control
.hw_key
&&
801 !(info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
)) {
802 /* hwaccel has no need for preallocated head room */
806 if (unlikely(skb_headroom(skb
) < iv_len
&&
807 pskb_expand_head(skb
, iv_len
, 0, GFP_ATOMIC
)))
810 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
812 pos
= skb_push(skb
, iv_len
);
813 memmove(pos
, pos
+ iv_len
, hdrlen
);
818 static inline int ieee80211_crypto_cs_pn_compare(u8
*pn1
, u8
*pn2
, int len
)
822 /* pn is little endian */
823 for (i
= len
- 1; i
>= 0; i
--) {
826 else if (pn1
[i
] > pn2
[i
])
833 static ieee80211_rx_result
834 ieee80211_crypto_cs_decrypt(struct ieee80211_rx_data
*rx
)
836 struct ieee80211_key
*key
= rx
->key
;
837 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)rx
->skb
->data
;
838 const struct ieee80211_cipher_scheme
*cs
= NULL
;
839 int hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
840 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(rx
->skb
);
846 if (!rx
->sta
|| !rx
->sta
->cipher_scheme
||
847 !(status
->flag
& RX_FLAG_DECRYPTED
))
848 return RX_DROP_UNUSABLE
;
850 if (!ieee80211_is_data(hdr
->frame_control
))
853 cs
= rx
->sta
->cipher_scheme
;
855 data_len
= rx
->skb
->len
- hdrlen
- cs
->hdr_len
;
858 return RX_DROP_UNUSABLE
;
860 if (ieee80211_is_data_qos(hdr
->frame_control
))
861 qos_tid
= *ieee80211_get_qos_ctl(hdr
) &
862 IEEE80211_QOS_CTL_TID_MASK
;
866 if (skb_linearize(rx
->skb
))
867 return RX_DROP_UNUSABLE
;
869 hdr
= (struct ieee80211_hdr
*)rx
->skb
->data
;
871 rx_pn
= key
->u
.gen
.rx_pn
[qos_tid
];
872 skb_pn
= rx
->skb
->data
+ hdrlen
+ cs
->pn_off
;
874 if (ieee80211_crypto_cs_pn_compare(skb_pn
, rx_pn
, cs
->pn_len
) <= 0)
875 return RX_DROP_UNUSABLE
;
877 memcpy(rx_pn
, skb_pn
, cs
->pn_len
);
879 /* remove security header and MIC */
880 if (pskb_trim(rx
->skb
, rx
->skb
->len
- cs
->mic_len
))
881 return RX_DROP_UNUSABLE
;
883 memmove(rx
->skb
->data
+ cs
->hdr_len
, rx
->skb
->data
, hdrlen
);
884 skb_pull(rx
->skb
, cs
->hdr_len
);
889 static void bip_aad(struct sk_buff
*skb
, u8
*aad
)
892 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
894 /* BIP AAD: FC(masked) || A1 || A2 || A3 */
896 /* FC type/subtype */
897 /* Mask FC Retry, PwrMgt, MoreData flags to zero */
898 mask_fc
= hdr
->frame_control
;
899 mask_fc
&= ~cpu_to_le16(IEEE80211_FCTL_RETRY
| IEEE80211_FCTL_PM
|
900 IEEE80211_FCTL_MOREDATA
);
901 put_unaligned(mask_fc
, (__le16
*) &aad
[0]);
903 memcpy(aad
+ 2, &hdr
->addr1
, 3 * ETH_ALEN
);
907 static inline void bip_ipn_set64(u8
*d
, u64 pn
)
917 static inline void bip_ipn_swap(u8
*d
, const u8
*s
)
929 ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data
*tx
)
932 struct ieee80211_tx_info
*info
;
933 struct ieee80211_key
*key
= tx
->key
;
934 struct ieee80211_mmie
*mmie
;
938 if (WARN_ON(skb_queue_len(&tx
->skbs
) != 1))
941 skb
= skb_peek(&tx
->skbs
);
943 info
= IEEE80211_SKB_CB(skb
);
945 if (info
->control
.hw_key
)
948 if (WARN_ON(skb_tailroom(skb
) < sizeof(*mmie
)))
951 mmie
= (struct ieee80211_mmie
*) skb_put(skb
, sizeof(*mmie
));
952 mmie
->element_id
= WLAN_EID_MMIE
;
953 mmie
->length
= sizeof(*mmie
) - 2;
954 mmie
->key_id
= cpu_to_le16(key
->conf
.keyidx
);
957 pn64
= atomic64_inc_return(&key
->conf
.tx_pn
);
959 bip_ipn_set64(mmie
->sequence_number
, pn64
);
964 * MIC = AES-128-CMAC(IGTK, AAD || Management Frame Body || MMIE, 64)
966 ieee80211_aes_cmac(key
->u
.aes_cmac
.tfm
, aad
,
967 skb
->data
+ 24, skb
->len
- 24, mmie
->mic
);
973 ieee80211_crypto_aes_cmac_256_encrypt(struct ieee80211_tx_data
*tx
)
976 struct ieee80211_tx_info
*info
;
977 struct ieee80211_key
*key
= tx
->key
;
978 struct ieee80211_mmie_16
*mmie
;
982 if (WARN_ON(skb_queue_len(&tx
->skbs
) != 1))
985 skb
= skb_peek(&tx
->skbs
);
987 info
= IEEE80211_SKB_CB(skb
);
989 if (info
->control
.hw_key
)
992 if (WARN_ON(skb_tailroom(skb
) < sizeof(*mmie
)))
995 mmie
= (struct ieee80211_mmie_16
*)skb_put(skb
, sizeof(*mmie
));
996 mmie
->element_id
= WLAN_EID_MMIE
;
997 mmie
->length
= sizeof(*mmie
) - 2;
998 mmie
->key_id
= cpu_to_le16(key
->conf
.keyidx
);
1001 pn64
= atomic64_inc_return(&key
->conf
.tx_pn
);
1003 bip_ipn_set64(mmie
->sequence_number
, pn64
);
1007 /* MIC = AES-256-CMAC(IGTK, AAD || Management Frame Body || MMIE, 128)
1009 ieee80211_aes_cmac_256(key
->u
.aes_cmac
.tfm
, aad
,
1010 skb
->data
+ 24, skb
->len
- 24, mmie
->mic
);
1016 ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data
*rx
)
1018 struct sk_buff
*skb
= rx
->skb
;
1019 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
1020 struct ieee80211_key
*key
= rx
->key
;
1021 struct ieee80211_mmie
*mmie
;
1022 u8 aad
[20], mic
[8], ipn
[6];
1023 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
1025 if (!ieee80211_is_mgmt(hdr
->frame_control
))
1028 /* management frames are already linear */
1030 if (skb
->len
< 24 + sizeof(*mmie
))
1031 return RX_DROP_UNUSABLE
;
1033 mmie
= (struct ieee80211_mmie
*)
1034 (skb
->data
+ skb
->len
- sizeof(*mmie
));
1035 if (mmie
->element_id
!= WLAN_EID_MMIE
||
1036 mmie
->length
!= sizeof(*mmie
) - 2)
1037 return RX_DROP_UNUSABLE
; /* Invalid MMIE */
1039 bip_ipn_swap(ipn
, mmie
->sequence_number
);
1041 if (memcmp(ipn
, key
->u
.aes_cmac
.rx_pn
, 6) <= 0) {
1042 key
->u
.aes_cmac
.replays
++;
1043 return RX_DROP_UNUSABLE
;
1046 if (!(status
->flag
& RX_FLAG_DECRYPTED
)) {
1047 /* hardware didn't decrypt/verify MIC */
1049 ieee80211_aes_cmac(key
->u
.aes_cmac
.tfm
, aad
,
1050 skb
->data
+ 24, skb
->len
- 24, mic
);
1051 if (memcmp(mic
, mmie
->mic
, sizeof(mmie
->mic
)) != 0) {
1052 key
->u
.aes_cmac
.icverrors
++;
1053 return RX_DROP_UNUSABLE
;
1057 memcpy(key
->u
.aes_cmac
.rx_pn
, ipn
, 6);
1060 skb_trim(skb
, skb
->len
- sizeof(*mmie
));
1066 ieee80211_crypto_aes_cmac_256_decrypt(struct ieee80211_rx_data
*rx
)
1068 struct sk_buff
*skb
= rx
->skb
;
1069 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
1070 struct ieee80211_key
*key
= rx
->key
;
1071 struct ieee80211_mmie_16
*mmie
;
1072 u8 aad
[20], mic
[16], ipn
[6];
1073 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1075 if (!ieee80211_is_mgmt(hdr
->frame_control
))
1078 /* management frames are already linear */
1080 if (skb
->len
< 24 + sizeof(*mmie
))
1081 return RX_DROP_UNUSABLE
;
1083 mmie
= (struct ieee80211_mmie_16
*)
1084 (skb
->data
+ skb
->len
- sizeof(*mmie
));
1085 if (mmie
->element_id
!= WLAN_EID_MMIE
||
1086 mmie
->length
!= sizeof(*mmie
) - 2)
1087 return RX_DROP_UNUSABLE
; /* Invalid MMIE */
1089 bip_ipn_swap(ipn
, mmie
->sequence_number
);
1091 if (memcmp(ipn
, key
->u
.aes_cmac
.rx_pn
, 6) <= 0) {
1092 key
->u
.aes_cmac
.replays
++;
1093 return RX_DROP_UNUSABLE
;
1096 if (!(status
->flag
& RX_FLAG_DECRYPTED
)) {
1097 /* hardware didn't decrypt/verify MIC */
1099 ieee80211_aes_cmac_256(key
->u
.aes_cmac
.tfm
, aad
,
1100 skb
->data
+ 24, skb
->len
- 24, mic
);
1101 if (memcmp(mic
, mmie
->mic
, sizeof(mmie
->mic
)) != 0) {
1102 key
->u
.aes_cmac
.icverrors
++;
1103 return RX_DROP_UNUSABLE
;
1107 memcpy(key
->u
.aes_cmac
.rx_pn
, ipn
, 6);
1110 skb_trim(skb
, skb
->len
- sizeof(*mmie
));
1116 ieee80211_crypto_aes_gmac_encrypt(struct ieee80211_tx_data
*tx
)
1118 struct sk_buff
*skb
;
1119 struct ieee80211_tx_info
*info
;
1120 struct ieee80211_key
*key
= tx
->key
;
1121 struct ieee80211_mmie_16
*mmie
;
1122 struct ieee80211_hdr
*hdr
;
1123 u8 aad
[GMAC_AAD_LEN
];
1125 u8 nonce
[GMAC_NONCE_LEN
];
1127 if (WARN_ON(skb_queue_len(&tx
->skbs
) != 1))
1130 skb
= skb_peek(&tx
->skbs
);
1132 info
= IEEE80211_SKB_CB(skb
);
1134 if (info
->control
.hw_key
)
1137 if (WARN_ON(skb_tailroom(skb
) < sizeof(*mmie
)))
1140 mmie
= (struct ieee80211_mmie_16
*)skb_put(skb
, sizeof(*mmie
));
1141 mmie
->element_id
= WLAN_EID_MMIE
;
1142 mmie
->length
= sizeof(*mmie
) - 2;
1143 mmie
->key_id
= cpu_to_le16(key
->conf
.keyidx
);
1146 pn64
= atomic64_inc_return(&key
->conf
.tx_pn
);
1148 bip_ipn_set64(mmie
->sequence_number
, pn64
);
1152 hdr
= (struct ieee80211_hdr
*)skb
->data
;
1153 memcpy(nonce
, hdr
->addr2
, ETH_ALEN
);
1154 bip_ipn_swap(nonce
+ ETH_ALEN
, mmie
->sequence_number
);
1156 /* MIC = AES-GMAC(IGTK, AAD || Management Frame Body || MMIE, 128) */
1157 if (ieee80211_aes_gmac(key
->u
.aes_gmac
.tfm
, aad
, nonce
,
1158 skb
->data
+ 24, skb
->len
- 24, mmie
->mic
) < 0)
1165 ieee80211_crypto_aes_gmac_decrypt(struct ieee80211_rx_data
*rx
)
1167 struct sk_buff
*skb
= rx
->skb
;
1168 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
1169 struct ieee80211_key
*key
= rx
->key
;
1170 struct ieee80211_mmie_16
*mmie
;
1171 u8 aad
[GMAC_AAD_LEN
], mic
[GMAC_MIC_LEN
], ipn
[6], nonce
[GMAC_NONCE_LEN
];
1172 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1174 if (!ieee80211_is_mgmt(hdr
->frame_control
))
1177 /* management frames are already linear */
1179 if (skb
->len
< 24 + sizeof(*mmie
))
1180 return RX_DROP_UNUSABLE
;
1182 mmie
= (struct ieee80211_mmie_16
*)
1183 (skb
->data
+ skb
->len
- sizeof(*mmie
));
1184 if (mmie
->element_id
!= WLAN_EID_MMIE
||
1185 mmie
->length
!= sizeof(*mmie
) - 2)
1186 return RX_DROP_UNUSABLE
; /* Invalid MMIE */
1188 bip_ipn_swap(ipn
, mmie
->sequence_number
);
1190 if (memcmp(ipn
, key
->u
.aes_gmac
.rx_pn
, 6) <= 0) {
1191 key
->u
.aes_gmac
.replays
++;
1192 return RX_DROP_UNUSABLE
;
1195 if (!(status
->flag
& RX_FLAG_DECRYPTED
)) {
1196 /* hardware didn't decrypt/verify MIC */
1199 memcpy(nonce
, hdr
->addr2
, ETH_ALEN
);
1200 memcpy(nonce
+ ETH_ALEN
, ipn
, 6);
1202 if (ieee80211_aes_gmac(key
->u
.aes_gmac
.tfm
, aad
, nonce
,
1203 skb
->data
+ 24, skb
->len
- 24,
1205 memcmp(mic
, mmie
->mic
, sizeof(mmie
->mic
)) != 0) {
1206 key
->u
.aes_gmac
.icverrors
++;
1207 return RX_DROP_UNUSABLE
;
1211 memcpy(key
->u
.aes_gmac
.rx_pn
, ipn
, 6);
1214 skb_trim(skb
, skb
->len
- sizeof(*mmie
));
1220 ieee80211_crypto_hw_encrypt(struct ieee80211_tx_data
*tx
)
1222 struct sk_buff
*skb
;
1223 struct ieee80211_tx_info
*info
= NULL
;
1224 ieee80211_tx_result res
;
1226 skb_queue_walk(&tx
->skbs
, skb
) {
1227 info
= IEEE80211_SKB_CB(skb
);
1229 /* handle hw-only algorithm */
1230 if (!info
->control
.hw_key
)
1233 if (tx
->key
->flags
& KEY_FLAG_CIPHER_SCHEME
) {
1234 res
= ieee80211_crypto_cs_encrypt(tx
, skb
);
1235 if (res
!= TX_CONTINUE
)
1240 ieee80211_tx_set_protected(tx
);
1246 ieee80211_crypto_hw_decrypt(struct ieee80211_rx_data
*rx
)
1248 if (rx
->sta
&& rx
->sta
->cipher_scheme
)
1249 return ieee80211_crypto_cs_decrypt(rx
);
1251 return RX_DROP_UNUSABLE
;