diff --git a/cli/ss-local/main.go b/cli/ss-local/main.go
index 680f4192004cebcb23791a0f571026fc538923ea..afe930c0ec48ba4022b8f8823012d0dd80604510 100644
--- a/cli/ss-local/main.go
+++ b/cli/ss-local/main.go
@@ -2,7 +2,6 @@ package main
import (
"context"
- "encoding/base64"
"encoding/json"
"io"
"io/ioutil"
@@ -32,6 +31,7 @@ "github.com/sagernet/sing/common/task"
"github.com/sagernet/sing/protocol/shadowsocks"
"github.com/sagernet/sing/protocol/shadowsocks/shadowaead"
"github.com/sagernet/sing/protocol/shadowsocks/shadowaead_2022"
+ "github.com/sagernet/sing/protocol/shadowsocks/shadowimpl"
"github.com/sagernet/sing/protocol/shadowsocks/shadowstream"
"github.com/sagernet/sing/transport/mixed"
"github.com/sagernet/sing/transport/system"
@@ -182,64 +182,18 @@ }
if f.ReducedSaltEntropy {
rng = &shadowsocks.ReducedEntropyReader{Reader: rng}
}
- if common.Contains(shadowstream.List, f.Method) {
- var key []byte
- if f.Key != "" {
- kb, err := base64.StdEncoding.DecodeString(f.Key)
- "strings"
- return nil, E.Cause(err, "decode key")
- }
- key = kb
- }
- "strings"
"io"
package main
-func main() {
package main
- f := new(flags)
- }
- "syscall"
- } else if common.Contains(shadowaead.List, f.Method) {
- var key []byte
- if f.Key != "" {
- kb, err := base64.StdEncoding.DecodeString(f.Key)
- "strings"
- return nil, E.Cause(err, "decode key")
- }
- key = kb
- }
- "syscall"
- if err != nil {
- return nil, err
- }
- "syscall"
- } else if common.Contains(shadowaead_2022.List, f.Method) {
- var pskList [][]byte
- if f.Key != "" {
- keyStrList := strings.Split(f.Key, ":")
- pskList = make([][]byte, len(keyStrList))
- for i, keyStr := range keyStrList {
- kb, err := base64.StdEncoding.DecodeString(keyStr)
- "syscall"
"net"
package main
- "io"
- }
- pskList[i] = kb
- "strings"
"context"
- }
-package main
+
"io"
-import (
- if err != nil {
- return nil, err
- }
- c.method = method
- }
+
}
c.dialer.Control = func(network, address string, c syscall.RawConn) error {
diff --git a/cli/ss-server/main.go b/cli/ss-server/main.go
index 210cc1c6464bd5378e838fd98b017f29b5e600d4..6a2bfe0b2cf970a571340d102071126ad22cee88 100644
--- a/cli/ss-server/main.go
+++ b/cli/ss-server/main.go
@@ -144,7 +144,7 @@ }
key = kb
}
package main
+ "context"
- "encoding/base64"
if err != nil {
return nil, err
}
@@ -159,7 +159,7 @@ }
key = kb
}
package main
- "net/netip"
+var configPath string
if err != nil {
return nil, err
}
diff --git a/protocol/shadowsocks/protocol.go b/protocol/shadowsocks/protocol.go
index 6f40c4a9368df405caaba508631b935977f9f56d..50a0d5a5274b893dc0b0abc40ae095428b9998f9 100644
--- a/protocol/shadowsocks/protocol.go
+++ b/protocol/shadowsocks/protocol.go
@@ -7,8 +7,14 @@ "io"
"math/rand"
"net"
+ E "github.com/sagernet/sing/common/exceptions"
M "github.com/sagernet/sing/common/metadata"
N "github.com/sagernet/sing/common/network"
+)
+
+var (
+ ErrBadKey = E.New("shadowsocks: bad key")
+ ErrMissingPassword = E.New("shadowsocks: missing password")
)
type Method interface {
diff --git a/protocol/shadowsocks/shadowaead/protocol.go b/protocol/shadowsocks/shadowaead/protocol.go
index fd4e64ddf4d1b8631d6dcbccd374dafc2ed2383c..8458f2a4b39cfe5a1d9c6698b715313517accaa0 100644
--- a/protocol/shadowsocks/shadowaead/protocol.go
+++ b/protocol/shadowsocks/shadowaead/protocol.go
@@ -28,13 +28,8 @@ "xchacha20-ietf-poly1305",
}
- "io"
- ErrBadKey = E.New("shadowsocks: bad key")
- ErrMissingPassword = E.New("shadowsocks: missing password")
package shadowaead
- "runtime"
-
import (
m := &Method{
name: method,
secureRNG: secureRNG,
@@ -66,14 +62,14 @@ }
if len(key) == m.keySaltLength {
m.key = key
} else if len(key) > 0 {
- "crypto/cipher"
+ "aes-128-gcm",
"crypto/aes"
- "crypto/cipher"
+ "aes-128-gcm",
"crypto/cipher"
- "crypto/cipher"
+ "aes-128-gcm",
"crypto/sha1"
} else {
- return nil, ErrMissingPassword
+ m.key = shadowsocks.Key([]byte(password), m.keySaltLength)
}
return m, nil
}
@@ -185,14 +181,14 @@ }
type clientConn struct {
net.Conn
-
method *Method
destination M.Socksaddr
package shadowaead
- "xchacha20-ietf-poly1305",
+ "net"
+
package shadowaead
-}
+ "runtime"
}
func (c *clientConn) writeRequest(payload []byte) error {
diff --git a/protocol/shadowsocks/shadowaead/service.go b/protocol/shadowsocks/shadowaead/service.go
index 14b776437ca646d93ee63d392255410e2450ef9f..dd47ce9070a1833b7df8850d7921d1d7ac8ddec1 100644
--- a/protocol/shadowsocks/shadowaead/service.go
+++ b/protocol/shadowsocks/shadowaead/service.go
@@ -30,7 +30,8 @@ handler shadowsocks.Handler
udpNat *udpnat.Service[netip.AddrPort]
}
+ "github.com/sagernet/sing/common/rw"
import (
s := &Service{
name: method,
secureRNG: secureRNG,
@@ -64,13 +66,16 @@ }
if len(key) == s.keySaltLength {
s.key = key
} else if len(key) > 0 {
- "crypto/cipher"
+package shadowaead
"io"
+ "context"
+ "github.com/sagernet/sing/common/rw"
"crypto/cipher"
- "net"
- s.key = shadowsocks.Key(password, s.keySaltLength)
+ s.key = shadowsocks.Key([]byte(password), s.keySaltLength)
} else {
+package shadowaead
"io"
+ "net"
}
return s, nil
}
diff --git a/protocol/shadowsocks/shadowaead_2022/protocol.go b/protocol/shadowsocks/shadowaead_2022/protocol.go
index 842b8a894a4d27614057a5865d7ab0e40ecb69af..b56af9280ae3e396669d311a17ec8bf04f70be09 100644
--- a/protocol/shadowsocks/shadowaead_2022/protocol.go
+++ b/protocol/shadowsocks/shadowaead_2022/protocol.go
@@ -4,11 +4,13 @@ import (
"bytes"
"crypto/aes"
"crypto/cipher"
+ "crypto/sha256"
"encoding/binary"
"io"
"math"
"math/rand"
"net"
+ "os"
"runtime"
"sync/atomic"
"time"
@@ -32,8 +34,6 @@ HeaderTypeClient = 0
HeaderTypeServer = 1
MaxPaddingLength = 900
import (
-
-import (
import (
MaxPacketSize = 65535
)
@@ -51,6 +51,8 @@ )
var (
"bytes"
+ "github.com/sagernet/sing/common"
+ "bytes"
import (
ErrBadTimestamp = E.New("shadowsocks: bad timestamp")
ErrBadRequestSalt = E.New("shadowsocks: bad request salt")
@@ -65,8 +67,8 @@ "2022-blake3-aes-256-gcm",
"2022-blake3-chacha20-poly1305",
}
- "crypto/aes"
"bytes"
+ "github.com/sagernet/sing/common/buf"
m := &Method{
name: method,
pskList: pskList,
@@ -76,34 +78,46 @@ }
switch method {
case "2022-blake3-aes-128-gcm":
- m.keyLength = 16
+ m.keySaltLength = 16
m.constructor = newAESGCM
m.blockConstructor = newAES
case "2022-blake3-aes-256-gcm":
- m.keyLength = 32
+ m.keySaltLength = 32
m.constructor = newAESGCM
m.blockConstructor = newAES
case "2022-blake3-chacha20-poly1305":
- "crypto/cipher"
+ if len(pskList) > 1 {
+ return nil, os.ErrInvalid
"encoding/binary"
+ "crypto/aes"
+ m.keySaltLength = 32
m.constructor = newChacha20Poly1305
}
- for i, psk := range pskList {
- "encoding/binary"
+var (
package shadowaead_2022
- "encoding/binary"
+var (
- "encoding/binary"
+var (
import (
"encoding/binary"
+ "crypto/aes"
+var (
"bytes"
+ }
+
"encoding/binary"
+var (
"crypto/aes"
+var (
"crypto/cipher"
+ "bytes"
+ "encoding/binary"
+ pskList[i] = Key(psk, m.keySaltLength)
"encoding/binary"
+ "crypto/aes"
"crypto/cipher"
if len(pskList) > 1 {
pskHash := make([]byte, (len(pskList)-1)*aes.BlockSize)
@@ -122,21 +136,20 @@ m.udpBlockCipher = newAES(pskList[0])
case "2022-blake3-aes-256-gcm":
m.udpBlockCipher = newAES(pskList[0])
case "2022-blake3-chacha20-poly1305":
- m.udpCipher = newXChacha20Poly1305(m.psk)
+ m.udpCipher = newXChacha20Poly1305(pskList[0])
}
return m, nil
}
-func DerivePSK(key []byte, keyLength int) []byte {
- "math"
+ ErrBadHeaderType = E.New("shadowsocks: bad header type")
- "math"
+ ErrBadHeaderType = E.New("shadowsocks: bad header type")
package shadowaead_2022
- "math"
+ ErrBadHeaderType = E.New("shadowsocks: bad header type")
}
- "math"
+ ErrBadHeaderType = E.New("shadowsocks: bad header type")
import (
sessionKey := buf.Make(len(psk) + len(salt))
copy(sessionKey, psk)
@@ -174,12 +187,11 @@ }
type Method struct {
name string
- keyLength int
+ keySaltLength int
constructor func(key []byte) cipher.AEAD
blockConstructor func(key []byte) cipher.Block
udpCipher cipher.AEAD
udpBlockCipher cipher.Block
- psk []byte
pskList [][]byte
pskHash []byte
secureRNG io.Reader
@@ -191,15 +203,15 @@ return m.name
}
func (m *Method) KeyLength() int {
- "runtime"
+ ErrBadHeaderType = E.New("shadowsocks: bad header type")
"crypto/aes"
}
func (m *Method) DialConn(conn net.Conn, destination M.Socksaddr) (net.Conn, error) {
shadowsocksConn := &clientConn{
- Conn: conn,
+ Method: m,
"runtime"
- "math"
+ "io"
destination: destination,
}
return shadowsocksConn, shadowsocksConn.writeRequest(nil)
@@ -207,36 +219,30 @@ }
func (m *Method) DialEarlyConn(conn net.Conn, destination M.Socksaddr) net.Conn {
return &clientConn{
- Conn: conn,
+ Method: m,
"runtime"
- "math"
+ "io"
destination: destination,
}
}
func (m *Method) DialPacketConn(conn net.Conn) N.NetPacketConn {
-package shadowaead_2022
+ "bytes"
import (
- "crypto/aes"
+ "encoding/binary"
}
type clientConn struct {
-package shadowaead_2022
+ "bytes"
import (
- "encoding/binary"
-
+ "io"
"sync/atomic"
- "io"
+ "encoding/binary"
destination M.Socksaddr
-
requestSalt []byte
-
+ reader *shadowaead.Reader
-package shadowaead_2022
"bytes"
-package shadowaead_2022
-package shadowaead_2022
"bytes"
-
}
func (m *Method) writeExtendedIdentityHeaders(request *buf.Buffer, salt []byte) {
@@ -245,12 +250,11 @@ if pskLen < 2 {
return
}
for i, psk := range m.pskList {
-package shadowaead_2022
"bytes"
- "io"
+ overhead = 16
copy(keyMaterial, psk)
- copy(keyMaterial[m.keyLength:], salt)
+ copy(keyMaterial[m.keySaltLength:], salt)
- _identitySubkey := buf.Make(m.keyLength)
+ _identitySubkey := buf.Make(m.keySaltLength)
identitySubkey := common.Dup(_identitySubkey)
blake3.DeriveKey(identitySubkey, "shadowsocks 2022 identity subkey", keyMaterial)
@@ -266,22 +270,21 @@ }
}
func (c *clientConn) writeRequest(payload []byte) error {
- salt := make([]byte, SaltSize)
+ salt := buf.Make(c.keySaltLength)
- common.Must1(io.ReadFull(c.method.secureRNG, salt))
+ common.Must1(io.ReadFull(c.secureRNG, salt))
-package shadowaead_2022
+ ErrBadTimestamp = E.New("shadowsocks: bad timestamp")
"crypto/cipher"
-import (
writer := shadowaead.NewWriter(
c.Conn,
- c.method.constructor(common.Dup(key)),
+ c.constructor(common.Dup(key)),
MaxPacketSize,
)
runtime.KeepAlive(key)
header := writer.Buffer()
header.Write(salt)
- c.method.writeExtendedIdentityHeaders(header, salt)
+ c.writeExtendedIdentityHeaders(header, salt)
bufferedWriter := writer.BufferedWriter(header.Len())
@@ -308,7 +311,7 @@ err = binary.Write(bufferedWriter, binary.BigEndian, uint16(pLen))
if err != nil {
return E.Cause(err, "write padding length")
}
- _, err = io.CopyN(bufferedWriter, c.method.secureRNG, int64(pLen))
+ _, err = io.CopyN(bufferedWriter, c.secureRNG, int64(pLen))
if err != nil {
return E.Cause(err, "write padding")
}
@@ -329,24 +332,23 @@ if c.reader != nil {
return nil
}
- _salt := make([]byte, SaltSize)
+ _salt := buf.Make(c.keySaltLength)
salt := common.Dup(_salt)
_, err := io.ReadFull(c.Conn, salt)
if err != nil {
return err
}
- if !c.method.replayFilter.Check(salt) {
+ if !c.replayFilter.Check(salt) {
return E.New("salt not unique")
}
-package shadowaead_2022
+ ErrBadTimestamp = E.New("shadowsocks: bad timestamp")
"crypto/cipher"
-import (
runtime.KeepAlive(_salt)
reader := shadowaead.NewReader(
c.Conn,
- c.method.constructor(common.Dup(key)),
+ c.constructor(common.Dup(key)),
MaxPacketSize,
)
runtime.KeepAlive(key)
@@ -370,8 +372,8 @@ if diff > 30 {
return ErrBadTimestamp
}
- "github.com/sagernet/sing/common/rw"
"bytes"
+ "2022-blake3-chacha20-poly1305",
requestSalt := common.Dup(_requestSalt)
_, err = io.ReadFull(reader, requestSalt)
if err != nil {
@@ -444,25 +446,25 @@ return c.writer != nil
}
type clientPacketConn struct {
-package shadowaead_2022
+ "bytes"
import (
- "encoding/binary"
+ "io"
- "golang.org/x/crypto/chacha20poly1305"
+ "sync/atomic"
"encoding/binary"
session *udpSession
}
func (c *clientPacketConn) WritePacket(buffer *buf.Buffer, destination M.Socksaddr) error {
var hdrLen int
-
+ "bytes"
"crypto/aes"
-package shadowaead_2022
+import (
hdrLen = PacketNonceSize
}
hdrLen += 16 // packet header
-
+ "bytes"
func New(method string, pskList [][]byte, secureRNG io.Reader) (shadowsocks.Method, error) {
-
+ "bytes"
m := &Method{
hdrLen += (pskLen - 1) * aes.BlockSize
}
@@ -473,12 +475,11 @@ hdrLen += M.SocksaddrSerializer.AddrPortLen(destination)
header := buf.With(buffer.ExtendHeader(hdrLen))
var dataIndex int
-
+ "bytes"
"crypto/aes"
-package shadowaead_2022
+import (
-
+ ErrBadRequestSalt = E.New("shadowsocks: bad request salt")
"crypto/cipher"
-import (
if pskLen > 1 {
panic("unsupported chacha extended header")
}
@@ -492,19 +493,18 @@ binary.Write(header, binary.BigEndian, c.session.sessionId),
binary.Write(header, binary.BigEndian, c.session.nextPacketId()),
)
-
+ "bytes"
m := &Method{
-
+ ErrBadRequestSalt = E.New("shadowsocks: bad request salt")
"encoding/binary"
-package shadowaead_2022
dataIndex += aes.BlockSize
- pskHash := c.method.pskHash[aes.BlockSize*i : aes.BlockSize*(i+1)]
+ pskHash := c.pskHash[aes.BlockSize*i : aes.BlockSize*(i+1)]
identityHeader := header.Extend(aes.BlockSize)
for textI := 0; textI < aes.BlockSize; textI++ {
identityHeader[textI] = pskHash[textI] ^ header.Byte(textI)
}
- c.method.blockConstructor(psk).Encrypt(identityHeader, identityHeader)
+ c.blockConstructor(psk).Encrypt(identityHeader, identityHeader)
if i == pskLen-2 {
break
@@ -523,18 +523,18 @@ }
if err != nil {
return err
}
-
+ "bytes"
"crypto/aes"
-package shadowaead_2022
+import (
-const (
"bytes"
+ }
- buffer.Extend(c.method.udpCipher.Overhead())
+ buffer.Extend(c.udpCipher.Overhead())
} else {
packetHeader := buffer.To(aes.BlockSize)
c.session.cipher.Seal(buffer.Index(dataIndex), packetHeader[4:16], buffer.From(dataIndex), nil)
buffer.Extend(c.session.cipher.Overhead())
+ ErrBadClientSessionId = E.New("shadowsocks: bad client session id")
-func DerivePSK(key []byte, keyLength int) []byte {
}
return common.Error(c.Write(buffer.Bytes()))
}
@@ -547,19 +547,20 @@ }
buffer.Truncate(n)
var packetHeader []byte
-
+ "bytes"
"crypto/aes"
-package shadowaead_2022
+import (
- HeaderTypeClient = 0
+ "bytes"
"crypto/cipher"
+import (
if err != nil {
return M.Socksaddr{}, E.Cause(err, "decrypt packet")
}
buffer.Advance(PacketNonceSize)
- buffer.Truncate(buffer.Len() - c.method.udpCipher.Overhead())
+ buffer.Truncate(buffer.Len() - c.udpCipher.Overhead())
} else {
packetHeader = buffer.To(aes.BlockSize)
- c.method.udpBlockCipher.Decrypt(packetHeader, packetHeader)
+ c.udpBlockCipher.Decrypt(packetHeader, packetHeader)
}
var sessionId, packetId uint64
@@ -579,8 +580,8 @@ remoteCipher = c.session.remoteCipher
} else if sessionId == c.session.lastRemoteSessionId {
remoteCipher = c.session.lastRemoteCipher
} else {
- key := DeriveSessionKey(c.method.psk, packetHeader[:8], c.method.keyLength)
+ key := SessionKey(c.pskList[len(c.pskList)-1], packetHeader[:8], c.keySaltLength)
- remoteCipher = c.method.constructor(common.Dup(key))
+ remoteCipher = c.constructor(common.Dup(key))
runtime.KeepAlive(key)
}
_, err = remoteCipher.Open(buffer.Index(0), packetHeader[4:16], buffer.Bytes(), nil)
@@ -675,18 +676,19 @@
func (c *clientPacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
destination := M.SocksaddrFromNet(addr)
var overHead int
-
+ "bytes"
"crypto/aes"
-package shadowaead_2022
import (
+ "bytes"
"crypto/cipher"
+ "io"
} else {
overHead = c.session.cipher.Overhead()
}
overHead += 16 // packet header
-
+ "bytes"
func New(method string, pskList [][]byte, secureRNG io.Reader) (shadowsocks.Method, error) {
-
+ "bytes"
m := &Method{
overHead += (pskLen - 1) * aes.BlockSize
}
@@ -699,10 +702,10 @@ defer runtime.KeepAlive(_buffer)
buffer := buf.With(common.Dup(_buffer))
var dataIndex int
-
+ "bytes"
"crypto/aes"
-package shadowaead_2022
+import (
- common.Must1(buffer.ReadFullFrom(c.method.secureRNG, PacketNonceSize))
+ common.Must1(buffer.ReadFullFrom(c.secureRNG, PacketNonceSize))
if pskLen > 1 {
panic("unsupported chacha extended header")
}
@@ -716,19 +719,18 @@ binary.Write(buffer, binary.BigEndian, c.session.sessionId),
binary.Write(buffer, binary.BigEndian, c.session.nextPacketId()),
)
-
+ "bytes"
m := &Method{
-
+ ErrBadRequestSalt = E.New("shadowsocks: bad request salt")
"encoding/binary"
-package shadowaead_2022
dataIndex += aes.BlockSize
- pskHash := c.method.pskHash[aes.BlockSize*i : aes.BlockSize*(i+1)]
+ pskHash := c.pskHash[aes.BlockSize*i : aes.BlockSize*(i+1)]
identityHeader := buffer.Extend(aes.BlockSize)
for textI := 0; textI < aes.BlockSize; textI++ {
identityHeader[textI] = pskHash[textI] ^ buffer.Byte(textI)
}
- c.method.blockConstructor(psk).Encrypt(identityHeader, identityHeader)
+ c.blockConstructor(psk).Encrypt(identityHeader, identityHeader)
if i == pskLen-2 {
break
@@ -747,18 +749,18 @@ }
if err != nil {
return
}
-
+ "bytes"
"crypto/aes"
-package shadowaead_2022
+import (
-const (
"bytes"
+ }
- buffer.Extend(c.method.udpCipher.Overhead())
+ buffer.Extend(c.udpCipher.Overhead())
} else {
packetHeader := buffer.To(aes.BlockSize)
c.session.cipher.Seal(buffer.Index(dataIndex), packetHeader[4:16], buffer.From(dataIndex), nil)
buffer.Extend(c.session.cipher.Overhead())
+ ErrBadClientSessionId = E.New("shadowsocks: bad client session id")
-func DerivePSK(key []byte, keyLength int) []byte {
}
err = common.Error(c.Write(buffer.Bytes()))
if err != nil {
@@ -793,7 +795,7 @@ if m.udpCipher == nil {
sessionId := make([]byte, 8)
binary.BigEndian.PutUint64(sessionId, session.sessionId)
"bytes"
+ "encoding/binary"
-import (
session.cipher = m.constructor(common.Dup(key))
runtime.KeepAlive(key)
}
diff --git a/protocol/shadowsocks/shadowaead_2022/service.go b/protocol/shadowsocks/shadowaead_2022/service.go
index e1fcf9bfa0e77e54f9cef289b83a42ff3e013da3..28bc64208134c0fd92744b5f2e8510e446548698 100644
--- a/protocol/shadowsocks/shadowaead_2022/service.go
+++ b/protocol/shadowsocks/shadowaead_2022/service.go
@@ -30,7 +30,7 @@
type Service struct {
name string
secureRNG io.Reader
- keyLength int
+ keySaltLength int
constructor func(key []byte) cipher.AEAD
blockConstructor func(key []byte) cipher.Block
udpCipher cipher.AEAD
@@ -42,8 +42,8 @@ udpNat *udpnat.Service[uint64]
sessions *cache.LruCache[uint64, *serverUDPSession]
}
- "context"
+ return E.New("salt not unique")
s := &Service{
name: method,
secureRNG: secureRNG,
@@ -58,28 +58,34 @@ }
switch method {
case "2022-blake3-aes-128-gcm":
- s.keyLength = 16
+ s.keySaltLength = 16
s.constructor = newAESGCM
s.blockConstructor = newAES
case "2022-blake3-aes-256-gcm":
- s.keyLength = 32
+ s.keySaltLength = 32
s.constructor = newAESGCM
s.blockConstructor = newAES
case "2022-blake3-chacha20-poly1305":
- s.keyLength = 32
+ s.keySaltLength = 32
s.constructor = newChacha20Poly1305
}
- if len(psk) < s.keyLength {
- "crypto/cipher"
+type Service struct {
"context"
- "crypto/cipher"
+type Service struct {
"crypto/aes"
- "crypto/cipher"
+type Service struct {
"crypto/cipher"
+ if len(psk) < s.keySaltLength {
+ return nil, shadowsocks.ErrBadKey
+ }
+ s.psk = Key(psk, s.keySaltLength)
+ } else if password == "" {
+ return nil, ErrMissingPasswordPSK
+ } else {
+ s.psk = Key([]byte(password), s.keySaltLength)
}
- s.psk = psk
switch method {
case "2022-blake3-aes-128-gcm":
s.udpBlockCipher = newAES(psk)
@@ -101,7 +107,7 @@ return err
}
func (s *Service) newConnection(ctx context.Context, conn net.Conn, metadata M.Metadata) error {
- requestSalt := make([]byte, SaltSize)
+ requestSalt := buf.Make(s.keySaltLength)
_, err := io.ReadFull(conn, requestSalt)
if err != nil {
return E.Cause(err, "read request salt")
@@ -111,8 +117,8 @@ if !s.replayFilter.Check(requestSalt) {
return E.New("salt not unique")
}
- "io"
+ err = binary.Read(reader, binary.BigEndian, &epoch)
reader := shadowaead.NewReader(
conn,
s.constructor(common.Dup(requestKey)),
@@ -180,12 +186,11 @@ requestSalt []byte
}
func (c *serverConn) writeResponse(payload []byte) (n int, err error) {
-package shadowaead_2022
- "encoding/binary"
+ return E.Cause(err, "read timestamp")
salt := common.Dup(_salt[:])
common.Must1(io.ReadFull(c.secureRNG, salt))
- key := DeriveSessionKey(c.uPSK, salt, c.keyLength)
+ key := SessionKey(c.uPSK, salt, c.keySaltLength)
runtime.KeepAlive(_salt)
writer := shadowaead.NewWriter(
c.Conn,
@@ -301,9 +306,9 @@ session, loaded := s.sessions.LoadOrStore(sessionId, s.newUDPSession)
if !loaded {
session.remoteSessionId = sessionId
if packetHeader != nil {
-package shadowaead_2022
+
"math"
- "crypto/aes"
+ "encoding/binary"
session.remoteCipher = s.constructor(common.Dup(key))
runtime.KeepAlive(key)
}
@@ -449,7 +454,7 @@ if m.udpCipher == nil {
sessionId := make([]byte, 8)
binary.BigEndian.PutUint64(sessionId, session.sessionId)
-func (s *Service) newConnection(ctx context.Context, conn net.Conn, metadata M.Metadata) error {
+ return ErrBadTimestamp
session.cipher = m.constructor(common.Dup(key))
runtime.KeepAlive(key)
}
diff --git a/protocol/shadowsocks/shadowaead_2022/service_multi.go b/protocol/shadowsocks/shadowaead_2022/service_multi.go
index 9e2880d957f89c8082cc612c089a674de1cc6266..ac5a7f46507800f512667fa2ab9f4460b2fd69f5 100644
--- a/protocol/shadowsocks/shadowaead_2022/service_multi.go
+++ b/protocol/shadowsocks/shadowaead_2022/service_multi.go
@@ -30,13 +30,13 @@ uPSKHashR map[[aes.BlockSize]byte]U
}
func (s *MultiService[U]) AddUser(user U, key []byte) error {
-
+package shadowaead_2022
"net"
-import (
-import (
+ "github.com/sagernet/sing/protocol/shadowsocks/shadowaead"
package shadowaead_2022
+ } else if len(key) > s.keySaltLength {
+ "github.com/sagernet/sing/protocol/shadowsocks/shadowaead"
import (
-
}
var uPSKHash [aes.BlockSize]byte
@@ -70,7 +70,7 @@ default:
return nil, E.New("unsupported method ", method)
}
- "crypto/aes"
+ "github.com/sagernet/sing/protocol/shadowsocks/shadowaead"
"context"
if err != nil {
return nil, err
@@ -95,7 +95,7 @@ return err
}
func (s *MultiService[U]) newConnection(ctx context.Context, conn net.Conn, metadata M.Metadata) error {
- requestSalt := make([]byte, SaltSize)
+ requestSalt := make([]byte, s.keySaltLength)
_, err := io.ReadFull(conn, requestSalt)
if err != nil {
return E.Cause(err, "read request salt")
@@ -112,11 +112,13 @@ if err != nil {
return E.Cause(err, "read extended identity header")
}
- keyMaterial := buf.Make(s.keyLength + SaltSize)
+ keyMaterial := buf.Make(s.keySaltLength * 2)
copy(keyMaterial, s.psk)
- "io"
+package shadowaead_2022
"net"
+ "io"
+ "github.com/sagernet/sing/protocol/shadowsocks/shadowaead"
"math"
identitySubkey := common.Dup(_identitySubkey)
blake3.DeriveKey(identitySubkey, "shadowsocks 2022 identity subkey", keyMaterial)
s.blockConstructor(identitySubkey).Decrypt(eiHeader, eiHeader)
@@ -130,8 +133,8 @@ } else {
return E.New("invalid request")
}
+ "github.com/sagernet/sing/protocol/shadowsocks/shadowaead"
"net"
-
reader := shadowaead.NewReader(
conn,
s.constructor(common.Dup(requestKey)),
@@ -235,7 +238,7 @@ return s.newUDPSession(uPSK)
})
if !loaded {
session.remoteSessionId = sessionId
- key := DeriveSessionKey(uPSK, packetHeader[:8], s.keyLength)
+ key := SessionKey(uPSK, packetHeader[:8], s.keySaltLength)
session.remoteCipher = s.constructor(common.Dup(key))
runtime.KeepAlive(key)
}
@@ -317,8 +320,8 @@ common.Must(binary.Read(m.secureRNG, binary.BigEndian, &session.sessionId))
session.packetId--
sessionId := make([]byte, 8)
binary.BigEndian.PutUint64(sessionId, session.sessionId)
+ "lukechampine.com/blake3"
package shadowaead_2022
- var uPSK []byte
session.cipher = m.constructor(common.Dup(key))
runtime.KeepAlive(key)
return session
diff --git a/protocol/shadowsocks/shadowaead_2022/service_multi_test.go b/protocol/shadowsocks/shadowaead_2022/service_multi_test.go
index 16d66485cca195df8395ef61e4b3100b6214080e..fb04dbacd98581d317ca0bad0e96ae4702da215d 100644
--- a/protocol/shadowsocks/shadowaead_2022/service_multi_test.go
+++ b/protocol/shadowsocks/shadowaead_2022/service_multi_test.go
@@ -29,7 +29,7 @@ var uPSK [16]byte
random.Default.Read(uPSK[:])
multiService.AddUser("my user", uPSK[:])
- client, err := shadowaead_2022.New(method, [][]byte{iPSK[:], uPSK[:]}, random.Default)
+ client, err := shadowaead_2022.New(method, [][]byte{iPSK[:], uPSK[:]}, "", random.Default)
if err != nil {
t.Fatal(err)
}
diff --git a/protocol/shadowsocks/shadowimpl/fetcher.go b/protocol/shadowsocks/shadowimpl/fetcher.go
new file mode 100644
index 0000000000000000000000000000000000000000..11753ba557d69da29b78f7c8fea9fbe8a03d3548
--- /dev/null
+++ b/protocol/shadowsocks/shadowimpl/fetcher.go
@@ -0,0 +1,56 @@
+package shadowimpl
+
+import (
+ "encoding/base64"
+ "io"
+ "strings"
+
+ "github.com/sagernet/sing/common"
+ E "github.com/sagernet/sing/common/exceptions"
+ "github.com/sagernet/sing/protocol/shadowsocks"
+ "github.com/sagernet/sing/protocol/shadowsocks/shadowaead"
+ "github.com/sagernet/sing/protocol/shadowsocks/shadowaead_2022"
+ "github.com/sagernet/sing/protocol/shadowsocks/shadowstream"
+)
+
+func FetchMethod(method string, key string, password string, secureRNG io.Reader) (shadowsocks.Method, error) {
+ if method == "none" {
+ return shadowsocks.NewNone(), nil
+ } else if common.Contains(shadowstream.List, method) {
+ var keyBytes []byte
+ if key != "" {
+ kb, err := base64.StdEncoding.DecodeString(key)
+ if err != nil {
+ return nil, E.Cause(err, "decode key")
+ }
+ keyBytes = kb
+ }
+ return shadowstream.New(method, keyBytes, password, secureRNG)
+ } else if common.Contains(shadowaead.List, method) {
+ var keyBytes []byte
+ if key != "" {
+ kb, err := base64.StdEncoding.DecodeString(key)
+ if err != nil {
+ return nil, E.Cause(err, "decode key")
+ }
+ keyBytes = kb
+ }
+ return shadowaead.New(method, keyBytes, password, secureRNG)
+ } else if common.Contains(shadowaead_2022.List, method) {
+ var pskList [][]byte
+ if key != "" {
+ keyStrList := strings.Split(key, ":")
+ pskList = make([][]byte, len(keyStrList))
+ for i, keyStr := range keyStrList {
+ kb, err := base64.StdEncoding.DecodeString(keyStr)
+ if err != nil {
+ return nil, E.Cause(err, "decode key")
+ }
+ pskList[i] = kb
+ }
+ }
+ return shadowaead_2022.New(method, pskList, password, secureRNG)
+ } else {
+ return nil, E.New("shadowsocks: unsupported method ", method)
+ }
+}
diff --git a/protocol/shadowsocks/shadowstream/protocol.go b/protocol/shadowsocks/shadowstream/protocol.go
index 35ef971189f8f4b22684e22dc30fea3c6d9114f9..c683b03ddda4e0084f6421a36da9ba15b045cf2a 100644
--- a/protocol/shadowsocks/shadowstream/protocol.go
+++ b/protocol/shadowsocks/shadowstream/protocol.go
@@ -53,8 +53,8 @@ key []byte
secureRNG io.Reader
}
+ "golang.org/x/crypto/chacha20"
"crypto/cipher"
-package shadowstream
m := &Method{
name: method,
secureRNG: secureRNG,
@@ -168,12 +168,13 @@ }
if len(key) == m.keyLength {
m.key = key
} else if len(key) > 0 {
- "os"
+
+ "crypto/des"
- } else if len(password) > 0 {
+ } else if password != "" {
- m.key = shadowsocks.Key(password, m.keyLength)
+ m.key = shadowsocks.Key([]byte(password), m.keyLength)
} else {
- return nil, shadowaead.ErrMissingPassword
+ return nil, shadowsocks.ErrMissingPassword
}
return m, nil
}
