s390/crypto/sha256_s390.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Cryptographic API.
0004  *
0005  * s390 implementation of the SHA256 and SHA224 Secure Hash Algorithm.
0006  *
0007  * s390 Version:
0008  *   Copyright IBM Corp. 2005, 2011
0009  *   Author(s): Jan Glauber (jang@de.ibm.com)
0010  */
0011 #include <crypto/internal/hash.h>
0012 #include <linux/init.h>
0013 #include <linux/module.h>
0014 #include <linux/cpufeature.h>
0015 #include <crypto/sha2.h>
0016 #include <asm/cpacf.h>
0017
0018 #include "sha.h"
0019
0020 static int s390_sha256_init(struct shash_desc *desc)
0021 {
0022     struct s390_sha_ctx *sctx = shash_desc_ctx(desc);
0023
0024     sctx->state[0] = SHA256_H0;
0025     sctx->state[1] = SHA256_H1;
0026     sctx->state[2] = SHA256_H2;
0027     sctx->state[3] = SHA256_H3;
0028     sctx->state[4] = SHA256_H4;
0029     sctx->state[5] = SHA256_H5;
0030     sctx->state[6] = SHA256_H6;
0031     sctx->state[7] = SHA256_H7;
0032     sctx->count = 0;
0033     sctx->func = CPACF_KIMD_SHA_256;
0034
0035     return 0;
0036 }
0037
0038 static int sha256_export(struct shash_desc *desc, void *out)
0039 {
0040     struct s390_sha_ctx *sctx = shash_desc_ctx(desc);
0041     struct sha256_state *octx = out;
0042
0043     octx->count = sctx->count;
0044     memcpy(octx->state, sctx->state, sizeof(octx->state));
0045     memcpy(octx->buf, sctx->buf, sizeof(octx->buf));
0046     return 0;
0047 }
0048
0049 static int sha256_import(struct shash_desc *desc, const void *in)
0050 {
0051     struct s390_sha_ctx *sctx = shash_desc_ctx(desc);
0052     const struct sha256_state *ictx = in;
0053
0054     sctx->count = ictx->count;
0055     memcpy(sctx->state, ictx->state, sizeof(ictx->state));
0056     memcpy(sctx->buf, ictx->buf, sizeof(ictx->buf));
0057     sctx->func = CPACF_KIMD_SHA_256;
0058     return 0;
0059 }
0060
0061 static struct shash_alg sha256_alg = {
0062     .digestsize =   SHA256_DIGEST_SIZE,
0063     .init       =   s390_sha256_init,
0064     .update     =   s390_sha_update,
0065     .final      =   s390_sha_final,
0066     .export     =   sha256_export,
0067     .import     =   sha256_import,
0068     .descsize   =   sizeof(struct s390_sha_ctx),
0069     .statesize  =   sizeof(struct sha256_state),
0070     .base       =   {
0071         .cra_name   =   "sha256",
0072         .cra_driver_name=   "sha256-s390",
0073         .cra_priority   =   300,
0074         .cra_blocksize  =   SHA256_BLOCK_SIZE,
0075         .cra_module =   THIS_MODULE,
0076     }
0077 };
0078
0079 static int s390_sha224_init(struct shash_desc *desc)
0080 {
0081     struct s390_sha_ctx *sctx = shash_desc_ctx(desc);
0082
0083     sctx->state[0] = SHA224_H0;
0084     sctx->state[1] = SHA224_H1;
0085     sctx->state[2] = SHA224_H2;
0086     sctx->state[3] = SHA224_H3;
0087     sctx->state[4] = SHA224_H4;
0088     sctx->state[5] = SHA224_H5;
0089     sctx->state[6] = SHA224_H6;
0090     sctx->state[7] = SHA224_H7;
0091     sctx->count = 0;
0092     sctx->func = CPACF_KIMD_SHA_256;
0093
0094     return 0;
0095 }
0096
0097 static struct shash_alg sha224_alg = {
0098     .digestsize =   SHA224_DIGEST_SIZE,
0099     .init       =   s390_sha224_init,
0100     .update     =   s390_sha_update,
0101     .final      =   s390_sha_final,
0102     .export     =   sha256_export,
0103     .import     =   sha256_import,
0104     .descsize   =   sizeof(struct s390_sha_ctx),
0105     .statesize  =   sizeof(struct sha256_state),
0106     .base       =   {
0107         .cra_name   =   "sha224",
0108         .cra_driver_name=   "sha224-s390",
0109         .cra_priority   =   300,
0110         .cra_blocksize  =   SHA224_BLOCK_SIZE,
0111         .cra_module =   THIS_MODULE,
0112     }
0113 };
0114
0115 static int __init sha256_s390_init(void)
0116 {
0117     int ret;
0118
0119     if (!cpacf_query_func(CPACF_KIMD, CPACF_KIMD_SHA_256))
0120         return -ENODEV;
0121     ret = crypto_register_shash(&sha256_alg);
0122     if (ret < 0)
0123         goto out;
0124     ret = crypto_register_shash(&sha224_alg);
0125     if (ret < 0)
0126         crypto_unregister_shash(&sha256_alg);
0127 out:
0128     return ret;
0129 }
0130
0131 static void __exit sha256_s390_fini(void)
0132 {
0133     crypto_unregister_shash(&sha224_alg);
0134     crypto_unregister_shash(&sha256_alg);
0135 }
0136
0137 module_cpu_feature_match(S390_CPU_FEATURE_MSA, sha256_s390_init);
0138 module_exit(sha256_s390_fini);
0139
0140 MODULE_ALIAS_CRYPTO("sha256");
0141 MODULE_ALIAS_CRYPTO("sha224");
0142 MODULE_LICENSE("GPL");
0143 MODULE_DESCRIPTION("SHA256 and SHA224 Secure Hash Algorithm");