dirmngr: Pass Tor credentials to libdns.
[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
300   log_debug ("BEGIN Certificate '%s':\n", text? text:"");
301   if (cert)
302     {
303       sexp = ksba_cert_get_serial (cert);
304       p = serial_hex (sexp);
305       log_debug ("     serial: %s\n", p?p:"?");
306       xfree (p);
307       ksba_free (sexp);
308
309       ksba_cert_get_validity (cert, 0, t);
310       log_debug ("  notBefore: ");
311       dump_isotime (t);
312       log_printf ("\n");
313       ksba_cert_get_validity (cert, 1, t);
314       log_debug ("   notAfter: ");
315       dump_isotime (t);
316       log_printf ("\n");
317
318       p = ksba_cert_get_issuer (cert, 0);
319       log_debug ("     issuer: ");
320       dump_string (p);
321       ksba_free (p);
322       log_printf ("\n");
323
324       p = ksba_cert_get_subject (cert, 0);
325       log_debug ("    subject: ");
326       dump_string (p);
327       ksba_free (p);
328       log_printf ("\n");
329
330       log_debug ("  hash algo: %s\n", ksba_cert_get_digest_algo (cert));
331
332       p = get_fingerprint_hexstring (cert);
333       log_debug ("  SHA1 fingerprint: %s\n", p);
334       xfree (p);
335     }
336   log_debug ("END Certificate\n");
337 }
338
339
340
341 /* Log the certificate's name in "#SN/ISSUERDN" format along with
342    TEXT. */
343 void
344 cert_log_name (const char *text, ksba_cert_t cert)
345 {
346   log_info ("%s", text? text:"certificate" );
347   if (cert)
348     {
349       ksba_sexp_t sn;
350       char *p;
351
352       p = ksba_cert_get_issuer (cert, 0);
353       sn = ksba_cert_get_serial (cert);
354       if (p && sn)
355         {
356           log_printf (" #");
357           dump_serial (sn);
358           log_printf ("/");
359           dump_string (p);
360         }
361       else
362         log_printf (" [invalid]");
363       ksba_free (sn);
364       xfree (p);
365     }
366   log_printf ("\n");
367 }
368
369
370 /* Log the certificate's subject DN along with TEXT. */
371 void
372 cert_log_subject (const char *text, ksba_cert_t cert)
373 {
374   log_info ("%s", text? text:"subject" );
375   if (cert)
376     {
377       char *p;
378
379       p = ksba_cert_get_subject (cert, 0);
380       if (p)
381         {
382           log_printf (" /");
383           dump_string (p);
384           xfree (p);
385         }
386       else
387         log_printf (" [invalid]");
388     }
389   log_printf ("\n");
390 }
391
392
393 /* Callback to print infos about the TLS certificates.  */
394 void
395 cert_log_cb (http_session_t sess, gpg_error_t err,
396              const char *hostname, const void **certs, size_t *certlens)
397 {
398   ksba_cert_t cert;
399   size_t n;
400
401   (void)sess;
402
403   if (!err)
404     return; /* No error - no need to log anything  */
405
406   log_debug ("expected hostname: %s\n", hostname);
407   for (n=0; certs[n]; n++)
408     {
409       err = ksba_cert_new (&cert);
410       if (!err)
411         err = ksba_cert_init_from_mem (cert, certs[n], certlens[n]);
412       if (err)
413         log_error ("error parsing cert for logging: %s\n", gpg_strerror (err));
414       else
415         {
416           char textbuf[20];
417           snprintf (textbuf, sizeof textbuf, "server[%u]", (unsigned int)n);
418           dump_cert (textbuf, cert);
419         }
420
421       ksba_cert_release (cert);
422     }
423 }
424
425
426 /****************
427  * Remove all %xx escapes; this is done inplace.
428  * Returns: New length of the string.
429  */
430 static int
431 remove_percent_escapes (unsigned char *string)
432 {
433   int n = 0;
434   unsigned char *p, *s;
435
436   for (p = s = string; *s; s++)
437     {
438       if (*s == '%')
439         {
440           if (s[1] && s[2] && hexdigitp (s+1) && hexdigitp (s+2))
441             {
442               s++;
443               *p = xtoi_2 (s);
444               s++;
445               p++;
446               n++;
447             }
448           else
449             {
450               *p++ = *s++;
451               if (*s)
452                 *p++ = *s++;
453               if (*s)
454                 *p++ = *s++;
455               if (*s)
456                 *p = 0;
457               return -1;   /* Bad URI. */
458             }
459         }
460       else
461         {
462           *p++ = *s;
463           n++;
464         }
465     }
466   *p = 0;  /* Always keep a string terminator. */
467   return n;
468 }
469
470
471 /* Return the host name and the port (0 if none was given) from the
472    URL.  Return NULL on error or if host is not included in the
473    URL.  */
474 char *
475 host_and_port_from_url (const char *url, int *port)
476 {
477   const char *s, *s2;
478   char *buf, *p;
479   int n;
480
481   s = url;
482
483   *port = 0;
484
485   /* Find the scheme */
486   if ( !(s2 = strchr (s, ':')) || s2 == s )
487     return NULL;  /* No scheme given. */
488   s = s2+1;
489
490   /* Find the hostname */
491   if (*s != '/')
492     return NULL; /* Does not start with a slash. */
493
494   s++;
495   if (*s != '/')
496     return NULL; /* No host name.  */
497   s++;
498
499   buf = xtrystrdup (s);
500   if (!buf)
501     {
502       log_error (_("malloc failed: %s\n"), strerror (errno));
503       return NULL;
504     }
505   if ((p = strchr (buf, '/')))
506     *p++ = 0;
507   strlwr (buf);
508   if ((p = strchr (p, ':')))
509     {
510       *p++ = 0;
511       *port = atoi (p);
512     }
513
514   /* Remove quotes and make sure that no Nul has been encoded. */
515   if ((n = remove_percent_escapes (buf)) < 0
516       || n != strlen (buf) )
517     {
518       log_error (_("bad URL encoding detected\n"));
519       xfree (buf);
520       return NULL;
521     }
522
523   return buf;
524 }
525
526
527 /* A KSBA reader callback to read from an estream.  */
528 static int
529 my_estream_ksba_reader_cb (void *cb_value, char *buffer, size_t count,
530                            size_t *r_nread)
531 {
532   estream_t fp = cb_value;
533
534   if (!fp)
535     return gpg_error (GPG_ERR_INV_VALUE);
536
537   if (!buffer && !count && !r_nread)
538     {
539       es_rewind (fp);
540       return 0;
541     }
542
543   *r_nread = es_fread (buffer, 1, count, fp);
544   if (!*r_nread)
545     return -1; /* EOF or error.  */
546   return 0; /* Success.  */
547 }
548
549
550 /* Create a KSBA reader object and connect it to the estream FP.  */
551 gpg_error_t
552 create_estream_ksba_reader (ksba_reader_t *r_reader, estream_t fp)
553 {
554   gpg_error_t err;
555   ksba_reader_t reader;
556
557   *r_reader = NULL;
558   err = ksba_reader_new (&reader);
559   if (!err)
560     err = ksba_reader_set_cb (reader, my_estream_ksba_reader_cb, fp);
561   if (err)
562     {
563       log_error (_("error initializing reader object: %s\n"),
564                  gpg_strerror (err));
565       ksba_reader_release (reader);
566       return err;
567     }
568   *r_reader = reader;
569   return 0;
570 }
571
572 gpg_error_t
573 armor_data (char **r_string, const void *data, size_t datalen)
574 {
575   gpg_error_t err;
576   struct b64state b64state;
577   estream_t fp;
578   long length;
579   char *buffer;
580   size_t nread;
581
582   *r_string = NULL;
583
584   fp = es_fopenmem (0, "rw,samethread");
585   if (!fp)
586     return gpg_error_from_syserror ();
587
588   if ((err=b64enc_start_es (&b64state, fp, "PGP PUBLIC KEY BLOCK"))
589       || (err=b64enc_write (&b64state, data, datalen))
590       || (err = b64enc_finish (&b64state)))
591     {
592       es_fclose (fp);
593       return err;
594     }
595
596   /* FIXME: To avoid the extra buffer allocation estream should
597      provide a function to snatch the internal allocated memory from
598      such a memory stream.  */
599   length = es_ftell (fp);
600   if (length < 0)
601     {
602       err = gpg_error_from_syserror ();
603       es_fclose (fp);
604       return err;
605     }
606
607   buffer = xtrymalloc (length+1);
608   if (!buffer)
609     {
610       err = gpg_error_from_syserror ();
611       es_fclose (fp);
612       return err;
613     }
614
615   es_rewind (fp);
616   if (es_read (fp, buffer, length, &nread))
617     {
618       err = gpg_error_from_syserror ();
619       es_fclose (fp);
620       return err;
621     }
622   buffer[nread] = 0;
623   es_fclose (fp);
624
625   *r_string = buffer;
626   return 0;
627 }
628
629 /* Copy all data from IN to OUT.  */
630 gpg_error_t
631 copy_stream (estream_t in, estream_t out)
632 {
633   char buffer[512];
634   size_t nread;
635
636   while (!es_read (in, buffer, sizeof buffer, &nread))
637     {
638       if (!nread)
639         return 0; /* EOF */
640       if (es_write (out, buffer, nread, NULL))
641         break;
642
643     }
644   return gpg_error_from_syserror ();
645 }