projects / openwrt / staging / yousong.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mac80211: update to wireless-testing 2015-03-09
[openwrt/staging/yousong.git] / package / kernel / mac80211 / patches / 100-revert-cryptoapi-ports.patch
1 This patch reverts the following commits from wireless-testing:
2
3 8ade538bf39b1ee53418528fdacd36b8e65621b9
4 56c52da2d554f081e8fce58ecbcf6a40c605b95b
5 2b2ba0db1c820d04d5143452d70012cd44d7b578
6 00b9cfa3ff38401bd70c34b250ca13e5ea347b4a
7 4f031fa9f188b2b0641ac20087d9e16bcfb4e49d
8 6e1ee5d2e9e411892b5d84e3ea93e3fc88ac786c
9 30ef7ef9672d92ab2cac37f60a31955c118321e7
10 f359d3fe832e49eeec2232b2af5a9e3aee6b4862 (only the changes in aes_cmac.{c,h})
11 7ec7c4a9a686c608315739ab6a2b0527a240883c
12 ---
13
14 --- a/include/linux/ieee80211.h
15 +++ b/include/linux/ieee80211.h
16 @@ -1017,15 +1017,6 @@ struct ieee80211_mmie {
17 u8 mic[8];
18 } __packed;
19
20 -/* Management MIC information element (IEEE 802.11w) for GMAC and CMAC-256 */
21 -struct ieee80211_mmie_16 {
22 - u8 element_id;
23 - u8 length;
24 - __le16 key_id;
25 - u8 sequence_number[6];
26 - u8 mic[16];
27 -} __packed;
28 -
29 struct ieee80211_vendor_ie {
30 u8 element_id;
31 u8 len;
32 --- a/include/net/mac80211.h
33 +++ b/include/net/mac80211.h
34 @@ -1306,8 +1306,8 @@ struct ieee80211_vif *wdev_to_ieee80211_
35 * @IEEE80211_KEY_FLAG_PAIRWISE: Set by mac80211, this flag indicates
36 * that the key is pairwise rather then a shared key.
37 * @IEEE80211_KEY_FLAG_SW_MGMT_TX: This flag should be set by the driver for a
38 - * CCMP/GCMP key if it requires CCMP/GCMP encryption of management frames
39 - * (MFP) to be done in software.
40 + * CCMP key if it requires CCMP encryption of management frames (MFP) to
41 + * be done in software.
42 * @IEEE80211_KEY_FLAG_PUT_IV_SPACE: This flag should be set by the driver
43 * if space should be prepared for the IV, but the IV
44 * itself should not be generated. Do not set together with
45 @@ -1322,7 +1322,7 @@ struct ieee80211_vif *wdev_to_ieee80211_
46 * RX, if your crypto engine can't deal with TX you can also set the
47 * %IEEE80211_KEY_FLAG_SW_MGMT_TX flag to encrypt such frames in SW.
48 * @IEEE80211_KEY_FLAG_GENERATE_IV_MGMT: This flag should be set by the
49 - * driver for a CCMP/GCMP key to indicate that is requires IV generation
50 + * driver for a CCMP key to indicate that is requires IV generation
51 * only for managment frames (MFP).
52 * @IEEE80211_KEY_FLAG_RESERVE_TAILROOM: This flag should be set by the
53 * driver for a key to indicate that sufficient tailroom must always
54 @@ -4112,10 +4112,6 @@ void ieee80211_aes_cmac_calculate_k1_k2(
55 * reverse order than in packet)
56 * @aes_cmac: PN data, most significant byte first (big endian,
57 * reverse order than in packet)
58 - * @aes_gmac: PN data, most significant byte first (big endian,
59 - * reverse order than in packet)
60 - * @gcmp: PN data, most significant byte first (big endian,
61 - * reverse order than in packet)
62 */
63 struct ieee80211_key_seq {
64 union {
65 @@ -4129,12 +4125,6 @@ struct ieee80211_key_seq {
66 struct {
67 u8 pn[6];
68 } aes_cmac;
69 - struct {
70 - u8 pn[6];
71 - } aes_gmac;
72 - struct {
73 - u8 pn[6];
74 - } gcmp;
75 };
76 };
77
78 @@ -4159,7 +4149,7 @@ void ieee80211_get_key_tx_seq(struct iee
79 * ieee80211_get_key_rx_seq - get key RX sequence counter
80 *
81 * @keyconf: the parameter passed with the set key
82 - * @tid: The TID, or -1 for the management frame value (CCMP/GCMP only);
83 + * @tid: The TID, or -1 for the management frame value (CCMP only);
84 * the value on TID 0 is also used for non-QoS frames. For
85 * CMAC, only TID 0 is valid.
86 * @seq: buffer to receive the sequence data
87 @@ -4195,7 +4185,7 @@ void ieee80211_set_key_tx_seq(struct iee
88 * ieee80211_set_key_rx_seq - set key RX sequence counter
89 *
90 * @keyconf: the parameter passed with the set key
91 - * @tid: The TID, or -1 for the management frame value (CCMP/GCMP only);
92 + * @tid: The TID, or -1 for the management frame value (CCMP only);
93 * the value on TID 0 is also used for non-QoS frames. For
94 * CMAC, only TID 0 is valid.
95 * @seq: new sequence data
96 --- a/net/mac80211/Kconfig
97 +++ b/net/mac80211/Kconfig
98 @@ -5,8 +5,6 @@ config MAC80211
99 depends on CRYPTO
100 depends on CRYPTO_ARC4
101 depends on CRYPTO_AES
102 - select BPAUTO_CRYPTO_CCM
103 - depends on CRYPTO_GCM
104 depends on CRC32
105 select BPAUTO_AVERAGE
106 ---help---
107 --- a/net/mac80211/Makefile
108 +++ b/net/mac80211/Makefile
109 @@ -15,9 +15,7 @@ mac80211-y := \
110 michael.o \
111 tkip.o \
112 aes_ccm.o \
113 - aes_gcm.o \
114 aes_cmac.o \
115 - aes_gmac.o \
116 cfg.o \
117 ethtool.o \
118 rx.o \
119 --- a/net/mac80211/aes_ccm.c
120 +++ b/net/mac80211/aes_ccm.c
121 @@ -2,8 +2,6 @@
122 * Copyright 2003-2004, Instant802 Networks, Inc.
123 * Copyright 2005-2006, Devicescape Software, Inc.
124 *
125 - * Rewrite: Copyright (C) 2013 Linaro Ltd <ard.biesheuvel@linaro.org>
126 - *
127 * This program is free software; you can redistribute it and/or modify
128 * it under the terms of the GNU General Public License version 2 as
129 * published by the Free Software Foundation.
130 @@ -19,82 +17,134 @@
131 #include "key.h"
132 #include "aes_ccm.h"
133
134 -void ieee80211_aes_ccm_encrypt(struct crypto_aead *tfm, u8 *b_0, u8 *aad,
135 - u8 *data, size_t data_len, u8 *mic,
136 - size_t mic_len)
137 +static void aes_ccm_prepare(struct crypto_cipher *tfm, u8 *scratch, u8 *a)
138 +{
139 + int i;
140 + u8 *b_0, *aad, *b, *s_0;
141 +
142 + b_0 = scratch + 3 * AES_BLOCK_SIZE;
143 + aad = scratch + 4 * AES_BLOCK_SIZE;
144 + b = scratch;
145 + s_0 = scratch + AES_BLOCK_SIZE;
146 +
147 + crypto_cipher_encrypt_one(tfm, b, b_0);
148 +
149 + /* Extra Authenticate-only data (always two AES blocks) */
150 + for (i = 0; i < AES_BLOCK_SIZE; i++)
151 + aad[i] ^= b[i];
152 + crypto_cipher_encrypt_one(tfm, b, aad);
153 +
154 + aad += AES_BLOCK_SIZE;
155 +
156 + for (i = 0; i < AES_BLOCK_SIZE; i++)
157 + aad[i] ^= b[i];
158 + crypto_cipher_encrypt_one(tfm, a, aad);
159 +
160 + /* Mask out bits from auth-only-b_0 */
161 + b_0[0] &= 0x07;
162 +
163 + /* S_0 is used to encrypt T (= MIC) */
164 + b_0[14] = 0;
165 + b_0[15] = 0;
166 + crypto_cipher_encrypt_one(tfm, s_0, b_0);
167 +}
168 +
169 +
170 +void ieee80211_aes_ccm_encrypt(struct crypto_cipher *tfm, u8 *scratch,
171 + u8 *data, size_t data_len,
172 + u8 *cdata, u8 *mic)
173 {
174 - struct scatterlist assoc, pt, ct[2];
175 + int i, j, last_len, num_blocks;
176 + u8 *pos, *cpos, *b, *s_0, *e, *b_0;
177
178 - char aead_req_data[sizeof(struct aead_request) +
179 - crypto_aead_reqsize(tfm)]
180 - __aligned(__alignof__(struct aead_request));
181 - struct aead_request *aead_req = (void *) aead_req_data;
182 -
183 - memset(aead_req, 0, sizeof(aead_req_data));
184 -
185 - sg_init_one(&pt, data, data_len);
186 - sg_init_one(&assoc, &aad[2], be16_to_cpup((__be16 *)aad));
187 - sg_init_table(ct, 2);
188 - sg_set_buf(&ct[0], data, data_len);
189 - sg_set_buf(&ct[1], mic, mic_len);
190 -
191 - aead_request_set_tfm(aead_req, tfm);
192 - aead_request_set_assoc(aead_req, &assoc, assoc.length);
193 - aead_request_set_crypt(aead_req, &pt, ct, data_len, b_0);
194 + b = scratch;
195 + s_0 = scratch + AES_BLOCK_SIZE;
196 + e = scratch + 2 * AES_BLOCK_SIZE;
197 + b_0 = scratch + 3 * AES_BLOCK_SIZE;
198 +
199 + num_blocks = DIV_ROUND_UP(data_len, AES_BLOCK_SIZE);
200 + last_len = data_len % AES_BLOCK_SIZE;
201 + aes_ccm_prepare(tfm, scratch, b);
202 +
203 + /* Process payload blocks */
204 + pos = data;
205 + cpos = cdata;
206 + for (j = 1; j <= num_blocks; j++) {
207 + int blen = (j == num_blocks && last_len) ?
208 + last_len : AES_BLOCK_SIZE;
209 +
210 + /* Authentication followed by encryption */
211 + for (i = 0; i < blen; i++)
212 + b[i] ^= pos[i];
213 + crypto_cipher_encrypt_one(tfm, b, b);
214 +
215 + b_0[14] = (j >> 8) & 0xff;
216 + b_0[15] = j & 0xff;
217 + crypto_cipher_encrypt_one(tfm, e, b_0);
218 + for (i = 0; i < blen; i++)
219 + *cpos++ = *pos++ ^ e[i];
220 + }
221
222 - crypto_aead_encrypt(aead_req);
223 + for (i = 0; i < IEEE80211_CCMP_MIC_LEN; i++)
224 + mic[i] = b[i] ^ s_0[i];
225 }
226
227 -int ieee80211_aes_ccm_decrypt(struct crypto_aead *tfm, u8 *b_0, u8 *aad,
228 - u8 *data, size_t data_len, u8 *mic,
229 - size_t mic_len)
230 +
231 +int ieee80211_aes_ccm_decrypt(struct crypto_cipher *tfm, u8 *scratch,
232 + u8 *cdata, size_t data_len, u8 *mic, u8 *data)
233 {
234 - struct scatterlist assoc, pt, ct[2];
235 - char aead_req_data[sizeof(struct aead_request) +
236 - crypto_aead_reqsize(tfm)]
237 - __aligned(__alignof__(struct aead_request));
238 - struct aead_request *aead_req = (void *) aead_req_data;
239 -
240 - if (data_len == 0)
241 - return -EINVAL;
242 -
243 - memset(aead_req, 0, sizeof(aead_req_data));
244 -
245 - sg_init_one(&pt, data, data_len);
246 - sg_init_one(&assoc, &aad[2], be16_to_cpup((__be16 *)aad));
247 - sg_init_table(ct, 2);
248 - sg_set_buf(&ct[0], data, data_len);
249 - sg_set_buf(&ct[1], mic, mic_len);
250 -
251 - aead_request_set_tfm(aead_req, tfm);
252 - aead_request_set_assoc(aead_req, &assoc, assoc.length);
253 - aead_request_set_crypt(aead_req, ct, &pt, data_len + mic_len, b_0);
254 + int i, j, last_len, num_blocks;
255 + u8 *pos, *cpos, *b, *s_0, *a, *b_0;
256 +
257 + b = scratch;
258 + s_0 = scratch + AES_BLOCK_SIZE;
259 + a = scratch + 2 * AES_BLOCK_SIZE;
260 + b_0 = scratch + 3 * AES_BLOCK_SIZE;
261 +
262 + num_blocks = DIV_ROUND_UP(data_len, AES_BLOCK_SIZE);
263 + last_len = data_len % AES_BLOCK_SIZE;
264 + aes_ccm_prepare(tfm, scratch, a);
265 +
266 + /* Process payload blocks */
267 + cpos = cdata;
268 + pos = data;
269 + for (j = 1; j <= num_blocks; j++) {
270 + int blen = (j == num_blocks && last_len) ?
271 + last_len : AES_BLOCK_SIZE;
272 +
273 + /* Decryption followed by authentication */
274 + b_0[14] = (j >> 8) & 0xff;
275 + b_0[15] = j & 0xff;
276 + crypto_cipher_encrypt_one(tfm, b, b_0);
277 + for (i = 0; i < blen; i++) {
278 + *pos = *cpos++ ^ b[i];
279 + a[i] ^= *pos++;
280 + }
281 + crypto_cipher_encrypt_one(tfm, a, a);
282 + }
283 +
284 + for (i = 0; i < IEEE80211_CCMP_MIC_LEN; i++) {
285 + if ((mic[i] ^ s_0[i]) != a[i])
286 + return -1;
287 + }
288
289 - return crypto_aead_decrypt(aead_req);
290 + return 0;
291 }
292
293 -struct crypto_aead *ieee80211_aes_key_setup_encrypt(const u8 key[],
294 - size_t key_len,
295 - size_t mic_len)
296 +
297 +struct crypto_cipher *ieee80211_aes_key_setup_encrypt(const u8 key[])
298 {
299 - struct crypto_aead *tfm;
300 - int err;
301 + struct crypto_cipher *tfm;
302
303 - tfm = crypto_alloc_aead("ccm(aes)", 0, CRYPTO_ALG_ASYNC);
304 - if (IS_ERR(tfm))
305 - return tfm;
306 -
307 - err = crypto_aead_setkey(tfm, key, key_len);
308 - if (!err)
309 - err = crypto_aead_setauthsize(tfm, mic_len);
310 - if (!err)
311 - return tfm;
312 + tfm = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
313 + if (!IS_ERR(tfm))
314 + crypto_cipher_setkey(tfm, key, WLAN_KEY_LEN_CCMP);
315
316 - crypto_free_aead(tfm);
317 - return ERR_PTR(err);
318 + return tfm;
319 }
320
321 -void ieee80211_aes_key_free(struct crypto_aead *tfm)
322 +
323 +void ieee80211_aes_key_free(struct crypto_cipher *tfm)
324 {
325 - crypto_free_aead(tfm);
326 + crypto_free_cipher(tfm);
327 }
328 --- a/net/mac80211/aes_ccm.h
329 +++ b/net/mac80211/aes_ccm.h
330 @@ -12,15 +12,13 @@
331
332 #include <linux/crypto.h>
333
334 -struct crypto_aead *ieee80211_aes_key_setup_encrypt(const u8 key[],
335 - size_t key_len,
336 - size_t mic_len);
337 -void ieee80211_aes_ccm_encrypt(struct crypto_aead *tfm, u8 *b_0, u8 *aad,
338 - u8 *data, size_t data_len, u8 *mic,
339 - size_t mic_len);
340 -int ieee80211_aes_ccm_decrypt(struct crypto_aead *tfm, u8 *b_0, u8 *aad,
341 - u8 *data, size_t data_len, u8 *mic,
342 - size_t mic_len);
343 -void ieee80211_aes_key_free(struct crypto_aead *tfm);
344 +struct crypto_cipher *ieee80211_aes_key_setup_encrypt(const u8 key[]);
345 +void ieee80211_aes_ccm_encrypt(struct crypto_cipher *tfm, u8 *scratch,
346 + u8 *data, size_t data_len,
347 + u8 *cdata, u8 *mic);
348 +int ieee80211_aes_ccm_decrypt(struct crypto_cipher *tfm, u8 *scratch,
349 + u8 *cdata, size_t data_len,
350 + u8 *mic, u8 *data);
351 +void ieee80211_aes_key_free(struct crypto_cipher *tfm);
352
353 #endif /* AES_CCM_H */
354 --- a/net/mac80211/aes_cmac.c
355 +++ b/net/mac80211/aes_cmac.c
356 @@ -18,8 +18,8 @@
357 #include "key.h"
358 #include "aes_cmac.h"
359
360 +#define AES_CMAC_KEY_LEN 16
361 #define CMAC_TLEN 8 /* CMAC TLen = 64 bits (8 octets) */
362 -#define CMAC_TLEN_256 16 /* CMAC TLen = 128 bits (16 octets) */
363 #define AAD_LEN 20
364
365
366 @@ -35,9 +35,9 @@ static void gf_mulx(u8 *pad)
367 pad[AES_BLOCK_SIZE - 1] ^= 0x87;
368 }
369
370 -static void aes_cmac_vector(struct crypto_cipher *tfm, size_t num_elem,
371 - const u8 *addr[], const size_t *len, u8 *mac,
372 - size_t mac_len)
373 +
374 +static void aes_128_cmac_vector(struct crypto_cipher *tfm, size_t num_elem,
375 + const u8 *addr[], const size_t *len, u8 *mac)
376 {
377 u8 cbc[AES_BLOCK_SIZE], pad[AES_BLOCK_SIZE];
378 const u8 *pos, *end;
379 @@ -88,7 +88,7 @@ static void aes_cmac_vector(struct crypt
380 for (i = 0; i < AES_BLOCK_SIZE; i++)
381 pad[i] ^= cbc[i];
382 crypto_cipher_encrypt_one(tfm, pad, pad);
383 - memcpy(mac, pad, mac_len);
384 + memcpy(mac, pad, CMAC_TLEN);
385 }
386
387
388 @@ -107,35 +107,17 @@ void ieee80211_aes_cmac(struct crypto_ci
389 addr[2] = zero;
390 len[2] = CMAC_TLEN;
391
392 - aes_cmac_vector(tfm, 3, addr, len, mic, CMAC_TLEN);
393 + aes_128_cmac_vector(tfm, 3, addr, len, mic);
394 }
395
396 -void ieee80211_aes_cmac_256(struct crypto_cipher *tfm, const u8 *aad,
397 - const u8 *data, size_t data_len, u8 *mic)
398 -{
399 - const u8 *addr[3];
400 - size_t len[3];
401 - u8 zero[CMAC_TLEN_256];
402 -
403 - memset(zero, 0, CMAC_TLEN_256);
404 - addr[0] = aad;
405 - len[0] = AAD_LEN;
406 - addr[1] = data;
407 - len[1] = data_len - CMAC_TLEN_256;
408 - addr[2] = zero;
409 - len[2] = CMAC_TLEN_256;
410 -
411 - aes_cmac_vector(tfm, 3, addr, len, mic, CMAC_TLEN_256);
412 -}
413
414 -struct crypto_cipher *ieee80211_aes_cmac_key_setup(const u8 key[],
415 - size_t key_len)
416 +struct crypto_cipher * ieee80211_aes_cmac_key_setup(const u8 key[])
417 {
418 struct crypto_cipher *tfm;
419
420 tfm = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC);
421 if (!IS_ERR(tfm))
422 - crypto_cipher_setkey(tfm, key, key_len);
423 + crypto_cipher_setkey(tfm, key, AES_CMAC_KEY_LEN);
424
425 return tfm;
426 }
427 --- a/net/mac80211/aes_cmac.h
428 +++ b/net/mac80211/aes_cmac.h
429 @@ -11,12 +11,9 @@
430
431 #include <linux/crypto.h>
432
433 -struct crypto_cipher *ieee80211_aes_cmac_key_setup(const u8 key[],
434 - size_t key_len);
435 +struct crypto_cipher * ieee80211_aes_cmac_key_setup(const u8 key[]);
436 void ieee80211_aes_cmac(struct crypto_cipher *tfm, const u8 *aad,
437 const u8 *data, size_t data_len, u8 *mic);
438 -void ieee80211_aes_cmac_256(struct crypto_cipher *tfm, const u8 *aad,
439 - const u8 *data, size_t data_len, u8 *mic);
440 void ieee80211_aes_cmac_key_free(struct crypto_cipher *tfm);
441
442 #endif /* AES_CMAC_H */
443 --- a/net/mac80211/aes_gcm.c
444 +++ /dev/null
445 @@ -1,95 +0,0 @@
446 -/*
447 - * Copyright 2014-2015, Qualcomm Atheros, Inc.
448 - *
449 - * This program is free software; you can redistribute it and/or modify
450 - * it under the terms of the GNU General Public License version 2 as
451 - * published by the Free Software Foundation.
452 - */
453 -
454 -#include <linux/kernel.h>
455 -#include <linux/types.h>
456 -#include <linux/crypto.h>
457 -#include <linux/err.h>
458 -#include <crypto/aes.h>
459 -
460 -#include <net/mac80211.h>
461 -#include "key.h"
462 -#include "aes_gcm.h"
463 -
464 -void ieee80211_aes_gcm_encrypt(struct crypto_aead *tfm, u8 *j_0, u8 *aad,
465 - u8 *data, size_t data_len, u8 *mic)
466 -{
467 - struct scatterlist assoc, pt, ct[2];
468 -
469 - char aead_req_data[sizeof(struct aead_request) +
470 - crypto_aead_reqsize(tfm)]
471 - __aligned(__alignof__(struct aead_request));
472 - struct aead_request *aead_req = (void *)aead_req_data;
473 -
474 - memset(aead_req, 0, sizeof(aead_req_data));
475 -
476 - sg_init_one(&pt, data, data_len);
477 - sg_init_one(&assoc, &aad[2], be16_to_cpup((__be16 *)aad));
478 - sg_init_table(ct, 2);
479 - sg_set_buf(&ct[0], data, data_len);
480 - sg_set_buf(&ct[1], mic, IEEE80211_GCMP_MIC_LEN);
481 -
482 - aead_request_set_tfm(aead_req, tfm);
483 - aead_request_set_assoc(aead_req, &assoc, assoc.length);
484 - aead_request_set_crypt(aead_req, &pt, ct, data_len, j_0);
485 -
486 - crypto_aead_encrypt(aead_req);
487 -}
488 -
489 -int ieee80211_aes_gcm_decrypt(struct crypto_aead *tfm, u8 *j_0, u8 *aad,
490 - u8 *data, size_t data_len, u8 *mic)
491 -{
492 - struct scatterlist assoc, pt, ct[2];
493 - char aead_req_data[sizeof(struct aead_request) +
494 - crypto_aead_reqsize(tfm)]
495 - __aligned(__alignof__(struct aead_request));
496 - struct aead_request *aead_req = (void *)aead_req_data;
497 -
498 - if (data_len == 0)
499 - return -EINVAL;
500 -
501 - memset(aead_req, 0, sizeof(aead_req_data));
502 -
503 - sg_init_one(&pt, data, data_len);
504 - sg_init_one(&assoc, &aad[2], be16_to_cpup((__be16 *)aad));
505 - sg_init_table(ct, 2);
506 - sg_set_buf(&ct[0], data, data_len);
507 - sg_set_buf(&ct[1], mic, IEEE80211_GCMP_MIC_LEN);
508 -
509 - aead_request_set_tfm(aead_req, tfm);
510 - aead_request_set_assoc(aead_req, &assoc, assoc.length);
511 - aead_request_set_crypt(aead_req, ct, &pt,
512 - data_len + IEEE80211_GCMP_MIC_LEN, j_0);
513 -
514 - return crypto_aead_decrypt(aead_req);
515 -}
516 -
517 -struct crypto_aead *ieee80211_aes_gcm_key_setup_encrypt(const u8 key[],
518 - size_t key_len)
519 -{
520 - struct crypto_aead *tfm;
521 - int err;
522 -
523 - tfm = crypto_alloc_aead("gcm(aes)", 0, CRYPTO_ALG_ASYNC);
524 - if (IS_ERR(tfm))
525 - return tfm;
526 -
527 - err = crypto_aead_setkey(tfm, key, key_len);
528 - if (!err)
529 - err = crypto_aead_setauthsize(tfm, IEEE80211_GCMP_MIC_LEN);
530 - if (!err)
531 - return tfm;
532 -
533 - crypto_free_aead(tfm);
534 - return ERR_PTR(err);
535 -}
536 -
537 -void ieee80211_aes_gcm_key_free(struct crypto_aead *tfm)
538 -{
539 - crypto_free_aead(tfm);
540 -}
541 --- a/net/mac80211/aes_gcm.h
542 +++ /dev/null
543 @@ -1,22 +0,0 @@
544 -/*
545 - * Copyright 2014-2015, Qualcomm Atheros, Inc.
546 - *
547 - * This program is free software; you can redistribute it and/or modify
548 - * it under the terms of the GNU General Public License version 2 as
549 - * published by the Free Software Foundation.
550 - */
551 -
552 -#ifndef AES_GCM_H
553 -#define AES_GCM_H
554 -
555 -#include <linux/crypto.h>
556 -
557 -void ieee80211_aes_gcm_encrypt(struct crypto_aead *tfm, u8 *j_0, u8 *aad,
558 - u8 *data, size_t data_len, u8 *mic);
559 -int ieee80211_aes_gcm_decrypt(struct crypto_aead *tfm, u8 *j_0, u8 *aad,
560 - u8 *data, size_t data_len, u8 *mic);
561 -struct crypto_aead *ieee80211_aes_gcm_key_setup_encrypt(const u8 key[],
562 - size_t key_len);
563 -void ieee80211_aes_gcm_key_free(struct crypto_aead *tfm);
564 -
565 -#endif /* AES_GCM_H */
566 --- a/net/mac80211/aes_gmac.c
567 +++ /dev/null
568 @@ -1,84 +0,0 @@
569 -/*
570 - * AES-GMAC for IEEE 802.11 BIP-GMAC-128 and BIP-GMAC-256
571 - * Copyright 2015, Qualcomm Atheros, Inc.
572 - *
573 - * This program is free software; you can redistribute it and/or modify
574 - * it under the terms of the GNU General Public License version 2 as
575 - * published by the Free Software Foundation.
576 - */
577 -
578 -#include <linux/kernel.h>
579 -#include <linux/types.h>
580 -#include <linux/crypto.h>
581 -#include <linux/err.h>
582 -#include <crypto/aes.h>
583 -
584 -#include <net/mac80211.h>
585 -#include "key.h"
586 -#include "aes_gmac.h"
587 -
588 -#define GMAC_MIC_LEN 16
589 -#define GMAC_NONCE_LEN 12
590 -#define AAD_LEN 20
591 -
592 -int ieee80211_aes_gmac(struct crypto_aead *tfm, const u8 *aad, u8 *nonce,
593 - const u8 *data, size_t data_len, u8 *mic)
594 -{
595 - struct scatterlist sg[3], ct[1];
596 - char aead_req_data[sizeof(struct aead_request) +
597 - crypto_aead_reqsize(tfm)]
598 - __aligned(__alignof__(struct aead_request));
599 - struct aead_request *aead_req = (void *)aead_req_data;
600 - u8 zero[GMAC_MIC_LEN], iv[AES_BLOCK_SIZE];
601 -
602 - if (data_len < GMAC_MIC_LEN)
603 - return -EINVAL;
604 -
605 - memset(aead_req, 0, sizeof(aead_req_data));
606 -
607 - memset(zero, 0, GMAC_MIC_LEN);
608 - sg_init_table(sg, 3);
609 - sg_set_buf(&sg[0], aad, AAD_LEN);
610 - sg_set_buf(&sg[1], data, data_len - GMAC_MIC_LEN);
611 - sg_set_buf(&sg[2], zero, GMAC_MIC_LEN);
612 -
613 - memcpy(iv, nonce, GMAC_NONCE_LEN);
614 - memset(iv + GMAC_NONCE_LEN, 0, sizeof(iv) - GMAC_NONCE_LEN);
615 - iv[AES_BLOCK_SIZE - 1] = 0x01;
616 -
617 - sg_init_table(ct, 1);
618 - sg_set_buf(&ct[0], mic, GMAC_MIC_LEN);
619 -
620 - aead_request_set_tfm(aead_req, tfm);
621 - aead_request_set_assoc(aead_req, sg, AAD_LEN + data_len);
622 - aead_request_set_crypt(aead_req, NULL, ct, 0, iv);
623 -
624 - crypto_aead_encrypt(aead_req);
625 -
626 - return 0;
627 -}
628 -
629 -struct crypto_aead *ieee80211_aes_gmac_key_setup(const u8 key[],
630 - size_t key_len)
631 -{
632 - struct crypto_aead *tfm;
633 - int err;
634 -
635 - tfm = crypto_alloc_aead("gcm(aes)", 0, CRYPTO_ALG_ASYNC);
636 - if (IS_ERR(tfm))
637 - return tfm;
638 -
639 - err = crypto_aead_setkey(tfm, key, key_len);
640 - if (!err)
641 - return tfm;
642 - if (!err)
643 - err = crypto_aead_setauthsize(tfm, GMAC_MIC_LEN);
644 -
645 - crypto_free_aead(tfm);
646 - return ERR_PTR(err);
647 -}
648 -
649 -void ieee80211_aes_gmac_key_free(struct crypto_aead *tfm)
650 -{
651 - crypto_free_aead(tfm);
652 -}
653 --- a/net/mac80211/aes_gmac.h
654 +++ /dev/null
655 @@ -1,20 +0,0 @@
656 -/*
657 - * Copyright 2015, Qualcomm Atheros, Inc.
658 - *
659 - * This program is free software; you can redistribute it and/or modify
660 - * it under the terms of the GNU General Public License version 2 as
661 - * published by the Free Software Foundation.
662 - */
663 -
664 -#ifndef AES_GMAC_H
665 -#define AES_GMAC_H
666 -
667 -#include <linux/crypto.h>
668 -
669 -struct crypto_aead *ieee80211_aes_gmac_key_setup(const u8 key[],
670 - size_t key_len);
671 -int ieee80211_aes_gmac(struct crypto_aead *tfm, const u8 *aad, u8 *nonce,
672 - const u8 *data, size_t data_len, u8 *mic);
673 -void ieee80211_aes_gmac_key_free(struct crypto_aead *tfm);
674 -
675 -#endif /* AES_GMAC_H */
676 --- a/net/mac80211/cfg.c
677 +++ b/net/mac80211/cfg.c
678 @@ -162,13 +162,8 @@ static int ieee80211_add_key(struct wiph
679 return -EINVAL;
680 break;
681 case WLAN_CIPHER_SUITE_CCMP:
682 - case WLAN_CIPHER_SUITE_CCMP_256:
683 case WLAN_CIPHER_SUITE_AES_CMAC:
684 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
685 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
686 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
687 case WLAN_CIPHER_SUITE_GCMP:
688 - case WLAN_CIPHER_SUITE_GCMP_256:
689 break;
690 default:
691 cs = ieee80211_cs_get(local, params->cipher, sdata->vif.type);
692 @@ -353,7 +348,6 @@ static int ieee80211_get_key(struct wiph
693 params.seq_len = 6;
694 break;
695 case WLAN_CIPHER_SUITE_CCMP:
696 - case WLAN_CIPHER_SUITE_CCMP_256:
697 pn64 = atomic64_read(&key->u.ccmp.tx_pn);
698 seq[0] = pn64;
699 seq[1] = pn64 >> 8;
700 @@ -365,35 +359,10 @@ static int ieee80211_get_key(struct wiph
701 params.seq_len = 6;
702 break;
703 case WLAN_CIPHER_SUITE_AES_CMAC:
704 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
705 pn64 = atomic64_read(&key->u.aes_cmac.tx_pn);
706 seq[0] = pn64;
707 seq[1] = pn64 >> 8;
708 seq[2] = pn64 >> 16;
709 - seq[3] = pn64 >> 24;
710 - seq[4] = pn64 >> 32;
711 - seq[5] = pn64 >> 40;
712 - params.seq = seq;
713 - params.seq_len = 6;
714 - break;
715 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
716 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
717 - pn64 = atomic64_read(&key->u.aes_gmac.tx_pn);
718 - seq[0] = pn64;
719 - seq[1] = pn64 >> 8;
720 - seq[2] = pn64 >> 16;
721 - seq[3] = pn64 >> 24;
722 - seq[4] = pn64 >> 32;
723 - seq[5] = pn64 >> 40;
724 - params.seq = seq;
725 - params.seq_len = 6;
726 - break;
727 - case WLAN_CIPHER_SUITE_GCMP:
728 - case WLAN_CIPHER_SUITE_GCMP_256:
729 - pn64 = atomic64_read(&key->u.gcmp.tx_pn);
730 - seq[0] = pn64;
731 - seq[1] = pn64 >> 8;
732 - seq[2] = pn64 >> 16;
733 seq[3] = pn64 >> 24;
734 seq[4] = pn64 >> 32;
735 seq[5] = pn64 >> 40;
736 --- a/net/mac80211/debugfs_key.c
737 +++ b/net/mac80211/debugfs_key.c
738 @@ -94,33 +94,17 @@ static ssize_t key_tx_spec_read(struct f
739 key->u.tkip.tx.iv16);
740 break;
741 case WLAN_CIPHER_SUITE_CCMP:
742 - case WLAN_CIPHER_SUITE_CCMP_256:
743 pn = atomic64_read(&key->u.ccmp.tx_pn);
744 len = scnprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x\n",
745 (u8)(pn >> 40), (u8)(pn >> 32), (u8)(pn >> 24),
746 (u8)(pn >> 16), (u8)(pn >> 8), (u8)pn);
747 break;
748 case WLAN_CIPHER_SUITE_AES_CMAC:
749 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
750 pn = atomic64_read(&key->u.aes_cmac.tx_pn);
751 len = scnprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x\n",
752 (u8)(pn >> 40), (u8)(pn >> 32), (u8)(pn >> 24),
753 (u8)(pn >> 16), (u8)(pn >> 8), (u8)pn);
754 break;
755 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
756 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
757 - pn = atomic64_read(&key->u.aes_gmac.tx_pn);
758 - len = scnprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x\n",
759 - (u8)(pn >> 40), (u8)(pn >> 32), (u8)(pn >> 24),
760 - (u8)(pn >> 16), (u8)(pn >> 8), (u8)pn);
761 - break;
762 - case WLAN_CIPHER_SUITE_GCMP:
763 - case WLAN_CIPHER_SUITE_GCMP_256:
764 - pn = atomic64_read(&key->u.gcmp.tx_pn);
765 - len = scnprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x\n",
766 - (u8)(pn >> 40), (u8)(pn >> 32), (u8)(pn >> 24),
767 - (u8)(pn >> 16), (u8)(pn >> 8), (u8)pn);
768 - break;
769 default:
770 return 0;
771 }
772 @@ -150,7 +134,6 @@ static ssize_t key_rx_spec_read(struct f
773 len = p - buf;
774 break;
775 case WLAN_CIPHER_SUITE_CCMP:
776 - case WLAN_CIPHER_SUITE_CCMP_256:
777 for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++) {
778 rpn = key->u.ccmp.rx_pn[i];
779 p += scnprintf(p, sizeof(buf)+buf-p,
780 @@ -161,7 +144,6 @@ static ssize_t key_rx_spec_read(struct f
781 len = p - buf;
782 break;
783 case WLAN_CIPHER_SUITE_AES_CMAC:
784 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
785 rpn = key->u.aes_cmac.rx_pn;
786 p += scnprintf(p, sizeof(buf)+buf-p,
787 "%02x%02x%02x%02x%02x%02x\n",
788 @@ -169,26 +151,6 @@ static ssize_t key_rx_spec_read(struct f
789 rpn[3], rpn[4], rpn[5]);
790 len = p - buf;
791 break;
792 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
793 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
794 - rpn = key->u.aes_gmac.rx_pn;
795 - p += scnprintf(p, sizeof(buf)+buf-p,
796 - "%02x%02x%02x%02x%02x%02x\n",
797 - rpn[0], rpn[1], rpn[2],
798 - rpn[3], rpn[4], rpn[5]);
799 - len = p - buf;
800 - break;
801 - case WLAN_CIPHER_SUITE_GCMP:
802 - case WLAN_CIPHER_SUITE_GCMP_256:
803 - for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++) {
804 - rpn = key->u.gcmp.rx_pn[i];
805 - p += scnprintf(p, sizeof(buf)+buf-p,
806 - "%02x%02x%02x%02x%02x%02x\n",
807 - rpn[0], rpn[1], rpn[2],
808 - rpn[3], rpn[4], rpn[5]);
809 - }
810 - len = p - buf;
811 - break;
812 default:
813 return 0;
814 }
815 @@ -205,23 +167,12 @@ static ssize_t key_replays_read(struct f
816
817 switch (key->conf.cipher) {
818 case WLAN_CIPHER_SUITE_CCMP:
819 - case WLAN_CIPHER_SUITE_CCMP_256:
820 len = scnprintf(buf, sizeof(buf), "%u\n", key->u.ccmp.replays);
821 break;
822 case WLAN_CIPHER_SUITE_AES_CMAC:
823 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
824 len = scnprintf(buf, sizeof(buf), "%u\n",
825 key->u.aes_cmac.replays);
826 break;
827 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
828 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
829 - len = scnprintf(buf, sizeof(buf), "%u\n",
830 - key->u.aes_gmac.replays);
831 - break;
832 - case WLAN_CIPHER_SUITE_GCMP:
833 - case WLAN_CIPHER_SUITE_GCMP_256:
834 - len = scnprintf(buf, sizeof(buf), "%u\n", key->u.gcmp.replays);
835 - break;
836 default:
837 return 0;
838 }
839 @@ -238,15 +189,9 @@ static ssize_t key_icverrors_read(struct
840
841 switch (key->conf.cipher) {
842 case WLAN_CIPHER_SUITE_AES_CMAC:
843 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
844 len = scnprintf(buf, sizeof(buf), "%u\n",
845 key->u.aes_cmac.icverrors);
846 break;
847 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
848 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
849 - len = scnprintf(buf, sizeof(buf), "%u\n",
850 - key->u.aes_gmac.icverrors);
851 - break;
852 default:
853 return 0;
854 }
855 --- a/net/mac80211/key.c
856 +++ b/net/mac80211/key.c
857 @@ -24,8 +24,6 @@
858 #include "debugfs_key.h"
859 #include "aes_ccm.h"
860 #include "aes_cmac.h"
861 -#include "aes_gmac.h"
862 -#include "aes_gcm.h"
863
864
865 /**
866 @@ -164,13 +162,7 @@ static int ieee80211_key_enable_hw_accel
867 case WLAN_CIPHER_SUITE_WEP104:
868 case WLAN_CIPHER_SUITE_TKIP:
869 case WLAN_CIPHER_SUITE_CCMP:
870 - case WLAN_CIPHER_SUITE_CCMP_256:
871 case WLAN_CIPHER_SUITE_AES_CMAC:
872 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
873 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
874 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
875 - case WLAN_CIPHER_SUITE_GCMP:
876 - case WLAN_CIPHER_SUITE_GCMP_256:
877 /* all of these we can do in software - if driver can */
878 if (ret == 1)
879 return 0;
880 @@ -394,26 +386,7 @@ ieee80211_key_alloc(u32 cipher, int idx,
881 * Initialize AES key state here as an optimization so that
882 * it does not need to be initialized for every packet.
883 */
884 - key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(
885 - key_data, key_len, IEEE80211_CCMP_MIC_LEN);
886 - if (IS_ERR(key->u.ccmp.tfm)) {
887 - err = PTR_ERR(key->u.ccmp.tfm);
888 - kfree(key);
889 - return ERR_PTR(err);
890 - }
891 - break;
892 - case WLAN_CIPHER_SUITE_CCMP_256:
893 - key->conf.iv_len = IEEE80211_CCMP_256_HDR_LEN;
894 - key->conf.icv_len = IEEE80211_CCMP_256_MIC_LEN;
895 - for (i = 0; seq && i < IEEE80211_NUM_TIDS + 1; i++)
896 - for (j = 0; j < IEEE80211_CCMP_256_PN_LEN; j++)
897 - key->u.ccmp.rx_pn[i][j] =
898 - seq[IEEE80211_CCMP_256_PN_LEN - j - 1];
899 - /* Initialize AES key state here as an optimization so that
900 - * it does not need to be initialized for every packet.
901 - */
902 - key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(
903 - key_data, key_len, IEEE80211_CCMP_256_MIC_LEN);
904 + key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
905 if (IS_ERR(key->u.ccmp.tfm)) {
906 err = PTR_ERR(key->u.ccmp.tfm);
907 kfree(key);
908 @@ -421,12 +394,8 @@ ieee80211_key_alloc(u32 cipher, int idx,
909 }
910 break;
911 case WLAN_CIPHER_SUITE_AES_CMAC:
912 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
913 key->conf.iv_len = 0;
914 - if (cipher == WLAN_CIPHER_SUITE_AES_CMAC)
915 - key->conf.icv_len = sizeof(struct ieee80211_mmie);
916 - else
917 - key->conf.icv_len = sizeof(struct ieee80211_mmie_16);
918 + key->conf.icv_len = sizeof(struct ieee80211_mmie);
919 if (seq)
920 for (j = 0; j < IEEE80211_CMAC_PN_LEN; j++)
921 key->u.aes_cmac.rx_pn[j] =
922 @@ -436,51 +405,13 @@ ieee80211_key_alloc(u32 cipher, int idx,
923 * it does not need to be initialized for every packet.
924 */
925 key->u.aes_cmac.tfm =
926 - ieee80211_aes_cmac_key_setup(key_data, key_len);
927 + ieee80211_aes_cmac_key_setup(key_data);
928 if (IS_ERR(key->u.aes_cmac.tfm)) {
929 err = PTR_ERR(key->u.aes_cmac.tfm);
930 kfree(key);
931 return ERR_PTR(err);
932 }
933 break;
934 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
935 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
936 - key->conf.iv_len = 0;
937 - key->conf.icv_len = sizeof(struct ieee80211_mmie_16);
938 - if (seq)
939 - for (j = 0; j < IEEE80211_GMAC_PN_LEN; j++)
940 - key->u.aes_gmac.rx_pn[j] =
941 - seq[IEEE80211_GMAC_PN_LEN - j - 1];
942 - /* Initialize AES key state here as an optimization so that
943 - * it does not need to be initialized for every packet.
944 - */
945 - key->u.aes_gmac.tfm =
946 - ieee80211_aes_gmac_key_setup(key_data, key_len);
947 - if (IS_ERR(key->u.aes_gmac.tfm)) {
948 - err = PTR_ERR(key->u.aes_gmac.tfm);
949 - kfree(key);
950 - return ERR_PTR(err);
951 - }
952 - break;
953 - case WLAN_CIPHER_SUITE_GCMP:
954 - case WLAN_CIPHER_SUITE_GCMP_256:
955 - key->conf.iv_len = IEEE80211_GCMP_HDR_LEN;
956 - key->conf.icv_len = IEEE80211_GCMP_MIC_LEN;
957 - for (i = 0; seq && i < IEEE80211_NUM_TIDS + 1; i++)
958 - for (j = 0; j < IEEE80211_GCMP_PN_LEN; j++)
959 - key->u.gcmp.rx_pn[i][j] =
960 - seq[IEEE80211_GCMP_PN_LEN - j - 1];
961 - /* Initialize AES key state here as an optimization so that
962 - * it does not need to be initialized for every packet.
963 - */
964 - key->u.gcmp.tfm = ieee80211_aes_gcm_key_setup_encrypt(key_data,
965 - key_len);
966 - if (IS_ERR(key->u.gcmp.tfm)) {
967 - err = PTR_ERR(key->u.gcmp.tfm);
968 - kfree(key);
969 - return ERR_PTR(err);
970 - }
971 - break;
972 default:
973 if (cs) {
974 size_t len = (seq_len > MAX_PN_LEN) ?
975 @@ -502,24 +433,10 @@ ieee80211_key_alloc(u32 cipher, int idx,
976
977 static void ieee80211_key_free_common(struct ieee80211_key *key)
978 {
979 - switch (key->conf.cipher) {
980 - case WLAN_CIPHER_SUITE_CCMP:
981 - case WLAN_CIPHER_SUITE_CCMP_256:
982 + if (key->conf.cipher == WLAN_CIPHER_SUITE_CCMP)
983 ieee80211_aes_key_free(key->u.ccmp.tfm);
984 - break;
985 - case WLAN_CIPHER_SUITE_AES_CMAC:
986 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
987 + if (key->conf.cipher == WLAN_CIPHER_SUITE_AES_CMAC)
988 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
989 - break;
990 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
991 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
992 - ieee80211_aes_gmac_key_free(key->u.aes_gmac.tfm);
993 - break;
994 - case WLAN_CIPHER_SUITE_GCMP:
995 - case WLAN_CIPHER_SUITE_GCMP_256:
996 - ieee80211_aes_gcm_key_free(key->u.gcmp.tfm);
997 - break;
998 - }
999 kzfree(key);
1000 }
1001
1002 @@ -826,7 +743,6 @@ void ieee80211_get_key_tx_seq(struct iee
1003 seq->tkip.iv16 = key->u.tkip.tx.iv16;
1004 break;
1005 case WLAN_CIPHER_SUITE_CCMP:
1006 - case WLAN_CIPHER_SUITE_CCMP_256:
1007 pn64 = atomic64_read(&key->u.ccmp.tx_pn);
1008 seq->ccmp.pn[5] = pn64;
1009 seq->ccmp.pn[4] = pn64 >> 8;
1010 @@ -836,7 +752,6 @@ void ieee80211_get_key_tx_seq(struct iee
1011 seq->ccmp.pn[0] = pn64 >> 40;
1012 break;
1013 case WLAN_CIPHER_SUITE_AES_CMAC:
1014 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1015 pn64 = atomic64_read(&key->u.aes_cmac.tx_pn);
1016 seq->ccmp.pn[5] = pn64;
1017 seq->ccmp.pn[4] = pn64 >> 8;
1018 @@ -845,26 +760,6 @@ void ieee80211_get_key_tx_seq(struct iee
1019 seq->ccmp.pn[1] = pn64 >> 32;
1020 seq->ccmp.pn[0] = pn64 >> 40;
1021 break;
1022 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1023 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1024 - pn64 = atomic64_read(&key->u.aes_gmac.tx_pn);
1025 - seq->ccmp.pn[5] = pn64;
1026 - seq->ccmp.pn[4] = pn64 >> 8;
1027 - seq->ccmp.pn[3] = pn64 >> 16;
1028 - seq->ccmp.pn[2] = pn64 >> 24;
1029 - seq->ccmp.pn[1] = pn64 >> 32;
1030 - seq->ccmp.pn[0] = pn64 >> 40;
1031 - break;
1032 - case WLAN_CIPHER_SUITE_GCMP:
1033 - case WLAN_CIPHER_SUITE_GCMP_256:
1034 - pn64 = atomic64_read(&key->u.gcmp.tx_pn);
1035 - seq->gcmp.pn[5] = pn64;
1036 - seq->gcmp.pn[4] = pn64 >> 8;
1037 - seq->gcmp.pn[3] = pn64 >> 16;
1038 - seq->gcmp.pn[2] = pn64 >> 24;
1039 - seq->gcmp.pn[1] = pn64 >> 32;
1040 - seq->gcmp.pn[0] = pn64 >> 40;
1041 - break;
1042 default:
1043 WARN_ON(1);
1044 }
1045 @@ -887,7 +782,6 @@ void ieee80211_get_key_rx_seq(struct iee
1046 seq->tkip.iv16 = key->u.tkip.rx[tid].iv16;
1047 break;
1048 case WLAN_CIPHER_SUITE_CCMP:
1049 - case WLAN_CIPHER_SUITE_CCMP_256:
1050 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1051 return;
1052 if (tid < 0)
1053 @@ -897,29 +791,11 @@ void ieee80211_get_key_rx_seq(struct iee
1054 memcpy(seq->ccmp.pn, pn, IEEE80211_CCMP_PN_LEN);
1055 break;
1056 case WLAN_CIPHER_SUITE_AES_CMAC:
1057 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1058 if (WARN_ON(tid != 0))
1059 return;
1060 pn = key->u.aes_cmac.rx_pn;
1061 memcpy(seq->aes_cmac.pn, pn, IEEE80211_CMAC_PN_LEN);
1062 break;
1063 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1064 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1065 - if (WARN_ON(tid != 0))
1066 - return;
1067 - pn = key->u.aes_gmac.rx_pn;
1068 - memcpy(seq->aes_gmac.pn, pn, IEEE80211_GMAC_PN_LEN);
1069 - break;
1070 - case WLAN_CIPHER_SUITE_GCMP:
1071 - case WLAN_CIPHER_SUITE_GCMP_256:
1072 - if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1073 - return;
1074 - if (tid < 0)
1075 - pn = key->u.gcmp.rx_pn[IEEE80211_NUM_TIDS];
1076 - else
1077 - pn = key->u.gcmp.rx_pn[tid];
1078 - memcpy(seq->gcmp.pn, pn, IEEE80211_GCMP_PN_LEN);
1079 - break;
1080 }
1081 }
1082 EXPORT_SYMBOL(ieee80211_get_key_rx_seq);
1083 @@ -938,7 +814,6 @@ void ieee80211_set_key_tx_seq(struct iee
1084 key->u.tkip.tx.iv16 = seq->tkip.iv16;
1085 break;
1086 case WLAN_CIPHER_SUITE_CCMP:
1087 - case WLAN_CIPHER_SUITE_CCMP_256:
1088 pn64 = (u64)seq->ccmp.pn[5] |
1089 ((u64)seq->ccmp.pn[4] << 8) |
1090 ((u64)seq->ccmp.pn[3] << 16) |
1091 @@ -948,7 +823,6 @@ void ieee80211_set_key_tx_seq(struct iee
1092 atomic64_set(&key->u.ccmp.tx_pn, pn64);
1093 break;
1094 case WLAN_CIPHER_SUITE_AES_CMAC:
1095 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1096 pn64 = (u64)seq->aes_cmac.pn[5] |
1097 ((u64)seq->aes_cmac.pn[4] << 8) |
1098 ((u64)seq->aes_cmac.pn[3] << 16) |
1099 @@ -957,26 +831,6 @@ void ieee80211_set_key_tx_seq(struct iee
1100 ((u64)seq->aes_cmac.pn[0] << 40);
1101 atomic64_set(&key->u.aes_cmac.tx_pn, pn64);
1102 break;
1103 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1104 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1105 - pn64 = (u64)seq->aes_gmac.pn[5] |
1106 - ((u64)seq->aes_gmac.pn[4] << 8) |
1107 - ((u64)seq->aes_gmac.pn[3] << 16) |
1108 - ((u64)seq->aes_gmac.pn[2] << 24) |
1109 - ((u64)seq->aes_gmac.pn[1] << 32) |
1110 - ((u64)seq->aes_gmac.pn[0] << 40);
1111 - atomic64_set(&key->u.aes_gmac.tx_pn, pn64);
1112 - break;
1113 - case WLAN_CIPHER_SUITE_GCMP:
1114 - case WLAN_CIPHER_SUITE_GCMP_256:
1115 - pn64 = (u64)seq->gcmp.pn[5] |
1116 - ((u64)seq->gcmp.pn[4] << 8) |
1117 - ((u64)seq->gcmp.pn[3] << 16) |
1118 - ((u64)seq->gcmp.pn[2] << 24) |
1119 - ((u64)seq->gcmp.pn[1] << 32) |
1120 - ((u64)seq->gcmp.pn[0] << 40);
1121 - atomic64_set(&key->u.gcmp.tx_pn, pn64);
1122 - break;
1123 default:
1124 WARN_ON(1);
1125 break;
1126 @@ -1000,7 +854,6 @@ void ieee80211_set_key_rx_seq(struct iee
1127 key->u.tkip.rx[tid].iv16 = seq->tkip.iv16;
1128 break;
1129 case WLAN_CIPHER_SUITE_CCMP:
1130 - case WLAN_CIPHER_SUITE_CCMP_256:
1131 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1132 return;
1133 if (tid < 0)
1134 @@ -1010,29 +863,11 @@ void ieee80211_set_key_rx_seq(struct iee
1135 memcpy(pn, seq->ccmp.pn, IEEE80211_CCMP_PN_LEN);
1136 break;
1137 case WLAN_CIPHER_SUITE_AES_CMAC:
1138 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1139 if (WARN_ON(tid != 0))
1140 return;
1141 pn = key->u.aes_cmac.rx_pn;
1142 memcpy(pn, seq->aes_cmac.pn, IEEE80211_CMAC_PN_LEN);
1143 break;
1144 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1145 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1146 - if (WARN_ON(tid != 0))
1147 - return;
1148 - pn = key->u.aes_gmac.rx_pn;
1149 - memcpy(pn, seq->aes_gmac.pn, IEEE80211_GMAC_PN_LEN);
1150 - break;
1151 - case WLAN_CIPHER_SUITE_GCMP:
1152 - case WLAN_CIPHER_SUITE_GCMP_256:
1153 - if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1154 - return;
1155 - if (tid < 0)
1156 - pn = key->u.gcmp.rx_pn[IEEE80211_NUM_TIDS];
1157 - else
1158 - pn = key->u.gcmp.rx_pn[tid];
1159 - memcpy(pn, seq->gcmp.pn, IEEE80211_GCMP_PN_LEN);
1160 - break;
1161 default:
1162 WARN_ON(1);
1163 break;
1164 --- a/net/mac80211/key.h
1165 +++ b/net/mac80211/key.h
1166 @@ -84,7 +84,7 @@ struct ieee80211_key {
1167 * Management frames.
1168 */
1169 u8 rx_pn[IEEE80211_NUM_TIDS + 1][IEEE80211_CCMP_PN_LEN];
1170 - struct crypto_aead *tfm;
1171 + struct crypto_cipher *tfm;
1172 u32 replays; /* dot11RSNAStatsCCMPReplays */
1173 } ccmp;
1174 struct {
1175 @@ -95,24 +95,6 @@ struct ieee80211_key {
1176 u32 icverrors; /* dot11RSNAStatsCMACICVErrors */
1177 } aes_cmac;
1178 struct {
1179 - atomic64_t tx_pn;
1180 - u8 rx_pn[IEEE80211_GMAC_PN_LEN];
1181 - struct crypto_aead *tfm;
1182 - u32 replays; /* dot11RSNAStatsCMACReplays */
1183 - u32 icverrors; /* dot11RSNAStatsCMACICVErrors */
1184 - } aes_gmac;
1185 - struct {
1186 - atomic64_t tx_pn;
1187 - /* Last received packet number. The first
1188 - * IEEE80211_NUM_TIDS counters are used with Data
1189 - * frames and the last counter is used with Robust
1190 - * Management frames.
1191 - */
1192 - u8 rx_pn[IEEE80211_NUM_TIDS + 1][IEEE80211_GCMP_PN_LEN];
1193 - struct crypto_aead *tfm;
1194 - u32 replays; /* dot11RSNAStatsGCMPReplays */
1195 - } gcmp;
1196 - struct {
1197 /* generic cipher scheme */
1198 u8 rx_pn[IEEE80211_NUM_TIDS + 1][MAX_PN_LEN];
1199 } gen;
1200 --- a/net/mac80211/main.c
1201 +++ b/net/mac80211/main.c
1202 @@ -666,15 +666,9 @@ static int ieee80211_init_cipher_suites(
1203 WLAN_CIPHER_SUITE_WEP104,
1204 WLAN_CIPHER_SUITE_TKIP,
1205 WLAN_CIPHER_SUITE_CCMP,
1206 - WLAN_CIPHER_SUITE_CCMP_256,
1207 - WLAN_CIPHER_SUITE_GCMP,
1208 - WLAN_CIPHER_SUITE_GCMP_256,
1209
1210 /* keep last -- depends on hw flags! */
1211 - WLAN_CIPHER_SUITE_AES_CMAC,
1212 - WLAN_CIPHER_SUITE_BIP_CMAC_256,
1213 - WLAN_CIPHER_SUITE_BIP_GMAC_128,
1214 - WLAN_CIPHER_SUITE_BIP_GMAC_256,
1215 + WLAN_CIPHER_SUITE_AES_CMAC
1216 };
1217
1218 if (local->hw.flags & IEEE80211_HW_SW_CRYPTO_CONTROL ||
1219 @@ -713,7 +707,7 @@ static int ieee80211_init_cipher_suites(
1220 local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
1221
1222 if (!have_mfp)
1223 - local->hw.wiphy->n_cipher_suites -= 4;
1224 + local->hw.wiphy->n_cipher_suites--;
1225
1226 if (!have_wep) {
1227 local->hw.wiphy->cipher_suites += 2;
1228 @@ -730,42 +724,32 @@ static int ieee80211_init_cipher_suites(
1229 /* Driver specifies cipher schemes only (but not cipher suites
1230 * including the schemes)
1231 *
1232 - * We start counting ciphers defined by schemes, TKIP, CCMP,
1233 - * CCMP-256, GCMP, and GCMP-256
1234 + * We start counting ciphers defined by schemes, TKIP and CCMP
1235 */
1236 - n_suites = local->hw.n_cipher_schemes + 5;
1237 + n_suites = local->hw.n_cipher_schemes + 2;
1238
1239 /* check if we have WEP40 and WEP104 */
1240 if (have_wep)
1241 n_suites += 2;
1242
1243 - /* check if we have AES_CMAC, BIP-CMAC-256, BIP-GMAC-128,
1244 - * BIP-GMAC-256
1245 - */
1246 + /* check if we have AES_CMAC */
1247 if (have_mfp)
1248 - n_suites += 4;
1249 + n_suites++;
1250
1251 suites = kmalloc(sizeof(u32) * n_suites, GFP_KERNEL);
1252 if (!suites)
1253 return -ENOMEM;
1254
1255 suites[w++] = WLAN_CIPHER_SUITE_CCMP;
1256 - suites[w++] = WLAN_CIPHER_SUITE_CCMP_256;
1257 suites[w++] = WLAN_CIPHER_SUITE_TKIP;
1258 - suites[w++] = WLAN_CIPHER_SUITE_GCMP;
1259 - suites[w++] = WLAN_CIPHER_SUITE_GCMP_256;
1260
1261 if (have_wep) {
1262 suites[w++] = WLAN_CIPHER_SUITE_WEP40;
1263 suites[w++] = WLAN_CIPHER_SUITE_WEP104;
1264 }
1265
1266 - if (have_mfp) {
1267 + if (have_mfp)
1268 suites[w++] = WLAN_CIPHER_SUITE_AES_CMAC;
1269 - suites[w++] = WLAN_CIPHER_SUITE_BIP_CMAC_256;
1270 - suites[w++] = WLAN_CIPHER_SUITE_BIP_GMAC_128;
1271 - suites[w++] = WLAN_CIPHER_SUITE_BIP_GMAC_256;
1272 - }
1273
1274 for (r = 0; r < local->hw.n_cipher_schemes; r++)
1275 suites[w++] = cs[r].cipher;
1276 --- a/net/mac80211/rx.c
1277 +++ b/net/mac80211/rx.c
1278 @@ -647,7 +647,6 @@ static int ieee80211_get_mmie_keyidx(str
1279 {
1280 struct ieee80211_mgmt *hdr = (struct ieee80211_mgmt *) skb->data;
1281 struct ieee80211_mmie *mmie;
1282 - struct ieee80211_mmie_16 *mmie16;
1283
1284 if (skb->len < 24 + sizeof(*mmie) || !is_multicast_ether_addr(hdr->da))
1285 return -1;
1286 @@ -657,18 +656,11 @@ static int ieee80211_get_mmie_keyidx(str
1287
1288 mmie = (struct ieee80211_mmie *)
1289 (skb->data + skb->len - sizeof(*mmie));
1290 - if (mmie->element_id == WLAN_EID_MMIE &&
1291 - mmie->length == sizeof(*mmie) - 2)
1292 - return le16_to_cpu(mmie->key_id);
1293 -
1294 - mmie16 = (struct ieee80211_mmie_16 *)
1295 - (skb->data + skb->len - sizeof(*mmie16));
1296 - if (skb->len >= 24 + sizeof(*mmie16) &&
1297 - mmie16->element_id == WLAN_EID_MMIE &&
1298 - mmie16->length == sizeof(*mmie16) - 2)
1299 - return le16_to_cpu(mmie16->key_id);
1300 + if (mmie->element_id != WLAN_EID_MMIE ||
1301 + mmie->length != sizeof(*mmie) - 2)
1302 + return -1;
1303
1304 - return -1;
1305 + return le16_to_cpu(mmie->key_id);
1306 }
1307
1308 static int iwl80211_get_cs_keyid(const struct ieee80211_cipher_scheme *cs,
1309 @@ -1658,27 +1650,11 @@ ieee80211_rx_h_decrypt(struct ieee80211_
1310 result = ieee80211_crypto_tkip_decrypt(rx);
1311 break;
1312 case WLAN_CIPHER_SUITE_CCMP:
1313 - result = ieee80211_crypto_ccmp_decrypt(
1314 - rx, IEEE80211_CCMP_MIC_LEN);
1315 - break;
1316 - case WLAN_CIPHER_SUITE_CCMP_256:
1317 - result = ieee80211_crypto_ccmp_decrypt(
1318 - rx, IEEE80211_CCMP_256_MIC_LEN);
1319 + result = ieee80211_crypto_ccmp_decrypt(rx);
1320 break;
1321 case WLAN_CIPHER_SUITE_AES_CMAC:
1322 result = ieee80211_crypto_aes_cmac_decrypt(rx);
1323 break;
1324 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1325 - result = ieee80211_crypto_aes_cmac_256_decrypt(rx);
1326 - break;
1327 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1328 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1329 - result = ieee80211_crypto_aes_gmac_decrypt(rx);
1330 - break;
1331 - case WLAN_CIPHER_SUITE_GCMP:
1332 - case WLAN_CIPHER_SUITE_GCMP_256:
1333 - result = ieee80211_crypto_gcmp_decrypt(rx);
1334 - break;
1335 default:
1336 result = ieee80211_crypto_hw_decrypt(rx);
1337 }
1338 @@ -1805,9 +1781,7 @@ ieee80211_rx_h_defragment(struct ieee802
1339 /* This is the first fragment of a new frame. */
1340 entry = ieee80211_reassemble_add(rx->sdata, frag, seq,
1341 rx->seqno_idx, &(rx->skb));
1342 - if (rx->key &&
1343 - (rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP ||
1344 - rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP_256) &&
1345 + if (rx->key && rx->key->conf.cipher == WLAN_CIPHER_SUITE_CCMP &&
1346 ieee80211_has_protected(fc)) {
1347 int queue = rx->security_idx;
1348 /* Store CCMP PN so that we can verify that the next
1349 @@ -1836,9 +1810,7 @@ ieee80211_rx_h_defragment(struct ieee802
1350 int i;
1351 u8 pn[IEEE80211_CCMP_PN_LEN], *rpn;
1352 int queue;
1353 - if (!rx->key ||
1354 - (rx->key->conf.cipher != WLAN_CIPHER_SUITE_CCMP &&
1355 - rx->key->conf.cipher != WLAN_CIPHER_SUITE_CCMP_256))
1356 + if (!rx->key || rx->key->conf.cipher != WLAN_CIPHER_SUITE_CCMP)
1357 return RX_DROP_UNUSABLE;
1358 memcpy(pn, entry->last_pn, IEEE80211_CCMP_PN_LEN);
1359 for (i = IEEE80211_CCMP_PN_LEN - 1; i >= 0; i--) {
1360 --- a/net/mac80211/tx.c
1361 +++ b/net/mac80211/tx.c
1362 @@ -626,9 +626,6 @@ ieee80211_tx_h_select_key(struct ieee802
1363 tx->key = NULL;
1364 break;
1365 case WLAN_CIPHER_SUITE_CCMP:
1366 - case WLAN_CIPHER_SUITE_CCMP_256:
1367 - case WLAN_CIPHER_SUITE_GCMP:
1368 - case WLAN_CIPHER_SUITE_GCMP_256:
1369 if (!ieee80211_is_data_present(hdr->frame_control) &&
1370 !ieee80211_use_mfp(hdr->frame_control, tx->sta,
1371 tx->skb))
1372 @@ -639,9 +636,6 @@ ieee80211_tx_h_select_key(struct ieee802
1373 ieee80211_is_mgmt(hdr->frame_control);
1374 break;
1375 case WLAN_CIPHER_SUITE_AES_CMAC:
1376 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1377 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1378 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1379 if (!ieee80211_is_mgmt(hdr->frame_control))
1380 tx->key = NULL;
1381 break;
1382 @@ -1017,21 +1011,9 @@ ieee80211_tx_h_encrypt(struct ieee80211_
1383 case WLAN_CIPHER_SUITE_TKIP:
1384 return ieee80211_crypto_tkip_encrypt(tx);
1385 case WLAN_CIPHER_SUITE_CCMP:
1386 - return ieee80211_crypto_ccmp_encrypt(
1387 - tx, IEEE80211_CCMP_MIC_LEN);
1388 - case WLAN_CIPHER_SUITE_CCMP_256:
1389 - return ieee80211_crypto_ccmp_encrypt(
1390 - tx, IEEE80211_CCMP_256_MIC_LEN);
1391 + return ieee80211_crypto_ccmp_encrypt(tx);
1392 case WLAN_CIPHER_SUITE_AES_CMAC:
1393 return ieee80211_crypto_aes_cmac_encrypt(tx);
1394 - case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1395 - return ieee80211_crypto_aes_cmac_256_encrypt(tx);
1396 - case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1397 - case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1398 - return ieee80211_crypto_aes_gmac_encrypt(tx);
1399 - case WLAN_CIPHER_SUITE_GCMP:
1400 - case WLAN_CIPHER_SUITE_GCMP_256:
1401 - return ieee80211_crypto_gcmp_encrypt(tx);
1402 default:
1403 return ieee80211_crypto_hw_encrypt(tx);
1404 }
1405 --- a/net/mac80211/wpa.c
1406 +++ b/net/mac80211/wpa.c
1407 @@ -22,8 +22,6 @@
1408 #include "tkip.h"
1409 #include "aes_ccm.h"
1410 #include "aes_cmac.h"
1411 -#include "aes_gmac.h"
1412 -#include "aes_gcm.h"
1413 #include "wpa.h"
1414
1415 ieee80211_tx_result
1416 @@ -304,15 +302,22 @@ ieee80211_crypto_tkip_decrypt(struct iee
1417 }
1418
1419
1420 -static void ccmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *b_0, u8 *aad)
1421 +static void ccmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *scratch,
1422 + int encrypted)
1423 {
1424 __le16 mask_fc;
1425 int a4_included, mgmt;
1426 u8 qos_tid;
1427 - u16 len_a;
1428 + u8 *b_0, *aad;
1429 + u16 data_len, len_a;
1430 unsigned int hdrlen;
1431 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1432
1433 + memset(scratch, 0, 6 * AES_BLOCK_SIZE);
1434 +
1435 + b_0 = scratch + 3 * AES_BLOCK_SIZE;
1436 + aad = scratch + 4 * AES_BLOCK_SIZE;
1437 +
1438 /*
1439 * Mask FC: zero subtype b4 b5 b6 (if not mgmt)
1440 * Retry, PwrMgt, MoreData; set Protected
1441 @@ -334,21 +339,20 @@ static void ccmp_special_blocks(struct s
1442 else
1443 qos_tid = 0;
1444
1445 - /* In CCM, the initial vectors (IV) used for CTR mode encryption and CBC
1446 - * mode authentication are not allowed to collide, yet both are derived
1447 - * from this vector b_0. We only set L := 1 here to indicate that the
1448 - * data size can be represented in (L+1) bytes. The CCM layer will take
1449 - * care of storing the data length in the top (L+1) bytes and setting
1450 - * and clearing the other bits as is required to derive the two IVs.
1451 - */
1452 - b_0[0] = 0x1;
1453 + data_len = skb->len - hdrlen - IEEE80211_CCMP_HDR_LEN;
1454 + if (encrypted)
1455 + data_len -= IEEE80211_CCMP_MIC_LEN;
1456
1457 + /* First block, b_0 */
1458 + b_0[0] = 0x59; /* flags: Adata: 1, M: 011, L: 001 */
1459 /* Nonce: Nonce Flags | A2 | PN
1460 * Nonce Flags: Priority (b0..b3) | Management (b4) | Reserved (b5..b7)
1461 */
1462 b_0[1] = qos_tid | (mgmt << 4);
1463 memcpy(&b_0[2], hdr->addr2, ETH_ALEN);
1464 memcpy(&b_0[8], pn, IEEE80211_CCMP_PN_LEN);
1465 + /* l(m) */
1466 + put_unaligned_be16(data_len, &b_0[14]);
1467
1468 /* AAD (extra authenticate-only data) / masked 802.11 header
1469 * FC | A1 | A2 | A3 | SC | [A4] | [QC] */
1470 @@ -395,8 +399,7 @@ static inline void ccmp_hdr2pn(u8 *pn, u
1471 }
1472
1473
1474 -static int ccmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb,
1475 - unsigned int mic_len)
1476 +static int ccmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
1477 {
1478 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1479 struct ieee80211_key *key = tx->key;
1480 @@ -405,8 +408,7 @@ static int ccmp_encrypt_skb(struct ieee8
1481 u8 *pos;
1482 u8 pn[6];
1483 u64 pn64;
1484 - u8 aad[2 * AES_BLOCK_SIZE];
1485 - u8 b_0[AES_BLOCK_SIZE];
1486 + u8 scratch[6 * AES_BLOCK_SIZE];
1487
1488 if (info->control.hw_key &&
1489 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) &&
1490 @@ -427,7 +429,7 @@ static int ccmp_encrypt_skb(struct ieee8
1491 if (info->control.hw_key)
1492 tail = 0;
1493 else
1494 - tail = mic_len;
1495 + tail = IEEE80211_CCMP_MIC_LEN;
1496
1497 if (WARN_ON(skb_tailroom(skb) < tail ||
1498 skb_headroom(skb) < IEEE80211_CCMP_HDR_LEN))
1499 @@ -460,24 +462,23 @@ static int ccmp_encrypt_skb(struct ieee8
1500 return 0;
1501
1502 pos += IEEE80211_CCMP_HDR_LEN;
1503 - ccmp_special_blocks(skb, pn, b_0, aad);
1504 - ieee80211_aes_ccm_encrypt(key->u.ccmp.tfm, b_0, aad, pos, len,
1505 - skb_put(skb, mic_len), mic_len);
1506 + ccmp_special_blocks(skb, pn, scratch, 0);
1507 + ieee80211_aes_ccm_encrypt(key->u.ccmp.tfm, scratch, pos, len,
1508 + pos, skb_put(skb, IEEE80211_CCMP_MIC_LEN));
1509
1510 return 0;
1511 }
1512
1513
1514 ieee80211_tx_result
1515 -ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data *tx,
1516 - unsigned int mic_len)
1517 +ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data *tx)
1518 {
1519 struct sk_buff *skb;
1520
1521 ieee80211_tx_set_protected(tx);
1522
1523 skb_queue_walk(&tx->skbs, skb) {
1524 - if (ccmp_encrypt_skb(tx, skb, mic_len) < 0)
1525 + if (ccmp_encrypt_skb(tx, skb) < 0)
1526 return TX_DROP;
1527 }
1528
1529 @@ -486,8 +487,7 @@ ieee80211_crypto_ccmp_encrypt(struct iee
1530
1531
1532 ieee80211_rx_result
1533 -ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx,
1534 - unsigned int mic_len)
1535 +ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx)
1536 {
1537 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1538 int hdrlen;
1539 @@ -504,7 +504,8 @@ ieee80211_crypto_ccmp_decrypt(struct iee
1540 !ieee80211_is_robust_mgmt_frame(skb))
1541 return RX_CONTINUE;
1542
1543 - data_len = skb->len - hdrlen - IEEE80211_CCMP_HDR_LEN - mic_len;
1544 + data_len = skb->len - hdrlen - IEEE80211_CCMP_HDR_LEN -
1545 + IEEE80211_CCMP_MIC_LEN;
1546 if (!rx->sta || data_len < 0)
1547 return RX_DROP_UNUSABLE;
1548
1549 @@ -526,23 +527,23 @@ ieee80211_crypto_ccmp_decrypt(struct iee
1550 }
1551
1552 if (!(status->flag & RX_FLAG_DECRYPTED)) {
1553 - u8 aad[2 * AES_BLOCK_SIZE];
1554 - u8 b_0[AES_BLOCK_SIZE];
1555 + u8 scratch[6 * AES_BLOCK_SIZE];
1556 /* hardware didn't decrypt/verify MIC */
1557 - ccmp_special_blocks(skb, pn, b_0, aad);
1558 + ccmp_special_blocks(skb, pn, scratch, 1);
1559
1560 if (ieee80211_aes_ccm_decrypt(
1561 - key->u.ccmp.tfm, b_0, aad,
1562 + key->u.ccmp.tfm, scratch,
1563 skb->data + hdrlen + IEEE80211_CCMP_HDR_LEN,
1564 data_len,
1565 - skb->data + skb->len - mic_len, mic_len))
1566 + skb->data + skb->len - IEEE80211_CCMP_MIC_LEN,
1567 + skb->data + hdrlen + IEEE80211_CCMP_HDR_LEN))
1568 return RX_DROP_UNUSABLE;
1569 }
1570
1571 memcpy(key->u.ccmp.rx_pn[queue], pn, IEEE80211_CCMP_PN_LEN);
1572
1573 /* Remove CCMP header and MIC */
1574 - if (pskb_trim(skb, skb->len - mic_len))
1575 + if (pskb_trim(skb, skb->len - IEEE80211_CCMP_MIC_LEN))
1576 return RX_DROP_UNUSABLE;
1577 memmove(skb->data + IEEE80211_CCMP_HDR_LEN, skb->data, hdrlen);
1578 skb_pull(skb, IEEE80211_CCMP_HDR_LEN);
1579 @@ -550,229 +551,6 @@ ieee80211_crypto_ccmp_decrypt(struct iee
1580 return RX_CONTINUE;
1581 }
1582
1583 -static void gcmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *j_0, u8 *aad)
1584 -{
1585 - __le16 mask_fc;
1586 - u8 qos_tid;
1587 - struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1588 -
1589 - memcpy(j_0, hdr->addr2, ETH_ALEN);
1590 - memcpy(&j_0[ETH_ALEN], pn, IEEE80211_GCMP_PN_LEN);
1591 - j_0[13] = 0;
1592 - j_0[14] = 0;
1593 - j_0[AES_BLOCK_SIZE - 1] = 0x01;
1594 -
1595 - /* AAD (extra authenticate-only data) / masked 802.11 header
1596 - * FC | A1 | A2 | A3 | SC | [A4] | [QC]
1597 - */
1598 - put_unaligned_be16(ieee80211_hdrlen(hdr->frame_control) - 2, &aad[0]);
1599 - /* Mask FC: zero subtype b4 b5 b6 (if not mgmt)
1600 - * Retry, PwrMgt, MoreData; set Protected
1601 - */
1602 - mask_fc = hdr->frame_control;
1603 - mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY |
1604 - IEEE80211_FCTL_PM | IEEE80211_FCTL_MOREDATA);
1605 - if (!ieee80211_is_mgmt(hdr->frame_control))
1606 - mask_fc &= ~cpu_to_le16(0x0070);
1607 - mask_fc |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
1608 -
1609 - put_unaligned(mask_fc, (__le16 *)&aad[2]);
1610 - memcpy(&aad[4], &hdr->addr1, 3 * ETH_ALEN);
1611 -
1612 - /* Mask Seq#, leave Frag# */
1613 - aad[22] = *((u8 *)&hdr->seq_ctrl) & 0x0f;
1614 - aad[23] = 0;
1615 -
1616 - if (ieee80211_is_data_qos(hdr->frame_control))
1617 - qos_tid = *ieee80211_get_qos_ctl(hdr) &
1618 - IEEE80211_QOS_CTL_TID_MASK;
1619 - else
1620 - qos_tid = 0;
1621 -
1622 - if (ieee80211_has_a4(hdr->frame_control)) {
1623 - memcpy(&aad[24], hdr->addr4, ETH_ALEN);
1624 - aad[30] = qos_tid;
1625 - aad[31] = 0;
1626 - } else {
1627 - memset(&aad[24], 0, ETH_ALEN + IEEE80211_QOS_CTL_LEN);
1628 - aad[24] = qos_tid;
1629 - }
1630 -}
1631 -
1632 -static inline void gcmp_pn2hdr(u8 *hdr, const u8 *pn, int key_id)
1633 -{
1634 - hdr[0] = pn[5];
1635 - hdr[1] = pn[4];
1636 - hdr[2] = 0;
1637 - hdr[3] = 0x20 | (key_id << 6);
1638 - hdr[4] = pn[3];
1639 - hdr[5] = pn[2];
1640 - hdr[6] = pn[1];
1641 - hdr[7] = pn[0];
1642 -}
1643 -
1644 -static inline void gcmp_hdr2pn(u8 *pn, const u8 *hdr)
1645 -{
1646 - pn[0] = hdr[7];
1647 - pn[1] = hdr[6];
1648 - pn[2] = hdr[5];
1649 - pn[3] = hdr[4];
1650 - pn[4] = hdr[1];
1651 - pn[5] = hdr[0];
1652 -}
1653 -
1654 -static int gcmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
1655 -{
1656 - struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1657 - struct ieee80211_key *key = tx->key;
1658 - struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1659 - int hdrlen, len, tail;
1660 - u8 *pos;
1661 - u8 pn[6];
1662 - u64 pn64;
1663 - u8 aad[2 * AES_BLOCK_SIZE];
1664 - u8 j_0[AES_BLOCK_SIZE];
1665 -
1666 - if (info->control.hw_key &&
1667 - !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) &&
1668 - !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) &&
1669 - !((info->control.hw_key->flags &
1670 - IEEE80211_KEY_FLAG_GENERATE_IV_MGMT) &&
1671 - ieee80211_is_mgmt(hdr->frame_control))) {
1672 - /* hwaccel has no need for preallocated room for GCMP
1673 - * header or MIC fields
1674 - */
1675 - return 0;
1676 - }
1677 -
1678 - hdrlen = ieee80211_hdrlen(hdr->frame_control);
1679 - len = skb->len - hdrlen;
1680 -
1681 - if (info->control.hw_key)
1682 - tail = 0;
1683 - else
1684 - tail = IEEE80211_GCMP_MIC_LEN;
1685 -
1686 - if (WARN_ON(skb_tailroom(skb) < tail ||
1687 - skb_headroom(skb) < IEEE80211_GCMP_HDR_LEN))
1688 - return -1;
1689 -
1690 - pos = skb_push(skb, IEEE80211_GCMP_HDR_LEN);
1691 - memmove(pos, pos + IEEE80211_GCMP_HDR_LEN, hdrlen);
1692 - skb_set_network_header(skb, skb_network_offset(skb) +
1693 - IEEE80211_GCMP_HDR_LEN);
1694 -
1695 - /* the HW only needs room for the IV, but not the actual IV */
1696 - if (info->control.hw_key &&
1697 - (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE))
1698 - return 0;
1699 -
1700 - hdr = (struct ieee80211_hdr *)pos;
1701 - pos += hdrlen;
1702 -
1703 - pn64 = atomic64_inc_return(&key->u.gcmp.tx_pn);
1704 -
1705 - pn[5] = pn64;
1706 - pn[4] = pn64 >> 8;
1707 - pn[3] = pn64 >> 16;
1708 - pn[2] = pn64 >> 24;
1709 - pn[1] = pn64 >> 32;
1710 - pn[0] = pn64 >> 40;
1711 -
1712 - gcmp_pn2hdr(pos, pn, key->conf.keyidx);
1713 -
1714 - /* hwaccel - with software GCMP header */
1715 - if (info->control.hw_key)
1716 - return 0;
1717 -
1718 - pos += IEEE80211_GCMP_HDR_LEN;
1719 - gcmp_special_blocks(skb, pn, j_0, aad);
1720 - ieee80211_aes_gcm_encrypt(key->u.gcmp.tfm, j_0, aad, pos, len,
1721 - skb_put(skb, IEEE80211_GCMP_MIC_LEN));
1722 -
1723 - return 0;
1724 -}
1725 -
1726 -ieee80211_tx_result
1727 -ieee80211_crypto_gcmp_encrypt(struct ieee80211_tx_data *tx)
1728 -{
1729 - struct sk_buff *skb;
1730 -
1731 - ieee80211_tx_set_protected(tx);
1732 -
1733 - skb_queue_walk(&tx->skbs, skb) {
1734 - if (gcmp_encrypt_skb(tx, skb) < 0)
1735 - return TX_DROP;
1736 - }
1737 -
1738 - return TX_CONTINUE;
1739 -}
1740 -
1741 -ieee80211_rx_result
1742 -ieee80211_crypto_gcmp_decrypt(struct ieee80211_rx_data *rx)
1743 -{
1744 - struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
1745 - int hdrlen;
1746 - struct ieee80211_key *key = rx->key;
1747 - struct sk_buff *skb = rx->skb;
1748 - struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1749 - u8 pn[IEEE80211_GCMP_PN_LEN];
1750 - int data_len;
1751 - int queue;
1752 -
1753 - hdrlen = ieee80211_hdrlen(hdr->frame_control);
1754 -
1755 - if (!ieee80211_is_data(hdr->frame_control) &&
1756 - !ieee80211_is_robust_mgmt_frame(skb))
1757 - return RX_CONTINUE;
1758 -
1759 - data_len = skb->len - hdrlen - IEEE80211_GCMP_HDR_LEN -
1760 - IEEE80211_GCMP_MIC_LEN;
1761 - if (!rx->sta || data_len < 0)
1762 - return RX_DROP_UNUSABLE;
1763 -
1764 - if (status->flag & RX_FLAG_DECRYPTED) {
1765 - if (!pskb_may_pull(rx->skb, hdrlen + IEEE80211_GCMP_HDR_LEN))
1766 - return RX_DROP_UNUSABLE;
1767 - } else {
1768 - if (skb_linearize(rx->skb))
1769 - return RX_DROP_UNUSABLE;
1770 - }
1771 -
1772 - gcmp_hdr2pn(pn, skb->data + hdrlen);
1773 -
1774 - queue = rx->security_idx;
1775 -
1776 - if (memcmp(pn, key->u.gcmp.rx_pn[queue], IEEE80211_GCMP_PN_LEN) <= 0) {
1777 - key->u.gcmp.replays++;
1778 - return RX_DROP_UNUSABLE;
1779 - }
1780 -
1781 - if (!(status->flag & RX_FLAG_DECRYPTED)) {
1782 - u8 aad[2 * AES_BLOCK_SIZE];
1783 - u8 j_0[AES_BLOCK_SIZE];
1784 - /* hardware didn't decrypt/verify MIC */
1785 - gcmp_special_blocks(skb, pn, j_0, aad);
1786 -
1787 - if (ieee80211_aes_gcm_decrypt(
1788 - key->u.gcmp.tfm, j_0, aad,
1789 - skb->data + hdrlen + IEEE80211_GCMP_HDR_LEN,
1790 - data_len,
1791 - skb->data + skb->len - IEEE80211_GCMP_MIC_LEN))
1792 - return RX_DROP_UNUSABLE;
1793 - }
1794 -
1795 - memcpy(key->u.gcmp.rx_pn[queue], pn, IEEE80211_GCMP_PN_LEN);
1796 -
1797 - /* Remove GCMP header and MIC */
1798 - if (pskb_trim(skb, skb->len - IEEE80211_GCMP_MIC_LEN))
1799 - return RX_DROP_UNUSABLE;
1800 - memmove(skb->data + IEEE80211_GCMP_HDR_LEN, skb->data, hdrlen);
1801 - skb_pull(skb, IEEE80211_GCMP_HDR_LEN);
1802 -
1803 - return RX_CONTINUE;
1804 -}
1805 -
1806 static ieee80211_tx_result
1807 ieee80211_crypto_cs_encrypt(struct ieee80211_tx_data *tx,
1808 struct sk_buff *skb)
1809 @@ -956,48 +734,6 @@ ieee80211_crypto_aes_cmac_encrypt(struct
1810 return TX_CONTINUE;
1811 }
1812
1813 -ieee80211_tx_result
1814 -ieee80211_crypto_aes_cmac_256_encrypt(struct ieee80211_tx_data *tx)
1815 -{
1816 - struct sk_buff *skb;
1817 - struct ieee80211_tx_info *info;
1818 - struct ieee80211_key *key = tx->key;
1819 - struct ieee80211_mmie_16 *mmie;
1820 - u8 aad[20];
1821 - u64 pn64;
1822 -
1823 - if (WARN_ON(skb_queue_len(&tx->skbs) != 1))
1824 - return TX_DROP;
1825 -
1826 - skb = skb_peek(&tx->skbs);
1827 -
1828 - info = IEEE80211_SKB_CB(skb);
1829 -
1830 - if (info->control.hw_key)
1831 - return TX_CONTINUE;
1832 -
1833 - if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie)))
1834 - return TX_DROP;
1835 -
1836 - mmie = (struct ieee80211_mmie_16 *)skb_put(skb, sizeof(*mmie));
1837 - mmie->element_id = WLAN_EID_MMIE;
1838 - mmie->length = sizeof(*mmie) - 2;
1839 - mmie->key_id = cpu_to_le16(key->conf.keyidx);
1840 -
1841 - /* PN = PN + 1 */
1842 - pn64 = atomic64_inc_return(&key->u.aes_cmac.tx_pn);
1843 -
1844 - bip_ipn_set64(mmie->sequence_number, pn64);
1845 -
1846 - bip_aad(skb, aad);
1847 -
1848 - /* MIC = AES-256-CMAC(IGTK, AAD || Management Frame Body || MMIE, 128)
1849 - */
1850 - ieee80211_aes_cmac_256(key->u.aes_cmac.tfm, aad,
1851 - skb->data + 24, skb->len - 24, mmie->mic);
1852 -
1853 - return TX_CONTINUE;
1854 -}
1855
1856 ieee80211_rx_result
1857 ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data *rx)
1858 @@ -1045,160 +781,6 @@ ieee80211_crypto_aes_cmac_decrypt(struct
1859
1860 /* Remove MMIE */
1861 skb_trim(skb, skb->len - sizeof(*mmie));
1862 -
1863 - return RX_CONTINUE;
1864 -}
1865 -
1866 -ieee80211_rx_result
1867 -ieee80211_crypto_aes_cmac_256_decrypt(struct ieee80211_rx_data *rx)
1868 -{
1869 - struct sk_buff *skb = rx->skb;
1870 - struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1871 - struct ieee80211_key *key = rx->key;
1872 - struct ieee80211_mmie_16 *mmie;
1873 - u8 aad[20], mic[16], ipn[6];
1874 - struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1875 -
1876 - if (!ieee80211_is_mgmt(hdr->frame_control))
1877 - return RX_CONTINUE;
1878 -
1879 - /* management frames are already linear */
1880 -
1881 - if (skb->len < 24 + sizeof(*mmie))
1882 - return RX_DROP_UNUSABLE;
1883 -
1884 - mmie = (struct ieee80211_mmie_16 *)
1885 - (skb->data + skb->len - sizeof(*mmie));
1886 - if (mmie->element_id != WLAN_EID_MMIE ||
1887 - mmie->length != sizeof(*mmie) - 2)
1888 - return RX_DROP_UNUSABLE; /* Invalid MMIE */
1889 -
1890 - bip_ipn_swap(ipn, mmie->sequence_number);
1891 -
1892 - if (memcmp(ipn, key->u.aes_cmac.rx_pn, 6) <= 0) {
1893 - key->u.aes_cmac.replays++;
1894 - return RX_DROP_UNUSABLE;
1895 - }
1896 -
1897 - if (!(status->flag & RX_FLAG_DECRYPTED)) {
1898 - /* hardware didn't decrypt/verify MIC */
1899 - bip_aad(skb, aad);
1900 - ieee80211_aes_cmac_256(key->u.aes_cmac.tfm, aad,
1901 - skb->data + 24, skb->len - 24, mic);
1902 - if (memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) {
1903 - key->u.aes_cmac.icverrors++;
1904 - return RX_DROP_UNUSABLE;
1905 - }
1906 - }
1907 -
1908 - memcpy(key->u.aes_cmac.rx_pn, ipn, 6);
1909 -
1910 - /* Remove MMIE */
1911 - skb_trim(skb, skb->len - sizeof(*mmie));
1912 -
1913 - return RX_CONTINUE;
1914 -}
1915 -
1916 -ieee80211_tx_result
1917 -ieee80211_crypto_aes_gmac_encrypt(struct ieee80211_tx_data *tx)
1918 -{
1919 - struct sk_buff *skb;
1920 - struct ieee80211_tx_info *info;
1921 - struct ieee80211_key *key = tx->key;
1922 - struct ieee80211_mmie_16 *mmie;
1923 - struct ieee80211_hdr *hdr;
1924 - u8 aad[20];
1925 - u64 pn64;
1926 - u8 nonce[12];
1927 -
1928 - if (WARN_ON(skb_queue_len(&tx->skbs) != 1))
1929 - return TX_DROP;
1930 -
1931 - skb = skb_peek(&tx->skbs);
1932 -
1933 - info = IEEE80211_SKB_CB(skb);
1934 -
1935 - if (info->control.hw_key)
1936 - return TX_CONTINUE;
1937 -
1938 - if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie)))
1939 - return TX_DROP;
1940 -
1941 - mmie = (struct ieee80211_mmie_16 *)skb_put(skb, sizeof(*mmie));
1942 - mmie->element_id = WLAN_EID_MMIE;
1943 - mmie->length = sizeof(*mmie) - 2;
1944 - mmie->key_id = cpu_to_le16(key->conf.keyidx);
1945 -
1946 - /* PN = PN + 1 */
1947 - pn64 = atomic64_inc_return(&key->u.aes_gmac.tx_pn);
1948 -
1949 - bip_ipn_set64(mmie->sequence_number, pn64);
1950 -
1951 - bip_aad(skb, aad);
1952 -
1953 - hdr = (struct ieee80211_hdr *)skb->data;
1954 - memcpy(nonce, hdr->addr2, ETH_ALEN);
1955 - bip_ipn_swap(nonce + ETH_ALEN, mmie->sequence_number);
1956 -
1957 - /* MIC = AES-GMAC(IGTK, AAD || Management Frame Body || MMIE, 128) */
1958 - if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce,
1959 - skb->data + 24, skb->len - 24, mmie->mic) < 0)
1960 - return TX_DROP;
1961 -
1962 - return TX_CONTINUE;
1963 -}
1964 -
1965 -ieee80211_rx_result
1966 -ieee80211_crypto_aes_gmac_decrypt(struct ieee80211_rx_data *rx)
1967 -{
1968 - struct sk_buff *skb = rx->skb;
1969 - struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
1970 - struct ieee80211_key *key = rx->key;
1971 - struct ieee80211_mmie_16 *mmie;
1972 - u8 aad[20], mic[16], ipn[6], nonce[12];
1973 - struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1974 -
1975 - if (!ieee80211_is_mgmt(hdr->frame_control))
1976 - return RX_CONTINUE;
1977 -
1978 - /* management frames are already linear */
1979 -
1980 - if (skb->len < 24 + sizeof(*mmie))
1981 - return RX_DROP_UNUSABLE;
1982 -
1983 - mmie = (struct ieee80211_mmie_16 *)
1984 - (skb->data + skb->len - sizeof(*mmie));
1985 - if (mmie->element_id != WLAN_EID_MMIE ||
1986 - mmie->length != sizeof(*mmie) - 2)
1987 - return RX_DROP_UNUSABLE; /* Invalid MMIE */
1988 -
1989 - bip_ipn_swap(ipn, mmie->sequence_number);
1990 -
1991 - if (memcmp(ipn, key->u.aes_gmac.rx_pn, 6) <= 0) {
1992 - key->u.aes_gmac.replays++;
1993 - return RX_DROP_UNUSABLE;
1994 - }
1995 -
1996 - if (!(status->flag & RX_FLAG_DECRYPTED)) {
1997 - /* hardware didn't decrypt/verify MIC */
1998 - bip_aad(skb, aad);
1999 -
2000 - memcpy(nonce, hdr->addr2, ETH_ALEN);
2001 - memcpy(nonce + ETH_ALEN, ipn, 6);
2002 -
2003 - if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce,
2004 - skb->data + 24, skb->len - 24,
2005 - mic) < 0 ||
2006 - memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) {
2007 - key->u.aes_gmac.icverrors++;
2008 - return RX_DROP_UNUSABLE;
2009 - }
2010 - }
2011 -
2012 - memcpy(key->u.aes_gmac.rx_pn, ipn, 6);
2013 -
2014 - /* Remove MMIE */
2015 - skb_trim(skb, skb->len - sizeof(*mmie));
2016
2017 return RX_CONTINUE;
2018 }
2019 --- a/net/mac80211/wpa.h
2020 +++ b/net/mac80211/wpa.h
2021 @@ -24,32 +24,17 @@ ieee80211_rx_result
2022 ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data *rx);
2023
2024 ieee80211_tx_result
2025 -ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data *tx,
2026 - unsigned int mic_len);
2027 +ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data *tx);
2028 ieee80211_rx_result
2029 -ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx,
2030 - unsigned int mic_len);
2031 +ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx);
2032
2033 ieee80211_tx_result
2034 ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data *tx);
2035 -ieee80211_tx_result
2036 -ieee80211_crypto_aes_cmac_256_encrypt(struct ieee80211_tx_data *tx);
2037 ieee80211_rx_result
2038 ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data *rx);
2039 -ieee80211_rx_result
2040 -ieee80211_crypto_aes_cmac_256_decrypt(struct ieee80211_rx_data *rx);
2041 -ieee80211_tx_result
2042 -ieee80211_crypto_aes_gmac_encrypt(struct ieee80211_tx_data *tx);
2043 -ieee80211_rx_result
2044 -ieee80211_crypto_aes_gmac_decrypt(struct ieee80211_rx_data *rx);
2045 ieee80211_tx_result
2046 ieee80211_crypto_hw_encrypt(struct ieee80211_tx_data *tx);
2047 ieee80211_rx_result
2048 ieee80211_crypto_hw_decrypt(struct ieee80211_rx_data *rx);
2049
2050 -ieee80211_tx_result
2051 -ieee80211_crypto_gcmp_encrypt(struct ieee80211_tx_data *tx);
2052 -ieee80211_rx_result
2053 -ieee80211_crypto_gcmp_decrypt(struct ieee80211_rx_data *rx);
2054 -
2055 #endif /* WPA_H */
Yousong Zhou staging tree