1 /******************************************************************************
2 *
3 * Copyright(c) 2016 - 2017 Realtek Corporation.
4 *
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.
8 *
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
12 * more details.
13 *
14 *****************************************************************************/
15 #ifdef CONFIG_WAPI_SUPPORT
16
17 #include <linux/unistd.h>
18 #include <linux/etherdevice.h>
19 #include <drv_types.h>
20 #include <rtw_wapi.h>
21
22
23 u32 wapi_debug_component =
24 /* WAPI_INIT |
25 * WAPI_API |
26 * WAPI_TX |
27 * WAPI_RX | */
28 WAPI_ERR ; /* always open err flags on */
29
WapiFreeAllStaInfo(_adapter * padapter)30 void WapiFreeAllStaInfo(_adapter *padapter)
31 {
32 PRT_WAPI_T pWapiInfo;
33 PRT_WAPI_STA_INFO pWapiStaInfo;
34 PRT_WAPI_BKID pWapiBkid;
35
36 WAPI_TRACE(WAPI_INIT, "===========> %s\n", __FUNCTION__);
37 pWapiInfo = &padapter->wapiInfo;
38
39 /* Pust to Idle List */
40 rtw_wapi_return_all_sta_info(padapter);
41
42 /* Sta Info List */
43 while (!list_empty(&(pWapiInfo->wapiSTAIdleList))) {
44 pWapiStaInfo = (PRT_WAPI_STA_INFO)list_entry(pWapiInfo->wapiSTAIdleList.next, RT_WAPI_STA_INFO, list);
45 list_del_init(&pWapiStaInfo->list);
46 }
47
48 /* BKID List */
49 while (!list_empty(&(pWapiInfo->wapiBKIDIdleList))) {
50 pWapiBkid = (PRT_WAPI_BKID)list_entry(pWapiInfo->wapiBKIDIdleList.next, RT_WAPI_BKID, list);
51 list_del_init(&pWapiBkid->list);
52 }
53 WAPI_TRACE(WAPI_INIT, "<=========== %s\n", __FUNCTION__);
54 return;
55 }
56
WapiSetIE(_adapter * padapter)57 void WapiSetIE(_adapter *padapter)
58 {
59 PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
60 /* PRT_WAPI_BKID pWapiBkid; */
61 u16 protocolVer = 1;
62 u16 akmCnt = 1;
63 u16 suiteCnt = 1;
64 u16 capability = 0;
65 u8 OUI[3];
66
67 OUI[0] = 0x00;
68 OUI[1] = 0x14;
69 OUI[2] = 0x72;
70
71 pWapiInfo->wapiIELength = 0;
72 /* protocol version */
73 memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, &protocolVer, 2);
74 pWapiInfo->wapiIELength += 2;
75 /* akm */
76 memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, &akmCnt, 2);
77 pWapiInfo->wapiIELength += 2;
78
79 if (pWapiInfo->bWapiPSK) {
80 memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, OUI, 3);
81 pWapiInfo->wapiIELength += 3;
82 pWapiInfo->wapiIE[pWapiInfo->wapiIELength] = 0x2;
83 pWapiInfo->wapiIELength += 1;
84 } else {
85 memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, OUI, 3);
86 pWapiInfo->wapiIELength += 3;
87 pWapiInfo->wapiIE[pWapiInfo->wapiIELength] = 0x1;
88 pWapiInfo->wapiIELength += 1;
89 }
90
91 /* usk */
92 memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, &suiteCnt, 2);
93 pWapiInfo->wapiIELength += 2;
94 memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, OUI, 3);
95 pWapiInfo->wapiIELength += 3;
96 pWapiInfo->wapiIE[pWapiInfo->wapiIELength] = 0x1;
97 pWapiInfo->wapiIELength += 1;
98
99 /* msk */
100 memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, OUI, 3);
101 pWapiInfo->wapiIELength += 3;
102 pWapiInfo->wapiIE[pWapiInfo->wapiIELength] = 0x1;
103 pWapiInfo->wapiIELength += 1;
104
105 /* Capbility */
106 memcpy(pWapiInfo->wapiIE + pWapiInfo->wapiIELength, &capability, 2);
107 pWapiInfo->wapiIELength += 2;
108 }
109
110
111 /* PN1 > PN2, return 1,
112 * else return 0.
113 */
WapiComparePN(u8 * PN1,u8 * PN2)114 u32 WapiComparePN(u8 *PN1, u8 *PN2)
115 {
116 char i;
117
118 if ((NULL == PN1) || (NULL == PN2))
119 return 1;
120
121 /* overflow case */
122 if ((PN2[15] - PN1[15]) & 0x80)
123 return 1;
124
125 for (i = 16; i > 0; i--) {
126 if (PN1[i - 1] == PN2[i - 1])
127 continue;
128 else if (PN1[i - 1] > PN2[i - 1])
129 return 1;
130 else
131 return 0;
132 }
133
134 return 0;
135 }
136
137 u8
WapiGetEntryForCamWrite(_adapter * padapter,u8 * pMacAddr,u8 KID,BOOLEAN IsMsk)138 WapiGetEntryForCamWrite(_adapter *padapter, u8 *pMacAddr, u8 KID, BOOLEAN IsMsk)
139 {
140 PRT_WAPI_T pWapiInfo = NULL;
141 /* PRT_WAPI_CAM_ENTRY pEntry=NULL; */
142 u8 i = 0;
143 u8 ret = 0xff;
144
145 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
146
147 pWapiInfo = &padapter->wapiInfo;
148
149 /* exist? */
150 for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
151 if (pWapiInfo->wapiCamEntry[i].IsUsed
152 && (_rtw_memcmp(pMacAddr, pWapiInfo->wapiCamEntry[i].PeerMacAddr, ETH_ALEN) == _TRUE)
153 && pWapiInfo->wapiCamEntry[i].keyidx == KID
154 && pWapiInfo->wapiCamEntry[i].type == IsMsk) {
155 ret = pWapiInfo->wapiCamEntry[i].entry_idx; /* cover it */
156 break;
157 }
158 }
159
160 if (i == WAPI_CAM_ENTRY_NUM) { /* not found */
161 for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
162 if (pWapiInfo->wapiCamEntry[i].IsUsed == 0) {
163 pWapiInfo->wapiCamEntry[i].IsUsed = 1;
164 pWapiInfo->wapiCamEntry[i].type = IsMsk;
165 pWapiInfo->wapiCamEntry[i].keyidx = KID;
166 _rtw_memcpy(pWapiInfo->wapiCamEntry[i].PeerMacAddr, pMacAddr, ETH_ALEN);
167 ret = pWapiInfo->wapiCamEntry[i].entry_idx;
168 break;
169 }
170 }
171 }
172
173 WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
174 return ret;
175
176 /*
177 if(RTIsListEmpty(&pWapiInfo->wapiCamIdleList)) {
178 return 0;
179 }
180
181 pEntry = (PRT_WAPI_CAM_ENTRY)RTRemoveHeadList(&pWapiInfo->wapiCamIdleList);
182 RTInsertTailList(&pWapiInfo->wapiCamUsedList, &pEntry->list);
183
184
185 return pEntry->entry_idx;*/
186 }
187
WapiGetEntryForCamClear(_adapter * padapter,u8 * pPeerMac,u8 keyid,u8 IsMsk)188 u8 WapiGetEntryForCamClear(_adapter *padapter, u8 *pPeerMac, u8 keyid, u8 IsMsk)
189 {
190 PRT_WAPI_T pWapiInfo = NULL;
191 u8 i = 0;
192
193 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
194
195 pWapiInfo = &padapter->wapiInfo;
196
197 for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
198 if (pWapiInfo->wapiCamEntry[i].IsUsed
199 && (_rtw_memcmp(pPeerMac, pWapiInfo->wapiCamEntry[i].PeerMacAddr, ETH_ALEN) == _TRUE)
200 && pWapiInfo->wapiCamEntry[i].keyidx == keyid
201 && pWapiInfo->wapiCamEntry[i].type == IsMsk) {
202 pWapiInfo->wapiCamEntry[i].IsUsed = 0;
203 pWapiInfo->wapiCamEntry[i].keyidx = 2;
204 _rtw_memset(pWapiInfo->wapiCamEntry[i].PeerMacAddr, 0, ETH_ALEN);
205
206 WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
207 return pWapiInfo->wapiCamEntry[i].entry_idx;
208 }
209 }
210
211 WAPI_TRACE(WAPI_API, "<====WapiGetReturnCamEntry(), No this cam entry.\n");
212 return 0xff;
213 /*
214 if(RTIsListEmpty(&pWapiInfo->wapiCamUsedList)) {
215 return FALSE;
216 }
217
218 pList = &pWapiInfo->wapiCamUsedList;
219 while(pList->Flink != &pWapiInfo->wapiCamUsedList)
220 {
221 pEntry = (PRT_WAPI_CAM_ENTRY)pList->Flink;
222 if(PlatformCompareMemory(pPeerMac,pEntry->PeerMacAddr, ETHER_ADDRLEN)== 0
223 && keyid == pEntry->keyidx)
224 {
225 RTRemoveEntryList(pList);
226 RTInsertHeadList(&pWapiInfo->wapiCamIdleList, pList);
227 return pEntry->entry_idx;
228 }
229 pList = pList->Flink;
230 }
231
232 return 0;
233 */
234 }
235
236 void
WapiResetAllCamEntry(_adapter * padapter)237 WapiResetAllCamEntry(_adapter *padapter)
238 {
239 PRT_WAPI_T pWapiInfo;
240 int i;
241
242 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
243
244 pWapiInfo = &padapter->wapiInfo;
245
246 for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
247 _rtw_memset(pWapiInfo->wapiCamEntry[i].PeerMacAddr, 0, ETH_ALEN);
248 pWapiInfo->wapiCamEntry[i].IsUsed = 0;
249 pWapiInfo->wapiCamEntry[i].keyidx = 2; /* invalid */
250 pWapiInfo->wapiCamEntry[i].entry_idx = 4 + i * 2;
251 }
252
253 WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
254
255 return;
256 }
257
WapiWriteOneCamEntry(_adapter * padapter,u8 * pMacAddr,u8 KeyId,u8 EntryId,u8 EncAlg,u8 bGroupKey,u8 * pKey)258 u8 WapiWriteOneCamEntry(
259 _adapter *padapter,
260 u8 *pMacAddr,
261 u8 KeyId,
262 u8 EntryId,
263 u8 EncAlg,
264 u8 bGroupKey,
265 u8 *pKey
266 )
267 {
268 u8 retVal = 0;
269 u16 usConfig = 0;
270
271 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
272
273 if (EntryId >= 32) {
274 WAPI_TRACE(WAPI_ERR, "<=== CamAddOneEntry(): ulKeyId exceed!\n");
275 return retVal;
276 }
277
278 usConfig = usConfig | (0x01 << 15) | ((u16)(EncAlg) << 2) | (KeyId);
279
280 if (EncAlg == _SMS4_) {
281 if (bGroupKey == 1)
282 usConfig |= (0x01 << 6);
283 if ((EntryId % 2) == 1) /* ==0 sec key; == 1mic key */
284 usConfig |= (0x01 << 5);
285 }
286
287 write_cam(padapter, EntryId, usConfig, pMacAddr, pKey);
288
289 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
290 return 1;
291 }
292
rtw_wapi_init(_adapter * padapter)293 void rtw_wapi_init(_adapter *padapter)
294 {
295 PRT_WAPI_T pWapiInfo;
296 int i;
297
298 WAPI_TRACE(WAPI_INIT, "===========> %s\n", __FUNCTION__);
299 RT_WAPI_ASSERT_RET(padapter);
300
301 if (!padapter->WapiSupport) {
302 WAPI_TRACE(WAPI_INIT, "<========== %s, WAPI not supported!\n", __FUNCTION__);
303 return;
304 }
305
306 pWapiInfo = &padapter->wapiInfo;
307 pWapiInfo->bWapiEnable = false;
308
309 /* Init BKID List */
310 INIT_LIST_HEAD(&pWapiInfo->wapiBKIDIdleList);
311 INIT_LIST_HEAD(&pWapiInfo->wapiBKIDStoreList);
312 for (i = 0; i < WAPI_MAX_BKID_NUM; i++)
313 list_add_tail(&pWapiInfo->wapiBKID[i].list, &pWapiInfo->wapiBKIDIdleList);
314
315 /* Init STA List */
316 INIT_LIST_HEAD(&pWapiInfo->wapiSTAIdleList);
317 INIT_LIST_HEAD(&pWapiInfo->wapiSTAUsedList);
318 for (i = 0; i < WAPI_MAX_STAINFO_NUM; i++)
319 list_add_tail(&pWapiInfo->wapiSta[i].list, &pWapiInfo->wapiSTAIdleList);
320
321 for (i = 0; i < WAPI_CAM_ENTRY_NUM; i++) {
322 pWapiInfo->wapiCamEntry[i].IsUsed = 0;
323 pWapiInfo->wapiCamEntry[i].keyidx = 2; /* invalid */
324 pWapiInfo->wapiCamEntry[i].entry_idx = 4 + i * 2;
325 }
326
327 WAPI_TRACE(WAPI_INIT, "<========== %s\n", __FUNCTION__);
328 }
329
rtw_wapi_free(_adapter * padapter)330 void rtw_wapi_free(_adapter *padapter)
331 {
332 WAPI_TRACE(WAPI_INIT, "===========> %s\n", __FUNCTION__);
333 RT_WAPI_ASSERT_RET(padapter);
334
335 if (!padapter->WapiSupport) {
336 WAPI_TRACE(WAPI_INIT, "<========== %s, WAPI not supported!\n", __FUNCTION__);
337 return;
338 }
339
340 WapiFreeAllStaInfo(padapter);
341
342 WAPI_TRACE(WAPI_INIT, "<========== %s\n", __FUNCTION__);
343 }
344
rtw_wapi_disable_tx(_adapter * padapter)345 void rtw_wapi_disable_tx(_adapter *padapter)
346 {
347 WAPI_TRACE(WAPI_INIT, "===========> %s\n", __FUNCTION__);
348 RT_WAPI_ASSERT_RET(padapter);
349
350 if (!padapter->WapiSupport) {
351 WAPI_TRACE(WAPI_INIT, "<========== %s, WAPI not supported!\n", __FUNCTION__);
352 return;
353 }
354
355 padapter->wapiInfo.wapiTxMsk.bTxEnable = false;
356 padapter->wapiInfo.wapiTxMsk.bSet = false;
357
358 WAPI_TRACE(WAPI_INIT, "<========== %s\n", __FUNCTION__);
359 }
360
rtw_wapi_is_wai_packet(_adapter * padapter,u8 * pkt_data)361 u8 rtw_wapi_is_wai_packet(_adapter *padapter, u8 *pkt_data)
362 {
363 PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
364 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
365 struct security_priv *psecuritypriv = &padapter->securitypriv;
366 PRT_WAPI_STA_INFO pWapiSta = NULL;
367 u8 WaiPkt = 0, *pTaddr, bFind = false;
368 u8 Offset_TypeWAI = 0 ; /* (mac header len + llc length) */
369
370 WAPI_TRACE(WAPI_TX | WAPI_RX, "===========> %s\n", __FUNCTION__);
371
372 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
373 WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
374 return 0;
375 }
376
377 Offset_TypeWAI = 24 + 6 ;
378
379 /* YJ,add,091103. Data frame may also have skb->data[30]=0x88 and skb->data[31]=0xb4. */
380 if ((pkt_data[1] & 0x40) != 0) {
381 /* RTW_INFO("data is privacy\n"); */
382 return 0;
383 }
384
385 pTaddr = get_addr2_ptr(pkt_data);
386 if (list_empty(&pWapiInfo->wapiSTAUsedList))
387 bFind = false;
388 else {
389 list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
390 if (_rtw_memcmp(pTaddr, pWapiSta->PeerMacAddr, 6) == _TRUE) {
391 bFind = true;
392 break;
393 }
394 }
395 }
396
397 WAPI_TRACE(WAPI_TX | WAPI_RX, "%s: bFind=%d pTaddr="MAC_FMT"\n", __FUNCTION__, bFind, MAC_ARG(pTaddr));
398
399 if (pkt_data[0] == WIFI_QOS_DATA_TYPE)
400 Offset_TypeWAI += 2;
401
402 /* 88b4? */
403 if ((pkt_data[Offset_TypeWAI] == 0x88) && (pkt_data[Offset_TypeWAI + 1] == 0xb4)) {
404 WaiPkt = pkt_data[Offset_TypeWAI + 5];
405
406 psecuritypriv->hw_decrypted = _TRUE;
407 } else
408 WAPI_TRACE(WAPI_TX | WAPI_RX, "%s(): non wai packet\n", __FUNCTION__);
409
410 WAPI_TRACE(WAPI_TX | WAPI_RX, "%s(): Recvd WAI frame. IsWAIPkt(%d)\n", __FUNCTION__, WaiPkt);
411
412 return WaiPkt;
413 }
414
415
rtw_wapi_update_info(_adapter * padapter,union recv_frame * precv_frame)416 void rtw_wapi_update_info(_adapter *padapter, union recv_frame *precv_frame)
417 {
418 PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
419 struct recv_frame_hdr *precv_hdr;
420 u8 *ptr;
421 u8 *pTA;
422 u8 *pRecvPN;
423
424
425 WAPI_TRACE(WAPI_RX, "===========> %s\n", __FUNCTION__);
426
427 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
428 WAPI_TRACE(WAPI_RX, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
429 return;
430 }
431
432 precv_hdr = &precv_frame->u.hdr;
433 ptr = precv_hdr->rx_data;
434
435 if (precv_hdr->attrib.qos == 1)
436 precv_hdr->UserPriority = GetTid(ptr);
437 else
438 precv_hdr->UserPriority = 0;
439
440 pTA = get_addr2_ptr(ptr);
441 _rtw_memcpy((u8 *)precv_hdr->WapiSrcAddr, pTA, 6);
442 pRecvPN = ptr + precv_hdr->attrib.hdrlen + 2;
443 _rtw_memcpy((u8 *)precv_hdr->WapiTempPN, pRecvPN, 16);
444
445 WAPI_TRACE(WAPI_RX, "<========== %s\n", __FUNCTION__);
446 }
447
448 /****************************************************************************
449 TRUE-----------------Drop
450 FALSE---------------- handle
451 add to support WAPI to N-mode
452 *****************************************************************************/
rtw_wapi_check_for_drop(_adapter * padapter,union recv_frame * precv_frame,u8 * ehdr_ops)453 u8 rtw_wapi_check_for_drop(
454 _adapter *padapter,
455 union recv_frame *precv_frame,
456 u8 *ehdr_ops
457 )
458 {
459 PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
460 u8 *pLastRecvPN = NULL;
461 u8 bFind = false;
462 PRT_WAPI_STA_INFO pWapiSta = NULL;
463 u8 bDrop = false;
464 struct recv_frame_hdr *precv_hdr = &precv_frame->u.hdr;
465 u8 WapiAEPNInitialValueSrc[16] = {0x37, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
466 u8 WapiAEMultiCastPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
467 u8 *ptr = ehdr_ops;
468 int i;
469
470 WAPI_TRACE(WAPI_RX, "===========> %s\n", __FUNCTION__);
471
472 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
473 WAPI_TRACE(WAPI_RX, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
474 return false;
475 }
476
477 if (precv_hdr->bIsWaiPacket != 0) {
478 if (precv_hdr->bIsWaiPacket == 0x8) {
479 WAPI_DATA(WAPI_RX, "rtw_wapi_check_for_drop() dump packet", ptr, 50);
480
481 for (i = 0; i < 16; i++) {
482 if (ptr[i + 27] != 0)
483 break;
484 }
485
486 if (i == 16) {
487 WAPI_TRACE(WAPI_RX, "rtw_wapi_check_for_drop: drop with zero BKID\n");
488 return true;
489 } else
490 return false;
491 } else
492 return false;
493 }
494
495 if (list_empty(&pWapiInfo->wapiSTAUsedList))
496 bFind = false;
497 else {
498 list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
499 if (_rtw_memcmp(precv_hdr->WapiSrcAddr, pWapiSta->PeerMacAddr, ETH_ALEN) == _TRUE) {
500 bFind = true;
501 break;
502 }
503 }
504 }
505 WAPI_TRACE(WAPI_RX, "%s: bFind=%d prxb->WapiSrcAddr="MAC_FMT"\n", __FUNCTION__, bFind, MAC_ARG(precv_hdr->WapiSrcAddr));
506
507 if (bFind) {
508 if (IS_MCAST(precv_hdr->attrib.ra)) {
509 WAPI_TRACE(WAPI_RX, "rtw_wapi_check_for_drop: multicast case\n");
510 pLastRecvPN = pWapiSta->lastRxMulticastPN;
511 } else {
512 WAPI_TRACE(WAPI_RX, "rtw_wapi_check_for_drop: unicast case\n");
513 switch (precv_hdr->UserPriority) {
514 case 0:
515 case 3:
516 pLastRecvPN = pWapiSta->lastRxUnicastPNBEQueue;
517 break;
518 case 1:
519 case 2:
520 pLastRecvPN = pWapiSta->lastRxUnicastPNBKQueue;
521 break;
522 case 4:
523 case 5:
524 pLastRecvPN = pWapiSta->lastRxUnicastPNVIQueue;
525 break;
526 case 6:
527 case 7:
528 pLastRecvPN = pWapiSta->lastRxUnicastPNVOQueue;
529 break;
530 default:
531 WAPI_TRACE(WAPI_ERR, "%s: Unknown TID\n", __FUNCTION__);
532 break;
533 }
534 }
535
536 if (!WapiComparePN(precv_hdr->WapiTempPN, pLastRecvPN)) {
537 WAPI_TRACE(WAPI_RX, "%s: Equal PN!!\n", __FUNCTION__);
538 if (IS_MCAST(precv_hdr->attrib.ra))
539 _rtw_memcpy(pLastRecvPN, WapiAEMultiCastPNInitialValueSrc, 16);
540 else
541 _rtw_memcpy(pLastRecvPN, WapiAEPNInitialValueSrc, 16);
542 bDrop = true;
543 } else
544 _rtw_memcpy(pLastRecvPN, precv_hdr->WapiTempPN, 16);
545 }
546
547 WAPI_TRACE(WAPI_RX, "<========== %s\n", __FUNCTION__);
548 return bDrop;
549 }
550
rtw_build_probe_resp_wapi_ie(_adapter * padapter,unsigned char * pframe,struct pkt_attrib * pattrib)551 void rtw_build_probe_resp_wapi_ie(_adapter *padapter, unsigned char *pframe, struct pkt_attrib *pattrib)
552 {
553 PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
554 u8 WapiIELength = 0;
555
556 WAPI_TRACE(WAPI_MLME, "===========> %s\n", __FUNCTION__);
557
558 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
559 WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported!\n", __FUNCTION__);
560 return;
561 }
562
563 WapiSetIE(padapter);
564 WapiIELength = pWapiInfo->wapiIELength;
565 pframe[0] = _WAPI_IE_;
566 pframe[1] = WapiIELength;
567 _rtw_memcpy(pframe + 2, pWapiInfo->wapiIE, WapiIELength);
568 pframe += WapiIELength + 2;
569 pattrib->pktlen += WapiIELength + 2;
570
571 WAPI_TRACE(WAPI_MLME, "<========== %s\n", __FUNCTION__);
572 }
573
rtw_build_beacon_wapi_ie(_adapter * padapter,unsigned char * pframe,struct pkt_attrib * pattrib)574 void rtw_build_beacon_wapi_ie(_adapter *padapter, unsigned char *pframe, struct pkt_attrib *pattrib)
575 {
576 PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
577 u8 WapiIELength = 0;
578 WAPI_TRACE(WAPI_MLME, "===========> %s\n", __FUNCTION__);
579
580 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
581 WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported!\n", __FUNCTION__);
582 return;
583 }
584
585 WapiSetIE(padapter);
586 WapiIELength = pWapiInfo->wapiIELength;
587 pframe[0] = _WAPI_IE_;
588 pframe[1] = WapiIELength;
589 _rtw_memcpy(pframe + 2, pWapiInfo->wapiIE, WapiIELength);
590 pframe += WapiIELength + 2;
591 pattrib->pktlen += WapiIELength + 2;
592
593 WAPI_TRACE(WAPI_MLME, "<========== %s\n", __FUNCTION__);
594 }
595
rtw_build_assoc_req_wapi_ie(_adapter * padapter,unsigned char * pframe,struct pkt_attrib * pattrib)596 void rtw_build_assoc_req_wapi_ie(_adapter *padapter, unsigned char *pframe, struct pkt_attrib *pattrib)
597 {
598 PRT_WAPI_BKID pWapiBKID;
599 u16 bkidNum;
600 PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
601 u8 WapiIELength = 0;
602
603 WAPI_TRACE(WAPI_MLME, "===========> %s\n", __FUNCTION__);
604
605 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
606 WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported!\n", __FUNCTION__);
607 return;
608 }
609
610 WapiSetIE(padapter);
611 WapiIELength = pWapiInfo->wapiIELength;
612 bkidNum = 0;
613 if (!list_empty(&(pWapiInfo->wapiBKIDStoreList))) {
614 list_for_each_entry(pWapiBKID, &pWapiInfo->wapiBKIDStoreList, list) {
615 bkidNum++;
616 _rtw_memcpy(pWapiInfo->wapiIE + WapiIELength + 2, pWapiBKID->bkid, 16);
617 WapiIELength += 16;
618 }
619 }
620 _rtw_memcpy(pWapiInfo->wapiIE + WapiIELength, &bkidNum, 2);
621 WapiIELength += 2;
622
623 pframe[0] = _WAPI_IE_;
624 pframe[1] = WapiIELength;
625 _rtw_memcpy(pframe + 2, pWapiInfo->wapiIE, WapiIELength);
626 pframe += WapiIELength + 2;
627 pattrib->pktlen += WapiIELength + 2;
628 WAPI_TRACE(WAPI_MLME, "<========== %s\n", __FUNCTION__);
629 }
630
rtw_wapi_on_assoc_ok(_adapter * padapter,PNDIS_802_11_VARIABLE_IEs pIE)631 void rtw_wapi_on_assoc_ok(_adapter *padapter, PNDIS_802_11_VARIABLE_IEs pIE)
632 {
633 PRT_WAPI_T pWapiInfo = &(padapter->wapiInfo);
634 PRT_WAPI_STA_INFO pWapiSta;
635 u8 WapiAEPNInitialValueSrc[16] = {0x37, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
636 /* u8 WapiASUEPNInitialValueSrc[16] = {0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C,0x36,0x5C} ; */
637 u8 WapiAEMultiCastPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
638
639 WAPI_TRACE(WAPI_MLME, "===========> %s\n", __FUNCTION__);
640
641 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
642 WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
643 return;
644 }
645
646 pWapiSta = (PRT_WAPI_STA_INFO)list_entry(pWapiInfo->wapiSTAIdleList.next, RT_WAPI_STA_INFO, list);
647 list_del_init(&pWapiSta->list);
648 list_add_tail(&pWapiSta->list, &pWapiInfo->wapiSTAUsedList);
649 _rtw_memcpy(pWapiSta->PeerMacAddr, padapter->mlmeextpriv.mlmext_info.network.MacAddress, 6);
650 _rtw_memcpy(pWapiSta->lastRxMulticastPN, WapiAEMultiCastPNInitialValueSrc, 16);
651 _rtw_memcpy(pWapiSta->lastRxUnicastPN, WapiAEPNInitialValueSrc, 16);
652
653 /* For chenk PN error with Qos Data after s3: add by ylb 20111114 */
654 _rtw_memcpy(pWapiSta->lastRxUnicastPNBEQueue, WapiAEPNInitialValueSrc, 16);
655 _rtw_memcpy(pWapiSta->lastRxUnicastPNBKQueue, WapiAEPNInitialValueSrc, 16);
656 _rtw_memcpy(pWapiSta->lastRxUnicastPNVIQueue, WapiAEPNInitialValueSrc, 16);
657 _rtw_memcpy(pWapiSta->lastRxUnicastPNVOQueue, WapiAEPNInitialValueSrc, 16);
658
659 WAPI_TRACE(WAPI_MLME, "<========== %s\n", __FUNCTION__);
660 }
661
662
rtw_wapi_return_one_sta_info(_adapter * padapter,u8 * MacAddr)663 void rtw_wapi_return_one_sta_info(_adapter *padapter, u8 *MacAddr)
664 {
665 PRT_WAPI_T pWapiInfo;
666 PRT_WAPI_STA_INFO pWapiStaInfo = NULL;
667 PRT_WAPI_BKID pWapiBkid = NULL;
668 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
669
670 pWapiInfo = &padapter->wapiInfo;
671
672 WAPI_TRACE(WAPI_API, "==========> %s\n", __FUNCTION__);
673
674 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
675 WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
676 return;
677 }
678
679 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
680 while (!list_empty(&(pWapiInfo->wapiBKIDStoreList))) {
681 pWapiBkid = (PRT_WAPI_BKID)list_entry(pWapiInfo->wapiBKIDStoreList.next, RT_WAPI_BKID, list);
682 list_del_init(&pWapiBkid->list);
683 _rtw_memset(pWapiBkid->bkid, 0, 16);
684 list_add_tail(&pWapiBkid->list, &pWapiInfo->wapiBKIDIdleList);
685 }
686 }
687
688
689 WAPI_TRACE(WAPI_API, " %s: after clear bkid\n", __FUNCTION__);
690
691
692 /* Remove STA info */
693 if (list_empty(&(pWapiInfo->wapiSTAUsedList))) {
694 WAPI_TRACE(WAPI_API, " %s: wapiSTAUsedList is null\n", __FUNCTION__);
695 return;
696 } else {
697
698 WAPI_TRACE(WAPI_API, " %s: wapiSTAUsedList is not null\n", __FUNCTION__);
699 #if 0
700 pWapiStaInfo = (PRT_WAPI_STA_INFO)list_entry((pWapiInfo->wapiSTAUsedList.next), RT_WAPI_STA_INFO, list);
701
702 list_for_each_entry(pWapiStaInfo, &(pWapiInfo->wapiSTAUsedList), list) {
703
704 RTW_INFO("MAC Addr %02x-%02x-%02x-%02x-%02x-%02x\n", MacAddr[0], MacAddr[1], MacAddr[2], MacAddr[3], MacAddr[4], MacAddr[5]);
705
706
707 RTW_INFO("peer Addr %02x-%02x-%02x-%02x-%02x-%02x\n", pWapiStaInfo->PeerMacAddr[0], pWapiStaInfo->PeerMacAddr[1], pWapiStaInfo->PeerMacAddr[2], pWapiStaInfo->PeerMacAddr[3],
708 pWapiStaInfo->PeerMacAddr[4], pWapiStaInfo->PeerMacAddr[5]);
709
710 if (pWapiStaInfo == NULL) {
711 WAPI_TRACE(WAPI_API, " %s: pWapiStaInfo == NULL Case\n", __FUNCTION__);
712 return;
713 }
714
715 if (pWapiStaInfo->PeerMacAddr == NULL) {
716 WAPI_TRACE(WAPI_API, " %s: pWapiStaInfo->PeerMacAddr == NULL Case\n", __FUNCTION__);
717 return;
718 }
719
720 if (MacAddr == NULL) {
721 WAPI_TRACE(WAPI_API, " %s: MacAddr == NULL Case\n", __FUNCTION__);
722 return;
723 }
724
725 if (_rtw_memcmp(pWapiStaInfo->PeerMacAddr, MacAddr, ETH_ALEN) == _TRUE) {
726 pWapiStaInfo->bAuthenticateInProgress = false;
727 pWapiStaInfo->bSetkeyOk = false;
728 _rtw_memset(pWapiStaInfo->PeerMacAddr, 0, ETH_ALEN);
729 list_del_init(&pWapiStaInfo->list);
730 list_add_tail(&pWapiStaInfo->list, &pWapiInfo->wapiSTAIdleList);
731 break;
732 }
733
734 }
735 #endif
736
737 while (!list_empty(&(pWapiInfo->wapiSTAUsedList))) {
738 pWapiStaInfo = (PRT_WAPI_STA_INFO)list_entry(pWapiInfo->wapiSTAUsedList.next, RT_WAPI_STA_INFO, list);
739
740 RTW_INFO("peer Addr %02x-%02x-%02x-%02x-%02x-%02x\n", pWapiStaInfo->PeerMacAddr[0], pWapiStaInfo->PeerMacAddr[1], pWapiStaInfo->PeerMacAddr[2], pWapiStaInfo->PeerMacAddr[3],
741 pWapiStaInfo->PeerMacAddr[4], pWapiStaInfo->PeerMacAddr[5]);
742
743 list_del_init(&pWapiStaInfo->list);
744 memset(pWapiStaInfo->PeerMacAddr, 0, ETH_ALEN);
745 pWapiStaInfo->bSetkeyOk = 0;
746 list_add_tail(&pWapiStaInfo->list, &pWapiInfo->wapiSTAIdleList);
747 }
748
749 }
750
751 WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
752 return;
753 }
754
rtw_wapi_return_all_sta_info(_adapter * padapter)755 void rtw_wapi_return_all_sta_info(_adapter *padapter)
756 {
757 PRT_WAPI_T pWapiInfo;
758 PRT_WAPI_STA_INFO pWapiStaInfo;
759 PRT_WAPI_BKID pWapiBkid;
760 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
761
762 pWapiInfo = &padapter->wapiInfo;
763
764 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable)) {
765 WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
766 return;
767 }
768
769 /* Sta Info List */
770 while (!list_empty(&(pWapiInfo->wapiSTAUsedList))) {
771 pWapiStaInfo = (PRT_WAPI_STA_INFO)list_entry(pWapiInfo->wapiSTAUsedList.next, RT_WAPI_STA_INFO, list);
772 list_del_init(&pWapiStaInfo->list);
773 memset(pWapiStaInfo->PeerMacAddr, 0, ETH_ALEN);
774 pWapiStaInfo->bSetkeyOk = 0;
775 list_add_tail(&pWapiStaInfo->list, &pWapiInfo->wapiSTAIdleList);
776 }
777
778 /* BKID List */
779 while (!list_empty(&(pWapiInfo->wapiBKIDStoreList))) {
780 pWapiBkid = (PRT_WAPI_BKID)list_entry(pWapiInfo->wapiBKIDStoreList.next, RT_WAPI_BKID, list);
781 list_del_init(&pWapiBkid->list);
782 memset(pWapiBkid->bkid, 0, 16);
783 list_add_tail(&pWapiBkid->list, &pWapiInfo->wapiBKIDIdleList);
784 }
785 WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
786 }
787
CAM_empty_entry(PADAPTER Adapter,u8 ucIndex)788 void CAM_empty_entry(
789 PADAPTER Adapter,
790 u8 ucIndex
791 )
792 {
793 rtw_hal_set_hwreg(Adapter, HW_VAR_CAM_EMPTY_ENTRY, (u8 *)(&ucIndex));
794 }
795
rtw_wapi_clear_cam_entry(_adapter * padapter,u8 * pMacAddr)796 void rtw_wapi_clear_cam_entry(_adapter *padapter, u8 *pMacAddr)
797 {
798 u8 UcIndex = 0;
799
800 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
801
802 if ((!padapter->WapiSupport) || (!padapter->wapiInfo.bWapiEnable)) {
803 WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
804 return;
805 }
806
807 UcIndex = WapiGetEntryForCamClear(padapter, pMacAddr, 0, 0);
808 if (UcIndex != 0xff) {
809 /* CAM_mark_invalid(Adapter, UcIndex); */
810 CAM_empty_entry(padapter, UcIndex);
811 }
812
813 UcIndex = WapiGetEntryForCamClear(padapter, pMacAddr, 1, 0);
814 if (UcIndex != 0xff) {
815 /* CAM_mark_invalid(Adapter, UcIndex); */
816 CAM_empty_entry(padapter, UcIndex);
817 }
818
819 UcIndex = WapiGetEntryForCamClear(padapter, pMacAddr, 0, 1);
820 if (UcIndex != 0xff) {
821 /* CAM_mark_invalid(Adapter, UcIndex); */
822 CAM_empty_entry(padapter, UcIndex);
823 }
824
825 UcIndex = WapiGetEntryForCamClear(padapter, pMacAddr, 1, 1);
826 if (UcIndex != 0xff) {
827 /* CAM_mark_invalid(padapter, UcIndex); */
828 CAM_empty_entry(padapter, UcIndex);
829 }
830
831 WAPI_TRACE(WAPI_API, "<========== %s\n", __FUNCTION__);
832 }
833
rtw_wapi_clear_all_cam_entry(_adapter * padapter)834 void rtw_wapi_clear_all_cam_entry(_adapter *padapter)
835 {
836 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
837
838 if ((!padapter->WapiSupport) || (!padapter->wapiInfo.bWapiEnable)) {
839 WAPI_TRACE(WAPI_MLME, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
840 return;
841 }
842
843 invalidate_cam_all(padapter); /* is this ok? */
844 WapiResetAllCamEntry(padapter);
845
846 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
847 }
848
rtw_wapi_set_key(_adapter * padapter,RT_WAPI_KEY * pWapiKey,RT_WAPI_STA_INFO * pWapiSta,u8 bGroupKey,u8 bUseDefaultKey)849 void rtw_wapi_set_key(_adapter *padapter, RT_WAPI_KEY *pWapiKey, RT_WAPI_STA_INFO *pWapiSta, u8 bGroupKey, u8 bUseDefaultKey)
850 {
851 PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
852 u8 *pMacAddr = pWapiSta->PeerMacAddr;
853 u32 EntryId = 0;
854 BOOLEAN IsPairWise = false ;
855 u8 EncAlgo;
856
857 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
858
859 if ((!padapter->WapiSupport) || (!padapter->wapiInfo.bWapiEnable)) {
860 WAPI_TRACE(WAPI_API, "<========== %s, WAPI not supported or not enabled!\n", __FUNCTION__);
861 return;
862 }
863
864 EncAlgo = _SMS4_;
865
866 /* For Tx bc/mc pkt,use defualt key entry */
867 if (bUseDefaultKey) {
868 /* when WAPI update key, keyid will be 0 or 1 by turns. */
869 if (pWapiKey->keyId == 0)
870 EntryId = 0;
871 else
872 EntryId = 2;
873 } else {
874 /* tx/rx unicast pkt, or rx broadcast, find the key entry by peer's MacAddr */
875 EntryId = WapiGetEntryForCamWrite(padapter, pMacAddr, pWapiKey->keyId, bGroupKey);
876 }
877
878 if (EntryId == 0xff) {
879 WAPI_TRACE(WAPI_API, "===>No entry for WAPI setkey! !!\n");
880 return;
881 }
882
883 /* EntryId is also used to diff Sec key and Mic key */
884 /* Sec Key */
885 WapiWriteOneCamEntry(padapter,
886 pMacAddr,
887 pWapiKey->keyId, /* keyid */
888 EntryId, /* entry */
889 EncAlgo, /* type */
890 bGroupKey, /* pairwise or group key */
891 pWapiKey->dataKey);
892 /* MIC key */
893 WapiWriteOneCamEntry(padapter,
894 pMacAddr,
895 pWapiKey->keyId, /* keyid */
896 EntryId + 1, /* entry */
897 EncAlgo, /* type */
898 bGroupKey, /* pairwise or group key */
899 pWapiKey->micKey);
900
901 WAPI_TRACE(WAPI_API, "Set Wapi Key :KeyId:%d,EntryId:%d,PairwiseKey:%d.\n", pWapiKey->keyId, EntryId, !bGroupKey);
902 WAPI_TRACE(WAPI_API, "===========> %s\n", __FUNCTION__);
903
904 }
905
906 #if 0
907 /* YJ,test,091013 */
908 void wapi_test_set_key(struct _adapter *padapter, u8 *buf)
909 {
910 /*Data: keyType(1) + bTxEnable(1) + bAuthenticator(1) + bUpdate(1) + PeerAddr(6) + DataKey(16) + MicKey(16) + KeyId(1)*/
911 PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
912 PRT_WAPI_BKID pWapiBkid;
913 PRT_WAPI_STA_INFO pWapiSta;
914 u8 data[43];
915 bool bTxEnable;
916 bool bUpdate;
917 bool bAuthenticator;
918 u8 PeerAddr[6];
919 u8 WapiAEPNInitialValueSrc[16] = {0x37, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
920 u8 WapiASUEPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
921 u8 WapiAEMultiCastPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
922
923 WAPI_TRACE(WAPI_INIT, "===========>%s\n", __FUNCTION__);
924
925 if (!padapter->WapiSupport)
926 return;
927
928 copy_from_user(data, buf, 43);
929 bTxEnable = data[1];
930 bAuthenticator = data[2];
931 bUpdate = data[3];
932 memcpy(PeerAddr, data + 4, 6);
933
934 if (data[0] == 0x3) {
935 if (!list_empty(&(pWapiInfo->wapiBKIDIdleList))) {
936 pWapiBkid = (PRT_WAPI_BKID)list_entry(pWapiInfo->wapiBKIDIdleList.next, RT_WAPI_BKID, list);
937 list_del_init(&pWapiBkid->list);
938 memcpy(pWapiBkid->bkid, data + 10, 16);
939 WAPI_DATA(WAPI_INIT, "SetKey - BKID", pWapiBkid->bkid, 16);
940 list_add_tail(&pWapiBkid->list, &pWapiInfo->wapiBKIDStoreList);
941 }
942 } else {
943 list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
944 if (!memcmp(pWapiSta->PeerMacAddr, PeerAddr, 6)) {
945 pWapiSta->bAuthenticatorInUpdata = false;
946 switch (data[0]) {
947 case 1: /* usk */
948 if (bAuthenticator) { /* authenticator */
949 memcpy(pWapiSta->lastTxUnicastPN, WapiAEPNInitialValueSrc, 16);
950 if (!bUpdate) { /* first */
951 WAPI_TRACE(WAPI_INIT, "AE fisrt set usk\n");
952 pWapiSta->wapiUsk.bSet = true;
953 memcpy(pWapiSta->wapiUsk.dataKey, data + 10, 16);
954 memcpy(pWapiSta->wapiUsk.micKey, data + 26, 16);
955 pWapiSta->wapiUsk.keyId = *(data + 42);
956 pWapiSta->wapiUsk.bTxEnable = true;
957 WAPI_DATA(WAPI_INIT, "SetKey - AE USK Data Key", pWapiSta->wapiUsk.dataKey, 16);
958 WAPI_DATA(WAPI_INIT, "SetKey - AE USK Mic Key", pWapiSta->wapiUsk.micKey, 16);
959 } else { /* update */
960 WAPI_TRACE(WAPI_INIT, "AE update usk\n");
961 pWapiSta->wapiUskUpdate.bSet = true;
962 pWapiSta->bAuthenticatorInUpdata = true;
963 memcpy(pWapiSta->wapiUskUpdate.dataKey, data + 10, 16);
964 memcpy(pWapiSta->wapiUskUpdate.micKey, data + 26, 16);
965 memcpy(pWapiSta->lastRxUnicastPNBEQueue, WapiASUEPNInitialValueSrc, 16);
966 memcpy(pWapiSta->lastRxUnicastPNBKQueue, WapiASUEPNInitialValueSrc, 16);
967 memcpy(pWapiSta->lastRxUnicastPNVIQueue, WapiASUEPNInitialValueSrc, 16);
968 memcpy(pWapiSta->lastRxUnicastPNVOQueue, WapiASUEPNInitialValueSrc, 16);
969 memcpy(pWapiSta->lastRxUnicastPN, WapiASUEPNInitialValueSrc, 16);
970 pWapiSta->wapiUskUpdate.keyId = *(data + 42);
971 pWapiSta->wapiUskUpdate.bTxEnable = true;
972 }
973 } else {
974 if (!bUpdate) {
975 WAPI_TRACE(WAPI_INIT, "ASUE fisrt set usk\n");
976 if (bTxEnable) {
977 pWapiSta->wapiUsk.bTxEnable = true;
978 memcpy(pWapiSta->lastTxUnicastPN, WapiASUEPNInitialValueSrc, 16);
979 } else {
980 pWapiSta->wapiUsk.bSet = true;
981 memcpy(pWapiSta->wapiUsk.dataKey, data + 10, 16);
982 memcpy(pWapiSta->wapiUsk.micKey, data + 26, 16);
983 pWapiSta->wapiUsk.keyId = *(data + 42);
984 pWapiSta->wapiUsk.bTxEnable = false;
985 }
986 } else {
987 WAPI_TRACE(WAPI_INIT, "ASUE update usk\n");
988 if (bTxEnable) {
989 pWapiSta->wapiUskUpdate.bTxEnable = true;
990 if (pWapiSta->wapiUskUpdate.bSet) {
991 memcpy(pWapiSta->wapiUsk.dataKey, pWapiSta->wapiUskUpdate.dataKey, 16);
992 memcpy(pWapiSta->wapiUsk.micKey, pWapiSta->wapiUskUpdate.micKey, 16);
993 pWapiSta->wapiUsk.keyId = pWapiSta->wapiUskUpdate.keyId;
994 memcpy(pWapiSta->lastRxUnicastPNBEQueue, WapiASUEPNInitialValueSrc, 16);
995 memcpy(pWapiSta->lastRxUnicastPNBKQueue, WapiASUEPNInitialValueSrc, 16);
996 memcpy(pWapiSta->lastRxUnicastPNVIQueue, WapiASUEPNInitialValueSrc, 16);
997 memcpy(pWapiSta->lastRxUnicastPNVOQueue, WapiASUEPNInitialValueSrc, 16);
998 memcpy(pWapiSta->lastRxUnicastPN, WapiASUEPNInitialValueSrc, 16);
999 pWapiSta->wapiUskUpdate.bTxEnable = false;
1000 pWapiSta->wapiUskUpdate.bSet = false;
1001 }
1002 memcpy(pWapiSta->lastTxUnicastPN, WapiASUEPNInitialValueSrc, 16);
1003 } else {
1004 pWapiSta->wapiUskUpdate.bSet = true;
1005 memcpy(pWapiSta->wapiUskUpdate.dataKey, data + 10, 16);
1006 memcpy(pWapiSta->wapiUskUpdate.micKey, data + 26, 16);
1007 pWapiSta->wapiUskUpdate.keyId = *(data + 42);
1008 pWapiSta->wapiUskUpdate.bTxEnable = false;
1009 }
1010 }
1011 }
1012 break;
1013 case 2: /* msk */
1014 if (bAuthenticator) { /* authenticator */
1015 pWapiInfo->wapiTxMsk.bSet = true;
1016 memcpy(pWapiInfo->wapiTxMsk.dataKey, data + 10, 16);
1017 memcpy(pWapiInfo->wapiTxMsk.micKey, data + 26, 16);
1018 pWapiInfo->wapiTxMsk.keyId = *(data + 42);
1019 pWapiInfo->wapiTxMsk.bTxEnable = true;
1020 memcpy(pWapiInfo->lastTxMulticastPN, WapiAEMultiCastPNInitialValueSrc, 16);
1021
1022 if (!bUpdate) { /* first */
1023 WAPI_TRACE(WAPI_INIT, "AE fisrt set msk\n");
1024 if (!pWapiSta->bSetkeyOk)
1025 pWapiSta->bSetkeyOk = true;
1026 pWapiInfo->bFirstAuthentiateInProgress = false;
1027 } else /* update */
1028 WAPI_TRACE(WAPI_INIT, "AE update msk\n");
1029
1030 WAPI_DATA(WAPI_INIT, "SetKey - AE MSK Data Key", pWapiInfo->wapiTxMsk.dataKey, 16);
1031 WAPI_DATA(WAPI_INIT, "SetKey - AE MSK Mic Key", pWapiInfo->wapiTxMsk.micKey, 16);
1032 } else {
1033 if (!bUpdate) {
1034 WAPI_TRACE(WAPI_INIT, "ASUE fisrt set msk\n");
1035 pWapiSta->wapiMsk.bSet = true;
1036 memcpy(pWapiSta->wapiMsk.dataKey, data + 10, 16);
1037 memcpy(pWapiSta->wapiMsk.micKey, data + 26, 16);
1038 pWapiSta->wapiMsk.keyId = *(data + 42);
1039 pWapiSta->wapiMsk.bTxEnable = false;
1040 if (!pWapiSta->bSetkeyOk)
1041 pWapiSta->bSetkeyOk = true;
1042 pWapiInfo->bFirstAuthentiateInProgress = false;
1043 WAPI_DATA(WAPI_INIT, "SetKey - ASUE MSK Data Key", pWapiSta->wapiMsk.dataKey, 16);
1044 WAPI_DATA(WAPI_INIT, "SetKey - ASUE MSK Mic Key", pWapiSta->wapiMsk.micKey, 16);
1045 } else {
1046 WAPI_TRACE(WAPI_INIT, "ASUE update msk\n");
1047 pWapiSta->wapiMskUpdate.bSet = true;
1048 memcpy(pWapiSta->wapiMskUpdate.dataKey, data + 10, 16);
1049 memcpy(pWapiSta->wapiMskUpdate.micKey, data + 26, 16);
1050 pWapiSta->wapiMskUpdate.keyId = *(data + 42);
1051 pWapiSta->wapiMskUpdate.bTxEnable = false;
1052 }
1053 }
1054 break;
1055 default:
1056 WAPI_TRACE(WAPI_ERR, "Unknown Flag\n");
1057 break;
1058 }
1059 }
1060 }
1061 }
1062 WAPI_TRACE(WAPI_INIT, "<===========%s\n", __FUNCTION__);
1063 }
1064
1065
1066 void wapi_test_init(struct _adapter *padapter)
1067 {
1068 u8 keybuf[100];
1069 u8 mac_addr[ETH_ALEN] = {0x00, 0xe0, 0x4c, 0x72, 0x04, 0x70};
1070 u8 UskDataKey[16] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
1071 u8 UskMicKey[16] = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
1072 u8 UskId = 0;
1073 u8 MskDataKey[16] = {0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f};
1074 u8 MskMicKey[16] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f};
1075 u8 MskId = 0;
1076
1077 WAPI_TRACE(WAPI_INIT, "===========>%s\n", __FUNCTION__);
1078
1079 /* Enable Wapi */
1080 WAPI_TRACE(WAPI_INIT, "%s: Enable wapi!!!!\n", __FUNCTION__);
1081 padapter->wapiInfo.bWapiEnable = true;
1082 padapter->pairwise_key_type = KEY_TYPE_SMS4;
1083 ieee->group_key_type = KEY_TYPE_SMS4;
1084 padapter->wapiInfo.extra_prefix_len = WAPI_EXT_LEN;
1085 padapter->wapiInfo.extra_postfix_len = SMS4_MIC_LEN;
1086
1087 /* set usk */
1088 WAPI_TRACE(WAPI_INIT, "%s: Set USK!!!!\n", __FUNCTION__);
1089 memset(keybuf, 0, 100);
1090 keybuf[0] = 1; /* set usk */
1091 keybuf[1] = 1; /* enable tx */
1092 keybuf[2] = 1; /* AE */
1093 keybuf[3] = 0; /* not update */
1094
1095 memcpy(keybuf + 4, mac_addr, ETH_ALEN);
1096 memcpy(keybuf + 10, UskDataKey, 16);
1097 memcpy(keybuf + 26, UskMicKey, 16);
1098 keybuf[42] = UskId;
1099 wapi_test_set_key(padapter, keybuf);
1100
1101 memset(keybuf, 0, 100);
1102 keybuf[0] = 1; /* set usk */
1103 keybuf[1] = 1; /* enable tx */
1104 keybuf[2] = 0; /* AE */
1105 keybuf[3] = 0; /* not update */
1106
1107 memcpy(keybuf + 4, mac_addr, ETH_ALEN);
1108 memcpy(keybuf + 10, UskDataKey, 16);
1109 memcpy(keybuf + 26, UskMicKey, 16);
1110 keybuf[42] = UskId;
1111 wapi_test_set_key(padapter, keybuf);
1112
1113 /* set msk */
1114 WAPI_TRACE(WAPI_INIT, "%s: Set MSK!!!!\n", __FUNCTION__);
1115 memset(keybuf, 0, 100);
1116 keybuf[0] = 2; /* set msk */
1117 keybuf[1] = 1; /* Enable TX */
1118 keybuf[2] = 1; /* AE */
1119 keybuf[3] = 0; /* not update */
1120 memcpy(keybuf + 4, mac_addr, ETH_ALEN);
1121 memcpy(keybuf + 10, MskDataKey, 16);
1122 memcpy(keybuf + 26, MskMicKey, 16);
1123 keybuf[42] = MskId;
1124 wapi_test_set_key(padapter, keybuf);
1125
1126 memset(keybuf, 0, 100);
1127 keybuf[0] = 2; /* set msk */
1128 keybuf[1] = 1; /* Enable TX */
1129 keybuf[2] = 0; /* AE */
1130 keybuf[3] = 0; /* not update */
1131 memcpy(keybuf + 4, mac_addr, ETH_ALEN);
1132 memcpy(keybuf + 10, MskDataKey, 16);
1133 memcpy(keybuf + 26, MskMicKey, 16);
1134 keybuf[42] = MskId;
1135 wapi_test_set_key(padapter, keybuf);
1136 WAPI_TRACE(WAPI_INIT, "<===========%s\n", __FUNCTION__);
1137 }
1138 #endif
1139
rtw_wapi_get_iv(_adapter * padapter,u8 * pRA,u8 * IV)1140 void rtw_wapi_get_iv(_adapter *padapter, u8 *pRA, u8 *IV)
1141 {
1142 PWLAN_HEADER_WAPI_EXTENSION pWapiExt = NULL;
1143 PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
1144 bool bPNOverflow = false;
1145 bool bFindMatchPeer = false;
1146 PRT_WAPI_STA_INFO pWapiSta = NULL;
1147
1148 pWapiExt = (PWLAN_HEADER_WAPI_EXTENSION)IV;
1149
1150 WAPI_DATA(WAPI_RX, "wapi_get_iv: pra", pRA, 6);
1151
1152 if (IS_MCAST(pRA)) {
1153 if (!pWapiInfo->wapiTxMsk.bTxEnable) {
1154 WAPI_TRACE(WAPI_ERR, "%s: bTxEnable = 0!!\n", __FUNCTION__);
1155 return;
1156 }
1157
1158 if (pWapiInfo->wapiTxMsk.keyId <= 1) {
1159 pWapiExt->KeyIdx = pWapiInfo->wapiTxMsk.keyId;
1160 pWapiExt->Reserved = 0;
1161 bPNOverflow = WapiIncreasePN(pWapiInfo->lastTxMulticastPN, 1);
1162 memcpy(pWapiExt->PN, pWapiInfo->lastTxMulticastPN, 16);
1163 }
1164 } else {
1165 if (list_empty(&pWapiInfo->wapiSTAUsedList)) {
1166 WAPI_TRACE(WAPI_RX, "rtw_wapi_get_iv: list is empty\n");
1167 _rtw_memset(IV, 10, 18);
1168 return;
1169 } else {
1170 list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
1171 WAPI_DATA(WAPI_RX, "rtw_wapi_get_iv: peermacaddr ", pWapiSta->PeerMacAddr, 6);
1172 if (_rtw_memcmp((u8 *)pWapiSta->PeerMacAddr, pRA, 6) == _TRUE) {
1173 bFindMatchPeer = true;
1174 break;
1175 }
1176 }
1177
1178 WAPI_TRACE(WAPI_RX, "bFindMatchPeer: %d\n", bFindMatchPeer);
1179 WAPI_DATA(WAPI_RX, "Addr", pRA, 6);
1180
1181 if (bFindMatchPeer) {
1182 if ((!pWapiSta->wapiUskUpdate.bTxEnable) && (!pWapiSta->wapiUsk.bTxEnable))
1183 return;
1184
1185 if (pWapiSta->wapiUsk.keyId <= 1) {
1186 if (pWapiSta->wapiUskUpdate.bTxEnable)
1187 pWapiExt->KeyIdx = pWapiSta->wapiUskUpdate.keyId;
1188 else
1189 pWapiExt->KeyIdx = pWapiSta->wapiUsk.keyId;
1190
1191 pWapiExt->Reserved = 0;
1192 bPNOverflow = WapiIncreasePN(pWapiSta->lastTxUnicastPN, 2);
1193 _rtw_memcpy(pWapiExt->PN, pWapiSta->lastTxUnicastPN, 16);
1194
1195 }
1196 }
1197 }
1198
1199 }
1200
1201 }
1202
rtw_wapi_drop_for_key_absent(_adapter * padapter,u8 * pRA)1203 bool rtw_wapi_drop_for_key_absent(_adapter *padapter, u8 *pRA)
1204 {
1205 PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
1206 bool bFindMatchPeer = false;
1207 bool bDrop = false;
1208 PRT_WAPI_STA_INFO pWapiSta = NULL;
1209 struct security_priv *psecuritypriv = &padapter->securitypriv;
1210
1211 WAPI_DATA(WAPI_RX, "rtw_wapi_drop_for_key_absent: ra ", pRA, 6);
1212
1213 if (psecuritypriv->dot11PrivacyAlgrthm == _SMS4_) {
1214 if ((!padapter->WapiSupport) || (!pWapiInfo->bWapiEnable))
1215 return true;
1216
1217 if (IS_MCAST(pRA)) {
1218 if (!pWapiInfo->wapiTxMsk.bTxEnable) {
1219 bDrop = true;
1220 WAPI_TRACE(WAPI_RX, "rtw_wapi_drop_for_key_absent: multicast key is absent\n");
1221 return bDrop;
1222 }
1223 } else {
1224 if (!list_empty(&pWapiInfo->wapiSTAUsedList)) {
1225 list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
1226 WAPI_DATA(WAPI_RX, "rtw_wapi_drop_for_key_absent: pWapiSta->PeerMacAddr ", pWapiSta->PeerMacAddr, 6);
1227 if (_rtw_memcmp(pRA, pWapiSta->PeerMacAddr, 6) == _TRUE) {
1228 bFindMatchPeer = true;
1229 break;
1230 }
1231 }
1232 if (bFindMatchPeer) {
1233 if (!pWapiSta->wapiUsk.bTxEnable) {
1234 bDrop = true;
1235 WAPI_TRACE(WAPI_RX, "rtw_wapi_drop_for_key_absent: unicast key is absent\n");
1236 return bDrop;
1237 }
1238 } else {
1239 bDrop = true;
1240 WAPI_TRACE(WAPI_RX, "rtw_wapi_drop_for_key_absent: no peer find\n");
1241 return bDrop;
1242 }
1243
1244 } else {
1245 bDrop = true;
1246 WAPI_TRACE(WAPI_RX, "rtw_wapi_drop_for_key_absent: no sta exist\n");
1247 return bDrop;
1248 }
1249 }
1250 } else
1251 return bDrop;
1252
1253 return bDrop;
1254 }
1255
rtw_wapi_set_set_encryption(_adapter * padapter,struct ieee_param * param)1256 void rtw_wapi_set_set_encryption(_adapter *padapter, struct ieee_param *param)
1257 {
1258 struct security_priv *psecuritypriv = &padapter->securitypriv;
1259 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1260 PRT_WAPI_T pWapiInfo = &padapter->wapiInfo;
1261 PRT_WAPI_STA_INFO pWapiSta;
1262 u8 WapiASUEPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
1263 u8 WapiAEPNInitialValueSrc[16] = {0x37, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
1264 u8 WapiAEMultiCastPNInitialValueSrc[16] = {0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C, 0x36, 0x5C} ;
1265
1266 if (param->u.crypt.set_tx == 1) {
1267 list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
1268 if (_rtw_memcmp(pWapiSta->PeerMacAddr, param->sta_addr, 6)) {
1269 _rtw_memcpy(pWapiSta->lastTxUnicastPN, WapiASUEPNInitialValueSrc, 16);
1270
1271 pWapiSta->wapiUsk.bSet = true;
1272 _rtw_memcpy(pWapiSta->wapiUsk.dataKey, param->u.crypt.key, 16);
1273 _rtw_memcpy(pWapiSta->wapiUsk.micKey, param->u.crypt.key + 16, 16);
1274 pWapiSta->wapiUsk.keyId = param->u.crypt.idx ;
1275 pWapiSta->wapiUsk.bTxEnable = true;
1276
1277 _rtw_memcpy(pWapiSta->lastRxUnicastPNBEQueue, WapiAEPNInitialValueSrc, 16);
1278 _rtw_memcpy(pWapiSta->lastRxUnicastPNBKQueue, WapiAEPNInitialValueSrc, 16);
1279 _rtw_memcpy(pWapiSta->lastRxUnicastPNVIQueue, WapiAEPNInitialValueSrc, 16);
1280 _rtw_memcpy(pWapiSta->lastRxUnicastPNVOQueue, WapiAEPNInitialValueSrc, 16);
1281 _rtw_memcpy(pWapiSta->lastRxUnicastPN, WapiAEPNInitialValueSrc, 16);
1282 pWapiSta->wapiUskUpdate.bTxEnable = false;
1283 pWapiSta->wapiUskUpdate.bSet = false;
1284
1285 if (psecuritypriv->sw_encrypt == false || psecuritypriv->sw_decrypt == false) {
1286 /* set unicast key for ASUE */
1287 rtw_wapi_set_key(padapter, &pWapiSta->wapiUsk, pWapiSta, false, false);
1288 }
1289 }
1290 }
1291 } else {
1292 list_for_each_entry(pWapiSta, &pWapiInfo->wapiSTAUsedList, list) {
1293 if (_rtw_memcmp(pWapiSta->PeerMacAddr, get_bssid(pmlmepriv), 6)) {
1294 pWapiSta->wapiMsk.bSet = true;
1295 _rtw_memcpy(pWapiSta->wapiMsk.dataKey, param->u.crypt.key, 16);
1296 _rtw_memcpy(pWapiSta->wapiMsk.micKey, param->u.crypt.key + 16, 16);
1297 pWapiSta->wapiMsk.keyId = param->u.crypt.idx ;
1298 pWapiSta->wapiMsk.bTxEnable = false;
1299 if (!pWapiSta->bSetkeyOk)
1300 pWapiSta->bSetkeyOk = true;
1301 pWapiSta->bAuthenticateInProgress = false;
1302
1303 _rtw_memcpy(pWapiSta->lastRxMulticastPN, WapiAEMultiCastPNInitialValueSrc, 16);
1304
1305 if (psecuritypriv->sw_decrypt == false) {
1306 /* set rx broadcast key for ASUE */
1307 rtw_wapi_set_key(padapter, &pWapiSta->wapiMsk, pWapiSta, true, false);
1308 }
1309 }
1310 }
1311 }
1312 }
1313 #endif
1314