11823795ce9ccd13b3cdda9b644cf41706082805
[users/heiko/exim.git] / src / src / tls.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2012 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* This module provides TLS (aka SSL) support for Exim. The code for OpenSSL is
9 based on a patch that was originally contributed by Steve Haslam. It was
10 adapted from stunnel, a GPL program by Michal Trojnara. The code for GNU TLS is
11 based on a patch contributed by Nikos Mavroyanopoulos. Because these packages
12 are so very different, the functions for each are kept in separate files. The
13 relevant file is #included as required, after any any common functions.
14
15 No cryptographic code is included in Exim. All this module does is to call
16 functions from the OpenSSL or GNU TLS libraries. */
17
18
19 #include "exim.h"
20 #include "transports/smtp.h"
21
22 /* This module is compiled only when it is specifically requested in the
23 build-time configuration. However, some compilers don't like compiling empty
24 modules, so keep them happy with a dummy when skipping the rest. Make it
25 reference itself to stop picky compilers complaining that it is unused, and put
26 in a dummy argument to stop even pickier compilers complaining about infinite
27 loops. */
28
29 #ifndef SUPPORT_TLS
30 static void dummy(int x) { dummy(x-1); }
31 #else
32
33 /* Static variables that are used for buffering data by both sets of
34 functions and the common functions below.
35
36 We're moving away from this; GnuTLS is already using a state, which
37 can switch, so we can do TLS callouts during ACLs. */
38
39 static const int ssl_xfer_buffer_size = 4096;
40 #ifndef USE_GNUTLS
41 static uschar *ssl_xfer_buffer = NULL;
42 static int ssl_xfer_buffer_lwm = 0;
43 static int ssl_xfer_buffer_hwm = 0;
44 static int ssl_xfer_eof = 0;
45 static int ssl_xfer_error = 0;
46 #endif
47
48 uschar *tls_channelbinding_b64 = NULL;
49
50
51 /*************************************************
52 *       Expand string; give error on failure     *
53 *************************************************/
54
55 /* If expansion is forced to fail, set the result NULL and return TRUE.
56 Other failures return FALSE. For a server, an SMTP response is given.
57
58 Arguments:
59   s         the string to expand; if NULL just return TRUE
60   name      name of string being expanded (for error)
61   result    where to put the result
62
63 Returns:    TRUE if OK; result may still be NULL after forced failure
64 */
65
66 static BOOL
67 expand_check(const uschar *s, const uschar *name, uschar **result)
68 {
69 if (s == NULL) *result = NULL; else
70   {
71   *result = expand_string(US s); /* need to clean up const some more */
72   if (*result == NULL && !expand_string_forcedfail)
73     {
74     log_write(0, LOG_MAIN|LOG_PANIC, "expansion of %s failed: %s", name,
75       expand_string_message);
76     return FALSE;
77     }
78   }
79 return TRUE;
80 }
81
82
83 /*************************************************
84 *        Timezone environment flipping           *
85 *************************************************/
86
87 static uschar *
88 to_tz(uschar * tz)
89 {
90   uschar * old = US getenv("TZ");
91   setenv("TZ", CS tz, 1);
92   tzset(); 
93   return old;
94 }
95 static void
96 restore_tz(uschar * tz)
97 {
98   if (tz)
99     setenv("TZ", CS tz, 1);
100   else
101     unsetenv("TZ");
102   tzset(); 
103 }
104
105 /*************************************************
106 *        Many functions are package-specific     *
107 *************************************************/
108
109 #ifdef USE_GNUTLS
110 #include "tls-gnu.c"
111 #include "tlscert-gnu.c"
112
113 #define ssl_xfer_buffer (state_server.xfer_buffer)
114 #define ssl_xfer_buffer_lwm (state_server.xfer_buffer_lwm)
115 #define ssl_xfer_buffer_hwm (state_server.xfer_buffer_hwm)
116 #define ssl_xfer_eof (state_server.xfer_eof)
117 #define ssl_xfer_error (state_server.xfer_error)
118
119 #else
120 #include "tls-openssl.c"
121 #include "tlscert-openssl.c"
122 #endif
123
124
125
126 /*************************************************
127 *           TLS version of ungetc                *
128 *************************************************/
129
130 /* Puts a character back in the input buffer. Only ever
131 called once.
132 Only used by the server-side TLS.
133
134 Arguments:
135   ch           the character
136
137 Returns:       the character
138 */
139
140 int
141 tls_ungetc(int ch)
142 {
143 ssl_xfer_buffer[--ssl_xfer_buffer_lwm] = ch;
144 return ch;
145 }
146
147
148
149 /*************************************************
150 *           TLS version of feof                  *
151 *************************************************/
152
153 /* Tests for a previous EOF
154 Only used by the server-side TLS.
155
156 Arguments:     none
157 Returns:       non-zero if the eof flag is set
158 */
159
160 int
161 tls_feof(void)
162 {
163 return ssl_xfer_eof;
164 }
165
166
167
168 /*************************************************
169 *              TLS version of ferror             *
170 *************************************************/
171
172 /* Tests for a previous read error, and returns with errno
173 restored to what it was when the error was detected.
174 Only used by the server-side TLS.
175
176 >>>>> Hmm. Errno not handled yet. Where do we get it from?  >>>>>
177
178 Arguments:     none
179 Returns:       non-zero if the error flag is set
180 */
181
182 int
183 tls_ferror(void)
184 {
185 return ssl_xfer_error;
186 }
187
188
189 /*************************************************
190 *           TLS version of smtp_buffered         *
191 *************************************************/
192
193 /* Tests for unused chars in the TLS input buffer.
194 Only used by the server-side TLS.
195
196 Arguments:     none
197 Returns:       TRUE/FALSE
198 */
199
200 BOOL
201 tls_smtp_buffered(void)
202 {
203 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm;
204 }
205
206
207 #endif  /* SUPPORT_TLS */
208
209 void
210 tls_modify_variables(tls_support * dest_tsp)
211 {
212 modify_variable(US"tls_bits",                 &dest_tsp->bits);
213 modify_variable(US"tls_certificate_verified", &dest_tsp->certificate_verified);
214 modify_variable(US"tls_cipher",               &dest_tsp->cipher);
215 modify_variable(US"tls_peerdn",               &dest_tsp->peerdn);
216 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
217 modify_variable(US"tls_sni",                  &dest_tsp->sni);
218 #endif
219 }
220
221
222 #ifdef SUPPORT_TLS
223 /************************************************
224 *       TLS certificate name operations         *
225 ************************************************/
226
227 /* Convert an rfc4514 DN to an exim comma-sep list.
228 Backslashed commas need to be replaced by doublecomma
229 for Exim's list quoting.  We modify the given string
230 inplace.
231 */
232
233 static void
234 dn_to_list(uschar * dn)
235 {
236 uschar * cp;
237 for (cp = dn; *cp; cp++)
238   if (cp[0] == '\\' && cp[1] == ',')
239     *cp++ = ',';
240 }
241
242
243 /* Extract fields of a given type from an RFC4514-
244 format Distinguished Name.  Return an Exim list.
245 NOTE: We modify the supplied dn string during operation.
246
247 Arguments:
248         dn      Distinguished Name string
249         mod     list containing optional output list-sep and
250                 field selector match, comma-separated
251 Return:
252         allocated string with list of matching fields,
253         field type stripped
254 */
255
256 uschar *
257 tls_field_from_dn(uschar * dn, uschar * mod)
258 {
259 int insep = ',';
260 uschar outsep = '\n';
261 uschar * ele;
262 uschar * match = NULL;
263 int len;
264 uschar * list = NULL;
265
266 while ((ele = string_nextinlist(&mod, &insep, NULL, 0)))
267   if (ele[0] != '>')
268     match = ele;        /* field tag to match */
269   else if (ele[1])
270     outsep = ele[1];    /* nondefault output separator */
271
272 dn_to_list(dn);
273 insep = ',';
274 len = match ? Ustrlen(match) : -1;
275 while ((ele = string_nextinlist(&dn, &insep, NULL, 0)))
276   if (  !match
277      || Ustrncmp(ele, match, len) == 0 && ele[len] == '='
278      )
279     list = string_append_listele(list, outsep, ele+len+1);
280 return list;
281 }
282
283
284 /* Compare a domain name with a possibly-wildcarded name. Wildcards
285 are restricted to a single one, as the first element of patterns
286 having at least three dot-separated elements.  Case-independent.
287 Return TRUE for a match
288 */
289 static BOOL
290 is_name_match(const uschar * name, const uschar * pat)
291 {
292 uschar * cp;
293 return *pat == '*'              /* possible wildcard match */
294   ?    *++pat == '.'            /* starts star, dot              */
295     && !Ustrchr(++pat, '*')     /* has no more stars             */
296     && Ustrchr(pat, '.')        /* and has another dot.          */
297     && (cp = Ustrchr(name, '.'))/* The name has at least one dot */
298     && strcmpic(++cp, pat) == 0 /* and we only compare after it. */
299   :    !Ustrchr(pat+1, '*')
300     && strcmpic(name, pat) == 0;
301 }
302
303 /* Compare a list of names with the dnsname elements
304 of the Subject Alternate Name, if any, and the
305 Subject otherwise.
306
307 Arguments:
308         namelist names to compare
309         cert     certificate
310
311 Returns:
312         TRUE/FALSE
313 */
314
315 BOOL
316 tls_is_name_for_cert(uschar * namelist, void * cert)
317 {
318 uschar * altnames = tls_cert_subject_altname(cert, US"dns");
319 uschar * subjdn;
320 uschar * certname;
321 int cmp_sep = 0;
322 uschar * cmpname;
323
324 if ((altnames = tls_cert_subject_altname(cert, US"dns")))
325   {
326   int alt_sep = '\n';
327   while ((cmpname = string_nextinlist(&namelist, &cmp_sep, NULL, 0)))
328     {
329     uschar * an = altnames;
330     while ((certname = string_nextinlist(&an, &alt_sep, NULL, 0)))
331       if (is_name_match(cmpname, certname))
332         return TRUE;
333     }
334   }
335
336 else if ((subjdn = tls_cert_subject(cert, NULL)))
337   {
338   int sn_sep = ',';
339
340   dn_to_list(subjdn);
341   while ((cmpname = string_nextinlist(&namelist, &cmp_sep, NULL, 0)))
342     {
343     uschar * sn = subjdn;
344     while ((certname = string_nextinlist(&sn, &sn_sep, NULL, 0)))
345       if (  *certname++ == 'C'
346          && *certname++ == 'N'
347          && *certname++ == '='
348          && is_name_match(cmpname, certname)
349          )
350         return TRUE;
351     }
352   }
353 return FALSE;
354 }
355 #endif  /*SUPPORT_TLS*/
356
357 /* vi: aw ai sw=2
358 */
359 /* End of tls.c */