agent/call-scd.c

   1 /* call-scd.c - fork of the scdaemon to do SC operations
   2  *      Copyright (C) 2001, 2002 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19  */
  20
  21 #include <config.h>
  22 #include <errno.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <assert.h>
  28 #include <unistd.h>
  29 #include <sys/stat.h>
  30
  31 #include "agent.h"
  32 #include "../assuan/assuan.h"
  33
  34 #ifdef _POSIX_OPEN_MAX
  35 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
  36 #else
  37 #define MAX_OPEN_FDS 20
  38 #endif
  39
  40 static ASSUAN_CONTEXT scd_ctx = NULL;
  41
  42 /* callback parameter for learn card */
  43 struct learn_parm_s {
  44   void (*kpinfo_cb)(void*, const char *);
  45   void *kpinfo_cb_arg;
  46 };
  47
  48 struct inq_needpin_s {
  49   ASSUAN_CONTEXT ctx;
  50   int (*getpin_cb)(void *, const char *, char*, size_t);
  51   void *getpin_cb_arg;
  52 };
  53
  54 struct membuf {
  55   size_t len;
  56   size_t size;
  57   char *buf;
  58   int out_of_core;
  59 };
  60
  61
  62 \f
  63 /* A simple implemnation of a dynamic buffer.  Use init_membuf() to
  64    create a buffer, put_membuf to append bytes and get_membuf to
  65    release and return the buffer.  Allocation errors are detected but
  66    only returned at the final get_membuf(), this helps not to clutter
  67    the code with out of core checks.  */
  68
  69 static void
  70 init_membuf (struct membuf *mb, int initiallen)
  71 {
  72   mb->len = 0;
  73   mb->size = initiallen;
  74   mb->out_of_core = 0;
  75   mb->buf = xtrymalloc (initiallen);
  76   if (!mb->buf)
  77       mb->out_of_core = 1;
  78 }
  79
  80 static void
  81 put_membuf (struct membuf *mb, const void *buf, size_t len)
  82 {
  83   if (mb->out_of_core)
  84     return;
  85
  86   if (mb->len + len >= mb->size)
  87     {
  88       char *p;
  89
  90       mb->size += len + 1024;
  91       p = xtryrealloc (mb->buf, mb->size);
  92       if (!p)
  93         {
  94           mb->out_of_core = 1;
  95           return;
  96         }
  97       mb->buf = p;
  98     }
  99   memcpy (mb->buf + mb->len, buf, len);
 100   mb->len += len;
 101 }
 102
 103 static void *
 104 get_membuf (struct membuf *mb, size_t *len)
 105 {
 106   char *p;
 107
 108   if (mb->out_of_core)
 109     {
 110       xfree (mb->buf);
 111       mb->buf = NULL;
 112       return NULL;
 113     }
 114
 115   p = mb->buf;
 116   *len = mb->len;
 117   mb->buf = NULL;
 118   mb->out_of_core = 1; /* don't allow a reuse */
 119   return p;
 120 }
 121
 122
 123
 124 \f
 125 /* Fork off the SCdaemon if this has not already been done */
 126 static int
 127 start_scd (void)
 128 {
 129   int rc;
 130   const char *pgmname;
 131   ASSUAN_CONTEXT ctx;
 132   const char *argv[3];
 133
 134   if (scd_ctx)
 135     return 0; /* No need to serialize things because the agent is
 136                  expected to tun as a single-thread (or may be in
 137                  future using libpth) */
 138
 139   log_debug ("no running SCdaemon - starting it\n");
 140
 141   if (fflush (NULL))
 142     {
 143       log_error ("error flushing pending output: %s\n", strerror (errno));
 144       return seterr (Write_Error);
 145     }
 146
 147   /* FIXME: change the default location of the program */
 148   if (!opt.scdaemon_program || !*opt.scdaemon_program)
 149     opt.scdaemon_program = "../scd/scdaemon";
 150   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
 151     pgmname = opt.scdaemon_program;
 152   else
 153     pgmname++;
 154
 155   argv[0] = pgmname;
 156   argv[1] = "--server";
 157   argv[2] = NULL;
 158
 159   /* connect to the pinentry and perform initial handshaking */
 160   rc = assuan_pipe_connect (&ctx, opt.scdaemon_program, (char**)argv, 0);
 161   if (rc)
 162     {
 163       log_error ("can't connect to the SCdaemon: %s\n",
 164                  assuan_strerror (rc));
 165       return seterr (No_Scdaemon);
 166     }
 167   scd_ctx = ctx;
 168
 169   log_debug ("connection to SCdaemon established\n");
 170   return 0;
 171 }
 172
 173
 174 \f
 175 static AssuanError
 176 learn_status_cb (void *opaque, const char *line)
 177 {
 178   struct learn_parm_s *parm = opaque;
 179   const char *keyword = line;
 180   int keywordlen;
 181
 182   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 183     ;
 184   while (spacep (line))
 185     line++;
 186   if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
 187     {
 188       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
 189     }
 190   else if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
 191     {
 192       log_debug ("learn_status_cb: serialno `%s'\n", line);
 193     }
 194   else
 195     log_debug ("learn_status_cb: ignoring `%.*s'\n", keywordlen, keyword);
 196
 197   return 0;
 198 }
 199
 200 /* Perform the learn command and return a list of all private keys
 201    stored on the card. */
 202 int
 203 agent_card_learn (void (*kpinfo_cb)(void*, const char *), void *kpinfo_cb_arg)
 204 {
 205   int rc;
 206   struct learn_parm_s parm;
 207
 208   rc = start_scd ();
 209   if (rc)
 210     return rc;
 211
 212   memset (&parm, 0, sizeof parm);
 213   parm.kpinfo_cb = kpinfo_cb;
 214   parm.kpinfo_cb_arg = kpinfo_cb_arg;
 215   rc = assuan_transact (scd_ctx, "LEARN --force",
 216                         NULL, NULL, NULL, NULL,
 217                         learn_status_cb, &parm);
 218   if (rc)
 219     return map_assuan_err (rc);
 220
 221   return 0;
 222 }
 223
 224
 225 \f
 226 static AssuanError
 227 get_serialno_cb (void *opaque, const char *line)
 228 {
 229   char **serialno = opaque;
 230   const char *keyword = line;
 231   const char *s;
 232   int keywordlen, n;
 233
 234   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 235     ;
 236   while (spacep (line))
 237     line++;
 238
 239   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
 240     {
 241       if (*serialno)
 242         return ASSUAN_Unexpected_Status;
 243       for (n=0,s=line; hexdigitp (s); s++, n++)
 244         ;
 245       if (!n || (n&1)|| !(spacep (s) || !*s) )
 246         return ASSUAN_Invalid_Status;
 247       *serialno = xtrymalloc (n+1);
 248       if (!*serialno)
 249         return ASSUAN_Out_Of_Core;
 250       memcpy (*serialno, line, n);
 251       (*serialno)[n] = 0;
 252     }
 253
 254   return 0;
 255 }
 256
 257 /* Return the serial number of the card or an appropriate error.  The
 258    serial number is returned as a hexstring. */
 259 int
 260 agent_card_serialno (char **r_serialno)
 261 {
 262   int rc;
 263   char *serialno = NULL;
 264
 265   rc = start_scd ();
 266   if (rc)
 267     return rc;
 268
 269   /* Hmm, do we really need this reset - scddaemon should do this or
 270      we can do this if we for some reason figure out that the
 271      operation might have failed due to a missing RESET.  Hmmm, I feel
 272      this is really SCdaemon's duty */
 273   rc = assuan_transact (scd_ctx, "RESET", NULL, NULL, NULL, NULL, NULL, NULL);
 274   if (rc)
 275     return map_assuan_err (rc);
 276
 277   rc = assuan_transact (scd_ctx, "SERIALNO",
 278                         NULL, NULL, NULL, NULL,
 279                         get_serialno_cb, &serialno);
 280   if (rc)
 281     {
 282       xfree (serialno);
 283       return map_assuan_err (rc);
 284     }
 285   *r_serialno = serialno;
 286   return 0;
 287 }
 288
 289 \f
 290 static AssuanError
 291 membuf_data_cb (void *opaque, const void *buffer, size_t length)
 292 {
 293   struct membuf *data = opaque;
 294
 295   if (buffer)
 296     put_membuf (data, buffer, length);
 297   return 0;
 298 }
 299
 300 /* Handle the NEEDPIN inquiry. */
 301 static AssuanError
 302 inq_needpin (void *opaque, const char *line)
 303 {
 304   struct inq_needpin_s *parm = opaque;
 305   char *pin;
 306   size_t pinlen;
 307   int rc;
 308
 309   if (!(!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7])))
 310     {
 311       log_error ("unsupported inquiry `%s'\n", line);
 312       return ASSUAN_Inquire_Unknown;
 313     }
 314   line += 7;
 315
 316   pinlen = 90;
 317   pin = gcry_malloc_secure (pinlen);
 318   if (!pin)
 319     return ASSUAN_Out_Of_Core;
 320
 321   rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
 322   if (rc)
 323     rc = ASSUAN_Canceled;
 324   if (!rc)
 325     rc = assuan_send_data (parm->ctx, pin, pinlen);
 326   xfree (pin);
 327
 328   return rc;
 329 }
 330
 331
 332
 333 /* Create a signature using the current card */
 334 int
 335 agent_card_pksign (const char *keyid,
 336                    int (*getpin_cb)(void *, const char *, char*, size_t),
 337                    void *getpin_cb_arg,
 338                    const unsigned char *indata, size_t indatalen,
 339                    char **r_buf, size_t *r_buflen)
 340 {
 341   int rc, i;
 342   char *p, line[ASSUAN_LINELENGTH];
 343   struct membuf data;
 344   struct inq_needpin_s inqparm;
 345   size_t len;
 346   unsigned char *sigbuf;
 347   size_t sigbuflen;
 348
 349   *r_buf = NULL;
 350   rc = start_scd ();
 351   if (rc)
 352     return rc;
 353
 354   if (indatalen*2 + 50 > DIM(line))
 355     return seterr (General_Error);
 356
 357   sprintf (line, "SETDATA ");
 358   p = line + strlen (line);
 359   for (i=0; i < indatalen ; i++, p += 2 )
 360     sprintf (p, "%02X", indata[i]);
 361   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
 362   if (rc)
 363     return map_assuan_err (rc);
 364
 365   init_membuf (&data, 1024);
 366   inqparm.ctx = scd_ctx;
 367   inqparm.getpin_cb = getpin_cb;
 368   inqparm.getpin_cb_arg = getpin_cb_arg;
 369   snprintf (line, DIM(line)-1, "PKSIGN %s", keyid);
 370   line[DIM(line)-1] = 0;
 371   rc = assuan_transact (scd_ctx, line,
 372                         membuf_data_cb, &data,
 373                         inq_needpin, &inqparm,
 374                         NULL, NULL);
 375   if (rc)
 376     {
 377       xfree (get_membuf (&data, &len));
 378       return map_assuan_err (rc);
 379     }
 380   sigbuf = get_membuf (&data, &sigbuflen);
 381
 382   /* create an S-expression from it which is formatted like this:
 383      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))" */
 384   *r_buflen = 21 + 11 + sigbuflen + 4;
 385   *r_buf = xtrymalloc (*r_buflen);
 386   if (!*r_buf)
 387     {
 388       xfree (*r_buf);
 389       return GNUPG_Out_Of_Core;
 390     }
 391   p = stpcpy (*r_buf, "(7:sig-val(3:rsa(1:s" );
 392   sprintf (p, "%u:", (unsigned int)sigbuflen);
 393   p += strlen (p);
 394   memcpy (p, sigbuf, sigbuflen);
 395   p += sigbuflen;
 396   strcpy (p, ")))");
 397   xfree (sigbuf);
 398
 399   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
 400   return 0;
 401 }
 402
 403 /* Decipher INDATA using the current card. Note that the returned value is */
 404 int
 405 agent_card_pkdecrypt (const char *keyid,
 406                    int (*getpin_cb)(void *, const char *, char*, size_t),
 407                    void *getpin_cb_arg,
 408                    const unsigned char *indata, size_t indatalen,
 409                    char **r_buf, size_t *r_buflen)
 410 {
 411   int rc, i;
 412   char *p, line[ASSUAN_LINELENGTH];
 413   struct membuf data;
 414   struct inq_needpin_s inqparm;
 415   size_t len;
 416
 417   *r_buf = NULL;
 418   rc = start_scd ();
 419   if (rc)
 420     return rc;
 421
 422   /* FIXME: use secure memory where appropriate */
 423   if (indatalen*2 + 50 > DIM(line))
 424     return seterr (General_Error);
 425
 426   sprintf (line, "SETDATA ");
 427   p = line + strlen (line);
 428   for (i=0; i < indatalen ; i++, p += 2 )
 429     sprintf (p, "%02X", indata[i]);
 430   rc = assuan_transact (scd_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
 431   if (rc)
 432     return map_assuan_err (rc);
 433
 434   init_membuf (&data, 1024);
 435   inqparm.ctx = scd_ctx;
 436   inqparm.getpin_cb = getpin_cb;
 437   inqparm.getpin_cb_arg = getpin_cb_arg;
 438   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
 439   line[DIM(line)-1] = 0;
 440   rc = assuan_transact (scd_ctx, line,
 441                         membuf_data_cb, &data,
 442                         inq_needpin, &inqparm,
 443                         NULL, NULL);
 444   if (rc)
 445     {
 446       xfree (get_membuf (&data, &len));
 447       return map_assuan_err (rc);
 448     }
 449   *r_buf = get_membuf (&data, r_buflen);
 450   if (!*r_buf)
 451     return GNUPG_Out_Of_Core;
 452
 453   return 0;
 454 }
 455
 456
 457 \f
 458 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
 459 int
 460 agent_card_readcert (const char *id, char **r_buf, size_t *r_buflen)
 461 {
 462   int rc;
 463   char line[ASSUAN_LINELENGTH];
 464   struct membuf data;
 465   size_t len;
 466
 467   *r_buf = NULL;
 468   rc = start_scd ();
 469   if (rc)
 470     return rc;
 471
 472   init_membuf (&data, 1024);
 473   snprintf (line, DIM(line)-1, "READCERT %s", id);
 474   line[DIM(line)-1] = 0;
 475   rc = assuan_transact (scd_ctx, line,
 476                         membuf_data_cb, &data,
 477                         NULL, NULL,
 478                         NULL, NULL);
 479   if (rc)
 480     {
 481       xfree (get_membuf (&data, &len));
 482       return map_assuan_err (rc);
 483     }
 484   *r_buf = get_membuf (&data, r_buflen);
 485   if (!*r_buf)
 486     return GNUPG_Out_Of_Core;
 487
 488   return 0;
 489 }
 490
 491
 492 \f
 493 /* Read a key with ID and return it in an allocate buffer pointed to
 494    by r_BUF as a valid S-expression. */
 495 int
 496 agent_card_readkey (const char *id, unsigned char **r_buf)
 497 {
 498   int rc;
 499   char line[ASSUAN_LINELENGTH];
 500   struct membuf data;
 501   size_t len, buflen;
 502
 503   *r_buf = NULL;
 504   rc = start_scd ();
 505   if (rc)
 506     return rc;
 507
 508   init_membuf (&data, 1024);
 509   snprintf (line, DIM(line)-1, "READKEY %s", id);
 510   line[DIM(line)-1] = 0;
 511   rc = assuan_transact (scd_ctx, line,
 512                         membuf_data_cb, &data,
 513                         NULL, NULL,
 514                         NULL, NULL);
 515   if (rc)
 516     {
 517       xfree (get_membuf (&data, &len));
 518       return map_assuan_err (rc);
 519     }
 520   *r_buf = get_membuf (&data, &buflen);
 521   if (!*r_buf)
 522     return GNUPG_Out_Of_Core;
 523
 524   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
 525     {
 526       xfree (*r_buf); *r_buf = NULL;
 527       return GNUPG_Invalid_Value;
 528     }
 529
 530   return 0;
 531 }
 532
 533
 534