libcurl: update to 8.6.0

12 files changed, 546 insertions, 689 deletions

diff --git a/libs/libcurl/src/vtls/bearssl.c b/libs/libcurl/src/vtls/bearssl.c
index 3bda30328c..924802c61f 100644
--- a/libs/libcurl/src/vtls/bearssl.c
+++ b/libs/libcurl/src/vtls/bearssl.c
@@ -509,7 +509,6 @@ static CURLcode bearssl_set_selected_ciphers(struct Curl_easy *data,
 {

   uint16_t selected_ciphers[NUM_OF_CIPHERS];

   size_t selected_count = 0;

-  char cipher_name[CIPHER_NAME_BUF_LEN];

   const char *cipher_start = ciphers;

   const char *cipher_end;

   size_t i, j;

@@ -518,41 +517,48 @@ static CURLcode bearssl_set_selected_ciphers(struct Curl_easy *data,
     return CURLE_SSL_CIPHER;

 

   while(true) {

+    const char *cipher;

+    size_t clen;

+

     /* Extract the next cipher name from the ciphers string */

     while(is_separator(*cipher_start))

       ++cipher_start;

-    if(*cipher_start == '\0')

+    if(!*cipher_start)

       break;

     cipher_end = cipher_start;

-    while(*cipher_end != '\0' && !is_separator(*cipher_end))

+    while(*cipher_end && !is_separator(*cipher_end))

       ++cipher_end;

-    j = cipher_end - cipher_start < CIPHER_NAME_BUF_LEN - 1 ?

-        cipher_end - cipher_start : CIPHER_NAME_BUF_LEN - 1;

-    strncpy(cipher_name, cipher_start, j);

-    cipher_name[j] = '\0';

+

+    clen = cipher_end - cipher_start;

+    cipher = cipher_start;

+

     cipher_start = cipher_end;

 

     /* Lookup the cipher name in the table of available ciphers. If the cipher

        name starts with "TLS_" we do the lookup by IANA name. Otherwise, we try

        to match cipher name by an (OpenSSL) alias. */

-    if(strncasecompare(cipher_name, "TLS_", 4)) {

+    if(strncasecompare(cipher, "TLS_", 4)) {

       for(i = 0; i < NUM_OF_CIPHERS &&

-                 !strcasecompare(cipher_name, ciphertable[i].name); ++i);

+            (strlen(ciphertable[i].name) == clen) &&

+            !strncasecompare(cipher, ciphertable[i].name, clen); ++i);

     }

     else {

       for(i = 0; i < NUM_OF_CIPHERS &&

-                 !strcasecompare(cipher_name, ciphertable[i].alias_name); ++i);

+            (strlen(ciphertable[i].alias_name) == clen) &&

+            !strncasecompare(cipher, ciphertable[i].alias_name, clen); ++i);

     }

     if(i == NUM_OF_CIPHERS) {

-      infof(data, "BearSSL: unknown cipher in list: %s", cipher_name);

+      infof(data, "BearSSL: unknown cipher in list: %.*s",

+            (int)clen, cipher);

       continue;

     }

 

     /* No duplicates allowed */

     for(j = 0; j < selected_count &&

-               selected_ciphers[j] != ciphertable[i].num; j++);

+          selected_ciphers[j] != ciphertable[i].num; j++);

     if(j < selected_count) {

-      infof(data, "BearSSL: duplicate cipher in list: %s", cipher_name);

+      infof(data, "BearSSL: duplicate cipher in list: %.*s",

+            (int)clen, cipher);

       continue;

     }

 

diff --git a/libs/libcurl/src/vtls/gtls.c b/libs/libcurl/src/vtls/gtls.c
index bd78eb5030..dd40380738 100644
--- a/libs/libcurl/src/vtls/gtls.c
+++ b/libs/libcurl/src/vtls/gtls.c
@@ -584,13 +584,9 @@ CURLcode gtls_client_init(struct Curl_easy *data,
   /* Only add SRP to the cipher list if SRP is requested. Otherwise

    * GnuTLS will disable TLS 1.3 support. */

   if(config->username) {

-    size_t len = strlen(prioritylist);

-

-    char *prioritysrp = malloc(len + sizeof(GNUTLS_SRP) + 1);

+    char *prioritysrp = aprintf("%s:" GNUTLS_SRP, prioritylist);

     if(!prioritysrp)

       return CURLE_OUT_OF_MEMORY;

-    strcpy(prioritysrp, prioritylist);

-    strcpy(prioritysrp + len, ":" GNUTLS_SRP);

     rc = gnutls_priority_set_direct(gtls->session, prioritysrp, &err);

     free(prioritysrp);

 

@@ -822,16 +818,17 @@ Curl_gtls_verifyserver(struct Curl_easy *data,
   char certname[65] = ""; /* limited to 64 chars by ASN.1 */

   size_t size;

   time_t certclock;

-  const char *ptr;

   int rc;

   CURLcode result = CURLE_OK;

 #ifndef CURL_DISABLE_VERBOSE_STRINGS

+  const char *ptr;

   unsigned int algo;

   unsigned int bits;

   gnutls_protocol_t version = gnutls_protocol_get_version(session);

 #endif

   long * const certverifyresult = &ssl_config->certverifyresult;

 

+#ifndef CURL_DISABLE_VERBOSE_STRINGS

   /* the name of the cipher suite used, e.g. ECDHE_RSA_AES_256_GCM_SHA384. */

   ptr = gnutls_cipher_suite_get_name(gnutls_kx_get(session),

                                      gnutls_cipher_get(session),

@@ -839,6 +836,7 @@ Curl_gtls_verifyserver(struct Curl_easy *data,
 

   infof(data, "SSL connection using %s / %s",

         gnutls_protocol_get_name(version), ptr);

+#endif

 

   /* This function will return the peer's raw certificate (chain) as sent by

      the peer. These certificates are in raw format (DER encoded for

diff --git a/libs/libcurl/src/vtls/mbedtls.c b/libs/libcurl/src/vtls/mbedtls.c
index 292c933291..c008eace9b 100644
--- a/libs/libcurl/src/vtls/mbedtls.c
+++ b/libs/libcurl/src/vtls/mbedtls.c
@@ -36,6 +36,13 @@
 /* Define this to enable lots of debugging for mbedTLS */

 /* #define MBEDTLS_DEBUG */

 

+#ifdef __GNUC__

+#pragma GCC diagnostic push

+/* mbedTLS (as of v3.5.1) has a duplicate function declaration

+   in its public headers. Disable the warning that detects it. */

+#pragma GCC diagnostic ignored "-Wredundant-decls"

+#endif

+

 #include <mbedtls/version.h>

 #if MBEDTLS_VERSION_NUMBER >= 0x02040000

 #include <mbedtls/net_sockets.h>

@@ -56,6 +63,10 @@
 #  endif

 #endif

 

+#ifdef __GNUC__

+#pragma GCC diagnostic pop

+#endif

+

 #include "urldata.h"

 #include "sendf.h"

 #include "inet_pton.h"

@@ -67,6 +78,7 @@
 #include "select.h"

 #include "multiif.h"

 #include "mbedtls_threadlock.h"

+#include "strdup.h"

 

 /* The last 3 #include files should be in this order */

 #include "curl_printf.h"

@@ -153,7 +165,6 @@ static void mbed_debug(void *context, int level, const char *f_name,
   infof(data, "%s", line);

   (void) level;

 }

-#else

 #endif

 

 static int mbedtls_bio_cf_write(void *bio,

@@ -165,6 +176,9 @@ static int mbedtls_bio_cf_write(void *bio,
   CURLcode result;

 

   DEBUGASSERT(data);

+  if(!data)

+    return 0;

+

   nwritten = Curl_conn_cf_send(cf->next, data, (char *)buf, blen, &result);

   CURL_TRC_CF(data, cf, "mbedtls_bio_cf_out_write(len=%zu) -> %zd, err=%d",

               blen, nwritten, result);

@@ -182,6 +196,8 @@ static int mbedtls_bio_cf_read(void *bio, unsigned char *buf, size_t blen)
   CURLcode result;

 

   DEBUGASSERT(data);

+  if(!data)

+    return 0;

   /* OpenSSL catches this case, so should we. */

   if(!buf)

     return 0;

@@ -367,11 +383,10 @@ mbed_connect_step1(struct Curl_cfilter *cf, struct Curl_easy *data)
     /* Unfortunately, mbedtls_x509_crt_parse() requires the data to be null

        terminated even when provided the exact length, forcing us to waste

        extra memory here. */

-    unsigned char *newblob = malloc(ca_info_blob->len + 1);

+    unsigned char *newblob = Curl_memdup0(ca_info_blob->data,

+                                          ca_info_blob->len);

     if(!newblob)

       return CURLE_OUT_OF_MEMORY;

-    memcpy(newblob, ca_info_blob->data, ca_info_blob->len);

-    newblob[ca_info_blob->len] = 0; /* null terminate */

     ret = mbedtls_x509_crt_parse(&backend->cacert, newblob,

                                  ca_info_blob->len + 1);

     free(newblob);

@@ -441,11 +456,10 @@ mbed_connect_step1(struct Curl_cfilter *cf, struct Curl_easy *data)
     /* Unfortunately, mbedtls_x509_crt_parse() requires the data to be null

        terminated even when provided the exact length, forcing us to waste

        extra memory here. */

-    unsigned char *newblob = malloc(ssl_cert_blob->len + 1);

+    unsigned char *newblob = Curl_memdup0(ssl_cert_blob->data,

+                                          ssl_cert_blob->len);

     if(!newblob)

       return CURLE_OUT_OF_MEMORY;

-    memcpy(newblob, ssl_cert_blob->data, ssl_cert_blob->len);

-    newblob[ssl_cert_blob->len] = 0; /* null terminate */

     ret = mbedtls_x509_crt_parse(&backend->clicert, newblob,

                                  ssl_cert_blob->len + 1);

     free(newblob);

@@ -1207,6 +1221,9 @@ static int mbedtls_init(void)
 

 static void mbedtls_cleanup(void)

 {

+#ifdef THREADING_SUPPORT

+  mbedtls_entropy_free(&ts_entropy);

+#endif /* THREADING_SUPPORT */

   (void)Curl_mbedtlsthreadlock_thread_cleanup();

 }

 

diff --git a/libs/libcurl/src/vtls/openssl.c b/libs/libcurl/src/vtls/openssl.c
index fcc4e4eb0b..be6780b7ed 100644
--- a/libs/libcurl/src/vtls/openssl.c
+++ b/libs/libcurl/src/vtls/openssl.c
@@ -954,8 +954,9 @@ static char *ossl_strerror(unsigned long error, char *buf, size_t size)
 #endif

 

   if(!*buf) {

-    strncpy(buf, (error ? "Unknown error" : "No error"), size);

-    buf[size - 1] = '\0';

+    const char *msg = error ? "Unknown error" : "No error";

+    if(strlen(msg) < size)

+      strcpy(buf, msg);

   }

 

   return buf;

@@ -1087,6 +1088,7 @@ static int ssl_ui_reader(UI *ui, UI_STRING *uis)
       UI_set_result(ui, uis, password);

       return 1;

     }

+    FALLTHROUGH();

   default:

     break;

   }

@@ -1105,6 +1107,7 @@ static int ssl_ui_writer(UI *ui, UI_STRING *uis)
        (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD)) {

       return 1;

     }

+    FALLTHROUGH();

   default:

     break;

   }

@@ -1522,7 +1525,7 @@ fail:
     case SSL_FILETYPE_PEM:

       if(cert_done)

         break;

-      /* FALLTHROUGH */

+      FALLTHROUGH();

     case SSL_FILETYPE_ASN1:

       cert_use_result = key_blob ?

         SSL_CTX_use_PrivateKey_blob(ctx, key_blob, file_type, key_passwd) :

@@ -1752,7 +1755,7 @@ static int ossl_init(void)
 static void ossl_cleanup(void)

 {

 #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) &&  \

-  !defined(LIBRESSL_VERSION_NUMBER)

+  (!defined(LIBRESSL_VERSION_NUMBER) || LIBRESSL_VERSION_NUMBER >= 0x2070000fL)

   /* OpenSSL 1.1 deprecates all these cleanup functions and

      turns them into no-ops in OpenSSL 1.0 compatibility mode */

 #else

@@ -2848,7 +2851,7 @@ ossl_set_ssl_version_min_max_legacy(ctx_option_t *ctx_options,
   failf(data, OSSL_PACKAGE " was built without TLS 1.3 support");

   return CURLE_NOT_BUILT_IN;

 #endif

-  /* FALLTHROUGH */

+  FALLTHROUGH();

   case CURL_SSLVERSION_TLSv1_2:

 #if OPENSSL_VERSION_NUMBER >= 0x1000100FL

     *ctx_options |= SSL_OP_NO_TLSv1_1;

@@ -2856,7 +2859,7 @@ ossl_set_ssl_version_min_max_legacy(ctx_option_t *ctx_options,
     failf(data, OSSL_PACKAGE " was built without TLS 1.2 support");

     return CURLE_NOT_BUILT_IN;

 #endif

-    /* FALLTHROUGH */

+    FALLTHROUGH();

   case CURL_SSLVERSION_TLSv1_1:

 #if OPENSSL_VERSION_NUMBER >= 0x1000100FL

     *ctx_options |= SSL_OP_NO_TLSv1;

@@ -2864,7 +2867,7 @@ ossl_set_ssl_version_min_max_legacy(ctx_option_t *ctx_options,
     failf(data, OSSL_PACKAGE " was built without TLS 1.1 support");

     return CURLE_NOT_BUILT_IN;

 #endif

-    /* FALLTHROUGH */

+    FALLTHROUGH();

   case CURL_SSLVERSION_TLSv1_0:

   case CURL_SSLVERSION_TLSv1:

     break;

@@ -2875,12 +2878,12 @@ ossl_set_ssl_version_min_max_legacy(ctx_option_t *ctx_options,
 #if OPENSSL_VERSION_NUMBER >= 0x1000100FL

     *ctx_options |= SSL_OP_NO_TLSv1_1;

 #endif

-    /* FALLTHROUGH */

+    FALLTHROUGH();

   case CURL_SSLVERSION_MAX_TLSv1_1:

 #if OPENSSL_VERSION_NUMBER >= 0x1000100FL

     *ctx_options |= SSL_OP_NO_TLSv1_2;

 #endif

-    /* FALLTHROUGH */

+    FALLTHROUGH();

   case CURL_SSLVERSION_MAX_TLSv1_2:

 #ifdef TLS1_3_VERSION

     *ctx_options |= SSL_OP_NO_TLSv1_3;

@@ -3174,6 +3177,8 @@ static CURLcode populate_x509_store(struct Curl_cfilter *cf,
   bool imported_native_ca = false;

   bool imported_ca_info_blob = false;

 

+  CURL_TRC_CF(data, cf, "populate_x509_store, path=%s, blob=%d",

+              ssl_cafile? ssl_cafile : "none", !!ca_info_blob);

   if(!store)

     return CURLE_OUT_OF_MEMORY;

 

@@ -4346,6 +4351,20 @@ static CURLcode servercert(struct Curl_cfilter *cf,
     /* don't do this after Session ID reuse */

     result = verifystatus(cf, data);

     if(result) {

+      /* when verifystatus failed, remove the session id from the cache again

+         if present */

+      if(!Curl_ssl_cf_is_proxy(cf)) {

+        void *old_ssl_sessionid = NULL;

+        bool incache;

+        Curl_ssl_sessionid_lock(data);

+        incache = !(Curl_ssl_getsessionid(cf, data, &old_ssl_sessionid, NULL));

+        if(incache) {

+          infof(data, "Remove session ID again from cache");

+          Curl_ssl_delsessionid(data, old_ssl_sessionid);

+        }

+        Curl_ssl_sessionid_unlock(data);

+      }

+

       X509_free(backend->server_cert);

       backend->server_cert = NULL;

       return result;

@@ -4592,10 +4611,10 @@ static ssize_t ossl_send(struct Curl_cfilter *cf,
         ossl_strerror(sslerror, error_buffer, sizeof(error_buffer));

       else if(sockerr)

         Curl_strerror(sockerr, error_buffer, sizeof(error_buffer));

-      else {

-        strncpy(error_buffer, SSL_ERROR_to_str(err), sizeof(error_buffer));

-        error_buffer[sizeof(error_buffer) - 1] = '\0';

-      }

+      else

+        msnprintf(error_buffer, sizeof(error_buffer), "%s",

+                  SSL_ERROR_to_str(err));

+

       failf(data, OSSL_PACKAGE " SSL_write: %s, errno %d",

             error_buffer, sockerr);

       *curlcode = CURLE_SEND_ERROR;

@@ -4688,10 +4707,9 @@ static ssize_t ossl_recv(struct Curl_cfilter *cf,
           ossl_strerror(sslerror, error_buffer, sizeof(error_buffer));

         else if(sockerr && err == SSL_ERROR_SYSCALL)

           Curl_strerror(sockerr, error_buffer, sizeof(error_buffer));

-        else {

-          strncpy(error_buffer, SSL_ERROR_to_str(err), sizeof(error_buffer));

-          error_buffer[sizeof(error_buffer) - 1] = '\0';

-        }

+        else

+          msnprintf(error_buffer, sizeof(error_buffer), "%s",

+                    SSL_ERROR_to_str(err));

         failf(data, OSSL_PACKAGE " SSL_read: %s, errno %d",

               error_buffer, sockerr);

         *curlcode = CURLE_RECV_ERROR;

diff --git a/libs/libcurl/src/vtls/rustls.c b/libs/libcurl/src/vtls/rustls.c
index d30325d098..f0eb1443e6 100644
--- a/libs/libcurl/src/vtls/rustls.c
+++ b/libs/libcurl/src/vtls/rustls.c
@@ -156,7 +156,7 @@ static ssize_t tls_recv_more(struct Curl_cfilter *cf,
     size_t errorlen;

     rustls_error(rresult, errorbuf, sizeof(errorbuf), &errorlen);

     failf(data, "rustls_connection_process_new_packets: %.*s",

-      errorlen, errorbuf);

+      (int)errorlen, errorbuf);

     *err = map_error(rresult);

     return -1;

   }

@@ -225,7 +225,7 @@ cr_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
       char errorbuf[255];

       size_t errorlen;

       rustls_error(rresult, errorbuf, sizeof(errorbuf), &errorlen);

-      failf(data, "rustls_connection_read: %.*s", errorlen, errorbuf);

+      failf(data, "rustls_connection_read: %.*s", (int)errorlen, errorbuf);

       *err = CURLE_READ_ERROR;

       nread = -1;

       goto out;

@@ -301,7 +301,7 @@ cr_send(struct Curl_cfilter *cf, struct Curl_easy *data,
                                       &plainwritten);

     if(rresult != RUSTLS_RESULT_OK) {

       rustls_error(rresult, errorbuf, sizeof(errorbuf), &errorlen);

-      failf(data, "rustls_connection_write: %.*s", errorlen, errorbuf);

+      failf(data, "rustls_connection_write: %.*s", (int)errorlen, errorbuf);

       *err = CURLE_WRITE_ERROR;

       return -1;

     }

@@ -459,7 +459,7 @@ cr_init_backend(struct Curl_cfilter *cf, struct Curl_easy *data,
   }

   if(result != RUSTLS_RESULT_OK) {

     rustls_error(result, errorbuf, sizeof(errorbuf), &errorlen);

-    failf(data, "rustls_client_connection_new: %.*s", errorlen, errorbuf);

+    failf(data, "rustls_client_connection_new: %.*s", (int)errorlen, errorbuf);

     return CURLE_COULDNT_CONNECT;

   }

   rustls_connection_set_userdata(rconn, backend);

@@ -563,8 +563,8 @@ cr_connect_common(struct Curl_cfilter *cf,
       return CURLE_SSL_CONNECT_ERROR;

     }

     if(blocking && 0 == what) {

-      failf(data, "rustls connection timeout after %d ms",

-        socket_check_timeout);

+      failf(data, "rustls connection timeout after %"

+        CURL_FORMAT_TIMEDIFF_T " ms", socket_check_timeout);

       return CURLE_OPERATION_TIMEDOUT;

     }

     if(0 == what) {

diff --git a/libs/libcurl/src/vtls/schannel.c b/libs/libcurl/src/vtls/schannel.c
index c04f968f29..64a31f155d 100644
--- a/libs/libcurl/src/vtls/schannel.c
+++ b/libs/libcurl/src/vtls/schannel.c
@@ -439,6 +439,12 @@ get_cert_location(TCHAR *path, DWORD *store_name, TCHAR **store_path,
   return CURLE_OK;

 }

 #endif

+

+static bool algo(const char *check, char *namep, size_t nlen)

+{

+  return (strlen(check) == nlen) && !strncmp(check, namep, nlen);

+}

+

 static CURLcode

 schannel_acquire_credential_handle(struct Curl_cfilter *cf,

                                    struct Curl_easy *data)

@@ -660,7 +666,7 @@ schannel_acquire_credential_handle(struct Curl_cfilter *cf,
                 cert_showfilename_error);

         else

           failf(data, "schannel: Failed to import cert file %s, "

-                "last error is 0x%x",

+                "last error is 0x%lx",

                 cert_showfilename_error, errorcode);

         return CURLE_SSL_CERTPROBLEM;

       }

@@ -671,7 +677,7 @@ schannel_acquire_credential_handle(struct Curl_cfilter *cf,
 

       if(!client_certs[0]) {

         failf(data, "schannel: Failed to get certificate from file %s"

-              ", last error is 0x%x",

+              ", last error is 0x%lx",

               cert_showfilename_error, GetLastError());

         CertCloseStore(cert_store, 0);

         return CURLE_SSL_CERTPROBLEM;

@@ -684,10 +690,15 @@ schannel_acquire_credential_handle(struct Curl_cfilter *cf,
                       CERT_STORE_OPEN_EXISTING_FLAG | cert_store_name,

                       cert_store_path);

       if(!cert_store) {

-        failf(data, "schannel: Failed to open cert store %x %s, "

-              "last error is 0x%x",

-              cert_store_name, cert_store_path, GetLastError());

+        char *path_utf8 =

+          curlx_convert_tchar_to_UTF8(cert_store_path);

+        failf(data, "schannel: Failed to open cert store %lx %s, "

+              "last error is 0x%lx",

+              cert_store_name,

+              (path_utf8 ? path_utf8 : "(unknown)"),

+              GetLastError());

         free(cert_store_path);

+        curlx_unicodefree(path_utf8);

         curlx_unicodefree(cert_path);

         return CURLE_SSL_CERTPROBLEM;

       }

@@ -790,9 +801,7 @@ schannel_acquire_credential_handle(struct Curl_cfilter *cf,
 

       char *startCur = ciphers13;

       int algCount = 0;

-      char tmp[LONGEST_ALG_ID] = { 0 };

       char *nameEnd;

-      size_t n;

 

       disable_aes_gcm_sha384 = TRUE;

       disable_aes_gcm_sha256 = TRUE;

@@ -801,40 +810,34 @@ schannel_acquire_credential_handle(struct Curl_cfilter *cf,
       disable_aes_ccm_sha256 = TRUE;

 

       while(startCur && (0 != *startCur) && (algCount < remaining_ciphers)) {

+        size_t n;

+        char *namep;

         nameEnd = strchr(startCur, ':');

         n = nameEnd ? (size_t)(nameEnd - startCur) : strlen(startCur);

+        namep = startCur;

 

-        /* reject too-long cipher names */

-        if(n > (LONGEST_ALG_ID - 1)) {

-          failf(data, "schannel: Cipher name too long, not checked");

-          return CURLE_SSL_CIPHER;

-        }

-

-        strncpy(tmp, startCur, n);

-        tmp[n] = 0;

-

-        if(disable_aes_gcm_sha384

-           && !strcmp("TLS_AES_256_GCM_SHA384", tmp)) {

+        if(disable_aes_gcm_sha384 &&

+           algo("TLS_AES_256_GCM_SHA384", namep, n)) {

           disable_aes_gcm_sha384 = FALSE;

         }

         else if(disable_aes_gcm_sha256

-                && !strcmp("TLS_AES_128_GCM_SHA256", tmp)) {

+                && algo("TLS_AES_128_GCM_SHA256", namep, n)) {

           disable_aes_gcm_sha256 = FALSE;

         }

         else if(disable_chacha_poly

-                && !strcmp("TLS_CHACHA20_POLY1305_SHA256", tmp)) {

+                && algo("TLS_CHACHA20_POLY1305_SHA256", namep, n)) {

           disable_chacha_poly = FALSE;

         }

         else if(disable_aes_ccm_8_sha256

-                && !strcmp("TLS_AES_128_CCM_8_SHA256", tmp)) {

+                && algo("TLS_AES_128_CCM_8_SHA256", namep, n)) {

           disable_aes_ccm_8_sha256 = FALSE;

         }

         else if(disable_aes_ccm_sha256

-                && !strcmp("TLS_AES_128_CCM_SHA256", tmp)) {

+                && algo("TLS_AES_128_CCM_SHA256", namep, n)) {

           disable_aes_ccm_sha256 = FALSE;

         }

         else {

-          failf(data, "schannel: Unknown TLS 1.3 cipher: %s", tmp);

+          failf(data, "schannel: Unknown TLS 1.3 cipher: %.*s", (int)n, namep);

           return CURLE_SSL_CIPHER;

         }

 

@@ -1195,9 +1198,8 @@ schannel_connect_step1(struct Curl_cfilter *cf, struct Curl_easy *data)
     cur += proto.len;

 

     *list_len = curlx_uitous(cur - list_start_index);

-    *extension_len = *list_len +

-      (unsigned short)sizeof(unsigned int) +

-      (unsigned short)sizeof(unsigned short);

+    *extension_len = (unsigned int)(*list_len +

+      sizeof(unsigned int) + sizeof(unsigned short));

 

     InitSecBuffer(&inbuf, SECBUFFER_APPLICATION_PROTOCOLS, alpn_buffer, cur);

     InitSecBufferDesc(&inbuf_desc, &inbuf, 1);

@@ -2332,10 +2334,10 @@ schannel_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
     else {

 #ifndef CURL_DISABLE_VERBOSE_STRINGS

       char buffer[STRERROR_LEN];

-#endif

-      *err = CURLE_RECV_ERROR;

       infof(data, "schannel: failed to read data from server: %s",

             Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));

+#endif

+      *err = CURLE_RECV_ERROR;

       goto cleanup;

     }

   }

diff --git a/libs/libcurl/src/vtls/schannel_verify.c b/libs/libcurl/src/vtls/schannel_verify.c
index 0c9c00c16a..743f3b059e 100644
--- a/libs/libcurl/src/vtls/schannel_verify.c
+++ b/libs/libcurl/src/vtls/schannel_verify.c
@@ -172,7 +172,7 @@ static CURLcode add_certs_data_to_store(HCERTSTORE trust_store,
           /* Sanity check that the cert_context object is the right type */

           if(CERT_QUERY_CONTENT_CERT != actual_content_type) {

             failf(data,

-                  "schannel: unexpected content type '%d' when extracting "

+                  "schannel: unexpected content type '%lu' when extracting "

                   "certificate from CA file '%s'",

                   actual_content_type, ca_file_text);

             result = CURLE_SSL_CACERT_BADFILE;

@@ -753,7 +753,7 @@ CURLcode Curl_verify_certificate(struct Curl_cfilter *cf,
           failf(data, "schannel: CertGetCertificateChain trust error"

                 " CERT_TRUST_REVOCATION_STATUS_UNKNOWN");

         else

-          failf(data, "schannel: CertGetCertificateChain error mask: 0x%08x",

+          failf(data, "schannel: CertGetCertificateChain error mask: 0x%08lx",

                 dwTrustErrorMask);

         result = CURLE_PEER_FAILED_VERIFICATION;

       }

diff --git a/libs/libcurl/src/vtls/sectransp.c b/libs/libcurl/src/vtls/sectransp.c
index 26b673016e..eb43d08c5b 100644
--- a/libs/libcurl/src/vtls/sectransp.c
+++ b/libs/libcurl/src/vtls/sectransp.c
@@ -906,7 +906,6 @@ static OSStatus sectransp_bio_cf_out_write(SSLConnectionRef connection,
   return rtn;

 }

 

-#ifndef CURL_DISABLE_VERBOSE_STRINGS

 CF_INLINE const char *TLSCipherNameForNumber(SSLCipherSuite cipher)

 {

   /* The first ciphers in the ciphertable are continuous. Here we do small

@@ -925,7 +924,6 @@ CF_INLINE const char *TLSCipherNameForNumber(SSLCipherSuite cipher)
   }

   return ciphertable[SSL_NULL_WITH_NULL_NULL].name;

 }

-#endif /* !CURL_DISABLE_VERBOSE_STRINGS */

 

 #if CURL_BUILD_MAC

 CF_INLINE void GetDarwinVersionNumber(int *major, int *minor)

@@ -2369,19 +2367,15 @@ static CURLcode verify_cert(struct Curl_cfilter *cf,
                             const struct curl_blob *ca_info_blob,

                             SSLContextRef ctx)

 {

-  int result;

+  CURLcode result;

   unsigned char *certbuf;

   size_t buflen;

+  bool free_certbuf = FALSE;

 

   if(ca_info_blob) {

     CURL_TRC_CF(data, cf, "verify_peer, CA from config blob");

-    certbuf = (unsigned char *)malloc(ca_info_blob->len + 1);

-    if(!certbuf) {

-      return CURLE_OUT_OF_MEMORY;

-    }

+    certbuf = ca_info_blob->data;

     buflen = ca_info_blob->len;

-    memcpy(certbuf, ca_info_blob->data, ca_info_blob->len);

-    certbuf[ca_info_blob->len]='\0';

   }

   else if(cafile) {

     CURL_TRC_CF(data, cf, "verify_peer, CA from file '%s'", cafile);

@@ -2389,12 +2383,14 @@ static CURLcode verify_cert(struct Curl_cfilter *cf,
       failf(data, "SSL: failed to read or invalid CA certificate");

       return CURLE_SSL_CACERT_BADFILE;

     }

+    free_certbuf = TRUE;

   }

   else

     return CURLE_SSL_CACERT_BADFILE;

 

   result = verify_cert_buf(cf, data, certbuf, buflen, ctx);

-  free(certbuf);

+  if(free_certbuf)

+    free(certbuf);

   return result;

 }

 

diff --git a/libs/libcurl/src/vtls/vtls.c b/libs/libcurl/src/vtls/vtls.c
index f37907c494..6deb512879 100644
--- a/libs/libcurl/src/vtls/vtls.c
+++ b/libs/libcurl/src/vtls/vtls.c
@@ -883,28 +883,21 @@ CURLcode Curl_ssl_push_certinfo_len(struct Curl_easy *data,
                                     size_t valuelen)

 {

   struct curl_certinfo *ci = &data->info.certs;

-  char *output;

   struct curl_slist *nl;

   CURLcode result = CURLE_OK;

-  size_t labellen = strlen(label);

-  size_t outlen = labellen + 1 + valuelen + 1; /* label:value\0 */

+  struct dynbuf build;

 

-  output = malloc(outlen);

-  if(!output)

-    return CURLE_OUT_OF_MEMORY;

-

-  /* sprintf the label and colon */

-  msnprintf(output, outlen, "%s:", label);

+  Curl_dyn_init(&build, 10000);

 

-  /* memcpy the value (it might not be null-terminated) */

-  memcpy(&output[labellen + 1], value, valuelen);

-

-  /* null-terminate the output */

-  output[labellen + 1 + valuelen] = 0;

+  if(Curl_dyn_add(&build, label) ||

+     Curl_dyn_addn(&build, ":", 1) ||

+     Curl_dyn_addn(&build, value, valuelen))

+    return CURLE_OUT_OF_MEMORY;

 

-  nl = Curl_slist_append_nodup(ci->certinfo[certnum], output);

+  nl = Curl_slist_append_nodup(ci->certinfo[certnum],

+                               Curl_dyn_ptr(&build));

   if(!nl) {

-    free(output);

+    Curl_dyn_free(&build);

     curl_slist_free_all(ci->certinfo[certnum]);

     result = CURLE_OUT_OF_MEMORY;

   }

@@ -1002,7 +995,7 @@ CURLcode Curl_pin_peer_pubkey(struct Curl_easy *data,
   /* only do this if pinnedpubkey starts with "sha256//", length 8 */

   if(strncmp(pinnedpubkey, "sha256//", 8) == 0) {

     CURLcode encode;

-    size_t encodedlen = 0, pinkeylen;

+    size_t encodedlen = 0;

     char *encoded = NULL, *pinkeycopy, *begin_pos, *end_pos;

     unsigned char *sha256sumdigest;

 

@@ -1030,13 +1023,11 @@ CURLcode Curl_pin_peer_pubkey(struct Curl_easy *data,
     infof(data, " public key hash: sha256//%s", encoded);

 

     /* it starts with sha256//, copy so we can modify it */

-    pinkeylen = strlen(pinnedpubkey) + 1;

-    pinkeycopy = malloc(pinkeylen);

+    pinkeycopy = strdup(pinnedpubkey);

     if(!pinkeycopy) {

       Curl_safefree(encoded);

       return CURLE_OUT_OF_MEMORY;

     }

-    memcpy(pinkeycopy, pinnedpubkey, pinkeylen);

     /* point begin_pos to the copy, and start extracting keys */

     begin_pos = pinkeycopy;

     do {

@@ -1422,17 +1413,13 @@ static size_t multissl_version(char *buffer, size_t size)
     backends_len = p - backends;

   }

 

-  if(!size)

-    return 0;

-

-  if(size <= backends_len) {

-    strncpy(buffer, backends, size - 1);

-    buffer[size - 1] = '\0';

-    return size - 1;

+  if(size) {

+    if(backends_len < size)

+      strcpy(buffer, backends);

+    else

+      *buffer = 0; /* did not fit */

   }

-

-  strcpy(buffer, backends);

-  return backends_len;

+  return 0;

 }

 

 static int multissl_setup(const struct Curl_ssl *backend)

@@ -1728,18 +1715,34 @@ static ssize_t ssl_cf_recv(struct Curl_cfilter *cf,
 {

   struct cf_call_data save;

   ssize_t nread;

+  size_t ntotal = 0;

 

   CF_DATA_SAVE(save, cf, data);

   *err = CURLE_OK;

-  nread = Curl_ssl->recv_plain(cf, data, buf, len, err);

-  if(nread > 0) {

-    DEBUGASSERT((size_t)nread <= len);

-  }

-  else if(nread == 0) {

-    /* eof */

+  /* Do receive until we fill the buffer somehwhat or EGAIN, error or EOF */

+  while(!ntotal || (len - ntotal) > (4*1024)) {

     *err = CURLE_OK;

+    nread = Curl_ssl->recv_plain(cf, data, buf + ntotal, len - ntotal, err);

+    if(nread < 0) {

+      if(*err == CURLE_AGAIN && ntotal > 0) {

+        /* we EAGAINed after having reed data, return the success amount */

+        *err = CURLE_OK;

+        break;

+      }

+      /* we have a an error to report */

+      goto out;

+    }

+    else if(nread == 0) {

+      /* eof */

+      break;

+    }

+    ntotal += (size_t)nread;

+    DEBUGASSERT((size_t)ntotal <= len);

   }

-  CURL_TRC_CF(data, cf, "cf_recv(len=%zu) -> %zd, %d", len, nread, *err);

+  nread = (ssize_t)ntotal;

+out:

+  CURL_TRC_CF(data, cf, "cf_recv(len=%zu) -> %zd, %d", len,

+              nread, *err);

   CF_DATA_RESTORE(cf, save);

   return nread;

 }

@@ -1855,6 +1858,8 @@ struct Curl_cftype Curl_cft_ssl = {
   ssl_cf_query,

 };

 

+#ifndef CURL_DISABLE_PROXY

+

 struct Curl_cftype Curl_cft_ssl_proxy = {

   "SSL-PROXY",

   CF_TYPE_SSL,

@@ -1873,6 +1878,8 @@ struct Curl_cftype Curl_cft_ssl_proxy = {
   Curl_cf_def_query,

 };

 

+#endif /* !CURL_DISABLE_PROXY */

+

 static CURLcode cf_ssl_create(struct Curl_cfilter **pcf,

                               struct Curl_easy *data,

                               struct connectdata *conn)

@@ -1980,8 +1987,12 @@ bool Curl_ssl_supports(struct Curl_easy *data, int option)
 static struct Curl_cfilter *get_ssl_filter(struct Curl_cfilter *cf)

 {

   for(; cf; cf = cf->next) {

-    if(cf->cft == &Curl_cft_ssl || cf->cft == &Curl_cft_ssl_proxy)

+    if(cf->cft == &Curl_cft_ssl)

+      return cf;

+#ifndef CURL_DISABLE_PROXY

+    if(cf->cft == &Curl_cft_ssl_proxy)

       return cf;

+#endif

   }

   return NULL;

 }

@@ -2027,7 +2038,12 @@ CURLcode Curl_ssl_cfilter_remove(struct Curl_easy *data,
 

 bool Curl_ssl_cf_is_proxy(struct Curl_cfilter *cf)

 {

+#ifndef CURL_DISABLE_PROXY

   return (cf->cft == &Curl_cft_ssl_proxy);

+#else

+  (void)cf;

+  return FALSE;

+#endif

 }

 

 struct ssl_config_data *

diff --git a/libs/libcurl/src/vtls/vtls.h b/libs/libcurl/src/vtls/vtls.h
index 111d17f32c..0bfefd0502 100644
--- a/libs/libcurl/src/vtls/vtls.h
+++ b/libs/libcurl/src/vtls/vtls.h
@@ -228,7 +228,9 @@ struct ssl_primary_config *
   Curl_ssl_cf_get_primary_config(struct Curl_cfilter *cf);

 

 extern struct Curl_cftype Curl_cft_ssl;

+#ifndef CURL_DISABLE_PROXY

 extern struct Curl_cftype Curl_cft_ssl_proxy;

+#endif

 

 #else /* if not USE_SSL */

 

diff --git a/libs/libcurl/src/vtls/wolfssl.c b/libs/libcurl/src/vtls/wolfssl.c
index 32681520a0..349d077ec4 100644
--- a/libs/libcurl/src/vtls/wolfssl.c
+++ b/libs/libcurl/src/vtls/wolfssl.c
@@ -583,12 +583,25 @@ wolfssl_connect_step1(struct Curl_cfilter *cf, struct Curl_easy *data)
   if(ssl_config->primary.clientcert && ssl_config->key) {

     int file_type = do_file_type(ssl_config->cert_type);

 

-    if(wolfSSL_CTX_use_certificate_file(backend->ctx,

-                                        ssl_config->primary.clientcert,

-                                        file_type) != 1) {

-      failf(data, "unable to use client certificate (no key or wrong pass"

-            " phrase?)");

-      return CURLE_SSL_CONNECT_ERROR;

+    if(file_type == WOLFSSL_FILETYPE_PEM) {

+      if(wolfSSL_CTX_use_certificate_chain_file(backend->ctx,

+                                                ssl_config->primary.clientcert)

+         != 1) {

+        failf(data, "unable to use client certificate");

+        return CURLE_SSL_CONNECT_ERROR;

+      }

+    }

+    else if(file_type == WOLFSSL_FILETYPE_ASN1) {

+      if(wolfSSL_CTX_use_certificate_file(backend->ctx,

+                                          ssl_config->primary.clientcert,

+                                          file_type) != 1) {

+        failf(data, "unable to use client certificate");

+        return CURLE_SSL_CONNECT_ERROR;

+      }

+    }

+    else {

+      failf(data, "unknown cert type");

+      return CURLE_BAD_FUNCTION_ARGUMENT;

     }

 

     file_type = do_file_type(ssl_config->key_type);

@@ -1084,9 +1097,7 @@ static ssize_t wolfssl_recv(struct Curl_cfilter *cf,
       *curlcode = CURLE_OK;

       return 0;

     case SSL_ERROR_NONE:

-      /* FALLTHROUGH */

     case SSL_ERROR_WANT_READ:

-      /* FALLTHROUGH */

     case SSL_ERROR_WANT_WRITE:

       /* there's data pending, re-invoke wolfSSL_read() */

       CURL_TRC_CF(data, cf, "wolfssl_recv(len=%zu) -> AGAIN", blen);

diff --git a/libs/libcurl/src/vtls/x509asn1.c b/libs/libcurl/src/vtls/x509asn1.c
index 0ce971c7ba..50a5fb5e9f 100644
--- a/libs/libcurl/src/vtls/x509asn1.c
+++ b/libs/libcurl/src/vtls/x509asn1.c
@@ -97,6 +97,11 @@
 #define CURL_ASN1_CHARACTER_STRING      29

 #define CURL_ASN1_BMP_STRING            30

 

+/* Max sixes */

+

+#define MAX_X509_STR  10000

+#define MAX_X509_CERT 100000

+

 #ifdef WANT_EXTRACT_CERTINFO

 /* ASN.1 OID table entry. */

 struct Curl_OID {

@@ -255,61 +260,61 @@ static const struct Curl_OID *searchOID(const char *oid)
 }

 

 /*

- * Convert an ASN.1 Boolean value into its string representation.  Return the

- * dynamically allocated string, or NULL if source is not an ASN.1 Boolean

- * value.

+ * Convert an ASN.1 Boolean value into its string representation.

+ *

+ * Return error code.

  */

 

-static const char *bool2str(const char *beg, const char *end)

+static CURLcode bool2str(struct dynbuf *store,

+                         const char *beg, const char *end)

 {

   if(end - beg != 1)

-    return NULL;

-  return strdup(*beg? "TRUE": "FALSE");

+    return CURLE_BAD_FUNCTION_ARGUMENT;

+  return Curl_dyn_add(store, *beg? "TRUE": "FALSE");

 }

 

 /*

  * Convert an ASN.1 octet string to a printable string.

- * Return the dynamically allocated string, or NULL if an error occurs.

+ *

+ * Return error code.

  */

-static const char *octet2str(const char *beg, const char *end)

+static CURLcode octet2str(struct dynbuf *store,

+                          const char *beg, const char *end)

 {

-  struct dynbuf buf;

-  CURLcode result;

-

-  Curl_dyn_init(&buf, 3 * CURL_ASN1_MAX + 1);

-  result = Curl_dyn_addn(&buf, "", 0);

+  CURLcode result = CURLE_OK;

 

   while(!result && beg < end)

-    result = Curl_dyn_addf(&buf, "%02x:", (unsigned char) *beg++);

+    result = Curl_dyn_addf(store, "%02x:", (unsigned char) *beg++);

 

-  return Curl_dyn_ptr(&buf);

+  return result;

 }

 

-static const char *bit2str(const char *beg, const char *end)

+static CURLcode bit2str(struct dynbuf *store,

+                        const char *beg, const char *end)

 {

-  /* Convert an ASN.1 bit string to a printable string.

-     Return the dynamically allocated string, or NULL if an error occurs. */

+  /* Convert an ASN.1 bit string to a printable string. */

 

   if(++beg > end)

-    return NULL;

-  return octet2str(beg, end);

+    return CURLE_BAD_FUNCTION_ARGUMENT;

+  return octet2str(store, beg, end);

 }

 

 /*

  * Convert an ASN.1 integer value into its string representation.

- * Return the dynamically allocated string, or NULL if source is not an

- * ASN.1 integer value.

+ *

+ * Returns error.

  */

-static const char *int2str(const char *beg, const char *end)

+static CURLcode int2str(struct dynbuf *store,

+                        const char *beg, const char *end)

 {

   unsigned int val = 0;

   size_t n = end - beg;

 

   if(!n)

-    return NULL;

+    return CURLE_BAD_FUNCTION_ARGUMENT;

 

   if(n > 4)

-    return octet2str(beg, end);

+    return octet2str(store, beg, end);

 

   /* Represent integers <= 32-bit as a single value. */

   if(*beg & 0x80)

@@ -318,25 +323,24 @@ static const char *int2str(const char *beg, const char *end)
   do

     val = (val << 8) | *(const unsigned char *) beg++;

   while(beg < end);

-  return curl_maprintf("%s%x", val >= 10? "0x": "", val);

+  return Curl_dyn_addf(store, "%s%x", val >= 10? "0x": "", val);

 }

 

 /*

- * Perform a lazy conversion from an ASN.1 typed string to UTF8. Allocate the

- * destination buffer dynamically. The allocation size will normally be too

- * large: this is to avoid buffer overflows.

- * Terminate the string with a nul byte and return the converted

- * string length.

+ * Convert from an ASN.1 typed string to UTF8.

+ *

+ * The result is stored in a dynbuf that is inited by the user of this

+ * function.

+ *

+ * Returns error.

  */

-static ssize_t

-utf8asn1str(char **to, int type, const char *from, const char *end)

+static CURLcode

+utf8asn1str(struct dynbuf *to, int type, const char *from, const char *end)

 {

   size_t inlength = end - from;

   int size = 1;

-  size_t outlength;

-  char *buf;

+  CURLcode result = CURLE_OK;

 

-  *to = NULL;

   switch(type) {

   case CURL_ASN1_BMP_STRING:

     size = 2;

@@ -352,133 +356,85 @@ utf8asn1str(char **to, int type, const char *from, const char *end)
   case CURL_ASN1_UTF8_STRING:

     break;

   default:

-    return -1;  /* Conversion not supported. */

+    return CURLE_BAD_FUNCTION_ARGUMENT;  /* Conversion not supported. */

   }

 

   if(inlength % size)

-    return -1;  /* Length inconsistent with character size. */

-  if(inlength / size > (SIZE_T_MAX - 1) / 4)

-    return -1;  /* Too big. */

-  buf = malloc(4 * (inlength / size) + 1);

-  if(!buf)

-    return -1;  /* Not enough memory. */

+    /* Length inconsistent with character size. */

+    return CURLE_BAD_FUNCTION_ARGUMENT;

 

   if(type == CURL_ASN1_UTF8_STRING) {

     /* Just copy. */

-    outlength = inlength;

-    if(outlength)

-      memcpy(buf, from, outlength);

+    if(inlength)

+      result = Curl_dyn_addn(to, from, inlength);

   }

   else {

-    for(outlength = 0; from < end;) {

-      int charsize;

-      unsigned int wc;

+    while(!result && (from < end)) {

+      char buf[4]; /* decode buffer */

+      int charsize = 1;

+      unsigned int wc = 0;

 

-      wc = 0;

       switch(size) {

       case 4:

         wc = (wc << 8) | *(const unsigned char *) from++;

         wc = (wc << 8) | *(const unsigned char *) from++;

-        /* FALLTHROUGH */

+        FALLTHROUGH();

       case 2:

         wc = (wc << 8) | *(const unsigned char *) from++;

-        /* FALLTHROUGH */

+        FALLTHROUGH();

       default: /* case 1: */

         wc = (wc << 8) | *(const unsigned char *) from++;

       }

-      charsize = 1;

       if(wc >= 0x00000080) {

         if(wc >= 0x00000800) {

           if(wc >= 0x00010000) {

             if(wc >= 0x00200000) {

               free(buf);

-              return -1;        /* Invalid char. size for target encoding. */

+              /* Invalid char. size for target encoding. */

+              return CURLE_WEIRD_SERVER_REPLY;

             }

-            buf[outlength + 3] = (char) (0x80 | (wc & 0x3F));

+            buf[3] = (char) (0x80 | (wc & 0x3F));

             wc = (wc >> 6) | 0x00010000;

             charsize++;

           }

-          buf[outlength + 2] = (char) (0x80 | (wc & 0x3F));

+          buf[2] = (char) (0x80 | (wc & 0x3F));

           wc = (wc >> 6) | 0x00000800;

           charsize++;

         }

-        buf[outlength + 1] = (char) (0x80 | (wc & 0x3F));

+        buf[1] = (char) (0x80 | (wc & 0x3F));

         wc = (wc >> 6) | 0x000000C0;

         charsize++;

       }

-      buf[outlength] = (char) wc;

-      outlength += charsize;

+      buf[0] = (char) wc;

+      result = Curl_dyn_addn(to, buf, charsize);

     }

   }

-  buf[outlength] = '\0';

-  *to = buf;

-  return outlength;

-}

-

-/*

- * Convert an ASN.1 String into its UTF-8 string representation.

- * Return the dynamically allocated string, or NULL if an error occurs.

- */

-static const char *string2str(int type, const char *beg, const char *end)

-{

-  char *buf;

-  if(utf8asn1str(&buf, type, beg, end) < 0)

-    return NULL;

-  return buf;

-}

-

-/*

- * Decimal ASCII encode unsigned integer `x' into the buflen sized buffer at

- * buf.  Return the total number of encoded digits, even if larger than

- * `buflen'.

- */

-static size_t encodeUint(char *buf, size_t buflen, unsigned int x)

-{

-  size_t i = 0;

-  unsigned int y = x / 10;

-

-  if(y) {

-    i = encodeUint(buf, buflen, y);

-    x -= y * 10;

-  }

-  if(i < buflen)

-    buf[i] = (char) ('0' + x);

-  i++;

-  if(i < buflen)

-    buf[i] = '\0';      /* Store a terminator if possible. */

-  return i;

+  return result;

 }

 

 /*

  * Convert an ASN.1 OID into its dotted string representation.

- * Store the result in th `n'-byte buffer at `buf'.

- * Return the converted string length, or 0 on errors.

+ *

+ * Return error code.

  */

-static size_t encodeOID(char *buf, size_t buflen,

-                        const char *beg, const char *end)

+static CURLcode encodeOID(struct dynbuf *store,

+                          const char *beg, const char *end)

 {

-  size_t i;

   unsigned int x;

   unsigned int y;

+  CURLcode result = CURLE_OK;

 

   /* Process the first two numbers. */

   y = *(const unsigned char *) beg++;

   x = y / 40;

   y -= x * 40;

-  i = encodeUint(buf, buflen, x);

-  if(i < buflen)

-    buf[i] = '.';

-  i++;

-  if(i >= buflen)

-    i += encodeUint(NULL, 0, y);

-  else

-    i += encodeUint(buf + i, buflen - i, y);

+

+  result = Curl_dyn_addf(store, "%u.%u", x, y);

+  if(result)

+    return result;

 

   /* Process the trailing numbers. */

   while(beg < end) {

-    if(i < buflen)

-      buf[i] = '.';

-    i++;

     x = 0;

     do {

       if(x & 0xFF000000)

@@ -486,46 +442,42 @@ static size_t encodeOID(char *buf, size_t buflen,
       y = *(const unsigned char *) beg++;

       x = (x << 7) | (y & 0x7F);

     } while(y & 0x80);

-    if(i >= buflen)

-      i += encodeUint(NULL, 0, x);

-    else

-      i += encodeUint(buf + i, buflen - i, x);

+    result = Curl_dyn_addf(store, ".%u", x);

   }

-  if(i < buflen)

-    buf[i] = '\0';

-  return i;

+  return result;

 }

 

 /*

  * Convert an ASN.1 OID into its dotted or symbolic string representation.

- * Return the dynamically allocated string, or NULL if an error occurs.

+ *

+ * Return error code.

  */

 

-static const char *OID2str(const char *beg, const char *end, bool symbolic)

+static CURLcode OID2str(struct dynbuf *store,

+                        const char *beg, const char *end, bool symbolic)

 {

-  char *buf = NULL;

+  CURLcode result = CURLE_OK;

   if(beg < end) {

-    size_t buflen = encodeOID(NULL, 0, beg, end);

-    if(buflen) {

-      buf = malloc(buflen + 1); /* one extra for the zero byte */

-      if(buf) {

-        encodeOID(buf, buflen, beg, end);

-        buf[buflen] = '\0';

-

-        if(symbolic) {

-          const struct Curl_OID *op = searchOID(buf);

-          if(op) {

-            free(buf);

-            buf = strdup(op->textoid);

-          }

-        }

+    if(symbolic) {

+      struct dynbuf buf;

+      Curl_dyn_init(&buf, MAX_X509_STR);

+      result = encodeOID(&buf, beg, end);

+

+      if(!result) {

+        const struct Curl_OID *op = searchOID(Curl_dyn_ptr(&buf));

+        if(op)

+          result = Curl_dyn_add(store, op->textoid);

+        Curl_dyn_free(&buf);

       }

     }

+    else

+      result = encodeOID(store, beg, end);

   }

-  return buf;

+  return result;

 }

 

-static const char *GTime2str(const char *beg, const char *end)

+static CURLcode GTime2str(struct dynbuf *store,

+                          const char *beg, const char *end)

 {

   const char *tzp;

   const char *fracp;

@@ -548,12 +500,12 @@ static const char *GTime2str(const char *beg, const char *end)
     break;

   case 2:

     sec1 = fracp[-2];

-    /* FALLTHROUGH */

+    FALLTHROUGH();

   case 1:

     sec2 = fracp[-1];

     break;

   default:

-    return NULL;

+    return CURLE_BAD_FUNCTION_ARGUMENT;

   }

 

   /* Scan for timezone, measure fractional seconds. */

@@ -582,7 +534,8 @@ static const char *GTime2str(const char *beg, const char *end)
   }

 

   tzl = end - tzp;

-  return curl_maprintf("%.4s-%.2s-%.2s %.2s:%.2s:%c%c%s%.*s%s%.*s",

+  return Curl_dyn_addf(store,

+                       "%.4s-%.2s-%.2s %.2s:%.2s:%c%c%s%.*s%s%.*s",

                        beg, beg + 4, beg + 6,

                        beg + 8, beg + 10, sec1, sec2,

                        fracl? ".": "", (int)fracl, fracp,

@@ -590,10 +543,12 @@ static const char *GTime2str(const char *beg, const char *end)
 }

 

 /*

- *  Convert an ASN.1 UTC time to a printable string.

- * Return the dynamically allocated string, or NULL if an error occurs.

+ * Convert an ASN.1 UTC time to a printable string.

+ *

+ * Return error code.

  */

-static const char *UTime2str(const char *beg, const char *end)

+static CURLcode UTime2str(struct dynbuf *store,

+                             const char *beg, const char *end)

 {

   const char *tzp;

   size_t tzl;

@@ -606,15 +561,16 @@ static const char *UTime2str(const char *beg, const char *end)
   switch(tzp - sec) {

   case 0:

     sec = "00";

+    FALLTHROUGH();

   case 2:

     break;

   default:

-    return NULL;

+    return CURLE_BAD_FUNCTION_ARGUMENT;

   }

 

   /* Process timezone. */

   if(tzp >= end)

-    return NULL;

+    return CURLE_BAD_FUNCTION_ARGUMENT;

   if(*tzp == 'Z') {

     tzp = "GMT";

     end = tzp + 3;

@@ -623,7 +579,7 @@ static const char *UTime2str(const char *beg, const char *end)
     tzp++;

 

   tzl = end - tzp;

-  return curl_maprintf("%u%.2s-%.2s-%.2s %.2s:%.2s:%.2s %.*s",

+  return Curl_dyn_addf(store, "%u%.2s-%.2s-%.2s %.2s:%.2s:%.2s %.*s",

                        20 - (*beg >= '5'), beg, beg + 2, beg + 4,

                        beg + 6, beg + 8, sec,

                        (int)tzl, tzp);

@@ -631,34 +587,45 @@ static const char *UTime2str(const char *beg, const char *end)
 

 /*

  * Convert an ASN.1 element to a printable string.

- * Return the dynamically allocated string, or NULL if an error occurs.

+ *

+ * Return error

  */

-static const char *ASN1tostr(struct Curl_asn1Element *elem, int type)

+static CURLcode ASN1tostr(struct dynbuf *store,

+                          struct Curl_asn1Element *elem, int type)

 {

+  CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;

   if(elem->constructed)

-    return NULL; /* No conversion of structured elements. */

+    return CURLE_OK; /* No conversion of structured elements. */

 

   if(!type)

     type = elem->tag;   /* Type not forced: use element tag as type. */

 

   switch(type) {

   case CURL_ASN1_BOOLEAN:

-    return bool2str(elem->beg, elem->end);

+    result = bool2str(store, elem->beg, elem->end);

+    break;

   case CURL_ASN1_INTEGER:

   case CURL_ASN1_ENUMERATED:

-    return int2str(elem->beg, elem->end);

+    result = int2str(store, elem->beg, elem->end);

+    break;

   case CURL_ASN1_BIT_STRING:

-    return bit2str(elem->beg, elem->end);

+    result = bit2str(store, elem->beg, elem->end);

+    break;

   case CURL_ASN1_OCTET_STRING:

-    return octet2str(elem->beg, elem->end);

+    result = octet2str(store, elem->beg, elem->end);

+    break;

   case CURL_ASN1_NULL:

-    return strdup("");

+    result = Curl_dyn_addn(store, "", 1);

+    break;

   case CURL_ASN1_OBJECT_IDENTIFIER:

-    return OID2str(elem->beg, elem->end, TRUE);

+    result = OID2str(store, elem->beg, elem->end, TRUE);

+    break;

   case CURL_ASN1_UTC_TIME:

-    return UTime2str(elem->beg, elem->end);

+    result = UTime2str(store, elem->beg, elem->end);

+    break;

   case CURL_ASN1_GENERALIZED_TIME:

-    return GTime2str(elem->beg, elem->end);

+    result = GTime2str(store, elem->beg, elem->end);

+    break;

   case CURL_ASN1_UTF8_STRING:

   case CURL_ASN1_NUMERIC_STRING:

   case CURL_ASN1_PRINTABLE_STRING:

@@ -667,87 +634,96 @@ static const char *ASN1tostr(struct Curl_asn1Element *elem, int type)
   case CURL_ASN1_VISIBLE_STRING:

   case CURL_ASN1_UNIVERSAL_STRING:

   case CURL_ASN1_BMP_STRING:

-    return string2str(type, elem->beg, elem->end);

+    result = utf8asn1str(store, type, elem->beg, elem->end);

+    break;

   }

 

-  return NULL;   /* Unsupported. */

+  return result;

 }

 

 /*

- * ASCII encode distinguished name at `dn' into the `buflen'-sized buffer at

- * `buf'.

+ * ASCII encode distinguished name at `dn' into the store dynbuf.

  *

- * Returns the total string length, even if larger than `buflen' or -1 on

- * error.

+ * Returns error.

  */

-static ssize_t encodeDN(char *buf, size_t buflen, struct Curl_asn1Element *dn)

+static CURLcode encodeDN(struct dynbuf *store, struct Curl_asn1Element *dn)

 {

   struct Curl_asn1Element rdn;

   struct Curl_asn1Element atv;

   struct Curl_asn1Element oid;

   struct Curl_asn1Element value;

-  size_t l = 0;

   const char *p1;

   const char *p2;

   const char *p3;

   const char *str;

+  CURLcode result = CURLE_OK;

+  bool added = FALSE;

+  struct dynbuf temp;

+  Curl_dyn_init(&temp, MAX_X509_STR);

 

   for(p1 = dn->beg; p1 < dn->end;) {

     p1 = getASN1Element(&rdn, p1, dn->end);

-    if(!p1)

-      return -1;

+    if(!p1) {

+      result = CURLE_BAD_FUNCTION_ARGUMENT;

+      goto error;

+    }

     for(p2 = rdn.beg; p2 < rdn.end;) {

       p2 = getASN1Element(&atv, p2, rdn.end);

-      if(!p2)

-        return -1;

+      if(!p2) {

+        result = CURLE_BAD_FUNCTION_ARGUMENT;

+        goto error;

+      }

       p3 = getASN1Element(&oid, atv.beg, atv.end);

-      if(!p3)

-        return -1;

-      if(!getASN1Element(&value, p3, atv.end))

-        return -1;

-      str = ASN1tostr(&oid, 0);

-      if(!str)

-        return -1;

+      if(!p3) {

+        result = CURLE_BAD_FUNCTION_ARGUMENT;

+        goto error;

+      }

+      if(!getASN1Element(&value, p3, atv.end)) {

+        result = CURLE_BAD_FUNCTION_ARGUMENT;

+        goto error;

+      }

+      Curl_dyn_reset(&temp);

+      result = ASN1tostr(&temp, &oid, 0);

+      if(result)

+        goto error;

+

+      str = Curl_dyn_ptr(&temp);

 

       /* Encode delimiter.

          If attribute has a short uppercase name, delimiter is ", ". */

-      if(l) {

-        for(p3 = str; ISUPPER(*p3); p3++)

-          ;

-        for(p3 = (*p3 || p3 - str > 2)? "/": ", "; *p3; p3++) {

-          if(l < buflen)

-            buf[l] = *p3;

-          l++;

-        }

+      for(p3 = str; ISUPPER(*p3); p3++)

+        ;

+      if(added) {

+        if(p3 - str > 2)

+          result = Curl_dyn_addn(store, "/", 1);

+        else

+          result = Curl_dyn_addn(store, ", ", 2);

+        if(result)

+          goto error;

       }

 

       /* Encode attribute name. */

-      for(p3 = str; *p3; p3++) {

-        if(l < buflen)

-          buf[l] = *p3;

-        l++;

-      }

-      free((char *) str);

+      result = Curl_dyn_add(store, str);

+      if(result)

+        goto error;

 

       /* Generate equal sign. */

-      if(l < buflen)

-        buf[l] = '=';

-      l++;

+      result = Curl_dyn_addn(store, "=", 1);

+      if(result)

+        goto error;

 

       /* Generate value. */

-      str = ASN1tostr(&value, 0);

-      if(!str)

-        return -1;

-      for(p3 = str; *p3; p3++) {

-        if(l < buflen)

-          buf[l] = *p3;

-        l++;

-      }

-      free((char *) str);

+      result = ASN1tostr(store, &value, 0);

+      if(result)

+        goto error;

+      Curl_dyn_reset(&temp);

+      added = TRUE; /* use separator for next */

     }

   }

+error:

+  Curl_dyn_free(&temp);

 

-  return l;

+  return result;

 }

 

 #endif /* WANT_EXTRACT_CERTINFO */

@@ -876,25 +852,9 @@ int Curl_parseX509(struct Curl_X509certificate *cert,
 

 #ifdef WANT_EXTRACT_CERTINFO

 

-/*

- * Copy at most 64-characters, terminate with a newline and returns the

- * effective number of stored characters.

- */

-static size_t copySubstring(char *to, const char *from)

-{

-  size_t i;

-  for(i = 0; i < 64; i++) {

-    to[i] = *from;

-    if(!*from++)

-      break;

-  }

-

-  to[i++] = '\n';

-  return i;

-}

-

-static const char *dumpAlgo(struct Curl_asn1Element *param,

-                            const char *beg, const char *end)

+static CURLcode dumpAlgo(struct dynbuf *store,

+                         struct Curl_asn1Element *param,

+                         const char *beg, const char *end)

 {

   struct Curl_asn1Element oid;

 

@@ -902,14 +862,16 @@ static const char *dumpAlgo(struct Curl_asn1Element *param,
 

   beg = getASN1Element(&oid, beg, end);

   if(!beg)

-    return NULL;

+    return CURLE_BAD_FUNCTION_ARGUMENT;

   param->header = NULL;

   param->tag = 0;

   param->beg = param->end = end;

-  if(beg < end)

-    if(!getASN1Element(param, beg, end))

-      return NULL;

-  return OID2str(oid.beg, oid.end, TRUE);

+  if(beg < end) {

+    const char *p = getASN1Element(param, beg, end);

+    if(!p)

+      return CURLE_BAD_FUNCTION_ARGUMENT;

+  }

+  return OID2str(store, oid.beg, oid.end, TRUE);

 }

 

 /*

@@ -926,24 +888,47 @@ static CURLcode ssl_push_certinfo(struct Curl_easy *data,
   return Curl_ssl_push_certinfo_len(data, certnum, label, value, valuelen);

 }

 

-/* return 0 on success, 1 on error */

-static int do_pubkey_field(struct Curl_easy *data, int certnum,

-                           const char *label, struct Curl_asn1Element *elem)

+/*

+ * This is a convenience function for push_certinfo_len that takes a

+ * dynbuf value.

+ *

+ * It also does the verbose output if !certnum.

+ */

+static CURLcode ssl_push_certinfo_dyn(struct Curl_easy *data,

+                                      int certnum,

+                                      const char *label,

+                                      struct dynbuf *ptr)

 {

-  const char *output;

-  CURLcode result = CURLE_OK;

+  size_t valuelen = Curl_dyn_len(ptr);

+  char *value = Curl_dyn_ptr(ptr);

+

+  CURLcode result = Curl_ssl_push_certinfo_len(data, certnum, label,

+                                               value, valuelen);

+

+  if(!certnum && !result)

+    infof(data, "   %s: %s", label, value);

+

+  return result;

+}

+

+static CURLcode do_pubkey_field(struct Curl_easy *data, int certnum,

+                                const char *label,

+                                struct Curl_asn1Element *elem)

+{

+  CURLcode result;

+  struct dynbuf out;

+

+  Curl_dyn_init(&out, MAX_X509_STR);

 

   /* Generate a certificate information record for the public key. */

 

-  output = ASN1tostr(elem, 0);

-  if(output) {

+  result = ASN1tostr(&out, elem, 0);

+  if(!result) {

     if(data->set.ssl.certinfo)

-      result = ssl_push_certinfo(data, certnum, label, output);

-    if(!certnum && !result)

-      infof(data, "   %s: %s", label, output);

-    free((char *) output);

+      result = ssl_push_certinfo_dyn(data, certnum, label, &out);

+    Curl_dyn_free(&out);

   }

-  return result ? 1 : 0;

+  return result;

 }

 

 /* return 0 on success, 1 on error */

@@ -964,7 +949,7 @@ static int do_pubkey(struct Curl_easy *data, int certnum,
      */

     const size_t len = ((pubkey->end - pubkey->beg - 2) * 4);

     if(!certnum)

-      infof(data, "   ECC Public Key (%lu bits)", len);

+      infof(data, "   ECC Public Key (%zu bits)", len);

     if(data->set.ssl.certinfo) {

       char q[sizeof(len) * 8 / 3 + 1];

       (void)msnprintf(q, sizeof(q), "%zu", len);

@@ -998,7 +983,7 @@ static int do_pubkey(struct Curl_easy *data, int certnum,
     if(len > 32)

       elem.beg = q;     /* Strip leading zero bytes. */

     if(!certnum)

-      infof(data, "   RSA Public Key (%lu bits)", len);

+      infof(data, "   RSA Public Key (%zu bits)", len);

     if(data->set.ssl.certinfo) {

       char r[sizeof(len) * 8 / 3 + 1];

       msnprintf(r, sizeof(r), "%zu", len);

@@ -1049,24 +1034,12 @@ static int do_pubkey(struct Curl_easy *data, int certnum,
 

 /*

  * Convert an ASN.1 distinguished name into a printable string.

- * Return the dynamically allocated string, or NULL if an error occurs.

+ * Return error.

  */

-static const char *DNtostr(struct Curl_asn1Element *dn)

+static CURLcode DNtostr(struct dynbuf *store,

+                        struct Curl_asn1Element *dn)

 {

-  char *buf = NULL;

-  ssize_t buflen = encodeDN(NULL, 0, dn);

-

-  if(buflen >= 0) {

-    buf = malloc(buflen + 1);

-    if(buf) {

-      if(encodeDN(buf, buflen + 1, dn) == -1) {

-        free(buf);

-        return NULL;

-      }

-      buf[buflen] = '\0';

-    }

-  }

-  return buf;

+  return encodeDN(store, dn);

 }

 

 CURLcode Curl_extract_certinfo(struct Curl_easy *data,

@@ -1076,19 +1049,19 @@ CURLcode Curl_extract_certinfo(struct Curl_easy *data,
 {

   struct Curl_X509certificate cert;

   struct Curl_asn1Element param;

-  const char *ccp;

-  char *cp1;

-  size_t cl1;

-  char *cp2;

+  char *certptr;

+  size_t clen;

+  struct dynbuf out;

   CURLcode result = CURLE_OK;

   unsigned int version;

-  size_t i;

-  size_t j;

+  const char *ptr;

+  int rc;

 

   if(!data->set.ssl.certinfo)

     if(certnum)

       return CURLE_OK;

 

+  Curl_dyn_init(&out, MAX_X509_STR);

   /* Prepare the certificate information for curl_easy_getinfo(). */

 

   /* Extract the certificate ASN.1 elements. */

@@ -1096,135 +1069,126 @@ CURLcode Curl_extract_certinfo(struct Curl_easy *data,
     return CURLE_PEER_FAILED_VERIFICATION;

 

   /* Subject. */

-  ccp = DNtostr(&cert.subject);

-  if(!ccp)

-    return CURLE_OUT_OF_MEMORY;

+  result = DNtostr(&out, &cert.subject);

+  if(result)

+    goto done;

   if(data->set.ssl.certinfo) {

-    result = ssl_push_certinfo(data, certnum, "Subject", ccp);

+    result = ssl_push_certinfo_dyn(data, certnum, "Subject", &out);

     if(result)

-      return result;

+      goto done;

   }

-  if(!certnum)

-    infof(data, "%2d Subject: %s", certnum, ccp);

-  free((char *) ccp);

+  Curl_dyn_reset(&out);

 

   /* Issuer. */

-  ccp = DNtostr(&cert.issuer);

-  if(!ccp)

-    return CURLE_OUT_OF_MEMORY;

+  result = DNtostr(&out, &cert.issuer);

+  if(result)

+    goto done;

   if(data->set.ssl.certinfo) {

-    result = ssl_push_certinfo(data, certnum, "Issuer", ccp);

+    result = ssl_push_certinfo_dyn(data, certnum, "Issuer", &out);

+    if(result)

+      goto done;

   }

-  if(!certnum)

-    infof(data, "   Issuer: %s", ccp);

-  free((char *) ccp);

-  if(result)

-    return result;

+  Curl_dyn_reset(&out);

 

   /* Version (always fits in less than 32 bits). */

   version = 0;

-  for(ccp = cert.version.beg; ccp < cert.version.end; ccp++)

-    version = (version << 8) | *(const unsigned char *) ccp;

+  for(ptr = cert.version.beg; ptr < cert.version.end; ptr++)

+    version = (version << 8) | *(const unsigned char *) ptr;

   if(data->set.ssl.certinfo) {

-    ccp = curl_maprintf("%x", version);

-    if(!ccp)

-      return CURLE_OUT_OF_MEMORY;

-    result = ssl_push_certinfo(data, certnum, "Version", ccp);

-    free((char *) ccp);

+    result = Curl_dyn_addf(&out, "%x", version);

+    if(result)

+      goto done;

+    result = ssl_push_certinfo_dyn(data, certnum, "Version", &out);

     if(result)

-      return result;

+      goto done;

+    Curl_dyn_reset(&out);

   }

-  if(!certnum)

-    infof(data, "   Version: %u (0x%x)", version + 1, version);

 

   /* Serial number. */

-  ccp = ASN1tostr(&cert.serialNumber, 0);

-  if(!ccp)

-    return CURLE_OUT_OF_MEMORY;

-  if(data->set.ssl.certinfo)

-    result = ssl_push_certinfo(data, certnum, "Serial Number", ccp);

-  if(!certnum)

-    infof(data, "   Serial Number: %s", ccp);

-  free((char *) ccp);

+  result = ASN1tostr(&out, &cert.serialNumber, 0);

   if(result)

-    return result;

+    goto done;

+  if(data->set.ssl.certinfo) {

+    result = ssl_push_certinfo_dyn(data, certnum, "Serial Number", &out);

+    if(result)

+      goto done;

+  }

+  Curl_dyn_reset(&out);

 

   /* Signature algorithm .*/

-  ccp = dumpAlgo(&param, cert.signatureAlgorithm.beg,

-                 cert.signatureAlgorithm.end);

-  if(!ccp)

-    return CURLE_OUT_OF_MEMORY;

-  if(data->set.ssl.certinfo)

-    result = ssl_push_certinfo(data, certnum, "Signature Algorithm", ccp);

-  if(!certnum)

-    infof(data, "   Signature Algorithm: %s", ccp);

-  free((char *) ccp);

+  result = dumpAlgo(&out, &param, cert.signatureAlgorithm.beg,

+                    cert.signatureAlgorithm.end);

   if(result)

-    return result;

+    goto done;

+  if(data->set.ssl.certinfo) {

+    result = ssl_push_certinfo_dyn(data, certnum, "Signature Algorithm",

+                                   &out);

+    if(result)

+      goto done;

+  }

+  Curl_dyn_reset(&out);

 

   /* Start Date. */

-  ccp = ASN1tostr(&cert.notBefore, 0);

-  if(!ccp)

-    return CURLE_OUT_OF_MEMORY;

-  if(data->set.ssl.certinfo)

-    result = ssl_push_certinfo(data, certnum, "Start Date", ccp);

-  if(!certnum)

-    infof(data, "   Start Date: %s", ccp);

-  free((char *) ccp);

+  result = ASN1tostr(&out, &cert.notBefore, 0);

   if(result)

-    return result;

+    goto done;

+  if(data->set.ssl.certinfo) {

+    result = ssl_push_certinfo_dyn(data, certnum, "Start Date", &out);

+    if(result)

+      goto done;

+  }

+  Curl_dyn_reset(&out);

 

   /* Expire Date. */

-  ccp = ASN1tostr(&cert.notAfter, 0);

-  if(!ccp)

-    return CURLE_OUT_OF_MEMORY;

-  if(data->set.ssl.certinfo)

-    result = ssl_push_certinfo(data, certnum, "Expire Date", ccp);

-  if(!certnum)

-    infof(data, "   Expire Date: %s", ccp);

-  free((char *) ccp);

+  result = ASN1tostr(&out, &cert.notAfter, 0);

   if(result)

-    return result;

+    goto done;

+  if(data->set.ssl.certinfo) {

+    result = ssl_push_certinfo_dyn(data, certnum, "Expire Date", &out);

+    if(result)

+      goto done;

+  }

+  Curl_dyn_reset(&out);

 

   /* Public Key Algorithm. */

-  ccp = dumpAlgo(&param, cert.subjectPublicKeyAlgorithm.beg,

-                 cert.subjectPublicKeyAlgorithm.end);

-  if(!ccp)

-    return CURLE_OUT_OF_MEMORY;

-  if(data->set.ssl.certinfo)

-    result = ssl_push_certinfo(data, certnum, "Public Key Algorithm",

-                                    ccp);

-  if(!result) {

-    int ret;

-    if(!certnum)

-      infof(data, "   Public Key Algorithm: %s", ccp);

-    ret = do_pubkey(data, certnum, ccp, &param, &cert.subjectPublicKey);

-    if(ret)

-      result = CURLE_OUT_OF_MEMORY; /* the most likely error */

-  }

-  free((char *) ccp);

+  result = dumpAlgo(&out, &param, cert.subjectPublicKeyAlgorithm.beg,

+                    cert.subjectPublicKeyAlgorithm.end);

   if(result)

-    return result;

+    goto done;

+  if(data->set.ssl.certinfo) {

+    result = ssl_push_certinfo_dyn(data, certnum, "Public Key Algorithm",

+                                   &out);

+    if(result)

+      goto done;

+  }

+

+  rc = do_pubkey(data, certnum, Curl_dyn_ptr(&out),

+                 &param, &cert.subjectPublicKey);

+  if(rc) {

+    result = CURLE_OUT_OF_MEMORY; /* the most likely error */

+    goto done;

+  }

+  Curl_dyn_reset(&out);

 

   /* Signature. */

-  ccp = ASN1tostr(&cert.signature, 0);

-  if(!ccp)

-    return CURLE_OUT_OF_MEMORY;

-  if(data->set.ssl.certinfo)

-    result = ssl_push_certinfo(data, certnum, "Signature", ccp);

-  if(!certnum)

-    infof(data, "   Signature: %s", ccp);

-  free((char *) ccp);

+  result = ASN1tostr(&out, &cert.signature, 0);

   if(result)

-    return result;

+    goto done;

+  if(data->set.ssl.certinfo) {

+    result = ssl_push_certinfo_dyn(data, certnum, "Signature", &out);

+    if(result)

+      goto done;

+  }

+  Curl_dyn_reset(&out);

 

   /* Generate PEM certificate. */

   result = Curl_base64_encode(cert.certificate.beg,

                               cert.certificate.end - cert.certificate.beg,

-                              &cp1, &cl1);

+                              &certptr, &clen);

   if(result)

-    return result;

-  /* Compute the number of characters in final certificate string. Format is:

+    goto done;

+

+  /* Generate the final output certificate string. Format is:

      -----BEGIN CERTIFICATE-----\n

      <max 64 base64 characters>\n

      .

@@ -1232,207 +1196,34 @@ CURLcode Curl_extract_certinfo(struct Curl_easy *data,
      .

      -----END CERTIFICATE-----\n

    */

-  i = 28 + cl1 + (cl1 + 64 - 1) / 64 + 26;

-  cp2 = malloc(i + 1);

-  if(!cp2) {

-    free(cp1);

-    return CURLE_OUT_OF_MEMORY;

-  }

-  /* Build the certificate string. */

-  i = copySubstring(cp2, "-----BEGIN CERTIFICATE-----");

-  for(j = 0; j < cl1; j += 64)

-    i += copySubstring(cp2 + i, cp1 + j);

-  i += copySubstring(cp2 + i, "-----END CERTIFICATE-----");

-  cp2[i] = '\0';

-  free(cp1);

-  if(data->set.ssl.certinfo)

-    result = ssl_push_certinfo(data, certnum, "Cert", cp2);

-  if(!certnum)

-    infof(data, "%s", cp2);

-  free(cp2);

-  return result;

-}

 

-#endif /* WANT_EXTRACT_CERTINFO */

-

-#endif /* USE_GNUTLS or USE_WOLFSSL or USE_SCHANNEL or USE_SECTRANSP */

+  Curl_dyn_reset(&out);

 

-#ifdef WANT_VERIFYHOST

-

-static const char *checkOID(const char *beg, const char *end,

-                            const char *oid)

-{

-  struct Curl_asn1Element e;

-  const char *ccp;

-  const char *p;

-  bool matched;

-

-  /* Check if first ASN.1 element at `beg' is the given OID.

-     Return a pointer in the source after the OID if found, else NULL. */

-

-  ccp = getASN1Element(&e, beg, end);

-  if(!ccp || e.tag != CURL_ASN1_OBJECT_IDENTIFIER)

-    return NULL;

-

-  p = OID2str(e.beg, e.end, FALSE);

-  if(!p)

-    return NULL;

-

-  matched = !strcmp(p, oid);

-  free((char *) p);

-  return matched? ccp: NULL;

-}

-

-CURLcode Curl_verifyhost(struct Curl_cfilter *cf,

-                         struct Curl_easy *data,

-                         const char *beg, const char *end)

-{

-  struct ssl_connect_data *connssl = cf->ctx;

-  struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);

-  struct Curl_X509certificate cert;

-  struct Curl_asn1Element dn;

-  struct Curl_asn1Element elem;

-  struct Curl_asn1Element ext;

-  struct Curl_asn1Element name;

-  const char *p;

-  const char *q;

-  char *dnsname;

-  int matched = -1;

-  size_t addrlen = (size_t) -1;

-  ssize_t len;

-  size_t hostlen;

-

-#ifdef ENABLE_IPV6

-  struct in6_addr addr;

-#else

-  struct in_addr addr;

-#endif

-

-  /* Verify that connection server matches info in X509 certificate at

-     `beg'..`end'. */

-

-  if(!conn_config->verifyhost)

-    return CURLE_OK;

-

-  if(Curl_parseX509(&cert, beg, end))

-    return CURLE_PEER_FAILED_VERIFICATION;

-

-  hostlen = strlen(connssl->peer.hostname);

-

-  /* Get the server IP address. */

-#ifdef ENABLE_IPV6

-  if(cf->conn->bits.ipv6_ip &&

-     Curl_inet_pton(AF_INET6, connssl->peer.hostname, &addr))

-    addrlen = sizeof(struct in6_addr);

-  else

-#endif

-  if(Curl_inet_pton(AF_INET, connssl->peer.hostname, &addr))

-    addrlen = sizeof(struct in_addr);

-

-  /* Process extensions. */

-  for(p = cert.extensions.beg; p < cert.extensions.end && matched != 1;) {

-    p = getASN1Element(&ext, p, cert.extensions.end);

-    if(!p)

-      return CURLE_PEER_FAILED_VERIFICATION;

-

-    /* Check if extension is a subjectAlternativeName. */

-    ext.beg = checkOID(ext.beg, ext.end, sanOID);

-    if(ext.beg) {

-      ext.beg = getASN1Element(&elem, ext.beg, ext.end);

-      if(!ext.beg)

-        return CURLE_PEER_FAILED_VERIFICATION;

-      /* Skip critical if present. */

-      if(elem.tag == CURL_ASN1_BOOLEAN) {

-        ext.beg = getASN1Element(&elem, ext.beg, ext.end);

-        if(!ext.beg)

-          return CURLE_PEER_FAILED_VERIFICATION;

-      }

-      /* Parse the octet string contents: is a single sequence. */

-      if(!getASN1Element(&elem, elem.beg, elem.end))

-        return CURLE_PEER_FAILED_VERIFICATION;

-      /* Check all GeneralNames. */

-      for(q = elem.beg; matched != 1 && q < elem.end;) {

-        q = getASN1Element(&name, q, elem.end);

-        if(!q)

-          break;

-        switch(name.tag) {

-        case 2: /* DNS name. */

-          len = utf8asn1str(&dnsname, CURL_ASN1_IA5_STRING,

-                            name.beg, name.end);

-          if(len > 0 && (size_t)len == strlen(dnsname))

-            matched = Curl_cert_hostcheck(dnsname, (size_t)len,

-                                          connssl->peer.hostname, hostlen);

-          else

-            matched = 0;

-          free(dnsname);

-          break;

-

-        case 7: /* IP address. */

-          matched = (size_t)(name.end - name.beg) == addrlen &&

-            !memcmp(&addr, name.beg, addrlen);

-          break;

-        }

-      }

-    }

-  }

-

-  switch(matched) {

-  case 1:

-    /* an alternative name matched the server hostname */

-    infof(data, "  subjectAltName: %s matched", connssl->dispname);

-    return CURLE_OK;

-  case 0:

-    /* an alternative name field existed, but didn't match and then

-       we MUST fail */

-    infof(data, "  subjectAltName does not match %s", connssl->dispname);

-    return CURLE_PEER_FAILED_VERIFICATION;

-  }

-

-  /* Process subject. */

-  name.header = NULL;

-  name.beg = name.end = "";

-  q = cert.subject.beg;

-  /* we have to look to the last occurrence of a commonName in the

-     distinguished one to get the most significant one. */

-  while(q < cert.subject.end) {

-    q = getASN1Element(&dn, q, cert.subject.end);

-    if(!q)

-      break;

-    for(p = dn.beg; p < dn.end;) {

-      p = getASN1Element(&elem, p, dn.end);

-      if(!p)

-        return CURLE_PEER_FAILED_VERIFICATION;

-      /* We have a DN's AttributeTypeAndValue: check it in case it's a CN. */

-      elem.beg = checkOID(elem.beg, elem.end, cnOID);

-      if(elem.beg)

-        name = elem;    /* Latch CN. */

-    }

-  }

-

-  /* Check the CN if found. */

-  if(!getASN1Element(&elem, name.beg, name.end))

-    failf(data, "SSL: unable to obtain common name from peer certificate");

-  else {

-    len = utf8asn1str(&dnsname, elem.tag, elem.beg, elem.end);

-    if(len < 0) {

-      free(dnsname);

-      return CURLE_OUT_OF_MEMORY;

-    }

-    if(strlen(dnsname) != (size_t) len)         /* Nul byte in string ? */

-      failf(data, "SSL: illegal cert name field");

-    else if(Curl_cert_hostcheck((const char *) dnsname,

-                                len, connssl->peer.hostname, hostlen)) {

-      infof(data, "  common name: %s (matched)", dnsname);

-      free(dnsname);

-      return CURLE_OK;

+  /* Build the certificate string. */

+  result = Curl_dyn_add(&out, "-----BEGIN CERTIFICATE-----\n");

+  if(!result) {

+    size_t j = 0;

+

+    while(!result && (j < clen)) {

+      size_t chunksize = (clen - j) > 64 ? 64 : (clen - j);

+      result = Curl_dyn_addn(&out, &certptr[j], chunksize);

+      if(!result)

+        result = Curl_dyn_addn(&out, "\n", 1);

+      j += chunksize;

     }

-    else

-      failf(data, "SSL: certificate subject name '%s' does not match "

-            "target host name '%s'", dnsname, connssl->dispname);

-    free(dnsname);

+    if(!result)

+      result = Curl_dyn_add(&out, "-----END CERTIFICATE-----\n");

   }

+  free(certptr);

+  if(!result)

+    if(data->set.ssl.certinfo)

+      result = ssl_push_certinfo_dyn(data, certnum, "Cert", &out);

 

-  return CURLE_PEER_FAILED_VERIFICATION;

+done:

+  Curl_dyn_free(&out);

+  return result;

 }

 

-#endif /* WANT_VERIFYHOST */

+#endif /* WANT_EXTRACT_CERTINFO */

+

+#endif /* USE_GNUTLS or USE_WOLFSSL or USE_SCHANNEL or USE_SECTRANSP */