“PKIX 경로 구축 실패”및“요청한 대상에 대한 유효한 인증 경로를 찾을 수 없습니다”

내 Java 프로젝트에 twitter4j 라이브러리를 사용하여 트윗을 얻으려고합니다 . 첫 번째 실행에서 인증서 sun.security.validator.ValidatorException및에 대한 오류가 발생했습니다 sun.security.provider.certpath.SunCertPathBuilderException. 그런 다음 트위터 인증서를 다음과 같이 추가했습니다.

C:\Program Files\Java\jdk1.7.0_45\jre\lib\security>keytool -importcert -trustcacerts -file PathToCert -alias ca_alias -keystore "C:\Program Files\Java\jdk1.7.0_45\jre\lib\security\cacerts"

그러나 성공하지 못했습니다. 트윗을 얻는 절차는 다음과 같습니다.

public static void main(String[] args) throws TwitterException {
    ConfigurationBuilder cb = new ConfigurationBuilder();
    cb.setDebugEnabled(true)
        .setOAuthConsumerKey("myConsumerKey")
        .setOAuthConsumerSecret("myConsumerSecret")
        .setOAuthAccessToken("myAccessToken")
        .setOAuthAccessTokenSecret("myAccessTokenSecret");

    TwitterFactory tf = new TwitterFactory(cb.build());
    Twitter twitter = tf.getInstance();

    try {
        Query query = new Query("iphone");
        QueryResult result;
        result = twitter.search(query);
        System.out.println("Total amount of tweets: " + result.getTweets().size());
        List<Status> tweets = result.getTweets();

        for (Status tweet : tweets) {
            System.out.println("@" + tweet.getUser().getScreenName() + " : " + tweet.getText());
        }
    } catch (TwitterException te) {
        te.printStackTrace();
        System.out.println("Failed to search tweets: " + te.getMessage());
    }

그리고 여기 오류가 있습니다 :

sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
Relevant discussions can be found on the Internet at:
    http://www.google.co.jp/search?q=d35baff5 or
    http://www.google.co.jp/search?q=1446302e
TwitterException{exceptionCode=[d35baff5-1446302e 43208640-747fd158 43208640-747fd158 43208640-747fd158], statusCode=-1, message=null, code=-1, retryAfter=-1, rateLimitStatus=null, version=3.0.5}
    at twitter4j.internal.http.HttpClientImpl.request(HttpClientImpl.java:177)
    at twitter4j.internal.http.HttpClientWrapper.request(HttpClientWrapper.java:61)
    at twitter4j.internal.http.HttpClientWrapper.get(HttpClientWrapper.java:81)
    at twitter4j.TwitterImpl.get(TwitterImpl.java:1929)
    at twitter4j.TwitterImpl.search(TwitterImpl.java:306)
    at jku.cc.servlets.TweetsAnalyzer.main(TweetsAnalyzer.java:38)
Caused by: javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
    at sun.security.ssl.Alerts.getSSLException(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.fatal(Unknown Source)
    at sun.security.ssl.Handshaker.fatalSE(Unknown Source)
    at sun.security.ssl.Handshaker.fatalSE(Unknown Source)
    at sun.security.ssl.ClientHandshaker.serverCertificate(Unknown Source)
    at sun.security.ssl.ClientHandshaker.processMessage(Unknown Source)
    at sun.security.ssl.Handshaker.processLoop(Unknown Source)
    at sun.security.ssl.Handshaker.process_record(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.readRecord(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.performInitialHandshake(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.startHandshake(Unknown Source)
    at sun.security.ssl.SSLSocketImpl.startHandshake(Unknown Source)
    at sun.net.www.protocol.https.HttpsClient.afterConnect(Unknown Source)
    at sun.net.www.protocol.https.AbstractDelegateHttpsURLConnection.connect(Unknown Source)
    at sun.net.www.protocol.http.HttpURLConnection.getInputStream(Unknown Source)
    at java.net.HttpURLConnection.getResponseCode(Unknown Source)
    at sun.net.www.protocol.https.HttpsURLConnectionImpl.getResponseCode(Unknown Source)
    at twitter4j.internal.http.HttpResponseImpl.<init>(HttpResponseImpl.java:34)
    at twitter4j.internal.http.HttpClientImpl.request(HttpClientImpl.java:141)
    ... 5 more
Caused by: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
    at sun.security.validator.PKIXValidator.doBuild(Unknown Source)
    at sun.security.validator.PKIXValidator.engineValidate(Unknown Source)
    at sun.security.validator.Validator.validate(Unknown Source)
    at sun.security.ssl.X509TrustManagerImpl.validate(Unknown Source)
    at sun.security.ssl.X509TrustManagerImpl.checkTrusted(Unknown Source)
    at sun.security.ssl.X509TrustManagerImpl.checkServerTrusted(Unknown Source)
    ... 20 more
Caused by: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
    at sun.security.provider.certpath.SunCertPathBuilder.engineBuild(Unknown Source)
    at java.security.cert.CertPathBuilder.build(Unknown Source)
    ... 26 more
Failed to search tweets: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

1. 브라우저에서 URL로 이동하십시오.
   • firefox-HTTPS 인증서 체인 (URL 주소 옆의 잠금 아이콘)을 클릭하십시오. 를 클릭하십시오 "more info" > "security" > "show certificate" > "details" > "export..". 이름을 들고 파일 유형을 선택하십시오.
   • 크롬-주소 표시 줄에 주소를 지정하려면 왼쪽에있는 사이트 아이콘을 클릭하고 "인증서"-> "세부 사항"-> "내보내기"를 선택하고 "Der-encoded binary, single certificate"형식으로 저장하십시오.

2. 이제 키 저장소가있는 파일이 있으며이를 JVM에 추가해야합니다. cacerts 파일의 위치를 ​​결정하십시오 (예 : C:\Program Files (x86)\Java\jre1.6.0_22\lib\security\cacerts.

3. 다음 example.cer명령 행에서 파일을 cacerts로 가져 오십시오 .

keytool -import -alias example -keystore C:\Program Files (x86)\Java\jre1.6.0_22\lib\security\cacerts -file example.cer

당신은 기본 암호를 묻는 메시지가 나타납니다 changeit

JVM / PC를 다시 시작하십시오.

출처 : http://magicmonster.com/kb/prg/java/ssl/pkix_path_building_failed.html

Java 6 설치가 새 트위터 인증서와 함께 작동하도록 인증서 파일을 작성하려고 여러 시간을 보낸 후 마침내 메시지 보드 중 하나의 주석에 묻힌 매우 간단한 솔루션을 발견했습니다. Java 7 설치에서 cacerts 파일을 복사하고 Java 6 설치에서 cacerts 파일을 덮어 쓰십시오. cacerts 파일을 먼저 백업하는 것이 가장 좋지만 새 파일을 BOOM에 복사하면됩니다. 그냥 작동합니다.

실제로 Windows cacerts 파일을 Linux 설치에 복사했으며 정상적으로 작동했습니다.

파일은 jre/lib/security/cacerts이전 및 새 Java jdk 설치 모두에 있습니다.

이로 인해 다른 사람이 몇 시간 동안 악화 될 수 있기를 바랍니다.

내 UI 접근 방식 :

1. 여기 에서 키 스토어 탐색기를 다운로드 하십시오
2. $ JAVA_HOME / jre / lib / security / cacerts를여십시오.
3. PW 입력 : changeit (Mac에서는 changeme 가능)
4. .crt 파일 가져 오기

CMD 라인 :

1. keytool -importcert -file jetty.crt -alias jetty -keystore $JAVA_HOME/jre/lib/security/cacerts
2. PW 입력 : changeit(Mac에서는 changeme 가능)

나는 공식 인증서와 달리 자동 생성 된 인증서를 사용하여 수정하는 데 많은 시간이 걸리는이 문제를 우연히 발견했습니다. 공식 인증서와 달리 상당히 까다 롭고 Java는 그렇게 많이 좋아하지 않습니다.

다음 링크를 확인하십시오. Java 인증서 문제 해결

기본적으로 서버에서 Java Home 인증서로 인증서를 추가해야합니다.

1. 인증서 생성 또는 가져 오기 및 Servers.xml에서 인증서를 사용하도록 Tomcat 구성
2. 클래스의 Java 소스 코드를 다운로드하여 InstallCert서버가 실행되는 동안 실행하여 다음 인수를 제공하십시오 server[:port]. 원래 비밀번호가 Java 인증서 ( "changeit")에 대해 작동하므로 비밀번호가 필요하지 않습니다.
3. 본 프로그램은 서버에 연결되며 Java는 예외를 처리하며, 서버가 제공 한 인증서를 분석 jssecerts하고 프로그램을 실행 한 디렉토리 내에 파일 을 작성할 수 있도록합니다 (Eclipse에서 실행 된 경우 작업을 구성해야합니다) 에 디렉토리 Run -> Configurations).
4. 해당 파일을 수동으로 복사 $JAVA_HOME/jre/lib/security

이 단계를 수행 한 후에는 인증서와의 연결로 Java 내에서 더 이상 예외가 생성되지 않습니다.

다음 소스 코드는 중요하며 (Sun) Oracle 블로그에서 사라졌으며 제공된 링크에있는 유일한 페이지이므로 참조를 위해 답변에 첨부했습니다.

/*
 * Copyright 2006 Sun Microsystems, Inc.  All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Sun Microsystems nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/**
 * Originally from:
 * http://blogs.sun.com/andreas/resource/InstallCert.java
 * Use:
 * java InstallCert hostname
 * Example:
 *% java InstallCert ecc.fedora.redhat.com
 */

import javax.net.ssl.*;
import java.io.*;
import java.security.KeyStore;
import java.security.MessageDigest;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

/**
 * Class used to add the server's certificate to the KeyStore
 * with your trusted certificates.
 */
public class InstallCert {

    public static void main(String[] args) throws Exception {
        String host;
        int port;
        char[] passphrase;
        if ((args.length == 1) || (args.length == 2)) {
            String[] c = args[0].split(":");
            host = c[0];
            port = (c.length == 1) ? 443 : Integer.parseInt(c[1]);
            String p = (args.length == 1) ? "changeit" : args[1];
            passphrase = p.toCharArray();
        } else {
            System.out.println("Usage: java InstallCert [:port] [passphrase]");
            return;
        }

        File file = new File("jssecacerts");
        if (file.isFile() == false) {
            char SEP = File.separatorChar;
            File dir = new File(System.getProperty("java.home") + SEP
                    + "lib" + SEP + "security");
            file = new File(dir, "jssecacerts");
            if (file.isFile() == false) {
                file = new File(dir, "cacerts");
            }
        }
        System.out.println("Loading KeyStore " + file + "...");
        InputStream in = new FileInputStream(file);
        KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
        ks.load(in, passphrase);
        in.close();

        SSLContext context = SSLContext.getInstance("TLS");
        TrustManagerFactory tmf =
                TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        X509TrustManager defaultTrustManager = (X509TrustManager) tmf.getTrustManagers()[0];
        SavingTrustManager tm = new SavingTrustManager(defaultTrustManager);
        context.init(null, new TrustManager[]{tm}, null);
        SSLSocketFactory factory = context.getSocketFactory();

        System.out.println("Opening connection to " + host + ":" + port + "...");
        SSLSocket socket = (SSLSocket) factory.createSocket(host, port);
        socket.setSoTimeout(10000);
        try {
            System.out.println("Starting SSL handshake...");
            socket.startHandshake();
            socket.close();
            System.out.println();
            System.out.println("No errors, certificate is already trusted");
        } catch (SSLException e) {
            System.out.println();
            e.printStackTrace(System.out);
        }

        X509Certificate[] chain = tm.chain;
        if (chain == null) {
            System.out.println("Could not obtain server certificate chain");
            return;
        }

        BufferedReader reader =
                new BufferedReader(new InputStreamReader(System.in));

        System.out.println();
        System.out.println("Server sent " + chain.length + " certificate(s):");
        System.out.println();
        MessageDigest sha1 = MessageDigest.getInstance("SHA1");
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        for (int i = 0; i < chain.length; i++) {
            X509Certificate cert = chain[i];
            System.out.println
                    (" " + (i + 1) + " Subject " + cert.getSubjectDN());
            System.out.println("   Issuer  " + cert.getIssuerDN());
            sha1.update(cert.getEncoded());
            System.out.println("   sha1    " + toHexString(sha1.digest()));
            md5.update(cert.getEncoded());
            System.out.println("   md5     " + toHexString(md5.digest()));
            System.out.println();
        }

        System.out.println("Enter certificate to add to trusted keystore or 'q' to quit: [1]");
        String line = reader.readLine().trim();
        int k;
        try {
            k = (line.length() == 0) ? 0 : Integer.parseInt(line) - 1;
        } catch (NumberFormatException e) {
            System.out.println("KeyStore not changed");
            return;
        }

        X509Certificate cert = chain[k];
        String alias = host + "-" + (k + 1);
        ks.setCertificateEntry(alias, cert);

        OutputStream out = new FileOutputStream("jssecacerts");
        ks.store(out, passphrase);
        out.close();

        System.out.println();
        System.out.println(cert);
        System.out.println();
        System.out.println
                ("Added certificate to keystore 'jssecacerts' using alias '"
                        + alias + "'");
    }

    private static final char[] HEXDIGITS = "0123456789abcdef".toCharArray();

    private static String toHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder(bytes.length * 3);
        for (int b : bytes) {
            b &= 0xff;
            sb.append(HEXDIGITS[b >> 4]);
            sb.append(HEXDIGITS[b & 15]);
            sb.append(' ');
        }
        return sb.toString();
    }

    private static class SavingTrustManager implements X509TrustManager {

        private final X509TrustManager tm;
        private X509Certificate[] chain;

        SavingTrustManager(X509TrustManager tm) {
            this.tm = tm;
        }

        public X509Certificate[] getAcceptedIssuers() {
            throw new UnsupportedOperationException();
        }

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

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

1. 인증서 확인

브라우저에 대상 URL을로드하고 다른 이유로 만료되었거나 신뢰할 수없는 사이트 인증서 (보통 자물쇠 기호가있는 아이콘으로 액세스 할 수 있습니다. 브라우저 주소 표시 줄의 왼쪽 또는 오른쪽에 있음)를보십시오.

2. 최신 버전의 JRE 및 JDK 설치

새 버전에는 일반적으로 업데이트 된 신뢰할 수있는 인증서 세트가 제공됩니다.

가능하면 이전 버전을 제거하십시오. 잘못된 구성 오류가 명시 적으로 나타납니다.

3. 구성을 확인하십시오.

• JAVA_HOME 환경 변수가 가리키는 위치를 확인하십시오.
• 프로그램을 실행하는 데 사용하는 Java 버전을 확인하십시오. IntelliJ 확인에서 :
  • 파일-> 프로젝트 구조 ...-> 프로젝트 설정-> 프로젝트-> 프로젝트 SDK :
  • 파일-> 프로젝트 구조 ...-> 플랫폼 설정-> SDK

4. 새로운 Java 버전에서 전체 키 저장소를 복사하십시오.

사용 가능한 최신 버전이 아닌 JDK로 개발하는 경우 %JAVA_HOME%/jre/lib/security/cacerts@ jeremy-goodell이 그의 답변 에서 제안한대로 최신 설치된 JRE의 새 파일로 파일 을 바꾸십시오 (먼저 백업 사본 만들기).

5. 키 저장소에 인증서 추가

위의 방법으로 문제를 해결하지 못하면 keytool인증서를 Java의 키 저장소에 저장 하는 데 사용하십시오 .

keytool -trustcacerts -keystore "%JAVA_HOME%jre\lib\security\cacerts" -storepass changeit -importcert -alias <alias_name> -file <path_to_crt_file>

@MagGGG가 그의 답변 에서 제안한대로 인증서를 가진 파일은 브라우저에서 얻을 수 있습니다 .

참고 1 : 사이트 인증서의 체인에있는 모든 인증서에 대해이 작업을 반복해야 할 수도 있습니다. 루트부터 시작하십시오.

참고 2 : <alias_name>상점의 키간에 고유해야하거나 keytool오류가 표시됩니다.

상점에서 모든 인증서 목록을 얻으려면 다음을 실행할 수 있습니다.

keytool -list -trustcacerts -keystore "%JAVA_HOME%jre\lib\security\cacerts" -storepass changeit

문제가 발생하면 저장소에서 인증서를 제거하는 데 도움이됩니다.

keytool -delete -alias <alias_name> -keystore "%JAVA_HOME%jre\lib\security\cacerts" -storepass changeit

-Dmaven.wagon.http.ssl.insecure=true -Dmaven.wagon.http.ssl.allowall=true

인증서 유효성 검사를 점프하는 데 사용됩니다.

경고 이것은 개발 목적으로 만 사용하는 것이 안전하지 않습니다!

JDK와 JRE 1.8.0_112가 모두 시스템에있을 때 상황이 약간 다릅니다.

[JDK_FOLDER]\jre\lib\security\cacerts이미 알려진 명령 을 사용하여 새 CA 인증서를 가져 왔습니다 .

keytool -import -trustcacerts -keystore cacerts -alias <new_ca_alias> -file <path_to_ca_cert_file>

여전히 동일한 PKIX 경로 작성 실패 오류가 계속 발생합니다.

를 사용하여 디버그 정보를 Java CLI에 추가했습니다 java -Djavax.net.debug=all ... > debug.log. debug.log 파일에서 trustStore로 시작하는 행 은 실제로 다음 에서 찾은 cacerts 저장소를 가리 킵니다 [JRE_FOLDER]\lib\security\cacerts.

필자의 경우 해결책은 JDK에서 사용하는 cacerts 파일 (새로운 CA가 추가 된 파일)을 JRE에서 사용하는 CACerts 파일에 복사하여 문제를 해결하는 것입니다.

문제 배경 :

프로젝트에서 Netbeans IDE 정리 및 빌드 옵션을 통해 mvn clean install을 실행하려고 할 때 다음 오류가 발생했습니다. 이 문제는 NET Bean IDE / 명령 프롬프트를 통해 다운로드 할 때 인증서를 사용할 수 없지만 브라우저를 통해 파일을 다운로드 할 수 있기 때문에 인증서가 없기 때문입니다.

오류 :

Caused by: org.eclipse.aether.transfer.ArtifactTransferException: Could not transfer artifact com.java.project:product:jar:1.0.32 from/to repo-local (https://url/local-repo): sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target  

해결:

1. 해당 URL의 인증서를 다운로드하십시오.

• "관리자로 실행"하여 IE를 시작합니다 (그렇지 않으면 인증서를 다운로드 할 수 없습니다).
• IE-> https : // url / local-repo에 URL을 입력하십시오 (제 경우에는이 URL에 신뢰할 수없는 인증서가 있습니다).
• 인증서 오류-> 인증서보기를 클릭하여 인증서를 다운로드하십시오.
• 세부 사항 탭-> 파일로 복사-> 다음-> "DER로 인코딩 된 바이너리 X.509 (.CER)를 선택하십시오.
• 인증서를 특정 위치에 저장하십시오 (예 : c : /user/sheldon/desktop/product.cer).
• 축하합니다! 사이트의 인증서를 성공적으로 다운로드했습니다

2. 이제 키 저장소를 설치하여 문제를 해결하십시오.

• keytool 명령을 실행하여 다운로드 한 키 저장소를 기존 인증서 파일에 추가하십시오.
• 명령 : jdk의 bin 폴더 (JAVA_HOME)에있는 명령 아래 .

C : \ Program Files \ Java \ jdk1.8.0_141 \ jre \ bin> keytool -importcert -file "C : /user/sheldon/desktop/product.cer"-alias product -keystore "C : / Program Files / Java / jdk1.8.0_141 / jre / lib / security / cacerts ".

• 비밀번호를 입력하라는 메시지가 표시됩니다. 키 저장소 비밀번호를 입력하십시오. "이 인증서를 신뢰 하시겠습니까? [no] :"에 "changeit"을 다시 입력하고 "yes"를 입력하십시오.

샘플 명령 행 명령 / 출력 :

keytool -importcert -file "C:/Users/sheldon/Desktop/product.cer" -alias product -keystore "C:/Program iles/Java/jdk1.8.0_141/jre/lib/security/cacerts"
Enter keystore password:
Trust this certificate? [no]:  yes
Certificate was added to keystore

• 투자자들! 이제 Netbeans IDE에서 "PKIX 경로 작성 실패 : sun.security.provider.certpath.SunCertPathBuilderException"오류를 제거해야합니다.

smtp.gmail.com에 대한 인증서를 가져오고 싶었습니다.

나를 위해 일한 해결책은 1입니다.이 인증서를 보려면 명령을 입력하십시오

D : \ openssl \ bin \ openssl.exe s_client -connect smtp.gmail.com:465

2. "------ BEGIN CERTIFICATE -----"와 "----- END CERTIFICATE -----"사이의 행을 gmail.cer 파일로 복사하여 저장하십시오.

3. 운영

   keytool -import -alias smtp.gmail.com -keystore "% JAVA_HOME % / jre / lib / security / cacerts"-file C : \ Users \ Admin \ Desktop \ gmail.cer

4. 비밀번호 입력

5. 인증서를 가져 오려면 예를 클릭하십시오.

6. 자바를 다시 시작

이제 명령을 실행하면 좋습니다.

이것은 트위터 고유의 답변은 아니지만이 오류를 검색 할 때 나타나는 질문입니다. 하는 웹 사이트에 연결할 때 시스템이 오류를 수신하는 경우 웹 브라우저에서 볼 때 표시가 유효한 인증서를 가지고 , 그것은 아마 의미 해당 웹 사이트가 불완전한 인증서 체인이있다 .

문제에 대한 간략한 요약 : 인증 기관은 루트 인증서를 사용하여 이전 인증서에 서명하지 않습니다. 대신 인증 기관 플래그가 설정된 중간 인증서에 서명 합니다 (즉, 인증서에 서명 할 수 있음). 그런 다음 CA에서 인증서를 구입할 때 이러한 중간 인증서 중 하나를 사용하여 CSR에 서명합니다.

Java 신뢰 저장소에는 루트 인증서 만 있고 중간 인증서는 없습니다.

잘못 구성된 사이트는 서명 된 인증서 만 반환 할 수 있습니다 . 문제 : 신뢰 저장소에없는 중간 인증서로 서명되었습니다. 브라우저는 캐시 된 중간 인증서를 다운로드하거나 사용하여이 문제를 처리합니다. 이것은 웹 사이트 호환성을 최대화합니다. 그러나 Java와 OpenSSL과 같은 도구는 그렇지 않습니다. 그리고 그것은 질문에 오류를 일으킬 것입니다.

Qualys SSL Test를 사용하여이 의심을 확인할 수 있습니다 . 사이트에 대해 실행하면

이 서버의 인증서 체인이 불완전합니다.

그런 다음 확인합니다. 인증 경로를보고 Extra Download 텍스트를 확인하여이를 확인할 수도 있습니다 .

수정 방법 : 서버 관리자는 웹 서버를 구성하여 중간 인증서도 리턴해야합니다. 예를 들어 Comodo의 경우 .ca-bundle파일이 편리한 곳입니다. 예를 들어 mod_ssl을 사용하는 Apache 구성에서는 SSLCertificateChainFile구성 설정을 사용합니다 . nginx의 경우 중간 인증서와 서명 된 인증서를 연결하고 SSL 인증서 구성에서 사용해야합니다. "불완전한 인증서 체인"을 온라인으로 검색하면 더 많은 것을 찾을 수 있습니다.

그 이유는 JDK가 신뢰할 수있는 많은 인증 기관 (CA) 인증서와 함께 'cacerts'라는 파일에 번들로 제공되었지만이 파일에는 자체 서명 인증서의 실마리가 없기 때문입니다. 즉, cacerts 파일에는 자체 서명 된 인증서를 가져 오지 않았으므로 신뢰할 수있는 엔티티로 취급하지 않으므로 위의 오류가 발생합니다.

위의 오류를 수정하는 방법

위의 오류를 해결하려면 자체 서명 된 인증서를 cacerts 파일로 가져 오기만하면됩니다.

먼저 cacerts 파일을 찾으십시오. JDK 위치를 찾아야합니다. Eclipse 또는 IntelliJ Idea와 같은 IDE 중 하나를 통해 응용 프로그램을 실행하는 경우 프로젝트 설정으로 이동하여 JDK 위치를 확인하십시오. 예를 들어 Mac OS에서 cacerts 파일의 일반적인 위치는 Windows 시스템의 / Library / Java / JavaVirtualMachines / {{JDK_version}} / Contents / Home / jre / lib / security 위치에 있으며 {{Installation_directory} 아래에 있습니다. } / {{JDK_version}} / jre / lib / security

cacerts 파일을 찾았 으면 이제 자체 서명 된 인증서를이 cacerts 파일로 가져와야합니다. 자체 서명 된 인증서를 올바르게 생성하는 방법을 모르는 경우 마지막 기사를 확인하십시오.

인증서 파일 (.crt)이없고 .jks 파일 만 있으면 아래 명령을 사용하여 .crt 파일을 생성 할 수 있습니다. 이미 .crt / .pem 파일이 있다면 아래 명령을 무시할 수 있습니다

## 키 저장소 (.jks 파일)에서 인증서를 생성하려면 ####

keytool -export -keystore keystore.jks -alias selfsigned -file selfsigned.crt

위의 단계는 selfsigned.crt라는 파일을 생성합니다. 이제 인증서를 cacerts로 가져 오기

keytool -importcert -file selfsigned.crt -alias selfsigned -keystore {{cacerts path}}

예를 들어

keytool -importcert -file selfsigned.nextgen.crt -alias selfsigned.nextgen -keystore /Library/Java/JavaVirtualMachines/jdk1.8.0_171.jdk/Contents/Home/jre/lib/security/cacerts

그게 다야 응용 프로그램을 다시 시작하면 제대로 작동합니다. 그래도 작동하지 않으면 SSL 핸드 셰이크 예외가 발생합니다. 다른 도메인을 사용하고 인증서에 등록되어 있음을 의미합니다.

자세한 설명과 단계별 해결 링크 가 여기에 있습니다.

추가 cacerts가 효과가 없었습니다. flag로 log를 활성화 한 후 -Djavax.net.debug=allJava read from을 알게되었습니다 jssecacerts.

jssecacerts마지막으로 가져 오기

이것은 해결책이지만이 문제에 대한 내 이야기의 형태입니다.

나는 위에서 주어진 모든 해결책을 시도하면서 거의 죽었고 (3 일 동안) 아무것도 효과가 없었습니다.

나는 모든 희망을 잃었다.

프록시 뒤에 있었기 때문에 보안 팀에 연락하여 최근에 보안 정책을 업데이트했다고 말했습니다.

나는 개발자들에게 알리지 않아서 심하게 꾸짖었다.

나중에 그들은 모든 인증서를 포함하는 새로운 "cacerts"파일을 발행했습니다.

% JAVA_HOME % / jre / lib / security에있는 cacerts 파일을 제거하여 문제를 해결했습니다.

따라서이 문제에 직면하면 네트워크 팀에서도 이와 같은 문제가 발생할 수 있습니다.

업데이트 사이트를 통해 Eclipse에 Cucumber-Eclipse 플러그인을 설치하려고 할 때이 질문을 보았습니다. 동일한 SunCertPathBuilderException 오류가 발생했습니다.

Unable to read repository at http://cucumber.io/cucumber-eclipse/update-site/content.xml.
    Unable to read repository at http://cucumber.io/cucumber-eclipse/update-site/content.xml.
    sun.security.validator.ValidatorException: PKIX path building failed: 
   sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

다른 답변 중 일부는이 질문의 주어진 상황에 적합하고 도움이되지만 그럼에도 불구하고 내 문제에 도움이되지 않고 오도했습니다.

필자의 경우 업데이트 사이트에 제공된 URL은 다음과 같습니다.

https://cucumber.io/cucumber-eclipse/update-site

그러나 브라우저를 통해 브라우저를 탐색하면 리디렉션됩니다 (추가 된 " .github " 참고 ).

http://cucumber.github.io/cucumber-eclipse/update-site/

따라서 해결 방법은 일식에 업데이트 사이트를 추가 할 때 업데이트 된 업데이트 사이트 URL 버전을 사용하는 것입니다.

나는 같은 문제에 직면하여 아래의 간단한 단계를 사용하여 해결되었습니다.

1) Google에서 InstallCert.java를 다운로드하십시오.

2) javac InstallCert.java를 사용하여 컴파일하십시오.

3) 호스트 이름과 https 포트를 사용하여 java InstallCert.java를 사용하여 InstallCert.java를 실행 하고 입력을 요청할 때“1”을 누르십시오. “localhost”를 신뢰할 수있는 키 저장소로 추가하고 아래와 같이“jssecacerts”라는 파일을 생성합니다.

java InstallCert 로컬 호스트 : 443

4) jssecacerts를 $ JAVA_HOME / jre / lib / security 폴더에 복사하십시오.

여기서 문제를 해결하기위한 주요 출처는 다음과 같습니다.

https://ankurjain26.blogspot.in/2017/11/javaxnetsslsslhandshakeexception.html

pkcs12상점에서 cacerts키 저장소로 인증서를 가져와 Java 8이 설치된 Windows Server 2016 에서이 문제를 해결했습니다 .

: PKCS12 저장소 경로
C:\Apps\pkcs12.pfx

자바 인 cacerts 경로 :
C:\Program Files\Java\jre1.8.0_151\lib\security\cacerts

키 도구 경로 :
C:\Program Files\Java\jre1.8.0_151\bin

(관리자로)에서 수입 인증서에 명령 프롬프트 명령 키 도구와 폴더에 possitioning 이후 pkcs12에 cacerts그대로는 다음과 같습니다
keytool -v -importkeystore -srckeystore C:\Apps\pkcs12.pfx -srcstoretype PKCS12 -destkeystore "C:\Program Files\Java\jre1.8.0_151\lib\security\cacerts" -deststoretype JKS

: 당신이하라는 메시지가 표시됩니다
1. 대상 키 스토어 암호를 입력 (cacerts pasword, 기본값은 "changeit")
2. 소스 키 저장소 비밀번호 (pkcs12 비밀번호)를 입력하십시오.

변경 사항을 적용하려면 서버 시스템을 다시 시작하십시오 (또는 JVM을 다시 시작하십시오).

일반적으로 이러한 종류의 예외는 신뢰할 수있는 인증서의 PATH에 불일치가있을 때 발생합니다. 보안 통신을 위해이 서버 인증서가 필요한 구성 또는 경로를 확인하십시오.

나를 위해, 피들러가 백그라운드에서 실행되고 인증서와 엉망으로 인해 인증서 오류가 발생했습니다. 프록시 역할을하므로 닫고 일식을 다시 시작하십시오.

목표 :

1. https 연결 사용
2. SSL 체인 확인
3. cacerts를 다루지 마십시오
4. 런타임에 인증서 추가
5. cacerts에서 인증서를 잃지 마십시오

그것을하는 방법 :

1. 자체 키 저장소 정의
2. 키 스토어에 증명서를 넣다
3. 사용자 정의 클래스를 사용하여 SSL 기본 컨텍스트를 재정의
4. ???
5. 이익

내 키 저장소 랩퍼 파일 :

public class CertificateManager {

    private final static Logger logger = Logger.getLogger(CertificateManager.class);

    private String keyStoreLocation;
    private String keyStorePassword;
    private X509TrustManager myTrustManager;
    private static KeyStore myTrustStore;

    public CertificateManager(String keyStoreLocation, String keyStorePassword) throws Exception {
        this.keyStoreLocation = keyStoreLocation;
        this.keyStorePassword = keyStorePassword;
        myTrustStore = createKeyStore(keyStoreLocation, keyStorePassword);
    }

    public void addCustomCertificate(String certFileName, String certificateAlias)
            throws Exception {
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init((KeyStore) null);
        Certificate certificate = myTrustStore.getCertificate(certificateAlias);
        if (certificate == null) {
            logger.info("Certificate not exists");
            addCertificate(certFileName, certificateAlias);
        } else {
            logger.info("Certificate exists");
        }
        tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(myTrustStore);
        for (TrustManager tm : tmf.getTrustManagers()) {
            if (tm instanceof X509TrustManager) {
                setMytrustManager((X509TrustManager) tm);
                logger.info("Trust manager found");
                break;
            }
        }
    }

    private InputStream fullStream(String fname) throws IOException {
        ClassLoader classLoader = getClass().getClassLoader();
        InputStream resource = classLoader.getResourceAsStream(fname);
        try {
            if (resource != null) {
                DataInputStream dis = new DataInputStream(resource);
                byte[] bytes = new byte[dis.available()];
                dis.readFully(bytes);
                return new ByteArrayInputStream(bytes);
            } else {
                logger.info("resource not found");
            }
        } catch (Exception e) {
            logger.error("exception in certificate fetching as resource", e);
        }
        return null;
    }

    public static KeyStore createKeyStore(String keystore, String pass) throws Exception {
        try {
            InputStream in = CertificateManager.class.getClass().getResourceAsStream(keystore);
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            keyStore.load(in, pass.toCharArray());
            logger.info("Keystore was created from resource file");
            return keyStore;
        } catch (Exception e) {
            logger.info("Fail to create keystore from resource file");
        }

        File file = new File(keystore);
        KeyStore keyStore = KeyStore.getInstance("JKS");
        if (file.exists()) {
            keyStore.load(new FileInputStream(file), pass.toCharArray());
            logger.info("Default keystore loaded");
        } else {
            keyStore.load(null, null);
            keyStore.store(new FileOutputStream(file), pass.toCharArray());
            logger.info("New keystore created");
        }
        return keyStore;
    }

    private void addCertificate(String certFileName, String certificateAlias) throws CertificateException,
            IOException, KeyStoreException, NoSuchAlgorithmException {
        CertificateFactory cf = CertificateFactory.getInstance("X.509");
        InputStream certStream = fullStream(certFileName);
        Certificate certs = cf.generateCertificate(certStream);
        myTrustStore.setCertificateEntry(certificateAlias, certs);
        FileOutputStream out = new FileOutputStream(getKeyStoreLocation());
        myTrustStore.store(out, getKeyStorePassword().toCharArray());
        out.close();
        logger.info("Certificate pushed");
    }

    public String getKeyStoreLocation() {
        return keyStoreLocation;
    }

    public String getKeyStorePassword() {
        return keyStorePassword;
    }
    public X509TrustManager getMytrustManager() {
        return myTrustManager;
    }
    public void setMytrustManager(X509TrustManager myTrustManager) {
        this.myTrustManager = myTrustManager;
    }
}

이 클래스는 필요한 경우 키 저장소를 작성하고 그 내부의 인증서를 관리 할 수 ​​있습니다. 이제 SSL 컨텍스트의 클래스 :

public class CustomTrustManager implements X509TrustManager {

    private final static Logger logger = Logger.getLogger(CertificateManager.class);

    private static SSLSocketFactory socketFactory;
    private static CustomTrustManager instance = new CustomTrustManager();
    private static List<CertificateManager> register = new ArrayList<>();

    public static CustomTrustManager getInstance() {
        return instance;
    }

    private X509TrustManager defaultTm;

    public void register(CertificateManager certificateManager) {
        for(CertificateManager manager : register) {
            if(manager == certificateManager) {
                logger.info("Certificate manager already registered");
                return;
            }
        }
        register.add(certificateManager);
        logger.info("New Certificate manager registered");
    }

    private CustomTrustManager() {
        try {
            String algorithm = TrustManagerFactory.getDefaultAlgorithm();
            TrustManagerFactory tmf = TrustManagerFactory.getInstance(algorithm);

            tmf.init((KeyStore) null);
            boolean found = false;
            for (TrustManager tm : tmf.getTrustManagers()) {
                if (tm instanceof X509TrustManager) {
                    defaultTm = (X509TrustManager) tm;
                    found = true;
                    break;
                }
            }
            if(found) {
                logger.info("Default trust manager found");
            } else {
                logger.warn("Default trust manager was not found");
            }

            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, new TrustManager[]{this}, null);
            SSLContext.setDefault(sslContext);
            socketFactory = sslContext.getSocketFactory();
            HttpsURLConnection.setDefaultSSLSocketFactory(socketFactory);


            logger.info("Custom trust manager was set");
        } catch (NoSuchAlgorithmException | KeyManagementException | KeyStoreException e) {
            logger.warn("Custom trust manager can't be set");
            e.printStackTrace();
        }
    }

    @Override
    public X509Certificate[] getAcceptedIssuers() {
        List<X509Certificate> out = new ArrayList<>();
        if (defaultTm != null) {
            out.addAll(Arrays.asList(defaultTm.getAcceptedIssuers()));
        }
        int defaultCount = out.size();
        logger.info("Default trust manager contain " + defaultCount + " certficates");
        for(CertificateManager manager : register) {
            X509TrustManager customTrustManager = manager.getMytrustManager();
            X509Certificate[] issuers = customTrustManager.getAcceptedIssuers();
            out.addAll(Arrays.asList(issuers));
        }
        logger.info("Custom trust managers contain " + (out.size() - defaultCount) + " certficates");
        X509Certificate[] arrayOut = new X509Certificate[out.size()];
        return out.toArray(arrayOut);
    }

    @Override
    public void checkServerTrusted(X509Certificate[] chain,
                                   String authType) throws CertificateException {
        for(CertificateManager certificateManager : register) {
            X509TrustManager customTrustManager = certificateManager.getMytrustManager();
            try {
                customTrustManager.checkServerTrusted(chain, authType);
                logger.info("Certificate chain (server) was aproved by custom trust manager");
                return;
            } catch (Exception e) {
            }
        }
        if (defaultTm != null) {
            defaultTm.checkServerTrusted(chain, authType);
            logger.info("Certificate chain (server) was aproved by default trust manager");
        } else {
            logger.info("Certificate chain (server) was rejected");
            throw new CertificateException("Can't check server trusted certificate.");
        }
    }

    @Override
    public void checkClientTrusted(X509Certificate[] chain,
                                   String authType) throws CertificateException {
        try {
            if (defaultTm != null) {
                defaultTm.checkClientTrusted(chain, authType);
                logger.info("Certificate chain (client) was aproved by default trust manager");
            } else {
                throw new NullPointerException();
            }
        } catch (Exception e) {
            for(CertificateManager certificateManager : register) {
                X509TrustManager customTrustManager = certificateManager.getMytrustManager();
                try {
                    customTrustManager.checkClientTrusted(chain, authType);
                    logger.info("Certificate chain (client) was aproved by custom trust manager");
                    return;
                } catch (Exception e1) {
                }
            }
            logger.info("Certificate chain (client) was rejected");
            throw new CertificateException("Can't check client trusted certificate.");
        }
    }

    public SSLSocketFactory getSocketFactory() {
        return socketFactory;
    }
}

하나의 defaultSSL 컨텍스트 만 허용되므로이 클래스는 싱글 톤으로 작성되었습니다. 이제 사용법 :

            CertificateManager certificateManager = new CertificateManager("C:\\myapplication\\mykeystore.jks", "changeit");
            String certificatePath = "C:\\myapplication\\public_key_for_your_ssl_service.crt";
            try {
                certificateManager.addCustomCertificate(certificatePath, "alias_for_public_key_for_your_ssl_service");
            } catch (Exception e) {
                log.error("Can't add custom certificate");
                e.printStackTrace();
            }
            CustomTrustManager.getInstance().register(certificateManager);

인증서 파일을 리소스 폴더 안에 보관하므로 경로가 절대적이지 않기 때문에이 설정에서는 작동하지 않을 수 있습니다. 그러나 일반적으로 완벽하게 작동합니다.

답변 https://stackoverflow.com/a/36427118/1491414에 추가됩니다 . 감사합니다 @MagGGG

• 관리자 권한이 있는지 확인하십시오
• 키 저장소 경로 (-keystore C : \ Program Files (x86) \ Java \ jre1.6.0_22 \ lib \ security \ cacerts ")에 큰 따옴표를 사용하십시오. Windows OS에서는 기본 설치 위치가 Program Files이므로 프로그램 파일 사이의 공간으로 인한 오류.

나는 아래 방법을 사용하여 이것을 고쳤다.

1. 연결 문제가있는 URL 복사
2. Android Studio-> 설정-> Http 설정으로 이동
3. '연결 테스트'에서 해당 URL을 붙여 넣고 확인을 누릅니다.
4. 클릭하면 Android Studio에서 해당 URL의 인증서 가져 오기를 요청합니다.
5. 그게 다야. 더 이상 할 일이없고 제 문제는 사라졌습니다. 스튜디오를 다시 시작할 필요가 없습니다.

atlassian 소프트웨어에서 위의 오류가 발생한 경우 ex. 지라

2018-08-18 11:35:00,312 Caesium-1-4 WARN anonymous    Default Mail Handler [c.a.mail.incoming.mailfetcherservice] Default Mail Handler[10001]: javax.mail.MessagingException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target while connecting to host 'imap.xyz.pl' as user 'jira@xyz.pl' via protocol 'imaps, caused by: javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

신뢰할 수있는 키 저장소에 인증서를 추가 할 수 있습니다 (missing_ca를 적절한 인증서 이름으로 변경).

keytool -importcert -file missing_ca.crt -alias missing_ca -keystore /opt/atlassian/jira/jre/lib/security/cacerts

비밀번호를 입력 changeit하고 확인하면y

그 후 jira를 다시 시작하십시오.

저장소 URL는 HTTP 작업과 보안이 아닌 경우, 당신은 갈 수 Settings.XML의 (자주, 항상은 아니지만,에 위치 %USERPROFILE%/.m2) 및 HTTP와 HTTPS를 대체 하기위한 <repository>과<pluginRepository> URL이 표시됩니다.

예를 들면 다음과 같습니다.

<repository>
    <snapshots>
        <enabled>false</enabled>
    </snapshots>
    <id>central</id>
    <name>libs-release</name>
    <url>https://<artifactory>/libs-release</url>
</repository>

이것으로 대체되어야합니다 :

<repository>
    <snapshots>
        <enabled>false</enabled>
    </snapshots>
    <id>central</id>
    <name>libs-release</name>
    <url>https://<artifactory>/libs-release</url>
</repository>

arg를 전달하여 JRE가 아닌 자체 신뢰 저장소를 사용하고있었습니다. -Djavax.net.ssl.trustStore=

신뢰 저장소의 인증서에 관계 없이이 오류가 발생했습니다. 나에게 문제는 arg 줄에 전달 된 속성의 순서였습니다. 내가 -Djavax.net.ssl.trustStore=& -Djavax.net.ssl.trustStorePassword= 앞에 -Dspring.config.location= & -jar인수를 넣을 때 https를 통해 나머지 통화를 성공적으로 호출 할 수있었습니다.

CloudFoundry를 사용하고 인증서 문제가 발생하면 인증서가있는 키 저장소 서비스로 jar을 다시 밀어야합니다. 바인드 해제, 바인드 및 재시작이 작동하지 않습니다.

호스트가 firewall / proxy 뒤에있는 경우 cmd에서 다음 명령을 사용하십시오.

keytool -J-Dhttps.proxyHost=<proxy_hostname> -J-Dhttps.proxyPort=<proxy_port> -printcert -rfc -sslserver <remote_host_name:remote_ssl_port>

교체 <proxy_hostname>및 <proxy_port>구성된 HTTP 프록시 서버. 바꾸다<remote_host_name:remote_ssl_port>인증 문제가있는 원격 호스트 (기본적으로 url) 및 포트 중 하나로 .

인쇄 된 마지막 인증서 내용을 가져 와서 복사하십시오 (복사 시작 및 종료 인증서). 텍스트 파일에 붙여넣고 .crt 확장자를 지정하십시오. 이제 java keytool 명령을 사용 하여이 인증서를 cacerts로 가져 오면 작동합니다.

keytool -importcert -file <filename>.crt -alias randomaliasname -keystore %JAVA_HOME%/jre/lib/security/cacerts -storepass changeit

Java cacert를 복사하십시오.

cp /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.172-9.b11.fc28.x86_64/jre/lib/security/cacerts $JAVA_HOME/jre/lib/security/cacerts

Java 애플리케이션이 다른 애플리케이션 / 사이트와 통신하려고 할 때 Linux 컨테이너에서이 문제가 발생하면 인증서가로드 밸런서로 잘못 가져 오기 때문입니다. 인증서를 가져 오기 위해 따라야 할 단계가 있으며 올바르게 수행하지 않으면 다음과 같은 문제가 나타납니다.

Caused by: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid 
certification path to requested target

인증서를 올바르게 가져 오면 완료해야합니다. JDK 인증서를 땜질 할 필요가 없습니다.

나는 그것을 해결했다 인 IntelliJ 아이디어 , 당신은 볼 것이다 나 프로젝트를 클릭 됐지이 문제 Althouh, 내가 문제 야 해결책을 찾아 해결하는 장소의 많은 변화에 직면 I 메이븐을 그 누른 후에, 소스 및 업데이트 폴더 생성 및 다시 가져 오기를

끝났습니다.

나는 같은 문제에 직면하고 있었고, 8.1.0-3을 사용하고 있었지만 나중에 9.2.1-0을 사용했으며 문제는 수동 단계없이 해결되었습니다. 자체 서명 인증서가 정상적으로 작동했습니다.