With --enable-gpg the keyservers are now build and a first test using gpg2
[gnupg.git] / sm / certdump.c
index 11e9f65..2f7c1fd 100644 (file)
@@ -1,5 +1,5 @@
 /* certdump.c - Dump a certificate for debugging
- *     Copyright (C) 2001 Free Software Foundation, Inc.
+ *     Copyright (C) 2001, 2004 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 <unistd.h> 
 #include <time.h>
 #include <assert.h>
+#ifdef HAVE_LOCALE_H
+#include <locale.h>
+#endif
+#ifdef HAVE_LANGINFO_CODESET
+#include <langinfo.h>
+#endif
 
+#include "gpgsm.h"
 #include <gcrypt.h>
 #include <ksba.h>
 
-#include "gpgsm.h"
 #include "keydb.h"
 #include "i18n.h"
 
 struct dn_array_s {
   char *key;
   char *value;
+  int   multivalued;
+  int   done;
 };
 
 
 /* print the first element of an S-Expression */
 void
-gpgsm_print_serial (FILE *fp, KsbaConstSexp p)
+gpgsm_print_serial (FILE *fp, ksba_const_sexp_t sn)
 {
+  const char *p = (const char *)sn;
   unsigned long n;
-  KsbaConstSexp endp;
+  char *endp;
 
   if (!p)
     fputs (_("none"), fp);
@@ -54,24 +64,26 @@ gpgsm_print_serial (FILE *fp, KsbaConstSexp p)
   else
     {
       p++;
-      n = strtoul (p, (char**)&endp, 10);
+      n = strtoul (p, &endp, 10);
       p = endp;
       if (*p!=':')
         fputs ("[Internal Error - invalid S-expression]", fp);
       else
         {
           for (p++; n; n--, p++)
-            fprintf (fp, "%02X", *p);
+            fprintf (fp, "%02X", *(const unsigned char*)p);
         }
     }
 }
 
 
+/* Dump the serial number or any other simple S-expression. */
 void
-gpgsm_dump_serial (KsbaConstSexp p)
+gpgsm_dump_serial (ksba_const_sexp_t sn)
 {
+  const char *p = (const char *)sn;
   unsigned long n;
-  KsbaConstSexp endp;
+  char *endp;
 
   if (!p)
     log_printf ("none");
@@ -80,55 +92,71 @@ gpgsm_dump_serial (KsbaConstSexp p)
   else
     {
       p++;
-      n = strtoul (p, (char**)&endp, 10);
+      n = strtoul (p, &endp, 10);
       p = endp;
       if (*p!=':')
         log_printf ("ERROR - invalid S-expression");
       else
         {
           for (p++; n; n--, p++)
-            log_printf ("%02X", *p);
+            log_printf ("%02X", *(const unsigned char *)p);
         }
     }
 }
 
-void
-gpgsm_print_time (FILE *fp, time_t t)
+
+char *
+gpgsm_format_serial (ksba_const_sexp_t sn)
 {
-  if (!t)
-    fputs (_("none"), fp);
-  else if ( t == (time_t)(-1) )
-    fputs ("[Error - Invalid time]", fp);
-  else
-    {
-      struct tm *tp;
+  const char *p = (const char *)sn;
+  unsigned long n;
+  char *endp;
+  char *buffer;
+  int i;
+
+  if (!p)
+    return NULL;
 
-      tp = gmtime (&t);
-      fprintf (fp, "%04d-%02d-%02d %02d:%02d:%02d Z",
-               1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
-               tp->tm_hour, tp->tm_min, tp->tm_sec);
-      assert (!tp->tm_isdst);
+  if (*p != '(')
+    BUG (); /* Not a valid S-expression. */
+
+  p++;
+  n = strtoul (p, &endp, 10);
+  p = endp;
+  if (*p!=':')
+    BUG (); /* Not a valid S-expression. */
+  p++;
+
+  buffer = xtrymalloc (n*2+1);
+  if (buffer)
+    {
+      for (i=0; n; n--, p++, i+=2)
+        sprintf (buffer+i, "%02X", *(unsigned char *)p);
+      buffer[i] = 0;
     }
+  return buffer;
 }
 
+
+
+
 void
-gpgsm_dump_time (time_t t)
+gpgsm_print_time (FILE *fp, ksba_isotime_t t)
 {
-
-  if (!t)
-    log_printf ("none");
-  else if ( t == (time_t)(-1) )
-    log_printf ("error");
+  if (!t || !*t)
+    fputs (_("none"), fp);
   else
-    {
-      struct tm *tp;
+    fprintf (fp, "%.4s-%.2s-%.2s %.2s:%.2s:%s", t, t+4, t+6, t+9, t+11, t+13);
+}
 
-      tp = gmtime (&t);
-      log_printf ("%04d-%02d-%02d %02d:%02d:%02d",
-                  1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
-                  tp->tm_hour, tp->tm_min, tp->tm_sec);
-      assert (!tp->tm_isdst);
-    }
+void
+gpgsm_dump_time (ksba_isotime_t t)
+{
+  if (!t || !*t)
+    log_printf (_("[none]"));
+  else
+    log_printf ("%.4s-%.2s-%.2s %.2s:%.2s:%s",
+                t, t+4, t+6, t+9, t+11, t+13);
 }
 
 
@@ -144,7 +172,7 @@ gpgsm_dump_string (const char *string)
     {
       const unsigned char *s;
 
-      for (s=string; *s; s++)
+      for (s=(const unsigned char*)string; *s; s++)
         {
           if (*s < ' ' || (*s >= 0x7f && *s <= 0xa0))
             break;
@@ -161,13 +189,14 @@ gpgsm_dump_string (const char *string)
 }
 
 
+/* This simple dump function is mainly used for debugging purposes. */
 void 
-gpgsm_dump_cert (const char *text, KsbaCert cert)
+gpgsm_dump_cert (const char *text, ksba_cert_t cert)
 {
-  KsbaSexp sexp;
-  unsigned char *p;
+  ksba_sexp_t sexp;
+  char *p;
   char *dn;
-  time_t t;
+  ksba_isotime_t t;
 
   log_debug ("BEGIN Certificate `%s':\n", text? text:"");
   if (cert)
@@ -178,11 +207,11 @@ gpgsm_dump_cert (const char *text, KsbaCert cert)
       ksba_free (sexp);
       log_printf ("\n");
 
-      t = ksba_cert_get_validity (cert, 0);
+      ksba_cert_get_validity (cert, 0, t);
       log_debug ("  notBefore: ");
       gpgsm_dump_time (t);
       log_printf ("\n");
-      t = ksba_cert_get_validity (cert, 1);
+      ksba_cert_get_validity (cert, 1, t);
       log_debug ("   notAfter: ");
       gpgsm_dump_time (t);
       log_printf ("\n");
@@ -209,16 +238,66 @@ gpgsm_dump_cert (const char *text, KsbaCert cert)
 }
 
 
+/* Log the certificate's name in "#SN/ISSUERDN" format along with
+   TEXT. */
+void 
+gpgsm_cert_log_name (const char *text, ksba_cert_t cert)
+{
+  log_info ("%s", text? text:"certificate" );
+  if (cert)
+    {
+      ksba_sexp_t sn;
+      char *p;
+
+      p = ksba_cert_get_issuer (cert, 0);
+      sn = ksba_cert_get_serial (cert);
+      if (p && sn)
+        {
+          log_printf (" #");
+          gpgsm_dump_serial (sn);
+          log_printf ("/");
+          gpgsm_dump_string (p);
+        }
+      else
+        log_printf (" [invalid]");
+      ksba_free (sn);
+      xfree (p);
+    }
+  log_printf ("\n");
+}
+
+
+
 \f
 /* helper for the rfc2253 string parser */
 static const unsigned char *
 parse_dn_part (struct dn_array_s *array, const unsigned char *string)
 {
+  static struct {
+    const char *label;
+    const char *oid;
+  } label_map[] = {
+    /* Warning: When adding new labels, make sure that the buffer
+       below we be allocated large enough. */
+    {"EMail",        "1.2.840.113549.1.9.1" },
+    {"T",            "2.5.4.12" },
+    {"GN",           "2.5.4.42" },
+    {"SN",           "2.5.4.4" },
+    {"NameDistinguisher", "0.2.262.1.10.7.20"}, 
+    {"ADDR",         "2.5.4.16" },
+    {"BC",           "2.5.4.15" },
+    {"D",            "2.5.4.13" },
+    {"PostalCode",   "2.5.4.17" },
+    {"Pseudo",       "2.5.4.65" },
+    {"SerialNumber", "2.5.4.5" },
+    {NULL, NULL}
+  };
   const unsigned char *s, *s1;
   size_t n;
-  unsigned char *p;
+  char *p;
+  int i;
 
-  /* parse attributeType */
+  /* Parse attributeType */
   for (s = string+1; *s && *s != '='; s++)
     ;
   if (!*s)
@@ -226,14 +305,25 @@ parse_dn_part (struct dn_array_s *array, const unsigned char *string)
   n = s - string;
   if (!n)
     return NULL; /* empty key */
-  array->key = p = xtrymalloc (n+1);
+
+  /* We need to allocate a few bytes more due to the possible mapping
+     from the shorter OID to the longer label. */
+  array->key = p = xtrymalloc (n+10);
   if (!array->key)
     return NULL;
   memcpy (p, string, n); 
   p[n] = 0;
   trim_trailing_spaces (p);
-  if ( !strcmp (p, "1.2.840.113549.1.9.1") )
-    strcpy (p, "EMail");
+
+  if (digitp (p))
+    {
+      for (i=0; label_map[i].label; i++ )
+        if ( !strcmp (p, label_map[i].oid) )
+          {
+            strcpy (p, label_map[i].label);
+            break;
+          }
+    }
   string = s + 1;
 
   if (*string == '#')
@@ -243,13 +333,18 @@ parse_dn_part (struct dn_array_s *array, const unsigned char *string)
         s++;
       n = s - string;
       if (!n || (n & 1))
-        return NULL; /* empty or odd number of digits */
+        return NULL; /* Empty or odd number of digits. */
       n /= 2;
       array->value = p = xtrymalloc (n+1);
       if (!p)
         return NULL;
-      for (s1=string; n; s1 += 2, n--)
-        *p++ = xtoi_2 (s1);
+      for (s1=string; n; s1 += 2, n--, p++)
+        {
+          *(unsigned char *)p = xtoi_2 (s1);
+          if (!*p)
+            *p = 0x01; /* Better print a wrong value than truncating
+                          the string. */
+        }
       *p = 0;
    }
   else
@@ -290,7 +385,7 @@ parse_dn_part (struct dn_array_s *array, const unsigned char *string)
               s++;
               if (hexdigitp (s))
                 {
-                  *p++ = xtoi_2 (s);
+                  *(unsigned char *)p++ = xtoi_2 (s);
                   s++;
                 }
               else
@@ -339,11 +434,13 @@ parse_dn (const unsigned char *string)
       array[arrayidx].key = NULL;
       array[arrayidx].value = NULL;
       string = parse_dn_part (array+arrayidx, string);
-      arrayidx++;
       if (!string)
         goto failure;
       while (*string == ' ')
         string++;
+      array[arrayidx].multivalued = (*string == '+');
+      array[arrayidx].done = 0;
+      arrayidx++;
       if (*string && *string != ',' && *string != ';' && *string != '+')
         goto failure; /* invalid delimiter */
       if (*string)
@@ -364,85 +461,131 @@ parse_dn (const unsigned char *string)
 }
 
 
-static int
-print_dn_part (FILE *fp, struct dn_array_s *dn, const char *key,
-               int need_delim)
+static void
+print_dn_part (FILE *fp, struct dn_array_s *dn, const char *key, int translate)
 {
-  int any = 0;
+  struct dn_array_s *first_dn = dn;
 
   for (; dn->key; dn++)
     {
-      if (!strcmp (dn->key, key) && dn->value && *dn->value)
+      if (!dn->done && !strcmp (dn->key, key))
         {
-          if (need_delim)
+          /* Forward to the last multi-valued RDN, so that we can
+             print them all in reverse in the correct order.  Note
+             that this overrides the the standard sequence but that
+             seems to a reasonable thing to do with multi-valued
+             RDNs. */
+          while (dn->multivalued && dn[1].key)
+            dn++;
+        next:
+          if (!dn->done && dn->value && *dn->value)
             {
-              putc ('/', fp);
-              need_delim = 0;
+              fprintf (fp, "/%s=", dn->key);
+              if (translate)
+                print_sanitized_utf8_string (fp, dn->value, '/');
+              else
+                print_sanitized_string (fp, dn->value, '/');
+            }
+          dn->done = 1;
+          if (dn > first_dn && dn[-1].multivalued)
+            {
+              dn--;
+              goto next;
             }
-          if (any)
-            fputs (" + ", fp);
-          else
-            fprintf (fp, "%s=", key);
-          print_sanitized_utf8_string (fp, dn->value, '/');
-          any = 1;
         }
     }
-  return any;
 }
 
 /* Print all parts of a DN in a "standard" sequence.  We first print
    all the known parts, followed by the uncommon ones */
 static void
-print_dn_parts (FILE *fp, struct dn_array_s *dn)
+print_dn_parts (FILE *fp, struct dn_array_s *dn, int translate)
 {
   const char *stdpart[] = {
     "CN", "OU", "O", "STREET", "L", "ST", "C", "EMail", NULL 
   };
-  int any=0, i;
+  int i;
   
   for (i=0; stdpart[i]; i++)
-    {
-      if (print_dn_part (fp, dn, stdpart[i], any))
-        any = 1;
-    }
+      print_dn_part (fp, dn, stdpart[i], translate);
 
-  /* now print the rest without any specific ordering */
+  /* Now print the rest without any specific ordering */
   for (; dn->key; dn++)
+    print_dn_part (fp, dn, dn->key, translate);
+}
+
+
+/* Print the S-Expression in BUF, which has a valid length of BUFLEN,
+   as a human readable string in one line to FP. */
+static void
+pretty_print_sexp (FILE *fp, const unsigned char *buf, size_t buflen)
+{
+  size_t len;
+  gcry_sexp_t sexp;
+  char *result, *p;
+
+  if ( gcry_sexp_sscan (&sexp, NULL, (const char*)buf, buflen) )
     {
-      for (i=0; stdpart[i]; i++)
-        {
-          if (!strcmp (dn->key, stdpart[i]))
-            break;
-        }
-      if (!stdpart[i])
+      fputs (_("[Error - invalid encoding]"), fp);
+      return;
+    }
+  len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, NULL, 0);
+  assert (len);
+  result = xtrymalloc (len);
+  if (!result)
+    {
+      fputs (_("[Error - out of core]"), fp);
+      gcry_sexp_release (sexp);
+      return;
+    }
+  len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, result, len);
+  assert (len);
+  for (p = result; len; len--, p++)
+    {
+      if (*p == '\n')
         {
-          if (print_dn_part (fp, dn, dn->key, any))
-            any = 1;
+          if (len > 1) /* Avoid printing the trailing LF. */
+            fputs ("\\n", fp);
         }
+      else if (*p == '\r')
+        fputs ("\\r", fp);
+      else if (*p == '\v')
+        fputs ("\\v", fp);
+      else if (*p == '\t')
+        fputs ("\\t", fp);
+      else
+        putc (*p, fp);
     }
+  xfree (result);
+  gcry_sexp_release (sexp);
 }
 
 
-
 void
-gpgsm_print_name (FILE *fp, const char *name)
+gpgsm_print_name2 (FILE *fp, const char *name, int translate)
 {
-  const unsigned char *s;
+  const unsigned char *s = (const unsigned char *)name;
   int i;
 
-  s = name;
   if (!s)
     {
       fputs (_("[Error - No name]"), fp);
     }
   else if (*s == '<')
     {
-      const unsigned char *s2 = strchr (s+1, '>');
+      const char *s2 = strchr ( (char*)s+1, '>');
       if (s2)
-        print_sanitized_utf8_buffer (fp, s + 1, s2 - s - 1, 0);
+        {
+          if (translate)
+            print_sanitized_utf8_buffer (fp, s + 1, s2 - (char*)s - 1, 0);
+          else
+            print_sanitized_buffer (fp, s + 1, s2 - (char*)s - 1, 0);
+        }
     }
   else if (*s == '(')
-    fputs (_("[Error - unknown encoding]"), fp);
+    {
+      pretty_print_sexp (fp, s, gcry_sexp_canon_len (s, 0, NULL, NULL));
+    }
   else if (!((*s >= '0' && *s < '9')
              || (*s >= 'A' && *s <= 'Z')
              || (*s >= 'a' && *s <= 'z')))
@@ -454,7 +597,7 @@ gpgsm_print_name (FILE *fp, const char *name)
         fputs (_("[Error - invalid DN]"), fp);
       else 
         {
-          print_dn_parts (fp, dn);          
+          print_dn_parts (fp, dn, translate);          
           for (i=0; dn[i].key; i++)
             {
               xfree (dn[i].key);
@@ -466,4 +609,194 @@ gpgsm_print_name (FILE *fp, const char *name)
 }
 
 
+void
+gpgsm_print_name (FILE *fp, const char *name)
+{
+  gpgsm_print_name2 (fp, name, 1);
+}
+
+
+/* A cookie structure used for the memory stream. */
+struct format_name_cookie 
+{
+  char *buffer;         /* Malloced buffer with the data to deliver. */
+  size_t size;          /* Allocated size of this buffer. */
+  size_t len;           /* strlen (buffer). */
+  int error;            /* system error code if any. */
+};
+
+/* The writer function for the memory stream. */
+static int 
+format_name_writer (void *cookie, const char *buffer, size_t size)
+{
+  struct format_name_cookie *c = cookie;
+  char *p;
 
+  if (c->buffer)
+    p = xtryrealloc (c->buffer, c->size + size + 1);
+  else
+    p = xtrymalloc (size + 1);
+  if (!p)
+    {
+      c->error = errno;
+      xfree (c->buffer);
+      errno = c->error;
+      return -1;
+    }
+  c->buffer = p;
+  memcpy (p + c->len, buffer, size);
+  c->len += size;
+  p[c->len] = 0; /* Terminate string. */ 
+
+  return size;
+}
+
+/* Format NAME which is expected to be in rfc2253 format into a better
+   human readable format. Caller must free the returned string.  NULL
+   is returned in case of an error.  With TRANSLATE set to true the
+   name will be translated to the native encoding.  Note that NAME is
+   internally always UTF-8 encoded. */
+char *
+gpgsm_format_name2 (const char *name, int translate)
+{
+#if defined (HAVE_FOPENCOOKIE) || defined (HAVE_FUNOPEN)
+  FILE *fp;
+  struct format_name_cookie cookie;
+
+  memset (&cookie, 0, sizeof cookie);
+
+#ifdef HAVE_FOPENCOOKIE
+  {
+    cookie_io_functions_t io = { NULL };
+    io.write = format_name_writer;
+    
+    fp = fopencookie (&cookie, "w", io);
+  }
+#else /*!HAVE_FOPENCOOKIE*/
+  {
+    fp = funopen (&cookie, NULL, format_name_writer, NULL, NULL);
+  }
+#endif /*!HAVE_FOPENCOOKIE*/
+  if (!fp)
+    {
+      int save_errno = errno;
+      log_error ("error creating memory stream: %s\n", strerror (errno));
+      errno = save_errno;
+      return NULL;
+    }
+  gpgsm_print_name2 (fp, name, translate);
+  fclose (fp);
+  if (cookie.error || !cookie.buffer)
+    {
+      xfree (cookie.buffer);
+      errno = cookie.error;
+      return NULL;
+    }
+  return cookie.buffer;
+#else /* No fun - use the name verbatim. */
+  return xtrystrdup (name);
+#endif /* No fun. */
+}
+
+char *
+gpgsm_format_name (const char *name)
+{
+  return gpgsm_format_name2 (name, 1);
+}
+
+
+/* Create a key description for the CERT, this may be passed to the
+   pinentry.  The caller must free the returned string. NULL may be
+   returned on error. */
+char *
+gpgsm_format_keydesc (ksba_cert_t cert)
+{
+  int rc;
+  char *name, *subject, *buffer, *p;
+  const char *s;
+  ksba_isotime_t t;
+  char created[20];
+  char *sn;
+  ksba_sexp_t sexp;
+  char *orig_codeset = NULL;
+
+  name = ksba_cert_get_subject (cert, 0);
+  subject = name? gpgsm_format_name2 (name, 0) : NULL;
+  ksba_free (name); name = NULL;
+
+  sexp = ksba_cert_get_serial (cert);
+  sn = sexp? gpgsm_format_serial (sexp) : NULL;
+  ksba_free (sexp);
+
+  ksba_cert_get_validity (cert, 0, t);
+  if (t && *t)
+    sprintf (created, "%.4s-%.2s-%.2s", t, t+4, t+6);
+  else
+    *created = 0;
+
+
+#ifdef ENABLE_NLS
+  /* The Assuan agent protocol requires us to transmit utf-8 strings */
+  orig_codeset = bind_textdomain_codeset (PACKAGE_GT, NULL);
+#ifdef HAVE_LANGINFO_CODESET
+  if (!orig_codeset)
+    orig_codeset = nl_langinfo (CODESET);
+#endif
+  if (orig_codeset)
+    { /* We only switch when we are able to restore the codeset later.
+         Note that bind_textdomain_codeset does only return on memory
+         errors but not if a codeset is not available.  Thus we don't
+         bother printing a diagnostic here. */
+      orig_codeset = xstrdup (orig_codeset);
+      if (!bind_textdomain_codeset (PACKAGE_GT, "utf-8"))
+        orig_codeset = NULL; 
+    }
+#endif
+
+
+  rc = asprintf (&name,
+                 _("Please enter the passphrase to unlock the"
+                   " secret key for:\n"
+                   "\"%s\"\n"
+                   "S/N %s, ID %08lX, created %s" ),
+                 subject? subject:"?",
+                 sn? sn: "?",
+                 gpgsm_get_short_fingerprint (cert),
+                 created);
+
+#ifdef ENABLE_NLS
+  if (orig_codeset)
+    bind_textdomain_codeset (PACKAGE_GT, orig_codeset);
+#endif
+  xfree (orig_codeset);
+
+  if (rc < 0)
+    {
+      int save_errno = errno;
+      xfree (subject);
+      xfree (sn);
+      errno = save_errno;
+      return NULL;
+    }
+  
+  xfree (subject);
+  xfree (sn);
+
+  buffer = p = xtrymalloc (strlen (name) * 3 + 1);
+  for (s=name; *s; s++)
+    {
+      if (*s < ' ' || *s == '+')
+        {
+          sprintf (p, "%%%02X", *(unsigned char *)s);
+          p += 3;
+        }
+      else if (*s == ' ')
+        *p++ = '+';
+      else
+        *p++ = *s;
+    }
+  *p = 0;
+  free (name); 
+
+  return buffer;
+}