1 /* 2 * Cryptographic API. 3 * 4 * s390 implementation of the SHA256 and SHA224 Secure Hash Algorithm. 5 * 6 * s390 Version: 7 * Copyright IBM Corp. 2005, 2011 8 * Author(s): Jan Glauber (jang@de.ibm.com) 9 * 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the Free 12 * Software Foundation; either version 2 of the License, or (at your option) 13 * any later version. 14 * 15 */ 16 #include <crypto/internal/hash.h> 17 #include <linux/init.h> 18 #include <linux/module.h> 19 #include <linux/cpufeature.h> 20 #include <crypto/sha.h> 21 #include <asm/cpacf.h> 22 23 #include "sha.h" 24 25 static int sha256_init(struct shash_desc *desc) 26 { 27 struct s390_sha_ctx *sctx = shash_desc_ctx(desc); 28 29 sctx->state[0] = SHA256_H0; 30 sctx->state[1] = SHA256_H1; 31 sctx->state[2] = SHA256_H2; 32 sctx->state[3] = SHA256_H3; 33 sctx->state[4] = SHA256_H4; 34 sctx->state[5] = SHA256_H5; 35 sctx->state[6] = SHA256_H6; 36 sctx->state[7] = SHA256_H7; 37 sctx->count = 0; 38 sctx->func = CPACF_KIMD_SHA_256; 39 40 return 0; 41 } 42 43 static int sha256_export(struct shash_desc *desc, void *out) 44 { 45 struct s390_sha_ctx *sctx = shash_desc_ctx(desc); 46 struct sha256_state *octx = out; 47 48 octx->count = sctx->count; 49 memcpy(octx->state, sctx->state, sizeof(octx->state)); 50 memcpy(octx->buf, sctx->buf, sizeof(octx->buf)); 51 return 0; 52 } 53 54 static int sha256_import(struct shash_desc *desc, const void *in) 55 { 56 struct s390_sha_ctx *sctx = shash_desc_ctx(desc); 57 const struct sha256_state *ictx = in; 58 59 sctx->count = ictx->count; 60 memcpy(sctx->state, ictx->state, sizeof(ictx->state)); 61 memcpy(sctx->buf, ictx->buf, sizeof(ictx->buf)); 62 sctx->func = CPACF_KIMD_SHA_256; 63 return 0; 64 } 65 66 static struct shash_alg sha256_alg = { 67 .digestsize = SHA256_DIGEST_SIZE, 68 .init = sha256_init, 69 .update = s390_sha_update, 70 .final = s390_sha_final, 71 .export = sha256_export, 72 .import = sha256_import, 73 .descsize = sizeof(struct s390_sha_ctx), 74 .statesize = sizeof(struct sha256_state), 75 .base = { 76 .cra_name = "sha256", 77 .cra_driver_name= "sha256-s390", 78 .cra_priority = 300, 79 .cra_flags = CRYPTO_ALG_TYPE_SHASH, 80 .cra_blocksize = SHA256_BLOCK_SIZE, 81 .cra_module = THIS_MODULE, 82 } 83 }; 84 85 static int sha224_init(struct shash_desc *desc) 86 { 87 struct s390_sha_ctx *sctx = shash_desc_ctx(desc); 88 89 sctx->state[0] = SHA224_H0; 90 sctx->state[1] = SHA224_H1; 91 sctx->state[2] = SHA224_H2; 92 sctx->state[3] = SHA224_H3; 93 sctx->state[4] = SHA224_H4; 94 sctx->state[5] = SHA224_H5; 95 sctx->state[6] = SHA224_H6; 96 sctx->state[7] = SHA224_H7; 97 sctx->count = 0; 98 sctx->func = CPACF_KIMD_SHA_256; 99 100 return 0; 101 } 102 103 static struct shash_alg sha224_alg = { 104 .digestsize = SHA224_DIGEST_SIZE, 105 .init = sha224_init, 106 .update = s390_sha_update, 107 .final = s390_sha_final, 108 .export = sha256_export, 109 .import = sha256_import, 110 .descsize = sizeof(struct s390_sha_ctx), 111 .statesize = sizeof(struct sha256_state), 112 .base = { 113 .cra_name = "sha224", 114 .cra_driver_name= "sha224-s390", 115 .cra_priority = 300, 116 .cra_flags = CRYPTO_ALG_TYPE_SHASH, 117 .cra_blocksize = SHA224_BLOCK_SIZE, 118 .cra_module = THIS_MODULE, 119 } 120 }; 121 122 static int __init sha256_s390_init(void) 123 { 124 int ret; 125 126 if (!cpacf_query(CPACF_KIMD, CPACF_KIMD_SHA_256)) 127 return -EOPNOTSUPP; 128 ret = crypto_register_shash(&sha256_alg); 129 if (ret < 0) 130 goto out; 131 ret = crypto_register_shash(&sha224_alg); 132 if (ret < 0) 133 crypto_unregister_shash(&sha256_alg); 134 out: 135 return ret; 136 } 137 138 static void __exit sha256_s390_fini(void) 139 { 140 crypto_unregister_shash(&sha224_alg); 141 crypto_unregister_shash(&sha256_alg); 142 } 143 144 module_cpu_feature_match(MSA, sha256_s390_init); 145 module_exit(sha256_s390_fini); 146 147 MODULE_ALIAS_CRYPTO("sha256"); 148 MODULE_ALIAS_CRYPTO("sha224"); 149 MODULE_LICENSE("GPL"); 150 MODULE_DESCRIPTION("SHA256 and SHA224 Secure Hash Algorithm"); 151