public void TestIsElementTrue()
{
var prime = BigPrime.CreateWithoutChecks(11);
var field = new BigIntegerField(prime);
Assert.IsTrue(field.IsElement(7));
}
public void TestIsSafeElementForNeutralElementCofactorOne()
{
var groupAlgebra = new MultiplicativeGroupAlgebra(BigPrime.CreateWithoutChecks(11), BigPrime.CreateWithoutChecks(10), 2);
Assert.That(groupAlgebra.IsPotentialElement(groupAlgebra.NeutralElement));
Assert.That(!groupAlgebra.IsSafeElement(groupAlgebra.NeutralElement));
}
public CurveGroupAlgebraTests()
{
curveEquationMock = new Mock <CurveEquation>(
BigPrime.CreateWithoutChecks(23),
BigInteger.Zero,
BigInteger.One
)
{
CallBase = true
};
curveParameters = new CurveParameters(
curveEquation: curveEquationMock.Object,
generator: TestCurveParameters.WeierstrassParameters.Generator,
order: TestCurveParameters.WeierstrassParameters.Order,
cofactor: TestCurveParameters.WeierstrassParameters.Cofactor
);
largeCurveEquationMock = new Mock <CurveEquation>(
BigPrime.CreateWithoutChecks(18392027),
BigInteger.Zero,
BigInteger.One
)
{
CallBase = true
}; // 25 bits prime
largeParameters = new CurveParameters(
curveEquation: largeCurveEquationMock.Object,
generator: new CurvePoint(),
order: BigPrime.CreateWithoutChecks(2),
cofactor: BigInteger.One
);
}
public void TestIsElementFalse(int value)
{
var prime = BigPrime.CreateWithoutChecks(11);
var field = new BigIntegerField(prime);
Assert.IsFalse(field.IsElement(new BigInteger(value)));
}
public CurveParametersTests()
{
equationMock = new Mock <CurveEquation>(
BigPrime.CreateWithoutChecks(11),
new BigInteger(2),
new BigInteger(-3)
);
}
public void SetUpAlgebra()
{
groupAlgebra = new MultiplicativeGroupAlgebra(
prime: BigPrime.CreateWithoutChecks(23),
order: BigPrime.CreateWithoutChecks(11),
generator: 2
);
}
public void TestConstructor()
{
var prime = BigPrime.CreateWithoutChecks(11);
var field = new BigIntegerField(prime);
Assert.AreEqual(prime, field.Modulo);
Assert.AreEqual(1, field.ElementByteLength);
}
public void TestEqualsFalseForOtherAlgebra()
{
var curve = TestCurveParameters.WeierstrassParameters.Equation;
var otherCurve = new WeierstrassCurveEquation(prime: BigPrime.CreateWithoutChecks(11), 0, 0);
bool result = curve.Equals(otherCurve);
Assert.IsFalse(result);
}
public void TestPowRejectsNegativeExponent()
{
var prime = BigPrime.CreateWithoutChecks(11);
var field = new BigIntegerField(prime);
Assert.Throws <ArgumentException>(
() => field.Pow(5, -1)
);
}
public void SetUpAlgebra()
{
groupAlgebra = new MultiplicativeGroupAlgebra(
prime: BigPrime.CreateWithoutChecks(23),
order: BigPrime.CreateWithoutChecks(11),
generator: 2
);
// group elements: 1, 2, 3, 4, 6, 8, 9, 12, 13, 16, 18
}
public void TestModReciprocal()
{
var numberRaw = 7652;
var modulo = BigPrime.CreateWithoutChecks(89237);
var number = new BigNumber(numberRaw);
var expected = number.ModExp(new BigNumber(modulo - 2), new BigNumber(modulo));
var result = number.ModReciprocal(new BigNumber(modulo));
Assert.That(result.Equals(expected));
}
public void TestSquare()
{
var prime = BigPrime.CreateWithoutChecks(11);
var field = new BigIntegerField(prime);
var result = field.Square(5);
var expected = new BigInteger(3);
Assert.AreEqual(expected, result);
}
public void TestEqualsFalseForOtherAlgebra()
{
var otherAlgebra = new MultiplicativeGroupAlgebra(
BigPrime.CreateWithoutChecks(2 * 53 + 1),
BigPrime.CreateWithoutChecks(53),
4
);
Assert.IsFalse(groupAlgebra !.Equals(otherAlgebra));
}
public void TestMod(int value, int expectedRaw)
{
var prime = BigPrime.CreateWithoutChecks(11);
var field = new BigIntegerField(prime);
var result = field.Mod(value);
var expected = new BigInteger(expectedRaw);
Assert.AreEqual(expected, result);
}
public void TestComputeSecurityLevel()
{
var mod = BigPrime.CreateWithoutChecks(BigInteger.One << 2047);
Assert.AreEqual(115, MultiplicativeGroupAlgebra.ComputeSecurityLevel(mod, mod));
var smallOrder = BigPrime.CreateWithoutChecks(new BigInteger(4));
Assert.AreEqual(2 * NumberLength.GetLength(smallOrder).InBits, MultiplicativeGroupAlgebra.ComputeSecurityLevel(mod, smallOrder));
}
public void TestEqualsIsFalseForUnrelatedObject()
{
var order = BigPrime.CreateWithoutChecks(7);
var cofactor = new BigInteger(2);
var generator = CurvePoint.PointAtInfinity;
CurveParameters parameters = new CurveParameters(
equationMock.Object, generator, order, cofactor
);
Assert.AreNotEqual(parameters, new object());
}
public void TestInvertMult()
{
var prime = BigPrime.CreateWithoutChecks(11);
var field = new BigIntegerField(prime);
var result = field.InvertMult(5);
var expected = new BigInteger(9);
Assert.AreEqual(expected, result);
Assert.AreEqual(BigInteger.One, field.Mod(result * 5));
}
public void TestEqualsFalseForUnrelatedObject()
{
var equationMock = new Mock <CurveEquation>(
BigPrime.CreateWithoutChecks(23),
BigInteger.Zero, BigInteger.One
)
{
CallBase = true
};
Assert.IsFalse(equationMock.Object.Equals(new object()));
}
public XOnlyMontgomeryCurveAlgebraTests()
{
largeParameters = new CurveParameters(
curveEquation: new MontgomeryCurveEquation(
prime: BigPrime.CreateWithoutChecks(18392027), // 25 bits
a: 0, b: 0
),
generator: CurvePoint.PointAtInfinity,
order: BigPrime.CreateWithoutChecks(3),
cofactor: 1
);
}
public void TestComputePrimeLengthForSecurityLevel()
{
// dominated by NFS
var l = MultiplicativeGroupAlgebra.ComputePrimeLengthForSecurityLevel(100);
var p = BigPrime.CreateWithoutChecks(BigInteger.One << (l.InBits - 1));
var s = MultiplicativeGroupAlgebra.ComputeSecurityLevel(p, p);
Assert.AreEqual(100, s);
// dominated by Pollard Rho
l = MultiplicativeGroupAlgebra.ComputePrimeLengthForSecurityLevel(1);
Assert.AreEqual(2, l.InBits);
}
public void TestProperties()
{
var generator = new BigInteger(2);
var neutralElement = BigInteger.One;
var modulo = BigPrime.CreateWithoutChecks(23);
var order = BigPrime.CreateWithoutChecks(11);
var cofactor = new BigInteger(2);
Assert.AreEqual(neutralElement, groupAlgebra !.NeutralElement, "verifying neutral element");
Assert.AreEqual(generator, groupAlgebra !.Generator, "verifying generator");
Assert.AreEqual(order, groupAlgebra !.Order, "verifying order");
Assert.AreEqual(modulo, groupAlgebra !.Prime, "verifying modulo");
Assert.AreEqual(cofactor, groupAlgebra !.Cofactor, "verifying cofactor");
}
public void TestEqualsIsTrueForEqualObjects()
{
var order = BigPrime.CreateWithoutChecks(7);
var cofactor = new BigInteger(2);
var generator = CurvePoint.PointAtInfinity;
CurveParameters parameters = new CurveParameters(
equationMock.Object, generator, order, cofactor
);
CurveParameters otherParameters = new CurveParameters(
equationMock.Object, generator, order, cofactor
);
Assert.AreEqual(parameters, otherParameters);
}
public void TestAreNegationsTrueForPointAtInfinity()
{
var equation = new Mock <CurveEquation>(
BigPrime.CreateWithoutChecks(23),
BigInteger.Zero, BigInteger.One
)
{
CallBase = true
};
var testElement = CurvePoint.PointAtInfinity;
var otherElement = testElement.Clone();
Assert.IsTrue(equation.Object.AreNegations(testElement, otherElement));
}
public void TestAreNegationsTrueForNegation()
{
var equation = new Mock <CurveEquation>(
BigPrime.CreateWithoutChecks(23),
BigInteger.Zero, BigInteger.One
)
{
CallBase = true
};
var testElement = new CurvePoint(5, 5);
var otherElement = equation.Object.Negate(testElement);
Assert.IsTrue(equation.Object.AreNegations(testElement, otherElement));
}
public void TestNegateForPointAtInfinity()
{
var equation = new Mock <CurveEquation>(
BigPrime.CreateWithoutChecks(23),
BigInteger.Zero, BigInteger.One
)
{
CallBase = true
};
var testElement = CurvePoint.PointAtInfinity;
var expected = CurvePoint.PointAtInfinity;
var result = equation.Object.Negate(testElement);
Assert.AreEqual(expected, result);
}
public void TestDiffieHellmanWithMultiplicativeGroup()
{
string primeHex = @"0
FFFFFFFF FFFFFFFF C90FDAA2 2168C234 C4C6628B 80DC1CD1
29024E08 8A67CC74 020BBEA6 3B139B22 514A0879 8E3404DD
EF9519B3 CD3A431B 302B0A6D F25F1437 4FE1356D 6D51C245
E485B576 625E7EC6 F44C42E9 A63A3620 FFFFFFFF FFFFFFFF";
BigPrime prime = BigPrime.CreateWithoutChecks(
BigInteger.Parse(Regex.Replace(primeHex, @"\s+", ""), NumberStyles.AllowHexSpecifier)
);
BigPrime order = BigPrime.CreateWithoutChecks((prime - 1) / 2);
BigNumber generator = new BigNumber(4);
var algebra = new MultiplicativeGroupAlgebra(prime, order, generator);
var group = new CryptoGroup <SecureBigNumber, BigNumber>(algebra);
CompactCryptoGroupAlgebra.DiffieHellmanIntegrationTests.DoDiffieHellman(group);
}
public void TestEqualsTrue()
{
var equationMock = new Mock <CurveEquation>(
BigPrime.CreateWithoutChecks(23),
BigInteger.Zero, BigInteger.One
)
{
CallBase = true
};
var otherMock = new Mock <CurveEquation>(
BigPrime.CreateWithoutChecks(23),
BigInteger.Zero, BigInteger.One
)
{
CallBase = true
};
Assert.IsTrue(equationMock.Object.Equals(otherMock.Object));
}
public void TestEqualsIsFalseForDifferentObjects()
{
var equation = equationMock.Object;
equationMock.Reset();
equationMock.Setup(eq => eq.Equals(It.IsAny <CurveEquation>())).Returns(false);
var order = BigPrime.CreateWithoutChecks(7);
var cofactor = new BigInteger(2);
var generator = CurvePoint.PointAtInfinity;
CurveParameters parameters = new CurveParameters(
equation, generator, order, cofactor
);
CurveParameters otherParameters = new CurveParameters(
equation, generator, order, cofactor
);
Assert.AreNotEqual(parameters, otherParameters);
equationMock.Reset();
equationMock.Setup(eq => eq.Equals(It.IsAny <CurveEquation>())).Returns(true);
otherParameters = new CurveParameters(
equation, new CurvePoint(1, 1), order, cofactor
);
Assert.AreNotEqual(parameters, otherParameters);
otherParameters = new CurveParameters(
equation, generator, BigPrime.CreateWithoutChecks(3), cofactor
);
Assert.AreNotEqual(parameters, otherParameters);
otherParameters = new CurveParameters(
equation, generator, order, BigInteger.One
);
Assert.AreNotEqual(parameters, otherParameters);
}
