[BAEL-13600] - Updated HttpClient with SSL Header article

2019-04-21 00:19:55 +05:30
parent ad3a6c4526
commit fab2df5166
25 changed files with 712 additions and 20 deletions
@@ -0,0 +1,47 @@
+package org.baeldung.client;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+import org.baeldung.client.spring.ClientConfig;
+import org.baeldung.web.dto.Foo;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+import org.springframework.web.client.ResourceAccessException;
+import org.springframework.web.client.RestTemplate;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { ClientConfig.class }, loader = AnnotationConfigContextLoader.class)
+public class ClientLiveTest {
+
+    @Autowired
+    private RestTemplate secureRestTemplate;
+
+    // tests
+
+    @Test
+    public final void whenContextIsBootstrapped_thenNoExceptions() {
+        //
+    }
+
+    @Test
+    public final void whenSecuredRestApiIsConsumed_then200OK() {
+        final ResponseEntity<Foo> responseEntity = secureRestTemplate.exchange("http://localhost:8082/httpclient-simple/api/foos/1", HttpMethod.GET, null, Foo.class);
+        assertThat(responseEntity.getStatusCode().value(), is(200));
+    }
+
+    @Test(expected = ResourceAccessException.class)
+    public final void whenHttpsUrlIsConsumed_thenException() {
+        final String urlOverHttps = "https://localhost:8443/httpclient-simple/api/bars/1";
+        final ResponseEntity<String> response = new RestTemplate().exchange(urlOverHttps, HttpMethod.GET, null, String.class);
+        assertThat(response.getStatusCode().value(), equalTo(200));
+    }
+
+}
@@ -0,0 +1,108 @@
+package org.baeldung.client;
+
+import static org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.cert.X509Certificate;
+
+import javax.net.ssl.SSLContext;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.config.Registry;
+import org.apache.http.config.RegistryBuilder;
+import org.apache.http.conn.scheme.Scheme;
+import org.apache.http.conn.socket.ConnectionSocketFactory;
+import org.apache.http.conn.socket.PlainConnectionSocketFactory;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
+import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
+import org.apache.http.conn.ssl.SSLSocketFactory;
+import org.apache.http.conn.ssl.TrustStrategy;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
+import org.apache.http.ssl.SSLContexts;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * This test requires a localhost server over HTTPS <br>
+ * It should only be manually run, not part of the automated build
+ * */
+public class RestClientLiveManualTest {
+
+    final String urlOverHttps = "http://localhost:8082/httpclient-simple/api/bars/1";
+
+    // tests
+
+    // old httpClient will throw UnsupportedOperationException
+    @Ignore
+    @Test
+    public final void givenAcceptingAllCertificates_whenHttpsUrlIsConsumed_thenException_1() throws GeneralSecurityException {
+        final HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
+        final CloseableHttpClient httpClient = (CloseableHttpClient) requestFactory.getHttpClient();
+
+        final TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
+            @Override
+            public final boolean isTrusted(final X509Certificate[] certificate, final String authType) {
+                return true;
+            }
+        };
+        final SSLSocketFactory sf = new SSLSocketFactory(acceptingTrustStrategy, ALLOW_ALL_HOSTNAME_VERIFIER);
+        httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 8443, sf));
+
+        final ResponseEntity<String> response = new RestTemplate(requestFactory).exchange(urlOverHttps, HttpMethod.GET, null, String.class);
+        assertThat(response.getStatusCode().value(), equalTo(200));
+    }
+    
+    // new httpClient : 4.4 and above
+    @Test
+    public final void givenAcceptingAllCertificates_whenHttpsUrlIsConsumed_thenException_2() throws GeneralSecurityException {
+
+        final TrustStrategy acceptingTrustStrategy = (cert, authType) -> true;
+        final SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
+        final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
+        final Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create()
+                .register("https", sslsf)
+                .register("http", new PlainConnectionSocketFactory())
+                .build();
+
+        final BasicHttpClientConnectionManager connectionManager = new BasicHttpClientConnectionManager(socketFactoryRegistry);
+        final CloseableHttpClient httpClient = HttpClients.custom()
+                .setSSLSocketFactory(sslsf)
+                .setConnectionManager(connectionManager)
+                .build();
+
+        final HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
+        final ResponseEntity<String> response = new RestTemplate(requestFactory).exchange(urlOverHttps, HttpMethod.GET, null, String.class);
+        assertThat(response.getStatusCode().value(), equalTo(200));
+    }
+
+    @Test
+    public final void givenAcceptingAllCertificatesUsing4_4_whenHttpsUrlIsConsumed_thenCorrect() throws ClientProtocolException, IOException {
+        final CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
+
+        final HttpGet getMethod = new HttpGet(urlOverHttps);
+        final HttpResponse response = httpClient.execute(getMethod);
+        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
+    }
+
+    @Test
+    public final void givenAcceptingAllCertificatesUsing4_4_whenHttpsUrlIsConsumedUsingRestTemplate_thenCorrect() throws ClientProtocolException, IOException {
+        final CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
+        final HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
+        requestFactory.setHttpClient(httpClient);
+
+        final ResponseEntity<String> response = new RestTemplate(requestFactory).exchange(urlOverHttps, HttpMethod.GET, null, String.class);
+        assertThat(response.getStatusCode().value(), equalTo(200));
+    }
+
+}
@@ -0,0 +1,137 @@
+package org.baeldung.httpclient;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLHandshakeException;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.config.Registry;
+import org.apache.http.config.RegistryBuilder;
+import org.apache.http.conn.socket.ConnectionSocketFactory;
+import org.apache.http.conn.ssl.NoopHostnameVerifier;
+import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
+import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
+import org.apache.http.conn.ssl.TrustStrategy;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import org.apache.http.ssl.SSLContextBuilder;
+import org.apache.http.ssl.SSLContexts;
+import org.junit.Test;
+
+/**
+ * This test requires a localhost server over HTTPS <br>
+ * It should only be manually run, not part of the automated build
+ * */
+public class HttpsClientSslLiveTest {
+
+    // "https://localhost:8443/spring-security-rest-basic-auth/api/bars/1" // local
+    // "https://mms.nw.ru/" // hosted
+    private static final String HOST_WITH_SSL = "https://mms.nw.ru/";
+
+    // tests
+
+    @Test(expected = SSLHandshakeException.class)
+    public final void whenHttpsUrlIsConsumed_thenException() throws IOException {
+        final CloseableHttpClient httpClient = HttpClientBuilder.create()
+            .build();
+
+        final HttpGet getMethod = new HttpGet(HOST_WITH_SSL);
+        final HttpResponse response = httpClient.execute(getMethod);
+        assertThat(response.getStatusLine()
+            .getStatusCode(), equalTo(200));
+    }
+
+    @Test
+    public final void givenHttpClientPre4_3_whenAcceptingAllCertificates_thenCanConsumeHttpsUriWithSelfSignedCertificate() throws IOException, GeneralSecurityException {
+        final TrustStrategy acceptingTrustStrategy = (certificate, authType) -> true;
+        
+        final SSLContext sslContext = SSLContexts.custom()
+                .loadTrustMaterial(null, acceptingTrustStrategy)
+                .build();
+
+        final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
+        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create().register("https", sslsf).build();
+        PoolingHttpClientConnectionManager clientConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
+
+        final CloseableHttpClient httpClient = HttpClients.custom()
+                .setSSLSocketFactory(sslsf)
+                .setConnectionManager(clientConnectionManager)
+                .build();
+
+        final HttpGet getMethod = new HttpGet(HOST_WITH_SSL);
+        final HttpResponse response = httpClient.execute(getMethod);
+        assertThat(response.getStatusLine()
+            .getStatusCode(), equalTo(200));
+
+        httpClient.close();
+    }
+
+    @Test
+    public final void givenHttpClientAfter4_3_whenAcceptingAllCertificates_thenCanConsumeHttpsUriWithSelfSignedCertificate() throws IOException, GeneralSecurityException {
+        final TrustStrategy acceptingTrustStrategy = (certificate, authType) -> true;
+        final SSLContext sslContext = SSLContexts.custom()
+            .loadTrustMaterial(null, acceptingTrustStrategy)
+            .build();
+
+        final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
+
+        final CloseableHttpClient httpClient = HttpClients.custom()
+            .setSSLSocketFactory(sslsf)
+            .build();
+
+        final HttpGet getMethod = new HttpGet(HOST_WITH_SSL);
+        final HttpResponse response = httpClient.execute(getMethod);
+        assertThat(response.getStatusLine()
+            .getStatusCode(), equalTo(200));
+
+        httpClient.close();
+    }
+
+    @Test
+    public final void givenHttpClientPost4_3_whenAcceptingAllCertificates_thenCanConsumeHttpsUriWithSelfSignedCertificate() throws IOException, GeneralSecurityException {
+        final SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustSelfSignedStrategy())
+            .build();
+        final NoopHostnameVerifier hostnameVerifier = new NoopHostnameVerifier();
+
+        final SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
+        final CloseableHttpClient httpClient = HttpClients.custom()
+            .setSSLHostnameVerifier(hostnameVerifier)
+            .setSSLSocketFactory(sslsf)
+            .build();
+
+        // new
+
+        final HttpGet getMethod = new HttpGet(HOST_WITH_SSL);
+        final HttpResponse response = httpClient.execute(getMethod);
+        assertThat(response.getStatusLine()
+            .getStatusCode(), equalTo(200));
+        httpClient.close();
+
+    }
+
+    @Test
+    public final void givenIgnoringCertificates_whenHttpsUrlIsConsumed_thenCorrect() throws Exception {
+        final SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, (certificate, authType) -> true)
+            .build();
+
+        final CloseableHttpClient client = HttpClients.custom()
+            .setSSLContext(sslContext)
+            .setSSLHostnameVerifier(new NoopHostnameVerifier())
+            .build();
+        final HttpGet httpGet = new HttpGet(HOST_WITH_SSL);
+        httpGet.setHeader("Accept", "application/xml");
+
+        final HttpResponse response = client.execute(httpGet);
+        assertThat(response.getStatusLine()
+            .getStatusCode(), equalTo(200));
+    }
+
+}
@@ -0,0 +1,16 @@
+package org.baeldung.test;
+
+import org.baeldung.client.ClientLiveTest;
+import org.baeldung.client.RestClientLiveManualTest;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+// @formatter:off
+    RestClientLiveManualTest.class
+    ,ClientLiveTest.class
+}) //
+public class LiveTestSuite {
+
+}