OpenVPN
ssl_verify.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-2025 OpenVPN Inc <sales@openvpn.net>
9 * Copyright (C) 2010-2021 Fox Crypto B.V. <openvpn@foxcrypto.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, see <https://www.gnu.org/licenses/>.
22 */
23
29#ifdef HAVE_CONFIG_H
30#include "config.h"
31#endif
32
33#include "syshead.h"
34#include <string.h>
35
36#include "base64.h"
37#include "manage.h"
38#include "otime.h"
39#include "run_command.h"
40#include "ssl_verify.h"
41#include "ssl_verify_backend.h"
42
43#ifdef ENABLE_CRYPTO_OPENSSL
44#include "ssl_verify_openssl.h"
45#endif
46#include "auth_token.h"
47#include "push.h"
48#include "ssl_util.h"
49
50static void
52{
53 string_mod(str, CC_PRINT, CC_CRLF, '_');
54}
55
56/*
57 * Export the untrusted IP address and port to the environment
58 */
59static void
61{
62 setenv_link_socket_actual(session->opt->es, "untrusted", &session->untrusted_addr, SA_IP_PORT);
63}
64
65/*
66 * Remove authenticated state from all sessions in the given tunnel
67 */
68static void
70{
71 if (multi)
72 {
73 wipe_auth_token(multi);
74 for (int i = 0; i < TM_SIZE; ++i)
75 {
76 for (int j = 0; j < KS_SIZE; ++j)
77 {
79 }
80 }
81 }
82}
83
84void
85set_common_name(struct tls_session *session, const char *common_name)
86{
87 if (session->common_name)
88 {
89 free(session->common_name);
90 session->common_name = NULL;
91 }
92 if (common_name)
93 {
94 /* FIXME: Last alloc will never be freed */
95 session->common_name = string_alloc(common_name, NULL);
96 }
97 /* update common name in env */
98 setenv_str(session->opt->es, "common_name", common_name);
99}
100
101/*
102 * Retrieve the common name for the given tunnel's active session. If the
103 * common name is NULL or empty, return NULL if null is true, or "UNDEF" if
104 * null is false.
105 */
106const char *
107tls_common_name(const struct tls_multi *multi, const bool null)
108{
109 const char *ret = NULL;
110 if (multi)
111 {
112 ret = multi->session[TM_ACTIVE].common_name;
113 }
114 if (ret && strlen(ret))
115 {
116 return ret;
117 }
118 else if (null)
119 {
120 return NULL;
121 }
122 else
123 {
124 return "UNDEF";
125 }
126}
127
128/*
129 * Lock the common name for the given tunnel.
130 */
131void
133{
134 const char *cn = multi->session[TM_ACTIVE].common_name;
135 if (cn && !multi->locked_cn)
136 {
137 multi->locked_cn = string_alloc(cn, NULL);
138 }
139}
140
141/*
142 * Lock the username for the given tunnel
143 */
144static bool
145tls_lock_username(struct tls_multi *multi, const char *username)
146{
147 if (multi->locked_username)
148 {
149 /* If the username has been overridden, we accept both the original
150 * username and the changed username */
151 if (strcmp(username, multi->locked_username) != 0
152 && (!multi->locked_original_username
153 || strcmp(username, multi->locked_original_username) != 0))
154 {
156 "TLS Auth Error: username attempted to change from '%s' to '%s' -- tunnel disabled",
157 multi->locked_username, username);
158
159 /* disable the tunnel */
160 tls_deauthenticate(multi);
161 return false;
162 }
163 }
164 else
165 {
166 multi->locked_username = string_alloc(username, NULL);
167 }
168 return true;
169}
170
171const char *
172tls_username(const struct tls_multi *multi, const bool null)
173{
174 const char *ret = NULL;
175 if (multi)
176 {
177 ret = multi->locked_username;
178 }
179 if (ret && strlen(ret))
180 {
181 return ret;
182 }
183 else if (null)
184 {
185 return NULL;
186 }
187 else
188 {
189 return "UNDEF";
190 }
191}
192
193void
194cert_hash_remember(struct tls_session *session, const int error_depth,
195 const struct buffer *cert_hash)
196{
197 if (error_depth >= 0 && error_depth < MAX_CERT_DEPTH)
198 {
199 if (!session->cert_hash_set)
200 {
201 ALLOC_OBJ_CLEAR(session->cert_hash_set, struct cert_hash_set);
202 }
203 if (!session->cert_hash_set->ch[error_depth])
204 {
205 ALLOC_OBJ(session->cert_hash_set->ch[error_depth], struct cert_hash);
206 }
207
208 struct cert_hash *ch = session->cert_hash_set->ch[error_depth];
209 ASSERT(sizeof(ch->sha256_hash) == BLEN(cert_hash));
210 memcpy(ch->sha256_hash, BPTR(cert_hash), sizeof(ch->sha256_hash));
211 }
212}
213
214void
216{
217 if (chs)
218 {
219 int i;
220 for (i = 0; i < MAX_CERT_DEPTH; ++i)
221 {
222 free(chs->ch[i]);
223 }
224 free(chs);
225 }
226}
227
228bool
229cert_hash_compare(const struct cert_hash_set *chs1, const struct cert_hash_set *chs2)
230{
231 if (chs1 && chs2)
232 {
233 int i;
234 for (i = 0; i < MAX_CERT_DEPTH; ++i)
235 {
236 const struct cert_hash *ch1 = chs1->ch[i];
237 const struct cert_hash *ch2 = chs2->ch[i];
238
239 if (!ch1 && !ch2)
240 {
241 continue;
242 }
243 else if (ch1 && ch2
244 && !memcmp(ch1->sha256_hash, ch2->sha256_hash, sizeof(ch1->sha256_hash)))
245 {
246 continue;
247 }
248 else
249 {
250 return false;
251 }
252 }
253 return true;
254 }
255 else if (!chs1 && !chs2)
256 {
257 return true;
258 }
259 else
260 {
261 return false;
262 }
263}
264
265static struct cert_hash_set *
267{
268 struct cert_hash_set *dest = NULL;
269 if (chs)
270 {
271 int i;
272 ALLOC_OBJ_CLEAR(dest, struct cert_hash_set);
273 for (i = 0; i < MAX_CERT_DEPTH; ++i)
274 {
275 const struct cert_hash *ch = chs->ch[i];
276 if (ch)
277 {
278 ALLOC_OBJ(dest->ch[i], struct cert_hash);
279 memcpy(dest->ch[i]->sha256_hash, ch->sha256_hash, sizeof(dest->ch[i]->sha256_hash));
280 }
281 }
282 }
283 return dest;
284}
285void
287{
288 const struct cert_hash_set *chs = multi->session[TM_ACTIVE].cert_hash_set;
289 if (chs && !multi->locked_cert_hash_set)
290 {
292 }
293}
294
295/*
296 * Returns the string associated with the given certificate type.
297 */
298static const char *
300{
301 switch (type)
302 {
304 return "SERVER";
305
307 return "CLIENT";
308
309 default:
310 return "?";
311 }
312}
313
314/*
315 * Verify the peer's certificate fields.
316 *
317 * @param opt the tls options to verify against
318 * @param peer_cert the peer's certificate
319 * @param subject the peer's extracted subject name
320 * @param subject the peer's extracted common name
321 */
322static result_t
323verify_peer_cert(const struct tls_options *opt, openvpn_x509_cert_t *peer_cert, const char *subject,
324 const char *common_name)
325{
326 /* verify certificate nsCertType */
328 {
329 if (SUCCESS == x509_verify_ns_cert_type(peer_cert, opt->ns_cert_type))
330 {
331 msg(D_HANDSHAKE, "VERIFY OK: nsCertType=%s", print_nsCertType(opt->ns_cert_type));
332 }
333 else
334 {
335 msg(D_HANDSHAKE, "VERIFY nsCertType ERROR: %s, require nsCertType=%s", subject,
337 return FAILURE; /* Reject connection */
338 }
339 }
340
341 /* verify certificate ku */
342 if (opt->remote_cert_ku[0] != 0)
343 {
344 if (SUCCESS == x509_verify_cert_ku(peer_cert, opt->remote_cert_ku, MAX_PARMS))
345 {
346 msg(D_HANDSHAKE, "VERIFY KU OK");
347 }
348 else
349 {
350 msg(D_HANDSHAKE, "VERIFY KU ERROR");
351 return FAILURE; /* Reject connection */
352 }
353 }
354
355 /* verify certificate eku */
356 if (opt->remote_cert_eku != NULL)
357 {
358 if (SUCCESS == x509_verify_cert_eku(peer_cert, opt->remote_cert_eku))
359 {
360 msg(D_HANDSHAKE, "VERIFY EKU OK");
361 }
362 else
363 {
364 msg(D_HANDSHAKE, "VERIFY EKU ERROR");
365 return FAILURE; /* Reject connection */
366 }
367 }
368
369 /* verify X509 name or username against --verify-x509-[user]name */
371 {
373 && strcmp(opt->verify_x509_name, subject) == 0)
375 && strcmp(opt->verify_x509_name, common_name) == 0)
377 && strncmp(opt->verify_x509_name, common_name, strlen(opt->verify_x509_name)) == 0))
378 {
379 msg(D_HANDSHAKE, "VERIFY X509NAME OK: %s", subject);
380 }
381 else
382 {
383 msg(D_HANDSHAKE, "VERIFY X509NAME ERROR: %s, must be %s", subject,
384 opt->verify_x509_name);
385 return FAILURE; /* Reject connection */
386 }
387 }
388
389 return SUCCESS;
390}
391
392/*
393 * Export the subject, common_name, and raw certificate fields to the
394 * environment for later verification by scripts and plugins.
395 */
396static void
397verify_cert_set_env(struct env_set *es, openvpn_x509_cert_t *peer_cert, int cert_depth,
398 const char *subject, const struct x509_track *x509_track)
399{
400 char envname[64];
401 char *serial = NULL;
402 struct gc_arena gc = gc_new();
403
404 /* Save X509 fields in environment */
405 if (x509_track)
406 {
407 x509_setenv_track(x509_track, es, cert_depth, peer_cert);
408 }
409 else
410 {
411 x509_setenv(es, cert_depth, peer_cert);
412 }
413
414 /* export subject name string as environmental variable */
415 snprintf(envname, sizeof(envname), "tls_id_%d", cert_depth);
416 setenv_str(es, envname, subject);
417
418 /* export X509 cert fingerprints */
419 {
422
423 snprintf(envname, sizeof(envname), "tls_digest_%d", cert_depth);
424 setenv_str(es, envname, format_hex_ex(BPTR(&sha1), BLEN(&sha1), 0, 1, ":", &gc));
425
426 snprintf(envname, sizeof(envname), "tls_digest_sha256_%d", cert_depth);
427 setenv_str(es, envname, format_hex_ex(BPTR(&sha256), BLEN(&sha256), 0, 1, ":", &gc));
428 }
429
430 /* export serial number as environmental variable */
432 snprintf(envname, sizeof(envname), "tls_serial_%d", cert_depth);
434
435 /* export serial number in hex as environmental variable */
437 snprintf(envname, sizeof(envname), "tls_serial_hex_%d", cert_depth);
439
440 gc_free(&gc);
441}
442
447static bool
449 const char *pem_export_fname)
450{
451 /* export the path to the current certificate in pem file format */
452 setenv_str(es, "peer_cert", pem_export_fname);
453
455}
456
457static void
459{
460 env_set_del(es, "peer_cert");
462 {
464 }
465}
466
467/*
468 * call --tls-verify plug-in(s)
469 */
470static result_t
471verify_cert_call_plugin(const struct plugin_list *plugins, struct env_set *es, int cert_depth,
472 openvpn_x509_cert_t *cert, char *subject)
473{
475 {
476 int ret;
477 struct argv argv = argv_new();
478
479 argv_printf(&argv, "%d %s", cert_depth, subject);
480
481 ret =
482 plugin_call_ssl(plugins, OPENVPN_PLUGIN_TLS_VERIFY, &argv, NULL, es, cert_depth, cert);
483
484 argv_free(&argv);
485
486 if (ret == OPENVPN_PLUGIN_FUNC_SUCCESS)
487 {
488 msg(D_HANDSHAKE, "VERIFY PLUGIN OK: depth=%d, %s", cert_depth, subject);
489 }
490 else
491 {
492 msg(D_HANDSHAKE, "VERIFY PLUGIN ERROR: depth=%d, %s", cert_depth, subject);
493 return FAILURE; /* Reject connection */
494 }
495 }
496 return SUCCESS;
497}
498
499/*
500 * run --tls-verify script
501 */
502static result_t
503verify_cert_call_command(const char *verify_command, struct env_set *es, int cert_depth,
504 char *subject)
505{
506 int ret;
507 struct gc_arena gc = gc_new();
508 struct argv argv = argv_new();
509
510 setenv_str(es, "script_type", "tls-verify");
511
512 argv_parse_cmd(&argv, verify_command);
513 argv_printf_cat(&argv, "%d %s", cert_depth, subject);
514
515 argv_msg_prefix(D_TLS_DEBUG, &argv, "TLS: executing verify command");
516 ret = openvpn_run_script(&argv, es, 0, "--tls-verify script");
517
518 gc_free(&gc);
519 argv_free(&argv);
520
521 if (ret)
522 {
523 msg(D_HANDSHAKE, "VERIFY SCRIPT OK: depth=%d, %s", cert_depth, subject);
524 return SUCCESS;
525 }
526
527 msg(D_HANDSHAKE, "VERIFY SCRIPT ERROR: depth=%d, %s", cert_depth, subject);
528 return FAILURE; /* Reject connection */
529}
530
531/*
532 * check peer cert against CRL directory
533 */
534static result_t
535verify_check_crl_dir(const char *crl_dir, openvpn_x509_cert_t *cert, const char *subject,
536 int cert_depth)
537{
538 result_t ret = FAILURE;
539 char fn[256];
540 int fd = -1;
541 struct gc_arena gc = gc_new();
542
543 char *serial = backend_x509_get_serial(cert, &gc);
544 if (!serial)
545 {
546 msg(D_HANDSHAKE, "VERIFY CRL: depth=%d, %s, serial number is not available", cert_depth,
547 subject);
548 goto cleanup;
549 }
550
551 if (!snprintf(fn, sizeof(fn), "%s%c%s", crl_dir, PATH_SEPARATOR, serial))
552 {
553 msg(D_HANDSHAKE, "VERIFY CRL: filename overflow");
554 goto cleanup;
555 }
556 fd = platform_open(fn, O_RDONLY, 0);
557 if (fd >= 0)
558 {
559 msg(D_HANDSHAKE, "VERIFY CRL: depth=%d, %s, serial=%s is revoked", cert_depth, subject,
560 serial);
561 goto cleanup;
562 }
563
564 ret = SUCCESS;
565
566cleanup:
567
568 if (fd != -1)
569 {
570 close(fd);
571 }
572 gc_free(&gc);
573 return ret;
574}
575
577verify_cert(struct tls_session *session, openvpn_x509_cert_t *cert, int cert_depth)
578{
579 /* need to define these variables here so goto cleanup will always have
580 * them defined */
581 result_t ret = FAILURE;
582 struct gc_arena gc = gc_new();
583 const char *pem_export_fname = NULL;
584
585 const struct tls_options *opt = session->opt;
586 ASSERT(opt);
587
588 session->verified = false;
589
590 /* get the X509 name */
591 char *subject = x509_get_subject(cert, &gc);
592 if (!subject)
593 {
595 "VERIFY ERROR: depth=%d, could not extract X509 "
596 "subject string from certificate",
597 cert_depth);
598 goto cleanup;
599 }
600
601 /* enforce character class restrictions in X509 name */
602 string_mod_remap_name(subject);
603 string_replace_leading(subject, '-', '_');
604
605 /* extract the username (default is CN) */
606 struct buffer buf = alloc_buf_gc(256, &gc);
607 for (int i = 0; opt->x509_username_field[i] != NULL; i++)
608 {
609 char username[TLS_USERNAME_LEN + 1] = { 0 }; /* null-terminated */
610
611 if (SUCCESS
612 != backend_x509_get_username(username, sizeof(username), opt->x509_username_field[i],
613 cert))
614 {
615 if (!cert_depth)
616 {
618 "VERIFY ERROR: could not extract %s from X509 "
619 "subject string ('%s') -- note that the field length is "
620 "limited to %d characters",
622 goto cleanup;
623 }
624 break;
625 }
626 if (!buf_printf(&buf, i ? "_%s" : "%s", username))
627 {
628 if (!cert_depth)
629 {
631 "VERIFY ERROR: could not append %s from X509 "
632 "certificate -- note that the username length is "
633 "limited to %d characters",
634 opt->x509_username_field[i], buf.capacity - 1);
635 goto cleanup;
636 }
637 break;
638 }
639 }
640
641 char *common_name = BSTR(&buf);
642 if (!common_name)
643 {
645 "VERIFY ERROR: depth=%d, could not extract X509 "
646 "username string from certificate",
647 cert_depth);
648 goto cleanup;
649 }
650
651 /* enforce character class restrictions in common name */
652 string_mod_remap_name(common_name);
653
654 /* warn if cert chain is too deep */
656 {
658 "TLS Error: Convoluted certificate chain detected with depth [%d] greater than %d",
660 goto cleanup; /* Reject connection */
661 }
662
663 if (cert_depth == opt->verify_hash_depth && opt->verify_hash)
664 {
665 struct buffer cert_fp = { 0 };
666
667 switch (opt->verify_hash_algo)
668 {
669 case MD_SHA1:
671 break;
672
673 case MD_SHA256:
675 break;
676
677 default:
678 /* This should normally not happen at all; the algorithm used
679 * is parsed by add_option() [options.c] and set to a predefined
680 * value in an enumerated type. So if this unlikely scenario
681 * happens, consider this a failure
682 */
683 msg(M_WARN,
684 "Unexpected invalid algorithm used with "
685 "--verify-hash (%i)",
686 opt->verify_hash_algo);
687 ret = FAILURE;
688 goto cleanup;
689 }
690
691 struct verify_hash_list *current_hash = opt->verify_hash;
692
693 while (current_hash)
694 {
695 if (memcmp_constant_time(BPTR(&cert_fp), current_hash->hash, BLEN(&cert_fp)) == 0)
696 {
697 break;
698 }
699 current_hash = current_hash->next;
700 }
701
702 if (!current_hash)
703 {
704 const char *hex_fp = format_hex_ex(BPTR(&cert_fp), BLEN(&cert_fp), 0, 1, ":", &gc);
706 "TLS Error: --tls-verify/--peer-fingerprint "
707 "certificate hash verification failed. (got certificate "
708 "fingerprint: %s)",
709 hex_fp);
710 goto cleanup;
711 }
712 }
713
714 /* save common name in session object */
715 if (cert_depth == 0)
716 {
717 set_common_name(session, common_name);
718 }
719
720 session->verify_maxlevel = max_int(session->verify_maxlevel, cert_depth);
721
722 if (opt->export_peer_cert_dir)
723 {
724 pem_export_fname = platform_create_temp_file(opt->export_peer_cert_dir, "pef", &gc);
725
726 if (!pem_export_fname || !verify_cert_cert_export_env(opt->es, cert, pem_export_fname))
727 {
729 "TLS Error: Failed to export certificate for "
730 "--tls-export-cert in %s",
732 goto cleanup;
733 }
734 }
735 /* export certificate values to the environment */
736 verify_cert_set_env(opt->es, cert, cert_depth, subject, opt->x509_track);
737
738 /* export current untrusted IP */
740
741 /* If this is the peer's own certificate, verify it */
742 if (cert_depth == 0 && SUCCESS != verify_peer_cert(opt, cert, subject, common_name))
743 {
744 goto cleanup;
745 }
746
747 /* call --tls-verify plug-in(s), if registered */
748 if (SUCCESS != verify_cert_call_plugin(opt->plugins, opt->es, cert_depth, cert, subject))
749 {
750 goto cleanup;
751 }
752
753 /* run --tls-verify script */
754 if (opt->verify_command
755 && SUCCESS != verify_cert_call_command(opt->verify_command, opt->es, cert_depth, subject))
756 {
757 goto cleanup;
758 }
759
760 /* check peer cert against CRL */
761 if (opt->crl_file)
762 {
764 {
765 if (SUCCESS != verify_check_crl_dir(opt->crl_file, cert, subject, cert_depth))
766 {
767 goto cleanup;
768 }
769 }
770 else
771 {
772 if (tls_verify_crl_missing(opt))
773 {
774 msg(D_TLS_ERRORS, "VERIFY ERROR: CRL not loaded");
775 goto cleanup;
776 }
777 }
778 }
779
780 msg(D_HANDSHAKE, "VERIFY OK: depth=%d, %s", cert_depth, subject);
781 session->verified = true;
782 ret = SUCCESS;
783
784cleanup:
785 verify_cert_cert_delete_env(opt->es, pem_export_fname);
786 if (ret != SUCCESS)
787 {
788 tls_clear_error(); /* always? */
789 session->verified = false; /* double sure? */
790 }
791
792 gc_free(&gc);
793
794 return ret;
795}
796
797/* ***************************************************************************
798 * Functions for the management of deferred authentication when using
799 * user/password authentication.
800 *************************************************************************** */
801
802void
803auth_set_client_reason(struct tls_multi *multi, const char *client_reason)
804{
805 free(multi->client_reason);
806 multi->client_reason = NULL;
807
808 if (client_reason && strlen(client_reason))
809 {
810 multi->client_reason = string_alloc(client_reason, NULL);
811 }
812}
813
814#ifdef ENABLE_MANAGEMENT
815
816static inline enum auth_deferred_result
818{
820 {
821 return ks->mda_status;
822 }
823 else
824 {
825 return ACF_DISABLED;
826 }
827}
828#endif /* ifdef ENABLE_MANAGEMENT */
829
834static void
836{
837 if (ads && ads->auth_pending_file)
838 {
840 free(ads->auth_pending_file);
841 ads->auth_pending_file = NULL;
842 }
843}
844
848static bool
849check_auth_pending_method(const char *peer_info, const char *method)
850{
851 struct gc_arena gc = gc_new();
852
853 char *iv_sso = extract_var_peer_info(peer_info, "IV_SSO=", &gc);
854 if (!iv_sso)
855 {
856 gc_free(&gc);
857 return false;
858 }
859
860 const char *client_method = strtok(iv_sso, ",");
861 bool supported = false;
862
863 while (client_method)
864 {
865 if (0 == strcmp(client_method, method))
866 {
867 supported = true;
868 break;
869 }
870 client_method = strtok(NULL, ",");
871 }
872
873 gc_free(&gc);
874 return supported;
875}
876
885static bool
887 struct tls_session *session)
888{
889 bool ret = true;
890 if (ads->auth_pending_file)
891 {
892 struct buffer_list *lines = buffer_list_file(ads->auth_pending_file, 1024);
893 if (lines && lines->head)
894 {
895 /* Must have at least three lines. further lines are ignored for
896 * forward compatibility */
897 if (!lines->head || !lines->head->next || !lines->head->next->next)
898 {
899 msg(M_WARN, "auth pending control file is not at least "
900 "three lines long.");
901 buffer_list_free(lines);
902 return false;
903 }
904 struct buffer *timeout_buf = &lines->head->buf;
905 struct buffer *iv_buf = &lines->head->next->buf;
906 struct buffer *extra_buf = &lines->head->next->next->buf;
907
908 /* Remove newline chars at the end of the lines */
912
913 long timeout = strtol(BSTR(timeout_buf), NULL, 10);
914 if (timeout == 0)
915 {
916 msg(M_WARN, "could not parse auth pending file timeout");
918 return false;
919 }
920
921 const char *pending_method = BSTR(iv_buf);
923 {
924 char buf[128];
925 snprintf(buf, sizeof(buf),
926 "Authentication failed, required pending auth "
927 "method '%s' not supported",
929 auth_set_client_reason(multi, buf);
930 msg(M_INFO,
931 "Client does not supported auth pending method "
932 "'%s'",
934 ret = false;
935 }
936 else
937 {
939 }
940 }
941
943 }
945 return ret;
946}
947
948
953void
955{
956 if (ads->auth_control_file)
957 {
958 platform_unlink(ads->auth_control_file);
959 free(ads->auth_control_file);
960 ads->auth_control_file = NULL;
961 }
962 if (ads->auth_failed_reason_file)
963 {
964 platform_unlink(ads->auth_failed_reason_file);
965 free(ads->auth_failed_reason_file);
966 ads->auth_failed_reason_file = NULL;
967 }
969}
970
977static bool
979{
980 struct gc_arena gc = gc_new();
981
983 const char *acf = platform_create_temp_file(opt->tmp_dir, "acf", &gc);
984 const char *apf = platform_create_temp_file(opt->tmp_dir, "apf", &gc);
985 const char *afr = platform_create_temp_file(opt->tmp_dir, "afr", &gc);
986
987 if (acf && apf)
988 {
989 ads->auth_control_file = string_alloc(acf, NULL);
990 ads->auth_pending_file = string_alloc(apf, NULL);
991 ads->auth_failed_reason_file = string_alloc(afr, NULL);
992
993 setenv_str(opt->es, "auth_control_file", ads->auth_control_file);
994 setenv_str(opt->es, "auth_pending_file", ads->auth_pending_file);
995 setenv_str(opt->es, "auth_failed_reason_file", ads->auth_failed_reason_file);
996 }
997
998 gc_free(&gc);
999 return (acf && apf);
1000}
1001
1006static char *
1008 struct gc_arena *gc)
1009{
1010 char *ret = NULL;
1011 if (ads->auth_failed_reason_file)
1012 {
1013 struct buffer reason = buffer_read_from_file(ads->auth_failed_reason_file, gc);
1014
1015 if (BLEN(&reason))
1016 {
1017 ret = BSTR(&reason);
1018 }
1019 }
1020 return ret;
1021}
1022
1023
1034static enum auth_deferred_result
1036{
1037 if (ads->auth_control_file)
1038 {
1039 unsigned int ret = ads->auth_control_status;
1040 if (ret == ACF_PENDING && !cached)
1041 {
1042 FILE *fp = fopen(ads->auth_control_file, "r");
1043 if (fp)
1044 {
1045 const int c = fgetc(fp);
1046 if (c == '1')
1047 {
1048 ret = ACF_SUCCEEDED;
1049 }
1050 else if (c == '0')
1051 {
1052 ret = ACF_FAILED;
1053 }
1054 fclose(fp);
1055 ads->auth_control_status = ret;
1056 }
1057 }
1058 return ret;
1059 }
1060 return ACF_DISABLED;
1061}
1062
1070static void
1072{
1073 if (ks->authenticated == KS_AUTH_FALSE)
1074 {
1075 return;
1076 }
1077 else
1078 {
1084#ifdef ENABLE_MANAGEMENT
1086#endif
1087 ASSERT(auth_plugin < 4 && auth_script < 4 && auth_man < 4);
1088
1090 {
1092 return;
1093 }
1095 || auth_man == ACF_PENDING)
1096 {
1097 if (now >= ks->auth_deferred_expire)
1098 {
1099 /* Window to authenticate the key has expired, mark
1100 * the key as unauthenticated */
1102 }
1103 }
1104 else
1105 {
1106 /* all auth states (auth_plugin, auth_script, auth_man)
1107 * are either ACF_DISABLED or ACF_SUCCEDED now, which
1108 * translates to "not checked" or "auth succeeded"
1109 */
1111 }
1112 }
1113}
1114
1115
1122static time_t cache_intervals[] = { 0, 0, 0, 0, 0, 1, 1, 2, 2, 4, 8 };
1123
1128static bool
1130{
1131 unsigned int idx = min_uint(multi->tas_cache_num_updates, SIZE(cache_intervals) - 1);
1133 return multi->tas_cache_last_update + latency >= now;
1134}
1135
1136enum tls_auth_status
1138{
1139 bool deferred = false;
1140
1141 /* at least one valid key has successfully completed authentication */
1142 bool success = false;
1143
1144 /* at least one key is enabled for decryption */
1145 int active = 0;
1146
1147 /* at least one key already failed authentication */
1148 bool failed_auth = false;
1149
1151
1152 for (int i = 0; i < KEY_SCAN_SIZE; ++i)
1153 {
1154 struct key_state *ks = get_key_scan(multi, i);
1155 if (TLS_AUTHENTICATED(multi, ks))
1156 {
1157 active++;
1158 update_key_auth_status(cached, ks);
1159
1160 if (ks->authenticated == KS_AUTH_FALSE)
1161 {
1162 failed_auth = true;
1163 }
1164 else if (ks->authenticated == KS_AUTH_DEFERRED)
1165 {
1166 deferred = true;
1167 }
1168 else if (ks->authenticated == KS_AUTH_TRUE)
1169 {
1170 success = true;
1171 }
1172 }
1173 }
1174
1175 /* we did not rely on a cached result, remember the cache update time */
1176 if (!cached)
1177 {
1178 multi->tas_cache_last_update = now;
1179 multi->tas_cache_num_updates++;
1180 }
1181
1182#if 0
1183 dmsg(D_TLS_ERRORS, "TAS: a=%d s=%d d=%d f=%d", active, success, deferred, failed_auth);
1184#endif
1185 if (failed_auth)
1186 {
1187 struct gc_arena gc = gc_new();
1188 const struct key_state *ks = get_primary_key(multi);
1189 const char *plugin_message =
1191 const char *script_message =
1193
1194 if (plugin_message)
1195 {
1196 auth_set_client_reason(multi, plugin_message);
1197 }
1198 if (script_message)
1199 {
1200 auth_set_client_reason(multi, script_message);
1201 }
1202
1203 /* We have at least one session that failed authentication. There
1204 * might be still another session with valid keys.
1205 * Although our protocol allows keeping the VPN session alive
1206 * with the other session (and we actually did that in earlier
1207 * version, this behaviour is really strange from a user (admin)
1208 * experience */
1209 gc_free(&gc);
1211 }
1212 else if (success)
1213 {
1215 }
1216 else if (active == 0 || deferred)
1217 {
1218 /* We have a deferred authentication and no currently active key
1219 * (first auth, no renegotiation) */
1221 }
1222 else
1223 {
1224 /* at least one key is active but none is fully authenticated (!success)
1225 * and all active are either failed authed or expired deferred auth */
1227 }
1228}
1229
1230#ifdef ENABLE_MANAGEMENT
1231/*
1232 * For deferred auth, this is where the management interface calls (on server)
1233 * to indicate auth failure/success.
1234 */
1235bool
1236tls_authenticate_key(struct tls_multi *multi, const unsigned int mda_key_id, const bool auth,
1237 const char *client_reason)
1238{
1239 bool ret = false;
1240 if (multi)
1241 {
1242 int i;
1243 auth_set_client_reason(multi, client_reason);
1244 for (i = 0; i < KEY_SCAN_SIZE; ++i)
1245 {
1246 struct key_state *ks = get_key_scan(multi, i);
1247 if (ks->mda_key_id == mda_key_id)
1248 {
1249 ks->mda_status = auth ? ACF_SUCCEEDED : ACF_FAILED;
1250 ret = true;
1251 }
1252 }
1253 }
1254 return ret;
1255}
1256#endif /* ifdef ENABLE_MANAGEMENT */
1257
1258
1259/* ****************************************************************************
1260 * Functions to verify username and password
1261 *
1262 * Authenticate a client using username/password.
1263 * Runs on server.
1264 *
1265 * If you want to add new authentication methods,
1266 * this is the place to start.
1267 *************************************************************************** */
1268
1272static void
1274{
1275 struct gc_arena gc = gc_new();
1277 if (msg)
1278 {
1280 }
1281 gc_free(&gc);
1282}
1283/*
1284 * Verify the user name and password using a script
1285 */
1286static int
1288 const struct user_pass *up)
1289{
1290 struct gc_arena gc = gc_new();
1291 struct argv argv = argv_new();
1292 const char *tmp_file = "";
1293 int retval = OPENVPN_PLUGIN_FUNC_ERROR;
1294 struct key_state *ks = &session->key[KS_PRIMARY]; /* primary key */
1295
1296 /* Set environmental variables prior to calling script */
1297 setenv_str(session->opt->es, "script_type", "user-pass-verify");
1298
1299 /* format command line */
1300 argv_parse_cmd(&argv, session->opt->auth_user_pass_verify_script);
1301
1302 if (session->opt->auth_user_pass_verify_script_via_file)
1303 {
1304 struct status_output *so;
1305
1306 tmp_file = platform_create_temp_file(session->opt->tmp_dir, "up", &gc);
1307 if (tmp_file)
1308 {
1309 so = status_open(tmp_file, 0, -1, NULL, STATUS_OUTPUT_WRITE);
1310 status_printf(so, "%s", up->username);
1311 status_printf(so, "%s", up->password);
1312 if (!status_close(so))
1313 {
1314 msg(D_TLS_ERRORS, "TLS Auth Error: could not write username/password to file: %s",
1315 tmp_file);
1316 goto done;
1317 }
1318 /* pass temp file name to script */
1319 argv_printf_cat(&argv, "%s", tmp_file);
1320 }
1321 }
1322 else
1323 {
1324 setenv_str(session->opt->es, "username", up->username);
1325 setenv_str(session->opt->es, "password", up->password);
1326 }
1327
1328 /* pre-create files for deferred auth control */
1330 {
1332 "TLS Auth Error (%s): "
1333 "could not create deferred auth control file",
1334 __func__);
1335 retval = OPENVPN_PLUGIN_FUNC_ERROR;
1336 goto error;
1337 }
1338
1339 /* call command */
1340 int script_ret =
1341 openvpn_run_script(&argv, session->opt->es, S_EXITCODE, "--auth-user-pass-verify");
1342 switch (script_ret)
1343 {
1344 case 0:
1345 retval = OPENVPN_PLUGIN_FUNC_SUCCESS;
1346 break;
1347
1348 case 2:
1349 retval = OPENVPN_PLUGIN_FUNC_DEFERRED;
1350 break;
1351
1352 default:
1354 retval = OPENVPN_PLUGIN_FUNC_ERROR;
1355 break;
1356 }
1357 if (retval == OPENVPN_PLUGIN_FUNC_DEFERRED)
1358 {
1359 /* Check if we the plugin has written the pending auth control
1360 * file and send the pending auth to the client */
1362 {
1363 retval = OPENVPN_PLUGIN_FUNC_ERROR;
1365 }
1366 }
1367 else
1368 {
1369 /* purge auth control filename (and file itself) for non-deferred returns */
1371 }
1372 if (!session->opt->auth_user_pass_verify_script_via_file)
1373 {
1374 setenv_del(session->opt->es, "password");
1375 }
1376
1377done:
1378 if (tmp_file && strlen(tmp_file) > 0)
1379 {
1380 platform_unlink(tmp_file);
1381 }
1382
1383error:
1384 argv_free(&argv);
1385 gc_free(&gc);
1386 return retval;
1387}
1388
1389#ifdef ENABLE_PLUGIN
1390void
1391verify_crresponse_plugin(struct tls_multi *multi, const char *cr_response)
1392{
1393 struct tls_session *session = &multi->session[TM_ACTIVE];
1394 setenv_str(session->opt->es, "crresponse", cr_response);
1395
1396 plugin_call(session->opt->plugins, OPENVPN_PLUGIN_CLIENT_CRRESPONSE, NULL, NULL,
1397 session->opt->es);
1398
1399 setenv_del(session->opt->es, "crresponse");
1400}
1401#endif
1402
1403void
1404verify_crresponse_script(struct tls_multi *multi, const char *cr_response)
1405{
1406 struct tls_session *session = &multi->session[TM_ACTIVE];
1407
1408 if (!session->opt->client_crresponse_script)
1409 {
1410 return;
1411 }
1412 struct argv argv = argv_new();
1413 struct gc_arena gc = gc_new();
1414
1415 setenv_str(session->opt->es, "script_type", "client-crresponse");
1416
1417 /* Since cr response might be sensitive, like a stupid way to query
1418 * a password via 2FA, we pass it via file instead environment */
1419 const char *tmp_file = platform_create_temp_file(session->opt->tmp_dir, "cr", &gc);
1420 static const char *openerrmsg = "TLS CR Response Error: could not write "
1421 "crtext challenge response to file: %s";
1422
1423 if (tmp_file)
1424 {
1425 struct status_output *so = status_open(tmp_file, 0, -1, NULL, STATUS_OUTPUT_WRITE);
1426 status_printf(so, "%s", cr_response);
1427 if (!status_close(so))
1428 {
1429 msg(D_TLS_ERRORS, openerrmsg, tmp_file);
1430 tls_deauthenticate(multi);
1431 goto done;
1432 }
1433 }
1434 else
1435 {
1436 msg(D_TLS_ERRORS, openerrmsg, "creating file failed");
1437 tls_deauthenticate(multi);
1438 goto done;
1439 }
1440
1441 argv_parse_cmd(&argv, session->opt->client_crresponse_script);
1442 argv_printf_cat(&argv, "%s", tmp_file);
1443
1444
1445 if (!openvpn_run_script(&argv, session->opt->es, 0, "--client-crresponse"))
1446 {
1447 tls_deauthenticate(multi);
1448 }
1449done:
1450 argv_free(&argv);
1451 gc_free(&gc);
1452}
1453
1454/*
1455 * Verify the username and password using a plugin
1456 */
1457static int
1459 const struct user_pass *up)
1460{
1461 int retval = OPENVPN_PLUGIN_FUNC_ERROR;
1462 struct key_state *ks = &session->key[KS_PRIMARY]; /* primary key */
1463
1464 /* set password in private env space */
1465 setenv_str(session->opt->es, "password", up->password);
1466
1467 /* generate filename for deferred auth control file */
1469 {
1471 "TLS Auth Error (%s): "
1472 "could not create deferred auth control file",
1473 __func__);
1474 return retval;
1475 }
1476
1477 /* call command */
1478 retval = plugin_call(session->opt->plugins, OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY, NULL, NULL,
1479 session->opt->es);
1480
1481 if (retval == OPENVPN_PLUGIN_FUNC_DEFERRED)
1482 {
1483 /* Check if the plugin has written the pending auth control
1484 * file and send the pending auth to the client */
1486 {
1487 retval = OPENVPN_PLUGIN_FUNC_ERROR;
1488 }
1489 }
1490
1491 if (retval == OPENVPN_PLUGIN_FUNC_ERROR)
1492 {
1494 }
1495
1496 if (retval != OPENVPN_PLUGIN_FUNC_DEFERRED)
1497 {
1498 /* purge auth control filename (and file itself) for non-deferred returns */
1500 }
1501
1502 setenv_del(session->opt->es, "password");
1503
1504 return retval;
1505}
1506
1507
1508#ifdef ENABLE_MANAGEMENT
1509/*
1510 * management deferred internal ssl_verify.c status codes
1511 */
1512#define KMDA_ERROR 0
1513#define KMDA_SUCCESS 1
1514#define KMDA_UNDEF 2
1515#define KMDA_DEF 3
1516
1517static int
1519{
1520 int retval = KMDA_ERROR;
1521 struct key_state *ks = &session->key[KS_PRIMARY]; /* primary key */
1522
1523 /* set username/password in private env space */
1524 setenv_str(session->opt->es, "password", up->password);
1525
1526 if (management)
1527 {
1529 session->opt->es);
1530 }
1531
1532 setenv_del(session->opt->es, "password");
1533
1534 retval = KMDA_SUCCESS;
1535
1536 return retval;
1537}
1538#endif /* ifdef ENABLE_MANAGEMENT */
1539
1540static bool
1542{
1543 /* Is username defined? */
1544 if ((session->opt->ssl_flags & SSLF_AUTH_USER_PASS_OPTIONAL) || strlen(up->username))
1545 {
1546 setenv_str(session->opt->es, "username", up->username);
1547
1548 /* setenv incoming cert common name for script */
1549 setenv_str(session->opt->es, "common_name", session->common_name);
1550
1551 /* setenv client real IP address */
1553
1554 /*
1555 * if we are using auth-gen-token, send also the session id of auth gen token to
1556 * allow the management to figure out if it is a new session or a continued one
1557 */
1558 add_session_token_env(session, multi, up);
1559 return true;
1560 }
1561 else
1562 {
1563 msg(D_TLS_ERRORS, "TLS Auth Error: peer provided a blank username");
1564 return false;
1565 }
1566}
1567
1568bool
1569ssl_verify_username_length(struct tls_session *session, const char *username)
1570{
1571 if ((session->opt->ssl_flags & SSLF_USERNAME_AS_COMMON_NAME)
1572 && strlen(username) > TLS_USERNAME_LEN)
1573 {
1575 "TLS Auth Error: --username-as-common name specified and "
1576 "username is longer than the maximum permitted Common Name "
1577 "length of %d characters",
1579 return false;
1580 }
1581 else
1582 {
1583 return true;
1584 }
1585}
1586
1593void
1594verify_user_pass(struct user_pass *up, struct tls_multi *multi, struct tls_session *session)
1595{
1596 struct key_state *ks = &session->key[KS_PRIMARY]; /* primary key */
1597
1598 ASSERT(up && !up->protected);
1599
1600#ifdef ENABLE_MANAGEMENT
1601 int man_def_auth = KMDA_UNDEF;
1602
1604 {
1605 man_def_auth = KMDA_DEF;
1606 }
1607#endif
1608
1609 /* enforce character class restrictions in username/password */
1611 string_mod(up->password, CC_PRINT, CC_CRLF, '_');
1612
1613 /*
1614 * If auth token succeeds we skip the auth
1615 * methods unless otherwise specified
1616 */
1617 bool skip_auth = false;
1618
1619 /* Replace username early if override-username is in effect but only
1620 * if client is sending the original username */
1621 if (multi->locked_original_username
1622 && strncmp(up->username, multi->locked_original_username, sizeof(up->username)) == 0)
1623 {
1625 "TLS: Replacing client provided username '%s' with "
1626 "username from override-user '%s'",
1627 up->username, multi->locked_username);
1628 strncpy(up->username, multi->locked_username, sizeof(up->username));
1629 }
1630
1631 /*
1632 * If server is configured with --auth-gen-token and the client sends
1633 * something that looks like an authentication token, this
1634 * round will be done internally using the token instead of
1635 * calling any external authentication modules.
1636 */
1637 if (session->opt->auth_token_generate && is_auth_token(up->password))
1638 {
1640
1641 /* If this is the first time we see an auth-token in this multi session,
1642 * save it as initial auth token. This ensures using the
1643 * same session ID and initial timestamp in new tokens */
1644 if (!multi->auth_token_initial)
1645 {
1646 multi->auth_token_initial = strdup(up->password);
1647 }
1648
1649 if (session->opt->auth_token_call_auth)
1650 {
1651 /*
1652 * we do not care about the result here because it is
1653 * the responsibility of the external authentication to
1654 * decide what to do with the result
1655 */
1656 }
1658 {
1659 /*
1660 * We do not want the EXPIRED or EMPTY USER flags here so check
1661 * for equality with AUTH_TOKEN_HMAC_OK
1662 */
1663 msg(M_WARN,
1664 "TLS: Username/auth-token authentication "
1665 "succeeded for username '%s'",
1666 up->username);
1667 skip_auth = true;
1668 }
1669 else
1670 {
1671 wipe_auth_token(multi);
1673 msg(M_WARN,
1674 "TLS: Username/auth-token authentication "
1675 "failed for username '%s'",
1676 up->username);
1677 return;
1678 }
1679 }
1680
1681 int plugin_status = OPENVPN_PLUGIN_FUNC_SUCCESS;
1682 int script_status = OPENVPN_PLUGIN_FUNC_SUCCESS;
1683 /* Set the environment variables used by all auth variants */
1684 if (!set_verify_user_pass_env(up, multi, session))
1685 {
1686 skip_auth = true;
1687 plugin_status = OPENVPN_PLUGIN_FUNC_ERROR;
1688 }
1689
1690 /* call plugin(s) and/or script */
1691 if (!skip_auth)
1692 {
1693#ifdef ENABLE_MANAGEMENT
1694 if (man_def_auth == KMDA_DEF)
1695 {
1696 man_def_auth = verify_user_pass_management(session, up);
1697 }
1698#endif
1699 if (plugin_defined(session->opt->plugins, OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY))
1700 {
1701 plugin_status = verify_user_pass_plugin(session, multi, up);
1702 }
1703
1704 if (session->opt->auth_user_pass_verify_script)
1705 {
1706 script_status = verify_user_pass_script(session, multi, up);
1707 }
1708 }
1709
1710 /* check sizing of username if it will become our common name */
1712 {
1713 plugin_status = OPENVPN_PLUGIN_FUNC_ERROR;
1714 script_status = OPENVPN_PLUGIN_FUNC_ERROR;
1715 }
1716
1717 /* auth succeeded? */
1718 bool plugin_ok = plugin_status == OPENVPN_PLUGIN_FUNC_SUCCESS
1719 || plugin_status == OPENVPN_PLUGIN_FUNC_DEFERRED;
1720
1721 bool script_ok = script_status == OPENVPN_PLUGIN_FUNC_SUCCESS
1722 || script_status == OPENVPN_PLUGIN_FUNC_DEFERRED;
1723
1724 if (script_ok && plugin_ok && tls_lock_username(multi, up->username)
1725#ifdef ENABLE_MANAGEMENT
1726 && man_def_auth != KMDA_ERROR
1727#endif
1728 )
1729 {
1731 if (plugin_status == OPENVPN_PLUGIN_FUNC_DEFERRED
1732 || script_status == OPENVPN_PLUGIN_FUNC_DEFERRED)
1733 {
1735 }
1736#ifdef ENABLE_MANAGEMENT
1737 if (man_def_auth != KMDA_UNDEF)
1738 {
1739 if (skip_auth)
1740 {
1742 }
1743 else
1744 {
1746 }
1747 }
1748#endif
1749 if ((session->opt->ssl_flags & SSLF_USERNAME_AS_COMMON_NAME))
1750 {
1752 }
1753
1754 if ((session->opt->auth_token_generate))
1755 {
1756 /*
1757 * If we accepted a (not expired) token, i.e.
1758 * initial auth via token on new connection, we need
1759 * to store the auth-token in multi->auth_token, so
1760 * the initial timestamp and session id can be extracted from it
1761 */
1764 {
1765 multi->auth_token = strdup(up->password);
1766 }
1767
1768 /*
1769 * Server is configured with --auth-gen-token. Generate or renew
1770 * the token.
1771 */
1772 generate_auth_token(up, multi);
1773 }
1774
1775 msg(D_HANDSHAKE, "TLS: Username/Password authentication %s for username '%s' %s",
1776 (ks->authenticated == KS_AUTH_DEFERRED) ? "deferred" : "succeeded", up->username,
1777 (session->opt->ssl_flags & SSLF_USERNAME_AS_COMMON_NAME) ? "[CN SET]" : "");
1778 }
1779 else
1780 {
1782 msg(D_TLS_ERRORS, "TLS Auth Error: Auth Username/Password verification failed for peer");
1783 }
1784}
1785
1786void
1788{
1789 struct key_state *ks = &session->key[KS_PRIMARY]; /* primary key */
1790
1791 /* While it shouldn't really happen, don't allow the common name to be NULL */
1792 if (!session->common_name)
1793 {
1795 }
1796
1797 /* Don't allow the CN to change once it's been locked */
1798 if (ks->authenticated > KS_AUTH_FALSE && multi->locked_cn)
1799 {
1800 const char *cn = session->common_name;
1801 if (cn && strcmp(cn, multi->locked_cn))
1802 {
1804 "TLS Auth Error: TLS object CN attempted to change from '%s' to '%s' -- tunnel disabled",
1805 multi->locked_cn, cn);
1806
1807 /* change the common name back to its original value and disable the tunnel */
1809 tls_deauthenticate(multi);
1810 }
1811 }
1812
1813 /* Don't allow the cert hashes to change once they have been locked */
1815 {
1816 const struct cert_hash_set *chs = session->cert_hash_set;
1817 if (chs && !cert_hash_compare(chs, multi->locked_cert_hash_set))
1818 {
1820 "TLS Auth Error: TLS object CN=%s client-provided SSL certs unexpectedly changed during mid-session reauth",
1821 session->common_name);
1822
1823 /* disable the tunnel */
1824 tls_deauthenticate(multi);
1825 }
1826 }
1827
1828 /* verify --client-config-dir based authentication */
1829 if (ks->authenticated > KS_AUTH_FALSE && session->opt->client_config_dir_exclusive)
1830 {
1831 struct gc_arena gc = gc_new();
1832
1833 const char *cn = session->common_name;
1834 const char *path = platform_gen_path(session->opt->client_config_dir_exclusive, cn, &gc);
1835 if (!cn || !strcmp(cn, CCD_DEFAULT) || !platform_test_file(path))
1836 {
1838 wipe_auth_token(multi);
1840 "TLS Auth Error: --client-config-dir authentication failed for common name '%s' file='%s'",
1841 session->common_name, path ? path : "UNDEF");
1842 }
1843
1844 gc_free(&gc);
1845 }
1846}
1847
1848void
1850{
1851 struct env_item *item = es->list;
1852 while (item)
1853 {
1854 struct env_item *next = item->next;
1855 if (item->string && 0 == strncmp("X509_", item->string, strlen("X509_")))
1856 {
1857 env_set_del(es, item->string);
1858 }
1859 item = next;
1860 }
1861}
void argv_msg_prefix(const int msglev, const struct argv *a, const char *prefix)
Similar to argv_msg() but prefixes the messages being written with a given string.
Definition argv.c:259
void argv_parse_cmd(struct argv *argres, const char *cmdstr)
Parses a command string, tokenizes it and puts each element into a separate struct argv argument slot...
Definition argv.c:481
void argv_free(struct argv *a)
Frees all memory allocations allocated by the struct argv related functions.
Definition argv.c:101
bool argv_printf(struct argv *argres, const char *format,...)
printf() variant which populates a struct argv.
Definition argv.c:438
bool argv_printf_cat(struct argv *argres, const char *format,...)
printf() inspired argv concatenation.
Definition argv.c:462
struct argv argv_new(void)
Allocates a new struct argv and ensures it is initialised.
Definition argv.c:87
void generate_auth_token(const struct user_pass *up, struct tls_multi *multi)
Generate an auth token based on username and timestamp.
Definition auth_token.c:161
unsigned int verify_auth_token(struct user_pass *up, struct tls_multi *multi, struct tls_session *session)
Verifies the auth token to be in the format that generate_auth_token create and checks if the token i...
Definition auth_token.c:291
void add_session_token_env(struct tls_session *session, struct tls_multi *multi, const struct user_pass *up)
Put the session id, and auth token status into the environment if auth-token is enabled.
Definition auth_token.c:38
void wipe_auth_token(struct tls_multi *multi)
Wipes the authentication token out of the memory, frees and cleans up related buffers and flags.
Definition auth_token.c:395
static bool is_auth_token(const char *password)
Return if the password string has the format of a password.
Definition auth_token.h:121
bool buf_printf(struct buffer *buf, const char *format,...)
Definition buffer.c:241
void string_replace_leading(char *str, const char match, const char replace)
Definition buffer.c:1107
struct buffer_list * buffer_list_file(const char *fn, int max_line_len)
Definition buffer.c:1325
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:483
void buffer_list_free(struct buffer_list *ol)
Frees a buffer list and all the buffers in it.
Definition buffer.c:1158
struct buffer alloc_buf_gc(size_t size, struct gc_arena *gc)
Definition buffer.c:89
bool string_mod(char *str, const unsigned int inclusive, const unsigned int exclusive, const char replace)
Modifies a string in place by replacing certain classes of characters of it with a specified characte...
Definition buffer.c:1041
struct buffer buffer_read_from_file(const char *filename, struct gc_arena *gc)
buffer_read_from_file - copy the content of a file into a buffer
Definition buffer.c:1348
char * string_alloc(const char *str, struct gc_arena *gc)
Definition buffer.c:649
void buf_chomp(struct buffer *buf)
Definition buffer.c:554
#define ALLOC_OBJ(dptr, type)
Definition buffer.h:1037
#define BSTR(buf)
Definition buffer.h:128
#define BPTR(buf)
Definition buffer.h:123
#define CC_CRLF
carriage return or newline
Definition buffer.h:904
#define BLEN(buf)
Definition buffer.h:126
static void gc_free(struct gc_arena *a)
Definition buffer.h:1015
#define CC_PRINT
printable (>= 32, != 127)
Definition buffer.h:875
#define ALLOC_OBJ_CLEAR(dptr, type)
Definition buffer.h:1042
static struct gc_arena gc_new(void)
Definition buffer.h:1007
#define CCD_DEFAULT
Definition common.h:61
int memcmp_constant_time(const void *a, const void *b, size_t size)
As memcmp(), but constant-time.
@ MD_SHA256
@ MD_SHA1
void setenv_str(struct env_set *es, const char *name, const char *value)
Definition env_set.c:307
bool env_set_del(struct env_set *es, const char *str)
Definition env_set.c:183
void setenv_del(struct env_set *es, const char *name)
Definition env_set.c:352
#define D_HANDSHAKE
Definition errlevel.h:71
#define D_MULTI_LOW
Definition errlevel.h:85
#define D_TLS_ERRORS
Definition errlevel.h:58
#define M_INFO
Definition errlevel.h:54
#define D_TLS_DEBUG
Definition errlevel.h:164
#define KS_SIZE
Size of the tls_session.key array.
Definition ssl_common.h:469
#define KS_PRIMARY
Primary key state index.
Definition ssl_common.h:465
#define TM_SIZE
Size of the tls_multi.session \ array.
Definition ssl_common.h:550
#define TM_ACTIVE
Active tls_session.
Definition ssl_common.h:545
#define TLS_AUTHENTICATED(multi, ks)
Check whether the ks key_state has finished the key exchange part of the OpenVPN hand shake.
Definition ssl_verify.h:113
static unsigned int min_uint(unsigned int x, unsigned int y)
Definition integer.h:66
static int max_int(int x, int y)
Definition integer.h:92
static SERVICE_STATUS status
Definition interactive.c:51
void management_notify_client_needing_auth(struct management *management, const unsigned int mda_key_id, struct man_def_auth_context *mdac, const struct env_set *es)
Definition manage.c:2963
static bool management_enable_def_auth(const struct management *man)
Definition manage.h:438
#define SIZE(x)
Definition basic.h:29
#define dmsg(flags,...)
Definition error.h:170
#define msg(flags,...)
Definition error.h:150
#define ASSERT(x)
Definition error.h:217
#define M_WARN
Definition error.h:90
#define MAX_PARMS
Definition options.h:51
time_t now
Definition otime.c:33
bool platform_test_file(const char *filename)
Return true if filename can be opened for read.
Definition platform.c:659
const char * platform_create_temp_file(const char *directory, const char *prefix, struct gc_arena *gc)
Create a temporary file in directory, returns the filename of the created file.
Definition platform.c:544
const char * platform_gen_path(const char *directory, const char *filename, struct gc_arena *gc)
Put a directory and filename together.
Definition platform.c:595
bool platform_unlink(const char *filename)
Definition platform.c:491
int platform_open(const char *path, int flags, int mode)
Definition platform.c:517
int plugin_call_ssl(const struct plugin_list *pl, const int type, const struct argv *av, struct plugin_return *pr, struct env_set *es, int certdepth, openvpn_x509_cert_t *current_cert)
Definition plugin.c:782
bool plugin_defined(const struct plugin_list *pl, const int type)
Definition plugin.c:904
static int plugin_call(const struct plugin_list *pl, const int type, const struct argv *av, struct plugin_return *pr, struct env_set *es)
Definition plugin.h:195
bool send_auth_pending_messages(struct tls_multi *tls_multi, struct tls_session *session, const char *extra, unsigned int timeout)
Sends the auth pending control messages to a client.
Definition push.c:434
#define S_EXITCODE
Instead of returning 1/0 for success/fail, return exit code when between 0 and 255 and -1 otherwise.
Definition run_command.h:53
static int openvpn_run_script(const struct argv *a, const struct env_set *es, const unsigned int flags, const char *hook)
Will run a script and return the exit code of the script if between 0 and 255, -1 otherwise.
Definition run_command.h:89
void setenv_link_socket_actual(struct env_set *es, const char *name_prefix, const struct link_socket_actual *act, const unsigned int flags)
#define SA_IP_PORT
Definition socket_util.h:99
void tls_clear_error(void)
Clear the underlying SSL library's error state.
#define AUTH_TOKEN_HMAC_OK
Auth-token sent from client has valid hmac.
Definition ssl_common.h:687
#define KEY_SCAN_SIZE
Definition ssl_common.h:567
auth_deferred_result
Definition ssl_common.h:175
@ ACF_PENDING
deferred auth still pending
Definition ssl_common.h:176
@ ACF_SUCCEEDED
deferred auth has suceeded
Definition ssl_common.h:177
@ ACF_FAILED
deferred auth has failed
Definition ssl_common.h:179
@ ACF_DISABLED
deferred auth is not used
Definition ssl_common.h:178
#define AUTH_TOKEN_EXPIRED
Auth-token sent from client has expired.
Definition ssl_common.h:689
static struct key_state * get_key_scan(struct tls_multi *multi, int index)
gets an item of key_state objects in the order they should be scanned by data channel modules.
Definition ssl_common.h:733
#define SSLF_AUTH_USER_PASS_OPTIONAL
Definition ssl_common.h:427
@ KS_AUTH_TRUE
Key state is authenticated.
Definition ssl_common.h:157
@ KS_AUTH_FALSE
Key state is not authenticated
Definition ssl_common.h:154
@ KS_AUTH_DEFERRED
Key state authentication is being deferred, by async auth.
Definition ssl_common.h:155
#define SSLF_CRL_VERIFY_DIR
Definition ssl_common.h:429
static const struct key_state * get_primary_key(const struct tls_multi *multi)
gets an item of key_state objects in the order they should be scanned by data channel modules.
Definition ssl_common.h:756
#define SSLF_USERNAME_AS_COMMON_NAME
Definition ssl_common.h:426
char * extract_var_peer_info(const char *peer_info, const char *var, struct gc_arena *gc)
Extracts a variable from peer info, the returned string will be allocated using the supplied gc_arena...
Definition ssl_util.c:31
SSL utility functions.
static result_t verify_cert_call_command(const char *verify_command, struct env_set *es, int cert_depth, char *subject)
Definition ssl_verify.c:503
static void verify_cert_set_env(struct env_set *es, openvpn_x509_cert_t *peer_cert, int cert_depth, const char *subject, const struct x509_track *x509_track)
Definition ssl_verify.c:397
void key_state_rm_auth_control_files(struct auth_deferred_status *ads)
Removes auth_pending and auth_control files from file system and key_state structure.
Definition ssl_verify.c:954
static bool key_state_gen_auth_control_files(struct auth_deferred_status *ads, const struct tls_options *opt)
Generates and creates the control files used for deferred authentification in the temporary directory...
Definition ssl_verify.c:978
static struct cert_hash_set * cert_hash_copy(const struct cert_hash_set *chs)
Definition ssl_verify.c:266
static void key_state_rm_auth_pending_file(struct auth_deferred_status *ads)
Removes auth_pending file from the file system and key_state structure.
Definition ssl_verify.c:835
#define KMDA_SUCCESS
bool ssl_verify_username_length(struct tls_session *session, const char *username)
Checks if the username length is valid to use.
static result_t verify_check_crl_dir(const char *crl_dir, openvpn_x509_cert_t *cert, const char *subject, int cert_depth)
Definition ssl_verify.c:535
#define KMDA_DEF
bool tls_authenticate_key(struct tls_multi *multi, const unsigned int mda_key_id, const bool auth, const char *client_reason)
static void verify_cert_cert_delete_env(struct env_set *es, const char *pem_export_fname)
Definition ssl_verify.c:458
static void tls_deauthenticate(struct tls_multi *multi)
Definition ssl_verify.c:69
void verify_crresponse_plugin(struct tls_multi *multi, const char *cr_response)
Call the plugin OPENVPN_PLUGIN_CLIENT_CRRESPONSE.
bool cert_hash_compare(const struct cert_hash_set *chs1, const struct cert_hash_set *chs2)
Compares certificates hashes, returns true if hashes are equal.
Definition ssl_verify.c:229
void tls_x509_clear_env(struct env_set *es)
Remove any X509_ env variables from env_set es.
static void update_key_auth_status(bool cached, struct key_state *ks)
This method takes a key_state and if updates the state of the key if it is deferred.
void tls_lock_cert_hash_set(struct tls_multi *multi)
Locks the certificate hash set used in the given tunnel.
Definition ssl_verify.c:286
static result_t verify_peer_cert(const struct tls_options *opt, openvpn_x509_cert_t *peer_cert, const char *subject, const char *common_name)
Definition ssl_verify.c:323
result_t verify_cert(struct tls_session *session, openvpn_x509_cert_t *cert, int cert_depth)
Definition ssl_verify.c:577
void tls_lock_common_name(struct tls_multi *multi)
Locks the common name field for the given tunnel.
Definition ssl_verify.c:132
static enum auth_deferred_result man_def_auth_test(const struct key_state *ks)
Definition ssl_verify.c:817
#define KMDA_UNDEF
void verify_final_auth_checks(struct tls_multi *multi, struct tls_session *session)
Perform final authentication checks, including locking of the cn, the allowed certificate hashes,...
static bool tls_lock_username(struct tls_multi *multi, const char *username)
Definition ssl_verify.c:145
static int verify_user_pass_plugin(struct tls_session *session, struct tls_multi *multi, const struct user_pass *up)
static bool key_state_check_auth_pending_file(struct auth_deferred_status *ads, struct tls_multi *multi, struct tls_session *session)
Checks if the deferred state should also send auth pending request to the client.
Definition ssl_verify.c:886
const char * tls_username(const struct tls_multi *multi, const bool null)
Returns the username field for the given tunnel.
Definition ssl_verify.c:172
void set_common_name(struct tls_session *session, const char *common_name)
Sets the common name field for the given tunnel.
Definition ssl_verify.c:85
#define KMDA_ERROR
static char * key_state_check_auth_failed_message_file(const struct auth_deferred_status *ads, struct gc_arena *gc)
Checks if the auth failed reason file has any content and if yes it will be returned as string alloca...
void auth_set_client_reason(struct tls_multi *multi, const char *client_reason)
Sets the reason why authentication of a client failed.
Definition ssl_verify.c:803
static result_t verify_cert_call_plugin(const struct plugin_list *plugins, struct env_set *es, int cert_depth, openvpn_x509_cert_t *cert, char *subject)
Definition ssl_verify.c:471
enum tls_auth_status tls_authentication_status(struct tls_multi *multi)
Return current session authentication state of the tls_multi structure This will return TLS_AUTHENTIC...
void verify_user_pass(struct user_pass *up, struct tls_multi *multi, struct tls_session *session)
Main username/password verification entry point.
static bool tls_authentication_status_use_cache(struct tls_multi *multi)
uses cache_intervals times to determine if we should update the cache.
static void check_for_client_reason(struct tls_multi *multi, struct auth_deferred_status *status)
Check if the script/plugin left a message in the auth failed message file and relay it to the user.
static const char * print_nsCertType(int type)
Definition ssl_verify.c:299
void verify_crresponse_script(struct tls_multi *multi, const char *cr_response)
Runs the –client-crresponse script if one is defined.
static time_t cache_intervals[]
The minimum times to have passed to update the cache.
static int verify_user_pass_script(struct tls_session *session, struct tls_multi *multi, const struct user_pass *up)
static enum auth_deferred_result key_state_test_auth_control_file(struct auth_deferred_status *ads, bool cached)
Checks the auth control status from a file.
static void string_mod_remap_name(char *str)
Definition ssl_verify.c:51
void cert_hash_remember(struct tls_session *session, const int error_depth, const struct buffer *cert_hash)
Definition ssl_verify.c:194
static void setenv_untrusted(struct tls_session *session)
Definition ssl_verify.c:60
const char * tls_common_name(const struct tls_multi *multi, const bool null)
Returns the common name field for the given tunnel.
Definition ssl_verify.c:107
static int verify_user_pass_management(struct tls_session *session, const struct user_pass *up)
static bool verify_cert_cert_export_env(struct env_set *es, openvpn_x509_cert_t *peer_cert, const char *pem_export_fname)
Exports the certificate in peer_cert into the environment and adds the filname.
Definition ssl_verify.c:448
void cert_hash_free(struct cert_hash_set *chs)
Frees the given set of certificate hashes.
Definition ssl_verify.c:215
static bool check_auth_pending_method(const char *peer_info, const char *method)
Check peer_info if the client supports the requested pending auth method.
Definition ssl_verify.c:849
static bool set_verify_user_pass_env(struct user_pass *up, struct tls_multi *multi, struct tls_session *session)
Control Channel Verification Module.
tls_auth_status
Definition ssl_verify.h:74
@ TLS_AUTHENTICATION_DEFERRED
Definition ssl_verify.h:77
@ TLS_AUTHENTICATION_SUCCEEDED
Definition ssl_verify.h:75
@ TLS_AUTHENTICATION_FAILED
Definition ssl_verify.h:76
#define VERIFY_X509_SUBJECT_DN
Definition ssl_verify.h:69
#define VERIFY_X509_SUBJECT_RDN
Definition ssl_verify.h:70
#define NS_CERT_CHECK_CLIENT
Do not perform Netscape certificate type verification.
Definition ssl_verify.h:254
#define VERIFY_X509_NONE
Definition ssl_verify.h:68
#define TLS_USERNAME_LEN
Maximum length of common name.
Definition ssl_verify.h:54
#define VERIFY_X509_SUBJECT_RDN_PREFIX
Definition ssl_verify.h:71
#define MAX_CERT_DEPTH
Maximum certificate depth we will allow.
Definition ssl_verify.h:51
#define NS_CERT_CHECK_NONE
Do not perform Netscape certificate type verification.
Definition ssl_verify.h:250
#define NS_CERT_CHECK_SERVER
Do not perform Netscape certificate type verification.
Definition ssl_verify.h:252
Control Channel Verification Module library-specific backend interface.
struct buffer x509_get_sha256_fingerprint(openvpn_x509_cert_t *cert, struct gc_arena *gc)
Retrieve the certificate's SHA256 fingerprint.
void x509_setenv_track(const struct x509_track *xt, struct env_set *es, const int depth, openvpn_x509_cert_t *x509)
void x509_setenv(struct env_set *es, int cert_depth, openvpn_x509_cert_t *cert)
bool tls_verify_crl_missing(const struct tls_options *opt)
Return true iff a CRL is configured, but is not loaded.
result_t backend_x509_write_pem(openvpn_x509_cert_t *cert, const char *filename)
result_t x509_verify_ns_cert_type(openvpn_x509_cert_t *cert, const int usage)
result_t backend_x509_get_username(char *common_name, int cn_len, char *x509_username_field, openvpn_x509_cert_t *peer_cert)
char * backend_x509_get_serial_hex(openvpn_x509_cert_t *cert, struct gc_arena *gc)
result_t x509_verify_cert_ku(openvpn_x509_cert_t *x509, const unsigned *const expected_ku, int expected_len)
struct buffer x509_get_sha1_fingerprint(openvpn_x509_cert_t *cert, struct gc_arena *gc)
Retrieve the certificate's SHA1 fingerprint.
char * x509_get_subject(openvpn_x509_cert_t *cert, struct gc_arena *gc)
Definition test_pkcs11.c:68
char * backend_x509_get_serial(openvpn_x509_cert_t *cert, struct gc_arena *gc)
result_t
Result of verification function.
@ FAILURE
@ SUCCESS
result_t x509_verify_cert_eku(openvpn_x509_cert_t *x509, const char *const expected_oid)
mbedtls_x509_crt openvpn_x509_cert_t
Control Channel Verification Module OpenSSL backend.
void status_printf(struct status_output *so, const char *format,...)
Definition status.c:213
struct status_output * status_open(const char *filename, const int refresh_freq, const int msglevel, const struct virtual_output *vout, const unsigned int flags)
Definition status.c:60
bool status_close(struct status_output *so)
Definition status.c:179
#define STATUS_OUTPUT_WRITE
Definition status.h:51
Definition argv.h:35
char * auth_failed_reason_file
Definition ssl_common.h:168
struct buffer_entry * next
Definition buffer.h:1099
struct buffer_entry * head
Definition buffer.h:1104
Wrapper structure for dynamically allocated memory.
Definition buffer.h:60
int capacity
Size in bytes of memory allocated by malloc().
Definition buffer.h:61
int len
Length in bytes of the actual content within the allocated memory.
Definition buffer.h:65
Structure containing the hashes for a full certificate chain.
Definition ssl_verify.h:64
struct cert_hash * ch[MAX_CERT_DEPTH]
Array of certificate hashes.
Definition ssl_verify.h:65
Structure containing the hash for a single certificate.
Definition ssl_verify.h:58
unsigned char sha256_hash[256/8]
Definition ssl_verify.h:59
char * string
Definition env_set.h:38
struct env_item * next
Definition env_set.h:39
struct env_item * list
Definition env_set.h:45
Garbage collection arena used to keep track of dynamically allocated memory.
Definition buffer.h:116
Security parameter state of one TLS and data channel key session.
Definition ssl_common.h:208
unsigned int auth_token_state_flags
The state of the auth-token sent from the client.
Definition ssl_common.h:211
struct auth_deferred_status plugin_auth
Definition ssl_common.h:268
unsigned int mda_key_id
Definition ssl_common.h:263
struct auth_deferred_status script_auth
Definition ssl_common.h:269
enum auth_deferred_result mda_status
Definition ssl_common.h:264
enum ks_auth_state authenticated
Definition ssl_common.h:259
time_t auth_deferred_expire
Definition ssl_common.h:260
Security parameter state for a single VPN tunnel.
Definition ssl_common.h:612
char * auth_token_initial
The first auth-token we sent to a client.
Definition ssl_common.h:684
char * peer_info
A multi-line string of general-purpose info received from peer over control channel.
Definition ssl_common.h:673
char * locked_username
The locked username is the username we assume the client is using.
Definition ssl_common.h:650
unsigned int tas_cache_num_updates
The number of times we updated the cache.
Definition ssl_common.h:664
struct tls_session session[TM_SIZE]
Array of tls_session objects representing control channel sessions with the remote peer.
Definition ssl_common.h:712
struct cert_hash_set * locked_cert_hash_set
Definition ssl_common.h:656
time_t tas_cache_last_update
Time of last when we updated the cached state of tls_authentication_status deferred files.
Definition ssl_common.h:661
char * locked_cn
Our locked common name, username, and cert hashes (cannot change during the life of this tls_multi ob...
Definition ssl_common.h:645
char * client_reason
An error message to send to client on AUTH_FAILED.
Definition ssl_common.h:667
char * auth_token
If server sends a generated auth-token, this is the token to use for future user/pass authentications...
Definition ssl_common.h:679
char * locked_original_username
The username that client initially used before being overridden by –override-user.
Definition ssl_common.h:654
struct env_set * es
Definition ssl_common.h:414
unsigned remote_cert_ku[MAX_PARMS]
Definition ssl_common.h:357
const char * tmp_dir
Definition ssl_common.h:396
int verify_hash_depth
Definition ssl_common.h:360
const struct plugin_list * plugins
Definition ssl_common.h:416
const char * export_peer_cert_dir
Definition ssl_common.h:397
const char * verify_command
Definition ssl_common.h:351
struct verify_hash_list * verify_hash
Definition ssl_common.h:359
char * x509_username_field[2]
Definition ssl_common.h:366
int verify_x509_type
Definition ssl_common.h:352
const char * verify_x509_name
Definition ssl_common.h:353
const struct x509_track * x509_track
Definition ssl_common.h:441
unsigned int ssl_flags
Definition ssl_common.h:435
hash_algo_type verify_hash_algo
Definition ssl_common.h:362
const char * crl_file
Definition ssl_common.h:354
const char * remote_cert_eku
Definition ssl_common.h:358
Security parameter state of a single session within a VPN tunnel.
Definition ssl_common.h:490
struct key_state key[KS_SIZE]
Definition ssl_common.h:525
struct cert_hash_set * cert_hash_set
Definition ssl_common.h:518
char * common_name
Definition ssl_common.h:516
bool protected
Definition misc.h:58
char password[USER_PASS_LEN]
Definition misc.h:68
char username[USER_PASS_LEN]
Definition misc.h:67
struct verify_hash_list * next
Definition options.h:247
uint8_t hash[SHA256_DIGEST_LENGTH]
Definition options.h:246
#define PATH_SEPARATOR
Definition syshead.h:427
struct env_set * es
static int cleanup(void **state)
struct gc_arena gc
Definition test_ssl.c:154