Make it also work for the card.
[gnupg.git] / agent / divert-scd.c
index 9b176a6..49768fe 100644 (file)
@@ -1,5 +1,5 @@
 /* divert-scd.c - divert operations to the scdaemon 
- *     Copyright (C) 2002 Free Software Foundation, Inc.
+ *     Copyright (C) 2002, 2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -15,7 +15,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
  */
 
 #include <config.h>
 
 #include "agent.h"
 #include "sexp-parse.h"
-
+#include "i18n.h"
 
 
 static int
-ask_for_card (const unsigned char *shadow_info, char **r_kid)
+ask_for_card (ctrl_t ctrl, const unsigned char *shadow_info, char **r_kid)
 {
   int rc, i;
   const unsigned char *s;
@@ -43,37 +44,45 @@ ask_for_card (const unsigned char *shadow_info, char **r_kid)
   int no_card = 0;
   char *desc;
   char *want_sn, *want_kid;
+  int want_sn_displen;
 
   *r_kid = NULL;
   s = shadow_info;
   if (*s != '(')
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   want_sn = xtrymalloc (n*2+1);
   if (!want_sn)
-    return GNUPG_Out_Of_Core;
+    return out_of_core ();
   for (i=0; i < n; i++)
     sprintf (want_sn+2*i, "%02X", s[i]);
   s += n;
+  /* We assume that a 20 byte serial number is a standard one which
+     seems to have the property to have a zero in the last nibble.  We
+     don't display this '0' because it may confuse the user */
+  want_sn_displen = strlen (want_sn);
+  if (want_sn_displen == 20 && want_sn[19] == '0')
+    want_sn_displen--;
 
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   want_kid = xtrymalloc (n+1);
   if (!want_kid)
     {
+      gpg_error_t tmperr = out_of_core ();
       xfree (want_sn);
-      return GNUPG_Out_Of_Core;
+      return tmperr;
     }
   memcpy (want_kid, s, n);
   want_kid[n] = 0;
 
   for (;;)
     {
-      rc = agent_card_serialno (&serialno);
+      rc = agent_card_serialno (ctrl, &serialno);
       if (!rc)
         {
           log_debug ("detected card with S/N %s\n", serialno);
@@ -87,7 +96,7 @@ ask_for_card (const unsigned char *shadow_info, char **r_kid)
               return 0; /* yes, we have the correct card */
             }
         }
-      else if (rc == GNUPG_Card_Not_Present)
+      else if (gpg_err_code (rc) == GPG_ERR_CARD_NOT_PRESENT)
         {
           log_debug ("no card present\n");
           rc = 0;
@@ -95,24 +104,24 @@ ask_for_card (const unsigned char *shadow_info, char **r_kid)
         }
       else
         {
-          log_error ("error accesing card: %s\n", gnupg_strerror (rc));
+          log_error ("error accesing card: %s\n", gpg_strerror (rc));
         }
 
       if (!rc)
         {
           if (asprintf (&desc,
                     "%s:%%0A%%0A"
-                    "  \"%s\"",
+                    "  \"%.*s\"",
                     no_card? "Please insert the card with serial number" 
                     : "Please remove the current card and "
                     "insert the one with serial number",
-                    want_sn) < 0)
+                    want_sn_displen, want_sn) < 0)
             {
-              rc = GNUPG_Out_Of_Core;
+              rc = out_of_core ();
             }
           else
             {
-              rc = agent_get_confirmation (desc, NULL);
+              rc = agent_get_confirmation (ctrl, desc, NULL, NULL);
               free (desc);
             }
         }
@@ -126,56 +135,37 @@ ask_for_card (const unsigned char *shadow_info, char **r_kid)
 }
 
 
-/* fixme: this should be moved to libgcrypt and only be used if the
-   smartcard does not support pkcs-1 itself */
+/* Put the DIGEST into an DER encoded container and return it in R_VAL. */
 static int
 encode_md_for_card (const unsigned char *digest, size_t digestlen, int algo,
-                    unsigned int nbits, unsigned char **r_val, size_t *r_len)
+                    unsigned char **r_val, size_t *r_len)
 {
-  int nframe = (nbits+7) / 8;
-  byte *frame;
-  int i, n;
-  byte asn[100];
+  unsigned char *frame;
+  unsigned char asn[100];
   size_t asnlen;
 
+  *r_val = NULL;
+  *r_len = 0;
+
   asnlen = DIM(asn);
+  if (!algo || gcry_md_test_algo (algo))
+    return gpg_error (GPG_ERR_DIGEST_ALGO);
   if (gcry_md_algo_info (algo, GCRYCTL_GET_ASNOID, asn, &asnlen))
     {
       log_error ("no object identifier for algo %d\n", algo);
-      return GNUPG_Internal_Error;
+      return gpg_error (GPG_ERR_INTERNAL);
     }
 
-  if (digestlen + asnlen + 4  > nframe )
-    {
-      log_error ("can't encode a %d bit MD into a %d bits frame\n",
-                 (int)(digestlen*8), (int)nbits);
-      return GNUPG_Internal_Error;
-    }
-  
-  /* We encode the MD in this way:
-   *
-   *      0  1 PAD(n bytes)   0  ASN(asnlen bytes)  MD(len bytes)
-   *
-   * PAD consists of FF bytes.
-   */
-  frame = xtrymalloc (nframe);
+  frame = xtrymalloc (asnlen + digestlen);
   if (!frame)
-    return GNUPG_Out_Of_Core;
-  n = 0;
-  frame[n++] = 0;
-  frame[n++] = 1; /* block type */
-  i = nframe - digestlen - asnlen -3 ;
-  assert ( i > 1 );
-  memset ( frame+n, 0xff, i ); n += i;
-  frame[n++] = 0;
-  memcpy ( frame+n, asn, asnlen ); n += asnlen;
-  memcpy ( frame+n, digest, digestlen ); n += digestlen;
-  assert ( n == nframe );
+    return out_of_core ();
+  memcpy (frame, asn, asnlen);
+  memcpy (frame+asnlen, digest, digestlen);
   if (DBG_CRYPTO)
-    log_printhex ("encoded hash:", frame, nframe);
+    log_printhex ("encoded hash:", frame, asnlen+digestlen);
       
   *r_val = frame;
-  *r_len = nframe;
+  *r_len = asnlen+digestlen;
   return 0;
 }
 
@@ -183,43 +173,136 @@ encode_md_for_card (const unsigned char *digest, size_t digestlen, int algo,
 /* Callback used to ask for the PIN which should be set into BUF.  The
    buf has been allocated by the caller and is of size MAXBUF which
    includes the terminating null.  The function should return an UTF-8
-   string with the passphrase, the buffer may optioanlly be padded
-   with arbitrary characters */
+   string with the passphrase, the buffer may optionally be padded
+   with arbitrary characters.
+
+   INFO gets displayed as part of a generic string.  However if the
+   first character of INFO is a vertical bar all up to the next
+   verical bar are considered flags and only everything after the
+   second vertical bar gets displayed as the full prompt.
+
+   Flags:
+
+      'N' = New PIN, this requests a second prompt to repeat the the
+            PIN.  If the PIN is not correctly repeated it starts from
+            all over.
+      'A' = The PIN is an Admin PIN, SO-PIN, PUK or alike.
+
+   Example:
+
+     "|AN|Please enter the new security officer's PIN"
+     
+   The text "Please ..." will get displayed and the flags 'A' and 'N'
+   are considered.
+ */
 static int 
 getpin_cb (void *opaque, const char *info, char *buf, size_t maxbuf)
 {
   struct pin_entry_info_s *pi;
   int rc;
-  int tries = 0;
-  const char *errtext;
-  
-  assert (!opaque);
+  ctrl_t ctrl = opaque;
+  const char *ends, *s;
+  int any_flags = 0;
+  int newpin = 0;
+  const char *again_text = NULL;
+  const char *prompt = "PIN";
 
-  if (maxbuf < 2)
-    return GNUPG_Invalid_Value;
+  if (buf && maxbuf < 2)
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  /* Parse the flags. */
+  if (info && *info =='|' && (ends=strchr (info+1, '|')))
+    {
+      for (s=info+1; s < ends; s++)
+        {
+          if (*s == 'A')
+            prompt = _("Admin PIN");
+          else if (*s == 'N')
+            newpin = 1;
+        }
+      info = ends+1;
+      any_flags = 1;
+    }
+  else if (info && *info == '|')
+    log_debug ("pin_cb called without proper PIN info hack\n");
 
-  /* FIXME: keep PI and TRIES in OPAQUE */
-  pi = gcry_calloc_secure (1, sizeof (*pi) + 100);
+  /* If BUF has been passed as NULL, we are in keypad mode: The
+     callback opens the popup and immediatley returns. */
+  if (!buf)
+    {
+      if (maxbuf == 0) /* Close the pinentry. */
+        {
+          agent_popup_message_stop (ctrl);
+          rc = 0;
+        }
+      else if (maxbuf == 1)  /* Open the pinentry. */
+        {
+          rc = agent_popup_message_start (ctrl, info, NULL, NULL);
+        }
+      else
+        rc = gpg_error (GPG_ERR_INV_VALUE);
+      return rc;
+    }
+
+  /* FIXME: keep PI and TRIES in OPAQUE.  Frankly this is a whole
+     mess because we should call the card's verify function from the
+     pinentry check pin CB. */
+ again:
+  pi = gcry_calloc_secure (1, sizeof (*pi) + maxbuf + 10);
+  if (!pi)
+    return gpg_error_from_syserror ();
   pi->max_length = maxbuf-1;
   pi->min_digits = 0;  /* we want a real passphrase */
   pi->max_digits = 8;
   pi->max_tries = 3;
 
-  errtext = NULL;
-  do
+  if (any_flags)
     {
-      rc = agent_askpin (info, errtext, pi);
-      if (!rc)
+      rc = agent_askpin (ctrl, info, prompt, again_text, pi);
+      again_text = NULL;
+      if (!rc && newpin)
         {
-          strncpy (buf, pi->pin, maxbuf-1);
-          buf[maxbuf-1] = 0;
-          xfree (pi);
-          return 0;
+          struct pin_entry_info_s *pi2;
+          pi2 = gcry_calloc_secure (1, sizeof (*pi) + maxbuf + 10);
+          if (!pi2)
+            {
+              rc = gpg_error_from_syserror ();
+              xfree (pi);
+              return rc;
+            }
+          pi2->max_length = maxbuf-1;
+          pi2->min_digits = 0;
+          pi2->max_digits = 8;
+          pi2->max_tries = 1;
+          rc = agent_askpin (ctrl, _("Repeat this PIN"), prompt, NULL, pi2);
+          if (!rc && strcmp (pi->pin, pi2->pin))
+            {
+              again_text = N_("PIN not correctly repeated; try again");
+              xfree (pi2);
+              xfree (pi);
+              goto again;
+            }
+          xfree (pi2);
         }
-      errtext = pi->min_digits? trans ("Bad PIN") : trans ("Bad Passphrase");
     }
-  while ((rc == GNUPG_Bad_Passphrase || rc == GNUPG_Bad_PIN)
-         && tries++ < 3);
+  else
+    {
+      char *desc;
+      if ( asprintf (&desc,
+                     _("Please enter the PIN%s%s%s to unlock the card"), 
+                     info? " (`":"",
+                     info? info:"",
+                     info? "')":"") < 0)
+        desc = NULL;
+      rc = agent_askpin (ctrl, desc?desc:info, prompt, NULL, pi);
+      free (desc);
+    }
+
+  if (!rc)
+    {
+      strncpy (buf, pi->pin, maxbuf-1);
+      buf[maxbuf-1] = 0;
+    }
   xfree (pi);
   return rc;
 }
@@ -228,32 +311,46 @@ getpin_cb (void *opaque, const char *info, char *buf, size_t maxbuf)
 
 
 int
-divert_pksign (const unsigned char *digest, size_t digestlen, int algo,
+divert_pksign (ctrl_t ctrl, 
+               const unsigned char *digest, size_t digestlen, int algo,
                const unsigned char *shadow_info, unsigned char **r_sig)
 {
   int rc;
   char *kid;
   size_t siglen;
-  char *sigval;
-  unsigned char *data;
-  size_t ndata;
+  unsigned char *sigval = NULL;
 
-  rc = ask_for_card (shadow_info, &kid);
+  rc = ask_for_card (ctrl, shadow_info, &kid);
   if (rc)
     return rc;
 
-  rc = encode_md_for_card (digest, digestlen, algo, 1024 /* fixme*/,
-                           &data, &ndata);
-  if (rc)
-    return rc;
+  if (algo == GCRY_MD_USER_TLS_MD5SHA1)
+    {
+      int save = ctrl->use_auth_call;
+      ctrl->use_auth_call = 1;
+      rc = agent_card_pksign (ctrl, kid, getpin_cb, ctrl,
+                              digest, digestlen, &sigval, &siglen);
+      ctrl->use_auth_call = save;
+    }
+  else
+    {
+      unsigned char *data;
+      size_t ndata;
+
+      rc = encode_md_for_card (digest, digestlen, algo, &data, &ndata);
+      if (!rc)
+        {
+          rc = agent_card_pksign (ctrl, kid, getpin_cb, ctrl,
+                                  data, ndata, &sigval, &siglen);
+          xfree (data);
+        }
+    }
 
-  rc = agent_card_pksign (kid, getpin_cb, NULL,
-                          data, ndata, &sigval, &siglen);
   if (!rc)
     *r_sig = sigval;
-  xfree (data);
+
   xfree (kid);
-  
+
   return rc;
 }
 
@@ -262,7 +359,8 @@ divert_pksign (const unsigned char *digest, size_t digestlen, int algo,
    key identified by SHADOW_INFO and return the plaintext in an
    allocated buffer in R_BUF.  */
 int  
-divert_pkdecrypt (const unsigned char *cipher,
+divert_pkdecrypt (ctrl_t ctrl,
+                  const unsigned char *cipher,
                   const unsigned char *shadow_info,
                   char **r_buf, size_t *r_len)
 {
@@ -277,40 +375,40 @@ divert_pkdecrypt (const unsigned char *cipher,
 
   s = cipher;
   if (*s != '(')
-    return GNUPG_Invalid_Sexp;
+    return gpg_error (GPG_ERR_INV_SEXP);
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "enc-val"))
-    return GNUPG_Unknown_Sexp
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP)
   if (*s != '(')
-    return GNUPG_Unknown_Sexp;
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP);
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "rsa"))
-    return GNUPG_Unsupported_Algorithm
+    return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM)
   if (*s != '(')
-    return GNUPG_Unknown_Sexp;
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP);
   s++;
   n = snext (&s);
   if (!n)
-    return GNUPG_Invalid_Sexp
+    return gpg_error (GPG_ERR_INV_SEXP)
   if (!smatch (&s, n, "a"))
-    return GNUPG_Unknown_Sexp;
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP);
   n = snext (&s);
   if (!n)
-    return GNUPG_Unknown_Sexp
+    return gpg_error (GPG_ERR_UNKNOWN_SEXP)
   ciphertext = s;
   ciphertextlen = n;
 
-  rc = ask_for_card (shadow_info, &kid);
+  rc = ask_for_card (ctrl, shadow_info, &kid);
   if (rc)
     return rc;
 
-  rc = agent_card_pkdecrypt (kid, getpin_cb, NULL,
+  rc = agent_card_pkdecrypt (ctrl, kid, getpin_cb, ctrl,
                              ciphertext, ciphertextlen,
                              &plaintext, &plaintextlen);
   if (!rc)
@@ -321,3 +419,15 @@ divert_pkdecrypt (const unsigned char *cipher,
   xfree (kid);
   return rc;
 }
+
+
+int  
+divert_generic_cmd (ctrl_t ctrl, const char *cmdline, void *assuan_context)
+{
+  return agent_card_scd (ctrl, cmdline, getpin_cb, ctrl, assuan_context);
+}
+
+
+
+
+