private void init( int L, int N, int certainty, SecureRandom random) { // TODO Check that the (L, N) pair is in the list of acceptable (L, N pairs) (see Section 4.2) // TODO Should we enforce the minimum 'certainty' values as per C.3 Table C.1? this.L = L; this.N = N; this.certainty = certainty; this.random = random; }
private static BigInteger calculateGenerator_FIPS186_3_Unverifiable(BigInteger p, BigInteger q, SecureRandom r) { return calculateGenerator_FIPS186_2(p, q, r); }
/** * which generates the p and g values from the given parameters, * returning the DSAParameters object. * <p> * Note: can take a while... */ public DSAParameters generateParameters() { return (use186_3) ? generateParameters_FIPS186_3() : generateParameters_FIPS186_2(); }
/** * initialise the key generator. * * @param size size of the key (range 2^512 -> 2^1024 - 64 bit increments) * @param certainty measure of robustness of prime (for FIPS 186-2 compliance this should be at least 80). * @param random random byte source. */ public void init( int size, int certainty, SecureRandom random) { this.L = size; this.N = getDefaultN(size); this.certainty = certainty; this.iterations = Math.max(getMinimumIterations(L), (certainty + 1) / 2); this.random = random; this.use186_3 = false; this.usageIndex = -1; }
protected AlgorithmParameters engineGenerateParameters() { DSAParametersGenerator pGen = new DSAParametersGenerator(); if (random != null) { pGen.init(strength, 20, random); } else { pGen.init(strength, 20, new SecureRandom()); } DSAParameters p = pGen.generateParameters(); AlgorithmParameters params; try { params = AlgorithmParameters.getInstance("DSA", BouncyCastleProvider.PROVIDER_NAME); params.init(new DSAParameterSpec(p.getP(), p.getQ(), p.getG())); } catch (Exception e) { throw new RuntimeException(e.getMessage()); } return params; } }
hash(d, seed, output, 0); if (!isProbablePrime(q)) inc(offset); hash(d, offset, w, w.length - j * output.length); inc(offset); hash(d, offset, output, 0); System.arraycopy(output, output.length - remaining, w, 0, remaining); if (isProbablePrime(p)) BigInteger g = calculateGenerator_FIPS186_3_Verifiable(d, p, q, seed, usageIndex); if (g != null) BigInteger g = calculateGenerator_FIPS186_3_Unverifiable(p, q, random);
hash(digest, seed, part1, 0); System.arraycopy(seed, 0, part2, 0, seed.length); inc(part2); hash(digest, part2, part2, 0); if (!isProbablePrime(q)) inc(offset); inc(offset); hash(digest, offset, w, w.length - k * part1.length); inc(offset); hash(digest, offset, part1, 0); System.arraycopy(part1, part1.length - remaining, w, 0, remaining); if (isProbablePrime(p)) BigInteger g = calculateGenerator_FIPS186_2(p, q, random);
hash(sha1, seed, part1); System.arraycopy(seed, 0, part2, 0, seed.length); inc(part2); hash(sha1, part2, part2); inc(offset); inc(offset); hash(sha1, offset, part1); System.arraycopy(part1, 0, w, w.length - (k + 1) * part1.length, part1.length); inc(offset); hash(sha1, offset, part1); System.arraycopy(part1, part1.length - ((w.length - (n) * part1.length)), w, 0, w.length - n * part1.length); BigInteger g = calculateGenerator_FIPS186_2(p, q, random);
hash(d, seed, output); BigInteger U = new BigInteger(1, output).mod(ONE.shiftLeft(N - 1)); for (int j = 0, exp = 0; j <= n; ++j, exp += outlen) inc(offset); hash(d, offset, output); BigInteger g = calculateGenerator_FIPS186_3_Unverifiable(p, q, random); return new DSAParameters(p, q, g, new DSAValidationParameters(seed, counter));
private static BigInteger calculateGenerator_FIPS186_3_Verifiable(Digest d, BigInteger p, BigInteger q, byte[] seed, int index) { // A.2.3 Verifiable Canonical Generation of the Generator g BigInteger e = p.subtract(ONE).divide(q); byte[] ggen = Hex.decode("6767656E"); // 7. U = domain_parameter_seed || "ggen" || index || count. byte[] U = new byte[seed.length + ggen.length + 1 + 2]; System.arraycopy(seed, 0, U, 0, seed.length); System.arraycopy(ggen, 0, U, seed.length, ggen.length); U[U.length - 3] = (byte)index; byte[] w = new byte[d.getDigestSize()]; for (int count = 1; count < (1 << 16); ++count) { inc(U); hash(d, U, w, 0); BigInteger W = new BigInteger(1, w); BigInteger g = W.modPow(e, p); if (g.compareTo(TWO) >= 0) { return g; } } return null; }
pGen = new DSAParametersGenerator(); pGen = new DSAParametersGenerator(new SHA256Digest()); pGen.init(params); pGen.init(params); pGen.init(strength, certainty, random); DSAParameters p = pGen.generateParameters();
public KeyPair generateKeyPair() { if (!initialised) { DSAParametersGenerator pGen = new DSAParametersGenerator(); pGen.init(strength, certainty, random); param = new DSAKeyGenerationParameters(random, pGen.generateParameters()); engine.init(param); initialised = true; } AsymmetricCipherKeyPair pair = engine.generateKeyPair(); DSAPublicKeyParameters pub = (DSAPublicKeyParameters)pair.getPublic(); DSAPrivateKeyParameters priv = (DSAPrivateKeyParameters)pair.getPrivate(); return new KeyPair(new BCDSAPublicKey(pub), new BCDSAPrivateKey(priv)); } }
/** * which generates the p and g values from the given parameters, * returning the DSAParameters object. * <p> * Note: can take a while... */ public DSAParameters generateParameters() { return L > 1024 ? generateParameters_FIPS186_3() : generateParameters_FIPS186_2(); }
private static BigInteger calculateGenerator_FIPS186_3_Unverifiable(BigInteger p, BigInteger q, SecureRandom r) { return calculateGenerator_FIPS186_2(p, q, r); }
pGen = new DSAParametersGenerator(); if (Properties.isOverrideSet("org.spongycastle.dsa.FIPS186-2for1024bits")) pGen.init(strength, certainty, random); pGen.init(dsaParams); pGen = new DSAParametersGenerator(new SHA256Digest()); pGen.init(dsaParams); pGen = new DSAParametersGenerator(); pGen.init(strength, certainty, random); param = new DSAKeyGenerationParameters(random, pGen.generateParameters());