public static string ByteArrayToBase58(this byte[] ba)
{
byte[] tmp = ba;
Array.Reverse(tmp);
byte[] positiveBa;
if (tmp[tmp.Length - 1] >= 0x80)
{
positiveBa = new byte[ba.Length + 1];
Array.Copy(tmp, positiveBa, tmp.Length);
}
else positiveBa = tmp;
BigInteger addrremain = new BigInteger(positiveBa);
if (addrremain<0) throw new Exception("Negative? I wont positive");
StringBuilder rv = new StringBuilder(100);
while (addrremain.CompareTo(BigInteger.Zero) > 0)
{
var remainder = addrremain % 58;
addrremain = addrremain / 58;
rv.Insert(0, B58[(int) remainder]);
}
// handle leading zeroes
foreach (byte b in ba)
{
if (b != 0) break;
rv = rv.Insert(0, '1');
}
string result = rv.ToString();
return result;
}
public static string Encode(byte[] plaintext)
{
ContractsCommon.NotNull(plaintext, "plaintext");
ContractsCommon.ResultIsNonNull<string>();
var plaintextArr = new byte[plaintext.Length + 1];
Array.Copy(plaintext, 0, plaintextArr, 1, plaintext.Length);
Array.Reverse(plaintextArr);
var workingValue = new BigInteger(plaintextArr);
StringBuilder sb = new StringBuilder(plaintext.Length * 138 / 100 + 1);
while (workingValue.CompareTo(BigInteger.Zero) > 0)
{
BigInteger remainder;
workingValue = BigInteger.DivRem(workingValue, Base, out remainder);
sb.Append(Alphabet[(int)remainder]);
}
Contract.Assert(workingValue.Sign >= 0);
//sb.Insert(0, Alphabet[(int)workingValue]);
for (int i = 0; i < plaintext.Length && plaintext[i] == 0; ++i)
{
sb.Append(Alphabet[0]);
}
var retVal = new char[sb.Length];
sb.CopyTo(0, retVal, 0, sb.Length);
Array.Reverse(retVal);
return new string(retVal);
}
/**
* An implementation of the RSASP method: Assuming that the designated
* RSA private key is a valid one, this method computes a signature
* representative for a designated message representative signed
* by the holder of the designated RSA private key.
*
* @param K the RSA private key.
* @param m the message representative: an integer between
* 0 and n - 1, where n
* is the RSA modulus.
* @return the signature representative, an integer between
* 0 and n - 1, where n
* is the RSA modulus.
*/
public static BigInteger RSASP1(RSAKey K, BigInteger m)
{
// 1. If the representative c is not between 0 and n - 1, output
// "representative out of range" and stop.
BigInteger n = K.getModulus();
if (m.CompareTo(BigInteger.Zero) < 0 || m.CompareTo(n - BigInteger.One) > 0)
throw new ArgumentException();
// 2. The representative m is computed as follows.
BigInteger result;
// a. If the first form (n, d) of K is used, let m = c^d mod n.
BigInteger d = K.getExponent();
result = BigInteger.ModPow(m, d, n);
// 3. Output m
return result;
}
private static void PortableDigitCount(BigInteger bi)
{
int kb=0;
if(!bi.IsZero){
while(true){
if(bi.CompareTo((BigInteger)Int32.MaxValue)<=0) {
int tmp = (int)bi;
while (tmp > 0) {
kb++;
tmp /= 10;
}
kb=(kb == 0 ? 1 : kb);
return kb;
}
BigInteger q=bi/(BigInteger)bidivisor;
if(q.IsZero){
int b=(int)bi;
while(b>0){
kb++;
b/=10;
}
break;
} else {
kb+=4;
bi=q;
}
}
} else {
kb=1;
}
return kb;
}
public bool VerifySignature(byte[] message, BigInteger r, BigInteger s)
{
if (r.Sign < 1 || s.Sign < 1 || r.CompareTo(curve.N) >= 0 || s.CompareTo(curve.N) >= 0)
return false;
BigInteger e = CalculateE(curve.N, message);
BigInteger c = s.ModInverse(curve.N);
BigInteger u1 = (e * c).Mod(curve.N);
BigInteger u2 = (r * c).Mod(curve.N);
ECPoint point = SumOfTwoMultiplies(curve.G, u1, publicKey, u2);
BigInteger v = point.X.Value.Mod(curve.N);
return v.Equals(r);
}
// Token: 0x06001410 RID: 5136 RVA: 0x00069CE8 File Offset: 0x00067EE8
private static int CompareBigInteger(System.Numerics.BigInteger i1, object i2)
{
int num = i1.CompareTo(ConvertUtils.ToBigInteger(i2));
if (num != 0)
{
return(num);
}
if (i2 is decimal)
{
decimal num2 = (decimal)i2;
return(0m.CompareTo(Math.Abs(num2 - Math.Truncate(num2))));
}
if (i2 is double || i2 is float)
{
double num3 = Convert.ToDouble(i2, CultureInfo.InvariantCulture);
return(0.0.CompareTo(Math.Abs(num3 - Math.Truncate(num3))));
}
return(num);
}
public RSA()
{
r = new Random();
List<int> primeP;
List<int> primeQ;
List<int> primeE;
int Prandom = r.Next(200000);
int Qrandom = r.Next(200000);
int Erandom = r.Next(200000);
primeP = GeneratePrimes(Prandom);
primeQ = GeneratePrimes(Qrandom);
primeE = GeneratePrimes(Erandom);
p = primeP[primeP.Count-1];
q = primeQ[primeQ.Count - 1];
N = BigInteger.Multiply(p,q);
phi =BigInteger.Multiply( BigInteger.Subtract(p,BigInteger.One),(BigInteger.Subtract(q,BigInteger.One)));
e = primeE[primeE.Count - 1];
while (BigInteger.GreatestCommonDivisor(phi, e).CompareTo(BigInteger.One) > 0 && e.CompareTo(phi) < 0)
{
BigInteger.Add(e, BigInteger.One);
}
// d = e.modInverse(phi);
d= BigInteger.ModPow(1/e,1,phi);
}
public static BigInteger Pow(BigInteger x, BigInteger y)
{
if (y.CompareTo(BigInteger.Zero) < 0)
throw new ArgumentException();
BigInteger z = x; // z will successively become x^2, x^4, x^8, x^16, x^32...
BigInteger result = BigInteger.One;
byte[] bytes = y.ToByteArray();
for (int i = bytes.Length - 1; i >= 0; i--)
{
byte bits = bytes[i];
for (int j = 0; j < 8; j++)
{
if ((bits & 1) != 0)
result = BigInteger.Multiply(result, z);
// short cut out if there are no more bits to handle:
if ((bits >>= 1) == 0 && i == 0)
return result;
z = BigInteger.Multiply(z, z);
}
}
return result;
}
private static void WritePortable(BigInteger bigint, Stream s)
{
if((s)==null)throw new ArgumentNullException("s");
if((object)bigint==(object)null){
s.WriteByte(0xf6);
return;
}
int datatype=0;
if(bigint.Sign<0){
datatype=1;
bigint+=(BigInteger)BigInteger.One;
bigint=-(BigInteger)bigint;
}
if(bigint.CompareTo(Int64MaxValue)<=0){
// If the big integer is representable as a long and in
// major type 0 or 1, write that major type
// instead of as a bignum
long ui=(long)(BigInteger)bigint;
WritePositiveInt64(datatype,ui,s);
} else {
using(MemoryStream ms=new MemoryStream()){
long tmp=0;
byte[] buffer=new byte[10];
while(bigint.Sign>0){
// To reduce the number of big integer
// operations, extract the big int 56 bits at a time
// (not 64, to avoid negative numbers)
BigInteger tmpbigint=bigint&(BigInteger)FiftySixBitMask;
tmp=(long)(BigInteger)tmpbigint;
bigint>>=56;
bool isNowZero=(bigint.IsZero);
int bufferindex=0;
for(int i=0;i<7 && (!isNowZero || tmp>0);i++){
buffer[bufferindex]=(byte)(tmp&0xFF);
tmp>>=8;
bufferindex++;
}
ms.Write(buffer,0,bufferindex);
}
byte[] bytes=ms.ToArray();
switch(bytes.Length){
case 1: // Fits in 1 byte (won't normally happen though)
buffer[0]=(byte)((datatype<<5)|24);
buffer[1]=bytes[0];
s.Write(buffer,0,2);
break;
case 2: // Fits in 2 bytes (won't normally happen though)
buffer[0]=(byte)((datatype<<5)|25);
buffer[1]=bytes[1];
buffer[2]=bytes[0];
s.Write(buffer,0,3);
break;
case 3:
case 4:
buffer[0]=(byte)((datatype<<5)|26);
buffer[1]=(bytes.Length>3) ? bytes[3] : (byte)0;
buffer[2]=bytes[2];
buffer[3]=bytes[1];
buffer[4]=bytes[0];
s.Write(buffer,0,5);
break;
case 5:
case 6:
case 7:
case 8:
buffer[0]=(byte)((datatype<<5)|27);
buffer[1]=(bytes.Length>7) ? bytes[7] : (byte)0;
buffer[2]=(bytes.Length>6) ? bytes[6] : (byte)0;
buffer[3]=(bytes.Length>5) ? bytes[5] : (byte)0;
buffer[4]=bytes[4];
buffer[5]=bytes[3];
buffer[6]=bytes[2];
buffer[7]=bytes[1];
buffer[8]=bytes[0];
s.Write(buffer,0,9);
break;
default:
s.WriteByte((datatype==0) ?
(byte)0xC2 :
(byte)0xC3);
WritePositiveInt(2,bytes.Length,s);
for(int i=bytes.Length-1;i>=0;i--){
s.WriteByte(bytes[i]);
}
break;
}
}
}
}
/**
* Raise a BigInteger to a BigInteger power.
*
* @param k Number to raise.
* @param e Exponent (must be positive or zero).
* @return k<sup>e</sup>
* @throws NotPositiveException if {@code e < 0}.
*/
//TODO: Implement this with an efficient algorithm which doesn't rely on the missing BigInteger functions
public static BigInteger pow(BigInteger k, BigInteger e) {
if (e.CompareTo(BigInteger.Zero) < 0) {
throw new NotPositiveException<BigInteger>(LocalizedFormats.EXPONENT, e);
}
BigInteger result = BigInteger.One;
//BigInteger k2p = k;
BigInteger incrementer = e;
while(!BigInteger.Zero.Equals(incrementer)) {
result = BigInteger.Multiply(result,k);
incrementer = BigInteger.Subtract(incrementer,1);
}
// while (!BigInteger.Zero.Equals(e)) {
// if (e.testBit(0)) {
// result = result.multiply(k2p);
// }
// k2p = k2p.multiply(k2p);
// e = e.shiftRight(1);
// }
return result;
}
// size is size in bits
private BigInteger GenerateRandomLargePrime(BigInteger min, BigInteger max, uint size)
{
bool IsPrime = false;
BigInteger p = new BigInteger();
do
{
var rng = new RNGCryptoServiceProvider();
byte[] bytes = new byte[size / 8];
do
{
rng.GetBytes(bytes);
p = new BigInteger(bytes);
if (p < 0)
{
p = BigInteger.Negate(p);
}
}
while (0 > p.CompareTo(min) || 0 < p.CompareTo(max));
if (IsProbablePrime(p, 100))
IsPrime = true;
} while (!IsPrime);
return p;
}
public void IComparable () {
var a = new BigInteger (99);
Assert.AreEqual (-1, a.CompareTo (100), "#1");
Assert.AreEqual (1, a.CompareTo (null), "#2");
}
public void CompareLong () {
long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 9999999, 100000000000L, 0xAA00000000, long.MaxValue, long.MinValue };
for (int i = 0; i < values.Length; ++i) {
for (int j = 0; j < values.Length; ++j) {
var a = new BigInteger (values [i]);
var b = values [j];
var c = new BigInteger (b);
Assert.AreEqual (a.CompareTo (c), a.CompareTo (b), "#a_" + i + "_" + j);
Assert.AreEqual (a > c, a > b, "#b_" + i + "_" + j);
Assert.AreEqual (a < c, a < b, "#c_" + i + "_" + j);
Assert.AreEqual (a <= c, a <= b, "#d_" + i + "_" + j);
Assert.AreEqual (a == c, a == b, "#e_" + i + "_" + j);
Assert.AreEqual (a != c, a != b, "#f_" + i + "_" + j);
Assert.AreEqual (a >= c, a >= b, "#g_" + i + "_" + j);
Assert.AreEqual (c > a, b > a, "#ib_" + i + "_" + j);
Assert.AreEqual (c < a, b < a, "#ic_" + i + "_" + j);
Assert.AreEqual (c <= a, b <= a, "#id_" + i + "_" + j);
Assert.AreEqual (c == a, b == a, "#ie_" + i + "_" + j);
Assert.AreEqual (c != a, b != a, "#if_" + i + "_" + j);
Assert.AreEqual (c >= a, b >= a, "#ig_" + i + "_" + j);
}
}
}
public void CompareOps2 () {
BigInteger a = new BigInteger (100000000000L);
BigInteger b = new BigInteger (28282828282UL);
Assert.IsTrue (a >= b, "#1");
Assert.IsTrue (a >= b, "#2");
Assert.IsFalse (a < b, "#3");
Assert.IsFalse (a <= b, "#4");
Assert.AreEqual (1, a.CompareTo (b), "#5");
}
public void CompareOps () {
long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
for (int i = 0; i < values.Length; ++i) {
for (int j = 0; j < values.Length; ++j) {
var a = new BigInteger (values [i]);
var b = new BigInteger (values [j]);
Assert.AreEqual (values [i].CompareTo (values [j]), a.CompareTo (b), "#a_" + i + "_" + j);
Assert.AreEqual (values [i].CompareTo (values [j]), BigInteger.Compare (a, b), "#b_" + i + "_" + j);
Assert.AreEqual (values [i] < values [j], a < b, "#c_" + i + "_" + j);
Assert.AreEqual (values [i] <= values [j], a <= b, "#d_" + i + "_" + j);
Assert.AreEqual (values [i] == values [j], a == b, "#e_" + i + "_" + j);
Assert.AreEqual (values [i] != values [j], a != b, "#f_" + i + "_" + j);
Assert.AreEqual (values [i] >= values [j], a >= b, "#g_" + i + "_" + j);
Assert.AreEqual (values [i] > values [j], a > b, "#h_" + i + "_" + j);
}
}
}
/**
* An implementation of the RSAVP method: Assuming that the designated
* RSA public key is a valid one, this method computes a message
* representative for the designated signature representative
* generated by an RSA private key, for a message intended for the holder of
* the designated RSA public key.
*
* @param K the RSA public key.
* @param s the signature representative, an integer between
* 0 and n - 1, where n is the RSA modulus.
* @return a message representative: an integer between 0
* and n - 1, where n is the RSA modulus.
*/
public static BigInteger RSAVP1(RSAKey K, BigInteger s)
{
// 1. If the representative m is not between 0 and n - 1, output
// "representative out of range" and stop.
BigInteger n = K.getModulus();
if (s.CompareTo(BigInteger.Zero) < 0 || s.CompareTo(n - BigInteger.One) > 0)
throw new ArgumentException();
// 2. Let c = m^e mod n.
BigInteger e = K.getExponent();
BigInteger result = BigInteger.ModPow(s, e, n); ;
// 3. Output c.
return result;
}
/// <summary>
/// Осуществляет поиск простого числа, путём перебора всех числел, начиная с <code>value</code> до
/// <code>border</code> с шагом равным 2 по модулю.
/// </summary>
/// <param name="value">Начальное значение.</param>
/// <param name="border">Граница интервала, в сторону которой будем двигатся.</param>
/// <returns>Простое число, либо -1, если на заданном интервале нет простых чисел.</returns>
private static BigInteger MoveToPrime(BigInteger value, BigInteger border, double probability)
{
int summand = (border >= value) ? 2 : -2;
int compareResult = (summand > 0) ? -1 : 1;
while (value.CompareTo(border) == compareResult)
{
value += summand;
if (IsPrime(value, probability))
return value;
}
return BigInteger.MinusOne;
}
/// <summary>
/// Check whether the integer represented is 0
/// </summary>
/// <returns> True is the integer represented is 0. False otherwise </returns>
public override bool zero()
{
return(_value.CompareTo(System.Numerics.BigInteger.Zero) == 0);
}