Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.crypto.prng;
  
  
  public class X931RNG
  {
      private static final long       BLOCK64_RESEED_MAX = 1L << (16 - 1);
      private static final long       BLOCK128_RESEED_MAX = 1L << (24 - 1);
      private static final int        BLOCK64_MAX_BITS_REQUEST = 1 << (13 - 1);
     private static final int        BLOCK128_MAX_BITS_REQUEST = 1 << (19 - 1);
     
     private final BlockCipher engine;
     private final EntropySource entropySource;
 
     private final byte[] DT;
     private final byte[] I;
     private final byte[] R;;
 
     private byte[] V;
 
     private long reseedCounter = 1;

    

Parameters:
engine
entropySource
 
     public X931RNG(BlockCipher enginebyte[] dateTimeVectorEntropySource entropySource)
     {
         this. = engine;
         this. = entropySource;
 
         this. = new byte[engine.getBlockSize()];
 
         System.arraycopy(dateTimeVector, 0, , 0, .);
 
         this. = new byte[engine.getBlockSize()];
         this. = new byte[engine.getBlockSize()];
     }

    
Populate a passed in array with random data.

Parameters:
output output array for generated bits.
predictionResistant true if a reseed should be forced, false otherwise.
Returns:
number of bits generated, -1 if a reseed required.
 
     int generate(byte[] outputboolean predictionResistant)
     {
         if (. == 8) // 64 bit block size
         {
             if ( > )
             {
                 return -1;
             }
 
             if (isTooLarge(output / 8))
             {
                 throw new IllegalArgumentException("Number of bits per request limited to " + );
             }
         }
         else
         {
             if ( > )
             {
                 return -1;
             }
 
             if (isTooLarge(output / 8))
             {
                 throw new IllegalArgumentException("Number of bits per request limited to " + );
             }
         }
         
         if (predictionResistant ||  == null)
         {
              = .getEntropy();
         }
 
         int m = output.length / .;
 
         for (int i = 0; i < mi++)
         {
             .processBlock(, 0, , 0);
             process();
             process();
 
             System.arraycopy(, 0, outputi * ..);
 
             increment();
         }
 
         int bytesToCopy = (output.length - m * .);
 
         if (bytesToCopy > 0)
         {
             .processBlock(, 0, , 0);
             process();
            process();
            System.arraycopy(, 0, outputm * .bytesToCopy);
            increment();
        }
        ++;
        return output.length;
    }

    
Reseed the RNG.
    void reseed()
    {
         = .getEntropy();
         = 1;
    }
    private void process(byte[] resbyte[] abyte[] b)
    {
        for (int i = 0; i != res.lengthi++)
        {
            res[i] = (byte)(a[i] ^ b[i]);
        }
        .processBlock(res, 0, res, 0);
    }
    private void increment(byte[] val)
    {
        for (int i = val.length - 1; i >= 0; i--)
        {
            if (++val[i] != 0)
            {
                break;
            }
        }
    }
    
    private static boolean isTooLarge(byte[] bytesint maxBytes)
    {
        return bytes != null && bytes.length > maxBytes;
    }
New to GrepCode? Check out our FAQ X