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 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