Hardware RNG based on CPU timing jitter.

The implementation works for both kernel and user space. Of course, there are
some small differences which are encapsulated into different files.

The design of the RNG is given in the documentation found in doc/. The text
below references the section in the design spec where the functionality
implemented in the respective file is documented

API
---

jitterentropy.h -- The API functions that are intended to be used by normal callers


Common files
------------
jitterentropy-base.c -- Jitter entropy collection -- file contains the heart
			of the CPU Jitter random number generator
			(design given in chapter 3)

jitterentropy-stat.c -- Implementation of the statistic validation of the data
			collected by the jitter entropy part (Note, that code
			is only needed for performing statistical tests
			when setting CRYPTO_CPU_JITTERENTROPY_STAT. Otherwise
			the entire code	is not compiled - the Makefile may
			even skip compiling this file when
			CRYPTO_CPU_JITTERENTROPY_STAT is not set).
			(functionality needed for graphs in chapter 4 and 5)


Kernel files
------------
jitterentropy-base-kernel.h -- Kernel helper functions needed for entropy
			       collection

jitterentropy-dbg-kernel.c -- DebugFS interface allow user space to interact
			      with entropy collector, defines 2 DRNGs
			      and interacts with the DRNG handler (note, that is
			      intended to support debugging only, file does not
			      need to be compiled, the switch is
			      CONFIG_JITTERENTROPY_DBG)
			      (design given in appendix B)
jitterentropy-dbg-kernel.h -- internal API for jitterentropy-dbg-kernel.c
			      exported to other C files

jitterentropy-drng-kernel.c -- implementation of the DRNG handling for the
			       entropy collector and this C file implements the
			       kernel module logic
			       (design given in appendix B)
jitterentropy-drng-kernel.h -- DRNG data structure and internal API exported
			       by the DRNG component

jitterentropy-kcapi-kernel.c -- Register regular and strong DRNG with kernel
				crypto API to provide a the CPU Jitter RNG
				whitenend by a DRNG as a non-physical true
				random number generator to the kernel. In
				addition, provide direct access to the CPU
				Jitter RNG.
				(design given in appendix B)
jitterentropy-kcapi-kernel.h -- export the init and exit functions

Makefile -- kernel make file


User space files
----------------
jitterentropy-base-user.h -- User space helper functions needed for entropy
			     collection

jitterentropy-main-user.c -- main() function used to test user space code. It is
			     intended as a debug support and does not need to be
			     compiled if the entropy collection code is compiled
			     into a shared library. However, it is a working
			     application showing how to use the CPU Jitter RNG.

jitterentropy-gcry-user.c -- wrapper layer for integrating the CPU Jitter random
			     number generator into the libgcrypt library.

jitterentropy-openssl-user.c -- wrapper layer for integrating the CPU Jitter
				random number generator into the OpenSSL
				library using the engine support.

Makefile.user -- user space make file to generate an executable binary from
jitterentropy-main-user.c.

Makefile.shared -- generation of a shared library for the CPU Jitter RNG

Makefile.openssleng -- generation of the OpenSSL Engine shared library


Test
----

The test directories contain shell files that drive the testing.
