1 /* $OpenBSD: test_file.c,v 1.10 2021/12/14 21:25:27 deraadt 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 TEST_START("parse DSA from private"); 158 buf = load_file("dsa_1"); 159 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0); 160 sshbuf_free(buf); 161 ASSERT_PTR_NE(k1, NULL); 162 a = load_bignum("dsa_1.param.g"); 163 b = load_bignum("dsa_1.param.priv"); 164 c = load_bignum("dsa_1.param.pub"); 165 ASSERT_BIGNUM_EQ(dsa_g(k1), a); 166 ASSERT_BIGNUM_EQ(dsa_priv_key(k1), b); 167 ASSERT_BIGNUM_EQ(dsa_pub_key(k1), c); 168 BN_free(a); 169 BN_free(b); 170 BN_free(c); 171 TEST_DONE(); 172 173 TEST_START("parse DSA from private w/ passphrase"); 174 buf = load_file("dsa_1_pw"); 175 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 176 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 177 sshbuf_free(buf); 178 ASSERT_PTR_NE(k2, NULL); 179 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 180 sshkey_free(k2); 181 TEST_DONE(); 182 183 TEST_START("parse DSA from new-format"); 184 buf = load_file("dsa_n"); 185 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k2, NULL), 0); 186 sshbuf_free(buf); 187 ASSERT_PTR_NE(k2, NULL); 188 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 189 sshkey_free(k2); 190 TEST_DONE(); 191 192 TEST_START("parse DSA from new-format w/ passphrase"); 193 buf = load_file("dsa_n_pw"); 194 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 195 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 196 sshbuf_free(buf); 197 ASSERT_PTR_NE(k2, NULL); 198 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 199 sshkey_free(k2); 200 TEST_DONE(); 201 202 TEST_START("load DSA from public"); 203 ASSERT_INT_EQ(sshkey_load_public(test_data_file("dsa_1.pub"), &k2, 204 NULL), 0); 205 ASSERT_PTR_NE(k2, NULL); 206 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 207 sshkey_free(k2); 208 TEST_DONE(); 209 210 TEST_START("load DSA cert"); 211 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("dsa_1"), &k2), 0); 212 ASSERT_PTR_NE(k2, NULL); 213 ASSERT_INT_EQ(k2->type, KEY_DSA_CERT); 214 ASSERT_INT_EQ(sshkey_equal(k1, k2), 0); 215 ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1); 216 TEST_DONE(); 217 218 TEST_START("DSA key hex fingerprint"); 219 buf = load_text_file("dsa_1.fp"); 220 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64); 221 ASSERT_PTR_NE(cp, NULL); 222 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 223 sshbuf_free(buf); 224 free(cp); 225 TEST_DONE(); 226 227 TEST_START("DSA cert hex fingerprint"); 228 buf = load_text_file("dsa_1-cert.fp"); 229 cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64); 230 ASSERT_PTR_NE(cp, NULL); 231 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 232 sshbuf_free(buf); 233 free(cp); 234 sshkey_free(k2); 235 TEST_DONE(); 236 237 TEST_START("DSA key bubblebabble fingerprint"); 238 buf = load_text_file("dsa_1.fp.bb"); 239 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE); 240 ASSERT_PTR_NE(cp, NULL); 241 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 242 sshbuf_free(buf); 243 free(cp); 244 TEST_DONE(); 245 246 sshkey_free(k1); 247 248 TEST_START("parse ECDSA from private"); 249 buf = load_file("ecdsa_1"); 250 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0); 251 sshbuf_free(buf); 252 ASSERT_PTR_NE(k1, NULL); 253 buf = load_text_file("ecdsa_1.param.curve"); 254 ASSERT_STRING_EQ((const char *)sshbuf_ptr(buf), 255 OBJ_nid2sn(k1->ecdsa_nid)); 256 sshbuf_free(buf); 257 a = load_bignum("ecdsa_1.param.priv"); 258 b = load_bignum("ecdsa_1.param.pub"); 259 c = EC_POINT_point2bn(EC_KEY_get0_group(k1->ecdsa), 260 EC_KEY_get0_public_key(k1->ecdsa), POINT_CONVERSION_UNCOMPRESSED, 261 NULL, NULL); 262 ASSERT_PTR_NE(c, NULL); 263 ASSERT_BIGNUM_EQ(EC_KEY_get0_private_key(k1->ecdsa), a); 264 ASSERT_BIGNUM_EQ(b, c); 265 BN_free(a); 266 BN_free(b); 267 BN_free(c); 268 TEST_DONE(); 269 270 TEST_START("parse ECDSA from private w/ passphrase"); 271 buf = load_file("ecdsa_1_pw"); 272 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 273 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 274 sshbuf_free(buf); 275 ASSERT_PTR_NE(k2, NULL); 276 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 277 sshkey_free(k2); 278 TEST_DONE(); 279 280 TEST_START("parse ECDSA from new-format"); 281 buf = load_file("ecdsa_n"); 282 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k2, NULL), 0); 283 sshbuf_free(buf); 284 ASSERT_PTR_NE(k2, NULL); 285 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 286 sshkey_free(k2); 287 TEST_DONE(); 288 289 TEST_START("parse ECDSA from new-format w/ passphrase"); 290 buf = load_file("ecdsa_n_pw"); 291 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 292 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 293 sshbuf_free(buf); 294 ASSERT_PTR_NE(k2, NULL); 295 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 296 sshkey_free(k2); 297 TEST_DONE(); 298 299 TEST_START("load ECDSA from public"); 300 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_1.pub"), &k2, 301 NULL), 0); 302 ASSERT_PTR_NE(k2, NULL); 303 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 304 sshkey_free(k2); 305 TEST_DONE(); 306 307 TEST_START("load ECDSA cert"); 308 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ecdsa_1"), &k2), 0); 309 ASSERT_PTR_NE(k2, NULL); 310 ASSERT_INT_EQ(k2->type, KEY_ECDSA_CERT); 311 ASSERT_INT_EQ(sshkey_equal(k1, k2), 0); 312 ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1); 313 TEST_DONE(); 314 315 TEST_START("ECDSA key hex fingerprint"); 316 buf = load_text_file("ecdsa_1.fp"); 317 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64); 318 ASSERT_PTR_NE(cp, NULL); 319 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 320 sshbuf_free(buf); 321 free(cp); 322 TEST_DONE(); 323 324 TEST_START("ECDSA cert hex fingerprint"); 325 buf = load_text_file("ecdsa_1-cert.fp"); 326 cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64); 327 ASSERT_PTR_NE(cp, NULL); 328 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 329 sshbuf_free(buf); 330 free(cp); 331 sshkey_free(k2); 332 TEST_DONE(); 333 334 TEST_START("ECDSA key bubblebabble fingerprint"); 335 buf = load_text_file("ecdsa_1.fp.bb"); 336 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE); 337 ASSERT_PTR_NE(cp, NULL); 338 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 339 sshbuf_free(buf); 340 free(cp); 341 TEST_DONE(); 342 343 sshkey_free(k1); 344 345 TEST_START("parse Ed25519 from private"); 346 buf = load_file("ed25519_1"); 347 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0); 348 sshbuf_free(buf); 349 ASSERT_PTR_NE(k1, NULL); 350 ASSERT_INT_EQ(k1->type, KEY_ED25519); 351 /* XXX check key contents */ 352 TEST_DONE(); 353 354 TEST_START("parse Ed25519 from private w/ passphrase"); 355 buf = load_file("ed25519_1_pw"); 356 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 357 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 358 sshbuf_free(buf); 359 ASSERT_PTR_NE(k2, NULL); 360 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 361 sshkey_free(k2); 362 TEST_DONE(); 363 364 TEST_START("load Ed25519 from public"); 365 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_1.pub"), &k2, 366 NULL), 0); 367 ASSERT_PTR_NE(k2, NULL); 368 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 369 sshkey_free(k2); 370 TEST_DONE(); 371 372 TEST_START("load Ed25519 cert"); 373 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ed25519_1"), &k2), 0); 374 ASSERT_PTR_NE(k2, NULL); 375 ASSERT_INT_EQ(k2->type, KEY_ED25519_CERT); 376 ASSERT_INT_EQ(sshkey_equal(k1, k2), 0); 377 ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1); 378 TEST_DONE(); 379 380 TEST_START("Ed25519 key hex fingerprint"); 381 buf = load_text_file("ed25519_1.fp"); 382 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64); 383 ASSERT_PTR_NE(cp, NULL); 384 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 385 sshbuf_free(buf); 386 free(cp); 387 TEST_DONE(); 388 389 TEST_START("Ed25519 cert hex fingerprint"); 390 buf = load_text_file("ed25519_1-cert.fp"); 391 cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64); 392 ASSERT_PTR_NE(cp, NULL); 393 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 394 sshbuf_free(buf); 395 free(cp); 396 sshkey_free(k2); 397 TEST_DONE(); 398 399 TEST_START("Ed25519 key bubblebabble fingerprint"); 400 buf = load_text_file("ed25519_1.fp.bb"); 401 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE); 402 ASSERT_PTR_NE(cp, NULL); 403 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 404 sshbuf_free(buf); 405 free(cp); 406 TEST_DONE(); 407 408 sshkey_free(k1); 409 410 TEST_START("parse ECDSA-SK from private"); 411 buf = load_file("ecdsa_sk1"); 412 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0); 413 sshbuf_free(buf); 414 ASSERT_PTR_NE(k1, NULL); 415 ASSERT_INT_EQ(k1->type, KEY_ECDSA_SK); 416 TEST_DONE(); 417 418 TEST_START("parse ECDSA-SK from private w/ passphrase"); 419 buf = load_file("ecdsa_sk1_pw"); 420 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 421 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 422 sshbuf_free(buf); 423 ASSERT_PTR_NE(k2, NULL); 424 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 425 sshkey_free(k2); 426 TEST_DONE(); 427 428 TEST_START("load ECDSA-SK from public"); 429 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_sk1.pub"), &k2, 430 NULL), 0); 431 ASSERT_PTR_NE(k2, NULL); 432 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 433 sshkey_free(k2); 434 TEST_DONE(); 435 436 TEST_START("load ECDSA-SK cert"); 437 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ecdsa_sk1"), &k2), 0); 438 ASSERT_PTR_NE(k2, NULL); 439 ASSERT_INT_EQ(k2->type, KEY_ECDSA_SK_CERT); 440 ASSERT_INT_EQ(sshkey_equal(k1, k2), 0); 441 ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1); 442 TEST_DONE(); 443 444 TEST_START("ECDSA-SK key hex fingerprint"); 445 buf = load_text_file("ecdsa_sk1.fp"); 446 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64); 447 ASSERT_PTR_NE(cp, NULL); 448 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 449 sshbuf_free(buf); 450 free(cp); 451 TEST_DONE(); 452 453 TEST_START("ECDSA-SK cert hex fingerprint"); 454 buf = load_text_file("ecdsa_sk1-cert.fp"); 455 cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64); 456 ASSERT_PTR_NE(cp, NULL); 457 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 458 sshbuf_free(buf); 459 free(cp); 460 sshkey_free(k2); 461 TEST_DONE(); 462 463 TEST_START("ECDSA-SK key bubblebabble fingerprint"); 464 buf = load_text_file("ecdsa_sk1.fp.bb"); 465 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE); 466 ASSERT_PTR_NE(cp, NULL); 467 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 468 sshbuf_free(buf); 469 free(cp); 470 TEST_DONE(); 471 472 sshkey_free(k1); 473 474 TEST_START("parse Ed25519-SK from private"); 475 buf = load_file("ed25519_sk1"); 476 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, "", &k1, NULL), 0); 477 sshbuf_free(buf); 478 ASSERT_PTR_NE(k1, NULL); 479 ASSERT_INT_EQ(k1->type, KEY_ED25519_SK); 480 /* XXX check key contents */ 481 TEST_DONE(); 482 483 TEST_START("parse Ed25519-SK from private w/ passphrase"); 484 buf = load_file("ed25519_sk1_pw"); 485 ASSERT_INT_EQ(sshkey_parse_private_fileblob(buf, 486 (const char *)sshbuf_ptr(pw), &k2, NULL), 0); 487 sshbuf_free(buf); 488 ASSERT_PTR_NE(k2, NULL); 489 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 490 sshkey_free(k2); 491 TEST_DONE(); 492 493 TEST_START("load Ed25519-SK from public"); 494 ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_sk1.pub"), 495 &k2, NULL), 0); 496 ASSERT_PTR_NE(k2, NULL); 497 ASSERT_INT_EQ(sshkey_equal(k1, k2), 1); 498 sshkey_free(k2); 499 TEST_DONE(); 500 501 TEST_START("load Ed25519-SK cert"); 502 ASSERT_INT_EQ(sshkey_load_cert(test_data_file("ed25519_sk1"), &k2), 0); 503 ASSERT_PTR_NE(k2, NULL); 504 ASSERT_INT_EQ(k2->type, KEY_ED25519_SK_CERT); 505 ASSERT_INT_EQ(sshkey_equal(k1, k2), 0); 506 ASSERT_INT_EQ(sshkey_equal_public(k1, k2), 1); 507 TEST_DONE(); 508 509 TEST_START("Ed25519-SK key hex fingerprint"); 510 buf = load_text_file("ed25519_sk1.fp"); 511 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA256, SSH_FP_BASE64); 512 ASSERT_PTR_NE(cp, NULL); 513 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 514 sshbuf_free(buf); 515 free(cp); 516 TEST_DONE(); 517 518 TEST_START("Ed25519-SK cert hex fingerprint"); 519 buf = load_text_file("ed25519_sk1-cert.fp"); 520 cp = sshkey_fingerprint(k2, SSH_DIGEST_SHA256, SSH_FP_BASE64); 521 ASSERT_PTR_NE(cp, NULL); 522 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 523 sshbuf_free(buf); 524 free(cp); 525 sshkey_free(k2); 526 TEST_DONE(); 527 528 TEST_START("Ed25519-SK key bubblebabble fingerprint"); 529 buf = load_text_file("ed25519_sk1.fp.bb"); 530 cp = sshkey_fingerprint(k1, SSH_DIGEST_SHA1, SSH_FP_BUBBLEBABBLE); 531 ASSERT_PTR_NE(cp, NULL); 532 ASSERT_STRING_EQ(cp, (const char *)sshbuf_ptr(buf)); 533 sshbuf_free(buf); 534 free(cp); 535 TEST_DONE(); 536 537 sshkey_free(k1); 538 539 sshbuf_free(pw); 540 541 } 542