Trust Trust non trovato per la connessione SSL Android

Sto cercando di connettermi a una scatola IIS6 che esegue un certificato SSL a 256 bit godaddy e sto ricevendo l'errore:

java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.

Ho cercato di determinare cosa potrebbe causare questo, ma disegnando spazi vuoti in questo momento.

Ecco come mi collego:

HttpsURLConnection conn;              
conn = (HttpsURLConnection) (new URL(mURL)).openConnection();
conn.setConnectTimeout(20000);
conn.setDoInput(true);
conn.setDoOutput(true);
conn.connect();
String tempString = toString(conn.getInputStream()); 

La soluzione di @Chrispix è pericolosa! Fidarsi di tutti i certificati consente a chiunque di fare un uomo nel mezzo dell'attacco! Basta inviare QUALSIASI certificato al cliente e lo accetterà!

Aggiungi i tuoi certificati a un gestore di fiducia personalizzato come descritto in questo post: Affidabilità di tutti i certificati tramite HttpClient su HTTPS

Sebbene sia un po 'più complesso stabilire una connessione sicura con un certificato personalizzato, ti porterà la sicurezza di crittografia SSL richiesta senza il pericolo dell'uomo nel mezzo dell'attacco!

Contrariamente alla risposta accettata , non è necessario un gestore fiducia personalizzato, è necessario correggere la configurazione del server!

Ho riscontrato lo stesso problema durante la connessione a un server Apache con un certificato dynadot / alphassl installato in modo errato. Mi sto collegando utilizzando HttpsUrlConnection (Java / Android), che stava lanciando -

javax.net.ssl.SSLHandshakeException: 
  java.security.cert.CertPathValidatorException: 
    Trust anchor for certification path not found.

Il vero problema è un'errata configurazione del server: provalo con http://www.digicert.com/help/ o simile e ti dirà anche la soluzione:

"Il certificato non è firmato da un'autorità fidata (verificando con il root store di Mozilla). Se hai acquistato il certificato da un'autorità fidata, probabilmente devi solo installare uno o più certificati intermedi . Contatta il tuo fornitore di certificati per assistenza facendo questo piattaforma server ".

Puoi anche controllare il certificato con openssl:

openssl s_client -debug -connect www.thedomaintocheck.com:443

Probabilmente vedrai:

Verify return code: 21 (unable to verify the first certificate)

e, prima nell'output:

depth=0 OU = Domain Control Validated, CN = www.thedomaintocheck.com
verify error:num=20:unable to get local issuer certificate
verify return:1
depth=0 OU = Domain Control Validated, CN = www.thedomaintocheck.com
verify error:num=27:certificate not trusted
verify return:1
depth=0 OU = Domain Control Validated, CN = www.thedomaintocheck.com
verify error:num=21:unable to verify the first certificate`

La catena di certificati conterrà solo 1 elemento (il tuo certificato):

Certificate chain
 0 s:/OU=Domain Control Validated/CN=www.thedomaintocheck.com
  i:/O=AlphaSSL/CN=AlphaSSL CA - G2

... ma dovrebbe fare riferimento alle autorità firmatarie di una catena a quelle ritenute affidabili da Android (Verisign, GlobalSign, ecc.):

Certificate chain
 0 s:/OU=Domain Control Validated/CN=www.thedomaintocheck.com
   i:/O=AlphaSSL/CN=AlphaSSL CA - G2
 1 s:/O=AlphaSSL/CN=AlphaSSL CA - G2
   i:/C=BE/O=GlobalSign nv-sa/OU=Root CA/CN=GlobalSign Root CA
 2 s:/C=BE/O=GlobalSign nv-sa/OU=Root CA/CN=GlobalSign Root CA
   i:/C=BE/O=GlobalSign nv-sa/OU=Root CA/CN=GlobalSign Root CA

Le istruzioni (e i certificati intermedi) per la configurazione del server sono generalmente fornite dall'autorità che ha emesso il certificato, ad esempio: http://www.alphassl.com/support/install-root-certificate.html

Dopo aver installato i certificati intermedi forniti dal mio emittente del certificato, ora non ho errori durante la connessione tramite HttpsUrlConnection.

Puoi affidarti a un certificato particolare in fase di esecuzione.
Basta scaricarlo dal server, inserire le risorse e caricare in questo modo usando ssl-utils-android :

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

Nell'esempio sopra ho usato OkHttpClientma SSLContextposso essere usato con qualsiasi client in Java.

Se avete domande non esitate a chiedere. Sono l'autore di questa piccola biblioteca.

Aggiornamento basato sull'ultima documentazione Android (marzo 2017):

Quando ricevi questo tipo di errore:

javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.
        at org.apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl.startHandshake(OpenSSLSocketImpl.java:374)
        at libcore.net.http.HttpConnection.setupSecureSocket(HttpConnection.java:209)
        at libcore.net.http.HttpsURLConnectionImpl$HttpsEngine.makeSslConnection(HttpsURLConnectionImpl.java:478)
        at libcore.net.http.HttpsURLConnectionImpl$HttpsEngine.connect(HttpsURLConnectionImpl.java:433)
        at libcore.net.http.HttpEngine.sendSocketRequest(HttpEngine.java:290)
        at libcore.net.http.HttpEngine.sendRequest(HttpEngine.java:240)
        at libcore.net.http.HttpURLConnectionImpl.getResponse(HttpURLConnectionImpl.java:282)
        at libcore.net.http.HttpURLConnectionImpl.getInputStream(HttpURLConnectionImpl.java:177)
        at libcore.net.http.HttpsURLConnectionImpl.getInputStream(HttpsURLConnectionImpl.java:271)

il problema potrebbe essere uno dei seguenti:

1. La CA che ha emesso il certificato del server era sconosciuta
2. Il certificato del server non è stato firmato da un'autorità di certificazione, ma è stato autofirmato
3. Nella configurazione del server manca una CA intermedia

La soluzione è insegnare HttpsURLConnectiona fidarsi di un insieme specifico di autorità di certificazione. Come? Si prega di controllare https://developer.android.com/training/articles/security-ssl.html#CommonProblems

Altri che stanno usando AsyncHTTPClientdalla com.loopj.android:android-async-httplibreria, controlla Setup AsyncHttpClient per usare HTTPS .

Se usi il retrofit, devi personalizzare OkHttpClient.

retrofit = new Retrofit.Builder()
                        .baseUrl(ApplicationData.FINAL_URL)
                        .client(getUnsafeOkHttpClient().build())
                        .addConverterFactory(GsonConverterFactory.create())
                        .build();

Il codice completo è come di seguito.

    public class RestAdapter {

    private static Retrofit retrofit = null;
    private static ApiInterface apiInterface;

    public static OkHttpClient.Builder getUnsafeOkHttpClient() {
        try {
            // Create a trust manager that does not validate certificate chains
            final TrustManager[] trustAllCerts = new TrustManager[]{
                    new X509TrustManager() {
                        @Override
                        public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
                        }

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

                        @Override
                        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                            return new java.security.cert.X509Certificate[]{};
                        }
                    }
            };

            // Install the all-trusting trust manager
            final SSLContext sslContext = SSLContext.getInstance("SSL");
            sslContext.init(null, trustAllCerts, new java.security.SecureRandom());

            // Create an ssl socket factory with our all-trusting manager
            final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

            OkHttpClient.Builder builder = new OkHttpClient.Builder();
            builder.sslSocketFactory(sslSocketFactory, (X509TrustManager) trustAllCerts[0]);
            builder.hostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            });
            return builder;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static ApiInterface getApiClient() {
        if (apiInterface == null) {

            try {
                retrofit = new Retrofit.Builder()
                        .baseUrl(ApplicationData.FINAL_URL)
                        .client(getUnsafeOkHttpClient().build())
                        .addConverterFactory(GsonConverterFactory.create())
                        .build();

            } catch (Exception e) {

                e.printStackTrace();
            }


            apiInterface = retrofit.create(ApiInterface.class);
        }
        return apiInterface;
    }

}

In risposta a post molto vecchio. Ma forse aiuterà alcuni novizi e se non di quanto sopra funziona.

Spiegazione: So che nessuno vuole schifo da spiegazione; piuttosto la soluzione. Ma in una riga, stai tentando di accedere a un servizio dal tuo computer locale a un computer remoto che non si fida del tuo computer. È necessario richiedere la fiducia dal server remoto.

Soluzione: la seguente soluzione presuppone che siano soddisfatte le seguenti condizioni

1. Prova di accedere a un'API remota dal tuo computer locale.
2. Stai creando un'applicazione per Android
3. Il tuo server remoto è sotto filtraggio proxy (usi il proxy nelle impostazioni del tuo browser per accedere al servizio API remoto, in genere un server di gestione temporanea o dev)
4. Stai testando su un dispositivo reale

passi:

È necessario un file di estensione .keystore per iscriversi all'app. Se non sai come creare il file .keystore; quindi segui la sezione seguente Crea file .keystore o salta altrimenti alla sezione successiva Firma file apk

Crea il file .keystore

Apri Android Studio. Fai clic sul menu principale Genera> Genera APK firmato. Nella finestra successiva fare clic sul Crea nuova ... pulsante. Nella nuova finestra, inserisci i dati in tutti i campi. Ricorda che i due campi Password che consiglio dovrebbero avere la stessa password; non usare password diverse; e anche ricordare il percorso di salvataggio in alto più campo percorso negozio Chiave: . Dopo aver inserito tutto il campo, fare clic sul pulsante OK.

Firma file apk

Ora devi creare un'app firmata con il file .keystore che hai appena creato. Segui questi passi

1. Build> Clean Project, attendi fino al termine della pulizia
2. Genera> Genera APK firmato
3. Fare clic sul Choose existing...pulsante
4. Selezionare il file .keystore abbiamo appena creato nel Crea .keystore file di sezione
5. Inserisci la stessa password che hai creato durante la creazione nella sezione Crea file .keystore . Usa la stessa password per Key store passworde Key passwordcampi. Inserisci anche l'alias
6. Fai clic sul pulsante Avanti
7. Nella schermata successiva; che potrebbe essere diverso in base alle tue impostazioni nei build.gradlefile, devi selezionare Build Typese Flavors.
8. Per la Build Typesscelta releasedal menu a discesa

9. Per Flavorstuttavia sarà dipende dalle impostazioni nel build.gradlefile. Scegli stagingda questo campo. Ho usato le seguenti impostazioni in build.gradle, puoi usare lo stesso del mio, ma assicurati di cambiare il applicationIdnome del tuo pacchetto

   productFlavors {
       staging {
           applicationId "com.yourapplication.package"
           manifestPlaceholders = [icon: "@drawable/ic_launcher"]
           buildConfigField "boolean", "CATALYST_DEBUG", "true"
           buildConfigField "boolean", "ALLOW_INVALID_CERTIFICATE", "true"
       }
       production {
           buildConfigField "boolean", "CATALYST_DEBUG", "false"
           buildConfigField "boolean", "ALLOW_INVALID_CERTIFICATE", "false"
       }
   }

10. Fai clic sulle due Signature Versionscaselle di controllo in basso e fai clic sul Finishpulsante.

Quasi lì:

Tutto il duro lavoro è fatto, ora il movimento della verità. Per accedere al server di staging di cui è stato eseguito il backup tramite proxy, è necessario effettuare alcune impostazioni nei dispositivi Android di test reali.

Impostazione proxy nel dispositivo Android:

1. Fai clic su Impostazione all'interno del telefono Android e quindi Wi-Fi
2. Premi a lungo sul wifi connesso e seleziona Modify network
3. Fai clic su Advanced optionsse non riesci a vedere il Proxy Hostnamecampo
4. Nella Proxy Hostnameinserire l'IP dell'host o il nome che si desidera collegare. Un tipico server di gestione temporanea verrà denominato comestg.api.mygoodcompany.com
5. Per la porta inserire ad esempio il numero di porta a quattro cifre 9502
6. Premi il Savepulsante

Un'ultima fermata:

Ricorda che abbiamo generato il file apk firmato nella sezione Firma file APK . Ora è il momento di installare quel file APK.

1. Apri un terminale e passa alla cartella del file apk firmata
2. Collega il tuo dispositivo Android al tuo computer
3. Rimuovi qualsiasi precedente file apk installato dal dispositivo Android
4. Correre adb install name of the apk file
5. Se per qualche motivo il comando sopra riportato ritorna con adb command not found. Immettere il percorso completo comeC:\Users\shah\AppData\Local\Android\sdk\platform-tools\adb.exe install name of the apk file

Spero che il problema possa essere risolto. In caso contrario, lasciami un commento.

Salam!

Il messaggio di errore che stavo ricevendo era simile ma il motivo era che il certificato autofirmato era scaduto. Quando è stato tentato il client openssl, mi ha dato il motivo che è stato trascurato quando stavo controllando la finestra di dialogo del certificato da Firefox.

Quindi, in generale, se il certificato è presente nel keystore e relativo "VALID", questo errore scompare.

Ho avuto lo stesso problema durante la connessione dal client Android al server Kurento. Il server Kurento usa i certificati jks, quindi ho dovuto convertire pem in esso. Come input per la conversione ho usato il file cert.pem e questo ha portato a tali errori. Ma se usi fullchain.pem invece di cert.pem , va tutto bene.

Utilizzare https://www.ssllabs.com/ssltest/ per testare un dominio.

La soluzione di Shihab Uddin a Kotlin.

import java.security.SecureRandom
import java.security.cert.X509Certificate
import javax.net.ssl.*
import javax.security.cert.CertificateException

companion object {

    private val gson: Gson
    private val retrofit: Retrofit

    init {

        val okHttpClient = getUnsafeOkHttpClient() // OkHttpClient().newBuilder()
            .build()

        gson = GsonBuilder().setLenient().create()

        retrofit = Retrofit.Builder()
            .baseUrl(BASE_URL)
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create(gson))
            .build()
    }

    private fun getUnsafeOkHttpClient(): OkHttpClient.Builder =
        try {
            // Create a trust manager that does not validate certificate chains
            val trustAllCerts: Array<TrustManager> = arrayOf(
                object : X509TrustManager {
                    @Throws(CertificateException::class)
                    override fun checkClientTrusted(chain: Array<X509Certificate?>?,
                                                    authType: String?) = Unit

                    @Throws(CertificateException::class)
                    override fun checkServerTrusted(chain: Array<X509Certificate?>?,
                                                    authType: String?) = Unit

                    override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
                }
            )
            // Install the all-trusting trust manager
            val sslContext: SSLContext = SSLContext.getInstance("SSL")
            sslContext.init(null, trustAllCerts, SecureRandom())
            // Create an ssl socket factory with our all-trusting manager
            val sslSocketFactory: SSLSocketFactory = sslContext.socketFactory
            val builder = OkHttpClient.Builder()
            builder.sslSocketFactory(sslSocketFactory,
                trustAllCerts[0] as X509TrustManager)
            builder.hostnameVerifier { _, _ -> true }
            builder
        } catch (e: Exception) {
            throw RuntimeException(e)
        }
}

Ho avuto lo stesso problema quello che ho scoperto è che il file .crt certificato che ho fornito mancava un certificato intermedio. Quindi ho chiesto a tutti i file .crt dal mio amministratore del server, quindi li ho concatenati in ordine inverso.

Ex. 1. Root.crt 2. Inter.crt 3. myCrt.crt

in Windows ho eseguito la copia Inter.crt + Root.crt newCertificate.crt

(Qui ho ignorato myCrt.crt)

Quindi ho fornito il file newCertificate.crt nel codice tramite inputstream. Lavoro fatto.

L'errore di ancoraggio Trust può verificarsi per molte ragioni. Per me era semplicemente che stavo cercando di accedere https://example.com/invece di https://www.example.com/.

Quindi potresti voler ricontrollare i tuoi URL prima di iniziare a costruire il tuo Trust Manager (come ho fatto io).

Nei telefoni Gingerbread, ottengo sempre questo errore:, Trust Anchor not found for Android SSL Connectionanche se ho impostato per fare affidamento sul mio certificato.

Ecco il codice che uso (in linguaggio Scala):

object Security {
    private def createCtxSsl(ctx: Context) = {
        val cer = {
            val is = ctx.getAssets.open("mycertificate.crt")
            try
                CertificateFactory.getInstance("X.509").generateCertificate(is)
            finally
                is.close()
        }
        val key = KeyStore.getInstance(KeyStore.getDefaultType)
        key.load(null, null)
        key.setCertificateEntry("ca", cer)

        val tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm)
    tmf.init(key)

        val c = SSLContext.getInstance("TLS")
        c.init(null, tmf.getTrustManagers, null)
        c
    }

    def prepare(url: HttpURLConnection)(implicit ctx: Context) {
        url match {
            case https: HttpsURLConnection ⇒
                val cSsl = ctxSsl match {
                    case None ⇒
                        val res = createCtxSsl(ctx)
                        ctxSsl = Some(res)
                        res
                    case Some(c) ⇒ c
                }
                https.setSSLSocketFactory(cSsl.getSocketFactory)
            case _ ⇒
        }
    }

    def noSecurity(url: HttpURLConnection) {
        url match {
            case https: HttpsURLConnection ⇒
                https.setHostnameVerifier(new HostnameVerifier {
                    override def verify(hostname: String, session: SSLSession) = true
                })
            case _ ⇒
        }
    }
}

ed ecco il codice di connessione:

def connect(securize: HttpURLConnection ⇒ Unit) {
    val conn = url.openConnection().asInstanceOf[HttpURLConnection]
    securize(conn)
    conn.connect();
    ....
}

try {
    connect(Security.prepare)
} catch {
    case ex: SSLHandshakeException /*if ex.getMessage != null && ex.getMessage.contains("Trust anchor for certification path not found")*/ ⇒
        connect(Security.noSecurity)
}

Fondamentalmente, ho impostato per fidarmi del mio certificato personalizzato. Se fallisce, disabilito la sicurezza. Questa non è l'opzione migliore, ma l'unica scelta che conosco con telefoni vecchi e buggy.

Questo codice di esempio può essere facilmente tradotto in Java.

Nel mio caso questo stava succedendo dopo l'aggiornamento ad Android 8.0. Il certificato autofirmato di cui Android era fidato stava usando l'algoritmo di firma SHA1 con RSA. Il passaggio a un nuovo certificato, utilizzando l'algoritmo di firma SHA256 con RSA ha risolto il problema.

So che non è necessario fidarsi di tutti i certificati, ma nel mio caso ho avuto problemi con alcuni ambienti di debug in cui avevamo certificati autofirmati e avevo bisogno di una soluzione sporca.

Tutto quello che dovevo fare era cambiare l'inizializzazione di sslContext

mySSLContext.init(null, trustAllCerts, null); 

dove è trustAllCertsstato creato in questo modo:

private final 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 {
    }
} };

Spero che questo possa tornare utile.

Ho avuto un problema simile e ho completamente escluso la strategia di fiducia in tutte le fonti.

Condivido qui la mia soluzione applicata a un'applicazione implementata in Kotlin

Per prima cosa consiglierei di utilizzare il seguente sito Web per ottenere informazioni sul certificato e sulla sua validità

Se non viene visualizzato come "Emittenti accettati" nel truststore predefinito di Android , dobbiamo ottenere quel certificato e incorporarlo nell'applicazione per creare un truststore personalizzato

La soluzione ideale nel mio caso era quella di creare un Trust Manager di alto livello che combina il truststore predefinito personalizzato e Android

Qui espone il codice di alto livello utilizzato per configurare OkHttpClient che ha usato con Retrofit.

override fun onBuildHttpClient(httpClientBuild: OkHttpClient.Builder) {

        val trustManagerWrapper = createX509TrustManagerWrapper(
            arrayOf(
                getCustomX509TrustManager(),
                getDefaultX509TrustManager()
            )
        )

        printX509TrustManagerAcceptedIssuers(trustManagerWrapper)

        val sslSocketFactory = createSocketFactory(trustManagerWrapper)
        httpClientBuild.sslSocketFactory(sslSocketFactory, trustManagerWrapper)

    }

In questo modo, potrei comunicare con il server con un certificato autofirmato e con altri server con un certificato emesso da un'entità di certificazione attendibile

Questo è, spero che possa aiutare qualcuno.

So che questo è un articolo molto vecchio, ma mi sono imbattuto in questo articolo quando ho cercato di risolvere i miei problemi di ancoraggio di fiducia. Ho pubblicato come l'ho risolto. Se è stata preinstallata la CA principale, è necessario aggiungere una configurazione al manifest.

https://stackoverflow.com/a/60102517/114265

**Set proper alias name**
CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509","BC");
            X509Certificate cert = (X509Certificate) certificateFactory.generateCertificate(derInputStream);
            String alias = cert.getSubjectX500Principal().getName();
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            trustStore.load(null);
trustStore.setCertificateEntry(alias, cert);

Ho anche affrontato lo stesso problema. Rimuovo semplicemente hhtps su http, come ad esempio

final public static String ROOT_URL = "https://example.com"; per final public static String ROOT_URL = "http://example.com";

Infine, ho risolto questo problema.