308 lines
15 KiB
Java
308 lines
15 KiB
Java
package org.bouncycastle.crypto.generators;
|
|
|
|
import io.grpc.internal.GrpcUtil;
|
|
import java.io.PrintStream;
|
|
import java.math.BigInteger;
|
|
import java.security.SecureRandom;
|
|
import java.util.Vector;
|
|
import okhttp3.internal.http.StatusLine;
|
|
import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
|
|
import org.bouncycastle.crypto.AsymmetricCipherKeyPairGenerator;
|
|
import org.bouncycastle.crypto.KeyGenerationParameters;
|
|
import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
|
|
import org.bouncycastle.crypto.params.NaccacheSternKeyGenerationParameters;
|
|
import org.bouncycastle.crypto.params.NaccacheSternKeyParameters;
|
|
import org.bouncycastle.crypto.params.NaccacheSternPrivateKeyParameters;
|
|
import org.bouncycastle.crypto.tls.CipherSuite;
|
|
import org.bouncycastle.math.Primes;
|
|
import org.jmrtd.cbeff.ISO781611;
|
|
|
|
/* loaded from: classes6.dex */
|
|
public class NaccacheSternKeyPairGenerator implements AsymmetricCipherKeyPairGenerator {
|
|
private NaccacheSternKeyGenerationParameters param;
|
|
private static int[] smallPrimes = {3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, ISO781611.CREATION_DATE_AND_TIME_TAG, CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA, CipherSuite.TLS_PSK_WITH_3DES_EDE_CBC_SHA, CipherSuite.TLS_RSA_PSK_WITH_AES_256_CBC_SHA, 151, CipherSuite.TLS_RSA_WITH_AES_256_GCM_SHA384, CipherSuite.TLS_DHE_DSS_WITH_AES_256_GCM_SHA384, CipherSuite.TLS_DH_anon_WITH_AES_256_GCM_SHA384, CipherSuite.TLS_RSA_PSK_WITH_AES_256_GCM_SHA384, CipherSuite.TLS_DHE_PSK_WITH_AES_256_CBC_SHA384, CipherSuite.TLS_DHE_PSK_WITH_NULL_SHA384, CipherSuite.TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256, CipherSuite.TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256, CipherSuite.TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256, 199, Primes.SMALL_FACTOR_LIMIT, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, StatusLine.HTTP_MISDIRECTED_REQUEST, 431, 433, 439, GrpcUtil.DEFAULT_PORT_SSL, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557};
|
|
private static final BigInteger ONE = BigInteger.valueOf(1);
|
|
|
|
@Override // org.bouncycastle.crypto.AsymmetricCipherKeyPairGenerator
|
|
public void init(KeyGenerationParameters keyGenerationParameters) {
|
|
this.param = (NaccacheSternKeyGenerationParameters) keyGenerationParameters;
|
|
}
|
|
|
|
@Override // org.bouncycastle.crypto.AsymmetricCipherKeyPairGenerator
|
|
public AsymmetricCipherKeyPair generateKeyPair() {
|
|
long j;
|
|
BigInteger generatePrime;
|
|
BigInteger add;
|
|
BigInteger generatePrime2;
|
|
BigInteger bigInteger;
|
|
BigInteger bigInteger2;
|
|
BigInteger add2;
|
|
BigInteger bigInteger3;
|
|
BigInteger bigInteger4;
|
|
BigInteger bigInteger5;
|
|
BigInteger bigInteger6;
|
|
BigInteger bigInteger7;
|
|
BigInteger bigInteger8;
|
|
BigInteger bigInteger9;
|
|
PrintStream printStream;
|
|
StringBuilder sb;
|
|
long j2;
|
|
BigInteger bigInteger10;
|
|
int i;
|
|
int strength = this.param.getStrength();
|
|
SecureRandom random = this.param.getRandom();
|
|
int certainty = this.param.getCertainty();
|
|
boolean isDebug = this.param.isDebug();
|
|
if (isDebug) {
|
|
PrintStream printStream2 = System.out;
|
|
StringBuilder sb2 = new StringBuilder("Fetching first ");
|
|
sb2.append(this.param.getCntSmallPrimes());
|
|
sb2.append(" primes.");
|
|
printStream2.println(sb2.toString());
|
|
}
|
|
Vector permuteList = permuteList(findFirstPrimes(this.param.getCntSmallPrimes()), random);
|
|
BigInteger bigInteger11 = ONE;
|
|
BigInteger bigInteger12 = bigInteger11;
|
|
for (int i2 = 0; i2 < permuteList.size() / 2; i2++) {
|
|
bigInteger12 = bigInteger12.multiply((BigInteger) permuteList.elementAt(i2));
|
|
}
|
|
for (int size = permuteList.size() / 2; size < permuteList.size(); size++) {
|
|
bigInteger11 = bigInteger11.multiply((BigInteger) permuteList.elementAt(size));
|
|
}
|
|
BigInteger multiply = bigInteger12.multiply(bigInteger11);
|
|
int bitLength = (((strength - multiply.bitLength()) - 48) / 2) + 1;
|
|
BigInteger generatePrime3 = generatePrime(bitLength, certainty, random);
|
|
BigInteger generatePrime4 = generatePrime(bitLength, certainty, random);
|
|
if (isDebug) {
|
|
System.out.println("generating p and q");
|
|
}
|
|
BigInteger shiftLeft = generatePrime3.multiply(bigInteger12).shiftLeft(1);
|
|
BigInteger shiftLeft2 = generatePrime4.multiply(bigInteger11).shiftLeft(1);
|
|
long j3 = 0;
|
|
while (true) {
|
|
j = j3 + 1;
|
|
generatePrime = generatePrime(24, certainty, random);
|
|
add = generatePrime.multiply(shiftLeft).add(ONE);
|
|
if (add.isProbablePrime(certainty)) {
|
|
while (true) {
|
|
do {
|
|
generatePrime2 = generatePrime(24, certainty, random);
|
|
} while (generatePrime.equals(generatePrime2));
|
|
BigInteger multiply2 = generatePrime2.multiply(shiftLeft2);
|
|
bigInteger = shiftLeft2;
|
|
bigInteger2 = ONE;
|
|
add2 = multiply2.add(bigInteger2);
|
|
if (add2.isProbablePrime(certainty)) {
|
|
break;
|
|
}
|
|
shiftLeft2 = bigInteger;
|
|
}
|
|
bigInteger3 = shiftLeft;
|
|
if (!multiply.gcd(generatePrime.multiply(generatePrime2)).equals(bigInteger2)) {
|
|
continue;
|
|
} else {
|
|
if (add.multiply(add2).bitLength() >= strength) {
|
|
break;
|
|
}
|
|
if (isDebug) {
|
|
PrintStream printStream3 = System.out;
|
|
StringBuilder sb3 = new StringBuilder("key size too small. Should be ");
|
|
sb3.append(strength);
|
|
sb3.append(" but is actually ");
|
|
sb3.append(add.multiply(add2).bitLength());
|
|
printStream3.println(sb3.toString());
|
|
}
|
|
}
|
|
} else {
|
|
bigInteger = shiftLeft2;
|
|
bigInteger3 = shiftLeft;
|
|
}
|
|
j3 = j;
|
|
shiftLeft2 = bigInteger;
|
|
shiftLeft = bigInteger3;
|
|
}
|
|
BigInteger bigInteger13 = generatePrime4;
|
|
if (isDebug) {
|
|
PrintStream printStream4 = System.out;
|
|
bigInteger4 = generatePrime3;
|
|
StringBuilder sb4 = new StringBuilder("needed ");
|
|
sb4.append(j);
|
|
sb4.append(" tries to generate p and q.");
|
|
printStream4.println(sb4.toString());
|
|
} else {
|
|
bigInteger4 = generatePrime3;
|
|
}
|
|
BigInteger multiply3 = add.multiply(add2);
|
|
BigInteger multiply4 = add.subtract(bigInteger2).multiply(add2.subtract(bigInteger2));
|
|
if (isDebug) {
|
|
System.out.println("generating g");
|
|
}
|
|
long j4 = 0;
|
|
while (true) {
|
|
Vector vector = new Vector();
|
|
bigInteger5 = add;
|
|
bigInteger6 = add2;
|
|
int i3 = 0;
|
|
while (i3 != permuteList.size()) {
|
|
BigInteger divide = multiply4.divide((BigInteger) permuteList.elementAt(i3));
|
|
while (true) {
|
|
j2 = j4 + 1;
|
|
bigInteger10 = new BigInteger(strength, certainty, random);
|
|
i = strength;
|
|
if (!bigInteger10.modPow(divide, multiply3).equals(ONE)) {
|
|
break;
|
|
}
|
|
j4 = j2;
|
|
strength = i;
|
|
}
|
|
vector.addElement(bigInteger10);
|
|
i3++;
|
|
j4 = j2;
|
|
strength = i;
|
|
}
|
|
int i4 = strength;
|
|
bigInteger7 = ONE;
|
|
int i5 = 0;
|
|
while (i5 < permuteList.size()) {
|
|
bigInteger7 = bigInteger7.multiply(((BigInteger) vector.elementAt(i5)).modPow(multiply.divide((BigInteger) permuteList.elementAt(i5)), multiply3)).mod(multiply3);
|
|
i5++;
|
|
random = random;
|
|
}
|
|
SecureRandom secureRandom = random;
|
|
int i6 = 0;
|
|
while (true) {
|
|
if (i6 >= permuteList.size()) {
|
|
BigInteger modPow = bigInteger7.modPow(multiply4.divide(BigInteger.valueOf(4L)), multiply3);
|
|
BigInteger bigInteger14 = ONE;
|
|
if (!modPow.equals(bigInteger14)) {
|
|
if (!bigInteger7.modPow(multiply4.divide(generatePrime), multiply3).equals(bigInteger14)) {
|
|
if (!bigInteger7.modPow(multiply4.divide(generatePrime2), multiply3).equals(bigInteger14)) {
|
|
bigInteger8 = bigInteger4;
|
|
if (!bigInteger7.modPow(multiply4.divide(bigInteger8), multiply3).equals(bigInteger14)) {
|
|
bigInteger9 = bigInteger13;
|
|
if (!bigInteger7.modPow(multiply4.divide(bigInteger9), multiply3).equals(bigInteger14)) {
|
|
break;
|
|
}
|
|
if (isDebug) {
|
|
System.out.println("g has order phi(n)/b\n g: ".concat(String.valueOf(bigInteger7)));
|
|
}
|
|
} else {
|
|
if (isDebug) {
|
|
System.out.println("g has order phi(n)/a\n g: ".concat(String.valueOf(bigInteger7)));
|
|
}
|
|
bigInteger9 = bigInteger13;
|
|
}
|
|
} else if (isDebug) {
|
|
printStream = System.out;
|
|
sb = new StringBuilder("g has order phi(n)/q'\n g: ");
|
|
sb.append(bigInteger7);
|
|
printStream.println(sb.toString());
|
|
}
|
|
} else if (isDebug) {
|
|
printStream = System.out;
|
|
sb = new StringBuilder("g has order phi(n)/p'\n g: ");
|
|
sb.append(bigInteger7);
|
|
printStream.println(sb.toString());
|
|
}
|
|
} else if (isDebug) {
|
|
printStream = System.out;
|
|
sb = new StringBuilder("g has order phi(n)/4\n g:");
|
|
sb.append(bigInteger7);
|
|
printStream.println(sb.toString());
|
|
}
|
|
} else if (!bigInteger7.modPow(multiply4.divide((BigInteger) permuteList.elementAt(i6)), multiply3).equals(ONE)) {
|
|
i6++;
|
|
} else if (isDebug) {
|
|
PrintStream printStream5 = System.out;
|
|
StringBuilder sb5 = new StringBuilder("g has order phi(n)/");
|
|
sb5.append(permuteList.elementAt(i6));
|
|
sb5.append("\n g: ");
|
|
sb5.append(bigInteger7);
|
|
printStream5.println(sb5.toString());
|
|
}
|
|
}
|
|
bigInteger9 = bigInteger13;
|
|
bigInteger8 = bigInteger4;
|
|
bigInteger4 = bigInteger8;
|
|
bigInteger13 = bigInteger9;
|
|
add2 = bigInteger6;
|
|
add = bigInteger5;
|
|
strength = i4;
|
|
random = secureRandom;
|
|
}
|
|
if (isDebug) {
|
|
PrintStream printStream6 = System.out;
|
|
StringBuilder sb6 = new StringBuilder("needed ");
|
|
sb6.append(j4);
|
|
sb6.append(" tries to generate g");
|
|
printStream6.println(sb6.toString());
|
|
System.out.println();
|
|
System.out.println("found new NaccacheStern cipher variables:");
|
|
System.out.println("smallPrimes: ".concat(String.valueOf(permuteList)));
|
|
PrintStream printStream7 = System.out;
|
|
StringBuilder sb7 = new StringBuilder("sigma:...... ");
|
|
sb7.append(multiply);
|
|
sb7.append(" (");
|
|
sb7.append(multiply.bitLength());
|
|
sb7.append(" bits)");
|
|
printStream7.println(sb7.toString());
|
|
System.out.println("a:.......... ".concat(String.valueOf(bigInteger8)));
|
|
System.out.println("b:.......... ".concat(String.valueOf(bigInteger9)));
|
|
System.out.println("p':......... ".concat(String.valueOf(generatePrime)));
|
|
System.out.println("q':......... ".concat(String.valueOf(generatePrime2)));
|
|
System.out.println("p:.......... ".concat(String.valueOf(bigInteger5)));
|
|
System.out.println("q:.......... ".concat(String.valueOf(bigInteger6)));
|
|
System.out.println("n:.......... ".concat(String.valueOf(multiply3)));
|
|
System.out.println("phi(n):..... ".concat(String.valueOf(multiply4)));
|
|
System.out.println("g:.......... ".concat(String.valueOf(bigInteger7)));
|
|
System.out.println();
|
|
}
|
|
return new AsymmetricCipherKeyPair((AsymmetricKeyParameter) new NaccacheSternKeyParameters(false, bigInteger7, multiply3, multiply.bitLength()), (AsymmetricKeyParameter) new NaccacheSternPrivateKeyParameters(bigInteger7, multiply3, multiply.bitLength(), permuteList, multiply4));
|
|
}
|
|
|
|
private static Vector permuteList(Vector vector, SecureRandom secureRandom) {
|
|
Vector vector2 = new Vector();
|
|
Vector vector3 = new Vector();
|
|
for (int i = 0; i < vector.size(); i++) {
|
|
vector3.addElement(vector.elementAt(i));
|
|
}
|
|
vector2.addElement(vector3.elementAt(0));
|
|
while (true) {
|
|
vector3.removeElementAt(0);
|
|
if (vector3.size() == 0) {
|
|
return vector2;
|
|
}
|
|
vector2.insertElementAt(vector3.elementAt(0), getInt(secureRandom, vector2.size() + 1));
|
|
}
|
|
}
|
|
|
|
private static int getInt(SecureRandom secureRandom, int i) {
|
|
int nextInt;
|
|
int i2;
|
|
if (((-i) & i) == i) {
|
|
return (int) ((i * (secureRandom.nextInt() & Integer.MAX_VALUE)) >> 31);
|
|
}
|
|
do {
|
|
nextInt = secureRandom.nextInt() & Integer.MAX_VALUE;
|
|
i2 = nextInt % i;
|
|
} while ((nextInt - i2) + (i - 1) < 0);
|
|
return i2;
|
|
}
|
|
|
|
private static BigInteger generatePrime(int i, int i2, SecureRandom secureRandom) {
|
|
BigInteger bigInteger = new BigInteger(i, i2, secureRandom);
|
|
while (bigInteger.bitLength() != i) {
|
|
bigInteger = new BigInteger(i, i2, secureRandom);
|
|
}
|
|
return bigInteger;
|
|
}
|
|
|
|
private static Vector findFirstPrimes(int i) {
|
|
Vector vector = new Vector(i);
|
|
for (int i2 = 0; i2 != i; i2++) {
|
|
vector.addElement(BigInteger.valueOf(smallPrimes[i2]));
|
|
}
|
|
return vector;
|
|
}
|
|
}
|