java - studio - httpsurlconnection android

Https Connection Android

Question

Estoy haciendo una publicación de https y obtengo una excepción de excepción ssl Certificado de servidor no confiable. Si hago un http normal, está funcionando perfectamente bien. ¿Debo aceptar el certificado del servidor de alguna manera?

Answer 1

Al tratar de responder esta pregunta, encontré un mejor tutorial. Con eso no tiene que comprometer la verificación del certificado.

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

* No escribí esto, pero gracias a Bob Lee por el trabajo

Answer 2

Cualquiera de estas respuestas no funcionó para mí, así que aquí hay un código que confía en cualquier certificado.

import java.io.IOException;

    import java.net.Socket;
    import java.security.KeyManagementException;
    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;

    import org.apache.http.client.ClientProtocolException;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.methods.HttpPost;
    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.conn.ssl.X509HostnameVerifier;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
    import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;

    public class HttpsClientBuilder {
        public static DefaultHttpClient getBelieverHttpsClient() {

            DefaultHttpClient client = null;

            SchemeRegistry Current_Scheme = new SchemeRegistry();
            Current_Scheme.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
            try {
                Current_Scheme.register(new Scheme("https", new Naive_SSLSocketFactory(), 8443));
            } catch (KeyManagementException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (UnrecoverableKeyException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (NoSuchAlgorithmException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (KeyStoreException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            HttpParams Current_Params = new BasicHttpParams();
            int timeoutConnection = 8000;
            HttpConnectionParams.setConnectionTimeout(Current_Params, timeoutConnection);
            int timeoutSocket = 10000;
            HttpConnectionParams.setSoTimeout(Current_Params, timeoutSocket);
            ThreadSafeClientConnManager Current_Manager = new ThreadSafeClientConnManager(Current_Params, Current_Scheme);
            client = new DefaultHttpClient(Current_Manager, Current_Params);
            //HttpPost httpPost = new HttpPost(url);
            //client.execute(httpPost);

         return client;
         }

    public static class Naive_SSLSocketFactory extends SSLSocketFactory
    {
        protected SSLContext Cur_SSL_Context = SSLContext.getInstance("TLS");

        public Naive_SSLSocketFactory ()
                throws NoSuchAlgorithmException, KeyManagementException,
                KeyStoreException, UnrecoverableKeyException
        {
            super(null, null, null, null, null, (X509HostnameVerifier)null);
            Cur_SSL_Context.init(null, new TrustManager[] { new X509_Trust_Manager() }, null);
        }

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

        @Override
        public Socket createSocket() throws IOException
        {
            return Cur_SSL_Context.getSocketFactory().createSocket();
        }
    }

    private static class X509_Trust_Manager implements X509TrustManager
    {

        public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
            // TODO Auto-generated method stub

        }

        public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
            // TODO Auto-generated method stub

        }

        public X509Certificate[] getAcceptedIssuers() {
            // TODO Auto-generated method stub
            return null;
        }

    };
}

Answer 3

Este es un problema conocido con Android 2.x. Estuve luchando con este problema durante una semana hasta que me encontré con la siguiente pregunta, que no solo brinda una buena base del problema, sino que también proporciona una solución efectiva y efectiva sin agujeros de seguridad.

Error ''No peer certificate'' en Android 2.3 pero NO en 4

Answer 4

Esto es lo que estoy haciendo. Simplemente ya no verifica el certificado.

// always verify the host - dont check for certificate
final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
    public boolean verify(String hostname, SSLSession session) {
        return true;
    }
};

/**
 * Trust every server - dont check for any certificate
 */
private static void trustAllHosts() {
    // Create a trust manager that does not validate certificate chains
    TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return new java.security.cert.X509Certificate[] {};
        }

        public void checkClientTrusted(X509Certificate[] chain,
                String authType) throws CertificateException {
        }

        public void checkServerTrusted(X509Certificate[] chain,
                String authType) throws CertificateException {
        }
    } };

    // Install the all-trusting trust manager
    try {
        SSLContext sc = SSLContext.getInstance("TLS");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        HttpsURLConnection
                .setDefaultSSLSocketFactory(sc.getSocketFactory());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

y

    HttpURLConnection http = null;

    if (url.getProtocol().toLowerCase().equals("https")) {
        trustAllHosts();
        HttpsURLConnection https = (HttpsURLConnection) url.openConnection();
        https.setHostnameVerifier(DO_NOT_VERIFY);
        http = https;
    } else {
        http = (HttpURLConnection) url.openConnection();
    }

Answer 5

Estoy adivinando, pero si quiere que se produzca un verdadero apretón de manos, debe informar a Android de su certificado. Si solo quiere aceptar, pase lo que pase, utilice este pseudocódigo para obtener lo que necesita con Apache HTTP Client:

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 es una clase que implementa javax.net.ssl.X509TrustManager, pero ninguno de los métodos realmente realiza ningún trabajo, obtenga una muestra here .

¡Buena suerte!

Answer 6

Fuentes que me ayudaron a trabajar con mi certificado autofirmado en mi servidor AWS Apache y conectarme con HttpsURLConnection desde un dispositivo Android:

SSL en instancia de aws - amazon tutorial en ssl
Seguridad de Android con HTTPS y SSL : crear su propio administrador de confianza en el cliente para aceptar su certificado
Creación de certificado autofirmado : secuencia de comandos sencilla para crear sus certificados

Entonces hice lo siguiente:

1. Se aseguró de que el servidor sea compatible con https (sudo yum install -y mod24_ssl)
2. Coloque esta secuencia de comandos en un archivo 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/

3. Ejecute bash create_my_certs.sh yourdomain.com

4. Coloque los certificados en su lugar correcto en el servidor (puede encontrar la configuración en /etc/httpd/conf.d/ssl.conf). Todos estos deben establecerse:
   SSLCertificateFile
   SSLCertificateKeyFile
   SSLCertificateChainFile
   SSLCACertificateFile

5. Reinicie httpd utilizando el sudo service httpd restart y asegúrese de que httpd started:
   Deteniendo httpd: [OK]
   Iniciando httpd: [OK]

6. Copie my-private-root-ca.cert en la carpeta de activos de proyectos de Android

7. Crea tu administrador de confianza:
   

   SSLContext SSLContext;

   CertificateFactory cf = CertificateFactory.getInstance ("X.509"); InputStream caInput = context.getAssets (). Open ("my-private-root-ca.cert.pem"); Certificado ca; 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);

8. Y haga la conexión usando HttpsURLConnection:

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

9. Eso es todo, pruebe su conexión https.

Answer 7

Hago esta clase y encontré

package com.example.fakessl;

import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;

import android.util.Log;

public class CertificadoAceptar {
    private static TrustManager[] trustManagers;

    public static class _FakeX509TrustManager implements
            javax.net.ssl.X509TrustManager {
        private static final X509Certificate[] _AcceptedIssuers = new X509Certificate[] {};

        public void checkClientTrusted(X509Certificate[] arg0, String arg1)
                throws CertificateException {
        }

        public void checkServerTrusted(X509Certificate[] arg0, String arg1)
                throws CertificateException {
        }

        public boolean isClientTrusted(X509Certificate[] chain) {
            return (true);
        }

        public boolean isServerTrusted(X509Certificate[] chain) {
            return (true);
        }

        public X509Certificate[] getAcceptedIssuers() {
            return (_AcceptedIssuers);
        }
    }

    public static void allowAllSSL() {

        javax.net.ssl.HttpsURLConnection
                .setDefaultHostnameVerifier(new HostnameVerifier() {
                    public boolean verify(String hostname, SSLSession session) {
                        return true;
                    }
                });

        javax.net.ssl.SSLContext context = null;

        if (trustManagers == null) {
            trustManagers = new javax.net.ssl.TrustManager[] { new _FakeX509TrustManager() };
        }

        try {
            context = javax.net.ssl.SSLContext.getInstance("TLS");
            context.init(null, trustManagers, new SecureRandom());
        } catch (NoSuchAlgorithmException e) {
            Log.e("allowAllSSL", e.toString());
        } catch (KeyManagementException e) {
            Log.e("allowAllSSL", e.toString());
        }
        javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(context
                .getSocketFactory());
    }
}

en tu código blanco esto

CertificadoAceptar ca = new CertificadoAceptar();
ca.allowAllSSL();
HttpsTransportSE Transport = new HttpsTransportSE("iphost or host name", 8080, "/WS/wsexample.asmx?WSDL", 30000);

Answer 8

Ninguno de estos funcionó para mí (agravado por el error Thawte también). Finalmente lo solucioné con la aceptación de SSL autofirmado en Android y el manejo de SSL personalizado dejó de funcionar en Android 2.2 FroYo

Answer 9

No conozco las especificaciones de Android para los certificados ssl, pero tendría sentido que Android no acepte un certificado ssl autofirmado de inmediato. Encontré esta publicación de foros de Android que parece estar abordando el mismo problema: http://androidforums.com/android-applications/950-imap-self-signed-ssl-certificates.html

Answer 10

Por alguna razón, la solución mencionada para httpClient anterior no funcionó para mí. Al final, pude hacer que funcione anulando correctamente el método al implementar la clase personalizada SSLSocketFactory.

@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();
}

Así es como funcionó perfectamente para mí. Puede ver la clase personalizada completa y la implementación en el siguiente hilo: http://blog.syedgakbar.com/2012/07/21/android-https-and-not-trusted-server-certificate-error/

Answer 11

Si está utilizando un certificado StartSSL o Thawte, fracasará para Froyo y versiones anteriores. Puede usar el repositorio CAcert de una versión más nueva en lugar de confiar en cada certificado.

Answer 12

Simplemente use este método como su HTTPClient:

public static  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();
    }
}

Answer 13

También puedes mirar el artículo de mi blog, muy similar a los crazybobs.

Esta solución tampoco compromete la verificación de certificados y explica cómo agregar los certificados de confianza en su propio almacén de claves.

http://blog.antoine.li/index.php/2010/10/android-trusting-ssl-certificates/

Answer 14

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

Cortesía de Maduranga

Al desarrollar una aplicación que usa https, su servidor de prueba no tiene un certificado SSL válido. O a veces el sitio web usa un certificado autofirmado o el sitio web usa un certificado SSL gratuito. Por lo tanto, si intenta conectarse al servidor utilizando Apache HttpClient , obtendrá una excepción que le informará que el "par no está autenticado". Aunque no es una buena práctica confiar en todos los certificados en un software de producción, es posible que deba hacerlo de acuerdo con la situación. Esta solución resuelve la excepción causada por "pares no autenticados".

Pero antes de ir a la solución, debo advertirle que esta no es una buena idea para una aplicación de producción. Esto violará el propósito de usar un certificado de seguridad. Entonces, a menos que tenga una buena razón o si está seguro de que esto no causará ningún problema, no use esta solución.

Normalmente creas un HttpClient como este.

HttpClient httpclient = new DefaultHttpClient();

Pero tienes que cambiar la forma en que creas el HttpClient.

Primero debe crear una clase que extienda 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();
    }
}

Luego crea un método como este.

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();
     }
}

Entonces puedes crear el HttpClient .

HttpClient httpclient = getNewHttpClient();

Si está intentando enviar una solicitud postal a una página de inicio de sesión, el resto del código sería así.

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();
}

Obtienes la página html en InputStream. Luego puede hacer lo que quiera con la página html devuelta.

Pero aquí enfrentarás un problema. Si desea administrar una sesión utilizando cookies, no podrá hacerlo con este método. Si desea obtener las cookies, tendrá que hacerlo a través de un navegador. Entonces solo usted recibirá las cookies.