Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
tkip.c
Go to the documentation of this file.
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: tkip.c
21  *
22  * Purpose: Implement functions for 802.11i TKIP
23  *
24  * Author: Jerry Chen
25  *
26  * Date: Mar. 11, 2003
27  *
28  * Functions:
29  * TKIPvMixKey - Get TKIP RC4 Key from TK,TA, and TSC
30  *
31  * Revision History:
32  *
33  */
34 
35 #include "tmacro.h"
36 #include "tkip.h"
37 
38 /*--------------------- Static Definitions -------------------------*/
39 
40 /*--------------------- Static Classes ----------------------------*/
41 
42 /*--------------------- Static Variables --------------------------*/
43 
44 /*--------------------- Static Functions --------------------------*/
45 
46 /*--------------------- Export Variables --------------------------*/
47 
48 /*--------------------- Static Definitions -------------------------*/
49 
50 /*--------------------- Static Classes ----------------------------*/
51 
52 /*--------------------- Static Variables --------------------------*/
53 
54 /* The Sbox is reduced to 2 16-bit wide tables, each with 256 entries. */
55 /* The 2nd table is the same as the 1st but with the upper and lower */
56 /* bytes swapped. To allow an endian tolerant implementation, the byte */
57 /* halves have been expressed independently here. */
58 const unsigned char TKIP_Sbox_Lower[256] = {
59  0xA5,0x84,0x99,0x8D,0x0D,0xBD,0xB1,0x54,
60  0x50,0x03,0xA9,0x7D,0x19,0x62,0xE6,0x9A,
61  0x45,0x9D,0x40,0x87,0x15,0xEB,0xC9,0x0B,
62  0xEC,0x67,0xFD,0xEA,0xBF,0xF7,0x96,0x5B,
63  0xC2,0x1C,0xAE,0x6A,0x5A,0x41,0x02,0x4F,
64  0x5C,0xF4,0x34,0x08,0x93,0x73,0x53,0x3F,
65  0x0C,0x52,0x65,0x5E,0x28,0xA1,0x0F,0xB5,
66  0x09,0x36,0x9B,0x3D,0x26,0x69,0xCD,0x9F,
67  0x1B,0x9E,0x74,0x2E,0x2D,0xB2,0xEE,0xFB,
68  0xF6,0x4D,0x61,0xCE,0x7B,0x3E,0x71,0x97,
69  0xF5,0x68,0x00,0x2C,0x60,0x1F,0xC8,0xED,
70  0xBE,0x46,0xD9,0x4B,0xDE,0xD4,0xE8,0x4A,
71  0x6B,0x2A,0xE5,0x16,0xC5,0xD7,0x55,0x94,
72  0xCF,0x10,0x06,0x81,0xF0,0x44,0xBA,0xE3,
73  0xF3,0xFE,0xC0,0x8A,0xAD,0xBC,0x48,0x04,
74  0xDF,0xC1,0x75,0x63,0x30,0x1A,0x0E,0x6D,
75  0x4C,0x14,0x35,0x2F,0xE1,0xA2,0xCC,0x39,
76  0x57,0xF2,0x82,0x47,0xAC,0xE7,0x2B,0x95,
77  0xA0,0x98,0xD1,0x7F,0x66,0x7E,0xAB,0x83,
78  0xCA,0x29,0xD3,0x3C,0x79,0xE2,0x1D,0x76,
79  0x3B,0x56,0x4E,0x1E,0xDB,0x0A,0x6C,0xE4,
80  0x5D,0x6E,0xEF,0xA6,0xA8,0xA4,0x37,0x8B,
81  0x32,0x43,0x59,0xB7,0x8C,0x64,0xD2,0xE0,
82  0xB4,0xFA,0x07,0x25,0xAF,0x8E,0xE9,0x18,
83  0xD5,0x88,0x6F,0x72,0x24,0xF1,0xC7,0x51,
84  0x23,0x7C,0x9C,0x21,0xDD,0xDC,0x86,0x85,
85  0x90,0x42,0xC4,0xAA,0xD8,0x05,0x01,0x12,
86  0xA3,0x5F,0xF9,0xD0,0x91,0x58,0x27,0xB9,
87  0x38,0x13,0xB3,0x33,0xBB,0x70,0x89,0xA7,
88  0xB6,0x22,0x92,0x20,0x49,0xFF,0x78,0x7A,
89  0x8F,0xF8,0x80,0x17,0xDA,0x31,0xC6,0xB8,
90  0xC3,0xB0,0x77,0x11,0xCB,0xFC,0xD6,0x3A
91 };
92 
93 const unsigned char TKIP_Sbox_Upper[256] = {
94  0xC6,0xF8,0xEE,0xF6,0xFF,0xD6,0xDE,0x91,
95  0x60,0x02,0xCE,0x56,0xE7,0xB5,0x4D,0xEC,
96  0x8F,0x1F,0x89,0xFA,0xEF,0xB2,0x8E,0xFB,
97  0x41,0xB3,0x5F,0x45,0x23,0x53,0xE4,0x9B,
98  0x75,0xE1,0x3D,0x4C,0x6C,0x7E,0xF5,0x83,
99  0x68,0x51,0xD1,0xF9,0xE2,0xAB,0x62,0x2A,
100  0x08,0x95,0x46,0x9D,0x30,0x37,0x0A,0x2F,
101  0x0E,0x24,0x1B,0xDF,0xCD,0x4E,0x7F,0xEA,
102  0x12,0x1D,0x58,0x34,0x36,0xDC,0xB4,0x5B,
103  0xA4,0x76,0xB7,0x7D,0x52,0xDD,0x5E,0x13,
104  0xA6,0xB9,0x00,0xC1,0x40,0xE3,0x79,0xB6,
105  0xD4,0x8D,0x67,0x72,0x94,0x98,0xB0,0x85,
106  0xBB,0xC5,0x4F,0xED,0x86,0x9A,0x66,0x11,
107  0x8A,0xE9,0x04,0xFE,0xA0,0x78,0x25,0x4B,
108  0xA2,0x5D,0x80,0x05,0x3F,0x21,0x70,0xF1,
109  0x63,0x77,0xAF,0x42,0x20,0xE5,0xFD,0xBF,
110  0x81,0x18,0x26,0xC3,0xBE,0x35,0x88,0x2E,
111  0x93,0x55,0xFC,0x7A,0xC8,0xBA,0x32,0xE6,
112  0xC0,0x19,0x9E,0xA3,0x44,0x54,0x3B,0x0B,
113  0x8C,0xC7,0x6B,0x28,0xA7,0xBC,0x16,0xAD,
114  0xDB,0x64,0x74,0x14,0x92,0x0C,0x48,0xB8,
115  0x9F,0xBD,0x43,0xC4,0x39,0x31,0xD3,0xF2,
116  0xD5,0x8B,0x6E,0xDA,0x01,0xB1,0x9C,0x49,
117  0xD8,0xAC,0xF3,0xCF,0xCA,0xF4,0x47,0x10,
118  0x6F,0xF0,0x4A,0x5C,0x38,0x57,0x73,0x97,
119  0xCB,0xA1,0xE8,0x3E,0x96,0x61,0x0D,0x0F,
120  0xE0,0x7C,0x71,0xCC,0x90,0x06,0xF7,0x1C,
121  0xC2,0x6A,0xAE,0x69,0x17,0x99,0x3A,0x27,
122  0xD9,0xEB,0x2B,0x22,0xD2,0xA9,0x07,0x33,
123  0x2D,0x3C,0x15,0xC9,0x87,0xAA,0x50,0xA5,
124  0x03,0x59,0x09,0x1A,0x65,0xD7,0x84,0xD0,
125  0x82,0x29,0x5A,0x1E,0x7B,0xA8,0x6D,0x2C
126 };
127 
128 
129 //STKIPKeyManagement sTKIPKeyTable[MAX_TKIP_KEY];
130 
131 /*--------------------- Static Functions --------------------------*/
132 unsigned int tkip_sbox(unsigned int index);
133 unsigned int rotr1(unsigned int a);
134 
135 /*--------------------- Export Variables --------------------------*/
136 
137 /************************************************************/
138 /* tkip_sbox() */
139 /* Returns a 16 bit value from a 64K entry table. The Table */
140 /* is synthesized from two 256 entry byte wide tables. */
141 /************************************************************/
142 unsigned int tkip_sbox(unsigned int index)
143 {
144  unsigned int index_low;
145  unsigned int index_high;
146  unsigned int left, right;
147 
148  index_low = (index % 256);
149  index_high = ((index >> 8) % 256);
150 
151  left = TKIP_Sbox_Lower[index_low] + (TKIP_Sbox_Upper[index_low] * 256);
152  right = TKIP_Sbox_Upper[index_high] + (TKIP_Sbox_Lower[index_high] * 256);
153 
154  return (left ^ right);
155 };
156 
157 
158 unsigned int rotr1(unsigned int a)
159 {
160  unsigned int b;
161 
162  if ((a & 0x01) == 0x01) {
163  b = (a >> 1) | 0x8000;
164  } else {
165  b = (a >> 1) & 0x7fff;
166  }
167  b = b % 65536;
168  return b;
169 }
170 
171 
172 /*
173  * Description: Calculate RC4Key fom TK, TA, and TSC
174  *
175  * Parameters:
176  * In:
177  * pbyTKey - TKey
178  * pbyTA - TA
179  * dwTSC - TSC
180  * Out:
181  * pbyRC4Key - RC4Key
182  *
183  * Return Value: none
184  *
185  */
186 void TKIPvMixKey(
187  unsigned char *pbyTKey,
188  unsigned char *pbyTA,
189  unsigned short wTSC15_0,
190  unsigned long dwTSC47_16,
191  unsigned char *pbyRC4Key
192  )
193 {
194  unsigned int p1k[5];
195 // unsigned int ttak0, ttak1, ttak2, ttak3, ttak4;
196  unsigned int tsc0, tsc1, tsc2;
197  unsigned int ppk0, ppk1, ppk2, ppk3, ppk4, ppk5;
198  unsigned long int pnl,pnh;
199 
200  int i, j;
201 
202  pnl = wTSC15_0;
203  pnh = dwTSC47_16;
204 
205  tsc0 = (unsigned int)((pnh >> 16) % 65536); /* msb */
206  tsc1 = (unsigned int)(pnh % 65536);
207  tsc2 = (unsigned int)(pnl % 65536); /* lsb */
208 
209  /* Phase 1, step 1 */
210  p1k[0] = tsc1;
211  p1k[1] = tsc0;
212  p1k[2] = (unsigned int)(pbyTA[0] + (pbyTA[1]*256));
213  p1k[3] = (unsigned int)(pbyTA[2] + (pbyTA[3]*256));
214  p1k[4] = (unsigned int)(pbyTA[4] + (pbyTA[5]*256));
215 
216  /* Phase 1, step 2 */
217  for (i=0; i<8; i++) {
218  j = 2*(i & 1);
219  p1k[0] = (p1k[0] + tkip_sbox( (p1k[4] ^ ((256*pbyTKey[1+j]) + pbyTKey[j])) % 65536 )) % 65536;
220  p1k[1] = (p1k[1] + tkip_sbox( (p1k[0] ^ ((256*pbyTKey[5+j]) + pbyTKey[4+j])) % 65536 )) % 65536;
221  p1k[2] = (p1k[2] + tkip_sbox( (p1k[1] ^ ((256*pbyTKey[9+j]) + pbyTKey[8+j])) % 65536 )) % 65536;
222  p1k[3] = (p1k[3] + tkip_sbox( (p1k[2] ^ ((256*pbyTKey[13+j]) + pbyTKey[12+j])) % 65536 )) % 65536;
223  p1k[4] = (p1k[4] + tkip_sbox( (p1k[3] ^ (((256*pbyTKey[1+j]) + pbyTKey[j]))) % 65536 )) % 65536;
224  p1k[4] = (p1k[4] + i) % 65536;
225  }
226  /* Phase 2, Step 1 */
227  ppk0 = p1k[0];
228  ppk1 = p1k[1];
229  ppk2 = p1k[2];
230  ppk3 = p1k[3];
231  ppk4 = p1k[4];
232  ppk5 = (p1k[4] + tsc2) % 65536;
233 
234  /* Phase2, Step 2 */
235  ppk0 = ppk0 + tkip_sbox( (ppk5 ^ ((256*pbyTKey[1]) + pbyTKey[0])) % 65536);
236  ppk1 = ppk1 + tkip_sbox( (ppk0 ^ ((256*pbyTKey[3]) + pbyTKey[2])) % 65536);
237  ppk2 = ppk2 + tkip_sbox( (ppk1 ^ ((256*pbyTKey[5]) + pbyTKey[4])) % 65536);
238  ppk3 = ppk3 + tkip_sbox( (ppk2 ^ ((256*pbyTKey[7]) + pbyTKey[6])) % 65536);
239  ppk4 = ppk4 + tkip_sbox( (ppk3 ^ ((256*pbyTKey[9]) + pbyTKey[8])) % 65536);
240  ppk5 = ppk5 + tkip_sbox( (ppk4 ^ ((256*pbyTKey[11]) + pbyTKey[10])) % 65536);
241 
242  ppk0 = ppk0 + rotr1(ppk5 ^ ((256*pbyTKey[13]) + pbyTKey[12]));
243  ppk1 = ppk1 + rotr1(ppk0 ^ ((256*pbyTKey[15]) + pbyTKey[14]));
244  ppk2 = ppk2 + rotr1(ppk1);
245  ppk3 = ppk3 + rotr1(ppk2);
246  ppk4 = ppk4 + rotr1(ppk3);
247  ppk5 = ppk5 + rotr1(ppk4);
248 
249  /* Phase 2, Step 3 */
250  pbyRC4Key[0] = (tsc2 >> 8) % 256;
251  pbyRC4Key[1] = (((tsc2 >> 8) % 256) | 0x20) & 0x7f;
252  pbyRC4Key[2] = tsc2 % 256;
253  pbyRC4Key[3] = ((ppk5 ^ ((256*pbyTKey[1]) + pbyTKey[0])) >> 1) % 256;
254 
255  pbyRC4Key[4] = ppk0 % 256;
256  pbyRC4Key[5] = (ppk0 >> 8) % 256;
257 
258  pbyRC4Key[6] = ppk1 % 256;
259  pbyRC4Key[7] = (ppk1 >> 8) % 256;
260 
261  pbyRC4Key[8] = ppk2 % 256;
262  pbyRC4Key[9] = (ppk2 >> 8) % 256;
263 
264  pbyRC4Key[10] = ppk3 % 256;
265  pbyRC4Key[11] = (ppk3 >> 8) % 256;
266 
267  pbyRC4Key[12] = ppk4 % 256;
268  pbyRC4Key[13] = (ppk4 >> 8) % 256;
269 
270  pbyRC4Key[14] = ppk5 % 256;
271  pbyRC4Key[15] = (ppk5 >> 8) % 256;
272 }
Generated on Thu Jan 10 2013 14:32:30 for Linux Kernel by   doxygen 1.8.2