baseelgamalkeypairgenerator.java

来自「jpeg2000编解码」· Java 代码 · 共 412 行 · 第 1/2 页

//...........................................................................

    public BaseElGamalKeyPairGenerator() { super("ElGamal"); }

    /**
     * Initialises the key pair generator using the prime and base from
     * the specified ElGamalParams object.
     *
     * @param params    the parameters to use to generate the keys.
     * @param random    the random bit source to use to generate 
     *                  key bits.
     * @exception NullPointerException if params == null || random == null
     * @exception InvalidParameterException if the parameters passed are
     *                  invalid.
     */
    public void initialize(ElGamalParams params, SecureRandom random)
        throws InvalidParameterException {
        initialize(params.getP(), params.getG(), random);
    }

    /**
     * Initialises the key pair generator using the specified prime
     * (</i>p</i>) and base (<i>g</i>). The difficulty of cracking ElGamal
     * by solving the discrete logarithm problem is dependent on the length
     * of the prime.
     * <p>
     * An InvalidParameterException will be thrown if <code>base >= prime</code>.
     *
     * @param prime     the prime to be used, as a java.math.BigInteger
     * @param base      the base to be used, as a java.math.BigInteger
     * @param random    the random bit source to use to generate 
     *                  key bits.
     * @exception NullPointerException if prime == null || base == null ||
     *                  random == null
     * @exception InvalidParameterException if the parameters passed are
     *                  invalid.
     */
    public void initialize(BigInteger prime, BigInteger base, SecureRandom random)
        throws InvalidParameterException {
        if (prime == null) throw new NullPointerException("prime == null");
        if (base == null) throw new NullPointerException("base == null");
        if (random == null) throw new NullPointerException("random == null");
        if (base.compareTo(prime) >= 0)
            throw new InvalidParameterException("base >= prime");

        p = prime;
        g = base;
        source = random;
    }

    /**
     * Initialises the key pair generator for a given prime length,
     * without parameters.
     *
     * @param primeLen  the prime length, in bits. Valid lengths are any
     *                  integer >= 256.
     * @param random    the random bit source to use to generate
     *                  key bits.
     * @exception InvalidParameterException if the prime length is less
     *                  than 256.
     */
    public void initialize(int primeLen, SecureRandom random) {
        ElGamalParams params = null;
        if (USE_PRECOMPUTED && defaultParamSet != null)
            params = defaultParamSet.getParameters(primeLen);

        if (params == null)
            params = generateParams(primeLen, random);

        p = params.getP();
        g = params.getG();
        source = random;
    }

    /**
     * Initialises the key pair generator for a given prime length,
     * without parameters.
     * <p>
     * If <i>genParams</i> is true, this method will generate new
     * p and g parameters. If it is false, the method will use precomputed
     * parameters for the prime length requested. If there are no
     * precomputed parameters for that prime length, an exception will be
     * thrown. It is guaranteed that there will always be default
     * parameters for a prime length of 512 bits.
     * <p>
     * [Future versions will probably also support 1024, 1536, 2048, 3072,
     * and 4096 bits.]
     *
     * @param primeLen  the prime length, in bits. Valid lengths are any
     *                  integer >= 256.
     * @param random    the random bit source to use to generate
     *                  key bits.
     * @param genParams whether to generate new parameters for the prime
     *                  length requested.
     * @exception InvalidParameterException if the prime length is less
     *                  than 256, or if genParams is false and there are not
     *                  precomputed parameters for the prime length requested.
     */
    public void initialize(int primeLen, boolean genParams, SecureRandom random)
        throws InvalidParameterException {
        if (primeLen < MIN_PRIME_LEN) throw new InvalidParameterException(
            "ElGamal: prime length " + primeLen + " is too short (< " + MIN_PRIME_LEN + ")");

        ElGamalParams params;
        if (!USE_PRECOMPUTED || genParams || defaultParamSet == null) {
            params = generateParams(primeLen, random);
        } else {
            params = defaultParamSet.getParameters(primeLen);
            if (params == null) throw new InvalidParameterException(
                "ElGamal: no pre-computed parameters for prime length " + primeLen);
        }
        p = params.getP();
        g = params.getG();
        source = random;
    }

    /**
     * Generates a key pair.
     */
    public KeyPair generateKeyPair() {
        if (p == null) throw new CryptixException(
            "ElGamal: key pair generator not initialized");

        int length = p.bitLength()-1;
        BigInteger x = new BigInteger(length, source).setBit(length);

        ElGamalPrivateKey privateKey =
            new BaseElGamalPrivateKey(p, g, x);
        ElGamalPublicKey publicKey =
            new BaseElGamalPublicKey(p, g, privateKey.getY());
        return new KeyPair(publicKey, privateKey);
    }

    /**
     * Generates new parameters, <i>p</i> and <i>g</i>. This method
     * does not change the parameters currently being used by
     * <code>generateKeyPair</code>.
     *
     * @param primeLen  the prime length, in bits. Valid lengths are any
     *                  integer >= 256.
     * @param random    the random bit source to use to generate the parameters.
     * @exception InvalidParameterException if the prime length is less
     *                  than 256.
     */
    public ElGamalParams generateParams(int primeLen, SecureRandom random)
    throws InvalidParameterException {
        if (primeLen < MIN_PRIME_LEN) throw new InvalidParameterException(
            "ElGamal: prime length " + primeLen + " is too short (< " + MIN_PRIME_LEN + ")");

        Object[] result = Prime.getElGamal(primeLen, CONFIDENCE, random, PRIME_TYPE);
        BigInteger newP = (BigInteger) result[0];
        BigInteger[] q = (BigInteger[]) result[1];
        BigInteger newG = findG(newP, q, random);
        return new BaseElGamalParams(newP, newG);
    }

    /**
     * Returns a generator mod <i>p</i>. <i>q</i> is an array containing all
     * the prime factors of <i>p-1</i>.
     * <p>
     * This algorithm is based on Schneier page 254.
     */
    private static BigInteger findG(BigInteger p, BigInteger[] q,
                                    SecureRandom random) {
        BigInteger p_minus_1 = p.subtract(ONE);
        BigInteger[] z = new BigInteger[q.length];
        BigInteger g;

        // z_i = (p-1)/q_i for each factor q_i
        for (int i = 0; i < q.length; i++) {
            z[i] = p_minus_1.divide(q[i]);
        }
if (DEBUG && debuglevel >= 5) progress("g =");
        if (USE_SMALL_G) {
            for (int i = 0; i < efficientBases.length; i++) {
                g = efficientBases[i];
if (DEBUG && debuglevel >= 5) progress(" " + g + "?");
                if (Prime.isGeneratorModP(g, p, z)) {
if (DEBUG && debuglevel >= 4) err.println(" OK");
                    return g;
                }
            }
        }
        int length = p.bitLength()-1;
        while (true) {
if (DEBUG && debuglevel >= 5) progress(" ?");
            g = new BigInteger(length, random).setBit(length);
            if (Prime.isGeneratorModP(g, p, z)) {
if (DEBUG && debuglevel >= 4) err.println(" OK");
                return g;
            }
        }
    }

    private static BigInteger[] efficientBases;

    static {
        if (USE_SMALL_G) {
            int[] eb = { 2, 3, 17, 257, 65537, };
            efficientBases = new BigInteger[eb.length];
            for (int i = 0; i < eb.length; i++)
                efficientBases[i] = BigInteger.valueOf(eb[i]);
        }
    }
}