spikefish.go

package main

import (
        "bytes"
        "log"
	"crypto/rsa"
	"crypto/dsa"
	"io"
	"crypto"
	"errors"
        "exp/ssh"
        "io/ioutil"
	"crypto/x509"
	"encoding/pem"
)

const testClientPrivateKey = `-----BEGIN RSA PRIVATE KEY-----
MIIEowIBAAKCAQEAluabv/gWq8IFQmoOHGyGJsYYiYivO1EyZEuulSlrSHBFEjVt
HWc5ehjXHoTyhPtAfkR/w1GzVbnDjI07BKaqVYJ6EIGmD9i3utC65UGR9p9jXF01
FSDyenCYjW3cMN3uw6n9e6VgfyU7xsjAEg8JxnFDZ8oAIu6uXw8bNSP9+QGquQ1N
aybMQfx9UPxJY6Fgn0dwlkgAFBs12DR5sNf8yeNMbvhUAI9WYqgbRSrQ80qKLcQA
IW0gaNdTBAOuxdzzBF7TD/RoRbRzk56GbL13U8pt/+5GLbt4vWk8fAQ/ZtvGT9gF
pYdekudTvHV1LvYX8xnDmwrrxGBpuCzwKDbBtwIDAQABAoIBAC+yZqqQFUJnCliK
wzkSyHh7Bwh57sF2EdKH5X/6XpHAAuUVhA7WMOG59k0MQsfrzt/acPPg4CmJlRjZ
Dz2SHKb4nfKXuFCr9K8VCO4sAqIMkVCBmaS7DEnNSzrw7bd4ft7T3W52wICP2Uwk
6ikLHdDeviqRO+fOv8kGMlhirwVEmFwXuVIaC8j5sE7pJ+JweusFnwQphjgCID5q
uTfyh3yUPzbdL41MmmI+KDHIP47wO+iPSp0Vf63+C2l6+z4KpVF2850KpfXQ3acJ
7krPxdIN5D3ZM2FTrRuU305rJ6Ijkxsed2VWhptIne7Aprz2TDTL+DjQc3OzjVJE
C/d0V6kCgYEAxbGR5HFhOg1OCrwTH9K/tVjzw9r+16vIUsSMGyOks9d3LwRzfowj
HTPx5irveiMqKEt13YS47M8I4Ge3sDs/ODaN8H2ZJ0cjj7CeQswkFg/VfbfKtx+E
01rBcgIHpKOWhBfk/Z+rgoRYgkor9/mqyZg9EhD9aXnvH5koX9wh/MMCgYEAw2gM
R7J8M7CnKkQ36UvFHgCCPWyLh2xPq7e843F76KA4Cj9Fyh3HDDNW4h4xfES0M1ui
sBWHUcxUhEnjNmzI6soa7AnFPNxsJLs5o6EEvXjaed5ouYyAS6Y69CUONt4r+ISf
9y5bi47VS1Sra/X+u4z/QlfInv87AxaovUmE5/0CgYAkmjnu1+cufmQirKvFyplg
FDYd3yAsAkw2ttlR9Ql7mrsgY2yW0490yrdQ7EYmkPgvObl66CXtAnAcTFfAM1gD
KmahTj/a+9rjscm7iFxuEURv4GWR/i3zi+whFasgmoE1t87X/oYcxjA0/1KguQMc
DCnSfH7O1pqleQ/2n6VTTQKBgBvOfKDfR0lbxA4BsyshuyUv0VjIT3qv8Q5wkRKU
nZtW4WKj6lx+rEqSK7T1svkKFdKRIa+JAL6lIwnIMesWw+iVZgtcwJKOk10Ov38H
dNM5lW1uNtzgn4kkWJNRippIN12gEdts314Wr0eO/u3YDa3GvLRGJahqjY089jop
ch5JAoGBAJYkDRWRncEx1qb2pH4yUPG9HaiBcATSoOc+L8fasYu0iKNAPDSSiEai
Qy5iOI0Y6WDYb60WAga/P4l5Iaim1t5Ae7PgK0NrQ6Bto9bJdukD5FzRNaE21FXH
S0/IFa7vQT4UNFQiusWR7elbkf7838KB/GOSy+10ppk5VQEm3yrc
-----END RSA PRIVATE KEY-----`

// password implements the ClientPassword interface
type password string

func (p password) Password(user string) (string, error) {
	return string(p), nil
}

type keychain struct {
        keys []interface{}
}

func (k *keychain) Key(i int) (interface{}, error) {
	if i < 0 || i >= len(k.keys) {
		return nil, nil
	}
	switch key := k.keys[i].(type) {
	case *rsa.PrivateKey:
		return key.PublicKey, nil
	case *dsa.PrivateKey:
		return key.PublicKey, nil
	}
	panic("unknown key type")
}

func (k *keychain) Sign(i int, rand io.Reader, data []byte) (sig []byte, err error) {
	hashFunc := crypto.SHA1
	h := hashFunc.New()
	h.Write(data)
	digest := h.Sum(nil)
	switch key := k.keys[i].(type) {
	case *rsa.PrivateKey:
		return rsa.SignPKCS1v15(rand, key, hashFunc, digest)
	}
	return nil, errors.New("unknown key type")
}

var (
        clientKeychain = new(keychain)
	rsakey         *rsa.PrivateKey
)

func pubKeyAuth(user, algorithm string, pubkey []byte) bool {
        path := "keys/" + user
        key, err := ioutil.ReadFile(path)
        if err != nil {
                ioutil.WriteFile(path, pubkey, 0666)
                return false
        } else {
                if bytes.Equal(key, pubkey) {
                        log.Printf("Hello %s\n", user)
                        return true
                }
        }
        return false
}

func main() {
        //pemBytes, err := ioutil.ReadFile("fixtures/id_rsa_test")
        block, _ := pem.Decode([]byte(testClientPrivateKey))
        rsakey, _ = x509.ParsePKCS1PrivateKey(block.Bytes)

        clientKeychain.keys = append(clientKeychain.keys, rsakey)
        clientAuth := []ssh.ClientAuth{
                        ssh.ClientAuthPassword(password("password")),
                        ssh.ClientAuthKeyring(clientKeychain),
        }

        config := &ssh.ClientConfig{
                        User: "root",
                        Auth: clientAuth,
        }

        client, err := ssh.Dial("tcp", "10.1.0.3:22", config)
        if err != nil {
                log.Fatalf("%v\n", err)
        }
        client.Close()


/*
        config := &ssh.ServerConfig{PublicKeyCallback: pubKeyAuth}

        if err != nil {
                log.Fatalf("%v\n", err)
        }

        err = config.SetRSAPrivateKey(pemBytes)
        if err != nil {
                log.Fatalf("%v\n", err)
        }

        listener, _ := ssh.Listen("tcp", "0.0.0.0:2022", config)

        log.Printf("SpikeFish\n")
        log.Printf("    listening for incoming connection on :2022\n")

        for {
                conn, err := listener.Accept()
                if err != nil {
                        log.Fatalf("%v\n", err)
                }
                err = conn.Handshake()
                if err != nil {
                        log.Fatalf("%v\n", err)
                }
                go func() {
                        defer conn.Close()
                        for {
                                channel, _ := conn.Accept()
                                channel.Accept()

                                shell := ssh.NewServerShell(channel, "> ")
                                go func() {
                                        defer channel.Close()
                                        for {
                                                line, err := shell.ReadLine()
                                                if err != nil {
                                                        log.Fatalf("%v\n", err)
                                                        break
                                                }
                                                config := &ssh.ClientConfig{
                                                        User: "root",
                                                        Auth: []ssh.ClientAuth{
                                                                ssh.ClientAuthKeyring(clientKeychain),
                                                        },
                                                }
                                                client, err := ssh.Dial("tcp", "10.1.0.3:22", config)
                                                if err != nil {
                                                        log.Fatalf("%v\n", err)
                                                }
                                                client.Close()
                                                println(client)
                                                println(line)
                                        }
                                        return
                                }()
                        }
                }()
        }
        */
}