net.i2p.util

## Class FortunaRandomSource

- java.lang.Object
- - java.util.Random
  - - java.security.SecureRandom
    - - net.i2p.util.RandomSource
      - - net.i2p.util.FortunaRandomSource

- All Implemented Interfaces:
    Serializable, EntropyHarvester

      public class FortunaRandomSource
      extends RandomSource
      implements EntropyHarvester

  Wrapper around GNU-Crypto's Fortuna PRNG. This seeds from /dev/urandom and ./prngseed.rnd on startup (if they exist), writing a new seed to ./prngseed.rnd on an explicit call to saveSeed().
  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from class net.i2p.util.RandomSource

      `_context`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `FortunaRandomSource(I2PAppContext context)` May block up to 10 seconds or forever

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `feedEntropy(String source, byte[] data, int offset, int len)` reseed the fortuna
    `void` | `feedEntropy(String source, long data, int bitoffset, int bits)` reseed the fortuna
    `static void` | `main(String[] args)` Outputs to stdout for dieharder: `java -cp build/i2p.jar net.i2p.util.FortunaRandomSource | dieharder -a -g 200`
    `protected int` | `nextBits(int numBits)` Pull the next numBits of random data off the fortuna instance (returning 0 through 2^numBits-1 Caller must synchronize!
    `boolean` | `nextBoolean()`
    `byte` | `nextByte()` Not part of java.util.SecureRandom, but added for efficiency, since Fortuna supports it.
    `void` | `nextBytes(byte[] buf)`
    `void` | `nextBytes(byte[] buf, int offset, int length)` Not part of java.util.SecureRandom, but added for efficiency, since Fortuna supports it.
    `double` | `nextDouble()` Implementation from sun's java.util.Random javadocs
    `float` | `nextFloat()` Implementation from sun's java.util.Random javadocs
    `double` | `nextGaussian()` Implementation from sun's java.util.Random javadocs
    `int` | `nextInt()`
    `int` | `nextInt(int n)` According to the java docs (http://java.sun.com/j2se/1.4.1/docs/api/java/util/Random.html#nextInt(int)) nextInt(n) should return a number between 0 and n (including 0 and excluding n).
    `long` | `nextLong()`
    `long` | `nextLong(long n)` Like the modified nextInt, nextLong(n) returns a random number from 0 through n, including 0, excluding n.
    `void` | `setSeed(byte[] buf)`
    `void` | `shutdown()` Note - methods may hang or NPE or throw IllegalStateExceptions after this
    `int` | `signedNextInt()` This code unused, see FortunaRandomSource override

    - ### Methods inherited from class net.i2p.util.RandomSource

      `getInstance, harvester, initSeed, loadSeed, saveSeed, writeSeed`

    - ### Methods inherited from class java.security.SecureRandom

      `generateSeed, getAlgorithm, getInstance, getInstance, getInstance, getInstanceStrong, getProvider, getSeed, next, setSeed`

    - ### Methods inherited from class java.util.Random

      `doubles, doubles, doubles, doubles, ints, ints, ints, ints, longs, longs, longs, longs`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### FortunaRandomSource

          public FortunaRandomSource(I2PAppContext context)

      May block up to 10 seconds or forever

  - ### Method Detail

    - #### feedEntropy

          public void feedEntropy(String source,
                                  byte[] data,
                                  int offset,
                                  int len)

      reseed the fortuna
      Specified by:
        `feedEntropy` in interface `EntropyHarvester`
      Overrides:
        `feedEntropy` in class `RandomSource`
      Parameters:
        `source` - origin of the entropy, allowing the harvester to determine how much to value the data
        `offset` - index into the data array to start
        `len` - how many bytes to use

    - #### feedEntropy

          public void feedEntropy(String source,
                                  long data,
                                  int bitoffset,
                                  int bits)

      reseed the fortuna
      Specified by:
        `feedEntropy` in interface `EntropyHarvester`
      Overrides:
        `feedEntropy` in class `RandomSource`
      Parameters:
        `source` - origin of the entropy, allowing the harvester to determine how much to value the data
        `bitoffset` - bit index into the data array to start (using java standard big-endian)
        `bits` - how many bits to use

    - #### main

          public static void main(String[] args)

      Outputs to stdout for dieharder: `java -cp build/i2p.jar net.i2p.util.FortunaRandomSource | dieharder -a -g 200`

    - #### nextBits

          protected int nextBits(int numBits)

      Pull the next numBits of random data off the fortuna instance (returning 0 through 2^numBits-1 Caller must synchronize!

    - #### nextBoolean

          public boolean nextBoolean()

      Overrides:
        `nextBoolean` in class `Random`

    - #### nextByte

          public byte nextByte()

      Not part of java.util.SecureRandom, but added for efficiency, since Fortuna supports it.

    - #### nextBytes

          public void nextBytes(byte[] buf)

      Overrides:
        `nextBytes` in class `SecureRandom`

    - #### nextBytes

          public void nextBytes(byte[] buf,
                                int offset,
                                int length)

      Not part of java.util.SecureRandom, but added for efficiency, since Fortuna supports it.
      Overrides:
        `nextBytes` in class `RandomSource`

    - #### nextDouble

          public double nextDouble()

      Implementation from sun's java.util.Random javadocs
      Overrides:
        `nextDouble` in class `Random`

    - #### nextFloat

          public float nextFloat()

      Implementation from sun's java.util.Random javadocs
      Overrides:
        `nextFloat` in class `Random`

    - #### nextGaussian

          public double nextGaussian()

      Implementation from sun's java.util.Random javadocs
      Overrides:
        `nextGaussian` in class `Random`

    - #### nextInt

          public int nextInt()

      Overrides:
        `nextInt` in class `Random`

    - #### nextInt

          public int nextInt(int n)

      According to the java docs (http://java.sun.com/j2se/1.4.1/docs/api/java/util/Random.html#nextInt(int)) nextInt(n) should return a number between 0 and n (including 0 and excluding n). However, their pseudocode, as well as sun's, kaffe's, and classpath's implementation INCLUDES NEGATIVE VALUES. Ok, so we're going to have it return between 0 and n (including 0, excluding n), since thats what it has been used for. Unlike Java's Random, which throws IAE, this returns 0 if n is 0.
      Overrides:
        `nextInt` in class `RandomSource`
      Parameters:
        `n` - non-negative
      Throws:
        `IllegalArgumentException` - if n is negative

    - #### nextLong

          public long nextLong()

      Overrides:
        `nextLong` in class `Random`
      Returns:
        all possible long values, positive and negative

    - #### nextLong

          public long nextLong(long n)

      Like the modified nextInt, nextLong(n) returns a random number from 0 through n, including 0, excluding n. Unlike Java's Random, which throws IAE, this returns 0 if n is 0.
      Overrides:
        `nextLong` in class `RandomSource`
      Parameters:
        `n` - non-negative
      Throws:
        `IllegalArgumentException` - if n is negative

    - #### setSeed

          public void setSeed(byte[] buf)

      Overrides:
        `setSeed` in class `SecureRandom`

    - #### shutdown

          public void shutdown()

      Note - methods may hang or NPE or throw IllegalStateExceptions after this

    - #### signedNextInt

          public int signedNextInt()

      Description copied from class: `RandomSource`
      This code unused, see FortunaRandomSource override
      Overrides:
        `signedNextInt` in class `RandomSource`
      Returns:
        all possible int values, positive and negative