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); } } }