crypto: md4 - Switch to shash

This patch changes md4 to the new shash interface. Signed-off-by: Adrian-Ken Rueegsegger <ken@codelabs.ch> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

crypto: md4 - Switch to shash
This patch changes md4 to the new shash interface. Signed-off-by: Adrian-Ken Rueegsegger <ken@codelabs.ch> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Adrian-Ken Rueegsegger · Herbert Xu
1 parent 54ccb36776
Showing 2 changed files with 30 additions and 24 deletions Side-by-side Diff
crypto/Kconfig
crypto/md4.c
@@ -276,7 +276,7 @@
  
 config CRYPTO_MD4
 	tristate "MD4 digest algorithm"
-	select CRYPTO_ALGAPI
+	select CRYPTO_HASH
 	help
 	  MD4 message digest algorithm (RFC1320).
  
@@ -20,8 +20,8 @@
  * (at your option) any later version.
  *
  */
+#include <crypto/internal/hash.h>
 #include <linux/init.h>
-#include <linux/crypto.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/types.h>
@@ -58,7 +58,7 @@
 {
 	return x ^ y ^ z;
 }
-                        
+
 #define ROUND1(a,b,c,d,k,s) (a = lshift(a + F(b,c,d) + k, s))
 #define ROUND2(a,b,c,d,k,s) (a = lshift(a + G(b,c,d) + k + (u32)0x5A827999,s))
 #define ROUND3(a,b,c,d,k,s) (a = lshift(a + H(b,c,d) + k + (u32)0x6ED9EBA1,s))
  
  
  
  
@@ -152,20 +152,22 @@
 	md4_transform(ctx->hash, ctx->block);
 }
  
-static void md4_init(struct crypto_tfm *tfm)
+static int md4_init(struct shash_desc *desc)
 {
-	struct md4_ctx *mctx = crypto_tfm_ctx(tfm);
+	struct md4_ctx *mctx = shash_desc_ctx(desc);
  
 	mctx->hash[0] = 0x67452301;
 	mctx->hash[1] = 0xefcdab89;
 	mctx->hash[2] = 0x98badcfe;
 	mctx->hash[3] = 0x10325476;
 	mctx->byte_count = 0;
+
+	return 0;
 }
  
-static void md4_update(struct crypto_tfm *tfm, const u8 *data, unsigned int len)
+static int md4_update(struct shash_desc *desc, const u8 *data, unsigned int len)
 {
-	struct md4_ctx *mctx = crypto_tfm_ctx(tfm);
+	struct md4_ctx *mctx = shash_desc_ctx(desc);
 	const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
  
 	mctx->byte_count += len;
@@ -173,7 +175,7 @@
 	if (avail > len) {
 		memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
 		       data, len);
-		return;
+		return 0;
 	}
  
 	memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
  
  
@@ -191,11 +193,13 @@
 	}
  
 	memcpy(mctx->block, data, len);
+
+	return 0;
 }
  
-static void md4_final(struct crypto_tfm *tfm, u8 *out)
+static int md4_final(struct shash_desc *desc, u8 *out)
 {
-	struct md4_ctx *mctx = crypto_tfm_ctx(tfm);
+	struct md4_ctx *mctx = shash_desc_ctx(desc);
 	const unsigned int offset = mctx->byte_count & 0x3f;
 	char *p = (char *)mctx->block + offset;
 	int padding = 56 - (offset + 1);
  
  
  
@@ -217,30 +221,32 @@
 	cpu_to_le32_array(mctx->hash, ARRAY_SIZE(mctx->hash));
 	memcpy(out, mctx->hash, sizeof(mctx->hash));
 	memset(mctx, 0, sizeof(*mctx));
+
+	return 0;
 }
  
-static struct crypto_alg alg = {
-	.cra_name	=	"md4",
-	.cra_flags	=	CRYPTO_ALG_TYPE_DIGEST,
-	.cra_blocksize	=	MD4_HMAC_BLOCK_SIZE,
-	.cra_ctxsize	=	sizeof(struct md4_ctx),
-	.cra_module	=	THIS_MODULE,
-	.cra_list       =       LIST_HEAD_INIT(alg.cra_list),	
-	.cra_u		=	{ .digest = {
-	.dia_digestsize	=	MD4_DIGEST_SIZE,
-	.dia_init   	= 	md4_init,
-	.dia_update 	=	md4_update,
-	.dia_final  	=	md4_final } }
+static struct shash_alg alg = {
+	.digestsize	=	MD4_DIGEST_SIZE,
+	.init		=	md4_init,
+	.update		=	md4_update,
+	.final		=	md4_final,
+	.descsize	=	sizeof(struct md4_ctx),
+	.base		=	{
+		.cra_name	=	"md4",
+		.cra_flags	=	CRYPTO_ALG_TYPE_SHASH,
+		.cra_blocksize	=	MD4_HMAC_BLOCK_SIZE,
+		.cra_module	=	THIS_MODULE,
+	}
 };
  
 static int __init md4_mod_init(void)
 {
-	return crypto_register_alg(&alg);
+	return crypto_register_shash(&alg);
 }
  
 static void __exit md4_mod_fini(void)
 {
-	crypto_unregister_alg(&alg);
+	crypto_unregister_shash(&alg);
 }
  
 module_init(md4_mod_init);
...	...	@@ -276,7 +276,7 @@
276	276
277	277	config CRYPTO_MD4
278	278	tristate "MD4 digest algorithm"
279		- select CRYPTO_ALGAPI
	279	+ select CRYPTO_HASH
280	280	help
281	281	MD4 message digest algorithm (RFC1320).
282	282
...	...	@@ -20,8 +20,8 @@
20	20	* (at your option) any later version.
21	21	*
22	22	*/
	23	+#include <crypto/internal/hash.h>
23	24	#include <linux/init.h>
24		-#include <linux/crypto.h>
25	25	#include <linux/kernel.h>
26	26	#include <linux/string.h>
27	27	#include <linux/types.h>
...	...	@@ -58,7 +58,7 @@
58	58	{
59	59	return x ^ y ^ z;
60	60	}
61		-
	61	+
62	62	#define ROUND1(a,b,c,d,k,s) (a = lshift(a + F(b,c,d) + k, s))
63	63	#define ROUND2(a,b,c,d,k,s) (a = lshift(a + G(b,c,d) + k + (u32)0x5A827999,s))
64	64	#define ROUND3(a,b,c,d,k,s) (a = lshift(a + H(b,c,d) + k + (u32)0x6ED9EBA1,s))
65	65
66	66
67	67
68	68
...	...	@@ -152,20 +152,22 @@
152	152	md4_transform(ctx->hash, ctx->block);
153	153	}
154	154
155		-static void md4_init(struct crypto_tfm *tfm)
	155	+static int md4_init(struct shash_desc *desc)
156	156	{
157		- struct md4_ctx *mctx = crypto_tfm_ctx(tfm);
	157	+ struct md4_ctx *mctx = shash_desc_ctx(desc);
158	158
159	159	mctx->hash[0] = 0x67452301;
160	160	mctx->hash[1] = 0xefcdab89;
161	161	mctx->hash[2] = 0x98badcfe;
162	162	mctx->hash[3] = 0x10325476;
163	163	mctx->byte_count = 0;
	164	+
	165	+ return 0;
164	166	}
165	167
166		-static void md4_update(struct crypto_tfm tfm, const u8 data, unsigned int len)
	168	+static int md4_update(struct shash_desc desc, const u8 data, unsigned int len)
167	169	{
168		- struct md4_ctx *mctx = crypto_tfm_ctx(tfm);
	170	+ struct md4_ctx *mctx = shash_desc_ctx(desc);
169	171	const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
170	172
171	173	mctx->byte_count += len;
...	...	@@ -173,7 +175,7 @@
173	175	if (avail > len) {
174	176	memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
175	177	data, len);
176		- return;
	178	+ return 0;
177	179	}
178	180
179	181	memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
180	182
181	183
...	...	@@ -191,11 +193,13 @@
191	193	}
192	194
193	195	memcpy(mctx->block, data, len);
	196	+
	197	+ return 0;
194	198	}
195	199
196		-static void md4_final(struct crypto_tfm tfm, u8 out)
	200	+static int md4_final(struct shash_desc desc, u8 out)
197	201	{
198		- struct md4_ctx *mctx = crypto_tfm_ctx(tfm);
	202	+ struct md4_ctx *mctx = shash_desc_ctx(desc);
199	203	const unsigned int offset = mctx->byte_count & 0x3f;
200	204	char p = (char )mctx->block + offset;
201	205	int padding = 56 - (offset + 1);
202	206
203	207
204	208
...	...	@@ -217,30 +221,32 @@
217	221	cpu_to_le32_array(mctx->hash, ARRAY_SIZE(mctx->hash));
218	222	memcpy(out, mctx->hash, sizeof(mctx->hash));
219	223	memset(mctx, 0, sizeof(*mctx));
	224	+
	225	+ return 0;
220	226	}
221	227
222		-static struct crypto_alg alg = {
223		- .cra_name = "md4",
224		- .cra_flags = CRYPTO_ALG_TYPE_DIGEST,
225		- .cra_blocksize = MD4_HMAC_BLOCK_SIZE,
226		- .cra_ctxsize = sizeof(struct md4_ctx),
227		- .cra_module = THIS_MODULE,
228		- .cra_list = LIST_HEAD_INIT(alg.cra_list),
229		- .cra_u = { .digest = {
230		- .dia_digestsize = MD4_DIGEST_SIZE,
231		- .dia_init = md4_init,
232		- .dia_update = md4_update,
233		- .dia_final = md4_final } }
	228	+static struct shash_alg alg = {
	229	+ .digestsize = MD4_DIGEST_SIZE,
	230	+ .init = md4_init,
	231	+ .update = md4_update,
	232	+ .final = md4_final,
	233	+ .descsize = sizeof(struct md4_ctx),
	234	+ .base = {
	235	+ .cra_name = "md4",
	236	+ .cra_flags = CRYPTO_ALG_TYPE_SHASH,
	237	+ .cra_blocksize = MD4_HMAC_BLOCK_SIZE,
	238	+ .cra_module = THIS_MODULE,
	239	+ }
234	240	};
235	241
236	242	static int __init md4_mod_init(void)
237	243	{
238		- return crypto_register_alg(&alg);
	244	+ return crypto_register_shash(&alg);
239	245	}
240	246
241	247	static void __exit md4_mod_fini(void)
242	248	{
243		- crypto_unregister_alg(&alg);
	249	+ crypto_unregister_shash(&alg);
244	250	}
245	251
246	252	module_init(md4_mod_init);