1 /******************************************************************************
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 ******************************************************************************/
20 #define _RTW_SECURITY_C_
22 #include <osdep_service.h>
23 #include <drv_types.h>
25 #include <osdep_intf.h>
27 /* WEP related ===== */
29 #define CRC32_POLY 0x04c11db7
37 static void arcfour_init(struct arc4context *parc4ctx, u8 *key, u32 key_len)
44 state = parc4ctx->state;
47 for (counter = 0; counter < 256; counter++)
48 state[counter] = (u8)counter;
51 for (counter = 0; counter < 256; counter++) {
53 stateindex = (stateindex + key[keyindex] + t) & 0xff;
54 u = state[stateindex];
55 state[stateindex] = (u8)t;
56 state[counter] = (u8)u;
57 if (++keyindex >= key_len)
62 static u32 arcfour_byte(struct arc4context *parc4ctx)
68 state = parc4ctx->state;
69 x = (parc4ctx->x + 1) & 0xff;
71 y = (sx + parc4ctx->y) & 0xff;
77 return state[(sx + sy) & 0xff];
80 static void arcfour_encrypt(struct arc4context *parc4ctx, u8 *dest, u8 *src, u32 len)
83 for (i = 0; i < len; i++)
84 dest[i] = src[i] ^ (unsigned char)arcfour_byte(parc4ctx);
87 static int bcrc32initialized;
88 static u32 crc32_table[256];
90 static u8 crc32_reverseBit(u8 data)
92 return (u8)((data<<7)&0x80) | ((data<<5)&0x40) | ((data<<3)&0x20) |
93 ((data<<1)&0x10) | ((data>>1)&0x08) | ((data>>3)&0x04) |
94 ((data>>5)&0x02) | ((data>>7)&0x01);
97 static void crc32_init(void)
99 if (bcrc32initialized == 1) {
104 u8 *p = (u8 *)&c, *p1;
109 for (i = 0; i < 256; ++i) {
110 k = crc32_reverseBit((u8)i);
111 for (c = ((u32)k) << 24, j = 8; j > 0; --j)
112 c = c & 0x80000000 ? (c << 1) ^ CRC32_POLY : (c << 1);
113 p1 = (u8 *)&crc32_table[i];
115 p1[0] = crc32_reverseBit(p[3]);
116 p1[1] = crc32_reverseBit(p[2]);
117 p1[2] = crc32_reverseBit(p[1]);
118 p1[3] = crc32_reverseBit(p[0]);
120 bcrc32initialized = 1;
124 static __le32 getcrc32(u8 *buf, int len)
128 if (bcrc32initialized == 0)
131 crc = 0xffffffff; /* preload shift register, per CRC-32 spec */
133 for (p = buf; len > 0; ++p, --len)
134 crc = crc32_table[(crc ^ *p) & 0xff] ^ (crc >> 8);
135 return cpu_to_le32(~crc); /* transmit complement, per CRC-32 spec */
139 Need to consider the fragment situation
141 void rtw_wep_encrypt(struct adapter *padapter, u8 *pxmitframe)
144 unsigned char crc[4];
145 struct arc4context mycontext;
147 int curfragnum, length;
150 u8 *pframe, *payload, *iv; /* wepkey */
152 u8 hw_hdr_offset = 0;
153 struct pkt_attrib *pattrib = &((struct xmit_frame *)pxmitframe)->attrib;
154 struct security_priv *psecuritypriv = &padapter->securitypriv;
155 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
158 if (((struct xmit_frame *)pxmitframe)->buf_addr == NULL)
161 hw_hdr_offset = TXDESC_SIZE +
162 (((struct xmit_frame *)pxmitframe)->pkt_offset * PACKET_OFFSET_SZ);
164 pframe = ((struct xmit_frame *)pxmitframe)->buf_addr + hw_hdr_offset;
166 /* start to encrypt each fragment */
167 if ((pattrib->encrypt == _WEP40_) || (pattrib->encrypt == _WEP104_)) {
168 keylength = psecuritypriv->dot11DefKeylen[psecuritypriv->dot11PrivacyKeyIndex];
170 for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
171 iv = pframe+pattrib->hdrlen;
172 memcpy(&wepkey[0], iv, 3);
173 memcpy(&wepkey[3], &psecuritypriv->dot11DefKey[psecuritypriv->dot11PrivacyKeyIndex].skey[0], keylength);
174 payload = pframe+pattrib->iv_len+pattrib->hdrlen;
176 if ((curfragnum+1) == pattrib->nr_frags) { /* the last fragment */
177 length = pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
179 *((__le32 *)crc) = getcrc32(payload, length);
181 arcfour_init(&mycontext, wepkey, 3+keylength);
182 arcfour_encrypt(&mycontext, payload, payload, length);
183 arcfour_encrypt(&mycontext, payload+length, crc, 4);
185 length = pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
186 *((__le32 *)crc) = getcrc32(payload, length);
187 arcfour_init(&mycontext, wepkey, 3+keylength);
188 arcfour_encrypt(&mycontext, payload, payload, length);
189 arcfour_encrypt(&mycontext, payload+length, crc, 4);
191 pframe += pxmitpriv->frag_len;
192 pframe = (u8 *)RND4((size_t)(pframe));
199 void rtw_wep_decrypt(struct adapter *padapter, u8 *precvframe)
203 struct arc4context mycontext;
206 u8 *pframe, *payload, *iv, wepkey[16];
208 struct rx_pkt_attrib *prxattrib = &(((struct recv_frame *)precvframe)->attrib);
209 struct security_priv *psecuritypriv = &padapter->securitypriv;
212 pframe = (unsigned char *)((struct recv_frame *)precvframe)->rx_data;
214 /* start to decrypt recvframe */
215 if ((prxattrib->encrypt == _WEP40_) || (prxattrib->encrypt == _WEP104_)) {
216 iv = pframe+prxattrib->hdrlen;
217 keyindex = prxattrib->key_index;
218 keylength = psecuritypriv->dot11DefKeylen[keyindex];
219 memcpy(&wepkey[0], iv, 3);
220 memcpy(&wepkey[3], &psecuritypriv->dot11DefKey[keyindex].skey[0], keylength);
221 length = ((struct recv_frame *)precvframe)->len-prxattrib->hdrlen-prxattrib->iv_len;
223 payload = pframe+prxattrib->iv_len+prxattrib->hdrlen;
225 /* decrypt payload include icv */
226 arcfour_init(&mycontext, wepkey, 3+keylength);
227 arcfour_encrypt(&mycontext, payload, payload, length);
229 /* calculate icv and compare the icv */
230 *((__le32 *)crc) = getcrc32(payload, length - 4);
232 if (crc[3] != payload[length-1] ||
233 crc[2] != payload[length-2] ||
234 crc[1] != payload[length-3] ||
235 crc[0] != payload[length-4]) {
236 RT_TRACE(_module_rtl871x_security_c_, _drv_err_,
237 ("rtw_wep_decrypt:icv error crc (%4ph)!=payload (%4ph)\n",
238 &crc, &payload[length-4]));
244 /* 3 ===== TKIP related ===== */
246 static u32 secmicgetuint32(u8 *p)
247 /* Convert from Byte[] to Us3232 in a portable way */
251 for (i = 0; i < 4; i++)
252 res |= ((u32)(*p++)) << (8*i);
256 static void secmicputuint32(u8 *p, u32 val)
257 /* Convert from Us3232 to Byte[] in a portable way */
260 for (i = 0; i < 4; i++) {
261 *p++ = (u8) (val & 0xff);
266 static void secmicclear(struct mic_data *pmicdata)
268 /* Reset the state to the empty message. */
269 pmicdata->L = pmicdata->K0;
270 pmicdata->R = pmicdata->K1;
271 pmicdata->nBytesInM = 0;
275 void rtw_secmicsetkey(struct mic_data *pmicdata, u8 *key)
278 pmicdata->K0 = secmicgetuint32(key);
279 pmicdata->K1 = secmicgetuint32(key + 4);
280 /* and reset the message */
281 secmicclear(pmicdata);
284 void rtw_secmicappendbyte(struct mic_data *pmicdata, u8 b)
286 /* Append the byte to our word-sized buffer */
287 pmicdata->M |= ((unsigned long)b) << (8*pmicdata->nBytesInM);
288 pmicdata->nBytesInM++;
289 /* Process the word if it is full. */
290 if (pmicdata->nBytesInM >= 4) {
291 pmicdata->L ^= pmicdata->M;
292 pmicdata->R ^= ROL32(pmicdata->L, 17);
293 pmicdata->L += pmicdata->R;
294 pmicdata->R ^= ((pmicdata->L & 0xff00ff00) >> 8) | ((pmicdata->L & 0x00ff00ff) << 8);
295 pmicdata->L += pmicdata->R;
296 pmicdata->R ^= ROL32(pmicdata->L, 3);
297 pmicdata->L += pmicdata->R;
298 pmicdata->R ^= ROR32(pmicdata->L, 2);
299 pmicdata->L += pmicdata->R;
300 /* Clear the buffer */
302 pmicdata->nBytesInM = 0;
306 void rtw_secmicappend(struct mic_data *pmicdata, u8 *src, u32 nbytes)
310 rtw_secmicappendbyte(pmicdata, *src++);
315 void rtw_secgetmic(struct mic_data *pmicdata, u8 *dst)
317 /* Append the minimum padding */
318 rtw_secmicappendbyte(pmicdata, 0x5a);
319 rtw_secmicappendbyte(pmicdata, 0);
320 rtw_secmicappendbyte(pmicdata, 0);
321 rtw_secmicappendbyte(pmicdata, 0);
322 rtw_secmicappendbyte(pmicdata, 0);
323 /* and then zeroes until the length is a multiple of 4 */
324 while (pmicdata->nBytesInM != 0)
325 rtw_secmicappendbyte(pmicdata, 0);
326 /* The appendByte function has already computed the result. */
327 secmicputuint32(dst, pmicdata->L);
328 secmicputuint32(dst+4, pmicdata->R);
329 /* Reset to the empty message. */
330 secmicclear(pmicdata);
333 void rtw_seccalctkipmic(u8 *key, u8 *header, u8 *data, u32 data_len, u8 *mic_code, u8 pri)
335 struct mic_data micdata;
336 u8 priority[4] = {0x0, 0x0, 0x0, 0x0};
337 rtw_secmicsetkey(&micdata, key);
340 /* Michael MIC pseudo header: DA, SA, 3 x 0, Priority */
341 if (header[1]&1) { /* ToDS == 1 */
342 rtw_secmicappend(&micdata, &header[16], 6); /* DA */
343 if (header[1]&2) /* From Ds == 1 */
344 rtw_secmicappend(&micdata, &header[24], 6);
346 rtw_secmicappend(&micdata, &header[10], 6);
347 } else { /* ToDS == 0 */
348 rtw_secmicappend(&micdata, &header[4], 6); /* DA */
349 if (header[1]&2) /* From Ds == 1 */
350 rtw_secmicappend(&micdata, &header[16], 6);
352 rtw_secmicappend(&micdata, &header[10], 6);
354 rtw_secmicappend(&micdata, &priority[0], 4);
356 rtw_secmicappend(&micdata, data, data_len);
358 rtw_secgetmic(&micdata, mic_code);
363 /* macros for extraction/creation of unsigned char/unsigned short values */
364 #define RotR1(v16) ((((v16) >> 1) & 0x7FFF) ^ (((v16) & 1) << 15))
365 #define Lo8(v16) ((u8)((v16) & 0x00FF))
366 #define Hi8(v16) ((u8)(((v16) >> 8) & 0x00FF))
367 #define Lo16(v32) ((u16)((v32) & 0xFFFF))
368 #define Hi16(v32) ((u16)(((v32) >> 16) & 0xFFFF))
369 #define Mk16(hi, lo) ((lo) ^ (((u16)(hi)) << 8))
371 /* select the Nth 16-bit word of the temporal key unsigned char array TK[] */
372 #define TK16(N) Mk16(tk[2*(N)+1], tk[2*(N)])
374 /* S-box lookup: 16 bits --> 16 bits */
375 #define _S_(v16) (Sbox1[0][Lo8(v16)] ^ Sbox1[1][Hi8(v16)])
377 /* fixed algorithm "parameters" */
378 #define PHASE1_LOOP_CNT 8 /* this needs to be "big enough" */
379 #define TA_SIZE 6 /* 48-bit transmitter address */
380 #define TK_SIZE 16 /* 128-bit temporal key */
381 #define P1K_SIZE 10 /* 80-bit Phase1 key */
382 #define RC4_KEY_SIZE 16 /* 128-bit RC4KEY (104 bits unknown) */
384 /* 2-unsigned char by 2-unsigned char subset of the full AES S-box table */
385 static const unsigned short Sbox1[2][256] = { /* Sbox for hash (can be in ROM) */
387 0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
388 0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
389 0x8F45, 0x1F9D, 0x8940, 0xFA87, 0xEF15, 0xB2EB, 0x8EC9, 0xFB0B,
390 0x41EC, 0xB367, 0x5FFD, 0x45EA, 0x23BF, 0x53F7, 0xE496, 0x9B5B,
391 0x75C2, 0xE11C, 0x3DAE, 0x4C6A, 0x6C5A, 0x7E41, 0xF502, 0x834F,
392 0x685C, 0x51F4, 0xD134, 0xF908, 0xE293, 0xAB73, 0x6253, 0x2A3F,
393 0x080C, 0x9552, 0x4665, 0x9D5E, 0x3028, 0x37A1, 0x0A0F, 0x2FB5,
394 0x0E09, 0x2436, 0x1B9B, 0xDF3D, 0xCD26, 0x4E69, 0x7FCD, 0xEA9F,
395 0x121B, 0x1D9E, 0x5874, 0x342E, 0x362D, 0xDCB2, 0xB4EE, 0x5BFB,
396 0xA4F6, 0x764D, 0xB761, 0x7DCE, 0x527B, 0xDD3E, 0x5E71, 0x1397,
397 0xA6F5, 0xB968, 0x0000, 0xC12C, 0x4060, 0xE31F, 0x79C8, 0xB6ED,
398 0xD4BE, 0x8D46, 0x67D9, 0x724B, 0x94DE, 0x98D4, 0xB0E8, 0x854A,
399 0xBB6B, 0xC52A, 0x4FE5, 0xED16, 0x86C5, 0x9AD7, 0x6655, 0x1194,
400 0x8ACF, 0xE910, 0x0406, 0xFE81, 0xA0F0, 0x7844, 0x25BA, 0x4BE3,
401 0xA2F3, 0x5DFE, 0x80C0, 0x058A, 0x3FAD, 0x21BC, 0x7048, 0xF104,
402 0x63DF, 0x77C1, 0xAF75, 0x4263, 0x2030, 0xE51A, 0xFD0E, 0xBF6D,
403 0x814C, 0x1814, 0x2635, 0xC32F, 0xBEE1, 0x35A2, 0x88CC, 0x2E39,
404 0x9357, 0x55F2, 0xFC82, 0x7A47, 0xC8AC, 0xBAE7, 0x322B, 0xE695,
405 0xC0A0, 0x1998, 0x9ED1, 0xA37F, 0x4466, 0x547E, 0x3BAB, 0x0B83,
406 0x8CCA, 0xC729, 0x6BD3, 0x283C, 0xA779, 0xBCE2, 0x161D, 0xAD76,
407 0xDB3B, 0x6456, 0x744E, 0x141E, 0x92DB, 0x0C0A, 0x486C, 0xB8E4,
408 0x9F5D, 0xBD6E, 0x43EF, 0xC4A6, 0x39A8, 0x31A4, 0xD337, 0xF28B,
409 0xD532, 0x8B43, 0x6E59, 0xDAB7, 0x018C, 0xB164, 0x9CD2, 0x49E0,
410 0xD8B4, 0xACFA, 0xF307, 0xCF25, 0xCAAF, 0xF48E, 0x47E9, 0x1018,
411 0x6FD5, 0xF088, 0x4A6F, 0x5C72, 0x3824, 0x57F1, 0x73C7, 0x9751,
412 0xCB23, 0xA17C, 0xE89C, 0x3E21, 0x96DD, 0x61DC, 0x0D86, 0x0F85,
413 0xE090, 0x7C42, 0x71C4, 0xCCAA, 0x90D8, 0x0605, 0xF701, 0x1C12,
414 0xC2A3, 0x6A5F, 0xAEF9, 0x69D0, 0x1791, 0x9958, 0x3A27, 0x27B9,
415 0xD938, 0xEB13, 0x2BB3, 0x2233, 0xD2BB, 0xA970, 0x0789, 0x33A7,
416 0x2DB6, 0x3C22, 0x1592, 0xC920, 0x8749, 0xAAFF, 0x5078, 0xA57A,
417 0x038F, 0x59F8, 0x0980, 0x1A17, 0x65DA, 0xD731, 0x84C6, 0xD0B8,
418 0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A,
421 { /* second half of table is unsigned char-reversed version of first! */
422 0xA5C6, 0x84F8, 0x99EE, 0x8DF6, 0x0DFF, 0xBDD6, 0xB1DE, 0x5491,
423 0x5060, 0x0302, 0xA9CE, 0x7D56, 0x19E7, 0x62B5, 0xE64D, 0x9AEC,
424 0x458F, 0x9D1F, 0x4089, 0x87FA, 0x15EF, 0xEBB2, 0xC98E, 0x0BFB,
425 0xEC41, 0x67B3, 0xFD5F, 0xEA45, 0xBF23, 0xF753, 0x96E4, 0x5B9B,
426 0xC275, 0x1CE1, 0xAE3D, 0x6A4C, 0x5A6C, 0x417E, 0x02F5, 0x4F83,
427 0x5C68, 0xF451, 0x34D1, 0x08F9, 0x93E2, 0x73AB, 0x5362, 0x3F2A,
428 0x0C08, 0x5295, 0x6546, 0x5E9D, 0x2830, 0xA137, 0x0F0A, 0xB52F,
429 0x090E, 0x3624, 0x9B1B, 0x3DDF, 0x26CD, 0x694E, 0xCD7F, 0x9FEA,
430 0x1B12, 0x9E1D, 0x7458, 0x2E34, 0x2D36, 0xB2DC, 0xEEB4, 0xFB5B,
431 0xF6A4, 0x4D76, 0x61B7, 0xCE7D, 0x7B52, 0x3EDD, 0x715E, 0x9713,
432 0xF5A6, 0x68B9, 0x0000, 0x2CC1, 0x6040, 0x1FE3, 0xC879, 0xEDB6,
433 0xBED4, 0x468D, 0xD967, 0x4B72, 0xDE94, 0xD498, 0xE8B0, 0x4A85,
434 0x6BBB, 0x2AC5, 0xE54F, 0x16ED, 0xC586, 0xD79A, 0x5566, 0x9411,
435 0xCF8A, 0x10E9, 0x0604, 0x81FE, 0xF0A0, 0x4478, 0xBA25, 0xE34B,
436 0xF3A2, 0xFE5D, 0xC080, 0x8A05, 0xAD3F, 0xBC21, 0x4870, 0x04F1,
437 0xDF63, 0xC177, 0x75AF, 0x6342, 0x3020, 0x1AE5, 0x0EFD, 0x6DBF,
438 0x4C81, 0x1418, 0x3526, 0x2FC3, 0xE1BE, 0xA235, 0xCC88, 0x392E,
439 0x5793, 0xF255, 0x82FC, 0x477A, 0xACC8, 0xE7BA, 0x2B32, 0x95E6,
440 0xA0C0, 0x9819, 0xD19E, 0x7FA3, 0x6644, 0x7E54, 0xAB3B, 0x830B,
441 0xCA8C, 0x29C7, 0xD36B, 0x3C28, 0x79A7, 0xE2BC, 0x1D16, 0x76AD,
442 0x3BDB, 0x5664, 0x4E74, 0x1E14, 0xDB92, 0x0A0C, 0x6C48, 0xE4B8,
443 0x5D9F, 0x6EBD, 0xEF43, 0xA6C4, 0xA839, 0xA431, 0x37D3, 0x8BF2,
444 0x32D5, 0x438B, 0x596E, 0xB7DA, 0x8C01, 0x64B1, 0xD29C, 0xE049,
445 0xB4D8, 0xFAAC, 0x07F3, 0x25CF, 0xAFCA, 0x8EF4, 0xE947, 0x1810,
446 0xD56F, 0x88F0, 0x6F4A, 0x725C, 0x2438, 0xF157, 0xC773, 0x5197,
447 0x23CB, 0x7CA1, 0x9CE8, 0x213E, 0xDD96, 0xDC61, 0x860D, 0x850F,
448 0x90E0, 0x427C, 0xC471, 0xAACC, 0xD890, 0x0506, 0x01F7, 0x121C,
449 0xA3C2, 0x5F6A, 0xF9AE, 0xD069, 0x9117, 0x5899, 0x273A, 0xB927,
450 0x38D9, 0x13EB, 0xB32B, 0x3322, 0xBBD2, 0x70A9, 0x8907, 0xA733,
451 0xB62D, 0x223C, 0x9215, 0x20C9, 0x4987, 0xFFAA, 0x7850, 0x7AA5,
452 0x8F03, 0xF859, 0x8009, 0x171A, 0xDA65, 0x31D7, 0xC684, 0xB8D0,
453 0xC382, 0xB029, 0x775A, 0x111E, 0xCB7B, 0xFCA8, 0xD66D, 0x3A2C,
458 **********************************************************************
459 * Routine: Phase 1 -- generate P1K, given TA, TK, IV32
462 * tk[] = temporal key [128 bits]
463 * ta[] = transmitter's MAC address [ 48 bits]
464 * iv32 = upper 32 bits of IV [ 32 bits]
466 * p1k[] = Phase 1 key [ 80 bits]
469 * This function only needs to be called every 2**16 packets,
470 * although in theory it could be called every packet.
472 **********************************************************************
474 static void phase1(u16 *p1k, const u8 *tk, const u8 *ta, u32 iv32)
477 /* Initialize the 80 bits of P1K[] from IV32 and TA[0..5] */
480 p1k[2] = Mk16(ta[1], ta[0]); /* use TA[] as little-endian */
481 p1k[3] = Mk16(ta[3], ta[2]);
482 p1k[4] = Mk16(ta[5], ta[4]);
484 /* Now compute an unbalanced Feistel cipher with 80-bit block */
485 /* size on the 80-bit block P1K[], using the 128-bit key TK[] */
486 for (i = 0; i < PHASE1_LOOP_CNT; i++) { /* Each add operation here is mod 2**16 */
487 p1k[0] += _S_(p1k[4] ^ TK16((i&1)+0));
488 p1k[1] += _S_(p1k[0] ^ TK16((i&1)+2));
489 p1k[2] += _S_(p1k[1] ^ TK16((i&1)+4));
490 p1k[3] += _S_(p1k[2] ^ TK16((i&1)+6));
491 p1k[4] += _S_(p1k[3] ^ TK16((i&1)+0));
492 p1k[4] += (unsigned short)i; /* avoid "slide attacks" */
497 **********************************************************************
498 * Routine: Phase 2 -- generate RC4KEY, given TK, P1K, IV16
501 * tk[] = Temporal key [128 bits]
502 * p1k[] = Phase 1 output key [ 80 bits]
503 * iv16 = low 16 bits of IV counter [ 16 bits]
505 * rc4key[] = the key used to encrypt the packet [128 bits]
508 * The value {TA, IV32, IV16} for Phase1/Phase2 must be unique
509 * across all packets using the same key TK value. Then, for a
510 * given value of TK[], this TKIP48 construction guarantees that
511 * the final RC4KEY value is unique across all packets.
513 * Suggested implementation optimization: if PPK[] is "overlaid"
514 * appropriately on RC4KEY[], there is no need for the final
515 * for loop below that copies the PPK[] result into RC4KEY[].
517 **********************************************************************
519 static void phase2(u8 *rc4key, const u8 *tk, const u16 *p1k, u16 iv16)
522 u16 PPK[6]; /* temporary key for mixing */
523 /* Note: all adds in the PPK[] equations below are mod 2**16 */
524 for (i = 0; i < 5; i++)
525 PPK[i] = p1k[i]; /* first, copy P1K to PPK */
526 PPK[5] = p1k[4] + iv16; /* next, add in IV16 */
528 /* Bijective non-linear mixing of the 96 bits of PPK[0..5] */
529 PPK[0] += _S_(PPK[5] ^ TK16(0)); /* Mix key in each "round" */
530 PPK[1] += _S_(PPK[0] ^ TK16(1));
531 PPK[2] += _S_(PPK[1] ^ TK16(2));
532 PPK[3] += _S_(PPK[2] ^ TK16(3));
533 PPK[4] += _S_(PPK[3] ^ TK16(4));
534 PPK[5] += _S_(PPK[4] ^ TK16(5)); /* Total # S-box lookups == 6 */
536 /* Final sweep: bijective, "linear". Rotates kill LSB correlations */
537 PPK[0] += RotR1(PPK[5] ^ TK16(6));
538 PPK[1] += RotR1(PPK[0] ^ TK16(7)); /* Use all of TK[] in Phase2 */
539 PPK[2] += RotR1(PPK[1]);
540 PPK[3] += RotR1(PPK[2]);
541 PPK[4] += RotR1(PPK[3]);
542 PPK[5] += RotR1(PPK[4]);
543 /* Note: At this point, for a given key TK[0..15], the 96-bit output */
544 /* value PPK[0..5] is guaranteed to be unique, as a function */
545 /* of the 96-bit "input" value {TA, IV32, IV16}. That is, P1K */
546 /* is now a keyed permutation of {TA, IV32, IV16}. */
548 /* Set RC4KEY[0..3], which includes "cleartext" portion of RC4 key */
549 rc4key[0] = Hi8(iv16); /* RC4KEY[0..2] is the WEP IV */
550 rc4key[1] = (Hi8(iv16) | 0x20) & 0x7F; /* Help avoid weak (FMS) keys */
551 rc4key[2] = Lo8(iv16);
552 rc4key[3] = Lo8((PPK[5] ^ TK16(0)) >> 1);
554 /* Copy 96 bits of PPK[0..5] to RC4KEY[4..15] (little-endian) */
555 for (i = 0; i < 6; i++) {
556 rc4key[4+2*i] = Lo8(PPK[i]);
557 rc4key[5+2*i] = Hi8(PPK[i]);
561 /* The hlen isn't include the IV */
562 u32 rtw_tkip_encrypt(struct adapter *padapter, u8 *pxmitframe)
569 u8 hw_hdr_offset = 0;
570 struct arc4context mycontext;
571 int curfragnum, length;
573 u8 *pframe, *payload, *iv, *prwskey;
574 union pn48 dot11txpn;
575 struct sta_info *stainfo;
576 struct pkt_attrib *pattrib = &((struct xmit_frame *)pxmitframe)->attrib;
577 struct security_priv *psecuritypriv = &padapter->securitypriv;
578 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
581 if (((struct xmit_frame *)pxmitframe)->buf_addr == NULL)
584 hw_hdr_offset = TXDESC_SIZE +
585 (((struct xmit_frame *)pxmitframe)->pkt_offset * PACKET_OFFSET_SZ);
586 pframe = ((struct xmit_frame *)pxmitframe)->buf_addr + hw_hdr_offset;
587 /* 4 start to encrypt each fragment */
588 if (pattrib->encrypt == _TKIP_) {
590 stainfo = pattrib->psta;
592 stainfo = rtw_get_stainfo(&padapter->stapriv, &pattrib->ra[0]);
594 if (stainfo != NULL) {
595 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("rtw_tkip_encrypt: stainfo!= NULL!!!\n"));
597 if (IS_MCAST(pattrib->ra))
598 prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey;
600 prwskey = &stainfo->dot118021x_UncstKey.skey[0];
602 for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
603 iv = pframe+pattrib->hdrlen;
604 payload = pframe+pattrib->iv_len+pattrib->hdrlen;
606 GET_TKIP_PN(iv, dot11txpn);
608 pnl = (u16)(dot11txpn.val);
609 pnh = (u32)(dot11txpn.val>>16);
610 phase1((u16 *)&ttkey[0], prwskey, &pattrib->ta[0], pnh);
611 phase2(&rc4key[0], prwskey, (u16 *)&ttkey[0], pnl);
613 if ((curfragnum+1) == pattrib->nr_frags) { /* 4 the last fragment */
614 length = pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
615 RT_TRACE(_module_rtl871x_security_c_, _drv_info_,
616 ("pattrib->iv_len=%x, pattrib->icv_len=%x\n",
617 pattrib->iv_len, pattrib->icv_len));
618 *((__le32 *)crc) = getcrc32(payload, length);/* modified by Amy*/
620 arcfour_init(&mycontext, rc4key, 16);
621 arcfour_encrypt(&mycontext, payload, payload, length);
622 arcfour_encrypt(&mycontext, payload+length, crc, 4);
624 length = pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len ;
625 *((__le32 *)crc) = getcrc32(payload, length);/* modified by Amy*/
626 arcfour_init(&mycontext, rc4key, 16);
627 arcfour_encrypt(&mycontext, payload, payload, length);
628 arcfour_encrypt(&mycontext, payload+length, crc, 4);
630 pframe += pxmitpriv->frag_len;
631 pframe = (u8 *)RND4((size_t)(pframe));
635 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("rtw_tkip_encrypt: stainfo==NULL!!!\n"));
642 /* The hlen isn't include the IV */
643 u32 rtw_tkip_decrypt(struct adapter *padapter, u8 *precvframe)
650 struct arc4context mycontext;
653 u8 *pframe, *payload, *iv, *prwskey;
654 union pn48 dot11txpn;
655 struct sta_info *stainfo;
656 struct rx_pkt_attrib *prxattrib = &((struct recv_frame *)precvframe)->attrib;
657 struct security_priv *psecuritypriv = &padapter->securitypriv;
661 pframe = (unsigned char *)((struct recv_frame *)precvframe)->rx_data;
663 /* 4 start to decrypt recvframe */
664 if (prxattrib->encrypt == _TKIP_) {
665 stainfo = rtw_get_stainfo(&padapter->stapriv, &prxattrib->ta[0]);
666 if (stainfo != NULL) {
667 if (IS_MCAST(prxattrib->ra)) {
668 if (!psecuritypriv->binstallGrpkey) {
670 DBG_88E("%s:rx bc/mc packets, but didn't install group key!!!!!!!!!!\n", __func__);
673 prwskey = psecuritypriv->dot118021XGrpKey[prxattrib->key_index].skey;
675 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("rtw_tkip_decrypt: stainfo!= NULL!!!\n"));
676 prwskey = &stainfo->dot118021x_UncstKey.skey[0];
679 iv = pframe+prxattrib->hdrlen;
680 payload = pframe+prxattrib->iv_len+prxattrib->hdrlen;
681 length = ((struct recv_frame *)precvframe)->len-prxattrib->hdrlen-prxattrib->iv_len;
683 GET_TKIP_PN(iv, dot11txpn);
685 pnl = (u16)(dot11txpn.val);
686 pnh = (u32)(dot11txpn.val>>16);
688 phase1((u16 *)&ttkey[0], prwskey, &prxattrib->ta[0], pnh);
689 phase2(&rc4key[0], prwskey, (unsigned short *)&ttkey[0], pnl);
691 /* 4 decrypt payload include icv */
693 arcfour_init(&mycontext, rc4key, 16);
694 arcfour_encrypt(&mycontext, payload, payload, length);
696 *((__le32 *)crc) = getcrc32(payload, length-4);
698 if (crc[3] != payload[length-1] ||
699 crc[2] != payload[length-2] ||
700 crc[1] != payload[length-3] ||
701 crc[0] != payload[length-4]) {
702 RT_TRACE(_module_rtl871x_security_c_, _drv_err_,
703 ("rtw_wep_decrypt:icv error crc (%4ph)!=payload (%4ph)\n",
704 &crc, &payload[length-4]));
708 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("rtw_tkip_decrypt: stainfo==NULL!!!\n"));
716 /* 3 ===== AES related ===== */
719 #define MAX_MSG_SIZE 2048
720 /*****************************/
721 /******** SBOX Table *********/
722 /*****************************/
724 static u8 sbox_table[256] = {
725 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
726 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
727 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
728 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
729 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
730 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
731 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
732 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
733 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
734 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
735 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
736 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
737 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
738 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
739 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
740 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
741 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
742 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
743 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
744 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
745 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
746 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
747 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
748 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
749 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
750 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
751 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
752 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
753 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
754 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
755 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
756 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
759 /*****************************/
760 /**** Function Prototypes ****/
761 /*****************************/
763 static void bitwise_xor(u8 *ina, u8 *inb, u8 *out);
764 static void construct_mic_iv(u8 *mic_header1, int qc_exists, int a4_exists, u8 *mpdu, uint payload_length, u8 *pn_vector);
765 static void construct_mic_header1(u8 *mic_header1, int header_length, u8 *mpdu);
766 static void construct_mic_header2(u8 *mic_header2, u8 *mpdu, int a4_exists, int qc_exists);
767 static void construct_ctr_preload(u8 *ctr_preload, int a4_exists, int qc_exists, u8 *mpdu, u8 *pn_vector, int c);
768 static void xor_128(u8 *a, u8 *b, u8 *out);
769 static void xor_32(u8 *a, u8 *b, u8 *out);
770 static u8 sbox(u8 a);
771 static void next_key(u8 *key, int round);
772 static void byte_sub(u8 *in, u8 *out);
773 static void shift_row(u8 *in, u8 *out);
774 static void mix_column(u8 *in, u8 *out);
775 static void aes128k128d(u8 *key, u8 *data, u8 *ciphertext);
777 /****************************************/
779 /* Performs a 128 bit AES encrypt with */
781 /****************************************/
782 static void xor_128(u8 *a, u8 *b, u8 *out)
785 for (i = 0; i < 16; i++)
786 out[i] = a[i] ^ b[i];
789 static void xor_32(u8 *a, u8 *b, u8 *out)
792 for (i = 0; i < 4; i++)
793 out[i] = a[i] ^ b[i];
798 return sbox_table[(int)a];
801 static void next_key(u8 *key, int round)
805 u8 rcon_table[12] = {
806 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
807 0x1b, 0x36, 0x36, 0x36
809 sbox_key[0] = sbox(key[13]);
810 sbox_key[1] = sbox(key[14]);
811 sbox_key[2] = sbox(key[15]);
812 sbox_key[3] = sbox(key[12]);
814 rcon = rcon_table[round];
816 xor_32(&key[0], sbox_key, &key[0]);
817 key[0] = key[0] ^ rcon;
819 xor_32(&key[4], &key[0], &key[4]);
820 xor_32(&key[8], &key[4], &key[8]);
821 xor_32(&key[12], &key[8], &key[12]);
824 static void byte_sub(u8 *in, u8 *out)
827 for (i = 0; i < 16; i++)
828 out[i] = sbox(in[i]);
831 static void shift_row(u8 *in, u8 *out)
851 static void mix_column(u8 *in, u8 *out)
862 for (i = 0 ; i < 4; i++) {
863 if ((in[i] & 0x80) == 0x80)
869 swap_halfs[0] = in[2]; /* Swap halves */
870 swap_halfs[1] = in[3];
871 swap_halfs[2] = in[0];
872 swap_halfs[3] = in[1];
874 rotl[0] = in[3]; /* Rotate left 8 bits */
879 andf7[0] = in[0] & 0x7f;
880 andf7[1] = in[1] & 0x7f;
881 andf7[2] = in[2] & 0x7f;
882 andf7[3] = in[3] & 0x7f;
884 for (i = 3; i > 0; i--) { /* logical shift left 1 bit */
885 andf7[i] = andf7[i] << 1;
886 if ((andf7[i-1] & 0x80) == 0x80)
887 andf7[i] = (andf7[i] | 0x01);
889 andf7[0] = andf7[0] << 1;
890 andf7[0] = andf7[0] & 0xfe;
892 xor_32(add1b, andf7, add1bf7);
894 xor_32(in, add1bf7, rotr);
896 temp[0] = rotr[0]; /* Rotate right 8 bits */
902 xor_32(add1bf7, rotr, temp);
903 xor_32(swap_halfs, rotl, tempb);
904 xor_32(temp, tempb, out);
907 static void aes128k128d(u8 *key, u8 *data, u8 *ciphertext)
911 u8 intermediatea[16];
912 u8 intermediateb[16];
914 for (i = 0; i < 16; i++)
915 round_key[i] = key[i];
916 for (round = 0; round < 11; round++) {
918 xor_128(round_key, data, ciphertext);
919 next_key(round_key, round);
920 } else if (round == 10) {
921 byte_sub(ciphertext, intermediatea);
922 shift_row(intermediatea, intermediateb);
923 xor_128(intermediateb, round_key, ciphertext);
925 byte_sub(ciphertext, intermediatea);
926 shift_row(intermediatea, intermediateb);
927 mix_column(&intermediateb[0], &intermediatea[0]);
928 mix_column(&intermediateb[4], &intermediatea[4]);
929 mix_column(&intermediateb[8], &intermediatea[8]);
930 mix_column(&intermediateb[12], &intermediatea[12]);
931 xor_128(intermediatea, round_key, ciphertext);
932 next_key(round_key, round);
937 /************************************************/
938 /* construct_mic_iv() */
939 /* Builds the MIC IV from header fields and PN */
940 /************************************************/
941 static void construct_mic_iv(u8 *mic_iv, int qc_exists, int a4_exists, u8 *mpdu,
942 uint payload_length, u8 *pn_vector)
946 if (qc_exists && a4_exists)
947 mic_iv[1] = mpdu[30] & 0x0f; /* QoS_TC */
948 if (qc_exists && !a4_exists)
949 mic_iv[1] = mpdu[24] & 0x0f; /* mute bits 7-4 */
952 for (i = 2; i < 8; i++)
953 mic_iv[i] = mpdu[i + 8]; /* mic_iv[2:7] = A2[0:5] = mpdu[10:15] */
954 for (i = 8; i < 14; i++)
955 mic_iv[i] = pn_vector[13 - i]; /* mic_iv[8:13] = PN[5:0] */
956 mic_iv[14] = (unsigned char) (payload_length / 256);
957 mic_iv[15] = (unsigned char) (payload_length % 256);
960 /************************************************/
961 /* construct_mic_header1() */
962 /* Builds the first MIC header block from */
964 /************************************************/
965 static void construct_mic_header1(u8 *mic_header1, int header_length, u8 *mpdu)
967 mic_header1[0] = (u8)((header_length - 2) / 256);
968 mic_header1[1] = (u8)((header_length - 2) % 256);
969 mic_header1[2] = mpdu[0] & 0xcf; /* Mute CF poll & CF ack bits */
970 mic_header1[3] = mpdu[1] & 0xc7; /* Mute retry, more data and pwr mgt bits */
971 mic_header1[4] = mpdu[4]; /* A1 */
972 mic_header1[5] = mpdu[5];
973 mic_header1[6] = mpdu[6];
974 mic_header1[7] = mpdu[7];
975 mic_header1[8] = mpdu[8];
976 mic_header1[9] = mpdu[9];
977 mic_header1[10] = mpdu[10]; /* A2 */
978 mic_header1[11] = mpdu[11];
979 mic_header1[12] = mpdu[12];
980 mic_header1[13] = mpdu[13];
981 mic_header1[14] = mpdu[14];
982 mic_header1[15] = mpdu[15];
985 /************************************************/
986 /* construct_mic_header2() */
987 /* Builds the last MIC header block from */
989 /************************************************/
990 static void construct_mic_header2(u8 *mic_header2, u8 *mpdu, int a4_exists, int qc_exists)
993 for (i = 0; i < 16; i++)
994 mic_header2[i] = 0x00;
996 mic_header2[0] = mpdu[16]; /* A3 */
997 mic_header2[1] = mpdu[17];
998 mic_header2[2] = mpdu[18];
999 mic_header2[3] = mpdu[19];
1000 mic_header2[4] = mpdu[20];
1001 mic_header2[5] = mpdu[21];
1003 mic_header2[6] = 0x00;
1004 mic_header2[7] = 0x00; /* mpdu[23]; */
1006 if (!qc_exists && a4_exists) {
1007 for (i = 0; i < 6; i++)
1008 mic_header2[8+i] = mpdu[24+i]; /* A4 */
1011 if (qc_exists && !a4_exists) {
1012 mic_header2[8] = mpdu[24] & 0x0f; /* mute bits 15 - 4 */
1013 mic_header2[9] = mpdu[25] & 0x00;
1016 if (qc_exists && a4_exists) {
1017 for (i = 0; i < 6; i++)
1018 mic_header2[8+i] = mpdu[24+i]; /* A4 */
1020 mic_header2[14] = mpdu[30] & 0x0f;
1021 mic_header2[15] = mpdu[31] & 0x00;
1026 /************************************************/
1027 /* construct_mic_header2() */
1028 /* Builds the last MIC header block from */
1029 /* header fields. */
1030 /************************************************/
1031 static void construct_ctr_preload(u8 *ctr_preload, int a4_exists, int qc_exists, u8 *mpdu, u8 *pn_vector, int c)
1034 for (i = 0; i < 16; i++)
1035 ctr_preload[i] = 0x00;
1038 ctr_preload[0] = 0x01; /* flag */
1039 if (qc_exists && a4_exists)
1040 ctr_preload[1] = mpdu[30] & 0x0f; /* QoC_Control */
1041 if (qc_exists && !a4_exists)
1042 ctr_preload[1] = mpdu[24] & 0x0f;
1044 for (i = 2; i < 8; i++)
1045 ctr_preload[i] = mpdu[i + 8]; /* ctr_preload[2:7] = A2[0:5] = mpdu[10:15] */
1046 for (i = 8; i < 14; i++)
1047 ctr_preload[i] = pn_vector[13 - i]; /* ctr_preload[8:13] = PN[5:0] */
1048 ctr_preload[14] = (unsigned char) (c / 256); /* Ctr */
1049 ctr_preload[15] = (unsigned char) (c % 256);
1052 /************************************/
1054 /* A 128 bit, bitwise exclusive or */
1055 /************************************/
1056 static void bitwise_xor(u8 *ina, u8 *inb, u8 *out)
1059 for (i = 0; i < 16; i++)
1060 out[i] = ina[i] ^ inb[i];
1063 static int aes_cipher(u8 *key, uint hdrlen, u8 *pframe, uint plen)
1065 uint qc_exists, a4_exists, i, j, payload_remainder,
1066 num_blocks, payload_index;
1074 /* Intermediate Buffers */
1075 u8 chain_buffer[16];
1077 u8 padded_buffer[16];
1079 uint frtype = GetFrameType(pframe);
1080 uint frsubtype = GetFrameSubType(pframe);
1082 frsubtype = frsubtype>>4;
1084 _rtw_memset((void *)mic_iv, 0, 16);
1085 _rtw_memset((void *)mic_header1, 0, 16);
1086 _rtw_memset((void *)mic_header2, 0, 16);
1087 _rtw_memset((void *)ctr_preload, 0, 16);
1088 _rtw_memset((void *)chain_buffer, 0, 16);
1089 _rtw_memset((void *)aes_out, 0, 16);
1090 _rtw_memset((void *)padded_buffer, 0, 16);
1092 if ((hdrlen == WLAN_HDR_A3_LEN) || (hdrlen == WLAN_HDR_A3_QOS_LEN))
1097 if ((frtype == WIFI_DATA_CFACK) || (frtype == WIFI_DATA_CFPOLL) || (frtype == WIFI_DATA_CFACKPOLL)) {
1099 if (hdrlen != WLAN_HDR_A3_QOS_LEN)
1101 } else if ((frsubtype == 0x08) || (frsubtype == 0x09) || (frsubtype == 0x0a) || (frsubtype == 0x0b)) {
1102 if (hdrlen != WLAN_HDR_A3_QOS_LEN)
1109 pn_vector[0] = pframe[hdrlen];
1110 pn_vector[1] = pframe[hdrlen+1];
1111 pn_vector[2] = pframe[hdrlen+4];
1112 pn_vector[3] = pframe[hdrlen+5];
1113 pn_vector[4] = pframe[hdrlen+6];
1114 pn_vector[5] = pframe[hdrlen+7];
1116 construct_mic_iv(mic_iv, qc_exists, a4_exists, pframe, plen, pn_vector);
1118 construct_mic_header1(mic_header1, hdrlen, pframe);
1119 construct_mic_header2(mic_header2, pframe, a4_exists, qc_exists);
1121 payload_remainder = plen % 16;
1122 num_blocks = plen / 16;
1124 /* Find start of payload */
1125 payload_index = (hdrlen + 8);
1128 aes128k128d(key, mic_iv, aes_out);
1129 bitwise_xor(aes_out, mic_header1, chain_buffer);
1130 aes128k128d(key, chain_buffer, aes_out);
1131 bitwise_xor(aes_out, mic_header2, chain_buffer);
1132 aes128k128d(key, chain_buffer, aes_out);
1134 for (i = 0; i < num_blocks; i++) {
1135 bitwise_xor(aes_out, &pframe[payload_index], chain_buffer);/* bitwise_xor(aes_out, &message[payload_index], chain_buffer); */
1137 payload_index += 16;
1138 aes128k128d(key, chain_buffer, aes_out);
1141 /* Add on the final payload block if it needs padding */
1142 if (payload_remainder > 0) {
1143 for (j = 0; j < 16; j++)
1144 padded_buffer[j] = 0x00;
1145 for (j = 0; j < payload_remainder; j++)
1146 padded_buffer[j] = pframe[payload_index++];/* padded_buffer[j] = message[payload_index++]; */
1147 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1148 aes128k128d(key, chain_buffer, aes_out);
1151 for (j = 0; j < 8; j++)
1152 mic[j] = aes_out[j];
1154 /* Insert MIC into payload */
1155 for (j = 0; j < 8; j++)
1156 pframe[payload_index+j] = mic[j]; /* message[payload_index+j] = mic[j]; */
1158 payload_index = hdrlen + 8;
1159 for (i = 0; i < num_blocks; i++) {
1160 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, pframe, pn_vector, i+1);
1161 aes128k128d(key, ctr_preload, aes_out);
1162 bitwise_xor(aes_out, &pframe[payload_index], chain_buffer);
1163 for (j = 0; j < 16; j++)
1164 pframe[payload_index++] = chain_buffer[j];
1167 if (payload_remainder > 0) { /* If there is a short final block, then pad it,*/
1168 /* encrypt it and copy the unpadded part back */
1169 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, pframe, pn_vector, num_blocks+1);
1171 for (j = 0; j < 16; j++)
1172 padded_buffer[j] = 0x00;
1173 for (j = 0; j < payload_remainder; j++)
1174 padded_buffer[j] = pframe[payload_index+j];
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];
1180 /* Encrypt the MIC */
1181 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, pframe, pn_vector, 0);
1183 for (j = 0; j < 16; j++)
1184 padded_buffer[j] = 0x00;
1185 for (j = 0; j < 8; j++)
1186 padded_buffer[j] = pframe[j+hdrlen+8+plen];
1188 aes128k128d(key, ctr_preload, aes_out);
1189 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1190 for (j = 0; j < 8; j++)
1191 pframe[payload_index++] = chain_buffer[j];
1195 u32 rtw_aes_encrypt(struct adapter *padapter, u8 *pxmitframe)
1199 /* unsigned char message[MAX_MSG_SIZE]; */
1201 /* Intermediate Buffers */
1202 int curfragnum, length;
1203 u8 *pframe, *prwskey; /* *payload,*iv */
1204 u8 hw_hdr_offset = 0;
1205 struct sta_info *stainfo;
1206 struct pkt_attrib *pattrib = &((struct xmit_frame *)pxmitframe)->attrib;
1207 struct security_priv *psecuritypriv = &padapter->securitypriv;
1208 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1210 /* uint offset = 0; */
1213 if (((struct xmit_frame *)pxmitframe)->buf_addr == NULL)
1216 hw_hdr_offset = TXDESC_SIZE +
1217 (((struct xmit_frame *)pxmitframe)->pkt_offset * PACKET_OFFSET_SZ);
1219 pframe = ((struct xmit_frame *)pxmitframe)->buf_addr + hw_hdr_offset;
1221 /* 4 start to encrypt each fragment */
1222 if ((pattrib->encrypt == _AES_)) {
1224 stainfo = pattrib->psta;
1226 stainfo = rtw_get_stainfo(&padapter->stapriv, &pattrib->ra[0]);
1228 if (stainfo != NULL) {
1229 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("rtw_aes_encrypt: stainfo!= NULL!!!\n"));
1231 if (IS_MCAST(pattrib->ra))
1232 prwskey = psecuritypriv->dot118021XGrpKey[psecuritypriv->dot118021XGrpKeyid].skey;
1234 prwskey = &stainfo->dot118021x_UncstKey.skey[0];
1235 for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
1236 if ((curfragnum+1) == pattrib->nr_frags) { /* 4 the last fragment */
1237 length = pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len;
1239 aes_cipher(prwskey, pattrib->hdrlen, pframe, length);
1241 length = pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-pattrib->icv_len ;
1243 aes_cipher(prwskey, pattrib->hdrlen, pframe, length);
1244 pframe += pxmitpriv->frag_len;
1245 pframe = (u8 *)RND4((size_t)(pframe));
1249 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("rtw_aes_encrypt: stainfo==NULL!!!\n"));
1258 static int aes_decipher(u8 *key, uint hdrlen,
1259 u8 *pframe, uint plen)
1261 static u8 message[MAX_MSG_SIZE];
1262 uint qc_exists, a4_exists, i, j, payload_remainder,
1263 num_blocks, payload_index;
1271 /* Intermediate Buffers */
1272 u8 chain_buffer[16];
1274 u8 padded_buffer[16];
1277 /* uint offset = 0; */
1278 uint frtype = GetFrameType(pframe);
1279 uint frsubtype = GetFrameSubType(pframe);
1280 frsubtype = frsubtype>>4;
1282 _rtw_memset((void *)mic_iv, 0, 16);
1283 _rtw_memset((void *)mic_header1, 0, 16);
1284 _rtw_memset((void *)mic_header2, 0, 16);
1285 _rtw_memset((void *)ctr_preload, 0, 16);
1286 _rtw_memset((void *)chain_buffer, 0, 16);
1287 _rtw_memset((void *)aes_out, 0, 16);
1288 _rtw_memset((void *)padded_buffer, 0, 16);
1290 /* start to decrypt the payload */
1292 num_blocks = (plen-8) / 16; /* plen including llc, payload_length and mic) */
1294 payload_remainder = (plen-8) % 16;
1296 pn_vector[0] = pframe[hdrlen];
1297 pn_vector[1] = pframe[hdrlen+1];
1298 pn_vector[2] = pframe[hdrlen+4];
1299 pn_vector[3] = pframe[hdrlen+5];
1300 pn_vector[4] = pframe[hdrlen+6];
1301 pn_vector[5] = pframe[hdrlen+7];
1303 if ((hdrlen == WLAN_HDR_A3_LEN) || (hdrlen == WLAN_HDR_A3_QOS_LEN))
1308 if ((frtype == WIFI_DATA_CFACK) || (frtype == WIFI_DATA_CFPOLL) ||
1309 (frtype == WIFI_DATA_CFACKPOLL)) {
1311 if (hdrlen != WLAN_HDR_A3_QOS_LEN)
1313 } else if ((frsubtype == 0x08) || (frsubtype == 0x09) ||
1314 (frsubtype == 0x0a) || (frsubtype == 0x0b)) {
1315 if (hdrlen != WLAN_HDR_A3_QOS_LEN)
1322 /* now, decrypt pframe with hdrlen offset and plen long */
1324 payload_index = hdrlen + 8; /* 8 is for extiv */
1326 for (i = 0; i < num_blocks; i++) {
1327 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, pframe, pn_vector, i+1);
1329 aes128k128d(key, ctr_preload, aes_out);
1330 bitwise_xor(aes_out, &pframe[payload_index], chain_buffer);
1332 for (j = 0; j < 16; j++)
1333 pframe[payload_index++] = chain_buffer[j];
1336 if (payload_remainder > 0) { /* If there is a short final block, then pad it,*/
1337 /* encrypt it and copy the unpadded part back */
1338 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, pframe, pn_vector, num_blocks+1);
1340 for (j = 0; j < 16; j++)
1341 padded_buffer[j] = 0x00;
1342 for (j = 0; j < payload_remainder; j++)
1343 padded_buffer[j] = pframe[payload_index+j];
1344 aes128k128d(key, ctr_preload, aes_out);
1345 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1346 for (j = 0; j < payload_remainder; j++)
1347 pframe[payload_index++] = chain_buffer[j];
1350 /* start to calculate the mic */
1351 if ((hdrlen+plen+8) <= MAX_MSG_SIZE)
1352 memcpy(message, pframe, (hdrlen + plen+8)); /* 8 is for ext iv len */
1354 pn_vector[0] = pframe[hdrlen];
1355 pn_vector[1] = pframe[hdrlen+1];
1356 pn_vector[2] = pframe[hdrlen+4];
1357 pn_vector[3] = pframe[hdrlen+5];
1358 pn_vector[4] = pframe[hdrlen+6];
1359 pn_vector[5] = pframe[hdrlen+7];
1360 construct_mic_iv(mic_iv, qc_exists, a4_exists, message, plen-8, pn_vector);
1362 construct_mic_header1(mic_header1, hdrlen, message);
1363 construct_mic_header2(mic_header2, message, a4_exists, qc_exists);
1365 payload_remainder = (plen-8) % 16;
1366 num_blocks = (plen-8) / 16;
1368 /* Find start of payload */
1369 payload_index = (hdrlen + 8);
1372 aes128k128d(key, mic_iv, aes_out);
1373 bitwise_xor(aes_out, mic_header1, chain_buffer);
1374 aes128k128d(key, chain_buffer, aes_out);
1375 bitwise_xor(aes_out, mic_header2, chain_buffer);
1376 aes128k128d(key, chain_buffer, aes_out);
1378 for (i = 0; i < num_blocks; i++) {
1379 bitwise_xor(aes_out, &message[payload_index], chain_buffer);
1381 payload_index += 16;
1382 aes128k128d(key, chain_buffer, aes_out);
1385 /* Add on the final payload block if it needs padding */
1386 if (payload_remainder > 0) {
1387 for (j = 0; j < 16; j++)
1388 padded_buffer[j] = 0x00;
1389 for (j = 0; j < payload_remainder; j++)
1390 padded_buffer[j] = message[payload_index++];
1391 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1392 aes128k128d(key, chain_buffer, aes_out);
1395 for (j = 0 ; j < 8; j++)
1396 mic[j] = aes_out[j];
1398 /* Insert MIC into payload */
1399 for (j = 0; j < 8; j++)
1400 message[payload_index+j] = mic[j];
1402 payload_index = hdrlen + 8;
1403 for (i = 0; i < num_blocks; i++) {
1404 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, message, pn_vector, i+1);
1405 aes128k128d(key, ctr_preload, aes_out);
1406 bitwise_xor(aes_out, &message[payload_index], chain_buffer);
1407 for (j = 0; j < 16; j++)
1408 message[payload_index++] = chain_buffer[j];
1411 if (payload_remainder > 0) { /* If there is a short final block, then pad it,*/
1412 /* encrypt it and copy the unpadded part back */
1413 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, message, pn_vector, num_blocks+1);
1415 for (j = 0; j < 16; j++)
1416 padded_buffer[j] = 0x00;
1417 for (j = 0; j < payload_remainder; j++)
1418 padded_buffer[j] = message[payload_index+j];
1419 aes128k128d(key, ctr_preload, aes_out);
1420 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1421 for (j = 0; j < payload_remainder; j++)
1422 message[payload_index++] = chain_buffer[j];
1425 /* Encrypt the MIC */
1426 construct_ctr_preload(ctr_preload, a4_exists, qc_exists, message, pn_vector, 0);
1428 for (j = 0; j < 16; j++)
1429 padded_buffer[j] = 0x00;
1430 for (j = 0; j < 8; j++)
1431 padded_buffer[j] = message[j+hdrlen+8+plen-8];
1433 aes128k128d(key, ctr_preload, aes_out);
1434 bitwise_xor(aes_out, padded_buffer, chain_buffer);
1435 for (j = 0; j < 8; j++)
1436 message[payload_index++] = chain_buffer[j];
1438 /* compare the mic */
1439 for (i = 0; i < 8; i++) {
1440 if (pframe[hdrlen+8+plen-8+i] != message[hdrlen+8+plen-8+i]) {
1441 RT_TRACE(_module_rtl871x_security_c_, _drv_err_,
1442 ("aes_decipher:mic check error mic[%d]: pframe(%x)!=message(%x)\n",
1443 i, pframe[hdrlen+8+plen-8+i], message[hdrlen+8+plen-8+i]));
1444 DBG_88E("aes_decipher:mic check error mic[%d]: pframe(%x)!=message(%x)\n",
1445 i, pframe[hdrlen+8+plen-8+i], message[hdrlen+8+plen-8+i]);
1452 u32 rtw_aes_decrypt(struct adapter *padapter, u8 *precvframe)
1454 /* Intermediate Buffers */
1456 u8 *pframe, *prwskey; /* *payload,*iv */
1457 struct sta_info *stainfo;
1458 struct rx_pkt_attrib *prxattrib = &((struct recv_frame *)precvframe)->attrib;
1459 struct security_priv *psecuritypriv = &padapter->securitypriv;
1461 pframe = (unsigned char *)((struct recv_frame *)precvframe)->rx_data;
1462 /* 4 start to encrypt each fragment */
1463 if ((prxattrib->encrypt == _AES_)) {
1464 stainfo = rtw_get_stainfo(&padapter->stapriv, &prxattrib->ta[0]);
1465 if (stainfo != NULL) {
1466 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("rtw_aes_decrypt: stainfo!= NULL!!!\n"));
1468 if (IS_MCAST(prxattrib->ra)) {
1469 /* in concurrent we should use sw descrypt in group key, so we remove this message */
1470 if (!psecuritypriv->binstallGrpkey) {
1472 DBG_88E("%s:rx bc/mc packets, but didn't install group key!!!!!!!!!!\n", __func__);
1475 prwskey = psecuritypriv->dot118021XGrpKey[prxattrib->key_index].skey;
1476 if (psecuritypriv->dot118021XGrpKeyid != prxattrib->key_index) {
1477 DBG_88E("not match packet_index=%d, install_index=%d\n",
1478 prxattrib->key_index, psecuritypriv->dot118021XGrpKeyid);
1483 prwskey = &stainfo->dot118021x_UncstKey.skey[0];
1485 length = ((struct recv_frame *)precvframe)->len-prxattrib->hdrlen-prxattrib->iv_len;
1486 res = aes_decipher(prwskey, prxattrib->hdrlen, pframe, length);
1488 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("rtw_aes_encrypt: stainfo==NULL!!!\n"));
1497 const u32 Te0[256] = {
1498 0xc66363a5U, 0xf87c7c84U, 0xee777799U, 0xf67b7b8dU,
1499 0xfff2f20dU, 0xd66b6bbdU, 0xde6f6fb1U, 0x91c5c554U,
1500 0x60303050U, 0x02010103U, 0xce6767a9U, 0x562b2b7dU,
1501 0xe7fefe19U, 0xb5d7d762U, 0x4dababe6U, 0xec76769aU,
1502 0x8fcaca45U, 0x1f82829dU, 0x89c9c940U, 0xfa7d7d87U,
1503 0xeffafa15U, 0xb25959ebU, 0x8e4747c9U, 0xfbf0f00bU,
1504 0x41adadecU, 0xb3d4d467U, 0x5fa2a2fdU, 0x45afafeaU,
1505 0x239c9cbfU, 0x53a4a4f7U, 0xe4727296U, 0x9bc0c05bU,
1506 0x75b7b7c2U, 0xe1fdfd1cU, 0x3d9393aeU, 0x4c26266aU,
1507 0x6c36365aU, 0x7e3f3f41U, 0xf5f7f702U, 0x83cccc4fU,
1508 0x6834345cU, 0x51a5a5f4U, 0xd1e5e534U, 0xf9f1f108U,
1509 0xe2717193U, 0xabd8d873U, 0x62313153U, 0x2a15153fU,
1510 0x0804040cU, 0x95c7c752U, 0x46232365U, 0x9dc3c35eU,
1511 0x30181828U, 0x379696a1U, 0x0a05050fU, 0x2f9a9ab5U,
1512 0x0e070709U, 0x24121236U, 0x1b80809bU, 0xdfe2e23dU,
1513 0xcdebeb26U, 0x4e272769U, 0x7fb2b2cdU, 0xea75759fU,
1514 0x1209091bU, 0x1d83839eU, 0x582c2c74U, 0x341a1a2eU,
1515 0x361b1b2dU, 0xdc6e6eb2U, 0xb45a5aeeU, 0x5ba0a0fbU,
1516 0xa45252f6U, 0x763b3b4dU, 0xb7d6d661U, 0x7db3b3ceU,
1517 0x5229297bU, 0xdde3e33eU, 0x5e2f2f71U, 0x13848497U,
1518 0xa65353f5U, 0xb9d1d168U, 0x00000000U, 0xc1eded2cU,
1519 0x40202060U, 0xe3fcfc1fU, 0x79b1b1c8U, 0xb65b5bedU,
1520 0xd46a6abeU, 0x8dcbcb46U, 0x67bebed9U, 0x7239394bU,
1521 0x944a4adeU, 0x984c4cd4U, 0xb05858e8U, 0x85cfcf4aU,
1522 0xbbd0d06bU, 0xc5efef2aU, 0x4faaaae5U, 0xedfbfb16U,
1523 0x864343c5U, 0x9a4d4dd7U, 0x66333355U, 0x11858594U,
1524 0x8a4545cfU, 0xe9f9f910U, 0x04020206U, 0xfe7f7f81U,
1525 0xa05050f0U, 0x783c3c44U, 0x259f9fbaU, 0x4ba8a8e3U,
1526 0xa25151f3U, 0x5da3a3feU, 0x804040c0U, 0x058f8f8aU,
1527 0x3f9292adU, 0x219d9dbcU, 0x70383848U, 0xf1f5f504U,
1528 0x63bcbcdfU, 0x77b6b6c1U, 0xafdada75U, 0x42212163U,
1529 0x20101030U, 0xe5ffff1aU, 0xfdf3f30eU, 0xbfd2d26dU,
1530 0x81cdcd4cU, 0x180c0c14U, 0x26131335U, 0xc3ecec2fU,
1531 0xbe5f5fe1U, 0x359797a2U, 0x884444ccU, 0x2e171739U,
1532 0x93c4c457U, 0x55a7a7f2U, 0xfc7e7e82U, 0x7a3d3d47U,
1533 0xc86464acU, 0xba5d5de7U, 0x3219192bU, 0xe6737395U,
1534 0xc06060a0U, 0x19818198U, 0x9e4f4fd1U, 0xa3dcdc7fU,
1535 0x44222266U, 0x542a2a7eU, 0x3b9090abU, 0x0b888883U,
1536 0x8c4646caU, 0xc7eeee29U, 0x6bb8b8d3U, 0x2814143cU,
1537 0xa7dede79U, 0xbc5e5ee2U, 0x160b0b1dU, 0xaddbdb76U,
1538 0xdbe0e03bU, 0x64323256U, 0x743a3a4eU, 0x140a0a1eU,
1539 0x924949dbU, 0x0c06060aU, 0x4824246cU, 0xb85c5ce4U,
1540 0x9fc2c25dU, 0xbdd3d36eU, 0x43acacefU, 0xc46262a6U,
1541 0x399191a8U, 0x319595a4U, 0xd3e4e437U, 0xf279798bU,
1542 0xd5e7e732U, 0x8bc8c843U, 0x6e373759U, 0xda6d6db7U,
1543 0x018d8d8cU, 0xb1d5d564U, 0x9c4e4ed2U, 0x49a9a9e0U,
1544 0xd86c6cb4U, 0xac5656faU, 0xf3f4f407U, 0xcfeaea25U,
1545 0xca6565afU, 0xf47a7a8eU, 0x47aeaee9U, 0x10080818U,
1546 0x6fbabad5U, 0xf0787888U, 0x4a25256fU, 0x5c2e2e72U,
1547 0x381c1c24U, 0x57a6a6f1U, 0x73b4b4c7U, 0x97c6c651U,
1548 0xcbe8e823U, 0xa1dddd7cU, 0xe874749cU, 0x3e1f1f21U,
1549 0x964b4bddU, 0x61bdbddcU, 0x0d8b8b86U, 0x0f8a8a85U,
1550 0xe0707090U, 0x7c3e3e42U, 0x71b5b5c4U, 0xcc6666aaU,
1551 0x904848d8U, 0x06030305U, 0xf7f6f601U, 0x1c0e0e12U,
1552 0xc26161a3U, 0x6a35355fU, 0xae5757f9U, 0x69b9b9d0U,
1553 0x17868691U, 0x99c1c158U, 0x3a1d1d27U, 0x279e9eb9U,
1554 0xd9e1e138U, 0xebf8f813U, 0x2b9898b3U, 0x22111133U,
1555 0xd26969bbU, 0xa9d9d970U, 0x078e8e89U, 0x339494a7U,
1556 0x2d9b9bb6U, 0x3c1e1e22U, 0x15878792U, 0xc9e9e920U,
1557 0x87cece49U, 0xaa5555ffU, 0x50282878U, 0xa5dfdf7aU,
1558 0x038c8c8fU, 0x59a1a1f8U, 0x09898980U, 0x1a0d0d17U,
1559 0x65bfbfdaU, 0xd7e6e631U, 0x844242c6U, 0xd06868b8U,
1560 0x824141c3U, 0x299999b0U, 0x5a2d2d77U, 0x1e0f0f11U,
1561 0x7bb0b0cbU, 0xa85454fcU, 0x6dbbbbd6U, 0x2c16163aU,
1564 const u32 Td0[256] = {
1565 0x51f4a750U, 0x7e416553U, 0x1a17a4c3U, 0x3a275e96U,
1566 0x3bab6bcbU, 0x1f9d45f1U, 0xacfa58abU, 0x4be30393U,
1567 0x2030fa55U, 0xad766df6U, 0x88cc7691U, 0xf5024c25U,
1568 0x4fe5d7fcU, 0xc52acbd7U, 0x26354480U, 0xb562a38fU,
1569 0xdeb15a49U, 0x25ba1b67U, 0x45ea0e98U, 0x5dfec0e1U,
1570 0xc32f7502U, 0x814cf012U, 0x8d4697a3U, 0x6bd3f9c6U,
1571 0x038f5fe7U, 0x15929c95U, 0xbf6d7aebU, 0x955259daU,
1572 0xd4be832dU, 0x587421d3U, 0x49e06929U, 0x8ec9c844U,
1573 0x75c2896aU, 0xf48e7978U, 0x99583e6bU, 0x27b971ddU,
1574 0xbee14fb6U, 0xf088ad17U, 0xc920ac66U, 0x7dce3ab4U,
1575 0x63df4a18U, 0xe51a3182U, 0x97513360U, 0x62537f45U,
1576 0xb16477e0U, 0xbb6bae84U, 0xfe81a01cU, 0xf9082b94U,
1577 0x70486858U, 0x8f45fd19U, 0x94de6c87U, 0x527bf8b7U,
1578 0xab73d323U, 0x724b02e2U, 0xe31f8f57U, 0x6655ab2aU,
1579 0xb2eb2807U, 0x2fb5c203U, 0x86c57b9aU, 0xd33708a5U,
1580 0x302887f2U, 0x23bfa5b2U, 0x02036abaU, 0xed16825cU,
1581 0x8acf1c2bU, 0xa779b492U, 0xf307f2f0U, 0x4e69e2a1U,
1582 0x65daf4cdU, 0x0605bed5U, 0xd134621fU, 0xc4a6fe8aU,
1583 0x342e539dU, 0xa2f355a0U, 0x058ae132U, 0xa4f6eb75U,
1584 0x0b83ec39U, 0x4060efaaU, 0x5e719f06U, 0xbd6e1051U,
1585 0x3e218af9U, 0x96dd063dU, 0xdd3e05aeU, 0x4de6bd46U,
1586 0x91548db5U, 0x71c45d05U, 0x0406d46fU, 0x605015ffU,
1587 0x1998fb24U, 0xd6bde997U, 0x894043ccU, 0x67d99e77U,
1588 0xb0e842bdU, 0x07898b88U, 0xe7195b38U, 0x79c8eedbU,
1589 0xa17c0a47U, 0x7c420fe9U, 0xf8841ec9U, 0x00000000U,
1590 0x09808683U, 0x322bed48U, 0x1e1170acU, 0x6c5a724eU,
1591 0xfd0efffbU, 0x0f853856U, 0x3daed51eU, 0x362d3927U,
1592 0x0a0fd964U, 0x685ca621U, 0x9b5b54d1U, 0x24362e3aU,
1593 0x0c0a67b1U, 0x9357e70fU, 0xb4ee96d2U, 0x1b9b919eU,
1594 0x80c0c54fU, 0x61dc20a2U, 0x5a774b69U, 0x1c121a16U,
1595 0xe293ba0aU, 0xc0a02ae5U, 0x3c22e043U, 0x121b171dU,
1596 0x0e090d0bU, 0xf28bc7adU, 0x2db6a8b9U, 0x141ea9c8U,
1597 0x57f11985U, 0xaf75074cU, 0xee99ddbbU, 0xa37f60fdU,
1598 0xf701269fU, 0x5c72f5bcU, 0x44663bc5U, 0x5bfb7e34U,
1599 0x8b432976U, 0xcb23c6dcU, 0xb6edfc68U, 0xb8e4f163U,
1600 0xd731dccaU, 0x42638510U, 0x13972240U, 0x84c61120U,
1601 0x854a247dU, 0xd2bb3df8U, 0xaef93211U, 0xc729a16dU,
1602 0x1d9e2f4bU, 0xdcb230f3U, 0x0d8652ecU, 0x77c1e3d0U,
1603 0x2bb3166cU, 0xa970b999U, 0x119448faU, 0x47e96422U,
1604 0xa8fc8cc4U, 0xa0f03f1aU, 0x567d2cd8U, 0x223390efU,
1605 0x87494ec7U, 0xd938d1c1U, 0x8ccaa2feU, 0x98d40b36U,
1606 0xa6f581cfU, 0xa57ade28U, 0xdab78e26U, 0x3fadbfa4U,
1607 0x2c3a9de4U, 0x5078920dU, 0x6a5fcc9bU, 0x547e4662U,
1608 0xf68d13c2U, 0x90d8b8e8U, 0x2e39f75eU, 0x82c3aff5U,
1609 0x9f5d80beU, 0x69d0937cU, 0x6fd52da9U, 0xcf2512b3U,
1610 0xc8ac993bU, 0x10187da7U, 0xe89c636eU, 0xdb3bbb7bU,
1611 0xcd267809U, 0x6e5918f4U, 0xec9ab701U, 0x834f9aa8U,
1612 0xe6956e65U, 0xaaffe67eU, 0x21bccf08U, 0xef15e8e6U,
1613 0xbae79bd9U, 0x4a6f36ceU, 0xea9f09d4U, 0x29b07cd6U,
1614 0x31a4b2afU, 0x2a3f2331U, 0xc6a59430U, 0x35a266c0U,
1615 0x744ebc37U, 0xfc82caa6U, 0xe090d0b0U, 0x33a7d815U,
1616 0xf104984aU, 0x41ecdaf7U, 0x7fcd500eU, 0x1791f62fU,
1617 0x764dd68dU, 0x43efb04dU, 0xccaa4d54U, 0xe49604dfU,
1618 0x9ed1b5e3U, 0x4c6a881bU, 0xc12c1fb8U, 0x4665517fU,
1619 0x9d5eea04U, 0x018c355dU, 0xfa877473U, 0xfb0b412eU,
1620 0xb3671d5aU, 0x92dbd252U, 0xe9105633U, 0x6dd64713U,
1621 0x9ad7618cU, 0x37a10c7aU, 0x59f8148eU, 0xeb133c89U,
1622 0xcea927eeU, 0xb761c935U, 0xe11ce5edU, 0x7a47b13cU,
1623 0x9cd2df59U, 0x55f2733fU, 0x1814ce79U, 0x73c737bfU,
1624 0x53f7cdeaU, 0x5ffdaa5bU, 0xdf3d6f14U, 0x7844db86U,
1625 0xcaaff381U, 0xb968c43eU, 0x3824342cU, 0xc2a3405fU,
1626 0x161dc372U, 0xbce2250cU, 0x283c498bU, 0xff0d9541U,
1627 0x39a80171U, 0x080cb3deU, 0xd8b4e49cU, 0x6456c190U,
1628 0x7bcb8461U, 0xd532b670U, 0x486c5c74U, 0xd0b85742U,
1631 const u8 Td4s[256] = {
1632 0x52U, 0x09U, 0x6aU, 0xd5U, 0x30U, 0x36U, 0xa5U, 0x38U,
1633 0xbfU, 0x40U, 0xa3U, 0x9eU, 0x81U, 0xf3U, 0xd7U, 0xfbU,
1634 0x7cU, 0xe3U, 0x39U, 0x82U, 0x9bU, 0x2fU, 0xffU, 0x87U,
1635 0x34U, 0x8eU, 0x43U, 0x44U, 0xc4U, 0xdeU, 0xe9U, 0xcbU,
1636 0x54U, 0x7bU, 0x94U, 0x32U, 0xa6U, 0xc2U, 0x23U, 0x3dU,
1637 0xeeU, 0x4cU, 0x95U, 0x0bU, 0x42U, 0xfaU, 0xc3U, 0x4eU,
1638 0x08U, 0x2eU, 0xa1U, 0x66U, 0x28U, 0xd9U, 0x24U, 0xb2U,
1639 0x76U, 0x5bU, 0xa2U, 0x49U, 0x6dU, 0x8bU, 0xd1U, 0x25U,
1640 0x72U, 0xf8U, 0xf6U, 0x64U, 0x86U, 0x68U, 0x98U, 0x16U,
1641 0xd4U, 0xa4U, 0x5cU, 0xccU, 0x5dU, 0x65U, 0xb6U, 0x92U,
1642 0x6cU, 0x70U, 0x48U, 0x50U, 0xfdU, 0xedU, 0xb9U, 0xdaU,
1643 0x5eU, 0x15U, 0x46U, 0x57U, 0xa7U, 0x8dU, 0x9dU, 0x84U,
1644 0x90U, 0xd8U, 0xabU, 0x00U, 0x8cU, 0xbcU, 0xd3U, 0x0aU,
1645 0xf7U, 0xe4U, 0x58U, 0x05U, 0xb8U, 0xb3U, 0x45U, 0x06U,
1646 0xd0U, 0x2cU, 0x1eU, 0x8fU, 0xcaU, 0x3fU, 0x0fU, 0x02U,
1647 0xc1U, 0xafU, 0xbdU, 0x03U, 0x01U, 0x13U, 0x8aU, 0x6bU,
1648 0x3aU, 0x91U, 0x11U, 0x41U, 0x4fU, 0x67U, 0xdcU, 0xeaU,
1649 0x97U, 0xf2U, 0xcfU, 0xceU, 0xf0U, 0xb4U, 0xe6U, 0x73U,
1650 0x96U, 0xacU, 0x74U, 0x22U, 0xe7U, 0xadU, 0x35U, 0x85U,
1651 0xe2U, 0xf9U, 0x37U, 0xe8U, 0x1cU, 0x75U, 0xdfU, 0x6eU,
1652 0x47U, 0xf1U, 0x1aU, 0x71U, 0x1dU, 0x29U, 0xc5U, 0x89U,
1653 0x6fU, 0xb7U, 0x62U, 0x0eU, 0xaaU, 0x18U, 0xbeU, 0x1bU,
1654 0xfcU, 0x56U, 0x3eU, 0x4bU, 0xc6U, 0xd2U, 0x79U, 0x20U,
1655 0x9aU, 0xdbU, 0xc0U, 0xfeU, 0x78U, 0xcdU, 0x5aU, 0xf4U,
1656 0x1fU, 0xddU, 0xa8U, 0x33U, 0x88U, 0x07U, 0xc7U, 0x31U,
1657 0xb1U, 0x12U, 0x10U, 0x59U, 0x27U, 0x80U, 0xecU, 0x5fU,
1658 0x60U, 0x51U, 0x7fU, 0xa9U, 0x19U, 0xb5U, 0x4aU, 0x0dU,
1659 0x2dU, 0xe5U, 0x7aU, 0x9fU, 0x93U, 0xc9U, 0x9cU, 0xefU,
1660 0xa0U, 0xe0U, 0x3bU, 0x4dU, 0xaeU, 0x2aU, 0xf5U, 0xb0U,
1661 0xc8U, 0xebU, 0xbbU, 0x3cU, 0x83U, 0x53U, 0x99U, 0x61U,
1662 0x17U, 0x2bU, 0x04U, 0x7eU, 0xbaU, 0x77U, 0xd6U, 0x26U,
1663 0xe1U, 0x69U, 0x14U, 0x63U, 0x55U, 0x21U, 0x0cU, 0x7dU,
1665 const u8 rcons[] = {
1666 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36
1667 /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
1671 * Expand the cipher key into the encryption key schedule.
1673 * @return the number of rounds for the given cipher key size.
1675 #define ROUND(i, d, s) \
1677 d##0 = TE0(s##0) ^ TE1(s##1) ^ TE2(s##2) ^ TE3(s##3) ^ rk[4 * i]; \
1678 d##1 = TE0(s##1) ^ TE1(s##2) ^ TE2(s##3) ^ TE3(s##0) ^ rk[4 * i + 1]; \
1679 d##2 = TE0(s##2) ^ TE1(s##3) ^ TE2(s##0) ^ TE3(s##1) ^ rk[4 * i + 2]; \
1680 d##3 = TE0(s##3) ^ TE1(s##0) ^ TE2(s##1) ^ TE3(s##2) ^ rk[4 * i + 3]; \
1684 * omac1_aes_128 - One-Key CBC MAC (OMAC1) hash with AES-128 (aka AES-CMAC)
1685 * @key: 128-bit key for the hash operation
1686 * @data: Data buffer for which a MAC is determined
1687 * @data_len: Length of data buffer in bytes
1688 * @mac: Buffer for MAC (128 bits, i.e., 16 bytes)
1689 * Returns: 0 on success, -1 on failure
1691 * This is a mode for using block cipher (AES in this case) for authentication.
1692 * OMAC1 was standardized with the name CMAC by NIST in a Special Publication
1695 void rtw_use_tkipkey_handler(void *FunctionContext)
1697 struct adapter *padapter = (struct adapter *)FunctionContext;
1700 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("^^^rtw_use_tkipkey_handler ^^^\n"));
1702 padapter->securitypriv.busetkipkey = true;
1704 RT_TRACE(_module_rtl871x_security_c_, _drv_err_, ("^^^rtw_use_tkipkey_handler padapter->securitypriv.busetkipkey=%d^^^\n", padapter->securitypriv.busetkipkey));