mihomo/adapter/outbound/shadowsocks.go

203 lines
5.4 KiB
Go
Raw Normal View History

2019-12-08 12:17:24 +08:00
package outbound
2018-06-10 22:50:03 +08:00
import (
"context"
"errors"
2018-06-10 22:50:03 +08:00
"fmt"
"net"
"strconv"
2019-02-11 15:25:10 +08:00
"github.com/Dreamacro/clash/common/structure"
2020-02-09 17:02:48 +08:00
"github.com/Dreamacro/clash/component/dialer"
2018-06-10 22:50:03 +08:00
C "github.com/Dreamacro/clash/constant"
2021-05-13 22:18:49 +08:00
obfs "github.com/Dreamacro/clash/transport/simple-obfs"
"github.com/Dreamacro/clash/transport/socks5"
v2rayObfs "github.com/Dreamacro/clash/transport/v2ray-plugin"
2018-06-10 22:50:03 +08:00
"github.com/Dreamacro/go-shadowsocks2/core"
2018-06-10 22:50:03 +08:00
)
type ShadowSocks struct {
2018-12-22 23:56:42 +08:00
*Base
2019-02-11 15:25:10 +08:00
cipher core.Cipher
// obfs
obfsMode string
obfsOption *simpleObfsOption
v2rayOption *v2rayObfs.Option
2018-06-10 22:50:03 +08:00
}
type ShadowSocksOption struct {
2019-02-11 15:25:10 +08:00
Name string `proxy:"name"`
Server string `proxy:"server"`
Port int `proxy:"port"`
Password string `proxy:"password"`
Cipher string `proxy:"cipher"`
2019-04-23 23:29:36 +08:00
UDP bool `proxy:"udp,omitempty"`
2019-02-11 15:25:10 +08:00
Plugin string `proxy:"plugin,omitempty"`
PluginOpts map[string]interface{} `proxy:"plugin-opts,omitempty"`
}
2019-02-11 15:25:10 +08:00
type simpleObfsOption struct {
Mode string `obfs:"mode,omitempty"`
2019-02-11 15:25:10 +08:00
Host string `obfs:"host,omitempty"`
}
type v2rayObfsOption struct {
Mode string `obfs:"mode"`
Host string `obfs:"host,omitempty"`
Path string `obfs:"path,omitempty"`
TLS bool `obfs:"tls,omitempty"`
Headers map[string]string `obfs:"headers,omitempty"`
SkipCertVerify bool `obfs:"skip-cert-verify,omitempty"`
Mux bool `obfs:"mux,omitempty"`
2019-02-11 15:25:10 +08:00
}
2021-04-29 11:23:14 +08:00
// StreamConn implements C.ProxyAdapter
func (ss *ShadowSocks) StreamConn(c net.Conn, metadata *C.Metadata) (net.Conn, error) {
2019-02-11 15:25:10 +08:00
switch ss.obfsMode {
case "tls":
2019-02-11 15:25:10 +08:00
c = obfs.NewTLSObfs(c, ss.obfsOption.Host)
case "http":
_, port, _ := net.SplitHostPort(ss.addr)
2019-02-11 15:25:10 +08:00
c = obfs.NewHTTPObfs(c, ss.obfsOption.Host, port)
case "websocket":
var err error
c, err = v2rayObfs.NewV2rayObfs(c, ss.v2rayOption)
2019-02-11 15:25:10 +08:00
if err != nil {
return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
2019-02-11 15:25:10 +08:00
}
}
c = ss.cipher.StreamConn(c)
_, err := c.Write(serializesSocksAddr(metadata))
return c, err
}
2021-04-29 11:23:14 +08:00
// DialContext implements C.ProxyAdapter
func (ss *ShadowSocks) DialContext(ctx context.Context, metadata *C.Metadata) (_ C.Conn, err error) {
c, err := dialer.DialContext(ctx, "tcp", ss.addr)
if err != nil {
return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
}
tcpKeepAlive(c)
defer safeConnClose(c, err)
c, err = ss.StreamConn(c, metadata)
return NewConn(c, ss), err
2018-06-10 22:50:03 +08:00
}
2021-04-29 11:23:14 +08:00
// DialUDP implements C.ProxyAdapter
2020-01-31 14:43:54 +08:00
func (ss *ShadowSocks) DialUDP(metadata *C.Metadata) (C.PacketConn, error) {
2020-02-09 17:02:48 +08:00
pc, err := dialer.ListenPacket("udp", "")
2019-04-23 23:29:36 +08:00
if err != nil {
2020-01-31 14:43:54 +08:00
return nil, err
2019-04-23 23:29:36 +08:00
}
addr, err := resolveUDPAddr("udp", ss.addr)
2019-04-24 10:29:29 +08:00
if err != nil {
pc.Close()
2020-01-31 14:43:54 +08:00
return nil, err
2019-04-24 10:29:29 +08:00
}
2019-04-23 23:29:36 +08:00
pc = ss.cipher.PacketConn(pc)
2020-02-17 17:34:19 +08:00
return newPacketConn(&ssPacketConn{PacketConn: pc, rAddr: addr}, ss), nil
2019-04-23 23:29:36 +08:00
}
func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
addr := net.JoinHostPort(option.Server, strconv.Itoa(option.Port))
cipher := option.Cipher
password := option.Password
2018-09-21 11:33:29 +08:00
ciph, err := core.PickCipher(cipher, nil, password)
if err != nil {
return nil, fmt.Errorf("ss %s initialize error: %w", addr, err)
2018-06-10 22:50:03 +08:00
}
var v2rayOption *v2rayObfs.Option
2019-02-11 15:25:10 +08:00
var obfsOption *simpleObfsOption
obfsMode := ""
decoder := structure.NewDecoder(structure.Option{TagName: "obfs", WeaklyTypedInput: true})
if option.Plugin == "obfs" {
opts := simpleObfsOption{Host: "bing.com"}
if err := decoder.Decode(option.PluginOpts, &opts); err != nil {
return nil, fmt.Errorf("ss %s initialize obfs error: %w", addr, err)
2019-02-11 15:25:10 +08:00
}
2019-06-18 20:37:53 +08:00
if opts.Mode != "tls" && opts.Mode != "http" {
return nil, fmt.Errorf("ss %s obfs mode error: %s", addr, opts.Mode)
2019-06-18 20:37:53 +08:00
}
2019-02-11 15:25:10 +08:00
obfsMode = opts.Mode
obfsOption = &opts
} else if option.Plugin == "v2ray-plugin" {
opts := v2rayObfsOption{Host: "bing.com", Mux: true}
2019-02-11 15:25:10 +08:00
if err := decoder.Decode(option.PluginOpts, &opts); err != nil {
return nil, fmt.Errorf("ss %s initialize v2ray-plugin error: %w", addr, err)
2019-02-11 15:25:10 +08:00
}
2019-06-18 20:37:53 +08:00
if opts.Mode != "websocket" {
return nil, fmt.Errorf("ss %s obfs mode error: %s", addr, opts.Mode)
2019-06-18 20:37:53 +08:00
}
2019-02-11 15:25:10 +08:00
obfsMode = opts.Mode
v2rayOption = &v2rayObfs.Option{
Host: opts.Host,
Path: opts.Path,
Headers: opts.Headers,
Mux: opts.Mux,
}
2019-06-18 20:37:53 +08:00
2019-02-11 15:25:10 +08:00
if opts.TLS {
v2rayOption.TLS = true
v2rayOption.SkipCertVerify = opts.SkipCertVerify
v2rayOption.SessionCache = getClientSessionCache()
2019-02-11 15:25:10 +08:00
}
}
return &ShadowSocks{
2018-12-22 23:56:42 +08:00
Base: &Base{
name: option.Name,
addr: addr,
2018-12-22 23:56:42 +08:00
tp: C.Shadowsocks,
2019-04-23 23:29:36 +08:00
udp: option.UDP,
2018-12-22 23:56:42 +08:00
},
2019-02-11 15:25:10 +08:00
cipher: ciph,
obfsMode: obfsMode,
v2rayOption: v2rayOption,
obfsOption: obfsOption,
}, nil
2018-06-10 22:50:03 +08:00
}
2020-02-17 17:34:19 +08:00
type ssPacketConn struct {
2019-04-23 23:29:36 +08:00
net.PacketConn
2020-01-31 14:43:54 +08:00
rAddr net.Addr
2019-04-23 23:29:36 +08:00
}
2020-02-17 17:34:19 +08:00
func (spc *ssPacketConn) WriteTo(b []byte, addr net.Addr) (n int, err error) {
2020-01-31 14:43:54 +08:00
packet, err := socks5.EncodeUDPPacket(socks5.ParseAddrToSocksAddr(addr), b)
2019-10-11 20:11:18 +08:00
if err != nil {
return
}
2020-02-17 17:34:19 +08:00
return spc.PacketConn.WriteTo(packet[3:], spc.rAddr)
2019-04-23 23:29:36 +08:00
}
2020-02-17 17:34:19 +08:00
func (spc *ssPacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, _, e := spc.PacketConn.ReadFrom(b)
2020-02-18 16:05:12 +08:00
if e != nil {
return 0, nil, e
}
2020-02-18 16:05:12 +08:00
addr := socks5.SplitAddr(b[:n])
if addr == nil {
return 0, nil, errors.New("parse addr error")
}
2020-03-02 23:47:23 +08:00
udpAddr := addr.UDPAddr()
if udpAddr == nil {
return 0, nil, errors.New("parse addr error")
}
2019-04-23 23:29:36 +08:00
copy(b, b[len(addr):])
2020-03-02 23:47:23 +08:00
return n - len(addr), udpAddr, e
2019-04-23 23:29:36 +08:00
}