Comment lire une clé privée pour une utilisation avec OpenSAML?

OK, c'est un autre de ces "je n'ai aucune idée par où commencer" questions, j'espère donc que la réponse est simple. Cependant, je ne sais pas vraiment quoi chercher, et mes tentatives jusqu'à présent n'ont pas beaucoup d'utilisation.

Je veux lire une clé privée à partir d'une (actuellement sur disque) fichier. En fin de compte, la clé réside dans une base de données, mais ce sera assez bon pour le moment et que la différence ne devrait pas avoir de réelles portant sur l'analyse du matériel de clé. J'ai été en mesure de créer un Credential instance qui détient la partie publique de la clé (confirmé par le débogueur), mais je n'arrive pas à comprendre comment lire la partie privée. La paire de clés est générée comme:

openssl genrsa 512 > d:\host.key
openssl req -new -x509 -nodes -sha1 -days 365 -key d:\host.key > d:\host.cert

(Oui, je sais que 512 bits de clés RSA ont été brisées, il y a longtemps. Cependant, pour essayer d'obtenir de l'API pour le travail, je ne vois aucune raison d'échappement le système d'entropie d'approvisionnement inutilement.)

Le code jusqu'à présent est:

import org.opensaml.xml.security.credential.Credential;
import org.opensaml.xml.security.x509.BasicX509Credential;

private Credential getSigningCredential()
throws java.security.cert.CertificateException, IOException {
    BasicX509Credential credential = new BasicX509Credential();

    credential.setUsageType(UsageType.SIGNING);

    //read public key
    InputStream inStream = new FileInputStream("d:\\host.cert");
    CertificateFactory cf = CertificateFactory.getInstance("X.509");
    X509Certificate cert = (X509Certificate)cf.generateCertificate(inStream);
    inStream.close();
    credential.setEntityCertificate(cert);

    //TODO: read private key

    //done.
    return credential;
}

Mais comment puis-je lire le fichier host.key dans la clé privée portion de credential, si je peux utiliser le générés Credential instance de signer des données?

OriginalL'auteur a CVn | 2011-03-08

19

BasicX509Credential ne fait pas partie de la norme Java; je suppose que vous parlez de la org.opensaml.xml.security.x509.BasicX509Credential de OpenSAML.

Vous voulez un PrivateKey qui vous permettra de définir avec credential.setPrivateKey(). Pour obtenir un PrivateKey, vous devez d'abord convertir la clé privée dans un format que Java peut lire, à savoir PKCS#8:
```
openssl pkcs8 -topk8 -nocrypt -outform DER < D:\host.key > D:\host.pk8
```
Puis, à partir de Java:
```
RandomAccessFile raf = new RandomAccessFile("d:\\host.pk8", "r");
byte[] buf = new byte[(int)raf.length()];
raf.readFully(buf);
raf.close();
PKCS8EncodedKeySpec kspec = new PKCS8EncodedKeySpec(buf);
KeyFactory kf = KeyFactory.getInstance("RSA");
PrivateKey privKey = kf.generatePrivate(kspec);
```
et voilà! vous avez votre PrivateKey.

Par défaut, openssl écrit clés dans son propre format (pour des clés RSA, PKCS#8 se trouve être un wrapper autour de ce format), et il les encode dans le format PEM, qui Base64 avec un en-tête et un pied de page. Les deux caractéristiques sont prises en charge par la plaine de Java, d'où la conversion à PKCS#8. Le -nocrypt option est parce que PKCS#8 prend en charge en option chiffrement par mot de passe de clé privée.

Avertissement: vous vraiment vraiment souhaitez utiliser un plus de clés RSA. 512 bits sont faibles; une de 512 bits de clé RSA a été cassé en 1999, avec quelques centaines d'ordinateurs. En 2011, avec 12 ans d'avancées technologiques, on devrait considérer que l'une de 512 bits de clé RSA peut être rompu par presque tout le monde. Par conséquent, le recours RSA de 1024 bits clés au moins (de préférence, est de 2048 bits; le calcul de la surcharge lors de l'utilisation de la clé n'est pas mauvais en soit, vous serez toujours en mesure d'effectuer des centaines de signatures par seconde).

Oui, BasicX509Credential est de OpenSAML, désolé de surveillance. Je vais certainement donner à ceci un essai. Et oui, je sais parfaitement bien que 512-bit RSA les touches ne sont pas du tout sûr, mais cette configuration particulière est strictement pour essayer d'avoir des choses à travailler, à tous, de sorte que la longueur de clé est un non-problème.
Semble fonctionner comme un charme, merci beaucoup! Bien sûr, mon code de signature semble être rompu, mais au moins, selon le débogueur, je reçois un bon Credential à partir de deux fichiers sur le disque. Sur le tour...
Je vous remercie. J'ai eu mystérieux des problèmes avec la redirection des < et > à Windows, donc on peut les remplacer par et les interrupteurs.

OriginalL'auteur Thomas Pornin

Cette question est liée à la SAML et est également pertinent pour quelqu'un qui veut récupérer une clé privée pour signer un XMLObject. La réponse ci-dessus fonctionne très bien et il est également possible de récupérer une clé privée à partir d'un fichier de clés:

        Properties sigProperties = new Properties();

    sigProperties.put("org.apache.ws.security.crypto.provider","org.apache.ws.security.components.crypto.Merlin");
    sigProperties.put("org.apache.ws.security.crypto.merlin.keystore.type","jks");
    sigProperties.put("org.apache.ws.security.crypto.merlin.keystore.password","keypass");
    sigProperties.put("org.apache.ws.security.crypto.merlin.keystore.alias","keyalias");
    sigProperties.put("org.apache.ws.security.crypto.merlin.keystore.file","keystore.jks");

    Crypto issuerCrypto = CryptoFactory.getInstance(sigProperties);

    String issuerKeyName = (String) sigProperties.get("org.apache.ws.security.crypto.merlin.keystore.alias");

    //See http://ws.apache.org/wss4j/xref/org/apache/ws/security/saml/ext/AssertionWrapper.html 'signAssertion' method
    //prepare to sign the SAML token
    CryptoType cryptoType = new CryptoType(CryptoType.TYPE.ALIAS);
    cryptoType.setAlias(issuerKeyName);
    X509Certificate[] issuerCerts = issuerCrypto.getX509Certificates(cryptoType);
    if (issuerCerts == null) {
        throw new WSSecurityException(
                "No issuer certs were found to sign the SAML Assertion using issuer name: "
                        + issuerKeyName);
    }

    String password = ADSUnitTestUtils.getPrivateKeyPasswordFromAlias(issuerKeyName);

    PrivateKey privateKey = null;
    try {
        privateKey = issuerCrypto.getPrivateKey(issuerKeyName, password);
    } catch (Exception ex) {
        throw new WSSecurityException(ex.getMessage(), ex);
    }


    BasicX509Credential signingCredential = new BasicX509Credential();
    signingCredential.setEntityCertificate(issuerCerts[0]);
    signingCredential.setPrivateKey(privateKey);

    signature.setSigningCredential(signingCredential);

C'est que le code de la requête d'origine demandé, mais il semble qu'ils essaient d'accéder à un BasicX509Credential.

Grâce,
Yogesh

OriginalL'auteur Yogesh Chawla

Vous devez vous connecter pour publier un commentaire.