dirmngr: Avoid PTR lookup for hosts in a pool
[gnupg.git] / dirmngr / crlfetch.c
1 /* crlfetch.c - LDAP access
2  *      Copyright (C) 2002 Klarälvdalens Datakonsult AB
3  *      Copyright (C) 2003, 2004, 2005, 2006, 2007 g10 Code GmbH
4  *
5  * This file is part of DirMngr.
6  *
7  * DirMngr is free software; you can redistribute it and/or modify
8  * it 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,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU 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, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <errno.h>
25 #include <npth.h>
26
27 #include "crlfetch.h"
28 #include "dirmngr.h"
29 #include "misc.h"
30 #include "http.h"
31
32 #if USE_LDAP
33 # include "ldap-wrapper.h"
34 #endif
35
36 /* For detecting armored CRLs received via HTTP (yes, such CRLS really
37    exits, e.g. http://grid.fzk.de/ca/gridka-crl.pem at least in June
38    2008) we need a context in the reader callback.  */
39 struct reader_cb_context_s
40 {
41   estream_t fp;             /* The stream used with the ksba reader.  */
42   int checked:1;            /* PEM/binary detection ahs been done.    */
43   int is_pem:1;             /* The file stream is PEM encoded.        */
44   struct b64state b64state; /* The state used for Base64 decoding.    */
45 };
46
47
48 /* We need to associate a reader object with the reader callback
49    context.  This table is used for it. */
50 struct file_reader_map_s
51 {
52   ksba_reader_t reader;
53   struct reader_cb_context_s *cb_ctx;
54 };
55 #define MAX_FILE_READER 50
56 static struct file_reader_map_s file_reader_map[MAX_FILE_READER];
57
58 /* Associate FP with READER.  If the table is full wait until another
59    thread has removed an entry.  */
60 static void
61 register_file_reader (ksba_reader_t reader, struct reader_cb_context_s *cb_ctx)
62 {
63   int i;
64
65   for (;;)
66     {
67       for (i=0; i < MAX_FILE_READER; i++)
68         if (!file_reader_map[i].reader)
69           {
70             file_reader_map[i].reader = reader;
71             file_reader_map[i].cb_ctx = cb_ctx;
72             return;
73           }
74       log_info (_("reader to file mapping table full - waiting\n"));
75       npth_sleep (2);
76     }
77 }
78
79 /* Scan the table for an entry matching READER, remove that entry and
80    return the associated file pointer. */
81 static struct reader_cb_context_s *
82 get_file_reader (ksba_reader_t reader)
83 {
84   struct reader_cb_context_s *cb_ctx = NULL;
85   int i;
86
87   for (i=0; i < MAX_FILE_READER; i++)
88     if (file_reader_map[i].reader == reader)
89       {
90         cb_ctx = file_reader_map[i].cb_ctx;
91         file_reader_map[i].reader = NULL;
92         file_reader_map[i].cb_ctx = NULL;
93         break;
94       }
95   return cb_ctx;
96 }
97
98
99
100 static int
101 my_es_read (void *opaque, char *buffer, size_t nbytes, size_t *nread)
102 {
103   struct reader_cb_context_s *cb_ctx = opaque;
104   int result;
105
106   result = es_read (cb_ctx->fp, buffer, nbytes, nread);
107   if (result)
108     return result;
109   /* Fixme we should check whether the semantics of es_read are okay
110      and well defined.  I have some doubts.  */
111   if (nbytes && !*nread && es_feof (cb_ctx->fp))
112     return gpg_error (GPG_ERR_EOF);
113   if (!nread && es_ferror (cb_ctx->fp))
114     return gpg_error (GPG_ERR_EIO);
115
116   if (!cb_ctx->checked && *nread)
117     {
118       int c = *(unsigned char *)buffer;
119
120       cb_ctx->checked = 1;
121       if ( ((c & 0xc0) >> 6) == 0 /* class: universal */
122            && (c & 0x1f) == 16    /* sequence */
123            && (c & 0x20)          /* is constructed */ )
124         ; /* Binary data.  */
125       else
126         {
127           cb_ctx->is_pem = 1;
128           b64dec_start (&cb_ctx->b64state, "");
129         }
130     }
131   if (cb_ctx->is_pem && *nread)
132     {
133       size_t nread2;
134
135       if (b64dec_proc (&cb_ctx->b64state, buffer, *nread, &nread2))
136         {
137           /* EOF from decoder. */
138           *nread = 0;
139           result = gpg_error (GPG_ERR_EOF);
140         }
141       else
142         *nread = nread2;
143     }
144
145   return result;
146 }
147
148
149 /* Fetch CRL from URL and return the entire CRL using new ksba reader
150    object in READER.  Note that this reader object should be closed
151    only using ldap_close_reader. */
152 gpg_error_t
153 crl_fetch (ctrl_t ctrl, const char *url, ksba_reader_t *reader)
154 {
155   gpg_error_t err;
156   parsed_uri_t uri;
157   char *free_this = NULL;
158   int redirects_left = 2; /* We allow for 2 redirect levels.  */
159
160   *reader = NULL;
161
162   if (!url)
163     return gpg_error (GPG_ERR_INV_ARG);
164
165  once_more:
166   err = http_parse_uri (&uri, url, 0);
167   http_release_parsed_uri (uri);
168   if (err && !strncmp (url, "https:", 6))
169     {
170       /* Our HTTP code does not support TLS, thus we can't use this
171          scheme and it is frankly not useful for CRL retrieval anyway.
172          We resort to using http, assuming that the server also
173          provides plain http access. */
174       free_this = xtrymalloc (strlen (url) + 1);
175       if (free_this)
176         {
177           strcpy (stpcpy (free_this,"http:"), url+6);
178           err = http_parse_uri (&uri, free_this, 0);
179           http_release_parsed_uri (uri);
180           if (!err)
181             {
182               log_info (_("using \"http\" instead of \"https\"\n"));
183               url = free_this;
184             }
185         }
186     }
187   if (!err) /* Yes, our HTTP code groks that. */
188     {
189       http_t hd;
190
191       if (opt.disable_http)
192         {
193           log_error (_("CRL access not possible due to disabled %s\n"),
194                      "HTTP");
195           err = gpg_error (GPG_ERR_NOT_SUPPORTED);
196         }
197       else
198         err = http_open_document (&hd, url, NULL,
199                                   ((opt.honor_http_proxy? HTTP_FLAG_TRY_PROXY:0)
200                                    |(DBG_LOOKUP? HTTP_FLAG_LOG_RESP:0)
201                                    |(dirmngr_use_tor()? HTTP_FLAG_FORCE_TOR:0)
202                                    |(opt.disable_ipv4? HTTP_FLAG_IGNORE_IPv4:0)
203                                    ),
204                                   ctrl->http_proxy, NULL, NULL, NULL);
205
206       switch ( err? 99999 : http_get_status_code (hd) )
207         {
208         case 200:
209           {
210             estream_t fp = http_get_read_ptr (hd);
211             struct reader_cb_context_s *cb_ctx;
212
213             cb_ctx = xtrycalloc (1, sizeof *cb_ctx);
214             if (!cb_ctx)
215               err = gpg_error_from_syserror ();
216             if (!err)
217               err = ksba_reader_new (reader);
218             if (!err)
219               {
220                 cb_ctx->fp = fp;
221                 err = ksba_reader_set_cb (*reader, &my_es_read, cb_ctx);
222               }
223             if (err)
224               {
225                 log_error (_("error initializing reader object: %s\n"),
226                            gpg_strerror (err));
227                 ksba_reader_release (*reader);
228                 *reader = NULL;
229                 http_close (hd, 0);
230               }
231             else
232               {
233                 /* The ksba reader misses a user pointer thus we need
234                    to come up with our own way of associating a file
235                    pointer (or well the callback context) with the
236                    reader.  It is only required when closing the
237                    reader thus there is no performance issue doing it
238                    this way.  FIXME: We now have a close notification
239                    which might be used here. */
240                 register_file_reader (*reader, cb_ctx);
241                 http_close (hd, 1);
242               }
243           }
244           break;
245
246         case 301: /* Redirection (perm.). */
247         case 302: /* Redirection (temp.). */
248           {
249             const char *s = http_get_header (hd, "Location");
250
251             log_info (_("URL '%s' redirected to '%s' (%u)\n"),
252                       url, s?s:"[none]", http_get_status_code (hd));
253             if (s && *s && redirects_left-- )
254               {
255                 xfree (free_this); url = NULL;
256                 free_this = xtrystrdup (s);
257                 if (!free_this)
258                   err = gpg_error_from_errno (errno);
259                 else
260                   {
261                     url = free_this;
262                     http_close (hd, 0);
263                     /* Note, that our implementation of redirection
264                        actually handles a redirect to LDAP.  */
265                     goto once_more;
266                   }
267               }
268             else
269               err = gpg_error (GPG_ERR_NO_DATA);
270             log_error (_("too many redirections\n")); /* Or no "Location". */
271             http_close (hd, 0);
272           }
273           break;
274
275         case 99999: /* Made up status code for error reporting.  */
276           log_error (_("error retrieving '%s': %s\n"),
277                      url, gpg_strerror (err));
278           break;
279
280         default:
281           log_error (_("error retrieving '%s': http status %u\n"),
282                      url, http_get_status_code (hd));
283           err = gpg_error (GPG_ERR_NO_DATA);
284           http_close (hd, 0);
285         }
286     }
287   else /* Let the LDAP code try other schemes. */
288     {
289       if (opt.disable_ldap)
290         {
291           log_error (_("CRL access not possible due to disabled %s\n"),
292                      "LDAP");
293           err = gpg_error (GPG_ERR_NOT_SUPPORTED);
294         }
295       else if (dirmngr_use_tor ())
296         {
297           /* For now we do not support LDAP over Tor.  */
298           log_error (_("CRL access not possible due to Tor mode\n"));
299           err = gpg_error (GPG_ERR_NOT_SUPPORTED);
300         }
301       else
302         {
303 #       if USE_LDAP
304           err = url_fetch_ldap (ctrl, url, NULL, 0, reader);
305 #       else /*!USE_LDAP*/
306           err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
307 #       endif /*!USE_LDAP*/
308         }
309     }
310
311   xfree (free_this);
312   return err;
313 }
314
315
316 /* Fetch CRL for ISSUER using a default server. Return the entire CRL
317    as a newly opened stream returned in R_FP. */
318 gpg_error_t
319 crl_fetch_default (ctrl_t ctrl, const char *issuer, ksba_reader_t *reader)
320 {
321   if (dirmngr_use_tor ())
322     {
323       /* For now we do not support LDAP over Tor.  */
324       log_error (_("CRL access not possible due to Tor mode\n"));
325       return gpg_error (GPG_ERR_NOT_SUPPORTED);
326     }
327   if (opt.disable_ldap)
328     {
329       log_error (_("CRL access not possible due to disabled %s\n"),
330                  "LDAP");
331       return gpg_error (GPG_ERR_NOT_SUPPORTED);
332     }
333
334 #if USE_LDAP
335   return attr_fetch_ldap (ctrl, issuer, "certificateRevocationList",
336                           reader);
337 #else
338   (void)ctrl;
339   (void)issuer;
340   (void)reader;
341   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
342 #endif
343 }
344
345
346 /* Fetch a CA certificate for DN using the default server. This
347    function only initiates the fetch; fetch_next_cert must be used to
348    actually read the certificate; end_cert_fetch to end the
349    operation. */
350 gpg_error_t
351 ca_cert_fetch (ctrl_t ctrl, cert_fetch_context_t *context, const char *dn)
352 {
353   if (dirmngr_use_tor ())
354     {
355       /* For now we do not support LDAP over Tor.  */
356       log_error (_("CRL access not possible due to Tor mode\n"));
357       return gpg_error (GPG_ERR_NOT_SUPPORTED);
358     }
359   if (opt.disable_ldap)
360     {
361       log_error (_("CRL access not possible due to disabled %s\n"),
362                  "LDAP");
363       return gpg_error (GPG_ERR_NOT_SUPPORTED);
364     }
365 #if USE_LDAP
366   return start_default_fetch_ldap (ctrl, context, dn, "cACertificate");
367 #else
368   (void)ctrl;
369   (void)context;
370   (void)dn;
371   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
372 #endif
373 }
374
375
376 gpg_error_t
377 start_cert_fetch (ctrl_t ctrl, cert_fetch_context_t *context,
378                   strlist_t patterns, const ldap_server_t server)
379 {
380   if (dirmngr_use_tor ())
381     {
382       /* For now we do not support LDAP over Tor.  */
383       log_error (_("CRL access not possible due to Tor mode\n"));
384       return gpg_error (GPG_ERR_NOT_SUPPORTED);
385     }
386   if (opt.disable_ldap)
387     {
388       log_error (_("certificate search not possible due to disabled %s\n"),
389                  "LDAP");
390       return gpg_error (GPG_ERR_NOT_SUPPORTED);
391     }
392 #if USE_LDAP
393   return start_cert_fetch_ldap (ctrl, context, patterns, server);
394 #else
395   (void)ctrl;
396   (void)context;
397   (void)patterns;
398   (void)server;
399   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
400 #endif
401 }
402
403
404 gpg_error_t
405 fetch_next_cert (cert_fetch_context_t context,
406                  unsigned char **value, size_t * valuelen)
407 {
408 #if USE_LDAP
409   return fetch_next_cert_ldap (context, value, valuelen);
410 #else
411   (void)context;
412   (void)value;
413   (void)valuelen;
414   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
415 #endif
416 }
417
418
419 /* Fetch the next data from CONTEXT, assuming it is a certificate and return
420    it as a cert object in R_CERT.  */
421 gpg_error_t
422 fetch_next_ksba_cert (cert_fetch_context_t context, ksba_cert_t *r_cert)
423 {
424   gpg_error_t err;
425   unsigned char *value;
426   size_t valuelen;
427   ksba_cert_t cert;
428
429   *r_cert = NULL;
430
431 #if USE_LDAP
432   err = fetch_next_cert_ldap (context, &value, &valuelen);
433   if (!err && !value)
434     err = gpg_error (GPG_ERR_BUG);
435 #else
436   (void)context;
437   err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
438 #endif
439   if (err)
440     return err;
441
442   err = ksba_cert_new (&cert);
443   if (err)
444     {
445       xfree (value);
446       return err;
447     }
448
449   err = ksba_cert_init_from_mem (cert, value, valuelen);
450   xfree (value);
451   if (err)
452     {
453       ksba_cert_release (cert);
454       return err;
455     }
456   *r_cert = cert;
457   return 0;
458 }
459
460
461 void
462 end_cert_fetch (cert_fetch_context_t context)
463 {
464 #if USE_LDAP
465   end_cert_fetch_ldap (context);
466 #else
467   (void)context;
468 #endif
469 }
470
471
472 /* Lookup a cert by it's URL.  */
473 gpg_error_t
474 fetch_cert_by_url (ctrl_t ctrl, const char *url,
475                    unsigned char **value, size_t *valuelen)
476 {
477   const unsigned char *cert_image;
478   size_t cert_image_n;
479   ksba_reader_t reader;
480   ksba_cert_t cert;
481   gpg_error_t err;
482
483   *value = NULL;
484   *valuelen = 0;
485   cert_image = NULL;
486   reader = NULL;
487   cert = NULL;
488
489 #if USE_LDAP
490   err = url_fetch_ldap (ctrl, url, NULL, 0, &reader);
491 #else
492   (void)ctrl;
493   (void)url;
494   err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
495 #endif /*USE_LDAP*/
496   if (err)
497     goto leave;
498
499   err = ksba_cert_new (&cert);
500   if (err)
501     goto leave;
502
503   err = ksba_cert_read_der (cert, reader);
504   if (err)
505     goto leave;
506
507   cert_image = ksba_cert_get_image (cert, &cert_image_n);
508   if (!cert_image || !cert_image_n)
509     {
510       err = gpg_error (GPG_ERR_INV_CERT_OBJ);
511       goto leave;
512     }
513
514   *value = xtrymalloc (cert_image_n);
515   if (!*value)
516     {
517       err = gpg_error_from_syserror ();
518       goto leave;
519     }
520
521   memcpy (*value, cert_image, cert_image_n);
522   *valuelen = cert_image_n;
523
524  leave:
525
526   ksba_cert_release (cert);
527 #if USE_LDAP
528   ldap_wrapper_release_context (reader);
529 #endif /*USE_LDAP*/
530
531   return err;
532 }
533
534 /* This function is to be used to close the reader object.  In
535    addition to running ksba_reader_release it also releases the LDAP
536    or HTTP contexts associated with that reader.  */
537 void
538 crl_close_reader (ksba_reader_t reader)
539 {
540   struct reader_cb_context_s *cb_ctx;
541
542   if (!reader)
543     return;
544
545   /* Check whether this is a HTTP one. */
546   cb_ctx = get_file_reader (reader);
547   if (cb_ctx)
548     {
549       /* This is an HTTP context. */
550       if (cb_ctx->fp)
551         es_fclose (cb_ctx->fp);
552       /* Release the base64 decoder state.  */
553       if (cb_ctx->is_pem)
554         b64dec_finish (&cb_ctx->b64state);
555       /* Release the callback context.  */
556       xfree (cb_ctx);
557     }
558   else /* This is an ldap wrapper context (Currently not used). */
559     {
560 #if USE_LDAP
561       ldap_wrapper_release_context (reader);
562 #endif /*USE_LDAP*/
563     }
564
565   /* Now get rid of the reader object. */
566   ksba_reader_release (reader);
567 }