akceptowanie połączeń HTTPS z certyfikatami podpisanymi samodzielnie

Aby uzyskać bezpieczne połączenie z organami certyfikującymi, które nie są uznawane za zaufane przez platformę android, wymagane są następujące główne kroki:

Zgodnie z życzeniem wielu użytkowników, przejrzałem najważniejsze części z mojego artykułu na blogu tutaj:

1. Pobierz wszystkie wymagane certyfikaty (root i wszelkie pośrednie CA)
Tworzenie keystore za pomocą keytool i dostawcy BouncyCastle i importowanie certów
2. załaduj keystore w aplikacji na Androida i używaj go do zabezpieczonych połączeń (zalecam użycie Apache HttpClient zamiast standardowego java.net.ssl.HttpsURLConnection (łatwiejsze do zrozumienia, bardziej wydajne)

Chwyć Cert

Musisz uzyskać wszystkie certyfikaty, które budują łańcuch od certyfikatu punktu końcowego aż do głównego CA. Oznacza to, że każdy (jeśli występuje) pośredni CERT CA, a także rdzeń cert ca. Nie musisz uzyskiwać punktu końcowego certyfikat.

Utwórz keystore

Pobierz dostawcę BouncyCastle i przechowaj go w znanej lokalizacji. Upewnij się również, że możesz wywołać polecenie keytool (zwykle znajdujące się w folderze bin instalacji JRE).

Teraz Importuj uzyskane certy (nie Importuj Cert punktu końcowego) do sformatowanego w BouncyCastle keystore.

Nie testowałem tego, ale myślę, że kolejność importowania certyfikatów jest ważna. Oznacza to, że importować najniższe Najpierw pośredni certyfikat CA, a następnie aż do głównego certyfikatu CA.

Za pomocą następującego polecenia zostanie utworzony nowy keystore (jeśli nie jest już obecny) z hasłem mysecret i zaimportowany zostanie pośredni certyfikat CA. Zdefiniowałem również dostawcę BouncyCastle, gdzie można go znaleźć w moim systemie plików i formacie keystore. Wykonaj to polecenie dla każdego certyfikatu w łańcuchu.

keytool -importcert -v -trustcacerts -file "path_to_cert/interm_ca.cer" -alias IntermediateCA -keystore "res/raw/myKeystore.bks" -provider org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath "path_to_bouncycastle/bcprov-jdk16-145.jar" -storetype BKS -storepass mysecret

Sprawdź, czy certyfikaty zostały zaimportowane poprawnie w keystore:

keytool -list -keystore "res/raw/myKeystore.bks" -provider org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath "path_to_bouncycastle/bcprov-jdk16-145.jar" -storetype BKS -storepass mysecret

Powinien wypisać cały łańcuch:

RootCA, 22.10.2010, trustedCertEntry, Thumbprint (MD5): 24:77:D9:A8:91:D1:3B:FA:88:2D:C2:FF:F8:CD:33:93
IntermediateCA, 22.10.2010, trustedCertEntry, Thumbprint (MD5): 98:0F:C3:F8:39:F7:D8:05:07:02:0D:E3:14:5B:29:43

Teraz możesz skopiować keystore jako surowy zasób w aplikacji na Androida Pod res/raw/

Użyj keystore w aplikacji

Przede wszystkim musimy utworzyć klienta Apache HttpClient, który używa naszego keystore dla połączeń HTTPS:

public class MyHttpClient extends DefaultHttpClient {

  final Context context;

  public MyHttpClient(Context context) {
      this.context = context;
  }

  @Override
  protected ClientConnectionManager createClientConnectionManager() {
      SchemeRegistry registry = new SchemeRegistry();
      registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
      // Register for port 443 our SSLSocketFactory with our keystore
      // to the ConnectionManager
      registry.register(new Scheme("https", newSslSocketFactory(), 443));
      return new SingleClientConnManager(getParams(), registry);
  }

  private SSLSocketFactory newSslSocketFactory() {
      try {
          // Get an instance of the Bouncy Castle KeyStore format
          KeyStore trusted = KeyStore.getInstance("BKS");
          // Get the raw resource, which contains the keystore with
          // your trusted certificates (root and any intermediate certs)
          InputStream in = context.getResources().openRawResource(R.raw.mykeystore);
          try {
              // Initialize the keystore with the provided trusted certificates
              // Also provide the password of the keystore
              trusted.load(in, "mysecret".toCharArray());
          } finally {
              in.close();
          }
          // Pass the keystore to the SSLSocketFactory. The factory is responsible
          // for the verification of the server certificate.
          SSLSocketFactory sf = new SSLSocketFactory(trusted);
          // Hostname verification from certificate
          // http://hc.apache.org/httpcomponents-client-ga/tutorial/html/connmgmt.html#d4e506
          sf.setHostnameVerifier(SSLSocketFactory.STRICT_HOSTNAME_VERIFIER);
          return sf;
      } catch (Exception e) {
          throw new AssertionError(e);
      }
  }
}

Stworzyliśmy nasz Niestandardowy HttpClient, teraz możemy go używać do bezpiecznych połączeń. Na przykład, gdy wykonujemy wezwanie do odpoczynku zasoby.

// Instantiate the custom HttpClient
DefaultHttpClient client = new MyHttpClient(getApplicationContext());
HttpGet get = new HttpGet("https://www.mydomain.ch/rest/contacts/23");
// Execute the GET call and obtain the response
HttpResponse getResponse = client.execute(get);
HttpEntity responseEntity = getResponse.getEntity();

To jest to;)

Jeśli masz własny certyfikat na serwerze, którego nie ma na urządzeniu, możesz użyć poniższej klasy, aby go załadować i użyć po stronie klienta w Androidzie:

Umieść plik certyfikatu *.crt w /res/raw tak, aby był dostępny z R.raw.*

Użyj poniższej klasy, aby uzyskać HTTPClient lub HttpsURLConnection, które będą miały fabrykę gniazd używającą tego certyfikatu:

package com.example.customssl;

import android.content.Context;
import org.apache.http.client.HttpClient;
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.AllowAllHostnameVerifier;
import org.apache.http.conn.ssl.SSLSocketFactory;
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.HttpParams;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;

public class CustomCAHttpsProvider {

    /**
     * Creates a {@link org.apache.http.client.HttpClient} which is configured to work with a custom authority
     * certificate.
     *
     * @param context       Application Context
     * @param certRawResId  R.raw.id of certificate file (*.crt). Should be stored in /res/raw.
     * @param allowAllHosts If true then client will not check server against host names of certificate.
     * @return Http Client.
     * @throws Exception If there is an error initializing the client.
     */
    public static HttpClient getHttpClient(Context context, int certRawResId, boolean allowAllHosts) throws Exception {


        // build key store with ca certificate
        KeyStore keyStore = buildKeyStore(context, certRawResId);

        // init ssl socket factory with key store
        SSLSocketFactory sslSocketFactory = new SSLSocketFactory(keyStore);

        // skip hostname security check if specified
        if (allowAllHosts) {
            sslSocketFactory.setHostnameVerifier(new AllowAllHostnameVerifier());
        }

        // basic http params for client
        HttpParams params = new BasicHttpParams();

        // normal scheme registry with our ssl socket factory for "https"
        SchemeRegistry schemeRegistry = new SchemeRegistry();
        schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
        schemeRegistry.register(new Scheme("https", sslSocketFactory, 443));

        // create connection manager
        ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);

        // create http client
        return new DefaultHttpClient(cm, params);
    }

    /**
     * Creates a {@link javax.net.ssl.HttpsURLConnection} which is configured to work with a custom authority
     * certificate.
     *
     * @param urlString     remote url string.
     * @param context       Application Context
     * @param certRawResId  R.raw.id of certificate file (*.crt). Should be stored in /res/raw.
     * @param allowAllHosts If true then client will not check server against host names of certificate.
     * @return Http url connection.
     * @throws Exception If there is an error initializing the connection.
     */
    public static HttpsURLConnection getHttpsUrlConnection(String urlString, Context context, int certRawResId,
                                                           boolean allowAllHosts) throws Exception {

        // build key store with ca certificate
        KeyStore keyStore = buildKeyStore(context, certRawResId);

        // 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 = SSLContext.getInstance("TLS");
        sslContext.init(null, tmf.getTrustManagers(), null);

        // Create a connection from url
        URL url = new URL(urlString);
        HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
        urlConnection.setSSLSocketFactory(sslContext.getSocketFactory());

        // skip hostname security check if specified
        if (allowAllHosts) {
            urlConnection.setHostnameVerifier(new AllowAllHostnameVerifier());
        }

        return urlConnection;
    }

    private static KeyStore buildKeyStore(Context context, int certRawResId) throws KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException {
        // init a default key store
        String keyStoreType = KeyStore.getDefaultType();
        KeyStore keyStore = KeyStore.getInstance(keyStoreType);
        keyStore.load(null, null);

        // read and add certificate authority
        Certificate cert = readCert(context, certRawResId);
        keyStore.setCertificateEntry("ca", cert);

        return keyStore;
    }

    private static Certificate readCert(Context context, int certResourceId) throws CertificateException, IOException {

        // read certificate resource
        InputStream caInput = context.getResources().openRawResource(certResourceId);

        Certificate ca;
        try {
            // generate a certificate
            CertificateFactory cf = CertificateFactory.getInstance("X.509");
            ca = cf.generateCertificate(caInput);
        } finally {
            caInput.close();
        }

        return ca;
    }

}

Kluczowe punkty:

1. Certificate obiekty są generowane z plików .crt.
2. a default KeyStore jest tworzony.
3. keyStore.setCertificateEntry("ca", cert) dodaje certyfikat do magazynu kluczy pod aliasem "ca". Modyfikujesz kod, aby dodać więcej certyfikatów (pośredni CA itp.).
4. głównym celem jest wygenerowanie SSLSocketFactory, który może być następnie użyty przez HTTPClient lub HttpsURLConnection.
5. SSLSocketFactory można skonfigurować dalej, na przykład, aby pominąć weryfikację nazwy hosta itp.

Więcej informacji na stronie: http://developer.android.com/training/articles/security-ssl.html

Byłem sfrustrowany, próbując połączyć moją aplikację na Androida z moją usługą RESTful za pomocą https. Byłem też nieco zirytowany wszystkimi odpowiedziami, które sugerowały całkowite wyłączenie sprawdzania certyfikatów. Jeśli to zrobisz, jaki jest sens https?

Po wygooglowaniu tematu przez chwilę, w końcu znalazłem to rozwiązanie, w którym zewnętrzne słoiki nie są potrzebne, tylko API Androida. Podziękowania dla Andrew Smitha, który opublikował go w lipcu 2014

 /**
 * Set up a connection to myservice.domain using HTTPS. An entire function
 * is needed to do this because myservice.domain has a self-signed certificate.
 * 
 * The caller of the function would do something like:
 * HttpsURLConnection urlConnection = setUpHttpsConnection("https://littlesvr.ca");
 * InputStream in = urlConnection.getInputStream();
 * And read from that "in" as usual in Java
 * 
 * Based on code from:
 * https://developer.android.com/training/articles/security-ssl.html#SelfSigned
 */
public static HttpsURLConnection setUpHttpsConnection(String urlString)
{
    try
    {
        // Load CAs from an InputStream
        // (could be from a resource or ByteArrayInputStream or ...)
        CertificateFactory cf = CertificateFactory.getInstance("X.509");

        // My CRT file that I put in the assets folder
        // I got this file by following these steps:
        // * Go to https://littlesvr.ca using Firefox
        // * Click the padlock/More/Security/View Certificate/Details/Export
        // * Saved the file as littlesvr.crt (type X.509 Certificate (PEM))
        // The MainActivity.context is declared as:
        // public static Context context;
        // And initialized in MainActivity.onCreate() as:
        // MainActivity.context = getApplicationContext();
        InputStream caInput = new BufferedInputStream(MainActivity.context.getAssets().open("littlesvr.crt"));
        Certificate ca = cf.generateCertificate(caInput);
        System.out.println("ca=" + ((X509Certificate) ca).getSubjectDN());

        // 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 context = SSLContext.getInstance("TLS");
        context.init(null, tmf.getTrustManagers(), null);

        // Tell the URLConnection to use a SocketFactory from our SSLContext
        URL url = new URL(urlString);
        HttpsURLConnection urlConnection = (HttpsURLConnection)url.openConnection();
        urlConnection.setSSLSocketFactory(context.getSocketFactory());

        return urlConnection;
    }
    catch (Exception ex)
    {
        Log.e(TAG, "Failed to establish SSL connection to server: " + ex.toString());
        return null;
    }
}

To działało dobrze dla mojej aplikacji makiety.

Najlepsza odpowiedź nie zadziałała dla mnie. Po pewnym dochodzeniu znalazłem wymagane informacje na " Android Developer": https://developer.android.com/training/articles/security-ssl.html#SelfSigned

Tworzenie pustej implementacji X509TrustManager ' a załatwiło sprawę:

private static class MyTrustManager implements X509TrustManager
{

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

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

    @Override
    public X509Certificate[] getAcceptedIssuers()
    {
        return null;
    }

}

...

HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
try
{
    // Create an SSLContext that uses our TrustManager
    SSLContext context = SSLContext.getInstance("TLS");
    TrustManager[] tmlist = {new MyTrustManager()};
    context.init(null, tmlist, null);
    conn.setSSLSocketFactory(context.getSocketFactory());
}
catch (NoSuchAlgorithmException e)
{
    throw new IOException(e);
} catch (KeyManagementException e)
{
    throw new IOException(e);
}
conn.setRequestMethod("GET");
int rcode = conn.getResponseCode();

Należy pamiętać, że ta pusta implementacja TustManager jest tylko przykładem i używanie jej w produktywnym środowisku spowodowałoby poważne zagrożenie bezpieczeństwa!

Oto jak można dodać dodatkowe certyfikaty do magazynu kluczy, aby uniknąć tego problemu: ufanie wszystkim certyfikatom za pomocą HttpClient przez HTTPS

Nie zapyta użytkownika tak, jak pytasz, ale zmniejszy prawdopodobieństwo wystąpienia błędu "certyfikat serwera nie zaufanego".

Google zaleca użycie Androida do połączeń HTTP / HTTPS , ponieważ HttpClient jest przestarzałe. Więc znasz właściwy wybór :).

A także nigdy nie Nuke certyfikatów SSL (nigdy!!!).

Aby Nuke certyfikaty SSL, jest całkowicie sprzeczne z celem SSL, który jest promowanie bezpieczeństwo . Nie ma sensu używać SSL, jeśli planujesz zbombardować wszystkie dostarczane certyfikaty SSL. Lepszym rozwiązaniem byłoby nie używanie SSL, albo lepsze rozwiązaniem byłoby utworzenie niestandardowego TrustManager w Twojej aplikacji + za pomocą Androida dla połączeń HTTP / HTTPS.

Oto Gist , który stworzyłem, z podstawową aplikacją LoginApp, wykonującą połączenia HTTPS, używając certyfikatu podpisanego samodzielnie po stronie serwera, akceptowanego w aplikacji.

Oto również inny Gist , który może pomóc w tworzeniu certyfikatów SSL z podpisem własnym do konfiguracji na serwerze, a także przy użyciu certyfikatu w aplikacji. bardzo ważne: musisz przyjąłem .plik crt, który został wygenerowany przez powyższy skrypt, do katalogu " raw " z twojego projektu Android.

Napisałem małą bibliotekę ssl-utils-android , aby zaufać konkretnemu certyfikatowi na Androidzie.

Możesz po prostu załadować dowolny certyfikat, podając nazwę pliku z katalogu zasobów.

Użycie:

OkHttpClient client = new OkHttpClient();
SSLContext sslContext = SslUtils.getSslContextForCertificateFile(context, "BPClass2RootCA-sha2.cer");
client.setSslSocketFactory(sslContext.getSocketFactory());

Żadna z tych poprawek nie działała dla mojej platformy programistycznej targetującej SDK 16, w wersji 4.1.2, więc znalazłem obejście.

Moja aplikacja przechowuje dane na serwerze za pomocą " http://www.example.com/page.php?data=somedata "

Ostatnio strona.php zostało przeniesione do " https://www.secure-example.com/page.php "i ciągle dostaję" javax.net.ssl.SSLException: not trusted server certificate".

Zamiast akceptować wszystkie certyfikaty tylko dla jednej strony, zaczynając od tego poradnik rozwiązałem swój problem pisząc własną stronę.PHP opublikowane na " http://www.example.com/page.php "

<?php

caronte ("https://www.secure-example.com/page.php");

function caronte($url) {
    // build curl request
    $ch = curl_init();
    foreach ($_POST as $a => $b) {
        $post[htmlentities($a)]=htmlentities($b);
    }
    curl_setopt($ch, CURLOPT_URL,$url);
    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_POSTFIELDS,http_build_query($post));

    // receive server response ...
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $server_output = curl_exec ($ch);
    curl_close ($ch);

    echo $server_output;
}

?>

Może to pomoże... działa na klientach java używając certyfikatów z własnym podpisem (nie ma sprawdzania certyfikatu). Bądź ostrożny i używaj go tylko w przypadku rozwoju, ponieważ nie jest to w ogóle bezpieczne!!

Jak zignorować błędy certyfikatu SSL w Apache HttpClient 4.0

Mam nadzieję, że będzie działać na Androidzie, dodając bibliotekę HttpClient... powodzenia!!

Jest to problem wynikający z braku wsparcia sni (Server Name Identification) inA,ndroid 2.x. zmagałem się z tym problemem przez tydzień, dopóki nie natknąłem się na następujące pytanie, które nie tylko daje dobre tło problemu, ale także zapewnia działające i skuteczne rozwiązanie pozbawione jakichkolwiek luk w zabezpieczeniach.

'No peer certificate' error in Android 2.3 but NOT in 4

Najprostszy sposób tworzenia certyfikatu SSL

Open Firefox (przypuszczam, że jest to możliwe również z Chrome, ale dla mnie łatwiej jest z FF)

Odwiedź witrynę programistyczną z własnoręcznie podpisanym certyfikatem SSL.

Kliknij na certyfikat (obok nazwy strony)

Kliknij "Więcej informacji"

Kliknij na "Zobacz certyfikat"

Kliknij "Szczegóły"

Kliknij " Eksportuj..."

Wybierz " X. 509 Certificate whith chain (PEM)", wybierz folder i nazwa, aby go zapisać i kliknij "Zapisz"

Przejdź do wiersza poleceń, do katalogu, w którym pobrano plik pem i wykonaj " openssl x509-inform PEM-outform DM-in .pem-out .crt "

Kopiuj .plik crt do katalogu głównego folderu / sdcard wewnątrz urządzenia z systemem Android Wewnątrz urządzenia z Androidem, Ustawienia > Zabezpieczenia > Zainstaluj z pamięci.

Powinien wykryć certyfikat i pozwolić na dodanie go do urządzenia Przejdź do witryny deweloperskiej.

Pierwszy raz należy poprosić o potwierdzenie wyjątku bezpieczeństwa. To wszystko.

Certyfikat powinien działać z dowolną przeglądarką zainstalowaną na Twoim Androidzie (Browser, Chrome, Opera, Dolphin...)

Pamiętaj, że jeśli obsługujesz pliki statyczne z innej domeny (wszyscy jesteśmy bitches page speed), musisz również dodać certyfikat dla tej domeny.