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();
    }
}
}

Я не знаю, чего мне не хватает. Я пробовал все, что мог, чтобы получить ECPrivateKey.

Это код для генерации открытого и закрытого ключа:

  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);
   }
  }