drivers/staging/vt6655/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 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 }