मैं एक https पोस्ट कर रहा हूं और मुझे ssl अपवाद का अपवाद मिल रहा है न कि विश्वसनीय सर्वर प्रमाणपत्र। अगर मैं सामान्य http करता हूं तो यह पूरी तरह से ठीक काम कर रहा है। क्या मुझे किसी तरह सर्वर सर्टिफिकेट स्वीकार करना होगा?
मैं एक https पोस्ट कर रहा हूं और मुझे ssl अपवाद का अपवाद मिल रहा है न कि विश्वसनीय सर्वर प्रमाणपत्र। अगर मैं सामान्य http करता हूं तो यह पूरी तरह से ठीक काम कर रहा है। क्या मुझे किसी तरह सर्वर सर्टिफिकेट स्वीकार करना होगा?
जवाबों:
मैं एक अनुमान लगा रहा हूं, लेकिन अगर आप चाहते हैं कि वास्तविक हैंडशेक हो, तो आपको अपने प्रमाण पत्र के बारे में बताना होगा। यदि आप बस किसी भी बात को स्वीकार नहीं करना चाहते हैं, तो अपाचे 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 को कार्यान्वित करता है, फिर भी कोई भी विधि वास्तव में कोई कार्य नहीं करती है, यहाँ एक नमूना प्राप्त करें ।
शुभ लाभ!
FullX509TrustManager
यही मैं कर रहा हूं। यह बस अब प्रमाण पत्र की जाँच नहीं करता है।
// 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();
}
javax.net.ssl.SSLException: Received fatal alert: bad_record_mac
। मैंने इसके TLS
साथ बदलने की भी कोशिश की है SSL
लेकिन इससे कोई फायदा नहीं हुआ। कृपया मेरी मदद करें, धन्यवाद
इस सवाल का जवाब देने की कोशिश करते हुए मुझे एक बेहतर ट्यूटोरियल मिला। इसके साथ आपको प्रमाणपत्र जांच से समझौता करने की आवश्यकता नहीं है।
http://blog.crazybob.org/2010/02/android-trusting-ssl-certificates.html
* मैंने यह नहीं लिखा, लेकिन काम के लिए बॉब ली को धन्यवाद
आप मेरे ब्लॉग लेख को भी देख सकते हैं, बहुत ही क्रेजीबोब्स के समान।
यह समाधान प्रमाणपत्र जाँच से भी समझौता नहीं करता है और बताता है कि अपने स्वयं के कीस्टोर में विश्वसनीय सिंट कैसे जोड़ें।
http://blog.antoine.li/index.php/2010/10/android-trusting-ssl-certificates/
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 पेज से जो चाहें कर सकते हैं।
लेकिन यहां आपको एक समस्या का सामना करना पड़ेगा। यदि आप कुकीज़ का उपयोग करके सत्र का प्रबंधन करना चाहते हैं, तो आप इसे इस विधि के साथ नहीं कर पाएंगे। यदि आप कुकीज़ प्राप्त करना चाहते हैं, तो आपको इसे ब्राउज़र के माध्यम से करना होगा। तब केवल आप कुकीज़ प्राप्त करेंगे।
यदि आप एक StartSSL या Thawte प्रमाणपत्र का उपयोग कर रहे हैं, तो यह Froyo और पुराने संस्करणों के लिए विफल हो जाएगा। आप हर प्रमाणपत्र पर भरोसा करने के बजाय एक नए संस्करण के CAcert रिपॉजिटरी का उपयोग कर सकते हैं ।
इनमें से किसी ने भी मेरे लिए काम नहीं किया ( थावटे बग के रूप में अच्छी तरह से)। आखिरकार मैंने इसे एंड्रॉइड पर स्व-हस्ताक्षरित एसएसएल स्वीकृति के साथ तय किया और कस्टम एसएसएल हैंडलिंग ने एंड्रॉइड 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;
}
};
}
मुझे ssl प्रमाणपत्र के लिए एंड्रॉइड बारीकियों के बारे में नहीं पता है, लेकिन यह समझ में आएगा कि एंड्रॉइड बल्ले से स्व हस्ताक्षरित एसएसएल प्रमाण पत्र स्वीकार नहीं करेगा। मुझे यह पोस्ट एंड्रॉइड फ़ोरम से मिली, जो एक ही मुद्दे को संबोधित करती प्रतीत होती है: http://androidforums.com/android-applications/950-imap-self-signed-ssl-certports.html
यह एंड्रॉइड 2.x के साथ एक ज्ञात समस्या है। मैं एक सप्ताह तक इस समस्या से जूझ रहा था जब तक कि मैं निम्नलिखित प्रश्न पर नहीं आया, जो न केवल समस्या की एक अच्छी पृष्ठभूमि देता है, बल्कि किसी भी सुरक्षा छेद से रहित और प्रभावी समाधान प्रदान करता है।
एंड्रॉइड 2.3 में 'नो पीयर सर्टिफिकेट' त्रुटि लेकिन 4 में नहीं
किसी कारण से ऊपर 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/
मैं यह वर्ग बनाता हूं और पाया जाता हूं
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);
जिन स्रोतों से मुझे अपने एडब्ल्यूएस अपाचे सर्वर पर अपने स्वयं के हस्ताक्षरित प्रमाण पत्र के साथ काम करने और एंड्रॉइड डिवाइस से HttpsURLConnection के साथ जुड़ने में मदद मिली:
SSL on aws उदाहरण -
HTTPS और SSL के साथ ssl Android सुरक्षा पर अमेज़न ट्यूटोरियल - स्वीकार करने के लिए क्लाइंट पर अपना स्वयं का विश्वास प्रबंधक बनाना आपका प्रमाणपत्र
स्व हस्ताक्षरित प्रमाण पत्र बनाना - अपने प्रमाण पत्र बनाने के लिए आसान स्क्रिप्ट
फिर मैंने निम्नलिखित कार्य किया:
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/
bash create_my_certs.sh yourdomain.com
प्रमाणपत्रों को सर्वर पर उनके उचित स्थान पर रखें (आप /etc/httpd/conf.d/ssl.conf में कॉन्फ़िगरेशन पा सकते हैं)। इन सभी को सेट किया जाना चाहिए:
SSLCertificateFile
SSLCertificateKeyFile
SSLCertificateChainFile
SSLCACertificateFile
Httpd का उपयोग करके पुनः आरंभ sudo service httpd restart
करें और सुनिश्चित करें कि httpd प्रारंभ हुआ:
httpd को रोक रहा है: [OK]
प्रारंभ httpd: [OK]
my-private-root-ca.cert
अपने Android प्रोजेक्ट एसेट फ़ोल्डर में कॉपी करें
अपना ट्रस्ट मैनेजर बनाएं:
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);
और HttpsURLConnection का उपयोग करके कनेक्शन बनाएं:
HttpsURLConnection कनेक्शन = (HttpsURLConnection) url.openConnection (); connection.setSSLSocketFactory (SSLContext.getSocketFactory ());
Thats यह, अपने https कनेक्शन की कोशिश करो।
इस विधि का उपयोग अपने 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();
}
}