michael.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 /*      $OpenBSD: michael.c,v 1.2 2008/07/21 19:52:45 damien Exp $      */
    2 
    3 /*
    4  * Copyright (c) 2005, 2006 Reyk Floeter <reyk@openbsd.org>
    5  *
    6  * Permission to use, copy, modify, and distribute this software for any
    7  * purpose with or without fee is hereby granted, provided that the above
    8  * copyright notice and this permission notice appear in all copies.
    9  *
   10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   17  */
   18 
   19 /*
   20  * Implementation of the Michael MIC as defined in IEEE 802.11i for TKIP.
   21  * The MIC generates a 64bit digest, which shouldn't be used for any other
   22  * applications except TKIP.
   23  */
   24 
   25 #include <sys/param.h>
   26 #include <sys/systm.h>
   27 
   28 #include <crypto/michael.h>
   29 
   30 #define ROL(n, x)       (((x) << (n)) | ((x) >> (32 - (n))))
   31 #define ROR(n, x)       (((x) >> (n)) | ((x) << (32 - (n))))
   32 #define XSWAP(x)        (((x) & 0xff00ff00UL) >> 8 | ((x) & 0x00ff00ffUL) << 8)
   33 
   34 #if defined(__STRICT_ALIGNMENT) || _BYTE_ORDER != _LITTLE_ENDIAN
   35 #define GETLE32(x)      ((x)[0] | (x)[1] << 8 | (x)[2] << 16 | (x)[3] << 24)
   36 #define PUTLE32(x, v)   ((x)[0] = (u_int8_t)(v),                        \
   37                          (x)[1] = (u_int8_t)((v) >> 8),                 \
   38                          (x)[2] = (u_int8_t)((v) >> 16),                \
   39                          (x)[3] = (u_int8_t)((v) >> 24))
   40 #else
   41 #define GETLE32(x)      (*((u_int32_t *)(x)))
   42 #define PUTLE32(x, v)   (*((u_int32_t *)(x)) = (v))
   43 #endif
   44 
   45 #define MICHAEL_BLOCK(l, r) do {                                        \
   46         r ^= ROL(17, l);                                                \
   47         l += r;                                                         \
   48         r ^= XSWAP(l);                                                  \
   49         l += r;                                                         \
   50         r ^= ROL(3, l);                                                 \
   51         l += r;                                                         \
   52         r ^= ROR(2, l);                                                 \
   53         l += r;                                                         \
   54 } while (0)
   55 
   56 void
   57 michael_init(MICHAEL_CTX *ctx)
   58 {
   59         bzero(ctx, sizeof(MICHAEL_CTX));
   60 }
   61 
   62 void
   63 michael_update(MICHAEL_CTX *ctx, const u_int8_t *data, u_int len)
   64 {
   65         int i;
   66 
   67         for (i = 0; i < len; i++) {
   68                 ctx->michael_state |= data[i] << (ctx->michael_count << 3);
   69                 ctx->michael_count++;
   70 
   71                 if (ctx->michael_count >= MICHAEL_RAW_BLOCK_LENGTH) {
   72                         ctx->michael_l ^= ctx->michael_state;
   73                         MICHAEL_BLOCK(ctx->michael_l, ctx->michael_r);
   74                         ctx->michael_state = ctx->michael_count = 0;
   75                 }
   76         }
   77 }
   78 
   79 void
   80 michael_final(u_int8_t digest[MICHAEL_DIGEST_LENGTH], MICHAEL_CTX *ctx)
   81 {
   82         static const u_int8_t pad[] =
   83             { 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
   84 
   85         michael_update(ctx, pad, sizeof(pad));
   86 
   87         PUTLE32(digest, ctx->michael_l);
   88         PUTLE32(digest + MICHAEL_RAW_BLOCK_LENGTH, ctx->michael_r);
   89 }
   90 
   91 void
   92 michael_key(const u_int8_t *key, MICHAEL_CTX *ctx)
   93 {
   94         ctx->michael_l = ctx->michael_key[0] =
   95             GETLE32(key);
   96         ctx->michael_r = ctx->michael_key[1] =
   97             GETLE32(key + MICHAEL_RAW_BLOCK_LENGTH);
   98 }

Cache object: b6b3b14561b6f4a66a4b30b0b11e419f

[ 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.

FreeBSD/Linux Kernel Cross Reference sys/crypto/michael.c

FreeBSD/Linux Kernel Cross Reference
sys/crypto/michael.c