Obsolete option --no-sig-create-check.
[gnupg.git] / util / pka.c
1 /* pka.c - DNS Public Key Association CERT record access
2  * Copyright (C) 1998-2015 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2015 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG 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 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG 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 <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27
28 #include "memory.h"
29 #include "types.h"
30 #include "cipher.h"
31 #include "util.h"
32
33 static int
34 string_has_ctrl_or_space (const char *string)
35 {
36   for (; *string; string++ )
37     if (!(*string & 0x80) && *string <= 0x20)
38       return 1;
39   return 0;
40 }
41
42
43 /* Return true if STRING has two consecutive '.' after an '@'
44    sign.  */
45 static int
46 has_dotdot_after_at (const char *string)
47 {
48   string = strchr (string, '@');
49   if (!string)
50     return 0; /* No at-sign.  */
51   string++;
52   return !!strstr (string, "..");
53 }
54
55
56 /* Return the mailbox (local-part@domain) form a standard user id.
57    Caller must free the result.  Returns NULL if no valid mailbox was
58    found (or we are out of memory). */
59 static char *
60 mailbox_from_userid (const char *userid)
61 {
62   const char *s, *s_end;
63   size_t len;
64   char *result = NULL;
65
66   s = strchr (userid, '<');
67   if (s)
68     {
69       /* Seems to be a standard user id.  */
70       s++;
71       s_end = strchr (s, '>');
72       if (s_end && s_end > s)
73         {
74           len = s_end - s;
75           result = xmalloc (len + 1);
76           strncpy (result, s, len);
77           result[len] = 0;
78           /* Apply some basic checks on the address.  We do not use
79              is_valid_mailbox because those checks are too strict.  */
80           if (string_count_chr (result, '@') != 1  /* Need exactly one '@.  */
81               || *result == '@'           /* local-part missing.  */
82               || result[len-1] == '@'     /* domain missing.  */
83               || result[len-1] == '.'     /* ends with a dot.  */
84               || string_has_ctrl_or_space (result)
85               || has_dotdot_after_at (result))
86             {
87               xfree (result);
88               result = NULL;
89               errno = EINVAL;
90             }
91         }
92       else
93         errno = EINVAL;
94     }
95   else if (is_valid_mailbox (userid))
96     {
97       /* The entire user id is a mailbox.  Return that one.  Note that
98          this fallback method has some restrictions on the valid
99          syntax of the mailbox.  However, those who want weird
100          addresses should know about it and use the regular <...>
101          syntax.  */
102       result = xtrystrdup (userid);
103     }
104   else
105     errno = EINVAL;
106
107   return result? ascii_strlwr (result) : NULL;
108 }
109
110
111 /* Zooko's base32 variant. See RFC-6189 and
112    http://philzimmermann.com/docs/human-oriented-base-32-encoding.txt
113    Caller must xfree the returned string.  Returns NULL and sets ERRNO
114    on error.  To avoid integer overflow DATALEN is limited to 2^16
115    bytes.  Note, that DATABITS is measured in bits!.  */
116 static char *
117 zb32_encode (const void *data, unsigned int databits)
118 {
119   static char const zb32asc[32] = {'y','b','n','d','r','f','g','8',
120                                    'e','j','k','m','c','p','q','x',
121                                    'o','t','1','u','w','i','s','z',
122                                    'a','3','4','5','h','7','6','9' };
123   const unsigned char *s;
124   char *output, *d;
125   size_t datalen;
126
127   datalen = (databits + 7) / 8;
128   if (datalen > (1 << 16))
129     {
130       errno = EINVAL;
131       return NULL;
132     }
133
134   d = output = xtrymalloc (8 * (datalen / 5)
135                            + 2 * (datalen % 5)
136                            - ((datalen%5)>2)
137                            + 1);
138   if (!output)
139     return NULL;
140
141   /* I use straightforward code.  The compiler should be able to do a
142      better job on optimization than me and it is easier to read.  */
143   for (s = data; datalen >= 5; s += 5, datalen -= 5)
144     {
145       *d++ = zb32asc[((s[0]      ) >> 3)               ];
146       *d++ = zb32asc[((s[0] &   7) << 2) | (s[1] >> 6) ];
147       *d++ = zb32asc[((s[1] &  63) >> 1)               ];
148       *d++ = zb32asc[((s[1] &   1) << 4) | (s[2] >> 4) ];
149       *d++ = zb32asc[((s[2] &  15) << 1) | (s[3] >> 7) ];
150       *d++ = zb32asc[((s[3] & 127) >> 2)               ];
151       *d++ = zb32asc[((s[3] &   3) << 3) | (s[4] >> 5) ];
152       *d++ = zb32asc[((s[4] &  31)     )               ];
153     }
154
155   switch (datalen)
156     {
157     case 4:
158       *d++ = zb32asc[((s[0]      ) >> 3)               ];
159       *d++ = zb32asc[((s[0] &   7) << 2) | (s[1] >> 6) ];
160       *d++ = zb32asc[((s[1] &  63) >> 1)               ];
161       *d++ = zb32asc[((s[1] &   1) << 4) | (s[2] >> 4) ];
162       *d++ = zb32asc[((s[2] &  15) << 1) | (s[3] >> 7) ];
163       *d++ = zb32asc[((s[3] & 127) >> 2)               ];
164       *d++ = zb32asc[((s[3] &   3) << 3)               ];
165       break;
166     case 3:
167       *d++ = zb32asc[((s[0]      ) >> 3)               ];
168       *d++ = zb32asc[((s[0] &   7) << 2) | (s[1] >> 6) ];
169       *d++ = zb32asc[((s[1] &  63) >> 1)               ];
170       *d++ = zb32asc[((s[1] &   1) << 4) | (s[2] >> 4) ];
171       *d++ = zb32asc[((s[2] &  15) << 1)               ];
172       break;
173     case 2:
174       *d++ = zb32asc[((s[0]      ) >> 3)               ];
175       *d++ = zb32asc[((s[0] &   7) << 2) | (s[1] >> 6) ];
176       *d++ = zb32asc[((s[1] &  63) >> 1)               ];
177       *d++ = zb32asc[((s[1] &   1) << 4)               ];
178       break;
179     case 1:
180       *d++ = zb32asc[((s[0]      ) >> 3)               ];
181       *d++ = zb32asc[((s[0] &   7) << 2)               ];
182       break;
183     default:
184       break;
185     }
186   *d = 0;
187
188   /* Need to strip some bytes if not a multiple of 40.  */
189   output[(databits + 5 - 1) / 5] = 0;
190   return output;
191 }
192
193
194
195 /* For the given email ADDRESS lookup the PKA information in the DNS.
196
197    On success the fingerprint is stored at FPRBUF and the URI will be
198    returned in an allocated buffer.  Note that the URI might be a zero
199    length string as this information is optional.  Caller must xfree
200    the returned string.  FPRBUFLEN gives the size of the expected
201    fingerprint (usually 20).
202
203    On error NULL is returned and the 20 bytes at FPR are not
204    defined. */
205 char *
206 get_pka_info (const char *address, void *fprbuf, size_t fprbuflen)
207 {
208   char *result = NULL;
209   char *mbox;
210   char *domain;  /* Points to mbox.  */
211   char hashbuf[20];
212   char *hash = NULL;
213   char *name = NULL;
214   unsigned char *fpr = NULL;
215   size_t fpr_len;
216   char *url = NULL;
217
218   mbox = mailbox_from_userid (address);
219   if (!mbox)
220     goto leave;
221   domain = strchr (mbox, '@');
222   if (!domain)
223     goto leave;
224   *domain++ = 0;
225
226   sha1_hash_buffer (hashbuf, mbox, strlen (mbox));
227   hash = zb32_encode (hashbuf, 8*20);
228   if (!hash)
229     goto leave;
230   name = strconcat (hash, "._pka.", domain, NULL);
231   if (!name)
232     goto leave;
233   if (get_cert (name, 1, 16384, NULL, &fpr, &fpr_len, &url))
234     goto leave;
235   if (!fpr)
236     goto leave;
237
238   /* Return the fingerprint.  */
239   if (fpr_len != fprbuflen)
240     {
241       /* fprintf (stderr, "get_dns_cert failed: fprlen (%zu/%zu)\n", */
242       /*          fpr_len, fprbuflen); */
243       goto leave;
244     }
245   memcpy (fprbuf, fpr, fpr_len);
246   /* We return the URL or an empty string.  */
247   if (!url)
248     url = xcalloc (1, 1);
249   result = url;
250   url = NULL;
251
252  leave:
253   xfree (fpr);
254   xfree (url);
255   xfree (name);
256   xfree (hash);
257   xfree (mbox);
258   return result;
259 }