src/src/tlscert-gnu.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2021 - 2022 */
   6 /* Copyright (c) Jeremy Harris 2014 - 2018 */
   7
   8 /* This file provides TLS/SSL support for Exim using the GnuTLS library,
   9 one of the available supported implementations.  This file is #included into
  10 tls.c when USE_GNUTLS has been set.
  11 */
  12
  13 #include <gnutls/gnutls.h>
  14 /* needed for cert checks in verification and DN extraction: */
  15 #include <gnutls/x509.h>
  16 /* needed to disable PKCS11 autoload unless requested */
  17 #if GNUTLS_VERSION_NUMBER >= 0x020c00
  18 # include <gnutls/pkcs11.h>
  19 #endif
  20
  21
  22 /*****************************************************
  23 *  Export/import a certificate, binary/printable
  24 ******************************************************
  25 Return: boolean success
  26 */
  27
  28 BOOL
  29 tls_export_cert(uschar * buf, size_t buflen, void * cert)
  30 {
  31 size_t sz = buflen;
  32 rmark reset_point = store_mark();
  33 BOOL fail;
  34 const uschar * cp;
  35
  36 if ((fail = gnutls_x509_crt_export((gnutls_x509_crt_t)cert,
  37     GNUTLS_X509_FMT_PEM, buf, &sz)))
  38   {
  39   log_write(0, LOG_MAIN, "TLS error in certificate export: %s",
  40     gnutls_strerror(fail));
  41   return FALSE;
  42   }
  43 if ((cp = string_printing(buf)) != buf)
  44   {
  45   Ustrncpy(buf, cp, buflen);
  46   if (buf[buflen-1])
  47     fail = 1;
  48   }
  49 store_reset(reset_point);
  50 return !fail;
  51 }
  52
  53 /* On error, NULL out the destination */
  54 BOOL
  55 tls_import_cert(const uschar * buf, void ** cert)
  56 {
  57 rmark reset_point = store_mark();
  58 gnutls_datum_t datum;
  59 gnutls_x509_crt_t crt = *(gnutls_x509_crt_t *)cert;
  60 int rc;
  61
  62 if (crt)
  63   gnutls_x509_crt_deinit(crt);
  64 else
  65   gnutls_global_init();
  66
  67 gnutls_x509_crt_init(&crt);
  68
  69 datum.data = string_unprinting(US buf);
  70 datum.size = Ustrlen(datum.data);
  71 if ((rc = gnutls_x509_crt_import(crt, &datum, GNUTLS_X509_FMT_PEM)))
  72   {
  73   log_write(0, LOG_MAIN, "TLS error in certificate import: %s",
  74     gnutls_strerror(rc));
  75   crt = NULL;
  76   }
  77 *cert = (void *)crt;
  78 store_reset(reset_point);
  79 return rc != 0;
  80 }
  81
  82 void
  83 tls_free_cert(void ** cert)
  84 {
  85 gnutls_x509_crt_t crt = *(gnutls_x509_crt_t *)cert;
  86 if (crt)
  87   {
  88   gnutls_x509_crt_deinit(crt);
  89   gnutls_global_deinit();
  90   *cert = NULL;
  91   }
  92 }
  93
  94 /*****************************************************
  95 *  Certificate field extraction routines
  96 *****************************************************/
  97
  98 /* First, some internal service functions */
  99
 100 static uschar *
 101 g_err(const char * tag, const char * from, int gnutls_err)
 102 {
 103 expand_string_message = string_sprintf("%s: %s fail: %s\n",
 104   from, tag, gnutls_strerror(gnutls_err));
 105 return NULL;
 106 }
 107
 108
 109 static uschar *
 110 time_copy(time_t t, uschar * mod)
 111 {
 112 uschar * cp;
 113 size_t len = 32;
 114
 115 if (mod && Ustrcmp(mod, "int") == 0)
 116   return string_sprintf("%u", (unsigned)t);
 117
 118 cp = store_get(len, GET_UNTAINTED);
 119 if (f.timestamps_utc)
 120   {
 121   uschar * tz = to_tz(US"GMT0");
 122   len = strftime(CS cp, len, "%b %e %T %Y %Z", gmtime(&t));
 123   restore_tz(tz);
 124   }
 125 else
 126   len = strftime(CS cp, len, "%b %e %T %Y %Z", localtime(&t));
 127 return len > 0 ? cp : NULL;
 128 }
 129
 130
 131 /**/
 132 /* Now the extractors, called from expand.c
 133 Arguments:
 134   cert          The certificate
 135   mod           Optional modifiers for the operator
 136
 137 Return:
 138   Allocated string with extracted value
 139 */
 140
 141 uschar *
 142 tls_cert_issuer(void * cert, uschar * mod)
 143 {
 144 uschar * cp = NULL;
 145 int ret;
 146 size_t siz = 0;
 147
 148 if ((ret = gnutls_x509_crt_get_issuer_dn(cert, CS cp, &siz))
 149     != GNUTLS_E_SHORT_MEMORY_BUFFER)
 150   return g_err("gi0", __FUNCTION__, ret);
 151
 152 cp = store_get(siz, GET_TAINTED);
 153 if ((ret = gnutls_x509_crt_get_issuer_dn(cert, CS cp, &siz)) < 0)
 154   return g_err("gi1", __FUNCTION__, ret);
 155
 156 return mod ? tls_field_from_dn(cp, mod) : cp;
 157 }
 158
 159 uschar *
 160 tls_cert_not_after(void * cert, uschar * mod)
 161 {
 162 return time_copy(
 163   gnutls_x509_crt_get_expiration_time((gnutls_x509_crt_t)cert),
 164   mod);
 165 }
 166
 167 uschar *
 168 tls_cert_not_before(void * cert, uschar * mod)
 169 {
 170 return time_copy(
 171   gnutls_x509_crt_get_activation_time((gnutls_x509_crt_t)cert),
 172   mod);
 173 }
 174
 175 uschar *
 176 tls_cert_serial_number(void * cert, uschar * mod)
 177 {
 178 uschar bin[50], txt[150];
 179 uschar * sp = bin;
 180 size_t sz = sizeof(bin);
 181 int ret;
 182
 183 if ((ret = gnutls_x509_crt_get_serial((gnutls_x509_crt_t)cert,
 184     bin, &sz)))
 185   return g_err("gs0", __FUNCTION__, ret);
 186
 187 for(uschar * dp = txt; sz; sz--)
 188   dp += sprintf(CS dp, "%.2x", *sp++);
 189 for(sp = txt; sp[0]=='0' && sp[1]; ) sp++;      /* leading zeroes */
 190 return string_copy(sp);
 191 }
 192
 193 uschar *
 194 tls_cert_signature(void * cert, uschar * mod)
 195 {
 196 uschar * cp1 = NULL;
 197 uschar * cp2;
 198 uschar * cp3;
 199 size_t len = 0;
 200 int ret;
 201
 202 if ((ret = gnutls_x509_crt_get_signature((gnutls_x509_crt_t)cert, CS cp1, &len))
 203     != GNUTLS_E_SHORT_MEMORY_BUFFER)
 204   return g_err("gs0", __FUNCTION__, ret);
 205
 206 cp1 = store_get(len*4+1, GET_TAINTED);
 207 if (gnutls_x509_crt_get_signature((gnutls_x509_crt_t)cert, CS cp1, &len) != 0)
 208   return g_err("gs1", __FUNCTION__, ret);
 209
 210 for(cp3 = cp2 = cp1+len; cp1 < cp2; cp1++)
 211   cp3 += sprintf(CS cp3, "%.2x ", *cp1);
 212 cp3[-1]= '\0';
 213
 214 return cp2;
 215 }
 216
 217 uschar *
 218 tls_cert_signature_algorithm(void * cert, uschar * mod)
 219 {
 220 gnutls_sign_algorithm_t algo =
 221   gnutls_x509_crt_get_signature_algorithm((gnutls_x509_crt_t)cert);
 222 return algo < 0 ? NULL : string_copy(US gnutls_sign_get_name(algo));
 223 }
 224
 225 uschar *
 226 tls_cert_subject(void * cert, uschar * mod)
 227 {
 228 uschar * cp = NULL;
 229 int ret;
 230 size_t siz = 0;
 231
 232 if ((ret = gnutls_x509_crt_get_dn(cert, CS cp, &siz))
 233     != GNUTLS_E_SHORT_MEMORY_BUFFER)
 234   return g_err("gs0", __FUNCTION__, ret);
 235
 236 cp = store_get(siz, GET_TAINTED);
 237 if ((ret = gnutls_x509_crt_get_dn(cert, CS cp, &siz)) < 0)
 238   return g_err("gs1", __FUNCTION__, ret);
 239
 240 return mod ? tls_field_from_dn(cp, mod) : cp;
 241 }
 242
 243 uschar *
 244 tls_cert_version(void * cert, uschar * mod)
 245 {
 246 return string_sprintf("%d", gnutls_x509_crt_get_version(cert));
 247 }
 248
 249 uschar *
 250 tls_cert_ext_by_oid(void * cert, uschar * oid, int idx)
 251 {
 252 uschar * cp1 = NULL;
 253 uschar * cp2;
 254 uschar * cp3;
 255 size_t siz = 0;
 256 unsigned int crit;
 257 int ret;
 258
 259 ret = gnutls_x509_crt_get_extension_by_oid ((gnutls_x509_crt_t)cert,
 260   CS oid, idx, CS cp1, &siz, &crit);
 261 if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
 262   return g_err("ge0", __FUNCTION__, ret);
 263
 264 cp1 = store_get(siz*4 + 1, GET_TAINTED);
 265
 266 ret = gnutls_x509_crt_get_extension_by_oid ((gnutls_x509_crt_t)cert,
 267   CS oid, idx, CS cp1, &siz, &crit);
 268 if (ret < 0)
 269   return g_err("ge1", __FUNCTION__, ret);
 270
 271 /* binary data, DER encoded */
 272
 273 /* just dump for now */
 274 for(cp3 = cp2 = cp1+siz; cp1 < cp2; cp1++)
 275   cp3 += sprintf(CS cp3, "%.2x ", *cp1);
 276 cp3[-1]= '\0';
 277
 278 return cp2;
 279 }
 280
 281 uschar *
 282 tls_cert_subject_altname(void * cert, uschar * mod)
 283 {
 284 gstring * list = NULL;
 285 size_t siz;
 286 int ret;
 287 uschar sep = '\n';
 288 uschar * tag = US"";
 289 uschar * ele;
 290 int match = -1;
 291
 292 if (mod) while (*mod)
 293   {
 294   if (*mod == '>' && *++mod) sep = *mod++;
 295   else if (Ustrncmp(mod, "dns", 3)==0) { match = GNUTLS_SAN_DNSNAME; mod += 3; }
 296   else if (Ustrncmp(mod, "uri", 3)==0) { match = GNUTLS_SAN_URI; mod += 3; }
 297   else if (Ustrncmp(mod, "mail", 4)==0) { match = GNUTLS_SAN_RFC822NAME; mod += 4; }
 298   else break;
 299
 300   if (*mod++ != ',')
 301     break;
 302   }
 303
 304 for (int index = 0;; index++)
 305   {
 306   siz = 0;
 307   switch(ret = gnutls_x509_crt_get_subject_alt_name(
 308       (gnutls_x509_crt_t)cert, index, NULL, &siz, NULL))
 309     {
 310     case GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE:
 311       return string_from_gstring(list); /* no more elements; normal exit */
 312
 313     case GNUTLS_E_SHORT_MEMORY_BUFFER:
 314       break;
 315
 316     default:
 317       return g_err("gs0", __FUNCTION__, ret);
 318     }
 319
 320   ele = store_get(siz+1, GET_TAINTED);
 321   if ((ret = gnutls_x509_crt_get_subject_alt_name(
 322     (gnutls_x509_crt_t)cert, index, ele, &siz, NULL)) < 0)
 323     return g_err("gs1", __FUNCTION__, ret);
 324   ele[siz] = '\0';
 325
 326   if (  match != -1 && match != ret     /* wrong type of SAN */
 327      || Ustrlen(ele) != siz)            /* contains a NUL */
 328     continue;
 329   switch (ret)
 330     {
 331     case GNUTLS_SAN_DNSNAME:    tag = US"DNS";  break;
 332     case GNUTLS_SAN_URI:        tag = US"URI";  break;
 333     case GNUTLS_SAN_RFC822NAME: tag = US"MAIL"; break;
 334     default: continue;        /* ignore unrecognised types */
 335     }
 336   list = string_append_listele(list, sep,
 337           match == -1 ? string_sprintf("%s=%s", tag, ele) : ele);
 338   }
 339 /*NOTREACHED*/
 340 }
 341
 342 uschar *
 343 tls_cert_ocsp_uri(void * cert, uschar * mod)
 344 {
 345 #if GNUTLS_VERSION_NUMBER >= 0x030000
 346 gnutls_datum_t uri;
 347 int ret;
 348 uschar sep = '\n';
 349 gstring * list = NULL;
 350
 351 if (mod)
 352   if (*mod == '>' && *++mod) sep = *mod++;
 353
 354 for (int index = 0;; index++)
 355   {
 356   ret = gnutls_x509_crt_get_authority_info_access((gnutls_x509_crt_t)cert,
 357           index, GNUTLS_IA_OCSP_URI, &uri, NULL);
 358
 359   if (ret == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
 360     return string_from_gstring(list);
 361   if (ret < 0)
 362     return g_err("gai", __FUNCTION__, ret);
 363
 364   list = string_append_listele_n(list, sep, uri.data, uri.size);
 365   }
 366 /*NOTREACHED*/
 367
 368 #else
 369
 370 expand_string_message =
 371   string_sprintf("%s: OCSP support with GnuTLS requires version 3.0.0\n",
 372     __FUNCTION__);
 373 return NULL;
 374
 375 #endif
 376 }
 377
 378 uschar *
 379 tls_cert_crl_uri(void * cert, uschar * mod)
 380 {
 381 int ret;
 382 uschar sep = '\n';
 383 gstring * list = NULL;
 384 uschar * ele;
 385
 386 if (mod)
 387   if (*mod == '>' && *++mod) sep = *mod++;
 388
 389 for (int index = 0;; index++)
 390   {
 391   size_t siz = 0;
 392   switch(ret = gnutls_x509_crt_get_crl_dist_points(
 393     (gnutls_x509_crt_t)cert, index, NULL, &siz, NULL, NULL))
 394     {
 395     case GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE:
 396       return string_from_gstring(list);
 397     case GNUTLS_E_SHORT_MEMORY_BUFFER:
 398       break;
 399     default:
 400       return g_err("gc0", __FUNCTION__, ret);
 401     }
 402
 403   ele = store_get(siz, GET_TAINTED);
 404   if ((ret = gnutls_x509_crt_get_crl_dist_points(
 405       (gnutls_x509_crt_t)cert, index, ele, &siz, NULL, NULL)) < 0)
 406     return g_err("gc1", __FUNCTION__, ret);
 407
 408   list = string_append_listele_n(list, sep, ele, siz);
 409   }
 410 /*NOTREACHED*/
 411 }
 412
 413
 414 /*****************************************************
 415 *  Certificate operator routines
 416 *****************************************************/
 417 uschar *
 418 tls_cert_der_b64(void * cert)
 419 {
 420 size_t len = 0;
 421 uschar * cp = NULL;
 422 int fail;
 423
 424 if (  (fail = gnutls_x509_crt_export((gnutls_x509_crt_t)cert,
 425         GNUTLS_X509_FMT_DER, cp, &len)) != GNUTLS_E_SHORT_MEMORY_BUFFER
 426    || !(cp = store_get((int)len, GET_TAINTED), TRUE)    /* tainted */
 427    || (fail = gnutls_x509_crt_export((gnutls_x509_crt_t)cert,
 428         GNUTLS_X509_FMT_DER, cp, &len))
 429    )
 430   {
 431   log_write(0, LOG_MAIN, "TLS error in certificate export: %s",
 432     gnutls_strerror(fail));
 433   return NULL;
 434   }
 435 return b64encode(CUS cp, (int)len);
 436 }
 437
 438
 439 static uschar *
 440 fingerprint(gnutls_x509_crt_t cert, gnutls_digest_algorithm_t algo)
 441 {
 442 int ret;
 443 size_t siz = 0;
 444 uschar * cp;
 445 uschar * cp2;
 446
 447 if ((ret = gnutls_x509_crt_get_fingerprint(cert, algo, NULL, &siz))
 448     != GNUTLS_E_SHORT_MEMORY_BUFFER)
 449   return g_err("gf0", __FUNCTION__, ret);
 450
 451 cp = store_get(siz*3+1, GET_TAINTED);
 452 if ((ret = gnutls_x509_crt_get_fingerprint(cert, algo, cp, &siz)) < 0)
 453   return g_err("gf1", __FUNCTION__, ret);
 454
 455 for (uschar * cp3 = cp2 = cp+siz; cp < cp2; cp++)
 456   cp3 += sprintf(CS cp3, "%02X", *cp);
 457 return cp2;
 458 }
 459
 460
 461 uschar *
 462 tls_cert_fprt_md5(void * cert)
 463 {
 464 return fingerprint((gnutls_x509_crt_t)cert, GNUTLS_DIG_MD5);
 465 }
 466
 467 uschar *
 468 tls_cert_fprt_sha1(void * cert)
 469 {
 470 return fingerprint((gnutls_x509_crt_t)cert, GNUTLS_DIG_SHA1);
 471 }
 472
 473 uschar *
 474 tls_cert_fprt_sha256(void * cert)
 475 {
 476 return fingerprint((gnutls_x509_crt_t)cert, GNUTLS_DIG_SHA256);
 477 }
 478
 479
 480 /* vi: aw ai sw=2
 481 */
 482 /* End of tlscert-gnu.c */