public void ShouldReturnNullWhenCurrentIsNull()
{
var subject = new Random800_90();
var result = subject.GetDifferentBitStringOfSameSize(null);
Assert.IsNull(result);
}
public void ShouldVerifyRandomlyGeneratedSignatures(ModeValues mode, DigestSizes digest, Curve curveEnum)
{
var nonces = new List <BigInteger>();
var hashFunction = new HashFunction(mode, digest);
var shaFactory = new NativeShaFactory();
var sha = shaFactory.GetShaInstance(hashFunction);
var hmacFactory = new HmacFactory(shaFactory);
var hmac = hmacFactory.GetHmacInstance(hashFunction);
var subject = new EccDsa(sha, new DeterministicNonceProvider(hmac), EntropyProviderTypes.Random);
var curveFactory = new EccCurveFactory();
var curve = curveFactory.GetCurve(curveEnum);
var domainParams = new EccDomainParameters(curve);
var key = subject.GenerateKeyPair(domainParams).KeyPair;
var rand = new Random800_90();
for (var i = 0; i < 100; i++)
{
var message = rand.GetRandomBitString(1024);
var signature = subject.Sign(domainParams, key, message).Signature;
var verify = subject.Verify(domainParams, key, message, signature);
nonces.Add(signature.R);
Assert.IsTrue(verify.Success, verify.ErrorMessage);
}
// Check nonces for uniqueness
Assert.AreEqual(nonces.Count, nonces.Distinct().Count(), "Repeated nonce detected");
}
public void ShouldReturnNullWhenCurrentIsZeroLength()
{
var subject = new Random800_90();
var zeroLengthBitString = new BitString(0);
var result = subject.GetDifferentBitStringOfSameSize(zeroLengthBitString);
Assert.IsNull(result);
}
public void ShouldReturnSelectedLength(int length)
{
var subject = new Random800_90();
var result = subject.GetRandomBitString(length);
Assert.That(result != null);
Assert.AreEqual(length, result.BitLength);
}
public void ShouldReturnZeroLengthBitStringForZeroOrLessLengths(int length)
{
var subject = new Random800_90();
var result = subject.GetRandomBitString(length);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.BitLength);
}
public void ShouldReturnCorrectNumberOfCharacters(int length)
{
var subject = new Random800_90();
var result = subject.GetRandomString(length);
Assert.AreEqual(length, result.Length);
}
public void ShouldReturnCorrectNumberOfAlphaCharacters(int length)
{
var subject = new Random800_90();
var result = subject.GetRandomAlphaCharacters(length);
Assert.IsTrue(Regex.IsMatch(result, @"^[a-zA-Z]+$"));
Assert.AreEqual(length, result.Length);
}
public void ShouldReturnNothingOutsideOfRange(int min, int max, int iterations)
{
var subject = new Random800_90();
for (int i = 0; i < iterations; i++)
{
var result = subject.GetRandomInt(min, max);
Assert.IsTrue(result >= 0 && result <= 1);
}
}
/// <summary>
/// B.1.1 from FIPS 186-4. This is equivalent to B.1.2, the other KeyGeneration method.
/// </summary>
/// <param name="domainParameters"></param>
/// <returns></returns>
public FfcKeyPairGenerateResult GenerateKeyPair(FfcDomainParameters domainParameters)
{
var L = new BitString(domainParameters.P).BitLength;
var N = new BitString(domainParameters.Q).BitLength;
// Shouldn't really be necessary but just in case
if (!DSAHelper.VerifyLenPair(L, N))
{
return(new FfcKeyPairGenerateResult("Invalid L, N pair"));
}
var rand = new Random800_90();
var c = rand.GetRandomBitString(N + 64).ToPositiveBigInteger();
var x = (c % (domainParameters.Q - 1)) + 1;
var y = BigInteger.ModPow(domainParameters.G, x, domainParameters.P);
return(new FfcKeyPairGenerateResult(new FfcKeyPair(x, y)));
}
public void ShouldGenerateAndVerifySuccessfully(string keyString, string messageString, string expectedMacString)
{
BitString key = new BitString(keyString);
BitString message = new BitString(messageString);
BitString expectedMac = new BitString(expectedMacString);
int macLength = expectedMac.BitLength;
Random800_90 rand = new Random800_90();
var badMac = rand.GetDifferentBitStringOfSameSize(expectedMac);
var generateResult = _subject.Generate(key, message, macLength);
var goodValidateResult = _subject.Verify(key, message, generateResult.Mac);
var badValidateResult = _subject.Verify(key, message, badMac);
Assert.IsTrue(generateResult.Success, "Successful generate");
Assert.AreEqual(expectedMac.ToHex(), generateResult.Mac.ToHex(), "Generate MAC");
Assert.IsTrue(goodValidateResult.Success, "Verify success");
Assert.IsFalse(badValidateResult.Success, "Verify failure");
}
public void ShouldEncryptDecrypt(int ptLen, int aadLen, int keyLen)
{
var rand = new Random800_90();
var plaintext = rand.GetRandomBitString(ptLen);
var aad = rand.GetRandomBitString(aadLen);
var key = rand.GetRandomBitString(keyLen);
var iv = rand.GetRandomBitString(96);
var param = new AeadModeBlockCipherParameters(BlockCipherDirections.Encrypt, iv, key, plaintext, aad, 0);
var result = _subject.ProcessPayload(param);
Assert.IsTrue(result.Success);
var param2 = new AeadModeBlockCipherParameters(BlockCipherDirections.Decrypt, iv, key, result.Result, aad, new BitString(0));
var result2 = _subject.ProcessPayload(param2);
Assert.IsTrue(result.Success);
}
public void PositiveModuloShouldAlwaysBePositive()
{
var rand = new Random800_90();
for (var i = 0; i < 100; i++)
{
var a = rand.GetRandomBigInteger(BigInteger.Pow(2, 1024));
var b = rand.GetRandomBigInteger(BigInteger.Pow(2, 1024) + 1, BigInteger.Pow(2, 2048));
var c = rand.GetRandomBigInteger(BigInteger.Pow(2, 2048));
// b is always greater than a
var result = (a - b).PosMod(c);
var negativeResult = (a - b) % c;
Assert.GreaterOrEqual(result, BigInteger.Zero);
// result - negativeResult should be a multiple of c.
Assert.AreEqual(BigInteger.Zero, (result + BigInteger.Abs(negativeResult)) % c);
}
}
/// <summary>
/// C.3.1 Probabilistic Primality Check, Miller-Rabin Algorithm
/// </summary>
/// <param name="n">Number</param>
/// <param name="k">Iterations</param>
/// <returns>True if probably prime. False if composite.</returns>
public static bool MillerRabin(BigInteger n, int k)
{
if (n < 2)
{
return(false);
}
if (n.IsEven)
{
return(false);
}
var s = n - 1;
while (s.IsEven)
{
s >>= 1;
}
var rand = new Random800_90();
for (var i = 0; i < k; i++)
{
var a = rand.GetRandomBigInteger(n - 1) + 1;
var temp = s;
var mod = BigInteger.ModPow(a, temp, n);
while (temp != n - 1 && mod != 1 && mod != n - 1)
{
mod = (mod * mod) % n;
temp = temp * 2;
}
if (mod != n - 1 && temp.IsEven)
{
return(false);
}
}
return(true);
}
