init

Author: jpillora

chisel-forward/main.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/jpillora/chisel"
+)
+
+const help = `
+	Usage: chisel-forward [--auth str] 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)
+
+`
+
+func main() {
+	auth := flag.String("auth", "", "Optional authentication")
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, help)
+		os.Exit(1)
+	}
+	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)
+	}
+
+	b, _ := json.Marshal(c)
+
+	fmt.Printf("%s", b)
+}

chiseld/main.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/jpillora/chisel"
+	"golang.org/x/net/websocket"
+)
+
+func main() {
+
+	auth := os.Getenv("AUTH")
+
+	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
+	}
+
+	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)
+	})
+
+	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"))
+		}
+	})
+
+	//get port
+	port := os.Getenv("PORT")
+	if port == "" {
+		port = "8080"
+	}
+	//listen
+	log.Println("listening on " + port)
+	log.Fatal(http.ListenAndServe(":"+port, handleHTTP))
+}

config.go

@@ -0,0 +1,41 @@
+package chisel
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+type Config struct {
+	Version string
+	Auth    string
+	Remotes []*Remote
+}
+
+const pre = "chisel-"
+
+func DecodeConfig(s string) (*Config, error) {
+	if !strings.HasPrefix(s, pre) {
+		return nil, fmt.Errorf("Invalid config")
+	}
+	s = strings.TrimPrefix(s, pre)
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid hex config")
+	}
+	c := &Config{}
+	err = json.Unmarshal(b, c)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid JSON config")
+	}
+	return c, nil
+}
+
+func EncodeConfig(c *Config) (string, error) {
+	b, err := json.Marshal(c)
+	if err != nil {
+		return "", err
+	}
+	return pre + hex.EncodeToString(b), nil
+}

remote.go

@@ -0,0 +1,117 @@
+package chisel
+
+import (
+	"errors"
+	"net/url"
+	"regexp"
+	"strings"
+)
+
+// short-hand conversions
+//   foobar.com:3000 ->
+//		local 127.0.0.1:3000
+//		remote foobar.com:3000
+//   3000:google.com:80 ->
+//		local 127.0.0.1:3000
+//		remote google.com:80
+//   192.168.0.1:3000:google.com:80 ->
+//		local 192.168.0.1:3000
+//		remote google.com:80
+
+type Remote struct {
+	LocalHost, LocalPort, RemoteHost, RemotePort string
+}
+
+func DecodeRemote(s string) (*Remote, error) {
+	parts := strings.Split(s, ":")
+
+	if len(parts) <= 0 || len(parts) >= 5 {
+		return nil, errors.New("Invalid remote")
+	}
+
+	r := &Remote{}
+
+	//TODO fix up hacky decode
+	for i := len(parts) - 1; i >= 0; i-- {
+		p := parts[i]
+
+		if isPort(p) {
+			if r.LocalPort == "" {
+				r.LocalPort = p
+				r.RemotePort = p
+			} else {
+				r.RemotePort = p
+			}
+			continue
+		}
+
+		if r.RemotePort == "" && r.LocalPort == "" {
+			return nil, errors.New("Missing ports")
+		}
+
+		if !isHTTP.MatchString(p) {
+			p = "http://" + p
+		}
+
+		if !isHost(p) {
+			return nil, errors.New("Invalid host")
+		}
+
+		if r.RemoteHost == "" {
+			r.RemoteHost = p
+		} else {
+			r.LocalHost = p
+		}
+	}
+	if r.LocalHost == "" {
+		r.LocalHost = "http://0.0.0.0"
+	}
+	if r.RemoteHost == "" {
+		return nil, errors.New("Missing remote host")
+	}
+	return r, nil
+}
+
+var isPortRegExp = regexp.MustCompile(`^\d+$`)
+
+func isPort(s string) bool {
+	if !isPortRegExp.MatchString(s) {
+		return false
+	}
+	return true
+}
+
+var isHTTP = regexp.MustCompile(`^http?:\/\/`)
+
+func isHost(s string) bool {
+	_, err := url.Parse(s)
+	if err != nil {
+		return false
+	}
+	return true
+}
+
+// func EncodeRemote(r *Remote) (string, error) {
+// 	s := ""
+// 	n := 0
+// 	if r.RemotePort != "" {
+// 		s = r.RemotePort
+// 		n++
+// 	}
+// 	if r.RemoteHost != "" {
+// 		s = r.RemoteHost + ":" + s
+// 		n++
+// 	}
+// 	if r.LocalPort != "" {
+// 		s = r.LocalPort + ":" + s
+// 		n++
+// 	}
+// 	if r.LocalHost != "" {
+// 		s = r.LocalHost + ":" + s
+// 		n++
+// 	}
+// 	if n == 0 {
+// 		return "", errors.New("Invalid remote")
+// 	}
+// 	return s, nil
+// }

version.go

@@ -0,0 +1,3 @@
+package chisel
+
+const Version = "1"