true if BigInteger is using the GNU MP native code. */
private boolean usingNativeImpl = Arrays.equals(BYTES,
new BigInteger(BYTES).toByteArray());
public void test(TestHarness harness)
{
harness.checkPoint("TestOfPR27372");
SecureRandom prng1, prng2;
byte[] ba, bb;
try
{
prng1 = SecureRandom.getInstance("SHA1PRNG");
prng1.setSeed(98243647L);
prng2 = SecureRandom.getInstance("SHA1PRNG");
prng2.setSeed(98243647L);
// from here on the two PRNGs are in sync. they should consume as
// little bytes as possible, and continue to be in sync
for (int numBytes = 1; numBytes < 10; numBytes++)
{
ba = new BigInteger(8 * numBytes, prng1).toByteArray();
bb = new byte[numBytes];
prng2.nextBytes(bb);
harness.check(areEqual(ba, bb),
"BigInteger(int, Random) SHOULD consume as little "
+ "bytes as possible from Random (and SecureRandom): "
+ numBytes);
}
}
catch (Exception x)
{
harness.debug(x);
harness.fail("TestOfPR27372: " + x);
}
}
/**
* In both cases --the pure Java implementation, and the native one based on
* the GNU MP library-- a BigInteger's toByteArray(), can produce an extra
* 0x00 byte as the most significant byte. This method ensures that there
* is no more than just one zero-byte at the high end, and then channels the
* call to the appropriate are-equal method depending on the type of the
* underlying implementation of the MPI.
*
* @param a the result of a {@link BigInteger#toByteArray()} of an instance
* constructed with {@link BigInteger#BigInteger(int, Random)}.
* @param b a non-null byte array filled with randomly generated values.
* @return true if the two byte arrays contain the same values
* taking into consideration how our BigInteger constructs its
* internal data structures.
*/
private boolean areEqual(byte[] a, byte[] b)
{
int offset = 0;
switch (a.length - b.length)
{
case 0:
break;
case 1:
if (a[0] != 0)
return false;
offset = 1;
break;
default:
return false;
}
if (usingNativeImpl)
return areEqualNativeBI(a, offset, b);
return areEqualJavaBI(a, offset, b);
}
/**
* Special byte array comparison method used to compare the result of
* byte[] a = new BigInteger(numBits, random).toByteArray() with
* a byte array filled with randomly generated values.
*
* This method takes into consideration how an array of bytes is used to
* fill the (pure java) BigInteger's internal data structure. As
* an example, here is what the two byte arrays may look like from the
* outside:
*
*
* a = 009ECB38BFD4C6 * b = CB9EC6D4BF38 ** * @param a the result of a {@link BigInteger#toByteArray()} of an instance * constructed with {@link BigInteger#BigInteger(int, Random)}. * @param
0 or 1 depending on the value of the
* leftmost byte (at index #0) of a.
* @param b a non-null byte array filled with randomly generated values.
* @return true if the two byte arrays contain the same values
* taking into consideration how our BigInteger constructs its
* internal data structures.
*/
private boolean areEqualJavaBI(byte[] a, int offset, byte[] b)
{
for (int i = b.length - 1, j, k; i >= 0; )
{
j = i - 3;
if (j < 0)
j = 0;
for (k = 0; k < 4; k++)
{
if (a[offset + j++] != b[i--])
return false;
if (i < 0)
break;
}
}
return true;
}
/**
* Straight equality check, byte-for-byte, of the two designated arrays. The
* first starting from either 0 or 1, while the
* second always starting from 0. This is used with GMP-based
* MPIs.
*
* @param a the result of a {@link BigInteger#toByteArray()} of an instance
* constructed with {@link BigInteger#BigInteger(int, Random)}.
* @param 0 or 1 depending on the value of the
* leftmost byte (at index #0) of a.
* @param b a non-null byte array filled with randomly generated values.
* @return true if the two byte arrays contain the same values
* taking into consideration how our BigInteger constructs its
* internal data structures.
*/
private boolean areEqualNativeBI(byte[] a, int offset, byte[] b)
{
for (int i = 0; i < b.length; i++)
if (a[offset + i] != b[i])
return false;
return true;
}
}