]>
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> | |
5265eeb2 | 19 | #include <crypto/sha.h> |
0a497c17 JG |
20 | |
21 | #include "crypt_s390.h" | |
604973f1 | 22 | #include "sha.h" |
0a497c17 | 23 | |
563f346d | 24 | static int sha256_init(struct shash_desc *desc) |
0a497c17 | 25 | { |
563f346d | 26 | struct s390_sha_ctx *sctx = shash_desc_ctx(desc); |
0a497c17 | 27 | |
5265eeb2 JG |
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; | |
0a497c17 | 36 | sctx->count = 0; |
604973f1 | 37 | sctx->func = KIMD_SHA_256; |
563f346d HX |
38 | |
39 | return 0; | |
0a497c17 JG |
40 | } |
41 | ||
f63559be HX |
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 | ||
81bd5f6c | 53 | static int sha256_import(struct shash_desc *desc, const void *in) |
f63559be | 54 | { |
2a549c36 | 55 | struct s390_sha_ctx *sctx = shash_desc_ctx(desc); |
81bd5f6c | 56 | const struct sha256_state *ictx = in; |
f63559be HX |
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 | ||
e3b4f515 | 65 | static struct shash_alg sha256_alg = { |
563f346d HX |
66 | .digestsize = SHA256_DIGEST_SIZE, |
67 | .init = sha256_init, | |
68 | .update = s390_sha_update, | |
69 | .final = s390_sha_final, | |
f63559be HX |
70 | .export = sha256_export, |
71 | .import = sha256_import, | |
563f346d | 72 | .descsize = sizeof(struct s390_sha_ctx), |
f63559be | 73 | .statesize = sizeof(struct sha256_state), |
563f346d HX |
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 | } | |
0a497c17 JG |
82 | }; |
83 | ||
e3b4f515 | 84 | static int sha224_init(struct shash_desc *desc) |
0a497c17 | 85 | { |
e3b4f515 JG |
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 | ||
1822bc90 | 125 | if (!crypt_s390_func_available(KIMD_SHA_256, CRYPT_S390_MSA)) |
86aa9fc2 | 126 | return -EOPNOTSUPP; |
e3b4f515 JG |
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; | |
0a497c17 JG |
135 | } |
136 | ||
9f7819c1 | 137 | static void __exit sha256_s390_fini(void) |
0a497c17 | 138 | { |
e3b4f515 JG |
139 | crypto_unregister_shash(&sha224_alg); |
140 | crypto_unregister_shash(&sha256_alg); | |
0a497c17 JG |
141 | } |
142 | ||
9f7819c1 HC |
143 | module_init(sha256_s390_init); |
144 | module_exit(sha256_s390_fini); | |
0a497c17 JG |
145 | |
146 | MODULE_ALIAS("sha256"); | |
e3b4f515 | 147 | MODULE_ALIAS("sha224"); |
0a497c17 | 148 | MODULE_LICENSE("GPL"); |
e3b4f515 | 149 | MODULE_DESCRIPTION("SHA256 and SHA224 Secure Hash Algorithm"); |