Digital Certificates and Digital Signatures


Jump to: navigation, search


PKIv3 architectual model and datastructures conforming to ITU-T X.509


  Users of a public key shall be confident that the associated private
  key is owned by the correct remote subject (person or system) with
  which an encryption or digital signature mechanism will be used.
  This confidence is obtained through the use of public key
  certificates, which are data structures that bind public key values
  to subjects.  


  The binding is asserted by having a trusted CA
  digitally sign each certificate. The CA may base this assertion upon
  technical means (a.k.a., proof of posession through a challenge-
  response protocol), presentation of the private key, or on an
  assertion by the subject.  A certificate has a limited valid lifetime
  which is indicated in its signed contents.  Because a certificate's
  signature and timeliness can be independently checked by a
  certificate-using client, certificates can be distributed via
  untrusted communications and server systems, and can be cached in
  unsecured storage in certificate-using systems.
  ITU-T X.509 (formerly CCITT X.509) or ISO/IEC/ITU 9594-8, which was
  first published in 1988 as part of the X.500 Directory
  recommendations, defines a standard certificate format [X.509]. The
  certificate format in the 1988 standard is called the version 1 (v1)
  format.  When X.500 was revised in 1993, two more fields were added,
  resulting in the version 2 (v2) format. These two fields may be used
  to support directory access control.


Basic certificate fields

  The v3 format extends the v2 format by
  adding provision for additional extension fields.  Particular
  extension field types may be specified in standards or may be defined
  and registered by any organization or community. In June 1996,
  standardization of the basic v3 format was completed [X.509].

  ISO/IEC/ITU and ANSI X9 have also developed standard extensions for
  use in the v3 extensions field [X.509][X9.55].  These extensions can
  convey such data as additional subject identification information,
  key attribute information, policy information, and certification path

Certification path processing

path processing algorithm

  verifies the binding between the subject distinguished name and/or
  subject alternative name and subject public key.  The binding is
  limited by constraints which are specified in the certificates which
  comprise the path. The basic constraints and policy constraints
  extensions allow the certification path processing logic to automate
  the decision making process.
  The "most-trusted CA" is a matter of policy: it could be a root CA in
  a hierarchical PKI; the CA that issued the verifier's own
  certificate(s); or any other CA in a network PKI.  The path
  validation procedure is the same regardless of the choice of "most-
  trusted CA."


  X.509 defines one method of certificate revocation.  This method
  involves each CA periodically issuing a signed data structure called
  a certificate revocation list (CRL).  A CRL is a time stamped list
  identifying revoked certificates which is signed by a CA and made
  freely available in a public repository.  Each revoked certificate is
  identified in a CRL by its certificate serial number.


 ITU-T Recommendation X.509

Flexible and Scalable Public Key Security for SSH secure shell)


A standard tool for secure remote access, the SSH protocol uses public key cryptography to establish an encrypted and integrity-protected channel with a remote server. However, widely-deployed implementations of the protocol are vulnerable to man-in-the-middle attacks, where an adversary substitutes her public key for the server’s. This danger particularly threatens a traveling user Bob borrowing a client machine. Imposing a traditional X.509 PKI on all SSH servers and clients is neither flexible nor scalable nor (in the foreseeable future) practical. Requiring extensive work or an SSL server at Bob’s site is also not practical for many users.


  • covers the problem, that open-source SSH programs have no solution to guarantee that the server's public key is correct.
  • this approach gives a way to build a flat trust-structure with the effect of secure public keys.
  • this approach published in European Public Key Infrastructure Workshop 2004(EuroPKI 2004: Samos Island, Greece)

The Situation

SSH uses public-key cryptography to establish authentication and encrypted communications over unsecured channels. The server presents a public key, and the client machine uses standard cryptography to establish a protected channel with the party knowing the private key, hopefully the server. But the binding of the server’s public key to the identity of the server to which the user intended to connect is not guaranteed. This makes the user susceptible to man-in-the-middle attacks. The attacker substitutes his public key for the server’s and leads the user to his own SSH-Server. If the user then authenticates via passwords, the attacker can gain complete control of the user’s account. If the client machine will be used from different traveling users, every user needs a list of its favorit SSH servers. It costs to much work to maintain all of the public keys on all machines. This isn't a possibility. Another natural approach would be to establish a traditional hierarchical PKI for SSH servers, including a trust root, which all SSH clients would know. All SSH servers public keys are bound to a node in the trust hierarchy. Every client checks the trust path before it communicates with a server. This approach does not meet the authors real world constraints, because this universal trust structure needs to be in place before the traveling user can securely connect from a remote machine and many system environments do not provide a natural hierarchy of certifiers or machine names. The authors have checked some other possibilities like building a the “universal PKI” or building a many-rooted trust structure. These solutions couldn't hold the real world constraints (see Real-World Constraints). At the end, we will look on the question: how do we bring public-key security to SSH, in a way that provides the flexibility and scalability that can permit easy adoption in the real world, without requiring an a priori trust structure or an SSL server?

The Solution

  • Goals and Real World Constraints
  • Creating a “Poor Man’s” Certificate
  • Decentralized Approach. (Implemented)
  • Semi-centralized Approach.

Goals and Real-World Constraints

Real-World Constraints

The user trusts the client machine and his intended remote server to work correctly.
The user does not trust the server machine he actually connects to until he verifies the server’s identity.
The user also does not trust the client’s network environment, including its DNS.
"small delta" means, that for the solution no changes in hardware or structure and only small changes in software are allowed. This is forced, because of reducing costs and fast implementation of a solution.

Goals (more Real-World Constraints)

The solution should enable users from borrowed (but trusted) clients to establish trusted connections to their home machines.
The solution should be adoptable in the near-term in similar infrastructure (“small delta”).
The solution should accommodate users in domains where sys-admins can set up trustable and usable CA services.
The solution should accommodate users in domains where no such services exist.
The solution should not require that a new universal PKI hierarchy be established before any of this works.
The solution should not require that a user memorize the fingerprints of all servers he wishes to interact with.

Creating a "Poor Man's" Certificate

Modifying SSH protocol violates “small delta” change restriction
Therefore, non SSH mechanism to be used to retrieve server public key
Poor Man’s Certificate: Use HMAC to retrieve server public key securely

HMAC (Hashed Message Authentication Code) is a Keyed MAC Algorithm:

take message M and a secret key k and produces a MAC value Mac(M,k)
infeasible to find another M’, k’ pair that generate the same keyed MAC (collision resistant)
It’s like digital signature, but with symmetric key instead of a key pair

Decentralized Approach


No Third Party involved.
Individually maintained by user.
User must have access to a web server to retrieve files.
Hashstore-file containing a list of server names, and (for each server) the keyed MAC.

Create Hashstore File

Configurator program produces pairs of (server name – keyed MAC).
Program input = passphrase, target server name(s), path to public keys of this server.
A symmetric (secret) key is generated from passphrase.
Symmetric key is used to calculate keyed MAC.
Keyed MAC = hashed public key of server.
Hashstore-file is stored under public access (Web-Server).

Establish SSH connection

The user wants to connect to SSH-server A.
The modified SSH client requests the hashstore file and requires the input of the passphrase of the user.
The user authenificates itself with the passphrase. The SSH client generates a symmetric key from the passphrase and decodes the hashstore file (verification of the user like a digital signature).
Now, the SSH client can extract the associated public key of the SSH server.
Now the SSH client checks the requested server public key.
If the keys are matching, the SSH session will be established normally.

Semi-Centralized Approach

Proposed and evaluated, not completely implemented.
Requires maintenance by Sys-Admins.
Requires LDAP server and a CA.
Preferably using server certificates instead of server public keys.
Personal tools
MediaWiki Appliance - Powered by TurnKey Linux