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 <crypto/sha.h> 20 21 #include "crypt_s390.h" 22 #include "sha.h" 23 24 static int sha256_init(struct shash_desc *desc) 25 { 26 struct s390_sha_ctx *sctx = shash_desc_ctx(desc); 27 28 sctx->state[0] = SHA256_H0; 29 sctx->state[1] = SHA256_H1; 30 sctx->state[2] = SHA256_H2; 31 sctx->state[3] = SHA256_H3; 32 sctx->state[4] = SHA256_H4; 33 sctx->state[5] = SHA256_H5; 34 sctx->state[6] = SHA256_H6; 35 sctx->state[7] = SHA256_H7; 36 sctx->count = 0; 37 sctx->func = KIMD_SHA_256; 38 39 return 0; 40 } 41 42 static int sha256_export(struct shash_desc *desc, void *out) 43 { 44 struct s390_sha_ctx *sctx = shash_desc_ctx(desc); 45 struct sha256_state *octx = out; 46 47 octx->count = sctx->count; 48 memcpy(octx->state, sctx->state, sizeof(octx->state)); 49 memcpy(octx->buf, sctx->buf, sizeof(octx->buf)); 50 return 0; 51 } 52 53 static int sha256_import(struct shash_desc *desc, const void *in) 54 { 55 struct s390_sha_ctx *sctx = shash_desc_ctx(desc); 56 const struct sha256_state *ictx = in; 57 58 sctx->count = ictx->count; 59 memcpy(sctx->state, ictx->state, sizeof(ictx->state)); 60 memcpy(sctx->buf, ictx->buf, sizeof(ictx->buf)); 61 sctx->func = KIMD_SHA_256; 62 return 0; 63 } 64 65 static struct shash_alg sha256_alg = { 66 .digestsize = SHA256_DIGEST_SIZE, 67 .init = sha256_init, 68 .update = s390_sha_update, 69 .final = s390_sha_final, 70 .export = sha256_export, 71 .import = sha256_import, 72 .descsize = sizeof(struct s390_sha_ctx), 73 .statesize = sizeof(struct sha256_state), 74 .base = { 75 .cra_name = "sha256", 76 .cra_driver_name= "sha256-s390", 77 .cra_priority = CRYPT_S390_PRIORITY, 78 .cra_flags = CRYPTO_ALG_TYPE_SHASH, 79 .cra_blocksize = SHA256_BLOCK_SIZE, 80 .cra_module = THIS_MODULE, 81 } 82 }; 83 84 static int sha224_init(struct shash_desc *desc) 85 { 86 struct s390_sha_ctx *sctx = shash_desc_ctx(desc); 87 88 sctx->state[0] = SHA224_H0; 89 sctx->state[1] = SHA224_H1; 90 sctx->state[2] = SHA224_H2; 91 sctx->state[3] = SHA224_H3; 92 sctx->state[4] = SHA224_H4; 93 sctx->state[5] = SHA224_H5; 94 sctx->state[6] = SHA224_H6; 95 sctx->state[7] = SHA224_H7; 96 sctx->count = 0; 97 sctx->func = KIMD_SHA_256; 98 99 return 0; 100 } 101 102 static struct shash_alg sha224_alg = { 103 .digestsize = SHA224_DIGEST_SIZE, 104 .init = sha224_init, 105 .update = s390_sha_update, 106 .final = s390_sha_final, 107 .export = sha256_export, 108 .import = sha256_import, 109 .descsize = sizeof(struct s390_sha_ctx), 110 .statesize = sizeof(struct sha256_state), 111 .base = { 112 .cra_name = "sha224", 113 .cra_driver_name= "sha224-s390", 114 .cra_priority = CRYPT_S390_PRIORITY, 115 .cra_flags = CRYPTO_ALG_TYPE_SHASH, 116 .cra_blocksize = SHA224_BLOCK_SIZE, 117 .cra_module = THIS_MODULE, 118 } 119 }; 120 121 static int __init sha256_s390_init(void) 122 { 123 int ret; 124 125 if (!crypt_s390_func_available(KIMD_SHA_256, CRYPT_S390_MSA)) 126 return -EOPNOTSUPP; 127 ret = crypto_register_shash(&sha256_alg); 128 if (ret < 0) 129 goto out; 130 ret = crypto_register_shash(&sha224_alg); 131 if (ret < 0) 132 crypto_unregister_shash(&sha256_alg); 133 out: 134 return ret; 135 } 136 137 static void __exit sha256_s390_fini(void) 138 { 139 crypto_unregister_shash(&sha224_alg); 140 crypto_unregister_shash(&sha256_alg); 141 } 142 143 module_init(sha256_s390_init); 144 module_exit(sha256_s390_fini); 145 146 MODULE_ALIAS("sha256"); 147 MODULE_ALIAS("sha224"); 148 MODULE_LICENSE("GPL"); 149 MODULE_DESCRIPTION("SHA256 and SHA224 Secure Hash Algorithm"); 150