LCOV - code coverage report
Current view: top level - crypto - crc32c_generic.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 10 36 27.8 %
Date: 2022-03-28 13:20:08 Functions: 3 9 33.3 %
Branches: 0 4 0.0 %

           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                 :          0 :         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         [ #  # ]:          0 :         struct chksum_ctx *mctx = crypto_shash_ctx(tfm);
      76                 :            : 
      77         [ #  # ]:          0 :         if (keylen != sizeof(mctx->key))
      78                 :            :                 return -EINVAL;
      79                 :          0 :         mctx->key = get_unaligned_le32(key);
      80                 :          0 :         return 0;
      81                 :            : }
      82                 :            : 
      83                 :    1592404 : static int chksum_update(struct shash_desc *desc, const u8 *data,
      84                 :            :                          unsigned int length)
      85                 :            : {
      86                 :    1592404 :         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
      87                 :            : 
      88                 :    1592404 :         ctx->crc = __crc32c_le(ctx->crc, data, length);
      89                 :    1592404 :         return 0;
      90                 :            : }
      91                 :            : 
      92                 :          0 : static int chksum_final(struct shash_desc *desc, u8 *out)
      93                 :            : {
      94                 :          0 :         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
      95                 :            : 
      96                 :          0 :         put_unaligned_le32(~ctx->crc, out);
      97                 :          0 :         return 0;
      98                 :            : }
      99                 :            : 
     100                 :          0 : static int __chksum_finup(u32 *crcp, const u8 *data, unsigned int len, u8 *out)
     101                 :            : {
     102                 :          0 :         put_unaligned_le32(~__crc32c_le(*crcp, data, len), out);
     103                 :          0 :         return 0;
     104                 :            : }
     105                 :            : 
     106                 :          0 : static int chksum_finup(struct shash_desc *desc, const u8 *data,
     107                 :            :                         unsigned int len, u8 *out)
     108                 :            : {
     109                 :          0 :         struct chksum_desc_ctx *ctx = shash_desc_ctx(desc);
     110                 :            : 
     111                 :          0 :         return __chksum_finup(&ctx->crc, data, len, out);
     112                 :            : }
     113                 :            : 
     114                 :          0 : static int chksum_digest(struct shash_desc *desc, const u8 *data,
     115                 :            :                          unsigned int length, u8 *out)
     116                 :            : {
     117                 :          0 :         struct chksum_ctx *mctx = crypto_shash_ctx(desc->tfm);
     118                 :            : 
     119                 :          0 :         return __chksum_finup(&mctx->key, data, length, out);
     120                 :            : }
     121                 :            : 
     122                 :        180 : static int crc32c_cra_init(struct crypto_tfm *tfm)
     123                 :            : {
     124                 :        180 :         struct chksum_ctx *mctx = crypto_tfm_ctx(tfm);
     125                 :            : 
     126                 :        180 :         mctx->key = ~0;
     127                 :        180 :         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                 :         30 : static int __init crc32c_mod_init(void)
     152                 :            : {
     153                 :         30 :         return crypto_register_shash(&alg);
     154                 :            : }
     155                 :            : 
     156                 :          0 : static void __exit crc32c_mod_fini(void)
     157                 :            : {
     158                 :          0 :         crypto_unregister_shash(&alg);
     159                 :          0 : }
     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");

Generated by: LCOV version 1.14