drivers/staging/vt6656/tkip.c

   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 BYTE 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 BYTE 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: Caculate 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     PBYTE   pbyTKey,
 188     PBYTE   pbyTA,
 189     WORD    wTSC15_0,
 190     DWORD   dwTSC47_16,
 191     PBYTE   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 }