public virtual AsymmetricCipherKeyPair GenerateKeyPair()
{
int num2;
BigInteger publicExponent;
BigInteger bigInteger;
BigInteger bigInteger2;
BigInteger bigInteger4;
BigInteger bigInteger6;
BigInteger bigInteger7;
BigInteger bigInteger8;
do
{
int strength = this.parameters.Strength;
int num = (strength + 1) / 2;
num2 = strength - num;
int num3 = strength / 3;
int num4 = strength >> 2;
publicExponent = this.parameters.PublicExponent;
bigInteger = this.ChooseRandomPrime(num, publicExponent);
while (true)
{
bigInteger2 = this.ChooseRandomPrime(num2, publicExponent);
BigInteger bigInteger3 = bigInteger2.Subtract(bigInteger).Abs();
if (bigInteger3.BitLength >= num3)
{
bigInteger4 = bigInteger.Multiply(bigInteger2);
if (bigInteger4.BitLength != strength)
{
bigInteger = bigInteger.Max(bigInteger2);
}
else
{
if (WNafUtilities.GetNafWeight(bigInteger4) >= num4)
{
break;
}
bigInteger = this.ChooseRandomPrime(num, publicExponent);
}
}
}
if (bigInteger.CompareTo(bigInteger2) < 0)
{
BigInteger bigInteger5 = bigInteger;
bigInteger = bigInteger2;
bigInteger2 = bigInteger5;
}
bigInteger6 = bigInteger.Subtract(RsaKeyPairGenerator.One);
bigInteger7 = bigInteger2.Subtract(RsaKeyPairGenerator.One);
BigInteger val = bigInteger6.Gcd(bigInteger7);
BigInteger m = bigInteger6.Divide(val).Multiply(bigInteger7);
bigInteger8 = publicExponent.ModInverse(m);
}while (bigInteger8.BitLength <= num2);
BigInteger dP = bigInteger8.Remainder(bigInteger6);
BigInteger dQ = bigInteger8.Remainder(bigInteger7);
BigInteger qInv = bigInteger2.ModInverse(bigInteger);
return(new AsymmetricCipherKeyPair(new RsaKeyParameters(false, bigInteger4, publicExponent), new RsaPrivateCrtKeyParameters(bigInteger4, publicExponent, bigInteger8, bigInteger, bigInteger2, dP, dQ, qInv)));
}
private static BigInteger GeneratePrivateKey(BigInteger q, SecureRandom random)
{
int num = q.BitLength >> 2;
BigInteger bigInteger;
do
{
bigInteger = BigIntegers.CreateRandomInRange(DsaKeyPairGenerator.One, q.Subtract(DsaKeyPairGenerator.One), random);
}while (WNafUtilities.GetNafWeight(bigInteger) < num);
return(bigInteger);
}
public virtual AsymmetricCipherKeyPair GenerateKeyPair()
{
int num;
BigInteger integer3;
Label_0005:
num = this.parameters.Strength;
int bitlength = (num + 1) / 2;
int num3 = num - bitlength;
int num4 = num / 3;
int num5 = num >> 2;
BigInteger publicExponent = this.parameters.PublicExponent;
BigInteger n = this.ChooseRandomPrime(bitlength, publicExponent);
Label_0041:
integer3 = this.ChooseRandomPrime(num3, publicExponent);
if (integer3.Subtract(n).Abs().BitLength < num4)
{
goto Label_0041;
}
BigInteger k = n.Multiply(integer3);
if (k.BitLength != num)
{
n = n.Max(integer3);
goto Label_0041;
}
if (WNafUtilities.GetNafWeight(k) < num5)
{
n = this.ChooseRandomPrime(bitlength, publicExponent);
goto Label_0041;
}
if (n.CompareTo(integer3) < 0)
{
BigInteger integer6 = n;
n = integer3;
integer3 = integer6;
}
BigInteger integer7 = n.Subtract(One);
BigInteger integer8 = integer3.Subtract(One);
BigInteger val = integer7.Gcd(integer8);
BigInteger m = integer7.Divide(val).Multiply(integer8);
BigInteger privateExponent = publicExponent.ModInverse(m);
if (privateExponent.BitLength <= num3)
{
goto Label_0005;
}
BigInteger dP = privateExponent.Remainder(integer7);
BigInteger dQ = privateExponent.Remainder(integer8);
BigInteger qInv = integer3.ModInverse(n);
return(new AsymmetricCipherKeyPair(new RsaKeyParameters(false, k, publicExponent), new RsaPrivateCrtKeyParameters(k, publicExponent, privateExponent, n, integer3, dP, dQ, qInv)));
}
private static BigInteger GeneratePrivateKey(BigInteger q, SecureRandom random)
{
BigInteger integer;
int num = q.BitLength >> 2;
do
{
integer = BigIntegers.CreateRandomInRange(One, q.Subtract(One), random);
}while (WNafUtilities.GetNafWeight(integer) < num);
return(integer);
}
public AsymmetricCipherKeyPair GenerateKeyPair()
{
SecureRandom random = param.Random;
Gost3410Parameters gost3410Params = param.Parameters;
BigInteger q = gost3410Params.Q, x;
int minWeight = 64;
for (;;)
{
x = new BigInteger(256, random);
if (x.SignValue < 1 || x.CompareTo(q) >= 0)
{
continue;
}
/*
* Require a minimum weight of the NAF representation, since low-weight primes may be
* weak against a version of the number-field-sieve for the discrete-logarithm-problem.
*
* See "The number field sieve for integers of low weight", Oliver Schirokauer.
*/
if (WNafUtilities.GetNafWeight(x) < minWeight)
{
continue;
}
break;
}
BigInteger p = gost3410Params.P;
BigInteger a = gost3410Params.A;
// calculate the public key.
BigInteger y = a.ModPow(x, p);
if (param.PublicKeyParamSet != null)
{
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, param.PublicKeyParamSet),
new Gost3410PrivateKeyParameters(x, param.PublicKeyParamSet)));
}
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, gost3410Params),
new Gost3410PrivateKeyParameters(x, gost3410Params)));
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int num = Math.Max(2, Math.Min(16, GetWindowSize(k.BitLength)));
WNafPreCompInfo wNafPreCompInfo = WNafUtilities.Precompute(p, num, includeNegated: true);
ECPoint[] preComp = wNafPreCompInfo.PreComp;
ECPoint[] preCompNeg = wNafPreCompInfo.PreCompNeg;
int[] array = WNafUtilities.GenerateCompactWindowNaf(num, k);
ECPoint eCPoint = p.Curve.Infinity;
int num2 = array.Length;
if (num2 > 1)
{
int num3 = array[--num2];
int num4 = num3 >> 16;
int num5 = num3 & 0xFFFF;
int num6 = Math.Abs(num4);
ECPoint[] array2 = (num4 < 0) ? preCompNeg : preComp;
if (num6 << 2 < 1 << num)
{
int num7 = LongArray.BitLengths[num6];
int num8 = num - num7;
int num9 = num6 ^ (1 << num7 - 1);
int num10 = (1 << num - 1) - 1;
int num11 = (num9 << num8) + 1;
eCPoint = array2[num10 >> 1].Add(array2[num11 >> 1]);
num5 -= num8;
}
else
{
eCPoint = array2[num6 >> 1];
}
eCPoint = eCPoint.TimesPow2(num5);
}
while (num2 > 0)
{
int num12 = array[--num2];
int num13 = num12 >> 16;
int e = num12 & 0xFFFF;
int num14 = Math.Abs(num13);
ECPoint[] array3 = (num13 < 0) ? preCompNeg : preComp;
ECPoint b = array3[num14 >> 1];
eCPoint = eCPoint.TwicePlus(b);
eCPoint = eCPoint.TimesPow2(e);
}
return(eCPoint);
}
internal BigInteger CalculatePrivate(
DHParameters dhParams,
SecureRandom random)
{
int limit = dhParams.L;
if (limit != 0)
{
int minWeight = limit >> 2;
for (;;)
{
BigInteger x = new BigInteger(limit, random).SetBit(limit - 1);
if (WNafUtilities.GetNafWeight(x) >= minWeight)
{
return(x);
}
}
}
BigInteger min = BigInteger.Two;
int m = dhParams.M;
if (m != 0)
{
min = BigInteger.One.ShiftLeft(m - 1);
}
BigInteger q = dhParams.Q;
if (q == null)
{
q = dhParams.P;
}
BigInteger max = q.Subtract(BigInteger.Two);
{
int minWeight = max.BitLength >> 2;
for (;;)
{
BigInteger x = BigIntegers.CreateRandomInRange(min, max, random);
if (WNafUtilities.GetNafWeight(x) >= minWeight)
{
return(x);
}
}
}
}
private static BigInteger GeneratePrivateKey(BigInteger q, SecureRandom random)
{
// B.1.2 Key Pair Generation by Testing Candidates
int minWeight = q.BitLength >> 2;
for (;;)
{
// TODO Prefer this method? (change test cases that used fixed random)
// B.1.1 Key Pair Generation Using Extra Random Bits
//BigInteger x = new BigInteger(q.BitLength + 64, random).Mod(q.Subtract(One)).Add(One);
BigInteger x = BigIntegers.CreateRandomInRange(One, q.Subtract(One), random);
if (WNafUtilities.GetNafWeight(x) >= minWeight)
{
return x;
}
}
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int[] array = WNafUtilities.GenerateCompactNaf(k);
ECPoint eCPoint = p.Curve.Infinity;
ECPoint eCPoint2 = p;
int num = 0;
foreach (int num2 in array)
{
int num3 = num2 >> 16;
num += (num2 & 0xFFFF);
eCPoint2 = eCPoint2.TimesPow2(num);
eCPoint = eCPoint.Add((num3 < 0) ? eCPoint2.Negate() : eCPoint2);
num = 1;
}
return(eCPoint);
}
internal static ECPoint ImplSumOfMultiplies(ECPoint[] ps, BigInteger[] ks)
{
int num = ps.Length;
bool[] array = new bool[num];
WNafPreCompInfo[] array2 = new WNafPreCompInfo[num];
byte[][] array3 = new byte[num][];
for (int i = 0; i < num; i++)
{
BigInteger bigInteger = ks[i];
array[i] = (bigInteger.SignValue < 0);
bigInteger = bigInteger.Abs();
int width = Math.Max(2, Math.Min(16, WNafUtilities.GetWindowSize(bigInteger.BitLength)));
array2[i] = WNafUtilities.Precompute(ps[i], width, includeNegated: true);
array3[i] = WNafUtilities.GenerateWindowNaf(width, bigInteger);
}
return(ImplSumOfMultiplies(array, array2, array3));
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int[] array = WNafUtilities.GenerateCompactNaf(k);
ECPoint eCPoint = p.Normalize();
ECPoint eCPoint2 = eCPoint.Negate();
ECPoint eCPoint3 = p.Curve.Infinity;
int num = array.Length;
while (--num >= 0)
{
int num2 = array[num];
int num3 = num2 >> 16;
int e = num2 & 0xFFFF;
eCPoint3 = eCPoint3.TwicePlus((num3 < 0) ? eCPoint2 : eCPoint);
eCPoint3 = eCPoint3.TimesPow2(e);
}
return(eCPoint3);
}
internal static ECPoint ImplSumOfMultiplies(ECPoint[] ps, BigInteger[] ks)
{
int length = ps.Length;
bool[] negs = new bool[length];
WNafPreCompInfo[] infos = new WNafPreCompInfo[length];
byte[][] wnafs = new byte[length][];
for (int i = 0; i < length; i++)
{
BigInteger k = ks[i];
negs[i] = k.SignValue < 0;
k = k.Abs();
int width = Math.Max(2, Math.Min(0x10, WNafUtilities.GetWindowSize(k.BitLength)));
infos[i] = WNafUtilities.Precompute(ps[i], width, true);
wnafs[i] = WNafUtilities.GenerateWindowNaf(width, k);
}
return(ImplSumOfMultiplies(negs, infos, wnafs));
}
internal static ECPoint ImplSumOfMultiplies(ECPoint[] ps, BigInteger[] ks)
{
int count = ps.Length;
bool[] negs = new bool[count];
WNafPreCompInfo[] infos = new WNafPreCompInfo[count];
byte[][] wnafs = new byte[count][];
for (int i = 0; i < count; ++i)
{
BigInteger ki = ks[i]; negs[i] = ki.SignValue < 0; ki = ki.Abs();
int width = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(ki.BitLength)));
infos[i] = WNafUtilities.Precompute(ps[i], width, true);
wnafs[i] = WNafUtilities.GenerateWindowNaf(width, ki);
}
return(ImplSumOfMultiplies(negs, infos, wnafs));
}
public AsymmetricCipherKeyPair GenerateKeyPair()
{
SecureRandom random = param.Random;
Gost3410Parameters gost3410Params = param.Parameters;
BigInteger q = gost3410Params.Q, x;
int minWeight = 64;
for (;;)
{
x = new BigInteger(256, random);
if (x.SignValue < 1 || x.CompareTo(q) >= 0)
{
continue;
}
if (WNafUtilities.GetNafWeight(x) < minWeight)
{
continue;
}
break;
}
BigInteger p = gost3410Params.P;
BigInteger a = gost3410Params.A;
// calculate the public key.
BigInteger y = a.ModPow(x, p);
if (param.PublicKeyParamSet != null)
{
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, param.PublicKeyParamSet),
new Gost3410PrivateKeyParameters(x, param.PublicKeyParamSet)));
}
return(new AsymmetricCipherKeyPair(
new Gost3410PublicKeyParameters(y, gost3410Params),
new Gost3410PrivateKeyParameters(x, gost3410Params)));
}
public static byte[] GeneratePrivateKey(SecureRandom random = null)
{
if (random == null)
{
random = new SecureRandom();
}
// generates a private key that will always
// have 32 bits of info and have a a positive
// public key Y coordinate
BigInteger n = domainParms.N;
BigInteger d;
int minWeight = n.BitLength / 4;
for (; ;)
{
var bytes = new byte[32];
random.NextBytes(bytes);
while (bytes[0] > 127 || bytes[0] == 0)
{
bytes[0] = (byte)random.Next();
}
d = new BigInteger(bytes);
var dbytes = d.ToByteArray();
var nafWeight = WNafUtilities.GetNafWeight(d);
if (nafWeight < minWeight)
{
continue;
}
var m = new FixedPointCombMultiplier();
ECPoint q = m.Multiply(domainParms.G, d).Normalize();
bool isOdd = q.AffineYCoord.TestBitZero();
if (!isOdd)
{
return(dbytes);
}
}
}
/**
* Given the domain parameters this routine generates an EC key
* pair in accordance with X9.62 section 5.2.1 pages 26, 27.
*/
public AsymmetricCipherKeyPair GenerateKeyPair()
{
BigInteger n = parameters.N;
BigInteger d;
int minWeight = n.BitLength >> 2;
for (;;)
{
d = new BigInteger(n.BitLength, random);
if (d.CompareTo(BigInteger.Two) < 0 || d.CompareTo(n) >= 0)
{
continue;
}
/*
* Require a minimum weight of the NAF representation, since low-weight primes may be
* weak against a version of the number-field-sieve for the discrete-logarithm-problem.
*
* See "The number field sieve for integers of low weight", Oliver Schirokauer.
*/
if (WNafUtilities.GetNafWeight(d) < minWeight)
{
continue;
}
break;
}
ECPoint q = CreateBasePointMultiplier().Multiply(parameters.G, d);
if (publicKeyParamSet != null)
{
return(new AsymmetricCipherKeyPair(
new ECPublicKeyParameters(algorithm, q, publicKeyParamSet),
new ECPrivateKeyParameters(algorithm, d, publicKeyParamSet)));
}
return(new AsymmetricCipherKeyPair(
new ECPublicKeyParameters(algorithm, q, parameters),
new ECPrivateKeyParameters(algorithm, d, parameters)));
}
internal static ECPoint ImplShamirsTrickWNaf(ECPoint P, BigInteger k, ECPoint Q, BigInteger l)
{
bool flag = k.SignValue < 0;
bool flag2 = l.SignValue < 0;
k = k.Abs();
l = l.Abs();
int width = Math.Max(2, Math.Min(16, WNafUtilities.GetWindowSize(k.BitLength)));
int width2 = Math.Max(2, Math.Min(16, WNafUtilities.GetWindowSize(l.BitLength)));
WNafPreCompInfo wNafPreCompInfo = WNafUtilities.Precompute(P, width, includeNegated: true);
WNafPreCompInfo wNafPreCompInfo2 = WNafUtilities.Precompute(Q, width2, includeNegated: true);
ECPoint[] preCompP = flag ? wNafPreCompInfo.PreCompNeg : wNafPreCompInfo.PreComp;
ECPoint[] preCompQ = flag2 ? wNafPreCompInfo2.PreCompNeg : wNafPreCompInfo2.PreComp;
ECPoint[] preCompNegP = flag ? wNafPreCompInfo.PreComp : wNafPreCompInfo.PreCompNeg;
ECPoint[] preCompNegQ = flag2 ? wNafPreCompInfo2.PreComp : wNafPreCompInfo2.PreCompNeg;
byte[] wnafP = WNafUtilities.GenerateWindowNaf(width, k);
byte[] wnafQ = WNafUtilities.GenerateWindowNaf(width2, l);
return(ImplShamirsTrickWNaf(preCompP, preCompNegP, wnafP, preCompQ, preCompNegQ, wnafQ));
}
internal static ECPoint ImplShamirsTrickWNaf(ECPoint P, BigInteger k, ECPointMap pointMapQ, BigInteger l)
{
bool flag = k.SignValue < 0;
bool flag2 = l.SignValue < 0;
k = k.Abs();
l = l.Abs();
int width = Math.Max(2, Math.Min(0x10, WNafUtilities.GetWindowSize(Math.Max(k.BitLength, l.BitLength))));
ECPoint p = WNafUtilities.MapPointWithPrecomp(P, width, true, pointMapQ);
WNafPreCompInfo wNafPreCompInfo = WNafUtilities.GetWNafPreCompInfo(P);
WNafPreCompInfo info2 = WNafUtilities.GetWNafPreCompInfo(p);
ECPoint[] preCompP = !flag ? wNafPreCompInfo.PreComp : wNafPreCompInfo.PreCompNeg;
ECPoint[] preCompQ = !flag2 ? info2.PreComp : info2.PreCompNeg;
ECPoint[] preCompNegP = !flag ? wNafPreCompInfo.PreCompNeg : wNafPreCompInfo.PreComp;
ECPoint[] preCompNegQ = !flag2 ? info2.PreCompNeg : info2.PreComp;
byte[] wnafP = WNafUtilities.GenerateWindowNaf(width, k);
byte[] wnafQ = WNafUtilities.GenerateWindowNaf(width, l);
return(ImplShamirsTrickWNaf(preCompP, preCompNegP, wnafP, preCompQ, preCompNegQ, wnafQ));
}
internal static ECPoint ImplShamirsTrickJsf(ECPoint P, BigInteger k, ECPoint Q, BigInteger l)
{
ECCurve curve = P.Curve;
ECPoint infinity = curve.Infinity;
ECPoint eCPoint = P.Add(Q);
ECPoint eCPoint2 = P.Subtract(Q);
ECPoint[] array = new ECPoint[4]
{
Q,
eCPoint2,
P,
eCPoint
};
curve.NormalizeAll(array);
ECPoint[] array2 = new ECPoint[9]
{
array[3].Negate(),
array[2].Negate(),
array[1].Negate(),
array[0].Negate(),
infinity,
array[0],
array[1],
array[2],
array[3]
};
byte[] array3 = WNafUtilities.GenerateJsf(k, l);
ECPoint eCPoint3 = infinity;
int num = array3.Length;
while (--num >= 0)
{
int num2 = array3[num];
int num3 = num2 << 24 >> 28;
int num4 = num2 << 28 >> 28;
int num5 = 4 + num3 * 3 + num4;
eCPoint3 = eCPoint3.TwicePlus(array2[num5]);
}
return(eCPoint3);
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int[] naf = WNafUtilities.GenerateCompactNaf(k);
ECPoint addP = p.Normalize(), subP = addP.Negate();
ECPoint R = p.Curve.Infinity;
int i = naf.Length;
while (--i >= 0)
{
int ni = naf[i];
int digit = ni >> 16, zeroes = ni & 0xFFFF;
R = R.TwicePlus(digit < 0 ? subP : addP);
R = R.TimesPow2(zeroes);
}
return(R);
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int[] naf = WNafUtilities.GenerateCompactNaf(k);
ECPoint R0 = p.Curve.Infinity, R1 = p;
int zeroes = 0;
for (int i = 0; i < naf.Length; ++i)
{
int ni = naf[i];
int digit = ni >> 16;
zeroes += ni & 0xFFFF;
R1 = R1.TimesPow2(zeroes);
R0 = R0.Add(digit < 0 ? R1.Negate() : R1);
zeroes = 1;
}
return(R0);
}
public AsymmetricCipherKeyPair GenerateKeyPair()
{
SecureRandom random = param.Random;
Gost3410Parameters parameters = param.Parameters;
BigInteger q = parameters.Q;
int num = 64;
BigInteger bigInteger;
do
{
bigInteger = new BigInteger(256, random);
}while (bigInteger.SignValue < 1 || bigInteger.CompareTo(q) >= 0 || WNafUtilities.GetNafWeight(bigInteger) < num);
BigInteger p = parameters.P;
BigInteger a = parameters.A;
BigInteger y = a.ModPow(bigInteger, p);
if (param.PublicKeyParamSet != null)
{
return(new AsymmetricCipherKeyPair(new Gost3410PublicKeyParameters(y, param.PublicKeyParamSet), new Gost3410PrivateKeyParameters(bigInteger, param.PublicKeyParamSet)));
}
return(new AsymmetricCipherKeyPair(new Gost3410PublicKeyParameters(y, parameters), new Gost3410PrivateKeyParameters(bigInteger, parameters)));
}
internal static ECPoint ImplShamirsTrickJsf(ECPoint P, BigInteger k, ECPoint Q, BigInteger l)
{
var curve = P.Curve;
var infinity = curve.Infinity;
// TODO conjugate co-Z addition (ZADDC) can return both of these
var PaddQ = P.Add(Q);
var PsubQ = P.Subtract(Q);
var points = new[] { Q, PsubQ, P, PaddQ };
curve.NormalizeAll(points);
var table = new[]
{
points[3].Negate(), points[2].Negate(), points[1].Negate(),
points[0].Negate(), infinity, points[0],
points[1], points[2], points[3]
};
var jsf = WNafUtilities.GenerateJsf(k, l);
var R = infinity;
var i = jsf.Length;
while (--i >= 0)
{
int jsfi = jsf[i];
// NOTE: The shifting ensures the sign is extended correctly
int kDigit = (jsfi << 24) >> 28, lDigit = (jsfi << 28) >> 28;
var index = 4 + kDigit * 3 + lDigit;
R = R.TwicePlus(table[index]);
}
return(R);
}
/**
* Given the domain parameters this routine generates an EC key
* pair in accordance with X9.62 section 5.2.1 pages 26, 27.
*/
public AsymmetricCipherKeyPair GenerateKeyPair()
{
BigInteger n = parameters.N;
BigInteger upper = n.Subtract(BigInteger.Two);
BigInteger d;
int minWeight = n.BitLength >> 2;
for (;;)
{
d = new BigInteger(n.BitLength, random);
if (d.CompareTo(upper) > 0)
{
continue;
}
if (WNafUtilities.GetNafWeight(d) < minWeight)
{
continue;
}
break;
}
d = d.Add(BigInteger.One);
ECPoint q = CreateBasePointMultiplier().Multiply(parameters.G, d);
if (publicKeyParamSet != null)
{
return(new AsymmetricCipherKeyPair(
new ECPublicKeyParameters(algorithm, q, publicKeyParamSet),
new ECPrivateKeyParameters(algorithm, d, publicKeyParamSet)));
}
return(new AsymmetricCipherKeyPair(
new ECPublicKeyParameters(algorithm, q, parameters),
new ECPrivateKeyParameters(algorithm, d, parameters)));
}
internal static ECPoint ImplShamirsTrickWNaf(ECPoint P, BigInteger k,
ECPoint Q, BigInteger l)
{
bool negK = k.SignValue < 0, negL = l.SignValue < 0;
BigInteger kAbs = k.Abs(), lAbs = l.Abs();
int minWidthP = WNafUtilities.GetWindowSize(kAbs.BitLength, 8);
int minWidthQ = WNafUtilities.GetWindowSize(lAbs.BitLength, 8);
WNafPreCompInfo infoP = WNafUtilities.Precompute(P, minWidthP, true);
WNafPreCompInfo infoQ = WNafUtilities.Precompute(Q, minWidthQ, true);
// When P, Q are 'promoted' (i.e. reused several times), switch to fixed-point algorithm
{
ECCurve c = P.Curve;
int combSize = FixedPointUtilities.GetCombSize(c);
if (!negK && !negL &&
k.BitLength <= combSize && l.BitLength <= combSize &&
infoP.IsPromoted && infoQ.IsPromoted)
{
return(ImplShamirsTrickFixedPoint(P, k, Q, l));
}
}
int widthP = System.Math.Min(8, infoP.Width);
int widthQ = System.Math.Min(8, infoQ.Width);
ECPoint[] preCompP = negK ? infoP.PreCompNeg : infoP.PreComp;
ECPoint[] preCompQ = negL ? infoQ.PreCompNeg : infoQ.PreComp;
ECPoint[] preCompNegP = negK ? infoP.PreComp : infoP.PreCompNeg;
ECPoint[] preCompNegQ = negL ? infoQ.PreComp : infoQ.PreCompNeg;
byte[] wnafP = WNafUtilities.GenerateWindowNaf(widthP, kAbs);
byte[] wnafQ = WNafUtilities.GenerateWindowNaf(widthQ, lAbs);
return(ImplShamirsTrickWNaf(preCompP, preCompNegP, wnafP, preCompQ, preCompNegQ, wnafQ));
}
internal static ECPoint ImplShamirsTrickWNaf(ECPoint P, BigInteger k, ECPointMap pointMapQ, BigInteger l)
{
bool negK = k.SignValue < 0, negL = l.SignValue < 0;
k = k.Abs();
l = l.Abs();
int width = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(System.Math.Max(k.BitLength, l.BitLength))));
ECPoint Q = WNafUtilities.MapPointWithPrecomp(P, width, true, pointMapQ);
WNafPreCompInfo infoP = WNafUtilities.GetWNafPreCompInfo(P);
WNafPreCompInfo infoQ = WNafUtilities.GetWNafPreCompInfo(Q);
ECPoint[] preCompP = negK ? infoP.PreCompNeg : infoP.PreComp;
ECPoint[] preCompQ = negL ? infoQ.PreCompNeg : infoQ.PreComp;
ECPoint[] preCompNegP = negK ? infoP.PreComp : infoP.PreCompNeg;
ECPoint[] preCompNegQ = negL ? infoQ.PreComp : infoQ.PreCompNeg;
byte[] wnafP = WNafUtilities.GenerateWindowNaf(width, k);
byte[] wnafQ = WNafUtilities.GenerateWindowNaf(width, l);
return(ImplShamirsTrickWNaf(preCompP, preCompNegP, wnafP, preCompQ, preCompNegQ, wnafQ));
}
internal BigInteger CalculatePrivate(DHParameters dhParams, SecureRandom random)
{
BigInteger integer5;
int l = dhParams.L;
if (l != 0)
{
BigInteger integer;
int num2 = l >> 2;
do
{
integer = new BigInteger(l, random).SetBit(l - 1);
}while (WNafUtilities.GetNafWeight(integer) < num2);
return(integer);
}
BigInteger two = BigInteger.Two;
int m = dhParams.M;
if (m != 0)
{
two = BigInteger.One.ShiftLeft(m - 1);
}
BigInteger q = dhParams.Q;
if (q == null)
{
q = dhParams.P;
}
BigInteger max = q.Subtract(BigInteger.Two);
int num4 = max.BitLength >> 2;
do
{
integer5 = BigIntegers.CreateRandomInRange(two, max, random);
}while (WNafUtilities.GetNafWeight(integer5) < num4);
return(integer5);
}
internal BigInteger CalculatePrivate(DHParameters dhParams, SecureRandom random)
{
int l = dhParams.L;
if (l != 0)
{
int num = l >> 2;
BigInteger bigInteger;
do
{
bigInteger = new BigInteger(l, random).SetBit(l - 1);
}while (WNafUtilities.GetNafWeight(bigInteger) < num);
return(bigInteger);
}
BigInteger min = BigInteger.Two;
int m = dhParams.M;
if (m != 0)
{
min = BigInteger.One.ShiftLeft(m - 1);
}
BigInteger bigInteger2 = dhParams.Q;
if (bigInteger2 == null)
{
bigInteger2 = dhParams.P;
}
BigInteger bigInteger3 = bigInteger2.Subtract(BigInteger.Two);
int num2 = bigInteger3.BitLength >> 2;
BigInteger bigInteger4;
do
{
bigInteger4 = BigIntegers.CreateRandomInRange(min, bigInteger3, random);
}while (WNafUtilities.GetNafWeight(bigInteger4) < num2);
return(bigInteger4);
}
internal static ECPoint ImplShamirsTrickJsf(ECPoint P, BigInteger k, ECPoint Q, BigInteger l)
{
ECCurve curve = P.Curve;
ECPoint infinity = curve.Infinity;
ECPoint point2 = P.Add(Q);
ECPoint point3 = P.Subtract(Q);
ECPoint[] points = new ECPoint[] { Q, point3, P, point2 };
curve.NormalizeAll(points);
ECPoint[] pointArray2 = new ECPoint[] { points[3].Negate(), points[2].Negate(), points[1].Negate(), points[0].Negate(), infinity, points[0], points[1], points[2], points[3] };
byte[] buffer = WNafUtilities.GenerateJsf(k, l);
ECPoint point4 = infinity;
int length = buffer.Length;
while (--length >= 0)
{
int num2 = buffer[length];
int num3 = (num2 << 0x18) >> 0x1c;
int num4 = (num2 << 0x1c) >> 0x1c;
int index = (4 + (num3 * 3)) + num4;
point4 = point4.TwicePlus(pointArray2[index]);
}
return(point4);
}
public BigInteger GenerateRandom()
{
BigInteger d;
int minWeight = curve.N.BitLength >> 2;
for (; ;)
{
d = new BigInteger(curve.N.BitLength, random);
if (d.CompareTo(BigInteger.Two) < 0 || d.CompareTo(curve.N) >= 0)
{
continue;
}
if (WNafUtilities.GetNafWeight(d) < minWeight)
{
continue;
}
break;
}
return(d);
}
