Java ECKeyAgreement使用ecc生成公钥和私钥

我正在研究使用ecc进行加密和解密的概念。 我已经生成了公钥和私钥。加密文本时，出现以下错误：

 java.security.InvalidKeyException: ECKeyAgreement requires ECPrivateKey
at 
org.bouncycastle.jce.provider.JCEECDHKeyAgreement.engineInit(JCEECDHKeyAgreement.java:121)
at javax.crypto.KeyAgreement.init(KeyAgreement.java:462)
at javax.crypto.KeyAgreement.init(KeyAgreement.java:436)
at rbl2015.encryec.main(encryec.java:67)

这是我的加密Java文件：

import java.io.File;
import java.io.FileInputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Security;
import java.security.spec.ECParameterSpec;
import java.security.spec.EllipticCurve;
import java.security.spec.KeySpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Scanner;
import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;


public class encryec
{
KeyPairGenerator kpg;
EllipticCurve curve;
ECParameterSpec ecSpec;
KeyPair aKeyPair;
static KeyAgreement aKeyAgree;
KeyPair bKeyPair;
KeyAgreement bKeyAgree;
KeyFactory keyFac;
static String msg;
public static void main(String args[])
{
    Security.addProvider(new BouncyCastleProvider());
    Scanner ss=new Scanner(System.in);

    try{
        String path = "D:\\rp";
        File filePublicKey = new File(path+"\\public.key");
        FileInputStream fis = new FileInputStream(path+"\\public.key");
        byte[] encodedPublicKey = new byte[(int) filePublicKey.length()];
        fis.read(encodedPublicKey);
        fis.close();

        // Read Private Key.
        File filePrivateKey = new File(path+"\\private.key");
        fis = new FileInputStream(path+"\\private.key");
        byte[] encodedPrivateKey = new byte[(int) filePrivateKey.length()];
        fis.read(encodedPrivateKey);
        fis.close();

        KeyFactory keyFactory = KeyFactory.getInstance("ECDH");
        X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(
        encodedPublicKey);
        PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);

        PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(encodedPrivateKey);

        PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);

        aKeyAgree = KeyAgreement.getInstance("ECDH", "BC");
        aKeyAgree.init(privateKey);                     // exception line
        aKeyAgree.doPhase(publicKey, true);

        byte[] aBys = aKeyAgree.generateSecret(); 
        KeySpec aKeySpec = new DESKeySpec(aBys);
        SecretKeyFactory aFactory = SecretKeyFactory.getInstance("DES");
        Key aSecretKey = aFactory.generateSecret(aKeySpec);
        Cipher aCipher = Cipher.getInstance(aSecretKey.getAlgorithm());   
        aCipher.init(Cipher.ENCRYPT_MODE, aSecretKey);  
        byte[] encText = aCipher.doFinal("Its Rahul".getBytes());

        System.out.println(Base64.encodeBase64String(encText));
        System.out.println(encText);
    }
    catch(Exception e)
    {
        e.printStackTrace();
    }
}
}

我不知道我错过了什么。我尽我所能去弄那把私钥

这是生成公钥和私钥的代码：

  import java.io.*;
  import java.security.*;
  import java.security.spec.*;

  public class Rahul {

   public static void main(String args[]) {
    Rahul rahul = new Rahul();
    try {
     String path = "D:\\rp";

     KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA");

     keyGen.initialize(1024);
     KeyPair generatedKeyPair = keyGen.genKeyPair();

     System.out.println("Generated Key Pair");
     rahul.dumpKeyPair(generatedKeyPair);
     rahul.SaveKeyPair(path, generatedKeyPair);

     KeyPair loadedKeyPair = rahul.LoadKeyPair(path, "DSA");
     System.out.println("Loaded Key Pair");
     rahul.dumpKeyPair(loadedKeyPair);
    } catch (Exception e) {
     e.printStackTrace();
     return;
    }
   }

   private void dumpKeyPair(KeyPair keyPair) {
    PublicKey pub = keyPair.getPublic();
    System.out.println("Public Key: " + getHexString(pub.getEncoded()));

    PrivateKey priv = keyPair.getPrivate();
    System.out.println("Private Key: " + getHexString(priv.getEncoded()));
   }

   private String getHexString(byte[] b) {
    String result = "";
    for (int i = 0; i < b.length; i++) {
     result += Integer.toString((b[i] & 0xff) + 0x100, 16).substring(1);
    }
    return result;
   }

   public void SaveKeyPair(String path, KeyPair keyPair) throws IOException             {
    PrivateKey privateKey = keyPair.getPrivate();
    PublicKey publicKey = keyPair.getPublic();

    // Store Public Key.
    X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(
      publicKey.getEncoded());
    FileOutputStream fos = new FileOutputStream(path + "/public.key");
    fos.write(x509EncodedKeySpec.getEncoded());
    fos.close();

    // Store Private Key.
    PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
      privateKey.getEncoded());
    fos = new FileOutputStream(path + "/private.key");
    fos.write(pkcs8EncodedKeySpec.getEncoded());
    fos.close();
   }

         public KeyPair LoadKeyPair(String path, String algorithm)
     throws IOException, NoSuchAlgorithmException,
     InvalidKeySpecException {
    // Read Public Key.
    File filePublicKey = new File(path + "/public.key");
    FileInputStream fis = new FileInputStream(path + "/public.key");
    byte[] encodedPublicKey = new byte[(int) filePublicKey.length()];
    fis.read(encodedPublicKey);
    fis.close();

    // Read Private Key.
    File filePrivateKey = new File(path + "/private.key");
    fis = new FileInputStream(path + "/private.key");
    byte[] encodedPrivateKey = new byte[(int) filePrivateKey.length()];
    fis.read(encodedPrivateKey);
    fis.close();

    // Generate KeyPair.
    KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(
encodedPublicKey);
    PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);

    PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(
encodedPrivateKey);
    PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);

    return new KeyPair(publicKey, privateKey);
   }
  }

import java.io.*；
导入java.security.*；
导入java.security.spec.*；
公共级拉胡尔{
公共静态void main（字符串参数[]）{
Rahul Rahul=新的Rahul（）；
试一试{
字符串路径=“D:\\rp”；
KeyPairGenerator keyGen=KeyPairGenerator.getInstance（“DSA”）；
密钥初始化（1024）；
KeyPair generatedKeyPair=keyGen.genKeyPair（）；
System.out.println（“生成的密钥对”）；
rahul.dumpKeyPair（generatedKeyPair）；
rahul.SaveKeyPair（路径，generatedKeyPair）；
KeyPair loadedKeyPair=rahul.LoadKeyPair（路径，“DSA”）；
System.out.println（“加载的密钥对”）；
rahul.dumpKeyPair（loadedKeyPair）；
}捕获（例外e）{
e、 printStackTrace（）；
返回；
}
}
私有密钥对（密钥对密钥对）{
PublicKey pub=keyPair.getPublic（）；
System.out.println（“公钥：+getHexString（pub.getEncoded（）））；
PrivateKey priv=keyPair.getPrivate（）；
System.out.println（“私钥：+getHexString（priv.getEncoded（）））；
}
私有字符串getHexString（字节[]b）{
字符串结果=”；
for（int i=0；i

您应该尝试创建EC（DH）密钥对，而不是DSA密钥对。虽然一般的操作方法是相同的（ECDSA和DSA都基于Diffie-Hellman问题），但密钥类型肯定不是。

我尝试创建ec密钥对。但是不能。你能告诉我怎么做吗。我应该在哪里换车？生成密钥有问题吗？thx dude正在工作。我刚刚使用了“DH”算法，现在它运行良好