sys/net80211/ieee80211_crypto_wep.c

   1 /*-
   2  * Copyright (c) 2002-2008 Sam Leffler, Errno Consulting
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 /*
  30  * IEEE 802.11 WEP crypto support.
  31  */
  32 #include "opt_wlan.h"
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/mbuf.h>
  37 #include <sys/malloc.h>
  38 #include <sys/kernel.h>
  39 #include <sys/module.h>
  40 #include <sys/endian.h>
  41
  42 #include <sys/socket.h>
  43
  44 #include <net/if.h>
  45 #include <net/if_media.h>
  46 #include <net/ethernet.h>
  47
  48 #include <net80211/ieee80211_var.h>
  49
  50 static  void *wep_attach(struct ieee80211vap *, struct ieee80211_key *);
  51 static  void wep_detach(struct ieee80211_key *);
  52 static  int wep_setkey(struct ieee80211_key *);
  53 static  void wep_setiv(struct ieee80211_key *, uint8_t *);
  54 static  int wep_encap(struct ieee80211_key *, struct mbuf *);
  55 static  int wep_decap(struct ieee80211_key *, struct mbuf *, int);
  56 static  int wep_enmic(struct ieee80211_key *, struct mbuf *, int);
  57 static  int wep_demic(struct ieee80211_key *, struct mbuf *, int);
  58
  59 static const struct ieee80211_cipher wep = {
  60         .ic_name        = "WEP",
  61         .ic_cipher      = IEEE80211_CIPHER_WEP,
  62         .ic_header      = IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN,
  63         .ic_trailer     = IEEE80211_WEP_CRCLEN,
  64         .ic_miclen      = 0,
  65         .ic_attach      = wep_attach,
  66         .ic_detach      = wep_detach,
  67         .ic_setkey      = wep_setkey,
  68         .ic_setiv       = wep_setiv,
  69         .ic_encap       = wep_encap,
  70         .ic_decap       = wep_decap,
  71         .ic_enmic       = wep_enmic,
  72         .ic_demic       = wep_demic,
  73 };
  74
  75 static  int wep_encrypt(struct ieee80211_key *, struct mbuf *, int hdrlen);
  76 static  int wep_decrypt(struct ieee80211_key *, struct mbuf *, int hdrlen);
  77
  78 struct wep_ctx {
  79         struct ieee80211vap *wc_vap;    /* for diagnostics+statistics */
  80         struct ieee80211com *wc_ic;
  81         uint32_t        wc_iv;          /* initial vector for crypto */
  82 };
  83
  84 /* number of references from net80211 layer */
  85 static  int nrefs = 0;
  86
  87 static void *
  88 wep_attach(struct ieee80211vap *vap, struct ieee80211_key *k)
  89 {
  90         struct wep_ctx *ctx;
  91
  92         ctx = (struct wep_ctx *) IEEE80211_MALLOC(sizeof(struct wep_ctx),
  93                 M_80211_CRYPTO, IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
  94         if (ctx == NULL) {
  95                 vap->iv_stats.is_crypto_nomem++;
  96                 return NULL;
  97         }
  98
  99         ctx->wc_vap = vap;
 100         ctx->wc_ic = vap->iv_ic;
 101         get_random_bytes(&ctx->wc_iv, sizeof(ctx->wc_iv));
 102         nrefs++;                        /* NB: we assume caller locking */
 103         return ctx;
 104 }
 105
 106 static void
 107 wep_detach(struct ieee80211_key *k)
 108 {
 109         struct wep_ctx *ctx = k->wk_private;
 110
 111         IEEE80211_FREE(ctx, M_80211_CRYPTO);
 112         KASSERT(nrefs > 0, ("imbalanced attach/detach"));
 113         nrefs--;                        /* NB: we assume caller locking */
 114 }
 115
 116 static int
 117 wep_setkey(struct ieee80211_key *k)
 118 {
 119         return k->wk_keylen >= 40/NBBY;
 120 }
 121
 122 static void
 123 wep_setiv(struct ieee80211_key *k, uint8_t *ivp)
 124 {
 125         struct wep_ctx *ctx = k->wk_private;
 126         struct ieee80211vap *vap = ctx->wc_vap;
 127         uint32_t iv;
 128         uint8_t keyid;
 129
 130         keyid = ieee80211_crypto_get_keyid(vap, k) << 6;
 131
 132         /*
 133          * XXX
 134          * IV must not duplicate during the lifetime of the key.
 135          * But no mechanism to renew keys is defined in IEEE 802.11
 136          * for WEP.  And the IV may be duplicated at other stations
 137          * because the session key itself is shared.  So we use a
 138          * pseudo random IV for now, though it is not the right way.
 139          *
 140          * NB: Rather than use a strictly random IV we select a
 141          * random one to start and then increment the value for
 142          * each frame.  This is an explicit tradeoff between
 143          * overhead and security.  Given the basic insecurity of
 144          * WEP this seems worthwhile.
 145          */
 146
 147         /*
 148          * Skip 'bad' IVs from Fluhrer/Mantin/Shamir:
 149          * (B, 255, N) with 3 <= B < 16 and 0 <= N <= 255
 150          */
 151         iv = ctx->wc_iv;
 152         if ((iv & 0xff00) == 0xff00) {
 153                 int B = (iv & 0xff0000) >> 16;
 154                 if (3 <= B && B < 16)
 155                         iv += 0x0100;
 156         }
 157         ctx->wc_iv = iv + 1;
 158
 159         /*
 160          * NB: Preserve byte order of IV for packet
 161          *     sniffers; it doesn't matter otherwise.
 162          */
 163 #if _BYTE_ORDER == _BIG_ENDIAN
 164         ivp[0] = iv >> 0;
 165         ivp[1] = iv >> 8;
 166         ivp[2] = iv >> 16;
 167 #else
 168         ivp[2] = iv >> 0;
 169         ivp[1] = iv >> 8;
 170         ivp[0] = iv >> 16;
 171 #endif
 172         ivp[3] = keyid;
 173 }
 174
 175 /*
 176  * Add privacy headers appropriate for the specified key.
 177  */
 178 static int
 179 wep_encap(struct ieee80211_key *k, struct mbuf *m)
 180 {
 181         struct wep_ctx *ctx = k->wk_private;
 182         struct ieee80211com *ic = ctx->wc_ic;
 183         struct ieee80211_frame *wh;
 184         uint8_t *ivp;
 185         int hdrlen;
 186         int is_mgmt;
 187
 188         hdrlen = ieee80211_hdrspace(ic, mtod(m, void *));
 189         wh = mtod(m, struct ieee80211_frame *);
 190         is_mgmt = IEEE80211_IS_MGMT(wh);
 191
 192         /*
 193          * Check to see if IV is required.
 194          */
 195         if (is_mgmt && (k->wk_flags & IEEE80211_KEY_NOIVMGT))
 196                 return 1;
 197         if ((! is_mgmt) && (k->wk_flags & IEEE80211_KEY_NOIV))
 198                 return 1;
 199
 200         /*
 201          * Copy down 802.11 header and add the IV + KeyID.
 202          */
 203         M_PREPEND(m, wep.ic_header, M_NOWAIT);
 204         if (m == NULL)
 205                 return 0;
 206         ivp = mtod(m, uint8_t *);
 207         ovbcopy(ivp + wep.ic_header, ivp, hdrlen);
 208         ivp += hdrlen;
 209
 210         wep_setiv(k, ivp);
 211
 212         /*
 213          * Finally, do software encrypt if needed.
 214          */
 215         if ((k->wk_flags & IEEE80211_KEY_SWENCRYPT) &&
 216             !wep_encrypt(k, m, hdrlen))
 217                 return 0;
 218
 219         return 1;
 220 }
 221
 222 /*
 223  * Add MIC to the frame as needed.
 224  */
 225 static int
 226 wep_enmic(struct ieee80211_key *k, struct mbuf *m, int force)
 227 {
 228
 229         return 1;
 230 }
 231
 232 /*
 233  * Validate and strip privacy headers (and trailer) for a
 234  * received frame.  If necessary, decrypt the frame using
 235  * the specified key.
 236  */
 237 static int
 238 wep_decap(struct ieee80211_key *k, struct mbuf *m, int hdrlen)
 239 {
 240         struct wep_ctx *ctx = k->wk_private;
 241         struct ieee80211vap *vap = ctx->wc_vap;
 242         struct ieee80211_frame *wh;
 243         const struct ieee80211_rx_stats *rxs;
 244
 245         wh = mtod(m, struct ieee80211_frame *);
 246
 247         rxs = ieee80211_get_rx_params_ptr(m);
 248
 249         if ((rxs != NULL) && (rxs->c_pktflags & IEEE80211_RX_F_IV_STRIP))
 250                 goto finish;
 251
 252         /*
 253          * Check if the device handled the decrypt in hardware.
 254          * If so we just strip the header; otherwise we need to
 255          * handle the decrypt in software.
 256          */
 257         if ((k->wk_flags & IEEE80211_KEY_SWDECRYPT) &&
 258             !wep_decrypt(k, m, hdrlen)) {
 259                 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
 260                     "%s", "WEP ICV mismatch on decrypt");
 261                 vap->iv_stats.is_rx_wepfail++;
 262                 return 0;
 263         }
 264
 265         /*
 266          * Copy up 802.11 header and strip crypto bits.
 267          */
 268         ovbcopy(mtod(m, void *), mtod(m, uint8_t *) + wep.ic_header, hdrlen);
 269         m_adj(m, wep.ic_header);
 270
 271 finish:
 272         /* XXX TODO: do we have to strip this for offload devices? */
 273         m_adj(m, -wep.ic_trailer);
 274
 275         return 1;
 276 }
 277
 278 /*
 279  * Verify and strip MIC from the frame.
 280  */
 281 static int
 282 wep_demic(struct ieee80211_key *k, struct mbuf *skb, int force)
 283 {
 284         return 1;
 285 }
 286
 287 static const uint32_t crc32_table[256] = {
 288         0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
 289         0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
 290         0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
 291         0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
 292         0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
 293         0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
 294         0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
 295         0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
 296         0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
 297         0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
 298         0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
 299         0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
 300         0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
 301         0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
 302         0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
 303         0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
 304         0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
 305         0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
 306         0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
 307         0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
 308         0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
 309         0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
 310         0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
 311         0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
 312         0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
 313         0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
 314         0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
 315         0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
 316         0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
 317         0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
 318         0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
 319         0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
 320         0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
 321         0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
 322         0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
 323         0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
 324         0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
 325         0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
 326         0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
 327         0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
 328         0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
 329         0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
 330         0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
 331         0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
 332         0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
 333         0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
 334         0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
 335         0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
 336         0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
 337         0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
 338         0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
 339         0x2d02ef8dL
 340 };
 341
 342 static int
 343 wep_encrypt(struct ieee80211_key *key, struct mbuf *m0, int hdrlen)
 344 {
 345 #define S_SWAP(a,b) do { uint8_t t = S[a]; S[a] = S[b]; S[b] = t; } while(0)
 346         struct wep_ctx *ctx = key->wk_private;
 347         struct ieee80211vap *vap = ctx->wc_vap;
 348         struct mbuf *m = m0;
 349         uint8_t rc4key[IEEE80211_WEP_IVLEN + IEEE80211_KEYBUF_SIZE];
 350         uint8_t icv[IEEE80211_WEP_CRCLEN];
 351         uint32_t i, j, k, crc;
 352         size_t buflen, data_len;
 353         uint8_t S[256];
 354         uint8_t *pos;
 355         u_int off, keylen;
 356
 357         vap->iv_stats.is_crypto_wep++;
 358
 359         /* NB: this assumes the header was pulled up */
 360         memcpy(rc4key, mtod(m, uint8_t *) + hdrlen, IEEE80211_WEP_IVLEN);
 361         memcpy(rc4key + IEEE80211_WEP_IVLEN, key->wk_key, key->wk_keylen);
 362
 363         /* Setup RC4 state */
 364         for (i = 0; i < 256; i++)
 365                 S[i] = i;
 366         j = 0;
 367         keylen = key->wk_keylen + IEEE80211_WEP_IVLEN;
 368         for (i = 0; i < 256; i++) {
 369                 j = (j + S[i] + rc4key[i % keylen]) & 0xff;
 370                 S_SWAP(i, j);
 371         }
 372
 373         off = hdrlen + wep.ic_header;
 374         data_len = m->m_pkthdr.len - off;
 375
 376         /* Compute CRC32 over unencrypted data and apply RC4 to data */
 377         crc = ~0;
 378         i = j = 0;
 379         pos = mtod(m, uint8_t *) + off;
 380         buflen = m->m_len - off;
 381         for (;;) {
 382                 if (buflen > data_len)
 383                         buflen = data_len;
 384                 data_len -= buflen;
 385                 for (k = 0; k < buflen; k++) {
 386                         crc = crc32_table[(crc ^ *pos) & 0xff] ^ (crc >> 8);
 387                         i = (i + 1) & 0xff;
 388                         j = (j + S[i]) & 0xff;
 389                         S_SWAP(i, j);
 390                         *pos++ ^= S[(S[i] + S[j]) & 0xff];
 391                 }
 392                 if (m->m_next == NULL) {
 393                         if (data_len != 0) {            /* out of data */
 394                                 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO,
 395                                     ether_sprintf(mtod(m0,
 396                                         struct ieee80211_frame *)->i_addr2),
 397                                     "out of data for WEP (data_len %zu)",
 398                                     data_len);
 399                                 /* XXX stat */
 400                                 return 0;
 401                         }
 402                         break;
 403                 }
 404                 m = m->m_next;
 405                 pos = mtod(m, uint8_t *);
 406                 buflen = m->m_len;
 407         }
 408         crc = ~crc;
 409
 410         /* Append little-endian CRC32 and encrypt it to produce ICV */
 411         icv[0] = crc;
 412         icv[1] = crc >> 8;
 413         icv[2] = crc >> 16;
 414         icv[3] = crc >> 24;
 415         for (k = 0; k < IEEE80211_WEP_CRCLEN; k++) {
 416                 i = (i + 1) & 0xff;
 417                 j = (j + S[i]) & 0xff;
 418                 S_SWAP(i, j);
 419                 icv[k] ^= S[(S[i] + S[j]) & 0xff];
 420         }
 421         return m_append(m0, IEEE80211_WEP_CRCLEN, icv);
 422 #undef S_SWAP
 423 }
 424
 425 static int
 426 wep_decrypt(struct ieee80211_key *key, struct mbuf *m0, int hdrlen)
 427 {
 428 #define S_SWAP(a,b) do { uint8_t t = S[a]; S[a] = S[b]; S[b] = t; } while(0)
 429         struct wep_ctx *ctx = key->wk_private;
 430         struct ieee80211vap *vap = ctx->wc_vap;
 431         struct mbuf *m = m0;
 432         uint8_t rc4key[IEEE80211_WEP_IVLEN + IEEE80211_KEYBUF_SIZE];
 433         uint8_t icv[IEEE80211_WEP_CRCLEN];
 434         uint32_t i, j, k, crc;
 435         size_t buflen, data_len;
 436         uint8_t S[256];
 437         uint8_t *pos;
 438         u_int off, keylen;
 439
 440         vap->iv_stats.is_crypto_wep++;
 441
 442         /* NB: this assumes the header was pulled up */
 443         memcpy(rc4key, mtod(m, uint8_t *) + hdrlen, IEEE80211_WEP_IVLEN);
 444         memcpy(rc4key + IEEE80211_WEP_IVLEN, key->wk_key, key->wk_keylen);
 445
 446         /* Setup RC4 state */
 447         for (i = 0; i < 256; i++)
 448                 S[i] = i;
 449         j = 0;
 450         keylen = key->wk_keylen + IEEE80211_WEP_IVLEN;
 451         for (i = 0; i < 256; i++) {
 452                 j = (j + S[i] + rc4key[i % keylen]) & 0xff;
 453                 S_SWAP(i, j);
 454         }
 455
 456         off = hdrlen + wep.ic_header;
 457         data_len = m->m_pkthdr.len - (off + wep.ic_trailer);
 458
 459         /* Compute CRC32 over unencrypted data and apply RC4 to data */
 460         crc = ~0;
 461         i = j = 0;
 462         pos = mtod(m, uint8_t *) + off;
 463         buflen = m->m_len - off;
 464         for (;;) {
 465                 if (buflen > data_len)
 466                         buflen = data_len;
 467                 data_len -= buflen;
 468                 for (k = 0; k < buflen; k++) {
 469                         i = (i + 1) & 0xff;
 470                         j = (j + S[i]) & 0xff;
 471                         S_SWAP(i, j);
 472                         *pos ^= S[(S[i] + S[j]) & 0xff];
 473                         crc = crc32_table[(crc ^ *pos) & 0xff] ^ (crc >> 8);
 474                         pos++;
 475                 }
 476                 m = m->m_next;
 477                 if (m == NULL) {
 478                         if (data_len != 0) {            /* out of data */
 479                                 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO,
 480                                     mtod(m0, struct ieee80211_frame *)->i_addr2,
 481                                     "out of data for WEP (data_len %zu)",
 482                                     data_len);
 483                                 return 0;
 484                         }
 485                         break;
 486                 }
 487                 pos = mtod(m, uint8_t *);
 488                 buflen = m->m_len;
 489         }
 490         crc = ~crc;
 491
 492         /* Encrypt little-endian CRC32 and verify that it matches with
 493          * received ICV */
 494         icv[0] = crc;
 495         icv[1] = crc >> 8;
 496         icv[2] = crc >> 16;
 497         icv[3] = crc >> 24;
 498         for (k = 0; k < IEEE80211_WEP_CRCLEN; k++) {
 499                 i = (i + 1) & 0xff;
 500                 j = (j + S[i]) & 0xff;
 501                 S_SWAP(i, j);
 502                 /* XXX assumes ICV is contiguous in mbuf */
 503                 if ((icv[k] ^ S[(S[i] + S[j]) & 0xff]) != *pos++) {
 504                         /* ICV mismatch - drop frame */
 505                         return 0;
 506                 }
 507         }
 508         return 1;
 509 #undef S_SWAP
 510 }
 511
 512 /*
 513  * Module glue.
 514  */
 515 IEEE80211_CRYPTO_MODULE(wep, 1);