finish inverse role server support for webtunnel

Author: xiaokangwang

main/commands/all/engineering/generateRandomData/errors.generated.go

@@ -0,0 +1,9 @@
+package generateRandomData
+
+import "github.com/v2fly/v2ray-core/v5/common/errors"
+
+type errPathObjHolder struct{}
+
+func newError(values ...interface{}) *errors.Error {
+	return errors.New(values...).WithPathObj(errPathObjHolder{})
+}

main/commands/all/engineering/generateRandomData/generateRandomData.go

@@ -0,0 +1,65 @@
+package generateRandomData
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+	"flag"
+	"fmt"
+
+	"github.com/v2fly/v2ray-core/v5/main/commands/all/engineering"
+	"github.com/v2fly/v2ray-core/v5/main/commands/base"
+)
+
+//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
+
+var length *int
+
+var cmdGenerateRandomData = &base.Command{
+	UsageLine: "{{.Exec}} engineering generate-random-data",
+	Short:     "generate random data and output as base64",
+	Long: `
+Generate random data of specified length and output as base64 encoded string.
+
+Usage:
+	{{.Exec}} engineering generate-random-data -length <bytes>
+
+Options:
+	-length <bytes>
+		The number of random bytes to generate (required)
+
+Example:
+	{{.Exec}} engineering generate-random-data -length 32
+`,
+	Flag: func() flag.FlagSet {
+		fs := flag.NewFlagSet("", flag.ExitOnError)
+		length = fs.Int("length", 0, "number of random bytes to generate")
+		return *fs
+	}(),
+	Run: func(cmd *base.Command, args []string) {
+		err := cmd.Flag.Parse(args)
+		if err != nil {
+			base.Fatalf("failed to parse flags: %v", err)
+		}
+
+		if *length <= 0 {
+			base.Fatalf("length must be a positive integer, got: %d", *length)
+		}
+
+		// Generate random data
+		randomData := make([]byte, *length)
+		_, err = rand.Read(randomData)
+		if err != nil {
+			base.Fatalf("failed to generate random data: %v", err)
+		}
+
+		// Encode to base64
+		encoded := base64.StdEncoding.EncodeToString(randomData)
+
+		// Output the result
+		fmt.Println(encoded)
+	},
+}
+
+func init() {
+	engineering.AddCommand(cmdGenerateRandomData)
+}

main/distro/all/all.go

@@ -113,6 +113,7 @@ import (
 
 	// engineering commands
 	_ "github.com/v2fly/v2ray-core/v5/main/commands/all/engineering"
+	_ "github.com/v2fly/v2ray-core/v5/main/commands/all/engineering/generateRandomData"
 
 	// Commands that rely on jsonv4 format This disable selective compile
 	_ "github.com/v2fly/v2ray-core/v5/main/commands/all/api/jsonv4"

transport/internet/request/roundtripper/httprt/httprt.go

@@ -82,7 +82,7 @@ func (h *httpTripperClient) RoundTrip(ctx context.Context, req request.Request,
 		if err != nil {
 			return request.Response{}, err
 		}
-		return request.Response{Data: result}, err
+		return request.Response{Data: result}, nil
 	}
 	_, err = io.Copy(streamingWriter, httpResp.Body)
 	if err != nil {
@@ -170,10 +170,10 @@ func (h *httpTripperServer) Start() error {
 	h.listener = listener
 	go func() {
 		httpServer := http.Server{
-			ReadHeaderTimeout: 15 * time.Second,
-			ReadTimeout:       15 * time.Second,
-			WriteTimeout:      10 * time.Second,
-			IdleTimeout:       30 * time.Second,
+			ReadHeaderTimeout: 240 * time.Second,
+			ReadTimeout:       240 * time.Second,
+			WriteTimeout:      240 * time.Second,
+			IdleTimeout:       240 * time.Second,
 		}
 		httpServer.Handler = h
 		err := httpServer.Serve(h.listener)

transport/internet/request/roundtripperreverserserver/reverser.go

@@ -46,6 +46,9 @@ func (s *Reverser) OnRoundTrip(ctx context.Context, req request.Request, opts ..
 		}
 		return reverserImpl, nil
 	}
+	if len(req.ConnectionTag) != 32 {
+		return request.Response{}, newError("invalid ConnectionTag length")
+	}
 	reverserImpl, err := s.reverser.OnOtherRoundTrip(ctx, req, opts...)
 	if err != nil {
 		return request.Response{}, newError("failed to handle client round trip").Base(err).AtError()

transport/internet/request/roundtripperreverserserver/reverserimpl.go

@@ -93,6 +93,9 @@ func (r *ReverserImpl) OnOtherRoundTrip(ctx context.Context, req request.Request
 		messageQueue: make(chan *reverserMessage, 1),
 	})
 	state := stateInterface.(*clientState)
+	defer func() {
+		r.clientTemporaryKeyToStateMap.Delete(string(sourceKey))
+	}()
 
 	serverStateInterface, ok := r.serverPublicKeyToStateMap.Load(string(destKey))
 	if ok {

transport/internet/tlsmirror/mirrorenrollment/cancelContextOnCloseConn.go

@@ -0,0 +1,23 @@
+package mirrorenrollment
+
+import (
+	"context"
+	"net"
+)
+
+func NewCancelContextOnCloseConn(conn net.Conn, done context.CancelFunc) net.Conn {
+	return &cancelContextOnCloseConn{
+		Conn: conn,
+		done: done,
+	}
+}
+
+type cancelContextOnCloseConn struct {
+	net.Conn
+	done context.CancelFunc
+}
+
+func (c *cancelContextOnCloseConn) Close() error {
+	c.done()
+	return c.Conn.Close()
+}

transport/internet/tlsmirror/mirrorenrollment/client.go

@@ -98,7 +98,14 @@ func (c *EnrollmentConfirmationClient) init() error {
 				primaryConfirmationOutbound = transportEnvironment.SelfProxyTag()
 				loopbackProtectedCtx = mirrorcommon.SetSecondaryLoopbackProtectionFlagForContext(c.ctx, c.serverIdentity)
 			}
-			return dialer(loopbackProtectedCtx, dest, primaryConfirmationOutbound)
+			connContext, done := context.WithCancel(loopbackProtectedCtx)
+			conn, err := dialer(connContext, dest, primaryConfirmationOutbound)
+			if err != nil {
+				done()
+				return nil, newError("failed to dial to destination").Base(err).AtError()
+			}
+			contextLinkedConn := NewCancelContextOnCloseConn(conn, done)
+			return contextLinkedConn, nil
 		}, c.serverIdentity)
 	if err != nil {
 		return newError("failed to create HTTP round tripper for enrollment confirmation").Base(err).AtError()

transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/clientbuilder.go

@@ -5,8 +5,11 @@ import (
 	"net"
 	"net/http"
 	"sync"
+	"time"
 
+	"github.com/desertbit/timer"
 	"github.com/v2fly/v2ray-core/v5/common"
+	"github.com/v2fly/v2ray-core/v5/common/signal/done"
 	"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
 	"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/httponconnection"
 )
@@ -81,8 +84,30 @@ func (c *clientRoundtripper) roundTrip(request *http.Request) (*http.Response, e
 	}
 	defer c.currentConnLock.RUnlock()
 
+	timeoutTimer := timer.NewTimer(30 * time.Second)
+	defer timeoutTimer.Stop()
+
+	waitForConnection := done.New()
+
+	var resp *http.Response
+	var error_resp_ error
+	var err error
+
+	go func() {
+		resp_, err_ := c.currentConn.RoundTrip(request)
+		resp = resp_
+		error_resp_ = err_
+		waitForConnection.Close()
+	}()
+
+	select {
+	case <-timeoutTimer.C:
+		err = newError("timeout during enrollment verification round trip")
+	case <-waitForConnection.Wait():
+		err = error_resp_
+	}
+
 	// Use the current connection to perform the round trip
-	resp, err := c.currentConn.RoundTrip(request)
 	if err != nil {
 		defer func() {
 			c.currentConnLock.RUnlock()

transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/serverinverserole.go

@@ -55,6 +55,8 @@ func NewServerInverseRole(ctx context.Context, config *ServerInverseRoleConfig)
 
 	rttClient.OnTransportClientAssemblyReady(c)
 
+	go c.worker(ctx)
+
 	return c, nil
 }
 
@@ -78,6 +80,7 @@ func (c *ServerInverseRole) worker(ctx context.Context) {
 			newError("error polling remote for enrollment").Base(err).AtWarning().WriteToLog()
 		}
 	}
+	newError("inverse role server quitted").AtWarning().WriteToLog()
 }
 
 func (c *ServerInverseRole) Dial(ctx context.Context) (net.Conn, error) {
@@ -149,14 +152,15 @@ func (s *ServerInverseRole) pollRemoteForEnrollment(ctx context.Context) error {
 	if err != nil {
 		return newError("failed to marshal enrollment confirmation response").Base(err).AtError()
 	}
-	respAs := append(s.config.ServerIdentity, enrollmentReq.ClientIdentifier...) //nolint:gocritic
+	respAs := append(s.config.ServerIdentity, enrollmentReq.ReplyAddressTag...) //nolint:gocritic
 	_, err = s.rttClient.RoundTrip(ctx, request.Request{
 		Data:          respData,
 		ConnectionTag: respAs,
 	})
 	if err != nil {
 		return newError("failed to send enrollment confirmation response back to remote").Base(err)
 	}
+	newError("successfully processed enrollment confirmation request").AtDebug().WriteToLog()
 	return nil
 }