Adding in curl and openssl repos

openssl-3.4.2/crypto/err/README.md

@@ -0,0 +1,55 @@
+Adding new libraries
+====================
+
+When adding a new sub-library to OpenSSL, assign it a library number
+`ERR_LIB_XXX`, define a macro `XXXerr()` (both in `err.h`), add its
+name to `ERR_str_libraries[]` (in `crypto/err/err.c`), and add
+`ERR_load_XXX_strings()` to the `ERR_load_crypto_strings()` function
+(in `crypto/err/err_all.c`). Finally, add an entry:
+
+    L      XXX     xxx.h   xxx_err.c
+
+to `crypto/err/openssl.ec`, and add `xxx_err.c` to the `Makefile`.
+Running make errors will then generate a file `xxx_err.c`, and
+add all error codes used in the library to `xxx.h`.
+
+Additionally the library include file must have a certain form.
+Typically it will initially look like this:
+
+    #ifndef HEADER_XXX_H
+    #define HEADER_XXX_H
+
+    #ifdef __cplusplus
+    extern "C" {
+    #endif
+
+    /* Include files */
+
+    #include <openssl/bio.h>
+    #include <openssl/x509.h>
+
+    /* Macros, structures and function prototypes */
+
+
+    /* BEGIN ERROR CODES */
+
+The `BEGIN ERROR CODES` sequence is used by the error code
+generation script as the point to place new error codes, any text
+after this point will be overwritten when make errors is run.
+The closing `#endif` etc will be automatically added by the script.
+
+The generated C error code file `xxx_err.c` will load the header
+files `stdio.h`, `openssl/err.h` and `openssl/xxx.h` so the
+header file must load any additional header files containing any
+definitions it uses.
+
+Adding new error codes
+======================
+
+Instead of manually adding error codes into `crypto/err/openssl.txt`,
+it is recommended to leverage `make update` for error code generation.
+The target will process relevant sources and generate error codes for
+any *used* error codes.
+
+If an error code is added manually into `crypto/err/openssl.txt`,
+subsequent `make update` has no effect.

openssl-3.4.2/crypto/err/build.info

@@ -0,0 +1,3 @@
+LIBS=../../libcrypto
+SOURCE[../../libcrypto]=\
+        err_blocks.c err_mark.c err.c err_all.c err_all_legacy.c err_prn.c err_save.c

openssl-3.4.2/crypto/err/err.c

@@ -0,0 +1,898 @@
+/*
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#define OSSL_FORCE_ERR_STATE
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include "crypto/cryptlib.h"
+#include "internal/err.h"
+#include "crypto/err.h"
+#include <openssl/err.h>
+#include <openssl/crypto.h>
+#include <openssl/buffer.h>
+#include <openssl/bio.h>
+#include <openssl/opensslconf.h>
+#include "internal/thread_once.h"
+#include "crypto/ctype.h"
+#include "internal/constant_time.h"
+#include "internal/e_os.h"
+#include "err_local.h"
+
+/* Forward declaration in case it's not published because of configuration */
+ERR_STATE *ERR_get_state(void);
+
+#ifndef OPENSSL_NO_ERR
+static int err_load_strings(const ERR_STRING_DATA *str);
+#endif
+
+#ifndef OPENSSL_NO_ERR
+static ERR_STRING_DATA ERR_str_libraries[] = {
+    {ERR_PACK(ERR_LIB_NONE, 0, 0), "unknown library"},
+    {ERR_PACK(ERR_LIB_SYS, 0, 0), "system library"},
+    {ERR_PACK(ERR_LIB_BN, 0, 0), "bignum routines"},
+    {ERR_PACK(ERR_LIB_RSA, 0, 0), "rsa routines"},
+    {ERR_PACK(ERR_LIB_DH, 0, 0), "Diffie-Hellman routines"},
+    {ERR_PACK(ERR_LIB_EVP, 0, 0), "digital envelope routines"},
+    {ERR_PACK(ERR_LIB_BUF, 0, 0), "memory buffer routines"},
+    {ERR_PACK(ERR_LIB_OBJ, 0, 0), "object identifier routines"},
+    {ERR_PACK(ERR_LIB_PEM, 0, 0), "PEM routines"},
+    {ERR_PACK(ERR_LIB_DSA, 0, 0), "dsa routines"},
+    {ERR_PACK(ERR_LIB_X509, 0, 0), "x509 certificate routines"},
+    {ERR_PACK(ERR_LIB_ASN1, 0, 0), "asn1 encoding routines"},
+    {ERR_PACK(ERR_LIB_CONF, 0, 0), "configuration file routines"},
+    {ERR_PACK(ERR_LIB_CRYPTO, 0, 0), "common libcrypto routines"},
+    {ERR_PACK(ERR_LIB_EC, 0, 0), "elliptic curve routines"},
+    {ERR_PACK(ERR_LIB_ECDSA, 0, 0), "ECDSA routines"},
+    {ERR_PACK(ERR_LIB_ECDH, 0, 0), "ECDH routines"},
+    {ERR_PACK(ERR_LIB_SSL, 0, 0), "SSL routines"},
+    {ERR_PACK(ERR_LIB_BIO, 0, 0), "BIO routines"},
+    {ERR_PACK(ERR_LIB_PKCS7, 0, 0), "PKCS7 routines"},
+    {ERR_PACK(ERR_LIB_X509V3, 0, 0), "X509 V3 routines"},
+    {ERR_PACK(ERR_LIB_PKCS12, 0, 0), "PKCS12 routines"},
+    {ERR_PACK(ERR_LIB_RAND, 0, 0), "random number generator"},
+    {ERR_PACK(ERR_LIB_DSO, 0, 0), "DSO support routines"},
+    {ERR_PACK(ERR_LIB_TS, 0, 0), "time stamp routines"},
+    {ERR_PACK(ERR_LIB_ENGINE, 0, 0), "engine routines"},
+    {ERR_PACK(ERR_LIB_OCSP, 0, 0), "OCSP routines"},
+    {ERR_PACK(ERR_LIB_UI, 0, 0), "UI routines"},
+    {ERR_PACK(ERR_LIB_FIPS, 0, 0), "FIPS routines"},
+    {ERR_PACK(ERR_LIB_CMS, 0, 0), "CMS routines"},
+    {ERR_PACK(ERR_LIB_CRMF, 0, 0), "CRMF routines"},
+    {ERR_PACK(ERR_LIB_CMP, 0, 0), "CMP routines"},
+    {ERR_PACK(ERR_LIB_HMAC, 0, 0), "HMAC routines"},
+    {ERR_PACK(ERR_LIB_CT, 0, 0), "CT routines"},
+    {ERR_PACK(ERR_LIB_ASYNC, 0, 0), "ASYNC routines"},
+    {ERR_PACK(ERR_LIB_KDF, 0, 0), "KDF routines"},
+    {ERR_PACK(ERR_LIB_OSSL_STORE, 0, 0), "STORE routines"},
+    {ERR_PACK(ERR_LIB_SM2, 0, 0), "SM2 routines"},
+    {ERR_PACK(ERR_LIB_ESS, 0, 0), "ESS routines"},
+    {ERR_PACK(ERR_LIB_PROV, 0, 0), "Provider routines"},
+    {ERR_PACK(ERR_LIB_OSSL_ENCODER, 0, 0), "ENCODER routines"},
+    {ERR_PACK(ERR_LIB_OSSL_DECODER, 0, 0), "DECODER routines"},
+    {ERR_PACK(ERR_LIB_HTTP, 0, 0), "HTTP routines"},
+    {0, NULL},
+};
+
+/*
+ * Should make sure that all ERR_R_ reasons defined in include/openssl/err.h.in
+ * are listed.  For maintainability, please keep all reasons in the same order.
+ */
+static ERR_STRING_DATA ERR_str_reasons[] = {
+    {ERR_R_SYS_LIB, "system lib"},
+    {ERR_R_BN_LIB, "BN lib"},
+    {ERR_R_RSA_LIB, "RSA lib"},
+    {ERR_R_DH_LIB, "DH lib"},
+    {ERR_R_EVP_LIB, "EVP lib"},
+    {ERR_R_BUF_LIB, "BUF lib"},
+    {ERR_R_OBJ_LIB, "OBJ lib"},
+    {ERR_R_PEM_LIB, "PEM lib"},
+    {ERR_R_DSA_LIB, "DSA lib"},
+    {ERR_R_X509_LIB, "X509 lib"},
+    {ERR_R_ASN1_LIB, "ASN1 lib"},
+    {ERR_R_CRYPTO_LIB, "CRYPTO lib"},
+    {ERR_R_EC_LIB, "EC lib"},
+    {ERR_R_BIO_LIB, "BIO lib"},
+    {ERR_R_PKCS7_LIB, "PKCS7 lib"},
+    {ERR_R_X509V3_LIB, "X509V3 lib"},
+    {ERR_R_ENGINE_LIB, "ENGINE lib"},
+    {ERR_R_UI_LIB, "UI lib"},
+    {ERR_R_ECDSA_LIB, "ECDSA lib"},
+    {ERR_R_OSSL_STORE_LIB, "OSSL_STORE lib"},
+    {ERR_R_OSSL_DECODER_LIB, "OSSL_DECODER lib"},
+
+    {ERR_R_FATAL, "fatal"},
+    {ERR_R_MALLOC_FAILURE, "malloc failure"},
+    {ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,
+     "called a function you should not call"},
+    {ERR_R_PASSED_NULL_PARAMETER, "passed a null parameter"},
+    {ERR_R_INTERNAL_ERROR, "internal error"},
+    {ERR_R_DISABLED, "called a function that was disabled at compile-time"},
+    {ERR_R_INIT_FAIL, "init fail"},
+    {ERR_R_PASSED_INVALID_ARGUMENT, "passed invalid argument"},
+    {ERR_R_OPERATION_FAIL, "operation fail"},
+    {ERR_R_INVALID_PROVIDER_FUNCTIONS, "invalid provider functions"},
+    {ERR_R_INTERRUPTED_OR_CANCELLED, "interrupted or cancelled"},
+    {ERR_R_NESTED_ASN1_ERROR, "nested asn1 error"},
+    {ERR_R_MISSING_ASN1_EOS, "missing asn1 eos"},
+    /*
+     * Something is unsupported, exactly what is expressed with additional data
+     */
+    {ERR_R_UNSUPPORTED, "unsupported"},
+    /*
+     * A fetch failed for other reasons than the name to be fetched being
+     * unsupported.
+     */
+    {ERR_R_FETCH_FAILED, "fetch failed"},
+    {ERR_R_INVALID_PROPERTY_DEFINITION, "invalid property definition"},
+    {ERR_R_UNABLE_TO_GET_READ_LOCK, "unable to get read lock"},
+    {ERR_R_UNABLE_TO_GET_WRITE_LOCK, "unable to get write lock"},
+    {0, NULL},
+};
+#endif
+
+static CRYPTO_ONCE err_init = CRYPTO_ONCE_STATIC_INIT;
+static int set_err_thread_local;
+static CRYPTO_THREAD_LOCAL err_thread_local;
+
+static CRYPTO_ONCE err_string_init = CRYPTO_ONCE_STATIC_INIT;
+static CRYPTO_RWLOCK *err_string_lock = NULL;
+
+#ifndef OPENSSL_NO_ERR
+static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *);
+#endif
+
+/*
+ * The internal state
+ */
+
+#ifndef OPENSSL_NO_ERR
+static LHASH_OF(ERR_STRING_DATA) *int_error_hash = NULL;
+#endif
+static int int_err_library_number = ERR_LIB_USER;
+
+typedef enum ERR_GET_ACTION_e {
+    EV_POP, EV_PEEK, EV_PEEK_LAST
+} ERR_GET_ACTION;
+
+static unsigned long get_error_values(ERR_GET_ACTION g,
+                                      const char **file, int *line,
+                                      const char **func, const char **data,
+                                      int *flags);
+
+#ifndef OPENSSL_NO_ERR
+static unsigned long err_string_data_hash(const ERR_STRING_DATA *a)
+{
+    unsigned long ret, l;
+
+    l = a->error;
+    ret = l ^ ERR_GET_LIB(l);
+    return (ret ^ ret % 19 * 13);
+}
+
+static int err_string_data_cmp(const ERR_STRING_DATA *a,
+                               const ERR_STRING_DATA *b)
+{
+    if (a->error == b->error)
+        return 0;
+    return a->error > b->error ? 1 : -1;
+}
+
+static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *d)
+{
+    ERR_STRING_DATA *p = NULL;
+
+    if (!CRYPTO_THREAD_read_lock(err_string_lock))
+        return NULL;
+    p = lh_ERR_STRING_DATA_retrieve(int_error_hash, d);
+    CRYPTO_THREAD_unlock(err_string_lock);
+
+    return p;
+}
+#endif
+
+void OSSL_ERR_STATE_free(ERR_STATE *state)
+{
+    int i;
+
+    if (state == NULL)
+        return;
+    for (i = 0; i < ERR_NUM_ERRORS; i++) {
+        err_clear(state, i, 1);
+    }
+    CRYPTO_free(state, OPENSSL_FILE, OPENSSL_LINE);
+}
+
+DEFINE_RUN_ONCE_STATIC(do_err_strings_init)
+{
+    if (!OPENSSL_init_crypto(OPENSSL_INIT_BASE_ONLY, NULL))
+        return 0;
+    err_string_lock = CRYPTO_THREAD_lock_new();
+    if (err_string_lock == NULL)
+        return 0;
+#ifndef OPENSSL_NO_ERR
+    int_error_hash = lh_ERR_STRING_DATA_new(err_string_data_hash,
+                                            err_string_data_cmp);
+    if (int_error_hash == NULL) {
+        CRYPTO_THREAD_lock_free(err_string_lock);
+        err_string_lock = NULL;
+        return 0;
+    }
+#endif
+    return 1;
+}
+
+void err_cleanup(void)
+{
+    if (set_err_thread_local != 0)
+        CRYPTO_THREAD_cleanup_local(&err_thread_local);
+    CRYPTO_THREAD_lock_free(err_string_lock);
+    err_string_lock = NULL;
+#ifndef OPENSSL_NO_ERR
+    lh_ERR_STRING_DATA_free(int_error_hash);
+    int_error_hash = NULL;
+#endif
+}
+
+#ifndef OPENSSL_NO_ERR
+/*
+ * Legacy; pack in the library.
+ */
+static void err_patch(int lib, ERR_STRING_DATA *str)
+{
+    unsigned long plib = ERR_PACK(lib, 0, 0);
+
+    for (; str->error != 0; str++)
+        str->error |= plib;
+}
+
+/*
+ * Hash in |str| error strings. Assumes the RUN_ONCE was done.
+ */
+static int err_load_strings(const ERR_STRING_DATA *str)
+{
+    if (!CRYPTO_THREAD_write_lock(err_string_lock))
+        return 0;
+    for (; str->error; str++)
+        (void)lh_ERR_STRING_DATA_insert(int_error_hash,
+                                       (ERR_STRING_DATA *)str);
+    CRYPTO_THREAD_unlock(err_string_lock);
+    return 1;
+}
+#endif
+
+int ossl_err_load_ERR_strings(void)
+{
+#ifndef OPENSSL_NO_ERR
+    if (!RUN_ONCE(&err_string_init, do_err_strings_init))
+        return 0;
+
+    err_load_strings(ERR_str_libraries);
+    err_load_strings(ERR_str_reasons);
+#endif
+    return 1;
+}
+
+int ERR_load_strings(int lib, ERR_STRING_DATA *str)
+{
+#ifndef OPENSSL_NO_ERR
+    if (ossl_err_load_ERR_strings() == 0)
+        return 0;
+
+    err_patch(lib, str);
+    err_load_strings(str);
+#endif
+
+    return 1;
+}
+
+int ERR_load_strings_const(const ERR_STRING_DATA *str)
+{
+#ifndef OPENSSL_NO_ERR
+    if (ossl_err_load_ERR_strings() == 0)
+        return 0;
+    err_load_strings(str);
+#endif
+
+    return 1;
+}
+
+int ERR_unload_strings(int lib, ERR_STRING_DATA *str)
+{
+#ifndef OPENSSL_NO_ERR
+    if (!RUN_ONCE(&err_string_init, do_err_strings_init))
+        return 0;
+
+    if (!CRYPTO_THREAD_write_lock(err_string_lock))
+        return 0;
+    /*
+     * We don't need to ERR_PACK the lib, since that was done (to
+     * the table) when it was loaded.
+     */
+    for (; str->error; str++)
+        (void)lh_ERR_STRING_DATA_delete(int_error_hash, str);
+    CRYPTO_THREAD_unlock(err_string_lock);
+#endif
+
+    return 1;
+}
+
+void err_free_strings_int(void)
+{
+    /* obsolete */
+}
+
+/********************************************************/
+
+void ERR_clear_error(void)
+{
+    int i;
+    ERR_STATE *es;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return;
+
+    for (i = 0; i < ERR_NUM_ERRORS; i++) {
+        err_clear(es, i, 0);
+    }
+    es->top = es->bottom = 0;
+}
+
+unsigned long ERR_get_error(void)
+{
+    return get_error_values(EV_POP, NULL, NULL, NULL, NULL, NULL);
+}
+
+unsigned long ERR_get_error_all(const char **file, int *line,
+                                const char **func,
+                                const char **data, int *flags)
+{
+    return get_error_values(EV_POP, file, line, func, data, flags);
+}
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+unsigned long ERR_get_error_line(const char **file, int *line)
+{
+    return get_error_values(EV_POP, file, line, NULL, NULL, NULL);
+}
+
+unsigned long ERR_get_error_line_data(const char **file, int *line,
+                                      const char **data, int *flags)
+{
+    return get_error_values(EV_POP, file, line, NULL, data, flags);
+}
+#endif
+
+unsigned long ERR_peek_error(void)
+{
+    return get_error_values(EV_PEEK, NULL, NULL, NULL, NULL, NULL);
+}
+
+unsigned long ERR_peek_error_line(const char **file, int *line)
+{
+    return get_error_values(EV_PEEK, file, line, NULL, NULL, NULL);
+}
+
+unsigned long ERR_peek_error_func(const char **func)
+{
+    return get_error_values(EV_PEEK, NULL, NULL, func, NULL, NULL);
+}
+
+unsigned long ERR_peek_error_data(const char **data, int *flags)
+{
+    return get_error_values(EV_PEEK, NULL, NULL, NULL, data, flags);
+}
+
+unsigned long ERR_peek_error_all(const char **file, int *line,
+                                 const char **func,
+                                 const char **data, int *flags)
+{
+    return get_error_values(EV_PEEK, file, line, func, data, flags);
+}
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+unsigned long ERR_peek_error_line_data(const char **file, int *line,
+                                       const char **data, int *flags)
+{
+    return get_error_values(EV_PEEK, file, line, NULL, data, flags);
+}
+#endif
+
+unsigned long ERR_peek_last_error(void)
+{
+    return get_error_values(EV_PEEK_LAST, NULL, NULL, NULL, NULL, NULL);
+}
+
+unsigned long ERR_peek_last_error_line(const char **file, int *line)
+{
+    return get_error_values(EV_PEEK_LAST, file, line, NULL, NULL, NULL);
+}
+
+unsigned long ERR_peek_last_error_func(const char **func)
+{
+    return get_error_values(EV_PEEK_LAST, NULL, NULL, func, NULL, NULL);
+}
+
+unsigned long ERR_peek_last_error_data(const char **data, int *flags)
+{
+    return get_error_values(EV_PEEK_LAST, NULL, NULL, NULL, data, flags);
+}
+
+unsigned long ERR_peek_last_error_all(const char **file, int *line,
+                                      const char **func,
+                                      const char **data, int *flags)
+{
+    return get_error_values(EV_PEEK_LAST, file, line, func, data, flags);
+}
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+unsigned long ERR_peek_last_error_line_data(const char **file, int *line,
+                                            const char **data, int *flags)
+{
+    return get_error_values(EV_PEEK_LAST, file, line, NULL, data, flags);
+}
+#endif
+
+static unsigned long get_error_values(ERR_GET_ACTION g,
+                                      const char **file, int *line,
+                                      const char **func,
+                                      const char **data, int *flags)
+{
+    int i = 0;
+    ERR_STATE *es;
+    unsigned long ret;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return 0;
+
+    /*
+     * Clear anything that should have been cleared earlier. We do this
+     * here because this doesn't have constant-time issues.
+     */
+    while (es->bottom != es->top) {
+        if (es->err_flags[es->top] & ERR_FLAG_CLEAR) {
+            err_clear(es, es->top, 0);
+            es->top = es->top > 0 ? es->top - 1 : ERR_NUM_ERRORS - 1;
+            continue;
+        }
+        i = (es->bottom + 1) % ERR_NUM_ERRORS;
+        if (es->err_flags[i] & ERR_FLAG_CLEAR) {
+            es->bottom = i;
+            err_clear(es, es->bottom, 0);
+            continue;
+        }
+        break;
+    }
+
+    /* If everything has been cleared, the stack is empty. */
+    if (es->bottom == es->top)
+        return 0;
+
+    /* Which error, the top of stack (latest one) or the first one? */
+    if (g == EV_PEEK_LAST)
+        i = es->top;
+    else
+        i = (es->bottom + 1) % ERR_NUM_ERRORS;
+
+    ret = es->err_buffer[i];
+    if (g == EV_POP) {
+        es->bottom = i;
+        es->err_buffer[i] = 0;
+    }
+
+    if (file != NULL) {
+        *file = es->err_file[i];
+        if (*file == NULL)
+            *file = "";
+    }
+    if (line != NULL)
+        *line = es->err_line[i];
+    if (func != NULL) {
+        *func = es->err_func[i];
+        if (*func == NULL)
+            *func = "";
+    }
+    if (flags != NULL)
+        *flags = es->err_data_flags[i];
+    if (data == NULL) {
+        if (g == EV_POP) {
+            err_clear_data(es, i, 0);
+        }
+    } else {
+        *data = es->err_data[i];
+        if (*data == NULL) {
+            *data = "";
+            if (flags != NULL)
+                *flags = 0;
+        }
+    }
+    return ret;
+}
+
+void ossl_err_string_int(unsigned long e, const char *func,
+                         char *buf, size_t len)
+{
+    char lsbuf[64], rsbuf[256];
+    const char *ls, *rs = NULL;
+    unsigned long l, r;
+
+    if (len == 0)
+        return;
+
+    l = ERR_GET_LIB(e);
+    ls = ERR_lib_error_string(e);
+    if (ls == NULL) {
+        BIO_snprintf(lsbuf, sizeof(lsbuf), "lib(%lu)", l);
+        ls = lsbuf;
+    }
+
+    /*
+     * ERR_reason_error_string() can't safely return system error strings,
+     * since it would call openssl_strerror_r(), which needs a buffer for
+     * thread safety.  So for system errors, we call openssl_strerror_r()
+     * directly instead.
+     */
+    r = ERR_GET_REASON(e);
+#ifndef OPENSSL_NO_ERR
+    if (ERR_SYSTEM_ERROR(e)) {
+        if (openssl_strerror_r(r, rsbuf, sizeof(rsbuf)))
+            rs = rsbuf;
+    } else {
+        rs = ERR_reason_error_string(e);
+    }
+#endif
+    if (rs == NULL) {
+        BIO_snprintf(rsbuf, sizeof(rsbuf), "reason(%lu)",
+                     r & ~(ERR_RFLAGS_MASK << ERR_RFLAGS_OFFSET));
+        rs = rsbuf;
+    }
+
+    BIO_snprintf(buf, len, "error:%08lX:%s:%s:%s", e, ls, func, rs);
+    if (strlen(buf) == len - 1) {
+        /* Didn't fit; use a minimal format. */
+        BIO_snprintf(buf, len, "err:%lx:%lx:%lx:%lx", e, l, 0L, r);
+    }
+}
+
+
+void ERR_error_string_n(unsigned long e, char *buf, size_t len)
+{
+    ossl_err_string_int(e, "", buf, len);
+}
+
+/*
+ * ERR_error_string_n should be used instead for ret != NULL as
+ * ERR_error_string cannot know how large the buffer is
+ */
+char *ERR_error_string(unsigned long e, char *ret)
+{
+    static char buf[256];
+
+    if (ret == NULL)
+        ret = buf;
+    ERR_error_string_n(e, ret, (int)sizeof(buf));
+    return ret;
+}
+
+const char *ERR_lib_error_string(unsigned long e)
+{
+#ifndef OPENSSL_NO_ERR
+    ERR_STRING_DATA d, *p;
+    unsigned long l;
+
+    if (!RUN_ONCE(&err_string_init, do_err_strings_init)) {
+        return NULL;
+    }
+
+    l = ERR_GET_LIB(e);
+    d.error = ERR_PACK(l, 0, 0);
+    p = int_err_get_item(&d);
+    return ((p == NULL) ? NULL : p->string);
+#else
+    return NULL;
+#endif
+}
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+const char *ERR_func_error_string(unsigned long e)
+{
+    return NULL;
+}
+#endif
+
+const char *ERR_reason_error_string(unsigned long e)
+{
+#ifndef OPENSSL_NO_ERR
+    ERR_STRING_DATA d, *p = NULL;
+    unsigned long l, r;
+
+    if (!RUN_ONCE(&err_string_init, do_err_strings_init)) {
+        return NULL;
+    }
+
+    /*
+     * ERR_reason_error_string() can't safely return system error strings,
+     * since openssl_strerror_r() needs a buffer for thread safety, and we
+     * haven't got one that would serve any sensible purpose.
+     */
+    if (ERR_SYSTEM_ERROR(e))
+        return NULL;
+
+    l = ERR_GET_LIB(e);
+    r = ERR_GET_REASON(e);
+    d.error = ERR_PACK(l, 0, r);
+    p = int_err_get_item(&d);
+    if (p == NULL) {
+        d.error = ERR_PACK(0, 0, r);
+        p = int_err_get_item(&d);
+    }
+    return ((p == NULL) ? NULL : p->string);
+#else
+    return NULL;
+#endif
+}
+
+static void err_delete_thread_state(void *unused)
+{
+    ERR_STATE *state = CRYPTO_THREAD_get_local(&err_thread_local);
+    if (state == NULL)
+        return;
+
+    CRYPTO_THREAD_set_local(&err_thread_local, NULL);
+    OSSL_ERR_STATE_free(state);
+}
+
+#ifndef OPENSSL_NO_DEPRECATED_1_1_0
+void ERR_remove_thread_state(void *dummy)
+{
+}
+#endif
+
+#ifndef OPENSSL_NO_DEPRECATED_1_0_0
+void ERR_remove_state(unsigned long pid)
+{
+}
+#endif
+
+DEFINE_RUN_ONCE_STATIC(err_do_init)
+{
+    set_err_thread_local = 1;
+    return CRYPTO_THREAD_init_local(&err_thread_local, NULL);
+}
+
+ERR_STATE *ossl_err_get_state_int(void)
+{
+    ERR_STATE *state;
+    int saveerrno = get_last_sys_error();
+
+    if (!OPENSSL_init_crypto(OPENSSL_INIT_BASE_ONLY, NULL))
+        return NULL;
+
+    if (!RUN_ONCE(&err_init, err_do_init))
+        return NULL;
+
+    state = CRYPTO_THREAD_get_local(&err_thread_local);
+    if (state == (ERR_STATE*)-1)
+        return NULL;
+
+    if (state == NULL) {
+        if (!CRYPTO_THREAD_set_local(&err_thread_local, (ERR_STATE*)-1))
+            return NULL;
+
+        state = OSSL_ERR_STATE_new();
+        if (state == NULL) {
+            CRYPTO_THREAD_set_local(&err_thread_local, NULL);
+            return NULL;
+        }
+
+        if (!ossl_init_thread_start(NULL, NULL, err_delete_thread_state)
+                || !CRYPTO_THREAD_set_local(&err_thread_local, state)) {
+            OSSL_ERR_STATE_free(state);
+            CRYPTO_THREAD_set_local(&err_thread_local, NULL);
+            return NULL;
+        }
+
+        /* Ignore failures from these */
+        OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL);
+    }
+
+    set_sys_error(saveerrno);
+    return state;
+}
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+ERR_STATE *ERR_get_state(void)
+{
+    return ossl_err_get_state_int();
+}
+#endif
+
+
+/*
+ * err_shelve_state returns the current thread local error state
+ * and freezes the error module until err_unshelve_state is called.
+ */
+int err_shelve_state(void **state)
+{
+    int saveerrno = get_last_sys_error();
+
+    /*
+     * Note, at present our only caller is OPENSSL_init_crypto(), indirectly
+     * via ossl_init_load_crypto_nodelete(), by which point the requested
+     * "base" initialization has already been performed, so the below call is a
+     * NOOP, that re-enters OPENSSL_init_crypto() only to quickly return.
+     *
+     * If are no other valid callers of this function, the call below can be
+     * removed, avoiding the re-entry into OPENSSL_init_crypto().  If there are
+     * potential uses that are not from inside OPENSSL_init_crypto(), then this
+     * call is needed, but some care is required to make sure that the re-entry
+     * remains a NOOP.
+     */
+    if (!OPENSSL_init_crypto(OPENSSL_INIT_BASE_ONLY, NULL))
+        return 0;
+
+    if (!RUN_ONCE(&err_init, err_do_init))
+        return 0;
+
+    *state = CRYPTO_THREAD_get_local(&err_thread_local);
+    if (!CRYPTO_THREAD_set_local(&err_thread_local, (ERR_STATE*)-1))
+        return 0;
+
+    set_sys_error(saveerrno);
+    return 1;
+}
+
+/*
+ * err_unshelve_state restores the error state that was returned
+ * by err_shelve_state previously.
+ */
+void err_unshelve_state(void* state)
+{
+    if (state != (void*)-1)
+        CRYPTO_THREAD_set_local(&err_thread_local, (ERR_STATE*)state);
+}
+
+int ERR_get_next_error_library(void)
+{
+    int ret;
+
+    if (!RUN_ONCE(&err_string_init, do_err_strings_init))
+        return 0;
+
+    if (!CRYPTO_THREAD_write_lock(err_string_lock))
+        return 0;
+    ret = int_err_library_number++;
+    CRYPTO_THREAD_unlock(err_string_lock);
+    return ret;
+}
+
+static int err_set_error_data_int(char *data, size_t size, int flags,
+                                  int deallocate)
+{
+    ERR_STATE *es;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return 0;
+
+    err_clear_data(es, es->top, deallocate);
+    err_set_data(es, es->top, data, size, flags);
+
+    return 1;
+}
+
+void ERR_set_error_data(char *data, int flags)
+{
+    /*
+     * This function is void so we cannot propagate the error return. Since it
+     * is also in the public API we can't change the return type.
+     *
+     * We estimate the size of the data.  If it's not flagged as allocated,
+     * then this is safe, and if it is flagged as allocated, then our size
+     * may be smaller than the actual allocation, but that doesn't matter
+     * too much, the buffer will remain untouched or will eventually be
+     * reallocated to a new size.
+     *
+     * callers should be advised that this function takes over ownership of
+     * the allocated memory, i.e. they can't count on the pointer to remain
+     * valid.
+     */
+    err_set_error_data_int(data, strlen(data) + 1, flags, 1);
+}
+
+void ERR_add_error_data(int num, ...)
+{
+    va_list args;
+    va_start(args, num);
+    ERR_add_error_vdata(num, args);
+    va_end(args);
+}
+
+void ERR_add_error_vdata(int num, va_list args)
+{
+    int i, len, size;
+    int flags = ERR_TXT_MALLOCED | ERR_TXT_STRING;
+    char *str, *arg;
+    ERR_STATE *es;
+
+    /* Get the current error data; if an allocated string get it. */
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return;
+    i = es->top;
+
+    /*
+     * If err_data is allocated already, reuse the space.
+     * Otherwise, allocate a small new buffer.
+     */
+    if ((es->err_data_flags[i] & flags) == flags
+            && ossl_assert(es->err_data[i] != NULL)) {
+        str = es->err_data[i];
+        size = es->err_data_size[i];
+
+        /*
+         * To protect the string we just grabbed from tampering by other
+         * functions we may call, or to protect them from freeing a pointer
+         * that may no longer be valid at that point, we clear away the
+         * data pointer and the flags.  We will set them again at the end
+         * of this function.
+         */
+        es->err_data[i] = NULL;
+        es->err_data_flags[i] = 0;
+    } else if ((str = OPENSSL_malloc(size = 81)) == NULL) {
+        return;
+    } else {
+        str[0] = '\0';
+    }
+    len = strlen(str);
+
+    while (--num >= 0) {
+        arg = va_arg(args, char *);
+        if (arg == NULL)
+            arg = "<NULL>";
+        len += strlen(arg);
+        if (len >= size) {
+            char *p;
+
+            size = len + 20;
+            p = OPENSSL_realloc(str, size);
+            if (p == NULL) {
+                OPENSSL_free(str);
+                return;
+            }
+            str = p;
+        }
+        OPENSSL_strlcat(str, arg, (size_t)size);
+    }
+    if (!err_set_error_data_int(str, size, flags, 0))
+        OPENSSL_free(str);
+}
+
+void err_clear_last_constant_time(int clear)
+{
+    ERR_STATE *es;
+    int top;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return;
+
+    top = es->top;
+
+    /*
+     * Flag error as cleared but remove it elsewhere to avoid two errors
+     * accessing the same error stack location, revealing timing information.
+     */
+    clear = constant_time_select_int(constant_time_eq_int(clear, 0),
+                                     0, ERR_FLAG_CLEAR);
+    es->err_flags[top] |= clear;
+}

openssl-3.4.2/crypto/err/err_all.c

@@ -0,0 +1,115 @@
+/*
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <stdio.h>
+#include <openssl/err.h>
+#include "crypto/err.h"
+#include "crypto/cryptoerr.h"
+#include "crypto/asn1err.h"
+#include "crypto/bnerr.h"
+#include "crypto/ecerr.h"
+#include "crypto/buffererr.h"
+#include "crypto/bioerr.h"
+#include "crypto/comperr.h"
+#include "crypto/rsaerr.h"
+#include "crypto/dherr.h"
+#include "crypto/dsaerr.h"
+#include "crypto/evperr.h"
+#include "crypto/objectserr.h"
+#include "crypto/pemerr.h"
+#include "crypto/pkcs7err.h"
+#include "crypto/x509err.h"
+#include "crypto/x509v3err.h"
+#include "crypto/conferr.h"
+#include "crypto/pkcs12err.h"
+#include "crypto/randerr.h"
+#include "internal/dsoerr.h"
+#include "crypto/engineerr.h"
+#include "crypto/uierr.h"
+#include "crypto/httperr.h"
+#include "crypto/ocsperr.h"
+#include "crypto/tserr.h"
+#include "crypto/cmserr.h"
+#include "crypto/crmferr.h"
+#include "crypto/cmperr.h"
+#include "crypto/cterr.h"
+#include "crypto/asyncerr.h"
+#include "crypto/storeerr.h"
+#include "crypto/esserr.h"
+#include "internal/propertyerr.h"
+#include "prov/proverr.h"
+
+int ossl_err_load_crypto_strings(void)
+{
+    if (0
+#ifndef OPENSSL_NO_ERR
+        || ossl_err_load_ERR_strings() == 0 /* include error strings for SYSerr */
+        || ossl_err_load_BN_strings() == 0
+        || ossl_err_load_RSA_strings() == 0
+# ifndef OPENSSL_NO_DH
+        || ossl_err_load_DH_strings() == 0
+# endif
+        || ossl_err_load_EVP_strings() == 0
+        || ossl_err_load_BUF_strings() == 0
+        || ossl_err_load_OBJ_strings() == 0
+        || ossl_err_load_PEM_strings() == 0
+# ifndef OPENSSL_NO_DSA
+        || ossl_err_load_DSA_strings() == 0
+# endif
+        || ossl_err_load_X509_strings() == 0
+        || ossl_err_load_ASN1_strings() == 0
+        || ossl_err_load_CONF_strings() == 0
+        || ossl_err_load_CRYPTO_strings() == 0
+# ifndef OPENSSL_NO_COMP
+        || ossl_err_load_COMP_strings() == 0
+# endif
+# ifndef OPENSSL_NO_EC
+        || ossl_err_load_EC_strings() == 0
+# endif
+        /* skip ossl_err_load_SSL_strings() because it is not in this library */
+        || ossl_err_load_BIO_strings() == 0
+        || ossl_err_load_PKCS7_strings() == 0
+        || ossl_err_load_X509V3_strings() == 0
+        || ossl_err_load_PKCS12_strings() == 0
+        || ossl_err_load_RAND_strings() == 0
+        || ossl_err_load_DSO_strings() == 0
+# ifndef OPENSSL_NO_TS
+        || ossl_err_load_TS_strings() == 0
+# endif
+# ifndef OPENSSL_NO_ENGINE
+        || ossl_err_load_ENGINE_strings() == 0
+# endif
+# ifndef OPENSSL_NO_HTTP
+        || ossl_err_load_HTTP_strings() == 0
+# endif
+# ifndef OPENSSL_NO_OCSP
+        || ossl_err_load_OCSP_strings() == 0
+# endif
+        || ossl_err_load_UI_strings() == 0
+# ifndef OPENSSL_NO_CMS
+        || ossl_err_load_CMS_strings() == 0
+# endif
+# ifndef OPENSSL_NO_CRMF
+        || ossl_err_load_CRMF_strings() == 0
+        || ossl_err_load_CMP_strings() == 0
+# endif
+# ifndef OPENSSL_NO_CT
+        || ossl_err_load_CT_strings() == 0
+# endif
+        || ossl_err_load_ESS_strings() == 0
+        || ossl_err_load_ASYNC_strings() == 0
+        || ossl_err_load_OSSL_STORE_strings() == 0
+        || ossl_err_load_PROP_strings() == 0
+        || ossl_err_load_PROV_strings() == 0
+#endif
+        )
+        return 0;
+
+    return 1;
+}

openssl-3.4.2/crypto/err/err_all_legacy.c

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/* This is the C source file where we include this header directly */
+#include <openssl/cryptoerr_legacy.h>
+
+#ifndef OPENSSL_NO_DEPRECATED_3_0
+
+# include "crypto/err.h"
+# include "crypto/asn1err.h"
+# include "crypto/asyncerr.h"
+# include "crypto/bnerr.h"
+# include "crypto/buffererr.h"
+# include "crypto/bioerr.h"
+# include "crypto/cmserr.h"
+# include "crypto/comperr.h"
+# include "crypto/conferr.h"
+# include "crypto/cryptoerr.h"
+# include "crypto/cterr.h"
+# include "crypto/dherr.h"
+# include "crypto/dsaerr.h"
+# include "internal/dsoerr.h"
+# include "crypto/ecerr.h"
+# include "crypto/engineerr.h"
+# include "crypto/evperr.h"
+# include "crypto/httperr.h"
+# include "crypto/objectserr.h"
+# include "crypto/ocsperr.h"
+# include "crypto/pemerr.h"
+# include "crypto/pkcs12err.h"
+# include "crypto/pkcs7err.h"
+# include "crypto/randerr.h"
+# include "crypto/rsaerr.h"
+# include "crypto/storeerr.h"
+# include "crypto/tserr.h"
+# include "crypto/uierr.h"
+# include "crypto/x509err.h"
+# include "crypto/x509v3err.h"
+
+# ifdef OPENSSL_NO_ERR
+#  define IMPLEMENT_LEGACY_ERR_LOAD(lib)        \
+    int ERR_load_##lib##_strings(void)          \
+    {                                           \
+        return 1;                               \
+    }
+# else
+#  define IMPLEMENT_LEGACY_ERR_LOAD(lib)        \
+    int ERR_load_##lib##_strings(void)          \
+    {                                           \
+        return ossl_err_load_##lib##_strings(); \
+    }
+# endif
+
+IMPLEMENT_LEGACY_ERR_LOAD(ASN1)
+IMPLEMENT_LEGACY_ERR_LOAD(ASYNC)
+IMPLEMENT_LEGACY_ERR_LOAD(BIO)
+IMPLEMENT_LEGACY_ERR_LOAD(BN)
+IMPLEMENT_LEGACY_ERR_LOAD(BUF)
+# ifndef OPENSSL_NO_CMS
+IMPLEMENT_LEGACY_ERR_LOAD(CMS)
+# endif
+# ifndef OPENSSL_NO_COMP
+IMPLEMENT_LEGACY_ERR_LOAD(COMP)
+# endif
+IMPLEMENT_LEGACY_ERR_LOAD(CONF)
+IMPLEMENT_LEGACY_ERR_LOAD(CRYPTO)
+# ifndef OPENSSL_NO_CT
+IMPLEMENT_LEGACY_ERR_LOAD(CT)
+# endif
+# ifndef OPENSSL_NO_DH
+IMPLEMENT_LEGACY_ERR_LOAD(DH)
+# endif
+# ifndef OPENSSL_NO_DSA
+IMPLEMENT_LEGACY_ERR_LOAD(DSA)
+# endif
+# ifndef OPENSSL_NO_EC
+IMPLEMENT_LEGACY_ERR_LOAD(EC)
+# endif
+# ifndef OPENSSL_NO_ENGINE
+IMPLEMENT_LEGACY_ERR_LOAD(ENGINE)
+# endif
+IMPLEMENT_LEGACY_ERR_LOAD(ERR)
+IMPLEMENT_LEGACY_ERR_LOAD(EVP)
+IMPLEMENT_LEGACY_ERR_LOAD(OBJ)
+# ifndef OPENSSL_NO_OCSP
+IMPLEMENT_LEGACY_ERR_LOAD(OCSP)
+# endif
+IMPLEMENT_LEGACY_ERR_LOAD(PEM)
+IMPLEMENT_LEGACY_ERR_LOAD(PKCS12)
+IMPLEMENT_LEGACY_ERR_LOAD(PKCS7)
+IMPLEMENT_LEGACY_ERR_LOAD(RAND)
+IMPLEMENT_LEGACY_ERR_LOAD(RSA)
+IMPLEMENT_LEGACY_ERR_LOAD(OSSL_STORE)
+# ifndef OPENSSL_NO_TS
+IMPLEMENT_LEGACY_ERR_LOAD(TS)
+# endif
+IMPLEMENT_LEGACY_ERR_LOAD(UI)
+IMPLEMENT_LEGACY_ERR_LOAD(X509)
+IMPLEMENT_LEGACY_ERR_LOAD(X509V3)
+#endif /* OPENSSL_NO_DEPRECATED_3_0 */

openssl-3.4.2/crypto/err/err_blocks.c

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#define OSSL_FORCE_ERR_STATE
+
+#include <string.h>
+#include <openssl/err.h>
+#include "err_local.h"
+
+void ERR_new(void)
+{
+    ERR_STATE *es;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return;
+
+    /* Allocate a slot */
+    err_get_slot(es);
+    err_clear(es, es->top, 0);
+}
+
+void ERR_set_debug(const char *file, int line, const char *func)
+{
+    ERR_STATE *es;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return;
+
+    err_set_debug(es, es->top, file, line, func);
+}
+
+void ERR_set_error(int lib, int reason, const char *fmt, ...)
+{
+    va_list args;
+
+    va_start(args, fmt);
+    ERR_vset_error(lib, reason, fmt, args);
+    va_end(args);
+}
+
+void ERR_vset_error(int lib, int reason, const char *fmt, va_list args)
+{
+    ERR_STATE *es;
+    char *buf = NULL;
+    size_t buf_size = 0;
+    unsigned long flags = 0;
+    size_t i;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return;
+    i = es->top;
+
+    if (fmt != NULL) {
+        int printed_len = 0;
+        char *rbuf = NULL;
+
+        buf = es->err_data[i];
+        buf_size = es->err_data_size[i];
+
+        /*
+         * To protect the string we just grabbed from tampering by other
+         * functions we may call, or to protect them from freeing a pointer
+         * that may no longer be valid at that point, we clear away the
+         * data pointer and the flags.  We will set them again at the end
+         * of this function.
+         */
+        es->err_data[i] = NULL;
+        es->err_data_flags[i] = 0;
+
+        /*
+         * Try to maximize the space available.  If that fails, we use what
+         * we have.
+         */
+        if (buf_size < ERR_MAX_DATA_SIZE
+            && (rbuf = OPENSSL_realloc(buf, ERR_MAX_DATA_SIZE)) != NULL) {
+            buf = rbuf;
+            buf_size = ERR_MAX_DATA_SIZE;
+        }
+
+        if (buf != NULL) {
+            printed_len = BIO_vsnprintf(buf, buf_size, fmt, args);
+        }
+        if (printed_len < 0)
+            printed_len = 0;
+        if (buf != NULL)
+            buf[printed_len] = '\0';
+
+        /*
+         * Try to reduce the size, but only if we maximized above.  If that
+         * fails, we keep what we have.
+         * (According to documentation, realloc leaves the old buffer untouched
+         * if it fails)
+         */
+        if ((rbuf = OPENSSL_realloc(buf, printed_len + 1)) != NULL) {
+            buf = rbuf;
+            buf_size = printed_len + 1;
+            buf[printed_len] = '\0';
+        }
+
+        if (buf != NULL)
+            flags = ERR_TXT_MALLOCED | ERR_TXT_STRING;
+    }
+
+    err_clear_data(es, es->top, 0);
+    err_set_error(es, es->top, lib, reason);
+    if (fmt != NULL)
+        err_set_data(es, es->top, buf, buf_size, flags);
+}

openssl-3.4.2/crypto/err/err_local.h

@@ -0,0 +1,99 @@
+/*
+ * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#include <string.h>
+#include <openssl/err.h>
+#include <openssl/e_os2.h>
+
+static ossl_inline void err_get_slot(ERR_STATE *es)
+{
+    es->top = (es->top + 1) % ERR_NUM_ERRORS;
+    if (es->top == es->bottom)
+        es->bottom = (es->bottom + 1) % ERR_NUM_ERRORS;
+}
+
+static ossl_inline void err_clear_data(ERR_STATE *es, size_t i, int deall)
+{
+    if (es->err_data_flags[i] & ERR_TXT_MALLOCED) {
+        if (deall) {
+            OPENSSL_free(es->err_data[i]);
+            es->err_data[i] = NULL;
+            es->err_data_size[i] = 0;
+            es->err_data_flags[i] = 0;
+        } else if (es->err_data[i] != NULL) {
+            es->err_data[i][0] = '\0';
+            es->err_data_flags[i] = ERR_TXT_MALLOCED;
+        }
+    } else {
+        es->err_data[i] = NULL;
+        es->err_data_size[i] = 0;
+        es->err_data_flags[i] = 0;
+    }
+}
+
+static ossl_inline void err_set_error(ERR_STATE *es, size_t i,
+                                      int lib, int reason)
+{
+    es->err_buffer[i] =
+        lib == ERR_LIB_SYS
+        ? (unsigned int)(ERR_SYSTEM_FLAG |  reason)
+        : ERR_PACK(lib, 0, reason);
+}
+
+static ossl_inline void err_set_debug(ERR_STATE *es, size_t i,
+                                      const char *file, int line,
+                                      const char *fn)
+{
+    /*
+     * We dup the file and fn strings because they may be provider owned. If the
+     * provider gets unloaded, they may not be valid anymore.
+     */
+    OPENSSL_free(es->err_file[i]);
+    if (file == NULL || file[0] == '\0')
+        es->err_file[i] = NULL;
+    else if ((es->err_file[i] = CRYPTO_malloc(strlen(file) + 1,
+                                              NULL, 0)) != NULL)
+        /* We cannot use OPENSSL_strdup due to possible recursion */
+        strcpy(es->err_file[i], file);
+
+    es->err_line[i] = line;
+    OPENSSL_free(es->err_func[i]);
+    if (fn == NULL || fn[0] == '\0')
+        es->err_func[i] = NULL;
+    else if ((es->err_func[i] = CRYPTO_malloc(strlen(fn) + 1,
+                                              NULL, 0)) != NULL)
+        strcpy(es->err_func[i], fn);
+}
+
+static ossl_inline void err_set_data(ERR_STATE *es, size_t i,
+                                     void *data, size_t datasz, int flags)
+{
+    if ((es->err_data_flags[i] & ERR_TXT_MALLOCED) != 0)
+        OPENSSL_free(es->err_data[i]);
+    es->err_data[i] = data;
+    es->err_data_size[i] = datasz;
+    es->err_data_flags[i] = flags;
+}
+
+static ossl_inline void err_clear(ERR_STATE *es, size_t i, int deall)
+{
+    err_clear_data(es, i, (deall));
+    es->err_marks[i] = 0;
+    es->err_flags[i] = 0;
+    es->err_buffer[i] = 0;
+    es->err_line[i] = -1;
+    OPENSSL_free(es->err_file[i]);
+    es->err_file[i] = NULL;
+    OPENSSL_free(es->err_func[i]);
+    es->err_func[i] = NULL;
+}
+
+ERR_STATE *ossl_err_get_state_int(void);
+void ossl_err_string_int(unsigned long e, const char *func,
+                         char *buf, size_t len);

openssl-3.4.2/crypto/err/err_mark.c

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2003-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#define OSSL_FORCE_ERR_STATE
+
+#include <openssl/err.h>
+#include "err_local.h"
+
+int ERR_set_mark(void)
+{
+    ERR_STATE *es;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return 0;
+
+    if (es->bottom == es->top)
+        return 0;
+    es->err_marks[es->top]++;
+    return 1;
+}
+
+int ERR_pop(void)
+{
+    ERR_STATE *es;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL || es->bottom == es->top)
+        return 0;
+
+    err_clear(es, es->top, 0);
+    es->top = es->top > 0 ? es->top - 1 : ERR_NUM_ERRORS - 1;
+    return 1;
+}
+
+int ERR_pop_to_mark(void)
+{
+    ERR_STATE *es;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return 0;
+
+    while (es->bottom != es->top
+           && es->err_marks[es->top] == 0) {
+        err_clear(es, es->top, 0);
+        es->top = es->top > 0 ? es->top - 1 : ERR_NUM_ERRORS - 1;
+    }
+
+    if (es->bottom == es->top)
+        return 0;
+    es->err_marks[es->top]--;
+    return 1;
+}
+
+int ERR_count_to_mark(void)
+{
+    ERR_STATE *es;
+    int count = 0, top;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return 0;
+
+    top = es->top;
+    while (es->bottom != top
+           && es->err_marks[top] == 0) {
+        ++count;
+        top = top > 0 ? top - 1 : ERR_NUM_ERRORS - 1;
+    }
+
+    return count;
+}
+
+int ERR_clear_last_mark(void)
+{
+    ERR_STATE *es;
+    int top;
+
+    es = ossl_err_get_state_int();
+    if (es == NULL)
+        return 0;
+
+    top = es->top;
+    while (es->bottom != top
+           && es->err_marks[top] == 0) {
+        top = top > 0 ? top - 1 : ERR_NUM_ERRORS - 1;
+    }
+
+    if (es->bottom == top)
+        return 0;
+    es->err_marks[top]--;
+    return 1;
+}
+

openssl-3.4.2/crypto/err/err_prn.c

@@ -0,0 +1,186 @@
+/*
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#define OSSL_FORCE_ERR_STATE
+
+#include <stdio.h>
+#include "internal/cryptlib.h"
+#include <openssl/crypto.h>
+#include <openssl/buffer.h>
+#include <openssl/err.h>
+#include "err_local.h"
+
+#define ERR_PRINT_BUF_SIZE 4096
+void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u),
+                         void *u)
+{
+    CRYPTO_THREAD_ID tid = CRYPTO_THREAD_get_current_id();
+    unsigned long l;
+    const char *file, *data, *func;
+    int line, flags;
+
+    while ((l = ERR_get_error_all(&file, &line, &func, &data, &flags)) != 0) {
+        char buf[ERR_PRINT_BUF_SIZE] = "";
+        char *hex = NULL;
+        int offset;
+
+        if ((flags & ERR_TXT_STRING) == 0)
+            data = "";
+
+        hex = ossl_buf2hexstr_sep((const unsigned char *)&tid, sizeof(tid), '\0');
+        BIO_snprintf(buf, sizeof(buf), "%s:", hex == NULL ? "<null>" : hex);
+        offset = strlen(buf);
+        ossl_err_string_int(l, func, buf + offset, sizeof(buf) - offset);
+        offset += strlen(buf + offset);
+        BIO_snprintf(buf + offset, sizeof(buf) - offset, ":%s:%d:%s\n",
+                     file, line, data);
+        OPENSSL_free(hex);
+        if (cb(buf, strlen(buf), u) <= 0)
+            break;              /* abort outputting the error report */
+    }
+}
+
+/* auxiliary function for incrementally reporting texts via the error queue */
+static void put_error(int lib, const char *func, int reason,
+                      const char *file, int line)
+{
+    ERR_new();
+    ERR_set_debug(file, line, func);
+    ERR_set_error(lib, reason, NULL /* no data here, so fmt is NULL */);
+}
+
+#define TYPICAL_MAX_OUTPUT_BEFORE_DATA 100
+#define MAX_DATA_LEN (ERR_PRINT_BUF_SIZE - TYPICAL_MAX_OUTPUT_BEFORE_DATA)
+void ERR_add_error_txt(const char *separator, const char *txt)
+{
+    const char *file = NULL;
+    int line;
+    const char *func = NULL;
+    const char *data = NULL;
+    int flags;
+    unsigned long err = ERR_peek_last_error();
+
+    if (separator == NULL)
+        separator = "";
+    if (err == 0)
+        put_error(ERR_LIB_NONE, NULL, 0, "", 0);
+
+    do {
+        size_t available_len, data_len;
+        const char *curr = txt, *next = txt;
+        const char *leading_separator = separator;
+        int trailing_separator = 0;
+        char *tmp;
+
+        ERR_peek_last_error_all(&file, &line, &func, &data, &flags);
+        if ((flags & ERR_TXT_STRING) == 0) {
+            data = "";
+            leading_separator = "";
+        }
+        data_len = strlen(data);
+
+        /* workaround for limit of ERR_print_errors_cb() */
+        if (data_len >= MAX_DATA_LEN
+                || strlen(separator) >= (size_t)(MAX_DATA_LEN - data_len))
+            available_len = 0;
+        else
+            available_len = MAX_DATA_LEN - data_len - strlen(separator) - 1;
+        /* MAX_DATA_LEN > available_len >= 0 */
+
+        if (*separator == '\0') {
+            const size_t len_next = strlen(next);
+
+            if (len_next <= available_len) {
+                next += len_next;
+                curr = NULL; /* no need to split */
+            } else {
+                next += available_len;
+                curr = next; /* will split at this point */
+            }
+        } else {
+            while (*next != '\0' && (size_t)(next - txt) <= available_len) {
+                curr = next;
+                next = strstr(curr, separator);
+                if (next != NULL) {
+                    next += strlen(separator);
+                    trailing_separator = *next == '\0';
+                } else {
+                    next = curr + strlen(curr);
+                }
+            }
+            if ((size_t)(next - txt) <= available_len)
+                curr = NULL; /* the above loop implies *next == '\0' */
+        }
+        if (curr != NULL) {
+            /* split error msg at curr since error data would get too long */
+            if (curr != txt) {
+                tmp = OPENSSL_strndup(txt, curr - txt);
+                if (tmp == NULL)
+                    return;
+                ERR_add_error_data(2, separator, tmp);
+                OPENSSL_free(tmp);
+            }
+            put_error(ERR_GET_LIB(err), func, err, file, line);
+            txt = curr;
+        } else {
+            if (trailing_separator) {
+                tmp = OPENSSL_strndup(txt, next - strlen(separator) - txt);
+                if (tmp == NULL)
+                    return;
+                /* output txt without the trailing separator */
+                ERR_add_error_data(2, leading_separator, tmp);
+                OPENSSL_free(tmp);
+            } else {
+                ERR_add_error_data(2, leading_separator, txt);
+            }
+            txt = next; /* finished */
+        }
+    } while (*txt != '\0');
+}
+
+void ERR_add_error_mem_bio(const char *separator, BIO *bio)
+{
+    if (bio != NULL) {
+        char *str;
+        long len = BIO_get_mem_data(bio, &str);
+
+        if (len > 0) {
+            if (str[len - 1] != '\0') {
+                if (BIO_write(bio, "", 1) <= 0)
+                    return;
+
+                len = BIO_get_mem_data(bio, &str);
+            }
+            if (len > 1)
+                ERR_add_error_txt(separator, str);
+        }
+    }
+}
+
+static int print_bio(const char *str, size_t len, void *bp)
+{
+    return BIO_write((BIO *)bp, str, len);
+}
+
+void ERR_print_errors(BIO *bp)
+{
+    ERR_print_errors_cb(print_bio, bp);
+}
+
+#ifndef OPENSSL_NO_STDIO
+void ERR_print_errors_fp(FILE *fp)
+{
+    BIO *bio = BIO_new_fp(fp, BIO_NOCLOSE);
+    if (bio == NULL)
+        return;
+
+    ERR_print_errors_cb(print_bio, bio);
+    BIO_free(bio);
+}
+#endif

openssl-3.4.2/crypto/err/err_save.c

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#define OSSL_FORCE_ERR_STATE
+
+#include <openssl/err.h>
+#include "err_local.h"
+
+/*
+ * Save and restore error state.
+ * We are using CRYPTO_zalloc(.., NULL, 0) instead of OPENSSL_malloc() in
+ * these functions to prevent mem alloc error loop.
+ */
+
+ERR_STATE *OSSL_ERR_STATE_new(void)
+{
+    return CRYPTO_zalloc(sizeof(ERR_STATE), NULL, 0);
+}
+
+void OSSL_ERR_STATE_save(ERR_STATE *es)
+{
+    size_t i;
+    ERR_STATE *thread_es;
+
+    if (es == NULL)
+        return;
+
+    for (i = 0; i < ERR_NUM_ERRORS; i++)
+        err_clear(es, i, 1);
+
+    thread_es = ossl_err_get_state_int();
+    if (thread_es == NULL)
+        return;
+
+    memcpy(es, thread_es, sizeof(*es));
+    /* Taking over the pointers, just clear the thread state. */
+    memset(thread_es, 0, sizeof(*thread_es));
+}
+
+void OSSL_ERR_STATE_save_to_mark(ERR_STATE *es)
+{
+    size_t i, j, count;
+    int top;
+    ERR_STATE *thread_es;
+
+    if (es == NULL)
+        return;
+
+    thread_es = ossl_err_get_state_int();
+    if (thread_es == NULL) {
+        for (i = 0; i < ERR_NUM_ERRORS; ++i)
+            err_clear(es, i, 1);
+
+        es->top = es->bottom = 0;
+        return;
+    }
+
+    /* Determine number of errors we are going to move. */
+    for (count = 0, top = thread_es->top;
+         thread_es->bottom != top
+         && thread_es->err_marks[top] == 0;
+         ++count)
+        top = top > 0 ? top - 1 : ERR_NUM_ERRORS - 1;
+
+    /* Move the errors, preserving order. */
+    for (i = 0, j = top; i < count; ++i) {
+        j = (j + 1) % ERR_NUM_ERRORS;
+
+        err_clear(es, i, 1);
+
+        /* Move the error entry to the given ERR_STATE. */
+        es->err_flags[i]        = thread_es->err_flags[j];
+        es->err_marks[i]        = 0;
+        es->err_buffer[i]       = thread_es->err_buffer[j];
+        es->err_data[i]         = thread_es->err_data[j];
+        es->err_data_size[i]    = thread_es->err_data_size[j];
+        es->err_data_flags[i]   = thread_es->err_data_flags[j];
+        es->err_file[i]         = thread_es->err_file[j];
+        es->err_line[i]         = thread_es->err_line[j];
+        es->err_func[i]         = thread_es->err_func[j];
+
+        thread_es->err_flags[j]      = 0;
+        thread_es->err_buffer[j]     = 0;
+        thread_es->err_data[j]       = NULL;
+        thread_es->err_data_size[j]  = 0;
+        thread_es->err_data_flags[j] = 0;
+        thread_es->err_file[j]       = NULL;
+        thread_es->err_line[j]       = 0;
+        thread_es->err_func[j]       = NULL;
+    }
+
+    if (i > 0) {
+        thread_es->top = top;
+        /* If we moved anything, es's stack always starts at [0]. */
+        es->top     = i - 1;
+        es->bottom  = ERR_NUM_ERRORS - 1;
+    } else {
+        /* Didn't move anything - empty stack */
+        es->top = es->bottom = 0;
+    }
+
+    /* Erase extra space as a precaution. */
+    for (; i < ERR_NUM_ERRORS; ++i)
+        err_clear(es, i, 1);
+}
+
+void OSSL_ERR_STATE_restore(const ERR_STATE *es)
+{
+    size_t i;
+    ERR_STATE *thread_es;
+
+    if (es == NULL || es->bottom == es->top)
+        return;
+
+    thread_es = ossl_err_get_state_int();
+    if (thread_es == NULL)
+        return;
+
+    for (i = (size_t)es->bottom; i != (size_t)es->top;) {
+        size_t top;
+
+        i = (i + 1) % ERR_NUM_ERRORS;
+        if ((es->err_flags[i] & ERR_FLAG_CLEAR) != 0)
+            continue;
+
+        err_get_slot(thread_es);
+        top = thread_es->top;
+        err_clear(thread_es, top, 0);
+
+        thread_es->err_flags[top] = es->err_flags[i];
+        thread_es->err_buffer[top] = es->err_buffer[i];
+
+        err_set_debug(thread_es, top, es->err_file[i], es->err_line[i],
+                      es->err_func[i]);
+
+        if (es->err_data[i] != NULL && es->err_data_size[i] != 0) {
+            void *data;
+            size_t data_sz = es->err_data_size[i];
+
+            data = CRYPTO_malloc(data_sz, NULL, 0);
+            if (data != NULL) {
+                memcpy(data, es->err_data[i], data_sz);
+                err_set_data(thread_es, top, data, data_sz,
+                             es->err_data_flags[i] | ERR_TXT_MALLOCED);
+            }
+        } else {
+            err_clear_data(thread_es, top, 0);
+        }
+    }
+}

openssl-3.4.2/crypto/err/libcrypto-lib-err.d

@@ -0,0 +1,17 @@
+crypto/err/libcrypto-lib-err.o: crypto/err/err.c \
+ include/crypto/cryptlib.h include/openssl/core.h include/openssl/types.h \
+ include/openssl/e_os2.h include/openssl/macros.h \
+ include/openssl/opensslconf.h include/openssl/configuration.h \
+ include/openssl/opensslv.h include/openssl/safestack.h \
+ include/openssl/stack.h include/internal/cryptlib.h \
+ include/internal/common.h include/internal/e_os.h \
+ include/openssl/crypto.h include/openssl/cryptoerr.h \
+ include/openssl/symhacks.h include/openssl/cryptoerr_legacy.h \
+ include/internal/numbers.h include/internal/nelem.h \
+ include/openssl/buffer.h include/openssl/buffererr.h \
+ include/openssl/bio.h include/openssl/bioerr.h include/openssl/asn1.h \
+ include/openssl/asn1err.h include/openssl/bn.h include/openssl/bnerr.h \
+ include/openssl/err.h include/openssl/lhash.h include/internal/err.h \
+ include/crypto/err.h include/internal/thread_once.h \
+ include/crypto/ctype.h include/internal/constant_time.h \
+ crypto/err/err_local.h

openssl-3.4.2/crypto/err/libcrypto-lib-err_all.d

@@ -0,0 +1,23 @@
+crypto/err/libcrypto-lib-err_all.o: crypto/err/err_all.c \
+ include/openssl/err.h include/openssl/macros.h \
+ include/openssl/opensslconf.h include/openssl/configuration.h \
+ include/openssl/opensslv.h include/openssl/e_os2.h \
+ include/openssl/types.h include/openssl/safestack.h \
+ include/openssl/stack.h include/openssl/bio.h include/openssl/crypto.h \
+ include/openssl/cryptoerr.h include/openssl/symhacks.h \
+ include/openssl/cryptoerr_legacy.h include/openssl/core.h \
+ include/openssl/bioerr.h include/openssl/lhash.h include/crypto/err.h \
+ include/crypto/cryptoerr.h include/crypto/asn1err.h \
+ include/crypto/bnerr.h include/crypto/ecerr.h include/crypto/buffererr.h \
+ include/crypto/bioerr.h include/crypto/comperr.h include/crypto/rsaerr.h \
+ include/crypto/dherr.h include/crypto/dsaerr.h include/crypto/evperr.h \
+ include/crypto/objectserr.h include/crypto/pemerr.h \
+ include/crypto/pkcs7err.h include/crypto/x509err.h \
+ include/crypto/x509v3err.h include/crypto/conferr.h \
+ include/crypto/pkcs12err.h include/crypto/randerr.h \
+ include/internal/dsoerr.h include/crypto/engineerr.h \
+ include/crypto/uierr.h include/crypto/httperr.h include/crypto/ocsperr.h \
+ include/crypto/tserr.h include/crypto/cmserr.h include/crypto/crmferr.h \
+ include/crypto/cmperr.h include/crypto/cterr.h include/crypto/asyncerr.h \
+ include/crypto/storeerr.h include/crypto/esserr.h \
+ include/internal/propertyerr.h providers/common/include/prov/proverr.h

openssl-3.4.2/crypto/err/libcrypto-lib-err_all_legacy.d

@@ -0,0 +1,18 @@
+crypto/err/libcrypto-lib-err_all_legacy.o: crypto/err/err_all_legacy.c \
+ include/openssl/cryptoerr_legacy.h include/openssl/macros.h \
+ include/openssl/opensslconf.h include/openssl/configuration.h \
+ include/openssl/opensslv.h include/openssl/symhacks.h \
+ include/openssl/e_os2.h include/crypto/err.h include/crypto/asn1err.h \
+ include/crypto/asyncerr.h include/crypto/bnerr.h \
+ include/crypto/buffererr.h include/crypto/bioerr.h \
+ include/crypto/cmserr.h include/crypto/comperr.h \
+ include/crypto/conferr.h include/crypto/cryptoerr.h \
+ include/crypto/cterr.h include/crypto/dherr.h include/crypto/dsaerr.h \
+ include/internal/dsoerr.h include/crypto/ecerr.h \
+ include/crypto/engineerr.h include/crypto/evperr.h \
+ include/crypto/httperr.h include/crypto/objectserr.h \
+ include/crypto/ocsperr.h include/crypto/pemerr.h \
+ include/crypto/pkcs12err.h include/crypto/pkcs7err.h \
+ include/crypto/randerr.h include/crypto/rsaerr.h \
+ include/crypto/storeerr.h include/crypto/tserr.h include/crypto/uierr.h \
+ include/crypto/x509err.h include/crypto/x509v3err.h

openssl-3.4.2/crypto/err/libcrypto-lib-err_blocks.d

@@ -0,0 +1,9 @@
+crypto/err/libcrypto-lib-err_blocks.o: crypto/err/err_blocks.c \
+ include/openssl/err.h include/openssl/macros.h \
+ include/openssl/opensslconf.h include/openssl/configuration.h \
+ include/openssl/opensslv.h include/openssl/e_os2.h \
+ include/openssl/types.h include/openssl/safestack.h \
+ include/openssl/stack.h include/openssl/bio.h include/openssl/crypto.h \
+ include/openssl/cryptoerr.h include/openssl/symhacks.h \
+ include/openssl/cryptoerr_legacy.h include/openssl/core.h \
+ include/openssl/bioerr.h include/openssl/lhash.h crypto/err/err_local.h

openssl-3.4.2/crypto/err/libcrypto-lib-err_mark.d

@@ -0,0 +1,9 @@
+crypto/err/libcrypto-lib-err_mark.o: crypto/err/err_mark.c \
+ include/openssl/err.h include/openssl/macros.h \
+ include/openssl/opensslconf.h include/openssl/configuration.h \
+ include/openssl/opensslv.h include/openssl/e_os2.h \
+ include/openssl/types.h include/openssl/safestack.h \
+ include/openssl/stack.h include/openssl/bio.h include/openssl/crypto.h \
+ include/openssl/cryptoerr.h include/openssl/symhacks.h \
+ include/openssl/cryptoerr_legacy.h include/openssl/core.h \
+ include/openssl/bioerr.h include/openssl/lhash.h crypto/err/err_local.h

openssl-3.4.2/crypto/err/libcrypto-lib-err_prn.d

@@ -0,0 +1,14 @@
+crypto/err/libcrypto-lib-err_prn.o: crypto/err/err_prn.c \
+ include/internal/cryptlib.h include/internal/common.h \
+ include/openssl/configuration.h include/internal/e_os.h \
+ include/openssl/opensslconf.h include/openssl/macros.h \
+ include/openssl/opensslv.h include/openssl/e_os2.h \
+ include/openssl/crypto.h include/openssl/safestack.h \
+ include/openssl/stack.h include/openssl/types.h \
+ include/openssl/cryptoerr.h include/openssl/symhacks.h \
+ include/openssl/cryptoerr_legacy.h include/openssl/core.h \
+ include/internal/numbers.h include/internal/nelem.h \
+ include/openssl/buffer.h include/openssl/buffererr.h \
+ include/openssl/bio.h include/openssl/bioerr.h include/openssl/asn1.h \
+ include/openssl/asn1err.h include/openssl/bn.h include/openssl/bnerr.h \
+ include/openssl/err.h include/openssl/lhash.h crypto/err/err_local.h

openssl-3.4.2/crypto/err/libcrypto-lib-err_save.d

@@ -0,0 +1,9 @@
+crypto/err/libcrypto-lib-err_save.o: crypto/err/err_save.c \
+ include/openssl/err.h include/openssl/macros.h \
+ include/openssl/opensslconf.h include/openssl/configuration.h \
+ include/openssl/opensslv.h include/openssl/e_os2.h \
+ include/openssl/types.h include/openssl/safestack.h \
+ include/openssl/stack.h include/openssl/bio.h include/openssl/crypto.h \
+ include/openssl/cryptoerr.h include/openssl/symhacks.h \
+ include/openssl/cryptoerr_legacy.h include/openssl/core.h \
+ include/openssl/bioerr.h include/openssl/lhash.h crypto/err/err_local.h

openssl-3.4.2/crypto/err/openssl.ec

@@ -0,0 +1,81 @@
+# configuration file for util/mkerr.pl
+
+# The INPUT HEADER is scanned for declarations
+# LIBNAME       PUBLIC HEADER                   ERROR-TABLE FILE                        INTERNAL HEADER (if relevant)
+L ERR           NONE                            NONE                                    
+L FUNC          NONE                            NONE                                    
+L BN            include/openssl/bnerr.h         crypto/bn/bn_err.c                      include/crypto/bnerr.h
+L RSA           include/openssl/rsaerr.h        crypto/rsa/rsa_err.c                    include/crypto/rsaerr.h
+L DH            include/openssl/dherr.h         crypto/dh/dh_err.c                      include/crypto/dherr.h
+L EVP           include/openssl/evperr.h        crypto/evp/evp_err.c                    include/crypto/evperr.h
+L BUF           include/openssl/buffererr.h     crypto/buffer/buf_err.c                 include/crypto/buffererr.h
+L OBJ           include/openssl/objectserr.h    crypto/objects/obj_err.c                include/crypto/objectserr.h
+L PEM           include/openssl/pemerr.h        crypto/pem/pem_err.c                    include/crypto/pemerr.h
+L DSA           include/openssl/dsaerr.h        crypto/dsa/dsa_err.c                    include/crypto/dsaerr.h
+L X509          include/openssl/x509err.h       crypto/x509/x509_err.c                  include/crypto/x509err.h
+L ASN1          include/openssl/asn1err.h       crypto/asn1/asn1_err.c                  include/crypto/asn1err.h
+L CONF          include/openssl/conferr.h       crypto/conf/conf_err.c                  include/crypto/conferr.h
+L CRYPTO        include/openssl/cryptoerr.h     crypto/cpt_err.c                        include/crypto/cryptoerr.h
+L EC            include/openssl/ecerr.h         crypto/ec/ec_err.c                      include/crypto/ecerr.h
+L SSL           include/openssl/sslerr.h        crypto/ssl_err.c                        crypto/sslerr.h
+L BIO           include/openssl/bioerr.h        crypto/bio/bio_err.c                    include/crypto/bioerr.h
+L PKCS7         include/openssl/pkcs7err.h      crypto/pkcs7/pkcs7err.c                 include/crypto/pkcs7err.h
+L X509V3        include/openssl/x509v3err.h     crypto/x509/v3err.c                     include/crypto/x509v3err.h
+L PKCS12        include/openssl/pkcs12err.h     crypto/pkcs12/pk12err.c                 include/crypto/pkcs12err.h
+L RAND          include/openssl/randerr.h       crypto/rand/rand_err.c                  include/crypto/randerr.h
+L DSO           NONE                            crypto/dso/dso_err.c                    include/internal/dsoerr.h
+L ENGINE        include/openssl/engineerr.h     crypto/engine/eng_err.c                 include/crypto/engineerr.h
+L OCSP          include/openssl/ocsperr.h       crypto/ocsp/ocsp_err.c                  include/crypto/ocsperr.h
+L UI            include/openssl/uierr.h         crypto/ui/ui_err.c                      include/crypto/uierr.h
+L COMP          include/openssl/comperr.h       crypto/comp/comp_err.c                  include/crypto/comperr.h
+L TS            include/openssl/tserr.h         crypto/ts/ts_err.c                      include/crypto/tserr.h
+L CMS           include/openssl/cmserr.h        crypto/cms/cms_err.c                    include/crypto/cmserr.h
+L CRMF          include/openssl/crmferr.h       crypto/crmf/crmf_err.c                  include/crypto/crmferr.h
+L CMP           include/openssl/cmperr.h        crypto/cmp/cmp_err.c                    include/crypto/cmperr.h
+L CT            include/openssl/cterr.h         crypto/ct/ct_err.c                      include/crypto/cterr.h
+L ASYNC         include/openssl/asyncerr.h      crypto/async/async_err.c                include/crypto/asyncerr.h
+# KDF is only here for conservation purposes
+L KDF           NONE                            NONE                                    NONE
+L SM2           NONE                            crypto/sm2/sm2_err.c                    include/crypto/sm2err.h
+L OSSL_STORE    include/openssl/storeerr.h      crypto/store/store_err.c                include/crypto/storeerr.h
+L ESS           include/openssl/esserr.h        crypto/ess/ess_err.c                    include/crypto/esserr.h
+L PROP          NONE                            crypto/property/property_err.c          include/internal/propertyerr.h
+L PROV          include/openssl/proverr.h       providers/common/provider_err.c         providers/common/include/prov/proverr.h
+L OSSL_ENCODER  include/openssl/encodererr.h    crypto/encode_decode/encoder_err.c      include/crypto/encodererr.h
+L OSSL_DECODER  include/openssl/decodererr.h    crypto/encode_decode/decoder_err.c      include/crypto/decodererr.h
+L HTTP          include/openssl/httperr.h       crypto/http/http_err.c                  include/crypto/httperr.h
+
+# SSL/TLS alerts
+R SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE          1010
+R SSL_R_SSLV3_ALERT_BAD_RECORD_MAC              1020
+R SSL_R_TLSV1_ALERT_DECRYPTION_FAILED           1021
+R SSL_R_TLSV1_ALERT_RECORD_OVERFLOW             1022
+R SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE       1030
+R SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE           1040
+R SSL_R_SSLV3_ALERT_NO_CERTIFICATE              1041
+R SSL_R_SSLV3_ALERT_BAD_CERTIFICATE             1042
+R SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE     1043
+R SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED         1044
+R SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED         1045
+R SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN         1046
+R SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER           1047
+R SSL_R_TLSV1_ALERT_UNKNOWN_CA                  1048
+R SSL_R_TLSV1_ALERT_ACCESS_DENIED               1049
+R SSL_R_TLSV1_ALERT_DECODE_ERROR                1050
+R SSL_R_TLSV1_ALERT_DECRYPT_ERROR               1051
+R SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION          1060
+R SSL_R_TLSV1_ALERT_PROTOCOL_VERSION            1070
+R SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY       1071
+R SSL_R_TLSV1_ALERT_INTERNAL_ERROR              1080
+R SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK      1086
+R SSL_R_TLSV1_ALERT_USER_CANCELLED              1090
+R SSL_R_TLSV1_ALERT_NO_RENEGOTIATION            1100
+R SSL_R_TLSV13_ALERT_MISSING_EXTENSION          1109
+R SSL_R_TLSV1_UNSUPPORTED_EXTENSION             1110
+R SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE          1111
+R SSL_R_TLSV1_UNRECOGNIZED_NAME                 1112
+R SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE   1113
+R SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE        1114
+R SSL_R_TLSV1_ALERT_UNKNOWN_PSK_IDENTITY        1115
+R SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED       1116
+R SSL_R_TLSV1_ALERT_NO_APPLICATION_PROTOCOL     1120