mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-12 10:55:08 +00:00
crypto: jitterentropy - avoid compiler warnings
The core of the Jitter RNG is intended to be compiled with -O0. To ensure that the Jitter RNG can be compiled on all architectures, separate out the RNG core into a stand-alone C file that can be compiled with -O0 which does not depend on any kernel include file. As no kernel includes can be used in the C file implementing the core RNG, any dependencies on kernel code must be extracted. A second file provides the link to the kernel and the kernel crypto API that can be compiled with the regular compile options of the kernel. Signed-off-by: Stephan Mueller <smueller@chronox.de> Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Stephan Mueller
Herbert Xu
parent
aefbef10e3
commit
dfc9fa9193
@ -106,7 +106,9 @@ obj-$(CONFIG_CRYPTO_842) += 842.o
|
||||
obj-$(CONFIG_CRYPTO_RNG2) += rng.o
|
||||
obj-$(CONFIG_CRYPTO_ANSI_CPRNG) += ansi_cprng.o
|
||||
obj-$(CONFIG_CRYPTO_DRBG) += drbg.o
|
||||
obj-$(CONFIG_CRYPTO_JITTERENTROPY) += jitterentropy.o
|
||||
obj-$(CONFIG_CRYPTO_JITTERENTROPY) += jitterentropy_rng.o
|
||||
CFLAGS_jitterentropy.o = -O0
|
||||
jitterentropy_rng-y := jitterentropy.o jitterentropy-kcapi.o
|
||||
obj-$(CONFIG_CRYPTO_TEST) += tcrypt.o
|
||||
obj-$(CONFIG_CRYPTO_GHASH) += ghash-generic.o
|
||||
obj-$(CONFIG_CRYPTO_USER_API) += af_alg.o
|
||||
|
||||
208
crypto/jitterentropy-kcapi.c
Normal file
208
crypto/jitterentropy-kcapi.c
Normal file
@ -0,0 +1,208 @@
|
||||
/*
|
||||
* Non-physical true random number generator based on timing jitter --
|
||||
* Linux Kernel Crypto API specific code
|
||||
*
|
||||
* Copyright Stephan Mueller <smueller@chronox.de>, 2015
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, and the entire permission notice in its entirety,
|
||||
* including the disclaimer of warranties.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. The name of the author may not be used to endorse or promote
|
||||
* products derived from this software without specific prior
|
||||
* written permission.
|
||||
*
|
||||
* ALTERNATIVELY, this product may be distributed under the terms of
|
||||
* the GNU General Public License, in which case the provisions of the GPL2 are
|
||||
* required INSTEAD OF the above restrictions. (This clause is
|
||||
* necessary due to a potential bad interaction between the GPL and
|
||||
* the restrictions contained in a BSD-style copyright.)
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
|
||||
* WHICH ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
|
||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
||||
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
|
||||
* USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
|
||||
* DAMAGE.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/fips.h>
|
||||
#include <linux/time.h>
|
||||
#include <linux/crypto.h>
|
||||
#include <crypto/internal/rng.h>
|
||||
|
||||
struct rand_data;
|
||||
int jent_read_entropy(struct rand_data *ec, unsigned char *data,
|
||||
unsigned int len);
|
||||
int jent_entropy_init(void);
|
||||
struct rand_data *jent_entropy_collector_alloc(unsigned int osr,
|
||||
unsigned int flags);
|
||||
void jent_entropy_collector_free(struct rand_data *entropy_collector);
|
||||
|
||||
/***************************************************************************
|
||||
* Helper function
|
||||
***************************************************************************/
|
||||
|
||||
__u64 jent_rol64(__u64 word, unsigned int shift)
|
||||
{
|
||||
return rol64(word, shift);
|
||||
}
|
||||
|
||||
void *jent_zalloc(unsigned int len)
|
||||
{
|
||||
return kzalloc(len, GFP_KERNEL);
|
||||
}
|
||||
|
||||
void jent_zfree(void *ptr)
|
||||
{
|
||||
kzfree(ptr);
|
||||
}
|
||||
|
||||
int jent_fips_enabled(void)
|
||||
{
|
||||
return fips_enabled;
|
||||
}
|
||||
|
||||
void jent_panic(char *s)
|
||||
{
|
||||
panic(s);
|
||||
}
|
||||
|
||||
void jent_memcpy(void *dest, const void *src, unsigned int n)
|
||||
{
|
||||
memcpy(dest, src, n);
|
||||
}
|
||||
|
||||
void jent_get_nstime(__u64 *out)
|
||||
{
|
||||
struct timespec ts;
|
||||
__u64 tmp = 0;
|
||||
|
||||
tmp = random_get_entropy();
|
||||
|
||||
/*
|
||||
* If random_get_entropy does not return a value (which is possible on,
|
||||
* for example, MIPS), invoke __getnstimeofday
|
||||
* hoping that there are timers we can work with.
|
||||
*
|
||||
* The list of available timers can be obtained from
|
||||
* /sys/devices/system/clocksource/clocksource0/available_clocksource
|
||||
* and are registered with clocksource_register()
|
||||
*/
|
||||
if ((0 == tmp) &&
|
||||
(0 == __getnstimeofday(&ts))) {
|
||||
tmp = ts.tv_sec;
|
||||
tmp = tmp << 32;
|
||||
tmp = tmp | ts.tv_nsec;
|
||||
}
|
||||
|
||||
*out = tmp;
|
||||
}
|
||||
|
||||
/***************************************************************************
|
||||
* Kernel crypto API interface
|
||||
***************************************************************************/
|
||||
|
||||
struct jitterentropy {
|
||||
spinlock_t jent_lock;
|
||||
struct rand_data *entropy_collector;
|
||||
};
|
||||
|
||||
static int jent_kcapi_init(struct crypto_tfm *tfm)
|
||||
{
|
||||
struct jitterentropy *rng = crypto_tfm_ctx(tfm);
|
||||
int ret = 0;
|
||||
|
||||
rng->entropy_collector = jent_entropy_collector_alloc(1, 0);
|
||||
if (!rng->entropy_collector)
|
||||
ret = -ENOMEM;
|
||||
|
||||
spin_lock_init(&rng->jent_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void jent_kcapi_cleanup(struct crypto_tfm *tfm)
|
||||
{
|
||||
struct jitterentropy *rng = crypto_tfm_ctx(tfm);
|
||||
|
||||
spin_lock(&rng->jent_lock);
|
||||
if (rng->entropy_collector)
|
||||
jent_entropy_collector_free(rng->entropy_collector);
|
||||
rng->entropy_collector = NULL;
|
||||
spin_unlock(&rng->jent_lock);
|
||||
}
|
||||
|
||||
static int jent_kcapi_random(struct crypto_rng *tfm,
|
||||
const u8 *src, unsigned int slen,
|
||||
u8 *rdata, unsigned int dlen)
|
||||
{
|
||||
struct jitterentropy *rng = crypto_rng_ctx(tfm);
|
||||
int ret = 0;
|
||||
|
||||
spin_lock(&rng->jent_lock);
|
||||
ret = jent_read_entropy(rng->entropy_collector, rdata, dlen);
|
||||
spin_unlock(&rng->jent_lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int jent_kcapi_reset(struct crypto_rng *tfm,
|
||||
const u8 *seed, unsigned int slen)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct rng_alg jent_alg = {
|
||||
.generate = jent_kcapi_random,
|
||||
.seed = jent_kcapi_reset,
|
||||
.seedsize = 0,
|
||||
.base = {
|
||||
.cra_name = "jitterentropy_rng",
|
||||
.cra_driver_name = "jitterentropy_rng",
|
||||
.cra_priority = 100,
|
||||
.cra_ctxsize = sizeof(struct jitterentropy),
|
||||
.cra_module = THIS_MODULE,
|
||||
.cra_init = jent_kcapi_init,
|
||||
.cra_exit = jent_kcapi_cleanup,
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
static int __init jent_mod_init(void)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
ret = jent_entropy_init();
|
||||
if (ret) {
|
||||
pr_info("jitterentropy: Initialization failed with host not compliant with requirements: %d\n", ret);
|
||||
return -EFAULT;
|
||||
}
|
||||
return crypto_register_rng(&jent_alg);
|
||||
}
|
||||
|
||||
static void __exit jent_mod_exit(void)
|
||||
{
|
||||
crypto_unregister_rng(&jent_alg);
|
||||
}
|
||||
|
||||
module_init(jent_mod_init);
|
||||
module_exit(jent_mod_exit);
|
||||
|
||||
MODULE_LICENSE("Dual BSD/GPL");
|
||||
MODULE_AUTHOR("Stephan Mueller <smueller@chronox.de>");
|
||||
MODULE_DESCRIPTION("Non-physical True Random Number Generator based on CPU Jitter");
|
||||
MODULE_ALIAS_CRYPTO("jitterentropy_rng");
|
||||
@ -1,7 +1,8 @@
|
||||
/*
|
||||
* Non-physical true random number generator based on timing jitter.
|
||||
* Non-physical true random number generator based on timing jitter --
|
||||
* Jitter RNG standalone code.
|
||||
*
|
||||
* Copyright Stephan Mueller <smueller@chronox.de>, 2014
|
||||
* Copyright Stephan Mueller <smueller@chronox.de>, 2015
|
||||
*
|
||||
* Design
|
||||
* ======
|
||||
@ -49,13 +50,14 @@
|
||||
* version 1.1.0 provided at http://www.chronox.de/jent.html
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/fips.h>
|
||||
#include <linux/time.h>
|
||||
#include <linux/crypto.h>
|
||||
#include <crypto/internal/rng.h>
|
||||
#ifdef __OPTIMIZE__
|
||||
#error "The CPU Jitter random number generator must not be compiled with optimizations. See documentation. Use the compiler switch -O0 for compiling jitterentropy.c."
|
||||
#endif
|
||||
|
||||
typedef unsigned long long __u64;
|
||||
typedef long long __s64;
|
||||
typedef unsigned int __u32;
|
||||
#define NULL ((void *) 0)
|
||||
|
||||
/* The entropy pool */
|
||||
struct rand_data {
|
||||
@ -93,8 +95,6 @@ struct rand_data {
|
||||
* entropy, saves MEMORY_SIZE RAM for
|
||||
* entropy collector */
|
||||
|
||||
#define DRIVER_NAME "jitterentropy"
|
||||
|
||||
/* -- error codes for init function -- */
|
||||
#define JENT_ENOTIME 1 /* Timer service not available */
|
||||
#define JENT_ECOARSETIME 2 /* Timer too coarse for RNG */
|
||||
@ -110,32 +110,13 @@ struct rand_data {
|
||||
* Helper functions
|
||||
***************************************************************************/
|
||||
|
||||
static inline void jent_get_nstime(__u64 *out)
|
||||
{
|
||||
struct timespec ts;
|
||||
__u64 tmp = 0;
|
||||
|
||||
tmp = random_get_entropy();
|
||||
|
||||
/*
|
||||
* If random_get_entropy does not return a value (which is possible on,
|
||||
* for example, MIPS), invoke __getnstimeofday
|
||||
* hoping that there are timers we can work with.
|
||||
*
|
||||
* The list of available timers can be obtained from
|
||||
* /sys/devices/system/clocksource/clocksource0/available_clocksource
|
||||
* and are registered with clocksource_register()
|
||||
*/
|
||||
if ((0 == tmp) &&
|
||||
(0 == __getnstimeofday(&ts))) {
|
||||
tmp = ts.tv_sec;
|
||||
tmp = tmp << 32;
|
||||
tmp = tmp | ts.tv_nsec;
|
||||
}
|
||||
|
||||
*out = tmp;
|
||||
}
|
||||
|
||||
void jent_get_nstime(__u64 *out);
|
||||
__u64 jent_rol64(__u64 word, unsigned int shift);
|
||||
void *jent_zalloc(unsigned int len);
|
||||
void jent_zfree(void *ptr);
|
||||
int jent_fips_enabled(void);
|
||||
void jent_panic(char *s);
|
||||
void jent_memcpy(void *dest, const void *src, unsigned int n);
|
||||
|
||||
/**
|
||||
* Update of the loop count used for the next round of
|
||||
@ -184,20 +165,6 @@ static __u64 jent_loop_shuffle(struct rand_data *ec,
|
||||
* Noise sources
|
||||
***************************************************************************/
|
||||
|
||||
/*
|
||||
* The disabling of the optimizations is performed as documented and assessed
|
||||
* thoroughly in http://www.chronox.de/jent.html. However, instead of disabling
|
||||
* the optimization of the entire C file, only the main functions the jitter is
|
||||
* measured for are not optimized. These functions include the noise sources as
|
||||
* well as the main functions triggering the noise sources. As the time
|
||||
* measurement is done from one invocation of the jitter noise source to the
|
||||
* next, even the execution jitter of the code invoking the noise sources
|
||||
* contribute to the overall randomness as well. The behavior of the RNG and the
|
||||
* statistical characteristics when only the mentioned functions are not
|
||||
* optimized is almost equal to the a completely non-optimized RNG compilation
|
||||
* as tested with the test tools provided at the initially mentioned web site.
|
||||
*/
|
||||
|
||||
/**
|
||||
* CPU Jitter noise source -- this is the noise source based on the CPU
|
||||
* execution time jitter
|
||||
@ -232,8 +199,6 @@ static __u64 jent_loop_shuffle(struct rand_data *ec,
|
||||
*
|
||||
* @return Number of loops the folding operation is performed
|
||||
*/
|
||||
#pragma GCC push_options
|
||||
#pragma GCC optimize ("-O0")
|
||||
static __u64 jent_fold_time(struct rand_data *ec, __u64 time,
|
||||
__u64 *folded, __u64 loop_cnt)
|
||||
{
|
||||
@ -263,7 +228,6 @@ static __u64 jent_fold_time(struct rand_data *ec, __u64 time,
|
||||
*folded = new;
|
||||
return fold_loop_cnt;
|
||||
}
|
||||
#pragma GCC pop_options
|
||||
|
||||
/**
|
||||
* Memory Access noise source -- this is a noise source based on variations in
|
||||
@ -292,8 +256,6 @@ static __u64 jent_fold_time(struct rand_data *ec, __u64 time,
|
||||
*
|
||||
* @return Number of memory access operations
|
||||
*/
|
||||
#pragma GCC push_options
|
||||
#pragma GCC optimize ("-O0")
|
||||
static unsigned int jent_memaccess(struct rand_data *ec, __u64 loop_cnt)
|
||||
{
|
||||
unsigned char *tmpval = NULL;
|
||||
@ -333,7 +295,6 @@ static unsigned int jent_memaccess(struct rand_data *ec, __u64 loop_cnt)
|
||||
}
|
||||
return i;
|
||||
}
|
||||
#pragma GCC pop_options
|
||||
|
||||
/***************************************************************************
|
||||
* Start of entropy processing logic
|
||||
@ -382,8 +343,6 @@ static void jent_stuck(struct rand_data *ec, __u64 current_delta)
|
||||
*
|
||||
* @return One random bit
|
||||
*/
|
||||
#pragma GCC push_options
|
||||
#pragma GCC optimize ("-O0")
|
||||
static __u64 jent_measure_jitter(struct rand_data *ec)
|
||||
{
|
||||
__u64 time = 0;
|
||||
@ -413,7 +372,6 @@ static __u64 jent_measure_jitter(struct rand_data *ec)
|
||||
|
||||
return data;
|
||||
}
|
||||
#pragma GCC pop_options
|
||||
|
||||
/**
|
||||
* Von Neuman unbias as explained in RFC 4086 section 4.2. As shown in the
|
||||
@ -502,7 +460,7 @@ static void jent_stir_pool(struct rand_data *entropy_collector)
|
||||
*/
|
||||
if ((entropy_collector->data >> i) & 1)
|
||||
mixer.u64 ^= constant.u64;
|
||||
mixer.u64 = rol64(mixer.u64, 1);
|
||||
mixer.u64 = jent_rol64(mixer.u64, 1);
|
||||
}
|
||||
entropy_collector->data ^= mixer.u64;
|
||||
}
|
||||
@ -514,8 +472,6 @@ static void jent_stir_pool(struct rand_data *entropy_collector)
|
||||
* Input:
|
||||
* @ec Reference to entropy collector
|
||||
*/
|
||||
#pragma GCC push_options
|
||||
#pragma GCC optimize ("-O0")
|
||||
static void jent_gen_entropy(struct rand_data *ec)
|
||||
{
|
||||
unsigned int k = 0;
|
||||
@ -565,7 +521,7 @@ static void jent_gen_entropy(struct rand_data *ec)
|
||||
ec->data ^= ((ec->data >> 30) & 1);
|
||||
ec->data ^= ((ec->data >> 27) & 1);
|
||||
ec->data ^= ((ec->data >> 22) & 1);
|
||||
ec->data = rol64(ec->data, 1);
|
||||
ec->data = jent_rol64(ec->data, 1);
|
||||
|
||||
/*
|
||||
* We multiply the loop value with ->osr to obtain the
|
||||
@ -577,7 +533,6 @@ static void jent_gen_entropy(struct rand_data *ec)
|
||||
if (ec->stir)
|
||||
jent_stir_pool(ec);
|
||||
}
|
||||
#pragma GCC pop_options
|
||||
|
||||
/**
|
||||
* The continuous test required by FIPS 140-2 -- the function automatically
|
||||
@ -589,7 +544,7 @@ static void jent_gen_entropy(struct rand_data *ec)
|
||||
*/
|
||||
static void jent_fips_test(struct rand_data *ec)
|
||||
{
|
||||
if (!fips_enabled)
|
||||
if (!jent_fips_enabled())
|
||||
return;
|
||||
|
||||
/* prime the FIPS test */
|
||||
@ -599,12 +554,11 @@ static void jent_fips_test(struct rand_data *ec)
|
||||
}
|
||||
|
||||
if (ec->data == ec->old_data)
|
||||
panic(DRIVER_NAME ": Duplicate output detected\n");
|
||||
jent_panic("jitterentropy: Duplicate output detected\n");
|
||||
|
||||
ec->old_data = ec->data;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Entry function: Obtain entropy for the caller.
|
||||
*
|
||||
@ -627,15 +581,16 @@ static void jent_fips_test(struct rand_data *ec)
|
||||
* The following error codes can occur:
|
||||
* -1 entropy_collector is NULL
|
||||
*/
|
||||
static ssize_t jent_read_entropy(struct rand_data *ec, u8 *data, size_t len)
|
||||
int jent_read_entropy(struct rand_data *ec, unsigned char *data,
|
||||
unsigned int len)
|
||||
{
|
||||
u8 *p = data;
|
||||
unsigned char *p = data;
|
||||
|
||||
if (!ec)
|
||||
return -EINVAL;
|
||||
return -1;
|
||||
|
||||
while (0 < len) {
|
||||
size_t tocopy;
|
||||
unsigned int tocopy;
|
||||
|
||||
jent_gen_entropy(ec);
|
||||
jent_fips_test(ec);
|
||||
@ -643,7 +598,7 @@ static ssize_t jent_read_entropy(struct rand_data *ec, u8 *data, size_t len)
|
||||
tocopy = (DATA_SIZE_BITS / 8);
|
||||
else
|
||||
tocopy = len;
|
||||
memcpy(p, &ec->data, tocopy);
|
||||
jent_memcpy(p, &ec->data, tocopy);
|
||||
|
||||
len -= tocopy;
|
||||
p += tocopy;
|
||||
@ -656,12 +611,12 @@ static ssize_t jent_read_entropy(struct rand_data *ec, u8 *data, size_t len)
|
||||
* Initialization logic
|
||||
***************************************************************************/
|
||||
|
||||
static struct rand_data *jent_entropy_collector_alloc(unsigned int osr,
|
||||
unsigned int flags)
|
||||
struct rand_data *jent_entropy_collector_alloc(unsigned int osr,
|
||||
unsigned int flags)
|
||||
{
|
||||
struct rand_data *entropy_collector;
|
||||
|
||||
entropy_collector = kzalloc(sizeof(struct rand_data), GFP_KERNEL);
|
||||
entropy_collector = jent_zalloc(sizeof(struct rand_data));
|
||||
if (!entropy_collector)
|
||||
return NULL;
|
||||
|
||||
@ -669,9 +624,9 @@ static struct rand_data *jent_entropy_collector_alloc(unsigned int osr,
|
||||
/* Allocate memory for adding variations based on memory
|
||||
* access
|
||||
*/
|
||||
entropy_collector->mem = kzalloc(JENT_MEMORY_SIZE, GFP_KERNEL);
|
||||
entropy_collector->mem = jent_zalloc(JENT_MEMORY_SIZE);
|
||||
if (!entropy_collector->mem) {
|
||||
kfree(entropy_collector);
|
||||
jent_zfree(entropy_collector);
|
||||
return NULL;
|
||||
}
|
||||
entropy_collector->memblocksize = JENT_MEMORY_BLOCKSIZE;
|
||||
@ -696,17 +651,17 @@ static struct rand_data *jent_entropy_collector_alloc(unsigned int osr,
|
||||
return entropy_collector;
|
||||
}
|
||||
|
||||
static void jent_entropy_collector_free(struct rand_data *entropy_collector)
|
||||
void jent_entropy_collector_free(struct rand_data *entropy_collector)
|
||||
{
|
||||
if (entropy_collector->mem)
|
||||
kzfree(entropy_collector->mem);
|
||||
jent_zfree(entropy_collector->mem);
|
||||
entropy_collector->mem = NULL;
|
||||
if (entropy_collector)
|
||||
kzfree(entropy_collector);
|
||||
jent_zfree(entropy_collector);
|
||||
entropy_collector = NULL;
|
||||
}
|
||||
|
||||
static int jent_entropy_init(void)
|
||||
int jent_entropy_init(void)
|
||||
{
|
||||
int i;
|
||||
__u64 delta_sum = 0;
|
||||
@ -832,97 +787,3 @@ static int jent_entropy_init(void)
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/***************************************************************************
|
||||
* Kernel crypto API interface
|
||||
***************************************************************************/
|
||||
|
||||
struct jitterentropy {
|
||||
spinlock_t jent_lock;
|
||||
struct rand_data *entropy_collector;
|
||||
};
|
||||
|
||||
static int jent_kcapi_init(struct crypto_tfm *tfm)
|
||||
{
|
||||
struct jitterentropy *rng = crypto_tfm_ctx(tfm);
|
||||
int ret = 0;
|
||||
|
||||
rng->entropy_collector = jent_entropy_collector_alloc(1, 0);
|
||||
if (!rng->entropy_collector)
|
||||
ret = -ENOMEM;
|
||||
|
||||
spin_lock_init(&rng->jent_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void jent_kcapi_cleanup(struct crypto_tfm *tfm)
|
||||
{
|
||||
struct jitterentropy *rng = crypto_tfm_ctx(tfm);
|
||||
|
||||
spin_lock(&rng->jent_lock);
|
||||
if (rng->entropy_collector)
|
||||
jent_entropy_collector_free(rng->entropy_collector);
|
||||
rng->entropy_collector = NULL;
|
||||
spin_unlock(&rng->jent_lock);
|
||||
}
|
||||
|
||||
static int jent_kcapi_random(struct crypto_rng *tfm,
|
||||
const u8 *src, unsigned int slen,
|
||||
u8 *rdata, unsigned int dlen)
|
||||
{
|
||||
struct jitterentropy *rng = crypto_rng_ctx(tfm);
|
||||
int ret = 0;
|
||||
|
||||
spin_lock(&rng->jent_lock);
|
||||
ret = jent_read_entropy(rng->entropy_collector, rdata, dlen);
|
||||
spin_unlock(&rng->jent_lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int jent_kcapi_reset(struct crypto_rng *tfm,
|
||||
const u8 *seed, unsigned int slen)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct rng_alg jent_alg = {
|
||||
.generate = jent_kcapi_random,
|
||||
.seed = jent_kcapi_reset,
|
||||
.seedsize = 0,
|
||||
.base = {
|
||||
.cra_name = "jitterentropy_rng",
|
||||
.cra_driver_name = "jitterentropy_rng",
|
||||
.cra_priority = 100,
|
||||
.cra_ctxsize = sizeof(struct jitterentropy),
|
||||
.cra_module = THIS_MODULE,
|
||||
.cra_init = jent_kcapi_init,
|
||||
.cra_exit = jent_kcapi_cleanup,
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
static int __init jent_mod_init(void)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
ret = jent_entropy_init();
|
||||
if (ret) {
|
||||
pr_info(DRIVER_NAME ": Initialization failed with host not compliant with requirements: %d\n", ret);
|
||||
return -EFAULT;
|
||||
}
|
||||
return crypto_register_rng(&jent_alg);
|
||||
}
|
||||
|
||||
static void __exit jent_mod_exit(void)
|
||||
{
|
||||
crypto_unregister_rng(&jent_alg);
|
||||
}
|
||||
|
||||
module_init(jent_mod_init);
|
||||
module_exit(jent_mod_exit);
|
||||
|
||||
MODULE_LICENSE("Dual BSD/GPL");
|
||||
MODULE_AUTHOR("Stephan Mueller <smueller@chronox.de>");
|
||||
MODULE_DESCRIPTION("Non-physical True Random Number Generator based on CPU Jitter");
|
||||
MODULE_ALIAS_CRYPTO("jitterentropy_rng");
|
||||
|
||||
Loading…
Reference in New Issue
Block a user