// A small SSH daemon providing client login attempts

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net"
    "time"
    "golang.org/x/crypto/ssh"
)

func main() {
    config := &ssh.ServerConfig{
        PasswordCallback: func(c ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) {
            fmt.Println(
                "Time:", time.Now().Format(time.RFC822Z),
                "Client:", c.RemoteAddr().String(),
                "User:", c.User(),
                "Password:", string(pass),
            )
            return nil, fmt.Errorf("password rejected for %q", c.User())
        },
    }

    privateBytes, err := ioutil.ReadFile("id_rsa")
    if err != nil {
        log.Fatal("Failed to load private key (./id_rsa)")
    }

    private, err := ssh.ParsePrivateKey(privateBytes)
    if err != nil {
        log.Fatal("Failed to parse private key")
    }

    config.AddHostKey(private)

    listener, err := net.Listen("tcp", "0.0.0.0:22")
    if err != nil {
        log.Fatalf("Failed to listen on 22 (%s)", err)
    }

    log.Print("Listening on 22...")
    for {
        tcpConn, err := listener.Accept()
        if err != nil {
            log.Printf("Failed to accept incoming connection (%s)", err)
            continue
        }
        _,  chans, reqs, err := ssh.NewServerConn(tcpConn, config)
        if err != nil {
            log.Printf("Failed to handshake (%s)", err)
            continue
        }

        go ssh.DiscardRequests(reqs)
        go handleChannels(chans)
    }
}

func handleChannels(chans <-chan ssh.NewChannel) {
    for newChannel := range chans {
        go handleChannel(newChannel)
    }
}

func handleChannel(newChannel ssh.NewChannel) {
    return
}