g10/call-agent.c

   1 /* call-agent.c - Divert GPG operations to the agent.
   2  * Copyright (C) 2001-2003, 2006-2011, 2013 Free Software Foundation, Inc.
   3  * Copyright (C) 2013-2015  Werner Koch
   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 <https://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 #ifdef HAVE_LOCALE_H
  29 #include <locale.h>
  30 #endif
  31
  32 #include "gpg.h"
  33 #include <assuan.h>
  34 #include "../common/util.h"
  35 #include "../common/membuf.h"
  36 #include "options.h"
  37 #include "../common/i18n.h"
  38 #include "../common/asshelp.h"
  39 #include "../common/sysutils.h"
  40 #include "call-agent.h"
  41 #include "../common/status.h"
  42 #include "../common/shareddefs.h"
  43 #include "../common/host2net.h"
  44
  45 #define CONTROL_D ('D' - 'A' + 1)
  46
  47
  48 static assuan_context_t agent_ctx = NULL;
  49 static int did_early_card_test;
  50
  51 struct default_inq_parm_s
  52 {
  53   ctrl_t ctrl;
  54   assuan_context_t ctx;
  55   struct {
  56     u32 *keyid;
  57     u32 *mainkeyid;
  58     int pubkey_algo;
  59   } keyinfo;
  60 };
  61
  62 struct cipher_parm_s
  63 {
  64   struct default_inq_parm_s *dflt;
  65   assuan_context_t ctx;
  66   unsigned char *ciphertext;
  67   size_t ciphertextlen;
  68 };
  69
  70 struct writecert_parm_s
  71 {
  72   struct default_inq_parm_s *dflt;
  73   const unsigned char *certdata;
  74   size_t certdatalen;
  75 };
  76
  77 struct writekey_parm_s
  78 {
  79   struct default_inq_parm_s *dflt;
  80   const unsigned char *keydata;
  81   size_t keydatalen;
  82 };
  83
  84 struct genkey_parm_s
  85 {
  86   struct default_inq_parm_s *dflt;
  87   const char *keyparms;
  88   const char *passphrase;
  89 };
  90
  91 struct import_key_parm_s
  92 {
  93   struct default_inq_parm_s *dflt;
  94   const void *key;
  95   size_t keylen;
  96 };
  97
  98
  99 struct cache_nonce_parm_s
 100 {
 101   char **cache_nonce_addr;
 102   char **passwd_nonce_addr;
 103 };
 104
 105
 106 static gpg_error_t learn_status_cb (void *opaque, const char *line);
 107
 108
 109 \f
 110 /* If RC is not 0, write an appropriate status message. */
 111 static void
 112 status_sc_op_failure (int rc)
 113 {
 114   switch (gpg_err_code (rc))
 115     {
 116     case 0:
 117       break;
 118     case GPG_ERR_CANCELED:
 119     case GPG_ERR_FULLY_CANCELED:
 120       write_status_text (STATUS_SC_OP_FAILURE, "1");
 121       break;
 122     case GPG_ERR_BAD_PIN:
 123       write_status_text (STATUS_SC_OP_FAILURE, "2");
 124       break;
 125     default:
 126       write_status (STATUS_SC_OP_FAILURE);
 127       break;
 128     }
 129 }
 130
 131
 132 /* This is the default inquiry callback.  It mainly handles the
 133    Pinentry notifications.  */
 134 static gpg_error_t
 135 default_inq_cb (void *opaque, const char *line)
 136 {
 137   gpg_error_t err = 0;
 138   struct default_inq_parm_s *parm = opaque;
 139
 140   if (has_leading_keyword (line, "PINENTRY_LAUNCHED"))
 141     {
 142       err = gpg_proxy_pinentry_notify (parm->ctrl, line);
 143       if (err)
 144         log_error (_("failed to proxy %s inquiry to client\n"),
 145                    "PINENTRY_LAUNCHED");
 146       /* We do not pass errors to avoid breaking other code.  */
 147     }
 148   else if ((has_leading_keyword (line, "PASSPHRASE")
 149             || has_leading_keyword (line, "NEW_PASSPHRASE"))
 150            && opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
 151     {
 152       if (have_static_passphrase ())
 153         {
 154           const char *s = get_static_passphrase ();
 155           err = assuan_send_data (parm->ctx, s, strlen (s));
 156         }
 157       else
 158         {
 159           char *pw;
 160           char buf[32];
 161
 162           if (parm->keyinfo.keyid)
 163             emit_status_need_passphrase (parm->ctrl,
 164                                          parm->keyinfo.keyid,
 165                                          parm->keyinfo.mainkeyid,
 166                                          parm->keyinfo.pubkey_algo);
 167
 168           snprintf (buf, sizeof (buf), "%u", 100);
 169           write_status_text (STATUS_INQUIRE_MAXLEN, buf);
 170           pw = cpr_get_hidden ("passphrase.enter", _("Enter passphrase: "));
 171           cpr_kill_prompt ();
 172           if (*pw == CONTROL_D && !pw[1])
 173             err = gpg_error (GPG_ERR_CANCELED);
 174           else
 175             err = assuan_send_data (parm->ctx, pw, strlen (pw));
 176           xfree (pw);
 177         }
 178     }
 179   else
 180     log_debug ("ignoring gpg-agent inquiry '%s'\n", line);
 181
 182   return err;
 183 }
 184
 185
 186 /* Print a warning if the server's version number is less than our
 187    version number.  Returns an error code on a connection problem.  */
 188 static gpg_error_t
 189 warn_version_mismatch (assuan_context_t ctx, const char *servername, int mode)
 190 {
 191   gpg_error_t err;
 192   char *serverversion;
 193   const char *myversion = strusage (13);
 194
 195   err = get_assuan_server_version (ctx, mode, &serverversion);
 196   if (err)
 197     log_log (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED?
 198              GPGRT_LOGLVL_INFO : GPGRT_LOGLVL_ERROR,
 199              _("error getting version from '%s': %s\n"),
 200              servername, gpg_strerror (err));
 201   else if (compare_version_strings (serverversion, myversion) < 0)
 202     {
 203       char *warn;
 204
 205       warn = xtryasprintf (_("server '%s' is older than us (%s < %s)"),
 206                            servername, serverversion, myversion);
 207       if (!warn)
 208         err = gpg_error_from_syserror ();
 209       else
 210         {
 211           log_info (_("WARNING: %s\n"), warn);
 212           if (!opt.quiet)
 213             {
 214               log_info (_("Note: Outdated servers may lack important"
 215                           " security fixes.\n"));
 216               log_info (_("Note: Use the command \"%s\" to restart them.\n"),
 217                         "gpgconf --kill all");
 218             }
 219           write_status_strings (STATUS_WARNING, "server_version_mismatch 0",
 220                                 " ", warn, NULL);
 221           xfree (warn);
 222         }
 223     }
 224   xfree (serverversion);
 225   return err;
 226 }
 227
 228
 229 #define FLAG_FOR_CARD_SUPPRESS_ERRORS 2
 230
 231 /* Try to connect to the agent via socket or fork it off and work by
 232    pipes.  Handle the server's initial greeting */
 233 static int
 234 start_agent (ctrl_t ctrl, int flag_for_card)
 235 {
 236   int rc;
 237
 238   (void)ctrl;  /* Not yet used.  */
 239
 240   /* Fixme: We need a context for each thread or serialize the access
 241      to the agent. */
 242   if (agent_ctx)
 243     rc = 0;
 244   else
 245     {
 246       rc = start_new_gpg_agent (&agent_ctx,
 247                                 GPG_ERR_SOURCE_DEFAULT,
 248                                 opt.agent_program,
 249                                 opt.lc_ctype, opt.lc_messages,
 250                                 opt.session_env,
 251                                 opt.autostart, opt.verbose, DBG_IPC,
 252                                 NULL, NULL);
 253       if (!opt.autostart && gpg_err_code (rc) == GPG_ERR_NO_AGENT)
 254         {
 255           static int shown;
 256
 257           if (!shown)
 258             {
 259               shown = 1;
 260               log_info (_("no gpg-agent running in this session\n"));
 261             }
 262         }
 263       else if (!rc
 264                && !(rc = warn_version_mismatch (agent_ctx, GPG_AGENT_NAME, 0)))
 265         {
 266           /* Tell the agent that we support Pinentry notifications.
 267              No error checking so that it will work also with older
 268              agents.  */
 269           assuan_transact (agent_ctx, "OPTION allow-pinentry-notify",
 270                            NULL, NULL, NULL, NULL, NULL, NULL);
 271           /* Tell the agent about what version we are aware.  This is
 272              here used to indirectly enable GPG_ERR_FULLY_CANCELED.  */
 273           assuan_transact (agent_ctx, "OPTION agent-awareness=2.1.0",
 274                            NULL, NULL, NULL, NULL, NULL, NULL);
 275           /* Pass on the pinentry mode.  */
 276           if (opt.pinentry_mode)
 277             {
 278               char *tmp = xasprintf ("OPTION pinentry-mode=%s",
 279                                      str_pinentry_mode (opt.pinentry_mode));
 280               rc = assuan_transact (agent_ctx, tmp,
 281                                NULL, NULL, NULL, NULL, NULL, NULL);
 282               xfree (tmp);
 283               if (rc)
 284                 {
 285                   log_error ("setting pinentry mode '%s' failed: %s\n",
 286                              str_pinentry_mode (opt.pinentry_mode),
 287                              gpg_strerror (rc));
 288                   write_status_error ("set_pinentry_mode", rc);
 289                 }
 290             }
 291
 292           /* Pass on the request origin.  */
 293           if (opt.request_origin)
 294             {
 295               char *tmp = xasprintf ("OPTION pretend-request-origin=%s",
 296                                      str_request_origin (opt.request_origin));
 297               rc = assuan_transact (agent_ctx, tmp,
 298                                NULL, NULL, NULL, NULL, NULL, NULL);
 299               xfree (tmp);
 300               if (rc)
 301                 {
 302                   log_error ("setting request origin '%s' failed: %s\n",
 303                              str_request_origin (opt.request_origin),
 304                              gpg_strerror (rc));
 305                   write_status_error ("set_request_origin", rc);
 306                 }
 307             }
 308
 309           /* In DE_VS mode under Windows we require that the JENT RNG
 310            * is active.  */
 311 #ifdef HAVE_W32_SYSTEM
 312           if (!rc && opt.compliance == CO_DE_VS)
 313             {
 314               if (assuan_transact (agent_ctx, "GETINFO jent_active",
 315                                    NULL, NULL, NULL, NULL, NULL, NULL))
 316                 {
 317                   rc = gpg_error (GPG_ERR_FORBIDDEN);
 318                   log_error (_("%s is not compliant with %s mode\n"),
 319                              GPG_AGENT_NAME,
 320                              gnupg_compliance_option_string (opt.compliance));
 321                   write_status_error ("random-compliance", rc);
 322                 }
 323             }
 324 #endif /*HAVE_W32_SYSTEM*/
 325
 326         }
 327     }
 328
 329   if (!rc && flag_for_card && !did_early_card_test)
 330     {
 331       /* Request the serial number of the card for an early test.  */
 332       struct agent_card_info_s info;
 333
 334       memset (&info, 0, sizeof info);
 335
 336       if (!(flag_for_card & FLAG_FOR_CARD_SUPPRESS_ERRORS))
 337         rc = warn_version_mismatch (agent_ctx, SCDAEMON_NAME, 2);
 338       if (!rc)
 339         rc = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
 340                               NULL, NULL, NULL, NULL,
 341                               learn_status_cb, &info);
 342       if (rc && !(flag_for_card & FLAG_FOR_CARD_SUPPRESS_ERRORS))
 343         {
 344           switch (gpg_err_code (rc))
 345             {
 346             case GPG_ERR_NOT_SUPPORTED:
 347             case GPG_ERR_NO_SCDAEMON:
 348               write_status_text (STATUS_CARDCTRL, "6");
 349               break;
 350             case GPG_ERR_OBJ_TERM_STATE:
 351               write_status_text (STATUS_CARDCTRL, "7");
 352               break;
 353             default:
 354               write_status_text (STATUS_CARDCTRL, "4");
 355               log_info ("selecting openpgp failed: %s\n", gpg_strerror (rc));
 356               break;
 357             }
 358         }
 359
 360       if (!rc && is_status_enabled () && info.serialno)
 361         {
 362           char *buf;
 363
 364           buf = xasprintf ("3 %s", info.serialno);
 365           write_status_text (STATUS_CARDCTRL, buf);
 366           xfree (buf);
 367         }
 368
 369       agent_release_card_info (&info);
 370
 371       if (!rc)
 372         did_early_card_test = 1;
 373     }
 374
 375
 376   return rc;
 377 }
 378
 379
 380 /* Return a new malloced string by unescaping the string S.  Escaping
 381    is percent escaping and '+'/space mapping.  A binary nul will
 382    silently be replaced by a 0xFF.  Function returns NULL to indicate
 383    an out of memory status. */
 384 static char *
 385 unescape_status_string (const unsigned char *s)
 386 {
 387   return percent_plus_unescape (s, 0xff);
 388 }
 389
 390
 391 /* Take a 20 or 32 byte hexencoded string and put it into the provided
 392  * FPRLEN byte long buffer FPR in binary format.  Returns the actual
 393  * used length of the FPR buffer or 0 on error.  */
 394 static unsigned int
 395 unhexify_fpr (const char *hexstr, unsigned char *fpr, unsigned int fprlen)
 396 {
 397   const char *s;
 398   int n;
 399
 400   for (s=hexstr, n=0; hexdigitp (s); s++, n++)
 401     ;
 402   if ((*s && *s != ' ') || !(n == 40 || n == 64))
 403     return 0; /* no fingerprint (invalid or wrong length). */
 404   for (s=hexstr, n=0; *s && n < fprlen; s += 2, n++)
 405     fpr[n] = xtoi_2 (s);
 406
 407   return (n == 20 || n == 32)? n : 0;
 408 }
 409
 410 /* Take the serial number from LINE and return it verbatim in a newly
 411    allocated string.  We make sure that only hex characters are
 412    returned. */
 413 static char *
 414 store_serialno (const char *line)
 415 {
 416   const char *s;
 417   char *p;
 418
 419   for (s=line; hexdigitp (s); s++)
 420     ;
 421   p = xtrymalloc (s + 1 - line);
 422   if (p)
 423     {
 424       memcpy (p, line, s-line);
 425       p[s-line] = 0;
 426     }
 427   return p;
 428 }
 429
 430
 431 \f
 432 /* This is a dummy data line callback.  */
 433 static gpg_error_t
 434 dummy_data_cb (void *opaque, const void *buffer, size_t length)
 435 {
 436   (void)opaque;
 437   (void)buffer;
 438   (void)length;
 439   return 0;
 440 }
 441
 442 /* A simple callback used to return the serialnumber of a card.  */
 443 static gpg_error_t
 444 get_serialno_cb (void *opaque, const char *line)
 445 {
 446   char **serialno = opaque;
 447   const char *keyword = line;
 448   const char *s;
 449   int keywordlen, n;
 450
 451   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 452     ;
 453   while (spacep (line))
 454     line++;
 455
 456   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
 457     {
 458       if (*serialno)
 459         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
 460       for (n=0,s=line; hexdigitp (s); s++, n++)
 461         ;
 462       if (!n || (n&1)|| !(spacep (s) || !*s) )
 463         return gpg_error (GPG_ERR_ASS_PARAMETER);
 464       *serialno = xtrymalloc (n+1);
 465       if (!*serialno)
 466         return out_of_core ();
 467       memcpy (*serialno, line, n);
 468       (*serialno)[n] = 0;
 469     }
 470
 471   return 0;
 472 }
 473
 474
 475
 476 /* Release the card info structure INFO. */
 477 void
 478 agent_release_card_info (struct agent_card_info_s *info)
 479 {
 480   int i;
 481
 482   if (!info)
 483     return;
 484
 485   xfree (info->reader); info->reader = NULL;
 486   xfree (info->serialno); info->serialno = NULL;
 487   xfree (info->apptype); info->apptype = NULL;
 488   xfree (info->disp_name); info->disp_name = NULL;
 489   xfree (info->disp_lang); info->disp_lang = NULL;
 490   xfree (info->pubkey_url); info->pubkey_url = NULL;
 491   xfree (info->login_data); info->login_data = NULL;
 492   info->cafpr1len = info->cafpr2len = info->cafpr3len = 0;
 493   info->fpr1len = info->fpr2len = info->fpr3len = 0;
 494   for (i=0; i < DIM(info->private_do); i++)
 495     {
 496       xfree (info->private_do[i]);
 497       info->private_do[i] = NULL;
 498     }
 499 }
 500
 501
 502 static gpg_error_t
 503 learn_status_cb (void *opaque, const char *line)
 504 {
 505   struct agent_card_info_s *parm = opaque;
 506   const char *keyword = line;
 507   int keywordlen;
 508   int i;
 509
 510   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 511     ;
 512   while (spacep (line))
 513     line++;
 514
 515   if (keywordlen == 6 && !memcmp (keyword, "READER", keywordlen))
 516     {
 517       xfree (parm->reader);
 518       parm->reader = unescape_status_string (line);
 519     }
 520   else if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
 521     {
 522       xfree (parm->serialno);
 523       parm->serialno = store_serialno (line);
 524       parm->is_v2 = (strlen (parm->serialno) >= 16
 525                      && xtoi_2 (parm->serialno+12) >= 2 );
 526     }
 527   else if (keywordlen == 7 && !memcmp (keyword, "APPTYPE", keywordlen))
 528     {
 529       xfree (parm->apptype);
 530       parm->apptype = unescape_status_string (line);
 531     }
 532   else if (keywordlen == 9 && !memcmp (keyword, "DISP-NAME", keywordlen))
 533     {
 534       xfree (parm->disp_name);
 535       parm->disp_name = unescape_status_string (line);
 536     }
 537   else if (keywordlen == 9 && !memcmp (keyword, "DISP-LANG", keywordlen))
 538     {
 539       xfree (parm->disp_lang);
 540       parm->disp_lang = unescape_status_string (line);
 541     }
 542   else if (keywordlen == 8 && !memcmp (keyword, "DISP-SEX", keywordlen))
 543     {
 544       parm->disp_sex = *line == '1'? 1 : *line == '2' ? 2: 0;
 545     }
 546   else if (keywordlen == 10 && !memcmp (keyword, "PUBKEY-URL", keywordlen))
 547     {
 548       xfree (parm->pubkey_url);
 549       parm->pubkey_url = unescape_status_string (line);
 550     }
 551   else if (keywordlen == 10 && !memcmp (keyword, "LOGIN-DATA", keywordlen))
 552     {
 553       xfree (parm->login_data);
 554       parm->login_data = unescape_status_string (line);
 555     }
 556   else if (keywordlen == 11 && !memcmp (keyword, "SIG-COUNTER", keywordlen))
 557     {
 558       parm->sig_counter = strtoul (line, NULL, 0);
 559     }
 560   else if (keywordlen == 10 && !memcmp (keyword, "CHV-STATUS", keywordlen))
 561     {
 562       char *p, *buf;
 563
 564       buf = p = unescape_status_string (line);
 565       if (buf)
 566         {
 567           while (spacep (p))
 568             p++;
 569           parm->chv1_cached = atoi (p);
 570           while (*p && !spacep (p))
 571             p++;
 572           while (spacep (p))
 573             p++;
 574           for (i=0; *p && i < 3; i++)
 575             {
 576               parm->chvmaxlen[i] = atoi (p);
 577               while (*p && !spacep (p))
 578                 p++;
 579               while (spacep (p))
 580                 p++;
 581             }
 582           for (i=0; *p && i < 3; i++)
 583             {
 584               parm->chvretry[i] = atoi (p);
 585               while (*p && !spacep (p))
 586                 p++;
 587               while (spacep (p))
 588                 p++;
 589             }
 590           xfree (buf);
 591         }
 592     }
 593   else if (keywordlen == 6 && !memcmp (keyword, "EXTCAP", keywordlen))
 594     {
 595       char *p, *p2, *buf;
 596       int abool;
 597
 598       buf = p = unescape_status_string (line);
 599       if (buf)
 600         {
 601           for (p = strtok (buf, " "); p; p = strtok (NULL, " "))
 602             {
 603               p2 = strchr (p, '=');
 604               if (p2)
 605                 {
 606                   *p2++ = 0;
 607                   abool = (*p2 == '1');
 608                   if (!strcmp (p, "ki"))
 609                     parm->extcap.ki = abool;
 610                   else if (!strcmp (p, "aac"))
 611                     parm->extcap.aac = abool;
 612                   else if (!strcmp (p, "bt"))
 613                     parm->extcap.bt = abool;
 614                   else if (!strcmp (p, "kdf"))
 615                     parm->extcap.kdf = abool;
 616                   else if (!strcmp (p, "si"))
 617                     parm->status_indicator = strtoul (p2, NULL, 10);
 618                 }
 619             }
 620           xfree (buf);
 621         }
 622     }
 623   else if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
 624     {
 625       int no = atoi (line);
 626       while (*line && !spacep (line))
 627         line++;
 628       while (spacep (line))
 629         line++;
 630       if (no == 1)
 631         parm->fpr1len = unhexify_fpr (line, parm->fpr1, sizeof parm->fpr1);
 632       else if (no == 2)
 633         parm->fpr2len = unhexify_fpr (line, parm->fpr2, sizeof parm->fpr2);
 634       else if (no == 3)
 635         parm->fpr3len = unhexify_fpr (line, parm->fpr3, sizeof parm->fpr3);
 636     }
 637   else if (keywordlen == 8 && !memcmp (keyword, "KEY-TIME", keywordlen))
 638     {
 639       int no = atoi (line);
 640       while (* line && !spacep (line))
 641         line++;
 642       while (spacep (line))
 643         line++;
 644       if (no == 1)
 645         parm->fpr1time = strtoul (line, NULL, 10);
 646       else if (no == 2)
 647         parm->fpr2time = strtoul (line, NULL, 10);
 648       else if (no == 3)
 649         parm->fpr3time = strtoul (line, NULL, 10);
 650     }
 651   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
 652     {
 653       const char *hexgrp = line;
 654       int no;
 655
 656       while (*line && !spacep (line))
 657         line++;
 658       while (spacep (line))
 659         line++;
 660       if (strncmp (line, "OPENPGP.", 8))
 661         ;
 662       else if ((no = atoi (line+8)) == 1)
 663         unhexify_fpr (hexgrp, parm->grp1, sizeof parm->grp1);
 664       else if (no == 2)
 665         unhexify_fpr (hexgrp, parm->grp2, sizeof parm->grp2);
 666       else if (no == 3)
 667         unhexify_fpr (hexgrp, parm->grp3, sizeof parm->grp3);
 668     }
 669   else if (keywordlen == 6 && !memcmp (keyword, "CA-FPR", keywordlen))
 670     {
 671       int no = atoi (line);
 672       while (*line && !spacep (line))
 673         line++;
 674       while (spacep (line))
 675         line++;
 676       if (no == 1)
 677         parm->cafpr1len = unhexify_fpr (line, parm->cafpr1,sizeof parm->cafpr1);
 678       else if (no == 2)
 679         parm->cafpr2len = unhexify_fpr (line, parm->cafpr2,sizeof parm->cafpr2);
 680       else if (no == 3)
 681         parm->cafpr3len = unhexify_fpr (line, parm->cafpr3,sizeof parm->cafpr3);
 682     }
 683   else if (keywordlen == 8 && !memcmp (keyword, "KEY-ATTR", keywordlen))
 684     {
 685       int keyno = 0;
 686       int algo = PUBKEY_ALGO_RSA;
 687       int n = 0;
 688
 689       sscanf (line, "%d %d %n", &keyno, &algo, &n);
 690       keyno--;
 691       if (keyno < 0 || keyno >= DIM (parm->key_attr))
 692         return 0;
 693
 694       parm->key_attr[keyno].algo = algo;
 695       if (algo == PUBKEY_ALGO_RSA)
 696         parm->key_attr[keyno].nbits = strtoul (line+n+3, NULL, 10);
 697       else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
 698                || algo == PUBKEY_ALGO_EDDSA)
 699         parm->key_attr[keyno].curve = openpgp_is_curve_supported (line + n,
 700                                                                   NULL, NULL);
 701     }
 702   else if (keywordlen == 12 && !memcmp (keyword, "PRIVATE-DO-", 11)
 703            && strchr("1234", keyword[11]))
 704     {
 705       int no = keyword[11] - '1';
 706       log_assert (no >= 0 && no <= 3);
 707       xfree (parm->private_do[no]);
 708       parm->private_do[no] = unescape_status_string (line);
 709     }
 710
 711   return 0;
 712 }
 713
 714 /* Call the scdaemon to learn about a smartcard */
 715 int
 716 agent_scd_learn (struct agent_card_info_s *info, int force)
 717 {
 718   int rc;
 719   struct default_inq_parm_s parm;
 720   struct agent_card_info_s dummyinfo;
 721
 722   if (!info)
 723     info = &dummyinfo;
 724   memset (info, 0, sizeof *info);
 725   memset (&parm, 0, sizeof parm);
 726
 727   rc = start_agent (NULL, 1);
 728   if (rc)
 729     return rc;
 730
 731   parm.ctx = agent_ctx;
 732   rc = assuan_transact (agent_ctx,
 733                         force ? "LEARN --sendinfo --force" : "LEARN --sendinfo",
 734                         dummy_data_cb, NULL, default_inq_cb, &parm,
 735                         learn_status_cb, info);
 736   /* Also try to get the key attributes.  */
 737   if (!rc)
 738     agent_scd_getattr ("KEY-ATTR", info);
 739
 740   if (info == &dummyinfo)
 741     agent_release_card_info (info);
 742
 743   return rc;
 744 }
 745
 746
 747 /* Send an APDU to the current card.  On success the status word is
 748    stored at R_SW.  With HEXAPDU being NULL only a RESET command is
 749    send to scd.  With HEXAPDU being the string "undefined" the command
 750    "SERIALNO undefined" is send to scd. */
 751 gpg_error_t
 752 agent_scd_apdu (const char *hexapdu, unsigned int *r_sw)
 753 {
 754   gpg_error_t err;
 755
 756   /* Start the agent but not with the card flag so that we do not
 757      autoselect the openpgp application.  */
 758   err = start_agent (NULL, 0);
 759   if (err)
 760     return err;
 761
 762   if (!hexapdu)
 763     {
 764       err = assuan_transact (agent_ctx, "SCD RESET",
 765                              NULL, NULL, NULL, NULL, NULL, NULL);
 766
 767     }
 768   else if (!strcmp (hexapdu, "undefined"))
 769     {
 770       err = assuan_transact (agent_ctx, "SCD SERIALNO undefined",
 771                              NULL, NULL, NULL, NULL, NULL, NULL);
 772     }
 773   else
 774     {
 775       char line[ASSUAN_LINELENGTH];
 776       membuf_t mb;
 777       unsigned char *data;
 778       size_t datalen;
 779
 780       init_membuf (&mb, 256);
 781
 782       snprintf (line, DIM(line), "SCD APDU %s", hexapdu);
 783       err = assuan_transact (agent_ctx, line,
 784                              put_membuf_cb, &mb, NULL, NULL, NULL, NULL);
 785       if (!err)
 786         {
 787           data = get_membuf (&mb, &datalen);
 788           if (!data)
 789             err = gpg_error_from_syserror ();
 790           else if (datalen < 2) /* Ooops */
 791             err = gpg_error (GPG_ERR_CARD);
 792           else
 793             {
 794               *r_sw = buf16_to_uint (data+datalen-2);
 795             }
 796           xfree (data);
 797         }
 798     }
 799
 800   return err;
 801 }
 802
 803
 804 int
 805 agent_keytocard (const char *hexgrip, int keyno, int force,
 806                  const char *serialno, const char *timestamp)
 807 {
 808   int rc;
 809   char line[ASSUAN_LINELENGTH];
 810   struct default_inq_parm_s parm;
 811
 812   memset (&parm, 0, sizeof parm);
 813
 814   snprintf (line, DIM(line), "KEYTOCARD %s%s %s OPENPGP.%d %s",
 815             force?"--force ": "", hexgrip, serialno, keyno, timestamp);
 816
 817   rc = start_agent (NULL, 1);
 818   if (rc)
 819     return rc;
 820   parm.ctx = agent_ctx;
 821
 822   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
 823                         NULL, NULL);
 824   if (rc)
 825     return rc;
 826
 827   return rc;
 828 }
 829
 830
 831 \f
 832 /* Call the agent to retrieve a data object.  This function returns
 833    the data in the same structure as used by the learn command.  It is
 834    allowed to update such a structure using this command. */
 835 int
 836 agent_scd_getattr (const char *name, struct agent_card_info_s *info)
 837 {
 838   int rc;
 839   char line[ASSUAN_LINELENGTH];
 840   struct default_inq_parm_s parm;
 841
 842   memset (&parm, 0, sizeof parm);
 843
 844   if (!*name)
 845     return gpg_error (GPG_ERR_INV_VALUE);
 846
 847   /* We assume that NAME does not need escaping. */
 848   if (12 + strlen (name) > DIM(line)-1)
 849     return gpg_error (GPG_ERR_TOO_LARGE);
 850   stpcpy (stpcpy (line, "SCD GETATTR "), name);
 851
 852   rc = start_agent (NULL, 1);
 853   if (rc)
 854     return rc;
 855
 856   parm.ctx = agent_ctx;
 857   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
 858                         learn_status_cb, info);
 859
 860   return rc;
 861 }
 862
 863 \f
 864 /* Send an setattr command to the SCdaemon.  SERIALNO is not actually
 865    used here but required by gpg 1.4's implementation of this code in
 866    cardglue.c. */
 867 int
 868 agent_scd_setattr (const char *name,
 869                    const unsigned char *value, size_t valuelen,
 870                    const char *serialno)
 871 {
 872   int rc;
 873   char line[ASSUAN_LINELENGTH];
 874   char *p;
 875   struct default_inq_parm_s parm;
 876
 877   memset (&parm, 0, sizeof parm);
 878
 879   (void)serialno;
 880
 881   if (!*name || !valuelen)
 882     return gpg_error (GPG_ERR_INV_VALUE);
 883
 884   /* We assume that NAME does not need escaping. */
 885   if (12 + strlen (name) > DIM(line)-1)
 886     return gpg_error (GPG_ERR_TOO_LARGE);
 887
 888   p = stpcpy (stpcpy (line, "SCD SETATTR "), name);
 889   *p++ = ' ';
 890   for (; valuelen; value++, valuelen--)
 891     {
 892       if (p >= line + DIM(line)-5 )
 893         return gpg_error (GPG_ERR_TOO_LARGE);
 894       if (*value < ' ' || *value == '+' || *value == '%')
 895         {
 896           sprintf (p, "%%%02X", *value);
 897           p += 3;
 898         }
 899       else if (*value == ' ')
 900         *p++ = '+';
 901       else
 902         *p++ = *value;
 903     }
 904   *p = 0;
 905
 906   rc = start_agent (NULL, 1);
 907   if (!rc)
 908     {
 909       parm.ctx = agent_ctx;
 910       rc = assuan_transact (agent_ctx, line, NULL, NULL,
 911                             default_inq_cb, &parm, NULL, NULL);
 912     }
 913
 914   status_sc_op_failure (rc);
 915   return rc;
 916 }
 917
 918
 919 \f
 920 /* Handle a CERTDATA inquiry.  Note, we only send the data,
 921    assuan_transact takes care of flushing and writing the END
 922    command. */
 923 static gpg_error_t
 924 inq_writecert_parms (void *opaque, const char *line)
 925 {
 926   int rc;
 927   struct writecert_parm_s *parm = opaque;
 928
 929   if (has_leading_keyword (line, "CERTDATA"))
 930     {
 931       rc = assuan_send_data (parm->dflt->ctx,
 932                              parm->certdata, parm->certdatalen);
 933     }
 934   else
 935     rc = default_inq_cb (parm->dflt, line);
 936
 937   return rc;
 938 }
 939
 940
 941 /* Send a WRITECERT command to the SCdaemon. */
 942 int
 943 agent_scd_writecert (const char *certidstr,
 944                      const unsigned char *certdata, size_t certdatalen)
 945 {
 946   int rc;
 947   char line[ASSUAN_LINELENGTH];
 948   struct writecert_parm_s parms;
 949   struct default_inq_parm_s dfltparm;
 950
 951   memset (&dfltparm, 0, sizeof dfltparm);
 952
 953   rc = start_agent (NULL, 1);
 954   if (rc)
 955     return rc;
 956
 957   memset (&parms, 0, sizeof parms);
 958
 959   snprintf (line, DIM(line), "SCD WRITECERT %s", certidstr);
 960   dfltparm.ctx = agent_ctx;
 961   parms.dflt = &dfltparm;
 962   parms.certdata = certdata;
 963   parms.certdatalen = certdatalen;
 964
 965   rc = assuan_transact (agent_ctx, line, NULL, NULL,
 966                         inq_writecert_parms, &parms, NULL, NULL);
 967
 968   return rc;
 969 }
 970
 971
 972 \f
 973 /* Handle a KEYDATA inquiry.  Note, we only send the data,
 974    assuan_transact takes care of flushing and writing the end */
 975 static gpg_error_t
 976 inq_writekey_parms (void *opaque, const char *line)
 977 {
 978   int rc;
 979   struct writekey_parm_s *parm = opaque;
 980
 981   if (has_leading_keyword (line, "KEYDATA"))
 982     {
 983       rc = assuan_send_data (parm->dflt->ctx, parm->keydata, parm->keydatalen);
 984     }
 985   else
 986     rc = default_inq_cb (parm->dflt, line);
 987
 988   return rc;
 989 }
 990
 991
 992 /* Send a WRITEKEY command to the SCdaemon. */
 993 int
 994 agent_scd_writekey (int keyno, const char *serialno,
 995                     const unsigned char *keydata, size_t keydatalen)
 996 {
 997   int rc;
 998   char line[ASSUAN_LINELENGTH];
 999   struct writekey_parm_s parms;
1000   struct default_inq_parm_s dfltparm;
1001
1002   memset (&dfltparm, 0, sizeof dfltparm);
1003
1004   (void)serialno;
1005
1006   rc = start_agent (NULL, 1);
1007   if (rc)
1008     return rc;
1009
1010   memset (&parms, 0, sizeof parms);
1011
1012   snprintf (line, DIM(line), "SCD WRITEKEY --force OPENPGP.%d", keyno);
1013   dfltparm.ctx = agent_ctx;
1014   parms.dflt = &dfltparm;
1015   parms.keydata = keydata;
1016   parms.keydatalen = keydatalen;
1017
1018   rc = assuan_transact (agent_ctx, line, NULL, NULL,
1019                         inq_writekey_parms, &parms, NULL, NULL);
1020
1021   status_sc_op_failure (rc);
1022   return rc;
1023 }
1024
1025
1026 \f
1027 /* Status callback for the SCD GENKEY command. */
1028 static gpg_error_t
1029 scd_genkey_cb (void *opaque, const char *line)
1030 {
1031   u32 *createtime = opaque;
1032   const char *keyword = line;
1033   int keywordlen;
1034
1035   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1036     ;
1037   while (spacep (line))
1038     line++;
1039
1040  if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
1041     {
1042       *createtime = (u32)strtoul (line, NULL, 10);
1043     }
1044   else if (keywordlen == 8 && !memcmp (keyword, "PROGRESS", keywordlen))
1045     {
1046       write_status_text (STATUS_PROGRESS, line);
1047     }
1048
1049   return 0;
1050 }
1051
1052 /* Send a GENKEY command to the SCdaemon.  If *CREATETIME is not 0,
1053   the value will be passed to SCDAEMON with --timestamp option so that
1054   the key is created with this.  Otherwise, timestamp was generated by
1055   SCDEAMON.  On success, creation time is stored back to
1056   CREATETIME.  */
1057 int
1058 agent_scd_genkey (int keyno, int force, u32 *createtime)
1059 {
1060   int rc;
1061   char line[ASSUAN_LINELENGTH];
1062   gnupg_isotime_t tbuf;
1063   struct default_inq_parm_s dfltparm;
1064
1065   memset (&dfltparm, 0, sizeof dfltparm);
1066
1067   rc = start_agent (NULL, 1);
1068   if (rc)
1069     return rc;
1070
1071   if (*createtime)
1072     epoch2isotime (tbuf, *createtime);
1073   else
1074     *tbuf = 0;
1075
1076   snprintf (line, DIM(line), "SCD GENKEY %s%s %s %d",
1077             *tbuf? "--timestamp=":"", tbuf,
1078             force? "--force":"",
1079             keyno);
1080
1081   dfltparm.ctx = agent_ctx;
1082   rc = assuan_transact (agent_ctx, line,
1083                         NULL, NULL, default_inq_cb, &dfltparm,
1084                         scd_genkey_cb, createtime);
1085
1086   status_sc_op_failure (rc);
1087   return rc;
1088 }
1089 \f
1090 /* Return the serial number of the card or an appropriate error.  The
1091    serial number is returned as a hexstring. */
1092 int
1093 agent_scd_serialno (char **r_serialno, const char *demand)
1094 {
1095   int err;
1096   char *serialno = NULL;
1097   char line[ASSUAN_LINELENGTH];
1098
1099   err = start_agent (NULL, 1 | FLAG_FOR_CARD_SUPPRESS_ERRORS);
1100   if (err)
1101     return err;
1102
1103   if (!demand)
1104     strcpy (line, "SCD SERIALNO");
1105   else
1106     snprintf (line, DIM(line), "SCD SERIALNO --demand=%s", demand);
1107
1108   err = assuan_transact (agent_ctx, line,
1109                          NULL, NULL, NULL, NULL,
1110                          get_serialno_cb, &serialno);
1111   if (err)
1112     {
1113       xfree (serialno);
1114       return err;
1115     }
1116
1117   *r_serialno = serialno;
1118   return 0;
1119 }
1120 \f
1121 /* Send a READCERT command to the SCdaemon. */
1122 int
1123 agent_scd_readcert (const char *certidstr,
1124                     void **r_buf, size_t *r_buflen)
1125 {
1126   int rc;
1127   char line[ASSUAN_LINELENGTH];
1128   membuf_t data;
1129   size_t len;
1130   struct default_inq_parm_s dfltparm;
1131
1132   memset (&dfltparm, 0, sizeof dfltparm);
1133
1134   *r_buf = NULL;
1135   rc = start_agent (NULL, 1);
1136   if (rc)
1137     return rc;
1138
1139   dfltparm.ctx = agent_ctx;
1140
1141   init_membuf (&data, 2048);
1142
1143   snprintf (line, DIM(line), "SCD READCERT %s", certidstr);
1144   rc = assuan_transact (agent_ctx, line,
1145                         put_membuf_cb, &data,
1146                         default_inq_cb, &dfltparm,
1147                         NULL, NULL);
1148   if (rc)
1149     {
1150       xfree (get_membuf (&data, &len));
1151       return rc;
1152     }
1153   *r_buf = get_membuf (&data, r_buflen);
1154   if (!*r_buf)
1155     return gpg_error (GPG_ERR_ENOMEM);
1156
1157   return 0;
1158 }
1159 \f
1160 struct card_cardlist_parm_s {
1161   int error;
1162   strlist_t list;
1163 };
1164
1165
1166 /* Callback function for agent_card_cardlist.  */
1167 static gpg_error_t
1168 card_cardlist_cb (void *opaque, const char *line)
1169 {
1170   struct card_cardlist_parm_s *parm = opaque;
1171   const char *keyword = line;
1172   int keywordlen;
1173
1174   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1175     ;
1176   while (spacep (line))
1177     line++;
1178
1179   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
1180     {
1181       const char *s;
1182       int n;
1183
1184       for (n=0,s=line; hexdigitp (s); s++, n++)
1185         ;
1186
1187       if (!n || (n&1) || *s)
1188         parm->error = gpg_error (GPG_ERR_ASS_PARAMETER);
1189       else
1190         add_to_strlist (&parm->list, line);
1191     }
1192
1193   return 0;
1194 }
1195
1196 /* Return cardlist.  */
1197 int
1198 agent_scd_cardlist (strlist_t *result)
1199 {
1200   int err;
1201   char line[ASSUAN_LINELENGTH];
1202   struct card_cardlist_parm_s parm;
1203
1204   memset (&parm, 0, sizeof parm);
1205   *result = NULL;
1206   err = start_agent (NULL, 1);
1207   if (err)
1208     return err;
1209
1210   strcpy (line, "SCD GETINFO card_list");
1211
1212   err = assuan_transact (agent_ctx, line,
1213                          NULL, NULL, NULL, NULL,
1214                          card_cardlist_cb, &parm);
1215   if (!err && parm.error)
1216     err = parm.error;
1217
1218   if (!err)
1219     *result = parm.list;
1220   else
1221     free_strlist (parm.list);
1222
1223   return 0;
1224 }
1225 \f
1226 /* Change the PIN of an OpenPGP card or reset the retry counter.
1227    CHVNO 1: Change the PIN
1228          2: For v1 cards: Same as 1.
1229             For v2 cards: Reset the PIN using the Reset Code.
1230          3: Change the admin PIN
1231        101: Set a new PIN and reset the retry counter
1232        102: For v1 cars: Same as 101.
1233             For v2 cards: Set a new Reset Code.
1234    SERIALNO is not used.
1235  */
1236 int
1237 agent_scd_change_pin (int chvno, const char *serialno)
1238 {
1239   int rc;
1240   char line[ASSUAN_LINELENGTH];
1241   const char *reset = "";
1242   struct default_inq_parm_s dfltparm;
1243
1244   memset (&dfltparm, 0, sizeof dfltparm);
1245
1246   (void)serialno;
1247
1248   if (chvno >= 100)
1249     reset = "--reset";
1250   chvno %= 100;
1251
1252   rc = start_agent (NULL, 1);
1253   if (rc)
1254     return rc;
1255   dfltparm.ctx = agent_ctx;
1256
1257   snprintf (line, DIM(line), "SCD PASSWD %s %d", reset, chvno);
1258   rc = assuan_transact (agent_ctx, line,
1259                         NULL, NULL,
1260                         default_inq_cb, &dfltparm,
1261                         NULL, NULL);
1262   status_sc_op_failure (rc);
1263   return rc;
1264 }
1265
1266
1267 /* Perform a CHECKPIN operation.  SERIALNO should be the serial
1268    number of the card - optionally followed by the fingerprint;
1269    however the fingerprint is ignored here. */
1270 int
1271 agent_scd_checkpin  (const char *serialno)
1272 {
1273   int rc;
1274   char line[ASSUAN_LINELENGTH];
1275   struct default_inq_parm_s dfltparm;
1276
1277   memset (&dfltparm, 0, sizeof dfltparm);
1278
1279   rc = start_agent (NULL, 1);
1280   if (rc)
1281     return rc;
1282   dfltparm.ctx = agent_ctx;
1283
1284   snprintf (line, DIM(line), "SCD CHECKPIN %s", serialno);
1285   rc = assuan_transact (agent_ctx, line,
1286                         NULL, NULL,
1287                         default_inq_cb, &dfltparm,
1288                         NULL, NULL);
1289   status_sc_op_failure (rc);
1290   return rc;
1291 }
1292
1293
1294 /* Dummy function, only used by the gpg 1.4 implementation. */
1295 void
1296 agent_clear_pin_cache (const char *sn)
1297 {
1298   (void)sn;
1299 }
1300
1301
1302
1303 \f
1304 /* Note: All strings shall be UTF-8. On success the caller needs to
1305    free the string stored at R_PASSPHRASE. On error NULL will be
1306    stored at R_PASSPHRASE and an appropriate fpf error code
1307    returned. */
1308 gpg_error_t
1309 agent_get_passphrase (const char *cache_id,
1310                       const char *err_msg,
1311                       const char *prompt,
1312                       const char *desc_msg,
1313                       int repeat,
1314                       int check,
1315                       char **r_passphrase)
1316 {
1317   int rc;
1318   char line[ASSUAN_LINELENGTH];
1319   char *arg1 = NULL;
1320   char *arg2 = NULL;
1321   char *arg3 = NULL;
1322   char *arg4 = NULL;
1323   membuf_t data;
1324   struct default_inq_parm_s dfltparm;
1325
1326   memset (&dfltparm, 0, sizeof dfltparm);
1327
1328   *r_passphrase = NULL;
1329
1330   rc = start_agent (NULL, 0);
1331   if (rc)
1332     return rc;
1333   dfltparm.ctx = agent_ctx;
1334
1335   /* Check that the gpg-agent understands the repeat option.  */
1336   if (assuan_transact (agent_ctx,
1337                        "GETINFO cmd_has_option GET_PASSPHRASE repeat",
1338                        NULL, NULL, NULL, NULL, NULL, NULL))
1339     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1340
1341   if (cache_id && *cache_id)
1342     if (!(arg1 = percent_plus_escape (cache_id)))
1343       goto no_mem;
1344   if (err_msg && *err_msg)
1345     if (!(arg2 = percent_plus_escape (err_msg)))
1346       goto no_mem;
1347   if (prompt && *prompt)
1348     if (!(arg3 = percent_plus_escape (prompt)))
1349       goto no_mem;
1350   if (desc_msg && *desc_msg)
1351     if (!(arg4 = percent_plus_escape (desc_msg)))
1352       goto no_mem;
1353
1354   snprintf (line, DIM(line),
1355             "GET_PASSPHRASE --data --repeat=%d%s -- %s %s %s %s",
1356             repeat,
1357             check? " --check --qualitybar":"",
1358             arg1? arg1:"X",
1359             arg2? arg2:"X",
1360             arg3? arg3:"X",
1361             arg4? arg4:"X");
1362   xfree (arg1);
1363   xfree (arg2);
1364   xfree (arg3);
1365   xfree (arg4);
1366
1367   init_membuf_secure (&data, 64);
1368   rc = assuan_transact (agent_ctx, line,
1369                         put_membuf_cb, &data,
1370                         default_inq_cb, &dfltparm,
1371                         NULL, NULL);
1372
1373   if (rc)
1374     xfree (get_membuf (&data, NULL));
1375   else
1376     {
1377       put_membuf (&data, "", 1);
1378       *r_passphrase = get_membuf (&data, NULL);
1379       if (!*r_passphrase)
1380         rc = gpg_error_from_syserror ();
1381     }
1382   return rc;
1383  no_mem:
1384   rc = gpg_error_from_syserror ();
1385   xfree (arg1);
1386   xfree (arg2);
1387   xfree (arg3);
1388   xfree (arg4);
1389   return rc;
1390 }
1391
1392
1393 gpg_error_t
1394 agent_clear_passphrase (const char *cache_id)
1395 {
1396   int rc;
1397   char line[ASSUAN_LINELENGTH];
1398   struct default_inq_parm_s dfltparm;
1399
1400   memset (&dfltparm, 0, sizeof dfltparm);
1401
1402   if (!cache_id || !*cache_id)
1403     return 0;
1404
1405   rc = start_agent (NULL, 0);
1406   if (rc)
1407     return rc;
1408   dfltparm.ctx = agent_ctx;
1409
1410   snprintf (line, DIM(line), "CLEAR_PASSPHRASE %s", cache_id);
1411   return assuan_transact (agent_ctx, line,
1412                           NULL, NULL,
1413                           default_inq_cb, &dfltparm,
1414                           NULL, NULL);
1415 }
1416
1417
1418 /* Ask the agent to pop up a confirmation dialog with the text DESC
1419    and an okay and cancel button. */
1420 gpg_error_t
1421 gpg_agent_get_confirmation (const char *desc)
1422 {
1423   int rc;
1424   char *tmp;
1425   char line[ASSUAN_LINELENGTH];
1426   struct default_inq_parm_s dfltparm;
1427
1428   memset (&dfltparm, 0, sizeof dfltparm);
1429
1430   rc = start_agent (NULL, 0);
1431   if (rc)
1432     return rc;
1433   dfltparm.ctx = agent_ctx;
1434
1435   tmp = percent_plus_escape (desc);
1436   if (!tmp)
1437     return gpg_error_from_syserror ();
1438   snprintf (line, DIM(line), "GET_CONFIRMATION %s", tmp);
1439   xfree (tmp);
1440
1441   rc = assuan_transact (agent_ctx, line,
1442                         NULL, NULL,
1443                         default_inq_cb, &dfltparm,
1444                         NULL, NULL);
1445   return rc;
1446 }
1447
1448
1449 /* Return the S2K iteration count as computed by gpg-agent.  */
1450 gpg_error_t
1451 agent_get_s2k_count (unsigned long *r_count)
1452 {
1453   gpg_error_t err;
1454   membuf_t data;
1455   char *buf;
1456
1457   *r_count = 0;
1458
1459   err = start_agent (NULL, 0);
1460   if (err)
1461     return err;
1462
1463   init_membuf (&data, 32);
1464   err = assuan_transact (agent_ctx, "GETINFO s2k_count",
1465                         put_membuf_cb, &data,
1466                         NULL, NULL, NULL, NULL);
1467   if (err)
1468     xfree (get_membuf (&data, NULL));
1469   else
1470     {
1471       put_membuf (&data, "", 1);
1472       buf = get_membuf (&data, NULL);
1473       if (!buf)
1474         err = gpg_error_from_syserror ();
1475       else
1476         {
1477           *r_count = strtoul (buf, NULL, 10);
1478           xfree (buf);
1479         }
1480     }
1481   return err;
1482 }
1483
1484
1485 \f
1486 /* Ask the agent whether a secret key for the given public key is
1487    available.  Returns 0 if available.  */
1488 gpg_error_t
1489 agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
1490 {
1491   gpg_error_t err;
1492   char line[ASSUAN_LINELENGTH];
1493   char *hexgrip;
1494
1495   err = start_agent (ctrl, 0);
1496   if (err)
1497     return err;
1498
1499   err = hexkeygrip_from_pk (pk, &hexgrip);
1500   if (err)
1501     return err;
1502
1503   snprintf (line, sizeof line, "HAVEKEY %s", hexgrip);
1504   xfree (hexgrip);
1505
1506   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1507   return err;
1508 }
1509
1510 /* Ask the agent whether a secret key is available for any of the
1511    keys (primary or sub) in KEYBLOCK.  Returns 0 if available.  */
1512 gpg_error_t
1513 agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
1514 {
1515   gpg_error_t err;
1516   char line[ASSUAN_LINELENGTH];
1517   char *p;
1518   kbnode_t kbctx, node;
1519   int nkeys;
1520   unsigned char grip[KEYGRIP_LEN];
1521
1522   err = start_agent (ctrl, 0);
1523   if (err)
1524     return err;
1525
1526   err = gpg_error (GPG_ERR_NO_SECKEY); /* Just in case no key was
1527                                           found in KEYBLOCK.  */
1528   p = stpcpy (line, "HAVEKEY");
1529   for (kbctx=NULL, nkeys=0; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1530     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1531         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1532         || node->pkt->pkttype == PKT_SECRET_KEY
1533         || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1534       {
1535         if (nkeys && ((p - line) + 41) > (ASSUAN_LINELENGTH - 2))
1536           {
1537             err = assuan_transact (agent_ctx, line,
1538                                    NULL, NULL, NULL, NULL, NULL, NULL);
1539             if (err != gpg_err_code (GPG_ERR_NO_SECKEY))
1540               break; /* Seckey available or unexpected error - ready.  */
1541             p = stpcpy (line, "HAVEKEY");
1542             nkeys = 0;
1543           }
1544
1545         err = keygrip_from_pk (node->pkt->pkt.public_key, grip);
1546         if (err)
1547           return err;
1548         *p++ = ' ';
1549         bin2hex (grip, 20, p);
1550         p += 40;
1551         nkeys++;
1552       }
1553
1554   if (!err && nkeys)
1555     err = assuan_transact (agent_ctx, line,
1556                            NULL, NULL, NULL, NULL, NULL, NULL);
1557
1558   return err;
1559 }
1560
1561
1562 \f
1563 struct keyinfo_data_parm_s
1564 {
1565   char *serialno;
1566   int cleartext;
1567 };
1568
1569
1570 static gpg_error_t
1571 keyinfo_status_cb (void *opaque, const char *line)
1572 {
1573   struct keyinfo_data_parm_s *data = opaque;
1574   int is_smartcard;
1575   char *s;
1576
1577   if ((s = has_leading_keyword (line, "KEYINFO")) && data)
1578     {
1579       /* Parse the arguments:
1580        *      0        1        2        3       4          5
1581        *   <keygrip> <type> <serialno> <idstr> <cached> <protection>
1582        */
1583       char *fields[6];
1584
1585       if (split_fields (s, fields, DIM (fields)) == 6)
1586         {
1587           is_smartcard = (fields[1][0] == 'T');
1588           if (is_smartcard && !data->serialno && strcmp (fields[2], "-"))
1589             data->serialno = xtrystrdup (fields[2]);
1590           /* 'P' for protected, 'C' for clear */
1591           data->cleartext = (fields[5][0] == 'C');
1592         }
1593     }
1594   return 0;
1595 }
1596
1597
1598 /* Return the serial number for a secret key.  If the returned serial
1599    number is NULL, the key is not stored on a smartcard.  Caller needs
1600    to free R_SERIALNO.
1601
1602    if r_cleartext is not NULL, the referenced int will be set to 1 if
1603    the agent's copy of the key is stored in the clear, or 0 otherwise
1604 */
1605 gpg_error_t
1606 agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip,
1607                    char **r_serialno, int *r_cleartext)
1608 {
1609   gpg_error_t err;
1610   char line[ASSUAN_LINELENGTH];
1611   struct keyinfo_data_parm_s keyinfo;
1612
1613   memset (&keyinfo, 0,sizeof keyinfo);
1614
1615   *r_serialno = NULL;
1616
1617   err = start_agent (ctrl, 0);
1618   if (err)
1619     return err;
1620
1621   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1622     return gpg_error (GPG_ERR_INV_VALUE);
1623
1624   snprintf (line, DIM(line), "KEYINFO %s", hexkeygrip);
1625
1626   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1627                          keyinfo_status_cb, &keyinfo);
1628   if (!err && keyinfo.serialno)
1629     {
1630       /* Sanity check for bad characters.  */
1631       if (strpbrk (keyinfo.serialno, ":\n\r"))
1632         err = GPG_ERR_INV_VALUE;
1633     }
1634   if (err)
1635     xfree (keyinfo.serialno);
1636   else
1637     {
1638       *r_serialno = keyinfo.serialno;
1639       if (r_cleartext)
1640         *r_cleartext = keyinfo.cleartext;
1641     }
1642   return err;
1643 }
1644
1645 \f
1646 /* Status callback for agent_import_key, agent_export_key and
1647    agent_genkey.  */
1648 static gpg_error_t
1649 cache_nonce_status_cb (void *opaque, const char *line)
1650 {
1651   struct cache_nonce_parm_s *parm = opaque;
1652   const char *s;
1653
1654   if ((s = has_leading_keyword (line, "CACHE_NONCE")))
1655     {
1656       if (parm->cache_nonce_addr)
1657         {
1658           xfree (*parm->cache_nonce_addr);
1659           *parm->cache_nonce_addr = xtrystrdup (s);
1660         }
1661     }
1662   else if ((s = has_leading_keyword (line, "PASSWD_NONCE")))
1663     {
1664       if (parm->passwd_nonce_addr)
1665         {
1666           xfree (*parm->passwd_nonce_addr);
1667           *parm->passwd_nonce_addr = xtrystrdup (s);
1668         }
1669     }
1670   else if ((s = has_leading_keyword (line, "PROGRESS")))
1671     {
1672       if (opt.enable_progress_filter)
1673         write_status_text (STATUS_PROGRESS, s);
1674     }
1675
1676   return 0;
1677 }
1678
1679
1680 \f
1681 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
1682    assuan_transact takes care of flushing and writing the end */
1683 static gpg_error_t
1684 inq_genkey_parms (void *opaque, const char *line)
1685 {
1686   struct genkey_parm_s *parm = opaque;
1687   gpg_error_t err;
1688
1689   if (has_leading_keyword (line, "KEYPARAM"))
1690     {
1691       err = assuan_send_data (parm->dflt->ctx,
1692                               parm->keyparms, strlen (parm->keyparms));
1693     }
1694   else if (has_leading_keyword (line, "NEWPASSWD") && parm->passphrase)
1695     {
1696       err = assuan_send_data (parm->dflt->ctx,
1697                               parm->passphrase,  strlen (parm->passphrase));
1698     }
1699   else
1700     err = default_inq_cb (parm->dflt, line);
1701
1702   return err;
1703 }
1704
1705
1706 /* Call the agent to generate a new key.  KEYPARMS is the usual
1707    S-expression giving the parameters of the key.  gpg-agent passes it
1708    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1709    to protect the generated key.  If NO_PROTECTION is not set and
1710    PASSPHRASE is not NULL the agent is requested to protect the key
1711    with that passphrase instead of asking for one.  */
1712 gpg_error_t
1713 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr, char **passwd_nonce_addr,
1714               const char *keyparms, int no_protection,
1715               const char *passphrase, gcry_sexp_t *r_pubkey)
1716 {
1717   gpg_error_t err;
1718   struct genkey_parm_s gk_parm;
1719   struct cache_nonce_parm_s cn_parm;
1720   struct default_inq_parm_s dfltparm;
1721   membuf_t data;
1722   size_t len;
1723   unsigned char *buf;
1724   char line[ASSUAN_LINELENGTH];
1725
1726   memset (&dfltparm, 0, sizeof dfltparm);
1727   dfltparm.ctrl = ctrl;
1728
1729   *r_pubkey = NULL;
1730   err = start_agent (ctrl, 0);
1731   if (err)
1732     return err;
1733   dfltparm.ctx = agent_ctx;
1734
1735   if (passwd_nonce_addr && *passwd_nonce_addr)
1736     ; /* A RESET would flush the passwd nonce cache.  */
1737   else
1738     {
1739       err = assuan_transact (agent_ctx, "RESET",
1740                              NULL, NULL, NULL, NULL, NULL, NULL);
1741       if (err)
1742         return err;
1743     }
1744
1745   init_membuf (&data, 1024);
1746   gk_parm.dflt     = &dfltparm;
1747   gk_parm.keyparms = keyparms;
1748   gk_parm.passphrase = passphrase;
1749   snprintf (line, sizeof line, "GENKEY%s%s%s%s%s",
1750             no_protection? " --no-protection" :
1751             passphrase   ? " --inq-passwd" :
1752             /*          */ "",
1753             passwd_nonce_addr && *passwd_nonce_addr? " --passwd-nonce=":"",
1754             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
1755             cache_nonce_addr && *cache_nonce_addr? " ":"",
1756             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1757   cn_parm.cache_nonce_addr = cache_nonce_addr;
1758   cn_parm.passwd_nonce_addr = NULL;
1759   err = assuan_transact (agent_ctx, line,
1760                          put_membuf_cb, &data,
1761                          inq_genkey_parms, &gk_parm,
1762                          cache_nonce_status_cb, &cn_parm);
1763   if (err)
1764     {
1765       xfree (get_membuf (&data, &len));
1766       return err;
1767     }
1768
1769   buf = get_membuf (&data, &len);
1770   if (!buf)
1771     err = gpg_error_from_syserror ();
1772   else
1773     {
1774       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
1775       xfree (buf);
1776     }
1777   return err;
1778 }
1779
1780
1781 \f
1782 /* Call the agent to read the public key part for a given keygrip.  If
1783    FROMCARD is true, the key is directly read from the current
1784    smartcard. In this case HEXKEYGRIP should be the keyID
1785    (e.g. OPENPGP.3). */
1786 gpg_error_t
1787 agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
1788                unsigned char **r_pubkey)
1789 {
1790   gpg_error_t err;
1791   membuf_t data;
1792   size_t len;
1793   unsigned char *buf;
1794   char line[ASSUAN_LINELENGTH];
1795   struct default_inq_parm_s dfltparm;
1796
1797   memset (&dfltparm, 0, sizeof dfltparm);
1798   dfltparm.ctrl = ctrl;
1799
1800   *r_pubkey = NULL;
1801   err = start_agent (ctrl, 0);
1802   if (err)
1803     return err;
1804   dfltparm.ctx = agent_ctx;
1805
1806   err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
1807   if (err)
1808     return err;
1809
1810   snprintf (line, DIM(line), "READKEY %s%s", fromcard? "--card ":"",
1811             hexkeygrip);
1812
1813   init_membuf (&data, 1024);
1814   err = assuan_transact (agent_ctx, line,
1815                          put_membuf_cb, &data,
1816                          default_inq_cb, &dfltparm,
1817                          NULL, NULL);
1818   if (err)
1819     {
1820       xfree (get_membuf (&data, &len));
1821       return err;
1822     }
1823   buf = get_membuf (&data, &len);
1824   if (!buf)
1825     return gpg_error_from_syserror ();
1826   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
1827     {
1828       xfree (buf);
1829       return gpg_error (GPG_ERR_INV_SEXP);
1830     }
1831   *r_pubkey = buf;
1832   return 0;
1833 }
1834
1835
1836 \f
1837 /* Call the agent to do a sign operation using the key identified by
1838    the hex string KEYGRIP.  DESC is a description of the key to be
1839    displayed if the agent needs to ask for the PIN.  DIGEST and
1840    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
1841    used to compute the digest.  If CACHE_NONCE is used the agent is
1842    advised to first try a passphrase associated with that nonce. */
1843 gpg_error_t
1844 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
1845               const char *keygrip, const char *desc,
1846               u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1847               unsigned char *digest, size_t digestlen, int digestalgo,
1848               gcry_sexp_t *r_sigval)
1849 {
1850   gpg_error_t err;
1851   char line[ASSUAN_LINELENGTH];
1852   membuf_t data;
1853   struct default_inq_parm_s dfltparm;
1854
1855   memset (&dfltparm, 0, sizeof dfltparm);
1856   dfltparm.ctrl = ctrl;
1857   dfltparm.keyinfo.keyid       = keyid;
1858   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1859   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1860
1861   *r_sigval = NULL;
1862   err = start_agent (ctrl, 0);
1863   if (err)
1864     return err;
1865   dfltparm.ctx = agent_ctx;
1866
1867   if (digestlen*2 + 50 > DIM(line))
1868     return gpg_error (GPG_ERR_GENERAL);
1869
1870   err = assuan_transact (agent_ctx, "RESET",
1871                          NULL, NULL, NULL, NULL, NULL, NULL);
1872   if (err)
1873     return err;
1874
1875   snprintf (line, DIM(line), "SIGKEY %s", keygrip);
1876   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1877   if (err)
1878     return err;
1879
1880   if (desc)
1881     {
1882       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
1883       err = assuan_transact (agent_ctx, line,
1884                             NULL, NULL, NULL, NULL, NULL, NULL);
1885       if (err)
1886         return err;
1887     }
1888
1889   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
1890   bin2hex (digest, digestlen, line + strlen (line));
1891   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1892   if (err)
1893     return err;
1894
1895   init_membuf (&data, 1024);
1896
1897   snprintf (line, sizeof line, "PKSIGN%s%s",
1898             cache_nonce? " -- ":"",
1899             cache_nonce? cache_nonce:"");
1900
1901   if (DBG_CLOCK)
1902     log_clock ("enter signing");
1903   err = assuan_transact (agent_ctx, line,
1904                          put_membuf_cb, &data,
1905                          default_inq_cb, &dfltparm,
1906                          NULL, NULL);
1907   if (DBG_CLOCK)
1908     log_clock ("leave signing");
1909
1910   if (err)
1911     xfree (get_membuf (&data, NULL));
1912   else
1913     {
1914       unsigned char *buf;
1915       size_t len;
1916
1917       buf = get_membuf (&data, &len);
1918       if (!buf)
1919         err = gpg_error_from_syserror ();
1920       else
1921         {
1922           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
1923           xfree (buf);
1924         }
1925     }
1926   return err;
1927 }
1928
1929
1930 \f
1931 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
1932    assuan_transact takes care of flushing and writing the END. */
1933 static gpg_error_t
1934 inq_ciphertext_cb (void *opaque, const char *line)
1935 {
1936   struct cipher_parm_s *parm = opaque;
1937   int rc;
1938
1939   if (has_leading_keyword (line, "CIPHERTEXT"))
1940     {
1941       assuan_begin_confidential (parm->ctx);
1942       rc = assuan_send_data (parm->dflt->ctx,
1943                              parm->ciphertext, parm->ciphertextlen);
1944       assuan_end_confidential (parm->ctx);
1945     }
1946   else
1947     rc = default_inq_cb (parm->dflt, line);
1948
1949   return rc;
1950 }
1951
1952
1953 /* Check whether there is any padding info from the agent.  */
1954 static gpg_error_t
1955 padding_info_cb (void *opaque, const char *line)
1956 {
1957   int *r_padding = opaque;
1958   const char *s;
1959
1960   if ((s=has_leading_keyword (line, "PADDING")))
1961     {
1962       *r_padding = atoi (s);
1963     }
1964
1965   return 0;
1966 }
1967
1968
1969 /* Call the agent to do a decrypt operation using the key identified
1970    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
1971    success the decoded value is stored verbatim at R_BUF and its
1972    length at R_BUF; the callers needs to release it.  KEYID, MAINKEYID
1973    and PUBKEY_ALGO are used to construct additional promots or status
1974    messages.   The padding information is stored at R_PADDING with -1
1975    for not known.  */
1976 gpg_error_t
1977 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
1978                  u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1979                  gcry_sexp_t s_ciphertext,
1980                  unsigned char **r_buf, size_t *r_buflen, int *r_padding)
1981 {
1982   gpg_error_t err;
1983   char line[ASSUAN_LINELENGTH];
1984   membuf_t data;
1985   size_t n, len;
1986   char *p, *buf, *endp;
1987   struct default_inq_parm_s dfltparm;
1988
1989   memset (&dfltparm, 0, sizeof dfltparm);
1990   dfltparm.ctrl = ctrl;
1991   dfltparm.keyinfo.keyid       = keyid;
1992   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1993   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1994
1995   if (!keygrip || strlen(keygrip) != 40
1996       || !s_ciphertext || !r_buf || !r_buflen || !r_padding)
1997     return gpg_error (GPG_ERR_INV_VALUE);
1998
1999   *r_buf = NULL;
2000   *r_padding = -1;
2001
2002   err = start_agent (ctrl, 0);
2003   if (err)
2004     return err;
2005   dfltparm.ctx = agent_ctx;
2006
2007   err = assuan_transact (agent_ctx, "RESET",
2008                          NULL, NULL, NULL, NULL, NULL, NULL);
2009   if (err)
2010     return err;
2011
2012   snprintf (line, sizeof line, "SETKEY %s", keygrip);
2013   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
2014   if (err)
2015     return err;
2016
2017   if (desc)
2018     {
2019       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2020       err = assuan_transact (agent_ctx, line,
2021                             NULL, NULL, NULL, NULL, NULL, NULL);
2022       if (err)
2023         return err;
2024     }
2025
2026   init_membuf_secure (&data, 1024);
2027   {
2028     struct cipher_parm_s parm;
2029
2030     parm.dflt = &dfltparm;
2031     parm.ctx = agent_ctx;
2032     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
2033     if (err)
2034       return err;
2035     err = assuan_transact (agent_ctx, "PKDECRYPT",
2036                            put_membuf_cb, &data,
2037                            inq_ciphertext_cb, &parm,
2038                            padding_info_cb, r_padding);
2039     xfree (parm.ciphertext);
2040   }
2041   if (err)
2042     {
2043       xfree (get_membuf (&data, &len));
2044       return err;
2045     }
2046
2047   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
2048   buf = get_membuf (&data, &len);
2049   if (!buf)
2050     return gpg_error_from_syserror ();
2051   log_assert (len); /* (we forced Nul termination.)  */
2052
2053   if (*buf != '(')
2054     {
2055       xfree (buf);
2056       return gpg_error (GPG_ERR_INV_SEXP);
2057     }
2058
2059   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
2060     {
2061       xfree (buf);
2062       return gpg_error (GPG_ERR_INV_SEXP);
2063     }
2064   len -= 10;   /* Count only the data of the second part. */
2065   p = buf + 8; /* Skip leading parenthesis and the value tag. */
2066
2067   n = strtoul (p, &endp, 10);
2068   if (!n || *endp != ':')
2069     {
2070       xfree (buf);
2071       return gpg_error (GPG_ERR_INV_SEXP);
2072     }
2073   endp++;
2074   if (endp-p+n > len)
2075     {
2076       xfree (buf);
2077       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
2078     }
2079
2080   memmove (buf, endp, n);
2081
2082   *r_buflen = n;
2083   *r_buf = buf;
2084   return 0;
2085 }
2086
2087
2088 \f
2089 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
2090    the key shall be used for export, with false for import.  On success
2091    the new key is stored at R_KEY and its length at R_KEKLEN.  */
2092 gpg_error_t
2093 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
2094 {
2095   gpg_error_t err;
2096   membuf_t data;
2097   size_t len;
2098   unsigned char *buf;
2099   char line[ASSUAN_LINELENGTH];
2100   struct default_inq_parm_s dfltparm;
2101
2102   memset (&dfltparm, 0, sizeof dfltparm);
2103   dfltparm.ctrl = ctrl;
2104
2105   *r_kek = NULL;
2106   err = start_agent (ctrl, 0);
2107   if (err)
2108     return err;
2109   dfltparm.ctx = agent_ctx;
2110
2111   snprintf (line, DIM(line), "KEYWRAP_KEY %s",
2112             forexport? "--export":"--import");
2113
2114   init_membuf_secure (&data, 64);
2115   err = assuan_transact (agent_ctx, line,
2116                          put_membuf_cb, &data,
2117                          default_inq_cb, &dfltparm,
2118                          NULL, NULL);
2119   if (err)
2120     {
2121       xfree (get_membuf (&data, &len));
2122       return err;
2123     }
2124   buf = get_membuf (&data, &len);
2125   if (!buf)
2126     return gpg_error_from_syserror ();
2127   *r_kek = buf;
2128   *r_keklen = len;
2129   return 0;
2130 }
2131
2132
2133 \f
2134 /* Handle the inquiry for an IMPORT_KEY command.  */
2135 static gpg_error_t
2136 inq_import_key_parms (void *opaque, const char *line)
2137 {
2138   struct import_key_parm_s *parm = opaque;
2139   gpg_error_t err;
2140
2141   if (has_leading_keyword (line, "KEYDATA"))
2142     {
2143       err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
2144     }
2145   else
2146     err = default_inq_cb (parm->dflt, line);
2147
2148   return err;
2149 }
2150
2151
2152 /* Call the agent to import a key into the agent.  */
2153 gpg_error_t
2154 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
2155                   const void *key, size_t keylen, int unattended, int force,
2156                   u32 *keyid, u32 *mainkeyid, int pubkey_algo)
2157 {
2158   gpg_error_t err;
2159   struct import_key_parm_s parm;
2160   struct cache_nonce_parm_s cn_parm;
2161   char line[ASSUAN_LINELENGTH];
2162   struct default_inq_parm_s dfltparm;
2163
2164   memset (&dfltparm, 0, sizeof dfltparm);
2165   dfltparm.ctrl = ctrl;
2166   dfltparm.keyinfo.keyid       = keyid;
2167   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2168   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2169
2170   err = start_agent (ctrl, 0);
2171   if (err)
2172     return err;
2173   dfltparm.ctx = agent_ctx;
2174
2175   if (desc)
2176     {
2177       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2178       err = assuan_transact (agent_ctx, line,
2179                             NULL, NULL, NULL, NULL, NULL, NULL);
2180       if (err)
2181         return err;
2182     }
2183
2184   parm.dflt   = &dfltparm;
2185   parm.key    = key;
2186   parm.keylen = keylen;
2187
2188   snprintf (line, sizeof line, "IMPORT_KEY%s%s%s%s",
2189             unattended? " --unattended":"",
2190             force? " --force":"",
2191             cache_nonce_addr && *cache_nonce_addr? " ":"",
2192             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
2193   cn_parm.cache_nonce_addr = cache_nonce_addr;
2194   cn_parm.passwd_nonce_addr = NULL;
2195   err = assuan_transact (agent_ctx, line,
2196                          NULL, NULL,
2197                          inq_import_key_parms, &parm,
2198                          cache_nonce_status_cb, &cn_parm);
2199   return err;
2200 }
2201
2202
2203 \f
2204 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
2205    keygrip, DESC a prompt to be displayed with the agent's passphrase
2206    question (needs to be plus+percent escaped).  if OPENPGP_PROTECTED
2207    is not zero, ensure that the key material is returned in RFC
2208    4880-compatible passphrased-protected form.  If CACHE_NONCE_ADDR is
2209    not NULL the agent is advised to first try a passphrase associated
2210    with that nonce.  On success the key is stored as a canonical
2211    S-expression at R_RESULT and R_RESULTLEN.  */
2212 gpg_error_t
2213 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2214                   int openpgp_protected, char **cache_nonce_addr,
2215                   unsigned char **r_result, size_t *r_resultlen,
2216                   u32 *keyid, u32 *mainkeyid, int pubkey_algo)
2217 {
2218   gpg_error_t err;
2219   struct cache_nonce_parm_s cn_parm;
2220   membuf_t data;
2221   size_t len;
2222   unsigned char *buf;
2223   char line[ASSUAN_LINELENGTH];
2224   struct default_inq_parm_s dfltparm;
2225
2226   memset (&dfltparm, 0, sizeof dfltparm);
2227   dfltparm.ctrl = ctrl;
2228   dfltparm.keyinfo.keyid       = keyid;
2229   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2230   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2231
2232   *r_result = NULL;
2233
2234   err = start_agent (ctrl, 0);
2235   if (err)
2236     return err;
2237   dfltparm.ctx = agent_ctx;
2238
2239   if (desc)
2240     {
2241       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2242       err = assuan_transact (agent_ctx, line,
2243                              NULL, NULL, NULL, NULL, NULL, NULL);
2244       if (err)
2245         return err;
2246     }
2247
2248   snprintf (line, DIM(line), "EXPORT_KEY %s%s%s %s",
2249             openpgp_protected ? "--openpgp ":"",
2250             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2251             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2252             hexkeygrip);
2253
2254   init_membuf_secure (&data, 1024);
2255   cn_parm.cache_nonce_addr = cache_nonce_addr;
2256   cn_parm.passwd_nonce_addr = NULL;
2257   err = assuan_transact (agent_ctx, line,
2258                          put_membuf_cb, &data,
2259                          default_inq_cb, &dfltparm,
2260                          cache_nonce_status_cb, &cn_parm);
2261   if (err)
2262     {
2263       xfree (get_membuf (&data, &len));
2264       return err;
2265     }
2266   buf = get_membuf (&data, &len);
2267   if (!buf)
2268     return gpg_error_from_syserror ();
2269   *r_result = buf;
2270   *r_resultlen = len;
2271   return 0;
2272 }
2273
2274
2275 \f
2276 /* Ask the agent to delete the key identified by HEXKEYGRIP.  If DESC
2277    is not NULL, display DESC instead of the default description
2278    message.  If FORCE is true the agent is advised not to ask for
2279    confirmation. */
2280 gpg_error_t
2281 agent_delete_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2282                   int force)
2283 {
2284   gpg_error_t err;
2285   char line[ASSUAN_LINELENGTH];
2286   struct default_inq_parm_s dfltparm;
2287
2288   memset (&dfltparm, 0, sizeof dfltparm);
2289   dfltparm.ctrl = ctrl;
2290
2291   err = start_agent (ctrl, 0);
2292   if (err)
2293     return err;
2294
2295   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2296     return gpg_error (GPG_ERR_INV_VALUE);
2297
2298   if (desc)
2299     {
2300       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2301       err = assuan_transact (agent_ctx, line,
2302                              NULL, NULL, NULL, NULL, NULL, NULL);
2303       if (err)
2304         return err;
2305     }
2306
2307   snprintf (line, DIM(line), "DELETE_KEY%s %s",
2308             force? " --force":"", hexkeygrip);
2309   err = assuan_transact (agent_ctx, line, NULL, NULL,
2310                          default_inq_cb, &dfltparm,
2311                          NULL, NULL);
2312   return err;
2313 }
2314
2315
2316 \f
2317 /* Ask the agent to change the passphrase of the key identified by
2318  * HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
2319  * default description message.  If CACHE_NONCE_ADDR is not NULL the
2320  * agent is advised to first try a passphrase associated with that
2321  * nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
2322  * the passphrase associated with that nonce for the new passphrase.
2323  * If VERIFY is true the passphrase is only verified.  */
2324 gpg_error_t
2325 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc, int verify,
2326               char **cache_nonce_addr, char **passwd_nonce_addr)
2327 {
2328   gpg_error_t err;
2329   struct cache_nonce_parm_s cn_parm;
2330   char line[ASSUAN_LINELENGTH];
2331   struct default_inq_parm_s dfltparm;
2332
2333   memset (&dfltparm, 0, sizeof dfltparm);
2334   dfltparm.ctrl = ctrl;
2335
2336   err = start_agent (ctrl, 0);
2337   if (err)
2338     return err;
2339   dfltparm.ctx = agent_ctx;
2340
2341   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2342     return gpg_error (GPG_ERR_INV_VALUE);
2343
2344   if (desc)
2345     {
2346       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2347       err = assuan_transact (agent_ctx, line,
2348                              NULL, NULL, NULL, NULL, NULL, NULL);
2349       if (err)
2350         return err;
2351     }
2352
2353   if (verify)
2354     snprintf (line, DIM(line), "PASSWD %s%s --verify %s",
2355               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2356               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2357               hexkeygrip);
2358   else
2359     snprintf (line, DIM(line), "PASSWD %s%s %s%s %s",
2360               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2361               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2362               passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
2363               passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
2364               hexkeygrip);
2365   cn_parm.cache_nonce_addr = cache_nonce_addr;
2366   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
2367   err = assuan_transact (agent_ctx, line, NULL, NULL,
2368                          default_inq_cb, &dfltparm,
2369                          cache_nonce_status_cb, &cn_parm);
2370   return err;
2371 }
2372
2373
2374 /* Return the version reported by gpg-agent.  */
2375 gpg_error_t
2376 agent_get_version (ctrl_t ctrl, char **r_version)
2377 {
2378   gpg_error_t err;
2379
2380   err = start_agent (ctrl, 0);
2381   if (err)
2382     return err;
2383
2384   err = get_assuan_server_version (agent_ctx, 0, r_version);
2385   return err;
2386 }