dirmngr: Use "pgpkey-hkps" and "pgpkey-hkp" for SRV record lookups.
[gnupg.git] / dirmngr / misc.c
1 /* misc.c - miscellaneous
2  *      Copyright (C) 2002 Klarälvdalens Datakonsult AB
3  *      Copyright (C) 2002, 2003, 2004, 2010 Free Software Foundation, Inc.
4  *
5  * This file is part of DirMngr.
6  *
7  * DirMngr is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * DirMngr is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <time.h>
27 #include <errno.h>
28
29 #include "dirmngr.h"
30 #include "util.h"
31 #include "misc.h"
32
33
34 /* Convert the hex encoded STRING back into binary and store the
35    result into the provided buffer RESULT.  The actual size of that
36    buffer will be returned.  The caller should provide RESULT of at
37    least strlen(STRING)/2 bytes.  There is no error detection, the
38    parsing stops at the first non hex character.  With RESULT given as
39    NULL, the function does only return the size of the buffer which
40    would be needed.  */
41 size_t
42 unhexify (unsigned char *result, const char *string)
43 {
44   const char *s;
45   size_t n;
46
47   for (s=string,n=0; hexdigitp (s) && hexdigitp(s+1); s += 2)
48     {
49       if (result)
50         result[n] = xtoi_2 (s);
51       n++;
52     }
53   return n;
54 }
55
56
57 char*
58 hashify_data( const char* data, size_t len )
59 {
60   unsigned char buf[20];
61   gcry_md_hash_buffer (GCRY_MD_SHA1, buf, data, len);
62   return hexify_data (buf, 20, 0);
63 }
64
65 char*
66 hexify_data (const unsigned char* data, size_t len, int with_prefix)
67 {
68   int i;
69   char *result = xmalloc (2*len + (with_prefix?2:0) + 1);
70   char *p;
71
72   if (with_prefix)
73     p = stpcpy (result, "0x");
74   else
75     p = result;
76
77   for (i = 0; i < 2*len; i+=2 )
78     snprintf (p+i, 3, "%02X", *data++);
79   return result;
80 }
81
82 char *
83 serial_hex (ksba_sexp_t serial )
84 {
85   unsigned char* p = serial;
86   char *endp;
87   unsigned long n;
88   char *certid;
89
90   if (!p)
91     return NULL;
92   else {
93     p++; /* ignore initial '(' */
94     n = strtoul (p, (char**)&endp, 10);
95     p = endp;
96     if (*p!=':')
97       return NULL;
98     else {
99       int i = 0;
100       certid = xmalloc( sizeof( char )*(2*n + 1 ) );
101       for (p++; n; n--, p++) {
102         sprintf ( certid+i , "%02X", *p);
103         i += 2;
104       }
105     }
106   }
107   return certid;
108 }
109
110
111 /* Take an S-Expression encoded blob and return a pointer to the
112    actual data as well as its length.  Return NULL for an invalid
113    S-Expression.*/
114 const unsigned char *
115 serial_to_buffer (const ksba_sexp_t serial, size_t *length)
116 {
117   unsigned char *p = serial;
118   char *endp;
119   unsigned long n;
120
121   if (!p || *p != '(')
122     return NULL;
123   p++;
124   n = strtoul (p, &endp, 10);
125   p = endp;
126   if (*p != ':')
127     return NULL;
128   p++;
129   *length = n;
130   return p;
131 }
132
133
134 /* Do an in-place percent unescaping of STRING. Returns STRING. Note
135    that this function does not do a '+'-to-space unescaping.*/
136 char *
137 unpercent_string (char *string)
138 {
139   char *s = string;
140   char *d = string;
141
142   while (*s)
143     {
144       if (*s == '%' && s[1] && s[2])
145         {
146           s++;
147           *d++ = xtoi_2 ( s);
148           s += 2;
149         }
150       else
151         *d++ = *s++;
152     }
153   *d = 0;
154   return string;
155 }
156
157 /* Convert a canonical encoded S-expression in CANON into the GCRY
158    type. */
159 gpg_error_t
160 canon_sexp_to_gcry (const unsigned char *canon, gcry_sexp_t *r_sexp)
161 {
162   gpg_error_t err;
163   size_t n;
164   gcry_sexp_t sexp;
165
166   *r_sexp = NULL;
167   n = gcry_sexp_canon_len (canon, 0, NULL, NULL);
168   if (!n)
169     {
170       log_error (_("invalid canonical S-expression found\n"));
171       err = gpg_error (GPG_ERR_INV_SEXP);
172     }
173   else if ((err = gcry_sexp_sscan (&sexp, NULL, canon, n)))
174     log_error (_("converting S-expression failed: %s\n"), gcry_strerror (err));
175   else
176     *r_sexp = sexp;
177   return err;
178 }
179
180
181 /* Return an allocated buffer with the formatted fingerprint as one
182    large hexnumber */
183 char *
184 get_fingerprint_hexstring (ksba_cert_t cert)
185 {
186   unsigned char digest[20];
187   gcry_md_hd_t md;
188   int rc;
189   char *buf;
190   int i;
191
192   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0);
193   if (rc)
194     log_fatal (_("gcry_md_open failed: %s\n"), gpg_strerror (rc));
195
196   rc = ksba_cert_hash (cert, 0, HASH_FNC, md);
197   if (rc)
198     {
199       log_error (_("oops: ksba_cert_hash failed: %s\n"), gpg_strerror (rc));
200       memset (digest, 0xff, 20); /* Use a dummy value. */
201     }
202   else
203     {
204       gcry_md_final (md);
205       memcpy (digest, gcry_md_read (md, GCRY_MD_SHA1), 20);
206     }
207   gcry_md_close (md);
208   buf = xmalloc (41);
209   *buf = 0;
210   for (i=0; i < 20; i++ )
211     sprintf (buf+strlen(buf), "%02X", digest[i]);
212   return buf;
213 }
214
215 /* Return an allocated buffer with the formatted fingerprint as one
216    large hexnumber.  This version inserts the usual colons. */
217 char *
218 get_fingerprint_hexstring_colon (ksba_cert_t cert)
219 {
220   unsigned char digest[20];
221   gcry_md_hd_t md;
222   int rc;
223   char *buf;
224   int i;
225
226   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0);
227   if (rc)
228     log_fatal (_("gcry_md_open failed: %s\n"), gpg_strerror (rc));
229
230   rc = ksba_cert_hash (cert, 0, HASH_FNC, md);
231   if (rc)
232     {
233       log_error (_("oops: ksba_cert_hash failed: %s\n"), gpg_strerror (rc));
234       memset (digest, 0xff, 20); /* Use a dummy value. */
235     }
236   else
237     {
238       gcry_md_final (md);
239       memcpy (digest, gcry_md_read (md, GCRY_MD_SHA1), 20);
240     }
241   gcry_md_close (md);
242   buf = xmalloc (61);
243   *buf = 0;
244   for (i=0; i < 20; i++ )
245     sprintf (buf+strlen(buf), "%02X:", digest[i]);
246   buf[strlen(buf)-1] = 0; /* Remove railing colon. */
247   return buf;
248 }
249
250
251 /* Dump the serial number SERIALNO to the log stream.  */
252 void
253 dump_serial (ksba_sexp_t serialno)
254 {
255   char *p;
256
257   p = serial_hex (serialno);
258   log_printf ("%s", p?p:"?");
259   xfree (p);
260 }
261
262
263 /* Dump STRING to the log file but choose the best readable
264    format.  */
265 void
266 dump_string (const char *string)
267 {
268
269   if (!string)
270     log_printf ("[error]");
271   else
272     {
273       const unsigned char *s;
274
275       for (s=string; *s; s++)
276         {
277           if (*s < ' ' || (*s >= 0x7f && *s <= 0xa0))
278             break;
279         }
280       if (!*s && *string != '[')
281         log_printf ("%s", string);
282       else
283         {
284           log_printf ( "[ ");
285           log_printhex (NULL, string, strlen (string));
286           log_printf ( " ]");
287         }
288     }
289 }
290
291 /* Dump an KSBA cert object to the log stream. Prefix the output with
292    TEXT.  This is used for debugging. */
293 void
294 dump_cert (const char *text, ksba_cert_t cert)
295 {
296   ksba_sexp_t sexp;
297   char *p;
298   ksba_isotime_t t;
299   int idx;
300
301   log_debug ("BEGIN Certificate '%s':\n", text? text:"");
302   if (cert)
303     {
304       sexp = ksba_cert_get_serial (cert);
305       p = serial_hex (sexp);
306       log_debug ("     serial: %s\n", p?p:"?");
307       xfree (p);
308       ksba_free (sexp);
309
310       ksba_cert_get_validity (cert, 0, t);
311       log_debug ("  notBefore: ");
312       dump_isotime (t);
313       log_printf ("\n");
314       ksba_cert_get_validity (cert, 1, t);
315       log_debug ("   notAfter: ");
316       dump_isotime (t);
317       log_printf ("\n");
318
319       p = ksba_cert_get_issuer (cert, 0);
320       log_debug ("     issuer: ");
321       dump_string (p);
322       ksba_free (p);
323       log_printf ("\n");
324
325       p = ksba_cert_get_subject (cert, 0);
326       log_debug ("    subject: ");
327       dump_string (p);
328       ksba_free (p);
329       log_printf ("\n");
330       for (idx=1; (p = ksba_cert_get_subject (cert, idx)); idx++)
331         {
332           log_debug ("        aka: ");
333           dump_string (p);
334           ksba_free (p);
335           log_printf ("\n");
336         }
337
338       log_debug ("  hash algo: %s\n", ksba_cert_get_digest_algo (cert));
339
340       p = get_fingerprint_hexstring (cert);
341       log_debug ("  SHA1 fingerprint: %s\n", p);
342       xfree (p);
343     }
344   log_debug ("END Certificate\n");
345 }
346
347
348
349 /* Log the certificate's name in "#SN/ISSUERDN" format along with
350    TEXT. */
351 void
352 cert_log_name (const char *text, ksba_cert_t cert)
353 {
354   log_info ("%s", text? text:"certificate" );
355   if (cert)
356     {
357       ksba_sexp_t sn;
358       char *p;
359
360       p = ksba_cert_get_issuer (cert, 0);
361       sn = ksba_cert_get_serial (cert);
362       if (p && sn)
363         {
364           log_printf (" #");
365           dump_serial (sn);
366           log_printf ("/");
367           dump_string (p);
368         }
369       else
370         log_printf (" [invalid]");
371       ksba_free (sn);
372       xfree (p);
373     }
374   log_printf ("\n");
375 }
376
377
378 /* Log the certificate's subject DN along with TEXT. */
379 void
380 cert_log_subject (const char *text, ksba_cert_t cert)
381 {
382   log_info ("%s", text? text:"subject" );
383   if (cert)
384     {
385       char *p;
386
387       p = ksba_cert_get_subject (cert, 0);
388       if (p)
389         {
390           log_printf (" /");
391           dump_string (p);
392           xfree (p);
393         }
394       else
395         log_printf (" [invalid]");
396     }
397   log_printf ("\n");
398 }
399
400
401 /* Callback to print infos about the TLS certificates.  */
402 void
403 cert_log_cb (http_session_t sess, gpg_error_t err,
404              const char *hostname, const void **certs, size_t *certlens)
405 {
406   ksba_cert_t cert;
407   size_t n;
408
409   (void)sess;
410
411   if (!err)
412     return; /* No error - no need to log anything  */
413
414   log_debug ("expected hostname: %s\n", hostname);
415   for (n=0; certs[n]; n++)
416     {
417       err = ksba_cert_new (&cert);
418       if (!err)
419         err = ksba_cert_init_from_mem (cert, certs[n], certlens[n]);
420       if (err)
421         log_error ("error parsing cert for logging: %s\n", gpg_strerror (err));
422       else
423         {
424           char textbuf[20];
425           snprintf (textbuf, sizeof textbuf, "server[%u]", (unsigned int)n);
426           dump_cert (textbuf, cert);
427         }
428
429       ksba_cert_release (cert);
430     }
431 }
432
433
434 /****************
435  * Remove all %xx escapes; this is done inplace.
436  * Returns: New length of the string.
437  */
438 static int
439 remove_percent_escapes (unsigned char *string)
440 {
441   int n = 0;
442   unsigned char *p, *s;
443
444   for (p = s = string; *s; s++)
445     {
446       if (*s == '%')
447         {
448           if (s[1] && s[2] && hexdigitp (s+1) && hexdigitp (s+2))
449             {
450               s++;
451               *p = xtoi_2 (s);
452               s++;
453               p++;
454               n++;
455             }
456           else
457             {
458               *p++ = *s++;
459               if (*s)
460                 *p++ = *s++;
461               if (*s)
462                 *p++ = *s++;
463               if (*s)
464                 *p = 0;
465               return -1;   /* Bad URI. */
466             }
467         }
468       else
469         {
470           *p++ = *s;
471           n++;
472         }
473     }
474   *p = 0;  /* Always keep a string terminator. */
475   return n;
476 }
477
478
479 /* Return the host name and the port (0 if none was given) from the
480    URL.  Return NULL on error or if host is not included in the
481    URL.  */
482 char *
483 host_and_port_from_url (const char *url, int *port)
484 {
485   const char *s, *s2;
486   char *buf, *p;
487   int n;
488
489   s = url;
490
491   *port = 0;
492
493   /* Find the scheme */
494   if ( !(s2 = strchr (s, ':')) || s2 == s )
495     return NULL;  /* No scheme given. */
496   s = s2+1;
497
498   /* Find the hostname */
499   if (*s != '/')
500     return NULL; /* Does not start with a slash. */
501
502   s++;
503   if (*s != '/')
504     return NULL; /* No host name.  */
505   s++;
506
507   buf = xtrystrdup (s);
508   if (!buf)
509     {
510       log_error (_("malloc failed: %s\n"), strerror (errno));
511       return NULL;
512     }
513   if ((p = strchr (buf, '/')))
514     *p++ = 0;
515   strlwr (buf);
516   if ((p = strchr (p, ':')))
517     {
518       *p++ = 0;
519       *port = atoi (p);
520     }
521
522   /* Remove quotes and make sure that no Nul has been encoded. */
523   if ((n = remove_percent_escapes (buf)) < 0
524       || n != strlen (buf) )
525     {
526       log_error (_("bad URL encoding detected\n"));
527       xfree (buf);
528       return NULL;
529     }
530
531   return buf;
532 }
533
534
535 /* A KSBA reader callback to read from an estream.  */
536 static int
537 my_estream_ksba_reader_cb (void *cb_value, char *buffer, size_t count,
538                            size_t *r_nread)
539 {
540   estream_t fp = cb_value;
541
542   if (!fp)
543     return gpg_error (GPG_ERR_INV_VALUE);
544
545   if (!buffer && !count && !r_nread)
546     {
547       es_rewind (fp);
548       return 0;
549     }
550
551   *r_nread = es_fread (buffer, 1, count, fp);
552   if (!*r_nread)
553     return -1; /* EOF or error.  */
554   return 0; /* Success.  */
555 }
556
557
558 /* Create a KSBA reader object and connect it to the estream FP.  */
559 gpg_error_t
560 create_estream_ksba_reader (ksba_reader_t *r_reader, estream_t fp)
561 {
562   gpg_error_t err;
563   ksba_reader_t reader;
564
565   *r_reader = NULL;
566   err = ksba_reader_new (&reader);
567   if (!err)
568     err = ksba_reader_set_cb (reader, my_estream_ksba_reader_cb, fp);
569   if (err)
570     {
571       log_error (_("error initializing reader object: %s\n"),
572                  gpg_strerror (err));
573       ksba_reader_release (reader);
574       return err;
575     }
576   *r_reader = reader;
577   return 0;
578 }
579
580 gpg_error_t
581 armor_data (char **r_string, const void *data, size_t datalen)
582 {
583   gpg_error_t err;
584   struct b64state b64state;
585   estream_t fp;
586   long length;
587   char *buffer;
588   size_t nread;
589
590   *r_string = NULL;
591
592   fp = es_fopenmem (0, "rw,samethread");
593   if (!fp)
594     return gpg_error_from_syserror ();
595
596   if ((err=b64enc_start_es (&b64state, fp, "PGP PUBLIC KEY BLOCK"))
597       || (err=b64enc_write (&b64state, data, datalen))
598       || (err = b64enc_finish (&b64state)))
599     {
600       es_fclose (fp);
601       return err;
602     }
603
604   /* FIXME: To avoid the extra buffer allocation estream should
605      provide a function to snatch the internal allocated memory from
606      such a memory stream.  */
607   length = es_ftell (fp);
608   if (length < 0)
609     {
610       err = gpg_error_from_syserror ();
611       es_fclose (fp);
612       return err;
613     }
614
615   buffer = xtrymalloc (length+1);
616   if (!buffer)
617     {
618       err = gpg_error_from_syserror ();
619       es_fclose (fp);
620       return err;
621     }
622
623   es_rewind (fp);
624   if (es_read (fp, buffer, length, &nread))
625     {
626       err = gpg_error_from_syserror ();
627       es_fclose (fp);
628       return err;
629     }
630   buffer[nread] = 0;
631   es_fclose (fp);
632
633   *r_string = buffer;
634   return 0;
635 }
636
637 /* Copy all data from IN to OUT.  */
638 gpg_error_t
639 copy_stream (estream_t in, estream_t out)
640 {
641   char buffer[512];
642   size_t nread;
643
644   while (!es_read (in, buffer, sizeof buffer, &nread))
645     {
646       if (!nread)
647         return 0; /* EOF */
648       if (es_write (out, buffer, nread, NULL))
649         break;
650
651     }
652   return gpg_error_from_syserror ();
653 }