xref: /openbsd-src/regress/usr.bin/ssh/unittests/sshkey/test_sshkey.c (revision 1a8dbaac879b9f3335ad7fb25429ce63ac1d6bac)
1 /* 	$OpenBSD: test_sshkey.c,v 1.21 2020/08/27 03:55:22 djm Exp $ */
2 /*
3  * Regress test for sshkey.h key management API
4  *
5  * Placed in the public domain
6  */
7 
8 #include <sys/types.h>
9 #include <sys/param.h>
10 #include <stdio.h>
11 #include <stdint.h>
12 #include <stdlib.h>
13 #include <string.h>
14 
15 #include <openssl/bn.h>
16 #include <openssl/ec.h>
17 #include <openssl/rsa.h>
18 #include <openssl/dsa.h>
19 
20 #include "test_helper.h"
21 
22 #include "ssherr.h"
23 #include "sshbuf.h"
24 #define SSHBUF_INTERNAL 1	/* access internals for testing */
25 #include "sshkey.h"
26 
27 #include "authfile.h"
28 #include "common.h"
29 #include "ssh2.h"
30 
31 void sshkey_tests(void);
32 
33 static void
34 put_opt(struct sshbuf *b, const char *name, const char *value)
35 {
36 	struct sshbuf *sect;
37 
38 	sect = sshbuf_new();
39 	ASSERT_PTR_NE(sect, NULL);
40 	ASSERT_INT_EQ(sshbuf_put_cstring(b, name), 0);
41 	if (value != NULL)
42 		ASSERT_INT_EQ(sshbuf_put_cstring(sect, value), 0);
43 	ASSERT_INT_EQ(sshbuf_put_stringb(b, sect), 0);
44 	sshbuf_free(sect);
45 }
46 
47 static void
48 build_cert(struct sshbuf *b, struct sshkey *k, const char *type,
49     struct sshkey *sign_key, struct sshkey *ca_key,
50     const char *sig_alg)
51 {
52 	struct sshbuf *ca_buf, *pk, *principals, *critopts, *exts;
53 	u_char *sigblob;
54 	size_t siglen;
55 
56 	ca_buf = sshbuf_new();
57 	ASSERT_PTR_NE(ca_buf, NULL);
58 	ASSERT_INT_EQ(sshkey_putb(ca_key, ca_buf), 0);
59 
60 	/*
61 	 * Get the public key serialisation by rendering the key and skipping
62 	 * the type string. This is a bit of a hack :/
63 	 */
64 	pk = sshbuf_new();
65 	ASSERT_PTR_NE(pk, NULL);
66 	ASSERT_INT_EQ(sshkey_putb_plain(k, pk), 0);
67 	ASSERT_INT_EQ(sshbuf_skip_string(pk), 0);
68 
69 	principals = sshbuf_new();
70 	ASSERT_PTR_NE(principals, NULL);
71 	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gsamsa"), 0);
72 	ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gregor"), 0);
73 
74 	critopts = sshbuf_new();
75 	ASSERT_PTR_NE(critopts, NULL);
76 	put_opt(critopts, "force-command", "/usr/local/bin/nethack");
77 	put_opt(critopts, "source-address", "192.168.0.0/24,127.0.0.1,::1");
78 
79 	exts = sshbuf_new();
80 	ASSERT_PTR_NE(exts, NULL);
81 	put_opt(critopts, "permit-X11-forwarding", NULL);
82 
83 	ASSERT_INT_EQ(sshbuf_put_cstring(b, type), 0);
84 	ASSERT_INT_EQ(sshbuf_put_cstring(b, "noncenoncenonce!"), 0); /* nonce */
85 	ASSERT_INT_EQ(sshbuf_putb(b, pk), 0); /* public key serialisation */
86 	ASSERT_INT_EQ(sshbuf_put_u64(b, 1234), 0); /* serial */
87 	ASSERT_INT_EQ(sshbuf_put_u32(b, SSH2_CERT_TYPE_USER), 0); /* type */
88 	ASSERT_INT_EQ(sshbuf_put_cstring(b, "gregor"), 0); /* key ID */
89 	ASSERT_INT_EQ(sshbuf_put_stringb(b, principals), 0); /* principals */
90 	ASSERT_INT_EQ(sshbuf_put_u64(b, 0), 0); /* start */
91 	ASSERT_INT_EQ(sshbuf_put_u64(b, 0xffffffffffffffffULL), 0); /* end */
92 	ASSERT_INT_EQ(sshbuf_put_stringb(b, critopts), 0); /* options */
93 	ASSERT_INT_EQ(sshbuf_put_stringb(b, exts), 0); /* extensions */
94 	ASSERT_INT_EQ(sshbuf_put_string(b, NULL, 0), 0); /* reserved */
95 	ASSERT_INT_EQ(sshbuf_put_stringb(b, ca_buf), 0); /* signature key */
96 	ASSERT_INT_EQ(sshkey_sign(sign_key, &sigblob, &siglen,
97 	    sshbuf_ptr(b), sshbuf_len(b), sig_alg, NULL, NULL, 0), 0);
98 	ASSERT_INT_EQ(sshbuf_put_string(b, sigblob, siglen), 0); /* signature */
99 
100 	free(sigblob);
101 	sshbuf_free(ca_buf);
102 	sshbuf_free(exts);
103 	sshbuf_free(critopts);
104 	sshbuf_free(principals);
105 	sshbuf_free(pk);
106 }
107 
108 static void
109 signature_test(struct sshkey *k, struct sshkey *bad, const char *sig_alg,
110     const u_char *d, size_t l)
111 {
112 	size_t len;
113 	u_char *sig;
114 
115 	ASSERT_INT_EQ(sshkey_sign(k, &sig, &len, d, l, sig_alg,
116 	    NULL, NULL, 0), 0);
117 	ASSERT_SIZE_T_GT(len, 8);
118 	ASSERT_PTR_NE(sig, NULL);
119 	ASSERT_INT_EQ(sshkey_verify(k, sig, len, d, l, NULL, 0, NULL), 0);
120 	ASSERT_INT_NE(sshkey_verify(bad, sig, len, d, l, NULL, 0, NULL), 0);
121 	/* Fuzz test is more comprehensive, this is just a smoke test */
122 	sig[len - 5] ^= 0x10;
123 	ASSERT_INT_NE(sshkey_verify(k, sig, len, d, l, NULL, 0, NULL), 0);
124 	free(sig);
125 }
126 
127 static void
128 banana(u_char *s, size_t l)
129 {
130 	size_t o;
131 	const u_char the_banana[] = { 'b', 'a', 'n', 'a', 'n', 'a' };
132 
133 	for (o = 0; o < l; o += sizeof(the_banana)) {
134 		if (l - o < sizeof(the_banana)) {
135 			memcpy(s + o, "nanananana", l - o);
136 			break;
137 		}
138 		memcpy(s + o, banana, sizeof(the_banana));
139 	}
140 }
141 
142 static void
143 signature_tests(struct sshkey *k, struct sshkey *bad, const char *sig_alg)
144 {
145 	u_char i, buf[2049];
146 	size_t lens[] = {
147 		1, 2, 7, 8, 9, 15, 16, 17, 31, 32, 33, 127, 128, 129,
148 		255, 256, 257, 1023, 1024, 1025, 2047, 2048, 2049
149 	};
150 
151 	for (i = 0; i < (sizeof(lens)/sizeof(lens[0])); i++) {
152 		test_subtest_info("%s key, banana length %zu",
153 		    sshkey_type(k), lens[i]);
154 		banana(buf, lens[i]);
155 		signature_test(k, bad, sig_alg, buf, lens[i]);
156 	}
157 }
158 
159 static struct sshkey *
160 get_private(const char *n)
161 {
162 	struct sshbuf *b;
163 	struct sshkey *ret;
164 
165 	b = load_file(n);
166 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(b, "", &ret, NULL), 0);
167 	sshbuf_free(b);
168 	return ret;
169 }
170 
171 void
172 sshkey_tests(void)
173 {
174 	struct sshkey *k1, *k2, *k3, *k4, *kr, *kd, *ke, *kf;
175 	struct sshbuf *b;
176 
177 	TEST_START("new invalid");
178 	k1 = sshkey_new(-42);
179 	ASSERT_PTR_EQ(k1, NULL);
180 	TEST_DONE();
181 
182 	TEST_START("new/free KEY_UNSPEC");
183 	k1 = sshkey_new(KEY_UNSPEC);
184 	ASSERT_PTR_NE(k1, NULL);
185 	sshkey_free(k1);
186 	TEST_DONE();
187 
188 	TEST_START("new/free KEY_RSA");
189 	k1 = sshkey_new(KEY_RSA);
190 	ASSERT_PTR_NE(k1, NULL);
191 	ASSERT_PTR_NE(k1->rsa, NULL);
192 	sshkey_free(k1);
193 	TEST_DONE();
194 
195 	TEST_START("new/free KEY_DSA");
196 	k1 = sshkey_new(KEY_DSA);
197 	ASSERT_PTR_NE(k1, NULL);
198 	ASSERT_PTR_NE(k1->dsa, NULL);
199 	sshkey_free(k1);
200 	TEST_DONE();
201 
202 	TEST_START("new/free KEY_ECDSA");
203 	k1 = sshkey_new(KEY_ECDSA);
204 	ASSERT_PTR_NE(k1, NULL);
205 	ASSERT_PTR_EQ(k1->ecdsa, NULL);  /* Can't allocate without NID */
206 	sshkey_free(k1);
207 	TEST_DONE();
208 
209 	TEST_START("new/free KEY_ED25519");
210 	k1 = sshkey_new(KEY_ED25519);
211 	ASSERT_PTR_NE(k1, NULL);
212 	/* These should be blank until key loaded or generated */
213 	ASSERT_PTR_EQ(k1->ed25519_sk, NULL);
214 	ASSERT_PTR_EQ(k1->ed25519_pk, NULL);
215 	sshkey_free(k1);
216 	TEST_DONE();
217 
218 	TEST_START("generate KEY_RSA too small modulus");
219 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 128, &k1),
220 	    SSH_ERR_KEY_LENGTH);
221 	ASSERT_PTR_EQ(k1, NULL);
222 	TEST_DONE();
223 
224 	TEST_START("generate KEY_RSA too large modulus");
225 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1 << 20, &k1),
226 	    SSH_ERR_KEY_LENGTH);
227 	ASSERT_PTR_EQ(k1, NULL);
228 	TEST_DONE();
229 
230 	TEST_START("generate KEY_DSA wrong bits");
231 	ASSERT_INT_EQ(sshkey_generate(KEY_DSA, 2048, &k1),
232 	    SSH_ERR_KEY_LENGTH);
233 	ASSERT_PTR_EQ(k1, NULL);
234 	sshkey_free(k1);
235 	TEST_DONE();
236 
237 	TEST_START("generate KEY_ECDSA wrong bits");
238 	ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 42, &k1),
239 	    SSH_ERR_KEY_LENGTH);
240 	ASSERT_PTR_EQ(k1, NULL);
241 	sshkey_free(k1);
242 	TEST_DONE();
243 
244 	TEST_START("generate KEY_RSA");
245 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 767, &kr),
246 	    SSH_ERR_KEY_LENGTH);
247 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1024, &kr), 0);
248 	ASSERT_PTR_NE(kr, NULL);
249 	ASSERT_PTR_NE(kr->rsa, NULL);
250 	ASSERT_PTR_NE(rsa_n(kr), NULL);
251 	ASSERT_PTR_NE(rsa_e(kr), NULL);
252 	ASSERT_PTR_NE(rsa_p(kr), NULL);
253 	ASSERT_INT_EQ(BN_num_bits(rsa_n(kr)), 1024);
254 	TEST_DONE();
255 
256 	TEST_START("generate KEY_DSA");
257 	ASSERT_INT_EQ(sshkey_generate(KEY_DSA, 1024, &kd), 0);
258 	ASSERT_PTR_NE(kd, NULL);
259 	ASSERT_PTR_NE(kd->dsa, NULL);
260 	ASSERT_PTR_NE(dsa_g(kd), NULL);
261 	ASSERT_PTR_NE(dsa_priv_key(kd), NULL);
262 	TEST_DONE();
263 
264 	TEST_START("generate KEY_ECDSA");
265 	ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 256, &ke), 0);
266 	ASSERT_PTR_NE(ke, NULL);
267 	ASSERT_PTR_NE(ke->ecdsa, NULL);
268 	ASSERT_PTR_NE(EC_KEY_get0_public_key(ke->ecdsa), NULL);
269 	ASSERT_PTR_NE(EC_KEY_get0_private_key(ke->ecdsa), NULL);
270 	TEST_DONE();
271 
272 	TEST_START("generate KEY_ED25519");
273 	ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 256, &kf), 0);
274 	ASSERT_PTR_NE(kf, NULL);
275 	ASSERT_INT_EQ(kf->type, KEY_ED25519);
276 	ASSERT_PTR_NE(kf->ed25519_pk, NULL);
277 	ASSERT_PTR_NE(kf->ed25519_sk, NULL);
278 	TEST_DONE();
279 
280 	TEST_START("demote KEY_RSA");
281 	ASSERT_INT_EQ(sshkey_from_private(kr, &k1), 0);
282 	ASSERT_PTR_NE(k1, NULL);
283 	ASSERT_PTR_NE(kr, k1);
284 	ASSERT_INT_EQ(k1->type, KEY_RSA);
285 	ASSERT_PTR_NE(k1->rsa, NULL);
286 	ASSERT_PTR_NE(rsa_n(k1), NULL);
287 	ASSERT_PTR_NE(rsa_e(k1), NULL);
288 	ASSERT_PTR_EQ(rsa_p(k1), NULL);
289 	TEST_DONE();
290 
291 	TEST_START("equal KEY_RSA/demoted KEY_RSA");
292 	ASSERT_INT_EQ(sshkey_equal(kr, k1), 1);
293 	sshkey_free(k1);
294 	TEST_DONE();
295 
296 	TEST_START("demote KEY_DSA");
297 	ASSERT_INT_EQ(sshkey_from_private(kd, &k1), 0);
298 	ASSERT_PTR_NE(k1, NULL);
299 	ASSERT_PTR_NE(kd, k1);
300 	ASSERT_INT_EQ(k1->type, KEY_DSA);
301 	ASSERT_PTR_NE(k1->dsa, NULL);
302 	ASSERT_PTR_NE(dsa_g(k1), NULL);
303 	ASSERT_PTR_EQ(dsa_priv_key(k1), NULL);
304 	TEST_DONE();
305 
306 	TEST_START("equal KEY_DSA/demoted KEY_DSA");
307 	ASSERT_INT_EQ(sshkey_equal(kd, k1), 1);
308 	sshkey_free(k1);
309 	TEST_DONE();
310 
311 	TEST_START("demote KEY_ECDSA");
312 	ASSERT_INT_EQ(sshkey_from_private(ke, &k1), 0);
313 	ASSERT_PTR_NE(k1, NULL);
314 	ASSERT_PTR_NE(ke, k1);
315 	ASSERT_INT_EQ(k1->type, KEY_ECDSA);
316 	ASSERT_PTR_NE(k1->ecdsa, NULL);
317 	ASSERT_INT_EQ(k1->ecdsa_nid, ke->ecdsa_nid);
318 	ASSERT_PTR_NE(EC_KEY_get0_public_key(ke->ecdsa), NULL);
319 	ASSERT_PTR_EQ(EC_KEY_get0_private_key(k1->ecdsa), NULL);
320 	TEST_DONE();
321 
322 	TEST_START("equal KEY_ECDSA/demoted KEY_ECDSA");
323 	ASSERT_INT_EQ(sshkey_equal(ke, k1), 1);
324 	sshkey_free(k1);
325 	TEST_DONE();
326 
327 	TEST_START("demote KEY_ED25519");
328 	ASSERT_INT_EQ(sshkey_from_private(kf, &k1), 0);
329 	ASSERT_PTR_NE(k1, NULL);
330 	ASSERT_PTR_NE(kf, k1);
331 	ASSERT_INT_EQ(k1->type, KEY_ED25519);
332 	ASSERT_PTR_NE(k1->ed25519_pk, NULL);
333 	ASSERT_PTR_EQ(k1->ed25519_sk, NULL);
334 	TEST_DONE();
335 
336 	TEST_START("equal KEY_ED25519/demoted KEY_ED25519");
337 	ASSERT_INT_EQ(sshkey_equal(kf, k1), 1);
338 	sshkey_free(k1);
339 	TEST_DONE();
340 
341 	TEST_START("equal mismatched key types");
342 	ASSERT_INT_EQ(sshkey_equal(kd, kr), 0);
343 	ASSERT_INT_EQ(sshkey_equal(kd, ke), 0);
344 	ASSERT_INT_EQ(sshkey_equal(kr, ke), 0);
345 	ASSERT_INT_EQ(sshkey_equal(ke, kf), 0);
346 	ASSERT_INT_EQ(sshkey_equal(kd, kf), 0);
347 	TEST_DONE();
348 
349 	TEST_START("equal different keys");
350 	ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1024, &k1), 0);
351 	ASSERT_INT_EQ(sshkey_equal(kr, k1), 0);
352 	sshkey_free(k1);
353 	ASSERT_INT_EQ(sshkey_generate(KEY_DSA, 1024, &k1), 0);
354 	ASSERT_INT_EQ(sshkey_equal(kd, k1), 0);
355 	sshkey_free(k1);
356 	ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 256, &k1), 0);
357 	ASSERT_INT_EQ(sshkey_equal(ke, k1), 0);
358 	sshkey_free(k1);
359 	ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 256, &k1), 0);
360 	ASSERT_INT_EQ(sshkey_equal(kf, k1), 0);
361 	sshkey_free(k1);
362 	TEST_DONE();
363 
364 	sshkey_free(kr);
365 	sshkey_free(kd);
366 	sshkey_free(ke);
367 	sshkey_free(kf);
368 
369 	TEST_START("certify key");
370 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_1.pub"),
371 	    &k1, NULL), 0);
372 	k2 = get_private("ed25519_2");
373 	ASSERT_INT_EQ(sshkey_to_certified(k1), 0);
374 	ASSERT_PTR_NE(k1->cert, NULL);
375 	k1->cert->type = SSH2_CERT_TYPE_USER;
376 	k1->cert->serial = 1234;
377 	k1->cert->key_id = strdup("estragon");
378 	ASSERT_PTR_NE(k1->cert->key_id, NULL);
379 	k1->cert->principals = calloc(4, sizeof(*k1->cert->principals));
380 	ASSERT_PTR_NE(k1->cert->principals, NULL);
381 	k1->cert->principals[0] = strdup("estragon");
382 	k1->cert->principals[1] = strdup("vladimir");
383 	k1->cert->principals[2] = strdup("pozzo");
384 	k1->cert->principals[3] = strdup("lucky");
385 	ASSERT_PTR_NE(k1->cert->principals[0], NULL);
386 	ASSERT_PTR_NE(k1->cert->principals[1], NULL);
387 	ASSERT_PTR_NE(k1->cert->principals[2], NULL);
388 	ASSERT_PTR_NE(k1->cert->principals[3], NULL);
389 	k1->cert->nprincipals = 4;
390 	k1->cert->valid_after = 0;
391 	k1->cert->valid_before = (u_int64_t)-1;
392 	sshbuf_free(k1->cert->critical);
393 	k1->cert->critical = sshbuf_new();
394 	ASSERT_PTR_NE(k1->cert->critical, NULL);
395 	sshbuf_free(k1->cert->extensions);
396 	k1->cert->extensions = sshbuf_new();
397 	ASSERT_PTR_NE(k1->cert->extensions, NULL);
398 	put_opt(k1->cert->critical, "force-command", "/usr/bin/true");
399 	put_opt(k1->cert->critical, "source-address", "127.0.0.1");
400 	put_opt(k1->cert->extensions, "permit-X11-forwarding", NULL);
401 	put_opt(k1->cert->extensions, "permit-agent-forwarding", NULL);
402 	ASSERT_INT_EQ(sshkey_from_private(k2, &k1->cert->signature_key), 0);
403 	ASSERT_INT_EQ(sshkey_certify(k1, k2, NULL, NULL, NULL), 0);
404 	b = sshbuf_new();
405 	ASSERT_PTR_NE(b, NULL);
406 	ASSERT_INT_EQ(sshkey_putb(k1, b), 0);
407 	ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k3), 0);
408 
409 	sshkey_free(k1);
410 	sshkey_free(k2);
411 	sshkey_free(k3);
412 	sshbuf_reset(b);
413 	TEST_DONE();
414 
415 	TEST_START("sign and verify RSA");
416 	k1 = get_private("rsa_1");
417 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2,
418 	    NULL), 0);
419 	signature_tests(k1, k2, "ssh-rsa");
420 	sshkey_free(k1);
421 	sshkey_free(k2);
422 	TEST_DONE();
423 
424 	TEST_START("sign and verify RSA-SHA256");
425 	k1 = get_private("rsa_1");
426 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2,
427 	    NULL), 0);
428 	signature_tests(k1, k2, "rsa-sha2-256");
429 	sshkey_free(k1);
430 	sshkey_free(k2);
431 	TEST_DONE();
432 
433 	TEST_START("sign and verify RSA-SHA512");
434 	k1 = get_private("rsa_1");
435 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2,
436 	    NULL), 0);
437 	signature_tests(k1, k2, "rsa-sha2-512");
438 	sshkey_free(k1);
439 	sshkey_free(k2);
440 	TEST_DONE();
441 
442 	TEST_START("sign and verify DSA");
443 	k1 = get_private("dsa_1");
444 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("dsa_2.pub"), &k2,
445 	    NULL), 0);
446 	signature_tests(k1, k2, NULL);
447 	sshkey_free(k1);
448 	sshkey_free(k2);
449 	TEST_DONE();
450 
451 	TEST_START("sign and verify ECDSA");
452 	k1 = get_private("ecdsa_1");
453 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_2.pub"), &k2,
454 	    NULL), 0);
455 	signature_tests(k1, k2, NULL);
456 	sshkey_free(k1);
457 	sshkey_free(k2);
458 	TEST_DONE();
459 
460 	TEST_START("sign and verify ED25519");
461 	k1 = get_private("ed25519_1");
462 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_2.pub"), &k2,
463 	    NULL), 0);
464 	signature_tests(k1, k2, NULL);
465 	sshkey_free(k1);
466 	sshkey_free(k2);
467 	TEST_DONE();
468 
469 	TEST_START("nested certificate");
470 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("rsa_1"), &k1), 0);
471 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_1.pub"), &k2,
472 	    NULL), 0);
473 	k3 = get_private("rsa_1");
474 	build_cert(b, k2, "ssh-rsa-cert-v01@openssh.com", k3, k1, NULL);
475 	ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k4),
476 	    SSH_ERR_KEY_CERT_INVALID_SIGN_KEY);
477 	ASSERT_PTR_EQ(k4, NULL);
478 	sshkey_free(k1);
479 	sshkey_free(k2);
480 	sshkey_free(k3);
481 	sshbuf_free(b);
482 	TEST_DONE();
483 
484 }
485