Example #1
0
 /// <summary>
 /// Calculate point addition
 /// </summary>
 /// <param name="t1">point</param>
 /// <param name="t2">point</param>
 /// <param name="infinityToNull">
 /// if result was point-at-infinity, and this parameter was true,
 /// null is returned instead of <see cref="ECPointAtInfinity"/>.
 /// </param>
 /// <returns>point, or null if failed</returns>
 public override ECPoint PointAdd(ECPoint t1, ECPoint t2, bool infinityToNull) {
     if (t1 == null || t2 == null) {
         return null;
     }
     BigInteger.ModulusRing ring = new BigInteger.ModulusRing(p);
     ECPoint r;
     if (!PointAdd(ring, t1, t2, out r)) {
         return null;
     }
     if (infinityToNull && r is ECPointAtInfinity) {
         return null;
     }
     return r;
 }
Example #2
0
 /// <summary>
 /// Calculate point multiplication
 /// </summary>
 /// <param name="k1">scalar</param>
 /// <param name="k2">scalar</param>
 /// <param name="t">point</param>
 /// <param name="infinityToNull">
 /// if result was point-at-infinity, and this parameter was true,
 /// null is returned instead of <see cref="ECPointAtInfinity"/>.
 /// </param>
 /// <returns>point on the curve, point at infinity, or null if failed</returns>
 public override ECPoint PointMul(BigInteger k1, BigInteger k2, ECPoint t, bool infinityToNull) {
     BigInteger.ModulusRing ring = new BigInteger.ModulusRing(p);
     BigInteger k = ring.Multiply(k1, k2);
     return PointMul(k, t, infinityToNull);
 }
Example #3
0
        /// <summary>
        /// Signing
        /// </summary>
        /// <param name="data">data to sign</param>
        /// <returns>signature blob</returns>
        public byte[] Sign(byte[] data) {
            BigInteger order = _curve.Order;

            byte[] hash = _publicKey.HashForSigning(data, _curve);
            BigInteger e = new BigInteger(hash);

            using (var rng = new RNGCryptoServiceProvider()) {

                BigInteger.ModulusRing nring = new BigInteger.ModulusRing(order);

                for (int tries = 0; tries < 10; ++tries) {
                    try {
                        ECDSAKeyPair tempKeyPair = _curve.GenerateKeyPair(rng);

                        BigInteger r = tempKeyPair.PublicKeyPoint.X % order;
                        if (r == 0) {
                            continue;
                        }

                        BigInteger k = tempKeyPair.PrivateKey;
                        BigInteger s = nring.Multiply(k.ModInverse(order), e + nring.Multiply(r, _privateKey));
                        if (s == 0) {
                            continue;
                        }

                        SSH2DataWriter writer = new SSH2DataWriter();
                        writer.WriteBigInteger(r);
                        writer.WriteBigInteger(s);

                        return writer.ToByteArray();
                    }
                    catch (Exception ex) {
                        Debug.WriteLine(ex);
                    }
                }
            }

            throw new SSHException(Strings.GetString("FailedSigning"));
        }
Example #4
0
 /// <summary>
 /// Calculate point multiplication
 /// </summary>
 /// <param name="k">scalar</param>
 /// <param name="t">point</param>
 /// <param name="infinityToNull">
 /// if result was point-at-infinity, and this parameter was true,
 /// null is returned instead of <see cref="ECPointAtInfinity"/>.
 /// </param>
 /// <returns>point on the curve, point at infinity, or null if failed</returns>
 public override ECPoint PointMul(BigInteger k, ECPoint t, bool infinityToNull) {
     if (t == null) {
         return null;
     }
     BigInteger.ModulusRing ring = new BigInteger.ModulusRing(p);
     ECPoint r;
     if (!PointMul(ring, t, k, out r)) {
         return null;
     }
     if (infinityToNull && r is ECPointAtInfinity) {
         return null;
     }
     return r;
 }
Example #5
0
        public void Verify(byte[] data, byte[] expected) {
            SSH2DataReader reader = new SSH2DataReader(data);
            BigInteger r = reader.ReadMPInt();
            BigInteger s = reader.ReadMPInt();
            if (r == 0 || r >= _curve.Order || s == 0 || s >= _curve.Order) {
                goto Fail;
            }

            if (!IsValid()) {
                goto Fail;
            }

            BigInteger order = _curve.Order;

            byte[] hash = HashForSigning(expected, _curve);
            BigInteger e = new BigInteger(hash);

            BigInteger.ModulusRing nring = new BigInteger.ModulusRing(order);

            try {
                BigInteger sInv = s.ModInverse(order);
                BigInteger u1 = nring.Multiply(e, sInv);
                BigInteger u2 = nring.Multiply(r, sInv);

                ECPoint p1 = _curve.PointMul(u1, _curve.BasePoint, true);
                ECPoint p2 = _curve.PointMul(u2, Point, true);
                if (p1 == null || p2 == null) {
                    goto Fail;
                }
                ECPoint R = _curve.PointAdd(p1, p2, true);
                if (R == null) {
                    goto Fail;
                }

                BigInteger v = R.X % order;

                if (v != r) {
                    goto Fail;
                }
            }
            catch (Exception) {
                goto Fail;
            }

            return;

        Fail:
            throw new VerifyException("Failed to verify");
        }