public void TestFromRawHandleFailsOnInvalid()
{
var invalidHandle = new BigNumberHandle();
Assert.That(invalidHandle.IsInvalid);
Assert.Throws <ArgumentException>(() => SecureBigNumber.FromRawHandle(invalidHandle));
}
public void TestLength()
{
var number = SecureBigNumber.FromBigNumber(new BigNumber(0x548f07));
var expected = NumberLength.FromBitLength(23);;
Assert.That(number.Length.Equals(expected));
}
/// <summary>
/// Create a <see cref="SecureBigNumber" /> with a value
/// sampled uniformly at random less than <paramref name="range"/>.
/// </summary>
/// <param name="range">The upper bound for the randomly generated value.</param>
/// <returns>
/// New <see cref="SecureBigNumber" /> instance containing
/// the random value.
/// </returns>
public static SecureBigNumber Random(BigNumber range)
{
var result = new SecureBigNumber();
BigNumberHandle.SecureRandom(result.Handle, range.Handle);
return(result);
}
public void TestDispose()
{
var number = new SecureBigNumber();
Assert.That(!number.Handle.IsClosed);
number.Dispose();
Assert.That(number.Handle.IsClosed);
Assert.DoesNotThrow(number.Dispose);
}
/// <summary>
/// Securely computes this <see cref="BigNumber" /> to the power
/// of <paramref name="exponent"/> modulo <paramref name="modulo"/>
/// and returns the result.
///
/// Precisely, the returned value is <c>z = x^y % m</c>, where
/// <c>x</c> is the value of this <see cref="BigNumber" /> instance,
/// <c>y</c> the value of <paramref name="exponent"/> and <c>m</c> the
/// value of <paramref name="modulo"/>.
///
/// The computation is constant time for different instances of <c>this</c>
/// but fixed <paramref name="exponent"/> and <paramref name="modulo"/>
/// and uses OpenSSL's secure heap.
/// </summary>
/// <param name="exponent">The exponent which to raise this <see cref="BigNumber" /> to.</param>
/// <param name="modulo">The modulo for the exponentiation.</param>
/// <returns>
/// A <see cref="BigNumber" /> instance with value<c>z</c>.
/// </returns>
public BigNumber ModExp(SecureBigNumber exponent, BigNumber modulo)
{
using (var ctx = BigNumberContextHandle.CreateSecure())
{
var result = new BigNumber();
BigNumberHandle.SecureModExp(result.Handle, Handle, exponent.Handle, modulo.Handle, ctx);
return(result);
}
}
public void TestFromBigNumber()
{
var rawValue = 0x548f07;
var number = SecureBigNumber.FromBigNumber(new BigNumber(rawValue));
using (var expectedHandle = BigNumberHandle.Create())
{
BigNumberHandle.SetWord(expectedHandle, (ulong)rawValue);
Assert.That(BigNumberHandle.Compare(number.Handle, expectedHandle) == 0);
}
}
/// <summary>
/// Creates a <see cref="SecureBigNumber" /> instance from a valid <see cref="BigNumberHandle" />
/// to a secure OpenSSL <c>BIGNUM</c> structure. A copy of the pointed to <c>BIGNUM</c> structure
/// is made for the created instance.
/// </summary>
/// <param name="bigNumberHandle">
/// A handle to a raw OpenSSL <c>BIGNUM</c> structure with which to initialize the new <see cref="SecureBigNumber" />.
/// </param>
/// <returns>
/// A new <see cref="SecureBigNumber" /> instance with the same value as
/// referred to by <paramref name="bigNumberHandle"/>.
/// </returns>
internal static SecureBigNumber FromRawHandle(BigNumberHandle bigNumberHandle)
{
if (bigNumberHandle.IsInvalid)
{
throw new ArgumentException("The provided handle is invalid.", nameof(bigNumberHandle));
}
var bn = new SecureBigNumber();
BigNumberHandle.Copy(bn.Handle, bigNumberHandle);
return(bn);
}
public void TestConstructor()
{
var number = new SecureBigNumber();
Assert.That(BigNumberHandle.GetFlags(
number.Handle, BigNumberFlags.Secure).HasFlag(BigNumberFlags.Secure)
);
Assert.That(BigNumberHandle.GetFlags(
number.Handle, BigNumberFlags.ConstantTime).HasFlag(BigNumberFlags.ConstantTime)
);
Assert.That(!number.Handle.IsInvalid);
Assert.That(!number.Handle.IsClosed);
}
public void TestFromRawHandle()
{
using (var handle = BigNumberHandle.Create())
{
BigNumberHandle.SetWord(handle, 3);
var number = SecureBigNumber.FromRawHandle(handle);
Assert.That(BigNumberHandle.Compare(number.Handle, handle) == 0);
Assert.That(BigNumberHandle.GetFlags(
number.Handle, BigNumberFlags.Secure).HasFlag(BigNumberFlags.Secure)
);
Assert.That(BigNumberHandle.GetFlags(
number.Handle, BigNumberFlags.ConstantTime).HasFlag(BigNumberFlags.ConstantTime)
);
}
}
public void TestSecureModExp()
{
var baseRaw = 96235;
var exponentRaw = 7354;
var moduloRaw = 200001;
var resultRaw = BigInteger.ModPow(baseRaw, exponentRaw, moduloRaw);
var expected = new BigNumber(resultRaw);
var basis = new BigNumber(baseRaw);
var exponent = SecureBigNumber.FromBigNumber(new BigNumber(exponentRaw));
var modulo = new BigNumber(moduloRaw);
var result = basis.ModExp(exponent, modulo);
Assert.That(result.Equals(expected));
}
public void TestRandom()
{
var NumTests = 100;
var range = new BigNumber(0x869375a76);
for (var k = 0; k < NumTests; k++)
{
using (var number = SecureBigNumber.Random(range))
{
Assert.That(BigNumberHandle.GetFlags(
number.Handle, BigNumberFlags.Secure).HasFlag(BigNumberFlags.Secure)
);
Assert.That(BigNumberHandle.GetFlags(
number.Handle, BigNumberFlags.ConstantTime).HasFlag(BigNumberFlags.ConstantTime)
);
Assert.That(BigNumberHandle.Compare(number.Handle, range.Handle) < 0);
}
}
}
