Re: OpenSSH certified keys

[Douglas Stebila <[e-mail]>]

The OpenSSL certkeys protocol has some similarities to our present X.509-in-SSH proposal, but also differs in at least three major ways; there are some lessons for each to learn from the other, but there are also some fundamental incompatibilities.

User/host identifiers: Our draft leaves the mapping between certificates and usernames / hostnames up to the implementation and system administrators.  Perhaps we should revisit the issue of mapping hostnames, but I believe that having the CA map certificates to usernames is inappropriate.  The same user (with the same certificate) may intend to use that certificate with multiple servers, and have different usernames on each server.  For example, on their primary work computer the user may have the username "admin", and on their departmental web server have the username "bsmith"; but the administrator of the departmental web server may not wish to allow that user to access the web server as "admin".

Revocation: At the request of members of this list, our draft -01 incorporated a mechanism for a party to relay certificate status / revocation information (specifically, OCSP responses) along with any certificates delivered during the exchange.  I was convinced by arguments made by members of this list that checking revocation is an important feature, and moreover that clients in particular may not have online access to a certificate status server.  For example, if a client is logging into a corporate network and the certificate status server is inside the corporate network, then the client cannot access the network to verify the status of the certificate.

Constraints: We did not include any SSH-specific constraints in our draft.  I have no opinion whether including such constraints is appropriate or not, and there seems to be some discussion going on right now about this.

X.509 versus not X.509: Obviously the main difference is the certificate format.  We started from the premise that "people want to use their PKIX infrastructure in SSH", and it appears, Damien, that you and your colleagues started from the premise that "people want to use some kind of certificates in SSH".  But you've also later written in this thread:
> Well, unfortunately we consider the additional complexity and attack surface added by X.509 to be too great.
Is it that you (a) consider all existing implementations of X.509 to be too untested and thus have an unacceptable attack surface or (b) consider the X.509 specification itself to be too complex to ever have an acceptable implementation?  If it's (a), then there's at least a hope for reconciliation between our approach and yours.  If it's (b), then to me that says the maintainers of the most popular SSH implementation will not ever accept the use of X.509 certificates in SSH.

Douglas

On 2010-Mar-17, at 3:19 AM, Damien Miller wrote:

> Hi,
> 
> OpenSSH 5.4p1 introduced a novel, lightweight certificate format for
> user and host keys. These were designed to reuse SSH wire-encoding and
> signature primitives to minimise the additional attack surface exposed
> pre-auth. In particular, we are not comfortable with the complexity
> (syntactically or sematically) of X.509.
> 
> Here is the document from the OpenSSH source distribution that describes
> them (PROTOCOL.certkeys). If there is interested from other implementors
> in interoperating with these certificates then I'm willing to write this
> up as an I-D.
> 
> -d
> 
> ------------------------
> 
> This document describes a simple public-key certificate authentication
> system for use by SSH.
> 
> Background
> ----------
> 
> The SSH protocol currently supports a simple public key authentication
> mechanism. Unlike other public key implementations, SSH eschews the
> use of X.509 certificates and uses raw keys. This approach has some
> benefits relating to simplicity of configuration and minimisation
> of attack surface, but it does not support the important use-cases
> of centrally managed, passwordless authentication and centrally
> certified host keys.
> 
> These protocol extensions build on the simple public key authentication
> system already in SSH to allow certificate-based authentication.
> The certificates used are not traditional X.509 certificates, with
> numerous options and complex encoding rules, but something rather
> more minimal: a key, some identity information and usage constraints
> that have been signed with some other trusted key.
> 
> A sshd server may be configured to allow authentication via certified
> keys, by extending the existing ~/.ssh/authorized_keys mechanism
> to allow specification of certification authority keys in addition
> to raw user keys. The ssh client will support automatic verification
> of acceptance of certified host keys, by adding a similar ability
> to specify CA keys in ~/.ssh/known_hosts.
> 
> Certified keys are represented using two new key types:
> [e-mail] and [e-mail] that
> include certification information along with the public key that is used
> to sign challenges. ssh-keygen performs the CA signing operation.
> 
> Protocol extensions
> -------------------
> 
> The SSH wire protocol includes several extensibility mechanisms.
> These modifications shall take advantage of namespaced public key
> algorithm names to add support for certificate authentication without
> breaking the protocol - implementations that do not support the
> extensions will simply ignore them.
> 
> Authentication using the new key formats described below proceeds
> using the existing SSH "publickey" authentication method described
> in RFC4252 section 7.
> 
> New public key formats
> ----------------------
> 
> The [e-mail] and [e-mail] key
> types take a similar high-level format (note: data types and
> encoding are as per RFC4251 section 5). The serialised wire encoding of
> these certificates is also used for storing them on disk.
> 
> #define SSH_CERT_TYPE_USER    1
> #define SSH_CERT_TYPE_HOST    2
> 
> RSA certificate
> 
>    string    "[e-mail]"
>    mpint     e
>    mpint     n
>    uint32    type
>    string    key id
>    string    valid principals
>    uint64    valid after
>    uint64    valid before
>    string    constraints
>    string    nonce
>    string    reserved
>    string    signature key
>    string    signature
> 
> DSA certificate
> 
>    string    "[e-mail]"
>    mpint     p
>    mpint     q
>    mpint     g
>    mpint     y
>    uint32    type
>    string    key id
>    string    valid principals
>    uint64    valid after
>    uint64    valid before
>    string    constraints
>    string    nonce
>    string    reserved
>    string    signature key
>    string    signature
> 
> e and n are the RSA exponent and public modulus respectively.
> 
> p, q, g, y are the DSA parameters as described in FIPS-186-2.
> 
> type specifies whether this certificate is for identification of a user
> or a host using a SSH_CERT_TYPE_... value.
> 
> key id is a free-form text field that is filled in by the CA at the time
> of signing; the intention is that the contents of this field are used to
> identify the identity principal in log messages.
> 
> "valid principals" is a string containing zero or more principals as
> strings packed inside it. These principals list the names for which this
> certificate is valid; hostnames for SSH_CERT_TYPE_HOST certificates and
> usernames for SSH_CERT_TYPE_USER certificates. As a special case, a
> zero-length "valid principals" field means the certificate is valid for
> any principal of the specified type. XXX DNS wildcards?
> 
> "valid after" and "valid before" specify a validity period for the
> certificate. Each represents a time in seconds since 1970-01-01
> 00:00:00. A certificate is considered valid if:
> 	 valid after <= current time < valid before
> 
> constraints is a set of zero or more key constraints encoded as below.
> 
> The nonce field is a CA-provided random bitstring of arbitrary length
> (but typically 16 or 32 bytes) included to make attacks that depend on
> inducing collisions in the signature hash infeasible.
> 
> The reserved field is current unused and is ignored in this version of
> the protocol.
> 
> signature key contains the CA key used to sign the certificate.
> The valid key types for CA keys are ssh-rsa and ssh-dss. "Chained"
> certificates, where the signature key type is a certificate type itself
> are NOT supported. Note that it is possible for a RSA certificate key to
> be signed by a DSS CA key and vice-versa.
> 
> signature is computed over all preceding fields from the initial string
> up to, and including the signature key. Signatures are computed and
> encoded according to the rules defined for the CA's public key algorithm
> (RFC4253 section 6.6 for ssh-rsa and ssh-dss).
> 
> Constraints
> -----------
> 
> The constraints section of the certificate specifies zero or more
> constraints on the certificates validity. The format of this field
> is a sequence of zero or more tuples:
> 
>    string       name
>    string       data
> 
> The name field identifies the constraint and the data field encodes
> constraint-specific information (see below). All constraints are
> "critical", if an implementation does not recognise a constraint
> then the validating party should refuse to accept the certificate.
> 
> The supported constraints and the contents and structure of their
> data fields are:
> 
> Name                    Format        Description
> -----------------------------------------------------------------------------
> force-command           string        Specifies a command that is executed
>                                      (replacing any the user specified on the
>                                      ssh command-line) whenever this key is
>                                      used for authentication.
> 
> permit-X11-forwarding   empty         Flag indicating that X11 forwarding
>                                      should be permitted. X11 forwarding will
>                                      be refused if this constraint is absent.
> 
> permit-agent-forwarding empty         Flag indicating that agent forwarding
>                                      should be allowed. Agent forwarding
>                                      must not be permitted unless this
>                                      constraint is present.
> 
> permit-port-forwarding  empty         Flag indicating that port-forwarding
>                                      should be allowed. If this constraint is
>                                      not present then no port forwarding will
>                                      be allowed.
> 
> permit-pty              empty         Flag indicating that PTY allocation
>                                      should be permitted. In the absence of
>                                      this constraint PTY allocation will be
>                                      disabled.
> 
> permit-user-rc          empty         Flag indicating that execution of
>                                      ~/.ssh/rc should be permitted. Execution
>                                      of this script will not be permitted if
>                                      this constraint is not present.
> 
> source-address          string        Comma-separated list of source addresses
>                                      from which this certificate is accepted
>                                      for authentication. Addresses are
>                                      specified in CIDR format (nn.nn.nn.nn/nn
>                                      or hhhh::hhhh/nn).
>                                      If this constraint is not present then
>                                      certificates may be presented from any
>                                      source address.
> 
> $OpenBSD: PROTOCOL.certkeys,v 1.3 2010/03/03 22:50:40 djm Exp $