ed-precompiled_ed25519 1.4.0-arm64-darwin

data/ext/ed25519_jruby/net/i2p/crypto/eddsa/math/ScalarOps.java

@@ -0,0 +1,34 @@
+/**
+ * EdDSA-Java by str4d
+ *
+ * To the extent possible under law, the person who associated CC0 with
+ * EdDSA-Java has waived all copyright and related or neighboring rights
+ * to EdDSA-Java.
+ *
+ * You should have received a copy of the CC0 legalcode along with this
+ * work. If not, see <https://creativecommons.org/publicdomain/zero/1.0/>.
+ *
+ */
+package net.i2p.crypto.eddsa.math;
+
+public interface ScalarOps {
+    /**
+     * Reduce the given scalar mod $l$.
+     * <p>
+     * From the Ed25519 paper:<br>
+     * Here we interpret $2b$-bit strings in little-endian form as integers in
+     * $\{0, 1,..., 2^{(2b)}-1\}$.
+     * @param s the scalar to reduce
+     * @return $s \bmod l$
+     */
+    public byte[] reduce(byte[] s);
+
+    /**
+     * $r = (a * b + c) \bmod l$
+     * @param a a scalar
+     * @param b a scalar
+     * @param c a scalar
+     * @return $(a*b + c) \bmod l$
+     */
+    public byte[] multiplyAndAdd(byte[] a, byte[] b, byte[] c);
+}

data/ext/ed25519_jruby/net/i2p/crypto/eddsa/math/bigint/BigIntegerFieldElement.java

@@ -0,0 +1,131 @@
+/**
+ * EdDSA-Java by str4d
+ *
+ * To the extent possible under law, the person who associated CC0 with
+ * EdDSA-Java has waived all copyright and related or neighboring rights
+ * to EdDSA-Java.
+ *
+ * You should have received a copy of the CC0 legalcode along with this
+ * work. If not, see <https://creativecommons.org/publicdomain/zero/1.0/>.
+ *
+ */
+package net.i2p.crypto.eddsa.math.bigint;
+
+import java.io.Serializable;
+import java.math.BigInteger;
+
+import net.i2p.crypto.eddsa.math.Field;
+import net.i2p.crypto.eddsa.math.FieldElement;
+
+/**
+ * A particular element of the field \Z/(2^255-19).
+ * @author str4d
+ *
+ */
+public class BigIntegerFieldElement extends FieldElement implements Serializable {
+    private static final long serialVersionUID = 4890398908392808L;
+    /**
+     * Variable is package private for encoding.
+     */
+    final BigInteger bi;
+
+    public BigIntegerFieldElement(Field f, BigInteger bi) {
+        super(f);
+        this.bi = bi;
+    }
+
+    public boolean isNonZero() {
+        return !bi.equals(BigInteger.ZERO);
+    }
+
+    public FieldElement add(FieldElement val) {
+        return new BigIntegerFieldElement(f, bi.add(((BigIntegerFieldElement)val).bi)).mod(f.getQ());
+    }
+
+    @Override
+    public FieldElement addOne() {
+        return new BigIntegerFieldElement(f, bi.add(BigInteger.ONE)).mod(f.getQ());
+    }
+
+    public FieldElement subtract(FieldElement val) {
+        return new BigIntegerFieldElement(f, bi.subtract(((BigIntegerFieldElement)val).bi)).mod(f.getQ());
+    }
+
+    @Override
+    public FieldElement subtractOne() {
+        return new BigIntegerFieldElement(f, bi.subtract(BigInteger.ONE)).mod(f.getQ());
+    }
+
+    public FieldElement negate() {
+        return f.getQ().subtract(this);
+    }
+
+    @Override
+    public FieldElement divide(FieldElement val) {
+        return divide(((BigIntegerFieldElement)val).bi);
+    }
+
+    public FieldElement divide(BigInteger val) {
+        return new BigIntegerFieldElement(f, bi.divide(val)).mod(f.getQ());
+    }
+
+    public FieldElement multiply(FieldElement val) {
+        return new BigIntegerFieldElement(f, bi.multiply(((BigIntegerFieldElement)val).bi)).mod(f.getQ());
+    }
+
+    public FieldElement square() {
+        return multiply(this);
+    }
+
+    public FieldElement squareAndDouble() {
+        FieldElement sq = square();
+        return sq.add(sq);
+    }
+
+    public FieldElement invert() {
+        // Euler's theorem
+        //return modPow(f.getQm2(), f.getQ());
+        return new BigIntegerFieldElement(f, bi.modInverse(((BigIntegerFieldElement)f.getQ()).bi));
+    }
+
+    public FieldElement mod(FieldElement m) {
+        return new BigIntegerFieldElement(f, bi.mod(((BigIntegerFieldElement)m).bi));
+    }
+
+    public FieldElement modPow(FieldElement e, FieldElement m) {
+        return new BigIntegerFieldElement(f, bi.modPow(((BigIntegerFieldElement)e).bi, ((BigIntegerFieldElement)m).bi));
+    }
+
+    public FieldElement pow(FieldElement e){
+        return modPow(e, f.getQ());
+    }
+
+    public FieldElement pow22523(){
+        return pow(f.getQm5d8());
+    }
+
+    @Override
+    public FieldElement cmov(FieldElement val, int b) {
+        // Not constant-time, but it doesn't really matter because none of the underlying BigInteger operations
+        // are either, so there's not much point in trying hard here ...
+        return b == 0 ? this : val;
+    }
+
+    @Override
+    public int hashCode() {
+        return bi.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof BigIntegerFieldElement))
+            return false;
+        BigIntegerFieldElement fe = (BigIntegerFieldElement) obj;
+        return bi.equals(fe.bi);
+    }
+
+    @Override
+    public String toString() {
+        return "[BigIntegerFieldElement val="+bi+"]";
+    }
+}

data/ext/ed25519_jruby/net/i2p/crypto/eddsa/math/bigint/BigIntegerLittleEndianEncoding.java

@@ -0,0 +1,102 @@
+/**
+ * EdDSA-Java by str4d
+ *
+ * To the extent possible under law, the person who associated CC0 with
+ * EdDSA-Java has waived all copyright and related or neighboring rights
+ * to EdDSA-Java.
+ *
+ * You should have received a copy of the CC0 legalcode along with this
+ * work. If not, see <https://creativecommons.org/publicdomain/zero/1.0/>.
+ *
+ */
+package net.i2p.crypto.eddsa.math.bigint;
+
+import java.io.Serializable;
+import java.math.BigInteger;
+
+import net.i2p.crypto.eddsa.math.Encoding;
+import net.i2p.crypto.eddsa.math.Field;
+import net.i2p.crypto.eddsa.math.FieldElement;
+
+public class BigIntegerLittleEndianEncoding extends Encoding implements Serializable {
+    private static final long serialVersionUID = 3984579843759837L;
+    /**
+     * Mask where only the first b-1 bits are set.
+     */
+    private BigInteger mask;
+
+    @Override
+    public synchronized void setField(Field f) {
+        super.setField(f);
+        mask = BigInteger.ONE.shiftLeft(f.getb()-1).subtract(BigInteger.ONE);
+    }
+
+    public byte[] encode(FieldElement x) {
+        return encode(((BigIntegerFieldElement)x).bi.and(mask));
+    }
+
+    /**
+     *  Convert $x$ to little endian.
+     *  Constant time.
+     *
+     *  @param x the BigInteger value to encode
+     *  @return array of length $b/8$
+     *  @throws IllegalStateException if field not set
+     */
+    public byte[] encode(BigInteger x) {
+        if (f == null)
+            throw new IllegalStateException("field not set");
+        byte[] in = x.toByteArray();
+        byte[] out = new byte[f.getb()/8];
+        for (int i = 0; i < in.length; i++) {
+            out[i] = in[in.length-1-i];
+        }
+        for (int i = in.length; i < out.length; i++) {
+            out[i] = 0;
+        }
+        return out;
+    }
+
+    /**
+     *  Decode a FieldElement from its $(b-1)$-bit encoding.
+     *  The highest bit is masked out.
+     *
+     *  @param in the $(b-1)$-bit encoding of a FieldElement.
+     *  @return the FieldElement represented by 'val'.
+     *  @throws IllegalStateException if field not set
+     *  @throws IllegalArgumentException if encoding is invalid
+     */
+    public FieldElement decode(byte[] in) {
+        if (f == null)
+            throw new IllegalStateException("field not set");
+        if (in.length != f.getb()/8)
+            throw new IllegalArgumentException("Not a valid encoding");
+        return new BigIntegerFieldElement(f, toBigInteger(in).and(mask));
+    }
+
+    /**
+     *  Convert in to big endian
+     *
+     *  @param in the $(b-1)$-bit encoding of a FieldElement.
+     *  @return the decoded value as a BigInteger
+     */
+    public BigInteger toBigInteger(byte[] in) {
+        byte[] out = new byte[in.length];
+        for (int i = 0; i < in.length; i++) {
+            out[i] = in[in.length-1-i];
+        }
+        return new BigInteger(1, out);
+    }
+
+    /**
+     * From the Ed25519 paper:<br>
+     * $x$ is negative if the $(b-1)$-bit encoding of $x$ is lexicographically larger
+     * than the $(b-1)$-bit encoding of $-x$. If $q$ is an odd prime and the encoding
+     * is the little-endian representation of $\{0, 1,\dots, q-1\}$ then the negative
+     * elements of $F_q$ are $\{1, 3, 5,\dots, q-2\}$.
+     * @return true if negative
+     */
+    public boolean isNegative(FieldElement x) {
+        return ((BigIntegerFieldElement)x).bi.testBit(0);
+    }
+}

data/ext/ed25519_jruby/net/i2p/crypto/eddsa/math/bigint/BigIntegerScalarOps.java

@@ -0,0 +1,37 @@
+/**
+ * EdDSA-Java by str4d
+ *
+ * To the extent possible under law, the person who associated CC0 with
+ * EdDSA-Java has waived all copyright and related or neighboring rights
+ * to EdDSA-Java.
+ *
+ * You should have received a copy of the CC0 legalcode along with this
+ * work. If not, see <https://creativecommons.org/publicdomain/zero/1.0/>.
+ *
+ */
+package net.i2p.crypto.eddsa.math.bigint;
+
+import java.math.BigInteger;
+
+import net.i2p.crypto.eddsa.math.Field;
+import net.i2p.crypto.eddsa.math.ScalarOps;
+
+public class BigIntegerScalarOps implements ScalarOps {
+    private final BigInteger l;
+    private final BigIntegerLittleEndianEncoding enc;
+
+    public BigIntegerScalarOps(Field f, BigInteger l) {
+        this.l = l;
+        enc = new BigIntegerLittleEndianEncoding();
+        enc.setField(f);
+    }
+
+    public byte[] reduce(byte[] s) {
+        return enc.encode(enc.toBigInteger(s).mod(l));
+    }
+
+    public byte[] multiplyAndAdd(byte[] a, byte[] b, byte[] c) {
+        return enc.encode(enc.toBigInteger(a).multiply(enc.toBigInteger(b)).add(enc.toBigInteger(c)).mod(l));
+    }
+
+}

data/ext/ed25519_jruby/net/i2p/crypto/eddsa/math/bigint/package.html

@@ -0,0 +1,6 @@
+<html><body>
+<p>
+   Low-level, non-optimized implementation using BigIntegers for any curve.
+   See the <a href="../ed25519/package-summary.html">ed25519</a> implementation for Curve 25519.
+</p>
+</body></html>