La lecture de la courbe elliptique de la clé privée à partir d'un fichier avec BouncyCastle

La BouncyCastle Api de cryptographie permet de créer et vérifier des signatures numériques à l'aide de l'ordinaire java.security paquet d'objets, tels que des java.security.PublicKey, java.security.PrivateKey et leur conteneur java.security.KeyPair.

Suppose que je utiliser OpenSSL pour créer une .pem (ou, si cela est plus facile, une .der fichier) contenant la courbe elliptique d'une clé privée, que je veux utiliser mon application. Par exemple, il ressemble à ceci:

-----BEGIN EC PARAMETERS-----
BgUrgQQACg==
-----END EC PARAMETERS-----
-----BEGIN EC PRIVATE KEY-----
MHQCAQEEIDzESrZFmTaOozu2NyiS8LMZGqkHfpSOoI/qA9Lw+d4NoAcGBSuBBAAK
oUQDQgAE7kIqoSQzC/UUXdFdQ9Xvu1Lri7pFfd7xDbQWhSqHaDtj+XY36Z1Cznun
GDxlA0AavdVDuoGXxNQPIed3FxPE3Q==
-----END EC PRIVATE KEY-----

Comment puis-je utiliser le BouncyCastle Api pour obtenir un java.security.KeyPair contenant à la fois cette clé privée et une clé publique correspondante?

Veuillez noter que je veux utiliser les Api disponibles dans BouncyCastle 1.50 (qui est en vigueur au moment de l'écriture) et pas d'Api obsolète. Ce qui malheureusement exclut la PEMReader classe utilisée chez d'autres réponses. En outre, cette question est spécifique à la forme des courbes elliptiques; ils contiennent des paramètres supplémentaires comparativement RSA ou DSA fichiers de la clé.

Le EC PARAMETERS bloc dans votre fichier est un accident de la voie openssl ecparam -genkey fonctionne par défaut; il n'est pas requis ou utilisés dans le cadre de la clé réelle et vous pouvez l'omettre en spécifiant -noout qui est certes un peu évident. La véritable clé de la structure ("caché" dans le base64/DER données) pour CE(DSA/DH) t contient un certain nombre de paramètres info qui RSA n'est pas, mais DSA t.

OriginalL'auteur DCKing | 2014-04-09

  1. 6

    En Java, ce sera à peu près le même code. Après entrelacement sécurisation des chaînes de loin et de décodage en Base64 données à donner à cette méthode utilitaire:

    public static PrivateKey keyToValue(byte[] pkcs8key)
    throw GeneralSecurityException {

    PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(pkcs8key);
    KeyFactory factory = KeyFactory.getInstance("ECDSA");
    PrivateKey privateKey = factory.generatePrivate(spec);
    return privateKey;
}
    J'ai marqué que cette réponse est correcte, car il présente la réponse sous la forme initialement demandé. Il devrait être plus clair pour le grand public, ainsi.
    Regarder les JCA Documentation qui me fait croire à l'argument de KeyFactory.getInstance() est censé être EC plutôt que ECDSA. Suis-je tort?
    Il dépend de l'opérateur utilisé. Pour BouncyCastle il pourrait être à la fois CE et ECDSA. Pour le Fournisseur de Soleil, il pourrait être CE ne, je ne l'utilise pas beaucoup.
    salut,quel est le gardiennage de chaînes ?quand je bande de commencer**----,je reçois tableau d'octets d'Entrée est incorrect de fin d'octets exception
    Cela ne fonctionne pas pour (la partie) les données de ce Q, qui est dans OpenSSL "héritage" format NON PKCS8 format que celui utilisé par la JCE; avis PEM-têtes BEGIN/END EC PRIVATE KEY pas BEGIN/END PRIVATE KEY utilisé non chiffrées PKCS8. Vous pouvez le convertir en utilisant openssl pkey -in oldfile -out newfile dans les versions modernes (1.0.0) ou openssl pkcs8 -topk8 -nocrypt -in oldfile -out newfile dans toutes les versions, puis de l'onu-base64 que en PKCS8EncodedKeySpec.

    OriginalL'auteur divanov

  2. 10

    En plus de la norme de la JCE approche illustré par divanov aussi longtemps que vous donnez la bonne entrée (voir mon commentaire s'y rapportant), ou tout simplement à l'aide de l'entreprise criminelle commune, en premier lieu, comme votre selfanswer, BouncyCastle 1.48 up NE contiennent encore de l'ancien PEMReader fonctionnalité vient d'être organisée un peu différemment et pour ce cas, vous pouvez utiliser quelque chose comme:

    static void SO22963581BCPEMPrivateEC () throws Exception {
    Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
    Reader rdr = new StringReader ("-----BEGIN EC PRIVATE KEY-----\n"
            +"MHQCAQEEIDzESrZFmTaOozu2NyiS8LMZGqkHfpSOoI/qA9Lw+d4NoAcGBSuBBAAK\n"
            +"oUQDQgAE7kIqoSQzC/UUXdFdQ9Xvu1Lri7pFfd7xDbQWhSqHaDtj+XY36Z1Cznun\n"
            +"GDxlA0AavdVDuoGXxNQPIed3FxPE3Q==\n"+"-----END EC PRIVATE KEY-----\n");
    Object parsed = new org.bouncycastle.openssl.PEMParser(rdr).readObject();
    KeyPair pair = new org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter().getKeyPair((org.bouncycastle.openssl.PEMKeyPair)parsed);
    System.out.println (pair.getPrivate().getAlgorithm());
}

    OriginalL'auteur dave_thompson_085

  3. 3

    Depuis que j'ai seulement besoin de cela pour un accès rapide et sale de la démo, je l'ai résolu de la façon suivante (en Scala). Tout d'abord, je générer un public-privé pour la paire de clés dans le REPL et l'impression de ses données:

    Security.addProvider(new BouncyCastleProvider)

val SignatureScheme = "some signature scheme, eg ECDSA"
val RandomAlgorithm = "some random algorithm, eg SHA1PRNG"

val keygen = KeyPairGenerator.getInstance(SignatureScheme)
val rng = SecureRandom.getInstance(RandomAlgorithm)
rng.setSeed(seed)
keygen.initialize(KeySize, rng)

val kp = keygen.generateKeyPair()
println(kp.getPublic.getEncoded.toSeq) //toSeq so that Scala actually prints it
println(kp.getPrivate.getEncoded.toSeq)

    Puis en utilisant les données générées,

    val hardcodedPublic = Array[Byte]( /* data */ )
val hardcodedPrivate = Array[Byte]( /* data */ )

val factory = KeyFactory.getInstance(SignatureScheme)

val publicSpec = new X509EncodedKeySpec(hardcodedPublic)
val publicKey = factory.generatePublic(publicSpec)

val privateSpec = new PKCS8EncodedKeySpec(hardcodedPrivate)
val privateKey = factory.generatePrivate(privateSpec)

    La chose principale que vous devez savoir ici est que, par défaut, la clé publique de l'utilisation des données X509 de l'encodage et de la clé privée de l'utilisation des données PKCS8 encodage. Il devrait être possible d'obtenir OpenSSL à la sortie de ces formats et les analyser manuellement, mais je n'ai pas vérifier comment.

    J'ai utilisé des informations provenant de ce blog sur SpongyCastle (qui est Android BouncyCastle alias) très utile. Il est regrettable que la documentation est fragmenté comme ça, et que BouncyCastle wiki était au moment de cette question.

    Mise à jour: le BouncyCastle wiki est en place, et vous pouvez trouver de la documentation ici.

    OriginalL'auteur DCKing