找不到Android SSL连接的信任锚

我正在尝试连接到运行Godaddy 256位SSL证书的IIS6框，但出现错误：

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

一直试图确定是什么原因导致的，但现在还是空白。

这是我的联系方式：

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

@Chrispix的解决方案很危险！信任所有证书，任何人都可以在中间攻击中做人！只需将任何证书发送给客户端，它将接受它！

将您的证书添加到自定义信任管理器中，如本文中所述：通过HTTPS使用HttpClient信任所有证书

尽管使用自定义证书建立安全连接会有些复杂，但是它将为您带来想要的ssl加密安全性，而不会造成中间攻击的危险！

违背了公认的答案，你并不需要一个定制信任管理器，你需要修复服务器配置！

使用错误安装的dynadot / alphassl证书连接到Apache服务器时，我遇到了同样的问题。我正在使用HttpsUrlConnection（Java / Android）进行连接，该连接会抛出-

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

实际的问题是服务器配置错误-使用http://www.digicert.com/help/对其进行测试或类似方法进行，它甚至会告诉您解决方案：

“证书不是由受信任的权威机构签名的（通过Mozilla的根存储进行检查）。如果您是从受信任的权威机构购买的证书，则可能只需要安装一个或多个中间证书。请与您的证书提供商联系，以获取帮助。服务器平台。”

您还可以使用openssl检查证书：

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

您可能会看到：

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

并且，在输出的前面：

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`

证书链仅包含1个元素（您的证书）：

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

...但应将链中的签名授权机构引用回Android信任的签名机构（Verisign，GlobalSign等）：

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

用于配置服务器的说明（和中间证书）通常由颁发证书的机构提供，例如：http : //www.alphassl.com/support/install-root-certificate.html

安装了由证书颁发者提供的中间证书之后，使用HttpsUrlConnection进行连接时，我现在没有任何错误。

您可以在运行时信任特定证书。
只需从服务器下载它，放入资产并使用ssl-utils-android这样加载：

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

在上面的例子中我用OkHttpClient但SSLContext了Java，可以将其与任何客户端一起使用。

如果您有任何问题随时问。我是这个小图书馆的作者。

根据最新的Android文档更新（2017年3月）：

当您收到此类错误时：

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)

问题可能是以下之一：

1. 颁发服务器证书的CA未知
2. 服务器证书不是由CA签名的，而是自签名的
3. 服务器配置缺少中间CA

解决方案是教导HttpsURLConnection信任一组特定的CA。怎么样？请检查 https://developer.android.com/training/articles/security-ssl.html#CommonProblems

其他正在AsyncHTTPClient从com.loopj.android:android-async-http库中使用的人，请检查Setup AsyncHttpClient以使用HTTPS。

如果使用改造，则需要自定义OkHttpClient。

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

完整代码如下。

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

}

回复很旧的帖子。但这可能会帮助一些新手，如果以上方法都不可行。

说明：我知道没人要废话。而不是解决方案。但是，在一台服务器中，您试图将服务从本地计算机访问到不信任您计算机的远程计算机。您请求需要获得远程服务器的信任。

解决方案：以下解决方案假定您满足以下条件

1. 尝试从本地计算机访问远程api。
2. 您正在构建Android应用程序
3. 远程服务器受到代理过滤（您在浏览器设置中使用代理访问远程api服务，通常是登台服务器或开发服务器）
4. 您正在真实设备上进行测试

脚步：

您需要一个.keystore扩展文件来注册您的应用。如果您不知道如何创建.keystore文件，请执行以下操作：然后按照以下部分创建.keystore文件，否则请跳至下一部分对Apk文件进行签名

创建.keystore文件

打开Android Studio。单击顶部菜单生成>生成签名的APK。在下一个窗口中，单击创建新...按钮。在新窗口中，请在所有字段中输入数据。记住我建议的两个密码字段应该具有相同的密码；请勿使用其他密码；并记住最上方字段“ 密钥存储路径”中的保存路径。输入所有字段后，单击确定按钮。

签名apk文件

现在，您需要使用刚刚创建的.keystore文件构建一个已签名的应用程序。跟着这些步骤

1. Build> Clean Project，等到完成清理
2. 生成>生成签名的APK
3. 点击Choose existing...按钮
4. 在创建.keystore文件部分中选择我们刚刚创建的.keystore文件
5. 输入在“ 创建.keystore文件”部分中创建时创建的相同密码。为Key store password和使用相同的密码Key password字段。同时输入别名
6. 单击下一步按钮
7. 在下一个屏幕中；根据build.gradle文件中的设置可能有所不同，您需要选择Build Types和Flavors。
8. 对于Build Types选择release从下拉菜单中

9. 对于Flavors然而，它会在依赖于你的设置build.gradle文件。staging从此字段中选择。我在中使用了以下设置build.gradle，您可以使用与我相同的设置，但请确保将更applicationId改为包名

   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. 单击底部的两个Signature Versions复选框，然后单击Finish按钮。

差不多了：

所有的努力都完成了，现在是真理的运动。为了访问由代理备份的Staging服务器，您需要在实际测试的Android设备中进行一些设置。

Android设备中的代理设置：

1. 点击Android手机中的设置，然后点击wi-fi
2. 长按连接的wifi并选择 Modify network
3. Advanced options如果看不到该Proxy Hostname字段，请单击
4. 在Proxy Hostname输入中，您要连接的主机IP或名称。典型的登台服务器将被命名为stg.api.mygoodcompany.com
5. 对于端口，请输入四位数的端口号，例如 9502
6. 点击Save按钮

最后一站：

请记住，我们在“签署APK文件”部分生成了签署的apk文件。现在是时候安装该APK文件了。

1. 打开终端并更改为签名的apk文件夹
2. 将您的Android设备连接到计算机
3. 从Android设备中删除任何以前安装的apk文件
4. 跑 adb install name of the apk file
5. 如果由于某种原因上述命令返回adb command not found。输入完整路径为C:\Users\shah\AppData\Local\Android\sdk\platform-tools\adb.exe install name of the apk file

我希望这个问题可以解决。如果没有，请给我留言。

萨拉姆！

我收到的错误消息类似，但是原因是自签名证书已过期。当尝试使用openssl客户端时，它给了我从firefox检查证书对话框时被忽略的原因。

因此，通常，如果证书位于密钥库中，并且证书的证书为“ VALID”，则此错误将消失。

从Android客户端连接到Kurento服务器时，我遇到了同样的问题。Kurento服务器使用jks证书，因此我不得不将pem转换为它。作为转换的输入，我使用了cert.pem文件，它导致了此类错误。但是，如果使用fullchain.pem而不是cert.pem-一切正常。

使用https://www.ssllabs.com/ssltest/测试域。

Shihab Uddin在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)
        }
}

我遇到了同样的问题，我发现的是我提供的certificate .crt文件缺少中间证书。因此，我从服务器管理员那里询问了所有.crt文件，然后以相反的顺序对其进行了隐化处理。

例如 1. Root.crt 2. Inter.crt 3. myCrt.crt

在Windows中，我执行了复制Inter.crt + Root.crt newCertificate.crt

（这里我忽略了myCrt.crt）

然后，我通过inputstream将newCertificate.crt文件提供给代码。完成工作。

信任锚错误可能由于多种原因而发生。对我来说，只是我尝试访问https://example.com/而不是https://www.example.com/。

因此，您可能想在开始构建自己的信任管理器之前仔细检查您的URL（就像我一样）。

在姜饼手机中，Trust Anchor not found for Android SSL Connection即使我设置为依靠我的证书，也总是会收到此错误：。

这是我使用的代码（使用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 _ ⇒
        }
    }
}

这是连接代码：

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

基本上，我设置为信任我的自定义证书。如果失败，则禁用安全性。这不是最好的选择，但我知道使用过时的越野车的唯一选择。

此示例代码可以轻松转换为Java。

就我而言，这是在更新至Android 8.0之后发生的。Android设置为信任的自签名证书使用的是签名算法SHA1withRSA。使用签名算法SHA256withRSA切换到新证书可以解决此问题。

我知道您不需要信任所有证书，但就我而言，在某些调试环境中我遇到了问题，在这些调试环境中我们拥有自签名证书，因此我需要一个肮脏的解决方案。

我要做的就是更改 sslContext

mySSLContext.init(null, trustAllCerts, null); 

这样trustAllCerts创建的位置：

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

希望这会派上用场。

我遇到了类似的问题，并且完全排除了信任所有来源的策略。

我在这里分享我的解决方案应用于Kotlin中实现的应用程序

我首先建议您使用以下网站来获取有关证书及其有效性的信息

如果未在Android默认信任存储中显示为“接受的发行者”颁发者”，我们必须获取该证书并将其合并到应用程序中以创建自定义信任库

就我而言，理想的解决方案是创建一个高级信任管理器结合了自定义和Android默认信任存储

在这里，他展示了用于配置与Retrofit一起使用的OkHttpClient的高级代码。

override fun onBuildHttpClient(httpClientBuild: OkHttpClient.Builder) {

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

        printX509TrustManagerAcceptedIssuers(trustManagerWrapper)

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

    }

通过这种方式，我可以通过自签名证书与服务器通信，并通过受信任的认证实体发布的证书与其他服务器通信

就是这样，希望它能对某人有所帮助。

我知道这是一篇非常古老的文章，但是当我尝试解决我的信任锚问题时遇到了这篇文章。我已经发布了解决方法。如果您已经预安装了根CA，则需要向清单添加配置。

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

我也面临同样的问题。我只是将hhtps删除到http，例如

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

最后，我解决了这个问题。