gnu.crypto.prng
Class FortunaStandalone

java.lang.Object
  extended by gnu.crypto.prng.BasePRNGStandalone
      extended by gnu.crypto.prng.FortunaStandalone
All Implemented Interfaces:
IRandomStandalone, RandomEventListenerStandalone, java.io.Serializable, java.lang.Cloneable, java.util.EventListener
Direct Known Subclasses:
AsyncFortunaStandalone

public class FortunaStandalone
extends BasePRNGStandalone
implements java.io.Serializable, RandomEventListenerStandalone

The Fortuna continuously-seeded pseudo-random number generator. This generator is composed of two major pieces: the entropy accumulator and the generator function. The former takes in random bits and incorporates them into the generator's state. The latter takes this base entropy and generates pseudo-random bits from it.

There are some things users of this class must be aware of:

Adding Random Data
This class does not do any polling of random sources, but rather provides an interface for adding random events. Applications that use this code must provide this mechanism. We use this design because an application writer who knows the system he is targeting is in a better position to judge what random data is available.
Storing the Seed
This class implements Serializable in such a way that it writes a 64 byte seed to the stream, and reads it back again when being deserialized. This is the extent of seed file management, however, and those using this class are encouraged to think deeply about when, how often, and where to store the seed.

References:

Modified by jrandom for I2P to use a standalone gnu-crypto SHA256, Cryptix's AES, to strip out some unnecessary dependencies and increase the buffer size. Renamed from Fortuna to FortunaStandalone so it doesn't conflict with the gnu-crypto implementation, which has been imported into GNU/classpath

See Also:
Serialized Form

Nested Class Summary
static class FortunaStandalone.Generator
          The Fortuna generator function.
 
Field Summary
(package private)  FortunaStandalone.Generator generator
           
(package private) static long lastRefill
           
(package private)  long lastReseed
           
(package private) static int MIN_POOL_SIZE
           
(package private) static int NUM_POOLS
           
(package private)  int pool
           
(package private)  int pool0Count
           
(package private)  Sha256Standalone[] pools
           
(package private) static long refillCount
           
(package private)  int reseedCount
           
static java.lang.String SEED
           
 
Fields inherited from class gnu.crypto.prng.BasePRNGStandalone
buffer, initialised, name, ndx
 
Constructor Summary
FortunaStandalone()
           
 
Method Summary
 void addRandomByte(byte b)
          Supplement, or possibly replace, the random state of this PRNG with a random byte.
 void addRandomBytes(byte[] buf, int offset, int length)
          Supplement, or possibly replace, the random state of this PRNG with a sequence of new random bytes.
 void addRandomEvent(RandomEventStandalone event)
           
protected  void allocBuffer()
           
 void fillBlock()
           
static void main(java.lang.String[] args)
           
 void seed(byte[] val)
           
 void setup(java.util.Map attributes)
           
 
Methods inherited from class gnu.crypto.prng.BasePRNGStandalone
addRandomBytes, clone, init, isInitialised, name, nextByte, nextBytes, nextBytes
 
Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

NUM_POOLS

static final int NUM_POOLS
See Also:
Constant Field Values

MIN_POOL_SIZE

static final int MIN_POOL_SIZE
See Also:
Constant Field Values

generator

final FortunaStandalone.Generator generator

pools

final Sha256Standalone[] pools

lastReseed

long lastReseed

pool

int pool

pool0Count

int pool0Count

reseedCount

int reseedCount

refillCount

static long refillCount

lastRefill

static long lastRefill

SEED

public static final java.lang.String SEED
See Also:
Constant Field Values
Constructor Detail

FortunaStandalone

public FortunaStandalone()
Method Detail

allocBuffer

protected void allocBuffer()

seed

public void seed(byte[] val)

setup

public void setup(java.util.Map attributes)
Specified by:
setup in class BasePRNGStandalone

fillBlock

public void fillBlock()
Specified by:
fillBlock in class BasePRNGStandalone

addRandomByte

public void addRandomByte(byte b)
Description copied from interface: IRandomStandalone

Supplement, or possibly replace, the random state of this PRNG with a random byte.

Implementations are not required to implement this method in any meaningful way; this may be a no-operation, and implementations may throw an UnsupportedOperationException.

Specified by:
addRandomByte in interface IRandomStandalone
Overrides:
addRandomByte in class BasePRNGStandalone
Parameters:
b - The byte to add.

addRandomBytes

public void addRandomBytes(byte[] buf,
                           int offset,
                           int length)
Description copied from interface: IRandomStandalone

Supplement, or possibly replace, the random state of this PRNG with a sequence of new random bytes.

Implementations are not required to implement this method in any meaningful way; this may be a no-operation, and implementations may throw an UnsupportedOperationException.

Specified by:
addRandomBytes in interface IRandomStandalone
Overrides:
addRandomBytes in class BasePRNGStandalone
Parameters:
buf - The buffer of new random bytes to add.
offset - The offset from whence to begin reading random bytes.
length - The number of random bytes to add.

addRandomEvent

public void addRandomEvent(RandomEventStandalone event)
Specified by:
addRandomEvent in interface RandomEventListenerStandalone

main

public static void main(java.lang.String[] args)