web-dev-qa-db-fra.com

Mauvaise version du magasin de clés sur Android call

Je souhaite faire une demande https.

J'utilise bouncycastle pour générer le magasin de clés comme ceci:

keytool -importcert -trustcacerts -alias ludevCA -file lu_dev_cert.crt -keypass mypass -keystore keystore.bks -storepass mypass -storetype BKS -providerclass org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath bcprov-jdk15on-146.jar

Et la commande keylist renvoie une valeur correcte.

Mais quand je fais :

KeyStore ks = KeyStore.getInstance("BKS");
InputStream in = getResources().openRawResource(R.raw.keystore);  
ks.load(in, "mypass".toCharArray());

j'ai une erreur:

wrong version of keystore

J'ai essayé d'utiliser plusieurs versions de bouncycast, mais le résultat est le même. J'ai également essayé de définir la taille de clé 1024, mais rien ne change.

Des idées ?

javaandroidcertificatebouncycastlekeystore
32
JuSchz

Jetez-y un œil Android: Faire confiance aux certificats SSL

  -storetype BKS
  -provider org.bouncycastle.jce.provider.BouncyCastleProvider
  -providerpath /path/to/bouncycastle.jar

Et utilisez cette version lors de la création de votre magasin de clés: Version 1.46 trouvée ici

Que cela aide ...

32
Strider

Plus besoin de tout refaire !!!

Vous devez modifier le type du fichier de clés, de BKS à BKS-v1 (BKS-v1 est une ancienne version de BKS). Parce que la version BKS a changé comme dit ici

Il existe une autre solution, beaucoup plus simple:

  1. Utilisation de Portecle:

    • Téléchargements Portecle http://portecle.sourceforge.net/
    • Ouvrez votre fichier bks avec le mot de passe et le portecle
    • Outils >> Changer le type de magasin de clés >> BKS-v1
    • Sauvegardez le fichier

  2. Vous pouvez utiliser KeyStore Explorer

Le nouveau fichier sera encodé avec BKS-v1 et ne montrera plus l'erreur ....

Remarque: Android fonctionne avec différentes versions de BKS: par exemple, l'API 15 nécessitera BKS-1 contrairement à l'API 23 qui nécessitent BKS, vous devrez donc peut-être mettre les deux fichiers dans votre application.

Remarque 2: Vous pouvez utiliser ce code:

int bks_version;
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
    bks_version = R.raw.publickey; //The BKS file
} else {
    bks_version = R.raw.publickey_v1; //The BKS (v-1) file
}
KeyStore ks = KeyStore.getInstance("BKS");
InputStream in = getResources().openRawResource(bks_version);  
ks.load(in, "mypass".toCharArray());
26
Cukic0d

Enfin j'ai utilisé un éditeur graphique (KeyStore Explorer) sous Windows et ça marche.

Peut-être que l'erreur a été causée par des problèmes de version Java/Mac

5
JuSchz

La solution est là, capable de supprimer le prolem de version

Création d'un fichier BKS pour Android

Détails d'installation du logiciel requis pour créer le fichier BKS:

Téléchargez le logiciel Keystore Explorer à partir du lien http://keystore-Explorer.sourceforge.net/

Téléchargez UnlimitedJCEPolicyJDK7 à partir de http://www.Oracle.com/technetwork/Java/javase/downloads/jce-7-download-432124.html

Extrayez Zip et copiez US_export_policy et local_policy dans votre fichier C:/programes/Java/jre7/lib/security.

installez le logiciel Keystore Explorer.

Étapes pour générer un fichier BKS: (Besoin d'un fichier CA, d'un fichier de certificat, d'un fichier clé et d'un fichier .P12, c'est-à-dire un fichier PKCS (si disponible).

1) Création d'un fichier de confiance à l'aide d'un fichier CA .crt à l'aide d'un logiciel de magasin de clés.

Pas:

Logiciel ouvert
Allez Fichier-> Nouveau-> sélectionnez .BKS dans l'assistant Pour importer un fichier de certificat CA Allez Outil-> Importer un certificat de confiance -> sélectionnez un fichier CA .crt -> mot de passe de divertissement -> (Cela générera une exception si certificat est auto-signé) importez le fichier avec force.

4.Enregistrez le fichier avec l'extension .bks.

2) Création d'un fichier de clé à l'aide d'un fichier .P12 à l'aide d'un logiciel de magasin de clés

Pas

Ouvrez le logiciel Allez Fichier-> Nouveau-> sélectionnez .BKS dans l'assistant

Importer> Outil p12 Go -> Importer une paire de clés -> sélectionner PKCS # 12 à partir de l'assistant -> entrer le mot de passe de description pour le fichier et parcourir le fichier -> Entrer le nom de l'alise (si vous souhaitez changer, vous pouvez le conserver tel quel) -> Entrer nouveau mot de passe

Enregistrez le fichier avec l'extension .bks.

3) Création d'un fichier de clé en utilisant si le fichier .P12 n'est pas disponible à l'aide du logiciel de magasin de clés

Pas

Logiciel ouvert

Allez Fichier-> Nouveau-> sélectionnez .BKS à partir de l'assistant Importer> fichier p12 Allez Outil -> Importer la paire de clés -> sélectionnez OpenSSL à partir de l'assistant -> mot de passe de description non vérifié pour le fichier, les navigateurs .key et .crt (fichier de certificat non CA) fichier -> Entrez le nom de l'alise (si vous souhaitez le changer, vous pouvez le conserver tel quel) -> Entrez un nouveau mot de passe

Enregistrez le fichier avec l'extension .bks.

Copiez les deux fichiers dans le dossier res/raw (les deux fichiers BKS sont obligatoires).

Code:

 static final String ENABLED_CIPHERS[] = {
    "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
    "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
    "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",
    "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
    "TLS_DHE_RSA_WITH_AES_128_CBC_SHA",
    "TLS_DHE_RSA_WITH_AES_256_CBC_SHA",
    "TLS_DHE_DSS_WITH_AES_128_CBC_SHA",
    "TLS_ECDHE_RSA_WITH_RC4_128_SHA",
    "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",
    "TLS_RSA_WITH_AES_256_CBC_SHA",
    "TLS_RSA_WITH_AES_128_CBC_SHA",
    "SSL_RSA_WITH_3DES_EDE_CBC_SHA",
    "SSL_RSA_WITH_RC4_128_SHA",
    "SSL_RSA_WITH_RC4_128_MD5",
};
// put this in a place where it can be reused
static final String ENABLED_PROTOCOLS[] = {
        "TLSv1.2", "TLSv1.1", "TLSv1"
    };

   private void sslCon()
    {
        try {
                             // setup truststore to provide trust for the server certificate
              // load truststore certificate
            InputStream trustStoresIs = getResources().openRawResource(R.raw.client_ca);
            String trustStoreType = KeyStore.getDefaultType();
            KeyStore trustStore = KeyStore.getInstance(trustStoreType);
            trustStore.load(trustStoresIs, "spsoft_123".toCharArray());
            //keyStore.setCertificateEntry("ca", ca);

            // initialize trust manager factory with the read truststore
            String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
            TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
            tmf.init(trustStore);

            // setup client certificate
            // load client certificate
            InputStream keyStoreStream = getResources().openRawResource(R.raw.client_cert_key);
            KeyStore keyStore = null;
            keyStore = KeyStore.getInstance("BKS");
            keyStore.load(keyStoreStream, "your password".toCharArray());

            KeyManagerFactory keyManagerFactory = null;
            keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(keyStore, "your password".toCharArray());

            // Create an SSLContext that uses our TrustManager
            SSLContext context = SSLContext.getInstance("SSL");
            context.init(keyManagerFactory.getKeyManagers(), tmf.getTrustManagers(), null);

            SSLSocketFactory sslsocketfactory = (SSLSocketFactory)context.getSocketFactory();
            InetAddress serverAddr = InetAddress.getByName("192.168.11.104");
            sslSocket = (SSLSocket) sslsocketfactory.createSocket(serverAddr, 5212);
            //String[] ciphers = sslSocket.getEnabledCipherSuites();
            sslSocket.setEnabledCipherSuites(ENABLED_CIPHERS);
            // put this right before setEnabledCipherSuites()!
            //sslSocket.setEnabledProtocols(ENABLED_PROTOCOLS);
            //InputStream inputStream =  sslSocket.getInputStream();
            OutputStream out = sslSocket.getOutputStream();

            Toast.makeText(getApplicationContext(), "Connected", Toast.LENGTH_SHORT).show();
            sslSocket.close();


        } catch (KeyManagementException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (CertificateException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (KeyStoreException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (UnrecoverableKeyException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}
2
Vikrant

Je poste cette réponse pour fournir une version cmdline pour convertir un fichier .pkcs12 en keystore.bks

Ce qui est necessaire:

Si vous ne savez pas comment générer un fichier .PKCS12, consultez ces sites:

Pour cet exemple, j'utilise jetty.pkcs12 comme source. La commande génère: keystore.bks /usr/local/share/Java/portecle-1.9/ est le chemin où j'ai installé le Portecle-Tool téléchargé (.Zip)

keytool -importkeystore -srckeystore jetty.pkcs12 \
-srcstoretype PKCS12 -deststoretype BKS -providerpath \
/usr/local/share/Java/portecle-1.9/bcprov.jar -provider \
org.bouncycastle.jce.provider.BouncyCastleProvider-destkeystore \
keystore.bks

Vous pouvez maintenant utiliser le BKS-Keystore sous Android

Grâce à la publication précédente, j'ai pu trouver une solution et fournir cette cmd. J'espère que cela aide quelqu'un!

0
Mike Mitterer

Utilisez l'un d'eux.

KeyStore.getInstance ("BKS"); KeyStore.getInstance ("PKCS12");

0
Ali Bagheri