Apache HttpClient 4.0 में SSL प्रमाणपत्र त्रुटियों को कैसे अनदेखा करें

Question

मैं अपाचे HttpClient 4.0 के साथ अवैध एसएसएल प्रमाणपत्र त्रुटियों को कैसे दरकिनार करूं ?

Comments

यह ध्यान दिया जाना चाहिए कि इस प्रश्न के उत्तर, जो कुछ पूछा गया है उससे अधिक नहीं करते हैं: वे आपको त्रुटि को अनदेखा करते हैं लेकिन अंतर्निहित समस्या को ठीक नहीं करते हैं (आग को बाहर रखने के बजाय एक धूम्रपान अलार्म से बैटरी को निकालने की तरह थोड़ा सा )। प्रमाणपत्र में एसएसएल / टीएलएस कनेक्शन की सुरक्षा सुनिश्चित करने का एक उद्देश्य है, उन त्रुटियों को अनदेखा करना MITM हमले के लिए एक भेद्यता का परिचय देता है। त्रुटि को अनदेखा करने के बजाय परीक्षण प्रमाणपत्र का उपयोग करें।

— ब्रूनो

से संबंधित stackoverflow.com/questions/1828775/...

— ग्रे

"एक स्मोक अलार्म से बैटरी को निकालना पसंद है" आप अन्य डेवलपर्स को संदेह का लाभ दे सकते हैं और मान सकते हैं कि वे जानते हैं कि वे क्या कर रहे हैं। शायद इस सवाल की प्रेरणा स्थानीय परीक्षण है और ओपी एक सरल एसएसएल वातावरण स्थापित करने के लिए आवश्यक जावा बॉयलरप्लेट की भयानक मात्रा के माध्यम से जाने के बिना एक त्वरित परीक्षण चलाने की इच्छा रखता है। हो सकता है कि कोई व्यक्ति "तू से भी अधिक पवित्र" व्याख्यान में जाए बिना इस प्रश्न का उत्तर दे सके।

— माइक

हमारी कंपनी में आंतरिक JIRA सर्वर में कुछ "विंडोज़ सुरक्षा नीति आधारित प्रमाणपत्र" है जो डोमेन में शामिल विंडोज मशीनों पर मान्य है और अन्य के लिए मान्य नहीं है। मैं इस नीति को नियंत्रित नहीं कर सकता और अभी भी JIRA REST API को कॉल करना चाहता हूं।

— odiszapc

@Bruno छोटी रसोई की आग से निपटने के दौरान 30-60 मिनट की अवधि के लिए स्मोक डिटेक्टरों को निष्क्रिय करने में असमर्थता कुछ बिंदु पर कुछ कानूनी अधिकारी द्वारा उपयोग पैटर्न में अंतर्दृष्टि की कमी को दर्शाती है कि मुझे अपराधी पर सीमाएं लगती हैं। तथ्य यह है कि "एक धूम्रपान अलार्म से बैटरी हटाने" की एक अवधारणा है, यह साबित करता है। मैं एक समान स्तर के क्रोध के बारे में महसूस करता हूं कि एक साधारण परीक्षण के लिए प्रमाण पत्र प्राप्त करने के लिए जो मुझे पता है कि सुरक्षा प्रभाव नहीं है। इस सवाल का अस्तित्व यह साबित करता है।

— बिल के

Answer 1

आपको अपने स्वयं के ट्रस्ट प्रबंधक के साथ एक SSLContext बनाने और इस संदर्भ का उपयोग करके HTTPS योजना बनाने की आवश्यकता है। यहाँ कोड है,

SSLContext sslContext = SSLContext.getInstance("SSL");

// set up a TrustManager that trusts everything
sslContext.init(null, new TrustManager[] { new X509TrustManager() {
            public X509Certificate[] getAcceptedIssuers() {
                    System.out.println("getAcceptedIssuers =============");
                    return null;
            }

            public void checkClientTrusted(X509Certificate[] certs,
                            String authType) {
                    System.out.println("checkClientTrusted =============");
            }

            public void checkServerTrusted(X509Certificate[] certs,
                            String authType) {
                    System.out.println("checkServerTrusted =============");
            }
} }, new SecureRandom());

SSLSocketFactory sf = new SSLSocketFactory(sslContext);
Scheme httpsScheme = new Scheme("https", 443, sf);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(httpsScheme);

// apache HttpClient version >4.2 should use BasicClientConnectionManager
ClientConnectionManager cm = new SingleClientConnManager(schemeRegistry);
HttpClient httpClient = new DefaultHttpClient(cm);

Comments

कहो कि मैं अपनी साइट के लिए वैध एसएसएल प्रमाणपत्र नहीं खरीदना चाहता हूं और केवल इसका उपयोग करना चाहता हूं, यह कोड का टुकड़ा मदद कर सकता है? मैं किसी भी भाग को नहीं देख सकता हूँ जहाँ एक URL की आवश्यकता है या अपवाद हैंडलिंग की आवश्यकता है?

— वियतनामी

हम्म, यह मुझे बता रहा है कि 'नया SSLSocketFactory (ssslCont)' KeyStore से उम्मीद कर रहा है, SSLContext नहीं। क्या मैं कुछ भूल रहा हूँ?

— एमएसपीड

मुझे एक त्रुटि मिलती है कि एक X509TrustManager एक TrustManager को नहीं डाला जा सकता है।

— मेगावाट।

सुनिश्चित करें कि आप सही संकुल आयात करते हैं, अर्थात org.apache.http से।

— वार्डन

किसी को पता है कि यह सब एक साथ फेंकने का उपयोग HttpClientBuilderकैसे करें?

— अली

Answer 2

अन्य सभी उत्तरों को या तो हटा दिया गया था या HttpClient 4.3 के लिए काम नहीं किया था।

Http क्लाइंट बनाते समय सभी होस्टनामों को अनुमति देने का एक तरीका यहां दिया गया है।

CloseableHttpClient httpClient = HttpClients
    .custom()
    .setHostnameVerifier(AllowAllHostnameVerifier.INSTANCE)
    .build();

या यदि आप 4.4 या बाद के संस्करण का उपयोग कर रहे हैं, तो अद्यतन कॉल इस तरह दिखती है:

CloseableHttpClient httpClient = HttpClients
    .custom()
    .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
    .build();

Comments

उत्तर के लिए धन्यवाद, मैं जानना चाहूंगा कि कौन सा पैकेज HttpsClients है जैसा कि मैं एंड्रॉइड संकलन ("org.apache.httpcompenders: httpclient: 4.3.4") में उपयोग कर रहा हूं, लेकिन यह वर्ग प्रकट नहीं होता है।

— जुआन साराविया

यह पैकेज है। org.apache.http.impl.client.HttpClients।

— erversteeg

यह एक होस्ट नाम मिसमैच के आसपास काम करता है (मेरा मानना ​​है), लेकिन जब कोई विश्वसनीय प्राधिकारी द्वारा प्रमाण पत्र पर हस्ताक्षर नहीं किया जाता है तो यह काम नहीं करता है।

— TWM

@ इसीलिए यह कहता है कि यह "सभी होस्टनामों को अनुमति देता है", ट्रस्ट मुद्दों को अलग कॉन्फ़िगरेशन की आवश्यकता होती है।

— eis

@eis, मैं इंगित कर रहा था कि यह उत्तर कुछ मामलों में मूल प्रश्न को संबोधित करता है, लेकिन दूसरों को नहीं।

— twm

Answer 3

बस नए HttpClient 4.5 के साथ ऐसा करना था और ऐसा लगता है कि उन्होंने 4.4 के बाद से कुछ चीजों को हटा दिया है इसलिए यहाँ स्निपेट मेरे लिए काम करता है और सबसे हाल के एपीआई का उपयोग करता है:

final SSLContext sslContext = new SSLContextBuilder()
        .loadTrustMaterial(null, (x509CertChain, authType) -> true)
        .build();

return HttpClientBuilder.create()
        .setSSLContext(sslContext)
        .setConnectionManager(
                new PoolingHttpClientConnectionManager(
                        RegistryBuilder.<ConnectionSocketFactory>create()
                                .register("http", PlainConnectionSocketFactory.INSTANCE)
                                .register("https", new SSLConnectionSocketFactory(sslContext,
                                        NoopHostnameVerifier.INSTANCE))
                                .build()
                ))
        .build();

Comments

मेरे लिए httpclient 4.5.2 के लिए भी काम किया

— विकास रंजन

यह एक HttpClient 4.5 के लिए अप-टू-डेट है

— आप

Answer 4

बस रिकॉर्ड के लिए, HttpClient 4.1 के साथ समान पूरा करने का एक बहुत सरल तरीका है

    SSLSocketFactory sslsf = new SSLSocketFactory(new TrustStrategy() {

        public boolean isTrusted(
                final X509Certificate[] chain, String authType) throws CertificateException {
            // Oh, I am easy...
            return true;
        }

    });

Comments

क्या आपको इस नमूने में कुछ कोड याद आ रहे हैं? शायद httpClient.set पर कॉल करें ...?

— ग्रे

httpclient.getConnectionManager ()। getSchemeRegistry ()। register (नई स्कीम ("https", 443, sslsf));

— बेन फ्लिन

SSLSocketFactory को HttpClient 4.3

— Toilal

यदि जावा 8 का उपयोग कर रहे हैं, तो आप भी कर सकते हैंnew SSLSocketFactory((chain, authType) -> true);

— jlb

Answer 5

अपाचे HttpClient 4.5.5

HttpClient httpClient = HttpClients
            .custom()
            .setSSLContext(new SSLContextBuilder().loadTrustMaterial(null, TrustAllStrategy.INSTANCE).build())
            .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
            .build();

किसी भी पदावनत एपीआई का उपयोग नहीं किया गया है।

सरल परीक्षण योग्य मामला:

package org.apache.http.client.test;

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;

public class ApacheHttpClientTest {

    private HttpClient httpClient;

    @Before
    public void initClient() throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException {
        httpClient = HttpClients
                .custom()
                .setSSLContext(new SSLContextBuilder().loadTrustMaterial(null, TrustAllStrategy.INSTANCE).build())
                .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                .build();
    }

    @Test
    public void apacheHttpClient455Test() throws IOException {
        executeRequestAndVerifyStatusIsOk("https://expired.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://wrong.host.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://self-signed.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://untrusted-root.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://revoked.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://pinning-test.badssl.com");
        executeRequestAndVerifyStatusIsOk("https://sha1-intermediate.badssl.com");
    }

    private void executeRequestAndVerifyStatusIsOk(String url) throws IOException {
        HttpUriRequest request = new HttpGet(url);

        HttpResponse response = httpClient.execute(request);
        int statusCode = response.getStatusLine().getStatusCode();

        assert statusCode == 200;
    }
}

Comments

धन्यवाद! बस इस जवाब के TrustAllStrategy.INSTANCEसाथ बदल जाते हैं TrustSelfSignedStrategy.INSTANCE।

— पर्सी वेगा

इसने मेरे लिए काम नहीं किया। javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX पथ निर्माण विफल: sun.security।

— प्रदाता.कार्पथ.सुंरपार्टपैथबेलस्टैप्शन:

Answer 6

रिकॉर्ड के लिए, httpclient 4.3.6 के साथ परीक्षण किया गया और धाराप्रवाह एपीआई के निष्पादन के साथ संगत:

CloseableHttpClient httpClient = HttpClients.custom().
                    setHostnameVerifier(new AllowAllHostnameVerifier()).
                    setSslcontext(new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy()
                    {
                        public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException
                        {
                            return true;
                        }
                    }).build()).build();

Comments

HttpClient 4.4 के लिए ऊपर की ओर, आपको यह करना होगा - और इसका SSLConnectionSocketFactoryउपयोग करने की आवश्यकता भी हो सकती है SSLContext, और Registry<ConnectionSocketFactory>यदि आप एक बनाने जा रहे हैं, तो इसे एक में परिभाषित करें PoolingHttpClientConnectionManager। अन्य उत्तर अधिक लोकप्रिय हैं, लेकिन HttpClient 4.4 पर काम नहीं करते हैं।

— थॉमस डब्ल्यू

Httpclient-4.3.5.jar के साथ ठीक इसी तरह काम करता है।

— हैराल्ड

Answer 7

अपाचे HttpClient 4.4 के लिए:

HttpClientBuilder b = HttpClientBuilder.create();

SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
    public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
        return true;
    }
}).build();
b.setSslcontext( sslContext);

// or SSLConnectionSocketFactory.getDefaultHostnameVerifier(), if you don't want to weaken
HostnameVerifier hostnameVerifier = SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;

SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
        .register("http", PlainConnectionSocketFactory.getSocketFactory())
        .register("https", sslSocketFactory)
        .build();

// allows multi-threaded use
PoolingHttpClientConnectionManager connMgr = new PoolingHttpClientConnectionManager( socketFactoryRegistry);
b.setConnectionManager( connMgr);

HttpClient client = b.build();

यह हमारे वास्तविक कार्य कार्यान्वयन से निकाला जाता है।

अन्य उत्तर लोकप्रिय हैं, लेकिन HttpClient 4.4 के लिए वे काम नहीं करते हैं। मैंने घंटों कोशिश की और थकावट की संभावनाएँ देखीं, लेकिन लगता है कि 4.4 पर बहुत बड़ा एपीआई परिवर्तन और स्थानांतरण हुआ है।

: पर यह भी देखें एक से थोड़ा पूरा विवरण दिया http://literatejava.com/networks/ignore-ssl-certificate-errors-apache-httpclient-4-4/

उम्मीद है की वो मदद करदे!

Comments

मैं उस SSLContext बिट की जरूरत थी। इतना मजबूर है।

— मटनअप

Answer 8

यदि आप सभी करना चाहते हैं तो अवैध होस्टनाम त्रुटियों से छुटकारा पाएं जो आप कर सकते हैं:

HttpClient httpClient = new DefaultHttpClient();
SSLSocketFactory sf = (SSLSocketFactory)httpClient.getConnectionManager()
    .getSchemeRegistry().getScheme("https").getSocketFactory();
sf.setHostnameVerifier(new AllowAllHostnameVerifier());

Comments

Sf.setHostnameVerifier पद्धति को 4.1 के रूप में चित्रित किया गया है। विकल्प यह है कि निर्माणकर्ताओं में से किसी एक का उपयोग किया जाए। उदाहरण के लिए:SSLSocketFactory sf = new SSLSocketFactory(sslContext, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

— कलियाते 21

यह तब बहुत उपयोगी था जब मुझे विरासत कोड से निपटना पड़ा।

— डंकनसंगवकिम

Answer 9

हम HTTPClient 4.3.5 का उपयोग कर रहे हैं और हमने स्टैकओवरफ़्लो पर मौजूद लगभग सभी समाधानों की कोशिश की, लेकिन कुछ भी नहीं, सोचने और समस्या का पता लगाने के बाद, हम निम्नलिखित कोड पर आते हैं जो पूरी तरह से काम करता है, बस इसे HttpClient इंस्टेंस बनाने से पहले जोड़ दें।

पोस्ट अनुरोध करते समय कॉल करने की कुछ विधि ....

SSLContextBuilder builder = new SSLContextBuilder();
    builder.loadTrustMaterial(null, new TrustStrategy() {
        @Override
        public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            return true;
        }
    });

    SSLConnectionSocketFactory sslSF = new SSLConnectionSocketFactory(builder.build(),
            SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

    HttpClient httpClient = HttpClients.custom().setSSLSocketFactory(sslSF).build();
    HttpPost postRequest = new HttpPost(url);

अपने अनुरोध को सामान्य रूप में जारी रखें

Answer 10

धाराप्रवाह 4.5.2 के साथ मुझे इसे काम करने के लिए निम्नलिखित संशोधन करना पड़ा।

try {
    TrustManager[] trustAllCerts = new TrustManager[] {
       new X509TrustManager() {
    public java.security.cert.X509Certificate[] getAcceptedIssuers() {
        return null;
    }
    public void checkClientTrusted(X509Certificate[] certs, String authType) {  }

    public void checkServerTrusted(X509Certificate[] certs, String authType) {  }
    }
    };

    SSLContext sc = SSLContext.getInstance("SSL");
    sc.init(null, trustAllCerts, new SecureRandom());
    CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE).setSslcontext(sc).build();

    String output = Executor.newInstance(httpClient).execute(Request.Get("https://127.0.0.1:3000/something")
                                      .connectTimeout(1000)
                                      .socketTimeout(1000)).returnContent().asString();
    } catch (Exception e) {
    }

Comments

यह एकमात्र समाधान है जिसने मेरे लिए काम किया। मैंने 4.5 में अपग्रेड करने से पहले 4.3 और 4.4 के लिए उपरोक्त समाधानों की कोशिश की और यह कोशिश की।

— dirkoneill

Answer 11

मैंने इस तरह से इसे किया -

1. अपना खुद का MockSSLSocketFactory बनाएँ (कक्षा नीचे संलग्न है)
2. DefaultHttpClient को इनिशियलाइज़ करने के लिए इसका उपयोग करें। यदि प्रॉक्सी का उपयोग किया जाता है तो प्रॉक्सी सेटिंग्स प्रदान करने की आवश्यकता है।

---

प्रारंभिक DefaultHTTPClient -

SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
    schemeRegistry.register(new Scheme("https", 443, new MockSSLSocketFactory()));
    ClientConnectionManager cm = new SingleClientConnManager(schemeRegistry);

    DefaultHttpClient httpclient = new DefaultHttpClient(cm);

---

नकली SSL फैक्टरी -

public class MockSSLSocketFactory extends SSLSocketFactory {

public MockSSLSocketFactory() throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
    super(trustStrategy, hostnameVerifier);
}

private static final X509HostnameVerifier hostnameVerifier = new X509HostnameVerifier() {
    @Override
    public void verify(String host, SSLSocket ssl) throws IOException {
        // Do nothing
    }

    @Override
    public void verify(String host, X509Certificate cert) throws SSLException {
        //Do nothing
    }

    @Override
    public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
        //Do nothing
    }

    @Override
    public boolean verify(String s, SSLSession sslSession) {
        return true; 
    }
};

private static final TrustStrategy trustStrategy = new TrustStrategy() {
    @Override
    public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        return true;
    }
};
}

---

यदि एक प्रॉक्सी के पीछे, यह करने की आवश्यकता है -

HttpParams params = new BasicHttpParams();
    params.setParameter(AuthPNames.PROXY_AUTH_PREF, getClientAuthPrefs());

DefaultHttpClient httpclient = new DefaultHttpClient(cm, params);

httpclient.getCredentialsProvider().setCredentials(
                        new AuthScope(proxyHost, proxyPort),
                        new UsernamePasswordCredentials(proxyUser, proxyPass));

Comments

यदि आप भविष्य में आयात को शामिल करते हैं तो यह मदद करेगा। दो अलग-अलग वर्ग हैं।

— एंड्रॉयड डे

Answer 12

ZZ कोडर के जवाब के विस्तार में hostnameverifier को ओवरराइड करना अच्छा रहेगा।

// ...
SSLSocketFactory sf = new SSLSocketFactory (sslContext);
sf.setHostnameVerifier(new X509HostnameVerifier() {
    public boolean verify(String hostname, SSLSession session) {
        return true;
    }

    public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
    }

    public void verify(String host, X509Certificate cert) throws SSLException {
    }

    public void verify(String host, SSLSocket ssl) throws IOException {
    }
});
// ...

Comments

आप इसे केवल कर के प्राप्त कर सकते हैंsf.setHostnameVerifier(new AllowAllHostnameVerifier());

— डैन डायर

Sf.setHostnameVerifier को 4.1 के रूप में चित्रित किया गया है। विकल्प यह है कि निर्माणकर्ताओं में से किसी एक का उपयोग किया जाए। उदाहरण के लिए:SSLSocketFactory sf = new SSLSocketFactory(sslContext, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

— कलियातेच

Answer 13

        DefaultHttpClient httpclient = new DefaultHttpClient();

    SSLContext sslContext;
    try {
        sslContext = SSLContext.getInstance("SSL");

        // set up a TrustManager that trusts everything
        try {
            sslContext.init(null,
                    new TrustManager[] { new X509TrustManager() {
                        public X509Certificate[] getAcceptedIssuers() {
                            log.debug("getAcceptedIssuers =============");
                            return null;
                        }

                        public void checkClientTrusted(
                                X509Certificate[] certs, String authType) {
                            log.debug("checkClientTrusted =============");
                        }

                        public void checkServerTrusted(
                                X509Certificate[] certs, String authType) {
                            log.debug("checkServerTrusted =============");
                        }
                    } }, new SecureRandom());
        } catch (KeyManagementException e) {
        }
         SSLSocketFactory ssf = new SSLSocketFactory(sslContext,SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
         ClientConnectionManager ccm = this.httpclient.getConnectionManager();
         SchemeRegistry sr = ccm.getSchemeRegistry();
         sr.register(new Scheme("https", 443, ssf));            
    } catch (Exception e) {
        log.error(e.getMessage(),e);
    }

Answer 14

HttpClient 4.4.x में सभी प्रमाणपत्र स्वीकार करने के लिए आप httpClient बनाते समय निम्नलिखित एक लाइनर का उपयोग कर सकते हैं:

httpClient = HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).setSslcontext(new SSLContextBuilder().loadTrustMaterial(null, (x509Certificates, s) -> true).build()).build();

Comments

मुझे यह मिल रहा है: इसके कारण: javax.net.ssl.SSLHandshakeException: java.security.cert.CertificateException: कोई विषय वैकल्पिक नाम मौजूद नहीं है?

HttpClient API में या RestClient API में बिना सीनेट्स के एसएसएल साइट्स पर कनेक्शन की अनुमति कैसे दें?

Answer 15

धाराप्रवाह एपीआई के साथ HttpClient 4.5.5 के साथ परीक्षण किया गया

final SSLContext sslContext = new SSLContextBuilder()
    .loadTrustMaterial(null, (x509CertChain, authType) -> true).build();

CloseableHttpClient httpClient = HttpClients.custom()
    .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
    .setSSLContext(sslContext).build();

String result = Executor.newInstance(httpClient)
    .execute(Request.Get("https://localhost:8080/someapi")
    .connectTimeout(1000).socketTimeout(1000))
    .returnContent().asString();

Answer 16

नीचे कोड के साथ काम करता है 4.5.5

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

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

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

class HttpsSSLClient {


    public static CloseableHttpClient createSSLInsecureClient() {
        SSLContext sslcontext = createSSLContext();
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new HostnameVerifier() {

            @Override
            public boolean verify(String paramString, SSLSession paramSSLSession) {
                return true;
            }
        });
        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
        return httpclient;
    }


    private static SSLContext createSSLContext() {
        SSLContext sslcontext = null;
        try {
            sslcontext = SSLContext.getInstance("TLS");
            sslcontext.init(null, new TrustManager[] {new TrustAnyTrustManager()}, new SecureRandom());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
        return sslcontext;
    }


    private static class TrustAnyTrustManager implements X509TrustManager {

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

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

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

}
public class TestMe {


    public static void main(String[] args) throws IOException {
        CloseableHttpClient client = HttpsSSLClient.createSSLInsecureClient();

        CloseableHttpResponse res = client.execute(new HttpGet("https://wrong.host.badssl.com/"));
        System.out.println(EntityUtils.toString(res.getEntity()));
    }
}

कोड से आउटपुट है

ब्राउज़र पर आउटपुट है

नीचे इस्तेमाल किया गया पोम है

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.tarun</groupId>
    <artifactId>testing</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>6</source>
                    <target>6</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
    <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.5</version>
    </dependency>

</dependencies>
</project>

Comments

अपडेट किए गए उत्तर के लिए धन्यवाद, मैंने नए व्यक्ति को "स्वागत" करने के लिए इनाम दिया, लेकिन मैं सिर्फ सभी के लिए अपडेट किए गए उत्तर चाहता था!

@feelingunw Welcome, ज़रूर। मैंने उसे भी उतारा है :-)

— तरुण लालवानी

Answer 17

Apache HttpClient 4.1.3 के लिए एक पूर्ण कार्यशील संस्करण (ऊपर दिए गए ऑगल्स कोड के आधार पर, लेकिन इसके लिए मेरे सिस्टम पर अभी भी allow_all_hostname_verifier की आवश्यकता है):

private static HttpClient trustEveryoneSslHttpClient() {
    try {
        SchemeRegistry registry = new SchemeRegistry();

        SSLSocketFactory socketFactory = new SSLSocketFactory(new TrustStrategy() {

            public boolean isTrusted(final X509Certificate[] chain, String authType) throws CertificateException {
                // Oh, I am easy...
                return true;
            }

        }, org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

        registry.register(new Scheme("https", 443, socketFactory));
        ThreadSafeClientConnManager mgr = new ThreadSafeClientConnManager(registry);
        DefaultHttpClient client = new DefaultHttpClient(mgr, new DefaultHttpClient().getParams());
        return client;
    } catch (GeneralSecurityException e) {
        throw new RuntimeException(e);
    }
}

ध्यान दें कि मैं सभी अपवादों को फिर से फेंक रहा हूं क्योंकि वास्तव में, बहुत कुछ नहीं है अगर मैं किसी भी वास्तविक प्रणाली में विफल रहता हूं!

Answer 18

यदि आप धाराप्रवाह एपीआई का उपयोग कर रहे हैं , तो आपको इसे इसके माध्यम से सेट करने की आवश्यकता है Executor:

Executor.unregisterScheme("https");
SSLSocketFactory sslSocketFactory = new SSLSocketFactory(sslContext,
                                  SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
Executor.registerScheme(new Scheme("https", 443, sslSocketFactory));

... जहाँ sslContextSSLContext बनाया है जैसा कि ZZ कोडर के उत्तर में दिखाया गया है ।

उसके बाद, आप अपने http अनुरोध कर सकते हैं:

String responseAsString = Request.Get("https://192.168.1.0/whatever.json")
                         .execute().getContent().asString();

_{नोट: HttpClient 4.2 के साथ परीक्षण किया गया}

Comments

दुर्भाग्य से 4.3 में पदावनत: "पदावनत। (4.3) का उपयोग नहीं करते हैं।"

— STM

Answer 19

4.3.3 के साथ परीक्षण किया गया

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

import javax.net.ssl.SSLContext;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class AccessProtectedResource {

public static void main(String[] args) throws Exception {

    // Trust all certs
    SSLContext sslcontext = buildSSLContext();

    // Allow TLSv1 protocol only
    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
            sslcontext,
            new String[] { "TLSv1" },
            null,
            SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

    CloseableHttpClient httpclient = HttpClients.custom()
            .setSSLSocketFactory(sslsf)
            .build();
    try {

        HttpGet httpget = new HttpGet("https://yoururl");

        System.out.println("executing request" + httpget.getRequestLine());

        CloseableHttpResponse response = httpclient.execute(httpget);
        try {
            HttpEntity entity = response.getEntity();

            System.out.println("----------------------------------------");
            System.out.println(response.getStatusLine());
            if (entity != null) {
                System.out.println("Response content length: " + entity.getContentLength());
            }
            for (Header header : response.getAllHeaders()) {
                System.out.println(header);
            }
            EntityUtils.consume(entity);
        } finally {
            response.close();
        }
    } finally {
        httpclient.close();
    }
}

private static SSLContext buildSSLContext()
        throws NoSuchAlgorithmException, KeyManagementException,
        KeyStoreException {
    SSLContext sslcontext = SSLContexts.custom()
            .setSecureRandom(new SecureRandom())
            .loadTrustMaterial(null, new TrustStrategy() {

                public boolean isTrusted(X509Certificate[] chain, String authType)
                        throws CertificateException {
                    return true;
                }
            })
            .build();
    return sslcontext;
}

}

Comments

यदि मैं ऐसा करना चाहता हूं तो हेडर्स में मूल्यों को कैसे निर्धारित किया जाए?

Answer 20

4.5.4 पर परीक्षण किया गया:

            SSLContext sslContext = new SSLContextBuilder()
                    .loadTrustMaterial(null, (TrustStrategy) (arg0, arg1) -> true).build();

            CloseableHttpClient httpClient = HttpClients
                    .custom()
                    .setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE)
                    .setSSLContext(sslContext)
                    .build();

Answer 21

यदि आप AmazonS3Client का उपयोग करते समय इस समस्या का सामना करते हैं, जो Apache HttpClient 4.1 को एम्बेड करता है, तो आपको बस इस तरह एक सिस्टम प्रॉपर्टी को परिभाषित करने की आवश्यकता होती है ताकि SSL सर्टिफिकेट चेकर को आराम मिले:

-Dcom.amazonaws.sdk.disableCertChecking = true

शरारत कामयाब

Answer 22

fwiw, JAX-RS 2.x के "रेस्टएसी" कार्यान्वयन का उपयोग करने वाला एक उदाहरण एक विशेष "सभी विश्वास" ग्राहक बनाने के लिए ...

    import java.io.IOException;
    import java.net.MalformedURLException;
    import java.security.GeneralSecurityException;
    import java.security.KeyManagementException;
    import java.security.KeyStoreException;
    import java.security.NoSuchAlgorithmException;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;
    import java.util.ArrayList;
    import java.util.Arrays;
    import javax.ejb.Stateless;
    import javax.net.ssl.SSLContext;
    import javax.ws.rs.GET;
    import javax.ws.rs.Path;
    import javax.ws.rs.Produces;
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    import javax.ws.rs.client.Entity;
    import javax.ws.rs.core.MediaType;
    import javax.ws.rs.core.Response;
    import org.apache.http.config.Registry;
    import org.apache.http.config.RegistryBuilder;
    import org.apache.http.conn.HttpClientConnectionManager;
    import org.apache.http.conn.ssl.TrustStrategy;
    import org.jboss.resteasy.client.jaxrs.ResteasyClient;
    import org.jboss.resteasy.client.jaxrs.ResteasyClientBuilder;
    import org.jboss.resteasy.client.jaxrs.ResteasyWebTarget;
    import org.jboss.resteasy.client.jaxrs.engines.ApacheHttpClient4Engine;
    import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
    import org.apache.http.conn.socket.ConnectionSocketFactory;
    import org.apache.http.conn.ssl.NoopHostnameVerifier;
    import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClientBuilder;
    import org.apache.http.ssl.SSLContexts;

    @Stateless
    @Path("/postservice")
    public class PostService {

        private static final Logger LOG = LogManager.getLogger("PostService");

        public PostService() {
        }

        @GET
        @Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML})
        public PostRespDTO get() throws NoSuchAlgorithmException, KeyManagementException, MalformedURLException, IOException, GeneralSecurityException {

            //...object passed to the POST method...
            PostDTO requestObject = new PostDTO();
            requestObject.setEntryAList(new ArrayList<>(Arrays.asList("ITEM0000A", "ITEM0000B", "ITEM0000C")));
            requestObject.setEntryBList(new ArrayList<>(Arrays.asList("AAA", "BBB", "CCC")));

            //...build special "trust all" client to call POST method...
            ApacheHttpClient4Engine engine = new ApacheHttpClient4Engine(createTrustAllClient());

            ResteasyClient client = new ResteasyClientBuilder().httpEngine(engine).build();
            ResteasyWebTarget target = client.target("https://localhost:7002/postRespWS").path("postrespservice");
            Response response = target.request().accept(MediaType.APPLICATION_JSON).post(Entity.entity(requestObject, MediaType.APPLICATION_JSON));

            //...object returned from the POST method...
            PostRespDTO responseObject = response.readEntity(PostRespDTO.class);

            response.close();

            return responseObject;
        }


        //...get special "trust all" client...
        private static CloseableHttpClient createTrustAllClient() throws NoSuchAlgorithmException, KeyStoreException, KeyManagementException {

            SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, TRUSTALLCERTS).useProtocol("TLS").build();
            HttpClientBuilder builder = HttpClientBuilder.create();
            NoopHostnameVerifier noop = new NoopHostnameVerifier();
            SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, noop);
            builder.setSSLSocketFactory(sslConnectionSocketFactory);
            Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create().register("https", sslConnectionSocketFactory).build();
            HttpClientConnectionManager ccm = new BasicHttpClientConnectionManager(registry);
            builder.setConnectionManager(ccm);

            return builder.build();
        }


        private static final TrustStrategy TRUSTALLCERTS = new TrustStrategy() {
            @Override
            public boolean isTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
                return true;
            }
        };
    }

संबंधित मावेन निर्भरता

    <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>resteasy-client</artifactId>
        <version>3.0.10.Final</version>
    </dependency>
    <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>jaxrs-api</artifactId>
        <version>3.0.10.Final</version>
    </dependency>
    <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>resteasy-jackson2-provider</artifactId>
        <version>3.0.10.Final</version>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5</version>
        <type>jar</type>
    </dependency>
    <dependency>
        <groupId>javax</groupId>
        <artifactId>javaee-web-api</artifactId>
        <version>7.0</version>
        <scope>provided</scope>
    </dependency> 

Answer 23

यदि आप अपाचे httpClient 4.5.x का उपयोग कर रहे हैं तो यह प्रयास करें:

public static void main(String... args)  {

    try (CloseableHttpClient httpclient = createAcceptSelfSignedCertificateClient()) {
        HttpGet httpget = new HttpGet("https://example.com");
        System.out.println("Executing request " + httpget.getRequestLine());

        httpclient.execute(httpget);
        System.out.println("----------------------------------------");
    } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException | IOException e) {
        throw new RuntimeException(e);
    }
}

private static CloseableHttpClient createAcceptSelfSignedCertificateClient()
        throws KeyManagementException, NoSuchAlgorithmException, KeyStoreException {

    // use the TrustSelfSignedStrategy to allow Self Signed Certificates
    SSLContext sslContext = SSLContextBuilder
            .create()
            .loadTrustMaterial(new TrustSelfSignedStrategy())
            .build();

    // we can optionally disable hostname verification. 
    // if you don't want to further weaken the security, you don't have to include this.
    HostnameVerifier allowAllHosts = new NoopHostnameVerifier();

    // create an SSL Socket Factory to use the SSLContext with the trust self signed certificate strategy
    // and allow all hosts verifier.
    SSLConnectionSocketFactory connectionFactory = new SSLConnectionSocketFactory(sslContext, allowAllHosts);

    // finally create the HttpClient using HttpClient factory methods and assign the ssl socket factory
    return HttpClients
            .custom()
            .setSSLSocketFactory(connectionFactory)
            .build();
}