/// <summary>
/// Runs the EEA on two BigIntegers
/// </summary>
/// <param name="A">Quotient A</param>
/// <param name="B">Quotient B</param>
/// <returns>Return a BigIntEuclidean object that contains the result in the variables X, Y, and GCD</returns>
///
/// <remarks>
/// Implemented from pseudocode on <a href="http://en.wikipedia.org/wiki/Extended_Euclidean_algorithm"/>Wikipedia
/// </remarks>
public static BigIntEuclidean Calculate(BigInteger A, BigInteger B)
{
BigInteger x = BigInteger.Zero;
BigInteger lastX = BigInteger.One;
BigInteger y = BigInteger.One;
BigInteger lastY = BigInteger.Zero;
while (!B.Equals(BigInteger.Zero))
{
BigInteger[] quotientAndRemainder = A.DivideAndRemainder(B);
BigInteger quotient = quotientAndRemainder[0];
BigInteger temp = A;
A = B;
B = quotientAndRemainder[1];
temp = x;
x = lastX.Subtract(quotient.Multiply(x));
lastX = temp;
temp = y;
y = lastY.Subtract(quotient.Multiply(y));
lastY = temp;
}
BigIntEuclidean result = new BigIntEuclidean();
result.X = lastX;
result.Y = lastY;
result.GCD = A;
return result;
}
/** @see BigInteger#andNot(BigInteger) */
public static BigInteger AndNot(BigInteger val, BigInteger that)
{
if (that.Sign == 0) {
return val;
}
if (val.Sign == 0) {
return BigInteger.Zero;
}
if (val.Equals(BigInteger.MinusOne)) {
return that.Not();
}
if (that.Equals(BigInteger.MinusOne)) {
return BigInteger.Zero;
}
//if val == that, return 0
if (val.Sign > 0) {
if (that.Sign > 0) {
return AndNotPositive(val, that);
} else {
return AndNotPositiveNegative(val, that);
}
} else {
if (that.Sign > 0) {
return AndNotNegativePositive(val, that);
} else {
return AndNotNegative(val, that);
}
}
}
/** @see BigInteger#and(BigInteger) */
public static BigInteger And(BigInteger val, BigInteger that)
{
if (that.Sign == 0 || val.Sign == 0) {
return BigInteger.Zero;
}
if (that.Equals(BigInteger.MinusOne)) {
return val;
}
if (val.Equals(BigInteger.MinusOne)) {
return that;
}
if (val.Sign > 0) {
if (that.Sign > 0) {
return AndPositive(val, that);
} else {
return AndDiffSigns(val, that);
}
} else {
if (that.Sign > 0) {
return AndDiffSigns(that, val);
} else if (val.numberLength > that.numberLength) {
return AndNegative(val, that);
} else {
return AndNegative(that, val);
}
}
}
public static BigInteger ValidatePublicValue(BigInteger N, BigInteger val)
{
val = val.Mod(N);
// Check that val % N != 0
if (val.Equals(BigInteger.Zero))
throw new CryptoException("Invalid public value: 0");
return val;
}
/// <summary>
/// Returns a new BigInteger whose value is ~Value.
/// <para>The result of this operation is <c>-this-1</c>.</para>
/// </summary>
///
/// <param name="Value">Value to be Not'ed</param>
///
/// <returns>Returns <c>~Value</c></returns>
internal static BigInteger Not(BigInteger Value)
{
if (Value._sign == 0)
return BigInteger.MinusOne;
if (Value.Equals(BigInteger.MinusOne))
return BigInteger.Zero;
int[] resDigits = new int[Value._numberLength + 1];
int i;
if (Value._sign > 0)
{
// ~val = -val + 1
if (Value._digits[Value._numberLength - 1] != -1)
{
for (i = 0; Value._digits[i] == -1; i++)
{
;
}
}
else
{
for (i = 0; (i < Value._numberLength) && (Value._digits[i] == -1); i++)
{
;
}
if (i == Value._numberLength)
{
resDigits[i] = 1;
return new BigInteger(-Value._sign, i + 1, resDigits);
}
}
// Here a carry 1 was generated
}
else
{
// ~val = -val - 1
for (i = 0; Value._digits[i] == 0; i++)
resDigits[i] = -1;
}
// Now, the carry/borrow can be absorbed
resDigits[i] = Value._digits[i] + Value._sign;
// Copying the remaining unchanged digit
for (i++; i < Value._numberLength; i++)
resDigits[i] = Value._digits[i];
return new BigInteger(-Value._sign, i, resDigits);
}
private static bool VerifyCtorInt32(Int32 value)
{
bool ret = true;
BigInteger bigInteger;
bigInteger = new BigInteger(value);
if (!bigInteger.Equals(value))
{
Console.WriteLine("Expected BigInteger {0} to be equal to Int32 {1}", bigInteger, value);
ret = false;
}
if (String.CompareOrdinal(value.ToString(), bigInteger.ToString()) != 0)
{
Console.WriteLine("Int32.ToString() and BigInteger.ToString() on {0} and {1} should be equal", value, bigInteger);
ret = false;
}
if (value != (Int32)bigInteger)
{
Console.WriteLine("Expected BigInteger {0} to be equal to Int32 {1}", bigInteger, value);
ret = false;
}
if (value != Int32.MaxValue)
{
if ((Int32)(value + 1) != (Int32)(bigInteger + 1))
{
Console.WriteLine("Adding 1 to both {0} and {1} should remain equal", value, bigInteger);
ret = false;
}
}
if (value != Int32.MinValue)
{
if ((Int32)(value - 1) != (Int32)(bigInteger - 1))
{
Console.WriteLine("Subtracting 1 from both {0} and {1} should remain equal", value, bigInteger);
ret = false;
}
}
Assert.True(VerifyBigintegerUsingIdentities(bigInteger, 0 == value), " Verification Failed");
return ret;
}
/**
* Generate a suitable blind factor for the public key the generator was initialised with.
*
* @return a random blind factor
*/
public BigInteger GenerateBlindingFactor()
{
if (key == null)
throw new InvalidOperationException("generator not initialised");
BigInteger m = key.Modulus;
int length = m.BitLength - 1; // must be less than m.BitLength
BigInteger factor;
BigInteger gcd;
do
{
factor = new BigInteger(length, random);
gcd = factor.Gcd(m);
}
while (factor.Sign == 0 || factor.Equals(BigInteger.One) || !gcd.Equals(BigInteger.One));
return factor;
}
public override bool Equals(object o)
{
if (this == o)
{
return(true);
}
if (o == null || !(o is ECKeyPair))
{
return(false);
}
var ecKeyPair = (ECKeyPair)o;
if (!_privateKey?.Equals(ecKeyPair._privateKey) ?? ecKeyPair._privateKey != null)
{
return(false);
}
return(_publicKey?.Equals(ecKeyPair._publicKey) ?? ecKeyPair._publicKey == null);
}
/// <summary>
/// Computes the square root of a BigInteger modulo a prime employing the Shanks-Tonelli algorithm
/// </summary>
///
/// <param name="X">The value out of which we extract the square root</param>
/// <param name="P">The prime modulus that determines the underlying field</param>
///
/// <returns>Returns a number <c>B</c> such that B^2 = A (mod P) if <c>A</c> is a quadratic residue modulo <c>P</c></returns>
public static BigInteger Ressol(BigInteger X, BigInteger P)
{
BigInteger v = null;
if (X.CompareTo(ZERO) < 0)
X = X.Add(P);
if (X.Equals(ZERO))
return ZERO;
if (P.Equals(TWO))
return X;
// p = 3 mod 4
if (P.TestBit(0) && P.TestBit(1))
{
if (Jacobi(X, P) == 1)
{
// a quadr. residue mod p
v = P.Add(ONE); // v = p+1
v = v.ShiftRight(2); // v = v/4
return X.ModPow(v, P); // return a^v mod p
}
throw new ArgumentException("No quadratic residue: " + X + ", " + P);
}
long t = 0;
// initialization
// compute k and s, where p = 2^s (2k+1) +1
BigInteger k = P.Subtract(ONE); // k = p-1
long s = 0;
while (!k.TestBit(0))
{ // while k is even
s++; // s = s+1
k = k.ShiftRight(1); // k = k/2
}
k = k.Subtract(ONE); // k = k - 1
k = k.ShiftRight(1); // k = k/2
// initial values
BigInteger r = X.ModPow(k, P); // r = a^k mod p
BigInteger n = r.Multiply(r).Remainder(P); // n = r^2 % p
n = n.Multiply(X).Remainder(P); // n = n * a % p
r = r.Multiply(X).Remainder(P); // r = r * a %p
if (n.Equals(ONE))
{
return r;
}
// non-quadratic residue
BigInteger z = TWO; // z = 2
while (Jacobi(z, P) == 1)
{
// while z quadratic residue
z = z.Add(ONE); // z = z + 1
}
v = k;
v = v.Multiply(TWO); // v = 2k
v = v.Add(ONE); // v = 2k + 1
BigInteger c = z.ModPow(v, P); // c = z^v mod p
// iteration
while (n.CompareTo(ONE) == 1)
{ // n > 1
k = n; // k = n
t = s; // t = s
s = 0;
while (!k.Equals(ONE))
{ // k != 1
k = k.Multiply(k).Mod(P); // k = k^2 % p
s++; // s = s + 1
}
t -= s; // t = t - s
if (t == 0)
{
throw new ArgumentException("No quadratic residue: " + X + ", " + P);
}
v = ONE;
for (long i = 0; i < t - 1; i++)
{
v = v.ShiftLeft(1); // v = 1 * 2^(t - 1)
}
c = c.ModPow(v, P); // c = c^v mod p
r = r.Multiply(c).Remainder(P); // r = r * c % p
c = c.Multiply(c).Remainder(P); // c = c^2 % p
n = n.Multiply(c).Mod(P); // n = n * c % p
}
return r;
}
public void Equals_BI_on_same_is_true()
{
BigInteger i = new BigInteger(1, 0x1, 0x2, 0x3);
BigInteger j = new BigInteger(1, 0x1, 0x2, 0x3);
Expect(i.Equals(j));
}
private static bool VerifyCtorByteArray(byte[] value, UInt64 expectedValue)
{
bool ret = true;
BigInteger bigInteger;
bigInteger = new BigInteger(value);
if (!bigInteger.Equals(expectedValue))
{
Console.WriteLine("Expected BigInteger {0} to be equal to UInt64 {1}", bigInteger, expectedValue);
ret = false;
}
if (!expectedValue.ToString().Equals(bigInteger.ToString(), StringComparison.OrdinalIgnoreCase))
{
Console.WriteLine("UInt64.ToString() and BigInteger.ToString()");
ret = false;
}
if (expectedValue != (UInt64)bigInteger)
{
Console.WriteLine("BigInteger casted to a UInt64");
ret = false;
}
if (expectedValue != UInt64.MaxValue)
{
if ((UInt64)(expectedValue + 1) != (UInt64)(bigInteger + 1))
{
Console.WriteLine("BigInteger added to 1");
ret = false;
}
}
if (expectedValue != UInt64.MinValue)
{
if ((UInt64)(expectedValue - 1) != (UInt64)(bigInteger - 1))
{
Console.WriteLine("BigInteger subtracted by 1");
ret = false;
}
}
Assert.True(VerifyCtorByteArray(value), " Verification Failed");
return ret;
}
/// <summary>
/// Verifies that the server's proof value matches the value
/// calculated by the client.
/// </summary>
/// <param name="serverProof">The 20-byte server proof.</param>
/// <exception cref="ArgumentOutOfRangeException">Thrown if
/// the server proof value is not exactly 20 bytes.</exception>
/// <exception cref="InvalidOperationException">Thrown if the object has not
/// yet been initialized.</exception>
/// <remarks>
/// This method should be called after the <see cref="LoginProof(byte[], int, int, byte[], byte[])">LoginProof</see> method.
/// </remarks>
/// <returns><b>True</b> if the server proof is valid;
/// otherwise <b>false</b>.</returns>
public bool VerifyServerProof(byte[] serverProof)
{
if (serverProof.Length != 20)
throw new ArgumentOutOfRangeException(Resources.nlsServerProof20);
MemoryStream ms_m2 = new MemoryStream(92);
BinaryWriter bw = new BinaryWriter(ms_m2);
bw.Write(EnsureArrayLength(A.GetBytes(), 32));
bw.Write(m1.GetBytes());
bw.Write(k);
byte[] client_m2_data = ms_m2.GetBuffer();
ms_m2.Close();
byte[] client_hash_m2 = s_sha.ComputeHash(client_m2_data);
BigInteger client_m2 = new BigInteger(client_hash_m2);
BigInteger server_m2 = new BigInteger(serverProof);
Debug.WriteLine(client_m2.ToHexString(), "Client");
Debug.WriteLine(server_m2.ToHexString(), "Server");
return client_m2.Equals(server_m2);
}
public void Equals_BI_on_different_is_false()
{
BigInteger i = new BigInteger(1, 0x1, 0x2, 0x3);
BigInteger j = new BigInteger(1, 0x1, 0x2, 0x4);
Expect(i.Equals(j),False);
}
public void ConstructorIRandom()
{
// regression test for HARMONY-1047
Assert.Throws<OverflowException>(() => new BigInteger(Int32.MaxValue, (Random) null));
bi = new BigInteger(70, rand);
bi2 = new BigInteger(70, rand);
Assert.IsTrue(bi.CompareTo(zero) >= 0, "Random number is negative");
Assert.IsTrue(bi.CompareTo(twoToTheSeventy) < 0, "Random number is too big");
Assert.IsTrue(!bi.Equals(bi2), "Two random numbers in a row are the same (might not be a bug but it very likely is)");
Assert.IsTrue(new BigInteger(0, rand).Equals(BigInteger.Zero), "Not zero");
}
protected bool Equals(
ECPrivateKeyParameters other)
{
return(d.Equals(other.d) && base.Equals(other));
}
public void doTestCurve(
string name)
{
// ECGenParameterSpec ecSpec = new ECGenParameterSpec(name);
ECDomainParameters ecSpec = GetCurveParameters(name);
IAsymmetricCipherKeyPairGenerator g = GeneratorUtilities.GetKeyPairGenerator("ECDH");
// g.initialize(ecSpec, new SecureRandom());
g.Init(new ECKeyGenerationParameters(ecSpec, new SecureRandom()));
//
// a side
//
AsymmetricCipherKeyPair aKeyPair = g.GenerateKeyPair();
// KeyAgreement aKeyAgree = KeyAgreement.getInstance("ECDHC");
IBasicAgreement aKeyAgree = AgreementUtilities.GetBasicAgreement("ECDHC");
aKeyAgree.Init(aKeyPair.Private);
//
// b side
//
AsymmetricCipherKeyPair bKeyPair = g.GenerateKeyPair();
// KeyAgreement bKeyAgree = KeyAgreement.getInstance("ECDHC");
IBasicAgreement bKeyAgree = AgreementUtilities.GetBasicAgreement("ECDHC");
bKeyAgree.Init(bKeyPair.Private);
//
// agreement
//
// aKeyAgree.doPhase(bKeyPair.Public, true);
// bKeyAgree.doPhase(aKeyPair.Public, true);
//
// BigInteger k1 = new BigInteger(aKeyAgree.generateSecret());
// BigInteger k2 = new BigInteger(bKeyAgree.generateSecret());
BigInteger k1 = aKeyAgree.CalculateAgreement(bKeyPair.Public);
BigInteger k2 = bKeyAgree.CalculateAgreement(aKeyPair.Public);
if (!k1.Equals(k2))
{
Fail("2-way test failed");
}
//
// public key encoding test
//
// byte[] pubEnc = aKeyPair.Public.getEncoded();
byte[] pubEnc = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(aKeyPair.Public).GetDerEncoded();
// KeyFactory keyFac = KeyFactory.getInstance("ECDH");
// X509EncodedKeySpec pubX509 = new X509EncodedKeySpec(pubEnc);
// ECPublicKey pubKey = (ECPublicKey)keyFac.generatePublic(pubX509);
ECPublicKeyParameters pubKey = (ECPublicKeyParameters)PublicKeyFactory.CreateKey(pubEnc);
// if (!pubKey.getW().Equals(((ECPublicKey)aKeyPair.Public).getW()))
if (!pubKey.Q.Equals(((ECPublicKeyParameters)aKeyPair.Public).Q))
{
Fail("public key encoding (Q test) failed");
}
// TODO Put back in?
// if (!(pubKey.getParams() is ECNamedCurveSpec))
// {
// Fail("public key encoding not named curve");
// }
//
// private key encoding test
//
// byte[] privEnc = aKeyPair.Private.getEncoded();
byte[] privEnc = PrivateKeyInfoFactory.CreatePrivateKeyInfo(aKeyPair.Private).GetDerEncoded();
// PKCS8EncodedKeySpec privPKCS8 = new PKCS8EncodedKeySpec(privEnc);
// ECPrivateKey privKey = (ECPrivateKey)keyFac.generatePrivate(privPKCS8);
ECPrivateKeyParameters privKey = (ECPrivateKeyParameters)PrivateKeyFactory.CreateKey(privEnc);
// if (!privKey.getS().Equals(((ECPrivateKey)aKeyPair.Private).getS()))
if (!privKey.D.Equals(((ECPrivateKeyParameters)aKeyPair.Private).D))
{
Fail("private key encoding (S test) failed");
}
// TODO Put back in?
// if (!(privKey.getParams() is ECNamedCurveSpec))
// {
// Fail("private key encoding not named curve");
// }
//
// ECNamedCurveSpec privSpec = (ECNamedCurveSpec)privKey.getParams();
// if (!(privSpec.GetName().Equals(name) || privSpec.GetName().Equals(CurveNames.get(name))))
// {
// Fail("private key encoding wrong named curve. Expected: "
// + CurveNames[name] + " got " + privSpec.GetName());
// }
}
/// <summary>
/// Returns a new BigInteger whose value is <c>this ^ Value</c>
/// </summary>
///
/// <param name="Value">Value to be Xor'ed </param>
/// <param name="X">The second value</param>
///
/// <returns>Returns <c>this ^ Value</c></returns>
internal static BigInteger Xor(BigInteger Value, BigInteger X)
{
if (X._sign == 0)
return Value;
if (Value._sign == 0)
return X;
if (X.Equals(BigInteger.MinusOne))
return Value.Not();
if (Value.Equals(BigInteger.MinusOne))
return X.Not();
if (Value._sign > 0)
{
if (X._sign > 0)
{
if (Value._numberLength > X._numberLength)
return XorPositive(Value, X);
else
return XorPositive(X, Value);
}
else
{
return XorDiffSigns(Value, X);
}
}
else
{
if (X._sign > 0)
return XorDiffSigns(X, Value);
else if (X.FirstNonzeroDigit > Value.FirstNonzeroDigit)
return XorNegative(X, Value);
else
return XorNegative(Value, X);
}
}
protected bool Equals(
DsaPrivateKeyParameters other)
{
return(x.Equals(other.x) && base.Equals(other));
}
/**
* FIPS 186-4 C.3.2 Enhanced Miller-Rabin Probabilistic Primality Test
*
* Run several iterations of the Miller-Rabin algorithm with randomly-chosen bases. This is an
* alternative to {@link #isMRProbablePrime(BigInteger, SecureRandom, int)} that provides more
* information about a composite candidate, which may be useful when generating or validating
* RSA moduli.
*
* @param candidate
* the {@link BigInteger} instance to test for primality.
* @param random
* the source of randomness to use to choose bases.
* @param iterations
* the number of randomly-chosen bases to perform the test for.
* @return an {@link MROutput} instance that can be further queried for details.
*/
public static MROutput EnhancedMRProbablePrimeTest(BigInteger candidate, SecureRandom random, int iterations)
{
CheckCandidate(candidate, "candidate");
if (random == null)
{
throw new ArgumentNullException("random");
}
if (iterations < 1)
{
throw new ArgumentException("must be > 0", "iterations");
}
if (candidate.BitLength == 2)
{
return(MROutput.ProbablyPrime());
}
if (!candidate.TestBit(0))
{
return(MROutput.ProvablyCompositeWithFactor(Two));
}
BigInteger w = candidate;
BigInteger wSubOne = candidate.Subtract(One);
BigInteger wSubTwo = candidate.Subtract(Two);
int a = wSubOne.GetLowestSetBit();
BigInteger m = wSubOne.ShiftRight(a);
for (int i = 0; i < iterations; ++i)
{
BigInteger b = BigIntegers.CreateRandomInRange(Two, wSubTwo, random);
BigInteger g = b.Gcd(w);
if (g.CompareTo(One) > 0)
{
return(MROutput.ProvablyCompositeWithFactor(g));
}
BigInteger z = b.ModPow(m, w);
if (z.Equals(One) || z.Equals(wSubOne))
{
continue;
}
bool primeToBase = false;
BigInteger x = z;
for (int j = 1; j < a; ++j)
{
z = z.ModPow(Two, w);
if (z.Equals(wSubOne))
{
primeToBase = true;
break;
}
if (z.Equals(One))
{
break;
}
x = z;
}
if (!primeToBase)
{
if (!z.Equals(One))
{
x = z;
z = z.ModPow(Two, w);
if (!z.Equals(One))
{
x = z;
}
}
g = x.Subtract(One).Gcd(w);
if (g.CompareTo(One) > 0)
{
return(MROutput.ProvablyCompositeWithFactor(g));
}
return(MROutput.ProvablyCompositeNotPrimePower());
}
}
return(MROutput.ProbablyPrime());
}
/**
* Computes the <code>[τ]</code>-adic window NAF of an element
* <code>λ</code> of <code><b>Z</b>[τ]</code>.
* @param mu The parameter μ of the elliptic curve.
* @param lambda The element <code>λ</code> of
* <code><b>Z</b>[τ]</code> of which to compute the
* <code>[τ]</code>-adic NAF.
* @param width The window width of the resulting WNAF.
* @param pow2w 2<sup>width</sup>.
* @param tw The auxiliary value <code>t<sub>w</sub></code>.
* @param alpha The <code>α<sub>u</sub></code>'s for the window width.
* @return The <code>[τ]</code>-adic window NAF of
* <code>λ</code>.
*/
public static sbyte[] TauAdicWNaf(sbyte mu, ZTauElement lambda,
sbyte width, BigInteger pow2w, BigInteger tw, ZTauElement[] alpha)
{
if (!((mu == 1) || (mu == -1)))
{
throw new ArgumentException("mu must be 1 or -1");
}
BigInteger norm = Norm(mu, lambda);
// Ceiling of log2 of the norm
int log2Norm = norm.BitLength;
// If length(TNAF) > 30, then length(TNAF) < log2Norm + 3.52
int maxLength = log2Norm > 30 ? log2Norm + 4 + width : 34 + width;
// The array holding the TNAF
sbyte[] u = new sbyte[maxLength];
// 2^(width - 1)
BigInteger pow2wMin1 = pow2w.ShiftRight(1);
// Split lambda into two BigIntegers to simplify calculations
BigInteger r0 = lambda.u;
BigInteger r1 = lambda.v;
int i = 0;
// while lambda <> (0, 0)
while (!((r0.Equals(BigInteger.Zero)) && (r1.Equals(BigInteger.Zero))))
{
// if r0 is odd
if (r0.TestBit(0))
{
// uUnMod = r0 + r1*tw Mod 2^width
BigInteger uUnMod
= r0.Add(r1.Multiply(tw)).Mod(pow2w);
sbyte uLocal;
// if uUnMod >= 2^(width - 1)
if (uUnMod.CompareTo(pow2wMin1) >= 0)
{
uLocal = (sbyte)uUnMod.Subtract(pow2w).IntValue;
}
else
{
uLocal = (sbyte)uUnMod.IntValue;
}
// uLocal is now in [-2^(width-1), 2^(width-1)-1]
u[i] = uLocal;
bool s = true;
if (uLocal < 0)
{
s = false;
uLocal = (sbyte)-uLocal;
}
// uLocal is now >= 0
if (s)
{
r0 = r0.Subtract(alpha[uLocal].u);
r1 = r1.Subtract(alpha[uLocal].v);
}
else
{
r0 = r0.Add(alpha[uLocal].u);
r1 = r1.Add(alpha[uLocal].v);
}
}
else
{
u[i] = 0;
}
BigInteger t = r0;
if (mu == 1)
{
r0 = r1.Add(r0.ShiftRight(1));
}
else
{
// mu == -1
r0 = r1.Subtract(r0.ShiftRight(1));
}
r1 = t.ShiftRight(1).Negate();
i++;
}
return(u);
}
/**
* Computes the <code>τ</code>-adic NAF (non-adjacent form) of an
* element <code>λ</code> of <code><b>Z</b>[τ]</code>.
* @param mu The parameter <code>μ</code> of the elliptic curve.
* @param lambda The element <code>λ</code> of
* <code><b>Z</b>[τ]</code>.
* @return The <code>τ</code>-adic NAF of <code>λ</code>.
*/
public static sbyte[] TauAdicNaf(sbyte mu, ZTauElement lambda)
{
if (!((mu == 1) || (mu == -1)))
{
throw new ArgumentException("mu must be 1 or -1");
}
BigInteger norm = Norm(mu, lambda);
// Ceiling of log2 of the norm
int log2Norm = norm.BitLength;
// If length(TNAF) > 30, then length(TNAF) < log2Norm + 3.52
int maxLength = log2Norm > 30 ? log2Norm + 4 : 34;
// The array holding the TNAF
sbyte[] u = new sbyte[maxLength];
int i = 0;
// The actual length of the TNAF
int length = 0;
BigInteger r0 = lambda.u;
BigInteger r1 = lambda.v;
while (!((r0.Equals(BigInteger.Zero)) && (r1.Equals(BigInteger.Zero))))
{
// If r0 is odd
if (r0.TestBit(0))
{
u[i] = (sbyte)BigInteger.Two.Subtract((r0.Subtract(r1.ShiftLeft(1))).Mod(Four)).IntValue;
// r0 = r0 - u[i]
if (u[i] == 1)
{
r0 = r0.ClearBit(0);
}
else
{
// u[i] == -1
r0 = r0.Add(BigInteger.One);
}
length = i;
}
else
{
u[i] = 0;
}
BigInteger t = r0;
BigInteger s = r0.ShiftRight(1);
if (mu == 1)
{
r0 = r1.Add(s);
}
else
{
// mu == -1
r0 = r1.Subtract(s);
}
r1 = t.ShiftRight(1).Negate();
i++;
}
length++;
// Reduce the TNAF array to its actual length
sbyte[] tnaf = new sbyte[length];
Array.Copy(u, 0, tnaf, 0, length);
return(tnaf);
}
public bool Equals(ECFieldElement other)
{
return(Value.Equals(other.Value));
}
/// <summary>
/// Compute the next probable prime greater than <c>N</c> with the specified certainty
/// </summary>
///
/// <param name="X">An integer number</param>
/// <param name="Certainty">The certainty that the generated number is prime</param>
///
/// <returns>Returns the next prime greater than <c>N</c></returns>
public static BigInteger NextProbablePrime(BigInteger X, int Certainty)
{
if (X.Signum() < 0 || X.Signum() == 0 || X.Equals(ONE))
return TWO;
BigInteger result = X.Add(ONE);
// Ensure an odd number
if (!result.TestBit(0))
result = result.Add(ONE);
while (true)
{
// Do cheap "pre-test" if applicable
if (result.BitLength > 6)
{
long r = result.Remainder(BigInteger.ValueOf(SMALL_PRIME_PRODUCT)).ToInt64();
if ((r % 3 == 0) || (r % 5 == 0) || (r % 7 == 0) ||
(r % 11 == 0) || (r % 13 == 0) || (r % 17 == 0) ||
(r % 19 == 0) || (r % 23 == 0) || (r % 29 == 0) ||
(r % 31 == 0) || (r % 37 == 0) || (r % 41 == 0))
{
result = result.Add(TWO);
continue; // Candidate is composite; try another
}
}
// All candidates of bitLength 2 and 3 are prime by this point
if (result.BitLength < 4)
return result;
// The expensive test
if (result.IsProbablePrime(Certainty))
return result;
result = result.Add(TWO);
}
}
public virtual bool Match(
object obj)
{
X509Certificate c = obj as X509Certificate;
if (c == null)
{
return(false);
}
if (!MatchExtension(authorityKeyIdentifier, c, X509Extensions.AuthorityKeyIdentifier))
{
return(false);
}
if (basicConstraints != -1)
{
int bc = c.GetBasicConstraints();
if (basicConstraints == -2)
{
if (bc != -1)
{
return(false);
}
}
else
{
if (bc < basicConstraints)
{
return(false);
}
}
}
if (certificate != null && !certificate.Equals(c))
{
return(false);
}
if (certificateValid != null && !c.IsValid(certificateValid.Value))
{
return(false);
}
if (extendedKeyUsage != null)
{
IList eku = c.GetExtendedKeyUsage();
// Note: if no extended key usage set, all key purposes are implicitly allowed
if (eku != null)
{
foreach (DerObjectIdentifier oid in extendedKeyUsage)
{
if (!eku.Contains(oid.Id))
{
return(false);
}
}
}
}
if (issuer != null && !issuer.Equivalent(c.IssuerDN, true))
{
return(false);
}
if (keyUsage != null)
{
bool[] ku = c.GetKeyUsage();
// Note: if no key usage set, all key purposes are implicitly allowed
if (ku != null)
{
for (int i = 0; i < 9; ++i)
{
if (keyUsage[i] && !ku[i])
{
return(false);
}
}
}
}
if (policy != null)
{
Asn1OctetString extVal = c.GetExtensionValue(X509Extensions.CertificatePolicies);
if (extVal == null)
{
return(false);
}
Asn1Sequence certPolicies = Asn1Sequence.GetInstance(
X509ExtensionUtilities.FromExtensionValue(extVal));
if (policy.Count < 1 && certPolicies.Count < 1)
{
return(false);
}
bool found = false;
foreach (PolicyInformation pi in certPolicies)
{
if (policy.Contains(pi.PolicyIdentifier))
{
found = true;
break;
}
}
if (!found)
{
return(false);
}
}
if (privateKeyValid != null)
{
Asn1OctetString extVal = c.GetExtensionValue(X509Extensions.PrivateKeyUsagePeriod);
if (extVal == null)
{
return(false);
}
PrivateKeyUsagePeriod pkup = PrivateKeyUsagePeriod.GetInstance(
X509ExtensionUtilities.FromExtensionValue(extVal));
DateTime dt = privateKeyValid.Value;
DateTime notAfter = pkup.NotAfter.ToDateTime();
DateTime notBefore = pkup.NotBefore.ToDateTime();
if (dt.CompareTo(notAfter) > 0 || dt.CompareTo(notBefore) < 0)
{
return(false);
}
}
if (serialNumber != null && !serialNumber.Equals(c.SerialNumber))
{
return(false);
}
if (subject != null && !subject.Equivalent(c.SubjectDN, true))
{
return(false);
}
if (!MatchExtension(subjectKeyIdentifier, c, X509Extensions.SubjectKeyIdentifier))
{
return(false);
}
if (subjectPublicKey != null && !subjectPublicKey.Equals(GetSubjectPublicKey(c)))
{
return(false);
}
if (subjectPublicKeyAlgID != null &&
!subjectPublicKeyAlgID.Equals(GetSubjectPublicKey(c).AlgorithmID))
{
return(false);
}
return(true);
}
public virtual bool Equals(
FpFieldElement other)
{
return(q.Equals(other.q) && base.Equals(other));
}
/// <summary>
/// Computes the bit per bit operator between this number and the given one.
/// </summary>
///
/// <param name="Value">The value to be And'ed with X</param>
/// <param name="X">The second value</param>
///
/// <returns>
/// Returns a new BigInteger whose value is <c>Value & X</c>.
/// </returns>
internal static BigInteger And(BigInteger Value, BigInteger X)
{
if (X._sign == 0 || Value._sign == 0)
return BigInteger.Zero;
if (X.Equals(BigInteger.MinusOne))
return Value;
if (Value.Equals(BigInteger.MinusOne))
return X;
if (Value._sign > 0)
{
if (X._sign > 0)
return AndPositive(Value, X);
else
return AndDiffSigns(Value, X);
}
else
{
if (X._sign > 0)
return AndDiffSigns(X, Value);
else if (Value._numberLength > X._numberLength)
return AndNegative(Value, X);
else
return AndNegative(X, Value);
}
}
private static void CheckNormaliseBaseTenResult(ExpandedDouble orig, NormalisedDecimal result)
{
String sigDigs = result.GetSignificantDecimalDigits();
BigInteger frac = orig.GetSignificand();
while (frac.BitLength() + orig.GetBinaryExponent() < 200)
{
frac = frac * (BIG_POW_10);
}
int binaryExp = orig.GetBinaryExponent() - orig.GetSignificand().BitLength();
String origDigs = (frac << (binaryExp + 1)).ToString(10);
if (!origDigs.StartsWith(sigDigs))
{
throw new AssertionException("Expected '" + origDigs + "' but got '" + sigDigs + "'.");
}
double dO = Double.Parse("0." + origDigs.Substring(sigDigs.Length));
double d1 = Double.Parse(result.GetFractionalPart().ToString());
BigInteger subDigsO = new BigInteger((int)(dO * 32768 + 0.5));
BigInteger subDigsB = new BigInteger((int)(d1 * 32768 + 0.5));
if (subDigsO.Equals(subDigsB))
{
return;
}
BigInteger diff = (subDigsB - subDigsO).Abs();
if (diff.IntValue() > 100)
{
// 100/32768 ~= 0.003
throw new AssertionException("minor mistake");
}
}
public void ConstructorIBytes()
{
var myByteArray = new byte[] { (byte)0xFF, (byte)0xFE };
bi = new BigInteger(1, myByteArray);
IsTrue(bi.Equals(BigInteger.Zero.SetBit(16).Subtract(two)), "Incorrect value for pos number");
bi = new BigInteger(-1, myByteArray);
IsTrue(bi.Equals(BigInteger.Zero.SetBit(16).Subtract(two).Negate()), "Incorrect value for neg number");
myByteArray = new byte[] { (byte)0, (byte)0 };
bi = new BigInteger(0, myByteArray);
IsTrue(bi.Equals(zero), "Incorrect value for zero");
myByteArray = new byte[] { (byte)1 };
Throw(() => new BigInteger(0, myByteArray), "BigInteger: failed constructor test");
}
/// <summary>
/// Validates a Warcraft III server signature.
/// </summary>
/// <param name="serverSignature">The server signature from
/// Battle.net's SID_AUTH_INFO message.</param>
/// <param name="ipAddress">The IPv4 address of the server
/// currently connected-to.</param>
/// <returns><b>True</b> if the signature matches;
/// otherwise <b>false</b>.</returns>
/// <exception cref="ArgumentOutOfRangeException">Thrown if
/// the server signature is not exactly 128 bytes.</exception>
public static bool ValidateServerSignature(byte[] serverSignature,
byte[] ipAddress)
{
// code based on iago's code.
if (serverSignature.Length != 128)
throw new ArgumentOutOfRangeException(Resources.nlsSrvSig128);
BigInteger key = new BigInteger(new byte[] { 0, 1, 0, 1 } /* ReverseArray(new BigInteger((ulong)SignatureKey).GetBytes()) */);
BigInteger mod = new BigInteger(ServerModulus, 16);
BigInteger sig = new BigInteger(ReverseArray(serverSignature));
byte[] result = sig.ModPow(key, mod).GetBytes();
BigInteger res = new BigInteger(ReverseArray(result));
MemoryStream ms_res = new MemoryStream(result.Length);
ms_res.Write(ipAddress, 0, 4);
for (int i = 4; i < result.Length; i++)
ms_res.WriteByte(0xbb);
ms_res.Seek(-1, SeekOrigin.Current);
ms_res.WriteByte(0x0b);
BigInteger cor_res = new BigInteger(ms_res.GetBuffer());
ms_res.Close();
return cor_res.Equals(res);
}
public virtual X509CrlEntry GetRevokedCertificate(
BigInteger serialNumber)
{
IEnumerable certs = c.GetRevokedCertificateEnumeration();
X509Name previousCertificateIssuer = IssuerDN;
foreach (CrlEntry entry in certs)
{
X509CrlEntry crlEntry = new X509CrlEntry(entry, isIndirect, previousCertificateIssuer);
if (serialNumber.Equals(entry.UserCertificate.Value))
{
return crlEntry;
}
previousCertificateIssuer = crlEntry.GetCertificateIssuer();
}
return null;
}
private static void VerifyComparison(BigInteger x, BigInteger y, int expectedResult)
{
bool expectedEquals = 0 == expectedResult;
bool expectedLessThan = expectedResult < 0;
bool expectedGreaterThan = expectedResult > 0;
Assert.Equal(expectedEquals, x == y);
Assert.Equal(expectedEquals, y == x);
Assert.Equal(!expectedEquals, x != y);
Assert.Equal(!expectedEquals, y != x);
Assert.Equal(expectedEquals, x.Equals(y));
Assert.Equal(expectedEquals, y.Equals(x));
Assert.Equal(expectedEquals, x.Equals((Object)y));
Assert.Equal(expectedEquals, y.Equals((Object)x));
VerifyCompareResult(expectedResult, x.CompareTo(y), "x.CompareTo(y)");
VerifyCompareResult(-expectedResult, y.CompareTo(x), "y.CompareTo(x)");
IComparable comparableX = x;
IComparable comparableY = y;
VerifyCompareResult(expectedResult, comparableX.CompareTo(y), "comparableX.CompareTo(y)");
VerifyCompareResult(-expectedResult, comparableY.CompareTo(x), "comparableY.CompareTo(x)");
VerifyCompareResult(expectedResult, BigInteger.Compare(x, y), "Compare(x,y)");
VerifyCompareResult(-expectedResult, BigInteger.Compare(y, x), "Compare(y,x)");
if (expectedEquals)
{
Assert.Equal(x.GetHashCode(), y.GetHashCode());
Assert.Equal(x.ToString(), y.ToString());
}
Assert.Equal(x.GetHashCode(), x.GetHashCode());
Assert.Equal(y.GetHashCode(), y.GetHashCode());
Assert.Equal(expectedLessThan, x < y);
Assert.Equal(expectedGreaterThan, y < x);
Assert.Equal(expectedGreaterThan, x > y);
Assert.Equal(expectedLessThan, y > x);
Assert.Equal(expectedLessThan || expectedEquals, x <= y);
Assert.Equal(expectedGreaterThan || expectedEquals, y <= x);
Assert.Equal(expectedGreaterThan || expectedEquals, x >= y);
Assert.Equal(expectedLessThan || expectedEquals, y >= x);
}
private static void VerifyComparison(BigInteger x, bool IsXNegative, BigInteger y, bool IsYNegative, int expectedResult)
{
bool expectedEquals = 0 == expectedResult;
bool expectedLessThan = expectedResult < 0;
bool expectedGreaterThan = expectedResult > 0;
if (IsXNegative == true)
{
x = x * -1;
}
if (IsYNegative == true)
{
y = y * -1;
}
Assert.Equal(expectedEquals, x == y);
Assert.Equal(expectedEquals, y == x);
Assert.Equal(!expectedEquals, x != y);
Assert.Equal(!expectedEquals, y != x);
Assert.Equal(expectedEquals, x.Equals(y));
Assert.Equal(expectedEquals, y.Equals(x));
Assert.Equal(expectedEquals, x.Equals((Object)y));
Assert.Equal(expectedEquals, y.Equals((Object)x));
VerifyCompareResult(expectedResult, x.CompareTo(y), "x.CompareTo(y)");
VerifyCompareResult(-expectedResult, y.CompareTo(x), "y.CompareTo(x)");
if (expectedEquals)
{
Assert.Equal(x.GetHashCode(), y.GetHashCode());
Assert.Equal(x.ToString(), y.ToString());
}
Assert.Equal(x.GetHashCode(), x.GetHashCode());
Assert.Equal(y.GetHashCode(), y.GetHashCode());
Assert.Equal(expectedLessThan, x < y);
Assert.Equal(expectedGreaterThan, y < x);
Assert.Equal(expectedGreaterThan, x > y);
Assert.Equal(expectedLessThan, y > x);
Assert.Equal(expectedLessThan || expectedEquals, x <= y);
Assert.Equal(expectedGreaterThan || expectedEquals, y <= x);
Assert.Equal(expectedGreaterThan || expectedEquals, x >= y);
Assert.Equal(expectedLessThan || expectedEquals, y >= x);
}
public void Equals_BI_on_null_is_false()
{
BigInteger i = new BigInteger(1, 0x1, 0x2, 0x3);
Expect(i.Equals(null), False);
}
private void MultiplyOverField(int blockSizeBits, byte[] x, byte[] y, byte[] x_mult_y)
{
//Multiplication over GF(2^m), GF(2^256), GF(2^512) with correspondent extension polynomials:
///
/// GF(2^128) | x^128 + x^7 + x^2 + x
/// GF(2^256) | x^256 + x^10 + x^5 + x^2 + 1
/// GF(2^512) | x^512 + x^8 + x^5 + x^2 + 1
///
//Thanks to João H de A Franco script. https://jhafranco.com/2012/02/17/multiplication-over-the-binary-finite-field-gf2m/
byte[] copy1 = new byte[cipher.GetBlockSize()];
byte[] copy2 = new byte[cipher.GetBlockSize()];
Array.Copy(x, 0, copy1, 0, cipher.GetBlockSize());
Array.Copy(y, 0, copy2, 0, cipher.GetBlockSize());
Array.Reverse(copy1);
Array.Reverse(copy2);
BigInteger mask1;
BigInteger mask2;
BigInteger polyred;
switch (blockSizeBits)
{
case 128:
mask1 = mask1_128;
mask2 = mask2_128;
polyred = polyred_128;
break;
case 256:
mask1 = mask1_256;
mask2 = mask2_256;
polyred = polyred_256;
break;
case 512:
mask1 = mask1_512;
mask2 = mask2_512;
polyred = polyred_512;
break;
default:
mask1 = mask1_128;
mask2 = mask2_128;
polyred = polyred_128;
break;
}
BigInteger p = BigInteger.Zero;
BigInteger p1 = new BigInteger(1, copy1);
BigInteger p2 = new BigInteger(1, copy2);
while (!p2.Equals(BigInteger.Zero))
{
if (p2.And(BigInteger.One).Equals(BigInteger.One))
{
p = p.Xor(p1);
}
p1 = p1.ShiftLeft(1);
if (!p1.And(mask1).Equals(BigInteger.Zero))
{
p1 = p1.Xor(polyred);
}
p2 = p2.ShiftRight(1);
}
byte[] got = p.And(mask2).ToByteArrayUnsigned();
Array.Clear(x_mult_y, 0, cipher.GetBlockSize());
Array.Copy(got, 0, x_mult_y, 0, got.Length);
}
public static object BIDivide(BigInteger n, BigInteger d)
{
if (d.Equals(BigInteger.ZERO))
throw new ArithmeticException("Divide by zero");
//BigInteger gcd = n.gcd(d);
BigInteger gcd = n.Gcd(d);
if (gcd.Equals(BigInteger.ZERO))
return 0;
//n = n.divide(gcd);
//d = d.divide(gcd);
n = n / gcd;
d = d / gcd;
if (d.Equals(BigInteger.ONE))
return reduce(n);
//return new Ratio((d.signum() < 0 ? n.negate() : n),
// (d.signum() < 0 ? d.negate() : d));
return new Ratio((d.Signum < 0 ? -n : n), d.Abs());
}
protected bool Equals(
FpCurve other)
{
return(base.Equals(other) && q.Equals(other.q));
}
protected bool Equals(
DsaPublicKeyParameters other)
{
return(y.Equals(other.y) && base.Equals(other));
}
public void ConstructorBytes()
{
var myByteArray = new byte[] { (byte)0x00, (byte)0xFF, (byte)0xFE };
bi = new BigInteger(myByteArray);
Assert.IsTrue(bi.Equals(BigInteger.Zero.SetBit(16).Subtract(two)), "Incorrect value for pos number");
myByteArray = new byte[] { (byte)0xFF, (byte)0xFE };
bi = new BigInteger(myByteArray);
Assert.IsTrue(bi.Equals(minusTwo), "Incorrect value for neg number");
}
/// <summary>
/// Computes the value of the Jacobi symbol (A|B).
/// </summary>
///
/// <param name="A">The integer value</param>
/// <param name="B">The integer value</param>
///
/// <returns>Returns value of the jacobi symbol (A|B)</returns>
public static int Jacobi(BigInteger A, BigInteger B)
{
BigInteger a, b, v;
long k = 1;
// test trivial cases
if (B.Equals(ZERO))
{
a = A.Abs();
return a.Equals(ONE) ? 1 : 0;
}
if (!A.TestBit(0) && !B.TestBit(0))
return 0;
a = A;
b = B;
if (b.Signum() == -1)
{ // b < 0
b = b.Negate();
if (a.Signum() == -1)
k = -1;
}
v = ZERO;
while (!b.TestBit(0))
{
v = v.Add(ONE);
b = b.Divide(TWO);
}
if (v.TestBit(0))
k = k * _jacobiTable[a.ToInt32() & 7];
if (a.Signum() < 0)
{
if (b.TestBit(1))
k = -k;
a = a.Negate();
}
// main loop
while (a.Signum() != 0)
{
v = ZERO;
while (!a.TestBit(0))
{ // a is even
v = v.Add(ONE);
a = a.Divide(TWO);
}
if (v.TestBit(0))
k = k * _jacobiTable[b.ToInt32() & 7];
if (a.CompareTo(b) < 0)
{
// swap and correct intermediate result
BigInteger x = a;
a = b;
b = x;
if (a.TestBit(1) && b.TestBit(1))
k = -k;
}
a = a.Subtract(b);
}
return b.Equals(ONE) ? (int)k : 0;
}
public void ConstructorIBytes()
{
var myByteArray = new byte[] { (byte)0xFF, (byte)0xFE };
bi = new BigInteger(1, myByteArray);
Assert.IsTrue(bi.Equals(BigInteger.Zero.SetBit(16).Subtract(two)), "Incorrect value for pos number");
bi = new BigInteger(-1, myByteArray);
Assert.IsTrue(bi.Equals(BigInteger.Zero.SetBit(16).Subtract(two).Negate()), "Incorrect value for neg number");
myByteArray = new byte[] { (byte)0, (byte)0 };
bi = new BigInteger(0, myByteArray);
Assert.IsTrue(bi.Equals(zero), "Incorrect value for zero");
myByteArray = new byte[] { (byte)1 };
Assert.Throws<FormatException>(() => new BigInteger(0, myByteArray));
}
private static void VerifyComparison(BigInteger x, UInt64 y, int expectedResult)
{
bool expectedEquals = 0 == expectedResult;
bool expectedLessThan = expectedResult < 0;
bool expectedGreaterThan = expectedResult > 0;
Assert.Equal(expectedEquals, x == y);
Assert.Equal(expectedEquals, y == x);
Assert.Equal(!expectedEquals, x != y);
Assert.Equal(!expectedEquals, y != x);
Assert.Equal(expectedEquals, x.Equals(y));
VerifyCompareResult(expectedResult, x.CompareTo(y), "x.CompareTo(y)");
if (expectedEquals)
{
Assert.Equal(x.GetHashCode(), ((BigInteger)y).GetHashCode());
Assert.Equal(x.ToString(), ((BigInteger)y).ToString());
}
Assert.Equal(x.GetHashCode(), x.GetHashCode());
Assert.Equal(((BigInteger)y).GetHashCode(), ((BigInteger)y).GetHashCode());
Assert.Equal(expectedLessThan, x < y);
Assert.Equal(expectedGreaterThan, y < x);
Assert.Equal(expectedGreaterThan, x > y);
Assert.Equal(expectedLessThan, y > x);
Assert.Equal(expectedLessThan || expectedEquals, x <= y);
Assert.Equal(expectedGreaterThan || expectedEquals, y <= x);
Assert.Equal(expectedGreaterThan || expectedEquals, x >= y);
Assert.Equal(expectedLessThan || expectedEquals, y >= x);
}
/**
* return a sqrt root - the routine verifies that the calculation
* returns the right value - if none exists it returns null.
*/
public override ECFieldElement Sqrt()
{
if (IsZero || IsOne)
{
return(this);
}
if (!q.TestBit(0))
{
throw Platform.CreateNotImplementedException("even value of q");
}
if (q.TestBit(1)) // q == 4m + 3
{
BigInteger e = q.ShiftRight(2).Add(BigInteger.One);
return(CheckSqrt(new FpFieldElement(q, r, x.ModPow(e, q))));
}
if (q.TestBit(2)) // q == 8m + 5
{
BigInteger t1 = x.ModPow(q.ShiftRight(3), q);
BigInteger t2 = ModMult(t1, x);
BigInteger t3 = ModMult(t2, t1);
if (t3.Equals(BigInteger.One))
{
return(CheckSqrt(new FpFieldElement(q, r, t2)));
}
// TODO This is constant and could be precomputed
BigInteger t4 = BigInteger.Two.ModPow(q.ShiftRight(2), q);
BigInteger y = ModMult(t2, t4);
return(CheckSqrt(new FpFieldElement(q, r, y)));
}
// q == 8m + 1
BigInteger legendreExponent = q.ShiftRight(1);
if (!(x.ModPow(legendreExponent, q).Equals(BigInteger.One)))
{
return(null);
}
BigInteger X = this.x;
BigInteger fourX = ModDouble(ModDouble(X));
;
BigInteger k = legendreExponent.Add(BigInteger.One), qMinusOne = q.Subtract(BigInteger.One);
BigInteger U, V;
do
{
BigInteger P;
do
{
P = BigInteger.Arbitrary(q.BitLength);
}while(P.CompareTo(q) >= 0 ||
!ModReduce(P.Multiply(P).Subtract(fourX)).ModPow(legendreExponent, q).Equals(qMinusOne));
BigInteger[] result = LucasSequence(P, X, k);
U = result[0];
V = result[1];
if (ModMult(V, V).Equals(fourX))
{
return(new FpFieldElement(q, r, ModHalfAbs(V)));
}
}while(U.Equals(BigInteger.One) || U.Equals(qMinusOne));
return(null);
}
public static object BIDivide(BigInteger n, BigInteger d)
{
if (d.Equals(BigInteger.ZERO))
throw new ArithmeticException("Divide by zero");
BigInteger gcd = n.Gcd(d);
if (gcd.Equals(BigInteger.ZERO))
return BigInt.ZERO;
n = n / gcd;
d = d / gcd;
if (d.Equals(BigInteger.ONE))
return BigInt.fromBigInteger(n);
else if (d.Equals(BigInteger.NEGATIVE_ONE))
return BigInt.fromBigInteger(n.Negate());
return new Ratio((d.Signum < 0 ? -n : n), d.Abs());
}
public void EqualsTest3()
{
BigInteger target = new BigInteger(); // TODO: Initialize to an appropriate value
long other = 0; // TODO: Initialize to an appropriate value
bool expected = false; // TODO: Initialize to an appropriate value
bool actual;
actual = target.Equals(other);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
