HTTPS post: bypass SSL security check and trust all the hosts

import com.eviware.soapui.model.testsuite.TestRunContext;
import javax.net.ssl.*
import java.net.URL
import java.net.URLEncoder
import java.net.CookieHandler;
import java.net.CookieManager;
 
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;

class AUTHttps {
	def dataDir = null
	def conn = null
	def sc = null
	def weguid = null
	def String weguidPrefix = "weguid"
	/* I have to set Cookie manually, so the device can receives weguid correctly.*/
	/* If ACCEPT_ALL, the device will receives weguid likes "79ffb31f54dbe461" $Path="/" $Domain="10.68.6.127" */
	def cookieManager = new CookieManager( null, CookiePolicy.ACCEPT_NONE ) 

	public AUTHttps(String dir) {
		initHttps(dir)
	}

	public AUTHttps(TestRunContext context) {
		dataDir = AUTProject.getDataDir(context)
		initHttps(dataDir)
	}

	private initHttps(String dir) {
		def nullTrustManager = [
			checkClientTrusted: { chain, authType ->  },
			checkServerTrusted: { chain, authType ->  },
			getAcceptedIssuers: { null }
		]
	
		sc = SSLContext.getInstance("SSL")
		sc.init(null, [nullTrustManager as X509TrustManager] as TrustManager[], null)
		
		// make sure cookies is turn on
		CookieHandler.setDefault(cookieManager)
		
		//System.setProperty("http.keepAlive", "true")
	}

	public HttpsURLConnection getHttpsURLConnection() {
		return conn
	}

	public String getResponseMessage() {
		if (null == conn) {
			return "null"
		}
		
		return conn.getResponseMessage()
	}

	public int post(String url, Map params) {
		def nullHostnameVerifier = [ verify: { hostname, session -> true } ]
		def postParams = ""
		if (null != params) {
			params.each{
				if ("" == postParams) {
					postParams += it.key + "=" + URLEncoder.encode(it.value, "UTF-8")
				} else {
					postParams += '&' + it.key + "=" + URLEncoder.encode(it.value, "UTF-8")
				}
			}
		}
		
		def oldConn = conn
		
		def urlObj = new URL(url)
		conn = (HttpsURLConnection)(urlObj.openConnection())
		
		System.setProperty("javax.net.ssl.trustStore", "${dataDir}/keystore")
		System.setProperty("javax.net.ssl.trustStorePassword", "cert123456")

		conn.setDefaultSSLSocketFactory(new FixedSSLSocketFactory(sc.getSocketFactory()))
		//conn.setDefaultSSLSocketFactory(sc.getSocketFactory())
		conn.setDefaultHostnameVerifier(nullHostnameVerifier as HostnameVerifier)
		
		conn.setRequestMethod("POST")
		conn.setRequestProperty("Host", urlObj.getHost())
		conn.setRequestProperty("User-Agent", "Mozilla/5.0")
		conn.setRequestProperty("DNT", "1")
		conn.setRequestProperty("Accept", "*/*")
		conn.setRequestProperty("Accept-Language", "en-US,en;q=0.5")
		conn.setRequestProperty("Accept-Encoding", "gzip, deflate")
//		conn.setRequestProperty("Connection", "Keep-Alive") this is default for https
//		conn.setRequestProperty("Connection", "Close")
		conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")	
		conn.setRequestProperty("Referer", "https://${urlObj.getHost()}/")
		conn.setRequestProperty("Content-Length", Integer.toString(postParams.length()))
		
		println("\nSending 'POST' request to URL : ${url}")
		println "http.keepAlive = " + System.getProperty("http.keepAlive").toString()

		if (null != weguid) {
			println "set cookies: ${weguidPrefix}=${weguid}"  
			conn.setRequestProperty("Cookie", "${weguidPrefix}=${weguid}")
		}

		conn.setDoOutput(true)
		conn.setDoInput(true)
		
		for (item in conn.getRequestProperties()) {
			println "${item.key}: ${item.value}"
		}
		println("Post parameters : " + postParams)

		// Send post request
		def wr = new DataOutputStream(conn.getOutputStream())
		wr.writeBytes(postParams)
		wr.flush()
		wr.close()
		
		def responseCode = conn.getResponseCode()
		println("\nRespose code: ${conn.getResponseMessage()}")
		for (item in conn.getHeaderFields()) {
			println "${item.key}: ${item.value}"
			if (item.key == "Set-Cookie") {
				def String propStr = item.value.toString().substring(1, item.value.toString().size() - 2)
				for (String str : propStr.split(";[ \t]*")) {
					//println str
					if (str.startsWith(weguidPrefix + "=")) {
						weguid = str.substring(str.indexOf(weguidPrefix + "=") + weguidPrefix.size() + 1)
						//println "${weguidPrefix}=${weguid}"
					}
				}
			}
		}
		return responseCode
	}
}

import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory

/*
 * http://stackoverflow.com/questions/6851461/java-why-does-ssl-handshake-give-could-not-generate-dh-keypair-exception
 */
class FixedSSLSocketFactory extends javax.net.ssl.SSLSocketFactory {
	def SSLSocketFactory sf = null
	def enabledCiphers = null

	public FixedSSLSocketFactory(SSLSocketFactory sf, String[] enabledCiphers) {
		super()
		this.sf = sf;
		this.enabledCiphers = enabledCiphers
	}

	public FixedSSLSocketFactory(SSLSocketFactory sf) {
		super()
		this.sf = sf;
		def excludes = ["_DHE_","_DH_"]
		def ciphers = []
		for (s in sf.getDefaultCipherSuites()) {
			def excluded = false
			for (subStr in excludes) {
				if (s.indexOf(subStr) >= 0) {
					excluded = true
				}
			}
			if (excluded == false) {
				ciphers.add(s)
			}
		}
		//println ciphers 
		this.enabledCiphers = new String[ciphers.size()]
		ciphers.toArray(this.enabledCiphers)
	}

	private Socket getSocketWithEnabledCiphers(Socket socket) {
		if (enabledCiphers != null && socket != null && socket instanceof SSLSocket)
			((SSLSocket)socket).setEnabledCipherSuites(enabledCiphers)

		return socket;
	}

	@Override
	public Socket createSocket(Socket s, String host, int port,
			boolean autoClose) throws IOException {
		return getSocketWithEnabledCiphers(sf.createSocket(s, host, port, autoClose))
	}

	@Override
	public String[] getDefaultCipherSuites() {
		return sf.getDefaultCipherSuites()
	}

	@Override
	public String[] getSupportedCipherSuites() {
		if (enabledCiphers == null)
			return sf.getSupportedCipherSuites()
		else
			return enabledCiphers;
	}

	@Override
	public Socket createSocket(String host, int port) throws IOException,
			UnknownHostException {
		return getSocketWithEnabledCiphers(sf.createSocket(host, port));
	}

	@Override
	public Socket createSocket(InetAddress address, int port)
			throws IOException {
		return getSocketWithEnabledCiphers(sf.createSocket(address, port));
	}

	@Override
	public Socket createSocket(String host, int port, InetAddress localAddress,
			int localPort) throws IOException, UnknownHostException {
		return getSocketWithEnabledCiphers(sf.createSocket(host, port, localAddress, localPort));
	}

	@Override
	public Socket createSocket(InetAddress address, int port,
			InetAddress localaddress, int localport) throws IOException {
		return getSocketWithEnabledCiphers(sf.createSocket(address, port, localaddress, localport));
	}
}