public DSAPrivateKeySpec (BigInteger x, BigInteger p, BigInteger q, BigInteger g)
{
this.x = x;
this.p = p;
this.q = q;
this.g = g;
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.String) { return null; }
var decrypted = (MCrypto)base.ReadJson(reader, objectType, existingValue, serializer);
var rsa_privk = new BigInteger[4];
var bytes = decrypted.Value;
int startindex = 0;
for (var i = 0; i < 4; i++)
{
var l = ((bytes[startindex + 0] * 256 + bytes[startindex + 1] + 7) >> 3) + 2;
rsa_privk[i] = Converter.MpiToBigInt(bytes, startindex, l);
startindex += l;
}
if (bytes.Length - startindex < 16)
{
return new RSAKey
{
P = rsa_privk[0],
Q = rsa_privk[1],
D = rsa_privk[2],
U = rsa_privk[3],
N = BigInteger.Multiply(rsa_privk[0], rsa_privk[1])
};
}
else return null;
}
public Bitwise_Base()
{
N = new BigInteger(n);
expectedNls = new BigInteger(ExpectedNLeftShift);
expectedNrs = new BigInteger(ExpectedNRightShift);
shiftAmount = ShiftAmount;
}
/* get plaintext using biginteger class. This is required because default int cannot handle large modpow function */
public byte[] getMyPlainText(int [] a, int d, int n)
{
int l = a.Length;
byte [] r = new byte[l];
for (int i = 0; i < a.Length; i++)
{
int temp = a[i];
/* if temp=199 which represents blankspace, handle it differently */
if (temp == 199 || temp == 200 || temp == 201)
{
r[i] = (byte)temp;
continue;
}
Mono.Math.BigInteger bi = temp;
bi = bi.ModPow(d, n);
string tempString = bi.ToString();
int g = Int32.Parse(tempString);
r[i] = (byte)g;
}
return(r);
}
public void Test()
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] blob = rsa.ExportCspBlob(false);
RSACryptoServiceProvider rsa_pub = new RSACryptoServiceProvider();
rsa_pub.ImportCspBlob(blob);
CertificateMaker cm = new CertificateMaker("United States", "UFL",
"ACIS", "David Wolinsky", "*****@*****.**", rsa_pub,
"brunet:node:abcdefghijklmnopqrs");
Assert.AreEqual("C=United States, O=UFL, OU=ACIS, CN=David Wolinsky, [email protected]", cm.Subject.DN, "DN test 1");
cm = new CertificateMaker(cm.UnsignedData);
Assert.AreEqual("C=United States, O=UFL, OU=ACIS, CN=David Wolinsky, [email protected]", cm.Subject.DN, "DN test 2");
Certificate cert = cm.Sign(cm, rsa);
Assert.IsTrue(cert.Signature != null, "Signature");
Assert.AreEqual(cm.Subject.DN, cert.Issuer.DN, "Issuer = Subject");
Assert.AreEqual("brunet:node:abcdefghijklmnopqrs", cert.NodeAddress, "Node address");
Mono.Math.BigInteger rsa_pub_bi = new Mono.Math.BigInteger(rsa_pub.ExportCspBlob(false));
Mono.Math.BigInteger cert_pub_bi = new Mono.Math.BigInteger(cert.PublicKey.ExportCspBlob(false));
Assert.AreEqual(rsa_pub_bi, cert_pub_bi, "Key");
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
Assert.AreEqual(MemBlock.Reference(cert.SerialNumber),
MemBlock.Reference(sha1.ComputeHash(cert.UnsignedData)),
"SerialNumber == hash of unsigned data");
}
public void ModPow_0_Even ()
{
BigInteger x = new BigInteger (1);
BigInteger y = new BigInteger (0);
BigInteger z = x.ModPow (y, 1024);
Assert.AreEqual ("1", z.ToString (), "1 pow 0 == 1");
}
public DSAPublicKeySpec (BigInteger y, BigInteger p, BigInteger q, BigInteger g)
{
this.y = y;
this.p = p;
this.q = q;
this.g = g;
}
static void Main(string[] args)
{
Datacenter datacenterController = new Datacenter();
var i = new BigInteger(8798782624624);
Console.WriteLine(i);
Console.ReadLine();
}
public void BarrettReduction(BigInteger x)
{
var n = mod;
uint k = n.length,
kPlusOne = k + 1,
kMinusOne = k - 1;
// x < mod, so nothing to do.
if (x.length < k) return;
BigInteger q3;
//
// Validate pointers
//
if (x.data.Length < x.length) throw new IndexOutOfRangeException("x out of range");
// q1 = x / b^ (k-1)
// q2 = q1 * constant
// q3 = q2 / b^ (k+1), Needs to be accessed with an offset of kPlusOne
// TODO: We should the method in HAC p 604 to do this (14.45)
q3 = new BigInteger(Sign.Positive, x.length - kMinusOne + constant.length);
Kernel.Multiply(x.data, kMinusOne, x.length - kMinusOne, constant.data, 0, constant.length, q3.data, 0);
// r1 = x mod b^ (k+1)
// i.e. keep the lowest (k+1) words
var lengthToCopy = x.length > kPlusOne ? kPlusOne : x.length;
x.length = lengthToCopy;
x.Normalize();
// r2 = (q3 * n) mod b^ (k+1)
// partial multiplication of q3 and n
var r2 = new BigInteger(Sign.Positive, kPlusOne);
Kernel.MultiplyMod2p32pmod(q3.data, (int) kPlusOne, (int) q3.length - (int) kPlusOne, n.data, 0,
(int) n.length, r2.data, 0, (int) kPlusOne);
r2.Normalize();
if (r2 <= x)
{
Kernel.MinusEq(x, r2);
}
else
{
var val = new BigInteger(Sign.Positive, kPlusOne + 1);
val.data[kPlusOne] = 0x00000001;
Kernel.MinusEq(val, r2);
Kernel.PlusEq(x, val);
}
while (x >= n)
Kernel.MinusEq(x, n);
}
public void WikipediaSanityChecks()
{
// http://en.wikipedia.org/wiki/RSA on 25 May 2009
var c = new BigInteger(855);
var d = new BigInteger(2753);
var n = new BigInteger(3233);
var m = c.ModPow(d, n);
Assert.AreEqual("123", m.ToString());
}
public SignedBigInteger(long a)
{
if (a < 0)
{
this.Negative = true;
a *= -1;
}
this.Number = new BigInteger((ulong)a);
}
public SignedBigInteger(int a)
{
if (a < 0)
{
this.Negative = true;
a *= -1;
}
this.Number = new BigInteger(a);
}
private void GenerateKeyPair()
{
// p and q values should have a length of half the strength in bits
int pbitlength = ((KeySize + 1) >> 1);
int qbitlength = (KeySize - pbitlength);
const uint uint_e = 17;
e = uint_e; // fixed
// generate p, prime and (p-1) relatively prime to e
for (; ; )
{
p = BigInteger.GeneratePseudoPrime(pbitlength);
if (p % uint_e != 1)
break;
}
// generate a modulus of the required length
for (; ; )
{
// generate q, prime and (q-1) relatively prime to e,
// and not equal to p
for (; ; )
{
q = BigInteger.GeneratePseudoPrime(qbitlength);
if ((q % uint_e != 1) && (p != q))
break;
}
// calculate the modulus
n = p * q;
if (n.BitCount() == KeySize)
break;
// if we get here our primes aren't big enough, make the largest
// of the two p and try again
if (p < q)
p = q;
}
BigInteger pSub1 = (p - 1);
BigInteger qSub1 = (q - 1);
BigInteger phi = pSub1 * qSub1;
// calculate the private exponent
d = e.ModInverse(phi);
// calculate the CRT factors
dp = d % pSub1;
dq = d % qSub1;
qInv = q.ModInverse(p);
keypairGenerated = true;
isCRTpossible = true;
if (KeyGenerated != null)
KeyGenerated(this, null);
}
public ModRing_Base()
{
A = new BigInteger( a );
B = new BigInteger( b );
N = new BigInteger( n );
abModN = new BigInteger( ExpectedABmodN );
aPowBmodN = new BigInteger( ExpectedApowBmodN );
mr = new BigInteger.ModulusRing(N);
}
/// <summary>
/// Performs the RSA operation Result = <paramref name="message"/>^<paramref name="exponent"/> (mod <paramref name="modulus"/>).
/// </summary>
/// <param name="message">The message to perform the operation on.</param>
/// <param name="exponent">The exponent value to raise the message by.</param>
/// <param name="modulus">The modulus to divide the results by.</param>
/// <returns>The value C, such that C = <paramref name="message"/>^<paramref name="exponent"/> (mod <paramref name="modulus"/>).</returns>
public static byte[] PublicKeyOperation(byte[] message, byte[] exponent, byte[] modulus)
{
var m = new BigInteger(message);
var e = new BigInteger(exponent);
var n = new BigInteger(modulus);
var c = m.ModPow(e, n);
var resultBytes = c.GetBytes();
return resultBytes;
}
public static BigInteger Power(this BigInteger a, BigInteger b)
{
BigInteger value = 1;
for (BigInteger count = 0; count < b; count += 1)
{
value *= a;
}
return value;
}
public void DefaultRandom ()
{
// based on bugzilla entry #68452
BigInteger bi = new BigInteger ();
Assert.AreEqual (0, bi.BitCount (), "before randomize");
bi.Randomize ();
// Randomize returns a random number of BitCount length
// so in this case it will ALWAYS return 0
Assert.AreEqual (0, bi.BitCount (), "after randomize");
Assert.AreEqual (new BigInteger (0), bi, "Zero");
}
public ModulusRing(BigInteger modulus)
{
mod = modulus;
// calculate constant = b^ (2k) / m
var i = mod.length << 1;
constant = new BigInteger(Sign.Positive, i + 1);
constant.data[i] = 0x00000001;
constant = constant/mod;
}
public void ModPow_2 ()
{
// #70169
BigInteger b = new BigInteger (10);
BigInteger m = new BigInteger (32);
// after 40 we start loosing double precision and result will differ
for (int i=1; i < 40; i++) {
BigInteger e = new BigInteger (i);
BigInteger r = e.ModPow (b, m);
long expected = (long) myalias.Math.Pow (i, 10) % 32;
Assert.AreEqual (expected.ToString (), r.ToString (), i.ToString ());
}
}
// myKeyAgree=KeyAgreement.getInstance("DiffieHellman");
/// <exception cref="System.Exception"></exception>
public virtual byte[] GetE()
{
if (e == null)
{
DHParameterSpec dhSkipParamSpec = new DHParameterSpec(p, g);
myKpairGen.Initialize(dhSkipParamSpec);
Sharpen.KeyPair myKpair = myKpairGen.GenerateKeyPair();
myKeyAgree.Init(myKpair.GetPrivate());
// BigInteger x=((javax.crypto.interfaces.DHPrivateKey)(myKpair.getPrivate())).getX();
e = ((DHPublicKey)(myKpair.GetPublic())).GetY();
e_array = e.GetBytes();
}
return e_array;
}
public void AppliedCryptographySanityChecks()
{
// Sanity checks from Applied Cryptography, 2nd Edition p467 - 468
var p = new BigInteger(47);
var q = new BigInteger(71);
var n = p * q;
var e = new BigInteger(79);
var d = e.ModInverse((p - 1) * (q - 1));
Func<int, string> encryptor = m => (new BigInteger(m).ModPow(e, n)).ToString();
Assert.AreEqual("1570", encryptor(688));
Assert.AreEqual("2756", encryptor(232));
Assert.AreEqual("2091", encryptor(687));
Assert.AreEqual("2276", encryptor(966));
Assert.AreEqual("2423", encryptor(668));
Assert.AreEqual("158", encryptor(3));
}
public void AssignTest()
{
SignedBigInteger a, b, c, d;
a = -3;
b = new BigInteger(12341234);
c = 12341513241234;
d = new BigInteger(123123823);
d *= -1;
Assert.AreEqual(true, a.Negative);
Assert.AreEqual(new BigInteger(3), a.Number);
Assert.AreEqual(new BigInteger(12341234), b.Number);
Assert.AreEqual(false, b.Negative);
Assert.AreEqual(new BigInteger(12341513241234), c.Number);
Assert.AreEqual(false, c.Negative);
Assert.AreEqual(true, d.Negative);
Assert.AreEqual(new BigInteger(123123823), d.Number);
}
// initializes the private variables (throws CryptographicException)
private void Initialize(BigInteger p, BigInteger g, BigInteger x, int secretLen, bool checkInput) {
if (!p.isProbablePrime() || g <= 0 || g >= p || (x != null && (x <= 0 || x > p - 2)))
throw new CryptographicException();
// default is to generate a number as large as the prime this
// is usually overkill, but it's the most secure thing we can
// do if the user doesn't specify a desired secret length ...
if (secretLen == 0)
secretLen = p.bitCount();
m_P = p;
m_G = g;
if (x == null) {
BigInteger pm1 = m_P - 1;
for(m_X = BigInteger.genRandom(secretLen); m_X >= pm1 || m_X == 0; m_X = BigInteger.genRandom(secretLen)) {}
} else {
m_X = x;
}
}
public static byte[] GenerateSharedKey(byte[] publicKey, byte[] privateKey, byte[] prime)
{
byte[] publicKeyReversed = new byte[publicKey.Length];
Array.Copy(publicKey, publicKeyReversed, publicKeyReversed.Length);
Array.Reverse(publicKeyReversed);
BigInteger a = new BigInteger(publicKeyReversed);
BigInteger x = new BigInteger(privateKey);
BigInteger p = new BigInteger(prime);
BigInteger b = a.ModPow(x, p);
byte[] sharedKey = b.GetBytes();
Array.Reverse(sharedKey);
return sharedKey;
}
public static byte[] Calculate(BigInteger a, BigInteger b)
{
byte[] bytes;
lock (locker)
bytes = a.ModPow(b, prime).GetBytes();
if (bytes.Length < 96)
{
byte[] oldBytes = bytes;
bytes = new byte[96];
Array.Copy(oldBytes, 0, bytes, 96 - oldBytes.Length, oldBytes.Length);
for (int i = 0; i < (96 - oldBytes.Length); i++)
bytes[i] = 0;
}
return bytes;
}
public void MakeAESKey(string keyExchangeBytes)
{
BigInteger A = new BigInteger(keyExchangeBytes);
byte[] R = A.modPow(privateKey, Module).getBytes();
aesKey = new byte[16];
Array.Copy(R, aesKey, 16);
for (int i = 0; i < 16; i++)
{
byte tmp = (byte)(aesKey[i] >> 4);
byte tmp2 = (byte)(aesKey[i] & 0xF);
if (tmp > 9)
tmp = (byte)(tmp - 9);
if (tmp2 > 9)
tmp2 = (byte)(tmp2 - 9);
aesKey[i] = (byte)( tmp << 4 | tmp2);
}
}
public static int GetTrailingZerosCount(BigInteger num)
{
int count = 0;
string numAsString = num.ToString ();
int len = numAsString.Length;
for (int i = 0; i < len; i++)
{
int digit = int.Parse (numAsString[len - i - 1].ToString());
if (digit != 0)
{
break;
}
count += 1;
}
return count;
}
public static byte[] GetCounterHexValue(BigInteger counter)
{
byte[] counterBytes = counter.GetBytes();
counterBytes = PppConvert.SwapBits(counterBytes);
int padNeeded = 16 - counterBytes.Length;
List<byte> padedBytes;
if (counterBytes.Length != 16)
{
padedBytes = new List<byte>(16);
padedBytes.AddRange(counterBytes);
padedBytes.AddRange(new byte[padNeeded]);
}
else
{
padedBytes = new List<byte>(counterBytes);
}
return padedBytes.ToArray();
}
public static string Convert(string source, int sourceRadix, int targetRadix)
{
/* Check if radix arguments are within the allowed range. */
if (sourceRadix < MIN_RADIX || sourceRadix > MAX_RADIX)
throw new ArgumentOutOfRangeException("sourceRadix", "Source radix needs to be in a range from " + MIN_RADIX + " to " + MAX_RADIX);
if (targetRadix < MIN_RADIX || targetRadix > MAX_RADIX)
throw new ArgumentOutOfRangeException("targetRadix", "Target radix needs to be in a range from " + MIN_RADIX + " to " + MAX_RADIX);
BigInteger radixFrom = new BigInteger((UInt32)sourceRadix);
BigInteger value = new BigInteger(0);
BigInteger multiplier = new BigInteger(1);
for (int i = source.Length - 1; i >= 0; i--)
{
int digit = Digit(source[i], sourceRadix);
if (digit == -1)
throw new ArgumentException("The character '" + source[i] + "' is not defined for the source radix.", "sourceRadix");
value += multiplier * digit;
multiplier = multiplier * radixFrom;
}
return value.ToString((UInt32)targetRadix, CHARACTERS.Substring(0, targetRadix));
}
static string ToDecimalString (string hexString)
{
#if TARGET_DOTNET
throw new NotImplementedException ();
#else
// http://tools.ietf.org/html/rfc5280#section-4.1.2.2
// We SHOULD support negative numbers
var bytes = FromBinHex (hexString);
var negative = bytes.Length > 0 && bytes [0] >= 0x80;
if (negative) {
for (int i = 0; i < bytes.Length; i++)
bytes [i] = (byte) ~ bytes [i];
}
var big = new BigInteger (bytes);
if (negative) {
big = big + 1;
return "-" + big.ToString ();
} else
return big.ToString ();
#endif
}
public void Test() {
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] blob = rsa.ExportCspBlob(false);
RSACryptoServiceProvider rsa_pub = new RSACryptoServiceProvider();
rsa_pub.ImportCspBlob(blob);
CertificateMaker cm = new CertificateMaker("United States", "UFL",
"ACIS", "David Wolinsky", "*****@*****.**", rsa_pub,
"brunet:node:abcdefghijklmnopqrs");
Assert.AreEqual("C=United States, O=UFL, OU=ACIS, CN=David Wolinsky, [email protected]", cm.Subject.DN, "DN test 1");
cm = new CertificateMaker(cm.UnsignedData);
Assert.AreEqual("C=United States, O=UFL, OU=ACIS, CN=David Wolinsky, [email protected]", cm.Subject.DN, "DN test 2");
Certificate cert = cm.Sign(cm, rsa);
Assert.IsTrue(cert.Signature != null, "Signature");
Assert.AreEqual(cm.Subject.DN, cert.Issuer.DN, "Issuer = Subject");
Assert.AreEqual("brunet:node:abcdefghijklmnopqrs", cert.NodeAddress , "Node address");
Mono.Math.BigInteger rsa_pub_bi = new Mono.Math.BigInteger(rsa_pub.ExportCspBlob(false));
Mono.Math.BigInteger cert_pub_bi = new Mono.Math.BigInteger(cert.PublicKey.ExportCspBlob(false));
Assert.AreEqual(rsa_pub_bi, cert_pub_bi, "Key");
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
Assert.AreEqual(MemBlock.Reference(cert.SerialNumber),
MemBlock.Reference(sha1.ComputeHash(cert.UnsignedData)),
"SerialNumber == hash of unsigned data");
}
/// <summary>
/// Generates the smallest prime >= bi
/// </summary>
/// <param name="bi">A BigInteger</param>
/// <returns>The smallest prime >= bi. More mathematically, if bi is prime: bi, else Prime [PrimePi [bi] + 1].</returns>
public static BigInteger NextHighestPrime (BigInteger bi)
{
NextPrimeFinder npf = new NextPrimeFinder ();
return npf.GenerateNewPrime (0, bi);
}