Initial Commit

Author: James Cunningham

.gitignore

@@ -0,0 +1 @@
+switcher

LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2014, James Cunningham
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the switcher nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL JAMES CUNNINGHAM BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Makefile

@@ -0,0 +1,4 @@
+.PHONY: build
+
+build:
+	go build -o switcher *.go

README.md

@@ -0,0 +1,72 @@
+![Switcher Logo](https://i.imgur.com/YL46yH8.png)
+
+Switcher
+========
+
+Switcher is a proxy server which accepts connections and proxies based on which protocol is detected.
+
+Currently implemented is:
+
+  - SSH
+
+The use case is running HTTP(S) and SSH on the same port.
+
+
+Usage
+-----
+
+To Build:
+
+    make
+
+To get help:
+
+    $ ./switcher --help
+    Switcher 1.0.0
+    usage: switcher [options]
+
+    Options:
+      --listen   <:80>            Server Listen Address
+      --ssh      <127.0.0.1:22>   SSH Server Address
+      --default  <127.0.0.1:8080>  Default Server Address
+
+    Examples:
+      To serve SSH(127.0.0.1:22) and HTTP(127.0.0.1:8080) on port 80
+      $ switcher
+
+      To serve SSH(127.0.0.1:2222) and HTTPS(127.0.0.1:443) on port 443
+      $ switcher --listen :443 --ssh 127.0.0.1:2222 --default 127.0.0.1:443
+
+
+Example
+-------
+
+Run switcher on HTTP port 80, proxy to SSH on 127.0.0.1:22 and Nginx on 127.0.0.1:8080
+
+    $ switcher --listen :80 --ssh 127.0.0.1:22 --default 127.0.0.1:8080
+
+To test HTTP:
+
+    $ curl -I http://my-server.local
+    HTTP/1.1 200 OK
+
+To test SSH
+
+    $ ssh [email protected] -p 80
+    Password:
+
+
+Why not sslh
+------------
+
+Switcher is heavily influenced by (sslh)[https://github.com/yrutschle/sslh]. It started out as a learning exercise to discover how sslh worked and attempt an implementation in Go.
+
+The result is useful in its own right through use of Go's interfaces for protocol matching (making adding new protocols trivial), and lightweight goroutines (instead of forking, which is more CPU intensive under load).
+
+
+License
+-------
+
+3-Clause "Modified" BSD Licence.
+
+(License)[LICENSE]

extra/logo.psd

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+)
+
+var (
+	listenAddress  = flag.String("listen", ":80", "Server Listen Address")
+	sshAddress     = flag.String("ssh", "127.0.0.1:22", "SSH Server Address")
+	defaultAddress = flag.String("default", "127.0.0.1:8080", "Default Server Address")
+)
+
+func usage() {
+	fmt.Println("Switcher 1.0.0")
+	fmt.Println("usage: switcher [options]\n")
+
+	fmt.Println("Options:")
+	fmt.Println("  --listen   <:80>            Server Listen Address")
+	fmt.Println("  --ssh      <127.0.0.1:22>   SSH Server Address")
+	fmt.Println("  --default  <127.0.0.1:8080>  Default Server Address\n")
+
+	fmt.Println("Examples:")
+	fmt.Println("  To serve SSH(127.0.0.1:22) and HTTP(127.0.0.1:8080) on port 80")
+	fmt.Println("  $ switcher\n")
+
+	fmt.Println("  To serve SSH(127.0.0.1:2222) and HTTPS(127.0.0.1:443) on port 443")
+	fmt.Println("  $ switcher --listen :443 --ssh 127.0.0.1:2222 --default 127.0.0.1:443")
+}
+
+func main() {
+	flag.Usage = usage
+	flag.Parse()
+
+	mux := NewMux()
+
+	mux.Handle(SSH(*sshAddress))
+	mux.Handle(TCP(*defaultAddress))
+
+	log.Printf("[INFO] listen: %s\n", *listenAddress)
+	err := mux.ListenAndServe(*listenAddress)
+	if err != nil {
+		log.Fatalf("[FATAL] listen: %s\n", err)
+	}
+}

main.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"io"
+	"log"
+	"net"
+)
+
+type Protocol interface {
+	// address to proxy to
+	Address() string
+
+	// identify protocol from header
+	Identify(header []byte) bool
+}
+
+type Mux struct {
+	Handlers []Protocol
+}
+
+// create a new Mux assignment
+func NewMux() *Mux {
+	return &Mux{}
+}
+
+// add a protocol to mux handler set
+func (m *Mux) Handle(p Protocol) {
+	m.Handlers = append(m.Handlers, p)
+}
+
+// match protocol to handler
+// returns address to proxy to
+func (m *Mux) Identify(header []byte) (address string) {
+	if len(m.Handlers) < 1 {
+		return ""
+	}
+
+	for _, handler := range m.Handlers {
+		if handler.Identify(header) {
+			return handler.Address()
+		}
+	}
+
+	// return address of last handler, default
+	return m.Handlers[len(m.Handlers)-1].Address()
+}
+
+// create a server on given address and handle incoming connections
+func (m *Mux) ListenAndServe(addr string) error {
+	server, err := net.Listen("tcp", addr)
+	if err != nil {
+		return err
+	}
+
+	for {
+		conn, err := server.Accept()
+		if err != nil {
+			return err
+		}
+
+		go m.Serve(conn)
+	}
+
+	return nil
+}
+
+// serve takes an incomming connection, applies configured protocol
+// handlers and proxies the connection based on result
+func (m *Mux) Serve(conn net.Conn) error {
+	defer conn.Close()
+
+	// get first 3 bytes of connection as header
+	header := make([]byte, 3)
+	if _, err := io.ReadAtLeast(conn, header, 3); err != nil {
+		return err
+	}
+
+	// identify protocol from header
+	address := m.Identify(header)
+
+	log.Printf("[INFO] proxy: from=%s to=%s\n", conn.RemoteAddr(), address)
+
+	// connect to remote
+	remote, err := net.Dial("tcp", address)
+	if err != nil {
+		log.Printf("[ERROR] remote: %s\n", err)
+		return err
+	}
+	defer remote.Close()
+
+	// write header we chopped back to remote
+	remote.Write(header)
+
+	// proxy between us and remote server
+	err = Shovel(conn, remote)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

mux.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"io"
+)
+
+// proxy between two sockets
+func Shovel(local, remote io.ReadWriteCloser) error {
+	err := make(chan error)
+
+	go chanCopy(err, local, remote)
+	go chanCopy(err, remote, local)
+
+	return <-err
+}
+
+// copy between pipes, sending errors to channel
+func chanCopy(e chan error, dst, src io.ReadWriter) {
+	_, err := io.Copy(dst, src)
+	if err != nil {
+		e <- err
+	}
+}

shovel.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"bytes"
+)
+
+type SSH string
+
+// address to proxy to
+func (s SSH) Address() string {
+	return string(s)
+}
+
+// identify header as one of SSH
+func (s SSH) Identify(header []byte) bool {
+	// first 3 bytes of 1.0/2.0 is literal `SSH`
+	if bytes.Compare(header, []byte("SSH")) == 0 {
+		return true
+	}
+
+	return false
+}

ssh.go

@@ -0,0 +1,14 @@
+package main
+
+type TCP string
+
+// address to proxy to
+func (t TCP) Address() string {
+	return string(t)
+}
+
+// identify header as one of TCP
+func (t TCP) Identify(header []byte) bool {
+	// this is a dummy protocol handler used for the default
+	return false
+}