1 /*
2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 *
20 * File: key.c
21 *
22 * Purpose: Implement functions for 802.11i Key management
23 *
24 * Author: Jerry Chen
25 *
26 * Date: May 29, 2003
27 *
28 * Functions:
29 * KeyvInitTable - Init Key management table
30 * KeybGetKey - Get Key from table
31 * KeybSetKey - Set Key to table
32 * KeybRemoveKey - Remove Key from table
33 * KeybGetTransmitKey - Get Transmit Key from table
34 *
35 * Revision History:
36 *
37 */
38
39
40 #if !defined(__TMACRO_H__)
41 #include "tmacro.h"
42 #endif
43 #if !defined(__TBIT_H__)
44 #include "tbit.h"
45 #endif
46 #if !defined(__KEY_H__)
47 #include "key.h"
48 #endif
49 #if !defined(__UMEM_H__)
50 #include "umem.h"
51 #endif
52 #if !defined(__MAC_H__)
53 #include "mac.h"
54 #endif
55
56
57 /*--------------------- Static Definitions -------------------------*/
58
59 /*--------------------- Static Classes ----------------------------*/
60
61 /*--------------------- Static Variables --------------------------*/
62 static int msglevel =MSG_LEVEL_INFO;
63 //static int msglevel =MSG_LEVEL_DEBUG;
64 /*--------------------- Static Functions --------------------------*/
65
66 /*--------------------- Export Variables --------------------------*/
67
68 /*--------------------- Static Definitions -------------------------*/
69
70 /*--------------------- Static Classes ----------------------------*/
71
72 /*--------------------- Static Variables --------------------------*/
73
74 /*--------------------- Static Functions --------------------------*/
75 static VOID
76 s_vCheckKeyTableValid (PSKeyManagement pTable, DWORD_PTR dwIoBase)
77 {
78 int i;
79
80 for (i=0;i<MAX_KEY_TABLE;i++) {
81 if ((pTable->KeyTable[i].bInUse == TRUE) &&
82 (pTable->KeyTable[i].PairwiseKey.bKeyValid == FALSE) &&
83 (pTable->KeyTable[i].GroupKey[0].bKeyValid == FALSE) &&
84 (pTable->KeyTable[i].GroupKey[1].bKeyValid == FALSE) &&
85 (pTable->KeyTable[i].GroupKey[2].bKeyValid == FALSE) &&
86 (pTable->KeyTable[i].GroupKey[3].bKeyValid == FALSE)
87 ) {
88 pTable->KeyTable[i].bInUse = FALSE;
89 pTable->KeyTable[i].wKeyCtl = 0;
90 pTable->KeyTable[i].bSoftWEP = FALSE;
91 MACvDisableKeyEntry(dwIoBase, i);
92 }
93 }
94 }
95
96
97 /*--------------------- Export Functions --------------------------*/
98
99
100 /*
101 * Description: Init Key management table
102 *
103 * Parameters:
104 * In:
105 * pTable - Pointer to Key table
106 * Out:
107 * none
108 *
109 * Return Value: none
110 *
111 */
112 VOID KeyvInitTable (PSKeyManagement pTable, DWORD_PTR dwIoBase)
113 {
114 int i;
115 int jj;
116
117 for (i=0;i<MAX_KEY_TABLE;i++) {
118 pTable->KeyTable[i].bInUse = FALSE;
119 pTable->KeyTable[i].PairwiseKey.bKeyValid = FALSE;
120 pTable->KeyTable[i].PairwiseKey.pvKeyTable = (PVOID)&pTable->KeyTable[i];
121 for (jj=0; jj < MAX_GROUP_KEY; jj++) {
122 pTable->KeyTable[i].GroupKey[jj].bKeyValid = FALSE;
123 pTable->KeyTable[i].GroupKey[jj].pvKeyTable = (PVOID)&pTable->KeyTable[i];
124 }
125 pTable->KeyTable[i].wKeyCtl = 0;
126 pTable->KeyTable[i].dwGTKeyIndex = 0;
127 pTable->KeyTable[i].bSoftWEP = FALSE;
128 MACvDisableKeyEntry(dwIoBase, i);
129 }
130 }
131
132
133 /*
134 * Description: Get Key from table
135 *
136 * Parameters:
137 * In:
138 * pTable - Pointer to Key table
139 * pbyBSSID - BSSID of Key
140 * dwKeyIndex - Key Index (0xFFFFFFFF means pairwise key)
141 * Out:
142 * pKey - Key return
143 *
144 * Return Value: TRUE if found otherwise FALSE
145 *
146 */
147 BOOL KeybGetKey (
148 IN PSKeyManagement pTable,
149 IN PBYTE pbyBSSID,
150 IN DWORD dwKeyIndex,
151 OUT PSKeyItem *pKey
152 )
153 {
154 int i;
155
156 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybGetKey() \n");
157
158 *pKey = NULL;
159 for (i=0;i<MAX_KEY_TABLE;i++) {
160 if ((pTable->KeyTable[i].bInUse == TRUE) &&
161 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
162 if (dwKeyIndex == 0xFFFFFFFF) {
163 if (pTable->KeyTable[i].PairwiseKey.bKeyValid == TRUE) {
164 *pKey = &(pTable->KeyTable[i].PairwiseKey);
165 return (TRUE);
166 }
167 else {
168 return (FALSE);
169 }
170 } else if (dwKeyIndex < MAX_GROUP_KEY) {
171 if (pTable->KeyTable[i].GroupKey[dwKeyIndex].bKeyValid == TRUE) {
172 *pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex]);
173 return (TRUE);
174 }
175 else {
176 return (FALSE);
177 }
178 }
179 else {
180 return (FALSE);
181 }
182 }
183 }
184 return (FALSE);
185 }
186
187
188 /*
189 * Description: Set Key to table
190 *
191 * Parameters:
192 * In:
193 * pTable - Pointer to Key table
194 * pbyBSSID - BSSID of Key
195 * dwKeyIndex - Key index (reference to NDIS DDK)
196 * uKeyLength - Key length
197 * KeyRSC - Key RSC
198 * pbyKey - Pointer to key
199 * Out:
200 * none
201 *
202 * Return Value: TRUE if success otherwise FALSE
203 *
204 */
205 BOOL KeybSetKey (
206 PSKeyManagement pTable,
207 PBYTE pbyBSSID,
208 DWORD dwKeyIndex,
209 ULONG uKeyLength,
210 PQWORD pKeyRSC,
211 PBYTE pbyKey,
212 BYTE byKeyDecMode,
213 DWORD_PTR dwIoBase,
214 BYTE byLocalID
215 )
216 {
217 int i,j;
218 UINT ii;
219 PSKeyItem pKey;
220 UINT uKeyIdx;
221
222 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Enter KeybSetKey: %lX\n", dwKeyIndex);
223
224 j = (MAX_KEY_TABLE-1);
225 for (i=0;i<(MAX_KEY_TABLE-1);i++) {
226 if ((pTable->KeyTable[i].bInUse == FALSE) &&
227 (j == (MAX_KEY_TABLE-1))) {
228 // found empty table
229 j = i;
230 }
231 if ((pTable->KeyTable[i].bInUse == TRUE) &&
232 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
233 // found table already exist
234 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
235 // Pairwise key
236 pKey = &(pTable->KeyTable[i].PairwiseKey);
237 pTable->KeyTable[i].wKeyCtl &= 0xFFF0; // clear pairwise key control filed
238 pTable->KeyTable[i].wKeyCtl |= byKeyDecMode;
239 uKeyIdx = 4; // use HW key entry 4 for pairwise key
240 } else {
241 // Group key
242 if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
243 return (FALSE);
244 pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF]);
245 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
246 // Group transmit key
247 pTable->KeyTable[i].dwGTKeyIndex = dwKeyIndex;
248 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Group transmit key(R)[%lX]: %d\n", pTable->KeyTable[i].dwGTKeyIndex, i);
249 }
250 pTable->KeyTable[i].wKeyCtl &= 0xFF0F; // clear group key control filed
251 pTable->KeyTable[i].wKeyCtl |= (byKeyDecMode << 4);
252 pTable->KeyTable[i].wKeyCtl |= 0x0040; // use group key for group address
253 uKeyIdx = (dwKeyIndex & 0x000000FF);
254 }
255 pTable->KeyTable[i].wKeyCtl |= 0x8000; // enable on-fly
256
257 pKey->bKeyValid = TRUE;
258 pKey->uKeyLength = uKeyLength;
259 pKey->dwKeyIndex = dwKeyIndex;
260 pKey->byCipherSuite = byKeyDecMode;
261 MEMvCopy(pKey->abyKey, pbyKey, uKeyLength);
262 if (byKeyDecMode == KEY_CTL_WEP) {
263 if (uKeyLength == WLAN_WEP40_KEYLEN)
264 pKey->abyKey[15] &= 0x7F;
265 if (uKeyLength == WLAN_WEP104_KEYLEN)
266 pKey->abyKey[15] |= 0x80;
267 }
268 MACvSetKeyEntry(dwIoBase, pTable->KeyTable[i].wKeyCtl, i, uKeyIdx, pbyBSSID, (PDWORD)pKey->abyKey, byLocalID);
269
270 if ((dwKeyIndex & USE_KEYRSC) == 0) {
271 // RSC set by NIC
272 ZERO_MEMORY(&(pKey->KeyRSC), sizeof(QWORD));
273 }
274 else {
275 MEMvCopy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
276 }
277 pKey->dwTSC47_16 = 0;
278 pKey->wTSC15_0 = 0;
279
280 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybSetKey(R): \n");
281 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->bKeyValid: %d\n ", pKey->bKeyValid);
282 //DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->uKeyLength: %d\n ", pKey->uKeyLength);
283 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->abyKey: ");
284 for (ii = 0; ii < pKey->uKeyLength; ii++) {
285 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pKey->abyKey[ii]);
286 }
287 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
288
289 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwTSC47_16: %lx\n ", pKey->dwTSC47_16);
290 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->wTSC15_0: %x\n ", pKey->wTSC15_0);
291 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwKeyIndex: %lx\n ", pKey->dwKeyIndex);
292
293 return (TRUE);
294 }
295 }
296 if (j < (MAX_KEY_TABLE-1)) {
297 MEMvCopy(pTable->KeyTable[j].abyBSSID,pbyBSSID,U_ETHER_ADDR_LEN);
298 pTable->KeyTable[j].bInUse = TRUE;
299 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
300 // Pairwise key
301 pKey = &(pTable->KeyTable[j].PairwiseKey);
302 pTable->KeyTable[j].wKeyCtl &= 0xFFF0; // clear pairwise key control filed
303 pTable->KeyTable[j].wKeyCtl |= byKeyDecMode;
304 uKeyIdx = 4; // use HW key entry 4 for pairwise key
305 } else {
306 // Group key
307 if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
308 return (FALSE);
309 pKey = &(pTable->KeyTable[j].GroupKey[dwKeyIndex & 0x000000FF]);
310 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
311 // Group transmit key
312 pTable->KeyTable[j].dwGTKeyIndex = dwKeyIndex;
313 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Group transmit key(N)[%lX]: %d\n", pTable->KeyTable[j].dwGTKeyIndex, j);
314 }
315 pTable->KeyTable[j].wKeyCtl &= 0xFF0F; // clear group key control filed
316 pTable->KeyTable[j].wKeyCtl |= (byKeyDecMode << 4);
317 pTable->KeyTable[j].wKeyCtl |= 0x0040; // use group key for group address
318 uKeyIdx = (dwKeyIndex & 0x000000FF);
319 }
320 pTable->KeyTable[j].wKeyCtl |= 0x8000; // enable on-fly
321
322 pKey->bKeyValid = TRUE;
323 pKey->uKeyLength = uKeyLength;
324 pKey->dwKeyIndex = dwKeyIndex;
325 pKey->byCipherSuite = byKeyDecMode;
326 MEMvCopy(pKey->abyKey, pbyKey, uKeyLength);
327 if (byKeyDecMode == KEY_CTL_WEP) {
328 if (uKeyLength == WLAN_WEP40_KEYLEN)
329 pKey->abyKey[15] &= 0x7F;
330 if (uKeyLength == WLAN_WEP104_KEYLEN)
331 pKey->abyKey[15] |= 0x80;
332 }
333 MACvSetKeyEntry(dwIoBase, pTable->KeyTable[j].wKeyCtl, j, uKeyIdx, pbyBSSID, (PDWORD)pKey->abyKey, byLocalID);
334
335 if ((dwKeyIndex & USE_KEYRSC) == 0) {
336 // RSC set by NIC
337 ZERO_MEMORY(&(pKey->KeyRSC), sizeof(QWORD));
338 }
339 else {
340 MEMvCopy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
341 }
342 pKey->dwTSC47_16 = 0;
343 pKey->wTSC15_0 = 0;
344
345 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybSetKey(N): \n");
346 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->bKeyValid: %d\n ", pKey->bKeyValid);
347 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->uKeyLength: %d\n ", (int)pKey->uKeyLength);
348 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->abyKey: ");
349 for (ii = 0; ii < pKey->uKeyLength; ii++) {
350 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%02x ", pKey->abyKey[ii]);
351 }
352 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
353
354 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwTSC47_16: %lx\n ", pKey->dwTSC47_16);
355 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->wTSC15_0: %x\n ", pKey->wTSC15_0);
356 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwKeyIndex: %lx\n ", pKey->dwKeyIndex);
357
358 return (TRUE);
359 }
360 return (FALSE);
361 }
362
363
364 /*
365 * Description: Remove Key from table
366 *
367 * Parameters:
368 * In:
369 * pTable - Pointer to Key table
370 * pbyBSSID - BSSID of Key
371 * dwKeyIndex - Key Index (reference to NDIS DDK)
372 * Out:
373 * none
374 *
375 * Return Value: TRUE if success otherwise FALSE
376 *
377 */
378 BOOL KeybRemoveKey (
379 PSKeyManagement pTable,
380 PBYTE pbyBSSID,
381 DWORD dwKeyIndex,
382 DWORD_PTR dwIoBase
383 )
384 {
385 int i;
386
387 if (IS_BROADCAST_ADDRESS(pbyBSSID)) {
388 // dealte all key
389 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
390 for (i=0;i<MAX_KEY_TABLE;i++) {
391 pTable->KeyTable[i].PairwiseKey.bKeyValid = FALSE;
392 }
393 s_vCheckKeyTableValid(pTable, dwIoBase);
394 return TRUE;
395 }
396 else if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
397 for (i=0;i<MAX_KEY_TABLE;i++) {
398 pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = FALSE;
399 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[i].dwGTKeyIndex & 0x7FFFFFFF)) {
400 // remove Group transmit key
401 pTable->KeyTable[i].dwGTKeyIndex = 0;
402 }
403 }
404 s_vCheckKeyTableValid(pTable, dwIoBase);
405 return TRUE;
406 }
407 else {
408 return FALSE;
409 }
410 }
411
412 for (i=0;i<MAX_KEY_TABLE;i++) {
413 if ((pTable->KeyTable[i].bInUse == TRUE) &&
414 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
415 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
416 pTable->KeyTable[i].PairwiseKey.bKeyValid = FALSE;
417 s_vCheckKeyTableValid(pTable, dwIoBase);
418 return (TRUE);
419 }
420 else if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
421 pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = FALSE;
422 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[i].dwGTKeyIndex & 0x7FFFFFFF)) {
423 // remove Group transmit key
424 pTable->KeyTable[i].dwGTKeyIndex = 0;
425 }
426 s_vCheckKeyTableValid(pTable, dwIoBase);
427 return (TRUE);
428 }
429 else {
430 return (FALSE);
431 }
432 }
433 }
434 return (FALSE);
435 }
436
437
438 /*
439 * Description: Remove Key from table
440 *
441 * Parameters:
442 * In:
443 * pTable - Pointer to Key table
444 * pbyBSSID - BSSID of Key
445 * Out:
446 * none
447 *
448 * Return Value: TRUE if success otherwise FALSE
449 *
450 */
451 BOOL KeybRemoveAllKey (
452 PSKeyManagement pTable,
453 PBYTE pbyBSSID,
454 DWORD_PTR dwIoBase
455 )
456 {
457 int i,u;
458
459 for (i=0;i<MAX_KEY_TABLE;i++) {
460 if ((pTable->KeyTable[i].bInUse == TRUE) &&
461 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
462 pTable->KeyTable[i].PairwiseKey.bKeyValid = FALSE;
463 for(u=0;u<MAX_GROUP_KEY;u++) {
464 pTable->KeyTable[i].GroupKey[u].bKeyValid = FALSE;
465 }
466 pTable->KeyTable[i].dwGTKeyIndex = 0;
467 s_vCheckKeyTableValid(pTable, dwIoBase);
468 return (TRUE);
469 }
470 }
471 return (FALSE);
472 }
473
474 /*
475 * Description: Remove WEP Key from table
476 *
477 * Parameters:
478 * In:
479 * pTable - Pointer to Key table
480 * Out:
481 * none
482 *
483 * Return Value: TRUE if success otherwise FALSE
484 *
485 */
486 VOID KeyvRemoveWEPKey (
487 PSKeyManagement pTable,
488 DWORD dwKeyIndex,
489 DWORD_PTR dwIoBase
490 )
491 {
492
493 if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
494 if (pTable->KeyTable[MAX_KEY_TABLE-1].bInUse == TRUE) {
495 if (pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF].byCipherSuite == KEY_CTL_WEP) {
496 pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = FALSE;
497 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex & 0x7FFFFFFF)) {
498 // remove Group transmit key
499 pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex = 0;
500 }
501 }
502 }
503 s_vCheckKeyTableValid(pTable, dwIoBase);
504 }
505 return;
506 }
507
508 VOID KeyvRemoveAllWEPKey (
509 PSKeyManagement pTable,
510 DWORD_PTR dwIoBase
511 )
512 {
513 int i;
514
515 for(i=0;i<MAX_GROUP_KEY;i++) {
516 KeyvRemoveWEPKey(pTable, i, dwIoBase);
517 }
518 }
519
520 /*
521 * Description: Get Transmit Key from table
522 *
523 * Parameters:
524 * In:
525 * pTable - Pointer to Key table
526 * pbyBSSID - BSSID of Key
527 * Out:
528 * pKey - Key return
529 *
530 * Return Value: TRUE if found otherwise FALSE
531 *
532 */
533 BOOL KeybGetTransmitKey (
534 IN PSKeyManagement pTable,
535 IN PBYTE pbyBSSID,
536 IN DWORD dwKeyType,
537 OUT PSKeyItem *pKey
538 )
539 {
540 int i, ii;
541
542 *pKey = NULL;
543 for (i=0;i<MAX_KEY_TABLE;i++) {
544 if ((pTable->KeyTable[i].bInUse == TRUE) &&
545 IS_ETH_ADDRESS_EQUAL(pTable->KeyTable[i].abyBSSID,pbyBSSID)) {
546
547 if (dwKeyType == PAIRWISE_KEY) {
548
549 if (pTable->KeyTable[i].PairwiseKey.bKeyValid == TRUE) {
550 *pKey = &(pTable->KeyTable[i].PairwiseKey);
551
552 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybGetTransmitKey:");
553 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"PAIRWISE_KEY: KeyTable.abyBSSID: ");
554 for (ii = 0; ii < 6; ii++) {
555 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%x ", pTable->KeyTable[i].abyBSSID[ii]);
556 }
557 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
558
559
560 return (TRUE);
561 }
562 else {
563 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"PairwiseKey.bKeyValid == FALSE\n");
564 return (FALSE);
565 }
566 } // End of Type == PAIRWISE
567 else {
568 if (pTable->KeyTable[i].dwGTKeyIndex == 0) {
569 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ERROR: dwGTKeyIndex == 0 !!!\n");
570 return FALSE;
571 }
572 if (pTable->KeyTable[i].GroupKey[(pTable->KeyTable[i].dwGTKeyIndex&0x000000FF)].bKeyValid == TRUE) {
573 *pKey = &(pTable->KeyTable[i].GroupKey[(pTable->KeyTable[i].dwGTKeyIndex&0x000000FF)]);
574
575 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybGetTransmitKey:");
576 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"GROUP_KEY: KeyTable.abyBSSID\n");
577 for (ii = 0; ii < 6; ii++) {
578 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%x ", pTable->KeyTable[i].abyBSSID[ii]);
579 }
580 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
581 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"dwGTKeyIndex: %lX\n", pTable->KeyTable[i].dwGTKeyIndex);
582
583 return (TRUE);
584 }
585 else {
586 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"GroupKey.bKeyValid == FALSE\n");
587 return (FALSE);
588 }
589 } // End of Type = GROUP
590 } // BSSID match
591 }
592 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ERROR: NO Match BSSID !!! ");
593 for (ii = 0; ii < 6; ii++) {
594 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", *(pbyBSSID+ii));
595 }
596 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
597 return (FALSE);
598 }
599
600
601 /*
602 * Description: Check Pairewise Key
603 *
604 * Parameters:
605 * In:
606 * pTable - Pointer to Key table
607 * Out:
608 * none
609 *
610 * Return Value: TRUE if found otherwise FALSE
611 *
612 */
613 BOOL KeybCheckPairewiseKey (
614 IN PSKeyManagement pTable,
615 OUT PSKeyItem *pKey
616 )
617 {
618 int i;
619
620 *pKey = NULL;
621 for (i=0;i<MAX_KEY_TABLE;i++) {
622 if ((pTable->KeyTable[i].bInUse == TRUE) &&
623 (pTable->KeyTable[i].PairwiseKey.bKeyValid == TRUE)) {
624 *pKey = &(pTable->KeyTable[i].PairwiseKey);
625 return (TRUE);
626 }
627 }
628 return (FALSE);
629 }
630
631 /*
632 * Description: Set Key to table
633 *
634 * Parameters:
635 * In:
636 * pTable - Pointer to Key table
637 * dwKeyIndex - Key index (reference to NDIS DDK)
638 * uKeyLength - Key length
639 * KeyRSC - Key RSC
640 * pbyKey - Pointer to key
641 * Out:
642 * none
643 *
644 * Return Value: TRUE if success otherwise FALSE
645 *
646 */
647 BOOL KeybSetDefaultKey (
648 PSKeyManagement pTable,
649 DWORD dwKeyIndex,
650 ULONG uKeyLength,
651 PQWORD pKeyRSC,
652 PBYTE pbyKey,
653 BYTE byKeyDecMode,
654 DWORD_PTR dwIoBase,
655 BYTE byLocalID
656 )
657 {
658 UINT ii;
659 PSKeyItem pKey;
660 UINT uKeyIdx;
661
662 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Enter KeybSetDefaultKey: %1x, %d \n", (int)dwKeyIndex, (int)uKeyLength);
663
664
665 if ((dwKeyIndex & PAIRWISE_KEY) != 0) { // Pairwise key
666 return (FALSE);
667 } else if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY) {
668 return (FALSE);
669 }
670
671 pTable->KeyTable[MAX_KEY_TABLE-1].bInUse = TRUE;
672 for(ii=0;ii<U_ETHER_ADDR_LEN;ii++)
673 pTable->KeyTable[MAX_KEY_TABLE-1].abyBSSID[ii] = 0xFF;
674
675 // Group key
676 pKey = &(pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF]);
677 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
678 // Group transmit key
679 pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex = dwKeyIndex;
680 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Group transmit key(R)[%lX]: %d\n", pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex, MAX_KEY_TABLE-1);
681
682 }
683 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl &= 0x7F00; // clear all key control filed
684 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= (byKeyDecMode << 4);
685 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= (byKeyDecMode);
686 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0x0044; // use group key for all address
687 uKeyIdx = (dwKeyIndex & 0x000000FF);
688
689 if ((uKeyLength == WLAN_WEP232_KEYLEN) &&
690 (byKeyDecMode == KEY_CTL_WEP)) {
691 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0x4000; // disable on-fly disable address match
692 pTable->KeyTable[MAX_KEY_TABLE-1].bSoftWEP = TRUE;
693 } else {
694 if (pTable->KeyTable[MAX_KEY_TABLE-1].bSoftWEP == FALSE)
695 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0xC000; // enable on-fly disable address match
696 }
697
698 pKey->bKeyValid = TRUE;
699 pKey->uKeyLength = uKeyLength;
700 pKey->dwKeyIndex = dwKeyIndex;
701 pKey->byCipherSuite = byKeyDecMode;
702 MEMvCopy(pKey->abyKey, pbyKey, uKeyLength);
703 if (byKeyDecMode == KEY_CTL_WEP) {
704 if (uKeyLength == WLAN_WEP40_KEYLEN)
705 pKey->abyKey[15] &= 0x7F;
706 if (uKeyLength == WLAN_WEP104_KEYLEN)
707 pKey->abyKey[15] |= 0x80;
708 }
709 MACvSetKeyEntry(dwIoBase, pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl, MAX_KEY_TABLE-1, uKeyIdx, pTable->KeyTable[MAX_KEY_TABLE-1].abyBSSID, (PDWORD)pKey->abyKey, byLocalID);
710
711 if ((dwKeyIndex & USE_KEYRSC) == 0) {
712 // RSC set by NIC
713 ZERO_MEMORY(&(pKey->KeyRSC), sizeof(QWORD));
714 } else {
715 MEMvCopy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
716 }
717 pKey->dwTSC47_16 = 0;
718 pKey->wTSC15_0 = 0;
719
720
721 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybSetKey(R): \n");
722 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->bKeyValid: %d\n", pKey->bKeyValid);
723 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->uKeyLength: %d\n", (int)pKey->uKeyLength);
724 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->abyKey: \n");
725 for (ii = 0; ii < pKey->uKeyLength; ii++) {
726 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%x", pKey->abyKey[ii]);
727 }
728 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
729
730 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwTSC47_16: %lx\n", pKey->dwTSC47_16);
731 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->wTSC15_0: %x\n", pKey->wTSC15_0);
732 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->dwKeyIndex: %lx\n", pKey->dwKeyIndex);
733
734 return (TRUE);
735 }
736
737
738 /*
739 * Description: Set Key to table
740 *
741 * Parameters:
742 * In:
743 * pTable - Pointer to Key table
744 * dwKeyIndex - Key index (reference to NDIS DDK)
745 * uKeyLength - Key length
746 * KeyRSC - Key RSC
747 * pbyKey - Pointer to key
748 * Out:
749 * none
750 *
751 * Return Value: TRUE if success otherwise FALSE
752 *
753 */
754 BOOL KeybSetAllGroupKey (
755 PSKeyManagement pTable,
756 DWORD dwKeyIndex,
757 ULONG uKeyLength,
758 PQWORD pKeyRSC,
759 PBYTE pbyKey,
760 BYTE byKeyDecMode,
761 DWORD_PTR dwIoBase,
762 BYTE byLocalID
763 )
764 {
765 int i;
766 UINT ii;
767 PSKeyItem pKey;
768 UINT uKeyIdx;
769
770 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Enter KeybSetAllGroupKey: %lX\n", dwKeyIndex);
771
772
773 if ((dwKeyIndex & PAIRWISE_KEY) != 0) { // Pairwise key
774 return (FALSE);
775 } else if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY) {
776 return (FALSE);
777 }
778
779 for (i=0; i < MAX_KEY_TABLE-1; i++) {
780 if (pTable->KeyTable[i].bInUse == TRUE) {
781 // found table already exist
782 // Group key
783 pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF]);
784 if ((dwKeyIndex & TRANSMIT_KEY) != 0) {
785 // Group transmit key
786 pTable->KeyTable[i].dwGTKeyIndex = dwKeyIndex;
787 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Group transmit key(R)[%lX]: %d\n", pTable->KeyTable[i].dwGTKeyIndex, i);
788
789 }
790 pTable->KeyTable[i].wKeyCtl &= 0xFF0F; // clear group key control filed
791 pTable->KeyTable[i].wKeyCtl |= (byKeyDecMode << 4);
792 pTable->KeyTable[i].wKeyCtl |= 0x0040; // use group key for group address
793 uKeyIdx = (dwKeyIndex & 0x000000FF);
794
795 pTable->KeyTable[i].wKeyCtl |= 0x8000; // enable on-fly
796
797 pKey->bKeyValid = TRUE;
798 pKey->uKeyLength = uKeyLength;
799 pKey->dwKeyIndex = dwKeyIndex;
800 pKey->byCipherSuite = byKeyDecMode;
801 MEMvCopy(pKey->abyKey, pbyKey, uKeyLength);
802 if (byKeyDecMode == KEY_CTL_WEP) {
803 if (uKeyLength == WLAN_WEP40_KEYLEN)
804 pKey->abyKey[15] &= 0x7F;
805 if (uKeyLength == WLAN_WEP104_KEYLEN)
806 pKey->abyKey[15] |= 0x80;
807 }
808 MACvSetKeyEntry(dwIoBase, pTable->KeyTable[i].wKeyCtl, i, uKeyIdx, pTable->KeyTable[i].abyBSSID, (PDWORD)pKey->abyKey, byLocalID);
809
810 if ((dwKeyIndex & USE_KEYRSC) == 0) {
811 // RSC set by NIC
812 ZERO_MEMORY(&(pKey->KeyRSC), sizeof(QWORD));
813 }
814 else {
815 MEMvCopy(&(pKey->KeyRSC), pKeyRSC, sizeof(QWORD));
816 }
817 pKey->dwTSC47_16 = 0;
818 pKey->wTSC15_0 = 0;
819
820 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KeybSetKey(R): \n");
821 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->bKeyValid: %d\n ", pKey->bKeyValid);
822 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->uKeyLength: %d\n ", (int)pKey->uKeyLength);
823 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pKey->abyKey: ");
824 for (ii = 0; ii < pKey->uKeyLength; ii++) {
825 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"%02x ", pKey->abyKey[ii]);
826 }
827 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\n");
828
829 //DBG_PRN_GRP12(("pKey->dwTSC47_16: %lX\n ", pKey->dwTSC47_16));
830 //DBG_PRN_GRP12(("pKey->wTSC15_0: %X\n ", pKey->wTSC15_0));
831 //DBG_PRN_GRP12(("pKey->dwKeyIndex: %lX\n ", pKey->dwKeyIndex));
832
833 } // (pTable->KeyTable[i].bInUse == TRUE)
834 }
835 return (TRUE);
836 }
837
|
This page was automatically generated by the
LXR engine.
|