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