1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-11-05 01:38:24 -05:00
v2fly/proxy/socks/protocol.go

424 lines
11 KiB
Go
Raw Normal View History

2017-01-03 18:43:13 -05:00
package socks
import (
"io"
"v2ray.com/core/common"
2017-01-03 18:43:13 -05:00
"v2ray.com/core/common/buf"
"v2ray.com/core/common/net"
2017-01-03 18:43:13 -05:00
"v2ray.com/core/common/protocol"
"v2ray.com/core/common/serial"
)
const (
socks5Version = 0x05
socks4Version = 0x04
cmdTCPConnect = 0x01
cmdTCPBind = 0x02
cmdUDPPort = 0x03
socks4RequestGranted = 90
socks4RequestRejected = 91
2017-01-08 17:31:45 -05:00
authNotRequired = 0x00
//authGssAPI = 0x01
2017-01-03 18:43:13 -05:00
authPassword = 0x02
authNoMatchingMethod = 0xFF
addrTypeIPv4 = 0x01
addrTypeIPv6 = 0x04
addrTypeDomain = 0x03
statusSuccess = 0x00
statusCmdNotSupport = 0x07
)
2018-02-23 17:42:01 -05:00
var addrParser = protocol.NewAddressParser(
protocol.AddressFamilyByte(0x01, net.AddressFamilyIPv4),
protocol.AddressFamilyByte(0x04, net.AddressFamilyIPv6),
protocol.AddressFamilyByte(0x03, net.AddressFamilyDomain),
)
2017-01-03 18:43:13 -05:00
type ServerSession struct {
config *ServerConfig
port net.Port
2017-01-03 18:43:13 -05:00
}
func (s *ServerSession) Handshake(reader io.Reader, writer io.Writer) (*protocol.RequestHeader, error) {
buffer := buf.NewLocal(512)
request := new(protocol.RequestHeader)
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 2)); err != nil {
2017-04-08 19:43:25 -04:00
return nil, newError("insufficient header").Base(err)
2017-01-03 18:43:13 -05:00
}
version := buffer.Byte(0)
if version == socks4Version {
2018-02-23 07:55:56 -05:00
if s.config.AuthType == AuthType_PASSWORD {
writeSocks4Response(writer, socks4RequestRejected, net.AnyIP, net.Port(0))
return nil, newError("socks 4 is not allowed when auth is required.")
}
2017-01-03 18:43:13 -05:00
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, 6)); err != nil {
2017-04-08 19:43:25 -04:00
return nil, newError("insufficient header").Base(err)
2017-01-03 18:43:13 -05:00
}
port := net.PortFromBytes(buffer.BytesRange(2, 4))
address := net.IPAddress(buffer.BytesRange(4, 8))
2017-01-03 18:43:13 -05:00
_, err := readUntilNull(reader) // user id
if err != nil {
return nil, err
}
if address.IP()[0] == 0x00 {
domain, err := readUntilNull(reader)
if err != nil {
2017-04-08 19:43:25 -04:00
return nil, newError("failed to read domain for socks 4a").Base(err)
2017-01-03 18:43:13 -05:00
}
address = net.DomainAddress(domain)
2017-01-03 18:43:13 -05:00
}
switch buffer.Byte(1) {
case cmdTCPConnect:
request.Command = protocol.RequestCommandTCP
request.Address = address
request.Port = port
request.Version = socks4Version
if err := writeSocks4Response(writer, socks4RequestGranted, net.AnyIP, net.Port(0)); err != nil {
2017-01-03 18:43:13 -05:00
return nil, err
}
return request, nil
default:
writeSocks4Response(writer, socks4RequestRejected, net.AnyIP, net.Port(0))
2017-04-09 07:30:46 -04:00
return nil, newError("unsupported command: ", buffer.Byte(1))
2017-01-03 18:43:13 -05:00
}
}
if version == socks5Version {
nMethod := int(buffer.Byte(1))
if err := buffer.AppendSupplier(buf.ReadFullFrom(reader, nMethod)); err != nil {
2017-04-08 19:43:25 -04:00
return nil, newError("failed to read auth methods").Base(err)
2017-01-03 18:43:13 -05:00
}
var expectedAuth byte = authNotRequired
2017-01-07 19:06:35 -05:00
if s.config.AuthType == AuthType_PASSWORD {
2017-01-03 18:43:13 -05:00
expectedAuth = authPassword
}
if !hasAuthMethod(expectedAuth, buffer.BytesRange(2, 2+nMethod)) {
2017-01-29 02:25:01 -05:00
writeSocks5AuthenticationResponse(writer, socks5Version, authNoMatchingMethod)
2017-04-08 19:43:25 -04:00
return nil, newError("no matching auth method")
2017-01-03 18:43:13 -05:00
}
2017-01-29 02:25:01 -05:00
if err := writeSocks5AuthenticationResponse(writer, socks5Version, expectedAuth); err != nil {
2017-04-08 19:43:25 -04:00
return nil, newError("failed to write auth response").Base(err)
2017-01-07 19:06:35 -05:00
}
2017-01-03 18:43:13 -05:00
if expectedAuth == authPassword {
username, password, err := readUsernamePassword(reader)
2017-01-17 04:22:18 -05:00
if err != nil {
2017-04-08 19:43:25 -04:00
return nil, newError("failed to read username and password for authentication").Base(err)
2017-01-17 04:22:18 -05:00
}
if !s.config.HasAccount(username, password) {
2017-01-29 02:25:01 -05:00
writeSocks5AuthenticationResponse(writer, 0x01, 0xFF)
2017-04-08 19:43:25 -04:00
return nil, newError("invalid username or password")
2017-01-03 18:43:13 -05:00
}
2017-01-29 02:25:01 -05:00
if err := writeSocks5AuthenticationResponse(writer, 0x01, 0x00); err != nil {
2017-04-08 19:43:25 -04:00
return nil, newError("failed to write auth response").Base(err)
2017-01-07 19:06:35 -05:00
}
2017-01-03 18:43:13 -05:00
}
2018-02-23 17:42:01 -05:00
if err := buffer.Reset(buf.ReadFullFrom(reader, 3)); err != nil {
2017-04-08 19:43:25 -04:00
return nil, newError("failed to read request").Base(err)
2017-01-03 18:43:13 -05:00
}
cmd := buffer.Byte(1)
if cmd == cmdTCPBind || (cmd == cmdUDPPort && !s.config.UdpEnabled) {
writeSocks5Response(writer, statusCmdNotSupport, net.AnyIP, net.Port(0))
2017-04-08 19:43:25 -04:00
return nil, newError("unsupported command: ", cmd)
2017-01-03 18:43:13 -05:00
}
switch cmd {
case cmdTCPConnect:
request.Command = protocol.RequestCommandTCP
case cmdUDPPort:
request.Command = protocol.RequestCommandUDP
}
buffer.Clear()
request.Version = socks5Version
2018-02-23 17:42:01 -05:00
addr, port, err := addrParser.ReadAddressPort(buffer, reader)
2018-02-22 04:49:06 -05:00
if err != nil {
return nil, newError("failed to read address").Base(err)
2017-01-03 18:43:13 -05:00
}
2018-02-22 04:49:06 -05:00
request.Address = addr
request.Port = port
2017-01-03 18:43:13 -05:00
responseAddress := net.AnyIP
responsePort := net.Port(1717)
2017-01-03 18:43:13 -05:00
if request.Command == protocol.RequestCommandUDP {
addr := s.config.Address.AsAddress()
if addr == nil {
addr = net.LocalHostIP
2017-01-03 18:43:13 -05:00
}
responseAddress = addr
responsePort = s.port
2017-01-03 18:43:13 -05:00
}
if err := writeSocks5Response(writer, statusSuccess, responseAddress, responsePort); err != nil {
return nil, err
}
return request, nil
}
2017-04-08 19:43:25 -04:00
return nil, newError("unknown Socks version: ", version)
2017-01-03 18:43:13 -05:00
}
func readUsernamePassword(reader io.Reader) (string, string, error) {
buffer := buf.NewLocal(512)
defer buffer.Release()
2017-04-18 16:36:43 -04:00
if err := buffer.Reset(buf.ReadFullFrom(reader, 2)); err != nil {
2017-01-03 18:43:13 -05:00
return "", "", err
}
nUsername := int(buffer.Byte(1))
2017-04-18 16:36:43 -04:00
if err := buffer.Reset(buf.ReadFullFrom(reader, nUsername)); err != nil {
2017-01-03 18:43:13 -05:00
return "", "", err
}
username := buffer.String()
2017-04-18 16:36:43 -04:00
if err := buffer.Reset(buf.ReadFullFrom(reader, 1)); err != nil {
2017-01-03 18:43:13 -05:00
return "", "", err
}
nPassword := int(buffer.Byte(0))
2017-04-18 16:36:43 -04:00
if err := buffer.Reset(buf.ReadFullFrom(reader, nPassword)); err != nil {
2017-01-03 18:43:13 -05:00
return "", "", err
}
password := buffer.String()
return username, password, nil
}
func readUntilNull(reader io.Reader) (string, error) {
var b [256]byte
size := 0
for {
_, err := reader.Read(b[size : size+1])
if err != nil {
return "", err
}
if b[size] == 0x00 {
return string(b[:size]), nil
}
size++
if size == 256 {
2017-04-08 19:43:25 -04:00
return "", newError("buffer overrun")
2017-01-03 18:43:13 -05:00
}
}
}
func hasAuthMethod(expectedAuth byte, authCandidates []byte) bool {
for _, a := range authCandidates {
if a == expectedAuth {
return true
}
}
return false
}
2017-01-29 02:25:01 -05:00
func writeSocks5AuthenticationResponse(writer io.Writer, version byte, auth byte) error {
_, err := writer.Write([]byte{version, auth})
2017-01-03 18:43:13 -05:00
return err
}
func writeSocks5Response(writer io.Writer, errCode byte, address net.Address, port net.Port) error {
2017-01-07 19:06:35 -05:00
buffer := buf.NewLocal(64)
buffer.AppendBytes(socks5Version, errCode, 0x00 /* reserved */)
2018-02-23 17:42:01 -05:00
if err := addrParser.WriteAddressPort(buffer, address, port); err != nil {
2017-09-18 19:39:33 -04:00
return err
}
2017-01-03 18:43:13 -05:00
_, err := writer.Write(buffer.Bytes())
return err
}
func writeSocks4Response(writer io.Writer, errCode byte, address net.Address, port net.Port) error {
2017-01-03 18:43:13 -05:00
buffer := buf.NewLocal(32)
buffer.AppendBytes(0x00, errCode)
common.Must(buffer.AppendSupplier(serial.WriteUint16(port.Value())))
2017-01-03 18:43:13 -05:00
buffer.Append(address.IP())
_, err := writer.Write(buffer.Bytes())
return err
}
2017-01-07 15:57:24 -05:00
2018-02-23 17:42:01 -05:00
func DecodeUDPPacket(packet *buf.Buffer) (*protocol.RequestHeader, error) {
if packet.Len() < 5 {
return nil, newError("insufficient length of packet.")
2017-01-07 15:57:24 -05:00
}
request := &protocol.RequestHeader{
Version: socks5Version,
Command: protocol.RequestCommandUDP,
}
// packet[0] and packet[1] are reserved
2018-02-23 17:42:01 -05:00
if packet.Byte(2) != 0 /* fragments */ {
return nil, newError("discarding fragmented payload.")
2017-01-07 15:57:24 -05:00
}
2018-02-23 17:42:01 -05:00
packet.SliceFrom(3)
2017-01-07 15:57:24 -05:00
2018-02-23 17:42:01 -05:00
addr, port, err := addrParser.ReadAddressPort(nil, packet)
if err != nil {
return nil, newError("failed to read UDP header").Base(err)
2017-01-07 15:57:24 -05:00
}
2018-02-23 17:42:01 -05:00
request.Address = addr
request.Port = port
return request, nil
2017-01-07 15:57:24 -05:00
}
2017-09-18 19:39:33 -04:00
func EncodeUDPPacket(request *protocol.RequestHeader, data []byte) (*buf.Buffer, error) {
2017-04-15 15:19:21 -04:00
b := buf.New()
2017-01-07 15:57:24 -05:00
b.AppendBytes(0, 0, 0 /* Fragment */)
2018-02-23 17:42:01 -05:00
if err := addrParser.WriteAddressPort(b, request.Address, request.Port); err != nil {
2017-09-18 19:39:33 -04:00
return nil, err
}
2017-01-07 15:57:24 -05:00
b.Append(data)
2017-09-18 19:39:33 -04:00
return b, nil
2017-01-07 15:57:24 -05:00
}
2017-01-07 19:06:35 -05:00
type UDPReader struct {
reader io.Reader
}
2017-01-08 10:31:28 -05:00
func NewUDPReader(reader io.Reader) *UDPReader {
return &UDPReader{reader: reader}
}
2017-11-09 16:33:15 -05:00
func (r *UDPReader) ReadMultiBuffer() (buf.MultiBuffer, error) {
2017-04-15 15:19:21 -04:00
b := buf.New()
2017-01-07 19:06:35 -05:00
if err := b.AppendSupplier(buf.ReadFrom(r.reader)); err != nil {
return nil, err
}
2018-02-23 17:42:01 -05:00
if _, err := DecodeUDPPacket(b); err != nil {
2017-01-07 19:06:35 -05:00
return nil, err
}
2017-04-16 07:17:35 -04:00
return buf.NewMultiBufferValue(b), nil
2017-01-07 19:06:35 -05:00
}
type UDPWriter struct {
request *protocol.RequestHeader
writer io.Writer
}
2017-01-08 10:31:28 -05:00
func NewUDPWriter(request *protocol.RequestHeader, writer io.Writer) *UDPWriter {
return &UDPWriter{
request: request,
writer: writer,
}
}
2017-04-21 09:36:05 -04:00
// Write implements io.Writer.
2017-04-21 08:51:09 -04:00
func (w *UDPWriter) Write(b []byte) (int, error) {
2017-09-18 19:39:33 -04:00
eb, err := EncodeUDPPacket(w.request, b)
if err != nil {
return 0, err
}
2017-04-21 08:51:09 -04:00
defer eb.Release()
if _, err := w.writer.Write(eb.Bytes()); err != nil {
return 0, err
2017-01-07 19:06:35 -05:00
}
2017-04-21 08:51:09 -04:00
return len(b), nil
2017-01-07 19:06:35 -05:00
}
func ClientHandshake(request *protocol.RequestHeader, reader io.Reader, writer io.Writer) (*protocol.RequestHeader, error) {
authByte := byte(authNotRequired)
if request.User != nil {
authByte = byte(authPassword)
}
b := buf.NewLocal(512)
b.AppendBytes(socks5Version, 0x01, authByte)
if authByte == authPassword {
rawAccount, err := request.User.GetTypedAccount()
if err != nil {
return nil, err
}
account := rawAccount.(*Account)
b.AppendBytes(0x01, byte(len(account.Username)))
b.Append([]byte(account.Username))
b.AppendBytes(byte(len(account.Password)))
b.Append([]byte(account.Password))
}
if _, err := writer.Write(b.Bytes()); err != nil {
2017-01-07 19:06:35 -05:00
return nil, err
}
if err := b.Reset(buf.ReadFullFrom(reader, 2)); err != nil {
2017-01-07 19:06:35 -05:00
return nil, err
}
if b.Byte(0) != socks5Version {
2017-04-09 07:30:46 -04:00
return nil, newError("unexpected server version: ", b.Byte(0)).AtWarning()
2017-01-07 19:06:35 -05:00
}
if b.Byte(1) != authByte {
2017-04-09 07:30:46 -04:00
return nil, newError("auth method not supported.").AtWarning()
2017-01-07 19:06:35 -05:00
}
if authByte == authPassword {
if err := b.Reset(buf.ReadFullFrom(reader, 2)); err != nil {
2017-01-07 19:06:35 -05:00
return nil, err
}
if b.Byte(1) != 0x00 {
2017-04-09 07:30:46 -04:00
return nil, newError("server rejects account: ", b.Byte(1))
2017-01-07 19:06:35 -05:00
}
}
b.Clear()
command := byte(cmdTCPConnect)
if request.Command == protocol.RequestCommandUDP {
command = byte(cmdUDPPort)
}
b.AppendBytes(socks5Version, command, 0x00 /* reserved */)
2018-02-23 17:42:01 -05:00
if err := addrParser.WriteAddressPort(b, request.Address, request.Port); err != nil {
return nil, err
}
2017-01-07 19:06:35 -05:00
if _, err := writer.Write(b.Bytes()); err != nil {
return nil, err
}
b.Clear()
2018-02-23 17:42:01 -05:00
if err := b.AppendSupplier(buf.ReadFullFrom(reader, 3)); err != nil {
2017-01-07 19:06:35 -05:00
return nil, err
}
resp := b.Byte(1)
if resp != 0x00 {
2017-04-09 07:30:46 -04:00
return nil, newError("server rejects request: ", resp)
2017-01-07 19:06:35 -05:00
}
b.Clear()
2018-02-23 17:42:01 -05:00
address, port, err := addrParser.ReadAddressPort(b, reader)
if err != nil {
2017-01-07 19:06:35 -05:00
return nil, err
}
if request.Command == protocol.RequestCommandUDP {
udpRequest := &protocol.RequestHeader{
Version: socks5Version,
Command: protocol.RequestCommandUDP,
Address: address,
Port: port,
}
return udpRequest, nil
}
return nil, nil
}