//OLD CODE//
/// <summary>
/// This generates an RSA Key Pair using a hijacked BouncyCastle approach.
/// </summary>
/// <param name="keyGen"></param>
/// <param name="keySize"></param>
/// <returns></returns>
public static AsymmetricCipherKeyPair GenerateKeyPair2(IBasylKeyGenerator keyGen, int keySize)
{
RsaKeyPairGenerator rsaGenerator = new RsaKeyPairGenerator();
rsaGenerator.Init(new KeyGenerationParameters(new BasylSecureRandom(keyGen), keySize));
AsymmetricCipherKeyPair keys = rsaGenerator.GenerateKeyPair();
return keys;
}
public BESCipher(IBasylKeyGenerator generator)
{
cipher = new byte[256];
cipherB = new byte[256];
for (int i = 0; i <= 255; i++)
{
cipherB[i] = cipher[i] = (byte)i;
}
this.generator = generator;
Shuffle(10);
}
public BESCipher(IBasylKeyGenerator generator)
{
cipher = new byte[256];
cipherB = new byte[256];
for (int i = 0; i <= 255; i++)
{
cipherB[i] = cipher[i] = (byte)i;
}
this.generator = generator;
Shuffle(10);
}
/// <summary>
/// Creates a Basyl Writer from the Stream and Key Generator.
/// </summary>
/// <param name="stream"></param>
/// <param name="keyGen"></param>
/// <param name="export">Only set to true if you have yet to use the Key Generator.
/// Otherwise, export stuff manually.</param>
public BasylWriter(Stream stream, IBasylKeyGenerator keyGen, bool export)
{
encodingSetting = Encoding.Unicode;
writer = new BinaryWriter(stream);
this.keyGen = keyGen;
if (export)
{
writer.Write(((BasylKeyGenerator)keyGen).GetSHA());
writer.Write(((BasylKeyGenerator)keyGen).GetSecondRandomizer());
writer.Write(((BasylKeyGenerator)keyGen).GetEncryptedKey1Random());
}
}
/// <summary>
/// This generates an elliptic curve key pair. Uses BouncyCastle library for generation.
/// Hijacked by the BES Random Generator.
/// </summary>
/// <param name="keyGen"></param>
/// <param name="keySize"></param>
/// <returns></returns>
public static AsymmetricCipherKeyPair GenerateKeyPair(IBasylKeyGenerator keyGen, string curveName)
{
var ecGenerator = new ECKeyPairGenerator("ECDH");
var ecp = GetCurveFromName(curveName);
ECDomainParameters ecSpec = new ECDomainParameters(ecp.Curve, ecp.G, ecp.N, ecp.H, ecp.GetSeed());
ECKeyGenerationParameters ecgp = new ECKeyGenerationParameters(ecSpec, new BasylSecureRandom(keyGen));
ecGenerator.Init(ecgp);
AsymmetricCipherKeyPair keys = ecGenerator.GenerateKeyPair();
return keys;
}
/// <summary>
/// Creates a Basyl Reader from the Stream and Key Generator.
/// </summary>
/// <param name="stream"></param>
/// <param name="generator"></param>
public BasylReader(Stream stream, IBasylKeyGenerator generator)
{
this.encodingSetting = Encoding.Unicode;
keyGen = generator;
this.reader = new BinaryReader(stream);
}
public BasylSecureRandom(IBasylKeyGenerator keyGen)
{
this.keyGen = keyGen;
}
/// <summary>
/// Creates a Basyl Reader from the Stream and Key Generator.
/// </summary>
/// <param name="stream"></param>
/// <param name="generator"></param>
public BasylReader(Stream stream, IBasylKeyGenerator generator)
{
this.encodingSetting = Encoding.Unicode;
keyGen = generator;
this.reader = new BinaryReader(stream);
}
/// <summary>
/// Generates a random large prime near the given bit size.
/// </summary>
/// <param name="generator"></param>
/// <param name="size"></param>
/// <returns></returns>
private static BigInteger GetRandomLargePrime(IBasylKeyGenerator generator, int size)
{
//fills an array with random bytes. This is used for the prime search.
byte[] vals = new byte[(int)Math.Ceiling(size / 8.0f)];
lock (generator)
{
for (int i = 0; i < 20; i++)
{
generator.FillBytes(vals);
}
for (int k = 0; k < 2; k++)
for (int i = 0; i < vals.Length; i++)
{
for (int n = 0; n < 3; n++)
generator.GetRandomByte();
generator.EncryptByte(ref vals[i]);
}
}
//searches for the prime number, decreases until it finds one that tests to be prime.
BigInteger gco = new BigInteger(vals);
if(gco < 0)
{
gco *= -1;
}
if (gco.IsEven)
{
gco -= 1;
}
var bouncyCastleBig = gco.Convert();
var amt = new BigInteger(2).Convert();
while (!bouncyCastleBig.IsProbablePrime(1))
{
bouncyCastleBig = bouncyCastleBig.Subtract(amt);
gco -= 2;
}
//Bouncy castles isProbablePrime method is severely optimized compared to a naive approach.
return gco;
}
/// <summary>
/// Generates a key pair using a portable BES approach.
/// </summary>
/// <param name="keyGen"></param>
/// <param name="keySize"></param>
/// <returns></returns>
public AsymmetricCipherKeyPair GenerateKeyPair(IBasylKeyGenerator keyGen, int keySize)
{
gSize = keySize;
gen = keyGen;
Thread thread = new Thread(new ThreadStart(GenerateP)),
thread2 = new Thread(new ThreadStart(GenerateQ));
thread.Start();
thread2.Start();
thread.Join();
thread2.Join();
var n = p * q;
var e = 65537;
var phi = (p - 1) * (q - 1);
var d = (new Org.BouncyCastle.Math.BigInteger(e.ToString())).ModInverse(phi.Convert());
var dP = d.Remainder((p - 1).Convert());
var dQ = d.Remainder((q - 1).Convert());
var qInv = q.Convert().ModInverse(p.Convert());
return new AsymmetricCipherKeyPair(
new RsaKeyParameters(false, n.Convert(), new Org.BouncyCastle.Math.BigInteger(e.ToString())),
new RsaPrivateCrtKeyParameters(n.Convert(), new Org.BouncyCastle.Math.BigInteger(e.ToString()), d, p.Convert(), q.Convert(), dP, dQ, qInv));
}
public BasylWriter(Stream stream, IBasylKeyGenerator keyGen) : this(stream, keyGen, false)
{
}
