Low budget man-in-the-middle

main.go

package main

import (
        "flag"
        "fmt"
        "io"
        "log"
        "net"
        "os"
)

func main() {
        var localPort string
        flag.StringVar(&localPort, "localPort", "9090", "local port")

        var remoteHost string
        flag.StringVar(&remoteHost, "remoteHost",
                defaultRemote().String(), "remote IP or hostname")

        var remotePort string
        flag.StringVar(&remotePort, "remotePort", "80", "report port")
        flag.Parse()

        fmt.Println("starting...")
        remote := net.JoinHostPort(remoteHost, remotePort)
        rc, err := net.Dial("tcp", remote)
        if err != nil {
                panic(fmt.Sprintf("cannot connect to %v: %v",
                        remote, err))
        }

        local := net.JoinHostPort(net.IPv6loopback.String(), localPort)
        listener, err := net.Listen("tcp", local)
        if err != nil {
                log.Fatalf("cannot listen on %v: %v", local, err)
        }
        for {
                lc, err := listener.Accept()
                if err != nil {
                        log.Fatalf("failed to accept listener: %v", err)
                }
                go copyDuplex(lc, rc)
        }
}

func copyDuplex(src, dst net.Conn) {
        go func() {
                defer dst.Close()
                defer src.Close()
                // output to Stdout
                tee := io.TeeReader(src, os.Stdout)
                io.Copy(dst, tee)
        }()
        go func() {
                defer dst.Close()
                defer src.Close()
                // input to Stderr
                tee := io.TeeReader(dst, os.Stderr)
                io.Copy(src, tee)
        }()
}

func defaultRemote() net.IP {
        return net.IPv6loopback
}