lzhr/v2fly
1
0
Fork 0
mirror of https://github.com/v2fly/v2ray-core.git synced 2025-02-20 23:47:21 -05:00
Code Issues Releases Wiki Activity

fix proxy ss2022 client lints

Browse Source
This commit is contained in:
Shelikhoo 2023-11-19 00:42:20 +00:00 committed by Xiaokang Wang (Shelikhoo)
parent 8a1777ce62
commit 39851b3732
10 changed files with 90 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
proxy/shadowsocks2022/client.go
View File

@ -2,6 +2,10 @@ package shadowsocks2022
import ( import (
"context" "context"
gonet "net"
"sync"
"time"
"github.com/v2fly/v2ray-core/v5/common" "github.com/v2fly/v2ray-core/v5/common"
"github.com/v2fly/v2ray-core/v5/common/buf" "github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/environment" "github.com/v2fly/v2ray-core/v5/common/environment"
@ -15,9 +19,6 @@ import (
"github.com/v2fly/v2ray-core/v5/transport" "github.com/v2fly/v2ray-core/v5/transport"
"github.com/v2fly/v2ray-core/v5/transport/internet" "github.com/v2fly/v2ray-core/v5/transport/internet"
"github.com/v2fly/v2ray-core/v5/transport/internet/udp" "github.com/v2fly/v2ray-core/v5/transport/internet/udp"
gonet "net"
"sync"
"time"
) )
type Client struct { type Client struct {
@ -33,17 +34,17 @@ type ClientUDPConnState struct {
} }
func (c *ClientUDPConnState) GetOrCreateSession(create func() (*ClientUDPSession, error)) (*ClientUDPSession, error) { func (c *ClientUDPConnState) GetOrCreateSession(create func() (*ClientUDPSession, error)) (*ClientUDPSession, error) {
var err error var errOuter error
c.initOnce.Do(func() { c.initOnce.Do(func() {
sessionState, err := create() sessionState, err := create()
if err != nil { if err != nil {
err = newError("failed to create UDP session").Base(err) errOuter = newError("failed to create UDP session").Base(err)
return return
} }
c.session = sessionState c.session = sessionState
}) })
if err != nil { if errOuter != nil {
return nil, newError("failed to initialize UDP State").Base(err) return nil, newError("failed to initialize UDP State").Base(errOuter)
} }
return c.session, nil return c.session, nil
} }
@ -60,7 +61,7 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
destination := outbound.Target destination := outbound.Target
network := destination.Network network := destination.Network
var keyDerivation = newBLAKE3KeyDerivation() keyDerivation := newBLAKE3KeyDerivation()
var method Method var method Method
switch c.config.Method { switch c.config.Method {
case "2022-blake3-aes-128-gcm": case "2022-blake3-aes-128-gcm":
@ -107,7 +108,6 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
return nil return nil
}) })
if err != nil { if err != nil {
return newError("failed to find an available destination").AtWarning().Base(err) return newError("failed to find an available destination").AtWarning().Base(err)
} }
@ -222,7 +222,6 @@ func (c *Client) getUDPSession(ctx context.Context, network net.Network, dialer
} }
func NewClient(ctx context.Context, config *ClientConfig) (*Client, error) { func NewClient(ctx context.Context, config *ClientConfig) (*Client, error) {
storage := envctx.EnvironmentFromContext(ctx).(environment.ProxyEnvironment).TransientStorage() storage := envctx.EnvironmentFromContext(ctx).(environment.ProxyEnvironment).TransientStorage()
udpState, err := NewClientUDPConnState() udpState, err := NewClientUDPConnState()

9
proxy/shadowsocks2022/client_session.go
View File

@ -3,13 +3,14 @@ package shadowsocks2022
import ( import (
"context" "context"
"crypto/rand" "crypto/rand"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
"io" "io"
gonet "net" gonet "net"
"sync" "sync"
"time" "time"
"github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/transport/internet"
) )
func NewClientUDPSession(ctx context.Context, conn io.ReadWriteCloser, packetProcessor UDPClientPacketProcessor) *ClientUDPSession { func NewClientUDPSession(ctx context.Context, conn io.ReadWriteCloser, packetProcessor UDPClientPacketProcessor) *ClientUDPSession {
@ -165,7 +166,7 @@ func (c *ClientUDPSessionConn) ReadFrom(p []byte) (n int, addr net.Addr, err err
case resp := <-c.readChan: case resp := <-c.readChan:
n = copy(p, resp.Payload.Bytes()) n = copy(p, resp.Payload.Bytes())
resp.Payload.Release() resp.Payload.Release()
addr = &net.UDPAddr{IP: resp.Address.IP(), Port: int(resp.Port)} addr = &net.UDPAddr{IP: resp.Address.IP(), Port: resp.Port}
} }
return return
} }

7
proxy/shadowsocks2022/eih_aes.go
View File

@ -2,9 +2,12 @@ package shadowsocks2022
import ( import (
"crypto/subtle" "crypto/subtle"
"github.com/lunixbochs/struc"
"github.com/v2fly/v2ray-core/v5/common/buf"
"io" "io"
"github.com/lunixbochs/struc"
"github.com/v2fly/v2ray-core/v5/common/buf"
"lukechampine.com/blake3" "lukechampine.com/blake3"
) )

36
proxy/shadowsocks2022/encoding.go
View File

@ -9,6 +9,7 @@ import (
"time" "time"
"github.com/lunixbochs/struc" "github.com/lunixbochs/struc"
"github.com/v2fly/v2ray-core/v5/common/buf" "github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/crypto" "github.com/v2fly/v2ray-core/v5/common/crypto"
"github.com/v2fly/v2ray-core/v5/common/net" "github.com/v2fly/v2ray-core/v5/common/net"
@ -32,7 +33,8 @@ type TCPRequest struct {
} }
func (t *TCPRequest) EncodeTCPRequestHeader(effectivePsk []byte, func (t *TCPRequest) EncodeTCPRequestHeader(effectivePsk []byte,
eih [][]byte, address DestinationAddress, destPort int, initialPayload []byte, Out *buf.Buffer) error { eih [][]byte, address DestinationAddress, destPort int, initialPayload []byte, out *buf.Buffer,
) error {
requestSalt := newRequestSaltWithLength(t.method.GetSessionSubKeyAndSaltLength()) requestSalt := newRequestSaltWithLength(t.method.GetSessionSubKeyAndSaltLength())
{ {
err := requestSalt.FillAllFrom(cryptoRand.Reader) err := requestSalt.FillAllFrom(cryptoRand.Reader)
@ -41,7 +43,7 @@ func (t *TCPRequest) EncodeTCPRequestHeader(effectivePsk []byte,
} }
} }
t.c2sSalt = requestSalt t.c2sSalt = requestSalt
var sessionKey = make([]byte, t.method.GetSessionSubKeyAndSaltLength()) sessionKey := make([]byte, t.method.GetSessionSubKeyAndSaltLength())
{ {
err := t.keyDerivation.GetSessionSubKey(effectivePsk, requestSalt.Bytes(), sessionKey) err := t.keyDerivation.GetSessionSubKey(effectivePsk, requestSalt.Bytes(), sessionKey)
if err != nil { if err != nil {
@ -54,7 +56,7 @@ func (t *TCPRequest) EncodeTCPRequestHeader(effectivePsk []byte,
return newError("failed to get stream AEAD").Base(err) return newError("failed to get stream AEAD").Base(err)
} }
t.c2sAEAD = aead t.c2sAEAD = aead
var paddingLength = TCPMinPaddingLength paddingLength := TCPMinPaddingLength
if initialPayload == nil { if initialPayload == nil {
initialPayload = []byte{} initialPayload = []byte{}
paddingLength += rand.Intn(TCPMaxPaddingLength) // TODO INSECURE RANDOM USED paddingLength += rand.Intn(TCPMaxPaddingLength) // TODO INSECURE RANDOM USED
@ -128,7 +130,7 @@ func (t *TCPRequest) EncodeTCPRequestHeader(effectivePsk []byte,
requestNonce := crypto.GenerateInitialAEADNonce() requestNonce := crypto.GenerateInitialAEADNonce()
t.c2sNonce = requestNonce t.c2sNonce = requestNonce
{ {
n, err := Out.Write(preSessionKeyHeaderBuffer.BytesFrom(0)) n, err := out.Write(preSessionKeyHeaderBuffer.BytesFrom(0))
if err != nil { if err != nil {
return newError("failed to write pre session key header").Base(err) return newError("failed to write pre session key header").Base(err)
} }
@ -137,28 +139,28 @@ func (t *TCPRequest) EncodeTCPRequestHeader(effectivePsk []byte,
} }
} }
{ {
fixedLengthEncrypted := Out.Extend(fixedLengthHeaderBuffer.Len() + int32(aead.Overhead())) fixedLengthEncrypted := out.Extend(fixedLengthHeaderBuffer.Len() + int32(aead.Overhead()))
aead.Seal(fixedLengthEncrypted[:0], requestNonce(), fixedLengthHeaderBuffer.Bytes(), nil) aead.Seal(fixedLengthEncrypted[:0], requestNonce(), fixedLengthHeaderBuffer.Bytes(), nil)
} }
{ {
variableLengthEncrypted := Out.Extend(variableLengthHeaderBuffer.Len() + int32(aead.Overhead())) variableLengthEncrypted := out.Extend(variableLengthHeaderBuffer.Len() + int32(aead.Overhead()))
aead.Seal(variableLengthEncrypted[:0], requestNonce(), variableLengthHeaderBuffer.Bytes(), nil) aead.Seal(variableLengthEncrypted[:0], requestNonce(), variableLengthHeaderBuffer.Bytes(), nil)
} }
return nil return nil
} }
func (t *TCPRequest) DecodeTCPResponseHeader(effectivePsk []byte, In io.Reader) error { func (t *TCPRequest) DecodeTCPResponseHeader(effectivePsk []byte, in io.Reader) error {
var preSessionKeyHeader TCPResponseHeader1PreSessionKey var preSessionKeyHeader TCPResponseHeader1PreSessionKey
preSessionKeyHeader.Salt = newRequestSaltWithLength(t.method.GetSessionSubKeyAndSaltLength()) preSessionKeyHeader.Salt = newRequestSaltWithLength(t.method.GetSessionSubKeyAndSaltLength())
{ {
err := struc.Unpack(In, &preSessionKeyHeader) err := struc.Unpack(in, &preSessionKeyHeader)
if err != nil { if err != nil {
return newError("failed to unpack pre session key header").Base(err) return newError("failed to unpack pre session key header").Base(err)
} }
} }
var s2cSalt = preSessionKeyHeader.Salt.Bytes() s2cSalt := preSessionKeyHeader.Salt.Bytes()
t.s2cSalt = preSessionKeyHeader.Salt t.s2cSalt = preSessionKeyHeader.Salt
var sessionKey = make([]byte, t.method.GetSessionSubKeyAndSaltLength()) sessionKey := make([]byte, t.method.GetSessionSubKeyAndSaltLength())
{ {
err := t.keyDerivation.GetSessionSubKey(effectivePsk, s2cSalt, sessionKey) err := t.keyDerivation.GetSessionSubKey(effectivePsk, s2cSalt, sessionKey)
if err != nil { if err != nil {
@ -171,17 +173,17 @@ func (t *TCPRequest) DecodeTCPResponseHeader(effectivePsk []byte, In io.Reader)
} }
t.s2cAEAD = aead t.s2cAEAD = aead
var fixedLengthHeaderEncryptedBuffer = buf.New() fixedLengthHeaderEncryptedBuffer := buf.New()
defer fixedLengthHeaderEncryptedBuffer.Release() defer fixedLengthHeaderEncryptedBuffer.Release()
{ {
_, err := fixedLengthHeaderEncryptedBuffer.ReadFullFrom(In, 11+int32(t.method.GetSessionSubKeyAndSaltLength())+int32(aead.Overhead())) _, err := fixedLengthHeaderEncryptedBuffer.ReadFullFrom(in, 11+int32(t.method.GetSessionSubKeyAndSaltLength())+int32(aead.Overhead()))
if err != nil { if err != nil {
return newError("failed to read fixed length header encrypted").Base(err) return newError("failed to read fixed length header encrypted").Base(err)
} }
} }
s2cNonce := crypto.GenerateInitialAEADNonce() s2cNonce := crypto.GenerateInitialAEADNonce()
t.s2cNonce = s2cNonce t.s2cNonce = s2cNonce
var fixedLengthHeaderDecryptedBuffer = buf.New() fixedLengthHeaderDecryptedBuffer := buf.New()
defer fixedLengthHeaderDecryptedBuffer.Release() defer fixedLengthHeaderDecryptedBuffer.Release()
{ {
decryptionBuffer := fixedLengthHeaderDecryptedBuffer.Extend(11 + int32(t.method.GetSessionSubKeyAndSaltLength())) decryptionBuffer := fixedLengthHeaderDecryptedBuffer.Extend(11 + int32(t.method.GetSessionSubKeyAndSaltLength()))
@ -213,13 +215,13 @@ func (t *TCPRequest) DecodeTCPResponseHeader(effectivePsk []byte, In io.Reader)
} }
func (t *TCPRequest) CheckC2SConnectionConstraint() error { func (t *TCPRequest) CheckC2SConnectionConstraint() error {
if bytes.Compare(t.c2sSalt.Bytes(), t.s2cSaltAssert.Bytes()) != 0 { if !bytes.Equal(t.c2sSalt.Bytes(), t.s2cSaltAssert.Bytes()) {
return newError("c2s salt not equal to s2c salt assert") return newError("c2s salt not equal to s2c salt assert")
} }
return nil return nil
} }
func (t *TCPRequest) CreateClientS2CReader(In io.Reader, initialPayload *buf.Buffer) (buf.Reader, error) { func (t *TCPRequest) CreateClientS2CReader(in io.Reader, initialPayload *buf.Buffer) (buf.Reader, error) {
AEADAuthenticator := &crypto.AEADAuthenticator{ AEADAuthenticator := &crypto.AEADAuthenticator{
AEAD: t.s2cAEAD, AEAD: t.s2cAEAD,
NonceGenerator: t.s2cNonce, NonceGenerator: t.s2cNonce,
@ -228,7 +230,7 @@ func (t *TCPRequest) CreateClientS2CReader(In io.Reader, initialPayload *buf.Buf
initialPayloadEncrypted := buf.NewWithSize(65535) initialPayloadEncrypted := buf.NewWithSize(65535)
defer initialPayloadEncrypted.Release() defer initialPayloadEncrypted.Release()
initialPayloadEncryptedBytes := initialPayloadEncrypted.Extend(int32(t.s2cAEAD.Overhead()) + int32(t.s2cInitialPayloadSize)) initialPayloadEncryptedBytes := initialPayloadEncrypted.Extend(int32(t.s2cAEAD.Overhead()) + int32(t.s2cInitialPayloadSize))
_, err := io.ReadFull(In, initialPayloadEncryptedBytes) _, err := io.ReadFull(in, initialPayloadEncryptedBytes)
if err != nil { if err != nil {
return nil, newError("failed to read initial payload").Base(err) return nil, newError("failed to read initial payload").Base(err)
} }
@ -239,7 +241,7 @@ func (t *TCPRequest) CreateClientS2CReader(In io.Reader, initialPayload *buf.Buf
} }
return crypto.NewAuthenticationReader(AEADAuthenticator, &crypto.AEADChunkSizeParser{ return crypto.NewAuthenticationReader(AEADAuthenticator, &crypto.AEADChunkSizeParser{
Auth: AEADAuthenticator, Auth: AEADAuthenticator,
}, In, protocol.TransferTypeStream, nil), nil }, in, protocol.TransferTypeStream, nil), nil
} }
func (t *TCPRequest) CreateClientC2SWriter(writer io.Writer) buf.Writer { func (t *TCPRequest) CreateClientC2SWriter(writer io.Writer) buf.Writer {

18
proxy/shadowsocks2022/kdf_blake3.go
View File

@ -1,31 +1,31 @@
package shadowsocks2022 package shadowsocks2022
import ( import (
"github.com/v2fly/v2ray-core/v5/common/buf"
"lukechampine.com/blake3" "lukechampine.com/blake3"
"github.com/v2fly/v2ray-core/v5/common/buf"
) )
func newBLAKE3KeyDerivation() *BLAKE3KeyDerivation { func newBLAKE3KeyDerivation() *BLAKE3KeyDerivation {
return &BLAKE3KeyDerivation{} return &BLAKE3KeyDerivation{}
} }
type BLAKE3KeyDerivation struct { type BLAKE3KeyDerivation struct{}
}
func (B BLAKE3KeyDerivation) GetSessionSubKey(effectivePsk, Salt []byte, OutKey []byte) error { func (b BLAKE3KeyDerivation) GetSessionSubKey(effectivePsk, salt []byte, outKey []byte) error {
keyingMaterialBuffer := buf.New() keyingMaterialBuffer := buf.New()
keyingMaterialBuffer.Write(effectivePsk) keyingMaterialBuffer.Write(effectivePsk)
keyingMaterialBuffer.Write(Salt) keyingMaterialBuffer.Write(salt)
blake3.DeriveKey(OutKey, "shadowsocks 2022 session subkey", keyingMaterialBuffer.Bytes()) blake3.DeriveKey(outKey, "shadowsocks 2022 session subkey", keyingMaterialBuffer.Bytes())
keyingMaterialBuffer.Release() keyingMaterialBuffer.Release()
return nil return nil
} }
func (B BLAKE3KeyDerivation) GetIdentitySubKey(effectivePsk, Salt []byte, OutKey []byte) error { func (b BLAKE3KeyDerivation) GetIdentitySubKey(effectivePsk, salt []byte, outKey []byte) error {
keyingMaterialBuffer := buf.New() keyingMaterialBuffer := buf.New()
keyingMaterialBuffer.Write(effectivePsk) keyingMaterialBuffer.Write(effectivePsk)
keyingMaterialBuffer.Write(Salt) keyingMaterialBuffer.Write(salt)
blake3.DeriveKey(OutKey, "shadowsocks 2022 identity subkey", keyingMaterialBuffer.Bytes()) blake3.DeriveKey(outKey, "shadowsocks 2022 identity subkey", keyingMaterialBuffer.Bytes())
keyingMaterialBuffer.Release() keyingMaterialBuffer.Release()
return nil return nil
} }

22
proxy/shadowsocks2022/method_aes128gcm.go
View File

@ -9,15 +9,14 @@ func newAES128GCMMethod() *AES128GCMMethod {
return &AES128GCMMethod{} return &AES128GCMMethod{}
} }
type AES128GCMMethod struct { type AES128GCMMethod struct{}
}
func (A AES128GCMMethod) GetSessionSubKeyAndSaltLength() int { func (a AES128GCMMethod) GetSessionSubKeyAndSaltLength() int {
return 16 return 16
} }
func (A AES128GCMMethod) GetStreamAEAD(SessionSubKey []byte) (cipher.AEAD, error) { func (a AES128GCMMethod) GetStreamAEAD(sessionSubKey []byte) (cipher.AEAD, error) {
aesCipher, err := aes.NewCipher(SessionSubKey) aesCipher, err := aes.NewCipher(sessionSubKey)
if err != nil { if err != nil {
return nil, newError("failed to create AES cipher").Base(err) return nil, newError("failed to create AES cipher").Base(err)
} }
@ -28,8 +27,8 @@ func (A AES128GCMMethod) GetStreamAEAD(SessionSubKey []byte) (cipher.AEAD, error
return aead, nil return aead, nil
} }
func (A AES128GCMMethod) GenerateEIH(CurrentIdentitySubKey []byte, nextPskHash []byte, out []byte) error { func (a AES128GCMMethod) GenerateEIH(currentIdentitySubKey []byte, nextPskHash []byte, out []byte) error {
aesCipher, err := aes.NewCipher(CurrentIdentitySubKey) aesCipher, err := aes.NewCipher(currentIdentitySubKey)
if err != nil { if err != nil {
return newError("failed to create AES cipher").Base(err) return newError("failed to create AES cipher").Base(err)
} }
@ -37,7 +36,7 @@ func (A AES128GCMMethod) GenerateEIH(CurrentIdentitySubKey []byte, nextPskHash [
return nil return nil
} }
func (A AES128GCMMethod) GetUDPClientProcessor(ipsk [][]byte, psk []byte, derivation KeyDerivation) (UDPClientPacketProcessor, error) { func (a AES128GCMMethod) GetUDPClientProcessor(ipsk [][]byte, psk []byte, derivation KeyDerivation) (UDPClientPacketProcessor, error) {
reqSeparateHeaderPsk := psk reqSeparateHeaderPsk := psk
if ipsk != nil { if ipsk != nil {
reqSeparateHeaderPsk = ipsk[0] reqSeparateHeaderPsk = ipsk[0]
@ -51,9 +50,12 @@ func (A AES128GCMMethod) GetUDPClientProcessor(ipsk [][]byte, psk []byte, deriva
return nil, newError("failed to create AES cipher").Base(err) return nil, newError("failed to create AES cipher").Base(err)
} }
getPacketAEAD := func(sessionID []byte) cipher.AEAD { getPacketAEAD := func(sessionID []byte) cipher.AEAD {
sessionKey := make([]byte, A.GetSessionSubKeyAndSaltLength()) sessionKey := make([]byte, a.GetSessionSubKeyAndSaltLength())
derivation.GetSessionSubKey(psk, sessionID, sessionKey) derivation.GetSessionSubKey(psk, sessionID, sessionKey)
block, err := aes.NewCipher(sessionKey) block, err := aes.NewCipher(sessionKey)
if err != nil {
panic(err)
}
aead, err := cipher.NewGCM(block) aead, err := cipher.NewGCM(block)
if err != nil { if err != nil {
panic(err) panic(err)
@ -62,7 +64,7 @@ func (A AES128GCMMethod) GetUDPClientProcessor(ipsk [][]byte, psk []byte, deriva
} }
eihGenerator := newAESEIHGeneratorContainer(len(ipsk), psk, ipsk) eihGenerator := newAESEIHGeneratorContainer(len(ipsk), psk, ipsk)
getEIH := func(mask []byte) ExtensibleIdentityHeaders { getEIH := func(mask []byte) ExtensibleIdentityHeaders {
eih, err := eihGenerator.GenerateEIHUDP(derivation, A, mask) eih, err := eihGenerator.GenerateEIHUDP(derivation, a, mask)
if err != nil { if err != nil {
newError("failed to generate EIH").Base(err).WriteToLog() newError("failed to generate EIH").Base(err).WriteToLog()
} }

22
proxy/shadowsocks2022/method_aes256gcm.go
View File

@ -9,15 +9,14 @@ func newAES256GCMMethod() *AES256GCMMethod {
return &AES256GCMMethod{} return &AES256GCMMethod{}
} }
type AES256GCMMethod struct { type AES256GCMMethod struct{}
}
func (A AES256GCMMethod) GetSessionSubKeyAndSaltLength() int { func (a AES256GCMMethod) GetSessionSubKeyAndSaltLength() int {
return 32 return 32
} }
func (A AES256GCMMethod) GetStreamAEAD(SessionSubKey []byte) (cipher.AEAD, error) { func (a AES256GCMMethod) GetStreamAEAD(sessionSubKey []byte) (cipher.AEAD, error) {
aesCipher, err := aes.NewCipher(SessionSubKey) aesCipher, err := aes.NewCipher(sessionSubKey)
if err != nil { if err != nil {
return nil, newError("failed to create AES cipher").Base(err) return nil, newError("failed to create AES cipher").Base(err)
} }
@ -28,8 +27,8 @@ func (A AES256GCMMethod) GetStreamAEAD(SessionSubKey []byte) (cipher.AEAD, error
return aead, nil return aead, nil
} }
func (A AES256GCMMethod) GenerateEIH(CurrentIdentitySubKey []byte, nextPskHash []byte, out []byte) error { func (a AES256GCMMethod) GenerateEIH(currentIdentitySubKey []byte, nextPskHash []byte, out []byte) error {
aesCipher, err := aes.NewCipher(CurrentIdentitySubKey) aesCipher, err := aes.NewCipher(currentIdentitySubKey)
if err != nil { if err != nil {
return newError("failed to create AES cipher").Base(err) return newError("failed to create AES cipher").Base(err)
} }
@ -37,7 +36,7 @@ func (A AES256GCMMethod) GenerateEIH(CurrentIdentitySubKey []byte, nextPskHash [
return nil return nil
} }
func (A AES256GCMMethod) GetUDPClientProcessor(ipsk [][]byte, psk []byte, derivation KeyDerivation) (UDPClientPacketProcessor, error) { func (a AES256GCMMethod) GetUDPClientProcessor(ipsk [][]byte, psk []byte, derivation KeyDerivation) (UDPClientPacketProcessor, error) {
reqSeparateHeaderPsk := psk reqSeparateHeaderPsk := psk
if ipsk != nil { if ipsk != nil {
reqSeparateHeaderPsk = ipsk[0] reqSeparateHeaderPsk = ipsk[0]
@ -51,9 +50,12 @@ func (A AES256GCMMethod) GetUDPClientProcessor(ipsk [][]byte, psk []byte, deriva
return nil, newError("failed to create AES cipher").Base(err) return nil, newError("failed to create AES cipher").Base(err)
} }
getPacketAEAD := func(sessionID []byte) cipher.AEAD { getPacketAEAD := func(sessionID []byte) cipher.AEAD {
sessionKey := make([]byte, A.GetSessionSubKeyAndSaltLength()) sessionKey := make([]byte, a.GetSessionSubKeyAndSaltLength())
derivation.GetSessionSubKey(psk, sessionID, sessionKey) derivation.GetSessionSubKey(psk, sessionID, sessionKey)
block, err := aes.NewCipher(sessionKey) block, err := aes.NewCipher(sessionKey)
if err != nil {
panic(err)
}
aead, err := cipher.NewGCM(block) aead, err := cipher.NewGCM(block)
if err != nil { if err != nil {
panic(err) panic(err)
@ -62,7 +64,7 @@ func (A AES256GCMMethod) GetUDPClientProcessor(ipsk [][]byte, psk []byte, deriva
} }
eihGenerator := newAESEIHGeneratorContainer(len(ipsk), psk, ipsk) eihGenerator := newAESEIHGeneratorContainer(len(ipsk), psk, ipsk)
getEIH := func(mask []byte) ExtensibleIdentityHeaders { getEIH := func(mask []byte) ExtensibleIdentityHeaders {
eih, err := eihGenerator.GenerateEIHUDP(derivation, A, mask) eih, err := eihGenerator.GenerateEIHUDP(derivation, a, mask)
if err != nil { if err != nil {
newError("failed to generate EIH").Base(err).WriteToLog() newError("failed to generate EIH").Base(err).WriteToLog()
} }

3
proxy/shadowsocks2022/requestsalt.go
View File

@ -2,8 +2,9 @@ package shadowsocks2022
import ( import (
"encoding/hex" "encoding/hex"
"github.com/lunixbochs/struc"
"io" "io"
"github.com/lunixbochs/struc"
) )
func newRequestSaltWithLength(length int) RequestSalt { func newRequestSaltWithLength(length int) RequestSalt {

20
proxy/shadowsocks2022/ss2022.go
View File

@ -2,11 +2,13 @@ package shadowsocks2022
import ( import (
"crypto/cipher" "crypto/cipher"
"io"
"github.com/lunixbochs/struc" "github.com/lunixbochs/struc"
"github.com/v2fly/v2ray-core/v5/common/buf" "github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net" "github.com/v2fly/v2ray-core/v5/common/net"
"github.com/v2fly/v2ray-core/v5/common/protocol" "github.com/v2fly/v2ray-core/v5/common/protocol"
"io"
) )
//go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen //go:generate go run github.com/v2fly/v2ray-core/v5/common/errors/errorgen
@ -78,10 +80,12 @@ type TCPResponseHeader struct {
Header TCPResponseHeader2FixedLength Header TCPResponseHeader2FixedLength
} }
const TCPHeaderTypeClientToServerStream = byte(0x00) const (
const TCPHeaderTypeServerToClientStream = byte(0x01) TCPHeaderTypeClientToServerStream = byte(0x00)
const TCPMinPaddingLength = 0 TCPHeaderTypeServerToClientStream = byte(0x01)
const TCPMaxPaddingLength = 900 TCPMinPaddingLength = 0
TCPMaxPaddingLength = 900
)
var addrParser = protocol.NewAddressParser( var addrParser = protocol.NewAddressParser(
protocol.AddressFamilyByte(0x01, net.AddressFamilyIPv4), protocol.AddressFamilyByte(0x01, net.AddressFamilyIPv4),
@ -103,8 +107,10 @@ type UDPResponse struct {
ClientSessionID [8]byte ClientSessionID [8]byte
} }
const UDPHeaderTypeClientToServerStream = byte(0x00) const (
const UDPHeaderTypeServerToClientStream = byte(0x01) UDPHeaderTypeClientToServerStream = byte(0x00)
UDPHeaderTypeServerToClientStream = byte(0x01)
)
// UDPClientPacketProcessor // UDPClientPacketProcessor
// Caller retain and receive all ownership of the buffer // Caller retain and receive all ownership of the buffer

6
proxy/shadowsocks2022/udp_aes.go
View File

@ -3,10 +3,12 @@ package shadowsocks2022
import ( import (
"bytes" "bytes"
"crypto/cipher" "crypto/cipher"
"io"
"github.com/lunixbochs/struc" "github.com/lunixbochs/struc"
"github.com/v2fly/v2ray-core/v5/common/buf" "github.com/v2fly/v2ray-core/v5/common/buf"
"github.com/v2fly/v2ray-core/v5/common/net" "github.com/v2fly/v2ray-core/v5/common/net"
"io"
) )
type AESUDPClientPacketProcessor struct { type AESUDPClientPacketProcessor struct {
@ -140,7 +142,7 @@ func (p *AESUDPClientPacketProcessor) DecodeUDPResp(input []byte, resp *UDPRespo
} }
} }
resp.TimeStamp = headerStruct.TimeStamp resp.TimeStamp = headerStruct.TimeStamp
var addressReaderBuf = buf.New() addressReaderBuf := buf.New()
defer addressReaderBuf.Release() defer addressReaderBuf.Release()
var port net.Port var port net.Port
resp.Address, port, err = addrParser.ReadAddressPort(addressReaderBuf, decryptedDestReader) resp.Address, port, err = addrParser.ReadAddressPort(addressReaderBuf, decryptedDestReader)