import java.io.InputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.KeyStore;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLParameters;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManagerFactory;

public class TlsIdentityDemo {
    public static void main(String[] args) throws Exception {
        Path directory = Files.createTempDirectory("kb-tls-identity-");
        Path store = directory.resolve("server.p12");
        Path log = directory.resolve("keytool.log");
        char[] password = "demo-only-password".toCharArray();
        try {
            String binary = System.getProperty("os.name").startsWith("Windows") ? "keytool.exe" : "keytool";
            Process keytool = new ProcessBuilder(Path.of(System.getProperty("java.home"), "bin", binary).toString(),
                    "-genkeypair", "-alias", "server", "-keyalg", "RSA", "-keysize", "2048", "-validity", "2",
                    "-dname", "CN=localhost", "-ext", "SAN=dns:localhost", "-storetype", "PKCS12",
                    "-keystore", store.toString(), "-storepass", new String(password), "-noprompt")
                    .redirectErrorStream(true).redirectOutput(log.toFile()).start();
            try {
                if (!keytool.waitFor(45, TimeUnit.SECONDS)) throw new IllegalStateException("keytool timeout");
                if (keytool.exitValue() != 0) throw new IllegalStateException("keytool failed: " + Files.readString(log));
            } finally {
                if (keytool.isAlive()) {
                    keytool.destroyForcibly();
                    keytool.waitFor();
                }
            }
            KeyStore keys = KeyStore.getInstance("PKCS12");
            try (InputStream input = Files.newInputStream(store)) { keys.load(input, password); }
            KeyManagerFactory managers = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            managers.init(keys, password);
            SSLContext serverContext = SSLContext.getInstance("TLS");
            serverContext.init(managers.getKeyManagers(), null, null);
            KeyStore trust = KeyStore.getInstance("PKCS12");
            trust.load(null, null);
            trust.setCertificateEntry("demo-trust-anchor", keys.getCertificate("server"));
            TrustManagerFactory trusted = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trusted.init(trust);
            SSLContext trustedContext = SSLContext.getInstance("TLS");
            trustedContext.init(null, trusted.getTrustManagers(), null);
            KeyStore emptyTrust = KeyStore.getInstance("PKCS12");
            emptyTrust.load(null, null);
            TrustManagerFactory untrusted = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            untrusted.init(emptyTrust);
            SSLContext untrustedContext = SSLContext.getInstance("TLS");
            untrustedContext.init(null, untrusted.getTrustManagers(), null);
            run(serverContext, trustedContext, untrustedContext);
        } finally {
            Files.deleteIfExists(store);
            Files.deleteIfExists(log);
            Files.deleteIfExists(directory);
        }
    }

    private static void run(SSLContext serverContext, SSLContext trusted, SSLContext untrusted) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        try (SSLServerSocket listener = (SSLServerSocket) serverContext.getServerSocketFactory().createServerSocket()) {
            listener.bind(new InetSocketAddress("127.0.0.1", 0));
            listener.setSoTimeout(5000);
            Future<?> serving = executor.submit(() -> {
                try {
                    for (int index = 0; index < 3; index++) {
                        try (SSLSocket socket = (SSLSocket) listener.accept()) {
                            socket.setSoTimeout(5000);
                            socket.startHandshake();
                            if (socket.getInputStream().read() != 42) throw new IllegalStateException("request mismatch");
                            socket.getOutputStream().write(43);
                        } catch (IOException expectedPeerFailure) {
                            System.out.println("server observed peer IO failure=" + expectedPeerFailure.getClass().getSimpleName());
                        }
                    }
                } catch (Exception failure) { throw new IllegalStateException(failure); }
            });
            probe(trusted, listener.getLocalPort(), "localhost", true);
            probe(trusted, listener.getLocalPort(), "127.0.0.1", false);
            probe(untrusted, listener.getLocalPort(), "localhost", false);
            serving.get(20, TimeUnit.SECONDS);
        } finally {
            executor.shutdownNow();
            if (!executor.awaitTermination(6, TimeUnit.SECONDS)) throw new IllegalStateException("server not stopped");
        }
    }

    private static void probe(SSLContext context, int port, String peerName, boolean success) throws Exception {
        try (Socket transport = new Socket()) {
            transport.connect(new InetSocketAddress("127.0.0.1", port), 2000);
            try (SSLSocket socket = (SSLSocket) context.getSocketFactory().createSocket(transport, peerName, port, true)) {
                socket.setSoTimeout(5000);
                SSLParameters parameters = socket.getSSLParameters();
                parameters.setEndpointIdentificationAlgorithm("HTTPS");
                socket.setSSLParameters(parameters);
                try {
                    socket.startHandshake();
                    if (!success) throw new IllegalStateException("invalid identity accepted");
                    socket.getOutputStream().write(42);
                    if (socket.getInputStream().read() != 43) throw new IllegalStateException("response mismatch");
                    System.out.println("trusted localhost, HTTPS identity check, protocol=" + socket.getSession().getProtocol() + ": PASS");
                } catch (SSLException failure) {
                    if (success) throw failure;
                    System.out.println("rejected peer=" + peerName + " TLS error=" + failure.getClass().getSimpleName() + ": PASS");
                }
            }
        }
    }
}
