summaryrefslogtreecommitdiffstats
path: root/scd/command.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--scd/command.c2130
1 files changed, 2130 insertions, 0 deletions
diff --git a/scd/command.c b/scd/command.c
new file mode 100644
index 0000000..925fd75
--- /dev/null
+++ b/scd/command.c
@@ -0,0 +1,2130 @@
+/* command.c - SCdaemon command handler
+ * Copyright (C) 2001, 2002, 2003, 2004, 2005,
+ * 2007, 2008, 2009, 2011 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <signal.h>
+#ifdef USE_NPTH
+# include <npth.h>
+#endif
+
+#include "scdaemon.h"
+#include <assuan.h>
+#include <ksba.h>
+#include "iso7816.h"
+#include "apdu.h" /* Required for apdu_*_reader (). */
+#include "atr.h"
+#include "../common/asshelp.h"
+#include "../common/server-help.h"
+
+/* Maximum length allowed as a PIN; used for INQUIRE NEEDPIN */
+#define MAXLEN_PIN 100
+
+/* Maximum allowed size of key data as used in inquiries. */
+#define MAXLEN_KEYDATA 4096
+
+/* Maximum allowed total data size for SETDATA. */
+#define MAXLEN_SETDATA 4096
+
+/* Maximum allowed size of certificate data as used in inquiries. */
+#define MAXLEN_CERTDATA 16384
+
+
+#define set_error(e,t) assuan_set_error (ctx, gpg_error (e), (t))
+
+#define IS_LOCKED(c) (locked_session && locked_session != (c)->server_local)
+
+
+/* Data used to associate an Assuan context with local server data.
+ This object describes the local properties of one session. */
+struct server_local_s
+{
+ /* We keep a list of all active sessions with the anchor at
+ SESSION_LIST (see below). This field is used for linking. */
+ struct server_local_s *next_session;
+
+ /* This object is usually assigned to a CTRL object (which is
+ globally visible). While enumerating all sessions we sometimes
+ need to access data of the CTRL object; thus we keep a
+ backpointer here. */
+ ctrl_t ctrl_backlink;
+
+ /* The Assuan context used by this session/server. */
+ assuan_context_t assuan_ctx;
+
+#ifdef HAVE_W32_SYSTEM
+ void *event_signal; /* Or NULL if not used. */
+#else
+ int event_signal; /* Or 0 if not used. */
+#endif
+
+ /* True if the card has been removed and a reset is required to
+ continue operation. */
+ int card_removed;
+
+ /* If set to true we will be terminate ourself at the end of the
+ this session. */
+ int stopme;
+
+};
+
+
+/* To keep track of all running sessions, we link all active server
+ contexts and the anchor in this variable. */
+static struct server_local_s *session_list;
+
+/* If a session has been locked we store a link to its server object
+ in this variable. */
+static struct server_local_s *locked_session;
+
+
+/* Convert the STRING into a newly allocated buffer while translating
+ the hex numbers. Stops at the first invalid character. Blanks and
+ colons are allowed to separate the hex digits. Returns NULL on
+ error or a newly malloced buffer and its length in LENGTH. */
+static unsigned char *
+hex_to_buffer (const char *string, size_t *r_length)
+{
+ unsigned char *buffer;
+ const char *s;
+ size_t n;
+
+ buffer = xtrymalloc (strlen (string)+1);
+ if (!buffer)
+ return NULL;
+ for (s=string, n=0; *s; s++)
+ {
+ if (spacep (s) || *s == ':')
+ continue;
+ if (hexdigitp (s) && hexdigitp (s+1))
+ {
+ buffer[n++] = xtoi_2 (s);
+ s++;
+ }
+ else
+ break;
+ }
+ *r_length = n;
+ return buffer;
+}
+
+
+
+/* Reset the card and free the application context. With SEND_RESET
+ set to true actually send a RESET to the reader; this is the normal
+ way of calling the function. If KEEP_LOCK is set and the session
+ is locked that lock wil not be released. */
+static void
+do_reset (ctrl_t ctrl, int send_reset, int keep_lock)
+{
+ app_t app = ctrl->app_ctx;
+
+ if (app)
+ app_reset (app, ctrl, IS_LOCKED (ctrl)? 0: send_reset);
+
+ /* If we hold a lock, unlock now. */
+ if (!keep_lock && locked_session && ctrl->server_local == locked_session)
+ {
+ locked_session = NULL;
+ log_info ("implicitly unlocking due to RESET\n");
+ }
+}
+
+static gpg_error_t
+reset_notify (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+
+ do_reset (ctrl, 1, has_option (line, "--keep-lock"));
+ return 0;
+}
+
+
+static gpg_error_t
+option_handler (assuan_context_t ctx, const char *key, const char *value)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+
+ if (!strcmp (key, "event-signal"))
+ {
+ /* A value of 0 is allowed to reset the event signal. */
+#ifdef HAVE_W32_SYSTEM
+ if (!*value)
+ return gpg_error (GPG_ERR_ASS_PARAMETER);
+#ifdef _WIN64
+ ctrl->server_local->event_signal = (void *)strtoull (value, NULL, 16);
+#else
+ ctrl->server_local->event_signal = (void *)strtoul (value, NULL, 16);
+#endif
+#else
+ int i = *value? atoi (value) : -1;
+ if (i < 0)
+ return gpg_error (GPG_ERR_ASS_PARAMETER);
+ ctrl->server_local->event_signal = i;
+#endif
+ }
+
+ return 0;
+}
+
+
+/* If the card has not yet been opened, do it. */
+static gpg_error_t
+open_card (ctrl_t ctrl)
+{
+ /* If we ever got a card not present error code, return that. Only
+ the SERIALNO command and a reset are able to clear from that
+ state. */
+ if (ctrl->server_local->card_removed)
+ return gpg_error (GPG_ERR_CARD_REMOVED);
+
+ if ( IS_LOCKED (ctrl) )
+ return gpg_error (GPG_ERR_LOCKED);
+
+ if (ctrl->app_ctx)
+ return 0;
+
+ return select_application (ctrl, NULL, &ctrl->app_ctx, 0, NULL, 0);
+}
+
+/* Explicitly open a card for a specific use of APPTYPE or SERIALNO. */
+static gpg_error_t
+open_card_with_request (ctrl_t ctrl, const char *apptype, const char *serialno)
+{
+ gpg_error_t err;
+ unsigned char *serialno_bin = NULL;
+ size_t serialno_bin_len = 0;
+ app_t app = ctrl->app_ctx;
+
+ /* If we are already initialized for one specific application we
+ need to check that the client didn't requested a specific
+ application different from the one in use before we continue. */
+ if (apptype && ctrl->app_ctx)
+ return check_application_conflict (apptype, ctrl->app_ctx);
+
+ /* Re-scan USB devices. Release APP, before the scan. */
+ ctrl->app_ctx = NULL;
+ release_application (app, 0);
+
+ if (serialno)
+ serialno_bin = hex_to_buffer (serialno, &serialno_bin_len);
+
+ err = select_application (ctrl, apptype, &ctrl->app_ctx, 1,
+ serialno_bin, serialno_bin_len);
+ xfree (serialno_bin);
+
+ return err;
+}
+
+
+static const char hlp_serialno[] =
+ "SERIALNO [--demand=<serialno>] [<apptype>]\n"
+ "\n"
+ "Return the serial number of the card using a status response. This\n"
+ "function should be used to check for the presence of a card.\n"
+ "\n"
+ "If --demand is given, an application on the card with SERIALNO is\n"
+ "selected and an error is returned if no such card available.\n"
+ "\n"
+ "If APPTYPE is given, an application of that type is selected and an\n"
+ "error is returned if the application is not supported or available.\n"
+ "The default is to auto-select the application using a hardwired\n"
+ "preference system. Note, that a future extension to this function\n"
+ "may enable specifying a list and order of applications to try.\n"
+ "\n"
+ "This function is special in that it can be used to reset the card.\n"
+ "Most other functions will return an error when a card change has\n"
+ "been detected and the use of this function is therefore required.\n"
+ "\n"
+ "Background: We want to keep the client clear of handling card\n"
+ "changes between operations; i.e. the client can assume that all\n"
+ "operations are done on the same card unless he calls this function.";
+static gpg_error_t
+cmd_serialno (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ struct server_local_s *sl;
+ int rc = 0;
+ char *serial;
+ const char *demand;
+
+ if ( IS_LOCKED (ctrl) )
+ return gpg_error (GPG_ERR_LOCKED);
+
+ if ((demand = has_option_name (line, "--demand")))
+ {
+ if (*demand != '=')
+ return set_error (GPG_ERR_ASS_PARAMETER, "missing value for option");
+ line = (char *)++demand;
+ for (; *line && !spacep (line); line++)
+ ;
+ if (*line)
+ *line++ = 0;
+ }
+ else
+ demand = NULL;
+
+ line = skip_options (line);
+
+ /* Clear the remove flag so that the open_card is able to reread it. */
+ if (ctrl->server_local->card_removed)
+ ctrl->server_local->card_removed = 0;
+
+ if ((rc = open_card_with_request (ctrl, *line? line:NULL, demand)))
+ {
+ ctrl->server_local->card_removed = 1;
+ return rc;
+ }
+
+ /* Success, clear the card_removed flag for all sessions. */
+ for (sl=session_list; sl; sl = sl->next_session)
+ {
+ ctrl_t c = sl->ctrl_backlink;
+
+ if (c != ctrl)
+ c->server_local->card_removed = 0;
+ }
+
+ serial = app_get_serialno (ctrl->app_ctx);
+ if (!serial)
+ return gpg_error (GPG_ERR_INV_VALUE);
+
+ rc = assuan_write_status (ctx, "SERIALNO", serial);
+ xfree (serial);
+ return rc;
+}
+
+
+static const char hlp_learn[] =
+ "LEARN [--force] [--keypairinfo]\n"
+ "\n"
+ "Learn all useful information of the currently inserted card. When\n"
+ "used without the force options, the command might do an INQUIRE\n"
+ "like this:\n"
+ "\n"
+ " INQUIRE KNOWNCARDP <hexstring_with_serialNumber>\n"
+ "\n"
+ "The client should just send an \"END\" if the processing should go on\n"
+ "or a \"CANCEL\" to force the function to terminate with a Cancel\n"
+ "error message.\n"
+ "\n"
+ "With the option --keypairinfo only KEYPARIINFO status lines are\n"
+ "returned.\n"
+ "\n"
+ "The response of this command is a list of status lines formatted as\n"
+ "this:\n"
+ "\n"
+ " S APPTYPE <apptype>\n"
+ "\n"
+ "This returns the type of the application, currently the strings:\n"
+ "\n"
+ " P15 = PKCS-15 structure used\n"
+ " DINSIG = DIN SIG\n"
+ " OPENPGP = OpenPGP card\n"
+ " PIV = PIV card\n"
+ " NKS = NetKey card\n"
+ "\n"
+ "are implemented. These strings are aliases for the AID\n"
+ "\n"
+ " S KEYPAIRINFO <hexstring_with_keygrip> <hexstring_with_id>\n"
+ "\n"
+ "If there is no certificate yet stored on the card a single 'X' is\n"
+ "returned as the keygrip. In addition to the keypair info, information\n"
+ "about all certificates stored on the card is also returned:\n"
+ "\n"
+ " S CERTINFO <certtype> <hexstring_with_id>\n"
+ "\n"
+ "Where CERTTYPE is a number indicating the type of certificate:\n"
+ " 0 := Unknown\n"
+ " 100 := Regular X.509 cert\n"
+ " 101 := Trusted X.509 cert\n"
+ " 102 := Useful X.509 cert\n"
+ " 110 := Root CA cert in a special format (e.g. DINSIG)\n"
+ " 111 := Root CA cert as standard X509 cert.\n"
+ "\n"
+ "For certain cards, more information will be returned:\n"
+ "\n"
+ " S KEY-FPR <no> <hexstring>\n"
+ "\n"
+ "For OpenPGP cards this returns the stored fingerprints of the\n"
+ "keys. This can be used check whether a key is available on the\n"
+ "card. NO may be 1, 2 or 3.\n"
+ "\n"
+ " S CA-FPR <no> <hexstring>\n"
+ "\n"
+ "Similar to above, these are the fingerprints of keys assumed to be\n"
+ "ultimately trusted.\n"
+ "\n"
+ " S DISP-NAME <name_of_card_holder>\n"
+ "\n"
+ "The name of the card holder as stored on the card; percent\n"
+ "escaping takes place, spaces are encoded as '+'\n"
+ "\n"
+ " S PUBKEY-URL <url>\n"
+ "\n"
+ "The URL to be used for locating the entire public key.\n"
+ " \n"
+ "Note, that this function may even be used on a locked card.";
+static gpg_error_t
+cmd_learn (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc = 0;
+ int only_keypairinfo = has_option (line, "--keypairinfo");
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ /* Unless the force option is used we try a shortcut by identifying
+ the card using a serial number and inquiring the client with
+ that. The client may choose to cancel the operation if he already
+ knows about this card */
+ if (!only_keypairinfo)
+ {
+ const char *reader;
+ char *serial;
+ app_t app = ctrl->app_ctx;
+
+ if (!app)
+ return gpg_error (GPG_ERR_CARD_NOT_PRESENT);
+
+ reader = apdu_get_reader_name (app->slot);
+ if (!reader)
+ return out_of_core ();
+ send_status_direct (ctrl, "READER", reader);
+ /* No need to free the string of READER. */
+
+ serial = app_get_serialno (ctrl->app_ctx);
+ if (!serial)
+ return gpg_error (GPG_ERR_INV_VALUE);
+
+ rc = assuan_write_status (ctx, "SERIALNO", serial);
+ if (rc < 0)
+ {
+ xfree (serial);
+ return out_of_core ();
+ }
+
+ if (!has_option (line, "--force"))
+ {
+ char *command;
+
+ rc = gpgrt_asprintf (&command, "KNOWNCARDP %s", serial);
+ if (rc < 0)
+ {
+ xfree (serial);
+ return out_of_core ();
+ }
+ rc = assuan_inquire (ctx, command, NULL, NULL, 0);
+ xfree (command);
+ if (rc)
+ {
+ if (gpg_err_code (rc) != GPG_ERR_ASS_CANCELED)
+ log_error ("inquire KNOWNCARDP failed: %s\n",
+ gpg_strerror (rc));
+ xfree (serial);
+ return rc;
+ }
+ /* Not canceled, so we have to proceed. */
+ }
+ xfree (serial);
+ }
+
+ /* Let the application print out its collection of useful status
+ information. */
+ if (!rc)
+ rc = app_write_learn_status (ctrl->app_ctx, ctrl, only_keypairinfo);
+
+ return rc;
+}
+
+
+
+static const char hlp_readcert[] =
+ "READCERT <hexified_certid>|<keyid>\n"
+ "\n"
+ "Note, that this function may even be used on a locked card.";
+static gpg_error_t
+cmd_readcert (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ unsigned char *cert;
+ size_t ncert;
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ line = xstrdup (line); /* Need a copy of the line. */
+ rc = app_readcert (ctrl->app_ctx, ctrl, line, &cert, &ncert);
+ if (rc)
+ log_error ("app_readcert failed: %s\n", gpg_strerror (rc));
+ xfree (line);
+ line = NULL;
+ if (!rc)
+ {
+ rc = assuan_send_data (ctx, cert, ncert);
+ xfree (cert);
+ if (rc)
+ return rc;
+ }
+
+ return rc;
+}
+
+
+static const char hlp_readkey[] =
+ "READKEY [--advanced] [--info[-only]] <keyid>\n"
+ "\n"
+ "Return the public key for the given cert or key ID as a standard\n"
+ "S-expression. With --advanced the S-expression is returned in\n"
+ "advanced format. With --info a KEYPAIRINFO status line is also\n"
+ "emitted; with --info-only the regular output is suppressed.";
+static gpg_error_t
+cmd_readkey (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ int advanced = 0;
+ int opt_info = 0;
+ int opt_nokey = 0;
+ unsigned char *cert = NULL;
+ size_t ncert;
+ unsigned char *pk;
+ size_t pklen;
+ int direct_readkey = 0;
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ if (has_option (line, "--advanced"))
+ advanced = 1;
+ if (has_option (line, "--info"))
+ opt_info = 1;
+ if (has_option (line, "--info-only"))
+ opt_info = opt_nokey = 1;
+
+ line = skip_options (line);
+ line = xstrdup (line); /* Need a copy of the line. */
+
+ /* If the application supports the READKEY function we use that.
+ Otherwise we use the old way by extracting it from the
+ certificate. */
+ rc = app_readkey (ctrl->app_ctx, ctrl, advanced, line, &pk, &pklen);
+ if (!rc)
+ direct_readkey = 1; /* Yeah, got that key - send it back. */
+ else if (gpg_err_code (rc) == GPG_ERR_UNSUPPORTED_OPERATION
+ || gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
+ {
+ /* Fall back to certificate reading. */
+ rc = app_readcert (ctrl->app_ctx, ctrl, line, &cert, &ncert);
+ if (rc)
+ log_error ("app_readcert failed: %s\n", gpg_strerror (rc));
+ else
+ {
+ rc = app_help_pubkey_from_cert (cert, ncert, &pk, &pklen);
+ if (rc)
+ log_error ("failed to parse the certificate: %s\n",
+ gpg_strerror (rc));
+ }
+ }
+ else
+ log_error ("app_readkey failed: %s\n", gpg_strerror (rc));
+
+ if (!rc && pk && pklen && opt_info && !direct_readkey)
+ {
+ char keygripstr[KEYGRIP_LEN*2+1];
+ char *algostr;
+
+ rc = app_help_get_keygrip_string_pk (pk, pklen,
+ keygripstr, NULL, NULL,
+ &algostr);
+ if (rc)
+ {
+ log_error ("app_help_get_keygrip_string failed: %s\n",
+ gpg_strerror (rc));
+ goto leave;
+ }
+
+ /* FIXME: Using LINE is not correct because it might be an
+ * OID and has not been canonicalized (i.e. uppercased). */
+ send_status_info (ctrl, "KEYPAIRINFO",
+ keygripstr, strlen (keygripstr),
+ line, strlen (line),
+ "-", (size_t)1,
+ "-", (size_t)1,
+ algostr, strlen (algostr),
+ NULL, (size_t)0);
+ xfree (algostr);
+ }
+
+
+ if (!rc && pk && pklen && !opt_nokey)
+ rc = assuan_send_data (ctx, pk, pklen);
+
+ leave:
+ xfree (cert);
+ xfree (pk);
+ xfree (line);
+ return rc;
+}
+
+
+
+static const char hlp_setdata[] =
+ "SETDATA [--append] <hexstring>\n"
+ "\n"
+ "The client should use this command to tell us the data he want to sign.\n"
+ "With the option --append, the data is appended to the data set by a\n"
+ "previous SETDATA command.";
+static gpg_error_t
+cmd_setdata (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int append;
+ int n, i, off;
+ char *p;
+ unsigned char *buf;
+
+ append = (ctrl->in_data.value && has_option (line, "--append"));
+
+ line = skip_options (line);
+
+ if (locked_session && locked_session != ctrl->server_local)
+ return gpg_error (GPG_ERR_LOCKED);
+
+ /* Parse the hexstring. */
+ for (p=line,n=0; hexdigitp (p); p++, n++)
+ ;
+ if (*p)
+ return set_error (GPG_ERR_ASS_PARAMETER, "invalid hexstring");
+ if (!n)
+ return set_error (GPG_ERR_ASS_PARAMETER, "no data given");
+ if ((n&1))
+ return set_error (GPG_ERR_ASS_PARAMETER, "odd number of digits");
+ n /= 2;
+ if (append)
+ {
+ if (ctrl->in_data.valuelen + n > MAXLEN_SETDATA)
+ return set_error (GPG_ERR_TOO_LARGE,
+ "limit on total size of data reached");
+ buf = xtrymalloc (ctrl->in_data.valuelen + n);
+ }
+ else
+ buf = xtrymalloc (n);
+ if (!buf)
+ return out_of_core ();
+
+ if (append)
+ {
+ memcpy (buf, ctrl->in_data.value, ctrl->in_data.valuelen);
+ off = ctrl->in_data.valuelen;
+ }
+ else
+ off = 0;
+ for (p=line, i=0; i < n; p += 2, i++)
+ buf[off+i] = xtoi_2 (p);
+
+ xfree (ctrl->in_data.value);
+ ctrl->in_data.value = buf;
+ ctrl->in_data.valuelen = off+n;
+ return 0;
+}
+
+
+
+static gpg_error_t
+pin_cb (void *opaque, const char *info, char **retstr)
+{
+ assuan_context_t ctx = opaque;
+ char *command;
+ int rc;
+ unsigned char *value;
+ size_t valuelen;
+
+ if (!retstr)
+ {
+ /* We prompt for pinpad entry. To make sure that the popup has
+ been show we use an inquire and not just a status message.
+ We ignore any value returned. */
+ if (info)
+ {
+ log_debug ("prompting for pinpad entry '%s'\n", info);
+ rc = gpgrt_asprintf (&command, "POPUPPINPADPROMPT %s", info);
+ if (rc < 0)
+ return gpg_error (gpg_err_code_from_errno (errno));
+ rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN);
+ xfree (command);
+ }
+ else
+ {
+ log_debug ("dismiss pinpad entry prompt\n");
+ rc = assuan_inquire (ctx, "DISMISSPINPADPROMPT",
+ &value, &valuelen, MAXLEN_PIN);
+ }
+ if (!rc)
+ xfree (value);
+ return rc;
+ }
+
+ *retstr = NULL;
+ log_debug ("asking for PIN '%s'\n", info);
+
+ rc = gpgrt_asprintf (&command, "NEEDPIN %s", info);
+ if (rc < 0)
+ return gpg_error (gpg_err_code_from_errno (errno));
+
+ /* Fixme: Write an inquire function which returns the result in
+ secure memory and check all further handling of the PIN. */
+ assuan_begin_confidential (ctx);
+ rc = assuan_inquire (ctx, command, &value, &valuelen, MAXLEN_PIN);
+ assuan_end_confidential (ctx);
+ xfree (command);
+ if (rc)
+ return rc;
+
+ if (!valuelen || value[valuelen-1])
+ {
+ /* We require that the returned value is an UTF-8 string */
+ xfree (value);
+ return gpg_error (GPG_ERR_INV_RESPONSE);
+ }
+ *retstr = (char*)value;
+ return 0;
+}
+
+
+static const char hlp_pksign[] =
+ "PKSIGN [--hash=[rmd160|sha{1,224,256,384,512}|md5]] <hexified_id>\n"
+ "\n"
+ "The --hash option is optional; the default is SHA1.";
+static gpg_error_t
+cmd_pksign (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ unsigned char *outdata;
+ size_t outdatalen;
+ char *keyidstr;
+ int hash_algo;
+
+ if (has_option (line, "--hash=rmd160"))
+ hash_algo = GCRY_MD_RMD160;
+ else if (has_option (line, "--hash=sha1"))
+ hash_algo = GCRY_MD_SHA1;
+ else if (has_option (line, "--hash=sha224"))
+ hash_algo = GCRY_MD_SHA224;
+ else if (has_option (line, "--hash=sha256"))
+ hash_algo = GCRY_MD_SHA256;
+ else if (has_option (line, "--hash=sha384"))
+ hash_algo = GCRY_MD_SHA384;
+ else if (has_option (line, "--hash=sha512"))
+ hash_algo = GCRY_MD_SHA512;
+ else if (has_option (line, "--hash=md5"))
+ hash_algo = GCRY_MD_MD5;
+ else if (!strstr (line, "--"))
+ hash_algo = GCRY_MD_SHA1;
+ else
+ return set_error (GPG_ERR_ASS_PARAMETER, "invalid hash algorithm");
+
+ line = skip_options (line);
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ /* We have to use a copy of the key ID because the function may use
+ the pin_cb which in turn uses the assuan line buffer and thus
+ overwriting the original line with the keyid */
+ keyidstr = xtrystrdup (line);
+ if (!keyidstr)
+ return out_of_core ();
+
+ rc = app_sign (ctrl->app_ctx, ctrl,
+ keyidstr, hash_algo,
+ pin_cb, ctx,
+ ctrl->in_data.value, ctrl->in_data.valuelen,
+ &outdata, &outdatalen);
+
+ xfree (keyidstr);
+ if (rc)
+ {
+ log_error ("app_sign failed: %s\n", gpg_strerror (rc));
+ }
+ else
+ {
+ rc = assuan_send_data (ctx, outdata, outdatalen);
+ xfree (outdata);
+ if (rc)
+ return rc; /* that is already an assuan error code */
+ }
+
+ return rc;
+}
+
+
+static const char hlp_pkauth[] =
+ "PKAUTH <hexified_id>";
+static gpg_error_t
+cmd_pkauth (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ unsigned char *outdata;
+ size_t outdatalen;
+ char *keyidstr;
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ if (!ctrl->app_ctx)
+ return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+
+ /* We have to use a copy of the key ID because the function may use
+ the pin_cb which in turn uses the assuan line buffer and thus
+ overwriting the original line with the keyid */
+ keyidstr = xtrystrdup (line);
+ if (!keyidstr)
+ return out_of_core ();
+
+ rc = app_auth (ctrl->app_ctx, ctrl, keyidstr, pin_cb, ctx,
+ ctrl->in_data.value, ctrl->in_data.valuelen,
+ &outdata, &outdatalen);
+ xfree (keyidstr);
+ if (rc)
+ {
+ log_error ("app_auth failed: %s\n", gpg_strerror (rc));
+ }
+ else
+ {
+ rc = assuan_send_data (ctx, outdata, outdatalen);
+ xfree (outdata);
+ if (rc)
+ return rc; /* that is already an assuan error code */
+ }
+
+ return rc;
+}
+
+
+static const char hlp_pkdecrypt[] =
+ "PKDECRYPT <hexified_id>";
+static gpg_error_t
+cmd_pkdecrypt (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ unsigned char *outdata;
+ size_t outdatalen;
+ char *keyidstr;
+ unsigned int infoflags;
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ keyidstr = xtrystrdup (line);
+ if (!keyidstr)
+ return out_of_core ();
+ rc = app_decipher (ctrl->app_ctx, ctrl, keyidstr, pin_cb, ctx,
+ ctrl->in_data.value, ctrl->in_data.valuelen,
+ &outdata, &outdatalen, &infoflags);
+
+ xfree (keyidstr);
+ if (rc)
+ {
+ log_error ("app_decipher failed: %s\n", gpg_strerror (rc));
+ }
+ else
+ {
+ /* If the card driver told us that there is no padding, send a
+ status line. If there is a padding it is assumed that the
+ caller knows what padding is used. It would have been better
+ to always send that information but for backward
+ compatibility we can't do that. */
+ if ((infoflags & APP_DECIPHER_INFO_NOPAD))
+ send_status_direct (ctrl, "PADDING", "0");
+ rc = assuan_send_data (ctx, outdata, outdatalen);
+ xfree (outdata);
+ if (rc)
+ return rc; /* that is already an assuan error code */
+ }
+
+ return rc;
+}
+
+
+static const char hlp_getattr[] =
+ "GETATTR <name>\n"
+ "\n"
+ "This command is used to retrieve data from a smartcard. The\n"
+ "allowed names depend on the currently selected smartcard\n"
+ "application. NAME must be percent and '+' escaped. The value is\n"
+ "returned through status message, see the LEARN command for details.\n"
+ "\n"
+ "However, the current implementation assumes that Name is not escaped;\n"
+ "this works as long as no one uses arbitrary escaping. \n"
+ "\n"
+ "Note, that this function may even be used on a locked card.";
+static gpg_error_t
+cmd_getattr (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ const char *keyword;
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ keyword = line;
+ for (; *line && !spacep (line); line++)
+ ;
+ if (*line)
+ *line++ = 0;
+
+ /* (We ignore any garbage for now.) */
+
+ /* FIXME: Applications should not return sensitive data if the card
+ is locked. */
+ rc = app_getattr (ctrl->app_ctx, ctrl, keyword);
+
+ return rc;
+}
+
+
+static const char hlp_setattr[] =
+ "SETATTR <name> <value> \n"
+ "\n"
+ "This command is used to store data on a smartcard. The allowed\n"
+ "names and values are depend on the currently selected smartcard\n"
+ "application. NAME and VALUE must be percent and '+' escaped.\n"
+ "\n"
+ "However, the current implementation assumes that NAME is not\n"
+ "escaped; this works as long as no one uses arbitrary escaping.\n"
+ "\n"
+ "A PIN will be requested for most NAMEs. See the corresponding\n"
+ "setattr function of the actually used application (app-*.c) for\n"
+ "details.";
+static gpg_error_t
+cmd_setattr (assuan_context_t ctx, char *orig_line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ char *keyword;
+ int keywordlen;
+ size_t nbytes;
+ char *line, *linebuf;
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ /* We need to use a copy of LINE, because PIN_CB uses the same
+ context and thus reuses the Assuan provided LINE. */
+ line = linebuf = xtrystrdup (orig_line);
+ if (!line)
+ return out_of_core ();
+
+ keyword = line;
+ for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
+ ;
+ if (*line)
+ *line++ = 0;
+ while (spacep (line))
+ line++;
+ nbytes = percent_plus_unescape_inplace (line, 0);
+
+ rc = app_setattr (ctrl->app_ctx, ctrl, keyword, pin_cb, ctx,
+ (const unsigned char*)line, nbytes);
+ xfree (linebuf);
+
+ return rc;
+}
+
+
+static const char hlp_writecert[] =
+ "WRITECERT <hexified_certid>\n"
+ "\n"
+ "This command is used to store a certifciate on a smartcard. The\n"
+ "allowed certids depend on the currently selected smartcard\n"
+ "application. The actual certifciate is requested using the inquiry\n"
+ "\"CERTDATA\" and needs to be provided in its raw (e.g. DER) form.\n"
+ "\n"
+ "In almost all cases a PIN will be requested. See the related\n"
+ "writecert function of the actually used application (app-*.c) for\n"
+ "details.";
+static gpg_error_t
+cmd_writecert (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ char *certid;
+ unsigned char *certdata;
+ size_t certdatalen;
+
+ line = skip_options (line);
+
+ if (!*line)
+ return set_error (GPG_ERR_ASS_PARAMETER, "no certid given");
+ certid = line;
+ while (*line && !spacep (line))
+ line++;
+ *line = 0;
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ if (!ctrl->app_ctx)
+ return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+
+ certid = xtrystrdup (certid);
+ if (!certid)
+ return out_of_core ();
+
+ /* Now get the actual keydata. */
+ rc = assuan_inquire (ctx, "CERTDATA",
+ &certdata, &certdatalen, MAXLEN_CERTDATA);
+ if (rc)
+ {
+ xfree (certid);
+ return rc;
+ }
+
+ /* Write the certificate to the card. */
+ rc = app_writecert (ctrl->app_ctx, ctrl, certid,
+ pin_cb, ctx, certdata, certdatalen);
+ xfree (certid);
+ xfree (certdata);
+
+ return rc;
+}
+
+
+static const char hlp_writekey[] =
+ "WRITEKEY [--force] <keyid> \n"
+ "\n"
+ "This command is used to store a secret key on a smartcard. The\n"
+ "allowed keyids depend on the currently selected smartcard\n"
+ "application. The actual keydata is requested using the inquiry\n"
+ "\"KEYDATA\" and need to be provided without any protection. With\n"
+ "--force set an existing key under this KEYID will get overwritten.\n"
+ "The keydata is expected to be the usual canonical encoded\n"
+ "S-expression.\n"
+ "\n"
+ "A PIN will be requested for most NAMEs. See the corresponding\n"
+ "writekey function of the actually used application (app-*.c) for\n"
+ "details.";
+static gpg_error_t
+cmd_writekey (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ char *keyid;
+ int force = has_option (line, "--force");
+ unsigned char *keydata;
+ size_t keydatalen;
+
+ line = skip_options (line);
+
+ if (!*line)
+ return set_error (GPG_ERR_ASS_PARAMETER, "no keyid given");
+ keyid = line;
+ while (*line && !spacep (line))
+ line++;
+ *line = 0;
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ if (!ctrl->app_ctx)
+ return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+
+ keyid = xtrystrdup (keyid);
+ if (!keyid)
+ return out_of_core ();
+
+ /* Now get the actual keydata. */
+ assuan_begin_confidential (ctx);
+ rc = assuan_inquire (ctx, "KEYDATA", &keydata, &keydatalen, MAXLEN_KEYDATA);
+ assuan_end_confidential (ctx);
+ if (rc)
+ {
+ xfree (keyid);
+ return rc;
+ }
+
+ /* Write the key to the card. */
+ rc = app_writekey (ctrl->app_ctx, ctrl, keyid, force? 1:0,
+ pin_cb, ctx, keydata, keydatalen);
+ xfree (keyid);
+ xfree (keydata);
+
+ return rc;
+}
+
+
+static const char hlp_genkey[] =
+ "GENKEY [--force] [--timestamp=<isodate>] <no>\n"
+ "\n"
+ "Generate a key on-card identified by NO, which is application\n"
+ "specific. Return values are application specific. For OpenPGP\n"
+ "cards 3 status lines are returned:\n"
+ "\n"
+ " S KEY-FPR <hexstring>\n"
+ " S KEY-CREATED-AT <seconds_since_epoch>\n"
+ " S KEY-DATA [-|p|n] <hexdata>\n"
+ "\n"
+ " 'p' and 'n' are the names of the RSA parameters; '-' is used to\n"
+ " indicate that HEXDATA is the first chunk of a parameter given\n"
+ " by the next KEY-DATA.\n"
+ "\n"
+ "--force is required to overwrite an already existing key. The\n"
+ "KEY-CREATED-AT is required for further processing because it is\n"
+ "part of the hashed key material for the fingerprint.\n"
+ "\n"
+ "If --timestamp is given an OpenPGP key will be created using this\n"
+ "value. The value needs to be in ISO Format; e.g.\n"
+ "\"--timestamp=20030316T120000\" and after 1970-01-01 00:00:00.\n"
+ "\n"
+ "The public part of the key can also later be retrieved using the\n"
+ "READKEY command.";
+static gpg_error_t
+cmd_genkey (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ char *save_line;
+ int force;
+ const char *s;
+ time_t timestamp;
+
+ force = has_option (line, "--force");
+
+ if ((s=has_option_name (line, "--timestamp")))
+ {
+ if (*s != '=')
+ return set_error (GPG_ERR_ASS_PARAMETER, "missing value for option");
+ timestamp = isotime2epoch (s+1);
+ if (timestamp < 1)
+ return set_error (GPG_ERR_ASS_PARAMETER, "invalid time value");
+ }
+ else
+ timestamp = 0;
+
+
+ line = skip_options (line);
+ if (!*line)
+ {
+ rc = set_error (GPG_ERR_ASS_PARAMETER, "no key number given");
+ goto leave;
+ }
+ save_line = line;
+ while (*line && !spacep (line))
+ line++;
+ *line = 0;
+
+ if ((rc = open_card (ctrl)))
+ goto leave;
+
+ if (!ctrl->app_ctx)
+ {
+ rc = gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+ goto leave;
+ }
+
+ {
+ char *tmp = xtrystrdup (save_line);
+ if (!tmp)
+ return gpg_error_from_syserror ();
+ rc = app_genkey (ctrl->app_ctx, ctrl, tmp, NULL,
+ force? APP_GENKEY_FLAG_FORCE : 0,
+ timestamp, pin_cb, ctx);
+ xfree (tmp);
+ }
+
+ leave:
+ return rc;
+}
+
+
+static const char hlp_random[] =
+ "RANDOM <nbytes>\n"
+ "\n"
+ "Get NBYTES of random from the card and send them back as data.\n"
+ "This usually involves EEPROM write on the card and thus excessive\n"
+ "use of this command may destroy the card.\n"
+ "\n"
+ "Note, that this function may be even be used on a locked card.";
+static gpg_error_t
+cmd_random (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ size_t nbytes;
+ unsigned char *buffer;
+
+ if (!*line)
+ return set_error (GPG_ERR_ASS_PARAMETER,
+ "number of requested bytes missing");
+ nbytes = strtoul (line, NULL, 0);
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ if (!ctrl->app_ctx)
+ return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+
+ buffer = xtrymalloc (nbytes);
+ if (!buffer)
+ return out_of_core ();
+
+ rc = app_get_challenge (ctrl->app_ctx, ctrl, nbytes, buffer);
+ if (!rc)
+ {
+ rc = assuan_send_data (ctx, buffer, nbytes);
+ xfree (buffer);
+ return rc; /* that is already an assuan error code */
+ }
+ xfree (buffer);
+
+ return rc;
+}
+
+
+
+static const char hlp_passwd[] =
+ "PASSWD [--reset] [--nullpin] [--clear] <chvno>\n"
+ "\n"
+ "Change the PIN or, if --reset is given, reset the retry counter of\n"
+ "the card holder verification vector CHVNO. The option --nullpin is\n"
+ "used for TCOS cards to set the initial PIN. The option --clear clears\n"
+ "the security status associated with the PIN so that the PIN needs to\n"
+ "be presented again. The format of CHVNO depends on the card application.";
+static gpg_error_t
+cmd_passwd (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ char *chvnostr;
+ unsigned int flags = 0;
+
+ if (has_option (line, "--reset"))
+ flags |= APP_CHANGE_FLAG_RESET;
+ if (has_option (line, "--nullpin"))
+ flags |= APP_CHANGE_FLAG_NULLPIN;
+ if (has_option (line, "--clear"))
+ flags |= APP_CHANGE_FLAG_CLEAR;
+
+ line = skip_options (line);
+
+ if (!*line)
+ return set_error (GPG_ERR_ASS_PARAMETER, "no CHV number given");
+ chvnostr = line;
+ while (*line && !spacep (line))
+ line++;
+ *line = 0;
+
+ /* Do not allow other flags aside of --clear. */
+ if ((flags & APP_CHANGE_FLAG_CLEAR) && (flags & ~APP_CHANGE_FLAG_CLEAR))
+ return set_error (GPG_ERR_UNSUPPORTED_OPERATION,
+ "--clear used with other options");
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ if (!ctrl->app_ctx)
+ return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+
+ chvnostr = xtrystrdup (chvnostr);
+ if (!chvnostr)
+ return out_of_core ();
+ rc = app_change_pin (ctrl->app_ctx, ctrl, chvnostr, flags, pin_cb, ctx);
+ if (rc)
+ log_error ("command passwd failed: %s\n", gpg_strerror (rc));
+ xfree (chvnostr);
+
+ return rc;
+}
+
+
+static const char hlp_checkpin[] =
+ "CHECKPIN <idstr>\n"
+ "\n"
+ "Perform a VERIFY operation without doing anything else. This may\n"
+ "be used to initialize a the PIN cache earlier to long lasting\n"
+ "operations. Its use is highly application dependent.\n"
+ "\n"
+ "For OpenPGP:\n"
+ "\n"
+ " Perform a simple verify operation for CHV1 and CHV2, so that\n"
+ " further operations won't ask for CHV2 and it is possible to do a\n"
+ " cheap check on the PIN: If there is something wrong with the PIN\n"
+ " entry system, only the regular CHV will get blocked and not the\n"
+ " dangerous CHV3. IDSTR is the usual card's serial number in hex\n"
+ " notation; an optional fingerprint part will get ignored. There\n"
+ " is however a special mode if the IDSTR is suffixed with the\n"
+ " literal string \"[CHV3]\": In this case the Admin PIN is checked\n"
+ " if and only if the retry counter is still at 3.\n"
+ "\n"
+ "For Netkey:\n"
+ "\n"
+ " Any of the valid PIN Ids may be used. These are the strings:\n"
+ "\n"
+ " PW1.CH - Global password 1\n"
+ " PW2.CH - Global password 2\n"
+ " PW1.CH.SIG - SigG password 1\n"
+ " PW2.CH.SIG - SigG password 2\n"
+ "\n"
+ " For a definitive list, see the implementation in app-nks.c.\n"
+ " Note that we call a PW2.* PIN a \"PUK\" despite that since TCOS\n"
+ " 3.0 they are technically alternative PINs used to mutally\n"
+ " unblock each other.";
+static gpg_error_t
+cmd_checkpin (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc;
+ char *idstr;
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ if (!ctrl->app_ctx)
+ return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+
+ /* We have to use a copy of the key ID because the function may use
+ the pin_cb which in turn uses the assuan line buffer and thus
+ overwriting the original line with the keyid. */
+ idstr = xtrystrdup (line);
+ if (!idstr)
+ return out_of_core ();
+
+ rc = app_check_pin (ctrl->app_ctx, ctrl, idstr, pin_cb, ctx);
+ xfree (idstr);
+ if (rc)
+ log_error ("app_check_pin failed: %s\n", gpg_strerror (rc));
+
+ return rc;
+}
+
+
+static const char hlp_lock[] =
+ "LOCK [--wait]\n"
+ "\n"
+ "Grant exclusive card access to this session. Note that there is\n"
+ "no lock counter used and a second lock from the same session will\n"
+ "be ignored. A single unlock (or RESET) unlocks the session.\n"
+ "Return GPG_ERR_LOCKED if another session has locked the reader.\n"
+ "\n"
+ "If the option --wait is given the command will wait until a\n"
+ "lock has been released.";
+static gpg_error_t
+cmd_lock (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc = 0;
+
+ retry:
+ if (locked_session)
+ {
+ if (locked_session != ctrl->server_local)
+ rc = gpg_error (GPG_ERR_LOCKED);
+ }
+ else
+ locked_session = ctrl->server_local;
+
+#ifdef USE_NPTH
+ if (rc && has_option (line, "--wait"))
+ {
+ rc = 0;
+ npth_sleep (1); /* Better implement an event mechanism. However,
+ for card operations this should be
+ sufficient. */
+ /* Send a progress so that we can detect a connection loss. */
+ rc = send_status_printf (ctrl, "PROGRESS", "scd_locked . 0 0");
+ if (!rc)
+ goto retry;
+ }
+#endif /*USE_NPTH*/
+
+ if (rc)
+ log_error ("cmd_lock failed: %s\n", gpg_strerror (rc));
+ return rc;
+}
+
+
+static const char hlp_unlock[] =
+ "UNLOCK\n"
+ "\n"
+ "Release exclusive card access.";
+static gpg_error_t
+cmd_unlock (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ int rc = 0;
+
+ (void)line;
+
+ if (locked_session)
+ {
+ if (locked_session != ctrl->server_local)
+ rc = gpg_error (GPG_ERR_LOCKED);
+ else
+ locked_session = NULL;
+ }
+ else
+ rc = gpg_error (GPG_ERR_NOT_LOCKED);
+
+ if (rc)
+ log_error ("cmd_unlock failed: %s\n", gpg_strerror (rc));
+ return rc;
+}
+
+
+/* Ease reading of Assuan data ;ines by sending a physical line after
+ * each LF. */
+static gpg_error_t
+pretty_assuan_send_data (assuan_context_t ctx,
+ const void *buffer_arg, size_t size)
+{
+ const char *buffer = buffer_arg;
+ const char *p;
+ size_t n, nbytes;
+ gpg_error_t err;
+
+ nbytes = size;
+ do
+ {
+ p = memchr (buffer, '\n', nbytes);
+ n = p ? (p - buffer) + 1 : nbytes;
+ err = assuan_send_data (ctx, buffer, n);
+ if (err)
+ {
+ /* We also set ERRNO in case this function is used by a
+ * custom estream I/O handler. */
+ gpg_err_set_errno (EIO);
+ goto leave;
+ }
+ buffer += n;
+ nbytes -= n;
+ if (nbytes && (err=assuan_send_data (ctx, NULL, 0))) /* Flush line. */
+ {
+ gpg_err_set_errno (EIO);
+ goto leave;
+ }
+ }
+ while (nbytes);
+
+ leave:
+ return err;
+}
+
+
+static const char hlp_getinfo[] =
+ "GETINFO <what>\n"
+ "\n"
+ "Multi purpose command to return certain information. \n"
+ "Supported values of WHAT are:\n"
+ "\n"
+ " version - Return the version of the program.\n"
+ " pid - Return the process id of the server.\n"
+ " socket_name - Return the name of the socket.\n"
+ " connections - Return number of active connections.\n"
+ " status - Return the status of the current reader (in the future,\n"
+ " may also return the status of all readers). The status\n"
+ " is a list of one-character flags. The following flags\n"
+ " are currently defined:\n"
+ " 'u' Usable card present.\n"
+ " 'r' Card removed. A reset is necessary.\n"
+ " These flags are exclusive.\n"
+ " reader_list - Return a list of detected card readers.\n"
+ " deny_admin - Returns OK if admin commands are not allowed or\n"
+ " GPG_ERR_GENERAL if admin commands are allowed.\n"
+ " app_list - Return a list of supported applications. One\n"
+ " application per line, fields delimited by colons,\n"
+ " first field is the name.\n"
+ " card_list - Return a list of serial numbers of active cards,\n"
+ " using a status response.";
+static gpg_error_t
+cmd_getinfo (assuan_context_t ctx, char *line)
+{
+ int rc = 0;
+
+ if (!strcmp (line, "version"))
+ {
+ const char *s = VERSION;
+ rc = assuan_send_data (ctx, s, strlen (s));
+ }
+ else if (!strcmp (line, "pid"))
+ {
+ char numbuf[50];
+
+ snprintf (numbuf, sizeof numbuf, "%lu", (unsigned long)getpid ());
+ rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
+ }
+ else if (!strcmp (line, "socket_name"))
+ {
+ const char *s = scd_get_socket_name ();
+
+ if (s)
+ rc = assuan_send_data (ctx, s, strlen (s));
+ else
+ rc = gpg_error (GPG_ERR_NO_DATA);
+ }
+ else if (!strcmp (line, "connections"))
+ {
+ char numbuf[20];
+
+ snprintf (numbuf, sizeof numbuf, "%d", get_active_connection_count ());
+ rc = assuan_send_data (ctx, numbuf, strlen (numbuf));
+ }
+ else if (!strcmp (line, "status"))
+ {
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ char flag;
+
+ if (open_card (ctrl))
+ flag = 'r';
+ else
+ flag = 'u';
+
+ rc = assuan_send_data (ctx, &flag, 1);
+ }
+ else if (!strcmp (line, "reader_list"))
+ {
+ char *s = apdu_get_reader_list ();
+ if (s)
+ rc = pretty_assuan_send_data (ctx, s, strlen (s));
+ else
+ rc = gpg_error (GPG_ERR_NO_DATA);
+ xfree (s);
+ }
+ else if (!strcmp (line, "deny_admin"))
+ rc = opt.allow_admin? gpg_error (GPG_ERR_GENERAL) : 0;
+ else if (!strcmp (line, "app_list"))
+ {
+ char *s = get_supported_applications ();
+ if (s)
+ rc = assuan_send_data (ctx, s, strlen (s));
+ else
+ rc = 0;
+ xfree (s);
+ }
+ else if (!strcmp (line, "card_list"))
+ {
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+
+ app_send_card_list (ctrl);
+ }
+ else
+ rc = set_error (GPG_ERR_ASS_PARAMETER, "unknown value for WHAT");
+ return rc;
+}
+
+
+static const char hlp_restart[] =
+ "RESTART\n"
+ "\n"
+ "Restart the current connection; this is a kind of warm reset. It\n"
+ "deletes the context used by this connection but does not send a\n"
+ "RESET to the card. Thus the card itself won't get reset. \n"
+ "\n"
+ "This is used by gpg-agent to reuse a primary pipe connection and\n"
+ "may be used by clients to backup from a conflict in the serial\n"
+ "command; i.e. to select another application.";
+static gpg_error_t
+cmd_restart (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ app_t app = ctrl->app_ctx;
+
+ (void)line;
+
+ if (app)
+ {
+ ctrl->app_ctx = NULL;
+ release_application (app, 0);
+ }
+ if (locked_session && ctrl->server_local == locked_session)
+ {
+ locked_session = NULL;
+ log_info ("implicitly unlocking due to RESTART\n");
+ }
+ return 0;
+}
+
+
+static const char hlp_disconnect[] =
+ "DISCONNECT\n"
+ "\n"
+ "Disconnect the card if the backend supports a disconnect operation.";
+static gpg_error_t
+cmd_disconnect (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+
+ (void)line;
+
+ if (!ctrl->app_ctx)
+ return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
+
+ apdu_disconnect (ctrl->app_ctx->slot);
+ return 0;
+}
+
+
+
+static const char hlp_apdu[] =
+ "APDU [--[dump-]atr] [--more] [--exlen[=N]] [hexstring]\n"
+ "\n"
+ "Send an APDU to the current reader. This command bypasses the high\n"
+ "level functions and sends the data directly to the card. HEXSTRING\n"
+ "is expected to be a proper APDU. If HEXSTRING is not given no\n"
+ "commands are set to the card but the command will implictly check\n"
+ "whether the card is ready for use. \n"
+ "\n"
+ "Using the option \"--atr\" returns the ATR of the card as a status\n"
+ "message before any data like this:\n"
+ " S CARD-ATR 3BFA1300FF813180450031C173C00100009000B1\n"
+ "\n"
+ "Using the option --more handles the card status word MORE_DATA\n"
+ "(61xx) and concatenates all responses to one block.\n"
+ "\n"
+ "Using the option \"--exlen\" the returned APDU may use extended\n"
+ "length up to N bytes. If N is not given a default value is used\n"
+ "(currently 4096).";
+static gpg_error_t
+cmd_apdu (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+ app_t app;
+ int rc;
+ unsigned char *apdu;
+ size_t apdulen;
+ int with_atr;
+ int handle_more;
+ const char *s;
+ size_t exlen;
+
+ if (has_option (line, "--dump-atr"))
+ with_atr = 2;
+ else
+ with_atr = has_option (line, "--atr");
+ handle_more = has_option (line, "--more");
+
+ if ((s=has_option_name (line, "--exlen")))
+ {
+ if (*s == '=')
+ exlen = strtoul (s+1, NULL, 0);
+ else
+ exlen = 4096;
+ }
+ else
+ exlen = 0;
+
+ line = skip_options (line);
+
+ if ((rc = open_card (ctrl)))
+ return rc;
+
+ app = ctrl->app_ctx;
+ if (!app)
+ return gpg_error (GPG_ERR_CARD_NOT_PRESENT);
+
+ if (with_atr)
+ {
+ unsigned char *atr;
+ size_t atrlen;
+ char hexbuf[400];
+
+ atr = apdu_get_atr (app->slot, &atrlen);
+ if (!atr || atrlen > sizeof hexbuf - 2 )
+ {
+ rc = gpg_error (GPG_ERR_INV_CARD);
+ goto leave;
+ }
+ if (with_atr == 2)
+ {
+ char *string, *p, *pend;
+
+ string = atr_dump (atr, atrlen);
+ if (string)
+ {
+ for (rc=0, p=string; !rc && (pend = strchr (p, '\n')); p = pend+1)
+ {
+ rc = assuan_send_data (ctx, p, pend - p + 1);
+ if (!rc)
+ rc = assuan_send_data (ctx, NULL, 0);
+ }
+ if (!rc && *p)
+ rc = assuan_send_data (ctx, p, strlen (p));
+ es_free (string);
+ if (rc)
+ goto leave;
+ }
+ }
+ else
+ {
+ bin2hex (atr, atrlen, hexbuf);
+ send_status_info (ctrl, "CARD-ATR", hexbuf, strlen (hexbuf), NULL, 0);
+ }
+ xfree (atr);
+ }
+
+ apdu = hex_to_buffer (line, &apdulen);
+ if (!apdu)
+ {
+ rc = gpg_error_from_syserror ();
+ goto leave;
+ }
+ if (apdulen)
+ {
+ unsigned char *result = NULL;
+ size_t resultlen;
+
+ rc = apdu_send_direct (app->slot, exlen,
+ apdu, apdulen, handle_more,
+ NULL, &result, &resultlen);
+ if (rc)
+ log_error ("apdu_send_direct failed: %s\n", gpg_strerror (rc));
+ else
+ {
+ rc = assuan_send_data (ctx, result, resultlen);
+ xfree (result);
+ }
+ }
+ xfree (apdu);
+
+ leave:
+ return rc;
+}
+
+
+static const char hlp_killscd[] =
+ "KILLSCD\n"
+ "\n"
+ "Commit suicide.";
+static gpg_error_t
+cmd_killscd (assuan_context_t ctx, char *line)
+{
+ ctrl_t ctrl = assuan_get_pointer (ctx);
+
+ (void)line;
+
+ ctrl->server_local->stopme = 1;
+ assuan_set_flag (ctx, ASSUAN_FORCE_CLOSE, 1);
+ return 0;
+}
+
+
+
+/* Tell the assuan library about our commands */
+static int
+register_commands (assuan_context_t ctx)
+{
+ static struct {
+ const char *name;
+ assuan_handler_t handler;
+ const char * const help;
+ } table[] = {
+ { "SERIALNO", cmd_serialno, hlp_serialno },
+ { "LEARN", cmd_learn, hlp_learn },
+ { "READCERT", cmd_readcert, hlp_readcert },
+ { "READKEY", cmd_readkey, hlp_readkey },
+ { "SETDATA", cmd_setdata, hlp_setdata },
+ { "PKSIGN", cmd_pksign, hlp_pksign },
+ { "PKAUTH", cmd_pkauth, hlp_pkauth },
+ { "PKDECRYPT", cmd_pkdecrypt,hlp_pkdecrypt },
+ { "INPUT", NULL },
+ { "OUTPUT", NULL },
+ { "GETATTR", cmd_getattr, hlp_getattr },
+ { "SETATTR", cmd_setattr, hlp_setattr },
+ { "WRITECERT", cmd_writecert,hlp_writecert },
+ { "WRITEKEY", cmd_writekey, hlp_writekey },
+ { "GENKEY", cmd_genkey, hlp_genkey },
+ { "RANDOM", cmd_random, hlp_random },
+ { "PASSWD", cmd_passwd, hlp_passwd },
+ { "CHECKPIN", cmd_checkpin, hlp_checkpin },
+ { "LOCK", cmd_lock, hlp_lock },
+ { "UNLOCK", cmd_unlock, hlp_unlock },
+ { "GETINFO", cmd_getinfo, hlp_getinfo },
+ { "RESTART", cmd_restart, hlp_restart },
+ { "DISCONNECT", cmd_disconnect,hlp_disconnect },
+ { "APDU", cmd_apdu, hlp_apdu },
+ { "KILLSCD", cmd_killscd, hlp_killscd },
+ { NULL }
+ };
+ int i, rc;
+
+ for (i=0; table[i].name; i++)
+ {
+ rc = assuan_register_command (ctx, table[i].name, table[i].handler,
+ table[i].help);
+ if (rc)
+ return rc;
+ }
+ assuan_set_hello_line (ctx, "GNU Privacy Guard's Smartcard server ready");
+
+ assuan_register_reset_notify (ctx, reset_notify);
+ assuan_register_option_handler (ctx, option_handler);
+ return 0;
+}
+
+
+/* Startup the server. If FD is given as -1 this is simple pipe
+ server, otherwise it is a regular server. Returns true if there
+ are no more active asessions. */
+int
+scd_command_handler (ctrl_t ctrl, int fd)
+{
+ int rc;
+ assuan_context_t ctx = NULL;
+ int stopme;
+
+ rc = assuan_new (&ctx);
+ if (rc)
+ {
+ log_error ("failed to allocate assuan context: %s\n",
+ gpg_strerror (rc));
+ scd_exit (2);
+ }
+
+ if (fd == -1)
+ {
+ assuan_fd_t filedes[2];
+
+ filedes[0] = assuan_fdopen (0);
+ filedes[1] = assuan_fdopen (1);
+ rc = assuan_init_pipe_server (ctx, filedes);
+ }
+ else
+ {
+ rc = assuan_init_socket_server (ctx, INT2FD(fd),
+ ASSUAN_SOCKET_SERVER_ACCEPTED);
+ }
+ if (rc)
+ {
+ log_error ("failed to initialize the server: %s\n",
+ gpg_strerror(rc));
+ scd_exit (2);
+ }
+ rc = register_commands (ctx);
+ if (rc)
+ {
+ log_error ("failed to register commands with Assuan: %s\n",
+ gpg_strerror(rc));
+ scd_exit (2);
+ }
+ assuan_set_pointer (ctx, ctrl);
+
+ /* Allocate and initialize the server object. Put it into the list
+ of active sessions. */
+ ctrl->server_local = xcalloc (1, sizeof *ctrl->server_local);
+ ctrl->server_local->next_session = session_list;
+ session_list = ctrl->server_local;
+ ctrl->server_local->ctrl_backlink = ctrl;
+ ctrl->server_local->assuan_ctx = ctx;
+
+ /* Command processing loop. */
+ for (;;)
+ {
+ rc = assuan_accept (ctx);
+ if (rc == -1)
+ {
+ break;
+ }
+ else if (rc)
+ {
+ log_info ("Assuan accept problem: %s\n", gpg_strerror (rc));
+ break;
+ }
+
+ rc = assuan_process (ctx);
+ if (rc)
+ {
+ log_info ("Assuan processing failed: %s\n", gpg_strerror (rc));
+ continue;
+ }
+ }
+
+ /* Cleanup. We don't send an explicit reset to the card. */
+ do_reset (ctrl, 0, 0);
+
+ /* Release the server object. */
+ if (session_list == ctrl->server_local)
+ session_list = ctrl->server_local->next_session;
+ else
+ {
+ struct server_local_s *sl;
+
+ for (sl=session_list; sl->next_session; sl = sl->next_session)
+ if (sl->next_session == ctrl->server_local)
+ break;
+ if (!sl->next_session)
+ BUG ();
+ sl->next_session = ctrl->server_local->next_session;
+ }
+ stopme = ctrl->server_local->stopme;
+ xfree (ctrl->server_local);
+ ctrl->server_local = NULL;
+
+ /* Release the Assuan context. */
+ assuan_release (ctx);
+
+ if (stopme)
+ scd_exit (0);
+
+ /* If there are no more sessions return true. */
+ return !session_list;
+}
+
+
+
+/* Send a keyinfo string. If DATA is true the string is emitted as a
+ * data line, else as a status line. */
+void
+send_keyinfo (ctrl_t ctrl, int data, const char *keygrip_str,
+ const char *serialno, const char *idstr)
+{
+ char *string;
+ assuan_context_t ctx = ctrl->server_local->assuan_ctx;
+
+ string = xtryasprintf ("%s T %s %s%s", keygrip_str,
+ serialno? serialno : "-",
+ idstr? idstr : "-",
+ data? "\n" : "");
+
+ if (!string)
+ return;
+
+ if (!data)
+ assuan_write_status (ctx, "KEYINFO", string);
+ else
+ assuan_send_data (ctx, string, strlen (string));
+
+ xfree (string);
+ return;
+}
+
+
+/* Send a line with status information via assuan and escape all given
+ buffers. The variable elements are pairs of (char *, size_t),
+ terminated with a (NULL, 0). */
+void
+send_status_info (ctrl_t ctrl, const char *keyword, ...)
+{
+ va_list arg_ptr;
+ const unsigned char *value;
+ size_t valuelen;
+ char buf[950], *p;
+ size_t n;
+ assuan_context_t ctx = ctrl->server_local->assuan_ctx;
+
+ va_start (arg_ptr, keyword);
+
+ p = buf;
+ n = 0;
+ while ( (value = va_arg (arg_ptr, const unsigned char *))
+ && n < DIM (buf)-2 )
+ {
+ valuelen = va_arg (arg_ptr, size_t);
+ if (!valuelen)
+ continue; /* empty buffer */
+ if (n)
+ {
+ *p++ = ' ';
+ n++;
+ }
+ for ( ; valuelen && n < DIM (buf)-2; n++, valuelen--, value++)
+ {
+ if (*value == '+' || *value == '\"' || *value == '%'
+ || *value < ' ')
+ {
+ sprintf (p, "%%%02X", *value);
+ p += 3;
+ n += 2;
+ }
+ else if (*value == ' ')
+ *p++ = '+';
+ else
+ *p++ = *value;
+ }
+ }
+ *p = 0;
+ assuan_write_status (ctx, keyword, buf);
+
+ va_end (arg_ptr);
+}
+
+
+/* Send a ready formatted status line via assuan. */
+gpg_error_t
+send_status_direct (ctrl_t ctrl, const char *keyword, const char *args)
+{
+ assuan_context_t ctx = ctrl->server_local->assuan_ctx;
+
+ if (strchr (args, '\n'))
+ {
+ log_error ("error: LF detected in status line - not sending\n");
+ return gpg_error (GPG_ERR_INTERNAL);
+ }
+ return assuan_write_status (ctx, keyword, args);
+}
+
+
+/* This status functions expects a printf style format string. No
+ * filtering of the data is done instead the orintf formatted data is
+ * send using assuan_send_status. */
+gpg_error_t
+send_status_printf (ctrl_t ctrl, const char *keyword, const char *format, ...)
+{
+ gpg_error_t err;
+ va_list arg_ptr;
+ assuan_context_t ctx;
+
+ if (!ctrl || !ctrl->server_local || !(ctx = ctrl->server_local->assuan_ctx))
+ return 0;
+
+ va_start (arg_ptr, format);
+ err = vprint_assuan_status (ctx, keyword, format, arg_ptr);
+ va_end (arg_ptr);
+ return err;
+}
+
+
+void
+popup_prompt (void *opaque, int on)
+{
+ ctrl_t ctrl = opaque;
+
+ if (ctrl)
+ {
+ assuan_context_t ctx = ctrl->server_local->assuan_ctx;
+
+ if (ctx)
+ {
+ const char *cmd;
+ gpg_error_t err;
+ unsigned char *value;
+ size_t valuelen;
+
+ if (on)
+ cmd = "POPUPPINPADPROMPT --ack";
+ else
+ cmd = "DISMISSPINPADPROMPT";
+ err = assuan_inquire (ctx, cmd, &value, &valuelen, 100);
+ if (!err)
+ xfree (value);
+ }
+ }
+}
+
+
+/* Helper to send the clients a status change notification. */
+void
+send_client_notifications (app_t app, int removal)
+{
+ struct {
+ pid_t pid;
+#ifdef HAVE_W32_SYSTEM
+ HANDLE handle;
+#else
+ int signo;
+#endif
+ } killed[50];
+ int killidx = 0;
+ int kidx;
+ struct server_local_s *sl;
+
+ for (sl=session_list; sl; sl = sl->next_session)
+ if (sl->ctrl_backlink && sl->ctrl_backlink->app_ctx == app)
+ {
+ pid_t pid;
+#ifdef HAVE_W32_SYSTEM
+ HANDLE handle;
+#else
+ int signo;
+#endif
+
+ if (removal)
+ {
+ sl->ctrl_backlink->app_ctx = NULL;
+ sl->card_removed = 1;
+ release_application (app, 1);
+ }
+
+ if (!sl->event_signal || !sl->assuan_ctx)
+ continue;
+
+ pid = assuan_get_pid (sl->assuan_ctx);
+
+#ifdef HAVE_W32_SYSTEM
+ handle = sl->event_signal;
+ for (kidx=0; kidx < killidx; kidx++)
+ if (killed[kidx].pid == pid
+ && killed[kidx].handle == handle)
+ break;
+ if (kidx < killidx)
+ log_info ("event %p (%p) already triggered for client %d\n",
+ sl->event_signal, handle, (int)pid);
+ else
+ {
+ log_info ("triggering event %p (%p) for client %d\n",
+ sl->event_signal, handle, (int)pid);
+ if (!SetEvent (handle))
+ log_error ("SetEvent(%p) failed: %s\n",
+ sl->event_signal, w32_strerror (-1));
+ if (killidx < DIM (killed))
+ {
+ killed[killidx].pid = pid;
+ killed[killidx].handle = handle;
+ killidx++;
+ }
+ }
+#else /*!HAVE_W32_SYSTEM*/
+ signo = sl->event_signal;
+
+ if (pid != (pid_t)(-1) && pid && signo > 0)
+ {
+ for (kidx=0; kidx < killidx; kidx++)
+ if (killed[kidx].pid == pid
+ && killed[kidx].signo == signo)
+ break;
+ if (kidx < killidx)
+ log_info ("signal %d already sent to client %d\n",
+ signo, (int)pid);
+ else
+ {
+ log_info ("sending signal %d to client %d\n",
+ signo, (int)pid);
+ kill (pid, signo);
+ if (killidx < DIM (killed))
+ {
+ killed[killidx].pid = pid;
+ killed[killidx].signo = signo;
+ killidx++;
+ }
+ }
+ }
+#endif /*!HAVE_W32_SYSTEM*/
+ }
+}