Adapted OpenSSL part to changes to IsElement

Author: lumip

CompactCryptoGroupAlgebra.OpenSsl.Tests/EllipticCurves/EllipticCurveAlgebraTests.cs

@@ -167,7 +167,17 @@ public void TestIsElement()
             var point = new ECPoint(groupHandle);
             ECPointHandle.Multiply(groupHandle, point.Handle, new BigNumber(index).Handle, ECPointHandle.Null, BigNumberHandle.Null, ctx);
 
-            Assert.That(algebra.IsElement(point), "valid point not accepted!");
+            Assert.That(algebra.IsPotentialElement(point), "valid point not accepted by IsPotentialElement!");
+            Assert.That(algebra.IsSafeElement(point), "valid point not accepted by IsSafeElement!");
+        }
+
+        [Test]
+        public void TestIsElementForPointAtInfinity()
+        {
+            var algebra = new EllipticCurveAlgebra(EllipticCurveID.Prime256v1);
+
+            Assert.That(algebra.IsPotentialElement(algebra.NeutralElement), "point at infinity not accepted by IsPotentialElement!");
+            Assert.That(!algebra.IsSafeElement(algebra.NeutralElement), "point at infinity accepted by IsSafeElement!");
         }
 
         [Test]

CompactCryptoGroupAlgebra.OpenSsl.Tests/Multiplicative/MultiplicativeGroupAlgebraTests.cs

@@ -113,7 +113,8 @@ public void TestInvalidElementRejectedAsGenerator(int generatorInt)
         public void TestIsElementAcceptsValidElements(int elementInt)
         {
             var element = new BigNumber(elementInt);
-            Assert.That(groupAlgebra!.IsElement(element));
+            Assert.That(groupAlgebra!.IsPotentialElement(element));
+            Assert.That(groupAlgebra!.IsSafeElement(element));
         }
 
         [Test]
@@ -124,16 +125,26 @@ public void TestIsElementAcceptsValidElements(int elementInt)
         public void TestIsElementRejectsInvalidElementsOutOfBounds(int elementInt)
         {
             var element = new BigNumber(elementInt);
-            Assert.That(!groupAlgebra!.IsElement(element));
+            Assert.That(!groupAlgebra!.IsPotentialElement(element));
+            Assert.That(!groupAlgebra!.IsSafeElement(element));
         }
 
         [Test]
         [TestCase(1)]
         [TestCase(22)]
-        public void TestIsElementRejectsUnsafeElements(int elementInt)
+        public void TestIsElementForUnsafeElements(int elementInt)
         {
             var element = new BigNumber(elementInt);
-            Assert.That(!groupAlgebra!.IsElement(element));
+            Assert.That(groupAlgebra!.IsPotentialElement(element));
+            Assert.That(!groupAlgebra!.IsSafeElement(element));
+        }
+
+        [Test]
+        public void TestIsElementForNeutralElementAndNoCofactor()
+        {
+            var groupAlgebra = new MultiplicativeGroupAlgebra(BigPrime.CreateWithoutChecks(11), BigPrime.CreateWithoutChecks(10), 2);
+            Assert.That(groupAlgebra.IsPotentialElement(groupAlgebra.NeutralElement));
+            Assert.That(!groupAlgebra.IsSafeElement(groupAlgebra.NeutralElement));
         }
 
         [Test]
@@ -222,27 +233,14 @@ public void TestEqualsFalseForUnrelatedObject()
         public void TestEqualsFalseForOtherAlgebra()
         {
             var otherAlgebra = new MultiplicativeGroupAlgebra(
-                BigPrime.CreateWithoutChecks(59),
-                BigPrime.CreateWithoutChecks(29),
-                5
-            );
-            Assert.That(!groupAlgebra!.Equals(otherAlgebra));
-
-            otherAlgebra = new MultiplicativeGroupAlgebra(
-                BigPrime.CreateWithoutChecks(23),
-                BigPrime.CreateWithoutChecks(11),
-                8
-            );
-            Assert.That(!groupAlgebra!.Equals(otherAlgebra));
-
-            otherAlgebra = new MultiplicativeGroupAlgebra(
-                BigPrime.CreateWithoutChecks(23),
-                BigPrime.CreateWithoutChecks(23),
-                5
+                BigPrime.CreateWithoutChecks(2*53+1),
+                BigPrime.CreateWithoutChecks(53),
+                4
             );
-            Assert.That(!groupAlgebra!.Equals(otherAlgebra));
+            Assert.IsFalse(groupAlgebra!.Equals(otherAlgebra));
         }
 
+
         [Test]
         public void TestGetHashCodeSameForEqual()
         {

CompactCryptoGroupAlgebra.OpenSsl/EllipticCurves/EllipticCurveAlgebra.cs

@@ -190,7 +190,17 @@ public bool IsPotentialElement(ECPoint element)
         /// <inheritdocs />
         public bool IsSafeElement(ECPoint element)
         {
-            return IsPotentialElement(element);
+            if (!IsPotentialElement(element)) return false;
+
+            // verifying that the point is not from a small subgroup of the whole curve (and thus outside
+            // of the safe subgroup over which operations are considered)
+            using (var cofactorBignum = new BigNumber(Cofactor))
+            {
+                var check = MultiplyScalar(element, SecureBigNumber.FromBigNumber(new BigNumber(Cofactor)));
+                if (check.IsAtInfinity)
+                    return false;
+            }
+            return true;
         }
 
         /// <inheritdocs />

CompactCryptoGroupAlgebra.OpenSsl/Multiplicative/MultiplicativeGroupAlgebra.cs

@@ -109,20 +109,18 @@ public bool IsPotentialElement(BigNumber element)
             return true;
         }
 
+        /// <inheritdocs />
         public bool IsSafeElement(BigNumber element)
         {
             if (!IsPotentialElement(element)) return false;
-            
+
             // verifying that the point is not from a small subgroup of the whole curve (and thus outside
             // of the safe subgroup over which operations are considered)
-            if (Cofactor > 1)
+            using (var cofactorBignum = new BigNumber(Cofactor))
             {
-                using (var cofactorBignum = new BigNumber(Cofactor))
-                {
-                    var check = element.ModExp(cofactorBignum, _modulo);
-                    if (check.Equals(NeutralElement))
-                        return false;
-                }
+                var check = element.ModExp(cofactorBignum, _modulo);
+                if (check.Equals(NeutralElement))
+                    return false;
             }
             return true;
         }