blob: 03c444d42dc3c9d5c3968b9b715c2cec9de8f4a3 [file] [log] [blame]
Damien Miller3009d3c2013-07-20 13:22:31 +10001/* $OpenBSD: ssh-keygen.c,v 1.230 2013/07/20 01:44:37 djm Exp $ */
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002/*
Damien Miller95def091999-11-25 00:26:21 +11003 * Author: Tatu Ylonen <ylo@cs.hut.fi>
4 * Copyright (c) 1994 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
5 * All rights reserved
Damien Miller95def091999-11-25 00:26:21 +11006 * Identity and host key generation and maintenance.
Damien Millere4340be2000-09-16 13:29:08 +11007 *
8 * As far as I am concerned, the code I have written for this software
9 * can be used freely for any purpose. Any derived versions of this
10 * software must be clearly marked as such, and if the derived work is
11 * incompatible with the protocol description in the RFC file, it must be
12 * called by a name other than "ssh" or "Secure Shell".
Damien Miller95def091999-11-25 00:26:21 +110013 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100014
15#include "includes.h"
Damien Millerf17883e2006-03-15 11:45:54 +110016
17#include <sys/types.h>
Damien Millere3b60b52006-07-10 21:08:03 +100018#include <sys/socket.h>
Damien Millerf17883e2006-03-15 11:45:54 +110019#include <sys/stat.h>
Damien Miller8dbffe72006-08-05 11:02:17 +100020#include <sys/param.h>
Damien Millerd4a8b7e1999-10-27 13:42:43 +100021
Damien Millereba71ba2000-04-29 23:57:08 +100022#include <openssl/evp.h>
23#include <openssl/pem.h>
Darren Tuckerbfaaf962008-02-28 19:13:52 +110024#include "openbsd-compat/openssl-compat.h"
Damien Millereba71ba2000-04-29 23:57:08 +100025
Darren Tucker39972492006-07-12 22:22:46 +100026#include <errno.h>
Damien Miller57cf6382006-07-10 21:13:46 +100027#include <fcntl.h>
Damien Millerb8fe89c2006-07-24 14:51:00 +100028#include <netdb.h>
Darren Tucker2ee50c52006-07-11 18:55:05 +100029#ifdef HAVE_PATHS_H
30# include <paths.h>
31#endif
Damien Miller9f2abc42006-07-10 20:53:08 +100032#include <pwd.h>
Damien Millerded319c2006-09-01 15:38:36 +100033#include <stdarg.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100034#include <stdio.h>
Damien Millere7a1e5c2006-08-05 11:34:19 +100035#include <stdlib.h>
Damien Millere3476ed2006-07-24 14:13:33 +100036#include <string.h>
Damien Millere6b3b612006-07-24 14:01:23 +100037#include <unistd.h>
Damien Miller9f2abc42006-07-10 20:53:08 +100038
Damien Millerd4a8b7e1999-10-27 13:42:43 +100039#include "xmalloc.h"
Damien Millereba71ba2000-04-29 23:57:08 +100040#include "key.h"
Ben Lindstromd09fcf52001-03-29 00:29:54 +000041#include "rsa.h"
Damien Millereba71ba2000-04-29 23:57:08 +100042#include "authfile.h"
43#include "uuencode.h"
Damien Miller874d77b2000-10-14 16:23:11 +110044#include "buffer.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000045#include "pathnames.h"
46#include "log.h"
Darren Tuckere608ca22004-05-13 16:15:47 +100047#include "misc.h"
Damien Miller4b42d7f2005-03-01 21:48:35 +110048#include "match.h"
49#include "hostfile.h"
Damien Miller69996102006-07-10 20:53:31 +100050#include "dns.h"
Damien Millerf3747bf2013-01-18 11:44:04 +110051#include "ssh.h"
Damien Miller0a80ca12010-02-27 07:55:05 +110052#include "ssh2.h"
Damien Miller7ea845e2010-02-12 09:21:02 +110053#include "ssh-pkcs11.h"
Damien Millerf3747bf2013-01-18 11:44:04 +110054#include "atomicio.h"
55#include "krl.h"
Ben Lindstromcd392282001-07-04 03:44:03 +000056
Damien Miller3f54a9f2005-11-05 14:52:18 +110057/* Number of bits in the RSA/DSA key. This value can be set on the command line. */
58#define DEFAULT_BITS 2048
59#define DEFAULT_BITS_DSA 1024
Damien Miller6e9f6802010-09-10 11:17:38 +100060#define DEFAULT_BITS_ECDSA 256
Damien Miller3f54a9f2005-11-05 14:52:18 +110061u_int32_t bits = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100062
Damien Miller5428f641999-11-25 11:54:57 +110063/*
64 * Flag indicating that we just want to change the passphrase. This can be
65 * set on the command line.
66 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100067int change_passphrase = 0;
68
Damien Miller5428f641999-11-25 11:54:57 +110069/*
70 * Flag indicating that we just want to change the comment. This can be set
71 * on the command line.
72 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100073int change_comment = 0;
74
75int quiet = 0;
76
Darren Tucker35c45532008-06-13 04:43:15 +100077int log_level = SYSLOG_LEVEL_INFO;
78
Damien Miller4b42d7f2005-03-01 21:48:35 +110079/* Flag indicating that we want to hash a known_hosts file */
80int hash_hosts = 0;
81/* Flag indicating that we want lookup a host in known_hosts file */
82int find_host = 0;
83/* Flag indicating that we want to delete a host from a known_hosts file */
84int delete_host = 0;
85
Damien Millerf2b70ca2010-03-05 07:39:35 +110086/* Flag indicating that we want to show the contents of a certificate */
87int show_cert = 0;
88
Damien Miller10f6f6b1999-11-17 17:29:08 +110089/* Flag indicating that we just want to see the key fingerprint */
90int print_fingerprint = 0;
Ben Lindstrom8fd372b2001-03-12 03:02:17 +000091int print_bubblebabble = 0;
Damien Miller10f6f6b1999-11-17 17:29:08 +110092
Damien Miller431f66b1999-11-21 18:31:57 +110093/* The identity file name, given on the command line or entered by the user. */
94char identity_file[1024];
95int have_identity = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100096
97/* This is set to the passphrase if given on the command line. */
98char *identity_passphrase = NULL;
99
100/* This is set to the new passphrase if given on the command line. */
101char *identity_new_passphrase = NULL;
102
103/* This is set to the new comment if given on the command line. */
104char *identity_comment = NULL;
105
Damien Miller0a80ca12010-02-27 07:55:05 +1100106/* Path to CA key when certifying keys. */
107char *ca_key_path = NULL;
108
Damien Miller4e270b02010-04-16 15:56:21 +1000109/* Certificate serial number */
Damien Miller55aca022012-12-03 11:25:30 +1100110unsigned long long cert_serial = 0;
Damien Miller4e270b02010-04-16 15:56:21 +1000111
Damien Miller0a80ca12010-02-27 07:55:05 +1100112/* Key type when certifying */
113u_int cert_key_type = SSH2_CERT_TYPE_USER;
114
115/* "key ID" of signed key */
116char *cert_key_id = NULL;
117
118/* Comma-separated list of principal names for certifying keys */
119char *cert_principals = NULL;
120
121/* Validity period for certificates */
122u_int64_t cert_valid_from = 0;
123u_int64_t cert_valid_to = ~0ULL;
124
Damien Miller4e270b02010-04-16 15:56:21 +1000125/* Certificate options */
Damien Millerd0e4a8e2010-05-21 14:58:32 +1000126#define CERTOPT_X_FWD (1)
127#define CERTOPT_AGENT_FWD (1<<1)
128#define CERTOPT_PORT_FWD (1<<2)
129#define CERTOPT_PTY (1<<3)
130#define CERTOPT_USER_RC (1<<4)
131#define CERTOPT_DEFAULT (CERTOPT_X_FWD|CERTOPT_AGENT_FWD| \
132 CERTOPT_PORT_FWD|CERTOPT_PTY|CERTOPT_USER_RC)
133u_int32_t certflags_flags = CERTOPT_DEFAULT;
134char *certflags_command = NULL;
135char *certflags_src_addr = NULL;
Damien Miller0a80ca12010-02-27 07:55:05 +1100136
Damien Miller44b25042010-07-02 13:35:01 +1000137/* Conversion to/from various formats */
138int convert_to = 0;
139int convert_from = 0;
140enum {
141 FMT_RFC4716,
142 FMT_PKCS8,
143 FMT_PEM
144} convert_format = FMT_RFC4716;
Damien Millereba71ba2000-04-29 23:57:08 +1000145int print_public = 0;
Damien Miller37876e92003-05-15 10:19:46 +1000146int print_generic = 0;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100147
Damien Millera41c8b12002-01-22 23:05:08 +1100148char *key_type_name = NULL;
Damien Millereba71ba2000-04-29 23:57:08 +1000149
Damien Miller757f34e2010-08-05 13:05:31 +1000150/* Load key from this PKCS#11 provider */
151char *pkcs11provider = NULL;
Damien Miller44b25042010-07-02 13:35:01 +1000152
Damien Miller431f66b1999-11-21 18:31:57 +1100153/* argv0 */
154extern char *__progname;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000155
Damien Millereba71ba2000-04-29 23:57:08 +1000156char hostname[MAXHOSTNAMELEN];
157
Darren Tucker770fc012004-05-13 16:24:32 +1000158/* moduli.c */
Damien Millerb089fb52005-05-26 12:16:18 +1000159int gen_candidates(FILE *, u_int32_t, u_int32_t, BIGNUM *);
Damien Millerdfceafe2012-07-06 13:44:19 +1000160int prime_test(FILE *, FILE *, u_int32_t, u_int32_t, char *, unsigned long,
161 unsigned long);
Darren Tucker770fc012004-05-13 16:24:32 +1000162
Ben Lindstrombba81212001-06-25 05:01:22 +0000163static void
Damien Miller884b63a2011-05-05 14:14:52 +1000164type_bits_valid(int type, u_int32_t *bitsp)
Damien Miller58f1baf2011-05-05 14:06:15 +1000165{
166 u_int maxbits;
167
168 if (type == KEY_UNSPEC) {
169 fprintf(stderr, "unknown key type %s\n", key_type_name);
170 exit(1);
171 }
Damien Miller884b63a2011-05-05 14:14:52 +1000172 if (*bitsp == 0) {
Damien Miller58f1baf2011-05-05 14:06:15 +1000173 if (type == KEY_DSA)
Damien Miller884b63a2011-05-05 14:14:52 +1000174 *bitsp = DEFAULT_BITS_DSA;
Damien Miller58f1baf2011-05-05 14:06:15 +1000175 else if (type == KEY_ECDSA)
Damien Miller884b63a2011-05-05 14:14:52 +1000176 *bitsp = DEFAULT_BITS_ECDSA;
Damien Miller58f1baf2011-05-05 14:06:15 +1000177 else
Damien Miller884b63a2011-05-05 14:14:52 +1000178 *bitsp = DEFAULT_BITS;
Damien Miller58f1baf2011-05-05 14:06:15 +1000179 }
180 maxbits = (type == KEY_DSA) ?
181 OPENSSL_DSA_MAX_MODULUS_BITS : OPENSSL_RSA_MAX_MODULUS_BITS;
Damien Miller884b63a2011-05-05 14:14:52 +1000182 if (*bitsp > maxbits) {
Damien Miller58f1baf2011-05-05 14:06:15 +1000183 fprintf(stderr, "key bits exceeds maximum %d\n", maxbits);
184 exit(1);
185 }
Damien Miller884b63a2011-05-05 14:14:52 +1000186 if (type == KEY_DSA && *bitsp != 1024)
Damien Miller58f1baf2011-05-05 14:06:15 +1000187 fatal("DSA keys must be 1024 bits");
Damien Miller884b63a2011-05-05 14:14:52 +1000188 else if (type != KEY_ECDSA && *bitsp < 768)
Damien Miller58f1baf2011-05-05 14:06:15 +1000189 fatal("Key must at least be 768 bits");
Damien Miller884b63a2011-05-05 14:14:52 +1000190 else if (type == KEY_ECDSA && key_ecdsa_bits_to_nid(*bitsp) == -1)
Damien Miller58f1baf2011-05-05 14:06:15 +1000191 fatal("Invalid ECDSA key length - valid lengths are "
192 "256, 384 or 521 bits");
193}
194
195static void
Damien Miller431f66b1999-11-21 18:31:57 +1100196ask_filename(struct passwd *pw, const char *prompt)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000197{
Damien Miller95def091999-11-25 00:26:21 +1100198 char buf[1024];
Damien Millere39cacc2000-11-29 12:18:44 +1100199 char *name = NULL;
200
Damien Miller993dd552002-02-19 15:22:47 +1100201 if (key_type_name == NULL)
Ben Lindstrom226cfa02001-01-22 05:34:40 +0000202 name = _PATH_SSH_CLIENT_ID_RSA;
Damien Miller90967402006-03-26 14:07:26 +1100203 else {
Damien Miller993dd552002-02-19 15:22:47 +1100204 switch (key_type_from_name(key_type_name)) {
205 case KEY_RSA1:
206 name = _PATH_SSH_CLIENT_IDENTITY;
207 break;
Damien Miller4e270b02010-04-16 15:56:21 +1000208 case KEY_DSA_CERT:
209 case KEY_DSA_CERT_V00:
Damien Miller993dd552002-02-19 15:22:47 +1100210 case KEY_DSA:
211 name = _PATH_SSH_CLIENT_ID_DSA;
212 break;
Damien Millerdd190dd2010-11-11 14:17:02 +1100213#ifdef OPENSSL_HAS_ECC
Damien Millereb8b60e2010-08-31 22:41:14 +1000214 case KEY_ECDSA_CERT:
215 case KEY_ECDSA:
216 name = _PATH_SSH_CLIENT_ID_ECDSA;
217 break;
Damien Millerdd190dd2010-11-11 14:17:02 +1100218#endif
Damien Miller4e270b02010-04-16 15:56:21 +1000219 case KEY_RSA_CERT:
220 case KEY_RSA_CERT_V00:
Damien Miller993dd552002-02-19 15:22:47 +1100221 case KEY_RSA:
222 name = _PATH_SSH_CLIENT_ID_RSA;
223 break;
224 default:
Damien Miller9eab9562009-02-22 08:47:02 +1100225 fprintf(stderr, "bad key type\n");
Damien Miller993dd552002-02-19 15:22:47 +1100226 exit(1);
227 break;
228 }
Damien Miller90967402006-03-26 14:07:26 +1100229 }
Damien Millere39cacc2000-11-29 12:18:44 +1100230 snprintf(identity_file, sizeof(identity_file), "%s/%s", pw->pw_dir, name);
Ben Lindstrom3deda8b2000-12-22 20:27:43 +0000231 fprintf(stderr, "%s (%s): ", prompt, identity_file);
Damien Miller95def091999-11-25 00:26:21 +1100232 if (fgets(buf, sizeof(buf), stdin) == NULL)
233 exit(1);
Damien Miller14b017d2007-09-17 16:09:15 +1000234 buf[strcspn(buf, "\n")] = '\0';
Damien Miller95def091999-11-25 00:26:21 +1100235 if (strcmp(buf, "") != 0)
236 strlcpy(identity_file, buf, sizeof(identity_file));
237 have_identity = 1;
Damien Miller10f6f6b1999-11-17 17:29:08 +1100238}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000239
Ben Lindstrombba81212001-06-25 05:01:22 +0000240static Key *
Ben Lindstromd78ae762001-06-05 20:35:09 +0000241load_identity(char *filename)
Damien Millereba71ba2000-04-29 23:57:08 +1000242{
Ben Lindstromd0fca422001-03-26 13:44:06 +0000243 char *pass;
244 Key *prv;
245
Ben Lindstroma3700052001-04-05 23:26:32 +0000246 prv = key_load_private(filename, "", NULL);
Ben Lindstromd0fca422001-03-26 13:44:06 +0000247 if (prv == NULL) {
Ben Lindstromd78ae762001-06-05 20:35:09 +0000248 if (identity_passphrase)
249 pass = xstrdup(identity_passphrase);
250 else
Ben Lindstrom949974b2001-06-25 05:20:31 +0000251 pass = read_passphrase("Enter passphrase: ",
252 RP_ALLOW_STDIN);
Ben Lindstromd0fca422001-03-26 13:44:06 +0000253 prv = key_load_private(filename, pass, NULL);
Damien Millereba71ba2000-04-29 23:57:08 +1000254 memset(pass, 0, strlen(pass));
Darren Tuckera627d422013-06-02 07:31:17 +1000255 free(pass);
Damien Millereba71ba2000-04-29 23:57:08 +1000256 }
Ben Lindstromd0fca422001-03-26 13:44:06 +0000257 return prv;
Damien Millereba71ba2000-04-29 23:57:08 +1000258}
259
Damien Miller874d77b2000-10-14 16:23:11 +1100260#define SSH_COM_PUBLIC_BEGIN "---- BEGIN SSH2 PUBLIC KEY ----"
Ben Lindstromcb72e4f2002-06-21 00:41:51 +0000261#define SSH_COM_PUBLIC_END "---- END SSH2 PUBLIC KEY ----"
Damien Miller874d77b2000-10-14 16:23:11 +1100262#define SSH_COM_PRIVATE_BEGIN "---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----"
Kevin Stevesef4eea92001-02-05 12:42:17 +0000263#define SSH_COM_PRIVATE_KEY_MAGIC 0x3f6ff9eb
Damien Millereba71ba2000-04-29 23:57:08 +1000264
Ben Lindstrombba81212001-06-25 05:01:22 +0000265static void
Damien Miller44b25042010-07-02 13:35:01 +1000266do_convert_to_ssh2(struct passwd *pw, Key *k)
Damien Millereba71ba2000-04-29 23:57:08 +1000267{
Ben Lindstromc58ab022002-02-26 18:15:09 +0000268 u_int len;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000269 u_char *blob;
Darren Tuckerd04758d2010-01-12 19:41:57 +1100270 char comment[61];
Damien Millereba71ba2000-04-29 23:57:08 +1000271
Damien Millera563cce2012-04-22 11:07:28 +1000272 if (k->type == KEY_RSA1) {
273 fprintf(stderr, "version 1 keys are not supported\n");
274 exit(1);
275 }
Ben Lindstrom99a30f12001-09-18 05:49:14 +0000276 if (key_to_blob(k, &blob, &len) <= 0) {
277 fprintf(stderr, "key_to_blob failed\n");
278 exit(1);
279 }
Darren Tuckerd04758d2010-01-12 19:41:57 +1100280 /* Comment + surrounds must fit into 72 chars (RFC 4716 sec 3.3) */
281 snprintf(comment, sizeof(comment),
282 "%u-bit %s, converted by %s@%s from OpenSSH",
Ben Lindstrom46c264f2001-04-24 16:56:58 +0000283 key_size(k), key_type(k),
Damien Millereba71ba2000-04-29 23:57:08 +1000284 pw->pw_name, hostname);
Darren Tuckerd04758d2010-01-12 19:41:57 +1100285
286 fprintf(stdout, "%s\n", SSH_COM_PUBLIC_BEGIN);
287 fprintf(stdout, "Comment: \"%s\"\n", comment);
Damien Millereba71ba2000-04-29 23:57:08 +1000288 dump_base64(stdout, blob, len);
Damien Miller874d77b2000-10-14 16:23:11 +1100289 fprintf(stdout, "%s\n", SSH_COM_PUBLIC_END);
Ben Lindstrom46c264f2001-04-24 16:56:58 +0000290 key_free(k);
Darren Tuckera627d422013-06-02 07:31:17 +1000291 free(blob);
Damien Millereba71ba2000-04-29 23:57:08 +1000292 exit(0);
293}
294
Ben Lindstrombba81212001-06-25 05:01:22 +0000295static void
Damien Miller44b25042010-07-02 13:35:01 +1000296do_convert_to_pkcs8(Key *k)
297{
298 switch (key_type_plain(k->type)) {
Damien Millera563cce2012-04-22 11:07:28 +1000299 case KEY_RSA1:
Damien Miller44b25042010-07-02 13:35:01 +1000300 case KEY_RSA:
301 if (!PEM_write_RSA_PUBKEY(stdout, k->rsa))
302 fatal("PEM_write_RSA_PUBKEY failed");
303 break;
304 case KEY_DSA:
305 if (!PEM_write_DSA_PUBKEY(stdout, k->dsa))
306 fatal("PEM_write_DSA_PUBKEY failed");
307 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000308#ifdef OPENSSL_HAS_ECC
Damien Millereb8b60e2010-08-31 22:41:14 +1000309 case KEY_ECDSA:
310 if (!PEM_write_EC_PUBKEY(stdout, k->ecdsa))
311 fatal("PEM_write_EC_PUBKEY failed");
312 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000313#endif
Damien Miller44b25042010-07-02 13:35:01 +1000314 default:
315 fatal("%s: unsupported key type %s", __func__, key_type(k));
316 }
317 exit(0);
318}
319
320static void
321do_convert_to_pem(Key *k)
322{
323 switch (key_type_plain(k->type)) {
Damien Millera563cce2012-04-22 11:07:28 +1000324 case KEY_RSA1:
Damien Miller44b25042010-07-02 13:35:01 +1000325 case KEY_RSA:
326 if (!PEM_write_RSAPublicKey(stdout, k->rsa))
327 fatal("PEM_write_RSAPublicKey failed");
328 break;
329#if notyet /* OpenSSH 0.9.8 lacks this function */
330 case KEY_DSA:
331 if (!PEM_write_DSAPublicKey(stdout, k->dsa))
332 fatal("PEM_write_DSAPublicKey failed");
333 break;
334#endif
Damien Millereb8b60e2010-08-31 22:41:14 +1000335 /* XXX ECDSA? */
Damien Miller44b25042010-07-02 13:35:01 +1000336 default:
337 fatal("%s: unsupported key type %s", __func__, key_type(k));
338 }
339 exit(0);
340}
341
342static void
343do_convert_to(struct passwd *pw)
344{
345 Key *k;
346 struct stat st;
347
348 if (!have_identity)
349 ask_filename(pw, "Enter file in which the key is");
350 if (stat(identity_file, &st) < 0)
351 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
352 if ((k = key_load_public(identity_file, NULL)) == NULL) {
353 if ((k = load_identity(identity_file)) == NULL) {
354 fprintf(stderr, "load failed\n");
355 exit(1);
356 }
357 }
Damien Miller44b25042010-07-02 13:35:01 +1000358
359 switch (convert_format) {
360 case FMT_RFC4716:
361 do_convert_to_ssh2(pw, k);
362 break;
363 case FMT_PKCS8:
364 do_convert_to_pkcs8(k);
365 break;
366 case FMT_PEM:
367 do_convert_to_pem(k);
368 break;
369 default:
370 fatal("%s: unknown key format %d", __func__, convert_format);
371 }
372 exit(0);
373}
374
375static void
Damien Miller874d77b2000-10-14 16:23:11 +1100376buffer_get_bignum_bits(Buffer *b, BIGNUM *value)
377{
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000378 u_int bignum_bits = buffer_get_int(b);
379 u_int bytes = (bignum_bits + 7) / 8;
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000380
Damien Miller874d77b2000-10-14 16:23:11 +1100381 if (buffer_len(b) < bytes)
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000382 fatal("buffer_get_bignum_bits: input buffer too small: "
383 "need %d have %d", bytes, buffer_len(b));
Darren Tucker0bc85572006-11-07 23:14:41 +1100384 if (BN_bin2bn(buffer_ptr(b), bytes, value) == NULL)
385 fatal("buffer_get_bignum_bits: BN_bin2bn failed");
Damien Miller874d77b2000-10-14 16:23:11 +1100386 buffer_consume(b, bytes);
387}
388
Ben Lindstrombba81212001-06-25 05:01:22 +0000389static Key *
Ben Lindstrom90fd8142002-02-26 18:09:42 +0000390do_convert_private_ssh2_from_blob(u_char *blob, u_int blen)
Damien Miller874d77b2000-10-14 16:23:11 +1100391{
392 Buffer b;
Damien Miller874d77b2000-10-14 16:23:11 +1100393 Key *key = NULL;
Damien Miller874d77b2000-10-14 16:23:11 +1100394 char *type, *cipher;
Ben Lindstrom511d69e2001-07-04 05:05:27 +0000395 u_char *sig, data[] = "abcde12345";
Ben Lindstrome586c4c2001-06-25 05:04:58 +0000396 int magic, rlen, ktype, i1, i2, i3, i4;
397 u_int slen;
398 u_long e;
Damien Miller874d77b2000-10-14 16:23:11 +1100399
400 buffer_init(&b);
401 buffer_append(&b, blob, blen);
402
Darren Tucker82a3d2b2007-02-19 22:10:25 +1100403 magic = buffer_get_int(&b);
Damien Miller874d77b2000-10-14 16:23:11 +1100404 if (magic != SSH_COM_PRIVATE_KEY_MAGIC) {
405 error("bad magic 0x%x != 0x%x", magic, SSH_COM_PRIVATE_KEY_MAGIC);
406 buffer_free(&b);
407 return NULL;
408 }
Ben Lindstrom34f91882001-06-25 04:47:54 +0000409 i1 = buffer_get_int(&b);
Damien Miller874d77b2000-10-14 16:23:11 +1100410 type = buffer_get_string(&b, NULL);
411 cipher = buffer_get_string(&b, NULL);
Ben Lindstrom34f91882001-06-25 04:47:54 +0000412 i2 = buffer_get_int(&b);
413 i3 = buffer_get_int(&b);
414 i4 = buffer_get_int(&b);
Damien Miller80163902007-01-05 16:30:16 +1100415 debug("ignore (%d %d %d %d)", i1, i2, i3, i4);
Damien Miller874d77b2000-10-14 16:23:11 +1100416 if (strcmp(cipher, "none") != 0) {
417 error("unsupported cipher %s", cipher);
Darren Tuckera627d422013-06-02 07:31:17 +1000418 free(cipher);
Damien Miller874d77b2000-10-14 16:23:11 +1100419 buffer_free(&b);
Darren Tuckera627d422013-06-02 07:31:17 +1000420 free(type);
Damien Miller874d77b2000-10-14 16:23:11 +1100421 return NULL;
422 }
Darren Tuckera627d422013-06-02 07:31:17 +1000423 free(cipher);
Damien Miller874d77b2000-10-14 16:23:11 +1100424
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000425 if (strstr(type, "dsa")) {
426 ktype = KEY_DSA;
427 } else if (strstr(type, "rsa")) {
428 ktype = KEY_RSA;
429 } else {
Darren Tucker7cfeecf2005-01-20 10:56:31 +1100430 buffer_free(&b);
Darren Tuckera627d422013-06-02 07:31:17 +1000431 free(type);
Damien Miller874d77b2000-10-14 16:23:11 +1100432 return NULL;
433 }
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000434 key = key_new_private(ktype);
Darren Tuckera627d422013-06-02 07:31:17 +1000435 free(type);
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000436
437 switch (key->type) {
438 case KEY_DSA:
439 buffer_get_bignum_bits(&b, key->dsa->p);
440 buffer_get_bignum_bits(&b, key->dsa->g);
441 buffer_get_bignum_bits(&b, key->dsa->q);
442 buffer_get_bignum_bits(&b, key->dsa->pub_key);
443 buffer_get_bignum_bits(&b, key->dsa->priv_key);
444 break;
445 case KEY_RSA:
Darren Tucker82a3d2b2007-02-19 22:10:25 +1100446 e = buffer_get_char(&b);
Ben Lindstrom34f91882001-06-25 04:47:54 +0000447 debug("e %lx", e);
448 if (e < 30) {
449 e <<= 8;
450 e += buffer_get_char(&b);
451 debug("e %lx", e);
452 e <<= 8;
453 e += buffer_get_char(&b);
454 debug("e %lx", e);
455 }
456 if (!BN_set_word(key->rsa->e, e)) {
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000457 buffer_free(&b);
458 key_free(key);
459 return NULL;
460 }
461 buffer_get_bignum_bits(&b, key->rsa->d);
462 buffer_get_bignum_bits(&b, key->rsa->n);
463 buffer_get_bignum_bits(&b, key->rsa->iqmp);
464 buffer_get_bignum_bits(&b, key->rsa->q);
465 buffer_get_bignum_bits(&b, key->rsa->p);
Ben Lindstromf7297dd2001-07-04 05:02:23 +0000466 rsa_generate_additional_parameters(key->rsa);
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000467 break;
468 }
Damien Miller874d77b2000-10-14 16:23:11 +1100469 rlen = buffer_len(&b);
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000470 if (rlen != 0)
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000471 error("do_convert_private_ssh2_from_blob: "
472 "remaining bytes in key blob %d", rlen);
Damien Miller874d77b2000-10-14 16:23:11 +1100473 buffer_free(&b);
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000474
Ben Lindstrome586c4c2001-06-25 05:04:58 +0000475 /* try the key */
476 key_sign(key, &sig, &slen, data, sizeof(data));
477 key_verify(key, sig, slen, data, sizeof(data));
Darren Tuckera627d422013-06-02 07:31:17 +1000478 free(sig);
Damien Miller874d77b2000-10-14 16:23:11 +1100479 return key;
480}
481
Damien Miller8056a9d2006-03-15 12:05:40 +1100482static int
483get_line(FILE *fp, char *line, size_t len)
484{
485 int c;
486 size_t pos = 0;
487
488 line[0] = '\0';
489 while ((c = fgetc(fp)) != EOF) {
490 if (pos >= len - 1) {
491 fprintf(stderr, "input line too long.\n");
492 exit(1);
493 }
Damien Miller90967402006-03-26 14:07:26 +1100494 switch (c) {
Damien Miller8056a9d2006-03-15 12:05:40 +1100495 case '\r':
496 c = fgetc(fp);
497 if (c != EOF && c != '\n' && ungetc(c, fp) == EOF) {
498 fprintf(stderr, "unget: %s\n", strerror(errno));
499 exit(1);
500 }
501 return pos;
502 case '\n':
503 return pos;
504 }
505 line[pos++] = c;
506 line[pos] = '\0';
507 }
Damien Miller6c7439f2007-01-05 16:29:55 +1100508 /* We reached EOF */
509 return -1;
Damien Miller8056a9d2006-03-15 12:05:40 +1100510}
511
Ben Lindstrombba81212001-06-25 05:01:22 +0000512static void
Damien Miller44b25042010-07-02 13:35:01 +1000513do_convert_from_ssh2(struct passwd *pw, Key **k, int *private)
Damien Millereba71ba2000-04-29 23:57:08 +1000514{
Damien Millereba71ba2000-04-29 23:57:08 +1000515 int blen;
Ben Lindstrom155b9812002-04-02 20:26:26 +0000516 u_int len;
Damien Miller8056a9d2006-03-15 12:05:40 +1100517 char line[1024];
Ben Lindstrom9e0ddd42001-09-18 05:41:19 +0000518 u_char blob[8096];
Damien Millereba71ba2000-04-29 23:57:08 +1000519 char encoded[8096];
Damien Miller44b25042010-07-02 13:35:01 +1000520 int escaped = 0;
Damien Millereba71ba2000-04-29 23:57:08 +1000521 FILE *fp;
522
Damien Millerba3420a2010-06-26 09:39:07 +1000523 if ((fp = fopen(identity_file, "r")) == NULL)
524 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
Damien Millereba71ba2000-04-29 23:57:08 +1000525 encoded[0] = '\0';
Damien Miller8056a9d2006-03-15 12:05:40 +1100526 while ((blen = get_line(fp, line, sizeof(line))) != -1) {
Damien Miller746d1a62013-07-18 16:13:02 +1000527 if (blen > 0 && line[blen - 1] == '\\')
Damien Miller30c3d422000-05-09 11:02:59 +1000528 escaped++;
Damien Millereba71ba2000-04-29 23:57:08 +1000529 if (strncmp(line, "----", 4) == 0 ||
530 strstr(line, ": ") != NULL) {
Damien Miller874d77b2000-10-14 16:23:11 +1100531 if (strstr(line, SSH_COM_PRIVATE_BEGIN) != NULL)
Damien Miller44b25042010-07-02 13:35:01 +1000532 *private = 1;
Ben Lindstrome586c4c2001-06-25 05:04:58 +0000533 if (strstr(line, " END ") != NULL) {
534 break;
535 }
Ben Lindstrom30358602001-04-24 16:59:28 +0000536 /* fprintf(stderr, "ignore: %s", line); */
Damien Millereba71ba2000-04-29 23:57:08 +1000537 continue;
538 }
Damien Miller30c3d422000-05-09 11:02:59 +1000539 if (escaped) {
540 escaped--;
Ben Lindstrom30358602001-04-24 16:59:28 +0000541 /* fprintf(stderr, "escaped: %s", line); */
Damien Miller30c3d422000-05-09 11:02:59 +1000542 continue;
Damien Millereba71ba2000-04-29 23:57:08 +1000543 }
Damien Millereba71ba2000-04-29 23:57:08 +1000544 strlcat(encoded, line, sizeof(encoded));
545 }
Ben Lindstrom155b9812002-04-02 20:26:26 +0000546 len = strlen(encoded);
547 if (((len % 4) == 3) &&
548 (encoded[len-1] == '=') &&
549 (encoded[len-2] == '=') &&
550 (encoded[len-3] == '='))
551 encoded[len-3] = '\0';
Damien Miller4a8ed542002-01-22 23:33:31 +1100552 blen = uudecode(encoded, blob, sizeof(blob));
Damien Millereba71ba2000-04-29 23:57:08 +1000553 if (blen < 0) {
554 fprintf(stderr, "uudecode failed.\n");
555 exit(1);
556 }
Damien Miller44b25042010-07-02 13:35:01 +1000557 *k = *private ?
Damien Miller874d77b2000-10-14 16:23:11 +1100558 do_convert_private_ssh2_from_blob(blob, blen) :
Damien Miller0bc1bd82000-11-13 22:57:25 +1100559 key_from_blob(blob, blen);
Damien Miller44b25042010-07-02 13:35:01 +1000560 if (*k == NULL) {
Damien Miller874d77b2000-10-14 16:23:11 +1100561 fprintf(stderr, "decode blob failed.\n");
562 exit(1);
563 }
Damien Miller44b25042010-07-02 13:35:01 +1000564 fclose(fp);
565}
566
567static void
568do_convert_from_pkcs8(Key **k, int *private)
569{
570 EVP_PKEY *pubkey;
571 FILE *fp;
572
573 if ((fp = fopen(identity_file, "r")) == NULL)
574 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
575 if ((pubkey = PEM_read_PUBKEY(fp, NULL, NULL, NULL)) == NULL) {
576 fatal("%s: %s is not a recognised public key format", __func__,
577 identity_file);
578 }
579 fclose(fp);
580 switch (EVP_PKEY_type(pubkey->type)) {
581 case EVP_PKEY_RSA:
582 *k = key_new(KEY_UNSPEC);
583 (*k)->type = KEY_RSA;
584 (*k)->rsa = EVP_PKEY_get1_RSA(pubkey);
585 break;
586 case EVP_PKEY_DSA:
587 *k = key_new(KEY_UNSPEC);
588 (*k)->type = KEY_DSA;
589 (*k)->dsa = EVP_PKEY_get1_DSA(pubkey);
590 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000591#ifdef OPENSSL_HAS_ECC
Damien Millereb8b60e2010-08-31 22:41:14 +1000592 case EVP_PKEY_EC:
593 *k = key_new(KEY_UNSPEC);
594 (*k)->type = KEY_ECDSA;
595 (*k)->ecdsa = EVP_PKEY_get1_EC_KEY(pubkey);
Damien Millerb472a902010-11-05 10:19:49 +1100596 (*k)->ecdsa_nid = key_ecdsa_key_to_nid((*k)->ecdsa);
Damien Millereb8b60e2010-08-31 22:41:14 +1000597 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000598#endif
Damien Miller44b25042010-07-02 13:35:01 +1000599 default:
600 fatal("%s: unsupported pubkey type %d", __func__,
601 EVP_PKEY_type(pubkey->type));
602 }
603 EVP_PKEY_free(pubkey);
604 return;
605}
606
607static void
608do_convert_from_pem(Key **k, int *private)
609{
610 FILE *fp;
611 RSA *rsa;
612#ifdef notyet
613 DSA *dsa;
614#endif
615
616 if ((fp = fopen(identity_file, "r")) == NULL)
617 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
618 if ((rsa = PEM_read_RSAPublicKey(fp, NULL, NULL, NULL)) != NULL) {
619 *k = key_new(KEY_UNSPEC);
620 (*k)->type = KEY_RSA;
621 (*k)->rsa = rsa;
622 fclose(fp);
623 return;
624 }
625#if notyet /* OpenSSH 0.9.8 lacks this function */
626 rewind(fp);
627 if ((dsa = PEM_read_DSAPublicKey(fp, NULL, NULL, NULL)) != NULL) {
628 *k = key_new(KEY_UNSPEC);
629 (*k)->type = KEY_DSA;
630 (*k)->dsa = dsa;
631 fclose(fp);
632 return;
633 }
Damien Millereb8b60e2010-08-31 22:41:14 +1000634 /* XXX ECDSA */
Damien Miller44b25042010-07-02 13:35:01 +1000635#endif
636 fatal("%s: unrecognised raw private key format", __func__);
637}
638
639static void
640do_convert_from(struct passwd *pw)
641{
642 Key *k = NULL;
Damien Miller844cccf2010-08-03 16:03:29 +1000643 int private = 0, ok = 0;
Damien Miller44b25042010-07-02 13:35:01 +1000644 struct stat st;
645
646 if (!have_identity)
647 ask_filename(pw, "Enter file in which the key is");
648 if (stat(identity_file, &st) < 0)
649 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
650
651 switch (convert_format) {
652 case FMT_RFC4716:
653 do_convert_from_ssh2(pw, &k, &private);
654 break;
655 case FMT_PKCS8:
656 do_convert_from_pkcs8(&k, &private);
657 break;
658 case FMT_PEM:
659 do_convert_from_pem(&k, &private);
660 break;
661 default:
662 fatal("%s: unknown key format %d", __func__, convert_format);
663 }
664
665 if (!private)
666 ok = key_write(k, stdout);
667 if (ok)
668 fprintf(stdout, "\n");
669 else {
670 switch (k->type) {
671 case KEY_DSA:
672 ok = PEM_write_DSAPrivateKey(stdout, k->dsa, NULL,
673 NULL, 0, NULL, NULL);
674 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000675#ifdef OPENSSL_HAS_ECC
Damien Millereb8b60e2010-08-31 22:41:14 +1000676 case KEY_ECDSA:
677 ok = PEM_write_ECPrivateKey(stdout, k->ecdsa, NULL,
678 NULL, 0, NULL, NULL);
679 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000680#endif
Damien Miller44b25042010-07-02 13:35:01 +1000681 case KEY_RSA:
682 ok = PEM_write_RSAPrivateKey(stdout, k->rsa, NULL,
683 NULL, 0, NULL, NULL);
684 break;
685 default:
686 fatal("%s: unsupported key type %s", __func__,
687 key_type(k));
688 }
689 }
690
Damien Miller874d77b2000-10-14 16:23:11 +1100691 if (!ok) {
Damien Miller9eab9562009-02-22 08:47:02 +1100692 fprintf(stderr, "key write failed\n");
Damien Miller874d77b2000-10-14 16:23:11 +1100693 exit(1);
694 }
Damien Millereba71ba2000-04-29 23:57:08 +1000695 key_free(k);
Damien Millereba71ba2000-04-29 23:57:08 +1000696 exit(0);
697}
698
Ben Lindstrombba81212001-06-25 05:01:22 +0000699static void
Damien Millereba71ba2000-04-29 23:57:08 +1000700do_print_public(struct passwd *pw)
701{
Ben Lindstromd0fca422001-03-26 13:44:06 +0000702 Key *prv;
Damien Millereba71ba2000-04-29 23:57:08 +1000703 struct stat st;
704
705 if (!have_identity)
706 ask_filename(pw, "Enter file in which the key is");
707 if (stat(identity_file, &st) < 0) {
708 perror(identity_file);
709 exit(1);
710 }
Ben Lindstromd78ae762001-06-05 20:35:09 +0000711 prv = load_identity(identity_file);
Ben Lindstromd0fca422001-03-26 13:44:06 +0000712 if (prv == NULL) {
Damien Millereba71ba2000-04-29 23:57:08 +1000713 fprintf(stderr, "load failed\n");
714 exit(1);
715 }
Ben Lindstromd0fca422001-03-26 13:44:06 +0000716 if (!key_write(prv, stdout))
Damien Millereba71ba2000-04-29 23:57:08 +1000717 fprintf(stderr, "key_write failed");
Ben Lindstromd0fca422001-03-26 13:44:06 +0000718 key_free(prv);
Damien Millereba71ba2000-04-29 23:57:08 +1000719 fprintf(stdout, "\n");
720 exit(0);
721}
722
Ben Lindstromcd392282001-07-04 03:44:03 +0000723static void
Damien Miller757f34e2010-08-05 13:05:31 +1000724do_download(struct passwd *pw)
Ben Lindstromcd392282001-07-04 03:44:03 +0000725{
Damien Miller7ea845e2010-02-12 09:21:02 +1100726#ifdef ENABLE_PKCS11
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000727 Key **keys = NULL;
Damien Miller7ea845e2010-02-12 09:21:02 +1100728 int i, nkeys;
Damien Millerec77c952013-01-09 15:58:00 +1100729 enum fp_rep rep;
730 enum fp_type fptype;
731 char *fp, *ra;
Ben Lindstrom8282d6a2001-08-06 21:44:05 +0000732
Damien Miller1422c082013-01-09 16:44:54 +1100733 fptype = print_bubblebabble ? SSH_FP_SHA1 : SSH_FP_MD5;
734 rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_HEX;
735
Damien Miller7ea845e2010-02-12 09:21:02 +1100736 pkcs11_init(0);
737 nkeys = pkcs11_add_provider(pkcs11provider, NULL, &keys);
738 if (nkeys <= 0)
739 fatal("cannot read public key from pkcs11");
740 for (i = 0; i < nkeys; i++) {
Damien Millerec77c952013-01-09 15:58:00 +1100741 if (print_fingerprint) {
742 fp = key_fingerprint(keys[i], fptype, rep);
743 ra = key_fingerprint(keys[i], SSH_FP_MD5,
744 SSH_FP_RANDOMART);
745 printf("%u %s %s (PKCS11 key)\n", key_size(keys[i]),
746 fp, key_type(keys[i]));
747 if (log_level >= SYSLOG_LEVEL_VERBOSE)
748 printf("%s\n", ra);
Darren Tuckera627d422013-06-02 07:31:17 +1000749 free(ra);
750 free(fp);
Damien Millerec77c952013-01-09 15:58:00 +1100751 } else {
752 key_write(keys[i], stdout);
753 fprintf(stdout, "\n");
754 }
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000755 key_free(keys[i]);
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000756 }
Darren Tuckera627d422013-06-02 07:31:17 +1000757 free(keys);
Damien Miller7ea845e2010-02-12 09:21:02 +1100758 pkcs11_terminate();
Ben Lindstrom8282d6a2001-08-06 21:44:05 +0000759 exit(0);
Damien Miller7ea845e2010-02-12 09:21:02 +1100760#else
761 fatal("no pkcs11 support");
762#endif /* ENABLE_PKCS11 */
Ben Lindstrom8282d6a2001-08-06 21:44:05 +0000763}
Ben Lindstromcd392282001-07-04 03:44:03 +0000764
Ben Lindstrombba81212001-06-25 05:01:22 +0000765static void
Damien Miller10f6f6b1999-11-17 17:29:08 +1100766do_fingerprint(struct passwd *pw)
767{
Damien Miller98c7ad62000-03-09 21:27:49 +1100768 FILE *f;
Damien Millereba71ba2000-04-29 23:57:08 +1000769 Key *public;
Darren Tucker9c16ac92008-06-13 04:40:35 +1000770 char *comment = NULL, *cp, *ep, line[16*1024], *fp, *ra;
Damien Millercb2fbb22008-02-10 22:24:55 +1100771 int i, skip = 0, num = 0, invalid = 1;
Ben Lindstrom65366a82001-12-06 16:32:47 +0000772 enum fp_rep rep;
773 enum fp_type fptype;
Damien Miller95def091999-11-25 00:26:21 +1100774 struct stat st;
Damien Miller10f6f6b1999-11-17 17:29:08 +1100775
Ben Lindstromd0fca422001-03-26 13:44:06 +0000776 fptype = print_bubblebabble ? SSH_FP_SHA1 : SSH_FP_MD5;
777 rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_HEX;
Ben Lindstrom8fd372b2001-03-12 03:02:17 +0000778
Damien Miller95def091999-11-25 00:26:21 +1100779 if (!have_identity)
780 ask_filename(pw, "Enter file in which the key is");
781 if (stat(identity_file, &st) < 0) {
782 perror(identity_file);
783 exit(1);
784 }
Ben Lindstromd0fca422001-03-26 13:44:06 +0000785 public = key_load_public(identity_file, &comment);
786 if (public != NULL) {
787 fp = key_fingerprint(public, fptype, rep);
Darren Tucker9bcd25b2009-10-07 08:45:48 +1100788 ra = key_fingerprint(public, SSH_FP_MD5, SSH_FP_RANDOMART);
Darren Tuckerb68fb4a2008-06-13 08:57:27 +1000789 printf("%u %s %s (%s)\n", key_size(public), fp, comment,
790 key_type(public));
Darren Tucker35c45532008-06-13 04:43:15 +1000791 if (log_level >= SYSLOG_LEVEL_VERBOSE)
792 printf("%s\n", ra);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100793 key_free(public);
Darren Tuckera627d422013-06-02 07:31:17 +1000794 free(comment);
795 free(ra);
796 free(fp);
Damien Miller98c7ad62000-03-09 21:27:49 +1100797 exit(0);
798 }
Damien Miller40b59852006-06-13 13:00:25 +1000799 if (comment) {
Darren Tuckera627d422013-06-02 07:31:17 +1000800 free(comment);
Damien Miller40b59852006-06-13 13:00:25 +1000801 comment = NULL;
802 }
Damien Miller98c7ad62000-03-09 21:27:49 +1100803
Damien Millerba3420a2010-06-26 09:39:07 +1000804 if ((f = fopen(identity_file, "r")) == NULL)
805 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
Damien Miller98c7ad62000-03-09 21:27:49 +1100806
Damien Millerba3420a2010-06-26 09:39:07 +1000807 while (fgets(line, sizeof(line), f)) {
808 if ((cp = strchr(line, '\n')) == NULL) {
809 error("line %d too long: %.40s...",
810 num + 1, line);
811 skip = 1;
812 continue;
Damien Miller95def091999-11-25 00:26:21 +1100813 }
Damien Millerba3420a2010-06-26 09:39:07 +1000814 num++;
815 if (skip) {
816 skip = 0;
817 continue;
818 }
819 *cp = '\0';
820
821 /* Skip leading whitespace, empty and comment lines. */
822 for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
823 ;
824 if (!*cp || *cp == '\n' || *cp == '#')
825 continue;
826 i = strtol(cp, &ep, 10);
827 if (i == 0 || ep == NULL || (*ep != ' ' && *ep != '\t')) {
828 int quoted = 0;
829 comment = cp;
830 for (; *cp && (quoted || (*cp != ' ' &&
831 *cp != '\t')); cp++) {
832 if (*cp == '\\' && cp[1] == '"')
833 cp++; /* Skip both */
834 else if (*cp == '"')
835 quoted = !quoted;
836 }
837 if (!*cp)
838 continue;
839 *cp++ = '\0';
840 }
841 ep = cp;
842 public = key_new(KEY_RSA1);
843 if (key_read(public, &cp) != 1) {
844 cp = ep;
845 key_free(public);
846 public = key_new(KEY_UNSPEC);
847 if (key_read(public, &cp) != 1) {
848 key_free(public);
849 continue;
850 }
851 }
852 comment = *cp ? cp : comment;
853 fp = key_fingerprint(public, fptype, rep);
854 ra = key_fingerprint(public, SSH_FP_MD5, SSH_FP_RANDOMART);
855 printf("%u %s %s (%s)\n", key_size(public), fp,
856 comment ? comment : "no comment", key_type(public));
857 if (log_level >= SYSLOG_LEVEL_VERBOSE)
858 printf("%s\n", ra);
Darren Tuckera627d422013-06-02 07:31:17 +1000859 free(ra);
860 free(fp);
Damien Millerba3420a2010-06-26 09:39:07 +1000861 key_free(public);
862 invalid = 0;
Damien Miller95def091999-11-25 00:26:21 +1100863 }
Damien Millerba3420a2010-06-26 09:39:07 +1000864 fclose(f);
865
Damien Miller98c7ad62000-03-09 21:27:49 +1100866 if (invalid) {
Damien Millereb5fec62001-11-12 10:52:44 +1100867 printf("%s is not a public key file.\n", identity_file);
Damien Miller98c7ad62000-03-09 21:27:49 +1100868 exit(1);
869 }
Damien Miller95def091999-11-25 00:26:21 +1100870 exit(0);
Damien Miller10f6f6b1999-11-17 17:29:08 +1100871}
872
Damien Miller4b42d7f2005-03-01 21:48:35 +1100873static void
Damien Miller58f1baf2011-05-05 14:06:15 +1000874do_gen_all_hostkeys(struct passwd *pw)
875{
876 struct {
877 char *key_type;
878 char *key_type_display;
879 char *path;
880 } key_types[] = {
881 { "rsa1", "RSA1", _PATH_HOST_KEY_FILE },
882 { "rsa", "RSA" ,_PATH_HOST_RSA_KEY_FILE },
883 { "dsa", "DSA", _PATH_HOST_DSA_KEY_FILE },
Damien Millerb56e4932012-02-06 07:41:27 +1100884#ifdef OPENSSL_HAS_ECC
Damien Miller58f1baf2011-05-05 14:06:15 +1000885 { "ecdsa", "ECDSA",_PATH_HOST_ECDSA_KEY_FILE },
Damien Millerb56e4932012-02-06 07:41:27 +1100886#endif
Damien Miller58f1baf2011-05-05 14:06:15 +1000887 { NULL, NULL, NULL }
888 };
889
890 int first = 0;
891 struct stat st;
892 Key *private, *public;
893 char comment[1024];
894 int i, type, fd;
895 FILE *f;
896
897 for (i = 0; key_types[i].key_type; i++) {
898 if (stat(key_types[i].path, &st) == 0)
899 continue;
900 if (errno != ENOENT) {
901 printf("Could not stat %s: %s", key_types[i].path,
902 strerror(errno));
903 first = 0;
904 continue;
905 }
906
907 if (first == 0) {
908 first = 1;
909 printf("%s: generating new host keys: ", __progname);
910 }
911 printf("%s ", key_types[i].key_type_display);
912 fflush(stdout);
913 arc4random_stir();
914 type = key_type_from_name(key_types[i].key_type);
915 strlcpy(identity_file, key_types[i].path, sizeof(identity_file));
916 bits = 0;
917 type_bits_valid(type, &bits);
918 private = key_generate(type, bits);
919 if (private == NULL) {
920 fprintf(stderr, "key_generate failed\n");
921 first = 0;
922 continue;
923 }
924 public = key_from_private(private);
925 snprintf(comment, sizeof comment, "%s@%s", pw->pw_name,
926 hostname);
927 if (!key_save_private(private, identity_file, "", comment)) {
928 printf("Saving the key failed: %s.\n", identity_file);
929 key_free(private);
930 key_free(public);
931 first = 0;
932 continue;
933 }
934 key_free(private);
935 arc4random_stir();
936 strlcat(identity_file, ".pub", sizeof(identity_file));
937 fd = open(identity_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
938 if (fd == -1) {
939 printf("Could not save your public key in %s\n",
940 identity_file);
941 key_free(public);
942 first = 0;
943 continue;
944 }
945 f = fdopen(fd, "w");
946 if (f == NULL) {
947 printf("fdopen %s failed\n", identity_file);
948 key_free(public);
949 first = 0;
950 continue;
951 }
952 if (!key_write(public, f)) {
953 fprintf(stderr, "write key failed\n");
954 key_free(public);
955 first = 0;
956 continue;
957 }
958 fprintf(f, " %s\n", comment);
959 fclose(f);
960 key_free(public);
961
962 }
963 if (first != 0)
964 printf("\n");
965}
966
967static void
Damien Miller0a80ca12010-02-27 07:55:05 +1100968printhost(FILE *f, const char *name, Key *public, int ca, int hash)
Damien Miller4b42d7f2005-03-01 21:48:35 +1100969{
Darren Tucker0f7e9102008-06-08 12:54:29 +1000970 if (print_fingerprint) {
971 enum fp_rep rep;
972 enum fp_type fptype;
Darren Tucker9c16ac92008-06-13 04:40:35 +1000973 char *fp, *ra;
Darren Tucker0f7e9102008-06-08 12:54:29 +1000974
975 fptype = print_bubblebabble ? SSH_FP_SHA1 : SSH_FP_MD5;
976 rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_HEX;
977 fp = key_fingerprint(public, fptype, rep);
Darren Tucker9bcd25b2009-10-07 08:45:48 +1100978 ra = key_fingerprint(public, SSH_FP_MD5, SSH_FP_RANDOMART);
Damien Miller81dec052008-07-14 11:28:29 +1000979 printf("%u %s %s (%s)\n", key_size(public), fp, name,
980 key_type(public));
981 if (log_level >= SYSLOG_LEVEL_VERBOSE)
982 printf("%s\n", ra);
Darren Tuckera627d422013-06-02 07:31:17 +1000983 free(ra);
984 free(fp);
Darren Tucker0f7e9102008-06-08 12:54:29 +1000985 } else {
986 if (hash && (name = host_hash(name, NULL, 0)) == NULL)
987 fatal("hash_host failed");
Damien Miller0a80ca12010-02-27 07:55:05 +1100988 fprintf(f, "%s%s%s ", ca ? CA_MARKER : "", ca ? " " : "", name);
Darren Tucker0f7e9102008-06-08 12:54:29 +1000989 if (!key_write(public, f))
990 fatal("key_write failed");
991 fprintf(f, "\n");
992 }
Damien Miller4b42d7f2005-03-01 21:48:35 +1100993}
994
995static void
996do_known_hosts(struct passwd *pw, const char *name)
997{
998 FILE *in, *out = stdout;
Damien Miller0a80ca12010-02-27 07:55:05 +1100999 Key *pub;
Damien Miller4b42d7f2005-03-01 21:48:35 +11001000 char *cp, *cp2, *kp, *kp2;
1001 char line[16*1024], tmp[MAXPATHLEN], old[MAXPATHLEN];
Damien Millercb2fbb22008-02-10 22:24:55 +11001002 int c, skip = 0, inplace = 0, num = 0, invalid = 0, has_unhashed = 0;
Damien Miller0a80ca12010-02-27 07:55:05 +11001003 int ca;
Damien Miller4b42d7f2005-03-01 21:48:35 +11001004
1005 if (!have_identity) {
1006 cp = tilde_expand_filename(_PATH_SSH_USER_HOSTFILE, pw->pw_uid);
1007 if (strlcpy(identity_file, cp, sizeof(identity_file)) >=
1008 sizeof(identity_file))
1009 fatal("Specified known hosts path too long");
Darren Tuckera627d422013-06-02 07:31:17 +10001010 free(cp);
Damien Miller4b42d7f2005-03-01 21:48:35 +11001011 have_identity = 1;
1012 }
1013 if ((in = fopen(identity_file, "r")) == NULL)
Damien Millerba3420a2010-06-26 09:39:07 +10001014 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
Damien Miller4b42d7f2005-03-01 21:48:35 +11001015
1016 /*
1017 * Find hosts goes to stdout, hash and deletions happen in-place
1018 * A corner case is ssh-keygen -HF foo, which should go to stdout
1019 */
1020 if (!find_host && (hash_hosts || delete_host)) {
1021 if (strlcpy(tmp, identity_file, sizeof(tmp)) >= sizeof(tmp) ||
1022 strlcat(tmp, ".XXXXXXXXXX", sizeof(tmp)) >= sizeof(tmp) ||
1023 strlcpy(old, identity_file, sizeof(old)) >= sizeof(old) ||
1024 strlcat(old, ".old", sizeof(old)) >= sizeof(old))
1025 fatal("known_hosts path too long");
1026 umask(077);
1027 if ((c = mkstemp(tmp)) == -1)
1028 fatal("mkstemp: %s", strerror(errno));
1029 if ((out = fdopen(c, "w")) == NULL) {
1030 c = errno;
1031 unlink(tmp);
1032 fatal("fdopen: %s", strerror(c));
1033 }
1034 inplace = 1;
1035 }
1036
1037 while (fgets(line, sizeof(line), in)) {
Damien Miller0f4ed692007-10-26 14:26:32 +10001038 if ((cp = strchr(line, '\n')) == NULL) {
Damien Millercb2fbb22008-02-10 22:24:55 +11001039 error("line %d too long: %.40s...", num + 1, line);
Damien Miller4b42d7f2005-03-01 21:48:35 +11001040 skip = 1;
1041 invalid = 1;
1042 continue;
1043 }
Damien Miller0f4ed692007-10-26 14:26:32 +10001044 num++;
Damien Miller4b42d7f2005-03-01 21:48:35 +11001045 if (skip) {
1046 skip = 0;
1047 continue;
1048 }
Damien Miller0f4ed692007-10-26 14:26:32 +10001049 *cp = '\0';
Damien Miller4b42d7f2005-03-01 21:48:35 +11001050
1051 /* Skip leading whitespace, empty and comment lines. */
1052 for (cp = line; *cp == ' ' || *cp == '\t'; cp++)
1053 ;
1054 if (!*cp || *cp == '\n' || *cp == '#') {
1055 if (inplace)
1056 fprintf(out, "%s\n", cp);
1057 continue;
1058 }
Damien Miller0a80ca12010-02-27 07:55:05 +11001059 /* Check whether this is a CA key */
1060 if (strncasecmp(cp, CA_MARKER, sizeof(CA_MARKER) - 1) == 0 &&
1061 (cp[sizeof(CA_MARKER) - 1] == ' ' ||
1062 cp[sizeof(CA_MARKER) - 1] == '\t')) {
1063 ca = 1;
1064 cp += sizeof(CA_MARKER);
1065 } else
1066 ca = 0;
1067
Damien Miller4b42d7f2005-03-01 21:48:35 +11001068 /* Find the end of the host name portion. */
1069 for (kp = cp; *kp && *kp != ' ' && *kp != '\t'; kp++)
1070 ;
Damien Miller0a80ca12010-02-27 07:55:05 +11001071
Damien Miller4b42d7f2005-03-01 21:48:35 +11001072 if (*kp == '\0' || *(kp + 1) == '\0') {
1073 error("line %d missing key: %.40s...",
1074 num, line);
1075 invalid = 1;
1076 continue;
1077 }
1078 *kp++ = '\0';
1079 kp2 = kp;
1080
Damien Miller0a80ca12010-02-27 07:55:05 +11001081 pub = key_new(KEY_RSA1);
1082 if (key_read(pub, &kp) != 1) {
Damien Miller4b42d7f2005-03-01 21:48:35 +11001083 kp = kp2;
Damien Miller0a80ca12010-02-27 07:55:05 +11001084 key_free(pub);
1085 pub = key_new(KEY_UNSPEC);
1086 if (key_read(pub, &kp) != 1) {
Damien Miller4b42d7f2005-03-01 21:48:35 +11001087 error("line %d invalid key: %.40s...",
1088 num, line);
Damien Miller0a80ca12010-02-27 07:55:05 +11001089 key_free(pub);
Damien Miller4b42d7f2005-03-01 21:48:35 +11001090 invalid = 1;
1091 continue;
1092 }
1093 }
1094
1095 if (*cp == HASH_DELIM) {
1096 if (find_host || delete_host) {
1097 cp2 = host_hash(name, cp, strlen(cp));
1098 if (cp2 == NULL) {
1099 error("line %d: invalid hashed "
1100 "name: %.64s...", num, line);
1101 invalid = 1;
1102 continue;
1103 }
1104 c = (strcmp(cp2, cp) == 0);
1105 if (find_host && c) {
1106 printf("# Host %s found: "
Damien Miller0a80ca12010-02-27 07:55:05 +11001107 "line %d type %s%s\n", name,
1108 num, key_type(pub),
1109 ca ? " (CA key)" : "");
1110 printhost(out, cp, pub, ca, 0);
Damien Miller4b42d7f2005-03-01 21:48:35 +11001111 }
Darren Tuckerf09a8a62012-09-06 21:20:39 +10001112 if (delete_host) {
1113 if (!c && !ca)
1114 printhost(out, cp, pub, ca, 0);
1115 else
1116 printf("# Host %s found: "
1117 "line %d type %s\n", name,
1118 num, key_type(pub));
1119 }
Damien Miller4b42d7f2005-03-01 21:48:35 +11001120 } else if (hash_hosts)
Damien Miller0a80ca12010-02-27 07:55:05 +11001121 printhost(out, cp, pub, ca, 0);
Damien Miller4b42d7f2005-03-01 21:48:35 +11001122 } else {
1123 if (find_host || delete_host) {
1124 c = (match_hostname(name, cp,
1125 strlen(cp)) == 1);
1126 if (find_host && c) {
1127 printf("# Host %s found: "
Damien Miller0a80ca12010-02-27 07:55:05 +11001128 "line %d type %s%s\n", name,
1129 num, key_type(pub),
1130 ca ? " (CA key)" : "");
1131 printhost(out, name, pub,
1132 ca, hash_hosts && !ca);
Damien Miller4b42d7f2005-03-01 21:48:35 +11001133 }
Darren Tuckerf09a8a62012-09-06 21:20:39 +10001134 if (delete_host) {
1135 if (!c && !ca)
1136 printhost(out, cp, pub, ca, 0);
1137 else
1138 printf("# Host %s found: "
1139 "line %d type %s\n", name,
1140 num, key_type(pub));
1141 }
Damien Miller4b42d7f2005-03-01 21:48:35 +11001142 } else if (hash_hosts) {
Darren Tucker47eede72005-03-14 23:08:12 +11001143 for (cp2 = strsep(&cp, ",");
Damien Miller4b42d7f2005-03-01 21:48:35 +11001144 cp2 != NULL && *cp2 != '\0';
Damien Miller89eac802005-03-02 12:33:04 +11001145 cp2 = strsep(&cp, ",")) {
Damien Miller0a80ca12010-02-27 07:55:05 +11001146 if (ca) {
1147 fprintf(stderr, "Warning: "
1148 "ignoring CA key for host: "
1149 "%.64s\n", cp2);
1150 printhost(out, cp2, pub, ca, 0);
1151 } else if (strcspn(cp2, "*?!") !=
1152 strlen(cp2)) {
Damien Miller89eac802005-03-02 12:33:04 +11001153 fprintf(stderr, "Warning: "
1154 "ignoring host name with "
1155 "metacharacters: %.64s\n",
1156 cp2);
Damien Miller0a80ca12010-02-27 07:55:05 +11001157 printhost(out, cp2, pub, ca, 0);
1158 } else
1159 printhost(out, cp2, pub, ca, 1);
Damien Miller89eac802005-03-02 12:33:04 +11001160 }
Damien Miller4b42d7f2005-03-01 21:48:35 +11001161 has_unhashed = 1;
1162 }
1163 }
Damien Miller0a80ca12010-02-27 07:55:05 +11001164 key_free(pub);
Damien Miller4b42d7f2005-03-01 21:48:35 +11001165 }
1166 fclose(in);
1167
1168 if (invalid) {
Damien Millercb2fbb22008-02-10 22:24:55 +11001169 fprintf(stderr, "%s is not a valid known_hosts file.\n",
Damien Miller4b42d7f2005-03-01 21:48:35 +11001170 identity_file);
1171 if (inplace) {
1172 fprintf(stderr, "Not replacing existing known_hosts "
Darren Tucker9f438a92005-03-14 23:09:18 +11001173 "file because of errors\n");
Damien Miller4b42d7f2005-03-01 21:48:35 +11001174 fclose(out);
1175 unlink(tmp);
1176 }
1177 exit(1);
1178 }
1179
1180 if (inplace) {
1181 fclose(out);
1182
1183 /* Backup existing file */
1184 if (unlink(old) == -1 && errno != ENOENT)
1185 fatal("unlink %.100s: %s", old, strerror(errno));
1186 if (link(identity_file, old) == -1)
1187 fatal("link %.100s to %.100s: %s", identity_file, old,
1188 strerror(errno));
1189 /* Move new one into place */
1190 if (rename(tmp, identity_file) == -1) {
1191 error("rename\"%s\" to \"%s\": %s", tmp, identity_file,
1192 strerror(errno));
1193 unlink(tmp);
1194 unlink(old);
1195 exit(1);
1196 }
1197
1198 fprintf(stderr, "%s updated.\n", identity_file);
1199 fprintf(stderr, "Original contents retained as %s\n", old);
1200 if (has_unhashed) {
1201 fprintf(stderr, "WARNING: %s contains unhashed "
1202 "entries\n", old);
1203 fprintf(stderr, "Delete this file to ensure privacy "
Damien Miller0dc1bef2005-07-17 17:22:45 +10001204 "of hostnames\n");
Damien Miller4b42d7f2005-03-01 21:48:35 +11001205 }
1206 }
1207
1208 exit(0);
1209}
1210
Damien Miller95def091999-11-25 00:26:21 +11001211/*
1212 * Perform changing a passphrase. The argument is the passwd structure
1213 * for the current user.
1214 */
Ben Lindstrombba81212001-06-25 05:01:22 +00001215static void
Damien Miller10f6f6b1999-11-17 17:29:08 +11001216do_change_passphrase(struct passwd *pw)
1217{
Damien Miller95def091999-11-25 00:26:21 +11001218 char *comment;
1219 char *old_passphrase, *passphrase1, *passphrase2;
1220 struct stat st;
Damien Millereba71ba2000-04-29 23:57:08 +10001221 Key *private;
Damien Miller10f6f6b1999-11-17 17:29:08 +11001222
Damien Miller95def091999-11-25 00:26:21 +11001223 if (!have_identity)
1224 ask_filename(pw, "Enter file in which the key is");
Damien Miller95def091999-11-25 00:26:21 +11001225 if (stat(identity_file, &st) < 0) {
1226 perror(identity_file);
1227 exit(1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001228 }
Damien Miller95def091999-11-25 00:26:21 +11001229 /* Try to load the file with empty passphrase. */
Ben Lindstromd0fca422001-03-26 13:44:06 +00001230 private = key_load_private(identity_file, "", &comment);
1231 if (private == NULL) {
Damien Miller95def091999-11-25 00:26:21 +11001232 if (identity_passphrase)
1233 old_passphrase = xstrdup(identity_passphrase);
1234 else
Ben Lindstrom949974b2001-06-25 05:20:31 +00001235 old_passphrase =
1236 read_passphrase("Enter old passphrase: ",
1237 RP_ALLOW_STDIN);
1238 private = key_load_private(identity_file, old_passphrase,
1239 &comment);
Ben Lindstromd0fca422001-03-26 13:44:06 +00001240 memset(old_passphrase, 0, strlen(old_passphrase));
Darren Tuckera627d422013-06-02 07:31:17 +10001241 free(old_passphrase);
Ben Lindstromd0fca422001-03-26 13:44:06 +00001242 if (private == NULL) {
Damien Miller95def091999-11-25 00:26:21 +11001243 printf("Bad passphrase.\n");
1244 exit(1);
1245 }
Damien Miller95def091999-11-25 00:26:21 +11001246 }
1247 printf("Key has comment '%s'\n", comment);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001248
Damien Miller95def091999-11-25 00:26:21 +11001249 /* Ask the new passphrase (twice). */
1250 if (identity_new_passphrase) {
1251 passphrase1 = xstrdup(identity_new_passphrase);
1252 passphrase2 = NULL;
1253 } else {
1254 passphrase1 =
Ben Lindstrom949974b2001-06-25 05:20:31 +00001255 read_passphrase("Enter new passphrase (empty for no "
1256 "passphrase): ", RP_ALLOW_STDIN);
1257 passphrase2 = read_passphrase("Enter same passphrase again: ",
Damien Miller9f0f5c62001-12-21 14:45:46 +11001258 RP_ALLOW_STDIN);
Damien Miller95def091999-11-25 00:26:21 +11001259
1260 /* Verify that they are the same. */
1261 if (strcmp(passphrase1, passphrase2) != 0) {
1262 memset(passphrase1, 0, strlen(passphrase1));
1263 memset(passphrase2, 0, strlen(passphrase2));
Darren Tuckera627d422013-06-02 07:31:17 +10001264 free(passphrase1);
1265 free(passphrase2);
Damien Miller95def091999-11-25 00:26:21 +11001266 printf("Pass phrases do not match. Try again.\n");
1267 exit(1);
1268 }
1269 /* Destroy the other copy. */
1270 memset(passphrase2, 0, strlen(passphrase2));
Darren Tuckera627d422013-06-02 07:31:17 +10001271 free(passphrase2);
Damien Miller95def091999-11-25 00:26:21 +11001272 }
1273
1274 /* Save the file using the new passphrase. */
Ben Lindstromd0fca422001-03-26 13:44:06 +00001275 if (!key_save_private(private, identity_file, passphrase1, comment)) {
Ben Lindstrom15f33862001-04-16 02:00:02 +00001276 printf("Saving the key failed: %s.\n", identity_file);
Damien Miller95def091999-11-25 00:26:21 +11001277 memset(passphrase1, 0, strlen(passphrase1));
Darren Tuckera627d422013-06-02 07:31:17 +10001278 free(passphrase1);
Damien Millereba71ba2000-04-29 23:57:08 +10001279 key_free(private);
Darren Tuckera627d422013-06-02 07:31:17 +10001280 free(comment);
Damien Miller95def091999-11-25 00:26:21 +11001281 exit(1);
1282 }
1283 /* Destroy the passphrase and the copy of the key in memory. */
1284 memset(passphrase1, 0, strlen(passphrase1));
Darren Tuckera627d422013-06-02 07:31:17 +10001285 free(passphrase1);
Damien Millereba71ba2000-04-29 23:57:08 +10001286 key_free(private); /* Destroys contents */
Darren Tuckera627d422013-06-02 07:31:17 +10001287 free(comment);
Damien Miller95def091999-11-25 00:26:21 +11001288
1289 printf("Your identification has been saved with the new passphrase.\n");
1290 exit(0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001291}
1292
Damien Miller37876e92003-05-15 10:19:46 +10001293/*
1294 * Print the SSHFP RR.
1295 */
Damien Millercb314822006-03-26 13:48:01 +11001296static int
1297do_print_resource_record(struct passwd *pw, char *fname, char *hname)
Damien Miller37876e92003-05-15 10:19:46 +10001298{
1299 Key *public;
1300 char *comment = NULL;
1301 struct stat st;
1302
Damien Millercb314822006-03-26 13:48:01 +11001303 if (fname == NULL)
Damien Miller5bb88332013-07-18 16:13:37 +10001304 fatal("%s: no filename", __func__);
Damien Millercb314822006-03-26 13:48:01 +11001305 if (stat(fname, &st) < 0) {
1306 if (errno == ENOENT)
1307 return 0;
1308 perror(fname);
Damien Miller37876e92003-05-15 10:19:46 +10001309 exit(1);
1310 }
Damien Millercb314822006-03-26 13:48:01 +11001311 public = key_load_public(fname, &comment);
Damien Miller37876e92003-05-15 10:19:46 +10001312 if (public != NULL) {
Darren Tucker3f9fdc72004-06-22 12:56:01 +10001313 export_dns_rr(hname, public, stdout, print_generic);
Damien Miller37876e92003-05-15 10:19:46 +10001314 key_free(public);
Darren Tuckera627d422013-06-02 07:31:17 +10001315 free(comment);
Damien Millercb314822006-03-26 13:48:01 +11001316 return 1;
Damien Miller37876e92003-05-15 10:19:46 +10001317 }
1318 if (comment)
Darren Tuckera627d422013-06-02 07:31:17 +10001319 free(comment);
Damien Miller37876e92003-05-15 10:19:46 +10001320
Damien Millercb314822006-03-26 13:48:01 +11001321 printf("failed to read v2 public key from %s.\n", fname);
Damien Miller37876e92003-05-15 10:19:46 +10001322 exit(1);
1323}
Damien Miller37876e92003-05-15 10:19:46 +10001324
Damien Miller95def091999-11-25 00:26:21 +11001325/*
1326 * Change the comment of a private key file.
1327 */
Ben Lindstrombba81212001-06-25 05:01:22 +00001328static void
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001329do_change_comment(struct passwd *pw)
1330{
Ben Lindstrom5fc62702001-03-09 18:19:24 +00001331 char new_comment[1024], *comment, *passphrase;
Ben Lindstromd0fca422001-03-26 13:44:06 +00001332 Key *private;
1333 Key *public;
Damien Miller95def091999-11-25 00:26:21 +11001334 struct stat st;
1335 FILE *f;
Ben Lindstrom5fc62702001-03-09 18:19:24 +00001336 int fd;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001337
Damien Miller95def091999-11-25 00:26:21 +11001338 if (!have_identity)
1339 ask_filename(pw, "Enter file in which the key is");
Damien Miller95def091999-11-25 00:26:21 +11001340 if (stat(identity_file, &st) < 0) {
1341 perror(identity_file);
1342 exit(1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001343 }
Ben Lindstromd0fca422001-03-26 13:44:06 +00001344 private = key_load_private(identity_file, "", &comment);
1345 if (private == NULL) {
Damien Miller95def091999-11-25 00:26:21 +11001346 if (identity_passphrase)
1347 passphrase = xstrdup(identity_passphrase);
1348 else if (identity_new_passphrase)
1349 passphrase = xstrdup(identity_new_passphrase);
1350 else
Ben Lindstrom949974b2001-06-25 05:20:31 +00001351 passphrase = read_passphrase("Enter passphrase: ",
1352 RP_ALLOW_STDIN);
Damien Miller95def091999-11-25 00:26:21 +11001353 /* Try to load using the passphrase. */
Ben Lindstromd0fca422001-03-26 13:44:06 +00001354 private = key_load_private(identity_file, passphrase, &comment);
1355 if (private == NULL) {
Damien Miller95def091999-11-25 00:26:21 +11001356 memset(passphrase, 0, strlen(passphrase));
Darren Tuckera627d422013-06-02 07:31:17 +10001357 free(passphrase);
Damien Miller95def091999-11-25 00:26:21 +11001358 printf("Bad passphrase.\n");
1359 exit(1);
1360 }
Ben Lindstromd0fca422001-03-26 13:44:06 +00001361 } else {
1362 passphrase = xstrdup("");
Damien Miller95def091999-11-25 00:26:21 +11001363 }
Ben Lindstromd0fca422001-03-26 13:44:06 +00001364 if (private->type != KEY_RSA1) {
1365 fprintf(stderr, "Comments are only supported for RSA1 keys.\n");
1366 key_free(private);
1367 exit(1);
Damien Miller9f0f5c62001-12-21 14:45:46 +11001368 }
Damien Miller95def091999-11-25 00:26:21 +11001369 printf("Key now has comment '%s'\n", comment);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001370
Damien Miller95def091999-11-25 00:26:21 +11001371 if (identity_comment) {
1372 strlcpy(new_comment, identity_comment, sizeof(new_comment));
1373 } else {
1374 printf("Enter new comment: ");
1375 fflush(stdout);
1376 if (!fgets(new_comment, sizeof(new_comment), stdin)) {
1377 memset(passphrase, 0, strlen(passphrase));
Damien Millereba71ba2000-04-29 23:57:08 +10001378 key_free(private);
Damien Miller95def091999-11-25 00:26:21 +11001379 exit(1);
1380 }
Damien Miller14b017d2007-09-17 16:09:15 +10001381 new_comment[strcspn(new_comment, "\n")] = '\0';
Damien Miller95def091999-11-25 00:26:21 +11001382 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001383
Damien Miller95def091999-11-25 00:26:21 +11001384 /* Save the file using the new passphrase. */
Ben Lindstromd0fca422001-03-26 13:44:06 +00001385 if (!key_save_private(private, identity_file, passphrase, new_comment)) {
Ben Lindstrom15f33862001-04-16 02:00:02 +00001386 printf("Saving the key failed: %s.\n", identity_file);
Damien Miller95def091999-11-25 00:26:21 +11001387 memset(passphrase, 0, strlen(passphrase));
Darren Tuckera627d422013-06-02 07:31:17 +10001388 free(passphrase);
Damien Millereba71ba2000-04-29 23:57:08 +10001389 key_free(private);
Darren Tuckera627d422013-06-02 07:31:17 +10001390 free(comment);
Damien Miller95def091999-11-25 00:26:21 +11001391 exit(1);
1392 }
Damien Miller95def091999-11-25 00:26:21 +11001393 memset(passphrase, 0, strlen(passphrase));
Darren Tuckera627d422013-06-02 07:31:17 +10001394 free(passphrase);
Ben Lindstromd0fca422001-03-26 13:44:06 +00001395 public = key_from_private(private);
Damien Millereba71ba2000-04-29 23:57:08 +10001396 key_free(private);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001397
Damien Miller95def091999-11-25 00:26:21 +11001398 strlcat(identity_file, ".pub", sizeof(identity_file));
Ben Lindstrom5fc62702001-03-09 18:19:24 +00001399 fd = open(identity_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
1400 if (fd == -1) {
Damien Miller95def091999-11-25 00:26:21 +11001401 printf("Could not save your public key in %s\n", identity_file);
1402 exit(1);
1403 }
Ben Lindstrom5fc62702001-03-09 18:19:24 +00001404 f = fdopen(fd, "w");
1405 if (f == NULL) {
Damien Miller9eab9562009-02-22 08:47:02 +11001406 printf("fdopen %s failed\n", identity_file);
Ben Lindstrom5fc62702001-03-09 18:19:24 +00001407 exit(1);
1408 }
Damien Millereba71ba2000-04-29 23:57:08 +10001409 if (!key_write(public, f))
Damien Miller9eab9562009-02-22 08:47:02 +11001410 fprintf(stderr, "write key failed\n");
Damien Millereba71ba2000-04-29 23:57:08 +10001411 key_free(public);
1412 fprintf(f, " %s\n", new_comment);
Damien Miller95def091999-11-25 00:26:21 +11001413 fclose(f);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001414
Darren Tuckera627d422013-06-02 07:31:17 +10001415 free(comment);
Damien Miller95def091999-11-25 00:26:21 +11001416
1417 printf("The comment in your key file has been changed.\n");
1418 exit(0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001419}
1420
Damien Miller0a80ca12010-02-27 07:55:05 +11001421static const char *
Damien Millerf2b70ca2010-03-05 07:39:35 +11001422fmt_validity(u_int64_t valid_from, u_int64_t valid_to)
Damien Miller0a80ca12010-02-27 07:55:05 +11001423{
1424 char from[32], to[32];
1425 static char ret[64];
1426 time_t tt;
1427 struct tm *tm;
1428
1429 *from = *to = '\0';
Damien Millerf2b70ca2010-03-05 07:39:35 +11001430 if (valid_from == 0 && valid_to == 0xffffffffffffffffULL)
Damien Miller0a80ca12010-02-27 07:55:05 +11001431 return "forever";
1432
Damien Millerf2b70ca2010-03-05 07:39:35 +11001433 if (valid_from != 0) {
Damien Miller0a80ca12010-02-27 07:55:05 +11001434 /* XXX revisit INT_MAX in 2038 :) */
Damien Millerf2b70ca2010-03-05 07:39:35 +11001435 tt = valid_from > INT_MAX ? INT_MAX : valid_from;
Damien Miller0a80ca12010-02-27 07:55:05 +11001436 tm = localtime(&tt);
1437 strftime(from, sizeof(from), "%Y-%m-%dT%H:%M:%S", tm);
1438 }
Damien Millerf2b70ca2010-03-05 07:39:35 +11001439 if (valid_to != 0xffffffffffffffffULL) {
Damien Miller0a80ca12010-02-27 07:55:05 +11001440 /* XXX revisit INT_MAX in 2038 :) */
Damien Millerf2b70ca2010-03-05 07:39:35 +11001441 tt = valid_to > INT_MAX ? INT_MAX : valid_to;
Damien Miller0a80ca12010-02-27 07:55:05 +11001442 tm = localtime(&tt);
1443 strftime(to, sizeof(to), "%Y-%m-%dT%H:%M:%S", tm);
1444 }
1445
Damien Millerf2b70ca2010-03-05 07:39:35 +11001446 if (valid_from == 0) {
Damien Miller0a80ca12010-02-27 07:55:05 +11001447 snprintf(ret, sizeof(ret), "before %s", to);
1448 return ret;
1449 }
Damien Millerf2b70ca2010-03-05 07:39:35 +11001450 if (valid_to == 0xffffffffffffffffULL) {
Damien Miller0a80ca12010-02-27 07:55:05 +11001451 snprintf(ret, sizeof(ret), "after %s", from);
1452 return ret;
1453 }
1454
1455 snprintf(ret, sizeof(ret), "from %s to %s", from, to);
1456 return ret;
1457}
1458
1459static void
Damien Miller4e270b02010-04-16 15:56:21 +10001460add_flag_option(Buffer *c, const char *name)
Damien Miller0a80ca12010-02-27 07:55:05 +11001461{
1462 debug3("%s: %s", __func__, name);
1463 buffer_put_cstring(c, name);
1464 buffer_put_string(c, NULL, 0);
1465}
1466
1467static void
Damien Miller4e270b02010-04-16 15:56:21 +10001468add_string_option(Buffer *c, const char *name, const char *value)
Damien Miller0a80ca12010-02-27 07:55:05 +11001469{
1470 Buffer b;
1471
1472 debug3("%s: %s=%s", __func__, name, value);
1473 buffer_init(&b);
1474 buffer_put_cstring(&b, value);
1475
1476 buffer_put_cstring(c, name);
1477 buffer_put_string(c, buffer_ptr(&b), buffer_len(&b));
1478
1479 buffer_free(&b);
1480}
1481
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001482#define OPTIONS_CRITICAL 1
1483#define OPTIONS_EXTENSIONS 2
Damien Miller0a80ca12010-02-27 07:55:05 +11001484static void
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001485prepare_options_buf(Buffer *c, int which)
Damien Miller0a80ca12010-02-27 07:55:05 +11001486{
Damien Miller0a80ca12010-02-27 07:55:05 +11001487 buffer_clear(c);
Damien Miller1da63882010-08-05 13:03:51 +10001488 if ((which & OPTIONS_CRITICAL) != 0 &&
1489 certflags_command != NULL)
1490 add_string_option(c, "force-command", certflags_command);
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001491 if ((which & OPTIONS_EXTENSIONS) != 0 &&
Damien Miller2ce12ef2011-05-05 14:17:18 +10001492 (certflags_flags & CERTOPT_X_FWD) != 0)
1493 add_flag_option(c, "permit-X11-forwarding");
1494 if ((which & OPTIONS_EXTENSIONS) != 0 &&
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001495 (certflags_flags & CERTOPT_AGENT_FWD) != 0)
Damien Miller4e270b02010-04-16 15:56:21 +10001496 add_flag_option(c, "permit-agent-forwarding");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001497 if ((which & OPTIONS_EXTENSIONS) != 0 &&
1498 (certflags_flags & CERTOPT_PORT_FWD) != 0)
Damien Miller4e270b02010-04-16 15:56:21 +10001499 add_flag_option(c, "permit-port-forwarding");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001500 if ((which & OPTIONS_EXTENSIONS) != 0 &&
1501 (certflags_flags & CERTOPT_PTY) != 0)
Damien Miller4e270b02010-04-16 15:56:21 +10001502 add_flag_option(c, "permit-pty");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001503 if ((which & OPTIONS_EXTENSIONS) != 0 &&
1504 (certflags_flags & CERTOPT_USER_RC) != 0)
Damien Miller4e270b02010-04-16 15:56:21 +10001505 add_flag_option(c, "permit-user-rc");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001506 if ((which & OPTIONS_CRITICAL) != 0 &&
1507 certflags_src_addr != NULL)
1508 add_string_option(c, "source-address", certflags_src_addr);
Damien Miller0a80ca12010-02-27 07:55:05 +11001509}
1510
Damien Miller757f34e2010-08-05 13:05:31 +10001511static Key *
1512load_pkcs11_key(char *path)
1513{
1514#ifdef ENABLE_PKCS11
1515 Key **keys = NULL, *public, *private = NULL;
1516 int i, nkeys;
1517
1518 if ((public = key_load_public(path, NULL)) == NULL)
1519 fatal("Couldn't load CA public key \"%s\"", path);
1520
1521 nkeys = pkcs11_add_provider(pkcs11provider, identity_passphrase, &keys);
1522 debug3("%s: %d keys", __func__, nkeys);
1523 if (nkeys <= 0)
1524 fatal("cannot read public key from pkcs11");
1525 for (i = 0; i < nkeys; i++) {
1526 if (key_equal_public(public, keys[i])) {
1527 private = keys[i];
1528 continue;
1529 }
1530 key_free(keys[i]);
1531 }
Darren Tuckera627d422013-06-02 07:31:17 +10001532 free(keys);
Damien Miller757f34e2010-08-05 13:05:31 +10001533 key_free(public);
1534 return private;
1535#else
1536 fatal("no pkcs11 support");
1537#endif /* ENABLE_PKCS11 */
1538}
1539
Damien Miller0a80ca12010-02-27 07:55:05 +11001540static void
1541do_ca_sign(struct passwd *pw, int argc, char **argv)
1542{
1543 int i, fd;
1544 u_int n;
1545 Key *ca, *public;
1546 char *otmp, *tmp, *cp, *out, *comment, **plist = NULL;
1547 FILE *f;
Damien Miller4e270b02010-04-16 15:56:21 +10001548 int v00 = 0; /* legacy keys */
Damien Miller0a80ca12010-02-27 07:55:05 +11001549
Damien Miller4e270b02010-04-16 15:56:21 +10001550 if (key_type_name != NULL) {
1551 switch (key_type_from_name(key_type_name)) {
1552 case KEY_RSA_CERT_V00:
1553 case KEY_DSA_CERT_V00:
1554 v00 = 1;
1555 break;
1556 case KEY_UNSPEC:
1557 if (strcasecmp(key_type_name, "v00") == 0) {
1558 v00 = 1;
1559 break;
1560 } else if (strcasecmp(key_type_name, "v01") == 0)
1561 break;
1562 /* FALLTHROUGH */
1563 default:
1564 fprintf(stderr, "unknown key type %s\n", key_type_name);
1565 exit(1);
1566 }
1567 }
1568
Damien Miller757f34e2010-08-05 13:05:31 +10001569 pkcs11_init(1);
1570 tmp = tilde_expand_filename(ca_key_path, pw->pw_uid);
1571 if (pkcs11provider != NULL) {
1572 if ((ca = load_pkcs11_key(tmp)) == NULL)
1573 fatal("No PKCS#11 key matching %s found", ca_key_path);
1574 } else if ((ca = load_identity(tmp)) == NULL)
1575 fatal("Couldn't load CA key \"%s\"", tmp);
Darren Tuckera627d422013-06-02 07:31:17 +10001576 free(tmp);
Damien Miller757f34e2010-08-05 13:05:31 +10001577
Damien Miller0a80ca12010-02-27 07:55:05 +11001578 for (i = 0; i < argc; i++) {
1579 /* Split list of principals */
1580 n = 0;
1581 if (cert_principals != NULL) {
1582 otmp = tmp = xstrdup(cert_principals);
1583 plist = NULL;
1584 for (; (cp = strsep(&tmp, ",")) != NULL; n++) {
1585 plist = xrealloc(plist, n + 1, sizeof(*plist));
1586 if (*(plist[n] = xstrdup(cp)) == '\0')
1587 fatal("Empty principal name");
1588 }
Darren Tuckera627d422013-06-02 07:31:17 +10001589 free(otmp);
Damien Miller0a80ca12010-02-27 07:55:05 +11001590 }
1591
1592 tmp = tilde_expand_filename(argv[i], pw->pw_uid);
1593 if ((public = key_load_public(tmp, &comment)) == NULL)
1594 fatal("%s: unable to open \"%s\"", __func__, tmp);
Damien Millereb8b60e2010-08-31 22:41:14 +10001595 if (public->type != KEY_RSA && public->type != KEY_DSA &&
1596 public->type != KEY_ECDSA)
Damien Miller0a80ca12010-02-27 07:55:05 +11001597 fatal("%s: key \"%s\" type %s cannot be certified",
1598 __func__, tmp, key_type(public));
1599
1600 /* Prepare certificate to sign */
Damien Miller4e270b02010-04-16 15:56:21 +10001601 if (key_to_certified(public, v00) != 0)
Damien Miller0a80ca12010-02-27 07:55:05 +11001602 fatal("Could not upgrade key %s to certificate", tmp);
1603 public->cert->type = cert_key_type;
Damien Miller4e270b02010-04-16 15:56:21 +10001604 public->cert->serial = (u_int64_t)cert_serial;
Damien Miller0a80ca12010-02-27 07:55:05 +11001605 public->cert->key_id = xstrdup(cert_key_id);
1606 public->cert->nprincipals = n;
1607 public->cert->principals = plist;
1608 public->cert->valid_after = cert_valid_from;
1609 public->cert->valid_before = cert_valid_to;
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001610 if (v00) {
1611 prepare_options_buf(&public->cert->critical,
1612 OPTIONS_CRITICAL|OPTIONS_EXTENSIONS);
1613 } else {
1614 prepare_options_buf(&public->cert->critical,
1615 OPTIONS_CRITICAL);
1616 prepare_options_buf(&public->cert->extensions,
1617 OPTIONS_EXTENSIONS);
1618 }
Damien Miller0a80ca12010-02-27 07:55:05 +11001619 public->cert->signature_key = key_from_private(ca);
1620
1621 if (key_certify(public, ca) != 0)
1622 fatal("Couldn't not certify key %s", tmp);
1623
1624 if ((cp = strrchr(tmp, '.')) != NULL && strcmp(cp, ".pub") == 0)
1625 *cp = '\0';
1626 xasprintf(&out, "%s-cert.pub", tmp);
Darren Tuckera627d422013-06-02 07:31:17 +10001627 free(tmp);
Damien Miller0a80ca12010-02-27 07:55:05 +11001628
1629 if ((fd = open(out, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1)
1630 fatal("Could not open \"%s\" for writing: %s", out,
1631 strerror(errno));
1632 if ((f = fdopen(fd, "w")) == NULL)
1633 fatal("%s: fdopen: %s", __func__, strerror(errno));
1634 if (!key_write(public, f))
1635 fatal("Could not write certified key to %s", out);
1636 fprintf(f, " %s\n", comment);
1637 fclose(f);
1638
Damien Miller4e270b02010-04-16 15:56:21 +10001639 if (!quiet) {
1640 logit("Signed %s key %s: id \"%s\" serial %llu%s%s "
1641 "valid %s", key_cert_type(public),
Damien Miller821de0a2011-01-11 17:20:29 +11001642 out, public->cert->key_id,
1643 (unsigned long long)public->cert->serial,
Damien Miller0a80ca12010-02-27 07:55:05 +11001644 cert_principals != NULL ? " for " : "",
1645 cert_principals != NULL ? cert_principals : "",
Damien Millerf2b70ca2010-03-05 07:39:35 +11001646 fmt_validity(cert_valid_from, cert_valid_to));
Damien Miller4e270b02010-04-16 15:56:21 +10001647 }
Damien Miller0a80ca12010-02-27 07:55:05 +11001648
1649 key_free(public);
Darren Tuckera627d422013-06-02 07:31:17 +10001650 free(out);
Damien Miller0a80ca12010-02-27 07:55:05 +11001651 }
Damien Miller757f34e2010-08-05 13:05:31 +10001652 pkcs11_terminate();
Damien Miller0a80ca12010-02-27 07:55:05 +11001653 exit(0);
1654}
1655
1656static u_int64_t
1657parse_relative_time(const char *s, time_t now)
1658{
1659 int64_t mul, secs;
1660
1661 mul = *s == '-' ? -1 : 1;
1662
1663 if ((secs = convtime(s + 1)) == -1)
1664 fatal("Invalid relative certificate time %s", s);
1665 if (mul == -1 && secs > now)
1666 fatal("Certificate time %s cannot be represented", s);
1667 return now + (u_int64_t)(secs * mul);
1668}
1669
1670static u_int64_t
1671parse_absolute_time(const char *s)
1672{
1673 struct tm tm;
1674 time_t tt;
Damien Miller2ca342b2010-03-03 12:14:15 +11001675 char buf[32], *fmt;
Damien Miller0a80ca12010-02-27 07:55:05 +11001676
Damien Miller2ca342b2010-03-03 12:14:15 +11001677 /*
1678 * POSIX strptime says "The application shall ensure that there
1679 * is white-space or other non-alphanumeric characters between
1680 * any two conversion specifications" so arrange things this way.
1681 */
1682 switch (strlen(s)) {
1683 case 8:
Damien Miller3e1ee492010-03-08 09:24:11 +11001684 fmt = "%Y-%m-%d";
1685 snprintf(buf, sizeof(buf), "%.4s-%.2s-%.2s", s, s + 4, s + 6);
Damien Miller2ca342b2010-03-03 12:14:15 +11001686 break;
1687 case 14:
Damien Miller3e1ee492010-03-08 09:24:11 +11001688 fmt = "%Y-%m-%dT%H:%M:%S";
1689 snprintf(buf, sizeof(buf), "%.4s-%.2s-%.2sT%.2s:%.2s:%.2s",
Damien Miller2ca342b2010-03-03 12:14:15 +11001690 s, s + 4, s + 6, s + 8, s + 10, s + 12);
1691 break;
1692 default:
Damien Miller0a80ca12010-02-27 07:55:05 +11001693 fatal("Invalid certificate time format %s", s);
Damien Miller2ca342b2010-03-03 12:14:15 +11001694 }
Damien Miller0a80ca12010-02-27 07:55:05 +11001695
1696 bzero(&tm, sizeof(tm));
Damien Miller2ca342b2010-03-03 12:14:15 +11001697 if (strptime(buf, fmt, &tm) == NULL)
Damien Miller0a80ca12010-02-27 07:55:05 +11001698 fatal("Invalid certificate time %s", s);
1699 if ((tt = mktime(&tm)) < 0)
1700 fatal("Certificate time %s cannot be represented", s);
1701 return (u_int64_t)tt;
1702}
1703
1704static void
1705parse_cert_times(char *timespec)
1706{
1707 char *from, *to;
1708 time_t now = time(NULL);
1709 int64_t secs;
1710
1711 /* +timespec relative to now */
1712 if (*timespec == '+' && strchr(timespec, ':') == NULL) {
1713 if ((secs = convtime(timespec + 1)) == -1)
1714 fatal("Invalid relative certificate life %s", timespec);
1715 cert_valid_to = now + secs;
1716 /*
1717 * Backdate certificate one minute to avoid problems on hosts
1718 * with poorly-synchronised clocks.
1719 */
1720 cert_valid_from = ((now - 59)/ 60) * 60;
1721 return;
1722 }
1723
1724 /*
1725 * from:to, where
1726 * from := [+-]timespec | YYYYMMDD | YYYYMMDDHHMMSS
1727 * to := [+-]timespec | YYYYMMDD | YYYYMMDDHHMMSS
1728 */
1729 from = xstrdup(timespec);
1730 to = strchr(from, ':');
1731 if (to == NULL || from == to || *(to + 1) == '\0')
Damien Miller910f2092010-03-04 14:17:22 +11001732 fatal("Invalid certificate life specification %s", timespec);
Damien Miller0a80ca12010-02-27 07:55:05 +11001733 *to++ = '\0';
1734
1735 if (*from == '-' || *from == '+')
1736 cert_valid_from = parse_relative_time(from, now);
1737 else
1738 cert_valid_from = parse_absolute_time(from);
1739
1740 if (*to == '-' || *to == '+')
1741 cert_valid_to = parse_relative_time(to, cert_valid_from);
1742 else
1743 cert_valid_to = parse_absolute_time(to);
1744
1745 if (cert_valid_to <= cert_valid_from)
1746 fatal("Empty certificate validity interval");
Darren Tuckera627d422013-06-02 07:31:17 +10001747 free(from);
Damien Miller0a80ca12010-02-27 07:55:05 +11001748}
1749
1750static void
Damien Miller4e270b02010-04-16 15:56:21 +10001751add_cert_option(char *opt)
Damien Miller0a80ca12010-02-27 07:55:05 +11001752{
1753 char *val;
1754
Damien Miller044f4a62011-05-05 14:14:08 +10001755 if (strcasecmp(opt, "clear") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001756 certflags_flags = 0;
Damien Miller0a80ca12010-02-27 07:55:05 +11001757 else if (strcasecmp(opt, "no-x11-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001758 certflags_flags &= ~CERTOPT_X_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001759 else if (strcasecmp(opt, "permit-x11-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001760 certflags_flags |= CERTOPT_X_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001761 else if (strcasecmp(opt, "no-agent-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001762 certflags_flags &= ~CERTOPT_AGENT_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001763 else if (strcasecmp(opt, "permit-agent-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001764 certflags_flags |= CERTOPT_AGENT_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001765 else if (strcasecmp(opt, "no-port-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001766 certflags_flags &= ~CERTOPT_PORT_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001767 else if (strcasecmp(opt, "permit-port-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001768 certflags_flags |= CERTOPT_PORT_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001769 else if (strcasecmp(opt, "no-pty") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001770 certflags_flags &= ~CERTOPT_PTY;
Damien Miller0a80ca12010-02-27 07:55:05 +11001771 else if (strcasecmp(opt, "permit-pty") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001772 certflags_flags |= CERTOPT_PTY;
Damien Miller0a80ca12010-02-27 07:55:05 +11001773 else if (strcasecmp(opt, "no-user-rc") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001774 certflags_flags &= ~CERTOPT_USER_RC;
Damien Miller0a80ca12010-02-27 07:55:05 +11001775 else if (strcasecmp(opt, "permit-user-rc") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001776 certflags_flags |= CERTOPT_USER_RC;
Damien Miller0a80ca12010-02-27 07:55:05 +11001777 else if (strncasecmp(opt, "force-command=", 14) == 0) {
1778 val = opt + 14;
1779 if (*val == '\0')
Damien Miller4e270b02010-04-16 15:56:21 +10001780 fatal("Empty force-command option");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001781 if (certflags_command != NULL)
Damien Miller0a80ca12010-02-27 07:55:05 +11001782 fatal("force-command already specified");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001783 certflags_command = xstrdup(val);
Damien Miller0a80ca12010-02-27 07:55:05 +11001784 } else if (strncasecmp(opt, "source-address=", 15) == 0) {
1785 val = opt + 15;
1786 if (*val == '\0')
Damien Miller4e270b02010-04-16 15:56:21 +10001787 fatal("Empty source-address option");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001788 if (certflags_src_addr != NULL)
Damien Miller0a80ca12010-02-27 07:55:05 +11001789 fatal("source-address already specified");
1790 if (addr_match_cidr_list(NULL, val) != 0)
1791 fatal("Invalid source-address list");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001792 certflags_src_addr = xstrdup(val);
Damien Miller0a80ca12010-02-27 07:55:05 +11001793 } else
Damien Miller4e270b02010-04-16 15:56:21 +10001794 fatal("Unsupported certificate option \"%s\"", opt);
Damien Miller0a80ca12010-02-27 07:55:05 +11001795}
1796
Ben Lindstrombba81212001-06-25 05:01:22 +00001797static void
Damien Millerd834d352010-06-26 09:48:02 +10001798show_options(const Buffer *optbuf, int v00, int in_critical)
1799{
Damien Miller746d1a62013-07-18 16:13:02 +10001800 char *name;
1801 u_char *data;
Damien Millerd834d352010-06-26 09:48:02 +10001802 u_int dlen;
1803 Buffer options, option;
1804
1805 buffer_init(&options);
1806 buffer_append(&options, buffer_ptr(optbuf), buffer_len(optbuf));
1807
1808 buffer_init(&option);
1809 while (buffer_len(&options) != 0) {
1810 name = buffer_get_string(&options, NULL);
1811 data = buffer_get_string_ptr(&options, &dlen);
1812 buffer_append(&option, data, dlen);
1813 printf(" %s", name);
1814 if ((v00 || !in_critical) &&
1815 (strcmp(name, "permit-X11-forwarding") == 0 ||
1816 strcmp(name, "permit-agent-forwarding") == 0 ||
1817 strcmp(name, "permit-port-forwarding") == 0 ||
1818 strcmp(name, "permit-pty") == 0 ||
1819 strcmp(name, "permit-user-rc") == 0))
1820 printf("\n");
1821 else if ((v00 || in_critical) &&
1822 (strcmp(name, "force-command") == 0 ||
1823 strcmp(name, "source-address") == 0)) {
1824 data = buffer_get_string(&option, NULL);
1825 printf(" %s\n", data);
Darren Tuckera627d422013-06-02 07:31:17 +10001826 free(data);
Damien Millerd834d352010-06-26 09:48:02 +10001827 } else {
1828 printf(" UNKNOWN OPTION (len %u)\n",
1829 buffer_len(&option));
1830 buffer_clear(&option);
1831 }
Darren Tuckera627d422013-06-02 07:31:17 +10001832 free(name);
Damien Millerd834d352010-06-26 09:48:02 +10001833 if (buffer_len(&option) != 0)
1834 fatal("Option corrupt: extra data at end");
1835 }
1836 buffer_free(&option);
1837 buffer_free(&options);
1838}
1839
1840static void
Damien Millerf2b70ca2010-03-05 07:39:35 +11001841do_show_cert(struct passwd *pw)
1842{
1843 Key *key;
1844 struct stat st;
1845 char *key_fp, *ca_fp;
Damien Millerd834d352010-06-26 09:48:02 +10001846 u_int i, v00;
Damien Millerf2b70ca2010-03-05 07:39:35 +11001847
1848 if (!have_identity)
1849 ask_filename(pw, "Enter file in which the key is");
Damien Millerba3420a2010-06-26 09:39:07 +10001850 if (stat(identity_file, &st) < 0)
1851 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
Damien Millerf2b70ca2010-03-05 07:39:35 +11001852 if ((key = key_load_public(identity_file, NULL)) == NULL)
1853 fatal("%s is not a public key", identity_file);
1854 if (!key_is_cert(key))
1855 fatal("%s is not a certificate", identity_file);
Damien Miller4e270b02010-04-16 15:56:21 +10001856 v00 = key->type == KEY_RSA_CERT_V00 || key->type == KEY_DSA_CERT_V00;
1857
Damien Millerf2b70ca2010-03-05 07:39:35 +11001858 key_fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
1859 ca_fp = key_fingerprint(key->cert->signature_key,
1860 SSH_FP_MD5, SSH_FP_HEX);
1861
1862 printf("%s:\n", identity_file);
Damien Miller4e270b02010-04-16 15:56:21 +10001863 printf(" Type: %s %s certificate\n", key_ssh_name(key),
1864 key_cert_type(key));
1865 printf(" Public key: %s %s\n", key_type(key), key_fp);
1866 printf(" Signing CA: %s %s\n",
Damien Millerf2b70ca2010-03-05 07:39:35 +11001867 key_type(key->cert->signature_key), ca_fp);
Damien Miller4e270b02010-04-16 15:56:21 +10001868 printf(" Key ID: \"%s\"\n", key->cert->key_id);
Damien Miller821de0a2011-01-11 17:20:29 +11001869 if (!v00) {
1870 printf(" Serial: %llu\n",
1871 (unsigned long long)key->cert->serial);
1872 }
Damien Millerf2b70ca2010-03-05 07:39:35 +11001873 printf(" Valid: %s\n",
1874 fmt_validity(key->cert->valid_after, key->cert->valid_before));
1875 printf(" Principals: ");
1876 if (key->cert->nprincipals == 0)
1877 printf("(none)\n");
1878 else {
1879 for (i = 0; i < key->cert->nprincipals; i++)
1880 printf("\n %s",
1881 key->cert->principals[i]);
1882 printf("\n");
1883 }
Damien Miller4e270b02010-04-16 15:56:21 +10001884 printf(" Critical Options: ");
1885 if (buffer_len(&key->cert->critical) == 0)
Damien Millerf2b70ca2010-03-05 07:39:35 +11001886 printf("(none)\n");
1887 else {
1888 printf("\n");
Damien Millerd834d352010-06-26 09:48:02 +10001889 show_options(&key->cert->critical, v00, 1);
Damien Millerf2b70ca2010-03-05 07:39:35 +11001890 }
Damien Miller4e270b02010-04-16 15:56:21 +10001891 if (!v00) {
1892 printf(" Extensions: ");
1893 if (buffer_len(&key->cert->extensions) == 0)
1894 printf("(none)\n");
1895 else {
1896 printf("\n");
Damien Millerd834d352010-06-26 09:48:02 +10001897 show_options(&key->cert->extensions, v00, 0);
Damien Miller4e270b02010-04-16 15:56:21 +10001898 }
1899 }
Damien Millerf2b70ca2010-03-05 07:39:35 +11001900 exit(0);
1901}
1902
1903static void
Damien Millerf3747bf2013-01-18 11:44:04 +11001904load_krl(const char *path, struct ssh_krl **krlp)
1905{
1906 Buffer krlbuf;
1907 int fd;
1908
1909 buffer_init(&krlbuf);
1910 if ((fd = open(path, O_RDONLY)) == -1)
1911 fatal("open %s: %s", path, strerror(errno));
1912 if (!key_load_file(fd, path, &krlbuf))
1913 fatal("Unable to load KRL");
1914 close(fd);
1915 /* XXX check sigs */
1916 if (ssh_krl_from_blob(&krlbuf, krlp, NULL, 0) != 0 ||
1917 *krlp == NULL)
1918 fatal("Invalid KRL file");
1919 buffer_free(&krlbuf);
1920}
1921
1922static void
1923update_krl_from_file(struct passwd *pw, const char *file, const Key *ca,
1924 struct ssh_krl *krl)
1925{
1926 Key *key = NULL;
1927 u_long lnum = 0;
1928 char *path, *cp, *ep, line[SSH_MAX_PUBKEY_BYTES];
1929 unsigned long long serial, serial2;
1930 int i, was_explicit_key, was_sha1, r;
1931 FILE *krl_spec;
1932
1933 path = tilde_expand_filename(file, pw->pw_uid);
1934 if (strcmp(path, "-") == 0) {
1935 krl_spec = stdin;
1936 free(path);
1937 path = xstrdup("(standard input)");
1938 } else if ((krl_spec = fopen(path, "r")) == NULL)
1939 fatal("fopen %s: %s", path, strerror(errno));
1940
1941 if (!quiet)
1942 printf("Revoking from %s\n", path);
1943 while (read_keyfile_line(krl_spec, path, line, sizeof(line),
1944 &lnum) == 0) {
1945 was_explicit_key = was_sha1 = 0;
1946 cp = line + strspn(line, " \t");
1947 /* Trim trailing space, comments and strip \n */
1948 for (i = 0, r = -1; cp[i] != '\0'; i++) {
1949 if (cp[i] == '#' || cp[i] == '\n') {
1950 cp[i] = '\0';
1951 break;
1952 }
1953 if (cp[i] == ' ' || cp[i] == '\t') {
1954 /* Remember the start of a span of whitespace */
1955 if (r == -1)
1956 r = i;
1957 } else
1958 r = -1;
1959 }
1960 if (r != -1)
1961 cp[r] = '\0';
1962 if (*cp == '\0')
1963 continue;
1964 if (strncasecmp(cp, "serial:", 7) == 0) {
1965 if (ca == NULL) {
1966 fatal("revoking certificated by serial number "
1967 "requires specification of a CA key");
1968 }
1969 cp += 7;
1970 cp = cp + strspn(cp, " \t");
1971 errno = 0;
1972 serial = strtoull(cp, &ep, 0);
1973 if (*cp == '\0' || (*ep != '\0' && *ep != '-'))
1974 fatal("%s:%lu: invalid serial \"%s\"",
1975 path, lnum, cp);
1976 if (errno == ERANGE && serial == ULLONG_MAX)
1977 fatal("%s:%lu: serial out of range",
1978 path, lnum);
1979 serial2 = serial;
1980 if (*ep == '-') {
1981 cp = ep + 1;
1982 errno = 0;
1983 serial2 = strtoull(cp, &ep, 0);
1984 if (*cp == '\0' || *ep != '\0')
1985 fatal("%s:%lu: invalid serial \"%s\"",
1986 path, lnum, cp);
1987 if (errno == ERANGE && serial2 == ULLONG_MAX)
1988 fatal("%s:%lu: serial out of range",
1989 path, lnum);
1990 if (serial2 <= serial)
1991 fatal("%s:%lu: invalid serial range "
1992 "%llu:%llu", path, lnum,
1993 (unsigned long long)serial,
1994 (unsigned long long)serial2);
1995 }
1996 if (ssh_krl_revoke_cert_by_serial_range(krl,
1997 ca, serial, serial2) != 0) {
1998 fatal("%s: revoke serial failed",
1999 __func__);
2000 }
2001 } else if (strncasecmp(cp, "id:", 3) == 0) {
2002 if (ca == NULL) {
2003 fatal("revoking certificated by key ID "
2004 "requires specification of a CA key");
2005 }
2006 cp += 3;
2007 cp = cp + strspn(cp, " \t");
2008 if (ssh_krl_revoke_cert_by_key_id(krl, ca, cp) != 0)
2009 fatal("%s: revoke key ID failed", __func__);
2010 } else {
2011 if (strncasecmp(cp, "key:", 4) == 0) {
2012 cp += 4;
2013 cp = cp + strspn(cp, " \t");
2014 was_explicit_key = 1;
2015 } else if (strncasecmp(cp, "sha1:", 5) == 0) {
2016 cp += 5;
2017 cp = cp + strspn(cp, " \t");
2018 was_sha1 = 1;
2019 } else {
2020 /*
2021 * Just try to process the line as a key.
2022 * Parsing will fail if it isn't.
2023 */
2024 }
2025 if ((key = key_new(KEY_UNSPEC)) == NULL)
2026 fatal("key_new");
2027 if (key_read(key, &cp) != 1)
2028 fatal("%s:%lu: invalid key", path, lnum);
2029 if (was_explicit_key)
2030 r = ssh_krl_revoke_key_explicit(krl, key);
2031 else if (was_sha1)
2032 r = ssh_krl_revoke_key_sha1(krl, key);
2033 else
2034 r = ssh_krl_revoke_key(krl, key);
2035 if (r != 0)
2036 fatal("%s: revoke key failed", __func__);
2037 key_free(key);
2038 }
2039 }
2040 if (strcmp(path, "-") != 0)
2041 fclose(krl_spec);
Damien Miller0d6771b2013-04-23 15:23:24 +10002042 free(path);
Damien Millerf3747bf2013-01-18 11:44:04 +11002043}
2044
2045static void
2046do_gen_krl(struct passwd *pw, int updating, int argc, char **argv)
2047{
2048 struct ssh_krl *krl;
2049 struct stat sb;
2050 Key *ca = NULL;
2051 int fd, i;
2052 char *tmp;
2053 Buffer kbuf;
2054
2055 if (*identity_file == '\0')
2056 fatal("KRL generation requires an output file");
2057 if (stat(identity_file, &sb) == -1) {
2058 if (errno != ENOENT)
2059 fatal("Cannot access KRL \"%s\": %s",
2060 identity_file, strerror(errno));
2061 if (updating)
2062 fatal("KRL \"%s\" does not exist", identity_file);
2063 }
2064 if (ca_key_path != NULL) {
2065 tmp = tilde_expand_filename(ca_key_path, pw->pw_uid);
2066 if ((ca = key_load_public(tmp, NULL)) == NULL)
2067 fatal("Cannot load CA public key %s", tmp);
Darren Tuckera627d422013-06-02 07:31:17 +10002068 free(tmp);
Damien Millerf3747bf2013-01-18 11:44:04 +11002069 }
2070
2071 if (updating)
2072 load_krl(identity_file, &krl);
2073 else if ((krl = ssh_krl_init()) == NULL)
2074 fatal("couldn't create KRL");
2075
2076 if (cert_serial != 0)
2077 ssh_krl_set_version(krl, cert_serial);
2078 if (identity_comment != NULL)
2079 ssh_krl_set_comment(krl, identity_comment);
2080
2081 for (i = 0; i < argc; i++)
2082 update_krl_from_file(pw, argv[i], ca, krl);
2083
2084 buffer_init(&kbuf);
2085 if (ssh_krl_to_blob(krl, &kbuf, NULL, 0) != 0)
2086 fatal("Couldn't generate KRL");
2087 if ((fd = open(identity_file, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1)
2088 fatal("open %s: %s", identity_file, strerror(errno));
2089 if (atomicio(vwrite, fd, buffer_ptr(&kbuf), buffer_len(&kbuf)) !=
2090 buffer_len(&kbuf))
2091 fatal("write %s: %s", identity_file, strerror(errno));
2092 close(fd);
2093 buffer_free(&kbuf);
2094 ssh_krl_free(krl);
Damien Miller0d6771b2013-04-23 15:23:24 +10002095 if (ca != NULL)
2096 key_free(ca);
Damien Millerf3747bf2013-01-18 11:44:04 +11002097}
2098
2099static void
2100do_check_krl(struct passwd *pw, int argc, char **argv)
2101{
2102 int i, r, ret = 0;
2103 char *comment;
2104 struct ssh_krl *krl;
2105 Key *k;
2106
2107 if (*identity_file == '\0')
2108 fatal("KRL checking requires an input file");
2109 load_krl(identity_file, &krl);
2110 for (i = 0; i < argc; i++) {
2111 if ((k = key_load_public(argv[i], &comment)) == NULL)
2112 fatal("Cannot load public key %s", argv[i]);
2113 r = ssh_krl_check_key(krl, k);
2114 printf("%s%s%s%s: %s\n", argv[i],
2115 *comment ? " (" : "", comment, *comment ? ")" : "",
2116 r == 0 ? "ok" : "REVOKED");
2117 if (r != 0)
2118 ret = 1;
2119 key_free(k);
2120 free(comment);
2121 }
2122 ssh_krl_free(krl);
2123 exit(ret);
2124}
2125
2126static void
Damien Miller431f66b1999-11-21 18:31:57 +11002127usage(void)
2128{
Damien Miller5cbe7ca2007-09-17 16:05:50 +10002129 fprintf(stderr, "usage: %s [options]\n", __progname);
Ben Lindstrom97be31e2001-08-06 21:49:06 +00002130 fprintf(stderr, "Options:\n");
Damien Miller58f1baf2011-05-05 14:06:15 +10002131 fprintf(stderr, " -A Generate non-existent host keys for all key types.\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002132 fprintf(stderr, " -a trials Number of trials for screening DH-GEX moduli.\n");
Ben Lindstrom97be31e2001-08-06 21:49:06 +00002133 fprintf(stderr, " -B Show bubblebabble digest of key file.\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002134 fprintf(stderr, " -b bits Number of bits in the key to create.\n");
Ben Lindstrom97be31e2001-08-06 21:49:06 +00002135 fprintf(stderr, " -C comment Provide new comment.\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002136 fprintf(stderr, " -c Change comment in private and public key files.\n");
Damien Miller7ea845e2010-02-12 09:21:02 +11002137#ifdef ENABLE_PKCS11
2138 fprintf(stderr, " -D pkcs11 Download public key from pkcs11 token.\n");
2139#endif
Damien Miller44b25042010-07-02 13:35:01 +10002140 fprintf(stderr, " -e Export OpenSSH to foreign format key file.\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002141 fprintf(stderr, " -F hostname Find hostname in known hosts file.\n");
2142 fprintf(stderr, " -f filename Filename of the key file.\n");
2143 fprintf(stderr, " -G file Generate candidates for DH-GEX moduli.\n");
2144 fprintf(stderr, " -g Use generic DNS resource record format.\n");
2145 fprintf(stderr, " -H Hash names in known_hosts file.\n");
Damien Miller0a80ca12010-02-27 07:55:05 +11002146 fprintf(stderr, " -h Generate host certificate instead of a user certificate.\n");
2147 fprintf(stderr, " -I key_id Key identifier to include in certificate.\n");
Damien Miller44b25042010-07-02 13:35:01 +10002148 fprintf(stderr, " -i Import foreign format to OpenSSH key file.\n");
Damien Miller709a1e92012-07-31 12:20:43 +10002149 fprintf(stderr, " -J number Screen this number of moduli lines.\n");
Damien Millerdfceafe2012-07-06 13:44:19 +10002150 fprintf(stderr, " -j number Start screening moduli at specified line.\n");
Damien Miller927d82b2011-10-18 16:05:38 +11002151 fprintf(stderr, " -K checkpt Write checkpoints to this file.\n");
Damien Millerf3747bf2013-01-18 11:44:04 +11002152 fprintf(stderr, " -k Generate a KRL file.\n");
Damien Millerf2b70ca2010-03-05 07:39:35 +11002153 fprintf(stderr, " -L Print the contents of a certificate.\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002154 fprintf(stderr, " -l Show fingerprint of key file.\n");
2155 fprintf(stderr, " -M memory Amount of memory (MB) to use for generating DH-GEX moduli.\n");
Damien Miller6022f582010-07-02 13:37:01 +10002156 fprintf(stderr, " -m key_fmt Conversion format for -e/-i (PEM|PKCS8|RFC4716).\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002157 fprintf(stderr, " -N phrase Provide new passphrase.\n");
Damien Miller6022f582010-07-02 13:37:01 +10002158 fprintf(stderr, " -n name,... User/host principal names to include in certificate\n");
Damien Miller1f181422010-04-18 08:08:03 +10002159 fprintf(stderr, " -O option Specify a certificate option.\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002160 fprintf(stderr, " -P phrase Provide old passphrase.\n");
2161 fprintf(stderr, " -p Change passphrase of private key file.\n");
Damien Millerf3747bf2013-01-18 11:44:04 +11002162 fprintf(stderr, " -Q Test whether key(s) are revoked in KRL.\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002163 fprintf(stderr, " -q Quiet.\n");
2164 fprintf(stderr, " -R hostname Remove host from known_hosts file.\n");
2165 fprintf(stderr, " -r hostname Print DNS resource record.\n");
2166 fprintf(stderr, " -S start Start point (hex) for generating DH-GEX moduli.\n");
Damien Miller6022f582010-07-02 13:37:01 +10002167 fprintf(stderr, " -s ca_key Certify keys with CA key.\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002168 fprintf(stderr, " -T file Screen candidates for DH-GEX moduli.\n");
2169 fprintf(stderr, " -t type Specify type of key to create.\n");
Damien Millerf3747bf2013-01-18 11:44:04 +11002170 fprintf(stderr, " -u Update KRL rather than creating a new one.\n");
Damien Miller3d6d68b2013-01-20 22:33:23 +11002171 fprintf(stderr, " -V from:to Specify certificate validity interval.\n");
Damien Miller9278ffa2005-05-26 11:59:06 +10002172 fprintf(stderr, " -v Verbose.\n");
2173 fprintf(stderr, " -W gen Generator to use for generating DH-GEX moduli.\n");
2174 fprintf(stderr, " -y Read private key file and print public key.\n");
Damien Miller1f181422010-04-18 08:08:03 +10002175 fprintf(stderr, " -z serial Specify a serial number.\n");
Darren Tucker019cefe2003-08-02 22:40:07 +10002176
Damien Miller95def091999-11-25 00:26:21 +11002177 exit(1);
Damien Miller431f66b1999-11-21 18:31:57 +11002178}
2179
Damien Miller95def091999-11-25 00:26:21 +11002180/*
2181 * Main program for key management.
2182 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002183int
Damien Millerdf8b7db2007-01-05 16:22:57 +11002184main(int argc, char **argv)
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002185{
Damien Millera41c8b12002-01-22 23:05:08 +11002186 char dotsshdir[MAXPATHLEN], comment[1024], *passphrase1, *passphrase2;
Damien Miller390d0562011-10-18 16:05:19 +11002187 char *checkpoint = NULL;
Damien Millerf3747bf2013-01-18 11:44:04 +11002188 char out_file[MAXPATHLEN], *ep, *rr_hostname = NULL;
Ben Lindstrom5fc62702001-03-09 18:19:24 +00002189 Key *private, *public;
Damien Miller95def091999-11-25 00:26:21 +11002190 struct passwd *pw;
Damien Miller95def091999-11-25 00:26:21 +11002191 struct stat st;
Damien Miller7ea845e2010-02-12 09:21:02 +11002192 int opt, type, fd;
Darren Tucker2db8ae62005-06-01 23:02:25 +10002193 u_int32_t memory = 0, generator_wanted = 0, trials = 100;
Darren Tucker019cefe2003-08-02 22:40:07 +10002194 int do_gen_candidates = 0, do_screen_candidates = 0;
Damien Millerf3747bf2013-01-18 11:44:04 +11002195 int gen_all_hostkeys = 0, gen_krl = 0, update_krl = 0, check_krl = 0;
Damien Millerdfceafe2012-07-06 13:44:19 +10002196 unsigned long start_lineno = 0, lines_to_process = 0;
Darren Tucker019cefe2003-08-02 22:40:07 +10002197 BIGNUM *start = NULL;
Damien Miller95def091999-11-25 00:26:21 +11002198 FILE *f;
Damien Miller02e754f2005-05-26 12:19:39 +10002199 const char *errstr;
Damien Miller0bc1bd82000-11-13 22:57:25 +11002200
Damien Miller95def091999-11-25 00:26:21 +11002201 extern int optind;
2202 extern char *optarg;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002203
Darren Tuckerce321d82005-10-03 18:11:24 +10002204 /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
2205 sanitise_stdfd();
2206
Darren Tucker9ac56e92007-01-14 10:19:59 +11002207 __progname = ssh_get_progname(argv[0]);
Damien Millerf9b625c2000-07-09 22:42:32 +10002208
Damien Miller4314c2b2010-09-10 11:12:09 +10002209 OpenSSL_add_all_algorithms();
Damien Millerdf8b7db2007-01-05 16:22:57 +11002210 log_init(argv[0], SYSLOG_LEVEL_INFO, SYSLOG_FACILITY_USER, 1);
Darren Tucker019cefe2003-08-02 22:40:07 +10002211
Kevin Steves3a881912002-07-20 19:05:40 +00002212 seed_rng();
Damien Millereba71ba2000-04-29 23:57:08 +10002213
Damien Miller5428f641999-11-25 11:54:57 +11002214 /* we need this for the home * directory. */
Damien Miller95def091999-11-25 00:26:21 +11002215 pw = getpwuid(getuid());
2216 if (!pw) {
Damien Miller3009d3c2013-07-20 13:22:31 +10002217 printf("No user exists for uid %lu\n", (u_long)getuid());
Damien Miller95def091999-11-25 00:26:21 +11002218 exit(1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002219 }
Damien Millereba71ba2000-04-29 23:57:08 +10002220 if (gethostname(hostname, sizeof(hostname)) < 0) {
2221 perror("gethostname");
2222 exit(1);
2223 }
Damien Miller5428f641999-11-25 11:54:57 +11002224
Damien Millerf3747bf2013-01-18 11:44:04 +11002225 while ((opt = getopt(argc, argv, "ABHLQXceghiklpquvxy"
2226 "C:D:F:G:I:J:K:M:N:O:P:R:S:T:V:W:a:b:f:g:j:m:n:r:s:t:z:")) != -1) {
Damien Miller95def091999-11-25 00:26:21 +11002227 switch (opt) {
Damien Miller58f1baf2011-05-05 14:06:15 +10002228 case 'A':
2229 gen_all_hostkeys = 1;
2230 break;
Damien Miller95def091999-11-25 00:26:21 +11002231 case 'b':
Damien Miller57737942010-09-10 11:16:37 +10002232 bits = (u_int32_t)strtonum(optarg, 256, 32768, &errstr);
Damien Miller02e754f2005-05-26 12:19:39 +10002233 if (errstr)
2234 fatal("Bits has bad value %s (%s)",
2235 optarg, errstr);
Damien Miller95def091999-11-25 00:26:21 +11002236 break;
Damien Miller4b42d7f2005-03-01 21:48:35 +11002237 case 'F':
2238 find_host = 1;
2239 rr_hostname = optarg;
2240 break;
2241 case 'H':
2242 hash_hosts = 1;
2243 break;
Damien Miller0a80ca12010-02-27 07:55:05 +11002244 case 'I':
2245 cert_key_id = optarg;
2246 break;
Damien Millerdfceafe2012-07-06 13:44:19 +10002247 case 'J':
2248 lines_to_process = strtoul(optarg, NULL, 10);
2249 break;
2250 case 'j':
2251 start_lineno = strtoul(optarg, NULL, 10);
2252 break;
Damien Miller4b42d7f2005-03-01 21:48:35 +11002253 case 'R':
2254 delete_host = 1;
2255 rr_hostname = optarg;
2256 break;
Damien Millerf2b70ca2010-03-05 07:39:35 +11002257 case 'L':
2258 show_cert = 1;
2259 break;
Damien Miller95def091999-11-25 00:26:21 +11002260 case 'l':
2261 print_fingerprint = 1;
2262 break;
Ben Lindstrom8fd372b2001-03-12 03:02:17 +00002263 case 'B':
2264 print_bubblebabble = 1;
2265 break;
Damien Miller44b25042010-07-02 13:35:01 +10002266 case 'm':
2267 if (strcasecmp(optarg, "RFC4716") == 0 ||
2268 strcasecmp(optarg, "ssh2") == 0) {
2269 convert_format = FMT_RFC4716;
2270 break;
2271 }
2272 if (strcasecmp(optarg, "PKCS8") == 0) {
2273 convert_format = FMT_PKCS8;
2274 break;
2275 }
2276 if (strcasecmp(optarg, "PEM") == 0) {
2277 convert_format = FMT_PEM;
2278 break;
2279 }
2280 fatal("Unsupported conversion format \"%s\"", optarg);
Damien Miller0a80ca12010-02-27 07:55:05 +11002281 case 'n':
2282 cert_principals = optarg;
2283 break;
Damien Miller95def091999-11-25 00:26:21 +11002284 case 'p':
2285 change_passphrase = 1;
2286 break;
Damien Miller95def091999-11-25 00:26:21 +11002287 case 'c':
2288 change_comment = 1;
2289 break;
Damien Miller95def091999-11-25 00:26:21 +11002290 case 'f':
Damien Millerb089fb52005-05-26 12:16:18 +10002291 if (strlcpy(identity_file, optarg, sizeof(identity_file)) >=
2292 sizeof(identity_file))
2293 fatal("Identity filename too long");
Damien Miller95def091999-11-25 00:26:21 +11002294 have_identity = 1;
2295 break;
Damien Miller37876e92003-05-15 10:19:46 +10002296 case 'g':
2297 print_generic = 1;
2298 break;
Damien Miller95def091999-11-25 00:26:21 +11002299 case 'P':
2300 identity_passphrase = optarg;
2301 break;
Damien Miller95def091999-11-25 00:26:21 +11002302 case 'N':
2303 identity_new_passphrase = optarg;
2304 break;
Damien Millerf3747bf2013-01-18 11:44:04 +11002305 case 'Q':
2306 check_krl = 1;
2307 break;
Damien Miller0a80ca12010-02-27 07:55:05 +11002308 case 'O':
Damien Miller4e270b02010-04-16 15:56:21 +10002309 add_cert_option(optarg);
Damien Miller0a80ca12010-02-27 07:55:05 +11002310 break;
Damien Miller95def091999-11-25 00:26:21 +11002311 case 'C':
2312 identity_comment = optarg;
2313 break;
Damien Miller95def091999-11-25 00:26:21 +11002314 case 'q':
2315 quiet = 1;
2316 break;
Ben Lindstrom5a707822001-04-22 17:15:46 +00002317 case 'e':
Damien Millereba71ba2000-04-29 23:57:08 +10002318 case 'x':
Ben Lindstrom5a707822001-04-22 17:15:46 +00002319 /* export key */
Damien Miller44b25042010-07-02 13:35:01 +10002320 convert_to = 1;
Damien Millereba71ba2000-04-29 23:57:08 +10002321 break;
Damien Miller0a80ca12010-02-27 07:55:05 +11002322 case 'h':
2323 cert_key_type = SSH2_CERT_TYPE_HOST;
Damien Millerd0e4a8e2010-05-21 14:58:32 +10002324 certflags_flags = 0;
Damien Miller0a80ca12010-02-27 07:55:05 +11002325 break;
Damien Millerf3747bf2013-01-18 11:44:04 +11002326 case 'k':
2327 gen_krl = 1;
2328 break;
Ben Lindstrom5a707822001-04-22 17:15:46 +00002329 case 'i':
Damien Millereba71ba2000-04-29 23:57:08 +10002330 case 'X':
Ben Lindstrom5a707822001-04-22 17:15:46 +00002331 /* import key */
Damien Miller44b25042010-07-02 13:35:01 +10002332 convert_from = 1;
Damien Millereba71ba2000-04-29 23:57:08 +10002333 break;
Damien Millereba71ba2000-04-29 23:57:08 +10002334 case 'y':
2335 print_public = 1;
2336 break;
Damien Miller0a80ca12010-02-27 07:55:05 +11002337 case 's':
2338 ca_key_path = optarg;
2339 break;
Damien Miller0bc1bd82000-11-13 22:57:25 +11002340 case 't':
2341 key_type_name = optarg;
Damien Miller0bc1bd82000-11-13 22:57:25 +11002342 break;
Ben Lindstrom8282d6a2001-08-06 21:44:05 +00002343 case 'D':
Damien Miller7ea845e2010-02-12 09:21:02 +11002344 pkcs11provider = optarg;
Ben Lindstromcd392282001-07-04 03:44:03 +00002345 break;
Damien Millerf3747bf2013-01-18 11:44:04 +11002346 case 'u':
2347 update_krl = 1;
2348 break;
Darren Tucker06930c72003-12-31 11:34:51 +11002349 case 'v':
2350 if (log_level == SYSLOG_LEVEL_INFO)
2351 log_level = SYSLOG_LEVEL_DEBUG1;
2352 else {
Darren Tuckerfc959702004-07-17 16:12:08 +10002353 if (log_level >= SYSLOG_LEVEL_DEBUG1 &&
Darren Tucker06930c72003-12-31 11:34:51 +11002354 log_level < SYSLOG_LEVEL_DEBUG3)
2355 log_level++;
2356 }
2357 break;
Damien Miller37876e92003-05-15 10:19:46 +10002358 case 'r':
Damien Miller4b42d7f2005-03-01 21:48:35 +11002359 rr_hostname = optarg;
Damien Miller37876e92003-05-15 10:19:46 +10002360 break;
Darren Tucker019cefe2003-08-02 22:40:07 +10002361 case 'W':
Damien Miller5f340062006-03-26 14:27:57 +11002362 generator_wanted = (u_int32_t)strtonum(optarg, 1,
2363 UINT_MAX, &errstr);
Damien Millerb089fb52005-05-26 12:16:18 +10002364 if (errstr)
2365 fatal("Desired generator has bad value: %s (%s)",
2366 optarg, errstr);
Darren Tucker019cefe2003-08-02 22:40:07 +10002367 break;
2368 case 'a':
Damien Miller5f340062006-03-26 14:27:57 +11002369 trials = (u_int32_t)strtonum(optarg, 1, UINT_MAX, &errstr);
Damien Millerb089fb52005-05-26 12:16:18 +10002370 if (errstr)
2371 fatal("Invalid number of trials: %s (%s)",
2372 optarg, errstr);
Darren Tucker019cefe2003-08-02 22:40:07 +10002373 break;
2374 case 'M':
Damien Miller5f340062006-03-26 14:27:57 +11002375 memory = (u_int32_t)strtonum(optarg, 1, UINT_MAX, &errstr);
Damien Miller4e270b02010-04-16 15:56:21 +10002376 if (errstr)
Damien Millerb089fb52005-05-26 12:16:18 +10002377 fatal("Memory limit is %s: %s", errstr, optarg);
Darren Tucker019cefe2003-08-02 22:40:07 +10002378 break;
2379 case 'G':
2380 do_gen_candidates = 1;
Damien Millerb089fb52005-05-26 12:16:18 +10002381 if (strlcpy(out_file, optarg, sizeof(out_file)) >=
2382 sizeof(out_file))
2383 fatal("Output filename too long");
Darren Tucker019cefe2003-08-02 22:40:07 +10002384 break;
2385 case 'T':
2386 do_screen_candidates = 1;
Damien Millerb089fb52005-05-26 12:16:18 +10002387 if (strlcpy(out_file, optarg, sizeof(out_file)) >=
2388 sizeof(out_file))
2389 fatal("Output filename too long");
Darren Tucker019cefe2003-08-02 22:40:07 +10002390 break;
Damien Miller390d0562011-10-18 16:05:19 +11002391 case 'K':
2392 if (strlen(optarg) >= MAXPATHLEN)
2393 fatal("Checkpoint filename too long");
2394 checkpoint = xstrdup(optarg);
2395 break;
Darren Tucker019cefe2003-08-02 22:40:07 +10002396 case 'S':
2397 /* XXX - also compare length against bits */
2398 if (BN_hex2bn(&start, optarg) == 0)
2399 fatal("Invalid start point.");
2400 break;
Damien Miller0a80ca12010-02-27 07:55:05 +11002401 case 'V':
2402 parse_cert_times(optarg);
2403 break;
Damien Miller4e270b02010-04-16 15:56:21 +10002404 case 'z':
Damien Miller6f3b3622012-11-14 19:04:33 +11002405 errno = 0;
2406 cert_serial = strtoull(optarg, &ep, 10);
2407 if (*optarg < '0' || *optarg > '9' || *ep != '\0' ||
2408 (errno == ERANGE && cert_serial == ULLONG_MAX))
2409 fatal("Invalid serial number \"%s\"", optarg);
Damien Miller4e270b02010-04-16 15:56:21 +10002410 break;
Damien Miller95def091999-11-25 00:26:21 +11002411 case '?':
2412 default:
2413 usage();
2414 }
2415 }
Darren Tucker06930c72003-12-31 11:34:51 +11002416
2417 /* reinit */
Damien Millerdf8b7db2007-01-05 16:22:57 +11002418 log_init(argv[0], log_level, SYSLOG_FACILITY_USER, 1);
Darren Tucker06930c72003-12-31 11:34:51 +11002419
Damien Miller0a80ca12010-02-27 07:55:05 +11002420 argv += optind;
2421 argc -= optind;
2422
2423 if (ca_key_path != NULL) {
Damien Millerf3747bf2013-01-18 11:44:04 +11002424 if (argc < 1 && !gen_krl) {
Damien Miller0a80ca12010-02-27 07:55:05 +11002425 printf("Too few arguments.\n");
2426 usage();
2427 }
Damien Millerf3747bf2013-01-18 11:44:04 +11002428 } else if (argc > 0 && !gen_krl && !check_krl) {
Damien Miller95def091999-11-25 00:26:21 +11002429 printf("Too many arguments.\n");
2430 usage();
2431 }
2432 if (change_passphrase && change_comment) {
2433 printf("Can only have one of -p and -c.\n");
2434 usage();
2435 }
Darren Tucker0f7e9102008-06-08 12:54:29 +10002436 if (print_fingerprint && (delete_host || hash_hosts)) {
Damien Millerec77c952013-01-09 15:58:00 +11002437 printf("Cannot use -l with -H or -R.\n");
Darren Tucker0f7e9102008-06-08 12:54:29 +10002438 usage();
2439 }
Damien Millerf3747bf2013-01-18 11:44:04 +11002440 if (gen_krl) {
2441 do_gen_krl(pw, update_krl, argc, argv);
2442 return (0);
2443 }
2444 if (check_krl) {
2445 do_check_krl(pw, argc, argv);
2446 return (0);
2447 }
Damien Miller0a80ca12010-02-27 07:55:05 +11002448 if (ca_key_path != NULL) {
2449 if (cert_key_id == NULL)
2450 fatal("Must specify key id (-I) when certifying");
2451 do_ca_sign(pw, argc, argv);
2452 }
Damien Millerf2b70ca2010-03-05 07:39:35 +11002453 if (show_cert)
2454 do_show_cert(pw);
Damien Miller4b42d7f2005-03-01 21:48:35 +11002455 if (delete_host || hash_hosts || find_host)
2456 do_known_hosts(pw, rr_hostname);
Damien Millerec77c952013-01-09 15:58:00 +11002457 if (pkcs11provider != NULL)
2458 do_download(pw);
Ben Lindstrom8fd372b2001-03-12 03:02:17 +00002459 if (print_fingerprint || print_bubblebabble)
Damien Miller95def091999-11-25 00:26:21 +11002460 do_fingerprint(pw);
Damien Miller95def091999-11-25 00:26:21 +11002461 if (change_passphrase)
2462 do_change_passphrase(pw);
Damien Miller4a10d2e2002-03-11 22:53:29 +11002463 if (change_comment)
2464 do_change_comment(pw);
Damien Miller44b25042010-07-02 13:35:01 +10002465 if (convert_to)
2466 do_convert_to(pw);
2467 if (convert_from)
2468 do_convert_from(pw);
Damien Millereba71ba2000-04-29 23:57:08 +10002469 if (print_public)
2470 do_print_public(pw);
Damien Miller4b42d7f2005-03-01 21:48:35 +11002471 if (rr_hostname != NULL) {
Damien Millercb314822006-03-26 13:48:01 +11002472 unsigned int n = 0;
2473
2474 if (have_identity) {
2475 n = do_print_resource_record(pw,
2476 identity_file, rr_hostname);
2477 if (n == 0) {
2478 perror(identity_file);
2479 exit(1);
2480 }
2481 exit(0);
2482 } else {
2483
2484 n += do_print_resource_record(pw,
2485 _PATH_HOST_RSA_KEY_FILE, rr_hostname);
2486 n += do_print_resource_record(pw,
2487 _PATH_HOST_DSA_KEY_FILE, rr_hostname);
Damien Miller3bde12a2012-06-20 21:51:11 +10002488 n += do_print_resource_record(pw,
2489 _PATH_HOST_ECDSA_KEY_FILE, rr_hostname);
Damien Millercb314822006-03-26 13:48:01 +11002490
2491 if (n == 0)
2492 fatal("no keys found.");
2493 exit(0);
2494 }
Damien Miller37876e92003-05-15 10:19:46 +10002495 }
Damien Miller95def091999-11-25 00:26:21 +11002496
Darren Tucker019cefe2003-08-02 22:40:07 +10002497 if (do_gen_candidates) {
2498 FILE *out = fopen(out_file, "w");
Damien Miller787b2ec2003-11-21 23:56:47 +11002499
Darren Tucker019cefe2003-08-02 22:40:07 +10002500 if (out == NULL) {
2501 error("Couldn't open modulus candidate file \"%s\": %s",
2502 out_file, strerror(errno));
2503 return (1);
2504 }
Damien Miller3f54a9f2005-11-05 14:52:18 +11002505 if (bits == 0)
2506 bits = DEFAULT_BITS;
Darren Tucker019cefe2003-08-02 22:40:07 +10002507 if (gen_candidates(out, memory, bits, start) != 0)
Damien Miller15d72a02005-11-05 15:07:33 +11002508 fatal("modulus candidate generation failed");
Darren Tucker019cefe2003-08-02 22:40:07 +10002509
2510 return (0);
2511 }
2512
2513 if (do_screen_candidates) {
2514 FILE *in;
Damien Miller78d22712013-02-12 11:03:36 +11002515 FILE *out = fopen(out_file, "a");
Darren Tucker019cefe2003-08-02 22:40:07 +10002516
2517 if (have_identity && strcmp(identity_file, "-") != 0) {
2518 if ((in = fopen(identity_file, "r")) == NULL) {
2519 fatal("Couldn't open modulus candidate "
Damien Millera8e06ce2003-11-21 23:48:55 +11002520 "file \"%s\": %s", identity_file,
Darren Tucker019cefe2003-08-02 22:40:07 +10002521 strerror(errno));
2522 }
2523 } else
2524 in = stdin;
2525
2526 if (out == NULL) {
2527 fatal("Couldn't open moduli file \"%s\": %s",
2528 out_file, strerror(errno));
2529 }
Damien Millerdfceafe2012-07-06 13:44:19 +10002530 if (prime_test(in, out, trials, generator_wanted, checkpoint,
2531 start_lineno, lines_to_process) != 0)
Damien Miller15d72a02005-11-05 15:07:33 +11002532 fatal("modulus screening failed");
Darren Tuckerf4220e62003-08-21 16:44:07 +10002533 return (0);
Darren Tucker019cefe2003-08-02 22:40:07 +10002534 }
2535
Damien Miller58f1baf2011-05-05 14:06:15 +10002536 if (gen_all_hostkeys) {
2537 do_gen_all_hostkeys(pw);
2538 return (0);
2539 }
2540
Damien Miller95def091999-11-25 00:26:21 +11002541 arc4random_stir();
2542
Damien Millerf14be5c2005-11-05 15:15:49 +11002543 if (key_type_name == NULL)
2544 key_type_name = "rsa";
2545
Damien Millere39cacc2000-11-29 12:18:44 +11002546 type = key_type_from_name(key_type_name);
Damien Miller58f1baf2011-05-05 14:06:15 +10002547 type_bits_valid(type, &bits);
2548
Darren Tucker3af2ac52005-11-29 13:10:24 +11002549 if (!quiet)
2550 printf("Generating public/private %s key pair.\n", key_type_name);
Damien Miller0bc1bd82000-11-13 22:57:25 +11002551 private = key_generate(type, bits);
2552 if (private == NULL) {
Damien Miller9eab9562009-02-22 08:47:02 +11002553 fprintf(stderr, "key_generate failed\n");
Damien Miller0bc1bd82000-11-13 22:57:25 +11002554 exit(1);
2555 }
2556 public = key_from_private(private);
Damien Miller95def091999-11-25 00:26:21 +11002557
2558 if (!have_identity)
2559 ask_filename(pw, "Enter file in which to save the key");
2560
Damien Miller788f2122005-11-05 15:14:59 +11002561 /* Create ~/.ssh directory if it doesn't already exist. */
Damien Miller50af79b2010-05-10 11:52:00 +10002562 snprintf(dotsshdir, sizeof dotsshdir, "%s/%s",
2563 pw->pw_dir, _PATH_SSH_USER_DIR);
2564 if (strstr(identity_file, dotsshdir) != NULL) {
2565 if (stat(dotsshdir, &st) < 0) {
2566 if (errno != ENOENT) {
2567 error("Could not stat %s: %s", dotsshdir,
2568 strerror(errno));
2569 } else if (mkdir(dotsshdir, 0700) < 0) {
2570 error("Could not create directory '%s': %s",
2571 dotsshdir, strerror(errno));
2572 } else if (!quiet)
2573 printf("Created directory '%s'.\n", dotsshdir);
2574 }
Damien Miller95def091999-11-25 00:26:21 +11002575 }
2576 /* If the file already exists, ask the user to confirm. */
2577 if (stat(identity_file, &st) >= 0) {
2578 char yesno[3];
2579 printf("%s already exists.\n", identity_file);
2580 printf("Overwrite (y/n)? ");
2581 fflush(stdout);
2582 if (fgets(yesno, sizeof(yesno), stdin) == NULL)
2583 exit(1);
2584 if (yesno[0] != 'y' && yesno[0] != 'Y')
2585 exit(1);
2586 }
2587 /* Ask for a passphrase (twice). */
2588 if (identity_passphrase)
2589 passphrase1 = xstrdup(identity_passphrase);
2590 else if (identity_new_passphrase)
2591 passphrase1 = xstrdup(identity_new_passphrase);
2592 else {
2593passphrase_again:
2594 passphrase1 =
Ben Lindstrom949974b2001-06-25 05:20:31 +00002595 read_passphrase("Enter passphrase (empty for no "
2596 "passphrase): ", RP_ALLOW_STDIN);
2597 passphrase2 = read_passphrase("Enter same passphrase again: ",
2598 RP_ALLOW_STDIN);
Damien Miller95def091999-11-25 00:26:21 +11002599 if (strcmp(passphrase1, passphrase2) != 0) {
Ben Lindstrom949974b2001-06-25 05:20:31 +00002600 /*
2601 * The passphrases do not match. Clear them and
2602 * retry.
2603 */
Damien Miller95def091999-11-25 00:26:21 +11002604 memset(passphrase1, 0, strlen(passphrase1));
2605 memset(passphrase2, 0, strlen(passphrase2));
Darren Tuckera627d422013-06-02 07:31:17 +10002606 free(passphrase1);
2607 free(passphrase2);
Damien Miller95def091999-11-25 00:26:21 +11002608 printf("Passphrases do not match. Try again.\n");
2609 goto passphrase_again;
2610 }
2611 /* Clear the other copy of the passphrase. */
2612 memset(passphrase2, 0, strlen(passphrase2));
Darren Tuckera627d422013-06-02 07:31:17 +10002613 free(passphrase2);
Damien Miller95def091999-11-25 00:26:21 +11002614 }
2615
Damien Miller95def091999-11-25 00:26:21 +11002616 if (identity_comment) {
2617 strlcpy(comment, identity_comment, sizeof(comment));
2618 } else {
Darren Tuckere15fb092008-11-11 16:31:43 +11002619 /* Create default comment field for the passphrase. */
Damien Miller95def091999-11-25 00:26:21 +11002620 snprintf(comment, sizeof comment, "%s@%s", pw->pw_name, hostname);
2621 }
2622
2623 /* Save the key with the given passphrase and comment. */
Ben Lindstromd0fca422001-03-26 13:44:06 +00002624 if (!key_save_private(private, identity_file, passphrase1, comment)) {
Ben Lindstrom15f33862001-04-16 02:00:02 +00002625 printf("Saving the key failed: %s.\n", identity_file);
Damien Miller95def091999-11-25 00:26:21 +11002626 memset(passphrase1, 0, strlen(passphrase1));
Darren Tuckera627d422013-06-02 07:31:17 +10002627 free(passphrase1);
Damien Miller95def091999-11-25 00:26:21 +11002628 exit(1);
2629 }
2630 /* Clear the passphrase. */
2631 memset(passphrase1, 0, strlen(passphrase1));
Darren Tuckera627d422013-06-02 07:31:17 +10002632 free(passphrase1);
Damien Miller95def091999-11-25 00:26:21 +11002633
2634 /* Clear the private key and the random number generator. */
Damien Miller0bc1bd82000-11-13 22:57:25 +11002635 key_free(private);
Damien Miller95def091999-11-25 00:26:21 +11002636 arc4random_stir();
2637
2638 if (!quiet)
2639 printf("Your identification has been saved in %s.\n", identity_file);
2640
Damien Miller95def091999-11-25 00:26:21 +11002641 strlcat(identity_file, ".pub", sizeof(identity_file));
Ben Lindstrom5fc62702001-03-09 18:19:24 +00002642 fd = open(identity_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
2643 if (fd == -1) {
Damien Miller95def091999-11-25 00:26:21 +11002644 printf("Could not save your public key in %s\n", identity_file);
2645 exit(1);
2646 }
Ben Lindstrom5fc62702001-03-09 18:19:24 +00002647 f = fdopen(fd, "w");
2648 if (f == NULL) {
Damien Miller9eab9562009-02-22 08:47:02 +11002649 printf("fdopen %s failed\n", identity_file);
Ben Lindstrom5fc62702001-03-09 18:19:24 +00002650 exit(1);
2651 }
Damien Millereba71ba2000-04-29 23:57:08 +10002652 if (!key_write(public, f))
Damien Miller9eab9562009-02-22 08:47:02 +11002653 fprintf(stderr, "write key failed\n");
Damien Millereba71ba2000-04-29 23:57:08 +10002654 fprintf(f, " %s\n", comment);
Damien Miller95def091999-11-25 00:26:21 +11002655 fclose(f);
2656
2657 if (!quiet) {
Ben Lindstromcfccef92001-03-13 04:57:58 +00002658 char *fp = key_fingerprint(public, SSH_FP_MD5, SSH_FP_HEX);
Darren Tucker9c16ac92008-06-13 04:40:35 +10002659 char *ra = key_fingerprint(public, SSH_FP_MD5,
2660 SSH_FP_RANDOMART);
Damien Millereba71ba2000-04-29 23:57:08 +10002661 printf("Your public key has been saved in %s.\n",
2662 identity_file);
Damien Miller95def091999-11-25 00:26:21 +11002663 printf("The key fingerprint is:\n");
Ben Lindstromcfccef92001-03-13 04:57:58 +00002664 printf("%s %s\n", fp, comment);
Darren Tucker9c16ac92008-06-13 04:40:35 +10002665 printf("The key's randomart image is:\n");
2666 printf("%s\n", ra);
Darren Tuckera627d422013-06-02 07:31:17 +10002667 free(ra);
2668 free(fp);
Damien Miller95def091999-11-25 00:26:21 +11002669 }
Damien Millereba71ba2000-04-29 23:57:08 +10002670
2671 key_free(public);
Damien Miller95def091999-11-25 00:26:21 +11002672 exit(0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002673}