Java DHPublicKey.getParams方法代码示例

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
protected Key engineDoPhase(
    Key     key,
    boolean lastPhase) 
    throws InvalidKeyException, IllegalStateException
{
    if (x == null)
    {
        throw new IllegalStateException("Diffie-Hellman not initialised.");
    }

    if (!(key instanceof DHPublicKey))
    {
        throw new InvalidKeyException("DHKeyAgreement doPhase requires DHPublicKey");
    }
    DHPublicKey pubKey = (DHPublicKey)key;

    if (!pubKey.getParams().getG().equals(g) || !pubKey.getParams().getP().equals(p))
    {
        throw new InvalidKeyException("DHPublicKey not for this KeyAgreement!");
    }

    if (lastPhase)
    {
        result = ((DHPublicKey)key).getY().modPow(x, p);
        return null;
    }
    else
    {
        result = ((DHPublicKey)key).getY().modPow(x, p);
    }

    return new BCDHPublicKey(result, pubKey.getParams());
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
/**
 * 乙方根据甲方公钥初始化并返回密钥对
 */
public static Map<String, Object> initKey(byte[] key) throws Exception{
	//将甲方公钥从字节数组转换为publicKey
	X509EncodedKeySpec keySpec = new X509EncodedKeySpec(key);
	//实例化密钥工厂
	KeyFactory keyFactory = KeyFactory.getInstance("DH");
	//产生甲方公钥pubKey
	DHPublicKey dhPublicKey = (DHPublicKey) keyFactory.generatePublic(keySpec);
	//剖析甲方公钥，得到其参数
	DHParameterSpec dhParameterSpec = dhPublicKey.getParams();
	//实例化密钥对生成器
	KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
	//用甲方公钥初始化密钥对生成器
	keyPairGenerator.initialize(dhParameterSpec);
	//产生密钥对
	KeyPair keyPair = keyPairGenerator.generateKeyPair();
	//得到乙方公钥
	DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
	//得到乙方私钥
	DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
	//将公钥和私钥封装到Map中，方便以后使用
	Map<String, Object> keyMap = new HashMap<String, Object>();
	keyMap.put(PUBLIC_KEY, publicKey);
	keyMap.put(PRIVATE_KEY, privateKey);
	
	return keyMap;
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
static DHPublicKeySpec getDHPublicKeySpec(PublicKey key) {
    if (key instanceof DHPublicKey) {
        DHPublicKey dhKey = (DHPublicKey)key;
        DHParameterSpec params = dhKey.getParams();
        return new DHPublicKeySpec(dhKey.getY(),
                                params.getP(), params.getG());
    }
    try {
        KeyFactory factory = JsseJce.getKeyFactory("DH");
        return factory.getKeySpec(key, DHPublicKeySpec.class);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
/**
 * Returns whether the Diffie-Hellman public key is valid or not.
 *
 * Per RFC 2631 and NIST SP800-56A, the following algorithm is used to
 * validate Diffie-Hellman public keys:
 * 1. Verify that y lies within the interval [2,p-1]. If it does not,
 *    the key is invalid.
 * 2. Compute y^q mod p. If the result == 1, the key is valid.
 *    Otherwise the key is invalid.
 */
private static void validateDHPublicKey(DHPublicKey publicKey)
        throws InvalidKeyException {
    DHParameterSpec paramSpec = publicKey.getParams();

    BigInteger p = paramSpec.getP();
    BigInteger g = paramSpec.getG();
    BigInteger y = publicKey.getY();

    validateDHPublicKey(p, g, y);
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
static DHPublicKeySpec getDHPublicKeySpec(PublicKey key) {
    if (key instanceof DHPublicKey) {
        DHPublicKey dhKey = (DHPublicKey)key;
        DHParameterSpec params = dhKey.getParams();
        return new DHPublicKeySpec(dhKey.getY(),
                                params.getP(), params.getG());
    }
    try {
        KeyFactory factory = JsseJce.getKeyFactory("DiffieHellman");
        return factory.getKeySpec(key, DHPublicKeySpec.class);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
/**
 * Create a set of public/private keys using ValueLinks defined parameters
 * @return KeyPair object containing both public and private keys
 * @throws NoSuchAlgorithmException
 * @throws InvalidAlgorithmParameterException
 */
public KeyPair createKeys() throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeySpecException {
    // initialize the parameter spec
    DHPublicKey publicKey = (DHPublicKey) this.getValueLinkPublicKey();
    DHParameterSpec dhParamSpec = publicKey.getParams();
    //Debug.logInfo(dhParamSpec.getP().toString() + " / " + dhParamSpec.getG().toString(), module);

    // create the public/private key pair using parameters defined by valuelink
    KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DH");
    keyGen.initialize(dhParamSpec);
    KeyPair keyPair = keyGen.generateKeyPair();

    return keyPair;
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
protected Key engineDoPhase(Key incoming, boolean lastPhase)
    throws InvalidKeyException
{
  if (key == null)
    throw new IllegalStateException("Not initialized");

  if (last_phase_done)
    throw new IllegalStateException("Last phase already done");

  if (! (incoming instanceof DHPublicKey))
    throw new InvalidKeyException("Key MUST be a DHPublicKey");

  DHPublicKey pub = (DHPublicKey) incoming;
  DHParameterSpec s1 = key.getParams();
  DHParameterSpec s2 = pub.getParams();
  if (! s1.getG().equals(s2.getG()) || ! s1.getP().equals(s2.getP()))
    throw new InvalidKeyException("Incompatible key");
  if (! lastPhase)
    throw new IllegalArgumentException(
        "This key-agreement MUST be concluded in one step only");
  BigInteger resultBI = pub.getY().modPow(key.getX(), s1.getP());
  result = resultBI.toByteArray();
  if (result[0] == 0x00)
    {
      byte[] buf = new byte[result.length - 1];
      System.arraycopy(result, 1, buf, 0, buf.length);
      result = buf;
    }
  last_phase_done = true;
  return null;
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
static DHPublicKeySpec getDHPublicKeySpec(PublicKey key) {
    if (key instanceof DHPublicKey) {
        DHPublicKey dhKey = (DHPublicKey)key;
        DHParameterSpec params = dhKey.getParams();
        return new DHPublicKeySpec(dhKey.getY(), params.getP(), params.getG());
    }
    try {
        KeyFactory factory = JsseJce.getKeyFactory("DH");
        return factory.getKeySpec(key, DHPublicKeySpec.class);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
protected Key engineDoPhase(
    Key     key,
    boolean lastPhase) 
    throws InvalidKeyException, IllegalStateException
{
    if (x == null)
    {
        throw new IllegalStateException("Diffie-Hellman not initialised.");
    }

    if (!(key instanceof DHPublicKey))
    {
        throw new InvalidKeyException("DHKeyAgreement doPhase requires DHPublicKey");
    }
    DHPublicKey pubKey = (DHPublicKey)key;

    if (!pubKey.getParams().getG().equals(g) || !pubKey.getParams().getP().equals(p))
    {
        throw new InvalidKeyException("DHPublicKey not for this KeyAgreement!");
    }

    if (lastPhase)
    {
        result = ((DHPublicKey)key).getY().modPow(x, p);
        return null;
    }
    else
    {
        result = ((DHPublicKey)key).getY().modPow(x, p);
    }

    return new JCEDHPublicKey(result, pubKey.getParams());
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
static DHPublicKeySpec getDHPublicKeySpec(PublicKey key) {
    if (key instanceof DHPublicKey) {
        DHPublicKey dhKey = (DHPublicKey)key;
        DHParameterSpec params = dhKey.getParams();
        return new DHPublicKeySpec(dhKey.getY(), params.getP(), params.getG());
    }
    try {
        KeyFactory factory = JsseJce.getKeyFactory("DH");
        return (DHPublicKeySpec)factory.getKeySpec
                                        (key, DHPublicKeySpec.class);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
JCEDHPublicKey(
    DHPublicKey    key)
{
    this.y = key.getY();
    this.dhSpec = key.getParams();
}
 

import javax.crypto.interfaces.DHPublicKey; //导入方法依赖的package包/类
BCDHPublicKey(
    DHPublicKey key)
{
    this.y = key.getY();
    this.dhSpec = key.getParams();
}