blob: 323e6ff84bfddeee1a2ca2228c389db6a6d5feda [file] [log] [blame]
Damien Miller450a7a12000-03-26 13:04:51 +10001/*
Damien Millere4340be2000-09-16 13:29:08 +11002 * read_bignum():
3 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
4 *
5 * As far as I am concerned, the code I have written for this software
6 * can be used freely for any purpose. Any derived versions of this
7 * software must be clearly marked as such, and if the derived work is
8 * incompatible with the protocol description in the RFC file, it must be
9 * called by a name other than "ssh" or "Secure Shell".
10 *
11 *
Ben Lindstrom44697232001-07-04 03:32:30 +000012 * Copyright (c) 2000, 2001 Markus Friedl. All rights reserved.
Damien Miller450a7a12000-03-26 13:04:51 +100013 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
16 * are met:
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in the
21 * documentation and/or other materials provided with the distribution.
Damien Miller450a7a12000-03-26 13:04:51 +100022 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
Damien Miller450a7a12000-03-26 13:04:51 +100034#include "includes.h"
Damien Millerf58b58c2003-11-17 21:18:23 +110035RCSID("$OpenBSD: key.c,v 1.55 2003/11/10 16:23:41 jakob Exp $");
Ben Lindstrom226cfa02001-01-22 05:34:40 +000036
Damien Miller450a7a12000-03-26 13:04:51 +100037#include <openssl/evp.h>
Ben Lindstrom226cfa02001-01-22 05:34:40 +000038
Damien Miller450a7a12000-03-26 13:04:51 +100039#include "xmalloc.h"
40#include "key.h"
Damien Miller0bc1bd82000-11-13 22:57:25 +110041#include "rsa.h"
Damien Millereba71ba2000-04-29 23:57:08 +100042#include "uuencode.h"
Damien Miller0bc1bd82000-11-13 22:57:25 +110043#include "buffer.h"
44#include "bufaux.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000045#include "log.h"
Damien Miller450a7a12000-03-26 13:04:51 +100046
47Key *
48key_new(int type)
49{
50 Key *k;
51 RSA *rsa;
52 DSA *dsa;
53 k = xmalloc(sizeof(*k));
54 k->type = type;
Ben Lindstromc5b68002001-07-04 04:52:03 +000055 k->flags = 0;
Damien Millereba71ba2000-04-29 23:57:08 +100056 k->dsa = NULL;
57 k->rsa = NULL;
Damien Miller450a7a12000-03-26 13:04:51 +100058 switch (k->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +110059 case KEY_RSA1:
Damien Miller450a7a12000-03-26 13:04:51 +100060 case KEY_RSA:
Damien Millerda755162002-01-22 23:09:22 +110061 if ((rsa = RSA_new()) == NULL)
62 fatal("key_new: RSA_new failed");
63 if ((rsa->n = BN_new()) == NULL)
64 fatal("key_new: BN_new failed");
65 if ((rsa->e = BN_new()) == NULL)
66 fatal("key_new: BN_new failed");
Damien Miller450a7a12000-03-26 13:04:51 +100067 k->rsa = rsa;
68 break;
69 case KEY_DSA:
Damien Millerda755162002-01-22 23:09:22 +110070 if ((dsa = DSA_new()) == NULL)
71 fatal("key_new: DSA_new failed");
72 if ((dsa->p = BN_new()) == NULL)
73 fatal("key_new: BN_new failed");
74 if ((dsa->q = BN_new()) == NULL)
75 fatal("key_new: BN_new failed");
76 if ((dsa->g = BN_new()) == NULL)
77 fatal("key_new: BN_new failed");
78 if ((dsa->pub_key = BN_new()) == NULL)
79 fatal("key_new: BN_new failed");
Damien Miller450a7a12000-03-26 13:04:51 +100080 k->dsa = dsa;
81 break;
Damien Miller0bc1bd82000-11-13 22:57:25 +110082 case KEY_UNSPEC:
Damien Miller450a7a12000-03-26 13:04:51 +100083 break;
84 default:
85 fatal("key_new: bad key type %d", k->type);
86 break;
87 }
88 return k;
89}
Ben Lindstrom836f0e92002-06-23 21:21:30 +000090
Damien Miller0bc1bd82000-11-13 22:57:25 +110091Key *
92key_new_private(int type)
93{
94 Key *k = key_new(type);
95 switch (k->type) {
96 case KEY_RSA1:
97 case KEY_RSA:
Damien Millerda755162002-01-22 23:09:22 +110098 if ((k->rsa->d = BN_new()) == NULL)
99 fatal("key_new_private: BN_new failed");
100 if ((k->rsa->iqmp = BN_new()) == NULL)
101 fatal("key_new_private: BN_new failed");
102 if ((k->rsa->q = BN_new()) == NULL)
103 fatal("key_new_private: BN_new failed");
104 if ((k->rsa->p = BN_new()) == NULL)
105 fatal("key_new_private: BN_new failed");
106 if ((k->rsa->dmq1 = BN_new()) == NULL)
107 fatal("key_new_private: BN_new failed");
108 if ((k->rsa->dmp1 = BN_new()) == NULL)
109 fatal("key_new_private: BN_new failed");
Damien Miller0bc1bd82000-11-13 22:57:25 +1100110 break;
111 case KEY_DSA:
Damien Millerda755162002-01-22 23:09:22 +1100112 if ((k->dsa->priv_key = BN_new()) == NULL)
113 fatal("key_new_private: BN_new failed");
Damien Miller0bc1bd82000-11-13 22:57:25 +1100114 break;
115 case KEY_UNSPEC:
116 break;
117 default:
118 break;
119 }
120 return k;
121}
Ben Lindstrom836f0e92002-06-23 21:21:30 +0000122
Damien Miller450a7a12000-03-26 13:04:51 +1000123void
124key_free(Key *k)
125{
126 switch (k->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100127 case KEY_RSA1:
Damien Miller450a7a12000-03-26 13:04:51 +1000128 case KEY_RSA:
129 if (k->rsa != NULL)
130 RSA_free(k->rsa);
131 k->rsa = NULL;
132 break;
133 case KEY_DSA:
134 if (k->dsa != NULL)
135 DSA_free(k->dsa);
136 k->dsa = NULL;
137 break;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100138 case KEY_UNSPEC:
139 break;
Damien Miller450a7a12000-03-26 13:04:51 +1000140 default:
141 fatal("key_free: bad key type %d", k->type);
142 break;
143 }
144 xfree(k);
145}
Damien Millerf58b58c2003-11-17 21:18:23 +1100146
Damien Miller450a7a12000-03-26 13:04:51 +1000147int
Damien Millerf58b58c2003-11-17 21:18:23 +1100148key_equal(const Key *a, const Key *b)
Damien Miller450a7a12000-03-26 13:04:51 +1000149{
150 if (a == NULL || b == NULL || a->type != b->type)
151 return 0;
152 switch (a->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100153 case KEY_RSA1:
Damien Miller450a7a12000-03-26 13:04:51 +1000154 case KEY_RSA:
155 return a->rsa != NULL && b->rsa != NULL &&
156 BN_cmp(a->rsa->e, b->rsa->e) == 0 &&
157 BN_cmp(a->rsa->n, b->rsa->n) == 0;
158 break;
159 case KEY_DSA:
160 return a->dsa != NULL && b->dsa != NULL &&
161 BN_cmp(a->dsa->p, b->dsa->p) == 0 &&
162 BN_cmp(a->dsa->q, b->dsa->q) == 0 &&
163 BN_cmp(a->dsa->g, b->dsa->g) == 0 &&
164 BN_cmp(a->dsa->pub_key, b->dsa->pub_key) == 0;
165 break;
166 default:
Damien Millereba71ba2000-04-29 23:57:08 +1000167 fatal("key_equal: bad key type %d", a->type);
Damien Miller450a7a12000-03-26 13:04:51 +1000168 break;
169 }
170 return 0;
171}
172
Damien Miller37876e92003-05-15 10:19:46 +1000173u_char*
Damien Millerf58b58c2003-11-17 21:18:23 +1100174key_fingerprint_raw(const Key *k, enum fp_type dgst_type,
175 u_int *dgst_raw_length)
Damien Miller450a7a12000-03-26 13:04:51 +1000176{
Ben Lindstrom80cb27d2002-03-05 01:33:36 +0000177 const EVP_MD *md = NULL;
Ben Lindstromf0b48532001-03-12 02:59:31 +0000178 EVP_MD_CTX ctx;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000179 u_char *blob = NULL;
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000180 u_char *retval = NULL;
Ben Lindstrom90fd8142002-02-26 18:09:42 +0000181 u_int len = 0;
Damien Millereba71ba2000-04-29 23:57:08 +1000182 int nlen, elen;
Damien Miller450a7a12000-03-26 13:04:51 +1000183
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000184 *dgst_raw_length = 0;
185
Ben Lindstromf0b48532001-03-12 02:59:31 +0000186 switch (dgst_type) {
187 case SSH_FP_MD5:
188 md = EVP_md5();
189 break;
190 case SSH_FP_SHA1:
191 md = EVP_sha1();
192 break;
193 default:
194 fatal("key_fingerprint_raw: bad digest type %d",
195 dgst_type);
196 }
Damien Miller450a7a12000-03-26 13:04:51 +1000197 switch (k->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100198 case KEY_RSA1:
Damien Miller450a7a12000-03-26 13:04:51 +1000199 nlen = BN_num_bytes(k->rsa->n);
200 elen = BN_num_bytes(k->rsa->e);
201 len = nlen + elen;
Damien Millereba71ba2000-04-29 23:57:08 +1000202 blob = xmalloc(len);
203 BN_bn2bin(k->rsa->n, blob);
204 BN_bn2bin(k->rsa->e, blob + nlen);
Damien Miller450a7a12000-03-26 13:04:51 +1000205 break;
206 case KEY_DSA:
Damien Miller0bc1bd82000-11-13 22:57:25 +1100207 case KEY_RSA:
208 key_to_blob(k, &blob, &len);
209 break;
210 case KEY_UNSPEC:
211 return retval;
Damien Miller450a7a12000-03-26 13:04:51 +1000212 break;
213 default:
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000214 fatal("key_fingerprint_raw: bad key type %d", k->type);
Damien Miller450a7a12000-03-26 13:04:51 +1000215 break;
216 }
Damien Millereba71ba2000-04-29 23:57:08 +1000217 if (blob != NULL) {
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000218 retval = xmalloc(EVP_MAX_MD_SIZE);
Damien Miller6536c7d2000-06-22 21:32:31 +1000219 EVP_DigestInit(&ctx, md);
220 EVP_DigestUpdate(&ctx, blob, len);
Damien Miller3672e4b2002-02-05 11:54:07 +1100221 EVP_DigestFinal(&ctx, retval, dgst_raw_length);
Damien Millereba71ba2000-04-29 23:57:08 +1000222 memset(blob, 0, len);
223 xfree(blob);
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000224 } else {
225 fatal("key_fingerprint_raw: blob is null");
Damien Miller450a7a12000-03-26 13:04:51 +1000226 }
227 return retval;
228}
229
Ben Lindstroma962c2f2002-07-04 00:14:17 +0000230static char *
231key_fingerprint_hex(u_char *dgst_raw, u_int dgst_raw_len)
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000232{
233 char *retval;
234 int i;
235
Ben Lindstrom459d1912001-04-17 18:06:14 +0000236 retval = xmalloc(dgst_raw_len * 3 + 1);
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000237 retval[0] = '\0';
Damien Miller9f0f5c62001-12-21 14:45:46 +1100238 for (i = 0; i < dgst_raw_len; i++) {
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000239 char hex[4];
240 snprintf(hex, sizeof(hex), "%02x:", dgst_raw[i]);
Darren Tucker29588612003-07-14 17:28:34 +1000241 strlcat(retval, hex, dgst_raw_len * 3 + 1);
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000242 }
Darren Tucker29588612003-07-14 17:28:34 +1000243
244 /* Remove the trailing ':' character */
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000245 retval[(dgst_raw_len * 3) - 1] = '\0';
246 return retval;
247}
248
Ben Lindstroma962c2f2002-07-04 00:14:17 +0000249static char *
250key_fingerprint_bubblebabble(u_char *dgst_raw, u_int dgst_raw_len)
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000251{
252 char vowels[] = { 'a', 'e', 'i', 'o', 'u', 'y' };
253 char consonants[] = { 'b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm',
254 'n', 'p', 'r', 's', 't', 'v', 'z', 'x' };
Ben Lindstromcbe3ad22001-03-11 20:06:59 +0000255 u_int i, j = 0, rounds, seed = 1;
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000256 char *retval;
257
258 rounds = (dgst_raw_len / 2) + 1;
259 retval = xmalloc(sizeof(char) * (rounds*6));
Ben Lindstromcbe3ad22001-03-11 20:06:59 +0000260 retval[j++] = 'x';
261 for (i = 0; i < rounds; i++) {
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000262 u_int idx0, idx1, idx2, idx3, idx4;
Ben Lindstromcbe3ad22001-03-11 20:06:59 +0000263 if ((i + 1 < rounds) || (dgst_raw_len % 2 != 0)) {
264 idx0 = (((((u_int)(dgst_raw[2 * i])) >> 6) & 3) +
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000265 seed) % 6;
Ben Lindstromcbe3ad22001-03-11 20:06:59 +0000266 idx1 = (((u_int)(dgst_raw[2 * i])) >> 2) & 15;
267 idx2 = ((((u_int)(dgst_raw[2 * i])) & 3) +
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000268 (seed / 6)) % 6;
Ben Lindstromcbe3ad22001-03-11 20:06:59 +0000269 retval[j++] = vowels[idx0];
270 retval[j++] = consonants[idx1];
271 retval[j++] = vowels[idx2];
272 if ((i + 1) < rounds) {
273 idx3 = (((u_int)(dgst_raw[(2 * i) + 1])) >> 4) & 15;
274 idx4 = (((u_int)(dgst_raw[(2 * i) + 1]))) & 15;
275 retval[j++] = consonants[idx3];
276 retval[j++] = '-';
277 retval[j++] = consonants[idx4];
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000278 seed = ((seed * 5) +
Ben Lindstromcbe3ad22001-03-11 20:06:59 +0000279 ((((u_int)(dgst_raw[2 * i])) * 7) +
280 ((u_int)(dgst_raw[(2 * i) + 1])))) % 36;
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000281 }
282 } else {
283 idx0 = seed % 6;
284 idx1 = 16;
285 idx2 = seed / 6;
Ben Lindstromcbe3ad22001-03-11 20:06:59 +0000286 retval[j++] = vowels[idx0];
287 retval[j++] = consonants[idx1];
288 retval[j++] = vowels[idx2];
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000289 }
290 }
Ben Lindstromcbe3ad22001-03-11 20:06:59 +0000291 retval[j++] = 'x';
292 retval[j++] = '\0';
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000293 return retval;
294}
295
Ben Lindstroma962c2f2002-07-04 00:14:17 +0000296char *
Damien Millerf58b58c2003-11-17 21:18:23 +1100297key_fingerprint(const Key *k, enum fp_type dgst_type, enum fp_rep dgst_rep)
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000298{
Ben Lindstroma3700052001-04-05 23:26:32 +0000299 char *retval = NULL;
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000300 u_char *dgst_raw;
Damien Miller3672e4b2002-02-05 11:54:07 +1100301 u_int dgst_raw_len;
Damien Miller9f0f5c62001-12-21 14:45:46 +1100302
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000303 dgst_raw = key_fingerprint_raw(k, dgst_type, &dgst_raw_len);
304 if (!dgst_raw)
Ben Lindstromcfccef92001-03-13 04:57:58 +0000305 fatal("key_fingerprint: null from key_fingerprint_raw()");
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000306 switch (dgst_rep) {
Ben Lindstrom96e8ea62001-03-11 20:03:44 +0000307 case SSH_FP_HEX:
308 retval = key_fingerprint_hex(dgst_raw, dgst_raw_len);
309 break;
310 case SSH_FP_BUBBLEBABBLE:
311 retval = key_fingerprint_bubblebabble(dgst_raw, dgst_raw_len);
312 break;
313 default:
314 fatal("key_fingerprint_ex: bad digest representation %d",
315 dgst_rep);
316 break;
317 }
318 memset(dgst_raw, 0, dgst_raw_len);
319 xfree(dgst_raw);
320 return retval;
321}
322
Damien Miller450a7a12000-03-26 13:04:51 +1000323/*
324 * Reads a multiple-precision integer in decimal from the buffer, and advances
325 * the pointer. The integer must already be initialized. This function is
326 * permitted to modify the buffer. This leaves *cpp to point just beyond the
327 * last processed (and maybe modified) character. Note that this may modify
328 * the buffer containing the number.
329 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000330static int
Damien Miller450a7a12000-03-26 13:04:51 +1000331read_bignum(char **cpp, BIGNUM * value)
332{
333 char *cp = *cpp;
334 int old;
335
336 /* Skip any leading whitespace. */
337 for (; *cp == ' ' || *cp == '\t'; cp++)
338 ;
339
340 /* Check that it begins with a decimal digit. */
341 if (*cp < '0' || *cp > '9')
342 return 0;
343
344 /* Save starting position. */
345 *cpp = cp;
346
347 /* Move forward until all decimal digits skipped. */
348 for (; *cp >= '0' && *cp <= '9'; cp++)
349 ;
350
351 /* Save the old terminating character, and replace it by \0. */
352 old = *cp;
353 *cp = 0;
354
355 /* Parse the number. */
356 if (BN_dec2bn(&value, *cpp) == 0)
357 return 0;
358
359 /* Restore old terminating character. */
360 *cp = old;
361
362 /* Move beyond the number and return success. */
363 *cpp = cp;
364 return 1;
365}
Ben Lindstrom836f0e92002-06-23 21:21:30 +0000366
Ben Lindstrombba81212001-06-25 05:01:22 +0000367static int
Damien Miller450a7a12000-03-26 13:04:51 +1000368write_bignum(FILE *f, BIGNUM *num)
369{
370 char *buf = BN_bn2dec(num);
371 if (buf == NULL) {
372 error("write_bignum: BN_bn2dec() failed");
373 return 0;
374 }
375 fprintf(f, " %s", buf);
Damien Milleraf3030f2001-10-10 15:00:49 +1000376 OPENSSL_free(buf);
Damien Miller450a7a12000-03-26 13:04:51 +1000377 return 1;
378}
Damien Miller0bc1bd82000-11-13 22:57:25 +1100379
Ben Lindstrom309f3d12001-09-20 00:55:53 +0000380/* returns 1 ok, -1 error */
Damien Miller0bc1bd82000-11-13 22:57:25 +1100381int
Damien Millereba71ba2000-04-29 23:57:08 +1000382key_read(Key *ret, char **cpp)
Damien Miller450a7a12000-03-26 13:04:51 +1000383{
Damien Millereba71ba2000-04-29 23:57:08 +1000384 Key *k;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100385 int success = -1;
386 char *cp, *space;
387 int len, n, type;
388 u_int bits;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000389 u_char *blob;
Damien Millereba71ba2000-04-29 23:57:08 +1000390
391 cp = *cpp;
392
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000393 switch (ret->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100394 case KEY_RSA1:
Damien Millereba71ba2000-04-29 23:57:08 +1000395 /* Get number of bits. */
396 if (*cp < '0' || *cp > '9')
Damien Miller0bc1bd82000-11-13 22:57:25 +1100397 return -1; /* Bad bit count... */
Damien Millereba71ba2000-04-29 23:57:08 +1000398 for (bits = 0; *cp >= '0' && *cp <= '9'; cp++)
399 bits = 10 * bits + *cp - '0';
Damien Miller450a7a12000-03-26 13:04:51 +1000400 if (bits == 0)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100401 return -1;
Damien Millereba71ba2000-04-29 23:57:08 +1000402 *cpp = cp;
Damien Miller450a7a12000-03-26 13:04:51 +1000403 /* Get public exponent, public modulus. */
404 if (!read_bignum(cpp, ret->rsa->e))
Damien Miller0bc1bd82000-11-13 22:57:25 +1100405 return -1;
Damien Miller450a7a12000-03-26 13:04:51 +1000406 if (!read_bignum(cpp, ret->rsa->n))
Damien Miller0bc1bd82000-11-13 22:57:25 +1100407 return -1;
408 success = 1;
Damien Miller450a7a12000-03-26 13:04:51 +1000409 break;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100410 case KEY_UNSPEC:
411 case KEY_RSA:
Damien Miller450a7a12000-03-26 13:04:51 +1000412 case KEY_DSA:
Damien Miller0bc1bd82000-11-13 22:57:25 +1100413 space = strchr(cp, ' ');
414 if (space == NULL) {
Damien Miller386f1f32003-02-24 11:54:57 +1100415 debug3("key_read: missing whitespace");
Damien Miller0bc1bd82000-11-13 22:57:25 +1100416 return -1;
417 }
418 *space = '\0';
419 type = key_type_from_name(cp);
420 *space = ' ';
421 if (type == KEY_UNSPEC) {
Damien Miller386f1f32003-02-24 11:54:57 +1100422 debug3("key_read: missing keytype");
Damien Miller0bc1bd82000-11-13 22:57:25 +1100423 return -1;
424 }
425 cp = space+1;
426 if (*cp == '\0') {
427 debug3("key_read: short string");
428 return -1;
429 }
430 if (ret->type == KEY_UNSPEC) {
431 ret->type = type;
432 } else if (ret->type != type) {
433 /* is a key, but different type */
434 debug3("key_read: type mismatch");
Ben Lindstrom309f3d12001-09-20 00:55:53 +0000435 return -1;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100436 }
Damien Millereba71ba2000-04-29 23:57:08 +1000437 len = 2*strlen(cp);
438 blob = xmalloc(len);
439 n = uudecode(cp, blob, len);
Damien Millere247cc42000-05-07 12:03:14 +1000440 if (n < 0) {
Damien Millerb1715dc2000-05-30 13:44:51 +1000441 error("key_read: uudecode %s failed", cp);
Ben Lindstrom4cbc1812001-12-06 16:41:41 +0000442 xfree(blob);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100443 return -1;
Damien Millere247cc42000-05-07 12:03:14 +1000444 }
Darren Tucker502d3842003-06-28 12:38:01 +1000445 k = key_from_blob(blob, (u_int)n);
Ben Lindstrom4cbc1812001-12-06 16:41:41 +0000446 xfree(blob);
Damien Millerb1715dc2000-05-30 13:44:51 +1000447 if (k == NULL) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100448 error("key_read: key_from_blob %s failed", cp);
449 return -1;
Damien Millerb1715dc2000-05-30 13:44:51 +1000450 }
Damien Miller0bc1bd82000-11-13 22:57:25 +1100451 if (k->type != type) {
452 error("key_read: type mismatch: encoding error");
453 key_free(k);
454 return -1;
455 }
456/*XXXX*/
457 if (ret->type == KEY_RSA) {
458 if (ret->rsa != NULL)
459 RSA_free(ret->rsa);
460 ret->rsa = k->rsa;
461 k->rsa = NULL;
462 success = 1;
463#ifdef DEBUG_PK
464 RSA_print_fp(stderr, ret->rsa, 8);
465#endif
466 } else {
467 if (ret->dsa != NULL)
468 DSA_free(ret->dsa);
469 ret->dsa = k->dsa;
470 k->dsa = NULL;
471 success = 1;
472#ifdef DEBUG_PK
473 DSA_print_fp(stderr, ret->dsa, 8);
474#endif
475 }
476/*XXXX*/
Ben Lindstrom4cbc1812001-12-06 16:41:41 +0000477 key_free(k);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100478 if (success != 1)
479 break;
Damien Millerb1715dc2000-05-30 13:44:51 +1000480 /* advance cp: skip whitespace and data */
481 while (*cp == ' ' || *cp == '\t')
482 cp++;
483 while (*cp != '\0' && *cp != ' ' && *cp != '\t')
484 cp++;
485 *cpp = cp;
Damien Miller450a7a12000-03-26 13:04:51 +1000486 break;
487 default:
Damien Millereba71ba2000-04-29 23:57:08 +1000488 fatal("key_read: bad key type: %d", ret->type);
Damien Miller450a7a12000-03-26 13:04:51 +1000489 break;
490 }
Damien Miller0bc1bd82000-11-13 22:57:25 +1100491 return success;
Damien Miller450a7a12000-03-26 13:04:51 +1000492}
Ben Lindstrom836f0e92002-06-23 21:21:30 +0000493
Damien Miller450a7a12000-03-26 13:04:51 +1000494int
Damien Millerf58b58c2003-11-17 21:18:23 +1100495key_write(const Key *key, FILE *f)
Damien Miller450a7a12000-03-26 13:04:51 +1000496{
Ben Lindstrom90fd8142002-02-26 18:09:42 +0000497 int n, success = 0;
498 u_int len, bits = 0;
Damien Millera10f5612002-09-12 09:49:15 +1000499 u_char *blob;
500 char *uu;
Damien Miller450a7a12000-03-26 13:04:51 +1000501
Damien Miller0bc1bd82000-11-13 22:57:25 +1100502 if (key->type == KEY_RSA1 && key->rsa != NULL) {
Damien Miller450a7a12000-03-26 13:04:51 +1000503 /* size of modulus 'n' */
504 bits = BN_num_bits(key->rsa->n);
505 fprintf(f, "%u", bits);
506 if (write_bignum(f, key->rsa->e) &&
507 write_bignum(f, key->rsa->n)) {
508 success = 1;
509 } else {
510 error("key_write: failed for RSA key");
511 }
Damien Miller0bc1bd82000-11-13 22:57:25 +1100512 } else if ((key->type == KEY_DSA && key->dsa != NULL) ||
513 (key->type == KEY_RSA && key->rsa != NULL)) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100514 key_to_blob(key, &blob, &len);
Damien Millereba71ba2000-04-29 23:57:08 +1000515 uu = xmalloc(2*len);
Damien Millere247cc42000-05-07 12:03:14 +1000516 n = uuencode(blob, len, uu, 2*len);
517 if (n > 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100518 fprintf(f, "%s %s", key_ssh_name(key), uu);
Damien Millere247cc42000-05-07 12:03:14 +1000519 success = 1;
520 }
Damien Millereba71ba2000-04-29 23:57:08 +1000521 xfree(blob);
522 xfree(uu);
Damien Miller450a7a12000-03-26 13:04:51 +1000523 }
524 return success;
525}
Ben Lindstrom836f0e92002-06-23 21:21:30 +0000526
Damien Millerf58b58c2003-11-17 21:18:23 +1100527const char *
528key_type(const Key *k)
Damien Millere247cc42000-05-07 12:03:14 +1000529{
530 switch (k->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100531 case KEY_RSA1:
532 return "RSA1";
533 break;
Damien Millere247cc42000-05-07 12:03:14 +1000534 case KEY_RSA:
535 return "RSA";
536 break;
537 case KEY_DSA:
538 return "DSA";
539 break;
540 }
541 return "unknown";
542}
Ben Lindstrom836f0e92002-06-23 21:21:30 +0000543
Damien Millerf58b58c2003-11-17 21:18:23 +1100544const char *
545key_ssh_name(const Key *k)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100546{
547 switch (k->type) {
548 case KEY_RSA:
549 return "ssh-rsa";
550 break;
551 case KEY_DSA:
552 return "ssh-dss";
553 break;
554 }
555 return "ssh-unknown";
556}
Ben Lindstrom836f0e92002-06-23 21:21:30 +0000557
Damien Miller0bc1bd82000-11-13 22:57:25 +1100558u_int
Damien Millerf58b58c2003-11-17 21:18:23 +1100559key_size(const Key *k)
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000560{
Damien Millerad833b32000-08-23 10:46:23 +1000561 switch (k->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100562 case KEY_RSA1:
Damien Millerad833b32000-08-23 10:46:23 +1000563 case KEY_RSA:
564 return BN_num_bits(k->rsa->n);
565 break;
566 case KEY_DSA:
567 return BN_num_bits(k->dsa->p);
568 break;
569 }
570 return 0;
571}
Damien Miller0bc1bd82000-11-13 22:57:25 +1100572
Ben Lindstrombba81212001-06-25 05:01:22 +0000573static RSA *
Ben Lindstrom46c16222000-12-22 01:43:59 +0000574rsa_generate_private_key(u_int bits)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100575{
Kevin Stevesef4eea92001-02-05 12:42:17 +0000576 RSA *private;
577 private = RSA_generate_key(bits, 35, NULL, NULL);
578 if (private == NULL)
579 fatal("rsa_generate_private_key: key generation failed.");
580 return private;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100581}
582
Ben Lindstrombba81212001-06-25 05:01:22 +0000583static DSA*
Ben Lindstrom46c16222000-12-22 01:43:59 +0000584dsa_generate_private_key(u_int bits)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100585{
586 DSA *private = DSA_generate_parameters(bits, NULL, 0, NULL, NULL, NULL, NULL);
587 if (private == NULL)
588 fatal("dsa_generate_private_key: DSA_generate_parameters failed");
589 if (!DSA_generate_key(private))
Kevin Stevesef4eea92001-02-05 12:42:17 +0000590 fatal("dsa_generate_private_key: DSA_generate_key failed.");
591 if (private == NULL)
592 fatal("dsa_generate_private_key: NULL.");
Damien Miller0bc1bd82000-11-13 22:57:25 +1100593 return private;
594}
595
596Key *
Ben Lindstrom46c16222000-12-22 01:43:59 +0000597key_generate(int type, u_int bits)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100598{
599 Key *k = key_new(KEY_UNSPEC);
600 switch (type) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000601 case KEY_DSA:
Damien Miller0bc1bd82000-11-13 22:57:25 +1100602 k->dsa = dsa_generate_private_key(bits);
603 break;
604 case KEY_RSA:
605 case KEY_RSA1:
606 k->rsa = rsa_generate_private_key(bits);
607 break;
608 default:
Kevin Stevesef4eea92001-02-05 12:42:17 +0000609 fatal("key_generate: unknown type %d", type);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100610 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000611 k->type = type;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100612 return k;
613}
614
615Key *
Damien Millerf58b58c2003-11-17 21:18:23 +1100616key_from_private(const Key *k)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100617{
618 Key *n = NULL;
619 switch (k->type) {
Kevin Stevesef4eea92001-02-05 12:42:17 +0000620 case KEY_DSA:
Damien Miller0bc1bd82000-11-13 22:57:25 +1100621 n = key_new(k->type);
622 BN_copy(n->dsa->p, k->dsa->p);
623 BN_copy(n->dsa->q, k->dsa->q);
624 BN_copy(n->dsa->g, k->dsa->g);
625 BN_copy(n->dsa->pub_key, k->dsa->pub_key);
626 break;
627 case KEY_RSA:
628 case KEY_RSA1:
629 n = key_new(k->type);
630 BN_copy(n->rsa->n, k->rsa->n);
631 BN_copy(n->rsa->e, k->rsa->e);
632 break;
633 default:
Kevin Stevesef4eea92001-02-05 12:42:17 +0000634 fatal("key_from_private: unknown type %d", k->type);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100635 break;
636 }
637 return n;
638}
639
640int
641key_type_from_name(char *name)
642{
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000643 if (strcmp(name, "rsa1") == 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100644 return KEY_RSA1;
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000645 } else if (strcmp(name, "rsa") == 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100646 return KEY_RSA;
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000647 } else if (strcmp(name, "dsa") == 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100648 return KEY_DSA;
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000649 } else if (strcmp(name, "ssh-rsa") == 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100650 return KEY_RSA;
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000651 } else if (strcmp(name, "ssh-dss") == 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100652 return KEY_DSA;
653 }
Ben Lindstromb54873a2001-03-11 20:01:55 +0000654 debug2("key_type_from_name: unknown key type '%s'", name);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100655 return KEY_UNSPEC;
656}
657
Ben Lindstrom982dbbc2001-04-17 18:11:36 +0000658int
659key_names_valid2(const char *names)
660{
661 char *s, *cp, *p;
662
663 if (names == NULL || strcmp(names, "") == 0)
664 return 0;
665 s = cp = xstrdup(names);
666 for ((p = strsep(&cp, ",")); p && *p != '\0';
Damien Miller9f0f5c62001-12-21 14:45:46 +1100667 (p = strsep(&cp, ","))) {
Ben Lindstrom982dbbc2001-04-17 18:11:36 +0000668 switch (key_type_from_name(p)) {
669 case KEY_RSA1:
670 case KEY_UNSPEC:
671 xfree(s);
672 return 0;
673 }
674 }
675 debug3("key names ok: [%s]", names);
676 xfree(s);
677 return 1;
678}
679
Damien Miller0bc1bd82000-11-13 22:57:25 +1100680Key *
Damien Millerf58b58c2003-11-17 21:18:23 +1100681key_from_blob(const u_char *blob, u_int blen)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100682{
683 Buffer b;
684 char *ktype;
685 int rlen, type;
686 Key *key = NULL;
687
688#ifdef DEBUG_PK
689 dump_base64(stderr, blob, blen);
690#endif
691 buffer_init(&b);
692 buffer_append(&b, blob, blen);
693 ktype = buffer_get_string(&b, NULL);
694 type = key_type_from_name(ktype);
695
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000696 switch (type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100697 case KEY_RSA:
698 key = key_new(type);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100699 buffer_get_bignum2(&b, key->rsa->e);
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000700 buffer_get_bignum2(&b, key->rsa->n);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100701#ifdef DEBUG_PK
702 RSA_print_fp(stderr, key->rsa, 8);
703#endif
704 break;
705 case KEY_DSA:
706 key = key_new(type);
707 buffer_get_bignum2(&b, key->dsa->p);
708 buffer_get_bignum2(&b, key->dsa->q);
709 buffer_get_bignum2(&b, key->dsa->g);
710 buffer_get_bignum2(&b, key->dsa->pub_key);
711#ifdef DEBUG_PK
712 DSA_print_fp(stderr, key->dsa, 8);
713#endif
714 break;
715 case KEY_UNSPEC:
716 key = key_new(type);
717 break;
718 default:
719 error("key_from_blob: cannot handle type %s", ktype);
720 break;
721 }
722 rlen = buffer_len(&b);
723 if (key != NULL && rlen != 0)
724 error("key_from_blob: remaining bytes in key blob %d", rlen);
725 xfree(ktype);
726 buffer_free(&b);
727 return key;
728}
729
730int
Damien Millerf58b58c2003-11-17 21:18:23 +1100731key_to_blob(const Key *key, u_char **blobp, u_int *lenp)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100732{
733 Buffer b;
734 int len;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100735
736 if (key == NULL) {
737 error("key_to_blob: key == NULL");
738 return 0;
739 }
740 buffer_init(&b);
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000741 switch (key->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100742 case KEY_DSA:
743 buffer_put_cstring(&b, key_ssh_name(key));
744 buffer_put_bignum2(&b, key->dsa->p);
745 buffer_put_bignum2(&b, key->dsa->q);
746 buffer_put_bignum2(&b, key->dsa->g);
747 buffer_put_bignum2(&b, key->dsa->pub_key);
748 break;
749 case KEY_RSA:
750 buffer_put_cstring(&b, key_ssh_name(key));
Damien Miller0bc1bd82000-11-13 22:57:25 +1100751 buffer_put_bignum2(&b, key->rsa->e);
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000752 buffer_put_bignum2(&b, key->rsa->n);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100753 break;
754 default:
Ben Lindstrom99a30f12001-09-18 05:49:14 +0000755 error("key_to_blob: unsupported key type %d", key->type);
756 buffer_free(&b);
757 return 0;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100758 }
759 len = buffer_len(&b);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100760 if (lenp != NULL)
761 *lenp = len;
Ben Lindstrom2bf759c2002-07-07 22:13:31 +0000762 if (blobp != NULL) {
763 *blobp = xmalloc(len);
764 memcpy(*blobp, buffer_ptr(&b), len);
765 }
766 memset(buffer_ptr(&b), 0, len);
767 buffer_free(&b);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100768 return len;
769}
770
771int
772key_sign(
Damien Millerf58b58c2003-11-17 21:18:23 +1100773 const Key *key,
Ben Lindstrom90fd8142002-02-26 18:09:42 +0000774 u_char **sigp, u_int *lenp,
Damien Millerf58b58c2003-11-17 21:18:23 +1100775 const u_char *data, u_int datalen)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100776{
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000777 switch (key->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100778 case KEY_DSA:
779 return ssh_dss_sign(key, sigp, lenp, data, datalen);
780 break;
781 case KEY_RSA:
782 return ssh_rsa_sign(key, sigp, lenp, data, datalen);
783 break;
784 default:
785 error("key_sign: illegal key type %d", key->type);
786 return -1;
787 break;
788 }
789}
790
Ben Lindstrom01fff0c2002-06-06 20:54:07 +0000791/*
792 * key_verify returns 1 for a correct signature, 0 for an incorrect signature
793 * and -1 on error.
794 */
Damien Miller0bc1bd82000-11-13 22:57:25 +1100795int
796key_verify(
Damien Millerf58b58c2003-11-17 21:18:23 +1100797 const Key *key,
798 const u_char *signature, u_int signaturelen,
799 const u_char *data, u_int datalen)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100800{
Ben Lindstrom5363aee2001-06-25 04:42:20 +0000801 if (signaturelen == 0)
802 return -1;
803
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000804 switch (key->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100805 case KEY_DSA:
806 return ssh_dss_verify(key, signature, signaturelen, data, datalen);
807 break;
808 case KEY_RSA:
809 return ssh_rsa_verify(key, signature, signaturelen, data, datalen);
810 break;
811 default:
812 error("key_verify: illegal key type %d", key->type);
813 return -1;
814 break;
815 }
816}
Ben Lindstroma674e8d2002-03-22 01:45:53 +0000817
818/* Converts a private to a public key */
Ben Lindstroma674e8d2002-03-22 01:45:53 +0000819Key *
Damien Millerf58b58c2003-11-17 21:18:23 +1100820key_demote(const Key *k)
Ben Lindstroma674e8d2002-03-22 01:45:53 +0000821{
822 Key *pk;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000823
Ben Lindstroma674e8d2002-03-22 01:45:53 +0000824 pk = xmalloc(sizeof(*pk));
825 pk->type = k->type;
826 pk->flags = k->flags;
827 pk->dsa = NULL;
828 pk->rsa = NULL;
829
830 switch (k->type) {
831 case KEY_RSA1:
832 case KEY_RSA:
833 if ((pk->rsa = RSA_new()) == NULL)
834 fatal("key_demote: RSA_new failed");
835 if ((pk->rsa->e = BN_dup(k->rsa->e)) == NULL)
836 fatal("key_demote: BN_dup failed");
837 if ((pk->rsa->n = BN_dup(k->rsa->n)) == NULL)
838 fatal("key_demote: BN_dup failed");
839 break;
840 case KEY_DSA:
841 if ((pk->dsa = DSA_new()) == NULL)
842 fatal("key_demote: DSA_new failed");
843 if ((pk->dsa->p = BN_dup(k->dsa->p)) == NULL)
844 fatal("key_demote: BN_dup failed");
845 if ((pk->dsa->q = BN_dup(k->dsa->q)) == NULL)
846 fatal("key_demote: BN_dup failed");
847 if ((pk->dsa->g = BN_dup(k->dsa->g)) == NULL)
848 fatal("key_demote: BN_dup failed");
849 if ((pk->dsa->pub_key = BN_dup(k->dsa->pub_key)) == NULL)
850 fatal("key_demote: BN_dup failed");
851 break;
852 default:
853 fatal("key_free: bad key type %d", k->type);
854 break;
855 }
856
857 return (pk);
858}