The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net80211/ieee80211_crypto_ccmp.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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.11i AES-CCMP crypto support.
   33  *
   34  * Part of this module is derived from similar code in the Host
   35  * AP driver. The code is used with the consent of the author and
   36  * it's license is included below.
   37  */
   38 #include "opt_wlan.h"
   39 
   40 #include <sys/param.h>
   41 #include <sys/systm.h> 
   42 #include <sys/mbuf.h>   
   43 #include <sys/malloc.h>
   44 #include <sys/kernel.h>
   45 #include <sys/module.h>
   46 
   47 #include <sys/socket.h>
   48 
   49 #include <net/if.h>
   50 #include <net/if_media.h>
   51 #include <net/ethernet.h>
   52 
   53 #include <net80211/ieee80211_var.h>
   54 
   55 #include <crypto/rijndael/rijndael.h>
   56 
   57 #define AES_BLOCK_LEN 16
   58 
   59 struct ccmp_ctx {
   60         struct ieee80211vap *cc_vap;    /* for diagnostics+statistics */
   61         struct ieee80211com *cc_ic;
   62         rijndael_ctx         cc_aes;
   63 };
   64 
   65 static  void *ccmp_attach(struct ieee80211vap *, struct ieee80211_key *);
   66 static  void ccmp_detach(struct ieee80211_key *);
   67 static  int ccmp_setkey(struct ieee80211_key *);
   68 static  void ccmp_setiv(struct ieee80211_key *, uint8_t *);
   69 static  int ccmp_encap(struct ieee80211_key *, struct mbuf *);
   70 static  int ccmp_decap(struct ieee80211_key *, struct mbuf *, int);
   71 static  int ccmp_enmic(struct ieee80211_key *, struct mbuf *, int);
   72 static  int ccmp_demic(struct ieee80211_key *, struct mbuf *, int);
   73 
   74 static const struct ieee80211_cipher ccmp = {
   75         .ic_name        = "AES-CCM",
   76         .ic_cipher      = IEEE80211_CIPHER_AES_CCM,
   77         .ic_header      = IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN +
   78                           IEEE80211_WEP_EXTIVLEN,
   79         .ic_trailer     = IEEE80211_WEP_MICLEN,
   80         .ic_miclen      = 0,
   81         .ic_attach      = ccmp_attach,
   82         .ic_detach      = ccmp_detach,
   83         .ic_setkey      = ccmp_setkey,
   84         .ic_setiv       = ccmp_setiv,
   85         .ic_encap       = ccmp_encap,
   86         .ic_decap       = ccmp_decap,
   87         .ic_enmic       = ccmp_enmic,
   88         .ic_demic       = ccmp_demic,
   89 };
   90 
   91 static  int ccmp_encrypt(struct ieee80211_key *, struct mbuf *, int hdrlen);
   92 static  int ccmp_decrypt(struct ieee80211_key *, u_int64_t pn,
   93                 struct mbuf *, int hdrlen);
   94 
   95 /* number of references from net80211 layer */
   96 static  int nrefs = 0;
   97 
   98 static void *
   99 ccmp_attach(struct ieee80211vap *vap, struct ieee80211_key *k)
  100 {
  101         struct ccmp_ctx *ctx;
  102 
  103         ctx = (struct ccmp_ctx *) IEEE80211_MALLOC(sizeof(struct ccmp_ctx),
  104                 M_80211_CRYPTO, IEEE80211_M_NOWAIT | IEEE80211_M_ZERO);
  105         if (ctx == NULL) {
  106                 vap->iv_stats.is_crypto_nomem++;
  107                 return NULL;
  108         }
  109         ctx->cc_vap = vap;
  110         ctx->cc_ic = vap->iv_ic;
  111         nrefs++;                        /* NB: we assume caller locking */
  112         return ctx;
  113 }
  114 
  115 static void
  116 ccmp_detach(struct ieee80211_key *k)
  117 {
  118         struct ccmp_ctx *ctx = k->wk_private;
  119 
  120         IEEE80211_FREE(ctx, M_80211_CRYPTO);
  121         KASSERT(nrefs > 0, ("imbalanced attach/detach"));
  122         nrefs--;                        /* NB: we assume caller locking */
  123 }
  124 
  125 static int
  126 ccmp_setkey(struct ieee80211_key *k)
  127 {
  128         struct ccmp_ctx *ctx = k->wk_private;
  129 
  130         if (k->wk_keylen != (128/NBBY)) {
  131                 IEEE80211_DPRINTF(ctx->cc_vap, IEEE80211_MSG_CRYPTO,
  132                         "%s: Invalid key length %u, expecting %u\n",
  133                         __func__, k->wk_keylen, 128/NBBY);
  134                 return 0;
  135         }
  136         if (k->wk_flags & IEEE80211_KEY_SWENCRYPT)
  137                 rijndael_set_key(&ctx->cc_aes, k->wk_key, k->wk_keylen*NBBY);
  138         return 1;
  139 }
  140 
  141 static void
  142 ccmp_setiv(struct ieee80211_key *k, uint8_t *ivp)
  143 {
  144         struct ccmp_ctx *ctx = k->wk_private;
  145         struct ieee80211vap *vap = ctx->cc_vap;
  146         uint8_t keyid;
  147 
  148         keyid = ieee80211_crypto_get_keyid(vap, k) << 6;
  149 
  150         k->wk_keytsc++;
  151         ivp[0] = k->wk_keytsc >> 0;             /* PN0 */
  152         ivp[1] = k->wk_keytsc >> 8;             /* PN1 */
  153         ivp[2] = 0;                             /* Reserved */
  154         ivp[3] = keyid | IEEE80211_WEP_EXTIV;   /* KeyID | ExtID */
  155         ivp[4] = k->wk_keytsc >> 16;            /* PN2 */
  156         ivp[5] = k->wk_keytsc >> 24;            /* PN3 */
  157         ivp[6] = k->wk_keytsc >> 32;            /* PN4 */
  158         ivp[7] = k->wk_keytsc >> 40;            /* PN5 */
  159 }
  160 
  161 /*
  162  * Add privacy headers appropriate for the specified key.
  163  */
  164 static int
  165 ccmp_encap(struct ieee80211_key *k, struct mbuf *m)
  166 {
  167         const struct ieee80211_frame *wh;
  168         struct ccmp_ctx *ctx = k->wk_private;
  169         struct ieee80211com *ic = ctx->cc_ic;
  170         uint8_t *ivp;
  171         int hdrlen;
  172         int is_mgmt;
  173 
  174         hdrlen = ieee80211_hdrspace(ic, mtod(m, void *));
  175         wh = mtod(m, const struct ieee80211_frame *);
  176         is_mgmt = IEEE80211_IS_MGMT(wh);
  177 
  178         /*
  179          * Check to see if we need to insert IV/MIC.
  180          *
  181          * Some offload devices don't require the IV to be inserted
  182          * as part of the hardware encryption.
  183          */
  184         if (is_mgmt && (k->wk_flags & IEEE80211_KEY_NOIVMGT))
  185                 return 1;
  186         if ((! is_mgmt) && (k->wk_flags & IEEE80211_KEY_NOIV))
  187                 return 1;
  188 
  189         /*
  190          * Copy down 802.11 header and add the IV, KeyID, and ExtIV.
  191          */
  192         M_PREPEND(m, ccmp.ic_header, M_NOWAIT);
  193         if (m == NULL)
  194                 return 0;
  195         ivp = mtod(m, uint8_t *);
  196         ovbcopy(ivp + ccmp.ic_header, ivp, hdrlen);
  197         ivp += hdrlen;
  198 
  199         ccmp_setiv(k, ivp);
  200 
  201         /*
  202          * Finally, do software encrypt if needed.
  203          */
  204         if ((k->wk_flags & IEEE80211_KEY_SWENCRYPT) &&
  205             !ccmp_encrypt(k, m, hdrlen))
  206                 return 0;
  207 
  208         return 1;
  209 }
  210 
  211 /*
  212  * Add MIC to the frame as needed.
  213  */
  214 static int
  215 ccmp_enmic(struct ieee80211_key *k, struct mbuf *m, int force)
  216 {
  217 
  218         return 1;
  219 }
  220 
  221 static __inline uint64_t
  222 READ_6(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint8_t b5)
  223 {
  224         uint32_t iv32 = (b0 << 0) | (b1 << 8) | (b2 << 16) | (b3 << 24);
  225         uint16_t iv16 = (b4 << 0) | (b5 << 8);
  226         return (((uint64_t)iv16) << 32) | iv32;
  227 }
  228 
  229 /*
  230  * Validate and strip privacy headers (and trailer) for a
  231  * received frame. The specified key should be correct but
  232  * is also verified.
  233  */
  234 static int
  235 ccmp_decap(struct ieee80211_key *k, struct mbuf *m, int hdrlen)
  236 {
  237         const struct ieee80211_rx_stats *rxs;
  238         struct ccmp_ctx *ctx = k->wk_private;
  239         struct ieee80211vap *vap = ctx->cc_vap;
  240         struct ieee80211_frame *wh;
  241         uint8_t *ivp, tid;
  242         uint64_t pn;
  243 
  244         rxs = ieee80211_get_rx_params_ptr(m);
  245 
  246         if ((rxs != NULL) && (rxs->c_pktflags & IEEE80211_RX_F_IV_STRIP))
  247                 goto finish;
  248 
  249         /*
  250          * Header should have extended IV and sequence number;
  251          * verify the former and validate the latter.
  252          */
  253         wh = mtod(m, struct ieee80211_frame *);
  254         ivp = mtod(m, uint8_t *) + hdrlen;
  255         if ((ivp[IEEE80211_WEP_IVLEN] & IEEE80211_WEP_EXTIV) == 0) {
  256                 /*
  257                  * No extended IV; discard frame.
  258                  */
  259                 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
  260                         "%s", "missing ExtIV for AES-CCM cipher");
  261                 vap->iv_stats.is_rx_ccmpformat++;
  262                 return 0;
  263         }
  264         tid = ieee80211_gettid(wh);
  265         pn = READ_6(ivp[0], ivp[1], ivp[4], ivp[5], ivp[6], ivp[7]);
  266         if (pn <= k->wk_keyrsc[tid] &&
  267             (k->wk_flags & IEEE80211_KEY_NOREPLAY) == 0) {
  268                 /*
  269                  * Replay violation.
  270                  */
  271                 ieee80211_notify_replay_failure(vap, wh, k, pn, tid);
  272                 vap->iv_stats.is_rx_ccmpreplay++;
  273                 return 0;
  274         }
  275 
  276         /*
  277          * Check if the device handled the decrypt in hardware.
  278          * If so we just strip the header; otherwise we need to
  279          * handle the decrypt in software.  Note that for the
  280          * latter we leave the header in place for use in the
  281          * decryption work.
  282          */
  283         if ((k->wk_flags & IEEE80211_KEY_SWDECRYPT) &&
  284             !ccmp_decrypt(k, pn, m, hdrlen))
  285                 return 0;
  286 
  287 finish:
  288         /*
  289          * Copy up 802.11 header and strip crypto bits.
  290          */
  291         if (! ((rxs != NULL) && (rxs->c_pktflags & IEEE80211_RX_F_IV_STRIP))) {
  292                 ovbcopy(mtod(m, void *), mtod(m, uint8_t *) + ccmp.ic_header,
  293                     hdrlen);
  294                 m_adj(m, ccmp.ic_header);
  295         }
  296 
  297         /*
  298          * XXX TODO: see if MMIC_STRIP also covers CCMP MIC trailer.
  299          */
  300         if (! ((rxs != NULL) && (rxs->c_pktflags & IEEE80211_RX_F_MMIC_STRIP)))
  301                 m_adj(m, -ccmp.ic_trailer);
  302 
  303         /*
  304          * Ok to update rsc now.
  305          */
  306         if (! ((rxs != NULL) && (rxs->c_pktflags & IEEE80211_RX_F_IV_STRIP))) {
  307                 k->wk_keyrsc[tid] = pn;
  308         }
  309 
  310         return 1;
  311 }
  312 
  313 /*
  314  * Verify and strip MIC from the frame.
  315  */
  316 static int
  317 ccmp_demic(struct ieee80211_key *k, struct mbuf *m, int force)
  318 {
  319         return 1;
  320 }
  321 
  322 static __inline void
  323 xor_block(uint8_t *b, const uint8_t *a, size_t len)
  324 {
  325         int i;
  326         for (i = 0; i < len; i++)
  327                 b[i] ^= a[i];
  328 }
  329 
  330 /*
  331  * Host AP crypt: host-based CCMP encryption implementation for Host AP driver
  332  *
  333  * Copyright (c) 2003-2004, Jouni Malinen <jkmaline@cc.hut.fi>
  334  *
  335  * This program is free software; you can redistribute it and/or modify
  336  * it under the terms of the GNU General Public License version 2 as
  337  * published by the Free Software Foundation. See README and COPYING for
  338  * more details.
  339  *
  340  * Alternatively, this software may be distributed under the terms of BSD
  341  * license.
  342  */
  343 
  344 static void
  345 ccmp_init_blocks(rijndael_ctx *ctx, struct ieee80211_frame *wh,
  346         u_int64_t pn, size_t dlen,
  347         uint8_t b0[AES_BLOCK_LEN], uint8_t aad[2 * AES_BLOCK_LEN],
  348         uint8_t auth[AES_BLOCK_LEN], uint8_t s0[AES_BLOCK_LEN])
  349 {
  350 #define IS_QOS_DATA(wh) IEEE80211_QOS_HAS_SEQ(wh)
  351 
  352         /* CCM Initial Block:
  353          * Flag (Include authentication header, M=3 (8-octet MIC),
  354          *       L=1 (2-octet Dlen))
  355          * Nonce: 0x00 | A2 | PN
  356          * Dlen */
  357         b0[0] = 0x59;
  358         /* NB: b0[1] set below */
  359         IEEE80211_ADDR_COPY(b0 + 2, wh->i_addr2);
  360         b0[8] = pn >> 40;
  361         b0[9] = pn >> 32;
  362         b0[10] = pn >> 24;
  363         b0[11] = pn >> 16;
  364         b0[12] = pn >> 8;
  365         b0[13] = pn >> 0;
  366         b0[14] = (dlen >> 8) & 0xff;
  367         b0[15] = dlen & 0xff;
  368 
  369         /* AAD:
  370          * FC with bits 4..6 and 11..13 masked to zero; 14 is always one
  371          * A1 | A2 | A3
  372          * SC with bits 4..15 (seq#) masked to zero
  373          * A4 (if present)
  374          * QC (if present)
  375          */
  376         aad[0] = 0;     /* AAD length >> 8 */
  377         /* NB: aad[1] set below */
  378         aad[2] = wh->i_fc[0] & 0x8f;    /* XXX magic #s */
  379         aad[3] = wh->i_fc[1] & 0xc7;    /* XXX magic #s */
  380         /* NB: we know 3 addresses are contiguous */
  381         memcpy(aad + 4, wh->i_addr1, 3 * IEEE80211_ADDR_LEN);
  382         aad[22] = wh->i_seq[0] & IEEE80211_SEQ_FRAG_MASK;
  383         aad[23] = 0; /* all bits masked */
  384         /*
  385          * Construct variable-length portion of AAD based
  386          * on whether this is a 4-address frame/QOS frame.
  387          * We always zero-pad to 32 bytes before running it
  388          * through the cipher.
  389          *
  390          * We also fill in the priority bits of the CCM
  391          * initial block as we know whether or not we have
  392          * a QOS frame.
  393          */
  394         if (IEEE80211_IS_DSTODS(wh)) {
  395                 IEEE80211_ADDR_COPY(aad + 24,
  396                         ((struct ieee80211_frame_addr4 *)wh)->i_addr4);
  397                 if (IS_QOS_DATA(wh)) {
  398                         struct ieee80211_qosframe_addr4 *qwh4 =
  399                                 (struct ieee80211_qosframe_addr4 *) wh;
  400                         aad[30] = qwh4->i_qos[0] & 0x0f;/* just priority bits */
  401                         aad[31] = 0;
  402                         b0[1] = aad[30];
  403                         aad[1] = 22 + IEEE80211_ADDR_LEN + 2;
  404                 } else {
  405                         *(uint16_t *)&aad[30] = 0;
  406                         b0[1] = 0;
  407                         aad[1] = 22 + IEEE80211_ADDR_LEN;
  408                 }
  409         } else {
  410                 if (IS_QOS_DATA(wh)) {
  411                         struct ieee80211_qosframe *qwh =
  412                                 (struct ieee80211_qosframe*) wh;
  413                         aad[24] = qwh->i_qos[0] & 0x0f; /* just priority bits */
  414                         aad[25] = 0;
  415                         b0[1] = aad[24];
  416                         aad[1] = 22 + 2;
  417                 } else {
  418                         *(uint16_t *)&aad[24] = 0;
  419                         b0[1] = 0;
  420                         aad[1] = 22;
  421                 }
  422                 *(uint16_t *)&aad[26] = 0;
  423                 *(uint32_t *)&aad[28] = 0;
  424         }
  425 
  426         /* Start with the first block and AAD */
  427         rijndael_encrypt(ctx, b0, auth);
  428         xor_block(auth, aad, AES_BLOCK_LEN);
  429         rijndael_encrypt(ctx, auth, auth);
  430         xor_block(auth, &aad[AES_BLOCK_LEN], AES_BLOCK_LEN);
  431         rijndael_encrypt(ctx, auth, auth);
  432         b0[0] &= 0x07;
  433         b0[14] = b0[15] = 0;
  434         rijndael_encrypt(ctx, b0, s0);
  435 #undef  IS_QOS_DATA
  436 }
  437 
  438 #define CCMP_ENCRYPT(_i, _b, _b0, _pos, _e, _len) do {  \
  439         /* Authentication */                            \
  440         xor_block(_b, _pos, _len);                      \
  441         rijndael_encrypt(&ctx->cc_aes, _b, _b);         \
  442         /* Encryption, with counter */                  \
  443         _b0[14] = (_i >> 8) & 0xff;                     \
  444         _b0[15] = _i & 0xff;                            \
  445         rijndael_encrypt(&ctx->cc_aes, _b0, _e);        \
  446         xor_block(_pos, _e, _len);                      \
  447 } while (0)
  448 
  449 static int
  450 ccmp_encrypt(struct ieee80211_key *key, struct mbuf *m0, int hdrlen)
  451 {
  452         struct ccmp_ctx *ctx = key->wk_private;
  453         struct ieee80211_frame *wh;
  454         struct mbuf *m = m0;
  455         int data_len, i, space;
  456         uint8_t aad[2 * AES_BLOCK_LEN], b0[AES_BLOCK_LEN], b[AES_BLOCK_LEN],
  457                 e[AES_BLOCK_LEN], s0[AES_BLOCK_LEN];
  458         uint8_t *pos;
  459 
  460         ctx->cc_vap->iv_stats.is_crypto_ccmp++;
  461 
  462         wh = mtod(m, struct ieee80211_frame *);
  463         data_len = m->m_pkthdr.len - (hdrlen + ccmp.ic_header);
  464         ccmp_init_blocks(&ctx->cc_aes, wh, key->wk_keytsc,
  465                 data_len, b0, aad, b, s0);
  466 
  467         i = 1;
  468         pos = mtod(m, uint8_t *) + hdrlen + ccmp.ic_header;
  469         /* NB: assumes header is entirely in first mbuf */
  470         space = m->m_len - (hdrlen + ccmp.ic_header);
  471         for (;;) {
  472                 if (space > data_len)
  473                         space = data_len;
  474                 /*
  475                  * Do full blocks.
  476                  */
  477                 while (space >= AES_BLOCK_LEN) {
  478                         CCMP_ENCRYPT(i, b, b0, pos, e, AES_BLOCK_LEN);
  479                         pos += AES_BLOCK_LEN, space -= AES_BLOCK_LEN;
  480                         data_len -= AES_BLOCK_LEN;
  481                         i++;
  482                 }
  483                 if (data_len <= 0)              /* no more data */
  484                         break;
  485                 m = m->m_next;
  486                 if (m == NULL) {                /* last buffer */
  487                         if (space != 0) {
  488                                 /*
  489                                  * Short last block.
  490                                  */
  491                                 CCMP_ENCRYPT(i, b, b0, pos, e, space);
  492                         }
  493                         break;
  494                 }
  495                 if (space != 0) {
  496                         uint8_t *pos_next;
  497                         int space_next;
  498                         int len, dl, sp;
  499                         struct mbuf *n;
  500 
  501                         /*
  502                          * Block straddles one or more mbufs, gather data
  503                          * into the block buffer b, apply the cipher, then
  504                          * scatter the results back into the mbuf chain.
  505                          * The buffer will automatically get space bytes
  506                          * of data at offset 0 copied in+out by the
  507                          * CCMP_ENCRYPT request so we must take care of
  508                          * the remaining data.
  509                          */
  510                         n = m;
  511                         dl = data_len;
  512                         sp = space;
  513                         for (;;) {
  514                                 pos_next = mtod(n, uint8_t *);
  515                                 len = min(dl, AES_BLOCK_LEN);
  516                                 space_next = len > sp ? len - sp : 0;
  517                                 if (n->m_len >= space_next) {
  518                                         /*
  519                                          * This mbuf has enough data; just grab
  520                                          * what we need and stop.
  521                                          */
  522                                         xor_block(b+sp, pos_next, space_next);
  523                                         break;
  524                                 }
  525                                 /*
  526                                  * This mbuf's contents are insufficient,
  527                                  * take 'em all and prepare to advance to
  528                                  * the next mbuf.
  529                                  */
  530                                 xor_block(b+sp, pos_next, n->m_len);
  531                                 sp += n->m_len, dl -= n->m_len;
  532                                 n = n->m_next;
  533                                 if (n == NULL)
  534                                         break;
  535                         }
  536 
  537                         CCMP_ENCRYPT(i, b, b0, pos, e, space);
  538 
  539                         /* NB: just like above, but scatter data to mbufs */
  540                         dl = data_len;
  541                         sp = space;
  542                         for (;;) {
  543                                 pos_next = mtod(m, uint8_t *);
  544                                 len = min(dl, AES_BLOCK_LEN);
  545                                 space_next = len > sp ? len - sp : 0;
  546                                 if (m->m_len >= space_next) {
  547                                         xor_block(pos_next, e+sp, space_next);
  548                                         break;
  549                                 }
  550                                 xor_block(pos_next, e+sp, m->m_len);
  551                                 sp += m->m_len, dl -= m->m_len;
  552                                 m = m->m_next;
  553                                 if (m == NULL)
  554                                         goto done;
  555                         }
  556                         /*
  557                          * Do bookkeeping.  m now points to the last mbuf
  558                          * we grabbed data from.  We know we consumed a
  559                          * full block of data as otherwise we'd have hit
  560                          * the end of the mbuf chain, so deduct from data_len.
  561                          * Otherwise advance the block number (i) and setup
  562                          * pos+space to reflect contents of the new mbuf.
  563                          */
  564                         data_len -= AES_BLOCK_LEN;
  565                         i++;
  566                         pos = pos_next + space_next;
  567                         space = m->m_len - space_next;
  568                 } else {
  569                         /*
  570                          * Setup for next buffer.
  571                          */
  572                         pos = mtod(m, uint8_t *);
  573                         space = m->m_len;
  574                 }
  575         }
  576 done:
  577         /* tack on MIC */
  578         xor_block(b, s0, ccmp.ic_trailer);
  579         return m_append(m0, ccmp.ic_trailer, b);
  580 }
  581 #undef CCMP_ENCRYPT
  582 
  583 #define CCMP_DECRYPT(_i, _b, _b0, _pos, _a, _len) do {  \
  584         /* Decrypt, with counter */                     \
  585         _b0[14] = (_i >> 8) & 0xff;                     \
  586         _b0[15] = _i & 0xff;                            \
  587         rijndael_encrypt(&ctx->cc_aes, _b0, _b);        \
  588         xor_block(_pos, _b, _len);                      \
  589         /* Authentication */                            \
  590         xor_block(_a, _pos, _len);                      \
  591         rijndael_encrypt(&ctx->cc_aes, _a, _a);         \
  592 } while (0)
  593 
  594 static int
  595 ccmp_decrypt(struct ieee80211_key *key, u_int64_t pn, struct mbuf *m, int hdrlen)
  596 {
  597         struct ccmp_ctx *ctx = key->wk_private;
  598         struct ieee80211vap *vap = ctx->cc_vap;
  599         struct ieee80211_frame *wh;
  600         uint8_t aad[2 * AES_BLOCK_LEN];
  601         uint8_t b0[AES_BLOCK_LEN], b[AES_BLOCK_LEN], a[AES_BLOCK_LEN];
  602         uint8_t mic[AES_BLOCK_LEN];
  603         size_t data_len;
  604         int i;
  605         uint8_t *pos;
  606         u_int space;
  607 
  608         ctx->cc_vap->iv_stats.is_crypto_ccmp++;
  609 
  610         wh = mtod(m, struct ieee80211_frame *);
  611         data_len = m->m_pkthdr.len - (hdrlen + ccmp.ic_header + ccmp.ic_trailer);
  612         ccmp_init_blocks(&ctx->cc_aes, wh, pn, data_len, b0, aad, a, b);
  613         m_copydata(m, m->m_pkthdr.len - ccmp.ic_trailer, ccmp.ic_trailer, mic);
  614         xor_block(mic, b, ccmp.ic_trailer);
  615 
  616         i = 1;
  617         pos = mtod(m, uint8_t *) + hdrlen + ccmp.ic_header;
  618         space = m->m_len - (hdrlen + ccmp.ic_header);
  619         for (;;) {
  620                 if (space > data_len)
  621                         space = data_len;
  622                 while (space >= AES_BLOCK_LEN) {
  623                         CCMP_DECRYPT(i, b, b0, pos, a, AES_BLOCK_LEN);
  624                         pos += AES_BLOCK_LEN, space -= AES_BLOCK_LEN;
  625                         data_len -= AES_BLOCK_LEN;
  626                         i++;
  627                 }
  628                 if (data_len <= 0)              /* no more data */
  629                         break;
  630                 m = m->m_next;
  631                 if (m == NULL) {                /* last buffer */
  632                         if (space != 0)         /* short last block */
  633                                 CCMP_DECRYPT(i, b, b0, pos, a, space);
  634                         break;
  635                 }
  636                 if (space != 0) {
  637                         uint8_t *pos_next;
  638                         u_int space_next;
  639                         u_int len;
  640 
  641                         /*
  642                          * Block straddles buffers, split references.  We
  643                          * do not handle splits that require >2 buffers
  644                          * since rx'd frames are never badly fragmented
  645                          * because drivers typically recv in clusters.
  646                          */
  647                         pos_next = mtod(m, uint8_t *);
  648                         len = min(data_len, AES_BLOCK_LEN);
  649                         space_next = len > space ? len - space : 0;
  650                         KASSERT(m->m_len >= space_next,
  651                                 ("not enough data in following buffer, "
  652                                 "m_len %u need %u\n", m->m_len, space_next));
  653 
  654                         xor_block(b+space, pos_next, space_next);
  655                         CCMP_DECRYPT(i, b, b0, pos, a, space);
  656                         xor_block(pos_next, b+space, space_next);
  657                         data_len -= len;
  658                         i++;
  659 
  660                         pos = pos_next + space_next;
  661                         space = m->m_len - space_next;
  662                 } else {
  663                         /*
  664                          * Setup for next buffer.
  665                          */
  666                         pos = mtod(m, uint8_t *);
  667                         space = m->m_len;
  668                 }
  669         }
  670         if (memcmp(mic, a, ccmp.ic_trailer) != 0) {
  671                 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
  672                     "%s", "AES-CCM decrypt failed; MIC mismatch");
  673                 vap->iv_stats.is_rx_ccmpmic++;
  674                 return 0;
  675         }
  676         return 1;
  677 }
  678 #undef CCMP_DECRYPT
  679 
  680 /*
  681  * Module glue.
  682  */
  683 IEEE80211_CRYPTO_MODULE(ccmp, 1);

Cache object: 2cf260bffae73a89e8852e8c55eed170


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.