public void TestGenerateRandom()
{
var order = BigPrime.CreateWithoutChecks(1021);
var expectedIndex = new BigInteger(19);
int expectedRaw = 7;
var algebraMock = new Mock <ICryptoGroupAlgebra <BigInteger, int> >(MockBehavior.Strict);
algebraMock.Setup(alg => alg.IsPotentialElement(It.IsAny <int>())).Returns(true);
algebraMock.Setup(alg => alg.GenerateRandomElement(It.IsAny <RandomNumberGenerator>())).Returns((expectedIndex, expectedRaw));
var expectedElement = new CryptoGroupElement <BigInteger, int>(expectedRaw, algebraMock.Object);
var groupMock = new CryptoGroup <BigInteger, int>(algebraMock.Object);
var rngMock = new Mock <RandomNumberGenerator>();
var result = groupMock.GenerateRandom(rngMock.Object);
var resultIndex = result.Item1;
var resultElement = result.Item2;
Assert.AreEqual(expectedIndex, resultIndex);
Assert.AreEqual(expectedElement, resultElement);
}
public void TestMultiplyScalar(int scalarInt)
{
// this also tests the implementation in MultiplyScalarUnsafe
var k = new BigInteger(scalarInt);
var order = BigPrime.CreateWithoutChecks(5);
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
int element = 3;
int expected = 3 * (scalarInt % 5);
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength)
{
CallBase = true
};
algebraMock.Setup(alg => alg.Add(It.IsAny <int>(), It.IsAny <int>())).Returns((int x, int y) => x + y);
var result = algebraMock.Object.MultiplyScalar(element, k);
Assert.AreEqual(expected, result);
}
public void TestMultiplyScalarWithSmallFactor(int factorInt)
{
int element = 5;
var k = new BigInteger(factorInt);
var order = BigPrime.CreateWithoutChecks(11);
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
int factorBitLength = 3;
int expected = 5 * factorInt;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength)
{
CallBase = true
};
algebraMock.Setup(alg => alg.Add(It.IsAny <int>(), It.IsAny <int>())).Returns((int x, int y) => x + y);
var result = algebraMock.Object.MultiplyScalar(element, k, factorBitLength);
Assert.AreEqual(expected, result);
}
public void TestIsSafeElement()
{
var order = BigPrime.CreateWithoutChecks(11);
int element = 7;
var generatorStub = 1;
var cofactor = new BigInteger(2);
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength)
{
CallBase = true
};
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Setup(alg => alg.IsElementDerived(It.IsAny <int>()))
.Returns(true);
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Setup(alg => alg.MultiplyScalarUnchecked(It.IsAny <int>(), It.Is <BigInteger>(x => x.Equals(cofactor)), It.IsAny <int>()))
.Returns(element);
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Setup(alg => alg.MultiplyScalarUnchecked(It.IsAny <int>(), It.Is <BigInteger>(x => x.Equals(order)), It.IsAny <int>()))
.Returns(neutralElement);
Assert.IsTrue(algebraMock.Object.IsSafeElement(element));
}
public void TestEqualsIsTrueForEqual()
{
var prime = BigPrime.CreateWithoutChecks(11);
var otherPrime = BigPrime.CreateWithoutChecks(11);
Assert.AreEqual(prime, otherPrime);
}
public void TestNegate()
{
var order = BigPrime.CreateWithoutChecks(17);
int element = 7;
int expected = -7;
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength)
{
CallBase = true
};
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Setup(alg => alg.MultiplyScalarUnchecked(
It.IsAny <int>(), It.Is <BigInteger>(i => i == order - 1), It.Is <int>(i => i == 5))
)
.Returns(expected);
int result = algebraMock.Object.Negate(element);
Assert.AreEqual(expected, result);
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Verify(alg => alg.MultiplyScalarUnchecked(
It.IsAny <int>(), It.Is <BigInteger>(i => i == order - 1), It.Is <int>(i => i == 5)),
Times.Once()
);
}
public void TestCreate()
{
var rawValue = new BigInteger(8052311);
var value = BigPrime.Create(rawValue, new SeededRandomNumberGenerator());
Assert.AreEqual(rawValue, (BigInteger)value);
}
public void TestGetHashCodeIsEqualForEqual()
{
var prime = BigPrime.CreateWithoutChecks(11);
var otherPrime = BigPrime.CreateWithoutChecks(11);
Assert.AreEqual(prime.GetHashCode(), otherPrime.GetHashCode());
}
public void TestCreateWithoutChecks()
{
var rawValue = new BigInteger(1236);
var value = BigPrime.CreateWithoutChecks(rawValue);
Assert.AreEqual(rawValue, (BigInteger)value);
}
public void TestIsSafeElementFalseForNeutralElementAndCofactorOne()
{
var order = BigPrime.CreateWithoutChecks(11);
var generatorStub = 1;
var cofactor = new BigInteger(1);
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength)
{
CallBase = true
};
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Setup(alg => alg.IsElementDerived(It.IsAny <int>()))
.Returns(true);
// an element is in an unsafe subgroup if it results in neutral element when multiplied by cofactor
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Setup(alg => alg.MultiplyScalarUnchecked(It.IsAny <int>(), It.Is <BigInteger>(x => x.Equals(cofactor)), It.IsAny <int>()))
.Returns(neutralElement);
Assert.IsFalse(algebraMock.Object.IsSafeElement(neutralElement));
}
public void TestEqualsIsFalseForDifferent()
{
var prime = BigPrime.CreateWithoutChecks(11);
var otherPrime = BigPrime.CreateWithoutChecks(13);
Assert.AreNotEqual(prime, otherPrime);
}
public void TestGenerateElement()
{
var order = BigPrime.CreateWithoutChecks(7);
int orderBitLength = 3;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
int generator = 2;
var index = new BigInteger(3);
int expected = 3 * generator;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(MockBehavior.Strict, generator, order, cofactor, neutralElement, elementBitLength);
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Setup(alg => alg.MultiplyScalarUnchecked(
It.IsAny <int>(), It.Is <BigInteger>(i => i == index), It.Is <int>(i => i == orderBitLength))
)
.Returns(expected);
var result = algebraMock.Object.GenerateElement(index);
Assert.AreEqual(expected, result);
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Verify(alg => alg.MultiplyScalarUnchecked(
It.IsAny <int>(), It.Is <BigInteger>(i => i == index), It.Is <int>(i => i == orderBitLength)),
Times.Once()
);
}
public void TestCreateThrowsForNonPrimeValue()
{
var rawValue = new BigInteger(124);
Assert.Throws <ArgumentException>(
() => BigPrime.Create(rawValue, new SeededRandomNumberGenerator())
);
}
public void TestToString()
{
var prime = BigPrime.CreateWithoutChecks(13);
var expected = new BigInteger(13).ToString();
var result = prime.ToString();
Assert.AreEqual(expected, result);
}
/// <summary>
/// Initializes a new instance of <see cref="CryptoGroupAlgebra{T}"/>
/// with a given generator <paramref name="order"/>.
///
/// Checks that the given <paramref name="order"/> is prime and throws
/// a <exception cref="ArgumentException"/> if that is not the case.
/// </summary>
/// <param name="generator">Generator of the group.</param>
/// <param name="order">Order of the group's generator.</param>
/// <param name="cofactor">Cofactor of the group's generator.</param>
/// <param name="neutralElement">The neutral element of the group.</param>
/// <param name="elementBitLength">The maximum bit length of any group element.</param>
protected CryptoGroupAlgebra(T generator, BigPrime order, BigInteger cofactor, T neutralElement, int elementBitLength)
{
Generator = generator;
Order = order;
Cofactor = cofactor;
NeutralElement = neutralElement;
ElementBitLength = elementBitLength;
}
public void TestNegation()
{
var prime = BigPrime.CreateWithoutChecks(11);
var expected = new BigInteger(-11);
var result = -prime;
Assert.AreEqual(expected, result);
}
public void TestSubtractionRight()
{
var prime = BigPrime.CreateWithoutChecks(11);
var other = new BigInteger(5);
var expected = new BigInteger(-6);
var result = other - prime;
Assert.AreEqual(expected, result);
}
public void TestAdditionLeft()
{
var prime = BigPrime.CreateWithoutChecks(11);
var other = new BigInteger(5);
var expected = new BigInteger(16);
var result = prime + other;
Assert.AreEqual(expected, result);
}
public void MultiplicationRight()
{
var prime = BigPrime.CreateWithoutChecks(11);
var other = new BigInteger(5);
var expected = new BigInteger(55);
var result = other * prime;
Assert.AreEqual(expected, result);
}
public void TestGenerateRandomElement()
{
var order = BigPrime.CreateWithoutChecks(1021);
int orderBitLength = 10;
int orderByteLength = 2;
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = orderBitLength;
var expected = 7;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength)
{
CallBase = true
};
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Setup(alg => alg.MultiplyScalarUnchecked(It.IsAny <int>(), It.IsAny <BigInteger>(), It.IsAny <int>())
).Returns(expected);
var index = new BigInteger(301);
byte[] rngResponse = (index - 1).ToByteArray();
var rngMock = new Mock <RandomNumberGenerator>();
rngMock
.Setup(rng => rng.GetBytes(It.IsAny <byte[]>()))
.Callback(
new Action <byte[]>(
(buffer) => { Buffer.BlockCopy(rngResponse, 0, buffer, 0, orderByteLength); }
)
);
var result = algebraMock.Object.GenerateRandomElement(rngMock.Object);
var resultIndex = result.Item1;
var resultElement = result.Item2;
Assert.AreEqual(index, resultIndex);
Assert.AreEqual(expected, resultElement);
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Verify(
alg => alg.MultiplyScalarUnchecked(
It.Is <int>(x => x == generatorStub),
It.Is <BigInteger>(x => x == index),
It.Is <int>(x => x == orderBitLength)),
Times.Once()
);
rngMock.Verify(rng => rng.GetBytes(It.Is <byte[]>(x => x.Length == orderByteLength)), Times.Once());
}
public void TestOrderBitLength(int orderInt, int expectedBitLength)
{
var order = BigPrime.CreateWithoutChecks(orderInt);
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(MockBehavior.Strict, generatorStub, order, cofactor, neutralElement, elementBitLength);
var result = algebraMock.Object.OrderBitLength;
Assert.AreEqual(expectedBitLength, result);
}
public void TestOrderCallsAlgebra()
{
var order = BigPrime.CreateWithoutChecks(29);
var algebraMock = new Mock <ICryptoGroupAlgebra <BigInteger, int> >(MockBehavior.Strict);
algebraMock.Setup(alg => alg.Order).Returns(order);
var group = new CryptoGroup <BigInteger, int>(algebraMock.Object);
var result = group.Order;
Assert.AreEqual(order, result);
}
public void TestProperties()
{
var order = BigPrime.CreateWithoutChecks(13);
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(MockBehavior.Strict, generatorStub, order, cofactor, neutralElement, elementBitLength);
Assert.AreEqual(generatorStub, algebraMock.Object.Generator);
Assert.AreEqual(cofactor, algebraMock.Object.Cofactor);
Assert.AreEqual(neutralElement, algebraMock.Object.NeutralElement);
Assert.AreEqual(elementBitLength, algebraMock.Object.ElementBitLength);
}
public void TestMultiplyScalarRejectsNegativeScalar()
{
int element = 5;
var index = BigInteger.MinusOne;
var order = BigPrime.CreateWithoutChecks(5);
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(MockBehavior.Strict, generatorStub, order, cofactor, neutralElement, elementBitLength);
Assert.Throws <ArgumentOutOfRangeException>(
() => algebraMock.Object.MultiplyScalar(element, index)
);
}
public void TestMultiplyScalarWithSmallFactorSizeRejectsLargerFactors(int factorInt)
{
var k = new BigInteger(factorInt);
int element = 5;
int factorBitLength = 3;
var order = BigPrime.CreateWithoutChecks(5);
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(MockBehavior.Strict, generatorStub, order, cofactor, neutralElement, elementBitLength);
Assert.Throws <ArgumentOutOfRangeException>(
() => algebraMock.Object.MultiplyScalar(element, k, factorBitLength)
);
}
public void TestGenerateElementRejectsNegativeIndex()
{
var index = BigInteger.MinusOne;
var order = BigPrime.CreateWithoutChecks(5);
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength)
{
CallBase = true
};
Assert.Throws <ArgumentOutOfRangeException>(
() => algebraMock.Object.GenerateElement(index)
);
}
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);
BigInteger generator = 4;
var group = Multiplicative.MultiplicativeGroupAlgebra.CreateCryptoGroup(
prime, order, generator
);
DoDiffieHellman(group);
}
public void TestIsSafeElementFalseIfDerivedIsFalse()
{
var order = BigPrime.CreateWithoutChecks(11);
int element = 7;
var generatorStub = 1;
var cofactor = new BigInteger(2);
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength)
{
CallBase = true
};
algebraMock.Protected().As <ICryptoGroupAlgebraProtectedMembers>()
.Setup(alg => alg.IsElementDerived(It.IsAny <int>()))
.Returns(false);
Assert.IsFalse(algebraMock.Object.IsSafeElement(element));
}
public void TestEqualsCallsSpecificEquals()
{
var order = BigPrime.CreateWithoutChecks(5);
var generatorStub = 1;
var cofactor = BigInteger.One;
var neutralElement = 0;
var elementBitLength = 8;
var algebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength)
{
CallBase = true
};
algebraMock.Setup(alg => alg.Equals(It.IsAny <CryptoGroupAlgebra <int> >())).Returns(true);
var otherAlgebraMock = new Mock <CryptoGroupAlgebra <int> >(generatorStub, order, cofactor, neutralElement, elementBitLength);
Assert.IsTrue(algebraMock.Object.Equals((object)(otherAlgebraMock.Object)));
algebraMock.Verify(
alg => alg.Equals(It.Is <CryptoGroupAlgebra <int> >(x => x == otherAlgebraMock.Object)),
Times.Once()
);
}
public void TestEqualsIsFalseForUnrelatedObject()
{
var prime = BigPrime.CreateWithoutChecks(11);
Assert.AreNotEqual(prime, new object());
}
