Commit | Line | Data |
---|---|---|
0a497c17 JG |
1 | /* |
2 | * Cryptographic API. | |
3 | * | |
e3b4f515 | 4 | * s390 implementation of the SHA256 and SHA224 Secure Hash Algorithm. |
0a497c17 JG |
5 | * |
6 | * s390 Version: | |
a53c8fab | 7 | * Copyright IBM Corp. 2005, 2011 |
0a497c17 JG |
8 | * Author(s): Jan Glauber (jang@de.ibm.com) |
9 | * | |
0a497c17 JG |
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 | */ | |
563f346d | 16 | #include <crypto/internal/hash.h> |
0a497c17 JG |
17 | #include <linux/init.h> |
18 | #include <linux/module.h> | |
d05377c1 | 19 | #include <linux/cpufeature.h> |
5265eeb2 | 20 | #include <crypto/sha.h> |
c7d4d259 | 21 | #include <asm/cpacf.h> |
0a497c17 | 22 | |
604973f1 | 23 | #include "sha.h" |
0a497c17 | 24 | |
563f346d | 25 | static int sha256_init(struct shash_desc *desc) |
0a497c17 | 26 | { |
563f346d | 27 | struct s390_sha_ctx *sctx = shash_desc_ctx(desc); |
0a497c17 | 28 | |
5265eeb2 JG |
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; | |
0a497c17 | 37 | sctx->count = 0; |
c7d4d259 | 38 | sctx->func = CPACF_KIMD_SHA_256; |
563f346d HX |
39 | |
40 | return 0; | |
0a497c17 JG |
41 | } |
42 | ||
f63559be HX |
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 | ||
81bd5f6c | 54 | static int sha256_import(struct shash_desc *desc, const void *in) |
f63559be | 55 | { |
2a549c36 | 56 | struct s390_sha_ctx *sctx = shash_desc_ctx(desc); |
81bd5f6c | 57 | const struct sha256_state *ictx = in; |
f63559be HX |
58 | |
59 | sctx->count = ictx->count; | |
60 | memcpy(sctx->state, ictx->state, sizeof(ictx->state)); | |
61 | memcpy(sctx->buf, ictx->buf, sizeof(ictx->buf)); | |
c7d4d259 | 62 | sctx->func = CPACF_KIMD_SHA_256; |
f63559be HX |
63 | return 0; |
64 | } | |
65 | ||
e3b4f515 | 66 | static struct shash_alg sha256_alg = { |
563f346d HX |
67 | .digestsize = SHA256_DIGEST_SIZE, |
68 | .init = sha256_init, | |
69 | .update = s390_sha_update, | |
70 | .final = s390_sha_final, | |
f63559be HX |
71 | .export = sha256_export, |
72 | .import = sha256_import, | |
563f346d | 73 | .descsize = sizeof(struct s390_sha_ctx), |
f63559be | 74 | .statesize = sizeof(struct sha256_state), |
563f346d HX |
75 | .base = { |
76 | .cra_name = "sha256", | |
77 | .cra_driver_name= "sha256-s390", | |
c7d4d259 | 78 | .cra_priority = 300, |
563f346d HX |
79 | .cra_flags = CRYPTO_ALG_TYPE_SHASH, |
80 | .cra_blocksize = SHA256_BLOCK_SIZE, | |
81 | .cra_module = THIS_MODULE, | |
82 | } | |
0a497c17 JG |
83 | }; |
84 | ||
e3b4f515 | 85 | static int sha224_init(struct shash_desc *desc) |
0a497c17 | 86 | { |
e3b4f515 JG |
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; | |
c7d4d259 | 98 | sctx->func = CPACF_KIMD_SHA_256; |
e3b4f515 JG |
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", | |
c7d4d259 | 115 | .cra_priority = 300, |
e3b4f515 JG |
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 | ||
c7d4d259 | 126 | if (!cpacf_query(CPACF_KIMD, CPACF_KIMD_SHA_256)) |
86aa9fc2 | 127 | return -EOPNOTSUPP; |
e3b4f515 JG |
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; | |
0a497c17 JG |
136 | } |
137 | ||
9f7819c1 | 138 | static void __exit sha256_s390_fini(void) |
0a497c17 | 139 | { |
e3b4f515 JG |
140 | crypto_unregister_shash(&sha224_alg); |
141 | crypto_unregister_shash(&sha256_alg); | |
0a497c17 JG |
142 | } |
143 | ||
d05377c1 | 144 | module_cpu_feature_match(MSA, sha256_s390_init); |
9f7819c1 | 145 | module_exit(sha256_s390_fini); |
0a497c17 | 146 | |
5d26a105 KC |
147 | MODULE_ALIAS_CRYPTO("sha256"); |
148 | MODULE_ALIAS_CRYPTO("sha224"); | |
0a497c17 | 149 | MODULE_LICENSE("GPL"); |
e3b4f515 | 150 | MODULE_DESCRIPTION("SHA256 and SHA224 Secure Hash Algorithm"); |