Convertir SSL .pem .p12 avec ou sans OpenSSL

J'externes .pem les fichiers doivent être convertis à .p12 fichiers - je ajouter un nom d'utilisateur et mot de passe dans le processus. (J'en ai besoin pour ce faire d'utiliser un tiers de l'API.)

À l'aide de openssl, la commande est...

openssl pkcs12 -export -in xxxx.pem -inkey xxxx.pem -out xxx.p12 -passout pas:newpassword -name "newname"

Je peux l'exécuter à partir d'une session de terminal, et il fonctionne parfaitement.

Cependant, j'ai besoin de le faire souvent et ont écrit une classe Java qui gère cela et plus (ma demande est principalement .jsp avec Tomcat et Apache). Lorsque j'essaie d'exécuter la même commande à partir de Java à l'aide de Runtime.exec, j'ai le redoutable "impossible d'écrire "aléatoire" d'état" erreur ( À l'aide d'OpenSSL ce qui ne "impossible d'écrire "aléatoire" d'état"? ).

Je suppose que la différence est que, quand je le lance à partir de Java, l'utilisateur n'est pas "root".

Alors, est-il un meilleur moyen de convertir du format pem .p12 à l'aide d'une bibliothèque Java plutôt que de l'exécution d'un programme en ligne de commande (c'est à dire openssl)?

Sinon, je suppose que j'ai besoin de faire un peu de configuration sur mon serveur. Je ne peux trouver aucune .md fichier n'importe où sur le serveur. La seule openssl.cnf fichier est dans un drôle de répertoire (/etc/pki/tls). Dois-je créer un nouveau openssl.cnf fichier quelque part d'autre?

OriginalL'auteur DrDave | 2012-03-14

Ceci devrait faire ce que vous voulez faire (à l'aide de la BouncyCastle PEMReader comme suggéré ci-dessus) - prendre un codés en PEM clé privée + certificat, et en sortie un fichier PKCS#12. Utilise le même mot de passe pour le PKCS12 qui a été utilisé pour protéger la clé privée.

public static byte[] pemToPKCS12(final String keyFile, final String cerFile, final String password) throws Exception {
    //Get the private key
    FileReader reader = new FileReader(keyFile);

    PEMReader pem = new PEMReader(reader, new PasswordFinder() {
        @Override public char[] getPassword() {
            return password.toCharArray();
        }
    });

    PrivateKey key = ((KeyPair)pem.readObject()).getPrivate();

    pem.close();
    reader.close();

    //Get the certificate      
    reader = new FileReader(cerFile);
    pem = new PEMReader(reader);

    X509Certificate cert = (X509Certificate)pem.readObject();

    pem.close();
    reader.close();

    //Put them into a PKCS12 keystore and write it to a byte[]
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    KeyStore ks = KeyStore.getInstance("PKCS12");
    ks.load(null);
    ks.setKeyEntry("alias", (Key)key, password.toCharArray(), new java.security.cert.Certificate[]{cert});
    ks.store(bos, password.toCharArray());
    bos.close();
    return bos.toByteArray();
}

OriginalL'auteur Muggles Merriweather

1

En Java, l'utilisation Bouncycastle mais attention, la courbe d'apprentissage est raide et documents rares. Je vous recommande fortement de regarder les exemples qui sont disponibles dans le cadre de la distribution source

Commencer avec la PemReader.

OriginalL'auteur Bruno Grieder

@MugglesMerriweather 's réponse, une version mise à jour de v1.51 est la suivante:

public static byte[] convertPEMToPKCS12(final String keyFile, final String cerFile,
        final String password)
        throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException
    {
        //Get the private key
        FileReader reader = new FileReader(keyFile);

        PEMParser pem = new PEMParser(reader);
        PEMKeyPair pemKeyPair = ((PEMKeyPair)pem.readObject());
        JcaPEMKeyConverter jcaPEMKeyConverter = new JcaPEMKeyConverter().setProvider("SC");
        KeyPair keyPair = jcaPEMKeyConverter.getKeyPair(pemKeyPair);

        PrivateKey key = keyPair.getPrivate();

        pem.close();
        reader.close();

        //Get the certificate
        reader = new FileReader(cerFile);
        pem = new PEMParser(reader);

        X509CertificateHolder certHolder = (X509CertificateHolder) pem.readObject();
        java.security.cert.Certificate X509Certificate =
            new JcaX509CertificateConverter().setProvider("SC")
                .getCertificate(certHolder);

        pem.close();
        reader.close();

        //Put them into a PKCS12 keystore and write it to a byte[]
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        KeyStore ks = KeyStore.getInstance("PKCS12");
        ks.load(null);
        ks.setKeyEntry("alias", (Key) key, password.toCharArray(),
            new java.security.cert.Certificate[]{X509Certificate});
        ks.store(bos, password.toCharArray());
        bos.close();
        return bos.toByteArray();
    }

SC signifie SpongyCastle fournisseur.

OriginalL'auteur EpicPandaForce

Sur la base des réponses, j'ai créé une classe java 7, qui s'occupe de tout pour la création d'un valide SSLContext. Aussi, il crée la base nécessaire de la chaîne. TODO: Trustmanager si nécessaire.

public final class SSL_Context {
private static SSL_Context instance = new SSL_Context();
public static SSL_Context getInstance() {
return instance;
}
private SSLContext sslContext = null;
private SSL_Context() {
try {
sslContext = generateSSLContext();
}
catch (Exception e)
{
ErrorLogger.logException(e);
}
}
final private void dumpKeyStore(KeyStore keyStore)
{
try {
//List the aliases
Enumeration aliases = keyStore.aliases();
for (; aliases.hasMoreElements(); ) {
String alias = (String) aliases.nextElement();
//Does alias refer to a private key?
boolean a = keyStore.isKeyEntry(alias);
//Does alias refer to a trusted certificate?
boolean b = keyStore.isCertificateEntry(alias);
ErrorLogger.log(alias + " " + a + " " + b, 2);
}
} catch (Exception e) {
ErrorLogger.logException(e);
}
}
final private KeyStore convertPEMToPKCS12(final String keyAndPubFile, final String chainFile, final String password) {
try {
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
PrivateKey key;
Certificate pubCert;
try (FileReader reader = new FileReader(keyAndPubFile);
PEMParser pem = new PEMParser(reader)) {
PEMKeyPair pemKeyPair = ((PEMKeyPair) pem.readObject());
JcaPEMKeyConverter jcaPEMKeyConverter = new JcaPEMKeyConverter().setProvider("BC");
KeyPair keyPair = jcaPEMKeyConverter.getKeyPair(pemKeyPair);
key = keyPair.getPrivate();
X509CertificateHolder certHolder = (X509CertificateHolder) pem.readObject();
pubCert = new JcaX509CertificateConverter().setProvider("BC").getCertificate(certHolder);
}
//Get the certificates
try (FileReader reader = new FileReader(chainFile);
PEMParser pem = new PEMParser(reader)) {
//load all certs
LinkedList<Certificate> certsll = new LinkedList<>();
X509CertificateHolder certHolder = (X509CertificateHolder) pem.readObject();
do {
Certificate X509Certificate = new JcaX509CertificateConverter().setProvider("BC").getCertificate(certHolder);
certsll.add(X509Certificate);
}
while ((certHolder = (X509CertificateHolder) pem.readObject()) != null);
Certificate[] chain = new Certificate[certsll.size()+1];
chain[0] = pubCert;
KeyStore ks = KeyStore.getInstance("PKCS12");
ks.load(null);
int i = 1;
for (Certificate cert : certsll) {
ks.setCertificateEntry("chain" + i, cert);
chain[i] = ks.getCertificate("chain" + i);
i++;
}
ks.setKeyEntry("cert", key, password.toCharArray(), chain);
return ks;
}
}
catch (Exception e)
{
ErrorLogger.logException(e);
}
return null;
}
final private SSLContext generateSSLContext()
{
String keyStorePassword = "";
try {
KeyStore keyStore = convertPEMToPKCS12("ssl/keyandcert.pem", "ssl/ca_bundle.crt", keyStorePassword);
SSLContext sslContext = SSLContext.getInstance("TLSv1");
KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
keyManagerFactory.init(keyStore, keyStorePassword.toCharArray());
sslContext.init(keyManagerFactory.getKeyManagers(), null, new SecureRandom());
return sslContext;
} catch (Exception e) {
ErrorLogger.logException(e);
}
return null;
}
final public SSLContext getContext() {
return sslContext;
}
final public static void main(String args[])
{
getInstance().getContext();
}
}

OriginalL'auteur sascha.arthur

Vous devez vous connecter pour publier un commentaire.