Java Security - Part 10: SSL/TLS Protocol Engineering - A Comprehensive Guide to Secure Communication

┌─────────────────────────────────────────────────────────┐
│                   Application Layer                      │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                  TLS Record Protocol                     │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│   TLS Handshake │ Alert Protocol │ Change Cipher Spec   │
└─────────────────────────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────┐
│                        TCP/IP                            │
└─────────────────────────────────────────────────────────┘

import javax.net.ssl.*;
import java.security.*;
import java.security.cert.*;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.*;
import java.nio.*;
import java.nio.channels.*;

public class TLSArchitecture {
    
    // Thread-safe SSL context initialization
    private static final class SSLContextHolder {
        static final SSLContext INSTANCE = initializeContext();
        
        private static SSLContext initializeContext() {
            try {
                // Load custom trust store
                KeyStore trustStore = KeyStore.getInstance("PKCS12");
                try (InputStream trustStoreStream = 
                     TLSArchitecture.class.getResourceAsStream("/truststore.p12")) {
                    trustStore.load(trustStoreStream, "truststore-password".toCharArray());
                }
                
                // Load identity store for client certificates
                KeyStore keyStore = KeyStore.getInstance("PKCS12");
                try (InputStream keyStoreStream = 
                     TLSArchitecture.class.getResourceAsStream("/keystore.p12")) {
                    keyStore.load(keyStoreStream, "keystore-password".toCharArray());
                }
                
                // Initialize trust manager factory
                TrustManagerFactory tmf = TrustManagerFactory.getInstance(
                    TrustManagerFactory.getDefaultAlgorithm());
                tmf.init(trustStore);
                
                // Initialize key manager factory
                KeyManagerFactory kmf = KeyManagerFactory.getInstance(
                    KeyManagerFactory.getDefaultAlgorithm());
                kmf.init(keyStore, "key-password".toCharArray());
                
                // Create SSL context
                SSLContext context = SSLContext.getInstance("TLSv1.3");
                context.init(kmf.getKeyManagers(), 
                           tmf.getTrustManagers(), 
                           new SecureRandom());
                
                return context;
            } catch (Exception e) {
                throw new RuntimeException("Failed to initialize SSL context", e);
            }
        }
    }
    
    public static SSLContext getSSLContext() {
        return SSLContextHolder.INSTANCE;
    }
}

public class ProductionSSLServer {
    private final ExecutorService executor = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors() * 2);
    private final SSLContext sslContext;
    private volatile boolean running = true;
    private ServerSocketChannel serverChannel;
    private Selector selector;
    
    // Connection pool for established SSL connections
    private final ConcurrentHashMap<SocketChannel, SSLEngine> connections = 
        new ConcurrentHashMap<>();
    
    // Metrics tracking
    private final AtomicLong acceptedConnections = new AtomicLong();
    private final AtomicLong failedHandshakes = new AtomicLong();
    private final AtomicLong successfulHandshakes = new AtomicLong();
    
    public ProductionSSLServer(int port) throws Exception {
        this.sslContext = TLSArchitecture.getSSLContext();
        initializeServer(port);
    }
    
    private void initializeServer(int port) throws Exception {
        selector = Selector.open();
        serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.socket().bind(new InetSocketAddress(port));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        // Configure server socket options
        serverChannel.socket().setReuseAddress(true);
        serverChannel.socket().setReceiveBufferSize(64 * 1024);
    }
    
    public void start() {
        executor.submit(this::acceptLoop);
        System.out.println("SSL Server started on port " + 
                         serverChannel.socket().getLocalPort());
    }
    
    private void acceptLoop() {
        while (running) {
            try {
                selector.select(1000);
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> iter = selectedKeys.iterator();
                
                while (iter.hasNext()) {
                    SelectionKey key = iter.next();
                    iter.remove();
                    
                    if (!key.isValid()) continue;
                    
                    if (key.isAcceptable()) {
                        acceptConnection(key);
                    } else if (key.isReadable()) {
                        readData(key);
                    }
                }
            } catch (Exception e) {
                System.err.println("Error in accept loop: " + e.getMessage());
            }
        }
    }
    
    private void acceptConnection(SelectionKey key) throws Exception {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel channel = serverChannel.accept();
        
        if (channel != null) {
            channel.configureBlocking(false);
            
            // Create SSL engine for this connection
            SSLEngine engine = createSSLEngine();
            connections.put(channel, engine);
            
            // Register for read events
            channel.register(selector, SelectionKey.OP_READ, engine);
            
            acceptedConnections.incrementAndGet();
            
            // Start SSL handshake
            engine.beginHandshake();
            performHandshake(channel, engine);
        }
    }
    
    private SSLEngine createSSLEngine() {
        SSLEngine engine = sslContext.createSSLEngine();
        engine.setUseClientMode(false);
        engine.setNeedClientAuth(false); // Set to true for mTLS
        
        // Configure protocols - only allow secure versions
        engine.setEnabledProtocols(new String[] {"TLSv1.3", "TLSv1.2"});
        
        // Configure cipher suites - only strong ciphers
        String[] cipherSuites = {
            "TLS_AES_256_GCM_SHA384",
            "TLS_AES_128_GCM_SHA256",
            "TLS_CHACHA20_POLY1305_SHA256",
            "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
            "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
            "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
            "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"
        };
        engine.setEnabledCipherSuites(filterAvailableCipherSuites(cipherSuites));
        
        // Configure SSL parameters
        SSLParameters params = engine.getSSLParameters();
        params.setUseCipherSuitesOrder(true); // Enforce server's cipher order
        params.setEndpointIdentificationAlgorithm("HTTPS"); // Enable hostname verification
        engine.setSSLParameters(params);
        
        return engine;
    }
    
    private String[] filterAvailableCipherSuites(String[] desired) {
        Set<String> available = new HashSet<>(
            Arrays.asList(sslContext.getSupportedSSLParameters().getCipherSuites()));
        return Arrays.stream(desired)
            .filter(available::contains)
            .toArray(String[]::new);
    }
    
    private void performHandshake(SocketChannel channel, SSLEngine engine) 
            throws Exception {
        ByteBuffer appBuffer = ByteBuffer.allocate(engine.getSession().getApplicationBufferSize());
        ByteBuffer netBuffer = ByteBuffer.allocate(engine.getSession().getPacketBufferSize());
        
        SSLEngineResult.HandshakeStatus handshakeStatus = engine.getHandshakeStatus();
        
        while (handshakeStatus != SSLEngineResult.HandshakeStatus.FINISHED &&
               handshakeStatus != SSLEngineResult.HandshakeStatus.NOT_HANDSHAKING) {
            
            switch (handshakeStatus) {
                case NEED_UNWRAP:
                    if (channel.read(netBuffer) < 0) {
                        throw new EOFException("Channel closed during handshake");
                    }
                    netBuffer.flip();
                    SSLEngineResult result = engine.unwrap(netBuffer, appBuffer);
                    netBuffer.compact();
                    handshakeStatus = result.getHandshakeStatus();
                    break;
                    
                case NEED_WRAP:
                    netBuffer.clear();
                    result = engine.wrap(appBuffer, netBuffer);
                    handshakeStatus = result.getHandshakeStatus();
                    netBuffer.flip();
                    while (netBuffer.hasRemaining()) {
                        channel.write(netBuffer);
                    }
                    break;
                    
                case NEED_TASK:
                    Runnable task;
                    while ((task = engine.getDelegatedTask()) != null) {
                        task.run();
                    }
                    handshakeStatus = engine.getHandshakeStatus();
                    break;
                    
                default:
                    throw new IllegalStateException("Invalid SSL handshake state");
            }
        }
        
        successfulHandshakes.incrementAndGet();
        System.out.println("SSL Handshake completed with cipher: " + 
                         engine.getSession().getCipherSuite());
    }
    
    private void readData(SelectionKey key) {
        SocketChannel channel = (SocketChannel) key.channel();
        SSLEngine engine = connections.get(channel);
        
        if (engine == null) return;
        
        executor.submit(() -> handleClientData(channel, engine));
    }
    
    private void handleClientData(SocketChannel channel, SSLEngine engine) {
        try {
            ByteBuffer netBuffer = ByteBuffer.allocate(engine.getSession().getPacketBufferSize());
            ByteBuffer appBuffer = ByteBuffer.allocate(engine.getSession().getApplicationBufferSize());
            
            int bytesRead = channel.read(netBuffer);
            if (bytesRead > 0) {
                netBuffer.flip();
                SSLEngineResult result = engine.unwrap(netBuffer, appBuffer);
                
                if (result.getStatus() == SSLEngineResult.Status.OK) {
                    appBuffer.flip();
                    // Process decrypted application data
                    processApplicationData(channel, engine, appBuffer);
                }
            } else if (bytesRead < 0) {
                closeConnection(channel);
            }
        } catch (Exception e) {
            System.err.println("Error handling client data: " + e.getMessage());
            closeConnection(channel);
        }
    }
    
    private void processApplicationData(SocketChannel channel, SSLEngine engine, 
                                      ByteBuffer data) throws Exception {
        // Example: Echo server functionality
        byte[] bytes = new byte[data.remaining()];
        data.get(bytes);
        String request = new String(bytes, "UTF-8");
        
        // Log request details
        System.out.println("Received: " + request);
        System.out.println("From: " + channel.getRemoteAddress());
        System.out.println("Protocol: " + engine.getSession().getProtocol());
        System.out.println("Cipher: " + engine.getSession().getCipherSuite());
        
        // Send response
        String response = "Echo: " + request;
        ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes("UTF-8"));
        ByteBuffer netBuffer = ByteBuffer.allocate(engine.getSession().getPacketBufferSize());
        
        engine.wrap(responseBuffer, netBuffer);
        netBuffer.flip();
        channel.write(netBuffer);
    }
    
    private void closeConnection(SocketChannel channel) {
        try {
            SSLEngine engine = connections.remove(channel);
            if (engine != null) {
                engine.closeOutbound();
            }
            channel.close();
        } catch (Exception e) {
            // Log error
        }
    }
    
    public void shutdown() {
        running = false;
        executor.shutdown();
        try {
            executor.awaitTermination(10, TimeUnit.SECONDS);
            selector.close();
            serverChannel.close();
        } catch (Exception e) {
            System.err.println("Error during shutdown: " + e.getMessage());
        }
    }
    
    // Metrics methods
    public long getAcceptedConnections() { return acceptedConnections.get(); }
    public long getFailedHandshakes() { return failedHandshakes.get(); }
    public long getSuccessfulHandshakes() { return successfulHandshakes.get(); }
    public int getActiveConnections() { return connections.size(); }
}

public class ProductionSSLClient {
    private final SSLContext sslContext;
    private final ExecutorService executor;
    private final BlockingQueue<SSLSocketWrapper> connectionPool;
    private final String hostname;
    private final int port;
    private final int maxPoolSize;
    
    // Metrics
    private final AtomicLong totalRequests = new AtomicLong();
    private final AtomicLong failedRequests = new AtomicLong();
    private final AtomicLong connectionReuse = new AtomicLong();
    
    public ProductionSSLClient(String hostname, int port, int maxPoolSize) 
            throws Exception {
        this.hostname = hostname;
        this.port = port;
        this.maxPoolSize = maxPoolSize;
        this.sslContext = TLSArchitecture.getSSLContext();
        this.executor = Executors.newCachedThreadPool();
        this.connectionPool = new LinkedBlockingQueue<>(maxPoolSize);
    }
    
    private class SSLSocketWrapper {
        final SSLSocket socket;
        final long createdAt;
        final AtomicInteger useCount;
        
        SSLSocketWrapper(SSLSocket socket) {
            this.socket = socket;
            this.createdAt = System.currentTimeMillis();
            this.useCount = new AtomicInteger(0);
        }
        
        boolean isValid() {
            return socket.isConnected() && 
                   !socket.isClosed() && 
                   (System.currentTimeMillis() - createdAt) < 300000; // 5 min max age
        }
    }
    
    private SSLSocketWrapper getConnection() throws Exception {
        SSLSocketWrapper wrapper = connectionPool.poll();
        
        if (wrapper != null && wrapper.isValid()) {
            connectionReuse.incrementAndGet();
            return wrapper;
        }
        
        // Create new connection
        return createNewConnection();
    }
    
    private SSLSocketWrapper createNewConnection() throws Exception {
        SSLSocketFactory factory = sslContext.getSocketFactory();
        SSLSocket socket = (SSLSocket) factory.createSocket();
        
        // Configure socket options
        socket.setTcpNoDelay(true);
        socket.setKeepAlive(true);
        socket.setSoTimeout(30000); // 30 second timeout
        socket.setReceiveBufferSize(64 * 1024);
        socket.setSendBufferSize(64 * 1024);
        
        // Configure SSL parameters
        SSLParameters params = socket.getSSLParameters();
        params.setEndpointIdentificationAlgorithm("HTTPS");
        params.setServerNames(Arrays.asList(new SNIHostName(hostname)));
        params.setApplicationProtocols(new String[] {"h2", "http/1.1"}); // ALPN
        socket.setSSLParameters(params);
        
        // Connect with timeout
        socket.connect(new InetSocketAddress(hostname, port), 10000);
        
        // Start handshake
        socket.startHandshake();
        
        // Verify session
        SSLSession session = socket.getSession();
        verifySession(session);
        
        return new SSLSocketWrapper(socket);
    }
    
    private void verifySession(SSLSession session) throws SSLException {
        // Verify protocol version
        String protocol = session.getProtocol();
        if (!protocol.equals("TLSv1.3") && !protocol.equals("TLSv1.2")) {
            throw new SSLException("Insecure protocol version: " + protocol);
        }
        
        // Verify cipher suite strength
        String cipherSuite = session.getCipherSuite();
        if (!isStrongCipherSuite(cipherSuite)) {
            throw new SSLException("Weak cipher suite: " + cipherSuite);
        }
        
        // Additional custom verification
        Certificate[] peerCerts = session.getPeerCertificates();
        if (peerCerts.length == 0) {
            throw new SSLException("No peer certificates");
        }
        
        // Log connection info
        System.out.println("SSL Session established:");
        System.out.println("  Protocol: " + protocol);
        System.out.println("  Cipher: " + cipherSuite);
        System.out.println("  Server: " + session.getPeerHost());
    }
    
    private boolean isStrongCipherSuite(String cipherSuite) {
        return cipherSuite.contains("_GCM_") || 
               cipherSuite.contains("_CHACHA20_") ||
               cipherSuite.contains("_CCM_");
    }
    
    public CompletableFuture<String> sendRequest(String request) {
        return CompletableFuture.supplyAsync(() -> {
            totalRequests.incrementAndGet();
            SSLSocketWrapper wrapper = null;
            
            try {
                wrapper = getConnection();
                SSLSocket socket = wrapper.socket;
                wrapper.useCount.incrementAndGet();
                
                // Send request
                PrintWriter out = new PrintWriter(
                    new OutputStreamWriter(socket.getOutputStream(), "UTF-8"), true);
                out.println(request);
                
                // Read response
                BufferedReader in = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(), "UTF-8"));
                String response = in.readLine();
                
                // Return connection to pool if healthy
                if (wrapper.useCount.get() < 100 && connectionPool.size() < maxPoolSize) {
                    connectionPool.offer(wrapper);
                } else {
                    closeConnection(wrapper);
                }
                
                return response;
                
            } catch (Exception e) {
                failedRequests.incrementAndGet();
                if (wrapper != null) {
                    closeConnection(wrapper);
                }
                throw new RuntimeException("Request failed", e);
            }
        }, executor);
    }
    
    private void closeConnection(SSLSocketWrapper wrapper) {
        try {
            wrapper.socket.close();
        } catch (Exception e) {
            // Log error
        }
    }
    
    public void shutdown() {
        executor.shutdown();
        SSLSocketWrapper wrapper;
        while ((wrapper = connectionPool.poll()) != null) {
            closeConnection(wrapper);
        }
    }
    
    // Metrics
    public long getTotalRequests() { return totalRequests.get(); }
    public long getFailedRequests() { return failedRequests.get(); }
    public long getConnectionReuse() { return connectionReuse.get(); }
    public int getPoolSize() { return connectionPool.size(); }
}

public class MutualTLSServer {
    private final SSLContext sslContext;
    private final Set<String> allowedClientDNs;
    
    public MutualTLSServer(String keystorePath, String truststorePath, 
                          Set<String> allowedClientDNs) throws Exception {
        this.allowedClientDNs = allowedClientDNs;
        this.sslContext = createMTLSContext(keystorePath, truststorePath);
    }
    
    private SSLContext createMTLSContext(String keystorePath, String truststorePath) 
            throws Exception {
        // Load server keystore
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        try (InputStream ks = new FileInputStream(keystorePath)) {
            keyStore.load(ks, "keystore-password".toCharArray());
        }
        
        // Load client truststore
        KeyStore trustStore = KeyStore.getInstance("PKCS12");
        try (InputStream ts = new FileInputStream(truststorePath)) {
            trustStore.load(ts, "truststore-password".toCharArray());
        }
        
        // Initialize key manager
        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(keyStore, "key-password".toCharArray());
        
        // Initialize trust manager with custom validation
        TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
        tmf.init(trustStore);
        
        // Wrap default trust manager with custom validation
        X509TrustManager defaultTm = findX509TrustManager(tmf);
        X509TrustManager customTm = new CustomTrustManager(defaultTm);
        
        // Create SSL context
        SSLContext context = SSLContext.getInstance("TLSv1.3");
        context.init(kmf.getKeyManagers(), 
                    new TrustManager[] { customTm }, 
                    new SecureRandom());
        
        return context;
    }
    
    private X509TrustManager findX509TrustManager(TrustManagerFactory tmf) {
        for (TrustManager tm : tmf.getTrustManagers()) {
            if (tm instanceof X509TrustManager) {
                return (X509TrustManager) tm;
            }
        }
        throw new IllegalStateException("No X509TrustManager found");
    }
    
    private class CustomTrustManager implements X509TrustManager {
        private final X509TrustManager delegate;
        
        CustomTrustManager(X509TrustManager delegate) {
            this.delegate = delegate;
        }
        
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType) 
                throws CertificateException {
            // First, perform standard validation
            delegate.checkClientTrusted(chain, authType);
            
            // Additional custom validation
            if (chain.length == 0) {
                throw new CertificateException("No client certificate provided");
            }
            
            X509Certificate clientCert = chain[0];
            
            // Verify certificate is not expired
            clientCert.checkValidity();
            
            // Verify client DN is in allowed list
            String clientDN = clientCert.getSubjectX500Principal().getName();
            if (!allowedClientDNs.contains(clientDN)) {
                throw new CertificateException("Client DN not authorized: " + clientDN);
            }
            
            // Verify key usage
            boolean[] keyUsage = clientCert.getKeyUsage();
            if (keyUsage != null && !keyUsage[0]) { // digitalSignature
                throw new CertificateException("Client cert missing digital signature usage");
            }
            
            // Log successful authentication
            System.out.println("Client authenticated: " + clientDN);
        }
        
        @Override
        public void checkServerTrusted(X509Certificate[] chain, String authType) 
                throws CertificateException {
            delegate.checkServerTrusted(chain, authType);
        }
        
        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return delegate.getAcceptedIssuers();
        }
    }
    
    public SSLServerSocket createServerSocket(int port) throws Exception {
        SSLServerSocketFactory factory = sslContext.getServerSocketFactory();
        SSLServerSocket serverSocket = (SSLServerSocket) factory.createServerSocket(port);
        
        // Configure for mutual TLS
        serverSocket.setNeedClientAuth(true);
        serverSocket.setEnabledProtocols(new String[] {"TLSv1.3", "TLSv1.2"});
        
        // Only strong cipher suites
        String[] cipherSuites = {
            "TLS_AES_256_GCM_SHA384",
            "TLS_AES_128_GCM_SHA256",
            "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
            "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
        };
        serverSocket.setEnabledCipherSuites(cipherSuites);
        
        return serverSocket;
    }
}

public class CertificateManager {
    private final ScheduledExecutorService scheduler = 
        Executors.newScheduledThreadPool(1);
    private final Map<String, CertificateInfo> certificates = 
        new ConcurrentHashMap<>();
    private final List<CertificateUpdateListener> listeners = 
        new CopyOnWriteArrayList<>();
    
    public interface CertificateUpdateListener {
        void onCertificateUpdate(String alias, X509Certificate newCert);
    }
    
    public static class CertificateInfo {
        final X509Certificate certificate;
        final PrivateKey privateKey;
        final Instant loadedAt;
        final Instant expiresAt;
        
        CertificateInfo(X509Certificate cert, PrivateKey key) {
            this.certificate = cert;
            this.privateKey = key;
            this.loadedAt = Instant.now();
            this.expiresAt = cert.getNotAfter().toInstant();
        }
        
        boolean isExpiringSoon() {
            return Instant.now().plus(30, ChronoUnit.DAYS).isAfter(expiresAt);
        }
    }
    
    public void startMonitoring() {
        // Check certificates every hour
        scheduler.scheduleAtFixedRate(this::checkCertificates, 0, 1, TimeUnit.HOURS);
    }
    
    private void checkCertificates() {
        certificates.forEach((alias, info) -> {
            try {
                // Check if certificate is expiring soon
                if (info.isExpiringSoon()) {
                    System.out.println("Certificate " + alias + 
                        " expires in less than 30 days: " + info.expiresAt);
                    notifyExpiringCertificate(alias, info);
                }
                
                // Verify certificate is still valid
                info.certificate.checkValidity();
                
                // Check for revocation (OCSP)
                if (isCertificateRevoked(info.certificate)) {
                    System.err.println("Certificate " + alias + " has been revoked!");
                    handleRevokedCertificate(alias);
                }
                
            } catch (CertificateExpiredException e) {
                System.err.println("Certificate " + alias + " has expired!");
                handleExpiredCertificate(alias);
            } catch (Exception e) {
                System.err.println("Error checking certificate " + alias + ": " + 
                    e.getMessage());
            }
        });
    }
    
    private boolean isCertificateRevoked(X509Certificate cert) {
        try {
            // Get OCSP responder URL from certificate
            String ocspUrl = getOCSPUrl(cert);
            if (ocspUrl == null) {
                return false; // No OCSP URL, skip check
            }
            
            // Create OCSP request
            OCSPReq ocspReq = generateOCSPRequest(cert);
            
            // Send OCSP request
            byte[] response = sendOCSPRequest(ocspUrl, ocspReq.getEncoded());
            
            // Parse response
            OCSPResp ocspResp = new OCSPResp(response);
            BasicOCSPResp basicResp = (BasicOCSPResp) ocspResp.getResponseObject();
            
            // Check certificate status
            SingleResp[] responses = basicResp.getResponses();
            for (SingleResp resp : responses) {
                CertificateStatus status = resp.getCertStatus();
                if (status != CertificateStatus.GOOD) {
                    return true; // Certificate is revoked or unknown
                }
            }
            
            return false;
            
        } catch (Exception e) {
            System.err.println("OCSP check failed: " + e.getMessage());
            return false; // Fail open - don't block on OCSP failure
        }
    }
    
    private String getOCSPUrl(X509Certificate cert) {
        try {
            byte[] ocspExtValue = cert.getExtensionValue(
                Extension.authorityInfoAccess.getId());
            if (ocspExtValue == null) return null;
            
            // Parse extension to get OCSP URL
            // Implementation details omitted for brevity
            return "http://ocsp.example.com";
        } catch (Exception e) {
            return null;
        }
    }
    
    public void loadCertificate(String alias, String certPath, String keyPath) 
            throws Exception {
        // Load certificate
        CertificateFactory cf = CertificateFactory.getInstance("X.509");
        X509Certificate cert;
        try (InputStream certStream = new FileInputStream(certPath)) {
            cert = (X509Certificate) cf.generateCertificate(certStream);
        }
        
        // Load private key
        PrivateKey privateKey = loadPrivateKey(keyPath);
        
        // Validate certificate
        validateCertificate(cert);
        
        // Store certificate info
        CertificateInfo info = new CertificateInfo(cert, privateKey);
        certificates.put(alias, info);
        
        // Notify listeners
        notifyCertificateUpdate(alias, cert);
    }
    
    private void validateCertificate(X509Certificate cert) 
            throws CertificateException {
        // Check validity period
        cert.checkValidity();
        
        // Verify key strength
        PublicKey publicKey = cert.getPublicKey();
        if (publicKey instanceof RSAPublicKey) {
            RSAPublicKey rsaKey = (RSAPublicKey) publicKey;
            if (rsaKey.getModulus().bitLength() < 2048) {
                throw new CertificateException("RSA key too weak: " + 
                    rsaKey.getModulus().bitLength() + " bits");
            }
        } else if (publicKey instanceof ECPublicKey) {
            ECPublicKey ecKey = (ECPublicKey) publicKey;
            if (ecKey.getParams().getCurve().getField().getFieldSize() < 256) {
                throw new CertificateException("EC key too weak");
            }
        }
        
        // Verify certificate chain
        // Implementation details omitted for brevity
    }
    
    // Certificate pinning implementation
    public static class CertificatePinner {
        private final Map<String, Set<String>> pinnedCertificates = 
            new ConcurrentHashMap<>();
        
        public void pin(String hostname, X509Certificate cert) 
                throws NoSuchAlgorithmException {
            String fingerprint = calculateFingerprint(cert);
            pinnedCertificates.computeIfAbsent(hostname, k -> new HashSet<>())
                            .add(fingerprint);
        }
        
        public void verify(String hostname, X509Certificate[] chain) 
                throws CertificateException {
            Set<String> pins = pinnedCertificates.get(hostname);
            if (pins == null || pins.isEmpty()) {
                return; // No pins for this host
            }
            
            boolean matched = false;
            for (X509Certificate cert : chain) {
                try {
                    String fingerprint = calculateFingerprint(cert);
                    if (pins.contains(fingerprint)) {
                        matched = true;
                        break;
                    }
                } catch (NoSuchAlgorithmException e) {
                    throw new CertificateException("Failed to calculate fingerprint", e);
                }
            }
            
            if (!matched) {
                throw new CertificateException(
                    "Certificate pinning failure for " + hostname);
            }
        }
        
        private String calculateFingerprint(X509Certificate cert) 
                throws NoSuchAlgorithmException {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] digest = md.digest(cert.getPublicKey().getEncoded());
            return Base64.getEncoder().encodeToString(digest);
        }
    }
}

public class SSLSessionManager {
    private final Cache<String, SSLSession> sessionCache;
    private final SSLContext sslContext;
    
    public SSLSessionManager(SSLContext sslContext, int maxCacheSize, 
                           Duration cacheTimeout) {
        this.sslContext = sslContext;
        this.sessionCache = Caffeine.newBuilder()
            .maximumSize(maxCacheSize)
            .expireAfterWrite(cacheTimeout)
            .removalListener((key, value, cause) -> {
                System.out.println("SSL session evicted: " + key + ", reason: " + cause);
            })
            .build();
        
        // Configure session caching in SSL context
        SSLSessionContext serverContext = sslContext.getServerSessionContext();
        serverContext.setSessionCacheSize(maxCacheSize);
        serverContext.setSessionTimeout((int) cacheTimeout.getSeconds());
    }
    
    public SSLSocket createSocketWithSessionResumption(String host, int port) 
            throws Exception {
        String sessionKey = host + ":" + port;
        SSLSession cachedSession = sessionCache.getIfPresent(sessionKey);
        
        SSLSocketFactory factory = sslContext.getSocketFactory();
        SSLSocket socket = (SSLSocket) factory.createSocket();
        
        if (cachedSession != null && cachedSession.isValid()) {
            // Enable session resumption
            SSLParameters params = socket.getSSLParameters();
            params.setServerNames(Arrays.asList(new SNIHostName(host)));
            socket.setSSLParameters(params);
            
            // Attempt to resume session
            socket.setEnableSessionCreation(false);
            try {
                socket.connect(new InetSocketAddress(host, port), 5000);
                socket.startHandshake();
                
                if (socket.getSession().equals(cachedSession)) {
                    System.out.println("SSL session resumed for " + host);
                    return socket;
                }
            } catch (Exception e) {
                // Session resumption failed, create new session
                socket.close();
                socket = (SSLSocket) factory.createSocket();
            }
        }
        
        // Create new session
        socket.setEnableSessionCreation(true);
        socket.connect(new InetSocketAddress(host, port), 5000);
        socket.startHandshake();
        
        // Cache the new session
        SSLSession newSession = socket.getSession();
        sessionCache.put(sessionKey, newSession);
        
        return socket;
    }
}

public class TLS13ZeroRTTClient {
    private final SSLContext sslContext;
    private final Map<String, byte[]> earlyDataCache = new ConcurrentHashMap<>();
    
    public void sendWithZeroRTT(String host, int port, byte[] data) 
            throws Exception {
        SSLSocketFactory factory = sslContext.getSocketFactory();
        SSLSocket socket = (SSLSocket) factory.createSocket();
        
        // Configure for TLS 1.3
        socket.setEnabledProtocols(new String[] {"TLSv1.3"});
        
        // Enable early data (0-RTT)
        SSLParameters params = socket.getSSLParameters();
        params.setEnableRetransmissions(false);
        params.setMaximumPacketSize(16384);
        
        // Check if we have cached early data secret
        String sessionKey = host + ":" + port;
        byte[] earlyDataSecret = earlyDataCache.get(sessionKey);
        
        if (earlyDataSecret != null) {
            // Attempt 0-RTT
            params.setApplicationProtocols(new String[] {"h2"});
            socket.setSSLParameters(params);
            
            socket.connect(new InetSocketAddress(host, port), 5000);
            
            // Send early data
            OutputStream out = socket.getOutputStream();
            out.write(data);
            out.flush();
            
            // Complete handshake
            socket.startHandshake();
            
            System.out.println("0-RTT data sent successfully");
        } else {
            // Regular handshake
            socket.connect(new InetSocketAddress(host, port), 5000);
            socket.startHandshake();
            
            // Cache session for future 0-RTT
            SSLSession session = socket.getSession();
            // Extract early data secret (implementation specific)
            // earlyDataCache.put(sessionKey, extractEarlyDataSecret(session));
            
            // Send data after handshake
            OutputStream out = socket.getOutputStream();
            out.write(data);
            out.flush();
        }
    }
}

public class SSLSecurityHardening {
    
    public static SSLContext createHardenedSSLContext() throws Exception {
        // Create custom SSL context with strict security settings
        SSLContext context = SSLContext.getInstance("TLSv1.3");
        
        // Custom KeyManager for certificate selection
        KeyManager[] keyManagers = createKeyManagers();
        
        // Custom TrustManager with additional validation
        TrustManager[] trustManagers = createTrustManagers();
        
        // Strong secure random
        SecureRandom secureRandom = SecureRandom.getInstanceStrong();
        
        context.init(keyManagers, trustManagers, secureRandom);
        
        return context;
    }
    
    private static KeyManager[] createKeyManagers() throws Exception {
        KeyManagerFactory kmf = KeyManagerFactory.getInstance("PKIX");
        
        // Custom key manager that selects certificates based on criteria
        X509ExtendedKeyManager defaultKm = (X509ExtendedKeyManager) 
            kmf.getKeyManagers()[0];
        
        X509ExtendedKeyManager customKm = new X509ExtendedKeyManager() {
            @Override
            public String chooseClientAlias(String[] keyTypes, Principal[] issuers,
                                          Socket socket) {
                // Custom logic to choose client certificate
                String alias = defaultKm.chooseClientAlias(keyTypes, issuers, socket);
                
                // Additional validation
                if (alias != null) {
                    X509Certificate cert = getCertificateChain(alias)[0];
                    if (!isValidForClientAuth(cert)) {
                        return null;
                    }
                }
                
                return alias;
            }
            
            private boolean isValidForClientAuth(X509Certificate cert) {
                try {
                    // Check extended key usage
                    List<String> extKeyUsage = cert.getExtendedKeyUsage();
                    return extKeyUsage != null && 
                           extKeyUsage.contains("1.3.6.1.5.5.7.3.2"); // clientAuth
                } catch (Exception e) {
                    return false;
                }
            }
            
            // Delegate other methods to default implementation
            // ... (other methods omitted for brevity)
        };
        
        return new KeyManager[] { customKm };
    }
    
    private static TrustManager[] createTrustManagers() throws Exception {
        TrustManagerFactory tmf = TrustManagerFactory.getInstance("PKIX");
        
        // Initialize with custom trust store
        KeyStore trustStore = loadTrustStore();
        
        // Configure certificate path validation
        PKIXBuilderParameters pkixParams = new PKIXBuilderParameters(
            trustStore, new X509CertSelector());
        
        // Enable revocation checking
        pkixParams.setRevocationEnabled(true);
        
        // Add custom certificate constraints
        pkixParams.addCertPathChecker(new CustomCertPathChecker());
        
        tmf.init(new CertPathTrustManagerParameters(pkixParams));
        
        return tmf.getTrustManagers();
    }
    
    static class CustomCertPathChecker extends PKIXCertPathChecker {
        @Override
        public void check(Certificate cert, Collection<String> unresolvedCritExts)
                throws CertPathValidatorException {
            X509Certificate x509Cert = (X509Certificate) cert;
            
            // Check certificate policies
            try {
                byte[] policyBytes = x509Cert.getExtensionValue("2.5.29.32");
                if (policyBytes != null) {
                    // Validate policies
                    validateCertificatePolicies(policyBytes);
                }
            } catch (Exception e) {
                throw new CertPathValidatorException(
                    "Certificate policy validation failed", e);
            }
            
            // Check signature algorithm strength
            String sigAlg = x509Cert.getSigAlgName();
            if (!isStrongSignatureAlgorithm(sigAlg)) {
                throw new CertPathValidatorException(
                    "Weak signature algorithm: " + sigAlg);
            }
        }
        
        private boolean isStrongSignatureAlgorithm(String algorithm) {
            return algorithm.contains("SHA256") || 
                   algorithm.contains("SHA384") || 
                   algorithm.contains("SHA512");
        }
        
        @Override
        public Set<String> getSupportedExtensions() {
            return null;
        }
        
        @Override
        public void init(boolean forward) throws CertPathValidatorException {
            // Initialization if needed
        }
        
        @Override
        public boolean isForwardCheckingSupported() {
            return true;
        }
    }
}

public class SSLMonitoring {
    private final MeterRegistry meterRegistry;
    private final Map<String, SSLMetrics> connectionMetrics = new ConcurrentHashMap<>();
    
    public static class SSLMetrics {
        final Counter handshakeAttempts;
        final Counter handshakeSuccesses;
        final Counter handshakeFailures;
        final Timer handshakeDuration;
        final Gauge activeConnections;
        final Counter protocolVersions;
        final Counter cipherSuites;
        
        SSLMetrics(MeterRegistry registry, String name) {
            this.handshakeAttempts = Counter.builder("ssl.handshake.attempts")
                .tag("connection", name)
                .register(registry);
                
            this.handshakeSuccesses = Counter.builder("ssl.handshake.success")
                .tag("connection", name)
                .register(registry);
                
            this.handshakeFailures = Counter.builder("ssl.handshake.failures")
                .tag("connection", name)
                .register(registry);
                
            this.handshakeDuration = Timer.builder("ssl.handshake.duration")
                .tag("connection", name)
                .register(registry);
                
            this.activeConnections = Gauge.builder("ssl.connections.active", 
                new AtomicInteger(0), AtomicInteger::get)
                .tag("connection", name)
                .register(registry);
        }
    }
    
    public void monitorHandshake(String connectionName, SSLSocket socket) {
        SSLMetrics metrics = connectionMetrics.computeIfAbsent(
            connectionName, name -> new SSLMetrics(meterRegistry, name));
        
        metrics.handshakeAttempts.increment();
        
        HandshakeCompletedListener listener = new HandshakeCompletedListener() {
            private final long startTime = System.nanoTime();
            
            @Override
            public void handshakeCompleted(HandshakeCompletedEvent event) {
                long duration = System.nanoTime() - startTime;
                metrics.handshakeDuration.record(duration, TimeUnit.NANOSECONDS);
                metrics.handshakeSuccesses.increment();
                
                SSLSession session = event.getSession();
                
                // Record protocol version
                Counter.builder("ssl.protocol.version")
                    .tag("version", session.getProtocol())
                    .register(meterRegistry)
                    .increment();
                
                // Record cipher suite
                Counter.builder("ssl.cipher.suite")
                    .tag("cipher", session.getCipherSuite())
                    .register(meterRegistry)
                    .increment();
                
                // Log session details
                logSessionDetails(session);
            }
        };
        
        socket.addHandshakeCompletedListener(listener);
    }
    
    private void logSessionDetails(SSLSession session) {
        System.out.println("=== SSL Session Details ===");
        System.out.println("Session ID: " + 
            bytesToHex(session.getId()));
        System.out.println("Protocol: " + session.getProtocol());
        System.out.println("Cipher Suite: " + session.getCipherSuite());
        System.out.println("Creation Time: " + 
            Instant.ofEpochMilli(session.getCreationTime()));
        System.out.println("Last Access: " + 
            Instant.ofEpochMilli(session.getLastAccessedTime()));
        System.out.println("Peer Host: " + session.getPeerHost());
        
        try {
            Certificate[] peerCerts = session.getPeerCertificates();
            System.out.println("Peer Certificates: " + peerCerts.length);
            for (int i = 0; i < peerCerts.length; i++) {
                if (peerCerts[i] instanceof X509Certificate) {
                    X509Certificate x509 = (X509Certificate) peerCerts[i];
                    System.out.println("  [" + i + "] Subject: " + 
                        x509.getSubjectDN());
                    System.out.println("      Issuer: " + x509.getIssuerDN());
                    System.out.println("      Valid: " + x509.getNotBefore() + 
                        " - " + x509.getNotAfter());
                }
            }
        } catch (SSLPeerUnverifiedException e) {
            System.out.println("Peer not verified");
        }
    }
    
    private String bytesToHex(byte[] bytes) {
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            result.append(String.format("%02X", b));
        }
        return result.toString();
    }
    
    // SSL debugging helper
    public static void enableSSLDebugging(String debugLevel) {
        System.setProperty("javax.net.debug", debugLevel);
        // Options: all, ssl, handshake, data, trustmanager, keymanager
    }
    
    // Connection state monitoring
    public void monitorConnectionState(SSLSocket socket, String connectionId) {
        ScheduledExecutorService monitor = Executors.newSingleThreadScheduledExecutor();
        
        monitor.scheduleAtFixedRate(() -> {
            try {
                SSLSession session = socket.getSession();
                
                // Check if session is still valid
                if (!session.isValid()) {
                    System.err.println("Session " + connectionId + " invalidated");
                    monitor.shutdown();
                    return;
                }
                
                // Monitor for renegotiation
                String currentCipher = session.getCipherSuite();
                String currentProtocol = session.getProtocol();
                
                // Log if cipher or protocol changes (renegotiation occurred)
                // Store previous values and compare
                
                // Check socket state
                if (socket.isClosed()) {
                    System.out.println("Socket " + connectionId + " closed");
                    monitor.shutdown();
                }
                
            } catch (Exception e) {
                System.err.println("Error monitoring " + connectionId + ": " + 
                    e.getMessage());
            }
        }, 0, 10, TimeUnit.SECONDS);
    }
}

public class SSLVulnerabilityMitigation {
    
    // Prevent BEAST attack
    public static void mitigateBEAST(SSLSocket socket) {
        // Disable SSL 3.0 and TLS 1.0
        socket.setEnabledProtocols(new String[] {"TLSv1.2", "TLSv1.3"});
        
        // Prefer RC4 cipher suites for TLS 1.0 (if must use TLS 1.0)
        // Better: Don't use TLS 1.0 at all
    }
    
    // Prevent CRIME attack
    public static void mitigateCRIME(SSLSocket socket) {
        // Disable TLS compression
        // Java doesn't support TLS compression by default, so this is handled
    }
    
    // Prevent BREACH attack
    public static class BREACHMitigation {
        private final SecureRandom random = new SecureRandom();
        
        public byte[] addRandomPadding(byte[] data) {
            // Add random padding to responses to prevent BREACH
            int paddingLength = random.nextInt(256);
            byte[] padded = new byte[data.length + paddingLength];
            System.arraycopy(data, 0, padded, 0, data.length);
            random.nextBytes(padded); // Fill padding with random data
            return padded;
        }
    }
    
    // Prevent POODLE attack
    public static void mitigatePOODLE(SSLSocket socket) {
        // Disable SSL 3.0 completely
        String[] protocols = socket.getEnabledProtocols();
        List<String> enabledProtocols = new ArrayList<>();
        for (String protocol : protocols) {
            if (!protocol.equals("SSLv3")) {
                enabledProtocols.add(protocol);
            }
        }
        socket.setEnabledProtocols(enabledProtocols.toArray(new String[0]));
    }
    
    // Prevent Heartbleed (OpenSSL specific, but good to check)
    public static void checkHeartbleedVulnerability(SSLSocket socket) {
        SSLSession session = socket.getSession();
        String cipherSuite = session.getCipherSuite();
        
        // Log warning if using vulnerable OpenSSL version
        // This is more relevant for native SSL implementations
    }
    
    // Implement perfect forward secrecy
    public static void enforcePerfectForwardSecrecy(SSLSocket socket) {
        // Only allow cipher suites with ephemeral key exchange
        String[] cipherSuites = socket.getEnabledCipherSuites();
        List<String> pfsCiphers = new ArrayList<>();
        
        for (String suite : cipherSuites) {
            if (suite.contains("_ECDHE_") || suite.contains("_DHE_")) {
                pfsCiphers.add(suite);
            }
        }
        
        socket.setEnabledCipherSuites(pfsCiphers.toArray(new String[0]));
    }
    
    // Prevent downgrade attacks
    public static class DowngradeProtection {
        public static void enforceMinimumProtocol(SSLSocket socket, 
                                                 String minimumProtocol) {
            String[] protocols = socket.getEnabledProtocols();
            List<String> allowedProtocols = new ArrayList<>();
            
            // Define protocol ordering
            List<String> protocolOrder = Arrays.asList(
                "SSLv3", "TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3"
            );
            
            int minIndex = protocolOrder.indexOf(minimumProtocol);
            
            for (String protocol : protocols) {
                int protocolIndex = protocolOrder.indexOf(protocol);
                if (protocolIndex >= minIndex) {
                    allowedProtocols.add(protocol);
                }
            }
            
            socket.setEnabledProtocols(allowedProtocols.toArray(new String[0]));
        }
    }
    
    // Implement certificate transparency checking
    public static class CertificateTransparencyValidator {
        public boolean validateCT(X509Certificate[] chain) {
            X509Certificate leafCert = chain[0];
            
            try {
                // Check for CT extension
                byte[] sctExtension = leafCert.getExtensionValue("1.3.6.1.4.1.11129.2.4.2");
                
                if (sctExtension == null) {
                    // Check for CT in OCSP stapling
                    // Implementation specific
                    return false;
                }
                
                // Validate SCT signatures
                // This requires parsing the SCT list and verifying signatures
                // against known CT log public keys
                
                return true;
                
            } catch (Exception e) {
                System.err.println("CT validation failed: " + e.getMessage());
                return false;
            }
        }
    }
}

public class SSLSecurityChecklist {
    
    public static class ChecklistItem {
        final String category;
        final String item;
        final Predicate<SSLSocket> check;
        final String remediation;
        
        ChecklistItem(String category, String item, 
                     Predicate<SSLSocket> check, String remediation) {
            this.category = category;
            this.item = item;
            this.check = check;
            this.remediation = remediation;
        }
    }
    
    private static final List<ChecklistItem> SECURITY_CHECKLIST = Arrays.asList(
        new ChecklistItem(
            "Protocol Version",
            "TLS 1.2 or higher",
            socket -> {
                String protocol = socket.getSession().getProtocol();
                return protocol.equals("TLSv1.2") || protocol.equals("TLSv1.3");
            },
            "Disable older protocol versions"
        ),
        
        new ChecklistItem(
            "Cipher Strength",
            "Strong cipher suites only",
            socket -> {
                String cipher = socket.getSession().getCipherSuite();
                return cipher.contains("_GCM_") || 
                       cipher.contains("_CHACHA20_") ||
                       cipher.contains("_CCM_");
            },
            "Configure strong cipher suites"
        ),
        
        new ChecklistItem(
            "Certificate Validation",
            "Hostname verification enabled",
            socket -> {
                SSLParameters params = socket.getSSLParameters();
                return params.getEndpointIdentificationAlgorithm() != null;
            },
            "Enable hostname verification"
        ),
        
        new ChecklistItem(
            "Perfect Forward Secrecy",
            "PFS cipher suites",
            socket -> {
                String cipher = socket.getSession().getCipherSuite();
                return cipher.contains("_ECDHE_") || cipher.contains("_DHE_");
            },
            "Use ephemeral key exchange"
        ),
        
        new ChecklistItem(
            "Session Security",
            "Secure session timeout",
            socket -> {
                int timeout = socket.getSession().getSessionContext().getSessionTimeout();
                return timeout > 0 && timeout <= 86400; // Max 24 hours
            },
            "Configure appropriate session timeout"
        )
    );
    
    public static void performSecurityAudit(SSLSocket socket) {
        System.out.println("=== SSL Security Audit ===");
        
        Map<String, List<ChecklistItem>> failedChecks = new HashMap<>();
        
        for (ChecklistItem item : SECURITY_CHECKLIST) {
            try {
                if (!item.check.test(socket)) {
                    failedChecks.computeIfAbsent(item.category, k -> new ArrayList<>())
                               .add(item);
                } else {
                    System.out.println("✓ " + item.category + ": " + item.item);
                }
            } catch (Exception e) {
                System.err.println("✗ " + item.category + ": " + item.item + 
                                 " (Error: " + e.getMessage() + ")");
            }
        }
        
        if (!failedChecks.isEmpty()) {
            System.out.println("\n=== Failed Checks ===");
            failedChecks.forEach((category, items) -> {
                System.out.println("\n" + category + ":");
                items.forEach(item -> {
                    System.out.println("  ✗ " + item.item);
                    System.out.println("    Remediation: " + item.remediation);
                });
            });
        }
    }
}