snell.go 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
  1. package snell
  2. import (
  3. "encoding/binary"
  4. "errors"
  5. "fmt"
  6. "io"
  7. "net"
  8. "sync"
  9. "github.com/metacubex/mihomo/common/pool"
  10. "github.com/metacubex/mihomo/transport/shadowsocks/shadowaead"
  11. "github.com/metacubex/mihomo/transport/socks5"
  12. )
  13. const (
  14. Version1 = 1
  15. Version2 = 2
  16. Version3 = 3
  17. DefaultSnellVersion = Version1
  18. // max packet length
  19. maxLength = 0x3FFF
  20. )
  21. const (
  22. CommandPing byte = 0
  23. CommandConnect byte = 1
  24. CommandConnectV2 byte = 5
  25. CommandUDP byte = 6
  26. CommondUDPForward byte = 1
  27. CommandTunnel byte = 0
  28. CommandPong byte = 1
  29. CommandError byte = 2
  30. Version byte = 1
  31. )
  32. var endSignal = []byte{}
  33. type Snell struct {
  34. net.Conn
  35. buffer [1]byte
  36. reply bool
  37. }
  38. func (s *Snell) Read(b []byte) (int, error) {
  39. if s.reply {
  40. return s.Conn.Read(b)
  41. }
  42. s.reply = true
  43. if _, err := io.ReadFull(s.Conn, s.buffer[:]); err != nil {
  44. return 0, err
  45. }
  46. if s.buffer[0] == CommandTunnel {
  47. return s.Conn.Read(b)
  48. } else if s.buffer[0] != CommandError {
  49. return 0, errors.New("command not support")
  50. }
  51. // CommandError
  52. // 1 byte error code
  53. if _, err := io.ReadFull(s.Conn, s.buffer[:]); err != nil {
  54. return 0, err
  55. }
  56. errcode := int(s.buffer[0])
  57. // 1 byte error message length
  58. if _, err := io.ReadFull(s.Conn, s.buffer[:]); err != nil {
  59. return 0, err
  60. }
  61. length := int(s.buffer[0])
  62. msg := make([]byte, length)
  63. if _, err := io.ReadFull(s.Conn, msg); err != nil {
  64. return 0, err
  65. }
  66. return 0, fmt.Errorf("server reported code: %d, message: %s", errcode, string(msg))
  67. }
  68. func WriteHeader(conn net.Conn, host string, port uint, version int) error {
  69. buf := pool.GetBuffer()
  70. defer pool.PutBuffer(buf)
  71. buf.WriteByte(Version)
  72. if version == Version2 {
  73. buf.WriteByte(CommandConnectV2)
  74. } else {
  75. buf.WriteByte(CommandConnect)
  76. }
  77. // clientID length & id
  78. buf.WriteByte(0)
  79. // host & port
  80. buf.WriteByte(uint8(len(host)))
  81. buf.WriteString(host)
  82. binary.Write(buf, binary.BigEndian, uint16(port))
  83. if _, err := conn.Write(buf.Bytes()); err != nil {
  84. return err
  85. }
  86. return nil
  87. }
  88. func WriteUDPHeader(conn net.Conn, version int) error {
  89. if version < Version3 {
  90. return errors.New("unsupport UDP version")
  91. }
  92. // version, command, clientID length
  93. _, err := conn.Write([]byte{Version, CommandUDP, 0x00})
  94. return err
  95. }
  96. // HalfClose works only on version2
  97. func HalfClose(conn net.Conn) error {
  98. if _, err := conn.Write(endSignal); err != nil {
  99. return err
  100. }
  101. if s, ok := conn.(*Snell); ok {
  102. s.reply = false
  103. }
  104. return nil
  105. }
  106. func StreamConn(conn net.Conn, psk []byte, version int) *Snell {
  107. var cipher shadowaead.Cipher
  108. if version != Version1 {
  109. cipher = NewAES128GCM(psk)
  110. } else {
  111. cipher = NewChacha20Poly1305(psk)
  112. }
  113. return &Snell{Conn: shadowaead.NewConn(conn, cipher)}
  114. }
  115. func PacketConn(conn net.Conn) net.PacketConn {
  116. return &packetConn{
  117. Conn: conn,
  118. }
  119. }
  120. func writePacket(w io.Writer, socks5Addr, payload []byte) (int, error) {
  121. buf := pool.GetBuffer()
  122. defer pool.PutBuffer(buf)
  123. // compose snell UDP address format (refer: icpz/snell-server-reversed)
  124. // a brand new wheel to replace socks5 address format, well done Yachen
  125. buf.WriteByte(CommondUDPForward)
  126. switch socks5Addr[0] {
  127. case socks5.AtypDomainName:
  128. hostLen := socks5Addr[1]
  129. buf.Write(socks5Addr[1 : 1+1+hostLen+2])
  130. case socks5.AtypIPv4:
  131. buf.Write([]byte{0x00, 0x04})
  132. buf.Write(socks5Addr[1 : 1+net.IPv4len+2])
  133. case socks5.AtypIPv6:
  134. buf.Write([]byte{0x00, 0x06})
  135. buf.Write(socks5Addr[1 : 1+net.IPv6len+2])
  136. }
  137. buf.Write(payload)
  138. _, err := w.Write(buf.Bytes())
  139. if err != nil {
  140. return 0, err
  141. }
  142. return len(payload), nil
  143. }
  144. func WritePacket(w io.Writer, socks5Addr, payload []byte) (int, error) {
  145. if len(payload) <= maxLength {
  146. return writePacket(w, socks5Addr, payload)
  147. }
  148. offset := 0
  149. total := len(payload)
  150. for {
  151. cursor := offset + maxLength
  152. if cursor > total {
  153. cursor = total
  154. }
  155. n, err := writePacket(w, socks5Addr, payload[offset:cursor])
  156. if err != nil {
  157. return offset + n, err
  158. }
  159. offset = cursor
  160. if offset == total {
  161. break
  162. }
  163. }
  164. return total, nil
  165. }
  166. func ReadPacket(r io.Reader, payload []byte) (net.Addr, int, error) {
  167. buf := pool.Get(pool.UDPBufferSize)
  168. defer pool.Put(buf)
  169. n, err := r.Read(buf)
  170. headLen := 1
  171. if err != nil {
  172. return nil, 0, err
  173. }
  174. if n < headLen {
  175. return nil, 0, errors.New("insufficient UDP length")
  176. }
  177. // parse snell UDP response address format
  178. switch buf[0] {
  179. case 0x04:
  180. headLen += net.IPv4len + 2
  181. if n < headLen {
  182. err = errors.New("insufficient UDP length")
  183. break
  184. }
  185. buf[0] = socks5.AtypIPv4
  186. case 0x06:
  187. headLen += net.IPv6len + 2
  188. if n < headLen {
  189. err = errors.New("insufficient UDP length")
  190. break
  191. }
  192. buf[0] = socks5.AtypIPv6
  193. default:
  194. err = errors.New("ip version invalid")
  195. }
  196. if err != nil {
  197. return nil, 0, err
  198. }
  199. addr := socks5.SplitAddr(buf[0:])
  200. if addr == nil {
  201. return nil, 0, errors.New("remote address invalid")
  202. }
  203. uAddr := addr.UDPAddr()
  204. if uAddr == nil {
  205. return nil, 0, errors.New("parse addr error")
  206. }
  207. length := len(payload)
  208. if n-headLen < length {
  209. length = n - headLen
  210. }
  211. copy(payload[:], buf[headLen:headLen+length])
  212. return uAddr, length, nil
  213. }
  214. type packetConn struct {
  215. net.Conn
  216. rMux sync.Mutex
  217. wMux sync.Mutex
  218. }
  219. func (pc *packetConn) WriteTo(b []byte, addr net.Addr) (int, error) {
  220. pc.wMux.Lock()
  221. defer pc.wMux.Unlock()
  222. return WritePacket(pc, socks5.ParseAddr(addr.String()), b)
  223. }
  224. func (pc *packetConn) ReadFrom(b []byte) (int, net.Addr, error) {
  225. pc.rMux.Lock()
  226. defer pc.rMux.Unlock()
  227. addr, n, err := ReadPacket(pc.Conn, b)
  228. if err != nil {
  229. return 0, nil, err
  230. }
  231. return n, addr, nil
  232. }