gpg: Move all DNS access to Dirmngr.
[gnupg.git] / dirmngr / dns-cert.c
1 /* dns-cert.c - DNS CERT code (rfc-4398)
2  * Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * This file is free software; you can redistribute it and/or modify
7  * it under the terms of either
8  *
9  *   - the GNU Lesser General Public License as published by the Free
10  *     Software Foundation; either version 3 of the License, or (at
11  *     your option) any later version.
12  *
13  * or
14  *
15  *   - the GNU General Public License as published by the Free
16  *     Software Foundation; either version 2 of the License, or (at
17  *     your option) any later version.
18  *
19  * or both in parallel, as here.
20  *
21  * This file is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24  * GNU General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, see <http://www.gnu.org/licenses/>.
28  */
29
30 #include <config.h>
31 #include <sys/types.h>
32 #ifdef USE_DNS_CERT
33 # ifdef HAVE_W32_SYSTEM
34 #  ifdef HAVE_WINSOCK2_H
35 #   include <winsock2.h>
36 #  endif
37 #  include <windows.h>
38 # else
39 #  include <netinet/in.h>
40 #  include <arpa/nameser.h>
41 #  include <resolv.h>
42 # endif
43 # include <string.h>
44 #endif
45 #ifdef USE_ADNS
46 # include <adns.h>
47 #endif
48
49 #include "util.h"
50 #include "host2net.h"
51 #include "dns-cert.h"
52
53 /* Not every installation has gotten around to supporting CERTs
54    yet... */
55 #ifndef T_CERT
56 #define T_CERT 37
57 #endif
58
59 /* ADNS has no support for CERT yet. */
60 #define my_adns_r_cert 37
61
62
63
64 /* Returns 0 on success or an error code.  If a PGP CERT record was
65    found, the malloced data is returned at (R_KEY, R_KEYLEN) and
66    the other return parameters are set to NULL/0.  If an IPGP CERT
67    record was found the fingerprint is stored as an allocated block at
68    R_FPR and its length at R_FPRLEN; an URL is is allocated as a
69    string and returned at R_URL.  If WANT_CERTTYPE is 0 this function
70    returns the first CERT found with a supported type; it is expected
71    that only one CERT record is used.  If WANT_CERTTYPE is one of the
72    supported certtypes only records wih this certtype are considered
73    and the first found is returned.  (R_KEY,R_KEYLEN) are optional. */
74 gpg_error_t
75 get_dns_cert (const char *name, int want_certtype,
76               void **r_key, size_t *r_keylen,
77               unsigned char **r_fpr, size_t *r_fprlen, char **r_url)
78 {
79 #ifdef USE_DNS_CERT
80 #ifdef USE_ADNS
81   gpg_error_t err;
82   adns_state state;
83   adns_answer *answer = NULL;
84   unsigned int ctype;
85   int count;
86
87   if (r_key)
88     *r_key = NULL;
89   if (r_keylen)
90     *r_keylen = 0;
91   *r_fpr = NULL;
92   *r_fprlen = 0;
93   *r_url = NULL;
94
95   if (adns_init (&state, adns_if_noerrprint, NULL))
96     {
97       err = gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
98       log_error ("error initializing adns: %s\n", strerror (errno));
99       return err;
100     }
101
102   if (adns_synchronous (state, name, (adns_r_unknown | my_adns_r_cert),
103                         adns_qf_quoteok_query, &answer))
104     {
105       err = gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
106       /* log_error ("DNS query failed: %s\n", strerror (errno)); */
107       adns_finish (state);
108       return err;
109     }
110   if (answer->status != adns_s_ok)
111     {
112       /* log_error ("DNS query returned an error: %s (%s)\n", */
113       /*            adns_strerror (answer->status), */
114       /*            adns_errabbrev (answer->status)); */
115       err = gpg_err_make (default_errsource, GPG_ERR_NOT_FOUND);
116       goto leave;
117     }
118
119   err = gpg_err_make (default_errsource, GPG_ERR_NOT_FOUND);
120   for (count = 0; count < answer->nrrs; count++)
121     {
122       int datalen = answer->rrs.byteblock[count].len;
123       const unsigned char *data = answer->rrs.byteblock[count].data;
124
125       if (datalen < 5)
126         continue;  /* Truncated CERT record - skip.  */
127
128       ctype = buf16_to_uint (data);
129       /* (key tag and algorithm fields are not required.) */
130       data += 5;
131       datalen -= 5;
132
133       if (want_certtype && want_certtype != ctype)
134         ; /* Not of the requested certtype.  */
135       else if (ctype == DNS_CERTTYPE_PGP && datalen >= 11 && r_key && r_keylen)
136         {
137           /* CERT type is PGP.  Gpg checks for a minimum length of 11,
138              thus we do the same.  */
139           *r_key = xtrymalloc (datalen);
140           if (!*r_key)
141             err = gpg_err_make (default_errsource,
142                                 gpg_err_code_from_syserror ());
143           else
144             {
145               memcpy (*r_key, data, datalen);
146               *r_keylen = datalen;
147               err = 0;
148             }
149           goto leave;
150         }
151       else if (ctype == DNS_CERTTYPE_IPGP && datalen && datalen < 1023
152                && datalen >= data[0] + 1 && r_fpr && r_fprlen && r_url)
153         {
154           /* CERT type is IPGP.  We made sure that the data is
155              plausible and that the caller requested this
156              information.  */
157           *r_fprlen = data[0];
158           if (*r_fprlen)
159             {
160               *r_fpr = xtrymalloc (*r_fprlen);
161               if (!*r_fpr)
162                 {
163                   err = gpg_err_make (default_errsource,
164                                       gpg_err_code_from_syserror ());
165                   goto leave;
166                 }
167               memcpy (*r_fpr, data + 1, *r_fprlen);
168             }
169           else
170             *r_fpr = NULL;
171
172           if (datalen > *r_fprlen + 1)
173             {
174               *r_url = xtrymalloc (datalen - (*r_fprlen + 1) + 1);
175               if (!*r_url)
176                 {
177                   err = gpg_err_make (default_errsource,
178                                       gpg_err_code_from_syserror ());
179                   xfree (*r_fpr);
180                   *r_fpr = NULL;
181                   goto leave;
182                 }
183               memcpy (*r_url,
184                       data + (*r_fprlen + 1), datalen - (*r_fprlen + 1));
185               (*r_url)[datalen - (*r_fprlen + 1)] = '\0';
186             }
187           else
188             *r_url = NULL;
189
190           err = 0;
191           goto leave;
192         }
193     }
194
195  leave:
196   adns_free (answer);
197   adns_finish (state);
198   return err;
199
200 #else /*!USE_ADNS*/
201
202   gpg_error_t err;
203   unsigned char *answer;
204   int r;
205   u16 count;
206
207   if (r_key)
208     *r_key = NULL;
209   if (r_keylen)
210     *r_keylen = 0;
211   *r_fpr = NULL;
212   *r_fprlen = 0;
213   *r_url = NULL;
214
215   /* Allocate a 64k buffer which is the limit for an DNS response.  */
216   answer = xtrymalloc (65536);
217   if (!answer)
218     return gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
219
220   err = gpg_err_make (default_errsource, GPG_ERR_NOT_FOUND);
221
222   r = res_query (name, C_IN, T_CERT, answer, 65536);
223   /* Not too big, not too small, no errors and at least 1 answer. */
224   if (r >= sizeof (HEADER) && r <= 65536
225       && (((HEADER *) answer)->rcode) == NOERROR
226       && (count = ntohs (((HEADER *) answer)->ancount)))
227     {
228       int rc;
229       unsigned char *pt, *emsg;
230
231       emsg = &answer[r];
232
233       pt = &answer[sizeof (HEADER)];
234
235       /* Skip over the query */
236
237       rc = dn_skipname (pt, emsg);
238       if (rc == -1)
239         {
240           err = gpg_err_make (default_errsource, GPG_ERR_INV_OBJ);
241           goto leave;
242         }
243       pt += rc + QFIXEDSZ;
244
245       /* There are several possible response types for a CERT request.
246          We're interested in the PGP (a key) and IPGP (a URI) types.
247          Skip all others.  TODO: A key is better than a URI since
248          we've gone through all this bother to fetch it, so favor that
249          if we have both PGP and IPGP? */
250
251       while (count-- > 0 && pt < emsg)
252         {
253           u16 type, class, dlen, ctype;
254
255           rc = dn_skipname (pt, emsg);  /* the name we just queried for */
256           if (rc == -1)
257             {
258               err = gpg_err_make (default_errsource, GPG_ERR_INV_OBJ);
259               goto leave;
260             }
261
262           pt += rc;
263
264           /* Truncated message? 15 bytes takes us to the point where
265              we start looking at the ctype. */
266           if ((emsg - pt) < 15)
267             break;
268
269           type = buf16_to_u16 (pt);
270           pt += 2;
271
272           class = buf16_to_u16 (pt);
273           pt += 2;
274
275           if (class != C_IN)
276             break;
277
278           /* ttl */
279           pt += 4;
280
281           /* data length */
282           dlen = buf16_to_u16 (pt);
283           pt += 2;
284
285           /* We asked for CERT and got something else - might be a
286              CNAME, so loop around again. */
287           if (type != T_CERT)
288             {
289               pt += dlen;
290               continue;
291             }
292
293           /* The CERT type */
294           ctype = buf16_to_u16 (pt);
295           pt += 2;
296
297           /* Skip the CERT key tag and algo which we don't need. */
298           pt += 3;
299
300           dlen -= 5;
301
302           /* 15 bytes takes us to here */
303           if (want_certtype && want_certtype != ctype)
304             ; /* Not of the requested certtype.  */
305           else if (ctype == DNS_CERTTYPE_PGP && dlen && r_key && r_keylen)
306             {
307               /* PGP type */
308               *r_key = xtrymalloc (dlen);
309               if (!*r_key)
310                 err = gpg_err_make (default_errsource,
311                                     gpg_err_code_from_syserror ());
312               else
313                 {
314                   memcpy (*r_key, pt, dlen);
315                   *r_keylen = dlen;
316                   err = 0;
317                 }
318               goto leave;
319             }
320           else if (ctype == DNS_CERTTYPE_IPGP
321                    && dlen && dlen < 1023 && dlen >= pt[0] + 1)
322             {
323               /* IPGP type */
324               *r_fprlen = pt[0];
325               if (*r_fprlen)
326                 {
327                   *r_fpr = xtrymalloc (*r_fprlen);
328                   if (!*r_fpr)
329                     {
330                       err = gpg_err_make (default_errsource,
331                                           gpg_err_code_from_syserror ());
332                       goto leave;
333                     }
334                   memcpy (*r_fpr, &pt[1], *r_fprlen);
335                 }
336               else
337                 *r_fpr = NULL;
338
339               if (dlen > *r_fprlen + 1)
340                 {
341                   *r_url = xtrymalloc (dlen - (*r_fprlen + 1) + 1);
342                   if (!*r_fpr)
343                     {
344                       err = gpg_err_make (default_errsource,
345                                           gpg_err_code_from_syserror ());
346                       xfree (*r_fpr);
347                       *r_fpr = NULL;
348                       goto leave;
349                     }
350                   memcpy (*r_url, &pt[*r_fprlen + 1], dlen - (*r_fprlen + 1));
351                   (*r_url)[dlen - (*r_fprlen + 1)] = '\0';
352                 }
353               else
354                 *r_url = NULL;
355
356               err = 0;
357               goto leave;
358             }
359
360           /* Neither type matches, so go around to the next answer. */
361           pt += dlen;
362         }
363     }
364
365  leave:
366   xfree (answer);
367   return err;
368
369 #endif /*!USE_ADNS */
370 #else /* !USE_DNS_CERT */
371   (void)name;
372   if (r_key)
373     *r_key = NULL;
374   if (r_keylen)
375     *r_keylen = NULL;
376   *r_fpr = NULL;
377   *r_fprlen = 0;
378   *r_url = NULL;
379
380   return gpg_err_make (default_errsource, GPG_ERR_NOT_SUPPORTED);
381 #endif
382 }