SSL·TLS — 보안 통신

// 서버: 인증서와 개인 키로 SslContext 생성
SslContext sslCtx = SslContextBuilder
    .forServer(certFile, keyFile)      // 서버 인증서 + 개인 키
    .protocols("TLSv1.3", "TLSv1.2")  // 허용할 TLS 버전
    .build();

// 클라이언트: 서버 인증서를 검증할 신뢰 저장소 설정
SslContext sslCtx = SslContextBuilder
    .forClient()
    .trustManager(caCertFile)          // CA 인증서 (서버 검증용)
    .build();

// JDK 기본 SSL 프로바이더
SslContext sslCtx = SslContextBuilder
    .forServer(certFile, keyFile)
    .sslProvider(SslProvider.JDK)
    .build();

// OpenSSL 기반 프로바이더 (netty-tcnative 의존성 필요)
SslContext sslCtx = SslContextBuilder
    .forServer(certFile, keyFile)
    .sslProvider(SslProvider.OPENSSL)
    .build();

[암호화된 바이트] → SslHandler(복호화) → 디코더 → 비즈니스 핸들러

비즈니스 핸들러 → 인코더 → SslHandler(암호화) → [암호화된 바이트]

// 서버 부트스트랩에서 파이프라인 구성
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
 .channel(NioServerSocketChannel.class)
 .childHandler(new ChannelInitializer<SocketChannel>() {
     @Override
     protected void initChannel(SocketChannel ch) {
         ChannelPipeline p = ch.pipeline();

         // 1. SslHandler — 반드시 맨 앞
         SSLEngine engine = sslCtx.newEngine(ch.alloc());
         p.addLast("ssl", new SslHandler(engine));

         // 2. 프레임 디코더
         p.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(
             1024, 0, 4, 0, 4));

         // 3. 비즈니스 핸들러
         p.addLast("handler", new MyServerHandler());
     }
 });

public class SslEventHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
        if (evt instanceof SslHandshakeCompletionEvent) {
            SslHandshakeCompletionEvent handshakeEvent =
                (SslHandshakeCompletionEvent) evt;

            if (handshakeEvent.isSuccess()) {
                // 핸드셰이크 성공 — 보안 통신 시작
                SSLSession session = ctx.pipeline()
                    .get(SslHandler.class)
                    .engine()
                    .getSession();
                System.out.println("프로토콜: " + session.getProtocol());
                System.out.println("암호 스위트: " + session.getCipherSuite());
            } else {
                // 핸드셰이크 실패 — 연결 종료
                System.err.println("TLS 핸드셰이크 실패: "
                    + handshakeEvent.cause().getMessage());
                ctx.close();
            }
        }
        ctx.fireUserEventTriggered(evt);
    }
}

// 자체 서명 인증서 생성 (개발/테스트 전용)
SelfSignedCertificate ssc = new SelfSignedCertificate();

// 서버 SslContext
SslContext serverSslCtx = SslContextBuilder
    .forServer(ssc.certificate(), ssc.privateKey())
    .build();

// 클라이언트 SslContext (인증서 검증 비활성화 — 개발용!)
SslContext clientSslCtx = SslContextBuilder
    .forClient()
    .trustManager(InsecureTrustManagerFactory.INSTANCE)  // 모든 인증서 신뢰
    .build();

// ❌ 프로덕션에서 이렇게 하면 중간자 공격에 무방비
SslContextBuilder.forClient()
    .trustManager(InsecureTrustManagerFactory.INSTANCE)
    .build();

// ✅ 프로덕션에서는 CA 인증서로 검증
SslContextBuilder.forClient()
    .trustManager(caCertFile)  // 신뢰할 수 있는 CA 인증서 지정
    .build();

[일반 TLS]
클라이언트 ----(서버 인증서 검증)---→ 서버
           ←---(데이터 암호화)------

[mTLS]
클라이언트 ----(서버 인증서 검증)---→ 서버
           ←---(클라이언트 인증서 검증)--
           ←---(데이터 암호화)------→

// 서버: 클라이언트 인증서를 반드시 요구
SslContext serverSslCtx = SslContextBuilder
    .forServer(serverCert, serverKey)
    .trustManager(caCert)             // 클라이언트 인증서를 검증할 CA
    .clientAuth(ClientAuth.REQUIRE)   // 클라이언트 인증서 필수
    .build();

// 클라이언트: 자신의 인증서를 제시
SslContext clientSslCtx = SslContextBuilder
    .forClient()
    .keyManager(clientCert, clientKey) // 클라이언트 인증서 + 개인 키
    .trustManager(caCert)              // 서버 인증서를 검증할 CA
    .build();

1. ClientHello          → 클라이언트가 지원하는 TLS 버전, 암호 스위트 전송
2. ServerHello          ← 서버가 선택한 TLS 버전, 암호 스위트 응답
3. Server Certificate   ← 서버 인증서 전송
4. CertificateRequest   ← 서버가 클라이언트 인증서 요청 ★ mTLS 핵심
5. Client Certificate   → 클라이언트 인증서 전송 ★
6. Key Exchange         → 양쪽이 세션 키 교환
7. Finished             ↔ 핸드셰이크 완료, 암호화 통신 시작

[일반 TLS]
연결 시작 → 즉시 TLS 핸드셰이크 → 암호화 통신

[StartTLS]
연결 시작 → 평문 통신 → "STARTTLS" 명령 → TLS 핸드셰이크 → 암호화 통신

public class StartTlsServerHandler extends ChannelInboundHandlerAdapter {

    private final SslContext sslCtx;

    public StartTlsServerHandler(SslContext sslCtx) {
        this.sslCtx = sslCtx;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        String command = (String) msg;

        if ("STARTTLS".equalsIgnoreCase(command.trim())) {
            // 1. 클라이언트에게 TLS 준비 완료 응답
            ctx.writeAndFlush("READY\r\n").addListener(future -> {
                if (future.isSuccess()) {
                    // 2. 파이프라인 맨 앞에 SslHandler 동적 추가
                    SslHandler sslHandler = sslCtx.newHandler(ctx.alloc());
                    ctx.pipeline().addFirst("ssl", sslHandler);

                    // 3. 핸드셰이크 완료 대기
                    sslHandler.handshakeFuture().addListener(hsFuture -> {
                        if (hsFuture.isSuccess()) {
                            System.out.println("StartTLS 업그레이드 성공");
                        } else {
                            System.err.println("StartTLS 핸드셰이크 실패");
                            ctx.close();
                        }
                    });
                }
            });
        } else {
            // TLS 업그레이드 전 — 평문 처리
            ctx.fireChannelRead(msg);
        }
    }
}

public class StartTlsClientHandler extends ChannelInboundHandlerAdapter {

    private final SslContext sslCtx;

    public StartTlsClientHandler(SslContext sslCtx) {
        this.sslCtx = sslCtx;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        // 서버에 STARTTLS 요청
        ctx.writeAndFlush("STARTTLS\r\n");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        String response = (String) msg;

        if ("READY".equalsIgnoreCase(response.trim())) {
            // 서버가 준비되면 SslHandler 추가
            SslHandler sslHandler = sslCtx.newHandler(
                ctx.alloc(),
                "server-host", 8443  // SNI를 위한 호스트/포트
            );
            ctx.pipeline().addFirst("ssl", sslHandler);

            sslHandler.handshakeFuture().addListener(future -> {
                if (future.isSuccess()) {
                    // TLS 업그레이드 완료 — 이후 암호화 통신
                    ctx.writeAndFlush("이제 암호화된 메시지입니다\r\n");
                }
            });
        }
    }
}

// ❌ SSL 환경에서는 FileRegion 사용 불가
ctx.writeAndFlush(new DefaultFileRegion(fileChannel, 0, fileLength));

// ✅ 대신 ChunkedFile 사용
ctx.writeAndFlush(new ChunkedFile(file));

// 1. OpenSSL 프로바이더 사용 — JDK보다 훨씬 빠름
SslContextBuilder.forServer(cert, key)
    .sslProvider(SslProvider.OPENSSL)
    .build();

// 2. TLS 세션 재개(Session Resumption) 활용
//    SslContext가 내부적으로 세션 캐시를 관리
//    동일 클라이언트의 재연결 시 풀 핸드셰이크를 생략

// 3. 적절한 암호 스위트 선택
SslContextBuilder.forServer(cert, key)
    .ciphers(Arrays.asList(
        "TLS_AES_256_GCM_SHA384",      // TLS 1.3
        "TLS_AES_128_GCM_SHA256"       // TLS 1.3
    ))
    .build();

// 인증서 갱신 시 SslContext를 재생성하는 패턴
public class ReloadableSslContext {

    private volatile SslContext sslContext;

    // 주기적으로 호출하여 인증서를 갱신
    public void reload(File certFile, File keyFile) throws Exception {
        SslContext newCtx = SslContextBuilder
            .forServer(certFile, keyFile)
            .sslProvider(SslProvider.OPENSSL)
            .build();

        SslContext oldCtx = this.sslContext;
        this.sslContext = newCtx;

        // 기존 연결은 이전 컨텍스트를 계속 사용
        // 새 연결부터 갱신된 인증서 적용
        // oldCtx는 모든 연결이 종료된 후 GC됨
    }

    public SslContext get() {
        return sslContext;
    }
}

public class SslServer {

    public static void main(String[] args) throws Exception {
        // 개발용 자체 서명 인증서
        SelfSignedCertificate ssc = new SelfSignedCertificate();
        SslContext sslCtx = SslContextBuilder
            .forServer(ssc.certificate(), ssc.privateKey())
            .build();

        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 protected void initChannel(SocketChannel ch) {
                     // SslHandler를 맨 앞에 배치
                     ch.pipeline().addLast(sslCtx.newHandler(ch.alloc()));
                     ch.pipeline().addLast(new StringDecoder());
                     ch.pipeline().addLast(new StringEncoder());
                     ch.pipeline().addLast(new SimpleChannelInboundHandler<String>() {
                         @Override
                         protected void channelRead0(
                                 ChannelHandlerContext ctx, String msg) {
                             System.out.println("수신 (암호화 해제됨): " + msg);
                             ctx.writeAndFlush("에코: " + msg);
                         }
                     });
                 }
             });

            ChannelFuture f = b.bind(8443).sync();
            System.out.println("SSL 서버 시작: 포트 8443");
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

public class SslClient {

    public static void main(String[] args) throws Exception {
        // 개발용 — 모든 인증서 신뢰 (프로덕션 금지!)
        SslContext sslCtx = SslContextBuilder
            .forClient()
            .trustManager(InsecureTrustManagerFactory.INSTANCE)
            .build();

        EventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
             .channel(NioSocketChannel.class)
             .handler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 protected void initChannel(SocketChannel ch) {
                     // SslHandler를 맨 앞에 배치
                     ch.pipeline().addLast(
                         sslCtx.newHandler(ch.alloc(), "localhost", 8443));
                     ch.pipeline().addLast(new StringDecoder());
                     ch.pipeline().addLast(new StringEncoder());
                     ch.pipeline().addLast(new SimpleChannelInboundHandler<String>() {
                         @Override
                         protected void channelRead0(
                                 ChannelHandlerContext ctx, String msg) {
                             System.out.println("서버 응답: " + msg);
                         }

                         @Override
                         public void channelActive(ChannelHandlerContext ctx) {
                             ctx.writeAndFlush("안녕하세요, 보안 채널입니다!");
                         }
                     });
                 }
             });

            ChannelFuture f = b.connect("localhost", 8443).sync();
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}