1 /* $OpenBSD: test_file.c,v 1.11 2024/01/11 01:45:58 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 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(k1->ecdsa), 262 EC_KEY_get0_public_key(k1->ecdsa), POINT_CONVERSION_UNCOMPRESSED, 263 NULL, NULL); 264 ASSERT_PTR_NE(c, NULL); 265 ASSERT_BIGNUM_EQ(EC_KEY_get0_private_key(k1->ecdsa), a); 266 ASSERT_BIGNUM_EQ(b, c); 267 BN_free(a); 268 BN_free(b); 269 BN_free(c); 270 TEST_DONE(); 271 272 TEST_START("parse ECDSA from private w/ passphrase"); 273 buf = load_file("ecdsa_1_pw"); 274 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 275 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 276 sshbuf_free(buf); 277 ASSERT_PTR_NE(k2, NULL); 278 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 279 sshkey_free(k2); 280 TEST_DONE(); 281 282 TEST_START("parse ECDSA from new-format"); 283 buf = load_file("ecdsa_n"); 284 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k2, NULL), 0); 285 sshbuf_free(buf); 286 ASSERT_PTR_NE(k2, NULL); 287 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 288 sshkey_free(k2); 289 TEST_DONE(); 290 291 TEST_START("parse ECDSA from new-format w/ passphrase"); 292 buf = load_file("ecdsa_n_pw"); 293 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 294 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 295 sshbuf_free(buf); 296 ASSERT_PTR_NE(k2, NULL); 297 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 298 sshkey_free(k2); 299 TEST_DONE(); 300 301 TEST_START("load ECDSA from public"); 302 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_1.pub"), &k2, 303 NULL), 0); 304 ASSERT_PTR_NE(k2, NULL); 305 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 306 sshkey_free(k2); 307 TEST_DONE(); 308 309 TEST_START("load ECDSA cert"); 310 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ecdsa_1"), &k2), 0); 311 ASSERT_PTR_NE(k2, NULL); 312 ASSERT_INT_EQ(k2->type, KEY_ECDSA_CERT); 313 ASSERT_INT_EQ(sshkey_equal(k1, k2), 0); 314 ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1); 315 TEST_DONE(); 316 317 TEST_START("ECDSA key hex fingerprint"); 318 buf = load_text_file("ecdsa_1.fp"); 319 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64); 320 ASSERT_PTR_NE(cp, NULL); 321 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 322 sshbuf_free(buf); 323 free(cp); 324 TEST_DONE(); 325 326 TEST_START("ECDSA cert hex fingerprint"); 327 buf = load_text_file("ecdsa_1-cert.fp"); 328 cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64); 329 ASSERT_PTR_NE(cp, NULL); 330 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 331 sshbuf_free(buf); 332 free(cp); 333 sshkey_free(k2); 334 TEST_DONE(); 335 336 TEST_START("ECDSA key bubblebabble fingerprint"); 337 buf = load_text_file("ecdsa_1.fp.bb"); 338 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE); 339 ASSERT_PTR_NE(cp, NULL); 340 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 341 sshbuf_free(buf); 342 free(cp); 343 TEST_DONE(); 344 345 sshkey_free(k1); 346 347 TEST_START("parse Ed25519 from private"); 348 buf = load_file("ed25519_1"); 349 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0); 350 sshbuf_free(buf); 351 ASSERT_PTR_NE(k1, NULL); 352 ASSERT_INT_EQ(k1->type, KEY_ED25519); 353 /* XXX check key contents */ 354 TEST_DONE(); 355 356 TEST_START("parse Ed25519 from private w/ passphrase"); 357 buf = load_file("ed25519_1_pw"); 358 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 359 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 360 sshbuf_free(buf); 361 ASSERT_PTR_NE(k2, NULL); 362 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 363 sshkey_free(k2); 364 TEST_DONE(); 365 366 TEST_START("load Ed25519 from public"); 367 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_1.pub"), &k2, 368 NULL), 0); 369 ASSERT_PTR_NE(k2, NULL); 370 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 371 sshkey_free(k2); 372 TEST_DONE(); 373 374 TEST_START("load Ed25519 cert"); 375 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ed25519_1"), &k2), 0); 376 ASSERT_PTR_NE(k2, NULL); 377 ASSERT_INT_EQ(k2->type, KEY_ED25519_CERT); 378 ASSERT_INT_EQ(sshkey_equal(k1, k2), 0); 379 ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1); 380 TEST_DONE(); 381 382 TEST_START("Ed25519 key hex fingerprint"); 383 buf = load_text_file("ed25519_1.fp"); 384 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64); 385 ASSERT_PTR_NE(cp, NULL); 386 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 387 sshbuf_free(buf); 388 free(cp); 389 TEST_DONE(); 390 391 TEST_START("Ed25519 cert hex fingerprint"); 392 buf = load_text_file("ed25519_1-cert.fp"); 393 cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64); 394 ASSERT_PTR_NE(cp, NULL); 395 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 396 sshbuf_free(buf); 397 free(cp); 398 sshkey_free(k2); 399 TEST_DONE(); 400 401 TEST_START("Ed25519 key bubblebabble fingerprint"); 402 buf = load_text_file("ed25519_1.fp.bb"); 403 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE); 404 ASSERT_PTR_NE(cp, NULL); 405 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 406 sshbuf_free(buf); 407 free(cp); 408 TEST_DONE(); 409 410 sshkey_free(k1); 411 412 TEST_START("parse ECDSA-SK from private"); 413 buf = load_file("ecdsa_sk1"); 414 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0); 415 sshbuf_free(buf); 416 ASSERT_PTR_NE(k1, NULL); 417 ASSERT_INT_EQ(k1->type, KEY_ECDSA_SK); 418 TEST_DONE(); 419 420 TEST_START("parse ECDSA-SK from private w/ passphrase"); 421 buf = load_file("ecdsa_sk1_pw"); 422 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 423 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 424 sshbuf_free(buf); 425 ASSERT_PTR_NE(k2, NULL); 426 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 427 sshkey_free(k2); 428 TEST_DONE(); 429 430 TEST_START("load ECDSA-SK from public"); 431 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_sk1.pub"), &k2, 432 NULL), 0); 433 ASSERT_PTR_NE(k2, NULL); 434 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 435 sshkey_free(k2); 436 TEST_DONE(); 437 438 TEST_START("load ECDSA-SK cert"); 439 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ecdsa_sk1"), &k2), 0); 440 ASSERT_PTR_NE(k2, NULL); 441 ASSERT_INT_EQ(k2->type, KEY_ECDSA_SK_CERT); 442 ASSERT_INT_EQ(sshkey_equal(k1, k2), 0); 443 ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1); 444 TEST_DONE(); 445 446 TEST_START("ECDSA-SK key hex fingerprint"); 447 buf = load_text_file("ecdsa_sk1.fp"); 448 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64); 449 ASSERT_PTR_NE(cp, NULL); 450 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 451 sshbuf_free(buf); 452 free(cp); 453 TEST_DONE(); 454 455 TEST_START("ECDSA-SK cert hex fingerprint"); 456 buf = load_text_file("ecdsa_sk1-cert.fp"); 457 cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64); 458 ASSERT_PTR_NE(cp, NULL); 459 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 460 sshbuf_free(buf); 461 free(cp); 462 sshkey_free(k2); 463 TEST_DONE(); 464 465 TEST_START("ECDSA-SK key bubblebabble fingerprint"); 466 buf = load_text_file("ecdsa_sk1.fp.bb"); 467 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE); 468 ASSERT_PTR_NE(cp, NULL); 469 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 470 sshbuf_free(buf); 471 free(cp); 472 TEST_DONE(); 473 474 sshkey_free(k1); 475 476 TEST_START("parse Ed25519-SK from private"); 477 buf = load_file("ed25519_sk1"); 478 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0); 479 sshbuf_free(buf); 480 ASSERT_PTR_NE(k1, NULL); 481 ASSERT_INT_EQ(k1->type, KEY_ED25519_SK); 482 /* XXX check key contents */ 483 TEST_DONE(); 484 485 TEST_START("parse Ed25519-SK from private w/ passphrase"); 486 buf = load_file("ed25519_sk1_pw"); 487 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 488 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 489 sshbuf_free(buf); 490 ASSERT_PTR_NE(k2, NULL); 491 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 492 sshkey_free(k2); 493 TEST_DONE(); 494 495 TEST_START("load Ed25519-SK from public"); 496 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_sk1.pub"), 497 &k2, NULL), 0); 498 ASSERT_PTR_NE(k2, NULL); 499 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 500 sshkey_free(k2); 501 TEST_DONE(); 502 503 TEST_START("load Ed25519-SK cert"); 504 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ed25519_sk1"), &k2), 0); 505 ASSERT_PTR_NE(k2, NULL); 506 ASSERT_INT_EQ(k2->type, KEY_ED25519_SK_CERT); 507 ASSERT_INT_EQ(sshkey_equal(k1, k2), 0); 508 ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1); 509 TEST_DONE(); 510 511 TEST_START("Ed25519-SK key hex fingerprint"); 512 buf = load_text_file("ed25519_sk1.fp"); 513 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64); 514 ASSERT_PTR_NE(cp, NULL); 515 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 516 sshbuf_free(buf); 517 free(cp); 518 TEST_DONE(); 519 520 TEST_START("Ed25519-SK cert hex fingerprint"); 521 buf = load_text_file("ed25519_sk1-cert.fp"); 522 cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64); 523 ASSERT_PTR_NE(cp, NULL); 524 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 525 sshbuf_free(buf); 526 free(cp); 527 sshkey_free(k2); 528 TEST_DONE(); 529 530 TEST_START("Ed25519-SK key bubblebabble fingerprint"); 531 buf = load_text_file("ed25519_sk1.fp.bb"); 532 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE); 533 ASSERT_PTR_NE(cp, NULL); 534 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 535 sshbuf_free(buf); 536 free(cp); 537 TEST_DONE(); 538 539 sshkey_free(k1); 540 541 sshbuf_free(pw); 542 543 } 544