Connexion Https Android

Je suis en train de faire une supposition, mais si vous voulez une véritable poignée de main à se produire, vous devez laisser android savoir de votre certificat. Si vous voulez juste accepter n'importe quoi, puis utiliser ce pseudo-code pour obtenir ce dont vous avez besoin avec le Client HTTP Apache:

SchemeRegistry schemeRegistry = new SchemeRegistry ();

schemeRegistry.register (new Scheme ("http",
    PlainSocketFactory.getSocketFactory (), 80));
schemeRegistry.register (new Scheme ("https",
    new CustomSSLSocketFactory (), 443));

ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager (
    params, schemeRegistry);


return new DefaultHttpClient (cm, params);

CustomSSLSocketFactory:

public class CustomSSLSocketFactory extends org.apache.http.conn.ssl.SSLSocketFactory
{
private SSLSocketFactory FACTORY = HttpsURLConnection.getDefaultSSLSocketFactory ();

public CustomSSLSocketFactory ()
    {
    super(null);
    try
        {
        SSLContext context = SSLContext.getInstance ("TLS");
        TrustManager[] tm = new TrustManager[] { new FullX509TrustManager () };
        context.init (null, tm, new SecureRandom ());

        FACTORY = context.getSocketFactory ();
        }
    catch (Exception e)
        {
        e.printStackTrace();
        }
    }

public Socket createSocket() throws IOException
{
    return FACTORY.createSocket();
}

 //TODO: add other methods like createSocket() and getDefaultCipherSuites().
 //Hint: they all just make a call to member FACTORY 
}

FullX509TrustManager est une classe qui implémente javax.net.le protocole ssl.X509TrustManager, mais aucune des méthodes d'effectuer un travail, obtenir un échantillon ici.

Bonne Chance!

OriginalL'auteur Nate

Tout en essayant de répondre à cette question, j'ai trouvé un meilleur tutoriel. Avec elle, vous n'avez pas à compromettre la vérification du certificat.

http://blog.crazybob.org/2010/02/android-trusting-ssl-certificates.html

*Je n'ai pas écrit cela, mais merci à Bob Lee pour le travail

OriginalL'auteur bajohns

http://madurangasblogs.blogspot.in/2013/08/avoiding-javaxnetsslsslpeerunverifiedex.html

Courtoisie Maduranga

Lors du développement d'une application qui utilise le protocole https, votre serveur de test n'a pas un certificat SSL valide. Ou, parfois, le site web est d'utiliser un certificat auto-signé ou le site web est à l'aide de certificat SSL gratuit. Donc, si vous essayez de vous connecter au serveur à l'aide d'Apache HttpClient, vous obtiendrez une exception indiquant que le "peer pas authentifié". Si elle n'est pas une bonne pratique de faire confiance à tous les certificats dans un logiciel de production, vous pouvez avoir à le faire selon la situation.
Cette solution résout l'exception provoquée par les "pairs non authentifié".

Mais avant d'aller à la solution, je dois vous avertir que ce n'est pas une bonne idée pour une application de production. Ce sera atteinte à l'objet de l'aide d'un certificat de sécurité. Donc, sauf si vous avez une bonne raison, ou si vous êtes sûr que cela ne cause aucun problème, n'utilisez pas cette solution.

Normalement, vous créer un HttpClient comme ça.

HttpClient httpclient = new DefaultHttpClient();

Mais vous avez à changer la façon dont vous créez les HttpClient.

Vous devez d'abord créer une classe étendant org.apache.http.conn.ssl.SSLSocketFactory.

import org.apache.http.conn.ssl.SSLSocketFactory;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
public class MySSLSocketFactory extends SSLSocketFactory {
SSLContext sslContext = SSLContext.getInstance("TLS");
public MySSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
super(truststore);
TrustManager tm = new X509TrustManager() {
public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return null;
}
};
sslContext.init(null, new TrustManager[] { tm }, null);
}
@Override
public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
}
@Override
public Socket createSocket() throws IOException {
return sslContext.getSocketFactory().createSocket();
}
}

Puis créer une méthode de ce genre.

public HttpClient getNewHttpClient() {
try {
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
trustStore.load(null, null);
SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
HttpParams params = new BasicHttpParams();
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
registry.register(new Scheme("https", sf, 443));
ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);
return new DefaultHttpClient(ccm, params);
} catch (Exception e) {
return new DefaultHttpClient();
}
}

Alors vous pouvez créer le HttpClient.

HttpClient httpclient = getNewHttpClient();

Si vous essayez d'envoyer une requête post vers une page de connexion le reste du code sera comme ceci.

private URI url = new URI("url of the action of the form");
HttpPost httppost =  new HttpPost(url);
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();  
nameValuePairs.add(new BasicNameValuePair("username", "user"));  
nameValuePairs.add(new BasicNameValuePair("password", "password"));
try {
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
InputStream is = entity.getContent();
} catch (UnsupportedEncodingException e) {
//TODO Auto-generated catch block
e.printStackTrace();
} catch (ClientProtocolException e) {
//TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}

Vous obtenez la page html à l'InputStream. Ensuite, vous pouvez faire ce que vous voulez avec le retour de la page html.

Mais ici, vous ferez face à un problème. Si vous souhaitez gérer une session à l'aide de cookies, vous ne serez pas en mesure de le faire avec cette méthode. Si vous voulez obtenir les cookies, vous devrez le faire par l'intermédiaire d'un navigateur. Alors seulement vous recevrez des cookies.

OriginalL'auteur Rohit Mandiwal

Aucun de ces fonctionné pour moi (aggravée par la Thawte bug ainsi). Finalement je l'ai fixé avec de la SSL auto-signé de l'acceptation sur Android et SSL personnalisé manipulation ne fonctionne plus sur Android 2.2 FroYo

OriginalL'auteur Adrian Spinei

Je ne sais pas à propos de l'Android spécificités pour les certificats ssl, mais il serait logique que Android ne sera pas accepter un certificat ssl auto-signé au large de la chauve-souris. J'ai trouvé ce post sur les forums android qui semble être portant sur le même sujet:
http://androidforums.com/android-applications/950-imap-self-signed-ssl-certificates.html

OriginalL'auteur Matti Lyra

Pour une raison quelconque, la solution indiquée pour httpClient ci-dessus n'a pas fonctionné pour moi. À la fin, j'ai été capable de le faire fonctionner correctement substitution de la méthode lors de la mise en œuvre de la coutume SSLSocketFactory classe.

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

C'est la façon dont il a fonctionné parfaitement pour moi. Vous pouvez voir l'intégralité de classe personnalisée et la mise en œuvre sur le fil de discussion suivant:
http://blog.syedgakbar.com/2012/07/21/android-https-and-not-trusted-server-certificate-error/

OriginalL'auteur Syed Ghulam Akbar

Sources qui m'ont permis d'apprendre à travailler avec mon certificat auto-signé sur mon AWS serveur Apache et de se connecter avec HttpsURLConnection à partir d'un appareil android:

SSL aws exemple - amazon tutoriel sur ssl

Android de Sécurité avec HTTPS et SSL - la création de votre propre confiance gestionnaire du client pour l'acceptation de votre certificat

La création d'un certificat auto-signé - facile de script pour la création de vos certificats

Puis j'ai fait la suivante:

1. Fait en sorte que le serveur prend en charge le protocole https (sudo yum install-y mod24_ssl)
2. Mettre ce script dans un fichier create_my_certs.sh:

#!/bin/bash
FQDN=$1
# make directories to work from
mkdir -p server/ client/ all/
# Create your very own Root Certificate Authority
openssl genrsa \
-out all/my-private-root-ca.privkey.pem \
2048
# Self-sign your Root Certificate Authority
# Since this is private, the details can be as bogus as you like
openssl req \
-x509 \
-new \
-nodes \
-key all/my-private-root-ca.privkey.pem \
-days 1024 \
-out all/my-private-root-ca.cert.pem \
-subj "/C=US/ST=Utah/L=Provo/O=ACME Signing Authority Inc/CN=example.com"
# Create a Device Certificate for each domain,
# such as example.com, *.example.com, awesome.example.com
# NOTE: You MUST match CN to the domain name or ip address you want to use
openssl genrsa \
-out all/privkey.pem \
2048
# Create a request from your Device, which your Root CA will sign
openssl req -new \
-key all/privkey.pem \
-out all/csr.pem \
-subj "/C=US/ST=Utah/L=Provo/O=ACME Tech Inc/CN=${FQDN}"
# Sign the request from Device with your Root CA
openssl x509 \
-req -in all/csr.pem \
-CA all/my-private-root-ca.cert.pem \
-CAkey all/my-private-root-ca.privkey.pem \
-CAcreateserial \
-out all/cert.pem \
-days 500
# Put things in their proper place
rsync -a all/{privkey,cert}.pem server/
cat all/cert.pem > server/fullchain.pem         # we have no intermediates in this case
rsync -a all/my-private-root-ca.cert.pem server/
rsync -a all/my-private-root-ca.cert.pem client/

1. Exécuter bash create_my_certs.sh yourdomain.com

2. Place les certificats à leur place sur le serveur (vous pouvez trouver la configuration dans /etc/httpd/conf.d/ssl.conf). Toutes ces mesures devraient être définies:
   
   SSLCertificateFile
   
   SSLCertificateKeyFile
   
   SSLCertificateChainFile
   
   SSLCACertificateFile

3. Redémarrer httpd à l'aide de sudo service httpd restart et assurez-vous que httpd commencé:
   
   L'arrêt de httpd: [ OK ]
   
   Démarrer httpd: [ OK ]

4. Copie my-private-root-ca.cert pour votre projet android actifs dossier

5. Créer votre confiance manager:

   SSLContext SSLContext;

   CertificateFactory cf = CertificateFactory.getInstance("X. 509");
   InputStream caInput = contexte.getAssets().open("mon-privé-root-ca.cert.pem");
   Certificat d'autorité de certification;
   try {
   ca = cf.generateCertificate(caInput);
   } finally {
   caInput.close();
   }

     //Create a KeyStore containing our trusted CAs
   String keyStoreType = KeyStore.getDefaultType();
   KeyStore keyStore = KeyStore.getInstance(keyStoreType);
   keyStore.load(null, null);
   keyStore.setCertificateEntry("ca", ca);
   //Create a TrustManager that trusts the CAs in our KeyStore
   String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
   TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
   tmf.init(keyStore);
   //Create an SSLContext that uses our TrustManager
   SSLContext = SSLContext.getInstance("TLS");
   SSSLContext.init(null, tmf.getTrustManagers(), null);

6. Et établissez la connexion à l'aide de HttpsURLConnection:

   HttpsURLConnection connexion = (HttpsURLConnection) url.openConnection();
   connexion.setSSLSocketFactory(SSLContext.getSocketFactory());

7. C'est ça, essayez de votre connexion https.

OriginalL'auteur MikeL