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/crypto/crc32c.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  * Cryptographic API.
    3  *
    4  * CRC32C chksum
    5  *
    6  *@Article{castagnoli-crc,
    7  * author =       { Guy Castagnoli and Stefan Braeuer and Martin Herrman},
    8  * title =        {{Optimization of Cyclic Redundancy-Check Codes with 24
    9  *                 and 32 Parity Bits}},
   10  * journal =      IEEE Transactions on Communication,
   11  * year =         {1993},
   12  * volume =       {41},
   13  * number =       {6},
   14  * pages =        {},
   15  * month =        {June},
   16  *}
   17  * Used by the iSCSI driver, possibly others, and derived from the
   18  * the iscsi-crc.c module of the linux-iscsi driver at
   19  * http://linux-iscsi.sourceforge.net.
   20  *
   21  * Following the example of lib/crc32, this function is intended to be
   22  * flexible and useful for all users.  Modules that currently have their
   23  * own crc32c, but hopefully may be able to use this one are:
   24  *  net/sctp (please add all your doco to here if you change to
   25  *            use this one!)
   26  *  <endoflist>
   27  *
   28  * Copyright (c) 2004 Cisco Systems, Inc.
   29  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
   30  *
   31  * This program is free software; you can redistribute it and/or modify it
   32  * under the terms of the GNU General Public License as published by the Free
   33  * Software Foundation; either version 2 of the License, or (at your option)
   34  * any later version.
   35  *
   36  */
   37 
   38 #include <crypto/internal/hash.h>
   39 #include <linux/init.h>
   40 #include <linux/module.h>
   41 #include <linux/string.h>
   42 #include <linux/kernel.h>
   43 #include <linux/crc32.h>
   44 
   45 #define CHKSUM_BLOCK_SIZE       1
   46 #define CHKSUM_DIGEST_SIZE      4
   47 
   48 struct chksum_ctx {
   49         u32 key;
   50 };
   51 
   52 struct chksum_desc_ctx {
   53         u32 crc;
   54 };
   55 
   56 /*
   57  * Steps through buffer one byte at at time, calculates reflected
   58  * crc using table.
   59  */
   60 
   61 static int chksum_init(struct shash_desc *desc)
   62 {
   63         struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
   64         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
   65 
   66         ctx->crc = mctx->key;
   67 
   68         return 0;
   69 }
   70 
   71 /*
   72  * Setting the seed allows arbitrary accumulators and flexible XOR policy
   73  * If your algorithm starts with ~0, then XOR with ~0 before you set
   74  * the seed.
   75  */
   76 static int chksum_setkey(struct crypto_shash *tfm, const u8 *key,
   77                          unsigned int keylen)
   78 {
   79         struct chksum_ctx *mctx = crypto_shash_ctx(tfm);
   80 
   81         if (keylen != sizeof(mctx->key)) {
   82                 crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
   83                 return -EINVAL;
   84         }
   85         mctx->key = le32_to_cpu(*(__le32 *)key);
   86         return 0;
   87 }
   88 
   89 static int chksum_update(struct shash_desc *desc, const u8 *data,
   90                          unsigned int length)
   91 {
   92         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
   93 
   94         ctx->crc = __crc32c_le(ctx->crc, data, length);
   95         return 0;
   96 }
   97 
   98 static int chksum_final(struct shash_desc *desc, u8 *out)
   99 {
  100         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
  101 
  102         *(__le32 *)out = ~cpu_to_le32p(&ctx->crc);
  103         return 0;
  104 }
  105 
  106 static int __chksum_finup(u32 *crcp, const u8 *data, unsigned int len, u8 *out)
  107 {
  108         *(__le32 *)out = ~cpu_to_le32(__crc32c_le(*crcp, data, len));
  109         return 0;
  110 }
  111 
  112 static int chksum_finup(struct shash_desc *desc, const u8 *data,
  113                         unsigned int len, u8 *out)
  114 {
  115         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
  116 
  117         return __chksum_finup(&ctx->crc, data, len, out);
  118 }
  119 
  120 static int chksum_digest(struct shash_desc *desc, const u8 *data,
  121                          unsigned int length, u8 *out)
  122 {
  123         struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
  124 
  125         return __chksum_finup(&mctx->key, data, length, out);
  126 }
  127 
  128 static int crc32c_cra_init(struct crypto_tfm *tfm)
  129 {
  130         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
  131 
  132         mctx->key = ~0;
  133         return 0;
  134 }
  135 
  136 static struct shash_alg alg = {
  137         .digestsize             =       CHKSUM_DIGEST_SIZE,
  138         .setkey                 =       chksum_setkey,
  139         .init           =       chksum_init,
  140         .update         =       chksum_update,
  141         .final          =       chksum_final,
  142         .finup          =       chksum_finup,
  143         .digest         =       chksum_digest,
  144         .descsize               =       sizeof(struct chksum_desc_ctx),
  145         .base                   =       {
  146                 .cra_name               =       "crc32c",
  147                 .cra_driver_name        =       "crc32c-generic",
  148                 .cra_priority           =       100,
  149                 .cra_blocksize          =       CHKSUM_BLOCK_SIZE,
  150                 .cra_alignmask          =       3,
  151                 .cra_ctxsize            =       sizeof(struct chksum_ctx),
  152                 .cra_module             =       THIS_MODULE,
  153                 .cra_init               =       crc32c_cra_init,
  154         }
  155 };
  156 
  157 static int __init crc32c_mod_init(void)
  158 {
  159         return crypto_register_shash(&alg);
  160 }
  161 
  162 static void __exit crc32c_mod_fini(void)
  163 {
  164         crypto_unregister_shash(&alg);
  165 }
  166 
  167 module_init(crc32c_mod_init);
  168 module_exit(crc32c_mod_fini);
  169 
  170 MODULE_AUTHOR("Clay Haapala <chaapala@cisco.com>");
  171 MODULE_DESCRIPTION("CRC32c (Castagnoli) calculations wrapper for lib/crc32c");
  172 MODULE_LICENSE("GPL");

Cache object: 206481308ab0a04b645eb4c47e8f20db


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