package ssh

Import Path
	golang.org/x/crypto/ssh (on go.dev)

Dependency Relation
	imports 47 packages, and imported by 3 packages

Involved Source Files

	      buffer.go
	      certs.go
	      channel.go
	      cipher.go
	      client.go
	      client_auth.go
	      common.go
	      connection.go
	   d➜ doc.go
		Package ssh implements an SSH client and server.

		SSH is a transport security protocol, an authentication protocol and a
		family of application protocols. The most typical application level
		protocol is a remote shell and this is specifically implemented.  However,
		the multiplexed nature of SSH is exposed to users that wish to support
		others.

		References:
		  [PROTOCOL.certkeys]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.certkeys?rev=HEAD
		  [SSH-PARAMETERS]:    http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1

		This package does not fall under the stability promise of the Go language itself,
		so its API may be changed when pressing needs arise.

	      handshake.go
	      kex.go
	      keys.go
	      mac.go
	      messages.go
	      mux.go
	      server.go
	      session.go
	      ssh_gss.go
	      streamlocal.go
	      tcpip.go
	      transport.go
Code Examples

	ClientConfig_HostKeyCallback
		package main
		
		import (
			"bufio"
			"golang.org/x/crypto/ssh"
			"log"
			"os"
			"path/filepath"
			"strings"
		)
		
		func main() {
			// Every client must provide a host key check.  Here is a
			// simple-minded parse of OpenSSH's known_hosts file
			host := "hostname"
			file, err := os.Open(filepath.Join(os.Getenv("HOME"), ".ssh", "known_hosts"))
			if err != nil {
				log.Fatal(err)
			}
			defer file.Close()
		
			scanner := bufio.NewScanner(file)
			var hostKey ssh.PublicKey
			for scanner.Scan() {
				fields := strings.Split(scanner.Text(), " ")
				if len(fields) != 3 {
					continue
				}
				if strings.Contains(fields[0], host) {
					var err error
					hostKey, _, _, _, err = ssh.ParseAuthorizedKey(scanner.Bytes())
					if err != nil {
						log.Fatalf("error parsing %q: %v", fields[2], err)
					}
					break
				}
			}
		
			if hostKey == nil {
				log.Fatalf("no hostkey for %s", host)
			}
		
			config := ssh.ClientConfig{
				User:            os.Getenv("USER"),
				HostKeyCallback: ssh.FixedHostKey(hostKey),
			}
		
			_, err = ssh.Dial("tcp", host+":22", &config)
			log.Println(err)
		}


	Client_Listen
		package main
		
		import (
			"fmt"
			"golang.org/x/crypto/ssh"
			"log"
			"net/http"
		)
		
		func main() {
			var hostKey ssh.PublicKey
			config := &ssh.ClientConfig{
				User: "username",
				Auth: []ssh.AuthMethod{
					ssh.Password("password"),
				},
				HostKeyCallback: ssh.FixedHostKey(hostKey),
			}
			// Dial your ssh server.
			conn, err := ssh.Dial("tcp", "localhost:22", config)
			if err != nil {
				log.Fatal("unable to connect: ", err)
			}
			defer conn.Close()
		
			// Request the remote side to open port 8080 on all interfaces.
			l, err := conn.Listen("tcp", "0.0.0.0:8080")
			if err != nil {
				log.Fatal("unable to register tcp forward: ", err)
			}
			defer l.Close()
		
			// Serve HTTP with your SSH server acting as a reverse proxy.
			http.Serve(l, http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
				fmt.Fprintf(resp, "Hello world!\n")
			}))
		}


	Dial
		package main
		
		import (
			"bytes"
			"fmt"
			"golang.org/x/crypto/ssh"
			"log"
		)
		
		func main() {
			var hostKey ssh.PublicKey
			// An SSH client is represented with a ClientConn.
			//
			// To authenticate with the remote server you must pass at least one
			// implementation of AuthMethod via the Auth field in ClientConfig,
			// and provide a HostKeyCallback.
			config := &ssh.ClientConfig{
				User: "username",
				Auth: []ssh.AuthMethod{
					ssh.Password("yourpassword"),
				},
				HostKeyCallback: ssh.FixedHostKey(hostKey),
			}
			client, err := ssh.Dial("tcp", "yourserver.com:22", config)
			if err != nil {
				log.Fatal("Failed to dial: ", err)
			}
			defer client.Close()
		
			// Each ClientConn can support multiple interactive sessions,
			// represented by a Session.
			session, err := client.NewSession()
			if err != nil {
				log.Fatal("Failed to create session: ", err)
			}
			defer session.Close()
		
			// Once a Session is created, you can execute a single command on
			// the remote side using the Run method.
			var b bytes.Buffer
			session.Stdout = &b
			if err := session.Run("/usr/bin/whoami"); err != nil {
				log.Fatal("Failed to run: " + err.Error())
			}
			fmt.Println(b.String())
		}


	NewServerConn
		package main
		
		import (
			"fmt"
			"golang.org/x/crypto/ssh"
			"golang.org/x/crypto/ssh/terminal"
			"io/ioutil"
			"log"
			"net"
		)
		
		func main() {
			// Public key authentication is done by comparing
			// the public key of a received connection
			// with the entries in the authorized_keys file.
			authorizedKeysBytes, err := ioutil.ReadFile("authorized_keys")
			if err != nil {
				log.Fatalf("Failed to load authorized_keys, err: %v", err)
			}
		
			authorizedKeysMap := map[string]bool{}
			for len(authorizedKeysBytes) > 0 {
				pubKey, _, _, rest, err := ssh.ParseAuthorizedKey(authorizedKeysBytes)
				if err != nil {
					log.Fatal(err)
				}
		
				authorizedKeysMap[string(pubKey.Marshal())] = true
				authorizedKeysBytes = rest
			}
		
			// An SSH server is represented by a ServerConfig, which holds
			// certificate details and handles authentication of ServerConns.
			config := &ssh.ServerConfig{
				// Remove to disable password auth.
				PasswordCallback: func(c ssh.ConnMetadata, pass []byte) (*ssh.Permissions, error) {
					// Should use constant-time compare (or better, salt+hash) in
					// a production setting.
					if c.User() == "testuser" && string(pass) == "tiger" {
						return nil, nil
					}
					return nil, fmt.Errorf("password rejected for %q", c.User())
				},
		
				// Remove to disable public key auth.
				PublicKeyCallback: func(c ssh.ConnMetadata, pubKey ssh.PublicKey) (*ssh.Permissions, error) {
					if authorizedKeysMap[string(pubKey.Marshal())] {
						return &ssh.Permissions{
							// Record the public key used for authentication.
							Extensions: map[string]string{
								"pubkey-fp": ssh.FingerprintSHA256(pubKey),
							},
						}, nil
					}
					return nil, fmt.Errorf("unknown public key for %q", c.User())
				},
			}
		
			privateBytes, err := ioutil.ReadFile("id_rsa")
			if err != nil {
				log.Fatal("Failed to load private key: ", err)
			}
		
			private, err := ssh.ParsePrivateKey(privateBytes)
			if err != nil {
				log.Fatal("Failed to parse private key: ", err)
			}
		
			config.AddHostKey(private)
		
			// Once a ServerConfig has been configured, connections can be
			// accepted.
			listener, err := net.Listen("tcp", "0.0.0.0:2022")
			if err != nil {
				log.Fatal("failed to listen for connection: ", err)
			}
			nConn, err := listener.Accept()
			if err != nil {
				log.Fatal("failed to accept incoming connection: ", err)
			}
		
			// Before use, a handshake must be performed on the incoming
			// net.Conn.
			conn, chans, reqs, err := ssh.NewServerConn(nConn, config)
			if err != nil {
				log.Fatal("failed to handshake: ", err)
			}
			log.Printf("logged in with key %s", conn.Permissions.Extensions["pubkey-fp"])
		
			// The incoming Request channel must be serviced.
			go ssh.DiscardRequests(reqs)
		
			// Service the incoming Channel channel.
			for newChannel := range chans {
				// Channels have a type, depending on the application level
				// protocol intended. In the case of a shell, the type is
				// "session" and ServerShell may be used to present a simple
				// terminal interface.
				if newChannel.ChannelType() != "session" {
					newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
					continue
				}
				channel, requests, err := newChannel.Accept()
				if err != nil {
					log.Fatalf("Could not accept channel: %v", err)
				}
		
				// Sessions have out-of-band requests such as "shell",
				// "pty-req" and "env".  Here we handle only the
				// "shell" request.
				go func(in <-chan *ssh.Request) {
					for req := range in {
						req.Reply(req.Type == "shell", nil)
					}
				}(requests)
		
				term := terminal.NewTerminal(channel, "> ")
		
				go func() {
					defer channel.Close()
					for {
						line, err := term.ReadLine()
						if err != nil {
							break
						}
						fmt.Println(line)
					}
				}()
			}
		}


	PublicKeys
		package main
		
		import (
			"golang.org/x/crypto/ssh"
			"io/ioutil"
			"log"
		)
		
		func main() {
			var hostKey ssh.PublicKey
			// A public key may be used to authenticate against the remote
			// server by using an unencrypted PEM-encoded private key file.
			//
			// If you have an encrypted private key, the crypto/x509 package
			// can be used to decrypt it.
			key, err := ioutil.ReadFile("/home/user/.ssh/id_rsa")
			if err != nil {
				log.Fatalf("unable to read private key: %v", err)
			}
		
			// Create the Signer for this private key.
			signer, err := ssh.ParsePrivateKey(key)
			if err != nil {
				log.Fatalf("unable to parse private key: %v", err)
			}
		
			config := &ssh.ClientConfig{
				User: "user",
				Auth: []ssh.AuthMethod{
					// Use the PublicKeys method for remote authentication.
					ssh.PublicKeys(signer),
				},
				HostKeyCallback: ssh.FixedHostKey(hostKey),
			}
		
			// Connect to the remote server and perform the SSH handshake.
			client, err := ssh.Dial("tcp", "host.com:22", config)
			if err != nil {
				log.Fatalf("unable to connect: %v", err)
			}
			defer client.Close()
		}


	Session_RequestPty
		package main
		
		import (
			"golang.org/x/crypto/ssh"
			"log"
		)
		
		func main() {
			var hostKey ssh.PublicKey
			// Create client config
			config := &ssh.ClientConfig{
				User: "username",
				Auth: []ssh.AuthMethod{
					ssh.Password("password"),
				},
				HostKeyCallback: ssh.FixedHostKey(hostKey),
			}
			// Connect to ssh server
			conn, err := ssh.Dial("tcp", "localhost:22", config)
			if err != nil {
				log.Fatal("unable to connect: ", err)
			}
			defer conn.Close()
			// Create a session
			session, err := conn.NewSession()
			if err != nil {
				log.Fatal("unable to create session: ", err)
			}
			defer session.Close()
			// Set up terminal modes
			modes := ssh.TerminalModes{
				ssh.ECHO:          0,     // disable echoing
				ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
				ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
			}
			// Request pseudo terminal
			if err := session.RequestPty("xterm", 40, 80, modes); err != nil {
				log.Fatal("request for pseudo terminal failed: ", err)
			}
			// Start remote shell
			if err := session.Shell(); err != nil {
				log.Fatal("failed to start shell: ", err)
			}
		}


Package-Level Type Names (total 156, in which 35 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type AlgorithmSigner (interface)
		A AlgorithmSigner is a Signer that also supports specifying a specific
		algorithm to use for signing.

		Methods (total 3, all are exported)
			( T) PublicKey() PublicKey
				PublicKey returns an associated PublicKey instance.

			( T) Sign(rand io.Reader, data []byte) (*Signature, error)
				Sign returns raw signature for the given data. This method
				will apply the hash specified for the keytype to the data.

			( T) SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*Signature, error)
				SignWithAlgorithm is like Signer.Sign, but allows specification of a
				non-default signing algorithm. See the SigAlgo* constants in this
				package for signature algorithms supported by this package. Callers may
				pass an empty string for the algorithm in which case the AlgorithmSigner
				will use its default algorithm.

		Implemented By (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*algorithmOpenSSHCertSigner
			*dsaPrivateKey
			*wrappedSigner
		Implements (at least one exported)
			 T : Signer

	 type AuthMethod (interface)
		An AuthMethod represents an instance of an RFC 4252 authentication method.

		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			( T) auth(session []byte, user string, p packetConn, rand io.Reader) (authResult, []string, error)
				auth authenticates user over transport t.
				Returns true if authentication is successful.
				If authentication is not successful, a []string of alternative
				method names is returned. If the slice is nil, it will be ignored
				and the previous set of possible methods will be reused.

			( T) method() string
				method returns the RFC 4252 method name.

		Implemented By (at least 6, in which 1 are exported)
			 KeyboardInteractiveChallenge
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			*gssAPIWithMICCallback
			*noneAuth
			 passwordCallback
			 publicKeyCallback
			*retryableAuthMethod
		As Outputs Of (at least 7, all are exported)
			func GSSAPIWithMICAuthMethod(gssAPIClient GSSAPIClient, target string) AuthMethod
			func KeyboardInteractive(challenge KeyboardInteractiveChallenge) AuthMethod
			func Password(secret string) AuthMethod
			func PasswordCallback(prompt func() (secret string, err error)) AuthMethod
			func PublicKeys(signers ...Signer) AuthMethod
			func PublicKeysCallback(getSigners func() (signers []Signer, err error)) AuthMethod
			func RetryableAuthMethod(auth AuthMethod, maxTries int) AuthMethod
		As Inputs Of (at least one exported)
			func RetryableAuthMethod(auth AuthMethod, maxTries int) AuthMethod

	 type BannerCallback (func)
		BannerCallback is the function type used for treat the banner sent by
		the server. A BannerCallback receives the message sent by the remote server.

		As Outputs Of (at least one exported)
			func BannerDisplayStderr() BannerCallback

	 type CertChecker (struct)
		CertChecker does the work of verifying a certificate. Its methods
		can be plugged into ClientConfig.HostKeyCallback and
		ServerConfig.PublicKeyCallback. For the CertChecker to work,
		minimally, the IsAuthority callback should be set.

		Fields (total 7, all are exported)
			Clock func() time.Time
				Clock is used for verifying time stamps. If nil, time.Now
				is used.

			HostKeyFallback HostKeyCallback
				HostKeyFallback is called when CertChecker.CheckHostKey encounters a
				public key that is not a certificate. It must implement host key
				validation or else, if nil, all such keys are rejected.

			IsHostAuthority func(auth PublicKey, address string) bool
				IsHostAuthority should report whether the key is recognized as
				an authority for this host. This allows for certificates to be
				signed by other keys, and for those other keys to only be valid
				signers for particular hostnames. This must be set if this
				CertChecker will be checking host certificates.

			IsRevoked func(cert *Certificate) bool
				IsRevoked is called for each certificate so that revocation checking
				can be implemented. It should return true if the given certificate
				is revoked and false otherwise. If nil, no certificates are
				considered to have been revoked.

			IsUserAuthority func(auth PublicKey) bool
				IsUserAuthority should return true if the key is recognized as an
				authority for the given user certificate. This allows for
				certificates to be signed by other certificates. This must be set
				if this CertChecker will be checking user certificates.

			SupportedCriticalOptions []string
				SupportedCriticalOptions lists the CriticalOptions that the
				server application layer understands. These are only used
				for user certificates.

			UserKeyFallback func(conn ConnMetadata, key PublicKey) (*Permissions, error)
				UserKeyFallback is called when CertChecker.Authenticate encounters a
				public key that is not a certificate. It must implement validation
				of user keys or else, if nil, all such keys are rejected.

		Methods (total 3, all are exported)
			(*T) Authenticate(conn ConnMetadata, pubKey PublicKey) (*Permissions, error)
				Authenticate checks a user certificate. Authenticate can be used as
				a value for ServerConfig.PublicKeyCallback.

			(*T) CheckCert(principal string, cert *Certificate) error
				CheckCert checks CriticalOptions, ValidPrincipals, revocation, timestamp and
				the signature of the certificate.

			(*T) CheckHostKey(addr string, remote net.Addr, key PublicKey) error
				CheckHostKey checks a host key certificate. This method can be
				plugged into ClientConfig.HostKeyCallback.


	 type Certificate (struct)
		An Certificate represents an OpenSSH certificate as defined in
		[PROTOCOL.certkeys]?rev=1.8. The Certificate type implements the
		PublicKey interface, so it can be unmarshaled using
		ParsePublicKey.

		Fields (total 14, all are exported)
			CertType uint32
			Key PublicKey
			KeyId string
			Nonce []byte
			Permissions Permissions
			Permissions.CriticalOptions map[string]string
				CriticalOptions indicate restrictions to the default
				permissions, and are typically used in conjunction with
				user certificates. The standard for SSH certificates
				defines "force-command" (only allow the given command to
				execute) and "source-address" (only allow connections from
				the given address). The SSH package currently only enforces
				the "source-address" critical option. It is up to server
				implementations to enforce other critical options, such as
				"force-command", by checking them after the SSH handshake
				is successful. In general, SSH servers should reject
				connections that specify critical options that are unknown
				or not supported.

			Permissions.Extensions map[string]string
				Extensions are extra functionality that the server may
				offer on authenticated connections. Lack of support for an
				extension does not preclude authenticating a user. Common
				extensions are "permit-agent-forwarding",
				"permit-X11-forwarding". The Go SSH library currently does
				not act on any extension, and it is up to server
				implementations to honor them. Extensions can be used to
				pass data from the authentication callbacks to the server
				application layer.

			Reserved []byte
			Serial uint64
			Signature *Signature
			SignatureKey PublicKey
			ValidAfter uint64
			ValidBefore uint64
			ValidPrincipals []string
		Methods (total 5, in which 4 are exported)
			(*T) Marshal() []byte
				Marshal serializes c into OpenSSH's wire format. It is part of the
				PublicKey interface.

			(*T) SignCert(rand io.Reader, authority Signer) error
				SignCert signs the certificate with an authority, setting the Nonce,
				SignatureKey, and Signature fields.

			(*T) Type() string
				Type returns the key name. It is part of the PublicKey interface.

			(*T) Verify(data []byte, sig *Signature) error
				Verify verifies a signature against the certificate's public
				key. It is part of the PublicKey interface.

			/* one unexported ... *//* one unexported: */
			(*T) bytesForSigning() []byte
		Implements (at least one exported)
			*T : PublicKey
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func parseCert(in []byte, privAlgo string) (*Certificate, error)
		As Inputs Of (at least 2, both are exported)
			func NewCertSigner(cert *Certificate, signer Signer) (Signer, error)
			func (*CertChecker).CheckCert(principal string, cert *Certificate) error

	 type Channel (interface)
		A Channel is an ordered, reliable, flow-controlled, duplex stream
		that is multiplexed over an SSH connection.

		Methods (total 6, all are exported)
			( T) Close() error
				Close signals end of channel use. No data may be sent after this
				call.

			( T) CloseWrite() error
				CloseWrite signals the end of sending in-band
				data. Requests may still be sent, and the other side may
				still send data

			( T) Read(data []byte) (int, error)
				Read reads up to len(data) bytes from the channel.

			( T) SendRequest(name string, wantReply bool, payload []byte) (bool, error)
				SendRequest sends a channel request.  If wantReply is true,
				it will wait for a reply and return the result as a
				boolean, otherwise the return value will be false. Channel
				requests are out-of-band messages so they may be sent even
				if the data stream is closed or blocked by flow control.
				If the channel is closed before a reply is returned, io.EOF
				is returned.

			( T) Stderr() io.ReadWriter
				Stderr returns an io.ReadWriter that writes to this channel
				with the extended data type set to stderr. Stderr may
				safely be read and written from a different goroutine than
				Read and Write respectively.

			( T) Write(data []byte) (int, error)
				Write writes len(data) bytes to the channel.

		Implemented By (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 chanConn
			*channel
			 tcpChan
		Implements (at least 11, in which 10 are exported)
			 T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			 T : github.com/jbenet/go-context/io.Reader
			 T : github.com/jbenet/go-context/io.Writer
			 T : io.Closer
			 T : io.ReadCloser
			 T : io.Reader
			 T : io.ReadWriteCloser
			 T : io.ReadWriter
			 T : io.WriteCloser
			 T : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			 T : net/http.closeWriter
		As Outputs Of (at least 4, in which 2 are exported)
			func Conn.OpenChannel(name string, data []byte) (Channel, <-chan *Request, error)
			func NewChannel.Accept() (Channel, <-chan *Request, error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func (*Client).dial(laddr string, lport int, raddr string, rport int) (Channel, error)
			func (*Client).dialStreamLocal(socketPath string) (Channel, error)
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func newSession(ch Channel, reqs <-chan *Request) (*Session, error)
			func golang.org/x/crypto/ssh/agent.forwardUnixSocket(channel Channel, addr string)

	 type Client (struct)
		Client implements a traditional SSH client that supports shells,
		subprocesses, TCP port/streamlocal forwarding and tunneled dialing.

		Fields (total 5, in which 1 are exported)
			Conn Conn
			/* 4 unexporteds ... *//* 4 unexporteds: */
			channelHandlers map[string]chan NewChannel
			forwards forwardList
				// forwarded tcpip connections from the remote side

			handleForwardsOnce sync.Once
				// guards calling (*Client).handleForwards

			mu sync.Mutex
		Methods (total 23, in which 17 are exported)
			( T) ClientVersion() []byte
				ClientVersion returns the client's version string as hashed
				into the session ID.

			( T) Close() error
				Close closes the underlying network connection

			(*T) Dial(n, addr string) (net.Conn, error)
				Dial initiates a connection to the addr from the remote host.
				The resulting connection has a zero LocalAddr() and RemoteAddr().

			(*T) DialTCP(n string, laddr, raddr *net.TCPAddr) (net.Conn, error)
				DialTCP connects to the remote address raddr on the network net,
				which must be "tcp", "tcp4", or "tcp6".  If laddr is not nil, it is used
				as the local address for the connection.

			(*T) HandleChannelOpen(channelType string) <-chan NewChannel
				HandleChannelOpen returns a channel on which NewChannel requests
				for the given type are sent. If the type already is being handled,
				nil is returned. The channel is closed when the connection is closed.

			(*T) Listen(n, addr string) (net.Listener, error)
				Listen requests the remote peer open a listening socket on
				addr. Incoming connections will be available by calling Accept on
				the returned net.Listener. The listener must be serviced, or the
				SSH connection may hang.
				N must be "tcp", "tcp4", "tcp6", or "unix".

			(*T) ListenTCP(laddr *net.TCPAddr) (net.Listener, error)
				ListenTCP requests the remote peer open a listening socket
				on laddr. Incoming connections will be available by calling
				Accept on the returned net.Listener.

			(*T) ListenUnix(socketPath string) (net.Listener, error)
				ListenUnix is similar to ListenTCP but uses a Unix domain socket.

			( T) LocalAddr() net.Addr
				LocalAddr returns the local address for this connection.

			(*T) NewSession() (*Session, error)
				NewSession opens a new Session for this client. (A session is a remote
				execution of a program.)

			( T) OpenChannel(name string, data []byte) (Channel, <-chan *Request, error)
				OpenChannel tries to open an channel. If the request is
				rejected, it returns *OpenChannelError. On success it returns
				the SSH Channel and a Go channel for incoming, out-of-band
				requests. The Go channel must be serviced, or the
				connection will hang.

			( T) RemoteAddr() net.Addr
				RemoteAddr returns the remote address for this connection.

			( T) SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error)
				SendRequest sends a global request, and returns the
				reply. If wantReply is true, it returns the response status
				and payload. See also RFC4254, section 4.

			( T) ServerVersion() []byte
				ServerVersion returns the server's version string as hashed
				into the session ID.

			( T) SessionID() []byte
				SessionID returns the session hash, also denoted by H.

			( T) User() string
				User returns the user ID for this connection.

			( T) Wait() error
				Wait blocks until the connection has shut down, and returns the
				error causing the shutdown.

			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) autoPortListenWorkaround(laddr *net.TCPAddr) (net.Listener, error)
				autoPortListenWorkaround simulates automatic port allocation by
				trying random ports repeatedly.

			(*T) dial(laddr string, lport int, raddr string, rport int) (Channel, error)
			(*T) dialStreamLocal(socketPath string) (Channel, error)
			(*T) handleChannelOpens(in <-chan NewChannel)
				handleChannelOpens channel open messages from the remote side.

			(*T) handleForwards()
				handleForwards starts goroutines handling forwarded connections.
				It's called on first use by (*Client).ListenTCP to not launch
				goroutines until needed.

			(*T) handleGlobalRequests(incoming <-chan *Request)
		Implements (at least 4, all are exported)
			 T : Conn
			 T : ConnMetadata
			*T : golang.org/x/net/proxy.Dialer
			 T : io.Closer
		As Outputs Of (at least 3, in which 2 are exported)
			func Dial(network, addr string, config *ClientConfig) (*Client, error)
			func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client
			/* at least one unexported ... *//* at least one unexported: */
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.dial(network, addr string, config *ClientConfig) (*Client, error)
		As Inputs Of (at least 2, both are exported)
			func golang.org/x/crypto/ssh/agent.ForwardToAgent(client *Client, keyring agent.Agent) error
			func golang.org/x/crypto/ssh/agent.ForwardToRemote(client *Client, addr string) error

	 type ClientConfig (struct)
		A ClientConfig structure is used to configure a Client. It must not be
		modified after having been passed to an SSH function.

		Fields (total 13, all are exported)
			Auth []AuthMethod
				Auth contains possible authentication methods to use with the
				server. Only the first instance of a particular RFC 4252 method will
				be used during authentication.

			BannerCallback BannerCallback
				BannerCallback is called during the SSH dance to display a custom
				server's message. The client configuration can supply this callback to
				handle it as wished. The function BannerDisplayStderr can be used for
				simplistic display on Stderr.

			ClientVersion string
				ClientVersion contains the version identification string that will
				be used for the connection. If empty, a reasonable default is used.

			Config Config
				Config contains configuration that is shared between clients and
				servers.

			Config.Ciphers []string
				The allowed cipher algorithms. If unspecified then a sensible
				default is used.

			Config.KeyExchanges []string
				The allowed key exchanges algorithms. If unspecified then a
				default set of algorithms is used.

			Config.MACs []string
				The allowed MAC algorithms. If unspecified then a sensible default
				is used.

			Config.Rand io.Reader
				Rand provides the source of entropy for cryptographic
				primitives. If Rand is nil, the cryptographic random reader
				in package crypto/rand will be used.

			Config.RekeyThreshold uint64
				The maximum number of bytes sent or received after which a
				new key is negotiated. It must be at least 256. If
				unspecified, a size suitable for the chosen cipher is used.

			HostKeyAlgorithms []string
				HostKeyAlgorithms lists the key types that the client will
				accept from the server as host key, in order of
				preference. If empty, a reasonable default is used. Any
				string returned from PublicKey.Type method may be used, or
				any of the CertAlgoXxxx and KeyAlgoXxxx constants.

			HostKeyCallback HostKeyCallback
				HostKeyCallback is called during the cryptographic
				handshake to validate the server's host key. The client
				configuration must supply this callback for the connection
				to succeed. The functions InsecureIgnoreHostKey or
				FixedHostKey can be used for simplistic host key checks.

			Timeout time.Duration
				Timeout is the maximum amount of time for the TCP connection to establish.

				A Timeout of zero means no timeout.

			User string
				User contains the username to authenticate as.

		Methods (only one, which is exported)
			(*T) SetDefaults()
				SetDefaults sets sensible values for unset fields in config. This is
				exported for testing: Configs passed to SSH functions are copied and have
				default values set automatically.

		As Outputs Of (at least 7, all are exported)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.AuthMethod.ClientConfig() (*ClientConfig, error)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.(*HostKeyCallbackHelper).SetHostKeyCallback(cfg *ClientConfig) (*ClientConfig, error)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.(*KeyboardInteractive).ClientConfig() (*ClientConfig, error)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.(*Password).ClientConfig() (*ClientConfig, error)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.(*PasswordCallback).ClientConfig() (*ClientConfig, error)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.(*PublicKeys).ClientConfig() (*ClientConfig, error)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.(*PublicKeysCallback).ClientConfig() (*ClientConfig, error)
		As Inputs Of (at least 8, in which 4 are exported)
			func Dial(network, addr string, config *ClientConfig) (*Client, error)
			func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan NewChannel, <-chan *Request, error)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.NewClient(config *ClientConfig) transport.Transport
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.(*HostKeyCallbackHelper).SetHostKeyCallback(cfg *ClientConfig) (*ClientConfig, error)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func newClientTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ClientConfig, dialAddr string, addr net.Addr) *handshakeTransport
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.dial(network, addr string, config *ClientConfig) (*Client, error)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.overrideConfig(overrides *ClientConfig, c *ClientConfig)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.overrideConfig(overrides *ClientConfig, c *ClientConfig)

	 type Config (struct)
		Config contains configuration data common to both ServerConfig and
		ClientConfig.

		Fields (total 5, all are exported)
			Ciphers []string
				The allowed cipher algorithms. If unspecified then a sensible
				default is used.

			KeyExchanges []string
				The allowed key exchanges algorithms. If unspecified then a
				default set of algorithms is used.

			MACs []string
				The allowed MAC algorithms. If unspecified then a sensible default
				is used.

			Rand io.Reader
				Rand provides the source of entropy for cryptographic
				primitives. If Rand is nil, the cryptographic random reader
				in package crypto/rand will be used.

			RekeyThreshold uint64
				The maximum number of bytes sent or received after which a
				new key is negotiated. It must be at least 256. If
				unspecified, a size suitable for the chosen cipher is used.

		Methods (only one, which is exported)
			(*T) SetDefaults()
				SetDefaults sets sensible values for unset fields in config. This is
				exported for testing: Configs passed to SSH functions are copied and have
				default values set automatically.

		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newHandshakeTransport(conn keyingTransport, config *Config, clientVersion, serverVersion []byte) *handshakeTransport

	 type Conn (interface)
		Conn represents an SSH connection for both server and client roles.
		Conn is the basis for implementing an application layer, such
		as ClientConn, which implements the traditional shell access for
		clients.

		Methods (total 10, all are exported)
			( T) ClientVersion() []byte
				ClientVersion returns the client's version string as hashed
				into the session ID.

			( T) Close() error
				Close closes the underlying network connection

			( T) LocalAddr() net.Addr
				LocalAddr returns the local address for this connection.

			( T) OpenChannel(name string, data []byte) (Channel, <-chan *Request, error)
				OpenChannel tries to open an channel. If the request is
				rejected, it returns *OpenChannelError. On success it returns
				the SSH Channel and a Go channel for incoming, out-of-band
				requests. The Go channel must be serviced, or the
				connection will hang.

			( T) RemoteAddr() net.Addr
				RemoteAddr returns the remote address for this connection.

			( T) SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error)
				SendRequest sends a global request, and returns the
				reply. If wantReply is true, it returns the response status
				and payload. See also RFC4254, section 4.

			( T) ServerVersion() []byte
				ServerVersion returns the server's version string as hashed
				into the session ID.

			( T) SessionID() []byte
				SessionID returns the session hash, also denoted by H.

			( T) User() string
				User returns the user ID for this connection.

			( T) Wait() error
				Wait blocks until the connection has shut down, and returns the
				error causing the shutdown.

		Implemented By (at least 4, in which 2 are exported)
			 Client
			 ServerConn
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*connection
			 sshClientKeyboardInteractive
		Implements (at least 2, both are exported)
			 T : ConnMetadata
			 T : io.Closer
		As Outputs Of (at least one exported)
			func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan NewChannel, <-chan *Request, error)
		As Inputs Of (at least one exported)
			func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client

	 type ConnMetadata (interface)
		ConnMetadata holds metadata for the connection.

		Methods (total 6, all are exported)
			( T) ClientVersion() []byte
				ClientVersion returns the client's version string as hashed
				into the session ID.

			( T) LocalAddr() net.Addr
				LocalAddr returns the local address for this connection.

			( T) RemoteAddr() net.Addr
				RemoteAddr returns the remote address for this connection.

			( T) ServerVersion() []byte
				ServerVersion returns the server's version string as hashed
				into the session ID.

			( T) SessionID() []byte
				SessionID returns the session hash, also denoted by H.

			( T) User() string
				User returns the user ID for this connection.

		Implemented By (at least 6, in which 3 are exported)
			 Client
			 Conn (interface)
			 ServerConn
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*connection
			 sshClientKeyboardInteractive
			*sshConn
		As Inputs Of (at least one exported)
			func (*CertChecker).Authenticate(conn ConnMetadata, pubKey PublicKey) (*Permissions, error)

	 type CryptoPublicKey (interface)
		CryptoPublicKey, if implemented by a PublicKey,
		returns the underlying crypto.PublicKey form of the key.

		Methods (only one, which is exported)
			( T) CryptoPublicKey() crypto.PublicKey
		Implemented By (at least 4, none are exported)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			*dsaPublicKey
			*ecdsaPublicKey
			 ed25519PublicKey
			*rsaPublicKey

	 type ExitError (struct)
		An ExitError reports unsuccessful completion of a remote command.

		Fields (total 5, in which 1 are exported)
			Waitmsg Waitmsg
			/* 4 unexporteds ... *//* 4 unexporteds: */
			Waitmsg.lang string
			Waitmsg.msg string
			Waitmsg.signal string
			Waitmsg.status int
		Methods (total 6, all are exported)
			(*T) Error() string
			( T) ExitStatus() int
				ExitStatus returns the exit status of the remote command.

			( T) Lang() string
				Lang returns the language tag. See RFC 3066

			( T) Msg() string
				Msg returns the exit message given by the remote command

			( T) Signal() string
				Signal returns the exit signal of the remote command if
				it was terminated violently.

			( T) String() string
		Implements (at least 5, in which 3 are exported)
			*T : error
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer

	 type ExitMissingError (struct)
		ExitMissingError is returned if a session is torn down cleanly, but
		the server sends no confirmation of the exit status.

		Methods (only one, which is exported)
			(*T) Error() string
		Implements (at least one exported)
			*T : error

	 type GSSAPIClient (interface)
		GSSAPIClient provides the API to plug-in GSSAPI authentication for client logins.

		Methods (total 3, all are exported)
			( T) DeleteSecContext() error
				Whenever possible, it should be possible for
				DeleteSecContext() calls to be successfully processed even
				if other calls cannot succeed, thereby enabling context-related
				resources to be released.
				In addition to deleting established security contexts,
				gss_delete_sec_context must also be able to delete "half-built"
				security contexts resulting from an incomplete sequence of
				InitSecContext()/AcceptSecContext() calls.
				See RFC 2743 section 2.2.3.

			( T) GetMIC(micFiled []byte) ([]byte, error)
				GetMIC generates a cryptographic MIC for the SSH2 message, and places
				the MIC in a token for transfer to the ssh server.
				The contents of the MIC field are obtained by calling GSS_GetMIC()
				over the following, using the GSS-API context that was just
				established:
				 string    session identifier
				 byte      SSH_MSG_USERAUTH_REQUEST
				 string    user name
				 string    service
				 string    "gssapi-with-mic"
				See RFC 2743 section 2.3.1 and RFC 4462 3.5.

			( T) InitSecContext(target string, token []byte, isGSSDelegCreds bool) (outputToken []byte, needContinue bool, err error)
				InitSecContext initiates the establishment of a security context for GSS-API between the
				ssh client and ssh server. Initially the token parameter should be specified as nil.
				The routine may return a outputToken which should be transferred to
				the ssh server, where the ssh server will present it to
				AcceptSecContext. If no token need be sent, InitSecContext will indicate this by setting
				needContinue to false. To complete the context
				establishment, one or more reply tokens may be required from the ssh
				server;if so, InitSecContext will return a needContinue which is true.
				In this case, InitSecContext should be called again when the
				reply token is received from the ssh server, passing the reply
				token to InitSecContext via the token parameters.
				See RFC 2743 section 2.2.1 and RFC 4462 section 3.4.

		As Inputs Of (at least one exported)
			func GSSAPIWithMICAuthMethod(gssAPIClient GSSAPIClient, target string) AuthMethod

	 type GSSAPIServer (interface)
		GSSAPIServer provides the API to plug in GSSAPI authentication for server logins.

		Methods (total 3, all are exported)
			( T) AcceptSecContext(token []byte) (outputToken []byte, srcName string, needContinue bool, err error)
				AcceptSecContext allows a remotely initiated security context between the application
				and a remote peer to be established by the ssh client. The routine may return a
				outputToken which should be transferred to the ssh client,
				where the ssh client will present it to InitSecContext.
				If no token need be sent, AcceptSecContext will indicate this
				by setting the needContinue to false. To
				complete the context establishment, one or more reply tokens may be
				required from the ssh client. if so, AcceptSecContext
				will return a needContinue which is true, in which case it
				should be called again when the reply token is received from the ssh
				client, passing the token to AcceptSecContext via the
				token parameters.
				The srcName return value is the authenticated username.
				See RFC 2743 section 2.2.2 and RFC 4462 section 3.4.

			( T) DeleteSecContext() error
				Whenever possible, it should be possible for
				DeleteSecContext() calls to be successfully processed even
				if other calls cannot succeed, thereby enabling context-related
				resources to be released.
				In addition to deleting established security contexts,
				gss_delete_sec_context must also be able to delete "half-built"
				security contexts resulting from an incomplete sequence of
				InitSecContext()/AcceptSecContext() calls.
				See RFC 2743 section 2.2.3.

			( T) VerifyMIC(micField []byte, micToken []byte) error
				VerifyMIC verifies that a cryptographic MIC, contained in the token parameter,
				fits the supplied message is received from the ssh client.
				See RFC 2743 section 2.3.2.


	 type GSSAPIWithMICConfig (struct)

		Fields (total 2, both are exported)
			AllowLogin func(conn ConnMetadata, srcName string) (*Permissions, error)
				AllowLogin, must be set, is called when gssapi-with-mic
				authentication is selected (RFC 4462 section 3). The srcName is from the
				results of the GSS-API authentication. The format is username@DOMAIN.
				GSSAPI just guarantees to the server who the user is, but not if they can log in, and with what permissions.
				This callback is called after the user identity is established with GSSAPI to decide if the user can login with
				which permissions. If the user is allowed to login, it should return a nil error.

			Server GSSAPIServer
				Server must be set. It's the implementation
				of the GSSAPIServer interface. See GSSAPIServer interface for details.

		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func gssExchangeToken(gssapiConfig *GSSAPIWithMICConfig, firstToken []byte, s *connection, sessionID []byte, userAuthReq userAuthRequestMsg) (authErr error, perms *Permissions, err error)

	 type HostKeyCallback (func)
		HostKeyCallback is the function type used for verifying server
		keys.  A HostKeyCallback must return nil if the host key is OK, or
		an error to reject it. It receives the hostname as passed to Dial
		or NewClientConn. The remote address is the RemoteAddr of the
		net.Conn underlying the SSH connection.

		As Outputs Of (at least 4, all are exported)
			func FixedHostKey(key PublicKey) HostKeyCallback
			func InsecureIgnoreHostKey() HostKeyCallback
			func golang.org/x/crypto/ssh/knownhosts.New(files ...string) (HostKeyCallback, error)
			func github.com/go-git/go-git/v5/plumbing/transport/ssh.NewKnownHostsCallback(files ...string) (HostKeyCallback, error)

	 type KeyboardInteractiveChallenge (func)
		KeyboardInteractiveChallenge should print questions, optionally
		disabling echoing (e.g. for passwords), and return all the answers.
		Challenge may be called multiple times in a single session. After
		successful authentication, the server may send a challenge with no
		questions, for which the user and instruction messages should be
		printed.  RFC 4256 section 3.3 details how the UI should behave for
		both CLI and GUI environments.

		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			( T) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error)
			( T) method() string
		Implements (at least one exported)
			 T : AuthMethod
		As Inputs Of (at least one exported)
			func KeyboardInteractive(challenge KeyboardInteractiveChallenge) AuthMethod

	 type NewChannel (interface)
		NewChannel represents an incoming request to a channel. It must either be
		accepted for use by calling Accept, or rejected by calling Reject.

		Methods (total 4, all are exported)
			( T) Accept() (Channel, <-chan *Request, error)
				Accept accepts the channel creation request. It returns the Channel
				and a Go channel containing SSH requests. The Go channel must be
				serviced otherwise the Channel will hang.

			( T) ChannelType() string
				ChannelType returns the type of the channel, as supplied by the
				client.

			( T) ExtraData() []byte
				ExtraData returns the arbitrary payload for this channel, as supplied
				by the client. This data is specific to the channel type.

			( T) Reject(reason RejectionReason, message string) error
				Reject rejects the channel creation request. After calling
				this, no other methods on the Channel may be called.

		Implemented By (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*channel
		As Outputs Of (at least 3, all are exported)
			func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan NewChannel, <-chan *Request, error)
			func NewServerConn(c net.Conn, config *ServerConfig) (*ServerConn, <-chan NewChannel, <-chan *Request, error)
			func (*Client).HandleChannelOpen(channelType string) <-chan NewChannel
		As Inputs Of (at least 2, in which 1 are exported)
			func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client
			/* at least one unexported ... *//* at least one unexported: */
			func (*Client).handleChannelOpens(in <-chan NewChannel)

	 type OpenChannelError (struct)
		OpenChannelError is returned if the other side rejects an
		OpenChannel request.

		Fields (total 2, both are exported)
			Message string
			Reason RejectionReason
		Methods (only one, which is exported)
			(*T) Error() string
		Implements (at least one exported)
			*T : error

	 type PassphraseMissingError (struct)
		A PassphraseMissingError indicates that parsing this private key requires a
		passphrase. Use ParsePrivateKeyWithPassphrase.

		Fields (only one, which is exported)
			PublicKey PublicKey
				PublicKey will be set if the private key format includes an unencrypted
				public key along with the encrypted private key.

		Methods (only one, which is exported)
			(*T) Error() string
		Implements (at least one exported)
			*T : error

	 type Permissions (struct)
		The Permissions type holds fine-grained permissions that are
		specific to a user or a specific authentication method for a user.
		The Permissions value for a successful authentication attempt is
		available in ServerConn, so it can be used to pass information from
		the user-authentication phase to the application layer.

		Fields (total 2, both are exported)
			CriticalOptions map[string]string
				CriticalOptions indicate restrictions to the default
				permissions, and are typically used in conjunction with
				user certificates. The standard for SSH certificates
				defines "force-command" (only allow the given command to
				execute) and "source-address" (only allow connections from
				the given address). The SSH package currently only enforces
				the "source-address" critical option. It is up to server
				implementations to enforce other critical options, such as
				"force-command", by checking them after the SSH handshake
				is successful. In general, SSH servers should reject
				connections that specify critical options that are unknown
				or not supported.

			Extensions map[string]string
				Extensions are extra functionality that the server may
				offer on authenticated connections. Lack of support for an
				extension does not preclude authenticating a user. Common
				extensions are "permit-agent-forwarding",
				"permit-X11-forwarding". The Go SSH library currently does
				not act on any extension, and it is up to server
				implementations to honor them. Extensions can be used to
				pass data from the authentication callbacks to the server
				application layer.

		As Outputs Of (at least 2, in which 1 are exported)
			func (*CertChecker).Authenticate(conn ConnMetadata, pubKey PublicKey) (*Permissions, error)
			/* at least one unexported ... *//* at least one unexported: */
			func gssExchangeToken(gssapiConfig *GSSAPIWithMICConfig, firstToken []byte, s *connection, sessionID []byte, userAuthReq userAuthRequestMsg) (authErr error, perms *Permissions, err error)

	 type PublicKey (interface)
		PublicKey is an abstraction of different types of public keys.

		Methods (total 3, all are exported)
			( T) Marshal() []byte
				Marshal returns the serialized key data in SSH wire format,
				with the name prefix. To unmarshal the returned data, use
				the ParsePublicKey function.

			( T) Type() string
				Type returns the key's type, e.g. "ssh-rsa".

			( T) Verify(data []byte, sig *Signature) error
				Verify that sig is a signature on the given data using this
				key. This function will hash the data appropriately first.

		Implemented By (at least 8, in which 2 are exported)
			*Certificate
			*golang.org/x/crypto/ssh/agent.Key
			/* 6+ unexporteds ... *//* 6+ unexporteds: */
			*dsaPublicKey
			*ecdsaPublicKey
			 ed25519PublicKey
			*rsaPublicKey
			*skECDSAPublicKey
			*skEd25519PublicKey
		As Outputs Of (at least 15, in which 6 are exported)
			func NewPublicKey(key interface{}) (PublicKey, error)
			func ParseAuthorizedKey(in []byte) (out PublicKey, comment string, options []string, rest []byte, err error)
			func ParseKnownHosts(in []byte) (marker string, hosts []string, pubKey PublicKey, comment string, rest []byte, err error)
			func ParsePublicKey(in []byte) (out PublicKey, err error)
			func AlgorithmSigner.PublicKey() PublicKey
			func Signer.PublicKey() PublicKey
			/* 9+ unexporteds ... *//* 9+ unexporteds: */
			func parseAuthorizedKey(in []byte) (out PublicKey, comment string, err error)
			func parseDSA(in []byte) (out PublicKey, rest []byte, err error)
			func parseECDSA(in []byte) (out PublicKey, rest []byte, err error)
			func parseED25519(in []byte) (out PublicKey, rest []byte, err error)
			func parsePubKey(in []byte, algo string) (pubKey PublicKey, rest []byte, err error)
			func parseRSA(in []byte) (out PublicKey, rest []byte, err error)
			func parseSKECDSA(in []byte) (out PublicKey, rest []byte, err error)
			func parseSKEd25519(in []byte) (out PublicKey, rest []byte, err error)
			func golang.org/x/crypto/ssh/knownhosts.parseLine(line []byte) (marker, host string, key PublicKey, err error)
		As Inputs Of (at least 17, in which 12 are exported)
			func FingerprintLegacyMD5(pubKey PublicKey) string
			func FingerprintSHA256(pubKey PublicKey) string
			func FixedHostKey(key PublicKey) HostKeyCallback
			func MarshalAuthorizedKey(key PublicKey) []byte
			func (*CertChecker).Authenticate(conn ConnMetadata, pubKey PublicKey) (*Permissions, error)
			func (*CertChecker).CheckHostKey(addr string, remote net.Addr, key PublicKey) error
			func golang.org/x/crypto/ssh/agent.Agent.Remove(key PublicKey) error
			func golang.org/x/crypto/ssh/agent.Agent.Sign(key PublicKey, data []byte) (*Signature, error)
			func golang.org/x/crypto/ssh/agent.ExtendedAgent.Remove(key PublicKey) error
			func golang.org/x/crypto/ssh/agent.ExtendedAgent.Sign(key PublicKey, data []byte) (*Signature, error)
			func golang.org/x/crypto/ssh/agent.ExtendedAgent.SignWithFlags(key PublicKey, data []byte, flags agent.SignatureFlags) (*Signature, error)
			func golang.org/x/crypto/ssh/knownhosts.Line(addresses []string, key PublicKey) string
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			func confirmKeyAck(key PublicKey, c packetConn) (bool, error)
			func validateKey(key PublicKey, user string, c packetConn) (bool, error)
			func verifyHostKeySignature(hostKey PublicKey, result *kexResult) error
			func golang.org/x/crypto/ssh/knownhosts.keyEq(a, b PublicKey) bool
			func golang.org/x/crypto/ssh/knownhosts.serialize(k PublicKey) string

	 type RejectionReason uint32 (basic type)
		RejectionReason is an enumeration used when rejecting channel creation
		requests. See RFC 4254, section 5.1.

		Methods (only one, which is exported)
			( T) String() string
				String converts the rejection reason to human readable form.

		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Inputs Of (at least one exported)
			func NewChannel.Reject(reason RejectionReason, message string) error
		As Types Of (total 4, all are exported)
			const ConnectionFailed
			const Prohibited
			const ResourceShortage
			const UnknownChannelType

	 type Request (struct)
		Request is a request sent outside of the normal stream of
		data. Requests can either be specific to an SSH channel, or they
		can be global.

		Fields (total 5, in which 3 are exported)
			Payload []byte
			Type string
			WantReply bool
			/* 2 unexporteds ... *//* 2 unexporteds: */
			ch *channel
			mux *mux
		Methods (only one, which is exported)
			(*T) Reply(ok bool, payload []byte) error
				Reply sends a response to a request. It must be called for all requests
				where WantReply is true and is a no-op otherwise. The payload argument is
				ignored for replies to channel-specific requests.

		As Outputs Of (at least 4, all are exported)
			func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan NewChannel, <-chan *Request, error)
			func NewServerConn(c net.Conn, config *ServerConfig) (*ServerConn, <-chan NewChannel, <-chan *Request, error)
			func Conn.OpenChannel(name string, data []byte) (Channel, <-chan *Request, error)
			func NewChannel.Accept() (Channel, <-chan *Request, error)
		As Inputs Of (at least 5, in which 2 are exported)
			func DiscardRequests(in <-chan *Request)
			func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func newSession(ch Channel, reqs <-chan *Request) (*Session, error)
			func (*Client).handleGlobalRequests(incoming <-chan *Request)
			func (*Session).wait(reqs <-chan *Request) error

	 type ServerAuthError (struct)
		ServerAuthError represents server authentication errors and is
		sometimes returned by NewServerConn. It appends any authentication
		errors that may occur, and is returned if all of the authentication
		methods provided by the user failed to authenticate.

		Fields (only one, which is exported)
			Errors []error
				Errors contains authentication errors returned by the authentication
				callback methods. The first entry is typically ErrNoAuth.

		Methods (only one, which is exported)
			( T) Error() string
		Implements (at least one exported)
			 T : error

	 type ServerConfig (struct)
		ServerConfig holds server specific configuration data.

		Fields (total 16, in which 15 are exported)
			AuthLogCallback func(conn ConnMetadata, method string, err error)
				AuthLogCallback, if non-nil, is called to log all authentication
				attempts.

			BannerCallback func(conn ConnMetadata) string
				BannerCallback, if present, is called and the return string is sent to
				the client after key exchange completed but before authentication.

			Config Config
				Config contains configuration shared between client and server.

			Config.Ciphers []string
				The allowed cipher algorithms. If unspecified then a sensible
				default is used.

			Config.KeyExchanges []string
				The allowed key exchanges algorithms. If unspecified then a
				default set of algorithms is used.

			Config.MACs []string
				The allowed MAC algorithms. If unspecified then a sensible default
				is used.

			Config.Rand io.Reader
				Rand provides the source of entropy for cryptographic
				primitives. If Rand is nil, the cryptographic random reader
				in package crypto/rand will be used.

			Config.RekeyThreshold uint64
				The maximum number of bytes sent or received after which a
				new key is negotiated. It must be at least 256. If
				unspecified, a size suitable for the chosen cipher is used.

			GSSAPIWithMICConfig *GSSAPIWithMICConfig
				GSSAPIWithMICConfig includes gssapi server and callback, which if both non-nil, is used
				when gssapi-with-mic authentication is selected (RFC 4462 section 3).

			KeyboardInteractiveCallback func(conn ConnMetadata, client KeyboardInteractiveChallenge) (*Permissions, error)
				KeyboardInteractiveCallback, if non-nil, is called when
				keyboard-interactive authentication is selected (RFC
				4256). The client object's Challenge function should be
				used to query the user. The callback may offer multiple
				Challenge rounds. To avoid information leaks, the client
				should be presented a challenge even if the user is
				unknown.

			MaxAuthTries int
				MaxAuthTries specifies the maximum number of authentication attempts
				permitted per connection. If set to a negative number, the number of
				attempts are unlimited. If set to zero, the number of attempts are limited
				to 6.

			NoClientAuth bool
				NoClientAuth is true if clients are allowed to connect without
				authenticating.

			PasswordCallback func(conn ConnMetadata, password []byte) (*Permissions, error)
				PasswordCallback, if non-nil, is called when a user
				attempts to authenticate using a password.

			PublicKeyCallback func(conn ConnMetadata, key PublicKey) (*Permissions, error)
				PublicKeyCallback, if non-nil, is called when a client
				offers a public key for authentication. It must return a nil error
				if the given public key can be used to authenticate the
				given user. For example, see CertChecker.Authenticate. A
				call to this function does not guarantee that the key
				offered is in fact used to authenticate. To record any data
				depending on the public key, store it inside a
				Permissions.Extensions entry.

			ServerVersion string
				ServerVersion is the version identification string to announce in
				the public handshake.
				If empty, a reasonable default is used.
				Note that RFC 4253 section 4.2 requires that this string start with
				"SSH-2.0-".

			/* one unexported ... *//* one unexported: */
			hostKeys []Signer
		Methods (total 2, both are exported)
			(*T) AddHostKey(key Signer)
				AddHostKey adds a private key as a host key. If an existing host
				key exists with the same algorithm, it is overwritten. Each server
				config must have at least one host key.

			(*T) SetDefaults()
				SetDefaults sets sensible values for unset fields in config. This is
				exported for testing: Configs passed to SSH functions are copied and have
				default values set automatically.

		As Inputs Of (at least 2, in which 1 are exported)
			func NewServerConn(c net.Conn, config *ServerConfig) (*ServerConn, <-chan NewChannel, <-chan *Request, error)
			/* at least one unexported ... *//* at least one unexported: */
			func newServerTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ServerConfig) *handshakeTransport

	 type ServerConn (struct)
		ServerConn is an authenticated SSH connection, as seen from the
		server

		Fields (total 2, both are exported)
			Conn Conn
			Permissions *Permissions
				If the succeeding authentication callback returned a
				non-nil Permissions pointer, it is stored here.

		Methods (total 10, all are exported)
			( T) ClientVersion() []byte
				ClientVersion returns the client's version string as hashed
				into the session ID.

			( T) Close() error
				Close closes the underlying network connection

			( T) LocalAddr() net.Addr
				LocalAddr returns the local address for this connection.

			( T) OpenChannel(name string, data []byte) (Channel, <-chan *Request, error)
				OpenChannel tries to open an channel. If the request is
				rejected, it returns *OpenChannelError. On success it returns
				the SSH Channel and a Go channel for incoming, out-of-band
				requests. The Go channel must be serviced, or the
				connection will hang.

			( T) RemoteAddr() net.Addr
				RemoteAddr returns the remote address for this connection.

			( T) SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error)
				SendRequest sends a global request, and returns the
				reply. If wantReply is true, it returns the response status
				and payload. See also RFC4254, section 4.

			( T) ServerVersion() []byte
				ServerVersion returns the server's version string as hashed
				into the session ID.

			( T) SessionID() []byte
				SessionID returns the session hash, also denoted by H.

			( T) User() string
				User returns the user ID for this connection.

			( T) Wait() error
				Wait blocks until the connection has shut down, and returns the
				error causing the shutdown.

		Implements (at least 3, all are exported)
			 T : Conn
			 T : ConnMetadata
			 T : io.Closer
		As Outputs Of (at least one exported)
			func NewServerConn(c net.Conn, config *ServerConfig) (*ServerConn, <-chan NewChannel, <-chan *Request, error)

	 type Session (struct)
		A Session represents a connection to a remote command or shell.

		Fields (total 12, in which 3 are exported)
			Stderr io.Writer
			Stdin io.Reader
				Stdin specifies the remote process's standard input.
				If Stdin is nil, the remote process reads from an empty
				bytes.Buffer.

			Stdout io.Writer
				Stdout and Stderr specify the remote process's standard
				output and error.

				If either is nil, Run connects the corresponding file
				descriptor to an instance of ioutil.Discard. There is a
				fixed amount of buffering that is shared for the two streams.
				If either blocks it may eventually cause the remote
				command to block.

			/* 9 unexporteds ... *//* 9 unexporteds: */
			ch Channel
				// the channel backing this session

			copyFuncs []func() error
			errors chan error
				// one send per copyFunc

			exitStatus chan error
			started bool
				// true once Start, Run or Shell is invoked.

			stderrpipe bool
				true if pipe method is active

			stdinPipeWriter io.WriteCloser
				stdinPipeWriter is non-nil if StdinPipe has not been called
				and Stdin was specified by the user; it is the write end of
				a pipe connecting Session.Stdin to the stdin channel.

			stdinpipe bool
				true if pipe method is active

			stdoutpipe bool
				true if pipe method is active

		Methods (total 21, in which 16 are exported)
			(*T) Close() error
			(*T) CombinedOutput(cmd string) ([]byte, error)
				CombinedOutput runs cmd on the remote host and returns its combined
				standard output and standard error.

			(*T) Output(cmd string) ([]byte, error)
				Output runs cmd on the remote host and returns its standard output.

			(*T) RequestPty(term string, h, w int, termmodes TerminalModes) error
				RequestPty requests the association of a pty with the session on the remote host.

			(*T) RequestSubsystem(subsystem string) error
				RequestSubsystem requests the association of a subsystem with the session on the remote host.
				A subsystem is a predefined command that runs in the background when the ssh session is initiated

			(*T) Run(cmd string) error
				Run runs cmd on the remote host. Typically, the remote
				server passes cmd to the shell for interpretation.
				A Session only accepts one call to Run, Start, Shell, Output,
				or CombinedOutput.

				The returned error is nil if the command runs, has no problems
				copying stdin, stdout, and stderr, and exits with a zero exit
				status.

				If the remote server does not send an exit status, an error of type
				*ExitMissingError is returned. If the command completes
				unsuccessfully or is interrupted by a signal, the error is of type
				*ExitError. Other error types may be returned for I/O problems.

			(*T) SendRequest(name string, wantReply bool, payload []byte) (bool, error)
				SendRequest sends an out-of-band channel request on the SSH channel
				underlying the session.

			(*T) Setenv(name, value string) error
				Setenv sets an environment variable that will be applied to any
				command executed by Shell or Run.

			(*T) Shell() error
				Shell starts a login shell on the remote host. A Session only
				accepts one call to Run, Start, Shell, Output, or CombinedOutput.

			(*T) Signal(sig Signal) error
				Signal sends the given signal to the remote process.
				sig is one of the SIG* constants.

			(*T) Start(cmd string) error
				Start runs cmd on the remote host. Typically, the remote
				server passes cmd to the shell for interpretation.
				A Session only accepts one call to Run, Start or Shell.

			(*T) StderrPipe() (io.Reader, error)
				StderrPipe returns a pipe that will be connected to the
				remote command's standard error when the command starts.
				There is a fixed amount of buffering that is shared between
				stdout and stderr streams. If the StderrPipe reader is
				not serviced fast enough it may eventually cause the
				remote command to block.

			(*T) StdinPipe() (io.WriteCloser, error)
				StdinPipe returns a pipe that will be connected to the
				remote command's standard input when the command starts.

			(*T) StdoutPipe() (io.Reader, error)
				StdoutPipe returns a pipe that will be connected to the
				remote command's standard output when the command starts.
				There is a fixed amount of buffering that is shared between
				stdout and stderr streams. If the StdoutPipe reader is
				not serviced fast enough it may eventually cause the
				remote command to block.

			(*T) Wait() error
				Wait waits for the remote command to exit.

				The returned error is nil if the command runs, has no problems
				copying stdin, stdout, and stderr, and exits with a zero exit
				status.

				If the remote server does not send an exit status, an error of type
				*ExitMissingError is returned. If the command completes
				unsuccessfully or is interrupted by a signal, the error is of type
				*ExitError. Other error types may be returned for I/O problems.

			(*T) WindowChange(h, w int) error
				WindowChange informs the remote host about a terminal window dimension change to h rows and w columns.

			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) start() error
			(*T) stderr()
			(*T) stdin()
			(*T) stdout()
			(*T) wait(reqs <-chan *Request) error
		Implements (at least one exported)
			*T : io.Closer
		As Outputs Of (at least 2, in which 1 are exported)
			func (*Client).NewSession() (*Session, error)
			/* at least one unexported ... *//* at least one unexported: */
			func newSession(ch Channel, reqs <-chan *Request) (*Session, error)
		As Inputs Of (at least one exported)
			func golang.org/x/crypto/ssh/agent.RequestAgentForwarding(session *Session) error

	 type Signal string (basic type)

		As Inputs Of (at least one exported)
			func (*Session).Signal(sig Signal) error
		As Types Of (total 13, all are exported)
			const SIGABRT
			const SIGALRM
			const SIGFPE
			const SIGHUP
			const SIGILL
			const SIGINT
			const SIGKILL
			const SIGPIPE
			const SIGQUIT
			const SIGSEGV
			const SIGTERM
			const SIGUSR1
			const SIGUSR2

	 type Signature (struct)
		Signature represents a cryptographic signature.

		Fields (total 3, all are exported)
			Blob []byte
			Format string
			Rest []byte
		As Outputs Of (at least 8, in which 6 are exported)
			func AlgorithmSigner.Sign(rand io.Reader, data []byte) (*Signature, error)
			func AlgorithmSigner.SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*Signature, error)
			func Signer.Sign(rand io.Reader, data []byte) (*Signature, error)
			func golang.org/x/crypto/ssh/agent.Agent.Sign(key PublicKey, data []byte) (*Signature, error)
			func golang.org/x/crypto/ssh/agent.ExtendedAgent.Sign(key PublicKey, data []byte) (*Signature, error)
			func golang.org/x/crypto/ssh/agent.ExtendedAgent.SignWithFlags(key PublicKey, data []byte, flags agent.SignatureFlags) (*Signature, error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func parseSignature(in []byte) (out *Signature, rest []byte, ok bool)
			func parseSignatureBody(in []byte) (out *Signature, rest []byte, ok bool)
		As Inputs Of (at least 3, all are exported)
			func (*Certificate).Verify(data []byte, sig *Signature) error
			func PublicKey.Verify(data []byte, sig *Signature) error
			func golang.org/x/crypto/ssh/agent.(*Key).Verify(data []byte, sig *Signature) error

	 type Signer (interface)
		A Signer can create signatures that verify against a public key.

		Methods (total 2, both are exported)
			( T) PublicKey() PublicKey
				PublicKey returns an associated PublicKey instance.

			( T) Sign(rand io.Reader, data []byte) (*Signature, error)
				Sign returns raw signature for the given data. This method
				will apply the hash specified for the keytype to the data.

		Implemented By (at least 6, in which 1 are exported)
			 AlgorithmSigner (interface)
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			 algorithmOpenSSHCertSigner
			*dsaPrivateKey
			*openSSHCertSigner
			*wrappedSigner
			*golang.org/x/crypto/ssh/agent.agentKeyringSigner
		As Outputs Of (at least 8, in which 7 are exported)
			func NewCertSigner(cert *Certificate, signer Signer) (Signer, error)
			func NewSignerFromKey(key interface{}) (Signer, error)
			func NewSignerFromSigner(signer crypto.Signer) (Signer, error)
			func ParsePrivateKey(pemBytes []byte) (Signer, error)
			func ParsePrivateKeyWithPassphrase(pemBytes, passphrase []byte) (Signer, error)
			func golang.org/x/crypto/ssh/agent.Agent.Signers() ([]Signer, error)
			func golang.org/x/crypto/ssh/agent.ExtendedAgent.Signers() ([]Signer, error)
			/* at least one unexported ... *//* at least one unexported: */
			func newDSAPrivateKey(key *dsa.PrivateKey) (Signer, error)
		As Inputs Of (at least 5, in which 4 are exported)
			func NewCertSigner(cert *Certificate, signer Signer) (Signer, error)
			func PublicKeys(signers ...Signer) AuthMethod
			func (*Certificate).SignCert(rand io.Reader, authority Signer) error
			func (*ServerConfig).AddHostKey(key Signer)
			/* at least one unexported ... *//* at least one unexported: */
			func signAndMarshal(k Signer, rand io.Reader, data []byte) ([]byte, error)

	 type TerminalModes (map)

		As Inputs Of (at least one exported)
			func (*Session).RequestPty(term string, h, w int, termmodes TerminalModes) error

	 type Waitmsg (struct)
		Waitmsg stores the information about an exited remote command
		as reported by Wait.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			lang string
			msg string
			signal string
			status int
		Methods (total 5, all are exported)
			( T) ExitStatus() int
				ExitStatus returns the exit status of the remote command.

			( T) Lang() string
				Lang returns the language tag. See RFC 3066

			( T) Msg() string
				Msg returns the exit message given by the remote command

			( T) Signal() string
				Signal returns the exit signal of the remote command if
				it was terminated violently.

			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : expvar.Var
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer

	/* 121 unexporteds ... *//* 121 unexporteds: */
	 type algorithmOpenSSHCertSigner (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			algorithmSigner AlgorithmSigner
			openSSHCertSigner *openSSHCertSigner
			openSSHCertSigner.pub *Certificate
			openSSHCertSigner.signer Signer
		Methods (total 3, all are exported)
			( T) PublicKey() PublicKey
			( T) Sign(rand io.Reader, data []byte) (*Signature, error)
			(*T) SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*Signature, error)
		Implements (at least 2, both are exported)
			*T : AlgorithmSigner
			 T : Signer

	 type algorithms (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			hostKey string
			kex string
			r directionAlgorithms
			w directionAlgorithms
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func findAgreedAlgorithms(isClient bool, clientKexInit, serverKexInit *kexInitMsg) (algs *algorithms, err error)

	 type authResult int (basic type)

		As Outputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func handleAuthResponse(c packetConn) (authResult, []string, error)
			func KeyboardInteractiveChallenge.auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error)
		As Types Of (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			const authFailure
			const authPartialSuccess
			const authSuccess

	 type buffer (struct)
		buffer provides a linked list buffer for data exchange
		between producer and consumer. Theoretically the buffer is
		of unlimited capacity as it does no allocation of its own.

		Fields (total 8, in which 2 are exported)
			Cond *sync.Cond
				protects concurrent access to head, tail and closed

			Cond.L sync.Locker
				L is held while observing or changing the condition

			/* 6 unexporteds ... *//* 6 unexporteds: */
			closed bool
			Cond.checker sync.copyChecker
			Cond.noCopy sync.noCopy
			Cond.notify sync.notifyList
			head *element
				// the buffer that will be read first

			tail *element
				// the buffer that will be read last

		Methods (total 6, in which 4 are exported)
			( T) Broadcast()
				Broadcast wakes all goroutines waiting on c.

				It is allowed but not required for the caller to hold c.L
				during the call.

			(*T) Read(buf []byte) (n int, err error)
				Read reads data from the internal buffer in buf.  Reads will block
				if no data is available, or until the buffer is closed.

			( T) Signal()
				Signal wakes one goroutine waiting on c, if there is any.

				It is allowed but not required for the caller to hold c.L
				during the call.

			( T) Wait()
				Wait atomically unlocks c.L and suspends execution
				of the calling goroutine. After later resuming execution,
				Wait locks c.L before returning. Unlike in other systems,
				Wait cannot return unless awoken by Broadcast or Signal.

				Because c.L is not locked when Wait first resumes, the caller
				typically cannot assume that the condition is true when
				Wait returns. Instead, the caller should Wait in a loop:

				   c.L.Lock()
				   for !condition() {
				       c.Wait()
				   }
				   ... make use of condition ...
				   c.L.Unlock()

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) eof()
				eof closes the buffer. Reads from the buffer once all
				the data has been consumed will receive io.EOF.

			(*T) write(buf []byte)
				write makes buf available for Read to receive.
				buf must not be modified after the call to write.

		Implements (at least 2, both are exported)
			*T : github.com/jbenet/go-context/io.Reader
			*T : io.Reader
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newBuffer() *buffer

	 type cachedPubKey (struct)
		cachedPubKey contains the results of querying whether a public key is
		acceptable for a user.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			perms *Permissions
			pubKeyData []byte
			result error
			user string

	 type cbcCipher (struct)
		cbcCipher implements aes128-cbc cipher defined in RFC 4253 section 6.1

		Fields (total 8, none are exported)
			/* 8 unexporteds ... *//* 8 unexporteds: */
			decrypter cipher.BlockMode
			encrypter cipher.BlockMode
			mac hash.Hash
			macResult []byte
			macSize uint32
			oracleCamouflage uint32
				Amount of data we should still read to hide which
				verification error triggered.

			packetData []byte
			seqNumBytes [4]byte
				The following members are to avoid per-packet allocations.

		Methods (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error)
			(*T) readCipherPacketLeaky(seqNum uint32, r io.Reader) ([]byte, error)
			(*T) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : packetCipher

	 type cbcError string (basic type)
		cbcError represents a verification error that may leak information.

		Methods (only one, which is exported)
			( T) Error() string
		Implements (at least one exported)
			 T : error

	 type chacha20Poly1305Cipher (struct)
		chacha20Poly1305Cipher implements the chacha20-poly1305@openssh.com
		AEAD, which is described here:

		  https://tools.ietf.org/html/draft-josefsson-ssh-chacha20-poly1305-openssh-00

		the methods here also implement padding, which RFC4253 Section 6
		also requires of stream ciphers.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			buf []byte
			contentKey [32]byte
			lengthKey [32]byte
		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error)
			(*T) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, payload []byte) error
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : packetCipher

	 type chanConn (struct)
		chanConn fulfills the net.Conn interface without
		the tcpChan having to hold laddr or raddr directly.

		Fields (total 3, in which 1 are exported)
			Channel Channel
			/* 2 unexporteds ... *//* 2 unexporteds: */
			laddr net.Addr
			raddr net.Addr
		Methods (total 11, all are exported)
			( T) Close() error
				Close signals end of channel use. No data may be sent after this
				call.

			( T) CloseWrite() error
				CloseWrite signals the end of sending in-band
				data. Requests may still be sent, and the other side may
				still send data

			(*T) LocalAddr() net.Addr
				LocalAddr returns the local network address.

			( T) Read(data []byte) (int, error)
				Read reads up to len(data) bytes from the channel.

			(*T) RemoteAddr() net.Addr
				RemoteAddr returns the remote network address.

			( T) SendRequest(name string, wantReply bool, payload []byte) (bool, error)
				SendRequest sends a channel request.  If wantReply is true,
				it will wait for a reply and return the result as a
				boolean, otherwise the return value will be false. Channel
				requests are out-of-band messages so they may be sent even
				if the data stream is closed or blocked by flow control.
				If the channel is closed before a reply is returned, io.EOF
				is returned.

			(*T) SetDeadline(deadline time.Time) error
				SetDeadline sets the read and write deadlines associated
				with the connection.

			(*T) SetReadDeadline(deadline time.Time) error
				SetReadDeadline sets the read deadline.
				A zero value for t means Read will not time out.
				After the deadline, the error from Read will implement net.Error
				with Timeout() == true.

			(*T) SetWriteDeadline(deadline time.Time) error
				SetWriteDeadline exists to satisfy the net.Conn interface
				but is not implemented by this type.  It always returns an error.

			( T) Stderr() io.ReadWriter
				Stderr returns an io.ReadWriter that writes to this channel
				with the extended data type set to stderr. Stderr may
				safely be read and written from a different goroutine than
				Read and Write respectively.

			( T) Write(data []byte) (int, error)
				Write writes len(data) bytes to the channel.

		Implements (at least 13, in which 12 are exported)
			 T : Channel
			 T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			 T : github.com/jbenet/go-context/io.Reader
			 T : github.com/jbenet/go-context/io.Writer
			 T : io.Closer
			 T : io.ReadCloser
			 T : io.Reader
			 T : io.ReadWriteCloser
			 T : io.ReadWriter
			 T : io.WriteCloser
			 T : io.Writer
			*T : net.Conn
			/* at least one unexported ... *//* at least one unexported: */
			 T : net/http.closeWriter

	 type chanList (struct)
		chanList is a thread safe channel list.

		Fields (total 5, in which 1 are exported)
			Mutex sync.Mutex
				protects concurrent access to chans

			/* 4 unexporteds ... *//* 4 unexporteds: */
			chans []*channel
				chans are indexed by the local id of the channel, which the
				other side should send in the PeersId field.

			Mutex.sema uint32
			Mutex.state int32
			offset uint32
				This is a debugging aid: it offsets all IDs by this
				amount. This helps distinguish otherwise identical
				server/client muxes

		Methods (total 8, in which 2 are exported)
			(*T) Lock()
				Lock locks m.
				If the lock is already in use, the calling goroutine
				blocks until the mutex is available.

			(*T) Unlock()
				Unlock unlocks m.
				It is a run-time error if m is not locked on entry to Unlock.

				A locked Mutex is not associated with a particular goroutine.
				It is allowed for one goroutine to lock a Mutex and then
				arrange for another goroutine to unlock it.

			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) add(ch *channel) uint32
				Assigns a channel ID to the given channel.

			(*T) dropAll() []*channel
				dropAll forgets all channels it knows, returning them in a slice.

			(*T) getChan(id uint32) *channel
				getChan returns the channel for the given ID.

			(*T) lockSlow()
			(*T) remove(id uint32)
			(*T) unlockSlow(new int32)
		Implements (at least one exported)
			*T : sync.Locker

	 type channel (struct)
		channel is an implementation of the Channel interface that works
		with the mux class.

		Fields (total 21, none are exported)
			/* 21 unexporteds ... *//* 21 unexporteds: */
			chanType string
				R/O after creation

			decided bool
				decided is set to true if an accept or reject message has been sent
				(for outbound channels) or received (for inbound channels).

			direction channelDirection
				direction contains either channelOutbound, for channels created
				locally, or channelInbound, for channels created by the peer.

			extPending *buffer
			extraData []byte
			incomingRequests chan *Request
			localId uint32
			maxIncomingPayload uint32
				maxIncomingPayload and maxRemotePayload are the maximum
				payload sizes of normal and extended data packets for
				receiving and sending, respectively. The wire packet will
				be 9 or 13 bytes larger (excluding encryption overhead).

			maxRemotePayload uint32
			msg chan interface{}
				Pending internal channel messages.

			mux *mux
			myWindow uint32
			packetPool map[uint32][]byte
				packetPool has a buffer for each extended channel ID to
				save allocations during writes.

			pending *buffer
			remoteId uint32
			remoteWin window
				thread-safe data

			sentClose bool
			sentEOF bool
			sentRequestMu sync.Mutex
				Since requests have no ID, there can be only one request
				with WantReply=true outstanding.  This lock is held by a
				goroutine that has such an outgoing request pending.

			windowMu sync.Mutex
				windowMu protects myWindow, the flow-control window.

			writeMu sync.Mutex
				writeMu serializes calls to mux.conn.writePacket() and
				protects sentClose and packetPool. This mutex must be
				different from windowMu, as writePacket can block if there
				is a key exchange pending.

		Methods (total 21, in which 13 are exported)
			(*T) Accept() (Channel, <-chan *Request, error)
			(*T) ChannelType() string
			(*T) Close() error
			(*T) CloseWrite() error
			(*T) Extended(code uint32) io.ReadWriter
				Extended returns an io.ReadWriter that sends and receives data on the given,
				SSH extended stream. Such streams are used, for example, for stderr.

			(*T) ExtraData() []byte
			(*T) Read(data []byte) (int, error)
			(*T) ReadExtended(data []byte, extended uint32) (n int, err error)
			(*T) Reject(reason RejectionReason, message string) error
			(*T) SendRequest(name string, wantReply bool, payload []byte) (bool, error)
			(*T) Stderr() io.ReadWriter
			(*T) Write(data []byte) (int, error)
			(*T) WriteExtended(data []byte, extendedCode uint32) (n int, err error)
				WriteExtended writes data to a specific extended stream. These streams are
				used, for example, for stderr.

			/* 8 unexporteds ... *//* 8 unexporteds: */
			(*T) ackRequest(ok bool) error
				ackRequest either sends an ack or nack to the channel request.

			(*T) adjustWindow(n uint32) error
			(*T) close()
			(*T) handleData(packet []byte) error
			(*T) handlePacket(packet []byte) error
			(*T) responseMessageReceived() error
				responseMessageReceived is called when a success or failure message is
				received on a channel to check that such a message is reasonable for the
				given channel.

			(*T) sendMessage(msg interface{}) error
			(*T) writePacket(packet []byte) error
				writePacket sends a packet. If the packet is a channel close, it updates
				sentClose. This method takes the lock c.writeMu.

		Implements (at least 13, in which 12 are exported)
			*T : Channel
			*T : NewChannel
			*T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			*T : github.com/jbenet/go-context/io.Reader
			*T : github.com/jbenet/go-context/io.Writer
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader
			*T : io.ReadWriteCloser
			*T : io.ReadWriter
			*T : io.WriteCloser
			*T : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			*T : net/http.closeWriter

	 type channelCloseMsg (struct)

		Fields (only one, which is exported)
			PeersID uint32

	 type channelDataMsg (struct)
		Used for debug print outs of packets.

		Fields (total 3, all are exported)
			Length uint32
			PeersID uint32
			Rest []byte

	 type channelDirection uint8 (basic type)

		As Types Of (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			const channelInbound
			const channelOutbound

	 type channelEOFMsg (struct)

		Fields (only one, which is exported)
			PeersID uint32

	 type channelForwardMsg (struct)
		RFC 4254 7.1

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			addr string
			rport uint32

	 type channelOpenConfirmMsg (struct)

		Fields (total 5, all are exported)
			MaxPacketSize uint32
			MyID uint32
			MyWindow uint32
			PeersID uint32
			TypeSpecificData []byte

	 type channelOpenDirectMsg (struct)
		RFC 4254 7.2

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			laddr string
			lport uint32
			raddr string
			rport uint32

	 type channelOpenFailureMsg (struct)

		Fields (total 4, all are exported)
			Language string
			Message string
			PeersID uint32
			Reason RejectionReason

	 type channelOpenMsg (struct)

		Fields (total 5, all are exported)
			ChanType string
			MaxPacketSize uint32
			PeersID uint32
			PeersWindow uint32
			TypeSpecificData []byte

	 type channelRequestFailureMsg (struct)

		Fields (only one, which is exported)
			PeersID uint32

	 type channelRequestMsg (struct)

		Fields (total 4, all are exported)
			PeersID uint32
			Request string
			RequestSpecificData []byte
			WantReply bool

	 type channelRequestSuccessMsg (struct)

		Fields (only one, which is exported)
			PeersID uint32

	 type cipherMode (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			create func(key, iv []byte, macKey []byte, algs directionAlgorithms) (packetCipher, error)
			ivSize int
			keySize int

	 type connection (struct)
		A connection represents an incoming connection.

		Fields (total 14, none are exported)
			/* 14 unexporteds ... *//* 14 unexporteds: */
			mux *mux
				The connection protocol.

			mux.chanList chanList
			mux.err error
			mux.errCond *sync.Cond
			mux.globalResponses chan interface{}
			mux.globalSentMu sync.Mutex
			mux.incomingChannels chan NewChannel
			mux.incomingRequests chan *Request
			sshConn sshConn
			sshConn.clientVersion []byte
			sshConn.serverVersion []byte
			sshConn.sessionID []byte
			sshConn.user string
			transport *handshakeTransport
		Methods (total 23, in which 10 are exported)
			(*T) ClientVersion() []byte
			(*T) Close() error
			(*T) LocalAddr() net.Addr
			( T) OpenChannel(chanType string, extra []byte) (Channel, <-chan *Request, error)
			(*T) RemoteAddr() net.Addr
			( T) SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error)
			(*T) ServerVersion() []byte
			(*T) SessionID() []byte
			(*T) User() string
			( T) Wait() error
			/* 13 unexporteds ... *//* 13 unexporteds: */
			( T) ackRequest(ok bool, data []byte) error
				ackRequest must be called after processing a global request that
				has WantReply set.

			(*T) clientAuthenticate(config *ClientConfig) error
				clientAuthenticate authenticates with the remote server. See RFC 4252.

			(*T) clientHandshake(dialAddress string, config *ClientConfig) error
				clientHandshake performs the client side key exchange. See RFC 4253 Section
				7.

			( T) handleChannelOpen(packet []byte) error
				handleChannelOpen schedules a channel to be Accept()ed.

			( T) handleGlobalPacket(packet []byte) error
			( T) handleUnknownChannelPacket(id uint32, packet []byte) error
			( T) loop()
				loop runs the connection machine. It will process packets until an
				error is encountered. To synchronize on loop exit, use mux.Wait.

			( T) newChannel(chanType string, direction channelDirection, extraData []byte) *channel
			( T) onePacket() error
				onePacket reads and processes one packet.

			( T) openChannel(chanType string, extra []byte) (*channel, error)
			( T) sendMessage(msg interface{}) error
			(*T) serverAuthenticate(config *ServerConfig) (*Permissions, error)
			(*T) serverHandshake(config *ServerConfig) (*Permissions, error)
				handshake performs key exchange and user authentication.

		Implements (at least 3, all are exported)
			*T : Conn
			*T : ConnMetadata
			*T : io.Closer
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func gssExchangeToken(gssapiConfig *GSSAPIWithMICConfig, firstToken []byte, s *connection, sessionID []byte, userAuthReq userAuthRequestMsg) (authErr error, perms *Permissions, err error)

	 type connectionState (struct)
		connectionState represents one side (read or write) of the
		connection. This is necessary because each direction has its own
		keys, and can even have its own algorithms

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			dir direction
			packetCipher packetCipher
			pendingKeyChange chan packetCipher
			seqNum uint32
		Methods (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			( T) readCipherPacket(seqnum uint32, r io.Reader) ([]byte, error)
				readCipherPacket reads and decrypts a packet of data. The
				returned packet may be overwritten by future calls of
				readPacket.

			(*T) readPacket(r *bufio.Reader) ([]byte, error)
			( T) writeCipherPacket(seqnum uint32, w io.Writer, rand io.Reader, packet []byte) error
				writeCipherPacket encrypts the packet and writes it to w. The
				contents of the packet are generally scrambled.

			(*T) writePacket(w *bufio.Writer, rand io.Reader, packet []byte) error
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 T : packetCipher

	 type curve25519KeyPair (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			priv [32]byte
			pub [32]byte
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*T) generate(rand io.Reader) error

	 type curve25519sha256 (struct)
		curve25519sha256 implements the curve25519-sha256@libssh.org key
		agreement protocol, as described in
		https://git.libssh.org/projects/libssh.git/tree/doc/curve25519-sha256@libssh.org.txt

		Methods (total 2, both are exported)
			(*T) Client(c packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error)
			(*T) Server(c packetConn, rand io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : kexAlgorithm

	 type dhGEXSHA (struct)
		dhGEXSHA implements the diffie-hellman-group-exchange-sha1 and
		diffie-hellman-group-exchange-sha256 key agreement protocols,
		as described in RFC 4419

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			g *big.Int
			hashFunc crypto.Hash
			p *big.Int
		Methods (total 3, in which 2 are exported)
			( T) Client(c packetConn, randSource io.Reader, magics *handshakeMagics) (*kexResult, error)
			( T) Server(c packetConn, randSource io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error)
				Server half implementation of the Diffie Hellman Key Exchange with SHA1 and SHA256.

				This is a minimal implementation to satisfy the automated tests.

			/* one unexported ... *//* one unexported: */
			(*T) diffieHellman(theirPublic, myPrivate *big.Int) (*big.Int, error)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 T : kexAlgorithm

	 type dhGroup (struct)
		dhGroup is a multiplicative group suitable for implementing Diffie-Hellman key agreement.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			g *big.Int
			p *big.Int
			pMinus1 *big.Int
		Methods (total 3, in which 2 are exported)
			(*T) Client(c packetConn, randSource io.Reader, magics *handshakeMagics) (*kexResult, error)
			(*T) Server(c packetConn, randSource io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error)
			/* one unexported ... *//* one unexported: */
			(*T) diffieHellman(theirPublic, myPrivate *big.Int) (*big.Int, error)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : kexAlgorithm

	 type direction (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			ivTag []byte
			keyTag []byte
			macKeyTag []byte
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newPacketCipher(d direction, algs directionAlgorithms, kex *kexResult) (packetCipher, error)
		As Types Of (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			  var clientKeys
			  var serverKeys

	 type directionAlgorithms (struct)
		directionAlgorithms records algorithm choices in one direction (either read or write)

		Fields (total 3, all are exported)
			Cipher string
			Compression string
			MAC string
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*T) rekeyBytes() int64
				rekeyBytes returns a rekeying intervals in bytes.

		As Inputs Of (at least 6, none are exported)
			/* 6+ unexporteds ... *//* 6+ unexporteds: */
			func newAESCBCCipher(key, iv, macKey []byte, algs directionAlgorithms) (packetCipher, error)
			func newCBCCipher(c cipher.Block, key, iv, macKey []byte, algs directionAlgorithms) (packetCipher, error)
			func newChaCha20Cipher(key, unusedIV, unusedMACKey []byte, unusedAlgs directionAlgorithms) (packetCipher, error)
			func newGCMCipher(key, iv, unusedMacKey []byte, unusedAlgs directionAlgorithms) (packetCipher, error)
			func newPacketCipher(d direction, algs directionAlgorithms, kex *kexResult) (packetCipher, error)
			func newTripleDESCBCCipher(key, iv, macKey []byte, algs directionAlgorithms) (packetCipher, error)

	 type disconnectMsg (struct)
		disconnectMsg is the message that signals a disconnect. It is also
		the error type returned from mux.Wait()

		Fields (total 3, all are exported)
			Language string
			Message string
			Reason uint32
		Methods (only one, which is exported)
			(*T) Error() string
		Implements (at least one exported)
			*T : error

	 type dsaPrivateKey (struct)

		Fields (total 7, all are exported)
			PrivateKey *dsa.PrivateKey
			PrivateKey.PublicKey.Parameters dsa.Parameters
			PrivateKey.PublicKey.Parameters.G *big.Int
			PrivateKey.PublicKey.Parameters.P *big.Int
			PrivateKey.PublicKey.Parameters.Q *big.Int
			PrivateKey.PublicKey.Y *big.Int
			PrivateKey.X *big.Int
		Methods (total 3, all are exported)
			(*T) PublicKey() PublicKey
			(*T) Sign(rand io.Reader, data []byte) (*Signature, error)
			(*T) SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*Signature, error)
		Implements (at least 2, both are exported)
			*T : AlgorithmSigner
			*T : Signer

	 type dsaPublicKey dsa.PublicKey (struct)

		Fields (total 5, all are exported)
			Parameters dsa.Parameters
			Parameters.G *big.Int
			Parameters.P *big.Int
			Parameters.Q *big.Int
			Y *big.Int
		Methods (total 4, all are exported)
			(*T) CryptoPublicKey() crypto.PublicKey
			(*T) Marshal() []byte
			(*T) Type() string
			(*T) Verify(data []byte, sig *Signature) error
		Implements (at least 2, both are exported)
			*T : CryptoPublicKey
			*T : PublicKey

	 type ecdh (struct)
		ecdh performs Elliptic Curve Diffie-Hellman key exchange as
		described in RFC 5656, section 4.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			curve elliptic.Curve
		Methods (total 2, both are exported)
			(*T) Client(c packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error)
			(*T) Server(c packetConn, rand io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : kexAlgorithm

	 type ecdsaPublicKey ecdsa.PublicKey (struct)

		Fields (total 3, all are exported)
			Curve elliptic.Curve
			X *big.Int
			Y *big.Int
		Methods (total 11, in which 10 are exported)
			( T) Add(x1, y1, x2, y2 *big.Int) (x, y *big.Int)
				Add returns the sum of (x1,y1) and (x2,y2)

			(*T) CryptoPublicKey() crypto.PublicKey
			( T) Double(x1, y1 *big.Int) (x, y *big.Int)
				Double returns 2*(x,y)

			( T) IsOnCurve(x, y *big.Int) bool
				IsOnCurve reports whether the given (x,y) lies on the curve.

			(*T) Marshal() []byte
			( T) Params() *elliptic.CurveParams
				Params returns the parameters for the curve.

			( T) ScalarBaseMult(k []byte) (x, y *big.Int)
				ScalarBaseMult returns k*G, where G is the base point of the group
				and k is an integer in big-endian form.

			( T) ScalarMult(x1, y1 *big.Int, k []byte) (x, y *big.Int)
				ScalarMult returns k*(Bx,By) where k is a number in big-endian form.

			(*T) Type() string
			(*T) Verify(data []byte, sig *Signature) error
			/* one unexported ... *//* one unexported: */
			(*T) nistID() string
		Implements (at least 3, all are exported)
			*T : CryptoPublicKey
			*T : PublicKey
			 T : crypto/elliptic.Curve

	 type ed25519PublicKey ed25519.PublicKey ([]T)

		Methods (total 4, all are exported)
			( T) CryptoPublicKey() crypto.PublicKey
			( T) Marshal() []byte
			( T) Type() string
			( T) Verify(b []byte, sig *Signature) error
		Implements (at least 2, both are exported)
			 T : CryptoPublicKey
			 T : PublicKey

	 type element (struct)
		An element represents a single link in a linked list.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			buf []byte
			next *element

	 type execMsg (struct)
		RFC 4254 Section 6.5.

		Fields (only one, which is exported)
			Command string

	 type extChannel (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			ch *channel
			code uint32
		Methods (total 2, both are exported)
			(*T) Read(data []byte) (n int, err error)
			(*T) Write(data []byte) (n int, err error)
		Implements (at least 6, all are exported)
			*T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			*T : github.com/jbenet/go-context/io.Reader
			*T : github.com/jbenet/go-context/io.Writer
			*T : io.Reader
			*T : io.ReadWriter
			*T : io.Writer

	 type fixedHostKey (struct)

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			key PublicKey
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*T) check(hostname string, remote net.Addr, key PublicKey) error

	 type forward (struct)
		forward represents an incoming forwarded tcpip connection. The
		arguments to add/remove/lookup should be address as specified in
		the original forward-request.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			newCh NewChannel
				// the ssh client channel underlying this forward

			raddr net.Addr
				// the raddr of the incoming connection


	 type forwardedStreamLocalPayload (struct)
		forwardedStreamLocalPayload is a struct used for SSH_MSG_CHANNEL_OPEN message
		with "forwarded-streamlocal@openssh.com" string.

		Fields (total 2, both are exported)
			Reserved0 string
			SocketPath string

	 type forwardedTCPPayload (struct)
		See RFC 4254, section 7.2

		Fields (total 4, all are exported)
			Addr string
			OriginAddr string
			OriginPort uint32
			Port uint32

	 type forwardEntry (struct)
		forwardEntry represents an established mapping of a laddr on a
		remote ssh server to a channel connected to a tcpListener.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			c chan forward
			laddr net.Addr

	 type forwardList (struct)
		forwardList stores a mapping between remote
		forward requests and the tcpListeners.

		Fields (total 4, in which 1 are exported)
			Mutex sync.Mutex
			/* 3 unexporteds ... *//* 3 unexporteds: */
			entries []forwardEntry
			Mutex.sema uint32
			Mutex.state int32
		Methods (total 9, in which 2 are exported)
			(*T) Lock()
				Lock locks m.
				If the lock is already in use, the calling goroutine
				blocks until the mutex is available.

			(*T) Unlock()
				Unlock unlocks m.
				It is a run-time error if m is not locked on entry to Unlock.

				A locked Mutex is not associated with a particular goroutine.
				It is allowed for one goroutine to lock a Mutex and then
				arrange for another goroutine to unlock it.

			/* 7 unexporteds ... *//* 7 unexporteds: */
			(*T) add(addr net.Addr) chan forward
			(*T) closeAll()
				closeAll closes and clears all forwards.

			(*T) forward(laddr, raddr net.Addr, ch NewChannel) bool
			(*T) handleChannels(in <-chan NewChannel)
			(*T) lockSlow()
			(*T) remove(addr net.Addr)
				remove removes the forward entry, and the channel feeding its
				listener.

			(*T) unlockSlow(new int32)
		Implements (at least one exported)
			*T : sync.Locker

	 type gcmCipher (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			aead cipher.AEAD
			buf []byte
			iv []byte
			prefix [4]byte
		Methods (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) incIV()
			(*T) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error)
			(*T) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : packetCipher

	 type genericCertData (struct)
		genericCertData holds the key-independent part of the certificate data.
		Overall, certificates contain an nonce, public key fields and
		key-independent fields.

		Fields (total 11, all are exported)
			CertType uint32
			CriticalOptions []byte
			Extensions []byte
			KeyId string
			Reserved []byte
			Serial uint64
			Signature []byte
			SignatureKey []byte
			ValidAfter uint64
			ValidBefore uint64
			ValidPrincipals []byte

	 type globalRequestFailureMsg (struct)

		Fields (only one, which is exported)
			Data []byte

	 type globalRequestMsg (struct)

		Fields (total 3, all are exported)
			Data []byte
			Type string
			WantReply bool

	 type globalRequestSuccessMsg (struct)

		Fields (only one, which is exported)
			Data []byte

	 type gssAPIWithMICCallback (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			gssAPIClient GSSAPIClient
			target string
		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error)
			(*T) method() string
		Implements (at least one exported)
			*T : AuthMethod

	 type handshakeMagics (struct)
		handshakeMagics contains data that is always included in the
		session hash.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			clientKexInit []byte
			clientVersion []byte
			serverKexInit []byte
			serverVersion []byte
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*T) write(w io.Writer)

	 type handshakeTransport (struct)
		handshakeTransport implements rekeying on top of a keyingTransport
		and offers a thread-safe writePacket() interface.

		Fields (total 25, none are exported)
			/* 25 unexporteds ... *//* 25 unexporteds: */
			algorithms *algorithms
				Algorithms agreed in the last key exchange.

			bannerCallback BannerCallback
				bannerCallback is non-empty if we are the client and it has been set in
				ClientConfig. In that case it is called during the user authentication
				dance to handle a custom server's message.

			clientVersion []byte
			config *Config
			conn keyingTransport
			dialAddress string
			hostKeyAlgorithms []string
				hostKeyAlgorithms is non-empty if we are the client. In that case,
				we accept these key types from the server as host key.

			hostKeyCallback HostKeyCallback
				data for host key checking

			hostKeys []Signer
				hostKeys is non-empty if we are the server. In that case,
				it contains all host keys that can be used to sign the
				connection.

			incoming chan []byte
				On read error, incoming is closed, and readError is set.

			mu sync.Mutex
			pendingPackets [][]byte
				// Used when a key exchange is in progress.

			readBytesLeft int64
			readError error
			readPacketsLeft uint32
			remoteAddr net.Addr
			requestKex chan struct{}
				If the read loop wants to schedule a kex, it pings this
				channel, and the write loop will send out a kex
				message.

			sentInitMsg *kexInitMsg
			sentInitPacket []byte
			serverVersion []byte
			sessionID []byte
				The session ID or nil if first kex did not complete yet.

			startKex chan *pendingKex
				If the other side requests or confirms a kex, its kexInit
				packet is sent here for the write loop to find it.

			writeBytesLeft int64
			writeError error
			writePacketsLeft uint32
		Methods (total 20, in which 1 are exported)
			(*T) Close() error
			/* 19 unexporteds ... *//* 19 unexporteds: */
			(*T) client(kex kexAlgorithm, algs *algorithms, magics *handshakeMagics) (*kexResult, error)
			(*T) enterKeyExchange(otherInitPacket []byte) error
			(*T) getSessionID() []byte
			(*T) getWriteError() error
			(*T) id() string
			(*T) kexLoop()
			(*T) printPacket(p []byte, write bool)
			(*T) pushPacket(p []byte) error
			(*T) readLoop()
			(*T) readOnePacket(first bool) ([]byte, error)
			(*T) readPacket() ([]byte, error)
			(*T) recordWriteError(err error)
			(*T) requestKeyExchange()
			(*T) resetReadThresholds()
			(*T) resetWriteThresholds()
			(*T) sendKexInit() error
				sendKexInit sends a key change message.

			(*T) server(kex kexAlgorithm, algs *algorithms, magics *handshakeMagics) (*kexResult, error)
			(*T) waitSession() error
				waitSession waits for the session to be established. This should be
				the first thing to call after instantiating handshakeTransport.

			(*T) writePacket(p []byte) error
		Implements (at least 2, in which 1 are exported)
			*T : io.Closer
			/* at least one unexported ... *//* at least one unexported: */
			*T : packetConn
		As Outputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func newClientTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ClientConfig, dialAddr string, addr net.Addr) *handshakeTransport
			func newHandshakeTransport(conn keyingTransport, config *Config, clientVersion, serverVersion []byte) *handshakeTransport
			func newServerTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ServerConfig) *handshakeTransport

	 type kexAlgorithm (interface)
		kexAlgorithm abstracts different key exchange algorithms.

		Methods (total 2, both are exported)
			( T) Client(p packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error)
				Client runs the client-side key agreement. Caller is
				responsible for verifying the host key signature.

			( T) Server(p packetConn, rand io.Reader, magics *handshakeMagics, s Signer) (*kexResult, error)
				Server runs server-side key agreement, signing the result
				with a hostkey.

		Implemented By (at least 4, none are exported)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			*curve25519sha256
			 dhGEXSHA
			*dhGroup
			*ecdh

	 type kexDHGexGroupMsg (struct)

		Fields (total 2, both are exported)
			G *big.Int
			P *big.Int

	 type kexDHGexInitMsg (struct)

		Fields (only one, which is exported)
			X *big.Int

	 type kexDHGexReplyMsg (struct)

		Fields (total 3, all are exported)
			HostKey []byte
			Signature []byte
			Y *big.Int

	 type kexDHGexRequestMsg (struct)

		Fields (total 3, all are exported)
			MaxBits uint32
			MinBits uint32
			PreferedBits uint32

	 type kexDHInitMsg (struct)

		Fields (only one, which is exported)
			X *big.Int

	 type kexDHReplyMsg (struct)

		Fields (total 3, all are exported)
			HostKey []byte
			Signature []byte
			Y *big.Int

	 type kexECDHInitMsg (struct)

		Fields (only one, which is exported)
			ClientPubKey []byte

	 type kexECDHReplyMsg (struct)

		Fields (total 3, all are exported)
			EphemeralPubKey []byte
			HostKey []byte
			Signature []byte

	 type kexInitMsg (struct)

		Fields (total 13, all are exported)
			CiphersClientServer []string
			CiphersServerClient []string
			CompressionClientServer []string
			CompressionServerClient []string
			Cookie [16]byte
			FirstKexFollows bool
			KexAlgos []string
			LanguagesClientServer []string
			LanguagesServerClient []string
			MACsClientServer []string
			MACsServerClient []string
			Reserved uint32
			ServerHostKeyAlgos []string
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func findAgreedAlgorithms(isClient bool, clientKexInit, serverKexInit *kexInitMsg) (algs *algorithms, err error)

	 type kexResult (struct)
		kexResult captures the outcome of a key exchange.

		Fields (total 6, all are exported)
			H []byte
				Session hash. See also RFC 4253, section 8.

			Hash crypto.Hash
				A cryptographic hash function that matches the security
				level of the key exchange algorithm. It is used for
				calculating H, and for deriving keys from H and K.

			HostKey []byte
				Host key as hashed into H.

			K []byte
				Shared secret. See also RFC 4253, section 8.

			SessionID []byte
				The session ID, which is the first H computed. This is used
				to derive key material inside the transport.

			Signature []byte
				Signature of H.

		As Inputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func generateKeyMaterial(out, tag []byte, r *kexResult)
			func newPacketCipher(d direction, algs directionAlgorithms, kex *kexResult) (packetCipher, error)
			func verifyHostKeySignature(hostKey PublicKey, result *kexResult) error

	 type keyingTransport (interface)
		keyingTransport is a packet based transport that supports key
		changes. It need not be thread-safe. It should pass through
		msgNewKeys in both directions.

		Methods (total 4, in which 1 are exported)
			( T) Close() error
				Close closes the write-side of the connection.

			/* 3 unexporteds ... *//* 3 unexporteds: */
			( T) prepareKeyChange(*algorithms, *kexResult) error
				prepareKeyChange sets up a key change. The key change for a
				direction will be effected if a msgNewKeys message is sent
				or received.

			( T) readPacket() ([]byte, error)
				Read a packet from the connection. The read is blocking,
				i.e. if error is nil, then the returned byte slice is
				always non-empty.

			( T) writePacket(packet []byte) error
				Encrypt and send a packet of data to the remote peer.

		Implemented By (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*transport
		Implements (at least 2, in which 1 are exported)
			 T : io.Closer
			/* at least one unexported ... *//* at least one unexported: */
			 T : packetConn
		As Inputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func newClientTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ClientConfig, dialAddr string, addr net.Addr) *handshakeTransport
			func newHandshakeTransport(conn keyingTransport, config *Config, clientVersion, serverVersion []byte) *handshakeTransport
			func newServerTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ServerConfig) *handshakeTransport

	 type macMode (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			etm bool
			keySize int
			new func(key []byte) hash.Hash

	 type mux (struct)
		mux represents the state for the SSH connection protocol, which
		multiplexes many channels onto a single packet transport.

		Fields (total 8, none are exported)
			/* 8 unexporteds ... *//* 8 unexporteds: */
			chanList chanList
			conn packetConn
			err error
			errCond *sync.Cond
			globalResponses chan interface{}
			globalSentMu sync.Mutex
			incomingChannels chan NewChannel
			incomingRequests chan *Request
		Methods (total 13, in which 4 are exported)
			(*T) Close() error
			(*T) OpenChannel(chanType string, extra []byte) (Channel, <-chan *Request, error)
			(*T) SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error)
			(*T) Wait() error
			/* 9 unexporteds ... *//* 9 unexporteds: */
			(*T) ackRequest(ok bool, data []byte) error
				ackRequest must be called after processing a global request that
				has WantReply set.

			(*T) handleChannelOpen(packet []byte) error
				handleChannelOpen schedules a channel to be Accept()ed.

			(*T) handleGlobalPacket(packet []byte) error
			(*T) handleUnknownChannelPacket(id uint32, packet []byte) error
			(*T) loop()
				loop runs the connection machine. It will process packets until an
				error is encountered. To synchronize on loop exit, use mux.Wait.

			(*T) newChannel(chanType string, direction channelDirection, extraData []byte) *channel
			(*T) onePacket() error
				onePacket reads and processes one packet.

			(*T) openChannel(chanType string, extra []byte) (*channel, error)
			(*T) sendMessage(msg interface{}) error
		Implements (at least one exported)
			*T : io.Closer
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newMux(p packetConn) *mux

	 type noneAuth int (basic type)
		"none" authentication, RFC 4252 section 5.2.

		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error)
			(*T) method() string
		Implements (at least one exported)
			*T : AuthMethod

	 type noneCipher (struct)
		noneCipher implements cipher.Stream and provides no encryption. It is used
		by the transport before the first key-exchange.

		Methods (only one, which is exported)
			( T) XORKeyStream(dst, src []byte)
		Implements (at least one exported)
			 T : crypto/cipher.Stream

	 type openSSHCertSigner (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			pub *Certificate
			signer Signer
		Methods (total 2, both are exported)
			(*T) PublicKey() PublicKey
			(*T) Sign(rand io.Reader, data []byte) (*Signature, error)
		Implements (at least one exported)
			*T : Signer

	 type openSSHDecryptFunc (func)

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func passphraseProtectedOpenSSHKey(passphrase []byte) openSSHDecryptFunc
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func parseOpenSSHPrivateKey(key []byte, decrypt openSSHDecryptFunc) (crypto.PrivateKey, error)

	 type optionsTuple (struct)

		Fields (total 2, both are exported)
			Key string
			Value []byte

	 type optionsTupleValue (struct)

		Fields (only one, which is exported)
			Value string

	 type packetCipher (interface)
		packetCipher represents a combination of SSH encryption/MAC
		protocol.  A single instance should be used for one direction only.

		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			( T) readCipherPacket(seqnum uint32, r io.Reader) ([]byte, error)
				readCipherPacket reads and decrypts a packet of data. The
				returned packet may be overwritten by future calls of
				readPacket.

			( T) writeCipherPacket(seqnum uint32, w io.Writer, rand io.Reader, packet []byte) error
				writeCipherPacket encrypts the packet and writes it to w. The
				contents of the packet are generally scrambled.

		Implemented By (at least 5, none are exported)
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			*cbcCipher
			*chacha20Poly1305Cipher
			 connectionState
			*gcmCipher
			*streamPacketCipher
		As Outputs Of (at least 6, none are exported)
			/* 6+ unexporteds ... *//* 6+ unexporteds: */
			func newAESCBCCipher(key, iv, macKey []byte, algs directionAlgorithms) (packetCipher, error)
			func newCBCCipher(c cipher.Block, key, iv, macKey []byte, algs directionAlgorithms) (packetCipher, error)
			func newChaCha20Cipher(key, unusedIV, unusedMACKey []byte, unusedAlgs directionAlgorithms) (packetCipher, error)
			func newGCMCipher(key, iv, unusedMacKey []byte, unusedAlgs directionAlgorithms) (packetCipher, error)
			func newPacketCipher(d direction, algs directionAlgorithms, kex *kexResult) (packetCipher, error)
			func newTripleDESCBCCipher(key, iv, macKey []byte, algs directionAlgorithms) (packetCipher, error)

	 type packetConn (interface)
		packetConn represents a transport that implements packet based
		operations.

		Methods (total 3, in which 1 are exported)
			( T) Close() error
				Close closes the write-side of the connection.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			( T) readPacket() ([]byte, error)
				Read a packet from the connection. The read is blocking,
				i.e. if error is nil, then the returned byte slice is
				always non-empty.

			( T) writePacket(packet []byte) error
				Encrypt and send a packet of data to the remote peer.

		Implemented By (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*handshakeTransport
			 keyingTransport (interface)
			*transport
		Implements (at least one exported)
			 T : io.Closer
		As Inputs Of (at least 6, none are exported)
			/* 6+ unexporteds ... *//* 6+ unexporteds: */
			func confirmKeyAck(key PublicKey, c packetConn) (bool, error)
			func handleAuthResponse(c packetConn) (authResult, []string, error)
			func handleBannerResponse(c packetConn, packet []byte) error
			func newMux(p packetConn) *mux
			func validateKey(key PublicKey, user string, c packetConn) (bool, error)
			func KeyboardInteractiveChallenge.auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error)

	 type passwordCallback (func)
		passwordCallback is an AuthMethod that fetches the password through
		a function call, e.g. by prompting the user.

		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			( T) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error)
			( T) method() string
		Implements (at least one exported)
			 T : AuthMethod

	 type pendingKex (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			done chan error
			otherInit []byte

	 type ptyRequestMsg (struct)
		RFC 4254 Section 6.2.

		Fields (total 6, all are exported)
			Columns uint32
			Height uint32
			Modelist string
			Rows uint32
			Term string
			Width uint32

	 type ptyWindowChangeMsg (struct)
		RFC 4254 Section 6.7.

		Fields (total 4, all are exported)
			Columns uint32
			Height uint32
			Rows uint32
			Width uint32

	 type pubKeyCache (struct)
		pubKeyCache caches tests for public keys.  Since SSH clients
		will query whether a public key is acceptable before attempting to
		authenticate with it, we end up with duplicate queries for public
		key validity.  The cache only applies to a single ServerConn.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			keys []cachedPubKey
		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) add(candidate cachedPubKey)
				add adds the given tuple to the cache.

			(*T) get(user string, pubKeyData []byte) (cachedPubKey, bool)
				get returns the result for a given user/algo/key tuple.


	 type publickeyAuthMsg (struct)

		Fields (total 7, all are exported)
			Algoname string
			HasSig bool
				HasSig indicates to the receiver packet that the auth request is signed and
				should be used for authentication of the request.

			Method string
			PubKey []byte
			Service string
			Sig []byte
				Sig is tagged with "rest" so Marshal will exclude it during
				validateKey

			User string

	 type publicKeyCallback (func)
		publicKeyCallback is an AuthMethod that uses a set of key
		pairs for authentication.

		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			( T) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error)
			( T) method() string
		Implements (at least one exported)
			 T : AuthMethod

	 type retryableAuthMethod (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			authMethod AuthMethod
			maxTries int
		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) auth(session []byte, user string, c packetConn, rand io.Reader) (ok authResult, methods []string, err error)
			(*T) method() string
		Implements (at least one exported)
			*T : AuthMethod

	 type rsaPublicKey rsa.PublicKey (struct)

		Fields (total 2, both are exported)
			E int
				// public exponent

			N *big.Int
				// modulus

		Methods (total 4, all are exported)
			(*T) CryptoPublicKey() crypto.PublicKey
			(*T) Marshal() []byte
			(*T) Type() string
			(*T) Verify(data []byte, sig *Signature) error
		Implements (at least 2, both are exported)
			*T : CryptoPublicKey
			*T : PublicKey

	 type serviceAcceptMsg (struct)

		Fields (only one, which is exported)
			Service string

	 type serviceRequestMsg (struct)

		Fields (only one, which is exported)
			Service string

	 type sessionStdin (struct)
		sessionStdin reroutes Close to CloseWrite.

		Fields (total 2, in which 1 are exported)
			Writer io.Writer
			/* one unexported ... *//* one unexported: */
			ch Channel
		Methods (total 2, both are exported)
			(*T) Close() error
			( T) Write(p []byte) (n int, err error)
		Implements (at least 5, all are exported)
			 T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			 T : github.com/jbenet/go-context/io.Writer
			*T : io.Closer
			*T : io.WriteCloser
			 T : io.Writer

	 type setenvRequest (struct)
		RFC 4254 Section 6.4.

		Fields (total 2, both are exported)
			Name string
			Value string

	 type signalMsg (struct)
		RFC 4254 Section 6.9.

		Fields (only one, which is exported)
			Signal string

	 type singleWriter (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			b bytes.Buffer
			mu sync.Mutex
		Methods (only one, which is exported)
			(*T) Write(p []byte) (int, error)
		Implements (at least 3, all are exported)
			*T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			*T : github.com/jbenet/go-context/io.Writer
			*T : io.Writer

	 type skECDSAPublicKey (struct)

		Fields (total 5, in which 4 are exported)
			PublicKey ecdsa.PublicKey
			PublicKey.Curve elliptic.Curve
			PublicKey.X *big.Int
			PublicKey.Y *big.Int
			/* one unexported ... *//* one unexported: */
			application string
				application is a URL-like string, typically "ssh:" for SSH.
				see openssh/PROTOCOL.u2f for details.

		Methods (total 11, in which 10 are exported)
			( T) Add(x1, y1, x2, y2 *big.Int) (x, y *big.Int)
				Add returns the sum of (x1,y1) and (x2,y2)

			( T) Double(x1, y1 *big.Int) (x, y *big.Int)
				Double returns 2*(x,y)

			(*T) Equal(x crypto.PublicKey) bool
				Equal reports whether pub and x have the same value.

				Two keys are only considered to have the same value if they have the same Curve value.
				Note that for example elliptic.P256() and elliptic.P256().Params() are different
				values, as the latter is a generic not constant time implementation.

			( T) IsOnCurve(x, y *big.Int) bool
				IsOnCurve reports whether the given (x,y) lies on the curve.

			(*T) Marshal() []byte
			( T) Params() *elliptic.CurveParams
				Params returns the parameters for the curve.

			( T) ScalarBaseMult(k []byte) (x, y *big.Int)
				ScalarBaseMult returns k*G, where G is the base point of the group
				and k is an integer in big-endian form.

			( T) ScalarMult(x1, y1 *big.Int, k []byte) (x, y *big.Int)
				ScalarMult returns k*(Bx,By) where k is a number in big-endian form.

			(*T) Type() string
			(*T) Verify(data []byte, sig *Signature) error
			/* one unexported ... *//* one unexported: */
			(*T) nistID() string
		Implements (at least 2, both are exported)
			*T : PublicKey
			 T : crypto/elliptic.Curve

	 type skEd25519PublicKey (struct)

		Fields (total 2, in which 1 are exported)
			PublicKey ed25519.PublicKey
			/* one unexported ... *//* one unexported: */
			application string
				application is a URL-like string, typically "ssh:" for SSH.
				see openssh/PROTOCOL.u2f for details.

		Methods (total 4, all are exported)
			( T) Equal(x crypto.PublicKey) bool
				Equal reports whether pub and x have the same value.

			(*T) Marshal() []byte
			(*T) Type() string
			(*T) Verify(data []byte, sig *Signature) error
		Implements (at least one exported)
			*T : PublicKey

	 type skFields (struct)
		skFields holds the additional fields present in U2F/FIDO2 signatures.
		See openssh/PROTOCOL.u2f 'SSH U2F Signatures' for details.

		Fields (total 2, both are exported)
			Counter uint32
				Counter is a monotonic signature counter which can be
				used to detect concurrent use of a private key, should
				it be extracted from hardware.

			Flags byte
				Flags contains U2F/FIDO2 flags such as 'user present'


	 type sshClientKeyboardInteractive (struct)
		sshClientKeyboardInteractive implements a ClientKeyboardInteractive by
		asking the client on the other side of a ServerConn.

		Fields (total 15, none are exported)
			/* 15 unexporteds ... *//* 15 unexporteds: */
			connection *connection
			connection.mux *mux
				The connection protocol.

			connection.mux.chanList chanList
			connection.mux.err error
			connection.mux.errCond *sync.Cond
			connection.mux.globalResponses chan interface{}
			connection.mux.globalSentMu sync.Mutex
			connection.mux.incomingChannels chan NewChannel
			connection.mux.incomingRequests chan *Request
			connection.sshConn sshConn
			connection.sshConn.clientVersion []byte
			connection.sshConn.serverVersion []byte
			connection.sshConn.sessionID []byte
			connection.sshConn.user string
			connection.transport *handshakeTransport
		Methods (total 24, in which 11 are exported)
			(*T) Challenge(user, instruction string, questions []string, echos []bool) (answers []string, err error)
			( T) ClientVersion() []byte
			( T) Close() error
			( T) LocalAddr() net.Addr
			( T) OpenChannel(chanType string, extra []byte) (Channel, <-chan *Request, error)
			( T) RemoteAddr() net.Addr
			( T) SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error)
			( T) ServerVersion() []byte
			( T) SessionID() []byte
			( T) User() string
			( T) Wait() error
			/* 13 unexporteds ... *//* 13 unexporteds: */
			( T) ackRequest(ok bool, data []byte) error
				ackRequest must be called after processing a global request that
				has WantReply set.

			( T) clientAuthenticate(config *ClientConfig) error
				clientAuthenticate authenticates with the remote server. See RFC 4252.

			( T) clientHandshake(dialAddress string, config *ClientConfig) error
				clientHandshake performs the client side key exchange. See RFC 4253 Section
				7.

			( T) handleChannelOpen(packet []byte) error
				handleChannelOpen schedules a channel to be Accept()ed.

			( T) handleGlobalPacket(packet []byte) error
			( T) handleUnknownChannelPacket(id uint32, packet []byte) error
			( T) loop()
				loop runs the connection machine. It will process packets until an
				error is encountered. To synchronize on loop exit, use mux.Wait.

			( T) newChannel(chanType string, direction channelDirection, extraData []byte) *channel
			( T) onePacket() error
				onePacket reads and processes one packet.

			( T) openChannel(chanType string, extra []byte) (*channel, error)
			( T) sendMessage(msg interface{}) error
			( T) serverAuthenticate(config *ServerConfig) (*Permissions, error)
			( T) serverHandshake(config *ServerConfig) (*Permissions, error)
				handshake performs key exchange and user authentication.

		Implements (at least 3, all are exported)
			 T : Conn
			 T : ConnMetadata
			 T : io.Closer

	 type sshConn (struct)
		sshconn provides net.Conn metadata, but disallows direct reads and
		writes.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			clientVersion []byte
			conn net.Conn
			serverVersion []byte
			sessionID []byte
			user string
		Methods (total 7, all are exported)
			(*T) ClientVersion() []byte
			(*T) Close() error
			(*T) LocalAddr() net.Addr
			(*T) RemoteAddr() net.Addr
			(*T) ServerVersion() []byte
			(*T) SessionID() []byte
			(*T) User() string
		Implements (at least 2, both are exported)
			*T : ConnMetadata
			*T : io.Closer

	 type streamLocalChannelForwardMsg (struct)
		streamLocalChannelForwardMsg is a struct used for SSH2_MSG_GLOBAL_REQUEST message
		with "streamlocal-forward@openssh.com"/"cancel-streamlocal-forward@openssh.com" string.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			socketPath string

	 type streamLocalChannelOpenDirectMsg (struct)
		streamLocalChannelOpenDirectMsg is a struct used for SSH_MSG_CHANNEL_OPEN message
		with "direct-streamlocal@openssh.com" string.

		See openssh-portable/PROTOCOL, section 2.4. connection: Unix domain socket forwarding
		https://github.com/openssh/openssh-portable/blob/master/PROTOCOL#L235

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			reserved0 string
			reserved1 uint32
			socketPath string

	 type streamPacketCipher (struct)
		streamPacketCipher is a packetCipher using a stream cipher.

		Fields (total 8, none are exported)
			/* 8 unexporteds ... *//* 8 unexporteds: */
			cipher cipher.Stream
			etm bool
			mac hash.Hash
			macResult []byte
			packetData []byte
			padding [32]byte
			prefix [5]byte
				The following members are to avoid per-packet allocations.

			seqNumBytes [4]byte
		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error)
				readCipherPacket reads and decrypt a single packet from the reader argument.

			(*T) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error
				writeCipherPacket encrypts and sends a packet of data to the writer argument

		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*T : packetCipher

	 type subsystemRequestMsg (struct)
		RFC 4254 Section 6.5.

		Fields (only one, which is exported)
			Subsystem string

	 type tcpChan (struct)

		Fields (only one, which is exported)
			Channel Channel
				// the backing channel

		Methods (total 6, all are exported)
			( T) Close() error
				Close signals end of channel use. No data may be sent after this
				call.

			( T) CloseWrite() error
				CloseWrite signals the end of sending in-band
				data. Requests may still be sent, and the other side may
				still send data

			( T) Read(data []byte) (int, error)
				Read reads up to len(data) bytes from the channel.

			( T) SendRequest(name string, wantReply bool, payload []byte) (bool, error)
				SendRequest sends a channel request.  If wantReply is true,
				it will wait for a reply and return the result as a
				boolean, otherwise the return value will be false. Channel
				requests are out-of-band messages so they may be sent even
				if the data stream is closed or blocked by flow control.
				If the channel is closed before a reply is returned, io.EOF
				is returned.

			( T) Stderr() io.ReadWriter
				Stderr returns an io.ReadWriter that writes to this channel
				with the extended data type set to stderr. Stderr may
				safely be read and written from a different goroutine than
				Read and Write respectively.

			( T) Write(data []byte) (int, error)
				Write writes len(data) bytes to the channel.

		Implements (at least 12, in which 11 are exported)
			 T : Channel
			 T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			 T : github.com/jbenet/go-context/io.Reader
			 T : github.com/jbenet/go-context/io.Writer
			 T : io.Closer
			 T : io.ReadCloser
			 T : io.Reader
			 T : io.ReadWriteCloser
			 T : io.ReadWriter
			 T : io.WriteCloser
			 T : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			 T : net/http.closeWriter

	 type tcpListener (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			conn *Client
			in <-chan forward
			laddr *net.TCPAddr
		Methods (total 3, all are exported)
			(*T) Accept() (net.Conn, error)
				Accept waits for and returns the next connection to the listener.

			(*T) Addr() net.Addr
				Addr returns the listener's network address.

			(*T) Close() error
				Close closes the listener.

		Implements (at least 2, both are exported)
			*T : io.Closer
			*T : net.Listener

	 type transport (struct)
		transport is the keyingTransport that implements the SSH packet
		protocol.

		Fields (total 7, in which 1 are exported)
			Closer io.Closer
			/* 6 unexporteds ... *//* 6 unexporteds: */
			bufReader *bufio.Reader
			bufWriter *bufio.Writer
			isClient bool
			rand io.Reader
			reader connectionState
			writer connectionState
		Methods (total 5, in which 1 are exported)
			( T) Close() error
			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) prepareKeyChange(algs *algorithms, kexResult *kexResult) error
				prepareKeyChange sets up key material for a keychange. The key changes in
				both directions are triggered by reading and writing a msgNewKey packet
				respectively.

			(*T) printPacket(p []byte, write bool)
			(*T) readPacket() (p []byte, err error)
				Read and decrypt next packet.

			(*T) writePacket(packet []byte) error
		Implements (at least 3, in which 1 are exported)
			 T : io.Closer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*T : keyingTransport
			*T : packetConn
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newTransport(rwc io.ReadWriteCloser, rand io.Reader, isClient bool) *transport

	 type truncatingMAC (struct)
		truncatingMAC wraps around a hash.Hash and truncates the output digest to
		a given size.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			hmac hash.Hash
			length int
		Methods (total 5, all are exported)
			( T) BlockSize() int
			( T) Reset()
			( T) Size() int
			( T) Sum(in []byte) []byte
			( T) Write(data []byte) (int, error)
		Implements (at least 4, all are exported)
			 T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			 T : github.com/jbenet/go-context/io.Writer
			 T : hash.Hash
			 T : io.Writer

	 type unixListener (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			conn *Client
			in <-chan forward
			socketPath string
		Methods (total 3, all are exported)
			(*T) Accept() (net.Conn, error)
				Accept waits for and returns the next connection to the listener.

			(*T) Addr() net.Addr
				Addr returns the listener's network address.

			(*T) Close() error
				Close closes the listener.

		Implements (at least 2, both are exported)
			*T : io.Closer
			*T : net.Listener

	 type userAuthBannerMsg (struct)

		Fields (total 2, both are exported)
			Language string
				unused, but required to allow message parsing

			Message string

	 type userAuthFailureMsg (struct)

		Fields (total 2, both are exported)
			Methods []string
			PartialSuccess bool

	 type userAuthGSSAPIError (struct)

		Fields (total 4, all are exported)
			LanguageTag string
			MajorStatus uint32
			Message string
			MinorStatus uint32

	 type userAuthGSSAPIErrTok (struct)

		Fields (only one, which is exported)
			ErrorToken []byte

	 type userAuthGSSAPIMIC (struct)

		Fields (only one, which is exported)
			MIC []byte

	 type userAuthGSSAPIResponse (struct)

		Fields (only one, which is exported)
			SupportMech []byte

	 type userAuthGSSAPIToken (struct)

		Fields (only one, which is exported)
			Token []byte

	 type userAuthInfoRequestMsg (struct)

		Fields (total 5, all are exported)
			DeprecatedLanguage string
			Instruction string
			NumPrompts uint32
			Prompts []byte
			User string

	 type userAuthPubKeyOkMsg (struct)

		Fields (total 2, both are exported)
			Algo string
			PubKey []byte

	 type userAuthRequestGSSAPI (struct)
		The GSS-API authentication method is initiated when the client sends an SSH_MSG_USERAUTH_REQUEST
		See RFC 4462 section 3.2.

		Fields (total 2, both are exported)
			N uint32
			OIDS []asn1.ObjectIdentifier
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func parseGSSAPIPayload(payload []byte) (*userAuthRequestGSSAPI, error)

	 type userAuthRequestMsg (struct)

		Fields (total 4, all are exported)
			Method string
			Payload []byte
			Service string
			User string
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func buildDataSignedForAuth(sessionID []byte, req userAuthRequestMsg, algo, pubKey []byte) []byte
			func gssExchangeToken(gssapiConfig *GSSAPIWithMICConfig, firstToken []byte, s *connection, sessionID []byte, userAuthReq userAuthRequestMsg) (authErr error, perms *Permissions, err error)

	 type userAuthSuccessMsg (struct)
		Used for debug printouts of packets.


	 type window (struct)
		window represents the buffer available to clients
		wishing to write to a channel.

		Fields (total 8, in which 2 are exported)
			Cond *sync.Cond
			Cond.L sync.Locker
				L is held while observing or changing the condition

			/* 6 unexporteds ... *//* 6 unexporteds: */
			closed bool
			Cond.checker sync.copyChecker
			Cond.noCopy sync.noCopy
			Cond.notify sync.notifyList
			win uint32
				// RFC 4254 5.2 says the window size can grow to 2^32-1

			writeWaiters int
		Methods (total 7, in which 3 are exported)
			( T) Broadcast()
				Broadcast wakes all goroutines waiting on c.

				It is allowed but not required for the caller to hold c.L
				during the call.

			( T) Signal()
				Signal wakes one goroutine waiting on c, if there is any.

				It is allowed but not required for the caller to hold c.L
				during the call.

			( T) Wait()
				Wait atomically unlocks c.L and suspends execution
				of the calling goroutine. After later resuming execution,
				Wait locks c.L before returning. Unlike in other systems,
				Wait cannot return unless awoken by Broadcast or Signal.

				Because c.L is not locked when Wait first resumes, the caller
				typically cannot assume that the condition is true when
				Wait returns. Instead, the caller should Wait in a loop:

				   c.L.Lock()
				   for !condition() {
				       c.Wait()
				   }
				   ... make use of condition ...
				   c.L.Unlock()

			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) add(win uint32) bool
				add adds win to the amount of window available
				for consumers.

			(*T) close()
				close sets the window to closed, so all reservations fail
				immediately.

			(*T) reserve(win uint32) (uint32, error)
				reserve reserves win from the available window capacity.
				If no capacity remains, reserve will block. reserve may
				return less than requested.

			(*T) waitWriterBlocked()
				waitWriterBlocked waits until some goroutine is blocked for further
				writes. It is used in tests only.


	 type windowAdjustMsg (struct)

		Fields (total 2, both are exported)
			AdditionalBytes uint32
			PeersID uint32

	 type wrappedSigner (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			pubKey PublicKey
			signer crypto.Signer
		Methods (total 3, all are exported)
			(*T) PublicKey() PublicKey
			(*T) Sign(rand io.Reader, data []byte) (*Signature, error)
			(*T) SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*Signature, error)
		Implements (at least 2, both are exported)
			*T : AlgorithmSigner
			*T : Signer


Package-Level Functions (total 126, in which 32 are exported)

	 func BannerDisplayStderr() BannerCallback
		BannerDisplayStderr returns a function that can be used for
		ClientConfig.BannerCallback to display banners on os.Stderr.

	 func Dial(network, addr string, config *ClientConfig) (*Client, error)
		Dial starts a client connection to the given SSH server. It is a
		convenience function that connects to the given network address,
		initiates the SSH handshake, and then sets up a Client.  For access
		to incoming channels and requests, use net.Dial with NewClientConn
		instead.

	 func DiscardRequests(in <-chan *Request)
		DiscardRequests consumes and rejects all requests from the
		passed-in channel.

	 func FingerprintLegacyMD5(pubKey PublicKey) string
		FingerprintLegacyMD5 returns the user presentation of the key's
		fingerprint as described by RFC 4716 section 4.

	 func FingerprintSHA256(pubKey PublicKey) string
		FingerprintSHA256 returns the user presentation of the key's
		fingerprint as unpadded base64 encoded sha256 hash.
		This format was introduced from OpenSSH 6.8.
		https://www.openssh.com/txt/release-6.8
		https://tools.ietf.org/html/rfc4648#section-3.2 (unpadded base64 encoding)

	 func FixedHostKey(key PublicKey) HostKeyCallback
		FixedHostKey returns a function for use in
		ClientConfig.HostKeyCallback to accept only a specific host key.

	 func GSSAPIWithMICAuthMethod(gssAPIClient GSSAPIClient, target string) AuthMethod
		GSSAPIWithMICAuthMethod is an AuthMethod with "gssapi-with-mic" authentication.
		See RFC 4462 section 3
		gssAPIClient is implementation of the GSSAPIClient interface, see the definition of the interface for details.
		target is the server host you want to log in to.

	 func InsecureIgnoreHostKey() HostKeyCallback
		InsecureIgnoreHostKey returns a function that can be used for
		ClientConfig.HostKeyCallback to accept any host key. It should
		not be used for production code.

	 func KeyboardInteractive(challenge KeyboardInteractiveChallenge) AuthMethod
		KeyboardInteractive returns an AuthMethod using a prompt/response
		sequence controlled by the server.

	 func Marshal(msg interface{}) []byte
		Marshal serializes the message in msg to SSH wire format.  The msg
		argument should be a struct or pointer to struct. If the first
		member has the "sshtype" tag set to a number in decimal, that
		number is prepended to the result. If the last of member has the
		"ssh" tag set to "rest", its contents are appended to the output.

	 func MarshalAuthorizedKey(key PublicKey) []byte
		MarshalAuthorizedKey serializes key for inclusion in an OpenSSH
		authorized_keys file. The return value ends with newline.

	 func NewCertSigner(cert *Certificate, signer Signer) (Signer, error)
		NewCertSigner returns a Signer that signs with the given Certificate, whose
		private key is held by signer. It returns an error if the public key in cert
		doesn't match the key used by signer.

	 func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client
		NewClient creates a Client on top of the given connection.

	 func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan NewChannel, <-chan *Request, error)
		NewClientConn establishes an authenticated SSH connection using c
		as the underlying transport.  The Request and NewChannel channels
		must be serviced or the connection will hang.

	 func NewPublicKey(key interface{}) (PublicKey, error)
		NewPublicKey takes an *rsa.PublicKey, *dsa.PublicKey, *ecdsa.PublicKey,
		or ed25519.PublicKey returns a corresponding PublicKey instance.
		ECDSA keys must use P-256, P-384 or P-521.

	 func NewServerConn(c net.Conn, config *ServerConfig) (*ServerConn, <-chan NewChannel, <-chan *Request, error)
		NewServerConn starts a new SSH server with c as the underlying
		transport.  It starts with a handshake and, if the handshake is
		unsuccessful, it closes the connection and returns an error.  The
		Request and NewChannel channels must be serviced, or the connection
		will hang.

		The returned error may be of type *ServerAuthError for
		authentication errors.

	 func NewSignerFromKey(key interface{}) (Signer, error)
		NewSignerFromKey takes an *rsa.PrivateKey, *dsa.PrivateKey,
		*ecdsa.PrivateKey or any other crypto.Signer and returns a
		corresponding Signer instance. ECDSA keys must use P-256, P-384 or
		P-521. DSA keys must use parameter size L1024N160.

	 func NewSignerFromSigner(signer crypto.Signer) (Signer, error)
		NewSignerFromSigner takes any crypto.Signer implementation and
		returns a corresponding Signer interface. This can be used, for
		example, with keys kept in hardware modules.

	 func ParseAuthorizedKey(in []byte) (out PublicKey, comment string, options []string, rest []byte, err error)
		ParseAuthorizedKeys parses a public key from an authorized_keys
		file used in OpenSSH according to the sshd(8) manual page.

	 func ParseDSAPrivateKey(der []byte) (*dsa.PrivateKey, error)
		ParseDSAPrivateKey returns a DSA private key from its ASN.1 DER encoding, as
		specified by the OpenSSL DSA man page.

	 func ParseKnownHosts(in []byte) (marker string, hosts []string, pubKey PublicKey, comment string, rest []byte, err error)
		ParseKnownHosts parses an entry in the format of the known_hosts file.

		The known_hosts format is documented in the sshd(8) manual page. This
		function will parse a single entry from in. On successful return, marker
		will contain the optional marker value (i.e. "cert-authority" or "revoked")
		or else be empty, hosts will contain the hosts that this entry matches,
		pubKey will contain the public key and comment will contain any trailing
		comment at the end of the line. See the sshd(8) manual page for the various
		forms that a host string can take.

		The unparsed remainder of the input will be returned in rest. This function
		can be called repeatedly to parse multiple entries.

		If no entries were found in the input then err will be io.EOF. Otherwise a
		non-nil err value indicates a parse error.

	 func ParsePrivateKey(pemBytes []byte) (Signer, error)
		ParsePrivateKey returns a Signer from a PEM encoded private key. It supports
		the same keys as ParseRawPrivateKey. If the private key is encrypted, it
		will return a PassphraseMissingError.

	 func ParsePrivateKeyWithPassphrase(pemBytes, passphrase []byte) (Signer, error)
		ParsePrivateKeyWithPassphrase returns a Signer from a PEM encoded private
		key and passphrase. It supports the same keys as
		ParseRawPrivateKeyWithPassphrase.

	 func ParsePublicKey(in []byte) (out PublicKey, err error)
		ParsePublicKey parses an SSH public key formatted for use in
		the SSH wire protocol according to RFC 4253, section 6.6.

	 func ParseRawPrivateKey(pemBytes []byte) (interface{}, error)
		ParseRawPrivateKey returns a private key from a PEM encoded private key. It
		supports RSA (PKCS#1), PKCS#8, DSA (OpenSSL), and ECDSA private keys. If the
		private key is encrypted, it will return a PassphraseMissingError.

	 func ParseRawPrivateKeyWithPassphrase(pemBytes, passphrase []byte) (interface{}, error)
		ParseRawPrivateKeyWithPassphrase returns a private key decrypted with
		passphrase from a PEM encoded private key. If the passphrase is wrong, it
		will return x509.IncorrectPasswordError.

	 func Password(secret string) AuthMethod
		Password returns an AuthMethod using the given password.

	 func PasswordCallback(prompt func() (secret string, err error)) AuthMethod
		PasswordCallback returns an AuthMethod that uses a callback for
		fetching a password.

	 func PublicKeys(signers ...Signer) AuthMethod
		PublicKeys returns an AuthMethod that uses the given key
		pairs.

	 func PublicKeysCallback(getSigners func() (signers []Signer, err error)) AuthMethod
		PublicKeysCallback returns an AuthMethod that runs the given
		function to obtain a list of key pairs.

	 func RetryableAuthMethod(auth AuthMethod, maxTries int) AuthMethod
		RetryableAuthMethod is a decorator for other auth methods enabling them to
		be retried up to maxTries before considering that AuthMethod itself failed.
		If maxTries is <= 0, will retry indefinitely

		This is useful for interactive clients using challenge/response type
		authentication (e.g. Keyboard-Interactive, Password, etc) where the user
		could mistype their response resulting in the server issuing a
		SSH_MSG_USERAUTH_FAILURE (rfc4252 #8 [password] and rfc4256 #3.4
		[keyboard-interactive]); Without this decorator, the non-retryable
		AuthMethod would be removed from future consideration, and never tried again
		(and so the user would never be able to retry their entry).

	 func Unmarshal(data []byte, out interface{}) error
		Unmarshal parses data in SSH wire format into a structure. The out
		argument should be a pointer to struct. If the first member of the
		struct has the "sshtype" tag set to a '|'-separated set of numbers
		in decimal, the packet must start with one of those numbers. In
		case of error, Unmarshal returns a ParseError or
		UnexpectedMessageError.

	/* 94 unexporteds ... *//* 94 unexporteds: */
	 func appendBool(buf []byte, b bool) []byte
	 func appendInt(buf []byte, n int) []byte
	 func appendString(buf []byte, s string) []byte
	 func appendU16(buf []byte, n uint16) []byte
	 func appendU32(buf []byte, n uint32) []byte
	 func appendU64(buf []byte, n uint64) []byte
	 func buildDataSignedForAuth(sessionID []byte, req userAuthRequestMsg, algo, pubKey []byte) []byte
		buildDataSignedForAuth returns the data that is signed in order to prove
		possession of a private key. See RFC 4252, section 7.

	 func buildMIC(sessionID string, username string, service string, authMethod string) []byte
		See RFC 4462 section 3.6.

	 func certToPrivAlgo(algo string) string
		certToPrivAlgo returns the underlying algorithm for a certificate algorithm.
		Panics if a non-certificate algorithm is passed.

	 func checkDSAParams(param *dsa.Parameters) error
	 func checkOpenSSHKeyPadding(pad []byte) error
	 func checkSourceAddress(addr net.Addr, sourceAddrs string) error
	 func confirmKeyAck(key PublicKey, c packetConn) (bool, error)
	 func contains(list []string, e string) bool
	 func containsMethod(methods []string, method string) bool
	 func decode(packet []byte) (interface{}, error)
		Decode a packet into its corresponding message.

	 func dup(src []byte) []byte
	 func ecHash(curve elliptic.Curve) crypto.Hash
		ecHash returns the hash to match the given elliptic curve, see RFC
		5656, section 6.2.1

	 func encryptedBlock(block *pem.Block) bool
		encryptedBlock tells whether a private key is
		encrypted by examining its Proc-Type header
		for a mention of ENCRYPTED
		according to RFC 1421 Section 4.6.1.1.

	 func exchangeVersions(rw io.ReadWriter, versionLine []byte) (them []byte, err error)
		Sends and receives a version line.  The versionLine string should
		be US ASCII, start with "SSH-2.0-", and should not include a
		newline. exchangeVersions returns the other side's version line.

	 func fieldError(t reflect.Type, field int, problem string) error
	 func findAgreedAlgorithms(isClient bool, clientKexInit, serverKexInit *kexInitMsg) (algs *algorithms, err error)
	 func findCommon(what string, client []string, server []string) (common string, err error)
	 func generateKeyMaterial(out, tag []byte, r *kexResult)
		generateKeyMaterial fills out with key material generated from tag, K, H
		and sessionId, as specified in RFC 4253, section 7.2.

	 func gssExchangeToken(gssapiConfig *GSSAPIWithMICConfig, firstToken []byte, s *connection, sessionID []byte, userAuthReq userAuthRequestMsg) (authErr error, perms *Permissions, err error)
	 func handleAuthResponse(c packetConn) (authResult, []string, error)
		handleAuthResponse returns whether the preceding authentication request succeeded
		along with a list of remaining authentication methods to try next and
		an error if an unexpected response was received.

	 func handleBannerResponse(c packetConn, packet []byte) error
	 func init()
	 func init()
	 func intLength(n *big.Int) int
	 func isAcceptableAlgo(algo string) bool
	 func isBrokenOpenSSHVersion(versionStr string) bool
		isBrokenOpenSSHVersion returns true if the given version string
		specifies a version of OpenSSH that is known to have a bug in port
		forwarding.

	 func marshalInt(to []byte, n *big.Int) []byte
	 func marshalString(to []byte, s []byte) []byte
	 func marshalStringList(namelist []string) []byte
	 func marshalStruct(out []byte, msg interface{}) []byte
	 func marshalTuples(tups map[string]string) []byte
		serialize a map of critical options or extensions
		issue #10569 - per [PROTOCOL.certkeys] and SSH implementation,
		we need two length prefixes for a non-empty string value

	 func marshalUint32(to []byte, n uint32) []byte
	 func marshalUint64(to []byte, n uint64) []byte
	 func maxUInt32(a, b int) uint32
	 func min(a uint32, b int) uint32
	 func newAESCBCCipher(key, iv, macKey []byte, algs directionAlgorithms) (packetCipher, error)
	 func newAESCTR(key, iv []byte) (cipher.Stream, error)
	 func newBuffer() *buffer
		newBuffer returns an empty buffer that is not closed.

	 func newCBCCipher(c cipher.Block, key, iv, macKey []byte, algs directionAlgorithms) (packetCipher, error)
	 func newChaCha20Cipher(key, unusedIV, unusedMACKey []byte, unusedAlgs directionAlgorithms) (packetCipher, error)
	 func newClientTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ClientConfig, dialAddr string, addr net.Addr) *handshakeTransport
	 func newCond() *sync.Cond
		newCond is a helper to hide the fact that there is no usable zero
		value for sync.Cond.

	 func newDSAPrivateKey(key *dsa.PrivateKey) (Signer, error)
	 func newGCMCipher(key, iv, unusedMacKey []byte, unusedAlgs directionAlgorithms) (packetCipher, error)
	 func newHandshakeTransport(conn keyingTransport, config *Config, clientVersion, serverVersion []byte) *handshakeTransport
	 func newMux(p packetConn) *mux
		newMux returns a mux that runs over the given connection.

	 func newPacketCipher(d direction, algs directionAlgorithms, kex *kexResult) (packetCipher, error)
		setupKeys sets the cipher and MAC keys from kex.K, kex.H and sessionId, as
		described in RFC 4253, section 6.4. direction should either be serverKeys
		(to setup server->client keys) or clientKeys (for client->server keys).

	 func newRC4(key, iv []byte) (cipher.Stream, error)
	 func newServerTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ServerConfig) *handshakeTransport
	 func newSession(ch Channel, reqs <-chan *Request) (*Session, error)
		newSession returns a new interactive session on the remote host.

	 func newTransport(rwc io.ReadWriteCloser, rand io.Reader, isClient bool) *transport
	 func newTripleDESCBCCipher(key, iv, macKey []byte, algs directionAlgorithms) (packetCipher, error)
	 func parseAuthorizedKey(in []byte) (out PublicKey, comment string, err error)
		parseAuthorizedKey parses a public key in OpenSSH authorized_keys format
		(see sshd(8) manual page) once the options and key type fields have been
		removed.

	 func parseCert(in []byte, privAlgo string) (*Certificate, error)
	 func parseDSA(in []byte) (out PublicKey, rest []byte, err error)
		parseDSA parses an DSA key according to RFC 4253, section 6.6.

	 func parseECDSA(in []byte) (out PublicKey, rest []byte, err error)
		parseECDSA parses an ECDSA key according to RFC 5656, section 3.1.

	 func parseED25519(in []byte) (out PublicKey, rest []byte, err error)
	 func parseError(tag uint8) error
		parseError results from a malformed SSH message.

	 func parseGSSAPIPayload(payload []byte) (*userAuthRequestGSSAPI, error)
	 func parseInt(in []byte) (out *big.Int, rest []byte, ok bool)
	 func parseNameList(in []byte) (out []string, rest []byte, ok bool)
	 func parseOpenSSHPrivateKey(key []byte, decrypt openSSHDecryptFunc) (crypto.PrivateKey, error)
		parseOpenSSHPrivateKey parses an OpenSSH private key, using the decrypt
		function to unwrap the encrypted portion. unencryptedOpenSSHKey can be used
		as the decrypt function to parse an unencrypted private key. See
		https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.key.

	 func parsePubKey(in []byte, algo string) (pubKey PublicKey, rest []byte, err error)
		parsePubKey parses a public key of the given algorithm.
		Use ParsePublicKey for keys with prepended algorithm.

	 func parseRSA(in []byte) (out PublicKey, rest []byte, err error)
		parseRSA parses an RSA key according to RFC 4253, section 6.6.

	 func parseSignature(in []byte) (out *Signature, rest []byte, ok bool)
	 func parseSignatureBody(in []byte) (out *Signature, rest []byte, ok bool)
	 func parseSKECDSA(in []byte) (out PublicKey, rest []byte, err error)
	 func parseSKEd25519(in []byte) (out PublicKey, rest []byte, err error)
	 func parseString(in []byte) (out, rest []byte, ok bool)
	 func parseTCPAddr(addr string, port uint32) (*net.TCPAddr, error)
		parseTCPAddr parses the originating address from the remote into a *net.TCPAddr.

	 func parseTuples(in []byte) (map[string]string, error)
		issue #10569 - per [PROTOCOL.certkeys] and SSH implementation,
		we need two length prefixes for a non-empty option value

	 func parseUint32(in []byte) (uint32, []byte, bool)
	 func parseUint64(in []byte) (uint64, []byte, bool)
	 func passphraseProtectedOpenSSHKey(passphrase []byte) openSSHDecryptFunc
	 func readVersion(r io.Reader) ([]byte, error)
		Read version string as specified by RFC 4253, section 4.2.

	 func signAndMarshal(k Signer, rand io.Reader, data []byte) ([]byte, error)
		signAndMarshal signs the data with the appropriate algorithm,
		and serializes the result in SSH wire format.

	 func streamCipherMode(skip int, createFunc func(key, iv []byte) (cipher.Stream, error)) func(key, iv []byte, macKey []byte, algs directionAlgorithms) (packetCipher, error)
	 func stringLength(n int) int
	 func supportedEllipticCurve(curve elliptic.Curve) bool
	 func typeTags(structType reflect.Type) (tags []byte)
		typeTags returns the possible type bytes for the given reflect.Type, which
		should be a struct. The possible values are separated by a '|' character.

	 func unencryptedOpenSSHKey(cipherName, kdfName, kdfOpts string, privKeyBlock []byte) ([]byte, error)
	 func unexpectedMessageError(expected, got uint8) error
		unexpectedMessageError results when the SSH message that we received didn't
		match what we wanted.

	 func unmarshalECKey(curve elliptic.Curve, pubkey []byte) (x, y *big.Int, err error)
		unmarshalECKey parses and checks an EC key.

	 func validateECPublicKey(curve elliptic.Curve, x, y *big.Int) bool
		validateECPublicKey checks that the point is a valid public key for
		the given curve. See [SEC1], 3.2.2

	 func validateKey(key PublicKey, user string, c packetConn) (bool, error)
		validateKey validates the key provided is acceptable to the server.

	 func verifyHostKeySignature(hostKey PublicKey, result *kexResult) error
		verifyHostKeySignature verifies the host key obtained in the key
		exchange.

	 func writeInt(w io.Writer, n *big.Int)
	 func writeString(w io.Writer, s []byte)
Package-Level Variables (total 30, in which 1 are exported)

	  var ErrNoAuth error
		ErrNoAuth is the error value returned if no
		authentication method has been passed yet. This happens as a normal
		part of the authentication loop, since the client first tries
		'none' authentication to discover available methods.
		It is returned in ServerAuthError.Errors from NewServerConn.

	/* 29 unexporteds ... *//* 29 unexporteds: */
	  var bigIntType reflect.Type
	  var bigOne *big.Int
	  var certAlgoNames map[string]string
	  var cipherModes map[string]*cipherMode
		cipherModes documents properties of supported ciphers. Ciphers not included
		are not supported and will not be negotiated, even if explicitly requested in
		ClientConfig.Crypto.Ciphers.

	  var clientKeys direction
	  var comma []byte
	  var curve25519Zeros [32]byte
		curve25519Zeros is just an array of 32 zero bytes so that we have something
		convenient to compare against in order to reject curve25519 points with the
		wrong order.

	  var emptyNameList []string
	  var errDecidedAlready error
	  var errShortRead error
	  var errUndecided error
	  var globalOff uint32
		When debugging, each new chanList instantiation has a different
		offset.

	  var hashFuncs map[string]crypto.Hash
		hashFuncs keeps the mapping of supported algorithms to their respective
		hashes needed for signature verification.

	  var kexAlgoMap map[string]kexAlgorithm
	  var krb5Mesh asn1.ObjectIdentifier
		OpenSSH supports Kerberos V5 mechanism only for GSS-API authentication,
		so we also support the krb5 mechanism only.
		See RFC 1964 section 1.

	  var krb5OID []byte
	  var macModes map[string]*macMode
	  var packetTypeNames map[byte]string
	  var portRandomizer *rand.Rand
	  var preferredCiphers []string
		preferredCiphers specifies the default preference for ciphers.

	  var preferredKexAlgos []string
		preferredKexAlgos specifies the default preference for key-exchange algorithms
		in preference order.

	  var serverForbiddenKexAlgos map[string]struct{}
		serverForbiddenKexAlgos contains key exchange algorithms, that are forbidden
		for the server half.

	  var serverKeys direction
	  var signals map[Signal]int
	  var supportedCiphers []string
		supportedCiphers lists ciphers we support but might not recommend.

	  var supportedCompressions []string
	  var supportedHostKeyAlgos []string
		supportedHostKeyAlgos specifies the supported host-key algorithms (i.e. methods
		of authenticating servers) in preference order.

	  var supportedKexAlgos []string
		supportedKexAlgos specifies the supported key-exchange algorithms in
		preference order.

	  var supportedMACs []string
		supportedMACs specifies a default set of MAC algorithms in preference order.
		This is based on RFC 4253, section 6.4, but with hmac-md5 variants removed
		because they have reached the end of their useful life.


Package-Level Constants (total 181, in which 94 are exported)

	const CertAlgoDSAv01 = "ssh-dss-cert-v01@openssh.com"
		These constants from [PROTOCOL.certkeys] represent the algorithm names
		for certificate types supported by this package.

	const CertAlgoECDSA256v01 = "ecdsa-sha2-nistp256-cert-v01@openssh.com"
		These constants from [PROTOCOL.certkeys] represent the algorithm names
		for certificate types supported by this package.

	const CertAlgoECDSA384v01 = "ecdsa-sha2-nistp384-cert-v01@openssh.com"
		These constants from [PROTOCOL.certkeys] represent the algorithm names
		for certificate types supported by this package.

	const CertAlgoECDSA521v01 = "ecdsa-sha2-nistp521-cert-v01@openssh.com"
		These constants from [PROTOCOL.certkeys] represent the algorithm names
		for certificate types supported by this package.

	const CertAlgoED25519v01 = "ssh-ed25519-cert-v01@openssh.com"
		These constants from [PROTOCOL.certkeys] represent the algorithm names
		for certificate types supported by this package.

	const CertAlgoRSAv01 = "ssh-rsa-cert-v01@openssh.com"
		These constants from [PROTOCOL.certkeys] represent the algorithm names
		for certificate types supported by this package.

	const CertAlgoSKECDSA256v01 = "sk-ecdsa-sha2-nistp256-cert-v01@openssh.com"
		These constants from [PROTOCOL.certkeys] represent the algorithm names
		for certificate types supported by this package.

	const CertAlgoSKED25519v01 = "sk-ssh-ed25519-cert-v01@openssh.com"
		These constants from [PROTOCOL.certkeys] represent the algorithm names
		for certificate types supported by this package.

	const CertTimeInfinity = 18446744073709551615
		CertTimeInfinity can be used for OpenSSHCertV01.ValidBefore to indicate that
		a certificate does not expire.

	const ConnectionFailed RejectionReason = 2
	const CS7 = 90
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const CS8 = 91
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ECHO = 53
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ECHOCTL = 60
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ECHOE = 54
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ECHOK = 55
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ECHOKE = 61
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ECHONL = 56
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const HostCert = 2
		Certificate types distinguish between host and user
		certificates. The values can be set in the CertType field of
		Certificate.

	const ICANON = 51
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ICRNL = 36
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const IEXTEN = 59
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const IGNCR = 35
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const IGNPAR = 30
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const IMAXBEL = 41
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const INLCR = 34
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const INPCK = 32
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ISIG = 50
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ISTRIP = 33
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const IUCLC = 37
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const IXANY = 39
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const IXOFF = 40
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const IXON = 38
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const KeyAlgoDSA = "ssh-dss"
		These constants represent the algorithm names for key types supported by this
		package.

	const KeyAlgoECDSA256 = "ecdsa-sha2-nistp256"
		These constants represent the algorithm names for key types supported by this
		package.

	const KeyAlgoECDSA384 = "ecdsa-sha2-nistp384"
		These constants represent the algorithm names for key types supported by this
		package.

	const KeyAlgoECDSA521 = "ecdsa-sha2-nistp521"
		These constants represent the algorithm names for key types supported by this
		package.

	const KeyAlgoED25519 = "ssh-ed25519"
		These constants represent the algorithm names for key types supported by this
		package.

	const KeyAlgoRSA = "ssh-rsa"
		These constants represent the algorithm names for key types supported by this
		package.

	const KeyAlgoSKECDSA256 = "sk-ecdsa-sha2-nistp256@openssh.com"
		These constants represent the algorithm names for key types supported by this
		package.

	const KeyAlgoSKED25519 = "sk-ssh-ed25519@openssh.com"
		These constants represent the algorithm names for key types supported by this
		package.

	const NOFLSH = 57
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const OCRNL = 73
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const OLCUC = 71
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ONLCR = 72
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ONLRET = 75
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const ONOCR = 74
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const OPOST = 70
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const PARENB = 92
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const PARMRK = 31
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const PARODD = 93
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const PENDIN = 62
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const Prohibited RejectionReason = 1
	const ResourceShortage RejectionReason = 4
	const SIGABRT Signal = "ABRT"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SigAlgoRSA = "ssh-rsa"
		These constants represent non-default signature algorithms that are supported
		as algorithm parameters to AlgorithmSigner.SignWithAlgorithm methods. See
		[PROTOCOL.agent] section 4.5.1 and
		https://tools.ietf.org/html/draft-ietf-curdle-rsa-sha2-10

	const SigAlgoRSASHA2256 = "rsa-sha2-256"
		These constants represent non-default signature algorithms that are supported
		as algorithm parameters to AlgorithmSigner.SignWithAlgorithm methods. See
		[PROTOCOL.agent] section 4.5.1 and
		https://tools.ietf.org/html/draft-ietf-curdle-rsa-sha2-10

	const SigAlgoRSASHA2512 = "rsa-sha2-512"
		These constants represent non-default signature algorithms that are supported
		as algorithm parameters to AlgorithmSigner.SignWithAlgorithm methods. See
		[PROTOCOL.agent] section 4.5.1 and
		https://tools.ietf.org/html/draft-ietf-curdle-rsa-sha2-10

	const SIGALRM Signal = "ALRM"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGFPE Signal = "FPE"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGHUP Signal = "HUP"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGILL Signal = "ILL"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGINT Signal = "INT"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGKILL Signal = "KILL"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGPIPE Signal = "PIPE"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGQUIT Signal = "QUIT"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGSEGV Signal = "SEGV"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGTERM Signal = "TERM"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGUSR1 Signal = "USR1"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const SIGUSR2 Signal = "USR2"
		POSIX signals as listed in RFC 4254 Section 6.10.

	const TOSTOP = 58
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const TTY_OP_ISPEED = 128
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const TTY_OP_OSPEED = 129
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const UnknownChannelType RejectionReason = 3
	const UserCert = 1
		Certificate types distinguish between host and user
		certificates. The values can be set in the CertType field of
		Certificate.

	const VDISCARD = 18
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VDSUSP = 11
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VEOF = 5
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VEOL = 6
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VEOL2 = 7
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VERASE = 3
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VFLUSH = 15
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VINTR = 1
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VKILL = 4
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VLNEXT = 14
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VQUIT = 2
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VREPRINT = 12
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VSTART = 8
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VSTATUS = 17
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VSTOP = 9
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VSUSP = 10
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VSWTCH = 16
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const VWERASE = 13
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	const XCASE = 52
		POSIX terminal mode flags as listed in RFC 4254 Section 8.

	/* 87 unexporteds ... *//* 87 unexporteds: */
	const aes128cbcID = "aes128-cbc"
	const authFailure authResult = 0
	const authPartialSuccess authResult = 1
	const authSuccess authResult = 2
	const cbcMinPacketSize = 16
	const cbcMinPacketSizeMultiple = 8
	const cbcMinPaddingSize = 4
	const chacha20Poly1305ID = "chacha20-poly1305@openssh.com"
	const channelInbound channelDirection = 0
	const channelMaxPacket = 32768
		channelMaxPacket contains the maximum number of bytes that will be
		sent in a single packet. As per RFC 4253, section 6.1, 32k is also
		the minimum.

	const channelOutbound channelDirection = 1
	const channelWindowSize = 2097152
		We follow OpenSSH here.

	const chanSize = 16
		chanSize sets the amount of buffering SSH connections. This is
		primarily for testing: setting chanSize=0 uncovers deadlocks more
		quickly.

	const compressionNone = "none"
		These are string constants in the SSH protocol.

	const debugHandshake = false
		debugHandshake, if set, prints messages sent and received.  Key
		exchange messages are printed as if DH were used, so the debug
		messages are wrong when using ECDH.

	const debugMux = false
		debugMux, if set, causes messages in the connection protocol to be
		logged.

	const debugTransport = false
		debugTransport if set, will print packet types as they go over the
		wire. No message decoding is done, to minimize the impact on timing.

	const dhGroupExchangeMaximumBits = 8192
	const dhGroupExchangeMinimumBits = 2048
	const dhGroupExchangePreferredBits = 2048
	const gcmCipherID = "aes128-gcm@openssh.com"
	const gcmTagSize = 16
	const kexAlgoCurve25519SHA256 = "curve25519-sha256@libssh.org"
	const kexAlgoDH14SHA1 = "diffie-hellman-group14-sha1"
	const kexAlgoDH1SHA1 = "diffie-hellman-group1-sha1"
	const kexAlgoDHGEXSHA1 = "diffie-hellman-group-exchange-sha1"
		For the following kex only the client half contains a production
		ready implementation. The server half only consists of a minimal
		implementation to satisfy the automated tests.

	const kexAlgoDHGEXSHA256 = "diffie-hellman-group-exchange-sha256"
	const kexAlgoECDH256 = "ecdh-sha2-nistp256"
	const kexAlgoECDH384 = "ecdh-sha2-nistp384"
	const kexAlgoECDH521 = "ecdh-sha2-nistp521"
	const maxCachedPubKeys = 16
	const maxPacket = 262144
		RFC 4253 section 6.1 defines a minimum packet size of 32768 that implementations
		MUST be able to process (plus a few more kilobytes for padding and mac). The RFC
		indicates implementations SHOULD be able to handle larger packet sizes, but then
		waffles on about reasonable limits.

		OpenSSH caps their maxPacket at 256kB so we choose to do
		the same. maxPacket is also used to ensure that uint32
		length fields do not overflow, so it should remain well
		below 4G.

	const maxVersionStringBytes = 255
		maxVersionStringBytes is the maximum number of bytes that we'll
		accept as a version string. RFC 4253 section 4.2 limits this at 255
		chars

	const minPacketLength = 9
	const minRekeyThreshold uint64 = 256
		If rekeythreshold is too small, we can't make any progress sending
		stuff.

	const msgChannelClose = 97
		See RFC 4254, section 5.3

	const msgChannelData = 94
	const msgChannelEOF = 96
		See RFC 4254, section 5.3

	const msgChannelExtendedData = 95
	const msgChannelFailure = 100
		See RFC 4254, section 5.4.

	const msgChannelOpen = 90
		See RFC 4254, section 5.1.

	const msgChannelOpenConfirm = 91
		See RFC 4254, section 5.1.

	const msgChannelOpenFailure = 92
		See RFC 4254, section 5.1.

	const msgChannelRequest = 98
	const msgChannelSuccess = 99
		See RFC 4254, section 5.4.

	const msgChannelWindowAdjust = 93
		See RFC 4254, section 5.2

	const msgDebug = 4
		These are SSH message type numbers. They are scattered around several
		documents but many were taken from [SSH-PARAMETERS].

	const msgDisconnect = 1
		See RFC 4253, section 11.1.

	const msgGlobalRequest = 80
		See RFC 4254, section 4

	const msgIgnore = 2
		These are SSH message type numbers. They are scattered around several
		documents but many were taken from [SSH-PARAMETERS].

	const msgKexDHGexGroup = 31
		See RFC 4419, section 5.

	const msgKexDHGexInit = 32
	const msgKexDHGexReply = 33
	const msgKexDHGexRequest = 34
	const msgKexDHInit = 30
		Diffie-Helman

	const msgKexDHReply = 31
	const msgKexECDHInit = 30
	const msgKexECDHReply = 31
	const msgKexInit = 20
		See RFC 4253, section 7.1.

	const msgNewKeys = 21
		These are SSH message type numbers. They are scattered around several
		documents but many were taken from [SSH-PARAMETERS].

	const msgRequestFailure = 82
		See RFC 4254, section 4

	const msgRequestSuccess = 81
		See RFC 4254, section 4

	const msgServiceAccept = 6
		See RFC 4253, section 10.

	const msgServiceRequest = 5
		See RFC 4253, section 10.

	const msgUnimplemented = 3
		These are SSH message type numbers. They are scattered around several
		documents but many were taken from [SSH-PARAMETERS].

	const msgUserAuthBanner = 53
		See RFC 4252, section 5.4

	const msgUserAuthFailure = 51
		See RFC 4252, section 5.1

	const msgUserAuthGSSAPIError = 65
		See RFC 4462, section 3.8

	const msgUserAuthGSSAPIErrTok = 64
		See RFC 4462, section 3.9

	const msgUserAuthGSSAPIMIC = 66
	const msgUserAuthGSSAPIResponse = 60
		See RFC 4462, section 3

	const msgUserAuthGSSAPIToken = 61
	const msgUserAuthInfoRequest = 60
		See RFC 4256, section 3.2

	const msgUserAuthInfoResponse = 61
	const msgUserAuthPubKeyOk = 60
		See RFC 4252, section 7

	const msgUserAuthRequest = 50
		See RFC 4252, section 5.

	const msgUserAuthSuccess = 52
		See RFC 4252, section 5.1

	const openSSHPrefix = "OpenSSH_"
	const packageVersion = "SSH-2.0-Go"
	const packetRekeyThreshold = 2147483648
		The protocol uses uint32 for packet counters, so we can't let them
		reach 1<<32.  We will actually read and write more packets than
		this, though: the other side may send more packets, and after we
		hit this limit on writing we will send a few more packets for the
		key exchange itself.

	const packetSizeMultiple = 16 // TODO(huin) this should be determined by the cipher.
	const prefixLen = 5
		prefixLen is the length of the packet prefix that contains the packet length
		and number of padding bytes.

	const serviceSSH = "ssh-connection"
		These are string constants in the SSH protocol.

	const serviceUserAuth = "ssh-userauth"
		These are string constants in the SSH protocol.

	const sourceAddressCriticalOption = "source-address"
	const tripledescbcID = "3des-cbc"
	const tty_OP_END = 0
		POSIX terminal mode flags as listed in RFC 4254 Section 8.