@@ -921,6 +921,7 @@ if test "${enable_crypto}" = "yes" -a "${with_crypto_library}" = "openssl"; then

 		[ \

 			SSL_CTX_get_default_passwd_cb \

 			SSL_CTX_get_default_passwd_cb_userdata \

+			X509_get0_pubkey \

 			X509_STORE_get0_objects \

 			X509_OBJECT_free \

 			X509_OBJECT_get_type \

@@ -73,6 +73,21 @@ SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx)

 }

 #endif

+#if !defined(HAVE_X509_GET0_PUBKEY)

+/**

+ * Get the public key from a X509 certificate

+ *

+ * @param x                  X509 certificate

+ * @return                   The certificate public key

+ */

+static inline EVP_PKEY *

+X509_get0_pubkey(const X509 *x)

+{

+    return (x && x->cert_info && x->cert_info->key) ?

+           x->cert_info->key->pkey : NULL;

+}

+#endif

+

 #if !defined(HAVE_X509_STORE_GET0_OBJECTS)

 /**

  * Fetch the X509 object stack from the X509 store

@@ -1070,7 +1070,8 @@ tls_ctx_use_external_private_key(struct tls_root_ctx *ctx,

     }

     /* get the public key */

-    ASSERT(cert->cert_info->key->pkey); /* NULL before SSL_CTX_use_certificate() is called */

+    EVP_PKEY *pkey = X509_get0_pubkey(cert);

+    ASSERT(pkey); /* NULL before SSL_CTX_use_certificate() is called */

     pub_rsa = cert->cert_info->key->pkey->pkey.rsa;

     /* initialize RSA object */

@@ -210,7 +210,7 @@ void x509_setenv_track(const struct x509_track *xt, struct env_set *es,

  *                      the expected bit set. \c FAILURE if the certificate does

  *                      not have NS cert type verification or the wrong bit set.

  */

-result_t x509_verify_ns_cert_type(const openvpn_x509_cert_t *cert, const int usage);

+result_t x509_verify_ns_cert_type(openvpn_x509_cert_t *cert, const int usage);

 /*

  * Verify X.509 key usage extension field.

@@ -410,7 +410,7 @@ x509_setenv(struct env_set *es, int cert_depth, mbedtls_x509_crt *cert)

 }

 result_t

-x509_verify_ns_cert_type(const mbedtls_x509_crt *cert, const int usage)

+x509_verify_ns_cert_type(mbedtls_x509_crt *cert, const int usage)

 {

     if (usage == NS_CERT_CHECK_NONE)

     {

@@ -293,18 +293,20 @@ backend_x509_get_serial_hex(openvpn_x509_cert_t *cert, struct gc_arena *gc)

 struct buffer

 x509_get_sha1_fingerprint(X509 *cert, struct gc_arena *gc)

 {

-    struct buffer hash = alloc_buf_gc(sizeof(cert->sha1_hash), gc);

-    memcpy(BPTR(&hash), cert->sha1_hash, sizeof(cert->sha1_hash));

-    ASSERT(buf_inc_len(&hash, sizeof(cert->sha1_hash)));

+    const EVP_MD *sha1 = EVP_sha1();

+    struct buffer hash = alloc_buf_gc(EVP_MD_size(sha1), gc);

+    X509_digest(cert, EVP_sha1(), BPTR(&hash), NULL);

+    ASSERT(buf_inc_len(&hash, EVP_MD_size(sha1)));

     return hash;

 }

 struct buffer

 x509_get_sha256_fingerprint(X509 *cert, struct gc_arena *gc)

 {

-    struct buffer hash = alloc_buf_gc((EVP_sha256())->md_size, gc);

+    const EVP_MD *sha256 = EVP_sha256();

+    struct buffer hash = alloc_buf_gc(EVP_MD_size(sha256), gc);

     X509_digest(cert, EVP_sha256(), BPTR(&hash), NULL);

-    ASSERT(buf_inc_len(&hash, (EVP_sha256())->md_size));

+    ASSERT(buf_inc_len(&hash, EVP_MD_size(sha256)));

     return hash;

 }

@@ -569,7 +571,7 @@ x509_setenv(struct env_set *es, int cert_depth, openvpn_x509_cert_t *peer_cert)

 }

 result_t

-x509_verify_ns_cert_type(const openvpn_x509_cert_t *peer_cert, const int usage)

+x509_verify_ns_cert_type(openvpn_x509_cert_t *peer_cert, const int usage)

 {

     if (usage == NS_CERT_CHECK_NONE)

     {

@@ -577,13 +579,59 @@ x509_verify_ns_cert_type(const openvpn_x509_cert_t *peer_cert, const int usage)

     }

     if (usage == NS_CERT_CHECK_CLIENT)

     {

-        return ((peer_cert->ex_flags & EXFLAG_NSCERT)

-                && (peer_cert->ex_nscert & NS_SSL_CLIENT)) ? SUCCESS : FAILURE;

+        /*

+         * Unfortunately, X509_check_purpose() does some weird thing that

+         * prevent it to take a const argument

+         */

+        result_t result = X509_check_purpose(peer_cert, X509_PURPOSE_SSL_CLIENT, 0) ?

+	       SUCCESS : FAILURE;

+

+        /*

+         * old versions of OpenSSL allow us to make the less strict check we used to

+         * do. If this less strict check pass, warn user that this might not be the

+         * case when its distribution will update to OpenSSL 1.1

+         */

+        if (result == FAILURE)

+        {

+            ASN1_BIT_STRING *ns;

+            ns = X509_get_ext_d2i(peer_cert, NID_netscape_cert_type, NULL, NULL);

+            result = (ns && ns->length > 0 && (ns->data[0] & NS_SSL_CLIENT)) ? SUCCESS : FAILURE;

+            if (result == SUCCESS)

+            {

+                msg(M_WARN, "X509: Certificate is a client certificate yet it's purpose "

+                    "cannot be verified (check may fail in the future)");

+            }

+            ASN1_BIT_STRING_free(ns);

+        }

+        return result;

     }

     if (usage == NS_CERT_CHECK_SERVER)

     {

-        return ((peer_cert->ex_flags & EXFLAG_NSCERT)

-                && (peer_cert->ex_nscert & NS_SSL_SERVER))  ? SUCCESS : FAILURE;

+        /*

+         * Unfortunately, X509_check_purpose() does some weird thing that

+         * prevent it to take a const argument

+         */

+        result_t result = X509_check_purpose(peer_cert, X509_PURPOSE_SSL_SERVER, 0) ?

+	       SUCCESS : FAILURE;

+

+        /*

+         * old versions of OpenSSL allow us to make the less strict check we used to

+         * do. If this less strict check pass, warn user that this might not be the

+         * case when its distribution will update to OpenSSL 1.1

+         */

+        if (result == FAILURE)

+        {

+            ASN1_BIT_STRING *ns;

+            ns = X509_get_ext_d2i(peer_cert, NID_netscape_cert_type, NULL, NULL);

+            result = (ns && ns->length > 0 && (ns->data[0] & NS_SSL_SERVER)) ? SUCCESS : FAILURE;

+            if (result == SUCCESS)

+            {

+                msg(M_WARN, "X509: Certificate is a server certificate yet it's purpose "

+                    "cannot be verified (check may fail in the future)");

+            }

+            ASN1_BIT_STRING_free(ns);

+        }

+        return result;

     }

     return FAILURE;