[JAVA] Suddividere PKCS#12 Chiave privata e file di certificato

[altropinto]

Salve,
ho un problema:Devo estrarre da un pkcs12 la chiave privata ed il certificato.
Ho provato in questo modo:

public static void main(String[] args) throws KeyStoreException, IOException, NoSuchAlgorithmException, UnrecoverableKeyException, CertificateEncodingException {
// TODO code application logic here
KeyStore ks = KeyStore.getInstance("PKCS12");
java.io.InputStream in = new FileInputStream("D:\\certs\\usercert.p12");

try {
ks.load(in, null);
} catch (CertificateException ex) {
ex.printStackTrace();
} catch (NoSuchAlgorithmException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}

String passwd = "manu";
PrivateKey priv = (PrivateKey) ks.getKey("ALIAS", passwd.toCharArray());
byte[] encodedKey = priv.getEncoded();
System.err.println(priv);
/* save the certificate in a file named "suecert" */
FileOutputStream keyfos = new FileOutputStream("suekey.der");
keyfos.write(encodedKey);
keyfos.close();


però mi salva la chiave in formato pkcs8. Come faccio ad ottenere la chiave in formato pkcs12??????

Mi potete aiutare?????

[kingv]

crea una nuova istanza di KeyStore , di tipo PKCS#12 , poi chiama setKeyEntry() con la chiave che hai estratto e store() con un OutputStream collegato al file che vuoi scrivere.

[altropinto]

KeyStore ks = KeyStore.getInstance("PKCS12");
ks.setKeyEntry("ALIAS",encodedKey,"manu".toCharArray(),..........);

Che devo mettere come "certificate [] chain" ?????
Come posso creare un "certificate [] chain" ?????

Grazie per l'aiuto

[kingv]

la catena di certificati che certificano la chiave pubblica corrispondente.

rileggendo il tuo post non mi è più tanto chiaro, da un pkcs#12 contenente chiave e certificati cosa vuoi ottenere come output?

[altropinto]

Scusa hai ragione.....

Allore io ho un certificato: usercert.p12 (certificato che si importa nei browser web).
Da questo certificato devo estrarre la chiave privata ed il certificato. Dopo di ciò li devo salvare nei seguenti file: userkey.pem e usercert.pem.

Come posso fare??????

[kingv]

ok allora lascia perdere il codice per scrivere un pkcs#12.

per recuperare il certificato puoi chiamare:
java.security.cert.Certificate cert = keystore.getCertificate("alias");


il pem altro non è che il der che hai scritto prima codificato in base64 con aggiunte una riga in testa e una in coda.

se lo devi fare da java devi scrivere qualche riga di codice perchè nativamente il formato supportato è quello binario (cioè DER), se puoi farlo esternamente puoi convertire con facilità tra i formati con openssl.

[altropinto]

In poche parole devo scrivere questo per ottenere la chiave privata nel formato .der:

File a = new File("D:\\certs\\usercert.p12");
PKCS12 x = new PKCS12(a, "manu");
PrivateKey key;
key = x.getKey();
System.out.println(key);
byte[] encodedKey = key.getEncoded();
FileOutputStream keyfos = new FileOutputStream("C:\\userkey.der");
keyfos.write(encodedKey);
keyfos.close();

E' corretto così?????
Quindi se voglio la chiave in formato .pem lo faccio con openssl, vero????

[altropinto]

ok, facendolo con openssl funziona.
Ti devo fare due domande:

1) Ma se volessi farlo con java, mi sapresti dire le istruzioni da fare?????

2) Sempre con java, come posso estrarre (salvare) dal browser web il certificato: usercert.p12 ?????


Ti ringrazio per il tuo aiuto

[kingv]

1) per il certificato salva un file .pem contenente:
-----BEGIN CERTIFICATE-----
xxx
-----END CERTIFICATE-----

per la chiave privata

-----BEGIN RSA PRIVATE KEY-----
yyy
-----END RSA PRIVATE KEY-----

sostituisci a xxx il certificato che hai ricavato in precedenza, codificato in base64 (vedi sun.misc.BASE64Encoder) e vai a capo ogni 64 caratteri. fai attenzione al numero di trattini e vai a capo sia dopo la prima riga che dopo l'ultima.
lo stesso per yyy, usando la chiave privata letta in precedenza. se la chiave fosse DSA (più rara) sostituisci RSA con DSA nelle intestazioni.

2) non ho idea ma non penso che sia possibile con facilità.

[altropinto]

Grazie per l'aiuto......
Per quanto riguarda il certificato funziona, ma per la chaive privata c'è un problema. Il file lo crea regolarmente, ma quando la vado ad usare mi dà un errore: "Chiave non conosciuta".
Però se la salvo nel formato .der, e poi la converto con openssl, la chiave viene creata correttamente. Quindi è sicuramente un problema nella mia conversione.

Mi sapresti dire dove sbaglio??????

Questo è il codice di conversione:

public boolean privateKeyToPem(PrivateKey privateKey, String path, String name) throws IOException
{
String LF = "\n";
String beginRSAPrivateKey = "-----BEGIN RSA PRIVATE KEY-----" +LF;
String endRSAPrivateKey = "-----END RSA PRIVATE KEY-----" +LF;
int length = 0;
int bytestowrite = 64;


FileOutputStream fos = new FileOutputStream(path + File.separator + name);
fos.write(beginRSAPrivateKey.getBytes());
byte [] certb64 = Base64.encode(privateKey.getEncoded());

length = certb64.length;

for ( int written = 0; written < length; )
{
fos.write(certb64,written,bytestowrite);
fos.write(LF.getBytes());
written += bytestowrite;
if ( (length - written) < 64 )
bytestowrite=(length - written);
}

fos.write(endRSAPrivateKey.getBytes());
fos.close();

return true;
}

[kingv]

ho sbagliato, l'intestazione deve essere :
-----BEGIN PRIVATE KEY-----

lo stesso per la chiusura

[kingv]

inoltre ci sono dei ritorni a capo di troppo, togliendoli a mano la chiave è scritta correttamente. quando ho tempo cerco di capire dove li aggoiunge

[altropinto]

ok.....grazie.

Comunque aprendo con un editor il file codificato da me (privkey.pem) e il file codificato con openssl (key.pem) , mi sono accorto che sono completamente differenti.

Inoltre, tu mi hai scritto "ci sono dei ritorni a capo di troppo, togliendoli a mano la chiave è scritta correttamente", come hai fatto a vederlo??????

[kingv]

Inoltre, tu mi hai scritto "ci sono dei ritorni a capo di troppo, togliendoli a mano la chiave è scritta correttamente", come hai fatto a vederlo??????


il file pem a parte la prima e l'ultima riga deve avere ogni riga di 64 caratteri mentre il codice che hai postato genera un file con dei ritorni a capo in più.
se li elimino a mano con un editor di testo ottengo un file che openssl è in grado di aprire (quindi formalmente corretto).

[kingv]

ti allego il file che genera il tuo codice e quello ritoccato a mano.

[altropinto]

Però il file convertito con openssl è ancora differente da quello che mi hai passato(testOK.pem). Secondo me non dipende dagli "a capo", perchè lo stesso algoritmo lo applico al certificato e me lo crea correttamente.

Per darti un idea:
Le prime due righe del file dovrebbero essere:

-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQC5BvbYgNAlEoB/75pmowBv/S8MRzysEoYL32E3yj/lrK9GmRiN

mentre mi ritrovo:

-----BEGIN RSA PRIVATE KEY-----
MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBALkG9tiA0CUSgH/v

Ho trovato questo:
http://forum.java.sun.com/thread.jspa?threadID=562738&messageID=2769554
Praticamente ha lo stesso problema mio.

[altropinto]

Il problema può essere nella seguente istruzione??????

byte [] certb64 = Base64.encode(cert.getEncoded());

Il package che ho importato è il seguente:

import org.bouncycastle.util.encoders.Base64;

[kingv]

Il problema può essere nella seguente istruzione??????

byte [] certb64 = Base64.encode(cert.getEncoded());



no il problema non è lì :(

[kingv]

ho fatto una prova, usando la classe che indichi tu per l'encoding BASE64 il pkcs#8 in fomrato PEM mi viene generato correttamente.


tu che problema hai?

[altropinto]

La classe che ho implementato per la conversione non mi dà errori, infatti genera il file userkey.pem . Il problema è che genera una chiave sbagliata.

Mi spiego meglio....lo stesso file .der convertito con openssl mi dà questa chiave:

-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQC5BvbYgNAlEoB/75pmowBv/S8MRzysEoYL32E3yj/lrK9GmRiN
Nbqz5RwuT6ZAwg9SRkPtESWTjiV/9e/5rYy4d8P21NIUwrwrT2QNHhLm2YnFsR5a
........................................................................................................
.........................................................................................................
Ue+VY9LPgR6svd6C5qsCQEqA3QpOymuJfA3wCHryHybMhnpM2/onVyMAEh+S+nVP
mWbkI77diDfFpVxDRH4NBWYLwIgMywXpv3ab0yVm3hc=
-----END RSA PRIVATE KEY-----

Mentre il file .der convertito con la mia classe mi dà questa chiave:

-----BEGIN RSA PRIVATE KEY-----
MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBALkG9tiA0CUSgH/v
mmajAG/9LwxHPKwShgvfYTfKP+Wsr0aZGI01urPlHC5PpkDCD1JGQ+0RJZOOJX/1
.........................................................................................................
.........................................................................................................
a4l8DfAIevIfJsyGekzb+idXIwASH5L6dU+ZZuQjvt2IN8WlXENEfg0FZgvAiAzL
Bem/dpvTJWbeFw==
-----END RSA PRIVATE KEY-----


Però la chiave corretta è quella ottenuta con openssl. Quindi secondo me potrebbe dipendere dalla conversione.......

tu che dici?????hai visto il link che ti ho postato?????

[kingv]

mi dici la riga comando che usi per convertire con openssl la prima chiave che hai postato?
adesso guardo il link.

[altropinto]

openssl pkcs8 -inform DER -nocrypt -in key.der -out key.pem

Questo è il comando che uso per la conversione. In questo modo ottengo la chiave corretta

[kingv]

openssl pkcs8 -inform DER -nocrypt -in key.der -out key.pem

Questo è il comando che uso per la conversione. In questo modo ottengo la chiave corretta

in questo modo stai convertendo un pkcs8 in formato DER in un vecchio formato (penso sia pkcs#1).

per convertirlo in un pkcs#8 in formato PEM usa:
openssl pkcs8 -inform DER -nocrypt -in key.der -out key.pem -topk8


ora dovresti ottenere lo stesso risultato che da java.

[altropinto]

Innanzitutto mi dà ques'errore:

"unable to load key".

Comunque a me interessa che la chiave sia convertita in quel "vecchio" formato.

Ti spiego il perchè: inizialmente io avevo una chiave privata (hostkey.pem) ed un certificato (hostcert.pem). Da questi, mediante openssl, mi sono creato il pkcs12 (usercert.p12). Ora da questo pkcs12 voglio riottenere la chiave privata (hostkey.pem) e il certificato (hostcert.pem) di partenza.

Confrontando la chiave privata generata con il comando:
openssl pkcs8 -inform DER -nocrypt -in key.der -out key.pem

con la chiave privata di partenza (hostkey.pem) ho notato che sono uguali.

Quindi a me interessa che la chiave privata .der sia convertita in quel formato.

[altropinto]

Da cosa può dipendere?????

Hai qualche idea?????

[kingv]

Da cosa può dipendere?????

Hai qualche idea?????

sì ho capito il perchè, purtroppo sto uscendo ti spiego piu' tardi

[altropinto]

ok................ti ringrazio!!!!!

[kingv]

Il problema è che il formato interno che usa il JDK per le chiavi private è PKCS#8.
Il formato che usa openssl (ma anche apache, ad esempio) è il vecchio formato di SSLeay (non sono sicuro che sia PKCS#1 ma dovrebbe).
openssl è in grado di leggere e convertire i due formati, ma il JDK no.
non sono riuscito a capire se il provider crittografico di BouncyCastle è in grado di fare la conversione, mentre dalla documentazione dovrebbe esserlo quello di IAIK (http://jce.iaik.tugraz.at/) che però è commerciale e a pagamento.

[altropinto]

ok......ti ringrazio!!!!!:) :) :)

Quindi in pratica non lo posso fare senza il Crypto Toolkit.......

Ma per qunato riguarda l'estrazione del pkcs12 dal browser, mi sapresti dare qualche indicazione, qualche link utile????

[kingv]

avevamo la soluzione sotto agli occhi, guardati la classe org.bouncycastle.openssl.PEMWriter
scrive chiavi e certificati nel formato di openssl.

[altropinto]

grazie ancora.....

ma non riesco a capire come utilizzarla...mi potresti postare un esempio????

[kingv]

try
{
PrivateKey privateKey = .... //recuperata dal p12 o generata
PEMWriter pw = new PEMWriter(new FileWriter("myfile.pem"));
pw.writeObject(privateKey);
pw.close();
}
catch (Exception e)
{
e.printStackTrace();
}

[altropinto]

ok ora funziona.....ti ringrazio tantissimo!!!!

:) :) :) :) :) :)

[kingv]

ok ora funziona.....ti ringrazio tantissimo!!!!



ok, bene :)

sull'altro quesito non ho idea, ma non penso che ti sarà facile.
se ci spieghi qual è l'esigenza magari riusciamo a trovare un'altrenativa.

[altropinto]

Salve,
ho un problema.......

In pratica ho il certificato (usercert.pem) e la chiave privata (userkey.pem), vorrei sapere se è possibile ottenere da questi il certificato PKCS12 (cert.p12).

Qualcuno mi può aiutare???

[altropinto]

nessuna idea????

[kingv]

Salve,
ho un problema.......

In pratica ho il certificato (usercert.pem) e la chiave privata (userkey.pem), vorrei sapere se è possibile ottenere da questi il certificato PKCS12 (cert.p12).

Qualcuno mi può aiutare???



openssl pkcs12 -export -in userkey.pem usercert.pem -out file.p12

[altropinto]

Scusami ma forse non mi sono spiegato bene......

devo creare il file .p12 non da openssl ma da un programma (API) java.

mi sapresti aiutare????

[kingv]

Scusami ma forse non mi sono spiegato bene......

devo creare il file .p12 non da openssl ma da un programma (API) java.

mi sapresti aiutare????

pensavo dovessi semplicemente convertire i due formati.

dal jdk 1.5 in poi i keystore pkcs12 sono supportati completamente (prima lo erano solo in lettura), che problema hai?

[altropinto]

In pratica io ho un certificato ed una chiave private: hostcert.pem e hostkey.pem .
Sto implementando un client https e quindi per far questo mi serve o un pkcs12 o un keystore. Siccome per me è + comodo usare il pkcs12, devo implementare una classe che mi crei, a partire dai certificati, un pkcs12.

.........
KeyStore keystorePkcs12;
keystorePkcs12 = KeyStore.getInstance("PKCS12");
keystorePkcs12.load(new FileInputStream("usercert.p12"), PASSWORD_PKCS11.toCharArray());


KeyManagerFactory kKeyManagerFactory;
kKeyManagerFactory = KeyManagerFactory.getInstance(ALGORITHM);
kKeyManagerFactory.init(keystorePkcs12, PASSWORD_PKCS11.toCharArray());

...................


Secondo te è possibile fare tale conversione?????
O mi conviene creare un keystore???

[altropinto]

nessuna idea????