1 /* $OpenBSD: test_sshkey.c,v 1.34 2026/06/14 04:08:06 djm Exp $ */
2 /*
3 * Regress test for sshkey.h key management API
4 *
5 * Placed in the public domain
6 */
7
8 #include "includes.h"
9
10 #include <sys/types.h>
11 #include <paths.h>
12 #include <stdio.h>
13 #include <stdint.h>
14 #include <stdlib.h>
15 #include <string.h>
16
17 #ifdef WITH_OPENSSL
18 #include <openssl/bn.h>
19 #include <openssl/rsa.h>
20 #if defined(OPENSSL_HAS_ECC) && defined(OPENSSL_HAS_NISTP256)
21 # include <openssl/ec.h>
22 #endif
23 #endif
24
25 #include "../test_helper/test_helper.h"
26
27 #include "ssherr.h"
28 #include "sshbuf.h"
29 #define SSHBUF_INTERNAL 1 /* access internals for testing */
30 #include "sshkey.h"
31
32 #include "authfile.h"
33 #include "common.h"
34 #include "ssh2.h"
35
36 void sshkey_tests(void);
37 void sshkey_benchmarks(void);
38
39 static void
put_opt(struct sshbuf * b,const char * name,const char * value)40 put_opt(struct sshbuf *b, const char *name, const char *value)
41 {
42 struct sshbuf *sect;
43
44 sect = sshbuf_new();
45 ASSERT_PTR_NE(sect, NULL);
46 ASSERT_INT_EQ(sshbuf_put_cstring(b, name), 0);
47 if (value != NULL)
48 ASSERT_INT_EQ(sshbuf_put_cstring(sect, value), 0);
49 ASSERT_INT_EQ(sshbuf_put_stringb(b, sect), 0);
50 sshbuf_free(sect);
51 }
52
53 #ifdef WITH_OPENSSL
54 static void
build_cert(struct sshbuf * b,struct sshkey * k,const char * type,struct sshkey * sign_key,struct sshkey * ca_key,const char * sig_alg)55 build_cert(struct sshbuf *b, struct sshkey *k, const char *type,
56 struct sshkey *sign_key, struct sshkey *ca_key,
57 const char *sig_alg)
58 {
59 struct sshbuf *ca_buf, *pk, *principals, *critopts, *exts;
60 u_char *sigblob;
61 size_t siglen;
62
63 ca_buf = sshbuf_new();
64 ASSERT_PTR_NE(ca_buf, NULL);
65 ASSERT_INT_EQ(sshkey_putb(ca_key, ca_buf), 0);
66
67 /*
68 * Get the public key serialisation by rendering the key and skipping
69 * the type string. This is a bit of a hack :/
70 */
71 pk = sshbuf_new();
72 ASSERT_PTR_NE(pk, NULL);
73 ASSERT_INT_EQ(sshkey_putb_plain(k, pk), 0);
74 ASSERT_INT_EQ(sshbuf_skip_string(pk), 0);
75
76 principals = sshbuf_new();
77 ASSERT_PTR_NE(principals, NULL);
78 ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gsamsa"), 0);
79 ASSERT_INT_EQ(sshbuf_put_cstring(principals, "gregor"), 0);
80
81 critopts = sshbuf_new();
82 ASSERT_PTR_NE(critopts, NULL);
83 put_opt(critopts, "force-command", _PATH_LOCALBASE "/bin/nethack");
84 put_opt(critopts, "source-address", "192.168.0.0/24,127.0.0.1,::1");
85
86 exts = sshbuf_new();
87 ASSERT_PTR_NE(exts, NULL);
88 put_opt(critopts, "permit-X11-forwarding", NULL);
89
90 ASSERT_INT_EQ(sshbuf_put_cstring(b, type), 0);
91 ASSERT_INT_EQ(sshbuf_put_cstring(b, "noncenoncenonce!"), 0); /* nonce */
92 ASSERT_INT_EQ(sshbuf_putb(b, pk), 0); /* public key serialisation */
93 ASSERT_INT_EQ(sshbuf_put_u64(b, 1234), 0); /* serial */
94 ASSERT_INT_EQ(sshbuf_put_u32(b, SSH2_CERT_TYPE_USER), 0); /* type */
95 ASSERT_INT_EQ(sshbuf_put_cstring(b, "gregor"), 0); /* key ID */
96 ASSERT_INT_EQ(sshbuf_put_stringb(b, principals), 0); /* principals */
97 ASSERT_INT_EQ(sshbuf_put_u64(b, 0), 0); /* start */
98 ASSERT_INT_EQ(sshbuf_put_u64(b, 0xffffffffffffffffULL), 0); /* end */
99 ASSERT_INT_EQ(sshbuf_put_stringb(b, critopts), 0); /* options */
100 ASSERT_INT_EQ(sshbuf_put_stringb(b, exts), 0); /* extensions */
101 ASSERT_INT_EQ(sshbuf_put_string(b, NULL, 0), 0); /* reserved */
102 ASSERT_INT_EQ(sshbuf_put_stringb(b, ca_buf), 0); /* signature key */
103 ASSERT_INT_EQ(sshkey_sign(sign_key, &sigblob, &siglen,
104 sshbuf_ptr(b), sshbuf_len(b), sig_alg, NULL, NULL, 0), 0);
105 ASSERT_INT_EQ(sshbuf_put_string(b, sigblob, siglen), 0); /* signature */
106
107 free(sigblob);
108 sshbuf_free(ca_buf);
109 sshbuf_free(exts);
110 sshbuf_free(critopts);
111 sshbuf_free(principals);
112 sshbuf_free(pk);
113 }
114 #endif /* WITH_OPENSSL */
115
116 static void
signature_test(struct sshkey * k,struct sshkey * bad,const char * sig_alg,const u_char * d,size_t l)117 signature_test(struct sshkey *k, struct sshkey *bad, const char *sig_alg,
118 const u_char *d, size_t l)
119 {
120 size_t len;
121 u_char *sig;
122
123 ASSERT_INT_EQ(sshkey_sign(k, &sig, &len, d, l, sig_alg,
124 NULL, NULL, 0), 0);
125 ASSERT_SIZE_T_GT(len, 8);
126 ASSERT_PTR_NE(sig, NULL);
127 ASSERT_INT_EQ(sshkey_verify(k, sig, len, d, l, NULL, 0, NULL), 0);
128 ASSERT_INT_NE(sshkey_verify(bad, sig, len, d, l, NULL, 0, NULL), 0);
129 /* Fuzz test is more comprehensive, this is just a smoke test */
130 sig[len - 5] ^= 0x10;
131 ASSERT_INT_NE(sshkey_verify(k, sig, len, d, l, NULL, 0, NULL), 0);
132 free(sig);
133 }
134
135 static void
signature_bench(const char * name,int ktype,int bits,const char * sig_alg,const u_char * d,size_t l)136 signature_bench(const char *name, int ktype, int bits, const char *sig_alg,
137 const u_char *d, size_t l)
138 {
139 struct sshkey *k;
140 size_t len;
141 u_char *sig;
142 char testname[256];
143
144 snprintf(testname, sizeof(testname), "sign %s", name);
145 TEST_START(testname);
146 ASSERT_INT_EQ(sshkey_generate(ktype, bits, &k), 0);
147 ASSERT_PTR_NE(k, NULL);
148
149 BENCH_START(testname);
150 ASSERT_INT_EQ(sshkey_sign(k, &sig, &len, d, l, sig_alg,
151 NULL, NULL, 0), 0);
152 free(sig);
153 BENCH_FINISH("sign");
154
155 sshkey_free(k);
156 TEST_DONE();
157 }
158
159 static void
verify_bench(const char * name,int ktype,int bits,const char * sig_alg,const u_char * d,size_t l)160 verify_bench(const char *name, int ktype, int bits, const char *sig_alg,
161 const u_char *d, size_t l)
162 {
163 struct sshkey *k;
164 size_t len;
165 u_char *sig;
166 char testname[256];
167
168 snprintf(testname, sizeof(testname), "verify %s", name);
169 TEST_START(testname);
170 ASSERT_INT_EQ(sshkey_generate(ktype, bits, &k), 0);
171 ASSERT_PTR_NE(k, NULL);
172
173 ASSERT_INT_EQ(sshkey_sign(k, &sig, &len, d, l, sig_alg,
174 NULL, NULL, 0), 0);
175 BENCH_START(testname);
176 ASSERT_INT_EQ(sshkey_verify(k, sig, len, d, l, NULL, 0, NULL), 0);
177 BENCH_FINISH("verify");
178
179 free(sig);
180 sshkey_free(k);
181 TEST_DONE();
182 }
183
184 static void
banana(u_char * s,size_t l)185 banana(u_char *s, size_t l)
186 {
187 size_t o;
188 const u_char the_banana[] = { 'b', 'a', 'n', 'a', 'n', 'a' };
189
190 for (o = 0; o < l; o += sizeof(the_banana)) {
191 if (l - o < sizeof(the_banana)) {
192 memcpy(s + o, "nanananana", l - o);
193 break;
194 }
195 memcpy(s + o, the_banana, sizeof(the_banana));
196 }
197 }
198
199 static void
signature_tests(struct sshkey * k,struct sshkey * bad,const char * sig_alg)200 signature_tests(struct sshkey *k, struct sshkey *bad, const char *sig_alg)
201 {
202 u_char i, buf[2049];
203 size_t lens[] = {
204 1, 2, 7, 8, 9, 15, 16, 17, 31, 32, 33, 127, 128, 129,
205 255, 256, 257, 1023, 1024, 1025, 2047, 2048, 2049
206 };
207
208 for (i = 0; i < (sizeof(lens)/sizeof(lens[0])); i++) {
209 test_subtest_info("%s key, banana length %zu",
210 sshkey_type(k), lens[i]);
211 banana(buf, lens[i]);
212 signature_test(k, bad, sig_alg, buf, lens[i]);
213 }
214 }
215
216 static void
signature_benchmark(const char * name,int ktype,int bits,const char * sig_alg,int bench_verify)217 signature_benchmark(const char *name, int ktype, int bits,
218 const char *sig_alg, int bench_verify)
219 {
220 u_char buf[256];
221
222 banana(buf, sizeof(buf));
223 if (bench_verify)
224 verify_bench(name, ktype, bits, sig_alg, buf, sizeof(buf));
225 else
226 signature_bench(name, ktype, bits, sig_alg, buf, sizeof(buf));
227 }
228
229 static struct sshkey *
get_private(const char * n)230 get_private(const char *n)
231 {
232 struct sshbuf *b;
233 struct sshkey *ret;
234
235 b = load_file(n);
236 ASSERT_INT_EQ(sshkey_parse_private_fileblob(b, "", &ret, NULL), 0);
237 sshbuf_free(b);
238 return ret;
239 }
240
241 void
sshkey_tests(void)242 sshkey_tests(void)
243 {
244 struct sshkey *k1 = NULL, *k2 = NULL, *k3 = NULL, *kf = NULL;
245 #ifdef WITH_OPENSSL
246 struct sshkey *k4 = NULL, *kr = NULL, *kd = NULL;
247 #ifdef OPENSSL_HAS_ECC
248 struct sshkey *ke = NULL;
249 #endif /* OPENSSL_HAS_ECC */
250 #endif /* WITH_OPENSSL */
251 struct sshbuf *b = NULL;
252
253 TEST_START("new invalid");
254 k1 = sshkey_new(-42);
255 ASSERT_PTR_EQ(k1, NULL);
256 TEST_DONE();
257
258 TEST_START("new/free KEY_UNSPEC");
259 k1 = sshkey_new(KEY_UNSPEC);
260 ASSERT_PTR_NE(k1, NULL);
261 sshkey_free(k1);
262 k1 = NULL;
263 TEST_DONE();
264
265 #ifdef WITH_OPENSSL
266 TEST_START("new/free KEY_RSA");
267 k1 = sshkey_new(KEY_RSA);
268 ASSERT_PTR_NE(k1, NULL);
269 ASSERT_PTR_NE(k1->pkey, NULL);
270 sshkey_free(k1);
271 k1 = NULL;
272 TEST_DONE();
273
274
275 #ifdef OPENSSL_HAS_ECC
276 TEST_START("new/free KEY_ECDSA");
277 k1 = sshkey_new(KEY_ECDSA);
278 ASSERT_PTR_NE(k1, NULL);
279 ASSERT_PTR_EQ(k1->pkey, NULL); /* Can't allocate without NID */
280 sshkey_free(k1);
281 k1 = NULL;
282 TEST_DONE();
283 #endif
284
285 TEST_START("new/free KEY_ED25519");
286 k1 = sshkey_new(KEY_ED25519);
287 ASSERT_PTR_NE(k1, NULL);
288 /* These should be blank until key loaded or generated */
289 ASSERT_PTR_EQ(k1->ed25519_sk, NULL);
290 ASSERT_PTR_EQ(k1->ed25519_pk, NULL);
291 sshkey_free(k1);
292 k1 = NULL;
293 TEST_DONE();
294
295 TEST_START("new/free KEY_MLDSA44_ED25519");
296 k1 = sshkey_new(KEY_MLDSA44_ED25519);
297 ASSERT_PTR_NE(k1, NULL);
298 ASSERT_PTR_EQ(k1->mldsa_ed25519_sk, NULL);
299 ASSERT_PTR_EQ(k1->mldsa_ed25519_pk, NULL);
300 sshkey_free(k1);
301 k1 = NULL;
302 TEST_DONE();
303
304 TEST_START("generate KEY_RSA too small modulus");
305 ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 128, &k1),
306 SSH_ERR_KEY_LENGTH);
307 ASSERT_PTR_EQ(k1, NULL);
308 TEST_DONE();
309
310 TEST_START("generate KEY_RSA too large modulus");
311 ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1 << 20, &k1),
312 SSH_ERR_KEY_LENGTH);
313 ASSERT_PTR_EQ(k1, NULL);
314 TEST_DONE();
315
316
317 #ifdef OPENSSL_HAS_ECC
318 TEST_START("generate KEY_ECDSA wrong bits");
319 ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 42, &k1),
320 SSH_ERR_KEY_LENGTH);
321 ASSERT_PTR_EQ(k1, NULL);
322 sshkey_free(k1);
323 k1 = NULL;
324 TEST_DONE();
325 #endif
326
327 TEST_START("generate KEY_RSA");
328 ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 767, &kr),
329 SSH_ERR_KEY_LENGTH);
330 ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1024, &kr), 0);
331 ASSERT_PTR_NE(kr, NULL);
332 ASSERT_PTR_NE(EVP_PKEY_get0_RSA(kr->pkey), NULL);
333 ASSERT_PTR_NE(rsa_n(kr), NULL);
334 ASSERT_PTR_NE(rsa_e(kr), NULL);
335 ASSERT_PTR_NE(rsa_p(kr), NULL);
336 ASSERT_INT_EQ(BN_num_bits(rsa_n(kr)), 1024);
337 TEST_DONE();
338
339
340 #ifdef OPENSSL_HAS_ECC
341 TEST_START("generate KEY_ECDSA");
342 ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 256, &ke), 0);
343 ASSERT_PTR_NE(ke, NULL);
344 ASSERT_PTR_NE(EVP_PKEY_get0_EC_KEY(ke->pkey), NULL);
345 ASSERT_PTR_NE(EC_KEY_get0_public_key(EVP_PKEY_get0_EC_KEY(ke->pkey)),
346 NULL);
347 ASSERT_PTR_NE(EC_KEY_get0_private_key(EVP_PKEY_get0_EC_KEY(ke->pkey)),
348 NULL);
349 TEST_DONE();
350 #endif /* OPENSSL_HAS_ECC */
351 #endif /* WITH_OPENSSL */
352
353 TEST_START("generate KEY_ED25519");
354 ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 256, &kf), 0);
355 ASSERT_PTR_NE(kf, NULL);
356 ASSERT_INT_EQ(kf->type, KEY_ED25519);
357 ASSERT_PTR_NE(kf->ed25519_pk, NULL);
358 ASSERT_PTR_NE(kf->ed25519_sk, NULL);
359 TEST_DONE();
360
361 TEST_START("generate KEY_MLDSA44_ED25519");
362 ASSERT_INT_EQ(sshkey_generate(KEY_MLDSA44_ED25519, 256, &k1), 0);
363 ASSERT_PTR_NE(k1, NULL);
364 ASSERT_INT_EQ(k1->type, KEY_MLDSA44_ED25519);
365 ASSERT_PTR_NE(k1->mldsa_ed25519_pk, NULL);
366 ASSERT_PTR_NE(k1->mldsa_ed25519_sk, NULL);
367 sshkey_free(k1);
368 k1 = NULL;
369 TEST_DONE();
370
371 #ifdef WITH_OPENSSL
372 TEST_START("demote KEY_RSA");
373 ASSERT_INT_EQ(sshkey_from_private(kr, &k1), 0);
374 ASSERT_PTR_NE(k1, NULL);
375 ASSERT_PTR_NE(kr, k1);
376 ASSERT_INT_EQ(k1->type, KEY_RSA);
377 ASSERT_PTR_NE(EVP_PKEY_get0_RSA(k1->pkey), NULL);
378 ASSERT_PTR_NE(rsa_n(k1), NULL);
379 ASSERT_PTR_NE(rsa_e(k1), NULL);
380 ASSERT_PTR_EQ(rsa_p(k1), NULL);
381 TEST_DONE();
382
383 TEST_START("equal KEY_RSA/demoted KEY_RSA");
384 ASSERT_INT_EQ(sshkey_equal(kr, k1), 1);
385 sshkey_free(k1);
386 k1 = NULL;
387 TEST_DONE();
388
389
390 #ifdef OPENSSL_HAS_ECC
391 TEST_START("demote KEY_ECDSA");
392 ASSERT_INT_EQ(sshkey_from_private(ke, &k1), 0);
393 ASSERT_PTR_NE(k1, NULL);
394 ASSERT_PTR_NE(ke, k1);
395 ASSERT_INT_EQ(k1->type, KEY_ECDSA);
396 ASSERT_PTR_NE(EVP_PKEY_get0_EC_KEY(k1->pkey), NULL);
397 ASSERT_INT_EQ(k1->ecdsa_nid, ke->ecdsa_nid);
398 ASSERT_PTR_NE(EC_KEY_get0_public_key(EVP_PKEY_get0_EC_KEY(ke->pkey)),
399 NULL);
400 ASSERT_PTR_EQ(EC_KEY_get0_private_key(EVP_PKEY_get0_EC_KEY(k1->pkey)),
401 NULL);
402 TEST_DONE();
403
404 TEST_START("equal KEY_ECDSA/demoted KEY_ECDSA");
405 ASSERT_INT_EQ(sshkey_equal(ke, k1), 1);
406 sshkey_free(k1);
407 k1 = NULL;
408 TEST_DONE();
409 #endif /* OPENSSL_HAS_ECC */
410 #endif /* WITH_OPENSSL */
411
412 TEST_START("demote KEY_ED25519");
413 ASSERT_INT_EQ(sshkey_from_private(kf, &k1), 0);
414 ASSERT_PTR_NE(k1, NULL);
415 ASSERT_PTR_NE(kf, k1);
416 ASSERT_INT_EQ(k1->type, KEY_ED25519);
417 ASSERT_PTR_NE(k1->ed25519_pk, NULL);
418 ASSERT_PTR_EQ(k1->ed25519_sk, NULL);
419 TEST_DONE();
420
421 TEST_START("equal KEY_ED25519/demoted KEY_ED25519");
422 ASSERT_INT_EQ(sshkey_equal(kf, k1), 1);
423 sshkey_free(k1);
424 k1 = NULL;
425 TEST_DONE();
426
427 TEST_START("demote KEY_MLDSA44_ED25519");
428 ASSERT_INT_EQ(sshkey_generate(KEY_MLDSA44_ED25519, 256, &k2), 0);
429 ASSERT_INT_EQ(sshkey_from_private(k2, &k1), 0);
430 ASSERT_PTR_NE(k1, NULL);
431 ASSERT_PTR_NE(k2, k1);
432 ASSERT_INT_EQ(k1->type, KEY_MLDSA44_ED25519);
433 ASSERT_PTR_NE(k1->mldsa_ed25519_pk, NULL);
434 ASSERT_PTR_EQ(k1->mldsa_ed25519_sk, NULL);
435 TEST_DONE();
436
437 TEST_START("equal KEY_MLDSA44_ED25519/demoted KEY_MLDSA44_ED25519");
438 ASSERT_INT_EQ(sshkey_equal(k2, k1), 1);
439 sshkey_free(k1);
440 sshkey_free(k2);
441 k1 = k2 = NULL;
442 TEST_DONE();
443
444 #ifdef WITH_OPENSSL
445 TEST_START("equal mismatched key types");
446 ASSERT_INT_EQ(sshkey_equal(kd, kr), 0);
447 #ifdef OPENSSL_HAS_ECC
448 ASSERT_INT_EQ(sshkey_equal(kd, ke), 0);
449 ASSERT_INT_EQ(sshkey_equal(kr, ke), 0);
450 ASSERT_INT_EQ(sshkey_equal(ke, kf), 0);
451 #endif /* OPENSSL_HAS_ECC */
452 ASSERT_INT_EQ(sshkey_equal(kd, kf), 0);
453 TEST_DONE();
454 #endif /* WITH_OPENSSL */
455
456 TEST_START("equal different keys");
457 #ifdef WITH_OPENSSL
458 ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1024, &k1), 0);
459 ASSERT_INT_EQ(sshkey_equal(kr, k1), 0);
460 sshkey_free(k1);
461 k1 = NULL;
462 #ifdef OPENSSL_HAS_ECC
463 ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 256, &k1), 0);
464 ASSERT_INT_EQ(sshkey_equal(ke, k1), 0);
465 sshkey_free(k1);
466 k1 = NULL;
467 #endif /* OPENSSL_HAS_ECC */
468 #endif /* WITH_OPENSSL */
469 ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 256, &k1), 0);
470 ASSERT_INT_EQ(sshkey_equal(kf, k1), 0);
471 sshkey_free(k1);
472 k1 = NULL;
473 ASSERT_INT_EQ(sshkey_generate(KEY_MLDSA44_ED25519, 256, &k1), 0);
474 ASSERT_INT_EQ(sshkey_generate(KEY_MLDSA44_ED25519, 256, &k2), 0);
475 ASSERT_INT_EQ(sshkey_equal(k2, k1), 0);
476 sshkey_free(k1);
477 sshkey_free(k2);
478 k1 = k2 = NULL;
479 TEST_DONE();
480
481 #ifdef WITH_OPENSSL
482 sshkey_free(kr);
483 sshkey_free(kd);
484 #ifdef OPENSSL_HAS_ECC
485 sshkey_free(ke);
486 #endif /* OPENSSL_HAS_ECC */
487 #endif /* WITH_OPENSSL */
488 sshkey_free(kf);
489
490 TEST_START("certify key");
491 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_1.pub"),
492 &k1, NULL), 0);
493 k2 = get_private("ed25519_2");
494 ASSERT_INT_EQ(sshkey_to_certified(k1), 0);
495 ASSERT_PTR_NE(k1->cert, NULL);
496 k1->cert->type = SSH2_CERT_TYPE_USER;
497 k1->cert->serial = 1234;
498 k1->cert->key_id = strdup("estragon");
499 ASSERT_PTR_NE(k1->cert->key_id, NULL);
500 k1->cert->principals = calloc(4, sizeof(*k1->cert->principals));
501 ASSERT_PTR_NE(k1->cert->principals, NULL);
502 k1->cert->principals[0] = strdup("estragon");
503 k1->cert->principals[1] = strdup("vladimir");
504 k1->cert->principals[2] = strdup("pozzo");
505 k1->cert->principals[3] = strdup("lucky");
506 ASSERT_PTR_NE(k1->cert->principals[0], NULL);
507 ASSERT_PTR_NE(k1->cert->principals[1], NULL);
508 ASSERT_PTR_NE(k1->cert->principals[2], NULL);
509 ASSERT_PTR_NE(k1->cert->principals[3], NULL);
510 k1->cert->nprincipals = 4;
511 k1->cert->valid_after = 0;
512 k1->cert->valid_before = (uint64_t)-1;
513 sshbuf_free(k1->cert->critical);
514 k1->cert->critical = sshbuf_new();
515 ASSERT_PTR_NE(k1->cert->critical, NULL);
516 sshbuf_free(k1->cert->extensions);
517 k1->cert->extensions = sshbuf_new();
518 ASSERT_PTR_NE(k1->cert->extensions, NULL);
519 put_opt(k1->cert->critical, "force-command", "/usr/bin/true");
520 put_opt(k1->cert->critical, "source-address", "127.0.0.1");
521 put_opt(k1->cert->extensions, "permit-X11-forwarding", NULL);
522 put_opt(k1->cert->extensions, "permit-agent-forwarding", NULL);
523 ASSERT_INT_EQ(sshkey_from_private(k2, &k1->cert->signature_key), 0);
524 ASSERT_INT_EQ(sshkey_certify(k1, k2, NULL, NULL, NULL), 0);
525 b = sshbuf_new();
526 ASSERT_PTR_NE(b, NULL);
527 ASSERT_INT_EQ(sshkey_putb(k1, b), 0);
528 ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k3), 0);
529
530 sshkey_free(k1);
531 sshkey_free(k2);
532 sshkey_free(k3);
533 k1 = k2 = k3 = NULL;
534 sshbuf_reset(b);
535 TEST_DONE();
536
537 TEST_START("certify key MLDSA44-ED25519");
538 ASSERT_INT_EQ(sshkey_load_public(
539 test_data_file("mldsa44_ed25519_1.pub"), &k1, NULL), 0);
540 k2 = get_private("mldsa44_ed25519_2");
541 ASSERT_INT_EQ(sshkey_to_certified(k1), 0);
542 ASSERT_PTR_NE(k1->cert, NULL);
543 k1->cert->type = SSH2_CERT_TYPE_USER;
544 k1->cert->serial = 1234;
545 k1->cert->key_id = strdup("estragon");
546 ASSERT_PTR_NE(k1->cert->key_id, NULL);
547 k1->cert->principals = calloc(4, sizeof(*k1->cert->principals));
548 ASSERT_PTR_NE(k1->cert->principals, NULL);
549 k1->cert->principals[0] = strdup("estragon");
550 k1->cert->principals[1] = strdup("vladimir");
551 k1->cert->principals[2] = strdup("pozzo");
552 k1->cert->principals[3] = strdup("lucky");
553 ASSERT_PTR_NE(k1->cert->principals[0], NULL);
554 ASSERT_PTR_NE(k1->cert->principals[1], NULL);
555 ASSERT_PTR_NE(k1->cert->principals[2], NULL);
556 ASSERT_PTR_NE(k1->cert->principals[3], NULL);
557 k1->cert->nprincipals = 4;
558 k1->cert->valid_after = 0;
559 k1->cert->valid_before = (uint64_t)-1;
560 sshbuf_free(k1->cert->critical);
561 k1->cert->critical = sshbuf_new();
562 ASSERT_PTR_NE(k1->cert->critical, NULL);
563 sshbuf_free(k1->cert->extensions);
564 k1->cert->extensions = sshbuf_new();
565 ASSERT_PTR_NE(k1->cert->extensions, NULL);
566 put_opt(k1->cert->critical, "force-command", "/usr/bin/true");
567 put_opt(k1->cert->critical, "source-address", "127.0.0.1");
568 put_opt(k1->cert->extensions, "permit-X11-forwarding", NULL);
569 put_opt(k1->cert->extensions, "permit-agent-forwarding", NULL);
570 ASSERT_INT_EQ(sshkey_from_private(k2, &k1->cert->signature_key), 0);
571 ASSERT_INT_EQ(sshkey_certify(k1, k2, NULL, NULL, NULL), 0);
572 b = sshbuf_new();
573 ASSERT_PTR_NE(b, NULL);
574 ASSERT_INT_EQ(sshkey_putb(k1, b), 0);
575 ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k3), 0);
576 sshkey_free(k1);
577 sshkey_free(k2);
578 sshkey_free(k3);
579 k1 = k2 = k3 = NULL;
580 sshbuf_reset(b);
581 TEST_DONE();
582
583 #ifdef WITH_OPENSSL
584 TEST_START("sign and verify RSA");
585 k1 = get_private("rsa_1");
586 ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2,
587 NULL), 0);
588 signature_tests(k1, k2, "ssh-rsa");
589 sshkey_free(k1);
590 sshkey_free(k2);
591 k1 = k2 = NULL;
592 TEST_DONE();
593
594 TEST_START("sign and verify RSA-SHA256");
595 k1 = get_private("rsa_1");
596 ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2,
597 NULL), 0);
598 signature_tests(k1, k2, "rsa-sha2-256");
599 sshkey_free(k1);
600 sshkey_free(k2);
601 k1 = k2 = NULL;
602 TEST_DONE();
603
604 TEST_START("sign and verify RSA-SHA512");
605 k1 = get_private("rsa_1");
606 ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2,
607 NULL), 0);
608 signature_tests(k1, k2, "rsa-sha2-512");
609 sshkey_free(k1);
610 sshkey_free(k2);
611 k1 = k2 = NULL;
612 TEST_DONE();
613
614
615 #ifdef OPENSSL_HAS_ECC
616 TEST_START("sign and verify ECDSA");
617 k1 = get_private("ecdsa_1");
618 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_2.pub"), &k2,
619 NULL), 0);
620 signature_tests(k1, k2, NULL);
621 sshkey_free(k1);
622 sshkey_free(k2);
623 k1 = k2 = NULL;
624 TEST_DONE();
625 #endif /* OPENSSL_HAS_ECC */
626 #endif /* WITH_OPENSSL */
627
628 TEST_START("sign and verify ED25519");
629 k1 = get_private("ed25519_1");
630 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_2.pub"), &k2,
631 NULL), 0);
632 signature_tests(k1, k2, NULL);
633 sshkey_free(k1);
634 sshkey_free(k2);
635 k1 = k2 = NULL;
636 TEST_DONE();
637
638 TEST_START("sign and verify MLDSA44-ED25519");
639 k1 = get_private("mldsa44_ed25519_1");
640 ASSERT_INT_EQ(sshkey_load_public(
641 test_data_file("mldsa44_ed25519_2.pub"), &k2, NULL), 0);
642 signature_tests(k1, k2, NULL);
643 sshkey_free(k1);
644 sshkey_free(k2);
645 k1 = k2 = NULL;
646 TEST_DONE();
647
648 #ifdef WITH_OPENSSL
649 TEST_START("nested certificate");
650 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("rsa_1"), &k1), 0);
651 ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_1.pub"), &k2,
652 NULL), 0);
653 k3 = get_private("rsa_1");
654 build_cert(b, k2, "ssh-rsa-cert-v01@openssh.com", k3, k1, NULL);
655 ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k4),
656 SSH_ERR_KEY_CERT_INVALID_SIGN_KEY);
657 ASSERT_PTR_EQ(k4, NULL);
658 sshkey_free(k1);
659 sshkey_free(k2);
660 sshkey_free(k3);
661 k1 = k2 = k3 = NULL;
662 sshbuf_free(b);
663 TEST_DONE();
664 #endif /* WITH_OPENSSL */
665 }
666
667 void
sshkey_benchmarks(void)668 sshkey_benchmarks(void)
669 {
670 struct sshkey *k = NULL;
671
672 #ifdef WITH_OPENSSL
673 BENCH_START("generate RSA-1024");
674 TEST_START("generate KEY_RSA");
675 ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1024, &k), 0);
676 ASSERT_PTR_NE(k, NULL);
677 sshkey_free(k);
678 k = NULL;
679 TEST_DONE();
680 BENCH_FINISH("keys");
681
682 BENCH_START("generate RSA-2048");
683 TEST_START("generate KEY_RSA");
684 ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 2048, &k), 0);
685 ASSERT_PTR_NE(k, NULL);
686 sshkey_free(k);
687 k = NULL;
688 TEST_DONE();
689 BENCH_FINISH("keys");
690
691 BENCH_START("generate ECDSA-256");
692 TEST_START("generate KEY_ECDSA");
693 ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 256, &k), 0);
694 ASSERT_PTR_NE(k, NULL);
695 sshkey_free(k);
696 k = NULL;
697 TEST_DONE();
698 BENCH_FINISH("keys");
699
700 BENCH_START("generate ECDSA-384");
701 TEST_START("generate KEY_ECDSA");
702 ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 384, &k), 0);
703 ASSERT_PTR_NE(k, NULL);
704 sshkey_free(k);
705 k = NULL;
706 TEST_DONE();
707 BENCH_FINISH("keys");
708
709 BENCH_START("generate ECDSA-521");
710 TEST_START("generate KEY_ECDSA");
711 ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 521, &k), 0);
712 ASSERT_PTR_NE(k, NULL);
713 sshkey_free(k);
714 k = NULL;
715 TEST_DONE();
716 BENCH_FINISH("keys");
717 #endif /* WITH_OPENSSL */
718
719 BENCH_START("generate ED25519");
720 TEST_START("generate KEY_ED25519");
721 ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 256, &k), 0);
722 ASSERT_PTR_NE(k, NULL);
723 sshkey_free(k);
724 k = NULL;
725 TEST_DONE();
726 BENCH_FINISH("keys");
727
728 BENCH_START("generate MLDSA44-ED25519");
729 TEST_START("generate KEY_MLDSA44_ED25519");
730 ASSERT_INT_EQ(sshkey_generate(KEY_MLDSA44_ED25519, 256, &k), 0);
731 ASSERT_PTR_NE(k, NULL);
732 sshkey_free(k);
733 k = NULL;
734 TEST_DONE();
735 BENCH_FINISH("keys");
736
737 #ifdef WITH_OPENSSL
738 /* sign */
739 signature_benchmark("RSA-1024/SHA1", KEY_RSA, 1024, "ssh-rsa", 0);
740 signature_benchmark("RSA-1024/SHA256", KEY_RSA, 1024, "rsa-sha2-256", 0);
741 signature_benchmark("RSA-1024/SHA512", KEY_RSA, 1024, "rsa-sha2-512", 0);
742 signature_benchmark("RSA-2048/SHA1", KEY_RSA, 2048, "ssh-rsa", 0);
743 signature_benchmark("RSA-2048/SHA256", KEY_RSA, 2048, "rsa-sha2-256", 0);
744 signature_benchmark("RSA-2048/SHA512", KEY_RSA, 2048, "rsa-sha2-512", 0);
745 signature_benchmark("ECDSA-256", KEY_ECDSA, 256, NULL, 0);
746 signature_benchmark("ECDSA-384", KEY_ECDSA, 384, NULL, 0);
747 signature_benchmark("ECDSA-521", KEY_ECDSA, 521, NULL, 0);
748 signature_benchmark("ED25519", KEY_ED25519, 0, NULL, 0);
749 signature_benchmark("MLDSA44-ED25519", KEY_MLDSA44_ED25519, 0, NULL, 0);
750
751 /* verify */
752 signature_benchmark("RSA-1024/SHA1", KEY_RSA, 1024, "ssh-rsa", 1);
753 signature_benchmark("RSA-1024/SHA256", KEY_RSA, 1024, "rsa-sha2-256", 1);
754 signature_benchmark("RSA-1024/SHA512", KEY_RSA, 1024, "rsa-sha2-512", 1);
755 signature_benchmark("RSA-2048/SHA1", KEY_RSA, 2048, "ssh-rsa", 1);
756 signature_benchmark("RSA-2048/SHA256", KEY_RSA, 2048, "rsa-sha2-256", 1);
757 signature_benchmark("RSA-2048/SHA512", KEY_RSA, 2048, "rsa-sha2-512", 1);
758 signature_benchmark("ECDSA-256", KEY_ECDSA, 256, NULL, 1);
759 signature_benchmark("ECDSA-384", KEY_ECDSA, 384, NULL, 1);
760 signature_benchmark("ECDSA-521", KEY_ECDSA, 521, NULL, 1);
761 #endif /* WITH_OPENSSL */
762 signature_benchmark("ED25519", KEY_ED25519, 0, NULL, 1);
763 signature_benchmark("MLDSA44-ED25519", KEY_MLDSA44_ED25519, 0, NULL, 1);
764 }
765