- OpenBSD CVS Sync

   - djm@cvs.openbsd.org 2010/02/26 20:29:54
     [PROTOCOL PROTOCOL.agent PROTOCOL.certkeys addrmatch.c auth-options.c]
     [auth-options.h auth.h auth2-pubkey.c authfd.c dns.c dns.h hostfile.c]
     [hostfile.h kex.h kexdhs.c kexgexs.c key.c key.h match.h monitor.c]
     [myproposal.h servconf.c servconf.h ssh-add.c ssh-agent.c ssh-dss.c]
     [ssh-keygen.1 ssh-keygen.c ssh-rsa.c ssh.1 ssh.c ssh2.h sshconnect.c]
     [sshconnect2.c sshd.8 sshd.c sshd_config.5]
     Add support for certificate key types for users and hosts.

     OpenSSH certificate key types are not X.509 certificates, but a much
     simpler format that encodes a public key, identity information and
     some validity constraints and signs it with a CA key. CA keys are
     regular SSH keys. This certificate style avoids the attack surface
     of X.509 certificates and is very easy to deploy.

     Certified host keys allow automatic acceptance of new host keys
     when a CA certificate is marked as sh/known_hosts.
     see VERIFYING HOST KEYS in ssh(1) for details.

     Certified user keys allow authentication of users when the signing
     CA key is marked as trusted in authorized_keys. See "AUTHORIZED_KEYS
     FILE FORMAT" in sshd(8) for details.

     Certificates are minted using ssh-keygen(1), documentation is in
     the "CERTIFICATES" section of that manpage.

     Documentation on the format of certificates is in the file
     PROTOCOL.certkeys

     feedback and ok markus@

1 files changed, 29 insertions, 3 deletions

diff --git a/key.h b/key.h
index 14aac79c2..6a2e049af 100644
--- a/key.h
+++ b/key.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: key.h,v 1.27 2008/06/11 21:01:35 grunk Exp $ */
+/* $OpenBSD: key.h,v 1.28 2010/02/26 20:29:54 djm Exp $ */
 
 /*
  * Copyright (c) 2000, 2001 Markus Friedl.  All rights reserved.
@@ -26,6 +26,7 @@
 #ifndef KEY_H
 #define KEY_H
 
+#include "buffer.h"
 #include <openssl/rsa.h>
 #include <openssl/dsa.h>
 
@@ -34,6 +35,8 @@ enum types {
         KEY_RSA1,
         KEY_RSA,
         KEY_DSA,
+        KEY_RSA_CERT,
+        KEY_DSA_CERT,
         KEY_UNSPEC
 };
 enum fp_type {
@@ -49,20 +52,35 @@ enum fp_rep {
 /* key is stored in external hardware */
 #define KEY_FLAG_EXT            0x0001
 
+#define CERT_MAX_PRINCIPALS     256
+struct KeyCert {
+        Buffer           certblob; /* Kept around for use on wire */
+        u_int            type; /* SSH2_CERT_TYPE_USER or SSH2_CERT_TYPE_HOST */
+        char            *key_id;
+        u_int            nprincipals;
+        char            **principals;
+        u_int64_t        valid_after, valid_before;
+        Buffer           constraints;
+        Key             *signature_key;
+};
+
 struct Key {
         int      type;
         int      flags;
         RSA     *rsa;
         DSA     *dsa;
+        struct KeyCert *cert;
 };
 
 Key             *key_new(int);
+void             key_add_private(Key *);
 Key             *key_new_private(int);
 void             key_free(Key *);
 Key             *key_demote(const Key *);
+int              key_equal_public(const Key *, const Key *);
 int              key_equal(const Key *, const Key *);
-char            *key_fingerprint(const Key *, enum fp_type, enum fp_rep);
-u_char          *key_fingerprint_raw(const Key *, enum fp_type, u_int *);
+char            *key_fingerprint(Key *, enum fp_type, enum fp_rep);
+u_char          *key_fingerprint_raw(Key *, enum fp_type, u_int *);
 const char      *key_type(const Key *);
 int              key_write(const Key *, FILE *);
 int              key_read(Key *, char **);
@@ -71,6 +89,14 @@ u_int		 key_size(const Key *);
 Key     *key_generate(int, u_int);
 Key     *key_from_private(const Key *);
 int      key_type_from_name(char *);
+int      key_is_cert(const Key *);
+int      key_type_plain(int);
+int      key_to_certified(Key *);
+int      key_drop_cert(Key *);
+int      key_certify(Key *, Key *);
+void     key_cert_copy(const Key *, struct Key *);
+int      key_cert_check_authority(const Key *, int, int, const char *,
+            const char **);
 
 Key             *key_from_blob(const u_char *, u_int);
 int              key_to_blob(const Key *, u_char **, u_int *);