adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-27 03:06:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

crypto: tgr192 - Switch to shash

Browse source 
This patch changes tgr192, tgr160 and tgr128 to the new shash interface.

Signed-off-by: Adrian-Ken Rueegsegger <ken@codelabs.ch>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Adrian-Ken Rueegsegger 2008-12-03 19:58:32 +08:00 committed by Herbert Xu
parent 50e109b5b9
commit f63fbd3d50
2 changed files with 72 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
crypto/Kconfig
View file

@ -381,7 +381,7 @@ config CRYPTO_SHA512
config CRYPTO_TGR192 config CRYPTO_TGR192
tristate "Tiger digest algorithms" tristate "Tiger digest algorithms"
select CRYPTO_ALGAPI select CRYPTO_HASH
help help
Tiger hash algorithm 192, 160 and 128-bit hashes Tiger hash algorithm 192, 160 and 128-bit hashes

135
crypto/tgr192.c
View file

@ -21,11 +21,11 @@
* (at your option) any later version. * (at your option) any later version.
* *
*/ */
#include <crypto/internal/hash.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <asm/byteorder.h> #include <asm/byteorder.h>
#include <linux/crypto.h>
#include <linux/types.h> #include <linux/types.h>
#define TGR192_DIGEST_SIZE 24 #define TGR192_DIGEST_SIZE 24
@ -495,24 +495,26 @@ static void tgr192_transform(struct tgr192_ctx *tctx, const u8 * data)
tctx->c = c; tctx->c = c;
} }
static void tgr192_init(struct crypto_tfm *tfm) static int tgr192_init(struct shash_desc *desc)
{ {
struct tgr192_ctx *tctx = crypto_tfm_ctx(tfm); struct tgr192_ctx *tctx = shash_desc_ctx(desc);
tctx->a = 0x0123456789abcdefULL; tctx->a = 0x0123456789abcdefULL;
tctx->b = 0xfedcba9876543210ULL; tctx->b = 0xfedcba9876543210ULL;
tctx->c = 0xf096a5b4c3b2e187ULL; tctx->c = 0xf096a5b4c3b2e187ULL;
tctx->nblocks = 0; tctx->nblocks = 0;
tctx->count = 0; tctx->count = 0;
return 0;
} }
/* Update the message digest with the contents /* Update the message digest with the contents
* of INBUF with length INLEN. */ * of INBUF with length INLEN. */
static void tgr192_update(struct crypto_tfm *tfm, const u8 *inbuf, static int tgr192_update(struct shash_desc *desc, const u8 *inbuf,
unsigned int len) unsigned int len)
{ {
struct tgr192_ctx *tctx = crypto_tfm_ctx(tfm); struct tgr192_ctx *tctx = shash_desc_ctx(desc);
if (tctx->count == 64) { /* flush the buffer */ if (tctx->count == 64) { /* flush the buffer */
tgr192_transform(tctx, tctx->hash); tgr192_transform(tctx, tctx->hash);
@ -520,15 +522,15 @@ static void tgr192_update(struct crypto_tfm *tfm, const u8 *inbuf,
tctx->nblocks++; tctx->nblocks++;
} }
if (!inbuf) { if (!inbuf) {
return; return 0;
} }
if (tctx->count) { if (tctx->count) {
for (; len && tctx->count < 64; len--) { for (; len && tctx->count < 64; len--) {
tctx->hash[tctx->count++] = *inbuf++; tctx->hash[tctx->count++] = *inbuf++;
} }
tgr192_update(tfm, NULL, 0); tgr192_update(desc, NULL, 0);
if (!len) { if (!len) {
return; return 0;
} }
} }
@ -543,20 +545,22 @@ static void tgr192_update(struct crypto_tfm *tfm, const u8 *inbuf,
for (; len && tctx->count < 64; len--) { for (; len && tctx->count < 64; len--) {
tctx->hash[tctx->count++] = *inbuf++; tctx->hash[tctx->count++] = *inbuf++;
} }
return 0;
} }
/* The routine terminates the computation */ /* The routine terminates the computation */
static void tgr192_final(struct crypto_tfm *tfm, u8 * out) static int tgr192_final(struct shash_desc *desc, u8 * out)
{ {
struct tgr192_ctx *tctx = crypto_tfm_ctx(tfm); struct tgr192_ctx *tctx = shash_desc_ctx(desc);
__be64 *dst = (__be64 *)out; __be64 *dst = (__be64 *)out;
__be64 *be64p; __be64 *be64p;
__le32 *le32p; __le32 *le32p;
u32 t, msb, lsb; u32 t, msb, lsb;
tgr192_update(tfm, NULL, 0); /* flush */ ; tgr192_update(desc, NULL, 0); /* flush */ ;
msb = 0; msb = 0;
t = tctx->nblocks; t = tctx->nblocks;
@ -584,7 +588,7 @@ static void tgr192_final(struct crypto_tfm *tfm, u8 * out)
while (tctx->count < 64) { while (tctx->count < 64) {
tctx->hash[tctx->count++] = 0; tctx->hash[tctx->count++] = 0;
} }
tgr192_update(tfm, NULL, 0); /* flush */ ; tgr192_update(desc, NULL, 0); /* flush */ ;
memset(tctx->hash, 0, 56); /* fill next block with zeroes */ memset(tctx->hash, 0, 56); /* fill next block with zeroes */
} }
/* append the 64 bit count */ /* append the 64 bit count */
@ -598,91 +602,94 @@ static void tgr192_final(struct crypto_tfm *tfm, u8 * out)
dst[0] = be64p[0] = cpu_to_be64(tctx->a); dst[0] = be64p[0] = cpu_to_be64(tctx->a);
dst[1] = be64p[1] = cpu_to_be64(tctx->b); dst[1] = be64p[1] = cpu_to_be64(tctx->b);
dst[2] = be64p[2] = cpu_to_be64(tctx->c); dst[2] = be64p[2] = cpu_to_be64(tctx->c);
return 0;
} }
static void tgr160_final(struct crypto_tfm *tfm, u8 * out) static int tgr160_final(struct shash_desc *desc, u8 * out)
{ {
u8 D[64]; u8 D[64];
tgr192_final(tfm, D); tgr192_final(desc, D);
memcpy(out, D, TGR160_DIGEST_SIZE); memcpy(out, D, TGR160_DIGEST_SIZE);
memset(D, 0, TGR192_DIGEST_SIZE); memset(D, 0, TGR192_DIGEST_SIZE);
return 0;
} }
static void tgr128_final(struct crypto_tfm *tfm, u8 * out) static int tgr128_final(struct shash_desc *desc, u8 * out)
{ {
u8 D[64]; u8 D[64];
tgr192_final(tfm, D); tgr192_final(desc, D);
memcpy(out, D, TGR128_DIGEST_SIZE); memcpy(out, D, TGR128_DIGEST_SIZE);
memset(D, 0, TGR192_DIGEST_SIZE); memset(D, 0, TGR192_DIGEST_SIZE);
return 0;
} }
static struct crypto_alg tgr192 = { static struct shash_alg tgr192 = {
.cra_name = "tgr192", .digestsize = TGR192_DIGEST_SIZE,
.cra_flags = CRYPTO_ALG_TYPE_DIGEST, .init = tgr192_init,
.cra_blocksize = TGR192_BLOCK_SIZE, .update = tgr192_update,
.cra_ctxsize = sizeof(struct tgr192_ctx), .final = tgr192_final,
.cra_module = THIS_MODULE, .descsize = sizeof(struct tgr192_ctx),
.cra_alignmask = 7, .base = {
.cra_list = LIST_HEAD_INIT(tgr192.cra_list), .cra_name = "tgr192",
.cra_u = {.digest = { .cra_flags = CRYPTO_ALG_TYPE_SHASH,
.dia_digestsize = TGR192_DIGEST_SIZE, .cra_blocksize = TGR192_BLOCK_SIZE,
.dia_init = tgr192_init, .cra_module = THIS_MODULE,
.dia_update = tgr192_update, }
.dia_final = tgr192_final}}
}; };
static struct crypto_alg tgr160 = { static struct shash_alg tgr160 = {
.cra_name = "tgr160", .digestsize = TGR160_DIGEST_SIZE,
.cra_flags = CRYPTO_ALG_TYPE_DIGEST, .init = tgr192_init,
.cra_blocksize = TGR192_BLOCK_SIZE, .update = tgr192_update,
.cra_ctxsize = sizeof(struct tgr192_ctx), .final = tgr160_final,
.cra_module = THIS_MODULE, .descsize = sizeof(struct tgr192_ctx),
.cra_alignmask = 7, .base = {
.cra_list = LIST_HEAD_INIT(tgr160.cra_list), .cra_name = "tgr160",
.cra_u = {.digest = { .cra_flags = CRYPTO_ALG_TYPE_SHASH,
.dia_digestsize = TGR160_DIGEST_SIZE, .cra_blocksize = TGR192_BLOCK_SIZE,
.dia_init = tgr192_init, .cra_module = THIS_MODULE,
.dia_update = tgr192_update, }
.dia_final = tgr160_final}}
}; };
static struct crypto_alg tgr128 = { static struct shash_alg tgr128 = {
.cra_name = "tgr128", .digestsize = TGR128_DIGEST_SIZE,
.cra_flags = CRYPTO_ALG_TYPE_DIGEST, .init = tgr192_init,
.cra_blocksize = TGR192_BLOCK_SIZE, .update = tgr192_update,
.cra_ctxsize = sizeof(struct tgr192_ctx), .final = tgr128_final,
.cra_module = THIS_MODULE, .descsize = sizeof(struct tgr192_ctx),
.cra_alignmask = 7, .base = {
.cra_list = LIST_HEAD_INIT(tgr128.cra_list), .cra_name = "tgr128",
.cra_u = {.digest = { .cra_flags = CRYPTO_ALG_TYPE_SHASH,
.dia_digestsize = TGR128_DIGEST_SIZE, .cra_blocksize = TGR192_BLOCK_SIZE,
.dia_init = tgr192_init, .cra_module = THIS_MODULE,
.dia_update = tgr192_update, }
.dia_final = tgr128_final}}
}; };
static int __init tgr192_mod_init(void) static int __init tgr192_mod_init(void)
{ {
int ret = 0; int ret = 0;
ret = crypto_register_alg(&tgr192); ret = crypto_register_shash(&tgr192);
if (ret < 0) { if (ret < 0) {
goto out; goto out;
} }
ret = crypto_register_alg(&tgr160); ret = crypto_register_shash(&tgr160);
if (ret < 0) { if (ret < 0) {
crypto_unregister_alg(&tgr192); crypto_unregister_shash(&tgr192);
goto out; goto out;
} }
ret = crypto_register_alg(&tgr128); ret = crypto_register_shash(&tgr128);
if (ret < 0) { if (ret < 0) {
crypto_unregister_alg(&tgr192); crypto_unregister_shash(&tgr192);
crypto_unregister_alg(&tgr160); crypto_unregister_shash(&tgr160);
} }
out: out:
return ret; return ret;
@ -690,9 +697,9 @@ static int __init tgr192_mod_init(void)
static void __exit tgr192_mod_fini(void) static void __exit tgr192_mod_fini(void)
{ {
crypto_unregister_alg(&tgr192); crypto_unregister_shash(&tgr192);
crypto_unregister_alg(&tgr160); crypto_unregister_shash(&tgr160);
crypto_unregister_alg(&tgr128); crypto_unregister_shash(&tgr128);
} }
MODULE_ALIAS("tgr160"); MODULE_ALIAS("tgr160");