linux/net/mac80211/wep.c
<<
>>
Prefs
   1/*
   2 * Software WEP encryption implementation
   3 * Copyright 2002, Jouni Malinen <jkmaline@cc.hut.fi>
   4 * Copyright 2003, Instant802 Networks, Inc.
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License version 2 as
   8 * published by the Free Software Foundation.
   9 */
  10
  11#include <linux/netdevice.h>
  12#include <linux/types.h>
  13#include <linux/random.h>
  14#include <linux/compiler.h>
  15#include <linux/crc32.h>
  16#include <linux/crypto.h>
  17#include <linux/err.h>
  18#include <linux/mm.h>
  19#include <linux/scatterlist.h>
  20#include <asm/unaligned.h>
  21
  22#include <net/mac80211.h>
  23#include "ieee80211_i.h"
  24#include "wep.h"
  25
  26
  27int ieee80211_wep_init(struct ieee80211_local *local)
  28{
  29        /* start WEP IV from a random value */
  30        get_random_bytes(&local->wep_iv, WEP_IV_LEN);
  31
  32        local->wep_tx_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0,
  33                                                CRYPTO_ALG_ASYNC);
  34        if (IS_ERR(local->wep_tx_tfm))
  35                return PTR_ERR(local->wep_tx_tfm);
  36
  37        local->wep_rx_tfm = crypto_alloc_blkcipher("ecb(arc4)", 0,
  38                                                CRYPTO_ALG_ASYNC);
  39        if (IS_ERR(local->wep_rx_tfm)) {
  40                crypto_free_blkcipher(local->wep_tx_tfm);
  41                return PTR_ERR(local->wep_rx_tfm);
  42        }
  43
  44        return 0;
  45}
  46
  47void ieee80211_wep_free(struct ieee80211_local *local)
  48{
  49        crypto_free_blkcipher(local->wep_tx_tfm);
  50        crypto_free_blkcipher(local->wep_rx_tfm);
  51}
  52
  53static inline bool ieee80211_wep_weak_iv(u32 iv, int keylen)
  54{
  55        /*
  56         * Fluhrer, Mantin, and Shamir have reported weaknesses in the
  57         * key scheduling algorithm of RC4. At least IVs (KeyByte + 3,
  58         * 0xff, N) can be used to speedup attacks, so avoid using them.
  59         */
  60        if ((iv & 0xff00) == 0xff00) {
  61                u8 B = (iv >> 16) & 0xff;
  62                if (B >= 3 && B < 3 + keylen)
  63                        return true;
  64        }
  65        return false;
  66}
  67
  68
  69static void ieee80211_wep_get_iv(struct ieee80211_local *local,
  70                                 struct ieee80211_key *key, u8 *iv)
  71{
  72        local->wep_iv++;
  73        if (ieee80211_wep_weak_iv(local->wep_iv, key->conf.keylen))
  74                local->wep_iv += 0x0100;
  75
  76        if (!iv)
  77                return;
  78
  79        *iv++ = (local->wep_iv >> 16) & 0xff;
  80        *iv++ = (local->wep_iv >> 8) & 0xff;
  81        *iv++ = local->wep_iv & 0xff;
  82        *iv++ = key->conf.keyidx << 6;
  83}
  84
  85
  86static u8 *ieee80211_wep_add_iv(struct ieee80211_local *local,
  87                                struct sk_buff *skb,
  88                                struct ieee80211_key *key)
  89{
  90        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
  91        unsigned int hdrlen;
  92        u8 *newhdr;
  93
  94        hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
  95
  96        if (WARN_ON(skb_tailroom(skb) < WEP_ICV_LEN ||
  97                    skb_headroom(skb) < WEP_IV_LEN))
  98                return NULL;
  99
 100        hdrlen = ieee80211_hdrlen(hdr->frame_control);
 101        newhdr = skb_push(skb, WEP_IV_LEN);
 102        memmove(newhdr, newhdr + WEP_IV_LEN, hdrlen);
 103        ieee80211_wep_get_iv(local, key, newhdr + hdrlen);
 104        return newhdr + hdrlen;
 105}
 106
 107
 108static void ieee80211_wep_remove_iv(struct ieee80211_local *local,
 109                                    struct sk_buff *skb,
 110                                    struct ieee80211_key *key)
 111{
 112        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 113        unsigned int hdrlen;
 114
 115        hdrlen = ieee80211_hdrlen(hdr->frame_control);
 116        memmove(skb->data + WEP_IV_LEN, skb->data, hdrlen);
 117        skb_pull(skb, WEP_IV_LEN);
 118}
 119
 120
 121/* Perform WEP encryption using given key. data buffer must have tailroom
 122 * for 4-byte ICV. data_len must not include this ICV. Note: this function
 123 * does _not_ add IV. data = RC4(data | CRC32(data)) */
 124void ieee80211_wep_encrypt_data(struct crypto_blkcipher *tfm, u8 *rc4key,
 125                                size_t klen, u8 *data, size_t data_len)
 126{
 127        struct blkcipher_desc desc = { .tfm = tfm };
 128        struct scatterlist sg;
 129        __le32 icv;
 130
 131        icv = cpu_to_le32(~crc32_le(~0, data, data_len));
 132        put_unaligned(icv, (__le32 *)(data + data_len));
 133
 134        crypto_blkcipher_setkey(tfm, rc4key, klen);
 135        sg_init_one(&sg, data, data_len + WEP_ICV_LEN);
 136        crypto_blkcipher_encrypt(&desc, &sg, &sg, sg.length);
 137}
 138
 139
 140/* Perform WEP encryption on given skb. 4 bytes of extra space (IV) in the
 141 * beginning of the buffer 4 bytes of extra space (ICV) in the end of the
 142 * buffer will be added. Both IV and ICV will be transmitted, so the
 143 * payload length increases with 8 bytes.
 144 *
 145 * WEP frame payload: IV + TX key idx, RC4(data), ICV = RC4(CRC32(data))
 146 */
 147int ieee80211_wep_encrypt(struct ieee80211_local *local, struct sk_buff *skb,
 148                          struct ieee80211_key *key)
 149{
 150        u32 klen;
 151        u8 *rc4key, *iv;
 152        size_t len;
 153
 154        if (!key || key->conf.alg != ALG_WEP)
 155                return -1;
 156
 157        klen = 3 + key->conf.keylen;
 158        rc4key = kmalloc(klen, GFP_ATOMIC);
 159        if (!rc4key)
 160                return -1;
 161
 162        iv = ieee80211_wep_add_iv(local, skb, key);
 163        if (!iv) {
 164                kfree(rc4key);
 165                return -1;
 166        }
 167
 168        len = skb->len - (iv + WEP_IV_LEN - skb->data);
 169
 170        /* Prepend 24-bit IV to RC4 key */
 171        memcpy(rc4key, iv, 3);
 172
 173        /* Copy rest of the WEP key (the secret part) */
 174        memcpy(rc4key + 3, key->conf.key, key->conf.keylen);
 175
 176        /* Add room for ICV */
 177        skb_put(skb, WEP_ICV_LEN);
 178
 179        ieee80211_wep_encrypt_data(local->wep_tx_tfm, rc4key, klen,
 180                                   iv + WEP_IV_LEN, len);
 181
 182        kfree(rc4key);
 183
 184        return 0;
 185}
 186
 187
 188/* Perform WEP decryption using given key. data buffer includes encrypted
 189 * payload, including 4-byte ICV, but _not_ IV. data_len must not include ICV.
 190 * Return 0 on success and -1 on ICV mismatch. */
 191int ieee80211_wep_decrypt_data(struct crypto_blkcipher *tfm, u8 *rc4key,
 192                               size_t klen, u8 *data, size_t data_len)
 193{
 194        struct blkcipher_desc desc = { .tfm = tfm };
 195        struct scatterlist sg;
 196        __le32 crc;
 197
 198        crypto_blkcipher_setkey(tfm, rc4key, klen);
 199        sg_init_one(&sg, data, data_len + WEP_ICV_LEN);
 200        crypto_blkcipher_decrypt(&desc, &sg, &sg, sg.length);
 201
 202        crc = cpu_to_le32(~crc32_le(~0, data, data_len));
 203        if (memcmp(&crc, data + data_len, WEP_ICV_LEN) != 0)
 204                /* ICV mismatch */
 205                return -1;
 206
 207        return 0;
 208}
 209
 210
 211/* Perform WEP decryption on given skb. Buffer includes whole WEP part of
 212 * the frame: IV (4 bytes), encrypted payload (including SNAP header),
 213 * ICV (4 bytes). skb->len includes both IV and ICV.
 214 *
 215 * Returns 0 if frame was decrypted successfully and ICV was correct and -1 on
 216 * failure. If frame is OK, IV and ICV will be removed, i.e., decrypted payload
 217 * is moved to the beginning of the skb and skb length will be reduced.
 218 */
 219int ieee80211_wep_decrypt(struct ieee80211_local *local, struct sk_buff *skb,
 220                          struct ieee80211_key *key)
 221{
 222        u32 klen;
 223        u8 *rc4key;
 224        u8 keyidx;
 225        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 226        unsigned int hdrlen;
 227        size_t len;
 228        int ret = 0;
 229
 230        if (!ieee80211_has_protected(hdr->frame_control))
 231                return -1;
 232
 233        hdrlen = ieee80211_hdrlen(hdr->frame_control);
 234        if (skb->len < hdrlen + WEP_IV_LEN + WEP_ICV_LEN)
 235                return -1;
 236
 237        len = skb->len - hdrlen - WEP_IV_LEN - WEP_ICV_LEN;
 238
 239        keyidx = skb->data[hdrlen + 3] >> 6;
 240
 241        if (!key || keyidx != key->conf.keyidx || key->conf.alg != ALG_WEP)
 242                return -1;
 243
 244        klen = 3 + key->conf.keylen;
 245
 246        rc4key = kmalloc(klen, GFP_ATOMIC);
 247        if (!rc4key)
 248                return -1;
 249
 250        /* Prepend 24-bit IV to RC4 key */
 251        memcpy(rc4key, skb->data + hdrlen, 3);
 252
 253        /* Copy rest of the WEP key (the secret part) */
 254        memcpy(rc4key + 3, key->conf.key, key->conf.keylen);
 255
 256        if (ieee80211_wep_decrypt_data(local->wep_rx_tfm, rc4key, klen,
 257                                       skb->data + hdrlen + WEP_IV_LEN,
 258                                       len))
 259                ret = -1;
 260
 261        kfree(rc4key);
 262
 263        /* Trim ICV */
 264        skb_trim(skb, skb->len - WEP_ICV_LEN);
 265
 266        /* Remove IV */
 267        memmove(skb->data + WEP_IV_LEN, skb->data, hdrlen);
 268        skb_pull(skb, WEP_IV_LEN);
 269
 270        return ret;
 271}
 272
 273
 274bool ieee80211_wep_is_weak_iv(struct sk_buff *skb, struct ieee80211_key *key)
 275{
 276        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 277        unsigned int hdrlen;
 278        u8 *ivpos;
 279        u32 iv;
 280
 281        if (!ieee80211_has_protected(hdr->frame_control))
 282                return false;
 283
 284        hdrlen = ieee80211_hdrlen(hdr->frame_control);
 285        ivpos = skb->data + hdrlen;
 286        iv = (ivpos[0] << 16) | (ivpos[1] << 8) | ivpos[2];
 287
 288        return ieee80211_wep_weak_iv(iv, key->conf.keylen);
 289}
 290
 291ieee80211_rx_result
 292ieee80211_crypto_wep_decrypt(struct ieee80211_rx_data *rx)
 293{
 294        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
 295
 296        if (!ieee80211_is_data(hdr->frame_control) &&
 297            !ieee80211_is_auth(hdr->frame_control))
 298                return RX_CONTINUE;
 299
 300        if (!(rx->status->flag & RX_FLAG_DECRYPTED)) {
 301                if (ieee80211_wep_decrypt(rx->local, rx->skb, rx->key))
 302                        return RX_DROP_UNUSABLE;
 303        } else if (!(rx->status->flag & RX_FLAG_IV_STRIPPED)) {
 304                ieee80211_wep_remove_iv(rx->local, rx->skb, rx->key);
 305                /* remove ICV */
 306                skb_trim(rx->skb, rx->skb->len - WEP_ICV_LEN);
 307        }
 308
 309        return RX_CONTINUE;
 310}
 311
 312static int wep_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
 313{
 314        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 315
 316        if (!(tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) {
 317                if (ieee80211_wep_encrypt(tx->local, skb, tx->key))
 318                        return -1;
 319        } else {
 320                info->control.hw_key = &tx->key->conf;
 321                if (tx->key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV) {
 322                        if (!ieee80211_wep_add_iv(tx->local, skb, tx->key))
 323                                return -1;
 324                }
 325        }
 326        return 0;
 327}
 328
 329ieee80211_tx_result
 330ieee80211_crypto_wep_encrypt(struct ieee80211_tx_data *tx)
 331{
 332        struct sk_buff *skb;
 333
 334        ieee80211_tx_set_protected(tx);
 335
 336        skb = tx->skb;
 337        do {
 338                if (wep_encrypt_skb(tx, skb) < 0) {
 339                        I802_DEBUG_INC(tx->local->tx_handlers_drop_wep);
 340                        return TX_DROP;
 341                }
 342        } while ((skb = skb->next));
 343
 344        return TX_CONTINUE;
 345}
 346