p71924506
/
linux_old1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6 

Pull crypto fixes from Herbert Xu:
 "This fixes the following issues:

   - move -O0 jitterentropy code into its own file instead of using gcc
     pragma magic.

   - kill testmgr warning for gcm-aes-aesni.

   - fix build failure in old rsa.

  Other minor fixes:

   - ignore asn1 files generated by new rsa.

   - remove unnecessary kzfree NULL checks in jitterentropy.

   - typo fix in akcipher"

* git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6:
  crypto: rsa - add .gitignore for crypto/*.-asn1.[ch] files
  crypto: asymmetric_keys/rsa - Use non-conflicting variable name
  crypto: testmgr - don't print info about missing test for gcm-aes-aesni
  crypto: jitterentropy - Delete unnecessary checks before the function call "kzfree"
  crypto: akcipher - fix spelling cihper -> cipher
  crypto: jitterentropy - avoid compiler warnings
This commit is contained in:
Linus Torvalds 2015-06-26 12:27:48 -07:00
parent e8a0b37d28 44a17ef872
commit a2f54be94f
7 changed files with 256 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
crypto/.gitignore vendored Normal file
View File

@ -0,0 +1 @@
*-asn1.[ch]

4
crypto/Makefile
View File

@ -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

2
crypto/akcipher.c
View File

@ -114,4 +114,4 @@ void crypto_unregister_akcipher(struct akcipher_alg *alg)
EXPORT_SYMBOL_GPL(crypto_unregister_akcipher);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Generic public key cihper type");
MODULE_DESCRIPTION("Generic public key cipher type");

4
crypto/asymmetric_keys/rsa.c
View File

@ -120,7 +120,7 @@ static int RSAVP1(const struct public_key *key, MPI s, MPI *_m)
/*
* Integer to Octet String conversion [RFC3447 sec 4.1]
*/
static int RSA_I2OSP(MPI x, size_t xLen, u8 **_X)
static int RSA_I2OSP(MPI x, size_t xLen, u8 **pX)
{
unsigned X_size, x_size;
int X_sign;
@ -147,7 +147,7 @@ static int RSA_I2OSP(MPI x, size_t xLen, u8 **_X)
return -EBADMSG;
}
*_X = X;
*pX = X;
return 0;
}

208
crypto/jitterentropy-kcapi.c Normal file
View 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");

215
crypto/jitterentropy.c
View File

@ -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,15 @@ 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 +785,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");

4
crypto/testmgr.c
View File

@ -2055,6 +2055,10 @@ static const struct alg_test_desc alg_test_descs[] = {
}, {
.alg = "__driver-ecb-twofish-avx",
.test = alg_test_null,
}, {
.alg = "__driver-gcm-aes-aesni",
.test = alg_test_null,
.fips_allowed = 1,
}, {
.alg = "__ghash-pclmulqdqni",
.test = alg_test_null,