~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/mac80211/wpa.c

Version: ~ [ linux-5.13-rc1 ] ~ [ linux-5.12.2 ] ~ [ linux-5.11.19 ] ~ [ linux-5.10.35 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.117 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.190 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.232 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.268 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.268 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp