sys/net80211/ieee80211_crypto_wep.c

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