From a7d0421c93c69134cc9bfe84a60329ca249bfa4f Mon Sep 17 00:00:00 2001 From: nadoo <287492+nadoo@users.noreply.github.com> Date: Mon, 16 Nov 2026 21:08:27 +0800 Subject: [PATCH] chore: optimize code --- dns/client.go | 5 +- dns/message.go | 47 +++++------ dns/server.go | 5 +- go.mod | 16 ++-- go.sum | 60 +++++++------ proxy/anytls/client.go | 39 ++++++--- proxy/anytls/protocol.go | 11 ++- proxy/anytls/session.go | 176 +++++++++++++++++++++++++++++++++++---- proxy/anytls/stream.go | 135 ++++++++++++++++++++++-------- proxy/obfs/tls.go | 62 ++++++++------ proxy/trojan/packet.go | 4 +- proxy/vless/client.go | 7 +- proxy/vless/packet.go | 4 +- proxy/vmess/auth.go | 14 ++-- proxy/vmess/client.go | 8 +- 15 files changed, 422 insertions(+), 171 deletions(-) diff --git a/dns/client.go b/dns/client.go index 4e24546..0c80e1c 100644 --- a/dns/client.go +++ b/dns/client.go @@ -234,10 +234,11 @@ func (c *Client) exchangeTCP(rc net.Conn, reqBytes []byte) ([]byte, error) { return nil, err } - var respLen uint16 - if err := binary.Read(rc, binary.BigEndian, &respLen); err != nil { + var lenRaw [2]byte + if _, err := io.ReadFull(rc, lenRaw[:]); err != nil { return nil, err } + respLen := binary.BigEndian.Uint16(lenRaw[:]) respBytes := pool.GetBuffer(int(respLen)) _, err := io.ReadFull(rc, respBytes) diff --git a/dns/message.go b/dns/message.go index 863f987..21e6959 100644 --- a/dns/message.go +++ b/dns/message.go @@ -218,7 +218,15 @@ func (h *Header) SetAncount(ancount int) { // MarshalTo marshals header struct to []byte and write to w. func (h *Header) MarshalTo(w io.Writer) (int, error) { - return HeaderLen, binary.Write(w, binary.BigEndian, h) + var b [HeaderLen]byte + binary.BigEndian.PutUint16(b[0:2], h.ID) + binary.BigEndian.PutUint16(b[2:4], h.Bits) + binary.BigEndian.PutUint16(b[4:6], h.QDCOUNT) + binary.BigEndian.PutUint16(b[6:8], h.ANCOUNT) + binary.BigEndian.PutUint16(b[8:10], h.NSCOUNT) + binary.BigEndian.PutUint16(b[10:12], h.ARCOUNT) + _, err := w.Write(b[:]) + return HeaderLen, err } // UnmarshalHeader unmarshals []bytes to Header. @@ -280,15 +288,13 @@ func (q *Question) MarshalTo(w io.Writer) (n int, err error) { return } - if err = binary.Write(w, binary.BigEndian, q.QTYPE); err != nil { + var b [4]byte + binary.BigEndian.PutUint16(b[0:2], q.QTYPE) + binary.BigEndian.PutUint16(b[2:4], q.QCLASS) + if _, err = w.Write(b[:]); err != nil { return } - n += 2 - - if err = binary.Write(w, binary.BigEndian, q.QCLASS); err != nil { - return - } - n += 2 + n += 4 return } @@ -368,26 +374,15 @@ func (rr *RR) MarshalTo(w io.Writer) (n int, err error) { return } - if err = binary.Write(w, binary.BigEndian, rr.TYPE); err != nil { + var b [10]byte + binary.BigEndian.PutUint16(b[0:2], rr.TYPE) + binary.BigEndian.PutUint16(b[2:4], rr.CLASS) + binary.BigEndian.PutUint32(b[4:8], rr.TTL) + binary.BigEndian.PutUint16(b[8:10], rr.RDLENGTH) + if _, err = w.Write(b[:]); err != nil { return } - n += 2 - - if err = binary.Write(w, binary.BigEndian, rr.CLASS); err != nil { - return - } - n += 2 - - if err = binary.Write(w, binary.BigEndian, rr.TTL); err != nil { - return - } - n += 4 - - err = binary.Write(w, binary.BigEndian, rr.RDLENGTH) - if err != nil { - return - } - n += 2 + n += 10 if _, err = w.Write(rr.RDATA); err != nil { return diff --git a/dns/server.go b/dns/server.go index cab312d..0b792ba 100644 --- a/dns/server.go +++ b/dns/server.go @@ -119,11 +119,12 @@ func (s *Server) ServeTCP(c net.Conn) { c.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second)) - var reqLen uint16 - if err := binary.Read(c, binary.BigEndian, &reqLen); err != nil { + var lengthBuf [2]byte + if _, err := io.ReadFull(c, lengthBuf[:]); err != nil { log.F("[dns-tcp] failed to get request length: %v", err) return } + reqLen := binary.BigEndian.Uint16(lengthBuf[:]) reqBytes := pool.GetBuffer(int(reqLen)) defer pool.PutBuffer(reqBytes) diff --git a/go.mod b/go.mod index bac8038..499f499 100644 --- a/go.mod +++ b/go.mod @@ -4,21 +4,23 @@ go 1.27 require ( github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da - github.com/insomniacslk/dhcp v0.0.0-20260901064844-234b97448fae + github.com/insomniacslk/dhcp v0.0.0-20261014062924-c6bb46ad3f3a github.com/nadoo/conflag v0.3.1 github.com/nadoo/netset v0.1.0 - github.com/xtaci/kcp-go/v5 v5.6.72 - golang.org/x/crypto v0.57.0 - golang.org/x/sys v0.49.0 + github.com/xtaci/kcp-go/v5 v5.7.6 + golang.org/x/crypto v0.59.0 + golang.org/x/sys v0.50.0 ) require ( - github.com/klauspost/cpuid/v2 v2.4.0 // indirect + github.com/juju/ratelimit v1.0.2 // indirect + github.com/klauspost/cpuid/v2 v2.4.2 // indirect github.com/klauspost/reedsolomon v1.14.2 // indirect + github.com/kr/pretty v0.3.1 // indirect github.com/pierrec/lz4/v4 v4.1.33 // indirect + github.com/pion/transport/v5 v5.1.5 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/tjfoc/gmsm v1.4.1 // indirect github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 // indirect - golang.org/x/net v0.60.0 // indirect - golang.org/x/time v0.16.0 // indirect + golang.org/x/net v0.62.0 // indirect ) diff --git a/go.sum b/go.sum index b7d5f0a..6a83fb6 100644 --- a/go.sum +++ b/go.sum @@ -5,8 +5,7 @@ github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da/go.mod h1:eHEWzANqSi github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= -github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= @@ -25,14 +24,20 @@ github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5a github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/insomniacslk/dhcp v0.0.0-20260901064844-234b97448fae h1:nXGg65fXsylSUTNNWwvHuQsXev7mhIzQTnZREPTbWzs= -github.com/insomniacslk/dhcp v0.0.0-20260901064844-234b97448fae/go.mod h1:tGfUTcnFYGYvVNCaZZhwlJySU/fQQxh9TmpsFzWXnnY= +github.com/insomniacslk/dhcp v0.0.0-20261014062924-c6bb46ad3f3a h1:07pMKu9gWaSFnDe817VcMl14qJfWCz1vm3uB+7YmyPE= +github.com/insomniacslk/dhcp v0.0.0-20261014062924-c6bb46ad3f3a/go.mod h1:tGfUTcnFYGYvVNCaZZhwlJySU/fQQxh9TmpsFzWXnnY= github.com/josharian/native v1.1.0 h1:uuaP0hAbW7Y4l0ZRQ6C9zfb7Mg1mbFKry/xzDAfmtLA= github.com/josharian/native v1.1.0/go.mod h1:7X/raswPFr05uY3HiLlYeyQntB6OO7E/d2Cu7qoaN2w= -github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw= -github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU= +github.com/juju/ratelimit v1.0.2 h1:sRxmtRiajbvrcLQT7S+JbqU0ntsb9W2yhSdNN8tWfaI= +github.com/juju/ratelimit v1.0.2/go.mod h1:qapgC/Gy+xNh9UxzV13HGGl/6UXNN+ct+vwSgWNm/qk= +github.com/klauspost/cpuid/v2 v2.4.2 h1:xRw7IZEsAgVCp6trS/DgWbTAqpixhmywgVgBjYGg1bQ= +github.com/klauspost/cpuid/v2 v2.4.2/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU= github.com/klauspost/reedsolomon v1.14.2 h1:SafJYwpBBQBI6amHUygcjxZjXeN2HpiENHQDwuPWCCQ= github.com/klauspost/reedsolomon v1.14.2/go.mod h1:yjqqjgMTQkBUHSG97/rm4zipffCNbCiZcB3kTqr++sQ= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/mdlayher/packet v1.1.2 h1:3Up1NG6LZrsgDVn6X4L9Ge/iyRyxFEFD9o6Pr3Q1nQY= github.com/mdlayher/packet v1.1.2/go.mod h1:GEu1+n9sG5VtiRE4SydOmX5GTwyyYlteZiFU+x0kew4= github.com/mdlayher/socket v0.4.1 h1:eM9y2/jlbs1M615oshPQOHZzj6R6wMT7bX5NPiQvn2U= @@ -43,26 +48,31 @@ github.com/nadoo/netset v0.1.0 h1:FNdGCVtoSjBX0Ctzve3BWwTOSXRxK/oSPBzS3/SemY4= github.com/nadoo/netset v0.1.0/go.mod h1:w2GPCnz+TxqH+HJIrhOEC4oZAeQ5Crefw4lToBIxEww= github.com/pierrec/lz4/v4 v4.1.33 h1:GjG1TJ1V4IzKP8L96muuuDNpTwd7D+l2ccXrjAbe014= github.com/pierrec/lz4/v4 v4.1.33/go.mod h1:7SE9MC2STkNtL4PIwGhjmyVwvILaGI9/COYQNBhKM/c= +github.com/pion/transport/v5 v5.1.5 h1:73fa352Y9dq85kCd9rzyBV7wd/qhAiBIuTtwzWO3WS0= +github.com/pion/transport/v5 v5.1.5/go.mod h1:Qxw6fCEjFWQkRDZOhS4Vf+neJBcihauvA3uyEa1J1F0= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0= -github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= github.com/tjfoc/gmsm v1.4.1 h1:aMe1GlZb+0bLjn+cKTPEvvn9oUEBlJitaZiiBwsbgho= github.com/tjfoc/gmsm v1.4.1/go.mod h1:j4INPkHWMrhJb38G+J6W4Tw0AbuN8Thu3PbdVYhVcTE= github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701 h1:pyC9PaHYZFgEKFdlp3G8RaCKgVpHZnecvArXvPXcFkM= github.com/u-root/uio v0.0.0-20240224005618-d2acac8f3701/go.mod h1:P3a5rG4X7tI17Nn3aOIAYr5HbIMukwXG0urG0WuL8OA= -github.com/xtaci/kcp-go/v5 v5.6.72 h1:FLaQPalgpufJYQRk0OK+gErEhXGLUPjv6FSRPrFR8Lk= -github.com/xtaci/kcp-go/v5 v5.6.72/go.mod h1:9O3D8WR+cyyUjGiTILYfg17vn72otWuXK2AFfqIe6CM= -github.com/xtaci/lossyconn v0.0.0-20190602105132-8df528c0c9ae h1:J0GxkO96kL4WF+AIT3M4mfUVinOCPgf2uUWYFUzN0sM= -github.com/xtaci/lossyconn v0.0.0-20190602105132-8df528c0c9ae/go.mod h1:gXtu8J62kEgmN++bm9BVICuT/e8yiLI2KFobd/TRFsE= +github.com/xtaci/kcp-go/v5 v5.7.6 h1:TckVvJxZhMHH1M0lLwXHa2/pLOhH7MxAibFzA4V58eg= +github.com/xtaci/kcp-go/v5 v5.7.6/go.mod h1:yXWQLZG5hW3+uwchBDrOg3WP7kzAAO5ShHsvDmYyWTc= +github.com/xtaci/lossyconn v1.1.0 h1:rXMYEzd9rA9GxaVKO7XMoOZfzZUPYQyt4HwBHiAhMME= +github.com/xtaci/lossyconn v1.1.0/go.mod h1:HpMP7DB2CyokmAh4lp0EQnnWhmycP/TvwBGzvuie+H0= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20201012173705-84dcc777aaee/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M= -golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA= +golang.org/x/crypto v0.59.0 h1:xS2jhqYbzNrpvkWP2YTDf4TJwBy3ykR03i8vFDxEc7c= +golang.org/x/crypto v0.59.0/go.mod h1:veDyUwATGs3c+vN3VfTbzViMGXeTBk3WyhBOkn+F/4U= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= @@ -73,8 +83,8 @@ golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.60.0 h1:79p50tfZlm0J9YfoDsSi639qSXNGVwEzOPLCxM2FsYU= -golang.org/x/net v0.60.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg= +golang.org/x/net v0.62.0 h1:18ELalfM5+XNRwzM2nYqXsZQ9ByS1uhj2O/U7+5jqRY= +golang.org/x/net v0.62.0/go.mod h1:WgDCOTH8iwtB66T4/GfI94AHo/hhdb7Hah9NDseQfiI= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -85,14 +95,12 @@ golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= -golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= -golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE= -golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc= +golang.org/x/sys v0.50.0 h1:dkKZEFTEKaLr1sjhs0WiKqoi8Jj5nHbS3Njmx1UoMJs= +golang.org/x/sys v0.50.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/term v0.48.0 h1:G6UU1eiSB8nl3DzeUGt7Mg+2SctI8tPS6Z5/mBt6cOk= +golang.org/x/term v0.48.0/go.mod h1:BRDLHCZr2SUjIeBHHpRyQeC9xzSAVbzY2rvKgafnHf4= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/time v0.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE= -golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= @@ -113,7 +121,7 @@ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQ google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/proxy/anytls/client.go b/proxy/anytls/client.go index 610a1ae..4881f84 100644 --- a/proxy/anytls/client.go +++ b/proxy/anytls/client.go @@ -4,6 +4,7 @@ import ( "crypto/tls" "fmt" "net" + "time" "github.com/nadoo/glider/pkg/log" "github.com/nadoo/glider/pkg/socks" @@ -60,7 +61,7 @@ func (s *AnyTLS) Dial(network, addr string) (net.Conn, error) { _ = ss.Close() return nil, err } - return &clientConn{Conn: st, session: ss}, nil + return &clientConn{stream: st}, nil } func (s *AnyTLS) DialUDP(network, addr string) (net.PacketConn, error) { @@ -99,7 +100,7 @@ func (s *AnyTLS) DialUDP(network, addr string) (net.PacketConn, error) { _ = ss.Close() return nil, err } - return &clientPacketConn{PacketConn: newUOTPacketConn(st, target), session: ss}, nil + return &clientPacketConn{PacketConn: newUOTPacketConn(st, target), stream: st}, nil } func (s *AnyTLS) newClientSession() (*session, error) { @@ -123,7 +124,7 @@ func (s *AnyTLS) newClientSession() (*session, error) { } ss := newSession(c) if err := ss.writeFrame(frame{command: cmdSettings, data: clientSettings(s.padding)}); err != nil { - _ = c.Close() + _ = ss.Close() return nil, err } ss.start() @@ -131,23 +132,37 @@ func (s *AnyTLS) newClientSession() (*session, error) { } type clientConn struct { - net.Conn - session *session + *stream } func (c *clientConn) Close() error { - err := c.Conn.Close() - _ = c.session.Close() - return err + return closeClientSession(c.stream) } type clientPacketConn struct { net.PacketConn - session *session + stream *stream } func (c *clientPacketConn) Close() error { - err := c.PacketConn.Close() - _ = c.session.Close() - return err + return closeClientSession(c.stream) +} + +const clientFINTimeout = time.Second + +// The client owns the whole session. Give FIN a chance to reach the transport +// before tearing it down, while keeping standalone stream.Close nonblocking. +func closeClientSession(st *stream) error { + _ = st.Close() + defer st.s.Close() + if st.fin != nil { + timer := time.NewTimer(clientFINTimeout) + defer timer.Stop() + select { + case <-st.fin.result: + case <-st.s.done: + case <-timer.C: + } + } + return nil } diff --git a/proxy/anytls/protocol.go b/proxy/anytls/protocol.go index 0c8f3e7..589ad7f 100644 --- a/proxy/anytls/protocol.go +++ b/proxy/anytls/protocol.go @@ -83,15 +83,18 @@ func readFrame(r io.Reader) (frame, error) { return frame{command: head[0], streamID: binary.BigEndian.Uint32(head[1:5]), data: data}, nil } -func writeFrame(w io.Writer, f frame) error { +func writeFrame(w io.Writer, f frame) (int, error) { if len(f.data) > maxFrameData { - return errors.New("frame data too large") + return 0, errors.New("frame data too large") } buf := make([]byte, 7+len(f.data)) buf[0] = f.command binary.BigEndian.PutUint32(buf[1:5], f.streamID) binary.BigEndian.PutUint16(buf[5:7], uint16(len(f.data))) copy(buf[7:], f.data) - _, err := w.Write(buf) - return err + n, err := w.Write(buf) + if n < len(buf) && err == nil { + err = io.ErrShortWrite + } + return max(0, n-7), err } diff --git a/proxy/anytls/session.go b/proxy/anytls/session.go index 489d5ac..f5ce73e 100644 --- a/proxy/anytls/session.go +++ b/proxy/anytls/session.go @@ -1,10 +1,13 @@ package anytls import ( + "bytes" + "container/list" "errors" "fmt" "io" "net" + "os" "sync" "sync/atomic" "time" @@ -13,16 +16,19 @@ import ( type session struct { conn net.Conn - writeMu sync.Mutex - mu sync.Mutex - streams map[uint32]*stream - synack map[uint32]chan synackResult - nextID atomic.Uint32 + writeMu sync.Mutex + writes list.List + writeWake chan struct{} + mu sync.Mutex + streams map[uint32]*stream + synack map[uint32]chan synackResult + nextID atomic.Uint32 incoming chan *stream done chan struct{} closeOnce sync.Once err atomic.Value + errOnce sync.Once settingsSeen bool } @@ -31,15 +37,33 @@ type synackResult struct { data []byte } +type frameWrite struct { + frame frame + stream *stream + deadline <-chan struct{} + result chan frameWriteResult + + // Guarded by session.writeMu. + elem *list.Element + started bool +} + +type frameWriteResult struct { + n int // payload bytes, excluding the frame header + err error +} + func newSession(conn net.Conn) *session { s := &session{ - conn: conn, - streams: map[uint32]*stream{}, - synack: map[uint32]chan synackResult{}, - incoming: make(chan *stream, 32), - done: make(chan struct{}), + conn: conn, + streams: map[uint32]*stream{}, + synack: map[uint32]chan synackResult{}, + incoming: make(chan *stream, 32), + done: make(chan struct{}), + writeWake: make(chan struct{}, 1), } s.nextID.Store(1) + go s.writeLoop() return s } @@ -103,9 +127,126 @@ func (s *session) waitSYNACK(id uint32, timeout time.Duration) error { } func (s *session) writeFrame(f frame) error { + req, err := s.queueFrame(f, nil, nil) + if err != nil { + return err + } + select { + case result := <-req.result: + return result.err + case <-s.done: + return s.Err() + } +} + +func (s *session) writeStreamFrame(st *stream, f frame) (int, error) { + if channelClosed(st.done) { + return 0, errStreamClosed + } + deadline := st.writeDeadline.wait() + if channelClosed(deadline) { + return 0, os.ErrDeadlineExceeded + } + req, err := s.queueFrame(f, st, deadline) + if err != nil { + return 0, err + } + select { + case result := <-req.result: + return result.n, result.err + case <-st.done: + err = errStreamClosed + case <-s.done: + err = s.Err() + case <-deadline: + err = os.ErrDeadlineExceeded + } + started := s.cancelWrite(req) + // Prefer the transport result when both completion and cancellation are ready. + select { + case result := <-req.result: + return result.n, result.err + default: + } + if started { + // The writer owns the whole frame once it starts. Its payload can + // still reach the peer after this call returns, so count it in n. + return len(f.data), err + } + return 0, err +} + +func (s *session) queueFrame(f frame, st *stream, deadline <-chan struct{}) (*frameWrite, error) { + // A stream may time out while the transport is writing. Own the payload so + // the caller can reuse its buffer without racing with the session writer. + f.data = bytes.Clone(f.data) + req := &frameWrite{frame: f, stream: st, deadline: deadline, result: make(chan frameWriteResult, 1)} s.writeMu.Lock() defer s.writeMu.Unlock() - return writeFrame(s.conn, f) + if channelClosed(s.done) { + return nil, s.Err() + } + req.elem = s.writes.PushBack(req) + select { + case s.writeWake <- struct{}{}: + default: + } + return req, nil +} + +// cancelWrite removes a pending request and reports whether it had already started. +func (s *session) cancelWrite(req *frameWrite) bool { + s.writeMu.Lock() + defer s.writeMu.Unlock() + if req.elem != nil { + s.writes.Remove(req.elem) + req.elem = nil + } + return req.started +} + +func (s *session) writeLoop() { + for { + select { + case <-s.done: + return + case <-s.writeWake: + } + for { + s.writeMu.Lock() + elem := s.writes.Front() + if elem == nil || channelClosed(s.done) { + s.writeMu.Unlock() + break + } + req := s.writes.Remove(elem).(*frameWrite) + req.elem = nil + if st := req.stream; st != nil { + if channelClosed(st.done) { + s.writeMu.Unlock() + req.result <- frameWriteResult{err: errStreamClosed} + continue + } + if channelClosed(req.deadline) { + s.writeMu.Unlock() + req.result <- frameWriteResult{err: os.ErrDeadlineExceeded} + continue + } + } + req.started = true + s.writeMu.Unlock() + // An in-flight frame must finish intact even if its stream times out. + // Only closing the session may interrupt the shared transport write. + n, err := writeFrame(s.conn, req.frame) + req.result <- frameWriteResult{n: n, err: err} + close(req.result) + if err != nil { + s.setErr(err) + s.Close() + return + } + } + } } func (s *session) readLoop() { @@ -202,8 +343,8 @@ func (s *session) removeStream(id uint32) { } func (s *session) setErr(err error) { - if err != nil && s.err.Load() == nil { - s.err.Store(err) + if err != nil { + s.errOnce.Do(func() { s.err.Store(err) }) } } @@ -218,8 +359,16 @@ func (s *session) Close() error { s.closeOnce.Do(func() { close(s.done) _ = s.conn.Close() + s.writeMu.Lock() + for elem := s.writes.Front(); elem != nil; elem = elem.Next() { + elem.Value.(*frameWrite).elem = nil + } + s.writes.Init() + s.writeMu.Unlock() s.mu.Lock() for _, st := range s.streams { + st.readDeadline.stop() + st.writeDeadline.stop() st.closeRead() } s.streams = map[uint32]*stream{} @@ -227,7 +376,6 @@ func (s *session) Close() error { delete(s.synack, id) close(ch) } - close(s.incoming) s.mu.Unlock() }) return nil diff --git a/proxy/anytls/stream.go b/proxy/anytls/stream.go index cb74e28..6e4f812 100644 --- a/proxy/anytls/stream.go +++ b/proxy/anytls/stream.go @@ -4,6 +4,7 @@ import ( "errors" "io" "net" + "os" "sync" "time" ) @@ -14,80 +15,142 @@ type stream struct { id uint32 s *session - in chan []byte - readBuf []byte - closeIn sync.Once - closeOut sync.Once + in chan []byte + readBuf []byte + readDone chan struct{} + done chan struct{} + closeIn sync.Once + closeOnce sync.Once + fin *frameWrite // published by closeOnce + readMu sync.Mutex + writeMu sync.Mutex - mu sync.Mutex - closed bool + readDeadline streamDeadline + writeDeadline streamDeadline } func newStream(id uint32, s *session) *stream { - return &stream{id: id, s: s, in: make(chan []byte, 32)} + return &stream{ + id: id, s: s, in: make(chan []byte, 32), + readDone: make(chan struct{}), done: make(chan struct{}), + } } func (st *stream) Read(p []byte) (int, error) { - for len(st.readBuf) == 0 { - b, ok := <-st.in - if !ok { - return 0, io.EOF + st.readMu.Lock() + defer st.readMu.Unlock() + for { + if channelClosed(st.done) { + return 0, net.ErrClosed + } + deadline := st.readDeadline.wait() + if channelClosed(deadline) { + return 0, os.ErrDeadlineExceeded + } + if len(p) == 0 { + return 0, nil + } + if len(st.readBuf) > 0 { + n := copy(p, st.readBuf) + st.readBuf = st.readBuf[n:] + return n, nil + } + // A peer FIN ends input after previously received data has been read. + select { + case st.readBuf = <-st.in: + continue + default: + } + select { + case st.readBuf = <-st.in: + case <-st.readDone: + select { + case st.readBuf = <-st.in: + default: + return 0, io.EOF + } + case <-st.done: + return 0, net.ErrClosed + case <-st.s.done: + return 0, st.s.Err() + case <-deadline: + return 0, os.ErrDeadlineExceeded } - st.readBuf = b } - n := copy(p, st.readBuf) - st.readBuf = st.readBuf[n:] - return n, nil } func (st *stream) Write(p []byte) (int, error) { - st.mu.Lock() - closed := st.closed - st.mu.Unlock() - if closed { + st.writeMu.Lock() + defer st.writeMu.Unlock() + if channelClosed(st.done) { return 0, errStreamClosed } + if channelClosed(st.writeDeadline.wait()) { + return 0, os.ErrDeadlineExceeded + } written := 0 for len(p) > 0 { n := min(len(p), maxFrameData) - if err := st.s.writeFrame(frame{command: cmdPSH, streamID: st.id, data: p[:n]}); err != nil { + accepted, err := st.s.writeStreamFrame(st, frame{command: cmdPSH, streamID: st.id, data: p[:n]}) + written += accepted + if err != nil { return written, err } - written += n p = p[n:] } return written, nil } func (st *stream) Close() error { - st.mu.Lock() - already := st.closed - st.closed = true - st.mu.Unlock() - if !already { - st.closeOut.Do(func() { - _ = st.s.writeFrame(frame{command: cmdFIN, streamID: st.id}) - }) + st.closeOnce.Do(func() { + close(st.done) + st.readDeadline.stop() + st.writeDeadline.stop() st.s.removeStream(st.id) - } + // FIN is queued behind any frame already being written. Closing a stream + // must not wait for a stalled transport or interrupt another stream. + st.fin, _ = st.s.queueFrame(frame{command: cmdFIN, streamID: st.id}, nil, nil) + }) return nil } func (st *stream) closeRead() { - st.closeIn.Do(func() { close(st.in) }) + st.closeIn.Do(func() { close(st.readDone) }) } func (st *stream) push(data []byte) { + if channelClosed(st.done) || channelClosed(st.readDone) || channelClosed(st.s.done) { + return + } cp := make([]byte, len(data)) copy(cp, data) select { case st.in <- cp: + case <-st.done: + case <-st.readDone: case <-st.s.done: } } -func (st *stream) LocalAddr() net.Addr { return st.s.conn.LocalAddr() } -func (st *stream) RemoteAddr() net.Addr { return st.s.conn.RemoteAddr() } -func (st *stream) SetDeadline(t time.Time) error { return st.s.conn.SetDeadline(t) } -func (st *stream) SetReadDeadline(t time.Time) error { return st.s.conn.SetReadDeadline(t) } -func (st *stream) SetWriteDeadline(t time.Time) error { return st.s.conn.SetWriteDeadline(t) } +func (st *stream) LocalAddr() net.Addr { return st.s.conn.LocalAddr() } +func (st *stream) RemoteAddr() net.Addr { return st.s.conn.RemoteAddr() } +func (st *stream) SetDeadline(t time.Time) error { + if err := st.SetReadDeadline(t); err != nil { + return err + } + return st.SetWriteDeadline(t) +} +func (st *stream) SetReadDeadline(t time.Time) error { + if channelClosed(st.done) || channelClosed(st.s.done) { + return net.ErrClosed + } + st.readDeadline.set(t) + return nil +} +func (st *stream) SetWriteDeadline(t time.Time) error { + if channelClosed(st.done) || channelClosed(st.s.done) { + return net.ErrClosed + } + st.writeDeadline.set(t) + return nil +} diff --git a/proxy/obfs/tls.go b/proxy/obfs/tls.go index dce5398..2a4bc52 100644 --- a/proxy/obfs/tls.go +++ b/proxy/obfs/tls.go @@ -25,6 +25,20 @@ const ( chunkSize = 1 << 13 // 8192 ) +// putBE16 writes v to buf as a big-endian uint16. +func putBE16(buf *bytes.Buffer, v uint16) { + var b [2]byte + binary.BigEndian.PutUint16(b[:], v) + buf.Write(b[:]) +} + +// putBE32 writes v to buf as a big-endian uint32. +func putBE32(buf *bytes.Buffer, v uint32) { + var b [4]byte + binary.BigEndian.PutUint32(b[:], v) + buf.Write(b[:]) +} + // TLSObfs struct type TLSObfs struct { obfsHost string @@ -67,7 +81,7 @@ func (c *TLSObfsConn) Write(b []byte) (int, error) { end := min(i+chunkSize, n) buf.Write([]byte{0x17, 0x03, 0x03}) - binary.Write(buf, binary.BigEndian, uint16(len(b[i:end]))) + putBE16(buf, uint16(len(b[i:end]))) buf.Write(b[i:end]) _, err := c.Conn.Write(buf.Bytes()) @@ -143,7 +157,7 @@ func (c *TLSObfsConn) handshake(b []byte) (int, error) { buf.Write([]byte{0x03, 0x01}) // length - binary.Write(buf, binary.BigEndian, uint16(handshakeLen)) + putBE16(buf, uint16(handshakeLen)) // Handshake Begin // Handshake Type: Client Hello (1) @@ -157,7 +171,7 @@ func (c *TLSObfsConn) handshake(b []byte) (int, error) { // Extension Begin // ext content length - binary.Write(buf, binary.BigEndian, uint16(extLen)) + putBE16(buf, uint16(extLen)) // ext content buf.Write(bufExt.Bytes()) @@ -182,7 +196,7 @@ func clientHello(buf *bytes.Buffer) { // clients do not send current time, and server do not check it, // golang tls client and chrome browser send random bytes instead. // - binary.Write(buf, binary.BigEndian, uint32(time.Now().Unix())) + putBE32(buf, uint32(time.Now().Unix())) random := make([]byte, 28) // The above 2 lines of codes was added to make it compatible with some server implementation, // if we don't need the compatibility, just use the following code instead. @@ -200,7 +214,7 @@ func clientHello(buf *bytes.Buffer) { // https://github.com/shadowsocks/simple-obfs/blob/7659eeccf473aa41eb294e92c32f8f60a8747325/src/obfs_tls.c#L57 // Cipher Suites Length: 56 - binary.Write(buf, binary.BigEndian, uint16(56)) + putBE16(buf, uint16(56)) // Cipher Suites (28 suites) buf.Write([]byte{ 0xc0, 0x2c, 0xc0, 0x30, 0x00, 0x9f, 0xcc, 0xa9, 0xcc, 0xa8, 0xcc, 0xaa, 0xc0, 0x2b, 0xc0, 0x2f, @@ -219,44 +233,44 @@ func extension(b []byte, server string, buf *bytes.Buffer) { // Extension: SessionTicket TLS buf.Write([]byte{0x00, 0x23}) // type // NOTE: send some data in sessionticket, the server will treat it as data too - binary.Write(buf, binary.BigEndian, uint16(len(b))) // length + putBE16(buf, uint16(len(b))) // length buf.Write(b) // Extension: server_name - buf.Write([]byte{0x00, 0x00}) // type - binary.Write(buf, binary.BigEndian, uint16(len(server)+5)) // length - binary.Write(buf, binary.BigEndian, uint16(len(server)+3)) // Server Name list length - buf.WriteByte(0x00) // Server Name Type: host_name (0) - binary.Write(buf, binary.BigEndian, uint16(len(server))) // Server Name length + buf.Write([]byte{0x00, 0x00}) // type + putBE16(buf, uint16(len(server)+5)) // length + putBE16(buf, uint16(len(server)+3)) // Server Name list length + buf.WriteByte(0x00) // Server Name Type: host_name (0) + putBE16(buf, uint16(len(server))) // Server Name length buf.WriteString(server) // https://github.com/shadowsocks/simple-obfs/blob/7659eeccf473aa41eb294e92c32f8f60a8747325/src/obfs_tls.c#L88 // Extension: ec_point_formats (len=4) - buf.Write([]byte{0x00, 0x0b}) // type - binary.Write(buf, binary.BigEndian, uint16(4)) // length - buf.WriteByte(0x03) // format length + buf.Write([]byte{0x00, 0x0b}) // type + putBE16(buf, uint16(4)) // length + buf.WriteByte(0x03) // format length buf.Write([]byte{0x01, 0x00, 0x02}) // Extension: supported_groups (len=10) - buf.Write([]byte{0x00, 0x0a}) // type - binary.Write(buf, binary.BigEndian, uint16(10)) // length - binary.Write(buf, binary.BigEndian, uint16(8)) // Supported Groups List Length: 8 + buf.Write([]byte{0x00, 0x0a}) // type + putBE16(buf, uint16(10)) // length + putBE16(buf, uint16(8)) // Supported Groups List Length: 8 buf.Write([]byte{0x00, 0x1d, 0x00, 0x17, 0x00, 0x19, 0x00, 0x18}) // Extension: signature_algorithms (len=32) - buf.Write([]byte{0x00, 0x0d}) // type - binary.Write(buf, binary.BigEndian, uint16(32)) // length - binary.Write(buf, binary.BigEndian, uint16(30)) // Signature Hash Algorithms Length: 30 + buf.Write([]byte{0x00, 0x0d}) // type + putBE16(buf, uint16(32)) // length + putBE16(buf, uint16(30)) // Signature Hash Algorithms Length: 30 buf.Write([]byte{ 0x06, 0x01, 0x06, 0x02, 0x06, 0x03, 0x05, 0x01, 0x05, 0x02, 0x05, 0x03, 0x04, 0x01, 0x04, 0x02, 0x04, 0x03, 0x03, 0x01, 0x03, 0x02, 0x03, 0x03, 0x02, 0x01, 0x02, 0x02, 0x02, 0x03, }) // Extension: encrypt_then_mac (len=0) - buf.Write([]byte{0x00, 0x16}) // type - binary.Write(buf, binary.BigEndian, uint16(0)) // length + buf.Write([]byte{0x00, 0x16}) // type + putBE16(buf, uint16(0)) // length // Extension: extended_master_secret (len=0) - buf.Write([]byte{0x00, 0x17}) // type - binary.Write(buf, binary.BigEndian, uint16(0)) // length + buf.Write([]byte{0x00, 0x17}) // type + putBE16(buf, uint16(0)) // length } diff --git a/proxy/trojan/packet.go b/proxy/trojan/packet.go index 38a5681..8708551 100644 --- a/proxy/trojan/packet.go +++ b/proxy/trojan/packet.go @@ -79,7 +79,9 @@ func (pc *PktConn) WriteTo(b []byte, addr net.Addr) (int, error) { defer pool.PutBytesBuffer(buf) tgtLen, _ := buf.Write(target) - binary.Write(buf, binary.BigEndian, uint16(len(b))) + var hdr [2]byte + binary.BigEndian.PutUint16(hdr[:], uint16(len(b))) + buf.Write(hdr[:]) buf.WriteString("\r\n") buf.Write(b) diff --git a/proxy/vless/client.go b/proxy/vless/client.go index e30978f..df8389b 100644 --- a/proxy/vless/client.go +++ b/proxy/vless/client.go @@ -81,10 +81,9 @@ func NewClientConn(c net.Conn, uuid [16]byte, network, target string) (*ClientCo buf.WriteByte(byte(cmd)) // cmd // target - err = binary.Write(buf, binary.BigEndian, uint16(port)) // port - if err != nil { - return nil, err - } + var portBuf [2]byte + binary.BigEndian.PutUint16(portBuf[:], uint16(port)) + buf.Write(portBuf[:]) buf.WriteByte(byte(atyp)) // atyp buf.Write(addr) //addr diff --git a/proxy/vless/packet.go b/proxy/vless/packet.go index 1ca0297..ab9d28e 100644 --- a/proxy/vless/packet.go +++ b/proxy/vless/packet.go @@ -46,7 +46,9 @@ func (pc *PktConn) WriteTo(b []byte, addr net.Addr) (int, error) { buf := pool.GetBytesBuffer() defer pool.PutBytesBuffer(buf) - binary.Write(buf, binary.BigEndian, uint16(len(b))) + var hdr [2]byte + binary.BigEndian.PutUint16(hdr[:], uint16(len(b))) + buf.Write(hdr[:]) buf.Write(b) n, err := pc.Write(buf.Bytes()) diff --git a/proxy/vmess/auth.go b/proxy/vmess/auth.go index 90e5902..d9c355b 100644 --- a/proxy/vmess/auth.go +++ b/proxy/vmess/auth.go @@ -119,17 +119,13 @@ func (h *hMacCreator) Create() hash.Hash { } func createAuthID(cmdKey []byte, time int64) [16]byte { - buf := &bytes.Buffer{} - binary.Write(buf, binary.BigEndian, time) - - random := make([]byte, 4) - rand.Read(random) - buf.Write(random) - zero := crc32.ChecksumIEEE(buf.Bytes()) - binary.Write(buf, binary.BigEndian, zero) + var buf [16]byte + binary.BigEndian.PutUint64(buf[0:8], uint64(time)) + rand.Read(buf[8:12]) + binary.BigEndian.PutUint32(buf[12:16], crc32.ChecksumIEEE(buf[:12])) aesBlock, _ := aes.NewCipher(kdf(cmdKey[:], kdfSaltConstAuthIDEncryptionKey)[:16]) var result [16]byte - aesBlock.Encrypt(result[:], buf.Bytes()) + aesBlock.Encrypt(result[:], buf[:]) return result } diff --git a/proxy/vmess/client.go b/proxy/vmess/client.go index e03afd2..4344366 100644 --- a/proxy/vmess/client.go +++ b/proxy/vmess/client.go @@ -201,9 +201,11 @@ func (c *Conn) Request(cmd CmdType) error { buf.WriteByte(byte(cmd)) // cmd // target - binary.Write(buf, binary.BigEndian, uint16(c.port)) // port - buf.WriteByte(byte(c.atyp)) // atyp - buf.Write(c.addr) // addr + var port [2]byte + binary.BigEndian.PutUint16(port[:], uint16(c.port)) + buf.Write(port[:]) + buf.WriteByte(byte(c.atyp)) // atyp + buf.Write(c.addr) // addr // padding if paddingLen > 0 {