[feat](protocol, client, server): replace DTLS with gRPC for tunnel implementation

- Introduced gRPC-based tunnel design for bi-directional communication, replacing legacy DTLS transport.
- Added `HopGateTunnel` gRPC service with client and server logic for `OpenTunnel` stream handling.
- Updated client to use gRPC tunnel exclusively, including experimental entry point for stream-based HTTP proxying.
- Removed DTLS-specific client, server, and related dependencies (`pion/dtls`).
- Adjusted `cmd/server` to route gRPC and HTTP/HTTPS traffic dynamically on shared ports.

cmd/client/main.go

@@ -5,14 +5,17 @@ import (
 	"crypto/tls"
 	"crypto/x509"
 	"flag"
+	"io"
 	"net"
 	"os"
 	"strings"
 
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+
 	"github.com/dalbodeule/hop-gate/internal/config"
-	"github.com/dalbodeule/hop-gate/internal/dtls"
 	"github.com/dalbodeule/hop-gate/internal/logging"
-	"github.com/dalbodeule/hop-gate/internal/proxy"
+	protocolpb "github.com/dalbodeule/hop-gate/internal/protocol/pb"
 )
 
 // version 은 빌드 시 -ldflags "-X main.version=xxxxxxx" 로 덮어쓰이는 필드입니다.
@@ -48,6 +51,148 @@ func firstNonEmpty(values ...string) string {
 	return ""
 }
 
+// runGRPCTunnelClient 는 gRPC 기반 터널을 사용하는 실험적 클라이언트 진입점입니다. (ko)
+// runGRPCTunnelClient is an experimental entrypoint for a gRPC-based tunnel client. (en)
+func runGRPCTunnelClient(ctx context.Context, logger logging.Logger, finalCfg *config.ClientConfig) error {
+	// TLS 설정은 기존 DTLS 클라이언트와 동일한 정책을 사용합니다. (ko)
+	// TLS configuration mirrors the existing DTLS client policy. (en)
+	var tlsCfg *tls.Config
+	if finalCfg.Debug {
+		tlsCfg = &tls.Config{
+			InsecureSkipVerify: true,
+			MinVersion:         tls.VersionTLS12,
+		}
+	} else {
+		rootCAs, err := x509.SystemCertPool()
+		if err != nil || rootCAs == nil {
+			rootCAs = x509.NewCertPool()
+		}
+		tlsCfg = &tls.Config{
+			RootCAs:    rootCAs,
+			MinVersion: tls.VersionTLS12,
+		}
+	}
+
+	// finalCfg.ServerAddr 가 "host:port" 형태이므로, SNI 에는 DNS(host) 부분만 넣어야 한다.
+	host := finalCfg.ServerAddr
+	if h, _, err := net.SplitHostPort(finalCfg.ServerAddr); err == nil && strings.TrimSpace(h) != "" {
+		host = h
+	}
+	tlsCfg.ServerName = host
+
+	creds := credentials.NewTLS(tlsCfg)
+
+	log := logger.With(logging.Fields{
+		"component":    "grpc_tunnel_client",
+		"server_addr":  finalCfg.ServerAddr,
+		"domain":       finalCfg.Domain,
+		"local_target": finalCfg.LocalTarget,
+	})
+
+	log.Info("dialing grpc tunnel", nil)
+
+	conn, err := grpc.DialContext(ctx, finalCfg.ServerAddr, grpc.WithTransportCredentials(creds), grpc.WithBlock())
+	if err != nil {
+		log.Error("failed to dial grpc tunnel server", logging.Fields{
+			"error": err.Error(),
+		})
+		return err
+	}
+	defer conn.Close()
+
+	client := protocolpb.NewHopGateTunnelClient(conn)
+
+	stream, err := client.OpenTunnel(ctx)
+	if err != nil {
+		log.Error("failed to open grpc tunnel stream", logging.Fields{
+			"error": err.Error(),
+		})
+		return err
+	}
+
+	log.Info("grpc tunnel stream opened", nil)
+
+	// 초기 핸드셰이크: 도메인, API 키, 로컬 타깃 정보를 StreamOpen 헤더로 전송합니다. (ko)
+	// Initial handshake: send domain, API key, and local target via StreamOpen headers. (en)
+	headers := map[string]*protocolpb.HeaderValues{
+		"X-HopGate-Domain":       {Values: []string{finalCfg.Domain}},
+		"X-HopGate-API-Key":      {Values: []string{finalCfg.ClientAPIKey}},
+		"X-HopGate-Local-Target": {Values: []string{finalCfg.LocalTarget}},
+	}
+
+	open := &protocolpb.StreamOpen{
+		Id:          "control-0",
+		ServiceName: "control",
+		TargetAddr:  "",
+		Header:      headers,
+	}
+
+	env := &protocolpb.Envelope{
+		Payload: &protocolpb.Envelope_StreamOpen{
+			StreamOpen: open,
+		},
+	}
+
+	if err := stream.Send(env); err != nil {
+		log.Error("failed to send initial stream_open handshake", logging.Fields{
+			"error": err.Error(),
+		})
+		return err
+	}
+
+	log.Info("sent initial stream_open handshake on grpc tunnel", logging.Fields{
+		"domain":       finalCfg.Domain,
+		"local_target": finalCfg.LocalTarget,
+		"api_key_mask": maskAPIKey(finalCfg.ClientAPIKey),
+	})
+
+	// 수신 루프: 현재는 수신된 Envelope 의 타입만 로그에 남기고 종료하지 않습니다. (ko)
+	// Receive loop: currently only logs envelope payload types and keeps the tunnel open. (en)
+	for {
+		if ctx.Err() != nil {
+			log.Info("context cancelled, closing grpc tunnel client", logging.Fields{
+				"error": ctx.Err().Error(),
+			})
+			return ctx.Err()
+		}
+
+		in, err := stream.Recv()
+		if err != nil {
+			if err == io.EOF {
+				log.Info("grpc tunnel stream closed by server", nil)
+				return nil
+			}
+			log.Error("grpc tunnel receive error", logging.Fields{
+				"error": err.Error(),
+			})
+			return err
+		}
+
+		payloadType := "unknown"
+		switch in.Payload.(type) {
+		case *protocolpb.Envelope_HttpRequest:
+			payloadType = "http_request"
+		case *protocolpb.Envelope_HttpResponse:
+			payloadType = "http_response"
+		case *protocolpb.Envelope_StreamOpen:
+			payloadType = "stream_open"
+		case *protocolpb.Envelope_StreamData:
+			payloadType = "stream_data"
+		case *protocolpb.Envelope_StreamClose:
+			payloadType = "stream_close"
+		case *protocolpb.Envelope_StreamAck:
+			payloadType = "stream_ack"
+		}
+
+		log.Info("received envelope on grpc tunnel client", logging.Fields{
+			"payload_type": payloadType,
+		})
+
+		// 이후 단계에서 여기서 HTTP 프록시와의 연동(요청/응답 처리)을 구현할 예정입니다. (ko)
+		// Future 3.3 work will hook HTTP proxy logic here. (en)
+	}
+}
+
 func main() {
 	logger := logging.NewStdJSONLogger("client")
 
@@ -87,7 +232,7 @@ func main() {
 	})
 
 	// CLI 인자 정의 (env 보다 우선 적용됨)
-	serverAddrFlag := flag.String("server-addr", "", "DTLS server address (host:port)")
+	serverAddrFlag := flag.String("server-addr", "", "HopGate server address (host:port)")
 	domainFlag := flag.String("domain", "", "registered domain (e.g. api.example.com)")
 	apiKeyFlag := flag.String("api-key", "", "client API key for the domain (64 chars)")
 	localTargetFlag := flag.String("local-target", "", "local HTTP target (host:port), e.g. 127.0.0.1:8080")
@@ -136,78 +281,16 @@ func main() {
 		"debug":                 finalCfg.Debug,
 	})
 
-	// 4. DTLS 클라이언트 연결 및 핸드셰이크
 	ctx := context.Background()
 
-	// 디버그 모드에서는 서버 인증서 검증을 스킵(InsecureSkipVerify=true) 하여
-	// self-signed 테스트 인증서도 신뢰하도록 합니다.
-	// 운영 환경에서는 Debug=false 로 두고, 올바른 RootCAs / ServerName 을 갖는 tls.Config 를 사용해야 합니다.
-	var tlsCfg *tls.Config
-	if finalCfg.Debug {
-		tlsCfg = &tls.Config{
-			InsecureSkipVerify: true,
-			MinVersion:         tls.VersionTLS12,
-		}
-	} else {
-		// 운영 모드: 시스템 루트 CA + SNI(ServerName)에 서버 도메인 설정
-		rootCAs, err := x509.SystemCertPool()
-		if err != nil || rootCAs == nil {
-			rootCAs = x509.NewCertPool()
-		}
-		tlsCfg = &tls.Config{
-			RootCAs:    rootCAs,
-			MinVersion: tls.VersionTLS12,
-		}
-	}
-	// DTLS 서버 측은 SNI(ServerName)가 HOP_SERVER_DOMAIN(cfg.Domain)과 일치하는지 검사하므로,
-	// 클라이언트 TLS 설정에도 반드시 도메인을 설정해준다.
-	//
-	// finalCfg.ServerAddr 가 "host:port" 형태이므로, SNI 에는 DNS(host) 부분만 넣어야 한다.
-	host := finalCfg.ServerAddr
-	if h, _, err := net.SplitHostPort(finalCfg.ServerAddr); err == nil && strings.TrimSpace(h) != "" {
-		host = h
-	}
-	tlsCfg.ServerName = host
-
-	client := dtls.NewPionClient(dtls.PionClientConfig{
-		Addr:      finalCfg.ServerAddr,
-		TLSConfig: tlsCfg,
-	})
-
-	sess, err := client.Connect()
-	if err != nil {
-		logger.Error("failed to establish dtls session", logging.Fields{
-			"error": err.Error(),
-		})
-		os.Exit(1)
-	}
-	defer sess.Close()
-
-	hsRes, err := dtls.PerformClientHandshake(ctx, sess, logger, finalCfg.Domain, finalCfg.ClientAPIKey, finalCfg.LocalTarget)
-	if err != nil {
-		logger.Error("dtls handshake failed", logging.Fields{
+	// 현재 클라이언트는 DTLS 레이어 없이 gRPC 터널만을 사용합니다. (ko)
+	// The client now uses only the gRPC tunnel, without any DTLS layer. (en)
+	if err := runGRPCTunnelClient(ctx, logger, finalCfg); err != nil {
+		logger.Error("grpc tunnel client exited with error", logging.Fields{
 			"error": err.Error(),
 		})
 		os.Exit(1)
 	}
 
-	logger.Info("dtls handshake completed", logging.Fields{
-		"domain":       hsRes.Domain,
-		"local_target": finalCfg.LocalTarget,
-	})
-
-	// 5. DTLS 세션 위에서 서버 요청을 처리하는 클라이언트 프록시 루프 시작
-	clientProxy := proxy.NewClientProxy(logger, finalCfg.LocalTarget)
-	logger.Info("starting client proxy loop", logging.Fields{
-		"local_target": finalCfg.LocalTarget,
-	})
-
-	if err := clientProxy.StartLoop(ctx, sess); err != nil {
-		logger.Error("client proxy loop exited with error", logging.Fields{
-			"error": err.Error(),
-		})
-		os.Exit(1)
-	}
-
-	logger.Info("client proxy loop exited normally", nil)
+	logger.Info("grpc tunnel client exited normally", nil)
 }

cmd/server/main.go

@@ -19,6 +19,8 @@ import (
 	"time"
 
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/peer"
 
 	"github.com/dalbodeule/hop-gate/internal/acme"
 	"github.com/dalbodeule/hop-gate/internal/admin"
@@ -28,6 +30,7 @@ import (
 	"github.com/dalbodeule/hop-gate/internal/logging"
 	"github.com/dalbodeule/hop-gate/internal/observability"
 	"github.com/dalbodeule/hop-gate/internal/protocol"
+	protocolpb "github.com/dalbodeule/hop-gate/internal/protocol/pb"
 	"github.com/dalbodeule/hop-gate/internal/store"
 )
 
@@ -795,6 +798,8 @@ var (
 	sessionsByDomain = make(map[string]*dtlsSessionWrapper)
 )
 
+// statusRecorder 는 HTTP 응답 상태 코드를 캡처하기 위한 래퍼입니다.
+// Prometheus 메트릭에서 status 라벨을 기록하는 데 사용합니다.
 // statusRecorder 는 HTTP 응답 상태 코드를 캡처하기 위한 래퍼입니다.
 // Prometheus 메트릭에서 status 라벨을 기록하는 데 사용합니다.
 type statusRecorder struct {
@@ -807,6 +812,82 @@ func (w *statusRecorder) WriteHeader(code int) {
 	w.ResponseWriter.WriteHeader(code)
 }
 
+// grpcTunnelServer 는 HopGate gRPC 터널 서비스(HopGateTunnel)의 서버 구현체입니다. (ko)
+// grpcTunnelServer implements the HopGateTunnel gRPC service on the server side. (en)
+type grpcTunnelServer struct {
+	protocolpb.UnimplementedHopGateTunnelServer
+
+	logger logging.Logger
+}
+
+// newGRPCTunnelServer 는 gRPC 터널 서버 구현체를 생성합니다. (ko)
+// newGRPCTunnelServer constructs a new gRPC tunnel server implementation. (en)
+func newGRPCTunnelServer(logger logging.Logger) *grpcTunnelServer {
+	return &grpcTunnelServer{
+		logger: logger.With(logging.Fields{
+			"component": "grpc_tunnel",
+		}),
+	}
+}
+
+// OpenTunnel 은 클라이언트와 서버 간 장기 유지 bi-directional gRPC 스트림을 처리합니다. (ko)
+// OpenTunnel handles the long-lived bi-directional gRPC stream between the
+// server and a HopGate client. At this stage, it only logs incoming envelopes
+// and does not yet integrate with the HTTP proxy layer. (en)
+func (s *grpcTunnelServer) OpenTunnel(stream protocolpb.HopGateTunnel_OpenTunnelServer) error {
+	ctx := stream.Context()
+
+	// 원격 주소가 있으면 로그 필드에 추가합니다. (ko)
+	// Attach remote address from the peer info to log fields when available. (en)
+	fields := logging.Fields{}
+	if p, ok := peer.FromContext(ctx); ok && p.Addr != nil {
+		fields["remote_addr"] = p.Addr.String()
+	}
+
+	log := s.logger.With(fields)
+	log.Info("grpc tunnel opened", nil)
+	defer log.Info("grpc tunnel closed", nil)
+
+	for {
+		env, err := stream.Recv()
+		if err != nil {
+			if err == io.EOF {
+				// 클라이언트가 정상적으로 스트림을 종료한 경우. (ko)
+				// Client closed the stream normally. (en)
+				return nil
+			}
+			log.Error("grpc tunnel receive error", logging.Fields{
+				"error": err.Error(),
+			})
+			return err
+		}
+
+		// 현재 단계에서는 수신된 Envelope 의 payload 타입만 로그에 남기고,
+		// 실제 HTTP 프록시 연동은 후속 3.3 작업에서 구현합니다. (ko)
+		// At this stage we only log the envelope payload type; HTTP proxy
+		// integration will be implemented in later 3.3 steps. (en)
+		payloadType := "unknown"
+		switch env.Payload.(type) {
+		case *protocolpb.Envelope_HttpRequest:
+			payloadType = "http_request"
+		case *protocolpb.Envelope_HttpResponse:
+			payloadType = "http_response"
+		case *protocolpb.Envelope_StreamOpen:
+			payloadType = "stream_open"
+		case *protocolpb.Envelope_StreamData:
+			payloadType = "stream_data"
+		case *protocolpb.Envelope_StreamClose:
+			payloadType = "stream_close"
+		case *protocolpb.Envelope_StreamAck:
+			payloadType = "stream_ack"
+		}
+
+		log.Info("received envelope on grpc tunnel", logging.Fields{
+			"payload_type": payloadType,
+		})
+	}
+}
+
 // hopGateOwnedHeaders 는 HopGate 서버가 스스로 관리하는 응답 헤더 목록입니다. (ko)
 // hopGateOwnedHeaders lists response headers that are owned by the HopGate server. (en)
 var hopGateOwnedHeaders = map[string]struct{}{
@@ -887,6 +968,22 @@ func hostDomainHandler(allowedDomain string, logger logging.Logger, next http.Ha
 	})
 }
 
+// grpcOrHTTPHandler 는 단일 HTTPS 포트에서 gRPC(OpenTunnel)와 일반 HTTP 요청을
+// Content-Type 및 프로토콜(HTTP/2) 기준으로 라우팅하는 헬퍼입니다. (ko)
+// grpcOrHTTPHandler routes between gRPC (OpenTunnel) and regular HTTP handlers
+// on a single HTTPS port, based on Content-Type and protocol (HTTP/2). (en)
+func grpcOrHTTPHandler(grpcServer *grpc.Server, httpHandler http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// gRPC 요청은 HTTP/2 + Content-Type: application/grpc 조합으로 들어옵니다. (ko)
+		// gRPC requests arrive as HTTP/2 with Content-Type: application/grpc. (en)
+		if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
+			grpcServer.ServeHTTP(w, r)
+			return
+		}
+		httpHandler.ServeHTTP(w, r)
+	})
+}
+
 func registerSessionForDomain(domain string, sess dtls.Session, logger logging.Logger) {
 	d := strings.ToLower(strings.TrimSpace(domain))
 	if d == "" {
@@ -1370,23 +1467,6 @@ func main() {
 		}
 	}
 
-	// 4. DTLS 서버 리스너 생성 (pion/dtls 기반)
-	dtlsServer, err := dtls.NewPionServer(dtls.PionServerConfig{
-		Addr:      cfg.DTLSListen,
-		TLSConfig: dtlsTLSConfig,
-	})
-	if err != nil {
-		logger.Error("failed to start dtls server", logging.Fields{
-			"error": err.Error(),
-		})
-		os.Exit(1)
-	}
-	defer dtlsServer.Close()
-
-	logger.Info("dtls server listening", logging.Fields{
-		"addr": cfg.DTLSListen,
-	})
-
 	// 5. HTTP / HTTPS 서버 시작
 	// 프록시 타임아웃은 HOP_SERVER_PROXY_TIMEOUT_SECONDS(초 단위) 로 설정할 수 있으며,
 	// 기본값은 15초입니다. (ko)
@@ -1464,6 +1544,11 @@ func main() {
 	// 기본 HTTP → DTLS Proxy 엔트리 포인트
 	httpMux.Handle("/", httpHandler)
 
+	// gRPC server for client tunnels (OpenTunnel). (en)
+	// 클라이언트 터널(OpenTunnel)을 처리하는 gRPC 서버 인스턴스를 생성합니다. (ko)
+	grpcSrv := grpc.NewServer()
+	protocolpb.RegisterHopGateTunnelServer(grpcSrv, newGRPCTunnelServer(logger))
+
 	// HTTP: 평문 포트
 	httpSrv := &http.Server{
 		Addr:    cfg.HTTPListen,
@@ -1481,9 +1566,15 @@ func main() {
 	}()
 
 	// HTTPS: ACME 기반 TLS 사용 (debug 모드에서도 ACME tls config 사용 가능)
+	// gRPC(OpenTunnel)을 위해 HTTP/2(h2)가 활성화되어 있어야 합니다. (ko)
+	// HTTP/2 (h2) must be enabled for gRPC (OpenTunnel) over TLS. (en)
+	if len(acmeTLSCfg.NextProtos) == 0 {
+		acmeTLSCfg.NextProtos = []string{"h2", "http/1.1"}
+	}
+
 	httpsSrv := &http.Server{
 		Addr:      cfg.HTTPSListen,
-		Handler:   httpMux,
+		Handler:   grpcOrHTTPHandler(grpcSrv, httpMux),
 		TLSConfig: acmeTLSCfg,
 	}
 	go func() {
@@ -1497,89 +1588,11 @@ func main() {
 		}
 	}()
 
-	// 6. 도메인 검증기 준비 (ent + PostgreSQL 기반 실제 구현)
-	// Admin Plane 에서 관리하는 Domain 테이블을 사용해 (domain, client_api_key) 조합을 검증합니다.
-	domainValidator := admin.NewEntDomainValidator(logger, dbClient)
+	// 6. 도메인 검증기 준비 (향후 gRPC 터널 핸드셰이크에서 사용 예정). (ko)
+	// Prepare domain validator (to be used in future gRPC tunnel handshakes). (en)
+	_ = admin.NewEntDomainValidator(logger, dbClient)
 
-	// DTLS 핸드셰이크 단계에서는 클라이언트가 제시한 도메인의 DNS(A/AAAA)가
-	// HOP_ACME_EXPECT_IPS 에 설정된 IP들 중 하나 이상을 가리키는지 추가로 검증합니다. (ko)
-	// During DTLS handshake, additionally verify that the presented domain resolves
-	// (via A/AAAA) to at least one IP configured in HOP_ACME_EXPECT_IPS. (en)
-	// EXPECT_IPS 가 비어 있으면 DNS 기반 검증은 생략하고 DB 검증만 수행합니다. (ko)
-	// If EXPECT_IPS is empty, only DB-based validation is performed. (en)
-	expectedHandshakeIPs := parseExpectedIPsFromEnv(logger, "HOP_ACME_EXPECT_IPS")
-	var validator dtls.DomainValidator = &domainGateValidator{
-		expectedIPs: expectedHandshakeIPs,
-		inner:       domainValidator,
-		logger:      logger,
-	}
-
-	// 7. DTLS Accept 루프 + Handshake
-	for {
-		sess, err := dtlsServer.Accept()
-		if err != nil {
-			logger.Error("dtls accept failed", logging.Fields{
-				"error": err.Error(),
-			})
-			continue
-		}
-
-		// 각 세션별로 goroutine 에서 핸드셰이크 및 후속 처리를 수행합니다.
-		go func(s dtls.Session) {
-			// NOTE: 세션은 HTTP↔DTLS 터널링에 계속 사용해야 하므로 이곳에서 Close 하지 않습니다.
-			// 세션 종료/타임아웃 관리는 별도의 세션 매니저(TODO)에서 담당해야 합니다.
-			hsRes, err := dtls.PerformServerHandshake(ctx, s, validator, logger)
-			if err != nil {
-				// 핸드셰이크 실패 메트릭 기록
-				observability.DTLSHandshakesTotal.WithLabelValues("failure").Inc()
-
-				// PerformServerHandshake 내부에서 이미 상세 로그를 남기므로 여기서는 요약만 기록합니다.
-				logger.Warn("dtls handshake failed", logging.Fields{
-					"session_id": s.ID(),
-					"error":      err.Error(),
-				})
-				// 핸드셰이크 실패 시 세션을 명시적으로 종료하여 invalid SNI 등 오류에서
-				// 연결이 열린 채로 남지 않도록 합니다.
-				_ = s.Close()
-				return
-			}
-
-			// Handshake 성공 메트릭 기록
-			observability.DTLSHandshakesTotal.WithLabelValues("success").Inc()
-
-			// Handshake 성공: 서버 측은 어떤 도메인이 연결되었는지 알 수 있습니다.
-			logger.Info("dtls handshake completed", logging.Fields{
-				"session_id": s.ID(),
-				"domain":     hsRes.Domain,
-			})
-
-			// Handshake 가 완료된 세션을 도메인에 매핑해 HTTP 요청 시 사용할 수 있도록 등록합니다.
-			registerSessionForDomain(hsRes.Domain, s, logger)
-
-			// Handshake 가 정상적으로 끝난 이후, 실제로 해당 도메인에 대해 ACME 인증서를 확보/연장합니다.
-			// Debug 모드에서도 ACME 는 항상 시도하지만, 위에서 HOP_ACME_USE_STAGING=true 로 설정되어
-			// Staging CA 를 사용하게 됩니다.
-			if hsRes.Domain != "" {
-				go func(domain string) {
-					acmeLogger := logger.With(logging.Fields{
-						"component": "acme_post_handshake",
-						"domain":    domain,
-						"debug":     cfg.Debug,
-					})
-					if _, err := acme.NewLegoManagerFromEnv(context.Background(), acmeLogger, []string{domain}); err != nil {
-						acmeLogger.Error("failed to ensure acme certificate after dtls handshake", logging.Fields{
-							"error": err.Error(),
-						})
-						return
-					}
-					acmeLogger.Info("acme certificate ensured after dtls handshake", nil)
-				}(hsRes.Domain)
-			}
-
-			// TODO:
-			//   - hsRes.Domain 과 연결된 세션을 proxy 레이어에 등록
-			//   - HTTP 요청을 이 세션을 통해 해당 클라이언트로 라우팅
-			//   - 세션 생명주기/타임아웃 관리 등
-		}(sess)
-	}
+	// DTLS 레이어 제거 이후에는 gRPC 및 HTTP/HTTPS 서버 goroutine 만 유지합니다. (ko)
+	// After removing the DTLS layer, only the gRPC and HTTP/HTTPS servers are kept running. (en)
+	select {}
 }

go.mod

@@ -7,9 +7,9 @@ require (
 	github.com/go-acme/lego/v4 v4.28.1
 	github.com/google/uuid v1.6.0
 	github.com/lib/pq v1.10.9
-	github.com/pion/dtls/v3 v3.0.7
 	github.com/prometheus/client_golang v1.19.0
 	golang.org/x/net v0.47.0
+	google.golang.org/grpc v1.76.0
 	google.golang.org/protobuf v1.36.10
 )
 
@@ -20,15 +20,13 @@ require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bmatcuk/doublestar v1.3.4 // indirect
 	github.com/cenkalti/backoff/v5 v5.0.3 // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/go-jose/go-jose/v4 v4.1.3 // indirect
 	github.com/go-openapi/inflect v0.19.0 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
 	github.com/hashicorp/hcl/v2 v2.18.1 // indirect
 	github.com/miekg/dns v1.1.68 // indirect
 	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
-	github.com/pion/logging v0.2.4 // indirect
-	github.com/pion/transport/v3 v3.0.7 // indirect
 	github.com/prometheus/client_model v0.5.0 // indirect
 	github.com/prometheus/common v0.48.0 // indirect
 	github.com/prometheus/procfs v0.12.0 // indirect
@@ -41,4 +39,5 @@ require (
 	golang.org/x/sys v0.38.0 // indirect
 	golang.org/x/text v0.31.0 // indirect
 	golang.org/x/tools v0.38.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251022142026-3a174f9686a8 // indirect
 )

go.sum

@@ -14,18 +14,24 @@ github.com/bmatcuk/doublestar v1.3.4 h1:gPypJ5xD31uhX6Tf54sDPUOBXTqKH4c9aPY66CyQ
 github.com/bmatcuk/doublestar v1.3.4/go.mod h1:wiQtGV+rzVYxB7WIlirSN++5HPtPlXEo9MEoZQC/PmE=
 github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
 github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
-github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
-github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/go-acme/lego/v4 v4.28.1 h1:zt301JYF51UIEkpSXsdeGq9hRePeFzQCq070OdAmP0Q=
 github.com/go-acme/lego/v4 v4.28.1/go.mod h1:bzjilr03IgbaOwlH396hq5W56Bi0/uoRwW/JM8hP7m4=
 github.com/go-jose/go-jose/v4 v4.1.3 h1:CVLmWDhDVRa6Mi/IgCgaopNosCaHz7zrMeF9MlZRkrs=
 github.com/go-jose/go-jose/v4 v4.1.3/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4=
 github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
 github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
 github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
@@ -46,12 +52,6 @@ github.com/miekg/dns v1.1.68 h1:jsSRkNozw7G/mnmXULynzMNIsgY2dHC8LO6U6Ij2JEA=
 github.com/miekg/dns v1.1.68/go.mod h1:fujopn7TB3Pu3JM69XaawiU0wqjpL9/8xGop5UrTPps=
 github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
-github.com/pion/dtls/v3 v3.0.7 h1:bItXtTYYhZwkPFk4t1n3Kkf5TDrfj6+4wG+CZR8uI9Q=
-github.com/pion/dtls/v3 v3.0.7/go.mod h1:uDlH5VPrgOQIw59irKYkMudSFprY9IEFCqz/eTz16f8=
-github.com/pion/logging v0.2.4 h1:tTew+7cmQ+Mc1pTBLKH2puKsOvhm32dROumOZ655zB8=
-github.com/pion/logging v0.2.4/go.mod h1:DffhXTKYdNZU+KtJ5pyQDjvOAh/GsNSyv1lbkFbe3so=
-github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0=
-github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU=
@@ -72,6 +72,18 @@ github.com/zclconf/go-cty v1.14.4 h1:uXXczd9QDGsgu0i/QFR/hzI5NYCHLf6NQw/atrbnhq8
 github.com/zclconf/go-cty v1.14.4/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE=
 github.com/zclconf/go-cty-yaml v1.1.0 h1:nP+jp0qPHv2IhUVqmQSzjvqAWcObN0KBkUl2rWBdig0=
 github.com/zclconf/go-cty-yaml v1.1.0/go.mod h1:9YLUH4g7lOhVWqUbctnVlZ5KLpg7JAprQNgxSZ1Gyxs=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
+go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
+go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
+go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
+go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
+go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
+go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
+go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
+go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
+go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
 golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
 golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
 golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA=
@@ -86,6 +98,12 @@ golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
 golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
 golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ=
 golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs=
+gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
+gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251022142026-3a174f9686a8 h1:M1rk8KBnUsBDg1oPGHNCxG4vc1f49epmTO7xscSajMk=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251022142026-3a174f9686a8/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
+google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A=
+google.golang.org/grpc v1.76.0/go.mod h1:Ju12QI8M6iQJtbcsV+awF5a4hfJMLi4X0JLo94ULZ6c=
 google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
 google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

internal/dtls/transport_pion.go

@@ -1,218 +1,58 @@
 package dtls
 
 import (
-	"context"
 	"crypto/tls"
 	"fmt"
-	"net"
 	"time"
-
-	piondtls "github.com/pion/dtls/v3"
 )
 
-// pionSession 은 pion/dtls.Conn 을 감싸 Session 인터페이스를 구현합니다.
-type pionSession struct {
-	conn *piondtls.Conn
-	id   string
-}
-
-func (s *pionSession) Read(b []byte) (int, error)  { return s.conn.Read(b) }
-func (s *pionSession) Write(b []byte) (int, error) { return s.conn.Write(b) }
-func (s *pionSession) Close() error                { return s.conn.Close() }
-func (s *pionSession) ID() string                  { return s.id }
-
-// pionServer 는 pion/dtls 기반 Server 구현입니다.
-type pionServer struct {
-	listener net.Listener
-}
-
-// PionServerConfig 는 DTLS 서버 리스너 구성을 정의합니다.
+// PionServerConfig 는 DTLS 서버 리스너 구성을 정의하는 기존 구조체를 그대로 유지합니다. (ko)
+// PionServerConfig keeps the old DTLS server listener configuration shape for compatibility. (en)
 type PionServerConfig struct {
-	// Addr 는 "0.0.0.0:443" 와 같은 UDP 리스닝 주소입니다.
-	Addr string
-
-	// TLSConfig 는 ACME 등을 통해 준비된 tls.Config 입니다.
-	// Certificates, RootCAs, ClientAuth 등의 설정이 여기서 넘어옵니다.
-	// nil 인 경우 기본 빈 tls.Config 가 사용됩니다.
+	Addr      string
 	TLSConfig *tls.Config
 }
 
-// NewPionServer 는 pion/dtls 기반 DTLS 서버를 생성합니다.
-// 내부적으로 udp 리스너를 열고, DTLS 핸드셰이크를 수행할 준비를 합니다.
-func NewPionServer(cfg PionServerConfig) (Server, error) {
-	if cfg.Addr == "" {
-		return nil, fmt.Errorf("PionServerConfig.Addr is required")
-	}
-	if cfg.TLSConfig == nil {
-		cfg.TLSConfig = &tls.Config{
-			MinVersion: tls.VersionTLS12,
-		}
-	}
-
-	udpAddr, err := net.ResolveUDPAddr("udp", cfg.Addr)
-	if err != nil {
-		return nil, fmt.Errorf("resolve udp addr: %w", err)
-	}
-
-	// tls.Config.GetCertificate (crypto/tls) → pion/dtls.GetCertificate 어댑터
-	var getCert func(*piondtls.ClientHelloInfo) (*tls.Certificate, error)
-	if cfg.TLSConfig.GetCertificate != nil {
-		tlsGetCert := cfg.TLSConfig.GetCertificate
-		getCert = func(chi *piondtls.ClientHelloInfo) (*tls.Certificate, error) {
-			if chi == nil {
-				return tlsGetCert(&tls.ClientHelloInfo{})
-			}
-			// ACME 매니저는 주로 SNI(ServerName)에 기반해 인증서를 선택하므로,
-			// 필요한 최소 필드만 복사해서 전달한다.
-			return tlsGetCert(&tls.ClientHelloInfo{
-				ServerName: chi.ServerName,
-			})
-		}
-	}
-
-	dtlsCfg := &piondtls.Config{
-		// 서버가 사용할 인증서 설정: 정적 Certificates + GetCertificate 어댑터
-		Certificates:       cfg.TLSConfig.Certificates,
-		GetCertificate:     getCert,
-		InsecureSkipVerify: cfg.TLSConfig.InsecureSkipVerify,
-		ClientAuth:         piondtls.ClientAuthType(cfg.TLSConfig.ClientAuth),
-		ClientCAs:          cfg.TLSConfig.ClientCAs,
-		RootCAs:            cfg.TLSConfig.RootCAs,
-		ServerName:         cfg.TLSConfig.ServerName,
-		// 필요 시 ExtendedMasterSecret 등을 추가 설정
-	}
-	l, err := piondtls.Listen("udp", udpAddr, dtlsCfg)
-	if err != nil {
-		return nil, fmt.Errorf("dtls listen: %w", err)
-	}
-
-	return &pionServer{
-		listener: l,
-	}, nil
-}
-
-// Accept 는 새로운 DTLS 연결을 수락하고, Session 으로 래핑합니다.
-func (s *pionServer) Accept() (Session, error) {
-	conn, err := s.listener.Accept()
-	if err != nil {
-		return nil, err
-	}
-	dtlsConn, ok := conn.(*piondtls.Conn)
-	if !ok {
-		_ = conn.Close()
-		return nil, fmt.Errorf("accepted connection is not *dtls.Conn")
-	}
-
-	id := ""
-	if ra := dtlsConn.RemoteAddr(); ra != nil {
-		id = ra.String()
-	}
-
-	return &pionSession{
-		conn: dtlsConn,
-		id:   id,
-	}, nil
-}
-
-// Close 는 DTLS 리스너를 종료합니다.
-func (s *pionServer) Close() error {
-	return s.listener.Close()
-}
-
-// pionClient 는 pion/dtls 기반 Client 구현입니다.
-type pionClient struct {
-	addr      string
-	tlsConfig *tls.Config
-	timeout   time.Duration
-}
-
-// PionClientConfig 는 DTLS 클라이언트 구성을 정의합니다.
+// PionClientConfig 는 DTLS 클라이언트 구성을 정의하는 기존 구조체를 그대로 유지합니다. (ko)
+// PionClientConfig keeps the old DTLS client configuration shape for compatibility. (en)
 type PionClientConfig struct {
-	// Addr 는 서버의 UDP 주소 (예: "example.com:443") 입니다.
-	Addr string
-
-	// TLSConfig 는 서버 인증에 사용할 tls.Config 입니다.
-	// InsecureSkipVerify=true 로 두면 서버 인증을 건너뛰므로 개발/테스트에만 사용해야 합니다.
+	Addr      string
 	TLSConfig *tls.Config
-
-	// Timeout 은 DTLS 핸드셰이크 타임아웃입니다.
-	// 0 이면 기본값 10초가 사용됩니다.
-	Timeout time.Duration
+	Timeout   time.Duration
 }
 
-// NewPionClient 는 pion/dtls 기반 DTLS 클라이언트를 생성합니다.
-func NewPionClient(cfg PionClientConfig) Client {
-	if cfg.Timeout == 0 {
-		cfg.Timeout = 10 * time.Second
-	}
-	if cfg.TLSConfig == nil {
-		// 기본값: 인증서 검증을 수행하는 안전한 설정(루트 CA 체인은 시스템 기본값 사용).
-		// 디버그 모드에서 인증서 검증을 스킵하고 싶다면, 호출 측에서
-		// TLSConfig: &tls.Config{InsecureSkipVerify: true} 를 명시적으로 전달해야 합니다.
-		cfg.TLSConfig = &tls.Config{
-			MinVersion: tls.VersionTLS12,
-		}
-	}
-	return &pionClient{
-		addr:      cfg.Addr,
-		tlsConfig: cfg.TLSConfig,
-		timeout:   cfg.Timeout,
-	}
+// disabledServer 는 DTLS 전송이 비활성화되었음을 나타내는 더미 구현입니다. (ko)
+// disabledServer is a dummy Server implementation indicating that DTLS transport is disabled. (en)
+type disabledServer struct{}
+
+func (s *disabledServer) Accept() (Session, error) {
+	return nil, fmt.Errorf("dtls transport is disabled; use gRPC tunnel instead")
 }
 
-// Connect 는 서버와 DTLS 핸드셰이크를 수행하고 Session 을 반환합니다.
-func (c *pionClient) Connect() (Session, error) {
-	if c.addr == "" {
-		return nil, fmt.Errorf("PionClientConfig.Addr is required")
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
-	defer cancel()
-
-	raddr, err := net.ResolveUDPAddr("udp", c.addr)
-	if err != nil {
-		return nil, fmt.Errorf("resolve udp addr: %w", err)
-	}
-
-	dtlsCfg := &piondtls.Config{
-		// 클라이언트는 서버 인증을 위해 RootCAs/ServerName 만 사용.
-		// (현재는 클라이언트 인증서 사용 계획이 없으므로 GetCertificate 는 전달하지 않는다.)
-		Certificates:       c.tlsConfig.Certificates,
-		InsecureSkipVerify: c.tlsConfig.InsecureSkipVerify,
-		RootCAs:            c.tlsConfig.RootCAs,
-		ServerName:         c.tlsConfig.ServerName,
-	}
-
-	type result struct {
-		conn *piondtls.Conn
-		err  error
-	}
-	ch := make(chan result, 1)
-
-	go func() {
-		conn, err := piondtls.Dial("udp", raddr, dtlsCfg)
-		ch <- result{conn: conn, err: err}
-	}()
-
-	select {
-	case <-ctx.Done():
-		return nil, fmt.Errorf("dtls dial timeout: %w", ctx.Err())
-	case res := <-ch:
-		if res.err != nil {
-			return nil, fmt.Errorf("dtls dial: %w", res.err)
-		}
-		id := ""
-		if ra := res.conn.RemoteAddr(); ra != nil {
-			id = ra.String()
-		}
-		return &pionSession{
-			conn: res.conn,
-			id:   id,
-		}, nil
-	}
-}
-
-// Close 는 클라이언트 단에서 유지하는 리소스가 없으므로 no-op 입니다.
-func (c *pionClient) Close() error {
+func (s *disabledServer) Close() error {
 	return nil
 }
+
+// disabledClient 는 DTLS 전송이 비활성화되었음을 나타내는 더미 구현입니다. (ko)
+// disabledClient is a dummy Client implementation indicating that DTLS transport is disabled. (en)
+type disabledClient struct{}
+
+func (c *disabledClient) Connect() (Session, error) {
+	return nil, fmt.Errorf("dtls transport is disabled; use gRPC tunnel instead")
+}
+
+func (c *disabledClient) Close() error {
+	return nil
+}
+
+// NewPionServer 는 더 이상 실제 DTLS 서버를 생성하지 않고, 항상 에러를 반환합니다. (ko)
+// NewPionServer no longer creates a real DTLS server and always returns an error. (en)
+func NewPionServer(cfg PionServerConfig) (Server, error) {
+	return nil, fmt.Errorf("dtls transport is disabled; NewPionServer is no longer supported")
+}
+
+// NewPionClient 는 더 이상 실제 DTLS 클라이언트를 생성하지 않고, disabledClient 를 반환합니다. (ko)
+// NewPionClient no longer creates a real DTLS client and instead returns a disabledClient. (en)
+func NewPionClient(cfg PionClientConfig) Client {
+	return &disabledClient{}
+}

internal/protocol/pb/hopgate_stream_grpc.go

@@ -0,0 +1,119 @@
+package pb
+
+import (
+	"context"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+// HopGateTunnelClient is the client API for the HopGateTunnel service.
+type HopGateTunnelClient interface {
+	// OpenTunnel establishes a long-lived bi-directional stream between
+	// a HopGate client and the server. Both HTTP requests and responses
+	// are multiplexed as Envelope messages on this stream.
+	OpenTunnel(ctx context.Context, opts ...grpc.CallOption) (HopGateTunnel_OpenTunnelClient, error)
+}
+
+type hopGateTunnelClient struct {
+	cc grpc.ClientConnInterface
+}
+
+// NewHopGateTunnelClient creates a new HopGateTunnelClient.
+func NewHopGateTunnelClient(cc grpc.ClientConnInterface) HopGateTunnelClient {
+	return &hopGateTunnelClient{cc: cc}
+}
+
+func (c *hopGateTunnelClient) OpenTunnel(ctx context.Context, opts ...grpc.CallOption) (HopGateTunnel_OpenTunnelClient, error) {
+	stream, err := c.cc.NewStream(ctx, &_HopGateTunnel_serviceDesc.Streams[0], "/hopgate.protocol.v1.HopGateTunnel/OpenTunnel", opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &hopGateTunnelOpenTunnelClient{ClientStream: stream}, nil
+}
+
+// HopGateTunnel_OpenTunnelClient is the client-side stream for OpenTunnel.
+type HopGateTunnel_OpenTunnelClient interface {
+	Send(*Envelope) error
+	Recv() (*Envelope, error)
+	grpc.ClientStream
+}
+
+type hopGateTunnelOpenTunnelClient struct {
+	grpc.ClientStream
+}
+
+func (x *hopGateTunnelOpenTunnelClient) Send(m *Envelope) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *hopGateTunnelOpenTunnelClient) Recv() (*Envelope, error) {
+	m := new(Envelope)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// HopGateTunnelServer is the server API for the HopGateTunnel service.
+type HopGateTunnelServer interface {
+	// OpenTunnel handles a long-lived bi-directional stream between the server
+	// and a HopGate client. Implementations are responsible for reading and
+	// writing Envelope messages on the stream.
+	OpenTunnel(HopGateTunnel_OpenTunnelServer) error
+}
+
+// UnimplementedHopGateTunnelServer can be embedded to have forward compatible implementations.
+type UnimplementedHopGateTunnelServer struct{}
+
+// OpenTunnel returns an Unimplemented error by default.
+func (UnimplementedHopGateTunnelServer) OpenTunnel(HopGateTunnel_OpenTunnelServer) error {
+	return status.Errorf(codes.Unimplemented, "method OpenTunnel not implemented")
+}
+
+// RegisterHopGateTunnelServer registers the HopGateTunnel service with the given gRPC server.
+func RegisterHopGateTunnelServer(s grpc.ServiceRegistrar, srv HopGateTunnelServer) {
+	s.RegisterService(&_HopGateTunnel_serviceDesc, srv)
+}
+
+// HopGateTunnel_OpenTunnelServer is the server-side stream for OpenTunnel.
+type HopGateTunnel_OpenTunnelServer interface {
+	Send(*Envelope) error
+	Recv() (*Envelope, error)
+	grpc.ServerStream
+}
+
+func _HopGateTunnel_OpenTunnel_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(HopGateTunnelServer).OpenTunnel(&hopGateTunnelOpenTunnelServer{ServerStream: stream})
+}
+
+type hopGateTunnelOpenTunnelServer struct {
+	grpc.ServerStream
+}
+
+func (x *hopGateTunnelOpenTunnelServer) Send(m *Envelope) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *hopGateTunnelOpenTunnelServer) Recv() (*Envelope, error) {
+	m := new(Envelope)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+var _HopGateTunnel_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "hopgate.protocol.v1.HopGateTunnel",
+	HandlerType: (*HopGateTunnelServer)(nil),
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "OpenTunnel",
+			Handler:       _HopGateTunnel_OpenTunnel_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "internal/protocol/hopgate_stream.proto",
+}

internal/proxy/client.go

@@ -14,7 +14,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/dalbodeule/hop-gate/internal/dtls"
 	"github.com/dalbodeule/hop-gate/internal/logging"
 	"github.com/dalbodeule/hop-gate/internal/protocol"
 )
@@ -144,9 +143,9 @@ type streamReceiver struct {
 	// Input channel for envelopes dispatched from the central readLoop. (en)
 	inCh chan *protocol.Envelope
 
-	// DTLS 세션 및 직렬화 codec / 로깅 핸들. (ko)
-	// DTLS session, wire codec and logging handles. (en)
-	sess   dtls.Session
+	// 세션(write 방향) 및 직렬화 codec / 로깅 핸들. (ko)
+	// Session (write side only), wire codec and logging handles. (en)
+	sess   io.ReadWriter
 	codec  protocol.WireCodec
 	logger logging.Logger
 
@@ -161,7 +160,7 @@ type streamReceiver struct {
 // newStreamReceiver initializes a streamReceiver for a single stream ID. (en)
 func newStreamReceiver(
 	id protocol.StreamID,
-	sess dtls.Session,
+	sess io.ReadWriter,
 	codec protocol.WireCodec,
 	logger logging.Logger,
 	httpClient *http.Client,
@@ -604,7 +603,7 @@ func (p *ClientProxy) getStreamSender(id protocol.StreamID) *streamSender {
 //   - `handleStreamRequest` 내부 HTTP 매핑 로직을 `streamReceiver` 로 옮기고,
 //   - StartLoop 가 DTLS 세션 → per-stream goroutine 으로 이벤트를 분배하는 역할만 수행하도록
 //     점진적으로 리팩터링할 예정입니다.
-func (p *ClientProxy) StartLoop(ctx context.Context, sess dtls.Session) error {
+func (p *ClientProxy) StartLoop(ctx context.Context, sess io.ReadWriter) error {
 	if ctx == nil {
 		ctx = context.Background()
 	}
@@ -839,7 +838,7 @@ func (p *ClientProxy) StartLoop(ctx context.Context, sess dtls.Session) error {
 
 // handleHTTPEnvelope 는 기존 단일 HTTP 요청/응답 Envelope 경로를 처리합니다. (ko)
 // handleHTTPEnvelope handles the legacy single HTTP request/response envelope path. (en)
-func (p *ClientProxy) handleHTTPEnvelope(ctx context.Context, sess dtls.Session, env *protocol.Envelope) error {
+func (p *ClientProxy) handleHTTPEnvelope(ctx context.Context, sess io.ReadWriter, env *protocol.Envelope) error {
 	if env.HTTPRequest == nil {
 		return fmt.Errorf("http envelope missing http_request payload")
 	}
@@ -896,7 +895,7 @@ func (p *ClientProxy) handleHTTPEnvelope(ctx context.Context, sess dtls.Session,
 
 // handleStreamRequest 는 StreamOpen/StreamData/StreamClose 기반 HTTP 요청/응답 스트림을 처리합니다. (ko)
 // handleStreamRequest handles an HTTP request/response exchange using StreamOpen/StreamData/StreamClose frames. (en)
-func (p *ClientProxy) handleStreamRequest(ctx context.Context, sess dtls.Session, reader io.Reader, openEnv *protocol.Envelope) error {
+func (p *ClientProxy) handleStreamRequest(ctx context.Context, sess io.ReadWriter, reader io.Reader, openEnv *protocol.Envelope) error {
 	codec := protocol.DefaultCodec
 	log := p.Logger
 

progress.md

@@ -229,7 +229,7 @@ This document tracks implementation progress against the HopGate architecture an
 HopGate 의 최종 목표는 **TCP + TLS(HTTPS) + HTTP/2 + gRPC** 기반 터널로 HTTP 트래픽을 전달하는 것입니다.
 이 섹션에서는 DTLS 기반 초기 설계를 정리만 남기고, 실제 구현/남은 작업은 gRPC 터널 기준으로 재정의합니다.
 
-- [ ] 서버 측 gRPC 터널 엔드포인트 설계/구현
+- [x] 서버 측 gRPC 터널 엔드포인트 설계/구현
   - 외부 사용자용 HTTPS(443/TCP)와 같은 포트에서:
     - 일반 HTTP 요청(브라우저/REST)은 기존 리버스 프록시 경로로,
     - `Content-Type: application/grpc` 인 요청은 클라이언트 터널용 gRPC 서버로
@@ -237,7 +237,7 @@ HopGate 의 최종 목표는 **TCP + TLS(HTTPS) + HTTP/2 + gRPC** 기반 터널
   - 예시: `rpc OpenTunnel(stream TunnelFrame) returns (stream TunnelFrame)` (bi-directional streaming).
   - HTTP/2 + ALPN(h2)을 사용해 gRPC 스트림을 유지하고, 요청/응답 HTTP 메시지를 `TunnelFrame`으로 멀티플렉싱합니다.
 
-- [ ] 클라이언트 측 gRPC 터널 설계/구현
+- [x] 클라이언트 측 gRPC 터널 설계/구현
   - 클라이언트 프로세스는 HopGate 서버로 장기 유지 bi-di gRPC 스트림을 **하나(또는 소수 개)** 연 상태로 유지합니다.
   - 서버로부터 들어오는 `TunnelFrame`(요청 메타데이터 + 바디 chunk)을 수신해,
     로컬 HTTP 서비스(예: `127.0.0.1:8080`)로 proxy 하고, 응답을 다시 `TunnelFrame` 시퀀스로 전송합니다.