]>
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> | |
22 | ||
23 | #include "crypt_s390.h" | |
24 | ||
25 | #define SHA256_DIGEST_SIZE 32 | |
26 | #define SHA256_BLOCK_SIZE 64 | |
27 | ||
28 | struct s390_sha256_ctx { | |
131a395c | 29 | u64 count; /* message length */ |
0a497c17 JG |
30 | u32 state[8]; |
31 | u8 buf[2 * SHA256_BLOCK_SIZE]; | |
32 | }; | |
33 | ||
6c2bb98b | 34 | static void sha256_init(struct crypto_tfm *tfm) |
0a497c17 | 35 | { |
6c2bb98b | 36 | struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); |
0a497c17 JG |
37 | |
38 | sctx->state[0] = 0x6a09e667; | |
39 | sctx->state[1] = 0xbb67ae85; | |
40 | sctx->state[2] = 0x3c6ef372; | |
41 | sctx->state[3] = 0xa54ff53a; | |
42 | sctx->state[4] = 0x510e527f; | |
43 | sctx->state[5] = 0x9b05688c; | |
44 | sctx->state[6] = 0x1f83d9ab; | |
45 | sctx->state[7] = 0x5be0cd19; | |
46 | sctx->count = 0; | |
0a497c17 JG |
47 | } |
48 | ||
6c2bb98b HX |
49 | static void sha256_update(struct crypto_tfm *tfm, const u8 *data, |
50 | unsigned int len) | |
0a497c17 | 51 | { |
6c2bb98b | 52 | struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); |
0a497c17 | 53 | unsigned int index; |
7ffbc9da | 54 | int ret; |
0a497c17 JG |
55 | |
56 | /* how much is already in the buffer? */ | |
131a395c | 57 | index = sctx->count & 0x3f; |
0a497c17 | 58 | |
131a395c | 59 | sctx->count += len; |
0a497c17 | 60 | |
7ffbc9da JG |
61 | if ((index + len) < SHA256_BLOCK_SIZE) |
62 | goto store; | |
63 | ||
64 | /* process one stored block */ | |
65 | if (index) { | |
0a497c17 | 66 | memcpy(sctx->buf + index, data, SHA256_BLOCK_SIZE - index); |
7ffbc9da JG |
67 | ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, sctx->buf, |
68 | SHA256_BLOCK_SIZE); | |
69 | BUG_ON(ret != SHA256_BLOCK_SIZE); | |
0a497c17 JG |
70 | data += SHA256_BLOCK_SIZE - index; |
71 | len -= SHA256_BLOCK_SIZE - index; | |
72 | } | |
73 | ||
7ffbc9da JG |
74 | /* process as many blocks as possible */ |
75 | if (len >= SHA256_BLOCK_SIZE) { | |
76 | ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, data, | |
77 | len & ~(SHA256_BLOCK_SIZE - 1)); | |
78 | BUG_ON(ret != (len & ~(SHA256_BLOCK_SIZE - 1))); | |
79 | data += ret; | |
80 | len -= ret; | |
81 | } | |
82 | ||
83 | store: | |
0a497c17 JG |
84 | /* anything left? */ |
85 | if (len) | |
86 | memcpy(sctx->buf + index , data, len); | |
87 | } | |
88 | ||
131a395c JG |
89 | /* Add padding and return the message digest */ |
90 | static void sha256_final(struct crypto_tfm *tfm, u8 *out) | |
0a497c17 | 91 | { |
131a395c JG |
92 | struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); |
93 | u64 bits; | |
94 | unsigned int index, end; | |
95 | int ret; | |
0a497c17 | 96 | |
131a395c JG |
97 | /* must perform manual padding */ |
98 | index = sctx->count & 0x3f; | |
99 | end = (index < 56) ? SHA256_BLOCK_SIZE : (2 * SHA256_BLOCK_SIZE); | |
0a497c17 JG |
100 | |
101 | /* start pad with 1 */ | |
102 | sctx->buf[index] = 0x80; | |
103 | ||
104 | /* pad with zeros */ | |
105 | index++; | |
106 | memset(sctx->buf + index, 0x00, end - index - 8); | |
107 | ||
108 | /* append message length */ | |
131a395c JG |
109 | bits = sctx->count * 8; |
110 | memcpy(sctx->buf + end - 8, &bits, sizeof(bits)); | |
0a497c17 | 111 | |
131a395c JG |
112 | ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, sctx->buf, end); |
113 | BUG_ON(ret != end); | |
0a497c17 JG |
114 | |
115 | /* copy digest to out */ | |
116 | memcpy(out, sctx->state, SHA256_DIGEST_SIZE); | |
117 | ||
118 | /* wipe context */ | |
119 | memset(sctx, 0, sizeof *sctx); | |
120 | } | |
121 | ||
122 | static struct crypto_alg alg = { | |
123 | .cra_name = "sha256", | |
65b75c36 HX |
124 | .cra_driver_name = "sha256-s390", |
125 | .cra_priority = CRYPT_S390_PRIORITY, | |
0a497c17 JG |
126 | .cra_flags = CRYPTO_ALG_TYPE_DIGEST, |
127 | .cra_blocksize = SHA256_BLOCK_SIZE, | |
128 | .cra_ctxsize = sizeof(struct s390_sha256_ctx), | |
129 | .cra_module = THIS_MODULE, | |
130 | .cra_list = LIST_HEAD_INIT(alg.cra_list), | |
131 | .cra_u = { .digest = { | |
132 | .dia_digestsize = SHA256_DIGEST_SIZE, | |
7ffbc9da JG |
133 | .dia_init = sha256_init, |
134 | .dia_update = sha256_update, | |
135 | .dia_final = sha256_final } } | |
0a497c17 JG |
136 | }; |
137 | ||
138 | static int init(void) | |
139 | { | |
0a497c17 | 140 | if (!crypt_s390_func_available(KIMD_SHA_256)) |
86aa9fc2 | 141 | return -EOPNOTSUPP; |
0a497c17 | 142 | |
86aa9fc2 | 143 | return crypto_register_alg(&alg); |
0a497c17 JG |
144 | } |
145 | ||
146 | static void __exit fini(void) | |
147 | { | |
148 | crypto_unregister_alg(&alg); | |
149 | } | |
150 | ||
151 | module_init(init); | |
152 | module_exit(fini); | |
153 | ||
154 | MODULE_ALIAS("sha256"); | |
155 | ||
156 | MODULE_LICENSE("GPL"); | |
157 | MODULE_DESCRIPTION("SHA256 Secure Hash Algorithm"); |