sm/call-agent.c

   1 /* call-agent.c - Divert GPGSM operations to the agent
   2  * Copyright (C) 2001, 2002, 2003, 2005, 2007,
   3  *               2008, 2009, 2010 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <unistd.h>
  27 #include <time.h>
  28 #include <assert.h>
  29 #ifdef HAVE_LOCALE_H
  30 #include <locale.h>
  31 #endif
  32
  33 #include "gpgsm.h"
  34 #include <gcrypt.h>
  35 #include <assuan.h>
  36 #include "i18n.h"
  37 #include "asshelp.h"
  38 #include "keydb.h" /* fixme: Move this to import.c */
  39 #include "membuf.h"
  40 #include "shareddefs.h"
  41 #include "passphrase.h"
  42
  43
  44 static assuan_context_t agent_ctx = NULL;
  45
  46
  47 struct cipher_parm_s
  48 {
  49   ctrl_t ctrl;
  50   assuan_context_t ctx;
  51   const unsigned char *ciphertext;
  52   size_t ciphertextlen;
  53 };
  54
  55 struct genkey_parm_s
  56 {
  57   ctrl_t ctrl;
  58   assuan_context_t ctx;
  59   const unsigned char *sexp;
  60   size_t sexplen;
  61 };
  62
  63 struct learn_parm_s
  64 {
  65   int error;
  66   ctrl_t ctrl;
  67   assuan_context_t ctx;
  68   membuf_t *data;
  69 };
  70
  71 struct import_key_parm_s
  72 {
  73   ctrl_t ctrl;
  74   assuan_context_t ctx;
  75   const void *key;
  76   size_t keylen;
  77 };
  78
  79 struct default_inq_parm_s
  80 {
  81   ctrl_t ctrl;
  82   assuan_context_t ctx;
  83 };
  84
  85 \f
  86 /* Print a warning if the server's version number is less than our
  87    version number.  Returns an error code on a connection problem.  */
  88 static gpg_error_t
  89 warn_version_mismatch (ctrl_t ctrl, assuan_context_t ctx,
  90                        const char *servername, int mode)
  91 {
  92   gpg_error_t err;
  93   char *serverversion;
  94   const char *myversion = strusage (13);
  95
  96   err = get_assuan_server_version (ctx, mode, &serverversion);
  97   if (err)
  98     log_error (_("error getting version from '%s': %s\n"),
  99                servername, gpg_strerror (err));
 100   else if (!compare_version_strings (serverversion, myversion))
 101     {
 102       char *warn;
 103
 104       warn = xtryasprintf (_("server '%s' is older than us (%s < %s)"),
 105                            servername, serverversion, myversion);
 106       if (!warn)
 107         err = gpg_error_from_syserror ();
 108       else
 109         {
 110           log_info (_("WARNING: %s\n"), warn);
 111           gpgsm_status2 (ctrl, STATUS_WARNING, "server_version_mismatch 0",
 112                          warn, NULL);
 113           xfree (warn);
 114         }
 115     }
 116   xfree (serverversion);
 117   return err;
 118 }
 119
 120
 121 /* Try to connect to the agent via socket or fork it off and work by
 122    pipes.  Handle the server's initial greeting */
 123 static int
 124 start_agent (ctrl_t ctrl)
 125 {
 126   int rc;
 127
 128   if (agent_ctx)
 129     rc = 0;      /* fixme: We need a context for each thread or
 130                     serialize the access to the agent (which is
 131                     suitable given that the agent is not MT. */
 132   else
 133     {
 134       rc = start_new_gpg_agent (&agent_ctx,
 135                                 GPG_ERR_SOURCE_DEFAULT,
 136                                 opt.homedir,
 137                                 opt.agent_program,
 138                                 opt.lc_ctype, opt.lc_messages,
 139                                 opt.session_env,
 140                                 opt.autostart, opt.verbose, DBG_IPC,
 141                                 gpgsm_status2, ctrl);
 142
 143       if (!opt.autostart && gpg_err_code (rc) == GPG_ERR_NO_AGENT)
 144         {
 145           static int shown;
 146
 147           if (!shown)
 148             {
 149               shown = 1;
 150               log_info (_("no gpg-agent running in this session\n"));
 151             }
 152         }
 153       else if (!rc && !(rc = warn_version_mismatch (ctrl, agent_ctx,
 154                                                     GPG_AGENT_NAME, 0)))
 155         {
 156           /* Tell the agent that we support Pinentry notifications.  No
 157              error checking so that it will work also with older
 158              agents.  */
 159           assuan_transact (agent_ctx, "OPTION allow-pinentry-notify",
 160                            NULL, NULL, NULL, NULL, NULL, NULL);
 161
 162           /* Pass on the pinentry mode.  */
 163           if (opt.pinentry_mode)
 164             {
 165               char *tmp = xasprintf ("OPTION pinentry-mode=%s",
 166                                      str_pinentry_mode (opt.pinentry_mode));
 167               rc = assuan_transact (agent_ctx, tmp,
 168                                NULL, NULL, NULL, NULL, NULL, NULL);
 169               xfree (tmp);
 170               if (rc)
 171                 log_error ("setting pinentry mode '%s' failed: %s\n",
 172                            str_pinentry_mode (opt.pinentry_mode),
 173                            gpg_strerror (rc));
 174             }
 175         }
 176     }
 177
 178   if (!ctrl->agent_seen)
 179     {
 180       ctrl->agent_seen = 1;
 181       audit_log_ok (ctrl->audit, AUDIT_AGENT_READY, rc);
 182     }
 183
 184   return rc;
 185 }
 186
 187 /* This is the default inquiry callback.  It mainly handles the
 188    Pinentry notifications.  */
 189 static gpg_error_t
 190 default_inq_cb (void *opaque, const char *line)
 191 {
 192   gpg_error_t err = 0;
 193   struct default_inq_parm_s *parm = opaque;
 194   ctrl_t ctrl = parm->ctrl;
 195
 196   if (has_leading_keyword (line, "PINENTRY_LAUNCHED"))
 197     {
 198       err = gpgsm_proxy_pinentry_notify (ctrl, line);
 199       if (err)
 200         log_error (_("failed to proxy %s inquiry to client\n"),
 201                    "PINENTRY_LAUNCHED");
 202       /* We do not pass errors to avoid breaking other code.  */
 203     }
 204   else if ((has_leading_keyword (line, "PASSPHRASE")
 205             || has_leading_keyword (line, "NEW_PASSPHRASE"))
 206            && opt.pinentry_mode == PINENTRY_MODE_LOOPBACK
 207            && have_static_passphrase ())
 208     {
 209       const char *s = get_static_passphrase ();
 210       err = assuan_send_data (parm->ctx, s, strlen (s));
 211     }
 212   else
 213     log_error ("ignoring gpg-agent inquiry '%s'\n", line);
 214
 215   return err;
 216 }
 217
 218
 219
 220 \f
 221 /* Call the agent to do a sign operation using the key identified by
 222    the hex string KEYGRIP. */
 223 int
 224 gpgsm_agent_pksign (ctrl_t ctrl, const char *keygrip, const char *desc,
 225                     unsigned char *digest, size_t digestlen, int digestalgo,
 226                     unsigned char **r_buf, size_t *r_buflen )
 227 {
 228   int rc, i;
 229   char *p, line[ASSUAN_LINELENGTH];
 230   membuf_t data;
 231   size_t len;
 232   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
 233
 234   *r_buf = NULL;
 235   rc = start_agent (ctrl);
 236   if (rc)
 237     return rc;
 238
 239   if (digestlen*2 + 50 > DIM(line))
 240     return gpg_error (GPG_ERR_GENERAL);
 241
 242   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
 243   if (rc)
 244     return rc;
 245
 246   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
 247   line[DIM(line)-1] = 0;
 248   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
 249   if (rc)
 250     return rc;
 251
 252   if (desc)
 253     {
 254       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
 255       line[DIM(line)-1] = 0;
 256       rc = assuan_transact (agent_ctx, line,
 257                             NULL, NULL, NULL, NULL, NULL, NULL);
 258       if (rc)
 259         return rc;
 260     }
 261
 262   sprintf (line, "SETHASH %d ", digestalgo);
 263   p = line + strlen (line);
 264   for (i=0; i < digestlen ; i++, p += 2 )
 265     sprintf (p, "%02X", digest[i]);
 266   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
 267   if (rc)
 268     return rc;
 269
 270   init_membuf (&data, 1024);
 271   rc = assuan_transact (agent_ctx, "PKSIGN",
 272                         put_membuf_cb, &data, default_inq_cb, &inq_parm,
 273                         NULL, NULL);
 274   if (rc)
 275     {
 276       xfree (get_membuf (&data, &len));
 277       return rc;
 278     }
 279   *r_buf = get_membuf (&data, r_buflen);
 280
 281   if (!gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL))
 282     {
 283       xfree (*r_buf); *r_buf = NULL;
 284       return gpg_error (GPG_ERR_INV_VALUE);
 285     }
 286
 287   return *r_buf? 0 : out_of_core ();
 288 }
 289
 290
 291 /* Call the scdaemon to do a sign operation using the key identified by
 292    the hex string KEYID. */
 293 int
 294 gpgsm_scd_pksign (ctrl_t ctrl, const char *keyid, const char *desc,
 295                   unsigned char *digest, size_t digestlen, int digestalgo,
 296                   unsigned char **r_buf, size_t *r_buflen )
 297 {
 298   int rc, i;
 299   char *p, line[ASSUAN_LINELENGTH];
 300   membuf_t data;
 301   size_t len;
 302   const char *hashopt;
 303   unsigned char *sigbuf;
 304   size_t sigbuflen;
 305   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
 306
 307   (void)desc;
 308
 309   *r_buf = NULL;
 310
 311   switch(digestalgo)
 312     {
 313     case GCRY_MD_SHA1:  hashopt = "--hash=sha1"; break;
 314     case GCRY_MD_RMD160:hashopt = "--hash=rmd160"; break;
 315     case GCRY_MD_MD5:   hashopt = "--hash=md5"; break;
 316     case GCRY_MD_SHA256:hashopt = "--hash=sha256"; break;
 317     default:
 318       return gpg_error (GPG_ERR_DIGEST_ALGO);
 319     }
 320
 321   rc = start_agent (ctrl);
 322   if (rc)
 323     return rc;
 324
 325   if (digestlen*2 + 50 > DIM(line))
 326     return gpg_error (GPG_ERR_GENERAL);
 327
 328   p = stpcpy (line, "SCD SETDATA " );
 329   for (i=0; i < digestlen ; i++, p += 2 )
 330     sprintf (p, "%02X", digest[i]);
 331   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
 332   if (rc)
 333     return rc;
 334
 335   init_membuf (&data, 1024);
 336
 337   snprintf (line, DIM(line)-1, "SCD PKSIGN %s %s", hashopt, keyid);
 338   line[DIM(line)-1] = 0;
 339   rc = assuan_transact (agent_ctx, line,
 340                         put_membuf_cb, &data, default_inq_cb, &inq_parm,
 341                         NULL, NULL);
 342   if (rc)
 343     {
 344       xfree (get_membuf (&data, &len));
 345       return rc;
 346     }
 347   sigbuf = get_membuf (&data, &sigbuflen);
 348
 349   /* Create an S-expression from it which is formatted like this:
 350      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" Fixme: If a card ever
 351      creates non-RSA keys we need to change things. */
 352   *r_buflen = 21 + 11 + sigbuflen + 4;
 353   p = xtrymalloc (*r_buflen);
 354   *r_buf = (unsigned char*)p;
 355   if (!p)
 356     {
 357       xfree (sigbuf);
 358       return 0;
 359     }
 360   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
 361   sprintf (p, "%u:", (unsigned int)sigbuflen);
 362   p += strlen (p);
 363   memcpy (p, sigbuf, sigbuflen);
 364   p += sigbuflen;
 365   strcpy (p, ")))");
 366   xfree (sigbuf);
 367
 368   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
 369   return  0;
 370 }
 371
 372
 373
 374 \f
 375 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
 376    assuan_transact takes care of flushing and writing the end */
 377 static gpg_error_t
 378 inq_ciphertext_cb (void *opaque, const char *line)
 379 {
 380   struct cipher_parm_s *parm = opaque;
 381   int rc;
 382
 383   if (has_leading_keyword (line, "CIPHERTEXT"))
 384     {
 385       assuan_begin_confidential (parm->ctx);
 386       rc = assuan_send_data (parm->ctx, parm->ciphertext, parm->ciphertextlen);
 387       assuan_end_confidential (parm->ctx);
 388     }
 389   else
 390     {
 391       struct default_inq_parm_s inq_parm = { parm->ctrl, parm->ctx };
 392       rc = default_inq_cb (&inq_parm, line);
 393     }
 394
 395   return rc;
 396 }
 397
 398
 399 /* Call the agent to do a decrypt operation using the key identified by
 400    the hex string KEYGRIP. */
 401 int
 402 gpgsm_agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
 403                        ksba_const_sexp_t ciphertext,
 404                        char **r_buf, size_t *r_buflen )
 405 {
 406   int rc;
 407   char line[ASSUAN_LINELENGTH];
 408    membuf_t data;
 409   struct cipher_parm_s cipher_parm;
 410   size_t n, len;
 411   char *p, *buf, *endp;
 412   size_t ciphertextlen;
 413
 414   if (!keygrip || strlen(keygrip) != 40 || !ciphertext || !r_buf || !r_buflen)
 415     return gpg_error (GPG_ERR_INV_VALUE);
 416   *r_buf = NULL;
 417
 418   ciphertextlen = gcry_sexp_canon_len (ciphertext, 0, NULL, NULL);
 419   if (!ciphertextlen)
 420     return gpg_error (GPG_ERR_INV_VALUE);
 421
 422   rc = start_agent (ctrl);
 423   if (rc)
 424     return rc;
 425
 426   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
 427   if (rc)
 428     return rc;
 429
 430   assert ( DIM(line) >= 50 );
 431   snprintf (line, DIM(line)-1, "SETKEY %s", keygrip);
 432   line[DIM(line)-1] = 0;
 433   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
 434   if (rc)
 435     return rc;
 436
 437   if (desc)
 438     {
 439       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
 440       line[DIM(line)-1] = 0;
 441       rc = assuan_transact (agent_ctx, line,
 442                             NULL, NULL, NULL, NULL, NULL, NULL);
 443       if (rc)
 444         return rc;
 445     }
 446
 447   init_membuf (&data, 1024);
 448   cipher_parm.ctrl = ctrl;
 449   cipher_parm.ctx = agent_ctx;
 450   cipher_parm.ciphertext = ciphertext;
 451   cipher_parm.ciphertextlen = ciphertextlen;
 452   rc = assuan_transact (agent_ctx, "PKDECRYPT",
 453                         put_membuf_cb, &data,
 454                         inq_ciphertext_cb, &cipher_parm, NULL, NULL);
 455   if (rc)
 456     {
 457       xfree (get_membuf (&data, &len));
 458       return rc;
 459     }
 460
 461   put_membuf (&data, "", 1); /* Make sure it is 0 terminated. */
 462   buf = get_membuf (&data, &len);
 463   if (!buf)
 464     return gpg_error (GPG_ERR_ENOMEM);
 465   assert (len); /* (we forced Nul termination.)  */
 466
 467   if (*buf == '(')
 468     {
 469       if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
 470         return gpg_error (GPG_ERR_INV_SEXP);
 471       len -= 11;   /* Count only the data of the second part. */
 472       p = buf + 8; /* Skip leading parenthesis and the value tag. */
 473     }
 474   else
 475     {
 476       /* For compatibility with older gpg-agents handle the old style
 477          incomplete S-exps. */
 478       len--;      /* Do not count the Nul. */
 479       p = buf;
 480     }
 481
 482   n = strtoul (p, &endp, 10);
 483   if (!n || *endp != ':')
 484     return gpg_error (GPG_ERR_INV_SEXP);
 485   endp++;
 486   if (endp-p+n > len)
 487     return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
 488
 489   memmove (buf, endp, n);
 490
 491   *r_buflen = n;
 492   *r_buf = buf;
 493   return 0;
 494 }
 495
 496
 497
 498
 499 \f
 500 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
 501    assuan_transact takes care of flushing and writing the end */
 502 static gpg_error_t
 503 inq_genkey_parms (void *opaque, const char *line)
 504 {
 505   struct genkey_parm_s *parm = opaque;
 506   int rc;
 507
 508   if (has_leading_keyword (line, "KEYPARAM"))
 509     {
 510       rc = assuan_send_data (parm->ctx, parm->sexp, parm->sexplen);
 511     }
 512   else
 513     {
 514       struct default_inq_parm_s inq_parm = { parm->ctrl, parm->ctx };
 515       rc = default_inq_cb (&inq_parm, line);
 516     }
 517
 518   return rc;
 519 }
 520
 521
 522 \f
 523 /* Call the agent to generate a newkey */
 524 int
 525 gpgsm_agent_genkey (ctrl_t ctrl,
 526                     ksba_const_sexp_t keyparms, ksba_sexp_t *r_pubkey)
 527 {
 528   int rc;
 529   struct genkey_parm_s gk_parm;
 530   membuf_t data;
 531   size_t len;
 532   unsigned char *buf;
 533
 534   *r_pubkey = NULL;
 535   rc = start_agent (ctrl);
 536   if (rc)
 537     return rc;
 538
 539   rc = assuan_transact (agent_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
 540   if (rc)
 541     return rc;
 542
 543   init_membuf (&data, 1024);
 544   gk_parm.ctrl = ctrl;
 545   gk_parm.ctx = agent_ctx;
 546   gk_parm.sexp = keyparms;
 547   gk_parm.sexplen = gcry_sexp_canon_len (keyparms, 0, NULL, NULL);
 548   if (!gk_parm.sexplen)
 549     return gpg_error (GPG_ERR_INV_VALUE);
 550   rc = assuan_transact (agent_ctx, "GENKEY",
 551                         put_membuf_cb, &data,
 552                         inq_genkey_parms, &gk_parm, NULL, NULL);
 553   if (rc)
 554     {
 555       xfree (get_membuf (&data, &len));
 556       return rc;
 557     }
 558   buf = get_membuf (&data, &len);
 559   if (!buf)
 560     return gpg_error (GPG_ERR_ENOMEM);
 561   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
 562     {
 563       xfree (buf);
 564       return gpg_error (GPG_ERR_INV_SEXP);
 565     }
 566   *r_pubkey = buf;
 567   return 0;
 568 }
 569
 570 \f
 571 /* Call the agent to read the public key part for a given keygrip.  If
 572    FROMCARD is true, the key is directly read from the current
 573    smartcard. In this case HEXKEYGRIP should be the keyID
 574    (e.g. OPENPGP.3). */
 575 int
 576 gpgsm_agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
 577                      ksba_sexp_t *r_pubkey)
 578 {
 579   int rc;
 580   membuf_t data;
 581   size_t len;
 582   unsigned char *buf;
 583   char line[ASSUAN_LINELENGTH];
 584   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
 585
 586   *r_pubkey = NULL;
 587   rc = start_agent (ctrl);
 588   if (rc)
 589     return rc;
 590
 591   rc = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
 592   if (rc)
 593     return rc;
 594
 595   snprintf (line, DIM(line)-1, "%sREADKEY %s",
 596             fromcard? "SCD ":"", hexkeygrip);
 597   line[DIM(line)-1] = 0;
 598
 599   init_membuf (&data, 1024);
 600   rc = assuan_transact (agent_ctx, line,
 601                         put_membuf_cb, &data,
 602                         default_inq_cb, &inq_parm, NULL, NULL);
 603   if (rc)
 604     {
 605       xfree (get_membuf (&data, &len));
 606       return rc;
 607     }
 608   buf = get_membuf (&data, &len);
 609   if (!buf)
 610     return gpg_error (GPG_ERR_ENOMEM);
 611   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
 612     {
 613       xfree (buf);
 614       return gpg_error (GPG_ERR_INV_SEXP);
 615     }
 616   *r_pubkey = buf;
 617   return 0;
 618 }
 619
 620
 621 \f
 622 /* Take the serial number from LINE and return it verbatim in a newly
 623    allocated string.  We make sure that only hex characters are
 624    returned. */
 625 static char *
 626 store_serialno (const char *line)
 627 {
 628   const char *s;
 629   char *p;
 630
 631   for (s=line; hexdigitp (s); s++)
 632     ;
 633   p = xtrymalloc (s + 1 - line);
 634   if (p)
 635     {
 636       memcpy (p, line, s-line);
 637       p[s-line] = 0;
 638     }
 639   return p;
 640 }
 641
 642
 643 /* Callback for the gpgsm_agent_serialno function.  */
 644 static gpg_error_t
 645 scd_serialno_status_cb (void *opaque, const char *line)
 646 {
 647   char **r_serialno = opaque;
 648   const char *keyword = line;
 649   int keywordlen;
 650
 651   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 652     ;
 653   while (spacep (line))
 654     line++;
 655
 656   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
 657     {
 658       xfree (*r_serialno);
 659       *r_serialno = store_serialno (line);
 660     }
 661
 662   return 0;
 663 }
 664
 665
 666 /* Call the agent to read the serial number of the current card.  */
 667 int
 668 gpgsm_agent_scd_serialno (ctrl_t ctrl, char **r_serialno)
 669 {
 670   int rc;
 671   char *serialno = NULL;
 672   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
 673
 674   *r_serialno = NULL;
 675   rc = start_agent (ctrl);
 676   if (rc)
 677     return rc;
 678
 679   rc = assuan_transact (agent_ctx, "SCD SERIALNO",
 680                         NULL, NULL,
 681                         default_inq_cb, &inq_parm,
 682                         scd_serialno_status_cb, &serialno);
 683   if (!rc && !serialno)
 684     rc = gpg_error (GPG_ERR_INTERNAL);
 685   if (rc)
 686     {
 687       xfree (serialno);
 688       return rc;
 689     }
 690   *r_serialno = serialno;
 691   return 0;
 692 }
 693
 694
 695 \f
 696 /* Callback for the gpgsm_agent_serialno function.  */
 697 static gpg_error_t
 698 scd_keypairinfo_status_cb (void *opaque, const char *line)
 699 {
 700   strlist_t *listaddr = opaque;
 701   const char *keyword = line;
 702   int keywordlen;
 703   strlist_t sl;
 704   char *p;
 705
 706   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 707     ;
 708   while (spacep (line))
 709     line++;
 710
 711   if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
 712     {
 713       sl = append_to_strlist (listaddr, line);
 714       p = sl->d;
 715       /* Make sure that we only have two tokes so that future
 716          extensions of the format won't change the format expected by
 717          the caller.  */
 718       while (*p && !spacep (p))
 719         p++;
 720       if (*p)
 721         {
 722           while (spacep (p))
 723             p++;
 724           while (*p && !spacep (p))
 725             p++;
 726           *p = 0;
 727         }
 728     }
 729
 730   return 0;
 731 }
 732
 733
 734 /* Call the agent to read the keypairinfo lines of the current card.
 735    The list is returned as a string made up of the keygrip, a space
 736    and the keyid.  */
 737 int
 738 gpgsm_agent_scd_keypairinfo (ctrl_t ctrl, strlist_t *r_list)
 739 {
 740   int rc;
 741   strlist_t list = NULL;
 742   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
 743
 744   *r_list = NULL;
 745   rc = start_agent (ctrl);
 746   if (rc)
 747     return rc;
 748
 749   rc = assuan_transact (agent_ctx, "SCD LEARN --force",
 750                         NULL, NULL,
 751                         default_inq_cb, &inq_parm,
 752                         scd_keypairinfo_status_cb, &list);
 753   if (!rc && !list)
 754     rc = gpg_error (GPG_ERR_NO_DATA);
 755   if (rc)
 756     {
 757       free_strlist (list);
 758       return rc;
 759     }
 760   *r_list = list;
 761   return 0;
 762 }
 763
 764
 765 \f
 766 static gpg_error_t
 767 istrusted_status_cb (void *opaque, const char *line)
 768 {
 769   struct rootca_flags_s *flags = opaque;
 770   const char *s;
 771
 772   if ((s = has_leading_keyword (line, "TRUSTLISTFLAG")))
 773     {
 774       line = s;
 775       if (has_leading_keyword (line, "relax"))
 776         flags->relax = 1;
 777       else if (has_leading_keyword (line, "cm"))
 778         flags->chain_model = 1;
 779     }
 780   return 0;
 781 }
 782
 783
 784
 785 /* Ask the agent whether the certificate is in the list of trusted
 786    keys.  The certificate is either specified by the CERT object or by
 787    the fingerprint HEXFPR.  ROOTCA_FLAGS is guaranteed to be cleared
 788    on error. */
 789 int
 790 gpgsm_agent_istrusted (ctrl_t ctrl, ksba_cert_t cert, const char *hexfpr,
 791                        struct rootca_flags_s *rootca_flags)
 792 {
 793   int rc;
 794   char line[ASSUAN_LINELENGTH];
 795
 796   memset (rootca_flags, 0, sizeof *rootca_flags);
 797
 798   if (cert && hexfpr)
 799     return gpg_error (GPG_ERR_INV_ARG);
 800
 801   rc = start_agent (ctrl);
 802   if (rc)
 803     return rc;
 804
 805   if (hexfpr)
 806     {
 807       snprintf (line, DIM(line)-1, "ISTRUSTED %s", hexfpr);
 808       line[DIM(line)-1] = 0;
 809     }
 810   else
 811     {
 812       char *fpr;
 813
 814       fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
 815       if (!fpr)
 816         {
 817           log_error ("error getting the fingerprint\n");
 818           return gpg_error (GPG_ERR_GENERAL);
 819         }
 820
 821       snprintf (line, DIM(line)-1, "ISTRUSTED %s", fpr);
 822       line[DIM(line)-1] = 0;
 823       xfree (fpr);
 824     }
 825
 826   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
 827                         istrusted_status_cb, rootca_flags);
 828   if (!rc)
 829     rootca_flags->valid = 1;
 830   return rc;
 831 }
 832
 833 /* Ask the agent to mark CERT as a trusted Root-CA one */
 834 int
 835 gpgsm_agent_marktrusted (ctrl_t ctrl, ksba_cert_t cert)
 836 {
 837   int rc;
 838   char *fpr, *dn, *dnfmt;
 839   char line[ASSUAN_LINELENGTH];
 840   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
 841
 842   rc = start_agent (ctrl);
 843   if (rc)
 844     return rc;
 845
 846   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
 847   if (!fpr)
 848     {
 849       log_error ("error getting the fingerprint\n");
 850       return gpg_error (GPG_ERR_GENERAL);
 851     }
 852
 853   dn = ksba_cert_get_issuer (cert, 0);
 854   if (!dn)
 855     {
 856       xfree (fpr);
 857       return gpg_error (GPG_ERR_GENERAL);
 858     }
 859   dnfmt = gpgsm_format_name2 (dn, 0);
 860   xfree (dn);
 861   if (!dnfmt)
 862     return gpg_error_from_syserror ();
 863   snprintf (line, DIM(line)-1, "MARKTRUSTED %s S %s", fpr, dnfmt);
 864   line[DIM(line)-1] = 0;
 865   ksba_free (dnfmt);
 866   xfree (fpr);
 867
 868   rc = assuan_transact (agent_ctx, line, NULL, NULL,
 869                         default_inq_cb, &inq_parm, NULL, NULL);
 870   return rc;
 871 }
 872
 873
 874 \f
 875 /* Ask the agent whether the a corresponding secret key is available
 876    for the given keygrip */
 877 int
 878 gpgsm_agent_havekey (ctrl_t ctrl, const char *hexkeygrip)
 879 {
 880   int rc;
 881   char line[ASSUAN_LINELENGTH];
 882
 883   rc = start_agent (ctrl);
 884   if (rc)
 885     return rc;
 886
 887   if (!hexkeygrip || strlen (hexkeygrip) != 40)
 888     return gpg_error (GPG_ERR_INV_VALUE);
 889
 890   snprintf (line, DIM(line)-1, "HAVEKEY %s", hexkeygrip);
 891   line[DIM(line)-1] = 0;
 892
 893   rc = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
 894   return rc;
 895 }
 896
 897 \f
 898 static gpg_error_t
 899 learn_status_cb (void *opaque, const char *line)
 900 {
 901   struct learn_parm_s *parm = opaque;
 902   const char *s;
 903
 904   /* Pass progress data to the caller.  */
 905   if ((s = has_leading_keyword (line, "PROGRESS")))
 906     {
 907       line = s;
 908       if (parm->ctrl)
 909         {
 910           if (gpgsm_status (parm->ctrl, STATUS_PROGRESS, line))
 911             return gpg_error (GPG_ERR_ASS_CANCELED);
 912         }
 913     }
 914   return 0;
 915 }
 916
 917 static gpg_error_t
 918 learn_cb (void *opaque, const void *buffer, size_t length)
 919 {
 920   struct learn_parm_s *parm = opaque;
 921   size_t len;
 922   char *buf;
 923   ksba_cert_t cert;
 924   int rc;
 925
 926   if (parm->error)
 927     return 0;
 928
 929   if (buffer)
 930     {
 931       put_membuf (parm->data, buffer, length);
 932       return 0;
 933     }
 934   /* END encountered - process what we have */
 935   buf = get_membuf (parm->data, &len);
 936   if (!buf)
 937     {
 938       parm->error = gpg_error (GPG_ERR_ENOMEM);
 939       return 0;
 940     }
 941
 942   if (gpgsm_status (parm->ctrl, STATUS_PROGRESS, "learncard C 0 0"))
 943     return gpg_error (GPG_ERR_ASS_CANCELED);
 944
 945   /* FIXME: this should go into import.c */
 946   rc = ksba_cert_new (&cert);
 947   if (rc)
 948     {
 949       parm->error = rc;
 950       return 0;
 951     }
 952   rc = ksba_cert_init_from_mem (cert, buf, len);
 953   if (rc)
 954     {
 955       log_error ("failed to parse a certificate: %s\n", gpg_strerror (rc));
 956       ksba_cert_release (cert);
 957       parm->error = rc;
 958       return 0;
 959     }
 960
 961   /* We do not store a certifciate with missing issuers as ephemeral
 962      because we can assume that the --learn-card command has been used
 963      on purpose.  */
 964   rc = gpgsm_basic_cert_check (parm->ctrl, cert);
 965   if (rc && gpg_err_code (rc) != GPG_ERR_MISSING_CERT
 966       && gpg_err_code (rc) != GPG_ERR_MISSING_ISSUER_CERT)
 967     log_error ("invalid certificate: %s\n", gpg_strerror (rc));
 968   else
 969     {
 970       int existed;
 971
 972       if (!keydb_store_cert (cert, 0, &existed))
 973         {
 974           if (opt.verbose > 1 && existed)
 975             log_info ("certificate already in DB\n");
 976           else if (opt.verbose && !existed)
 977             log_info ("certificate imported\n");
 978         }
 979     }
 980
 981   ksba_cert_release (cert);
 982   init_membuf (parm->data, 4096);
 983   return 0;
 984 }
 985
 986 /* Call the agent to learn about a smartcard */
 987 int
 988 gpgsm_agent_learn (ctrl_t ctrl)
 989 {
 990   int rc;
 991   struct learn_parm_s learn_parm;
 992   membuf_t data;
 993   size_t len;
 994
 995   rc = start_agent (ctrl);
 996   if (rc)
 997     return rc;
 998
 999   rc = warn_version_mismatch (ctrl, agent_ctx, SCDAEMON_NAME, 2);
1000   if (rc)
1001     return rc;
1002
1003   init_membuf (&data, 4096);
1004   learn_parm.error = 0;
1005   learn_parm.ctrl = ctrl;
1006   learn_parm.ctx = agent_ctx;
1007   learn_parm.data = &data;
1008   rc = assuan_transact (agent_ctx, "LEARN --send",
1009                         learn_cb, &learn_parm,
1010                         NULL, NULL,
1011                         learn_status_cb, &learn_parm);
1012   xfree (get_membuf (&data, &len));
1013   if (rc)
1014     return rc;
1015   return learn_parm.error;
1016 }
1017
1018 \f
1019 /* Ask the agent to change the passphrase of the key identified by
1020    HEXKEYGRIP. If DESC is not NULL, display instead of the default
1021    description message. */
1022 int
1023 gpgsm_agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc)
1024 {
1025   int rc;
1026   char line[ASSUAN_LINELENGTH];
1027   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1028
1029   rc = start_agent (ctrl);
1030   if (rc)
1031     return rc;
1032
1033   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1034     return gpg_error (GPG_ERR_INV_VALUE);
1035
1036   if (desc)
1037     {
1038       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1039       line[DIM(line)-1] = 0;
1040       rc = assuan_transact (agent_ctx, line,
1041                             NULL, NULL, NULL, NULL, NULL, NULL);
1042       if (rc)
1043         return rc;
1044     }
1045
1046   snprintf (line, DIM(line)-1, "PASSWD %s", hexkeygrip);
1047   line[DIM(line)-1] = 0;
1048
1049   rc = assuan_transact (agent_ctx, line, NULL, NULL,
1050                         default_inq_cb, &inq_parm, NULL, NULL);
1051   return rc;
1052 }
1053
1054
1055 \f
1056 /* Ask the agent to pop up a confirmation dialog with the text DESC
1057    and an okay and cancel button.  */
1058 gpg_error_t
1059 gpgsm_agent_get_confirmation (ctrl_t ctrl, const char *desc)
1060 {
1061   int rc;
1062   char line[ASSUAN_LINELENGTH];
1063   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1064
1065   rc = start_agent (ctrl);
1066   if (rc)
1067     return rc;
1068
1069   snprintf (line, DIM(line)-1, "GET_CONFIRMATION %s", desc);
1070   line[DIM(line)-1] = 0;
1071
1072   rc = assuan_transact (agent_ctx, line, NULL, NULL,
1073                         default_inq_cb, &inq_parm, NULL, NULL);
1074   return rc;
1075 }
1076
1077
1078 \f
1079 /* Return 0 if the agent is alive.  This is useful to make sure that
1080    an agent has been started. */
1081 gpg_error_t
1082 gpgsm_agent_send_nop (ctrl_t ctrl)
1083 {
1084   int rc;
1085
1086   rc = start_agent (ctrl);
1087   if (!rc)
1088     rc = assuan_transact (agent_ctx, "NOP",
1089                           NULL, NULL, NULL, NULL, NULL, NULL);
1090   return rc;
1091 }
1092
1093
1094 \f
1095 static gpg_error_t
1096 keyinfo_status_cb (void *opaque, const char *line)
1097 {
1098   char **serialno = opaque;
1099   const char *s, *s2;
1100
1101   if ((s = has_leading_keyword (line, "KEYINFO")) && !*serialno)
1102     {
1103       s = strchr (s, ' ');
1104       if (s && s[1] == 'T' && s[2] == ' ' && s[3])
1105         {
1106           s += 3;
1107           s2 = strchr (s, ' ');
1108           if ( s2 > s )
1109             {
1110               *serialno = xtrymalloc ((s2 - s)+1);
1111               if (*serialno)
1112                 {
1113                   memcpy (*serialno, s, s2 - s);
1114                   (*serialno)[s2 - s] = 0;
1115                 }
1116             }
1117         }
1118     }
1119   return 0;
1120 }
1121
1122 /* Return the serial number for a secret key.  If the returned serial
1123    number is NULL, the key is not stored on a smartcard.  Caller needs
1124    to free R_SERIALNO.  */
1125 gpg_error_t
1126 gpgsm_agent_keyinfo (ctrl_t ctrl, const char *hexkeygrip, char **r_serialno)
1127 {
1128   gpg_error_t err;
1129   char line[ASSUAN_LINELENGTH];
1130   char *serialno = NULL;
1131
1132   *r_serialno = NULL;
1133
1134   err = start_agent (ctrl);
1135   if (err)
1136     return err;
1137
1138   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1139     return gpg_error (GPG_ERR_INV_VALUE);
1140
1141   snprintf (line, DIM(line)-1, "KEYINFO %s", hexkeygrip);
1142   line[DIM(line)-1] = 0;
1143
1144   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1145                          keyinfo_status_cb, &serialno);
1146   if (!err && serialno)
1147     {
1148       /* Sanity check for bad characters.  */
1149       if (strpbrk (serialno, ":\n\r"))
1150         err = GPG_ERR_INV_VALUE;
1151     }
1152   if (err)
1153     xfree (serialno);
1154   else
1155     *r_serialno = serialno;
1156   return err;
1157 }
1158
1159
1160 \f
1161 /* Ask for the passphrase (this is used for pkcs#12 import/export.  On
1162    success the caller needs to free the string stored at R_PASSPHRASE.
1163    On error NULL will be stored at R_PASSPHRASE and an appropriate
1164    error code returned.  If REPEAT is true the agent tries to get a
1165    new passphrase (i.e. asks the user to confirm it).  */
1166 gpg_error_t
1167 gpgsm_agent_ask_passphrase (ctrl_t ctrl, const char *desc_msg, int repeat,
1168                             char **r_passphrase)
1169 {
1170   gpg_error_t err;
1171   char line[ASSUAN_LINELENGTH];
1172   char *arg4 = NULL;
1173   membuf_t data;
1174   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1175
1176   *r_passphrase = NULL;
1177
1178   err = start_agent (ctrl);
1179   if (err)
1180     return err;
1181
1182   if (desc_msg && *desc_msg && !(arg4 = percent_plus_escape (desc_msg)))
1183     return gpg_error_from_syserror ();
1184
1185   snprintf (line, DIM(line)-1, "GET_PASSPHRASE --data%s -- X X X %s",
1186             repeat? " --repeat=1 --check --qualitybar":"",
1187             arg4);
1188   xfree (arg4);
1189
1190   init_membuf_secure (&data, 64);
1191   err = assuan_transact (agent_ctx, line,
1192                          put_membuf_cb, &data,
1193                          default_inq_cb, &inq_parm, NULL, NULL);
1194
1195   if (err)
1196     xfree (get_membuf (&data, NULL));
1197   else
1198     {
1199       put_membuf (&data, "", 1);
1200       *r_passphrase = get_membuf (&data, NULL);
1201       if (!*r_passphrase)
1202         err = gpg_error_from_syserror ();
1203     }
1204   return err;
1205 }
1206
1207
1208 \f
1209 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
1210    the key shall be use for export, with false for import.  On success
1211    the new key is stored at R_KEY and its length at R_KEKLEN.  */
1212 gpg_error_t
1213 gpgsm_agent_keywrap_key (ctrl_t ctrl, int forexport,
1214                          void **r_kek, size_t *r_keklen)
1215 {
1216   gpg_error_t err;
1217   membuf_t data;
1218   size_t len;
1219   unsigned char *buf;
1220   char line[ASSUAN_LINELENGTH];
1221   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1222
1223   *r_kek = NULL;
1224   err = start_agent (ctrl);
1225   if (err)
1226     return err;
1227
1228   snprintf (line, DIM(line)-1, "KEYWRAP_KEY %s",
1229             forexport? "--export":"--import");
1230
1231   init_membuf_secure (&data, 64);
1232   err = assuan_transact (agent_ctx, line,
1233                          put_membuf_cb, &data,
1234                          default_inq_cb, &inq_parm, NULL, NULL);
1235   if (err)
1236     {
1237       xfree (get_membuf (&data, &len));
1238       return err;
1239     }
1240   buf = get_membuf (&data, &len);
1241   if (!buf)
1242     return gpg_error_from_syserror ();
1243   *r_kek = buf;
1244   *r_keklen = len;
1245   return 0;
1246 }
1247
1248
1249
1250 \f
1251 /* Handle the inquiry for an IMPORT_KEY command.  */
1252 static gpg_error_t
1253 inq_import_key_parms (void *opaque, const char *line)
1254 {
1255   struct import_key_parm_s *parm = opaque;
1256   gpg_error_t err;
1257
1258   if (has_leading_keyword (line, "KEYDATA"))
1259     {
1260       assuan_begin_confidential (parm->ctx);
1261       err = assuan_send_data (parm->ctx, parm->key, parm->keylen);
1262       assuan_end_confidential (parm->ctx);
1263     }
1264   else
1265     {
1266       struct default_inq_parm_s inq_parm = { parm->ctrl, parm->ctx };
1267       err = default_inq_cb (&inq_parm, line);
1268     }
1269
1270   return err;
1271 }
1272
1273
1274 /* Call the agent to import a key into the agent.  */
1275 gpg_error_t
1276 gpgsm_agent_import_key (ctrl_t ctrl, const void *key, size_t keylen)
1277 {
1278   gpg_error_t err;
1279   struct import_key_parm_s parm;
1280
1281   err = start_agent (ctrl);
1282   if (err)
1283     return err;
1284
1285   parm.ctrl   = ctrl;
1286   parm.ctx    = agent_ctx;
1287   parm.key    = key;
1288   parm.keylen = keylen;
1289
1290   err = assuan_transact (agent_ctx, "IMPORT_KEY",
1291                          NULL, NULL, inq_import_key_parms, &parm, NULL, NULL);
1292   return err;
1293 }
1294
1295
1296 \f
1297 /* Receive a secret key from the agent.  KEYGRIP is the hexified
1298    keygrip, DESC a prompt to be displayed with the agent's passphrase
1299    question (needs to be plus+percent escaped).  On success the key is
1300    stored as a canonical S-expression at R_RESULT and R_RESULTLEN. */
1301 gpg_error_t
1302 gpgsm_agent_export_key (ctrl_t ctrl, const char *keygrip, const char *desc,
1303                         unsigned char **r_result, size_t *r_resultlen)
1304 {
1305   gpg_error_t err;
1306   membuf_t data;
1307   size_t len;
1308   unsigned char *buf;
1309   char line[ASSUAN_LINELENGTH];
1310   struct default_inq_parm_s inq_parm = { ctrl, agent_ctx };
1311
1312   *r_result = NULL;
1313
1314   err = start_agent (ctrl);
1315   if (err)
1316     return err;
1317
1318   if (desc)
1319     {
1320       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1321       err = assuan_transact (agent_ctx, line,
1322                              NULL, NULL, NULL, NULL, NULL, NULL);
1323       if (err)
1324         return err;
1325     }
1326
1327   snprintf (line, DIM(line)-1, "EXPORT_KEY %s", keygrip);
1328
1329   init_membuf_secure (&data, 1024);
1330   err = assuan_transact (agent_ctx, line,
1331                          put_membuf_cb, &data,
1332                          default_inq_cb, &inq_parm, NULL, NULL);
1333   if (err)
1334     {
1335       xfree (get_membuf (&data, &len));
1336       return err;
1337     }
1338   buf = get_membuf (&data, &len);
1339   if (!buf)
1340     return gpg_error_from_syserror ();
1341   *r_result = buf;
1342   *r_resultlen = len;
1343   return 0;
1344 }