gpgtar: Improve error messages.
[gnupg.git] / sm / certdump.c
1 /* certdump.c - Dump a certificate for debugging
2  * Copyright (C) 2001-2010, 2014-2015  g10 Code GmbH
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <unistd.h>
26 #include <time.h>
27 #include <assert.h>
28 #ifdef HAVE_LOCALE_H
29 #include <locale.h>
30 #endif
31 #ifdef HAVE_LANGINFO_CODESET
32 #include <langinfo.h>
33 #endif
34
35 #include "gpgsm.h"
36 #include <gcrypt.h>
37 #include <ksba.h>
38
39 #include "keydb.h"
40 #include "../common/i18n.h"
41
42
43 struct dn_array_s {
44   char *key;
45   char *value;
46   int   multivalued;
47   int   done;
48 };
49
50
51 /* Print the first element of an S-Expression. */
52 void
53 gpgsm_print_serial (estream_t fp, ksba_const_sexp_t sn)
54 {
55   const char *p = (const char *)sn;
56   unsigned long n;
57   char *endp;
58
59   if (!p)
60     es_fputs (_("none"), fp);
61   else if (*p != '(')
62     es_fputs ("[Internal error - not an S-expression]", fp);
63   else
64     {
65       p++;
66       n = strtoul (p, &endp, 10);
67       p = endp;
68       if (*p++ != ':')
69         es_fputs ("[Internal Error - invalid S-expression]", fp);
70       else
71         es_write_hexstring (fp, p, n, 0, NULL);
72     }
73 }
74
75
76 /* Dump the serial number or any other simple S-expression. */
77 void
78 gpgsm_dump_serial (ksba_const_sexp_t sn)
79 {
80   const char *p = (const char *)sn;
81   unsigned long n;
82   char *endp;
83
84   if (!p)
85     log_printf ("none");
86   else if (*p != '(')
87     log_printf ("ERROR - not an S-expression");
88   else
89     {
90       p++;
91       n = strtoul (p, &endp, 10);
92       p = endp;
93       if (*p!=':')
94         log_printf ("ERROR - invalid S-expression");
95       else
96         {
97           for (p++; n; n--, p++)
98             log_printf ("%02X", *(const unsigned char *)p);
99         }
100     }
101 }
102
103
104 char *
105 gpgsm_format_serial (ksba_const_sexp_t sn)
106 {
107   const char *p = (const char *)sn;
108   unsigned long n;
109   char *endp;
110   char *buffer;
111   int i;
112
113   if (!p)
114     return NULL;
115
116   if (*p != '(')
117     BUG (); /* Not a valid S-expression. */
118
119   p++;
120   n = strtoul (p, &endp, 10);
121   p = endp;
122   if (*p!=':')
123     BUG (); /* Not a valid S-expression. */
124   p++;
125
126   buffer = xtrymalloc (n*2+1);
127   if (buffer)
128     {
129       for (i=0; n; n--, p++, i+=2)
130         sprintf (buffer+i, "%02X", *(unsigned char *)p);
131       buffer[i] = 0;
132     }
133   return buffer;
134 }
135
136
137
138
139 void
140 gpgsm_print_time (estream_t fp, ksba_isotime_t t)
141 {
142   if (!t || !*t)
143     es_fputs (_("none"), fp);
144   else
145     es_fprintf (fp, "%.4s-%.2s-%.2s %.2s:%.2s:%s",
146                 t, t+4, t+6, t+9, t+11, t+13);
147 }
148
149
150 void
151 gpgsm_dump_string (const char *string)
152 {
153
154   if (!string)
155     log_printf ("[error]");
156   else
157     {
158       const unsigned char *s;
159
160       for (s=(const unsigned char*)string; *s; s++)
161         {
162           if (*s < ' ' || (*s >= 0x7f && *s <= 0xa0))
163             break;
164         }
165       if (!*s && *string != '[')
166         log_printf ("%s", string);
167       else
168         {
169           log_printf ( "[ ");
170           log_printhex (string, strlen (string), NULL);
171           log_printf ( " ]");
172         }
173     }
174 }
175
176
177 /* This simple dump function is mainly used for debugging purposes. */
178 void
179 gpgsm_dump_cert (const char *text, ksba_cert_t cert)
180 {
181   ksba_sexp_t sexp;
182   char *p;
183   char *dn;
184   ksba_isotime_t t;
185
186   log_debug ("BEGIN Certificate '%s':\n", text? text:"");
187   if (cert)
188     {
189       sexp = ksba_cert_get_serial (cert);
190       log_debug ("     serial: ");
191       gpgsm_dump_serial (sexp);
192       ksba_free (sexp);
193       log_printf ("\n");
194
195       ksba_cert_get_validity (cert, 0, t);
196       log_debug ("  notBefore: ");
197       dump_isotime (t);
198       log_printf ("\n");
199       ksba_cert_get_validity (cert, 1, t);
200       log_debug ("   notAfter: ");
201       dump_isotime (t);
202       log_printf ("\n");
203
204       dn = ksba_cert_get_issuer (cert, 0);
205       log_debug ("     issuer: ");
206       gpgsm_dump_string (dn);
207       ksba_free (dn);
208       log_printf ("\n");
209
210       dn = ksba_cert_get_subject (cert, 0);
211       log_debug ("    subject: ");
212       gpgsm_dump_string (dn);
213       ksba_free (dn);
214       log_printf ("\n");
215
216       log_debug ("  hash algo: %s\n", ksba_cert_get_digest_algo (cert));
217
218       p = gpgsm_get_fingerprint_string (cert, 0);
219       log_debug ("  SHA1 Fingerprint: %s\n", p);
220       xfree (p);
221     }
222   log_debug ("END Certificate\n");
223 }
224
225
226 /* Return a new string holding the format serial number and issuer
227    ("#SN/issuer").  No filtering on invalid characters is done.
228    Caller must release the string.  On memory failure NULL is
229    returned.  */
230 char *
231 gpgsm_format_sn_issuer (ksba_sexp_t sn, const char *issuer)
232 {
233   char *p, *p1;
234
235   if (sn && issuer)
236     {
237       p1 = gpgsm_format_serial (sn);
238       if (!p1)
239         p = xtrystrdup ("[invalid SN]");
240       else
241         {
242           p = xtrymalloc (strlen (p1) + strlen (issuer) + 2 + 1);
243           if (p)
244             {
245               *p = '#';
246               strcpy (stpcpy (stpcpy (p+1, p1),"/"), issuer);
247             }
248           xfree (p1);
249         }
250     }
251   else
252     p = xtrystrdup ("[invalid SN/issuer]");
253   return p;
254 }
255
256
257 /* Log the certificate's name in "#SN/ISSUERDN" format along with
258    TEXT. */
259 void
260 gpgsm_cert_log_name (const char *text, ksba_cert_t cert)
261 {
262   log_info ("%s", text? text:"certificate" );
263   if (cert)
264     {
265       ksba_sexp_t sn;
266       char *p;
267
268       p = ksba_cert_get_issuer (cert, 0);
269       sn = ksba_cert_get_serial (cert);
270       if (p && sn)
271         {
272           log_printf (" #");
273           gpgsm_dump_serial (sn);
274           log_printf ("/");
275           gpgsm_dump_string (p);
276         }
277       else
278         log_printf (" [invalid]");
279       ksba_free (sn);
280       xfree (p);
281     }
282   log_printf ("\n");
283 }
284
285
286
287
288
289 \f
290 /* helper for the rfc2253 string parser */
291 static const unsigned char *
292 parse_dn_part (struct dn_array_s *array, const unsigned char *string)
293 {
294   static struct {
295     const char *label;
296     const char *oid;
297   } label_map[] = {
298     /* Warning: When adding new labels, make sure that the buffer
299        below we be allocated large enough. */
300     {"EMail",        "1.2.840.113549.1.9.1" },
301     {"T",            "2.5.4.12" },
302     {"GN",           "2.5.4.42" },
303     {"SN",           "2.5.4.4" },
304     {"NameDistinguisher", "0.2.262.1.10.7.20"},
305     {"ADDR",         "2.5.4.16" },
306     {"BC",           "2.5.4.15" },
307     {"D",            "2.5.4.13" },
308     {"PostalCode",   "2.5.4.17" },
309     {"Pseudo",       "2.5.4.65" },
310     {"SerialNumber", "2.5.4.5" },
311     {NULL, NULL}
312   };
313   const unsigned char *s, *s1;
314   size_t n;
315   char *p;
316   int i;
317
318   /* Parse attributeType */
319   for (s = string+1; *s && *s != '='; s++)
320     ;
321   if (!*s)
322     return NULL; /* error */
323   n = s - string;
324   if (!n)
325     return NULL; /* empty key */
326
327   /* We need to allocate a few bytes more due to the possible mapping
328      from the shorter OID to the longer label. */
329   array->key = p = xtrymalloc (n+10);
330   if (!array->key)
331     return NULL;
332   memcpy (p, string, n);
333   p[n] = 0;
334   trim_trailing_spaces (p);
335
336   if (digitp (p))
337     {
338       for (i=0; label_map[i].label; i++ )
339         if ( !strcmp (p, label_map[i].oid) )
340           {
341             strcpy (p, label_map[i].label);
342             break;
343           }
344     }
345   string = s + 1;
346
347   if (*string == '#')
348     { /* hexstring */
349       string++;
350       for (s=string; hexdigitp (s); s++)
351         s++;
352       n = s - string;
353       if (!n || (n & 1))
354         return NULL; /* Empty or odd number of digits. */
355       n /= 2;
356       array->value = p = xtrymalloc (n+1);
357       if (!p)
358         return NULL;
359       for (s1=string; n; s1 += 2, n--, p++)
360         {
361           *(unsigned char *)p = xtoi_2 (s1);
362           if (!*p)
363             *p = 0x01; /* Better print a wrong value than truncating
364                           the string. */
365         }
366       *p = 0;
367    }
368   else
369     { /* regular v3 quoted string */
370       for (n=0, s=string; *s; s++)
371         {
372           if (*s == '\\')
373             { /* pair */
374               s++;
375               if (*s == ',' || *s == '=' || *s == '+'
376                   || *s == '<' || *s == '>' || *s == '#' || *s == ';'
377                   || *s == '\\' || *s == '\"' || *s == ' ')
378                 n++;
379               else if (hexdigitp (s) && hexdigitp (s+1))
380                 {
381                   s++;
382                   n++;
383                 }
384               else
385                 return NULL; /* invalid escape sequence */
386             }
387           else if (*s == '\"')
388             return NULL; /* invalid encoding */
389           else if (*s == ',' || *s == '=' || *s == '+'
390                    || *s == '<' || *s == '>' || *s == ';' )
391             break;
392           else
393             n++;
394         }
395
396       array->value = p = xtrymalloc (n+1);
397       if (!p)
398         return NULL;
399       for (s=string; n; s++, n--)
400         {
401           if (*s == '\\')
402             {
403               s++;
404               if (hexdigitp (s))
405                 {
406                   *(unsigned char *)p++ = xtoi_2 (s);
407                   s++;
408                 }
409               else
410                 *p++ = *s;
411             }
412           else
413             *p++ = *s;
414         }
415       *p = 0;
416     }
417   return s;
418 }
419
420
421 /* Parse a DN and return an array-ized one.  This is not a validating
422    parser and it does not support any old-stylish syntax; KSBA is
423    expected to return only rfc2253 compatible strings. */
424 static struct dn_array_s *
425 parse_dn (const unsigned char *string)
426 {
427   struct dn_array_s *array;
428   size_t arrayidx, arraysize;
429   int i;
430
431   arraysize = 7; /* C,ST,L,O,OU,CN,email */
432   arrayidx = 0;
433   array = xtrymalloc ((arraysize+1) * sizeof *array);
434   if (!array)
435     return NULL;
436   while (*string)
437     {
438       while (*string == ' ')
439         string++;
440       if (!*string)
441         break; /* ready */
442       if (arrayidx >= arraysize)
443         {
444           struct dn_array_s *a2;
445
446           arraysize += 5;
447           a2 = xtryrealloc (array, (arraysize+1) * sizeof *array);
448           if (!a2)
449             goto failure;
450           array = a2;
451         }
452       array[arrayidx].key = NULL;
453       array[arrayidx].value = NULL;
454       string = parse_dn_part (array+arrayidx, string);
455       if (!string)
456         goto failure;
457       while (*string == ' ')
458         string++;
459       array[arrayidx].multivalued = (*string == '+');
460       array[arrayidx].done = 0;
461       arrayidx++;
462       if (*string && *string != ',' && *string != ';' && *string != '+')
463         goto failure; /* invalid delimiter */
464       if (*string)
465         string++;
466     }
467   array[arrayidx].key = NULL;
468   array[arrayidx].value = NULL;
469   return array;
470
471  failure:
472   for (i=0; i < arrayidx; i++)
473     {
474       xfree (array[i].key);
475       xfree (array[i].value);
476     }
477   xfree (array);
478   return NULL;
479 }
480
481
482 /* Print a DN part to STREAM. */
483 static void
484 print_dn_part (estream_t stream,
485                struct dn_array_s *dn, const char *key, int translate)
486 {
487   struct dn_array_s *first_dn = dn;
488
489   for (; dn->key; dn++)
490     {
491       if (!dn->done && !strcmp (dn->key, key))
492         {
493           /* Forward to the last multi-valued RDN, so that we can
494              print them all in reverse in the correct order.  Note
495              that this overrides the standard sequence but that
496              seems to a reasonable thing to do with multi-valued
497              RDNs. */
498           while (dn->multivalued && dn[1].key)
499             dn++;
500         next:
501           if (!dn->done && dn->value && *dn->value)
502             {
503               es_fprintf (stream, "/%s=", dn->key);
504               if (translate)
505                 print_utf8_buffer3 (stream, dn->value, strlen (dn->value),
506                                     "/");
507               else
508                 es_write_sanitized (stream, dn->value, strlen (dn->value),
509                                     "/", NULL);
510             }
511           dn->done = 1;
512           if (dn > first_dn && dn[-1].multivalued)
513             {
514               dn--;
515               goto next;
516             }
517         }
518     }
519 }
520
521 /* Print all parts of a DN in a "standard" sequence.  We first print
522    all the known parts, followed by the uncommon ones */
523 static void
524 print_dn_parts (estream_t stream,
525                 struct dn_array_s *dn, int translate)
526 {
527   const char *stdpart[] = {
528     "CN", "OU", "O", "STREET", "L", "ST", "C", "EMail", NULL
529   };
530   int i;
531
532   for (i=0; stdpart[i]; i++)
533       print_dn_part (stream, dn, stdpart[i], translate);
534
535   /* Now print the rest without any specific ordering */
536   for (; dn->key; dn++)
537     print_dn_part (stream, dn, dn->key, translate);
538 }
539
540
541 /* Print the S-Expression in BUF to extended STREAM, which has a valid
542    length of BUFLEN, as a human readable string in one line to FP. */
543 static void
544 pretty_es_print_sexp (estream_t fp, const unsigned char *buf, size_t buflen)
545 {
546   size_t len;
547   gcry_sexp_t sexp;
548   char *result, *p;
549
550   if ( gcry_sexp_sscan (&sexp, NULL, (const char*)buf, buflen) )
551     {
552       es_fputs (_("[Error - invalid encoding]"), fp);
553       return;
554     }
555   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, NULL, 0);
556   assert (len);
557   result = xtrymalloc (len);
558   if (!result)
559     {
560       es_fputs (_("[Error - out of core]"), fp);
561       gcry_sexp_release (sexp);
562       return;
563     }
564   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, result, len);
565   assert (len);
566   for (p = result; len; len--, p++)
567     {
568       if (*p == '\n')
569         {
570           if (len > 1) /* Avoid printing the trailing LF. */
571             es_fputs ("\\n", fp);
572         }
573       else if (*p == '\r')
574         es_fputs ("\\r", fp);
575       else if (*p == '\v')
576         es_fputs ("\\v", fp);
577       else if (*p == '\t')
578         es_fputs ("\\t", fp);
579       else
580         es_putc (*p, fp);
581     }
582   xfree (result);
583   gcry_sexp_release (sexp);
584 }
585
586
587 /* This is a variant of gpgsm_print_name sending it output to an estream. */
588 void
589 gpgsm_es_print_name2 (estream_t fp, const char *name, int translate)
590 {
591   const unsigned char *s = (const unsigned char *)name;
592   int i;
593
594   if (!s)
595     {
596       es_fputs (_("[Error - No name]"), fp);
597     }
598   else if (*s == '<')
599     {
600       const char *s2 = strchr ( (char*)s+1, '>');
601
602       if (s2)
603         {
604           if (translate)
605             print_utf8_buffer (fp, s + 1, s2 - (char*)s - 1);
606           else
607             es_write_sanitized (fp, s + 1, s2 - (char*)s - 1, NULL, NULL);
608         }
609     }
610   else if (*s == '(')
611     {
612       pretty_es_print_sexp (fp, s, gcry_sexp_canon_len (s, 0, NULL, NULL));
613     }
614   else if (!((*s >= '0' && *s < '9')
615              || (*s >= 'A' && *s <= 'Z')
616              || (*s >= 'a' && *s <= 'z')))
617     es_fputs (_("[Error - invalid encoding]"), fp);
618   else
619     {
620       struct dn_array_s *dn = parse_dn (s);
621
622       if (!dn)
623         es_fputs (_("[Error - invalid DN]"), fp);
624       else
625         {
626           print_dn_parts (fp, dn, translate);
627           for (i=0; dn[i].key; i++)
628             {
629               xfree (dn[i].key);
630               xfree (dn[i].value);
631             }
632           xfree (dn);
633         }
634     }
635 }
636
637
638 void
639 gpgsm_es_print_name (estream_t fp, const char *name)
640 {
641   gpgsm_es_print_name2 (fp, name, 1);
642 }
643
644
645 /* A cookie structure used for the memory stream. */
646 struct format_name_cookie
647 {
648   char *buffer;         /* Malloced buffer with the data to deliver. */
649   size_t size;          /* Allocated size of this buffer. */
650   size_t len;           /* strlen (buffer). */
651   int error;            /* system error code if any. */
652 };
653
654 /* The writer function for the memory stream. */
655 static gpgrt_ssize_t
656 format_name_writer (void *cookie, const void *buffer, size_t size)
657 {
658   struct format_name_cookie *c = cookie;
659   char *p;
660
661   if (!c->buffer)
662     {
663       p = xtrymalloc (size + 1 + 1);
664       if (p)
665         {
666           c->size = size + 1;
667           c->buffer = p;
668           c->len = 0;
669         }
670     }
671   else if (c->len + size < c->len)
672     {
673       p = NULL;
674       gpg_err_set_errno (ENOMEM);
675     }
676   else if (c->size < c->len + size)
677     {
678       p = xtryrealloc (c->buffer, c->len + size + 1);
679       if (p)
680         {
681           c->size = c->len + size;
682           c->buffer = p;
683         }
684     }
685   else
686     p = c->buffer;
687   if (!p)
688     {
689       c->error = errno;
690       xfree (c->buffer);
691       c->buffer = NULL;
692       gpg_err_set_errno (c->error);
693       return -1;
694     }
695   memcpy (p + c->len, buffer, size);
696   c->len += size;
697   p[c->len] = 0; /* Terminate string. */
698
699   return (gpgrt_ssize_t)size;
700 }
701
702
703 /* Format NAME which is expected to be in rfc2253 format into a better
704    human readable format. Caller must free the returned string.  NULL
705    is returned in case of an error.  With TRANSLATE set to true the
706    name will be translated to the native encoding.  Note that NAME is
707    internally always UTF-8 encoded. */
708 char *
709 gpgsm_format_name2 (const char *name, int translate)
710 {
711   estream_t fp;
712   struct format_name_cookie cookie;
713   es_cookie_io_functions_t io = { NULL };
714
715   memset (&cookie, 0, sizeof cookie);
716
717   io.func_write = format_name_writer;
718   fp = es_fopencookie (&cookie, "w", io);
719   if (!fp)
720     {
721       int save_errno = errno;
722       log_error ("error creating memory stream: %s\n", strerror (save_errno));
723       gpg_err_set_errno (save_errno);
724       return NULL;
725     }
726   gpgsm_es_print_name2 (fp, name, translate);
727   es_fclose (fp);
728   if (cookie.error || !cookie.buffer)
729     {
730       xfree (cookie.buffer);
731       gpg_err_set_errno (cookie.error);
732       return NULL;
733     }
734   return cookie.buffer;
735 }
736
737
738 char *
739 gpgsm_format_name (const char *name)
740 {
741   return gpgsm_format_name2 (name, 1);
742 }
743
744
745 /* Return fingerprint and a percent escaped name in a human readable
746    format suitable for status messages like GOODSIG.  May return NULL
747    on error (out of core). */
748 char *
749 gpgsm_fpr_and_name_for_status (ksba_cert_t cert)
750 {
751   char *fpr, *name, *p;
752   char *buffer;
753
754   fpr = gpgsm_get_fingerprint_hexstring (cert, GCRY_MD_SHA1);
755   if (!fpr)
756     return NULL;
757
758   name = ksba_cert_get_subject (cert, 0);
759   if (!name)
760     {
761       xfree (fpr);
762       return NULL;
763     }
764
765   p = gpgsm_format_name2 (name, 0);
766   ksba_free (name);
767   name = p;
768   if (!name)
769     {
770       xfree (fpr);
771       return NULL;
772     }
773
774   buffer = xtrymalloc (strlen (fpr) + 1 + 3*strlen (name) + 1);
775   if (buffer)
776     {
777       const char *s;
778
779       p = stpcpy (stpcpy (buffer, fpr), " ");
780       for (s = name; *s; s++)
781         {
782           if (*s < ' ')
783             {
784               sprintf (p, "%%%02X", *(const unsigned char*)s);
785               p += 3;
786             }
787           else
788             *p++ = *s;
789         }
790       *p = 0;
791     }
792   xfree (fpr);
793   xfree (name);
794   return buffer;
795 }
796
797
798 /* Create a key description for the CERT, this may be passed to the
799    pinentry.  The caller must free the returned string.  NULL may be
800    returned on error. */
801 char *
802 gpgsm_format_keydesc (ksba_cert_t cert)
803 {
804   char *name, *subject, *buffer;
805   ksba_isotime_t t;
806   char created[20];
807   char expires[20];
808   char *sn;
809   ksba_sexp_t sexp;
810   char *orig_codeset;
811
812   name = ksba_cert_get_subject (cert, 0);
813   subject = name? gpgsm_format_name2 (name, 0) : NULL;
814   ksba_free (name); name = NULL;
815
816   sexp = ksba_cert_get_serial (cert);
817   sn = sexp? gpgsm_format_serial (sexp) : NULL;
818   ksba_free (sexp);
819
820   ksba_cert_get_validity (cert, 0, t);
821   if (*t)
822     sprintf (created, "%.4s-%.2s-%.2s", t, t+4, t+6);
823   else
824     *created = 0;
825   ksba_cert_get_validity (cert, 1, t);
826   if (*t)
827     sprintf (expires, "%.4s-%.2s-%.2s", t, t+4, t+6);
828   else
829     *expires = 0;
830
831   orig_codeset = i18n_switchto_utf8 ();
832
833   name = xtryasprintf (_("Please enter the passphrase to unlock the"
834                          " secret key for the X.509 certificate:\n"
835                          "\"%s\"\n"
836                          "S/N %s, ID 0x%08lX,\n"
837                          "created %s, expires %s.\n" ),
838                        subject? subject:"?",
839                        sn? sn: "?",
840                        gpgsm_get_short_fingerprint (cert, NULL),
841                        created, expires);
842
843   i18n_switchback (orig_codeset);
844
845   if (!name)
846     {
847       xfree (subject);
848       xfree (sn);
849       return NULL;
850     }
851
852   xfree (subject);
853   xfree (sn);
854
855   buffer = percent_plus_escape (name);
856   xfree (name);
857   return buffer;
858 }