working!

Author: jpillora

README.md

@@ -0,0 +1,107 @@
+# chisel
+
+Chisel is TCP proxy tunnelled over HTTP and Websockets
+
+### Install
+
+Server
+
+```
+$ go get -v github.com/jpillora/chisel/chiseld
+$ chiseld --help
+
+	Usage: chiseld [--host 0.0.0.0] [--port 8080] [--auth str]
+
+	host defines the HTTP listening host – the
+	network interface (defaults to 0.0.0.0). You
+	may also set the HOST environment variable.
+
+	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.
+```
+
+Forwarder
+
+```
+$ go get -v github.com/jpillora/chisel/chisel-forward
+$ chisel-forward --help
+
+	Usage: chisel-forward [--auth str] server remote [remote] [remote] ...
+
+	where 'server' is the URL to the chiseld server
+
+	where 'remote' is a 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)
+```
+
+### Usage
+
+
+### Performance
+
+With crowbar, I was getting extremely slow transfer times
+
+```
+#tab 1 (basic file server)
+$ serve -p 4000
+
+#tab 2 (tunnel server)
+$ echo -ne "foo:bar" > userfile
+$ crowbard -listen="0.0.0.0:8080" -userfile=./userfile
+
+#tab 3 (tunnel client)
+$ crowbar-forward -local=0.0.0.0:3000 -server http://localhost:8080 -remote localhost:4000 -username foo -password bar
+
+#tab 4 (transfer test)
+$ time curl -s "127.0.0.1:3000/largefile.bin" > /dev/null
+       74.74 real         2.37 user         6.74 sys
+```
+
+Here, `largefile.bin` (~200MB) is transferred in 1m14s over localhost (also has high CPU utilisation).
+
+Enter `chisel`, lets swap in `chiseld` and `chisel-forward`:
+
+```
+#tab 2 (tunnel server)
+$ chiseld --auth foo
+
+#tab 3 (tunnel client)
+$ chisel-forward --auth foo http://localhost:8080 3000:4000
+2015/02/27 16:13:43 Connected to http://localhost:8080
+2015/02/27 16:13:43 Proxy 0.0.0.0:3000 => 0.0.0.0:4000 enabled
+
+#tab 4 (transfer test)
+$ time curl -s "127.0.0.1:3000/largefile.bin" > /dev/null
+       0.60 real         0.05 user         0.14 sys
+```
+
+Here, the same file was transferred in 0.6s
+
+#### MIT License
+
+Copyright © 2014 Jaime Pillora <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

chisel-forward/client/client.go

@@ -1,8 +1,8 @@
 package client
 
 import (
-	"fmt"
 	"log"
+	"net"
 	"strings"
 
 	"github.com/hashicorp/yamux"
@@ -12,23 +12,21 @@ import (
 
 type Client struct {
 	config  *chisel.Config
-	proxies []*ProxyServer
-	ws      *websocket.Conn
-	session *yamux.Session
+	proxies []*Proxy
 }
 
-func NewClient(auth, server string, args []string) *Client {
+func NewClient(auth, server string, remotes []string) *Client {
 
 	c := &chisel.Config{
 		Version: chisel.Version,
 		Auth:    auth,
 		Server:  server,
 	}
 
-	for _, a := range args {
-		r, err := chisel.DecodeRemote(a)
+	for _, s := range remotes {
+		r, err := chisel.DecodeRemote(s)
 		if err != nil {
-			log.Fatalf("Remote decode failed: %s", err)
+			log.Fatalf("Failed to decode remote '%s': %s", s, err)
 		}
 		c.Remotes = append(c.Remotes, r)
 	}
@@ -37,70 +35,53 @@ func NewClient(auth, server string, args []string) *Client {
 }
 
 func (c *Client) Start() {
-	s, err := chisel.EncodeConfig(c.config)
+	encconfig, 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/")
+	ws, err := websocket.Dial(url, encconfig, "http://localhost/")
 	if err != nil {
 		log.Fatal(err)
 	}
 
+	b := make([]byte, 0xff)
+	n, _ := ws.Read(b)
+	if msg := string(b[:n]); msg != "handshake-success" {
+		log.Fatal(msg)
+	}
+
 	// Setup client side of yamux
-	c.session, err = yamux.Client(c.ws, nil)
+	session, err := yamux.Client(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)
+	markClosed := make(chan bool)
+	isClosed := false
 
+	//proxies all use this function
+	openStream := func() (net.Conn, error) {
+		stream, err := session.Open()
 		if err != nil {
-			break
+			if !isClosed {
+				close(markClosed)
+			}
+			return nil, err
 		}
+		return stream, nil
+	}
 
-		b := buff[:n]
-
-		fmt.Printf("%s\n", b)
-
-		//decode
-		//place on proxy's read queue
+	//prepare proxies
+	for id, r := range c.config.Remotes {
+		proxy := NewProxy(id, r, openStream)
+		go proxy.start()
+		c.proxies = append(c.proxies, proxy)
 	}
+
+	log.Printf("Connected to %s\n", c.config.Server)
+	<-markClosed
+	isClosed = true
+	log.Printf("Disconnected\n")
 }

chisel-forward/client/proxy-server.go

@@ -0,0 +1,66 @@
+package client
+
+import (
+	"encoding/binary"
+	"log"
+	"net"
+
+	"github.com/jpillora/chisel"
+)
+
+type Proxy struct {
+	id         int
+	count      int
+	remote     *chisel.Remote
+	openStream func() (net.Conn, error)
+}
+
+func NewProxy(id int, remote *chisel.Remote, openStream func() (net.Conn, error)) *Proxy {
+	return &Proxy{
+		id:         id,
+		remote:     remote,
+		openStream: openStream,
+	}
+}
+
+func (p *Proxy) start() {
+
+	l, err := net.Listen("tcp4", p.remote.LocalHost+":"+p.remote.LocalPort)
+	if err != nil {
+		log.Printf("Proxy %s failed: %s", p.remote, err)
+		return
+	}
+
+	log.Printf("Proxy %s enabled", p.remote)
+	for {
+		src, err := l.Accept()
+		if err != nil {
+			log.Println(err)
+			return
+		}
+		go p.accept(src)
+	}
+}
+
+func (p *Proxy) accept(src net.Conn) {
+	p.count++
+	c := p.count
+
+	log.Printf("[#%d] accept conn %d", p.id, c)
+
+	dst, err := p.openStream()
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	//write endpoint id
+	b := make([]byte, 2)
+	binary.BigEndian.PutUint16(b, uint16(p.id))
+	dst.Write(b)
+
+	//then pipe
+	chisel.Pipe(src, dst)
+
+	log.Printf("[#%d] close conn %d", p.id, c)
+}