import logging
import netmiko
import time

class BaseSshDriver(object):
    def __init__(self, ip, port, user, password, brand):
        self.ip = ip
        self.port = port
        self.user = user
        self.password = password
        self.brand = brand
        self.timestamp = None
        self.conn = None

    def open_session(self):
        try:
            device = {
                'device_type': self.brand,
                'ip': self.ip,
                'username': self.user,
                'password': self.password,
                'port': self.port,
            }
            # open ssh session based on netmiko lib
            self.conn = netmiko.ConnectHandler(**device)
        except Exception as e:
            logging.error("Failed open ssh session: %s" % str(e))
            return False
        self.timestamp = time.time()
        return True

    def is_session_opened(self):
        if not self.conn:
            return False
        try:
            connected = self.conn.find_prompt()
        except Exception as e:
            logging.debug("Find ssh prompt error: %s" % str(e))
            return False

        return connected

    def send_cmd(self, commands):
        if not self.is_session_opened():
            return "SSH session to %s is invalid!" % self.ip, 400
        try:
            output = ""
            for command in commands:
                result = self.conn.send_command(command, strip_prompt=False, max_loops=800)
                output = output + "\n" + result
        except Exception as e:
            logging.error("SSH get error. %s" % repr(e))
            return str(e), 400

        return str(output), 200

func (group *dhGroup) Client(c packetConn, randSource io.Reader, magics *handshakeMagics) (*kexResult, error) {
	hashFunc := crypto.SHA1

	var x *big.Int
	for {
		var err error
		if x, err = rand.Int(randSource, group.pMinus1); err != nil {
			return nil, err
		}
		if x.Sign() > 0 {
			break
		}
	}

	X := new(big.Int).Exp(group.g, x, group.p)
	kexDHInit := kexDHInitMsg{
		X: X,
	}
	if err := c.writePacket(Marshal(&kexDHInit)); err != nil {
		return nil, err
	}

	packet, err := c.readPacket()
	if err != nil {
		return nil, err
	}

	var kexDHReply kexDHReplyMsg
	if err = Unmarshal(packet, &kexDHReply); err != nil {
		///////////////////////////////////////////////////
		// the console output: >>>>> [31] ssh: short read. Seems the packet is too short so unmarshal failed.
		///////////////////////////////////////////////////
		fmt.Println(">>>>>", packet, err)
		return nil, err
	}

	ki, err := group.diffieHellman(kexDHReply.Y, x)
	if err != nil {
		return nil, err
	}

	h := hashFunc.New()
	magics.write(h)
	writeString(h, kexDHReply.HostKey)
	writeInt(h, X)
	writeInt(h, kexDHReply.Y)
	K := make([]byte, intLength(ki))
	marshalInt(K, ki)
	h.Write(K)

	return &kexResult{
		H:         h.Sum(nil),
		K:         K,
		HostKey:   kexDHReply.HostKey,
		Signature: kexDHReply.Signature,
		Hash:      crypto.SHA1,
	}, nil
}

func Unmarshal(data []byte, out interface{}) error {
	......
		case reflect.Slice:
			switch t.Elem().Kind() {
			case reflect.Uint8:
				if structType.Field(i).Tag.Get("ssh") == "rest" {
					field.Set(reflect.ValueOf(data))
					data = nil
				} else {
					var s []byte
					///////////////////////////////////////////////////
					// the error is created at here. 
					// parseString() asks len(data) > 4 (in fact len(data) = 1) so it returns false.
					///////////////////////////////////////////////////
					if s, data, ok = parseString(data); !ok { 
						return errShortRead
					}
					field.Set(reflect.ValueOf(s))
				}
	......
}

package main

import (
	"fmt"
	"net"
	"time"

	"golang.org/x/crypto/ssh"
)

func main() {
	config := new(ssh.ClientConfig)
	config.SetDefaults()
	config.User = "user"
	config.Auth = []ssh.AuthMethod{ssh.Password("passwd")}
	config.Timeout = time.Second * 5
	config.Ciphers = append(config.Ciphers, "aes256-cbc", "aes128-cbc",
		"3des-cbc", "aes256-cbc", "des-cbc")
	config.HostKeyCallback = func(hostname string, remote net.Addr,
		key ssh.PublicKey) error {
		return nil
	}
	client, err := ssh.Dial("tcp", "106.39.177.129:22", config)
	if err != nil {
		fmt.Println(err)
	} else {
		client.Close()
	}
}