crypto/crc32c_generic.c

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