1 files changed, 138 insertions, 0 deletions
diff --git a/libraries/spongycastle/core/src/main/java/org/spongycastle/pqc/math/linearalgebra/BigIntUtils.java b/libraries/spongycastle/core/src/main/java/org/spongycastle/pqc/math/linearalgebra/BigIntUtils.java
new file mode 100644
index 000000000..19734977a
--- /dev/null
+++ b/libraries/spongycastle/core/src/main/java/org/spongycastle/pqc/math/linearalgebra/BigIntUtils.java
@@ -0,0 +1,138 @@
+package org.spongycastle.pqc.math.linearalgebra;
+
+import java.math.BigInteger;
+
+/**
+ * FIXME: is this really necessary?!
+ */
+public final class BigIntUtils
+{
+
+    /**
+     * Default constructor (private).
+     */
+    private BigIntUtils()
+    {
+        // empty
+    }
+
+    /**
+     * Checks if two BigInteger arrays contain the same entries
+     *
+     * @param a first BigInteger array
+     * @param b second BigInteger array
+     * @return true or false
+     */
+    public static boolean equals(BigInteger[] a, BigInteger[] b)
+    {
+        int flag = 0;
+
+        if (a.length != b.length)
+        {
+            return false;
+        }
+        for (int i = 0; i < a.length; i++)
+        {
+            // avoid branches here!
+            // problem: compareTo on BigIntegers is not
+            // guaranteed constant-time!
+            flag |= a[i].compareTo(b[i]);
+        }
+        return flag == 0;
+    }
+
+    /**
+     * Fill the given BigInteger array with the given value.
+     *
+     * @param array the array
+     * @param value the value
+     */
+    public static void fill(BigInteger[] array, BigInteger value)
+    {
+        for (int i = array.length - 1; i >= 0; i--)
+        {
+            array[i] = value;
+        }
+    }
+
+    /**
+     * Generates a subarray of a given BigInteger array.
+     *
+     * @param input -
+     *              the input BigInteger array
+     * @param start -
+     *              the start index
+     * @param end   -
+     *              the end index
+     * @return a subarray of <tt>input</tt>, ranging from <tt>start</tt> to
+     *         <tt>end</tt>
+     */
+    public static BigInteger[] subArray(BigInteger[] input, int start, int end)
+    {
+        BigInteger[] result = new BigInteger[end - start];
+        System.arraycopy(input, start, result, 0, end - start);
+        return result;
+    }
+
+    /**
+     * Converts a BigInteger array into an integer array
+     *
+     * @param input -
+     *              the BigInteger array
+     * @return the integer array
+     */
+    public static int[] toIntArray(BigInteger[] input)
+    {
+        int[] result = new int[input.length];
+        for (int i = 0; i < input.length; i++)
+        {
+            result[i] = input[i].intValue();
+        }
+        return result;
+    }
+
+    /**
+     * Converts a BigInteger array into an integer array, reducing all
+     * BigIntegers mod q.
+     *
+     * @param q     -
+     *              the modulus
+     * @param input -
+     *              the BigInteger array
+     * @return the integer array
+     */
+    public static int[] toIntArrayModQ(int q, BigInteger[] input)
+    {
+        BigInteger bq = BigInteger.valueOf(q);
+        int[] result = new int[input.length];
+        for (int i = 0; i < input.length; i++)
+        {
+            result[i] = input[i].mod(bq).intValue();
+        }
+        return result;
+    }
+
+    /**
+     * Return the value of <tt>big</tt> as a byte array. Although BigInteger
+     * has such a method, it uses an extra bit to indicate the sign of the
+     * number. For elliptic curve cryptography, the numbers usually are
+     * positive. Thus, this helper method returns a byte array of minimal
+     * length, ignoring the sign of the number.
+     *
+     * @param value the <tt>BigInteger</tt> value to be converted to a byte
+     *              array
+     * @return the value <tt>big</tt> as byte array
+     */
+    public static byte[] toMinimalByteArray(BigInteger value)
+    {
+        byte[] valBytes = value.toByteArray();
+        if ((valBytes.length == 1) || (value.bitLength() & 0x07) != 0)
+        {
+            return valBytes;
+        }
+        byte[] result = new byte[value.bitLength() >> 3];
+        System.arraycopy(valBytes, 1, result, 0, result.length);
+        return result;
+    }
+
+}