public SRP6Client(
HashAlgorithm hashAlgorithm, BigInteger n, BigInteger g, BigInteger b,
BigInteger salt, byte[] account, byte[] passwordMd5Hex)
{
this.smallA = BigIntegerHelper.RandUnsignedBigInteger(19);
this.hashAlgorithm = hashAlgorithm;
this.n = n;
this.g = g;
this.b = b;
this.salt = salt;
this.account = account;
this.p = hashAlgorithm.ComputeHash(new byte[0]
.Concat(account)
.Concat(new[] { (byte)':' })
.Concat(passwordMd5Hex)
.ToArray());
this.a = this.CalculateA(); // A = g ^ a % N
this.x = this.CalculateX(); // X = H(s, P)
this.u = this.CalculateU(); // U = H(A, B)
this.s = this.CalculateS(); // S = (B - (k * g.ModExp(x, N))).ModExp(a + (u * x), N)
this.k = this.CalculateK();
this.m = this.CalculateM(); // H(H(N) ^ H(g), H(P), s, A, B, K)
}
public void Execute()
{
ProgressChanged(0, 1);
if (NumberOfNumbers <= 0)
{
GuiLogMessage("The number of numbers must be greater than 0.", NotificationLevel.Error);
return;
}
if (Maximum <= 0)
{
GuiLogMessage("The maximum value must be greater than 0.", NotificationLevel.Error);
return;
}
List = new BigInteger[NumberOfNumbers];
for (int i = 0; i < NumberOfNumbers; i++)
{
List[i] = BigIntegerHelper.RandomIntLimit(Maximum);
}
OnPropertyChanged("List");
ProgressChanged(1, 1);
}
public void Execute()
{
ProgressChanged(0, 1);
if (AmountOfOptions <= 0)
{
GuiLogMessage("AmountOfOptions must be a positive integer.", NotificationLevel.Error);
return;
}
if (settings.Secret)
{
// If the prover knows the secret, he can generate any requested number.
// This is represented by him simply forwarding the requested number 'Input' to the 'Output'.
Output = Input;
}
else
{
// If the prover doesn't know he secret, he doesn't know how to produce the requested number.
// He can only hope his random guess equals the requested number.
// The more rounds and the more choices there are, it will become more and more unlikely that he always guesses right.
Output = BigIntegerHelper.RandomIntLimit(AmountOfOptions);
}
OnPropertyChanged("Output");
ProgressChanged(1, 1);
}
/*
* Encryption ( g^m * r^n = (1 + m*n) * r^n mod n^2 )
* Hint: g^m = (n+1)^m = sum(k=0,m)((m over k)*n^k) = 1+m*n (mod n^2)
*/
//private BigInteger encrypt(BigInteger m, bool useRandom=true )
private BigInteger encrypt(BigInteger m)
{
if (m >= n)
{
GuiLogMessage("Message is bigger than N - this will produce a wrong result!", NotificationLevel.Warning);
}
BigInteger r;
Boolean useRandom = true;
if (useRandom)
{
while (true)
{
r = BigIntegerHelper.RandomIntLimit(n) % n;
if (BigInteger.GreatestCommonDivisor(r, n) == 1)
{
break;
}
GuiLogMessage("GCD <> 1, retrying...", NotificationLevel.Warning);
}
r = BigInteger.ModPow(r, n, n_square);
//r = cipherMul(r,n);
}
else
{
r = 1;
}
return((((n * m + 1) % n_square) * r) % n_square);
//return cipherAdd( (n * m + 1) % n_square, r );
}
public void Execute()
{
if (currentAttempt == 0)
{
RateOfSuccess = Math.Pow(settings._AmountOfOptions, -settings.AmountOfAttempts);
OnPropertyChanged("RateOfSuccess");
}
if (currentAttempt > 0 && OutputRandom != Input)
{
Success = false;
}
if (currentAttempt >= settings.AmountOfAttempts || !Success)
{
OnPropertyChanged("Success");
ProgressChanged(1, 1);
return;
}
OutputRandom = BigIntegerHelper.RandomIntLimit(settings._AmountOfOptions);
OnPropertyChanged("AmountOfOptions");
OnPropertyChanged("OutputRandom");
currentAttempt++;
ProgressChanged(currentAttempt, settings.AmountOfAttempts);
}
public void Execute()
{
if (!checkParameters())
{
return;
}
ProgressChanged(0, 100);
switch (m_Settings.Mode)
{
case 0: // create prime with m_Input bits
OutputString = this.RandomPrimeBits((int)n);
break;
case 1: // create prime with m_Input bits, MSB set
OutputString = this.RandomPrimeMSBSet((int)n);
break;
case 2: // create prime <= m_Input
OutputString = BigIntegerHelper.RandomPrimeLimit(n + 1);
break;
case 3: // search biggest prime < m_Input
OutputString = this.PreviousProbablePrime(n - 1);
break;
case 4: // search smallest prime > m_Input
OutputString = this.NextProbablePrime(n + 1);
break;
}
ProgressChanged(100, 100);
}
private void ExecuteRandomThread()
{
FireEventExecuteTest();
int i = 1;
for (; i <= m_Rounds; i++)
{
BigInteger k = BigIntegerHelper.Max(2, BigIntegerHelper.RandomIntLimit(BigInteger.Parse(m_RandomBaseTo.ToString())));
if (ExecuteWitness(i, new PrimesBigInteger(k.ToString())))
{
break;
}
}
if (i <= m_Rounds)
{
log.Info(string.Format((i == 1) ? rsc.Primetest.mr_witnessfound1 : rsc.Primetest.mr_witnessfound2, i, m_Value));
}
else
{
log.Info(string.Format((m_Rounds.IntValue == 1) ? rsc.Primetest.mr_witnessnotfound1 : rsc.Primetest.mr_witnessnotfound2, m_Rounds.IntValue, m_Value));
}
FireEventCancelTest();
}
/// <summary>
/// 计算S: S = (B - (k * g.ModExp(x, N))).ModExp(a + (u * x), N);
/// </summary>
/// <returns></returns>
private BigInteger CalculateS()
{
BigInteger s1 = this.B - BigIntegerHelper.UModPow(this.G, this.X, this.N) * lowerK;
BigInteger s2 = this.SmallA + (this.U * this.X);
BigInteger s3 = BigIntegerHelper.UModPow(s1, s2, this.N);
return(s3);
}
//private void GetDigitsAndBitsWithTimeOut(out int digits, out int bits)
//{
// int[] result = null;
// var tokenSource = new CancellationTokenSource();
// CancellationToken token = tokenSource.Token;
// int timeOut = 500; // milliseconds
// bool success;
// var task = Task.Factory.StartNew(() => result = GetDigitsAndBits(), token);
// success = task.Wait(timeOut, token);
// if (!success)
// throw new OverflowException();
// digits = result[0];
// bits = result[1];
//}
private BigInteger GetNumber()
{
//The input from the taskpane is converted to a BigNumber and is sent to the output.
if (settings.Number == null || settings.Number.Equals(""))
{
return(BigInteger.Zero);
}
return(BigIntegerHelper.ParseExpression(settings.Number));
}
/*
* Decryption using chinese remainder theorem
*/
//public BigInteger decrypt(BigInteger c)
//{
// // L_p(c^p-1)
// mp = (((BigInteger.ModPow(c, p_minus1, p_square) - 1) / p) * hp) % p;
// // L_q(c^q-1)
// mq = (((BigInteger.ModPow(c, q_minus1, q_square) - 1) / q) * hq) % q;
// // ( mp*eq + mq*ep ) % n
// return (mp * eq + mq * ep) % n;
//}
/*
* Encryption ( (1 + m*n) * r^n mod n^2 )
* Computing r^n using CRT.
*/
//public BigInteger encrypt(BigInteger m)
//{
// BigInteger r = RandomInt(keyBitLength) % n;
// mp = BigInteger.ModPow(r, n, p_square);
// mq = BigInteger.ModPow(r, n, q_square);
// r = (mp * eq2 + mq * ep2) % n_square;
// return (((n * m + 1) % n_square) * r) % n_square;
//}
/*
* Decryption ( ((c^lambda) % n^2 - 1) div n ) * lambda^(-1) ) % n
*/
private BigInteger decrypt(BigInteger c)
{
if (c >= n_square)
{
GuiLogMessage("Cipher is bigger than N^2 - this will produce a wrong result!", NotificationLevel.Warning);
}
BigInteger lambdainv = BigIntegerHelper.ModInverse(InputLambda, n);
return((((BigInteger.ModPow(c, InputLambda, n_square) - 1) / n) * lambdainv) % n);
}
/*
* DGK encryption using CRT for the owner of the private key (p,q,vp,vq).
*/
BigInteger encryptCRT(BigInteger message)
{
if (message >= u)
{
GuiLogMessage("Message is bigger than U - this will produce a wrong result!", NotificationLevel.Warning);
}
// Use Zv instead of a 2t bit number:
BigInteger r = BigIntegerHelper.RandomIntLimit(vpvq);
// Calculate in Zp and Zq instead of Zn:
BigInteger tmp_cp = BigInteger.ModPow(g, message, p) * BigInteger.ModPow(h, r, p);
BigInteger tmp_cq = BigInteger.ModPow(g, message, q) * BigInteger.ModPow(h, r, q);
return((tmp_cp * qq_inv + tmp_cq * pp_inv) % n);
}
protected override void DoExecute()
{
FireOnStart();
try
{
BigInteger second = BigInteger.Parse(m_SecondParameter.ToString());
BigInteger from = BigInteger.Parse(m_From.ToString());
BigInteger to = BigInteger.Parse(m_To.ToString());
BigInteger a, b;
for (BigInteger x = from; x <= to; x++)
{
string msg;
try
{
BigInteger gcd = BigIntegerHelper.ExtEuclid(x, second, out a, out b);
string sa = a.ToString(); if (a < 0)
{
sa = "(" + sa + ")";
}
string sb = b.ToString(); if (b < 0)
{
sb = "(" + sb + ")";
}
if (b < 0)
{
b = -b;
}
msg = String.Format("{0}*{1} + {2}*{3} = {4}", sa, x, sb, second, gcd);
}
catch (Exception ex)
{
msg = "-";
}
FireOnMessage(this, new PrimesBigInteger(x.ToString()), msg);
}
}
catch (Exception ex)
{
}
FireOnStop();
}
private void miIntegerManyFactors_Click(object sender, RoutedEventArgs e)
{
PrimesBigInteger value = null;
try
{
if (sender == miPrime)
{
value = new PrimesBigInteger(MaxValue.RandomPrimeLimit());
}
else if (sender == miBigInteger)
{
value = new PrimesBigInteger(MaxValue.RandomIntLimit());
}
else if (sender == miIntegerManyFactors)
{
int bits = Math.Max(MaxValue.BitCount() / 16, 8);
BigInteger p = MaxValue.Sqrt().RandomIntLimit();
for (int i = 0; i < 16; i++)
{
BigInteger pp = p * BigIntegerHelper.RandomPrimeBits(bits);
if (pp < MaxValue)
{
p = pp;
}
}
value = new PrimesBigInteger(p);
}
else if (sender == miTowBigFactors)
{
BigInteger a = MaxValue.Sqrt().RandomPrimeLimit();
BigInteger b = (MaxValue / a).RandomPrimeLimit();
value = new PrimesBigInteger(a * b);
}
}
catch
{
return;
}
if (value != null)
{
FireOnRandomNumberGenerated(value);
}
}
private BigInteger RandomPrimeMSBSet(int bits)
{
if (bits <= 1)
{
throw new ArithmeticException("No primes with this bitcount");
}
BigInteger limit = ((BigInteger)1) << bits;
while (true)
{
var p = this.NextProbablePrime(BigIntegerHelper.SetBit(BigIntegerHelper.RandomIntBits(bits - 1), bits - 1));
if (p < limit)
{
return(p);
}
}
}
public void Execute()
{
ProgressChanged(0, 1);
if (b < 0 || b >= x.Length)
{
GuiLogMessage("Requested message index " + b + " is illegal, it must be bigger than 0 and smaller than " + x.Length, NotificationLevel.Error);
return;
}
K = BigIntegerHelper.RandomIntLimit(N);
v = (x[b] + BigInteger.ModPow(K, e, N)) % N;
OnPropertyChanged("K");
OnPropertyChanged("v");
ProgressChanged(1, 1);
}
// not used, public/private keys are input variables for this plugin
private void generateKeys()
{
BigInteger twoPowModulusBits, n_plus1;
p = BigIntegerHelper.RandomPrimeBits(keyBitLength - (keyBitLength / 2));
q = BigIntegerHelper.RandomPrimeBits(keyBitLength / 2);
n = p * q;
// Just complete PK: n^2
n_plus1 = n + 1;
n_square = n * n;
// compute lambda
p_minus1 = p - 1;
q_minus1 = q - 1;
lambda = BigIntegerHelper.LCM(p_minus1, q_minus1);
// Compute n^(-1)
twoPowModulusBits = 1 << keyBitLength;
n_inv = BigIntegerHelper.ModInverse(n, twoPowModulusBits);
// Store the L(lambda)-part for decryption
decDiv = BigInteger.ModPow(n + 1, lambda, n_square);
decDiv = BigIntegerHelper.ModInverse(L(decDiv), n);
p_square = p * p;
q_square = q * q;
hp = BigIntegerHelper.ModInverse((BigInteger.ModPow(n + 1, p_minus1, p_square) - 1) / p, p);
hq = BigIntegerHelper.ModInverse((BigInteger.ModPow(n + 1, q_minus1, q_square) - 1) / q, q);
// for CRT
BigInteger s, t;
BigIntegerHelper.ExtEuclid(p, q, out s, out t);
ep = s * p;
eq = t * q;
// CRT Encryption:
BigIntegerHelper.ExtEuclid(p_square, q_square, out s, out t);
ep2 = s * p_square;
eq2 = t * q_square;
}
/*
* Standard DGK encryption.
*/
BigInteger encrypt(BigInteger message)
{
if (secretKeyValid)
{
return(encryptCRT(message));
}
if (message >= u)
{
GuiLogMessage("Message is bigger than U - this will produce a wrong result!", NotificationLevel.Warning);
}
//BigInteger r = BigIntegerHelper.RandomIntBits(DGK_BLINDING_T);
// Choose random number with 2t bits. But t is not part of the public key.
// Workaround: use n as upper bound. n has k bits and k>t, so n^2 has 2k bits.
BigInteger r = BigIntegerHelper.RandomIntLimit(n_square);
return(cipherAdd(cipherMul(g, message), cipherMul(h, r)));
//return ( BigInteger.ModPow(g,message,n) * BigInteger.ModPow(h,r,n) ) % n;
}
/// <summary>
/// Implementation of solutionfinding for chinese remainder theorem.
/// i.e. finding an x that fullfills
/// x = a1 (mod m1)
/// x = a2 (mod m2)
/// ...
/// </summary>
/// <param name="congruences">The congruences (a_i, m_i)</param>
/// <returns>the value that fits into all congruences</returns>
private BigInteger CRT(List <KeyValuePair <BigInteger, BigInteger> > congruences)
{
BigInteger x = 0;
for (int i = 0; i < congruences.Count; i++)
{
BigInteger k = 1;
for (int c = 0; c < congruences.Count; c++)
{
if (c != i)
{
k *= congruences[c].Value;
}
}
BigInteger r = BigIntegerHelper.ModInverse(k, congruences[i].Value);
x += congruences[i].Key * r * k;
}
return(x);
}
public void Execute()
{
BigInteger m, k;
ProgressChanged(0, 1);
if (x == null || Messages == null)
{
GuiLogMessage("Illegal array 'x' or 'messages'.", NotificationLevel.Error);
return;
}
if (x.Length != Messages.Length)
{
GuiLogMessage("Arrays 'x' and 'messages' must have the same number of entries.", NotificationLevel.Error);
return;
}
EncryptedMessages = new BigInteger[x.Length];
for (int i = 0; i < Messages.Length; i++)
{
try // can be read as parseable expression?
{
m = BigIntegerHelper.ParseExpression(Messages[i]);
}
catch (Exception ex)
{
GuiLogMessage("Error while converting '" + Messages[i] + "' to a number.", NotificationLevel.Error);
return;
}
k = BigInteger.ModPow(((v - x[i]) % N + N) % N, d, N);
EncryptedMessages[i] = (m + k) % N;
ProgressChanged(i + 1, Messages.Length);
}
OnPropertyChanged("EncryptedMessages");
}
public void PrimesGeneratorTestMethod()
{
var pluginInstance = TestHelpers.GetPluginInstance("PrimesGenerator");
var scenario = new PluginTestScenario(pluginInstance, new[] { "n", ".Mode" }, new[] { "OutputString" });
foreach (TestVector vector in testvectors)
{
if (vector.mode <= 2)
{
for (int i = 0; i < vector.count; i++)
{
object[] output = scenario.GetOutputs(new object[] { vector.input, vector.mode });
Assert.IsTrue(BigIntegerHelper.IsProbablePrime((BigInteger)output[0]), (BigInteger)output[0] + " is not a prime number in test #" + vector.n + ".");
}
}
else
{
object[] output = scenario.GetOutputs(new object[] { vector.input, vector.mode });
Assert.AreEqual(vector.output, output[0], "Unexpected value in test #" + vector.n + ".");
}
}
}
public void MakeBinaryOperandsCompatible(Type leftType, Type rightType, ref Expression leftExpression, ref Expression rightExpression)
{
if (CanBeConverted(leftType, rightType))
{
leftExpression = VelocityExpressions.ConvertIfNeeded(leftExpression, rightType);
}
else if (CanBeConverted(rightType, leftType))
{
rightExpression = VelocityExpressions.ConvertIfNeeded(rightExpression, leftType);
}
else if (leftType == typeof(string) && (rightType == typeof(char) || rightType.IsEnum))
{
rightExpression = Expression.Call(rightExpression, MethodHelpers.ToStringMethodInfo);
}
else if (rightType == typeof(string) && (leftType == typeof(char) || leftType.IsEnum))
{
leftExpression = Expression.Call(leftExpression, MethodHelpers.ToStringMethodInfo);
}
else if (leftType != rightType && TypeHelper.IsInteger(leftType) && TypeHelper.IsInteger(rightType))
{
leftExpression = BigIntegerHelper.ConvertToBigInteger(leftExpression);
rightExpression = BigIntegerHelper.ConvertToBigInteger(rightExpression);
}
}
/*
* Compute: res = E(-m)
* Computes the multiplicative inverse of some ciphertext c = E(m).
*/
private BigInteger cipherNeg(BigInteger c)
{
return(BigIntegerHelper.ModInverse(c, n_square));
}
public void Execute()
{
ProgressChanged(0, 1);
if (n < 2 * 3)
{
GuiLogMessage("Illegal Input N - DGK can not work", NotificationLevel.Error);
return;
}
n_square = n * n;
// check whether the sectret key is provided
secretKeyValid = false;
if (p != null && p != 0)
{
q = n / p;
if (vp != null && vp > 0 && vq != null && vq > 0)
{
vpvq = vp * vq; secretKeyValid = true;
}
// for faster de-/encryption:
pp_inv = BigIntegerHelper.ModInverse(p, q) * p;
qq_inv = BigIntegerHelper.ModInverse(q, p) * q;
}
if (settings.Action == 0) // Encryption
{
if (InputM is BigInteger)
{
OutputC1 = encrypt((BigInteger)InputM);
}
else if (InputM is byte[])
{
OutputC2 = BlockConvert((byte[])InputM, (u < 256)?256:u, n, encrypt, true);
}
}
else if (settings.Action == 1) // Decryption
{
if (!secretKeyValid)
{
GuiLogMessage("Can't decrypt because secret key is not available", NotificationLevel.Error);
return;
}
if (!decrypttableIsValid)
{
decrypttable = new BigInteger[(int)u];
BigInteger gv = BigInteger.ModPow(g, vp, p);
//for (int i = 0; i < (int)u; i++) decrypttable[i] = BigInteger.ModPow(gv,i,p);
decrypttableIsValid = true;
dechash = new Hashtable();
for (int i = 0; i < (int)u; i++)
{
dechash[BigInteger.ModPow(gv, i, p) % (((BigInteger)1) << 48)] = i;
}
}
if (InputM is BigInteger)
{
OutputC1 = decrypt((BigInteger)InputM);
}
else if (InputM is byte[])
{
OutputC2 = removeZeros(BlockConvert((byte[])InputM, n, (u < 256)?256:u, decrypt, false));
}
}
// Make sure the progress bar is at maximum when your Execute() finished successfully.
ProgressChanged(1, 1);
}
/// <summary>
/// Main method
/// </summary>
public void Execute()
{
BigInteger result = 0;
//First checks if both inputs are set
if (input1 != null && input2 != null)
{
ProgressChanged(0.5, 1.0);
try
{
//As the user changes the operation different outputs are calculated.
switch (settings.Operat)
{
// x + y
case 0:
result = Input1 + Input2;
break;
// x - y
case 1:
result = Input1 - Input2;
break;
//x * y
case 2:
result = Input1 * Input2;
break;
// x / y
case 3:
result = Input1 / Input2;
break;
// x ^ y
case 4:
if (Mod != 0)
{
if (Input2 >= 0)
{
result = BigInteger.ModPow(Input1, Input2, Mod);
}
else
{
result = BigInteger.ModPow(BigIntegerHelper.ModInverse(Input1, Mod), -Input2, Mod);
}
}
else
{
result = BigIntegerHelper.Pow(Input1, Input2);
}
break;
// gcd(x,y)
case 5:
result = Input1.GCD(Input2);
break;
// lcm(x,y)
case 6:
result = Input1.LCM(Input2);
break;
// sqrt(x,y)
case 7:
result = Input1.Sqrt();
break;
// modinv(x,y)
case 8:
if (Input2 != 0)
{
result = BigIntegerHelper.ModInverse(Input1, Input2);
}
else
{
result = 1 / Input1;
}
break;
// phi(x)
case 9:
result = Input1.Phi();
break;
}
Output = (Mod == 0) ? result : (((result % Mod) + Mod) % Mod);
}
catch (Exception e)
{
GuiLogMessage("Big Number fail: " + e.Message, NotificationLevel.Error);
return;
}
ProgressChanged(1.0, 1.0);
}
}
/// <summary>
/// Called by the environment to start generating of public/private keys
/// </summary>
public void Execute()
{
BigInteger p = 1, q = 1;
ProgressChanged(0, 1);
switch (settings.Source)
{
// manually enter primes
case 0:
try
{
p = BigIntegerHelper.ParseExpression(settings.P);
q = BigIntegerHelper.ParseExpression(settings.Q);
if (!BigIntegerHelper.IsProbablePrime(p))
{
GuiLogMessage(p.ToString() + " is not prime!", NotificationLevel.Error);
return;
}
if (!BigIntegerHelper.IsProbablePrime(q))
{
GuiLogMessage(q.ToString() + " is not prime!", NotificationLevel.Error);
return;
}
if (p == q)
{
GuiLogMessage("The primes P and Q can not be equal!", NotificationLevel.Error);
return;
}
}
catch (Exception ex)
{
GuiLogMessage("Invalid Big Number input: " + ex.Message, NotificationLevel.Error);
return;
}
break;
//randomly generated primes
case 1:
try
{
int keyBitLength = Convert.ToInt32(settings.KeyBitLength);
if (keyBitLength < 4)
{
GuiLogMessage("The keylength must be greater than 3.", NotificationLevel.Error);
return;
}
int i, maxtries = 10;
for (i = 0; i < maxtries; i++)
{
p = BigIntegerHelper.RandomPrimeMSBSet(keyBitLength - (keyBitLength / 2));
q = BigIntegerHelper.RandomPrimeMSBSet(keyBitLength / 2);
//GuiLogMessage("p = " + p.ToString(), NotificationLevel.Info);
//GuiLogMessage("q = " + q.ToString(), NotificationLevel.Info);
if (p != q)
{
break;
}
}
if (i == maxtries)
{
throw new Exception("Could not create two differing primes");
}
}
catch (Exception ex)
{
GuiLogMessage(ex.Message, NotificationLevel.Error);
return;
}
break;
default:
throw new Exception("Illegal Key Generation Mode");
}
N = p * q;
G = N + 1;
Lambda = (p - 1) * (q - 1);
ProgressChanged(1, 1);
}
public BigInteger[] Solve(List <BigInteger[]> matrix, BigInteger mod)
{
this.matrix = matrix;
this.mod = mod;
size = matrix.Count;
this.rowSwaps = new int[matrix.Count];
for (int i = 0; i < matrix.Count; i++)
{
rowSwaps[i] = i;
}
//make lower triangular matrix:
for (int x = 0; x < size; x++)
{
if ((matrix[x][x] % mod) == 0)
{
int y = x + 1;
while (y < size && (matrix[y][x] % mod) == 0)
{
y++;
}
if (y == size)
{
int[] rowsToDelete = new int[size - (x + 1)];
for (int i = x + 1; i < size; i++)
{
rowsToDelete[i - (x + 1)] = rowSwaps[i];
}
throw new LinearDependentException(rowsToDelete);
}
SwapRows(x, y);
}
BigInteger matrixXXinverse;
try
{
matrixXXinverse = BigIntegerHelper.ModInverse(matrix[x][x], mod);
}
catch (ArithmeticException)
{
throw new NotInvertibleException(matrix[x][x] % mod);
}
for (int y = x + 1; y < size; y++)
{
if ((matrix[y][x] % mod) != 0)
{
SubAndMultiplyWithConstantRows(x, y, (matrixXXinverse * matrix[y][x]) % mod);
}
Debug.Assert((matrix[y][x] % mod) == 0);
}
}
//make upper triangular matrix:
for (int x = (size - 1); x >= 0; x--)
{
BigInteger matrixXXinverse;
try
{
matrixXXinverse = BigIntegerHelper.ModInverse(matrix[x][x], mod);
}
catch (ArithmeticException)
{
throw new NotInvertibleException(matrix[x][x] % mod);
}
for (int y = x - 1; y >= 0; y--)
{
if ((matrix[y][x] % mod) != 0)
{
SubAndMultiplyWithConstantRows(x, y, (matrixXXinverse * matrix[y][x]) % mod);
}
Debug.Assert((matrix[y][x] % mod) == 0);
}
}
//get solution:
BigInteger[] sol = new BigInteger[size];
for (int x = 0; x < size; x++)
{
BigInteger matrixXXinverse = BigIntegerHelper.ModInverse(matrix[x][x], mod);
sol[x] = (matrixXXinverse * matrix[x][size]) % mod;
while (sol[x] < 0)
{
sol[x] += mod;
}
}
return(sol);
}
public bool ConvertToOutput(object input)
{
if (input == null)
{
return(false);
}
#region ConvertFromTypes
#region ConvertFromICryptoolStream
if (input is ICryptoolStream)
{
switch (this.settings.Converter)
{
case OutputTypes.CryptoolStreamType:
{
Output = (ICryptoolStream)input;
break;
}
case OutputTypes.StringType:
{
byte[] buffer = ICryptoolStreamToByteArray((ICryptoolStream)input);
Output = GetStringForEncoding(buffer, settings.InputEncoding);
break;
}
case OutputTypes.ByteArrayType:
{
Output = ICryptoolStreamToByteArray((ICryptoolStream)input);
break;
}
case OutputTypes.BigIntegerType:
{
byte[] buffer = ICryptoolStreamToByteArray((ICryptoolStream)input);
Output = ByteArrayToBigInteger(buffer, settings.Endianness);
break;
}
default:
GuiLogMessage("Conversion from " + input.GetType() + " to " + GetType(settings.Converter) + " is not implemented", NotificationLevel.Error);
return(false);
}
return(true);
}
#endregion
#region ConvertFromIntArray
else if (input is int[])
{
GuiLogMessage("Conversion from int[] to the chosen type is not implemented", NotificationLevel.Error);
return(false);
}
#endregion
#region ConvertFromByteArray
else if (input is byte[])
{
switch (this.settings.Converter)
{
case OutputTypes.BigIntegerType: // byte[] to BigInteger
{
byte[] temp = (byte[])input;
Output = ByteArrayToBigInteger(temp, settings.Endianness);
return(true);
}
case OutputTypes.IntType: // byte[] to int
{
try
{
byte[] temp = new byte[4];
Array.Copy((byte[])input, temp, 4);
if (settings.Endianness)
{
Array.Reverse(temp);
}
Output = BitConverter.ToInt32(temp, 0);
return(true);
}
catch (Exception e)
{
GuiLogMessage("Could not convert byte[] to integer: " + e.Message, NotificationLevel.Error);
return(false);
}
}
case OutputTypes.ShortType: // byte[] to short
{
try
{
byte[] temp = new byte[2];
Array.Copy((byte[])input, temp, 2);
if (settings.Endianness)
{
Array.Reverse(temp);
}
Output = BitConverter.ToInt16(temp, 0);
return(true);
}
catch (Exception e)
{
GuiLogMessage("Could not convert byte[] to short: " + e.Message, NotificationLevel.Error);
return(false);
}
}
case OutputTypes.ByteType: // byte[] to byte
{
try
{
Output = ((byte[])input)[0];
return(true);
}
catch (Exception e)
{
GuiLogMessage("Could not convert byte[] to byte: " + e.Message, NotificationLevel.Error);
return(false);
}
}
case OutputTypes.StringType: // byte[] to String
{
Output = GetStringForEncoding((byte[])input, settings.InputEncoding);
return(true);
}
case OutputTypes.ByteArrayType: // byte[] to byte[]
{
Output = (byte[])input;
return(true);
}
}
}
#endregion
#region ConvertFromBigInteger
else if (input is BigInteger)
{
if (this.settings.Converter == OutputTypes.ByteArrayType)
{
Output = ((BigInteger)input).ToByteArray();
return(true);
}
try
{
Output = ((BigInteger)input).ToString(this.settings.Format);
return(true);
}
catch (FormatException ex)
{
ShowFormatErrorMessage(ex);
}
}
#endregion
#region ConvertFromInt
else if (input is int)
{
if (this.settings.Converter == OutputTypes.ByteArrayType)
{
Output = BitConverter.GetBytes((int)input);
return(true);
}
try
{
Output = ((int)input).ToString(this.settings.Format);
return(true);
}
catch (FormatException ex)
{
ShowFormatErrorMessage(ex);
}
}
#endregion
#region ConvertFromShort
else if (input is short)
{
if (this.settings.Converter == OutputTypes.ByteArrayType)
{
Output = BitConverter.GetBytes((short)input);
return(true);
}
if (this.settings.Converter == OutputTypes.StringType && !string.IsNullOrEmpty(this.settings.Format))
{
try
{
Output = ((short)input).ToString(this.settings.Format);
return(true);
}
catch (FormatException ex)
{
ShowFormatErrorMessage(ex);
}
}
}
#endregion
#region ConvertFromByte
else if (input is byte)
{
if (this.settings.Converter == OutputTypes.ByteArrayType)
{
Output = new byte[] { (byte)input };
return(true);
}
if (this.settings.Converter == OutputTypes.StringType && !string.IsNullOrEmpty(this.settings.Format))
{
try
{
Output = ((byte)input).ToString(this.settings.Format);
return(true);
}
catch (FormatException ex)
{
ShowFormatErrorMessage(ex);
}
}
}
#endregion
#region ConvertFromDouble
else if (input is Double)
{
if (this.settings.Converter == OutputTypes.ByteArrayType)
{
Output = BitConverter.GetBytes((Double)input);
return(true);
}
if (this.settings.Converter == OutputTypes.StringType && !string.IsNullOrEmpty(this.settings.Format))
{
try
{
Output = ((double)input).ToString(this.settings.Format);
return(true);
}
catch (FormatException ex)
{
ShowFormatErrorMessage(ex);
}
}
}
#endregion
#region ConvertFromBool
else if (input is bool)
{
switch (this.settings.Converter)
{
case OutputTypes.BooleanType:
Output = input;
return(true);
case OutputTypes.StringType:
Output = input.ToString();
return(true);
case OutputTypes.IntType:
Output = (int)((bool)input ? 1 : 0);
return(true);
case OutputTypes.ShortType:
Output = (short)((bool)input ? 1 : 0);
return(true);
case OutputTypes.ByteType:
Output = (byte)((bool)input ? 1 : 0);
return(true);
case OutputTypes.ByteArrayType:
Output = new byte[] { (byte)(((bool)input) ? 1 : 0) };
return(true);
case OutputTypes.BigIntegerType:
Output = (BigInteger)((bool)input ? 1 : 0);
return(true);
case OutputTypes.DoubleType:
Output = (Double)((bool)input ? 1 : 0);
return(true);
case OutputTypes.CryptoolStreamType:
Output = new byte[] { (byte)(((bool)input) ? 1 : 0) };
return(true);
default:
GuiLogMessage("Could not convert from bool to chosen type: ", NotificationLevel.Error);
return(false);
}
}
#endregion
#endregion
if (input is string[])
{
string[] inputarray = (string[])input;
if (this.settings.Converter == OutputTypes.BooleanType)
{
bool[] result = new bool[inputarray.Length];
for (int i = 0; i < inputarray.Length; i++)
{
result[i] = inputarray[i] == "1";
}
Output = result;
return(true);
}
if (this.settings.Converter == OutputTypes.BigIntegerType)
{
BigInteger[] result = new BigInteger[inputarray.Length];
try // can be read as parseable expression?
{
for (int i = 0; i < inputarray.Length; i++)
{
result[i] = BigIntegerHelper.ParseExpression(inputarray[i]);
}
}
catch (Exception)
{
GuiLogMessage("Could not convert input to BigInteger", NotificationLevel.Error);
return(false);
}
Output = result;
return(true);
}
}
// the string representation is used for all upcoming operations
string inpString = Convert.ToString(input);
#region ConvertFromString
switch (this.settings.Converter) // convert to what?
{
#region ConvertToString
case OutputTypes.StringType:
{
if (settings.Numeric)
{
try // can be read as parseable expression?
{
Output = BigIntegerHelper.ParseExpression(inpString).ToString();
return(true);
}
catch (Exception) { }
}
Output = inpString;
return(true);
}
#endregion
#region ConvertToInt
case OutputTypes.IntType:
{
try // can be read as int from decimal string?
{
Output = Convert.ToInt32(inpString);
return(true);
}
catch (Exception e)
{
}
try // can be read as int from hexadecimal string?
{
Output = Convert.ToInt32(inpString, 16);
return(true);
}
catch (Exception e)
{
GuiLogMessage("Could not convert input to integer: " + e.Message, NotificationLevel.Error);
return(false);
}
}
#endregion
#region ConvertToShort
case OutputTypes.ShortType:
{
try // can be read as short from decimal string?
{
Output = Convert.ToInt16(inpString);
return(true);
}
catch (Exception e)
{
}
try // can be read as short from hexadecimal string?
{
Output = Convert.ToInt16(inpString, 16);
return(true);
}
catch (Exception e)
{
GuiLogMessage("Could not convert input to short: " + e.Message, NotificationLevel.Error);
return(false);
}
}
#endregion
#region ConvertToByte
case OutputTypes.ByteType:
{
try // can be read as byte from decimal string?
{
Output = Convert.ToByte(inpString);
return(true);
}
catch (Exception e)
{
}
try // can be read as byte hexadecimal string?
{
Output = Convert.ToByte(inpString, 16);
return(true);
}
catch (Exception e)
{
GuiLogMessage("Could not convert input to byte: " + e.Message, NotificationLevel.Error);
return(false);
}
}
#endregion
#region ConvertToDouble
case OutputTypes.DoubleType:
{
try // can be read as double?
{
Output = StringToDouble(inpString, this.settings.FormatAmer ? "en" : "de");
GuiLogMessage("Converting String to double is not safe. Digits may have been cut off.", NotificationLevel.Warning);
return(true);
}
catch (Exception e)
{
GuiLogMessage("Could not convert input to double: " + e.Message, NotificationLevel.Error);
return(false);
}
}
#endregion
#region ConvertToBigInteger
case OutputTypes.BigIntegerType:
{
try // can be read as parseable expression?
{
Output = BigIntegerHelper.ParseExpression(inpString);
return(true);
}
catch (Exception) { }
// remove all non-hex characters and parse as hexstring
byte[] result = TryMatchHex(inpString);
if (result != null)
{
Output = ByteArrayToBigInteger(result, settings.Endianness);
return(true);
}
GuiLogMessage("Could not convert input to BigInteger", NotificationLevel.Error);
return(false);
}
#endregion
#region ConvertToIntArray
#endregion
#region ConvertToByteArray
case OutputTypes.ByteArrayType:
{
if (settings.Numeric) // apply user setting concerning numeric interpretation of input (else input is read as string)
{
try // can be read as parseable expression?
{
Output = BigIntegerHelper.ParseExpression(inpString).ToByteArray();
return(true);
}
catch (Exception) { }
try // can be read as Hexstring?
{
byte[] result = TryMatchHex(inpString);
if (result != null)
{
Output = result;
return(true);
}
}
catch (Exception) { }
try // can be read as double
{
double tempDouble = StringToDouble(inpString, this.settings.FormatAmer ? "en" : "de");
byte[] temp = BitConverter.GetBytes(tempDouble);
Output = temp;
double test = BitConverter.ToDouble(temp, 0);
GuiLogMessage("Converting String to double is not safe. Digits may have been cut off: " + test.ToString(), NotificationLevel.Warning);
return(true);
}
catch (Exception) { }
}
// numeric interpretation NOT selected:
Output = GetBytesForEncoding(inpString, settings.OutputEncoding);
return(true);
}
#endregion
#region ConvertToCryptoolStream
case OutputTypes.CryptoolStreamType:
{
if (input is byte[] || input is byte || input is BigInteger || input is String)
{
OnPropertyChanged("Output");
return(true);
}
else
{
GuiLogMessage("Conversion from " + input.GetType().Name + " to CryptoolStream is not yet implemented", NotificationLevel.Error);
return(false);
}
}
#endregion
#region ConvertToAnythingLeft
default:
return(false);
#endregion
}
#endregion
}
/// <summary>
/// 计算A: A = g ^ a % N
/// </summary>
/// <returns></returns>
private BigInteger CalculateA()
{
return(BigIntegerHelper.UModPow(this.G, this.SmallA, this.N));
}
private void DoCalculateGoldbach(object o)
{
if (o == null || o.GetType() != typeof(PrimesBigInteger))
{
return;
}
PrimesBigInteger value = o as PrimesBigInteger;
if (value.Mod(PrimesBigInteger.Two).Equals(PrimesBigInteger.One)) // value is odd
{
ControlHandler.SetPropertyValue(lblGoldbachInfoCalc, "Text", string.Format(Distribution.numberline_isodd, value));
ControlHandler.SetPropertyValue(gbGoldbach, "Visibility", Visibility.Collapsed);
}
else if (value.Equals(PrimesBigInteger.Two)) // value = 2
{
ControlHandler.SetPropertyValue(lblGoldbachInfoCalc, "Text", Distribution.numberline_istwo);
ControlHandler.SetPropertyValue(gbGoldbach, "Visibility", Visibility.Collapsed);
}
else // value is even and not prime
{
int counter = 0;
int maxlines = 1000;
if (!value.IsProbablePrime(10))
{
long x = value.LongValue;
int i = 0;
long sum1 = PrimeNumbers.primes[i];
while (sum1 <= x / 2)
{
long sum2 = x - sum1;
if (BigIntegerHelper.IsProbablePrime(sum2))
//if (PrimeNumbers.isprime.Contains(sum2))
{
counter++;
if (counter < maxlines)
{
logGoldbach.Info(string.Format("{0} + {1} ", sum1, sum2));
}
else if (counter == maxlines)
{
logGoldbach.Info(string.Format(Distribution.numberline_goldbachmaxlines, maxlines));
}
if (counter % 50 == 0)
{
string fmt = (counter == 1) ? Distribution.numberline_goldbachfoundsum : Distribution.numberline_goldbachfoundsums;
ControlHandler.SetPropertyValue(lblGoldbachInfoCalc, "Text", string.Format(fmt, counter, value));
}
}
sum1 = (++i < PrimeNumbers.primes.Length) ? PrimeNumbers.primes[i] : (long)BigIntegerHelper.NextProbablePrime(sum1 + 1);
}
string fmt1 = (counter == 1) ? Distribution.numberline_goldbachfoundsum : Distribution.numberline_goldbachfoundsums;
ControlHandler.SetPropertyValue(lblGoldbachInfoCalc, "Text", string.Format(fmt1, counter, value));
ControlHandler.SetPropertyValue(gbGoldbach, "Visibility", goldbachIsOpen ? Visibility.Visible : Visibility.Collapsed);
}
}
if (GoldbachDone != null)
{
GoldbachDone();
}
}
/// <summary>
/// Called by the environment to start generating of public/private keys
/// </summary>
public void Execute()
{
BigInteger p;
BigInteger q;
BigInteger n;
BigInteger e;
BigInteger d;
ProgressChanged(0.0, 1.0);
switch (settings.Source)
{
// manual
case 0:
try
{
p = BigIntegerHelper.ParseExpression(settings.P);
q = BigIntegerHelper.ParseExpression(settings.Q);
e = BigIntegerHelper.ParseExpression(settings.E);
if (!BigIntegerHelper.IsProbablePrime(p))
{
GuiLogMessage(p.ToString() + " is not prime!", NotificationLevel.Error);
return;
}
if (!BigIntegerHelper.IsProbablePrime(q))
{
GuiLogMessage(q.ToString() + " is not prime!", NotificationLevel.Error);
return;
}
if (p == q)
{
GuiLogMessage("The primes P and Q can not be equal!", NotificationLevel.Error);
return;
}
}
catch (Exception ex)
{
GuiLogMessage("Invalid Big Number input: " + ex.Message, NotificationLevel.Error);
return;
}
try
{
D = BigIntegerHelper.ModInverse(e, (p - 1) * (q - 1));
}
catch (Exception)
{
GuiLogMessage("RSAKeyGenerator Error: E (" + e + ") can not be inverted.", NotificationLevel.Error);
return;
}
try
{
N = p * q;
E = e;
}
catch (Exception ex)
{
GuiLogMessage("Big Number fail: " + ex.Message, NotificationLevel.Error);
return;
}
break;
case 1:
try
{
n = BigIntegerHelper.ParseExpression(settings.N);
d = BigIntegerHelper.ParseExpression(settings.D);
e = BigIntegerHelper.ParseExpression(settings.E);
}
catch (Exception ex)
{
GuiLogMessage("Invalid Big Number input: " + ex.Message, NotificationLevel.Error);
return;
}
try
{
N = n;
E = e;
D = d;
}
catch (Exception ex)
{
GuiLogMessage("Big Number fail: " + ex.Message, NotificationLevel.Error);
return;
}
break;
//randomly generated
case 2:
try
{
n = BigInteger.Parse(this.settings.Range);
switch (this.settings.RangeType)
{
case 0: // n = number of bits for primes
if ((int)n <= 2)
{
GuiLogMessage("Value for n has to be greater than 2.", NotificationLevel.Error);
return;
}
if (n >= 1024)
{
GuiLogMessage("Please note that the generation of prime numbers with " + n + " bits may take some time...", NotificationLevel.Warning);
}
// calculate the number of expected tries for the indeterministic prime number generation using the density of primes in the given region
BigInteger limit = ((BigInteger)1) << (int)n;
limittries = (int)(BigInteger.Log(limit) / 6);
expectedtries = 2 * limittries;
tries = 0;
p = this.RandomPrimeBits((int)n);
tries = limittries; limittries = expectedtries;
do
{
q = this.RandomPrimeBits((int)n);
} while (p == q);
break;
case 1: // n = upper limit for primes
default:
if (n <= 4)
{
GuiLogMessage("Value for n has to be greater than 4", NotificationLevel.Error);
return;
}
p = BigIntegerHelper.RandomPrimeLimit(n + 1);
ProgressChanged(0.5, 1.0);
do
{
q = BigIntegerHelper.RandomPrimeLimit(n + 1);
} while (p == q);
break;
}
}
catch
{
GuiLogMessage("Please enter an integer value for n.", NotificationLevel.Error);
return;
}
BigInteger phi = (p - 1) * (q - 1);
// generate E for the given values of p and q
bool found = false;
foreach (var ee in new BigInteger[] { 3, 5, 7, 11, 17, 65537 })
{
if (ee < phi && ee.GCD(phi) == 1)
{
E = ee; found = true; break;
}
}
if (!found)
{
for (int i = 0; i < 1000; i++)
{
e = BigIntegerHelper.RandomIntLimit(phi);
if (e >= 2 && e.GCD(phi) == 1)
{
E = e; found = true; break;
}
}
}
if (!found)
{
GuiLogMessage("Could not generate a valid E for p=" + p + " and q=" + q + ".", NotificationLevel.Error);
return;
}
N = p * q;
D = BigIntegerHelper.ModInverse(E, phi);
break;
//using x509 certificate
case 3:
try
{
X509Certificate2 cert;
RSAParameters par;
if (this.settings.Password != "")
{
GuiLogMessage("Password entered. Try getting public and private key", NotificationLevel.Info);
cert = new X509Certificate2(settings.CertificateFile, settings.Password, X509KeyStorageFlags.Exportable);
if (cert == null || cert.PrivateKey == null)
{
throw new Exception("Private Key of X509Certificate could not be fetched");
}
RSACryptoServiceProvider provider = (RSACryptoServiceProvider)cert.PrivateKey;
par = provider.ExportParameters(true);
}
else
{
GuiLogMessage("No Password entered. Try loading public key only", NotificationLevel.Info);
cert = new X509Certificate2(settings.CertificateFile);
if (cert == null || cert.PublicKey == null || cert.PublicKey.Key == null)
{
throw new Exception("Private Key of X509Certificate could not be fetched");
}
RSACryptoServiceProvider provider = (RSACryptoServiceProvider)cert.PublicKey.Key;
par = provider.ExportParameters(false);
}
try
{
N = new BigInteger(par.Modulus);
}
catch (Exception ex)
{
GuiLogMessage("Could not get N from certificate: " + ex.Message, NotificationLevel.Warning);
}
try
{
E = new BigInteger(par.Exponent);
}
catch (Exception ex)
{
GuiLogMessage("Could not get E from certificate: " + ex.Message, NotificationLevel.Warning);
}
try
{
if (this.settings.Password != "")
{
D = new BigInteger(par.D);
}
else
{
D = 0;
}
}
catch (Exception ex)
{
GuiLogMessage("Could not get D from certificate: " + ex.Message, NotificationLevel.Warning);
}
}
catch (Exception ex)
{
GuiLogMessage("Could not load the selected certificate: " + ex.Message, NotificationLevel.Error);
}
break;
}
ProgressChanged(1.0, 1.0);
}
