On Thu, Aug 14, 2008 at 09:51:38PM +1000, Herbert Xu wrote: > On Mon, Aug 11, 2008 at 04:26:07PM -0400, Neil Horman wrote: > > Patch to obscure state information on free in prng code. Keeps prying eyes > > from > > sifting through your trash :) > > Thanks Neil. I've merged this with the original patch and made > some small changes on the API side, such as adding a reset helper > and adding a krng that just uses get_random_bytes. > > Here is the final result against cryptodev-2.6. Let me know if > you're OK with it and I'll push it out. > > Cheers,
Looks great to me. Thanks Herbert! Best Neil > -- > Visit Openswan at http://www.openswan.org/ > Email: Herbert Xu ~{PmV>HI~} <[EMAIL PROTECTED]> > Home Page: http://gondor.apana.org.au/~herbert/ > PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt > -- > diff --git a/crypto/Kconfig b/crypto/Kconfig > index 776f90d..15823a6 100644 > --- a/crypto/Kconfig > +++ b/crypto/Kconfig > @@ -38,6 +38,10 @@ config CRYPTO_HASH > tristate > select CRYPTO_ALGAPI > > +config CRYPTO_RNG > + tristate > + select CRYPTO_ALGAPI > + > config CRYPTO_MANAGER > tristate "Cryptographic algorithm manager" > select CRYPTO_AEAD > @@ -681,6 +685,18 @@ config CRYPTO_LZO > help > This is the LZO algorithm. > > +comment "Random Number Generation" > + > +config CRYPTO_ANSI_CPRNG > + tristate "Pseudo Random Number Generation for Cryptographic modules" > + select CRYPTO_AES > + select CRYPTO_CTR > + select CRYPTO_RNG > + help > + This option enables the generic pseudo random number generator > + for cryptographic modules. Uses the Algorithm specified in > + ANSI X9.31 A.2.4 > + > source "drivers/crypto/Kconfig" > > endif # if CRYPTO > diff --git a/crypto/Makefile b/crypto/Makefile > index 59ab500..a14ed7d 100644 > --- a/crypto/Makefile > +++ b/crypto/Makefile > @@ -24,6 +24,8 @@ obj-$(CONFIG_CRYPTO_HASH) += crypto_hash.o > > cryptomgr-objs := algboss.o testmgr.o > > +rng-objs := rngapi.o krng.o > + > obj-$(CONFIG_CRYPTO_MANAGER) += cryptomgr.o > obj-$(CONFIG_CRYPTO_HMAC) += hmac.o > obj-$(CONFIG_CRYPTO_XCBC) += xcbc.o > @@ -71,7 +73,8 @@ obj-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o > obj-$(CONFIG_CRYPTO_CRC32C) += crc32c.o > obj-$(CONFIG_CRYPTO_AUTHENC) += authenc.o > obj-$(CONFIG_CRYPTO_LZO) += lzo.o > - > +obj-$(CONFIG_CRYPTO_RNG) += rng.o > +obj-$(CONFIG_CRYPTO_ANSI_CPRNG) += ansi_cprng.o > obj-$(CONFIG_CRYPTO_TEST) += tcrypt.o > > # > diff --git a/crypto/ansi_cprng.c b/crypto/ansi_cprng.c > new file mode 100644 > index 0000000..c20642e > --- /dev/null > +++ b/crypto/ansi_cprng.c > @@ -0,0 +1,417 @@ > +/* > + * PRNG: Pseudo Random Number Generator > + * Based on NIST Recommended PRNG From ANSI X9.31 Appendix A.2.4 using > + * AES 128 cipher > + * > + * (C) Neil Horman <[EMAIL PROTECTED]> > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms of the GNU General Public License as published by the > + * Free Software Foundation; either version 2 of the License, or (at your > + * any later version. > + * > + * > + */ > + > +#include <crypto/internal/rng.h> > +#include <linux/err.h> > +#include <linux/init.h> > +#include <linux/module.h> > +#include <linux/moduleparam.h> > +#include <linux/string.h> > + > +#include "internal.h" > + > +#define DEFAULT_PRNG_KEY "0123456789abcdef" > +#define DEFAULT_PRNG_KSZ 16 > +#define DEFAULT_BLK_SZ 16 > +#define DEFAULT_V_SEED "zaybxcwdveuftgsh" > + > +/* > + * Flags for the prng_context flags field > + */ > + > +#define PRNG_FIXED_SIZE 0x1 > +#define PRNG_NEED_RESET 0x2 > + > +/* > + * Note: DT is our counter value > + * I is our intermediate value > + * V is our seed vector > + * See http://csrc.nist.gov/groups/STM/cavp/documents/rng/931rngext.pdf > + * for implementation details > + */ > + > + > +struct prng_context { > + spinlock_t prng_lock; > + unsigned char rand_data[DEFAULT_BLK_SZ]; > + unsigned char last_rand_data[DEFAULT_BLK_SZ]; > + unsigned char DT[DEFAULT_BLK_SZ]; > + unsigned char I[DEFAULT_BLK_SZ]; > + unsigned char V[DEFAULT_BLK_SZ]; > + u32 rand_data_valid; > + struct crypto_cipher *tfm; > + u32 flags; > +}; > + > +static int dbg; > + > +static void hexdump(char *note, unsigned char *buf, unsigned int len) > +{ > + if (dbg) { > + printk(KERN_CRIT "%s", note); > + print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, > + 16, 1, > + buf, len, false); > + } > +} > + > +#define dbgprint(format, args...) do {\ > +if (dbg)\ > + printk(format, ##args);\ > +} while (0) > + > +static void xor_vectors(unsigned char *in1, unsigned char *in2, > + unsigned char *out, unsigned int size) > +{ > + int i; > + > + for (i = 0; i < size; i++) > + out[i] = in1[i] ^ in2[i]; > + > +} > +/* > + * Returns DEFAULT_BLK_SZ bytes of random data per call > + * returns 0 if generation succeded, <0 if something went wrong > + */ > +static int _get_more_prng_bytes(struct prng_context *ctx) > +{ > + int i; > + unsigned char tmp[DEFAULT_BLK_SZ]; > + unsigned char *output = NULL; > + > + > + dbgprint(KERN_CRIT "Calling _get_more_prng_bytes for context %p\n", > + ctx); > + > + hexdump("Input DT: ", ctx->DT, DEFAULT_BLK_SZ); > + hexdump("Input I: ", ctx->I, DEFAULT_BLK_SZ); > + hexdump("Input V: ", ctx->V, DEFAULT_BLK_SZ); > + > + /* > + * This algorithm is a 3 stage state machine > + */ > + for (i = 0; i < 3; i++) { > + > + switch (i) { > + case 0: > + /* > + * Start by encrypting the counter value > + * This gives us an intermediate value I > + */ > + memcpy(tmp, ctx->DT, DEFAULT_BLK_SZ); > + output = ctx->I; > + hexdump("tmp stage 0: ", tmp, DEFAULT_BLK_SZ); > + break; > + case 1: > + > + /* > + * Next xor I with our secret vector V > + * encrypt that result to obtain our > + * pseudo random data which we output > + */ > + xor_vectors(ctx->I, ctx->V, tmp, DEFAULT_BLK_SZ); > + hexdump("tmp stage 1: ", tmp, DEFAULT_BLK_SZ); > + output = ctx->rand_data; > + break; > + case 2: > + /* > + * First check that we didn't produce the same > + * random data that we did last time around through this > + */ > + if (!memcmp(ctx->rand_data, ctx->last_rand_data, > + DEFAULT_BLK_SZ)) { > + printk(KERN_ERR > + "ctx %p Failed repetition check!\n", > + ctx); > + ctx->flags |= PRNG_NEED_RESET; > + return -EINVAL; > + } > + memcpy(ctx->last_rand_data, ctx->rand_data, > + DEFAULT_BLK_SZ); > + > + /* > + * Lastly xor the random data with I > + * and encrypt that to obtain a new secret vector V > + */ > + xor_vectors(ctx->rand_data, ctx->I, tmp, > + DEFAULT_BLK_SZ); > + output = ctx->V; > + hexdump("tmp stage 2: ", tmp, DEFAULT_BLK_SZ); > + break; > + } > + > + > + /* do the encryption */ > + crypto_cipher_encrypt_one(ctx->tfm, output, tmp); > + > + } > + > + /* > + * Now update our DT value > + */ > + for (i = 0; i < DEFAULT_BLK_SZ; i++) { > + ctx->DT[i] += 1; > + if (ctx->DT[i] != 0) > + break; > + } > + > + dbgprint("Returning new block for context %p\n", ctx); > + ctx->rand_data_valid = 0; > + > + hexdump("Output DT: ", ctx->DT, DEFAULT_BLK_SZ); > + hexdump("Output I: ", ctx->I, DEFAULT_BLK_SZ); > + hexdump("Output V: ", ctx->V, DEFAULT_BLK_SZ); > + hexdump("New Random Data: ", ctx->rand_data, DEFAULT_BLK_SZ); > + > + return 0; > +} > + > +/* Our exported functions */ > +static int get_prng_bytes(char *buf, size_t nbytes, struct prng_context *ctx) > +{ > + unsigned long flags; > + unsigned char *ptr = buf; > + unsigned int byte_count = (unsigned int)nbytes; > + int err; > + > + > + if (nbytes < 0) > + return -EINVAL; > + > + spin_lock_irqsave(&ctx->prng_lock, flags); > + > + err = -EINVAL; > + if (ctx->flags & PRNG_NEED_RESET) > + goto done; > + > + /* > + * If the FIXED_SIZE flag is on, only return whole blocks of > + * pseudo random data > + */ > + err = -EINVAL; > + if (ctx->flags & PRNG_FIXED_SIZE) { > + if (nbytes < DEFAULT_BLK_SZ) > + goto done; > + byte_count = DEFAULT_BLK_SZ; > + } > + > + err = byte_count; > + > + dbgprint(KERN_CRIT "getting %d random bytes for context %p\n", > + byte_count, ctx); > + > + > +remainder: > + if (ctx->rand_data_valid == DEFAULT_BLK_SZ) { > + if (_get_more_prng_bytes(ctx) < 0) { > + memset(buf, 0, nbytes); > + err = -EINVAL; > + goto done; > + } > + } > + > + /* > + * Copy up to the next whole block size > + */ > + if (byte_count < DEFAULT_BLK_SZ) { > + for (; ctx->rand_data_valid < DEFAULT_BLK_SZ; > + ctx->rand_data_valid++) { > + *ptr = ctx->rand_data[ctx->rand_data_valid]; > + ptr++; > + byte_count--; > + if (byte_count == 0) > + goto done; > + } > + } > + > + /* > + * Now copy whole blocks > + */ > + for (; byte_count >= DEFAULT_BLK_SZ; byte_count -= DEFAULT_BLK_SZ) { > + if (_get_more_prng_bytes(ctx) < 0) { > + memset(buf, 0, nbytes); > + err = -EINVAL; > + goto done; > + } > + memcpy(ptr, ctx->rand_data, DEFAULT_BLK_SZ); > + ctx->rand_data_valid += DEFAULT_BLK_SZ; > + ptr += DEFAULT_BLK_SZ; > + } > + > + /* > + * Now copy any extra partial data > + */ > + if (byte_count) > + goto remainder; > + > +done: > + spin_unlock_irqrestore(&ctx->prng_lock, flags); > + dbgprint(KERN_CRIT "returning %d from get_prng_bytes in context %p\n", > + err, ctx); > + return err; > +} > + > +static void free_prng_context(struct prng_context *ctx) > +{ > + crypto_free_cipher(ctx->tfm); > +} > + > +static int reset_prng_context(struct prng_context *ctx, > + unsigned char *key, size_t klen, > + unsigned char *V, unsigned char *DT) > +{ > + int ret; > + int rc = -EINVAL; > + unsigned char *prng_key; > + > + spin_lock(&ctx->prng_lock); > + ctx->flags |= PRNG_NEED_RESET; > + > + prng_key = (key != NULL) ? key : (unsigned char *)DEFAULT_PRNG_KEY; > + > + if (!key) > + klen = DEFAULT_PRNG_KSZ; > + > + if (V) > + memcpy(ctx->V, V, DEFAULT_BLK_SZ); > + else > + memcpy(ctx->V, DEFAULT_V_SEED, DEFAULT_BLK_SZ); > + > + if (DT) > + memcpy(ctx->DT, DT, DEFAULT_BLK_SZ); > + else > + memset(ctx->DT, 0, DEFAULT_BLK_SZ); > + > + memset(ctx->rand_data, 0, DEFAULT_BLK_SZ); > + memset(ctx->last_rand_data, 0, DEFAULT_BLK_SZ); > + > + if (ctx->tfm) > + crypto_free_cipher(ctx->tfm); > + > + ctx->tfm = crypto_alloc_cipher("aes", 0, 0); > + if (IS_ERR(ctx->tfm)) { > + dbgprint(KERN_CRIT "Failed to alloc tfm for context %p\n", > + ctx); > + ctx->tfm = NULL; > + goto out; > + } > + > + ctx->rand_data_valid = DEFAULT_BLK_SZ; > + > + ret = crypto_cipher_setkey(ctx->tfm, prng_key, klen); > + if (ret) { > + dbgprint(KERN_CRIT "PRNG: setkey() failed flags=%x\n", > + crypto_cipher_get_flags(ctx->tfm)); > + crypto_free_cipher(ctx->tfm); > + goto out; > + } > + > + rc = 0; > + ctx->flags &= ~PRNG_NEED_RESET; > +out: > + spin_unlock(&ctx->prng_lock); > + > + return rc; > + > +} > + > +static int cprng_init(struct crypto_tfm *tfm) > +{ > + struct prng_context *ctx = crypto_tfm_ctx(tfm); > + > + spin_lock_init(&ctx->prng_lock); > + > + return reset_prng_context(ctx, NULL, DEFAULT_PRNG_KSZ, NULL, NULL); > +} > + > +static void cprng_exit(struct crypto_tfm *tfm) > +{ > + free_prng_context(crypto_tfm_ctx(tfm)); > +} > + > +static int cprng_get_random(struct crypto_rng *tfm, u8 *rdata, > + unsigned int dlen) > +{ > + struct prng_context *prng = crypto_rng_ctx(tfm); > + > + return get_prng_bytes(rdata, dlen, prng); > +} > + > +static int cprng_reset(struct crypto_rng *tfm, u8 *seed, unsigned int slen) > +{ > + struct prng_context *prng = crypto_rng_ctx(tfm); > + u8 *key = seed + DEFAULT_PRNG_KSZ; > + > + if (slen < DEFAULT_PRNG_KSZ + DEFAULT_BLK_SZ) > + return -EINVAL; > + > + reset_prng_context(prng, key, DEFAULT_PRNG_KSZ, seed, NULL); > + > + if (prng->flags & PRNG_NEED_RESET) > + return -EINVAL; > + return 0; > +} > + > +static struct crypto_alg rng_alg = { > + .cra_name = "stdrng", > + .cra_driver_name = "ansi_cprng", > + .cra_priority = 100, > + .cra_flags = CRYPTO_ALG_TYPE_RNG, > + .cra_ctxsize = sizeof(struct prng_context), > + .cra_type = &crypto_rng_type, > + .cra_module = THIS_MODULE, > + .cra_list = LIST_HEAD_INIT(rng_alg.cra_list), > + .cra_init = cprng_init, > + .cra_exit = cprng_exit, > + .cra_u = { > + .rng = { > + .rng_make_random = cprng_get_random, > + .rng_reset = cprng_reset, > + .seedsize = DEFAULT_PRNG_KSZ + DEFAULT_BLK_SZ, > + } > + } > +}; > + > + > +/* Module initalization */ > +static int __init prng_mod_init(void) > +{ > + int ret = 0; > + > + if (fips_enabled) > + rng_alg.cra_priority += 200; > + > + ret = crypto_register_alg(&rng_alg); > + > + if (ret) > + goto out; > +out: > + return 0; > +} > + > +static void __exit prng_mod_fini(void) > +{ > + crypto_unregister_alg(&rng_alg); > + return; > +} > + > +MODULE_LICENSE("GPL"); > +MODULE_DESCRIPTION("Software Pseudo Random Number Generator"); > +MODULE_AUTHOR("Neil Horman <[EMAIL PROTECTED]>"); > +module_param(dbg, int, 0); > +MODULE_PARM_DESC(dbg, "Boolean to enable debugging (0/1 == off/on)"); > +module_init(prng_mod_init); > +module_exit(prng_mod_fini); > +MODULE_ALIAS("stdrng"); > diff --git a/crypto/krng.c b/crypto/krng.c > new file mode 100644 > index 0000000..8ef62a9 > --- /dev/null > +++ b/crypto/krng.c > @@ -0,0 +1,66 @@ > +/* > + * RNG implementation using standard kernel RNG. > + * > + * Copyright (c) 2008 Herbert Xu <[EMAIL PROTECTED]> > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms of the GNU General Public License as published by the > + * Free Software Foundation; either version 2 of the License, or (at your > + * any later version. > + * > + */ > + > +#include <crypto/internal/rng.h> > +#include <linux/err.h> > +#include <linux/init.h> > +#include <linux/module.h> > +#include <linux/random.h> > + > +static int krng_get_random(struct crypto_rng *tfm, u8 *rdata, unsigned int > dlen) > +{ > + get_random_bytes(rdata, dlen); > + return 0; > +} > + > +static int krng_reset(struct crypto_rng *tfm, u8 *seed, unsigned int slen) > +{ > + return 0; > +} > + > +static struct crypto_alg krng_alg = { > + .cra_name = "stdrng", > + .cra_driver_name = "krng", > + .cra_priority = 200, > + .cra_flags = CRYPTO_ALG_TYPE_RNG, > + .cra_ctxsize = 0, > + .cra_type = &crypto_rng_type, > + .cra_module = THIS_MODULE, > + .cra_list = LIST_HEAD_INIT(krng_alg.cra_list), > + .cra_u = { > + .rng = { > + .rng_make_random = krng_get_random, > + .rng_reset = krng_reset, > + .seedsize = 0, > + } > + } > +}; > + > + > +/* Module initalization */ > +static int __init krng_mod_init(void) > +{ > + return crypto_register_alg(&krng_alg); > +} > + > +static void __exit krng_mod_fini(void) > +{ > + crypto_unregister_alg(&krng_alg); > + return; > +} > + > +module_init(krng_mod_init); > +module_exit(krng_mod_fini); > + > +MODULE_LICENSE("GPL"); > +MODULE_DESCRIPTION("Random Number Generator API"); > +MODULE_ALIAS("stdrng"); > diff --git a/crypto/rngapi.c b/crypto/rngapi.c > new file mode 100644 > index 0000000..ea57697 > --- /dev/null > +++ b/crypto/rngapi.c > @@ -0,0 +1,74 @@ > +/* > + * Cryptographic API. > + * > + * RNG operations. > + * > + * Copyright (c) 2008 Neil Horman <[EMAIL PROTECTED]> > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms of the GNU General Public License as published by the Free > + * Software Foundation; either version 2 of the License, or (at your option) > + * any later version. > + * > + */ > + > +#include <crypto/internal/rng.h> > +#include <linux/errno.h> > +#include <linux/module.h> > +#include <linux/random.h> > +#include <linux/seq_file.h> > +#include <linux/string.h> > + > +static int rngapi_reset(struct crypto_rng *tfm, u8 *seed, unsigned int slen) > +{ > + u8 *buf = NULL; > + int err; > + > + if (!seed && slen) { > + buf = kmalloc(slen, GFP_KERNEL); > + if (!buf) > + return -ENOMEM; > + > + get_random_bytes(buf, slen); > + seed = buf; > + } > + > + err = crypto_rng_crt(tfm)->rng_reset(tfm, seed, slen); > + > + kfree(buf); > + return err; > +} > + > +static int crypto_init_rng_ops(struct crypto_tfm *tfm, u32 type, u32 mask) > +{ > + struct rng_alg *alg = &tfm->__crt_alg->cra_rng; > + struct rng_tfm *ops = &tfm->crt_rng; > + > + ops->rng_gen_random = alg->rng_make_random; > + ops->rng_reset = rngapi_reset; > + > + return 0; > +} > + > +static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg) > + __attribute__ ((unused)); > +static void crypto_rng_show(struct seq_file *m, struct crypto_alg *alg) > +{ > + seq_printf(m, "type : rng\n"); > + seq_printf(m, "seedsize : %u\n", alg->cra_rng.seedsize); > +} > + > +static unsigned int crypto_rng_ctxsize(struct crypto_alg *alg, u32 type, > + u32 mask) > +{ > + return alg->cra_ctxsize; > +} > + > +const struct crypto_type crypto_rng_type = { > + .ctxsize = crypto_rng_ctxsize, > + .init = crypto_init_rng_ops, > +#ifdef CONFIG_PROC_FS > + .show = crypto_rng_show, > +#endif > +}; > +EXPORT_SYMBOL_GPL(crypto_rng_type); > diff --git a/include/crypto/internal/rng.h b/include/crypto/internal/rng.h > new file mode 100644 > index 0000000..8969733 > --- /dev/null > +++ b/include/crypto/internal/rng.h > @@ -0,0 +1,26 @@ > +/* > + * RNG: Random Number Generator algorithms under the crypto API > + * > + * Copyright (c) 2008 Neil Horman <[EMAIL PROTECTED]> > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms of the GNU General Public License as published by the Free > + * Software Foundation; either version 2 of the License, or (at your option) > + * any later version. > + * > + */ > + > +#ifndef _CRYPTO_INTERNAL_RNG_H > +#define _CRYPTO_INTERNAL_RNG_H > + > +#include <crypto/algapi.h> > +#include <crypto/rng.h> > + > +extern const struct crypto_type crypto_rng_type; > + > +static inline void *crypto_rng_ctx(struct crypto_rng *tfm) > +{ > + return crypto_tfm_ctx(&tfm->base); > +} > + > +#endif > diff --git a/include/crypto/rng.h b/include/crypto/rng.h > new file mode 100644 > index 0000000..7a33c63 > --- /dev/null > +++ b/include/crypto/rng.h > @@ -0,0 +1,70 @@ > +/* > + * RNG: Random Number Generator algorithms under the crypto API > + * > + * Copyright (c) 2008 Neil Horman <[EMAIL PROTECTED]> > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms of the GNU General Public License as published by the Free > + * Software Foundation; either version 2 of the License, or (at your option) > + * any later version. > + * > + */ > + > +#ifndef _CRYPTO_RNG_H > +#define _CRYPTO_RNG_H > + > +#include <linux/crypto.h> > + > +static inline struct crypto_rng *__crypto_rng_cast(struct crypto_tfm *tfm) > +{ > + return (struct crypto_rng *)tfm; > +} > + > +static inline struct crypto_rng *crypto_alloc_rng(const char *alg_name) > +{ > + u32 type, mask; > + > + mask = CRYPTO_ALG_TYPE_MASK; > + type = CRYPTO_ALG_TYPE_RNG; > + > + return __crypto_rng_cast(crypto_alloc_base(alg_name, type, mask)); > +} > + > +static inline struct crypto_tfm *crypto_rng_tfm(struct crypto_rng *tfm) > +{ > + return &tfm->base; > +} > + > +static inline struct rng_alg *crypto_rng_alg(struct crypto_rng *tfm) > +{ > + return &crypto_rng_tfm(tfm)->__crt_alg->cra_rng; > +} > + > +static inline struct rng_tfm *crypto_rng_crt(struct crypto_rng *tfm) > +{ > + return &crypto_rng_tfm(tfm)->crt_rng; > +} > + > +static inline void crypto_free_rng(struct crypto_rng *tfm) > +{ > + crypto_free_tfm(crypto_rng_tfm(tfm)); > +} > + > +static inline int crypto_rng_get_bytes(struct crypto_rng *tfm, > + u8 *rdata, unsigned int dlen) > +{ > + return crypto_rng_crt(tfm)->rng_gen_random(tfm, rdata, dlen); > +} > + > +static inline int crypto_rng_reset(struct crypto_rng *tfm, > + u8 *seed, unsigned int slen) > +{ > + return crypto_rng_crt(tfm)->rng_reset(tfm, seed, slen); > +} > + > +static inline int crypto_rng_seedsize(struct crypto_rng *tfm) > +{ > + return crypto_rng_alg(tfm)->seedsize; > +} > + > +#endif > diff --git a/include/linux/crypto.h b/include/linux/crypto.h > index 81d994a..3d2317e 100644 > --- a/include/linux/crypto.h > +++ b/include/linux/crypto.h > @@ -38,6 +38,7 @@ > #define CRYPTO_ALG_TYPE_DIGEST 0x00000008 > #define CRYPTO_ALG_TYPE_HASH 0x00000009 > #define CRYPTO_ALG_TYPE_AHASH 0x0000000a > +#define CRYPTO_ALG_TYPE_RNG 0x0000000c > > #define CRYPTO_ALG_TYPE_HASH_MASK 0x0000000e > #define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000c > @@ -113,6 +114,7 @@ struct crypto_aead; > struct crypto_blkcipher; > struct crypto_hash; > struct crypto_ahash; > +struct crypto_rng; > struct crypto_tfm; > struct crypto_type; > struct aead_givcrypt_request; > @@ -298,6 +300,15 @@ struct compress_alg { > unsigned int slen, u8 *dst, unsigned int *dlen); > }; > > +struct rng_alg { > + int (*rng_make_random)(struct crypto_rng *tfm, u8 *rdata, > + unsigned int dlen); > + int (*rng_reset)(struct crypto_rng *tfm, u8 *seed, unsigned int slen); > + > + unsigned int seedsize; > +}; > + > + > #define cra_ablkcipher cra_u.ablkcipher > #define cra_aead cra_u.aead > #define cra_blkcipher cra_u.blkcipher > @@ -306,6 +317,7 @@ struct compress_alg { > #define cra_hash cra_u.hash > #define cra_ahash cra_u.ahash > #define cra_compress cra_u.compress > +#define cra_rng cra_u.rng > > struct crypto_alg { > struct list_head cra_list; > @@ -333,6 +345,7 @@ struct crypto_alg { > struct hash_alg hash; > struct ahash_alg ahash; > struct compress_alg compress; > + struct rng_alg rng; > } cra_u; > > int (*cra_init)(struct crypto_tfm *tfm); > @@ -438,6 +451,12 @@ struct compress_tfm { > u8 *dst, unsigned int *dlen); > }; > > +struct rng_tfm { > + int (*rng_gen_random)(struct crypto_rng *tfm, u8 *rdata, > + unsigned int dlen); > + int (*rng_reset)(struct crypto_rng *tfm, u8 *seed, unsigned int slen); > +}; > + > #define crt_ablkcipher crt_u.ablkcipher > #define crt_aead crt_u.aead > #define crt_blkcipher crt_u.blkcipher > @@ -445,6 +464,7 @@ struct compress_tfm { > #define crt_hash crt_u.hash > #define crt_ahash crt_u.ahash > #define crt_compress crt_u.compress > +#define crt_rng crt_u.rng > > struct crypto_tfm { > > @@ -458,6 +478,7 @@ struct crypto_tfm { > struct hash_tfm hash; > struct ahash_tfm ahash; > struct compress_tfm compress; > + struct rng_tfm rng; > } crt_u; > > struct crypto_alg *__crt_alg; > @@ -489,6 +510,10 @@ struct crypto_hash { > struct crypto_tfm base; > }; > > +struct crypto_rng { > + struct crypto_tfm base; > +}; > + > enum { > CRYPTOA_UNSPEC, > CRYPTOA_ALG, -- /*************************************************** *Neil Horman [EMAIL PROTECTED] *gpg keyid: 1024D / 0x92A74FA1 *http://pgp.mit.edu ***************************************************/ -- To unsubscribe from this list: send the line "unsubscribe linux-crypto" in the body of a message to [EMAIL PROTECTED] More majordomo info at http://vger.kernel.org/majordomo-info.html
