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