1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
3 *
4 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
5 *
6 ******************************************************************************/
7 #include <linux/crc32.h>
8 #include <drv_types.h>
9 #include <rtw_debug.h>
10 #include <crypto/aes.h>
11
12 static const char * const _security_type_str[] = {
13 "N/A",
14 "WEP40",
15 "TKIP",
16 "TKIP_WM",
17 "AES",
18 "WEP104",
19 "SMS4",
20 "WEP_WPA",
21 "BIP",
22 };
23
security_type_str(u8 value)24 const char *security_type_str(u8 value)
25 {
26 if (value <= _BIP_)
27 return _security_type_str[value];
28 return NULL;
29 }
30
31 /* WEP related ===== */
32
33 /*
34 Need to consider the fragment situation
35 */
rtw_wep_encrypt(struct adapter * padapter,u8 * pxmitframe)36 void rtw_wep_encrypt(struct adapter *padapter, u8 *pxmitframe)
37 { /* exclude ICV */
38 union {
39 __le32 f0;
40 unsigned char f1[4];
41 } crc;
42
43 signed int curfragnum, length;
44 u32 keylength;
45
46 u8 *pframe, *payload, *iv; /* wepkey */
47 u8 wepkey[16];
48 u8 hw_hdr_offset = 0;
49 struct pkt_attrib *pattrib = &((struct xmit_frame *)pxmitframe)->attrib;
50 struct security_priv *psecuritypriv = &padapter->securitypriv;
51 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
52 struct arc4_ctx *ctx = &psecuritypriv->xmit_arc4_ctx;
53
54 if (!((struct xmit_frame *)pxmitframe)->buf_addr)
55 return;
56
57 hw_hdr_offset = TXDESC_OFFSET;
58 pframe = ((struct xmit_frame *)pxmitframe)->buf_addr + hw_hdr_offset;
59
60 /* start to encrypt each fragment */
61 if ((pattrib->encrypt == _WEP40_) || (pattrib->encrypt == _WEP104_)) {
62 keylength = psecuritypriv->dot11DefKeylen[psecuritypriv->dot11PrivacyKeyIndex];
63
64 for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
65 iv = pframe+pattrib->hdrlen;
66 memcpy(&wepkey[0], iv, 3);
67 memcpy(&wepkey[3], &psecuritypriv->dot11DefKey[psecuritypriv->dot11PrivacyKeyIndex].skey[0], keylength);
68 payload = pframe+pattrib->iv_len+pattrib->hdrlen;
69
70 if ((curfragnum+1) == pattrib->nr_frags) { /* the last fragment */
71
72 length = pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
73
74 crc.f0 = cpu_to_le32(~crc32_le(~0, payload, length));
75
76 arc4_setkey(ctx, wepkey, 3 + keylength);
77 arc4_crypt(ctx, payload, payload, length);
78 arc4_crypt(ctx, payload + length, crc.f1, 4);
79
80 } else {
81 length = pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
82 crc.f0 = cpu_to_le32(~crc32_le(~0, payload, length));
83 arc4_setkey(ctx, wepkey, 3 + keylength);
84 arc4_crypt(ctx, payload, payload, length);
85 arc4_crypt(ctx, payload + length, crc.f1, 4);
86
87 pframe += pxmitpriv->frag_len;
88 pframe = (u8 *)round_up((SIZE_PTR)(pframe), 4);
89 }
90 }
91 }
92 }
93
rtw_wep_decrypt(struct adapter * padapter,u8 * precvframe)94 void rtw_wep_decrypt(struct adapter *padapter, u8 *precvframe)
95 {
96 /* exclude ICV */
97 u8 crc[4];
98 signed int length;
99 u32 keylength;
100 u8 *pframe, *payload, *iv, wepkey[16];
101 u8 keyindex;
102 struct rx_pkt_attrib *prxattrib = &(((union recv_frame *)precvframe)->u.hdr.attrib);
103 struct security_priv *psecuritypriv = &padapter->securitypriv;
104 struct arc4_ctx *ctx = &psecuritypriv->recv_arc4_ctx;
105
106 pframe = (unsigned char *)((union recv_frame *)precvframe)->u.hdr.rx_data;
107
108 /* start to decrypt recvframe */
109 if ((prxattrib->encrypt == _WEP40_) || (prxattrib->encrypt == _WEP104_)) {
110 iv = pframe+prxattrib->hdrlen;
111 /* keyindex =(iv[3]&0x3); */
112 keyindex = prxattrib->key_index;
113 keylength = psecuritypriv->dot11DefKeylen[keyindex];
114 memcpy(&wepkey[0], iv, 3);
115 /* memcpy(&wepkey[3], &psecuritypriv->dot11DefKey[psecuritypriv->dot11PrivacyKeyIndex].skey[0], keylength); */
116 memcpy(&wepkey[3], &psecuritypriv->dot11DefKey[keyindex].skey[0], keylength);
117 length = ((union recv_frame *)precvframe)->u.hdr.len-prxattrib->hdrlen-prxattrib->iv_len;
118
119 payload = pframe+prxattrib->iv_len+prxattrib->hdrlen;
120
121 /* decrypt payload include icv */
122 arc4_setkey(ctx, wepkey, 3 + keylength);
123 arc4_crypt(ctx, payload, payload, length);
124
125 /* calculate icv and compare the icv */
126 *((u32 *)crc) = ~crc32_le(~0, payload, length - 4);
127
128 }
129 }
130
131 /* 3 =====TKIP related ===== */
132
secmicgetuint32(u8 * p)133 static u32 secmicgetuint32(u8 *p)
134 /* Convert from Byte[] to Us3232 in a portable way */
135 {
136 s32 i;
137 u32 res = 0;
138
139 for (i = 0; i < 4; i++)
140 res |= ((u32)(*p++)) << (8 * i);
141
142 return res;
143 }
144
secmicputuint32(u8 * p,u32 val)145 static void secmicputuint32(u8 *p, u32 val)
146 /* Convert from Us3232 to Byte[] in a portable way */
147 {
148 long i;
149
150 for (i = 0; i < 4; i++) {
151 *p++ = (u8) (val & 0xff);
152 val >>= 8;
153 }
154 }
155
secmicclear(struct mic_data * pmicdata)156 static void secmicclear(struct mic_data *pmicdata)
157 {
158 /* Reset the state to the empty message. */
159 pmicdata->L = pmicdata->K0;
160 pmicdata->R = pmicdata->K1;
161 pmicdata->nBytesInM = 0;
162 pmicdata->M = 0;
163 }
164
rtw_secmicsetkey(struct mic_data * pmicdata,u8 * key)165 void rtw_secmicsetkey(struct mic_data *pmicdata, u8 *key)
166 {
167 /* Set the key */
168 pmicdata->K0 = secmicgetuint32(key);
169 pmicdata->K1 = secmicgetuint32(key + 4);
170 /* and reset the message */
171 secmicclear(pmicdata);
172 }
173
rtw_secmicappendbyte(struct mic_data * pmicdata,u8 b)174 void rtw_secmicappendbyte(struct mic_data *pmicdata, u8 b)
175 {
176 /* Append the byte to our word-sized buffer */
177 pmicdata->M |= ((unsigned long)b) << (8*pmicdata->nBytesInM);
178 pmicdata->nBytesInM++;
179 /* Process the word if it is full. */
180 if (pmicdata->nBytesInM >= 4) {
181 pmicdata->L ^= pmicdata->M;
182 pmicdata->R ^= ROL32(pmicdata->L, 17);
183 pmicdata->L += pmicdata->R;
184 pmicdata->R ^= ((pmicdata->L & 0xff00ff00) >> 8) | ((pmicdata->L & 0x00ff00ff) << 8);
185 pmicdata->L += pmicdata->R;
186 pmicdata->R ^= ROL32(pmicdata->L, 3);
187 pmicdata->L += pmicdata->R;
188 pmicdata->R ^= ROR32(pmicdata->L, 2);
189 pmicdata->L += pmicdata->R;
190 /* Clear the buffer */
191 pmicdata->M = 0;
192 pmicdata->nBytesInM = 0;
193 }
194 }
195
rtw_secmicappend(struct mic_data * pmicdata,u8 * src,u32 nbytes)196 void rtw_secmicappend(struct mic_data *pmicdata, u8 *src, u32 nbytes)
197 {
198 /* This is simple */
199 while (nbytes > 0) {
200 rtw_secmicappendbyte(pmicdata, *src++);
201 nbytes--;
202 }
203 }
204
rtw_secgetmic(struct mic_data * pmicdata,u8 * dst)205 void rtw_secgetmic(struct mic_data *pmicdata, u8 *dst)
206 {
207 /* Append the minimum padding */
208 rtw_secmicappendbyte(pmicdata, 0x5a);
209 rtw_secmicappendbyte(pmicdata, 0);
210 rtw_secmicappendbyte(pmicdata, 0);
211 rtw_secmicappendbyte(pmicdata, 0);
212 rtw_secmicappendbyte(pmicdata, 0);
213 /* and then zeroes until the length is a multiple of 4 */
214 while (pmicdata->nBytesInM != 0)
215 rtw_secmicappendbyte(pmicdata, 0);
216 /* The appendByte function has already computed the result. */
217 secmicputuint32(dst, pmicdata->L);
218 secmicputuint32(dst + 4, pmicdata->R);
219 /* Reset to the empty message. */
220 secmicclear(pmicdata);
221 }
222
223
rtw_seccalctkipmic(u8 * key,u8 * header,u8 * data,u32 data_len,u8 * mic_code,u8 pri)224 void rtw_seccalctkipmic(u8 *key, u8 *header, u8 *data, u32 data_len, u8 *mic_code, u8 pri)
225 {
226
227 struct mic_data micdata;
228 u8 priority[4] = {0x0, 0x0, 0x0, 0x0};
229
230 rtw_secmicsetkey(&micdata, key);
231 priority[0] = pri;
232
233 /* Michael MIC pseudo header: DA, SA, 3 x 0, Priority */
234 if (header[1] & 1) { /* ToDS == 1 */
235 rtw_secmicappend(&micdata, &header[16], 6); /* DA */
236 if (header[1] & 2) /* From Ds == 1 */
237 rtw_secmicappend(&micdata, &header[24], 6);
238 else
239 rtw_secmicappend(&micdata, &header[10], 6);
240 } else { /* ToDS == 0 */
241 rtw_secmicappend(&micdata, &header[4], 6); /* DA */
242 if (header[1] & 2) /* From Ds == 1 */
243 rtw_secmicappend(&micdata, &header[16], 6);
244 else
245 rtw_secmicappend(&micdata, &header[10], 6);
246 }
247 rtw_secmicappend(&micdata, &priority[0], 4);
248
249
250 rtw_secmicappend(&micdata, data, data_len);
251
252 rtw_secgetmic(&micdata, mic_code);
253 }
254
255 /* macros for extraction/creation of unsigned char/unsigned short values */
256 #define RotR1(v16) ((((v16) >> 1) & 0x7FFF) ^ (((v16) & 1) << 15))
257 #define Lo8(v16) ((u8)((v16) & 0x00FF))
258 #define Hi8(v16) ((u8)(((v16) >> 8) & 0x00FF))
259 #define Lo16(v32) ((u16)((v32) & 0xFFFF))
260 #define Hi16(v32) ((u16)(((v32) >> 16) & 0xFFFF))
261 #define Mk16(hi, lo) ((lo) ^ (((u16)(hi)) << 8))
262
263 /* select the Nth 16-bit word of the temporal key unsigned char array TK[] */
264 #define TK16(N) Mk16(tk[2*(N)+1], tk[2*(N)])
265
266 /* S-box lookup: 16 bits --> 16 bits */
267 #define _S_(v16) (Sbox1[0][Lo8(v16)] ^ Sbox1[1][Hi8(v16)])
268
269 /* fixed algorithm "parameters" */
270 #define PHASE1_LOOP_CNT 8 /* this needs to be "big enough" */
271
272 /* 2-unsigned char by 2-unsigned char subset of the full AES S-box table */
273 static const unsigned short Sbox1[2][256] = { /* Sbox for hash (can be in ROM) */
274 {
275 0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
276 0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
277 0x8F45, 0x1F9D, 0x8940, 0xFA87, 0xEF15, 0xB2EB, 0x8EC9, 0xFB0B,
278 0x41EC, 0xB367, 0x5FFD, 0x45EA, 0x23BF, 0x53F7, 0xE496, 0x9B5B,
279 0x75C2, 0xE11C, 0x3DAE, 0x4C6A, 0x6C5A, 0x7E41, 0xF502, 0x834F,
280 0x685C, 0x51F4, 0xD134, 0xF908, 0xE293, 0xAB73, 0x6253, 0x2A3F,
281 0x080C, 0x9552, 0x4665, 0x9D5E, 0x3028, 0x37A1, 0x0A0F, 0x2FB5,
282 0x0E09, 0x2436, 0x1B9B, 0xDF3D, 0xCD26, 0x4E69, 0x7FCD, 0xEA9F,
283 0x121B, 0x1D9E, 0x5874, 0x342E, 0x362D, 0xDCB2, 0xB4EE, 0x5BFB,
284 0xA4F6, 0x764D, 0xB761, 0x7DCE, 0x527B, 0xDD3E, 0x5E71, 0x1397,
285 0xA6F5, 0xB968, 0x0000, 0xC12C, 0x4060, 0xE31F, 0x79C8, 0xB6ED,
286 0xD4BE, 0x8D46, 0x67D9, 0x724B, 0x94DE, 0x98D4, 0xB0E8, 0x854A,
287 0xBB6B, 0xC52A, 0x4FE5, 0xED16, 0x86C5, 0x9AD7, 0x6655, 0x1194,
288 0x8ACF, 0xE910, 0x0406, 0xFE81, 0xA0F0, 0x7844, 0x25BA, 0x4BE3,
289 0xA2F3, 0x5DFE, 0x80C0, 0x058A, 0x3FAD, 0x21BC, 0x7048, 0xF104,
290 0x63DF, 0x77C1, 0xAF75, 0x4263, 0x2030, 0xE51A, 0xFD0E, 0xBF6D,
291 0x814C, 0x1814, 0x2635, 0xC32F, 0xBEE1, 0x35A2, 0x88CC, 0x2E39,
292 0x9357, 0x55F2, 0xFC82, 0x7A47, 0xC8AC, 0xBAE7, 0x322B, 0xE695,
293 0xC0A0, 0x1998, 0x9ED1, 0xA37F, 0x4466, 0x547E, 0x3BAB, 0x0B83,
294 0x8CCA, 0xC729, 0x6BD3, 0x283C, 0xA779, 0xBCE2, 0x161D, 0xAD76,
295 0xDB3B, 0x6456, 0x744E, 0x141E, 0x92DB, 0x0C0A, 0x486C, 0xB8E4,
296 0x9F5D, 0xBD6E, 0x43EF, 0xC4A6, 0x39A8, 0x31A4, 0xD337, 0xF28B,
297 0xD532, 0x8B43, 0x6E59, 0xDAB7, 0x018C, 0xB164, 0x9CD2, 0x49E0,
298 0xD8B4, 0xACFA, 0xF307, 0xCF25, 0xCAAF, 0xF48E, 0x47E9, 0x1018,
299 0x6FD5, 0xF088, 0x4A6F, 0x5C72, 0x3824, 0x57F1, 0x73C7, 0x9751,
300 0xCB23, 0xA17C, 0xE89C, 0x3E21, 0x96DD, 0x61DC, 0x0D86, 0x0F85,
301 0xE090, 0x7C42, 0x71C4, 0xCCAA, 0x90D8, 0x0605, 0xF701, 0x1C12,
302 0xC2A3, 0x6A5F, 0xAEF9, 0x69D0, 0x1791, 0x9958, 0x3A27, 0x27B9,
303 0xD938, 0xEB13, 0x2BB3, 0x2233, 0xD2BB, 0xA970, 0x0789, 0x33A7,
304 0x2DB6, 0x3C22, 0x1592, 0xC920, 0x8749, 0xAAFF, 0x5078, 0xA57A,
305 0x038F, 0x59F8, 0x0980, 0x1A17, 0x65DA, 0xD731, 0x84C6, 0xD0B8,
306 0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A,
307 },
308
309
310 { /* second half of table is unsigned char-reversed version of first! */
311 0xA5C6, 0x84F8, 0x99EE, 0x8DF6, 0x0DFF, 0xBDD6, 0xB1DE, 0x5491,
312 0x5060, 0x0302, 0xA9CE, 0x7D56, 0x19E7, 0x62B5, 0xE64D, 0x9AEC,
313 0x458F, 0x9D1F, 0x4089, 0x87FA, 0x15EF, 0xEBB2, 0xC98E, 0x0BFB,
314 0xEC41, 0x67B3, 0xFD5F, 0xEA45, 0xBF23, 0xF753, 0x96E4, 0x5B9B,
315 0xC275, 0x1CE1, 0xAE3D, 0x6A4C, 0x5A6C, 0x417E, 0x02F5, 0x4F83,
316 0x5C68, 0xF451, 0x34D1, 0x08F9, 0x93E2, 0x73AB, 0x5362, 0x3F2A,
317 0x0C08, 0x5295, 0x6546, 0x5E9D, 0x2830, 0xA137, 0x0F0A, 0xB52F,
318 0x090E, 0x3624, 0x9B1B, 0x3DDF, 0x26CD, 0x694E, 0xCD7F, 0x9FEA,
319 0x1B12, 0x9E1D, 0x7458, 0x2E34, 0x2D36, 0xB2DC, 0xEEB4, 0xFB5B,
320 0xF6A4, 0x4D76, 0x61B7, 0xCE7D, 0x7B52, 0x3EDD, 0x715E, 0x9713,
321 0xF5A6, 0x68B9, 0x0000, 0x2CC1, 0x6040, 0x1FE3, 0xC879, 0xEDB6,
322 0xBED4, 0x468D, 0xD967, 0x4B72, 0xDE94, 0xD498, 0xE8B0, 0x4A85,
323 0x6BBB, 0x2AC5, 0xE54F, 0x16ED, 0xC586, 0xD79A, 0x5566, 0x9411,
324 0xCF8A, 0x10E9, 0x0604, 0x81FE, 0xF0A0, 0x4478, 0xBA25, 0xE34B,
325 0xF3A2, 0xFE5D, 0xC080, 0x8A05, 0xAD3F, 0xBC21, 0x4870, 0x04F1,
326 0xDF63, 0xC177, 0x75AF, 0x6342, 0x3020, 0x1AE5, 0x0EFD, 0x6DBF,
327 0x4C81, 0x1418, 0x3526, 0x2FC3, 0xE1BE, 0xA235, 0xCC88, 0x392E,
328 0x5793, 0xF255, 0x82FC, 0x477A, 0xACC8, 0xE7BA, 0x2B32, 0x95E6,
329 0xA0C0, 0x9819, 0xD19E, 0x7FA3, 0x6644, 0x7E54, 0xAB3B, 0x830B,
330 0xCA8C, 0x29C7, 0xD36B, 0x3C28, 0x79A7, 0xE2BC, 0x1D16, 0x76AD,
331 0x3BDB, 0x5664, 0x4E74, 0x1E14, 0xDB92, 0x0A0C, 0x6C48, 0xE4B8,
332 0x5D9F, 0x6EBD, 0xEF43, 0xA6C4, 0xA839, 0xA431, 0x37D3, 0x8BF2,
333 0x32D5, 0x438B, 0x596E, 0xB7DA, 0x8C01, 0x64B1, 0xD29C, 0xE049,
334 0xB4D8, 0xFAAC, 0x07F3, 0x25CF, 0xAFCA, 0x8EF4, 0xE947, 0x1810,
335 0xD56F, 0x88F0, 0x6F4A, 0x725C, 0x2438, 0xF157, 0xC773, 0x5197,
336 0x23CB, 0x7CA1, 0x9CE8, 0x213E, 0xDD96, 0xDC61, 0x860D, 0x850F,
337 0x90E0, 0x427C, 0xC471, 0xAACC, 0xD890, 0x0506, 0x01F7, 0x121C,
338 0xA3C2, 0x5F6A, 0xF9AE, 0xD069, 0x9117, 0x5899, 0x273A, 0xB927,
339 0x38D9, 0x13EB, 0xB32B, 0x3322, 0xBBD2, 0x70A9, 0x8907, 0xA733,
340 0xB62D, 0x223C, 0x9215, 0x20C9, 0x4987, 0xFFAA, 0x7850, 0x7AA5,
341 0x8F03, 0xF859, 0x8009, 0x171A, 0xDA65, 0x31D7, 0xC684, 0xB8D0,
342 0xC382, 0xB029, 0x775A, 0x111E, 0xCB7B, 0xFCA8, 0xD66D, 0x3A2C,
343 }
344 };
345
346 /*
347 **********************************************************************
348 * Routine: Phase 1 -- generate P1K, given TA, TK, IV32
349 *
350 * Inputs:
351 * tk[] = temporal key [128 bits]
352 * ta[] = transmitter's MAC address [ 48 bits]
353 * iv32 = upper 32 bits of IV [ 32 bits]
354 * Output:
355 * p1k[] = Phase 1 key [ 80 bits]
356 *
357 * Note:
358 * This function only needs to be called every 2**16 packets,
359 * although in theory it could be called every packet.
360 *
361 **********************************************************************
362 */
phase1(u16 * p1k,const u8 * tk,const u8 * ta,u32 iv32)363 static void phase1(u16 *p1k, const u8 *tk, const u8 *ta, u32 iv32)
364 {
365 signed int i;
366
367 /* Initialize the 80 bits of P1K[] from IV32 and TA[0..5] */
368 p1k[0] = Lo16(iv32);
369 p1k[1] = Hi16(iv32);
370 p1k[2] = Mk16(ta[1], ta[0]); /* use TA[] as little-endian */
371 p1k[3] = Mk16(ta[3], ta[2]);
372 p1k[4] = Mk16(ta[5], ta[4]);
373
374 /* Now compute an unbalanced Feistel cipher with 80-bit block */
375 /* size on the 80-bit block P1K[], using the 128-bit key TK[] */
376 for (i = 0; i < PHASE1_LOOP_CNT; i++) {
377 /* Each add operation here is mod 2**16 */
378 p1k[0] += _S_(p1k[4] ^ TK16((i&1)+0));
379 p1k[1] += _S_(p1k[0] ^ TK16((i&1)+2));
380 p1k[2] += _S_(p1k[1] ^ TK16((i&1)+4));
381 p1k[3] += _S_(p1k[2] ^ TK16((i&1)+6));
382 p1k[4] += _S_(p1k[3] ^ TK16((i&1)+0));
383 p1k[4] += (unsigned short)i; /* avoid "slide attacks" */
384 }
385 }
386
387
388 /*
389 **********************************************************************
390 * Routine: Phase 2 -- generate RC4KEY, given TK, P1K, IV16
391 *
392 * Inputs:
393 * tk[] = Temporal key [128 bits]
394 * p1k[] = Phase 1 output key [ 80 bits]
395 * iv16 = low 16 bits of IV counter [ 16 bits]
396 * Output:
397 * rc4key[] = the key used to encrypt the packet [128 bits]
398 *
399 * Note:
400 * The value {TA, IV32, IV16} for Phase1/Phase2 must be unique
401 * across all packets using the same key TK value. Then, for a
402 * given value of TK[], this TKIP48 construction guarantees that
403 * the final RC4KEY value is unique across all packets.
404 *
405 * Suggested implementation optimization: if PPK[] is "overlaid"
406 * appropriately on RC4KEY[], there is no need for the final
407 * for loop below that copies the PPK[] result into RC4KEY[].
408 *
409 **********************************************************************
410 */
phase2(u8 * rc4key,const u8 * tk,const u16 * p1k,u16 iv16)411 static void phase2(u8 *rc4key, const u8 *tk, const u16 *p1k, u16 iv16)
412 {
413 signed int i;
414 u16 PPK[6]; /* temporary key for mixing */
415
416 /* Note: all adds in the PPK[] equations below are mod 2**16 */
417 for (i = 0; i < 5; i++)
418 PPK[i] = p1k[i]; /* first, copy P1K to PPK */
419
420 PPK[5] = p1k[4]+iv16; /* next, add in IV16 */
421
422 /* Bijective non-linear mixing of the 96 bits of PPK[0..5] */
423 PPK[0] += _S_(PPK[5] ^ TK16(0)); /* Mix key in each "round" */
424 PPK[1] += _S_(PPK[0] ^ TK16(1));
425 PPK[2] += _S_(PPK[1] ^ TK16(2));
426 PPK[3] += _S_(PPK[2] ^ TK16(3));
427 PPK[4] += _S_(PPK[3] ^ TK16(4));
428 PPK[5] += _S_(PPK[4] ^ TK16(5)); /* Total # S-box lookups == 6 */
429
430 /* Final sweep: bijective, "linear". Rotates kill LSB correlations */
431 PPK[0] += RotR1(PPK[5] ^ TK16(6));
432 PPK[1] += RotR1(PPK[0] ^ TK16(7)); /* Use all of TK[] in Phase2 */
433 PPK[2] += RotR1(PPK[1]);
434 PPK[3] += RotR1(PPK[2]);
435 PPK[4] += RotR1(PPK[3]);
436 PPK[5] += RotR1(PPK[4]);
437 /* Note: At this point, for a given key TK[0..15], the 96-bit output */
438 /* value PPK[0..5] is guaranteed to be unique, as a function */
439 /* of the 96-bit "input" value {TA, IV32, IV16}. That is, P1K */
440 /* is now a keyed permutation of {TA, IV32, IV16}. */
441
442 /* Set RC4KEY[0..3], which includes "cleartext" portion of RC4 key */
443 rc4key[0] = Hi8(iv16); /* RC4KEY[0..2] is the WEP IV */
444 rc4key[1] = (Hi8(iv16) | 0x20) & 0x7F; /* Help avoid weak (FMS) keys */
445 rc4key[2] = Lo8(iv16);
446 rc4key[3] = Lo8((PPK[5] ^ TK16(0)) >> 1);
447
448
449 /* Copy 96 bits of PPK[0..5] to RC4KEY[4..15] (little-endian) */
450 for (i = 0; i < 6; i++) {
451 rc4key[4+2*i] = Lo8(PPK[i]);
452 rc4key[5+2*i] = Hi8(PPK[i]);
453 }
454 }
455
456
457 /* The hlen isn't include the IV */
rtw_tkip_encrypt(struct adapter * padapter,u8 * pxmitframe)458 u32 rtw_tkip_encrypt(struct adapter *padapter, u8 *pxmitframe)
459 { /* exclude ICV */
460 u16 pnl;
461 u32 pnh;
462 u8 rc4key[16];
463 u8 ttkey[16];
464 union {
465 __le32 f0;
466 u8 f1[4];
467 } crc;
468 u8 hw_hdr_offset = 0;
469 signed int curfragnum, length;
470
471 u8 *pframe, *payload, *iv, *prwskey;
472 union pn48 dot11txpn;
473 struct pkt_attrib *pattrib = &((struct xmit_frame *)pxmitframe)->attrib;
474 struct security_priv *psecuritypriv = &padapter->securitypriv;
475 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
476 struct arc4_ctx *ctx = &psecuritypriv->xmit_arc4_ctx;
477 u32 res = _SUCCESS;
478
479 if (!((struct xmit_frame *)pxmitframe)->buf_addr)
480 return _FAIL;
481
482 hw_hdr_offset = TXDESC_OFFSET;
483 pframe = ((struct xmit_frame *)pxmitframe)->buf_addr + hw_hdr_offset;
484
485 /* 4 start to encrypt each fragment */
486 if (pattrib->encrypt == _TKIP_) {
487
488 {
489 if (IS_MCAST(pattrib->ra))
490 prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey;
491 else
492 prwskey = pattrib->dot118021x_UncstKey.skey;
493
494 for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
495 iv = pframe+pattrib->hdrlen;
496 payload = pframe+pattrib->iv_len+pattrib->hdrlen;
497
498 GET_TKIP_PN(iv, dot11txpn);
499
500 pnl = (u16)(dot11txpn.val);
501 pnh = (u32)(dot11txpn.val>>16);
502
503 phase1((u16 *)&ttkey[0], prwskey, &pattrib->ta[0], pnh);
504
505 phase2(&rc4key[0], prwskey, (u16 *)&ttkey[0], pnl);
506
507 if ((curfragnum+1) == pattrib->nr_frags) { /* 4 the last fragment */
508 length = pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
509 crc.f0 = cpu_to_le32(~crc32_le(~0, payload, length));
510
511 arc4_setkey(ctx, rc4key, 16);
512 arc4_crypt(ctx, payload, payload, length);
513 arc4_crypt(ctx, payload + length, crc.f1, 4);
514
515 } else {
516 length = pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
517 crc.f0 = cpu_to_le32(~crc32_le(~0, payload, length));
518
519 arc4_setkey(ctx, rc4key, 16);
520 arc4_crypt(ctx, payload, payload, length);
521 arc4_crypt(ctx, payload + length, crc.f1, 4);
522
523 pframe += pxmitpriv->frag_len;
524 pframe = (u8 *)round_up((SIZE_PTR)(pframe), 4);
525 }
526 }
527 }
528 }
529 return res;
530 }
531
532
533 /* The hlen isn't include the IV */
rtw_tkip_decrypt(struct adapter * padapter,u8 * precvframe)534 u32 rtw_tkip_decrypt(struct adapter *padapter, u8 *precvframe)
535 { /* exclude ICV */
536 u16 pnl;
537 u32 pnh;
538 u8 rc4key[16];
539 u8 ttkey[16];
540 u8 crc[4];
541 signed int length;
542
543 u8 *pframe, *payload, *iv, *prwskey;
544 union pn48 dot11txpn;
545 struct sta_info *stainfo;
546 struct rx_pkt_attrib *prxattrib = &((union recv_frame *)precvframe)->u.hdr.attrib;
547 struct security_priv *psecuritypriv = &padapter->securitypriv;
548 struct arc4_ctx *ctx = &psecuritypriv->recv_arc4_ctx;
549 u32 res = _SUCCESS;
550
551 pframe = (unsigned char *)((union recv_frame *)precvframe)->u.hdr.rx_data;
552
553 /* 4 start to decrypt recvframe */
554 if (prxattrib->encrypt == _TKIP_) {
555 stainfo = rtw_get_stainfo(&padapter->stapriv, &prxattrib->ta[0]);
556 if (stainfo) {
557 if (IS_MCAST(prxattrib->ra)) {
558 static unsigned long start;
559 static u32 no_gkey_bc_cnt;
560 static u32 no_gkey_mc_cnt;
561
562 if (!psecuritypriv->binstallGrpkey) {
563 res = _FAIL;
564
565 if (start == 0)
566 start = jiffies;
567
568 if (is_broadcast_mac_addr(prxattrib->ra))
569 no_gkey_bc_cnt++;
570 else
571 no_gkey_mc_cnt++;
572
573 if (jiffies_to_msecs(jiffies - start) > 1000) {
574 if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
575 netdev_dbg(padapter->pnetdev,
576 FUNC_ADPT_FMT " no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
577 FUNC_ADPT_ARG(padapter),
578 no_gkey_bc_cnt,
579 no_gkey_mc_cnt);
580 }
581 start = jiffies;
582 no_gkey_bc_cnt = 0;
583 no_gkey_mc_cnt = 0;
584 }
585 goto exit;
586 }
587
588 if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
589 netdev_dbg(padapter->pnetdev,
590 FUNC_ADPT_FMT " gkey installed. no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
591 FUNC_ADPT_ARG(padapter),
592 no_gkey_bc_cnt,
593 no_gkey_mc_cnt);
594 }
595 start = 0;
596 no_gkey_bc_cnt = 0;
597 no_gkey_mc_cnt = 0;
598
599 prwskey = psecuritypriv->dot118021XGrpKey[prxattrib->key_index].skey;
600 } else {
601 prwskey = &stainfo->dot118021x_UncstKey.skey[0];
602 }
603
604 iv = pframe+prxattrib->hdrlen;
605 payload = pframe+prxattrib->iv_len+prxattrib->hdrlen;
606 length = ((union recv_frame *)precvframe)->u.hdr.len-prxattrib->hdrlen-prxattrib->iv_len;
607
608 GET_TKIP_PN(iv, dot11txpn);
609
610 pnl = (u16)(dot11txpn.val);
611 pnh = (u32)(dot11txpn.val>>16);
612
613 phase1((u16 *)&ttkey[0], prwskey, &prxattrib->ta[0], pnh);
614 phase2(&rc4key[0], prwskey, (unsigned short *)&ttkey[0], pnl);
615
616 /* 4 decrypt payload include icv */
617
618 arc4_setkey(ctx, rc4key, 16);
619 arc4_crypt(ctx, payload, payload, length);
620
621 *((u32 *)crc) = ~crc32_le(~0, payload, length - 4);
622
623 if (crc[3] != payload[length - 1] || crc[2] != payload[length - 2] ||
624 crc[1] != payload[length - 3] || crc[0] != payload[length - 4])
625 res = _FAIL;
626 } else {
627 res = _FAIL;
628 }
629 }
630 exit:
631 return res;
632 }
633
634
635 /* 3 =====AES related ===== */
636
637
638
639 #define MAX_MSG_SIZE 2048
640
641 /*****************************/
642 /**** Function Prototypes ****/
643 /*****************************/
644
645 static void bitwise_xor(u8 *ina, u8 *inb, u8 *out);
646 static void construct_mic_iv(u8 *mic_header1,
647 signed int qc_exists,
648 signed int a4_exists,
649 u8 *mpdu,
650 uint payload_length,
651 u8 *pn_vector,
652 uint frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
653 static void construct_mic_header1(u8 *mic_header1,
654 signed int header_length,
655 u8 *mpdu,
656 uint frtype); /* for CONFIG_IEEE80211W, none 11w also can use */
657 static void construct_mic_header2(u8 *mic_header2,
658 u8 *mpdu,
659 signed int a4_exists,
660 signed int qc_exists);
661 static void construct_ctr_preload(u8 *ctr_preload,
662 signed int a4_exists,
663 signed int qc_exists,
664 u8 *mpdu,
665 u8 *pn_vector,
666 signed int c,
667 uint frtype); /* for CONFIG_IEEE80211W, none 11w also can use */
668
669 static void aes128k128d(u8 *key, u8 *data, u8 *ciphertext);
670
671
672 /****************************************/
673 /* aes128k128d() */
674 /* Performs a 128 bit AES encrypt with */
675 /* 128 bit data. */
676 /****************************************/
aes128k128d(u8 * key,u8 * data,u8 * ciphertext)677 static void aes128k128d(u8 *key, u8 *data, u8 *ciphertext)
678 {
679 struct crypto_aes_ctx ctx;
680
681 aes_expandkey(&ctx, key, 16);
682 aes_encrypt(&ctx, ciphertext, data);
683 memzero_explicit(&ctx, sizeof(ctx));
684 }
685
686 /************************************************/
687 /* construct_mic_iv() */
688 /* Builds the MIC IV from header fields and PN */
689 /* Baron think the function is construct CCM */
690 /* nonce */
691 /************************************************/
construct_mic_iv(u8 * mic_iv,signed int qc_exists,signed int a4_exists,u8 * mpdu,uint payload_length,u8 * pn_vector,uint frtype)692 static void construct_mic_iv(u8 *mic_iv,
693 signed int qc_exists,
694 signed int a4_exists,
695 u8 *mpdu,
696 uint payload_length,
697 u8 *pn_vector,
698 uint frtype) /* add for CONFIG_IEEE80211W, none 11w also can use */
699 {
700 signed int i;
701
702 mic_iv[0] = 0x59;
703
704 if (qc_exists && a4_exists)
705 mic_iv[1] = mpdu[30] & 0x0f; /* QoS_TC */
706
707 if (qc_exists && !a4_exists)
708 mic_iv[1] = mpdu[24] & 0x0f; /* mute bits 7-4 */
709
710 if (!qc_exists)
711 mic_iv[1] = 0x00;
712
713 /* 802.11w management frame should set management bit(4) */
714 if (frtype == WIFI_MGT_TYPE)
715 mic_iv[1] |= BIT(4);
716
717 for (i = 2; i < 8; i++)
718 mic_iv[i] = mpdu[i + 8]; /* mic_iv[2:7] = A2[0:5] = mpdu[10:15] */
719 #ifdef CONSISTENT_PN_ORDER
720 for (i = 8; i < 14; i++)
721 mic_iv[i] = pn_vector[i - 8]; /* mic_iv[8:13] = PN[0:5] */
722 #else
723 for (i = 8; i < 14; i++)
724 mic_iv[i] = pn_vector[13 - i]; /* mic_iv[8:13] = PN[5:0] */
725 #endif
726 mic_iv[14] = (unsigned char) (payload_length / 256);
727 mic_iv[15] = (unsigned char) (payload_length % 256);
728 }
729
730 /************************************************/
731 /* construct_mic_header1() */
732 /* Builds the first MIC header block from */
733 /* header fields. */
734 /* Build AAD SC, A1, A2 */
735 /************************************************/
construct_mic_header1(u8 * mic_header1,signed int header_length,u8 * mpdu,uint frtype)736 static void construct_mic_header1(u8 *mic_header1,
737 signed int header_length,
738 u8 *mpdu,
739 uint frtype) /* for CONFIG_IEEE80211W, none 11w also can use */
740 {
741 mic_header1[0] = (u8)((header_length - 2) / 256);
742 mic_header1[1] = (u8)((header_length - 2) % 256);
743
744 /* 802.11w management frame don't AND subtype bits 4, 5, 6 of frame control field */
745 if (frtype == WIFI_MGT_TYPE)
746 mic_header1[2] = mpdu[0];
747 else
748 mic_header1[2] = mpdu[0] & 0xcf; /* Mute CF poll & CF ack bits */
749
750 mic_header1[3] = mpdu[1] & 0xc7; /* Mute retry, more data and pwr mgt bits */
751 mic_header1[4] = mpdu[4]; /* A1 */
752 mic_header1[5] = mpdu[5];
753 mic_header1[6] = mpdu[6];
754 mic_header1[7] = mpdu[7];
755 mic_header1[8] = mpdu[8];
756 mic_header1[9] = mpdu[9];
757 mic_header1[10] = mpdu[10]; /* A2 */
758 mic_header1[11] = mpdu[11];
759 mic_header1[12] = mpdu[12];
760 mic_header1[13] = mpdu[13];
761 mic_header1[14] = mpdu[14];
762 mic_header1[15] = mpdu[15];
763 }
764
765 /************************************************/
766 /* construct_mic_header2() */
767 /* Builds the last MIC header block from */
768 /* header fields. */
769 /************************************************/
construct_mic_header2(u8 * mic_header2,u8 * mpdu,signed int a4_exists,signed int qc_exists)770 static void construct_mic_header2(u8 *mic_header2,
771 u8 *mpdu,
772 signed int a4_exists,
773 signed int qc_exists)
774 {
775 signed int i;
776
777 for (i = 0; i < 16; i++)
778 mic_header2[i] = 0x00;
779
780 mic_header2[0] = mpdu[16]; /* A3 */
781 mic_header2[1] = mpdu[17];
782 mic_header2[2] = mpdu[18];
783 mic_header2[3] = mpdu[19];
784 mic_header2[4] = mpdu[20];
785 mic_header2[5] = mpdu[21];
786
787 mic_header2[6] = 0x00;
788 mic_header2[7] = 0x00; /* mpdu[23]; */
789
790 if (!qc_exists && a4_exists) {
791 for (i = 0; i < 6; i++)
792 mic_header2[8+i] = mpdu[24+i]; /* A4 */
793 }
794
795 if (qc_exists && !a4_exists) {
796 mic_header2[8] = mpdu[24] & 0x0f; /* mute bits 15 - 4 */
797 mic_header2[9] = mpdu[25] & 0x00;
798 }
799
800 if (qc_exists && a4_exists) {
801 for (i = 0; i < 6; i++)
802 mic_header2[8+i] = mpdu[24+i]; /* A4 */
803
804 mic_header2[14] = mpdu[30] & 0x0f;
805 mic_header2[15] = mpdu[31] & 0x00;
806 }
807 }
808
809 /************************************************/
810 /* construct_mic_header2() */
811 /* Builds the last MIC header block from */
812 /* header fields. */
813 /* Baron think the function is construct CCM */
814 /* nonce */
815 /************************************************/
construct_ctr_preload(u8 * ctr_preload,signed int a4_exists,signed int qc_exists,u8 * mpdu,u8 * pn_vector,signed int c,uint frtype)816 static void construct_ctr_preload(u8 *ctr_preload,
817 signed int a4_exists,
818 signed int qc_exists,
819 u8 *mpdu,
820 u8 *pn_vector,
821 signed int c,
822 uint frtype) /* for CONFIG_IEEE80211W, none 11w also can use */
823 {
824 signed int i = 0;
825
826 for (i = 0; i < 16; i++)
827 ctr_preload[i] = 0x00;
828 i = 0;
829
830 ctr_preload[0] = 0x01; /* flag */
831 if (qc_exists && a4_exists)
832 ctr_preload[1] = mpdu[30] & 0x0f; /* QoC_Control */
833 if (qc_exists && !a4_exists)
834 ctr_preload[1] = mpdu[24] & 0x0f;
835
836 /* 802.11w management frame should set management bit(4) */
837 if (frtype == WIFI_MGT_TYPE)
838 ctr_preload[1] |= BIT(4);
839
840 for (i = 2; i < 8; i++)
841 ctr_preload[i] = mpdu[i + 8]; /* ctr_preload[2:7] = A2[0:5] = mpdu[10:15] */
842 #ifdef CONSISTENT_PN_ORDER
843 for (i = 8; i < 14; i++)
844 ctr_preload[i] = pn_vector[i - 8]; /* ctr_preload[8:13] = PN[0:5] */
845 #else
846 for (i = 8; i < 14; i++)
847 ctr_preload[i] = pn_vector[13 - i]; /* ctr_preload[8:13] = PN[5:0] */
848 #endif
849 ctr_preload[14] = (unsigned char) (c / 256); /* Ctr */
850 ctr_preload[15] = (unsigned char) (c % 256);
851 }
852
853 /************************************/
854 /* bitwise_xor() */
855 /* A 128 bit, bitwise exclusive or */
856 /************************************/
bitwise_xor(u8 * ina,u8 * inb,u8 * out)857 static void bitwise_xor(u8 *ina, u8 *inb, u8 *out)
858 {
859 signed int i;
860
861 for (i = 0; i < 16; i++)
862 out[i] = ina[i] ^ inb[i];
863 }
864
aes_cipher(u8 * key,uint hdrlen,u8 * pframe,uint plen)865 static signed int aes_cipher(u8 *key, uint hdrlen,
866 u8 *pframe, uint plen)
867 {
868 uint qc_exists, a4_exists, i, j, payload_remainder,
869 num_blocks, payload_index;
870
871 u8 pn_vector[6];
872 u8 mic_iv[16];
873 u8 mic_header1[16];
874 u8 mic_header2[16];
875 u8 ctr_preload[16];
876
877 /* Intermediate Buffers */
878 u8 chain_buffer[16];
879 u8 aes_out[16];
880 u8 padded_buffer[16];
881 u8 mic[8];
882 uint frtype = GetFrameType(pframe);
883 uint frsubtype = GetFrameSubType(pframe);
884
885 frsubtype = frsubtype>>4;
886
887 memset((void *)mic_iv, 0, 16);
888 memset((void *)mic_header1, 0, 16);
889 memset((void *)mic_header2, 0, 16);
890 memset((void *)ctr_preload, 0, 16);
891 memset((void *)chain_buffer, 0, 16);
892 memset((void *)aes_out, 0, 16);
893 memset((void *)padded_buffer, 0, 16);
894
895 if ((hdrlen == WLAN_HDR_A3_LEN) || (hdrlen == WLAN_HDR_A3_QOS_LEN))
896 a4_exists = 0;
897 else
898 a4_exists = 1;
899
900 if (((frtype|frsubtype) == WIFI_DATA_CFACK) ||
901 ((frtype|frsubtype) == WIFI_DATA_CFPOLL) ||
902 ((frtype|frsubtype) == WIFI_DATA_CFACKPOLL)) {
903 qc_exists = 1;
904 if (hdrlen != WLAN_HDR_A3_QOS_LEN)
905 hdrlen += 2;
906
907 } else if ((frtype == WIFI_DATA) && /* add for CONFIG_IEEE80211W, none 11w also can use */
908 ((frsubtype == 0x08) ||
909 (frsubtype == 0x09) ||
910 (frsubtype == 0x0a) ||
911 (frsubtype == 0x0b))) {
912 if (hdrlen != WLAN_HDR_A3_QOS_LEN)
913 hdrlen += 2;
914
915 qc_exists = 1;
916 } else {
917 qc_exists = 0;
918 }
919
920 pn_vector[0] = pframe[hdrlen];
921 pn_vector[1] = pframe[hdrlen+1];
922 pn_vector[2] = pframe[hdrlen+4];
923 pn_vector[3] = pframe[hdrlen+5];
924 pn_vector[4] = pframe[hdrlen+6];
925 pn_vector[5] = pframe[hdrlen+7];
926
927 construct_mic_iv(mic_iv,
928 qc_exists,
929 a4_exists,
930 pframe, /* message, */
931 plen,
932 pn_vector,
933 frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
934
935 construct_mic_header1(mic_header1,
936 hdrlen,
937 pframe, /* message */
938 frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
939
940 construct_mic_header2(mic_header2,
941 pframe, /* message, */
942 a4_exists,
943 qc_exists);
944
945 payload_remainder = plen % 16;
946 num_blocks = plen / 16;
947
948 /* Find start of payload */
949 payload_index = (hdrlen + 8);
950
951 /* Calculate MIC */
952 aes128k128d(key, mic_iv, aes_out);
953 bitwise_xor(aes_out, mic_header1, chain_buffer);
954 aes128k128d(key, chain_buffer, aes_out);
955 bitwise_xor(aes_out, mic_header2, chain_buffer);
956 aes128k128d(key, chain_buffer, aes_out);
957
958 for (i = 0; i < num_blocks; i++) {
959 bitwise_xor(aes_out, &pframe[payload_index], chain_buffer);
960
961 payload_index += 16;
962 aes128k128d(key, chain_buffer, aes_out);
963 }
964
965 /* Add on the final payload block if it needs padding */
966 if (payload_remainder > 0) {
967 for (j = 0; j < 16; j++)
968 padded_buffer[j] = 0x00;
969 for (j = 0; j < payload_remainder; j++)
970 padded_buffer[j] = pframe[payload_index++];
971
972 bitwise_xor(aes_out, padded_buffer, chain_buffer);
973 aes128k128d(key, chain_buffer, aes_out);
974 }
975
976 for (j = 0 ; j < 8; j++)
977 mic[j] = aes_out[j];
978
979 /* Insert MIC into payload */
980 for (j = 0; j < 8; j++)
981 pframe[payload_index+j] = mic[j];
982
983 payload_index = hdrlen + 8;
984 for (i = 0; i < num_blocks; i++) {
985 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, pframe, /* message, */
986 pn_vector, i+1, frtype);
987 /* add for CONFIG_IEEE80211W, none 11w also can use */
988 aes128k128d(key, ctr_preload, aes_out);
989 bitwise_xor(aes_out, &pframe[payload_index], chain_buffer);
990 for (j = 0; j < 16; j++)
991 pframe[payload_index++] = chain_buffer[j];
992 }
993
994 if (payload_remainder > 0) {
995 /* If there is a short final block, then pad it,*/
996 /* encrypt it and copy the unpadded part back */
997 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, pframe, /* message, */
998 pn_vector, num_blocks+1, frtype);
999 /* add for CONFIG_IEEE80211W, none 11w also can use */
1000
1001 for (j = 0; j < 16; j++)
1002 padded_buffer[j] = 0x00;
1003 for (j = 0; j < payload_remainder; j++)
1004 padded_buffer[j] = pframe[payload_index+j];
1005
1006 aes128k128d(key, ctr_preload, aes_out);
1007 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1008 for (j = 0; j < payload_remainder; j++)
1009 pframe[payload_index++] = chain_buffer[j];
1010 }
1011
1012 /* Encrypt the MIC */
1013 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, pframe, /* message, */
1014 pn_vector, 0, frtype);
1015 /* add for CONFIG_IEEE80211W, none 11w also can use */
1016
1017 for (j = 0; j < 16; j++)
1018 padded_buffer[j] = 0x00;
1019 for (j = 0; j < 8; j++)
1020 padded_buffer[j] = pframe[j+hdrlen+8+plen];
1021
1022 aes128k128d(key, ctr_preload, aes_out);
1023 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1024 for (j = 0; j < 8; j++)
1025 pframe[payload_index++] = chain_buffer[j];
1026
1027 return _SUCCESS;
1028 }
1029
rtw_aes_encrypt(struct adapter * padapter,u8 * pxmitframe)1030 u32 rtw_aes_encrypt(struct adapter *padapter, u8 *pxmitframe)
1031 { /* exclude ICV */
1032
1033 /*static*/
1034 /* unsigned char message[MAX_MSG_SIZE]; */
1035
1036 /* Intermediate Buffers */
1037 signed int curfragnum, length;
1038 u8 *pframe, *prwskey; /* *payload,*iv */
1039 u8 hw_hdr_offset = 0;
1040 struct pkt_attrib *pattrib = &((struct xmit_frame *)pxmitframe)->attrib;
1041 struct security_priv *psecuritypriv = &padapter->securitypriv;
1042 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1043
1044 u32 res = _SUCCESS;
1045
1046 if (!((struct xmit_frame *)pxmitframe)->buf_addr)
1047 return _FAIL;
1048
1049 hw_hdr_offset = TXDESC_OFFSET;
1050 pframe = ((struct xmit_frame *)pxmitframe)->buf_addr + hw_hdr_offset;
1051
1052 /* 4 start to encrypt each fragment */
1053 if (pattrib->encrypt == _AES_) {
1054 if (IS_MCAST(pattrib->ra))
1055 prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey;
1056 else
1057 prwskey = pattrib->dot118021x_UncstKey.skey;
1058
1059 for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
1060 if ((curfragnum+1) == pattrib->nr_frags) { /* 4 the last fragment */
1061 length = pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
1062
1063 aes_cipher(prwskey, pattrib->hdrlen, pframe, length);
1064 } else {
1065 length = pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
1066
1067 aes_cipher(prwskey, pattrib->hdrlen, pframe, length);
1068 pframe += pxmitpriv->frag_len;
1069 pframe = (u8 *)round_up((SIZE_PTR)(pframe), 4);
1070 }
1071 }
1072 }
1073 return res;
1074 }
1075
aes_decipher(u8 * key,uint hdrlen,u8 * pframe,uint plen)1076 static signed int aes_decipher(u8 *key, uint hdrlen,
1077 u8 *pframe, uint plen)
1078 {
1079 static u8 message[MAX_MSG_SIZE];
1080 uint qc_exists, a4_exists, i, j, payload_remainder,
1081 num_blocks, payload_index;
1082 signed int res = _SUCCESS;
1083 u8 pn_vector[6];
1084 u8 mic_iv[16];
1085 u8 mic_header1[16];
1086 u8 mic_header2[16];
1087 u8 ctr_preload[16];
1088
1089 /* Intermediate Buffers */
1090 u8 chain_buffer[16];
1091 u8 aes_out[16];
1092 u8 padded_buffer[16];
1093 u8 mic[8];
1094
1095 uint frtype = GetFrameType(pframe);
1096 uint frsubtype = GetFrameSubType(pframe);
1097
1098 frsubtype = frsubtype>>4;
1099
1100 memset((void *)mic_iv, 0, 16);
1101 memset((void *)mic_header1, 0, 16);
1102 memset((void *)mic_header2, 0, 16);
1103 memset((void *)ctr_preload, 0, 16);
1104 memset((void *)chain_buffer, 0, 16);
1105 memset((void *)aes_out, 0, 16);
1106 memset((void *)padded_buffer, 0, 16);
1107
1108 /* start to decrypt the payload */
1109
1110 num_blocks = (plen-8) / 16; /* plen including LLC, payload_length and mic) */
1111
1112 payload_remainder = (plen-8) % 16;
1113
1114 pn_vector[0] = pframe[hdrlen];
1115 pn_vector[1] = pframe[hdrlen + 1];
1116 pn_vector[2] = pframe[hdrlen + 4];
1117 pn_vector[3] = pframe[hdrlen + 5];
1118 pn_vector[4] = pframe[hdrlen + 6];
1119 pn_vector[5] = pframe[hdrlen + 7];
1120
1121 if ((hdrlen == WLAN_HDR_A3_LEN) || (hdrlen == WLAN_HDR_A3_QOS_LEN))
1122 a4_exists = 0;
1123 else
1124 a4_exists = 1;
1125
1126 if (((frtype|frsubtype) == WIFI_DATA_CFACK) ||
1127 ((frtype|frsubtype) == WIFI_DATA_CFPOLL) ||
1128 ((frtype|frsubtype) == WIFI_DATA_CFACKPOLL)) {
1129 qc_exists = 1;
1130 if (hdrlen != WLAN_HDR_A3_QOS_LEN)
1131 hdrlen += 2;
1132
1133 } else if ((frtype == WIFI_DATA) && /* only for data packet . add for CONFIG_IEEE80211W, none 11w also can use */
1134 ((frsubtype == 0x08) ||
1135 (frsubtype == 0x09) ||
1136 (frsubtype == 0x0a) ||
1137 (frsubtype == 0x0b))) {
1138 if (hdrlen != WLAN_HDR_A3_QOS_LEN)
1139 hdrlen += 2;
1140
1141 qc_exists = 1;
1142 } else {
1143 qc_exists = 0;
1144 }
1145
1146 /* now, decrypt pframe with hdrlen offset and plen long */
1147
1148 payload_index = hdrlen + 8; /* 8 is for extiv */
1149
1150 for (i = 0; i < num_blocks; i++) {
1151 construct_ctr_preload(ctr_preload, a4_exists,
1152 qc_exists, pframe,
1153 pn_vector, i + 1,
1154 frtype); /* add for CONFIG_IEEE80211W, none 11w also can use */
1155
1156 aes128k128d(key, ctr_preload, aes_out);
1157 bitwise_xor(aes_out, &pframe[payload_index], chain_buffer);
1158
1159 for (j = 0; j < 16; j++)
1160 pframe[payload_index++] = chain_buffer[j];
1161 }
1162
1163 if (payload_remainder > 0) {
1164 /* If there is a short final block, then pad it,*/
1165 /* encrypt it and copy the unpadded part back */
1166 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, pframe, pn_vector,
1167 num_blocks+1, frtype);
1168 /* add for CONFIG_IEEE80211W, none 11w also can use */
1169
1170 for (j = 0; j < 16; j++)
1171 padded_buffer[j] = 0x00;
1172 for (j = 0; j < payload_remainder; j++)
1173 padded_buffer[j] = pframe[payload_index+j];
1174
1175 aes128k128d(key, ctr_preload, aes_out);
1176 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1177 for (j = 0; j < payload_remainder; j++)
1178 pframe[payload_index++] = chain_buffer[j];
1179 }
1180
1181 /* start to calculate the mic */
1182 if ((hdrlen + plen+8) <= MAX_MSG_SIZE)
1183 memcpy((void *)message, pframe, (hdrlen + plen+8)); /* 8 is for ext iv len */
1184
1185 pn_vector[0] = pframe[hdrlen];
1186 pn_vector[1] = pframe[hdrlen+1];
1187 pn_vector[2] = pframe[hdrlen+4];
1188 pn_vector[3] = pframe[hdrlen+5];
1189 pn_vector[4] = pframe[hdrlen+6];
1190 pn_vector[5] = pframe[hdrlen+7];
1191
1192 construct_mic_iv(mic_iv, qc_exists, a4_exists, message, plen-8, pn_vector, frtype);
1193 /* add for CONFIG_IEEE80211W, none 11w also can use */
1194
1195 construct_mic_header1(mic_header1, hdrlen, message, frtype);
1196 /* add for CONFIG_IEEE80211W, none 11w also can use */
1197 construct_mic_header2(mic_header2, message, a4_exists, qc_exists);
1198
1199 payload_remainder = (plen-8) % 16;
1200 num_blocks = (plen-8) / 16;
1201
1202 /* Find start of payload */
1203 payload_index = (hdrlen + 8);
1204
1205 /* Calculate MIC */
1206 aes128k128d(key, mic_iv, aes_out);
1207 bitwise_xor(aes_out, mic_header1, chain_buffer);
1208 aes128k128d(key, chain_buffer, aes_out);
1209 bitwise_xor(aes_out, mic_header2, chain_buffer);
1210 aes128k128d(key, chain_buffer, aes_out);
1211
1212 for (i = 0; i < num_blocks; i++) {
1213 bitwise_xor(aes_out, &message[payload_index], chain_buffer);
1214
1215 payload_index += 16;
1216 aes128k128d(key, chain_buffer, aes_out);
1217 }
1218
1219 /* Add on the final payload block if it needs padding */
1220 if (payload_remainder > 0) {
1221 for (j = 0; j < 16; j++)
1222 padded_buffer[j] = 0x00;
1223 for (j = 0; j < payload_remainder; j++)
1224 padded_buffer[j] = message[payload_index++];
1225
1226 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1227 aes128k128d(key, chain_buffer, aes_out);
1228 }
1229
1230 for (j = 0; j < 8; j++)
1231 mic[j] = aes_out[j];
1232
1233 /* Insert MIC into payload */
1234 for (j = 0; j < 8; j++)
1235 message[payload_index+j] = mic[j];
1236
1237 payload_index = hdrlen + 8;
1238 for (i = 0; i < num_blocks; i++) {
1239 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, message, pn_vector, i+1,
1240 frtype);
1241 /* add for CONFIG_IEEE80211W, none 11w also can use */
1242 aes128k128d(key, ctr_preload, aes_out);
1243 bitwise_xor(aes_out, &message[payload_index], chain_buffer);
1244 for (j = 0; j < 16; j++)
1245 message[payload_index++] = chain_buffer[j];
1246 }
1247
1248 if (payload_remainder > 0) {
1249 /* If there is a short final block, then pad it,*/
1250 /* encrypt it and copy the unpadded part back */
1251 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, message, pn_vector,
1252 num_blocks+1, frtype);
1253 /* add for CONFIG_IEEE80211W, none 11w also can use */
1254
1255 for (j = 0; j < 16; j++)
1256 padded_buffer[j] = 0x00;
1257 for (j = 0; j < payload_remainder; j++)
1258 padded_buffer[j] = message[payload_index+j];
1259
1260 aes128k128d(key, ctr_preload, aes_out);
1261 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1262 for (j = 0; j < payload_remainder; j++)
1263 message[payload_index++] = chain_buffer[j];
1264 }
1265
1266 /* Encrypt the MIC */
1267 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, message, pn_vector, 0, frtype);
1268 /* add for CONFIG_IEEE80211W, none 11w also can use */
1269
1270 for (j = 0; j < 16; j++)
1271 padded_buffer[j] = 0x00;
1272 for (j = 0; j < 8; j++)
1273 padded_buffer[j] = message[j+hdrlen+8+plen-8];
1274
1275 aes128k128d(key, ctr_preload, aes_out);
1276 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1277 for (j = 0; j < 8; j++)
1278 message[payload_index++] = chain_buffer[j];
1279
1280 /* compare the mic */
1281 for (i = 0; i < 8; i++) {
1282 if (pframe[hdrlen + 8 + plen - 8 + i] != message[hdrlen + 8 + plen - 8 + i])
1283 res = _FAIL;
1284 }
1285 return res;
1286 }
1287
rtw_aes_decrypt(struct adapter * padapter,u8 * precvframe)1288 u32 rtw_aes_decrypt(struct adapter *padapter, u8 *precvframe)
1289 { /* exclude ICV */
1290
1291 /*static*/
1292 /* unsigned char message[MAX_MSG_SIZE]; */
1293
1294 /* Intermediate Buffers */
1295
1296 signed int length;
1297 u8 *pframe, *prwskey; /* *payload,*iv */
1298 struct sta_info *stainfo;
1299 struct rx_pkt_attrib *prxattrib = &((union recv_frame *)precvframe)->u.hdr.attrib;
1300 struct security_priv *psecuritypriv = &padapter->securitypriv;
1301 u32 res = _SUCCESS;
1302
1303 pframe = (unsigned char *)((union recv_frame *)precvframe)->u.hdr.rx_data;
1304 /* 4 start to encrypt each fragment */
1305 if (prxattrib->encrypt == _AES_) {
1306 stainfo = rtw_get_stainfo(&padapter->stapriv, &prxattrib->ta[0]);
1307 if (stainfo) {
1308 if (IS_MCAST(prxattrib->ra)) {
1309 static unsigned long start;
1310 static u32 no_gkey_bc_cnt;
1311 static u32 no_gkey_mc_cnt;
1312
1313 if (!psecuritypriv->binstallGrpkey) {
1314 res = _FAIL;
1315
1316 if (start == 0)
1317 start = jiffies;
1318
1319 if (is_broadcast_mac_addr(prxattrib->ra))
1320 no_gkey_bc_cnt++;
1321 else
1322 no_gkey_mc_cnt++;
1323
1324 if (jiffies_to_msecs(jiffies - start) > 1000) {
1325 if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
1326 netdev_dbg(padapter->pnetdev,
1327 FUNC_ADPT_FMT " no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
1328 FUNC_ADPT_ARG(padapter),
1329 no_gkey_bc_cnt,
1330 no_gkey_mc_cnt);
1331 }
1332 start = jiffies;
1333 no_gkey_bc_cnt = 0;
1334 no_gkey_mc_cnt = 0;
1335 }
1336
1337 goto exit;
1338 }
1339
1340 if (no_gkey_bc_cnt || no_gkey_mc_cnt) {
1341 netdev_dbg(padapter->pnetdev,
1342 FUNC_ADPT_FMT " gkey installed. no_gkey_bc_cnt:%u, no_gkey_mc_cnt:%u\n",
1343 FUNC_ADPT_ARG(padapter),
1344 no_gkey_bc_cnt,
1345 no_gkey_mc_cnt);
1346 }
1347 start = 0;
1348 no_gkey_bc_cnt = 0;
1349 no_gkey_mc_cnt = 0;
1350
1351 prwskey = psecuritypriv->dot118021XGrpKey[prxattrib->key_index].skey;
1352 if (psecuritypriv->dot118021XGrpKeyid != prxattrib->key_index) {
1353 res = _FAIL;
1354 goto exit;
1355 }
1356 } else {
1357 prwskey = &stainfo->dot118021x_UncstKey.skey[0];
1358 }
1359
1360 length = ((union recv_frame *)precvframe)->u.hdr.len-prxattrib->hdrlen-prxattrib->iv_len;
1361
1362 res = aes_decipher(prwskey, prxattrib->hdrlen, pframe, length);
1363
1364 } else {
1365 res = _FAIL;
1366 }
1367 }
1368 exit:
1369 return res;
1370 }
1371
rtw_BIP_verify(struct adapter * padapter,u8 * precvframe)1372 u32 rtw_BIP_verify(struct adapter *padapter, u8 *precvframe)
1373 {
1374 struct rx_pkt_attrib *pattrib = &((union recv_frame *)precvframe)->u.hdr.attrib;
1375 u8 *pframe;
1376 u8 *BIP_AAD, *p;
1377 u32 res = _FAIL;
1378 uint len, ori_len;
1379 struct ieee80211_hdr *pwlanhdr;
1380 u8 mic[16];
1381 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1382 __le16 le_tmp;
1383 __le64 le_tmp64;
1384
1385 ori_len = pattrib->pkt_len-WLAN_HDR_A3_LEN+BIP_AAD_SIZE;
1386 BIP_AAD = rtw_zmalloc(ori_len);
1387
1388 if (!BIP_AAD)
1389 return _FAIL;
1390
1391 /* PKT start */
1392 pframe = (unsigned char *)((union recv_frame *)precvframe)->u.hdr.rx_data;
1393 /* mapping to wlan header */
1394 pwlanhdr = (struct ieee80211_hdr *)pframe;
1395 /* save the frame body + MME */
1396 memcpy(BIP_AAD+BIP_AAD_SIZE, pframe+WLAN_HDR_A3_LEN, pattrib->pkt_len-WLAN_HDR_A3_LEN);
1397 /* find MME IE pointer */
1398 p = rtw_get_ie(BIP_AAD+BIP_AAD_SIZE, WLAN_EID_MMIE, &len, pattrib->pkt_len-WLAN_HDR_A3_LEN);
1399 /* Baron */
1400 if (p) {
1401 u16 keyid = 0;
1402 u64 temp_ipn = 0;
1403 /* save packet number */
1404 memcpy(&le_tmp64, p+4, 6);
1405 temp_ipn = le64_to_cpu(le_tmp64);
1406 /* BIP packet number should bigger than previous BIP packet */
1407 if (temp_ipn <= pmlmeext->mgnt_80211w_IPN_rx)
1408 goto BIP_exit;
1409
1410 /* copy key index */
1411 memcpy(&le_tmp, p+2, 2);
1412 keyid = le16_to_cpu(le_tmp);
1413 if (keyid != padapter->securitypriv.dot11wBIPKeyid)
1414 goto BIP_exit;
1415
1416 /* clear the MIC field of MME to zero */
1417 memset(p+2+len-8, 0, 8);
1418
1419 /* conscruct AAD, copy frame control field */
1420 memcpy(BIP_AAD, &pwlanhdr->frame_control, 2);
1421 ClearRetry(BIP_AAD);
1422 ClearPwrMgt(BIP_AAD);
1423 ClearMData(BIP_AAD);
1424 /* conscruct AAD, copy address 1 to address 3 */
1425 memcpy(BIP_AAD+2, pwlanhdr->addr1, 18);
1426
1427 if (omac1_aes_128(padapter->securitypriv.dot11wBIPKey[padapter->securitypriv.dot11wBIPKeyid].skey
1428 , BIP_AAD, ori_len, mic))
1429 goto BIP_exit;
1430
1431 /* MIC field should be last 8 bytes of packet (packet without FCS) */
1432 if (!memcmp(mic, pframe+pattrib->pkt_len-8, 8)) {
1433 pmlmeext->mgnt_80211w_IPN_rx = temp_ipn;
1434 res = _SUCCESS;
1435 } else {
1436 }
1437
1438 } else {
1439 res = RTW_RX_HANDLED;
1440 }
1441 BIP_exit:
1442
1443 kfree(BIP_AAD);
1444 return res;
1445 }
1446
gf_mulx(u8 * pad)1447 static void gf_mulx(u8 *pad)
1448 {
1449 int i, carry;
1450
1451 carry = pad[0] & 0x80;
1452 for (i = 0; i < AES_BLOCK_SIZE - 1; i++)
1453 pad[i] = (pad[i] << 1) | (pad[i + 1] >> 7);
1454
1455 pad[AES_BLOCK_SIZE - 1] <<= 1;
1456 if (carry)
1457 pad[AES_BLOCK_SIZE - 1] ^= 0x87;
1458 }
1459
1460 /**
1461 * omac1_aes_128_vector - One-Key CBC MAC (OMAC1) hash with AES-128
1462 * @key: 128-bit key for the hash operation
1463 * @num_elem: Number of elements in the data vector
1464 * @addr: Pointers to the data areas
1465 * @len: Lengths of the data blocks
1466 * @mac: Buffer for MAC (128 bits, i.e., 16 bytes)
1467 * Returns: 0 on success, -1 on failure
1468 *
1469 * This is a mode for using block cipher (AES in this case) for authentication.
1470 * OMAC1 was standardized with the name CMAC by NIST in a Special Publication
1471 * (SP) 800-38B.
1472 */
omac1_aes_128_vector(u8 * key,size_t num_elem,u8 * addr[],size_t * len,u8 * mac)1473 static int omac1_aes_128_vector(u8 *key, size_t num_elem,
1474 u8 *addr[], size_t *len, u8 *mac)
1475 {
1476 struct crypto_aes_ctx ctx;
1477 u8 cbc[AES_BLOCK_SIZE], pad[AES_BLOCK_SIZE];
1478 u8 *pos, *end;
1479 size_t i, e, left, total_len;
1480 int ret;
1481
1482 ret = aes_expandkey(&ctx, key, 16);
1483 if (ret)
1484 return -1;
1485 memset(cbc, 0, AES_BLOCK_SIZE);
1486
1487 total_len = 0;
1488 for (e = 0; e < num_elem; e++)
1489 total_len += len[e];
1490 left = total_len;
1491
1492 e = 0;
1493 pos = addr[0];
1494 end = pos + len[0];
1495
1496 while (left >= AES_BLOCK_SIZE) {
1497 for (i = 0; i < AES_BLOCK_SIZE; i++) {
1498 cbc[i] ^= *pos++;
1499 if (pos >= end) {
1500 e++;
1501 pos = addr[e];
1502 end = pos + len[e];
1503 }
1504 }
1505 if (left > AES_BLOCK_SIZE)
1506 aes_encrypt(&ctx, cbc, cbc);
1507 left -= AES_BLOCK_SIZE;
1508 }
1509
1510 memset(pad, 0, AES_BLOCK_SIZE);
1511 aes_encrypt(&ctx, pad, pad);
1512 gf_mulx(pad);
1513
1514 if (left || total_len == 0) {
1515 for (i = 0; i < left; i++) {
1516 cbc[i] ^= *pos++;
1517 if (pos >= end) {
1518 e++;
1519 pos = addr[e];
1520 end = pos + len[e];
1521 }
1522 }
1523 cbc[left] ^= 0x80;
1524 gf_mulx(pad);
1525 }
1526
1527 for (i = 0; i < AES_BLOCK_SIZE; i++)
1528 pad[i] ^= cbc[i];
1529 aes_encrypt(&ctx, pad, mac);
1530 memzero_explicit(&ctx, sizeof(ctx));
1531 return 0;
1532 }
1533
1534 /**
1535 * omac1_aes_128 - One-Key CBC MAC (OMAC1) hash with AES-128 (aka AES-CMAC)
1536 * @key: 128-bit key for the hash operation
1537 * @data: Data buffer for which a MAC is determined
1538 * @data_len: Length of data buffer in bytes
1539 * @mac: Buffer for MAC (128 bits, i.e., 16 bytes)
1540 * Returns: 0 on success, -1 on failure
1541 *
1542 * This is a mode for using block cipher (AES in this case) for authentication.
1543 * OMAC1 was standardized with the name CMAC by NIST in a Special Publication
1544 * (SP) 800-38B.
1545 * modify for CONFIG_IEEE80211W */
omac1_aes_128(u8 * key,u8 * data,size_t data_len,u8 * mac)1546 int omac1_aes_128(u8 *key, u8 *data, size_t data_len, u8 *mac)
1547 {
1548 return omac1_aes_128_vector(key, 1, &data, &data_len, mac);
1549 }
1550
1551 /* Restore HW wep key setting according to key_mask */
rtw_sec_restore_wep_key(struct adapter * adapter)1552 void rtw_sec_restore_wep_key(struct adapter *adapter)
1553 {
1554 struct security_priv *securitypriv = &(adapter->securitypriv);
1555 signed int keyid;
1556
1557 if ((_WEP40_ == securitypriv->dot11PrivacyAlgrthm) || (_WEP104_ == securitypriv->dot11PrivacyAlgrthm)) {
1558 for (keyid = 0; keyid < 4; keyid++) {
1559 if (securitypriv->key_mask & BIT(keyid)) {
1560 if (keyid == securitypriv->dot11PrivacyKeyIndex)
1561 rtw_set_key(adapter, securitypriv, keyid, 1, false);
1562 else
1563 rtw_set_key(adapter, securitypriv, keyid, 0, false);
1564 }
1565 }
1566 }
1567 }
1568
rtw_handle_tkip_countermeasure(struct adapter * adapter,const char * caller)1569 u8 rtw_handle_tkip_countermeasure(struct adapter *adapter, const char *caller)
1570 {
1571 struct security_priv *securitypriv = &(adapter->securitypriv);
1572 u8 status = _SUCCESS;
1573
1574 if (securitypriv->btkip_countermeasure) {
1575 unsigned long passing_ms = jiffies_to_msecs(jiffies - securitypriv->btkip_countermeasure_time);
1576
1577 if (passing_ms > 60*1000) {
1578 netdev_dbg(adapter->pnetdev,
1579 "%s(%s) countermeasure time:%lus > 60s\n",
1580 caller, ADPT_ARG(adapter),
1581 passing_ms / 1000);
1582 securitypriv->btkip_countermeasure = false;
1583 securitypriv->btkip_countermeasure_time = 0;
1584 } else {
1585 netdev_dbg(adapter->pnetdev,
1586 "%s(%s) countermeasure time:%lus < 60s\n",
1587 caller, ADPT_ARG(adapter),
1588 passing_ms / 1000);
1589 status = _FAIL;
1590 }
1591 }
1592
1593 return status;
1594 }
1595