Synnefo » Pithos Android Client

package com.rackspace.cloud.files.api.client;

import java.io.IOException;

import java.io.InputStream;

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.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.conn.ClientConnectionManager;

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.impl.client.DefaultHttpClient;

import org.apache.http.impl.conn.SingleClientConnManager;

import android.content.Context;

import com.rackspace.cloud.android.R;

/**

 * 

 * @author Chmouel Boudjnah <chmouel.boudjnah@rackspace.co.uk>

 * 

 *         Custom implementation of HTTPClient using the keystore (in bks

 *         format) from android 2.3.1 which allow us to connect to London

 *         CloudFiles SSL host which doesn't work with the default keystore in

 *         other version than 2.3.1.

 */

public class CustomHttpClient extends DefaultHttpClient {

        public static final String X_AUTH_TOKEN = "X-Auth-Token";

        public static final String X_STORAGE_TOKEN = "X-Auth-Token";

        private static KeyStore trusted;

        final Context context;

        public CustomHttpClient(Context context) {

                super();

                this.context = context;

        }

        @Override

        protected ClientConnectionManager createClientConnectionManager() {

                SchemeRegistry registry = new SchemeRegistry();

                registry.register(new Scheme("http", PlainSocketFactory

                                .getSocketFactory(), 80));

                try {

                        KeyStore trustStore = KeyStore.getInstance(KeyStore

                                        .getDefaultType());

                        trustStore.load(null, null);

                        SSLSocketFactory sf = new MySSLSocketFactory(trustStore);

                        sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

                        registry.register(new Scheme("https", sf,// newSslSocketFactory(),

                                        443));

                        ClientConnectionManager m = new SingleClientConnManager(

                                        getParams(), registry);

                        return m;

                } catch (Exception e) {

                        throw new IllegalStateException(e);

                }

        }

        private SSLSocketFactory newSslSocketFactory() {

                try {

                        if (trusted == null) {

                                trusted = KeyStore.getInstance("BKS");

                                InputStream in = context.getResources().openRawResource(

                                                R.raw.mystore);

                                try {

                                        trusted.load(in, "ez24get".toCharArray());

                                } finally {

                                        in.close();

                                }

                        }

                        return new SSLSocketFactory(trusted);

                } catch (Exception e) {

                        throw new AssertionError(e);

                }

        }

        final static HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {

                public boolean verify(String hostname, SSLSession session) {

                        return true;

                }

        };

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

                }

        }

}