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/slab.h>
13 #include <linux/skbuff.h>
14 #include <linux/compiler.h>
15 #include <linux/ieee80211.h>
16 #include <asm/unaligned.h>
17 #include <net/mac80211.h>
19 #include "ieee80211_i.h"
27 ieee80211_tx_h_michael_mic_add(struct ieee80211_tx_data
*tx
)
29 u8
*data
, *key
, *mic
, key_offset
;
32 struct ieee80211_hdr
*hdr
;
33 struct sk_buff
*skb
= tx
->skb
;
38 hdr
= (struct ieee80211_hdr
*)skb
->data
;
39 if (!tx
->key
|| tx
->key
->conf
.alg
!= ALG_TKIP
|| skb
->len
< 24 ||
40 !ieee80211_is_data_present(hdr
->frame_control
))
43 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
44 if (skb
->len
< hdrlen
)
47 data
= skb
->data
+ hdrlen
;
48 data_len
= skb
->len
- hdrlen
;
50 if ((tx
->key
->flags
& KEY_FLAG_UPLOADED_TO_HARDWARE
) &&
51 !(tx
->flags
& IEEE80211_TX_FRAGMENTED
) &&
52 !(tx
->key
->conf
.flags
& IEEE80211_KEY_FLAG_GENERATE_MMIC
) &&
54 /* hwaccel - with no need for preallocated room for MMIC */
58 tail
= MICHAEL_MIC_LEN
;
59 if (!(tx
->key
->flags
& KEY_FLAG_UPLOADED_TO_HARDWARE
))
62 if (WARN_ON(skb_tailroom(skb
) < tail
||
63 skb_headroom(skb
) < TKIP_IV_LEN
))
67 authenticator
= fc
& IEEE80211_FCTL_FROMDS
; /* FIX */
71 key_offset
= authenticator
?
72 NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY
:
73 NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY
;
74 key
= &tx
->key
->conf
.key
[key_offset
];
75 mic
= skb_put(skb
, MICHAEL_MIC_LEN
);
76 michael_mic(key
, hdr
, data
, data_len
, mic
);
83 ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data
*rx
)
85 u8
*data
, *key
= NULL
, key_offset
;
88 struct ieee80211_hdr
*hdr
;
89 u8 mic
[MICHAEL_MIC_LEN
];
90 struct sk_buff
*skb
= rx
->skb
;
91 int authenticator
= 1, wpa_test
= 0;
93 /* No way to verify the MIC if the hardware stripped it */
94 if (rx
->status
->flag
& RX_FLAG_MMIC_STRIPPED
)
97 hdr
= (struct ieee80211_hdr
*)skb
->data
;
98 if (!rx
->key
|| rx
->key
->conf
.alg
!= ALG_TKIP
||
99 !ieee80211_has_protected(hdr
->frame_control
) ||
100 !ieee80211_is_data_present(hdr
->frame_control
))
103 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
104 if (skb
->len
< hdrlen
+ MICHAEL_MIC_LEN
)
105 return RX_DROP_UNUSABLE
;
107 data
= skb
->data
+ hdrlen
;
108 data_len
= skb
->len
- hdrlen
- MICHAEL_MIC_LEN
;
111 authenticator
= fc
& IEEE80211_FCTL_TODS
; /* FIX */
115 key_offset
= authenticator
?
116 NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY
:
117 NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY
;
118 key
= &rx
->key
->conf
.key
[key_offset
];
119 michael_mic(key
, hdr
, data
, data_len
, mic
);
120 if (memcmp(mic
, data
+ data_len
, MICHAEL_MIC_LEN
) != 0 || wpa_test
) {
121 if (!(rx
->flags
& IEEE80211_RX_RA_MATCH
))
122 return RX_DROP_UNUSABLE
;
124 mac80211_ev_michael_mic_failure(rx
->sdata
, rx
->key
->conf
.keyidx
,
126 return RX_DROP_UNUSABLE
;
129 /* remove Michael MIC from payload */
130 skb_trim(skb
, skb
->len
- MICHAEL_MIC_LEN
);
132 /* update IV in key information to be able to detect replays */
133 rx
->key
->u
.tkip
.rx
[rx
->queue
].iv32
= rx
->tkip_iv32
;
134 rx
->key
->u
.tkip
.rx
[rx
->queue
].iv16
= rx
->tkip_iv16
;
140 static int tkip_encrypt_skb(struct ieee80211_tx_data
*tx
, struct sk_buff
*skb
)
142 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
143 struct ieee80211_key
*key
= tx
->key
;
144 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
149 if ((tx
->key
->flags
& KEY_FLAG_UPLOADED_TO_HARDWARE
) &&
150 !(tx
->key
->conf
.flags
& IEEE80211_KEY_FLAG_GENERATE_IV
)) {
151 /* hwaccel - with no need for preallocated room for IV/ICV */
152 info
->control
.hw_key
= &tx
->key
->conf
;
156 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
157 len
= skb
->len
- hdrlen
;
159 if (tx
->key
->flags
& KEY_FLAG_UPLOADED_TO_HARDWARE
)
164 if (WARN_ON(skb_tailroom(skb
) < tail
||
165 skb_headroom(skb
) < TKIP_IV_LEN
))
168 pos
= skb_push(skb
, TKIP_IV_LEN
);
169 memmove(pos
, pos
+ TKIP_IV_LEN
, hdrlen
);
172 /* Increase IV for the frame */
173 key
->u
.tkip
.tx
.iv16
++;
174 if (key
->u
.tkip
.tx
.iv16
== 0)
175 key
->u
.tkip
.tx
.iv32
++;
177 if (tx
->key
->flags
& KEY_FLAG_UPLOADED_TO_HARDWARE
) {
178 /* hwaccel - with preallocated room for IV */
179 ieee80211_tkip_add_iv(pos
, key
, key
->u
.tkip
.tx
.iv16
);
181 info
->control
.hw_key
= &tx
->key
->conf
;
185 /* Add room for ICV */
186 skb_put(skb
, TKIP_ICV_LEN
);
188 hdr
= (struct ieee80211_hdr
*) skb
->data
;
189 ieee80211_tkip_encrypt_data(tx
->local
->wep_tx_tfm
,
190 key
, pos
, len
, hdr
->addr2
);
196 ieee80211_crypto_tkip_encrypt(struct ieee80211_tx_data
*tx
)
198 struct sk_buff
*skb
= tx
->skb
;
201 ieee80211_tx_set_protected(tx
);
203 if (tkip_encrypt_skb(tx
, skb
) < 0)
206 if (tx
->extra_frag
) {
207 for (i
= 0; i
< tx
->num_extra_frag
; i
++) {
208 if (tkip_encrypt_skb(tx
, tx
->extra_frag
[i
]))
218 ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data
*rx
)
220 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) rx
->skb
->data
;
221 int hdrlen
, res
, hwaccel
= 0, wpa_test
= 0;
222 struct ieee80211_key
*key
= rx
->key
;
223 struct sk_buff
*skb
= rx
->skb
;
225 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
227 if (!ieee80211_is_data(hdr
->frame_control
))
230 if (!rx
->sta
|| skb
->len
- hdrlen
< 12)
231 return RX_DROP_UNUSABLE
;
233 if (rx
->status
->flag
& RX_FLAG_DECRYPTED
) {
234 if (rx
->status
->flag
& RX_FLAG_IV_STRIPPED
) {
236 * Hardware took care of all processing, including
237 * replay protection, and stripped the ICV/IV so
238 * we cannot do any checks here.
243 /* let TKIP code verify IV, but skip decryption */
247 res
= ieee80211_tkip_decrypt_data(rx
->local
->wep_rx_tfm
,
248 key
, skb
->data
+ hdrlen
,
249 skb
->len
- hdrlen
, rx
->sta
->sta
.addr
,
250 hdr
->addr1
, hwaccel
, rx
->queue
,
253 if (res
!= TKIP_DECRYPT_OK
|| wpa_test
)
254 return RX_DROP_UNUSABLE
;
257 skb_trim(skb
, skb
->len
- TKIP_ICV_LEN
);
260 memmove(skb
->data
+ TKIP_IV_LEN
, skb
->data
, hdrlen
);
261 skb_pull(skb
, TKIP_IV_LEN
);
267 static void ccmp_special_blocks(struct sk_buff
*skb
, u8
*pn
, u8
*scratch
,
271 int a4_included
, mgmt
;
276 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
278 b_0
= scratch
+ 3 * AES_BLOCK_LEN
;
279 aad
= scratch
+ 4 * AES_BLOCK_LEN
;
282 * Mask FC: zero subtype b4 b5 b6 (if not mgmt)
283 * Retry, PwrMgt, MoreData; set Protected
285 mgmt
= ieee80211_is_mgmt(hdr
->frame_control
);
286 mask_fc
= hdr
->frame_control
;
287 mask_fc
&= ~cpu_to_le16(IEEE80211_FCTL_RETRY
|
288 IEEE80211_FCTL_PM
| IEEE80211_FCTL_MOREDATA
);
290 mask_fc
&= ~cpu_to_le16(0x0070);
291 mask_fc
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
293 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
295 a4_included
= ieee80211_has_a4(hdr
->frame_control
);
297 if (ieee80211_is_data_qos(hdr
->frame_control
))
298 qos_tid
= *ieee80211_get_qos_ctl(hdr
) & IEEE80211_QOS_CTL_TID_MASK
;
302 data_len
= skb
->len
- hdrlen
- CCMP_HDR_LEN
;
304 data_len
-= CCMP_MIC_LEN
;
306 /* First block, b_0 */
307 b_0
[0] = 0x59; /* flags: Adata: 1, M: 011, L: 001 */
308 /* Nonce: Nonce Flags | A2 | PN
309 * Nonce Flags: Priority (b0..b3) | Management (b4) | Reserved (b5..b7)
311 b_0
[1] = qos_tid
| (mgmt
<< 4);
312 memcpy(&b_0
[2], hdr
->addr2
, ETH_ALEN
);
313 memcpy(&b_0
[8], pn
, CCMP_PN_LEN
);
315 put_unaligned_be16(data_len
, &b_0
[14]);
317 /* AAD (extra authenticate-only data) / masked 802.11 header
318 * FC | A1 | A2 | A3 | SC | [A4] | [QC] */
319 put_unaligned_be16(len_a
, &aad
[0]);
320 put_unaligned(mask_fc
, (__le16
*)&aad
[2]);
321 memcpy(&aad
[4], &hdr
->addr1
, 3 * ETH_ALEN
);
323 /* Mask Seq#, leave Frag# */
324 aad
[22] = *((u8
*) &hdr
->seq_ctrl
) & 0x0f;
328 memcpy(&aad
[24], hdr
->addr4
, ETH_ALEN
);
332 memset(&aad
[24], 0, ETH_ALEN
+ IEEE80211_QOS_CTL_LEN
);
338 static inline void ccmp_pn2hdr(u8
*hdr
, u8
*pn
, int key_id
)
343 hdr
[3] = 0x20 | (key_id
<< 6);
351 static inline void ccmp_hdr2pn(u8
*pn
, u8
*hdr
)
362 static int ccmp_encrypt_skb(struct ieee80211_tx_data
*tx
, struct sk_buff
*skb
)
364 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
365 struct ieee80211_key
*key
= tx
->key
;
366 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
367 int hdrlen
, len
, tail
;
372 skip_hw
= (tx
->key
->conf
.flags
& IEEE80211_KEY_FLAG_SW_MGMT
) &&
373 ieee80211_is_mgmt(hdr
->frame_control
);
375 if ((tx
->key
->flags
& KEY_FLAG_UPLOADED_TO_HARDWARE
) &&
376 !(tx
->key
->conf
.flags
& IEEE80211_KEY_FLAG_GENERATE_IV
) &&
378 /* hwaccel - with no need for preallocated room for CCMP
379 * header or MIC fields */
380 info
->control
.hw_key
= &tx
->key
->conf
;
384 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
385 len
= skb
->len
- hdrlen
;
387 if (key
->flags
& KEY_FLAG_UPLOADED_TO_HARDWARE
)
392 if (WARN_ON(skb_tailroom(skb
) < tail
||
393 skb_headroom(skb
) < CCMP_HDR_LEN
))
396 pos
= skb_push(skb
, CCMP_HDR_LEN
);
397 memmove(pos
, pos
+ CCMP_HDR_LEN
, hdrlen
);
398 hdr
= (struct ieee80211_hdr
*) pos
;
402 pn
= key
->u
.ccmp
.tx_pn
;
404 for (i
= CCMP_PN_LEN
- 1; i
>= 0; i
--) {
410 ccmp_pn2hdr(pos
, pn
, key
->conf
.keyidx
);
412 if ((key
->flags
& KEY_FLAG_UPLOADED_TO_HARDWARE
) && !skip_hw
) {
413 /* hwaccel - with preallocated room for CCMP header */
414 info
->control
.hw_key
= &tx
->key
->conf
;
419 ccmp_special_blocks(skb
, pn
, key
->u
.ccmp
.tx_crypto_buf
, 0);
420 ieee80211_aes_ccm_encrypt(key
->u
.ccmp
.tfm
, key
->u
.ccmp
.tx_crypto_buf
, pos
, len
,
421 pos
, skb_put(skb
, CCMP_MIC_LEN
));
428 ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data
*tx
)
430 struct sk_buff
*skb
= tx
->skb
;
433 ieee80211_tx_set_protected(tx
);
435 if (ccmp_encrypt_skb(tx
, skb
) < 0)
438 if (tx
->extra_frag
) {
439 for (i
= 0; i
< tx
->num_extra_frag
; i
++) {
440 if (ccmp_encrypt_skb(tx
, tx
->extra_frag
[i
]))
450 ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data
*rx
)
452 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)rx
->skb
->data
;
454 struct ieee80211_key
*key
= rx
->key
;
455 struct sk_buff
*skb
= rx
->skb
;
459 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
461 if (!ieee80211_is_data(hdr
->frame_control
) &&
462 !ieee80211_is_robust_mgmt_frame(hdr
))
465 data_len
= skb
->len
- hdrlen
- CCMP_HDR_LEN
- CCMP_MIC_LEN
;
466 if (!rx
->sta
|| data_len
< 0)
467 return RX_DROP_UNUSABLE
;
469 if ((rx
->status
->flag
& RX_FLAG_DECRYPTED
) &&
470 (rx
->status
->flag
& RX_FLAG_IV_STRIPPED
))
473 ccmp_hdr2pn(pn
, skb
->data
+ hdrlen
);
475 if (memcmp(pn
, key
->u
.ccmp
.rx_pn
[rx
->queue
], CCMP_PN_LEN
) <= 0) {
476 key
->u
.ccmp
.replays
++;
477 return RX_DROP_UNUSABLE
;
480 if (!(rx
->status
->flag
& RX_FLAG_DECRYPTED
)) {
481 /* hardware didn't decrypt/verify MIC */
482 ccmp_special_blocks(skb
, pn
, key
->u
.ccmp
.rx_crypto_buf
, 1);
484 if (ieee80211_aes_ccm_decrypt(
485 key
->u
.ccmp
.tfm
, key
->u
.ccmp
.rx_crypto_buf
,
486 skb
->data
+ hdrlen
+ CCMP_HDR_LEN
, data_len
,
487 skb
->data
+ skb
->len
- CCMP_MIC_LEN
,
488 skb
->data
+ hdrlen
+ CCMP_HDR_LEN
))
489 return RX_DROP_UNUSABLE
;
492 memcpy(key
->u
.ccmp
.rx_pn
[rx
->queue
], pn
, CCMP_PN_LEN
);
494 /* Remove CCMP header and MIC */
495 skb_trim(skb
, skb
->len
- CCMP_MIC_LEN
);
496 memmove(skb
->data
+ CCMP_HDR_LEN
, skb
->data
, hdrlen
);
497 skb_pull(skb
, CCMP_HDR_LEN
);
503 static void bip_aad(struct sk_buff
*skb
, u8
*aad
)
505 /* BIP AAD: FC(masked) || A1 || A2 || A3 */
507 /* FC type/subtype */
508 aad
[0] = skb
->data
[0];
509 /* Mask FC Retry, PwrMgt, MoreData flags to zero */
510 aad
[1] = skb
->data
[1] & ~(BIT(4) | BIT(5) | BIT(6));
512 memcpy(aad
+ 2, skb
->data
+ 4, 3 * ETH_ALEN
);
516 static inline void bip_ipn_swap(u8
*d
, const u8
*s
)
528 ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data
*tx
)
530 struct sk_buff
*skb
= tx
->skb
;
531 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
532 struct ieee80211_key
*key
= tx
->key
;
533 struct ieee80211_mmie
*mmie
;
537 if (tx
->key
->flags
& KEY_FLAG_UPLOADED_TO_HARDWARE
) {
539 info
->control
.hw_key
= &tx
->key
->conf
;
543 if (WARN_ON(skb_tailroom(skb
) < sizeof(*mmie
)))
546 mmie
= (struct ieee80211_mmie
*) skb_put(skb
, sizeof(*mmie
));
547 mmie
->element_id
= WLAN_EID_MMIE
;
548 mmie
->length
= sizeof(*mmie
) - 2;
549 mmie
->key_id
= cpu_to_le16(key
->conf
.keyidx
);
552 pn
= key
->u
.aes_cmac
.tx_pn
;
554 for (i
= sizeof(key
->u
.aes_cmac
.tx_pn
) - 1; i
>= 0; i
--) {
559 bip_ipn_swap(mmie
->sequence_number
, pn
);
564 * MIC = AES-128-CMAC(IGTK, AAD || Management Frame Body || MMIE, 64)
566 ieee80211_aes_cmac(key
->u
.aes_cmac
.tfm
, key
->u
.aes_cmac
.tx_crypto_buf
,
567 aad
, skb
->data
+ 24, skb
->len
- 24, mmie
->mic
);
574 ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data
*rx
)
576 struct sk_buff
*skb
= rx
->skb
;
577 struct ieee80211_key
*key
= rx
->key
;
578 struct ieee80211_mmie
*mmie
;
579 u8 aad
[20], mic
[8], ipn
[6];
580 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
582 if (!ieee80211_is_mgmt(hdr
->frame_control
))
585 if ((rx
->status
->flag
& RX_FLAG_DECRYPTED
) &&
586 (rx
->status
->flag
& RX_FLAG_IV_STRIPPED
))
589 if (skb
->len
< 24 + sizeof(*mmie
))
590 return RX_DROP_UNUSABLE
;
592 mmie
= (struct ieee80211_mmie
*)
593 (skb
->data
+ skb
->len
- sizeof(*mmie
));
594 if (mmie
->element_id
!= WLAN_EID_MMIE
||
595 mmie
->length
!= sizeof(*mmie
) - 2)
596 return RX_DROP_UNUSABLE
; /* Invalid MMIE */
598 bip_ipn_swap(ipn
, mmie
->sequence_number
);
600 if (memcmp(ipn
, key
->u
.aes_cmac
.rx_pn
, 6) <= 0) {
601 key
->u
.aes_cmac
.replays
++;
602 return RX_DROP_UNUSABLE
;
605 if (!(rx
->status
->flag
& RX_FLAG_DECRYPTED
)) {
606 /* hardware didn't decrypt/verify MIC */
608 ieee80211_aes_cmac(key
->u
.aes_cmac
.tfm
,
609 key
->u
.aes_cmac
.rx_crypto_buf
, aad
,
610 skb
->data
+ 24, skb
->len
- 24, mic
);
611 if (memcmp(mic
, mmie
->mic
, sizeof(mmie
->mic
)) != 0) {
612 key
->u
.aes_cmac
.icverrors
++;
613 return RX_DROP_UNUSABLE
;
617 memcpy(key
->u
.aes_cmac
.rx_pn
, ipn
, 6);
620 skb_trim(skb
, skb
->len
- sizeof(*mmie
));