Xray-core/transport/internet/tls/tls.go

package tls

import (
	"context"
	"crypto/rand"
	"crypto/tls"
	"math/big"

	utls "github.com/refraction-networking/utls"
	"github.com/xtls/xray-core/common/buf"
	"github.com/xtls/xray-core/common/net"
	"github.com/xtls/xray-core/common/session"
)

//go:generate go run github.com/xtls/xray-core/common/errors/errorgen

var _ buf.Writer = (*Conn)(nil)

var XrayRandom *utls.ClientHelloID

type Conn struct {
	*tls.Conn
}

func (c *Conn) WriteMultiBuffer(mb buf.MultiBuffer) error {
	mb = buf.Compact(mb)
	mb, err := buf.WriteMultiBuffer(c, mb)
	buf.ReleaseMulti(mb)
	return err
}

func (c *Conn) HandshakeAddress() net.Address {
	if err := c.Handshake(); err != nil {
		return nil
	}
	state := c.ConnectionState()
	if state.ServerName == "" {
		return nil
	}
	return net.ParseAddress(state.ServerName)
}

func (c *Conn) NegotiatedProtocol() (name string, mutual bool) {
	state := c.ConnectionState()
	return state.NegotiatedProtocol, state.NegotiatedProtocolIsMutual
}

// Client initiates a TLS client handshake on the given connection.
func Client(c net.Conn, config *tls.Config) net.Conn {
	tlsConn := tls.Client(c, config)
	return &Conn{Conn: tlsConn}
}

// Server initiates a TLS server handshake on the given connection.
func Server(c net.Conn, config *tls.Config) net.Conn {
	tlsConn := tls.Server(c, config)
	return &Conn{Conn: tlsConn}
}

type UConn struct {
	*utls.UConn
}

func (c *UConn) HandshakeAddress() net.Address {
	if err := c.Handshake(); err != nil {
		return nil
	}
	state := c.ConnectionState()
	if state.ServerName == "" {
		return nil
	}
	return net.ParseAddress(state.ServerName)
}

// WebsocketHandshake basically calls UConn.Handshake inside it but it will only send
// http/1.1 in its ALPN.
func (c *UConn) WebsocketHandshake() error {
	// Build the handshake state. This will apply every variable of the TLS of the
	// fingerprint in the UConn
	if err := c.BuildHandshakeState(); err != nil {
		return err
	}
	// Iterate over extensions and check for utls.ALPNExtension
	hasALPNExtension := false
	for _, extension := range c.Extensions {
		if alpn, ok := extension.(*utls.ALPNExtension); ok {
			hasALPNExtension = true
			alpn.AlpnProtocols = []string{"http/1.1"}
			break
		}
	}
	if !hasALPNExtension { // Append extension if doesn't exists
		c.Extensions = append(c.Extensions, &utls.ALPNExtension{AlpnProtocols: []string{"http/1.1"}})
	}
	// Rebuild the client hello and do the handshake
	if err := c.BuildHandshakeState(); err != nil {
		return err
	}
	return c.Handshake()
}

func (c *UConn) NegotiatedProtocol() (name string, mutual bool) {
	state := c.ConnectionState()
	return state.NegotiatedProtocol, state.NegotiatedProtocolIsMutual
}

func UClient(c net.Conn, config *tls.Config, fingerprint *utls.ClientHelloID) net.Conn {
	utlsConn := utls.UClient(c, copyConfig(config), *fingerprint)
	return &UConn{UConn: utlsConn}
}

func copyConfig(c *tls.Config) *utls.Config {
	return &utls.Config{
		RootCAs:            c.RootCAs,
		ServerName:         c.ServerName,
		InsecureSkipVerify: c.InsecureSkipVerify,
	}
}

func GetFingerprint(ctx context.Context, config string) (*utls.ClientHelloID, bool) {
	if XrayRandom == nil {
		// lazy init
		for k, v := range FingerprintsForRNG {
			Fingerprints[k] = v
		}
		big, err := rand.Int(rand.Reader, big.NewInt(int64(len(FingerprintsForRNG))))
		if err != nil {
			newError("failed to generate xray random fingerprint").Base(err).WriteToLog(session.ExportIDToError(ctx))
		}
		var i = int(big.Int64())
		count := 0
		for k, v := range FingerprintsForRNG {
			if count == i {
				newError("xray random fingerprint: ", k).WriteToLog(session.ExportIDToError(ctx))
				XrayRandom = v
				break
			}
			count++
		}
	}
	if config == "random" {
		return XrayRandom, true
	}
	fingerprint, ok := Fingerprints[config]
	return fingerprint, ok
}

var Fingerprints = map[string]*utls.ClientHelloID{
	"chrome":     &utls.HelloChrome_Auto,
	"firefox":    &utls.HelloFirefox_Auto,
	"safari":     &utls.HelloSafari_Auto,
	"randomized": &utls.HelloRandomized,
	// This is a bit lame, but it seems there is no good way to reflect variables from Golang package
	// We don't RNG for go, randomized, or fingerprints that is more than 4 years old
	"hellogolang":           &utls.HelloGolang,
	"hellorandomized":       &utls.HelloRandomized,
	"hellorandomizedalpn":   &utls.HelloRandomizedALPN,
	"hellorandomizednoalpn": &utls.HelloRandomizedNoALPN,
	"hellofirefox_55":       &utls.HelloFirefox_55,
	"hellofirefox_56":       &utls.HelloFirefox_56,
	"hellofirefox_63":       &utls.HelloFirefox_63,
	"hellofirefox_65":       &utls.HelloFirefox_65,
	"hellochrome_58":        &utls.HelloChrome_58,
	"hellochrome_62":        &utls.HelloChrome_62,
	"hellochrome_70":        &utls.HelloChrome_70,
	"hellochrome_72":        &utls.HelloChrome_72,
	"helloios_11_1":         &utls.HelloIOS_11_1,
	"hello360_7_5":          &utls.Hello360_7_5,
}

var FingerprintsForRNG = map[string]*utls.ClientHelloID{
	"hellofirefox_auto":       &utls.HelloFirefox_Auto,
	"hellofirefox_99":         &utls.HelloFirefox_99,
	"hellofirefox_102":        &utls.HelloFirefox_102,
	"hellofirefox_105":        &utls.HelloFirefox_105,
	"hellochrome_auto":        &utls.HelloChrome_Auto,
	"hellochrome_83":          &utls.HelloChrome_83,
	"hellochrome_87":          &utls.HelloChrome_87,
	"hellochrome_96":          &utls.HelloChrome_96,
	"hellochrome_100":         &utls.HelloChrome_100,
	"hellochrome_102":         &utls.HelloChrome_102,
	"hellochrome_106_shuffle": &utls.HelloChrome_106_Shuffle,
	"helloios_auto":           &utls.HelloIOS_Auto,
	"helloios_12_1":           &utls.HelloIOS_12_1,
	"helloios_13":             &utls.HelloIOS_13,
	"helloios_14":             &utls.HelloIOS_14,
	"helloandroid_11_okhttp":  &utls.HelloAndroid_11_OkHttp,
	"helloedge_auto":          &utls.HelloEdge_Auto,
	"helloedge_85":            &utls.HelloEdge_85,
	"helloedge_106":           &utls.HelloEdge_106,
	"hellosafari_auto":        &utls.HelloSafari_Auto,
	"hellosafari_16_0":        &utls.HelloSafari_16_0,
	"hello360_auto":           &utls.Hello360_Auto,
	"hello360_11_0":           &utls.Hello360_11_0,
	"helloqq_auto":            &utls.HelloQQ_Auto,
	"helloqq_11_1":            &utls.HelloQQ_11_1,
}

type Interface interface {
	net.Conn
	Handshake() error
	VerifyHostname(host string) error
	NegotiatedProtocol() (name string, mutual bool)
}