Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * Crypto API wrapper for the generic SHA256 code from lib/crypto/sha256.c
       4                 :            :  *
       5                 :            :  * Copyright (c) Jean-Luc Cooke <jlcooke@certainkey.com>
       6                 :            :  * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
       7                 :            :  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
       8                 :            :  * SHA224 Support Copyright 2007 Intel Corporation <jonathan.lynch@intel.com>
       9                 :            :  */
      10                 :            : #include <crypto/internal/hash.h>
      11                 :            : #include <linux/init.h>
      12                 :            : #include <linux/module.h>
      13                 :            : #include <linux/mm.h>
      14                 :            : #include <linux/types.h>
      15                 :            : #include <crypto/sha.h>
      16                 :            : #include <crypto/sha256_base.h>
      17                 :            : #include <asm/byteorder.h>
      18                 :            : #include <asm/unaligned.h>
      19                 :            : 
      20                 :            : const u8 sha224_zero_message_hash[SHA224_DIGEST_SIZE] = {
      21                 :            :         0xd1, 0x4a, 0x02, 0x8c, 0x2a, 0x3a, 0x2b, 0xc9, 0x47,
      22                 :            :         0x61, 0x02, 0xbb, 0x28, 0x82, 0x34, 0xc4, 0x15, 0xa2,
      23                 :            :         0xb0, 0x1f, 0x82, 0x8e, 0xa6, 0x2a, 0xc5, 0xb3, 0xe4,
      24                 :            :         0x2f
      25                 :            : };
      26                 :            : EXPORT_SYMBOL_GPL(sha224_zero_message_hash);
      27                 :            : 
      28                 :            : const u8 sha256_zero_message_hash[SHA256_DIGEST_SIZE] = {
      29                 :            :         0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14,
      30                 :            :         0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24,
      31                 :            :         0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
      32                 :            :         0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55
      33                 :            : };
      34                 :            : EXPORT_SYMBOL_GPL(sha256_zero_message_hash);
      35                 :            : 
      36                 :          3 : static int crypto_sha256_init(struct shash_desc *desc)
      37                 :            : {
      38                 :          3 :         return sha256_init(shash_desc_ctx(desc));
      39                 :            : }
      40                 :            : 
      41                 :          0 : static int crypto_sha224_init(struct shash_desc *desc)
      42                 :            : {
      43                 :          0 :         return sha224_init(shash_desc_ctx(desc));
      44                 :            : }
      45                 :            : 
      46                 :          3 : int crypto_sha256_update(struct shash_desc *desc, const u8 *data,
      47                 :            :                           unsigned int len)
      48                 :            : {
      49                 :          3 :         return sha256_update(shash_desc_ctx(desc), data, len);
      50                 :            : }
      51                 :            : EXPORT_SYMBOL(crypto_sha256_update);
      52                 :            : 
      53                 :          3 : static int crypto_sha256_final(struct shash_desc *desc, u8 *out)
      54                 :            : {
      55                 :          3 :         if (crypto_shash_digestsize(desc->tfm) == SHA224_DIGEST_SIZE)
      56                 :          0 :                 return sha224_final(shash_desc_ctx(desc), out);
      57                 :            :         else
      58                 :          3 :                 return sha256_final(shash_desc_ctx(desc), out);
      59                 :            : }
      60                 :            : 
      61                 :          3 : int crypto_sha256_finup(struct shash_desc *desc, const u8 *data,
      62                 :            :                         unsigned int len, u8 *hash)
      63                 :            : {
      64                 :          3 :         sha256_update(shash_desc_ctx(desc), data, len);
      65                 :          3 :         return crypto_sha256_final(desc, hash);
      66                 :            : }
      67                 :            : EXPORT_SYMBOL(crypto_sha256_finup);
      68                 :            : 
      69                 :            : static struct shash_alg sha256_algs[2] = { {
      70                 :            :         .digestsize     =       SHA256_DIGEST_SIZE,
      71                 :            :         .init           =       crypto_sha256_init,
      72                 :            :         .update         =       crypto_sha256_update,
      73                 :            :         .final          =       crypto_sha256_final,
      74                 :            :         .finup          =       crypto_sha256_finup,
      75                 :            :         .descsize       =       sizeof(struct sha256_state),
      76                 :            :         .base           =       {
      77                 :            :                 .cra_name       =       "sha256",
      78                 :            :                 .cra_driver_name=       "sha256-generic",
      79                 :            :                 .cra_priority   =       100,
      80                 :            :                 .cra_blocksize  =       SHA256_BLOCK_SIZE,
      81                 :            :                 .cra_module     =       THIS_MODULE,
      82                 :            :         }
      83                 :            : }, {
      84                 :            :         .digestsize     =       SHA224_DIGEST_SIZE,
      85                 :            :         .init           =       crypto_sha224_init,
      86                 :            :         .update         =       crypto_sha256_update,
      87                 :            :         .final          =       crypto_sha256_final,
      88                 :            :         .finup          =       crypto_sha256_finup,
      89                 :            :         .descsize       =       sizeof(struct sha256_state),
      90                 :            :         .base           =       {
      91                 :            :                 .cra_name       =       "sha224",
      92                 :            :                 .cra_driver_name=       "sha224-generic",
      93                 :            :                 .cra_priority   =       100,
      94                 :            :                 .cra_blocksize  =       SHA224_BLOCK_SIZE,
      95                 :            :                 .cra_module     =       THIS_MODULE,
      96                 :            :         }
      97                 :            : } };
      98                 :            : 
      99                 :          3 : static int __init sha256_generic_mod_init(void)
     100                 :            : {
     101                 :          3 :         return crypto_register_shashes(sha256_algs, ARRAY_SIZE(sha256_algs));
     102                 :            : }
     103                 :            : 
     104                 :          0 : static void __exit sha256_generic_mod_fini(void)
     105                 :            : {
     106                 :          0 :         crypto_unregister_shashes(sha256_algs, ARRAY_SIZE(sha256_algs));
     107                 :          0 : }
     108                 :            : 
     109                 :            : subsys_initcall(sha256_generic_mod_init);
     110                 :            : module_exit(sha256_generic_mod_fini);
     111                 :            : 
     112                 :            : MODULE_LICENSE("GPL");
     113                 :            : MODULE_DESCRIPTION("SHA-224 and SHA-256 Secure Hash Algorithm");
     114                 :            : 
     115                 :            : MODULE_ALIAS_CRYPTO("sha224");
     116                 :            : MODULE_ALIAS_CRYPTO("sha224-generic");
     117                 :            : MODULE_ALIAS_CRYPTO("sha256");
     118                 :            : MODULE_ALIAS_CRYPTO("sha256-generic");