Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * Cryptographic API.
       4                 :            :  *
       5                 :            :  * SHA1 Secure Hash Algorithm.
       6                 :            :  *
       7                 :            :  * Derived from cryptoapi implementation, adapted for in-place
       8                 :            :  * scatterlist interface.
       9                 :            :  *
      10                 :            :  * Copyright (c) Alan Smithee.
      11                 :            :  * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
      12                 :            :  * Copyright (c) Jean-Francois Dive <jef@linuxbe.org>
      13                 :            :  */
      14                 :            : #include <crypto/internal/hash.h>
      15                 :            : #include <linux/init.h>
      16                 :            : #include <linux/module.h>
      17                 :            : #include <linux/mm.h>
      18                 :            : #include <linux/cryptohash.h>
      19                 :            : #include <linux/types.h>
      20                 :            : #include <crypto/sha.h>
      21                 :            : #include <crypto/sha1_base.h>
      22                 :            : #include <asm/byteorder.h>
      23                 :            : 
      24                 :            : const u8 sha1_zero_message_hash[SHA1_DIGEST_SIZE] = {
      25                 :            :         0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d,
      26                 :            :         0x32, 0x55, 0xbf, 0xef, 0x95, 0x60, 0x18, 0x90,
      27                 :            :         0xaf, 0xd8, 0x07, 0x09
      28                 :            : };
      29                 :            : EXPORT_SYMBOL_GPL(sha1_zero_message_hash);
      30                 :            : 
      31                 :          0 : static void sha1_generic_block_fn(struct sha1_state *sst, u8 const *src,
      32                 :            :                                   int blocks)
      33                 :            : {
      34                 :          0 :         u32 temp[SHA_WORKSPACE_WORDS];
      35                 :            : 
      36         [ #  # ]:          0 :         while (blocks--) {
      37                 :          0 :                 sha_transform(sst->state, src, temp);
      38                 :          0 :                 src += SHA1_BLOCK_SIZE;
      39                 :            :         }
      40                 :          0 :         memzero_explicit(temp, sizeof(temp));
      41                 :          0 : }
      42                 :            : 
      43                 :          0 : int crypto_sha1_update(struct shash_desc *desc, const u8 *data,
      44                 :            :                        unsigned int len)
      45                 :            : {
      46                 :          0 :         return sha1_base_do_update(desc, data, len, sha1_generic_block_fn);
      47                 :            : }
      48                 :            : EXPORT_SYMBOL(crypto_sha1_update);
      49                 :            : 
      50                 :          0 : static int sha1_final(struct shash_desc *desc, u8 *out)
      51                 :            : {
      52                 :          0 :         sha1_base_do_finalize(desc, sha1_generic_block_fn);
      53                 :          0 :         return sha1_base_finish(desc, out);
      54                 :            : }
      55                 :            : 
      56                 :          0 : int crypto_sha1_finup(struct shash_desc *desc, const u8 *data,
      57                 :            :                       unsigned int len, u8 *out)
      58                 :            : {
      59                 :          0 :         sha1_base_do_update(desc, data, len, sha1_generic_block_fn);
      60                 :          0 :         return sha1_final(desc, out);
      61                 :            : }
      62                 :            : EXPORT_SYMBOL(crypto_sha1_finup);
      63                 :            : 
      64                 :            : static struct shash_alg alg = {
      65                 :            :         .digestsize     =       SHA1_DIGEST_SIZE,
      66                 :            :         .init           =       sha1_base_init,
      67                 :            :         .update         =       crypto_sha1_update,
      68                 :            :         .final          =       sha1_final,
      69                 :            :         .finup          =       crypto_sha1_finup,
      70                 :            :         .descsize       =       sizeof(struct sha1_state),
      71                 :            :         .base           =       {
      72                 :            :                 .cra_name       =       "sha1",
      73                 :            :                 .cra_driver_name=       "sha1-generic",
      74                 :            :                 .cra_priority   =       100,
      75                 :            :                 .cra_blocksize  =       SHA1_BLOCK_SIZE,
      76                 :            :                 .cra_module     =       THIS_MODULE,
      77                 :            :         }
      78                 :            : };
      79                 :            : 
      80                 :         13 : static int __init sha1_generic_mod_init(void)
      81                 :            : {
      82                 :         13 :         return crypto_register_shash(&alg);
      83                 :            : }
      84                 :            : 
      85                 :          0 : static void __exit sha1_generic_mod_fini(void)
      86                 :            : {
      87                 :          0 :         crypto_unregister_shash(&alg);
      88                 :          0 : }
      89                 :            : 
      90                 :            : subsys_initcall(sha1_generic_mod_init);
      91                 :            : module_exit(sha1_generic_mod_fini);
      92                 :            : 
      93                 :            : MODULE_LICENSE("GPL");
      94                 :            : MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm");
      95                 :            : 
      96                 :            : MODULE_ALIAS_CRYPTO("sha1");
      97                 :            : MODULE_ALIAS_CRYPTO("sha1-generic");