package agent

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

Dependency Relation
	imports 20 packages, and imported by one package


Involved Source Files

	
		Package agent implements the ssh-agent protocol, and provides both
		a client and a server. The client can talk to a standard ssh-agent
		that uses UNIX sockets, and one could implement an alternative
		ssh-agent process using the sample server.

		References:
		 [PROTOCOL.agent]: https://tools.ietf.org/html/draft-miller-ssh-agent-00

	      forward.go
	      keyring.go
	      server.go


Code Examples

	
		package main
		
		import (
			"golang.org/x/crypto/ssh"
			"golang.org/x/crypto/ssh/agent"
			"log"
			"net"
			"os"
		)
		
		func main() {
			// ssh-agent(1) provides a UNIX socket at $SSH_AUTH_SOCK.
			socket := os.Getenv("SSH_AUTH_SOCK")
			conn, err := net.Dial("unix", socket)
			if err != nil {
				log.Fatalf("Failed to open SSH_AUTH_SOCK: %v", err)
			}
		
			agentClient := agent.NewClient(conn)
			config := &ssh.ClientConfig{
				User: "gopher",
				Auth: []ssh.AuthMethod{
					// Use a callback rather than PublicKeys so we only consult the
					// agent once the remote server wants it.
					ssh.PublicKeysCallback(agentClient.Signers),
				},
				HostKeyCallback: ssh.InsecureIgnoreHostKey(),
			}
		
			sshc, err := ssh.Dial("tcp", "localhost:22", config)
			if err != nil {
				log.Fatal(err)
			}
			// Use sshc...
			sshc.Close()
		}




Package-Level Type Names (total 34, in which 6 are exported)


	/* sort exporteds by:  |  */
	
		AddedKey describes an SSH key to be added to an Agent.

		
			
				Certificate, if not nil, is communicated to the agent and will be
				stored with the key.

			
				Comment is an optional, free-form string.

			
				ConfirmBeforeUse, if true, requests that the agent confirm with the
				user before each use of this key.

			
				ConstraintExtensions are the experimental or private-use constraints
				defined by users.

			
				LifetimeSecs, if not zero, is the number of seconds that the
				agent will store the key for.

			
				PrivateKey must be a *rsa.PrivateKey, *dsa.PrivateKey,
				ed25519.PrivateKey or *ecdsa.PrivateKey, which will be inserted into the
				agent.

		
			
		
			func Agent.Add(key AddedKey) error
			func ExtendedAgent.Add(key AddedKey) error
			


	
		Agent represents the capabilities of an ssh-agent.

		
			
				Add adds a private key to the agent.

			
				List returns the identities known to the agent.

			
				Lock locks the agent. Sign and Remove will fail, and List will empty an empty list.

			
				Remove removes all identities with the given public key.

			
				RemoveAll removes all identities.

			
				Sign has the agent sign the data using a protocol 2 key as defined
				in [PROTOCOL.agent] section 2.6.2.

			
				Signers returns signers for all the known keys.

			
				Unlock undoes the effect of Lock

		
			 ExtendedAgent (interface)
			
		
			func NewKeyring() Agent
			func github.com/xanzy/ssh-agent.New() (Agent, net.Conn, error)
		
			func ForwardToAgent(client *ssh.Client, keyring Agent) error
			func ServeAgent(agent Agent, c io.ReadWriter) error


	
		ConstraintExtension describes an optional constraint defined by users.

		
			
				ExtensionDetails contains the actual content of the extended
				constraint.

			
				ExtensionName consist of a UTF-8 string suffixed by the
				implementation domain following the naming scheme defined
				in Section 4.2 of [RFC4251], e.g.  "foo@example.com".

		
			


	

		
			
				Add adds a private key to the agent.

			
				Extension processes a custom extension request. Standard-compliant agents are not
				required to support any extensions, but this method allows agents to implement
				vendor-specific methods or add experimental features. See [PROTOCOL.agent] section 4.7.
				If agent extensions are unsupported entirely this method MUST return an
				ErrExtensionUnsupported error. Similarly, if just the specific extensionType in
				the request is unsupported by the agent then ErrExtensionUnsupported MUST be
				returned.

				In the case of success, since [PROTOCOL.agent] section 4.7 specifies that the contents
				of the response are unspecified (including the type of the message), the complete
				response will be returned as a []byte slice, including the "type" byte of the message.

			
				List returns the identities known to the agent.

			
				Lock locks the agent. Sign and Remove will fail, and List will empty an empty list.

			
				Remove removes all identities with the given public key.

			
				RemoveAll removes all identities.

			
				Sign has the agent sign the data using a protocol 2 key as defined
				in [PROTOCOL.agent] section 2.6.2.

			
				SignWithFlags signs like Sign, but allows for additional flags to be sent/received

			
				Signers returns signers for all the known keys.

			
				Unlock undoes the effect of Lock

		
			
		
			 T : Agent
		
			func NewClient(rw io.ReadWriter) ExtendedAgent


	
		Key represents a protocol 2 public key as defined in
		[PROTOCOL.agent], section 2.5.2.

		
			Blob []byte
			Comment string
			Format string
		
			
				Marshal returns key blob to satisfy the ssh.PublicKey interface.

			
				String returns the storage form of an agent key with the format, base64
				encoded serialized key, and the comment if it is not empty.

			
				Type returns the public key type.

			
				Verify satisfies the ssh.PublicKey interface.

		
			*T : golang.org/x/crypto/ssh.PublicKey
			*T : expvar.Var
			*T : fmt.Stringer
			
		
			func Agent.List() ([]*Key, error)
			func ExtendedAgent.List() ([]*Key, error)
			
		
			


	
		SignatureFlags represent additional flags that can be passed to the signature
		requests an defined in [PROTOCOL.agent] section 4.5.1.

		
			func ExtendedAgent.SignWithFlags(key ssh.PublicKey, data []byte, flags SignatureFlags) (*ssh.Signature, error)
		
			const SignatureFlagReserved
			const SignatureFlagRsaSha256
			const SignatureFlagRsaSha512


	


Package-Level Functions (total 22, in which 6 are exported)


	
		ForwardToAgent routes authentication requests to the given keyring.


	
		ForwardToRemote routes authentication requests to the ssh-agent
		process serving on the given unix socket.


	
		NewClient returns an Agent that talks to an ssh-agent process over
		the given connection.


	
		NewKeyring returns an Agent that holds keys in memory.  It is safe
		for concurrent use by multiple goroutines.


	
		RequestAgentForwarding sets up agent forwarding for the session.
		ForwardToAgent or ForwardToRemote should be called to route
		the authentication requests.


	
		ServeAgent serves the agent protocol on the given connection. It
		returns when an I/O error occurs.


	


Package-Level Variables (total 2, in which 1 are exported)


	
		ErrExtensionUnsupported indicates that an extension defined in
		[PROTOCOL.agent] section 4.7 is unsupported by the agent. Specifically this
		error indicates that the agent returned a standard SSH_AGENT_FAILURE message
		as the result of a SSH_AGENTC_EXTENSION request. Note that the protocol
		specification (and therefore this error) does not distinguish between a
		specific extension being unsupported and extensions being unsupported entirely.


	


Package-Level Constants (total 28, in which 3 are exported)


	
		SignatureFlag values as defined in [PROTOCOL.agent] section 5.3.


	
		SignatureFlag values as defined in [PROTOCOL.agent] section 5.3.


	
		SignatureFlag values as defined in [PROTOCOL.agent] section 5.3.