Example #1
0
func (s TorPTTransport) Parse() (starter server.Starter, err error) {

	handler := server.NewHandler(s.Name)

	remoteAddr := server.NewOption("remoteaddr")
	err = remoteAddr.Required()
	if err != nil {
		handler.PrintError(err.Error())
		return
	}
	s.RemoteAddr = remoteAddr.Get()

	secret := server.NewOption("secret")
	err = secret.Required()
	if err != nil {
		handler.PrintError(err.Error())
		return
	}

	err = s.Args.UnmarshalJSON([]byte(secret.Get()))
	if err != nil {
		handler.PrintError(err.Error())
		return
	}
	handler.PrintVersion()
	return s, nil

}
Example #2
0
func (s ShadowsocksTransport) Parse() (starter server.Starter, err error) {

	handler := server.NewHandler(s.Name)
	handler.PrintVersion()

	bindAddr := server.NewOption("bindaddr")
	bindAddr.Default("127.0.0.1:0")

	_, bindPortStr, err := net.SplitHostPort(bindAddr.BindAddr())
	if err != nil {
		handler.PrintError(err.Error())
		return
	}
	s.BindAddr = bindAddr.Get()
	bindPort, err := strconv.Atoi(bindPortStr)
	if err != nil {
		handler.PrintError(err.Error())
		return
	}
	s.BindPort = bindPort

	remoteAddr := server.NewOption("remoteaddr")
	err = remoteAddr.Required()
	if err != nil {
		handler.PrintError(err.Error())
		return
	}
	s.RemoteAddr = remoteAddr.Get()

	remoteHost, remotePortStr, err := net.SplitHostPort(remoteAddr.Get())
	if err != nil {
		handler.PrintError(err.Error())
		return
	}
	s.RemoteHost = remoteHost

	remotePort, err := strconv.Atoi(remotePortStr)
	if err != nil {
		handler.PrintError(err.Error())
		return
	}
	s.RemotePort = remotePort

	secret := server.NewOption("secret")
	err = secret.Required()
	if err != nil {
		handler.PrintError(err.Error())
		return
	}
	s.Secret = secret.Get()
	return s, nil
}
Example #3
0
func (m MockTransport) Parse() (starter server.Starter, err error) {
	handler := server.NewHandler(m.Name)
	handler.PrintVersion()
	bindAddr := server.NewOption("bindaddr")
	m.BindAddr = bindAddr.Get()
	return m, nil
}
Example #4
0
func (s Socks5Transport) Parse() (starter server.Starter, err error) {
	handler := server.NewHandler(s.Name)
	err = handler.PrintVersion()
	if err != nil {
		return nil, err
	}
	// handler := server.NewHandler(s.Name)
	bindAddr := server.NewOption("bindaddr")
	s.BindAddr = bindAddr.Get()
	return s, nil
}
Example #5
0
	"github.com/alkasir/alkasir/pkg/service/server"
	"github.com/armon/go-socks5"
)

type Socks5Transport struct {
	Name      string
	Transport string
	BindAddr  string
}

const (
	transportName = "socks5"
)

var transportOption = server.NewOption("transport")

func Check(serviceName *server.Option) (server.Parser, error) {
	if !serviceName.Is("transport") {
		return nil, server.ServiceNotFound()
	}
	if !transportOption.Is(transportName) {
		return nil, server.TransportNotFound()
	}
	st := Socks5Transport{
		Name:      serviceName.Get(),
		Transport: transportOption.Get(),
	}
	return st, nil
}
Example #6
0
func (s ShadowsocksTransport) Start() error {
	handler := server.NewHandler(s.Name)

	listener, err := net.Listen("tcp", s.BindAddr)
	if err != nil {
		listener, err = net.Listen("tcp", "127.0.0.1:0")
	}
	if err != nil {
		handler.PrintError("CANNOT BIND TO ANY PORT")
		return errors.New("Cannot bind to any port")
	}

	listener = handler.MonitorListener(listener)
	handler.PrintExpose("socks5", listener.Addr().String())

	config := &ss.Config{
		Server:     s.RemoteHost,
		ServerPort: s.RemotePort,
		Password:   s.Secret,
		LocalPort:  s.BindPort,
		Method:     "aes-256-cfb",
	}

	parseServerConfig(config)

	handler.PrintDone()

	verbose := server.NewOption("verbose")

	if verbose.Has() {
		s.Verbose = true
		ss.SetDebug(true)
		debug = true
	}

	go func() {
		for {
			defer listener.Close()
			conn, err := listener.Accept()
			if err != nil {
				debug.Println("accept:", err)
				continue
			}
			go func(conn net.Conn) {
				conn = handler.MonitorConn(conn)
				if debug {
					debug.Printf("socks connect from %s\n", conn.RemoteAddr().String())
				}
				closed := false
				defer func() {
					if !closed {
						conn.Close()
					}
				}()

				var err error = nil
				if err = handShake(conn); err != nil {
					debug.Printf("socks handshake: %s", err)
					return
				}
				rawaddr, addr, err := getRequest(conn)
				if err != nil {
					debug.Println("error getting request:", err)
					return
				}
				// Sending connection established message immediately to client.
				// This some round trip time for creating socks connection with the client.
				// But if connection failed, the client will get connection reset error.
				_, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x08, 0x43})
				if err != nil {
					debug.Println("send connection confirmation:", err)
					return
				}

				remote, err := createServerConn(rawaddr, addr)
				if err != nil {
					if len(servers.srvCipher) > 1 {
						debug.Println("Failed connect to all avaiable shadowsocks server")
					}
					return
				}
				handler.TrackOpenConn(addr)
				defer func() {
					if !closed {
						remote.Close()
					}
				}()

				go ss.PipeThenClose(conn, remote)
				ss.PipeThenClose(remote, conn)
				closed = true
				handler.TrackCloseConn(addr)

			}(conn)
		}
	}()
	handler.Wait()
	return nil
}