gpg-interface.c

   1 #include "git-compat-util.h"
   2 #include "commit.h"
   3 #include "config.h"
   4 #include "date.h"
   5 #include "gettext.h"
   6 #include "run-command.h"
   7 #include "strbuf.h"
   8 #include "dir.h"
   9 #include "ident.h"
  10 #include "gpg-interface.h"
  11 #include "path.h"
  12 #include "sigchain.h"
  13 #include "tempfile.h"
  14 #include "alias.h"
  15
  16 static int git_gpg_config(const char *, const char *,
  17                           const struct config_context *, void *);
  18
  19 static void gpg_interface_lazy_init(void)
  20 {
  21         static int done;
  22
  23         if (done)
  24                 return;
  25         done = 1;
  26         git_config(git_gpg_config, NULL);
  27 }
  28
  29 static char *configured_signing_key;
  30 static const char *ssh_default_key_command, *ssh_allowed_signers, *ssh_revocation_file;
  31 static enum signature_trust_level configured_min_trust_level = TRUST_UNDEFINED;
  32
  33 struct gpg_format {
  34         const char *name;
  35         const char *program;
  36         const char **verify_args;
  37         const char **sigs;
  38         int (*verify_signed_buffer)(struct signature_check *sigc,
  39                                     struct gpg_format *fmt,
  40                                     const char *signature,
  41                                     size_t signature_size);
  42         int (*sign_buffer)(struct strbuf *buffer, struct strbuf *signature,
  43                            const char *signing_key);
  44         const char *(*get_default_key)(void);
  45         const char *(*get_key_id)(void);
  46 };
  47
  48 static const char *openpgp_verify_args[] = {
  49         "--keyid-format=long",
  50         NULL
  51 };
  52 static const char *openpgp_sigs[] = {
  53         "-----BEGIN PGP SIGNATURE-----",
  54         "-----BEGIN PGP MESSAGE-----",
  55         NULL
  56 };
  57
  58 static const char *x509_verify_args[] = {
  59         NULL
  60 };
  61 static const char *x509_sigs[] = {
  62         "-----BEGIN SIGNED MESSAGE-----",
  63         NULL
  64 };
  65
  66 static const char *ssh_verify_args[] = { NULL };
  67 static const char *ssh_sigs[] = {
  68         "-----BEGIN SSH SIGNATURE-----",
  69         NULL
  70 };
  71
  72 static int verify_gpg_signed_buffer(struct signature_check *sigc,
  73                                     struct gpg_format *fmt,
  74                                     const char *signature,
  75                                     size_t signature_size);
  76 static int verify_ssh_signed_buffer(struct signature_check *sigc,
  77                                     struct gpg_format *fmt,
  78                                     const char *signature,
  79                                     size_t signature_size);
  80 static int sign_buffer_gpg(struct strbuf *buffer, struct strbuf *signature,
  81                            const char *signing_key);
  82 static int sign_buffer_ssh(struct strbuf *buffer, struct strbuf *signature,
  83                            const char *signing_key);
  84
  85 static const char *get_default_ssh_signing_key(void);
  86
  87 static const char *get_ssh_key_id(void);
  88
  89 static struct gpg_format gpg_format[] = {
  90         {
  91                 .name = "openpgp",
  92                 .program = "gpg",
  93                 .verify_args = openpgp_verify_args,
  94                 .sigs = openpgp_sigs,
  95                 .verify_signed_buffer = verify_gpg_signed_buffer,
  96                 .sign_buffer = sign_buffer_gpg,
  97                 .get_default_key = NULL,
  98                 .get_key_id = NULL,
  99         },
 100         {
 101                 .name = "x509",
 102                 .program = "gpgsm",
 103                 .verify_args = x509_verify_args,
 104                 .sigs = x509_sigs,
 105                 .verify_signed_buffer = verify_gpg_signed_buffer,
 106                 .sign_buffer = sign_buffer_gpg,
 107                 .get_default_key = NULL,
 108                 .get_key_id = NULL,
 109         },
 110         {
 111                 .name = "ssh",
 112                 .program = "ssh-keygen",
 113                 .verify_args = ssh_verify_args,
 114                 .sigs = ssh_sigs,
 115                 .verify_signed_buffer = verify_ssh_signed_buffer,
 116                 .sign_buffer = sign_buffer_ssh,
 117                 .get_default_key = get_default_ssh_signing_key,
 118                 .get_key_id = get_ssh_key_id,
 119         },
 120 };
 121
 122 static struct gpg_format *use_format = &gpg_format[0];
 123
 124 static struct gpg_format *get_format_by_name(const char *str)
 125 {
 126         int i;
 127
 128         for (i = 0; i < ARRAY_SIZE(gpg_format); i++)
 129                 if (!strcmp(gpg_format[i].name, str))
 130                         return gpg_format + i;
 131         return NULL;
 132 }
 133
 134 static struct gpg_format *get_format_by_sig(const char *sig)
 135 {
 136         int i, j;
 137
 138         for (i = 0; i < ARRAY_SIZE(gpg_format); i++)
 139                 for (j = 0; gpg_format[i].sigs[j]; j++)
 140                         if (starts_with(sig, gpg_format[i].sigs[j]))
 141                                 return gpg_format + i;
 142         return NULL;
 143 }
 144
 145 void signature_check_clear(struct signature_check *sigc)
 146 {
 147         FREE_AND_NULL(sigc->payload);
 148         FREE_AND_NULL(sigc->output);
 149         FREE_AND_NULL(sigc->gpg_status);
 150         FREE_AND_NULL(sigc->signer);
 151         FREE_AND_NULL(sigc->key);
 152         FREE_AND_NULL(sigc->fingerprint);
 153         FREE_AND_NULL(sigc->primary_key_fingerprint);
 154 }
 155
 156 /* An exclusive status -- only one of them can appear in output */
 157 #define GPG_STATUS_EXCLUSIVE    (1<<0)
 158 /* The status includes key identifier */
 159 #define GPG_STATUS_KEYID        (1<<1)
 160 /* The status includes user identifier */
 161 #define GPG_STATUS_UID          (1<<2)
 162 /* The status includes key fingerprints */
 163 #define GPG_STATUS_FINGERPRINT  (1<<3)
 164 /* The status includes trust level */
 165 #define GPG_STATUS_TRUST_LEVEL  (1<<4)
 166
 167 /* Short-hand for standard exclusive *SIG status with keyid & UID */
 168 #define GPG_STATUS_STDSIG       (GPG_STATUS_EXCLUSIVE|GPG_STATUS_KEYID|GPG_STATUS_UID)
 169
 170 static struct {
 171         char result;
 172         const char *check;
 173         unsigned int flags;
 174 } sigcheck_gpg_status[] = {
 175         { 'G', "GOODSIG ", GPG_STATUS_STDSIG },
 176         { 'B', "BADSIG ", GPG_STATUS_STDSIG },
 177         { 'E', "ERRSIG ", GPG_STATUS_EXCLUSIVE|GPG_STATUS_KEYID },
 178         { 'X', "EXPSIG ", GPG_STATUS_STDSIG },
 179         { 'Y', "EXPKEYSIG ", GPG_STATUS_STDSIG },
 180         { 'R', "REVKEYSIG ", GPG_STATUS_STDSIG },
 181         { 0, "VALIDSIG ", GPG_STATUS_FINGERPRINT },
 182         { 0, "TRUST_", GPG_STATUS_TRUST_LEVEL },
 183 };
 184
 185 /* Keep the order same as enum signature_trust_level */
 186 static struct sigcheck_gpg_trust_level {
 187         const char *key;
 188         const char *display_key;
 189         enum signature_trust_level value;
 190 } sigcheck_gpg_trust_level[] = {
 191         { "UNDEFINED", "undefined", TRUST_UNDEFINED },
 192         { "NEVER", "never", TRUST_NEVER },
 193         { "MARGINAL", "marginal", TRUST_MARGINAL },
 194         { "FULLY", "fully", TRUST_FULLY },
 195         { "ULTIMATE", "ultimate", TRUST_ULTIMATE },
 196 };
 197
 198 static void replace_cstring(char **field, const char *line, const char *next)
 199 {
 200         free(*field);
 201
 202         if (line && next)
 203                 *field = xmemdupz(line, next - line);
 204         else
 205                 *field = NULL;
 206 }
 207
 208 static int parse_gpg_trust_level(const char *level,
 209                                  enum signature_trust_level *res)
 210 {
 211         size_t i;
 212
 213         for (i = 0; i < ARRAY_SIZE(sigcheck_gpg_trust_level); i++) {
 214                 if (!strcmp(sigcheck_gpg_trust_level[i].key, level)) {
 215                         *res = sigcheck_gpg_trust_level[i].value;
 216                         return 0;
 217                 }
 218         }
 219         return 1;
 220 }
 221
 222 static void parse_gpg_output(struct signature_check *sigc)
 223 {
 224         const char *buf = sigc->gpg_status;
 225         const char *line, *next;
 226         int i, j;
 227         int seen_exclusive_status = 0;
 228
 229         /* Iterate over all lines */
 230         for (line = buf; *line; line = strchrnul(line+1, '\n')) {
 231                 while (*line == '\n')
 232                         line++;
 233                 if (!*line)
 234                         break;
 235
 236                 /* Skip lines that don't start with GNUPG status */
 237                 if (!skip_prefix(line, "[GNUPG:] ", &line))
 238                         continue;
 239
 240                 /* Iterate over all search strings */
 241                 for (i = 0; i < ARRAY_SIZE(sigcheck_gpg_status); i++) {
 242                         if (skip_prefix(line, sigcheck_gpg_status[i].check, &line)) {
 243                                 /*
 244                                  * GOODSIG, BADSIG etc. can occur only once for
 245                                  * each signature.  Therefore, if we had more
 246                                  * than one then we're dealing with multiple
 247                                  * signatures.  We don't support them
 248                                  * currently, and they're rather hard to
 249                                  * create, so something is likely fishy and we
 250                                  * should reject them altogether.
 251                                  */
 252                                 if (sigcheck_gpg_status[i].flags & GPG_STATUS_EXCLUSIVE) {
 253                                         if (seen_exclusive_status++)
 254                                                 goto error;
 255                                 }
 256
 257                                 if (sigcheck_gpg_status[i].result)
 258                                         sigc->result = sigcheck_gpg_status[i].result;
 259                                 /* Do we have key information? */
 260                                 if (sigcheck_gpg_status[i].flags & GPG_STATUS_KEYID) {
 261                                         next = strchrnul(line, ' ');
 262                                         replace_cstring(&sigc->key, line, next);
 263                                         /* Do we have signer information? */
 264                                         if (*next && (sigcheck_gpg_status[i].flags & GPG_STATUS_UID)) {
 265                                                 line = next + 1;
 266                                                 next = strchrnul(line, '\n');
 267                                                 replace_cstring(&sigc->signer, line, next);
 268                                         }
 269                                 }
 270
 271                                 /* Do we have trust level? */
 272                                 if (sigcheck_gpg_status[i].flags & GPG_STATUS_TRUST_LEVEL) {
 273                                         /*
 274                                          * GPG v1 and v2 differs in how the
 275                                          * TRUST_ lines are written.  Some
 276                                          * trust lines contain no additional
 277                                          * space-separated information for v1.
 278                                          */
 279                                         size_t trust_size = strcspn(line, " \n");
 280                                         char *trust = xmemdupz(line, trust_size);
 281
 282                                         if (parse_gpg_trust_level(trust, &sigc->trust_level)) {
 283                                                 free(trust);
 284                                                 goto error;
 285                                         }
 286                                         free(trust);
 287                                 }
 288
 289                                 /* Do we have fingerprint? */
 290                                 if (sigcheck_gpg_status[i].flags & GPG_STATUS_FINGERPRINT) {
 291                                         const char *limit;
 292                                         char **field;
 293
 294                                         next = strchrnul(line, ' ');
 295                                         replace_cstring(&sigc->fingerprint, line, next);
 296
 297                                         /*
 298                                          * Skip interim fields.  The search is
 299                                          * limited to the same line since only
 300                                          * OpenPGP signatures has a field with
 301                                          * the primary fingerprint.
 302                                          */
 303                                         limit = strchrnul(line, '\n');
 304                                         for (j = 9; j > 0; j--) {
 305                                                 if (!*next || limit <= next)
 306                                                         break;
 307                                                 line = next + 1;
 308                                                 next = strchrnul(line, ' ');
 309                                         }
 310
 311                                         field = &sigc->primary_key_fingerprint;
 312                                         if (!j) {
 313                                                 next = strchrnul(line, '\n');
 314                                                 replace_cstring(field, line, next);
 315                                         } else {
 316                                                 replace_cstring(field, NULL, NULL);
 317                                         }
 318                                 }
 319
 320                                 break;
 321                         }
 322                 }
 323         }
 324         return;
 325
 326 error:
 327         sigc->result = 'E';
 328         /* Clear partial data to avoid confusion */
 329         FREE_AND_NULL(sigc->primary_key_fingerprint);
 330         FREE_AND_NULL(sigc->fingerprint);
 331         FREE_AND_NULL(sigc->signer);
 332         FREE_AND_NULL(sigc->key);
 333 }
 334
 335 static int verify_gpg_signed_buffer(struct signature_check *sigc,
 336                                     struct gpg_format *fmt,
 337                                     const char *signature,
 338                                     size_t signature_size)
 339 {
 340         struct child_process gpg = CHILD_PROCESS_INIT;
 341         struct tempfile *temp;
 342         int ret;
 343         struct strbuf gpg_stdout = STRBUF_INIT;
 344         struct strbuf gpg_stderr = STRBUF_INIT;
 345
 346         temp = mks_tempfile_t(".git_vtag_tmpXXXXXX");
 347         if (!temp)
 348                 return error_errno(_("could not create temporary file"));
 349         if (write_in_full(temp->fd, signature, signature_size) < 0 ||
 350             close_tempfile_gently(temp) < 0) {
 351                 error_errno(_("failed writing detached signature to '%s'"),
 352                             temp->filename.buf);
 353                 delete_tempfile(&temp);
 354                 return -1;
 355         }
 356
 357         strvec_push(&gpg.args, fmt->program);
 358         strvec_pushv(&gpg.args, fmt->verify_args);
 359         strvec_pushl(&gpg.args,
 360                      "--status-fd=1",
 361                      "--verify", temp->filename.buf, "-",
 362                      NULL);
 363
 364         sigchain_push(SIGPIPE, SIG_IGN);
 365         ret = pipe_command(&gpg, sigc->payload, sigc->payload_len, &gpg_stdout, 0,
 366                            &gpg_stderr, 0);
 367         sigchain_pop(SIGPIPE);
 368
 369         delete_tempfile(&temp);
 370
 371         ret |= !strstr(gpg_stdout.buf, "\n[GNUPG:] GOODSIG ");
 372         sigc->output = strbuf_detach(&gpg_stderr, NULL);
 373         sigc->gpg_status = strbuf_detach(&gpg_stdout, NULL);
 374
 375         parse_gpg_output(sigc);
 376
 377         strbuf_release(&gpg_stdout);
 378         strbuf_release(&gpg_stderr);
 379
 380         return ret;
 381 }
 382
 383 static void parse_ssh_output(struct signature_check *sigc)
 384 {
 385         const char *line, *principal, *search;
 386         char *to_free;
 387         char *key = NULL;
 388
 389         /*
 390          * ssh-keygen output should be:
 391          * Good "git" signature for PRINCIPAL with RSA key SHA256:FINGERPRINT
 392          *
 393          * or for valid but unknown keys:
 394          * Good "git" signature with RSA key SHA256:FINGERPRINT
 395          *
 396          * Note that "PRINCIPAL" can contain whitespace, "RSA" and
 397          * "SHA256" part could be a different token that names of
 398          * the algorithms used, and "FINGERPRINT" is a hexadecimal
 399          * string.  By finding the last occurence of " with ", we can
 400          * reliably parse out the PRINCIPAL.
 401          */
 402         sigc->result = 'B';
 403         sigc->trust_level = TRUST_NEVER;
 404
 405         line = to_free = xmemdupz(sigc->output, strcspn(sigc->output, "\n"));
 406
 407         if (skip_prefix(line, "Good \"git\" signature for ", &line)) {
 408                 /* Search for the last "with" to get the full principal */
 409                 principal = line;
 410                 do {
 411                         search = strstr(line, " with ");
 412                         if (search)
 413                                 line = search + 1;
 414                 } while (search != NULL);
 415                 if (line == principal)
 416                         goto cleanup;
 417
 418                 /* Valid signature and known principal */
 419                 sigc->result = 'G';
 420                 sigc->trust_level = TRUST_FULLY;
 421                 sigc->signer = xmemdupz(principal, line - principal - 1);
 422         } else if (skip_prefix(line, "Good \"git\" signature with ", &line)) {
 423                 /* Valid signature, but key unknown */
 424                 sigc->result = 'G';
 425                 sigc->trust_level = TRUST_UNDEFINED;
 426         } else {
 427                 goto cleanup;
 428         }
 429
 430         key = strstr(line, "key ");
 431         if (key) {
 432                 sigc->fingerprint = xstrdup(strstr(line, "key ") + 4);
 433                 sigc->key = xstrdup(sigc->fingerprint);
 434         } else {
 435                 /*
 436                  * Output did not match what we expected
 437                  * Treat the signature as bad
 438                  */
 439                 sigc->result = 'B';
 440         }
 441
 442 cleanup:
 443         free(to_free);
 444 }
 445
 446 static int verify_ssh_signed_buffer(struct signature_check *sigc,
 447                                     struct gpg_format *fmt,
 448                                     const char *signature,
 449                                     size_t signature_size)
 450 {
 451         struct child_process ssh_keygen = CHILD_PROCESS_INIT;
 452         struct tempfile *buffer_file;
 453         int ret = -1;
 454         const char *line;
 455         char *principal;
 456         struct strbuf ssh_principals_out = STRBUF_INIT;
 457         struct strbuf ssh_principals_err = STRBUF_INIT;
 458         struct strbuf ssh_keygen_out = STRBUF_INIT;
 459         struct strbuf ssh_keygen_err = STRBUF_INIT;
 460         struct strbuf verify_time = STRBUF_INIT;
 461         const struct date_mode verify_date_mode = {
 462                 .type = DATE_STRFTIME,
 463                 .strftime_fmt = "%Y%m%d%H%M%S",
 464                 /* SSH signing key validity has no timezone information - Use the local timezone */
 465                 .local = 1,
 466         };
 467
 468         if (!ssh_allowed_signers) {
 469                 error(_("gpg.ssh.allowedSignersFile needs to be configured and exist for ssh signature verification"));
 470                 return -1;
 471         }
 472
 473         buffer_file = mks_tempfile_t(".git_vtag_tmpXXXXXX");
 474         if (!buffer_file)
 475                 return error_errno(_("could not create temporary file"));
 476         if (write_in_full(buffer_file->fd, signature, signature_size) < 0 ||
 477             close_tempfile_gently(buffer_file) < 0) {
 478                 error_errno(_("failed writing detached signature to '%s'"),
 479                             buffer_file->filename.buf);
 480                 delete_tempfile(&buffer_file);
 481                 return -1;
 482         }
 483
 484         if (sigc->payload_timestamp)
 485                 strbuf_addf(&verify_time, "-Overify-time=%s",
 486                         show_date(sigc->payload_timestamp, 0, &verify_date_mode));
 487
 488         /* Find the principal from the signers */
 489         strvec_pushl(&ssh_keygen.args, fmt->program,
 490                      "-Y", "find-principals",
 491                      "-f", ssh_allowed_signers,
 492                      "-s", buffer_file->filename.buf,
 493                      verify_time.buf,
 494                      NULL);
 495         ret = pipe_command(&ssh_keygen, NULL, 0, &ssh_principals_out, 0,
 496                            &ssh_principals_err, 0);
 497         if (ret && strstr(ssh_principals_err.buf, "usage:")) {
 498                 error(_("ssh-keygen -Y find-principals/verify is needed for ssh signature verification (available in openssh version 8.2p1+)"));
 499                 goto out;
 500         }
 501         if (ret || !ssh_principals_out.len) {
 502                 /*
 503                  * We did not find a matching principal in the allowedSigners
 504                  * Check without validation
 505                  */
 506                 child_process_init(&ssh_keygen);
 507                 strvec_pushl(&ssh_keygen.args, fmt->program,
 508                              "-Y", "check-novalidate",
 509                              "-n", "git",
 510                              "-s", buffer_file->filename.buf,
 511                              verify_time.buf,
 512                              NULL);
 513                 pipe_command(&ssh_keygen, sigc->payload, sigc->payload_len,
 514                                    &ssh_keygen_out, 0, &ssh_keygen_err, 0);
 515
 516                 /*
 517                  * Fail on unknown keys
 518                  * we still call check-novalidate to display the signature info
 519                  */
 520                 ret = -1;
 521         } else {
 522                 /* Check every principal we found (one per line) */
 523                 const char *next;
 524                 for (line = ssh_principals_out.buf;
 525                      *line;
 526                      line = next) {
 527                         const char *end_of_text;
 528
 529                         next = end_of_text = strchrnul(line, '\n');
 530
 531                          /* Did we find a LF, and did we have CR before it? */
 532                         if (*end_of_text &&
 533                             line < end_of_text &&
 534                             end_of_text[-1] == '\r')
 535                                 end_of_text--;
 536
 537                         /* Unless we hit NUL, skip over the LF we found */
 538                         if (*next)
 539                                 next++;
 540
 541                         /* Not all lines are data.  Skip empty ones */
 542                         if (line == end_of_text)
 543                                 continue;
 544
 545                         /* We now know we have an non-empty line. Process it */
 546                         principal = xmemdupz(line, end_of_text - line);
 547
 548                         child_process_init(&ssh_keygen);
 549                         strbuf_release(&ssh_keygen_out);
 550                         strbuf_release(&ssh_keygen_err);
 551                         strvec_push(&ssh_keygen.args, fmt->program);
 552                         /*
 553                          * We found principals
 554                          * Try with each until we find a match
 555                          */
 556                         strvec_pushl(&ssh_keygen.args, "-Y", "verify",
 557                                      "-n", "git",
 558                                      "-f", ssh_allowed_signers,
 559                                      "-I", principal,
 560                                      "-s", buffer_file->filename.buf,
 561                                      verify_time.buf,
 562                                      NULL);
 563
 564                         if (ssh_revocation_file) {
 565                                 if (file_exists(ssh_revocation_file)) {
 566                                         strvec_pushl(&ssh_keygen.args, "-r",
 567                                                      ssh_revocation_file, NULL);
 568                                 } else {
 569                                         warning(_("ssh signing revocation file configured but not found: %s"),
 570                                                 ssh_revocation_file);
 571                                 }
 572                         }
 573
 574                         sigchain_push(SIGPIPE, SIG_IGN);
 575                         ret = pipe_command(&ssh_keygen, sigc->payload, sigc->payload_len,
 576                                            &ssh_keygen_out, 0, &ssh_keygen_err, 0);
 577                         sigchain_pop(SIGPIPE);
 578
 579                         FREE_AND_NULL(principal);
 580
 581                         if (!ret)
 582                                 ret = !starts_with(ssh_keygen_out.buf, "Good");
 583
 584                         if (!ret)
 585                                 break;
 586                 }
 587         }
 588
 589         strbuf_stripspace(&ssh_keygen_out, '\0');
 590         strbuf_stripspace(&ssh_keygen_err, '\0');
 591         /* Add stderr outputs to show the user actual ssh-keygen errors */
 592         strbuf_add(&ssh_keygen_out, ssh_principals_err.buf, ssh_principals_err.len);
 593         strbuf_add(&ssh_keygen_out, ssh_keygen_err.buf, ssh_keygen_err.len);
 594         sigc->output = strbuf_detach(&ssh_keygen_out, NULL);
 595         sigc->gpg_status = xstrdup(sigc->output);
 596
 597         parse_ssh_output(sigc);
 598
 599 out:
 600         if (buffer_file)
 601                 delete_tempfile(&buffer_file);
 602         strbuf_release(&ssh_principals_out);
 603         strbuf_release(&ssh_principals_err);
 604         strbuf_release(&ssh_keygen_out);
 605         strbuf_release(&ssh_keygen_err);
 606         strbuf_release(&verify_time);
 607
 608         return ret;
 609 }
 610
 611 static int parse_payload_metadata(struct signature_check *sigc)
 612 {
 613         const char *ident_line = NULL;
 614         size_t ident_len;
 615         struct ident_split ident;
 616         const char *signer_header;
 617
 618         switch (sigc->payload_type) {
 619         case SIGNATURE_PAYLOAD_COMMIT:
 620                 signer_header = "committer";
 621                 break;
 622         case SIGNATURE_PAYLOAD_TAG:
 623                 signer_header = "tagger";
 624                 break;
 625         case SIGNATURE_PAYLOAD_UNDEFINED:
 626         case SIGNATURE_PAYLOAD_PUSH_CERT:
 627                 /* Ignore payloads we don't want to parse */
 628                 return 0;
 629         default:
 630                 BUG("invalid value for sigc->payload_type");
 631         }
 632
 633         ident_line = find_commit_header(sigc->payload, signer_header, &ident_len);
 634         if (!ident_line || !ident_len)
 635                 return 1;
 636
 637         if (split_ident_line(&ident, ident_line, ident_len))
 638                 return 1;
 639
 640         if (!sigc->payload_timestamp && ident.date_begin && ident.date_end)
 641                 sigc->payload_timestamp = parse_timestamp(ident.date_begin, NULL, 10);
 642
 643         return 0;
 644 }
 645
 646 int check_signature(struct signature_check *sigc,
 647                     const char *signature, size_t slen)
 648 {
 649         struct gpg_format *fmt;
 650         int status;
 651
 652         gpg_interface_lazy_init();
 653
 654         sigc->result = 'N';
 655         sigc->trust_level = TRUST_UNDEFINED;
 656
 657         fmt = get_format_by_sig(signature);
 658         if (!fmt)
 659                 die(_("bad/incompatible signature '%s'"), signature);
 660
 661         if (parse_payload_metadata(sigc))
 662                 return 1;
 663
 664         status = fmt->verify_signed_buffer(sigc, fmt, signature, slen);
 665
 666         if (status && !sigc->output)
 667                 return !!status;
 668
 669         status |= sigc->result != 'G';
 670         status |= sigc->trust_level < configured_min_trust_level;
 671
 672         return !!status;
 673 }
 674
 675 void print_signature_buffer(const struct signature_check *sigc, unsigned flags)
 676 {
 677         const char *output = flags & GPG_VERIFY_RAW ? sigc->gpg_status :
 678                                                             sigc->output;
 679
 680         if (flags & GPG_VERIFY_VERBOSE && sigc->payload)
 681                 fwrite(sigc->payload, 1, sigc->payload_len, stdout);
 682
 683         if (output)
 684                 fputs(output, stderr);
 685 }
 686
 687 size_t parse_signed_buffer(const char *buf, size_t size)
 688 {
 689         size_t len = 0;
 690         size_t match = size;
 691         while (len < size) {
 692                 const char *eol;
 693
 694                 if (get_format_by_sig(buf + len))
 695                         match = len;
 696
 697                 eol = memchr(buf + len, '\n', size - len);
 698                 len += eol ? eol - (buf + len) + 1 : size - len;
 699         }
 700         return match;
 701 }
 702
 703 int parse_signature(const char *buf, size_t size, struct strbuf *payload, struct strbuf *signature)
 704 {
 705         size_t match = parse_signed_buffer(buf, size);
 706         if (match != size) {
 707                 strbuf_add(payload, buf, match);
 708                 remove_signature(payload);
 709                 strbuf_add(signature, buf + match, size - match);
 710                 return 1;
 711         }
 712         return 0;
 713 }
 714
 715 void set_signing_key(const char *key)
 716 {
 717         gpg_interface_lazy_init();
 718
 719         free(configured_signing_key);
 720         configured_signing_key = xstrdup(key);
 721 }
 722
 723 static int git_gpg_config(const char *var, const char *value,
 724                           const struct config_context *ctx UNUSED,
 725                           void *cb UNUSED)
 726 {
 727         struct gpg_format *fmt = NULL;
 728         char *fmtname = NULL;
 729         char *trust;
 730         int ret;
 731
 732         if (!strcmp(var, "user.signingkey")) {
 733                 if (!value)
 734                         return config_error_nonbool(var);
 735                 set_signing_key(value);
 736                 return 0;
 737         }
 738
 739         if (!strcmp(var, "gpg.format")) {
 740                 if (!value)
 741                         return config_error_nonbool(var);
 742                 fmt = get_format_by_name(value);
 743                 if (!fmt)
 744                         return error(_("invalid value for '%s': '%s'"),
 745                                      var, value);
 746                 use_format = fmt;
 747                 return 0;
 748         }
 749
 750         if (!strcmp(var, "gpg.mintrustlevel")) {
 751                 if (!value)
 752                         return config_error_nonbool(var);
 753
 754                 trust = xstrdup_toupper(value);
 755                 ret = parse_gpg_trust_level(trust, &configured_min_trust_level);
 756                 free(trust);
 757
 758                 if (ret)
 759                         return error(_("invalid value for '%s': '%s'"),
 760                                      var, value);
 761                 return 0;
 762         }
 763
 764         if (!strcmp(var, "gpg.ssh.defaultkeycommand"))
 765                 return git_config_string(&ssh_default_key_command, var, value);
 766
 767         if (!strcmp(var, "gpg.ssh.allowedsignersfile"))
 768                 return git_config_pathname(&ssh_allowed_signers, var, value);
 769
 770         if (!strcmp(var, "gpg.ssh.revocationfile"))
 771                 return git_config_pathname(&ssh_revocation_file, var, value);
 772
 773         if (!strcmp(var, "gpg.program") || !strcmp(var, "gpg.openpgp.program"))
 774                 fmtname = "openpgp";
 775
 776         if (!strcmp(var, "gpg.x509.program"))
 777                 fmtname = "x509";
 778
 779         if (!strcmp(var, "gpg.ssh.program"))
 780                 fmtname = "ssh";
 781
 782         if (fmtname) {
 783                 fmt = get_format_by_name(fmtname);
 784                 return git_config_string(&fmt->program, var, value);
 785         }
 786
 787         return 0;
 788 }
 789
 790 /*
 791  * Returns 1 if `string` contains a literal ssh key, 0 otherwise
 792  * `key` will be set to the start of the actual key if a prefix is present.
 793  */
 794 static int is_literal_ssh_key(const char *string, const char **key)
 795 {
 796         if (skip_prefix(string, "key::", key))
 797                 return 1;
 798         if (starts_with(string, "ssh-")) {
 799                 *key = string;
 800                 return 1;
 801         }
 802         return 0;
 803 }
 804
 805 static char *get_ssh_key_fingerprint(const char *signing_key)
 806 {
 807         struct child_process ssh_keygen = CHILD_PROCESS_INIT;
 808         int ret = -1;
 809         struct strbuf fingerprint_stdout = STRBUF_INIT;
 810         struct strbuf **fingerprint;
 811         char *fingerprint_ret;
 812         const char *literal_key = NULL;
 813
 814         /*
 815          * With SSH Signing this can contain a filename or a public key
 816          * For textual representation we usually want a fingerprint
 817          */
 818         if (is_literal_ssh_key(signing_key, &literal_key)) {
 819                 strvec_pushl(&ssh_keygen.args, "ssh-keygen", "-lf", "-", NULL);
 820                 ret = pipe_command(&ssh_keygen, literal_key,
 821                                    strlen(literal_key), &fingerprint_stdout, 0,
 822                                    NULL, 0);
 823         } else {
 824                 strvec_pushl(&ssh_keygen.args, "ssh-keygen", "-lf",
 825                              configured_signing_key, NULL);
 826                 ret = pipe_command(&ssh_keygen, NULL, 0, &fingerprint_stdout, 0,
 827                                    NULL, 0);
 828         }
 829
 830         if (!!ret)
 831                 die_errno(_("failed to get the ssh fingerprint for key '%s'"),
 832                           signing_key);
 833
 834         fingerprint = strbuf_split_max(&fingerprint_stdout, ' ', 3);
 835         if (!fingerprint[1])
 836                 die_errno(_("failed to get the ssh fingerprint for key '%s'"),
 837                           signing_key);
 838
 839         fingerprint_ret = strbuf_detach(fingerprint[1], NULL);
 840         strbuf_list_free(fingerprint);
 841         strbuf_release(&fingerprint_stdout);
 842         return fingerprint_ret;
 843 }
 844
 845 /* Returns the first public key from an ssh-agent to use for signing */
 846 static const char *get_default_ssh_signing_key(void)
 847 {
 848         struct child_process ssh_default_key = CHILD_PROCESS_INIT;
 849         int ret = -1;
 850         struct strbuf key_stdout = STRBUF_INIT, key_stderr = STRBUF_INIT;
 851         struct strbuf **keys;
 852         char *key_command = NULL;
 853         const char **argv;
 854         int n;
 855         char *default_key = NULL;
 856         const char *literal_key = NULL;
 857
 858         if (!ssh_default_key_command)
 859                 die(_("either user.signingkey or gpg.ssh.defaultKeyCommand needs to be configured"));
 860
 861         key_command = xstrdup(ssh_default_key_command);
 862         n = split_cmdline(key_command, &argv);
 863
 864         if (n < 0)
 865                 die("malformed build-time gpg.ssh.defaultKeyCommand: %s",
 866                     split_cmdline_strerror(n));
 867
 868         strvec_pushv(&ssh_default_key.args, argv);
 869         ret = pipe_command(&ssh_default_key, NULL, 0, &key_stdout, 0,
 870                            &key_stderr, 0);
 871
 872         if (!ret) {
 873                 keys = strbuf_split_max(&key_stdout, '\n', 2);
 874                 if (keys[0] && is_literal_ssh_key(keys[0]->buf, &literal_key)) {
 875                         /*
 876                          * We only use `is_literal_ssh_key` here to check validity
 877                          * The prefix will be stripped when the key is used.
 878                          */
 879                         default_key = strbuf_detach(keys[0], NULL);
 880                 } else {
 881                         warning(_("gpg.ssh.defaultKeyCommand succeeded but returned no keys: %s %s"),
 882                                 key_stderr.buf, key_stdout.buf);
 883                 }
 884
 885                 strbuf_list_free(keys);
 886         } else {
 887                 warning(_("gpg.ssh.defaultKeyCommand failed: %s %s"),
 888                         key_stderr.buf, key_stdout.buf);
 889         }
 890
 891         free(key_command);
 892         free(argv);
 893         strbuf_release(&key_stdout);
 894
 895         return default_key;
 896 }
 897
 898 static const char *get_ssh_key_id(void) {
 899         return get_ssh_key_fingerprint(get_signing_key());
 900 }
 901
 902 /* Returns a textual but unique representation of the signing key */
 903 const char *get_signing_key_id(void)
 904 {
 905         gpg_interface_lazy_init();
 906
 907         if (use_format->get_key_id) {
 908                 return use_format->get_key_id();
 909         }
 910
 911         /* GPG/GPGSM only store a key id on this variable */
 912         return get_signing_key();
 913 }
 914
 915 const char *get_signing_key(void)
 916 {
 917         gpg_interface_lazy_init();
 918
 919         if (configured_signing_key)
 920                 return configured_signing_key;
 921         if (use_format->get_default_key) {
 922                 return use_format->get_default_key();
 923         }
 924
 925         return git_committer_info(IDENT_STRICT | IDENT_NO_DATE);
 926 }
 927
 928 const char *gpg_trust_level_to_str(enum signature_trust_level level)
 929 {
 930         struct sigcheck_gpg_trust_level *trust;
 931
 932         if (level < 0 || level >= ARRAY_SIZE(sigcheck_gpg_trust_level))
 933                 BUG("invalid trust level requested %d", level);
 934
 935         trust = &sigcheck_gpg_trust_level[level];
 936         if (trust->value != level)
 937                 BUG("sigcheck_gpg_trust_level[] unsorted");
 938
 939         return sigcheck_gpg_trust_level[level].display_key;
 940 }
 941
 942 int sign_buffer(struct strbuf *buffer, struct strbuf *signature, const char *signing_key)
 943 {
 944         gpg_interface_lazy_init();
 945
 946         return use_format->sign_buffer(buffer, signature, signing_key);
 947 }
 948
 949 /*
 950  * Strip CR from the line endings, in case we are on Windows.
 951  * NEEDSWORK: make it trim only CRs before LFs and rename
 952  */
 953 static void remove_cr_after(struct strbuf *buffer, size_t offset)
 954 {
 955         size_t i, j;
 956
 957         for (i = j = offset; i < buffer->len; i++) {
 958                 if (buffer->buf[i] != '\r') {
 959                         if (i != j)
 960                                 buffer->buf[j] = buffer->buf[i];
 961                         j++;
 962                 }
 963         }
 964         strbuf_setlen(buffer, j);
 965 }
 966
 967 static int sign_buffer_gpg(struct strbuf *buffer, struct strbuf *signature,
 968                           const char *signing_key)
 969 {
 970         struct child_process gpg = CHILD_PROCESS_INIT;
 971         int ret;
 972         size_t bottom;
 973         const char *cp;
 974         struct strbuf gpg_status = STRBUF_INIT;
 975
 976         strvec_pushl(&gpg.args,
 977                      use_format->program,
 978                      "--status-fd=2",
 979                      "-bsau", signing_key,
 980                      NULL);
 981
 982         bottom = signature->len;
 983
 984         /*
 985          * When the username signingkey is bad, program could be terminated
 986          * because gpg exits without reading and then write gets SIGPIPE.
 987          */
 988         sigchain_push(SIGPIPE, SIG_IGN);
 989         ret = pipe_command(&gpg, buffer->buf, buffer->len,
 990                            signature, 1024, &gpg_status, 0);
 991         sigchain_pop(SIGPIPE);
 992
 993         for (cp = gpg_status.buf;
 994              cp && (cp = strstr(cp, "[GNUPG:] SIG_CREATED "));
 995              cp++) {
 996                 if (cp == gpg_status.buf || cp[-1] == '\n')
 997                         break; /* found */
 998         }
 999         ret |= !cp;
1000         if (ret) {
1001                 error(_("gpg failed to sign the data:\n%s"),
1002                       gpg_status.len ? gpg_status.buf : "(no gpg output)");
1003                 strbuf_release(&gpg_status);
1004                 return -1;
1005         }
1006         strbuf_release(&gpg_status);
1007
1008         /* Strip CR from the line endings, in case we are on Windows. */
1009         remove_cr_after(signature, bottom);
1010
1011         return 0;
1012 }
1013
1014 static int sign_buffer_ssh(struct strbuf *buffer, struct strbuf *signature,
1015                            const char *signing_key)
1016 {
1017         struct child_process signer = CHILD_PROCESS_INIT;
1018         int ret = -1;
1019         size_t bottom, keylen;
1020         struct strbuf signer_stderr = STRBUF_INIT;
1021         struct tempfile *key_file = NULL, *buffer_file = NULL;
1022         char *ssh_signing_key_file = NULL;
1023         struct strbuf ssh_signature_filename = STRBUF_INIT;
1024         const char *literal_key = NULL;
1025         int literal_ssh_key = 0;
1026
1027         if (!signing_key || signing_key[0] == '\0')
1028                 return error(
1029                         _("user.signingKey needs to be set for ssh signing"));
1030
1031         if (is_literal_ssh_key(signing_key, &literal_key)) {
1032                 /* A literal ssh key */
1033                 literal_ssh_key = 1;
1034                 key_file = mks_tempfile_t(".git_signing_key_tmpXXXXXX");
1035                 if (!key_file)
1036                         return error_errno(
1037                                 _("could not create temporary file"));
1038                 keylen = strlen(literal_key);
1039                 if (write_in_full(key_file->fd, literal_key, keylen) < 0 ||
1040                     close_tempfile_gently(key_file) < 0) {
1041                         error_errno(_("failed writing ssh signing key to '%s'"),
1042                                     key_file->filename.buf);
1043                         goto out;
1044                 }
1045                 ssh_signing_key_file = strbuf_detach(&key_file->filename, NULL);
1046         } else {
1047                 /* We assume a file */
1048                 ssh_signing_key_file = interpolate_path(signing_key, 1);
1049         }
1050
1051         buffer_file = mks_tempfile_t(".git_signing_buffer_tmpXXXXXX");
1052         if (!buffer_file) {
1053                 error_errno(_("could not create temporary file"));
1054                 goto out;
1055         }
1056
1057         if (write_in_full(buffer_file->fd, buffer->buf, buffer->len) < 0 ||
1058             close_tempfile_gently(buffer_file) < 0) {
1059                 error_errno(_("failed writing ssh signing key buffer to '%s'"),
1060                             buffer_file->filename.buf);
1061                 goto out;
1062         }
1063
1064         strvec_pushl(&signer.args, use_format->program,
1065                      "-Y", "sign",
1066                      "-n", "git",
1067                      "-f", ssh_signing_key_file,
1068                      NULL);
1069         if (literal_ssh_key)
1070                 strvec_push(&signer.args, "-U");
1071         strvec_push(&signer.args, buffer_file->filename.buf);
1072
1073         sigchain_push(SIGPIPE, SIG_IGN);
1074         ret = pipe_command(&signer, NULL, 0, NULL, 0, &signer_stderr, 0);
1075         sigchain_pop(SIGPIPE);
1076
1077         if (ret) {
1078                 if (strstr(signer_stderr.buf, "usage:"))
1079                         error(_("ssh-keygen -Y sign is needed for ssh signing (available in openssh version 8.2p1+)"));
1080
1081                 ret = error("%s", signer_stderr.buf);
1082                 goto out;
1083         }
1084
1085         bottom = signature->len;
1086
1087         strbuf_addbuf(&ssh_signature_filename, &buffer_file->filename);
1088         strbuf_addstr(&ssh_signature_filename, ".sig");
1089         if (strbuf_read_file(signature, ssh_signature_filename.buf, 0) < 0) {
1090                 ret = error_errno(
1091                         _("failed reading ssh signing data buffer from '%s'"),
1092                         ssh_signature_filename.buf);
1093                 goto out;
1094         }
1095         /* Strip CR from the line endings, in case we are on Windows. */
1096         remove_cr_after(signature, bottom);
1097
1098 out:
1099         if (key_file)
1100                 delete_tempfile(&key_file);
1101         if (buffer_file)
1102                 delete_tempfile(&buffer_file);
1103         if (ssh_signature_filename.len)
1104                 unlink_or_warn(ssh_signature_filename.buf);
1105         strbuf_release(&signer_stderr);
1106         strbuf_release(&ssh_signature_filename);
1107         FREE_AND_NULL(ssh_signing_key_file);
1108         return ret;
1109 }