gnu.crypto.prng

## Class FortunaStandalone

- java.lang.Object
- - gnu.crypto.prng.BasePRNGStandalone
  - - gnu.crypto.prng.FortunaStandalone

- All Implemented Interfaces:
    IRandomStandalone, RandomEventListenerStandalone, Serializable, Cloneable, EventListener
  Direct Known Subclasses:
    AsyncFortunaStandalone

      public class FortunaStandalone
      extends BasePRNGStandalone
      implements 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:

  - Niels Ferguson and Bruce Schneier, Practical Cryptography, pp. 155--184. Wiley Publishing, Indianapolis. (2003 Niels Ferguson and Bruce Schneier). ISBN 0-471-22357-3.
  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

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `FortunaStandalone.Generator` The Fortuna generator function.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `(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 String` | `SEED`

    - ### Fields inherited from class gnu.crypto.prng.BasePRNGStandalone

      `buffer, initialised, name, ndx`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `FortunaStandalone()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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()`
    `void` | `seed(byte[] val)`
    `void` | `setup(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 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(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`