Branch data     Line data    Source code

       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 the
      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 at time, calculates reflected
      54                 :            :  * crc using table.
      55                 :            :  */
      56                 :            : 
      57                 :          0 : static int chksum_init(struct shash_desc *desc)
      58                 :            : {
      59                 :          0 :         struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
      60                 :            :         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
      61                 :            : 
      62                 :          0 :         ctx->crc = mctx->key;
      63                 :            : 
      64                 :          0 :         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                 :          0 : 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                 :          0 :         if (keylen != sizeof(mctx->key)) {
      78                 :            :                 crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
      79                 :          0 :                 return -EINVAL;
      80                 :            :         }
      81                 :          0 :         mctx->key = get_unaligned_le32(key);
      82                 :          0 :         return 0;
      83                 :            : }
      84                 :            : 
      85                 :          0 : static int chksum_update(struct shash_desc *desc, const u8 *data,
      86                 :            :                          unsigned int length)
      87                 :            : {
      88                 :            :         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
      89                 :            : 
      90                 :          0 :         ctx->crc = __crc32c_le(ctx->crc, data, length);
      91                 :          0 :         return 0;
      92                 :            : }
      93                 :            : 
      94                 :          0 : static int chksum_final(struct shash_desc *desc, u8 *out)
      95                 :            : {
      96                 :            :         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
      97                 :            : 
      98                 :          0 :         put_unaligned_le32(~ctx->crc, out);
      99                 :          0 :         return 0;
     100                 :            : }
     101                 :            : 
     102                 :            : static int __chksum_finup(u32 *crcp, const u8 *data, unsigned int len, u8 *out)
     103                 :            : {
     104                 :          0 :         put_unaligned_le32(~__crc32c_le(*crcp, data, len), out);
     105                 :            :         return 0;
     106                 :            : }
     107                 :            : 
     108                 :          0 : static int chksum_finup(struct shash_desc *desc, const u8 *data,
     109                 :            :                         unsigned int len, u8 *out)
     110                 :            : {
     111                 :            :         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
     112                 :            : 
     113                 :          0 :         return __chksum_finup(&ctx->crc, data, len, out);
     114                 :            : }
     115                 :            : 
     116                 :          0 : static int chksum_digest(struct shash_desc *desc, const u8 *data,
     117                 :            :                          unsigned int length, u8 *out)
     118                 :            : {
     119                 :          0 :         struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
     120                 :            : 
     121                 :          0 :         return __chksum_finup(&mctx->key, data, length, out);
     122                 :            : }
     123                 :            : 
     124                 :          3 : static int crc32c_cra_init(struct crypto_tfm *tfm)
     125                 :            : {
     126                 :            :         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
     127                 :            : 
     128                 :          3 :         mctx->key = ~0;
     129                 :          3 :         return 0;
     130                 :            : }
     131                 :            : 
     132                 :            : static struct shash_alg alg = {
     133                 :            :         .digestsize             =       CHKSUM_DIGEST_SIZE,
     134                 :            :         .setkey                 =       chksum_setkey,
     135                 :            :         .init           =       chksum_init,
     136                 :            :         .update         =       chksum_update,
     137                 :            :         .final          =       chksum_final,
     138                 :            :         .finup          =       chksum_finup,
     139                 :            :         .digest         =       chksum_digest,
     140                 :            :         .descsize               =       sizeof(struct chksum_desc_ctx),
     141                 :            :         .base                   =       {
     142                 :            :                 .cra_name               =       "crc32c",
     143                 :            :                 .cra_driver_name        =       "crc32c-generic",
     144                 :            :                 .cra_priority           =       100,
     145                 :            :                 .cra_flags              =       CRYPTO_ALG_OPTIONAL_KEY,
     146                 :            :                 .cra_blocksize          =       CHKSUM_BLOCK_SIZE,
     147                 :            :                 .cra_ctxsize            =       sizeof(struct chksum_ctx),
     148                 :            :                 .cra_module             =       THIS_MODULE,
     149                 :            :                 .cra_init               =       crc32c_cra_init,
     150                 :            :         }
     151                 :            : };
     152                 :            : 
     153                 :          3 : static int __init crc32c_mod_init(void)
     154                 :            : {
     155                 :          3 :         return crypto_register_shash(&alg);
     156                 :            : }
     157                 :            : 
     158                 :          0 : static void __exit crc32c_mod_fini(void)
     159                 :            : {
     160                 :          0 :         crypto_unregister_shash(&alg);
     161                 :          0 : }
     162                 :            : 
     163                 :            : subsys_initcall(crc32c_mod_init);
     164                 :            : module_exit(crc32c_mod_fini);
     165                 :            : 
     166                 :            : MODULE_AUTHOR("Clay Haapala <chaapala@cisco.com>");
     167                 :            : MODULE_DESCRIPTION("CRC32c (Castagnoli) calculations wrapper for lib/crc32c");
     168                 :            : MODULE_LICENSE("GPL");
     169                 :            : MODULE_ALIAS_CRYPTO("crc32c");
     170                 :            : MODULE_ALIAS_CRYPTO("crc32c-generic");