drivers/staging/wlan-ng/p80211wep.c

   1 /* src/p80211/p80211wep.c
   2 *
   3 * WEP encode/decode for P80211.
   4 *
   5 * Copyright (C) 2002 AbsoluteValue Systems, Inc.  All Rights Reserved.
   6 * --------------------------------------------------------------------
   7 *
   8 * linux-wlan
   9 *
  10 *   The contents of this file are subject to the Mozilla Public
  11 *   License Version 1.1 (the "License"); you may not use this file
  12 *   except in compliance with the License. You may obtain a copy of
  13 *   the License at http://www.mozilla.org/MPL/
  14 *
  15 *   Software distributed under the License is distributed on an "AS
  16 *   IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  17 *   implied. See the License for the specific language governing
  18 *   rights and limitations under the License.
  19 *
  20 *   Alternatively, the contents of this file may be used under the
  21 *   terms of the GNU Public License version 2 (the "GPL"), in which
  22 *   case the provisions of the GPL are applicable instead of the
  23 *   above.  If you wish to allow the use of your version of this file
  24 *   only under the terms of the GPL and not to allow others to use
  25 *   your version of this file under the MPL, indicate your decision
  26 *   by deleting the provisions above and replace them with the notice
  27 *   and other provisions required by the GPL.  If you do not delete
  28 *   the provisions above, a recipient may use your version of this
  29 *   file under either the MPL or the GPL.
  30 *
  31 * --------------------------------------------------------------------
  32 *
  33 * Inquiries regarding the linux-wlan Open Source project can be
  34 * made directly to:
  35 *
  36 * AbsoluteValue Systems Inc.
  37 * info@linux-wlan.com
  38 * http://www.linux-wlan.com
  39 *
  40 * --------------------------------------------------------------------
  41 *
  42 * Portions of the development of this software were funded by
  43 * Intersil Corporation as part of PRISM(R) chipset product development.
  44 *
  45 * --------------------------------------------------------------------
  46 */
  47
  48 /*================================================================*/
  49 /* System Includes */
  50
  51
  52 #include <linux/version.h>
  53
  54 #include <linux/netdevice.h>
  55 #include <linux/wireless.h>
  56 #include <linux/slab.h>
  57 #include <linux/random.h>
  58
  59 #include "version.h"
  60 #include "wlan_compat.h"
  61
  62 // #define WEP_DEBUG
  63
  64 /*================================================================*/
  65 /* Project Includes */
  66
  67 #include "p80211hdr.h"
  68 #include "p80211types.h"
  69 #include "p80211msg.h"
  70 #include "p80211conv.h"
  71 #include "p80211netdev.h"
  72
  73 /*================================================================*/
  74 /* Local Constants */
  75
  76 #define SSWAP(a,b) {UINT8 tmp = s[a]; s[a] = s[b]; s[b] = tmp;}
  77 #define WEP_KEY(x)       (((x) & 0xC0) >> 6)
  78
  79 /*================================================================*/
  80 /* Local Macros */
  81
  82
  83 /*================================================================*/
  84 /* Local Types */
  85
  86
  87 /*================================================================*/
  88 /* Local Static Definitions */
  89
  90 static const UINT32 wep_crc32_table[256] = {
  91         0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
  92         0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
  93         0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
  94         0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
  95         0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
  96         0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
  97         0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
  98         0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
  99         0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
 100         0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
 101         0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
 102         0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
 103         0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
 104         0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
 105         0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
 106         0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
 107         0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
 108         0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
 109         0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
 110         0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
 111         0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
 112         0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
 113         0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
 114         0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
 115         0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
 116         0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
 117         0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
 118         0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
 119         0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
 120         0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
 121         0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
 122         0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
 123         0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
 124         0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
 125         0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
 126         0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
 127         0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
 128         0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
 129         0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
 130         0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
 131         0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
 132         0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
 133         0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
 134         0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
 135         0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
 136         0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
 137         0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
 138         0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
 139         0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
 140         0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
 141         0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
 142         0x2d02ef8dL
 143 };
 144
 145 /*================================================================*/
 146 /* Local Function Declarations */
 147
 148 /*================================================================*/
 149 /* Function Definitions */
 150
 151 /* keylen in bytes! */
 152
 153 int wep_change_key(wlandevice_t *wlandev, int keynum, UINT8* key, int keylen)
 154 {
 155         if (keylen < 0)  return -1;
 156         if (keylen >= MAX_KEYLEN) return -1;
 157         if (key == NULL) return -1;
 158         if (keynum < 0)  return -1;
 159         if (keynum >= NUM_WEPKEYS) return -1;
 160
 161
 162 #ifdef WEP_DEBUG
 163         printk(KERN_DEBUG "WEP key %d len %d = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", keynum, keylen, key[0], key[1], key[2], key[3], key[4], key[5], key[6], key[7]);
 164 #endif
 165
 166         wlandev->wep_keylens[keynum] = keylen;
 167         memcpy(wlandev->wep_keys[keynum], key, keylen);
 168
 169         return 0;
 170 }
 171
 172 /*
 173   4-byte IV at start of buffer, 4-byte ICV at end of buffer.
 174   if successful, buf start is payload begin, length -= 8;
 175  */
 176 int wep_decrypt(wlandevice_t *wlandev, UINT8 *buf, UINT32 len, int key_override, UINT8 *iv, UINT8 *icv)
 177 {
 178         UINT32 i, j, k, crc, keylen;
 179         UINT8 s[256], key[64], c_crc[4];
 180         UINT8 keyidx;
 181
 182         /* Needs to be at least 8 bytes of payload */
 183         if (len <= 0) return -1;
 184
 185         /* initialize the first bytes of the key from the IV */
 186         key[0] = iv[0];
 187         key[1] = iv[1];
 188         key[2] = iv[2];
 189         keyidx = WEP_KEY(iv[3]);
 190
 191         if (key_override >= 0)
 192                 keyidx = key_override;
 193
 194         if (keyidx >= NUM_WEPKEYS) return -2;
 195
 196         keylen = wlandev->wep_keylens[keyidx];
 197
 198         if (keylen == 0) return -3;
 199
 200         /* copy the rest of the key over from the designated key */
 201         memcpy(key+3, wlandev->wep_keys[keyidx], keylen);
 202
 203         keylen+=3;  /* add in IV bytes */
 204
 205 #ifdef WEP_DEBUG
 206         printk(KERN_DEBUG "D %d: %02x %02x %02x (%d %d) %02x:%02x:%02x:%02x:%02x\n", len, key[0], key[1], key[2], keyidx, keylen, key[3], key[4], key[5], key[6], key[7]);
 207 #endif
 208
 209         /* set up the RC4 state */
 210         for (i = 0; i < 256; i++)
 211                 s[i] = i;
 212         j = 0;
 213         for (i = 0; i < 256; i++) {
 214                 j = (j + s[i] + key[i % keylen]) & 0xff;
 215                 SSWAP(i,j);
 216         }
 217
 218         /* Apply the RC4 to the data, update the CRC32 */
 219         crc = ~0;
 220         i = j = 0;
 221         for (k = 0; k < len; k++) {
 222                 i = (i+1) & 0xff;
 223                 j = (j+s[i]) & 0xff;
 224                 SSWAP(i,j);
 225                 buf[k] ^= s[(s[i] + s[j]) & 0xff];
 226                 crc = wep_crc32_table[(crc ^ buf[k]) & 0xff] ^ (crc >> 8);
 227         }
 228         crc = ~crc;
 229
 230         /* now let's check the crc */
 231         c_crc[0] = crc;
 232         c_crc[1] = crc >> 8;
 233         c_crc[2] = crc >> 16;
 234         c_crc[3] = crc >> 24;
 235
 236         for (k = 0; k < 4; k++) {
 237                 i = (i + 1) & 0xff;
 238                 j = (j+s[i]) & 0xff;
 239                 SSWAP(i,j);
 240                 if ((c_crc[k] ^ s[(s[i] + s[j]) & 0xff]) != icv[k])
 241                         return -(4 | (k << 4)) ; /* ICV mismatch */
 242         }
 243
 244         return 0;
 245 }
 246
 247 /* encrypts in-place. */
 248 int wep_encrypt(wlandevice_t *wlandev, UINT8 *buf, UINT8 *dst, UINT32 len, int keynum, UINT8 *iv, UINT8 *icv)
 249 {
 250         UINT32 i, j, k, crc, keylen;
 251         UINT8 s[256], key[64];
 252
 253         /* no point in WEPping an empty frame */
 254         if (len <= 0) return -1;
 255
 256         /* we need to have a real key.. */
 257         if (keynum >= NUM_WEPKEYS) return -2;
 258         keylen = wlandev->wep_keylens[keynum];
 259         if (keylen <= 0) return -3;
 260
 261         /* use a random IV.  And skip known weak ones. */
 262         get_random_bytes(iv, 3);
 263         while ((iv[1] == 0xff) && (iv[0] >= 3) && (iv[0] < keylen))
 264                 get_random_bytes(iv, 3);
 265
 266         iv[3] = (keynum & 0x03) << 6;
 267
 268         key[0] = iv[0];
 269         key[1] = iv[1];
 270         key[2] = iv[2];
 271
 272         /* copy the rest of the key over from the designated key */
 273         memcpy(key+3, wlandev->wep_keys[keynum], keylen);
 274
 275         keylen+=3;  /* add in IV bytes */
 276
 277 #ifdef WEP_DEBUG
 278         printk(KERN_DEBUG "E %d (%d/%d %d) %02x %02x %02x %02x:%02x:%02x:%02x:%02x\n", len,  iv[3], keynum, keylen, key[0], key[1], key[2], key[3], key[4], key[5], key[6], key[7]);
 279 #endif
 280
 281         /* set up the RC4 state */
 282         for (i = 0; i < 256; i++)
 283                 s[i] = i;
 284         j = 0;
 285         for (i = 0; i < 256; i++) {
 286                 j = (j + s[i] + key[i % keylen]) & 0xff;
 287                 SSWAP(i,j);
 288         }
 289
 290         /* Update CRC32 then apply RC4 to the data */
 291         crc = ~0;
 292         i = j = 0;
 293         for (k = 0; k < len; k++) {
 294                 crc = wep_crc32_table[(crc ^ buf[k]) & 0xff] ^ (crc >> 8);
 295                 i = (i+1) & 0xff;
 296                 j = (j+s[i]) & 0xff;
 297                 SSWAP(i,j);
 298                 dst[k] = buf[k] ^ s[(s[i] + s[j]) & 0xff];
 299         }
 300         crc = ~crc;
 301
 302         /* now let's encrypt the crc */
 303         icv[0] = crc;
 304         icv[1] = crc >> 8;
 305         icv[2] = crc >> 16;
 306         icv[3] = crc >> 24;
 307
 308         for (k = 0; k < 4; k++) {
 309                 i = (i + 1) & 0xff;
 310                 j = (j+s[i]) & 0xff;
 311                 SSWAP(i,j);
 312                 icv[k] ^= s[(s[i] + s[j]) & 0xff];
 313         }
 314
 315         return 0;
 316 }