Java DHGenParameterSpec类代码示例

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
@Override
protected void engineInit(
    AlgorithmParameterSpec  genParamSpec,
    SecureRandom            random)
    throws InvalidAlgorithmParameterException
{
    if (!(genParamSpec instanceof DHGenParameterSpec))
    {
        throw new InvalidAlgorithmParameterException("DH parameter generator requires a DHGenParameterSpec for initialisation");
    }
    DHGenParameterSpec  spec = (DHGenParameterSpec)genParamSpec;

    this.strength = spec.getPrimeSize();
    this.l = spec.getExponentSize();
    this.random = random;
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
public void initialize(AlgorithmParameterSpec params, SecureRandom random)
    throws InvalidAlgorithmParameterException
{
  HashMap attributes = new HashMap();
  if (params != null)
    {
      if (! (params instanceof DHGenParameterSpec) &&
          ! (params instanceof DHParameterSpec))
        throw new InvalidAlgorithmParameterException("params");

      attributes.put(GnuDHKeyPairGenerator.DH_PARAMETERS, params);
    }

  if (random != null)
    attributes.put(GnuDHKeyPairGenerator.SOURCE_OF_RANDOMNESS, random);

  attributes.put(GnuDHKeyPairGenerator.PREFERRED_ENCODING_FORMAT,
                 Integer.valueOf(Registry.ASN1_ENCODING_ID));
  adaptee.setup(attributes);
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
protected void engineInit(
    AlgorithmParameterSpec genParamSpec,
    SecureRandom random)
    throws InvalidAlgorithmParameterException
{
    if (!(genParamSpec instanceof DHGenParameterSpec))
    {
        throw new InvalidAlgorithmParameterException("DH parameter generator requires a DHGenParameterSpec for initialisation");
    }
    DHGenParameterSpec spec = (DHGenParameterSpec)genParamSpec;

    this.strength = spec.getPrimeSize();
    this.l = spec.getExponentSize();
    this.random = random;
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
/**
 * Initializes this parameter generator with a set of parameter
 * generation values, which specify the size of the prime modulus and
 * the size of the random exponent, both in bits.
 *
 * @param params the set of parameter generation values
 * @param random the source of randomness
 *
 * @exception InvalidAlgorithmParameterException if the given parameter
 * generation values are inappropriate for this parameter generator
 */
protected void engineInit(AlgorithmParameterSpec genParamSpec,
                          SecureRandom random)
    throws InvalidAlgorithmParameterException {
    if (!(genParamSpec instanceof DHGenParameterSpec)) {
        throw new InvalidAlgorithmParameterException
            ("Inappropriate parameter type");
    }

    DHGenParameterSpec dhParamSpec = (DHGenParameterSpec)genParamSpec;

    primeSize = dhParamSpec.getPrimeSize();

    // Re-uses DSA parameters and thus have the same range
    checkKeySize(primeSize);

    exponentSize = dhParamSpec.getExponentSize();
    if (exponentSize <= 0) {
        throw new InvalidAlgorithmParameterException
            ("Exponent size must be greater than zero");
    }

    // Require exponentSize < primeSize
    if (exponentSize >= primeSize) {
        throw new InvalidAlgorithmParameterException
            ("Exponent size must be less than modulus size");
    }
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
/**
 * Initializes this parameter generator with a set of parameter
 * generation values, which specify the size of the prime modulus and
 * the size of the random exponent, both in bits.
 *
 * @param params the set of parameter generation values
 * @param random the source of randomness
 *
 * @exception InvalidAlgorithmParameterException if the given parameter
 * generation values are inappropriate for this parameter generator
 */
protected void engineInit(AlgorithmParameterSpec genParamSpec,
                          SecureRandom random)
    throws InvalidAlgorithmParameterException {
    if (!(genParamSpec instanceof DHGenParameterSpec)) {
        throw new InvalidAlgorithmParameterException
            ("Inappropriate parameter type");
    }

    DHGenParameterSpec dhParamSpec = (DHGenParameterSpec)genParamSpec;

    primeSize = dhParamSpec.getPrimeSize();

    // Re-uses DSA parameters and thus have the same range
    try {
        checkKeySize(primeSize);
    } catch (InvalidParameterException ipe) {
        throw new InvalidAlgorithmParameterException(ipe.getMessage());
    }

    exponentSize = dhParamSpec.getExponentSize();
    if (exponentSize <= 0) {
        throw new InvalidAlgorithmParameterException
            ("Exponent size must be greater than zero");
    }

    // Require exponentSize < primeSize
    if (exponentSize >= primeSize) {
        throw new InvalidAlgorithmParameterException
            ("Exponent size must be less than modulus size");
    }
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
/**
 * Initializes this parameter generator with a set of parameter
 * generation values, which specify the size of the prime modulus and
 * the size of the random exponent, both in bits.
 *
 * @param genParamSpec the set of parameter generation values
 * @param random the source of randomness
 *
 * @exception InvalidAlgorithmParameterException if the given parameter
 * generation values are inappropriate for this parameter generator
 */
@Override
protected void engineInit(AlgorithmParameterSpec genParamSpec,
        SecureRandom random) throws InvalidAlgorithmParameterException {

    if (!(genParamSpec instanceof DHGenParameterSpec)) {
        throw new InvalidAlgorithmParameterException
            ("Inappropriate parameter type");
    }

    DHGenParameterSpec dhParamSpec = (DHGenParameterSpec)genParamSpec;
    primeSize = dhParamSpec.getPrimeSize();
    exponentSize = dhParamSpec.getExponentSize();
    if ((exponentSize <= 0) || (exponentSize >= primeSize)) {
        throw new InvalidAlgorithmParameterException(
                "Exponent size (" + exponentSize +
                ") must be positive and less than modulus size (" +
                primeSize + ")");
    }
    try {
        checkKeySize(primeSize);
    } catch (InvalidParameterException ipe) {
        throw new InvalidAlgorithmParameterException(ipe.getMessage());
    }

    this.random = random;
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
protected void engineInit(
    AlgorithmParameterSpec  genParamSpec,
    SecureRandom            random)
    throws InvalidAlgorithmParameterException
{
    if (!(genParamSpec instanceof DHGenParameterSpec))
    {
        throw new InvalidAlgorithmParameterException("DH parameter generator requires a DHGenParameterSpec for initialisation");
    }
    DHGenParameterSpec  spec = (DHGenParameterSpec)genParamSpec;

    this.strength = spec.getPrimeSize();
    this.l = spec.getExponentSize();
    this.random = random;
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
protected AlgorithmParameterSpec engineGetParameterSpec(Class paramSpec)
    throws InvalidParameterSpecException
{
  if (paramSpec.isAssignableFrom(DHParameterSpec.class))
    return new DHParameterSpec(p, g, l);

  if (paramSpec.isAssignableFrom(DHGenParameterSpec.class))
    return new DHGenParameterSpec(p.bitLength(), l);

  throw new InvalidParameterSpecException("Wrong AlgorithmParameterSpec type: "
                                          + paramSpec.getName());
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
public static DHParameterSpec generateRandomParameter(int primeSize, int keySize)
{
    try
    {
        AlgorithmParameterGenerator paramGen =
                AlgorithmParameterGenerator.getInstance(ALGORITHM);

        DHGenParameterSpec genParameterSpec =
                new DHGenParameterSpec(primeSize, keySize);

        paramGen.init(genParameterSpec);

        AlgorithmParameters params = paramGen.generateParameters();

        DHParameterSpec result = (DHParameterSpec)
                params.getParameterSpec(DHParameterSpec.class);

        if (DEBUG) _log.debug("Generated random DHParameterSpec, base: "
                + result.getG() + ", modulus: " + result.getP());

        return result;
    }
    catch (GeneralSecurityException e)
    {
        _log.error("Cannot generate DH params for primeSize: "
                + primeSize + " keySize: " + keySize, e);
        return null;
    }
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
/**
 * DHGenParameterSpec class testing. Tests the equivalence of
 * parameters specified in the constructor with the values returned
 * by getters.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "All functionality tested in one method. Probably it should be divided into several tests.",
        method = "DHGenParameterSpec",
        args = {int.class, int.class}
    ),
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "All functionality tested in one method. Probably it should be divided into several tests.",
        method = "getExponentSize",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "All functionality tested in one method. Probably it should be divided into several tests.",
        method = "getPrimeSize",
        args = {}
    )
})
public void testDHGenParameterSpec() {
    int[] primes = {Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE};
    int[] exponents = {Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE};
    for (int i=0; i<primes.length; i++) {
        DHGenParameterSpec ps = new DHGenParameterSpec(primes[i],
                                                        exponents[i]);
        assertEquals("The value returned by getPrimeSize() must be "
                    + "equal to the value specified in the constructor",
                    ps.getPrimeSize(), primes[i]);
        assertEquals("The value returned by getExponentSize() must be "
                    + "equal to the value specified in the constructor",
                    ps.getPrimeSize(), exponents[i]);
    }
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
/**
 * Initializes this parameter generator with a set of parameter
 * generation values, which specify the size of the prime modulus and
 * the size of the random exponent, both in bits.
 *
 * @param params the set of parameter generation values
 * @param random the source of randomness
 *
 * @exception InvalidAlgorithmParameterException if the given parameter
 * generation values are inappropriate for this parameter generator
 */
protected void engineInit(AlgorithmParameterSpec genParamSpec,
                          SecureRandom random)
    throws InvalidAlgorithmParameterException {
        if (!(genParamSpec instanceof DHGenParameterSpec)) {
            throw new InvalidAlgorithmParameterException
                ("Inappropriate parameter type");
        }

        DHGenParameterSpec dhParamSpec = (DHGenParameterSpec)genParamSpec;

        primeSize = dhParamSpec.getPrimeSize();
        if ((primeSize<512) || (primeSize>1024) || (primeSize%64 != 0)) {
            throw new InvalidAlgorithmParameterException
                ("Modulus size must be multiple of 64, and can only range "
                 + "from 512 to 1024 (inclusive)");
        }

        exponentSize = dhParamSpec.getExponentSize();
        if (exponentSize <= 0) {
            throw new InvalidAlgorithmParameterException
                ("Exponent size must be greater than zero");
        }

        // Require exponentSize < primeSize
        if (exponentSize >= primeSize) {
            throw new InvalidAlgorithmParameterException
                ("Exponent size must be less than modulus size");
        }
}
 

import javax.crypto.spec.DHGenParameterSpec; //导入依赖的package包/类
/**
 * DHGenParameterSpec class testing. Tests the equivalence of
 * parameters specified in the constructor with the values returned
 * by getters.
 */
public void testDHGenParameterSpec() {
    int[] primes = {Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE};
    int[] exponents = {Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE};
    for (int i=0; i<primes.length; i++) {
        DHGenParameterSpec ps = new DHGenParameterSpec(primes[i],
                                                        exponents[i]);
        assertEquals("The value returned by getPrimeSize() must be "
                    + "equal to the value specified in the constructor",
                    ps.getPrimeSize(), primes[i]);
        assertEquals("The value returned by getExponentSize() must be "
                    + "equal to the value specified in the constructor",
                    ps.getPrimeSize(), exponents[i]);
    }
}