title: How to initiate handshakes in Java 8 using new GCM cipher suites
body: <p>I am very new to Java security, so the answer to this might be obvious. I am trying to perform a simple handshake between a client and a server and I want them to handshake using either TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384. According to everywhere I read these ciphers are supported in Java 8 and I have installed JCE Unlimited Strength Jurisdiction Policy Files. So when I print out all the enabled ciphers in my Java installation, those two ciphers are present, which means they are enabled by default. But for some reason the handshake fails because client and server have no cipher suites in common. I enabled TLSv1.2 protocol as well. The client's public key has been imported into the server's trust store and the handshake succeed for other ciphers such as TLS_RSA_WITH_AES_128_CBC_SHA256 etc. I am running Java 8 v1.8.0_60. What else am I missing?</p>
  
  <pre><code>import static org.junit.Assert.assertEquals;
  import java.io.IOException;
  import javax.net.ssl.SSLSession;
  import javax.net.ssl.SSLSocket;
  import javax.net.ssl.SSLSocketFactory;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import org.eclipse.jetty.server.Connector;
  import org.eclipse.jetty.server.Request;
  import org.eclipse.jetty.server.Server;
  import org.eclipse.jetty.server.handler.AbstractHandler;
  import org.eclipse.jetty.server.ssl.SslSelectChannelConnector;
  import org.eclipse.jetty.util.ssl.SslContextFactory;
  import org.junit.After;
  import org.junit.BeforeClass;
  import org.junit.Test;
  
  public class GCMCiphersJava8Test {
  
  private static final String SERVER_KEY_STORE = "testkeystore.jks";
  private static final String CLIENT_KEY_STORE = "testtruststore.jks";
  private static final String HOST = "localhost";
  private static final String PASSWORD = "Pa55word";
  private static final int SSL_PORT = 8443;
  private static final String[] TLS_12 = new String[]{"TLSv1.2"};
  private static String serverKeyStorePath = null;
  private static String clientKeyStorePath = null;
  private Server server = null;
  
  @BeforeClass
  public static void setup() {
      serverKeyStorePath = GCMCiphersJava8Test.class.getResource(SERVER_KEY_STORE).getFile();
      clientKeyStorePath = GCMCiphersJava8Test.class.getResource(CLIENT_KEY_STORE).getFile();
  }
  
  @Test
  public void testGCMCiphersInJava8() throws Exception{
  
      SSLSession session = null;
      startServer(TLS_12, null, new String[]{"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"}, null);
      SSLSocket sslSocket = createSslSocket(TLS_12, null, new String[]{"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"}, null);
  
      if (this.server.isRunning()){
          session = sslSocket.getSession();
      }
  
      assertEquals("TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", session.getCipherSuite());
  }
  
  private void startServer(String[] includeProtocols, String[] excludeProtocols, String[] includeCiphers, String[] excludeCiphers) throws Exception{
  
      this.server = new Server();
  
      SslSelectChannelConnector ssl_connector = new SslSelectChannelConnector();
      ssl_connector.setPort(SSL_PORT);
  
      SslContextFactory cf = ssl_connector.getSslContextFactory();
      cf.setKeyStorePath(serverKeyStorePath);
      cf.setKeyStorePassword(PASSWORD);
      cf.setKeyManagerPassword(PASSWORD);
  
      if (includeCiphers != null){
          cf.setIncludeCipherSuites(includeCiphers);
      }
  
      if (excludeCiphers != null){
          cf.setExcludeCipherSuites(excludeCiphers);
      }
  
      if (includeProtocols != null){
          cf.setIncludeProtocols(includeProtocols);
      }
  
      if (excludeProtocols != null){
          cf.setExcludeProtocols(excludeProtocols);
      }
  
      this.server.setConnectors(new Connector[]{ssl_connector});
  
      this.server.setHandler(new AbstractHandler() {
  
          @Override
          public void handle(String target,Request baseRequest,HttpServletRequest request, HttpServletResponse response)
              throws IOException, ServletException
          {
              response.setContentType("text/html;charset=utf-8");
              response.setStatus(HttpServletResponse.SC_OK);
              baseRequest.setHandled(true);
              response.getWriter().println("&lt;h1&gt;Hello World&lt;/h1&gt;");
          }
      });
  
      this.server.start();
  }
  
  @After
  public void stopServer() throws Exception{
      this.server.stop();
  }
  
  private SSLSocket createSslSocket(String[] includeProtocols, String[] excludeProtocols, String[] includeCiphers, String[] excludeCiphers){
  
      SSLSocket sslSocket = null;
  
      try {
  
          System.setProperty("javax.net.ssl.trustStore", clientKeyStorePath);
  
          SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault();
          sslSocket = (SSLSocket) factory.createSocket(HOST, SSL_PORT);
  
          if (includeCiphers != null){
              sslSocket.setEnabledCipherSuites(includeCiphers);
          }
  
          if (includeProtocols != null){
              sslSocket.setEnabledProtocols(includeProtocols);
          }
  
          sslSocket.addHandshakeCompletedListener(e -&gt; {
                  System.out.println("Handshake succesful!");
                  System.out.println("Using cipher suite: " + e.getCipherSuite());
          });
  
      } catch (Exception e) {
          e.printStackTrace();
      }
  
      return sslSocket;
  }
  </code></pre>
  
  <p>}</p>