1/*
2 * Cryptographic API.
3 *
4 * s390 implementation of the SHA256 Secure Hash Algorithm.
5 *
6 * s390 Version:
7 *   Copyright IBM Corp. 2005,2007
8 *   Author(s): Jan Glauber (jang@de.ibm.com)
9 *
10 * Derived from "crypto/sha256.c"
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
28struct s390_sha256_ctx {
29	u64 count;		/* message length */
30	u32 state[8];
31	u8 buf[2 * SHA256_BLOCK_SIZE];
32};
33
34static void sha256_init(struct crypto_tfm *tfm)
35{
36	struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm);
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;
47}
48
49static void sha256_update(struct crypto_tfm *tfm, const u8 *data,
50			  unsigned int len)
51{
52	struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm);
53	unsigned int index;
54	int ret;
55
56	/* how much is already in the buffer? */
57	index = sctx->count & 0x3f;
58
59	sctx->count += len;
60
61	if ((index + len) < SHA256_BLOCK_SIZE)
62		goto store;
63
64	/* process one stored block */
65	if (index) {
66		memcpy(sctx->buf + index, data, SHA256_BLOCK_SIZE - index);
67		ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, sctx->buf,
68				      SHA256_BLOCK_SIZE);
69		BUG_ON(ret != SHA256_BLOCK_SIZE);
70		data += SHA256_BLOCK_SIZE - index;
71		len -= SHA256_BLOCK_SIZE - index;
72	}
73
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
83store:
84	/* anything left? */
85	if (len)
86		memcpy(sctx->buf + index , data, len);
87}
88
89/* Add padding and return the message digest */
90static void sha256_final(struct crypto_tfm *tfm, u8 *out)
91{
92	struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm);
93	u64 bits;
94	unsigned int index, end;
95	int ret;
96
97	/* must perform manual padding */
98	index = sctx->count & 0x3f;
99	end = (index < 56) ? SHA256_BLOCK_SIZE : (2 * SHA256_BLOCK_SIZE);
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 */
109	bits = sctx->count * 8;
110	memcpy(sctx->buf + end - 8, &bits, sizeof(bits));
111
112	ret = crypt_s390_kimd(KIMD_SHA_256, sctx->state, sctx->buf, end);
113	BUG_ON(ret != end);
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
122static struct crypto_alg alg = {
123	.cra_name	=	"sha256",
124	.cra_driver_name =	"sha256-s390",
125	.cra_priority	=	CRYPT_S390_PRIORITY,
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,
133	.dia_init	=	sha256_init,
134	.dia_update	=	sha256_update,
135	.dia_final	=	sha256_final } }
136};
137
138static int init(void)
139{
140	if (!crypt_s390_func_available(KIMD_SHA_256))
141		return -EOPNOTSUPP;
142
143	return crypto_register_alg(&alg);
144}
145
146static void __exit fini(void)
147{
148	crypto_unregister_alg(&alg);
149}
150
151module_init(init);
152module_exit(fini);
153
154MODULE_ALIAS("sha256");
155
156MODULE_LICENSE("GPL");
157MODULE_DESCRIPTION("SHA256 Secure Hash Algorithm");
158