Java: formato keystore non valido, se generato tramite codice

Question

Questo è stato chiesto un paio di volte, ma nessuno fornisce casi di test codificati. Qui faccio un esempio del problema:

1. generazione programmatica di un Keystore (funziona)
2. creazione del certificato all'interno di quel negozio (opere)
3. salvataggio del keystore su disco (funziona)
4. elencando il keystore con keytool (funziona)
5. caricamento del keystore a livello di codice (errore con IOException: InvalidKeystoreFormat)

Quello che non capisco è che sia in save che in load, utilizzo KeyStore.getInstance (" JKS ") , ma non funziona. Eventuali suggerimenti sono ben accetti!

Output di runtime:

Creating private keystore at 'private.keystore'.
Created keystore, now created signer cert
Created signer cert, saving cert
Reloading keystore:
Failed to load the keystore after creation: Invalid keystore format

Origine del test case:

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.InvalidKeyException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.SignatureException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import sun.security.x509.X500Name;

public class KeystoreCreator
{
 private String fPrivateKeyStore;
 private String fPrivateKeyStorePassword;
 private String fPrivateKeyStoreKeyPassword;
 private String fPublicKeyCipherPassword;
 private String fPrivateKeyAlias;

 /**
  * @param args
  * @throws Exception 
  */
 public static void main(String[] args) throws Exception
 {
  KeystoreCreator creator = new KeystoreCreator();

  creator.setPrivateKeyStore("private.keystore");
  creator.setPrivateKeyStorePassword("beer123");

  creator.setPrivateKeyAlias("myalias");
  creator.setPrivateKeyStoreKeyPassword("beer123");
  creator.setPublicKeyCipherPassword("beer123");

  creator.initKeyStores();
 }

 public KeystoreCreator()
 {  
 }

 public void setPrivateKeyStore(String name)
 {
  fPrivateKeyStore=name;
 }
 public void setPrivateKeyStorePassword(String pass)
 {
  fPrivateKeyStorePassword=pass;
 }
 public void setPrivateKeyStoreKeyPassword(String pass)
 {
  fPrivateKeyStoreKeyPassword=pass;
 }
 public void setPublicKeyCipherPassword(String pass)
 {
  fPublicKeyCipherPassword=pass;
 }
 public void setPrivateKeyAlias(String alias)
 {
  fPrivateKeyAlias=alias;
 }

    public void initKeyStores() throws Exception
    {
        OutputStream out = null;
        File f=new File(fPrivateKeyStore);
        if (f.exists())
        {
         f.delete();
         if (f.exists())
         {
          throw new IOException("Want to remove the keystore but can't, still reported as present after removal");
         }
        }
        try
        {
         System.out.println("Creating private keystore at '" + fPrivateKeyStore + "'.");
         out = new FileOutputStream(fPrivateKeyStore);
         KeyStore privateKeyStore = KeyStore.getInstance("JKS");
         privateKeyStore.load(null, fPrivateKeyStorePassword.toCharArray());

         System.out.println("Created keystore, now created signer cert");
         X500Name x500name=getCA();
         Certificate cert = createCertificate(fPrivateKeyAlias, fPrivateKeyStoreKeyPassword, x500name, privateKeyStore);

         System.out.println("Created signer cert, saving cert");
         privateKeyStore.store(out, fPublicKeyCipherPassword.toCharArray());
         out.flush();
         out.close();
         //try to load it.
         KeyStore reloadedKeyStore = KeyStore.getInstance("JKS");
         try
         {
          InputStream reloadedIs=getClass().getClassLoader().getResourceAsStream(fPrivateKeyStore);
          if (reloadedIs!=null)
          {
           System.out.println("Reloading keystore:");
           reloadedKeyStore.load(reloadedIs, fPrivateKeyStorePassword.toCharArray());
          }
         }
         catch (Exception e)
         {
          System.err.println("Failed to load the keystore after creation: "+e.getLocalizedMessage());
         }
        }
        catch (Exception e)
        {
         System.err.println("Failed to save the keystore: "+e.getLocalizedMessage());
        }
    }

    private X500Name getCA() throws IOException
    {
     return new sun.security.x509.X500Name("a","b", "c","d","e", "GB");
    }

    public Certificate createCertificate( String alias, String keyPassword,
            sun.security.x509.X500Name x500Name, KeyStore keyStore ) throws NoSuchAlgorithmException,
            InvalidKeyException, CertificateException, SignatureException, NoSuchProviderException,
            KeyStoreException {     
        sun.security.x509.CertAndKeyGen keypair = new sun.security.x509.CertAndKeyGen( "RSA", "MD5WithRSA" );
        keypair.generate( 1024 );
        PrivateKey privKey = keypair.getPrivateKey();
        X509Certificate[] chain = new X509Certificate[1];
        chain[0] = keypair.getSelfCertificate( x500Name, 7000 * 24 * 60 * 60 );
        keyStore.setKeyEntry( alias, privKey, keyPassword.toCharArray(), chain );

        Certificate cert = keyStore.getCertificate( alias );
        return cert;
    }
}

Answer 1

1) È possibile creare l'archivio chiavi privato nella directory di lavoro corrente, scrivendo in un file : new FileOutputStream (fPrivateKeyStore);

2) Successivamente, leggi dal percorso della classe utilizzando getClass().getClassLoader().getResourceAsStream(fPrivateKeyStore);

Penso che tu stia leggendo i file sbagliati. E ce n'è già un altro con il nome private.keystore dei test precedenti. Per verificare, potresti voler stampare il percorso assoluto del file di entrambi i file, ad es. nuovo file (fPrivateKeyStore) .getAbsolutePath () e confrontalo con getClass().getClassLoader().getResource(fPrivateKeyStore).toFileURL();

Answer 2

Forse mi manca qualcosa, ma perché non ricaricare l'archivio delle chiavi private usando FileInputStream ?

InputStream reloadedIs = new FileInputStream(fPrivateKeyStore);

(Non sono sicuro che questo risolva il problema, l'ho appena notato durante la scansione del codice)