crypto/openssh-5/PROTOCOL.agent

   1 This describes the protocol used by OpenSSH's ssh-agent.
   2
   3 OpenSSH's agent supports managing keys for the standard SSH protocol
   4 2 as well as the legacy SSH protocol 1. Support for these key types
   5 is almost completely disjoint - in all but a few cases, operations on
   6 protocol 2 keys cannot see or affect protocol 1 keys and vice-versa.
   7
   8 Protocol 1 and protocol 2 keys are separated because of the differing
   9 cryptographic usage: protocol 1 private RSA keys are used to decrypt
  10 challenges that were encrypted with the corresponding public key,
  11 whereas protocol 2 RSA private keys are used to sign challenges with
  12 a private key for verification with the corresponding public key. It
  13 is considered unsound practice to use the same key for signing and
  14 encryption.
  15
  16 With a couple of exceptions, the protocol message names used in this
  17 document indicate which type of key the message relates to. SSH_*
  18 messages refer to protocol 1 keys only. SSH2_* messages refer to
  19 protocol 2 keys. Furthermore, the names also indicate whether the
  20 message is a request to the agent (*_AGENTC_*) or a reply from the
  21 agent (*_AGENT_*). Section 3 below contains the mapping of the
  22 protocol message names to their integer values.
  23
  24 1. Data types
  25
  26 Because of support for legacy SSH protocol 1 keys, OpenSSH's agent
  27 protocol makes use of some data types not defined in RFC 4251.
  28
  29 1.1 uint16
  30
  31 The "uint16" data type is a simple MSB-first 16 bit unsigned integer
  32 encoded in two bytes.
  33
  34 1.2 mpint1
  35
  36 The "mpint1" type represents an arbitrary precision integer (bignum).
  37 Its format is as follows:
  38
  39         uint16                  bits
  40         byte[(bits + 7) / 8]    bignum
  41
  42 "bignum" contains an unsigned arbitrary precision integer encoded as
  43 eight bits per byte in big-endian (MSB first) format.
  44
  45 Note the difference between the "mpint1" encoding and the "mpint"
  46 encoding defined in RFC 4251. Also note that the length of the encoded
  47 integer is specified in bits, not bytes and that the byte length of
  48 the integer must be calculated by rounding up the number of bits to the
  49 nearest eight.
  50
  51 2. Protocol Messages
  52
  53 All protocol messages are prefixed with their length in bytes, encoded
  54 as a 32 bit unsigned integer. Specifically:
  55
  56         uint32                  message_length
  57         byte[message_length]    message
  58
  59 The following message descriptions refer only to the content the
  60 "message" field.
  61
  62 2.1 Generic server responses
  63
  64 The following generic messages may be sent by the server in response to
  65 requests from the client. On success the agent may reply either with:
  66
  67         byte                    SSH_AGENT_SUCCESS
  68
  69 or a request-specific success message.
  70
  71 On failure, the agent may reply with:
  72
  73         byte                    SSH_AGENT_FAILURE
  74
  75 SSH_AGENT_FAILURE messages are also sent in reply to unknown request
  76 types.
  77
  78 2.2 Adding keys to the agent
  79
  80 Keys are added to the agent using the SSH_AGENTC_ADD_RSA_IDENTITY and
  81 SSH2_AGENTC_ADD_IDENTITY requests for protocol 1 and protocol 2 keys
  82 respectively.
  83
  84 Two variants of these requests are SSH_AGENTC_ADD_RSA_ID_CONSTRAINED
  85 and SSH2_AGENTC_ADD_ID_CONSTRAINED - these add keys with optional
  86 "constraints" on their usage.
  87
  88 OpenSSH may be built with support for keys hosted on a smartcard
  89 or other hardware security module. These keys may be added
  90 to the agent using the SSH_AGENTC_ADD_SMARTCARD_KEY and
  91 SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED requests.
  92
  93 2.2.1 Key constraints
  94
  95 The OpenSSH agent supports some basic optional constraints on key usage.
  96 At present there are two constraints defined.
  97
  98 The first constraint limits the validity duration of a key. It is
  99 encoded as:
 100
 101         byte                    SSH_AGENT_CONSTRAIN_LIFETIME
 102         uint32                  seconds
 103
 104 Where "seconds" contains the number of seconds that the key shall remain
 105 valid measured from the moment that the agent receives it. After the
 106 validity period has expired, OpenSSH's agent will erase these keys from
 107 memory.
 108
 109 The second constraint requires the agent to seek explicit user
 110 confirmation before performing private key operations with the loaded
 111 key. This constraint is encoded as:
 112
 113         byte                    SSH_AGENT_CONSTRAIN_CONFIRM
 114
 115 Zero or more constraints may be specified when adding a key with one
 116 of the *_CONSTRAINED requests. Multiple constraints are appended
 117 consecutively to the end of the request:
 118
 119         byte                    constraint1_type
 120         ....                    constraint1_data
 121         byte                    constraint2_type
 122         ....                    constraint2_data
 123         ....
 124         byte                    constraintN_type
 125         ....                    constraintN_data
 126
 127 Such a sequence of zero or more constraints will be referred to below
 128 as "constraint[]". Agents may determine whether there are constraints
 129 by checking whether additional data exists in the "add key" request
 130 after the key data itself. OpenSSH will refuse to add a key if it
 131 contains unknown constraints.
 132
 133 2.2.2 Add protocol 1 key
 134
 135 A client may add a protocol 1 key to an agent with the following
 136 request:
 137
 138         byte                    SSH_AGENTC_ADD_RSA_IDENTITY or
 139                                 SSH_AGENTC_ADD_RSA_ID_CONSTRAINED
 140         uint32                  ignored
 141         mpint1                  rsa_n
 142         mpint1                  rsa_e
 143         mpint1                  rsa_d
 144         mpint1                  rsa_iqmp
 145         mpint1                  rsa_q
 146         mpint1                  rsa_p
 147         string                  key_comment
 148         constraint[]            key_constraints
 149
 150 Note that there is some redundancy in the key parameters; a key could be
 151 fully specified using just rsa_q, rsa_p and rsa_e at the cost of extra
 152 computation.
 153
 154 "key_constraints" may only be present if the request type is
 155 SSH_AGENTC_ADD_RSA_IDENTITY.
 156
 157 The agent will reply with a SSH_AGENT_SUCCESS if the key has been
 158 successfully added or a SSH_AGENT_FAILURE if an error occurred.
 159
 160 2.2.3 Add protocol 2 key
 161
 162 The OpenSSH agent supports DSA and RSA keys for protocol 2. DSA keys may
 163 be added using the following request
 164
 165         byte                    SSH2_AGENTC_ADD_IDENTITY or
 166                                 SSH2_AGENTC_ADD_ID_CONSTRAINED
 167         string                  "ssh-dss"
 168         mpint                   dsa_p
 169         mpint                   dsa_q
 170         mpint                   dsa_g
 171         mpint                   dsa_public_key
 172         mpint                   dsa_private_key
 173         string                  key_comment
 174         constraint[]            key_constraints
 175
 176 RSA keys may be added with this request:
 177
 178         byte                    SSH2_AGENTC_ADD_IDENTITY or
 179                                 SSH2_AGENTC_ADD_ID_CONSTRAINED
 180         string                  "ssh-rsa"
 181         mpint                   rsa_n
 182         mpint                   rsa_e
 183         mpint                   rsa_d
 184         mpint                   rsa_iqmp
 185         mpint                   rsa_p
 186         mpint                   rsa_q
 187         string                  key_comment
 188         constraint[]            key_constraints
 189
 190 Note that the 'rsa_p' and 'rsa_q' parameters are sent in the reverse
 191 order to the protocol 1 add keys message. As with the corresponding
 192 protocol 1 "add key" request, the private key is overspecified to avoid
 193 redundant processing.
 194
 195 For both DSA and RSA key add requests, "key_constraints" may only be
 196 present if the request type is SSH2_AGENTC_ADD_ID_CONSTRAINED.
 197
 198 The agent will reply with a SSH_AGENT_SUCCESS if the key has been
 199 successfully added or a SSH_AGENT_FAILURE if an error occurred.
 200
 201 2.2.4 Loading keys from a smartcard
 202
 203 The OpenSSH agent may have optional smartcard support built in to it. If
 204 so, it supports an operation to load keys from a smartcard. Technically,
 205 only the public components of the keys are loaded into the agent so
 206 this operation really arranges for future private key operations to be
 207 delegated to the smartcard.
 208
 209         byte                    SSH_AGENTC_ADD_SMARTCARD_KEY or
 210                                 SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED
 211         string                  reader_id
 212         string                  pin
 213         constraint[]            key_constraints
 214
 215 "reader_id" is an identifier to a smartcard reader and "pin"
 216 is a PIN or passphrase used to unlock the private key(s) on the
 217 device. "key_constraints" may only be present if the request type is
 218 SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED.
 219
 220 This operation may load all SSH keys that are unlocked using the
 221 "pin" on the specified reader. The type of key loaded (protocol 1
 222 or protocol 2) will be specified by the smartcard itself, it is not
 223 client-specified.
 224
 225 The agent will reply with a SSH_AGENT_SUCCESS if one or more keys have
 226 been successfully loaded or a SSH_AGENT_FAILURE if an error occurred.
 227 The agent will also return SSH_AGENT_FAILURE if it does not support
 228 smartcards.
 229
 230 2.3 Removing multiple keys
 231
 232 A client may request that an agent delete all protocol 1 keys using the
 233 following request:
 234
 235         byte                    SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES
 236
 237 This message requests the deletion of all protocol 2 keys:
 238
 239         byte                    SSH2_AGENTC_REMOVE_ALL_IDENTITIES
 240
 241 On success, the agent will delete all keys of the requested type and
 242 reply with a SSH_AGENT_SUCCESS message. If an error occurred, the agent
 243 will reply with SSH_AGENT_FAILURE.
 244
 245 Note that, to delete all keys (both protocol 1 and 2), a client
 246 must send both a SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES and a
 247 SSH2_AGENTC_REMOVE_ALL_IDENTITIES request.
 248
 249 2.4 Removing specific keys
 250
 251 2.4.1 Removing a protocol 1 key
 252
 253 Removal of a protocol 1 key may be requested with the following message:
 254
 255         byte                    SSH_AGENTC_REMOVE_RSA_IDENTITY
 256         uint32                  key_bits
 257         mpint1                  rsa_e
 258         mpint1                  rsa_n
 259
 260 Note that key_bits is strictly redundant, as it may be inferred by the
 261 length of rsa_n.
 262
 263 The agent will delete any private key matching the specified public key
 264 and return SSH_AGENT_SUCCESS. If no such key was found, the agent will
 265 return SSH_AGENT_FAILURE.
 266
 267 2.4.2 Removing a protocol 2 key
 268
 269 Protocol 2 keys may be removed with the following request:
 270
 271         byte                    SSH2_AGENTC_REMOVE_IDENTITY
 272         string                  key_blob
 273
 274 Where "key_blob" is encoded as per RFC 4253 section 6.6 "Public Key
 275 Algorithms" for either of the supported key types: "ssh-dss" or
 276 "ssh-rsa".
 277
 278 The agent will delete any private key matching the specified public key
 279 and return SSH_AGENT_SUCCESS. If no such key was found, the agent will
 280 return SSH_AGENT_FAILURE.
 281
 282 2.4.3 Removing keys loaded from a smartcard
 283
 284 A client may request that a server remove one or more smartcard-hosted
 285 keys using this message:
 286
 287         byte                    SSH_AGENTC_REMOVE_SMARTCARD_KEY
 288         string                  reader_id
 289         string                  pin
 290
 291 "reader_id" the an identifier to a smartcard reader and "pin" is a PIN
 292 or passphrase used to unlock the private key(s) on the device.
 293
 294 When this message is received, and if the agent supports
 295 smartcard-hosted keys, it will delete all keys that are hosted on the
 296 specified smartcard that may be accessed with the given "pin".
 297
 298 The agent will reply with a SSH_AGENT_SUCCESS if one or more keys have
 299 been successfully removed or a SSH_AGENT_FAILURE if an error occurred.
 300 The agent will also return SSH_AGENT_FAILURE if it does not support
 301 smartcards.
 302
 303 2.5 Requesting a list of known keys
 304
 305 An agent may be requested to list which keys it holds. Different
 306 requests exist for protocol 1 and protocol 2 keys.
 307
 308 2.5.1 Requesting a list of protocol 1 keys
 309
 310 To request a list of protocol 1 keys that are held in the agent, a
 311 client may send the following message:
 312
 313         byte                    SSH_AGENTC_REQUEST_RSA_IDENTITIES
 314
 315 The agent will reply with the following message:
 316
 317         byte                    SSH_AGENT_RSA_IDENTITIES_ANSWER
 318         uint32                  num_keys
 319
 320 Followed by zero or more consecutive keys, encoded as:
 321
 322         uint32                  bits
 323         mpint1                  rsa_e
 324         mpint1                  rsa_n
 325         string                  key_comment
 326
 327 2.5.2 Requesting a list of protocol 2 keys
 328
 329 A client may send the following message to request a list of
 330 protocol 2 keys that are stored in the agent:
 331
 332         byte                    SSH2_AGENTC_REQUEST_IDENTITIES
 333
 334 The agent will reply with the following message header:
 335
 336         byte                    SSH2_AGENT_IDENTITIES_ANSWER
 337         uint32                  num_keys
 338
 339 Followed by zero or more consecutive keys, encoded as:
 340
 341         string                  key_blob
 342         string                  key_comment
 343
 344 Where "key_blob" is encoded as per RFC 4253 section 6.6 "Public Key
 345 Algorithms" for either of the supported key types: "ssh-dss" or
 346 "ssh-rsa".
 347
 348 2.6 Private key operations
 349
 350 The purpose of the agent is to perform private key operations, such as
 351 signing and encryption without requiring a passphrase to unlock the
 352 key and without allowing the private key itself to be exposed. There
 353 are separate requests for the protocol 1 and protocol 2 private key
 354 operations.
 355
 356 2.6.1 Protocol 1 private key challenge
 357
 358 The private key operation used in version 1 of the SSH protocol is
 359 decrypting a challenge that has been encrypted with a public key.
 360 It may be requested using this message:
 361
 362         byte                    SSH_AGENTC_RSA_CHALLENGE
 363         uint32                  ignored
 364         mpint1                  rsa_e
 365         mpint1                  rsa_n
 366         mpint1                  encrypted_challenge
 367         byte[16]                session_id
 368         uint32                  response_type /* must be 1 */
 369
 370 "rsa_e" and "rsa_n" are used to identify which private key to use.
 371 "encrypted_challenge" is a challenge blob that has (presumably)
 372 been encrypted with the public key and must be in the range
 373 1 <= encrypted_challenge < 2^256. "session_id" is the SSH protocol 1
 374 session ID (computed from the server host key, the server semi-ephemeral
 375 key and the session cookie).
 376
 377 "ignored" and "response_type" exist for compatibility with legacy
 378 implementations. "response_type" must be equal to 1; other response
 379 types are not supported.
 380
 381 On receiving this request, the server decrypts the "encrypted_challenge"
 382 using the private key matching the supplied (rsa_e, rsa_n) values. For
 383 the response derivation, the decrypted challenge is represented as an
 384 unsigned, big-endian integer encoded in a 32 byte buffer (i.e. values
 385 smaller than 2^248 will have leading 0 bytes).
 386
 387 The response value is then calculated as:
 388
 389         response = MD5(decrypted_challenge || session_id)
 390
 391 and returned in the following message
 392
 393         byte                    SSH_AGENT_RSA_RESPONSE
 394         byte[16]                response
 395
 396 If the agent cannot find the key specified by the supplied (rsa_e,
 397 rsa_n) then it will return SSH_AGENT_FAILURE.
 398
 399 2.6.2 Protocol 2 private key signature request
 400
 401 A client may use the following message to request signing of data using
 402 a protocol 2 key:
 403
 404         byte                    SSH2_AGENTC_SIGN_REQUEST
 405         string                  key_blob
 406         string                  data
 407         uint32                  flags
 408
 409 Where "key_blob" is encoded as per RFC 4253 section 6.6 "Public Key
 410 Algorithms" for either of the supported key types: "ssh-dss" or
 411 "ssh-rsa". "flags" is a bit-mask, but at present only one possible value
 412 is defined (see below for its meaning):
 413
 414         SSH_AGENT_OLD_SIGNATURE         1
 415
 416 Upon receiving this request, the agent will look up the private key that
 417 corresponds to the public key contained in key_blob. It will use this
 418 private key to sign the "data" and produce a signature blob using the
 419 key type-specific method described in RFC 4253 section 6.6 "Public Key
 420 Algorithms".
 421
 422 An exception to this is for "ssh-dss" keys where the "flags" word
 423 contains the value SSH_AGENT_OLD_SIGNATURE. In this case, a legacy
 424 signature encoding is used in lieu of the standard one. In this case,
 425 the DSA signature blob is encoded as:
 426
 427         byte[40]                signature
 428
 429 The signature will be returned in the response message:
 430
 431         byte                    SSH2_AGENT_SIGN_RESPONSE
 432         string                  signature_blob
 433
 434 If the agent cannot find the key specified by the supplied key_blob then
 435 it will return SSH_AGENT_FAILURE.
 436
 437 2.7 Locking or unlocking an agent
 438
 439 The agent supports temporary locking with a passphrase to suspend
 440 processing of sensitive operations until it has been unlocked with the
 441 same passphrase. To lock an agent, a client send the following request:
 442
 443         byte                    SSH_AGENTC_LOCK
 444         string                  passphrase
 445
 446 Upon receipt of this message and if the agent is not already locked,
 447 it will suspend processing requests and return a SSH_AGENT_SUCCESS
 448 reply. If the agent is already locked, it will return SSH_AGENT_FAILURE.
 449
 450 While locked, the agent will refuse all requests except
 451 SSH_AGENTC_UNLOCK, SSH_AGENTC_REQUEST_RSA_IDENTITIES and
 452 SSH2_AGENTC_REQUEST_IDENTITIES. The "request identities" requests are
 453 treated specially by a locked agent: it will always return an empty list
 454 of keys.
 455
 456 To unlock an agent, a client may request:
 457
 458         byte                    SSH_AGENTC_UNLOCK
 459         string                  passphrase
 460
 461 If the passphrase matches and the agent is locked, then it will resume
 462 processing all requests and return SSH_AGENT_SUCCESS. If the agent
 463 is not locked or the passphrase does not match then it will return
 464 SSH_AGENT_FAILURE.
 465
 466 Locking and unlocking affects both protocol 1 and protocol 2 keys.
 467
 468 3. Protocol message numbers
 469
 470 3.1 Requests from client to agent for protocol 1 key operations
 471
 472         SSH_AGENTC_REQUEST_RSA_IDENTITIES               1
 473         SSH_AGENTC_RSA_CHALLENGE                        3
 474         SSH_AGENTC_ADD_RSA_IDENTITY                     7
 475         SSH_AGENTC_REMOVE_RSA_IDENTITY                  8
 476         SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES            9
 477         SSH_AGENTC_ADD_RSA_ID_CONSTRAINED               24
 478
 479 3.2 Requests from client to agent for protocol 2 key operations
 480
 481         SSH2_AGENTC_REQUEST_IDENTITIES                  11
 482         SSH2_AGENTC_SIGN_REQUEST                        13
 483         SSH2_AGENTC_ADD_IDENTITY                        17
 484         SSH2_AGENTC_REMOVE_IDENTITY                     18
 485         SSH2_AGENTC_REMOVE_ALL_IDENTITIES               19
 486         SSH2_AGENTC_ADD_ID_CONSTRAINED                  25
 487
 488 3.3 Key-type independent requests from client to agent
 489
 490         SSH_AGENTC_ADD_SMARTCARD_KEY                    20
 491         SSH_AGENTC_REMOVE_SMARTCARD_KEY                 21
 492         SSH_AGENTC_LOCK                                 22
 493         SSH_AGENTC_UNLOCK                               23
 494         SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED        26
 495
 496 3.4 Generic replies from agent to client
 497
 498         SSH_AGENT_FAILURE                               5
 499         SSH_AGENT_SUCCESS                               6
 500
 501 3.5 Replies from agent to client for protocol 1 key operations
 502
 503         SSH_AGENT_RSA_IDENTITIES_ANSWER                 2
 504         SSH_AGENT_RSA_RESPONSE                          4
 505
 506 3.6 Replies from agent to client for protocol 2 key operations
 507
 508         SSH2_AGENT_IDENTITIES_ANSWER                    12
 509         SSH2_AGENT_SIGN_RESPONSE                        14
 510
 511 3.7 Key constraint identifiers
 512
 513         SSH_AGENT_CONSTRAIN_LIFETIME                    1
 514         SSH_AGENT_CONSTRAIN_CONFIRM                     2
 515
 516 $OpenBSD: PROTOCOL.agent,v 1.4 2008/07/01 23:12:47 stevesk Exp $