Https कनेक्शन Android


101

मैं एक https पोस्ट कर रहा हूं और मुझे ssl अपवाद का अपवाद मिल रहा है न कि विश्वसनीय सर्वर प्रमाणपत्र। अगर मैं सामान्य http करता हूं तो यह पूरी तरह से ठीक काम कर रहा है। क्या मुझे किसी तरह सर्वर सर्टिफिकेट स्वीकार करना होगा?


क्या मैं उसी का कुछ नमूना क्रियान्वयन प्राप्त कर सकता हूं
Sam97305421562

इस सूत्र में मदद मिल सकती है, लेकिन मैं नहीं बता सकता है अगर यह होगा काम करता है नवीनतम एपीआई: groups.google.com/group/android-developers/browse_thread/thread/...
RZR

जवाबों:


45

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

SchemeRegistry schemeRegistry = new SchemeRegistry ();

schemeRegistry.register (new Scheme ("http",
    PlainSocketFactory.getSocketFactory (), 80));
schemeRegistry.register (new Scheme ("https",
    new CustomSSLSocketFactory (), 443));

ThreadSafeClientConnManager cm = new ThreadSafeClientConnManager (
    params, schemeRegistry);


return new DefaultHttpClient (cm, params);

CustomSSLSocketFactory:

public class CustomSSLSocketFactory extends org.apache.http.conn.ssl.SSLSocketFactory
{
private SSLSocketFactory FACTORY = HttpsURLConnection.getDefaultSSLSocketFactory ();

public CustomSSLSocketFactory ()
    {
    super(null);
    try
        {
        SSLContext context = SSLContext.getInstance ("TLS");
        TrustManager[] tm = new TrustManager[] { new FullX509TrustManager () };
        context.init (null, tm, new SecureRandom ());

        FACTORY = context.getSocketFactory ();
        }
    catch (Exception e)
        {
        e.printStackTrace();
        }
    }

public Socket createSocket() throws IOException
{
    return FACTORY.createSocket();
}

 // TODO: add other methods like createSocket() and getDefaultCipherSuites().
 // Hint: they all just make a call to member FACTORY 
}

FullX509TrustManager एक वर्ग है जो javax.net.ssl.X509TrustManager को कार्यान्वित करता है, फिर भी कोई भी विधि वास्तव में कोई कार्य नहीं करती है, यहाँ एक नमूना प्राप्त करें

शुभ लाभ!


क्यों है फैक्ट्री वैरिएबल ??
कोडवेल्ले

1
वापसी FACTORY.createSocket (); समस्या हो रही है निर्मित सॉकेट निष्पादन पर () को शून्य पॉइंटर अपवाद दे रहा है। इसके अलावा, मैंने देखा, 2 सॉकेटफैक्टरी कक्षाएं हैं। 1. org.apache.http.conn.ssl.SSLSocketFactory और 2. javax.net.ssl.SSLSocketFactory
Codevalley

2
हाय नैट, यह मेरी स्थिति के लिए उपयोगी कुछ की तरह लग रहा है। लेकिन, मुझे CustomSSLSocketFactory बनाने के साथ कुछ समस्याएं हैं। इसे किस वर्ग को विस्तारित करना है? या इसे लागू करने के लिए कौन सा इंटरफ़ेस है? मैं के साथ प्रयोग कर रहा हूँ: javax.net.SocketFactory, javax.net.ssl.SSLSocketFactory, org.apache.http.conn.scheme.SocketFactory, जिनमें से अन्य सभी के बल लागू होने पर ... तो, सामान्य तौर पर, क्या क्या आपके कोड में प्रयुक्त वर्गों के नाम स्थान हैं? धन्यवाद। :)
सेफ्रोन

2
मेरे लिए काम नहीं करता है, मुझे एक ही नहीं विश्वसनीय सर्वर प्रमाणपत्र त्रुटि देता है।
उमर रहमान

1
मैं इस कक्षा को कैसे प्राप्त कर सकता हूंFullX509TrustManager
राजारेड्डी पोलामेडी

89

यही मैं कर रहा हूं। यह बस अब प्रमाण पत्र की जाँच नहीं करता है।

// always verify the host - dont check for certificate
final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
    public boolean verify(String hostname, SSLSession session) {
        return true;
    }
};

/**
 * Trust every server - dont check for any certificate
 */
private static void trustAllHosts() {
    // Create a trust manager that does not validate certificate chains
    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 {
        }
    } };

    // Install the all-trusting trust manager
    try {
        SSLContext sc = SSLContext.getInstance("TLS");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        HttpsURLConnection
                .setDefaultSSLSocketFactory(sc.getSocketFactory());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

तथा

    HttpURLConnection http = null;

    if (url.getProtocol().toLowerCase().equals("https")) {
        trustAllHosts();
        HttpsURLConnection https = (HttpsURLConnection) url.openConnection();
        https.setHostnameVerifier(DO_NOT_VERIFY);
        http = https;
    } else {
        http = (HttpURLConnection) url.openConnection();
    }

यह अच्छा लग रहा है! हालाँकि, मैं WebView का उपयोग कर रहा हूं, और केवल परीक्षण उद्देश्यों के लिए https सर्वर से कनेक्ट करने की आवश्यकता है। (क्लाइंट एक मेल FQDN के साथ एक प्रावधान नहीं कर सकता है, न ही वे http पर परीक्षण कर सकते हैं।) क्या WebView के दौरान इससे निपटने का कोई तरीका है? क्या मैं इस कोड को उस गतिविधि में छोड़ देता हूँ जहाँ WebView है और "यह सिर्फ काम करता है?" (शक नहीं ... ??)
जो

मैं कदम-दर-कदम उस समाधान का उपयोग करने की कोशिश कर रहा हूँ और मुझे ऐसा अपवाद मिल रहा है: 07-25 12: 35: 25.941: WARN / System.err (24383): java.lang.ClassCastException: org.apache.harmony.luni .intern.net.www.protocol.http.HttpURLConnectionImpl उस जगह पर जहाँ मैं कनेक्शन खोलने की कोशिश कर रहा हूँ ... किसी भी विचार क्यों ??
रॉबर्ट

1
हे, जैसा कि मैंने आपके द्वारा सुझाया था लेकिन मुझे इसके अपवाद मिल रहे हैं javax.net.ssl.SSLException: Received fatal alert: bad_record_mac। मैंने इसके TLSसाथ बदलने की भी कोशिश की है SSLलेकिन इससे कोई फायदा नहीं हुआ। कृपया मेरी मदद करें, धन्यवाद
devsri

40
हालांकि यह विकास के चरण के दौरान अच्छा है, आपको इस तथ्य के बारे में पता होना चाहिए कि यह किसी को भी एक यादृच्छिक SSL प्रमाणपत्र को रोककर आपके सुरक्षित कनेक्शन को MITM करने की अनुमति देता है, जो आपके कनेक्शन को अब सुरक्षित नहीं बनाता है। इस प्रश्न पर एक नज़र डालें कि इसे सही तरीके से बनाया गया है, यहाँ यह देखने के लिए कि प्रमाण पत्र कैसे प्राप्त किया जाए, और अंत में यह जानने के लिए कि इसे कैसेट में जोड़ना है।
cimnine

2
आपको इस कोड का उपयोग या अनुशंसा नहीं करनी चाहिए। यह मौलिक रूप से असुरक्षित है। आपको वास्तविक समस्या का समाधान करना चाहिए।
लोर्ने

33

इस सवाल का जवाब देने की कोशिश करते हुए मुझे एक बेहतर ट्यूटोरियल मिला। इसके साथ आपको प्रमाणपत्र जांच से समझौता करने की आवश्यकता नहीं है।

http://blog.crazybob.org/2010/02/android-trusting-ssl-certificates.html

* मैंने यह नहीं लिखा, लेकिन काम के लिए बॉब ली को धन्यवाद


4
यह एकदम सही जवाब है। मैंने एक अपडेट पोस्ट बनाई जिसमें दिखाया गया है कि गैर-सूचीबद्ध सीए से कैसे निपटें क्योंकि मुझे एक PeerCertificate त्रुटि मिल रही थी। इसे यहाँ देखें: blog.donnfelker.com/2011/06/13/…
Donn Felker

6

आप मेरे ब्लॉग लेख को भी देख सकते हैं, बहुत ही क्रेजीबोब्स के समान।

यह समाधान प्रमाणपत्र जाँच से भी समझौता नहीं करता है और बताता है कि अपने स्वयं के कीस्टोर में विश्वसनीय सिंट कैसे जोड़ें।

http://blog.antoine.li/index.php/2010/10/android-trusting-ssl-certificates/


4

http://madurangasblogs.blogspot.in/2013/08/avoiding-javaxnetsslsslpeerunverifiedex.html

सौजन्य मदुरंगा

Https का उपयोग करने वाले एप्लिकेशन को विकसित करते समय, आपके परीक्षण सर्वर में एक मान्य SSL प्रमाणपत्र नहीं होता है। या कभी-कभी वेब साइट एक स्व-हस्ताक्षरित प्रमाण पत्र का उपयोग कर रही है या वेब साइट मुफ्त एसएसएल प्रमाणपत्र का उपयोग कर रही है। इसलिए यदि आप अपाचे का उपयोग कर सर्वर से कनेक्ट करने का प्रयास करते हैं HttpClient, तो आपको एक अपवाद मिलेगा जो बताएगा कि "सहकर्मी प्रमाणित नहीं है"। यद्यपि किसी उत्पादन सॉफ़्टवेयर में सभी प्रमाणपत्रों पर भरोसा करना एक अच्छा अभ्यास नहीं है, लेकिन आपको स्थिति के अनुसार ऐसा करना पड़ सकता है। यह समाधान "सहकर्मी प्रमाणित नहीं" के कारण अपवाद को हल करता है।

लेकिन इससे पहले कि हम समाधान पर जाएं, मुझे आपको चेतावनी देनी चाहिए कि यह एक उत्पादन अनुप्रयोग के लिए एक अच्छा विचार नहीं है। यह सुरक्षा प्रमाणपत्र का उपयोग करने के उद्देश्य का उल्लंघन करेगा। इसलिए जब तक आपके पास एक अच्छा कारण नहीं है या यदि आप सुनिश्चित हैं कि इससे कोई समस्या नहीं होगी, तो इस समाधान का उपयोग न करें।

आम तौर पर आप ऐसा बनाते हैं HttpClient

HttpClient httpclient = new DefaultHttpClient();

लेकिन आपको HttpClient बनाने के तरीके को बदलना होगा।

पहले आपको एक वर्ग का विस्तार करना होगा org.apache.http.conn.ssl.SSLSocketFactory

import org.apache.http.conn.ssl.SSLSocketFactory;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

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

public class MySSLSocketFactory extends SSLSocketFactory {
         SSLContext sslContext = SSLContext.getInstance("TLS");

    public MySSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
        super(truststore);

        TrustManager tm = new X509TrustManager() {
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

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

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

        sslContext.init(null, new TrustManager[] { tm }, null);
    }

    @Override
    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
        return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
    }

    @Override
    public Socket createSocket() throws IOException {
        return sslContext.getSocketFactory().createSocket();
    }
}

फिर इस तरह एक विधि बनाएं।

public HttpClient getNewHttpClient() {
     try {
         KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
         trustStore.load(null, null);

         SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
         sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

         HttpParams params = new BasicHttpParams();
         HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
         HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);

         SchemeRegistry registry = new SchemeRegistry();
         registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
         registry.register(new Scheme("https", sf, 443));

         ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);

         return new DefaultHttpClient(ccm, params);
     } catch (Exception e) {
         return new DefaultHttpClient();
     }
}

तब आप बना सकते हैं HttpClient

HttpClient httpclient = getNewHttpClient();

यदि आप लॉगिन पेज पर पोस्ट रिक्वेस्ट भेजने की कोशिश कर रहे हैं तो बाकी कोड इस तरह होगा।

private URI url = new URI("url of the action of the form");
HttpPost httppost =  new HttpPost(url);
List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();  
nameValuePairs.add(new BasicNameValuePair("username", "user"));  
nameValuePairs.add(new BasicNameValuePair("password", "password"));
try {
    httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
    HttpResponse response = httpclient.execute(httppost);
    HttpEntity entity = response.getEntity();
    InputStream is = entity.getContent();
} catch (UnsupportedEncodingException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} catch (ClientProtocolException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

आपको InputStream में html पेज मिलता है। फिर आप लौटे html पेज से जो चाहें कर सकते हैं।

लेकिन यहां आपको एक समस्या का सामना करना पड़ेगा। यदि आप कुकीज़ का उपयोग करके सत्र का प्रबंधन करना चाहते हैं, तो आप इसे इस विधि के साथ नहीं कर पाएंगे। यदि आप कुकीज़ प्राप्त करना चाहते हैं, तो आपको इसे ब्राउज़र के माध्यम से करना होगा। तब केवल आप कुकीज़ प्राप्त करेंगे।


3

यदि आप एक StartSSL या Thawte प्रमाणपत्र का उपयोग कर रहे हैं, तो यह Froyo और पुराने संस्करणों के लिए विफल हो जाएगा। आप हर प्रमाणपत्र पर भरोसा करने के बजाय एक नए संस्करण के CAcert रिपॉजिटरी का उपयोग कर सकते हैं ।


2

इनमें से किसी ने भी मेरे लिए काम नहीं किया ( थावटे बग के रूप में अच्छी तरह से)। आखिरकार मैंने इसे एंड्रॉइड पर स्व-हस्ताक्षरित एसएसएल स्वीकृति के साथ तय किया और कस्टम एसएसएल हैंडलिंग ने एंड्रॉइड 2.2 फ्रायो पर काम करना बंद कर दिया


2

इस उत्तर में से कोई भी मेरे लिए काम नहीं करता था इसलिए यहाँ कोड है जो किसी भी प्रमाण पत्र पर भरोसा करता है।

import java.io.IOException;

    import java.net.Socket;
    import java.security.KeyManagementException;
    import java.security.KeyStoreException;
    import java.security.NoSuchAlgorithmException;
    import java.security.UnrecoverableKeyException;
    import java.security.cert.CertificateException;
    import java.security.cert.X509Certificate;

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

    import org.apache.http.client.ClientProtocolException;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.conn.scheme.PlainSocketFactory;
    import org.apache.http.conn.scheme.Scheme;
    import org.apache.http.conn.scheme.SchemeRegistry;
    import org.apache.http.conn.ssl.SSLSocketFactory;
    import org.apache.http.conn.ssl.X509HostnameVerifier;
    import org.apache.http.impl.client.DefaultHttpClient;
    import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
    import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;

    public class HttpsClientBuilder {
        public static DefaultHttpClient getBelieverHttpsClient() {

            DefaultHttpClient client = null;

            SchemeRegistry Current_Scheme = new SchemeRegistry();
            Current_Scheme.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
            try {
                Current_Scheme.register(new Scheme("https", new Naive_SSLSocketFactory(), 8443));
            } catch (KeyManagementException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (UnrecoverableKeyException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (NoSuchAlgorithmException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (KeyStoreException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            HttpParams Current_Params = new BasicHttpParams();
            int timeoutConnection = 8000;
            HttpConnectionParams.setConnectionTimeout(Current_Params, timeoutConnection);
            int timeoutSocket = 10000;
            HttpConnectionParams.setSoTimeout(Current_Params, timeoutSocket);
            ThreadSafeClientConnManager Current_Manager = new ThreadSafeClientConnManager(Current_Params, Current_Scheme);
            client = new DefaultHttpClient(Current_Manager, Current_Params);
            //HttpPost httpPost = new HttpPost(url);
            //client.execute(httpPost);

         return client;
         }

    public static class Naive_SSLSocketFactory extends SSLSocketFactory
    {
        protected SSLContext Cur_SSL_Context = SSLContext.getInstance("TLS");

        public Naive_SSLSocketFactory ()
                throws NoSuchAlgorithmException, KeyManagementException,
                KeyStoreException, UnrecoverableKeyException
        {
            super(null, null, null, null, null, (X509HostnameVerifier)null);
            Cur_SSL_Context.init(null, new TrustManager[] { new X509_Trust_Manager() }, null);
        }

        @Override
        public Socket createSocket(Socket socket, String host, int port,
                boolean autoClose) throws IOException
        {
            return Cur_SSL_Context.getSocketFactory().createSocket(socket, host, port, autoClose);
        }

        @Override
        public Socket createSocket() throws IOException
        {
            return Cur_SSL_Context.getSocketFactory().createSocket();
        }
    }

    private static class X509_Trust_Manager implements X509TrustManager
    {

        public void checkClientTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
            // TODO Auto-generated method stub

        }

        public void checkServerTrusted(X509Certificate[] chain, String authType)
                throws CertificateException {
            // TODO Auto-generated method stub

        }

        public X509Certificate[] getAcceptedIssuers() {
            // TODO Auto-generated method stub
            return null;
        }

    };
}

यह कोड URL पैटर्न के साथ ठीक काम करता है - लोकलहोस्ट: 8443 / webProject / YourService
Speise

कंस्ट्रक्टर SSLSocketFactory (नल, अशक्त, अशक्त, अशक्त, अशक्त, X509HostnameVerifier) ​​अपरिभाषित है
Michal

1

मुझे ssl प्रमाणपत्र के लिए एंड्रॉइड बारीकियों के बारे में नहीं पता है, लेकिन यह समझ में आएगा कि एंड्रॉइड बल्ले से स्व हस्ताक्षरित एसएसएल प्रमाण पत्र स्वीकार नहीं करेगा। मुझे यह पोस्ट एंड्रॉइड फ़ोरम से मिली, जो एक ही मुद्दे को संबोधित करती प्रतीत होती है: http://androidforums.com/android-applications/950-imap-self-signed-ssl-certports.html


जैसे मैंने कहा कि मुझे एंड्रॉइड बारीकियों के बारे में नहीं पता है, लेकिन मुझे लगता है कि आपको उस प्लेटफॉर्म को बताना होगा जो आपके द्वारा कनेक्ट किए जा रहे सर्वर का एसएसएल प्रमाणपत्र है। यदि आप स्व-हस्ताक्षरित प्रमाणपत्र का उपयोग कर रहे हैं जो कि मंच द्वारा मान्यता प्राप्त नहीं है। SslCertificate class संभवतः मददगार होगी: developer.android.com/reference/android/net/http/… मैं इसे बाद में खोदूंगा जब मेरे पास अधिक समय होगा।
मैटी लाइरा

1

यह एंड्रॉइड 2.x के साथ एक ज्ञात समस्या है। मैं एक सप्ताह तक इस समस्या से जूझ रहा था जब तक कि मैं निम्नलिखित प्रश्न पर नहीं आया, जो न केवल समस्या की एक अच्छी पृष्ठभूमि देता है, बल्कि किसी भी सुरक्षा छेद से रहित और प्रभावी समाधान प्रदान करता है।

एंड्रॉइड 2.3 में 'नो पीयर सर्टिफिकेट' त्रुटि लेकिन 4 में नहीं


0

किसी कारण से ऊपर httpClient के लिए बताए गए समाधान ने मेरे लिए काम नहीं किया। अंत में मैं कस्टम SSLSocketFactory वर्ग को लागू करते समय विधि को सही ढंग से ओवरराइड करके इसे काम करने में सक्षम था।

@Override
public Socket createSocket(Socket socket, String host, int port, boolean autoClose) 
                              throws IOException, UnknownHostException 
    {
    return sslFactory.createSocket(socket, host, port, autoClose);
}

@Override
public Socket createSocket() throws IOException {
    return sslFactory.createSocket();
}

इस तरह इसने मेरे लिए पूरी तरह से काम किया। आप निम्न थ्रेड पर पूर्ण कस्टम क्लास और कार्यान्वयन देख सकते हैं: http://blog.syedgakbar.com/2012/07/21/android-https-and-not-trusted-server-certificate-error/


0

मैं यह वर्ग बनाता हूं और पाया जाता हूं

package com.example.fakessl;

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.SSLSession;
import javax.net.ssl.TrustManager;

import android.util.Log;

public class CertificadoAceptar {
    private static TrustManager[] trustManagers;

    public static class _FakeX509TrustManager implements
            javax.net.ssl.X509TrustManager {
        private static final X509Certificate[] _AcceptedIssuers = new X509Certificate[] {};

        public void checkClientTrusted(X509Certificate[] arg0, String arg1)
                throws CertificateException {
        }

        public void checkServerTrusted(X509Certificate[] arg0, String arg1)
                throws CertificateException {
        }

        public boolean isClientTrusted(X509Certificate[] chain) {
            return (true);
        }

        public boolean isServerTrusted(X509Certificate[] chain) {
            return (true);
        }

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

    public static void allowAllSSL() {

        javax.net.ssl.HttpsURLConnection
                .setDefaultHostnameVerifier(new HostnameVerifier() {
                    public boolean verify(String hostname, SSLSession session) {
                        return true;
                    }
                });

        javax.net.ssl.SSLContext context = null;

        if (trustManagers == null) {
            trustManagers = new javax.net.ssl.TrustManager[] { new _FakeX509TrustManager() };
        }

        try {
            context = javax.net.ssl.SSLContext.getInstance("TLS");
            context.init(null, trustManagers, new SecureRandom());
        } catch (NoSuchAlgorithmException e) {
            Log.e("allowAllSSL", e.toString());
        } catch (KeyManagementException e) {
            Log.e("allowAllSSL", e.toString());
        }
        javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(context
                .getSocketFactory());
    }
}

आप इस सफेद कोड में

CertificadoAceptar ca = new CertificadoAceptar();
ca.allowAllSSL();
HttpsTransportSE Transport = new HttpsTransportSE("iphost or host name", 8080, "/WS/wsexample.asmx?WSDL", 30000);

0

जिन स्रोतों से मुझे अपने एडब्ल्यूएस अपाचे सर्वर पर अपने स्वयं के हस्ताक्षरित प्रमाण पत्र के साथ काम करने और एंड्रॉइड डिवाइस से HttpsURLConnection के साथ जुड़ने में मदद मिली:

SSL on aws उदाहरण -
HTTPS और SSL के साथ ssl Android सुरक्षा पर अमेज़न ट्यूटोरियल - स्वीकार करने के लिए क्लाइंट पर अपना स्वयं का विश्वास प्रबंधक बनाना आपका प्रमाणपत्र
स्व हस्ताक्षरित प्रमाण पत्र बनाना - अपने प्रमाण पत्र बनाने के लिए आसान स्क्रिप्ट

फिर मैंने निम्नलिखित कार्य किया:

  1. सुनिश्चित करें कि सर्वर https (sudo yum install -y mod24_ssl) का समर्थन करता है
  2. इस स्क्रिप्ट को एक फ़ाइल में रखें create_my_certs.sh:
#!/bin/bash
FQDN=$1

# make directories to work from
mkdir -p server/ client/ all/

# Create your very own Root Certificate Authority
openssl genrsa \
  -out all/my-private-root-ca.privkey.pem \
  2048

# Self-sign your Root Certificate Authority
# Since this is private, the details can be as bogus as you like
openssl req \
  -x509 \
  -new \
  -nodes \
  -key all/my-private-root-ca.privkey.pem \
  -days 1024 \
  -out all/my-private-root-ca.cert.pem \
  -subj "/C=US/ST=Utah/L=Provo/O=ACME Signing Authority Inc/CN=example.com"

# Create a Device Certificate for each domain,
# such as example.com, *.example.com, awesome.example.com
# NOTE: You MUST match CN to the domain name or ip address you want to use
openssl genrsa \
  -out all/privkey.pem \
  2048

# Create a request from your Device, which your Root CA will sign
openssl req -new \
  -key all/privkey.pem \
  -out all/csr.pem \
  -subj "/C=US/ST=Utah/L=Provo/O=ACME Tech Inc/CN=${FQDN}"

# Sign the request from Device with your Root CA
openssl x509 \
  -req -in all/csr.pem \
  -CA all/my-private-root-ca.cert.pem \
  -CAkey all/my-private-root-ca.privkey.pem \
  -CAcreateserial \
  -out all/cert.pem \
  -days 500

# Put things in their proper place
rsync -a all/{privkey,cert}.pem server/
cat all/cert.pem > server/fullchain.pem         # we have no intermediates in this case
rsync -a all/my-private-root-ca.cert.pem server/
rsync -a all/my-private-root-ca.cert.pem client/
  1. Daud bash create_my_certs.sh yourdomain.com
  2. प्रमाणपत्रों को सर्वर पर उनके उचित स्थान पर रखें (आप /etc/httpd/conf.d/ssl.conf में कॉन्फ़िगरेशन पा सकते हैं)। इन सभी को सेट किया जाना चाहिए:
    SSLCertificateFile
    SSLCertificateKeyFile
    SSLCertificateChainFile
    SSLCACertificateFile

  3. Httpd का उपयोग करके पुनः आरंभ sudo service httpd restartकरें और सुनिश्चित करें कि httpd प्रारंभ हुआ:
    httpd को रोक रहा है: [OK]
    प्रारंभ httpd: [OK]

  4. my-private-root-ca.certअपने Android प्रोजेक्ट एसेट फ़ोल्डर में कॉपी करें

  5. अपना ट्रस्ट मैनेजर बनाएं:

    SSLContext SSLContext;

    सर्टिफ़िकेटिंग cf = सर्टिफ़िकेट फ़्रीगेट.इनस्टेंस ("X.509"); InputStream caInput = reference.getAssets ()। Open ("my-private-root-ca.cert.pite"); प्रमाणपत्र सीए; try {ca = cf.generateCertificate (caInput); } अंत में {caInput.close (); }

      // Create a KeyStore containing our trusted CAs
      String keyStoreType = KeyStore.getDefaultType();
      KeyStore keyStore = KeyStore.getInstance(keyStoreType);
      keyStore.load(null, null);
      keyStore.setCertificateEntry("ca", ca);
    
      // Create a TrustManager that trusts the CAs in our KeyStore
      String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
      TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
      tmf.init(keyStore);
    
      // Create an SSLContext that uses our TrustManager
      SSLContext = SSLContext.getInstance("TLS");
      SSSLContext.init(null, tmf.getTrustManagers(), null);
  6. और HttpsURLConnection का उपयोग करके कनेक्शन बनाएं:

    HttpsURLConnection कनेक्शन = (HttpsURLConnection) url.openConnection (); connection.setSSLSocketFactory (SSLContext.getSocketFactory ());

  7. Thats यह, अपने https कनेक्शन की कोशिश करो।


0

संभवतः आप कुछ इस तरह की कोशिश कर सकते हैं। इससे मुझे मदद मिली

    SslContextFactory sec = new SslContextFactory();
    sec.setValidateCerts(false);
    sec.setTrustAll(true);

    org.eclipse.jetty.websocket.client.WebSocketClient client = new WebSocketClient(sec);

-1

इस विधि का उपयोग अपने HTTPClient के रूप में करें:

public static  HttpClient getNewHttpClient() {
    try {
        KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
        trustStore.load(null, null);

        SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
        sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

        HttpParams params = new BasicHttpParams();
        HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);

        SchemeRegistry registry = new SchemeRegistry();
        registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
        registry.register(new Scheme("https", sf, 443));

        ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);

        return new DefaultHttpClient(ccm, params);
    } catch (Exception e) {
        return new DefaultHttpClient();
    }
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.