PROTOCOL

This documents OpenSSH's deviations and extensions to the published SSH
protocol.

Note that OpenSSH's sftp and sftp-server implement revision 3 of the SSH
filexfer protocol described in:

https://www.openssh.com/txt/draft-ietf-secsh-filexfer-02.txt

Newer versions of the draft will not be supported, though some features
are individually implemented as extensions described below.

The protocol used by OpenSSH's ssh-agent is described in the file
PROTOCOL.agent

1. Transport protocol changes

1.1. transport: Protocol 2 MAC algorithm "umac-64@openssh.com"

This is a new transport-layer MAC method using the UMAC algorithm
(rfc4418). This method is identical to the "umac-64" method documented
in:

https://www.openssh.com/txt/draft-miller-secsh-umac-01.txt

1.2. transport: Protocol 2 compression algorithm "zlib@openssh.com"

This transport-layer compression method uses the zlib compression
algorithm (identical to the "zlib" method in rfc4253), but delays the
start of compression until after authentication has completed. This
avoids exposing compression code to attacks from unauthenticated users.

The method is documented in:

https://www.openssh.com/txt/draft-miller-secsh-compression-delayed-00.txt

1.3. transport: New public key algorithms "ssh-rsa-cert-v01@openssh.com",
     "ssh-dsa-cert-v01@openssh.com",
     "ecdsa-sha2-nistp256-cert-v01@openssh.com",
     "ecdsa-sha2-nistp384-cert-v01@openssh.com" and
     "ecdsa-sha2-nistp521-cert-v01@openssh.com"

OpenSSH introduces new public key algorithms to support certificate
authentication for users and host keys. These methods are documented
in the file PROTOCOL.certkeys

1.4. transport: Elliptic Curve cryptography

OpenSSH supports ECC key exchange and public key authentication as
specified in RFC5656. Only the ecdsa-sha2-nistp256, ecdsa-sha2-nistp384
and ecdsa-sha2-nistp521 curves over GF(p) are supported. Elliptic
curve points encoded using point compression are NOT accepted or
generated.

1.5 transport: Protocol 2 Encrypt-then-MAC MAC algorithms

OpenSSH supports MAC algorithms, whose names contain "-etm", that
perform the calculations in a different order to that defined in RFC
4253. These variants use the so-called "encrypt then MAC" ordering,
calculating the MAC over the packet ciphertext rather than the
plaintext. This ordering closes a security flaw in the SSH transport
protocol, where decryption of unauthenticated ciphertext provided a
"decryption oracle" that could, in conjunction with cipher flaws, reveal
session plaintext.

Specifically, the "-etm" MAC algorithms modify the transport protocol
to calculate the MAC over the packet ciphertext and to send the packet
length unencrypted. This is necessary for the transport to obtain the
length of the packet and location of the MAC tag so that it may be
verified without decrypting unauthenticated data.

As such, the MAC covers:

      mac = MAC(key, sequence_number || packet_length || encrypted_packet)

where "packet_length" is encoded as a uint32 and "encrypted_packet"
contains:

      byte      padding_length
      byte[n1]  payload; n1 = packet_length - padding_length - 1
      byte[n2]  random padding; n2 = padding_length

1.6 transport: AES-GCM

OpenSSH supports the AES-GCM algorithm as specified in RFC 5647.
Because of problems with the specification of the key exchange
the behaviour of OpenSSH differs from the RFC as follows:

AES-GCM is only negotiated as the cipher algorithms
"aes128-gcm@openssh.com" or "aes256-gcm@openssh.com" and never as
an MAC algorithm. Additionally, if AES-GCM is selected as the cipher
the exchanged MAC algorithms are ignored and there doesn't have to be
a matching MAC.

1.7 transport: chacha20-poly1305@openssh.com authenticated encryption

OpenSSH supports authenticated encryption using ChaCha20 and Poly1305
as described in PROTOCOL.chacha20poly1305.

1.8 transport: curve25519-sha256@libssh.org key exchange algorithm

OpenSSH supports the use of ECDH in Curve25519 for key exchange as
described at:
http://git.libssh.org/users/aris/libssh.git/plain/doc/curve25519-sha256@libssh.org.txt?h=curve25519

This is identical to curve25519-sha256 as later published in RFC8731.

1.9 transport: ping facility

OpenSSH implements a transport level ping message SSH2_MSG_PING
and a corresponding SSH2_MSG_PONG reply.

#define SSH2_MSG_PING	192
#define SSH2_MSG_PONG	193

The ping message is simply:

	byte		SSH_MSG_PING
	string		data

The reply copies the data (which may be the empty string) from the
ping:

	byte		SSH_MSG_PONG
	string		data

Replies are sent in order. They are sent immediately except when rekeying
is in progress, in which case they are queued until rekeying completes.

The server advertises support for these messages using the
SSH2_MSG_EXT_INFO mechanism (RFC8308), with the following message:

	string		"ping@openssh.com"
	string		"0" (version)

The ping/reply message is implemented at the transport layer rather
than as a named global or channel request to allow pings with very
short packet lengths, which would not be possible with other
approaches.

1.9 transport: strict key exchange extension

OpenSSH supports a number of transport-layer hardening measures under
a "strict KEX" feature. This feature is signalled similarly to the
RFC8308 ext-info feature: by including a additional algorithm in the
initiial SSH2_MSG_KEXINIT kex_algorithms field. The client may append
"kex-strict-c-v00@openssh.com" to its kex_algorithms and the server
may append "kex-strict-s-v00@openssh.com". These pseudo-algorithms
are only valid in the initial SSH2_MSG_KEXINIT and MUST be ignored
if they are present in subsequent SSH2_MSG_KEXINIT packets.

When an endpoint that supports this extension observes this algorithm
name in a peer's KEXINIT packet, it MUST make the following changes to
the the protocol:

a) During initial KEX, terminate the connection if any unexpected or
   out-of-sequence packet is received. This includes terminating the
   connection if the first packet received is not SSH2_MSG_KEXINIT.
   Unexpected packets for the purpose of strict KEX include messages
   that are otherwise valid at any time during the connection such as
   SSH2_MSG_DEBUG and SSH2_MSG_IGNORE.
b) After sending or receiving a SSH2_MSG_NEWKEYS message, reset the
   packet sequence number to zero. This behaviour persists for the
   duration of the connection (i.e. not just the first
   SSH2_MSG_NEWKEYS).

1.10 transport: SSH2_MSG_EXT_INFO during user authentication

This protocol extension allows the SSH2_MSG_EXT_INFO to be sent
during user authentication. RFC8308 does allow a second
SSH2_MSG_EXT_INFO notification, but it may only be sent at the end
of user authentication and this is too late to signal per-user
server signature algorithms.

Support for receiving the SSH2_MSG_EXT_INFO message during user
authentication is signalled by the client including a
"ext-info-in-auth@openssh.com" key via its initial SSH2_MSG_EXT_INFO
set after the SSH2_MSG_NEWKEYS message.

A server that supports this extension MAY send a second
SSH2_MSG_EXT_INFO message any time after the client's first
SSH2_MSG_USERAUTH_REQUEST, regardless of whether it succeed or fails.
The client SHOULD be prepared to update the server-sig-algs that
it received during an earlier SSH2_MSG_EXT_INFO with the later one.

2. Connection protocol changes

2.1. connection: Channel write close extension "eow@openssh.com"

The SSH connection protocol (rfc4254) provides the SSH_MSG_CHANNEL_EOF
message to allow an endpoint to signal its peer that it will send no
more data over a channel. Unfortunately, there is no symmetric way for
an endpoint to request that its peer should cease sending data to it
while still keeping the channel open for the endpoint to send data to
the peer.

This is desirable, since it saves the transmission of data that would
otherwise need to be discarded and it allows an endpoint to signal local
processes of the condition, e.g. by closing the corresponding file
descriptor.

OpenSSH implements a channel extension message to perform this
signalling: "eow@openssh.com" (End Of Write). This message is sent by
an endpoint when the local output of a session channel is closed or
experiences a write error. The message is formatted as follows:

	byte		SSH_MSG_CHANNEL_REQUEST
	uint32		recipient channel
	string		"eow@openssh.com"
	boolean		FALSE

On receiving this message, the peer SHOULD cease sending data of
the channel and MAY signal the process from which the channel data
originates (e.g. by closing its read file descriptor).

As with the symmetric SSH_MSG_CHANNEL_EOF message, the channel does
remain open after a "eow@openssh.com" has been sent and more data may
still be sent in the other direction. This message does not consume
window space and may be sent even if no window space is available.

NB. due to certain broken SSH implementations aborting upon receipt
of this message (in contravention of RFC4254 section 5.4), this
message is only sent to OpenSSH peers (identified by banner).
Other SSH implementations may be listed to receive this message
upon request.

2.2. connection: disallow additional sessions extension
     "no-more-sessions@openssh.com"

Most SSH connections will only ever request a single session, but a
attacker may abuse a running ssh client to surreptitiously open
additional sessions under their control. OpenSSH provides a global
request "no-more-sessions@openssh.com" to mitigate this attack.

When an OpenSSH client expects that it will never open another session
(i.e. it has been started with connection multiplexing disabled), it
will send the following global request:

	byte		SSH_MSG_GLOBAL_REQUEST
	string		"no-more-sessions@openssh.com"
	char		want-reply

On receipt of such a message, an OpenSSH server will refuse to open
future channels of type "session" and instead immediately abort the
connection.

Note that this is not a general defence against compromised clients
(that is impossible), but it thwarts a simple attack.

NB. due to certain broken SSH implementations aborting upon receipt
of this message, the no-more-sessions request is only sent to OpenSSH
servers (identified by banner). Other SSH implementations may be
listed to receive this message upon request.

2.3. connection: Tunnel forward extension "tun@openssh.com"

OpenSSH supports layer 2 and layer 3 tunnelling via the "tun@openssh.com"
channel type. This channel type supports forwarding of network packets
with datagram boundaries intact between endpoints equipped with
interfaces like the BSD tun(4) device. Tunnel forwarding channels are
requested by the client with the following packet:

	byte		SSH_MSG_CHANNEL_OPEN
	string		"tun@openssh.com"
	uint32		sender channel
	uint32		initial window size
	uint32		maximum packet size
	uint32		tunnel mode
	uint32		remote unit number

The "tunnel mode" parameter specifies whether the tunnel should forward
layer 2 frames or layer 3 packets. It may take one of the following values:

	SSH_TUNMODE_POINTOPOINT  1		/* layer 3 packets */
	SSH_TUNMODE_ETHERNET     2		/* layer 2 frames */

The "tunnel unit number" specifies the remote interface number, or may
be 0x7fffffff to allow the server to automatically choose an interface. A
server that is not willing to open a client-specified unit should refuse
the request with a SSH_MSG_CHANNEL_OPEN_FAILURE error. On successful
open, the server should reply with SSH_MSG_CHANNEL_OPEN_SUCCESS.

Once established the client and server may exchange packet or frames
over the tunnel channel by encapsulating them in SSH protocol strings
and sending them as channel data. This ensures that packet boundaries
are kept intact. Specifically, packets are transmitted using normal
SSH_MSG_CHANNEL_DATA packets:

	byte		SSH_MSG_CHANNEL_DATA
	uint32		recipient channel
	string		data

The contents of the "data" field for layer 3 packets is:

	uint32			packet length
	uint32			address family
	byte[packet length - 4]	packet data

The "address family" field identifies the type of packet in the message.
It may be one of:

	SSH_TUN_AF_INET		2		/* IPv4 */
	SSH_TUN_AF_INET6	24		/* IPv6 */

The "packet data" field consists of the IPv4/IPv6 datagram itself
without any link layer header.

The contents of the "data" field for layer 2 packets is:

	uint32			packet length
	byte[packet length]	frame

The "frame" field contains an IEEE 802.3 Ethernet frame, including
header.

2.4. connection: Unix domain socket forwarding

OpenSSH supports local and remote Unix domain socket forwarding
using the "streamlocal" extension.  Forwarding is initiated as per
TCP sockets but with a single path instead of a host and port.

Similar to direct-tcpip, direct-streamlocal is sent by the client
to request that the server make a connection to a Unix domain socket.

	byte		SSH_MSG_CHANNEL_OPEN
	string		"direct-streamlocal@openssh.com"
	uint32		sender channel
	uint32		initial window size
	uint32		maximum packet size
	string		socket path
	string		reserved
	uint32		reserved

Similar to forwarded-tcpip, forwarded-streamlocal is sent by the
server when the client has previously send the server a streamlocal-forward
GLOBAL_REQUEST.

	byte		SSH_MSG_CHANNEL_OPEN
	string		"forwarded-streamlocal@openssh.com"
	uint32		sender channel
	uint32		initial window size
	uint32		maximum packet size
	string		socket path
	string		reserved for future use

The reserved field is not currently defined and is ignored on the
remote end.  It is intended to be used in the future to pass
information about the socket file, such as ownership and mode.
The client currently sends the empty string for this field.

Similar to tcpip-forward, streamlocal-forward is sent by the client
to request remote forwarding of a Unix domain socket.

	byte		SSH2_MSG_GLOBAL_REQUEST
	string		"streamlocal-forward@openssh.com"
	boolean		TRUE
	string		socket path

Similar to cancel-tcpip-forward, cancel-streamlocal-forward is sent
by the client cancel the forwarding of a Unix domain socket.

	byte		SSH2_MSG_GLOBAL_REQUEST
	string		"cancel-streamlocal-forward@openssh.com"
	boolean		FALSE
	string		socket path

2.5. connection: hostkey update and rotation "hostkeys-00@openssh.com"
and "hostkeys-prove-00@openssh.com"

OpenSSH supports a protocol extension allowing a server to inform
a client of all its protocol v.2 host keys after user-authentication
has completed.

	byte		SSH_MSG_GLOBAL_REQUEST
	string		"hostkeys-00@openssh.com"
	char		0 /* want-reply */
	string[]	hostkeys

Upon receiving this message, a client should check which of the
supplied host keys are present in known_hosts.

Note that the server may send key types that the client does not
support. The client should disregard such keys if they are received.

If the client identifies any keys that are not present for the host,
it should send a "hostkeys-prove@openssh.com" message to request the
server prove ownership of the private half of the key.

	byte		SSH_MSG_GLOBAL_REQUEST
	string		"hostkeys-prove-00@openssh.com"
	char		1 /* want-reply */
	string[]	hostkeys

When a server receives this message, it should generate a signature
using each requested key over the following:

	string		"hostkeys-prove-00@openssh.com"
	string		session identifier
	string		hostkey

These signatures should be included in the reply, in the order matching
the hostkeys in the request:

	byte		SSH_MSG_REQUEST_SUCCESS
	string[]	signatures

When the client receives this reply (and not a failure), it should
validate the signatures and may update its known_hosts file, adding keys
that it has not seen before and deleting keys for the server host that
are no longer offered.

These extensions let a client learn key types that it had not previously
encountered, thereby allowing it to potentially upgrade from weaker
key algorithms to better ones. It also supports graceful key rotation:
a server may offer multiple keys of the same type for a period (to
give clients an opportunity to learn them using this extension) before
removing the deprecated key from those offered.

2.6. connection: SIGINFO support for "signal" channel request

The SSH channels protocol (RFC4254 section 6.9) supports sending a
signal to a session attached to a channel. OpenSSH supports one
extension signal "INFO@openssh.com" that allows sending SIGINFO on
BSD-derived systems.

3. Authentication protocol changes

3.1. Host-bound public key authentication

This is trivial change to the traditional "publickey" authentication
method. The authentication request is identical to the original method
but for the name and one additional field:

	byte		SSH2_MSG_USERAUTH_REQUEST
	string		username
	string		"ssh-connection"
	string		"publickey-hostbound-v00@openssh.com"
	bool		has_signature
	string		pkalg
	string		public key
	string		server host key

Because the entire SSH2_MSG_USERAUTH_REQUEST message is included in
the signed data, this ensures that a binding between the destination
user, the server identity and the session identifier is visible to the
signer. OpenSSH uses this binding via signed data to implement per-key
restrictions in ssh-agent.

A server may advertise this method using the SSH2_MSG_EXT_INFO
mechanism (RFC8308), with the following message:

	string		"publickey-hostbound@openssh.com"
	string		"0" (version)

Clients should prefer host-bound authentication when advertised by
server.

4. SFTP protocol changes

4.1. sftp: Reversal of arguments to SSH_FXP_SYMLINK

When OpenSSH's sftp-server was implemented, the order of the arguments
to the SSH_FXP_SYMLINK method was inadvertently reversed. Unfortunately,
the reversal was not noticed until the server was widely deployed. Since
fixing this to follow the specification would cause incompatibility, the
current order was retained. For correct operation, clients should send
SSH_FXP_SYMLINK as follows:

	uint32		id
	string		targetpath
	string		linkpath

4.2. sftp: Server extension announcement in SSH_FXP_VERSION

OpenSSH's sftp-server lists the extensions it supports using the
standard extension announcement mechanism in the SSH_FXP_VERSION server
hello packet:

	uint32		3		/* protocol version */
	string		ext1-name
	string		ext1-version
	string		ext2-name
	string		ext2-version
	...
	string		extN-name
	string		extN-version

Each extension reports its integer version number as an ASCII encoded
string, e.g. "1". The version will be incremented if the extension is
ever changed in an incompatible way. The server MAY advertise the same
extension with multiple versions (though this is unlikely). Clients MUST
check the version number before attempting to use the extension.

4.3. sftp: Extension request "posix-rename@openssh.com"

This operation provides a rename operation with POSIX semantics, which
are different to those provided by the standard SSH_FXP_RENAME in
draft-ietf-secsh-filexfer-02.txt. This request is implemented as a
SSH_FXP_EXTENDED request with the following format:

	uint32		id
	string		"posix-rename@openssh.com"
	string		oldpath
	string		newpath

On receiving this request the server will perform the POSIX operation
rename(oldpath, newpath) and will respond with a SSH_FXP_STATUS message.
This extension is advertised in the SSH_FXP_VERSION hello with version
"1".

4.4. sftp: Extension requests "statvfs@openssh.com" and
         "fstatvfs@openssh.com"

These requests correspond to the statvfs and fstatvfs POSIX system
interfaces. The "statvfs@openssh.com" request operates on an explicit
pathname, and is formatted as follows:

	uint32		id
	string		"statvfs@openssh.com"
	string		path

The "fstatvfs@openssh.com" operates on an open file handle:

	uint32		id
	string		"fstatvfs@openssh.com"
	string		handle

These requests return a SSH_FXP_STATUS reply on failure. On success they
return the following SSH_FXP_EXTENDED_REPLY reply:

	uint32		id
	uint64		f_bsize		/* file system block size */
	uint64		f_frsize	/* fundamental fs block size */
	uint64		f_blocks	/* number of blocks (unit f_frsize) */
	uint64		f_bfree		/* free blocks in file system */
	uint64		f_bavail	/* free blocks for non-root */
	uint64		f_files		/* total file inodes */
	uint64		f_ffree		/* free file inodes */
	uint64		f_favail	/* free file inodes for to non-root */
	uint64		f_fsid		/* file system id */
	uint64		f_flag		/* bit mask of f_flag values */
	uint64		f_namemax	/* maximum filename length */

The values of the f_flag bitmask are as follows:

	#define SSH_FXE_STATVFS_ST_RDONLY	0x1	/* read-only */
	#define SSH_FXE_STATVFS_ST_NOSUID	0x2	/* no setuid */

Both the "statvfs@openssh.com" and "fstatvfs@openssh.com" extensions are
advertised in the SSH_FXP_VERSION hello with version "2".

4.5. sftp: Extension request "hardlink@openssh.com"

This request is for creating a hard link to a regular file. This
request is implemented as a SSH_FXP_EXTENDED request with the
following format:

	uint32		id
	string		"hardlink@openssh.com"
	string		oldpath
	string		newpath

On receiving this request the server will perform the operation
link(oldpath, newpath) and will respond with a SSH_FXP_STATUS message.
This extension is advertised in the SSH_FXP_VERSION hello with version
"1".

4.6. sftp: Extension request "fsync@openssh.com"

This request asks the server to call fsync(2) on an open file handle.

	uint32		id
	string		"fsync@openssh.com"
	string		handle

On receiving this request, a server will call fsync(handle_fd) and will
respond with a SSH_FXP_STATUS message.

This extension is advertised in the SSH_FXP_VERSION hello with version
"1".

4.7. sftp: Extension request "lsetstat@openssh.com"

This request is like the "setstat" command, but sets file attributes on
symlinks.  It is implemented as a SSH_FXP_EXTENDED request with the
following format:

	uint32		id
	string		"lsetstat@openssh.com"
	string		path
	ATTRS		attrs

See the "setstat" command for more details.

This extension is advertised in the SSH_FXP_VERSION hello with version
"1".

4.8. sftp: Extension request "limits@openssh.com"

This request is used to determine various limits the server might impose.
Clients should not attempt to exceed these limits as the server might sever
the connection immediately.

	uint32		id
	string		"limits@openssh.com"

The server will respond with a SSH_FXP_EXTENDED_REPLY reply:

	uint32		id
	uint64		max-packet-length
	uint64		max-read-length
	uint64		max-write-length
	uint64		max-open-handles

The 'max-packet-length' applies to the total number of bytes in a
single SFTP packet.  Servers SHOULD set this at least to 34000.

The 'max-read-length' is the largest length in a SSH_FXP_READ packet.
Even if the client requests a larger size, servers will usually respond
with a shorter SSH_FXP_DATA packet.  Servers SHOULD set this at least to
32768.

The 'max-write-length' is the largest length in a SSH_FXP_WRITE packet
the server will accept.  Servers SHOULD set this at least to 32768.

The 'max-open-handles' is the maximum number of active handles that the
server allows (e.g. handles created by SSH_FXP_OPEN and SSH_FXP_OPENDIR
packets).  Servers MAY count internal file handles against this limit
(e.g. system logging or stdout/stderr), so clients SHOULD NOT expect to
open this many handles in practice.

If the server doesn't enforce a specific limit, then the field may be
set to 0.  This implies the server relies on the OS to enforce limits
(e.g. available memory or file handles), and such limits might be
dynamic.  The client SHOULD take care to not try to exceed reasonable
limits.

This extension is advertised in the SSH_FXP_VERSION hello with version
"1".

4.9. sftp: Extension request "expand-path@openssh.com"

This request supports canonicalisation of relative paths and
those that need tilde-expansion, i.e. "~", "~/..." and "~user/..."
These paths are expanded using shell-like rules and the resultant
path is canonicalised similarly to SSH2_FXP_REALPATH.

It is implemented as a SSH_FXP_EXTENDED request with the following
format:

	uint32		id
	string		"expand-path@openssh.com"
	string		path

Its reply is the same format as that of SSH2_FXP_REALPATH.

This extension is advertised in the SSH_FXP_VERSION hello with version
"1".

4.10. sftp: Extension request "copy-data"

This request asks the server to copy data from one open file handle and
write it to a different open file handle.  This avoids needing to transfer
the data across the network twice (a download followed by an upload).

	byte		SSH_FXP_EXTENDED
	uint32		id
	string		"copy-data"
	string		read-from-handle
	uint64		read-from-offset
	uint64		read-data-length
	string		write-to-handle
	uint64		write-to-offset

The server will copy read-data-length bytes starting from
read-from-offset from the read-from-handle and write them to
write-to-handle starting from write-to-offset, and then respond with a
SSH_FXP_STATUS message.

It's equivalent to issuing a series of SSH_FXP_READ requests on
read-from-handle and a series of requests of SSH_FXP_WRITE on
write-to-handle.

If read-from-handle and write-to-handle are the same, the server will
fail the request and respond with a SSH_FX_INVALID_PARAMETER message.

If read-data-length is 0, then the server will read data from the
read-from-handle until EOF is reached.

This extension is advertised in the SSH_FXP_VERSION hello with version
"1".

This request is identical to the "copy-data" request documented in:

https://tools.ietf.org/html/draft-ietf-secsh-filexfer-extensions-00#section-7

4.11. sftp: Extension request "home-directory"

This request asks the server to expand the specified user's home directory.
An empty username implies the current user.  This can be used by the client
to expand ~/ type paths locally.

	byte		SSH_FXP_EXTENDED
	uint32		id
	string		"home-directory"
	string		username

This extension is advertised in the SSH_FXP_VERSION hello with version
"1".

This provides similar information as the "expand-path@openssh.com" extension.

This request is identical to the "home-directory" request documented in:

https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-extensions-00#section-5

4.12. sftp: Extension request "users-groups-by-id@openssh.com"

This request asks the server to return user and/or group names that
correspond to one or more IDs (e.g. as returned from a SSH_FXP_STAT
request). This may be used by the client to provide usernames in
directory listings.

	byte		SSH_FXP_EXTENDED
	uint32		id
	string		"users-groups-by-id@openssh.com"
	string		uids
	string		gids

Where "uids" and "gids" consists of one or more integer user or group
identifiers:

	uint32		id-0
	...

The server will reply with a SSH_FXP_EXTENDED_REPLY:

	byte		SSH_FXP_EXTENDED_REPLY
	string		usernames
	string		groupnames

Where "username" and "groupnames" consists of names in identical request
order to "uids" and "gids" respectively:

	string		name-0
	...

If a name cannot be identified for a given user or group ID, an empty
string will be returned in its place.

It is acceptable for either "uids" or "gids" to be an empty set, in
which case the respective "usernames" or "groupnames" list will also
be empty.

This extension is advertised in the SSH_FXP_VERSION hello with version
"1".

5. Miscellaneous changes

5.1 Public key format

OpenSSH public keys, as generated by ssh-keygen(1) and appearing in
authorized_keys files, are formatted as a single line of text consisting
of the public key algorithm name followed by a base64-encoded key blob.
The public key blob (before base64 encoding) is the same format used for
the encoding of public keys sent on the wire: as described in RFC4253
section 6.6 for RSA and DSA keys, RFC5656 section 3.1 for ECDSA keys
and the "New public key formats" section of PROTOCOL.certkeys for the
OpenSSH certificate formats.

5.2 Private key format

OpenSSH private keys, as generated by ssh-keygen(1) use the format
described in PROTOCOL.key by default. As a legacy option, PEM format
(RFC7468) private keys are also supported for RSA, DSA and ECDSA keys
and were the default format before OpenSSH 7.8.

5.3 KRL format

OpenSSH supports a compact format for Key Revocation Lists (KRLs). This
format is described in the PROTOCOL.krl file.

5.4 Connection multiplexing

OpenSSH's connection multiplexing uses messages as described in
PROTOCOL.mux over a Unix domain socket for communications between a
master instance and later clients.

5.5. Agent protocol extensions

OpenSSH extends the usual agent protocol. These changes are documented
in the PROTOCOL.agent file.

$OpenBSD: PROTOCOL,v 1.51 2023/12/18 14:45:49 djm Exp $