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