From 64f730d2dfca52b7d5a68199b3e8a3c2e780695a Mon Sep 17 00:00:00 2001 From: dalbodeule <11470513+dalbodeule@users.noreply.github.com> Date: Thu, 11 Dec 2025 16:48:17 +0900 Subject: [PATCH] [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 | 223 ++++++++++++------ cmd/server/main.go | 217 +++++++++--------- go.mod | 7 +- go.sum | 34 ++- internal/dtls/transport_pion.go | 236 ++++---------------- internal/protocol/pb/hopgate_stream_grpc.go | 119 ++++++++++ internal/proxy/client.go | 15 +- progress.md | 4 +- 8 files changed, 463 insertions(+), 392 deletions(-) create mode 100644 internal/protocol/pb/hopgate_stream_grpc.go diff --git a/cmd/client/main.go b/cmd/client/main.go index ad0848d..a00185d 100644 --- a/cmd/client/main.go +++ b/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) } diff --git a/cmd/server/main.go b/cmd/server/main.go index cdb886f..c9e659c 100644 --- a/cmd/server/main.go +++ b/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 {} } diff --git a/go.mod b/go.mod index 4c023aa..3e160e1 100644 --- a/go.mod +++ b/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 ) diff --git a/go.sum b/go.sum index cfe1a69..e1ca9b7 100644 --- a/go.sum +++ b/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= diff --git a/internal/dtls/transport_pion.go b/internal/dtls/transport_pion.go index ae88c6c..cbe885d 100644 --- a/internal/dtls/transport_pion.go +++ b/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{} +} diff --git a/internal/protocol/pb/hopgate_stream_grpc.go b/internal/protocol/pb/hopgate_stream_grpc.go new file mode 100644 index 0000000..36e403e --- /dev/null +++ b/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", +} diff --git a/internal/proxy/client.go b/internal/proxy/client.go index be2cd22..91108e2 100644 --- a/internal/proxy/client.go +++ b/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 diff --git a/progress.md b/progress.md index adff4af..1b00ac7 100644 --- a/progress.md +++ b/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` 시퀀스로 전송합니다.