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, const 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(CUSS &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(const 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     const 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     const 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 */