]>
Commit | Line | Data |
---|---|---|
0a497c17 JG |
1 | /* |
2 | * Cryptographic API. | |
3 | * | |
4 | * s390 implementation of the SHA256 Secure Hash Algorithm. | |
5 | * | |
6 | * s390 Version: | |
86aa9fc2 | 7 | * Copyright IBM Corp. 2005,2007 |
0a497c17 JG |
8 | * Author(s): Jan Glauber (jang@de.ibm.com) |
9 | * | |
ad5d2789 | 10 | * Derived from "crypto/sha256_generic.c" |
0a497c17 JG |
11 | * and "arch/s390/crypto/sha1_s390.c" |
12 | * | |
13 | * This program is free software; you can redistribute it and/or modify it | |
14 | * under the terms of the GNU General Public License as published by the Free | |
15 | * Software Foundation; either version 2 of the License, or (at your option) | |
16 | * any later version. | |
17 | * | |
18 | */ | |
19 | #include <linux/init.h> | |
20 | #include <linux/module.h> | |
21 | #include <linux/crypto.h> | |
5265eeb2 | 22 | #include <crypto/sha.h> |
0a497c17 JG |
23 | |
24 | #include "crypt_s390.h" | |
25 | ||
0a497c17 | 26 | struct s390_sha256_ctx { |
131a395c | 27 | u64 count; /* message length */ |
0a497c17 JG |
28 | u32 state[8]; |
29 | u8 buf[2 * SHA256_BLOCK_SIZE]; | |
30 | }; | |
31 | ||
6c2bb98b | 32 | static void sha256_init(struct crypto_tfm *tfm) |
0a497c17 | 33 | { |
6c2bb98b | 34 | struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); |
0a497c17 | 35 | |
5265eeb2 JG |
36 | sctx->state[0] = SHA256_H0; |
37 | sctx->state[1] = SHA256_H1; | |
38 | sctx->state[2] = SHA256_H2; | |
39 | sctx->state[3] = SHA256_H3; | |
40 | sctx->state[4] = SHA256_H4; | |
41 | sctx->state[5] = SHA256_H5; | |
42 | sctx->state[6] = SHA256_H6; | |
43 | sctx->state[7] = SHA256_H7; | |
0a497c17 | 44 | sctx->count = 0; |
0a497c17 JG |
45 | } |
46 | ||
6c2bb98b HX |
47 | static void sha256_update(struct crypto_tfm *tfm, const u8 *data, |
48 | unsigned int len) | |
0a497c17 | 49 | { |
6c2bb98b | 50 | struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); |
0a497c17 | 51 | unsigned int index; |
7ffbc9da | 52 | int ret; |
0a497c17 JG |
53 | |
54 | /* how much is already in the buffer? */ | |
131a395c | 55 | index = sctx->count & 0x3f; |
0a497c17 | 56 | |
131a395c | 57 | sctx->count += len; |
0a497c17 | 58 | |
7ffbc9da JG |
59 | if ((index + len) < SHA256_BLOCK_SIZE) |
60 | goto store; | |
61 | ||
62 | /* process one stored block */ | |
63 | if (index) { | |
0a497c17 | 64 | memcpy(sctx->buf + index, data, SHA256_BLOCK_SIZE - index); |
7ffbc9da JG |
65 | ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, sctx->buf, |
66 | SHA256_BLOCK_SIZE); | |
67 | BUG_ON(ret != SHA256_BLOCK_SIZE); | |
0a497c17 JG |
68 | data += SHA256_BLOCK_SIZE - index; |
69 | len -= SHA256_BLOCK_SIZE - index; | |
70 | } | |
71 | ||
7ffbc9da JG |
72 | /* process as many blocks as possible */ |
73 | if (len >= SHA256_BLOCK_SIZE) { | |
74 | ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, data, | |
75 | len & ~(SHA256_BLOCK_SIZE - 1)); | |
76 | BUG_ON(ret != (len & ~(SHA256_BLOCK_SIZE - 1))); | |
77 | data += ret; | |
78 | len -= ret; | |
79 | } | |
80 | ||
81 | store: | |
0a497c17 JG |
82 | /* anything left? */ |
83 | if (len) | |
84 | memcpy(sctx->buf + index , data, len); | |
85 | } | |
86 | ||
131a395c JG |
87 | /* Add padding and return the message digest */ |
88 | static void sha256_final(struct crypto_tfm *tfm, u8 *out) | |
0a497c17 | 89 | { |
131a395c JG |
90 | struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); |
91 | u64 bits; | |
92 | unsigned int index, end; | |
93 | int ret; | |
0a497c17 | 94 | |
131a395c JG |
95 | /* must perform manual padding */ |
96 | index = sctx->count & 0x3f; | |
97 | end = (index < 56) ? SHA256_BLOCK_SIZE : (2 * SHA256_BLOCK_SIZE); | |
0a497c17 JG |
98 | |
99 | /* start pad with 1 */ | |
100 | sctx->buf[index] = 0x80; | |
101 | ||
102 | /* pad with zeros */ | |
103 | index++; | |
104 | memset(sctx->buf + index, 0x00, end - index - 8); | |
105 | ||
106 | /* append message length */ | |
131a395c JG |
107 | bits = sctx->count * 8; |
108 | memcpy(sctx->buf + end - 8, &bits, sizeof(bits)); | |
0a497c17 | 109 | |
131a395c JG |
110 | ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, sctx->buf, end); |
111 | BUG_ON(ret != end); | |
0a497c17 JG |
112 | |
113 | /* copy digest to out */ | |
114 | memcpy(out, sctx->state, SHA256_DIGEST_SIZE); | |
115 | ||
116 | /* wipe context */ | |
117 | memset(sctx, 0, sizeof *sctx); | |
118 | } | |
119 | ||
120 | static struct crypto_alg alg = { | |
121 | .cra_name = "sha256", | |
65b75c36 HX |
122 | .cra_driver_name = "sha256-s390", |
123 | .cra_priority = CRYPT_S390_PRIORITY, | |
0a497c17 JG |
124 | .cra_flags = CRYPTO_ALG_TYPE_DIGEST, |
125 | .cra_blocksize = SHA256_BLOCK_SIZE, | |
126 | .cra_ctxsize = sizeof(struct s390_sha256_ctx), | |
127 | .cra_module = THIS_MODULE, | |
128 | .cra_list = LIST_HEAD_INIT(alg.cra_list), | |
129 | .cra_u = { .digest = { | |
130 | .dia_digestsize = SHA256_DIGEST_SIZE, | |
7ffbc9da JG |
131 | .dia_init = sha256_init, |
132 | .dia_update = sha256_update, | |
133 | .dia_final = sha256_final } } | |
0a497c17 JG |
134 | }; |
135 | ||
136 | static int init(void) | |
137 | { | |
0a497c17 | 138 | if (!crypt_s390_func_available(KIMD_SHA_256)) |
86aa9fc2 | 139 | return -EOPNOTSUPP; |
0a497c17 | 140 | |
86aa9fc2 | 141 | return crypto_register_alg(&alg); |
0a497c17 JG |
142 | } |
143 | ||
144 | static void __exit fini(void) | |
145 | { | |
146 | crypto_unregister_alg(&alg); | |
147 | } | |
148 | ||
149 | module_init(init); | |
150 | module_exit(fini); | |
151 | ||
152 | MODULE_ALIAS("sha256"); | |
153 | ||
154 | MODULE_LICENSE("GPL"); | |
155 | MODULE_DESCRIPTION("SHA256 Secure Hash Algorithm"); |