blob: 9aac64fc3b14a8e859c9de6db5be566dcb4ac9b2 [file] [log] [blame]
djm@openbsd.orgbf0fbf22018-03-12 00:52:01 +00001/* $OpenBSD: ssh-keygen.c,v 1.314 2018/03/12 00:52:01 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 Millerd4a8b7e1999-10-27 13:42:43 +100020
Damien Miller72ef7c12015-01-15 02:21:31 +110021#ifdef WITH_OPENSSL
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 Miller72ef7c12015-01-15 02:21:31 +110025#endif
Damien Millereba71ba2000-04-29 23:57:08 +100026
Darren Tucker39972492006-07-12 22:22:46 +100027#include <errno.h>
Damien Miller57cf6382006-07-10 21:13:46 +100028#include <fcntl.h>
Damien Millerb8fe89c2006-07-24 14:51:00 +100029#include <netdb.h>
Darren Tucker2ee50c52006-07-11 18:55:05 +100030#ifdef HAVE_PATHS_H
31# include <paths.h>
32#endif
Damien Miller9f2abc42006-07-10 20:53:08 +100033#include <pwd.h>
Damien Millerded319c2006-09-01 15:38:36 +100034#include <stdarg.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100035#include <stdio.h>
Damien Millere7a1e5c2006-08-05 11:34:19 +100036#include <stdlib.h>
Damien Millere3476ed2006-07-24 14:13:33 +100037#include <string.h>
Damien Millere6b3b612006-07-24 14:01:23 +100038#include <unistd.h>
deraadt@openbsd.org2ae4f332015-01-16 06:40:12 +000039#include <limits.h>
djm@openbsd.orga287c5a2017-02-10 03:36:40 +000040#include <locale.h>
Damien Miller9f2abc42006-07-10 20:53:08 +100041
Damien Millerd4a8b7e1999-10-27 13:42:43 +100042#include "xmalloc.h"
djm@openbsd.org1129dcf2015-01-15 09:40:00 +000043#include "sshkey.h"
Damien Millereba71ba2000-04-29 23:57:08 +100044#include "authfile.h"
45#include "uuencode.h"
djm@openbsd.org1129dcf2015-01-15 09:40:00 +000046#include "sshbuf.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000047#include "pathnames.h"
48#include "log.h"
Darren Tuckere608ca22004-05-13 16:15:47 +100049#include "misc.h"
Damien Miller4b42d7f2005-03-01 21:48:35 +110050#include "match.h"
51#include "hostfile.h"
Damien Miller69996102006-07-10 20:53:31 +100052#include "dns.h"
Damien Millerf3747bf2013-01-18 11:44:04 +110053#include "ssh.h"
Damien Miller0a80ca12010-02-27 07:55:05 +110054#include "ssh2.h"
djm@openbsd.org1129dcf2015-01-15 09:40:00 +000055#include "ssherr.h"
Damien Miller7ea845e2010-02-12 09:21:02 +110056#include "ssh-pkcs11.h"
Damien Millerf3747bf2013-01-18 11:44:04 +110057#include "atomicio.h"
58#include "krl.h"
djm@openbsd.org56d1c832014-12-21 22:27:55 +000059#include "digest.h"
djm@openbsd.orga287c5a2017-02-10 03:36:40 +000060#include "utf8.h"
djm@openbsd.orga98339e2017-06-28 01:09:22 +000061#include "authfd.h"
Ben Lindstromcd392282001-07-04 03:44:03 +000062
djm@openbsd.orgd1958792015-05-28 04:40:13 +000063#ifdef WITH_OPENSSL
64# define DEFAULT_KEY_TYPE_NAME "rsa"
65#else
66# define DEFAULT_KEY_TYPE_NAME "ed25519"
67#endif
68
Damien Miller3f54a9f2005-11-05 14:52:18 +110069/* Number of bits in the RSA/DSA key. This value can be set on the command line. */
70#define DEFAULT_BITS 2048
71#define DEFAULT_BITS_DSA 1024
Damien Miller6e9f6802010-09-10 11:17:38 +100072#define DEFAULT_BITS_ECDSA 256
Damien Miller3f54a9f2005-11-05 14:52:18 +110073u_int32_t bits = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100074
Damien Miller5428f641999-11-25 11:54:57 +110075/*
76 * Flag indicating that we just want to change the passphrase. This can be
77 * set on the command line.
78 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100079int change_passphrase = 0;
80
Damien Miller5428f641999-11-25 11:54:57 +110081/*
82 * Flag indicating that we just want to change the comment. This can be set
83 * on the command line.
84 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100085int change_comment = 0;
86
87int quiet = 0;
88
Darren Tucker35c45532008-06-13 04:43:15 +100089int log_level = SYSLOG_LEVEL_INFO;
90
Damien Miller4b42d7f2005-03-01 21:48:35 +110091/* Flag indicating that we want to hash a known_hosts file */
92int hash_hosts = 0;
93/* Flag indicating that we want lookup a host in known_hosts file */
94int find_host = 0;
95/* Flag indicating that we want to delete a host from a known_hosts file */
96int delete_host = 0;
97
Damien Millerf2b70ca2010-03-05 07:39:35 +110098/* Flag indicating that we want to show the contents of a certificate */
99int show_cert = 0;
100
Damien Miller10f6f6b1999-11-17 17:29:08 +1100101/* Flag indicating that we just want to see the key fingerprint */
102int print_fingerprint = 0;
Ben Lindstrom8fd372b2001-03-12 03:02:17 +0000103int print_bubblebabble = 0;
Damien Miller10f6f6b1999-11-17 17:29:08 +1100104
djm@openbsd.org56d1c832014-12-21 22:27:55 +0000105/* Hash algorithm to use for fingerprints. */
106int fingerprint_hash = SSH_FP_HASH_DEFAULT;
107
Damien Miller431f66b1999-11-21 18:31:57 +1100108/* The identity file name, given on the command line or entered by the user. */
109char identity_file[1024];
110int have_identity = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000111
112/* This is set to the passphrase if given on the command line. */
113char *identity_passphrase = NULL;
114
115/* This is set to the new passphrase if given on the command line. */
116char *identity_new_passphrase = NULL;
117
118/* This is set to the new comment if given on the command line. */
119char *identity_comment = NULL;
120
Damien Miller0a80ca12010-02-27 07:55:05 +1100121/* Path to CA key when certifying keys. */
122char *ca_key_path = NULL;
123
djm@openbsd.orga98339e2017-06-28 01:09:22 +0000124/* Prefer to use agent keys for CA signing */
125int prefer_agent = 0;
126
Damien Miller4e270b02010-04-16 15:56:21 +1000127/* Certificate serial number */
Damien Miller55aca022012-12-03 11:25:30 +1100128unsigned long long cert_serial = 0;
Damien Miller4e270b02010-04-16 15:56:21 +1000129
Damien Miller0a80ca12010-02-27 07:55:05 +1100130/* Key type when certifying */
131u_int cert_key_type = SSH2_CERT_TYPE_USER;
132
133/* "key ID" of signed key */
134char *cert_key_id = NULL;
135
136/* Comma-separated list of principal names for certifying keys */
137char *cert_principals = NULL;
138
139/* Validity period for certificates */
140u_int64_t cert_valid_from = 0;
141u_int64_t cert_valid_to = ~0ULL;
142
Damien Miller4e270b02010-04-16 15:56:21 +1000143/* Certificate options */
Damien Millerd0e4a8e2010-05-21 14:58:32 +1000144#define CERTOPT_X_FWD (1)
145#define CERTOPT_AGENT_FWD (1<<1)
146#define CERTOPT_PORT_FWD (1<<2)
147#define CERTOPT_PTY (1<<3)
148#define CERTOPT_USER_RC (1<<4)
149#define CERTOPT_DEFAULT (CERTOPT_X_FWD|CERTOPT_AGENT_FWD| \
150 CERTOPT_PORT_FWD|CERTOPT_PTY|CERTOPT_USER_RC)
151u_int32_t certflags_flags = CERTOPT_DEFAULT;
152char *certflags_command = NULL;
153char *certflags_src_addr = NULL;
Damien Miller0a80ca12010-02-27 07:55:05 +1100154
djm@openbsd.org249516e2017-04-29 04:12:25 +0000155/* Arbitrary extensions specified by user */
156struct cert_userext {
157 char *key;
158 char *val;
159 int crit;
160};
161struct cert_userext *cert_userext;
162size_t ncert_userext;
163
Damien Miller44b25042010-07-02 13:35:01 +1000164/* Conversion to/from various formats */
165int convert_to = 0;
166int convert_from = 0;
167enum {
168 FMT_RFC4716,
169 FMT_PKCS8,
170 FMT_PEM
171} convert_format = FMT_RFC4716;
Damien Millereba71ba2000-04-29 23:57:08 +1000172int print_public = 0;
Damien Miller37876e92003-05-15 10:19:46 +1000173int print_generic = 0;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100174
Damien Millera41c8b12002-01-22 23:05:08 +1100175char *key_type_name = NULL;
Damien Millereba71ba2000-04-29 23:57:08 +1000176
Damien Miller757f34e2010-08-05 13:05:31 +1000177/* Load key from this PKCS#11 provider */
178char *pkcs11provider = NULL;
Damien Miller44b25042010-07-02 13:35:01 +1000179
Damien Millerbcd00ab2013-12-07 10:41:55 +1100180/* Use new OpenSSH private key format when writing SSH2 keys instead of PEM */
181int use_new_format = 0;
182
183/* Cipher for new-format private keys */
184char *new_format_cipher = NULL;
185
186/*
187 * Number of KDF rounds to derive new format keys /
188 * number of primality trials when screening moduli.
189 */
190int rounds = 0;
191
Damien Miller431f66b1999-11-21 18:31:57 +1100192/* argv0 */
193extern char *__progname;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000194
Damien Millere5c0d522014-07-03 21:24:19 +1000195char hostname[NI_MAXHOST];
Damien Millereba71ba2000-04-29 23:57:08 +1000196
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +0000197#ifdef WITH_OPENSSL
Darren Tucker770fc012004-05-13 16:24:32 +1000198/* moduli.c */
Damien Millerb089fb52005-05-26 12:16:18 +1000199int gen_candidates(FILE *, u_int32_t, u_int32_t, BIGNUM *);
Damien Millerdfceafe2012-07-06 13:44:19 +1000200int prime_test(FILE *, FILE *, u_int32_t, u_int32_t, char *, unsigned long,
201 unsigned long);
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +0000202#endif
Darren Tucker770fc012004-05-13 16:24:32 +1000203
Ben Lindstrombba81212001-06-25 05:01:22 +0000204static void
djm@openbsd.org7efb4552015-01-18 13:22:28 +0000205type_bits_valid(int type, const char *name, u_int32_t *bitsp)
Damien Miller58f1baf2011-05-05 14:06:15 +1000206{
Damien Miller72ef7c12015-01-15 02:21:31 +1100207#ifdef WITH_OPENSSL
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +0000208 u_int maxbits, nid;
Damien Miller72ef7c12015-01-15 02:21:31 +1100209#endif
Damien Miller58f1baf2011-05-05 14:06:15 +1000210
djm@openbsd.org3038a192015-04-17 13:19:22 +0000211 if (type == KEY_UNSPEC)
212 fatal("unknown key type %s", key_type_name);
Damien Miller884b63a2011-05-05 14:14:52 +1000213 if (*bitsp == 0) {
Damien Miller773dda22015-01-30 23:10:17 +1100214#ifdef WITH_OPENSSL
Damien Miller58f1baf2011-05-05 14:06:15 +1000215 if (type == KEY_DSA)
Damien Miller884b63a2011-05-05 14:14:52 +1000216 *bitsp = DEFAULT_BITS_DSA;
djm@openbsd.org7efb4552015-01-18 13:22:28 +0000217 else if (type == KEY_ECDSA) {
218 if (name != NULL &&
219 (nid = sshkey_ecdsa_nid_from_name(name)) > 0)
220 *bitsp = sshkey_curve_nid_to_bits(nid);
221 if (*bitsp == 0)
222 *bitsp = DEFAULT_BITS_ECDSA;
Damien Miller773dda22015-01-30 23:10:17 +1100223 } else
224#endif
Damien Miller884b63a2011-05-05 14:14:52 +1000225 *bitsp = DEFAULT_BITS;
Damien Miller58f1baf2011-05-05 14:06:15 +1000226 }
Damien Miller72ef7c12015-01-15 02:21:31 +1100227#ifdef WITH_OPENSSL
Damien Miller58f1baf2011-05-05 14:06:15 +1000228 maxbits = (type == KEY_DSA) ?
229 OPENSSL_DSA_MAX_MODULUS_BITS : OPENSSL_RSA_MAX_MODULUS_BITS;
djm@openbsd.org3038a192015-04-17 13:19:22 +0000230 if (*bitsp > maxbits)
231 fatal("key bits exceeds maximum %d", maxbits);
djm@openbsd.orgbd636f42017-05-07 23:15:59 +0000232 switch (type) {
233 case KEY_DSA:
234 if (*bitsp != 1024)
235 fatal("Invalid DSA key length: must be 1024 bits");
236 break;
237 case KEY_RSA:
238 if (*bitsp < SSH_RSA_MINIMUM_MODULUS_SIZE)
239 fatal("Invalid RSA key length: minimum is %d bits",
240 SSH_RSA_MINIMUM_MODULUS_SIZE);
241 break;
242 case KEY_ECDSA:
243 if (sshkey_ecdsa_bits_to_nid(*bitsp) == -1)
244 fatal("Invalid ECDSA key length: valid lengths are "
245 "256, 384 or 521 bits");
246 }
Damien Miller1f0311c2014-05-15 14:24:09 +1000247#endif
Damien Miller58f1baf2011-05-05 14:06:15 +1000248}
249
250static void
Damien Miller431f66b1999-11-21 18:31:57 +1100251ask_filename(struct passwd *pw, const char *prompt)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000252{
Damien Miller95def091999-11-25 00:26:21 +1100253 char buf[1024];
Damien Millere39cacc2000-11-29 12:18:44 +1100254 char *name = NULL;
255
Damien Miller993dd552002-02-19 15:22:47 +1100256 if (key_type_name == NULL)
Ben Lindstrom226cfa02001-01-22 05:34:40 +0000257 name = _PATH_SSH_CLIENT_ID_RSA;
Damien Miller90967402006-03-26 14:07:26 +1100258 else {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000259 switch (sshkey_type_from_name(key_type_name)) {
Damien Miller4e270b02010-04-16 15:56:21 +1000260 case KEY_DSA_CERT:
Damien Miller993dd552002-02-19 15:22:47 +1100261 case KEY_DSA:
262 name = _PATH_SSH_CLIENT_ID_DSA;
263 break;
Damien Millerdd190dd2010-11-11 14:17:02 +1100264#ifdef OPENSSL_HAS_ECC
Damien Millereb8b60e2010-08-31 22:41:14 +1000265 case KEY_ECDSA_CERT:
266 case KEY_ECDSA:
267 name = _PATH_SSH_CLIENT_ID_ECDSA;
268 break;
Damien Millerdd190dd2010-11-11 14:17:02 +1100269#endif
Damien Miller4e270b02010-04-16 15:56:21 +1000270 case KEY_RSA_CERT:
Damien Miller993dd552002-02-19 15:22:47 +1100271 case KEY_RSA:
272 name = _PATH_SSH_CLIENT_ID_RSA;
273 break;
Damien Miller5be9d9e2013-12-07 11:24:01 +1100274 case KEY_ED25519:
275 case KEY_ED25519_CERT:
276 name = _PATH_SSH_CLIENT_ID_ED25519;
277 break;
markus@openbsd.org1b11ea72018-02-23 15:58:37 +0000278 case KEY_XMSS:
279 case KEY_XMSS_CERT:
280 name = _PATH_SSH_CLIENT_ID_XMSS;
281 break;
Damien Miller993dd552002-02-19 15:22:47 +1100282 default:
djm@openbsd.org3038a192015-04-17 13:19:22 +0000283 fatal("bad key type");
Damien Miller993dd552002-02-19 15:22:47 +1100284 }
Damien Miller90967402006-03-26 14:07:26 +1100285 }
djm@openbsd.org3038a192015-04-17 13:19:22 +0000286 snprintf(identity_file, sizeof(identity_file),
287 "%s/%s", pw->pw_dir, name);
288 printf("%s (%s): ", prompt, identity_file);
289 fflush(stdout);
Damien Miller95def091999-11-25 00:26:21 +1100290 if (fgets(buf, sizeof(buf), stdin) == NULL)
291 exit(1);
Damien Miller14b017d2007-09-17 16:09:15 +1000292 buf[strcspn(buf, "\n")] = '\0';
Damien Miller95def091999-11-25 00:26:21 +1100293 if (strcmp(buf, "") != 0)
294 strlcpy(identity_file, buf, sizeof(identity_file));
295 have_identity = 1;
Damien Miller10f6f6b1999-11-17 17:29:08 +1100296}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000297
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000298static struct sshkey *
Ben Lindstromd78ae762001-06-05 20:35:09 +0000299load_identity(char *filename)
Damien Millereba71ba2000-04-29 23:57:08 +1000300{
Ben Lindstromd0fca422001-03-26 13:44:06 +0000301 char *pass;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000302 struct sshkey *prv;
303 int r;
Ben Lindstromd0fca422001-03-26 13:44:06 +0000304
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000305 if ((r = sshkey_load_private(filename, "", &prv, NULL)) == 0)
306 return prv;
307 if (r != SSH_ERR_KEY_WRONG_PASSPHRASE)
308 fatal("Load key \"%s\": %s", filename, ssh_err(r));
309 if (identity_passphrase)
310 pass = xstrdup(identity_passphrase);
311 else
312 pass = read_passphrase("Enter passphrase: ", RP_ALLOW_STDIN);
313 r = sshkey_load_private(filename, pass, &prv, NULL);
314 explicit_bzero(pass, strlen(pass));
315 free(pass);
316 if (r != 0)
317 fatal("Load key \"%s\": %s", filename, ssh_err(r));
Ben Lindstromd0fca422001-03-26 13:44:06 +0000318 return prv;
Damien Millereba71ba2000-04-29 23:57:08 +1000319}
320
Damien Miller874d77b2000-10-14 16:23:11 +1100321#define SSH_COM_PUBLIC_BEGIN "---- BEGIN SSH2 PUBLIC KEY ----"
Ben Lindstromcb72e4f2002-06-21 00:41:51 +0000322#define SSH_COM_PUBLIC_END "---- END SSH2 PUBLIC KEY ----"
Damien Miller874d77b2000-10-14 16:23:11 +1100323#define SSH_COM_PRIVATE_BEGIN "---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----"
Kevin Stevesef4eea92001-02-05 12:42:17 +0000324#define SSH_COM_PRIVATE_KEY_MAGIC 0x3f6ff9eb
Damien Millereba71ba2000-04-29 23:57:08 +1000325
Damien Miller1f0311c2014-05-15 14:24:09 +1000326#ifdef WITH_OPENSSL
Ben Lindstrombba81212001-06-25 05:01:22 +0000327static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000328do_convert_to_ssh2(struct passwd *pw, struct sshkey *k)
Damien Millereba71ba2000-04-29 23:57:08 +1000329{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000330 size_t len;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000331 u_char *blob;
Darren Tuckerd04758d2010-01-12 19:41:57 +1100332 char comment[61];
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000333 int r;
Damien Millereba71ba2000-04-29 23:57:08 +1000334
djm@openbsd.org3038a192015-04-17 13:19:22 +0000335 if ((r = sshkey_to_blob(k, &blob, &len)) != 0)
336 fatal("key_to_blob failed: %s", ssh_err(r));
Darren Tuckerd04758d2010-01-12 19:41:57 +1100337 /* Comment + surrounds must fit into 72 chars (RFC 4716 sec 3.3) */
338 snprintf(comment, sizeof(comment),
339 "%u-bit %s, converted by %s@%s from OpenSSH",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000340 sshkey_size(k), sshkey_type(k),
Damien Millereba71ba2000-04-29 23:57:08 +1000341 pw->pw_name, hostname);
Darren Tuckerd04758d2010-01-12 19:41:57 +1100342
343 fprintf(stdout, "%s\n", SSH_COM_PUBLIC_BEGIN);
344 fprintf(stdout, "Comment: \"%s\"\n", comment);
Damien Millereba71ba2000-04-29 23:57:08 +1000345 dump_base64(stdout, blob, len);
Damien Miller874d77b2000-10-14 16:23:11 +1100346 fprintf(stdout, "%s\n", SSH_COM_PUBLIC_END);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000347 sshkey_free(k);
Darren Tuckera627d422013-06-02 07:31:17 +1000348 free(blob);
Damien Millereba71ba2000-04-29 23:57:08 +1000349 exit(0);
350}
351
Ben Lindstrombba81212001-06-25 05:01:22 +0000352static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000353do_convert_to_pkcs8(struct sshkey *k)
Damien Miller44b25042010-07-02 13:35:01 +1000354{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000355 switch (sshkey_type_plain(k->type)) {
Damien Miller44b25042010-07-02 13:35:01 +1000356 case KEY_RSA:
357 if (!PEM_write_RSA_PUBKEY(stdout, k->rsa))
358 fatal("PEM_write_RSA_PUBKEY failed");
359 break;
360 case KEY_DSA:
361 if (!PEM_write_DSA_PUBKEY(stdout, k->dsa))
362 fatal("PEM_write_DSA_PUBKEY failed");
363 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000364#ifdef OPENSSL_HAS_ECC
Damien Millereb8b60e2010-08-31 22:41:14 +1000365 case KEY_ECDSA:
366 if (!PEM_write_EC_PUBKEY(stdout, k->ecdsa))
367 fatal("PEM_write_EC_PUBKEY failed");
368 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000369#endif
Damien Miller44b25042010-07-02 13:35:01 +1000370 default:
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000371 fatal("%s: unsupported key type %s", __func__, sshkey_type(k));
Damien Miller44b25042010-07-02 13:35:01 +1000372 }
373 exit(0);
374}
375
376static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000377do_convert_to_pem(struct sshkey *k)
Damien Miller44b25042010-07-02 13:35:01 +1000378{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000379 switch (sshkey_type_plain(k->type)) {
Damien Miller44b25042010-07-02 13:35:01 +1000380 case KEY_RSA:
381 if (!PEM_write_RSAPublicKey(stdout, k->rsa))
382 fatal("PEM_write_RSAPublicKey failed");
383 break;
Damien Miller44b25042010-07-02 13:35:01 +1000384 default:
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000385 fatal("%s: unsupported key type %s", __func__, sshkey_type(k));
Damien Miller44b25042010-07-02 13:35:01 +1000386 }
387 exit(0);
388}
389
390static void
391do_convert_to(struct passwd *pw)
392{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000393 struct sshkey *k;
Damien Miller44b25042010-07-02 13:35:01 +1000394 struct stat st;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000395 int r;
Damien Miller44b25042010-07-02 13:35:01 +1000396
397 if (!have_identity)
398 ask_filename(pw, "Enter file in which the key is");
399 if (stat(identity_file, &st) < 0)
400 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000401 if ((r = sshkey_load_public(identity_file, &k, NULL)) != 0)
402 k = load_identity(identity_file);
Damien Miller44b25042010-07-02 13:35:01 +1000403 switch (convert_format) {
404 case FMT_RFC4716:
405 do_convert_to_ssh2(pw, k);
406 break;
407 case FMT_PKCS8:
408 do_convert_to_pkcs8(k);
409 break;
410 case FMT_PEM:
411 do_convert_to_pem(k);
412 break;
413 default:
414 fatal("%s: unknown key format %d", __func__, convert_format);
415 }
416 exit(0);
417}
418
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000419/*
420 * This is almost exactly the bignum1 encoding, but with 32 bit for length
421 * instead of 16.
422 */
Damien Miller44b25042010-07-02 13:35:01 +1000423static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000424buffer_get_bignum_bits(struct sshbuf *b, BIGNUM *value)
Damien Miller874d77b2000-10-14 16:23:11 +1100425{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000426 u_int bytes, bignum_bits;
427 int r;
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000428
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000429 if ((r = sshbuf_get_u32(b, &bignum_bits)) != 0)
430 fatal("%s: buffer error: %s", __func__, ssh_err(r));
431 bytes = (bignum_bits + 7) / 8;
432 if (sshbuf_len(b) < bytes)
433 fatal("%s: input buffer too small: need %d have %zu",
434 __func__, bytes, sshbuf_len(b));
435 if (BN_bin2bn(sshbuf_ptr(b), bytes, value) == NULL)
436 fatal("%s: BN_bin2bn failed", __func__);
437 if ((r = sshbuf_consume(b, bytes)) != 0)
438 fatal("%s: buffer error: %s", __func__, ssh_err(r));
Damien Miller874d77b2000-10-14 16:23:11 +1100439}
440
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000441static struct sshkey *
Ben Lindstrom90fd8142002-02-26 18:09:42 +0000442do_convert_private_ssh2_from_blob(u_char *blob, u_int blen)
Damien Miller874d77b2000-10-14 16:23:11 +1100443{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000444 struct sshbuf *b;
445 struct sshkey *key = NULL;
Damien Miller874d77b2000-10-14 16:23:11 +1100446 char *type, *cipher;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000447 u_char e1, e2, e3, *sig = NULL, data[] = "abcde12345";
448 int r, rlen, ktype;
449 u_int magic, i1, i2, i3, i4;
450 size_t slen;
Ben Lindstrome586c4c2001-06-25 05:04:58 +0000451 u_long e;
Damien Miller874d77b2000-10-14 16:23:11 +1100452
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000453 if ((b = sshbuf_from(blob, blen)) == NULL)
454 fatal("%s: sshbuf_from failed", __func__);
455 if ((r = sshbuf_get_u32(b, &magic)) != 0)
456 fatal("%s: buffer error: %s", __func__, ssh_err(r));
Damien Miller874d77b2000-10-14 16:23:11 +1100457
Damien Miller874d77b2000-10-14 16:23:11 +1100458 if (magic != SSH_COM_PRIVATE_KEY_MAGIC) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000459 error("bad magic 0x%x != 0x%x", magic,
460 SSH_COM_PRIVATE_KEY_MAGIC);
461 sshbuf_free(b);
Damien Miller874d77b2000-10-14 16:23:11 +1100462 return NULL;
463 }
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000464 if ((r = sshbuf_get_u32(b, &i1)) != 0 ||
465 (r = sshbuf_get_cstring(b, &type, NULL)) != 0 ||
466 (r = sshbuf_get_cstring(b, &cipher, NULL)) != 0 ||
467 (r = sshbuf_get_u32(b, &i2)) != 0 ||
468 (r = sshbuf_get_u32(b, &i3)) != 0 ||
469 (r = sshbuf_get_u32(b, &i4)) != 0)
470 fatal("%s: buffer error: %s", __func__, ssh_err(r));
Damien Miller80163902007-01-05 16:30:16 +1100471 debug("ignore (%d %d %d %d)", i1, i2, i3, i4);
Damien Miller874d77b2000-10-14 16:23:11 +1100472 if (strcmp(cipher, "none") != 0) {
473 error("unsupported cipher %s", cipher);
Darren Tuckera627d422013-06-02 07:31:17 +1000474 free(cipher);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000475 sshbuf_free(b);
Darren Tuckera627d422013-06-02 07:31:17 +1000476 free(type);
Damien Miller874d77b2000-10-14 16:23:11 +1100477 return NULL;
478 }
Darren Tuckera627d422013-06-02 07:31:17 +1000479 free(cipher);
Damien Miller874d77b2000-10-14 16:23:11 +1100480
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000481 if (strstr(type, "dsa")) {
482 ktype = KEY_DSA;
483 } else if (strstr(type, "rsa")) {
484 ktype = KEY_RSA;
485 } else {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000486 sshbuf_free(b);
Darren Tuckera627d422013-06-02 07:31:17 +1000487 free(type);
Damien Miller874d77b2000-10-14 16:23:11 +1100488 return NULL;
489 }
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000490 if ((key = sshkey_new_private(ktype)) == NULL)
markus@openbsd.org7da5df12017-05-30 14:16:41 +0000491 fatal("sshkey_new_private failed");
Darren Tuckera627d422013-06-02 07:31:17 +1000492 free(type);
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000493
494 switch (key->type) {
495 case KEY_DSA:
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000496 buffer_get_bignum_bits(b, key->dsa->p);
497 buffer_get_bignum_bits(b, key->dsa->g);
498 buffer_get_bignum_bits(b, key->dsa->q);
499 buffer_get_bignum_bits(b, key->dsa->pub_key);
500 buffer_get_bignum_bits(b, key->dsa->priv_key);
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000501 break;
502 case KEY_RSA:
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000503 if ((r = sshbuf_get_u8(b, &e1)) != 0 ||
504 (e1 < 30 && (r = sshbuf_get_u8(b, &e2)) != 0) ||
505 (e1 < 30 && (r = sshbuf_get_u8(b, &e3)) != 0))
506 fatal("%s: buffer error: %s", __func__, ssh_err(r));
507 e = e1;
Ben Lindstrom34f91882001-06-25 04:47:54 +0000508 debug("e %lx", e);
509 if (e < 30) {
510 e <<= 8;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000511 e += e2;
Ben Lindstrom34f91882001-06-25 04:47:54 +0000512 debug("e %lx", e);
513 e <<= 8;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000514 e += e3;
Ben Lindstrom34f91882001-06-25 04:47:54 +0000515 debug("e %lx", e);
516 }
517 if (!BN_set_word(key->rsa->e, e)) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000518 sshbuf_free(b);
519 sshkey_free(key);
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000520 return NULL;
521 }
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000522 buffer_get_bignum_bits(b, key->rsa->d);
523 buffer_get_bignum_bits(b, key->rsa->n);
524 buffer_get_bignum_bits(b, key->rsa->iqmp);
525 buffer_get_bignum_bits(b, key->rsa->q);
526 buffer_get_bignum_bits(b, key->rsa->p);
djm@openbsd.org83fa3a02017-07-01 13:50:45 +0000527 if ((r = ssh_rsa_generate_additional_parameters(key)) != 0)
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000528 fatal("generate RSA parameters failed: %s", ssh_err(r));
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000529 break;
530 }
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000531 rlen = sshbuf_len(b);
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000532 if (rlen != 0)
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000533 error("do_convert_private_ssh2_from_blob: "
534 "remaining bytes in key blob %d", rlen);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000535 sshbuf_free(b);
Ben Lindstromd09fcf52001-03-29 00:29:54 +0000536
Ben Lindstrome586c4c2001-06-25 05:04:58 +0000537 /* try the key */
markus@openbsd.org76c9fbb2015-12-04 16:41:28 +0000538 if (sshkey_sign(key, &sig, &slen, data, sizeof(data), NULL, 0) != 0 ||
djm@openbsd.org04c7e282017-12-18 02:25:15 +0000539 sshkey_verify(key, sig, slen, data, sizeof(data), NULL, 0) != 0) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000540 sshkey_free(key);
541 free(sig);
542 return NULL;
543 }
Darren Tuckera627d422013-06-02 07:31:17 +1000544 free(sig);
Damien Miller874d77b2000-10-14 16:23:11 +1100545 return key;
546}
547
Damien Miller8056a9d2006-03-15 12:05:40 +1100548static int
549get_line(FILE *fp, char *line, size_t len)
550{
551 int c;
552 size_t pos = 0;
553
554 line[0] = '\0';
555 while ((c = fgetc(fp)) != EOF) {
djm@openbsd.org3038a192015-04-17 13:19:22 +0000556 if (pos >= len - 1)
557 fatal("input line too long.");
Damien Miller90967402006-03-26 14:07:26 +1100558 switch (c) {
Damien Miller8056a9d2006-03-15 12:05:40 +1100559 case '\r':
560 c = fgetc(fp);
djm@openbsd.org3038a192015-04-17 13:19:22 +0000561 if (c != EOF && c != '\n' && ungetc(c, fp) == EOF)
562 fatal("unget: %s", strerror(errno));
Damien Miller8056a9d2006-03-15 12:05:40 +1100563 return pos;
564 case '\n':
565 return pos;
566 }
567 line[pos++] = c;
568 line[pos] = '\0';
569 }
Damien Miller6c7439f2007-01-05 16:29:55 +1100570 /* We reached EOF */
571 return -1;
Damien Miller8056a9d2006-03-15 12:05:40 +1100572}
573
Ben Lindstrombba81212001-06-25 05:01:22 +0000574static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000575do_convert_from_ssh2(struct passwd *pw, struct sshkey **k, int *private)
Damien Millereba71ba2000-04-29 23:57:08 +1000576{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000577 int r, blen, escaped = 0;
Ben Lindstrom155b9812002-04-02 20:26:26 +0000578 u_int len;
Damien Miller8056a9d2006-03-15 12:05:40 +1100579 char line[1024];
Ben Lindstrom9e0ddd42001-09-18 05:41:19 +0000580 u_char blob[8096];
Damien Millereba71ba2000-04-29 23:57:08 +1000581 char encoded[8096];
Damien Millereba71ba2000-04-29 23:57:08 +1000582 FILE *fp;
583
Damien Millerba3420a2010-06-26 09:39:07 +1000584 if ((fp = fopen(identity_file, "r")) == NULL)
585 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
Damien Millereba71ba2000-04-29 23:57:08 +1000586 encoded[0] = '\0';
Damien Miller8056a9d2006-03-15 12:05:40 +1100587 while ((blen = get_line(fp, line, sizeof(line))) != -1) {
Damien Miller746d1a62013-07-18 16:13:02 +1000588 if (blen > 0 && line[blen - 1] == '\\')
Damien Miller30c3d422000-05-09 11:02:59 +1000589 escaped++;
Damien Millereba71ba2000-04-29 23:57:08 +1000590 if (strncmp(line, "----", 4) == 0 ||
591 strstr(line, ": ") != NULL) {
Damien Miller874d77b2000-10-14 16:23:11 +1100592 if (strstr(line, SSH_COM_PRIVATE_BEGIN) != NULL)
Damien Miller44b25042010-07-02 13:35:01 +1000593 *private = 1;
Ben Lindstrome586c4c2001-06-25 05:04:58 +0000594 if (strstr(line, " END ") != NULL) {
595 break;
596 }
Ben Lindstrom30358602001-04-24 16:59:28 +0000597 /* fprintf(stderr, "ignore: %s", line); */
Damien Millereba71ba2000-04-29 23:57:08 +1000598 continue;
599 }
Damien Miller30c3d422000-05-09 11:02:59 +1000600 if (escaped) {
601 escaped--;
Ben Lindstrom30358602001-04-24 16:59:28 +0000602 /* fprintf(stderr, "escaped: %s", line); */
Damien Miller30c3d422000-05-09 11:02:59 +1000603 continue;
Damien Millereba71ba2000-04-29 23:57:08 +1000604 }
Damien Millereba71ba2000-04-29 23:57:08 +1000605 strlcat(encoded, line, sizeof(encoded));
606 }
Ben Lindstrom155b9812002-04-02 20:26:26 +0000607 len = strlen(encoded);
608 if (((len % 4) == 3) &&
609 (encoded[len-1] == '=') &&
610 (encoded[len-2] == '=') &&
611 (encoded[len-3] == '='))
612 encoded[len-3] = '\0';
Damien Miller4a8ed542002-01-22 23:33:31 +1100613 blen = uudecode(encoded, blob, sizeof(blob));
djm@openbsd.org3038a192015-04-17 13:19:22 +0000614 if (blen < 0)
615 fatal("uudecode failed.");
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000616 if (*private)
617 *k = do_convert_private_ssh2_from_blob(blob, blen);
djm@openbsd.org3038a192015-04-17 13:19:22 +0000618 else if ((r = sshkey_from_blob(blob, blen, k)) != 0)
619 fatal("decode blob failed: %s", ssh_err(r));
Damien Miller44b25042010-07-02 13:35:01 +1000620 fclose(fp);
621}
622
623static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000624do_convert_from_pkcs8(struct sshkey **k, int *private)
Damien Miller44b25042010-07-02 13:35:01 +1000625{
626 EVP_PKEY *pubkey;
627 FILE *fp;
628
629 if ((fp = fopen(identity_file, "r")) == NULL)
630 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
631 if ((pubkey = PEM_read_PUBKEY(fp, NULL, NULL, NULL)) == NULL) {
632 fatal("%s: %s is not a recognised public key format", __func__,
633 identity_file);
634 }
635 fclose(fp);
636 switch (EVP_PKEY_type(pubkey->type)) {
637 case EVP_PKEY_RSA:
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000638 if ((*k = sshkey_new(KEY_UNSPEC)) == NULL)
639 fatal("sshkey_new failed");
Damien Miller44b25042010-07-02 13:35:01 +1000640 (*k)->type = KEY_RSA;
641 (*k)->rsa = EVP_PKEY_get1_RSA(pubkey);
642 break;
643 case EVP_PKEY_DSA:
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000644 if ((*k = sshkey_new(KEY_UNSPEC)) == NULL)
645 fatal("sshkey_new failed");
Damien Miller44b25042010-07-02 13:35:01 +1000646 (*k)->type = KEY_DSA;
647 (*k)->dsa = EVP_PKEY_get1_DSA(pubkey);
648 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000649#ifdef OPENSSL_HAS_ECC
Damien Millereb8b60e2010-08-31 22:41:14 +1000650 case EVP_PKEY_EC:
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000651 if ((*k = sshkey_new(KEY_UNSPEC)) == NULL)
652 fatal("sshkey_new failed");
Damien Millereb8b60e2010-08-31 22:41:14 +1000653 (*k)->type = KEY_ECDSA;
654 (*k)->ecdsa = EVP_PKEY_get1_EC_KEY(pubkey);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000655 (*k)->ecdsa_nid = sshkey_ecdsa_key_to_nid((*k)->ecdsa);
Damien Millereb8b60e2010-08-31 22:41:14 +1000656 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000657#endif
Damien Miller44b25042010-07-02 13:35:01 +1000658 default:
659 fatal("%s: unsupported pubkey type %d", __func__,
660 EVP_PKEY_type(pubkey->type));
661 }
662 EVP_PKEY_free(pubkey);
663 return;
664}
665
666static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000667do_convert_from_pem(struct sshkey **k, int *private)
Damien Miller44b25042010-07-02 13:35:01 +1000668{
669 FILE *fp;
670 RSA *rsa;
Damien Miller44b25042010-07-02 13:35:01 +1000671
672 if ((fp = fopen(identity_file, "r")) == NULL)
673 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
674 if ((rsa = PEM_read_RSAPublicKey(fp, NULL, NULL, NULL)) != NULL) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000675 if ((*k = sshkey_new(KEY_UNSPEC)) == NULL)
676 fatal("sshkey_new failed");
Damien Miller44b25042010-07-02 13:35:01 +1000677 (*k)->type = KEY_RSA;
678 (*k)->rsa = rsa;
679 fclose(fp);
680 return;
681 }
Damien Miller44b25042010-07-02 13:35:01 +1000682 fatal("%s: unrecognised raw private key format", __func__);
683}
684
685static void
686do_convert_from(struct passwd *pw)
687{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000688 struct sshkey *k = NULL;
689 int r, private = 0, ok = 0;
Damien Miller44b25042010-07-02 13:35:01 +1000690 struct stat st;
691
692 if (!have_identity)
693 ask_filename(pw, "Enter file in which the key is");
694 if (stat(identity_file, &st) < 0)
695 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
696
697 switch (convert_format) {
698 case FMT_RFC4716:
699 do_convert_from_ssh2(pw, &k, &private);
700 break;
701 case FMT_PKCS8:
702 do_convert_from_pkcs8(&k, &private);
703 break;
704 case FMT_PEM:
705 do_convert_from_pem(&k, &private);
706 break;
707 default:
708 fatal("%s: unknown key format %d", __func__, convert_format);
709 }
710
djm@openbsd.org7a2c3682015-01-30 00:59:19 +0000711 if (!private) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000712 if ((r = sshkey_write(k, stdout)) == 0)
713 ok = 1;
Damien Miller44b25042010-07-02 13:35:01 +1000714 if (ok)
715 fprintf(stdout, "\n");
djm@openbsd.org7a2c3682015-01-30 00:59:19 +0000716 } else {
Damien Miller44b25042010-07-02 13:35:01 +1000717 switch (k->type) {
718 case KEY_DSA:
719 ok = PEM_write_DSAPrivateKey(stdout, k->dsa, NULL,
720 NULL, 0, NULL, NULL);
721 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000722#ifdef OPENSSL_HAS_ECC
Damien Millereb8b60e2010-08-31 22:41:14 +1000723 case KEY_ECDSA:
724 ok = PEM_write_ECPrivateKey(stdout, k->ecdsa, NULL,
725 NULL, 0, NULL, NULL);
726 break;
Damien Miller6af914a2010-09-10 11:39:26 +1000727#endif
Damien Miller44b25042010-07-02 13:35:01 +1000728 case KEY_RSA:
729 ok = PEM_write_RSAPrivateKey(stdout, k->rsa, NULL,
730 NULL, 0, NULL, NULL);
731 break;
732 default:
733 fatal("%s: unsupported key type %s", __func__,
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000734 sshkey_type(k));
Damien Miller44b25042010-07-02 13:35:01 +1000735 }
736 }
737
djm@openbsd.org3038a192015-04-17 13:19:22 +0000738 if (!ok)
739 fatal("key write failed");
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000740 sshkey_free(k);
Damien Millereba71ba2000-04-29 23:57:08 +1000741 exit(0);
742}
Damien Miller1f0311c2014-05-15 14:24:09 +1000743#endif
Damien Millereba71ba2000-04-29 23:57:08 +1000744
Ben Lindstrombba81212001-06-25 05:01:22 +0000745static void
Damien Millereba71ba2000-04-29 23:57:08 +1000746do_print_public(struct passwd *pw)
747{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000748 struct sshkey *prv;
Damien Millereba71ba2000-04-29 23:57:08 +1000749 struct stat st;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000750 int r;
Damien Millereba71ba2000-04-29 23:57:08 +1000751
752 if (!have_identity)
753 ask_filename(pw, "Enter file in which the key is");
djm@openbsd.org3038a192015-04-17 13:19:22 +0000754 if (stat(identity_file, &st) < 0)
755 fatal("%s: %s", identity_file, strerror(errno));
Ben Lindstromd78ae762001-06-05 20:35:09 +0000756 prv = load_identity(identity_file);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000757 if ((r = sshkey_write(prv, stdout)) != 0)
markus@openbsd.org7da5df12017-05-30 14:16:41 +0000758 error("sshkey_write failed: %s", ssh_err(r));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000759 sshkey_free(prv);
Damien Millereba71ba2000-04-29 23:57:08 +1000760 fprintf(stdout, "\n");
761 exit(0);
762}
763
Ben Lindstromcd392282001-07-04 03:44:03 +0000764static void
Damien Miller757f34e2010-08-05 13:05:31 +1000765do_download(struct passwd *pw)
Ben Lindstromcd392282001-07-04 03:44:03 +0000766{
Damien Miller7ea845e2010-02-12 09:21:02 +1100767#ifdef ENABLE_PKCS11
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000768 struct sshkey **keys = NULL;
Damien Miller7ea845e2010-02-12 09:21:02 +1100769 int i, nkeys;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000770 enum sshkey_fp_rep rep;
djm@openbsd.org56d1c832014-12-21 22:27:55 +0000771 int fptype;
Damien Millerec77c952013-01-09 15:58:00 +1100772 char *fp, *ra;
Ben Lindstrom8282d6a2001-08-06 21:44:05 +0000773
djm@openbsd.org56d1c832014-12-21 22:27:55 +0000774 fptype = print_bubblebabble ? SSH_DIGEST_SHA1 : fingerprint_hash;
775 rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_DEFAULT;
Damien Miller1422c082013-01-09 16:44:54 +1100776
Damien Miller7ea845e2010-02-12 09:21:02 +1100777 pkcs11_init(0);
778 nkeys = pkcs11_add_provider(pkcs11provider, NULL, &keys);
779 if (nkeys <= 0)
780 fatal("cannot read public key from pkcs11");
781 for (i = 0; i < nkeys; i++) {
Damien Millerec77c952013-01-09 15:58:00 +1100782 if (print_fingerprint) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000783 fp = sshkey_fingerprint(keys[i], fptype, rep);
784 ra = sshkey_fingerprint(keys[i], fingerprint_hash,
Damien Millerec77c952013-01-09 15:58:00 +1100785 SSH_FP_RANDOMART);
djm@openbsd.org9ce86c92015-01-28 22:36:00 +0000786 if (fp == NULL || ra == NULL)
787 fatal("%s: sshkey_fingerprint fail", __func__);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000788 printf("%u %s %s (PKCS11 key)\n", sshkey_size(keys[i]),
789 fp, sshkey_type(keys[i]));
Damien Millerec77c952013-01-09 15:58:00 +1100790 if (log_level >= SYSLOG_LEVEL_VERBOSE)
791 printf("%s\n", ra);
Darren Tuckera627d422013-06-02 07:31:17 +1000792 free(ra);
793 free(fp);
Damien Millerec77c952013-01-09 15:58:00 +1100794 } else {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000795 (void) sshkey_write(keys[i], stdout); /* XXX check */
Damien Millerec77c952013-01-09 15:58:00 +1100796 fprintf(stdout, "\n");
797 }
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000798 sshkey_free(keys[i]);
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000799 }
Darren Tuckera627d422013-06-02 07:31:17 +1000800 free(keys);
Damien Miller7ea845e2010-02-12 09:21:02 +1100801 pkcs11_terminate();
Ben Lindstrom8282d6a2001-08-06 21:44:05 +0000802 exit(0);
Damien Miller7ea845e2010-02-12 09:21:02 +1100803#else
804 fatal("no pkcs11 support");
805#endif /* ENABLE_PKCS11 */
Ben Lindstrom8282d6a2001-08-06 21:44:05 +0000806}
Ben Lindstromcd392282001-07-04 03:44:03 +0000807
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000808static struct sshkey *
809try_read_key(char **cpp)
810{
811 struct sshkey *ret;
812 int r;
813
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000814 if ((ret = sshkey_new(KEY_UNSPEC)) == NULL)
815 fatal("sshkey_new failed");
816 if ((r = sshkey_read(ret, cpp)) == 0)
817 return ret;
818 /* Not a key */
819 sshkey_free(ret);
820 return NULL;
821}
822
823static void
824fingerprint_one_key(const struct sshkey *public, const char *comment)
825{
826 char *fp = NULL, *ra = NULL;
827 enum sshkey_fp_rep rep;
828 int fptype;
829
830 fptype = print_bubblebabble ? SSH_DIGEST_SHA1 : fingerprint_hash;
831 rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_DEFAULT;
832 fp = sshkey_fingerprint(public, fptype, rep);
833 ra = sshkey_fingerprint(public, fingerprint_hash, SSH_FP_RANDOMART);
834 if (fp == NULL || ra == NULL)
835 fatal("%s: sshkey_fingerprint failed", __func__);
djm@openbsd.orga287c5a2017-02-10 03:36:40 +0000836 mprintf("%u %s %s (%s)\n", sshkey_size(public), fp,
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000837 comment ? comment : "no comment", sshkey_type(public));
838 if (log_level >= SYSLOG_LEVEL_VERBOSE)
839 printf("%s\n", ra);
840 free(ra);
841 free(fp);
842}
843
844static void
845fingerprint_private(const char *path)
846{
847 struct stat st;
848 char *comment = NULL;
849 struct sshkey *public = NULL;
850 int r;
851
852 if (stat(identity_file, &st) < 0)
853 fatal("%s: %s", path, strerror(errno));
djm@openbsd.orgbcb7bc72015-11-18 08:37:28 +0000854 if ((r = sshkey_load_public(path, &public, &comment)) != 0) {
855 debug("load public \"%s\": %s", path, ssh_err(r));
856 if ((r = sshkey_load_private(path, NULL,
857 &public, &comment)) != 0) {
858 debug("load private \"%s\": %s", path, ssh_err(r));
859 fatal("%s is not a key file.", path);
860 }
861 }
862
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000863 fingerprint_one_key(public, comment);
864 sshkey_free(public);
865 free(comment);
866}
867
Ben Lindstrombba81212001-06-25 05:01:22 +0000868static void
Damien Miller10f6f6b1999-11-17 17:29:08 +1100869do_fingerprint(struct passwd *pw)
870{
Damien Miller98c7ad62000-03-09 21:27:49 +1100871 FILE *f;
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000872 struct sshkey *public = NULL;
djm@openbsd.orgcce6a362015-12-11 03:19:09 +0000873 char *comment = NULL, *cp, *ep, line[SSH_MAX_PUBKEY_BYTES];
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000874 int i, invalid = 1;
875 const char *path;
djm@openbsd.org1a31d022016-05-02 08:49:03 +0000876 u_long lnum = 0;
Damien Miller10f6f6b1999-11-17 17:29:08 +1100877
Damien Miller95def091999-11-25 00:26:21 +1100878 if (!have_identity)
879 ask_filename(pw, "Enter file in which the key is");
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000880 path = identity_file;
Damien Miller98c7ad62000-03-09 21:27:49 +1100881
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000882 if (strcmp(identity_file, "-") == 0) {
883 f = stdin;
884 path = "(stdin)";
885 } else if ((f = fopen(path, "r")) == NULL)
886 fatal("%s: %s: %s", __progname, path, strerror(errno));
Damien Miller98c7ad62000-03-09 21:27:49 +1100887
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000888 while (read_keyfile_line(f, path, line, sizeof(line), &lnum) == 0) {
889 cp = line;
890 cp[strcspn(cp, "\n")] = '\0';
891 /* Trim leading space and comments */
892 cp = line + strspn(line, " \t");
893 if (*cp == '#' || *cp == '\0')
894 continue;
895
896 /*
897 * Input may be plain keys, private keys, authorized_keys
898 * or known_hosts.
899 */
900
901 /*
902 * Try private keys first. Assume a key is private if
903 * "SSH PRIVATE KEY" appears on the first line and we're
904 * not reading from stdin (XXX support private keys on stdin).
905 */
906 if (lnum == 1 && strcmp(identity_file, "-") != 0 &&
djm@openbsd.orgbcb7bc72015-11-18 08:37:28 +0000907 strstr(cp, "PRIVATE KEY") != NULL) {
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000908 fclose(f);
909 fingerprint_private(path);
910 exit(0);
911 }
912
913 /*
914 * If it's not a private key, then this must be prepared to
915 * accept a public key prefixed with a hostname or options.
916 * Try a bare key first, otherwise skip the leading stuff.
917 */
918 if ((public = try_read_key(&cp)) == NULL) {
919 i = strtol(cp, &ep, 10);
920 if (i == 0 || ep == NULL ||
921 (*ep != ' ' && *ep != '\t')) {
922 int quoted = 0;
923
924 comment = cp;
925 for (; *cp && (quoted || (*cp != ' ' &&
926 *cp != '\t')); cp++) {
927 if (*cp == '\\' && cp[1] == '"')
928 cp++; /* Skip both */
929 else if (*cp == '"')
930 quoted = !quoted;
931 }
932 if (!*cp)
933 continue;
934 *cp++ = '\0';
935 }
936 }
937 /* Retry after parsing leading hostname/key options */
938 if (public == NULL && (public = try_read_key(&cp)) == NULL) {
djm@openbsd.org1a31d022016-05-02 08:49:03 +0000939 debug("%s:%lu: not a public key", path, lnum);
Damien Millerba3420a2010-06-26 09:39:07 +1000940 continue;
Damien Miller95def091999-11-25 00:26:21 +1100941 }
Damien Millerba3420a2010-06-26 09:39:07 +1000942
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000943 /* Find trailing comment, if any */
944 for (; *cp == ' ' || *cp == '\t'; cp++)
Damien Millerba3420a2010-06-26 09:39:07 +1000945 ;
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000946 if (*cp != '\0' && *cp != '#')
Damien Millerba3420a2010-06-26 09:39:07 +1000947 comment = cp;
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000948
949 fingerprint_one_key(public, comment);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000950 sshkey_free(public);
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000951 invalid = 0; /* One good key in the file is sufficient */
Damien Miller95def091999-11-25 00:26:21 +1100952 }
Damien Millerba3420a2010-06-26 09:39:07 +1000953 fclose(f);
954
djm@openbsd.org3038a192015-04-17 13:19:22 +0000955 if (invalid)
djm@openbsd.orgc56a2552015-11-16 22:53:07 +0000956 fatal("%s is not a public key file.", path);
Damien Miller95def091999-11-25 00:26:21 +1100957 exit(0);
Damien Miller10f6f6b1999-11-17 17:29:08 +1100958}
959
Damien Miller4b42d7f2005-03-01 21:48:35 +1100960static void
Damien Miller58f1baf2011-05-05 14:06:15 +1000961do_gen_all_hostkeys(struct passwd *pw)
962{
963 struct {
964 char *key_type;
965 char *key_type_display;
966 char *path;
967 } key_types[] = {
djm@openbsd.org5c27e3b2015-03-23 06:06:38 +0000968#ifdef WITH_OPENSSL
Damien Miller58f1baf2011-05-05 14:06:15 +1000969 { "rsa", "RSA" ,_PATH_HOST_RSA_KEY_FILE },
970 { "dsa", "DSA", _PATH_HOST_DSA_KEY_FILE },
Damien Millerb56e4932012-02-06 07:41:27 +1100971#ifdef OPENSSL_HAS_ECC
Damien Miller58f1baf2011-05-05 14:06:15 +1000972 { "ecdsa", "ECDSA",_PATH_HOST_ECDSA_KEY_FILE },
djm@openbsd.org5c27e3b2015-03-23 06:06:38 +0000973#endif /* OPENSSL_HAS_ECC */
974#endif /* WITH_OPENSSL */
Damien Miller5be9d9e2013-12-07 11:24:01 +1100975 { "ed25519", "ED25519",_PATH_HOST_ED25519_KEY_FILE },
markus@openbsd.org1b11ea72018-02-23 15:58:37 +0000976#ifdef WITH_XMSS
977 { "xmss", "XMSS",_PATH_HOST_XMSS_KEY_FILE },
978#endif /* WITH_XMSS */
Damien Miller58f1baf2011-05-05 14:06:15 +1000979 { NULL, NULL, NULL }
980 };
981
982 int first = 0;
983 struct stat st;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000984 struct sshkey *private, *public;
djm@openbsd.org853edbe2017-07-07 03:53:12 +0000985 char comment[1024], *prv_tmp, *pub_tmp, *prv_file, *pub_file;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +0000986 int i, type, fd, r;
Damien Miller58f1baf2011-05-05 14:06:15 +1000987 FILE *f;
988
989 for (i = 0; key_types[i].key_type; i++) {
djm@openbsd.org853edbe2017-07-07 03:53:12 +0000990 public = private = NULL;
991 prv_tmp = pub_tmp = prv_file = pub_file = NULL;
992
993 xasprintf(&prv_file, "%s%s",
994 identity_file, key_types[i].path);
995
996 /* Check whether private key exists and is not zero-length */
997 if (stat(prv_file, &st) == 0) {
998 if (st.st_size != 0)
999 goto next;
1000 } else if (errno != ENOENT) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00001001 error("Could not stat %s: %s", key_types[i].path,
Damien Miller58f1baf2011-05-05 14:06:15 +10001002 strerror(errno));
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001003 goto failnext;
Damien Miller58f1baf2011-05-05 14:06:15 +10001004 }
1005
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001006 /*
1007 * Private key doesn't exist or is invalid; proceed with
1008 * key generation.
1009 */
1010 xasprintf(&prv_tmp, "%s%s.XXXXXXXXXX",
1011 identity_file, key_types[i].path);
1012 xasprintf(&pub_tmp, "%s%s.pub.XXXXXXXXXX",
1013 identity_file, key_types[i].path);
1014 xasprintf(&pub_file, "%s%s.pub",
1015 identity_file, key_types[i].path);
1016
Damien Miller58f1baf2011-05-05 14:06:15 +10001017 if (first == 0) {
1018 first = 1;
1019 printf("%s: generating new host keys: ", __progname);
1020 }
1021 printf("%s ", key_types[i].key_type_display);
1022 fflush(stdout);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001023 type = sshkey_type_from_name(key_types[i].key_type);
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001024 if ((fd = mkstemp(prv_tmp)) == -1) {
1025 error("Could not save your public key in %s: %s",
1026 prv_tmp, strerror(errno));
1027 goto failnext;
1028 }
1029 close(fd); /* just using mkstemp() to generate/reserve a name */
Damien Miller58f1baf2011-05-05 14:06:15 +10001030 bits = 0;
djm@openbsd.org7efb4552015-01-18 13:22:28 +00001031 type_bits_valid(type, NULL, &bits);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001032 if ((r = sshkey_generate(type, bits, &private)) != 0) {
markus@openbsd.org7da5df12017-05-30 14:16:41 +00001033 error("sshkey_generate failed: %s", ssh_err(r));
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001034 goto failnext;
Damien Miller58f1baf2011-05-05 14:06:15 +10001035 }
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001036 if ((r = sshkey_from_private(private, &public)) != 0)
1037 fatal("sshkey_from_private failed: %s", ssh_err(r));
Damien Miller58f1baf2011-05-05 14:06:15 +10001038 snprintf(comment, sizeof comment, "%s@%s", pw->pw_name,
1039 hostname);
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001040 if ((r = sshkey_save_private(private, prv_tmp, "",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001041 comment, use_new_format, new_format_cipher, rounds)) != 0) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00001042 error("Saving key \"%s\" failed: %s",
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001043 prv_tmp, ssh_err(r));
1044 goto failnext;
Damien Miller58f1baf2011-05-05 14:06:15 +10001045 }
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001046 if ((fd = mkstemp(pub_tmp)) == -1) {
1047 error("Could not save your public key in %s: %s",
1048 pub_tmp, strerror(errno));
1049 goto failnext;
Damien Miller58f1baf2011-05-05 14:06:15 +10001050 }
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001051 (void)fchmod(fd, 0644);
Damien Miller58f1baf2011-05-05 14:06:15 +10001052 f = fdopen(fd, "w");
1053 if (f == NULL) {
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001054 error("fdopen %s failed: %s", pub_tmp, strerror(errno));
doug@openbsd.org7df88182014-08-21 01:08:52 +00001055 close(fd);
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001056 goto failnext;
Damien Miller58f1baf2011-05-05 14:06:15 +10001057 }
djm@openbsd.orgbb8b4422015-01-16 15:55:07 +00001058 if ((r = sshkey_write(public, f)) != 0) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00001059 error("write key failed: %s", ssh_err(r));
doug@openbsd.org7df88182014-08-21 01:08:52 +00001060 fclose(f);
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001061 goto failnext;
Damien Miller58f1baf2011-05-05 14:06:15 +10001062 }
1063 fprintf(f, " %s\n", comment);
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001064 if (ferror(f) != 0) {
1065 error("write key failed: %s", strerror(errno));
1066 fclose(f);
1067 goto failnext;
1068 }
1069 if (fclose(f) != 0) {
1070 error("key close failed: %s", strerror(errno));
1071 goto failnext;
1072 }
Damien Miller58f1baf2011-05-05 14:06:15 +10001073
djm@openbsd.org853edbe2017-07-07 03:53:12 +00001074 /* Rename temporary files to their permanent locations. */
1075 if (rename(pub_tmp, pub_file) != 0) {
1076 error("Unable to move %s into position: %s",
1077 pub_file, strerror(errno));
1078 goto failnext;
1079 }
1080 if (rename(prv_tmp, prv_file) != 0) {
1081 error("Unable to move %s into position: %s",
1082 key_types[i].path, strerror(errno));
1083 failnext:
1084 first = 0;
1085 goto next;
1086 }
1087 next:
1088 sshkey_free(private);
1089 sshkey_free(public);
1090 free(prv_tmp);
1091 free(pub_tmp);
1092 free(prv_file);
1093 free(pub_file);
Damien Miller58f1baf2011-05-05 14:06:15 +10001094 }
1095 if (first != 0)
1096 printf("\n");
1097}
1098
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001099struct known_hosts_ctx {
djm@openbsd.org2b3c3c72015-01-18 21:51:19 +00001100 const char *host; /* Hostname searched for in find/delete case */
1101 FILE *out; /* Output file, stdout for find_hosts case */
1102 int has_unhashed; /* When hashing, original had unhashed hosts */
1103 int found_key; /* For find/delete, host was found */
1104 int invalid; /* File contained invalid items; don't delete */
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001105};
1106
1107static int
1108known_hosts_hash(struct hostkey_foreach_line *l, void *_ctx)
Damien Miller4b42d7f2005-03-01 21:48:35 +11001109{
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001110 struct known_hosts_ctx *ctx = (struct known_hosts_ctx *)_ctx;
1111 char *hashed, *cp, *hosts, *ohosts;
1112 int has_wild = l->hosts && strcspn(l->hosts, "*?!") != strlen(l->hosts);
dtucker@openbsd.org18501152017-03-06 02:03:20 +00001113 int was_hashed = l->hosts && l->hosts[0] == HASH_DELIM;
Darren Tucker0f7e9102008-06-08 12:54:29 +10001114
djm@openbsd.org6c5c9492015-02-16 22:08:57 +00001115 switch (l->status) {
1116 case HKF_STATUS_OK:
1117 case HKF_STATUS_MATCHED:
1118 /*
1119 * Don't hash hosts already already hashed, with wildcard
1120 * characters or a CA/revocation marker.
1121 */
djm@openbsd.org12d37672017-03-03 06:13:11 +00001122 if (was_hashed || has_wild || l->marker != MRK_NONE) {
djm@openbsd.org6c5c9492015-02-16 22:08:57 +00001123 fprintf(ctx->out, "%s\n", l->line);
1124 if (has_wild && !find_host) {
dtucker@openbsd.orgd0723702017-03-06 00:44:51 +00001125 logit("%s:%lu: ignoring host name "
djm@openbsd.org3038a192015-04-17 13:19:22 +00001126 "with wildcard: %.64s", l->path,
djm@openbsd.org6c5c9492015-02-16 22:08:57 +00001127 l->linenum, l->hosts);
1128 }
1129 return 0;
1130 }
1131 /*
1132 * Split any comma-separated hostnames from the host list,
1133 * hash and store separately.
1134 */
1135 ohosts = hosts = xstrdup(l->hosts);
1136 while ((cp = strsep(&hosts, ",")) != NULL && *cp != '\0') {
djm@openbsd.orgdb259722017-03-10 04:26:06 +00001137 lowercase(cp);
djm@openbsd.org6c5c9492015-02-16 22:08:57 +00001138 if ((hashed = host_hash(cp, NULL, 0)) == NULL)
1139 fatal("hash_host failed");
1140 fprintf(ctx->out, "%s %s\n", hashed, l->rawkey);
1141 ctx->has_unhashed = 1;
1142 }
1143 free(ohosts);
1144 return 0;
1145 case HKF_STATUS_INVALID:
1146 /* Retain invalid lines, but mark file as invalid. */
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001147 ctx->invalid = 1;
dtucker@openbsd.orgd0723702017-03-06 00:44:51 +00001148 logit("%s:%lu: invalid line", l->path, l->linenum);
djm@openbsd.org6c5c9492015-02-16 22:08:57 +00001149 /* FALLTHROUGH */
1150 default:
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001151 fprintf(ctx->out, "%s\n", l->line);
1152 return 0;
Darren Tucker0f7e9102008-06-08 12:54:29 +10001153 }
djm@openbsd.org6c5c9492015-02-16 22:08:57 +00001154 /* NOTREACHED */
1155 return -1;
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001156}
1157
1158static int
1159known_hosts_find_delete(struct hostkey_foreach_line *l, void *_ctx)
1160{
1161 struct known_hosts_ctx *ctx = (struct known_hosts_ctx *)_ctx;
djm@openbsd.org4739e8d2015-05-21 12:01:19 +00001162 enum sshkey_fp_rep rep;
1163 int fptype;
1164 char *fp;
1165
1166 fptype = print_bubblebabble ? SSH_DIGEST_SHA1 : fingerprint_hash;
1167 rep = print_bubblebabble ? SSH_FP_BUBBLEBABBLE : SSH_FP_DEFAULT;
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001168
djm@openbsd.org6c5c9492015-02-16 22:08:57 +00001169 if (l->status == HKF_STATUS_MATCHED) {
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001170 if (delete_host) {
1171 if (l->marker != MRK_NONE) {
1172 /* Don't remove CA and revocation lines */
1173 fprintf(ctx->out, "%s\n", l->line);
1174 } else {
1175 /*
1176 * Hostname matches and has no CA/revoke
1177 * marker, delete it by *not* writing the
1178 * line to ctx->out.
1179 */
1180 ctx->found_key = 1;
1181 if (!quiet)
dtucker@openbsd.orgd0723702017-03-06 00:44:51 +00001182 printf("# Host %s found: line %lu\n",
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001183 ctx->host, l->linenum);
1184 }
1185 return 0;
1186 } else if (find_host) {
1187 ctx->found_key = 1;
1188 if (!quiet) {
dtucker@openbsd.orgd0723702017-03-06 00:44:51 +00001189 printf("# Host %s found: line %lu %s\n",
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001190 ctx->host,
1191 l->linenum, l->marker == MRK_CA ? "CA" :
1192 (l->marker == MRK_REVOKE ? "REVOKED" : ""));
1193 }
1194 if (hash_hosts)
1195 known_hosts_hash(l, ctx);
djm@openbsd.org4739e8d2015-05-21 12:01:19 +00001196 else if (print_fingerprint) {
1197 fp = sshkey_fingerprint(l->key, fptype, rep);
djm@openbsd.orga287c5a2017-02-10 03:36:40 +00001198 mprintf("%s %s %s %s\n", ctx->host,
djm@openbsd.org4739e8d2015-05-21 12:01:19 +00001199 sshkey_type(l->key), fp, l->comment);
1200 free(fp);
1201 } else
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001202 fprintf(ctx->out, "%s\n", l->line);
1203 return 0;
1204 }
1205 } else if (delete_host) {
1206 /* Retain non-matching hosts when deleting */
1207 if (l->status == HKF_STATUS_INVALID) {
1208 ctx->invalid = 1;
dtucker@openbsd.orgd0723702017-03-06 00:44:51 +00001209 logit("%s:%lu: invalid line", l->path, l->linenum);
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001210 }
1211 fprintf(ctx->out, "%s\n", l->line);
1212 }
1213 return 0;
Damien Miller4b42d7f2005-03-01 21:48:35 +11001214}
1215
1216static void
1217do_known_hosts(struct passwd *pw, const char *name)
1218{
deraadt@openbsd.orgd2099de2015-01-19 00:32:54 +00001219 char *cp, tmp[PATH_MAX], old[PATH_MAX];
djm@openbsd.org2b3c3c72015-01-18 21:51:19 +00001220 int r, fd, oerrno, inplace = 0;
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001221 struct known_hosts_ctx ctx;
djm@openbsd.org4739e8d2015-05-21 12:01:19 +00001222 u_int foreach_options;
Damien Miller4b42d7f2005-03-01 21:48:35 +11001223
1224 if (!have_identity) {
1225 cp = tilde_expand_filename(_PATH_SSH_USER_HOSTFILE, pw->pw_uid);
1226 if (strlcpy(identity_file, cp, sizeof(identity_file)) >=
1227 sizeof(identity_file))
1228 fatal("Specified known hosts path too long");
Darren Tuckera627d422013-06-02 07:31:17 +10001229 free(cp);
Damien Miller4b42d7f2005-03-01 21:48:35 +11001230 have_identity = 1;
1231 }
Damien Miller4b42d7f2005-03-01 21:48:35 +11001232
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001233 memset(&ctx, 0, sizeof(ctx));
1234 ctx.out = stdout;
1235 ctx.host = name;
1236
Damien Miller4b42d7f2005-03-01 21:48:35 +11001237 /*
1238 * Find hosts goes to stdout, hash and deletions happen in-place
1239 * A corner case is ssh-keygen -HF foo, which should go to stdout
1240 */
1241 if (!find_host && (hash_hosts || delete_host)) {
1242 if (strlcpy(tmp, identity_file, sizeof(tmp)) >= sizeof(tmp) ||
1243 strlcat(tmp, ".XXXXXXXXXX", sizeof(tmp)) >= sizeof(tmp) ||
1244 strlcpy(old, identity_file, sizeof(old)) >= sizeof(old) ||
1245 strlcat(old, ".old", sizeof(old)) >= sizeof(old))
1246 fatal("known_hosts path too long");
1247 umask(077);
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001248 if ((fd = mkstemp(tmp)) == -1)
Damien Miller4b42d7f2005-03-01 21:48:35 +11001249 fatal("mkstemp: %s", strerror(errno));
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001250 if ((ctx.out = fdopen(fd, "w")) == NULL) {
1251 oerrno = errno;
Damien Miller4b42d7f2005-03-01 21:48:35 +11001252 unlink(tmp);
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001253 fatal("fdopen: %s", strerror(oerrno));
Damien Miller4b42d7f2005-03-01 21:48:35 +11001254 }
djm@openbsd.org2b3c3c72015-01-18 21:51:19 +00001255 inplace = 1;
Damien Miller4b42d7f2005-03-01 21:48:35 +11001256 }
1257
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001258 /* XXX support identity_file == "-" for stdin */
djm@openbsd.org4739e8d2015-05-21 12:01:19 +00001259 foreach_options = find_host ? HKF_WANT_MATCH : 0;
1260 foreach_options |= print_fingerprint ? HKF_WANT_PARSE_KEY : 0;
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001261 if ((r = hostkeys_foreach(identity_file,
1262 hash_hosts ? known_hosts_hash : known_hosts_find_delete, &ctx,
deraadt@openbsd.org6da413c2015-11-28 06:50:52 +00001263 name, NULL, foreach_options)) != 0) {
1264 if (inplace)
1265 unlink(tmp);
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001266 fatal("%s: hostkeys_foreach failed: %s", __func__, ssh_err(r));
deraadt@openbsd.org6da413c2015-11-28 06:50:52 +00001267 }
Damien Miller4b42d7f2005-03-01 21:48:35 +11001268
djm@openbsd.org2b3c3c72015-01-18 21:51:19 +00001269 if (inplace)
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001270 fclose(ctx.out);
Damien Miller0a80ca12010-02-27 07:55:05 +11001271
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001272 if (ctx.invalid) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00001273 error("%s is not a valid known_hosts file.", identity_file);
djm@openbsd.org2b3c3c72015-01-18 21:51:19 +00001274 if (inplace) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00001275 error("Not replacing existing known_hosts "
1276 "file because of errors");
Damien Miller4b42d7f2005-03-01 21:48:35 +11001277 unlink(tmp);
1278 }
1279 exit(1);
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001280 } else if (delete_host && !ctx.found_key) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00001281 logit("Host %s not found in %s", name, identity_file);
djm@openbsd.orgc8376432015-08-19 23:17:51 +00001282 if (inplace)
1283 unlink(tmp);
djm@openbsd.org2b3c3c72015-01-18 21:51:19 +00001284 } else if (inplace) {
Damien Miller4b42d7f2005-03-01 21:48:35 +11001285 /* Backup existing file */
1286 if (unlink(old) == -1 && errno != ENOENT)
1287 fatal("unlink %.100s: %s", old, strerror(errno));
1288 if (link(identity_file, old) == -1)
1289 fatal("link %.100s to %.100s: %s", identity_file, old,
1290 strerror(errno));
1291 /* Move new one into place */
1292 if (rename(tmp, identity_file) == -1) {
1293 error("rename\"%s\" to \"%s\": %s", tmp, identity_file,
1294 strerror(errno));
1295 unlink(tmp);
1296 unlink(old);
1297 exit(1);
1298 }
1299
djm@openbsd.org3038a192015-04-17 13:19:22 +00001300 printf("%s updated.\n", identity_file);
1301 printf("Original contents retained as %s\n", old);
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001302 if (ctx.has_unhashed) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00001303 logit("WARNING: %s contains unhashed entries", old);
1304 logit("Delete this file to ensure privacy "
1305 "of hostnames");
Damien Miller4b42d7f2005-03-01 21:48:35 +11001306 }
1307 }
1308
djm@openbsd.orgcecb30b2015-01-18 21:49:42 +00001309 exit (find_host && !ctx.found_key);
Damien Miller4b42d7f2005-03-01 21:48:35 +11001310}
1311
Damien Miller95def091999-11-25 00:26:21 +11001312/*
1313 * Perform changing a passphrase. The argument is the passwd structure
1314 * for the current user.
1315 */
Ben Lindstrombba81212001-06-25 05:01:22 +00001316static void
Damien Miller10f6f6b1999-11-17 17:29:08 +11001317do_change_passphrase(struct passwd *pw)
1318{
Damien Miller95def091999-11-25 00:26:21 +11001319 char *comment;
1320 char *old_passphrase, *passphrase1, *passphrase2;
1321 struct stat st;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001322 struct sshkey *private;
1323 int r;
Damien Miller10f6f6b1999-11-17 17:29:08 +11001324
Damien Miller95def091999-11-25 00:26:21 +11001325 if (!have_identity)
1326 ask_filename(pw, "Enter file in which the key is");
djm@openbsd.org3038a192015-04-17 13:19:22 +00001327 if (stat(identity_file, &st) < 0)
1328 fatal("%s: %s", identity_file, strerror(errno));
Damien Miller95def091999-11-25 00:26:21 +11001329 /* Try to load the file with empty passphrase. */
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001330 r = sshkey_load_private(identity_file, "", &private, &comment);
1331 if (r == SSH_ERR_KEY_WRONG_PASSPHRASE) {
Damien Miller95def091999-11-25 00:26:21 +11001332 if (identity_passphrase)
1333 old_passphrase = xstrdup(identity_passphrase);
1334 else
Ben Lindstrom949974b2001-06-25 05:20:31 +00001335 old_passphrase =
1336 read_passphrase("Enter old passphrase: ",
1337 RP_ALLOW_STDIN);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001338 r = sshkey_load_private(identity_file, old_passphrase,
1339 &private, &comment);
Damien Millera5103f42014-02-04 11:20:14 +11001340 explicit_bzero(old_passphrase, strlen(old_passphrase));
Darren Tuckera627d422013-06-02 07:31:17 +10001341 free(old_passphrase);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001342 if (r != 0)
1343 goto badkey;
1344 } else if (r != 0) {
1345 badkey:
djm@openbsd.org3038a192015-04-17 13:19:22 +00001346 fatal("Failed to load key %s: %s", identity_file, ssh_err(r));
Damien Miller95def091999-11-25 00:26:21 +11001347 }
djm@openbsd.orgf43d1722015-02-26 20:45:47 +00001348 if (comment)
djm@openbsd.orga287c5a2017-02-10 03:36:40 +00001349 mprintf("Key has comment '%s'\n", comment);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001350
Damien Miller95def091999-11-25 00:26:21 +11001351 /* Ask the new passphrase (twice). */
1352 if (identity_new_passphrase) {
1353 passphrase1 = xstrdup(identity_new_passphrase);
1354 passphrase2 = NULL;
1355 } else {
1356 passphrase1 =
Ben Lindstrom949974b2001-06-25 05:20:31 +00001357 read_passphrase("Enter new passphrase (empty for no "
1358 "passphrase): ", RP_ALLOW_STDIN);
1359 passphrase2 = read_passphrase("Enter same passphrase again: ",
Damien Miller9f0f5c62001-12-21 14:45:46 +11001360 RP_ALLOW_STDIN);
Damien Miller95def091999-11-25 00:26:21 +11001361
1362 /* Verify that they are the same. */
1363 if (strcmp(passphrase1, passphrase2) != 0) {
Damien Millera5103f42014-02-04 11:20:14 +11001364 explicit_bzero(passphrase1, strlen(passphrase1));
1365 explicit_bzero(passphrase2, strlen(passphrase2));
Darren Tuckera627d422013-06-02 07:31:17 +10001366 free(passphrase1);
1367 free(passphrase2);
Damien Miller95def091999-11-25 00:26:21 +11001368 printf("Pass phrases do not match. Try again.\n");
1369 exit(1);
1370 }
1371 /* Destroy the other copy. */
Damien Millera5103f42014-02-04 11:20:14 +11001372 explicit_bzero(passphrase2, strlen(passphrase2));
Darren Tuckera627d422013-06-02 07:31:17 +10001373 free(passphrase2);
Damien Miller95def091999-11-25 00:26:21 +11001374 }
1375
1376 /* Save the file using the new passphrase. */
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001377 if ((r = sshkey_save_private(private, identity_file, passphrase1,
1378 comment, use_new_format, new_format_cipher, rounds)) != 0) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00001379 error("Saving key \"%s\" failed: %s.",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001380 identity_file, ssh_err(r));
Damien Millera5103f42014-02-04 11:20:14 +11001381 explicit_bzero(passphrase1, strlen(passphrase1));
Darren Tuckera627d422013-06-02 07:31:17 +10001382 free(passphrase1);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001383 sshkey_free(private);
Darren Tuckera627d422013-06-02 07:31:17 +10001384 free(comment);
Damien Miller95def091999-11-25 00:26:21 +11001385 exit(1);
1386 }
1387 /* Destroy the passphrase and the copy of the key in memory. */
Damien Millera5103f42014-02-04 11:20:14 +11001388 explicit_bzero(passphrase1, strlen(passphrase1));
Darren Tuckera627d422013-06-02 07:31:17 +10001389 free(passphrase1);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001390 sshkey_free(private); /* Destroys contents */
Darren Tuckera627d422013-06-02 07:31:17 +10001391 free(comment);
Damien Miller95def091999-11-25 00:26:21 +11001392
1393 printf("Your identification has been saved with the new passphrase.\n");
1394 exit(0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001395}
1396
Damien Miller37876e92003-05-15 10:19:46 +10001397/*
1398 * Print the SSHFP RR.
1399 */
Damien Millercb314822006-03-26 13:48:01 +11001400static int
1401do_print_resource_record(struct passwd *pw, char *fname, char *hname)
Damien Miller37876e92003-05-15 10:19:46 +10001402{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001403 struct sshkey *public;
Damien Miller37876e92003-05-15 10:19:46 +10001404 char *comment = NULL;
1405 struct stat st;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001406 int r;
Damien Miller37876e92003-05-15 10:19:46 +10001407
Damien Millercb314822006-03-26 13:48:01 +11001408 if (fname == NULL)
Damien Miller5bb88332013-07-18 16:13:37 +10001409 fatal("%s: no filename", __func__);
Damien Millercb314822006-03-26 13:48:01 +11001410 if (stat(fname, &st) < 0) {
1411 if (errno == ENOENT)
1412 return 0;
djm@openbsd.org3038a192015-04-17 13:19:22 +00001413 fatal("%s: %s", fname, strerror(errno));
Damien Miller37876e92003-05-15 10:19:46 +10001414 }
djm@openbsd.org3038a192015-04-17 13:19:22 +00001415 if ((r = sshkey_load_public(fname, &public, &comment)) != 0)
1416 fatal("Failed to read v2 public key from \"%s\": %s.",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001417 fname, ssh_err(r));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001418 export_dns_rr(hname, public, stdout, print_generic);
1419 sshkey_free(public);
1420 free(comment);
1421 return 1;
Damien Miller37876e92003-05-15 10:19:46 +10001422}
Damien Miller37876e92003-05-15 10:19:46 +10001423
Damien Miller95def091999-11-25 00:26:21 +11001424/*
1425 * Change the comment of a private key file.
1426 */
Ben Lindstrombba81212001-06-25 05:01:22 +00001427static void
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001428do_change_comment(struct passwd *pw)
1429{
Ben Lindstrom5fc62702001-03-09 18:19:24 +00001430 char new_comment[1024], *comment, *passphrase;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001431 struct sshkey *private;
1432 struct sshkey *public;
Damien Miller95def091999-11-25 00:26:21 +11001433 struct stat st;
1434 FILE *f;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001435 int r, fd;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001436
Damien Miller95def091999-11-25 00:26:21 +11001437 if (!have_identity)
1438 ask_filename(pw, "Enter file in which the key is");
djm@openbsd.org3038a192015-04-17 13:19:22 +00001439 if (stat(identity_file, &st) < 0)
1440 fatal("%s: %s", identity_file, strerror(errno));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001441 if ((r = sshkey_load_private(identity_file, "",
1442 &private, &comment)) == 0)
1443 passphrase = xstrdup("");
djm@openbsd.org3038a192015-04-17 13:19:22 +00001444 else if (r != SSH_ERR_KEY_WRONG_PASSPHRASE)
1445 fatal("Cannot load private key \"%s\": %s.",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001446 identity_file, ssh_err(r));
djm@openbsd.org3038a192015-04-17 13:19:22 +00001447 else {
Damien Miller95def091999-11-25 00:26:21 +11001448 if (identity_passphrase)
1449 passphrase = xstrdup(identity_passphrase);
1450 else if (identity_new_passphrase)
1451 passphrase = xstrdup(identity_new_passphrase);
1452 else
Ben Lindstrom949974b2001-06-25 05:20:31 +00001453 passphrase = read_passphrase("Enter passphrase: ",
1454 RP_ALLOW_STDIN);
Damien Miller95def091999-11-25 00:26:21 +11001455 /* Try to load using the passphrase. */
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001456 if ((r = sshkey_load_private(identity_file, passphrase,
1457 &private, &comment)) != 0) {
Damien Millera5103f42014-02-04 11:20:14 +11001458 explicit_bzero(passphrase, strlen(passphrase));
Darren Tuckera627d422013-06-02 07:31:17 +10001459 free(passphrase);
djm@openbsd.org3038a192015-04-17 13:19:22 +00001460 fatal("Cannot load private key \"%s\": %s.",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001461 identity_file, ssh_err(r));
Damien Miller95def091999-11-25 00:26:21 +11001462 }
1463 }
halex@openbsd.org4d906252015-11-20 23:04:01 +00001464
markus@openbsd.org1b11ea72018-02-23 15:58:37 +00001465 if (private->type != KEY_ED25519 && private->type != KEY_XMSS &&
1466 !use_new_format) {
djm@openbsd.org873d3e72017-04-30 23:18:44 +00001467 error("Comments are only supported for keys stored in "
halex@openbsd.org4d906252015-11-20 23:04:01 +00001468 "the new format (-o).");
tobias@openbsd.org704d8c82015-03-31 11:06:49 +00001469 explicit_bzero(passphrase, strlen(passphrase));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001470 sshkey_free(private);
Ben Lindstromd0fca422001-03-26 13:44:06 +00001471 exit(1);
Damien Miller9f0f5c62001-12-21 14:45:46 +11001472 }
millert@openbsd.orge40269b2017-02-08 20:32:43 +00001473 if (comment)
1474 printf("Key now has comment '%s'\n", comment);
1475 else
1476 printf("Key now has no comment\n");
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001477
Damien Miller95def091999-11-25 00:26:21 +11001478 if (identity_comment) {
1479 strlcpy(new_comment, identity_comment, sizeof(new_comment));
1480 } else {
1481 printf("Enter new comment: ");
1482 fflush(stdout);
1483 if (!fgets(new_comment, sizeof(new_comment), stdin)) {
Damien Millera5103f42014-02-04 11:20:14 +11001484 explicit_bzero(passphrase, strlen(passphrase));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001485 sshkey_free(private);
Damien Miller95def091999-11-25 00:26:21 +11001486 exit(1);
1487 }
Damien Miller14b017d2007-09-17 16:09:15 +10001488 new_comment[strcspn(new_comment, "\n")] = '\0';
Damien Miller95def091999-11-25 00:26:21 +11001489 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001490
Damien Miller95def091999-11-25 00:26:21 +11001491 /* Save the file using the new passphrase. */
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001492 if ((r = sshkey_save_private(private, identity_file, passphrase,
1493 new_comment, use_new_format, new_format_cipher, rounds)) != 0) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00001494 error("Saving key \"%s\" failed: %s",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001495 identity_file, ssh_err(r));
Damien Millera5103f42014-02-04 11:20:14 +11001496 explicit_bzero(passphrase, strlen(passphrase));
Darren Tuckera627d422013-06-02 07:31:17 +10001497 free(passphrase);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001498 sshkey_free(private);
Darren Tuckera627d422013-06-02 07:31:17 +10001499 free(comment);
Damien Miller95def091999-11-25 00:26:21 +11001500 exit(1);
1501 }
Damien Millera5103f42014-02-04 11:20:14 +11001502 explicit_bzero(passphrase, strlen(passphrase));
Darren Tuckera627d422013-06-02 07:31:17 +10001503 free(passphrase);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001504 if ((r = sshkey_from_private(private, &public)) != 0)
markus@openbsd.org7da5df12017-05-30 14:16:41 +00001505 fatal("sshkey_from_private failed: %s", ssh_err(r));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001506 sshkey_free(private);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001507
Damien Miller95def091999-11-25 00:26:21 +11001508 strlcat(identity_file, ".pub", sizeof(identity_file));
Ben Lindstrom5fc62702001-03-09 18:19:24 +00001509 fd = open(identity_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
djm@openbsd.org3038a192015-04-17 13:19:22 +00001510 if (fd == -1)
1511 fatal("Could not save your public key in %s", identity_file);
Ben Lindstrom5fc62702001-03-09 18:19:24 +00001512 f = fdopen(fd, "w");
djm@openbsd.org3038a192015-04-17 13:19:22 +00001513 if (f == NULL)
1514 fatal("fdopen %s failed: %s", identity_file, strerror(errno));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001515 if ((r = sshkey_write(public, f)) != 0)
djm@openbsd.org3038a192015-04-17 13:19:22 +00001516 fatal("write key failed: %s", ssh_err(r));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001517 sshkey_free(public);
Damien Millereba71ba2000-04-29 23:57:08 +10001518 fprintf(f, " %s\n", new_comment);
Damien Miller95def091999-11-25 00:26:21 +11001519 fclose(f);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001520
Darren Tuckera627d422013-06-02 07:31:17 +10001521 free(comment);
Damien Miller95def091999-11-25 00:26:21 +11001522
1523 printf("The comment in your key file has been changed.\n");
1524 exit(0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001525}
1526
Damien Miller0a80ca12010-02-27 07:55:05 +11001527static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001528add_flag_option(struct sshbuf *c, const char *name)
Damien Miller0a80ca12010-02-27 07:55:05 +11001529{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001530 int r;
1531
Damien Miller0a80ca12010-02-27 07:55:05 +11001532 debug3("%s: %s", __func__, name);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001533 if ((r = sshbuf_put_cstring(c, name)) != 0 ||
1534 (r = sshbuf_put_string(c, NULL, 0)) != 0)
1535 fatal("%s: buffer error: %s", __func__, ssh_err(r));
Damien Miller0a80ca12010-02-27 07:55:05 +11001536}
1537
1538static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001539add_string_option(struct sshbuf *c, const char *name, const char *value)
Damien Miller0a80ca12010-02-27 07:55:05 +11001540{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001541 struct sshbuf *b;
1542 int r;
Damien Miller0a80ca12010-02-27 07:55:05 +11001543
1544 debug3("%s: %s=%s", __func__, name, value);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001545 if ((b = sshbuf_new()) == NULL)
1546 fatal("%s: sshbuf_new failed", __func__);
1547 if ((r = sshbuf_put_cstring(b, value)) != 0 ||
1548 (r = sshbuf_put_cstring(c, name)) != 0 ||
1549 (r = sshbuf_put_stringb(c, b)) != 0)
1550 fatal("%s: buffer error: %s", __func__, ssh_err(r));
Damien Miller0a80ca12010-02-27 07:55:05 +11001551
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001552 sshbuf_free(b);
Damien Miller0a80ca12010-02-27 07:55:05 +11001553}
1554
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001555#define OPTIONS_CRITICAL 1
1556#define OPTIONS_EXTENSIONS 2
Damien Miller0a80ca12010-02-27 07:55:05 +11001557static void
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001558prepare_options_buf(struct sshbuf *c, int which)
Damien Miller0a80ca12010-02-27 07:55:05 +11001559{
djm@openbsd.org249516e2017-04-29 04:12:25 +00001560 size_t i;
1561
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001562 sshbuf_reset(c);
Damien Miller1da63882010-08-05 13:03:51 +10001563 if ((which & OPTIONS_CRITICAL) != 0 &&
1564 certflags_command != NULL)
1565 add_string_option(c, "force-command", certflags_command);
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001566 if ((which & OPTIONS_EXTENSIONS) != 0 &&
Damien Miller2ce12ef2011-05-05 14:17:18 +10001567 (certflags_flags & CERTOPT_X_FWD) != 0)
1568 add_flag_option(c, "permit-X11-forwarding");
1569 if ((which & OPTIONS_EXTENSIONS) != 0 &&
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001570 (certflags_flags & CERTOPT_AGENT_FWD) != 0)
Damien Miller4e270b02010-04-16 15:56:21 +10001571 add_flag_option(c, "permit-agent-forwarding");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001572 if ((which & OPTIONS_EXTENSIONS) != 0 &&
1573 (certflags_flags & CERTOPT_PORT_FWD) != 0)
Damien Miller4e270b02010-04-16 15:56:21 +10001574 add_flag_option(c, "permit-port-forwarding");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001575 if ((which & OPTIONS_EXTENSIONS) != 0 &&
1576 (certflags_flags & CERTOPT_PTY) != 0)
Damien Miller4e270b02010-04-16 15:56:21 +10001577 add_flag_option(c, "permit-pty");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001578 if ((which & OPTIONS_EXTENSIONS) != 0 &&
1579 (certflags_flags & CERTOPT_USER_RC) != 0)
Damien Miller4e270b02010-04-16 15:56:21 +10001580 add_flag_option(c, "permit-user-rc");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001581 if ((which & OPTIONS_CRITICAL) != 0 &&
1582 certflags_src_addr != NULL)
1583 add_string_option(c, "source-address", certflags_src_addr);
djm@openbsd.org249516e2017-04-29 04:12:25 +00001584 for (i = 0; i < ncert_userext; i++) {
1585 if ((cert_userext[i].crit && (which & OPTIONS_EXTENSIONS)) ||
1586 (!cert_userext[i].crit && (which & OPTIONS_CRITICAL)))
1587 continue;
1588 if (cert_userext[i].val == NULL)
1589 add_flag_option(c, cert_userext[i].key);
1590 else {
1591 add_string_option(c, cert_userext[i].key,
1592 cert_userext[i].val);
1593 }
1594 }
Damien Miller0a80ca12010-02-27 07:55:05 +11001595}
1596
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001597static struct sshkey *
Damien Miller757f34e2010-08-05 13:05:31 +10001598load_pkcs11_key(char *path)
1599{
1600#ifdef ENABLE_PKCS11
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001601 struct sshkey **keys = NULL, *public, *private = NULL;
1602 int r, i, nkeys;
Damien Miller757f34e2010-08-05 13:05:31 +10001603
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001604 if ((r = sshkey_load_public(path, &public, NULL)) != 0)
1605 fatal("Couldn't load CA public key \"%s\": %s",
1606 path, ssh_err(r));
Damien Miller757f34e2010-08-05 13:05:31 +10001607
1608 nkeys = pkcs11_add_provider(pkcs11provider, identity_passphrase, &keys);
1609 debug3("%s: %d keys", __func__, nkeys);
1610 if (nkeys <= 0)
1611 fatal("cannot read public key from pkcs11");
1612 for (i = 0; i < nkeys; i++) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001613 if (sshkey_equal_public(public, keys[i])) {
Damien Miller757f34e2010-08-05 13:05:31 +10001614 private = keys[i];
1615 continue;
1616 }
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001617 sshkey_free(keys[i]);
Damien Miller757f34e2010-08-05 13:05:31 +10001618 }
Darren Tuckera627d422013-06-02 07:31:17 +10001619 free(keys);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001620 sshkey_free(public);
Damien Miller757f34e2010-08-05 13:05:31 +10001621 return private;
1622#else
1623 fatal("no pkcs11 support");
1624#endif /* ENABLE_PKCS11 */
1625}
1626
djm@openbsd.orga98339e2017-06-28 01:09:22 +00001627/* Signer for sshkey_certify_custom that uses the agent */
1628static int
1629agent_signer(const struct sshkey *key, u_char **sigp, size_t *lenp,
1630 const u_char *data, size_t datalen,
1631 const char *alg, u_int compat, void *ctx)
1632{
1633 int *agent_fdp = (int *)ctx;
1634
1635 return ssh_agent_sign(*agent_fdp, key, sigp, lenp,
1636 data, datalen, alg, compat);
1637}
1638
Damien Miller0a80ca12010-02-27 07:55:05 +11001639static void
1640do_ca_sign(struct passwd *pw, int argc, char **argv)
1641{
djm@openbsd.orga98339e2017-06-28 01:09:22 +00001642 int r, i, fd, found, agent_fd = -1;
Damien Miller0a80ca12010-02-27 07:55:05 +11001643 u_int n;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001644 struct sshkey *ca, *public;
djm@openbsd.org499cf362015-11-19 01:08:55 +00001645 char valid[64], *otmp, *tmp, *cp, *out, *comment, **plist = NULL;
Damien Miller0a80ca12010-02-27 07:55:05 +11001646 FILE *f;
djm@openbsd.orga98339e2017-06-28 01:09:22 +00001647 struct ssh_identitylist *agent_ids;
1648 size_t j;
Damien Miller4e270b02010-04-16 15:56:21 +10001649
Damien Miller1f0311c2014-05-15 14:24:09 +10001650#ifdef ENABLE_PKCS11
Damien Miller757f34e2010-08-05 13:05:31 +10001651 pkcs11_init(1);
Damien Miller1f0311c2014-05-15 14:24:09 +10001652#endif
Damien Miller757f34e2010-08-05 13:05:31 +10001653 tmp = tilde_expand_filename(ca_key_path, pw->pw_uid);
1654 if (pkcs11provider != NULL) {
djm@openbsd.orga98339e2017-06-28 01:09:22 +00001655 /* If a PKCS#11 token was specified then try to use it */
Damien Miller757f34e2010-08-05 13:05:31 +10001656 if ((ca = load_pkcs11_key(tmp)) == NULL)
1657 fatal("No PKCS#11 key matching %s found", ca_key_path);
djm@openbsd.orga98339e2017-06-28 01:09:22 +00001658 } else if (prefer_agent) {
1659 /*
1660 * Agent signature requested. Try to use agent after making
1661 * sure the public key specified is actually present in the
1662 * agent.
1663 */
1664 if ((r = sshkey_load_public(tmp, &ca, NULL)) != 0)
1665 fatal("Cannot load CA public key %s: %s",
1666 tmp, ssh_err(r));
1667 if ((r = ssh_get_authentication_socket(&agent_fd)) != 0)
1668 fatal("Cannot use public key for CA signature: %s",
1669 ssh_err(r));
1670 if ((r = ssh_fetch_identitylist(agent_fd, &agent_ids)) != 0)
1671 fatal("Retrieve agent key list: %s", ssh_err(r));
1672 found = 0;
1673 for (j = 0; j < agent_ids->nkeys; j++) {
1674 if (sshkey_equal(ca, agent_ids->keys[j])) {
1675 found = 1;
1676 break;
1677 }
1678 }
1679 if (!found)
1680 fatal("CA key %s not found in agent", tmp);
1681 ssh_free_identitylist(agent_ids);
1682 ca->flags |= SSHKEY_FLAG_EXT;
1683 } else {
1684 /* CA key is assumed to be a private key on the filesystem */
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001685 ca = load_identity(tmp);
djm@openbsd.orga98339e2017-06-28 01:09:22 +00001686 }
Darren Tuckera627d422013-06-02 07:31:17 +10001687 free(tmp);
Damien Miller757f34e2010-08-05 13:05:31 +10001688
djm@openbsd.org57464e32016-05-02 09:36:42 +00001689 if (key_type_name != NULL &&
1690 sshkey_type_from_name(key_type_name) != ca->type) {
1691 fatal("CA key type %s doesn't match specified %s",
1692 sshkey_ssh_name(ca), key_type_name);
1693 }
1694
Damien Miller0a80ca12010-02-27 07:55:05 +11001695 for (i = 0; i < argc; i++) {
1696 /* Split list of principals */
1697 n = 0;
1698 if (cert_principals != NULL) {
1699 otmp = tmp = xstrdup(cert_principals);
1700 plist = NULL;
1701 for (; (cp = strsep(&tmp, ",")) != NULL; n++) {
deraadt@openbsd.org657a5fb2015-04-24 01:36:00 +00001702 plist = xreallocarray(plist, n + 1, sizeof(*plist));
Damien Miller0a80ca12010-02-27 07:55:05 +11001703 if (*(plist[n] = xstrdup(cp)) == '\0')
1704 fatal("Empty principal name");
1705 }
Darren Tuckera627d422013-06-02 07:31:17 +10001706 free(otmp);
Damien Miller0a80ca12010-02-27 07:55:05 +11001707 }
djm@openbsd.orgca613242018-02-10 05:48:46 +00001708 if (n > SSHKEY_CERT_MAX_PRINCIPALS)
1709 fatal("Too many certificate principals specified");
Damien Miller0a80ca12010-02-27 07:55:05 +11001710
1711 tmp = tilde_expand_filename(argv[i], pw->pw_uid);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001712 if ((r = sshkey_load_public(tmp, &public, &comment)) != 0)
1713 fatal("%s: unable to open \"%s\": %s",
1714 __func__, tmp, ssh_err(r));
Damien Millereb8b60e2010-08-31 22:41:14 +10001715 if (public->type != KEY_RSA && public->type != KEY_DSA &&
markus@openbsd.org1b11ea72018-02-23 15:58:37 +00001716 public->type != KEY_ECDSA && public->type != KEY_ED25519 &&
1717 public->type != KEY_XMSS)
Damien Miller0a80ca12010-02-27 07:55:05 +11001718 fatal("%s: key \"%s\" type %s cannot be certified",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001719 __func__, tmp, sshkey_type(public));
Damien Miller0a80ca12010-02-27 07:55:05 +11001720
1721 /* Prepare certificate to sign */
djm@openbsd.orgc28fc622015-07-03 03:43:18 +00001722 if ((r = sshkey_to_certified(public)) != 0)
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001723 fatal("Could not upgrade key %s to certificate: %s",
1724 tmp, ssh_err(r));
Damien Miller0a80ca12010-02-27 07:55:05 +11001725 public->cert->type = cert_key_type;
Damien Miller4e270b02010-04-16 15:56:21 +10001726 public->cert->serial = (u_int64_t)cert_serial;
Damien Miller0a80ca12010-02-27 07:55:05 +11001727 public->cert->key_id = xstrdup(cert_key_id);
1728 public->cert->nprincipals = n;
1729 public->cert->principals = plist;
1730 public->cert->valid_after = cert_valid_from;
1731 public->cert->valid_before = cert_valid_to;
djm@openbsd.orgc28fc622015-07-03 03:43:18 +00001732 prepare_options_buf(public->cert->critical, OPTIONS_CRITICAL);
1733 prepare_options_buf(public->cert->extensions,
1734 OPTIONS_EXTENSIONS);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001735 if ((r = sshkey_from_private(ca,
1736 &public->cert->signature_key)) != 0)
markus@openbsd.org7da5df12017-05-30 14:16:41 +00001737 fatal("sshkey_from_private (ca key): %s", ssh_err(r));
Damien Miller0a80ca12010-02-27 07:55:05 +11001738
djm@openbsd.orga98339e2017-06-28 01:09:22 +00001739 if (agent_fd != -1 && (ca->flags & SSHKEY_FLAG_EXT) != 0) {
1740 if ((r = sshkey_certify_custom(public, ca,
1741 key_type_name, agent_signer, &agent_fd)) != 0)
1742 fatal("Couldn't certify key %s via agent: %s",
1743 tmp, ssh_err(r));
1744 } else {
1745 if ((sshkey_certify(public, ca, key_type_name)) != 0)
1746 fatal("Couldn't certify key %s: %s",
1747 tmp, ssh_err(r));
1748 }
Damien Miller0a80ca12010-02-27 07:55:05 +11001749
1750 if ((cp = strrchr(tmp, '.')) != NULL && strcmp(cp, ".pub") == 0)
1751 *cp = '\0';
1752 xasprintf(&out, "%s-cert.pub", tmp);
Darren Tuckera627d422013-06-02 07:31:17 +10001753 free(tmp);
Damien Miller0a80ca12010-02-27 07:55:05 +11001754
1755 if ((fd = open(out, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1)
1756 fatal("Could not open \"%s\" for writing: %s", out,
1757 strerror(errno));
1758 if ((f = fdopen(fd, "w")) == NULL)
1759 fatal("%s: fdopen: %s", __func__, strerror(errno));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001760 if ((r = sshkey_write(public, f)) != 0)
1761 fatal("Could not write certified key to %s: %s",
1762 out, ssh_err(r));
Damien Miller0a80ca12010-02-27 07:55:05 +11001763 fprintf(f, " %s\n", comment);
1764 fclose(f);
1765
Damien Miller4e270b02010-04-16 15:56:21 +10001766 if (!quiet) {
djm@openbsd.org964ab3e2015-11-19 01:12:32 +00001767 sshkey_format_cert_validity(public->cert,
djm@openbsd.org499cf362015-11-19 01:08:55 +00001768 valid, sizeof(valid));
Damien Miller4e270b02010-04-16 15:56:21 +10001769 logit("Signed %s key %s: id \"%s\" serial %llu%s%s "
djm@openbsd.org964ab3e2015-11-19 01:12:32 +00001770 "valid %s", sshkey_cert_type(public),
Damien Miller821de0a2011-01-11 17:20:29 +11001771 out, public->cert->key_id,
1772 (unsigned long long)public->cert->serial,
Damien Miller0a80ca12010-02-27 07:55:05 +11001773 cert_principals != NULL ? " for " : "",
1774 cert_principals != NULL ? cert_principals : "",
djm@openbsd.org499cf362015-11-19 01:08:55 +00001775 valid);
Damien Miller4e270b02010-04-16 15:56:21 +10001776 }
Damien Miller0a80ca12010-02-27 07:55:05 +11001777
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001778 sshkey_free(public);
Darren Tuckera627d422013-06-02 07:31:17 +10001779 free(out);
Damien Miller0a80ca12010-02-27 07:55:05 +11001780 }
Damien Miller1f0311c2014-05-15 14:24:09 +10001781#ifdef ENABLE_PKCS11
Damien Miller757f34e2010-08-05 13:05:31 +10001782 pkcs11_terminate();
Damien Miller1f0311c2014-05-15 14:24:09 +10001783#endif
Damien Miller0a80ca12010-02-27 07:55:05 +11001784 exit(0);
1785}
1786
1787static u_int64_t
1788parse_relative_time(const char *s, time_t now)
1789{
1790 int64_t mul, secs;
1791
1792 mul = *s == '-' ? -1 : 1;
1793
1794 if ((secs = convtime(s + 1)) == -1)
1795 fatal("Invalid relative certificate time %s", s);
1796 if (mul == -1 && secs > now)
1797 fatal("Certificate time %s cannot be represented", s);
1798 return now + (u_int64_t)(secs * mul);
1799}
1800
Damien Miller0a80ca12010-02-27 07:55:05 +11001801static void
1802parse_cert_times(char *timespec)
1803{
1804 char *from, *to;
1805 time_t now = time(NULL);
1806 int64_t secs;
1807
1808 /* +timespec relative to now */
1809 if (*timespec == '+' && strchr(timespec, ':') == NULL) {
1810 if ((secs = convtime(timespec + 1)) == -1)
1811 fatal("Invalid relative certificate life %s", timespec);
1812 cert_valid_to = now + secs;
1813 /*
1814 * Backdate certificate one minute to avoid problems on hosts
1815 * with poorly-synchronised clocks.
1816 */
1817 cert_valid_from = ((now - 59)/ 60) * 60;
1818 return;
1819 }
1820
1821 /*
1822 * from:to, where
djm@openbsd.org@openbsd.orgd52131a2017-11-03 05:14:04 +00001823 * from := [+-]timespec | YYYYMMDD | YYYYMMDDHHMMSS | "always"
1824 * to := [+-]timespec | YYYYMMDD | YYYYMMDDHHMMSS | "forever"
Damien Miller0a80ca12010-02-27 07:55:05 +11001825 */
1826 from = xstrdup(timespec);
1827 to = strchr(from, ':');
1828 if (to == NULL || from == to || *(to + 1) == '\0')
Damien Miller910f2092010-03-04 14:17:22 +11001829 fatal("Invalid certificate life specification %s", timespec);
Damien Miller0a80ca12010-02-27 07:55:05 +11001830 *to++ = '\0';
1831
1832 if (*from == '-' || *from == '+')
1833 cert_valid_from = parse_relative_time(from, now);
djm@openbsd.org@openbsd.orgd52131a2017-11-03 05:14:04 +00001834 else if (strcmp(from, "always") == 0)
1835 cert_valid_from = 0;
djm@openbsd.orgbf0fbf22018-03-12 00:52:01 +00001836 else if (parse_absolute_time(from, &cert_valid_from) != 0)
1837 fatal("Invalid from time \"%s\"", from);
Damien Miller0a80ca12010-02-27 07:55:05 +11001838
1839 if (*to == '-' || *to == '+')
Damien Miller5b01b0d2013-10-23 16:31:31 +11001840 cert_valid_to = parse_relative_time(to, now);
djm@openbsd.org@openbsd.orgd52131a2017-11-03 05:14:04 +00001841 else if (strcmp(to, "forever") == 0)
1842 cert_valid_to = ~(u_int64_t)0;
djm@openbsd.orgbf0fbf22018-03-12 00:52:01 +00001843 else if (parse_absolute_time(to, &cert_valid_to) != 0)
1844 fatal("Invalid to time \"%s\"", to);
Damien Miller0a80ca12010-02-27 07:55:05 +11001845
1846 if (cert_valid_to <= cert_valid_from)
1847 fatal("Empty certificate validity interval");
Darren Tuckera627d422013-06-02 07:31:17 +10001848 free(from);
Damien Miller0a80ca12010-02-27 07:55:05 +11001849}
1850
1851static void
Damien Miller4e270b02010-04-16 15:56:21 +10001852add_cert_option(char *opt)
Damien Miller0a80ca12010-02-27 07:55:05 +11001853{
djm@openbsd.org249516e2017-04-29 04:12:25 +00001854 char *val, *cp;
1855 int iscrit = 0;
Damien Miller0a80ca12010-02-27 07:55:05 +11001856
Damien Miller044f4a62011-05-05 14:14:08 +10001857 if (strcasecmp(opt, "clear") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001858 certflags_flags = 0;
Damien Miller0a80ca12010-02-27 07:55:05 +11001859 else if (strcasecmp(opt, "no-x11-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001860 certflags_flags &= ~CERTOPT_X_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001861 else if (strcasecmp(opt, "permit-x11-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001862 certflags_flags |= CERTOPT_X_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001863 else if (strcasecmp(opt, "no-agent-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001864 certflags_flags &= ~CERTOPT_AGENT_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001865 else if (strcasecmp(opt, "permit-agent-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001866 certflags_flags |= CERTOPT_AGENT_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001867 else if (strcasecmp(opt, "no-port-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001868 certflags_flags &= ~CERTOPT_PORT_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001869 else if (strcasecmp(opt, "permit-port-forwarding") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001870 certflags_flags |= CERTOPT_PORT_FWD;
Damien Miller0a80ca12010-02-27 07:55:05 +11001871 else if (strcasecmp(opt, "no-pty") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001872 certflags_flags &= ~CERTOPT_PTY;
Damien Miller0a80ca12010-02-27 07:55:05 +11001873 else if (strcasecmp(opt, "permit-pty") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001874 certflags_flags |= CERTOPT_PTY;
Damien Miller0a80ca12010-02-27 07:55:05 +11001875 else if (strcasecmp(opt, "no-user-rc") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001876 certflags_flags &= ~CERTOPT_USER_RC;
Damien Miller0a80ca12010-02-27 07:55:05 +11001877 else if (strcasecmp(opt, "permit-user-rc") == 0)
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001878 certflags_flags |= CERTOPT_USER_RC;
Damien Miller0a80ca12010-02-27 07:55:05 +11001879 else if (strncasecmp(opt, "force-command=", 14) == 0) {
1880 val = opt + 14;
1881 if (*val == '\0')
Damien Miller4e270b02010-04-16 15:56:21 +10001882 fatal("Empty force-command option");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001883 if (certflags_command != NULL)
Damien Miller0a80ca12010-02-27 07:55:05 +11001884 fatal("force-command already specified");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001885 certflags_command = xstrdup(val);
Damien Miller0a80ca12010-02-27 07:55:05 +11001886 } else if (strncasecmp(opt, "source-address=", 15) == 0) {
1887 val = opt + 15;
1888 if (*val == '\0')
Damien Miller4e270b02010-04-16 15:56:21 +10001889 fatal("Empty source-address option");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001890 if (certflags_src_addr != NULL)
Damien Miller0a80ca12010-02-27 07:55:05 +11001891 fatal("source-address already specified");
1892 if (addr_match_cidr_list(NULL, val) != 0)
1893 fatal("Invalid source-address list");
Damien Millerd0e4a8e2010-05-21 14:58:32 +10001894 certflags_src_addr = xstrdup(val);
djm@openbsd.org249516e2017-04-29 04:12:25 +00001895 } else if (strncasecmp(opt, "extension:", 10) == 0 ||
1896 (iscrit = (strncasecmp(opt, "critical:", 9) == 0))) {
1897 val = xstrdup(strchr(opt, ':') + 1);
1898 if ((cp = strchr(val, '=')) != NULL)
1899 *cp++ = '\0';
1900 cert_userext = xreallocarray(cert_userext, ncert_userext + 1,
1901 sizeof(*cert_userext));
1902 cert_userext[ncert_userext].key = val;
1903 cert_userext[ncert_userext].val = cp == NULL ?
1904 NULL : xstrdup(cp);
1905 cert_userext[ncert_userext].crit = iscrit;
1906 ncert_userext++;
Damien Miller0a80ca12010-02-27 07:55:05 +11001907 } else
Damien Miller4e270b02010-04-16 15:56:21 +10001908 fatal("Unsupported certificate option \"%s\"", opt);
Damien Miller0a80ca12010-02-27 07:55:05 +11001909}
1910
Ben Lindstrombba81212001-06-25 05:01:22 +00001911static void
djm@openbsd.orgc28fc622015-07-03 03:43:18 +00001912show_options(struct sshbuf *optbuf, int in_critical)
Damien Millerd834d352010-06-26 09:48:02 +10001913{
Damien Miller633de332014-05-15 13:48:26 +10001914 char *name, *arg;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001915 struct sshbuf *options, *option = NULL;
1916 int r;
Damien Millerd834d352010-06-26 09:48:02 +10001917
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001918 if ((options = sshbuf_fromb(optbuf)) == NULL)
1919 fatal("%s: sshbuf_fromb failed", __func__);
1920 while (sshbuf_len(options) != 0) {
1921 sshbuf_free(option);
1922 option = NULL;
1923 if ((r = sshbuf_get_cstring(options, &name, NULL)) != 0 ||
1924 (r = sshbuf_froms(options, &option)) != 0)
1925 fatal("%s: buffer error: %s", __func__, ssh_err(r));
Damien Millerd834d352010-06-26 09:48:02 +10001926 printf(" %s", name);
djm@openbsd.orgc28fc622015-07-03 03:43:18 +00001927 if (!in_critical &&
Damien Millerd834d352010-06-26 09:48:02 +10001928 (strcmp(name, "permit-X11-forwarding") == 0 ||
1929 strcmp(name, "permit-agent-forwarding") == 0 ||
1930 strcmp(name, "permit-port-forwarding") == 0 ||
1931 strcmp(name, "permit-pty") == 0 ||
1932 strcmp(name, "permit-user-rc") == 0))
1933 printf("\n");
djm@openbsd.orgc28fc622015-07-03 03:43:18 +00001934 else if (in_critical &&
Damien Millerd834d352010-06-26 09:48:02 +10001935 (strcmp(name, "force-command") == 0 ||
1936 strcmp(name, "source-address") == 0)) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001937 if ((r = sshbuf_get_cstring(option, &arg, NULL)) != 0)
1938 fatal("%s: buffer error: %s",
1939 __func__, ssh_err(r));
Damien Miller633de332014-05-15 13:48:26 +10001940 printf(" %s\n", arg);
1941 free(arg);
Damien Millerd834d352010-06-26 09:48:02 +10001942 } else {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001943 printf(" UNKNOWN OPTION (len %zu)\n",
1944 sshbuf_len(option));
1945 sshbuf_reset(option);
Damien Millerd834d352010-06-26 09:48:02 +10001946 }
Darren Tuckera627d422013-06-02 07:31:17 +10001947 free(name);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001948 if (sshbuf_len(option) != 0)
Damien Millerd834d352010-06-26 09:48:02 +10001949 fatal("Option corrupt: extra data at end");
1950 }
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001951 sshbuf_free(option);
1952 sshbuf_free(options);
Damien Millerd834d352010-06-26 09:48:02 +10001953}
1954
1955static void
djm@openbsd.org94bc0b72015-11-13 04:34:15 +00001956print_cert(struct sshkey *key)
Damien Millerf2b70ca2010-03-05 07:39:35 +11001957{
djm@openbsd.org499cf362015-11-19 01:08:55 +00001958 char valid[64], *key_fp, *ca_fp;
djm@openbsd.orgc28fc622015-07-03 03:43:18 +00001959 u_int i;
Damien Miller4e270b02010-04-16 15:56:21 +10001960
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001961 key_fp = sshkey_fingerprint(key, fingerprint_hash, SSH_FP_DEFAULT);
1962 ca_fp = sshkey_fingerprint(key->cert->signature_key,
djm@openbsd.org56d1c832014-12-21 22:27:55 +00001963 fingerprint_hash, SSH_FP_DEFAULT);
djm@openbsd.org9ce86c92015-01-28 22:36:00 +00001964 if (key_fp == NULL || ca_fp == NULL)
1965 fatal("%s: sshkey_fingerprint fail", __func__);
djm@openbsd.org499cf362015-11-19 01:08:55 +00001966 sshkey_format_cert_validity(key->cert, valid, sizeof(valid));
Damien Millerf2b70ca2010-03-05 07:39:35 +11001967
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001968 printf(" Type: %s %s certificate\n", sshkey_ssh_name(key),
1969 sshkey_cert_type(key));
1970 printf(" Public key: %s %s\n", sshkey_type(key), key_fp);
Damien Miller4e270b02010-04-16 15:56:21 +10001971 printf(" Signing CA: %s %s\n",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001972 sshkey_type(key->cert->signature_key), ca_fp);
Damien Miller4e270b02010-04-16 15:56:21 +10001973 printf(" Key ID: \"%s\"\n", key->cert->key_id);
djm@openbsd.orgc28fc622015-07-03 03:43:18 +00001974 printf(" Serial: %llu\n", (unsigned long long)key->cert->serial);
djm@openbsd.org499cf362015-11-19 01:08:55 +00001975 printf(" Valid: %s\n", valid);
Damien Millerf2b70ca2010-03-05 07:39:35 +11001976 printf(" Principals: ");
1977 if (key->cert->nprincipals == 0)
1978 printf("(none)\n");
1979 else {
1980 for (i = 0; i < key->cert->nprincipals; i++)
1981 printf("\n %s",
1982 key->cert->principals[i]);
1983 printf("\n");
1984 }
Damien Miller4e270b02010-04-16 15:56:21 +10001985 printf(" Critical Options: ");
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00001986 if (sshbuf_len(key->cert->critical) == 0)
Damien Millerf2b70ca2010-03-05 07:39:35 +11001987 printf("(none)\n");
1988 else {
1989 printf("\n");
djm@openbsd.orgc28fc622015-07-03 03:43:18 +00001990 show_options(key->cert->critical, 1);
Damien Millerf2b70ca2010-03-05 07:39:35 +11001991 }
djm@openbsd.orgc28fc622015-07-03 03:43:18 +00001992 printf(" Extensions: ");
1993 if (sshbuf_len(key->cert->extensions) == 0)
1994 printf("(none)\n");
1995 else {
1996 printf("\n");
1997 show_options(key->cert->extensions, 0);
Damien Miller4e270b02010-04-16 15:56:21 +10001998 }
djm@openbsd.org94bc0b72015-11-13 04:34:15 +00001999}
2000
2001static void
2002do_show_cert(struct passwd *pw)
2003{
2004 struct sshkey *key = NULL;
2005 struct stat st;
2006 int r, is_stdin = 0, ok = 0;
2007 FILE *f;
djm@openbsd.orgcce6a362015-12-11 03:19:09 +00002008 char *cp, line[SSH_MAX_PUBKEY_BYTES];
djm@openbsd.org94bc0b72015-11-13 04:34:15 +00002009 const char *path;
djm@openbsd.org1a31d022016-05-02 08:49:03 +00002010 u_long lnum = 0;
djm@openbsd.org94bc0b72015-11-13 04:34:15 +00002011
2012 if (!have_identity)
2013 ask_filename(pw, "Enter file in which the key is");
2014 if (strcmp(identity_file, "-") != 0 && stat(identity_file, &st) < 0)
2015 fatal("%s: %s: %s", __progname, identity_file, strerror(errno));
2016
2017 path = identity_file;
2018 if (strcmp(path, "-") == 0) {
2019 f = stdin;
2020 path = "(stdin)";
2021 is_stdin = 1;
2022 } else if ((f = fopen(identity_file, "r")) == NULL)
2023 fatal("fopen %s: %s", identity_file, strerror(errno));
2024
2025 while (read_keyfile_line(f, path, line, sizeof(line), &lnum) == 0) {
2026 sshkey_free(key);
2027 key = NULL;
2028 /* Trim leading space and comments */
2029 cp = line + strspn(line, " \t");
2030 if (*cp == '#' || *cp == '\0')
2031 continue;
2032 if ((key = sshkey_new(KEY_UNSPEC)) == NULL)
markus@openbsd.org7da5df12017-05-30 14:16:41 +00002033 fatal("sshkey_new");
djm@openbsd.org94bc0b72015-11-13 04:34:15 +00002034 if ((r = sshkey_read(key, &cp)) != 0) {
2035 error("%s:%lu: invalid key: %s", path,
2036 lnum, ssh_err(r));
2037 continue;
2038 }
2039 if (!sshkey_is_cert(key)) {
2040 error("%s:%lu is not a certificate", path, lnum);
2041 continue;
2042 }
2043 ok = 1;
2044 if (!is_stdin && lnum == 1)
2045 printf("%s:\n", path);
2046 else
2047 printf("%s:%lu:\n", path, lnum);
2048 print_cert(key);
2049 }
2050 sshkey_free(key);
2051 fclose(f);
2052 exit(ok ? 0 : 1);
Damien Millerf2b70ca2010-03-05 07:39:35 +11002053}
2054
2055static void
Damien Millerf3747bf2013-01-18 11:44:04 +11002056load_krl(const char *path, struct ssh_krl **krlp)
2057{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002058 struct sshbuf *krlbuf;
2059 int r, fd;
Damien Millerf3747bf2013-01-18 11:44:04 +11002060
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002061 if ((krlbuf = sshbuf_new()) == NULL)
2062 fatal("sshbuf_new failed");
Damien Millerf3747bf2013-01-18 11:44:04 +11002063 if ((fd = open(path, O_RDONLY)) == -1)
2064 fatal("open %s: %s", path, strerror(errno));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002065 if ((r = sshkey_load_file(fd, krlbuf)) != 0)
2066 fatal("Unable to load KRL: %s", ssh_err(r));
Damien Millerf3747bf2013-01-18 11:44:04 +11002067 close(fd);
2068 /* XXX check sigs */
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002069 if ((r = ssh_krl_from_blob(krlbuf, krlp, NULL, 0)) != 0 ||
Damien Millerf3747bf2013-01-18 11:44:04 +11002070 *krlp == NULL)
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002071 fatal("Invalid KRL file: %s", ssh_err(r));
2072 sshbuf_free(krlbuf);
Damien Millerf3747bf2013-01-18 11:44:04 +11002073}
2074
2075static void
djm@openbsd.org669aee92015-01-30 01:10:33 +00002076update_krl_from_file(struct passwd *pw, const char *file, int wild_ca,
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002077 const struct sshkey *ca, struct ssh_krl *krl)
Damien Millerf3747bf2013-01-18 11:44:04 +11002078{
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002079 struct sshkey *key = NULL;
Damien Millerf3747bf2013-01-18 11:44:04 +11002080 u_long lnum = 0;
2081 char *path, *cp, *ep, line[SSH_MAX_PUBKEY_BYTES];
2082 unsigned long long serial, serial2;
2083 int i, was_explicit_key, was_sha1, r;
2084 FILE *krl_spec;
2085
2086 path = tilde_expand_filename(file, pw->pw_uid);
2087 if (strcmp(path, "-") == 0) {
2088 krl_spec = stdin;
2089 free(path);
2090 path = xstrdup("(standard input)");
2091 } else if ((krl_spec = fopen(path, "r")) == NULL)
2092 fatal("fopen %s: %s", path, strerror(errno));
2093
2094 if (!quiet)
2095 printf("Revoking from %s\n", path);
2096 while (read_keyfile_line(krl_spec, path, line, sizeof(line),
2097 &lnum) == 0) {
2098 was_explicit_key = was_sha1 = 0;
2099 cp = line + strspn(line, " \t");
2100 /* Trim trailing space, comments and strip \n */
2101 for (i = 0, r = -1; cp[i] != '\0'; i++) {
2102 if (cp[i] == '#' || cp[i] == '\n') {
2103 cp[i] = '\0';
2104 break;
2105 }
2106 if (cp[i] == ' ' || cp[i] == '\t') {
2107 /* Remember the start of a span of whitespace */
2108 if (r == -1)
2109 r = i;
2110 } else
2111 r = -1;
2112 }
2113 if (r != -1)
2114 cp[r] = '\0';
2115 if (*cp == '\0')
2116 continue;
2117 if (strncasecmp(cp, "serial:", 7) == 0) {
djm@openbsd.org669aee92015-01-30 01:10:33 +00002118 if (ca == NULL && !wild_ca) {
Damien Millerd234afb2013-08-21 02:42:58 +10002119 fatal("revoking certificates by serial number "
Damien Millerf3747bf2013-01-18 11:44:04 +11002120 "requires specification of a CA key");
2121 }
2122 cp += 7;
2123 cp = cp + strspn(cp, " \t");
2124 errno = 0;
2125 serial = strtoull(cp, &ep, 0);
2126 if (*cp == '\0' || (*ep != '\0' && *ep != '-'))
2127 fatal("%s:%lu: invalid serial \"%s\"",
2128 path, lnum, cp);
2129 if (errno == ERANGE && serial == ULLONG_MAX)
2130 fatal("%s:%lu: serial out of range",
2131 path, lnum);
2132 serial2 = serial;
2133 if (*ep == '-') {
2134 cp = ep + 1;
2135 errno = 0;
2136 serial2 = strtoull(cp, &ep, 0);
2137 if (*cp == '\0' || *ep != '\0')
2138 fatal("%s:%lu: invalid serial \"%s\"",
2139 path, lnum, cp);
2140 if (errno == ERANGE && serial2 == ULLONG_MAX)
2141 fatal("%s:%lu: serial out of range",
2142 path, lnum);
2143 if (serial2 <= serial)
2144 fatal("%s:%lu: invalid serial range "
2145 "%llu:%llu", path, lnum,
2146 (unsigned long long)serial,
2147 (unsigned long long)serial2);
2148 }
2149 if (ssh_krl_revoke_cert_by_serial_range(krl,
2150 ca, serial, serial2) != 0) {
2151 fatal("%s: revoke serial failed",
2152 __func__);
2153 }
2154 } else if (strncasecmp(cp, "id:", 3) == 0) {
djm@openbsd.org669aee92015-01-30 01:10:33 +00002155 if (ca == NULL && !wild_ca) {
Damien Millerd5d9d7b2013-08-21 02:43:27 +10002156 fatal("revoking certificates by key ID "
Damien Millerf3747bf2013-01-18 11:44:04 +11002157 "requires specification of a CA key");
2158 }
2159 cp += 3;
2160 cp = cp + strspn(cp, " \t");
2161 if (ssh_krl_revoke_cert_by_key_id(krl, ca, cp) != 0)
2162 fatal("%s: revoke key ID failed", __func__);
2163 } else {
2164 if (strncasecmp(cp, "key:", 4) == 0) {
2165 cp += 4;
2166 cp = cp + strspn(cp, " \t");
2167 was_explicit_key = 1;
2168 } else if (strncasecmp(cp, "sha1:", 5) == 0) {
2169 cp += 5;
2170 cp = cp + strspn(cp, " \t");
2171 was_sha1 = 1;
2172 } else {
2173 /*
2174 * Just try to process the line as a key.
2175 * Parsing will fail if it isn't.
2176 */
2177 }
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002178 if ((key = sshkey_new(KEY_UNSPEC)) == NULL)
markus@openbsd.org7da5df12017-05-30 14:16:41 +00002179 fatal("sshkey_new");
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002180 if ((r = sshkey_read(key, &cp)) != 0)
2181 fatal("%s:%lu: invalid key: %s",
2182 path, lnum, ssh_err(r));
Damien Millerf3747bf2013-01-18 11:44:04 +11002183 if (was_explicit_key)
2184 r = ssh_krl_revoke_key_explicit(krl, key);
2185 else if (was_sha1)
2186 r = ssh_krl_revoke_key_sha1(krl, key);
2187 else
2188 r = ssh_krl_revoke_key(krl, key);
2189 if (r != 0)
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002190 fatal("%s: revoke key failed: %s",
2191 __func__, ssh_err(r));
2192 sshkey_free(key);
Damien Millerf3747bf2013-01-18 11:44:04 +11002193 }
2194 }
2195 if (strcmp(path, "-") != 0)
2196 fclose(krl_spec);
Damien Miller0d6771b2013-04-23 15:23:24 +10002197 free(path);
Damien Millerf3747bf2013-01-18 11:44:04 +11002198}
2199
2200static void
2201do_gen_krl(struct passwd *pw, int updating, int argc, char **argv)
2202{
2203 struct ssh_krl *krl;
2204 struct stat sb;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002205 struct sshkey *ca = NULL;
djm@openbsd.org669aee92015-01-30 01:10:33 +00002206 int fd, i, r, wild_ca = 0;
Damien Millerf3747bf2013-01-18 11:44:04 +11002207 char *tmp;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002208 struct sshbuf *kbuf;
Damien Millerf3747bf2013-01-18 11:44:04 +11002209
2210 if (*identity_file == '\0')
2211 fatal("KRL generation requires an output file");
2212 if (stat(identity_file, &sb) == -1) {
2213 if (errno != ENOENT)
2214 fatal("Cannot access KRL \"%s\": %s",
2215 identity_file, strerror(errno));
2216 if (updating)
2217 fatal("KRL \"%s\" does not exist", identity_file);
2218 }
2219 if (ca_key_path != NULL) {
djm@openbsd.org669aee92015-01-30 01:10:33 +00002220 if (strcasecmp(ca_key_path, "none") == 0)
2221 wild_ca = 1;
2222 else {
2223 tmp = tilde_expand_filename(ca_key_path, pw->pw_uid);
2224 if ((r = sshkey_load_public(tmp, &ca, NULL)) != 0)
2225 fatal("Cannot load CA public key %s: %s",
2226 tmp, ssh_err(r));
2227 free(tmp);
2228 }
Damien Millerf3747bf2013-01-18 11:44:04 +11002229 }
2230
2231 if (updating)
2232 load_krl(identity_file, &krl);
2233 else if ((krl = ssh_krl_init()) == NULL)
2234 fatal("couldn't create KRL");
2235
2236 if (cert_serial != 0)
2237 ssh_krl_set_version(krl, cert_serial);
2238 if (identity_comment != NULL)
2239 ssh_krl_set_comment(krl, identity_comment);
2240
2241 for (i = 0; i < argc; i++)
djm@openbsd.org669aee92015-01-30 01:10:33 +00002242 update_krl_from_file(pw, argv[i], wild_ca, ca, krl);
Damien Millerf3747bf2013-01-18 11:44:04 +11002243
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002244 if ((kbuf = sshbuf_new()) == NULL)
2245 fatal("sshbuf_new failed");
2246 if (ssh_krl_to_blob(krl, kbuf, NULL, 0) != 0)
Damien Millerf3747bf2013-01-18 11:44:04 +11002247 fatal("Couldn't generate KRL");
2248 if ((fd = open(identity_file, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1)
2249 fatal("open %s: %s", identity_file, strerror(errno));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002250 if (atomicio(vwrite, fd, (void *)sshbuf_ptr(kbuf), sshbuf_len(kbuf)) !=
2251 sshbuf_len(kbuf))
Damien Millerf3747bf2013-01-18 11:44:04 +11002252 fatal("write %s: %s", identity_file, strerror(errno));
2253 close(fd);
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002254 sshbuf_free(kbuf);
Damien Millerf3747bf2013-01-18 11:44:04 +11002255 ssh_krl_free(krl);
mmcc@openbsd.org89540b62015-12-11 02:31:47 +00002256 sshkey_free(ca);
Damien Millerf3747bf2013-01-18 11:44:04 +11002257}
2258
2259static void
2260do_check_krl(struct passwd *pw, int argc, char **argv)
2261{
2262 int i, r, ret = 0;
2263 char *comment;
2264 struct ssh_krl *krl;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002265 struct sshkey *k;
Damien Millerf3747bf2013-01-18 11:44:04 +11002266
2267 if (*identity_file == '\0')
2268 fatal("KRL checking requires an input file");
2269 load_krl(identity_file, &krl);
2270 for (i = 0; i < argc; i++) {
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002271 if ((r = sshkey_load_public(argv[i], &k, &comment)) != 0)
2272 fatal("Cannot load public key %s: %s",
2273 argv[i], ssh_err(r));
Damien Millerf3747bf2013-01-18 11:44:04 +11002274 r = ssh_krl_check_key(krl, k);
2275 printf("%s%s%s%s: %s\n", argv[i],
2276 *comment ? " (" : "", comment, *comment ? ")" : "",
2277 r == 0 ? "ok" : "REVOKED");
2278 if (r != 0)
2279 ret = 1;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002280 sshkey_free(k);
Damien Millerf3747bf2013-01-18 11:44:04 +11002281 free(comment);
2282 }
2283 ssh_krl_free(krl);
2284 exit(ret);
2285}
2286
2287static void
Damien Miller431f66b1999-11-21 18:31:57 +11002288usage(void)
2289{
Damien Millerf0858de2014-04-20 13:01:30 +10002290 fprintf(stderr,
djm@openbsd.org873d3e72017-04-30 23:18:44 +00002291 "usage: ssh-keygen [-q] [-b bits] [-t dsa | ecdsa | ed25519 | rsa]\n"
Damien Millerf0858de2014-04-20 13:01:30 +10002292 " [-N new_passphrase] [-C comment] [-f output_keyfile]\n"
2293 " ssh-keygen -p [-P old_passphrase] [-N new_passphrase] [-f keyfile]\n"
2294 " ssh-keygen -i [-m key_format] [-f input_keyfile]\n"
2295 " ssh-keygen -e [-m key_format] [-f input_keyfile]\n"
2296 " ssh-keygen -y [-f input_keyfile]\n"
2297 " ssh-keygen -c [-P passphrase] [-C comment] [-f keyfile]\n"
naddy@openbsd.org6288e3a2015-02-24 15:24:05 +00002298 " ssh-keygen -l [-v] [-E fingerprint_hash] [-f input_keyfile]\n"
djm@openbsd.org873d3e72017-04-30 23:18:44 +00002299 " ssh-keygen -B [-f input_keyfile]\n");
Damien Miller7ea845e2010-02-12 09:21:02 +11002300#ifdef ENABLE_PKCS11
Damien Millerf0858de2014-04-20 13:01:30 +10002301 fprintf(stderr,
2302 " ssh-keygen -D pkcs11\n");
Damien Miller7ea845e2010-02-12 09:21:02 +11002303#endif
Damien Millerf0858de2014-04-20 13:01:30 +10002304 fprintf(stderr,
2305 " ssh-keygen -F hostname [-f known_hosts_file] [-l]\n"
2306 " ssh-keygen -H [-f known_hosts_file]\n"
2307 " ssh-keygen -R hostname [-f known_hosts_file]\n"
2308 " ssh-keygen -r hostname [-f input_keyfile] [-g]\n"
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +00002309#ifdef WITH_OPENSSL
Damien Millerf0858de2014-04-20 13:01:30 +10002310 " ssh-keygen -G output_file [-v] [-b bits] [-M memory] [-S start_point]\n"
2311 " ssh-keygen -T output_file -f input_file [-v] [-a rounds] [-J num_lines]\n"
2312 " [-j start_line] [-K checkpt] [-W generator]\n"
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +00002313#endif
djm@openbsd.orga98339e2017-06-28 01:09:22 +00002314 " ssh-keygen -s ca_key -I certificate_identity [-h] [-U]\n"
2315 " [-D pkcs11_provider] [-n principals] [-O option]\n"
2316 " [-V validity_interval] [-z serial_number] file ...\n"
Damien Millerf0858de2014-04-20 13:01:30 +10002317 " ssh-keygen -L [-f input_keyfile]\n"
2318 " ssh-keygen -A\n"
2319 " ssh-keygen -k -f krl_file [-u] [-s ca_public] [-z version_number]\n"
2320 " file ...\n"
2321 " ssh-keygen -Q -f krl_file file ...\n");
Damien Miller95def091999-11-25 00:26:21 +11002322 exit(1);
Damien Miller431f66b1999-11-21 18:31:57 +11002323}
2324
Damien Miller95def091999-11-25 00:26:21 +11002325/*
2326 * Main program for key management.
2327 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002328int
Damien Millerdf8b7db2007-01-05 16:22:57 +11002329main(int argc, char **argv)
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002330{
deraadt@openbsd.org2ae4f332015-01-16 06:40:12 +00002331 char dotsshdir[PATH_MAX], comment[1024], *passphrase1, *passphrase2;
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +00002332 char *rr_hostname = NULL, *ep, *fp, *ra;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002333 struct sshkey *private, *public;
Damien Miller95def091999-11-25 00:26:21 +11002334 struct passwd *pw;
Damien Miller95def091999-11-25 00:26:21 +11002335 struct stat st;
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002336 int r, opt, type, fd;
Damien Millerf3747bf2013-01-18 11:44:04 +11002337 int gen_all_hostkeys = 0, gen_krl = 0, update_krl = 0, check_krl = 0;
Damien Miller95def091999-11-25 00:26:21 +11002338 FILE *f;
Damien Miller02e754f2005-05-26 12:19:39 +10002339 const char *errstr;
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +00002340#ifdef WITH_OPENSSL
2341 /* Moduli generation/screening */
2342 char out_file[PATH_MAX], *checkpoint = NULL;
2343 u_int32_t memory = 0, generator_wanted = 0;
2344 int do_gen_candidates = 0, do_screen_candidates = 0;
2345 unsigned long start_lineno = 0, lines_to_process = 0;
2346 BIGNUM *start = NULL;
2347#endif
Damien Miller0bc1bd82000-11-13 22:57:25 +11002348
Damien Miller95def091999-11-25 00:26:21 +11002349 extern int optind;
2350 extern char *optarg;
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002351
dtucker@openbsd.orgffb1e7e2016-02-15 09:47:49 +00002352 ssh_malloc_init(); /* must be called before any mallocs */
Darren Tuckerce321d82005-10-03 18:11:24 +10002353 /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
2354 sanitise_stdfd();
2355
Darren Tucker9ac56e92007-01-14 10:19:59 +11002356 __progname = ssh_get_progname(argv[0]);
Damien Millerf9b625c2000-07-09 22:42:32 +10002357
Damien Miller72ef7c12015-01-15 02:21:31 +11002358#ifdef WITH_OPENSSL
Damien Miller4314c2b2010-09-10 11:12:09 +10002359 OpenSSL_add_all_algorithms();
Damien Miller72ef7c12015-01-15 02:21:31 +11002360#endif
Damien Millerdf8b7db2007-01-05 16:22:57 +11002361 log_init(argv[0], SYSLOG_LEVEL_INFO, SYSLOG_FACILITY_USER, 1);
Darren Tucker019cefe2003-08-02 22:40:07 +10002362
Kevin Steves3a881912002-07-20 19:05:40 +00002363 seed_rng();
Damien Millereba71ba2000-04-29 23:57:08 +10002364
djm@openbsd.orga287c5a2017-02-10 03:36:40 +00002365 msetlocale();
2366
Damien Miller5428f641999-11-25 11:54:57 +11002367 /* we need this for the home * directory. */
Damien Miller95def091999-11-25 00:26:21 +11002368 pw = getpwuid(getuid());
djm@openbsd.org3038a192015-04-17 13:19:22 +00002369 if (!pw)
2370 fatal("No user exists for uid %lu", (u_long)getuid());
2371 if (gethostname(hostname, sizeof(hostname)) < 0)
2372 fatal("gethostname: %s", strerror(errno));
Damien Miller5428f641999-11-25 11:54:57 +11002373
djm@openbsd.orga98339e2017-06-28 01:09:22 +00002374 /* Remaining characters: Ydw */
2375 while ((opt = getopt(argc, argv, "ABHLQUXceghiklopquvxy"
djm@openbsd.org56d1c832014-12-21 22:27:55 +00002376 "C:D:E:F:G:I:J:K:M:N:O:P:R:S:T:V:W:Z:"
2377 "a:b:f:g:j:m:n:r:s:t:z:")) != -1) {
Damien Miller95def091999-11-25 00:26:21 +11002378 switch (opt) {
Damien Miller58f1baf2011-05-05 14:06:15 +10002379 case 'A':
2380 gen_all_hostkeys = 1;
2381 break;
Damien Miller95def091999-11-25 00:26:21 +11002382 case 'b':
markus@openbsd.org1b11ea72018-02-23 15:58:37 +00002383 bits = (u_int32_t)strtonum(optarg, 10, 32768, &errstr);
Damien Miller02e754f2005-05-26 12:19:39 +10002384 if (errstr)
2385 fatal("Bits has bad value %s (%s)",
2386 optarg, errstr);
Damien Miller95def091999-11-25 00:26:21 +11002387 break;
djm@openbsd.org56d1c832014-12-21 22:27:55 +00002388 case 'E':
2389 fingerprint_hash = ssh_digest_alg_by_name(optarg);
2390 if (fingerprint_hash == -1)
2391 fatal("Invalid hash algorithm \"%s\"", optarg);
2392 break;
Damien Miller4b42d7f2005-03-01 21:48:35 +11002393 case 'F':
2394 find_host = 1;
2395 rr_hostname = optarg;
2396 break;
2397 case 'H':
2398 hash_hosts = 1;
2399 break;
Damien Miller0a80ca12010-02-27 07:55:05 +11002400 case 'I':
2401 cert_key_id = optarg;
2402 break;
Damien Miller4b42d7f2005-03-01 21:48:35 +11002403 case 'R':
2404 delete_host = 1;
2405 rr_hostname = optarg;
2406 break;
Damien Millerf2b70ca2010-03-05 07:39:35 +11002407 case 'L':
2408 show_cert = 1;
2409 break;
Damien Miller95def091999-11-25 00:26:21 +11002410 case 'l':
2411 print_fingerprint = 1;
2412 break;
Ben Lindstrom8fd372b2001-03-12 03:02:17 +00002413 case 'B':
2414 print_bubblebabble = 1;
2415 break;
Damien Miller44b25042010-07-02 13:35:01 +10002416 case 'm':
2417 if (strcasecmp(optarg, "RFC4716") == 0 ||
2418 strcasecmp(optarg, "ssh2") == 0) {
2419 convert_format = FMT_RFC4716;
2420 break;
2421 }
2422 if (strcasecmp(optarg, "PKCS8") == 0) {
2423 convert_format = FMT_PKCS8;
2424 break;
2425 }
2426 if (strcasecmp(optarg, "PEM") == 0) {
2427 convert_format = FMT_PEM;
2428 break;
2429 }
2430 fatal("Unsupported conversion format \"%s\"", optarg);
Damien Miller0a80ca12010-02-27 07:55:05 +11002431 case 'n':
2432 cert_principals = optarg;
2433 break;
Damien Millerbcd00ab2013-12-07 10:41:55 +11002434 case 'o':
2435 use_new_format = 1;
2436 break;
Damien Miller95def091999-11-25 00:26:21 +11002437 case 'p':
2438 change_passphrase = 1;
2439 break;
Damien Miller95def091999-11-25 00:26:21 +11002440 case 'c':
2441 change_comment = 1;
2442 break;
Damien Miller95def091999-11-25 00:26:21 +11002443 case 'f':
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +00002444 if (strlcpy(identity_file, optarg,
2445 sizeof(identity_file)) >= sizeof(identity_file))
Damien Millerb089fb52005-05-26 12:16:18 +10002446 fatal("Identity filename too long");
Damien Miller95def091999-11-25 00:26:21 +11002447 have_identity = 1;
2448 break;
Damien Miller37876e92003-05-15 10:19:46 +10002449 case 'g':
2450 print_generic = 1;
2451 break;
Damien Miller95def091999-11-25 00:26:21 +11002452 case 'P':
2453 identity_passphrase = optarg;
2454 break;
Damien Miller95def091999-11-25 00:26:21 +11002455 case 'N':
2456 identity_new_passphrase = optarg;
2457 break;
Damien Millerf3747bf2013-01-18 11:44:04 +11002458 case 'Q':
2459 check_krl = 1;
2460 break;
Damien Miller0a80ca12010-02-27 07:55:05 +11002461 case 'O':
Damien Miller4e270b02010-04-16 15:56:21 +10002462 add_cert_option(optarg);
Damien Miller0a80ca12010-02-27 07:55:05 +11002463 break;
Damien Millerbcd00ab2013-12-07 10:41:55 +11002464 case 'Z':
2465 new_format_cipher = optarg;
2466 break;
Damien Miller95def091999-11-25 00:26:21 +11002467 case 'C':
2468 identity_comment = optarg;
2469 break;
Damien Miller95def091999-11-25 00:26:21 +11002470 case 'q':
2471 quiet = 1;
2472 break;
Ben Lindstrom5a707822001-04-22 17:15:46 +00002473 case 'e':
Damien Millereba71ba2000-04-29 23:57:08 +10002474 case 'x':
Ben Lindstrom5a707822001-04-22 17:15:46 +00002475 /* export key */
Damien Miller44b25042010-07-02 13:35:01 +10002476 convert_to = 1;
Damien Millereba71ba2000-04-29 23:57:08 +10002477 break;
Damien Miller0a80ca12010-02-27 07:55:05 +11002478 case 'h':
2479 cert_key_type = SSH2_CERT_TYPE_HOST;
Damien Millerd0e4a8e2010-05-21 14:58:32 +10002480 certflags_flags = 0;
Damien Miller0a80ca12010-02-27 07:55:05 +11002481 break;
Damien Millerf3747bf2013-01-18 11:44:04 +11002482 case 'k':
2483 gen_krl = 1;
2484 break;
Ben Lindstrom5a707822001-04-22 17:15:46 +00002485 case 'i':
Damien Millereba71ba2000-04-29 23:57:08 +10002486 case 'X':
Ben Lindstrom5a707822001-04-22 17:15:46 +00002487 /* import key */
Damien Miller44b25042010-07-02 13:35:01 +10002488 convert_from = 1;
Damien Millereba71ba2000-04-29 23:57:08 +10002489 break;
Damien Millereba71ba2000-04-29 23:57:08 +10002490 case 'y':
2491 print_public = 1;
2492 break;
Damien Miller0a80ca12010-02-27 07:55:05 +11002493 case 's':
2494 ca_key_path = optarg;
2495 break;
Damien Miller0bc1bd82000-11-13 22:57:25 +11002496 case 't':
2497 key_type_name = optarg;
Damien Miller0bc1bd82000-11-13 22:57:25 +11002498 break;
Ben Lindstrom8282d6a2001-08-06 21:44:05 +00002499 case 'D':
Damien Miller7ea845e2010-02-12 09:21:02 +11002500 pkcs11provider = optarg;
Ben Lindstromcd392282001-07-04 03:44:03 +00002501 break;
djm@openbsd.orga98339e2017-06-28 01:09:22 +00002502 case 'U':
2503 prefer_agent = 1;
2504 break;
Damien Millerf3747bf2013-01-18 11:44:04 +11002505 case 'u':
2506 update_krl = 1;
2507 break;
Darren Tucker06930c72003-12-31 11:34:51 +11002508 case 'v':
2509 if (log_level == SYSLOG_LEVEL_INFO)
2510 log_level = SYSLOG_LEVEL_DEBUG1;
2511 else {
Darren Tuckerfc959702004-07-17 16:12:08 +10002512 if (log_level >= SYSLOG_LEVEL_DEBUG1 &&
Darren Tucker06930c72003-12-31 11:34:51 +11002513 log_level < SYSLOG_LEVEL_DEBUG3)
2514 log_level++;
2515 }
2516 break;
Damien Miller37876e92003-05-15 10:19:46 +10002517 case 'r':
Damien Miller4b42d7f2005-03-01 21:48:35 +11002518 rr_hostname = optarg;
Damien Miller37876e92003-05-15 10:19:46 +10002519 break;
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +00002520 case 'a':
2521 rounds = (int)strtonum(optarg, 1, INT_MAX, &errstr);
2522 if (errstr)
2523 fatal("Invalid number: %s (%s)",
2524 optarg, errstr);
2525 break;
2526 case 'V':
2527 parse_cert_times(optarg);
2528 break;
2529 case 'z':
2530 errno = 0;
2531 cert_serial = strtoull(optarg, &ep, 10);
2532 if (*optarg < '0' || *optarg > '9' || *ep != '\0' ||
2533 (errno == ERANGE && cert_serial == ULLONG_MAX))
2534 fatal("Invalid serial number \"%s\"", optarg);
2535 break;
2536#ifdef WITH_OPENSSL
2537 /* Moduli generation/screening */
Darren Tucker019cefe2003-08-02 22:40:07 +10002538 case 'G':
2539 do_gen_candidates = 1;
Damien Millerb089fb52005-05-26 12:16:18 +10002540 if (strlcpy(out_file, optarg, sizeof(out_file)) >=
2541 sizeof(out_file))
2542 fatal("Output filename too long");
Darren Tucker019cefe2003-08-02 22:40:07 +10002543 break;
Darren Tucker0bb29802016-09-12 11:07:00 +10002544 case 'J':
2545 lines_to_process = strtoul(optarg, NULL, 10);
dtucker@openbsd.org7b63cf62016-09-12 03:29:16 +00002546 break;
Darren Tucker0bb29802016-09-12 11:07:00 +10002547 case 'j':
2548 start_lineno = strtoul(optarg, NULL, 10);
dtucker@openbsd.org7b63cf62016-09-12 03:29:16 +00002549 break;
Damien Miller390d0562011-10-18 16:05:19 +11002550 case 'K':
deraadt@openbsd.org2ae4f332015-01-16 06:40:12 +00002551 if (strlen(optarg) >= PATH_MAX)
Damien Miller390d0562011-10-18 16:05:19 +11002552 fatal("Checkpoint filename too long");
2553 checkpoint = xstrdup(optarg);
2554 break;
Darren Tuckerd8c3cfb2016-09-12 13:30:50 +10002555 case 'M':
2556 memory = (u_int32_t)strtonum(optarg, 1, UINT_MAX,
2557 &errstr);
2558 if (errstr)
2559 fatal("Memory limit is %s: %s", errstr, optarg);
2560 break;
Darren Tucker019cefe2003-08-02 22:40:07 +10002561 case 'S':
2562 /* XXX - also compare length against bits */
2563 if (BN_hex2bn(&start, optarg) == 0)
2564 fatal("Invalid start point.");
2565 break;
Darren Tuckeraf48d542016-09-12 13:52:17 +10002566 case 'T':
2567 do_screen_candidates = 1;
2568 if (strlcpy(out_file, optarg, sizeof(out_file)) >=
2569 sizeof(out_file))
2570 fatal("Output filename too long");
2571 break;
Darren Tucker43cceff2016-09-12 13:55:37 +10002572 case 'W':
2573 generator_wanted = (u_int32_t)strtonum(optarg, 1,
2574 UINT_MAX, &errstr);
Darren Tucker70508962016-09-12 13:57:28 +10002575 if (errstr != NULL)
2576 fatal("Desired generator invalid: %s (%s)",
2577 optarg, errstr);
Darren Tucker43cceff2016-09-12 13:55:37 +10002578 break;
Damien Miller72ef7c12015-01-15 02:21:31 +11002579#endif /* WITH_OPENSSL */
Damien Miller95def091999-11-25 00:26:21 +11002580 case '?':
2581 default:
2582 usage();
2583 }
2584 }
Darren Tucker06930c72003-12-31 11:34:51 +11002585
2586 /* reinit */
Damien Millerdf8b7db2007-01-05 16:22:57 +11002587 log_init(argv[0], log_level, SYSLOG_FACILITY_USER, 1);
Darren Tucker06930c72003-12-31 11:34:51 +11002588
Damien Miller0a80ca12010-02-27 07:55:05 +11002589 argv += optind;
2590 argc -= optind;
2591
2592 if (ca_key_path != NULL) {
Damien Millerf3747bf2013-01-18 11:44:04 +11002593 if (argc < 1 && !gen_krl) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00002594 error("Too few arguments.");
Damien Miller0a80ca12010-02-27 07:55:05 +11002595 usage();
2596 }
Damien Millerf3747bf2013-01-18 11:44:04 +11002597 } else if (argc > 0 && !gen_krl && !check_krl) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00002598 error("Too many arguments.");
Damien Miller95def091999-11-25 00:26:21 +11002599 usage();
2600 }
2601 if (change_passphrase && change_comment) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00002602 error("Can only have one of -p and -c.");
Damien Miller95def091999-11-25 00:26:21 +11002603 usage();
2604 }
Darren Tucker0f7e9102008-06-08 12:54:29 +10002605 if (print_fingerprint && (delete_host || hash_hosts)) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00002606 error("Cannot use -l with -H or -R.");
Darren Tucker0f7e9102008-06-08 12:54:29 +10002607 usage();
2608 }
Damien Millerf3747bf2013-01-18 11:44:04 +11002609 if (gen_krl) {
2610 do_gen_krl(pw, update_krl, argc, argv);
2611 return (0);
2612 }
2613 if (check_krl) {
2614 do_check_krl(pw, argc, argv);
2615 return (0);
2616 }
Damien Miller0a80ca12010-02-27 07:55:05 +11002617 if (ca_key_path != NULL) {
2618 if (cert_key_id == NULL)
2619 fatal("Must specify key id (-I) when certifying");
2620 do_ca_sign(pw, argc, argv);
2621 }
Damien Millerf2b70ca2010-03-05 07:39:35 +11002622 if (show_cert)
2623 do_show_cert(pw);
Damien Miller4b42d7f2005-03-01 21:48:35 +11002624 if (delete_host || hash_hosts || find_host)
2625 do_known_hosts(pw, rr_hostname);
Damien Millerec77c952013-01-09 15:58:00 +11002626 if (pkcs11provider != NULL)
2627 do_download(pw);
Ben Lindstrom8fd372b2001-03-12 03:02:17 +00002628 if (print_fingerprint || print_bubblebabble)
Damien Miller95def091999-11-25 00:26:21 +11002629 do_fingerprint(pw);
Damien Miller95def091999-11-25 00:26:21 +11002630 if (change_passphrase)
2631 do_change_passphrase(pw);
Damien Miller4a10d2e2002-03-11 22:53:29 +11002632 if (change_comment)
2633 do_change_comment(pw);
Damien Miller1f0311c2014-05-15 14:24:09 +10002634#ifdef WITH_OPENSSL
Damien Miller44b25042010-07-02 13:35:01 +10002635 if (convert_to)
2636 do_convert_to(pw);
2637 if (convert_from)
2638 do_convert_from(pw);
Damien Miller1f0311c2014-05-15 14:24:09 +10002639#endif
Damien Millereba71ba2000-04-29 23:57:08 +10002640 if (print_public)
2641 do_print_public(pw);
Damien Miller4b42d7f2005-03-01 21:48:35 +11002642 if (rr_hostname != NULL) {
Damien Millercb314822006-03-26 13:48:01 +11002643 unsigned int n = 0;
2644
2645 if (have_identity) {
2646 n = do_print_resource_record(pw,
2647 identity_file, rr_hostname);
djm@openbsd.org3038a192015-04-17 13:19:22 +00002648 if (n == 0)
2649 fatal("%s: %s", identity_file, strerror(errno));
Damien Millercb314822006-03-26 13:48:01 +11002650 exit(0);
2651 } else {
2652
2653 n += do_print_resource_record(pw,
2654 _PATH_HOST_RSA_KEY_FILE, rr_hostname);
2655 n += do_print_resource_record(pw,
2656 _PATH_HOST_DSA_KEY_FILE, rr_hostname);
Damien Miller3bde12a2012-06-20 21:51:11 +10002657 n += do_print_resource_record(pw,
2658 _PATH_HOST_ECDSA_KEY_FILE, rr_hostname);
Damien Miller16cd3922014-05-15 13:45:58 +10002659 n += do_print_resource_record(pw,
2660 _PATH_HOST_ED25519_KEY_FILE, rr_hostname);
markus@openbsd.org1b11ea72018-02-23 15:58:37 +00002661 n += do_print_resource_record(pw,
2662 _PATH_HOST_XMSS_KEY_FILE, rr_hostname);
Damien Millercb314822006-03-26 13:48:01 +11002663 if (n == 0)
2664 fatal("no keys found.");
2665 exit(0);
2666 }
Damien Miller37876e92003-05-15 10:19:46 +10002667 }
Damien Miller95def091999-11-25 00:26:21 +11002668
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +00002669#ifdef WITH_OPENSSL
Darren Tucker019cefe2003-08-02 22:40:07 +10002670 if (do_gen_candidates) {
2671 FILE *out = fopen(out_file, "w");
Damien Miller787b2ec2003-11-21 23:56:47 +11002672
Darren Tucker019cefe2003-08-02 22:40:07 +10002673 if (out == NULL) {
2674 error("Couldn't open modulus candidate file \"%s\": %s",
2675 out_file, strerror(errno));
2676 return (1);
2677 }
Damien Miller3f54a9f2005-11-05 14:52:18 +11002678 if (bits == 0)
2679 bits = DEFAULT_BITS;
Darren Tucker019cefe2003-08-02 22:40:07 +10002680 if (gen_candidates(out, memory, bits, start) != 0)
Damien Miller15d72a02005-11-05 15:07:33 +11002681 fatal("modulus candidate generation failed");
Darren Tucker019cefe2003-08-02 22:40:07 +10002682
2683 return (0);
2684 }
2685
2686 if (do_screen_candidates) {
2687 FILE *in;
Damien Miller78d22712013-02-12 11:03:36 +11002688 FILE *out = fopen(out_file, "a");
Darren Tucker019cefe2003-08-02 22:40:07 +10002689
2690 if (have_identity && strcmp(identity_file, "-") != 0) {
2691 if ((in = fopen(identity_file, "r")) == NULL) {
2692 fatal("Couldn't open modulus candidate "
Damien Millera8e06ce2003-11-21 23:48:55 +11002693 "file \"%s\": %s", identity_file,
Darren Tucker019cefe2003-08-02 22:40:07 +10002694 strerror(errno));
2695 }
2696 } else
2697 in = stdin;
2698
2699 if (out == NULL) {
2700 fatal("Couldn't open moduli file \"%s\": %s",
2701 out_file, strerror(errno));
2702 }
Damien Millerbcd00ab2013-12-07 10:41:55 +11002703 if (prime_test(in, out, rounds == 0 ? 100 : rounds,
2704 generator_wanted, checkpoint,
Damien Millerdfceafe2012-07-06 13:44:19 +10002705 start_lineno, lines_to_process) != 0)
Damien Miller15d72a02005-11-05 15:07:33 +11002706 fatal("modulus screening failed");
Darren Tuckerf4220e62003-08-21 16:44:07 +10002707 return (0);
Darren Tucker019cefe2003-08-02 22:40:07 +10002708 }
djm@openbsd.org1d9a2e22015-05-28 07:37:31 +00002709#endif
Darren Tucker019cefe2003-08-02 22:40:07 +10002710
Damien Miller58f1baf2011-05-05 14:06:15 +10002711 if (gen_all_hostkeys) {
2712 do_gen_all_hostkeys(pw);
2713 return (0);
2714 }
2715
Damien Millerf14be5c2005-11-05 15:15:49 +11002716 if (key_type_name == NULL)
djm@openbsd.orgd1958792015-05-28 04:40:13 +00002717 key_type_name = DEFAULT_KEY_TYPE_NAME;
Damien Millerf14be5c2005-11-05 15:15:49 +11002718
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002719 type = sshkey_type_from_name(key_type_name);
djm@openbsd.org7efb4552015-01-18 13:22:28 +00002720 type_bits_valid(type, key_type_name, &bits);
Damien Miller58f1baf2011-05-05 14:06:15 +10002721
Darren Tucker3af2ac52005-11-29 13:10:24 +11002722 if (!quiet)
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002723 printf("Generating public/private %s key pair.\n",
2724 key_type_name);
djm@openbsd.org3038a192015-04-17 13:19:22 +00002725 if ((r = sshkey_generate(type, bits, &private)) != 0)
markus@openbsd.org7da5df12017-05-30 14:16:41 +00002726 fatal("sshkey_generate failed");
djm@openbsd.org3038a192015-04-17 13:19:22 +00002727 if ((r = sshkey_from_private(private, &public)) != 0)
markus@openbsd.org7da5df12017-05-30 14:16:41 +00002728 fatal("sshkey_from_private failed: %s\n", ssh_err(r));
Damien Miller95def091999-11-25 00:26:21 +11002729
2730 if (!have_identity)
2731 ask_filename(pw, "Enter file in which to save the key");
2732
Damien Miller788f2122005-11-05 15:14:59 +11002733 /* Create ~/.ssh directory if it doesn't already exist. */
Damien Miller50af79b2010-05-10 11:52:00 +10002734 snprintf(dotsshdir, sizeof dotsshdir, "%s/%s",
2735 pw->pw_dir, _PATH_SSH_USER_DIR);
2736 if (strstr(identity_file, dotsshdir) != NULL) {
2737 if (stat(dotsshdir, &st) < 0) {
2738 if (errno != ENOENT) {
2739 error("Could not stat %s: %s", dotsshdir,
2740 strerror(errno));
2741 } else if (mkdir(dotsshdir, 0700) < 0) {
2742 error("Could not create directory '%s': %s",
2743 dotsshdir, strerror(errno));
2744 } else if (!quiet)
2745 printf("Created directory '%s'.\n", dotsshdir);
2746 }
Damien Miller95def091999-11-25 00:26:21 +11002747 }
2748 /* If the file already exists, ask the user to confirm. */
2749 if (stat(identity_file, &st) >= 0) {
2750 char yesno[3];
2751 printf("%s already exists.\n", identity_file);
2752 printf("Overwrite (y/n)? ");
2753 fflush(stdout);
2754 if (fgets(yesno, sizeof(yesno), stdin) == NULL)
2755 exit(1);
2756 if (yesno[0] != 'y' && yesno[0] != 'Y')
2757 exit(1);
2758 }
2759 /* Ask for a passphrase (twice). */
2760 if (identity_passphrase)
2761 passphrase1 = xstrdup(identity_passphrase);
2762 else if (identity_new_passphrase)
2763 passphrase1 = xstrdup(identity_new_passphrase);
2764 else {
2765passphrase_again:
2766 passphrase1 =
Ben Lindstrom949974b2001-06-25 05:20:31 +00002767 read_passphrase("Enter passphrase (empty for no "
2768 "passphrase): ", RP_ALLOW_STDIN);
2769 passphrase2 = read_passphrase("Enter same passphrase again: ",
2770 RP_ALLOW_STDIN);
Damien Miller95def091999-11-25 00:26:21 +11002771 if (strcmp(passphrase1, passphrase2) != 0) {
Ben Lindstrom949974b2001-06-25 05:20:31 +00002772 /*
2773 * The passphrases do not match. Clear them and
2774 * retry.
2775 */
Damien Millera5103f42014-02-04 11:20:14 +11002776 explicit_bzero(passphrase1, strlen(passphrase1));
2777 explicit_bzero(passphrase2, strlen(passphrase2));
Darren Tuckera627d422013-06-02 07:31:17 +10002778 free(passphrase1);
2779 free(passphrase2);
Damien Miller95def091999-11-25 00:26:21 +11002780 printf("Passphrases do not match. Try again.\n");
2781 goto passphrase_again;
2782 }
2783 /* Clear the other copy of the passphrase. */
Damien Millera5103f42014-02-04 11:20:14 +11002784 explicit_bzero(passphrase2, strlen(passphrase2));
Darren Tuckera627d422013-06-02 07:31:17 +10002785 free(passphrase2);
Damien Miller95def091999-11-25 00:26:21 +11002786 }
2787
Damien Miller95def091999-11-25 00:26:21 +11002788 if (identity_comment) {
2789 strlcpy(comment, identity_comment, sizeof(comment));
2790 } else {
Darren Tuckere15fb092008-11-11 16:31:43 +11002791 /* Create default comment field for the passphrase. */
Damien Miller95def091999-11-25 00:26:21 +11002792 snprintf(comment, sizeof comment, "%s@%s", pw->pw_name, hostname);
2793 }
2794
2795 /* Save the key with the given passphrase and comment. */
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002796 if ((r = sshkey_save_private(private, identity_file, passphrase1,
2797 comment, use_new_format, new_format_cipher, rounds)) != 0) {
djm@openbsd.org3038a192015-04-17 13:19:22 +00002798 error("Saving key \"%s\" failed: %s",
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002799 identity_file, ssh_err(r));
Damien Millera5103f42014-02-04 11:20:14 +11002800 explicit_bzero(passphrase1, strlen(passphrase1));
Darren Tuckera627d422013-06-02 07:31:17 +10002801 free(passphrase1);
Damien Miller95def091999-11-25 00:26:21 +11002802 exit(1);
2803 }
2804 /* Clear the passphrase. */
Damien Millera5103f42014-02-04 11:20:14 +11002805 explicit_bzero(passphrase1, strlen(passphrase1));
Darren Tuckera627d422013-06-02 07:31:17 +10002806 free(passphrase1);
Damien Miller95def091999-11-25 00:26:21 +11002807
2808 /* Clear the private key and the random number generator. */
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002809 sshkey_free(private);
Damien Miller95def091999-11-25 00:26:21 +11002810
2811 if (!quiet)
2812 printf("Your identification has been saved in %s.\n", identity_file);
2813
Damien Miller95def091999-11-25 00:26:21 +11002814 strlcat(identity_file, ".pub", sizeof(identity_file));
djm@openbsd.org3038a192015-04-17 13:19:22 +00002815 if ((fd = open(identity_file, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1)
2816 fatal("Unable to save public key to %s: %s",
2817 identity_file, strerror(errno));
2818 if ((f = fdopen(fd, "w")) == NULL)
2819 fatal("fdopen %s failed: %s", identity_file, strerror(errno));
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002820 if ((r = sshkey_write(public, f)) != 0)
djm@openbsd.org3038a192015-04-17 13:19:22 +00002821 error("write key failed: %s", ssh_err(r));
Damien Millereba71ba2000-04-29 23:57:08 +10002822 fprintf(f, " %s\n", comment);
djm@openbsd.orgb56ac062018-02-10 05:43:26 +00002823 if (ferror(f) || fclose(f) != 0)
2824 fatal("write public failed: %s", strerror(errno));
Damien Miller95def091999-11-25 00:26:21 +11002825
2826 if (!quiet) {
djm@openbsd.org9ce86c92015-01-28 22:36:00 +00002827 fp = sshkey_fingerprint(public, fingerprint_hash,
djm@openbsd.org56d1c832014-12-21 22:27:55 +00002828 SSH_FP_DEFAULT);
djm@openbsd.org9ce86c92015-01-28 22:36:00 +00002829 ra = sshkey_fingerprint(public, fingerprint_hash,
Darren Tucker9c16ac92008-06-13 04:40:35 +10002830 SSH_FP_RANDOMART);
djm@openbsd.org9ce86c92015-01-28 22:36:00 +00002831 if (fp == NULL || ra == NULL)
2832 fatal("sshkey_fingerprint failed");
Damien Millereba71ba2000-04-29 23:57:08 +10002833 printf("Your public key has been saved in %s.\n",
2834 identity_file);
Damien Miller95def091999-11-25 00:26:21 +11002835 printf("The key fingerprint is:\n");
Ben Lindstromcfccef92001-03-13 04:57:58 +00002836 printf("%s %s\n", fp, comment);
Darren Tucker9c16ac92008-06-13 04:40:35 +10002837 printf("The key's randomart image is:\n");
2838 printf("%s\n", ra);
Darren Tuckera627d422013-06-02 07:31:17 +10002839 free(ra);
2840 free(fp);
Damien Miller95def091999-11-25 00:26:21 +11002841 }
Damien Millereba71ba2000-04-29 23:57:08 +10002842
djm@openbsd.org1129dcf2015-01-15 09:40:00 +00002843 sshkey_free(public);
Damien Miller95def091999-11-25 00:26:21 +11002844 exit(0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002845}