splitting out into modules, currently not working

Author: jpillora

chisel-forward/client/client.go

@@ -0,0 +1,106 @@
+package client
+
+import (
+	"fmt"
+	"log"
+	"strings"
+
+	"github.com/hashicorp/yamux"
+	"github.com/jpillora/chisel"
+	"golang.org/x/net/websocket"
+)
+
+type Client struct {
+	config  *chisel.Config
+	proxies []*ProxyServer
+	ws      *websocket.Conn
+	session *yamux.Session
+}
+
+func NewClient(auth, server string, args []string) *Client {
+
+	c := &chisel.Config{
+		Version: chisel.Version,
+		Auth:    auth,
+		Server:  server,
+	}
+
+	for _, a := range args {
+		r, err := chisel.DecodeRemote(a)
+		if err != nil {
+			log.Fatalf("Remote decode failed: %s", err)
+		}
+		c.Remotes = append(c.Remotes, r)
+	}
+
+	return &Client{config: c}
+}
+
+func (c *Client) Start() {
+	s, err := chisel.EncodeConfig(c.config)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	url := strings.Replace(c.config.Server, "http:", "ws:", 1)
+	c.ws, err = websocket.Dial(url, s, "http://localhost/")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Setup client side of yamux
+	c.session, err = yamux.Client(c.ws, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	//prepare proxies
+	for id, r := range c.config.Remotes {
+		if err := c.setupProxy(id, r, c.session); err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	// ws.Write([]byte("hello!"))
+
+	fmt.Printf("Connected to %s\n", c.config.Server)
+	c.handleData()
+	fmt.Printf("Disconnected\n")
+}
+
+func (c *Client) setupProxy(id int, r *chisel.Remote, session *yamux.Session) error {
+
+	addr := r.LocalHost + ":" + r.LocalPort
+
+	proxy := NewProxyServer(id, addr, session)
+	//watch conn for writes
+	// go func() {
+	// 	for b := range conn.out {
+	// 		//encode
+	// 		c.ws.Write(b)
+	// 	}
+	// }()
+
+	go proxy.start()
+	c.proxies = append(c.proxies, proxy)
+	return nil
+}
+
+func (c *Client) handleData() {
+
+	buff := make([]byte, 0xffff)
+	for {
+		n, err := c.ws.Read(buff)
+
+		if err != nil {
+			break
+		}
+
+		b := buff[:n]
+
+		fmt.Printf("%s\n", b)
+
+		//decode
+		//place on proxy's read queue
+	}
+}

chisel-forward/client/proxy-server.go

@@ -0,0 +1,69 @@
+package client
+
+//proxy conn        server  | clients
+//                 /-> ws <-|-> ws <--> local <-
+//         proxy <---> ws <-|-> ws <--> local <-
+//                 \-> ws <-|-> ws <--> local <-
+import (
+	"encoding/binary"
+	"log"
+	"net"
+
+	"github.com/hashicorp/yamux"
+	"github.com/jpillora/chisel"
+)
+
+type ProxyServer struct {
+	id      int
+	addr    string
+	session *yamux.Session
+}
+
+func NewProxyServer(id int, addr string, session *yamux.Session) *ProxyServer {
+	return &ProxyServer{
+		id:      id,
+		addr:    addr,
+		session: session,
+	}
+}
+
+func (r *ProxyServer) start() {
+
+	a, err := net.ResolveTCPAddr("tcp4", r.addr)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	l, err := net.ListenTCP("tcp4", a)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for {
+		src, err := l.Accept()
+		if err != nil {
+			log.Println(err)
+			return
+		}
+
+		dst, err := r.session.Open()
+		if err != nil {
+			log.Println(err)
+			return
+		}
+
+		b := make([]byte, 2)
+		binary.BigEndian.PutUint16(b, uint16(r.id))
+		dst.Write(b)
+
+		chisel.Pipe(src, dst)
+	}
+}
+
+func (r *ProxyServer) Send() {
+
+}
+
+func (r *ProxyServer) Recieve() {
+
+}

chisel-forward/main.go

@@ -1,21 +1,22 @@
 package main
 
 import (
-	"encoding/json"
 	"flag"
 	"fmt"
 	"log"
 	"os"
 
-	"github.com/jpillora/chisel"
+	"github.com/jpillora/chisel/chisel-forward/client"
 )
 
 const help = `
-	Usage: chisel-forward [--auth str] remote [remote] [remote]
+	Usage: chisel-forward [--auth str] server remote [remote] [remote] ...
 
-	where a remote is in the form:
-		example.com:3000 (http://0.0.0.0:3000 => http://example.com:3000)
-		3000:google.com:80 (http://0.0.0.0:3000 => http://google.com:80)
+	where server is the URL to the chiseld server
+
+	where a remote is remote connection via the server, in the form
+		example.com:3000 (which means http://0.0.0.0:3000 => http://example.com:3000)
+		3000:google.com:80 (which means http://0.0.0.0:3000 => http://google.com:80)
 
 `
 
@@ -27,30 +28,12 @@ func main() {
 	}
 	flag.Parse()
 	args := flag.Args()
-
-	c := &chisel.Config{
-		Version: chisel.Version,
-		Auth:    *auth,
-	}
-
-	for _, a := range args {
-		r, err := chisel.DecodeRemote(a)
-		if err != nil {
-			log.Fatalf("Remote decode failed: %s", err)
-		}
-		c.Remotes = append(c.Remotes, r)
-	}
-
-	if len(c.Remotes) == 0 {
-		log.Fatalf("At least one remote is required")
-	}
-
-	fmt.Printf("Forwarding:\n")
-	for i, r := range c.Remotes {
-		fmt.Printf(" [#%d] %s:%s -> %s:%s\n", i+1, r.LocalHost, r.LocalPort, r.RemoteHost, r.RemotePort)
+	if len(args) < 2 {
+		log.Fatalf("A server and least one remote is required")
 	}
 
-	b, _ := json.Marshal(c)
+	server := args[0]
+	args = args[1:]
 
-	fmt.Printf("%s", b)
+	client.NewClient(*auth, server, args).Start()
 }

chiseld/main.go

@@ -1,68 +1,61 @@
 package main
 
 import (
+	"flag"
 	"fmt"
-	"io"
-	"log"
-	"net/http"
 	"os"
 
-	"github.com/jpillora/chisel"
-	"golang.org/x/net/websocket"
+	"github.com/jpillora/chisel/chiseld/server"
 )
 
-func main() {
+const help = `
+	Usage: chiseld [--host 0.0.0.0] [--port 8080] [--auth str]
 
-	auth := os.Getenv("AUTH")
+	host defines the HTTP listening host – the
+	network interface (defaults to 0.0.0.0). You
+	may also set the HOST environment variable.
 
-	handshakeWS := func(h string) (*chisel.Config, error) {
-		c, err := chisel.DecodeConfig(h)
-		if err != nil {
-			return nil, err
-		}
-		if chisel.Version != c.Version {
-			return nil, fmt.Errorf("Version mismatch")
-		}
-		if auth != "" {
-			if auth != c.Auth {
-				return nil, fmt.Errorf("Authentication failed")
-			}
-		}
-		return c, nil
-	}
+	port defines the HTTP listening port (defaults
+	to 8080). You may also set the PORT environment
+	variable.
+
+	auth specifies the exact authentication string
+	the client must provide to attain access. You
+	may also set the AUTH environment variable.
+
+`
 
-	handleWS := websocket.Handler(func(ws *websocket.Conn) {
-		protos := ws.Config().Protocol
-		if len(protos) != 1 {
-			ws.Write([]byte("Handshake invalid"))
-			ws.Close()
-			return
-		}
-		config, err := handshakeWS(protos[0])
-		if err != nil {
-			ws.Write([]byte("Handshake denied: " + err.Error()))
-			ws.Close()
-			return
-		}
-		fmt.Printf("%+v\n", config)
-		io.Copy(ws, ws)
-	})
+func main() {
+
+	hostf := flag.String("host", "", "")
+	portf := flag.String("port", "", "")
+	authf := flag.String("auth", "", "")
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, help)
+		os.Exit(1)
+	}
+	flag.Parse()
 
-	handleHTTP := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Header.Get("Upgrade") == "websocket" {
-			handleWS.ServeHTTP(w, r)
-		} else {
-			w.WriteHeader(200)
-			w.Write([]byte("hello world\n"))
-		}
-	})
+	host := *hostf
+	if host == "" {
+		host = os.Getenv("HOST")
+	}
+	if host == "" {
+		host = "0.0.0.0"
+	}
 
-	//get port
-	port := os.Getenv("PORT")
+	port := *portf
+	if port == "" {
+		port = os.Getenv("PORT")
+	}
 	if port == "" {
 		port = "8080"
 	}
-	//listen
-	log.Println("listening on " + port)
-	log.Fatal(http.ListenAndServe(":"+port, handleHTTP))
+
+	auth := *authf
+	if auth == "" {
+		auth = os.Getenv("AUTH")
+	}
+
+	server.NewServer(auth).Start(host, port)
 }

chiseld/server/endpoint.go

@@ -0,0 +1,44 @@
+package server
+
+import (
+	"log"
+	"net"
+
+	"github.com/jpillora/chisel"
+)
+
+type Endpoint struct {
+	id      int
+	addr    string
+	session chan net.Conn
+}
+
+func NewEndpoint(id int, addr string) *Endpoint {
+	return &Endpoint{
+		id:      id,
+		addr:    addr,
+		session: make(chan net.Conn),
+	}
+}
+
+func (e *Endpoint) start() {
+
+	laddr, _ := net.ResolveTCPAddr("tcp4", "127.0.0.1")
+	raddr, err := net.ResolveTCPAddr("tcp4", e.addr)
+	if err != nil {
+		log.Fatal(err)
+		return
+	}
+
+	for src := range e.session {
+
+		dst, err := net.DialTCP("tcp4", laddr, raddr)
+		if err != nil {
+			log.Println(err)
+			src.Close()
+			continue
+		}
+
+		chisel.Pipe(src, dst)
+	}
+}