SSL auto-signé de l'acceptation sur Android

J'ai cette fonctionnalité dans exchangeIt, qui se connecte à Microsoft exchange via WebDav. Voici un code pour créer un client http qui va se connecter à l'auto-signé cert via SSL:

SchemeRegistry schemeRegistry = new SchemeRegistry();
//http scheme
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
//https scheme
schemeRegistry.register(new Scheme("https", new EasySSLSocketFactory(), 443));

HttpParams params = new BasicHttpParams();
params.setParameter(ConnManagerPNames.MAX_TOTAL_CONNECTIONS, 30);
params.setParameter(ConnManagerPNames.MAX_CONNECTIONS_PER_ROUTE, new ConnPerRouteBean(30));
params.setParameter(HttpProtocolParams.USE_EXPECT_CONTINUE, false);
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);

ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);

La EasySSLSocketFactory est ici, et la EasyX509TrustManager est ici.

Le code pour exchangeIt est open source, et hébergé sur googlecode ici, si vous avez des questions. Je ne suis pas en train de le plus, mais le code devrait fonctionner.

Noter que depuis Android 2.2 le processus a changé un peu, afin de vérifier cette pour rendre le code ci-dessus.

J'ai fait face à cette question hier, lors de la migration de notre société API RESTful HTTPS, mais à l'aide de certificats SSL auto-signés.

J'ai cherché partout, mais tous les "corriger", a marqué les réponses que j'ai trouvé se composait de la désactivation de la validation de certificat, clairement écrasant tous les sens du protocole SSL.

Je suis finalement venu à une solution:

1. Créer Des Locaux De Stockage Des Clés

   Pour permettre à votre application de valider vos certificats auto-signés, vous devez fournir une coutume keystore avec les certificats d'une manière qui Android peuvent faire confiance à votre point de terminaison.

Le format de ces personnalisées des fichiers de clés est "BKS" de BouncyCastle, si vous avez besoin de la version 1.46 de BouncyCastleProvider que vous pouvez télécharger ici.

Vous avez également besoin de votre certificat auto-signé, je vais supposer que c'est nommée self_cert.pem.

Maintenant la commande pour la création de votre fichier de clés est:

<!-- language: lang-sh -->

    $ keytool -import -v -trustcacerts -alias 0 \
    -file *PATH_TO_SELF_CERT.PEM* \
    -keystore *PATH_TO_KEYSTORE* \
    -storetype BKS \
    -provider org.bouncycastle.jce.provider.BouncyCastleProvider \
    -providerpath *PATH_TO_bcprov-jdk15on-146.jar* \
    -storepass *STOREPASS*

PATH_TO_KEYSTORE pointe vers un fichier de votre fichier de clés sera créé. Il ne DOIT PAS EXISTER.

PATH_TO_bcprov-jdk15on-146.jar.JAR est le chemin d'accès pour le téléchargement .jar libary.

STOREPASS est votre nouvellement créé de mot de passe du fichier de clés.

1. Inclure fichier de clés dans votre Application

Copier le nouveau fichier de stockage des clés de PATH_TO_KEYSTORE à res/raw/certs.bks (certs.bks est juste le nom du fichier; vous pouvez utiliser n'importe quel nom que vous voulez)

Créer une clé dans res/values/strings.xml avec

<!-- language: lang-xml -->

    <resources>
    ...
        <string name="store_pass">*STOREPASS*</string>
    ...
    </resources>

1. Créer un cette classe qui hérite DefaultHttpClient

   import android.content.Context;
   import android.util.Log;
   import org.apache.http.conn.scheme.PlainSocketFactory;
   import org.apache.http.conn.scheme.Scheme;
   import org.apache.http.conn.scheme.SchemeRegistry;
   import org.apache.http.conn.ssl.SSLSocketFactory;
   import org.apache.http.impl.client.DefaultHttpClient;
   import org.apache.http.params.HttpParams;
   import java.io.IOException;
   import java.io.InputStream;
   import java.security.*;
   public class MyHttpClient extends DefaultHttpClient {
   private static Context appContext = null;
   private static HttpParams params = null;
   private static SchemeRegistry schmReg = null;
   private static Scheme httpsScheme = null;
   private static Scheme httpScheme = null;
   private static String TAG = "MyHttpClient";
   public MyHttpClient(Context myContext) {
   appContext = myContext;
   if (httpScheme == null || httpsScheme == null) {
   httpScheme = new Scheme("http", PlainSocketFactory.getSocketFactory(), 80);
   httpsScheme = new Scheme("https", mySSLSocketFactory(), 443);
   }
   getConnectionManager().getSchemeRegistry().register(httpScheme);
   getConnectionManager().getSchemeRegistry().register(httpsScheme);
   }
   private SSLSocketFactory mySSLSocketFactory() {
   SSLSocketFactory ret = null;
   try {
   final KeyStore ks = KeyStore.getInstance("BKS");
   final InputStream inputStream = appContext.getResources().openRawResource(R.raw.certs);
   ks.load(inputStream, appContext.getString(R.string.store_pass).toCharArray());
   inputStream.close();
   ret = new SSLSocketFactory(ks);
   } catch (UnrecoverableKeyException ex) {
   Log.d(TAG, ex.getMessage());
   } catch (KeyStoreException ex) {
   Log.d(TAG, ex.getMessage());
   } catch (KeyManagementException ex) {
   Log.d(TAG, ex.getMessage());
   } catch (NoSuchAlgorithmException ex) {
   Log.d(TAG, ex.getMessage());
   } catch (IOException ex) {
   Log.d(TAG, ex.getMessage());
   } catch (Exception ex) {
   Log.d(TAG, ex.getMessage());
   } finally {
   return ret;
   }
   }
   }

Maintenant il suffit d'utiliser une instance de **MyHttpClient** comme vous le feriez avec **DefaultHttpClient** pour faire de votre HTTPS requêtes, et il va utiliser et de valider correctement vos certificats SSL auto-signés.

HttpResponse httpResponse;
HttpPost httpQuery = new HttpPost("https://yourserver.com");
... set up your query ...
MyHttpClient myClient = new MyHttpClient(myContext);
try{
httpResponse = myClient.(peticionHttp);
//Check for 200 OK code
if (httpResponse.getStatusLine().getStatusCode() == HttpURLConnection.HTTP_OK) {
... do whatever you want with your response ...
}
}catch (Exception ex){
Log.d("httpError", ex.getMessage());
}

Brian Yarger réponse fonctionne sous Android 2.2 ainsi, si vous modifiez le plus grand createSocket surcharge de la méthode comme suit. Il m'a fallu un certain temps pour obtenir l'auto-signé Ssl de travail.

public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
}

@Chris - ce Détachement comme une réponse car je ne peux pas ajouter des commentaires (pas encore). Je me demandais si votre approche est censé fonctionner lors de l'utilisation d'une webView. Je n'arrive pas à le faire sur Android 2.3 - au lieu de cela, j'ai juste un écran blanc.

Après quelques recherches, je suis tombé sur ce solution simple pour le traitement des erreurs SSL dans une webView qui a fonctionné comme un charme pour moi.

Dans le gestionnaire j'ai vérifier pour voir si je suis dans un dev mode et gestionnaire d'appel.aller de l'avant(), sinon je le gestionnaire d'appel.annuler(). Cela me permet de faire du développement à l'encontre d'un auto-signé cert sur un site web local.