scd: Allow generating ECC curves on PIV cards.
[gnupg.git] / common / mbox-util.c
1 /* mbox-util.c - Mail address helper functions
2  * Copyright (C) 1998-2010 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2015 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * This file is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * This file 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 Lesser General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 /* NB: GPGME uses the same code to reflect our idea on how to extract
22  * a mail address from a user id.
23  */
24
25 #include <config.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <unistd.h>
30 #include <errno.h>
31
32 #include "util.h"
33 #include "mbox-util.h"
34
35
36 static int
37 string_count_chr (const char *string, int c)
38 {
39   int count;
40
41   for (count=0; *string; string++ )
42     if ( *string == c )
43       count++;
44   return count;
45 }
46
47 static int
48 mem_count_chr (const void *buffer, int c, size_t length)
49 {
50   const char *s = buffer;
51   int count;
52
53   for (count=0; length; length--, s++)
54     if (*s == c)
55       count++;
56   return count;
57 }
58
59
60 /* This is a case-sensitive version of our memistr.  I wonder why no
61    standard function memstr exists but I better do not use the name
62    memstr to avoid future conflicts.  */
63 static const char *
64 my_memstr (const void *buffer, size_t buflen, const char *sub)
65 {
66   const unsigned char *buf = buffer;
67   const unsigned char *t = (const unsigned char *)buf;
68   const unsigned char *s = (const unsigned char *)sub;
69   size_t n = buflen;
70
71   for ( ; n ; t++, n-- )
72     {
73       if (*t == *s)
74         {
75           for (buf = t++, buflen = n--, s++; n && *t ==*s; t++, s++, n--)
76             ;
77           if (!*s)
78             return (const char*)buf;
79           t = (const unsigned char *)buf;
80           s = (const unsigned char *)sub ;
81           n = buflen;
82         }
83     }
84   return NULL;
85 }
86
87
88
89 static int
90 string_has_ctrl_or_space (const char *string)
91 {
92   for (; *string; string++ )
93     if (!(*string & 0x80) && *string <= 0x20)
94       return 1;
95   return 0;
96 }
97
98
99 /* Return true if STRING has two consecutive '.' after an '@'
100    sign.  */
101 static int
102 has_dotdot_after_at (const char *string)
103 {
104   string = strchr (string, '@');
105   if (!string)
106     return 0; /* No at-sign.  */
107   string++;
108   return !!strstr (string, "..");
109 }
110
111
112 /* Check whether BUFFER has characters not valid in an RFC-822
113    address.  LENGTH gives the length of BUFFER.
114
115    To cope with OpenPGP we ignore non-ascii characters so that for
116    example umlauts are legal in an email address.  An OpenPGP user ID
117    must be utf-8 encoded but there is no strict requirement for
118    RFC-822.  Thus to avoid IDNA encoding we put the address verbatim
119    as utf-8 into the user ID under the assumption that mail programs
120    handle IDNA at a lower level and take OpenPGP user IDs as utf-8.
121    Note that we can't do an utf-8 encoding checking here because in
122    keygen.c this function is called with the native encoding and
123    native to utf-8 encoding is only done later.  */
124 int
125 has_invalid_email_chars (const void *buffer, size_t length)
126 {
127   const unsigned char *s = buffer;
128   int at_seen=0;
129   const char *valid_chars=
130     "01234567890_-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
131
132   for ( ; length && *s; length--, s++ )
133     {
134       if ((*s & 0x80))
135         continue; /* We only care about ASCII.  */
136       if (*s == '@')
137         at_seen=1;
138       else if (!at_seen && !(strchr (valid_chars, *s)
139                              || strchr ("!#$%&'*+/=?^`{|}~", *s)))
140         return 1;
141       else if (at_seen && !strchr (valid_chars, *s))
142         return 1;
143     }
144   return 0;
145 }
146
147
148 /* Same as is_valid_mailbox (see below) but operates on non-nul
149    terminated buffer.  */
150 int
151 is_valid_mailbox_mem (const void *name_arg, size_t namelen)
152 {
153   const char *name = name_arg;
154
155   return !( !name
156             || !namelen
157             || has_invalid_email_chars (name, namelen)
158             || mem_count_chr (name, '@', namelen) != 1
159             || *name == '@'
160             || name[namelen-1] == '@'
161             || name[namelen-1] == '.'
162             || my_memstr (name, namelen, ".."));
163 }
164
165
166 /* Check whether NAME represents a valid mailbox according to
167    RFC822. Returns true if so. */
168 int
169 is_valid_mailbox (const char *name)
170 {
171   return name? is_valid_mailbox_mem (name, strlen (name)) : 0;
172 }
173
174
175 /* Return the mailbox (local-part@domain) form a standard user id.
176  * All plain ASCII characters in the result are converted to
177  * lowercase.  If SUBADDRESS is 1, '+' denoted sub-addresses are not
178  * included in the result.  Caller must free the result.  Returns NULL
179  * if no valid mailbox was found (or we are out of memory). */
180 char *
181 mailbox_from_userid (const char *userid, int subaddress)
182 {
183   const char *s, *s_end;
184   size_t len;
185   char *result = NULL;
186
187   s = strchr (userid, '<');
188   if (s)
189     {
190       /* Seems to be a standard user id.  */
191       s++;
192       s_end = strchr (s, '>');
193       if (s_end && s_end > s)
194         {
195           len = s_end - s;
196           result = xtrymalloc (len + 1);
197           if (!result)
198             return NULL; /* Ooops - out of core.  */
199           strncpy (result, s, len);
200           result[len] = 0;
201           /* Apply some basic checks on the address.  We do not use
202              is_valid_mailbox because those checks are too strict.  */
203           if (string_count_chr (result, '@') != 1  /* Need exactly one '@.  */
204               || *result == '@'           /* local-part missing.  */
205               || result[len-1] == '@'     /* domain missing.  */
206               || result[len-1] == '.'     /* ends with a dot.  */
207               || string_has_ctrl_or_space (result)
208               || has_dotdot_after_at (result))
209             {
210               xfree (result);
211               result = NULL;
212               errno = EINVAL;
213             }
214         }
215       else
216         errno = EINVAL;
217     }
218   else if (is_valid_mailbox (userid))
219     {
220       /* The entire user id is a mailbox.  Return that one.  Note that
221          this fallback method has some restrictions on the valid
222          syntax of the mailbox.  However, those who want weird
223          addresses should know about it and use the regular <...>
224          syntax.  */
225       result = xtrystrdup (userid);
226     }
227   else
228     errno = EINVAL;
229
230   if (result && subaddress == 1)
231     {
232       char *atsign, *plus;
233
234       if ((atsign = strchr (result, '@')))
235         {
236           /* We consider a subaddress only if there is a single '+'
237            * in the local part and the '+' is not the first or last
238            * character.  */
239           *atsign = 0;
240           if ((plus = strchr (result, '+'))
241               && !strchr (plus+1, '+')
242               && result != plus
243               && plus[1] )
244             {
245               *atsign = '@';
246               memmove (plus, atsign, strlen (atsign)+1);
247             }
248           else
249             *atsign = '@';
250         }
251     }
252
253   return result? ascii_strlwr (result): NULL;
254 }
255
256
257 /* Check whether UID is a valid standard user id of the form
258      "Heinrich Heine <heinrichh@duesseldorf.de>"
259    and return true if this is the case. */
260 int
261 is_valid_user_id (const char *uid)
262 {
263   if (!uid || !*uid)
264     return 0;
265
266   return 1;
267 }
268
269
270 /* Returns true if STRING is a valid domain name according to the LDH
271  * rule. */
272 int
273 is_valid_domain_name (const char *string)
274 {
275   static char const ldh_chars[] =
276     "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-";
277   const char *s;
278
279   /* Note that we do not check the length limit of a label or the
280    * entire name */
281
282   for (s=string; *s; s++)
283     if (*s == '.')
284       {
285         if (string == s)
286           return 0; /* Dot at the start of the string.  */
287                     /* (may also be at the end like in ".") */
288         if (s[1] == '.')
289           return 0; /* No - double dot.  */
290       }
291     else if (!strchr (ldh_chars, *s))
292       return 0;
293     else if (*s == '-')
294       {
295         if (string == s)
296           return 0;  /* Leading hyphen.  */
297         if (s[-1] == '.')
298           return 0;  /* Hyphen at begin of a label.  */
299         if (s[1] == '.')
300           return 0;  /* Hyphen at start of a label.  */
301         if (!s[1])
302           return 0;  /* Trailing hyphen.  */
303       }
304
305   return !!*string;
306 }