repo stringlengths 6 47 | file_url stringlengths 77 269 | file_path stringlengths 5 186 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-07 08:35:43 2026-01-07 08:55:24 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/headers/http/errors.generated.go | transport/internet/headers/http/errors.generated.go | package http
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/headers/http/config.go | transport/internet/headers/http/config.go | package http
import (
"strings"
"github.com/v2fly/v2ray-core/v5/common/dice"
)
func pickString(arr []string) string {
n := len(arr)
switch n {
case 0:
return ""
case 1:
return arr[0]
default:
return arr[dice.Roll(n)]
}
}
func (v *RequestConfig) PickURI() string {
return pickString(v.Uri)
}
func (v *RequestConfig) PickHeaders() []string {
n := len(v.Header)
if n == 0 {
return nil
}
headers := make([]string, n)
for idx, headerConfig := range v.Header {
headerName := headerConfig.Name
headerValue := pickString(headerConfig.Value)
headers[idx] = headerName + ": " + headerValue
}
return headers
}
func (v *RequestConfig) GetVersionValue() string {
if v == nil || v.Version == nil {
return "1.1"
}
return v.Version.Value
}
func (v *RequestConfig) GetMethodValue() string {
if v == nil || v.Method == nil {
return "GET"
}
return v.Method.Value
}
func (v *RequestConfig) GetFullVersion() string {
return "HTTP/" + v.GetVersionValue()
}
func (v *ResponseConfig) HasHeader(header string) bool {
cHeader := strings.ToLower(header)
for _, tHeader := range v.Header {
if strings.EqualFold(tHeader.Name, cHeader) {
return true
}
}
return false
}
func (v *ResponseConfig) PickHeaders() []string {
n := len(v.Header)
if n == 0 {
return nil
}
headers := make([]string, n)
for idx, headerConfig := range v.Header {
headerName := headerConfig.Name
headerValue := pickString(headerConfig.Value)
headers[idx] = headerName + ": " + headerValue
}
return headers
}
func (v *ResponseConfig) GetVersionValue() string {
if v == nil || v.Version == nil {
return "1.1"
}
return v.Version.Value
}
func (v *ResponseConfig) GetFullVersion() string {
return "HTTP/" + v.GetVersionValue()
}
func (v *ResponseConfig) GetStatusValue() *Status {
if v == nil || v.Status == nil {
return &Status{
Code: "200",
Reason: "OK",
}
}
return v.Status
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/headers/http/linkedreadRequest.go | transport/internet/headers/http/linkedreadRequest.go | package http
import (
"bufio"
"net/http"
_ "unsafe"
)
//go:linkname readRequest net/http.readRequest
func readRequest(b *bufio.Reader) (req *http.Request, err error)
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/headers/http/http_test.go | transport/internet/headers/http/http_test.go | package http_test
import (
"bufio"
"bytes"
"context"
"crypto/rand"
"strings"
"testing"
"time"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net"
. "github.com/v2fly/v2ray-core/v5/transport/internet/headers/http"
)
func TestReaderWriter(t *testing.T) {
cache := buf.New()
b := buf.New()
common.Must2(b.WriteString("abcd" + ENDING))
writer := NewHeaderWriter(b)
err := writer.Write(cache)
common.Must(err)
if v := cache.Len(); v != 8 {
t.Error("cache len: ", v)
}
_, err = cache.Write([]byte{'e', 'f', 'g'})
common.Must(err)
reader := &HeaderReader{}
_, err = reader.Read(cache)
if err != nil && !strings.HasPrefix(err.Error(), "malformed HTTP request") {
t.Error("unknown error ", err)
}
}
func TestRequestHeader(t *testing.T) {
auth, err := NewAuthenticator(context.Background(), &Config{
Request: &RequestConfig{
Uri: []string{"/"},
Header: []*Header{
{
Name: "Test",
Value: []string{"Value"},
},
},
},
})
common.Must(err)
cache := buf.New()
err = auth.GetClientWriter().Write(cache)
common.Must(err)
if cache.String() != "GET / HTTP/1.1\r\nTest: Value\r\n\r\n" {
t.Error("cache: ", cache.String())
}
}
func TestLongRequestHeader(t *testing.T) {
payload := make([]byte, buf.Size+2)
common.Must2(rand.Read(payload[:buf.Size-2]))
copy(payload[buf.Size-2:], ENDING)
payload = append(payload, []byte("abcd")...)
reader := HeaderReader{}
_, err := reader.Read(bytes.NewReader(payload))
if err != nil && !(strings.HasPrefix(err.Error(), "invalid") || strings.HasPrefix(err.Error(), "malformed")) {
t.Error("unknown error ", err)
}
}
func TestConnection(t *testing.T) {
auth, err := NewAuthenticator(context.Background(), &Config{
Request: &RequestConfig{
Method: &Method{Value: "Post"},
Uri: []string{"/testpath"},
Header: []*Header{
{
Name: "Host",
Value: []string{"www.v2fly.org", "www.google.com"},
},
{
Name: "User-Agent",
Value: []string{"Test-Agent"},
},
},
},
Response: &ResponseConfig{
Version: &Version{
Value: "1.1",
},
Status: &Status{
Code: "404",
Reason: "Not Found",
},
},
})
common.Must(err)
listener, err := net.Listen("tcp", "127.0.0.1:0")
common.Must(err)
go func() {
conn, err := listener.Accept()
common.Must(err)
authConn := auth.Server(conn)
b := make([]byte, 256)
for {
n, err := authConn.Read(b)
if err != nil {
break
}
_, err = authConn.Write(b[:n])
common.Must(err)
}
}()
conn, err := net.DialTCP("tcp", nil, listener.Addr().(*net.TCPAddr))
common.Must(err)
authConn := auth.Client(conn)
defer authConn.Close()
authConn.Write([]byte("Test payload"))
authConn.Write([]byte("Test payload 2"))
expectedResponse := "Test payloadTest payload 2"
actualResponse := make([]byte, 256)
deadline := time.Now().Add(time.Second * 5)
totalBytes := 0
for {
n, err := authConn.Read(actualResponse[totalBytes:])
common.Must(err)
totalBytes += n
if totalBytes >= len(expectedResponse) || time.Now().After(deadline) {
break
}
}
if string(actualResponse[:totalBytes]) != expectedResponse {
t.Error("response: ", string(actualResponse[:totalBytes]))
}
}
func TestConnectionInvPath(t *testing.T) {
auth, err := NewAuthenticator(context.Background(), &Config{
Request: &RequestConfig{
Method: &Method{Value: "Post"},
Uri: []string{"/testpath"},
Header: []*Header{
{
Name: "Host",
Value: []string{"www.v2fly.org", "www.google.com"},
},
{
Name: "User-Agent",
Value: []string{"Test-Agent"},
},
},
},
Response: &ResponseConfig{
Version: &Version{
Value: "1.1",
},
Status: &Status{
Code: "404",
Reason: "Not Found",
},
},
})
common.Must(err)
authR, err := NewAuthenticator(context.Background(), &Config{
Request: &RequestConfig{
Method: &Method{Value: "Post"},
Uri: []string{"/testpathErr"},
Header: []*Header{
{
Name: "Host",
Value: []string{"www.v2fly.org", "www.google.com"},
},
{
Name: "User-Agent",
Value: []string{"Test-Agent"},
},
},
},
Response: &ResponseConfig{
Version: &Version{
Value: "1.1",
},
Status: &Status{
Code: "404",
Reason: "Not Found",
},
},
})
common.Must(err)
listener, err := net.Listen("tcp", "127.0.0.1:0")
common.Must(err)
go func() {
conn, err := listener.Accept()
common.Must(err)
authConn := auth.Server(conn)
b := make([]byte, 256)
for {
n, err := authConn.Read(b)
if err != nil {
authConn.Close()
break
}
_, err = authConn.Write(b[:n])
common.Must(err)
}
}()
conn, err := net.DialTCP("tcp", nil, listener.Addr().(*net.TCPAddr))
common.Must(err)
authConn := authR.Client(conn)
defer authConn.Close()
authConn.Write([]byte("Test payload"))
authConn.Write([]byte("Test payload 2"))
expectedResponse := "Test payloadTest payload 2"
actualResponse := make([]byte, 256)
deadline := time.Now().Add(time.Second * 5)
totalBytes := 0
for {
n, err := authConn.Read(actualResponse[totalBytes:])
if err == nil {
t.Error("Error Expected", err)
} else {
return
}
totalBytes += n
if totalBytes >= len(expectedResponse) || time.Now().After(deadline) {
break
}
}
}
func TestConnectionInvReq(t *testing.T) {
auth, err := NewAuthenticator(context.Background(), &Config{
Request: &RequestConfig{
Method: &Method{Value: "Post"},
Uri: []string{"/testpath"},
Header: []*Header{
{
Name: "Host",
Value: []string{"www.v2fly.org", "www.google.com"},
},
{
Name: "User-Agent",
Value: []string{"Test-Agent"},
},
},
},
Response: &ResponseConfig{
Version: &Version{
Value: "1.1",
},
Status: &Status{
Code: "404",
Reason: "Not Found",
},
},
})
common.Must(err)
listener, err := net.Listen("tcp", "127.0.0.1:0")
common.Must(err)
go func() {
conn, err := listener.Accept()
common.Must(err)
authConn := auth.Server(conn)
b := make([]byte, 256)
for {
n, err := authConn.Read(b)
if err != nil {
authConn.Close()
break
}
_, err = authConn.Write(b[:n])
common.Must(err)
}
}()
conn, err := net.DialTCP("tcp", nil, listener.Addr().(*net.TCPAddr))
common.Must(err)
conn.Write([]byte("ABCDEFGHIJKMLN\r\n\r\n"))
l, _, err := bufio.NewReader(conn).ReadLine()
common.Must(err)
if !strings.HasPrefix(string(l), "HTTP/1.1 400 Bad Request") {
t.Error("Resp to non http conn", string(l))
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/headers/http/http.go | transport/internet/headers/http/http.go | package http
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
import (
"bufio"
"bytes"
"context"
"io"
"net"
"net/http"
"strings"
"time"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
)
const (
// CRLF is the line ending in HTTP header
CRLF = "\r\n"
// ENDING is the double line ending between HTTP header and body.
ENDING = CRLF + CRLF
// max length of HTTP header. Safety precaution for DDoS attack.
maxHeaderLength = 8192
)
var (
ErrHeaderToLong = newError("Header too long.")
ErrHeaderMisMatch = newError("Header Mismatch.")
)
type Reader interface {
Read(io.Reader) (*buf.Buffer, error)
}
type Writer interface {
Write(io.Writer) error
}
type NoOpReader struct{}
func (NoOpReader) Read(io.Reader) (*buf.Buffer, error) {
return nil, nil
}
type NoOpWriter struct{}
func (NoOpWriter) Write(io.Writer) error {
return nil
}
type HeaderReader struct {
req *http.Request
expectedHeader *RequestConfig
}
func (h *HeaderReader) ExpectThisRequest(expectedHeader *RequestConfig) *HeaderReader {
h.expectedHeader = expectedHeader
return h
}
func (h *HeaderReader) Read(reader io.Reader) (*buf.Buffer, error) {
buffer := buf.New()
totalBytes := int32(0)
endingDetected := false
var headerBuf bytes.Buffer
for totalBytes < maxHeaderLength {
_, err := buffer.ReadFrom(reader)
if err != nil {
buffer.Release()
return nil, err
}
if n := bytes.Index(buffer.Bytes(), []byte(ENDING)); n != -1 {
headerBuf.Write(buffer.BytesRange(0, int32(n+len(ENDING))))
buffer.Advance(int32(n + len(ENDING)))
endingDetected = true
break
}
lenEnding := int32(len(ENDING))
if buffer.Len() >= lenEnding {
totalBytes += buffer.Len() - lenEnding
headerBuf.Write(buffer.BytesRange(0, buffer.Len()-lenEnding))
leftover := buffer.BytesFrom(-lenEnding)
buffer.Clear()
copy(buffer.Extend(lenEnding), leftover)
if _, err := readRequest(bufio.NewReader(bytes.NewReader(headerBuf.Bytes()))); err != io.ErrUnexpectedEOF {
return nil, err
}
}
}
if !endingDetected {
buffer.Release()
return nil, ErrHeaderToLong
}
if h.expectedHeader == nil {
if buffer.IsEmpty() {
buffer.Release()
return nil, nil
}
return buffer, nil
}
// Parse the request
if req, err := readRequest(bufio.NewReader(bytes.NewReader(headerBuf.Bytes()))); err != nil {
return nil, err
} else { // nolint: revive
h.req = req
}
// Check req
path := h.req.URL.Path
hasThisURI := false
for _, u := range h.expectedHeader.Uri {
if u == path {
hasThisURI = true
}
}
if !hasThisURI {
return nil, ErrHeaderMisMatch
}
if buffer.IsEmpty() {
buffer.Release()
return nil, nil
}
return buffer, nil
}
type HeaderWriter struct {
header *buf.Buffer
}
func NewHeaderWriter(header *buf.Buffer) *HeaderWriter {
return &HeaderWriter{
header: header,
}
}
func (w *HeaderWriter) Write(writer io.Writer) error {
if w.header == nil {
return nil
}
err := buf.WriteAllBytes(writer, w.header.Bytes())
w.header.Release()
w.header = nil
return err
}
type Conn struct {
net.Conn
readBuffer *buf.Buffer
oneTimeReader Reader
oneTimeWriter Writer
errorWriter Writer
errorMismatchWriter Writer
errorTooLongWriter Writer
errReason error
}
func NewConn(conn net.Conn, reader Reader, writer Writer, errorWriter Writer, errorMismatchWriter Writer, errorTooLongWriter Writer) *Conn {
return &Conn{
Conn: conn,
oneTimeReader: reader,
oneTimeWriter: writer,
errorWriter: errorWriter,
errorMismatchWriter: errorMismatchWriter,
errorTooLongWriter: errorTooLongWriter,
}
}
func (c *Conn) Read(b []byte) (int, error) {
if c.oneTimeReader != nil {
buffer, err := c.oneTimeReader.Read(c.Conn)
if err != nil {
c.errReason = err
return 0, err
}
c.readBuffer = buffer
c.oneTimeReader = nil
}
if !c.readBuffer.IsEmpty() {
nBytes, _ := c.readBuffer.Read(b)
if c.readBuffer.IsEmpty() {
c.readBuffer.Release()
c.readBuffer = nil
}
return nBytes, nil
}
return c.Conn.Read(b)
}
// Write implements io.Writer.
func (c *Conn) Write(b []byte) (int, error) {
if c.oneTimeWriter != nil {
err := c.oneTimeWriter.Write(c.Conn)
c.oneTimeWriter = nil
if err != nil {
return 0, err
}
}
return c.Conn.Write(b)
}
// Close implements net.Conn.Close().
func (c *Conn) Close() error {
if c.oneTimeWriter != nil && c.errorWriter != nil {
// Connection is being closed but header wasn't sent. This means the client request
// is probably not valid. Sending back a server error header in this case.
// Write response based on error reason
switch c.errReason {
case ErrHeaderMisMatch:
c.errorMismatchWriter.Write(c.Conn)
case ErrHeaderToLong:
c.errorTooLongWriter.Write(c.Conn)
default:
c.errorWriter.Write(c.Conn)
}
}
return c.Conn.Close()
}
func formResponseHeader(config *ResponseConfig) *HeaderWriter {
header := buf.New()
common.Must2(header.WriteString(strings.Join([]string{config.GetFullVersion(), config.GetStatusValue().Code, config.GetStatusValue().Reason}, " ")))
common.Must2(header.WriteString(CRLF))
headers := config.PickHeaders()
for _, h := range headers {
common.Must2(header.WriteString(h))
common.Must2(header.WriteString(CRLF))
}
if !config.HasHeader("Date") {
common.Must2(header.WriteString("Date: "))
common.Must2(header.WriteString(time.Now().Format(http.TimeFormat)))
common.Must2(header.WriteString(CRLF))
}
common.Must2(header.WriteString(CRLF))
return &HeaderWriter{
header: header,
}
}
type Authenticator struct {
config *Config
}
func (a Authenticator) GetClientWriter() *HeaderWriter {
header := buf.New()
config := a.config.Request
common.Must2(header.WriteString(strings.Join([]string{config.GetMethodValue(), config.PickURI(), config.GetFullVersion()}, " ")))
common.Must2(header.WriteString(CRLF))
headers := config.PickHeaders()
for _, h := range headers {
common.Must2(header.WriteString(h))
common.Must2(header.WriteString(CRLF))
}
common.Must2(header.WriteString(CRLF))
return &HeaderWriter{
header: header,
}
}
func (a Authenticator) GetServerWriter() *HeaderWriter {
return formResponseHeader(a.config.Response)
}
func (a Authenticator) Client(conn net.Conn) net.Conn {
if a.config.Request == nil && a.config.Response == nil {
return conn
}
var reader Reader = NoOpReader{}
if a.config.Request != nil {
reader = new(HeaderReader)
}
var writer Writer = NoOpWriter{}
if a.config.Response != nil {
writer = a.GetClientWriter()
}
return NewConn(conn, reader, writer, NoOpWriter{}, NoOpWriter{}, NoOpWriter{})
}
func (a Authenticator) Server(conn net.Conn) net.Conn {
if a.config.Request == nil && a.config.Response == nil {
return conn
}
return NewConn(conn, new(HeaderReader).ExpectThisRequest(a.config.Request), a.GetServerWriter(),
formResponseHeader(resp400),
formResponseHeader(resp404),
formResponseHeader(resp400))
}
func NewAuthenticator(ctx context.Context, config *Config) (Authenticator, error) {
return Authenticator{
config: config,
}, nil
}
func init() {
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return NewAuthenticator(ctx, config.(*Config))
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/headers/http/resp.go | transport/internet/headers/http/resp.go | package http
var resp400 = &ResponseConfig{
Version: &Version{
Value: "1.1",
},
Status: &Status{
Code: "400",
Reason: "Bad Request",
},
Header: []*Header{
{
Name: "Connection",
Value: []string{"close"},
},
{
Name: "Cache-Control",
Value: []string{"private"},
},
{
Name: "Content-Length",
Value: []string{"0"},
},
},
}
var resp404 = &ResponseConfig{
Version: &Version{
Value: "1.1",
},
Status: &Status{
Code: "404",
Reason: "Not Found",
},
Header: []*Header{
{
Name: "Connection",
Value: []string{"close"},
},
{
Name: "Cache-Control",
Value: []string{"private"},
},
{
Name: "Content-Length",
Value: []string{"0"},
},
},
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/headers/http/config.pb.go | transport/internet/headers/http/config.pb.go | package http
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Header struct {
state protoimpl.MessageState `protogen:"open.v1"`
// "Accept", "Cookie", etc
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// Each entry must be valid in one piece. Random entry will be chosen if
// multiple entries present.
Value []string `protobuf:"bytes,2,rep,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Header) Reset() {
*x = Header{}
mi := &file_transport_internet_headers_http_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Header) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Header) ProtoMessage() {}
func (x *Header) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_headers_http_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Header.ProtoReflect.Descriptor instead.
func (*Header) Descriptor() ([]byte, []int) {
return file_transport_internet_headers_http_config_proto_rawDescGZIP(), []int{0}
}
func (x *Header) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Header) GetValue() []string {
if x != nil {
return x.Value
}
return nil
}
// HTTP version. Default value "1.1".
type Version struct {
state protoimpl.MessageState `protogen:"open.v1"`
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Version) Reset() {
*x = Version{}
mi := &file_transport_internet_headers_http_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Version) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Version) ProtoMessage() {}
func (x *Version) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_headers_http_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Version.ProtoReflect.Descriptor instead.
func (*Version) Descriptor() ([]byte, []int) {
return file_transport_internet_headers_http_config_proto_rawDescGZIP(), []int{1}
}
func (x *Version) GetValue() string {
if x != nil {
return x.Value
}
return ""
}
// HTTP method. Default value "GET".
type Method struct {
state protoimpl.MessageState `protogen:"open.v1"`
Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Method) Reset() {
*x = Method{}
mi := &file_transport_internet_headers_http_config_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Method) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Method) ProtoMessage() {}
func (x *Method) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_headers_http_config_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Method.ProtoReflect.Descriptor instead.
func (*Method) Descriptor() ([]byte, []int) {
return file_transport_internet_headers_http_config_proto_rawDescGZIP(), []int{2}
}
func (x *Method) GetValue() string {
if x != nil {
return x.Value
}
return ""
}
type RequestConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Full HTTP version like "1.1".
Version *Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
// GET, POST, CONNECT etc
Method *Method `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`
// URI like "/login.php"
Uri []string `protobuf:"bytes,3,rep,name=uri,proto3" json:"uri,omitempty"`
Header []*Header `protobuf:"bytes,4,rep,name=header,proto3" json:"header,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *RequestConfig) Reset() {
*x = RequestConfig{}
mi := &file_transport_internet_headers_http_config_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *RequestConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RequestConfig) ProtoMessage() {}
func (x *RequestConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_headers_http_config_proto_msgTypes[3]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RequestConfig.ProtoReflect.Descriptor instead.
func (*RequestConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_headers_http_config_proto_rawDescGZIP(), []int{3}
}
func (x *RequestConfig) GetVersion() *Version {
if x != nil {
return x.Version
}
return nil
}
func (x *RequestConfig) GetMethod() *Method {
if x != nil {
return x.Method
}
return nil
}
func (x *RequestConfig) GetUri() []string {
if x != nil {
return x.Uri
}
return nil
}
func (x *RequestConfig) GetHeader() []*Header {
if x != nil {
return x.Header
}
return nil
}
type Status struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Status code. Default "200".
Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
// Statue reason. Default "OK".
Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Status) Reset() {
*x = Status{}
mi := &file_transport_internet_headers_http_config_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Status) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Status) ProtoMessage() {}
func (x *Status) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_headers_http_config_proto_msgTypes[4]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Status.ProtoReflect.Descriptor instead.
func (*Status) Descriptor() ([]byte, []int) {
return file_transport_internet_headers_http_config_proto_rawDescGZIP(), []int{4}
}
func (x *Status) GetCode() string {
if x != nil {
return x.Code
}
return ""
}
func (x *Status) GetReason() string {
if x != nil {
return x.Reason
}
return ""
}
type ResponseConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
Version *Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
Status *Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
Header []*Header `protobuf:"bytes,3,rep,name=header,proto3" json:"header,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ResponseConfig) Reset() {
*x = ResponseConfig{}
mi := &file_transport_internet_headers_http_config_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ResponseConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ResponseConfig) ProtoMessage() {}
func (x *ResponseConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_headers_http_config_proto_msgTypes[5]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ResponseConfig.ProtoReflect.Descriptor instead.
func (*ResponseConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_headers_http_config_proto_rawDescGZIP(), []int{5}
}
func (x *ResponseConfig) GetVersion() *Version {
if x != nil {
return x.Version
}
return nil
}
func (x *ResponseConfig) GetStatus() *Status {
if x != nil {
return x.Status
}
return nil
}
func (x *ResponseConfig) GetHeader() []*Header {
if x != nil {
return x.Header
}
return nil
}
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Settings for authenticating requests. If not set, client side will not send
// authenication header, and server side will bypass authentication.
Request *RequestConfig `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
// Settings for authenticating responses. If not set, client side will bypass
// authentication, and server side will not send authentication header.
Response *ResponseConfig `protobuf:"bytes,2,opt,name=response,proto3" json:"response,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_headers_http_config_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_headers_http_config_proto_msgTypes[6]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_headers_http_config_proto_rawDescGZIP(), []int{6}
}
func (x *Config) GetRequest() *RequestConfig {
if x != nil {
return x.Request
}
return nil
}
func (x *Config) GetResponse() *ResponseConfig {
if x != nil {
return x.Response
}
return nil
}
var File_transport_internet_headers_http_config_proto protoreflect.FileDescriptor
const file_transport_internet_headers_http_config_proto_rawDesc = "" +
"\n" +
",transport/internet/headers/http/config.proto\x12*v2ray.core.transport.internet.headers.http\"2\n" +
"\x06Header\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
"\x05value\x18\x02 \x03(\tR\x05value\"\x1f\n" +
"\aVersion\x12\x14\n" +
"\x05value\x18\x01 \x01(\tR\x05value\"\x1e\n" +
"\x06Method\x12\x14\n" +
"\x05value\x18\x01 \x01(\tR\x05value\"\x88\x02\n" +
"\rRequestConfig\x12M\n" +
"\aversion\x18\x01 \x01(\v23.v2ray.core.transport.internet.headers.http.VersionR\aversion\x12J\n" +
"\x06method\x18\x02 \x01(\v22.v2ray.core.transport.internet.headers.http.MethodR\x06method\x12\x10\n" +
"\x03uri\x18\x03 \x03(\tR\x03uri\x12J\n" +
"\x06header\x18\x04 \x03(\v22.v2ray.core.transport.internet.headers.http.HeaderR\x06header\"4\n" +
"\x06Status\x12\x12\n" +
"\x04code\x18\x01 \x01(\tR\x04code\x12\x16\n" +
"\x06reason\x18\x02 \x01(\tR\x06reason\"\xf7\x01\n" +
"\x0eResponseConfig\x12M\n" +
"\aversion\x18\x01 \x01(\v23.v2ray.core.transport.internet.headers.http.VersionR\aversion\x12J\n" +
"\x06status\x18\x02 \x01(\v22.v2ray.core.transport.internet.headers.http.StatusR\x06status\x12J\n" +
"\x06header\x18\x03 \x03(\v22.v2ray.core.transport.internet.headers.http.HeaderR\x06header\"\xb5\x01\n" +
"\x06Config\x12S\n" +
"\arequest\x18\x01 \x01(\v29.v2ray.core.transport.internet.headers.http.RequestConfigR\arequest\x12V\n" +
"\bresponse\x18\x02 \x01(\v2:.v2ray.core.transport.internet.headers.http.ResponseConfigR\bresponseB\x9f\x01\n" +
".com.v2ray.core.transport.internet.headers.httpP\x01Z>github.com/v2fly/v2ray-core/v5/transport/internet/headers/http\xaa\x02*V2Ray.Core.Transport.Internet.Headers.Httpb\x06proto3"
var (
file_transport_internet_headers_http_config_proto_rawDescOnce sync.Once
file_transport_internet_headers_http_config_proto_rawDescData []byte
)
func file_transport_internet_headers_http_config_proto_rawDescGZIP() []byte {
file_transport_internet_headers_http_config_proto_rawDescOnce.Do(func() {
file_transport_internet_headers_http_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_headers_http_config_proto_rawDesc), len(file_transport_internet_headers_http_config_proto_rawDesc)))
})
return file_transport_internet_headers_http_config_proto_rawDescData
}
var file_transport_internet_headers_http_config_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
var file_transport_internet_headers_http_config_proto_goTypes = []any{
(*Header)(nil), // 0: v2ray.core.transport.internet.headers.http.Header
(*Version)(nil), // 1: v2ray.core.transport.internet.headers.http.Version
(*Method)(nil), // 2: v2ray.core.transport.internet.headers.http.Method
(*RequestConfig)(nil), // 3: v2ray.core.transport.internet.headers.http.RequestConfig
(*Status)(nil), // 4: v2ray.core.transport.internet.headers.http.Status
(*ResponseConfig)(nil), // 5: v2ray.core.transport.internet.headers.http.ResponseConfig
(*Config)(nil), // 6: v2ray.core.transport.internet.headers.http.Config
}
var file_transport_internet_headers_http_config_proto_depIdxs = []int32{
1, // 0: v2ray.core.transport.internet.headers.http.RequestConfig.version:type_name -> v2ray.core.transport.internet.headers.http.Version
2, // 1: v2ray.core.transport.internet.headers.http.RequestConfig.method:type_name -> v2ray.core.transport.internet.headers.http.Method
0, // 2: v2ray.core.transport.internet.headers.http.RequestConfig.header:type_name -> v2ray.core.transport.internet.headers.http.Header
1, // 3: v2ray.core.transport.internet.headers.http.ResponseConfig.version:type_name -> v2ray.core.transport.internet.headers.http.Version
4, // 4: v2ray.core.transport.internet.headers.http.ResponseConfig.status:type_name -> v2ray.core.transport.internet.headers.http.Status
0, // 5: v2ray.core.transport.internet.headers.http.ResponseConfig.header:type_name -> v2ray.core.transport.internet.headers.http.Header
3, // 6: v2ray.core.transport.internet.headers.http.Config.request:type_name -> v2ray.core.transport.internet.headers.http.RequestConfig
5, // 7: v2ray.core.transport.internet.headers.http.Config.response:type_name -> v2ray.core.transport.internet.headers.http.ResponseConfig
8, // [8:8] is the sub-list for method output_type
8, // [8:8] is the sub-list for method input_type
8, // [8:8] is the sub-list for extension type_name
8, // [8:8] is the sub-list for extension extendee
0, // [0:8] is the sub-list for field type_name
}
func init() { file_transport_internet_headers_http_config_proto_init() }
func file_transport_internet_headers_http_config_proto_init() {
if File_transport_internet_headers_http_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_headers_http_config_proto_rawDesc), len(file_transport_internet_headers_http_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 7,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_headers_http_config_proto_goTypes,
DependencyIndexes: file_transport_internet_headers_http_config_proto_depIdxs,
MessageInfos: file_transport_internet_headers_http_config_proto_msgTypes,
}.Build()
File_transport_internet_headers_http_config_proto = out.File
file_transport_internet_headers_http_config_proto_goTypes = nil
file_transport_internet_headers_http_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/hub.go | transport/internet/grpc/hub.go | //go:build !confonly
// +build !confonly
package grpc
import (
"context"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/grpc/encoding"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
type Listener struct {
encoding.UnimplementedGunServiceServer
ctx context.Context
handler internet.ConnHandler
local net.Addr
config *Config
s *grpc.Server
}
func (l Listener) Tun(server encoding.GunService_TunServer) error {
tunCtx, cancel := context.WithCancel(l.ctx)
l.handler(encoding.NewGunConn(server, cancel))
<-tunCtx.Done()
return nil
}
func (l Listener) Close() error {
l.s.Stop()
return nil
}
func (l Listener) Addr() net.Addr {
return l.local
}
func Listen(ctx context.Context, address net.Address, port net.Port, settings *internet.MemoryStreamConfig, handler internet.ConnHandler) (internet.Listener, error) {
grpcSettings := settings.ProtocolSettings.(*Config)
var listener *Listener
if port == net.Port(0) { // unix
listener = &Listener{
handler: handler,
local: &net.UnixAddr{
Name: address.Domain(),
Net: "unix",
},
config: grpcSettings,
}
} else { // tcp
listener = &Listener{
handler: handler,
local: &net.TCPAddr{
IP: address.IP(),
Port: int(port),
},
config: grpcSettings,
}
}
listener.ctx = ctx
config := tls.ConfigFromStreamSettings(settings)
var s *grpc.Server
if config == nil {
s = grpc.NewServer()
} else {
// gRPC server may silently ignore TLS errors
s = grpc.NewServer(grpc.Creds(credentials.NewTLS(config.GetTLSConfig(tls.WithNextProto("h2")))))
}
listener.s = s
if settings.SocketSettings != nil && settings.SocketSettings.AcceptProxyProtocol {
newError("accepting PROXY protocol").AtWarning().WriteToLog(session.ExportIDToError(ctx))
}
go func() {
var streamListener net.Listener
var err error
if port == net.Port(0) { // unix
streamListener, err = internet.ListenSystem(ctx, &net.UnixAddr{
Name: address.Domain(),
Net: "unix",
}, settings.SocketSettings)
if err != nil {
newError("failed to listen on ", address).Base(err).AtError().WriteToLog(session.ExportIDToError(ctx))
return
}
} else { // tcp
streamListener, err = internet.ListenSystem(ctx, &net.TCPAddr{
IP: address.IP(),
Port: int(port),
}, settings.SocketSettings)
if err != nil {
newError("failed to listen on ", address, ":", port).Base(err).AtError().WriteToLog(session.ExportIDToError(ctx))
return
}
}
encoding.RegisterGunServiceServerX(s, listener, grpcSettings.ServiceName)
if err = s.Serve(streamListener); err != nil {
newError("Listener for grpc ended").Base(err).WriteToLog()
}
}()
return listener, nil
}
func init() {
common.Must(internet.RegisterTransportListener(protocolName, Listen))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/errors.generated.go | transport/internet/grpc/errors.generated.go | package grpc
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/config.go | transport/internet/grpc/config.go | package grpc
import (
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
const protocolName = "gun"
func init() {
common.Must(internet.RegisterProtocolConfigCreator(protocolName, func() interface{} {
return new(Config)
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/grpc.go | transport/internet/grpc/grpc.go | //go:build !confonly
// +build !confonly
package grpc
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/config.pb.go | transport/internet/grpc/config.pb.go | package grpc
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
ServiceName string `protobuf:"bytes,2,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_grpc_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_grpc_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_grpc_config_proto_rawDescGZIP(), []int{0}
}
func (x *Config) GetHost() string {
if x != nil {
return x.Host
}
return ""
}
func (x *Config) GetServiceName() string {
if x != nil {
return x.ServiceName
}
return ""
}
var File_transport_internet_grpc_config_proto protoreflect.FileDescriptor
const file_transport_internet_grpc_config_proto_rawDesc = "" +
"\n" +
"$transport/internet/grpc/config.proto\x12+v2ray.core.transport.internet.grpc.encoding\x1a common/protoext/extensions.proto\"a\n" +
"\x06Config\x12\x12\n" +
"\x04host\x18\x01 \x01(\tR\x04host\x12!\n" +
"\fservice_name\x18\x02 \x01(\tR\vserviceName: \x82\xb5\x18\x1c\n" +
"\ttransport\x12\x04grpc\x8a\xff)\x03gun\x90\xff)\x01B\x85\x01\n" +
"&com.v2ray.core.transport.internet.grpcZ6github.com/v2fly/v2ray-core/v5/transport/internet/grpc\xaa\x02\"V2Ray.Core.Transport.Internet.Grpcb\x06proto3"
var (
file_transport_internet_grpc_config_proto_rawDescOnce sync.Once
file_transport_internet_grpc_config_proto_rawDescData []byte
)
func file_transport_internet_grpc_config_proto_rawDescGZIP() []byte {
file_transport_internet_grpc_config_proto_rawDescOnce.Do(func() {
file_transport_internet_grpc_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_grpc_config_proto_rawDesc), len(file_transport_internet_grpc_config_proto_rawDesc)))
})
return file_transport_internet_grpc_config_proto_rawDescData
}
var file_transport_internet_grpc_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_transport_internet_grpc_config_proto_goTypes = []any{
(*Config)(nil), // 0: v2ray.core.transport.internet.grpc.encoding.Config
}
var file_transport_internet_grpc_config_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_transport_internet_grpc_config_proto_init() }
func file_transport_internet_grpc_config_proto_init() {
if File_transport_internet_grpc_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_grpc_config_proto_rawDesc), len(file_transport_internet_grpc_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_grpc_config_proto_goTypes,
DependencyIndexes: file_transport_internet_grpc_config_proto_depIdxs,
MessageInfos: file_transport_internet_grpc_config_proto_msgTypes,
}.Build()
File_transport_internet_grpc_config_proto = out.File
file_transport_internet_grpc_config_proto_goTypes = nil
file_transport_internet_grpc_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/dial.go | transport/internet/grpc/dial.go | //go:build !confonly
// +build !confonly
package grpc
import (
"context"
gonet "net"
"sync"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/backoff"
"google.golang.org/grpc/connectivity"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/credentials/insecure"
core "github.com/v2fly/v2ray-core/v5"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/grpc/encoding"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
func Dial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) {
newError("creating connection to ", dest).WriteToLog(session.ExportIDToError(ctx))
conn, err := dialgRPC(ctx, dest, streamSettings)
if err != nil {
return nil, newError("failed to dial Grpc").Base(err)
}
return internet.Connection(conn), nil
}
func init() {
common.Must(internet.RegisterTransportDialer(protocolName, Dial))
}
type transportConnectionState struct {
scopedDialerMap map[net.Destination]*grpc.ClientConn
scopedDialerAccess sync.Mutex
}
func (t *transportConnectionState) IsTransientStorageLifecycleReceiver() {
}
func (t *transportConnectionState) Close() error {
t.scopedDialerAccess.Lock()
defer t.scopedDialerAccess.Unlock()
for _, conn := range t.scopedDialerMap {
_ = conn.Close()
}
t.scopedDialerMap = nil
return nil
}
type dialerCanceller func()
func dialgRPC(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (net.Conn, error) {
grpcSettings := streamSettings.ProtocolSettings.(*Config)
config := tls.ConfigFromStreamSettings(streamSettings)
transportCredentials := insecure.NewCredentials()
if config != nil {
transportCredentials = credentials.NewTLS(config.GetTLSConfig(tls.WithDestination(dest)))
}
dialOption := grpc.WithTransportCredentials(transportCredentials)
conn, canceller, err := getGrpcClient(ctx, dest, dialOption, streamSettings)
if err != nil {
return nil, newError("Cannot dial grpc").Base(err)
}
client := encoding.NewGunServiceClient(conn)
gunService, err := client.(encoding.GunServiceClientX).TunCustomName(ctx, grpcSettings.ServiceName)
if err != nil {
canceller()
return nil, newError("Cannot dial grpc").Base(err)
}
return encoding.NewGunConn(gunService, nil), nil
}
func getGrpcClient(ctx context.Context, dest net.Destination, dialOption grpc.DialOption, streamSettings *internet.MemoryStreamConfig) (*grpc.ClientConn, dialerCanceller, error) {
transportEnvironment := envctx.EnvironmentFromContext(ctx).(environment.TransportEnvironment)
state, err := transportEnvironment.TransientStorage().Get(ctx, "grpc-transport-connection-state")
if err != nil {
state = &transportConnectionState{}
transportEnvironment.TransientStorage().Put(ctx, "grpc-transport-connection-state", state)
state, err = transportEnvironment.TransientStorage().Get(ctx, "grpc-transport-connection-state")
if err != nil {
return nil, nil, newError("failed to get grpc transport connection state").Base(err)
}
}
stateTyped := state.(*transportConnectionState)
stateTyped.scopedDialerAccess.Lock()
defer stateTyped.scopedDialerAccess.Unlock()
if stateTyped.scopedDialerMap == nil {
stateTyped.scopedDialerMap = make(map[net.Destination]*grpc.ClientConn)
}
canceller := func() {
stateTyped.scopedDialerAccess.Lock()
defer stateTyped.scopedDialerAccess.Unlock()
delete(stateTyped.scopedDialerMap, dest)
}
if client, found := stateTyped.scopedDialerMap[dest]; found && client.GetState() != connectivity.Shutdown {
return client, canceller, nil
}
conn, err := grpc.NewClient(
dest.Address.String()+":"+dest.Port.String(),
dialOption,
grpc.WithConnectParams(grpc.ConnectParams{
Backoff: backoff.Config{
BaseDelay: 500 * time.Millisecond,
Multiplier: 1.5,
Jitter: 0.2,
MaxDelay: 19 * time.Second,
},
MinConnectTimeout: 5 * time.Second,
}),
grpc.WithContextDialer(func(ctxGrpc context.Context, s string) (gonet.Conn, error) {
rawHost, rawPort, err := net.SplitHostPort(s)
if err != nil {
return nil, err
}
if len(rawPort) == 0 {
rawPort = "443"
}
port, err := net.PortFromString(rawPort)
if err != nil {
return nil, err
}
address := net.ParseAddress(rawHost)
detachedContext := core.ToBackgroundDetachedContext(ctx)
return internet.DialSystem(detachedContext, net.TCPDestination(address, port), streamSettings.SocketSettings)
}),
)
canceller = func() {
stateTyped.scopedDialerAccess.Lock()
defer stateTyped.scopedDialerAccess.Unlock()
delete(stateTyped.scopedDialerMap, dest)
if err != nil {
conn.Close()
}
}
stateTyped.scopedDialerMap[dest] = conn
return conn, canceller, err
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/encoding/errors.generated.go | transport/internet/grpc/encoding/errors.generated.go | package encoding
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/encoding/stream.pb.go | transport/internet/grpc/encoding/stream.pb.go | package encoding
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Hunk struct {
state protoimpl.MessageState `protogen:"open.v1"`
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Hunk) Reset() {
*x = Hunk{}
mi := &file_transport_internet_grpc_encoding_stream_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Hunk) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Hunk) ProtoMessage() {}
func (x *Hunk) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_grpc_encoding_stream_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Hunk.ProtoReflect.Descriptor instead.
func (*Hunk) Descriptor() ([]byte, []int) {
return file_transport_internet_grpc_encoding_stream_proto_rawDescGZIP(), []int{0}
}
func (x *Hunk) GetData() []byte {
if x != nil {
return x.Data
}
return nil
}
var File_transport_internet_grpc_encoding_stream_proto protoreflect.FileDescriptor
const file_transport_internet_grpc_encoding_stream_proto_rawDesc = "" +
"\n" +
"-transport/internet/grpc/encoding/stream.proto\x12+v2ray.core.transport.internet.grpc.encoding\"\x1a\n" +
"\x04Hunk\x12\x12\n" +
"\x04data\x18\x01 \x01(\fR\x04data2}\n" +
"\n" +
"GunService\x12o\n" +
"\x03Tun\x121.v2ray.core.transport.internet.grpc.encoding.Hunk\x1a1.v2ray.core.transport.internet.grpc.encoding.Hunk(\x010\x01B\xa0\x01\n" +
"/com.v2ray.core.transport.internet.grpc.encodingZ?github.com/v2fly/v2ray-core/v5/transport/internet/grpc/encoding\xaa\x02+V2Ray.Core.Transport.Internet.Grpc.Encodingb\x06proto3"
var (
file_transport_internet_grpc_encoding_stream_proto_rawDescOnce sync.Once
file_transport_internet_grpc_encoding_stream_proto_rawDescData []byte
)
func file_transport_internet_grpc_encoding_stream_proto_rawDescGZIP() []byte {
file_transport_internet_grpc_encoding_stream_proto_rawDescOnce.Do(func() {
file_transport_internet_grpc_encoding_stream_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_grpc_encoding_stream_proto_rawDesc), len(file_transport_internet_grpc_encoding_stream_proto_rawDesc)))
})
return file_transport_internet_grpc_encoding_stream_proto_rawDescData
}
var file_transport_internet_grpc_encoding_stream_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_transport_internet_grpc_encoding_stream_proto_goTypes = []any{
(*Hunk)(nil), // 0: v2ray.core.transport.internet.grpc.encoding.Hunk
}
var file_transport_internet_grpc_encoding_stream_proto_depIdxs = []int32{
0, // 0: v2ray.core.transport.internet.grpc.encoding.GunService.Tun:input_type -> v2ray.core.transport.internet.grpc.encoding.Hunk
0, // 1: v2ray.core.transport.internet.grpc.encoding.GunService.Tun:output_type -> v2ray.core.transport.internet.grpc.encoding.Hunk
1, // [1:2] is the sub-list for method output_type
0, // [0:1] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_transport_internet_grpc_encoding_stream_proto_init() }
func file_transport_internet_grpc_encoding_stream_proto_init() {
if File_transport_internet_grpc_encoding_stream_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_grpc_encoding_stream_proto_rawDesc), len(file_transport_internet_grpc_encoding_stream_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_transport_internet_grpc_encoding_stream_proto_goTypes,
DependencyIndexes: file_transport_internet_grpc_encoding_stream_proto_depIdxs,
MessageInfos: file_transport_internet_grpc_encoding_stream_proto_msgTypes,
}.Build()
File_transport_internet_grpc_encoding_stream_proto = out.File
file_transport_internet_grpc_encoding_stream_proto_goTypes = nil
file_transport_internet_grpc_encoding_stream_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/encoding/conn.go | transport/internet/grpc/encoding/conn.go | //go:build !confonly
// +build !confonly
package encoding
import (
"bytes"
"context"
"io"
"net"
"time"
"google.golang.org/grpc/peer"
)
// GunService is the abstract interface of GunService_TunClient and GunService_TunServer
type GunService interface {
Context() context.Context
Send(*Hunk) error
Recv() (*Hunk, error)
}
// GunConn implements net.Conn for gun tunnel
type GunConn struct {
service GunService
reader io.Reader
over context.CancelFunc
local net.Addr
remote net.Addr
}
// Read implements net.Conn.Read()
func (c *GunConn) Read(b []byte) (n int, err error) {
if c.reader == nil {
h, err := c.service.Recv()
if err != nil {
return 0, newError("unable to read from gun tunnel").Base(err)
}
c.reader = bytes.NewReader(h.Data)
}
n, err = c.reader.Read(b)
if err == io.EOF {
c.reader = nil
return n, nil
}
return n, err
}
// Write implements net.Conn.Write()
func (c *GunConn) Write(b []byte) (n int, err error) {
err = c.service.Send(&Hunk{Data: b})
if err != nil {
return 0, newError("Unable to send data over gun").Base(err)
}
return len(b), nil
}
// Close implements net.Conn.Close()
func (c *GunConn) Close() error {
if c.over != nil {
c.over()
}
return nil
}
// LocalAddr implements net.Conn.LocalAddr()
func (c *GunConn) LocalAddr() net.Addr {
return c.local
}
// RemoteAddr implements net.Conn.RemoteAddr()
func (c *GunConn) RemoteAddr() net.Addr {
return c.remote
}
// SetDeadline implements net.Conn.SetDeadline()
func (*GunConn) SetDeadline(time.Time) error {
return nil
}
// SetReadDeadline implements net.Conn.SetReadDeadline()
func (*GunConn) SetReadDeadline(time.Time) error {
return nil
}
// SetWriteDeadline implements net.Conn.SetWriteDeadline()
func (*GunConn) SetWriteDeadline(time.Time) error {
return nil
}
// NewGunConn creates GunConn which handles gun tunnel
func NewGunConn(service GunService, over context.CancelFunc) *GunConn {
conn := &GunConn{
service: service,
reader: nil,
over: over,
}
conn.local = &net.TCPAddr{
IP: []byte{0, 0, 0, 0},
Port: 0,
}
pr, ok := peer.FromContext(service.Context())
if ok {
conn.remote = pr.Addr
} else {
conn.remote = &net.TCPAddr{
IP: []byte{0, 0, 0, 0},
Port: 0,
}
}
return conn
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/encoding/encoding.go | transport/internet/grpc/encoding/encoding.go | package encoding
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/encoding/stream_grpc.pb.go | transport/internet/grpc/encoding/stream_grpc.pb.go | package encoding
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9
const (
GunService_Tun_FullMethodName = "/v2ray.core.transport.internet.grpc.encoding.GunService/Tun"
)
// GunServiceClient is the client API for GunService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type GunServiceClient interface {
Tun(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[Hunk, Hunk], error)
}
type gunServiceClient struct {
cc grpc.ClientConnInterface
}
func NewGunServiceClient(cc grpc.ClientConnInterface) GunServiceClient {
return &gunServiceClient{cc}
}
func (c *gunServiceClient) Tun(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[Hunk, Hunk], error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
stream, err := c.cc.NewStream(ctx, &GunService_ServiceDesc.Streams[0], GunService_Tun_FullMethodName, cOpts...)
if err != nil {
return nil, err
}
x := &grpc.GenericClientStream[Hunk, Hunk]{ClientStream: stream}
return x, nil
}
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GunService_TunClient = grpc.BidiStreamingClient[Hunk, Hunk]
// GunServiceServer is the server API for GunService service.
// All implementations must embed UnimplementedGunServiceServer
// for forward compatibility.
type GunServiceServer interface {
Tun(grpc.BidiStreamingServer[Hunk, Hunk]) error
mustEmbedUnimplementedGunServiceServer()
}
// UnimplementedGunServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedGunServiceServer struct{}
func (UnimplementedGunServiceServer) Tun(grpc.BidiStreamingServer[Hunk, Hunk]) error {
return status.Errorf(codes.Unimplemented, "method Tun not implemented")
}
func (UnimplementedGunServiceServer) mustEmbedUnimplementedGunServiceServer() {}
func (UnimplementedGunServiceServer) testEmbeddedByValue() {}
// UnsafeGunServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GunServiceServer will
// result in compilation errors.
type UnsafeGunServiceServer interface {
mustEmbedUnimplementedGunServiceServer()
}
func RegisterGunServiceServer(s grpc.ServiceRegistrar, srv GunServiceServer) {
// If the following call pancis, it indicates UnimplementedGunServiceServer was
// embedded by pointer and is nil. This will cause panics if an
// unimplemented method is ever invoked, so we test this at initialization
// time to prevent it from happening at runtime later due to I/O.
if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
t.testEmbeddedByValue()
}
s.RegisterService(&GunService_ServiceDesc, srv)
}
func _GunService_Tun_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(GunServiceServer).Tun(&grpc.GenericServerStream[Hunk, Hunk]{ServerStream: stream})
}
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
type GunService_TunServer = grpc.BidiStreamingServer[Hunk, Hunk]
// GunService_ServiceDesc is the grpc.ServiceDesc for GunService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GunService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "v2ray.core.transport.internet.grpc.encoding.GunService",
HandlerType: (*GunServiceServer)(nil),
Methods: []grpc.MethodDesc{},
Streams: []grpc.StreamDesc{
{
StreamName: "Tun",
Handler: _GunService_Tun_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "transport/internet/grpc/encoding/stream.proto",
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/grpc/encoding/customSeviceName.go | transport/internet/grpc/encoding/customSeviceName.go | //go:build !confonly
// +build !confonly
package encoding
import (
"context"
"google.golang.org/grpc"
)
func ServerDesc(name string) grpc.ServiceDesc {
return grpc.ServiceDesc{
ServiceName: name,
HandlerType: (*GunServiceServer)(nil),
Methods: []grpc.MethodDesc{},
Streams: []grpc.StreamDesc{
{
StreamName: "Tun",
Handler: _GunService_Tun_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
Metadata: "gun.proto",
}
}
func (c *gunServiceClient) TunCustomName(ctx context.Context, name string, opts ...grpc.CallOption) (GunService_TunClient, error) {
stream, err := c.cc.NewStream(ctx, &ServerDesc(name).Streams[0], "/"+name+"/Tun", opts...)
if err != nil {
return nil, err
}
x := &grpc.GenericClientStream[Hunk, Hunk]{ClientStream: stream}
return x, nil
}
type GunServiceClientX interface {
TunCustomName(ctx context.Context, name string, opts ...grpc.CallOption) (GunService_TunClient, error)
Tun(ctx context.Context, opts ...grpc.CallOption) (GunService_TunClient, error)
}
func RegisterGunServiceServerX(s *grpc.Server, srv GunServiceServer, name string) {
desc := ServerDesc(name)
s.RegisterService(&desc, srv)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/domainsocket/listener.go | transport/internet/domainsocket/listener.go | //go:build !windows && !wasm
// +build !windows,!wasm
package domainsocket
import (
"context"
gotls "crypto/tls"
"os"
"strings"
"golang.org/x/sys/unix"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
type Listener struct {
addr *net.UnixAddr
ln net.Listener
tlsConfig *gotls.Config
config *Config
addConn internet.ConnHandler
locker *fileLocker
}
func Listen(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, handler internet.ConnHandler) (internet.Listener, error) {
settings := streamSettings.ProtocolSettings.(*Config)
addr, err := settings.GetUnixAddr()
if err != nil {
return nil, err
}
unixListener, err := net.ListenUnix("unix", addr)
if err != nil {
return nil, newError("failed to listen domain socket").Base(err).AtWarning()
}
ln := &Listener{
addr: addr,
ln: unixListener,
config: settings,
addConn: handler,
}
if !settings.Abstract {
ln.locker = &fileLocker{
path: settings.Path + ".lock",
}
if err := ln.locker.Acquire(); err != nil {
unixListener.Close()
return nil, err
}
}
if config := tls.ConfigFromStreamSettings(streamSettings); config != nil {
ln.tlsConfig = config.GetTLSConfig()
}
go ln.run()
return ln, nil
}
func (ln *Listener) Addr() net.Addr {
return ln.addr
}
func (ln *Listener) Close() error {
if ln.locker != nil {
ln.locker.Release()
}
return ln.ln.Close()
}
func (ln *Listener) run() {
for {
conn, err := ln.ln.Accept()
if err != nil {
if strings.Contains(err.Error(), "closed") {
break
}
newError("failed to accepted raw connections").Base(err).AtWarning().WriteToLog()
continue
}
if ln.tlsConfig != nil {
conn = tls.Server(conn, ln.tlsConfig)
}
ln.addConn(internet.Connection(conn))
}
}
type fileLocker struct {
path string
file *os.File
}
func (fl *fileLocker) Acquire() error {
f, err := os.Create(fl.path)
if err != nil {
return err
}
if err := unix.Flock(int(f.Fd()), unix.LOCK_EX); err != nil {
f.Close()
return newError("failed to lock file: ", fl.path).Base(err)
}
fl.file = f
return nil
}
func (fl *fileLocker) Release() {
if err := unix.Flock(int(fl.file.Fd()), unix.LOCK_UN); err != nil {
newError("failed to unlock file: ", fl.path).Base(err).WriteToLog()
}
if err := fl.file.Close(); err != nil {
newError("failed to close file: ", fl.path).Base(err).WriteToLog()
}
if err := os.Remove(fl.path); err != nil {
newError("failed to remove file: ", fl.path).Base(err).WriteToLog()
}
}
func init() {
common.Must(internet.RegisterTransportListener(protocolName, Listen))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/domainsocket/errors.generated.go | transport/internet/domainsocket/errors.generated.go | package domainsocket
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/domainsocket/config.go | transport/internet/domainsocket/config.go | package domainsocket
import (
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
const (
protocolName = "domainsocket"
sizeofSunPath = 108
)
func (c *Config) GetUnixAddr() (*net.UnixAddr, error) {
path := c.Path
if path == "" {
return nil, newError("empty domain socket path")
}
if c.Abstract && path[0] != '\x00' {
path = "\x00" + path
}
if c.Abstract && c.Padding {
raw := []byte(path)
addr := make([]byte, sizeofSunPath)
copy(addr, raw)
path = string(addr)
}
return &net.UnixAddr{
Name: path,
Net: "unix",
}, nil
}
func init() {
common.Must(internet.RegisterProtocolConfigCreator(protocolName, func() interface{} {
return new(Config)
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/domainsocket/errgen.go | transport/internet/domainsocket/errgen.go | package domainsocket
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/domainsocket/config.pb.go | transport/internet/domainsocket/config.pb.go | package domainsocket
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Path of the domain socket. This overrides the IP/Port parameter from
// upstream caller.
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
// Abstract specifies whether to use abstract namespace or not.
// Traditionally Unix domain socket is file system based. Abstract domain
// socket can be used without acquiring file lock.
Abstract bool `protobuf:"varint,2,opt,name=abstract,proto3" json:"abstract,omitempty"`
// Some apps, eg. haproxy, use the full length of sockaddr_un.sun_path to
// connect(2) or bind(2) when using abstract UDS.
Padding bool `protobuf:"varint,3,opt,name=padding,proto3" json:"padding,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_domainsocket_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_domainsocket_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_domainsocket_config_proto_rawDescGZIP(), []int{0}
}
func (x *Config) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
func (x *Config) GetAbstract() bool {
if x != nil {
return x.Abstract
}
return false
}
func (x *Config) GetPadding() bool {
if x != nil {
return x.Padding
}
return false
}
var File_transport_internet_domainsocket_config_proto protoreflect.FileDescriptor
const file_transport_internet_domainsocket_config_proto_rawDesc = "" +
"\n" +
",transport/internet/domainsocket/config.proto\x12*v2ray.core.transport.internet.domainsocket\x1a common/protoext/extensions.proto\"q\n" +
"\x06Config\x12\x12\n" +
"\x04path\x18\x01 \x01(\tR\x04path\x12\x1a\n" +
"\babstract\x18\x02 \x01(\bR\babstract\x12\x18\n" +
"\apadding\x18\x03 \x01(\bR\apadding:\x1d\x82\xb5\x18\x19\n" +
"\ttransport\x12\fdomainsocketB\x9f\x01\n" +
".com.v2ray.core.transport.internet.domainsocketP\x01Z>github.com/v2fly/v2ray-core/v5/transport/internet/domainsocket\xaa\x02*V2Ray.Core.Transport.Internet.DomainSocketb\x06proto3"
var (
file_transport_internet_domainsocket_config_proto_rawDescOnce sync.Once
file_transport_internet_domainsocket_config_proto_rawDescData []byte
)
func file_transport_internet_domainsocket_config_proto_rawDescGZIP() []byte {
file_transport_internet_domainsocket_config_proto_rawDescOnce.Do(func() {
file_transport_internet_domainsocket_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_domainsocket_config_proto_rawDesc), len(file_transport_internet_domainsocket_config_proto_rawDesc)))
})
return file_transport_internet_domainsocket_config_proto_rawDescData
}
var file_transport_internet_domainsocket_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_transport_internet_domainsocket_config_proto_goTypes = []any{
(*Config)(nil), // 0: v2ray.core.transport.internet.domainsocket.Config
}
var file_transport_internet_domainsocket_config_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_transport_internet_domainsocket_config_proto_init() }
func file_transport_internet_domainsocket_config_proto_init() {
if File_transport_internet_domainsocket_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_domainsocket_config_proto_rawDesc), len(file_transport_internet_domainsocket_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_domainsocket_config_proto_goTypes,
DependencyIndexes: file_transport_internet_domainsocket_config_proto_depIdxs,
MessageInfos: file_transport_internet_domainsocket_config_proto_msgTypes,
}.Build()
File_transport_internet_domainsocket_config_proto = out.File
file_transport_internet_domainsocket_config_proto_goTypes = nil
file_transport_internet_domainsocket_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/domainsocket/listener_test.go | transport/internet/domainsocket/listener_test.go | //go:build !windows && !android
// +build !windows,!android
package domainsocket_test
import (
"context"
"runtime"
"testing"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
. "github.com/v2fly/v2ray-core/v5/transport/internet/domainsocket"
)
func TestListen(t *testing.T) {
ctx := context.Background()
streamSettings := &internet.MemoryStreamConfig{
ProtocolName: "domainsocket",
ProtocolSettings: &Config{
Path: "/tmp/ts3",
},
}
listener, err := Listen(ctx, nil, net.Port(0), streamSettings, func(conn internet.Connection) {
defer conn.Close()
b := buf.New()
defer b.Release()
common.Must2(b.ReadFrom(conn))
b.WriteString("Response")
common.Must2(conn.Write(b.Bytes()))
})
common.Must(err)
defer listener.Close()
conn, err := Dial(ctx, net.Destination{}, streamSettings)
common.Must(err)
defer conn.Close()
common.Must2(conn.Write([]byte("Request")))
b := buf.New()
defer b.Release()
common.Must2(b.ReadFrom(conn))
if b.String() != "RequestResponse" {
t.Error("expected response as 'RequestResponse' but got ", b.String())
}
}
func TestListenAbstract(t *testing.T) {
if runtime.GOOS != "linux" {
return
}
ctx := context.Background()
streamSettings := &internet.MemoryStreamConfig{
ProtocolName: "domainsocket",
ProtocolSettings: &Config{
Path: "/tmp/ts3",
Abstract: true,
},
}
listener, err := Listen(ctx, nil, net.Port(0), streamSettings, func(conn internet.Connection) {
defer conn.Close()
b := buf.New()
defer b.Release()
common.Must2(b.ReadFrom(conn))
b.WriteString("Response")
common.Must2(conn.Write(b.Bytes()))
})
common.Must(err)
defer listener.Close()
conn, err := Dial(ctx, net.Destination{}, streamSettings)
common.Must(err)
defer conn.Close()
common.Must2(conn.Write([]byte("Request")))
b := buf.New()
defer b.Release()
common.Must2(b.ReadFrom(conn))
if b.String() != "RequestResponse" {
t.Error("expected response as 'RequestResponse' but got ", b.String())
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/domainsocket/dial.go | transport/internet/domainsocket/dial.go | //go:build !windows && !wasm
// +build !windows,!wasm
package domainsocket
import (
"context"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
func Dial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) {
settings := streamSettings.ProtocolSettings.(*Config)
addr, err := settings.GetUnixAddr()
if err != nil {
return nil, err
}
conn, err := net.DialUnix("unix", nil, addr)
if err != nil {
return nil, newError("failed to dial unix: ", settings.Path).Base(err).AtWarning()
}
if config := tls.ConfigFromStreamSettings(streamSettings); config != nil {
return tls.Client(conn, config.GetTLSConfig(tls.WithDestination(dest))), nil
}
return conn, nil
}
func init() {
common.Must(internet.RegisterTransportDialer(protocolName, Dial))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/interface.go | transport/internet/tlsmirror/interface.go | package tlsmirror
import (
"context"
"github.com/v2fly/v2ray-core/v5/common"
)
type TLSRecord struct {
RecordType byte
LegacyProtocolVersion [2]byte
RecordLength uint16
Fragment []byte
// Annotations are used to store additional information about the record. Never sent over the wire.
InsertedMessage bool
}
type RecordReader interface {
ReadNextRecord(rejectProfile PartialTLSRecordRejectProfile) (*TLSRecord, error)
}
type RecordWriter interface {
WriteRecord(record *TLSRecord) error
}
type Peeker interface {
Peek(n int) ([]byte, error)
}
type PartialTLSRecordRejectProfile interface {
TestIfReject(record *TLSRecord, readyFields int) error
}
type MessageHook func(message *TLSRecord) (drop bool, ok error)
type ExplicitNonceDetection func(cipherSuite uint16) bool
type InsertableTLSConn interface {
common.Closable
GetHandshakeRandom() ([]byte, []byte, error)
InsertC2SMessage(message *TLSRecord) error
InsertS2CMessage(message *TLSRecord) error
GetApplicationDataExplicitNonceReservedOverheadHeaderLength() (int, error)
}
const TrafficGeneratorManagedConnectionContextKey = "TrafficGeneratorManagedConnection-ku63HMMD-kduCPhr8-DN4y6WEa"
type TrafficGeneratorManagedConnection interface {
RecallTrafficGenerator() error
WaitConnectionReady() context.Context
IsConnectionInvalidated() bool
}
type ConnectionEnrollmentConfirmation interface {
VerifyConnectionEnrollment(req *EnrollmentConfirmationReq) (*EnrollmentConfirmationResp, error)
}
const EnrollmentVerificationControlConnectionPostfix = ".tlsmirror-controlconnection.v2fly.arpa"
type InsertableTLSConnForEnrollment interface {
InsertableTLSConnEnrollmentEventReceiver
}
type InsertableTLSConnEnrollmentEventReceiver interface {
ConnectionEnrollmentConfirmation
}
type RemoveConnectionFunc func() error
type ConnectionEnrollmentConfirmationProcessor interface {
ConnectionEnrollmentConfirmation
AddConnection(ctx context.Context, clientRandom, ServerRandom []byte, conn InsertableTLSConnForEnrollment) (RemoveConnectionFunc, error)
}
type ConnectionEnrollmentConfirmationClientInstanceConfig struct {
DefaultOutboundTag string
}
type ConnectionEnrollmentConfirmationClientInstanceConfigReceiver interface {
OnConnectionEnrollmentConfirmationClientInstanceConfigReady(ConnectionEnrollmentConfirmationClientInstanceConfig)
}
type ConnectionEnrollmentConfirmationServerInstanceConfig struct {
EnrollmentProcessor ConnectionEnrollmentConfirmationProcessor
}
type ConnectionEnrollmentConfirmationServerInstanceConfigReceiver interface {
OnConnectionEnrollmentConfirmationServerInstanceConfigReady(ConnectionEnrollmentConfirmationServerInstanceConfig)
}
type ConnectionLoopbackPrevention struct {
Key string
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/data.pb.go | transport/internet/tlsmirror/data.pb.go | package tlsmirror
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type EnrollmentConfirmationReq struct {
state protoimpl.MessageState `protogen:"open.v1"`
ServerIdentifier []byte `protobuf:"bytes,1,opt,name=server_identifier,json=serverIdentifier,proto3" json:"server_identifier,omitempty"`
CarrierTlsConnectionClientRandom []byte `protobuf:"bytes,2,opt,name=carrier_tls_connection_client_random,json=carrierTlsConnectionClientRandom,proto3" json:"carrier_tls_connection_client_random,omitempty"`
CarrierTlsConnectionServerRandom []byte `protobuf:"bytes,3,opt,name=carrier_tls_connection_server_random,json=carrierTlsConnectionServerRandom,proto3" json:"carrier_tls_connection_server_random,omitempty"`
ClientIdentifier []byte `protobuf:"bytes,4,opt,name=client_identifier,json=clientIdentifier,proto3" json:"client_identifier,omitempty"` // Implicated
ReplyAddressTag []byte `protobuf:"bytes,5,opt,name=reply_address_tag,json=replyAddressTag,proto3" json:"reply_address_tag,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EnrollmentConfirmationReq) Reset() {
*x = EnrollmentConfirmationReq{}
mi := &file_transport_internet_tlsmirror_data_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EnrollmentConfirmationReq) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EnrollmentConfirmationReq) ProtoMessage() {}
func (x *EnrollmentConfirmationReq) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_data_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EnrollmentConfirmationReq.ProtoReflect.Descriptor instead.
func (*EnrollmentConfirmationReq) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_data_proto_rawDescGZIP(), []int{0}
}
func (x *EnrollmentConfirmationReq) GetServerIdentifier() []byte {
if x != nil {
return x.ServerIdentifier
}
return nil
}
func (x *EnrollmentConfirmationReq) GetCarrierTlsConnectionClientRandom() []byte {
if x != nil {
return x.CarrierTlsConnectionClientRandom
}
return nil
}
func (x *EnrollmentConfirmationReq) GetCarrierTlsConnectionServerRandom() []byte {
if x != nil {
return x.CarrierTlsConnectionServerRandom
}
return nil
}
func (x *EnrollmentConfirmationReq) GetClientIdentifier() []byte {
if x != nil {
return x.ClientIdentifier
}
return nil
}
func (x *EnrollmentConfirmationReq) GetReplyAddressTag() []byte {
if x != nil {
return x.ReplyAddressTag
}
return nil
}
type EnrollmentConfirmationResp struct {
state protoimpl.MessageState `protogen:"open.v1"`
Enrolled bool `protobuf:"varint,1,opt,name=enrolled,proto3" json:"enrolled,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *EnrollmentConfirmationResp) Reset() {
*x = EnrollmentConfirmationResp{}
mi := &file_transport_internet_tlsmirror_data_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *EnrollmentConfirmationResp) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*EnrollmentConfirmationResp) ProtoMessage() {}
func (x *EnrollmentConfirmationResp) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_data_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use EnrollmentConfirmationResp.ProtoReflect.Descriptor instead.
func (*EnrollmentConfirmationResp) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_data_proto_rawDescGZIP(), []int{1}
}
func (x *EnrollmentConfirmationResp) GetEnrolled() bool {
if x != nil {
return x.Enrolled
}
return false
}
var File_transport_internet_tlsmirror_data_proto protoreflect.FileDescriptor
const file_transport_internet_tlsmirror_data_proto_rawDesc = "" +
"\n" +
"'transport/internet/tlsmirror/data.proto\x12'v2ray.core.transport.internet.tlsmirror\"\xc1\x02\n" +
"\x19EnrollmentConfirmationReq\x12+\n" +
"\x11server_identifier\x18\x01 \x01(\fR\x10serverIdentifier\x12N\n" +
"$carrier_tls_connection_client_random\x18\x02 \x01(\fR carrierTlsConnectionClientRandom\x12N\n" +
"$carrier_tls_connection_server_random\x18\x03 \x01(\fR carrierTlsConnectionServerRandom\x12+\n" +
"\x11client_identifier\x18\x04 \x01(\fR\x10clientIdentifier\x12*\n" +
"\x11reply_address_tag\x18\x05 \x01(\fR\x0freplyAddressTag\"8\n" +
"\x1aEnrollmentConfirmationResp\x12\x1a\n" +
"\benrolled\x18\x01 \x01(\bR\benrolledB\x96\x01\n" +
"+com.v2ray.core.transport.internet.tlsmirrorP\x01Z;github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror\xaa\x02'V2Ray.Core.Transport.Internet.Tlsmirrorb\x06proto3"
var (
file_transport_internet_tlsmirror_data_proto_rawDescOnce sync.Once
file_transport_internet_tlsmirror_data_proto_rawDescData []byte
)
func file_transport_internet_tlsmirror_data_proto_rawDescGZIP() []byte {
file_transport_internet_tlsmirror_data_proto_rawDescOnce.Do(func() {
file_transport_internet_tlsmirror_data_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_data_proto_rawDesc), len(file_transport_internet_tlsmirror_data_proto_rawDesc)))
})
return file_transport_internet_tlsmirror_data_proto_rawDescData
}
var file_transport_internet_tlsmirror_data_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_transport_internet_tlsmirror_data_proto_goTypes = []any{
(*EnrollmentConfirmationReq)(nil), // 0: v2ray.core.transport.internet.tlsmirror.EnrollmentConfirmationReq
(*EnrollmentConfirmationResp)(nil), // 1: v2ray.core.transport.internet.tlsmirror.EnrollmentConfirmationResp
}
var file_transport_internet_tlsmirror_data_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_transport_internet_tlsmirror_data_proto_init() }
func file_transport_internet_tlsmirror_data_proto_init() {
if File_transport_internet_tlsmirror_data_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_data_proto_rawDesc), len(file_transport_internet_tlsmirror_data_proto_rawDesc)),
NumEnums: 0,
NumMessages: 2,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_tlsmirror_data_proto_goTypes,
DependencyIndexes: file_transport_internet_tlsmirror_data_proto_depIdxs,
MessageInfos: file_transport_internet_tlsmirror_data_proto_msgTypes,
}.Build()
File_transport_internet_tlsmirror_data_proto = out.File
file_transport_internet_tlsmirror_data_proto_goTypes = nil
file_transport_internet_tlsmirror_data_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/errors.generated.go | transport/internet/tlsmirror/mirrorenrollment/errors.generated.go | package mirrorenrollment
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/client.go | transport/internet/tlsmirror/mirrorenrollment/client.go | package mirrorenrollment
import (
"context"
"net"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
v2net "github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorcommon"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation"
)
func NewEnrollmentConfirmationClient(
ctx context.Context,
config *Config,
serverIdentity []byte,
) (*EnrollmentConfirmationClient, error) {
if ctx == nil {
return nil, newError("context cannot be nil")
}
if config == nil {
return nil, newError("config cannot be nil")
}
ecc := &EnrollmentConfirmationClient{
ctx: ctx,
config: config,
serverIdentity: serverIdentity,
}
if err := ecc.init(); err != nil {
return nil, newError("failed to initialize enrollment confirmation client").Base(err).AtError()
}
return ecc, nil
}
type EnrollmentConfirmationClient struct {
ctx context.Context
config *Config
serverIdentity []byte
primaryEnrollmentConfirmationClient tlsmirror.ConnectionEnrollmentConfirmation
bootstrapEnrollmentConfirmationClients []tlsmirror.ConnectionEnrollmentConfirmation
}
func (c *EnrollmentConfirmationClient) VerifyConnectionEnrollment(req *tlsmirror.EnrollmentConfirmationReq) (*tlsmirror.EnrollmentConfirmationResp, error) {
resp, err := c.primaryEnrollmentConfirmationClient.VerifyConnectionEnrollment(req)
if err == nil {
if resp.Enrolled {
newError("enrollment confirmation verification with primary enrollment successful").Base(err).WriteToLog()
} else {
newError("enrollment confirmation verification with primary enrollment over, not enrolled").Base(err).WriteToLog()
}
return resp, nil
}
newError("enrollment confirmation verification with primary enrollment failed").Base(err).WriteToLog()
for _, bootstrapClient := range c.bootstrapEnrollmentConfirmationClients {
resp, err := bootstrapClient.VerifyConnectionEnrollment(req)
if err == nil {
if resp.Enrolled {
newError("enrollment confirmation verification with bootstrap enrollment successful").Base(err).WriteToLog()
} else {
newError("enrollment confirmation verification with bootstrap enrollment over, not enrolled").Base(err).WriteToLog()
}
return resp, nil
}
newError("enrollment confirmation verification with bootstrap enrollment failed").Base(err).WriteToLog()
}
return nil, newError("all enrollment confirmation clients failed").Base(err).AtError()
}
func (c *EnrollmentConfirmationClient) init() error {
rtt, _, err := httpenrollmentconfirmation.NewClientRoundTripperForEnrollmentConfirmation(
func(network, addr string) (net.Conn, error) {
transportEnvironment := envctx.EnvironmentFromContext(c.ctx).(environment.TransportEnvironment)
dialer := transportEnvironment.OutboundDialer()
if dialer == nil {
return nil, newError("no outbound dialer available in transport environment")
}
dest, err := v2net.ParseDestination(addr)
if err != nil {
return nil, newError("failed to parse destination address").Base(err).AtError()
}
dest.Network = v2net.Network_TCP
loopbackProtectedCtx := mirrorcommon.SetLoopbackProtectionFlagForContext(c.ctx, c.serverIdentity)
primaryConfirmationOutbound := c.config.PrimaryEgressOutbound
if primaryConfirmationOutbound == "" {
primaryConfirmationOutbound = transportEnvironment.SelfProxyTag()
loopbackProtectedCtx = mirrorcommon.SetSecondaryLoopbackProtectionFlagForContext(c.ctx, c.serverIdentity)
}
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()
}
c.primaryEnrollmentConfirmationClient, err = httpenrollmentconfirmation.NewHTTPEnrollmentConfirmationClientFromHTTPRoundTripper(rtt)
if err != nil {
return newError("failed to create HTTP enrollment confirmation client").Base(err).AtError()
}
for _, bootstrapEnrollmentConfirmationConfig := range c.config.BootstrapEgressConfig {
enrollment, err := serial.GetInstanceOf(bootstrapEnrollmentConfirmationConfig)
if err != nil {
return newError("failed to get instance of bootstrap enrollment confirmation config").Base(err).AtError()
}
loopbackProtectedCtx := mirrorcommon.SetLoopbackProtectionFlagForContext(c.ctx, c.serverIdentity)
enrollmentInst, err := common.CreateObject(loopbackProtectedCtx, enrollment)
if err != nil {
return newError("failed to create bootstrap enrollment confirmation config").Base(err).AtError()
}
enrollmentConfirmation, ok := enrollmentInst.(tlsmirror.ConnectionEnrollmentConfirmation)
if !ok {
return newError("bootstrap enrollment confirmation config is not a valid ConnectionEnrollmentConfirmation")
}
if configReceiver, ok := enrollmentConfirmation.(tlsmirror.ConnectionEnrollmentConfirmationClientInstanceConfigReceiver); ok {
configReceiver.OnConnectionEnrollmentConfirmationClientInstanceConfigReady(tlsmirror.ConnectionEnrollmentConfirmationClientInstanceConfig{
DefaultOutboundTag: c.config.BootstrapEgressOutbound,
})
}
c.bootstrapEnrollmentConfirmationClients = append(c.bootstrapEnrollmentConfirmationClients, enrollmentConfirmation)
}
return nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/enrollment.go | transport/internet/tlsmirror/mirrorenrollment/enrollment.go | package mirrorenrollment
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/keyderivation.go | transport/internet/tlsmirror/mirrorenrollment/keyderivation.go | package mirrorenrollment
import (
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorcrypto"
)
type EnrollmentKey struct {
EnrollmentRequestKey []byte
EnrollmentResponseKey []byte
}
func DeriveEnrollmentKeyWithClientAndServerRandom(primaryKey []byte, clientRandom []byte, serverRandom []byte) (*EnrollmentKey, error) {
requestKey, responseKey, err := mirrorcrypto.DeriveEncryptionKey(primaryKey, clientRandom, serverRandom,
":connection-enrollment-re78HQNM-CmpRnPbr-PNJVRMhu")
if err != nil {
return nil, newError("failed to derive connection enrollment key").Base(err).AtError()
}
return &EnrollmentKey{
EnrollmentRequestKey: requestKey,
EnrollmentResponseKey: responseKey,
}, nil
}
func DeriveEnrollmentServerIdentifier(primaryKey []byte) ([]byte, error) {
if len(primaryKey) != 32 {
return nil, newError("invalid primary key size: ", len(primaryKey))
}
// Use HKDF to derive a secondary key
serverID, err := mirrorcrypto.DeriveSecondaryKey(primaryKey, ":connection-enrollment-server-identifier-av38NNGF-TJvRw7C3-p8KM8yKd")
if err != nil {
return nil, newError("unable to server identifier").Base(err)
}
return serverID, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/cancelContextOnCloseConn.go | transport/internet/tlsmirror/mirrorenrollment/cancelContextOnCloseConn.go | 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()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/server.go | transport/internet/tlsmirror/mirrorenrollment/server.go | package mirrorenrollment
import (
"context"
"net"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation"
)
func NewEnrollmentConfirmationServer(ctx context.Context, config *Config, enrollmentProcessor tlsmirror.ConnectionEnrollmentConfirmationProcessor) (*EnrollmentConfirmationServer, error) {
if ctx == nil {
return nil, newError("context cannot be nil")
}
if config == nil {
return nil, newError("config cannot be nil")
}
if enrollmentProcessor == nil {
return nil, newError("enrollment processor cannot be nil")
}
enrollmentHandler, err := httpenrollmentconfirmation.NewHTTPEnrollmentConfirmationServerFromConnectionEnrollmentConfirmation(enrollmentProcessor)
if err != nil {
return nil, newError("failed to create HTTP enrollment confirmation server").Base(err).AtError()
}
primaryIngressConnectionHandler := httpenrollmentconfirmation.NewHTTPConnectionHub(enrollmentHandler)
s := &EnrollmentConfirmationServer{
ctx: ctx,
config: config,
enrollmentProcessor: enrollmentProcessor,
primaryIngressConnectionHandler: primaryIngressConnectionHandler,
}
if err = s.init(); err != nil {
return nil, newError("failed to initialize enrollment confirmation server").Base(err).AtError()
}
return s, nil
}
type EnrollmentConfirmationServer struct {
ctx context.Context
config *Config
enrollmentProcessor tlsmirror.ConnectionEnrollmentConfirmationProcessor
primaryIngressConnectionHandler *httpenrollmentconfirmation.HTTPConnectionHub
bootstrapIngressConnectionHandlers []tlsmirror.ConnectionEnrollmentConfirmationServerInstanceConfigReceiver
}
func (s *EnrollmentConfirmationServer) HandlePrimaryIngressConnection(ctx context.Context, conn net.Conn) error {
err := s.primaryIngressConnectionHandler.ServeConnection(ctx, conn)
if err != nil {
return newError("failed to handle primary ingress connection").Base(err).AtError()
}
return nil
}
func (s *EnrollmentConfirmationServer) init() error {
for _, handler := range s.config.BootstrapIngressConfig {
bootstrapEnrollmentHandler, err := serial.GetInstanceOf(handler)
if err != nil {
return newError("failed to get instance of bootstrap enrollment handler").Base(err).AtError()
}
bootstrapEnrollmentHandlerObj, err := common.CreateObject(s.ctx, bootstrapEnrollmentHandler)
if err != nil {
return newError("failed to create bootstrap enrollment handler").Base(err).AtError()
}
bootstrapEnrollmentHandlerObjTyped, ok := bootstrapEnrollmentHandlerObj.(tlsmirror.ConnectionEnrollmentConfirmationServerInstanceConfigReceiver)
if !ok {
return newError("bootstrap enrollment handler is not a valid ConnectionEnrollmentConfirmationServerInstanceConfigReceiver")
}
bootstrapEnrollmentHandlerObjTyped.OnConnectionEnrollmentConfirmationServerInstanceConfigReady(
tlsmirror.ConnectionEnrollmentConfirmationServerInstanceConfig{
EnrollmentProcessor: s.enrollmentProcessor,
})
s.bootstrapIngressConnectionHandlers = append(s.bootstrapIngressConnectionHandlers, bootstrapEnrollmentHandlerObjTyped)
}
return nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/serverenrollmentprocessor.go | transport/internet/tlsmirror/mirrorenrollment/serverenrollmentprocessor.go | package mirrorenrollment
import (
"context"
"sync"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
)
func NewServerEnrollmentProcessor(primaryKey []byte) (tlsmirror.ConnectionEnrollmentConfirmationProcessor, error) {
if len(primaryKey) == 0 {
return nil, newError("primary key cannot be empty")
}
return &serverEnrollmentProcessor{
primaryKey: primaryKey,
}, nil
}
type serverEnrollmentProcessor struct {
primaryKey []byte
activeConnections sync.Map
}
func (p *serverEnrollmentProcessor) AddConnection(ctx context.Context, clientRandom, serverRandom []byte, conn tlsmirror.InsertableTLSConnForEnrollment) (tlsmirror.RemoveConnectionFunc, error) {
if conn == nil {
return nil, newError("nil InsertableTLSConnForEnrollment")
}
enrollmentKey, err := DeriveEnrollmentKeyWithClientAndServerRandom(p.primaryKey, clientRandom, serverRandom)
if err != nil {
return nil, newError("failed to derive enrollment key").Base(err).AtError()
}
if _, loaded := p.activeConnections.LoadOrStore(string(enrollmentKey.EnrollmentRequestKey), conn); loaded {
return nil, newError("connection with ID ", enrollmentKey.EnrollmentRequestKey, " already exists")
}
return func() error {
p.activeConnections.Delete(string(enrollmentKey.EnrollmentRequestKey))
return nil
}, nil
}
func (p *serverEnrollmentProcessor) VerifyConnectionEnrollment(req *tlsmirror.EnrollmentConfirmationReq) (*tlsmirror.EnrollmentConfirmationResp, error) {
if req == nil {
return nil, newError("nil EnrollmentConfirmationReq")
}
if req.CarrierTlsConnectionClientRandom == nil || req.CarrierTlsConnectionServerRandom == nil {
return nil, newError("missing client or server random in EnrollmentConfirmationReq")
}
enrollmentKey, err := DeriveEnrollmentKeyWithClientAndServerRandom(p.primaryKey,
req.CarrierTlsConnectionClientRandom, req.CarrierTlsConnectionServerRandom)
if err != nil {
return nil, newError("failed to derive enrollment key").Base(err).AtError()
}
if conn, ok := p.activeConnections.Load(string(enrollmentKey.EnrollmentRequestKey)); ok {
insertableConn, ok := conn.(tlsmirror.InsertableTLSConnForEnrollment)
if !ok {
return nil, newError("connection does not implement InsertableTLSConnForEnrollment")
}
return insertableConn.VerifyConnectionEnrollment(req)
}
return &tlsmirror.EnrollmentConfirmationResp{
Enrolled: false,
}, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/config.pb.go | transport/internet/tlsmirror/mirrorenrollment/config.pb.go | package mirrorenrollment
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
// This will be handled by the TLS Mirror server, the enrollment part only accepts existing connections.
PrimaryIngressOutbound string `protobuf:"bytes,1,opt,name=primary_ingress_outbound,json=primaryIngressOutbound,proto3" json:"primary_ingress_outbound,omitempty"`
PrimaryEgressOutbound string `protobuf:"bytes,2,opt,name=primary_egress_outbound,json=primaryEgressOutbound,proto3" json:"primary_egress_outbound,omitempty"`
BootstrapIngressUrl []string `protobuf:"bytes,3,rep,name=bootstrap_ingress_url,json=bootstrapIngressUrl,proto3" json:"bootstrap_ingress_url,omitempty"`
BootstrapEgressUrl []string `protobuf:"bytes,4,rep,name=bootstrap_egress_url,json=bootstrapEgressUrl,proto3" json:"bootstrap_egress_url,omitempty"`
BootstrapIngressConfig []*anypb.Any `protobuf:"bytes,5,rep,name=bootstrap_ingress_config,json=bootstrapIngressConfig,proto3" json:"bootstrap_ingress_config,omitempty"`
BootstrapEgressConfig []*anypb.Any `protobuf:"bytes,6,rep,name=bootstrap_egress_config,json=bootstrapEgressConfig,proto3" json:"bootstrap_egress_config,omitempty"`
BootstrapEgressOutbound string `protobuf:"bytes,7,opt,name=bootstrap_egress_outbound,json=bootstrapEgressOutbound,proto3" json:"bootstrap_egress_outbound,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_tlsmirror_mirrorenrollment_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_mirrorenrollment_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDescGZIP(), []int{0}
}
func (x *Config) GetPrimaryIngressOutbound() string {
if x != nil {
return x.PrimaryIngressOutbound
}
return ""
}
func (x *Config) GetPrimaryEgressOutbound() string {
if x != nil {
return x.PrimaryEgressOutbound
}
return ""
}
func (x *Config) GetBootstrapIngressUrl() []string {
if x != nil {
return x.BootstrapIngressUrl
}
return nil
}
func (x *Config) GetBootstrapEgressUrl() []string {
if x != nil {
return x.BootstrapEgressUrl
}
return nil
}
func (x *Config) GetBootstrapIngressConfig() []*anypb.Any {
if x != nil {
return x.BootstrapIngressConfig
}
return nil
}
func (x *Config) GetBootstrapEgressConfig() []*anypb.Any {
if x != nil {
return x.BootstrapEgressConfig
}
return nil
}
func (x *Config) GetBootstrapEgressOutbound() string {
if x != nil {
return x.BootstrapEgressOutbound
}
return ""
}
var File_transport_internet_tlsmirror_mirrorenrollment_config_proto protoreflect.FileDescriptor
const file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDesc = "" +
"\n" +
":transport/internet/tlsmirror/mirrorenrollment/config.proto\x128v2ray.core.transport.internet.tlsmirror.mirrorenrollment\x1a common/protoext/extensions.proto\x1a\x19google/protobuf/any.proto\"\xba\x03\n" +
"\x06Config\x128\n" +
"\x18primary_ingress_outbound\x18\x01 \x01(\tR\x16primaryIngressOutbound\x126\n" +
"\x17primary_egress_outbound\x18\x02 \x01(\tR\x15primaryEgressOutbound\x122\n" +
"\x15bootstrap_ingress_url\x18\x03 \x03(\tR\x13bootstrapIngressUrl\x120\n" +
"\x14bootstrap_egress_url\x18\x04 \x03(\tR\x12bootstrapEgressUrl\x12N\n" +
"\x18bootstrap_ingress_config\x18\x05 \x03(\v2\x14.google.protobuf.AnyR\x16bootstrapIngressConfig\x12L\n" +
"\x17bootstrap_egress_config\x18\x06 \x03(\v2\x14.google.protobuf.AnyR\x15bootstrapEgressConfig\x12:\n" +
"\x19bootstrap_egress_outbound\x18\a \x01(\tR\x17bootstrapEgressOutboundB\xc9\x01\n" +
"<com.v2ray.core.transport.internet.tlsmirror.mirrorenrollmentP\x01ZLgithub.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorenrollment\xaa\x028V2Ray.Core.Transport.Internet.Tlsmirror.MirrorEnrollmentb\x06proto3"
var (
file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDescOnce sync.Once
file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDescData []byte
)
func file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDescGZIP() []byte {
file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDescOnce.Do(func() {
file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDesc), len(file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDesc)))
})
return file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDescData
}
var file_transport_internet_tlsmirror_mirrorenrollment_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_transport_internet_tlsmirror_mirrorenrollment_config_proto_goTypes = []any{
(*Config)(nil), // 0: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.Config
(*anypb.Any)(nil), // 1: google.protobuf.Any
}
var file_transport_internet_tlsmirror_mirrorenrollment_config_proto_depIdxs = []int32{
1, // 0: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.Config.bootstrap_ingress_config:type_name -> google.protobuf.Any
1, // 1: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.Config.bootstrap_egress_config:type_name -> google.protobuf.Any
2, // [2:2] is the sub-list for method output_type
2, // [2:2] is the sub-list for method input_type
2, // [2:2] is the sub-list for extension type_name
2, // [2:2] is the sub-list for extension extendee
0, // [0:2] is the sub-list for field type_name
}
func init() { file_transport_internet_tlsmirror_mirrorenrollment_config_proto_init() }
func file_transport_internet_tlsmirror_mirrorenrollment_config_proto_init() {
if File_transport_internet_tlsmirror_mirrorenrollment_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDesc), len(file_transport_internet_tlsmirror_mirrorenrollment_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_tlsmirror_mirrorenrollment_config_proto_goTypes,
DependencyIndexes: file_transport_internet_tlsmirror_mirrorenrollment_config_proto_depIdxs,
MessageInfos: file_transport_internet_tlsmirror_mirrorenrollment_config_proto_msgTypes,
}.Build()
File_transport_internet_tlsmirror_mirrorenrollment_config_proto = out.File
file_transport_internet_tlsmirror_mirrorenrollment_config_proto_goTypes = nil
file_transport_internet_tlsmirror_mirrorenrollment_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/hub.go | transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/hub.go | package httpenrollmentconfirmation
import (
"context"
"net"
"net/http"
"golang.org/x/net/http2"
)
func NewHTTPConnectionHub(handler http.Handler) *HTTPConnectionHub {
return &HTTPConnectionHub{
handler: handler,
h2server: &http2.Server{},
}
}
type HTTPConnectionHub struct {
handler http.Handler
h2server *http2.Server
}
func (h *HTTPConnectionHub) ServeConnection(ctx context.Context, conn net.Conn) error {
go h.h2server.ServeConn(conn, &http2.ServeConnOpts{
Handler: h.handler,
})
return nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/errors.generated.go | transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/errors.generated.go | package httpenrollmentconfirmation
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/client.go | transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/client.go | package httpenrollmentconfirmation
import (
"bytes"
"encoding/base32"
"io"
"net/http"
protov2 "google.golang.org/protobuf/proto"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
)
func NewHTTPEnrollmentConfirmationClientFromHTTPRoundTripper(tripper http.RoundTripper) (tlsmirror.ConnectionEnrollmentConfirmation, error) {
if tripper == nil {
return nil, newError("nil tripper")
}
return &client{
httpRoundTripper: tripper,
}, nil
}
type client struct {
httpRoundTripper http.RoundTripper
}
func (c *client) VerifyConnectionEnrollment(req *tlsmirror.EnrollmentConfirmationReq) (*tlsmirror.EnrollmentConfirmationResp, error) {
requestMessage, err := protov2.Marshal(req)
if err != nil {
return nil, newError("failed to marshal enrollment confirmation request").Base(err)
}
serverID := base32.NewEncoding("0123456789abcdefghijklmnopqrstuv").WithPadding(base32.NoPadding).EncodeToString(req.ServerIdentifier)
httpReq, err := http.NewRequest("POST", "http://"+serverID+tlsmirror.EnrollmentVerificationControlConnectionPostfix, bytes.NewReader(requestMessage))
if err != nil {
return nil, newError("failed to create HTTP request").Base(err)
}
httpResp, err := c.httpRoundTripper.RoundTrip(httpReq)
defer func() {
if httpResp != nil && httpResp.Body != nil {
httpResp.Body.Close()
}
}()
if err != nil {
return nil, newError("failed to send HTTP request").Base(err)
}
if httpResp.StatusCode != http.StatusOK {
return nil, newError("unexpected HTTP response status: ", httpResp.StatusCode)
}
responseMessage, err := io.ReadAll(httpResp.Body)
if err != nil {
return nil, newError("failed to read HTTP response body").Base(err)
}
resp := &tlsmirror.EnrollmentConfirmationResp{}
if err := protov2.Unmarshal(responseMessage, resp); err != nil {
return nil, newError("failed to unmarshal enrollment confirmation response").Base(err)
}
return resp, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/enrollment.go | transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/enrollment.go | package httpenrollmentconfirmation
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/clientbuilder.go | transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/clientbuilder.go | package httpenrollmentconfirmation
import (
"context"
"encoding/base32"
"net"
"net/http"
"sync"
"time"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/httponconnection"
)
func NewClientRoundTripperForEnrollmentConfirmation(
dial func(network, addr string) (net.Conn, error),
serverIdentity []byte,
) (http.RoundTripper, RoundTripperMetadata, error) {
if dial == nil {
return nil, nil, newError("nil dial function")
}
if len(serverIdentity) == 0 {
return nil, nil, newError("nil or empty server identity")
}
cr := &clientRoundtripper{
dial: dial,
serverIdentity: serverIdentity,
}
return cr, cr, nil
}
type RoundTripperMetadata interface {
IsCreatingSecondaryNewConnection() bool
}
type clientRoundtripper struct {
dial func(network, addr string) (net.Conn, error)
serverIdentity []byte
currentConnInnerConn common.Closable
currentConn http.RoundTripper
currentConnLock sync.RWMutex
pendingNewConnection int
// DO NOT ATTEMPT TO ACQUIRE ANY LOCK WHILE HOLDING THIS LOCK
pendingNewConnectionLock sync.RWMutex
}
func (c *clientRoundtripper) IsCreatingSecondaryNewConnection() bool {
defer c.pendingNewConnectionLock.RUnlock()
c.pendingNewConnectionLock.RLock()
return c.pendingNewConnection >= 1
}
func (c *clientRoundtripper) RoundTrip(request *http.Request) (*http.Response, error) {
if c.IsCreatingSecondaryNewConnection() {
return nil, newError("another connection is being established, cannot create a secondary connection")
}
return c.roundTrip(request)
}
func (c *clientRoundtripper) roundTrip(request *http.Request) (*http.Response, error) {
c.currentConnLock.RLock()
if c.currentConn == nil {
c.currentConnLock.RUnlock()
c.pendingNewConnectionLock.Lock()
c.pendingNewConnection += 1
c.pendingNewConnectionLock.Unlock()
decreaseCount := func() {
c.pendingNewConnectionLock.Lock()
c.pendingNewConnection -= 1
c.pendingNewConnectionLock.Unlock()
}
if err := c.createNewConnection(); err != nil {
decreaseCount()
return nil, err // Failed to create a new connection
}
resp, err := c.roundTrip(request)
decreaseCount()
return resp, err
}
defer c.currentConnLock.RUnlock()
timeoutContext, _ := context.WithTimeout(context.Background(), time.Second*30) //nolint:govet
request = request.WithContext(timeoutContext)
resp, err := c.currentConn.RoundTrip(request)
// Use the current connection to perform the round trip
if err != nil {
if resp != nil && resp.Body != nil {
resp.Body.Close()
}
defer func() {
c.currentConnLock.RUnlock()
c.currentConnLock.Lock()
if c.currentConn != nil {
c.currentConnInnerConn.Close()
c.currentConnInnerConn = nil
c.currentConn = nil
}
c.currentConnLock.Unlock()
c.currentConnLock.RLock()
}()
return nil, newError("unable to roundtrip for enrollment verification").Base(err)
}
return resp, nil
}
func (c *clientRoundtripper) createNewConnection() error {
c.currentConnLock.Lock()
defer c.currentConnLock.Unlock()
if c.currentConn != nil {
return nil // Connection already exists
}
serverID := base32.NewEncoding("0123456789abcdefghijklmnopqrstuv").WithPadding(base32.NoPadding).EncodeToString(c.serverIdentity)
conn, err := c.dial("tcp", serverID+tlsmirror.EnrollmentVerificationControlConnectionPostfix+":80")
if err != nil {
return newError("failed to dial server: ", err)
}
c.currentConnInnerConn = conn
c.currentConn, err = httponconnection.NewSingleConnectionHTTPTransport(conn, "h2")
if err != nil {
_ = conn.Close() // Close the connection if transport creation fails
return newError("failed to create HTTP transport: ", err)
}
return nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/server.go | transport/internet/tlsmirror/mirrorenrollment/httpenrollmentconfirmation/server.go | package httpenrollmentconfirmation
import (
"io"
"net/http"
"strconv"
"google.golang.org/protobuf/proto"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
)
func NewHTTPEnrollmentConfirmationServerFromConnectionEnrollmentConfirmation(confirmation tlsmirror.ConnectionEnrollmentConfirmation) (http.Handler, error) {
if confirmation == nil {
return nil, newError("nil confirmation")
}
return &server{
ConnectionEnrollmentConfirmation: confirmation,
}, nil
}
type server struct {
tlsmirror.ConnectionEnrollmentConfirmation
}
func (s *server) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
requestBody, err := io.ReadAll(request.Body)
if err != nil {
http.Error(writer, "failed to read request body: "+err.Error(), http.StatusInternalServerError)
return
}
req := &tlsmirror.EnrollmentConfirmationReq{}
if err := proto.Unmarshal(requestBody, req); err != nil {
http.Error(writer, "failed to unmarshal request: "+err.Error(), http.StatusBadRequest)
return
}
resp, err := s.VerifyConnectionEnrollment(req)
if err != nil {
http.Error(writer, "failed to verify connection enrollment: "+err.Error(), http.StatusInternalServerError)
return
}
responseBody, err := proto.Marshal(resp)
if err != nil {
http.Error(writer, "failed to marshal response: "+err.Error(), http.StatusInternalServerError)
return
}
writer.Header().Set("Content-Type", "application/octet-stream")
writer.Header().Set("Content-Length", strconv.Itoa(len(responseBody)))
writer.WriteHeader(http.StatusOK)
if _, err := writer.Write(responseBody); err != nil {
http.Error(writer, "failed to write response: "+err.Error(), http.StatusInternalServerError)
return
}
if flusher, ok := writer.(http.Flusher); ok {
flusher.Flush()
} else {
http.Error(writer, "response writer does not support flushing", http.StatusInternalServerError)
return
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/errors.generated.go | transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/errors.generated.go | package roundtripperenrollmentconfirmation
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/client.go | transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/client.go | package roundtripperenrollmentconfirmation
import (
"context"
csrand "crypto/rand"
"io"
"net"
"google.golang.org/protobuf/proto"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
v2net "github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
"github.com/v2fly/v2ray-core/v5/transport/internet/security"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
)
func NewClient(ctx context.Context, config *ClientConfig) (*Client, error) {
if ctx == nil {
return nil, newError("context cannot be nil")
}
if config == nil {
return nil, newError("config cannot be nil")
}
rttClientConfig, err := serial.GetInstanceOf(config.RoundTripperClient)
if err != nil {
return nil, newError("failed to get instance of RoundTripperClient").Base(err)
}
rttClientI, err := common.CreateObject(ctx, rttClientConfig)
if err != nil {
return nil, newError("failed to create RoundTripperClient").Base(err)
}
rttClient, ok := rttClientI.(request.RoundTripperClient)
if !ok {
return nil, newError("RoundTripperClient is not a valid request.RoundTripperClient")
}
clientTemporaryIdentifier := make([]byte, 16)
if _, err := csrand.Read(clientTemporaryIdentifier); err != nil {
return nil, newError("failed to generate client temporary identifier").Base(err)
}
c := &Client{
ctx: ctx,
config: config,
rttClient: rttClient,
clientTemporaryIdentifier: clientTemporaryIdentifier,
}
rttClient.OnTransportClientAssemblyReady(c)
return c, nil
}
type Client struct {
config *ClientConfig
rttClient request.RoundTripperClient
clientTemporaryIdentifier []byte
ctx context.Context
defaultOutboundTag string
}
func (c *Client) OnConnectionEnrollmentConfirmationClientInstanceConfigReady(config tlsmirror.ConnectionEnrollmentConfirmationClientInstanceConfig) {
c.defaultOutboundTag = config.DefaultOutboundTag
}
func (c *Client) Dial(ctx context.Context) (net.Conn, error) {
transportEnvironment := envctx.EnvironmentFromContext(c.ctx).(environment.TransportEnvironment)
dialer := transportEnvironment.OutboundDialer()
if dialer == nil {
return nil, newError("no outbound dialer available in transport environment")
}
dest, err := v2net.ParseDestination(c.config.Dest)
if err != nil {
return nil, newError("failed to parse destination address").Base(err).AtError()
}
dest.Network = v2net.Network_TCP
conn, err := dialer(c.ctx, dest, c.config.OutboundTag)
if err != nil {
return nil, newError("failed to dial to destination").Base(err).AtError()
}
if c.config.SecurityConfig != nil {
securityConfigSetting, err := serial.GetInstanceOf(c.config.SecurityConfig)
if err != nil {
return nil, newError("unable to get security config instance").Base(err)
}
securityEngine, err := common.CreateObject(c.ctx, securityConfigSetting)
if err != nil {
return nil, newError("unable to create security engine from security settings").Base(err)
}
securityEngineTyped, ok := securityEngine.(security.Engine)
if !ok {
return nil, newError("type assertion error when create security engine from security settings")
}
conn, err = securityEngineTyped.Client(conn, security.OptionWithDestination{Dest: dest})
if err != nil {
return nil, newError("unable to create security protocol client from security engine").Base(err)
}
}
return conn, nil
}
func (c *Client) Tripper() request.Tripper {
return c.rttClient
}
func (c *Client) AutoImplDialer() request.Dialer {
return c
}
func (c *Client) VerifyConnectionEnrollment(req *tlsmirror.EnrollmentConfirmationReq) (*tlsmirror.EnrollmentConfirmationResp, error) {
connectionTagServerID := req.ServerIdentifier
if c.config.ServerIdentity != nil {
connectionTagServerID = c.config.ServerIdentity
}
var replyAddressTag [16]byte
_, err := io.ReadFull(csrand.Reader, replyAddressTag[:])
if err != nil {
return nil, newError("failed to generate reply address tag").Base(err)
}
connectionTag := append(replyAddressTag[:], connectionTagServerID...) //nolint:gocritic
req.ClientIdentifier = c.clientTemporaryIdentifier
req.ReplyAddressTag = replyAddressTag[:]
wrappedData, err := proto.Marshal(req)
if err != nil {
return nil, newError("failed to marshal enrollment confirmation request").Base(err)
}
wreq := request.Request{
Data: wrappedData,
ConnectionTag: connectionTag,
}
resp, err := c.rttClient.RoundTrip(c.ctx, wreq)
if err != nil {
return nil, newError("failed to perform round trip").Base(err)
}
confirmationResp := &tlsmirror.EnrollmentConfirmationResp{}
if err := proto.Unmarshal(resp.Data, confirmationResp); err != nil {
return nil, newError("failed to unmarshal enrollment confirmation response").Base(err)
}
return confirmationResp, nil
}
func init() {
common.Must(common.RegisterConfig((*ClientConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return NewClient(ctx, config.(*ClientConfig))
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/serverinverserole.go | transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/serverinverserole.go | package roundtripperenrollmentconfirmation
import (
"context"
csrand "crypto/rand"
"net"
"google.golang.org/protobuf/proto"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
v2net "github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
"github.com/v2fly/v2ray-core/v5/transport/internet/security"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
)
func NewServerInverseRole(ctx context.Context, config *ServerInverseRoleConfig) (*ServerInverseRole, error) {
if ctx == nil {
return nil, newError("context cannot be nil")
}
if config == nil {
return nil, newError("config cannot be nil")
}
rttClientConfig, err := serial.GetInstanceOf(config.RoundTripperClient)
if err != nil {
return nil, newError("failed to get instance of RoundTripperClient").Base(err)
}
rttClientI, err := common.CreateObject(ctx, rttClientConfig)
if err != nil {
return nil, newError("failed to create RoundTripperClient").Base(err)
}
rttClient, ok := rttClientI.(request.RoundTripperClient)
if !ok {
return nil, newError("RoundTripperClient is not a valid request.RoundTripperClient")
}
clientTemporaryIdentifier := make([]byte, 16)
if _, err := csrand.Read(clientTemporaryIdentifier); err != nil {
return nil, newError("failed to generate client temporary identifier").Base(err)
}
c := &ServerInverseRole{
ctx: ctx,
config: config,
rttClient: rttClient,
clientTemporaryIdentifier: clientTemporaryIdentifier,
}
rttClient.OnTransportClientAssemblyReady(c)
go c.worker(ctx)
return c, nil
}
type ServerInverseRole struct {
config *ServerInverseRoleConfig
rttClient request.RoundTripperClient
clientTemporaryIdentifier []byte
ctx context.Context
defaultOutboundTag string
enrollmentProcessor tlsmirror.ConnectionEnrollmentConfirmationProcessor
}
func (c *ServerInverseRole) worker(ctx context.Context) {
for ctx.Err() == nil {
err := c.pollRemoteForEnrollment(ctx)
if err != nil {
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) {
transportEnvironment := envctx.EnvironmentFromContext(ctx).(environment.TransportEnvironment)
dialer := transportEnvironment.OutboundDialer()
if dialer == nil {
return nil, newError("no outbound dialer available in transport environment")
}
dest, err := v2net.ParseDestination(c.config.Dest)
if err != nil {
return nil, newError("failed to parse destination address").Base(err).AtError()
}
dest.Network = v2net.Network_TCP
conn, err := dialer(ctx, dest, c.config.OutboundTag)
if err != nil {
return nil, newError("failed to dial to destination").Base(err).AtError()
}
if c.config.SecurityConfig != nil {
securityConfigSetting, err := serial.GetInstanceOf(c.config.SecurityConfig)
if err != nil {
return nil, newError("unable to get security config instance").Base(err)
}
securityEngine, err := common.CreateObject(c.ctx, securityConfigSetting)
if err != nil {
return nil, newError("unable to create security engine from security settings").Base(err)
}
securityEngineTyped, ok := securityEngine.(security.Engine)
if !ok {
return nil, newError("type assertion error when create security engine from security settings")
}
conn, err = securityEngineTyped.Client(conn, security.OptionWithDestination{Dest: dest})
if err != nil {
return nil, newError("unable to create security protocol client from security engine").Base(err)
}
}
return conn, nil
}
func (c *ServerInverseRole) Tripper() request.Tripper {
return c.rttClient
}
func (c *ServerInverseRole) AutoImplDialer() request.Dialer {
return c
}
func (s *ServerInverseRole) OnConnectionEnrollmentConfirmationServerInstanceConfigReady(config tlsmirror.ConnectionEnrollmentConfirmationServerInstanceConfig) {
s.enrollmentProcessor = config.EnrollmentProcessor
}
func (s *ServerInverseRole) pollRemoteForEnrollment(ctx context.Context) error {
pollAs := s.config.ServerIdentity
req := request.Request{
ConnectionTag: pollAs,
}
resp, err := s.rttClient.RoundTrip(ctx, req)
if err != nil {
return newError("failed to poll remote for enrollment").Base(err)
}
if resp.Data == nil {
return newError("no enrollment confirmation response received from remote")
}
enrollmentReq := &tlsmirror.EnrollmentConfirmationReq{}
err = proto.Unmarshal(resp.Data, enrollmentReq)
if err != nil {
return newError("failed to unmarshal enrollment confirmation request").Base(err).AtError()
}
enrollmentResp, err := s.enrollmentProcessor.VerifyConnectionEnrollment(enrollmentReq)
if err != nil {
return newError("failed to process enrollment confirmation request").Base(err).AtError()
}
respData, err := proto.Marshal(enrollmentResp)
if err != nil {
return newError("failed to marshal enrollment confirmation response").Base(err).AtError()
}
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
}
func init() {
common.Must(common.RegisterConfig((*ServerInverseRoleConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return NewServerInverseRole(ctx, config.(*ServerInverseRoleConfig))
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/server.go | transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/server.go | package roundtripperenrollmentconfirmation
import (
"context"
"net"
"google.golang.org/protobuf/proto"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
v2net "github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet/request"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
)
func NewServer(ctx context.Context, config *ServerConfig) (*Server, error) {
s := &Server{
ctx: ctx,
config: config,
}
if err := s.init(); err != nil {
return nil, newError("failed to initialize RoundTripperEnrollmentConfirmation server").Base(err).AtError()
}
return s, nil
}
type Server struct {
config *ServerConfig
ctx context.Context
enrollmentProcessor tlsmirror.ConnectionEnrollmentConfirmationProcessor
rttServer request.RoundTripperServer
}
func (s *Server) OnConnectionEnrollmentConfirmationServerInstanceConfigReady(config tlsmirror.ConnectionEnrollmentConfirmationServerInstanceConfig) {
s.enrollmentProcessor = config.EnrollmentProcessor
}
func (s *Server) Listen(ctx context.Context) (v2net.Listener, error) {
transportEnvironment := envctx.EnvironmentFromContext(s.ctx).(environment.TransportEnvironment)
listener := transportEnvironment.Listener()
addr, err := v2net.ParseDestination(s.config.Listen)
if err != nil {
panic(newError("invalid listen address " + s.config.Listen).Base(err).AtError())
}
netaddr := &net.TCPAddr{IP: addr.Address.IP(), Port: int(addr.Port)}
l, err := listener.Listen(s.ctx, netaddr, nil)
if err != nil {
panic(newError("failed to listen on " + s.config.Listen).Base(err).AtError())
}
return l, nil
}
func (s *Server) OnRoundTrip(ctx context.Context, req request.Request, opts ...request.RoundTripperOption) (resp request.Response, err error) {
enrollmentReq := &tlsmirror.EnrollmentConfirmationReq{}
err = proto.Unmarshal(req.Data, enrollmentReq)
if err != nil {
return request.Response{}, newError("failed to unmarshal enrollment confirmation request").Base(err).AtError()
}
enrollmentResp, err := s.enrollmentProcessor.VerifyConnectionEnrollment(enrollmentReq)
if err != nil {
return request.Response{}, newError("failed to process enrollment confirmation request").Base(err).AtError()
}
respData, err := proto.Marshal(enrollmentResp)
if err != nil {
return request.Response{}, newError("failed to marshal enrollment confirmation response").Base(err).AtError()
}
return request.Response{
Data: respData,
}, nil
}
func (s *Server) TripperReceiver() request.TripperReceiver {
return s
}
func (s *Server) SessionReceiver() request.SessionReceiver {
return nil
}
func (s *Server) AutoImplListener() request.Listener {
return s
}
func (s *Server) init() error {
if s.config == nil {
return newError("nil ServerConfig")
}
if s.config.RoundTripperServer == nil {
return newError("nil RoundTripperServer in ServerConfig")
}
RoundTripperServerConfig, err := serial.GetInstanceOf(s.config.RoundTripperServer)
if err != nil {
return newError("failed to get instance of RoundTripperServer").Base(err).AtError()
}
RoundTripperServerObj, err := common.CreateObject(s.ctx, RoundTripperServerConfig)
if err != nil {
return newError("failed to create RoundTripperServer").Base(err).AtError()
}
RoundTripperServerTyped, ok := RoundTripperServerObj.(request.RoundTripperServer)
if !ok {
return newError("RoundTripperServer is not a valid request.RoundTripperServer")
}
s.rttServer = RoundTripperServerTyped
s.rttServer.OnTransportServerAssemblyReady(s)
if err := s.rttServer.Start(); err != nil {
return newError("failed to start RoundTripperServer").Base(err).AtError()
}
return nil
}
func init() {
common.Must(common.RegisterConfig((*ServerConfig)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return NewServer(ctx, config.(*ServerConfig))
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/config.pb.go | transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/config.pb.go | package roundtripperenrollmentconfirmation
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type ClientConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
RoundTripperClient *anypb.Any `protobuf:"bytes,1,opt,name=round_tripper_client,json=roundTripperClient,proto3" json:"round_tripper_client,omitempty"`
SecurityConfig *anypb.Any `protobuf:"bytes,2,opt,name=security_config,json=securityConfig,proto3" json:"security_config,omitempty"`
Dest string `protobuf:"bytes,3,opt,name=dest,proto3" json:"dest,omitempty"`
OutboundTag string `protobuf:"bytes,4,opt,name=outbound_tag,json=outboundTag,proto3" json:"outbound_tag,omitempty"`
ServerIdentity []byte `protobuf:"bytes,5,opt,name=server_identity,json=serverIdentity,proto3" json:"server_identity,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ClientConfig) Reset() {
*x = ClientConfig{}
mi := &file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ClientConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ClientConfig) ProtoMessage() {}
func (x *ClientConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ClientConfig.ProtoReflect.Descriptor instead.
func (*ClientConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDescGZIP(), []int{0}
}
func (x *ClientConfig) GetRoundTripperClient() *anypb.Any {
if x != nil {
return x.RoundTripperClient
}
return nil
}
func (x *ClientConfig) GetSecurityConfig() *anypb.Any {
if x != nil {
return x.SecurityConfig
}
return nil
}
func (x *ClientConfig) GetDest() string {
if x != nil {
return x.Dest
}
return ""
}
func (x *ClientConfig) GetOutboundTag() string {
if x != nil {
return x.OutboundTag
}
return ""
}
func (x *ClientConfig) GetServerIdentity() []byte {
if x != nil {
return x.ServerIdentity
}
return nil
}
type ServerInverseRoleConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
RoundTripperClient *anypb.Any `protobuf:"bytes,1,opt,name=round_tripper_client,json=roundTripperClient,proto3" json:"round_tripper_client,omitempty"`
SecurityConfig *anypb.Any `protobuf:"bytes,2,opt,name=security_config,json=securityConfig,proto3" json:"security_config,omitempty"`
Dest string `protobuf:"bytes,3,opt,name=dest,proto3" json:"dest,omitempty"`
OutboundTag string `protobuf:"bytes,4,opt,name=outbound_tag,json=outboundTag,proto3" json:"outbound_tag,omitempty"`
ServerIdentity []byte `protobuf:"bytes,5,opt,name=server_identity,json=serverIdentity,proto3" json:"server_identity,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ServerInverseRoleConfig) Reset() {
*x = ServerInverseRoleConfig{}
mi := &file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ServerInverseRoleConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ServerInverseRoleConfig) ProtoMessage() {}
func (x *ServerInverseRoleConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ServerInverseRoleConfig.ProtoReflect.Descriptor instead.
func (*ServerInverseRoleConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDescGZIP(), []int{1}
}
func (x *ServerInverseRoleConfig) GetRoundTripperClient() *anypb.Any {
if x != nil {
return x.RoundTripperClient
}
return nil
}
func (x *ServerInverseRoleConfig) GetSecurityConfig() *anypb.Any {
if x != nil {
return x.SecurityConfig
}
return nil
}
func (x *ServerInverseRoleConfig) GetDest() string {
if x != nil {
return x.Dest
}
return ""
}
func (x *ServerInverseRoleConfig) GetOutboundTag() string {
if x != nil {
return x.OutboundTag
}
return ""
}
func (x *ServerInverseRoleConfig) GetServerIdentity() []byte {
if x != nil {
return x.ServerIdentity
}
return nil
}
type ServerConfig struct {
state protoimpl.MessageState `protogen:"open.v1"`
RoundTripperServer *anypb.Any `protobuf:"bytes,2,opt,name=round_tripper_server,json=roundTripperServer,proto3" json:"round_tripper_server,omitempty"`
Listen string `protobuf:"bytes,3,opt,name=listen,proto3" json:"listen,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *ServerConfig) Reset() {
*x = ServerConfig{}
mi := &file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *ServerConfig) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ServerConfig) ProtoMessage() {}
func (x *ServerConfig) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ServerConfig.ProtoReflect.Descriptor instead.
func (*ServerConfig) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDescGZIP(), []int{2}
}
func (x *ServerConfig) GetRoundTripperServer() *anypb.Any {
if x != nil {
return x.RoundTripperServer
}
return nil
}
func (x *ServerConfig) GetListen() string {
if x != nil {
return x.Listen
}
return ""
}
var File_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto protoreflect.FileDescriptor
const file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDesc = "" +
"\n" +
"]transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/config.proto\x12[v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmation\x1a common/protoext/extensions.proto\x1a\x19google/protobuf/any.proto\"\xf5\x01\n" +
"\fClientConfig\x12F\n" +
"\x14round_tripper_client\x18\x01 \x01(\v2\x14.google.protobuf.AnyR\x12roundTripperClient\x12=\n" +
"\x0fsecurity_config\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x0esecurityConfig\x12\x12\n" +
"\x04dest\x18\x03 \x01(\tR\x04dest\x12!\n" +
"\foutbound_tag\x18\x04 \x01(\tR\voutboundTag\x12'\n" +
"\x0fserver_identity\x18\x05 \x01(\fR\x0eserverIdentity\"\x80\x02\n" +
"\x17ServerInverseRoleConfig\x12F\n" +
"\x14round_tripper_client\x18\x01 \x01(\v2\x14.google.protobuf.AnyR\x12roundTripperClient\x12=\n" +
"\x0fsecurity_config\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x0esecurityConfig\x12\x12\n" +
"\x04dest\x18\x03 \x01(\tR\x04dest\x12!\n" +
"\foutbound_tag\x18\x04 \x01(\tR\voutboundTag\x12'\n" +
"\x0fserver_identity\x18\x05 \x01(\fR\x0eserverIdentity\"n\n" +
"\fServerConfig\x12F\n" +
"\x14round_tripper_server\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x12roundTripperServer\x12\x16\n" +
"\x06listen\x18\x03 \x01(\tR\x06listenB\xb2\x02\n" +
"_com.v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmationP\x01Zogithub.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation\xaa\x02[V2Ray.Core.Transport.Internet.Tlsmirror.MirrorEnrollment.RoundTripperEnrollmentConfirmationb\x06proto3"
var (
file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDescOnce sync.Once
file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDescData []byte
)
func file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDescGZIP() []byte {
file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDescOnce.Do(func() {
file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDesc), len(file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDesc)))
})
return file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDescData
}
var file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
var file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_goTypes = []any{
(*ClientConfig)(nil), // 0: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmation.ClientConfig
(*ServerInverseRoleConfig)(nil), // 1: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmation.ServerInverseRoleConfig
(*ServerConfig)(nil), // 2: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmation.ServerConfig
(*anypb.Any)(nil), // 3: google.protobuf.Any
}
var file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_depIdxs = []int32{
3, // 0: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmation.ClientConfig.round_tripper_client:type_name -> google.protobuf.Any
3, // 1: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmation.ClientConfig.security_config:type_name -> google.protobuf.Any
3, // 2: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmation.ServerInverseRoleConfig.round_tripper_client:type_name -> google.protobuf.Any
3, // 3: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmation.ServerInverseRoleConfig.security_config:type_name -> google.protobuf.Any
3, // 4: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.roundtripperenrollmentconfirmation.ServerConfig.round_tripper_server:type_name -> google.protobuf.Any
5, // [5:5] is the sub-list for method output_type
5, // [5:5] is the sub-list for method input_type
5, // [5:5] is the sub-list for extension type_name
5, // [5:5] is the sub-list for extension extendee
0, // [0:5] is the sub-list for field type_name
}
func init() {
file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_init()
}
func file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_init() {
if File_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDesc), len(file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 3,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_goTypes,
DependencyIndexes: file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_depIdxs,
MessageInfos: file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_msgTypes,
}.Build()
File_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto = out.File
file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_goTypes = nil
file_transport_internet_tlsmirror_mirrorenrollment_roundtripperenrollmentconfirmation_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/rttconfirmation.go | transport/internet/tlsmirror/mirrorenrollment/roundtripperenrollmentconfirmation/rttconfirmation.go | package roundtripperenrollmentconfirmation
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/tlstrafficgen/errors.generated.go | transport/internet/tlsmirror/tlstrafficgen/errors.generated.go | package tlstrafficgen
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/tlstrafficgen/trafficgen.go | transport/internet/tlsmirror/tlstrafficgen/trafficgen.go | package tlstrafficgen
import (
"context"
cryptoRand "crypto/rand"
"io"
"math/big"
"net/http"
"net/url"
"time"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/transport/internet/security"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/httponconnection"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
type TrafficGenerator struct {
config *Config
ctx context.Context
destination net.Destination
tag string
}
func NewTrafficGenerator(ctx context.Context, config *Config, destination net.Destination, tag string) *TrafficGenerator {
return &TrafficGenerator{
ctx: ctx,
config: config,
destination: destination,
tag: tag,
}
}
type trafficGeneratorManagedConnectionController struct {
readyCtx context.Context
readyDone context.CancelFunc
recallCtx context.Context
recallDone context.CancelFunc
invalidatedCtx context.Context
invalidatedDone context.CancelFunc
}
func newTrafficGeneratorManagedConnectionController(parent context.Context) *trafficGeneratorManagedConnectionController {
readyCtx, readyDone := context.WithCancel(parent)
recallCtx, recallDone := context.WithCancel(parent)
invalidatedCtx, invalidatedDone := context.WithCancel(parent)
return &trafficGeneratorManagedConnectionController{
readyCtx: readyCtx,
readyDone: readyDone,
recallCtx: recallCtx,
recallDone: recallDone,
invalidatedCtx: invalidatedCtx,
invalidatedDone: invalidatedDone,
}
}
func (t *trafficGeneratorManagedConnectionController) WaitConnectionReady() context.Context {
return t.readyCtx
}
func (t *trafficGeneratorManagedConnectionController) RecallTrafficGenerator() error {
t.recallDone()
return nil
}
func (t *trafficGeneratorManagedConnectionController) IsConnectionInvalidated() bool {
return t.invalidatedCtx.Err() != nil
}
// Copied from https://brandur.org/fragments/crypto-rand-float64, Thanks
func randIntN(max int64) int64 {
nBig, err := cryptoRand.Int(cryptoRand.Reader, big.NewInt(max))
if err != nil {
panic(err)
}
return nBig.Int64()
}
func randFloat64() float64 {
return float64(randIntN(1<<53)) / (1 << 53)
}
func (generator *TrafficGenerator) GenerateNextTraffic(ctx context.Context) error {
transportEnvironment := envctx.EnvironmentFromContext(generator.ctx).(environment.TransportEnvironment)
dialer := transportEnvironment.OutboundDialer()
trafficController := newTrafficGeneratorManagedConnectionController(generator.ctx)
var trafficControllerIfce tlsmirror.TrafficGeneratorManagedConnection = trafficController
managedConnectionContextValue := context.WithValue(generator.ctx,
tlsmirror.TrafficGeneratorManagedConnectionContextKey, trafficControllerIfce) // nolint:staticcheck
defer func() {
trafficController.invalidatedDone()
trafficController.readyDone()
}()
conn, err := dialer(managedConnectionContextValue, generator.destination, generator.tag)
if err != nil {
return newError("failed to dial to destination").Base(err).AtWarning()
}
tlsConn, err := generator.tlsHandshake(conn)
if err != nil {
return newError("failed to create TLS connection").Base(err).AtWarning()
}
getAlpn, ok := tlsConn.(security.ConnectionApplicationProtocol)
if !ok {
return newError("TLS connection does not support getting ALPN").AtWarning()
}
alpn, err := getAlpn.GetConnectionApplicationProtocol()
if err != nil {
return newError("failed to get ALPN from TLS connection").Base(err).AtWarning()
}
steps := generator.config.Steps
currentStep := 0
httpRoundTripper, err := httponconnection.NewSingleConnectionHTTPTransport(tlsConn, alpn)
if err != nil {
return newError("failed to create HTTP transport").Base(err).AtWarning()
}
for {
if currentStep >= len(steps) {
return tlsConn.Close()
}
step := steps[currentStep]
url := url.URL{
Scheme: "https",
Host: step.Host,
Path: step.Path,
}
httpReq := &http.Request{Host: url.Hostname(), Method: step.Method, URL: &url}
if step.Headers != nil {
header := make(http.Header, len(step.Headers))
for _, v := range step.Headers {
if v.Value != "" {
header.Add(v.Name, v.Value)
}
if v.Values != nil {
for _, value := range v.Values {
header.Add(v.Name, value)
}
}
}
httpReq.Header = header
}
startTime := time.Now()
resp, err := httpRoundTripper.RoundTrip(httpReq) //nolint:bodyclose
if err != nil {
return newError("failed to send HTTP request").Base(err).AtWarning()
}
finishRequest := func() error {
_, err = io.Copy(io.Discard, resp.Body)
if err != nil {
return newError("failed to read HTTP response body").Base(err).AtWarning()
}
err = resp.Body.Close()
if err != nil {
return newError("failed to close HTTP response body").Base(err).AtWarning()
}
return nil
}
if step.H2DoNotWaitForDownloadFinish && alpn == "h2" {
go func() {
if err := finishRequest(); err != nil {
newError("failed to finish request in background").Base(err).AtWarning().WriteToLog()
}
}()
} else {
if err := finishRequest(); err != nil {
return err
}
}
endTime := time.Now()
eclipsedTime := endTime.Sub(startTime)
if step.WaitTime == nil {
step.WaitTime = &TimeSpec{}
newError("no wait time specified for step ", currentStep, ", using default 0 seconds").AtWarning().WriteToLog()
}
secondToWait := (float64(step.WaitTime.UniformRandomMultiplierNanoseconds)*randFloat64() + float64(step.WaitTime.BaseNanoseconds)) / float64(time.Second)
if eclipsedTime < time.Duration(secondToWait*float64(time.Second)) {
waitTime := time.Duration(secondToWait*float64(time.Second)) - eclipsedTime
newError("waiting for ", waitTime, " after step ", currentStep).AtDebug().WriteToLog()
waitTimer := time.NewTimer(waitTime)
select {
case <-ctx.Done():
waitTimer.Stop()
return ctx.Err()
case <-waitTimer.C:
}
} else {
newError("step ", currentStep, " took too long: ", eclipsedTime, ", expected: ", secondToWait, " seconds").AtWarning().WriteToLog()
}
if step.ConnectionReady {
trafficController.readyDone()
newError("connection ready for payload traffic").AtInfo().WriteToLog()
}
if step.ConnectionRecallExit {
if trafficController.recallCtx.Err() != nil {
return tlsConn.Close()
}
}
if step.NextStep == nil {
currentStep++
} else {
overallWeight := int32(0)
for _, nextStep := range step.NextStep {
overallWeight += nextStep.Weight
}
maxBound := big.NewInt(int64(overallWeight))
selectionValue, err := cryptoRand.Int(cryptoRand.Reader, maxBound)
if err != nil {
return newError("failed to generate random selection value").Base(err).AtWarning()
}
selectedValue := int32(selectionValue.Int64())
currentValue := int32(0)
matched := false
for _, nextStep := range step.NextStep {
if currentValue >= selectedValue {
currentStep = int(nextStep.GotoLocation)
matched = true
break
}
currentValue += nextStep.Weight
}
if !matched {
newError("invalid steps jump instruction, check configuration for step ", currentStep).AtError().WriteToLog()
currentStep++
}
}
}
}
func (generator *TrafficGenerator) tlsHandshake(conn net.Conn) (security.Conn, error) {
securitySettingInstance, err := serial.GetInstanceOf(generator.config.SecuritySettings)
if err != nil {
return nil, newError("failed to get instance of security settings").Base(err)
}
securityEngine, err := common.CreateObject(generator.ctx, securitySettingInstance)
if err != nil {
return nil, newError("unable to create security engine from security settings").Base(err)
}
securityEngineTyped, ok := securityEngine.(security.Engine)
if !ok {
return nil, newError("type assertion error when create security engine from security settings")
}
return securityEngineTyped.Client(conn)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/tlstrafficgen/config.pb.go | transport/internet/tlsmirror/tlstrafficgen/config.pb.go | package tlstrafficgen
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
anypb "google.golang.org/protobuf/types/known/anypb"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type TimeSpec struct {
state protoimpl.MessageState `protogen:"open.v1"`
BaseNanoseconds uint64 `protobuf:"varint,1,opt,name=base_nanoseconds,json=baseNanoseconds,proto3" json:"base_nanoseconds,omitempty"`
UniformRandomMultiplierNanoseconds uint64 `protobuf:"varint,2,opt,name=uniform_random_multiplier_nanoseconds,json=uniformRandomMultiplierNanoseconds,proto3" json:"uniform_random_multiplier_nanoseconds,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TimeSpec) Reset() {
*x = TimeSpec{}
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TimeSpec) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TimeSpec) ProtoMessage() {}
func (x *TimeSpec) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TimeSpec.ProtoReflect.Descriptor instead.
func (*TimeSpec) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescGZIP(), []int{0}
}
func (x *TimeSpec) GetBaseNanoseconds() uint64 {
if x != nil {
return x.BaseNanoseconds
}
return 0
}
func (x *TimeSpec) GetUniformRandomMultiplierNanoseconds() uint64 {
if x != nil {
return x.UniformRandomMultiplierNanoseconds
}
return 0
}
type Header struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
Values []string `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Header) Reset() {
*x = Header{}
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Header) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Header) ProtoMessage() {}
func (x *Header) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Header.ProtoReflect.Descriptor instead.
func (*Header) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescGZIP(), []int{1}
}
func (x *Header) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Header) GetValue() string {
if x != nil {
return x.Value
}
return ""
}
func (x *Header) GetValues() []string {
if x != nil {
return x.Values
}
return nil
}
type TransferCandidate struct {
state protoimpl.MessageState `protogen:"open.v1"`
Weight int32 `protobuf:"varint,1,opt,name=weight,proto3" json:"weight,omitempty"`
GotoLocation int64 `protobuf:"varint,2,opt,name=goto_location,json=gotoLocation,proto3" json:"goto_location,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TransferCandidate) Reset() {
*x = TransferCandidate{}
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TransferCandidate) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TransferCandidate) ProtoMessage() {}
func (x *TransferCandidate) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TransferCandidate.ProtoReflect.Descriptor instead.
func (*TransferCandidate) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescGZIP(), []int{2}
}
func (x *TransferCandidate) GetWeight() int32 {
if x != nil {
return x.Weight
}
return 0
}
func (x *TransferCandidate) GetGotoLocation() int64 {
if x != nil {
return x.GotoLocation
}
return 0
}
type Step struct {
state protoimpl.MessageState `protogen:"open.v1"`
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Host string `protobuf:"bytes,8,opt,name=host,proto3" json:"host,omitempty"`
Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
Method string `protobuf:"bytes,3,opt,name=method,proto3" json:"method,omitempty"`
NextStep []*TransferCandidate `protobuf:"bytes,6,rep,name=next_step,json=nextStep,proto3" json:"next_step,omitempty"`
ConnectionReady bool `protobuf:"varint,7,opt,name=connection_ready,json=connectionReady,proto3" json:"connection_ready,omitempty"`
Headers []*Header `protobuf:"bytes,9,rep,name=headers,proto3" json:"headers,omitempty"`
ConnectionRecallExit bool `protobuf:"varint,10,opt,name=connection_recall_exit,json=connectionRecallExit,proto3" json:"connection_recall_exit,omitempty"`
WaitTime *TimeSpec `protobuf:"bytes,11,opt,name=wait_time,json=waitTime,proto3" json:"wait_time,omitempty"`
H2DoNotWaitForDownloadFinish bool `protobuf:"varint,12,opt,name=h2_do_not_wait_for_download_finish,json=h2DoNotWaitForDownloadFinish,proto3" json:"h2_do_not_wait_for_download_finish,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Step) Reset() {
*x = Step{}
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Step) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Step) ProtoMessage() {}
func (x *Step) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[3]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Step.ProtoReflect.Descriptor instead.
func (*Step) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescGZIP(), []int{3}
}
func (x *Step) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Step) GetHost() string {
if x != nil {
return x.Host
}
return ""
}
func (x *Step) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
func (x *Step) GetMethod() string {
if x != nil {
return x.Method
}
return ""
}
func (x *Step) GetNextStep() []*TransferCandidate {
if x != nil {
return x.NextStep
}
return nil
}
func (x *Step) GetConnectionReady() bool {
if x != nil {
return x.ConnectionReady
}
return false
}
func (x *Step) GetHeaders() []*Header {
if x != nil {
return x.Headers
}
return nil
}
func (x *Step) GetConnectionRecallExit() bool {
if x != nil {
return x.ConnectionRecallExit
}
return false
}
func (x *Step) GetWaitTime() *TimeSpec {
if x != nil {
return x.WaitTime
}
return nil
}
func (x *Step) GetH2DoNotWaitForDownloadFinish() bool {
if x != nil {
return x.H2DoNotWaitForDownloadFinish
}
return false
}
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
Steps []*Step `protobuf:"bytes,1,rep,name=steps,proto3" json:"steps,omitempty"`
SecuritySettings *anypb.Any `protobuf:"bytes,2,opt,name=security_settings,json=securitySettings,proto3" json:"security_settings,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes[4]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescGZIP(), []int{4}
}
func (x *Config) GetSteps() []*Step {
if x != nil {
return x.Steps
}
return nil
}
func (x *Config) GetSecuritySettings() *anypb.Any {
if x != nil {
return x.SecuritySettings
}
return nil
}
var File_transport_internet_tlsmirror_tlstrafficgen_config_proto protoreflect.FileDescriptor
const file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDesc = "" +
"\n" +
"7transport/internet/tlsmirror/tlstrafficgen/config.proto\x125v2ray.core.transport.internet.tlsmirror.tlstrafficgen\x1a\x19google/protobuf/any.proto\"\x88\x01\n" +
"\bTimeSpec\x12)\n" +
"\x10base_nanoseconds\x18\x01 \x01(\x04R\x0fbaseNanoseconds\x12Q\n" +
"%uniform_random_multiplier_nanoseconds\x18\x02 \x01(\x04R\"uniformRandomMultiplierNanoseconds\"J\n" +
"\x06Header\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value\x12\x16\n" +
"\x06values\x18\x03 \x03(\tR\x06values\"P\n" +
"\x11TransferCandidate\x12\x16\n" +
"\x06weight\x18\x01 \x01(\x05R\x06weight\x12#\n" +
"\rgoto_location\x18\x02 \x01(\x03R\fgotoLocation\"\xa3\x04\n" +
"\x04Step\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n" +
"\x04host\x18\b \x01(\tR\x04host\x12\x12\n" +
"\x04path\x18\x02 \x01(\tR\x04path\x12\x16\n" +
"\x06method\x18\x03 \x01(\tR\x06method\x12e\n" +
"\tnext_step\x18\x06 \x03(\v2H.v2ray.core.transport.internet.tlsmirror.tlstrafficgen.TransferCandidateR\bnextStep\x12)\n" +
"\x10connection_ready\x18\a \x01(\bR\x0fconnectionReady\x12W\n" +
"\aheaders\x18\t \x03(\v2=.v2ray.core.transport.internet.tlsmirror.tlstrafficgen.HeaderR\aheaders\x124\n" +
"\x16connection_recall_exit\x18\n" +
" \x01(\bR\x14connectionRecallExit\x12\\\n" +
"\twait_time\x18\v \x01(\v2?.v2ray.core.transport.internet.tlsmirror.tlstrafficgen.TimeSpecR\bwaitTime\x12H\n" +
"\"h2_do_not_wait_for_download_finish\x18\f \x01(\bR\x1ch2DoNotWaitForDownloadFinish\"\x9e\x01\n" +
"\x06Config\x12Q\n" +
"\x05steps\x18\x01 \x03(\v2;.v2ray.core.transport.internet.tlsmirror.tlstrafficgen.StepR\x05steps\x12A\n" +
"\x11security_settings\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x10securitySettingsB\xc0\x01\n" +
"9com.v2ray.core.transport.internet.tlsmirror.tlstrafficgenP\x01ZIgithub.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/tlstrafficgen\xaa\x025V2Ray.Core.Transport.Internet.Tlsmirror.Tlstrafficgenb\x06proto3"
var (
file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescOnce sync.Once
file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescData []byte
)
func file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescGZIP() []byte {
file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescOnce.Do(func() {
file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDesc), len(file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDesc)))
})
return file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDescData
}
var file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
var file_transport_internet_tlsmirror_tlstrafficgen_config_proto_goTypes = []any{
(*TimeSpec)(nil), // 0: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.TimeSpec
(*Header)(nil), // 1: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Header
(*TransferCandidate)(nil), // 2: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.TransferCandidate
(*Step)(nil), // 3: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Step
(*Config)(nil), // 4: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Config
(*anypb.Any)(nil), // 5: google.protobuf.Any
}
var file_transport_internet_tlsmirror_tlstrafficgen_config_proto_depIdxs = []int32{
2, // 0: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Step.next_step:type_name -> v2ray.core.transport.internet.tlsmirror.tlstrafficgen.TransferCandidate
1, // 1: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Step.headers:type_name -> v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Header
0, // 2: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Step.wait_time:type_name -> v2ray.core.transport.internet.tlsmirror.tlstrafficgen.TimeSpec
3, // 3: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Config.steps:type_name -> v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Step
5, // 4: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Config.security_settings:type_name -> google.protobuf.Any
5, // [5:5] is the sub-list for method output_type
5, // [5:5] is the sub-list for method input_type
5, // [5:5] is the sub-list for extension type_name
5, // [5:5] is the sub-list for extension extendee
0, // [0:5] is the sub-list for field type_name
}
func init() { file_transport_internet_tlsmirror_tlstrafficgen_config_proto_init() }
func file_transport_internet_tlsmirror_tlstrafficgen_config_proto_init() {
if File_transport_internet_tlsmirror_tlstrafficgen_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDesc), len(file_transport_internet_tlsmirror_tlstrafficgen_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 5,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_tlsmirror_tlstrafficgen_config_proto_goTypes,
DependencyIndexes: file_transport_internet_tlsmirror_tlstrafficgen_config_proto_depIdxs,
MessageInfos: file_transport_internet_tlsmirror_tlstrafficgen_config_proto_msgTypes,
}.Build()
File_transport_internet_tlsmirror_tlstrafficgen_config_proto = out.File
file_transport_internet_tlsmirror_tlstrafficgen_config_proto_goTypes = nil
file_transport_internet_tlsmirror_tlstrafficgen_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcommon/record.go | transport/internet/tlsmirror/mirrorcommon/record.go | package mirrorcommon
import (
"fmt"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
)
// PeekTLSRecord reads a TLS record from peeker.
// It returns the record, the number of bytes read from peeker, and any error encountered.
// It does not consume content from peeker, and the content peeked is borrowed from peeker.
func PeekTLSRecord(peeker tlsmirror.Peeker, rejectionProfile tlsmirror.PartialTLSRecordRejectProfile) (result tlsmirror.TLSRecord, tryAgainLength, processed int, err error) {
var record tlsmirror.TLSRecord
header, err := peeker.Peek(5)
if err != nil {
return record, 0, 0, err
}
if len(header) < 5 {
return record, 5, 0, fmt.Errorf("tls: record header too short")
}
record.RecordType = header[0]
record.LegacyProtocolVersion[0] = header[1]
record.LegacyProtocolVersion[1] = header[2]
record.RecordLength = uint16(header[3])<<8 | uint16(header[4])
if record.RecordLength > 16384 {
return record, 0, 0, fmt.Errorf("tls: record length %d is too large", record.RecordLength)
}
if rejectionProfile != nil {
err = rejectionProfile.TestIfReject(&record, 2)
if err != nil {
return record, 0, 0, err
}
}
fragment, err := peeker.Peek(int(5 + record.RecordLength))
if err != nil {
return record, int(5 + record.RecordLength), 0, err
}
if len(fragment) < 5+int(record.RecordLength) {
return record, int(5 + record.RecordLength), 0, fmt.Errorf("tls: record fragment too short")
}
record.Fragment = fragment[5:]
return record, 0, int(5 + record.RecordLength), nil
}
func PackTLSRecord(record tlsmirror.TLSRecord) []byte {
buf := make([]byte, 5+len(record.Fragment))
buf[0] = record.RecordType
buf[1] = record.LegacyProtocolVersion[0]
buf[2] = record.LegacyProtocolVersion[1]
buf[3] = byte(record.RecordLength >> 8)
buf[4] = byte(record.RecordLength)
copy(buf[5:], record.Fragment)
return buf
}
func DuplicateRecord(record tlsmirror.TLSRecord) tlsmirror.TLSRecord {
newRecord := record
newRecord.Fragment = make([]byte, len(record.Fragment))
copy(newRecord.Fragment, record.Fragment)
return newRecord
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcommon/loopback_protect.go | transport/internet/tlsmirror/mirrorcommon/loopback_protect.go | package mirrorcommon
import (
"context"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
)
func SetLoopbackProtectionFlagForContext(ctx context.Context, enrollmentID []byte) context.Context {
loopbackProtectionKey := tlsmirror.ConnectionLoopbackPrevention{Key: string(enrollmentID)}
return context.WithValue(ctx, loopbackProtectionKey, true)
}
func SetSecondaryLoopbackProtectionFlagForContext(ctx context.Context, enrollmentID []byte) context.Context {
loopbackProtectionKey := tlsmirror.ConnectionLoopbackPrevention{Key: string(enrollmentID)}
return context.WithValue(ctx, loopbackProtectionKey, false)
}
func IsLoopbackProtectionEnabled(ctx context.Context, enrollmentID []byte) bool {
loopbackProtectionKey := tlsmirror.ConnectionLoopbackPrevention{Key: string(enrollmentID)}
val := ctx.Value(loopbackProtectionKey)
enabled, ok := val.(bool)
return ok && enabled
}
func IsSecondaryLoopbackProtectionEnabled(ctx context.Context, enrollmentID []byte) bool {
loopbackProtectionKey := tlsmirror.ConnectionLoopbackPrevention{Key: string(enrollmentID)}
val := ctx.Value(loopbackProtectionKey)
enabled, ok := val.(bool)
return ok && !enabled
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcommon/handshake.go | transport/internet/tlsmirror/mirrorcommon/handshake.go | package mirrorcommon
import (
"bytes"
"github.com/v2fly/struc"
)
type TLSClientHello struct {
HandshakeType uint8
Length [3]byte
Version uint16
ClientRandom [32]byte
// There are other entries, however we do not need them yet
}
func UnpackTLSClientHello(data []byte) (TLSClientHello, error) {
var clientHello TLSClientHello
err := struc.Unpack(bytes.NewReader(data), &clientHello)
return clientHello, err
}
type TLSServerHello struct {
HandshakeType uint8
Length [3]byte
Version uint16
ServerRandom [32]byte
SessionIDLength uint8 `struc:"sizeof=SessionID"`
SessionID []byte
CipherSuite uint16
// There are other entries, however we do not need them yet
}
func UnpackTLSServerHello(data []byte) (TLSServerHello, error) {
var serverHello TLSServerHello
err := struc.Unpack(bytes.NewReader(data), &serverHello)
return serverHello, err
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcommon/recordstream.go | transport/internet/tlsmirror/mirrorcommon/recordstream.go | package mirrorcommon
import (
"bufio"
"errors"
"io"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
)
func NewTLSRecordStreamReader(reader *bufio.Reader) *TLSRecordStreamReader {
return &TLSRecordStreamReader{bufferedReader: reader}
}
type TLSRecordStreamReader struct {
bufferedReader *bufio.Reader
consumedSize int64
}
func (t *TLSRecordStreamReader) ReadNextRecord() (*tlsmirror.TLSRecord, error) {
record, tryAgainLength, processedLength, err := PeekTLSRecord(t.bufferedReader, nil)
if err == nil {
_, err := t.bufferedReader.Discard(processedLength)
t.consumedSize += int64(processedLength)
if err != nil {
return nil, err
}
return &record, nil
}
if errors.Is(err, io.EOF) {
return nil, err
} else { // nolint: gocritic
if tryAgainLength == 0 {
return nil, err
}
}
if tryAgainLength > 0 {
_, err := t.bufferedReader.Read(make([]byte, tryAgainLength))
if err != nil {
return nil, err
}
err = t.bufferedReader.UnreadByte()
if err != nil {
return nil, err
}
}
return t.ReadNextRecord()
}
func (t *TLSRecordStreamReader) GetConsumedSize() int64 {
return t.consumedSize
}
func NewTLSRecordStreamWriter(writer *bufio.Writer) *TLSRecordStreamWriter {
return &TLSRecordStreamWriter{bufferedWriter: writer}
}
type TLSRecordStreamWriter struct {
bufferedWriter *bufio.Writer
}
func (t *TLSRecordStreamWriter) WriteRecord(record *tlsmirror.TLSRecord, holdFlush bool) error {
_, err := t.bufferedWriter.Write(PackTLSRecord(*record))
if err != nil {
return err
}
if holdFlush {
return nil
}
return t.bufferedWriter.Flush()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcommon/record_consts.go | transport/internet/tlsmirror/mirrorcommon/record_consts.go | package mirrorcommon
const (
TLSRecord_RecordType_application_data = 23
TLSRecord_RecordType_handshake = 22
TLSRecord_RecordType_change_cipher_spec = 20
TLSRecord_RecordType_alert = 21
)
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/httponconnection/errors.generated.go | transport/internet/tlsmirror/httponconnection/errors.generated.go | package httponconnection
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/httponconnection/singleconnhttp.go | transport/internet/tlsmirror/httponconnection/singleconnhttp.go | package httponconnection
import (
"bufio"
"net"
"net/http"
"golang.org/x/net/http2"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
type HttpRequestTransport interface {
http.RoundTripper
}
func newHTTPRequestTransportH1(conn net.Conn) HttpRequestTransport {
return &httpRequestTransportH1{
conn: conn,
bufReader: bufio.NewReader(conn),
}
}
type httpRequestTransportH1 struct {
conn net.Conn
bufReader *bufio.Reader
}
func (h *httpRequestTransportH1) RoundTrip(req *http.Request) (*http.Response, error) {
req.Proto = "HTTP/1.1"
req.ProtoMajor = 1
req.ProtoMinor = 1
err := req.Write(h.conn)
if err != nil {
return nil, err
}
return http.ReadResponse(h.bufReader, req)
}
func newHTTPRequestTransportH2(conn net.Conn) HttpRequestTransport {
transport := &http2.Transport{}
clientConn, err := transport.NewClientConn(conn)
if err != nil {
return nil
}
return &httpRequestTransportH2{
transport: transport,
clientConnection: clientConn,
}
}
type httpRequestTransportH2 struct {
transport *http2.Transport
clientConnection *http2.ClientConn
}
func (h *httpRequestTransportH2) RoundTrip(request *http.Request) (*http.Response, error) {
request.ProtoMajor = 2
request.ProtoMinor = 0
response, err := h.clientConnection.RoundTrip(request)
if err != nil {
return nil, err
}
return response, nil
}
func newSingleConnectionHTTPTransport(conn net.Conn, alpn string) (HttpRequestTransport, error) {
switch alpn {
case "h2":
return newHTTPRequestTransportH2(conn), nil
case "http/1.1", "":
return newHTTPRequestTransportH1(conn), nil
default:
return nil, newError("unknown alpn: " + alpn).AtWarning()
}
}
func NewSingleConnectionHTTPTransport(conn net.Conn, alpn string) (HttpRequestTransport, error) {
return newSingleConnectionHTTPTransport(conn, alpn)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcrypto/decryptor.go | transport/internet/tlsmirror/mirrorcrypto/decryptor.go | package mirrorcrypto
import (
"crypto/cipher"
"github.com/v2fly/v2ray-core/v5/common/crypto"
)
type Decryptor struct {
nonceGenerator crypto.BytesGenerator
aead cipher.AEAD
nextNonce []byte
}
func NewDecryptor(encryptionKey []byte, nonceMask []byte) *Decryptor {
wrappedAead := aeadAESGCMTLS13(encryptionKey, nonceMask)
return &Decryptor{
nonceGenerator: generateInitialAEADNonce(),
aead: wrappedAead,
}
}
func (d *Decryptor) Open(dst, src []byte) ([]byte, error) {
if d.nextNonce == nil {
d.nextNonce = d.nonceGenerator()
}
dst, err := d.aead.Open(dst[:0], d.nextNonce, src, nil)
if err != nil {
return nil, err
}
d.nextNonce = nil
return dst, nil
}
func (d *Decryptor) NonceSize() int {
return d.aead.NonceSize()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcrypto/errors.generated.go | transport/internet/tlsmirror/mirrorcrypto/errors.generated.go | package mirrorcrypto
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcrypto/tls_cipher_suites_linkname.go | transport/internet/tlsmirror/mirrorcrypto/tls_cipher_suites_linkname.go | package mirrorcrypto
import (
"crypto/cipher"
_ "unsafe"
)
// This linkname is necessary to avoid duplicating too many internal packages.
//go:linkname aeadAESGCMTLS13 crypto/tls.aeadAESGCMTLS13
func aeadAESGCMTLS13(key, nonceMask []byte) cipher.AEAD
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcrypto/tls_cipher_suites.go | transport/internet/tlsmirror/mirrorcrypto/tls_cipher_suites.go | package mirrorcrypto
import (
"crypto/cipher"
"golang.org/x/crypto/chacha20poly1305"
)
const (
aeadNonceLength = 12
)
type aead interface {
cipher.AEAD
// explicitNonceLen returns the number of bytes of explicit nonce
// included in each record. This is eight for older AEADs and
// zero for modern ones.
explicitNonceLen() int
}
// xorNonceAEAD wraps an AEAD by XORing in a fixed pattern to the nonce
// before each call.
type xorNonceAEAD struct {
nonceMask [aeadNonceLength]byte
aead cipher.AEAD
}
func (f *xorNonceAEAD) NonceSize() int { return 8 } // 64-bit sequence number
func (f *xorNonceAEAD) Overhead() int { return f.aead.Overhead() }
func (f *xorNonceAEAD) explicitNonceLen() int { return 0 }
func (f *xorNonceAEAD) Seal(out, nonce, plaintext, additionalData []byte) []byte {
for i, b := range nonce {
f.nonceMask[4+i] ^= b
}
result := f.aead.Seal(out, f.nonceMask[:], plaintext, additionalData)
for i, b := range nonce {
f.nonceMask[4+i] ^= b
}
return result
}
func (f *xorNonceAEAD) Open(out, nonce, ciphertext, additionalData []byte) ([]byte, error) {
for i, b := range nonce {
f.nonceMask[4+i] ^= b
}
result, err := f.aead.Open(out, f.nonceMask[:], ciphertext, additionalData)
for i, b := range nonce {
f.nonceMask[4+i] ^= b
}
return result, err
}
func aeadChaCha20Poly1305(key, nonceMask []byte) aead {
if len(nonceMask) != aeadNonceLength {
panic("tls: internal error: wrong nonce length")
}
aead, err := chacha20poly1305.New(key)
if err != nil {
panic(err)
}
ret := &xorNonceAEAD{aead: aead}
copy(ret.nonceMask[:], nonceMask)
return ret
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcrypto/derive_key.go | transport/internet/tlsmirror/mirrorcrypto/derive_key.go | package mirrorcrypto
import (
"crypto/hkdf"
"crypto/sha256"
)
func DeriveEncryptionKey(primaryKey, clientRandom, serverRandom []byte, tag string) ([]byte, []byte, error) {
if len(primaryKey) != 32 {
return nil, nil, newError("invalid primary key size: ", len(primaryKey))
}
if len(clientRandom) != 32 {
return nil, nil, newError("invalid client random size: ", len(clientRandom))
}
if len(serverRandom) != 32 {
return nil, nil, newError("invalid server random size: ", len(serverRandom))
}
// Concatenate the primary key, client random, and server random
combined := append(primaryKey, clientRandom...) // nolint: gocritic
combined = append(combined, serverRandom...)
encryptionKey, err := hkdf.Expand(sha256.New, combined, "v2ray-sp76YMKM-EkGrFUNL-rTJRJMkU:tlsmirror-encryption"+tag, 16)
if err != nil {
return nil, nil, newError("unable to derive encryption key").Base(err)
}
nonceMask, err := hkdf.Expand(sha256.New, combined, "v2ray-sp76YMKM-EkGrFUNL-rTJRJMkU:tlsmirror-noncemask"+tag, 12)
if err != nil {
return nil, nil, newError("unable to derive nonce mask").Base(err)
}
return encryptionKey, nonceMask, nil
}
func DeriveSecondaryKey(primaryKey []byte, tag string) ([]byte, error) {
if len(primaryKey) != 32 {
return nil, newError("invalid primary key size: ", len(primaryKey))
}
// Use HKDF to derive a secondary key
secondaryKey, err := hkdf.Expand(sha256.New, primaryKey, "v2ray-sv77RCEY-e8AhYsbD-BmFC7XRK:tlsmirror-secondary"+tag, 16)
if err != nil {
return nil, newError("unable to derive secondary key").Base(err)
}
return secondaryKey, nil
}
func DeriveSequenceWatermarkingKey(primaryKey, clientRandom, serverRandom []byte, tag string) ([]byte, []byte, error) {
if len(primaryKey) != 32 {
return nil, nil, newError("invalid primary key size: ", len(primaryKey))
}
if len(clientRandom) != 32 {
return nil, nil, newError("invalid client random size: ", len(clientRandom))
}
if len(serverRandom) != 32 {
return nil, nil, newError("invalid server random size: ", len(serverRandom))
}
// Concatenate the primary key, client random, and server random
combined := append(primaryKey, clientRandom...) // nolint: gocritic
combined = append(combined, serverRandom...)
encryptionKey, err := hkdf.Expand(sha256.New, combined, "v2ray-xv64FXUU-GxMn8UYz-bTy6UDeE:tlsmirror-sequence-watermark-encryption"+tag, 32)
if err != nil {
return nil, nil, newError("unable to derive encryption key").Base(err)
}
nonceMask, err := hkdf.Expand(sha256.New, combined, "v2ray-xv64FXUU-GxMn8UYz-bTy6UDeE:tlsmirror-sequence-watermark-noncemask"+tag, 24)
if err != nil {
return nil, nil, newError("unable to derive nonce mask").Base(err)
}
return encryptionKey, nonceMask, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcrypto/mirrorcrypto.go | transport/internet/tlsmirror/mirrorcrypto/mirrorcrypto.go | package mirrorcrypto
import "github.com/v2fly/v2ray-core/v5/common/crypto"
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
func generateInitialAEADNonce() crypto.BytesGenerator {
return crypto.GenerateIncreasingNonce([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorcrypto/encrypter.go | transport/internet/tlsmirror/mirrorcrypto/encrypter.go | package mirrorcrypto
import (
"crypto/cipher"
"github.com/v2fly/v2ray-core/v5/common/crypto"
)
type Encryptor struct {
nonceGenerator crypto.BytesGenerator
aead cipher.AEAD
}
func NewEncryptor(encryptionKey []byte, nonceMask []byte) *Encryptor {
wrappedAead := aeadAESGCMTLS13(encryptionKey, nonceMask)
return &Encryptor{
nonceGenerator: generateInitialAEADNonce(),
aead: wrappedAead,
}
}
func (e *Encryptor) Seal(dst, src []byte) ([]byte, error) {
nonce := e.nonceGenerator()
dst = e.aead.Seal(dst, nonce, src, nil)
return dst, nil
}
func (e *Encryptor) NonceSize() int {
return e.aead.NonceSize()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/hub.go | transport/internet/tlsmirror/server/hub.go | package server
import (
"context"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/transportcommon"
)
func ListenTLSMirror(ctx context.Context, address net.Address, port net.Port,
streamSettings *internet.MemoryStreamConfig, handler internet.ConnHandler,
) (internet.Listener, error) {
tlsMirrorSettings := streamSettings.ProtocolSettings.(*Config)
listener, err := transportcommon.ListenWithSecuritySettings(ctx, address, port, streamSettings)
if err != nil {
return nil, newError("failed to listen TLS mirror").Base(err)
}
tlsMirrorServer, err := NewServer(ctx, listener, tlsMirrorSettings, handler)
if err != nil {
return nil, newError("failed to create TLS mirror server").Base(err)
}
go tlsMirrorServer.accepts()
return tlsMirrorServer, nil
}
const protocolName = "tlsmirror"
func init() {
common.Must(internet.RegisterTransportListener(protocolName, ListenTLSMirror))
}
func init() {
common.Must(internet.RegisterProtocolConfigCreator(protocolName, func() interface{} {
return new(Config)
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/errors.generated.go | transport/internet/tlsmirror/server/errors.generated.go | package server
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/client.go | transport/internet/tlsmirror/server/client.go | package server
import (
"context"
cryptoRand "crypto/rand"
"math/big"
"time"
"github.com/golang/protobuf/proto"
core "github.com/v2fly/v2ray-core/v5"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
"github.com/v2fly/v2ray-core/v5/features/outbound"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorbase"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorcommon"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorenrollment"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/tlstrafficgen"
)
func newPersistentMirrorTLSDialer(ctx context.Context, config *Config, serverAddress net.Destination, overrideSecuritySetting proto.Message) (*persistentMirrorTLSDialer, error) {
persistentDialer := &persistentMirrorTLSDialer{
ctx: ctx,
serverAddress: serverAddress,
overridingSecuritySettings: overrideSecuritySetting,
}
err := persistentDialer.init(ctx, config)
if err != nil {
return nil, newError("failed to initialize persistent mirror TLS dialer").Base(err)
}
return persistentDialer, nil
}
type persistentMirrorTLSDialer struct {
ctx context.Context
config *Config
requestNewConnection func(ctx context.Context) error
incomingConnections chan net.Conn
listener *OutboundListener
outbound *Outbound
serverAddress net.Destination
overridingSecuritySettings proto.Message
trafficGenerator *tlstrafficgen.TrafficGenerator
obm outbound.Manager
explicitNonceCiphersuiteLookup *ciphersuiteLookuper
enrollmentConfirmationClient *mirrorenrollment.EnrollmentConfirmationClient
enrollmentServerIdentifier []byte
}
func (d *persistentMirrorTLSDialer) init(ctx context.Context, config *Config) error {
if err := core.RequireFeatures(ctx, func(om outbound.Manager) {
d.obm = om
}); err != nil {
return err
}
d.requestNewConnection = func(ctx context.Context) error {
return nil
}
d.ctx = ctx
d.config = config
d.incomingConnections = make(chan net.Conn, 4)
d.listener = NewOutboundListener()
d.outbound = NewOutbound(d.config.CarrierConnectionTag, d.listener)
if len(d.config.ExplicitNonceCiphersuites) > 0 {
var err error
d.explicitNonceCiphersuiteLookup, err = newCipherSuiteLookuperFromUint32Array(d.config.ExplicitNonceCiphersuites)
if err != nil {
return newError("failed to create explicit nonce ciphersuite lookuper").Base(err)
}
} else {
d.explicitNonceCiphersuiteLookup = newEmptyCipherSuiteLookuper()
newError("no explicit nonce ciphersuites configured, all ciphersuites will be treated as non-explicit nonce").AtWarning().WriteToLog()
}
go func() {
err := d.outbound.Start()
if err != nil {
newError("failed to start outbound listener").Base(err).AtWarning().WriteToLog()
return
}
if err := d.obm.RemoveHandler(context.Background(), d.config.CarrierConnectionTag); err != nil {
newError("failed to remove existing handler").WriteToLog()
}
err = d.obm.AddHandler(context.Background(), d.outbound)
if err != nil {
newError("failed to add outbound handler").Base(err).AtWarning().WriteToLog()
return
}
for {
var ctx context.Context
conn, err := d.listener.Accept()
if err != nil {
break
}
if ctxGetter, ok := conn.(connectionContextGetter); ok {
ctx = ctxGetter.GetConnectionContext()
} else {
ctx = d.ctx
newError("connection does not implement connectionContextGetter, using default context").AtError().WriteToLog()
}
d.handleIncomingCarrierConnection(ctx, conn)
}
}()
if d.config.EmbeddedTrafficGenerator != nil {
if d.overridingSecuritySettings != nil && d.config.EmbeddedTrafficGenerator.SecuritySettings == nil {
d.config.EmbeddedTrafficGenerator.SecuritySettings = serial.ToTypedMessage(d.overridingSecuritySettings)
}
d.trafficGenerator = tlstrafficgen.NewTrafficGenerator(d.ctx, d.config.EmbeddedTrafficGenerator,
d.serverAddress, d.config.CarrierConnectionTag)
d.requestNewConnection = func(ctx context.Context) error {
go func() {
err := d.trafficGenerator.GenerateNextTraffic(d.ctx)
if err != nil {
newError("failed to generate next traffic").Base(err).AtWarning().WriteToLog()
} else {
newError("traffic generation request sent").AtDebug().WriteToLog()
}
}()
return nil
}
}
if d.config.ConnectionEnrolment != nil {
enrollmentServerIdentifier, err := mirrorenrollment.DeriveEnrollmentServerIdentifier(d.config.PrimaryKey)
if err != nil {
return newError("failed to derive enrollment server identifier").Base(err).AtError()
}
d.enrollmentServerIdentifier = enrollmentServerIdentifier
d.enrollmentConfirmationClient, err = mirrorenrollment.NewEnrollmentConfirmationClient(d.ctx, d.config.ConnectionEnrolment, enrollmentServerIdentifier)
if err != nil {
return newError("failed to create enrollment confirmation client").Base(err).AtError()
}
}
return nil
}
func (d *persistentMirrorTLSDialer) handleIncomingCarrierConnection(ctx context.Context, conn net.Conn) {
transportEnvironment := envctx.EnvironmentFromContext(d.ctx).(environment.TransportEnvironment)
dialer := transportEnvironment.OutboundDialer()
forwardConn, err := dialer(d.ctx, d.serverAddress, d.config.ForwardTag)
if err != nil {
newError("failed to dial to destination").Base(err).AtWarning().WriteToLog()
return
}
var firstWriteDelay time.Duration
if d.config.DeferInstanceDerivedWriteTime != nil {
firstWriteDelay = time.Duration(d.config.DeferInstanceDerivedWriteTime.BaseNanoseconds)
if d.config.DeferInstanceDerivedWriteTime.UniformRandomMultiplierNanoseconds > 0 {
uniformRandomAdd := big.NewInt(int64(d.config.DeferInstanceDerivedWriteTime.UniformRandomMultiplierNanoseconds))
uniformRandomAddBigInt, err := cryptoRand.Int(cryptoRand.Reader, uniformRandomAdd)
if err != nil {
newError("failed to generate random delay").Base(err).AtWarning().WriteToLog()
return
}
uniformRandomAddU64 := uint64(uniformRandomAddBigInt.Int64())
firstWriteDelay += time.Duration(uniformRandomAddU64)
}
}
ctx, cancel := context.WithCancel(ctx)
cconnState := &clientConnState{
ctx: ctx,
done: cancel,
localAddr: conn.LocalAddr(),
remoteAddr: conn.RemoteAddr(),
handler: d.handleIncomingReadyConnection,
primaryKey: d.config.PrimaryKey,
readPipe: make(chan []byte, 1),
firstWrite: true,
firstWriteDelay: firstWriteDelay,
transportLayerPadding: d.config.TransportLayerPadding,
sequenceWatermarkEnabled: d.config.SequenceWatermarkingEnabled,
}
cconnState.mirrorConn = mirrorbase.NewMirroredTLSConn(ctx, conn, forwardConn, cconnState.onC2SMessage, cconnState.onS2CMessage, conn,
d.explicitNonceCiphersuiteLookup.Lookup, cconnState.onC2SMessageTx, cconnState.onS2CMessageTx)
}
type connectionContextGetter interface {
GetConnectionContext() context.Context
}
type verifyConnectionEnrollment interface {
VerifyConnectionEnrollmentWithProcessor(connectionEnrollmentConfirmationClient tlsmirror.ConnectionEnrollmentConfirmation) error
}
func (d *persistentMirrorTLSDialer) handleIncomingReadyConnection(conn internet.Connection) {
go func() {
if d.config.ConnectionEnrolment != nil {
if enrollableConn, ok := conn.(verifyConnectionEnrollment); ok {
if d.enrollmentConfirmationClient != nil {
err := enrollableConn.VerifyConnectionEnrollmentWithProcessor(d.enrollmentConfirmationClient)
if err != nil {
newError("failed to verify connection enrollment").Base(err).AtWarning().WriteToLog()
return
}
} else {
newError("enrollment confirmation client is not set, connection rejected").AtWarning().WriteToLog()
return
}
} else {
newError("connection does not implement verifyConnectionEnrollment, connection rejected").AtWarning().WriteToLog()
return
}
}
var waitedForReady bool
if getter, ok := conn.(connectionContextGetter); ok {
ctx := getter.GetConnectionContext()
if managedConnectionController := ctx.Value(tlsmirror.TrafficGeneratorManagedConnectionContextKey); managedConnectionController != nil {
if controller, ok := managedConnectionController.(tlsmirror.TrafficGeneratorManagedConnection); ok {
select { // nolint: staticcheck
case <-controller.WaitConnectionReady().Done():
waitedForReady = true
// TODO: connection might become invalid and never ready, handle this case
if controller.IsConnectionInvalidated() {
newError("connection is invalidated, skipping").AtWarning().WriteToLog()
return
}
case <-ctx.Done():
return
case <-d.ctx.Done():
return
}
}
}
}
if !waitedForReady {
newError("unable to wait for connection ready, please verify your setup").AtWarning().WriteToLog()
}
d.incomingConnections <- conn
}()
}
func (d *persistentMirrorTLSDialer) Dial(ctx context.Context,
dest net.Destination, settings *internet.MemoryStreamConfig,
) (internet.Connection, error) {
if len(d.enrollmentServerIdentifier) > 0 {
if mirrorcommon.IsLoopbackProtectionEnabled(ctx, d.enrollmentServerIdentifier) {
return nil, newError("loopback protection: refusing to dial to self")
}
}
var recvConn net.Conn
select {
case conn := <-d.incomingConnections:
recvConn = conn
default:
err := d.requestNewConnection(ctx)
if err != nil {
return nil, newError("failed to request new connection").Base(err)
}
timer := time.NewTimer(10 * time.Second)
defer timer.Stop()
select { // nolint: staticcheck
case conn := <-d.incomingConnections:
recvConn = conn
case <-timer.C:
return nil, newError("timeout waiting for incoming connection")
case <-ctx.Done():
return nil, newError("context done while waiting for incoming connection")
}
}
if recvConn == nil {
return nil, newError("failed to receive connection")
}
return recvConn, nil
}
func Dial(ctx context.Context, dest net.Destination, settings *internet.MemoryStreamConfig) (internet.Connection, error) {
transportEnvironment := envctx.EnvironmentFromContext(ctx).(environment.TransportEnvironment)
dialer, err := transportEnvironment.TransientStorage().Get(ctx, "persistentDialer")
if err != nil {
var securitySetting proto.Message
if settings.SecurityType != "" && settings.SecurityType != "none" {
securitySetting = settings.SecuritySettings.(proto.Message)
}
config := settings.ProtocolSettings.(*Config)
detachedContext := core.ToBackgroundDetachedContext(ctx)
dialer, err = newPersistentMirrorTLSDialer(detachedContext, config, dest, securitySetting)
if err != nil {
return nil, newError("failed to create persistent mirror TLS dialer").Base(err)
}
err = transportEnvironment.TransientStorage().Put(ctx, "persistentDialer", dialer)
if err != nil {
return nil, newError("failed to put persistent dialer").Base(err)
}
}
conn, err := dialer.(*persistentMirrorTLSDialer).Dial(ctx, dest, settings)
if err != nil {
return nil, newError("failed to dial").Base(err)
}
return conn, nil
}
func init() {
common.Must(internet.RegisterTransportDialer(protocolName, Dial))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/padding.go | transport/internet/tlsmirror/server/padding.go | package server
// this file defines methods to pad packets
// with a given number of bytes, and to unpack the padding from a padded packet.
// The packet format is as follows if the desired output length is greater than
// 4 bytes:
// | data | padding | data length |
// The data length is a 32-bit big-endian integer that represents the length of
// the data in bytes.
// If the desired output length is 4 bytes or less, the packet format is as
// follows:
// | padding |
// No payload will be included in the packet.
import "encoding/binary"
// Pack pads the given data with the given number of bytes, and appends the
// length of the data to the end of the data. The returned byte slice
// contains the padded data.
// This generates a packet with a length of
// len(data_OWNERSHIP_RELINQUISHED) + padding + 2
// @param data_OWNERSHIP_RELINQUISHED - The payload, this reference is consumed and should not be used after this call.
// @param padding - The number of padding bytes to add to the data.
func Pack(data_OWNERSHIP_RELINQUISHED []byte, paddingLength int) []byte {
data := append(data_OWNERSHIP_RELINQUISHED, make([]byte, paddingLength)...) //nolint:gocritic
dataLength := len(data_OWNERSHIP_RELINQUISHED)
data = binary.BigEndian.AppendUint32(data, uint32(dataLength))
return data
}
// Pad returns a padding packet of padding length.
// If the padding length is less than 0, nil is returned.
// @param padding - The number of padding bytes to add to the data.
func Pad(paddingLength int) []byte {
if assertPaddingLengthIsNotNegative := paddingLength < 0; assertPaddingLengthIsNotNegative {
return nil
}
switch paddingLength {
case 0:
return []byte{}
case 1:
return []byte{0}
case 2:
return []byte{0, 0}
case 3:
return []byte{0, 0, 0}
case 4:
return []byte{0, 0, 0, 0}
default:
return append(make([]byte, paddingLength)) //nolint:gocritic, govet, staticcheck
}
}
// Unpack extracts the data and padding from the given padded data. It
// returns the data and the number of padding bytes.
// the data may be nil.
// @param wrappedData_OWNERSHIP_RELINQUISHED - The packet, this reference is consumed and should not be used after this call.
func Unpack(wrappedData_OWNERSHIP_RELINQUISHED []byte) ([]byte, int) {
dataLength := len(wrappedData_OWNERSHIP_RELINQUISHED)
if dataLength < 4 {
return nil, dataLength
}
dataLen := int(binary.BigEndian.Uint32(wrappedData_OWNERSHIP_RELINQUISHED[dataLength-4:]))
if dataLen > len(wrappedData_OWNERSHIP_RELINQUISHED)-4 {
return nil, 0
}
paddingLength := dataLength - dataLen - 4
if paddingLength < 0 {
return nil, paddingLength
}
return wrappedData_OWNERSHIP_RELINQUISHED[:dataLen], paddingLength
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/conn.go | transport/internet/tlsmirror/server/conn.go | package server
import (
"bytes"
"context"
"crypto/cipher"
"net"
"time"
"golang.org/x/crypto/chacha20"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorcommon"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorcrypto"
)
type connState struct {
ctx context.Context
done context.CancelFunc
handler internet.ConnHandler
mirrorConn tlsmirror.InsertableTLSConn
localAddr net.Addr
remoteAddr net.Addr
activated bool
decryptor *mirrorcrypto.Decryptor
encryptor *mirrorcrypto.Encryptor
primaryKey []byte
readPipe chan []byte
readBuffer *bytes.Buffer
protocolVersion [2]byte
firstWrite bool
firstWriteDelay time.Duration
transportLayerPadding *TransportLayerPadding
connectionEnrollmentEnabled bool
connectionEnrollmentProcessorEnrolled bool
connectionEnrollmentProcessor tlsmirror.ConnectionEnrollmentConfirmationProcessor
connectionEnrollmentRemover tlsmirror.RemoveConnectionFunc
sequenceWatermarkEnabled bool
sequenceWatermarkTx, sequenceWatermarkRx cipher.Stream
}
func (s *connState) VerifyConnectionEnrollment(req *tlsmirror.EnrollmentConfirmationReq) (*tlsmirror.EnrollmentConfirmationResp, error) {
return &tlsmirror.EnrollmentConfirmationResp{Enrolled: true}, nil
}
func (s *connState) Read(b []byte) (n int, err error) {
if s.readBuffer != nil {
n, _ = s.readBuffer.Read(b)
if n > 0 {
return n, nil
}
s.readBuffer = nil
}
select {
case <-s.ctx.Done():
return 0, s.ctx.Err()
case data := <-s.readPipe:
if s.transportLayerPadding != nil && s.transportLayerPadding.Enabled {
var padding int
data, padding = Unpack(data)
_ = padding
if data == nil {
return 0, nil
}
}
s.readBuffer = bytes.NewBuffer(data)
n, err = s.readBuffer.Read(b)
if err != nil {
return 0, err
}
return n, nil
}
}
func (s *connState) Write(b []byte) (n int, err error) {
payloadSize := len(b)
if s.firstWrite && s.firstWriteDelay > 0 {
firstWriteDelayTimer := time.NewTimer(s.firstWriteDelay)
defer firstWriteDelayTimer.Stop()
select {
case <-s.ctx.Done():
return 0, s.ctx.Err()
case <-firstWriteDelayTimer.C:
s.firstWrite = false
}
}
if s.transportLayerPadding != nil && s.transportLayerPadding.Enabled {
b = Pack(bytes.Clone(b), 0)
}
err = s.WriteMessage(b)
if err != nil {
return 0, err
}
n = payloadSize
return n, nil
}
func (s *connState) LocalAddr() net.Addr {
return s.localAddr
}
func (s *connState) RemoteAddr() net.Addr {
return s.remoteAddr
}
func (s *connState) SetDeadline(t time.Time) error {
return nil
}
func (s *connState) SetReadDeadline(t time.Time) error {
return nil
}
func (s *connState) SetWriteDeadline(t time.Time) error {
return nil
}
func (s *connState) Close() error {
s.done()
if s.connectionEnrollmentRemover != nil {
if err := s.connectionEnrollmentRemover(); err != nil {
newError("failed to remove connection enrollment").Base(err).AtWarning().WriteToLog()
}
s.connectionEnrollmentRemover = nil
}
return nil
}
func (s *connState) onS2CMessage(message *tlsmirror.TLSRecord) (drop bool, ok error) {
if message.RecordType == mirrorcommon.TLSRecord_RecordType_handshake {
if s.connectionEnrollmentEnabled && !s.connectionEnrollmentProcessorEnrolled {
clientRandom, serverRandom, err := s.mirrorConn.GetHandshakeRandom()
if err != nil {
newError("failed to get handshake random").Base(err).AtWarning().WriteToLog()
return false, nil
}
remove, err := s.connectionEnrollmentProcessor.AddConnection(s.ctx, clientRandom, serverRandom, s)
if err != nil {
newError("failed to add connection for enrollment").Base(err).AtWarning().WriteToLog()
return false, nil
}
s.connectionEnrollmentRemover = remove
s.connectionEnrollmentProcessorEnrolled = true
return false, nil
}
}
return false, nil
}
func (s *connState) onC2SMessage(message *tlsmirror.TLSRecord) (drop bool, ok error) {
if s.sequenceWatermarkEnabled {
if s.sequenceWatermarkRx != nil {
if (message.RecordType == mirrorcommon.TLSRecord_RecordType_application_data ||
message.RecordType == mirrorcommon.TLSRecord_RecordType_alert) && len(message.Fragment) >= 16 {
watermarkRegion := message.Fragment[len(message.Fragment)-16:]
s.sequenceWatermarkRx.XORKeyStream(watermarkRegion, watermarkRegion)
}
}
}
if message.RecordType == mirrorcommon.TLSRecord_RecordType_application_data {
if s.decryptor == nil {
clientRandom, serverRandom, err := s.mirrorConn.GetHandshakeRandom()
if err != nil {
newError("failed to get handshake random").Base(err).AtWarning().WriteToLog()
return false, nil
}
{
encryptionKey, nonceMask, err := mirrorcrypto.DeriveEncryptionKey(s.primaryKey, clientRandom, serverRandom, ":c2s")
if err != nil {
newError("failed to derive C2S encryption key").Base(err).AtWarning().WriteToLog()
return false, nil
}
s.decryptor = mirrorcrypto.NewDecryptor(encryptionKey, nonceMask)
}
{
encryptionKey, nonceMask, err := mirrorcrypto.DeriveEncryptionKey(s.primaryKey, clientRandom, serverRandom, ":s2c")
if err != nil {
newError("failed to derive S2C encryption key").Base(err).AtWarning().WriteToLog()
return false, nil
}
s.encryptor = mirrorcrypto.NewEncryptor(encryptionKey, nonceMask)
}
s.protocolVersion = message.LegacyProtocolVersion
}
explicitNonceReservedOverheadHeaderLength, err := s.mirrorConn.GetApplicationDataExplicitNonceReservedOverheadHeaderLength()
if err != nil {
return false, newError("failed to get explicit nonce reserved overhead header length").Base(err)
}
buffer := make([]byte, 0, len(message.Fragment)-s.decryptor.NonceSize()-explicitNonceReservedOverheadHeaderLength)
buffer, err = s.decryptor.Open(buffer, message.Fragment[explicitNonceReservedOverheadHeaderLength:])
if err != nil {
return false, nil
}
if s.sequenceWatermarkEnabled && s.sequenceWatermarkRx == nil {
clientRandom, serverRandom, err := s.mirrorConn.GetHandshakeRandom()
if err != nil {
newError("failed to get handshake random").Base(err).AtError().WriteToLog()
return true, nil
}
key, nonce, err := mirrorcrypto.DeriveSequenceWatermarkingKey(s.primaryKey, clientRandom, serverRandom, ":c2s")
if err != nil {
newError("failed to derive sequence watermarking key").Base(err).AtError().WriteToLog()
return true, nil
}
s.sequenceWatermarkRx, err = chacha20.NewUnauthenticatedCipher(key, nonce)
if err != nil {
newError("failed to create sequence watermarking cipher").Base(err).AtError().WriteToLog()
return true, nil
}
}
if !s.activated {
s.handler(s)
s.activated = true
}
s.readPipe <- buffer
return true, nil
}
return false, ok
}
func (s *connState) WriteMessage(message []byte) error {
explicitNonceReservedOverheadHeaderLength, err := s.mirrorConn.GetApplicationDataExplicitNonceReservedOverheadHeaderLength()
if err != nil {
return newError("failed to get explicit nonce reserved overhead header length").Base(err)
}
buffer := make([]byte, explicitNonceReservedOverheadHeaderLength, explicitNonceReservedOverheadHeaderLength+len(message)+s.decryptor.NonceSize())
buffer, err = s.encryptor.Seal(buffer, message)
if err != nil {
return newError("failed to encrypt message").Base(err)
}
record := tlsmirror.TLSRecord{
RecordType: mirrorcommon.TLSRecord_RecordType_application_data,
LegacyProtocolVersion: s.protocolVersion,
RecordLength: uint16(len(buffer)),
Fragment: buffer,
InsertedMessage: true,
}
return s.mirrorConn.InsertS2CMessage(&record)
}
func (s *connState) onC2SMessageTx(message *tlsmirror.TLSRecord) (drop bool, ok error) {
return false, nil
}
func (s *connState) onS2CMessageTx(message *tlsmirror.TLSRecord) (drop bool, ok error) {
if s.sequenceWatermarkEnabled {
if s.sequenceWatermarkTx != nil {
if (message.RecordType == mirrorcommon.TLSRecord_RecordType_application_data ||
message.RecordType == mirrorcommon.TLSRecord_RecordType_alert) && len(message.Fragment) >= 16 {
watermarkRegion := message.Fragment[len(message.Fragment)-16:]
s.sequenceWatermarkTx.XORKeyStream(watermarkRegion, watermarkRegion)
}
}
if message.InsertedMessage && s.sequenceWatermarkTx == nil {
clientRandom, serverRandom, err := s.mirrorConn.GetHandshakeRandom()
if err != nil {
newError("failed to get handshake random").Base(err).AtError().WriteToLog()
return true, nil
}
key, nonce, err := mirrorcrypto.DeriveSequenceWatermarkingKey(s.primaryKey, clientRandom, serverRandom, ":s2c")
if err != nil {
newError("failed to derive sequence watermarking key").Base(err).AtError().WriteToLog()
return true, nil
}
s.sequenceWatermarkTx, err = chacha20.NewUnauthenticatedCipher(key, nonce)
if err != nil {
newError("failed to create sequence watermarking cipher").Base(err).AtError().WriteToLog()
return true, nil
}
}
}
return false, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/outbound.go | transport/internet/tlsmirror/server/outbound.go | package server
import (
"context"
"sync"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/signal/done"
"github.com/v2fly/v2ray-core/v5/transport"
)
func NewOutboundListener() *OutboundListener {
return &OutboundListener{
buffer: make(chan *connWithContext, 4),
done: done.New(),
}
}
type connWithContext struct {
net.Conn
ctx context.Context
}
func (c *connWithContext) GetConnectionContext() context.Context {
return c.ctx
}
// OutboundListener is a net.Listener for listening gRPC connections.
type OutboundListener struct {
buffer chan *connWithContext
done *done.Instance
}
func (l *OutboundListener) addWithContext(ctx context.Context, conn net.Conn) {
select {
case l.buffer <- &connWithContext{Conn: conn, ctx: ctx}:
case <-l.done.Wait():
conn.Close()
default:
conn.Close()
}
}
// Accept implements net.Listener.
func (l *OutboundListener) Accept() (net.Conn, error) {
select {
case <-l.done.Wait():
return nil, newError("listen closed")
case c := <-l.buffer:
return c, nil
}
}
// Close implement net.Listener.
func (l *OutboundListener) Close() error {
common.Must(l.done.Close())
L:
for {
select {
case c := <-l.buffer:
c.Close()
default:
break L
}
}
return nil
}
// Addr implements net.Listener.
func (l *OutboundListener) Addr() net.Addr {
return &net.TCPAddr{
IP: net.IP{0, 0, 0, 0},
Port: 0,
}
}
func NewOutbound(tag string, listener *OutboundListener) *Outbound {
return &Outbound{
tag: tag,
listener: listener,
}
}
// Outbound is a outbound.Handler that handles gRPC connections.
type Outbound struct {
tag string
listener *OutboundListener
access sync.RWMutex
closed bool
}
// Dispatch implements outbound.Handler.
func (co *Outbound) Dispatch(ctx context.Context, link *transport.Link) {
co.access.RLock()
if co.closed {
common.Interrupt(link.Reader)
common.Interrupt(link.Writer)
co.access.RUnlock()
return
}
closeSignal := done.New()
c := net.NewConnection(net.ConnectionInputMulti(link.Writer), net.ConnectionOutputMulti(link.Reader), net.ConnectionOnClose(closeSignal))
co.listener.addWithContext(ctx, c)
co.access.RUnlock()
<-closeSignal.Wait()
}
// Tag implements outbound.Handler.
func (co *Outbound) Tag() string {
return co.tag
}
// Start implements common.Runnable.
func (co *Outbound) Start() error {
co.access.Lock()
co.closed = false
co.access.Unlock()
return nil
}
// Close implements common.Closable.
func (co *Outbound) Close() error {
co.access.Lock()
defer co.access.Unlock()
co.closed = true
return co.listener.Close()
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/client_conn.go | transport/internet/tlsmirror/server/client_conn.go | package server
import (
"bytes"
"context"
"crypto/cipher"
gonet "net"
"time"
"golang.org/x/crypto/chacha20"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorcommon"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorcrypto"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorenrollment"
)
type clientConnState struct {
ctx context.Context
done context.CancelFunc
handler internet.ConnHandler
mirrorConn tlsmirror.InsertableTLSConn
localAddr net.Addr
remoteAddr net.Addr
activated bool
decryptor *mirrorcrypto.Decryptor
encryptor *mirrorcrypto.Encryptor
primaryKey []byte
readPipe chan []byte
readBuffer *bytes.Buffer
protocolVersion [2]byte
firstWrite bool
firstWriteDelay time.Duration
transportLayerPadding *TransportLayerPadding
sequenceWatermarkEnabled bool
sequenceWatermarkTx, sequenceWatermarkRx cipher.Stream
}
func (s *clientConnState) GetConnectionContext() context.Context {
return s.ctx
}
func (s *clientConnState) Read(b []byte) (n int, err error) {
if s.readBuffer != nil {
n, _ = s.readBuffer.Read(b)
if n > 0 {
return n, nil
}
s.readBuffer = nil
}
select {
case <-s.ctx.Done():
return 0, s.ctx.Err()
case data := <-s.readPipe:
if s.transportLayerPadding != nil && s.transportLayerPadding.Enabled {
var padding int
data, padding = Unpack(data)
_ = padding
if data == nil {
return 0, nil
}
}
s.readBuffer = bytes.NewBuffer(data)
n, err = s.readBuffer.Read(b)
if err != nil {
return 0, err
}
return n, nil
}
}
func (s *clientConnState) Write(b []byte) (n int, err error) {
payloadSize := len(b)
if s.firstWrite && s.firstWriteDelay > 0 {
firstWriteDelayTimer := time.NewTimer(s.firstWriteDelay)
defer firstWriteDelayTimer.Stop()
select {
case <-s.ctx.Done():
return 0, s.ctx.Err()
case <-firstWriteDelayTimer.C:
s.firstWrite = false
}
}
if s.transportLayerPadding != nil && s.transportLayerPadding.Enabled {
b = Pack(bytes.Clone(b), 0)
}
err = s.WriteMessage(b)
if err != nil {
return 0, err
}
n = payloadSize
return n, nil
}
func (s *clientConnState) Close() error {
// TODO: Only recall the connection, not close it.
s.done()
return nil
}
func (s *clientConnState) LocalAddr() gonet.Addr {
return s.remoteAddr
}
func (s *clientConnState) RemoteAddr() gonet.Addr {
return s.remoteAddr
}
func (s *clientConnState) SetDeadline(t time.Time) error {
return nil
}
func (s *clientConnState) SetReadDeadline(t time.Time) error {
return nil
}
func (s *clientConnState) SetWriteDeadline(t time.Time) error {
return nil
}
func (s *clientConnState) onC2SMessage(message *tlsmirror.TLSRecord) (drop bool, ok error) {
if message.RecordType == mirrorcommon.TLSRecord_RecordType_application_data {
if s.decryptor == nil {
clientRandom, serverRandom, err := s.mirrorConn.GetHandshakeRandom()
if err != nil {
newError("failed to get handshake random").Base(err).AtWarning().WriteToLog()
return false, nil
}
{
encryptionKey, nonceMask, err := mirrorcrypto.DeriveEncryptionKey(s.primaryKey, clientRandom, serverRandom, ":s2c")
if err != nil {
newError("failed to derive C2S encryption key").Base(err).AtWarning().WriteToLog()
return false, nil
}
s.decryptor = mirrorcrypto.NewDecryptor(encryptionKey, nonceMask)
}
{
encryptionKey, nonceMask, err := mirrorcrypto.DeriveEncryptionKey(s.primaryKey, clientRandom, serverRandom, ":c2s")
if err != nil {
newError("failed to derive S2C encryption key").Base(err).AtWarning().WriteToLog()
return false, nil
}
s.encryptor = mirrorcrypto.NewEncryptor(encryptionKey, nonceMask)
}
s.protocolVersion = message.LegacyProtocolVersion
if !s.activated {
s.handler(s)
s.activated = true
}
}
}
return false, ok
}
func (s *clientConnState) onS2CMessage(message *tlsmirror.TLSRecord) (drop bool, ok error) {
if s.sequenceWatermarkEnabled {
if s.sequenceWatermarkRx != nil {
if (message.RecordType == mirrorcommon.TLSRecord_RecordType_application_data ||
message.RecordType == mirrorcommon.TLSRecord_RecordType_alert) && len(message.Fragment) >= 16 {
watermarkRegion := message.Fragment[len(message.Fragment)-16:]
s.sequenceWatermarkRx.XORKeyStream(watermarkRegion, watermarkRegion)
}
}
}
if message.RecordType == mirrorcommon.TLSRecord_RecordType_application_data {
explicitNonceReservedOverheadHeaderLength, err := s.mirrorConn.GetApplicationDataExplicitNonceReservedOverheadHeaderLength()
if err != nil {
return false, newError("failed to get explicit nonce reserved overhead header length").Base(err)
}
if s.encryptor == nil {
return false, nil
}
buffer := make([]byte, 0, len(message.Fragment)-s.encryptor.NonceSize()-explicitNonceReservedOverheadHeaderLength)
buffer, err = s.decryptor.Open(buffer, message.Fragment[explicitNonceReservedOverheadHeaderLength:])
if err != nil {
return false, nil
}
if s.sequenceWatermarkEnabled && s.sequenceWatermarkRx == nil {
clientRandom, serverRandom, err := s.mirrorConn.GetHandshakeRandom()
if err != nil {
newError("failed to get handshake random").Base(err).AtError().WriteToLog()
return true, nil
}
key, nonce, err := mirrorcrypto.DeriveSequenceWatermarkingKey(s.primaryKey, clientRandom, serverRandom, ":s2c")
if err != nil {
newError("failed to derive sequence watermarking key").Base(err).AtError().WriteToLog()
return true, nil
}
s.sequenceWatermarkRx, err = chacha20.NewUnauthenticatedCipher(key, nonce)
if err != nil {
newError("failed to create sequence watermarking cipher").Base(err).AtError().WriteToLog()
return true, nil
}
}
s.readPipe <- buffer
return true, nil
}
return false, ok
}
func (s *clientConnState) WriteMessage(message []byte) error {
explicitNonceReservedOverheadHeaderLength, err := s.mirrorConn.GetApplicationDataExplicitNonceReservedOverheadHeaderLength()
if err != nil {
return newError("failed to get explicit nonce reserved overhead header length").Base(err)
}
buffer := make([]byte, explicitNonceReservedOverheadHeaderLength, explicitNonceReservedOverheadHeaderLength+len(message)+s.encryptor.NonceSize())
buffer, err = s.encryptor.Seal(buffer, message)
if err != nil {
return newError("failed to encrypt message").Base(err)
}
record := tlsmirror.TLSRecord{
RecordType: mirrorcommon.TLSRecord_RecordType_application_data,
LegacyProtocolVersion: s.protocolVersion,
RecordLength: uint16(len(buffer)),
Fragment: buffer,
InsertedMessage: true,
}
return s.mirrorConn.InsertC2SMessage(&record)
}
func (s *clientConnState) VerifyConnectionEnrollmentWithProcessor(connectionEnrollmentConfirmationClient tlsmirror.ConnectionEnrollmentConfirmation) error {
clientRandom, serverRandom, err := s.mirrorConn.GetHandshakeRandom()
if err != nil {
return newError("failed to get handshake random").Base(err).AtWarning()
}
enrollmentServerIdentity, err := mirrorenrollment.DeriveEnrollmentServerIdentifier(s.primaryKey)
if err != nil {
return newError("failed to derive enrollment server identifier").Base(err).AtError()
}
enrollmentReq := &tlsmirror.EnrollmentConfirmationReq{
ServerIdentifier: enrollmentServerIdentity,
CarrierTlsConnectionClientRandom: clientRandom,
CarrierTlsConnectionServerRandom: serverRandom,
}
resp, err := connectionEnrollmentConfirmationClient.VerifyConnectionEnrollment(enrollmentReq)
if err != nil {
return newError("failed to verify connection enrollment").Base(err).AtError()
}
if resp == nil {
return newError("nil EnrollmentConfirmationResp")
}
if resp.Enrolled {
newError("connection enrolled successfully").AtInfo().WriteToLog()
} else {
return newError("connection enrollment failed")
}
return nil
}
func (s *clientConnState) onC2SMessageTx(message *tlsmirror.TLSRecord) (drop bool, ok error) {
if s.sequenceWatermarkEnabled {
if s.sequenceWatermarkTx != nil {
if (message.RecordType == mirrorcommon.TLSRecord_RecordType_application_data ||
message.RecordType == mirrorcommon.TLSRecord_RecordType_alert) && len(message.Fragment) >= 16 {
watermarkRegion := message.Fragment[len(message.Fragment)-16:]
s.sequenceWatermarkTx.XORKeyStream(watermarkRegion, watermarkRegion)
}
}
if message.InsertedMessage && s.sequenceWatermarkTx == nil {
clientRandom, serverRandom, err := s.mirrorConn.GetHandshakeRandom()
if err != nil {
newError("failed to get handshake random").Base(err).AtError().WriteToLog()
return true, nil
}
key, nonce, err := mirrorcrypto.DeriveSequenceWatermarkingKey(s.primaryKey, clientRandom, serverRandom, ":c2s")
if err != nil {
newError("failed to derive sequence watermarking key").Base(err).AtError().WriteToLog()
return true, nil
}
s.sequenceWatermarkTx, err = chacha20.NewUnauthenticatedCipher(key, nonce)
if err != nil {
newError("failed to create sequence watermarking cipher").Base(err).AtError().WriteToLog()
return true, nil
}
}
}
return false, nil
}
func (s *clientConnState) onS2CMessageTx(message *tlsmirror.TLSRecord) (drop bool, ok error) {
return false, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/server.go | transport/internet/tlsmirror/server/server.go | package server
import (
cryptoRand "crypto/rand"
"math/big"
"strings"
"time"
"golang.org/x/net/context"
core "github.com/v2fly/v2ray-core/v5"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/features/outbound"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorbase"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorenrollment"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
type Server struct {
config *Config
listener net.Listener
handler internet.ConnHandler
ctx context.Context
explicitNonceCiphersuiteLookup *ciphersuiteLookuper
enrollmentConfirmationListener *OutboundListener
enrollmentConfirmationOutbound *Outbound
obm outbound.Manager
enrollmentConfirmationServer *mirrorenrollment.EnrollmentConfirmationServer
enrollmentConfirmationProcessor tlsmirror.ConnectionEnrollmentConfirmationProcessor
}
func (s *Server) process(conn net.Conn) {
transportEnvironment := envctx.EnvironmentFromContext(s.ctx).(environment.TransportEnvironment)
dialer := transportEnvironment.OutboundDialer()
port, err := net.PortFromInt(s.config.ForwardPort)
if err != nil {
newError("failed to parse port").Base(err).AtWarning().WriteToLog()
return
}
address := net.ParseAddress(s.config.ForwardAddress)
dest := net.TCPDestination(address, port)
forwardConn, err := dialer(s.ctx, dest, s.config.ForwardTag)
if err != nil {
newError("failed to dial to destination").Base(err).AtWarning().WriteToLog()
return
}
s.accept(conn, forwardConn)
}
func (s *Server) accepts() {
for {
conn, err := s.listener.Accept()
if err != nil {
errStr := err.Error()
if strings.Contains(errStr, "closed") {
break
}
newError("failed to accepted raw connections").Base(err).AtWarning().WriteToLog()
if strings.Contains(errStr, "too many") {
time.Sleep(time.Millisecond * 500)
}
continue
}
go s.process(conn)
}
}
func (s *Server) Close() error {
if s.enrollmentConfirmationListener != nil {
if err := s.enrollmentConfirmationListener.Close(); err != nil {
newError("failed to close enrollment confirmation listener").Base(err).AtWarning().WriteToLog()
}
}
return s.listener.Close()
}
func (s *Server) Addr() net.Addr {
return s.listener.Addr()
}
func (s *Server) accept(clientConn net.Conn, serverConn net.Conn) {
ctx, cancel := context.WithCancel(s.ctx)
firstWriteDelay := time.Duration(0)
if s.config.DeferInstanceDerivedWriteTime != nil {
firstWriteDelay = time.Duration(s.config.DeferInstanceDerivedWriteTime.BaseNanoseconds)
if s.config.DeferInstanceDerivedWriteTime.UniformRandomMultiplierNanoseconds > 0 {
uniformRandomAdd := big.NewInt(int64(s.config.DeferInstanceDerivedWriteTime.UniformRandomMultiplierNanoseconds))
uniformRandomAddBigInt, err := cryptoRand.Int(cryptoRand.Reader, uniformRandomAdd)
if err != nil {
newError("failed to generate random delay").Base(err).AtWarning().WriteToLog()
return
}
uniformRandomAddU64 := uint64(uniformRandomAddBigInt.Int64())
firstWriteDelay += time.Duration(uniformRandomAddU64)
}
}
conn := &connState{
ctx: ctx,
done: cancel,
localAddr: clientConn.LocalAddr(),
remoteAddr: clientConn.RemoteAddr(),
primaryKey: s.config.PrimaryKey,
handler: s.onIncomingReadyConnection,
readPipe: make(chan []byte, 1),
firstWrite: true,
firstWriteDelay: firstWriteDelay,
transportLayerPadding: s.config.TransportLayerPadding,
sequenceWatermarkEnabled: s.config.SequenceWatermarkingEnabled,
}
if s.config.ConnectionEnrolment != nil {
conn.connectionEnrollmentEnabled = true
conn.connectionEnrollmentProcessor = s.enrollmentConfirmationProcessor
}
conn.mirrorConn = mirrorbase.NewMirroredTLSConn(ctx, clientConn, serverConn, conn.onC2SMessage, conn.onS2CMessage, conn,
s.explicitNonceCiphersuiteLookup.Lookup, conn.onC2SMessageTx, conn.onS2CMessageTx)
}
func (s *Server) onIncomingReadyConnection(conn internet.Connection) {
go s.handler(conn)
}
func (s *Server) init() error {
if err := core.RequireFeatures(s.ctx, func(om outbound.Manager) {
s.obm = om
}); err != nil {
return err
}
if s.config.ConnectionEnrolment != nil {
s.enrollmentConfirmationListener = NewOutboundListener()
s.enrollmentConfirmationOutbound = NewOutbound(s.config.ConnectionEnrolment.PrimaryIngressOutbound,
s.enrollmentConfirmationListener)
if err := s.enrollmentConfirmationOutbound.Start(); err != nil {
return newError("failed to start enrollment confirmation outbound").Base(err).AtWarning()
}
if err := s.obm.RemoveHandler(context.Background(), s.config.ConnectionEnrolment.PrimaryIngressOutbound); err != nil {
newError("failed to remove existing handler").Base(err).AtDebug().WriteToLog()
}
err := s.obm.AddHandler(context.Background(), s.enrollmentConfirmationOutbound)
if err != nil {
return newError("failed to add outbound handler").Base(err)
}
s.enrollmentConfirmationProcessor, err = mirrorenrollment.NewServerEnrollmentProcessor(s.config.PrimaryKey)
if err != nil {
return newError("failed to create enrollment confirmation processor").Base(err).AtError()
}
s.enrollmentConfirmationServer, err = mirrorenrollment.NewEnrollmentConfirmationServer(s.ctx, s.config.ConnectionEnrolment,
s.enrollmentConfirmationProcessor)
if err != nil {
return newError("failed to create enrollment confirmation server").Base(err).AtError()
}
go func() {
for {
conn, err := s.enrollmentConfirmationListener.Accept()
if err != nil {
newError("failed to accept enrollment confirmation connection").Base(err).AtWarning().WriteToLog()
continue
}
go func() {
if err := s.enrollmentConfirmationServer.HandlePrimaryIngressConnection(s.ctx, conn); err != nil {
newError("failed to handle primary ingress connection for enrollment confirmation").Base(err).AtWarning().WriteToLog()
}
}()
}
}()
}
return nil
}
func NewServer(ctx context.Context, listener net.Listener, config *Config, handler internet.ConnHandler) (*Server, error) {
var explicitNonceCiphersuiteLookup *ciphersuiteLookuper
if len(config.ExplicitNonceCiphersuites) > 0 {
var err error
explicitNonceCiphersuiteLookup, err = newCipherSuiteLookuperFromUint32Array(config.ExplicitNonceCiphersuites)
if err != nil {
newError("failed to create explicit nonce ciphersuite lookuper").Base(err).AtWarning().WriteToLog()
}
} else {
explicitNonceCiphersuiteLookup = newEmptyCipherSuiteLookuper()
newError("no explicit nonce ciphersuites configured, all ciphersuites will be treated as non-explicit nonce").AtWarning().WriteToLog()
}
s := &Server{
ctx: ctx,
listener: listener,
config: config,
handler: handler,
explicitNonceCiphersuiteLookup: explicitNonceCiphersuiteLookup,
}
if err := s.init(); err != nil {
return nil, newError("failed to initialize TLS mirror server").Base(err).AtError()
}
return s, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/config.pb.go | transport/internet/tlsmirror/server/config.pb.go | package server
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
mirrorenrollment "github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorenrollment"
tlstrafficgen "github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/tlstrafficgen"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type TimeSpec struct {
state protoimpl.MessageState `protogen:"open.v1"`
BaseNanoseconds uint64 `protobuf:"varint,1,opt,name=base_nanoseconds,json=baseNanoseconds,proto3" json:"base_nanoseconds,omitempty"`
UniformRandomMultiplierNanoseconds uint64 `protobuf:"varint,2,opt,name=uniform_random_multiplier_nanoseconds,json=uniformRandomMultiplierNanoseconds,proto3" json:"uniform_random_multiplier_nanoseconds,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TimeSpec) Reset() {
*x = TimeSpec{}
mi := &file_transport_internet_tlsmirror_server_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TimeSpec) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TimeSpec) ProtoMessage() {}
func (x *TimeSpec) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_server_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TimeSpec.ProtoReflect.Descriptor instead.
func (*TimeSpec) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_server_config_proto_rawDescGZIP(), []int{0}
}
func (x *TimeSpec) GetBaseNanoseconds() uint64 {
if x != nil {
return x.BaseNanoseconds
}
return 0
}
func (x *TimeSpec) GetUniformRandomMultiplierNanoseconds() uint64 {
if x != nil {
return x.UniformRandomMultiplierNanoseconds
}
return 0
}
type TransportLayerPadding struct {
state protoimpl.MessageState `protogen:"open.v1"`
Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *TransportLayerPadding) Reset() {
*x = TransportLayerPadding{}
mi := &file_transport_internet_tlsmirror_server_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *TransportLayerPadding) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TransportLayerPadding) ProtoMessage() {}
func (x *TransportLayerPadding) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_server_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TransportLayerPadding.ProtoReflect.Descriptor instead.
func (*TransportLayerPadding) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_server_config_proto_rawDescGZIP(), []int{1}
}
func (x *TransportLayerPadding) GetEnabled() bool {
if x != nil {
return x.Enabled
}
return false
}
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
ForwardAddress string `protobuf:"bytes,1,opt,name=forward_address,json=forwardAddress,proto3" json:"forward_address,omitempty"`
ForwardPort uint32 `protobuf:"varint,2,opt,name=forward_port,json=forwardPort,proto3" json:"forward_port,omitempty"`
ForwardTag string `protobuf:"bytes,3,opt,name=forward_tag,json=forwardTag,proto3" json:"forward_tag,omitempty"`
CarrierConnectionTag string `protobuf:"bytes,4,opt,name=carrier_connection_tag,json=carrierConnectionTag,proto3" json:"carrier_connection_tag,omitempty"`
EmbeddedTrafficGenerator *tlstrafficgen.Config `protobuf:"bytes,5,opt,name=embedded_traffic_generator,json=embeddedTrafficGenerator,proto3" json:"embedded_traffic_generator,omitempty"`
PrimaryKey []byte `protobuf:"bytes,6,opt,name=primary_key,json=primaryKey,proto3" json:"primary_key,omitempty"`
ExplicitNonceCiphersuites []uint32 `protobuf:"varint,7,rep,packed,name=explicit_nonce_ciphersuites,json=explicitNonceCiphersuites,proto3" json:"explicit_nonce_ciphersuites,omitempty"`
DeferInstanceDerivedWriteTime *TimeSpec `protobuf:"bytes,8,opt,name=defer_instance_derived_write_time,json=deferInstanceDerivedWriteTime,proto3" json:"defer_instance_derived_write_time,omitempty"`
TransportLayerPadding *TransportLayerPadding `protobuf:"bytes,9,opt,name=transport_layer_padding,json=transportLayerPadding,proto3" json:"transport_layer_padding,omitempty"`
ConnectionEnrolment *mirrorenrollment.Config `protobuf:"bytes,10,opt,name=connection_enrolment,json=connectionEnrolment,proto3" json:"connection_enrolment,omitempty"`
SequenceWatermarkingEnabled bool `protobuf:"varint,11,opt,name=sequence_watermarking_enabled,json=sequenceWatermarkingEnabled,proto3" json:"sequence_watermarking_enabled,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_tlsmirror_server_config_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_tlsmirror_server_config_proto_msgTypes[2]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_tlsmirror_server_config_proto_rawDescGZIP(), []int{2}
}
func (x *Config) GetForwardAddress() string {
if x != nil {
return x.ForwardAddress
}
return ""
}
func (x *Config) GetForwardPort() uint32 {
if x != nil {
return x.ForwardPort
}
return 0
}
func (x *Config) GetForwardTag() string {
if x != nil {
return x.ForwardTag
}
return ""
}
func (x *Config) GetCarrierConnectionTag() string {
if x != nil {
return x.CarrierConnectionTag
}
return ""
}
func (x *Config) GetEmbeddedTrafficGenerator() *tlstrafficgen.Config {
if x != nil {
return x.EmbeddedTrafficGenerator
}
return nil
}
func (x *Config) GetPrimaryKey() []byte {
if x != nil {
return x.PrimaryKey
}
return nil
}
func (x *Config) GetExplicitNonceCiphersuites() []uint32 {
if x != nil {
return x.ExplicitNonceCiphersuites
}
return nil
}
func (x *Config) GetDeferInstanceDerivedWriteTime() *TimeSpec {
if x != nil {
return x.DeferInstanceDerivedWriteTime
}
return nil
}
func (x *Config) GetTransportLayerPadding() *TransportLayerPadding {
if x != nil {
return x.TransportLayerPadding
}
return nil
}
func (x *Config) GetConnectionEnrolment() *mirrorenrollment.Config {
if x != nil {
return x.ConnectionEnrolment
}
return nil
}
func (x *Config) GetSequenceWatermarkingEnabled() bool {
if x != nil {
return x.SequenceWatermarkingEnabled
}
return false
}
var File_transport_internet_tlsmirror_server_config_proto protoreflect.FileDescriptor
const file_transport_internet_tlsmirror_server_config_proto_rawDesc = "" +
"\n" +
"0transport/internet/tlsmirror/server/config.proto\x12.v2ray.core.transport.internet.tlsmirror.server\x1a common/protoext/extensions.proto\x1a7transport/internet/tlsmirror/tlstrafficgen/config.proto\x1a:transport/internet/tlsmirror/mirrorenrollment/config.proto\"\x88\x01\n" +
"\bTimeSpec\x12)\n" +
"\x10base_nanoseconds\x18\x01 \x01(\x04R\x0fbaseNanoseconds\x12Q\n" +
"%uniform_random_multiplier_nanoseconds\x18\x02 \x01(\x04R\"uniformRandomMultiplierNanoseconds\"1\n" +
"\x15TransportLayerPadding\x12\x18\n" +
"\aenabled\x18\x01 \x01(\bR\aenabled\"\xef\x06\n" +
"\x06Config\x12'\n" +
"\x0fforward_address\x18\x01 \x01(\tR\x0eforwardAddress\x12!\n" +
"\fforward_port\x18\x02 \x01(\rR\vforwardPort\x12\x1f\n" +
"\vforward_tag\x18\x03 \x01(\tR\n" +
"forwardTag\x124\n" +
"\x16carrier_connection_tag\x18\x04 \x01(\tR\x14carrierConnectionTag\x12{\n" +
"\x1aembedded_traffic_generator\x18\x05 \x01(\v2=.v2ray.core.transport.internet.tlsmirror.tlstrafficgen.ConfigR\x18embeddedTrafficGenerator\x12\x1f\n" +
"\vprimary_key\x18\x06 \x01(\fR\n" +
"primaryKey\x12>\n" +
"\x1bexplicit_nonce_ciphersuites\x18\a \x03(\rR\x19explicitNonceCiphersuites\x12\x82\x01\n" +
"!defer_instance_derived_write_time\x18\b \x01(\v28.v2ray.core.transport.internet.tlsmirror.server.TimeSpecR\x1ddeferInstanceDerivedWriteTime\x12}\n" +
"\x17transport_layer_padding\x18\t \x01(\v2E.v2ray.core.transport.internet.tlsmirror.server.TransportLayerPaddingR\x15transportLayerPadding\x12s\n" +
"\x14connection_enrolment\x18\n" +
" \x01(\v2@.v2ray.core.transport.internet.tlsmirror.mirrorenrollment.ConfigR\x13connectionEnrolment\x12B\n" +
"\x1dsequence_watermarking_enabled\x18\v \x01(\bR\x1bsequenceWatermarkingEnabled:'\x82\xb5\x18#\n" +
"\ttransport\x12\ttlsmirror\x8a\xff)\ttlsmirrorB\xab\x01\n" +
"2com.v2ray.core.transport.internet.tlsmirror.serverP\x01ZBgithub.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/server\xaa\x02.V2Ray.Core.Transport.Internet.Tlsmirror.Serverb\x06proto3"
var (
file_transport_internet_tlsmirror_server_config_proto_rawDescOnce sync.Once
file_transport_internet_tlsmirror_server_config_proto_rawDescData []byte
)
func file_transport_internet_tlsmirror_server_config_proto_rawDescGZIP() []byte {
file_transport_internet_tlsmirror_server_config_proto_rawDescOnce.Do(func() {
file_transport_internet_tlsmirror_server_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_server_config_proto_rawDesc), len(file_transport_internet_tlsmirror_server_config_proto_rawDesc)))
})
return file_transport_internet_tlsmirror_server_config_proto_rawDescData
}
var file_transport_internet_tlsmirror_server_config_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
var file_transport_internet_tlsmirror_server_config_proto_goTypes = []any{
(*TimeSpec)(nil), // 0: v2ray.core.transport.internet.tlsmirror.server.TimeSpec
(*TransportLayerPadding)(nil), // 1: v2ray.core.transport.internet.tlsmirror.server.TransportLayerPadding
(*Config)(nil), // 2: v2ray.core.transport.internet.tlsmirror.server.Config
(*tlstrafficgen.Config)(nil), // 3: v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Config
(*mirrorenrollment.Config)(nil), // 4: v2ray.core.transport.internet.tlsmirror.mirrorenrollment.Config
}
var file_transport_internet_tlsmirror_server_config_proto_depIdxs = []int32{
3, // 0: v2ray.core.transport.internet.tlsmirror.server.Config.embedded_traffic_generator:type_name -> v2ray.core.transport.internet.tlsmirror.tlstrafficgen.Config
0, // 1: v2ray.core.transport.internet.tlsmirror.server.Config.defer_instance_derived_write_time:type_name -> v2ray.core.transport.internet.tlsmirror.server.TimeSpec
1, // 2: v2ray.core.transport.internet.tlsmirror.server.Config.transport_layer_padding:type_name -> v2ray.core.transport.internet.tlsmirror.server.TransportLayerPadding
4, // 3: v2ray.core.transport.internet.tlsmirror.server.Config.connection_enrolment:type_name -> v2ray.core.transport.internet.tlsmirror.mirrorenrollment.Config
4, // [4:4] is the sub-list for method output_type
4, // [4:4] is the sub-list for method input_type
4, // [4:4] is the sub-list for extension type_name
4, // [4:4] is the sub-list for extension extendee
0, // [0:4] is the sub-list for field type_name
}
func init() { file_transport_internet_tlsmirror_server_config_proto_init() }
func file_transport_internet_tlsmirror_server_config_proto_init() {
if File_transport_internet_tlsmirror_server_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_tlsmirror_server_config_proto_rawDesc), len(file_transport_internet_tlsmirror_server_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 3,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_tlsmirror_server_config_proto_goTypes,
DependencyIndexes: file_transport_internet_tlsmirror_server_config_proto_depIdxs,
MessageInfos: file_transport_internet_tlsmirror_server_config_proto_msgTypes,
}.Build()
File_transport_internet_tlsmirror_server_config_proto = out.File
file_transport_internet_tlsmirror_server_config_proto_goTypes = nil
file_transport_internet_tlsmirror_server_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/server/ciphersuits_lookup.go | transport/internet/tlsmirror/server/ciphersuits_lookup.go | package server
func newEmptyCipherSuiteLookuper() *ciphersuiteLookuper {
return &ciphersuiteLookuper{
ciphersuiteMap: make(map[uint16]bool),
}
}
func newCipherSuiteLookuperFromUint32Array(source []uint32) (*ciphersuiteLookuper, error) {
if len(source) == 0 {
return nil, newError("ciphersuite list is empty")
}
ciphersuiteUint16Array := make([]uint16, len(source))
for i, ciphersuite := range source {
if ciphersuite > 0xFFFF {
return nil, newError("ciphersuite value out of range: ", ciphersuite)
}
ciphersuiteUint16Array[i] = uint16(ciphersuite)
}
return newCipherSuiteLookuperFromUint16Array(ciphersuiteUint16Array), nil
}
func newCipherSuiteLookuperFromUint16Array(source []uint16) *ciphersuiteLookuper {
ciphersuiteMap := make(map[uint16]bool, len(source))
for _, ciphersuite := range source {
ciphersuiteMap[ciphersuite] = true
}
return &ciphersuiteLookuper{
ciphersuiteMap: ciphersuiteMap,
}
}
type ciphersuiteLookuper struct {
ciphersuiteMap map[uint16]bool
}
func (l *ciphersuiteLookuper) Lookup(ciphersuite uint16) bool {
if result, ok := l.ciphersuiteMap[ciphersuite]; ok {
return result
}
return false
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorbase/base.go | transport/internet/tlsmirror/mirrorbase/base.go | package mirrorbase
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorbase/crypto_test.go | transport/internet/tlsmirror/mirrorbase/crypto_test.go | package mirrorbase
import (
"testing"
"github.com/google/go-cmp/cmp"
"github.com/v2fly/v2ray-core/v5/common/crypto"
)
func TestTLS12ExplicitNonceGeneration(t *testing.T) {
generator := reverseBytesGeneratorByteOrder(crypto.GenerateIncreasingNonce([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}))
firstValue := generator()
if diff := cmp.Diff(firstValue, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}); diff != "" {
t.Errorf("Unexpected first value: %s", diff)
}
secondValue := generator()
if diff := cmp.Diff(secondValue, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}); diff != "" {
t.Errorf("Unexpected second value: %s", diff)
}
thirdValue := generator()
if diff := cmp.Diff(thirdValue, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}); diff != "" {
t.Errorf("Unexpected third value: %s", diff)
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorbase/errors.generated.go | transport/internet/tlsmirror/mirrorbase/errors.generated.go | package mirrorbase
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorbase/conn.go | transport/internet/tlsmirror/mirrorbase/conn.go | package mirrorbase
import (
"bufio"
"bytes"
"context"
"io"
"net"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/crypto"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror"
"github.com/v2fly/v2ray-core/v5/transport/internet/tlsmirror/mirrorcommon"
)
// NewMirroredTLSConn creates a new mirrored TLS connection.
// No stable interface
func NewMirroredTLSConn(ctx context.Context, clientConn net.Conn,
serverConn net.Conn, onC2SMessage, onS2CMessage tlsmirror.MessageHook,
closable common.Closable, explicitNonceDetection tlsmirror.ExplicitNonceDetection,
onC2SMessageTx, onS2CMessageTx tlsmirror.MessageHook,
) tlsmirror.InsertableTLSConn {
explicitNonceDetectionReady, explicitNonceDetectionOver := context.WithCancel(ctx)
c := &conn{
ctx: ctx,
clientConn: clientConn,
serverConn: serverConn,
c2sInsert: make(chan *tlsmirror.TLSRecord, 100),
s2cInsert: make(chan *tlsmirror.TLSRecord, 100),
OnC2SMessage: onC2SMessage,
OnS2CMessage: onS2CMessage,
explicitNonceDetection: explicitNonceDetection,
explicitNonceDetectionReady: explicitNonceDetectionReady,
explicitNonceDetectionOver: explicitNonceDetectionOver,
OnC2SMessageTx: onC2SMessageTx,
OnS2CMessageTx: onS2CMessageTx,
}
c.ctx, c.done = context.WithCancel(ctx)
go c.c2sWorker()
go c.s2cWorker()
go func() {
<-c.ctx.Done()
if closable != nil {
closable.Close()
}
c.clientConn.Close()
c.serverConn.Close()
}()
return c
}
type conn struct {
ctx context.Context
done context.CancelFunc
clientConn net.Conn
serverConn net.Conn
OnC2SMessage tlsmirror.MessageHook
OnS2CMessage tlsmirror.MessageHook
explicitNonceDetection tlsmirror.ExplicitNonceDetection
OnC2SMessageTx tlsmirror.MessageHook
OnS2CMessageTx tlsmirror.MessageHook
c2sInsert chan *tlsmirror.TLSRecord
s2cInsert chan *tlsmirror.TLSRecord
isClientRandomReady bool
ClientRandom [32]byte
isServerRandomReady bool
ServerRandom [32]byte
tls12ExplicitNonce *bool
explicitNonceDetectionReady context.Context
explicitNonceDetectionOver context.CancelFunc
c2sExplicitNonceCounterGenerator crypto.BytesGenerator
s2cExplicitNonceCounterGenerator crypto.BytesGenerator
}
func (c *conn) GetHandshakeRandom() ([]byte, []byte, error) {
// TODO: the value of c.isClientRandomReady, c.isServerRandomReady, c.ClientRandom, c.ServerRandom has incorrect memory consistency assumptions.
if !c.isClientRandomReady || !c.isServerRandomReady {
return nil, nil, newError("client random or server random not ready")
}
return c.ClientRandom[:], c.ServerRandom[:], nil
}
func (c *conn) Close() error {
c.done()
return nil
}
func (c *conn) InsertC2SMessage(message *tlsmirror.TLSRecord) error {
duplicatedRecord := mirrorcommon.DuplicateRecord(*message)
c.c2sInsert <- &duplicatedRecord
return nil
}
func (c *conn) InsertS2CMessage(message *tlsmirror.TLSRecord) error {
duplicatedRecord := mirrorcommon.DuplicateRecord(*message)
c.s2cInsert <- &duplicatedRecord
return nil
}
type bufPeeker struct {
buffer []byte
}
func (b *bufPeeker) Peek(n int) ([]byte, error) {
if len(b.buffer) < n {
return nil, newError("not enough data")
}
return b.buffer[:n], nil
}
type readerWithInitialData struct {
initialData []byte
innerReader io.Reader
}
func (r *readerWithInitialData) initialDataDrained() bool {
return len(r.initialData) == 0
}
func (r *readerWithInitialData) Read(p []byte) (n int, err error) {
if len(r.initialData) > 0 {
n = copy(p, r.initialData)
r.initialData = r.initialData[n:]
return n, nil
}
return r.innerReader.Read(p)
}
func (c *conn) c2sWorker() {
c2sHandshake, handshakeReminder, c2sReminderData, err := c.captureHandshake(c.clientConn, c.serverConn)
if err != nil {
c.done()
return
}
_ = c2sHandshake
_ = handshakeReminder
_ = c2sReminderData
serverConnectionWriter := bufio.NewWriter(c.serverConn)
_, err = io.Copy(serverConnectionWriter, bytes.NewReader(handshakeReminder))
if err != nil {
c.done()
newError("failed to copy handshake reminder").Base(err).AtWarning().WriteToLog()
return
}
clientHello, err := mirrorcommon.UnpackTLSClientHello(c2sHandshake.Fragment)
if err != nil {
c.done()
newError("failed to unpack client hello").Base(err).AtWarning().WriteToLog()
return
}
c.ClientRandom = clientHello.ClientRandom
c.isClientRandomReady = true
clientSocketReader := &readerWithInitialData{initialData: c2sReminderData, innerReader: c.clientConn}
clientSocket := bufio.NewReaderSize(clientSocketReader, 65536)
recordReader := mirrorcommon.NewTLSRecordStreamReader(clientSocket)
recordWriter := mirrorcommon.NewTLSRecordStreamWriter(serverConnectionWriter)
if len(c2sReminderData) == 0 {
err := serverConnectionWriter.Flush()
if err != nil {
c.done()
newError("failed to flush server connection writer").Base(err).AtWarning().WriteToLog()
return
}
}
go func() {
for c.ctx.Err() == nil {
var record *tlsmirror.TLSRecord
select {
case <-c.ctx.Done():
return
case record = <-c.c2sInsert:
// implicit memory consistency synchronization capture read for c.tls12ExplicitNonce
}
// memory consistency synchronization for value c.tls12ExplicitNonce is required!!!
if *c.tls12ExplicitNonce {
if record.RecordType == mirrorcommon.TLSRecord_RecordType_application_data ||
record.RecordType == mirrorcommon.TLSRecord_RecordType_alert {
if len(record.Fragment) >= 8 {
nonce := c.c2sExplicitNonceCounterGenerator()
copy(record.Fragment, nonce)
}
}
}
if c.OnC2SMessageTx != nil {
drop, err := c.OnC2SMessageTx(record)
if err != nil {
c.done()
newError("failed to process C2S message").Base(err).AtWarning().WriteToLog()
return
}
if drop {
continue
}
}
err := recordWriter.WriteRecord(record, false)
if err != nil {
c.done()
newError("failed to write C2S message").Base(err).AtWarning().WriteToLog()
return
}
if record.RecordType == mirrorcommon.TLSRecord_RecordType_alert {
c.done()
newError("alert sent, ending copy").AtWarning().WriteToLog()
return
}
}
}()
explicitNonceSessionAndChangeCipherSpecWasLastMessage := false
for c.ctx.Err() == nil {
record, err := recordReader.ReadNextRecord()
if err != nil {
c.done()
drainCopy(c.clientConn, nil, c.serverConn)
newError("failed to read TLS record").Base(err).AtWarning().WriteToLog()
return
}
if record.RecordType == mirrorcommon.TLSRecord_RecordType_change_cipher_spec {
// implicit memory consistency synchronization capture read for c.tls12ExplicitNonce
if c.explicitNonceDetectionReady.Err() == nil {
c.done()
drainCopy(c.clientConn, nil, c.serverConn)
newError("received client to server change cipher spec before server hello").Base(err).AtWarning().WriteToLog()
return
}
// memory consistency synchronization for value c.tls12ExplicitNonce is required!!!
if *c.tls12ExplicitNonce {
explicitNonceSessionAndChangeCipherSpecWasLastMessage = true
}
}
if record.RecordType == mirrorcommon.TLSRecord_RecordType_handshake &&
explicitNonceSessionAndChangeCipherSpecWasLastMessage {
// verify if the first 8 bytes are 0x00
if len(record.Fragment) < 8 || !bytes.Equal(record.Fragment[:8],
[]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}) {
newError("unexpected explicit nonce header at tls 12 finish").AtWarning().WriteToLog()
c.done()
drainCopy(c.clientConn, nil, c.serverConn)
return
}
c.c2sExplicitNonceCounterGenerator = reverseBytesGeneratorByteOrder(crypto.GenerateIncreasingNonce([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}))
}
if c.OnC2SMessage != nil {
drop, err := c.OnC2SMessage(record)
if err != nil {
c.done()
newError("failed to process C2S message").Base(err).AtWarning().WriteToLog()
drainCopy(c.clientConn, nil, c.serverConn)
return
}
if drop {
continue
}
}
duplicatedRecord := mirrorcommon.DuplicateRecord(*record)
c.c2sInsert <- &duplicatedRecord
}
drainCopy(c.serverConn, nil, c.clientConn)
}
func (c *conn) s2cWorker() {
// TODO: stick packets together, if they arrived so
s2cHandshake, handshakeReminder, s2cReminderData, err := c.captureHandshake(c.serverConn, c.clientConn)
if err != nil {
c.done()
return
}
_ = s2cHandshake
_ = handshakeReminder
_ = s2cReminderData
clientConnectionWriter := bufio.NewWriter(c.clientConn)
_, err = io.Copy(clientConnectionWriter, bytes.NewReader(handshakeReminder))
if err != nil {
c.done()
newError("failed to copy handshake reminder").Base(err).AtWarning().WriteToLog()
return
}
serverHello, err := mirrorcommon.UnpackTLSServerHello(s2cHandshake.Fragment)
if err != nil {
c.done()
newError("failed to unpack server hello").Base(err).AtWarning().WriteToLog()
drainCopy(c.clientConn, nil, c.serverConn)
return
}
c.ServerRandom = serverHello.ServerRandom
c.isServerRandomReady = true
isTLS12ExplicitNonce := c.explicitNonceDetection(serverHello.CipherSuite)
c.tls12ExplicitNonce = &isTLS12ExplicitNonce
// implicit memory consistency synchronization release write for c.tls12ExplicitNonce
c.explicitNonceDetectionOver()
_, err = c.OnS2CMessage(&s2cHandshake)
if err != nil {
newError("failed to process S2C server hello message").Base(err).AtWarning().WriteToLog()
drainCopy(c.clientConn, nil, c.serverConn)
c.done()
return
}
serverSocketReader := &readerWithInitialData{initialData: s2cReminderData, innerReader: c.serverConn}
serverSocket := bufio.NewReaderSize(serverSocketReader, 65536)
recordReader := mirrorcommon.NewTLSRecordStreamReader(serverSocket)
recordWriter := mirrorcommon.NewTLSRecordStreamWriter(clientConnectionWriter)
if len(s2cReminderData) == 0 {
err := clientConnectionWriter.Flush()
if err != nil {
newError("failed to flush client connection writer").Base(err).AtWarning().WriteToLog()
drainCopy(c.clientConn, nil, c.serverConn)
c.done()
return
}
}
go func() {
for c.ctx.Err() == nil {
var record *tlsmirror.TLSRecord
select {
case <-c.ctx.Done():
return
case record = <-c.s2cInsert:
// implicit memory consistency synchronization capture read for c.tls12ExplicitNonce
}
// memory consistency synchronization for value c.tls12ExplicitNonce is required!!!
if *c.tls12ExplicitNonce {
if record.RecordType == mirrorcommon.TLSRecord_RecordType_application_data ||
record.RecordType == mirrorcommon.TLSRecord_RecordType_alert {
if len(record.Fragment) >= 8 {
nonce := c.s2cExplicitNonceCounterGenerator()
copy(record.Fragment, nonce)
}
}
}
if c.OnS2CMessageTx != nil {
drop, err := c.OnS2CMessageTx(record)
if err != nil {
c.done()
newError("failed to process S2C message").Base(err).AtWarning().WriteToLog()
return
}
if drop {
continue
}
}
err := recordWriter.WriteRecord(record, false)
if err != nil {
c.done()
newError("failed to write S2C message").Base(err).AtWarning().WriteToLog()
return
}
if record.RecordType == mirrorcommon.TLSRecord_RecordType_alert {
c.done()
newError("alert sent, ending copy").AtWarning().WriteToLog()
return
}
}
}()
explicitNonceSessionAndChangeCipherSpecWasLastMessage := false
for c.ctx.Err() == nil {
record, err := recordReader.ReadNextRecord()
if err != nil {
newError("failed to read TLS record").Base(err).AtWarning().WriteToLog()
c.done()
drainCopy(c.clientConn, nil, c.serverConn)
return
}
if record.RecordType == mirrorcommon.TLSRecord_RecordType_change_cipher_spec {
if *c.tls12ExplicitNonce {
explicitNonceSessionAndChangeCipherSpecWasLastMessage = true
}
}
if record.RecordType == mirrorcommon.TLSRecord_RecordType_handshake &&
explicitNonceSessionAndChangeCipherSpecWasLastMessage {
// verify if the first 8 bytes are 0x00
if len(record.Fragment) < 8 || !bytes.Equal(record.Fragment[:8],
[]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}) {
newError("unexpected explicit nonce header at tls 12 finish").AtWarning().WriteToLog()
c.done()
drainCopy(c.clientConn, nil, c.serverConn)
return
}
c.s2cExplicitNonceCounterGenerator = reverseBytesGeneratorByteOrder(crypto.GenerateIncreasingNonce([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}))
}
if c.OnS2CMessage != nil {
drop, err := c.OnS2CMessage(record)
if err != nil {
c.done()
newError("failed to process S2C message").Base(err).AtWarning().WriteToLog()
drainCopy(c.clientConn, nil, c.serverConn)
return
}
if drop {
continue
}
}
duplicatedRecord := mirrorcommon.DuplicateRecord(*record)
c.s2cInsert <- &duplicatedRecord
}
drainCopy(c.clientConn, nil, c.serverConn)
}
func drainCopy(dst io.Writer, initData []byte, src io.Reader) {
if initData != nil {
_, err := io.Copy(dst, bytes.NewReader(initData))
if err != nil {
newError("failed to drain copy").Base(err).AtWarning().WriteToLog()
}
}
_, err := io.Copy(dst, src)
if err != nil {
newError("failed to drain copy").Base(err).AtWarning().WriteToLog()
}
}
type rejectionDecisionMaker struct{}
func (r *rejectionDecisionMaker) TestIfReject(record *tlsmirror.TLSRecord, readyFields int) error {
if readyFields >= 1 {
if record.RecordType != mirrorcommon.TLSRecord_RecordType_handshake {
return newError("unexpected record type").AtWarning()
}
}
if readyFields >= 2 {
switch record.LegacyProtocolVersion[0] {
case 0x01:
case 0x02:
case 0x03:
if record.LegacyProtocolVersion[1] > 0x03 {
return newError("unexpected minor protocol version").AtWarning()
}
default:
return newError("unexpected major protocol version").AtWarning()
}
}
return nil
}
func (c *conn) captureHandshake(sourceConn, mirrorConn net.Conn) (handshake tlsmirror.TLSRecord, handshakeReminder, rest []byte, reterr error) {
var readBuffer [65536]byte
var nextRead int
for c.ctx.Err() == nil {
n, err := sourceConn.Read(readBuffer[nextRead:])
if err != nil {
c.done()
reterr = newError("failed to read from source connection").Base(err).AtWarning()
return handshake, nil, nil, reterr
}
handshakeRejectionDecisionMaker := &rejectionDecisionMaker{}
result, tryAgainLen, processed, err := mirrorcommon.PeekTLSRecord(&bufPeeker{buffer: readBuffer[:nextRead+n]}, handshakeRejectionDecisionMaker)
if processed == 0 {
if tryAgainLen == 0 {
// TODO: directly copy
drainCopy(mirrorConn, readBuffer[:nextRead+n], sourceConn)
c.done()
reterr = newError("failed to peek tls record").Base(err).AtWarning()
return handshake, nil, nil, reterr
}
_, err = io.Copy(mirrorConn, bytes.NewReader(readBuffer[nextRead:nextRead+n]))
if err != nil {
c.done()
newError("failed to copy to server connection").Base(err).AtWarning().WriteToLog()
return handshake, nil, nil, reterr
}
nextRead += n
} else {
// Parse the client hello
if result.RecordType != mirrorcommon.TLSRecord_RecordType_handshake {
c.done()
reterr = newError("unexpected record type").AtWarning()
return handshake, nil, nil, reterr
}
handshake = result
handshakeReminder = readBuffer[nextRead:processed]
rest = readBuffer[processed : nextRead+n]
return handshake, handshakeReminder, rest, nil
}
}
reterr = newError("context is done")
return handshake, nil, nil, reterr
}
func (c *conn) GetApplicationDataExplicitNonceReservedOverheadHeaderLength() (int, error) {
if c.tls12ExplicitNonce == nil {
return 0, newError("explicit nonce info is not ready")
}
if *c.tls12ExplicitNonce {
return 8, nil
}
return 0, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/tlsmirror/mirrorbase/crypto.go | transport/internet/tlsmirror/mirrorbase/crypto.go | package mirrorbase
import (
"github.com/v2fly/v2ray-core/v5/common/crypto"
)
func reverseBytesGeneratorByteOrder(generator crypto.BytesGenerator) crypto.BytesGenerator {
var reverseResult [8]byte
return func() []byte {
result := generator()
if len(result) != 8 {
panic("reverseBytesGeneratorByteOrder requires a generator that returns exactly 8 bytes")
}
for i := 0; i < 8; i++ {
reverseResult[i] = result[7-i]
}
return reverseResult[:]
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/security/errors.generated.go | transport/internet/security/errors.generated.go | package security
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/security/util.go | transport/internet/security/util.go | package security
import (
"context"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
func CreateSecurityEngineFromSettings(context context.Context, settings *internet.MemoryStreamConfig) (Engine, error) {
if settings == nil || settings.SecurityType == "" {
return nil, nil
}
securityEngine, err := common.CreateObject(context, settings.SecuritySettings)
if err != nil {
return nil, newError("unable to create security engine from security settings").Base(err)
}
securityEngineTyped, ok := securityEngine.(Engine)
if !ok {
return nil, newError("type assertion error when create security engine from security settings")
}
return securityEngineTyped, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/security/security.go | transport/internet/security/security.go | package security
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
import (
"github.com/v2fly/v2ray-core/v5/common/net"
)
type Engine interface {
Client(conn net.Conn, opts ...Option) (Conn, error)
}
type Conn interface {
net.Conn
}
type Option interface {
isSecurityOption()
}
type OptionWithALPN struct {
ALPNs []string
}
func (a OptionWithALPN) isSecurityOption() {
}
type OptionWithDestination struct {
Dest net.Destination
}
func (a OptionWithDestination) isSecurityOption() {
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/security/connprop.go | transport/internet/security/connprop.go | package security
type ConnectionApplicationProtocol interface {
GetConnectionApplicationProtocol() (string, error)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/httpupgrade/hub.go | transport/internet/httpupgrade/hub.go | package httpupgrade
import (
"bufio"
"bytes"
"context"
"encoding/base64"
"net/http"
"strings"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/transportcommon"
)
type server struct {
config *Config
addConn internet.ConnHandler
innnerListener net.Listener
}
func (s *server) Close() error {
return s.innnerListener.Close()
}
func (s *server) Addr() net.Addr {
return nil
}
func (s *server) Handle(conn net.Conn) (internet.Connection, error) {
connReader := bufio.NewReader(conn)
req, err := http.ReadRequest(connReader)
if err != nil {
return nil, err
}
connection := strings.ToLower(req.Header.Get("Connection"))
upgrade := strings.ToLower(req.Header.Get("Upgrade"))
if connection != "upgrade" || upgrade != "websocket" {
_ = conn.Close()
return nil, newError("unrecognized request")
}
resp := &http.Response{
Status: "101 Switching Protocols",
StatusCode: 101,
Proto: "HTTP/1.1",
ProtoMajor: 1,
ProtoMinor: 1,
Header: http.Header{},
}
resp.Header.Set("Connection", "upgrade")
resp.Header.Set("Upgrade", "websocket")
err = resp.Write(conn)
if err != nil {
_ = conn.Close()
return nil, err
}
if s.config.MaxEarlyData != 0 {
if s.config.EarlyDataHeaderName == "" {
return nil, newError("EarlyDataHeaderName is not set")
}
earlyData := req.Header.Get(s.config.EarlyDataHeaderName)
if earlyData != "" {
earlyDataBytes, err := base64.URLEncoding.DecodeString(earlyData)
if err != nil {
return nil, err
}
return newConnectionWithPendingRead(conn, conn.RemoteAddr(), bytes.NewReader(earlyDataBytes)), nil
}
}
return internet.Connection(conn), nil
}
func (s *server) keepAccepting() {
for {
conn, err := s.innnerListener.Accept()
if err != nil {
return
}
handledConn, err := s.Handle(conn)
if err != nil {
newError("failed to handle request").Base(err).WriteToLog()
continue
}
s.addConn(handledConn)
}
}
func listenHTTPUpgrade(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, addConn internet.ConnHandler) (internet.Listener, error) {
transportConfiguration := streamSettings.ProtocolSettings.(*Config)
serverInstance := &server{config: transportConfiguration, addConn: addConn}
listener, err := transportcommon.ListenWithSecuritySettings(ctx, address, port, streamSettings)
if err != nil {
return nil, newError("failed to listen on ", address, ":", port).Base(err)
}
serverInstance.innnerListener = listener
go serverInstance.keepAccepting()
return serverInstance, nil
}
func init() {
common.Must(internet.RegisterTransportListener(protocolName, listenHTTPUpgrade))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/httpupgrade/dialer.go | transport/internet/httpupgrade/dialer.go | package httpupgrade
import (
"bufio"
"context"
"encoding/base64"
"io"
"net/http"
"strings"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/transportcommon"
)
func dialhttpUpgrade(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (net.Conn, error) {
transportConfiguration := streamSettings.ProtocolSettings.(*Config)
dialer := func(earlyData []byte) (net.Conn, io.Reader, error) {
conn, err := transportcommon.DialWithSecuritySettings(ctx, dest, streamSettings)
if err != nil {
return nil, nil, newError("failed to dial request to ", dest).Base(err)
}
req, err := http.NewRequest("GET", transportConfiguration.GetNormalizedPath(), nil)
if err != nil {
return nil, nil, err
}
req.Header.Set("Connection", "upgrade")
req.Header.Set("Upgrade", "websocket")
req.Host = transportConfiguration.Host
if transportConfiguration.Header != nil {
for _, value := range transportConfiguration.Header {
req.Header.Set(value.Key, value.Value)
}
}
earlyDataSize := len(earlyData)
if earlyDataSize > int(transportConfiguration.MaxEarlyData) {
earlyDataSize = int(transportConfiguration.MaxEarlyData)
}
if len(earlyData) > 0 {
if transportConfiguration.EarlyDataHeaderName == "" {
return nil, nil, newError("EarlyDataHeaderName is not set")
}
req.Header.Set(transportConfiguration.EarlyDataHeaderName, base64.URLEncoding.EncodeToString(earlyData))
}
err = req.Write(conn)
if err != nil {
return nil, nil, err
}
if earlyData != nil && len(earlyData[earlyDataSize:]) > 0 {
_, err = conn.Write(earlyData[earlyDataSize:])
if err != nil {
return nil, nil, newError("failed to finish write early data").Base(err)
}
}
bufferedConn := bufio.NewReader(conn)
resp, err := http.ReadResponse(bufferedConn, req) // nolint:bodyclose
if err != nil {
return nil, nil, err
}
if resp.Status == "101 Switching Protocols" &&
strings.ToLower(resp.Header.Get("Upgrade")) == "websocket" &&
strings.ToLower(resp.Header.Get("Connection")) == "upgrade" {
earlyReplyReader := io.LimitReader(bufferedConn, int64(bufferedConn.Buffered()))
return conn, earlyReplyReader, nil
}
return nil, nil, newError("unrecognized reply")
}
if transportConfiguration.MaxEarlyData == 0 {
conn, earlyReplyReader, err := dialer(nil)
if err != nil {
return nil, err
}
remoteAddr := conn.RemoteAddr()
return newConnectionWithPendingRead(conn, remoteAddr, earlyReplyReader), nil
}
return newConnectionWithDelayedDial(dialer), nil
}
func dial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) {
newError("creating connection to ", dest).WriteToLog(session.ExportIDToError(ctx))
conn, err := dialhttpUpgrade(ctx, dest, streamSettings)
if err != nil {
return nil, newError("failed to dial request to ", dest).Base(err)
}
return internet.Connection(conn), nil
}
func init() {
common.Must(internet.RegisterTransportDialer(protocolName, dial))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/httpupgrade/errors.generated.go | transport/internet/httpupgrade/errors.generated.go | package httpupgrade
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/httpupgrade/config.go | transport/internet/httpupgrade/config.go | package httpupgrade
func (c *Config) GetNormalizedPath() string {
path := c.Path
if path == "" {
return "/"
}
if path[0] != '/' {
return "/" + path
}
return path
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/httpupgrade/connection.go | transport/internet/httpupgrade/connection.go | package httpupgrade
import (
"context"
"io"
"time"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/serial"
)
type connection struct {
conn net.Conn
reader io.Reader
remoteAddr net.Addr
shouldWait bool
delayedDialFinish context.Context
finishedDial context.CancelFunc
dialer delayedDialer
}
type delayedDialer func(earlyData []byte) (conn net.Conn, earlyReply io.Reader, err error)
func newConnectionWithPendingRead(conn net.Conn, remoteAddr net.Addr, earlyReplyReader io.Reader) *connection {
return &connection{
conn: conn,
remoteAddr: remoteAddr,
reader: earlyReplyReader,
}
}
func newConnectionWithDelayedDial(dialer delayedDialer) *connection {
ctx, cancel := context.WithCancel(context.Background())
return &connection{
shouldWait: true,
delayedDialFinish: ctx,
finishedDial: cancel,
dialer: dialer,
}
}
// Read implements net.Conn.Read()
func (c *connection) Read(b []byte) (int, error) {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
return 0, newError("unable to read delayed dial websocket connection as it do not exist")
}
}
if c.reader != nil {
n, err := c.reader.Read(b)
if err == io.EOF {
c.reader = nil
return c.conn.Read(b)
}
return n, err
}
return c.conn.Read(b)
}
// Write implements io.Writer.
func (c *connection) Write(b []byte) (int, error) {
if c.shouldWait {
var err error
var earlyReply io.Reader
c.conn, earlyReply, err = c.dialer(b)
if earlyReply != nil {
c.reader = earlyReply
}
c.finishedDial()
if err != nil {
return 0, newError("Unable to proceed with delayed write").Base(err)
}
c.remoteAddr = c.conn.RemoteAddr()
c.shouldWait = false
return len(b), nil
}
return c.conn.Write(b)
}
func (c *connection) WriteMultiBuffer(mb buf.MultiBuffer) error {
mb = buf.Compact(mb)
mb, err := buf.WriteMultiBuffer(c, mb)
buf.ReleaseMulti(mb)
return err
}
func (c *connection) Close() error {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
return newError("unable to close delayed dial websocket connection as it do not exist")
}
}
var closeErrors []interface{}
if err := c.conn.Close(); err != nil {
closeErrors = append(closeErrors, err)
}
if len(closeErrors) > 0 {
return newError("failed to close connection").Base(newError(serial.Concat(closeErrors...)))
}
return nil
}
func (c *connection) LocalAddr() net.Addr {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
newError("websocket transport is not materialized when LocalAddr() is called").AtWarning().WriteToLog()
return &net.UnixAddr{
Name: "@placeholder",
Net: "unix",
}
}
}
return c.conn.LocalAddr()
}
func (c *connection) RemoteAddr() net.Addr {
return c.remoteAddr
}
func (c *connection) SetDeadline(t time.Time) error {
if err := c.SetReadDeadline(t); err != nil {
return err
}
return c.SetWriteDeadline(t)
}
func (c *connection) SetReadDeadline(t time.Time) error {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
newError("httpupgrade transport is not materialized when SetReadDeadline() is called").AtWarning().WriteToLog()
return nil
}
}
return c.conn.SetReadDeadline(t)
}
func (c *connection) SetWriteDeadline(t time.Time) error {
if c.shouldWait {
<-c.delayedDialFinish.Done()
if c.conn == nil {
newError("httpupgrade transport is not materialized when SetWriteDeadline() is called").AtWarning().WriteToLog()
return nil
}
}
return c.conn.SetWriteDeadline(t)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/httpupgrade/httpupgrade.go | transport/internet/httpupgrade/httpupgrade.go | package httpupgrade
import (
"context"
"github.com/v2fly/v2ray-core/v5/common"
)
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
const protocolName = "httpupgrade"
func init() {
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
return nil, newError("httpupgrade is a transport protocol.")
}))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/httpupgrade/config.pb.go | transport/internet/httpupgrade/config.pb.go | package httpupgrade
import (
_ "github.com/v2fly/v2ray-core/v5/common/protoext"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Header struct {
state protoimpl.MessageState `protogen:"open.v1"`
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Header) Reset() {
*x = Header{}
mi := &file_transport_internet_httpupgrade_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Header) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Header) ProtoMessage() {}
func (x *Header) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_httpupgrade_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Header.ProtoReflect.Descriptor instead.
func (*Header) Descriptor() ([]byte, []int) {
return file_transport_internet_httpupgrade_config_proto_rawDescGZIP(), []int{0}
}
func (x *Header) GetKey() string {
if x != nil {
return x.Key
}
return ""
}
func (x *Header) GetValue() string {
if x != nil {
return x.Value
}
return ""
}
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
Host string `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"`
MaxEarlyData int32 `protobuf:"varint,3,opt,name=max_early_data,json=maxEarlyData,proto3" json:"max_early_data,omitempty"`
EarlyDataHeaderName string `protobuf:"bytes,4,opt,name=early_data_header_name,json=earlyDataHeaderName,proto3" json:"early_data_header_name,omitempty"`
Header []*Header `protobuf:"bytes,5,rep,name=header,proto3" json:"header,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_transport_internet_httpupgrade_config_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_transport_internet_httpupgrade_config_proto_msgTypes[1]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_transport_internet_httpupgrade_config_proto_rawDescGZIP(), []int{1}
}
func (x *Config) GetPath() string {
if x != nil {
return x.Path
}
return ""
}
func (x *Config) GetHost() string {
if x != nil {
return x.Host
}
return ""
}
func (x *Config) GetMaxEarlyData() int32 {
if x != nil {
return x.MaxEarlyData
}
return 0
}
func (x *Config) GetEarlyDataHeaderName() string {
if x != nil {
return x.EarlyDataHeaderName
}
return ""
}
func (x *Config) GetHeader() []*Header {
if x != nil {
return x.Header
}
return nil
}
var File_transport_internet_httpupgrade_config_proto protoreflect.FileDescriptor
const file_transport_internet_httpupgrade_config_proto_rawDesc = "" +
"\n" +
"+transport/internet/httpupgrade/config.proto\x121v2ray.core.transport.internet.request.httpupgrade\x1a common/protoext/extensions.proto\"0\n" +
"\x06Header\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
"\x05value\x18\x02 \x01(\tR\x05value\"\x80\x02\n" +
"\x06Config\x12\x12\n" +
"\x04path\x18\x01 \x01(\tR\x04path\x12\x12\n" +
"\x04host\x18\x02 \x01(\tR\x04host\x12$\n" +
"\x0emax_early_data\x18\x03 \x01(\x05R\fmaxEarlyData\x123\n" +
"\x16early_data_header_name\x18\x04 \x01(\tR\x13earlyDataHeaderName\x12Q\n" +
"\x06header\x18\x05 \x03(\v29.v2ray.core.transport.internet.request.httpupgrade.HeaderR\x06header: \x82\xb5\x18\x1c\n" +
"\ttransport\x12\vhttpupgrade\x90\xff)\x01B\x9c\x01\n" +
"-com.v2ray.core.transport.internet.httpupgradeP\x01Z=github.com/v2fly/v2ray-core/v5/transport/internet/httpupgrade\xaa\x02)V2Ray.Core.Transport.Internet.HttpUpgradeb\x06proto3"
var (
file_transport_internet_httpupgrade_config_proto_rawDescOnce sync.Once
file_transport_internet_httpupgrade_config_proto_rawDescData []byte
)
func file_transport_internet_httpupgrade_config_proto_rawDescGZIP() []byte {
file_transport_internet_httpupgrade_config_proto_rawDescOnce.Do(func() {
file_transport_internet_httpupgrade_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_httpupgrade_config_proto_rawDesc), len(file_transport_internet_httpupgrade_config_proto_rawDesc)))
})
return file_transport_internet_httpupgrade_config_proto_rawDescData
}
var file_transport_internet_httpupgrade_config_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_transport_internet_httpupgrade_config_proto_goTypes = []any{
(*Header)(nil), // 0: v2ray.core.transport.internet.request.httpupgrade.Header
(*Config)(nil), // 1: v2ray.core.transport.internet.request.httpupgrade.Config
}
var file_transport_internet_httpupgrade_config_proto_depIdxs = []int32{
0, // 0: v2ray.core.transport.internet.request.httpupgrade.Config.header:type_name -> v2ray.core.transport.internet.request.httpupgrade.Header
1, // [1:1] is the sub-list for method output_type
1, // [1:1] is the sub-list for method input_type
1, // [1:1] is the sub-list for extension type_name
1, // [1:1] is the sub-list for extension extendee
0, // [0:1] is the sub-list for field type_name
}
func init() { file_transport_internet_httpupgrade_config_proto_init() }
func file_transport_internet_httpupgrade_config_proto_init() {
if File_transport_internet_httpupgrade_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_httpupgrade_config_proto_rawDesc), len(file_transport_internet_httpupgrade_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 2,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_transport_internet_httpupgrade_config_proto_goTypes,
DependencyIndexes: file_transport_internet_httpupgrade_config_proto_depIdxs,
MessageInfos: file_transport_internet_httpupgrade_config_proto_msgTypes,
}.Build()
File_transport_internet_httpupgrade_config_proto = out.File
file_transport_internet_httpupgrade_config_proto_goTypes = nil
file_transport_internet_httpupgrade_config_proto_depIdxs = nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/transportcommon/listener.go | transport/internet/transportcommon/listener.go | package transportcommon
import (
"context"
"crypto/tls"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/transport/internet"
v2tls "github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
func ListenWithSecuritySettings(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig) (
net.Listener, error,
) {
var l net.Listener
transportEnvironment := envctx.EnvironmentFromContext(ctx).(environment.TransportEnvironment)
transportListener := transportEnvironment.Listener()
if port == net.Port(0) { // unix
if !address.Family().IsDomain() {
return nil, newError("invalid address for unix domain socket: ", address)
}
listener, err := transportListener.Listen(ctx, &net.UnixAddr{
Name: address.Domain(),
Net: "unix",
}, streamSettings.SocketSettings)
if err != nil {
return nil, newError("failed to listen unix domain socket on ", address).Base(err)
}
newError("listening unix domain socket on ", address).WriteToLog(session.ExportIDToError(ctx))
l = listener
} else { // tcp
listener, err := transportListener.Listen(ctx, &net.TCPAddr{
IP: address.IP(),
Port: int(port),
}, streamSettings.SocketSettings)
if err != nil {
return nil, newError("failed to listen TCP on ", address, ":", port).Base(err)
}
newError("listening TCP on ", address, ":", port).WriteToLog(session.ExportIDToError(ctx))
l = listener
}
if streamSettings.SocketSettings != nil && streamSettings.SocketSettings.AcceptProxyProtocol {
newError("accepting PROXY protocol").AtWarning().WriteToLog(session.ExportIDToError(ctx))
}
if config := v2tls.ConfigFromStreamSettings(streamSettings); config != nil {
if tlsConfig := config.GetTLSConfig(); tlsConfig != nil {
l = tls.NewListener(l, tlsConfig)
}
}
return l, nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/transportcommon/tansportcommon.go | transport/internet/transportcommon/tansportcommon.go | package transportcommon
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/transportcommon/dialer.go | transport/internet/transportcommon/dialer.go | package transportcommon
import (
"context"
"github.com/v2fly/v2ray-core/v5/transport/internet/security"
"github.com/v2fly/v2ray-core/v5/common/environment"
"github.com/v2fly/v2ray-core/v5/common/environment/envctx"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
)
func DialWithSecuritySettings(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) {
transportEnvironment := envctx.EnvironmentFromContext(ctx).(environment.TransportEnvironment)
dialer := transportEnvironment.Dialer()
conn, err := dialer.Dial(ctx, nil, dest, streamSettings.SocketSettings)
if err != nil {
return nil, newError("failed to dial to ", dest).Base(err)
}
securityEngine, err := security.CreateSecurityEngineFromSettings(ctx, streamSettings)
if err != nil {
return nil, newError("unable to create security engine").Base(err)
}
if securityEngine != nil {
conn, err = securityEngine.Client(conn, security.OptionWithDestination{Dest: dest})
if err != nil {
return nil, newError("unable to create security protocol client from security engine").Base(err)
}
}
return internet.Connection(conn), nil
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/transportcommon/errors.generated.go | transport/internet/transportcommon/errors.generated.go | package transportcommon
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/transportcommon/httpDialer.go | transport/internet/transportcommon/httpDialer.go | package transportcommon
import (
"context"
"crypto/tls"
"errors"
"fmt"
"net"
"net/http"
"sync"
"time"
"golang.org/x/net/http2"
"github.com/v2fly/v2ray-core/v5/transport/internet/security"
)
type DialerFunc func(ctx context.Context, addr string) (net.Conn, error)
func NewALPNAwareHTTPRoundTripper(ctx context.Context, dialer DialerFunc,
backdropTransport http.RoundTripper,
) http.RoundTripper {
return NewALPNAwareHTTPRoundTripperWithH2Pool(ctx, dialer, backdropTransport, 1)
}
// NewALPNAwareHTTPRoundTripperWithH2Pool creates an instance of RoundTripper that dial to remote HTTPS endpoint with
// an alternative version of TLS implementation.
func NewALPNAwareHTTPRoundTripperWithH2Pool(ctx context.Context, dialer DialerFunc,
backdropTransport http.RoundTripper,
h2PoolSize int,
) http.RoundTripper {
rtImpl := &alpnAwareHTTPRoundTripperImpl{
connectWithH1: map[string]bool{},
backdropTransport: backdropTransport,
pendingConn: map[pendingConnKey]*unclaimedConnection{},
dialer: dialer,
ctx: ctx,
}
rtImpl.init()
return rtImpl
}
type alpnAwareHTTPRoundTripperImpl struct {
accessConnectWithH1 sync.Mutex
connectWithH1 map[string]bool
httpsH1Transport http.RoundTripper
httpsH2Transport http.RoundTripper
backdropTransport http.RoundTripper
accessDialingConnection sync.Mutex
pendingConn map[pendingConnKey]*unclaimedConnection
ctx context.Context
dialer DialerFunc
h2PoolSize int
}
type pendingConnKey struct {
isH2 bool
dest string
}
var (
errEAGAIN = errors.New("incorrect ALPN negotiated, try again with another ALPN")
errEAGAINTooMany = errors.New("incorrect ALPN negotiated")
errExpired = errors.New("connection have expired")
)
func (r *alpnAwareHTTPRoundTripperImpl) RoundTrip(req *http.Request) (*http.Response, error) {
if req.URL.Scheme != "https" {
return r.backdropTransport.RoundTrip(req)
}
for retryCount := 0; retryCount < 5; retryCount++ {
effectivePort := req.URL.Port()
if effectivePort == "" {
effectivePort = "443"
}
if r.getShouldConnectWithH1(fmt.Sprintf("%v:%v", req.URL.Hostname(), effectivePort)) {
resp, err := r.httpsH1Transport.RoundTrip(req)
if errors.Is(err, errEAGAIN) {
continue
}
return resp, err
}
resp, err := r.httpsH2Transport.RoundTrip(req)
if errors.Is(err, errEAGAIN) {
continue
}
return resp, err
}
return nil, errEAGAINTooMany
}
func (r *alpnAwareHTTPRoundTripperImpl) getShouldConnectWithH1(domainName string) bool {
r.accessConnectWithH1.Lock()
defer r.accessConnectWithH1.Unlock()
if value, set := r.connectWithH1[domainName]; set {
return value
}
return false
}
func (r *alpnAwareHTTPRoundTripperImpl) setShouldConnectWithH1(domainName string) {
r.accessConnectWithH1.Lock()
defer r.accessConnectWithH1.Unlock()
r.connectWithH1[domainName] = true
}
func (r *alpnAwareHTTPRoundTripperImpl) clearShouldConnectWithH1(domainName string) {
r.accessConnectWithH1.Lock()
defer r.accessConnectWithH1.Unlock()
r.connectWithH1[domainName] = false
}
func getPendingConnectionID(dest string, alpnIsH2 bool) pendingConnKey {
return pendingConnKey{isH2: alpnIsH2, dest: dest}
}
func (r *alpnAwareHTTPRoundTripperImpl) putConn(addr string, alpnIsH2 bool, conn net.Conn) {
connID := getPendingConnectionID(addr, alpnIsH2)
r.pendingConn[connID] = NewUnclaimedConnection(conn, time.Minute)
}
func (r *alpnAwareHTTPRoundTripperImpl) getConn(addr string, alpnIsH2 bool) net.Conn {
connID := getPendingConnectionID(addr, alpnIsH2)
if conn, ok := r.pendingConn[connID]; ok {
delete(r.pendingConn, connID)
if claimedConnection, err := conn.claimConnection(); err == nil {
return claimedConnection
}
}
return nil
}
func (r *alpnAwareHTTPRoundTripperImpl) dialOrGetTLSWithExpectedALPN(ctx context.Context, addr string, expectedH2 bool) (net.Conn, error) {
r.accessDialingConnection.Lock()
defer r.accessDialingConnection.Unlock()
if r.getShouldConnectWithH1(addr) == expectedH2 {
return nil, errEAGAIN
}
// Get a cached connection if possible to reduce preflight connection closed without sending data
if gconn := r.getConn(addr, expectedH2); gconn != nil {
return gconn, nil
}
conn, err := r.dialTLS(ctx, addr)
if err != nil {
return nil, err
}
protocol := ""
if connAPLNGetter, ok := conn.(security.ConnectionApplicationProtocol); ok {
connectionALPN, err := connAPLNGetter.GetConnectionApplicationProtocol()
if err != nil {
return nil, newError("failed to get connection ALPN").Base(err).AtWarning()
}
protocol = connectionALPN
}
protocolIsH2 := protocol == http2.NextProtoTLS
if protocolIsH2 == expectedH2 {
return conn, err
}
r.putConn(addr, protocolIsH2, conn)
if protocolIsH2 {
r.clearShouldConnectWithH1(addr)
} else {
r.setShouldConnectWithH1(addr)
}
return nil, errEAGAIN
}
func (r *alpnAwareHTTPRoundTripperImpl) dialTLS(ctx context.Context, addr string) (net.Conn, error) {
_ = ctx
return r.dialer(r.ctx, addr)
}
func (r *alpnAwareHTTPRoundTripperImpl) init() {
if r.h2PoolSize >= 2 {
r.httpsH2Transport = newH2TransportPool(int64(r.h2PoolSize), func() *http2.Transport {
return &http2.Transport{
DialTLS: func(network, addr string, cfg *tls.Config) (net.Conn, error) {
return r.dialOrGetTLSWithExpectedALPN(context.Background(), addr, true)
},
}
})
} else {
r.httpsH2Transport = &http2.Transport{
DialTLS: func(network, addr string, cfg *tls.Config) (net.Conn, error) {
return r.dialOrGetTLSWithExpectedALPN(context.Background(), addr, true)
},
}
}
r.httpsH1Transport = &http.Transport{
DialTLSContext: func(ctx context.Context, network string, addr string) (net.Conn, error) {
return r.dialOrGetTLSWithExpectedALPN(ctx, addr, false)
},
}
}
func NewUnclaimedConnection(conn net.Conn, expireTime time.Duration) *unclaimedConnection {
c := &unclaimedConnection{
Conn: conn,
}
time.AfterFunc(expireTime, c.tick)
return c
}
type unclaimedConnection struct {
net.Conn
claimed bool
access sync.Mutex
}
func (c *unclaimedConnection) claimConnection() (net.Conn, error) {
c.access.Lock()
defer c.access.Unlock()
if !c.claimed {
c.claimed = true
return c.Conn, nil
}
return nil, errExpired
}
func (c *unclaimedConnection) tick() {
c.access.Lock()
defer c.access.Unlock()
if !c.claimed {
c.claimed = true
c.Conn.Close() //nolint: staticcheck
c.Conn = nil
}
}
type h2TransportFactory func() *http2.Transport
func newH2TransportPool(size int64, h2factory h2TransportFactory) *h2TransportPool {
return &h2TransportPool{
pool: make([]*http2.Transport, size),
size: size,
h2factory: h2factory,
}
}
type h2TransportPool struct {
pool []*http2.Transport
h2factory h2TransportFactory
usageCount int64
size int64
}
func (h *h2TransportPool) RoundTrip(request *http.Request) (*http.Response, error) {
currentSlot := h.usageCount % h.size
h.usageCount++
if h.pool[currentSlot] == nil {
h.pool[currentSlot] = h.h2factory()
}
return h.pool[currentSlot].RoundTrip(request)
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/hysteria2/hub.go | transport/internet/hysteria2/hub.go | package hysteria2
import (
"context"
"github.com/apernet/quic-go"
"github.com/apernet/quic-go/http3"
hyServer "github.com/v2fly/hysteria/core/v2/server"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
// Listener is an internet.Listener that listens for TCP connections.
type Listener struct {
hyServer hyServer.Server
rawConn net.PacketConn
addConn internet.ConnHandler
}
// Addr implements internet.Listener.Addr.
func (l *Listener) Addr() net.Addr {
return l.rawConn.LocalAddr()
}
// Close implements internet.Listener.Close.
func (l *Listener) Close() error {
return l.hyServer.Close()
}
func (l *Listener) StreamHijacker(ft http3.FrameType, conn quic.Connection, stream quic.Stream, err error) (bool, error) {
// err always == nil
tcpConn := &HyConn{
stream: stream,
local: conn.LocalAddr(),
remote: conn.RemoteAddr(),
}
l.addConn(tcpConn)
return true, nil
}
func (l *Listener) UDPHijacker(entry *hyServer.UdpSessionEntry, originalAddr string) {
addr, err := net.ResolveUDPAddr("udp", originalAddr)
if err != nil {
return
}
udpConn := &HyConn{
IsUDPExtension: true,
IsServer: true,
ServerUDPSession: entry,
remote: addr,
local: l.rawConn.LocalAddr(),
}
l.addConn(udpConn)
}
// Listen creates a new Listener based on configurations.
func Listen(ctx context.Context, address net.Address, port net.Port, streamSettings *internet.MemoryStreamConfig, handler internet.ConnHandler) (internet.Listener, error) {
tlsConfig, err := GetServerTLSConfig(streamSettings)
if err != nil {
return nil, err
}
if address.Family().IsDomain() {
return nil, nil
}
config := streamSettings.ProtocolSettings.(*Config)
rawConn, err := internet.ListenSystemPacket(context.Background(),
&net.UDPAddr{
IP: address.IP(),
Port: int(port),
}, streamSettings.SocketSettings)
if err != nil {
return nil, err
}
listener := &Listener{
rawConn: rawConn,
addConn: handler,
}
hyServer, err := hyServer.NewServer(&hyServer.Config{
Conn: rawConn,
TLSConfig: *tlsConfig,
DisableUDP: !config.GetUseUdpExtension(),
Authenticator: &Authenticator{Password: config.GetPassword()},
StreamHijacker: listener.StreamHijacker, // acceptStreams
BandwidthConfig: hyServer.BandwidthConfig{MaxTx: config.Congestion.GetUpMbps() * MBps, MaxRx: config.GetCongestion().GetDownMbps() * MBps},
UdpSessionHijacker: listener.UDPHijacker, // acceptUDPSession
IgnoreClientBandwidth: config.GetIgnoreClientBandwidth(),
})
if err != nil {
return nil, err
}
listener.hyServer = hyServer
go hyServer.Serve()
return listener, nil
}
func GetServerTLSConfig(streamSettings *internet.MemoryStreamConfig) (*hyServer.TLSConfig, error) {
config := tls.ConfigFromStreamSettings(streamSettings)
if config == nil {
return nil, newError(Hy2MustNeedTLS)
}
tlsConfig := config.GetTLSConfig()
return &hyServer.TLSConfig{Certificates: tlsConfig.Certificates, GetCertificate: tlsConfig.GetCertificate}, nil
}
type Authenticator struct {
Password string
}
func (a *Authenticator) Authenticate(addr net.Addr, auth string, tx uint64) (ok bool, id string) {
if auth == a.Password || a.Password == "" {
return true, "user"
}
return false, ""
}
func init() {
common.Must(internet.RegisterTransportListener(protocolName, Listen))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/hysteria2/hy2_transport_test.go | transport/internet/hysteria2/hy2_transport_test.go | package hysteria2_test
import (
"context"
"crypto/rand"
"fmt"
"testing"
"time"
"github.com/google/go-cmp/cmp"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/protocol/tls/cert"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/testing/servers/udp"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/hysteria2"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
func TestTCP(t *testing.T) {
port := udp.PickPort()
listener, err := hysteria2.Listen(context.Background(), net.LocalHostIP, port, &internet.MemoryStreamConfig{
ProtocolName: "hysteria2",
ProtocolSettings: &hysteria2.Config{Password: "123"},
SecurityType: "tls",
SecuritySettings: &tls.Config{
Certificate: []*tls.Certificate{
tls.ParseCertificate(
cert.MustGenerate(nil,
cert.DNSNames("www.v2fly.org"),
),
),
},
},
}, func(conn internet.Connection) {
go func() {
defer conn.Close()
b := buf.New()
defer b.Release()
for {
b.Clear()
if _, err := b.ReadFrom(conn); err != nil {
fmt.Println(err)
return
}
common.Must2(conn.Write(b.Bytes()))
}
}()
})
common.Must(err)
defer listener.Close()
time.Sleep(time.Second)
dctx := context.Background()
conn, err := hysteria2.Dial(dctx, net.TCPDestination(net.LocalHostIP, port), &internet.MemoryStreamConfig{
ProtocolName: "hysteria2",
ProtocolSettings: &hysteria2.Config{Password: "123"},
SecurityType: "tls",
SecuritySettings: &tls.Config{
ServerName: "www.v2fly.org",
AllowInsecure: true,
},
})
common.Must(err)
defer conn.Close()
const N = 1000
b1 := make([]byte, N)
common.Must2(rand.Read(b1))
b2 := buf.New()
common.Must2(conn.Write(b1))
b2.Clear()
common.Must2(b2.ReadFullFrom(conn, N))
if r := cmp.Diff(b2.Bytes(), b1); r != "" {
t.Error(r)
}
}
func TestUDP(t *testing.T) {
port := udp.PickPort()
listener, err := hysteria2.Listen(context.Background(), net.LocalHostIP, port, &internet.MemoryStreamConfig{
ProtocolName: "hysteria2",
ProtocolSettings: &hysteria2.Config{Password: "123", UseUdpExtension: true},
SecurityType: "tls",
SecuritySettings: &tls.Config{
Certificate: []*tls.Certificate{
tls.ParseCertificate(
cert.MustGenerate(nil,
cert.DNSNames("www.v2fly.org"),
),
),
},
},
}, func(conn internet.Connection) {
fmt.Println("incoming")
go func() {
defer conn.Close()
b := buf.New()
defer b.Release()
for {
b.Clear()
if _, err := b.ReadFrom(conn); err != nil {
fmt.Println(err)
return
}
common.Must2(conn.Write(b.Bytes()))
}
}()
})
common.Must(err)
defer listener.Close()
time.Sleep(time.Second)
address, err := net.ParseDestination("udp:127.0.0.1:1180")
common.Must(err)
dctx := session.ContextWithOutbound(context.Background(), &session.Outbound{Target: address})
conn, err := hysteria2.Dial(dctx, net.TCPDestination(net.LocalHostIP, port), &internet.MemoryStreamConfig{
ProtocolName: "hysteria2",
ProtocolSettings: &hysteria2.Config{Password: "123", UseUdpExtension: true},
SecurityType: "tls",
SecuritySettings: &tls.Config{
ServerName: "www.v2fly.org",
AllowInsecure: true,
},
})
common.Must(err)
defer conn.Close()
const N = 1000
b1 := make([]byte, N)
common.Must2(rand.Read(b1))
common.Must2(conn.Write(b1))
b2 := buf.New()
b2.Clear()
common.Must2(b2.ReadFullFrom(conn, N))
if r := cmp.Diff(b2.Bytes(), b1); r != "" {
t.Error(r)
}
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/hysteria2/dialer.go | transport/internet/hysteria2/dialer.go | package hysteria2
import (
"context"
"sync"
"github.com/apernet/quic-go/quicvarint"
hyClient "github.com/v2fly/hysteria/core/v2/client"
hyProtocol "github.com/v2fly/hysteria/core/v2/international/protocol"
"github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/session"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/tls"
)
type dialerConf struct {
net.Destination
*internet.MemoryStreamConfig
}
var (
RunningClient map[dialerConf](hyClient.Client)
ClientMutex sync.Mutex
MBps uint64 = 1000000 / 8 // MByte
)
func GetClientTLSConfig(dest net.Destination, streamSettings *internet.MemoryStreamConfig) (*hyClient.TLSConfig, error) {
config := tls.ConfigFromStreamSettings(streamSettings)
if config == nil {
return nil, newError(Hy2MustNeedTLS)
}
tlsConfig := config.GetTLSConfig(tls.WithDestination(dest))
return &hyClient.TLSConfig{
RootCAs: tlsConfig.RootCAs,
ServerName: tlsConfig.ServerName,
InsecureSkipVerify: tlsConfig.InsecureSkipVerify,
VerifyPeerCertificate: tlsConfig.VerifyPeerCertificate,
}, nil
}
func ResolveAddress(dest net.Destination) (net.Addr, error) {
var destAddr *net.UDPAddr
if dest.Address.Family().IsIP() {
destAddr = &net.UDPAddr{
IP: dest.Address.IP(),
Port: int(dest.Port),
}
} else {
addr, err := net.ResolveUDPAddr("udp", dest.NetAddr())
if err != nil {
return nil, err
}
destAddr = addr
}
return destAddr, nil
}
type connFactory struct {
hyClient.ConnFactory
NewFunc func(addr net.Addr) (net.PacketConn, error)
}
func (f *connFactory) New(addr net.Addr) (net.PacketConn, error) {
return f.NewFunc(addr)
}
func NewHyClient(dest net.Destination, streamSettings *internet.MemoryStreamConfig) (hyClient.Client, error) {
tlsConfig, err := GetClientTLSConfig(dest, streamSettings)
if err != nil {
return nil, err
}
serverAddr, err := ResolveAddress(dest)
if err != nil {
return nil, err
}
config := streamSettings.ProtocolSettings.(*Config)
client, _, err := hyClient.NewClient(&hyClient.Config{
Auth: config.GetPassword(),
TLSConfig: *tlsConfig,
ServerAddr: serverAddr,
ConnFactory: &connFactory{
NewFunc: func(addr net.Addr) (net.PacketConn, error) {
rawConn, err := internet.ListenSystemPacket(context.Background(), &net.UDPAddr{
IP: []byte{0, 0, 0, 0},
Port: 0,
}, streamSettings.SocketSettings)
if err != nil {
return nil, err
}
return rawConn.(*net.UDPConn), nil
},
},
BandwidthConfig: hyClient.BandwidthConfig{MaxTx: config.Congestion.GetUpMbps() * MBps, MaxRx: config.GetCongestion().GetDownMbps() * MBps},
})
if err != nil {
return nil, err
}
return client, nil
}
func CloseHyClient(dest net.Destination, streamSettings *internet.MemoryStreamConfig) error {
ClientMutex.Lock()
defer ClientMutex.Unlock()
client, found := RunningClient[dialerConf{dest, streamSettings}]
if found {
delete(RunningClient, dialerConf{dest, streamSettings})
return client.Close()
}
return nil
}
func GetHyClient(dest net.Destination, streamSettings *internet.MemoryStreamConfig) (hyClient.Client, error) {
var err error
var client hyClient.Client
ClientMutex.Lock()
client, found := RunningClient[dialerConf{dest, streamSettings}]
ClientMutex.Unlock()
if !found || !CheckHyClientHealthy(client) {
if found {
// retry
CloseHyClient(dest, streamSettings)
}
client, err = NewHyClient(dest, streamSettings)
if err != nil {
return nil, err
}
ClientMutex.Lock()
RunningClient[dialerConf{dest, streamSettings}] = client
ClientMutex.Unlock()
}
return client, nil
}
func CheckHyClientHealthy(client hyClient.Client) bool {
quicConn := client.GetQuicConn()
if quicConn == nil {
return false
}
select {
case <-quicConn.Context().Done():
return false
default:
}
return true
}
func Dial(ctx context.Context, dest net.Destination, streamSettings *internet.MemoryStreamConfig) (internet.Connection, error) {
config := streamSettings.ProtocolSettings.(*Config)
client, err := GetHyClient(dest, streamSettings)
if err != nil {
CloseHyClient(dest, streamSettings)
return nil, err
}
quicConn := client.GetQuicConn()
conn := &HyConn{
local: quicConn.LocalAddr(),
remote: quicConn.RemoteAddr(),
}
outbound := session.OutboundFromContext(ctx)
network := net.Network_TCP
if outbound != nil {
network = outbound.Target.Network
}
if network == net.Network_UDP && config.GetUseUdpExtension() { // only hysteria2 can use udpExtension
conn.IsUDPExtension = true
conn.IsServer = false
conn.ClientUDPSession, err = client.UDP()
if err != nil {
CloseHyClient(dest, streamSettings)
return nil, err
}
return conn, nil
}
conn.stream, err = client.OpenStream()
if err != nil {
CloseHyClient(dest, streamSettings)
return nil, err
}
// write TCP frame type
frameSize := quicvarint.Len(hyProtocol.FrameTypeTCPRequest)
buf := make([]byte, frameSize)
hyProtocol.VarintPut(buf, hyProtocol.FrameTypeTCPRequest)
_, err = conn.stream.Write(buf)
if err != nil {
CloseHyClient(dest, streamSettings)
return nil, err
}
return conn, nil
}
func init() {
RunningClient = make(map[dialerConf]hyClient.Client)
common.Must(internet.RegisterTransportDialer(protocolName, Dial))
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
v2fly/v2ray-core | https://github.com/v2fly/v2ray-core/blob/b2c3b2506695d872162baeed95c9525fbfdbfda0/transport/internet/hysteria2/errors.generated.go | transport/internet/hysteria2/errors.generated.go | package hysteria2
import "github.com/v2fly/v2ray-core/v5/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}
| go | MIT | b2c3b2506695d872162baeed95c9525fbfdbfda0 | 2026-01-07T08:36:12.135351Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.