httpclient模拟登陆facebook.com

第一步，导出证书。
用IE到https://login.facebook.com/login.php这个页面逛一下，用“查看证书”，点证书的“详细信息”，然后导出证书，
保存为d:/temp/test/test.cer

第二步，把证书导入到受信证书库。
在dos下面，用这2个命令：
[code=BatchFile]
D:\temp\test>keytool -import -alias "my server cert" -file test.cer -keystore my.truststore
D:\temp\test>keytool -genkey -v -alias "my client key" -validity 365 -keystore my.keystore 
-dname "CN=Equifax Secure Global eBusiness CA-1,O=Equifax Secure Inc.,C=US"
[/code]

第三步，编写代码，我是用的HC3.0版的

public class AuthSSLInitializationError extends Error {

    /**
     * 构招一个AuthSSLInitializationError实例
     */
    public AuthSSLInitializationError() {
        super();
    }

    /**
     * 用指定信息构造一个AuthSSLInitializationError实例
     * @param message
     */
    public AuthSSLInitializationError(String message) {
        super(message);
    }
}

import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.URL;
import java.net.UnknownHostException;
import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Enumeration;

import org.apache.commons.httpclient.ConnectTimeoutException;
import org.apache.commons.httpclient.params.HttpConnectionParams;
import org.apache.commons.httpclient.protocol.ControllerThreadSocketFactory;
import org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.sun.net.ssl.KeyManager;
import com.sun.net.ssl.KeyManagerFactory;
import com.sun.net.ssl.SSLContext;
import com.sun.net.ssl.TrustManager;
import com.sun.net.ssl.TrustManagerFactory;
import com.sun.net.ssl.X509TrustManager;

public class AuthSSLProtocolSocketFactory implements
		SecureProtocolSocketFactory {

	/** Log object for this class. */
	private static final Log LOG = LogFactory
			.getLog(AuthSSLProtocolSocketFactory.class);

	private URL keystoreUrl = null;
	private String keystorePassword = null;
	private URL truststoreUrl = null;
	private String truststorePassword = null;
	private SSLContext sslcontext = null;

	public AuthSSLProtocolSocketFactory(final URL keystoreUrl,
			final String keystorePassword, final URL truststoreUrl,
			final String truststorePassword) {
		super();
		this.keystoreUrl = keystoreUrl;
		this.keystorePassword = keystorePassword;
		this.truststoreUrl = truststoreUrl;
		this.truststorePassword = truststorePassword;
	}

	private static KeyStore createKeyStore(final URL url, final String password)
			throws KeyStoreException, NoSuchAlgorithmException,
			CertificateException, IOException {
		if (url == null) {
			throw new IllegalArgumentException("Keystore url may not be null");
		}
		LOG.debug("Initializing key store");
		KeyStore keystore = KeyStore.getInstance("jks");
		keystore.load(url.openStream(), password != null ? password
				.toCharArray() : null);
		return keystore;
	}

	private static KeyManager[] createKeyManagers(final KeyStore keystore,
			final String password) throws KeyStoreException,
			NoSuchAlgorithmException, UnrecoverableKeyException {
		if (keystore == null) {
			throw new IllegalArgumentException("Keystore may not be null");
		}
		LOG.debug("Initializing key manager");
		KeyManagerFactory kmfactory = KeyManagerFactory
				.getInstance(KeyManagerFactory.getDefaultAlgorithm());
		kmfactory.init(keystore, password != null ? password.toCharArray()
				: null);
		return kmfactory.getKeyManagers();
	}

	private static TrustManager[] createTrustManagers(final KeyStore keystore)
			throws KeyStoreException, NoSuchAlgorithmException {
		if (keystore == null) {
			throw new IllegalArgumentException("Keystore may not be null");
		}
		LOG.debug("Initializing trust manager");
		TrustManagerFactory tmfactory = TrustManagerFactory
				.getInstance(TrustManagerFactory.getDefaultAlgorithm());
		tmfactory.init(keystore);
		TrustManager[] trustmanagers = tmfactory.getTrustManagers();
		for (int i = 0; i < trustmanagers.length; i++) {
			if (trustmanagers[i] instanceof X509TrustManager) {
				trustmanagers[i] = new AuthSSLX509TrustManager(
						(X509TrustManager) trustmanagers[i]);
			}
		}
		return trustmanagers;
	}

	private SSLContext createSSLContext() {
		try {
			KeyManager[] keymanagers = null;
			TrustManager[] trustmanagers = null;
			if (this.keystoreUrl != null) {
				KeyStore keystore = createKeyStore(this.keystoreUrl,
						this.keystorePassword);
				if (LOG.isDebugEnabled()) {
					Enumeration aliases = keystore.aliases();
					while (aliases.hasMoreElements()) {
						String alias = (String) aliases.nextElement();
						Certificate[] certs = keystore
								.getCertificateChain(alias);
						if (certs != null) {
							LOG.debug("Certificate chain '" + alias + "':");
							for (int c = 0; c < certs.length; c++) {
								if (certs[c] instanceof X509Certificate) {
									X509Certificate cert = (X509Certificate) certs[c];
									LOG.debug(" Certificate " + (c + 1) + ":");
									LOG.debug(" Subject DN: "
											+ cert.getSubjectDN());
									LOG.debug(" Signature Algorithm: "
											+ cert.getSigAlgName());
									LOG.debug(" Valid from: "
											+ cert.getNotBefore());
									LOG.debug(" Valid until: "
											+ cert.getNotAfter());
									LOG.debug(" Issuer: " + cert.getIssuerDN());
								}
							}
						}
					}
				}
				keymanagers = createKeyManagers(keystore, this.keystorePassword);
			}

			if (this.truststoreUrl != null) {
				KeyStore keystore = createKeyStore(this.truststoreUrl,
						this.truststorePassword);
				if (LOG.isDebugEnabled()) {
					Enumeration aliases = keystore.aliases();
					while (aliases.hasMoreElements()) {
						String alias = (String) aliases.nextElement();
						LOG.debug("Trusted certificate '" + alias + "':");
						Certificate trustedcert = keystore
								.getCertificate(alias);
						if (trustedcert != null
								&& trustedcert instanceof X509Certificate) {
							X509Certificate cert = (X509Certificate) trustedcert;
							LOG.debug(" Subject DN: " + cert.getSubjectDN());
							LOG.debug(" Signature Algorithm: "
									+ cert.getSigAlgName());
							LOG.debug(" Valid from: " + cert.getNotBefore());
							LOG.debug(" Valid until: " + cert.getNotAfter());
							LOG.debug(" Issuer: " + cert.getIssuerDN());
						}
					}
				}
				trustmanagers = createTrustManagers(keystore);
			}
			SSLContext sslcontext = SSLContext.getInstance("SSL");
			sslcontext.init(keymanagers, trustmanagers, null);
			return sslcontext;
		} catch (NoSuchAlgorithmException e) {
			LOG.error(e.getMessage(), e);
			throw new AuthSSLInitializationError(
					"Unsupported algorithm exception: " + e.getMessage());
		} catch (KeyStoreException e) {
			LOG.error(e.getMessage(), e);
			throw new AuthSSLInitializationError("Keystore exception: "
					+ e.getMessage());
		} catch (GeneralSecurityException e) {
			LOG.error(e.getMessage(), e);
			throw new AuthSSLInitializationError("Key management exception: "
					+ e.getMessage());
		} catch (IOException e) {
			LOG.error(e.getMessage(), e);
			throw new AuthSSLInitializationError(
					"I/O error reading keystore/truststore file: "
							+ e.getMessage());
		}
	}

	private SSLContext getSSLContext() {
		if (this.sslcontext == null) {
			this.sslcontext = createSSLContext();
		}
		return this.sslcontext;
	}

	public Socket createSocket(final String host, final int port,
			final InetAddress localAddress, final int localPort,
			final HttpConnectionParams params) throws IOException,
			UnknownHostException, ConnectTimeoutException {
		if (params == null) {
			throw new IllegalArgumentException("Parameters may not be null");
		}
		int timeout = params.getConnectionTimeout();
		if (timeout == 0) {
			return createSocket(host, port, localAddress, localPort);
		} else {
			// To be eventually deprecated when migrated to Java 1.4 or above
			return ControllerThreadSocketFactory.createSocket(this, host, port,
					localAddress, localPort, timeout);
		}
	}

	public Socket createSocket(String host, int port, InetAddress clientHost,
			int clientPort) throws IOException, UnknownHostException {
		return getSSLContext().getSocketFactory().createSocket(host, port,
				clientHost, clientPort);
	}

	public Socket createSocket(String host, int port) throws IOException,
			UnknownHostException {
		return getSSLContext().getSocketFactory().createSocket(host, port);
	}

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

import java.security.cert.X509Certificate;

import com.sun.net.ssl.X509TrustManager;
import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory;

public class AuthSSLX509TrustManager implements X509TrustManager
{
    private X509TrustManager defaultTrustManager = null;

    /** Log object for this class. */
    private static final Log LOG = LogFactory.getLog(AuthSSLX509TrustManager.class);

    /**
     * Constructor for AuthSSLX509TrustManager.
     */
    public AuthSSLX509TrustManager(final X509TrustManager defaultTrustManager) {
        super();
        if (defaultTrustManager == null) {
            throw new IllegalArgumentException("Trust manager may not be null");
        }
        this.defaultTrustManager = defaultTrustManager;
    }

    /**
     * @see com.sun.net.ssl.X509TrustManager#isClientTrusted(X509Certificate[])
     */
    public boolean isClientTrusted(X509Certificate[] certificates) {
        if (LOG.isInfoEnabled() && certificates != null) {
            for (int c = 0; c < certificates.length; c++) {
                X509Certificate cert = certificates[c];
                LOG.info(" Client certificate " + (c + 1) + ":");
                LOG.info(" Subject DN: " + cert.getSubjectDN());
                LOG.info(" Signature Algorithm: " + cert.getSigAlgName());
                LOG.info(" Valid from: " + cert.getNotBefore() );
                LOG.info(" Valid until: " + cert.getNotAfter());
                LOG.info(" Issuer: " + cert.getIssuerDN());
            }
        }
        return this.defaultTrustManager.isClientTrusted(certificates);
    }

    /**
     * @see com.sun.net.ssl.X509TrustManager#isServerTrusted(X509Certificate[])
     */
    public boolean isServerTrusted(X509Certificate[] certificates) {
        if (LOG.isInfoEnabled() && certificates != null) {
            for (int c = 0; c < certificates.length; c++) {
                X509Certificate cert = certificates[c];
                LOG.info(" Server certificate " + (c + 1) + ":");
                LOG.info(" Subject DN: " + cert.getSubjectDN());
                LOG.info(" Signature Algorithm: " + cert.getSigAlgName());
                LOG.info(" Valid from: " + cert.getNotBefore() );
                LOG.info(" Valid until: " + cert.getNotAfter());
                LOG.info(" Issuer: " + cert.getIssuerDN());
            }
        }
        return this.defaultTrustManager.isServerTrusted(certificates);
    }

    /**
     * @see com.sun.net.ssl.X509TrustManager#getAcceptedIssuers()
     */
    public X509Certificate[] getAcceptedIssuers() {
        return this.defaultTrustManager.getAcceptedIssuers();
    }
}

import java.io.InputStream;
import java.net.URL;

import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.protocol.Protocol;

public class Test {

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

		Protocol authhttps = new Protocol("https",
				new AuthSSLProtocolSocketFactory( new URL("file:///D:/temp/test/my.keystore"), "mypassword",
				new URL("file:///D:/temp/test/my.truststore"), "mypassword"),
				443);
		HttpClient client = new HttpClient();
		client.getHostConfiguration().setHost("login.facebook.com", 443, authhttps);

		/* 只能使用相对路径 */
		GetMethod httpget = new GetMethod("/login.php");
		client.executeMethod(httpget);
		System.out.println(new String(httpget.getResponseBody(),"UTF-8"));
		PostMethod httppost=new PostMethod("https://login.facebook.com/login.php?login_attempt=1");
		httppost.setParameter("email", "[email protected]");
		httppost.setParameter("pass", "密码哦");
		httppost.setParameter("version", "1.0");
		httppost.setParameter("charset_test", "€,´,€,´,水,Д,Є");
		httppost.setParameter("charset_test", "€,´,€,´,水,Д,Є");
		httppost.setParameter("return_session", "0");
		httppost.setParameter("persistent", "1");
		httppost.setParameter("login", "登录");
		client.executeMethod(httppost);
		
		Header[] heads=httppost.getResponseHeaders();
		for (int i=0;i<heads.length;i++){
			System.out.println(i+":"+heads[i].getName()+":"+heads[i].getValue());
		}
		int i=0;
		InputStream ins=httppost.getResponseBodyAsStream();
		while ((i=ins.read())!=-1){
			System.out.print(i);
		}
		//System.out.println(new String(httppost.getResponseBody(),"UTF-8"));
	}

}