Examples with SSLContext javax.net.ssl.SSLContext used on opensource projects

Example 66 with SSLContext

use of javax.net.ssl.SSLContext in project jetty.project by eclipse.

the class ConnectHandlerSSLTest method wrapSocket.

private SSLSocket wrapSocket(Socket socket) throws Exception {
    SSLContext sslContext = sslContextFactory.getSslContext();
    SSLSocketFactory socketFactory = sslContext.getSocketFactory();
    SSLSocket sslSocket = (SSLSocket) socketFactory.createSocket(socket, socket.getInetAddress().getHostAddress(), socket.getPort(), true);
    sslSocket.setUseClientMode(true);
    sslSocket.startHandshake();
    return sslSocket;
}

Example 67 with SSLContext

use of javax.net.ssl.SSLContext in project jetty.project by eclipse.

the class SslContextFactoryReloadTest method testReloadWhileServing.

@Test
public void testReloadWhileServing() throws Exception {
    start(new EchoHandler());
    Scheduler scheduler = new ScheduledExecutorScheduler();
    scheduler.start();
    try {
        SSLContext ctx = SSLContext.getInstance("TLSv1.2");
        ctx.init(null, SslContextFactory.TRUST_ALL_CERTS, null);
        SSLSocketFactory socketFactory = ctx.getSocketFactory();
        // Perform 4 reloads while connections are being served.
        AtomicInteger reloads = new AtomicInteger(4);
        long reloadPeriod = 500;
        AtomicBoolean running = new AtomicBoolean(true);
        scheduler.schedule(new Runnable() {

            @Override
            public void run() {
                if (reloads.decrementAndGet() == 0) {
                    running.set(false);
                } else {
                    try {
                        sslContextFactory.reload(sslContextFactory -> {
                            if (sslContextFactory.getKeyStorePath().endsWith(KEYSTORE_1))
                                sslContextFactory.setKeyStorePath(KEYSTORE_2);
                            else
                                sslContextFactory.setKeyStorePath(KEYSTORE_1);
                        });
                        scheduler.schedule(this, reloadPeriod, TimeUnit.MILLISECONDS);
                    } catch (Exception x) {
                        running.set(false);
                        reloads.set(-1);
                    }
                }
            }
        }, reloadPeriod, TimeUnit.MILLISECONDS);
        byte[] content = new byte[16 * 1024];
        while (running.get()) {
            try (SSLSocket client = (SSLSocket) socketFactory.createSocket("localhost", connector.getLocalPort())) {
                // We need to invalidate the session every time we open a new SSLSocket.
                // This is because when the client uses session resumption, it caches
                // the server certificates and then checks that it is the same during
                // a new TLS handshake. If the SslContextFactory is reloaded during the
                // TLS handshake, the client will see the new certificate and blow up.
                // Note that browsers can handle this case better: they will just not
                // use session resumption and fallback to the normal TLS handshake.
                client.getSession().invalidate();
                String request1 = "" + "POST / HTTP/1.1\r\n" + "Host: localhost\r\n" + "Content-Length: " + content.length + "\r\n" + "\r\n";
                OutputStream outputStream = client.getOutputStream();
                outputStream.write(request1.getBytes(StandardCharsets.UTF_8));
                outputStream.write(content);
                outputStream.flush();
                InputStream inputStream = client.getInputStream();
                HttpTester.Response response1 = HttpTester.parseResponse(HttpTester.from(inputStream));
                Assert.assertNotNull(response1);
                Assert.assertThat(response1.getStatus(), Matchers.equalTo(HttpStatus.OK_200));
                String request2 = "" + "GET / HTTP/1.1\r\n" + "Host: localhost\r\n" + "Connection: close\r\n" + "\r\n";
                outputStream.write(request2.getBytes(StandardCharsets.UTF_8));
                outputStream.flush();
                HttpTester.Response response2 = HttpTester.parseResponse(HttpTester.from(inputStream));
                Assert.assertNotNull(response2);
                Assert.assertThat(response2.getStatus(), Matchers.equalTo(HttpStatus.OK_200));
            }
        }
        Assert.assertEquals(0, reloads.get());
    } finally {
        scheduler.stop();
    }
}

Example 68 with SSLContext

use of javax.net.ssl.SSLContext in project jetty.project by eclipse.

the class SslContextFactoryReloadTest method testReload.

@Test
public void testReload() throws Exception {
    start(new EchoHandler());
    SSLContext ctx = SSLContext.getInstance("TLSv1.2");
    ctx.init(null, SslContextFactory.TRUST_ALL_CERTS, null);
    SSLSocketFactory socketFactory = ctx.getSocketFactory();
    try (SSLSocket client1 = (SSLSocket) socketFactory.createSocket("localhost", connector.getLocalPort())) {
        String serverDN1 = client1.getSession().getPeerPrincipal().getName();
        Assert.assertThat(serverDN1, Matchers.startsWith("CN=localhost1"));
        String request = "" + "GET / HTTP/1.1\r\n" + "Host: localhost\r\n" + "\r\n";
        OutputStream output1 = client1.getOutputStream();
        output1.write(request.getBytes(StandardCharsets.UTF_8));
        output1.flush();
        HttpTester.Response response1 = HttpTester.parseResponse(HttpTester.from(client1.getInputStream()));
        Assert.assertNotNull(response1);
        Assert.assertThat(response1.getStatus(), Matchers.equalTo(HttpStatus.OK_200));
        // Reconfigure SslContextFactory.
        sslContextFactory.reload(sslContextFactory -> {
            sslContextFactory.setKeyStorePath(KEYSTORE_2);
            sslContextFactory.setKeyStorePassword("storepwd");
        });
        // New connection should use the new keystore.
        try (SSLSocket client2 = (SSLSocket) socketFactory.createSocket("localhost", connector.getLocalPort())) {
            String serverDN2 = client2.getSession().getPeerPrincipal().getName();
            Assert.assertThat(serverDN2, Matchers.startsWith("CN=localhost2"));
            OutputStream output2 = client1.getOutputStream();
            output2.write(request.getBytes(StandardCharsets.UTF_8));
            output2.flush();
            HttpTester.Response response2 = HttpTester.parseResponse(HttpTester.from(client1.getInputStream()));
            Assert.assertNotNull(response2);
            Assert.assertThat(response2.getStatus(), Matchers.equalTo(HttpStatus.OK_200));
        }
        // Must still be possible to make requests with the first connection.
        output1.write(request.getBytes(StandardCharsets.UTF_8));
        output1.flush();
        response1 = HttpTester.parseResponse(HttpTester.from(client1.getInputStream()));
        Assert.assertNotNull(response1);
        Assert.assertThat(response1.getStatus(), Matchers.equalTo(HttpStatus.OK_200));
    }
}

Example 69 with SSLContext

use of javax.net.ssl.SSLContext in project jetty.project by eclipse.

the class SslUploadTest method test.

@Test
@Ignore
public void test() throws Exception {
    KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
    SslContextFactory ctx = connector.getConnectionFactory(SslConnectionFactory.class).getSslContextFactory();
    try (InputStream stream = new FileInputStream(ctx.getKeyStorePath())) {
        keystore.load(stream, "storepwd".toCharArray());
    }
    TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
    trustManagerFactory.init(keystore);
    SSLContext sslContext = SSLContext.getInstance("SSL");
    sslContext.init(null, trustManagerFactory.getTrustManagers(), null);
    final SSLSocket socket = (SSLSocket) sslContext.getSocketFactory().createSocket("localhost", connector.getLocalPort());
    // Simulate async close
    /*
        new Thread()
        {
            @Override
            public void run()
            {
                try
                {
                    sleep(100);
                    socket.close();
                }
                catch (IOException x)
                {
                    x.printStackTrace();
                }
                catch (InterruptedException x)
                {
                    Thread.currentThread().interrupt();
                }
            }
        }.start();
        */
    long start = System.nanoTime();
    OutputStream out = socket.getOutputStream();
    out.write("POST / HTTP/1.1\r\n".getBytes());
    out.write("Host: localhost\r\n".getBytes());
    out.write("Content-Length: 16777216\r\n".getBytes());
    out.write("Content-Type: bytes\r\n".getBytes());
    out.write("Connection: close\r\n".getBytes());
    out.write("\r\n".getBytes());
    out.flush();
    byte[] requestContent = new byte[16777216];
    Arrays.fill(requestContent, (byte) 120);
    out.write(requestContent);
    out.flush();
    InputStream in = socket.getInputStream();
    String response = IO.toString(in);
    assertTrue(response.indexOf("200") > 0);
    // System.err.println(response);
    // long end = System.nanoTime();
    // System.out.println("upload time: " + TimeUnit.NANOSECONDS.toMillis(end - start));
    assertEquals(requestContent.length, total);
}

Example 70 with SSLContext

use of javax.net.ssl.SSLContext in project jetty.project by eclipse.

the class SSLCloseTest method testClose.

@Test
public void testClose() throws Exception {
    File keystore = MavenTestingUtils.getTestResourceFile("keystore");
    SslContextFactory sslContextFactory = new SslContextFactory();
    sslContextFactory.setKeyStoreResource(Resource.newResource(keystore));
    sslContextFactory.setKeyStorePassword("storepwd");
    sslContextFactory.setKeyManagerPassword("keypwd");
    Server server = new Server();
    ServerConnector connector = new ServerConnector(server, sslContextFactory);
    connector.setPort(0);
    server.addConnector(connector);
    server.setHandler(new WriteHandler());
    server.start();
    SSLContext ctx = SSLContext.getInstance("TLSv1.2");
    ctx.init(null, SslContextFactory.TRUST_ALL_CERTS, new java.security.SecureRandom());
    int port = connector.getLocalPort();
    Socket socket = ctx.getSocketFactory().createSocket("localhost", port);
    OutputStream os = socket.getOutputStream();
    os.write(("GET /test HTTP/1.1\r\n" + "Host:test\r\n" + "Connection:close\r\n\r\n").getBytes());
    os.flush();
    BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    String line;
    while ((line = in.readLine()) != null) {
        if (line.trim().length() == 0)
            break;
    }
    Thread.sleep(2000);
    while (in.readLine() != null) Thread.yield();
}