ECKeyAgreement в генерации открытого и закрытого ключа с использованием ecc

Question

Я работаю над концепцией шифрования и расшифровки с использованием 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); 
    } 
    } 

Answer 1

Вы должны попытаться создать EC (DH) пару ключей вместо пары ключей DSA. Хотя общий метод работы идентичен (как ECDSA, так и DSA основаны на проблеме Диффи-Хеллмана), типы ключей, конечно же, нет.