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-2010 OpenVPN Technologies, Inc. <sales@openvpn.net> 9 * Copyright (C) 2010 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 21 * along with this program (see the file COPYING included with this 22 * distribution); if not, write to the Free Software Foundation, Inc., 23 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 24 */ 25 26/** 27 * @file Control Channel Verification Module 28 */ 29 30#ifdef HAVE_CONFIG_H 31#include "config.h" 32#elif defined(_MSC_VER) 33#include "config-msvc.h" 34#endif 35 36#include "syshead.h" 37 38#if defined(ENABLE_CRYPTO) && defined(ENABLE_SSL) 39 40#include "misc.h" 41#include "manage.h" 42#include "ssl_verify.h" 43#include "ssl_verify_backend.h" 44 45#ifdef ENABLE_CRYPTO_OPENSSL 46#include "ssl_verify_openssl.h" 47#endif 48 49/** Maximum length of common name */ 50#define TLS_USERNAME_LEN 64 51 52/** Legal characters in an X509 name with --compat-names */ 53#define X509_NAME_CHAR_CLASS (CC_ALNUM|CC_UNDERBAR|CC_DASH|CC_DOT|CC_AT|CC_SLASH|CC_COLON|CC_EQUAL) 54 55/** Legal characters in a common name with --compat-names */ 56#define COMMON_NAME_CHAR_CLASS (CC_ALNUM|CC_UNDERBAR|CC_DASH|CC_DOT|CC_AT|CC_SLASH) 57 58static void 59string_mod_remap_name (char *str, const unsigned int restrictive_flags) 60{ 61 if (compat_flag (COMPAT_FLAG_QUERY | COMPAT_NAMES) 62 && !compat_flag (COMPAT_FLAG_QUERY | COMPAT_NO_NAME_REMAPPING)) 63 string_mod (str, restrictive_flags, 0, '_'); 64 else 65 string_mod (str, CC_PRINT, CC_CRLF, '_'); 66} 67 68/* 69 * Export the untrusted IP address and port to the environment 70 */ 71static void 72setenv_untrusted (struct tls_session *session) 73{ 74 setenv_link_socket_actual (session->opt->es, "untrusted", &session->untrusted_addr, SA_IP_PORT); 75} 76 77/* 78 * Remove authenticated state from all sessions in the given tunnel 79 */ 80static void 81tls_deauthenticate (struct tls_multi *multi) 82{ 83 if (multi) 84 { 85 int i, j; 86 for (i = 0; i < TM_SIZE; ++i) 87 for (j = 0; j < KS_SIZE; ++j) 88 multi->session[i].key[j].authenticated = false; 89 } 90} 91 92/* 93 * Set the given session's common_name 94 */ 95static void 96set_common_name (struct tls_session *session, const char *common_name) 97{ 98 if (session->common_name) 99 { 100 free (session->common_name); 101 session->common_name = NULL; 102#ifdef ENABLE_PF 103 session->common_name_hashval = 0; 104#endif 105 } 106 if (common_name) 107 { 108 /* FIXME: Last alloc will never be freed */ 109 session->common_name = string_alloc (common_name, NULL); 110#ifdef ENABLE_PF 111 { 112 const uint32_t len = (uint32_t) strlen (common_name); 113 if (len) 114 session->common_name_hashval = hash_func ((const uint8_t*)common_name, len+1, 0); 115 else 116 session->common_name_hashval = 0; 117 } 118#endif 119 } 120} 121 122/* 123 * Retrieve the common name for the given tunnel's active session. If the 124 * common name is NULL or empty, return NULL if null is true, or "UNDEF" if 125 * null is false. 126 */ 127const char * 128tls_common_name (const struct tls_multi *multi, const bool null) 129{ 130 const char *ret = NULL; 131 if (multi) 132 ret = multi->session[TM_ACTIVE].common_name; 133 if (ret && strlen (ret)) 134 return ret; 135 else if (null) 136 return NULL; 137 else 138 return "UNDEF"; 139} 140 141/* 142 * Lock the common name for the given tunnel. 143 */ 144void 145tls_lock_common_name (struct tls_multi *multi) 146{ 147 const char *cn = multi->session[TM_ACTIVE].common_name; 148 if (cn && !multi->locked_cn) 149 multi->locked_cn = string_alloc (cn, NULL); 150} 151 152/* 153 * Lock the username for the given tunnel 154 */ 155static bool 156tls_lock_username (struct tls_multi *multi, const char *username) 157{ 158 if (multi->locked_username) 159 { 160 if (!username || strcmp (username, multi->locked_username)) 161 { 162 msg (D_TLS_ERRORS, "TLS Auth Error: username attempted to change from '%s' to '%s' -- tunnel disabled", 163 multi->locked_username, 164 np(username)); 165 166 /* disable the tunnel */ 167 tls_deauthenticate (multi); 168 return false; 169 } 170 } 171 else 172 { 173 if (username) 174 multi->locked_username = string_alloc (username, NULL); 175 } 176 return true; 177} 178 179const char * 180tls_username (const struct tls_multi *multi, const bool null) 181{ 182 const char *ret = NULL; 183 if (multi) 184 ret = multi->locked_username; 185 if (ret && strlen (ret)) 186 return ret; 187 else if (null) 188 return NULL; 189 else 190 return "UNDEF"; 191} 192 193void 194cert_hash_remember (struct tls_session *session, const int error_depth, const unsigned char *sha1_hash) 195{ 196 if (error_depth >= 0 && error_depth < MAX_CERT_DEPTH) 197 { 198 if (!session->cert_hash_set) 199 ALLOC_OBJ_CLEAR (session->cert_hash_set, struct cert_hash_set); 200 if (!session->cert_hash_set->ch[error_depth]) 201 ALLOC_OBJ (session->cert_hash_set->ch[error_depth], struct cert_hash); 202 { 203 struct cert_hash *ch = session->cert_hash_set->ch[error_depth]; 204 memcpy (ch->sha1_hash, sha1_hash, SHA_DIGEST_LENGTH); 205 } 206 } 207} 208 209#if 0 210static void 211cert_hash_print (const struct cert_hash_set *chs, int msglevel) 212{ 213 struct gc_arena gc = gc_new (); 214 msg (msglevel, "CERT_HASH"); 215 if (chs) 216 { 217 int i; 218 for (i = 0; i < MAX_CERT_DEPTH; ++i) 219 { 220 const struct cert_hash *ch = chs->ch[i]; 221 if (ch) 222 msg (msglevel, "%d:%s", i, format_hex(ch->sha1_hash, SHA_DIGEST_LENGTH, 0, &gc)); 223 } 224 } 225 gc_free (&gc); 226} 227#endif 228 229void 230cert_hash_free (struct cert_hash_set *chs) 231{ 232 if (chs) 233 { 234 int i; 235 for (i = 0; i < MAX_CERT_DEPTH; ++i) 236 free (chs->ch[i]); 237 free (chs); 238 } 239} 240 241static bool 242cert_hash_compare (const struct cert_hash_set *chs1, const struct cert_hash_set *chs2) 243{ 244 if (chs1 && chs2) 245 { 246 int i; 247 for (i = 0; i < MAX_CERT_DEPTH; ++i) 248 { 249 const struct cert_hash *ch1 = chs1->ch[i]; 250 const struct cert_hash *ch2 = chs2->ch[i]; 251 252 if (!ch1 && !ch2) 253 continue; 254 else if (ch1 && ch2 && !memcmp (ch1->sha1_hash, ch2->sha1_hash, SHA_DIGEST_LENGTH)) 255 continue; 256 else 257 return false; 258 } 259 return true; 260 } 261 else if (!chs1 && !chs2) 262 return true; 263 else 264 return false; 265} 266 267static struct cert_hash_set * 268cert_hash_copy (const struct cert_hash_set *chs) 269{ 270 struct cert_hash_set *dest = NULL; 271 if (chs) 272 { 273 int i; 274 ALLOC_OBJ_CLEAR (dest, struct cert_hash_set); 275 for (i = 0; i < MAX_CERT_DEPTH; ++i) 276 { 277 const struct cert_hash *ch = chs->ch[i]; 278 if (ch) 279 { 280 ALLOC_OBJ (dest->ch[i], struct cert_hash); 281 memcpy (dest->ch[i]->sha1_hash, ch->sha1_hash, SHA_DIGEST_LENGTH); 282 } 283 } 284 } 285 return dest; 286} 287void 288tls_lock_cert_hash_set (struct tls_multi *multi) 289{ 290 const struct cert_hash_set *chs = multi->session[TM_ACTIVE].cert_hash_set; 291 if (chs && !multi->locked_cert_hash_set) 292 multi->locked_cert_hash_set = cert_hash_copy (chs); 293} 294 295/* 296 * Returns the string associated with the given certificate type. 297 */ 298static const char * 299print_nsCertType (int type) 300{ 301 switch (type) 302 { 303 case NS_CERT_CHECK_SERVER: 304 return "SERVER"; 305 case NS_CERT_CHECK_CLIENT: 306 return "CLIENT"; 307 default: 308 return "?"; 309 } 310} 311 312/* 313 * Verify the peer's certificate fields. 314 * 315 * @param opt the tls options to verify against 316 * @param peer_cert the peer's certificate 317 * @param subject the peer's extracted subject name 318 * @param subject the peer's extracted common name 319 */ 320static result_t 321verify_peer_cert(const struct tls_options *opt, openvpn_x509_cert_t *peer_cert, 322 const char *subject, const char *common_name) 323{ 324 /* verify certificate nsCertType */ 325 if (opt->ns_cert_type != NS_CERT_CHECK_NONE) 326 { 327 if (SUCCESS == x509_verify_ns_cert_type (peer_cert, opt->ns_cert_type)) 328 { 329 msg (D_HANDSHAKE, "VERIFY OK: nsCertType=%s", 330 print_nsCertType (opt->ns_cert_type)); 331 } 332 else 333 { 334 msg (D_HANDSHAKE, "VERIFY nsCertType ERROR: %s, require nsCertType=%s", 335 subject, print_nsCertType (opt->ns_cert_type)); 336 return FAILURE; /* Reject connection */ 337 } 338 } 339 340#if OPENSSL_VERSION_NUMBER >= 0x00907000L || ENABLE_CRYPTO_POLARSSL 341 342 /* verify certificate ku */ 343 if (opt->remote_cert_ku[0] != 0) 344 { 345 if (SUCCESS == x509_verify_cert_ku (peer_cert, opt->remote_cert_ku, MAX_PARMS)) 346 { 347 msg (D_HANDSHAKE, "VERIFY KU OK"); 348 } 349 else 350 { 351 msg (D_HANDSHAKE, "VERIFY KU ERROR"); 352 return FAILURE; /* Reject connection */ 353 } 354 } 355 356 /* verify certificate eku */ 357 if (opt->remote_cert_eku != NULL) 358 { 359 if (SUCCESS == x509_verify_cert_eku (peer_cert, opt->remote_cert_eku)) 360 { 361 msg (D_HANDSHAKE, "VERIFY EKU OK"); 362 } 363 else 364 { 365 msg (D_HANDSHAKE, "VERIFY EKU ERROR"); 366 return FAILURE; /* Reject connection */ 367 } 368 } 369 370#endif /* OPENSSL_VERSION_NUMBER */ 371 372 /* verify X509 name or username against --verify-x509-[user]name */ 373 if (opt->verify_x509_type != VERIFY_X509_NONE) 374 { 375 if ( (opt->verify_x509_type == VERIFY_X509_SUBJECT_DN 376 && strcmp (opt->verify_x509_name, subject) == 0) 377 || (opt->verify_x509_type == VERIFY_X509_SUBJECT_RDN 378 && strcmp (opt->verify_x509_name, common_name) == 0) 379 || (opt->verify_x509_type == VERIFY_X509_SUBJECT_RDN_PREFIX 380 && strncmp (opt->verify_x509_name, common_name, 381 strlen (opt->verify_x509_name)) == 0) ) 382 msg (D_HANDSHAKE, "VERIFY X509NAME OK: %s", subject); 383 else 384 { 385 msg (D_HANDSHAKE, "VERIFY X509NAME ERROR: %s, must be %s", 386 subject, opt->verify_x509_name); 387 return FAILURE; /* Reject connection */ 388 } 389 } 390 391 return SUCCESS; 392} 393 394/* 395 * Export the subject, common_name, and raw certificate fields to the 396 * environment for later verification by scripts and plugins. 397 */ 398static void 399verify_cert_set_env(struct env_set *es, openvpn_x509_cert_t *peer_cert, int cert_depth, 400 const char *subject, const char *common_name 401#ifdef ENABLE_X509_TRACK 402 , const struct x509_track *x509_track 403#endif 404 ) 405{ 406 char envname[64]; 407 char *serial = NULL; 408 struct gc_arena gc = gc_new (); 409 410 /* Save X509 fields in environment */ 411#ifdef ENABLE_X509_TRACK 412 if (x509_track) 413 x509_setenv_track (x509_track, es, cert_depth, peer_cert); 414 else 415#endif 416 x509_setenv (es, cert_depth, peer_cert); 417 418 /* export subject name string as environmental variable */ 419 openvpn_snprintf (envname, sizeof(envname), "tls_id_%d", cert_depth); 420 setenv_str (es, envname, subject); 421 422#if 0 423 /* export common name string as environmental variable */ 424 openvpn_snprintf (envname, sizeof(envname), "tls_common_name_%d", cert_depth); 425 setenv_str (es, envname, common_name); 426#endif 427 428#ifdef ENABLE_EUREPHIA 429 /* export X509 cert SHA1 fingerprint */ 430 { 431 unsigned char *sha1_hash = x509_get_sha1_hash(peer_cert, &gc); 432 433 openvpn_snprintf (envname, sizeof(envname), "tls_digest_%d", cert_depth); 434 setenv_str (es, envname, format_hex_ex(sha1_hash, SHA_DIGEST_LENGTH, 0, 1, 435 ":", &gc)); 436 } 437#endif 438 439 /* export serial number as environmental variable */ 440 serial = x509_get_serial(peer_cert, &gc); 441 openvpn_snprintf (envname, sizeof(envname), "tls_serial_%d", cert_depth); 442 setenv_str (es, envname, serial); 443 444 gc_free(&gc); 445} 446 447/* 448 * call --tls-verify plug-in(s) 449 */ 450static result_t 451verify_cert_call_plugin(const struct plugin_list *plugins, struct env_set *es, 452 int cert_depth, openvpn_x509_cert_t *cert, char *subject) 453{ 454 if (plugin_defined (plugins, OPENVPN_PLUGIN_TLS_VERIFY)) 455 { 456 int ret; 457 struct argv argv = argv_new (); 458 459 argv_printf (&argv, "%d %s", cert_depth, subject); 460 461 ret = plugin_call_ssl (plugins, OPENVPN_PLUGIN_TLS_VERIFY, &argv, NULL, es, cert_depth, cert); 462 463 argv_reset (&argv); 464 465 if (ret == OPENVPN_PLUGIN_FUNC_SUCCESS) 466 { 467 msg (D_HANDSHAKE, "VERIFY PLUGIN OK: depth=%d, %s", 468 cert_depth, subject); 469 } 470 else 471 { 472 msg (D_HANDSHAKE, "VERIFY PLUGIN ERROR: depth=%d, %s", 473 cert_depth, subject); 474 return FAILURE; /* Reject connection */ 475 } 476 } 477 return SUCCESS; 478} 479 480static const char * 481verify_cert_export_cert(openvpn_x509_cert_t *peercert, const char *tmp_dir, struct gc_arena *gc) 482{ 483 FILE *peercert_file; 484 const char *peercert_filename=""; 485 486 if(!tmp_dir) 487 return NULL; 488 489 /* create tmp file to store peer cert */ 490 peercert_filename = create_temp_file (tmp_dir, "pcf", gc); 491 492 /* write peer-cert in tmp-file */ 493 peercert_file = fopen(peercert_filename, "w+"); 494 if(!peercert_file) 495 { 496 msg (M_ERR, "Failed to open temporary file : %s", peercert_filename); 497 return NULL; 498 } 499 500 if (SUCCESS != x509_write_pem(peercert_file, peercert)) 501 msg (M_ERR, "Error writing PEM file containing certificate"); 502 503 fclose(peercert_file); 504 return peercert_filename; 505} 506 507 508/* 509 * run --tls-verify script 510 */ 511static result_t 512verify_cert_call_command(const char *verify_command, struct env_set *es, 513 int cert_depth, openvpn_x509_cert_t *cert, char *subject, const char *verify_export_cert) 514{ 515 const char *tmp_file = NULL; 516 int ret; 517 struct gc_arena gc = gc_new(); 518 struct argv argv = argv_new (); 519 520 setenv_str (es, "script_type", "tls-verify"); 521 522 if (verify_export_cert) 523 { 524 if ((tmp_file=verify_cert_export_cert(cert, verify_export_cert, &gc))) 525 { 526 setenv_str(es, "peer_cert", tmp_file); 527 } 528 } 529 530 argv_printf (&argv, "%sc %d %s", verify_command, cert_depth, subject); 531 532 argv_msg_prefix (D_TLS_DEBUG, &argv, "TLS: executing verify command"); 533 ret = openvpn_run_script (&argv, es, 0, "--tls-verify script"); 534 535 if (verify_export_cert) 536 { 537 if (tmp_file) 538 platform_unlink(tmp_file); 539 } 540 541 gc_free(&gc); 542 argv_reset (&argv); 543 544 if (ret) 545 { 546 msg (D_HANDSHAKE, "VERIFY SCRIPT OK: depth=%d, %s", 547 cert_depth, subject); 548 return SUCCESS; 549 } 550 551 msg (D_HANDSHAKE, "VERIFY SCRIPT ERROR: depth=%d, %s", 552 cert_depth, subject); 553 return FAILURE; /* Reject connection */ 554} 555 556/* 557 * check peer cert against CRL directory 558 */ 559static result_t 560verify_check_crl_dir(const char *crl_dir, openvpn_x509_cert_t *cert) 561{ 562 result_t ret = FAILURE; 563 char fn[256]; 564 int fd = -1; 565 struct gc_arena gc = gc_new(); 566 567 char *serial = x509_get_serial(cert, &gc); 568 569 if (!openvpn_snprintf(fn, sizeof(fn), "%s%c%s", crl_dir, OS_SPECIFIC_DIRSEP, serial)) 570 { 571 msg (D_HANDSHAKE, "VERIFY CRL: filename overflow"); 572 goto cleanup; 573 } 574 fd = platform_open (fn, O_RDONLY, 0); 575 if (fd >= 0) 576 { 577 msg (D_HANDSHAKE, "VERIFY CRL: certificate serial number %s is revoked", serial); 578 goto cleanup; 579 } 580 581 ret = SUCCESS; 582 583cleanup: 584 585 if (fd != -1) 586 close(fd); 587 gc_free(&gc); 588 return ret; 589} 590 591result_t 592verify_cert(struct tls_session *session, openvpn_x509_cert_t *cert, int cert_depth) 593{ 594 result_t ret = FAILURE; 595 char *subject = NULL; 596 char common_name[TLS_USERNAME_LEN] = {0}; 597 const struct tls_options *opt; 598 struct gc_arena gc = gc_new(); 599 600 opt = session->opt; 601 ASSERT (opt); 602 603 session->verified = false; 604 605 /* get the X509 name */ 606 subject = x509_get_subject(cert, &gc); 607 if (!subject) 608 { 609 msg (D_TLS_ERRORS, "VERIFY ERROR: depth=%d, could not extract X509 " 610 "subject string from certificate", cert_depth); 611 goto cleanup; 612 } 613 614 /* enforce character class restrictions in X509 name */ 615 string_mod_remap_name (subject, X509_NAME_CHAR_CLASS); 616 string_replace_leading (subject, '-', '_'); 617 618 /* extract the username (default is CN) */ 619 if (SUCCESS != x509_get_username (common_name, TLS_USERNAME_LEN, 620 opt->x509_username_field, cert)) 621 { 622 if (!cert_depth) 623 { 624 msg (D_TLS_ERRORS, "VERIFY ERROR: could not extract %s from X509 " 625 "subject string ('%s') -- note that the username length is " 626 "limited to %d characters", 627 opt->x509_username_field, 628 subject, 629 TLS_USERNAME_LEN); 630 goto cleanup; 631 } 632 } 633 634 /* enforce character class restrictions in common name */ 635 string_mod_remap_name (common_name, COMMON_NAME_CHAR_CLASS); 636 637 /* warn if cert chain is too deep */ 638 if (cert_depth >= MAX_CERT_DEPTH) 639 { 640 msg (D_TLS_ERRORS, "TLS Error: Convoluted certificate chain detected with depth [%d] greater than %d", cert_depth, MAX_CERT_DEPTH); 641 goto cleanup; /* Reject connection */ 642 } 643 644 /* verify level 1 cert, i.e. the CA that signed our leaf cert */ 645 if (cert_depth == 1 && opt->verify_hash) 646 { 647 unsigned char *sha1_hash = x509_get_sha1_hash(cert, &gc); 648 if (memcmp (sha1_hash, opt->verify_hash, SHA_DIGEST_LENGTH)) 649 { 650 msg (D_TLS_ERRORS, "TLS Error: level-1 certificate hash verification failed"); 651 goto cleanup; 652 } 653 } 654 655 /* save common name in session object */ 656 if (cert_depth == 0) 657 set_common_name (session, common_name); 658 659 session->verify_maxlevel = max_int (session->verify_maxlevel, cert_depth); 660 661 /* export certificate values to the environment */ 662 verify_cert_set_env(opt->es, cert, cert_depth, subject, common_name 663#ifdef ENABLE_X509_TRACK 664 , opt->x509_track 665#endif 666 ); 667 668 /* export current untrusted IP */ 669 setenv_untrusted (session); 670 671 /* If this is the peer's own certificate, verify it */ 672 if (cert_depth == 0 && SUCCESS != verify_peer_cert(opt, cert, subject, common_name)) 673 goto cleanup; 674 675 /* call --tls-verify plug-in(s), if registered */ 676 if (SUCCESS != verify_cert_call_plugin(opt->plugins, opt->es, cert_depth, cert, subject)) 677 goto cleanup; 678 679 /* run --tls-verify script */ 680 if (opt->verify_command && SUCCESS != verify_cert_call_command(opt->verify_command, 681 opt->es, cert_depth, cert, subject, opt->verify_export_cert)) 682 goto cleanup; 683 684 /* check peer cert against CRL */ 685 if (opt->crl_file) 686 { 687 if (opt->ssl_flags & SSLF_CRL_VERIFY_DIR) 688 { 689 if (SUCCESS != verify_check_crl_dir(opt->crl_file, cert)) 690 goto cleanup; 691 } 692 else 693 { 694 if (SUCCESS != x509_verify_crl(opt->crl_file, cert, subject)) 695 goto cleanup; 696 } 697 } 698 699 msg (D_HANDSHAKE, "VERIFY OK: depth=%d, %s", cert_depth, subject); 700 session->verified = true; 701 ret = SUCCESS; 702 703cleanup: 704 705 if (ret != SUCCESS) 706 { 707 tls_clear_error(); /* always? */ 708 session->verified = false; /* double sure? */ 709 } 710 gc_free(&gc); 711 712 return ret; 713} 714 715/* *************************************************************************** 716 * Functions for the management of deferred authentication when using 717 * user/password authentication. 718 *************************************************************************** */ 719 720#ifdef ENABLE_DEF_AUTH 721/* key_state_test_auth_control_file return values, 722 NOTE: acf_merge indexing depends on these values */ 723#define ACF_UNDEFINED 0 724#define ACF_SUCCEEDED 1 725#define ACF_DISABLED 2 726#define ACF_FAILED 3 727#endif 728 729#ifdef MANAGEMENT_DEF_AUTH 730void 731man_def_auth_set_client_reason (struct tls_multi *multi, const char *client_reason) 732{ 733 if (multi->client_reason) 734 { 735 free (multi->client_reason); 736 multi->client_reason = NULL; 737 } 738 if (client_reason && strlen (client_reason)) 739 /* FIXME: Last alloc will never be freed */ 740 multi->client_reason = string_alloc (client_reason, NULL); 741} 742 743static inline unsigned int 744man_def_auth_test (const struct key_state *ks) 745{ 746 if (management_enable_def_auth (management)) 747 return ks->mda_status; 748 else 749 return ACF_DISABLED; 750} 751#endif 752 753#ifdef PLUGIN_DEF_AUTH 754 755/* 756 * auth_control_file functions 757 */ 758 759void 760key_state_rm_auth_control_file (struct key_state *ks) 761{ 762 if (ks && ks->auth_control_file) 763 { 764 platform_unlink (ks->auth_control_file); 765 free (ks->auth_control_file); 766 ks->auth_control_file = NULL; 767 } 768} 769 770static void 771key_state_gen_auth_control_file (struct key_state *ks, const struct tls_options *opt) 772{ 773 struct gc_arena gc = gc_new (); 774 const char *acf; 775 776 key_state_rm_auth_control_file (ks); 777 acf = create_temp_file (opt->tmp_dir, "acf", &gc); 778 if (acf) { 779 ks->auth_control_file = string_alloc (acf, NULL); 780 setenv_str (opt->es, "auth_control_file", ks->auth_control_file); 781 } /* FIXME: Should have better error handling? */ 782 783 gc_free (&gc); 784} 785 786static unsigned int 787key_state_test_auth_control_file (struct key_state *ks) 788{ 789 if (ks && ks->auth_control_file) 790 { 791 unsigned int ret = ks->auth_control_status; 792 if (ret == ACF_UNDEFINED) 793 { 794 FILE *fp = fopen (ks->auth_control_file, "r"); 795 if (fp) 796 { 797 const int c = fgetc (fp); 798 if (c == '1') 799 ret = ACF_SUCCEEDED; 800 else if (c == '0') 801 ret = ACF_FAILED; 802 fclose (fp); 803 ks->auth_control_status = ret; 804 } 805 } 806 return ret; 807 } 808 return ACF_DISABLED; 809} 810 811#endif 812 813/* 814 * Return current session authentication state. Return 815 * value is TLS_AUTHENTICATION_x. 816 */ 817 818int 819tls_authentication_status (struct tls_multi *multi, const int latency) 820{ 821 bool deferred = false; 822 bool success = false; 823 bool active = false; 824 825#ifdef ENABLE_DEF_AUTH 826 static const unsigned char acf_merge[] = 827 { 828 ACF_UNDEFINED, /* s1=ACF_UNDEFINED s2=ACF_UNDEFINED */ 829 ACF_UNDEFINED, /* s1=ACF_UNDEFINED s2=ACF_SUCCEEDED */ 830 ACF_UNDEFINED, /* s1=ACF_UNDEFINED s2=ACF_DISABLED */ 831 ACF_FAILED, /* s1=ACF_UNDEFINED s2=ACF_FAILED */ 832 ACF_UNDEFINED, /* s1=ACF_SUCCEEDED s2=ACF_UNDEFINED */ 833 ACF_SUCCEEDED, /* s1=ACF_SUCCEEDED s2=ACF_SUCCEEDED */ 834 ACF_SUCCEEDED, /* s1=ACF_SUCCEEDED s2=ACF_DISABLED */ 835 ACF_FAILED, /* s1=ACF_SUCCEEDED s2=ACF_FAILED */ 836 ACF_UNDEFINED, /* s1=ACF_DISABLED s2=ACF_UNDEFINED */ 837 ACF_SUCCEEDED, /* s1=ACF_DISABLED s2=ACF_SUCCEEDED */ 838 ACF_DISABLED, /* s1=ACF_DISABLED s2=ACF_DISABLED */ 839 ACF_FAILED, /* s1=ACF_DISABLED s2=ACF_FAILED */ 840 ACF_FAILED, /* s1=ACF_FAILED s2=ACF_UNDEFINED */ 841 ACF_FAILED, /* s1=ACF_FAILED s2=ACF_SUCCEEDED */ 842 ACF_FAILED, /* s1=ACF_FAILED s2=ACF_DISABLED */ 843 ACF_FAILED /* s1=ACF_FAILED s2=ACF_FAILED */ 844 }; 845#endif /* ENABLE_DEF_AUTH */ 846 847 if (multi) 848 { 849 int i; 850 851#ifdef ENABLE_DEF_AUTH 852 if (latency && multi->tas_last && multi->tas_last + latency >= now) 853 return TLS_AUTHENTICATION_UNDEFINED; 854 multi->tas_last = now; 855#endif /* ENABLE_DEF_AUTH */ 856 857 for (i = 0; i < KEY_SCAN_SIZE; ++i) 858 { 859 struct key_state *ks = multi->key_scan[i]; 860 if (DECRYPT_KEY_ENABLED (multi, ks)) 861 { 862 active = true; 863 if (ks->authenticated) 864 { 865#ifdef ENABLE_DEF_AUTH 866 unsigned int s1 = ACF_DISABLED; 867 unsigned int s2 = ACF_DISABLED; 868#ifdef PLUGIN_DEF_AUTH 869 s1 = key_state_test_auth_control_file (ks); 870#endif /* PLUGIN_DEF_AUTH */ 871#ifdef MANAGEMENT_DEF_AUTH 872 s2 = man_def_auth_test (ks); 873#endif /* MANAGEMENT_DEF_AUTH */ 874 ASSERT (s1 < 4 && s2 < 4); 875 switch (acf_merge[(s1<<2) + s2]) 876 { 877 case ACF_SUCCEEDED: 878 case ACF_DISABLED: 879 success = true; 880 ks->auth_deferred = false; 881 break; 882 case ACF_UNDEFINED: 883 if (now < ks->auth_deferred_expire) 884 deferred = true; 885 break; 886 case ACF_FAILED: 887 ks->authenticated = false; 888 break; 889 default: 890 ASSERT (0); 891 } 892#else /* !ENABLE_DEF_AUTH */ 893 success = true; 894#endif /* ENABLE_DEF_AUTH */ 895 } 896 } 897 } 898 } 899 900#if 0 901 dmsg (D_TLS_ERRORS, "TAS: a=%d s=%d d=%d", active, success, deferred); 902#endif 903 904 if (success) 905 return TLS_AUTHENTICATION_SUCCEEDED; 906 else if (!active || deferred) 907 return TLS_AUTHENTICATION_DEFERRED; 908 else 909 return TLS_AUTHENTICATION_FAILED; 910} 911 912#ifdef MANAGEMENT_DEF_AUTH 913/* 914 * For deferred auth, this is where the management interface calls (on server) 915 * to indicate auth failure/success. 916 */ 917bool 918tls_authenticate_key (struct tls_multi *multi, const unsigned int mda_key_id, const bool auth, const char *client_reason) 919{ 920 bool ret = false; 921 if (multi) 922 { 923 int i; 924 man_def_auth_set_client_reason (multi, client_reason); 925 for (i = 0; i < KEY_SCAN_SIZE; ++i) 926 { 927 struct key_state *ks = multi->key_scan[i]; 928 if (ks->mda_key_id == mda_key_id) 929 { 930 ks->mda_status = auth ? ACF_SUCCEEDED : ACF_FAILED; 931 ret = true; 932 } 933 } 934 } 935 return ret; 936} 937#endif 938 939 940/* **************************************************************************** 941 * Functions to verify username and password 942 * 943 * Authenticate a client using username/password. 944 * Runs on server. 945 * 946 * If you want to add new authentication methods, 947 * this is the place to start. 948 *************************************************************************** */ 949 950/* 951 * Verify the user name and password using a script 952 */ 953static bool 954verify_user_pass_script (struct tls_session *session, const struct user_pass *up) 955{ 956 struct gc_arena gc = gc_new (); 957 struct argv argv = argv_new (); 958 const char *tmp_file = ""; 959 bool ret = false; 960 961 /* Is username defined? */ 962 if ((session->opt->ssl_flags & SSLF_AUTH_USER_PASS_OPTIONAL) || strlen (up->username)) 963 { 964 /* Set environmental variables prior to calling script */ 965 setenv_str (session->opt->es, "script_type", "user-pass-verify"); 966 967 if (session->opt->auth_user_pass_verify_script_via_file) 968 { 969 struct status_output *so; 970 971 tmp_file = create_temp_file (session->opt->tmp_dir, "up", &gc); 972 if( tmp_file ) { 973 so = status_open (tmp_file, 0, -1, NULL, STATUS_OUTPUT_WRITE); 974 status_printf (so, "%s", up->username); 975 status_printf (so, "%s", up->password); 976 if (!status_close (so)) 977 { 978 msg (D_TLS_ERRORS, "TLS Auth Error: could not write username/password to file: %s", 979 tmp_file); 980 goto done; 981 } 982 } else { 983 msg (D_TLS_ERRORS, "TLS Auth Error: could not create write " 984 "username/password to temp file"); 985 } 986 } 987 else 988 { 989 setenv_str (session->opt->es, "username", up->username); 990 setenv_str (session->opt->es, "password", up->password); 991 } 992 993 /* setenv incoming cert common name for script */ 994 setenv_str (session->opt->es, "common_name", session->common_name); 995 996 /* setenv client real IP address */ 997 setenv_untrusted (session); 998 999 /* format command line */ 1000 argv_printf (&argv, "%sc %s", session->opt->auth_user_pass_verify_script, tmp_file); 1001 1002 /* call command */ 1003 ret = openvpn_run_script (&argv, session->opt->es, 0, 1004 "--auth-user-pass-verify"); 1005 1006 if (!session->opt->auth_user_pass_verify_script_via_file) 1007 setenv_del (session->opt->es, "password"); 1008 } 1009 else 1010 { 1011 msg (D_TLS_ERRORS, "TLS Auth Error: peer provided a blank username"); 1012 } 1013 1014 done: 1015 if (tmp_file && strlen (tmp_file) > 0) 1016 platform_unlink (tmp_file); 1017 1018 argv_reset (&argv); 1019 gc_free (&gc); 1020 return ret; 1021} 1022 1023/* 1024 * Verify the username and password using a plugin 1025 */ 1026static int 1027verify_user_pass_plugin (struct tls_session *session, const struct user_pass *up, const char *raw_username) 1028{ 1029 int retval = OPENVPN_PLUGIN_FUNC_ERROR; 1030 struct key_state *ks = &session->key[KS_PRIMARY]; /* primary key */ 1031 1032 /* Is username defined? */ 1033 if ((session->opt->ssl_flags & SSLF_AUTH_USER_PASS_OPTIONAL) || strlen (up->username)) 1034 { 1035 /* set username/password in private env space */ 1036 setenv_str (session->opt->es, "username", (raw_username ? raw_username : up->username)); 1037 setenv_str (session->opt->es, "password", up->password); 1038 1039 /* setenv incoming cert common name for script */ 1040 setenv_str (session->opt->es, "common_name", session->common_name); 1041 1042 /* setenv client real IP address */ 1043 setenv_untrusted (session); 1044 1045#ifdef PLUGIN_DEF_AUTH 1046 /* generate filename for deferred auth control file */ 1047 key_state_gen_auth_control_file (ks, session->opt); 1048#endif 1049 1050 /* call command */ 1051 retval = plugin_call (session->opt->plugins, OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY, NULL, NULL, session->opt->es); 1052 1053#ifdef PLUGIN_DEF_AUTH 1054 /* purge auth control filename (and file itself) for non-deferred returns */ 1055 if (retval != OPENVPN_PLUGIN_FUNC_DEFERRED) 1056 key_state_rm_auth_control_file (ks); 1057#endif 1058 1059 setenv_del (session->opt->es, "password"); 1060 if (raw_username) 1061 setenv_str (session->opt->es, "username", up->username); 1062 } 1063 else 1064 { 1065 msg (D_TLS_ERRORS, "TLS Auth Error (verify_user_pass_plugin): peer provided a blank username"); 1066 } 1067 1068 return retval; 1069} 1070 1071 1072#ifdef MANAGEMENT_DEF_AUTH 1073/* 1074 * MANAGEMENT_DEF_AUTH internal ssl_verify.c status codes 1075 */ 1076#define KMDA_ERROR 0 1077#define KMDA_SUCCESS 1 1078#define KMDA_UNDEF 2 1079#define KMDA_DEF 3 1080 1081static int 1082verify_user_pass_management (struct tls_session *session, const struct user_pass *up, const char *raw_username) 1083{ 1084 int retval = KMDA_ERROR; 1085 struct key_state *ks = &session->key[KS_PRIMARY]; /* primary key */ 1086 1087 /* Is username defined? */ 1088 if ((session->opt->ssl_flags & SSLF_AUTH_USER_PASS_OPTIONAL) || strlen (up->username)) 1089 { 1090 /* set username/password in private env space */ 1091 setenv_str (session->opt->es, "username", (raw_username ? raw_username : up->username)); 1092 setenv_str (session->opt->es, "password", up->password); 1093 1094 /* setenv incoming cert common name for script */ 1095 setenv_str (session->opt->es, "common_name", session->common_name); 1096 1097 /* setenv client real IP address */ 1098 setenv_untrusted (session); 1099 1100 if (management) 1101 management_notify_client_needing_auth (management, ks->mda_key_id, session->opt->mda_context, session->opt->es); 1102 1103 setenv_del (session->opt->es, "password"); 1104 if (raw_username) 1105 setenv_str (session->opt->es, "username", up->username); 1106 1107 retval = KMDA_SUCCESS; 1108 } 1109 else 1110 { 1111 msg (D_TLS_ERRORS, "TLS Auth Error (verify_user_pass_management): peer provided a blank username"); 1112 } 1113 1114 return retval; 1115} 1116#endif 1117 1118/* 1119 * Main username/password verification entry point 1120 */ 1121void 1122verify_user_pass(struct user_pass *up, struct tls_multi *multi, 1123 struct tls_session *session) 1124{ 1125 int s1 = OPENVPN_PLUGIN_FUNC_SUCCESS; 1126 bool s2 = true; 1127 struct key_state *ks = &session->key[KS_PRIMARY]; /* primary key */ 1128 1129 struct gc_arena gc = gc_new (); 1130 char *raw_username = NULL; 1131 1132#ifdef MANAGEMENT_DEF_AUTH 1133 int man_def_auth = KMDA_UNDEF; 1134 1135 if (management_enable_def_auth (management)) 1136 man_def_auth = KMDA_DEF; 1137#endif 1138 1139 /* 1140 * Preserve the raw username before string_mod remapping, for plugins 1141 * and management clients when in --compat-names mode 1142 */ 1143 if (compat_flag (COMPAT_FLAG_QUERY | COMPAT_NAMES)) 1144 { 1145 ALLOC_ARRAY_CLEAR_GC (raw_username, char, USER_PASS_LEN, &gc); 1146 strcpy (raw_username, up->username); 1147 string_mod (raw_username, CC_PRINT, CC_CRLF, '_'); 1148 } 1149 1150 /* enforce character class restrictions in username/password */ 1151 string_mod_remap_name (up->username, COMMON_NAME_CHAR_CLASS); 1152 string_mod (up->password, CC_PRINT, CC_CRLF, '_'); 1153 1154 /* call plugin(s) and/or script */ 1155#ifdef MANAGEMENT_DEF_AUTH 1156 if (man_def_auth == KMDA_DEF) 1157 man_def_auth = verify_user_pass_management (session, up, raw_username); 1158#endif 1159 if (plugin_defined (session->opt->plugins, OPENVPN_PLUGIN_AUTH_USER_PASS_VERIFY)) 1160 s1 = verify_user_pass_plugin (session, up, raw_username); 1161 if (session->opt->auth_user_pass_verify_script) 1162 s2 = verify_user_pass_script (session, up); 1163 1164 /* check sizing of username if it will become our common name */ 1165 if ((session->opt->ssl_flags & SSLF_USERNAME_AS_COMMON_NAME) && strlen (up->username) >= TLS_USERNAME_LEN) 1166 { 1167 msg (D_TLS_ERRORS, "TLS Auth Error: --username-as-common name specified and username is longer than the maximum permitted Common Name length of %d characters", TLS_USERNAME_LEN); 1168 s1 = OPENVPN_PLUGIN_FUNC_ERROR; 1169 } 1170 1171 /* auth succeeded? */ 1172 if ((s1 == OPENVPN_PLUGIN_FUNC_SUCCESS 1173#ifdef PLUGIN_DEF_AUTH 1174 || s1 == OPENVPN_PLUGIN_FUNC_DEFERRED 1175#endif 1176 ) && s2 1177#ifdef MANAGEMENT_DEF_AUTH 1178 && man_def_auth != KMDA_ERROR 1179#endif 1180 && tls_lock_username (multi, up->username)) 1181 { 1182 ks->authenticated = true; 1183#ifdef PLUGIN_DEF_AUTH 1184 if (s1 == OPENVPN_PLUGIN_FUNC_DEFERRED) 1185 ks->auth_deferred = true; 1186#endif 1187#ifdef MANAGEMENT_DEF_AUTH 1188 if (man_def_auth != KMDA_UNDEF) 1189 ks->auth_deferred = true; 1190#endif 1191 if ((session->opt->ssl_flags & SSLF_USERNAME_AS_COMMON_NAME)) 1192 set_common_name (session, up->username); 1193#ifdef ENABLE_DEF_AUTH 1194 msg (D_HANDSHAKE, "TLS: Username/Password authentication %s for username '%s' %s", 1195 ks->auth_deferred ? "deferred" : "succeeded", 1196 up->username, 1197 (session->opt->ssl_flags & SSLF_USERNAME_AS_COMMON_NAME) ? "[CN SET]" : ""); 1198#else 1199 msg (D_HANDSHAKE, "TLS: Username/Password authentication %s for username '%s' %s", 1200 "succeeded", 1201 up->username, 1202 (session->opt->ssl_flags & SSLF_USERNAME_AS_COMMON_NAME) ? "[CN SET]" : ""); 1203#endif 1204 } 1205 else 1206 { 1207 msg (D_TLS_ERRORS, "TLS Auth Error: Auth Username/Password verification failed for peer"); 1208 } 1209 1210 gc_free (&gc); 1211} 1212 1213void 1214verify_final_auth_checks(struct tls_multi *multi, struct tls_session *session) 1215{ 1216 struct key_state *ks = &session->key[KS_PRIMARY]; /* primary key */ 1217 1218 /* While it shouldn't really happen, don't allow the common name to be NULL */ 1219 if (!session->common_name) 1220 set_common_name (session, ""); 1221 1222 /* Don't allow the CN to change once it's been locked */ 1223 if (ks->authenticated && multi->locked_cn) 1224 { 1225 const char *cn = session->common_name; 1226 if (cn && strcmp (cn, multi->locked_cn)) 1227 { 1228 msg (D_TLS_ERRORS, "TLS Auth Error: TLS object CN attempted to change from '%s' to '%s' -- tunnel disabled", 1229 multi->locked_cn, 1230 cn); 1231 1232 /* change the common name back to its original value and disable the tunnel */ 1233 set_common_name (session, multi->locked_cn); 1234 tls_deauthenticate (multi); 1235 } 1236 } 1237 1238 /* Don't allow the cert hashes to change once they have been locked */ 1239 if (ks->authenticated && multi->locked_cert_hash_set) 1240 { 1241 const struct cert_hash_set *chs = session->cert_hash_set; 1242 if (chs && !cert_hash_compare (chs, multi->locked_cert_hash_set)) 1243 { 1244 msg (D_TLS_ERRORS, "TLS Auth Error: TLS object CN=%s client-provided SSL certs unexpectedly changed during mid-session reauth", 1245 session->common_name); 1246 1247 /* disable the tunnel */ 1248 tls_deauthenticate (multi); 1249 } 1250 } 1251 1252 /* verify --client-config-dir based authentication */ 1253 if (ks->authenticated && session->opt->client_config_dir_exclusive) 1254 { 1255 struct gc_arena gc = gc_new (); 1256 1257 const char *cn = session->common_name; 1258 const char *path = gen_path (session->opt->client_config_dir_exclusive, cn, &gc); 1259 if (!cn || !strcmp (cn, CCD_DEFAULT) || !test_file (path)) 1260 { 1261 ks->authenticated = false; 1262 msg (D_TLS_ERRORS, "TLS Auth Error: --client-config-dir authentication failed for common name '%s' file='%s'", 1263 session->common_name, 1264 path ? path : "UNDEF"); 1265 } 1266 1267 gc_free (&gc); 1268 } 1269} 1270#endif /* defined(ENABLE_CRYPTO) && defined(ENABLE_SSL) */ 1271