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 *        Many functions are package-specific     *
  85 *************************************************/
  86
  87 #ifdef USE_GNUTLS
  88 #include "tls-gnu.c"
  89 #include "tlscert-gnu.c"
  90
  91 #define ssl_xfer_buffer (state_server.xfer_buffer)
  92 #define ssl_xfer_buffer_lwm (state_server.xfer_buffer_lwm)
  93 #define ssl_xfer_buffer_hwm (state_server.xfer_buffer_hwm)
  94 #define ssl_xfer_eof (state_server.xfer_eof)
  95 #define ssl_xfer_error (state_server.xfer_error)
  96
  97 #else
  98 #include "tls-openssl.c"
  99 #include "tlscert-openssl.c"
 100 #endif
 101
 102
 103
 104 /*************************************************
 105 *           TLS version of ungetc                *
 106 *************************************************/
 107
 108 /* Puts a character back in the input buffer. Only ever
 109 called once.
 110 Only used by the server-side TLS.
 111
 112 Arguments:
 113   ch           the character
 114
 115 Returns:       the character
 116 */
 117
 118 int
 119 tls_ungetc(int ch)
 120 {
 121 ssl_xfer_buffer[--ssl_xfer_buffer_lwm] = ch;
 122 return ch;
 123 }
 124
 125
 126
 127 /*************************************************
 128 *           TLS version of feof                  *
 129 *************************************************/
 130
 131 /* Tests for a previous EOF
 132 Only used by the server-side TLS.
 133
 134 Arguments:     none
 135 Returns:       non-zero if the eof flag is set
 136 */
 137
 138 int
 139 tls_feof(void)
 140 {
 141 return ssl_xfer_eof;
 142 }
 143
 144
 145
 146 /*************************************************
 147 *              TLS version of ferror             *
 148 *************************************************/
 149
 150 /* Tests for a previous read error, and returns with errno
 151 restored to what it was when the error was detected.
 152 Only used by the server-side TLS.
 153
 154 >>>>> Hmm. Errno not handled yet. Where do we get it from?  >>>>>
 155
 156 Arguments:     none
 157 Returns:       non-zero if the error flag is set
 158 */
 159
 160 int
 161 tls_ferror(void)
 162 {
 163 return ssl_xfer_error;
 164 }
 165
 166
 167 /*************************************************
 168 *           TLS version of smtp_buffered         *
 169 *************************************************/
 170
 171 /* Tests for unused chars in the TLS input buffer.
 172 Only used by the server-side TLS.
 173
 174 Arguments:     none
 175 Returns:       TRUE/FALSE
 176 */
 177
 178 BOOL
 179 tls_smtp_buffered(void)
 180 {
 181 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm;
 182 }
 183
 184
 185 #endif  /* SUPPORT_TLS */
 186
 187 void
 188 tls_modify_variables(tls_support * dest_tsp)
 189 {
 190 modify_variable(US"tls_bits",                 &dest_tsp->bits);
 191 modify_variable(US"tls_certificate_verified", &dest_tsp->certificate_verified);
 192 modify_variable(US"tls_cipher",               &dest_tsp->cipher);
 193 modify_variable(US"tls_peerdn",               &dest_tsp->peerdn);
 194 #if defined(SUPPORT_TLS) && !defined(USE_GNUTLS)
 195 modify_variable(US"tls_sni",                  &dest_tsp->sni);
 196 #endif
 197 }
 198
 199 /************************************************
 200 *       TLS certificate name operations         *
 201 ************************************************/
 202
 203 /* Convert an rfc4514 DN to an exim comma-sep list.
 204 Backslashed commas need to be replaced by doublecomma
 205 for Exim's list quoting.  We modify the given string
 206 inplace.
 207 */
 208
 209 static void
 210 dn_to_list(uschar * dn)
 211 {
 212 uschar * cp;
 213 for (cp = dn; *cp; cp++)
 214   if (cp[0] == '\\' && cp[1] == ',')
 215     *cp++ = ',';
 216 }
 217
 218
 219 /* Extract fields of a given type from an RFC4514-
 220 format Distinguished Name.  Return an Exim list.
 221 NOTE: We modify the supplied dn string during operation.
 222
 223 Arguments:
 224         dn      Distinguished Name string
 225         mod     string containing optional list-sep and
 226                 field selector match, comma-separated
 227 Return:
 228         allocated string with list of matching fields,
 229         field type stripped
 230 */
 231
 232 uschar *
 233 tls_field_from_dn(uschar * dn, uschar * mod)
 234 {
 235 int insep = ',';
 236 uschar outsep = '\n';
 237 uschar * ele;
 238 uschar * match = NULL;
 239 int len;
 240 uschar * list = NULL;
 241
 242 while (ele = string_nextinlist(&mod, &insep, NULL, 0))
 243   if (ele[0] != '>')
 244     match = ele;        /* field tag to match */
 245   else if (ele[1])
 246     outsep = ele[1];    /* nondefault separator */
 247
 248 dn_to_list(dn);
 249 insep = ',';
 250 len = Ustrlen(match);
 251 while (ele = string_nextinlist(&dn, &insep, NULL, 0))
 252   if (Ustrncmp(ele, match, len) == 0 && ele[len] == '=')
 253     list = string_append_listele(list, outsep, ele+len+1);
 254 return list;
 255 }
 256
 257
 258 #ifdef EXPERIMENTAL_CERTNAMES
 259 /* Compare a domain name with a possibly-wildcarded name. Wildcards
 260 are restricted to a single one, as the first element of patterns
 261 having at least three dot-separated elements.  Case-independent.
 262 Return TRUE for a match
 263 */
 264 static BOOL
 265 is_name_match(const uschar * name, const uschar * pat)
 266 {
 267 uschar * cp;
 268 return *pat == '*'              /* possible wildcard match */
 269   ?    *++pat == '.'            /* starts star, dot              */
 270     && !Ustrchr(++pat, '*')     /* has no more stars             */
 271     && Ustrchr(pat, '.')        /* and has another dot.          */
 272     && (cp = Ustrchr(name, '.'))/* The name has at least one dot */
 273     && strcmpic(++cp, pat) == 0 /* and we only compare after it. */
 274   :    !Ustrchr(pat+1, '*')
 275     && strcmpic(name, pat) == 0;
 276 }
 277
 278 /* Compare a list of names with the dnsname elements
 279 of the Subject Alternate Name, if any, and the
 280 Subject otherwise.
 281
 282 Arguments:
 283         namelist names to compare
 284         cert     certificate
 285
 286 Returns:
 287         TRUE/FALSE
 288 */
 289
 290 BOOL
 291 tls_is_name_for_cert(uschar * namelist, void * cert)
 292 {
 293 uschar * altnames = tls_cert_subject_altname(cert, US"dns");
 294 uschar * subjdn;
 295 uschar * certname;
 296 int cmp_sep = 0;
 297 uschar * cmpname;
 298
 299 if ((altnames = tls_cert_subject_altname(cert, US"dns")))
 300   {
 301   int alt_sep = '\n';
 302   while (cmpname = string_nextinlist(&namelist, &cmp_sep, NULL, 0))
 303     {
 304     uschar * an = altnames;
 305     while (certname = string_nextinlist(&an, &alt_sep, NULL, 0))
 306       if (is_name_match(cmpname, certname))
 307         return TRUE;
 308     }
 309   }
 310
 311 else if ((subjdn = tls_cert_subject(cert, NULL)))
 312   {
 313   int sn_sep = ',';
 314   uschar * sn;
 315
 316   dn_to_list(subjdn);
 317   while (cmpname = string_nextinlist(&namelist, &cmp_sep, NULL, 0))
 318     {
 319     uschar * sn = subjdn;
 320     while (certname = string_nextinlist(&sn, &sn_sep, NULL, 0))
 321       if (  *certname++ == 'C'
 322          && *certname++ == 'N'
 323          && *certname++ == '='
 324          && is_name_match(cmpname, certname)
 325          )
 326         return TRUE;
 327     }
 328   }
 329 return FALSE;
 330 }
 331 #endif
 332
 333 /* vi: aw ai sw=2
 334 */
 335 /* End of tls.c */