New. Taken from gnupg 1.9.
[gnupg.git] / scd / app-openpgp.c
index 1f9ec56..09a1969 100644 (file)
@@ -61,6 +61,9 @@ static struct {
 };
 
 
+static unsigned long get_sig_counter (APP app);
+
+
 /* Locate a TLV encoded data object in BUFFER of LENGTH and
    return a pointer to value as well as its length in NBYTES.  Return
    NULL if it was not found.  Note, that the function does not check
@@ -365,9 +368,9 @@ static int
 store_fpr (int slot, int keynumber, u32 timestamp,
            const unsigned char *m, size_t mlen,
            const unsigned char *e, size_t elen, 
-           unsigned char *fpr)
+           unsigned char *fpr, unsigned int card_version)
 {
-  unsigned int n, nbits;;
+  unsigned int n, nbits;
   unsigned char *buffer, *p;
   int rc;
   
@@ -404,7 +407,8 @@ store_fpr (int slot, int keynumber, u32 timestamp,
 
   xfree (buffer);
 
-  rc = iso7816_put_data (slot, 0xC6 + keynumber, fpr, 20);
+  rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
+                               + keynumber, fpr, 20);
   if (rc)
     log_error ("failed to store the fingerprint: rc=%04X\n", rc);
 
@@ -467,12 +471,30 @@ do_learn_status (APP app, CTRL ctrl)
       send_status_info (ctrl, "DISP-NAME", value, valuelen, NULL, 0);
       xfree (relptr);
     }
+  relptr = get_one_do (app->slot, 0x5F2D, &value, &valuelen);
+  if (relptr)
+    {
+      send_status_info (ctrl, "DISP-LANG", value, valuelen, NULL, 0);
+      xfree (relptr);
+    }
+  relptr = get_one_do (app->slot, 0x5F35, &value, &valuelen);
+  if (relptr)
+    {
+      send_status_info (ctrl, "DISP-SEX", value, valuelen, NULL, 0);
+      xfree (relptr);
+    }
   relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
   if (relptr)
     {
       send_status_info (ctrl, "PUBKEY-URL", value, valuelen, NULL, 0);
       xfree (relptr);
     }
+  relptr = get_one_do (app->slot, 0x005E, &value, &valuelen);
+  if (relptr)
+    {
+      send_status_info (ctrl, "LOGIN-DATA", value, valuelen, NULL, 0);
+      xfree (relptr);
+    }
 
   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
   if (relptr && valuelen >= 60)
@@ -488,6 +510,24 @@ do_learn_status (APP app, CTRL ctrl)
         send_fpr_if_not_null (ctrl, "CA-FPR", i+1, value+i*20);
     }
   xfree (relptr);
+  relptr = get_one_do (app->slot, 0x00C4, &value, &valuelen);
+  if (relptr)
+    {
+      char numbuf[7*23];
+
+      for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
+        sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
+      send_status_info (ctrl, "CHV-STATUS", numbuf, strlen (numbuf), NULL, 0);
+      xfree (relptr);
+    }
+
+  {
+    unsigned long ul = get_sig_counter (app);
+    char numbuf[23];
+
+    sprintf (numbuf, "%lu", ul);
+    send_status_info (ctrl, "SIG-COUNTER", numbuf, strlen (numbuf), NULL, 0);
+  }
   return 0;
 }
 
@@ -501,10 +541,28 @@ do_setattr (APP app, const char *name,
             const unsigned char *value, size_t valuelen)
 {
   gpg_error_t rc;
-
-  log_debug ("app_openpgp#setattr `%s' value of length %u\n",
-             name, (unsigned int)valuelen); /* fixme: name should be
-                                               sanitized. */
+  int idx;
+  static struct {
+    const char *name;
+    int tag;
+  } table[] = {
+    { "DISP-NAME",    0x005B },
+    { "LOGIN-DATA",   0x005E },
+    { "DISP-LANG",    0x5F2D },
+    { "DISP-SEX",     0x5F35 },
+    { "PUBKEY-URL",   0x5F50 },
+    { "CHV-STATUS-1", 0x00C4 },
+    { "CA-FPR-1",     0x00CA },
+    { "CA-FPR-2",     0x00CB },
+    { "CA-FPR-3",     0x00CC },
+    { NULL, 0 }
+  };
+
+
+  for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
+    ;
+  if (!table[idx].name)
+    return gpg_error (GPG_ERR_INV_NAME); 
 
   if (!app->did_chv3)
     {
@@ -512,8 +570,8 @@ do_setattr (APP app, const char *name,
 
       rc = pincb (pincb_arg, "Admin PIN (CHV3)",
                   &pinvalue);
-      pinvalue = xstrdup ("12345678");
-      rc = 0;
+/*        pinvalue = xstrdup ("12345678"); */
+/*        rc = 0; */
       if (rc)
         {
           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
@@ -531,37 +589,111 @@ do_setattr (APP app, const char *name,
       app->did_chv3 = 1;
     }
 
-  log_debug ("setting `%s' to `%.*s'\n", name, (int)valuelen, value);
-  if (!strcmp (name, "DISP-NAME"))
+  rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
+  if (rc)
+    log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
+  /* FIXME: If this fails we should *once* try again after
+     doing a verify command, so that in case of a problem with
+     tracking the verify operation we have a fallback. */
+
+  return rc;
+}
+
+/* Handle the PASSWD command. */
+static int 
+do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
+               int (*pincb)(void*, const char *, char **),
+               void *pincb_arg)
+{
+  int rc = 0;
+  int chvno = atoi (chvnostr);
+  char *pinvalue;
+
+  if (reset_mode && chvno == 3)
+    {
+      rc = gpg_error (GPG_ERR_INV_ID);
+      goto leave;
+    }
+  else if (reset_mode || chvno == 3)
     {
-      rc = iso7816_put_data (app->slot, 0x005B, value, valuelen);
+      rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
       if (rc)
         {
-          /* FIXME: If this fails we should *once* try again after
-          doing a verify command, so that in case of a problem with
-          tracking the verify operation we have a fallback. */
-          /* FIXME: change this when iso7816 returns correct error
-          codes. */
-          log_error ("failed to set `Name'\n");
-          rc = gpg_error (GPG_ERR_GENERAL);
+          log_error ("error getting PIN: %s\n", gpg_strerror (rc));
+          goto leave;
+        }
+      rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
+      xfree (pinvalue);
+      if (rc)
+        {
+          log_error ("verify CHV3 failed: rc=%04X\n", rc);
+          goto leave;
         }
     }
-  else if (!strcmp (name, "PUBKEY-URL"))
+  else if (chvno == 1)
     {
-      rc = iso7816_put_data (app->slot, 0x5F50, value, valuelen);
+      rc = pincb (pincb_arg, "Signature PIN", &pinvalue); 
       if (rc)
         {
-          log_error ("failed to set `Pubkey-URL'\n");
-          rc = gpg_error (GPG_ERR_GENERAL);
+          log_error ("error getting PIN: %s\n", gpg_strerror (rc));
+          goto leave;
+        }
+      rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
+      xfree (pinvalue);
+      if (rc)
+        {
+          log_error ("verify CHV1 failed: rc=%04X\n", rc);
+          goto leave;
+        }
+    }
+  else if (chvno == 2)
+    {
+      rc = pincb (pincb_arg, "Decryption PIN", &pinvalue); 
+      if (rc)
+        {
+          log_error ("error getting PIN: %s\n", gpg_strerror (rc));
+          goto leave;
+        }
+      rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
+      xfree (pinvalue);
+      if (rc)
+        {
+          log_error ("verify CHV2 failed: rc=%04X\n", rc);
+          goto leave;
         }
     }
   else
-    rc = gpg_error (GPG_ERR_INV_NAME); 
+    {
+      rc = gpg_error (GPG_ERR_INV_ID);
+      goto leave;
+    }
+
+  
+  rc = pincb (pincb_arg, chvno == 1? "New Signature PIN" :
+                         chvno == 2? "New Decryption PIN" :
+                         chvno == 3? "New Admin PIN" : "?", &pinvalue); 
+  if (rc)
+    {
+      log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
+      goto leave;
+    }
+
+  if (reset_mode)
+    rc = iso7816_reset_retry_counter (app->slot, 0x80 + chvno,
+                                      pinvalue, strlen (pinvalue));
+  else
+    rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
+                                        NULL, 0,
+                                        pinvalue, strlen (pinvalue));
+  xfree (pinvalue);
+
 
+ leave:
   return rc;
 }
 
 
+
 /* Handle the GENKEY command. */
 static int 
 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
@@ -630,7 +762,7 @@ do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
     }
 
   xfree (buffer); buffer = NULL;
-#if 0
+#if 1
   log_info ("please wait while key is being generated ...\n");
   start_at = time (NULL);
   rc = iso7816_generate_keypair 
@@ -685,7 +817,7 @@ do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
                     numbuf, (size_t)strlen(numbuf), NULL, 0);
 
   rc = store_fpr (app->slot, keyno, (u32)created_at,
-                  m, mlen, e, elen, fprbuf);
+                  m, mlen, e, elen, fprbuf, app->card_version);
   if (rc)
     goto leave;
   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
@@ -816,7 +948,7 @@ do_sign (APP app, const char *keyidstr, int hashalgo,
      the card.  This is allows for a meaningful error message in case
      the key on the card has been replaced but the shadow information
      known to gpg was not updated.  If there is no fingerprint, gpg
-     will detect the bodus signature anyway die to the
+     will detect a bogus signature anyway due to the
      verify-after-signing feature. */
   if (fpr)
     {
@@ -883,6 +1015,107 @@ do_sign (APP app, const char *keyidstr, int hashalgo,
   return rc;
 }
 
+/* Compute a digital signature using the INTERNAL AUTHENTICATE command
+   on INDATA which is expected to be the raw message digest. For this
+   application the KEYIDSTR consists of the serialnumber and the
+   fingerprint delimited by a slash.
+
+   Note that this fucntion may return the error code
+   GPG_ERR_WRONG_CARD to indicate that the card currently present does
+   not match the one required for the requested action (e.g. the
+   serial number does not match). */
+static int 
+do_auth (APP app, const char *keyidstr,
+         int (*pincb)(void*, const char *, char **),
+         void *pincb_arg,
+         const void *indata, size_t indatalen,
+         unsigned char **outdata, size_t *outdatalen )
+{
+  int rc;
+  unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
+  const char *s;
+  int n;
+  const char *fpr = NULL;
+
+  if (!keyidstr || !*keyidstr)
+    return gpg_error (GPG_ERR_INV_VALUE);
+  if (indatalen > 50) /* For a 1024 bit key. */
+    return gpg_error (GPG_ERR_INV_VALUE);
+
+  /* Check whether an OpenPGP card of any version has been requested. */
+  if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
+    return gpg_error (GPG_ERR_INV_ID);
+  
+  for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
+    ;
+  if (n != 32)
+    return gpg_error (GPG_ERR_INV_ID);
+  else if (!*s)
+    ; /* no fingerprint given: we allow this for now. */
+  else if (*s == '/')
+    fpr = s + 1; 
+  else
+    return gpg_error (GPG_ERR_INV_ID);
+
+  for (s=keyidstr, n=0; n < 16; s += 2, n++)
+    tmp_sn[n] = xtoi_2 (s);
+
+  if (app->serialnolen != 16)
+    return gpg_error (GPG_ERR_INV_CARD);
+  if (memcmp (app->serialno, tmp_sn, 16))
+    return gpg_error (GPG_ERR_WRONG_CARD);
+
+  /* If a fingerprint has been specified check it against the one on
+     the card.  This is allows for a meaningful error message in case
+     the key on the card has been replaced but the shadow information
+     known to gpg was not updated.  If there is no fingerprint, gpg
+     will detect a bogus signature anyway due to the
+     verify-after-signing feature. */
+  if (fpr)
+    {
+      for (s=fpr, n=0; hexdigitp (s); s++, n++)
+        ;
+      if (n != 40)
+        return gpg_error (GPG_ERR_INV_ID);
+      else if (!*s)
+        ; /* okay */
+      else
+        return gpg_error (GPG_ERR_INV_ID);
+
+      for (s=fpr, n=0; n < 20; s += 2, n++)
+        tmp_sn[n] = xtoi_2 (s);
+      rc = compare_fingerprint (app, 3, tmp_sn);
+      if (rc)
+        return rc;
+    }
+
+  if (!app->did_chv2) 
+    {
+      char *pinvalue;
+
+      rc = pincb (pincb_arg, "Authentication/Decryption PIN", &pinvalue); 
+      if (rc)
+        {
+          log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
+          return rc;
+        }
+
+      rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
+      xfree (pinvalue);
+      if (rc)
+        {
+          log_error ("verify CHV2 failed\n");
+          rc = gpg_error (GPG_ERR_GENERAL);
+          return rc;
+        }
+      app->did_chv2 = 1;
+    }
+
+  rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
+                                      outdata, outdatalen);
+  return rc;
+}
+
 
 static int 
 do_decipher (APP app, const char *keyidstr,
@@ -1006,6 +1239,8 @@ app_select_openpgp (APP app, unsigned char **sn, size_t *snlen)
         {
           *sn = buffer;
           *snlen = buflen;
+          app->card_version = buffer[6] << 8;
+          app->card_version |= buffer[7];
         }
       else
         xfree (buffer);
@@ -1017,7 +1252,9 @@ app_select_openpgp (APP app, unsigned char **sn, size_t *snlen)
       app->fnc.setattr = do_setattr;
       app->fnc.genkey = do_genkey;
       app->fnc.sign = do_sign;
+      app->fnc.auth = do_auth;
       app->fnc.decipher = do_decipher;
+      app->fnc.change_pin = do_change_pin;
    }
 
 leave:
@@ -1153,7 +1390,9 @@ app_openpgp_storekey (APP app, int keyno,
       goto leave;
     }
 
-  rc = iso7816_put_data (app->slot, 0xE9 + keyno, template, template_len);
+  rc = iso7816_put_data (app->slot,
+                         (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
+                         template, template_len);
   if (rc)
     {
       log_error ("failed to store the key: rc=%04X\n", rc);
@@ -1161,11 +1400,11 @@ app_openpgp_storekey (APP app, int keyno,
       goto leave;
     }
  
-  log_printhex ("RSA n:", m, mlen); 
-  log_printhex ("RSA e:", e, elen); 
+/*    log_printhex ("RSA n:", m, mlen);  */
+/*    log_printhex ("RSA e:", e, elen);  */
 
   rc = store_fpr (app->slot, keyno, (u32)created_at,
-                  m, mlen, e, elen, fprbuf);
+                  m, mlen, e, elen, fprbuf, app->card_version);
 
  leave:
   return rc;