OpenVPN
ssl_verify_openssl.c
Go to the documentation of this file.
1 /*
2  * OpenVPN -- An application to securely tunnel IP networks
3  * over a single TCP/UDP port, with support for SSL/TLS-based
4  * session authentication and key exchange,
5  * packet encryption, packet authentication, and
6  * packet compression.
7  *
8  * Copyright (C) 2002-2018 OpenVPN Inc <sales@openvpn.net>
9  * Copyright (C) 2010-2018 Fox Crypto B.V. <openvpn@fox-it.com>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2
13  * as published by the Free Software Foundation.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License along
21  * with this program; if not, write to the Free Software Foundation, Inc.,
22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23  */
24 
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #elif defined(_MSC_VER)
32 #include "config-msvc.h"
33 #endif
34 
35 #include "syshead.h"
36 
37 #if defined(ENABLE_CRYPTO_OPENSSL)
38 
39 #include "ssl_verify_openssl.h"
40 
41 #include "error.h"
42 #include "ssl_openssl.h"
43 #include "ssl_verify.h"
44 #include "ssl_verify_backend.h"
45 #include "openssl_compat.h"
46 
47 #include <openssl/bn.h>
48 #include <openssl/err.h>
49 #include <openssl/x509v3.h>
50 
51 int
52 verify_callback(int preverify_ok, X509_STORE_CTX *ctx)
53 {
54  int ret = 0;
55  struct tls_session *session;
56  SSL *ssl;
57  struct gc_arena gc = gc_new();
58 
59  /* get the tls_session pointer */
60  ssl = X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
61  ASSERT(ssl);
62  session = (struct tls_session *) SSL_get_ex_data(ssl, mydata_index);
63  ASSERT(session);
64 
65  X509 *current_cert = X509_STORE_CTX_get_current_cert(ctx);
66  struct buffer cert_hash = x509_get_sha256_fingerprint(current_cert, &gc);
67  cert_hash_remember(session, X509_STORE_CTX_get_error_depth(ctx), &cert_hash);
68 
69  /* did peer present cert which was signed by our root cert? */
70  if (!preverify_ok)
71  {
72  /* get the X509 name */
73  char *subject = x509_get_subject(current_cert, &gc);
74 
75  if (!subject)
76  {
77  subject = "(Failed to retrieve certificate subject)";
78  }
79 
80  /* Log and ignore missing CRL errors */
81  if (X509_STORE_CTX_get_error(ctx) == X509_V_ERR_UNABLE_TO_GET_CRL)
82  {
83  msg(D_TLS_DEBUG_LOW, "VERIFY WARNING: depth=%d, %s: %s",
84  X509_STORE_CTX_get_error_depth(ctx),
85  X509_verify_cert_error_string(X509_STORE_CTX_get_error(ctx)),
86  subject);
87  ret = 1;
88  goto cleanup;
89  }
90 
91  /* Remote site specified a certificate, but it's not correct */
92  msg(D_TLS_ERRORS, "VERIFY ERROR: depth=%d, error=%s: %s",
93  X509_STORE_CTX_get_error_depth(ctx),
94  X509_verify_cert_error_string(X509_STORE_CTX_get_error(ctx)),
95  subject);
96 
97  ERR_clear_error();
98 
99  session->verified = false;
100  goto cleanup;
101  }
102 
103  if (SUCCESS != verify_cert(session, current_cert, X509_STORE_CTX_get_error_depth(ctx)))
104  {
105  goto cleanup;
106  }
107 
108  ret = 1;
109 
110 cleanup:
111  gc_free(&gc);
112 
113  return ret;
114 }
115 
116 #ifdef ENABLE_X509ALTUSERNAME
117 bool x509_username_field_ext_supported(const char *fieldname)
118 {
119  int nid = OBJ_txt2nid(fieldname);
120  return nid == NID_subject_alt_name || nid == NID_issuer_alt_name;
121 }
122 
123 static
124 bool
125 extract_x509_extension(X509 *cert, char *fieldname, char *out, int size)
126 {
127  bool retval = false;
128  char *buf = 0;
129 
130  if (!x509_username_field_ext_supported(fieldname))
131  {
133  "ERROR: --x509-username-field 'ext:%s' not supported", fieldname);
134  return false;
135  }
136 
137  int nid = OBJ_txt2nid(fieldname);
138  GENERAL_NAMES *extensions = X509_get_ext_d2i(cert, nid, NULL, NULL);
139  if (extensions)
140  {
141  int numalts;
142  int i;
143  /* get amount of alternatives,
144  * RFC2459 claims there MUST be at least
145  * one, but we don't depend on it...
146  */
147 
148  numalts = sk_GENERAL_NAME_num(extensions);
149 
150  /* loop through all alternatives */
151  for (i = 0; i<numalts; i++)
152  {
153  /* get a handle to alternative name number i */
154  const GENERAL_NAME *name = sk_GENERAL_NAME_value(extensions, i );
155 
156  switch (name->type)
157  {
158  case GEN_EMAIL:
159  if (ASN1_STRING_to_UTF8((unsigned char **)&buf, name->d.ia5) < 0)
160  {
161  continue;
162  }
163  if (strlen(buf) != name->d.ia5->length)
164  {
165  msg(D_TLS_ERRORS, "ASN1 ERROR: string contained terminating zero");
166  OPENSSL_free(buf);
167  }
168  else
169  {
170  strncpynt(out, buf, size);
171  OPENSSL_free(buf);
172  retval = true;
173  }
174  break;
175 
176  default:
177  msg(D_TLS_DEBUG, "%s: ignoring general name field type %i",
178  __func__, name->type);
179  break;
180  }
181  }
182  GENERAL_NAMES_free(extensions);
183  }
184  return retval;
185 }
186 #endif /* ENABLE_X509ALTUSERNAME */
187 
188 /*
189  * Extract a field from an X509 subject name.
190  *
191  * Example:
192  *
193  * /C=US/ST=CO/L=Denver/O=ORG/CN=First-CN/CN=Test-CA/Email=jim@yonan.net
194  *
195  * The common name is 'Test-CA'
196  *
197  * Return true on success, false on error (insufficient buffer size in 'out'
198  * to contain result is grounds for error).
199  */
200 static result_t
201 extract_x509_field_ssl(X509_NAME *x509, const char *field_name, char *out,
202  int size)
203 {
204  int lastpos = -1;
205  int tmp = -1;
206  X509_NAME_ENTRY *x509ne = NULL;
207  ASN1_STRING *asn1 = NULL;
208  unsigned char *buf = NULL;
209  ASN1_OBJECT *field_name_obj = OBJ_txt2obj(field_name, 0);
210 
211  if (field_name_obj == NULL)
212  {
213  msg(D_TLS_ERRORS, "Invalid X509 attribute name '%s'", field_name);
214  return FAILURE;
215  }
216 
217  ASSERT(size > 0);
218  *out = '\0';
219  do
220  {
221  lastpos = tmp;
222  tmp = X509_NAME_get_index_by_OBJ(x509, field_name_obj, lastpos);
223  } while (tmp > -1);
224 
225  ASN1_OBJECT_free(field_name_obj);
226 
227  /* Nothing found */
228  if (lastpos == -1)
229  {
230  return FAILURE;
231  }
232 
233  x509ne = X509_NAME_get_entry(x509, lastpos);
234  if (!x509ne)
235  {
236  return FAILURE;
237  }
238 
239  asn1 = X509_NAME_ENTRY_get_data(x509ne);
240  if (!asn1)
241  {
242  return FAILURE;
243  }
244  if (ASN1_STRING_to_UTF8(&buf, asn1) < 0)
245  {
246  return FAILURE;
247  }
248 
249  strncpynt(out, (char *)buf, size);
250 
251  {
252  const result_t ret = (strlen((char *)buf) < size) ? SUCCESS : FAILURE;
253  OPENSSL_free(buf);
254  return ret;
255  }
256 }
257 
258 result_t
259 backend_x509_get_username(char *common_name, int cn_len,
260  char *x509_username_field, X509 *peer_cert)
261 {
262 #ifdef ENABLE_X509ALTUSERNAME
263  if (strncmp("ext:",x509_username_field,4) == 0)
264  {
265  if (!extract_x509_extension(peer_cert, x509_username_field+4, common_name, cn_len))
266  {
267  return FAILURE;
268  }
269  }
270  else
271 #endif
272  if (FAILURE == extract_x509_field_ssl(X509_get_subject_name(peer_cert),
273  x509_username_field, common_name, cn_len))
274  {
275  return FAILURE;
276  }
277 
278  return SUCCESS;
279 }
280 
281 char *
283 {
284  ASN1_INTEGER *asn1_i;
285  BIGNUM *bignum;
286  char *openssl_serial, *serial;
287 
288  asn1_i = X509_get_serialNumber(cert);
289  bignum = ASN1_INTEGER_to_BN(asn1_i, NULL);
290  openssl_serial = BN_bn2dec(bignum);
291 
292  serial = string_alloc(openssl_serial, gc);
293 
294  BN_free(bignum);
295  OPENSSL_free(openssl_serial);
296 
297  return serial;
298 }
299 
300 char *
302 {
303  const ASN1_INTEGER *asn1_i = X509_get_serialNumber(cert);
304 
305  return format_hex_ex(asn1_i->data, asn1_i->length, 0, 1, ":", gc);
306 }
307 
308 struct buffer
309 x509_get_sha1_fingerprint(X509 *cert, struct gc_arena *gc)
310 {
311  const EVP_MD *sha1 = EVP_sha1();
312  struct buffer hash = alloc_buf_gc(EVP_MD_size(sha1), gc);
313  X509_digest(cert, EVP_sha1(), BPTR(&hash), NULL);
314  ASSERT(buf_inc_len(&hash, EVP_MD_size(sha1)));
315  return hash;
316 }
317 
318 struct buffer
319 x509_get_sha256_fingerprint(X509 *cert, struct gc_arena *gc)
320 {
321  const EVP_MD *sha256 = EVP_sha256();
322  struct buffer hash = alloc_buf_gc(EVP_MD_size(sha256), gc);
323  X509_digest(cert, EVP_sha256(), BPTR(&hash), NULL);
324  ASSERT(buf_inc_len(&hash, EVP_MD_size(sha256)));
325  return hash;
326 }
327 
328 char *
329 x509_get_subject(X509 *cert, struct gc_arena *gc)
330 {
331  BIO *subject_bio = NULL;
332  BUF_MEM *subject_mem;
333  char *subject = NULL;
334 
335  /*
336  * Generate the subject string in OpenSSL proprietary format,
337  * when in --compat-names mode
338  */
340  {
341  subject = gc_malloc(256, false, gc);
342  X509_NAME_oneline(X509_get_subject_name(cert), subject, 256);
343  subject[255] = '\0';
344  return subject;
345  }
346 
347  subject_bio = BIO_new(BIO_s_mem());
348  if (subject_bio == NULL)
349  {
350  goto err;
351  }
352 
353  X509_NAME_print_ex(subject_bio, X509_get_subject_name(cert),
354  0, XN_FLAG_SEP_CPLUS_SPC | XN_FLAG_FN_SN
355  |ASN1_STRFLGS_UTF8_CONVERT | ASN1_STRFLGS_ESC_CTRL);
356 
357  if (BIO_eof(subject_bio))
358  {
359  goto err;
360  }
361 
362  BIO_get_mem_ptr(subject_bio, &subject_mem);
363 
364  subject = gc_malloc(subject_mem->length + 1, false, gc);
365 
366  memcpy(subject, subject_mem->data, subject_mem->length);
367  subject[subject_mem->length] = '\0';
368 
369 err:
370  if (subject_bio)
371  {
372  BIO_free(subject_bio);
373  }
374 
375  return subject;
376 }
377 
378 
379 /*
380  * x509-track implementation -- save X509 fields to environment,
381  * using the naming convention:
382  *
383  * X509_{cert_depth}_{name}={value}
384  *
385  * This function differs from x509_setenv below in the following ways:
386  *
387  * (1) Only explicitly named attributes in xt are saved, per usage
388  * of "x509-track" program options.
389  * (2) Only the level 0 cert info is saved unless the XT_FULL_CHAIN
390  * flag is set in xt->flags (corresponds with prepending a '+'
391  * to the name when specified by "x509-track" program option).
392  * (3) This function supports both X509 subject name fields as
393  * well as X509 V3 extensions.
394  * (4) This function can return the SHA1 fingerprint of a cert, e.g.
395  * x509-track "+SHA1"
396  * will return the SHA1 fingerprint for each certificate in the
397  * peer chain.
398  */
399 
400 void
401 x509_track_add(const struct x509_track **ll_head, const char *name, int msglevel, struct gc_arena *gc)
402 {
403  struct x509_track *xt;
404  ALLOC_OBJ_CLEAR_GC(xt, struct x509_track, gc);
405  if (*name == '+')
406  {
407  xt->flags |= XT_FULL_CHAIN;
408  ++name;
409  }
410  xt->name = name;
411  xt->nid = OBJ_txt2nid(name);
412  if (xt->nid != NID_undef)
413  {
414  xt->next = *ll_head;
415  *ll_head = xt;
416  }
417  else
418  {
419  msg(msglevel, "x509_track: no such attribute '%s'", name);
420  }
421 }
422 
423 /* worker method for setenv_x509_track */
424 static void
425 do_setenv_x509(struct env_set *es, const char *name, char *value, int depth)
426 {
427  char *name_expand;
428  size_t name_expand_size;
429 
430  string_mod(value, CC_ANY, CC_CRLF, '?');
431  msg(D_X509_ATTR, "X509 ATTRIBUTE name='%s' value='%s' depth=%d", name, value, depth);
432  name_expand_size = 64 + strlen(name);
433  name_expand = (char *) malloc(name_expand_size);
434  check_malloc_return(name_expand);
435  openvpn_snprintf(name_expand, name_expand_size, "X509_%d_%s", depth, name);
436  setenv_str(es, name_expand, value);
437  free(name_expand);
438 }
439 
440 void
441 x509_setenv_track(const struct x509_track *xt, struct env_set *es, const int depth, X509 *x509)
442 {
443  struct gc_arena gc = gc_new();
444  X509_NAME *x509_name = X509_get_subject_name(x509);
445  const char nullc = '\0';
446 
447  while (xt)
448  {
449  if (depth == 0 || (xt->flags & XT_FULL_CHAIN))
450  {
451  switch (xt->nid)
452  {
453  case NID_sha1:
454  case NID_sha256:
455  {
456  struct buffer fp_buf;
457  char *fp_str = NULL;
458 
459  if (xt->nid == NID_sha1)
460  {
461  fp_buf = x509_get_sha1_fingerprint(x509, &gc);
462  }
463  else
464  {
465  fp_buf = x509_get_sha256_fingerprint(x509, &gc);
466  }
467 
468  fp_str = format_hex_ex(BPTR(&fp_buf), BLEN(&fp_buf), 0,
469  1 | FHE_CAPS, ":", &gc);
470  do_setenv_x509(es, xt->name, fp_str, depth);
471  }
472  break;
473 
474  default:
475  {
476  int i = X509_NAME_get_index_by_NID(x509_name, xt->nid, -1);
477  if (i >= 0)
478  {
479  X509_NAME_ENTRY *ent = X509_NAME_get_entry(x509_name, i);
480  if (ent)
481  {
482  ASN1_STRING *val = X509_NAME_ENTRY_get_data(ent);
483  unsigned char *buf = NULL;
484  if (ASN1_STRING_to_UTF8(&buf, val) >= 0)
485  {
486  do_setenv_x509(es, xt->name, (char *)buf, depth);
487  OPENSSL_free(buf);
488  }
489  }
490  }
491  else
492  {
493  i = X509_get_ext_by_NID(x509, xt->nid, -1);
494  if (i >= 0)
495  {
496  X509_EXTENSION *ext = X509_get_ext(x509, i);
497  if (ext)
498  {
499  BIO *bio = BIO_new(BIO_s_mem());
500  if (bio)
501  {
502  if (X509V3_EXT_print(bio, ext, 0, 0))
503  {
504  if (BIO_write(bio, &nullc, 1) == 1)
505  {
506  char *str;
507  BIO_get_mem_data(bio, &str);
508  do_setenv_x509(es, xt->name, str, depth);
509  }
510  }
511  BIO_free(bio);
512  }
513  }
514  }
515  }
516  }
517  }
518  }
519  xt = xt->next;
520  }
521  gc_free(&gc);
522 }
523 
524 /*
525  * Save X509 fields to environment, using the naming convention:
526  *
527  * X509_{cert_depth}_{name}={value}
528  */
529 void
530 x509_setenv(struct env_set *es, int cert_depth, openvpn_x509_cert_t *peer_cert)
531 {
532  int i, n;
533  int fn_nid;
534  ASN1_OBJECT *fn;
535  ASN1_STRING *val;
536  X509_NAME_ENTRY *ent;
537  const char *objbuf;
538  unsigned char *buf = NULL;
539  char *name_expand;
540  size_t name_expand_size;
541  X509_NAME *x509 = X509_get_subject_name(peer_cert);
542 
543  n = X509_NAME_entry_count(x509);
544  for (i = 0; i < n; ++i)
545  {
546  ent = X509_NAME_get_entry(x509, i);
547  if (!ent)
548  {
549  continue;
550  }
551  fn = X509_NAME_ENTRY_get_object(ent);
552  if (!fn)
553  {
554  continue;
555  }
556  val = X509_NAME_ENTRY_get_data(ent);
557  if (!val)
558  {
559  continue;
560  }
561  fn_nid = OBJ_obj2nid(fn);
562  if (fn_nid == NID_undef)
563  {
564  continue;
565  }
566  objbuf = OBJ_nid2sn(fn_nid);
567  if (!objbuf)
568  {
569  continue;
570  }
571  if (ASN1_STRING_to_UTF8(&buf, val) < 0)
572  {
573  continue;
574  }
575  name_expand_size = 64 + strlen(objbuf);
576  name_expand = (char *) malloc(name_expand_size);
577  check_malloc_return(name_expand);
578  openvpn_snprintf(name_expand, name_expand_size, "X509_%d_%s", cert_depth,
579  objbuf);
580  string_mod(name_expand, CC_PRINT, CC_CRLF, '_');
581  string_mod((char *)buf, CC_PRINT, CC_CRLF, '_');
582  setenv_str_incr(es, name_expand, (char *)buf);
583  free(name_expand);
584  OPENSSL_free(buf);
585  }
586 }
587 
588 result_t
590 {
591  if (usage == NS_CERT_CHECK_NONE)
592  {
593  return SUCCESS;
594  }
595  if (usage == NS_CERT_CHECK_CLIENT)
596  {
597  /*
598  * Unfortunately, X509_check_purpose() does some weird thing that
599  * prevent it to take a const argument
600  */
601  result_t result = X509_check_purpose(peer_cert, X509_PURPOSE_SSL_CLIENT, 0) ?
602  SUCCESS : FAILURE;
603 
604  /*
605  * old versions of OpenSSL allow us to make the less strict check we used to
606  * do. If this less strict check pass, warn user that this might not be the
607  * case when its distribution will update to OpenSSL 1.1
608  */
609  if (result == FAILURE)
610  {
611  ASN1_BIT_STRING *ns;
612  ns = X509_get_ext_d2i(peer_cert, NID_netscape_cert_type, NULL, NULL);
613  result = (ns && ns->length > 0 && (ns->data[0] & NS_SSL_CLIENT)) ? SUCCESS : FAILURE;
614  if (result == SUCCESS)
615  {
616  msg(M_WARN, "X509: Certificate is a client certificate yet it's purpose "
617  "cannot be verified (check may fail in the future)");
618  }
619  ASN1_BIT_STRING_free(ns);
620  }
621  return result;
622  }
623  if (usage == NS_CERT_CHECK_SERVER)
624  {
625  /*
626  * Unfortunately, X509_check_purpose() does some weird thing that
627  * prevent it to take a const argument
628  */
629  result_t result = X509_check_purpose(peer_cert, X509_PURPOSE_SSL_SERVER, 0) ?
630  SUCCESS : FAILURE;
631 
632  /*
633  * old versions of OpenSSL allow us to make the less strict check we used to
634  * do. If this less strict check pass, warn user that this might not be the
635  * case when its distribution will update to OpenSSL 1.1
636  */
637  if (result == FAILURE)
638  {
639  ASN1_BIT_STRING *ns;
640  ns = X509_get_ext_d2i(peer_cert, NID_netscape_cert_type, NULL, NULL);
641  result = (ns && ns->length > 0 && (ns->data[0] & NS_SSL_SERVER)) ? SUCCESS : FAILURE;
642  if (result == SUCCESS)
643  {
644  msg(M_WARN, "X509: Certificate is a server certificate yet it's purpose "
645  "cannot be verified (check may fail in the future)");
646  }
647  ASN1_BIT_STRING_free(ns);
648  }
649  return result;
650  }
651 
652  return FAILURE;
653 }
654 
655 result_t
656 x509_verify_cert_ku(X509 *x509, const unsigned *const expected_ku,
657  int expected_len)
658 {
659  ASN1_BIT_STRING *ku = X509_get_ext_d2i(x509, NID_key_usage, NULL, NULL);
660 
661  if (ku == NULL)
662  {
663  msg(D_TLS_ERRORS, "Certificate does not have key usage extension");
664  return FAILURE;
665  }
666 
667  if (expected_ku[0] == OPENVPN_KU_REQUIRED)
668  {
669  /* Extension required, value checked by TLS library */
670  ASN1_BIT_STRING_free(ku);
671  return SUCCESS;
672  }
673 
674  unsigned nku = 0;
675  for (size_t i = 0; i < 8; i++)
676  {
677  if (ASN1_BIT_STRING_get_bit(ku, i))
678  {
679  nku |= 1 << (7 - i);
680  }
681  }
682 
683  /*
684  * Fixup if no LSB bits
685  */
686  if ((nku & 0xff) == 0)
687  {
688  nku >>= 8;
689  }
690 
691  msg(D_HANDSHAKE, "Validating certificate key usage");
692  result_t fFound = FAILURE;
693  for (size_t i = 0; fFound != SUCCESS && i < expected_len; i++)
694  {
695  if (expected_ku[i] != 0 && (nku & expected_ku[i]) == expected_ku[i])
696  {
697  fFound = SUCCESS;
698  }
699  }
700 
701  if (fFound != SUCCESS)
702  {
704  "ERROR: Certificate has key usage %04x, expected one of:", nku);
705  for (size_t i = 0; i < expected_len && expected_ku[i]; i++)
706  {
707  msg(D_TLS_ERRORS, " * %04x", expected_ku[i]);
708  }
709  }
710 
711  ASN1_BIT_STRING_free(ku);
712 
713  return fFound;
714 }
715 
716 result_t
717 x509_verify_cert_eku(X509 *x509, const char *const expected_oid)
718 {
719  EXTENDED_KEY_USAGE *eku = NULL;
720  result_t fFound = FAILURE;
721 
722  if ((eku = (EXTENDED_KEY_USAGE *) X509_get_ext_d2i(x509, NID_ext_key_usage,
723  NULL, NULL)) == NULL)
724  {
725  msg(D_HANDSHAKE, "Certificate does not have extended key usage extension");
726  }
727  else
728  {
729  int i;
730 
731  msg(D_HANDSHAKE, "Validating certificate extended key usage");
732  for (i = 0; SUCCESS != fFound && i < sk_ASN1_OBJECT_num(eku); i++)
733  {
734  ASN1_OBJECT *oid = sk_ASN1_OBJECT_value(eku, i);
735  char szOid[1024];
736 
737  if (SUCCESS != fFound && OBJ_obj2txt(szOid, sizeof(szOid), oid, 0) != -1)
738  {
739  msg(D_HANDSHAKE, "++ Certificate has EKU (str) %s, expects %s",
740  szOid, expected_oid);
741  if (!strcmp(expected_oid, szOid))
742  {
743  fFound = SUCCESS;
744  }
745  }
746  if (SUCCESS != fFound && OBJ_obj2txt(szOid, sizeof(szOid), oid, 1) != -1)
747  {
748  msg(D_HANDSHAKE, "++ Certificate has EKU (oid) %s, expects %s",
749  szOid, expected_oid);
750  if (!strcmp(expected_oid, szOid))
751  {
752  fFound = SUCCESS;
753  }
754  }
755  }
756  }
757 
758  if (eku != NULL)
759  {
760  sk_ASN1_OBJECT_pop_free(eku, ASN1_OBJECT_free);
761  }
762 
763  return fFound;
764 }
765 
766 result_t
767 x509_write_pem(FILE *peercert_file, X509 *peercert)
768 {
769  if (PEM_write_X509(peercert_file, peercert) < 0)
770  {
771  msg(M_NONFATAL, "Failed to write peer certificate in PEM format");
772  return FAILURE;
773  }
774  return SUCCESS;
775 }
776 
777 bool
779 {
780  if (!opt->crl_file || (opt->ssl_flags & SSLF_CRL_VERIFY_DIR))
781  {
782  return false;
783  }
784 
785  X509_STORE *store = SSL_CTX_get_cert_store(opt->ssl_ctx.ctx);
786  if (!store)
787  {
788  crypto_msg(M_FATAL, "Cannot get certificate store");
789  }
790 
791  STACK_OF(X509_OBJECT) *objs = X509_STORE_get0_objects(store);
792  for (int i = 0; i < sk_X509_OBJECT_num(objs); i++)
793  {
794  X509_OBJECT *obj = sk_X509_OBJECT_value(objs, i);
795  ASSERT(obj);
796  if (X509_OBJECT_get_type(obj) == X509_LU_CRL)
797  {
798  return false;
799  }
800  }
801  return true;
802 }
803 
804 #endif /* defined(ENABLE_CRYPTO_OPENSSL) */
static void strncpynt(char *dest, const char *src, size_t maxlen)
Definition: buffer.h:348
const char * crl_file
Definition: ssl_common.h:278
#define SSLF_CRL_VERIFY_DIR
Definition: ssl_common.h:335
#define D_TLS_DEBUG_LOW
Definition: errlevel.h:77
char * string_alloc(const char *str, struct gc_arena *gc)
Definition: buffer.c:680
#define D_TLS_DEBUG
Definition: errlevel.h:159
bool tls_verify_crl_missing(const struct tls_options *opt)
Return true iff a CRL is configured, but is not loaded.
static void gc_free(struct gc_arena *a)
Definition: buffer.h:1010
struct tls_root_ctx ssl_ctx
Definition: ssl_common.h:238
bool verified
Definition: ssl_common.h:431
#define NS_CERT_CHECK_CLIENT
Do not perform Netscape certificate type verification.
Definition: ssl_verify.h:216
#define D_TLS_ERRORS
Definition: errlevel.h:59
#define CC_PRINT
Definition: buffer.h:902
X509 openvpn_x509_cert_t
#define ASSERT(x)
Definition: error.h:221
#define M_FATAL
Definition: error.h:94
#define crypto_msg(flags,...)
Retrieve any OpenSSL errors, then print the supplied error message.
void cert_hash_remember(struct tls_session *session, const int error_depth, const struct buffer *cert_hash)
Definition: ssl_verify.c:247
void setenv_str(struct env_set *es, const char *name, const char *value)
Definition: env_set.c:285
void x509_setenv(struct env_set *es, int cert_depth, openvpn_x509_cert_t *peer_cert)
result_t verify_cert(struct tls_session *session, openvpn_x509_cert_t *cert, int cert_depth)
Definition: ssl_verify.c:670
result_t x509_verify_cert_ku(X509 *x509, const unsigned *const expected_ku, int expected_len)
char * x509_get_subject(X509 *cert, struct gc_arena *gc)
#define D_X509_ATTR
Definition: errlevel.h:104
#define BPTR(buf)
Definition: buffer.h:124
struct buffer x509_get_sha1_fingerprint(X509 *cert, struct gc_arena *gc)
Retrieve the certificate&#39;s SHA1 fingerprint.
bool openvpn_snprintf(char *str, size_t size, const char *format,...)
Definition: buffer.c:299
void setenv_str_incr(struct env_set *es, const char *name, const char *value)
Store the supplied name value pair in the env_set.
Definition: env_set.c:307
static struct gc_arena gc_new(void)
Definition: buffer.h:1002
#define COMPAT_NAMES
Definition: misc.h:171
result_t x509_verify_cert_eku(X509 *x509, const char *const expected_oid)
#define malloc
Definition: cmocka.c:1795
unsigned int flags
Definition: ssl_verify.h:204
void * gc_malloc(size_t size, bool clear, struct gc_arena *a)
Definition: buffer.c:400
#define NS_CERT_CHECK_NONE
Do not perform Netscape certificate type verification.
Definition: ssl_verify.h:212
#define COMPAT_FLAG_QUERY
Definition: misc.h:169
static STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(X509_STORE *store)
Fetch the X509 object stack from the X509 store.
void x509_setenv_track(const struct x509_track *xt, struct env_set *es, const int depth, X509 *x509)
const struct x509_track * next
Definition: ssl_verify.h:201
static result_t extract_x509_field_ssl(X509_NAME *x509, const char *field_name, char *out, int size)
char * format_hex_ex(const uint8_t *data, int size, int maxoutput, unsigned int space_break_flags, const char *separator, struct gc_arena *gc)
Definition: buffer.c:514
struct buffer x509_get_sha256_fingerprint(X509 *cert, struct gc_arena *gc)
Retrieve the certificate&#39;s SHA256 fingerprint.
const char * name
Definition: ssl_verify.h:202
char * backend_x509_get_serial_hex(openvpn_x509_cert_t *cert, struct gc_arena *gc)
#define BLEN(buf)
Definition: buffer.h:127
int verify_callback(int preverify_ok, X509_STORE_CTX *ctx)
Verify that the remote OpenVPN peer&#39;s certificate allows setting up a VPN tunnel. ...
char * backend_x509_get_serial(openvpn_x509_cert_t *cert, struct gc_arena *gc)
#define D_HANDSHAKE
Definition: errlevel.h:72
SSL_CTX * ctx
Definition: ssl_openssl.h:39
bool string_mod(char *str, const unsigned int inclusive, const unsigned int exclusive, const char replace)
Definition: buffer.c:1073
#define ALLOC_OBJ_CLEAR_GC(dptr, type, gc)
Definition: buffer.h:1074
static void do_setenv_x509(struct env_set *es, const char *name, char *value, int depth)
static bool buf_inc_len(struct buffer *buf, int inc)
Definition: buffer.h:605
static void check_malloc_return(const void *p)
Definition: buffer.h:1080
static void usage(void)
Definition: options.c:4054
Security parameter state of a single session within a VPN tunnel.
Definition: ssl_common.h:398
#define msg
Definition: error.h:173
Wrapper structure for dynamically allocated memory.
Definition: buffer.h:60
int mydata_index
Allocate space in SSL objects in which to store a struct tls_session pointer back to parent...
Definition: ssl_openssl.c:74
#define FHE_CAPS
Definition: buffer.h:513
struct buffer alloc_buf_gc(size_t size, struct gc_arena *gc)
Definition: buffer.c:90
#define free
Definition: cmocka.c:1850
Garbage collection arena used to keep track of dynamically allocated memory.
Definition: buffer.h:116
result_t backend_x509_get_username(char *common_name, int cn_len, char *x509_username_field, X509 *peer_cert)
result_t x509_write_pem(FILE *peercert_file, X509 *peercert)
void x509_track_add(const struct x509_track **ll_head, const char *name, int msglevel, struct gc_arena *gc)
#define XT_FULL_CHAIN
Definition: ssl_verify.h:203
#define CC_CRLF
Definition: buffer.h:931
#define M_NONFATAL
Definition: error.h:95
#define CC_ANY
Definition: buffer.h:894
bool compat_flag(unsigned int flag)
Will set or query for a global compat flag.
Definition: misc.c:679
unsigned int ssl_flags
Definition: ssl_common.h:340
#define M_WARN
Definition: error.h:96
result_t x509_verify_ns_cert_type(openvpn_x509_cert_t *peer_cert, const int usage)
static int X509_OBJECT_get_type(const X509_OBJECT *obj)
Get the type of an X509 object.
result_t
Result of verification function.
#define NS_CERT_CHECK_SERVER
Do not perform Netscape certificate type verification.
Definition: ssl_verify.h:214
#define OPENVPN_KU_REQUIRED
Require keyUsage to be present in cert (0xFFFF is an invalid KU value)
Definition: ssl_verify.h:219