Reconstruire des clés privées et publiques avec Bouncy Castle?

Question

Si j'obtiens la clé réelle avec getEncoded d'une clé publique ou privée dans Bouncy Castle en Java (la classe réelle semble être BCECPublicKey et BCECPrivateKey). Est-il possible de reconstruire les objets clés pour les utiliser dans le code?

J'ai découvert ici dans Stack Overflow comment sérialiser l'ensemble de l'objet en binaire (puis en disque) puis en binaire et en un objet de la classe appropriée, mais je crois que la sérialisation contient des détails d'implémentation et si essayez d'utiliser ces touches avec autre chose que Bouncy Castle, ça va échouer. Je n'essaie pas de le faire maintenant, mais je veux mettre mon programme à l'épreuve de l'avenir.

Voici comment je crée les clés:

KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC", "BC"); 
    keyPairGenerator.initialize(new ECGenParameterSpec("secp521r1"), new SecureRandom()); 
    java.security.KeyPair keyPair = keyPairGenerator.generateKeyPair(); 

    privateKey = keyPair.getPrivate(); 
    publicKey = keyPair.getPublic(); 

Answer 1

Le KeyFactory est utilisé pour convertir les clés codées et les classes Java qui les représentent. Toutefois, l'instance KeyFactory ne convertit pas directement entre un tableau d'octets et une classe Key. Au lieu de cela, vous devez déjà savoir quel format utilise le codage, puis créer un objet KeySpec à l'aide du tableau d'octets du constructeur. Le format peut être déterminé par la méthode appelée sur la clé. Voici un exemple illustrant certains de ces points.

import org.bouncycastle.jce.provider.BouncyCastleProvider; 

import java.security.*; 
import java.security.spec.ECGenParameterSpec; 
import java.security.spec.PKCS8EncodedKeySpec; 
import java.security.spec.X509EncodedKeySpec; 

public class Main { 

    public static void main(String[] args) throws Exception{ 
     Security.addProvider(new BouncyCastleProvider()); 
     KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC", "BC"); 
     keyPairGenerator.initialize(new ECGenParameterSpec("secp521r1"), new SecureRandom()); 
     java.security.KeyPair keyPair = keyPairGenerator.generateKeyPair(); 

     PrivateKey privateKey = keyPair.getPrivate(); 
     System.out.println(privateKey.getFormat()); 
     PublicKey publicKey = keyPair.getPublic(); 
     System.out.println(publicKey.getFormat()); 

     // A KeyFactory is used to convert encoded keys to their actual Java classes 
     KeyFactory ecKeyFac = KeyFactory.getInstance("EC", "BC"); 

     // Now do a round-trip for a private key, 
     byte [] encodedPriv = privateKey.getEncoded(); 
     // now take the encoded value and recreate the private key 
     PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(encodedPriv); 
     PrivateKey privateKey2 = ecKeyFac.generatePrivate(pkcs8EncodedKeySpec); 

     // And a round trip for the public key as well. 
     byte [] encodedPub = publicKey.getEncoded(); 
     X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(encodedPub); 
     PublicKey publicKey2 = ecKeyFac.generatePublic(x509EncodedKeySpec); 
     System.out.println(publicKey2); 

    } 
}