2 * OpenConnect (SSL + DTLS) VPN client
4 * Copyright © 2008-2012 Intel Corporation.
6 * Author: David Woodhouse <dwmw2@infradead.org>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * version 2.1, as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to:
20 * Free Software Foundation, Inc.
21 * 51 Franklin Street, Fifth Floor,
22 * Boston, MA 02110-1301 USA
26 #include <sys/types.h>
27 #include <netinet/in.h>
28 #include <arpa/inet.h>
31 #include <openssl/ssl.h>
32 #include <openssl/err.h>
33 #include <openssl/engine.h>
34 #include <openssl/evp.h>
35 #include <openssl/rand.h>
36 #include <openssl/pkcs12.h>
37 #include <openssl/x509v3.h>
38 #include <openssl/x509.h>
39 #include <openssl/bio.h>
41 #include "openconnect-internal.h"
43 int openconnect_sha1(unsigned char *result, void *data, int len)
48 EVP_Digest(data, len, result, NULL, EVP_sha1(), NULL);
49 EVP_MD_CTX_cleanup(&c);
54 int openconnect_get_cert_DER(struct openconnect_info *vpninfo,
55 OPENCONNECT_X509 *cert, unsigned char **buf)
57 BIO *bp = BIO_new(BIO_s_mem());
61 if (!i2d_X509_bio(bp, cert)) {
66 BIO_get_mem_ptr(bp, &certinfo);
73 memcpy(*buf, certinfo->data, l);
78 int openconnect_random(void *bytes, int len)
80 if (RAND_bytes(bytes, len) != 1)
85 /* Helper functions for reading/writing lines over SSL.
86 We could use cURL for the HTTP stuff, but it's overkill */
88 int openconnect_SSL_write(struct openconnect_info *vpninfo, char *buf, size_t len)
90 size_t orig_len = len;
93 int done = SSL_write(vpninfo->https_ssl, buf, len);
98 int err = SSL_get_error(vpninfo->https_ssl, done);
99 fd_set wr_set, rd_set;
100 int maxfd = vpninfo->ssl_fd;
105 if (err == SSL_ERROR_WANT_READ)
106 FD_SET(vpninfo->ssl_fd, &rd_set);
107 else if (err == SSL_ERROR_WANT_WRITE)
108 FD_SET(vpninfo->ssl_fd, &wr_set);
110 vpn_progress(vpninfo, PRG_ERR, _("Failed to write to SSL socket"));
111 openconnect_report_ssl_errors(vpninfo);
114 if (vpninfo->cancel_fd != -1) {
115 FD_SET(vpninfo->cancel_fd, &rd_set);
116 if (vpninfo->cancel_fd > vpninfo->ssl_fd)
117 maxfd = vpninfo->cancel_fd;
119 select(maxfd + 1, &rd_set, &wr_set, NULL, NULL);
120 if (vpninfo->cancel_fd != -1 &&
121 FD_ISSET(vpninfo->cancel_fd, &rd_set)) {
122 vpn_progress(vpninfo, PRG_ERR, _("SSL write cancelled\n"));
130 int openconnect_SSL_read(struct openconnect_info *vpninfo, char *buf, size_t len)
134 while ((done = SSL_read(vpninfo->https_ssl, buf, len)) == -1) {
135 int err = SSL_get_error(vpninfo->https_ssl, done);
136 fd_set wr_set, rd_set;
137 int maxfd = vpninfo->ssl_fd;
142 if (err == SSL_ERROR_WANT_READ)
143 FD_SET(vpninfo->ssl_fd, &rd_set);
144 else if (err == SSL_ERROR_WANT_WRITE)
145 FD_SET(vpninfo->ssl_fd, &wr_set);
147 vpn_progress(vpninfo, PRG_ERR, _("Failed to read from SSL socket"));
148 openconnect_report_ssl_errors(vpninfo);
151 if (vpninfo->cancel_fd != -1) {
152 FD_SET(vpninfo->cancel_fd, &rd_set);
153 if (vpninfo->cancel_fd > vpninfo->ssl_fd)
154 maxfd = vpninfo->cancel_fd;
156 select(maxfd + 1, &rd_set, &wr_set, NULL, NULL);
157 if (vpninfo->cancel_fd != -1 &&
158 FD_ISSET(vpninfo->cancel_fd, &rd_set)) {
159 vpn_progress(vpninfo, PRG_ERR, _("SSL read cancelled\n"));
166 int openconnect_SSL_gets(struct openconnect_info *vpninfo, char *buf, size_t len)
175 ret = SSL_read(vpninfo->https_ssl, buf + i, 1);
177 if (buf[i] == '\n') {
179 if (i && buf[i-1] == '\r') {
192 fd_set rd_set, wr_set;
193 int maxfd = vpninfo->ssl_fd;
198 ret = SSL_get_error(vpninfo->https_ssl, ret);
199 if (ret == SSL_ERROR_WANT_READ)
200 FD_SET(vpninfo->ssl_fd, &rd_set);
201 else if (ret == SSL_ERROR_WANT_WRITE)
202 FD_SET(vpninfo->ssl_fd, &wr_set);
204 vpn_progress(vpninfo, PRG_ERR, _("Failed to read from SSL socket\n"));
205 openconnect_report_ssl_errors(vpninfo);
209 if (vpninfo->cancel_fd != -1) {
210 FD_SET(vpninfo->cancel_fd, &rd_set);
211 if (vpninfo->cancel_fd > vpninfo->ssl_fd)
212 maxfd = vpninfo->cancel_fd;
214 select(maxfd + 1, &rd_set, &wr_set, NULL, NULL);
215 if (vpninfo->cancel_fd != -1 &&
216 FD_ISSET(vpninfo->cancel_fd, &rd_set)) {
217 vpn_progress(vpninfo, PRG_ERR, _("SSL read cancelled\n"));
228 /* UI handling. All this just to handle the PIN callback from the TPM ENGINE,
229 and turn it into a call to our ->process_auth_form function */
232 struct openconnect_info *vpninfo;
233 struct oc_form_opt **last_opt;
234 struct oc_auth_form form;
238 struct oc_form_opt opt;
242 /* Ick. But there is no way to pass this sanely through OpenSSL */
243 static struct openconnect_info *ui_vpninfo;
245 static int ui_open(UI *ui)
247 struct openconnect_info *vpninfo = ui_vpninfo; /* Ick */
248 struct ui_data *ui_data;
250 if (!vpninfo || !vpninfo->process_auth_form)
253 ui_data = malloc(sizeof(*ui_data));
257 memset(ui_data, 0, sizeof(*ui_data));
258 ui_data->last_opt = &ui_data->form.opts;
259 ui_data->vpninfo = vpninfo;
260 ui_data->form.auth_id = (char *)"openssl_ui";
261 UI_add_user_data(ui, ui_data);
266 static int ui_write(UI *ui, UI_STRING *uis)
268 struct ui_data *ui_data = UI_get0_user_data(ui);
269 struct ui_form_opt *opt;
271 switch(UI_get_string_type(uis)) {
273 ui_data->form.error = (char *)UI_get0_output_string(uis);
276 ui_data->form.message = (char *)UI_get0_output_string(uis);
279 opt = malloc(sizeof(*opt));
282 memset(opt, 0, sizeof(*opt));
284 opt->opt.label = opt->opt.name = (char *)UI_get0_output_string(uis);
285 if (UI_get_input_flags(uis) & UI_INPUT_FLAG_ECHO)
286 opt->opt.type = OC_FORM_OPT_TEXT;
288 opt->opt.type = OC_FORM_OPT_PASSWORD;
289 *(ui_data->last_opt) = &opt->opt;
290 ui_data->last_opt = &opt->opt.next;
294 fprintf(stderr, "Unhandled SSL UI request type %d\n",
295 UI_get_string_type(uis));
301 static int ui_flush(UI *ui)
303 struct ui_data *ui_data = UI_get0_user_data(ui);
304 struct openconnect_info *vpninfo = ui_data->vpninfo;
305 struct ui_form_opt *opt;
308 ret = vpninfo->process_auth_form(vpninfo->cbdata, &ui_data->form);
312 for (opt = (struct ui_form_opt *)ui_data->form.opts; opt;
313 opt = (struct ui_form_opt *)opt->opt.next) {
314 if (opt->opt.value && opt->uis)
315 UI_set_result(ui, opt->uis, opt->opt.value);
320 static int ui_close(UI *ui)
322 struct ui_data *ui_data = UI_get0_user_data(ui);
323 struct ui_form_opt *opt, *next_opt;
325 opt = (struct ui_form_opt *)ui_data->form.opts;
327 next_opt = (struct ui_form_opt *)opt->opt.next;
329 free(opt->opt.value);
334 UI_add_user_data(ui, NULL);
339 static UI_METHOD *create_openssl_ui(struct openconnect_info *vpninfo)
341 UI_METHOD *ui_method = UI_create_method((char *)"AnyConnect VPN UI");
343 /* There is a race condition here because of the use of the
344 static ui_vpninfo pointer. This sucks, but it's OpenSSL's
345 fault and in practice it's *never* going to hurt us.
347 This UI is only used for loading certificates from a TPM; for
348 PKCS#12 and PEM files we hook the passphrase request differently.
349 The ui_vpninfo variable is set here, and is used from ui_open()
350 when the TPM ENGINE decides it needs to ask the user for a PIN.
352 The race condition exists because theoretically, there
353 could be more than one thread using libopenconnect and
354 trying to authenticate to a VPN server, within the *same*
355 process. And if *both* are using certificates from the TPM,
356 and *both* manage to be within that short window of time
357 between setting ui_vpninfo and invoking ui_open() to fetch
358 the PIN, then one connection's ->process_auth_form() could
359 get a PIN request for the *other* connection.
361 However, the only thing that ever does run libopenconnect more
362 than once from the same process is KDE's NetworkManager support,
363 and NetworkManager doesn't *support* having more than one VPN
364 connected anyway, so first that would have to be fixed and then
365 you'd have to connect to two VPNs simultaneously by clicking
366 'connect' on both at *exactly* the same time and then getting
369 Oh, and the KDE support won't be using OpenSSL anyway because of
370 licensing conflicts... so although this sucks, I'm not going to
373 ui_vpninfo = vpninfo;
375 /* Set up a UI method of our own for password/passphrase requests */
376 UI_method_set_opener(ui_method, ui_open);
377 UI_method_set_writer(ui_method, ui_write);
378 UI_method_set_flusher(ui_method, ui_flush);
379 UI_method_set_closer(ui_method, ui_close);
384 static int pem_pw_cb(char *buf, int len, int w, void *v)
386 struct openconnect_info *vpninfo = v;
390 if (vpninfo->cert_password) {
391 pass = vpninfo->cert_password;
392 vpninfo->cert_password = NULL;
393 } else if (request_passphrase(vpninfo, "openconnect_pem",
394 &pass, _("Enter PEM pass phrase:")))
400 vpn_progress(vpninfo, PRG_ERR,
401 _("PEM password too long (%d >= %d)\n"),
407 memcpy(buf, pass, plen+1);
412 static int load_pkcs12_certificate(struct openconnect_info *vpninfo, PKCS12 *p12)
414 EVP_PKEY *pkey = NULL;
420 pass = vpninfo->cert_password;
421 vpninfo->cert_password = NULL;
423 /* We do this every time round the loop, to work around a bug in
424 OpenSSL < 1.0.0-beta2 -- where the stack at *ca will be freed
425 when PKCS12_parse() returns an error, but *ca is left pointing
426 to the freed memory. */
428 if (!pass && request_passphrase(vpninfo, "openconnect_pkcs12", &pass,
429 _("Enter PKCS#12 pass phrase:")) < 0) {
433 if (!PKCS12_parse(p12, pass, &pkey, &cert, &ca)) {
434 unsigned long err = ERR_peek_error();
436 openconnect_report_ssl_errors(vpninfo);
438 if (ERR_GET_LIB(err) == ERR_LIB_PKCS12 &&
439 ERR_GET_FUNC(err) == PKCS12_F_PKCS12_PARSE &&
440 ERR_GET_REASON(err) == PKCS12_R_MAC_VERIFY_FAILURE) {
441 vpn_progress(vpninfo, PRG_ERR,
442 _("Parse PKCS#12 failed (wrong passphrase?)\n"));
448 vpn_progress(vpninfo, PRG_ERR,
449 _("Parse PKCS#12 failed (see above errors)\n"));
457 vpninfo->cert_x509 = cert;
458 SSL_CTX_use_certificate(vpninfo->https_ctx, cert);
459 X509_NAME_oneline(X509_get_subject_name(cert), buf, sizeof(buf));
460 vpn_progress(vpninfo, PRG_INFO,
461 _("Using client certificate '%s'\n"), buf);
463 vpn_progress(vpninfo, PRG_ERR,
464 _("PKCS#12 contained no certificate!"));
469 SSL_CTX_use_PrivateKey(vpninfo->https_ctx, pkey);
472 vpn_progress(vpninfo, PRG_ERR,
473 _("PKCS#12 contained no private key!"));
477 /* Only include supporting certificates which are actually necessary */
481 for (i = 0; i < sk_X509_num(ca); i++) {
482 X509 *cert2 = sk_X509_value(ca, i);
483 if (X509_check_issued(cert2, cert) == X509_V_OK) {
488 if (X509_check_issued(cert2, cert2) == X509_V_OK)
491 X509_NAME_oneline(X509_get_subject_name(cert2),
493 vpn_progress(vpninfo, PRG_DEBUG,
494 _("Extra cert from PKCS#12: '%s'\n"), buf);
495 CRYPTO_add(&cert2->references, 1, CRYPTO_LOCK_X509);
496 SSL_CTX_add_extra_chain_cert(vpninfo->https_ctx, cert2);
501 sk_X509_pop_free(ca, X509_free);
509 static int load_tpm_certificate(struct openconnect_info *vpninfo)
513 UI_METHOD *meth = NULL;
516 ENGINE_load_builtin_engines();
518 e = ENGINE_by_id("tpm");
520 vpn_progress(vpninfo, PRG_ERR, _("Can't load TPM engine.\n"));
521 openconnect_report_ssl_errors(vpninfo);
524 if (!ENGINE_init(e) || !ENGINE_set_default_RSA(e) ||
525 !ENGINE_set_default_RAND(e)) {
526 vpn_progress(vpninfo, PRG_ERR, _("Failed to init TPM engine\n"));
527 openconnect_report_ssl_errors(vpninfo);
532 if (vpninfo->cert_password) {
533 if (!ENGINE_ctrl_cmd(e, "PIN", strlen(vpninfo->cert_password),
534 vpninfo->cert_password, NULL, 0)) {
535 vpn_progress(vpninfo, PRG_ERR,
536 _("Failed to set TPM SRK password\n"));
537 openconnect_report_ssl_errors(vpninfo);
539 vpninfo->cert_password = NULL;
540 free(vpninfo->cert_password);
542 /* Provide our own UI method to handle the PIN callback. */
543 meth = create_openssl_ui(vpninfo);
545 key = ENGINE_load_private_key(e, vpninfo->sslkey, meth, NULL);
547 UI_destroy_method(meth);
549 vpn_progress(vpninfo, PRG_ERR,
550 _("Failed to load TPM private key\n"));
551 openconnect_report_ssl_errors(vpninfo);
555 if (!SSL_CTX_use_PrivateKey(vpninfo->https_ctx, key)) {
556 vpn_progress(vpninfo, PRG_ERR, _("Add key from TPM failed\n"));
557 openconnect_report_ssl_errors(vpninfo);
567 static int load_tpm_certificate(struct openconnect_info *vpninfo)
569 vpn_progress(vpninfo, PRG_ERR,
570 _("This version of OpenConnect was built without TPM support\n"));
575 static int reload_pem_cert(struct openconnect_info *vpninfo)
577 BIO *b = BIO_new(BIO_s_file_internal());
583 if (BIO_read_filename(b, vpninfo->cert) <= 0) {
586 vpn_progress(vpninfo, PRG_ERR,
587 _("Failed to reload X509 cert for expiry check\n"));
588 openconnect_report_ssl_errors(vpninfo);
591 vpninfo->cert_x509 = PEM_read_bio_X509_AUX(b, NULL, NULL, NULL);
593 if (!vpninfo->cert_x509)
596 X509_NAME_oneline(X509_get_subject_name(vpninfo->cert_x509), buf, sizeof(buf));
597 vpn_progress(vpninfo, PRG_INFO,
598 _("Using client certificate '%s'\n"), buf);
603 static int load_certificate(struct openconnect_info *vpninfo)
605 if (!strncmp(vpninfo->sslkey, "pkcs11:", 7) ||
606 !strncmp(vpninfo->cert, "pkcs11:", 7)) {
607 vpn_progress(vpninfo, PRG_ERR,
608 _("This binary built without PKCS#11 support\n"));
612 vpn_progress(vpninfo, PRG_TRACE,
613 _("Using certificate file %s\n"), vpninfo->cert);
615 if (vpninfo->cert_type == CERT_TYPE_PKCS12 ||
616 vpninfo->cert_type == CERT_TYPE_UNKNOWN) {
620 f = fopen(vpninfo->cert, "r");
622 vpn_progress(vpninfo, PRG_ERR,
623 _("Failed to open certificate file %s: %s\n"),
624 vpninfo->cert, strerror(errno));
627 p12 = d2i_PKCS12_fp(f, NULL);
630 return load_pkcs12_certificate(vpninfo, p12);
633 if (vpninfo->cert_type == CERT_TYPE_PKCS12) {
634 vpn_progress(vpninfo, PRG_ERR, _("Read PKCS#12 failed\n"));
635 openconnect_report_ssl_errors(vpninfo);
638 /* Clear error and fall through to see if it's a PEM file... */
642 /* It's PEM or TPM now, and either way we need to load the plain cert: */
643 if (!SSL_CTX_use_certificate_chain_file(vpninfo->https_ctx,
645 vpn_progress(vpninfo, PRG_ERR,
646 _("Loading certificate failed\n"));
647 openconnect_report_ssl_errors(vpninfo);
651 /* Ew, we can't get it back from the OpenSSL CTX in any sane fashion */
652 reload_pem_cert(vpninfo);
654 if (vpninfo->cert_type == CERT_TYPE_UNKNOWN) {
655 FILE *f = fopen(vpninfo->sslkey, "r");
659 vpn_progress(vpninfo, PRG_ERR,
660 _("Failed to open private key file %s: %s\n"),
661 vpninfo->cert, strerror(errno));
666 while (fgets(buf, 255, f)) {
667 if (!strcmp(buf, "-----BEGIN TSS KEY BLOB-----\n")) {
668 vpninfo->cert_type = CERT_TYPE_TPM;
670 } else if (!strcmp(buf, "-----BEGIN RSA PRIVATE KEY-----\n") ||
671 !strcmp(buf, "-----BEGIN DSA PRIVATE KEY-----\n") ||
672 !strcmp(buf, "-----BEGIN ENCRYPTED PRIVATE KEY-----\n")) {
673 vpninfo->cert_type = CERT_TYPE_PEM;
678 if (vpninfo->cert_type == CERT_TYPE_UNKNOWN) {
679 vpn_progress(vpninfo, PRG_ERR,
680 _("Failed to identify private key type in '%s'\n"),
686 if (vpninfo->cert_type == CERT_TYPE_TPM)
687 return load_tpm_certificate(vpninfo);
689 /* Standard PEM certificate */
690 SSL_CTX_set_default_passwd_cb(vpninfo->https_ctx, pem_pw_cb);
691 SSL_CTX_set_default_passwd_cb_userdata(vpninfo->https_ctx, vpninfo);
693 if (!SSL_CTX_use_RSAPrivateKey_file(vpninfo->https_ctx, vpninfo->sslkey,
695 unsigned long err = ERR_peek_error();
697 openconnect_report_ssl_errors(vpninfo);
699 #ifndef EVP_F_EVP_DECRYPTFINAL_EX
700 #define EVP_F_EVP_DECRYPTFINAL_EX EVP_F_EVP_DECRYPTFINAL
702 /* If the user fat-fingered the passphrase, try again */
703 if (ERR_GET_LIB(err) == ERR_LIB_EVP &&
704 ERR_GET_FUNC(err) == EVP_F_EVP_DECRYPTFINAL_EX &&
705 ERR_GET_REASON(err) == EVP_R_BAD_DECRYPT) {
706 vpn_progress(vpninfo, PRG_ERR,
707 _("Loading private key failed (wrong passphrase?)\n"));
711 vpn_progress(vpninfo, PRG_ERR,
712 _("Loading private key failed (see above errors)\n"));
718 static int get_cert_fingerprint(struct openconnect_info *vpninfo,
719 OPENCONNECT_X509 *cert, const EVP_MD *type,
722 unsigned char md[EVP_MAX_MD_SIZE];
725 if (!X509_digest(cert, type, md, &n))
728 for (i=0; i < n; i++)
729 sprintf(&buf[i*2], "%02X", md[i]);
734 int get_cert_md5_fingerprint(struct openconnect_info *vpninfo,
735 OPENCONNECT_X509 *cert, char *buf)
737 return get_cert_fingerprint(vpninfo, cert, EVP_md5(), buf);
740 int openconnect_get_cert_sha1(struct openconnect_info *vpninfo,
741 OPENCONNECT_X509 *cert, char *buf)
743 return get_cert_fingerprint(vpninfo, cert, EVP_sha1(), buf);
746 static int check_server_cert(struct openconnect_info *vpninfo, X509 *cert)
748 char fingerprint[EVP_MAX_MD_SIZE * 2 + 1];
751 ret = openconnect_get_cert_sha1(vpninfo, cert, fingerprint);
755 if (strcasecmp(vpninfo->servercert, fingerprint)) {
756 vpn_progress(vpninfo, PRG_ERR,
757 _("Server SSL certificate didn't match: %s\n"), fingerprint);
763 static int match_hostname_elem(const char *hostname, int helem_len,
764 const char *match, int melem_len)
766 if (!helem_len && !melem_len)
769 if (!helem_len || !melem_len)
773 if (match[0] == '*') {
776 for (i = 1 ; i <= helem_len; i++) {
777 if (!match_hostname_elem(hostname + i, helem_len - i,
778 match + 1, melem_len - 1))
784 /* From the NetBSD (5.1) man page for ctype(3):
785 Values of type char or signed char must first be cast to unsigned char,
786 to ensure that the values are within the correct range. The result
787 should then be cast to int to avoid warnings from some compilers.
788 We do indeed get warning "array subscript has type 'char'" without
790 if (toupper((int)(unsigned char)hostname[0]) ==
791 toupper((int)(unsigned char)match[0]))
792 return match_hostname_elem(hostname + 1, helem_len - 1,
793 match + 1, melem_len - 1);
798 static int match_hostname(const char *hostname, const char *match)
801 const char *h_dot, *m_dot;
802 int helem_len, melem_len;
804 h_dot = strchr(hostname, '.');
805 m_dot = strchr(match, '.');
807 if (h_dot && m_dot) {
808 helem_len = h_dot - hostname + 1;
809 melem_len = m_dot - match + 1;
810 } else if (!h_dot && !m_dot) {
811 helem_len = strlen(hostname);
812 melem_len = strlen(match);
817 if (match_hostname_elem(hostname, helem_len,
821 hostname += helem_len;
830 /* cf. RFC2818 and RFC2459 */
831 static int match_cert_hostname(struct openconnect_info *vpninfo, X509 *peer_cert)
833 STACK_OF(GENERAL_NAME) *altnames;
835 ASN1_STRING *subjasn1;
836 char *subjstr = NULL;
839 char addrbuf[sizeof(struct in6_addr)];
842 /* Allow GEN_IP in the certificate only if we actually connected
843 by IP address rather than by name. */
844 if (inet_pton(AF_INET, vpninfo->hostname, addrbuf) > 0)
846 else if (inet_pton(AF_INET6, vpninfo->hostname, addrbuf) > 0)
848 else if (vpninfo->hostname[0] == '[' &&
849 vpninfo->hostname[strlen(vpninfo->hostname)-1] == ']') {
850 char *p = &vpninfo->hostname[strlen(vpninfo->hostname)-1];
852 if (inet_pton(AF_INET6, vpninfo->hostname + 1, addrbuf) > 0)
857 altnames = X509_get_ext_d2i(peer_cert, NID_subject_alt_name,
859 for (i = 0; i < sk_GENERAL_NAME_num(altnames); i++) {
860 const GENERAL_NAME *this = sk_GENERAL_NAME_value(altnames, i);
862 if (this->type == GEN_DNS) {
865 int len = ASN1_STRING_to_UTF8((void *)&str, this->d.ia5);
871 /* We don't like names with embedded NUL */
872 if (strlen(str) != len)
875 if (!match_hostname(vpninfo->hostname, str)) {
876 vpn_progress(vpninfo, PRG_TRACE,
877 _("Matched DNS altname '%s'\n"),
879 GENERAL_NAMES_free(altnames);
883 vpn_progress(vpninfo, PRG_TRACE,
884 _("No match for altname '%s'\n"),
888 } else if (this->type == GEN_IPADD && addrlen) {
892 if (this->d.ip->length == 4) {
894 } else if (this->d.ip->length == 16) {
897 vpn_progress(vpninfo, PRG_ERR,
898 _("Certificate has GEN_IPADD altname with bogus length %d\n"),
903 /* We only do this for the debug messages */
904 inet_ntop(family, this->d.ip->data, host, sizeof(host));
906 if (this->d.ip->length == addrlen &&
907 !memcmp(addrbuf, this->d.ip->data, addrlen)) {
908 vpn_progress(vpninfo, PRG_TRACE,
909 _("Matched %s address '%s'\n"),
910 (family == AF_INET6)?"IPv6":"IPv4",
912 GENERAL_NAMES_free(altnames);
915 vpn_progress(vpninfo, PRG_TRACE,
916 _("No match for %s address '%s'\n"),
917 (family == AF_INET6)?"IPv6":"IPv4",
920 } else if (this->type == GEN_URI) {
922 char *url_proto, *url_host, *url_path, *url_host2;
924 int len = ASN1_STRING_to_UTF8((void *)&str, this->d.ia5);
929 /* We don't like names with embedded NUL */
930 if (strlen(str) != len)
933 if (internal_parse_url(str, &url_proto, &url_host, &url_port, &url_path, 0)) {
938 if (!url_proto || strcasecmp(url_proto, "https"))
941 if (url_port != vpninfo->port)
944 /* Leave url_host as it was so that it can be freed */
945 url_host2 = url_host;
946 if (addrlen == 16 && vpninfo->hostname[0] != '[' &&
947 url_host[0] == '[' && url_host[strlen(url_host)-1] == ']') {
948 /* Cope with https://[IPv6]/ when the hostname is bare IPv6 */
949 url_host[strlen(url_host)-1] = 0;
953 if (strcasecmp(vpninfo->hostname, url_host2))
957 vpn_progress(vpninfo, PRG_TRACE,
958 _("URI '%s' has non-empty path; ignoring\n"),
960 goto no_uri_match_silent;
962 vpn_progress(vpninfo, PRG_TRACE,
963 _("Matched URI '%s'\n"),
969 GENERAL_NAMES_free(altnames);
973 vpn_progress(vpninfo, PRG_TRACE,
974 _("No match for URI '%s'\n"),
983 GENERAL_NAMES_free(altnames);
985 /* According to RFC2818, we don't use the legacy subject name if
986 there was an altname with DNS type. */
988 vpn_progress(vpninfo, PRG_ERR,
989 _("No altname in peer cert matched '%s'\n"),
994 subjname = X509_get_subject_name(peer_cert);
996 vpn_progress(vpninfo, PRG_ERR,
997 _("No subject name in peer cert!\n"));
1001 /* Find the _last_ (most specific) commonName */
1004 int j = X509_NAME_get_index_by_NID(subjname, NID_commonName, i);
1011 subjasn1 = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subjname, i));
1013 i = ASN1_STRING_to_UTF8((void *)&subjstr, subjasn1);
1015 if (!subjstr || strlen(subjstr) != i) {
1016 vpn_progress(vpninfo, PRG_ERR,
1017 _("Failed to parse subject name in peer cert\n"));
1022 if (match_hostname(vpninfo->hostname, subjstr)) {
1023 vpn_progress(vpninfo, PRG_ERR,
1024 _("Peer cert subject mismatch ('%s' != '%s')\n"),
1025 subjstr, vpninfo->hostname);
1028 vpn_progress(vpninfo, PRG_TRACE,
1029 _("Matched peer certificate subject name '%s'\n"),
1033 OPENSSL_free(subjstr);
1037 static int verify_peer(struct openconnect_info *vpninfo, SSL *https_ssl)
1042 peer_cert = SSL_get_peer_certificate(https_ssl);
1044 if (vpninfo->servercert) {
1045 /* If given a cert fingerprint on the command line, that's
1047 ret = check_server_cert(vpninfo, peer_cert);
1049 int vfy = SSL_get_verify_result(https_ssl);
1050 const char *err_string = NULL;
1052 if (vfy != X509_V_OK)
1053 err_string = X509_verify_cert_error_string(vfy);
1054 else if (match_cert_hostname(vpninfo, peer_cert))
1055 err_string = _("certificate does not match hostname");
1058 vpn_progress(vpninfo, PRG_INFO,
1059 _("Server certificate verify failed: %s\n"),
1062 if (vpninfo->validate_peer_cert)
1063 ret = vpninfo->validate_peer_cert(vpninfo->cbdata,
1072 X509_free(peer_cert);
1077 static void workaround_openssl_certchain_bug(struct openconnect_info *vpninfo,
1080 /* OpenSSL has problems with certificate chains -- if there are
1081 multiple certs with the same name, it doesn't necessarily
1082 choose the _right_ one. (RT#1942)
1083 Pick the right ones for ourselves and add them manually. */
1084 X509 *cert = SSL_get_certificate(ssl);
1086 X509_STORE *store = SSL_CTX_get_cert_store(vpninfo->https_ctx);
1089 if (!cert || !store)
1092 /* If we already have 'supporting' certs, don't add them again */
1093 if (vpninfo->https_ctx->extra_certs)
1096 if (!X509_STORE_CTX_init(&ctx, store, NULL, NULL))
1099 while (ctx.get_issuer(&cert2, &ctx, cert) == 1) {
1103 if (X509_check_issued(cert2, cert2) == X509_V_OK)
1106 X509_NAME_oneline(X509_get_subject_name(cert),
1108 vpn_progress(vpninfo, PRG_DEBUG,
1109 _("Extra cert from cafile: '%s'\n"), buf);
1110 SSL_CTX_add_extra_chain_cert(vpninfo->https_ctx, cert);
1112 X509_STORE_CTX_cleanup(&ctx);
1115 #if OPENSSL_VERSION_NUMBER >= 0x00908000
1116 static int ssl_app_verify_callback(X509_STORE_CTX *ctx, void *arg)
1118 /* We've seen certificates in the wild which don't have the
1119 purpose fields filled in correctly */
1120 X509_VERIFY_PARAM_set_purpose(ctx->param, X509_PURPOSE_ANY);
1121 return X509_verify_cert(ctx);
1125 static int check_certificate_expiry(struct openconnect_info *vpninfo)
1127 ASN1_TIME *notAfter;
1128 const char *reason = NULL;
1132 if (!vpninfo->cert_x509)
1136 notAfter = X509_get_notAfter(vpninfo->cert_x509);
1137 i = X509_cmp_time(notAfter, &t);
1139 vpn_progress(vpninfo, PRG_ERR,
1140 _("Error in client cert notAfter field\n"));
1143 reason = _("Client certificate has expired at");
1145 t += vpninfo->cert_expire_warning;
1146 i = X509_cmp_time(notAfter, &t);
1148 reason = _("Client certificate expires soon at");
1152 BIO *bp = BIO_new(BIO_s_mem());
1154 const char *expiry = _("<error>");
1158 ASN1_TIME_print(bp, notAfter);
1159 BIO_write(bp, &zero, 1);
1160 BIO_get_mem_ptr(bp, &bm);
1163 vpn_progress(vpninfo, PRG_ERR, "%s: %s\n", reason, expiry);
1169 int openconnect_open_https(struct openconnect_info *vpninfo)
1171 method_const SSL_METHOD *ssl3_method;
1177 if (vpninfo->https_ssl)
1180 if (vpninfo->peer_cert) {
1181 X509_free(vpninfo->peer_cert);
1182 vpninfo->peer_cert = NULL;
1185 ssl_sock = connect_https_socket(vpninfo);
1189 ssl3_method = TLSv1_client_method();
1190 if (!vpninfo->https_ctx) {
1191 vpninfo->https_ctx = SSL_CTX_new(ssl3_method);
1193 /* Some servers (or their firewalls) really don't like seeing
1195 #ifdef SSL_OP_NO_TICKET
1196 SSL_CTX_set_options (vpninfo->https_ctx, SSL_OP_NO_TICKET);
1199 if (vpninfo->cert) {
1200 err = load_certificate(vpninfo);
1202 vpn_progress(vpninfo, PRG_ERR,
1203 _("Loading certificate failed. Aborting.\n"));
1206 check_certificate_expiry(vpninfo);
1209 /* We just want to do:
1210 SSL_CTX_set_purpose(vpninfo->https_ctx, X509_PURPOSE_ANY);
1211 ... but it doesn't work with OpenSSL < 0.9.8k because of
1212 problems with inheritance (fixed in v1.1.4.6 of
1213 crypto/x509/x509_vpm.c) so we have to play silly buggers
1214 instead. This trick doesn't work _either_ in < 0.9.7 but
1215 I don't know of _any_ workaround which will, and can't
1216 be bothered to find out either. */
1217 #if OPENSSL_VERSION_NUMBER >= 0x00908000
1218 SSL_CTX_set_cert_verify_callback(vpninfo->https_ctx,
1219 ssl_app_verify_callback, NULL);
1221 SSL_CTX_set_default_verify_paths(vpninfo->https_ctx);
1223 if (vpninfo->cafile) {
1224 if (!SSL_CTX_load_verify_locations(vpninfo->https_ctx, vpninfo->cafile, NULL)) {
1225 vpn_progress(vpninfo, PRG_ERR,
1226 _("Failed to open CA file '%s'\n"),
1228 openconnect_report_ssl_errors(vpninfo);
1235 https_ssl = SSL_new(vpninfo->https_ctx);
1236 workaround_openssl_certchain_bug(vpninfo, https_ssl);
1238 https_bio = BIO_new_socket(ssl_sock, BIO_NOCLOSE);
1239 BIO_set_nbio(https_bio, 1);
1240 SSL_set_bio(https_ssl, https_bio, https_bio);
1242 vpn_progress(vpninfo, PRG_INFO, _("SSL negotiation with %s\n"),
1245 while ((err = SSL_connect(https_ssl)) <= 0) {
1246 fd_set wr_set, rd_set;
1247 int maxfd = ssl_sock;
1252 err = SSL_get_error(https_ssl, err);
1253 if (err == SSL_ERROR_WANT_READ)
1254 FD_SET(ssl_sock, &rd_set);
1255 else if (err == SSL_ERROR_WANT_WRITE)
1256 FD_SET(ssl_sock, &wr_set);
1258 vpn_progress(vpninfo, PRG_ERR, _("SSL connection failure\n"));
1259 openconnect_report_ssl_errors(vpninfo);
1260 SSL_free(https_ssl);
1265 if (vpninfo->cancel_fd != -1) {
1266 FD_SET(vpninfo->cancel_fd, &rd_set);
1267 if (vpninfo->cancel_fd > ssl_sock)
1268 maxfd = vpninfo->cancel_fd;
1270 select(maxfd + 1, &rd_set, &wr_set, NULL, NULL);
1271 if (vpninfo->cancel_fd != -1 &&
1272 FD_ISSET(vpninfo->cancel_fd, &rd_set)) {
1273 vpn_progress(vpninfo, PRG_ERR, _("SSL connection cancelled\n"));
1274 SSL_free(https_ssl);
1280 if (verify_peer(vpninfo, https_ssl)) {
1281 SSL_free(https_ssl);
1286 vpninfo->ssl_fd = ssl_sock;
1287 vpninfo->https_ssl = https_ssl;
1289 /* Stash this now, because it might not be available later if the
1290 server has disconnected. */
1291 vpninfo->peer_cert = SSL_get_peer_certificate(vpninfo->https_ssl);
1293 vpn_progress(vpninfo, PRG_INFO, _("Connected to HTTPS on %s\n"),
1299 void openconnect_close_https(struct openconnect_info *vpninfo, int final)
1301 if (vpninfo->peer_cert) {
1302 X509_free(vpninfo->peer_cert);
1303 vpninfo->peer_cert = NULL;
1305 if (vpninfo->https_ssl) {
1306 SSL_free(vpninfo->https_ssl);
1307 vpninfo->https_ssl = NULL;
1309 if (vpninfo->ssl_fd != -1) {
1310 close(vpninfo->ssl_fd);
1311 FD_CLR(vpninfo->ssl_fd, &vpninfo->select_rfds);
1312 FD_CLR(vpninfo->ssl_fd, &vpninfo->select_wfds);
1313 FD_CLR(vpninfo->ssl_fd, &vpninfo->select_efds);
1314 vpninfo->ssl_fd = -1;
1317 if (vpninfo->https_ctx) {
1318 SSL_CTX_free(vpninfo->https_ctx);
1319 vpninfo->https_ctx = NULL;
1321 if (vpninfo->cert_x509) {
1322 X509_free(vpninfo->cert_x509);
1323 vpninfo->cert_x509 = NULL;
1328 void openconnect_init_ssl(void)
1330 SSL_library_init ();
1332 SSL_load_error_strings ();
1333 OpenSSL_add_all_algorithms ();
1336 char *openconnect_get_cert_details(struct openconnect_info *vpninfo,
1337 OPENCONNECT_X509 *cert)
1339 BIO *bp = BIO_new(BIO_s_mem());
1344 X509_print_ex(bp, cert, 0, 0);
1345 BIO_write(bp, &zero, 1);
1346 BIO_get_mem_ptr(bp, &certinfo);
1348 ret = strdup(certinfo->data);
1354 int openconnect_local_cert_md5(struct openconnect_info *vpninfo,
1359 if (!vpninfo->cert_x509)
1362 if (get_cert_md5_fingerprint(vpninfo, vpninfo->cert_x509, buf))