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 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 */ 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 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 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 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 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 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 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 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 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 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 */ 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 */ 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 */ 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 */ 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 /****************************************/ 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 /************************************************/ 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 /************************************************/ 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 /************************************************/ 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 /************************************************/ 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 /************************************/ 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 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 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 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 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 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 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 */ 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 */ 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 */ 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 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