1 /* $OpenBSD: sshsig.c,v 1.33 2023/09/06 23:18:15 djm Exp $ */ 2 /* 3 * Copyright (c) 2019 Google LLC 4 * 5 * Permission to use, copy, modify, and distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 #include "includes.h" 19 20 #include <stdio.h> 21 #include <stdlib.h> 22 #include <stdarg.h> 23 #include <errno.h> 24 #include <string.h> 25 #include <unistd.h> 26 27 #include "authfd.h" 28 #include "authfile.h" 29 #include "log.h" 30 #include "misc.h" 31 #include "sshbuf.h" 32 #include "sshsig.h" 33 #include "ssherr.h" 34 #include "sshkey.h" 35 #include "match.h" 36 #include "digest.h" 37 38 #define SIG_VERSION 0x01 39 #define MAGIC_PREAMBLE "SSHSIG" 40 #define MAGIC_PREAMBLE_LEN (sizeof(MAGIC_PREAMBLE) - 1) 41 #define BEGIN_SIGNATURE "-----BEGIN SSH SIGNATURE-----" 42 #define END_SIGNATURE "-----END SSH SIGNATURE-----" 43 #define RSA_SIGN_ALG "rsa-sha2-512" /* XXX maybe make configurable */ 44 #define RSA_SIGN_ALLOWED "rsa-sha2-512,rsa-sha2-256" 45 #define HASHALG_DEFAULT "sha512" /* XXX maybe make configurable */ 46 #define HASHALG_ALLOWED "sha256,sha512" 47 48 int 49 sshsig_armor(const struct sshbuf *blob, struct sshbuf **out) 50 { 51 struct sshbuf *buf = NULL; 52 int r = SSH_ERR_INTERNAL_ERROR; 53 54 *out = NULL; 55 56 if ((buf = sshbuf_new()) == NULL) { 57 error_f("sshbuf_new failed"); 58 r = SSH_ERR_ALLOC_FAIL; 59 goto out; 60 } 61 62 if ((r = sshbuf_putf(buf, "%s\n", BEGIN_SIGNATURE)) != 0) { 63 error_fr(r, "sshbuf_putf"); 64 goto out; 65 } 66 67 if ((r = sshbuf_dtob64(blob, buf, 1)) != 0) { 68 error_fr(r, "base64 encode signature"); 69 goto out; 70 } 71 72 if ((r = sshbuf_put(buf, END_SIGNATURE, 73 sizeof(END_SIGNATURE)-1)) != 0 || 74 (r = sshbuf_put_u8(buf, '\n')) != 0) { 75 error_fr(r, "sshbuf_put"); 76 goto out; 77 } 78 /* success */ 79 *out = buf; 80 buf = NULL; /* transferred */ 81 r = 0; 82 out: 83 sshbuf_free(buf); 84 return r; 85 } 86 87 int 88 sshsig_dearmor(struct sshbuf *sig, struct sshbuf **out) 89 { 90 int r; 91 size_t eoffset = 0; 92 struct sshbuf *buf = NULL; 93 struct sshbuf *sbuf = NULL; 94 char *b64 = NULL; 95 96 if ((sbuf = sshbuf_fromb(sig)) == NULL) { 97 error_f("sshbuf_fromb failed"); 98 return SSH_ERR_ALLOC_FAIL; 99 } 100 101 /* Expect and consume preamble + lf/crlf */ 102 if ((r = sshbuf_cmp(sbuf, 0, 103 BEGIN_SIGNATURE, sizeof(BEGIN_SIGNATURE)-1)) != 0) { 104 error("Couldn't parse signature: missing header"); 105 goto done; 106 } 107 if ((r = sshbuf_consume(sbuf, sizeof(BEGIN_SIGNATURE)-1)) != 0) { 108 error_fr(r, "consume"); 109 goto done; 110 } 111 if ((r = sshbuf_cmp(sbuf, 0, "\r\n", 2)) == 0) 112 eoffset = 2; 113 else if ((r = sshbuf_cmp(sbuf, 0, "\n", 1)) == 0) 114 eoffset = 1; 115 else { 116 r = SSH_ERR_INVALID_FORMAT; 117 error_f("no header eol"); 118 goto done; 119 } 120 if ((r = sshbuf_consume(sbuf, eoffset)) != 0) { 121 error_fr(r, "consume eol"); 122 goto done; 123 } 124 /* Find and consume lf + suffix (any prior cr would be ignored) */ 125 if ((r = sshbuf_find(sbuf, 0, "\n" END_SIGNATURE, 126 sizeof(END_SIGNATURE), &eoffset)) != 0) { 127 error("Couldn't parse signature: missing footer"); 128 goto done; 129 } 130 if ((r = sshbuf_consume_end(sbuf, sshbuf_len(sbuf)-eoffset)) != 0) { 131 error_fr(r, "consume"); 132 goto done; 133 } 134 135 if ((b64 = sshbuf_dup_string(sbuf)) == NULL) { 136 error_f("sshbuf_dup_string failed"); 137 r = SSH_ERR_ALLOC_FAIL; 138 goto done; 139 } 140 141 if ((buf = sshbuf_new()) == NULL) { 142 error_f("sshbuf_new() failed"); 143 r = SSH_ERR_ALLOC_FAIL; 144 goto done; 145 } 146 147 if ((r = sshbuf_b64tod(buf, b64)) != 0) { 148 error_fr(r, "decode base64"); 149 goto done; 150 } 151 152 /* success */ 153 *out = buf; 154 r = 0; 155 buf = NULL; /* transferred */ 156 done: 157 sshbuf_free(buf); 158 sshbuf_free(sbuf); 159 free(b64); 160 return r; 161 } 162 163 static int 164 sshsig_wrap_sign(struct sshkey *key, const char *hashalg, 165 const char *sk_provider, const char *sk_pin, const struct sshbuf *h_message, 166 const char *sig_namespace, struct sshbuf **out, 167 sshsig_signer *signer, void *signer_ctx) 168 { 169 int r; 170 size_t slen = 0; 171 u_char *sig = NULL; 172 struct sshbuf *blob = NULL; 173 struct sshbuf *tosign = NULL; 174 const char *sign_alg = NULL; 175 176 if ((tosign = sshbuf_new()) == NULL || 177 (blob = sshbuf_new()) == NULL) { 178 error_f("sshbuf_new failed"); 179 r = SSH_ERR_ALLOC_FAIL; 180 goto done; 181 } 182 183 if ((r = sshbuf_put(tosign, MAGIC_PREAMBLE, MAGIC_PREAMBLE_LEN)) != 0 || 184 (r = sshbuf_put_cstring(tosign, sig_namespace)) != 0 || 185 (r = sshbuf_put_string(tosign, NULL, 0)) != 0 || /* reserved */ 186 (r = sshbuf_put_cstring(tosign, hashalg)) != 0 || 187 (r = sshbuf_put_stringb(tosign, h_message)) != 0) { 188 error_fr(r, "assemble message to sign"); 189 goto done; 190 } 191 192 /* If using RSA keys then default to a good signature algorithm */ 193 if (sshkey_type_plain(key->type) == KEY_RSA) 194 sign_alg = RSA_SIGN_ALG; 195 196 if (signer != NULL) { 197 if ((r = signer(key, &sig, &slen, 198 sshbuf_ptr(tosign), sshbuf_len(tosign), 199 sign_alg, sk_provider, sk_pin, 0, signer_ctx)) != 0) { 200 error_r(r, "Couldn't sign message (signer)"); 201 goto done; 202 } 203 } else { 204 if ((r = sshkey_sign(key, &sig, &slen, 205 sshbuf_ptr(tosign), sshbuf_len(tosign), 206 sign_alg, sk_provider, sk_pin, 0)) != 0) { 207 error_r(r, "Couldn't sign message"); 208 goto done; 209 } 210 } 211 212 if ((r = sshbuf_put(blob, MAGIC_PREAMBLE, MAGIC_PREAMBLE_LEN)) != 0 || 213 (r = sshbuf_put_u32(blob, SIG_VERSION)) != 0 || 214 (r = sshkey_puts(key, blob)) != 0 || 215 (r = sshbuf_put_cstring(blob, sig_namespace)) != 0 || 216 (r = sshbuf_put_string(blob, NULL, 0)) != 0 || /* reserved */ 217 (r = sshbuf_put_cstring(blob, hashalg)) != 0 || 218 (r = sshbuf_put_string(blob, sig, slen)) != 0) { 219 error_fr(r, "assemble signature object"); 220 goto done; 221 } 222 223 if (out != NULL) { 224 *out = blob; 225 blob = NULL; 226 } 227 r = 0; 228 done: 229 free(sig); 230 sshbuf_free(blob); 231 sshbuf_free(tosign); 232 return r; 233 } 234 235 /* Check preamble and version. */ 236 static int 237 sshsig_parse_preamble(struct sshbuf *buf) 238 { 239 int r = SSH_ERR_INTERNAL_ERROR; 240 uint32_t sversion; 241 242 if ((r = sshbuf_cmp(buf, 0, MAGIC_PREAMBLE, MAGIC_PREAMBLE_LEN)) != 0 || 243 (r = sshbuf_consume(buf, (sizeof(MAGIC_PREAMBLE)-1))) != 0 || 244 (r = sshbuf_get_u32(buf, &sversion)) != 0) { 245 error("Couldn't verify signature: invalid format"); 246 return r; 247 } 248 249 if (sversion > SIG_VERSION) { 250 error("Signature version %lu is larger than supported " 251 "version %u", (unsigned long)sversion, SIG_VERSION); 252 return SSH_ERR_INVALID_FORMAT; 253 } 254 return 0; 255 } 256 257 static int 258 sshsig_check_hashalg(const char *hashalg) 259 { 260 if (hashalg == NULL || 261 match_pattern_list(hashalg, HASHALG_ALLOWED, 0) == 1) 262 return 0; 263 error_f("unsupported hash algorithm \"%.100s\"", hashalg); 264 return SSH_ERR_SIGN_ALG_UNSUPPORTED; 265 } 266 267 static int 268 sshsig_peek_hashalg(struct sshbuf *signature, char **hashalgp) 269 { 270 struct sshbuf *buf = NULL; 271 char *hashalg = NULL; 272 int r = SSH_ERR_INTERNAL_ERROR; 273 274 if (hashalgp != NULL) 275 *hashalgp = NULL; 276 if ((buf = sshbuf_fromb(signature)) == NULL) 277 return SSH_ERR_ALLOC_FAIL; 278 if ((r = sshsig_parse_preamble(buf)) != 0) 279 goto done; 280 if ((r = sshbuf_get_string_direct(buf, NULL, NULL)) != 0 || 281 (r = sshbuf_get_string_direct(buf, NULL, NULL)) != 0 || 282 (r = sshbuf_get_string(buf, NULL, NULL)) != 0 || 283 (r = sshbuf_get_cstring(buf, &hashalg, NULL)) != 0 || 284 (r = sshbuf_get_string_direct(buf, NULL, NULL)) != 0) { 285 error_fr(r, "parse signature object"); 286 goto done; 287 } 288 289 /* success */ 290 r = 0; 291 *hashalgp = hashalg; 292 hashalg = NULL; 293 done: 294 free(hashalg); 295 sshbuf_free(buf); 296 return r; 297 } 298 299 static int 300 sshsig_wrap_verify(struct sshbuf *signature, const char *hashalg, 301 const struct sshbuf *h_message, const char *expect_namespace, 302 struct sshkey **sign_keyp, struct sshkey_sig_details **sig_details) 303 { 304 int r = SSH_ERR_INTERNAL_ERROR; 305 struct sshbuf *buf = NULL, *toverify = NULL; 306 struct sshkey *key = NULL; 307 const u_char *sig; 308 char *got_namespace = NULL, *sigtype = NULL, *sig_hashalg = NULL; 309 size_t siglen; 310 311 debug_f("verify message length %zu", sshbuf_len(h_message)); 312 if (sig_details != NULL) 313 *sig_details = NULL; 314 if (sign_keyp != NULL) 315 *sign_keyp = NULL; 316 317 if ((toverify = sshbuf_new()) == NULL) { 318 error_f("sshbuf_new failed"); 319 r = SSH_ERR_ALLOC_FAIL; 320 goto done; 321 } 322 if ((r = sshbuf_put(toverify, MAGIC_PREAMBLE, 323 MAGIC_PREAMBLE_LEN)) != 0 || 324 (r = sshbuf_put_cstring(toverify, expect_namespace)) != 0 || 325 (r = sshbuf_put_string(toverify, NULL, 0)) != 0 || /* reserved */ 326 (r = sshbuf_put_cstring(toverify, hashalg)) != 0 || 327 (r = sshbuf_put_stringb(toverify, h_message)) != 0) { 328 error_fr(r, "assemble message to verify"); 329 goto done; 330 } 331 332 if ((r = sshsig_parse_preamble(signature)) != 0) 333 goto done; 334 335 if ((r = sshkey_froms(signature, &key)) != 0 || 336 (r = sshbuf_get_cstring(signature, &got_namespace, NULL)) != 0 || 337 (r = sshbuf_get_string(signature, NULL, NULL)) != 0 || 338 (r = sshbuf_get_cstring(signature, &sig_hashalg, NULL)) != 0 || 339 (r = sshbuf_get_string_direct(signature, &sig, &siglen)) != 0) { 340 error_fr(r, "parse signature object"); 341 goto done; 342 } 343 344 if (sshbuf_len(signature) != 0) { 345 error("Signature contains trailing data"); 346 r = SSH_ERR_INVALID_FORMAT; 347 goto done; 348 } 349 350 if (strcmp(expect_namespace, got_namespace) != 0) { 351 error("Couldn't verify signature: namespace does not match"); 352 debug_f("expected namespace \"%s\" received \"%s\"", 353 expect_namespace, got_namespace); 354 r = SSH_ERR_SIGNATURE_INVALID; 355 goto done; 356 } 357 if (strcmp(hashalg, sig_hashalg) != 0) { 358 error("Couldn't verify signature: hash algorithm mismatch"); 359 debug_f("expected algorithm \"%s\" received \"%s\"", 360 hashalg, sig_hashalg); 361 r = SSH_ERR_SIGNATURE_INVALID; 362 goto done; 363 } 364 /* Ensure that RSA keys use an acceptable signature algorithm */ 365 if (sshkey_type_plain(key->type) == KEY_RSA) { 366 if ((r = sshkey_get_sigtype(sig, siglen, &sigtype)) != 0) { 367 error_r(r, "Couldn't verify signature: unable to get " 368 "signature type"); 369 goto done; 370 } 371 if (match_pattern_list(sigtype, RSA_SIGN_ALLOWED, 0) != 1) { 372 error("Couldn't verify signature: unsupported RSA " 373 "signature algorithm %s", sigtype); 374 r = SSH_ERR_SIGN_ALG_UNSUPPORTED; 375 goto done; 376 } 377 } 378 if ((r = sshkey_verify(key, sig, siglen, sshbuf_ptr(toverify), 379 sshbuf_len(toverify), NULL, 0, sig_details)) != 0) { 380 error_r(r, "Signature verification failed"); 381 goto done; 382 } 383 384 /* success */ 385 r = 0; 386 if (sign_keyp != NULL) { 387 *sign_keyp = key; 388 key = NULL; /* transferred */ 389 } 390 done: 391 free(got_namespace); 392 free(sigtype); 393 free(sig_hashalg); 394 sshbuf_free(buf); 395 sshbuf_free(toverify); 396 sshkey_free(key); 397 return r; 398 } 399 400 static int 401 hash_buffer(const struct sshbuf *m, const char *hashalg, struct sshbuf **bp) 402 { 403 char *hex, hash[SSH_DIGEST_MAX_LENGTH]; 404 int alg, r = SSH_ERR_INTERNAL_ERROR; 405 struct sshbuf *b = NULL; 406 407 *bp = NULL; 408 memset(hash, 0, sizeof(hash)); 409 410 if ((r = sshsig_check_hashalg(hashalg)) != 0) 411 return r; 412 if ((alg = ssh_digest_alg_by_name(hashalg)) == -1) { 413 error_f("can't look up hash algorithm %s", hashalg); 414 return SSH_ERR_INTERNAL_ERROR; 415 } 416 if ((r = ssh_digest_buffer(alg, m, hash, sizeof(hash))) != 0) { 417 error_fr(r, "ssh_digest_buffer"); 418 return r; 419 } 420 if ((hex = tohex(hash, ssh_digest_bytes(alg))) != NULL) { 421 debug3_f("final hash: %s", hex); 422 freezero(hex, strlen(hex)); 423 } 424 if ((b = sshbuf_new()) == NULL) { 425 r = SSH_ERR_ALLOC_FAIL; 426 goto out; 427 } 428 if ((r = sshbuf_put(b, hash, ssh_digest_bytes(alg))) != 0) { 429 error_fr(r, "sshbuf_put"); 430 goto out; 431 } 432 *bp = b; 433 b = NULL; /* transferred */ 434 /* success */ 435 r = 0; 436 out: 437 sshbuf_free(b); 438 explicit_bzero(hash, sizeof(hash)); 439 return r; 440 } 441 442 int 443 sshsig_signb(struct sshkey *key, const char *hashalg, 444 const char *sk_provider, const char *sk_pin, 445 const struct sshbuf *message, const char *sig_namespace, 446 struct sshbuf **out, sshsig_signer *signer, void *signer_ctx) 447 { 448 struct sshbuf *b = NULL; 449 int r = SSH_ERR_INTERNAL_ERROR; 450 451 if (hashalg == NULL) 452 hashalg = HASHALG_DEFAULT; 453 if (out != NULL) 454 *out = NULL; 455 if ((r = hash_buffer(message, hashalg, &b)) != 0) { 456 error_fr(r, "hash buffer"); 457 goto out; 458 } 459 if ((r = sshsig_wrap_sign(key, hashalg, sk_provider, sk_pin, b, 460 sig_namespace, out, signer, signer_ctx)) != 0) 461 goto out; 462 /* success */ 463 r = 0; 464 out: 465 sshbuf_free(b); 466 return r; 467 } 468 469 int 470 sshsig_verifyb(struct sshbuf *signature, const struct sshbuf *message, 471 const char *expect_namespace, struct sshkey **sign_keyp, 472 struct sshkey_sig_details **sig_details) 473 { 474 struct sshbuf *b = NULL; 475 int r = SSH_ERR_INTERNAL_ERROR; 476 char *hashalg = NULL; 477 478 if (sig_details != NULL) 479 *sig_details = NULL; 480 if (sign_keyp != NULL) 481 *sign_keyp = NULL; 482 if ((r = sshsig_peek_hashalg(signature, &hashalg)) != 0) 483 return r; 484 debug_f("signature made with hash \"%s\"", hashalg); 485 if ((r = hash_buffer(message, hashalg, &b)) != 0) { 486 error_fr(r, "hash buffer"); 487 goto out; 488 } 489 if ((r = sshsig_wrap_verify(signature, hashalg, b, expect_namespace, 490 sign_keyp, sig_details)) != 0) 491 goto out; 492 /* success */ 493 r = 0; 494 out: 495 sshbuf_free(b); 496 free(hashalg); 497 return r; 498 } 499 500 static int 501 hash_file(int fd, const char *hashalg, struct sshbuf **bp) 502 { 503 char *hex, rbuf[8192], hash[SSH_DIGEST_MAX_LENGTH]; 504 ssize_t n, total = 0; 505 struct ssh_digest_ctx *ctx = NULL; 506 int alg, oerrno, r = SSH_ERR_INTERNAL_ERROR; 507 struct sshbuf *b = NULL; 508 509 *bp = NULL; 510 memset(hash, 0, sizeof(hash)); 511 512 if ((r = sshsig_check_hashalg(hashalg)) != 0) 513 return r; 514 if ((alg = ssh_digest_alg_by_name(hashalg)) == -1) { 515 error_f("can't look up hash algorithm %s", hashalg); 516 return SSH_ERR_INTERNAL_ERROR; 517 } 518 if ((ctx = ssh_digest_start(alg)) == NULL) { 519 error_f("ssh_digest_start failed"); 520 return SSH_ERR_INTERNAL_ERROR; 521 } 522 for (;;) { 523 if ((n = read(fd, rbuf, sizeof(rbuf))) == -1) { 524 if (errno == EINTR || errno == EAGAIN) 525 continue; 526 oerrno = errno; 527 error_f("read: %s", strerror(errno)); 528 errno = oerrno; 529 r = SSH_ERR_SYSTEM_ERROR; 530 goto out; 531 } else if (n == 0) { 532 debug2_f("hashed %zu bytes", total); 533 break; /* EOF */ 534 } 535 total += (size_t)n; 536 if ((r = ssh_digest_update(ctx, rbuf, (size_t)n)) != 0) { 537 error_fr(r, "ssh_digest_update"); 538 goto out; 539 } 540 } 541 if ((r = ssh_digest_final(ctx, hash, sizeof(hash))) != 0) { 542 error_fr(r, "ssh_digest_final"); 543 goto out; 544 } 545 if ((hex = tohex(hash, ssh_digest_bytes(alg))) != NULL) { 546 debug3_f("final hash: %s", hex); 547 freezero(hex, strlen(hex)); 548 } 549 if ((b = sshbuf_new()) == NULL) { 550 r = SSH_ERR_ALLOC_FAIL; 551 goto out; 552 } 553 if ((r = sshbuf_put(b, hash, ssh_digest_bytes(alg))) != 0) { 554 error_fr(r, "sshbuf_put"); 555 goto out; 556 } 557 *bp = b; 558 b = NULL; /* transferred */ 559 /* success */ 560 r = 0; 561 out: 562 oerrno = errno; 563 sshbuf_free(b); 564 ssh_digest_free(ctx); 565 explicit_bzero(hash, sizeof(hash)); 566 errno = oerrno; 567 return r; 568 } 569 570 int 571 sshsig_sign_fd(struct sshkey *key, const char *hashalg, 572 const char *sk_provider, const char *sk_pin, 573 int fd, const char *sig_namespace, struct sshbuf **out, 574 sshsig_signer *signer, void *signer_ctx) 575 { 576 struct sshbuf *b = NULL; 577 int r = SSH_ERR_INTERNAL_ERROR; 578 579 if (hashalg == NULL) 580 hashalg = HASHALG_DEFAULT; 581 if (out != NULL) 582 *out = NULL; 583 if ((r = hash_file(fd, hashalg, &b)) != 0) { 584 error_fr(r, "hash_file"); 585 return r; 586 } 587 if ((r = sshsig_wrap_sign(key, hashalg, sk_provider, sk_pin, b, 588 sig_namespace, out, signer, signer_ctx)) != 0) 589 goto out; 590 /* success */ 591 r = 0; 592 out: 593 sshbuf_free(b); 594 return r; 595 } 596 597 int 598 sshsig_verify_fd(struct sshbuf *signature, int fd, 599 const char *expect_namespace, struct sshkey **sign_keyp, 600 struct sshkey_sig_details **sig_details) 601 { 602 struct sshbuf *b = NULL; 603 int r = SSH_ERR_INTERNAL_ERROR; 604 char *hashalg = NULL; 605 606 if (sig_details != NULL) 607 *sig_details = NULL; 608 if (sign_keyp != NULL) 609 *sign_keyp = NULL; 610 if ((r = sshsig_peek_hashalg(signature, &hashalg)) != 0) 611 return r; 612 debug_f("signature made with hash \"%s\"", hashalg); 613 if ((r = hash_file(fd, hashalg, &b)) != 0) { 614 error_fr(r, "hash_file"); 615 goto out; 616 } 617 if ((r = sshsig_wrap_verify(signature, hashalg, b, expect_namespace, 618 sign_keyp, sig_details)) != 0) 619 goto out; 620 /* success */ 621 r = 0; 622 out: 623 sshbuf_free(b); 624 free(hashalg); 625 return r; 626 } 627 628 struct sshsigopt { 629 int ca; 630 char *namespaces; 631 uint64_t valid_after, valid_before; 632 }; 633 634 struct sshsigopt * 635 sshsigopt_parse(const char *opts, const char *path, u_long linenum, 636 const char **errstrp) 637 { 638 struct sshsigopt *ret; 639 int r; 640 char *opt; 641 const char *errstr = NULL; 642 643 if ((ret = calloc(1, sizeof(*ret))) == NULL) 644 return NULL; 645 if (opts == NULL || *opts == '\0') 646 return ret; /* Empty options yields empty options :) */ 647 648 while (*opts && *opts != ' ' && *opts != '\t') { 649 /* flag options */ 650 if ((r = opt_flag("cert-authority", 0, &opts)) != -1) { 651 ret->ca = 1; 652 } else if (opt_match(&opts, "namespaces")) { 653 if (ret->namespaces != NULL) { 654 errstr = "multiple \"namespaces\" clauses"; 655 goto fail; 656 } 657 ret->namespaces = opt_dequote(&opts, &errstr); 658 if (ret->namespaces == NULL) 659 goto fail; 660 } else if (opt_match(&opts, "valid-after")) { 661 if (ret->valid_after != 0) { 662 errstr = "multiple \"valid-after\" clauses"; 663 goto fail; 664 } 665 if ((opt = opt_dequote(&opts, &errstr)) == NULL) 666 goto fail; 667 if (parse_absolute_time(opt, &ret->valid_after) != 0 || 668 ret->valid_after == 0) { 669 free(opt); 670 errstr = "invalid \"valid-after\" time"; 671 goto fail; 672 } 673 free(opt); 674 } else if (opt_match(&opts, "valid-before")) { 675 if (ret->valid_before != 0) { 676 errstr = "multiple \"valid-before\" clauses"; 677 goto fail; 678 } 679 if ((opt = opt_dequote(&opts, &errstr)) == NULL) 680 goto fail; 681 if (parse_absolute_time(opt, &ret->valid_before) != 0 || 682 ret->valid_before == 0) { 683 free(opt); 684 errstr = "invalid \"valid-before\" time"; 685 goto fail; 686 } 687 free(opt); 688 } 689 /* 690 * Skip the comma, and move to the next option 691 * (or break out if there are no more). 692 */ 693 if (*opts == '\0' || *opts == ' ' || *opts == '\t') 694 break; /* End of options. */ 695 /* Anything other than a comma is an unknown option */ 696 if (*opts != ',') { 697 errstr = "unknown key option"; 698 goto fail; 699 } 700 opts++; 701 if (*opts == '\0') { 702 errstr = "unexpected end-of-options"; 703 goto fail; 704 } 705 } 706 /* final consistency check */ 707 if (ret->valid_after != 0 && ret->valid_before != 0 && 708 ret->valid_before <= ret->valid_after) { 709 errstr = "\"valid-before\" time is before \"valid-after\""; 710 goto fail; 711 } 712 /* success */ 713 return ret; 714 fail: 715 if (errstrp != NULL) 716 *errstrp = errstr; 717 sshsigopt_free(ret); 718 return NULL; 719 } 720 721 void 722 sshsigopt_free(struct sshsigopt *opts) 723 { 724 if (opts == NULL) 725 return; 726 free(opts->namespaces); 727 free(opts); 728 } 729 730 static int 731 parse_principals_key_and_options(const char *path, u_long linenum, char *line, 732 const char *required_principal, char **principalsp, struct sshkey **keyp, 733 struct sshsigopt **sigoptsp) 734 { 735 char *opts = NULL, *tmp, *cp, *principals = NULL; 736 const char *reason = NULL; 737 struct sshsigopt *sigopts = NULL; 738 struct sshkey *key = NULL; 739 int r = SSH_ERR_INTERNAL_ERROR; 740 741 if (principalsp != NULL) 742 *principalsp = NULL; 743 if (sigoptsp != NULL) 744 *sigoptsp = NULL; 745 if (keyp != NULL) 746 *keyp = NULL; 747 748 cp = line; 749 cp = cp + strspn(cp, " \t"); /* skip leading whitespace */ 750 if (*cp == '#' || *cp == '\0') 751 return SSH_ERR_KEY_NOT_FOUND; /* blank or all-comment line */ 752 753 /* format: identity[,identity...] [option[,option...]] key */ 754 if ((tmp = strdelimw(&cp)) == NULL || cp == NULL) { 755 error("%s:%lu: invalid line", path, linenum); 756 r = SSH_ERR_INVALID_FORMAT; 757 goto out; 758 } 759 if ((principals = strdup(tmp)) == NULL) { 760 error_f("strdup failed"); 761 r = SSH_ERR_ALLOC_FAIL; 762 goto out; 763 } 764 /* 765 * Bail out early if we're looking for a particular principal and this 766 * line does not list it. 767 */ 768 if (required_principal != NULL) { 769 if (match_pattern_list(required_principal, 770 principals, 0) != 1) { 771 /* principal didn't match */ 772 r = SSH_ERR_KEY_NOT_FOUND; 773 goto out; 774 } 775 debug_f("%s:%lu: matched principal \"%s\"", 776 path, linenum, required_principal); 777 } 778 779 if ((key = sshkey_new(KEY_UNSPEC)) == NULL) { 780 error_f("sshkey_new failed"); 781 r = SSH_ERR_ALLOC_FAIL; 782 goto out; 783 } 784 if (sshkey_read(key, &cp) != 0) { 785 /* no key? Check for options */ 786 opts = cp; 787 if (sshkey_advance_past_options(&cp) != 0) { 788 error("%s:%lu: invalid options", path, linenum); 789 r = SSH_ERR_INVALID_FORMAT; 790 goto out; 791 } 792 if (cp == NULL || *cp == '\0') { 793 error("%s:%lu: missing key", path, linenum); 794 r = SSH_ERR_INVALID_FORMAT; 795 goto out; 796 } 797 *cp++ = '\0'; 798 skip_space(&cp); 799 if (sshkey_read(key, &cp) != 0) { 800 error("%s:%lu: invalid key", path, linenum); 801 r = SSH_ERR_INVALID_FORMAT; 802 goto out; 803 } 804 } 805 debug3("%s:%lu: options %s", path, linenum, opts == NULL ? "" : opts); 806 if ((sigopts = sshsigopt_parse(opts, path, linenum, &reason)) == NULL) { 807 error("%s:%lu: bad options: %s", path, linenum, reason); 808 r = SSH_ERR_INVALID_FORMAT; 809 goto out; 810 } 811 /* success */ 812 if (principalsp != NULL) { 813 *principalsp = principals; 814 principals = NULL; /* transferred */ 815 } 816 if (sigoptsp != NULL) { 817 *sigoptsp = sigopts; 818 sigopts = NULL; /* transferred */ 819 } 820 if (keyp != NULL) { 821 *keyp = key; 822 key = NULL; /* transferred */ 823 } 824 r = 0; 825 out: 826 free(principals); 827 sshsigopt_free(sigopts); 828 sshkey_free(key); 829 return r; 830 } 831 832 static int 833 cert_filter_principals(const char *path, u_long linenum, 834 char **principalsp, const struct sshkey *cert, uint64_t verify_time) 835 { 836 char *cp, *oprincipals, *principals; 837 const char *reason; 838 struct sshbuf *nprincipals; 839 int r = SSH_ERR_INTERNAL_ERROR, success = 0; 840 u_int i; 841 842 oprincipals = principals = *principalsp; 843 *principalsp = NULL; 844 845 if ((nprincipals = sshbuf_new()) == NULL) { 846 r = SSH_ERR_ALLOC_FAIL; 847 goto out; 848 } 849 850 while ((cp = strsep(&principals, ",")) != NULL && *cp != '\0') { 851 /* Check certificate validity */ 852 if ((r = sshkey_cert_check_authority(cert, 0, 1, 0, 853 verify_time, NULL, &reason)) != 0) { 854 debug("%s:%lu: principal \"%s\" not authorized: %s", 855 path, linenum, cp, reason); 856 continue; 857 } 858 /* Return all matching principal names from the cert */ 859 for (i = 0; i < cert->cert->nprincipals; i++) { 860 if (match_pattern(cert->cert->principals[i], cp)) { 861 if ((r = sshbuf_putf(nprincipals, "%s%s", 862 sshbuf_len(nprincipals) != 0 ? "," : "", 863 cert->cert->principals[i])) != 0) { 864 error_f("buffer error"); 865 goto out; 866 } 867 } 868 } 869 } 870 if (sshbuf_len(nprincipals) == 0) { 871 error("%s:%lu: no valid principals found", path, linenum); 872 r = SSH_ERR_KEY_CERT_INVALID; 873 goto out; 874 } 875 if ((principals = sshbuf_dup_string(nprincipals)) == NULL) { 876 error_f("buffer error"); 877 goto out; 878 } 879 /* success */ 880 success = 1; 881 *principalsp = principals; 882 out: 883 sshbuf_free(nprincipals); 884 free(oprincipals); 885 return success ? 0 : r; 886 } 887 888 static int 889 check_allowed_keys_line(const char *path, u_long linenum, char *line, 890 const struct sshkey *sign_key, const char *principal, 891 const char *sig_namespace, uint64_t verify_time, char **principalsp) 892 { 893 struct sshkey *found_key = NULL; 894 char *principals = NULL; 895 int r, success = 0; 896 const char *reason = NULL; 897 struct sshsigopt *sigopts = NULL; 898 char tvalid[64], tverify[64]; 899 900 if (principalsp != NULL) 901 *principalsp = NULL; 902 903 /* Parse the line */ 904 if ((r = parse_principals_key_and_options(path, linenum, line, 905 principal, &principals, &found_key, &sigopts)) != 0) { 906 /* error already logged */ 907 goto done; 908 } 909 910 if (!sigopts->ca && sshkey_equal(found_key, sign_key)) { 911 /* Exact match of key */ 912 debug("%s:%lu: matched key", path, linenum); 913 } else if (sigopts->ca && sshkey_is_cert(sign_key) && 914 sshkey_equal_public(sign_key->cert->signature_key, found_key)) { 915 if (principal) { 916 /* Match certificate CA key with specified principal */ 917 if ((r = sshkey_cert_check_authority(sign_key, 0, 1, 0, 918 verify_time, principal, &reason)) != 0) { 919 error("%s:%lu: certificate not authorized: %s", 920 path, linenum, reason); 921 goto done; 922 } 923 debug("%s:%lu: matched certificate CA key", 924 path, linenum); 925 } else { 926 /* No principal specified - find all matching ones */ 927 if ((r = cert_filter_principals(path, linenum, 928 &principals, sign_key, verify_time)) != 0) { 929 /* error already displayed */ 930 debug_r(r, "%s:%lu: cert_filter_principals", 931 path, linenum); 932 goto done; 933 } 934 debug("%s:%lu: matched certificate CA key", 935 path, linenum); 936 } 937 } else { 938 /* Didn't match key */ 939 goto done; 940 } 941 942 /* Check whether options preclude the use of this key */ 943 if (sigopts->namespaces != NULL && sig_namespace != NULL && 944 match_pattern_list(sig_namespace, sigopts->namespaces, 0) != 1) { 945 error("%s:%lu: key is not permitted for use in signature " 946 "namespace \"%s\"", path, linenum, sig_namespace); 947 goto done; 948 } 949 950 /* check key time validity */ 951 format_absolute_time((uint64_t)verify_time, tverify, sizeof(tverify)); 952 if (sigopts->valid_after != 0 && 953 (uint64_t)verify_time < sigopts->valid_after) { 954 format_absolute_time(sigopts->valid_after, 955 tvalid, sizeof(tvalid)); 956 error("%s:%lu: key is not yet valid: " 957 "verify time %s < valid-after %s", path, linenum, 958 tverify, tvalid); 959 goto done; 960 } 961 if (sigopts->valid_before != 0 && 962 (uint64_t)verify_time > sigopts->valid_before) { 963 format_absolute_time(sigopts->valid_before, 964 tvalid, sizeof(tvalid)); 965 error("%s:%lu: key has expired: " 966 "verify time %s > valid-before %s", path, linenum, 967 tverify, tvalid); 968 goto done; 969 } 970 success = 1; 971 972 done: 973 if (success && principalsp != NULL) { 974 *principalsp = principals; 975 principals = NULL; /* transferred */ 976 } 977 free(principals); 978 sshkey_free(found_key); 979 sshsigopt_free(sigopts); 980 return success ? 0 : SSH_ERR_KEY_NOT_FOUND; 981 } 982 983 int 984 sshsig_check_allowed_keys(const char *path, const struct sshkey *sign_key, 985 const char *principal, const char *sig_namespace, uint64_t verify_time) 986 { 987 FILE *f = NULL; 988 char *line = NULL; 989 size_t linesize = 0; 990 u_long linenum = 0; 991 int r = SSH_ERR_KEY_NOT_FOUND, oerrno; 992 993 /* Check key and principal against file */ 994 if ((f = fopen(path, "r")) == NULL) { 995 oerrno = errno; 996 error("Unable to open allowed keys file \"%s\": %s", 997 path, strerror(errno)); 998 errno = oerrno; 999 return SSH_ERR_SYSTEM_ERROR; 1000 } 1001 1002 while (getline(&line, &linesize, f) != -1) { 1003 linenum++; 1004 r = check_allowed_keys_line(path, linenum, line, sign_key, 1005 principal, sig_namespace, verify_time, NULL); 1006 free(line); 1007 line = NULL; 1008 linesize = 0; 1009 if (r == SSH_ERR_KEY_NOT_FOUND) 1010 continue; 1011 else if (r == 0) { 1012 /* success */ 1013 fclose(f); 1014 return 0; 1015 } else 1016 break; 1017 } 1018 /* Either we hit an error parsing or we simply didn't find the key */ 1019 fclose(f); 1020 free(line); 1021 return r; 1022 } 1023 1024 int 1025 sshsig_find_principals(const char *path, const struct sshkey *sign_key, 1026 uint64_t verify_time, char **principals) 1027 { 1028 FILE *f = NULL; 1029 char *line = NULL; 1030 size_t linesize = 0; 1031 u_long linenum = 0; 1032 int r = SSH_ERR_KEY_NOT_FOUND, oerrno; 1033 1034 if ((f = fopen(path, "r")) == NULL) { 1035 oerrno = errno; 1036 error("Unable to open allowed keys file \"%s\": %s", 1037 path, strerror(errno)); 1038 errno = oerrno; 1039 return SSH_ERR_SYSTEM_ERROR; 1040 } 1041 1042 while (getline(&line, &linesize, f) != -1) { 1043 linenum++; 1044 r = check_allowed_keys_line(path, linenum, line, 1045 sign_key, NULL, NULL, verify_time, principals); 1046 free(line); 1047 line = NULL; 1048 linesize = 0; 1049 if (r == SSH_ERR_KEY_NOT_FOUND) 1050 continue; 1051 else if (r == 0) { 1052 /* success */ 1053 fclose(f); 1054 return 0; 1055 } else 1056 break; 1057 } 1058 free(line); 1059 /* Either we hit an error parsing or we simply didn't find the key */ 1060 if (ferror(f) != 0) { 1061 oerrno = errno; 1062 fclose(f); 1063 error("Unable to read allowed keys file \"%s\": %s", 1064 path, strerror(errno)); 1065 errno = oerrno; 1066 return SSH_ERR_SYSTEM_ERROR; 1067 } 1068 fclose(f); 1069 return r; 1070 } 1071 1072 int 1073 sshsig_match_principals(const char *path, const char *principal, 1074 char ***principalsp, size_t *nprincipalsp) 1075 { 1076 FILE *f = NULL; 1077 char *found, *line = NULL, **principals = NULL, **tmp; 1078 size_t i, nprincipals = 0, linesize = 0; 1079 u_long linenum = 0; 1080 int oerrno = 0, r, ret = 0; 1081 1082 if (principalsp != NULL) 1083 *principalsp = NULL; 1084 if (nprincipalsp != NULL) 1085 *nprincipalsp = 0; 1086 1087 /* Check key and principal against file */ 1088 if ((f = fopen(path, "r")) == NULL) { 1089 oerrno = errno; 1090 error("Unable to open allowed keys file \"%s\": %s", 1091 path, strerror(errno)); 1092 errno = oerrno; 1093 return SSH_ERR_SYSTEM_ERROR; 1094 } 1095 1096 while (getline(&line, &linesize, f) != -1) { 1097 linenum++; 1098 /* Parse the line */ 1099 if ((r = parse_principals_key_and_options(path, linenum, line, 1100 principal, &found, NULL, NULL)) != 0) { 1101 if (r == SSH_ERR_KEY_NOT_FOUND) 1102 continue; 1103 ret = r; 1104 oerrno = errno; 1105 break; /* unexpected error */ 1106 } 1107 if ((tmp = recallocarray(principals, nprincipals, 1108 nprincipals + 1, sizeof(*principals))) == NULL) { 1109 ret = SSH_ERR_ALLOC_FAIL; 1110 free(found); 1111 break; 1112 } 1113 principals = tmp; 1114 principals[nprincipals++] = found; /* transferred */ 1115 free(line); 1116 line = NULL; 1117 linesize = 0; 1118 } 1119 fclose(f); 1120 1121 if (ret == 0) { 1122 if (nprincipals == 0) 1123 ret = SSH_ERR_KEY_NOT_FOUND; 1124 if (principalsp != NULL) { 1125 *principalsp = principals; 1126 principals = NULL; /* transferred */ 1127 } 1128 if (nprincipalsp != 0) { 1129 *nprincipalsp = nprincipals; 1130 nprincipals = 0; 1131 } 1132 } 1133 1134 for (i = 0; i < nprincipals; i++) 1135 free(principals[i]); 1136 free(principals); 1137 1138 errno = oerrno; 1139 return ret; 1140 } 1141 1142 int 1143 sshsig_get_pubkey(struct sshbuf *signature, struct sshkey **pubkey) 1144 { 1145 struct sshkey *pk = NULL; 1146 int r = SSH_ERR_SIGNATURE_INVALID; 1147 1148 if (pubkey == NULL) 1149 return SSH_ERR_INTERNAL_ERROR; 1150 if ((r = sshsig_parse_preamble(signature)) != 0) 1151 return r; 1152 if ((r = sshkey_froms(signature, &pk)) != 0) 1153 return r; 1154 1155 *pubkey = pk; 1156 pk = NULL; 1157 return 0; 1158 } 1159