• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Cryptographic API.
3  * Glue code for the SHA1 Secure Hash Algorithm assembler implementation
4  *
5  * This file is based on sha1_generic.c and sha1_ssse3_glue.c
6  *
7  * Copyright (c) Alan Smithee.
8  * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
9  * Copyright (c) Jean-Francois Dive <jef@linuxbe.org>
10  * Copyright (c) Mathias Krause <minipli@googlemail.com>
11  *
12  * This program is free software; you can redistribute it and/or modify it
13  * under the terms of the GNU General Public License as published by the Free
14  * Software Foundation; either version 2 of the License, or (at your option)
15  * any later version.
16  *
17  */
18 
19 #include <crypto/internal/hash.h>
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <linux/cryptohash.h>
23 #include <linux/types.h>
24 #include <crypto/sha.h>
25 #include <asm/byteorder.h>
26 #include <asm/crypto/sha1.h>
27 
28 
29 asmlinkage void sha1_block_data_order(u32 *digest,
30 		const unsigned char *data, unsigned int rounds);
31 
32 
sha1_init(struct shash_desc * desc)33 static int sha1_init(struct shash_desc *desc)
34 {
35 	struct sha1_state *sctx = shash_desc_ctx(desc);
36 
37 	*sctx = (struct sha1_state){
38 		.state = { SHA1_H0, SHA1_H1, SHA1_H2, SHA1_H3, SHA1_H4 },
39 	};
40 
41 	return 0;
42 }
43 
44 
__sha1_update(struct sha1_state * sctx,const u8 * data,unsigned int len,unsigned int partial)45 static int __sha1_update(struct sha1_state *sctx, const u8 *data,
46 			 unsigned int len, unsigned int partial)
47 {
48 	unsigned int done = 0;
49 
50 	sctx->count += len;
51 
52 	if (partial) {
53 		done = SHA1_BLOCK_SIZE - partial;
54 		memcpy(sctx->buffer + partial, data, done);
55 		sha1_block_data_order(sctx->state, sctx->buffer, 1);
56 	}
57 
58 	if (len - done >= SHA1_BLOCK_SIZE) {
59 		const unsigned int rounds = (len - done) / SHA1_BLOCK_SIZE;
60 		sha1_block_data_order(sctx->state, data + done, rounds);
61 		done += rounds * SHA1_BLOCK_SIZE;
62 	}
63 
64 	memcpy(sctx->buffer, data + done, len - done);
65 	return 0;
66 }
67 
68 
sha1_update_arm(struct shash_desc * desc,const u8 * data,unsigned int len)69 int sha1_update_arm(struct shash_desc *desc, const u8 *data,
70 		    unsigned int len)
71 {
72 	struct sha1_state *sctx = shash_desc_ctx(desc);
73 	unsigned int partial = sctx->count % SHA1_BLOCK_SIZE;
74 	int res;
75 
76 	/* Handle the fast case right here */
77 	if (partial + len < SHA1_BLOCK_SIZE) {
78 		sctx->count += len;
79 		memcpy(sctx->buffer + partial, data, len);
80 		return 0;
81 	}
82 	res = __sha1_update(sctx, data, len, partial);
83 	return res;
84 }
85 EXPORT_SYMBOL_GPL(sha1_update_arm);
86 
87 
88 /* Add padding and return the message digest. */
sha1_final(struct shash_desc * desc,u8 * out)89 static int sha1_final(struct shash_desc *desc, u8 *out)
90 {
91 	struct sha1_state *sctx = shash_desc_ctx(desc);
92 	unsigned int i, index, padlen;
93 	__be32 *dst = (__be32 *)out;
94 	__be64 bits;
95 	static const u8 padding[SHA1_BLOCK_SIZE] = { 0x80, };
96 
97 	bits = cpu_to_be64(sctx->count << 3);
98 
99 	/* Pad out to 56 mod 64 and append length */
100 	index = sctx->count % SHA1_BLOCK_SIZE;
101 	padlen = (index < 56) ? (56 - index) : ((SHA1_BLOCK_SIZE+56) - index);
102 	/* We need to fill a whole block for __sha1_update() */
103 	if (padlen <= 56) {
104 		sctx->count += padlen;
105 		memcpy(sctx->buffer + index, padding, padlen);
106 	} else {
107 		__sha1_update(sctx, padding, padlen, index);
108 	}
109 	__sha1_update(sctx, (const u8 *)&bits, sizeof(bits), 56);
110 
111 	/* Store state in digest */
112 	for (i = 0; i < 5; i++)
113 		dst[i] = cpu_to_be32(sctx->state[i]);
114 
115 	/* Wipe context */
116 	memset(sctx, 0, sizeof(*sctx));
117 	return 0;
118 }
119 
120 
sha1_export(struct shash_desc * desc,void * out)121 static int sha1_export(struct shash_desc *desc, void *out)
122 {
123 	struct sha1_state *sctx = shash_desc_ctx(desc);
124 	memcpy(out, sctx, sizeof(*sctx));
125 	return 0;
126 }
127 
128 
sha1_import(struct shash_desc * desc,const void * in)129 static int sha1_import(struct shash_desc *desc, const void *in)
130 {
131 	struct sha1_state *sctx = shash_desc_ctx(desc);
132 	memcpy(sctx, in, sizeof(*sctx));
133 	return 0;
134 }
135 
136 
137 static struct shash_alg alg = {
138 	.digestsize	=	SHA1_DIGEST_SIZE,
139 	.init		=	sha1_init,
140 	.update		=	sha1_update_arm,
141 	.final		=	sha1_final,
142 	.export		=	sha1_export,
143 	.import		=	sha1_import,
144 	.descsize	=	sizeof(struct sha1_state),
145 	.statesize	=	sizeof(struct sha1_state),
146 	.base		=	{
147 		.cra_name	=	"sha1",
148 		.cra_driver_name=	"sha1-asm",
149 		.cra_priority	=	150,
150 		.cra_flags	=	CRYPTO_ALG_TYPE_SHASH,
151 		.cra_blocksize	=	SHA1_BLOCK_SIZE,
152 		.cra_module	=	THIS_MODULE,
153 	}
154 };
155 
156 
sha1_mod_init(void)157 static int __init sha1_mod_init(void)
158 {
159 	return crypto_register_shash(&alg);
160 }
161 
162 
sha1_mod_fini(void)163 static void __exit sha1_mod_fini(void)
164 {
165 	crypto_unregister_shash(&alg);
166 }
167 
168 
169 module_init(sha1_mod_init);
170 module_exit(sha1_mod_fini);
171 
172 MODULE_LICENSE("GPL");
173 MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm (ARM)");
174 MODULE_ALIAS("sha1");
175 MODULE_AUTHOR("David McCullough <ucdevel@gmail.com>");
176