ECKeyAgreement dans Générer une clé publique et privée en utilisant ecc

Question

Je travaille sur un concept de cryptage et de décryptage utilisant ecc. J'ai déjà généré une clé publique et privée. Alors que je suis CHIFFREMENT le texte que je reçois cette erreur:

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) 

Ceci est mon fichier Java de cryptage:

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

Je ne sais pas ce que je suis absent. J'ai essayé tout ce que je peux pour obtenir le ECPrivateKey.

Ceci est le code pour générer la clé publique et privée:

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

Vous devriez essayer de créer un CE (DH) paire de clés au lieu d'une paire de clés DSA. Bien que la méthode générale de fonctionnement soit identique (ECDSA et DSA sont basés sur le problème de Diffie-Hellman), les types de clés ne le sont certainement pas.