1 /* 	$OpenBSD: test_file.c,v 1.9 2020/06/19 03:48:49 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 <sys/param.h>
12 #include <sys/stat.h>
13 #include <fcntl.h>
14 #include <stdio.h>
15 #ifdef HAVE_STDINT_H
16 #include <stdint.h>
17 #endif
18 #include <stdlib.h>
19 #include <string.h>
20 #include <unistd.h>
21 
22 #ifdef WITH_OPENSSL
23 #include <openssl/bn.h>
24 #include <openssl/rsa.h>
25 #include <openssl/dsa.h>
26 #include <openssl/objects.h>
27 #ifdef OPENSSL_HAS_NISTP256
28 # include <openssl/ec.h>
29 #endif /* OPENSSL_HAS_NISTP256 */
30 #endif /* WITH_OPENSSL */
31 
32 #include "../test_helper/test_helper.h"
33 
34 #include "ssherr.h"
35 #include "authfile.h"
36 #include "sshkey.h"
37 #include "sshbuf.h"
38 #include "digest.h"
39 
40 #include "common.h"
41 
42 void sshkey_file_tests(void);
43 
44 void
sshkey_file_tests(void)45 sshkey_file_tests(void)
46 {
47 	struct sshkey *k1, *k2;
48 	struct sshbuf *buf, *pw;
49 #ifdef WITH_OPENSSL
50 	BIGNUM *a, *b, *c;
51 #endif
52 	char *cp;
53 
54 	TEST_START("load passphrase");
55 	pw = load_text_file("pw");
56 	TEST_DONE();
57 
58 
59 #ifdef WITH_OPENSSL
60 	TEST_START("parse RSA from private");
61 	buf = load_file("rsa_1");
62 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0);
63 	sshbuf_free(buf);
64 	ASSERT_PTR_NE(k1, NULL);
65 	a = load_bignum("rsa_1.param.n");
66 	b = load_bignum("rsa_1.param.p");
67 	c = load_bignum("rsa_1.param.q");
68 	ASSERT_BIGNUM_EQ(rsa_n(k1), a);
69 	ASSERT_BIGNUM_EQ(rsa_p(k1), b);
70 	ASSERT_BIGNUM_EQ(rsa_q(k1), c);
71 	BN_free(a);
72 	BN_free(b);
73 	BN_free(c);
74 	TEST_DONE();
75 
76 	TEST_START("parse RSA from private w/ passphrase");
77 	buf = load_file("rsa_1_pw");
78 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
79 	    (const char *)sshbuf_ptr(pw), &k2, NULL), 0);
80 	sshbuf_free(buf);
81 	ASSERT_PTR_NE(k2, NULL);
82 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
83 	sshkey_free(k2);
84 	TEST_DONE();
85 
86 	TEST_START("parse RSA from new-format");
87 	buf = load_file("rsa_n");
88 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k2, NULL), 0);
89 	sshbuf_free(buf);
90 	ASSERT_PTR_NE(k2, NULL);
91 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
92 	sshkey_free(k2);
93 	TEST_DONE();
94 
95 	TEST_START("parse RSA from new-format w/ passphrase");
96 	buf = load_file("rsa_n_pw");
97 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
98 	    (const char *)sshbuf_ptr(pw), &k2, NULL), 0);
99 	sshbuf_free(buf);
100 	ASSERT_PTR_NE(k2, NULL);
101 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
102 	sshkey_free(k2);
103 	TEST_DONE();
104 
105 	TEST_START("load RSA from public");
106 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_1.pub"), &k2,
107 	    NULL), 0);
108 	ASSERT_PTR_NE(k2, NULL);
109 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
110 	sshkey_free(k2);
111 	TEST_DONE();
112 
113 	TEST_START("load RSA cert with SHA1 signature");
114 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("rsa_1_sha1"), &k2), 0);
115 	ASSERT_PTR_NE(k2, NULL);
116 	ASSERT_INT_EQ(k2->type, KEY_RSA_CERT);
117 	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
118 	ASSERT_STRING_EQ(k2->cert->signature_type, "ssh-rsa");
119 	sshkey_free(k2);
120 	TEST_DONE();
121 
122 	TEST_START("load RSA cert with SHA512 signature");
123 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("rsa_1_sha512"), &k2), 0);
124 	ASSERT_PTR_NE(k2, NULL);
125 	ASSERT_INT_EQ(k2->type, KEY_RSA_CERT);
126 	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
127 	ASSERT_STRING_EQ(k2->cert->signature_type, "rsa-sha2-512");
128 	sshkey_free(k2);
129 	TEST_DONE();
130 
131 	TEST_START("load RSA cert");
132 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("rsa_1"), &k2), 0);
133 	ASSERT_PTR_NE(k2, NULL);
134 	ASSERT_INT_EQ(k2->type, KEY_RSA_CERT);
135 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
136 	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
137 	TEST_DONE();
138 
139 	TEST_START("RSA key hex fingerprint");
140 	buf = load_text_file("rsa_1.fp");
141 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64);
142 	ASSERT_PTR_NE(cp, NULL);
143 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
144 	sshbuf_free(buf);
145 	free(cp);
146 	TEST_DONE();
147 
148 	TEST_START("RSA cert hex fingerprint");
149 	buf = load_text_file("rsa_1-cert.fp");
150 	cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64);
151 	ASSERT_PTR_NE(cp, NULL);
152 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
153 	sshbuf_free(buf);
154 	free(cp);
155 	sshkey_free(k2);
156 	TEST_DONE();
157 
158 	TEST_START("RSA key bubblebabble fingerprint");
159 	buf = load_text_file("rsa_1.fp.bb");
160 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE);
161 	ASSERT_PTR_NE(cp, NULL);
162 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
163 	sshbuf_free(buf);
164 	free(cp);
165 	TEST_DONE();
166 
167 	sshkey_free(k1);
168 
169 	TEST_START("parse DSA from private");
170 	buf = load_file("dsa_1");
171 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0);
172 	sshbuf_free(buf);
173 	ASSERT_PTR_NE(k1, NULL);
174 	a = load_bignum("dsa_1.param.g");
175 	b = load_bignum("dsa_1.param.priv");
176 	c = load_bignum("dsa_1.param.pub");
177 	ASSERT_BIGNUM_EQ(dsa_g(k1), a);
178 	ASSERT_BIGNUM_EQ(dsa_priv_key(k1), b);
179 	ASSERT_BIGNUM_EQ(dsa_pub_key(k1), c);
180 	BN_free(a);
181 	BN_free(b);
182 	BN_free(c);
183 	TEST_DONE();
184 
185 	TEST_START("parse DSA from private w/ passphrase");
186 	buf = load_file("dsa_1_pw");
187 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
188 	    (const char *)sshbuf_ptr(pw), &k2, NULL), 0);
189 	sshbuf_free(buf);
190 	ASSERT_PTR_NE(k2, NULL);
191 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
192 	sshkey_free(k2);
193 	TEST_DONE();
194 
195 	TEST_START("parse DSA from new-format");
196 	buf = load_file("dsa_n");
197 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k2, NULL), 0);
198 	sshbuf_free(buf);
199 	ASSERT_PTR_NE(k2, NULL);
200 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
201 	sshkey_free(k2);
202 	TEST_DONE();
203 
204 	TEST_START("parse DSA from new-format w/ passphrase");
205 	buf = load_file("dsa_n_pw");
206 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
207 	    (const char *)sshbuf_ptr(pw), &k2, NULL), 0);
208 	sshbuf_free(buf);
209 	ASSERT_PTR_NE(k2, NULL);
210 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
211 	sshkey_free(k2);
212 	TEST_DONE();
213 
214 	TEST_START("load DSA from public");
215 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("dsa_1.pub"), &k2,
216 	    NULL), 0);
217 	ASSERT_PTR_NE(k2, NULL);
218 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
219 	sshkey_free(k2);
220 	TEST_DONE();
221 
222 	TEST_START("load DSA cert");
223 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("dsa_1"), &k2), 0);
224 	ASSERT_PTR_NE(k2, NULL);
225 	ASSERT_INT_EQ(k2->type, KEY_DSA_CERT);
226 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
227 	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
228 	TEST_DONE();
229 
230 	TEST_START("DSA key hex fingerprint");
231 	buf = load_text_file("dsa_1.fp");
232 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64);
233 	ASSERT_PTR_NE(cp, NULL);
234 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
235 	sshbuf_free(buf);
236 	free(cp);
237 	TEST_DONE();
238 
239 	TEST_START("DSA cert hex fingerprint");
240 	buf = load_text_file("dsa_1-cert.fp");
241 	cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64);
242 	ASSERT_PTR_NE(cp, NULL);
243 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
244 	sshbuf_free(buf);
245 	free(cp);
246 	sshkey_free(k2);
247 	TEST_DONE();
248 
249 	TEST_START("DSA key bubblebabble fingerprint");
250 	buf = load_text_file("dsa_1.fp.bb");
251 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE);
252 	ASSERT_PTR_NE(cp, NULL);
253 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
254 	sshbuf_free(buf);
255 	free(cp);
256 	TEST_DONE();
257 
258 	sshkey_free(k1);
259 
260 #ifdef OPENSSL_HAS_ECC
261 	TEST_START("parse ECDSA from private");
262 	buf = load_file("ecdsa_1");
263 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0);
264 	sshbuf_free(buf);
265 	ASSERT_PTR_NE(k1, NULL);
266 	buf = load_text_file("ecdsa_1.param.curve");
267 	ASSERT_STRING_EQ((const char *)sshbuf_ptr(buf),
268 	    OBJ_nid2sn(k1->ecdsa_nid));
269 	sshbuf_free(buf);
270 	a = load_bignum("ecdsa_1.param.priv");
271 	b = load_bignum("ecdsa_1.param.pub");
272 	c = EC_POINT_point2bn(EC_KEY_get0_group(k1->ecdsa),
273 	    EC_KEY_get0_public_key(k1->ecdsa), POINT_CONVERSION_UNCOMPRESSED,
274 	    NULL, NULL);
275 	ASSERT_PTR_NE(c, NULL);
276 	ASSERT_BIGNUM_EQ(EC_KEY_get0_private_key(k1->ecdsa), a);
277 	ASSERT_BIGNUM_EQ(b, c);
278 	BN_free(a);
279 	BN_free(b);
280 	BN_free(c);
281 	TEST_DONE();
282 
283 	TEST_START("parse ECDSA from private w/ passphrase");
284 	buf = load_file("ecdsa_1_pw");
285 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
286 	    (const char *)sshbuf_ptr(pw), &k2, NULL), 0);
287 	sshbuf_free(buf);
288 	ASSERT_PTR_NE(k2, NULL);
289 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
290 	sshkey_free(k2);
291 	TEST_DONE();
292 
293 	TEST_START("parse ECDSA from new-format");
294 	buf = load_file("ecdsa_n");
295 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k2, NULL), 0);
296 	sshbuf_free(buf);
297 	ASSERT_PTR_NE(k2, NULL);
298 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
299 	sshkey_free(k2);
300 	TEST_DONE();
301 
302 	TEST_START("parse ECDSA from new-format w/ passphrase");
303 	buf = load_file("ecdsa_n_pw");
304 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
305 	    (const char *)sshbuf_ptr(pw), &k2, NULL), 0);
306 	sshbuf_free(buf);
307 	ASSERT_PTR_NE(k2, NULL);
308 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
309 	sshkey_free(k2);
310 	TEST_DONE();
311 
312 	TEST_START("load ECDSA from public");
313 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_1.pub"), &k2,
314 	    NULL), 0);
315 	ASSERT_PTR_NE(k2, NULL);
316 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
317 	sshkey_free(k2);
318 	TEST_DONE();
319 
320 	TEST_START("load ECDSA cert");
321 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ecdsa_1"), &k2), 0);
322 	ASSERT_PTR_NE(k2, NULL);
323 	ASSERT_INT_EQ(k2->type, KEY_ECDSA_CERT);
324 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
325 	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
326 	TEST_DONE();
327 
328 	TEST_START("ECDSA key hex fingerprint");
329 	buf = load_text_file("ecdsa_1.fp");
330 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64);
331 	ASSERT_PTR_NE(cp, NULL);
332 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
333 	sshbuf_free(buf);
334 	free(cp);
335 	TEST_DONE();
336 
337 	TEST_START("ECDSA cert hex fingerprint");
338 	buf = load_text_file("ecdsa_1-cert.fp");
339 	cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64);
340 	ASSERT_PTR_NE(cp, NULL);
341 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
342 	sshbuf_free(buf);
343 	free(cp);
344 	sshkey_free(k2);
345 	TEST_DONE();
346 
347 	TEST_START("ECDSA key bubblebabble fingerprint");
348 	buf = load_text_file("ecdsa_1.fp.bb");
349 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE);
350 	ASSERT_PTR_NE(cp, NULL);
351 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
352 	sshbuf_free(buf);
353 	free(cp);
354 	TEST_DONE();
355 
356 	sshkey_free(k1);
357 #endif /* OPENSSL_HAS_ECC */
358 #endif /* WITH_OPENSSL */
359 
360 	TEST_START("parse Ed25519 from private");
361 	buf = load_file("ed25519_1");
362 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0);
363 	sshbuf_free(buf);
364 	ASSERT_PTR_NE(k1, NULL);
365 	ASSERT_INT_EQ(k1->type, KEY_ED25519);
366 	/* XXX check key contents */
367 	TEST_DONE();
368 
369 	TEST_START("parse Ed25519 from private w/ passphrase");
370 	buf = load_file("ed25519_1_pw");
371 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
372 	    (const char *)sshbuf_ptr(pw), &k2, NULL), 0);
373 	sshbuf_free(buf);
374 	ASSERT_PTR_NE(k2, NULL);
375 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
376 	sshkey_free(k2);
377 	TEST_DONE();
378 
379 	TEST_START("load Ed25519 from public");
380 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_1.pub"), &k2,
381 	    NULL), 0);
382 	ASSERT_PTR_NE(k2, NULL);
383 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
384 	sshkey_free(k2);
385 	TEST_DONE();
386 
387 	TEST_START("load Ed25519 cert");
388 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ed25519_1"), &k2), 0);
389 	ASSERT_PTR_NE(k2, NULL);
390 	ASSERT_INT_EQ(k2->type, KEY_ED25519_CERT);
391 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
392 	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
393 	TEST_DONE();
394 
395 	TEST_START("Ed25519 key hex fingerprint");
396 	buf = load_text_file("ed25519_1.fp");
397 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64);
398 	ASSERT_PTR_NE(cp, NULL);
399 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
400 	sshbuf_free(buf);
401 	free(cp);
402 	TEST_DONE();
403 
404 	TEST_START("Ed25519 cert hex fingerprint");
405 	buf = load_text_file("ed25519_1-cert.fp");
406 	cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64);
407 	ASSERT_PTR_NE(cp, NULL);
408 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
409 	sshbuf_free(buf);
410 	free(cp);
411 	sshkey_free(k2);
412 	TEST_DONE();
413 
414 	TEST_START("Ed25519 key bubblebabble fingerprint");
415 	buf = load_text_file("ed25519_1.fp.bb");
416 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE);
417 	ASSERT_PTR_NE(cp, NULL);
418 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
419 	sshbuf_free(buf);
420 	free(cp);
421 	TEST_DONE();
422 
423 	sshkey_free(k1);
424 
425 #if defined(WITH_OPENSSL) && defined(OPENSSL_HAS_ECC)
426 	TEST_START("parse ECDSA-SK from private");
427 	buf = load_file("ecdsa_sk1");
428 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0);
429 	sshbuf_free(buf);
430 	ASSERT_PTR_NE(k1, NULL);
431 	ASSERT_INT_EQ(k1->type, KEY_ECDSA_SK);
432 	TEST_DONE();
433 
434 	TEST_START("parse ECDSA-SK from private w/ passphrase");
435 	buf = load_file("ecdsa_sk1_pw");
436 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
437 	    (const char *)sshbuf_ptr(pw), &k2, NULL), 0);
438 	sshbuf_free(buf);
439 	ASSERT_PTR_NE(k2, NULL);
440 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
441 	sshkey_free(k2);
442 	TEST_DONE();
443 
444 	TEST_START("load ECDSA-SK from public");
445 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_sk1.pub"), &k2,
446 	    NULL), 0);
447 	ASSERT_PTR_NE(k2, NULL);
448 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
449 	sshkey_free(k2);
450 	TEST_DONE();
451 
452 	TEST_START("load ECDSA-SK cert");
453 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ecdsa_sk1"), &k2), 0);
454 	ASSERT_PTR_NE(k2, NULL);
455 	ASSERT_INT_EQ(k2->type, KEY_ECDSA_SK_CERT);
456 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
457 	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
458 	TEST_DONE();
459 
460 	TEST_START("ECDSA-SK key hex fingerprint");
461 	buf = load_text_file("ecdsa_sk1.fp");
462 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64);
463 	ASSERT_PTR_NE(cp, NULL);
464 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
465 	sshbuf_free(buf);
466 	free(cp);
467 	TEST_DONE();
468 
469 	TEST_START("ECDSA-SK cert hex fingerprint");
470 	buf = load_text_file("ecdsa_sk1-cert.fp");
471 	cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64);
472 	ASSERT_PTR_NE(cp, NULL);
473 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
474 	sshbuf_free(buf);
475 	free(cp);
476 	sshkey_free(k2);
477 	TEST_DONE();
478 
479 	TEST_START("ECDSA-SK key bubblebabble fingerprint");
480 	buf = load_text_file("ecdsa_sk1.fp.bb");
481 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE);
482 	ASSERT_PTR_NE(cp, NULL);
483 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
484 	sshbuf_free(buf);
485 	free(cp);
486 	TEST_DONE();
487 
488 	sshkey_free(k1);
489 #endif
490 
491 	TEST_START("parse Ed25519-SK from private");
492 	buf = load_file("ed25519_sk1");
493 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0);
494 	sshbuf_free(buf);
495 	ASSERT_PTR_NE(k1, NULL);
496 	ASSERT_INT_EQ(k1->type, KEY_ED25519_SK);
497 	/* XXX check key contents */
498 	TEST_DONE();
499 
500 	TEST_START("parse Ed25519-SK from private w/ passphrase");
501 	buf = load_file("ed25519_sk1_pw");
502 	ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf,
503 	    (const char *)sshbuf_ptr(pw), &k2, NULL), 0);
504 	sshbuf_free(buf);
505 	ASSERT_PTR_NE(k2, NULL);
506 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
507 	sshkey_free(k2);
508 	TEST_DONE();
509 
510 	TEST_START("load Ed25519-SK from public");
511 	ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_sk1.pub"),
512 	    &k2, NULL), 0);
513 	ASSERT_PTR_NE(k2, NULL);
514 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 1);
515 	sshkey_free(k2);
516 	TEST_DONE();
517 
518 	TEST_START("load Ed25519-SK cert");
519 	ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ed25519_sk1"), &k2), 0);
520 	ASSERT_PTR_NE(k2, NULL);
521 	ASSERT_INT_EQ(k2->type, KEY_ED25519_SK_CERT);
522 	ASSERT_INT_EQ(sshkey_equal(k1, k2), 0);
523 	ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1);
524 	TEST_DONE();
525 
526 	TEST_START("Ed25519-SK key hex fingerprint");
527 	buf = load_text_file("ed25519_sk1.fp");
528 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64);
529 	ASSERT_PTR_NE(cp, NULL);
530 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
531 	sshbuf_free(buf);
532 	free(cp);
533 	TEST_DONE();
534 
535 	TEST_START("Ed25519-SK cert hex fingerprint");
536 	buf = load_text_file("ed25519_sk1-cert.fp");
537 	cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64);
538 	ASSERT_PTR_NE(cp, NULL);
539 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
540 	sshbuf_free(buf);
541 	free(cp);
542 	sshkey_free(k2);
543 	TEST_DONE();
544 
545 	TEST_START("Ed25519-SK key bubblebabble fingerprint");
546 	buf = load_text_file("ed25519_sk1.fp.bb");
547 	cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE);
548 	ASSERT_PTR_NE(cp, NULL);
549 	ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf));
550 	sshbuf_free(buf);
551 	free(cp);
552 	TEST_DONE();
553 
554 	sshkey_free(k1);
555 
556 	sshbuf_free(pw);
557 
558 }
559