From 6492cd890b92eab3b04244c3595bdc2e774c6397 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Mon, 27 Oct 2025 19:49:56 +0900 Subject: [PATCH] more ssl impl --- Cargo.lock | 15 + Lib/test/test_httplib.py | 2 - Lib/test/test_ssl.py | 21 - Lib/test/test_urllib2_localnet.py | 2 - common/src/fileutils.rs | 96 ++ scripts/make_ssl_data_rs.py | 168 +++ stdlib/Cargo.toml | 1 + stdlib/src/socket.rs | 13 + stdlib/src/ssl.rs | 1291 +++++++++++++++++++-- stdlib/src/ssl/ssl_data_111.rs | 1347 ++++++++++++++++++++++ stdlib/src/ssl/ssl_data_300.rs | 1759 ++++++++++++++++++++++++++++ stdlib/src/ssl/ssl_data_31.rs | 1770 +++++++++++++++++++++++++++++ 12 files changed, 6356 insertions(+), 129 deletions(-) create mode 100755 scripts/make_ssl_data_rs.py create mode 100644 stdlib/src/ssl/ssl_data_111.rs create mode 100644 stdlib/src/ssl/ssl_data_300.rs create mode 100644 stdlib/src/ssl/ssl_data_31.rs diff --git a/Cargo.lock b/Cargo.lock index 53b4f969223..9903fd19334 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1825,6 +1825,7 @@ version = "0.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078" dependencies = [ + "phf_macros", "phf_shared", ] @@ -1848,6 +1849,19 @@ dependencies = [ "rand 0.8.5", ] +[[package]] +name = "phf_macros" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216" +dependencies = [ + "phf_generator", + "phf_shared", + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "phf_shared" version = "0.11.3" @@ -2573,6 +2587,7 @@ dependencies = [ "page_size", "parking_lot", "paste", + "phf", "pymath", "rand_core 0.9.3", "rustix", diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py index abe8b9f54cd..d4a6eefe322 100644 --- a/Lib/test/test_httplib.py +++ b/Lib/test/test_httplib.py @@ -1801,8 +1801,6 @@ def test_local_good_hostname(self): self.addCleanup(resp.close) self.assertEqual(resp.status, 404) - # TODO: RUSTPYTHON - @unittest.expectedFailure def test_local_bad_hostname(self): # The (valid) cert doesn't validate the HTTP hostname import ssl diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py index e0b8870fa8c..55e6bb59143 100644 --- a/Lib/test/test_ssl.py +++ b/Lib/test/test_ssl.py @@ -586,7 +586,6 @@ def test_refcycle(self): del ss self.assertEqual(wr(), None) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_wrapped_unconnected(self): # Methods on an unconnected SSLSocket propagate the original # OSError raise by the underlying socket object. @@ -1400,7 +1399,6 @@ def test_load_dh_params(self): with self.assertRaises(ssl.SSLError) as cm: ctx.load_dh_params(CERTFILE) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_session_stats(self): for proto in {ssl.PROTOCOL_TLS_CLIENT, ssl.PROTOCOL_TLS_SERVER}: ctx = ssl.SSLContext(proto) @@ -1461,7 +1459,6 @@ def dummycallback(sock, servername, ctx, cycle=ctx): gc.collect() self.assertIs(wr(), None) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_cert_store_stats(self): ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) self.assertEqual(ctx.cert_store_stats(), @@ -1521,7 +1518,6 @@ def test_load_default_certs(self): self.assertRaises(TypeError, ctx.load_default_certs, 'SERVER_AUTH') @unittest.skipIf(sys.platform == "win32", "not-Windows specific") - @unittest.expectedFailure # TODO: RUSTPYTHON def test_load_default_certs_env(self): ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) with os_helper.EnvironmentVarGuard() as env: @@ -1673,7 +1669,6 @@ def test_context_client_server(self): self.assertFalse(ctx.check_hostname) self.assertEqual(ctx.verify_mode, ssl.CERT_NONE) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_context_custom_class(self): class MySSLSocket(ssl.SSLSocket): pass @@ -1690,7 +1685,6 @@ class MySSLObject(ssl.SSLObject): obj = ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO(), server_side=True) self.assertIsInstance(obj, MySSLObject) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_num_tickest(self): ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) self.assertEqual(ctx.num_tickets, 2) @@ -1721,7 +1715,6 @@ def test_str(self): self.assertEqual(str(e), "foo") self.assertEqual(e.errno, 1) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_lib_reason(self): # Test the library and reason attributes ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) @@ -1899,7 +1892,6 @@ def setUp(self): self.enterContext(server) self.server_addr = (HOST, server.port) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_connect(self): with test_wrap_socket(socket.socket(socket.AF_INET), cert_reqs=ssl.CERT_NONE) as s: @@ -1966,7 +1958,6 @@ def test_non_blocking_connect_ex(self): # SSL established self.assertTrue(s.getpeercert()) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_connect_with_context(self): # Same as test_connect, but with a separately created context ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) @@ -2093,7 +2084,6 @@ def test_non_blocking_handshake(self): def test_get_server_certificate(self): _test_get_server_certificate(self, *self.server_addr, cert=SIGNING_CA) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_get_server_certificate_sni(self): host, port = self.server_addr server_names = [] @@ -2120,7 +2110,6 @@ def test_get_server_certificate_fail(self): # independent test method _test_get_server_certificate_fail(self, *self.server_addr) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_get_server_certificate_timeout(self): def servername_cb(ssl_sock, server_name, initial_context): time.sleep(0.2) @@ -2156,7 +2145,6 @@ def test_get_ca_certs_capath(self): self.assertTrue(cert) self.assertEqual(len(ctx.get_ca_certs()), 1) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_context_setget(self): # Check that the context of a connected socket can be replaced. ctx1 = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) @@ -3041,7 +3029,6 @@ def test_crl_check(self): cert = s.getpeercert() self.assertTrue(cert, "Can't get peer certificate.") - @unittest.expectedFailure # TODO: RUSTPYTHON def test_check_hostname(self): if support.verbose: sys.stdout.write("\n") @@ -3182,7 +3169,6 @@ def test_dual_rsa_ecc(self): cipher = s.cipher()[0].split('-') self.assertTrue(cipher[:2], ('ECDHE', 'ECDSA')) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_check_hostname_idn(self, warnings_filters=True): if support.verbose: sys.stdout.write("\n") @@ -3370,7 +3356,6 @@ def connector(): finally: t.join() - @unittest.expectedFailure # TODO: RUSTPYTHON def test_ssl_cert_verify_error(self): if support.verbose: sys.stdout.write("\n") @@ -3477,7 +3462,6 @@ def test_protocol_tlsv1_1(self): try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLSv1_1, False) @requires_tls_version('TLSv1_2') - @unittest.expectedFailure # TODO: RUSTPYTHON def test_protocol_tlsv1_2(self): """Connecting to a TLSv1.2 server with various client options. Testing against older TLS versions.""" @@ -3924,7 +3908,6 @@ def test_do_handshake_enotconn(self): sock.do_handshake() self.assertEqual(cm.exception.errno, errno.ENOTCONN) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_no_shared_ciphers(self): client_context, server_context, hostname = testing_context() # OpenSSL enables all TLS 1.3 ciphers, enforce TLS 1.2 for test @@ -4156,7 +4139,6 @@ def test_no_legacy_server_connect(self): chatty=True, connectionchatty=True, sni_name=hostname) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_dh_params(self): # Check we can get a connection with ephemeral finite-field # Diffie-Hellman (if supported). @@ -4755,7 +4737,6 @@ def test_pha_optional(self): s.write(b'HASCERT') self.assertEqual(s.recv(1024), b'TRUE\n') - @unittest.expectedFailure # TODO: RUSTPYTHON def test_pha_optional_nocert(self): if support.verbose: sys.stdout.write("\n") @@ -4795,7 +4776,6 @@ def test_pha_no_pha_client(self): s.write(b'PHA') self.assertIn(b'extension not received', s.recv(1024)) - @unittest.expectedFailure # TODO: RUSTPYTHON def test_pha_no_pha_server(self): # server doesn't have PHA enabled, cert is requested in handshake client_context, server_context, hostname = testing_context() @@ -4816,7 +4796,6 @@ def test_pha_no_pha_server(self): s.write(b'HASCERT') self.assertEqual(s.recv(1024), b'TRUE\n') - @unittest.expectedFailure # TODO: RUSTPYTHON def test_pha_not_tls13(self): # TLS 1.2 client_context, server_context, hostname = testing_context() diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py index b40a2410bcc..2c54ef85b4b 100644 --- a/Lib/test/test_urllib2_localnet.py +++ b/Lib/test/test_urllib2_localnet.py @@ -602,8 +602,6 @@ def test_https_with_cadefault(self): self.urlopen("https://localhost:%s/bizarre" % handler.port, cadefault=True) - # TODO: RUSTPYTHON - @unittest.expectedFailure @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name") def test_https_sni(self): if ssl is None: diff --git a/common/src/fileutils.rs b/common/src/fileutils.rs index 6fa8e62a657..cd61d9b204a 100644 --- a/common/src/fileutils.rs +++ b/common/src/fileutils.rs @@ -438,3 +438,99 @@ pub mod windows { } } } + +// _Py_fopen_obj in cpython (Python/fileutils.c:1757-1835) +// Open a file using std::fs::File and convert to FILE* +// Automatically handles path encoding and EINTR retries +pub fn fopen(path: &std::path::Path, mode: &str) -> std::io::Result<*mut libc::FILE> { + use std::ffi::CString; + use std::fs::File; + + // Currently only supports read mode + // Can be extended to support "wb", "w+b", etc. if needed + if mode != "rb" { + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidInput, + format!("unsupported mode: {}", mode), + )); + } + + // Open file using std::fs::File (handles path encoding and EINTR automatically) + let file = File::open(path)?; + + #[cfg(windows)] + { + use std::os::windows::io::IntoRawHandle; + + // Declare Windows CRT functions + unsafe extern "C" { + fn _open_osfhandle(handle: isize, flags: libc::c_int) -> libc::c_int; + fn _fdopen(fd: libc::c_int, mode: *const libc::c_char) -> *mut libc::FILE; + } + + // Convert File handle to CRT file descriptor + let handle = file.into_raw_handle(); + let fd = unsafe { _open_osfhandle(handle as isize, libc::O_RDONLY) }; + if fd == -1 { + return Err(std::io::Error::last_os_error()); + } + + // Convert fd to FILE* + let mode_cstr = CString::new(mode).unwrap(); + let fp = unsafe { _fdopen(fd, mode_cstr.as_ptr()) }; + if fp.is_null() { + unsafe { libc::close(fd) }; + return Err(std::io::Error::last_os_error()); + } + + // Set non-inheritable (Windows needs this explicitly) + if let Err(e) = set_inheritable(fd, false) { + unsafe { libc::fclose(fp) }; + return Err(e); + } + + Ok(fp) + } + + #[cfg(not(windows))] + { + use std::os::fd::IntoRawFd; + + // Convert File to raw fd + let fd = file.into_raw_fd(); + + // Convert fd to FILE* + let mode_cstr = CString::new(mode).unwrap(); + let fp = unsafe { libc::fdopen(fd, mode_cstr.as_ptr()) }; + if fp.is_null() { + unsafe { libc::close(fd) }; + return Err(std::io::Error::last_os_error()); + } + + // Unix: O_CLOEXEC is already set by File::open, so non-inheritable is automatic + Ok(fp) + } +} + +// set_inheritable in cpython (Python/fileutils.c:1443-1570) +// Set the inheritable flag of the specified file descriptor +// Only used on Windows; Unix automatically sets O_CLOEXEC +#[cfg(windows)] +fn set_inheritable(fd: libc::c_int, inheritable: bool) -> std::io::Result<()> { + use windows_sys::Win32::Foundation::{ + HANDLE, HANDLE_FLAG_INHERIT, INVALID_HANDLE_VALUE, SetHandleInformation, + }; + + let handle = unsafe { libc::get_osfhandle(fd) }; + if handle == INVALID_HANDLE_VALUE as isize { + return Err(std::io::Error::last_os_error()); + } + + let flags = if inheritable { HANDLE_FLAG_INHERIT } else { 0 }; + let result = unsafe { SetHandleInformation(handle as HANDLE, HANDLE_FLAG_INHERIT, flags) }; + if result == 0 { + return Err(std::io::Error::last_os_error()); + } + + Ok(()) +} diff --git a/scripts/make_ssl_data_rs.py b/scripts/make_ssl_data_rs.py new file mode 100755 index 00000000000..b6891416a07 --- /dev/null +++ b/scripts/make_ssl_data_rs.py @@ -0,0 +1,168 @@ +#!/usr/bin/env python3 + +""" +Generate Rust SSL error mapping code from OpenSSL sources. + +This is based on CPython's Tools/ssl/make_ssl_data.py but generates +Rust code instead of C headers. + +It takes two arguments: +- the path to the OpenSSL source tree (e.g. git checkout) +- the path to the Rust file to be generated (e.g. stdlib/src/ssl/ssl_data.rs) +- error codes are version specific +""" + +import argparse +import datetime +import operator +import os +import re +import sys + + +parser = argparse.ArgumentParser( + description="Generate ssl_data.rs from OpenSSL sources" +) +parser.add_argument("srcdir", help="OpenSSL source directory") +parser.add_argument("output", nargs="?", default=None) + + +def _file_search(fname, pat): + with open(fname, encoding="utf-8") as f: + for line in f: + match = pat.search(line) + if match is not None: + yield match + + +def parse_err_h(args): + """Parse err codes, e.g. ERR_LIB_X509: 11""" + pat = re.compile(r"#\s*define\W+ERR_LIB_(\w+)\s+(\d+)") + lib2errnum = {} + for match in _file_search(args.err_h, pat): + libname, num = match.groups() + lib2errnum[libname] = int(num) + + return lib2errnum + + +def parse_openssl_error_text(args): + """Parse error reasons, X509_R_AKID_MISMATCH""" + # ignore backslash line continuation for now + pat = re.compile(r"^((\w+?)_R_(\w+)):(\d+):") + for match in _file_search(args.errtxt, pat): + reason, libname, errname, num = match.groups() + if "_F_" in reason: + # ignore function codes + continue + num = int(num) + yield reason, libname, errname, num + + +def parse_extra_reasons(args): + """Parse extra reasons from openssl.ec""" + pat = re.compile(r"^R\s+((\w+)_R_(\w+))\s+(\d+)") + for match in _file_search(args.errcodes, pat): + reason, libname, errname, num = match.groups() + num = int(num) + yield reason, libname, errname, num + + +def gen_library_codes_rust(args): + """Generate Rust phf map for library codes""" + yield "// Maps lib_code -> library name" + yield '// Example: 20 -> "SSL"' + yield "pub static LIBRARY_CODES: phf::Map = phf_map! {" + + # Deduplicate: keep the last one if there are duplicates + seen = {} + for libname in sorted(args.lib2errnum): + lib_num = args.lib2errnum[libname] + seen[lib_num] = libname + + for lib_num in sorted(seen.keys()): + libname = seen[lib_num] + yield f' {lib_num}u32 => "{libname}",' + yield "};" + yield "" + + +def gen_error_codes_rust(args): + """Generate Rust phf map for error codes""" + yield "// Maps encoded (lib, reason) -> error mnemonic" + yield '// Example: encode_error_key(20, 134) -> "CERTIFICATE_VERIFY_FAILED"' + yield "// Key encoding: (lib << 32) | reason" + yield "pub static ERROR_CODES: phf::Map = phf_map! {" + for reason, libname, errname, num in args.reasons: + if libname not in args.lib2errnum: + continue + lib_num = args.lib2errnum[libname] + # Encode (lib, reason) as single u64 + key = (lib_num << 32) | num + yield f' {key}u64 => "{errname}",' + yield "};" + yield "" + + +def main(): + args = parser.parse_args() + + args.err_h = os.path.join(args.srcdir, "include", "openssl", "err.h") + if not os.path.isfile(args.err_h): + # Fall back to infile for OpenSSL 3.0.0 + args.err_h += ".in" + args.errcodes = os.path.join(args.srcdir, "crypto", "err", "openssl.ec") + args.errtxt = os.path.join(args.srcdir, "crypto", "err", "openssl.txt") + + if not os.path.isfile(args.errtxt): + parser.error(f"File {args.errtxt} not found in srcdir\n.") + + # {X509: 11, ...} + args.lib2errnum = parse_err_h(args) + + # [('X509_R_AKID_MISMATCH', 'X509', 'AKID_MISMATCH', 110), ...] + reasons = [] + reasons.extend(parse_openssl_error_text(args)) + reasons.extend(parse_extra_reasons(args)) + # sort by libname, numeric error code + args.reasons = sorted(reasons, key=operator.itemgetter(0, 3)) + + lines = [ + "// File generated by tools/make_ssl_data_rs.py", + f"// Generated on {datetime.datetime.now(datetime.timezone.utc).isoformat()}", + f"// Source: OpenSSL from {args.srcdir}", + "// spell-checker: disable", + "", + "use phf::phf_map;", + "", + ] + lines.extend(gen_library_codes_rust(args)) + lines.extend(gen_error_codes_rust(args)) + + # Add helper function + lines.extend( + [ + "/// Helper function to create encoded key from (lib, reason) pair", + "#[inline]", + "pub fn encode_error_key(lib: i32, reason: i32) -> u64 {", + " ((lib as u64) << 32) | (reason as u64 & 0xFFFFFFFF)", + "}", + "", + ] + ) + + if args.output is None: + for line in lines: + print(line) + else: + with open(args.output, "w") as output: + for line in lines: + print(line, file=output) + + print(f"Generated {args.output}") + print(f"Found {len(args.lib2errnum)} library codes") + print(f"Found {len(args.reasons)} error codes") + + +if __name__ == "__main__": + main() diff --git a/stdlib/Cargo.toml b/stdlib/Cargo.toml index cc6f76a1a64..7f64802d352 100644 --- a/stdlib/Cargo.toml +++ b/stdlib/Cargo.toml @@ -40,6 +40,7 @@ num-integer = { workspace = true } num-traits = { workspace = true } num_enum = { workspace = true } parking_lot = { workspace = true } +phf = { version = "0.11", features = ["macros"] } memchr = { workspace = true } base64 = "0.22" diff --git a/stdlib/src/socket.rs b/stdlib/src/socket.rs index f3ae72b63fb..234d94a5263 100644 --- a/stdlib/src/socket.rs +++ b/stdlib/src/socket.rs @@ -1198,6 +1198,7 @@ mod _socket { fn recv_into( &self, buf: ArgMemoryBuffer, + nbytes: OptionalArg, flags: OptionalArg, vm: &VirtualMachine, ) -> Result { @@ -1205,6 +1206,18 @@ mod _socket { let sock = self.sock()?; let mut buf = buf.borrow_buf_mut(); let buf = &mut *buf; + + // Handle nbytes parameter + let read_len = if let OptionalArg::Present(nbytes) = nbytes { + let nbytes = nbytes.to_usize().ok_or_else(|| { + vm.new_value_error("negative buffersize in recv_into".to_owned()) + })?; + nbytes.min(buf.len()) + } else { + buf.len() + }; + + let buf = &mut buf[..read_len]; self.sock_op(vm, SelectKind::Read, || { sock.recv_with_flags(unsafe { slice_as_uninit(buf) }, flags) }) diff --git a/stdlib/src/ssl.rs b/stdlib/src/ssl.rs index d151c2948c6..9fd050a7efa 100644 --- a/stdlib/src/ssl.rs +++ b/stdlib/src/ssl.rs @@ -2,6 +2,23 @@ mod cert; +// Conditional compilation for OpenSSL version-specific error codes +cfg_if::cfg_if! { + if #[cfg(ossl310)] { + // OpenSSL 3.1.0+ + #[path = "ssl/ssl_data_31.rs"] + mod ssl_data; + } else if #[cfg(ossl300)] { + // OpenSSL 3.0.0+ + #[path = "ssl/ssl_data_300.rs"] + mod ssl_data; + } else { + // OpenSSL 1.1.1+ (fallback) + #[path = "ssl/ssl_data_111.rs"] + mod ssl_data; + } +} + use crate::vm::{PyRef, VirtualMachine, builtins::PyModule}; use openssl_probe::ProbeResult; @@ -173,9 +190,9 @@ mod _ssl { #[pyattr] const HAS_ALPN: bool = true; #[pyattr] - const HAS_SSLv2: bool = true; + const HAS_SSLv2: bool = false; #[pyattr] - const HAS_SSLv3: bool = true; + const HAS_SSLv3: bool = false; #[pyattr] const HAS_TLSv1: bool = true; #[pyattr] @@ -199,6 +216,10 @@ mod _ssl { const ERR_LIB_SSL: i32 = 20; const SSL_R_UNEXPECTED_EOF_WHILE_READING: i32 = 294; + // SSL_VERIFY constants for post-handshake authentication + #[cfg(ossl111)] + const SSL_VERIFY_POST_HANDSHAKE: libc::c_int = 0x20; + // the openssl version from the API headers #[pyattr(name = "OPENSSL_VERSION")] @@ -503,6 +524,131 @@ mod _ssl { Ok(buf) } + // Callback data stored in SSL context for SNI + struct SniCallbackData { + ssl_context: PyRef, + vm_ptr: *const VirtualMachine, + } + + impl Drop for SniCallbackData { + fn drop(&mut self) { + // PyRef will handle reference counting + } + } + + // Get or create an ex_data index for SNI callback data + fn get_sni_ex_data_index() -> libc::c_int { + use std::sync::LazyLock; + static SNI_EX_DATA_IDX: LazyLock = LazyLock::new(|| unsafe { + sys::SSL_get_ex_new_index( + 0, + std::ptr::null_mut(), + None, + None, + Some(sni_callback_data_free), + ) + }); + *SNI_EX_DATA_IDX + } + + // Free function for callback data + unsafe extern "C" fn sni_callback_data_free( + _parent: *mut libc::c_void, + ptr: *mut libc::c_void, + _ad: *mut sys::CRYPTO_EX_DATA, + _idx: libc::c_int, + _argl: libc::c_long, + _argp: *mut libc::c_void, + ) { + if !ptr.is_null() { + unsafe { + let _ = Box::from_raw(ptr as *mut SniCallbackData); + } + } + } + + // SNI callback function called by OpenSSL + unsafe extern "C" fn _servername_callback( + ssl_ptr: *mut sys::SSL, + _al: *mut libc::c_int, + arg: *mut libc::c_void, + ) -> libc::c_int { + const SSL_TLSEXT_ERR_OK: libc::c_int = 0; + const SSL_TLSEXT_ERR_ALERT_FATAL: libc::c_int = 2; + const TLSEXT_NAMETYPE_host_name: libc::c_int = 0; + + if arg.is_null() { + return SSL_TLSEXT_ERR_OK; + } + + unsafe { + let ctx = &*(arg as *const PySslContext); + + // Get the callback + let callback_opt = ctx.sni_callback.lock().clone(); + let Some(callback) = callback_opt else { + return SSL_TLSEXT_ERR_OK; + }; + + // Get callback data from SSL ex_data + let idx = get_sni_ex_data_index(); + let data_ptr = sys::SSL_get_ex_data(ssl_ptr, idx); + if data_ptr.is_null() { + return SSL_TLSEXT_ERR_ALERT_FATAL; + } + + let callback_data = &*(data_ptr as *const SniCallbackData); + + // SAFETY: vm_ptr is stored during wrap_socket and is valid for the lifetime + // of the SSL connection. The handshake happens synchronously in the same thread. + let vm = &*callback_data.vm_ptr; + + // Get server name + let servername = sys::SSL_get_servername(ssl_ptr, TLSEXT_NAMETYPE_host_name); + let server_name_arg = if servername.is_null() { + vm.ctx.none() + } else { + let name_cstr = std::ffi::CStr::from_ptr(servername); + match name_cstr.to_str() { + Ok(name_str) => vm.ctx.new_str(name_str).into(), + Err(_) => vm.ctx.none(), + } + }; + + // Get SSL socket from SSL ex_data (stored as PySslSocket pointer) + let ssl_socket_ptr = sys::SSL_get_ex_data(ssl_ptr, 0); // Index 0 for SSL socket + let ssl_socket_obj = if !ssl_socket_ptr.is_null() { + let ssl_socket = &*(ssl_socket_ptr as *const PySslSocket); + // Try to get owner first + ssl_socket + .owner + .read() + .as_ref() + .and_then(|weak| weak.upgrade()) + .unwrap_or_else(|| vm.ctx.none()) + } else { + vm.ctx.none() + }; + + // Call the Python callback + match callback.call( + ( + ssl_socket_obj, + server_name_arg, + callback_data.ssl_context.to_owned(), + ), + vm, + ) { + Ok(_) => SSL_TLSEXT_ERR_OK, + Err(exc) => { + // Log the exception but don't propagate it + vm.run_unraisable(exc, None, vm.ctx.none()); + SSL_TLSEXT_ERR_ALERT_FATAL + } + } + } + } + #[pyfunction(name = "RAND_pseudo_bytes")] fn rand_pseudo_bytes(n: i32, vm: &VirtualMachine) -> PyResult<(Vec, bool)> { if n < 0 { @@ -524,6 +670,7 @@ mod _ssl { check_hostname: AtomicCell, protocol: SslVersion, post_handshake_auth: PyMutex, + sni_callback: PyMutex>, } impl fmt::Debug for PySslContext { @@ -591,6 +738,28 @@ mod _ssl { .set_session_id_context(b"Python") .map_err(|e| convert_openssl_error(vm, e))?; + // Set protocol version limits based on the protocol version + unsafe { + let ctx_ptr = builder.as_ptr(); + match proto { + SslVersion::Tls1 => { + sys::SSL_CTX_set_min_proto_version(ctx_ptr, sys::TLS1_VERSION); + sys::SSL_CTX_set_max_proto_version(ctx_ptr, sys::TLS1_VERSION); + } + SslVersion::Tls1_1 => { + sys::SSL_CTX_set_min_proto_version(ctx_ptr, sys::TLS1_1_VERSION); + sys::SSL_CTX_set_max_proto_version(ctx_ptr, sys::TLS1_1_VERSION); + } + SslVersion::Tls1_2 => { + sys::SSL_CTX_set_min_proto_version(ctx_ptr, sys::TLS1_2_VERSION); + sys::SSL_CTX_set_max_proto_version(ctx_ptr, sys::TLS1_2_VERSION); + } + _ => { + // For Tls, TlsClient, TlsServer, use default (no restrictions) + } + } + } + // Set default verify flags: VERIFY_X509_TRUSTED_FIRST unsafe { let ctx_ptr = builder.as_ptr(); @@ -603,13 +772,14 @@ mod _ssl { check_hostname: AtomicCell::new(check_hostname), protocol: proto, post_handshake_auth: PyMutex::new(false), + sni_callback: PyMutex::new(None), } .into_ref_with_type(vm, cls) .map(Into::into) } } - #[pyclass(flags(BASETYPE), with(Constructor))] + #[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor))] impl PySslContext { fn builder(&self) -> PyRwLockWriteGuard<'_, SslContextBuilder> { self.ctx.write() @@ -677,6 +847,11 @@ mod _ssl { dict.set_item("name", vm.ctx.new_str(name).into(), vm)?; dict.set_item("protocol", vm.ctx.new_str(version).into(), vm)?; dict.set_item("secret_bits", vm.ctx.new_int(bits).into(), vm)?; + + // Add description field + let description = cipher_description(cipher_ptr); + dict.set_item("description", vm.ctx.new_str(description).into(), vm)?; + result.push(dict.into()); } @@ -825,8 +1000,22 @@ mod _ssl { } #[pygetset(setter)] fn set_minimum_version(&self, value: i32, vm: &VirtualMachine) -> PyResult<()> { + // Handle special values + let proto_version = match value { + -2 => { + // PY_PROTO_MINIMUM_SUPPORTED -> use minimum available (TLS 1.2) + sys::TLS1_2_VERSION + } + -1 => { + // PY_PROTO_MAXIMUM_SUPPORTED -> use maximum available + // For max on min_proto_version, we use the newest available + sys::TLS1_3_VERSION + } + _ => value, + }; + let ctx = self.builder(); - let result = unsafe { sys::SSL_CTX_set_min_proto_version(ctx.as_ptr(), value) }; + let result = unsafe { sys::SSL_CTX_set_min_proto_version(ctx.as_ptr(), proto_version) }; if result == 0 { return Err(vm.new_value_error("invalid protocol version")); } @@ -845,14 +1034,72 @@ mod _ssl { } #[pygetset(setter)] fn set_maximum_version(&self, value: i32, vm: &VirtualMachine) -> PyResult<()> { + // Handle special values + let proto_version = match value { + -1 => { + // PY_PROTO_MAXIMUM_SUPPORTED -> use 0 for OpenSSL (means no limit) + 0 + } + -2 => { + // PY_PROTO_MINIMUM_SUPPORTED -> use minimum available (TLS 1.2) + sys::TLS1_2_VERSION + } + _ => value, + }; + let ctx = self.builder(); - let result = unsafe { sys::SSL_CTX_set_max_proto_version(ctx.as_ptr(), value) }; + let result = unsafe { sys::SSL_CTX_set_max_proto_version(ctx.as_ptr(), proto_version) }; if result == 0 { return Err(vm.new_value_error("invalid protocol version")); } Ok(()) } + #[pygetset] + fn num_tickets(&self, _vm: &VirtualMachine) -> PyResult { + // Only supported for TLS 1.3 + #[cfg(ossl110)] + { + let ctx = self.ctx(); + let num = unsafe { sys::SSL_CTX_get_num_tickets(ctx.as_ptr()) }; + Ok(num) + } + #[cfg(not(ossl110))] + { + let _ = vm; + Ok(0) + } + } + #[pygetset(setter)] + fn set_num_tickets(&self, value: isize, vm: &VirtualMachine) -> PyResult<()> { + // Check for negative values + if value < 0 { + return Err( + vm.new_value_error("num_tickets must be a non-negative integer".to_owned()) + ); + } + + // Check that this is a server context + if self.protocol != SslVersion::TlsServer { + return Err(vm.new_value_error("SSLContext is not a server context.".to_owned())); + } + + #[cfg(ossl110)] + { + let ctx = self.builder(); + let result = unsafe { sys::SSL_CTX_set_num_tickets(ctx.as_ptr(), value as usize) }; + if result != 1 { + return Err(vm.new_value_error("failed to set num tickets.")); + } + Ok(()) + } + #[cfg(not(ossl110))] + { + let _ = (value, vm); + Ok(()) + } + } + #[pymethod] fn set_default_verify_paths(&self, vm: &VirtualMachine) -> PyResult<()> { cfg_if::cfg_if! { @@ -976,6 +1223,208 @@ mod _ssl { Ok(certs) } + #[pymethod] + fn cert_store_stats(&self, vm: &VirtualMachine) -> PyResult { + let ctx = self.ctx(); + let store_ptr = unsafe { sys::SSL_CTX_get_cert_store(ctx.as_ptr()) }; + + if store_ptr.is_null() { + return Err(vm.new_memory_error("failed to get cert store".to_owned())); + } + + let objs_ptr = unsafe { sys::X509_STORE_get0_objects(store_ptr) }; + if objs_ptr.is_null() { + return Err(vm.new_memory_error("failed to query cert store".to_owned())); + } + + let mut x509_count = 0; + let mut crl_count = 0; + let mut ca_count = 0; + + unsafe { + let num_objs = sys::OPENSSL_sk_num(objs_ptr as *const _); + for i in 0..num_objs { + let obj_ptr = + sys::OPENSSL_sk_value(objs_ptr as *const _, i) as *const sys::X509_OBJECT; + let obj_type = X509_OBJECT_get_type(obj_ptr); + + match obj_type { + X509_LU_X509 => { + x509_count += 1; + let x509_ptr = sys::X509_OBJECT_get0_X509(obj_ptr); + if !x509_ptr.is_null() && X509_check_ca(x509_ptr) == 1 { + ca_count += 1; + } + } + X509_LU_CRL => { + crl_count += 1; + } + _ => { + // Ignore unrecognized types + } + } + } + // Note: No need to free objs_ptr as X509_STORE_get0_objects returns + // a pointer to internal data that should not be freed by the caller + } + + let dict = vm.ctx.new_dict(); + dict.set_item("x509", vm.ctx.new_int(x509_count).into(), vm)?; + dict.set_item("crl", vm.ctx.new_int(crl_count).into(), vm)?; + dict.set_item("x509_ca", vm.ctx.new_int(ca_count).into(), vm)?; + Ok(dict.into()) + } + + #[pymethod] + fn session_stats(&self, vm: &VirtualMachine) -> PyResult { + let ctx = self.ctx(); + let ctx_ptr = ctx.as_ptr(); + + let dict = vm.ctx.new_dict(); + + macro_rules! add_stat { + ($key:expr, $func:ident) => { + let value = unsafe { $func(ctx_ptr) }; + dict.set_item($key, vm.ctx.new_int(value).into(), vm)?; + }; + } + + add_stat!("number", SSL_CTX_sess_number); + add_stat!("connect", SSL_CTX_sess_connect); + add_stat!("connect_good", SSL_CTX_sess_connect_good); + add_stat!("connect_renegotiate", SSL_CTX_sess_connect_renegotiate); + add_stat!("accept", SSL_CTX_sess_accept); + add_stat!("accept_good", SSL_CTX_sess_accept_good); + add_stat!("accept_renegotiate", SSL_CTX_sess_accept_renegotiate); + add_stat!("hits", SSL_CTX_sess_hits); + add_stat!("misses", SSL_CTX_sess_misses); + add_stat!("timeouts", SSL_CTX_sess_timeouts); + add_stat!("cache_full", SSL_CTX_sess_cache_full); + + Ok(dict.into()) + } + + #[pymethod] + fn load_dh_params(&self, filepath: FsPath, vm: &VirtualMachine) -> PyResult<()> { + let path = filepath.to_path_buf(vm)?; + + // Open the file using fopen (cross-platform) + let fp = + rustpython_common::fileutils::fopen(path.as_path(), "rb").map_err(|e| { + match e.kind() { + std::io::ErrorKind::NotFound => vm.new_exception_msg( + vm.ctx.exceptions.file_not_found_error.to_owned(), + e.to_string(), + ), + _ => vm.new_os_error(e.to_string()), + } + })?; + + // Read DH parameters + let dh = unsafe { + PEM_read_DHparams( + fp, + std::ptr::null_mut(), + std::ptr::null_mut(), + std::ptr::null_mut(), + ) + }; + unsafe { + libc::fclose(fp); + } + + if dh.is_null() { + return Err(convert_openssl_error(vm, ErrorStack::get())); + } + + // Set temporary DH parameters + let ctx = self.builder(); + let result = unsafe { sys::SSL_CTX_set_tmp_dh(ctx.as_ptr(), dh) }; + unsafe { + sys::DH_free(dh); + } + + if result != 1 { + return Err(convert_openssl_error(vm, ErrorStack::get())); + } + + Ok(()) + } + + #[pygetset] + fn sni_callback(&self) -> Option { + self.sni_callback.lock().clone() + } + + #[pygetset(setter)] + fn set_sni_callback( + &self, + value: Option, + vm: &VirtualMachine, + ) -> PyResult<()> { + // Check if this is a server context + if self.protocol == SslVersion::TlsClient { + return Err(vm.new_value_error( + "sni_callback cannot be set on TLS_CLIENT context".to_owned(), + )); + } + + let mut callback_guard = self.sni_callback.lock(); + + if let Some(callback_obj) = value { + if !vm.is_none(&callback_obj) { + // Check if callable + if !callback_obj.is_callable() { + return Err(vm.new_type_error("not a callable object".to_owned())); + } + + // Set the callback + *callback_guard = Some(callback_obj); + + // Set OpenSSL callback + unsafe { + sys::SSL_CTX_set_tlsext_servername_callback__fixed_rust( + self.ctx().as_ptr(), + Some(_servername_callback), + ); + sys::SSL_CTX_set_tlsext_servername_arg( + self.ctx().as_ptr(), + self as *const _ as *mut _, + ); + } + } else { + // Clear callback + *callback_guard = None; + unsafe { + sys::SSL_CTX_set_tlsext_servername_callback__fixed_rust( + self.ctx().as_ptr(), + None, + ); + } + } + } else { + // Clear callback + *callback_guard = None; + unsafe { + sys::SSL_CTX_set_tlsext_servername_callback__fixed_rust( + self.ctx().as_ptr(), + None, + ); + } + } + + Ok(()) + } + + #[pymethod] + fn set_servername_callback( + &self, + callback: Option, + vm: &VirtualMachine, + ) -> PyResult<()> { + self.set_sni_callback(callback, vm) + } + #[pymethod] fn load_cert_chain(&self, args: LoadCertChainArgs, vm: &VirtualMachine) -> PyResult<()> { let LoadCertChainArgs { @@ -1006,7 +1455,7 @@ mod _ssl { zelf: PyRef, args: WrapSocketArgs, vm: &VirtualMachine, - ) -> PyResult { + ) -> PyResult { // validate socket type and context protocol if !args.server_side && zelf.protocol == SslVersion::TlsServer { return Err(vm.new_exception_msg( @@ -1038,6 +1487,9 @@ mod _ssl { "server_hostname cannot be an empty string or start with a leading dot.", )); } + if hostname.contains('\0') { + return Err(vm.new_value_error("embedded null byte in server_hostname")); + } let ip = hostname.parse::(); if ip.is_err() { ssl.set_hostname(hostname) @@ -1056,34 +1508,203 @@ mod _ssl { } } + // Configure post-handshake authentication (PHA) + #[cfg(ossl111)] + if *zelf.post_handshake_auth.lock() { + unsafe { + if args.server_side { + // Server socket: add SSL_VERIFY_POST_HANDSHAKE flag + // Only in combination with SSL_VERIFY_PEER + let mode = sys::SSL_get_verify_mode(ssl.as_ptr()); + if (mode & sys::SSL_VERIFY_PEER as libc::c_int) != 0 { + // Add POST_HANDSHAKE flag (keep existing flags including FAIL_IF_NO_PEER_CERT) + sys::SSL_set_verify( + ssl.as_ptr(), + mode | SSL_VERIFY_POST_HANDSHAKE, + None, + ); + } + } else { + // Client socket: call SSL_set_post_handshake_auth + SSL_set_post_handshake_auth(ssl.as_ptr(), 1); + } + } + } + let stream = ssl::SslStream::new(ssl, SocketStream(args.sock.clone())) .map_err(|e| convert_openssl_error(vm, e))?; let py_ssl_socket = PySslSocket { - ctx: zelf, - stream: PyRwLock::new(stream), + ctx: PyRwLock::new(zelf.clone()), + connection: PyRwLock::new(SslConnection::Socket(stream)), socket_type, server_hostname: args.server_hostname, owner: PyRwLock::new(args.owner.map(|o| o.downgrade(None, vm)).transpose()?), }; + // Convert to PyRef (heap allocation) to avoid use-after-free + let py_ref = + py_ssl_socket.into_ref_with_type(vm, PySslSocket::class(&vm.ctx).to_owned())?; + + // Set SNI callback data if callback is configured + if zelf.sni_callback.lock().is_some() { + unsafe { + let ssl_ptr = py_ref.connection.read().ssl().as_ptr(); + + // Store callback data in SSL ex_data + let callback_data = Box::new(SniCallbackData { + ssl_context: zelf.clone(), + vm_ptr: vm as *const _, + }); + let idx = get_sni_ex_data_index(); + sys::SSL_set_ex_data(ssl_ptr, idx, Box::into_raw(callback_data) as *mut _); + + // Store PyRef pointer (heap-allocated) in ex_data index 0 + sys::SSL_set_ex_data(ssl_ptr, 0, &*py_ref as *const _ as *mut _); + } + } + // Set session if provided if let Some(session) = args.session && !vm.is_none(&session) { - py_ssl_socket.set_session(session, vm)?; + py_ref.set_session(session, vm)?; } - Ok(py_ssl_socket) + Ok(py_ref.into()) } #[pymethod] - fn _wrap_bio(_zelf: PyRef, _args: WrapBioArgs, vm: &VirtualMachine) -> PyResult { - // TODO: Implement BIO-based SSL wrapping - // This requires refactoring PySslSocket to support both socket and BIO modes - Err(vm.new_not_implemented_error( - "_wrap_bio is not yet implemented in RustPython".to_owned(), - )) + fn _wrap_bio( + zelf: PyRef, + args: WrapBioArgs, + vm: &VirtualMachine, + ) -> PyResult { + // validate socket type and context protocol + if !args.server_side && zelf.protocol == SslVersion::TlsServer { + return Err(vm.new_exception_msg( + PySslError::class(&vm.ctx).to_owned(), + "Cannot create a client socket with a PROTOCOL_TLS_SERVER context".to_owned(), + )); + } + if args.server_side && zelf.protocol == SslVersion::TlsClient { + return Err(vm.new_exception_msg( + PySslError::class(&vm.ctx).to_owned(), + "Cannot create a server socket with a PROTOCOL_TLS_CLIENT context".to_owned(), + )); + } + + let mut ssl = ssl::Ssl::new(&zelf.ctx()).map_err(|e| convert_openssl_error(vm, e))?; + + let socket_type = if args.server_side { + ssl.set_accept_state(); + SslServerOrClient::Server + } else { + ssl.set_connect_state(); + SslServerOrClient::Client + }; + + if let Some(hostname) = &args.server_hostname { + let hostname = hostname.as_str(); + if hostname.is_empty() || hostname.starts_with('.') { + return Err(vm.new_value_error( + "server_hostname cannot be an empty string or start with a leading dot.", + )); + } + if hostname.contains('\0') { + return Err(vm.new_value_error("embedded null byte in server_hostname")); + } + let ip = hostname.parse::(); + if ip.is_err() { + ssl.set_hostname(hostname) + .map_err(|e| convert_openssl_error(vm, e))?; + } + if zelf.check_hostname.load() { + if let Ok(ip) = ip { + ssl.param_mut() + .set_ip(ip) + .map_err(|e| convert_openssl_error(vm, e))?; + } else { + ssl.param_mut() + .set_host(hostname) + .map_err(|e| convert_openssl_error(vm, e))?; + } + } + } + + // Don't use SSL_set_bio - let SslStream drive I/O through BioStream Read/Write + + // Configure post-handshake authentication (PHA) + #[cfg(ossl111)] + if *zelf.post_handshake_auth.lock() { + unsafe { + if args.server_side { + // Server socket: add SSL_VERIFY_POST_HANDSHAKE flag + // Only in combination with SSL_VERIFY_PEER + let mode = sys::SSL_get_verify_mode(ssl.as_ptr()); + if (mode & sys::SSL_VERIFY_PEER as libc::c_int) != 0 { + // Add POST_HANDSHAKE flag (keep existing flags including FAIL_IF_NO_PEER_CERT) + sys::SSL_set_verify( + ssl.as_ptr(), + mode | SSL_VERIFY_POST_HANDSHAKE, + None, + ); + } + } else { + // Client socket: call SSL_set_post_handshake_auth + SSL_set_post_handshake_auth(ssl.as_ptr(), 1); + } + } + } + + // Create a BioStream wrapper (dummy, actual IO goes through BIOs) + let bio_stream = BioStream { + inbio: args.incoming, + outbio: args.outgoing, + }; + + // Create SslStream with BioStream + let stream = + ssl::SslStream::new(ssl, bio_stream).map_err(|e| convert_openssl_error(vm, e))?; + + let py_ssl_socket = PySslSocket { + ctx: PyRwLock::new(zelf.clone()), + connection: PyRwLock::new(SslConnection::Bio(stream)), + socket_type, + server_hostname: args.server_hostname, + owner: PyRwLock::new(args.owner.map(|o| o.downgrade(None, vm)).transpose()?), + }; + + // Convert to PyRef (heap allocation) to avoid use-after-free + let py_ref = + py_ssl_socket.into_ref_with_type(vm, PySslSocket::class(&vm.ctx).to_owned())?; + + // Set SNI callback data if callback is configured + if zelf.sni_callback.lock().is_some() { + unsafe { + let ssl_ptr = py_ref.connection.read().ssl().as_ptr(); + + // Store callback data in SSL ex_data + let callback_data = Box::new(SniCallbackData { + ssl_context: zelf.clone(), + vm_ptr: vm as *const _, + }); + let idx = get_sni_ex_data_index(); + sys::SSL_set_ex_data(ssl_ptr, idx, Box::into_raw(callback_data) as *mut _); + + // Store PyRef pointer (heap-allocated) in ex_data index 0 + sys::SSL_set_ex_data(ssl_ptr, 0, &*py_ref as *const _ as *mut _); + } + } + + // Set session if provided + if let Some(session) = args.session + && !vm.is_none(&session) + { + py_ref.set_session(session, vm)?; + } + + Ok(py_ref.into()) } } @@ -1205,13 +1826,125 @@ mod _ssl { ) } + // BIO stream wrapper to implement Read/Write traits for MemoryBIO + struct BioStream { + inbio: PyRef, + outbio: PyRef, + } + + impl Read for BioStream { + fn read(&mut self, buf: &mut [u8]) -> std::io::Result { + // Read from incoming MemoryBIO + unsafe { + let nbytes = sys::BIO_read( + self.inbio.bio, + buf.as_mut_ptr() as *mut _, + buf.len().min(i32::MAX as usize) as i32, + ); + if nbytes < 0 { + // BIO_read returns -1 on error or when no data is available + // Check if it's a retry condition (WANT_READ) + Err(std::io::Error::new( + std::io::ErrorKind::WouldBlock, + "BIO has no data available", + )) + } else { + Ok(nbytes as usize) + } + } + } + } + + impl Write for BioStream { + fn write(&mut self, buf: &[u8]) -> std::io::Result { + // Write to outgoing MemoryBIO + unsafe { + let nbytes = sys::BIO_write( + self.outbio.bio, + buf.as_ptr() as *const _, + buf.len().min(i32::MAX as usize) as i32, + ); + if nbytes < 0 { + return Err(std::io::Error::other("BIO write failed")); + } + Ok(nbytes as usize) + } + } + + fn flush(&mut self) -> std::io::Result<()> { + // MemoryBIO doesn't need flushing + Ok(()) + } + } + + // Enum to represent different SSL connection modes + enum SslConnection { + Socket(ssl::SslStream), + Bio(ssl::SslStream), + } + + impl SslConnection { + // Get a reference to the SSL object + fn ssl(&self) -> &ssl::SslRef { + match self { + SslConnection::Socket(stream) => stream.ssl(), + SslConnection::Bio(stream) => stream.ssl(), + } + } + + // Get underlying socket stream reference (only for socket mode) + fn get_ref(&self) -> Option<&SocketStream> { + match self { + SslConnection::Socket(stream) => Some(stream.get_ref()), + SslConnection::Bio(_) => None, + } + } + + // Check if this is in BIO mode + fn is_bio(&self) -> bool { + matches!(self, SslConnection::Bio(_)) + } + + // Perform SSL handshake + fn do_handshake(&mut self) -> Result<(), ssl::Error> { + match self { + SslConnection::Socket(stream) => stream.do_handshake(), + SslConnection::Bio(stream) => stream.do_handshake(), + } + } + + // Write data to SSL connection + fn ssl_write(&mut self, buf: &[u8]) -> Result { + match self { + SslConnection::Socket(stream) => stream.ssl_write(buf), + SslConnection::Bio(stream) => stream.ssl_write(buf), + } + } + + // Read data from SSL connection + fn ssl_read(&mut self, buf: &mut [u8]) -> Result { + match self { + SslConnection::Socket(stream) => stream.ssl_read(buf), + SslConnection::Bio(stream) => stream.ssl_read(buf), + } + } + + // Get SSL shutdown state + fn get_shutdown(&mut self) -> ssl::ShutdownState { + match self { + SslConnection::Socket(stream) => stream.get_shutdown(), + SslConnection::Bio(stream) => stream.get_shutdown(), + } + } + } + #[pyattr] #[pyclass(module = "ssl", name = "_SSLSocket", traverse)] #[derive(PyPayload)] struct PySslSocket { - ctx: PyRef, + ctx: PyRwLock>, #[pytraverse(skip)] - stream: PyRwLock>, + connection: PyRwLock, #[pytraverse(skip)] socket_type: SslServerOrClient, server_hostname: Option, @@ -1224,7 +1957,7 @@ mod _ssl { } } - #[pyclass] + #[pyclass(flags(IMMUTABLETYPE))] impl PySslSocket { #[pygetset] fn owner(&self) -> Option { @@ -1243,7 +1976,24 @@ mod _ssl { } #[pygetset] fn context(&self) -> PyRef { - self.ctx.clone() + self.ctx.read().clone() + } + #[pygetset(setter)] + fn set_context(&self, value: PyRef, vm: &VirtualMachine) -> PyResult<()> { + // Update the SSL context in the underlying SSL object + let stream = self.connection.read(); + + // Set the new SSL_CTX on the SSL object + unsafe { + let result = SSL_set_SSL_CTX(stream.ssl().as_ptr(), value.ctx().as_ptr()); + if result.is_null() { + return Err(vm.new_runtime_error("Failed to set SSL context".to_owned())); + } + } + + // Update self.ctx to the new context + *self.ctx.write() = value; + Ok(()) } #[pygetset] fn server_hostname(&self) -> Option { @@ -1257,20 +2007,38 @@ mod _ssl { vm: &VirtualMachine, ) -> PyResult> { let binary = binary.unwrap_or(false); - let stream = self.stream.read(); + let stream = self.connection.read(); if !stream.ssl().is_init_finished() { return Err(vm.new_value_error("handshake not done yet")); } - stream - .ssl() - .peer_certificate() - .map(|cert| cert_to_py(vm, &cert, binary)) - .transpose() + + let peer_cert = stream.ssl().peer_certificate(); + let Some(cert) = peer_cert else { + return Ok(None); + }; + + if binary { + // Return DER-encoded certificate + cert_to_py(vm, &cert, true).map(Some) + } else { + // Check verify_mode + unsafe { + let ssl_ctx = sys::SSL_get_SSL_CTX(stream.ssl().as_ptr()); + let verify_mode = sys::SSL_CTX_get_verify_mode(ssl_ctx); + if (verify_mode & sys::SSL_VERIFY_PEER as libc::c_int) == 0 { + // Return empty dict when SSL_VERIFY_PEER is not set + Ok(Some(vm.ctx.new_dict().into())) + } else { + // Return decoded certificate + cert_to_py(vm, &cert, false).map(Some) + } + } + } } #[pymethod] fn get_unverified_chain(&self, vm: &VirtualMachine) -> PyResult> { - let stream = self.stream.read(); + let stream = self.connection.read(); let Some(chain) = stream.ssl().peer_cert_chain() else { return Ok(None); }; @@ -1289,7 +2057,7 @@ mod _ssl { #[pymethod] fn get_verified_chain(&self, vm: &VirtualMachine) -> PyResult> { - let stream = self.stream.read(); + let stream = self.connection.read(); unsafe { let chain = sys::SSL_get0_verified_chain(stream.ssl().as_ptr()); if chain.is_null() { @@ -1322,13 +2090,13 @@ mod _ssl { #[pymethod] fn version(&self) -> Option<&'static str> { - let v = self.stream.read().ssl().version_str(); + let v = self.connection.read().ssl().version_str(); if v == "unknown" { None } else { Some(v) } } #[pymethod] fn cipher(&self) -> Option { - self.stream + self.connection .read() .ssl() .current_cipher() @@ -1339,7 +2107,7 @@ mod _ssl { fn shared_ciphers(&self, vm: &VirtualMachine) -> Option { #[cfg(ossl110)] { - let stream = self.stream.read(); + let stream = self.connection.read(); unsafe { let server_ciphers = SSL_get_ciphers(stream.ssl().as_ptr()); if server_ciphers.is_null() { @@ -1402,7 +2170,7 @@ mod _ssl { fn selected_alpn_protocol(&self) -> Option { #[cfg(ossl102)] { - let stream = self.stream.read(); + let stream = self.connection.read(); unsafe { let mut out: *const libc::c_uchar = std::ptr::null(); let mut outlen: libc::c_uint = 0; @@ -1440,7 +2208,7 @@ mod _ssl { ))); } - let stream = self.stream.read(); + let stream = self.connection.read(); let ssl_ptr = stream.ssl().as_ptr(); unsafe { @@ -1470,13 +2238,10 @@ mod _ssl { fn verify_client_post_handshake(&self, vm: &VirtualMachine) -> PyResult<()> { #[cfg(ossl111)] { - let stream = self.stream.read(); + let stream = self.connection.read(); let result = unsafe { SSL_verify_client_post_handshake(stream.ssl().as_ptr()) }; if result == 0 { - Err(vm.new_exception_msg( - PySslError::class(&vm.ctx).to_owned(), - "Post-handshake authentication failed".to_owned(), - )) + Err(convert_openssl_error(vm, openssl::error::ErrorStack::get())) } else { Ok(()) } @@ -1491,7 +2256,15 @@ mod _ssl { #[pymethod] fn shutdown(&self, vm: &VirtualMachine) -> PyResult> { - let stream = self.stream.read(); + let stream = self.connection.read(); + + // BIO mode doesn't have an underlying socket + if stream.is_bio() { + return Err(vm.new_not_implemented_error( + "shutdown() is not supported for BIO-based SSL objects".to_owned(), + )); + } + let ssl_ptr = stream.ssl().as_ptr(); // Perform SSL shutdown @@ -1514,7 +2287,9 @@ mod _ssl { // Return the underlying socket // Get the socket from the stream (SocketStream wraps PyRef) - let socket = stream.get_ref(); + let socket = stream + .get_ref() + .expect("unwrap() called on bio mode; should only be called in socket mode"); Ok(socket.0.clone()) } @@ -1526,7 +2301,7 @@ mod _ssl { #[cfg(not(osslconf = "OPENSSL_NO_COMP"))] #[pymethod] fn compression(&self) -> Option<&'static str> { - let stream = self.stream.read(); + let stream = self.connection.read(); let comp_method = unsafe { sys::SSL_get_current_compression(stream.ssl().as_ptr()) }; if comp_method.is_null() { return None; @@ -1541,14 +2316,35 @@ mod _ssl { #[pymethod] fn do_handshake(&self, vm: &VirtualMachine) -> PyResult<()> { - let mut stream = self.stream.write(); - let timeout = stream.get_ref().timeout_deadline(); + let mut stream = self.connection.write(); + let ssl_ptr = stream.ssl().as_ptr(); + + // BIO mode: no timeout/select logic, just do handshake + if stream.is_bio() { + return stream.do_handshake().map_err(|e| { + let exc = convert_ssl_error(vm, e); + // If it's a cert verification error, set verify info + if exc.class().is(PySslCertVerificationError::class(&vm.ctx)) { + set_verify_error_info(&exc, ssl_ptr, vm); + } + exc + }); + } + + // Socket mode: handle timeout and blocking + let timeout = stream + .get_ref() + .expect("handshake called in bio mode; should only be called in socket mode") + .timeout_deadline(); loop { let err = match stream.do_handshake() { Ok(()) => return Ok(()), Err(e) => e, }; - let (needs, state) = stream.get_ref().socket_needs(&err, &timeout); + let (needs, state) = stream + .get_ref() + .expect("handshake called in bio mode; should only be called in socket mode") + .socket_needs(&err, &timeout); match state { SelectRet::TimedOut => { return Err(socket::timeout_error_msg( @@ -1564,17 +2360,32 @@ mod _ssl { } } } - return Err(convert_ssl_error(vm, err)); + let exc = convert_ssl_error(vm, err); + // If it's a cert verification error, set verify info + if exc.class().is(PySslCertVerificationError::class(&vm.ctx)) { + set_verify_error_info(&exc, ssl_ptr, vm); + } + return Err(exc); } } #[pymethod] fn write(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult { - let mut stream = self.stream.write(); + let mut stream = self.connection.write(); let data = data.borrow_buf(); let data = &*data; - let timeout = stream.get_ref().timeout_deadline(); - let state = stream.get_ref().select(SslNeeds::Write, &timeout); + + // BIO mode: no timeout/select logic + if stream.is_bio() { + return stream.ssl_write(data).map_err(|e| convert_ssl_error(vm, e)); + } + + // Socket mode: handle timeout and blocking + let socket_ref = stream + .get_ref() + .expect("write called in bio mode; should only be called in socket mode"); + let timeout = socket_ref.timeout_deadline(); + let state = socket_ref.select(SslNeeds::Write, &timeout); match state { SelectRet::TimedOut => { return Err(socket::timeout_error_msg( @@ -1590,7 +2401,10 @@ mod _ssl { Ok(len) => return Ok(len), Err(e) => e, }; - let (needs, state) = stream.get_ref().socket_needs(&err, &timeout); + let (needs, state) = stream + .get_ref() + .expect("write called in bio mode; should only be called in socket mode") + .socket_needs(&err, &timeout); match state { SelectRet::TimedOut => { return Err(socket::timeout_error_msg( @@ -1612,7 +2426,7 @@ mod _ssl { #[pygetset] fn session(&self, _vm: &VirtualMachine) -> PyResult> { - let stream = self.stream.read(); + let stream = self.connection.read(); unsafe { let session_ptr = sys::SSL_get_session(stream.ssl().as_ptr()); if session_ptr.is_null() { @@ -1624,7 +2438,7 @@ mod _ssl { Ok(Some(PySslSession { session: session_ptr, - ctx: self.ctx.clone(), + ctx: self.ctx.read().clone(), })) } } @@ -1639,7 +2453,7 @@ mod _ssl { // Check if session refers to the same SSLContext if !std::ptr::eq( - self.ctx.ctx.read().as_ptr(), + self.ctx.read().ctx.read().as_ptr(), session.ctx.ctx.read().as_ptr(), ) { return Err( @@ -1655,7 +2469,7 @@ mod _ssl { } // Check if handshake is not finished - let stream = self.stream.read(); + let stream = self.connection.read(); unsafe { if sys::SSL_is_init_finished(stream.ssl().as_ptr()) != 0 { return Err( @@ -1673,7 +2487,7 @@ mod _ssl { #[pygetset] fn session_reused(&self) -> bool { - let stream = self.stream.read(); + let stream = self.connection.read(); unsafe { sys::SSL_session_reused(stream.ssl().as_ptr()) != 0 } } @@ -1684,7 +2498,16 @@ mod _ssl { buffer: OptionalArg, vm: &VirtualMachine, ) -> PyResult { - let mut stream = self.stream.write(); + // Special case: reading 0 bytes should return empty bytes immediately + if n == 0 { + return if buffer.is_present() { + Ok(vm.ctx.new_int(0).into()) + } else { + Ok(vm.ctx.new_bytes(vec![]).into()) + }; + } + + let mut stream = self.connection.write(); let mut inner_buffer = if let OptionalArg::Present(buffer) = &buffer { Either::A(buffer.borrow_buf_mut()) } else { @@ -1698,33 +2521,49 @@ mod _ssl { Some(b) => b, None => buf, }; - let timeout = stream.get_ref().timeout_deadline(); - let count = loop { - let err = match stream.ssl_read(buf) { - Ok(count) => break count, - Err(e) => e, - }; - if err.code() == ssl::ErrorCode::ZERO_RETURN - && stream.get_shutdown() == ssl::ShutdownState::RECEIVED - { - break 0; + + // BIO mode: no timeout/select logic + let count = if stream.is_bio() { + match stream.ssl_read(buf) { + Ok(count) => count, + Err(e) => return Err(convert_ssl_error(vm, e)), } - let (needs, state) = stream.get_ref().socket_needs(&err, &timeout); - match state { - SelectRet::TimedOut => { - return Err(socket::timeout_error_msg( - vm, - "The read operation timed out".to_owned(), - )); + } else { + // Socket mode: handle timeout and blocking + let timeout = stream + .get_ref() + .expect("read called in bio mode; should only be called in socket mode") + .timeout_deadline(); + loop { + let err = match stream.ssl_read(buf) { + Ok(count) => break count, + Err(e) => e, + }; + if err.code() == ssl::ErrorCode::ZERO_RETURN + && stream.get_shutdown() == ssl::ShutdownState::RECEIVED + { + break 0; } - SelectRet::Nonblocking => {} - _ => { - if needs.is_some() { - continue; + let (needs, state) = stream + .get_ref() + .expect("read called in bio mode; should only be called in socket mode") + .socket_needs(&err, &timeout); + match state { + SelectRet::TimedOut => { + return Err(socket::timeout_error_msg( + vm, + "The read operation timed out".to_owned(), + )); + } + SelectRet::Nonblocking => {} + _ => { + if needs.is_some() { + continue; + } } } + return Err(convert_ssl_error(vm, err)); } - return Err(convert_ssl_error(vm, err)); }; let ret = match inner_buffer { Either::A(_buf) => vm.ctx.new_int(count).into(), @@ -1844,6 +2683,7 @@ mod _ssl { #[cfg(ossl111)] unsafe extern "C" { fn SSL_verify_client_post_handshake(ssl: *const sys::SSL) -> libc::c_int; + fn SSL_set_post_handshake_auth(ssl: *mut sys::SSL, val: libc::c_int); } #[cfg(ossl110)] @@ -1851,6 +2691,152 @@ mod _ssl { fn SSL_CTX_get_security_level(ctx: *const sys::SSL_CTX) -> libc::c_int; } + unsafe extern "C" { + fn SSL_set_SSL_CTX(ssl: *mut sys::SSL, ctx: *mut sys::SSL_CTX) -> *mut sys::SSL_CTX; + } + + #[cfg(ossl110)] + unsafe extern "C" { + fn SSL_SESSION_has_ticket(session: *const sys::SSL_SESSION) -> libc::c_int; + fn SSL_SESSION_get_ticket_lifetime_hint(session: *const sys::SSL_SESSION) -> libc::c_ulong; + } + + // X509 object types + const X509_LU_X509: libc::c_int = 1; + const X509_LU_CRL: libc::c_int = 2; + + unsafe extern "C" { + fn X509_OBJECT_get_type(obj: *const sys::X509_OBJECT) -> libc::c_int; + } + + // SSL session statistics constants (used with SSL_CTX_ctrl) + const SSL_CTRL_SESS_NUMBER: libc::c_int = 20; + const SSL_CTRL_SESS_CONNECT: libc::c_int = 21; + const SSL_CTRL_SESS_CONNECT_GOOD: libc::c_int = 22; + const SSL_CTRL_SESS_CONNECT_RENEGOTIATE: libc::c_int = 23; + const SSL_CTRL_SESS_ACCEPT: libc::c_int = 24; + const SSL_CTRL_SESS_ACCEPT_GOOD: libc::c_int = 25; + const SSL_CTRL_SESS_ACCEPT_RENEGOTIATE: libc::c_int = 26; + const SSL_CTRL_SESS_HIT: libc::c_int = 27; + const SSL_CTRL_SESS_MISSES: libc::c_int = 29; + const SSL_CTRL_SESS_TIMEOUTS: libc::c_int = 30; + const SSL_CTRL_SESS_CACHE_FULL: libc::c_int = 31; + + // SSL session statistics functions (implemented as macros in OpenSSL) + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_number(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { sys::SSL_CTX_ctrl(ctx as *mut _, SSL_CTRL_SESS_NUMBER, 0, std::ptr::null_mut()) } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_connect(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { + sys::SSL_CTX_ctrl( + ctx as *mut _, + SSL_CTRL_SESS_CONNECT, + 0, + std::ptr::null_mut(), + ) + } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_connect_good(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { + sys::SSL_CTX_ctrl( + ctx as *mut _, + SSL_CTRL_SESS_CONNECT_GOOD, + 0, + std::ptr::null_mut(), + ) + } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_connect_renegotiate(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { + sys::SSL_CTX_ctrl( + ctx as *mut _, + SSL_CTRL_SESS_CONNECT_RENEGOTIATE, + 0, + std::ptr::null_mut(), + ) + } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_accept(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { sys::SSL_CTX_ctrl(ctx as *mut _, SSL_CTRL_SESS_ACCEPT, 0, std::ptr::null_mut()) } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_accept_good(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { + sys::SSL_CTX_ctrl( + ctx as *mut _, + SSL_CTRL_SESS_ACCEPT_GOOD, + 0, + std::ptr::null_mut(), + ) + } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_accept_renegotiate(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { + sys::SSL_CTX_ctrl( + ctx as *mut _, + SSL_CTRL_SESS_ACCEPT_RENEGOTIATE, + 0, + std::ptr::null_mut(), + ) + } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_hits(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { sys::SSL_CTX_ctrl(ctx as *mut _, SSL_CTRL_SESS_HIT, 0, std::ptr::null_mut()) } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_misses(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { sys::SSL_CTX_ctrl(ctx as *mut _, SSL_CTRL_SESS_MISSES, 0, std::ptr::null_mut()) } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_timeouts(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { + sys::SSL_CTX_ctrl( + ctx as *mut _, + SSL_CTRL_SESS_TIMEOUTS, + 0, + std::ptr::null_mut(), + ) + } + } + + #[allow(non_snake_case)] + unsafe fn SSL_CTX_sess_cache_full(ctx: *const sys::SSL_CTX) -> libc::c_long { + unsafe { + sys::SSL_CTX_ctrl( + ctx as *mut _, + SSL_CTRL_SESS_CACHE_FULL, + 0, + std::ptr::null_mut(), + ) + } + } + + // DH parameters functions + unsafe extern "C" { + fn PEM_read_DHparams( + fp: *mut libc::FILE, + x: *mut *mut sys::DH, + cb: *mut libc::c_void, + u: *mut libc::c_void, + ) -> *mut sys::DH; + } + // OpenSSL BIO helper functions // These are typically macros in OpenSSL, implemented via BIO_ctrl const BIO_CTRL_PENDING: libc::c_int = 10; @@ -1903,7 +2889,7 @@ mod _ssl { } } - #[pyclass(with(Constructor))] + #[pyclass(flags(IMMUTABLETYPE), with(Constructor))] impl PySslMemoryBio { #[pygetset] fn pending(&self) -> usize { @@ -1974,7 +2960,7 @@ mod _ssl { } } - #[pyclass(with(Comparable))] + #[pyclass(flags(IMMUTABLETYPE), with(Comparable))] impl PySslSession { #[pygetset] fn time(&self) -> i64 { @@ -1997,17 +2983,14 @@ mod _ssl { #[pygetset] fn ticket_lifetime_hint(&self) -> u64 { - // SSL_SESSION_get_ticket_lifetime_hint may not be available in older OpenSSL - // Return 0 as default if not available + // SSL_SESSION_get_ticket_lifetime_hint available in OpenSSL 1.1.0+ #[cfg(ossl110)] { - // For now, return 0 as this function may not be in openssl-sys - let _ = self.session; - 0 + unsafe { SSL_SESSION_get_ticket_lifetime_hint(self.session) as u64 } } #[cfg(not(ossl110))] { - let _ = self.session; + // Not available in older OpenSSL versions 0 } } @@ -2024,17 +3007,14 @@ mod _ssl { #[pygetset] fn has_ticket(&self) -> bool { - // SSL_SESSION_has_ticket may not be available in older OpenSSL - // Return false as default + // SSL_SESSION_has_ticket available in OpenSSL 1.1.0+ #[cfg(ossl110)] { - // For now, return false as this function may not be in openssl-sys - let _ = self.session; - false + unsafe { SSL_SESSION_has_ticket(self.session) != 0 } } #[cfg(not(ossl110))] { - let _ = self.session; + // Not available in older OpenSSL versions false } } @@ -2045,25 +3025,71 @@ mod _ssl { vm: &VirtualMachine, err: ErrorStack, ) -> PyBaseExceptionRef { - let cls = PySslError::class(&vm.ctx).to_owned(); match err.errors().last() { Some(e) => { + // Check if this is a system library error (errno-based) + // CPython: Modules/_ssl.c:667-671 + let lib = sys::ERR_GET_LIB(e.code()); + + if lib == sys::ERR_LIB_SYS { + // A system error is being reported; reason is set to errno + let reason = sys::ERR_GET_REASON(e.code()); + + // errno 2 = ENOENT = FileNotFoundError + let exc_type = if reason == 2 { + vm.ctx.exceptions.file_not_found_error.to_owned() + } else { + vm.ctx.exceptions.os_error.to_owned() + }; + let exc = vm.new_exception(exc_type, vec![vm.ctx.new_int(reason).into()]); + // Set errno attribute explicitly + let _ = exc + .as_object() + .set_attr("errno", vm.ctx.new_int(reason), vm); + return exc; + } + let caller = std::panic::Location::caller(); let (file, line) = (caller.file(), caller.line()); let file = file .rsplit_once(&['/', '\\'][..]) .map_or(file, |(_, basename)| basename); - // TODO: finish map - let default_errstr = e.reason().unwrap_or("unknown error"); - let errstr = match default_errstr { - "certificate verify failed" => "CERTIFICATE_VERIFY_FAILED", - _ => default_errstr, + + // Get error codes - same approach as CPython + let lib = sys::ERR_GET_LIB(e.code()); + let reason = sys::ERR_GET_REASON(e.code()); + + // Look up error mnemonic from our static tables + // CPython uses dict lookup: err_codes_to_names[(lib, reason)] + let key = super::ssl_data::encode_error_key(lib, reason); + let errstr = super::ssl_data::ERROR_CODES + .get(&key) + .copied() + .or_else(|| { + // Fallback: use OpenSSL's error string + e.reason() + }) + .unwrap_or("unknown error"); + + // Check if this is a certificate verification error + // ERR_LIB_SSL = 20 (from _ssl_data_300.h) + // SSL_R_CERTIFICATE_VERIFY_FAILED = 134 (from _ssl_data_300.h) + let is_cert_verify_error = lib == 20 && reason == 134; + + // Look up library name from our static table + // CPython uses: lib_codes_to_names[lib] + let lib_name = super::ssl_data::LIBRARY_CODES.get(&(lib as u32)).copied(); + + // Use SSLCertVerificationError for certificate verification failures + let cls = if is_cert_verify_error { + PySslCertVerificationError::class(&vm.ctx).to_owned() + } else { + PySslError::class(&vm.ctx).to_owned() }; // Build message - let lib_obj = e.library(); - let msg = if let Some(lib) = lib_obj { - format!("[{lib}] {errstr} ({file}:{line})") + let msg = if let Some(lib_str) = lib_name { + format!("[{lib_str}] {errstr} ({file}:{line})") } else { format!("{errstr} ({file}:{line})") }; @@ -2083,19 +3109,58 @@ mod _ssl { let _ = exc_obj.set_attr("reason", reason_value, vm); // Set library attribute (None if not available) - let library_value: PyObjectRef = if let Some(lib) = lib_obj { - vm.ctx.new_str(lib).into() + let library_value: PyObjectRef = if let Some(lib_str) = lib_name { + vm.ctx.new_str(lib_str).into() } else { vm.ctx.none() }; let _ = exc_obj.set_attr("library", library_value, vm); + // For SSLCertVerificationError, set verify_code and verify_message + // Note: These will be set to None here, and can be updated by the caller + // if they have access to the SSL object + if is_cert_verify_error { + let _ = exc_obj.set_attr("verify_code", vm.ctx.none(), vm); + let _ = exc_obj.set_attr("verify_message", vm.ctx.none(), vm); + } + // Convert back to PyBaseExceptionRef - exc_obj.downcast().unwrap() + exc_obj.downcast().expect( + "exc_obj is created as PyBaseExceptionRef and must downcast successfully", + ) + } + None => { + let cls = PySslError::class(&vm.ctx).to_owned(); + vm.new_exception_empty(cls) } - None => vm.new_exception_empty(cls), } } + + // Helper function to set verify_code and verify_message on SSLCertVerificationError + fn set_verify_error_info( + exc: &PyBaseExceptionRef, + ssl_ptr: *const sys::SSL, + vm: &VirtualMachine, + ) { + // Get verify result + let verify_code = unsafe { sys::SSL_get_verify_result(ssl_ptr) }; + let verify_code_obj = vm.ctx.new_int(verify_code); + + // Get verify message + let verify_message = unsafe { + let verify_str = sys::X509_verify_cert_error_string(verify_code); + if verify_str.is_null() { + vm.ctx.none() + } else { + let c_str = std::ffi::CStr::from_ptr(verify_str); + vm.ctx.new_str(c_str.to_string_lossy()).into() + } + }; + + let exc_obj = exc.as_object(); + let _ = exc_obj.set_attr("verify_code", verify_code_obj, vm); + let _ = exc_obj.set_attr("verify_message", verify_message, vm); + } #[track_caller] fn convert_ssl_error( vm: &VirtualMachine, @@ -2203,6 +3268,24 @@ mod _ssl { (cipher.name(), cipher.version(), cipher.bits().secret) } + fn cipher_description(cipher: *const sys::SSL_CIPHER) -> String { + unsafe { + // SSL_CIPHER_description writes up to 128 bytes + let mut buf = vec![0u8; 256]; + let result = sys::SSL_CIPHER_description( + cipher, + buf.as_mut_ptr() as *mut libc::c_char, + buf.len() as i32, + ); + if result.is_null() { + return String::from("No description available"); + } + // Find the null terminator + let len = buf.iter().position(|&c| c == 0).unwrap_or(buf.len()); + String::from_utf8_lossy(&buf[..len]).trim().to_string() + } + } + impl Read for SocketStream { fn read(&mut self, buf: &mut [u8]) -> std::io::Result { let mut socket: &PySocket = &self.0; diff --git a/stdlib/src/ssl/ssl_data_111.rs b/stdlib/src/ssl/ssl_data_111.rs new file mode 100644 index 00000000000..2d5f56f4855 --- /dev/null +++ b/stdlib/src/ssl/ssl_data_111.rs @@ -0,0 +1,1347 @@ +// File generated by tools/make_ssl_data_rs.py +// Generated on 2025-10-29T07:17:23.692784+00:00 +// Source: OpenSSL from /tmp/openssl-1.1.1 +// spell-checker: disable + +use phf::phf_map; + +// Maps lib_code -> library name +// Example: 20 -> "SSL" +pub static LIBRARY_CODES: phf::Map = phf_map! { + 1u32 => "NONE", + 2u32 => "SYS", + 3u32 => "BN", + 4u32 => "RSA", + 5u32 => "DH", + 6u32 => "EVP", + 7u32 => "BUF", + 8u32 => "OBJ", + 9u32 => "PEM", + 10u32 => "DSA", + 11u32 => "X509", + 12u32 => "METH", + 13u32 => "ASN1", + 14u32 => "CONF", + 15u32 => "CRYPTO", + 16u32 => "EC", + 20u32 => "SSL", + 21u32 => "SSL23", + 22u32 => "SSL2", + 23u32 => "SSL3", + 30u32 => "RSAREF", + 31u32 => "PROXY", + 32u32 => "BIO", + 33u32 => "PKCS7", + 34u32 => "X509V3", + 35u32 => "PKCS12", + 36u32 => "RAND", + 37u32 => "DSO", + 38u32 => "ENGINE", + 39u32 => "OCSP", + 40u32 => "UI", + 41u32 => "COMP", + 42u32 => "ECDSA", + 43u32 => "ECDH", + 44u32 => "OSSL_STORE", + 45u32 => "FIPS", + 46u32 => "CMS", + 47u32 => "TS", + 48u32 => "HMAC", + 49u32 => "JPAKE", + 50u32 => "CT", + 51u32 => "ASYNC", + 52u32 => "KDF", + 53u32 => "SM2", + 128u32 => "USER", +}; + +// Maps encoded (lib, reason) -> error mnemonic +// Example: encode_error_key(20, 134) -> "CERTIFICATE_VERIFY_FAILED" +// Key encoding: (lib << 32) | reason +pub static ERROR_CODES: phf::Map = phf_map! { + 55834575019u64 => "ADDING_OBJECT", + 55834575051u64 => "ASN1_PARSE_ERROR", + 55834575052u64 => "ASN1_SIG_PARSE_ERROR", + 55834574948u64 => "AUX_ERROR", + 55834574950u64 => "BAD_OBJECT_HEADER", + 55834575078u64 => "BAD_TEMPLATE", + 55834575062u64 => "BMPSTRING_IS_WRONG_LENGTH", + 55834574953u64 => "BN_LIB", + 55834574954u64 => "BOOLEAN_IS_WRONG_LENGTH", + 55834574955u64 => "BUFFER_TOO_SMALL", + 55834574956u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER", + 55834575065u64 => "CONTEXT_NOT_INITIALISED", + 55834574957u64 => "DATA_IS_WRONG", + 55834574958u64 => "DECODE_ERROR", + 55834575022u64 => "DEPTH_EXCEEDED", + 55834575046u64 => "DIGEST_AND_KEY_TYPE_NOT_SUPPORTED", + 55834574960u64 => "ENCODE_ERROR", + 55834575021u64 => "ERROR_GETTING_TIME", + 55834575020u64 => "ERROR_LOADING_SECTION", + 55834574962u64 => "ERROR_SETTING_CIPHER_PARAMS", + 55834574963u64 => "EXPECTING_AN_INTEGER", + 55834574964u64 => "EXPECTING_AN_OBJECT", + 55834574967u64 => "EXPLICIT_LENGTH_MISMATCH", + 55834574968u64 => "EXPLICIT_TAG_NOT_CONSTRUCTED", + 55834574969u64 => "FIELD_MISSING", + 55834574970u64 => "FIRST_NUM_TOO_LARGE", + 55834574971u64 => "HEADER_TOO_LONG", + 55834575023u64 => "ILLEGAL_BITSTRING_FORMAT", + 55834575024u64 => "ILLEGAL_BOOLEAN", + 55834574972u64 => "ILLEGAL_CHARACTERS", + 55834575025u64 => "ILLEGAL_FORMAT", + 55834575026u64 => "ILLEGAL_HEX", + 55834575027u64 => "ILLEGAL_IMPLICIT_TAG", + 55834575028u64 => "ILLEGAL_INTEGER", + 55834575074u64 => "ILLEGAL_NEGATIVE_VALUE", + 55834575029u64 => "ILLEGAL_NESTED_TAGGING", + 55834574973u64 => "ILLEGAL_NULL", + 55834575030u64 => "ILLEGAL_NULL_VALUE", + 55834575031u64 => "ILLEGAL_OBJECT", + 55834574974u64 => "ILLEGAL_OPTIONAL_ANY", + 55834575018u64 => "ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE", + 55834575069u64 => "ILLEGAL_PADDING", + 55834574975u64 => "ILLEGAL_TAGGED_ANY", + 55834575032u64 => "ILLEGAL_TIME_VALUE", + 55834575070u64 => "ILLEGAL_ZERO_CONTENT", + 55834575033u64 => "INTEGER_NOT_ASCII_FORMAT", + 55834574976u64 => "INTEGER_TOO_LARGE_FOR_LONG", + 55834575068u64 => "INVALID_BIT_STRING_BITS_LEFT", + 55834574977u64 => "INVALID_BMPSTRING_LENGTH", + 55834574978u64 => "INVALID_DIGIT", + 55834575053u64 => "INVALID_MIME_TYPE", + 55834575034u64 => "INVALID_MODIFIER", + 55834575035u64 => "INVALID_NUMBER", + 55834575064u64 => "INVALID_OBJECT_ENCODING", + 55834575075u64 => "INVALID_SCRYPT_PARAMETERS", + 55834574979u64 => "INVALID_SEPARATOR", + 55834575066u64 => "INVALID_STRING_TABLE_VALUE", + 55834574981u64 => "INVALID_UNIVERSALSTRING_LENGTH", + 55834574982u64 => "INVALID_UTF8STRING", + 55834575067u64 => "INVALID_VALUE", + 55834575036u64 => "LIST_ERROR", + 55834575054u64 => "MIME_NO_CONTENT_TYPE", + 55834575055u64 => "MIME_PARSE_ERROR", + 55834575056u64 => "MIME_SIG_PARSE_ERROR", + 55834574985u64 => "MISSING_EOC", + 55834574986u64 => "MISSING_SECOND_NUMBER", + 55834575037u64 => "MISSING_VALUE", + 55834574987u64 => "MSTRING_NOT_UNIVERSAL", + 55834574988u64 => "MSTRING_WRONG_TAG", + 55834575045u64 => "NESTED_ASN1_STRING", + 55834575049u64 => "NESTED_TOO_DEEP", + 55834574989u64 => "NON_HEX_CHARACTERS", + 55834575038u64 => "NOT_ASCII_FORMAT", + 55834574990u64 => "NOT_ENOUGH_DATA", + 55834575057u64 => "NO_CONTENT_TYPE", + 55834574991u64 => "NO_MATCHING_CHOICE_TYPE", + 55834575058u64 => "NO_MULTIPART_BODY_FAILURE", + 55834575059u64 => "NO_MULTIPART_BOUNDARY", + 55834575060u64 => "NO_SIG_CONTENT_TYPE", + 55834574992u64 => "NULL_IS_WRONG_LENGTH", + 55834575039u64 => "OBJECT_NOT_ASCII_FORMAT", + 55834574993u64 => "ODD_NUMBER_OF_CHARS", + 55834574995u64 => "SECOND_NUMBER_TOO_LARGE", + 55834574996u64 => "SEQUENCE_LENGTH_MISMATCH", + 55834574997u64 => "SEQUENCE_NOT_CONSTRUCTED", + 55834575040u64 => "SEQUENCE_OR_SET_NEEDS_CONFIG", + 55834574998u64 => "SHORT_LINE", + 55834575061u64 => "SIG_INVALID_MIME_TYPE", + 55834575050u64 => "STREAMING_NOT_SUPPORTED", + 55834574999u64 => "STRING_TOO_LONG", + 55834575000u64 => "STRING_TOO_SHORT", + 55834575002u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD", + 55834575041u64 => "TIME_NOT_ASCII_FORMAT", + 55834575071u64 => "TOO_LARGE", + 55834575003u64 => "TOO_LONG", + 55834575072u64 => "TOO_SMALL", + 55834575004u64 => "TYPE_NOT_CONSTRUCTED", + 55834575043u64 => "TYPE_NOT_PRIMITIVE", + 55834575007u64 => "UNEXPECTED_EOC", + 55834575063u64 => "UNIVERSALSTRING_IS_WRONG_LENGTH", + 55834575008u64 => "UNKNOWN_FORMAT", + 55834575009u64 => "UNKNOWN_MESSAGE_DIGEST_ALGORITHM", + 55834575010u64 => "UNKNOWN_OBJECT_TYPE", + 55834575011u64 => "UNKNOWN_PUBLIC_KEY_TYPE", + 55834575047u64 => "UNKNOWN_SIGNATURE_ALGORITHM", + 55834575042u64 => "UNKNOWN_TAG", + 55834575012u64 => "UNSUPPORTED_ANY_DEFINED_BY_TYPE", + 55834575076u64 => "UNSUPPORTED_CIPHER", + 55834575015u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE", + 55834575044u64 => "UNSUPPORTED_TYPE", + 55834575073u64 => "WRONG_INTEGER_TYPE", + 55834575048u64 => "WRONG_PUBLIC_KEY_TYPE", + 55834575016u64 => "WRONG_TAG", + 219043332197u64 => "FAILED_TO_SET_POOL", + 219043332198u64 => "FAILED_TO_SWAP_CONTEXT", + 219043332201u64 => "INIT_FAILED", + 219043332199u64 => "INVALID_POOL_SIZE", + 137438953572u64 => "ACCEPT_ERROR", + 137438953613u64 => "ADDRINFO_ADDR_IS_NOT_AF_INET", + 137438953601u64 => "AMBIGUOUS_HOST_OR_SERVICE", + 137438953573u64 => "BAD_FOPEN_MODE", + 137438953596u64 => "BROKEN_PIPE", + 137438953575u64 => "CONNECT_ERROR", + 137438953579u64 => "GETHOSTBYNAME_ADDR_IS_NOT_AF_INET", + 137438953604u64 => "GETSOCKNAME_ERROR", + 137438953605u64 => "GETSOCKNAME_TRUNCATED_ADDRESS", + 137438953606u64 => "GETTING_SOCKTYPE", + 137438953597u64 => "INVALID_ARGUMENT", + 137438953607u64 => "INVALID_SOCKET", + 137438953595u64 => "IN_USE", + 137438953574u64 => "LENGTH_TOO_LONG", + 137438953608u64 => "LISTEN_V6_ONLY", + 137438953614u64 => "LOOKUP_RETURNED_NOTHING", + 137438953602u64 => "MALFORMED_HOST_OR_SERVICE", + 137438953582u64 => "NBIO_CONNECT_ERROR", + 137438953615u64 => "NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED", + 137438953616u64 => "NO_HOSTNAME_OR_SERVICE_SPECIFIED", + 137438953585u64 => "NO_PORT_DEFINED", + 137438953600u64 => "NO_SUCH_FILE", + 137438953587u64 => "NULL_PARAMETER", + 137438953589u64 => "UNABLE_TO_BIND_SOCKET", + 137438953590u64 => "UNABLE_TO_CREATE_SOCKET", + 137438953609u64 => "UNABLE_TO_KEEPALIVE", + 137438953591u64 => "UNABLE_TO_LISTEN_SOCKET", + 137438953610u64 => "UNABLE_TO_NODELAY", + 137438953611u64 => "UNABLE_TO_REUSEADDR", + 137438953617u64 => "UNAVAILABLE_IP_FAMILY", + 137438953592u64 => "UNINITIALIZED", + 137438953612u64 => "UNKNOWN_INFO_TYPE", + 137438953618u64 => "UNSUPPORTED_IP_FAMILY", + 137438953593u64 => "UNSUPPORTED_METHOD", + 137438953603u64 => "UNSUPPORTED_PROTOCOL_FAMILY", + 137438953598u64 => "WRITE_TO_READ_ONLY_BIO", + 137438953594u64 => "WSASTARTUP", + 12884901988u64 => "ARG2_LT_ARG3", + 12884901989u64 => "BAD_RECIPROCAL", + 12884902002u64 => "BIGNUM_TOO_LONG", + 12884902006u64 => "BITS_TOO_SMALL", + 12884901990u64 => "CALLED_WITH_EVEN_MODULUS", + 12884901991u64 => "DIV_BY_ZERO", + 12884901992u64 => "ENCODING_ERROR", + 12884901993u64 => "EXPAND_ON_STATIC_BIGNUM_DATA", + 12884901998u64 => "INPUT_NOT_REDUCED", + 12884901994u64 => "INVALID_LENGTH", + 12884902003u64 => "INVALID_RANGE", + 12884902007u64 => "INVALID_SHIFT", + 12884901999u64 => "NOT_A_SQUARE", + 12884901995u64 => "NOT_INITIALIZED", + 12884901996u64 => "NO_INVERSE", + 12884902004u64 => "NO_SOLUTION", + 12884902005u64 => "PRIVATE_KEY_TOO_LARGE", + 12884902000u64 => "P_IS_NOT_PRIME", + 12884902001u64 => "TOO_MANY_ITERATIONS", + 12884901997u64 => "TOO_MANY_TEMPORARY_VARIABLES", + 197568495715u64 => "ADD_SIGNER_ERROR", + 197568495777u64 => "ATTRIBUTE_ERROR", + 197568495791u64 => "CERTIFICATE_ALREADY_PRESENT", + 197568495776u64 => "CERTIFICATE_HAS_NO_KEYID", + 197568495716u64 => "CERTIFICATE_VERIFY_ERROR", + 197568495717u64 => "CIPHER_INITIALISATION_ERROR", + 197568495718u64 => "CIPHER_PARAMETER_INITIALISATION_ERROR", + 197568495719u64 => "CMS_DATAFINAL_ERROR", + 197568495720u64 => "CMS_LIB", + 197568495786u64 => "CONTENTIDENTIFIER_MISMATCH", + 197568495721u64 => "CONTENT_NOT_FOUND", + 197568495787u64 => "CONTENT_TYPE_MISMATCH", + 197568495722u64 => "CONTENT_TYPE_NOT_COMPRESSED_DATA", + 197568495723u64 => "CONTENT_TYPE_NOT_ENVELOPED_DATA", + 197568495724u64 => "CONTENT_TYPE_NOT_SIGNED_DATA", + 197568495725u64 => "CONTENT_VERIFY_ERROR", + 197568495726u64 => "CTRL_ERROR", + 197568495727u64 => "CTRL_FAILURE", + 197568495728u64 => "DECRYPT_ERROR", + 197568495729u64 => "ERROR_GETTING_PUBLIC_KEY", + 197568495730u64 => "ERROR_READING_MESSAGEDIGEST_ATTRIBUTE", + 197568495731u64 => "ERROR_SETTING_KEY", + 197568495732u64 => "ERROR_SETTING_RECIPIENTINFO", + 197568495733u64 => "INVALID_ENCRYPTED_KEY_LENGTH", + 197568495792u64 => "INVALID_KEY_ENCRYPTION_PARAMETER", + 197568495734u64 => "INVALID_KEY_LENGTH", + 197568495735u64 => "MD_BIO_INIT_ERROR", + 197568495736u64 => "MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH", + 197568495737u64 => "MESSAGEDIGEST_WRONG_LENGTH", + 197568495788u64 => "MSGSIGDIGEST_ERROR", + 197568495778u64 => "MSGSIGDIGEST_VERIFICATION_FAILURE", + 197568495779u64 => "MSGSIGDIGEST_WRONG_LENGTH", + 197568495780u64 => "NEED_ONE_SIGNER", + 197568495781u64 => "NOT_A_SIGNED_RECEIPT", + 197568495738u64 => "NOT_ENCRYPTED_DATA", + 197568495739u64 => "NOT_KEK", + 197568495797u64 => "NOT_KEY_AGREEMENT", + 197568495740u64 => "NOT_KEY_TRANSPORT", + 197568495793u64 => "NOT_PWRI", + 197568495741u64 => "NOT_SUPPORTED_FOR_THIS_KEY_TYPE", + 197568495742u64 => "NO_CIPHER", + 197568495743u64 => "NO_CONTENT", + 197568495789u64 => "NO_CONTENT_TYPE", + 197568495744u64 => "NO_DEFAULT_DIGEST", + 197568495745u64 => "NO_DIGEST_SET", + 197568495746u64 => "NO_KEY", + 197568495790u64 => "NO_KEY_OR_CERT", + 197568495747u64 => "NO_MATCHING_DIGEST", + 197568495748u64 => "NO_MATCHING_RECIPIENT", + 197568495782u64 => "NO_MATCHING_SIGNATURE", + 197568495783u64 => "NO_MSGSIGDIGEST", + 197568495794u64 => "NO_PASSWORD", + 197568495749u64 => "NO_PRIVATE_KEY", + 197568495750u64 => "NO_PUBLIC_KEY", + 197568495784u64 => "NO_RECEIPT_REQUEST", + 197568495751u64 => "NO_SIGNERS", + 197568495752u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 197568495785u64 => "RECEIPT_DECODE_ERROR", + 197568495753u64 => "RECIPIENT_ERROR", + 197568495754u64 => "SIGNER_CERTIFICATE_NOT_FOUND", + 197568495755u64 => "SIGNFINAL_ERROR", + 197568495756u64 => "SMIME_TEXT_ERROR", + 197568495757u64 => "STORE_INIT_ERROR", + 197568495758u64 => "TYPE_NOT_COMPRESSED_DATA", + 197568495759u64 => "TYPE_NOT_DATA", + 197568495760u64 => "TYPE_NOT_DIGESTED_DATA", + 197568495761u64 => "TYPE_NOT_ENCRYPTED_DATA", + 197568495762u64 => "TYPE_NOT_ENVELOPED_DATA", + 197568495763u64 => "UNABLE_TO_FINALIZE_CONTEXT", + 197568495764u64 => "UNKNOWN_CIPHER", + 197568495765u64 => "UNKNOWN_DIGEST_ALGORITHM", + 197568495766u64 => "UNKNOWN_ID", + 197568495767u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM", + 197568495810u64 => "UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM", + 197568495768u64 => "UNSUPPORTED_CONTENT_TYPE", + 197568495769u64 => "UNSUPPORTED_KEK_ALGORITHM", + 197568495795u64 => "UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM", + 197568495771u64 => "UNSUPPORTED_RECIPIENTINFO_TYPE", + 197568495770u64 => "UNSUPPORTED_RECIPIENT_TYPE", + 197568495772u64 => "UNSUPPORTED_TYPE", + 197568495773u64 => "UNWRAP_ERROR", + 197568495796u64 => "UNWRAP_FAILURE", + 197568495774u64 => "VERIFICATION_FAILURE", + 197568495775u64 => "WRAP_ERROR", + 176093659235u64 => "ZLIB_DEFLATE_ERROR", + 176093659236u64 => "ZLIB_INFLATE_ERROR", + 176093659237u64 => "ZLIB_NOT_SUPPORTED", + 60129542254u64 => "ERROR_LOADING_DSO", + 60129542259u64 => "LIST_CANNOT_BE_NULL", + 60129542244u64 => "MISSING_CLOSE_SQUARE_BRACKET", + 60129542245u64 => "MISSING_EQUAL_SIGN", + 60129542256u64 => "MISSING_INIT_FUNCTION", + 60129542253u64 => "MODULE_INITIALIZATION_ERROR", + 60129542246u64 => "NO_CLOSE_BRACE", + 60129542249u64 => "NO_CONF", + 60129542250u64 => "NO_CONF_OR_ENVIRONMENT_VARIABLE", + 60129542251u64 => "NO_SECTION", + 60129542258u64 => "NO_SUCH_FILE", + 60129542252u64 => "NO_VALUE", + 60129542265u64 => "NUMBER_TOO_LARGE", + 60129542255u64 => "RECURSIVE_DIRECTORY_INCLUDE", + 60129542261u64 => "SSL_COMMAND_SECTION_EMPTY", + 60129542262u64 => "SSL_COMMAND_SECTION_NOT_FOUND", + 60129542263u64 => "SSL_SECTION_EMPTY", + 60129542264u64 => "SSL_SECTION_NOT_FOUND", + 60129542247u64 => "UNABLE_TO_CREATE_NEW_SECTION", + 60129542257u64 => "UNKNOWN_MODULE_NAME", + 60129542260u64 => "VARIABLE_EXPANSION_TOO_LONG", + 60129542248u64 => "VARIABLE_HAS_NO_VALUE", + 64424509541u64 => "FIPS_MODE_NOT_SUPPORTED", + 64424509542u64 => "ILLEGAL_HEX_DIGIT", + 64424509543u64 => "ODD_NUMBER_OF_DIGITS", + 214748364908u64 => "BASE64_DECODE_ERROR", + 214748364900u64 => "INVALID_LOG_ID_LENGTH", + 214748364909u64 => "LOG_CONF_INVALID", + 214748364910u64 => "LOG_CONF_INVALID_KEY", + 214748364911u64 => "LOG_CONF_MISSING_DESCRIPTION", + 214748364912u64 => "LOG_CONF_MISSING_KEY", + 214748364913u64 => "LOG_KEY_INVALID", + 214748364916u64 => "SCT_FUTURE_TIMESTAMP", + 214748364904u64 => "SCT_INVALID", + 214748364907u64 => "SCT_INVALID_SIGNATURE", + 214748364905u64 => "SCT_LIST_INVALID", + 214748364914u64 => "SCT_LOG_ID_MISMATCH", + 214748364906u64 => "SCT_NOT_SET", + 214748364915u64 => "SCT_UNSUPPORTED_VERSION", + 214748364901u64 => "UNRECOGNIZED_SIGNATURE_NID", + 214748364902u64 => "UNSUPPORTED_ENTRY_TYPE", + 214748364903u64 => "UNSUPPORTED_VERSION", + 21474836581u64 => "BAD_GENERATOR", + 21474836589u64 => "BN_DECODE_ERROR", + 21474836586u64 => "BN_ERROR", + 21474836595u64 => "CHECK_INVALID_J_VALUE", + 21474836596u64 => "CHECK_INVALID_Q_VALUE", + 21474836602u64 => "CHECK_PUBKEY_INVALID", + 21474836603u64 => "CHECK_PUBKEY_TOO_LARGE", + 21474836604u64 => "CHECK_PUBKEY_TOO_SMALL", + 21474836597u64 => "CHECK_P_NOT_PRIME", + 21474836598u64 => "CHECK_P_NOT_SAFE_PRIME", + 21474836599u64 => "CHECK_Q_NOT_PRIME", + 21474836584u64 => "DECODE_ERROR", + 21474836590u64 => "INVALID_PARAMETER_NAME", + 21474836594u64 => "INVALID_PARAMETER_NID", + 21474836582u64 => "INVALID_PUBKEY", + 21474836592u64 => "KDF_PARAMETER_ERROR", + 21474836588u64 => "KEYS_NOT_SET", + 21474836605u64 => "MISSING_PUBKEY", + 21474836583u64 => "MODULUS_TOO_LARGE", + 21474836600u64 => "NOT_SUITABLE_GENERATOR", + 21474836587u64 => "NO_PARAMETERS_SET", + 21474836580u64 => "NO_PRIVATE_VALUE", + 21474836585u64 => "PARAMETER_ENCODING_ERROR", + 21474836591u64 => "PEER_KEY_ERROR", + 21474836593u64 => "SHARED_INFO_ERROR", + 21474836601u64 => "UNABLE_TO_CHECK_GENERATOR", + 42949673062u64 => "BAD_Q_VALUE", + 42949673068u64 => "BN_DECODE_ERROR", + 42949673069u64 => "BN_ERROR", + 42949673064u64 => "DECODE_ERROR", + 42949673066u64 => "INVALID_DIGEST_TYPE", + 42949673072u64 => "INVALID_PARAMETERS", + 42949673061u64 => "MISSING_PARAMETERS", + 42949673071u64 => "MISSING_PRIVATE_KEY", + 42949673063u64 => "MODULUS_TOO_LARGE", + 42949673067u64 => "NO_PARAMETERS_SET", + 42949673065u64 => "PARAMETER_ENCODING_ERROR", + 42949673073u64 => "Q_NOT_PRIME", + 42949673070u64 => "SEED_LEN_SMALL", + 158913790052u64 => "CTRL_FAILED", + 158913790062u64 => "DSO_ALREADY_LOADED", + 158913790065u64 => "EMPTY_FILE_STRUCTURE", + 158913790066u64 => "FAILURE", + 158913790053u64 => "FILENAME_TOO_BIG", + 158913790054u64 => "FINISH_FAILED", + 158913790067u64 => "INCORRECT_FILE_SYNTAX", + 158913790055u64 => "LOAD_FAILED", + 158913790061u64 => "NAME_TRANSLATION_FAILED", + 158913790063u64 => "NO_FILENAME", + 158913790056u64 => "NULL_HANDLE", + 158913790064u64 => "SET_FILENAME_FAILED", + 158913790057u64 => "STACK_ERROR", + 158913790058u64 => "SYM_FAILURE", + 158913790059u64 => "UNLOAD_FAILED", + 158913790060u64 => "UNSUPPORTED", + 68719476851u64 => "ASN1_ERROR", + 68719476892u64 => "BAD_SIGNATURE", + 68719476880u64 => "BIGNUM_OUT_OF_RANGE", + 68719476836u64 => "BUFFER_TOO_SMALL", + 68719476901u64 => "CANNOT_INVERT", + 68719476882u64 => "COORDINATES_OUT_OF_RANGE", + 68719476896u64 => "CURVE_DOES_NOT_SUPPORT_ECDH", + 68719476895u64 => "CURVE_DOES_NOT_SUPPORT_SIGNING", + 68719476853u64 => "D2I_ECPKPARAMETERS_FAILURE", + 68719476878u64 => "DECODE_ERROR", + 68719476854u64 => "DISCRIMINANT_IS_ZERO", + 68719476855u64 => "EC_GROUP_NEW_BY_NAME_FAILURE", + 68719476879u64 => "FIELD_TOO_LARGE", + 68719476883u64 => "GF2M_NOT_SUPPORTED", + 68719476856u64 => "GROUP2PKPARAMETERS_FAILURE", + 68719476857u64 => "I2D_ECPKPARAMETERS_FAILURE", + 68719476837u64 => "INCOMPATIBLE_OBJECTS", + 68719476848u64 => "INVALID_ARGUMENT", + 68719476846u64 => "INVALID_COMPRESSED_POINT", + 68719476845u64 => "INVALID_COMPRESSION_BIT", + 68719476877u64 => "INVALID_CURVE", + 68719476887u64 => "INVALID_DIGEST", + 68719476874u64 => "INVALID_DIGEST_TYPE", + 68719476838u64 => "INVALID_ENCODING", + 68719476839u64 => "INVALID_FIELD", + 68719476840u64 => "INVALID_FORM", + 68719476858u64 => "INVALID_GROUP_ORDER", + 68719476852u64 => "INVALID_KEY", + 68719476897u64 => "INVALID_OUTPUT_LENGTH", + 68719476869u64 => "INVALID_PEER_KEY", + 68719476868u64 => "INVALID_PENTANOMIAL_BASIS", + 68719476859u64 => "INVALID_PRIVATE_KEY", + 68719476873u64 => "INVALID_TRINOMIAL_BASIS", + 68719476884u64 => "KDF_PARAMETER_ERROR", + 68719476876u64 => "KEYS_NOT_SET", + 68719476872u64 => "LADDER_POST_FAILURE", + 68719476889u64 => "LADDER_PRE_FAILURE", + 68719476898u64 => "LADDER_STEP_FAILURE", + 68719476903u64 => "MISSING_OID", + 68719476860u64 => "MISSING_PARAMETERS", + 68719476861u64 => "MISSING_PRIVATE_KEY", + 68719476893u64 => "NEED_NEW_SETUP_VALUES", + 68719476871u64 => "NOT_A_NIST_PRIME", + 68719476862u64 => "NOT_IMPLEMENTED", + 68719476847u64 => "NOT_INITIALIZED", + 68719476875u64 => "NO_PARAMETERS_SET", + 68719476890u64 => "NO_PRIVATE_VALUE", + 68719476888u64 => "OPERATION_NOT_SUPPORTED", + 68719476870u64 => "PASSED_NULL_PARAMETER", + 68719476885u64 => "PEER_KEY_ERROR", + 68719476863u64 => "PKPARAMETERS2GROUP_FAILURE", + 68719476891u64 => "POINT_ARITHMETIC_FAILURE", + 68719476842u64 => "POINT_AT_INFINITY", + 68719476899u64 => "POINT_COORDINATES_BLIND_FAILURE", + 68719476843u64 => "POINT_IS_NOT_ON_CURVE", + 68719476894u64 => "RANDOM_NUMBER_GENERATION_FAILED", + 68719476886u64 => "SHARED_INFO_ERROR", + 68719476844u64 => "SLOT_FULL", + 68719476849u64 => "UNDEFINED_GENERATOR", + 68719476864u64 => "UNDEFINED_ORDER", + 68719476900u64 => "UNKNOWN_COFACTOR", + 68719476865u64 => "UNKNOWN_GROUP", + 68719476850u64 => "UNKNOWN_ORDER", + 68719476867u64 => "UNSUPPORTED_FIELD", + 68719476881u64 => "WRONG_CURVE_PARAMETERS", + 68719476866u64 => "WRONG_ORDER", + 163208757348u64 => "ALREADY_LOADED", + 163208757381u64 => "ARGUMENT_IS_NOT_A_NUMBER", + 163208757382u64 => "CMD_NOT_EXECUTABLE", + 163208757383u64 => "COMMAND_TAKES_INPUT", + 163208757384u64 => "COMMAND_TAKES_NO_INPUT", + 163208757351u64 => "CONFLICTING_ENGINE_ID", + 163208757367u64 => "CTRL_COMMAND_NOT_IMPLEMENTED", + 163208757352u64 => "DSO_FAILURE", + 163208757380u64 => "DSO_NOT_FOUND", + 163208757396u64 => "ENGINES_SECTION_ERROR", + 163208757350u64 => "ENGINE_CONFIGURATION_ERROR", + 163208757353u64 => "ENGINE_IS_NOT_IN_LIST", + 163208757397u64 => "ENGINE_SECTION_ERROR", + 163208757376u64 => "FAILED_LOADING_PRIVATE_KEY", + 163208757377u64 => "FAILED_LOADING_PUBLIC_KEY", + 163208757354u64 => "FINISH_FAILED", + 163208757356u64 => "ID_OR_NAME_MISSING", + 163208757357u64 => "INIT_FAILED", + 163208757358u64 => "INTERNAL_LIST_ERROR", + 163208757391u64 => "INVALID_ARGUMENT", + 163208757385u64 => "INVALID_CMD_NAME", + 163208757386u64 => "INVALID_CMD_NUMBER", + 163208757399u64 => "INVALID_INIT_VALUE", + 163208757398u64 => "INVALID_STRING", + 163208757365u64 => "NOT_INITIALISED", + 163208757360u64 => "NOT_LOADED", + 163208757368u64 => "NO_CONTROL_FUNCTION", + 163208757392u64 => "NO_INDEX", + 163208757373u64 => "NO_LOAD_FUNCTION", + 163208757378u64 => "NO_REFERENCE", + 163208757364u64 => "NO_SUCH_ENGINE", + 163208757394u64 => "UNIMPLEMENTED_CIPHER", + 163208757395u64 => "UNIMPLEMENTED_DIGEST", + 163208757349u64 => "UNIMPLEMENTED_PUBLIC_KEY_METHOD", + 163208757393u64 => "VERSION_INCOMPATIBILITY", + 25769803919u64 => "AES_KEY_SETUP_FAILED", + 25769803952u64 => "ARIA_KEY_SETUP_FAILED", + 25769803876u64 => "BAD_DECRYPT", + 25769803971u64 => "BAD_KEY_LENGTH", + 25769803931u64 => "BUFFER_TOO_SMALL", + 25769803933u64 => "CAMELLIA_KEY_SETUP_FAILED", + 25769803898u64 => "CIPHER_PARAMETER_ERROR", + 25769803923u64 => "COMMAND_NOT_SUPPORTED", + 25769803949u64 => "COPY_ERROR", + 25769803908u64 => "CTRL_NOT_IMPLEMENTED", + 25769803909u64 => "CTRL_OPERATION_NOT_IMPLEMENTED", + 25769803914u64 => "DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH", + 25769803890u64 => "DECODE_ERROR", + 25769803877u64 => "DIFFERENT_KEY_TYPES", + 25769803929u64 => "DIFFERENT_PARAMETERS", + 25769803941u64 => "ERROR_LOADING_SECTION", + 25769803942u64 => "ERROR_SETTING_FIPS_MODE", + 25769803950u64 => "EXPECTING_AN_HMAC_KEY", + 25769803903u64 => "EXPECTING_AN_RSA_KEY", + 25769803904u64 => "EXPECTING_A_DH_KEY", + 25769803905u64 => "EXPECTING_A_DSA_KEY", + 25769803918u64 => "EXPECTING_A_EC_KEY", + 25769803940u64 => "EXPECTING_A_POLY1305_KEY", + 25769803951u64 => "EXPECTING_A_SIPHASH_KEY", + 25769803943u64 => "FIPS_MODE_NOT_SUPPORTED", + 25769803958u64 => "GET_RAW_KEY_FAILED", + 25769803947u64 => "ILLEGAL_SCRYPT_PARAMETERS", + 25769803910u64 => "INITIALIZATION_ERROR", + 25769803887u64 => "INPUT_NOT_INITIALIZED", + 25769803928u64 => "INVALID_DIGEST", + 25769803944u64 => "INVALID_FIPS_MODE", + 25769803970u64 => "INVALID_IV_LENGTH", + 25769803939u64 => "INVALID_KEY", + 25769803906u64 => "INVALID_KEY_LENGTH", + 25769803924u64 => "INVALID_OPERATION", + 25769803896u64 => "KEYGEN_FAILURE", + 25769803956u64 => "KEY_SETUP_FAILED", + 25769803948u64 => "MEMORY_LIMIT_EXCEEDED", + 25769803935u64 => "MESSAGE_DIGEST_IS_NULL", + 25769803920u64 => "METHOD_NOT_SUPPORTED", + 25769803879u64 => "MISSING_PARAMETERS", + 25769803954u64 => "NOT_XOF_OR_INVALID_LENGTH", + 25769803907u64 => "NO_CIPHER_SET", + 25769803934u64 => "NO_DEFAULT_DIGEST", + 25769803915u64 => "NO_DIGEST_SET", + 25769803930u64 => "NO_KEY_SET", + 25769803925u64 => "NO_OPERATION_SET", + 25769803953u64 => "ONLY_ONESHOT_SUPPORTED", + 25769803926u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE", + 25769803927u64 => "OPERATON_NOT_INITIALIZED", + 25769803960u64 => "OUTPUT_WOULD_OVERFLOW", + 25769803938u64 => "PARTIALLY_OVERLAPPING", + 25769803957u64 => "PBKDF2_ERROR", + 25769803955u64 => "PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED", + 25769803921u64 => "PRIVATE_KEY_DECODE_ERROR", + 25769803922u64 => "PRIVATE_KEY_ENCODE_ERROR", + 25769803882u64 => "PUBLIC_KEY_NOT_RSA", + 25769803936u64 => "UNKNOWN_CIPHER", + 25769803937u64 => "UNKNOWN_DIGEST", + 25769803945u64 => "UNKNOWN_OPTION", + 25769803897u64 => "UNKNOWN_PBE_ALGORITHM", + 25769803932u64 => "UNSUPPORTED_ALGORITHM", + 25769803883u64 => "UNSUPPORTED_CIPHER", + 25769803899u64 => "UNSUPPORTED_KEYLENGTH", + 25769803900u64 => "UNSUPPORTED_KEY_DERIVATION_FUNCTION", + 25769803884u64 => "UNSUPPORTED_KEY_SIZE", + 25769803911u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS", + 25769803901u64 => "UNSUPPORTED_PRF", + 25769803894u64 => "UNSUPPORTED_PRIVATE_KEY_ALGORITHM", + 25769803902u64 => "UNSUPPORTED_SALT_TYPE", + 25769803946u64 => "WRAP_MODE_NOT_ALLOWED", + 25769803885u64 => "WRONG_FINAL_BLOCK_LENGTH", + 25769803959u64 => "XTS_DUPLICATED_KEYS", + 223338299492u64 => "INVALID_DIGEST", + 223338299501u64 => "MISSING_ITERATION_COUNT", + 223338299496u64 => "MISSING_KEY", + 223338299497u64 => "MISSING_MESSAGE_DIGEST", + 223338299493u64 => "MISSING_PARAMETER", + 223338299502u64 => "MISSING_PASS", + 223338299503u64 => "MISSING_SALT", + 223338299499u64 => "MISSING_SECRET", + 223338299498u64 => "MISSING_SEED", + 223338299495u64 => "UNKNOWN_PARAMETER_TYPE", + 223338299500u64 => "VALUE_ERROR", + 223338299494u64 => "VALUE_MISSING", + 34359738470u64 => "OID_EXISTS", + 34359738469u64 => "UNKNOWN_NID", + 167503724645u64 => "CERTIFICATE_VERIFY_ERROR", + 167503724646u64 => "DIGEST_ERR", + 167503724666u64 => "ERROR_IN_NEXTUPDATE_FIELD", + 167503724667u64 => "ERROR_IN_THISUPDATE_FIELD", + 167503724665u64 => "ERROR_PARSING_URL", + 167503724647u64 => "MISSING_OCSPSIGNING_USAGE", + 167503724668u64 => "NEXTUPDATE_BEFORE_THISUPDATE", + 167503724648u64 => "NOT_BASIC_RESPONSE", + 167503724649u64 => "NO_CERTIFICATES_IN_CHAIN", + 167503724652u64 => "NO_RESPONSE_DATA", + 167503724653u64 => "NO_REVOKED_TIME", + 167503724674u64 => "NO_SIGNER_KEY", + 167503724654u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 167503724672u64 => "REQUEST_NOT_SIGNED", + 167503724655u64 => "RESPONSE_CONTAINS_NO_REVOCATION_DATA", + 167503724656u64 => "ROOT_CA_NOT_TRUSTED", + 167503724658u64 => "SERVER_RESPONSE_ERROR", + 167503724659u64 => "SERVER_RESPONSE_PARSE_ERROR", + 167503724661u64 => "SIGNATURE_FAILURE", + 167503724662u64 => "SIGNER_CERTIFICATE_NOT_FOUND", + 167503724669u64 => "STATUS_EXPIRED", + 167503724670u64 => "STATUS_NOT_YET_VALID", + 167503724671u64 => "STATUS_TOO_OLD", + 167503724663u64 => "UNKNOWN_MESSAGE_DIGEST", + 167503724664u64 => "UNKNOWN_NID", + 167503724673u64 => "UNSUPPORTED_REQUESTORNAME_TYPE", + 188978561131u64 => "AMBIGUOUS_CONTENT_TYPE", + 188978561139u64 => "BAD_PASSWORD_READ", + 188978561137u64 => "ERROR_VERIFYING_PKCS12_MAC", + 188978561145u64 => "FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST", + 188978561130u64 => "INVALID_SCHEME", + 188978561136u64 => "IS_NOT_A", + 188978561140u64 => "LOADER_INCOMPLETE", + 188978561141u64 => "LOADING_STARTED", + 188978561124u64 => "NOT_A_CERTIFICATE", + 188978561125u64 => "NOT_A_CRL", + 188978561126u64 => "NOT_A_KEY", + 188978561127u64 => "NOT_A_NAME", + 188978561128u64 => "NOT_PARAMETERS", + 188978561138u64 => "PASSPHRASE_CALLBACK_ERROR", + 188978561132u64 => "PATH_MUST_BE_ABSOLUTE", + 188978561143u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES", + 188978561133u64 => "UI_PROCESS_INTERRUPTED_OR_CANCELLED", + 188978561129u64 => "UNREGISTERED_SCHEME", + 188978561134u64 => "UNSUPPORTED_CONTENT_TYPE", + 188978561142u64 => "UNSUPPORTED_OPERATION", + 188978561144u64 => "UNSUPPORTED_SEARCH_TYPE", + 188978561135u64 => "URI_AUTHORITY_UNSUPPORTED", + 38654705764u64 => "BAD_BASE64_DECODE", + 38654705765u64 => "BAD_DECRYPT", + 38654705766u64 => "BAD_END_LINE", + 38654705767u64 => "BAD_IV_CHARS", + 38654705780u64 => "BAD_MAGIC_NUMBER", + 38654705768u64 => "BAD_PASSWORD_READ", + 38654705781u64 => "BAD_VERSION_NUMBER", + 38654705782u64 => "BIO_WRITE_FAILURE", + 38654705791u64 => "CIPHER_IS_NULL", + 38654705779u64 => "ERROR_CONVERTING_PRIVATE_KEY", + 38654705783u64 => "EXPECTING_PRIVATE_KEY_BLOB", + 38654705784u64 => "EXPECTING_PUBLIC_KEY_BLOB", + 38654705792u64 => "HEADER_TOO_LONG", + 38654705785u64 => "INCONSISTENT_HEADER", + 38654705786u64 => "KEYBLOB_HEADER_PARSE_ERROR", + 38654705787u64 => "KEYBLOB_TOO_SHORT", + 38654705793u64 => "MISSING_DEK_IV", + 38654705769u64 => "NOT_DEK_INFO", + 38654705770u64 => "NOT_ENCRYPTED", + 38654705771u64 => "NOT_PROC_TYPE", + 38654705772u64 => "NO_START_LINE", + 38654705773u64 => "PROBLEMS_GETTING_PASSWORD", + 38654705788u64 => "PVK_DATA_TOO_SHORT", + 38654705789u64 => "PVK_TOO_SHORT", + 38654705775u64 => "READ_KEY", + 38654705776u64 => "SHORT_HEADER", + 38654705794u64 => "UNEXPECTED_DEK_IV", + 38654705777u64 => "UNSUPPORTED_CIPHER", + 38654705778u64 => "UNSUPPORTED_ENCRYPTION", + 38654705790u64 => "UNSUPPORTED_KEY_COMPONENTS", + 38654705774u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE", + 150323855460u64 => "CANT_PACK_STRUCTURE", + 150323855481u64 => "CONTENT_TYPE_NOT_DATA", + 150323855461u64 => "DECODE_ERROR", + 150323855462u64 => "ENCODE_ERROR", + 150323855463u64 => "ENCRYPT_ERROR", + 150323855480u64 => "ERROR_SETTING_ENCRYPTED_DATA_TYPE", + 150323855464u64 => "INVALID_NULL_ARGUMENT", + 150323855465u64 => "INVALID_NULL_PKCS12_POINTER", + 150323855466u64 => "IV_GEN_ERROR", + 150323855467u64 => "KEY_GEN_ERROR", + 150323855468u64 => "MAC_ABSENT", + 150323855469u64 => "MAC_GENERATION_ERROR", + 150323855470u64 => "MAC_SETUP_ERROR", + 150323855471u64 => "MAC_STRING_SET_ERROR", + 150323855473u64 => "MAC_VERIFY_FAILURE", + 150323855474u64 => "PARSE_ERROR", + 150323855475u64 => "PKCS12_ALGOR_CIPHERINIT_ERROR", + 150323855476u64 => "PKCS12_CIPHERFINAL_ERROR", + 150323855477u64 => "PKCS12_PBE_CRYPT_ERROR", + 150323855478u64 => "UNKNOWN_DIGEST_ALGORITHM", + 150323855479u64 => "UNSUPPORTED_PKCS12_MODE", + 141733920885u64 => "CERTIFICATE_VERIFY_ERROR", + 141733920912u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER", + 141733920884u64 => "CIPHER_NOT_INITIALIZED", + 141733920886u64 => "CONTENT_AND_DATA_PRESENT", + 141733920920u64 => "CTRL_ERROR", + 141733920887u64 => "DECRYPT_ERROR", + 141733920869u64 => "DIGEST_FAILURE", + 141733920917u64 => "ENCRYPTION_CTRL_FAILURE", + 141733920918u64 => "ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE", + 141733920888u64 => "ERROR_ADDING_RECIPIENT", + 141733920889u64 => "ERROR_SETTING_CIPHER", + 141733920911u64 => "INVALID_NULL_POINTER", + 141733920923u64 => "INVALID_SIGNED_DATA_TYPE", + 141733920890u64 => "NO_CONTENT", + 141733920919u64 => "NO_DEFAULT_DIGEST", + 141733920922u64 => "NO_MATCHING_DIGEST_TYPE_FOUND", + 141733920883u64 => "NO_RECIPIENT_MATCHES_CERTIFICATE", + 141733920891u64 => "NO_SIGNATURES_ON_DATA", + 141733920910u64 => "NO_SIGNERS", + 141733920872u64 => "OPERATION_NOT_SUPPORTED_ON_THIS_TYPE", + 141733920892u64 => "PKCS7_ADD_SIGNATURE_ERROR", + 141733920921u64 => "PKCS7_ADD_SIGNER_ERROR", + 141733920913u64 => "PKCS7_DATASIGN", + 141733920895u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 141733920873u64 => "SIGNATURE_FAILURE", + 141733920896u64 => "SIGNER_CERTIFICATE_NOT_FOUND", + 141733920915u64 => "SIGNING_CTRL_FAILURE", + 141733920916u64 => "SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE", + 141733920897u64 => "SMIME_TEXT_ERROR", + 141733920874u64 => "UNABLE_TO_FIND_CERTIFICATE", + 141733920875u64 => "UNABLE_TO_FIND_MEM_BIO", + 141733920876u64 => "UNABLE_TO_FIND_MESSAGE_DIGEST", + 141733920877u64 => "UNKNOWN_DIGEST_TYPE", + 141733920878u64 => "UNKNOWN_OPERATION", + 141733920879u64 => "UNSUPPORTED_CIPHER_TYPE", + 141733920880u64 => "UNSUPPORTED_CONTENT_TYPE", + 141733920881u64 => "WRONG_CONTENT_TYPE", + 141733920882u64 => "WRONG_PKCS7_TYPE", + 154618822758u64 => "ADDITIONAL_INPUT_TOO_LONG", + 154618822759u64 => "ALREADY_INSTANTIATED", + 154618822761u64 => "ARGUMENT_OUT_OF_RANGE", + 154618822777u64 => "CANNOT_OPEN_FILE", + 154618822785u64 => "DRBG_ALREADY_INITIALIZED", + 154618822760u64 => "DRBG_NOT_INITIALISED", + 154618822762u64 => "ENTROPY_INPUT_TOO_LONG", + 154618822780u64 => "ENTROPY_OUT_OF_RANGE", + 154618822783u64 => "ERROR_ENTROPY_POOL_WAS_IGNORED", + 154618822763u64 => "ERROR_INITIALISING_DRBG", + 154618822764u64 => "ERROR_INSTANTIATING_DRBG", + 154618822765u64 => "ERROR_RETRIEVING_ADDITIONAL_INPUT", + 154618822766u64 => "ERROR_RETRIEVING_ENTROPY", + 154618822767u64 => "ERROR_RETRIEVING_NONCE", + 154618822782u64 => "FAILED_TO_CREATE_LOCK", + 154618822757u64 => "FUNC_NOT_IMPLEMENTED", + 154618822779u64 => "FWRITE_ERROR", + 154618822768u64 => "GENERATE_ERROR", + 154618822769u64 => "INTERNAL_ERROR", + 154618822770u64 => "IN_ERROR_STATE", + 154618822778u64 => "NOT_A_REGULAR_FILE", + 154618822771u64 => "NOT_INSTANTIATED", + 154618822784u64 => "NO_DRBG_IMPLEMENTATION_SELECTED", + 154618822786u64 => "PARENT_LOCKING_NOT_ENABLED", + 154618822787u64 => "PARENT_STRENGTH_TOO_WEAK", + 154618822772u64 => "PERSONALISATION_STRING_TOO_LONG", + 154618822789u64 => "PREDICTION_RESISTANCE_NOT_SUPPORTED", + 154618822756u64 => "PRNG_NOT_SEEDED", + 154618822781u64 => "RANDOM_POOL_OVERFLOW", + 154618822790u64 => "RANDOM_POOL_UNDERFLOW", + 154618822773u64 => "REQUEST_TOO_LARGE_FOR_DRBG", + 154618822774u64 => "RESEED_ERROR", + 154618822775u64 => "SELFTEST_FAILURE", + 154618822791u64 => "TOO_LITTLE_NONCE_REQUESTED", + 154618822792u64 => "TOO_MUCH_NONCE_REQUESTED", + 154618822788u64 => "UNSUPPORTED_DRBG_FLAGS", + 154618822776u64 => "UNSUPPORTED_DRBG_TYPE", + 17179869284u64 => "ALGORITHM_MISMATCH", + 17179869285u64 => "BAD_E_VALUE", + 17179869286u64 => "BAD_FIXED_HEADER_DECRYPT", + 17179869287u64 => "BAD_PAD_BYTE_COUNT", + 17179869288u64 => "BAD_SIGNATURE", + 17179869290u64 => "BLOCK_TYPE_IS_NOT_01", + 17179869291u64 => "BLOCK_TYPE_IS_NOT_02", + 17179869292u64 => "DATA_GREATER_THAN_MOD_LEN", + 17179869293u64 => "DATA_TOO_LARGE", + 17179869294u64 => "DATA_TOO_LARGE_FOR_KEY_SIZE", + 17179869316u64 => "DATA_TOO_LARGE_FOR_MODULUS", + 17179869295u64 => "DATA_TOO_SMALL", + 17179869306u64 => "DATA_TOO_SMALL_FOR_KEY_SIZE", + 17179869342u64 => "DIGEST_DOES_NOT_MATCH", + 17179869329u64 => "DIGEST_NOT_ALLOWED", + 17179869296u64 => "DIGEST_TOO_BIG_FOR_RSA_KEY", + 17179869308u64 => "DMP1_NOT_CONGRUENT_TO_D", + 17179869309u64 => "DMQ1_NOT_CONGRUENT_TO_D", + 17179869307u64 => "D_E_NOT_CONGRUENT_TO_1", + 17179869317u64 => "FIRST_OCTET_INVALID", + 17179869328u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE", + 17179869341u64 => "INVALID_DIGEST", + 17179869327u64 => "INVALID_DIGEST_LENGTH", + 17179869321u64 => "INVALID_HEADER", + 17179869344u64 => "INVALID_LABEL", + 17179869315u64 => "INVALID_MESSAGE_LENGTH", + 17179869340u64 => "INVALID_MGF1_MD", + 17179869351u64 => "INVALID_MULTI_PRIME_KEY", + 17179869345u64 => "INVALID_OAEP_PARAMETERS", + 17179869322u64 => "INVALID_PADDING", + 17179869325u64 => "INVALID_PADDING_MODE", + 17179869333u64 => "INVALID_PSS_PARAMETERS", + 17179869330u64 => "INVALID_PSS_SALTLEN", + 17179869334u64 => "INVALID_SALT_LENGTH", + 17179869323u64 => "INVALID_TRAILER", + 17179869326u64 => "INVALID_X931_DIGEST", + 17179869310u64 => "IQMP_NOT_INVERSE_OF_Q", + 17179869349u64 => "KEY_PRIME_NUM_INVALID", + 17179869304u64 => "KEY_SIZE_TOO_SMALL", + 17179869318u64 => "LAST_OCTET_INVALID", + 17179869336u64 => "MGF1_DIGEST_NOT_ALLOWED", + 17179869363u64 => "MISSING_PRIVATE_KEY", + 17179869289u64 => "MODULUS_TOO_LARGE", + 17179869352u64 => "MP_COEFFICIENT_NOT_INVERSE_OF_R", + 17179869353u64 => "MP_EXPONENT_NOT_CONGRUENT_TO_D", + 17179869354u64 => "MP_R_NOT_PRIME", + 17179869324u64 => "NO_PUBLIC_EXPONENT", + 17179869297u64 => "NULL_BEFORE_BLOCK_MISSING", + 17179869356u64 => "N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES", + 17179869311u64 => "N_DOES_NOT_EQUAL_P_Q", + 17179869305u64 => "OAEP_DECODING_ERROR", + 17179869332u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE", + 17179869298u64 => "PADDING_CHECK_FAILED", + 17179869343u64 => "PKCS_DECODING_ERROR", + 17179869348u64 => "PSS_SALTLEN_TOO_SMALL", + 17179869312u64 => "P_NOT_PRIME", + 17179869313u64 => "Q_NOT_PRIME", + 17179869314u64 => "RSA_OPERATIONS_NOT_SUPPORTED", + 17179869320u64 => "SLEN_CHECK_FAILED", + 17179869319u64 => "SLEN_RECOVERY_FAILED", + 17179869299u64 => "SSLV3_ROLLBACK_ATTACK", + 17179869300u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD", + 17179869301u64 => "UNKNOWN_ALGORITHM_TYPE", + 17179869350u64 => "UNKNOWN_DIGEST", + 17179869335u64 => "UNKNOWN_MASK_DIGEST", + 17179869302u64 => "UNKNOWN_PADDING_TYPE", + 17179869346u64 => "UNSUPPORTED_ENCRYPTION_TYPE", + 17179869347u64 => "UNSUPPORTED_LABEL_SOURCE", + 17179869337u64 => "UNSUPPORTED_MASK_ALGORITHM", + 17179869338u64 => "UNSUPPORTED_MASK_PARAMETER", + 17179869339u64 => "UNSUPPORTED_SIGNATURE_TYPE", + 17179869331u64 => "VALUE_MISSING", + 17179869303u64 => "WRONG_SIGNATURE_LENGTH", + 227633266788u64 => "ASN1_ERROR", + 227633266789u64 => "BAD_SIGNATURE", + 227633266795u64 => "BUFFER_TOO_SMALL", + 227633266798u64 => "DIST_ID_TOO_LARGE", + 227633266800u64 => "ID_NOT_SET", + 227633266799u64 => "ID_TOO_LARGE", + 227633266796u64 => "INVALID_CURVE", + 227633266790u64 => "INVALID_DIGEST", + 227633266791u64 => "INVALID_DIGEST_TYPE", + 227633266792u64 => "INVALID_ENCODING", + 227633266793u64 => "INVALID_FIELD", + 227633266797u64 => "NO_PARAMETERS_SET", + 227633266794u64 => "USER_ID_TOO_LARGE", + 85899346211u64 => "APPLICATION_DATA_AFTER_CLOSE_NOTIFY", + 85899346020u64 => "APP_DATA_IN_HANDSHAKE", + 85899346192u64 => "ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT", + 85899346063u64 => "AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE", + 85899346078u64 => "AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE", + 85899346023u64 => "BAD_CHANGE_CIPHER_SPEC", + 85899346106u64 => "BAD_CIPHER", + 85899346310u64 => "BAD_DATA", + 85899346026u64 => "BAD_DATA_RETURNED_BY_CALLBACK", + 85899346027u64 => "BAD_DECOMPRESSION", + 85899346022u64 => "BAD_DH_VALUE", + 85899346031u64 => "BAD_DIGEST_LENGTH", + 85899346153u64 => "BAD_EARLY_DATA", + 85899346224u64 => "BAD_ECC_CERT", + 85899346226u64 => "BAD_ECPOINT", + 85899346030u64 => "BAD_EXTENSION", + 85899346252u64 => "BAD_HANDSHAKE_LENGTH", + 85899346156u64 => "BAD_HANDSHAKE_STATE", + 85899346025u64 => "BAD_HELLO_REQUEST", + 85899346183u64 => "BAD_HRR_VERSION", + 85899346028u64 => "BAD_KEY_SHARE", + 85899346042u64 => "BAD_KEY_UPDATE", + 85899346212u64 => "BAD_LEGACY_VERSION", + 85899346191u64 => "BAD_LENGTH", + 85899346160u64 => "BAD_PACKET", + 85899346035u64 => "BAD_PACKET_LENGTH", + 85899346036u64 => "BAD_PROTOCOL_VERSION_NUMBER", + 85899346139u64 => "BAD_PSK", + 85899346034u64 => "BAD_PSK_IDENTITY", + 85899346363u64 => "BAD_RECORD_TYPE", + 85899346039u64 => "BAD_RSA_ENCRYPT", + 85899346043u64 => "BAD_SIGNATURE", + 85899346267u64 => "BAD_SRP_A_LENGTH", + 85899346291u64 => "BAD_SRP_PARAMETERS", + 85899346272u64 => "BAD_SRTP_MKI_VALUE", + 85899346273u64 => "BAD_SRTP_PROTECTION_PROFILE_LIST", + 85899346044u64 => "BAD_SSL_FILETYPE", + 85899346304u64 => "BAD_VALUE", + 85899346047u64 => "BAD_WRITE_RETRY", + 85899346173u64 => "BINDER_DOES_NOT_VERIFY", + 85899346048u64 => "BIO_NOT_SET", + 85899346049u64 => "BLOCK_CIPHER_PAD_IS_WRONG", + 85899346050u64 => "BN_LIB", + 85899346154u64 => "CALLBACK_FAILED", + 85899346029u64 => "CANNOT_CHANGE_CIPHER", + 85899346051u64 => "CA_DN_LENGTH_MISMATCH", + 85899346317u64 => "CA_KEY_TOO_SMALL", + 85899346318u64 => "CA_MD_TOO_WEAK", + 85899346053u64 => "CCS_RECEIVED_EARLY", + 85899346054u64 => "CERTIFICATE_VERIFY_FAILED", + 85899346297u64 => "CERT_CB_ERROR", + 85899346055u64 => "CERT_LENGTH_MISMATCH", + 85899346138u64 => "CIPHERSUITE_DIGEST_HAS_CHANGED", + 85899346057u64 => "CIPHER_CODE_WRONG_LENGTH", + 85899346058u64 => "CIPHER_OR_HASH_UNAVAILABLE", + 85899346146u64 => "CLIENTHELLO_TLSEXT", + 85899346060u64 => "COMPRESSED_LENGTH_TOO_LONG", + 85899346263u64 => "COMPRESSION_DISABLED", + 85899346061u64 => "COMPRESSION_FAILURE", + 85899346227u64 => "COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE", + 85899346062u64 => "COMPRESSION_LIBRARY_ERROR", + 85899346064u64 => "CONNECTION_TYPE_NOT_SET", + 85899346087u64 => "CONTEXT_NOT_DANE_ENABLED", + 85899346320u64 => "COOKIE_GEN_CALLBACK_FAILURE", + 85899346228u64 => "COOKIE_MISMATCH", + 85899346126u64 => "CUSTOM_EXT_HANDLER_ALREADY_INSTALLED", + 85899346092u64 => "DANE_ALREADY_ENABLED", + 85899346093u64 => "DANE_CANNOT_OVERRIDE_MTYPE_FULL", + 85899346095u64 => "DANE_NOT_ENABLED", + 85899346100u64 => "DANE_TLSA_BAD_CERTIFICATE", + 85899346104u64 => "DANE_TLSA_BAD_CERTIFICATE_USAGE", + 85899346109u64 => "DANE_TLSA_BAD_DATA_LENGTH", + 85899346112u64 => "DANE_TLSA_BAD_DIGEST_LENGTH", + 85899346120u64 => "DANE_TLSA_BAD_MATCHING_TYPE", + 85899346121u64 => "DANE_TLSA_BAD_PUBLIC_KEY", + 85899346122u64 => "DANE_TLSA_BAD_SELECTOR", + 85899346123u64 => "DANE_TLSA_NULL_DATA", + 85899346065u64 => "DATA_BETWEEN_CCS_AND_FINISHED", + 85899346066u64 => "DATA_LENGTH_TOO_LONG", + 85899346067u64 => "DECRYPTION_FAILED", + 85899346201u64 => "DECRYPTION_FAILED_OR_BAD_RECORD_MAC", + 85899346314u64 => "DH_KEY_TOO_SMALL", + 85899346068u64 => "DH_PUBLIC_VALUE_LENGTH_IS_WRONG", + 85899346069u64 => "DIGEST_CHECK_FAILED", + 85899346254u64 => "DTLS_MESSAGE_TOO_BIG", + 85899346229u64 => "DUPLICATE_COMPRESSION_ID", + 85899346238u64 => "ECC_CERT_NOT_FOR_SIGNING", + 85899346294u64 => "ECDH_REQUIRED_FOR_SUITEB_MODE", + 85899346319u64 => "EE_KEY_TOO_SMALL", + 85899346274u64 => "EMPTY_SRTP_PROTECTION_PROFILE_LIST", + 85899346070u64 => "ENCRYPTED_LENGTH_TOO_LONG", + 85899346071u64 => "ERROR_IN_RECEIVED_CIPHER_LIST", + 85899346124u64 => "ERROR_SETTING_TLSA_BASE_DOMAIN", + 85899346114u64 => "EXCEEDS_MAX_FRAGMENT_SIZE", + 85899346072u64 => "EXCESSIVE_MESSAGE_SIZE", + 85899346199u64 => "EXTENSION_NOT_RECEIVED", + 85899346073u64 => "EXTRA_DATA_IN_MESSAGE", + 85899346083u64 => "EXT_LENGTH_MISMATCH", + 85899346325u64 => "FAILED_TO_INIT_ASYNC", + 85899346321u64 => "FRAGMENTED_CLIENT_HELLO", + 85899346074u64 => "GOT_A_FIN_BEFORE_A_CCS", + 85899346075u64 => "HTTPS_PROXY_REQUEST", + 85899346076u64 => "HTTP_REQUEST", + 85899346082u64 => "ILLEGAL_POINT_COMPRESSION", + 85899346300u64 => "ILLEGAL_SUITEB_DIGEST", + 85899346293u64 => "INAPPROPRIATE_FALLBACK", + 85899346260u64 => "INCONSISTENT_COMPRESSION", + 85899346142u64 => "INCONSISTENT_EARLY_DATA_ALPN", + 85899346151u64 => "INCONSISTENT_EARLY_DATA_SNI", + 85899346024u64 => "INCONSISTENT_EXTMS", + 85899346161u64 => "INSUFFICIENT_SECURITY", + 85899346125u64 => "INVALID_ALERT", + 85899346180u64 => "INVALID_CCS_MESSAGE", + 85899346158u64 => "INVALID_CERTIFICATE_OR_ALG", + 85899346200u64 => "INVALID_COMMAND", + 85899346261u64 => "INVALID_COMPRESSION_ALGORITHM", + 85899346203u64 => "INVALID_CONFIG", + 85899346033u64 => "INVALID_CONFIGURATION_NAME", + 85899346202u64 => "INVALID_CONTEXT", + 85899346132u64 => "INVALID_CT_VALIDATION_TYPE", + 85899346040u64 => "INVALID_KEY_UPDATE_TYPE", + 85899346094u64 => "INVALID_MAX_EARLY_DATA", + 85899346305u64 => "INVALID_NULL_CMD_NAME", + 85899346322u64 => "INVALID_SEQUENCE_NUMBER", + 85899346308u64 => "INVALID_SERVERINFO_DATA", + 85899346919u64 => "INVALID_SESSION_ID", + 85899346277u64 => "INVALID_SRP_USERNAME", + 85899346248u64 => "INVALID_STATUS_RESPONSE", + 85899346245u64 => "INVALID_TICKET_KEYS_LENGTH", + 85899346079u64 => "LENGTH_MISMATCH", + 85899346324u64 => "LENGTH_TOO_LONG", + 85899346080u64 => "LENGTH_TOO_SHORT", + 85899346194u64 => "LIBRARY_BUG", + 85899346081u64 => "LIBRARY_HAS_NO_CIPHERS", + 85899346085u64 => "MISSING_DSA_SIGNING_CERT", + 85899346301u64 => "MISSING_ECDSA_SIGNING_CERT", + 85899346176u64 => "MISSING_FATAL", + 85899346210u64 => "MISSING_PARAMETERS", + 85899346230u64 => "MISSING_PSK_KEX_MODES_EXTENSION", + 85899346088u64 => "MISSING_RSA_CERTIFICATE", + 85899346089u64 => "MISSING_RSA_ENCRYPTING_CERT", + 85899346090u64 => "MISSING_RSA_SIGNING_CERT", + 85899346032u64 => "MISSING_SIGALGS_EXTENSION", + 85899346141u64 => "MISSING_SIGNING_CERT", + 85899346278u64 => "MISSING_SRP_PARAM", + 85899346129u64 => "MISSING_SUPPORTED_GROUPS_EXTENSION", + 85899346091u64 => "MISSING_TMP_DH_KEY", + 85899346231u64 => "MISSING_TMP_ECDH_KEY", + 85899346213u64 => "MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA", + 85899346102u64 => "NOT_ON_RECORD_BOUNDARY", + 85899346209u64 => "NOT_REPLACING_CERTIFICATE", + 85899346204u64 => "NOT_SERVER", + 85899346155u64 => "NO_APPLICATION_PROTOCOL", + 85899346096u64 => "NO_CERTIFICATES_RETURNED", + 85899346097u64 => "NO_CERTIFICATE_ASSIGNED", + 85899346099u64 => "NO_CERTIFICATE_SET", + 85899346134u64 => "NO_CHANGE_FOLLOWING_HRR", + 85899346101u64 => "NO_CIPHERS_AVAILABLE", + 85899346103u64 => "NO_CIPHERS_SPECIFIED", + 85899346105u64 => "NO_CIPHER_MATCH", + 85899346251u64 => "NO_CLIENT_CERT_METHOD", + 85899346107u64 => "NO_COMPRESSION_SPECIFIED", + 85899346207u64 => "NO_COOKIE_CALLBACK_SET", + 85899346250u64 => "NO_GOST_CERTIFICATE_SENT_BY_PEER", + 85899346108u64 => "NO_METHOD_SPECIFIED", + 85899346309u64 => "NO_PEM_EXTENSIONS", + 85899346110u64 => "NO_PRIVATE_KEY_ASSIGNED", + 85899346111u64 => "NO_PROTOCOLS_AVAILABLE", + 85899346259u64 => "NO_RENEGOTIATION", + 85899346244u64 => "NO_REQUIRED_DIGEST", + 85899346113u64 => "NO_SHARED_CIPHER", + 85899346330u64 => "NO_SHARED_GROUPS", + 85899346296u64 => "NO_SHARED_SIGNATURE_ALGORITHMS", + 85899346279u64 => "NO_SRTP_PROFILES", + 85899346021u64 => "NO_SUITABLE_KEY_SHARE", + 85899346038u64 => "NO_SUITABLE_SIGNATURE_ALGORITHM", + 85899346136u64 => "NO_VALID_SCTS", + 85899346323u64 => "NO_VERIFY_COOKIE_CALLBACK", + 85899346115u64 => "NULL_SSL_CTX", + 85899346116u64 => "NULL_SSL_METHOD_PASSED", + 85899346214u64 => "OCSP_CALLBACK_FAILURE", + 85899346117u64 => "OLD_SESSION_CIPHER_NOT_RETURNED", + 85899346264u64 => "OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED", + 85899346157u64 => "OVERFLOW_ERROR", + 85899346118u64 => "PACKET_LENGTH_TOO_LONG", + 85899346147u64 => "PARSE_TLSEXT", + 85899346190u64 => "PATH_TOO_LONG", + 85899346119u64 => "PEER_DID_NOT_RETURN_A_CERTIFICATE", + 85899346311u64 => "PEM_NAME_BAD_PREFIX", + 85899346312u64 => "PEM_NAME_TOO_SHORT", + 85899346326u64 => "PIPELINE_FAILURE", + 85899346198u64 => "POST_HANDSHAKE_AUTH_ENCODING_ERR", + 85899346208u64 => "PRIVATE_KEY_MISMATCH", + 85899346127u64 => "PROTOCOL_IS_SHUTDOWN", + 85899346143u64 => "PSK_IDENTITY_NOT_FOUND", + 85899346144u64 => "PSK_NO_CLIENT_CB", + 85899346145u64 => "PSK_NO_SERVER_CB", + 85899346131u64 => "READ_BIO_NOT_SET", + 85899346232u64 => "READ_TIMEOUT_EXPIRED", + 85899346133u64 => "RECORD_LENGTH_MISMATCH", + 85899346218u64 => "RECORD_TOO_SMALL", + 85899346255u64 => "RENEGOTIATE_EXT_TOO_LONG", + 85899346256u64 => "RENEGOTIATION_ENCODING_ERR", + 85899346257u64 => "RENEGOTIATION_MISMATCH", + 85899346205u64 => "REQUEST_PENDING", + 85899346206u64 => "REQUEST_SENT", + 85899346135u64 => "REQUIRED_CIPHER_MISSING", + 85899346262u64 => "REQUIRED_COMPRESSION_ALGORITHM_MISSING", + 85899346265u64 => "SCSV_RECEIVED_WHEN_RENEGOTIATING", + 85899346128u64 => "SCT_VERIFICATION_FAILED", + 85899346195u64 => "SERVERHELLO_TLSEXT", + 85899346197u64 => "SESSION_ID_CONTEXT_UNINITIALIZED", + 85899346327u64 => "SHUTDOWN_WHILE_IN_INIT", + 85899346280u64 => "SIGNATURE_ALGORITHMS_ERROR", + 85899346140u64 => "SIGNATURE_FOR_NON_SIGNING_CERTIFICATE", + 85899346281u64 => "SRP_A_CALC", + 85899346282u64 => "SRTP_COULD_NOT_ALLOCATE_PROFILES", + 85899346283u64 => "SRTP_PROTECTION_PROFILE_LIST_TOO_LONG", + 85899346284u64 => "SRTP_UNKNOWN_PROTECTION_PROFILE", + 85899346152u64 => "SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH", + 85899346239u64 => "SSL3_EXT_INVALID_SERVERNAME", + 85899346240u64 => "SSL3_EXT_INVALID_SERVERNAME_TYPE", + 85899346220u64 => "SSL3_SESSION_ID_TOO_LONG", + 85899346962u64 => "SSLV3_ALERT_BAD_CERTIFICATE", + 85899346940u64 => "SSLV3_ALERT_BAD_RECORD_MAC", + 85899346965u64 => "SSLV3_ALERT_CERTIFICATE_EXPIRED", + 85899346964u64 => "SSLV3_ALERT_CERTIFICATE_REVOKED", + 85899346966u64 => "SSLV3_ALERT_CERTIFICATE_UNKNOWN", + 85899346950u64 => "SSLV3_ALERT_DECOMPRESSION_FAILURE", + 85899346960u64 => "SSLV3_ALERT_HANDSHAKE_FAILURE", + 85899346967u64 => "SSLV3_ALERT_ILLEGAL_PARAMETER", + 85899346961u64 => "SSLV3_ALERT_NO_CERTIFICATE", + 85899346930u64 => "SSLV3_ALERT_UNEXPECTED_MESSAGE", + 85899346963u64 => "SSLV3_ALERT_UNSUPPORTED_CERTIFICATE", + 85899346037u64 => "SSL_COMMAND_SECTION_EMPTY", + 85899346045u64 => "SSL_COMMAND_SECTION_NOT_FOUND", + 85899346148u64 => "SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION", + 85899346149u64 => "SSL_HANDSHAKE_FAILURE", + 85899346150u64 => "SSL_LIBRARY_HAS_NO_CIPHERS", + 85899346292u64 => "SSL_NEGATIVE_LENGTH", + 85899346046u64 => "SSL_SECTION_EMPTY", + 85899346056u64 => "SSL_SECTION_NOT_FOUND", + 85899346221u64 => "SSL_SESSION_ID_CALLBACK_FAILED", + 85899346222u64 => "SSL_SESSION_ID_CONFLICT", + 85899346193u64 => "SSL_SESSION_ID_CONTEXT_TOO_LONG", + 85899346223u64 => "SSL_SESSION_ID_HAS_BAD_LENGTH", + 85899346328u64 => "SSL_SESSION_ID_TOO_LONG", + 85899346130u64 => "SSL_SESSION_VERSION_MISMATCH", + 85899346041u64 => "STILL_IN_INIT", + 85899347036u64 => "TLSV13_ALERT_CERTIFICATE_REQUIRED", + 85899347029u64 => "TLSV13_ALERT_MISSING_EXTENSION", + 85899346969u64 => "TLSV1_ALERT_ACCESS_DENIED", + 85899346970u64 => "TLSV1_ALERT_DECODE_ERROR", + 85899346941u64 => "TLSV1_ALERT_DECRYPTION_FAILED", + 85899346971u64 => "TLSV1_ALERT_DECRYPT_ERROR", + 85899346980u64 => "TLSV1_ALERT_EXPORT_RESTRICTION", + 85899347006u64 => "TLSV1_ALERT_INAPPROPRIATE_FALLBACK", + 85899346991u64 => "TLSV1_ALERT_INSUFFICIENT_SECURITY", + 85899347000u64 => "TLSV1_ALERT_INTERNAL_ERROR", + 85899347020u64 => "TLSV1_ALERT_NO_RENEGOTIATION", + 85899346990u64 => "TLSV1_ALERT_PROTOCOL_VERSION", + 85899346942u64 => "TLSV1_ALERT_RECORD_OVERFLOW", + 85899346968u64 => "TLSV1_ALERT_UNKNOWN_CA", + 85899347010u64 => "TLSV1_ALERT_USER_CANCELLED", + 85899347034u64 => "TLSV1_BAD_CERTIFICATE_HASH_VALUE", + 85899347033u64 => "TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE", + 85899347031u64 => "TLSV1_CERTIFICATE_UNOBTAINABLE", + 85899347032u64 => "TLSV1_UNRECOGNIZED_NAME", + 85899347030u64 => "TLSV1_UNSUPPORTED_EXTENSION", + 85899346285u64 => "TLS_HEARTBEAT_PEER_DOESNT_ACCEPT", + 85899346286u64 => "TLS_HEARTBEAT_PENDING", + 85899346287u64 => "TLS_ILLEGAL_EXPORTER_LABEL", + 85899346077u64 => "TLS_INVALID_ECPOINTFORMAT_LIST", + 85899346052u64 => "TOO_MANY_KEY_UPDATES", + 85899346329u64 => "TOO_MANY_WARN_ALERTS", + 85899346084u64 => "TOO_MUCH_EARLY_DATA", + 85899346234u64 => "UNABLE_TO_FIND_ECDH_PARAMETERS", + 85899346159u64 => "UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS", + 85899346162u64 => "UNABLE_TO_LOAD_SSL3_MD5_ROUTINES", + 85899346163u64 => "UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES", + 85899346182u64 => "UNEXPECTED_CCS_MESSAGE", + 85899346098u64 => "UNEXPECTED_END_OF_EARLY_DATA", + 85899346164u64 => "UNEXPECTED_MESSAGE", + 85899346165u64 => "UNEXPECTED_RECORD", + 85899346196u64 => "UNINITIALIZED", + 85899346166u64 => "UNKNOWN_ALERT_TYPE", + 85899346167u64 => "UNKNOWN_CERTIFICATE_TYPE", + 85899346168u64 => "UNKNOWN_CIPHER_RETURNED", + 85899346169u64 => "UNKNOWN_CIPHER_TYPE", + 85899346306u64 => "UNKNOWN_CMD_NAME", + 85899346059u64 => "UNKNOWN_COMMAND", + 85899346288u64 => "UNKNOWN_DIGEST", + 85899346170u64 => "UNKNOWN_KEY_EXCHANGE_TYPE", + 85899346171u64 => "UNKNOWN_PKEY_TYPE", + 85899346172u64 => "UNKNOWN_PROTOCOL", + 85899346174u64 => "UNKNOWN_SSL_VERSION", + 85899346175u64 => "UNKNOWN_STATE", + 85899346258u64 => "UNSAFE_LEGACY_RENEGOTIATION_DISABLED", + 85899346137u64 => "UNSOLICITED_EXTENSION", + 85899346177u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM", + 85899346235u64 => "UNSUPPORTED_ELLIPTIC_CURVE", + 85899346178u64 => "UNSUPPORTED_PROTOCOL", + 85899346179u64 => "UNSUPPORTED_SSL_VERSION", + 85899346249u64 => "UNSUPPORTED_STATUS_TYPE", + 85899346289u64 => "USE_SRTP_NOT_NEGOTIATED", + 85899346086u64 => "VERSION_TOO_HIGH", + 85899346316u64 => "VERSION_TOO_LOW", + 85899346303u64 => "WRONG_CERTIFICATE_TYPE", + 85899346181u64 => "WRONG_CIPHER_RETURNED", + 85899346298u64 => "WRONG_CURVE", + 85899346184u64 => "WRONG_SIGNATURE_LENGTH", + 85899346185u64 => "WRONG_SIGNATURE_SIZE", + 85899346290u64 => "WRONG_SIGNATURE_TYPE", + 85899346186u64 => "WRONG_SSL_VERSION", + 85899346187u64 => "WRONG_VERSION_NUMBER", + 85899346188u64 => "X509_LIB", + 85899346189u64 => "X509_VERIFICATION_SETUP_PROBLEMS", + 201863463044u64 => "BAD_PKCS7_TYPE", + 201863463045u64 => "BAD_TYPE", + 201863463049u64 => "CANNOT_LOAD_CERT", + 201863463050u64 => "CANNOT_LOAD_KEY", + 201863463012u64 => "CERTIFICATE_VERIFY_ERROR", + 201863463039u64 => "COULD_NOT_SET_ENGINE", + 201863463027u64 => "COULD_NOT_SET_TIME", + 201863463046u64 => "DETACHED_CONTENT", + 201863463028u64 => "ESS_ADD_SIGNING_CERT_ERROR", + 201863463051u64 => "ESS_ADD_SIGNING_CERT_V2_ERROR", + 201863463013u64 => "ESS_SIGNING_CERTIFICATE_ERROR", + 201863463014u64 => "INVALID_NULL_POINTER", + 201863463029u64 => "INVALID_SIGNER_CERTIFICATE_PURPOSE", + 201863463015u64 => "MESSAGE_IMPRINT_MISMATCH", + 201863463016u64 => "NONCE_MISMATCH", + 201863463017u64 => "NONCE_NOT_RETURNED", + 201863463018u64 => "NO_CONTENT", + 201863463019u64 => "NO_TIME_STAMP_TOKEN", + 201863463030u64 => "PKCS7_ADD_SIGNATURE_ERROR", + 201863463031u64 => "PKCS7_ADD_SIGNED_ATTR_ERROR", + 201863463041u64 => "PKCS7_TO_TS_TST_INFO_FAILED", + 201863463020u64 => "POLICY_MISMATCH", + 201863463032u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 201863463033u64 => "RESPONSE_SETUP_ERROR", + 201863463021u64 => "SIGNATURE_FAILURE", + 201863463022u64 => "THERE_MUST_BE_ONE_SIGNER", + 201863463034u64 => "TIME_SYSCALL_ERROR", + 201863463042u64 => "TOKEN_NOT_PRESENT", + 201863463043u64 => "TOKEN_PRESENT", + 201863463023u64 => "TSA_NAME_MISMATCH", + 201863463024u64 => "TSA_UNTRUSTED", + 201863463035u64 => "TST_INFO_SETUP_ERROR", + 201863463036u64 => "TS_DATASIGN", + 201863463037u64 => "UNACCEPTABLE_POLICY", + 201863463038u64 => "UNSUPPORTED_MD_ALGORITHM", + 201863463025u64 => "UNSUPPORTED_VERSION", + 201863463047u64 => "VAR_BAD_VALUE", + 201863463048u64 => "VAR_LOOKUP_FAILURE", + 201863463026u64 => "WRONG_CONTENT_TYPE", + 171798691944u64 => "COMMON_OK_AND_CANCEL_CHARACTERS", + 171798691942u64 => "INDEX_TOO_LARGE", + 171798691943u64 => "INDEX_TOO_SMALL", + 171798691945u64 => "NO_RESULT_BUFFER", + 171798691947u64 => "PROCESSING_ERROR", + 171798691940u64 => "RESULT_TOO_LARGE", + 171798691941u64 => "RESULT_TOO_SMALL", + 171798691949u64 => "SYSASSIGN_ERROR", + 171798691950u64 => "SYSDASSGN_ERROR", + 171798691951u64 => "SYSQIOW_ERROR", + 171798691946u64 => "UNKNOWN_CONTROL_COMMAND", + 171798691948u64 => "UNKNOWN_TTYGET_ERRNO_VALUE", + 171798691952u64 => "USER_DATA_DUPLICATION_UNSUPPORTED", + 146028888182u64 => "BAD_IP_ADDRESS", + 146028888183u64 => "BAD_OBJECT", + 146028888164u64 => "BN_DEC2BN_ERROR", + 146028888165u64 => "BN_TO_ASN1_INTEGER_ERROR", + 146028888213u64 => "DIRNAME_ERROR", + 146028888224u64 => "DISTPOINT_ALREADY_SET", + 146028888197u64 => "DUPLICATE_ZONE_ID", + 146028888195u64 => "ERROR_CONVERTING_ZONE", + 146028888208u64 => "ERROR_CREATING_EXTENSION", + 146028888192u64 => "ERROR_IN_EXTENSION", + 146028888201u64 => "EXPECTED_A_SECTION_NAME", + 146028888209u64 => "EXTENSION_EXISTS", + 146028888179u64 => "EXTENSION_NAME_ERROR", + 146028888166u64 => "EXTENSION_NOT_FOUND", + 146028888167u64 => "EXTENSION_SETTING_NOT_SUPPORTED", + 146028888180u64 => "EXTENSION_VALUE_ERROR", + 146028888215u64 => "ILLEGAL_EMPTY_EXTENSION", + 146028888216u64 => "INCORRECT_POLICY_SYNTAX_TAG", + 146028888226u64 => "INVALID_ASNUMBER", + 146028888227u64 => "INVALID_ASRANGE", + 146028888168u64 => "INVALID_BOOLEAN_STRING", + 146028888169u64 => "INVALID_EXTENSION_STRING", + 146028888229u64 => "INVALID_INHERITANCE", + 146028888230u64 => "INVALID_IPADDRESS", + 146028888225u64 => "INVALID_MULTIPLE_RDNS", + 146028888170u64 => "INVALID_NAME", + 146028888171u64 => "INVALID_NULL_ARGUMENT", + 146028888172u64 => "INVALID_NULL_NAME", + 146028888173u64 => "INVALID_NULL_VALUE", + 146028888204u64 => "INVALID_NUMBER", + 146028888205u64 => "INVALID_NUMBERS", + 146028888174u64 => "INVALID_OBJECT_IDENTIFIER", + 146028888202u64 => "INVALID_OPTION", + 146028888198u64 => "INVALID_POLICY_IDENTIFIER", + 146028888217u64 => "INVALID_PROXY_POLICY_SETTING", + 146028888210u64 => "INVALID_PURPOSE", + 146028888228u64 => "INVALID_SAFI", + 146028888199u64 => "INVALID_SECTION", + 146028888207u64 => "INVALID_SYNTAX", + 146028888190u64 => "ISSUER_DECODE_ERROR", + 146028888188u64 => "MISSING_VALUE", + 146028888206u64 => "NEED_ORGANIZATION_AND_NUMBERS", + 146028888200u64 => "NO_CONFIG_DATABASE", + 146028888185u64 => "NO_ISSUER_CERTIFICATE", + 146028888191u64 => "NO_ISSUER_DETAILS", + 146028888203u64 => "NO_POLICY_IDENTIFIER", + 146028888218u64 => "NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED", + 146028888178u64 => "NO_PUBLIC_KEY", + 146028888189u64 => "NO_SUBJECT_DETAILS", + 146028888212u64 => "OPERATION_NOT_DEFINED", + 146028888211u64 => "OTHERNAME_ERROR", + 146028888219u64 => "POLICY_LANGUAGE_ALREADY_DEFINED", + 146028888220u64 => "POLICY_PATH_LENGTH", + 146028888221u64 => "POLICY_PATH_LENGTH_ALREADY_DEFINED", + 146028888223u64 => "POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY", + 146028888214u64 => "SECTION_NOT_FOUND", + 146028888186u64 => "UNABLE_TO_GET_ISSUER_DETAILS", + 146028888187u64 => "UNABLE_TO_GET_ISSUER_KEYID", + 146028888175u64 => "UNKNOWN_BIT_STRING_ARGUMENT", + 146028888193u64 => "UNKNOWN_EXTENSION", + 146028888194u64 => "UNKNOWN_EXTENSION_NAME", + 146028888184u64 => "UNKNOWN_OPTION", + 146028888181u64 => "UNSUPPORTED_OPTION", + 146028888231u64 => "UNSUPPORTED_TYPE", + 146028888196u64 => "USER_TOO_LONG", + 47244640366u64 => "AKID_MISMATCH", + 47244640389u64 => "BAD_SELECTOR", + 47244640356u64 => "BAD_X509_FILETYPE", + 47244640374u64 => "BASE64_DECODE_ERROR", + 47244640370u64 => "CANT_CHECK_DH_KEY", + 47244640357u64 => "CERT_ALREADY_IN_HASH_TABLE", + 47244640383u64 => "CRL_ALREADY_DELTA", + 47244640387u64 => "CRL_VERIFY_FAILURE", + 47244640384u64 => "IDP_MISMATCH", + 47244640394u64 => "INVALID_ATTRIBUTES", + 47244640369u64 => "INVALID_DIRECTORY", + 47244640375u64 => "INVALID_FIELD_NAME", + 47244640379u64 => "INVALID_TRUST", + 47244640385u64 => "ISSUER_MISMATCH", + 47244640371u64 => "KEY_TYPE_MISMATCH", + 47244640372u64 => "KEY_VALUES_MISMATCH", + 47244640359u64 => "LOADING_CERT_DIR", + 47244640360u64 => "LOADING_DEFAULTS", + 47244640380u64 => "METHOD_NOT_SUPPORTED", + 47244640390u64 => "NAME_TOO_LONG", + 47244640388u64 => "NEWER_CRL_NOT_NEWER", + 47244640391u64 => "NO_CERTIFICATE_FOUND", + 47244640392u64 => "NO_CERTIFICATE_OR_CRL_FOUND", + 47244640361u64 => "NO_CERT_SET_FOR_US_TO_VERIFY", + 47244640393u64 => "NO_CRL_FOUND", + 47244640386u64 => "NO_CRL_NUMBER", + 47244640381u64 => "PUBLIC_KEY_DECODE_ERROR", + 47244640382u64 => "PUBLIC_KEY_ENCODE_ERROR", + 47244640362u64 => "SHOULD_RETRY", + 47244640363u64 => "UNABLE_TO_FIND_PARAMETERS_IN_CHAIN", + 47244640364u64 => "UNABLE_TO_GET_CERTS_PUBLIC_KEY", + 47244640373u64 => "UNKNOWN_KEY_TYPE", + 47244640365u64 => "UNKNOWN_NID", + 47244640377u64 => "UNKNOWN_PURPOSE_ID", + 47244640376u64 => "UNKNOWN_TRUST_ID", + 47244640367u64 => "UNSUPPORTED_ALGORITHM", + 47244640368u64 => "WRONG_LOOKUP_TYPE", + 47244640378u64 => "WRONG_TYPE", +}; + +/// Helper function to create encoded key from (lib, reason) pair +#[inline] +pub fn encode_error_key(lib: i32, reason: i32) -> u64 { + ((lib as u64) << 32) | (reason as u64 & 0xFFFFFFFF) +} diff --git a/stdlib/src/ssl/ssl_data_300.rs b/stdlib/src/ssl/ssl_data_300.rs new file mode 100644 index 00000000000..0f657eb1b01 --- /dev/null +++ b/stdlib/src/ssl/ssl_data_300.rs @@ -0,0 +1,1759 @@ +// File generated by tools/make_ssl_data_rs.py +// Generated on 2025-10-29T07:17:23.737586+00:00 +// Source: OpenSSL from /tmp/openssl-3.0 +// spell-checker: disable + +use phf::phf_map; + +// Maps lib_code -> library name +// Example: 20 -> "SSL" +pub static LIBRARY_CODES: phf::Map = phf_map! { + 0u32 => "MASK", + 1u32 => "NONE", + 2u32 => "SYS", + 3u32 => "BN", + 4u32 => "RSA", + 5u32 => "DH", + 6u32 => "EVP", + 7u32 => "BUF", + 8u32 => "OBJ", + 9u32 => "PEM", + 10u32 => "DSA", + 11u32 => "X509", + 12u32 => "METH", + 13u32 => "ASN1", + 14u32 => "CONF", + 15u32 => "CRYPTO", + 16u32 => "EC", + 20u32 => "SSL", + 21u32 => "SSL23", + 22u32 => "SSL2", + 23u32 => "SSL3", + 30u32 => "RSAREF", + 31u32 => "PROXY", + 32u32 => "BIO", + 33u32 => "PKCS7", + 34u32 => "X509V3", + 35u32 => "PKCS12", + 36u32 => "RAND", + 37u32 => "DSO", + 38u32 => "ENGINE", + 39u32 => "OCSP", + 40u32 => "UI", + 41u32 => "COMP", + 42u32 => "ECDSA", + 43u32 => "ECDH", + 44u32 => "OSSL_STORE", + 45u32 => "FIPS", + 46u32 => "CMS", + 47u32 => "TS", + 48u32 => "HMAC", + 49u32 => "JPAKE", + 50u32 => "CT", + 51u32 => "ASYNC", + 52u32 => "KDF", + 53u32 => "SM2", + 54u32 => "ESS", + 55u32 => "PROP", + 56u32 => "CRMF", + 57u32 => "PROV", + 58u32 => "CMP", + 59u32 => "OSSL_ENCODER", + 60u32 => "OSSL_DECODER", + 61u32 => "HTTP", + 128u32 => "USER", +}; + +// Maps encoded (lib, reason) -> error mnemonic +// Example: encode_error_key(20, 134) -> "CERTIFICATE_VERIFY_FAILED" +// Key encoding: (lib << 32) | reason +pub static ERROR_CODES: phf::Map = phf_map! { + 55834575019u64 => "ADDING_OBJECT", + 55834575051u64 => "ASN1_PARSE_ERROR", + 55834575052u64 => "ASN1_SIG_PARSE_ERROR", + 55834574948u64 => "AUX_ERROR", + 55834574950u64 => "BAD_OBJECT_HEADER", + 55834575078u64 => "BAD_TEMPLATE", + 55834575062u64 => "BMPSTRING_IS_WRONG_LENGTH", + 55834574953u64 => "BN_LIB", + 55834574954u64 => "BOOLEAN_IS_WRONG_LENGTH", + 55834574955u64 => "BUFFER_TOO_SMALL", + 55834574956u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER", + 55834575065u64 => "CONTEXT_NOT_INITIALISED", + 55834574957u64 => "DATA_IS_WRONG", + 55834574958u64 => "DECODE_ERROR", + 55834575022u64 => "DEPTH_EXCEEDED", + 55834575046u64 => "DIGEST_AND_KEY_TYPE_NOT_SUPPORTED", + 55834574960u64 => "ENCODE_ERROR", + 55834575021u64 => "ERROR_GETTING_TIME", + 55834575020u64 => "ERROR_LOADING_SECTION", + 55834574962u64 => "ERROR_SETTING_CIPHER_PARAMS", + 55834574963u64 => "EXPECTING_AN_INTEGER", + 55834574964u64 => "EXPECTING_AN_OBJECT", + 55834574967u64 => "EXPLICIT_LENGTH_MISMATCH", + 55834574968u64 => "EXPLICIT_TAG_NOT_CONSTRUCTED", + 55834574969u64 => "FIELD_MISSING", + 55834574970u64 => "FIRST_NUM_TOO_LARGE", + 55834574971u64 => "HEADER_TOO_LONG", + 55834575023u64 => "ILLEGAL_BITSTRING_FORMAT", + 55834575024u64 => "ILLEGAL_BOOLEAN", + 55834574972u64 => "ILLEGAL_CHARACTERS", + 55834575025u64 => "ILLEGAL_FORMAT", + 55834575026u64 => "ILLEGAL_HEX", + 55834575027u64 => "ILLEGAL_IMPLICIT_TAG", + 55834575028u64 => "ILLEGAL_INTEGER", + 55834575074u64 => "ILLEGAL_NEGATIVE_VALUE", + 55834575029u64 => "ILLEGAL_NESTED_TAGGING", + 55834574973u64 => "ILLEGAL_NULL", + 55834575030u64 => "ILLEGAL_NULL_VALUE", + 55834575031u64 => "ILLEGAL_OBJECT", + 55834574974u64 => "ILLEGAL_OPTIONAL_ANY", + 55834575018u64 => "ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE", + 55834575069u64 => "ILLEGAL_PADDING", + 55834574975u64 => "ILLEGAL_TAGGED_ANY", + 55834575032u64 => "ILLEGAL_TIME_VALUE", + 55834575070u64 => "ILLEGAL_ZERO_CONTENT", + 55834575033u64 => "INTEGER_NOT_ASCII_FORMAT", + 55834574976u64 => "INTEGER_TOO_LARGE_FOR_LONG", + 55834575068u64 => "INVALID_BIT_STRING_BITS_LEFT", + 55834574977u64 => "INVALID_BMPSTRING_LENGTH", + 55834574978u64 => "INVALID_DIGIT", + 55834575053u64 => "INVALID_MIME_TYPE", + 55834575034u64 => "INVALID_MODIFIER", + 55834575035u64 => "INVALID_NUMBER", + 55834575064u64 => "INVALID_OBJECT_ENCODING", + 55834575075u64 => "INVALID_SCRYPT_PARAMETERS", + 55834574979u64 => "INVALID_SEPARATOR", + 55834575066u64 => "INVALID_STRING_TABLE_VALUE", + 55834574981u64 => "INVALID_UNIVERSALSTRING_LENGTH", + 55834574982u64 => "INVALID_UTF8STRING", + 55834575067u64 => "INVALID_VALUE", + 55834575079u64 => "LENGTH_TOO_LONG", + 55834575036u64 => "LIST_ERROR", + 55834575054u64 => "MIME_NO_CONTENT_TYPE", + 55834575055u64 => "MIME_PARSE_ERROR", + 55834575056u64 => "MIME_SIG_PARSE_ERROR", + 55834574985u64 => "MISSING_EOC", + 55834574986u64 => "MISSING_SECOND_NUMBER", + 55834575037u64 => "MISSING_VALUE", + 55834574987u64 => "MSTRING_NOT_UNIVERSAL", + 55834574988u64 => "MSTRING_WRONG_TAG", + 55834575045u64 => "NESTED_ASN1_STRING", + 55834575049u64 => "NESTED_TOO_DEEP", + 55834574989u64 => "NON_HEX_CHARACTERS", + 55834575038u64 => "NOT_ASCII_FORMAT", + 55834574990u64 => "NOT_ENOUGH_DATA", + 55834575057u64 => "NO_CONTENT_TYPE", + 55834574991u64 => "NO_MATCHING_CHOICE_TYPE", + 55834575058u64 => "NO_MULTIPART_BODY_FAILURE", + 55834575059u64 => "NO_MULTIPART_BOUNDARY", + 55834575060u64 => "NO_SIG_CONTENT_TYPE", + 55834574992u64 => "NULL_IS_WRONG_LENGTH", + 55834575039u64 => "OBJECT_NOT_ASCII_FORMAT", + 55834574993u64 => "ODD_NUMBER_OF_CHARS", + 55834574995u64 => "SECOND_NUMBER_TOO_LARGE", + 55834574996u64 => "SEQUENCE_LENGTH_MISMATCH", + 55834574997u64 => "SEQUENCE_NOT_CONSTRUCTED", + 55834575040u64 => "SEQUENCE_OR_SET_NEEDS_CONFIG", + 55834574998u64 => "SHORT_LINE", + 55834575061u64 => "SIG_INVALID_MIME_TYPE", + 55834575050u64 => "STREAMING_NOT_SUPPORTED", + 55834574999u64 => "STRING_TOO_LONG", + 55834575000u64 => "STRING_TOO_SHORT", + 55834575002u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD", + 55834575041u64 => "TIME_NOT_ASCII_FORMAT", + 55834575071u64 => "TOO_LARGE", + 55834575003u64 => "TOO_LONG", + 55834575072u64 => "TOO_SMALL", + 55834575004u64 => "TYPE_NOT_CONSTRUCTED", + 55834575043u64 => "TYPE_NOT_PRIMITIVE", + 55834575007u64 => "UNEXPECTED_EOC", + 55834575063u64 => "UNIVERSALSTRING_IS_WRONG_LENGTH", + 55834575077u64 => "UNKNOWN_DIGEST", + 55834575008u64 => "UNKNOWN_FORMAT", + 55834575009u64 => "UNKNOWN_MESSAGE_DIGEST_ALGORITHM", + 55834575010u64 => "UNKNOWN_OBJECT_TYPE", + 55834575011u64 => "UNKNOWN_PUBLIC_KEY_TYPE", + 55834575047u64 => "UNKNOWN_SIGNATURE_ALGORITHM", + 55834575042u64 => "UNKNOWN_TAG", + 55834575012u64 => "UNSUPPORTED_ANY_DEFINED_BY_TYPE", + 55834575076u64 => "UNSUPPORTED_CIPHER", + 55834575015u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE", + 55834575044u64 => "UNSUPPORTED_TYPE", + 55834575073u64 => "WRONG_INTEGER_TYPE", + 55834575048u64 => "WRONG_PUBLIC_KEY_TYPE", + 55834575016u64 => "WRONG_TAG", + 219043332197u64 => "FAILED_TO_SET_POOL", + 219043332198u64 => "FAILED_TO_SWAP_CONTEXT", + 219043332201u64 => "INIT_FAILED", + 219043332199u64 => "INVALID_POOL_SIZE", + 137438953572u64 => "ACCEPT_ERROR", + 137438953613u64 => "ADDRINFO_ADDR_IS_NOT_AF_INET", + 137438953601u64 => "AMBIGUOUS_HOST_OR_SERVICE", + 137438953573u64 => "BAD_FOPEN_MODE", + 137438953596u64 => "BROKEN_PIPE", + 137438953575u64 => "CONNECT_ERROR", + 137438953619u64 => "CONNECT_TIMEOUT", + 137438953579u64 => "GETHOSTBYNAME_ADDR_IS_NOT_AF_INET", + 137438953604u64 => "GETSOCKNAME_ERROR", + 137438953605u64 => "GETSOCKNAME_TRUNCATED_ADDRESS", + 137438953606u64 => "GETTING_SOCKTYPE", + 137438953597u64 => "INVALID_ARGUMENT", + 137438953607u64 => "INVALID_SOCKET", + 137438953595u64 => "IN_USE", + 137438953574u64 => "LENGTH_TOO_LONG", + 137438953608u64 => "LISTEN_V6_ONLY", + 137438953614u64 => "LOOKUP_RETURNED_NOTHING", + 137438953602u64 => "MALFORMED_HOST_OR_SERVICE", + 137438953582u64 => "NBIO_CONNECT_ERROR", + 137438953615u64 => "NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED", + 137438953616u64 => "NO_HOSTNAME_OR_SERVICE_SPECIFIED", + 137438953585u64 => "NO_PORT_DEFINED", + 137438953600u64 => "NO_SUCH_FILE", + 137438953576u64 => "TRANSFER_ERROR", + 137438953577u64 => "TRANSFER_TIMEOUT", + 137438953589u64 => "UNABLE_TO_BIND_SOCKET", + 137438953590u64 => "UNABLE_TO_CREATE_SOCKET", + 137438953609u64 => "UNABLE_TO_KEEPALIVE", + 137438953591u64 => "UNABLE_TO_LISTEN_SOCKET", + 137438953610u64 => "UNABLE_TO_NODELAY", + 137438953611u64 => "UNABLE_TO_REUSEADDR", + 137438953617u64 => "UNAVAILABLE_IP_FAMILY", + 137438953592u64 => "UNINITIALIZED", + 137438953612u64 => "UNKNOWN_INFO_TYPE", + 137438953618u64 => "UNSUPPORTED_IP_FAMILY", + 137438953593u64 => "UNSUPPORTED_METHOD", + 137438953603u64 => "UNSUPPORTED_PROTOCOL_FAMILY", + 137438953598u64 => "WRITE_TO_READ_ONLY_BIO", + 137438953594u64 => "WSASTARTUP", + 12884901988u64 => "ARG2_LT_ARG3", + 12884901989u64 => "BAD_RECIPROCAL", + 12884902002u64 => "BIGNUM_TOO_LONG", + 12884902006u64 => "BITS_TOO_SMALL", + 12884901990u64 => "CALLED_WITH_EVEN_MODULUS", + 12884901991u64 => "DIV_BY_ZERO", + 12884901992u64 => "ENCODING_ERROR", + 12884901993u64 => "EXPAND_ON_STATIC_BIGNUM_DATA", + 12884901998u64 => "INPUT_NOT_REDUCED", + 12884901994u64 => "INVALID_LENGTH", + 12884902003u64 => "INVALID_RANGE", + 12884902007u64 => "INVALID_SHIFT", + 12884901999u64 => "NOT_A_SQUARE", + 12884901995u64 => "NOT_INITIALIZED", + 12884901996u64 => "NO_INVERSE", + 12884902009u64 => "NO_PRIME_CANDIDATE", + 12884902004u64 => "NO_SOLUTION", + 12884902008u64 => "NO_SUITABLE_DIGEST", + 12884902005u64 => "PRIVATE_KEY_TOO_LARGE", + 12884902000u64 => "P_IS_NOT_PRIME", + 12884902001u64 => "TOO_MANY_ITERATIONS", + 12884901997u64 => "TOO_MANY_TEMPORARY_VARIABLES", + 249108103307u64 => "ALGORITHM_NOT_SUPPORTED", + 249108103335u64 => "BAD_CHECKAFTER_IN_POLLREP", + 249108103276u64 => "BAD_REQUEST_ID", + 249108103324u64 => "CERTHASH_UNMATCHED", + 249108103277u64 => "CERTID_NOT_FOUND", + 249108103337u64 => "CERTIFICATE_NOT_ACCEPTED", + 249108103280u64 => "CERTIFICATE_NOT_FOUND", + 249108103325u64 => "CERTREQMSG_NOT_FOUND", + 249108103281u64 => "CERTRESPONSE_NOT_FOUND", + 249108103282u64 => "CERT_AND_KEY_DO_NOT_MATCH", + 249108103349u64 => "CHECKAFTER_OUT_OF_RANGE", + 249108103344u64 => "ENCOUNTERED_KEYUPDATEWARNING", + 249108103330u64 => "ENCOUNTERED_WAITING", + 249108103283u64 => "ERROR_CALCULATING_PROTECTION", + 249108103284u64 => "ERROR_CREATING_CERTCONF", + 249108103285u64 => "ERROR_CREATING_CERTREP", + 249108103331u64 => "ERROR_CREATING_CERTREQ", + 249108103286u64 => "ERROR_CREATING_ERROR", + 249108103287u64 => "ERROR_CREATING_GENM", + 249108103288u64 => "ERROR_CREATING_GENP", + 249108103290u64 => "ERROR_CREATING_PKICONF", + 249108103291u64 => "ERROR_CREATING_POLLREP", + 249108103292u64 => "ERROR_CREATING_POLLREQ", + 249108103293u64 => "ERROR_CREATING_RP", + 249108103294u64 => "ERROR_CREATING_RR", + 249108103275u64 => "ERROR_PARSING_PKISTATUS", + 249108103326u64 => "ERROR_PROCESSING_MESSAGE", + 249108103295u64 => "ERROR_PROTECTING_MESSAGE", + 249108103296u64 => "ERROR_SETTING_CERTHASH", + 249108103328u64 => "ERROR_UNEXPECTED_CERTCONF", + 249108103308u64 => "ERROR_VALIDATING_PROTECTION", + 249108103339u64 => "ERROR_VALIDATING_SIGNATURE", + 249108103332u64 => "FAILED_BUILDING_OWN_CHAIN", + 249108103309u64 => "FAILED_EXTRACTING_PUBKEY", + 249108103278u64 => "FAILURE_OBTAINING_RANDOM", + 249108103297u64 => "FAIL_INFO_OUT_OF_RANGE", + 249108103268u64 => "INVALID_ARGS", + 249108103342u64 => "INVALID_OPTION", + 249108103333u64 => "MISSING_CERTID", + 249108103298u64 => "MISSING_KEY_INPUT_FOR_CREATING_PROTECTION", + 249108103310u64 => "MISSING_KEY_USAGE_DIGITALSIGNATURE", + 249108103289u64 => "MISSING_P10CSR", + 249108103334u64 => "MISSING_PBM_SECRET", + 249108103299u64 => "MISSING_PRIVATE_KEY", + 249108103358u64 => "MISSING_PRIVATE_KEY_FOR_POPO", + 249108103311u64 => "MISSING_PROTECTION", + 249108103351u64 => "MISSING_PUBLIC_KEY", + 249108103336u64 => "MISSING_REFERENCE_CERT", + 249108103346u64 => "MISSING_SECRET", + 249108103279u64 => "MISSING_SENDER_IDENTIFICATION", + 249108103347u64 => "MISSING_TRUST_ANCHOR", + 249108103312u64 => "MISSING_TRUST_STORE", + 249108103329u64 => "MULTIPLE_REQUESTS_NOT_SUPPORTED", + 249108103338u64 => "MULTIPLE_RESPONSES_NOT_SUPPORTED", + 249108103270u64 => "MULTIPLE_SAN_SOURCES", + 249108103362u64 => "NO_STDIO", + 249108103313u64 => "NO_SUITABLE_SENDER_CERT", + 249108103271u64 => "NULL_ARGUMENT", + 249108103314u64 => "PKIBODY_ERROR", + 249108103300u64 => "PKISTATUSINFO_NOT_FOUND", + 249108103340u64 => "POLLING_FAILED", + 249108103315u64 => "POTENTIALLY_INVALID_CERTIFICATE", + 249108103348u64 => "RECEIVED_ERROR", + 249108103316u64 => "RECIPNONCE_UNMATCHED", + 249108103317u64 => "REQUEST_NOT_ACCEPTED", + 249108103350u64 => "REQUEST_REJECTED_BY_SERVER", + 249108103318u64 => "SENDER_GENERALNAME_TYPE_NOT_SUPPORTED", + 249108103319u64 => "SRVCERT_DOES_NOT_VALIDATE_MSG", + 249108103352u64 => "TOTAL_TIMEOUT", + 249108103320u64 => "TRANSACTIONID_UNMATCHED", + 249108103327u64 => "TRANSFER_ERROR", + 249108103301u64 => "UNEXPECTED_PKIBODY", + 249108103353u64 => "UNEXPECTED_PKISTATUS", + 249108103321u64 => "UNEXPECTED_PVNO", + 249108103302u64 => "UNKNOWN_ALGORITHM_ID", + 249108103303u64 => "UNKNOWN_CERT_TYPE", + 249108103354u64 => "UNKNOWN_PKISTATUS", + 249108103304u64 => "UNSUPPORTED_ALGORITHM", + 249108103305u64 => "UNSUPPORTED_KEY_TYPE", + 249108103322u64 => "UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC", + 249108103343u64 => "VALUE_TOO_LARGE", + 249108103345u64 => "VALUE_TOO_SMALL", + 249108103306u64 => "WRONG_ALGORITHM_OID", + 249108103357u64 => "WRONG_CERTID", + 249108103355u64 => "WRONG_CERTID_IN_RP", + 249108103323u64 => "WRONG_PBM_VALUE", + 249108103356u64 => "WRONG_RP_COMPONENT_COUNT", + 249108103341u64 => "WRONG_SERIAL_IN_RP", + 197568495715u64 => "ADD_SIGNER_ERROR", + 197568495777u64 => "ATTRIBUTE_ERROR", + 197568495791u64 => "CERTIFICATE_ALREADY_PRESENT", + 197568495776u64 => "CERTIFICATE_HAS_NO_KEYID", + 197568495716u64 => "CERTIFICATE_VERIFY_ERROR", + 197568495800u64 => "CIPHER_AEAD_SET_TAG_ERROR", + 197568495801u64 => "CIPHER_GET_TAG", + 197568495717u64 => "CIPHER_INITIALISATION_ERROR", + 197568495718u64 => "CIPHER_PARAMETER_INITIALISATION_ERROR", + 197568495719u64 => "CMS_DATAFINAL_ERROR", + 197568495720u64 => "CMS_LIB", + 197568495786u64 => "CONTENTIDENTIFIER_MISMATCH", + 197568495721u64 => "CONTENT_NOT_FOUND", + 197568495787u64 => "CONTENT_TYPE_MISMATCH", + 197568495722u64 => "CONTENT_TYPE_NOT_COMPRESSED_DATA", + 197568495723u64 => "CONTENT_TYPE_NOT_ENVELOPED_DATA", + 197568495724u64 => "CONTENT_TYPE_NOT_SIGNED_DATA", + 197568495725u64 => "CONTENT_VERIFY_ERROR", + 197568495726u64 => "CTRL_ERROR", + 197568495727u64 => "CTRL_FAILURE", + 197568495803u64 => "DECODE_ERROR", + 197568495728u64 => "DECRYPT_ERROR", + 197568495729u64 => "ERROR_GETTING_PUBLIC_KEY", + 197568495730u64 => "ERROR_READING_MESSAGEDIGEST_ATTRIBUTE", + 197568495731u64 => "ERROR_SETTING_KEY", + 197568495732u64 => "ERROR_SETTING_RECIPIENTINFO", + 197568495799u64 => "ESS_SIGNING_CERTID_MISMATCH_ERROR", + 197568495733u64 => "INVALID_ENCRYPTED_KEY_LENGTH", + 197568495792u64 => "INVALID_KEY_ENCRYPTION_PARAMETER", + 197568495734u64 => "INVALID_KEY_LENGTH", + 197568495806u64 => "INVALID_LABEL", + 197568495807u64 => "INVALID_OAEP_PARAMETERS", + 197568495802u64 => "KDF_PARAMETER_ERROR", + 197568495735u64 => "MD_BIO_INIT_ERROR", + 197568495736u64 => "MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH", + 197568495737u64 => "MESSAGEDIGEST_WRONG_LENGTH", + 197568495788u64 => "MSGSIGDIGEST_ERROR", + 197568495778u64 => "MSGSIGDIGEST_VERIFICATION_FAILURE", + 197568495779u64 => "MSGSIGDIGEST_WRONG_LENGTH", + 197568495780u64 => "NEED_ONE_SIGNER", + 197568495781u64 => "NOT_A_SIGNED_RECEIPT", + 197568495738u64 => "NOT_ENCRYPTED_DATA", + 197568495739u64 => "NOT_KEK", + 197568495797u64 => "NOT_KEY_AGREEMENT", + 197568495740u64 => "NOT_KEY_TRANSPORT", + 197568495793u64 => "NOT_PWRI", + 197568495741u64 => "NOT_SUPPORTED_FOR_THIS_KEY_TYPE", + 197568495742u64 => "NO_CIPHER", + 197568495743u64 => "NO_CONTENT", + 197568495789u64 => "NO_CONTENT_TYPE", + 197568495744u64 => "NO_DEFAULT_DIGEST", + 197568495745u64 => "NO_DIGEST_SET", + 197568495746u64 => "NO_KEY", + 197568495790u64 => "NO_KEY_OR_CERT", + 197568495747u64 => "NO_MATCHING_DIGEST", + 197568495748u64 => "NO_MATCHING_RECIPIENT", + 197568495782u64 => "NO_MATCHING_SIGNATURE", + 197568495783u64 => "NO_MSGSIGDIGEST", + 197568495794u64 => "NO_PASSWORD", + 197568495749u64 => "NO_PRIVATE_KEY", + 197568495750u64 => "NO_PUBLIC_KEY", + 197568495784u64 => "NO_RECEIPT_REQUEST", + 197568495751u64 => "NO_SIGNERS", + 197568495804u64 => "PEER_KEY_ERROR", + 197568495752u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 197568495785u64 => "RECEIPT_DECODE_ERROR", + 197568495753u64 => "RECIPIENT_ERROR", + 197568495805u64 => "SHARED_INFO_ERROR", + 197568495754u64 => "SIGNER_CERTIFICATE_NOT_FOUND", + 197568495755u64 => "SIGNFINAL_ERROR", + 197568495756u64 => "SMIME_TEXT_ERROR", + 197568495757u64 => "STORE_INIT_ERROR", + 197568495758u64 => "TYPE_NOT_COMPRESSED_DATA", + 197568495759u64 => "TYPE_NOT_DATA", + 197568495760u64 => "TYPE_NOT_DIGESTED_DATA", + 197568495761u64 => "TYPE_NOT_ENCRYPTED_DATA", + 197568495762u64 => "TYPE_NOT_ENVELOPED_DATA", + 197568495763u64 => "UNABLE_TO_FINALIZE_CONTEXT", + 197568495764u64 => "UNKNOWN_CIPHER", + 197568495765u64 => "UNKNOWN_DIGEST_ALGORITHM", + 197568495766u64 => "UNKNOWN_ID", + 197568495767u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM", + 197568495810u64 => "UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM", + 197568495768u64 => "UNSUPPORTED_CONTENT_TYPE", + 197568495808u64 => "UNSUPPORTED_ENCRYPTION_TYPE", + 197568495769u64 => "UNSUPPORTED_KEK_ALGORITHM", + 197568495795u64 => "UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM", + 197568495809u64 => "UNSUPPORTED_LABEL_SOURCE", + 197568495771u64 => "UNSUPPORTED_RECIPIENTINFO_TYPE", + 197568495770u64 => "UNSUPPORTED_RECIPIENT_TYPE", + 197568495811u64 => "UNSUPPORTED_SIGNATURE_ALGORITHM", + 197568495772u64 => "UNSUPPORTED_TYPE", + 197568495773u64 => "UNWRAP_ERROR", + 197568495796u64 => "UNWRAP_FAILURE", + 197568495774u64 => "VERIFICATION_FAILURE", + 197568495775u64 => "WRAP_ERROR", + 176093659235u64 => "ZLIB_DEFLATE_ERROR", + 176093659236u64 => "ZLIB_INFLATE_ERROR", + 176093659237u64 => "ZLIB_NOT_SUPPORTED", + 60129542254u64 => "ERROR_LOADING_DSO", + 60129542266u64 => "INVALID_PRAGMA", + 60129542259u64 => "LIST_CANNOT_BE_NULL", + 60129542267u64 => "MANDATORY_BRACES_IN_VARIABLE_EXPANSION", + 60129542244u64 => "MISSING_CLOSE_SQUARE_BRACKET", + 60129542245u64 => "MISSING_EQUAL_SIGN", + 60129542256u64 => "MISSING_INIT_FUNCTION", + 60129542253u64 => "MODULE_INITIALIZATION_ERROR", + 60129542246u64 => "NO_CLOSE_BRACE", + 60129542249u64 => "NO_CONF", + 60129542250u64 => "NO_CONF_OR_ENVIRONMENT_VARIABLE", + 60129542251u64 => "NO_SECTION", + 60129542258u64 => "NO_SUCH_FILE", + 60129542252u64 => "NO_VALUE", + 60129542265u64 => "NUMBER_TOO_LARGE", + 60129542268u64 => "OPENSSL_CONF_REFERENCES_MISSING_SECTION", + 60129542255u64 => "RECURSIVE_DIRECTORY_INCLUDE", + 60129542270u64 => "RECURSIVE_SECTION_REFERENCE", + 60129542269u64 => "RELATIVE_PATH", + 60129542261u64 => "SSL_COMMAND_SECTION_EMPTY", + 60129542262u64 => "SSL_COMMAND_SECTION_NOT_FOUND", + 60129542263u64 => "SSL_SECTION_EMPTY", + 60129542264u64 => "SSL_SECTION_NOT_FOUND", + 60129542247u64 => "UNABLE_TO_CREATE_NEW_SECTION", + 60129542257u64 => "UNKNOWN_MODULE_NAME", + 60129542260u64 => "VARIABLE_EXPANSION_TOO_LONG", + 60129542248u64 => "VARIABLE_HAS_NO_VALUE", + 240518168676u64 => "BAD_PBM_ITERATIONCOUNT", + 240518168678u64 => "CRMFERROR", + 240518168679u64 => "ERROR", + 240518168680u64 => "ERROR_DECODING_CERTIFICATE", + 240518168681u64 => "ERROR_DECRYPTING_CERTIFICATE", + 240518168682u64 => "ERROR_DECRYPTING_SYMMETRIC_KEY", + 240518168683u64 => "FAILURE_OBTAINING_RANDOM", + 240518168684u64 => "ITERATIONCOUNT_BELOW_100", + 240518168677u64 => "MALFORMED_IV", + 240518168685u64 => "NULL_ARGUMENT", + 240518168689u64 => "POPOSKINPUT_NOT_SUPPORTED", + 240518168693u64 => "POPO_INCONSISTENT_PUBLIC_KEY", + 240518168697u64 => "POPO_MISSING", + 240518168694u64 => "POPO_MISSING_PUBLIC_KEY", + 240518168695u64 => "POPO_MISSING_SUBJECT", + 240518168696u64 => "POPO_RAVERIFIED_NOT_ACCEPTED", + 240518168686u64 => "SETTING_MAC_ALGOR_FAILURE", + 240518168687u64 => "SETTING_OWF_ALGOR_FAILURE", + 240518168688u64 => "UNSUPPORTED_ALGORITHM", + 240518168690u64 => "UNSUPPORTED_CIPHER", + 240518168691u64 => "UNSUPPORTED_METHOD_FOR_CREATING_POPO", + 240518168692u64 => "UNSUPPORTED_POPO_METHOD", + 64424509557u64 => "BAD_ALGORITHM_NAME", + 64424509558u64 => "CONFLICTING_NAMES", + 64424509561u64 => "HEX_STRING_TOO_SHORT", + 64424509542u64 => "ILLEGAL_HEX_DIGIT", + 64424509546u64 => "INSUFFICIENT_DATA_SPACE", + 64424509547u64 => "INSUFFICIENT_PARAM_SIZE", + 64424509548u64 => "INSUFFICIENT_SECURE_DATA_SPACE", + 64424509562u64 => "INVALID_NEGATIVE_VALUE", + 64424509549u64 => "INVALID_NULL_ARGUMENT", + 64424509550u64 => "INVALID_OSSL_PARAM_TYPE", + 64424509543u64 => "ODD_NUMBER_OF_DIGITS", + 64424509544u64 => "PROVIDER_ALREADY_EXISTS", + 64424509545u64 => "PROVIDER_SECTION_ERROR", + 64424509559u64 => "RANDOM_SECTION_ERROR", + 64424509551u64 => "SECURE_MALLOC_FAILURE", + 64424509552u64 => "STRING_TOO_LONG", + 64424509553u64 => "TOO_MANY_BYTES", + 64424509554u64 => "TOO_MANY_RECORDS", + 64424509556u64 => "TOO_SMALL_BUFFER", + 64424509560u64 => "UNKNOWN_NAME_IN_RANDOM_SECTION", + 64424509555u64 => "ZERO_LENGTH_NUMBER", + 214748364908u64 => "BASE64_DECODE_ERROR", + 214748364900u64 => "INVALID_LOG_ID_LENGTH", + 214748364909u64 => "LOG_CONF_INVALID", + 214748364910u64 => "LOG_CONF_INVALID_KEY", + 214748364911u64 => "LOG_CONF_MISSING_DESCRIPTION", + 214748364912u64 => "LOG_CONF_MISSING_KEY", + 214748364913u64 => "LOG_KEY_INVALID", + 214748364916u64 => "SCT_FUTURE_TIMESTAMP", + 214748364904u64 => "SCT_INVALID", + 214748364907u64 => "SCT_INVALID_SIGNATURE", + 214748364905u64 => "SCT_LIST_INVALID", + 214748364914u64 => "SCT_LOG_ID_MISMATCH", + 214748364906u64 => "SCT_NOT_SET", + 214748364915u64 => "SCT_UNSUPPORTED_VERSION", + 214748364901u64 => "UNRECOGNIZED_SIGNATURE_NID", + 214748364902u64 => "UNSUPPORTED_ENTRY_TYPE", + 214748364903u64 => "UNSUPPORTED_VERSION", + 21474836607u64 => "BAD_FFC_PARAMETERS", + 21474836581u64 => "BAD_GENERATOR", + 21474836589u64 => "BN_DECODE_ERROR", + 21474836586u64 => "BN_ERROR", + 21474836595u64 => "CHECK_INVALID_J_VALUE", + 21474836596u64 => "CHECK_INVALID_Q_VALUE", + 21474836602u64 => "CHECK_PUBKEY_INVALID", + 21474836603u64 => "CHECK_PUBKEY_TOO_LARGE", + 21474836604u64 => "CHECK_PUBKEY_TOO_SMALL", + 21474836597u64 => "CHECK_P_NOT_PRIME", + 21474836598u64 => "CHECK_P_NOT_SAFE_PRIME", + 21474836599u64 => "CHECK_Q_NOT_PRIME", + 21474836584u64 => "DECODE_ERROR", + 21474836590u64 => "INVALID_PARAMETER_NAME", + 21474836594u64 => "INVALID_PARAMETER_NID", + 21474836582u64 => "INVALID_PUBKEY", + 21474836608u64 => "INVALID_SECRET", + 21474836592u64 => "KDF_PARAMETER_ERROR", + 21474836588u64 => "KEYS_NOT_SET", + 21474836605u64 => "MISSING_PUBKEY", + 21474836583u64 => "MODULUS_TOO_LARGE", + 21474836606u64 => "MODULUS_TOO_SMALL", + 21474836600u64 => "NOT_SUITABLE_GENERATOR", + 21474836587u64 => "NO_PARAMETERS_SET", + 21474836580u64 => "NO_PRIVATE_VALUE", + 21474836585u64 => "PARAMETER_ENCODING_ERROR", + 21474836591u64 => "PEER_KEY_ERROR", + 21474836610u64 => "Q_TOO_LARGE", + 21474836593u64 => "SHARED_INFO_ERROR", + 21474836601u64 => "UNABLE_TO_CHECK_GENERATOR", + 42949673074u64 => "BAD_FFC_PARAMETERS", + 42949673062u64 => "BAD_Q_VALUE", + 42949673068u64 => "BN_DECODE_ERROR", + 42949673069u64 => "BN_ERROR", + 42949673064u64 => "DECODE_ERROR", + 42949673066u64 => "INVALID_DIGEST_TYPE", + 42949673072u64 => "INVALID_PARAMETERS", + 42949673061u64 => "MISSING_PARAMETERS", + 42949673071u64 => "MISSING_PRIVATE_KEY", + 42949673063u64 => "MODULUS_TOO_LARGE", + 42949673067u64 => "NO_PARAMETERS_SET", + 42949673065u64 => "PARAMETER_ENCODING_ERROR", + 42949673075u64 => "P_NOT_PRIME", + 42949673073u64 => "Q_NOT_PRIME", + 42949673070u64 => "SEED_LEN_SMALL", + 42949673076u64 => "TOO_MANY_RETRIES", + 158913790052u64 => "CTRL_FAILED", + 158913790062u64 => "DSO_ALREADY_LOADED", + 158913790065u64 => "EMPTY_FILE_STRUCTURE", + 158913790066u64 => "FAILURE", + 158913790053u64 => "FILENAME_TOO_BIG", + 158913790054u64 => "FINISH_FAILED", + 158913790067u64 => "INCORRECT_FILE_SYNTAX", + 158913790055u64 => "LOAD_FAILED", + 158913790061u64 => "NAME_TRANSLATION_FAILED", + 158913790063u64 => "NO_FILENAME", + 158913790056u64 => "NULL_HANDLE", + 158913790064u64 => "SET_FILENAME_FAILED", + 158913790057u64 => "STACK_ERROR", + 158913790058u64 => "SYM_FAILURE", + 158913790059u64 => "UNLOAD_FAILED", + 158913790060u64 => "UNSUPPORTED", + 68719476851u64 => "ASN1_ERROR", + 68719476892u64 => "BAD_SIGNATURE", + 68719476880u64 => "BIGNUM_OUT_OF_RANGE", + 68719476836u64 => "BUFFER_TOO_SMALL", + 68719476901u64 => "CANNOT_INVERT", + 68719476882u64 => "COORDINATES_OUT_OF_RANGE", + 68719476896u64 => "CURVE_DOES_NOT_SUPPORT_ECDH", + 68719476906u64 => "CURVE_DOES_NOT_SUPPORT_ECDSA", + 68719476895u64 => "CURVE_DOES_NOT_SUPPORT_SIGNING", + 68719476878u64 => "DECODE_ERROR", + 68719476854u64 => "DISCRIMINANT_IS_ZERO", + 68719476855u64 => "EC_GROUP_NEW_BY_NAME_FAILURE", + 68719476863u64 => "EXPLICIT_PARAMS_NOT_SUPPORTED", + 68719476902u64 => "FAILED_MAKING_PUBLIC_KEY", + 68719476879u64 => "FIELD_TOO_LARGE", + 68719476883u64 => "GF2M_NOT_SUPPORTED", + 68719476856u64 => "GROUP2PKPARAMETERS_FAILURE", + 68719476857u64 => "I2D_ECPKPARAMETERS_FAILURE", + 68719476837u64 => "INCOMPATIBLE_OBJECTS", + 68719476904u64 => "INVALID_A", + 68719476848u64 => "INVALID_ARGUMENT", + 68719476905u64 => "INVALID_B", + 68719476907u64 => "INVALID_COFACTOR", + 68719476846u64 => "INVALID_COMPRESSED_POINT", + 68719476845u64 => "INVALID_COMPRESSION_BIT", + 68719476877u64 => "INVALID_CURVE", + 68719476887u64 => "INVALID_DIGEST", + 68719476874u64 => "INVALID_DIGEST_TYPE", + 68719476838u64 => "INVALID_ENCODING", + 68719476839u64 => "INVALID_FIELD", + 68719476840u64 => "INVALID_FORM", + 68719476909u64 => "INVALID_GENERATOR", + 68719476858u64 => "INVALID_GROUP_ORDER", + 68719476852u64 => "INVALID_KEY", + 68719476853u64 => "INVALID_LENGTH", + 68719476910u64 => "INVALID_NAMED_GROUP_CONVERSION", + 68719476897u64 => "INVALID_OUTPUT_LENGTH", + 68719476908u64 => "INVALID_P", + 68719476869u64 => "INVALID_PEER_KEY", + 68719476868u64 => "INVALID_PENTANOMIAL_BASIS", + 68719476859u64 => "INVALID_PRIVATE_KEY", + 68719476911u64 => "INVALID_SEED", + 68719476873u64 => "INVALID_TRINOMIAL_BASIS", + 68719476884u64 => "KDF_PARAMETER_ERROR", + 68719476876u64 => "KEYS_NOT_SET", + 68719476872u64 => "LADDER_POST_FAILURE", + 68719476889u64 => "LADDER_PRE_FAILURE", + 68719476898u64 => "LADDER_STEP_FAILURE", + 68719476903u64 => "MISSING_OID", + 68719476860u64 => "MISSING_PARAMETERS", + 68719476861u64 => "MISSING_PRIVATE_KEY", + 68719476893u64 => "NEED_NEW_SETUP_VALUES", + 68719476871u64 => "NOT_A_NIST_PRIME", + 68719476862u64 => "NOT_IMPLEMENTED", + 68719476847u64 => "NOT_INITIALIZED", + 68719476875u64 => "NO_PARAMETERS_SET", + 68719476890u64 => "NO_PRIVATE_VALUE", + 68719476888u64 => "OPERATION_NOT_SUPPORTED", + 68719476870u64 => "PASSED_NULL_PARAMETER", + 68719476885u64 => "PEER_KEY_ERROR", + 68719476891u64 => "POINT_ARITHMETIC_FAILURE", + 68719476842u64 => "POINT_AT_INFINITY", + 68719476899u64 => "POINT_COORDINATES_BLIND_FAILURE", + 68719476843u64 => "POINT_IS_NOT_ON_CURVE", + 68719476894u64 => "RANDOM_NUMBER_GENERATION_FAILED", + 68719476886u64 => "SHARED_INFO_ERROR", + 68719476844u64 => "SLOT_FULL", + 68719476912u64 => "TOO_MANY_RETRIES", + 68719476849u64 => "UNDEFINED_GENERATOR", + 68719476864u64 => "UNDEFINED_ORDER", + 68719476900u64 => "UNKNOWN_COFACTOR", + 68719476865u64 => "UNKNOWN_GROUP", + 68719476850u64 => "UNKNOWN_ORDER", + 68719476867u64 => "UNSUPPORTED_FIELD", + 68719476881u64 => "WRONG_CURVE_PARAMETERS", + 68719476866u64 => "WRONG_ORDER", + 163208757348u64 => "ALREADY_LOADED", + 163208757381u64 => "ARGUMENT_IS_NOT_A_NUMBER", + 163208757382u64 => "CMD_NOT_EXECUTABLE", + 163208757383u64 => "COMMAND_TAKES_INPUT", + 163208757384u64 => "COMMAND_TAKES_NO_INPUT", + 163208757351u64 => "CONFLICTING_ENGINE_ID", + 163208757367u64 => "CTRL_COMMAND_NOT_IMPLEMENTED", + 163208757352u64 => "DSO_FAILURE", + 163208757380u64 => "DSO_NOT_FOUND", + 163208757396u64 => "ENGINES_SECTION_ERROR", + 163208757350u64 => "ENGINE_CONFIGURATION_ERROR", + 163208757353u64 => "ENGINE_IS_NOT_IN_LIST", + 163208757397u64 => "ENGINE_SECTION_ERROR", + 163208757376u64 => "FAILED_LOADING_PRIVATE_KEY", + 163208757377u64 => "FAILED_LOADING_PUBLIC_KEY", + 163208757354u64 => "FINISH_FAILED", + 163208757356u64 => "ID_OR_NAME_MISSING", + 163208757357u64 => "INIT_FAILED", + 163208757358u64 => "INTERNAL_LIST_ERROR", + 163208757391u64 => "INVALID_ARGUMENT", + 163208757385u64 => "INVALID_CMD_NAME", + 163208757386u64 => "INVALID_CMD_NUMBER", + 163208757399u64 => "INVALID_INIT_VALUE", + 163208757398u64 => "INVALID_STRING", + 163208757365u64 => "NOT_INITIALISED", + 163208757360u64 => "NOT_LOADED", + 163208757368u64 => "NO_CONTROL_FUNCTION", + 163208757392u64 => "NO_INDEX", + 163208757373u64 => "NO_LOAD_FUNCTION", + 163208757378u64 => "NO_REFERENCE", + 163208757364u64 => "NO_SUCH_ENGINE", + 163208757394u64 => "UNIMPLEMENTED_CIPHER", + 163208757395u64 => "UNIMPLEMENTED_DIGEST", + 163208757349u64 => "UNIMPLEMENTED_PUBLIC_KEY_METHOD", + 163208757393u64 => "VERSION_INCOMPATIBILITY", + 231928234091u64 => "EMPTY_ESS_CERT_ID_LIST", + 231928234087u64 => "ESS_CERT_DIGEST_ERROR", + 231928234088u64 => "ESS_CERT_ID_NOT_FOUND", + 231928234089u64 => "ESS_CERT_ID_WRONG_ORDER", + 231928234090u64 => "ESS_DIGEST_ALG_UNKNOWN", + 231928234086u64 => "ESS_SIGNING_CERTIFICATE_ERROR", + 231928234084u64 => "ESS_SIGNING_CERT_ADD_ERROR", + 231928234085u64 => "ESS_SIGNING_CERT_V2_ADD_ERROR", + 231928234092u64 => "MISSING_SIGNING_CERTIFICATE_ATTRIBUTE", + 25769803919u64 => "AES_KEY_SETUP_FAILED", + 25769803952u64 => "ARIA_KEY_SETUP_FAILED", + 25769803976u64 => "BAD_ALGORITHM_NAME", + 25769803876u64 => "BAD_DECRYPT", + 25769803971u64 => "BAD_KEY_LENGTH", + 25769803931u64 => "BUFFER_TOO_SMALL", + 25769804001u64 => "CACHE_CONSTANTS_FAILED", + 25769803933u64 => "CAMELLIA_KEY_SETUP_FAILED", + 25769803973u64 => "CANNOT_GET_PARAMETERS", + 25769803974u64 => "CANNOT_SET_PARAMETERS", + 25769803960u64 => "CIPHER_NOT_GCM_MODE", + 25769803898u64 => "CIPHER_PARAMETER_ERROR", + 25769803923u64 => "COMMAND_NOT_SUPPORTED", + 25769803977u64 => "CONFLICTING_ALGORITHM_NAME", + 25769803949u64 => "COPY_ERROR", + 25769803908u64 => "CTRL_NOT_IMPLEMENTED", + 25769803909u64 => "CTRL_OPERATION_NOT_IMPLEMENTED", + 25769803914u64 => "DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH", + 25769803890u64 => "DECODE_ERROR", + 25769803986u64 => "DEFAULT_QUERY_PARSE_ERROR", + 25769803877u64 => "DIFFERENT_KEY_TYPES", + 25769803929u64 => "DIFFERENT_PARAMETERS", + 25769803941u64 => "ERROR_LOADING_SECTION", + 25769803950u64 => "EXPECTING_AN_HMAC_KEY", + 25769803903u64 => "EXPECTING_AN_RSA_KEY", + 25769803904u64 => "EXPECTING_A_DH_KEY", + 25769803905u64 => "EXPECTING_A_DSA_KEY", + 25769803995u64 => "EXPECTING_A_ECX_KEY", + 25769803918u64 => "EXPECTING_A_EC_KEY", + 25769803940u64 => "EXPECTING_A_POLY1305_KEY", + 25769803951u64 => "EXPECTING_A_SIPHASH_KEY", + 25769803964u64 => "FINAL_ERROR", + 25769803990u64 => "GENERATE_ERROR", + 25769803958u64 => "GET_RAW_KEY_FAILED", + 25769803947u64 => "ILLEGAL_SCRYPT_PARAMETERS", + 25769803980u64 => "INACCESSIBLE_DOMAIN_PARAMETERS", + 25769803979u64 => "INACCESSIBLE_KEY", + 25769803910u64 => "INITIALIZATION_ERROR", + 25769803887u64 => "INPUT_NOT_INITIALIZED", + 25769803961u64 => "INVALID_CUSTOM_LENGTH", + 25769803928u64 => "INVALID_DIGEST", + 25769803970u64 => "INVALID_IV_LENGTH", + 25769803939u64 => "INVALID_KEY", + 25769803906u64 => "INVALID_KEY_LENGTH", + 25769803997u64 => "INVALID_LENGTH", + 25769803994u64 => "INVALID_NULL_ALGORITHM", + 25769803924u64 => "INVALID_OPERATION", + 25769803969u64 => "INVALID_PROVIDER_FUNCTIONS", + 25769803962u64 => "INVALID_SALT_LENGTH", + 25769803999u64 => "INVALID_SECRET_LENGTH", + 25769803996u64 => "INVALID_SEED_LENGTH", + 25769803998u64 => "INVALID_VALUE", + 25769803981u64 => "KEYMGMT_EXPORT_FAILURE", + 25769803956u64 => "KEY_SETUP_FAILED", + 25769803989u64 => "LOCKING_NOT_SUPPORTED", + 25769803948u64 => "MEMORY_LIMIT_EXCEEDED", + 25769803935u64 => "MESSAGE_DIGEST_IS_NULL", + 25769803920u64 => "METHOD_NOT_SUPPORTED", + 25769803879u64 => "MISSING_PARAMETERS", + 25769803966u64 => "NOT_ABLE_TO_COPY_CTX", + 25769803954u64 => "NOT_XOF_OR_INVALID_LENGTH", + 25769803907u64 => "NO_CIPHER_SET", + 25769803934u64 => "NO_DEFAULT_DIGEST", + 25769803915u64 => "NO_DIGEST_SET", + 25769803982u64 => "NO_IMPORT_FUNCTION", + 25769803975u64 => "NO_KEYMGMT_AVAILABLE", + 25769803972u64 => "NO_KEYMGMT_PRESENT", + 25769803930u64 => "NO_KEY_SET", + 25769803925u64 => "NO_OPERATION_SET", + 25769803984u64 => "NULL_MAC_PKEY_CTX", + 25769803953u64 => "ONLY_ONESHOT_SUPPORTED", + 25769803927u64 => "OPERATION_NOT_INITIALIZED", + 25769803926u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE", + 25769803978u64 => "OUTPUT_WOULD_OVERFLOW", + 25769803963u64 => "PARAMETER_TOO_LARGE", + 25769803938u64 => "PARTIALLY_OVERLAPPING", + 25769803957u64 => "PBKDF2_ERROR", + 25769803955u64 => "PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED", + 25769803921u64 => "PRIVATE_KEY_DECODE_ERROR", + 25769803922u64 => "PRIVATE_KEY_ENCODE_ERROR", + 25769803882u64 => "PUBLIC_KEY_NOT_RSA", + 25769804003u64 => "SETTING_XOF_FAILED", + 25769803985u64 => "SET_DEFAULT_PROPERTY_FAILURE", + 25769803959u64 => "TOO_MANY_RECORDS", + 25769803988u64 => "UNABLE_TO_ENABLE_LOCKING", + 25769803991u64 => "UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE", + 25769803992u64 => "UNABLE_TO_GET_RANDOM_STRENGTH", + 25769803987u64 => "UNABLE_TO_LOCK_CONTEXT", + 25769803993u64 => "UNABLE_TO_SET_CALLBACKS", + 25769803936u64 => "UNKNOWN_CIPHER", + 25769803937u64 => "UNKNOWN_DIGEST", + 25769803983u64 => "UNKNOWN_KEY_TYPE", + 25769803945u64 => "UNKNOWN_OPTION", + 25769803897u64 => "UNKNOWN_PBE_ALGORITHM", + 25769803932u64 => "UNSUPPORTED_ALGORITHM", + 25769803883u64 => "UNSUPPORTED_CIPHER", + 25769803899u64 => "UNSUPPORTED_KEYLENGTH", + 25769803900u64 => "UNSUPPORTED_KEY_DERIVATION_FUNCTION", + 25769803884u64 => "UNSUPPORTED_KEY_SIZE", + 25769804000u64 => "UNSUPPORTED_KEY_TYPE", + 25769803911u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS", + 25769803901u64 => "UNSUPPORTED_PRF", + 25769803894u64 => "UNSUPPORTED_PRIVATE_KEY_ALGORITHM", + 25769803902u64 => "UNSUPPORTED_SALT_TYPE", + 25769803965u64 => "UPDATE_ERROR", + 25769803946u64 => "WRAP_MODE_NOT_ALLOWED", + 25769803885u64 => "WRONG_FINAL_BLOCK_LENGTH", + 25769803967u64 => "XTS_DATA_UNIT_IS_TOO_LARGE", + 25769803968u64 => "XTS_DUPLICATED_KEYS", + 261993005164u64 => "ASN1_LEN_EXCEEDS_MAX_RESP_LEN", + 261993005156u64 => "CONNECT_FAILURE", + 261993005165u64 => "ERROR_PARSING_ASN1_LENGTH", + 261993005175u64 => "ERROR_PARSING_CONTENT_LENGTH", + 261993005157u64 => "ERROR_PARSING_URL", + 261993005159u64 => "ERROR_RECEIVING", + 261993005158u64 => "ERROR_SENDING", + 261993005184u64 => "FAILED_READING_DATA", + 261993005182u64 => "HEADER_PARSE_ERROR", + 261993005176u64 => "INCONSISTENT_CONTENT_LENGTH", + 261993005179u64 => "INVALID_PORT_NUMBER", + 261993005181u64 => "INVALID_URL_PATH", + 261993005180u64 => "INVALID_URL_SCHEME", + 261993005173u64 => "MAX_RESP_LEN_EXCEEDED", + 261993005166u64 => "MISSING_ASN1_ENCODING", + 261993005177u64 => "MISSING_CONTENT_TYPE", + 261993005167u64 => "MISSING_REDIRECT_LOCATION", + 261993005161u64 => "RECEIVED_ERROR", + 261993005162u64 => "RECEIVED_WRONG_HTTP_VERSION", + 261993005168u64 => "REDIRECTION_FROM_HTTPS_TO_HTTP", + 261993005172u64 => "REDIRECTION_NOT_ENABLED", + 261993005169u64 => "RESPONSE_LINE_TOO_LONG", + 261993005160u64 => "RESPONSE_PARSE_ERROR", + 261993005185u64 => "RETRY_TIMEOUT", + 261993005183u64 => "SERVER_CANCELED_CONNECTION", + 261993005178u64 => "SOCK_NOT_SUPPORTED", + 261993005170u64 => "STATUS_CODE_UNSUPPORTED", + 261993005163u64 => "TLS_NOT_ENABLED", + 261993005171u64 => "TOO_MANY_REDIRECTIONS", + 261993005174u64 => "UNEXPECTED_CONTENT_TYPE", + 34359738470u64 => "OID_EXISTS", + 34359738469u64 => "UNKNOWN_NID", + 34359738471u64 => "UNKNOWN_OBJECT_NAME", + 167503724645u64 => "CERTIFICATE_VERIFY_ERROR", + 167503724646u64 => "DIGEST_ERR", + 167503724650u64 => "DIGEST_NAME_ERR", + 167503724651u64 => "DIGEST_SIZE_ERR", + 167503724666u64 => "ERROR_IN_NEXTUPDATE_FIELD", + 167503724667u64 => "ERROR_IN_THISUPDATE_FIELD", + 167503724647u64 => "MISSING_OCSPSIGNING_USAGE", + 167503724668u64 => "NEXTUPDATE_BEFORE_THISUPDATE", + 167503724648u64 => "NOT_BASIC_RESPONSE", + 167503724649u64 => "NO_CERTIFICATES_IN_CHAIN", + 167503724652u64 => "NO_RESPONSE_DATA", + 167503724653u64 => "NO_REVOKED_TIME", + 167503724674u64 => "NO_SIGNER_KEY", + 167503724654u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 167503724672u64 => "REQUEST_NOT_SIGNED", + 167503724655u64 => "RESPONSE_CONTAINS_NO_REVOCATION_DATA", + 167503724656u64 => "ROOT_CA_NOT_TRUSTED", + 167503724661u64 => "SIGNATURE_FAILURE", + 167503724662u64 => "SIGNER_CERTIFICATE_NOT_FOUND", + 167503724669u64 => "STATUS_EXPIRED", + 167503724670u64 => "STATUS_NOT_YET_VALID", + 167503724671u64 => "STATUS_TOO_OLD", + 167503724663u64 => "UNKNOWN_MESSAGE_DIGEST", + 167503724664u64 => "UNKNOWN_NID", + 167503724673u64 => "UNSUPPORTED_REQUESTORNAME_TYPE", + 257698037861u64 => "COULD_NOT_DECODE_OBJECT", + 257698037862u64 => "DECODER_NOT_FOUND", + 257698037860u64 => "MISSING_GET_PARAMS", + 253403070565u64 => "ENCODER_NOT_FOUND", + 253403070564u64 => "INCORRECT_PROPERTY_QUERY", + 253403070566u64 => "MISSING_GET_PARAMS", + 188978561131u64 => "AMBIGUOUS_CONTENT_TYPE", + 188978561139u64 => "BAD_PASSWORD_READ", + 188978561137u64 => "ERROR_VERIFYING_PKCS12_MAC", + 188978561145u64 => "FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST", + 188978561130u64 => "INVALID_SCHEME", + 188978561136u64 => "IS_NOT_A", + 188978561140u64 => "LOADER_INCOMPLETE", + 188978561141u64 => "LOADING_STARTED", + 188978561124u64 => "NOT_A_CERTIFICATE", + 188978561125u64 => "NOT_A_CRL", + 188978561127u64 => "NOT_A_NAME", + 188978561126u64 => "NOT_A_PRIVATE_KEY", + 188978561146u64 => "NOT_A_PUBLIC_KEY", + 188978561128u64 => "NOT_PARAMETERS", + 188978561147u64 => "NO_LOADERS_FOUND", + 188978561138u64 => "PASSPHRASE_CALLBACK_ERROR", + 188978561132u64 => "PATH_MUST_BE_ABSOLUTE", + 188978561143u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES", + 188978561133u64 => "UI_PROCESS_INTERRUPTED_OR_CANCELLED", + 188978561129u64 => "UNREGISTERED_SCHEME", + 188978561134u64 => "UNSUPPORTED_CONTENT_TYPE", + 188978561142u64 => "UNSUPPORTED_OPERATION", + 188978561144u64 => "UNSUPPORTED_SEARCH_TYPE", + 188978561135u64 => "URI_AUTHORITY_UNSUPPORTED", + 38654705764u64 => "BAD_BASE64_DECODE", + 38654705765u64 => "BAD_DECRYPT", + 38654705766u64 => "BAD_END_LINE", + 38654705767u64 => "BAD_IV_CHARS", + 38654705780u64 => "BAD_MAGIC_NUMBER", + 38654705768u64 => "BAD_PASSWORD_READ", + 38654705781u64 => "BAD_VERSION_NUMBER", + 38654705782u64 => "BIO_WRITE_FAILURE", + 38654705791u64 => "CIPHER_IS_NULL", + 38654705779u64 => "ERROR_CONVERTING_PRIVATE_KEY", + 38654705795u64 => "EXPECTING_DSS_KEY_BLOB", + 38654705783u64 => "EXPECTING_PRIVATE_KEY_BLOB", + 38654705784u64 => "EXPECTING_PUBLIC_KEY_BLOB", + 38654705796u64 => "EXPECTING_RSA_KEY_BLOB", + 38654705792u64 => "HEADER_TOO_LONG", + 38654705785u64 => "INCONSISTENT_HEADER", + 38654705786u64 => "KEYBLOB_HEADER_PARSE_ERROR", + 38654705787u64 => "KEYBLOB_TOO_SHORT", + 38654705793u64 => "MISSING_DEK_IV", + 38654705769u64 => "NOT_DEK_INFO", + 38654705770u64 => "NOT_ENCRYPTED", + 38654705771u64 => "NOT_PROC_TYPE", + 38654705772u64 => "NO_START_LINE", + 38654705773u64 => "PROBLEMS_GETTING_PASSWORD", + 38654705788u64 => "PVK_DATA_TOO_SHORT", + 38654705789u64 => "PVK_TOO_SHORT", + 38654705775u64 => "READ_KEY", + 38654705776u64 => "SHORT_HEADER", + 38654705794u64 => "UNEXPECTED_DEK_IV", + 38654705777u64 => "UNSUPPORTED_CIPHER", + 38654705778u64 => "UNSUPPORTED_ENCRYPTION", + 38654705790u64 => "UNSUPPORTED_KEY_COMPONENTS", + 38654705774u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE", + 150323855460u64 => "CANT_PACK_STRUCTURE", + 150323855481u64 => "CONTENT_TYPE_NOT_DATA", + 150323855461u64 => "DECODE_ERROR", + 150323855462u64 => "ENCODE_ERROR", + 150323855463u64 => "ENCRYPT_ERROR", + 150323855480u64 => "ERROR_SETTING_ENCRYPTED_DATA_TYPE", + 150323855464u64 => "INVALID_NULL_ARGUMENT", + 150323855465u64 => "INVALID_NULL_PKCS12_POINTER", + 150323855472u64 => "INVALID_TYPE", + 150323855466u64 => "IV_GEN_ERROR", + 150323855467u64 => "KEY_GEN_ERROR", + 150323855468u64 => "MAC_ABSENT", + 150323855469u64 => "MAC_GENERATION_ERROR", + 150323855470u64 => "MAC_SETUP_ERROR", + 150323855471u64 => "MAC_STRING_SET_ERROR", + 150323855473u64 => "MAC_VERIFY_FAILURE", + 150323855474u64 => "PARSE_ERROR", + 150323855476u64 => "PKCS12_CIPHERFINAL_ERROR", + 150323855478u64 => "UNKNOWN_DIGEST_ALGORITHM", + 150323855479u64 => "UNSUPPORTED_PKCS12_MODE", + 141733920885u64 => "CERTIFICATE_VERIFY_ERROR", + 141733920912u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER", + 141733920884u64 => "CIPHER_NOT_INITIALIZED", + 141733920886u64 => "CONTENT_AND_DATA_PRESENT", + 141733920920u64 => "CTRL_ERROR", + 141733920887u64 => "DECRYPT_ERROR", + 141733920869u64 => "DIGEST_FAILURE", + 141733920917u64 => "ENCRYPTION_CTRL_FAILURE", + 141733920918u64 => "ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE", + 141733920888u64 => "ERROR_ADDING_RECIPIENT", + 141733920889u64 => "ERROR_SETTING_CIPHER", + 141733920911u64 => "INVALID_NULL_POINTER", + 141733920923u64 => "INVALID_SIGNED_DATA_TYPE", + 141733920890u64 => "NO_CONTENT", + 141733920919u64 => "NO_DEFAULT_DIGEST", + 141733920922u64 => "NO_MATCHING_DIGEST_TYPE_FOUND", + 141733920883u64 => "NO_RECIPIENT_MATCHES_CERTIFICATE", + 141733920891u64 => "NO_SIGNATURES_ON_DATA", + 141733920910u64 => "NO_SIGNERS", + 141733920872u64 => "OPERATION_NOT_SUPPORTED_ON_THIS_TYPE", + 141733920892u64 => "PKCS7_ADD_SIGNATURE_ERROR", + 141733920921u64 => "PKCS7_ADD_SIGNER_ERROR", + 141733920913u64 => "PKCS7_DATASIGN", + 141733920895u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 141733920873u64 => "SIGNATURE_FAILURE", + 141733920896u64 => "SIGNER_CERTIFICATE_NOT_FOUND", + 141733920915u64 => "SIGNING_CTRL_FAILURE", + 141733920916u64 => "SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE", + 141733920897u64 => "SMIME_TEXT_ERROR", + 141733920874u64 => "UNABLE_TO_FIND_CERTIFICATE", + 141733920875u64 => "UNABLE_TO_FIND_MEM_BIO", + 141733920876u64 => "UNABLE_TO_FIND_MESSAGE_DIGEST", + 141733920877u64 => "UNKNOWN_DIGEST_TYPE", + 141733920878u64 => "UNKNOWN_OPERATION", + 141733920879u64 => "UNSUPPORTED_CIPHER_TYPE", + 141733920880u64 => "UNSUPPORTED_CONTENT_TYPE", + 141733920881u64 => "WRONG_CONTENT_TYPE", + 141733920882u64 => "WRONG_PKCS7_TYPE", + 236223201380u64 => "NAME_TOO_LONG", + 236223201381u64 => "NOT_AN_ASCII_CHARACTER", + 236223201382u64 => "NOT_AN_HEXADECIMAL_DIGIT", + 236223201383u64 => "NOT_AN_IDENTIFIER", + 236223201384u64 => "NOT_AN_OCTAL_DIGIT", + 236223201385u64 => "NOT_A_DECIMAL_DIGIT", + 236223201386u64 => "NO_MATCHING_STRING_DELIMITER", + 236223201387u64 => "NO_VALUE", + 236223201388u64 => "PARSE_FAILED", + 236223201389u64 => "STRING_TOO_LONG", + 236223201390u64 => "TRAILING_CHARACTERS", + 244813136056u64 => "ADDITIONAL_INPUT_TOO_LONG", + 244813136045u64 => "ALGORITHM_MISMATCH", + 244813136057u64 => "ALREADY_INSTANTIATED", + 244813135972u64 => "BAD_DECRYPT", + 244813136013u64 => "BAD_ENCODING", + 244813136014u64 => "BAD_LENGTH", + 244813136033u64 => "BAD_TLS_CLIENT_VERSION", + 244813136032u64 => "BN_ERROR", + 244813135974u64 => "CIPHER_OPERATION_FAILED", + 244813136077u64 => "DERIVATION_FUNCTION_INIT_FAILED", + 244813136046u64 => "DIGEST_NOT_ALLOWED", + 244813136058u64 => "ENTROPY_SOURCE_STRENGTH_TOO_WEAK", + 244813136060u64 => "ERROR_INSTANTIATING_DRBG", + 244813136061u64 => "ERROR_RETRIEVING_ENTROPY", + 244813136062u64 => "ERROR_RETRIEVING_NONCE", + 244813136036u64 => "FAILED_DURING_DERIVATION", + 244813136052u64 => "FAILED_TO_CREATE_LOCK", + 244813136034u64 => "FAILED_TO_DECRYPT", + 244813135993u64 => "FAILED_TO_GENERATE_KEY", + 244813135975u64 => "FAILED_TO_GET_PARAMETER", + 244813135976u64 => "FAILED_TO_SET_PARAMETER", + 244813136047u64 => "FAILED_TO_SIGN", + 244813136099u64 => "FIPS_MODULE_CONDITIONAL_ERROR", + 244813136096u64 => "FIPS_MODULE_ENTERING_ERROR_STATE", + 244813136097u64 => "FIPS_MODULE_IN_ERROR_STATE", + 244813136063u64 => "GENERATE_ERROR", + 244813136037u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE", + 244813136082u64 => "INDICATOR_INTEGRITY_FAILURE", + 244813136053u64 => "INSUFFICIENT_DRBG_STRENGTH", + 244813135980u64 => "INVALID_AAD", + 244813136083u64 => "INVALID_CONFIG_DATA", + 244813136029u64 => "INVALID_CONSTANT_LENGTH", + 244813136048u64 => "INVALID_CURVE", + 244813135983u64 => "INVALID_CUSTOM_LENGTH", + 244813135987u64 => "INVALID_DATA", + 244813135994u64 => "INVALID_DIGEST", + 244813136038u64 => "INVALID_DIGEST_LENGTH", + 244813136090u64 => "INVALID_DIGEST_SIZE", + 244813136102u64 => "INVALID_INPUT_LENGTH", + 244813135995u64 => "INVALID_ITERATION_COUNT", + 244813135981u64 => "INVALID_IV_LENGTH", + 244813136030u64 => "INVALID_KEY", + 244813135977u64 => "INVALID_KEY_LENGTH", + 244813136023u64 => "INVALID_MAC", + 244813136039u64 => "INVALID_MGF1_MD", + 244813135997u64 => "INVALID_MODE", + 244813136089u64 => "INVALID_OUTPUT_LENGTH", + 244813136040u64 => "INVALID_PADDING_MODE", + 244813136070u64 => "INVALID_PUBINFO", + 244813135984u64 => "INVALID_SALT_LENGTH", + 244813136026u64 => "INVALID_SEED_LENGTH", + 244813136051u64 => "INVALID_SIGNATURE_SIZE", + 244813136084u64 => "INVALID_STATE", + 244813135982u64 => "INVALID_TAG", + 244813135990u64 => "INVALID_TAG_LENGTH", + 244813136072u64 => "INVALID_UKM_LENGTH", + 244813136042u64 => "INVALID_X931_DIGEST", + 244813136064u64 => "IN_ERROR_STATE", + 244813135973u64 => "KEY_SETUP_FAILED", + 244813136043u64 => "KEY_SIZE_TOO_SMALL", + 244813136074u64 => "LENGTH_TOO_LARGE", + 244813136075u64 => "MISMATCHING_DOMAIN_PARAMETERS", + 244813136016u64 => "MISSING_CEK_ALG", + 244813136027u64 => "MISSING_CIPHER", + 244813136085u64 => "MISSING_CONFIG_DATA", + 244813136028u64 => "MISSING_CONSTANT", + 244813136000u64 => "MISSING_KEY", + 244813136022u64 => "MISSING_MAC", + 244813136001u64 => "MISSING_MESSAGE_DIGEST", + 244813136081u64 => "MISSING_OID", + 244813136002u64 => "MISSING_PASS", + 244813136003u64 => "MISSING_SALT", + 244813136004u64 => "MISSING_SECRET", + 244813136012u64 => "MISSING_SEED", + 244813136005u64 => "MISSING_SESSION_ID", + 244813136006u64 => "MISSING_TYPE", + 244813136007u64 => "MISSING_XCGHASH", + 244813136086u64 => "MODULE_INTEGRITY_FAILURE", + 244813136093u64 => "NOT_A_PRIVATE_KEY", + 244813136092u64 => "NOT_A_PUBLIC_KEY", + 244813136065u64 => "NOT_INSTANTIATED", + 244813136098u64 => "NOT_PARAMETERS", + 244813136008u64 => "NOT_SUPPORTED", + 244813135985u64 => "NOT_XOF_OR_INVALID_LENGTH", + 244813135986u64 => "NO_KEY_SET", + 244813136049u64 => "NO_PARAMETERS_SET", + 244813136050u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE", + 244813135978u64 => "OUTPUT_BUFFER_TOO_SMALL", + 244813136100u64 => "PARENT_CANNOT_GENERATE_RANDOM_NUMBERS", + 244813136059u64 => "PARENT_CANNOT_SUPPLY_ENTROPY_SEED", + 244813136054u64 => "PARENT_LOCKING_NOT_ENABLED", + 244813136066u64 => "PARENT_STRENGTH_TOO_WEAK", + 244813136091u64 => "PATH_MUST_BE_ABSOLUTE", + 244813136067u64 => "PERSONALISATION_STRING_TOO_LONG", + 244813136044u64 => "PSS_SALTLEN_TOO_SMALL", + 244813136068u64 => "REQUEST_TOO_LARGE_FOR_DRBG", + 244813136078u64 => "REQUIRE_CTR_MODE_CIPHER", + 244813136069u64 => "RESEED_ERROR", + 244813136094u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES", + 244813136101u64 => "SEED_SOURCES_MUST_NOT_HAVE_A_PARENT", + 244813136087u64 => "SELF_TEST_KAT_FAILURE", + 244813136088u64 => "SELF_TEST_POST_FAILURE", + 244813135992u64 => "TAG_NOT_NEEDED", + 244813135991u64 => "TAG_NOT_SET", + 244813135998u64 => "TOO_MANY_RECORDS", + 244813136079u64 => "UNABLE_TO_FIND_CIPHERS", + 244813136071u64 => "UNABLE_TO_GET_PARENT_STRENGTH", + 244813136031u64 => "UNABLE_TO_GET_PASSPHRASE", + 244813136080u64 => "UNABLE_TO_INITIALISE_CIPHERS", + 244813136019u64 => "UNABLE_TO_LOAD_SHA256", + 244813136073u64 => "UNABLE_TO_LOCK_PARENT", + 244813136076u64 => "UNABLE_TO_RESEED", + 244813136017u64 => "UNSUPPORTED_CEK_ALG", + 244813136025u64 => "UNSUPPORTED_KEY_SIZE", + 244813136009u64 => "UNSUPPORTED_MAC_TYPE", + 244813136024u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS", + 244813136095u64 => "URI_AUTHORITY_UNSUPPORTED", + 244813136010u64 => "VALUE_ERROR", + 244813135979u64 => "WRONG_FINAL_BLOCK_LENGTH", + 244813136011u64 => "WRONG_OUTPUT_BUFFER_SIZE", + 244813136055u64 => "XOF_DIGESTS_NOT_ALLOWED", + 244813136020u64 => "XTS_DATA_UNIT_IS_TOO_LARGE", + 244813136021u64 => "XTS_DUPLICATED_KEYS", + 154618822758u64 => "ADDITIONAL_INPUT_TOO_LONG", + 154618822759u64 => "ALREADY_INSTANTIATED", + 154618822761u64 => "ARGUMENT_OUT_OF_RANGE", + 154618822777u64 => "CANNOT_OPEN_FILE", + 154618822785u64 => "DRBG_ALREADY_INITIALIZED", + 154618822760u64 => "DRBG_NOT_INITIALISED", + 154618822762u64 => "ENTROPY_INPUT_TOO_LONG", + 154618822780u64 => "ENTROPY_OUT_OF_RANGE", + 154618822783u64 => "ERROR_ENTROPY_POOL_WAS_IGNORED", + 154618822763u64 => "ERROR_INITIALISING_DRBG", + 154618822764u64 => "ERROR_INSTANTIATING_DRBG", + 154618822765u64 => "ERROR_RETRIEVING_ADDITIONAL_INPUT", + 154618822766u64 => "ERROR_RETRIEVING_ENTROPY", + 154618822767u64 => "ERROR_RETRIEVING_NONCE", + 154618822782u64 => "FAILED_TO_CREATE_LOCK", + 154618822757u64 => "FUNC_NOT_IMPLEMENTED", + 154618822779u64 => "FWRITE_ERROR", + 154618822768u64 => "GENERATE_ERROR", + 154618822795u64 => "INSUFFICIENT_DRBG_STRENGTH", + 154618822769u64 => "INTERNAL_ERROR", + 154618822770u64 => "IN_ERROR_STATE", + 154618822778u64 => "NOT_A_REGULAR_FILE", + 154618822771u64 => "NOT_INSTANTIATED", + 154618822784u64 => "NO_DRBG_IMPLEMENTATION_SELECTED", + 154618822786u64 => "PARENT_LOCKING_NOT_ENABLED", + 154618822787u64 => "PARENT_STRENGTH_TOO_WEAK", + 154618822772u64 => "PERSONALISATION_STRING_TOO_LONG", + 154618822789u64 => "PREDICTION_RESISTANCE_NOT_SUPPORTED", + 154618822756u64 => "PRNG_NOT_SEEDED", + 154618822781u64 => "RANDOM_POOL_OVERFLOW", + 154618822790u64 => "RANDOM_POOL_UNDERFLOW", + 154618822773u64 => "REQUEST_TOO_LARGE_FOR_DRBG", + 154618822774u64 => "RESEED_ERROR", + 154618822775u64 => "SELFTEST_FAILURE", + 154618822791u64 => "TOO_LITTLE_NONCE_REQUESTED", + 154618822792u64 => "TOO_MUCH_NONCE_REQUESTED", + 154618822799u64 => "UNABLE_TO_CREATE_DRBG", + 154618822800u64 => "UNABLE_TO_FETCH_DRBG", + 154618822797u64 => "UNABLE_TO_GET_PARENT_RESEED_PROP_COUNTER", + 154618822794u64 => "UNABLE_TO_GET_PARENT_STRENGTH", + 154618822796u64 => "UNABLE_TO_LOCK_PARENT", + 154618822788u64 => "UNSUPPORTED_DRBG_FLAGS", + 154618822776u64 => "UNSUPPORTED_DRBG_TYPE", + 17179869284u64 => "ALGORITHM_MISMATCH", + 17179869285u64 => "BAD_E_VALUE", + 17179869286u64 => "BAD_FIXED_HEADER_DECRYPT", + 17179869287u64 => "BAD_PAD_BYTE_COUNT", + 17179869288u64 => "BAD_SIGNATURE", + 17179869290u64 => "BLOCK_TYPE_IS_NOT_01", + 17179869291u64 => "BLOCK_TYPE_IS_NOT_02", + 17179869292u64 => "DATA_GREATER_THAN_MOD_LEN", + 17179869293u64 => "DATA_TOO_LARGE", + 17179869294u64 => "DATA_TOO_LARGE_FOR_KEY_SIZE", + 17179869316u64 => "DATA_TOO_LARGE_FOR_MODULUS", + 17179869295u64 => "DATA_TOO_SMALL", + 17179869306u64 => "DATA_TOO_SMALL_FOR_KEY_SIZE", + 17179869342u64 => "DIGEST_DOES_NOT_MATCH", + 17179869329u64 => "DIGEST_NOT_ALLOWED", + 17179869296u64 => "DIGEST_TOO_BIG_FOR_RSA_KEY", + 17179869308u64 => "DMP1_NOT_CONGRUENT_TO_D", + 17179869309u64 => "DMQ1_NOT_CONGRUENT_TO_D", + 17179869307u64 => "D_E_NOT_CONGRUENT_TO_1", + 17179869317u64 => "FIRST_OCTET_INVALID", + 17179869328u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE", + 17179869341u64 => "INVALID_DIGEST", + 17179869327u64 => "INVALID_DIGEST_LENGTH", + 17179869321u64 => "INVALID_HEADER", + 17179869355u64 => "INVALID_KEYPAIR", + 17179869357u64 => "INVALID_KEY_LENGTH", + 17179869344u64 => "INVALID_LABEL", + 17179869365u64 => "INVALID_LENGTH", + 17179869315u64 => "INVALID_MESSAGE_LENGTH", + 17179869340u64 => "INVALID_MGF1_MD", + 17179869358u64 => "INVALID_MODULUS", + 17179869351u64 => "INVALID_MULTI_PRIME_KEY", + 17179869345u64 => "INVALID_OAEP_PARAMETERS", + 17179869322u64 => "INVALID_PADDING", + 17179869325u64 => "INVALID_PADDING_MODE", + 17179869333u64 => "INVALID_PSS_PARAMETERS", + 17179869330u64 => "INVALID_PSS_SALTLEN", + 17179869359u64 => "INVALID_REQUEST", + 17179869334u64 => "INVALID_SALT_LENGTH", + 17179869360u64 => "INVALID_STRENGTH", + 17179869323u64 => "INVALID_TRAILER", + 17179869326u64 => "INVALID_X931_DIGEST", + 17179869310u64 => "IQMP_NOT_INVERSE_OF_Q", + 17179869349u64 => "KEY_PRIME_NUM_INVALID", + 17179869304u64 => "KEY_SIZE_TOO_SMALL", + 17179869318u64 => "LAST_OCTET_INVALID", + 17179869336u64 => "MGF1_DIGEST_NOT_ALLOWED", + 17179869363u64 => "MISSING_PRIVATE_KEY", + 17179869289u64 => "MODULUS_TOO_LARGE", + 17179869352u64 => "MP_COEFFICIENT_NOT_INVERSE_OF_R", + 17179869353u64 => "MP_EXPONENT_NOT_CONGRUENT_TO_D", + 17179869354u64 => "MP_R_NOT_PRIME", + 17179869324u64 => "NO_PUBLIC_EXPONENT", + 17179869297u64 => "NULL_BEFORE_BLOCK_MISSING", + 17179869356u64 => "N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES", + 17179869311u64 => "N_DOES_NOT_EQUAL_P_Q", + 17179869305u64 => "OAEP_DECODING_ERROR", + 17179869332u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE", + 17179869298u64 => "PADDING_CHECK_FAILED", + 17179869361u64 => "PAIRWISE_TEST_FAILURE", + 17179869343u64 => "PKCS_DECODING_ERROR", + 17179869348u64 => "PSS_SALTLEN_TOO_SMALL", + 17179869362u64 => "PUB_EXPONENT_OUT_OF_RANGE", + 17179869312u64 => "P_NOT_PRIME", + 17179869313u64 => "Q_NOT_PRIME", + 17179869364u64 => "RANDOMNESS_SOURCE_STRENGTH_INSUFFICIENT", + 17179869314u64 => "RSA_OPERATIONS_NOT_SUPPORTED", + 17179869320u64 => "SLEN_CHECK_FAILED", + 17179869319u64 => "SLEN_RECOVERY_FAILED", + 17179869299u64 => "SSLV3_ROLLBACK_ATTACK", + 17179869300u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD", + 17179869301u64 => "UNKNOWN_ALGORITHM_TYPE", + 17179869350u64 => "UNKNOWN_DIGEST", + 17179869335u64 => "UNKNOWN_MASK_DIGEST", + 17179869302u64 => "UNKNOWN_PADDING_TYPE", + 17179869346u64 => "UNSUPPORTED_ENCRYPTION_TYPE", + 17179869347u64 => "UNSUPPORTED_LABEL_SOURCE", + 17179869337u64 => "UNSUPPORTED_MASK_ALGORITHM", + 17179869338u64 => "UNSUPPORTED_MASK_PARAMETER", + 17179869339u64 => "UNSUPPORTED_SIGNATURE_TYPE", + 17179869331u64 => "VALUE_MISSING", + 17179869303u64 => "WRONG_SIGNATURE_LENGTH", + 227633266788u64 => "ASN1_ERROR", + 227633266789u64 => "BAD_SIGNATURE", + 227633266795u64 => "BUFFER_TOO_SMALL", + 227633266798u64 => "DIST_ID_TOO_LARGE", + 227633266800u64 => "ID_NOT_SET", + 227633266799u64 => "ID_TOO_LARGE", + 227633266796u64 => "INVALID_CURVE", + 227633266790u64 => "INVALID_DIGEST", + 227633266791u64 => "INVALID_DIGEST_TYPE", + 227633266792u64 => "INVALID_ENCODING", + 227633266793u64 => "INVALID_FIELD", + 227633266801u64 => "INVALID_PRIVATE_KEY", + 227633266797u64 => "NO_PARAMETERS_SET", + 227633266794u64 => "USER_ID_TOO_LARGE", + 85899346211u64 => "APPLICATION_DATA_AFTER_CLOSE_NOTIFY", + 85899346020u64 => "APP_DATA_IN_HANDSHAKE", + 85899346192u64 => "ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT", + 85899346078u64 => "AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE", + 85899346023u64 => "BAD_CHANGE_CIPHER_SPEC", + 85899346106u64 => "BAD_CIPHER", + 85899346310u64 => "BAD_DATA", + 85899346026u64 => "BAD_DATA_RETURNED_BY_CALLBACK", + 85899346027u64 => "BAD_DECOMPRESSION", + 85899346022u64 => "BAD_DH_VALUE", + 85899346031u64 => "BAD_DIGEST_LENGTH", + 85899346153u64 => "BAD_EARLY_DATA", + 85899346224u64 => "BAD_ECC_CERT", + 85899346226u64 => "BAD_ECPOINT", + 85899346030u64 => "BAD_EXTENSION", + 85899346252u64 => "BAD_HANDSHAKE_LENGTH", + 85899346156u64 => "BAD_HANDSHAKE_STATE", + 85899346025u64 => "BAD_HELLO_REQUEST", + 85899346183u64 => "BAD_HRR_VERSION", + 85899346028u64 => "BAD_KEY_SHARE", + 85899346042u64 => "BAD_KEY_UPDATE", + 85899346212u64 => "BAD_LEGACY_VERSION", + 85899346191u64 => "BAD_LENGTH", + 85899346160u64 => "BAD_PACKET", + 85899346035u64 => "BAD_PACKET_LENGTH", + 85899346036u64 => "BAD_PROTOCOL_VERSION_NUMBER", + 85899346139u64 => "BAD_PSK", + 85899346034u64 => "BAD_PSK_IDENTITY", + 85899346363u64 => "BAD_RECORD_TYPE", + 85899346039u64 => "BAD_RSA_ENCRYPT", + 85899346043u64 => "BAD_SIGNATURE", + 85899346267u64 => "BAD_SRP_A_LENGTH", + 85899346291u64 => "BAD_SRP_PARAMETERS", + 85899346272u64 => "BAD_SRTP_MKI_VALUE", + 85899346273u64 => "BAD_SRTP_PROTECTION_PROFILE_LIST", + 85899346044u64 => "BAD_SSL_FILETYPE", + 85899346304u64 => "BAD_VALUE", + 85899346047u64 => "BAD_WRITE_RETRY", + 85899346173u64 => "BINDER_DOES_NOT_VERIFY", + 85899346048u64 => "BIO_NOT_SET", + 85899346049u64 => "BLOCK_CIPHER_PAD_IS_WRONG", + 85899346050u64 => "BN_LIB", + 85899346154u64 => "CALLBACK_FAILED", + 85899346029u64 => "CANNOT_CHANGE_CIPHER", + 85899346219u64 => "CANNOT_GET_GROUP_NAME", + 85899346051u64 => "CA_DN_LENGTH_MISMATCH", + 85899346317u64 => "CA_KEY_TOO_SMALL", + 85899346318u64 => "CA_MD_TOO_WEAK", + 85899346053u64 => "CCS_RECEIVED_EARLY", + 85899346054u64 => "CERTIFICATE_VERIFY_FAILED", + 85899346297u64 => "CERT_CB_ERROR", + 85899346055u64 => "CERT_LENGTH_MISMATCH", + 85899346138u64 => "CIPHERSUITE_DIGEST_HAS_CHANGED", + 85899346057u64 => "CIPHER_CODE_WRONG_LENGTH", + 85899346146u64 => "CLIENTHELLO_TLSEXT", + 85899346060u64 => "COMPRESSED_LENGTH_TOO_LONG", + 85899346263u64 => "COMPRESSION_DISABLED", + 85899346061u64 => "COMPRESSION_FAILURE", + 85899346227u64 => "COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE", + 85899346062u64 => "COMPRESSION_LIBRARY_ERROR", + 85899346064u64 => "CONNECTION_TYPE_NOT_SET", + 85899346087u64 => "CONTEXT_NOT_DANE_ENABLED", + 85899346320u64 => "COOKIE_GEN_CALLBACK_FAILURE", + 85899346228u64 => "COOKIE_MISMATCH", + 85899346216u64 => "COPY_PARAMETERS_FAILED", + 85899346126u64 => "CUSTOM_EXT_HANDLER_ALREADY_INSTALLED", + 85899346092u64 => "DANE_ALREADY_ENABLED", + 85899346093u64 => "DANE_CANNOT_OVERRIDE_MTYPE_FULL", + 85899346095u64 => "DANE_NOT_ENABLED", + 85899346100u64 => "DANE_TLSA_BAD_CERTIFICATE", + 85899346104u64 => "DANE_TLSA_BAD_CERTIFICATE_USAGE", + 85899346109u64 => "DANE_TLSA_BAD_DATA_LENGTH", + 85899346112u64 => "DANE_TLSA_BAD_DIGEST_LENGTH", + 85899346120u64 => "DANE_TLSA_BAD_MATCHING_TYPE", + 85899346121u64 => "DANE_TLSA_BAD_PUBLIC_KEY", + 85899346122u64 => "DANE_TLSA_BAD_SELECTOR", + 85899346123u64 => "DANE_TLSA_NULL_DATA", + 85899346065u64 => "DATA_BETWEEN_CCS_AND_FINISHED", + 85899346066u64 => "DATA_LENGTH_TOO_LONG", + 85899346067u64 => "DECRYPTION_FAILED", + 85899346201u64 => "DECRYPTION_FAILED_OR_BAD_RECORD_MAC", + 85899346314u64 => "DH_KEY_TOO_SMALL", + 85899346068u64 => "DH_PUBLIC_VALUE_LENGTH_IS_WRONG", + 85899346069u64 => "DIGEST_CHECK_FAILED", + 85899346254u64 => "DTLS_MESSAGE_TOO_BIG", + 85899346229u64 => "DUPLICATE_COMPRESSION_ID", + 85899346238u64 => "ECC_CERT_NOT_FOR_SIGNING", + 85899346294u64 => "ECDH_REQUIRED_FOR_SUITEB_MODE", + 85899346319u64 => "EE_KEY_TOO_SMALL", + 85899346274u64 => "EMPTY_SRTP_PROTECTION_PROFILE_LIST", + 85899346070u64 => "ENCRYPTED_LENGTH_TOO_LONG", + 85899346071u64 => "ERROR_IN_RECEIVED_CIPHER_LIST", + 85899346124u64 => "ERROR_SETTING_TLSA_BASE_DOMAIN", + 85899346114u64 => "EXCEEDS_MAX_FRAGMENT_SIZE", + 85899346072u64 => "EXCESSIVE_MESSAGE_SIZE", + 85899346199u64 => "EXTENSION_NOT_RECEIVED", + 85899346073u64 => "EXTRA_DATA_IN_MESSAGE", + 85899346083u64 => "EXT_LENGTH_MISMATCH", + 85899346325u64 => "FAILED_TO_INIT_ASYNC", + 85899346321u64 => "FRAGMENTED_CLIENT_HELLO", + 85899346074u64 => "GOT_A_FIN_BEFORE_A_CCS", + 85899346075u64 => "HTTPS_PROXY_REQUEST", + 85899346076u64 => "HTTP_REQUEST", + 85899346082u64 => "ILLEGAL_POINT_COMPRESSION", + 85899346300u64 => "ILLEGAL_SUITEB_DIGEST", + 85899346293u64 => "INAPPROPRIATE_FALLBACK", + 85899346260u64 => "INCONSISTENT_COMPRESSION", + 85899346142u64 => "INCONSISTENT_EARLY_DATA_ALPN", + 85899346151u64 => "INCONSISTENT_EARLY_DATA_SNI", + 85899346024u64 => "INCONSISTENT_EXTMS", + 85899346161u64 => "INSUFFICIENT_SECURITY", + 85899346125u64 => "INVALID_ALERT", + 85899346180u64 => "INVALID_CCS_MESSAGE", + 85899346158u64 => "INVALID_CERTIFICATE_OR_ALG", + 85899346200u64 => "INVALID_COMMAND", + 85899346261u64 => "INVALID_COMPRESSION_ALGORITHM", + 85899346203u64 => "INVALID_CONFIG", + 85899346033u64 => "INVALID_CONFIGURATION_NAME", + 85899346202u64 => "INVALID_CONTEXT", + 85899346132u64 => "INVALID_CT_VALIDATION_TYPE", + 85899346040u64 => "INVALID_KEY_UPDATE_TYPE", + 85899346094u64 => "INVALID_MAX_EARLY_DATA", + 85899346305u64 => "INVALID_NULL_CMD_NAME", + 85899346322u64 => "INVALID_SEQUENCE_NUMBER", + 85899346308u64 => "INVALID_SERVERINFO_DATA", + 85899346919u64 => "INVALID_SESSION_ID", + 85899346277u64 => "INVALID_SRP_USERNAME", + 85899346248u64 => "INVALID_STATUS_RESPONSE", + 85899346245u64 => "INVALID_TICKET_KEYS_LENGTH", + 85899346253u64 => "LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED", + 85899346079u64 => "LENGTH_MISMATCH", + 85899346324u64 => "LENGTH_TOO_LONG", + 85899346080u64 => "LENGTH_TOO_SHORT", + 85899346194u64 => "LIBRARY_BUG", + 85899346081u64 => "LIBRARY_HAS_NO_CIPHERS", + 85899346085u64 => "MISSING_DSA_SIGNING_CERT", + 85899346301u64 => "MISSING_ECDSA_SIGNING_CERT", + 85899346176u64 => "MISSING_FATAL", + 85899346210u64 => "MISSING_PARAMETERS", + 85899346230u64 => "MISSING_PSK_KEX_MODES_EXTENSION", + 85899346088u64 => "MISSING_RSA_CERTIFICATE", + 85899346089u64 => "MISSING_RSA_ENCRYPTING_CERT", + 85899346090u64 => "MISSING_RSA_SIGNING_CERT", + 85899346032u64 => "MISSING_SIGALGS_EXTENSION", + 85899346141u64 => "MISSING_SIGNING_CERT", + 85899346278u64 => "MISSING_SRP_PARAM", + 85899346129u64 => "MISSING_SUPPORTED_GROUPS_EXTENSION", + 85899346091u64 => "MISSING_TMP_DH_KEY", + 85899346231u64 => "MISSING_TMP_ECDH_KEY", + 85899346213u64 => "MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA", + 85899346102u64 => "NOT_ON_RECORD_BOUNDARY", + 85899346209u64 => "NOT_REPLACING_CERTIFICATE", + 85899346204u64 => "NOT_SERVER", + 85899346155u64 => "NO_APPLICATION_PROTOCOL", + 85899346096u64 => "NO_CERTIFICATES_RETURNED", + 85899346097u64 => "NO_CERTIFICATE_ASSIGNED", + 85899346099u64 => "NO_CERTIFICATE_SET", + 85899346134u64 => "NO_CHANGE_FOLLOWING_HRR", + 85899346101u64 => "NO_CIPHERS_AVAILABLE", + 85899346103u64 => "NO_CIPHERS_SPECIFIED", + 85899346105u64 => "NO_CIPHER_MATCH", + 85899346251u64 => "NO_CLIENT_CERT_METHOD", + 85899346107u64 => "NO_COMPRESSION_SPECIFIED", + 85899346207u64 => "NO_COOKIE_CALLBACK_SET", + 85899346250u64 => "NO_GOST_CERTIFICATE_SENT_BY_PEER", + 85899346108u64 => "NO_METHOD_SPECIFIED", + 85899346309u64 => "NO_PEM_EXTENSIONS", + 85899346110u64 => "NO_PRIVATE_KEY_ASSIGNED", + 85899346111u64 => "NO_PROTOCOLS_AVAILABLE", + 85899346259u64 => "NO_RENEGOTIATION", + 85899346244u64 => "NO_REQUIRED_DIGEST", + 85899346113u64 => "NO_SHARED_CIPHER", + 85899346330u64 => "NO_SHARED_GROUPS", + 85899346296u64 => "NO_SHARED_SIGNATURE_ALGORITHMS", + 85899346279u64 => "NO_SRTP_PROFILES", + 85899346217u64 => "NO_SUITABLE_DIGEST_ALGORITHM", + 85899346215u64 => "NO_SUITABLE_GROUPS", + 85899346021u64 => "NO_SUITABLE_KEY_SHARE", + 85899346038u64 => "NO_SUITABLE_SIGNATURE_ALGORITHM", + 85899346136u64 => "NO_VALID_SCTS", + 85899346323u64 => "NO_VERIFY_COOKIE_CALLBACK", + 85899346115u64 => "NULL_SSL_CTX", + 85899346116u64 => "NULL_SSL_METHOD_PASSED", + 85899346225u64 => "OCSP_CALLBACK_FAILURE", + 85899346117u64 => "OLD_SESSION_CIPHER_NOT_RETURNED", + 85899346264u64 => "OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED", + 85899346157u64 => "OVERFLOW_ERROR", + 85899346118u64 => "PACKET_LENGTH_TOO_LONG", + 85899346147u64 => "PARSE_TLSEXT", + 85899346190u64 => "PATH_TOO_LONG", + 85899346119u64 => "PEER_DID_NOT_RETURN_A_CERTIFICATE", + 85899346311u64 => "PEM_NAME_BAD_PREFIX", + 85899346312u64 => "PEM_NAME_TOO_SHORT", + 85899346326u64 => "PIPELINE_FAILURE", + 85899346198u64 => "POST_HANDSHAKE_AUTH_ENCODING_ERR", + 85899346208u64 => "PRIVATE_KEY_MISMATCH", + 85899346127u64 => "PROTOCOL_IS_SHUTDOWN", + 85899346143u64 => "PSK_IDENTITY_NOT_FOUND", + 85899346144u64 => "PSK_NO_CLIENT_CB", + 85899346145u64 => "PSK_NO_SERVER_CB", + 85899346131u64 => "READ_BIO_NOT_SET", + 85899346232u64 => "READ_TIMEOUT_EXPIRED", + 85899346133u64 => "RECORD_LENGTH_MISMATCH", + 85899346218u64 => "RECORD_TOO_SMALL", + 85899346255u64 => "RENEGOTIATE_EXT_TOO_LONG", + 85899346256u64 => "RENEGOTIATION_ENCODING_ERR", + 85899346257u64 => "RENEGOTIATION_MISMATCH", + 85899346205u64 => "REQUEST_PENDING", + 85899346206u64 => "REQUEST_SENT", + 85899346135u64 => "REQUIRED_CIPHER_MISSING", + 85899346262u64 => "REQUIRED_COMPRESSION_ALGORITHM_MISSING", + 85899346265u64 => "SCSV_RECEIVED_WHEN_RENEGOTIATING", + 85899346128u64 => "SCT_VERIFICATION_FAILED", + 85899346195u64 => "SERVERHELLO_TLSEXT", + 85899346197u64 => "SESSION_ID_CONTEXT_UNINITIALIZED", + 85899346327u64 => "SHUTDOWN_WHILE_IN_INIT", + 85899346280u64 => "SIGNATURE_ALGORITHMS_ERROR", + 85899346140u64 => "SIGNATURE_FOR_NON_SIGNING_CERTIFICATE", + 85899346281u64 => "SRP_A_CALC", + 85899346282u64 => "SRTP_COULD_NOT_ALLOCATE_PROFILES", + 85899346283u64 => "SRTP_PROTECTION_PROFILE_LIST_TOO_LONG", + 85899346284u64 => "SRTP_UNKNOWN_PROTECTION_PROFILE", + 85899346152u64 => "SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH", + 85899346239u64 => "SSL3_EXT_INVALID_SERVERNAME", + 85899346240u64 => "SSL3_EXT_INVALID_SERVERNAME_TYPE", + 85899346220u64 => "SSL3_SESSION_ID_TOO_LONG", + 85899346962u64 => "SSLV3_ALERT_BAD_CERTIFICATE", + 85899346940u64 => "SSLV3_ALERT_BAD_RECORD_MAC", + 85899346965u64 => "SSLV3_ALERT_CERTIFICATE_EXPIRED", + 85899346964u64 => "SSLV3_ALERT_CERTIFICATE_REVOKED", + 85899346966u64 => "SSLV3_ALERT_CERTIFICATE_UNKNOWN", + 85899346950u64 => "SSLV3_ALERT_DECOMPRESSION_FAILURE", + 85899346960u64 => "SSLV3_ALERT_HANDSHAKE_FAILURE", + 85899346967u64 => "SSLV3_ALERT_ILLEGAL_PARAMETER", + 85899346961u64 => "SSLV3_ALERT_NO_CERTIFICATE", + 85899346930u64 => "SSLV3_ALERT_UNEXPECTED_MESSAGE", + 85899346963u64 => "SSLV3_ALERT_UNSUPPORTED_CERTIFICATE", + 85899346037u64 => "SSL_COMMAND_SECTION_EMPTY", + 85899346045u64 => "SSL_COMMAND_SECTION_NOT_FOUND", + 85899346148u64 => "SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION", + 85899346149u64 => "SSL_HANDSHAKE_FAILURE", + 85899346150u64 => "SSL_LIBRARY_HAS_NO_CIPHERS", + 85899346292u64 => "SSL_NEGATIVE_LENGTH", + 85899346046u64 => "SSL_SECTION_EMPTY", + 85899346056u64 => "SSL_SECTION_NOT_FOUND", + 85899346221u64 => "SSL_SESSION_ID_CALLBACK_FAILED", + 85899346222u64 => "SSL_SESSION_ID_CONFLICT", + 85899346193u64 => "SSL_SESSION_ID_CONTEXT_TOO_LONG", + 85899346223u64 => "SSL_SESSION_ID_HAS_BAD_LENGTH", + 85899346328u64 => "SSL_SESSION_ID_TOO_LONG", + 85899346130u64 => "SSL_SESSION_VERSION_MISMATCH", + 85899346041u64 => "STILL_IN_INIT", + 85899347036u64 => "TLSV13_ALERT_CERTIFICATE_REQUIRED", + 85899347029u64 => "TLSV13_ALERT_MISSING_EXTENSION", + 85899346969u64 => "TLSV1_ALERT_ACCESS_DENIED", + 85899346970u64 => "TLSV1_ALERT_DECODE_ERROR", + 85899346941u64 => "TLSV1_ALERT_DECRYPTION_FAILED", + 85899346971u64 => "TLSV1_ALERT_DECRYPT_ERROR", + 85899346980u64 => "TLSV1_ALERT_EXPORT_RESTRICTION", + 85899347006u64 => "TLSV1_ALERT_INAPPROPRIATE_FALLBACK", + 85899346991u64 => "TLSV1_ALERT_INSUFFICIENT_SECURITY", + 85899347000u64 => "TLSV1_ALERT_INTERNAL_ERROR", + 85899347040u64 => "TLSV1_ALERT_NO_APPLICATION_PROTOCOL", + 85899347020u64 => "TLSV1_ALERT_NO_RENEGOTIATION", + 85899346990u64 => "TLSV1_ALERT_PROTOCOL_VERSION", + 85899346942u64 => "TLSV1_ALERT_RECORD_OVERFLOW", + 85899346968u64 => "TLSV1_ALERT_UNKNOWN_CA", + 85899347035u64 => "TLSV1_ALERT_UNKNOWN_PSK_IDENTITY", + 85899347010u64 => "TLSV1_ALERT_USER_CANCELLED", + 85899347034u64 => "TLSV1_BAD_CERTIFICATE_HASH_VALUE", + 85899347033u64 => "TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE", + 85899347031u64 => "TLSV1_CERTIFICATE_UNOBTAINABLE", + 85899347032u64 => "TLSV1_UNRECOGNIZED_NAME", + 85899347030u64 => "TLSV1_UNSUPPORTED_EXTENSION", + 85899346287u64 => "TLS_ILLEGAL_EXPORTER_LABEL", + 85899346077u64 => "TLS_INVALID_ECPOINTFORMAT_LIST", + 85899346052u64 => "TOO_MANY_KEY_UPDATES", + 85899346329u64 => "TOO_MANY_WARN_ALERTS", + 85899346084u64 => "TOO_MUCH_EARLY_DATA", + 85899346234u64 => "UNABLE_TO_FIND_ECDH_PARAMETERS", + 85899346159u64 => "UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS", + 85899346162u64 => "UNABLE_TO_LOAD_SSL3_MD5_ROUTINES", + 85899346163u64 => "UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES", + 85899346182u64 => "UNEXPECTED_CCS_MESSAGE", + 85899346098u64 => "UNEXPECTED_END_OF_EARLY_DATA", + 85899346214u64 => "UNEXPECTED_EOF_WHILE_READING", + 85899346164u64 => "UNEXPECTED_MESSAGE", + 85899346165u64 => "UNEXPECTED_RECORD", + 85899346196u64 => "UNINITIALIZED", + 85899346166u64 => "UNKNOWN_ALERT_TYPE", + 85899346167u64 => "UNKNOWN_CERTIFICATE_TYPE", + 85899346168u64 => "UNKNOWN_CIPHER_RETURNED", + 85899346169u64 => "UNKNOWN_CIPHER_TYPE", + 85899346306u64 => "UNKNOWN_CMD_NAME", + 85899346059u64 => "UNKNOWN_COMMAND", + 85899346288u64 => "UNKNOWN_DIGEST", + 85899346170u64 => "UNKNOWN_KEY_EXCHANGE_TYPE", + 85899346171u64 => "UNKNOWN_PKEY_TYPE", + 85899346172u64 => "UNKNOWN_PROTOCOL", + 85899346174u64 => "UNKNOWN_SSL_VERSION", + 85899346175u64 => "UNKNOWN_STATE", + 85899346258u64 => "UNSAFE_LEGACY_RENEGOTIATION_DISABLED", + 85899346137u64 => "UNSOLICITED_EXTENSION", + 85899346177u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM", + 85899346235u64 => "UNSUPPORTED_ELLIPTIC_CURVE", + 85899346178u64 => "UNSUPPORTED_PROTOCOL", + 85899346179u64 => "UNSUPPORTED_SSL_VERSION", + 85899346249u64 => "UNSUPPORTED_STATUS_TYPE", + 85899346289u64 => "USE_SRTP_NOT_NEGOTIATED", + 85899346086u64 => "VERSION_TOO_HIGH", + 85899346316u64 => "VERSION_TOO_LOW", + 85899346303u64 => "WRONG_CERTIFICATE_TYPE", + 85899346181u64 => "WRONG_CIPHER_RETURNED", + 85899346298u64 => "WRONG_CURVE", + 85899346184u64 => "WRONG_SIGNATURE_LENGTH", + 85899346185u64 => "WRONG_SIGNATURE_SIZE", + 85899346290u64 => "WRONG_SIGNATURE_TYPE", + 85899346186u64 => "WRONG_SSL_VERSION", + 85899346187u64 => "WRONG_VERSION_NUMBER", + 85899346188u64 => "X509_LIB", + 85899346189u64 => "X509_VERIFICATION_SETUP_PROBLEMS", + 201863463044u64 => "BAD_PKCS7_TYPE", + 201863463045u64 => "BAD_TYPE", + 201863463049u64 => "CANNOT_LOAD_CERT", + 201863463050u64 => "CANNOT_LOAD_KEY", + 201863463012u64 => "CERTIFICATE_VERIFY_ERROR", + 201863463039u64 => "COULD_NOT_SET_ENGINE", + 201863463027u64 => "COULD_NOT_SET_TIME", + 201863463046u64 => "DETACHED_CONTENT", + 201863463028u64 => "ESS_ADD_SIGNING_CERT_ERROR", + 201863463051u64 => "ESS_ADD_SIGNING_CERT_V2_ERROR", + 201863463013u64 => "ESS_SIGNING_CERTIFICATE_ERROR", + 201863463014u64 => "INVALID_NULL_POINTER", + 201863463029u64 => "INVALID_SIGNER_CERTIFICATE_PURPOSE", + 201863463015u64 => "MESSAGE_IMPRINT_MISMATCH", + 201863463016u64 => "NONCE_MISMATCH", + 201863463017u64 => "NONCE_NOT_RETURNED", + 201863463018u64 => "NO_CONTENT", + 201863463019u64 => "NO_TIME_STAMP_TOKEN", + 201863463030u64 => "PKCS7_ADD_SIGNATURE_ERROR", + 201863463031u64 => "PKCS7_ADD_SIGNED_ATTR_ERROR", + 201863463041u64 => "PKCS7_TO_TS_TST_INFO_FAILED", + 201863463020u64 => "POLICY_MISMATCH", + 201863463032u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 201863463033u64 => "RESPONSE_SETUP_ERROR", + 201863463021u64 => "SIGNATURE_FAILURE", + 201863463022u64 => "THERE_MUST_BE_ONE_SIGNER", + 201863463034u64 => "TIME_SYSCALL_ERROR", + 201863463042u64 => "TOKEN_NOT_PRESENT", + 201863463043u64 => "TOKEN_PRESENT", + 201863463023u64 => "TSA_NAME_MISMATCH", + 201863463024u64 => "TSA_UNTRUSTED", + 201863463035u64 => "TST_INFO_SETUP_ERROR", + 201863463036u64 => "TS_DATASIGN", + 201863463037u64 => "UNACCEPTABLE_POLICY", + 201863463038u64 => "UNSUPPORTED_MD_ALGORITHM", + 201863463025u64 => "UNSUPPORTED_VERSION", + 201863463047u64 => "VAR_BAD_VALUE", + 201863463048u64 => "VAR_LOOKUP_FAILURE", + 201863463026u64 => "WRONG_CONTENT_TYPE", + 171798691944u64 => "COMMON_OK_AND_CANCEL_CHARACTERS", + 171798691942u64 => "INDEX_TOO_LARGE", + 171798691943u64 => "INDEX_TOO_SMALL", + 171798691945u64 => "NO_RESULT_BUFFER", + 171798691947u64 => "PROCESSING_ERROR", + 171798691940u64 => "RESULT_TOO_LARGE", + 171798691941u64 => "RESULT_TOO_SMALL", + 171798691949u64 => "SYSASSIGN_ERROR", + 171798691950u64 => "SYSDASSGN_ERROR", + 171798691951u64 => "SYSQIOW_ERROR", + 171798691946u64 => "UNKNOWN_CONTROL_COMMAND", + 171798691948u64 => "UNKNOWN_TTYGET_ERRNO_VALUE", + 171798691952u64 => "USER_DATA_DUPLICATION_UNSUPPORTED", + 146028888182u64 => "BAD_IP_ADDRESS", + 146028888183u64 => "BAD_OBJECT", + 146028888164u64 => "BN_DEC2BN_ERROR", + 146028888165u64 => "BN_TO_ASN1_INTEGER_ERROR", + 146028888213u64 => "DIRNAME_ERROR", + 146028888224u64 => "DISTPOINT_ALREADY_SET", + 146028888197u64 => "DUPLICATE_ZONE_ID", + 146028888233u64 => "EMPTY_KEY_USAGE", + 146028888195u64 => "ERROR_CONVERTING_ZONE", + 146028888208u64 => "ERROR_CREATING_EXTENSION", + 146028888192u64 => "ERROR_IN_EXTENSION", + 146028888201u64 => "EXPECTED_A_SECTION_NAME", + 146028888209u64 => "EXTENSION_EXISTS", + 146028888179u64 => "EXTENSION_NAME_ERROR", + 146028888166u64 => "EXTENSION_NOT_FOUND", + 146028888167u64 => "EXTENSION_SETTING_NOT_SUPPORTED", + 146028888180u64 => "EXTENSION_VALUE_ERROR", + 146028888215u64 => "ILLEGAL_EMPTY_EXTENSION", + 146028888216u64 => "INCORRECT_POLICY_SYNTAX_TAG", + 146028888226u64 => "INVALID_ASNUMBER", + 146028888227u64 => "INVALID_ASRANGE", + 146028888168u64 => "INVALID_BOOLEAN_STRING", + 146028888222u64 => "INVALID_CERTIFICATE", + 146028888172u64 => "INVALID_EMPTY_NAME", + 146028888169u64 => "INVALID_EXTENSION_STRING", + 146028888229u64 => "INVALID_INHERITANCE", + 146028888230u64 => "INVALID_IPADDRESS", + 146028888225u64 => "INVALID_MULTIPLE_RDNS", + 146028888170u64 => "INVALID_NAME", + 146028888171u64 => "INVALID_NULL_ARGUMENT", + 146028888173u64 => "INVALID_NULL_VALUE", + 146028888204u64 => "INVALID_NUMBER", + 146028888205u64 => "INVALID_NUMBERS", + 146028888174u64 => "INVALID_OBJECT_IDENTIFIER", + 146028888202u64 => "INVALID_OPTION", + 146028888198u64 => "INVALID_POLICY_IDENTIFIER", + 146028888217u64 => "INVALID_PROXY_POLICY_SETTING", + 146028888210u64 => "INVALID_PURPOSE", + 146028888228u64 => "INVALID_SAFI", + 146028888199u64 => "INVALID_SECTION", + 146028888207u64 => "INVALID_SYNTAX", + 146028888190u64 => "ISSUER_DECODE_ERROR", + 146028888188u64 => "MISSING_VALUE", + 146028888206u64 => "NEED_ORGANIZATION_AND_NUMBERS", + 146028888232u64 => "NEGATIVE_PATHLEN", + 146028888200u64 => "NO_CONFIG_DATABASE", + 146028888185u64 => "NO_ISSUER_CERTIFICATE", + 146028888191u64 => "NO_ISSUER_DETAILS", + 146028888203u64 => "NO_POLICY_IDENTIFIER", + 146028888218u64 => "NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED", + 146028888178u64 => "NO_PUBLIC_KEY", + 146028888189u64 => "NO_SUBJECT_DETAILS", + 146028888212u64 => "OPERATION_NOT_DEFINED", + 146028888211u64 => "OTHERNAME_ERROR", + 146028888219u64 => "POLICY_LANGUAGE_ALREADY_DEFINED", + 146028888220u64 => "POLICY_PATH_LENGTH", + 146028888221u64 => "POLICY_PATH_LENGTH_ALREADY_DEFINED", + 146028888223u64 => "POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY", + 146028888214u64 => "SECTION_NOT_FOUND", + 146028888186u64 => "UNABLE_TO_GET_ISSUER_DETAILS", + 146028888187u64 => "UNABLE_TO_GET_ISSUER_KEYID", + 146028888175u64 => "UNKNOWN_BIT_STRING_ARGUMENT", + 146028888193u64 => "UNKNOWN_EXTENSION", + 146028888194u64 => "UNKNOWN_EXTENSION_NAME", + 146028888184u64 => "UNKNOWN_OPTION", + 146028888181u64 => "UNSUPPORTED_OPTION", + 146028888231u64 => "UNSUPPORTED_TYPE", + 146028888196u64 => "USER_TOO_LONG", + 47244640366u64 => "AKID_MISMATCH", + 47244640389u64 => "BAD_SELECTOR", + 47244640356u64 => "BAD_X509_FILETYPE", + 47244640374u64 => "BASE64_DECODE_ERROR", + 47244640370u64 => "CANT_CHECK_DH_KEY", + 47244640395u64 => "CERTIFICATE_VERIFICATION_FAILED", + 47244640357u64 => "CERT_ALREADY_IN_HASH_TABLE", + 47244640383u64 => "CRL_ALREADY_DELTA", + 47244640387u64 => "CRL_VERIFY_FAILURE", + 47244640396u64 => "DUPLICATE_ATTRIBUTE", + 47244640397u64 => "ERROR_GETTING_MD_BY_NID", + 47244640398u64 => "ERROR_USING_SIGINF_SET", + 47244640384u64 => "IDP_MISMATCH", + 47244640394u64 => "INVALID_ATTRIBUTES", + 47244640369u64 => "INVALID_DIRECTORY", + 47244640399u64 => "INVALID_DISTPOINT", + 47244640375u64 => "INVALID_FIELD_NAME", + 47244640379u64 => "INVALID_TRUST", + 47244640385u64 => "ISSUER_MISMATCH", + 47244640371u64 => "KEY_TYPE_MISMATCH", + 47244640372u64 => "KEY_VALUES_MISMATCH", + 47244640359u64 => "LOADING_CERT_DIR", + 47244640360u64 => "LOADING_DEFAULTS", + 47244640380u64 => "METHOD_NOT_SUPPORTED", + 47244640390u64 => "NAME_TOO_LONG", + 47244640388u64 => "NEWER_CRL_NOT_NEWER", + 47244640391u64 => "NO_CERTIFICATE_FOUND", + 47244640392u64 => "NO_CERTIFICATE_OR_CRL_FOUND", + 47244640361u64 => "NO_CERT_SET_FOR_US_TO_VERIFY", + 47244640393u64 => "NO_CRL_FOUND", + 47244640386u64 => "NO_CRL_NUMBER", + 47244640381u64 => "PUBLIC_KEY_DECODE_ERROR", + 47244640382u64 => "PUBLIC_KEY_ENCODE_ERROR", + 47244640362u64 => "SHOULD_RETRY", + 47244640363u64 => "UNABLE_TO_FIND_PARAMETERS_IN_CHAIN", + 47244640364u64 => "UNABLE_TO_GET_CERTS_PUBLIC_KEY", + 47244640373u64 => "UNKNOWN_KEY_TYPE", + 47244640365u64 => "UNKNOWN_NID", + 47244640377u64 => "UNKNOWN_PURPOSE_ID", + 47244640400u64 => "UNKNOWN_SIGID_ALGS", + 47244640376u64 => "UNKNOWN_TRUST_ID", + 47244640367u64 => "UNSUPPORTED_ALGORITHM", + 47244640368u64 => "WRONG_LOOKUP_TYPE", + 47244640378u64 => "WRONG_TYPE", +}; + +/// Helper function to create encoded key from (lib, reason) pair +#[inline] +pub fn encode_error_key(lib: i32, reason: i32) -> u64 { + ((lib as u64) << 32) | (reason as u64 & 0xFFFFFFFF) +} diff --git a/stdlib/src/ssl/ssl_data_31.rs b/stdlib/src/ssl/ssl_data_31.rs new file mode 100644 index 00000000000..4b80de539ec --- /dev/null +++ b/stdlib/src/ssl/ssl_data_31.rs @@ -0,0 +1,1770 @@ +// File generated by tools/make_ssl_data_rs.py +// Generated on 2025-10-29T07:17:16.621749+00:00 +// Source: OpenSSL from /tmp/openssl-3.1 +// spell-checker: disable + +use phf::phf_map; + +// Maps lib_code -> library name +// Example: 20 -> "SSL" +pub static LIBRARY_CODES: phf::Map = phf_map! { + 0u32 => "MASK", + 1u32 => "NONE", + 2u32 => "SYS", + 3u32 => "BN", + 4u32 => "RSA", + 5u32 => "DH", + 6u32 => "EVP", + 7u32 => "BUF", + 8u32 => "OBJ", + 9u32 => "PEM", + 10u32 => "DSA", + 11u32 => "X509", + 12u32 => "METH", + 13u32 => "ASN1", + 14u32 => "CONF", + 15u32 => "CRYPTO", + 16u32 => "EC", + 20u32 => "SSL", + 21u32 => "SSL23", + 22u32 => "SSL2", + 23u32 => "SSL3", + 30u32 => "RSAREF", + 31u32 => "PROXY", + 32u32 => "BIO", + 33u32 => "PKCS7", + 34u32 => "X509V3", + 35u32 => "PKCS12", + 36u32 => "RAND", + 37u32 => "DSO", + 38u32 => "ENGINE", + 39u32 => "OCSP", + 40u32 => "UI", + 41u32 => "COMP", + 42u32 => "ECDSA", + 43u32 => "ECDH", + 44u32 => "OSSL_STORE", + 45u32 => "FIPS", + 46u32 => "CMS", + 47u32 => "TS", + 48u32 => "HMAC", + 49u32 => "JPAKE", + 50u32 => "CT", + 51u32 => "ASYNC", + 52u32 => "KDF", + 53u32 => "SM2", + 54u32 => "ESS", + 55u32 => "PROP", + 56u32 => "CRMF", + 57u32 => "PROV", + 58u32 => "CMP", + 59u32 => "OSSL_ENCODER", + 60u32 => "OSSL_DECODER", + 61u32 => "HTTP", + 128u32 => "USER", +}; + +// Maps encoded (lib, reason) -> error mnemonic +// Example: encode_error_key(20, 134) -> "CERTIFICATE_VERIFY_FAILED" +// Key encoding: (lib << 32) | reason +pub static ERROR_CODES: phf::Map = phf_map! { + 55834575019u64 => "ADDING_OBJECT", + 55834575051u64 => "ASN1_PARSE_ERROR", + 55834575052u64 => "ASN1_SIG_PARSE_ERROR", + 55834574948u64 => "AUX_ERROR", + 55834574950u64 => "BAD_OBJECT_HEADER", + 55834575078u64 => "BAD_TEMPLATE", + 55834575062u64 => "BMPSTRING_IS_WRONG_LENGTH", + 55834574953u64 => "BN_LIB", + 55834574954u64 => "BOOLEAN_IS_WRONG_LENGTH", + 55834574955u64 => "BUFFER_TOO_SMALL", + 55834574956u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER", + 55834575065u64 => "CONTEXT_NOT_INITIALISED", + 55834574957u64 => "DATA_IS_WRONG", + 55834574958u64 => "DECODE_ERROR", + 55834575022u64 => "DEPTH_EXCEEDED", + 55834575046u64 => "DIGEST_AND_KEY_TYPE_NOT_SUPPORTED", + 55834574960u64 => "ENCODE_ERROR", + 55834575021u64 => "ERROR_GETTING_TIME", + 55834575020u64 => "ERROR_LOADING_SECTION", + 55834574962u64 => "ERROR_SETTING_CIPHER_PARAMS", + 55834574963u64 => "EXPECTING_AN_INTEGER", + 55834574964u64 => "EXPECTING_AN_OBJECT", + 55834574967u64 => "EXPLICIT_LENGTH_MISMATCH", + 55834574968u64 => "EXPLICIT_TAG_NOT_CONSTRUCTED", + 55834574969u64 => "FIELD_MISSING", + 55834574970u64 => "FIRST_NUM_TOO_LARGE", + 55834574971u64 => "HEADER_TOO_LONG", + 55834575023u64 => "ILLEGAL_BITSTRING_FORMAT", + 55834575024u64 => "ILLEGAL_BOOLEAN", + 55834574972u64 => "ILLEGAL_CHARACTERS", + 55834575025u64 => "ILLEGAL_FORMAT", + 55834575026u64 => "ILLEGAL_HEX", + 55834575027u64 => "ILLEGAL_IMPLICIT_TAG", + 55834575028u64 => "ILLEGAL_INTEGER", + 55834575074u64 => "ILLEGAL_NEGATIVE_VALUE", + 55834575029u64 => "ILLEGAL_NESTED_TAGGING", + 55834574973u64 => "ILLEGAL_NULL", + 55834575030u64 => "ILLEGAL_NULL_VALUE", + 55834575031u64 => "ILLEGAL_OBJECT", + 55834574974u64 => "ILLEGAL_OPTIONAL_ANY", + 55834575018u64 => "ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE", + 55834575069u64 => "ILLEGAL_PADDING", + 55834574975u64 => "ILLEGAL_TAGGED_ANY", + 55834575032u64 => "ILLEGAL_TIME_VALUE", + 55834575070u64 => "ILLEGAL_ZERO_CONTENT", + 55834575033u64 => "INTEGER_NOT_ASCII_FORMAT", + 55834574976u64 => "INTEGER_TOO_LARGE_FOR_LONG", + 55834575068u64 => "INVALID_BIT_STRING_BITS_LEFT", + 55834574977u64 => "INVALID_BMPSTRING_LENGTH", + 55834574978u64 => "INVALID_DIGIT", + 55834575053u64 => "INVALID_MIME_TYPE", + 55834575034u64 => "INVALID_MODIFIER", + 55834575035u64 => "INVALID_NUMBER", + 55834575064u64 => "INVALID_OBJECT_ENCODING", + 55834575075u64 => "INVALID_SCRYPT_PARAMETERS", + 55834574979u64 => "INVALID_SEPARATOR", + 55834575066u64 => "INVALID_STRING_TABLE_VALUE", + 55834574981u64 => "INVALID_UNIVERSALSTRING_LENGTH", + 55834574982u64 => "INVALID_UTF8STRING", + 55834575067u64 => "INVALID_VALUE", + 55834575079u64 => "LENGTH_TOO_LONG", + 55834575036u64 => "LIST_ERROR", + 55834575054u64 => "MIME_NO_CONTENT_TYPE", + 55834575055u64 => "MIME_PARSE_ERROR", + 55834575056u64 => "MIME_SIG_PARSE_ERROR", + 55834574985u64 => "MISSING_EOC", + 55834574986u64 => "MISSING_SECOND_NUMBER", + 55834575037u64 => "MISSING_VALUE", + 55834574987u64 => "MSTRING_NOT_UNIVERSAL", + 55834574988u64 => "MSTRING_WRONG_TAG", + 55834575045u64 => "NESTED_ASN1_STRING", + 55834575049u64 => "NESTED_TOO_DEEP", + 55834574989u64 => "NON_HEX_CHARACTERS", + 55834575038u64 => "NOT_ASCII_FORMAT", + 55834574990u64 => "NOT_ENOUGH_DATA", + 55834575057u64 => "NO_CONTENT_TYPE", + 55834574991u64 => "NO_MATCHING_CHOICE_TYPE", + 55834575058u64 => "NO_MULTIPART_BODY_FAILURE", + 55834575059u64 => "NO_MULTIPART_BOUNDARY", + 55834575060u64 => "NO_SIG_CONTENT_TYPE", + 55834574992u64 => "NULL_IS_WRONG_LENGTH", + 55834575039u64 => "OBJECT_NOT_ASCII_FORMAT", + 55834574993u64 => "ODD_NUMBER_OF_CHARS", + 55834574995u64 => "SECOND_NUMBER_TOO_LARGE", + 55834574996u64 => "SEQUENCE_LENGTH_MISMATCH", + 55834574997u64 => "SEQUENCE_NOT_CONSTRUCTED", + 55834575040u64 => "SEQUENCE_OR_SET_NEEDS_CONFIG", + 55834574998u64 => "SHORT_LINE", + 55834575061u64 => "SIG_INVALID_MIME_TYPE", + 55834575050u64 => "STREAMING_NOT_SUPPORTED", + 55834574999u64 => "STRING_TOO_LONG", + 55834575000u64 => "STRING_TOO_SHORT", + 55834575002u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD", + 55834575041u64 => "TIME_NOT_ASCII_FORMAT", + 55834575071u64 => "TOO_LARGE", + 55834575003u64 => "TOO_LONG", + 55834575072u64 => "TOO_SMALL", + 55834575004u64 => "TYPE_NOT_CONSTRUCTED", + 55834575043u64 => "TYPE_NOT_PRIMITIVE", + 55834575007u64 => "UNEXPECTED_EOC", + 55834575063u64 => "UNIVERSALSTRING_IS_WRONG_LENGTH", + 55834575077u64 => "UNKNOWN_DIGEST", + 55834575008u64 => "UNKNOWN_FORMAT", + 55834575009u64 => "UNKNOWN_MESSAGE_DIGEST_ALGORITHM", + 55834575010u64 => "UNKNOWN_OBJECT_TYPE", + 55834575011u64 => "UNKNOWN_PUBLIC_KEY_TYPE", + 55834575047u64 => "UNKNOWN_SIGNATURE_ALGORITHM", + 55834575042u64 => "UNKNOWN_TAG", + 55834575012u64 => "UNSUPPORTED_ANY_DEFINED_BY_TYPE", + 55834575076u64 => "UNSUPPORTED_CIPHER", + 55834575015u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE", + 55834575044u64 => "UNSUPPORTED_TYPE", + 55834575073u64 => "WRONG_INTEGER_TYPE", + 55834575048u64 => "WRONG_PUBLIC_KEY_TYPE", + 55834575016u64 => "WRONG_TAG", + 219043332197u64 => "FAILED_TO_SET_POOL", + 219043332198u64 => "FAILED_TO_SWAP_CONTEXT", + 219043332201u64 => "INIT_FAILED", + 219043332199u64 => "INVALID_POOL_SIZE", + 137438953572u64 => "ACCEPT_ERROR", + 137438953613u64 => "ADDRINFO_ADDR_IS_NOT_AF_INET", + 137438953601u64 => "AMBIGUOUS_HOST_OR_SERVICE", + 137438953573u64 => "BAD_FOPEN_MODE", + 137438953596u64 => "BROKEN_PIPE", + 137438953575u64 => "CONNECT_ERROR", + 137438953619u64 => "CONNECT_TIMEOUT", + 137438953579u64 => "GETHOSTBYNAME_ADDR_IS_NOT_AF_INET", + 137438953604u64 => "GETSOCKNAME_ERROR", + 137438953605u64 => "GETSOCKNAME_TRUNCATED_ADDRESS", + 137438953606u64 => "GETTING_SOCKTYPE", + 137438953597u64 => "INVALID_ARGUMENT", + 137438953607u64 => "INVALID_SOCKET", + 137438953595u64 => "IN_USE", + 137438953574u64 => "LENGTH_TOO_LONG", + 137438953608u64 => "LISTEN_V6_ONLY", + 137438953614u64 => "LOOKUP_RETURNED_NOTHING", + 137438953602u64 => "MALFORMED_HOST_OR_SERVICE", + 137438953582u64 => "NBIO_CONNECT_ERROR", + 137438953615u64 => "NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED", + 137438953616u64 => "NO_HOSTNAME_OR_SERVICE_SPECIFIED", + 137438953585u64 => "NO_PORT_DEFINED", + 137438953600u64 => "NO_SUCH_FILE", + 137438953576u64 => "TRANSFER_ERROR", + 137438953577u64 => "TRANSFER_TIMEOUT", + 137438953589u64 => "UNABLE_TO_BIND_SOCKET", + 137438953590u64 => "UNABLE_TO_CREATE_SOCKET", + 137438953609u64 => "UNABLE_TO_KEEPALIVE", + 137438953591u64 => "UNABLE_TO_LISTEN_SOCKET", + 137438953610u64 => "UNABLE_TO_NODELAY", + 137438953611u64 => "UNABLE_TO_REUSEADDR", + 137438953617u64 => "UNAVAILABLE_IP_FAMILY", + 137438953592u64 => "UNINITIALIZED", + 137438953612u64 => "UNKNOWN_INFO_TYPE", + 137438953618u64 => "UNSUPPORTED_IP_FAMILY", + 137438953593u64 => "UNSUPPORTED_METHOD", + 137438953603u64 => "UNSUPPORTED_PROTOCOL_FAMILY", + 137438953598u64 => "WRITE_TO_READ_ONLY_BIO", + 137438953594u64 => "WSASTARTUP", + 12884901988u64 => "ARG2_LT_ARG3", + 12884901989u64 => "BAD_RECIPROCAL", + 12884902002u64 => "BIGNUM_TOO_LONG", + 12884902006u64 => "BITS_TOO_SMALL", + 12884901990u64 => "CALLED_WITH_EVEN_MODULUS", + 12884901991u64 => "DIV_BY_ZERO", + 12884901992u64 => "ENCODING_ERROR", + 12884901993u64 => "EXPAND_ON_STATIC_BIGNUM_DATA", + 12884901998u64 => "INPUT_NOT_REDUCED", + 12884901994u64 => "INVALID_LENGTH", + 12884902003u64 => "INVALID_RANGE", + 12884902007u64 => "INVALID_SHIFT", + 12884901999u64 => "NOT_A_SQUARE", + 12884901995u64 => "NOT_INITIALIZED", + 12884901996u64 => "NO_INVERSE", + 12884902009u64 => "NO_PRIME_CANDIDATE", + 12884902004u64 => "NO_SOLUTION", + 12884902008u64 => "NO_SUITABLE_DIGEST", + 12884902005u64 => "PRIVATE_KEY_TOO_LARGE", + 12884902000u64 => "P_IS_NOT_PRIME", + 12884902001u64 => "TOO_MANY_ITERATIONS", + 12884901997u64 => "TOO_MANY_TEMPORARY_VARIABLES", + 249108103307u64 => "ALGORITHM_NOT_SUPPORTED", + 249108103335u64 => "BAD_CHECKAFTER_IN_POLLREP", + 249108103276u64 => "BAD_REQUEST_ID", + 249108103324u64 => "CERTHASH_UNMATCHED", + 249108103277u64 => "CERTID_NOT_FOUND", + 249108103337u64 => "CERTIFICATE_NOT_ACCEPTED", + 249108103280u64 => "CERTIFICATE_NOT_FOUND", + 249108103325u64 => "CERTREQMSG_NOT_FOUND", + 249108103281u64 => "CERTRESPONSE_NOT_FOUND", + 249108103282u64 => "CERT_AND_KEY_DO_NOT_MATCH", + 249108103349u64 => "CHECKAFTER_OUT_OF_RANGE", + 249108103344u64 => "ENCOUNTERED_KEYUPDATEWARNING", + 249108103330u64 => "ENCOUNTERED_WAITING", + 249108103283u64 => "ERROR_CALCULATING_PROTECTION", + 249108103284u64 => "ERROR_CREATING_CERTCONF", + 249108103285u64 => "ERROR_CREATING_CERTREP", + 249108103331u64 => "ERROR_CREATING_CERTREQ", + 249108103286u64 => "ERROR_CREATING_ERROR", + 249108103287u64 => "ERROR_CREATING_GENM", + 249108103288u64 => "ERROR_CREATING_GENP", + 249108103290u64 => "ERROR_CREATING_PKICONF", + 249108103291u64 => "ERROR_CREATING_POLLREP", + 249108103292u64 => "ERROR_CREATING_POLLREQ", + 249108103293u64 => "ERROR_CREATING_RP", + 249108103294u64 => "ERROR_CREATING_RR", + 249108103275u64 => "ERROR_PARSING_PKISTATUS", + 249108103326u64 => "ERROR_PROCESSING_MESSAGE", + 249108103295u64 => "ERROR_PROTECTING_MESSAGE", + 249108103296u64 => "ERROR_SETTING_CERTHASH", + 249108103328u64 => "ERROR_UNEXPECTED_CERTCONF", + 249108103308u64 => "ERROR_VALIDATING_PROTECTION", + 249108103339u64 => "ERROR_VALIDATING_SIGNATURE", + 249108103332u64 => "FAILED_BUILDING_OWN_CHAIN", + 249108103309u64 => "FAILED_EXTRACTING_PUBKEY", + 249108103278u64 => "FAILURE_OBTAINING_RANDOM", + 249108103297u64 => "FAIL_INFO_OUT_OF_RANGE", + 249108103268u64 => "INVALID_ARGS", + 249108103342u64 => "INVALID_OPTION", + 249108103333u64 => "MISSING_CERTID", + 249108103298u64 => "MISSING_KEY_INPUT_FOR_CREATING_PROTECTION", + 249108103310u64 => "MISSING_KEY_USAGE_DIGITALSIGNATURE", + 249108103289u64 => "MISSING_P10CSR", + 249108103334u64 => "MISSING_PBM_SECRET", + 249108103299u64 => "MISSING_PRIVATE_KEY", + 249108103358u64 => "MISSING_PRIVATE_KEY_FOR_POPO", + 249108103311u64 => "MISSING_PROTECTION", + 249108103351u64 => "MISSING_PUBLIC_KEY", + 249108103336u64 => "MISSING_REFERENCE_CERT", + 249108103346u64 => "MISSING_SECRET", + 249108103279u64 => "MISSING_SENDER_IDENTIFICATION", + 249108103347u64 => "MISSING_TRUST_ANCHOR", + 249108103312u64 => "MISSING_TRUST_STORE", + 249108103329u64 => "MULTIPLE_REQUESTS_NOT_SUPPORTED", + 249108103338u64 => "MULTIPLE_RESPONSES_NOT_SUPPORTED", + 249108103270u64 => "MULTIPLE_SAN_SOURCES", + 249108103362u64 => "NO_STDIO", + 249108103313u64 => "NO_SUITABLE_SENDER_CERT", + 249108103271u64 => "NULL_ARGUMENT", + 249108103314u64 => "PKIBODY_ERROR", + 249108103300u64 => "PKISTATUSINFO_NOT_FOUND", + 249108103340u64 => "POLLING_FAILED", + 249108103315u64 => "POTENTIALLY_INVALID_CERTIFICATE", + 249108103348u64 => "RECEIVED_ERROR", + 249108103316u64 => "RECIPNONCE_UNMATCHED", + 249108103317u64 => "REQUEST_NOT_ACCEPTED", + 249108103350u64 => "REQUEST_REJECTED_BY_SERVER", + 249108103318u64 => "SENDER_GENERALNAME_TYPE_NOT_SUPPORTED", + 249108103319u64 => "SRVCERT_DOES_NOT_VALIDATE_MSG", + 249108103352u64 => "TOTAL_TIMEOUT", + 249108103320u64 => "TRANSACTIONID_UNMATCHED", + 249108103327u64 => "TRANSFER_ERROR", + 249108103301u64 => "UNEXPECTED_PKIBODY", + 249108103353u64 => "UNEXPECTED_PKISTATUS", + 249108103321u64 => "UNEXPECTED_PVNO", + 249108103302u64 => "UNKNOWN_ALGORITHM_ID", + 249108103303u64 => "UNKNOWN_CERT_TYPE", + 249108103354u64 => "UNKNOWN_PKISTATUS", + 249108103304u64 => "UNSUPPORTED_ALGORITHM", + 249108103305u64 => "UNSUPPORTED_KEY_TYPE", + 249108103322u64 => "UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC", + 249108103343u64 => "VALUE_TOO_LARGE", + 249108103345u64 => "VALUE_TOO_SMALL", + 249108103306u64 => "WRONG_ALGORITHM_OID", + 249108103357u64 => "WRONG_CERTID", + 249108103355u64 => "WRONG_CERTID_IN_RP", + 249108103323u64 => "WRONG_PBM_VALUE", + 249108103356u64 => "WRONG_RP_COMPONENT_COUNT", + 249108103341u64 => "WRONG_SERIAL_IN_RP", + 197568495715u64 => "ADD_SIGNER_ERROR", + 197568495777u64 => "ATTRIBUTE_ERROR", + 197568495791u64 => "CERTIFICATE_ALREADY_PRESENT", + 197568495776u64 => "CERTIFICATE_HAS_NO_KEYID", + 197568495716u64 => "CERTIFICATE_VERIFY_ERROR", + 197568495800u64 => "CIPHER_AEAD_SET_TAG_ERROR", + 197568495801u64 => "CIPHER_GET_TAG", + 197568495717u64 => "CIPHER_INITIALISATION_ERROR", + 197568495718u64 => "CIPHER_PARAMETER_INITIALISATION_ERROR", + 197568495719u64 => "CMS_DATAFINAL_ERROR", + 197568495720u64 => "CMS_LIB", + 197568495786u64 => "CONTENTIDENTIFIER_MISMATCH", + 197568495721u64 => "CONTENT_NOT_FOUND", + 197568495787u64 => "CONTENT_TYPE_MISMATCH", + 197568495722u64 => "CONTENT_TYPE_NOT_COMPRESSED_DATA", + 197568495723u64 => "CONTENT_TYPE_NOT_ENVELOPED_DATA", + 197568495724u64 => "CONTENT_TYPE_NOT_SIGNED_DATA", + 197568495725u64 => "CONTENT_VERIFY_ERROR", + 197568495726u64 => "CTRL_ERROR", + 197568495727u64 => "CTRL_FAILURE", + 197568495803u64 => "DECODE_ERROR", + 197568495728u64 => "DECRYPT_ERROR", + 197568495729u64 => "ERROR_GETTING_PUBLIC_KEY", + 197568495730u64 => "ERROR_READING_MESSAGEDIGEST_ATTRIBUTE", + 197568495731u64 => "ERROR_SETTING_KEY", + 197568495732u64 => "ERROR_SETTING_RECIPIENTINFO", + 197568495799u64 => "ESS_SIGNING_CERTID_MISMATCH_ERROR", + 197568495733u64 => "INVALID_ENCRYPTED_KEY_LENGTH", + 197568495792u64 => "INVALID_KEY_ENCRYPTION_PARAMETER", + 197568495734u64 => "INVALID_KEY_LENGTH", + 197568495806u64 => "INVALID_LABEL", + 197568495807u64 => "INVALID_OAEP_PARAMETERS", + 197568495802u64 => "KDF_PARAMETER_ERROR", + 197568495735u64 => "MD_BIO_INIT_ERROR", + 197568495736u64 => "MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH", + 197568495737u64 => "MESSAGEDIGEST_WRONG_LENGTH", + 197568495788u64 => "MSGSIGDIGEST_ERROR", + 197568495778u64 => "MSGSIGDIGEST_VERIFICATION_FAILURE", + 197568495779u64 => "MSGSIGDIGEST_WRONG_LENGTH", + 197568495780u64 => "NEED_ONE_SIGNER", + 197568495781u64 => "NOT_A_SIGNED_RECEIPT", + 197568495738u64 => "NOT_ENCRYPTED_DATA", + 197568495739u64 => "NOT_KEK", + 197568495797u64 => "NOT_KEY_AGREEMENT", + 197568495740u64 => "NOT_KEY_TRANSPORT", + 197568495793u64 => "NOT_PWRI", + 197568495741u64 => "NOT_SUPPORTED_FOR_THIS_KEY_TYPE", + 197568495742u64 => "NO_CIPHER", + 197568495743u64 => "NO_CONTENT", + 197568495789u64 => "NO_CONTENT_TYPE", + 197568495744u64 => "NO_DEFAULT_DIGEST", + 197568495745u64 => "NO_DIGEST_SET", + 197568495746u64 => "NO_KEY", + 197568495790u64 => "NO_KEY_OR_CERT", + 197568495747u64 => "NO_MATCHING_DIGEST", + 197568495748u64 => "NO_MATCHING_RECIPIENT", + 197568495782u64 => "NO_MATCHING_SIGNATURE", + 197568495783u64 => "NO_MSGSIGDIGEST", + 197568495794u64 => "NO_PASSWORD", + 197568495749u64 => "NO_PRIVATE_KEY", + 197568495750u64 => "NO_PUBLIC_KEY", + 197568495784u64 => "NO_RECEIPT_REQUEST", + 197568495751u64 => "NO_SIGNERS", + 197568495804u64 => "PEER_KEY_ERROR", + 197568495752u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 197568495785u64 => "RECEIPT_DECODE_ERROR", + 197568495753u64 => "RECIPIENT_ERROR", + 197568495805u64 => "SHARED_INFO_ERROR", + 197568495754u64 => "SIGNER_CERTIFICATE_NOT_FOUND", + 197568495755u64 => "SIGNFINAL_ERROR", + 197568495756u64 => "SMIME_TEXT_ERROR", + 197568495757u64 => "STORE_INIT_ERROR", + 197568495758u64 => "TYPE_NOT_COMPRESSED_DATA", + 197568495759u64 => "TYPE_NOT_DATA", + 197568495760u64 => "TYPE_NOT_DIGESTED_DATA", + 197568495761u64 => "TYPE_NOT_ENCRYPTED_DATA", + 197568495762u64 => "TYPE_NOT_ENVELOPED_DATA", + 197568495763u64 => "UNABLE_TO_FINALIZE_CONTEXT", + 197568495764u64 => "UNKNOWN_CIPHER", + 197568495765u64 => "UNKNOWN_DIGEST_ALGORITHM", + 197568495766u64 => "UNKNOWN_ID", + 197568495767u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM", + 197568495810u64 => "UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM", + 197568495768u64 => "UNSUPPORTED_CONTENT_TYPE", + 197568495808u64 => "UNSUPPORTED_ENCRYPTION_TYPE", + 197568495769u64 => "UNSUPPORTED_KEK_ALGORITHM", + 197568495795u64 => "UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM", + 197568495809u64 => "UNSUPPORTED_LABEL_SOURCE", + 197568495771u64 => "UNSUPPORTED_RECIPIENTINFO_TYPE", + 197568495770u64 => "UNSUPPORTED_RECIPIENT_TYPE", + 197568495811u64 => "UNSUPPORTED_SIGNATURE_ALGORITHM", + 197568495772u64 => "UNSUPPORTED_TYPE", + 197568495773u64 => "UNWRAP_ERROR", + 197568495796u64 => "UNWRAP_FAILURE", + 197568495774u64 => "VERIFICATION_FAILURE", + 197568495775u64 => "WRAP_ERROR", + 176093659235u64 => "ZLIB_DEFLATE_ERROR", + 176093659236u64 => "ZLIB_INFLATE_ERROR", + 176093659237u64 => "ZLIB_NOT_SUPPORTED", + 60129542254u64 => "ERROR_LOADING_DSO", + 60129542266u64 => "INVALID_PRAGMA", + 60129542259u64 => "LIST_CANNOT_BE_NULL", + 60129542267u64 => "MANDATORY_BRACES_IN_VARIABLE_EXPANSION", + 60129542244u64 => "MISSING_CLOSE_SQUARE_BRACKET", + 60129542245u64 => "MISSING_EQUAL_SIGN", + 60129542256u64 => "MISSING_INIT_FUNCTION", + 60129542253u64 => "MODULE_INITIALIZATION_ERROR", + 60129542246u64 => "NO_CLOSE_BRACE", + 60129542249u64 => "NO_CONF", + 60129542250u64 => "NO_CONF_OR_ENVIRONMENT_VARIABLE", + 60129542251u64 => "NO_SECTION", + 60129542258u64 => "NO_SUCH_FILE", + 60129542252u64 => "NO_VALUE", + 60129542265u64 => "NUMBER_TOO_LARGE", + 60129542268u64 => "OPENSSL_CONF_REFERENCES_MISSING_SECTION", + 60129542255u64 => "RECURSIVE_DIRECTORY_INCLUDE", + 60129542270u64 => "RECURSIVE_SECTION_REFERENCE", + 60129542269u64 => "RELATIVE_PATH", + 60129542261u64 => "SSL_COMMAND_SECTION_EMPTY", + 60129542262u64 => "SSL_COMMAND_SECTION_NOT_FOUND", + 60129542263u64 => "SSL_SECTION_EMPTY", + 60129542264u64 => "SSL_SECTION_NOT_FOUND", + 60129542247u64 => "UNABLE_TO_CREATE_NEW_SECTION", + 60129542257u64 => "UNKNOWN_MODULE_NAME", + 60129542260u64 => "VARIABLE_EXPANSION_TOO_LONG", + 60129542248u64 => "VARIABLE_HAS_NO_VALUE", + 240518168676u64 => "BAD_PBM_ITERATIONCOUNT", + 240518168678u64 => "CRMFERROR", + 240518168679u64 => "ERROR", + 240518168680u64 => "ERROR_DECODING_CERTIFICATE", + 240518168681u64 => "ERROR_DECRYPTING_CERTIFICATE", + 240518168682u64 => "ERROR_DECRYPTING_SYMMETRIC_KEY", + 240518168683u64 => "FAILURE_OBTAINING_RANDOM", + 240518168684u64 => "ITERATIONCOUNT_BELOW_100", + 240518168677u64 => "MALFORMED_IV", + 240518168685u64 => "NULL_ARGUMENT", + 240518168689u64 => "POPOSKINPUT_NOT_SUPPORTED", + 240518168693u64 => "POPO_INCONSISTENT_PUBLIC_KEY", + 240518168697u64 => "POPO_MISSING", + 240518168694u64 => "POPO_MISSING_PUBLIC_KEY", + 240518168695u64 => "POPO_MISSING_SUBJECT", + 240518168696u64 => "POPO_RAVERIFIED_NOT_ACCEPTED", + 240518168686u64 => "SETTING_MAC_ALGOR_FAILURE", + 240518168687u64 => "SETTING_OWF_ALGOR_FAILURE", + 240518168688u64 => "UNSUPPORTED_ALGORITHM", + 240518168690u64 => "UNSUPPORTED_CIPHER", + 240518168691u64 => "UNSUPPORTED_METHOD_FOR_CREATING_POPO", + 240518168692u64 => "UNSUPPORTED_POPO_METHOD", + 64424509557u64 => "BAD_ALGORITHM_NAME", + 64424509558u64 => "CONFLICTING_NAMES", + 64424509561u64 => "HEX_STRING_TOO_SHORT", + 64424509542u64 => "ILLEGAL_HEX_DIGIT", + 64424509546u64 => "INSUFFICIENT_DATA_SPACE", + 64424509547u64 => "INSUFFICIENT_PARAM_SIZE", + 64424509548u64 => "INSUFFICIENT_SECURE_DATA_SPACE", + 64424509567u64 => "INTEGER_OVERFLOW", + 64424509562u64 => "INVALID_NEGATIVE_VALUE", + 64424509549u64 => "INVALID_NULL_ARGUMENT", + 64424509550u64 => "INVALID_OSSL_PARAM_TYPE", + 64424509571u64 => "NO_PARAMS_TO_MERGE", + 64424509568u64 => "NO_SPACE_FOR_TERMINATING_NULL", + 64424509543u64 => "ODD_NUMBER_OF_DIGITS", + 64424509563u64 => "PARAM_CANNOT_BE_REPRESENTED_EXACTLY", + 64424509564u64 => "PARAM_NOT_INTEGER_TYPE", + 64424509569u64 => "PARAM_OF_INCOMPATIBLE_TYPE", + 64424509565u64 => "PARAM_UNSIGNED_INTEGER_NEGATIVE_VALUE_UNSUPPORTED", + 64424509570u64 => "PARAM_UNSUPPORTED_FLOATING_POINT_FORMAT", + 64424509566u64 => "PARAM_VALUE_TOO_LARGE_FOR_DESTINATION", + 64424509544u64 => "PROVIDER_ALREADY_EXISTS", + 64424509545u64 => "PROVIDER_SECTION_ERROR", + 64424509559u64 => "RANDOM_SECTION_ERROR", + 64424509551u64 => "SECURE_MALLOC_FAILURE", + 64424509552u64 => "STRING_TOO_LONG", + 64424509553u64 => "TOO_MANY_BYTES", + 64424509554u64 => "TOO_MANY_RECORDS", + 64424509556u64 => "TOO_SMALL_BUFFER", + 64424509560u64 => "UNKNOWN_NAME_IN_RANDOM_SECTION", + 64424509555u64 => "ZERO_LENGTH_NUMBER", + 214748364908u64 => "BASE64_DECODE_ERROR", + 214748364900u64 => "INVALID_LOG_ID_LENGTH", + 214748364909u64 => "LOG_CONF_INVALID", + 214748364910u64 => "LOG_CONF_INVALID_KEY", + 214748364911u64 => "LOG_CONF_MISSING_DESCRIPTION", + 214748364912u64 => "LOG_CONF_MISSING_KEY", + 214748364913u64 => "LOG_KEY_INVALID", + 214748364916u64 => "SCT_FUTURE_TIMESTAMP", + 214748364904u64 => "SCT_INVALID", + 214748364907u64 => "SCT_INVALID_SIGNATURE", + 214748364905u64 => "SCT_LIST_INVALID", + 214748364914u64 => "SCT_LOG_ID_MISMATCH", + 214748364906u64 => "SCT_NOT_SET", + 214748364915u64 => "SCT_UNSUPPORTED_VERSION", + 214748364901u64 => "UNRECOGNIZED_SIGNATURE_NID", + 214748364902u64 => "UNSUPPORTED_ENTRY_TYPE", + 214748364903u64 => "UNSUPPORTED_VERSION", + 21474836607u64 => "BAD_FFC_PARAMETERS", + 21474836581u64 => "BAD_GENERATOR", + 21474836589u64 => "BN_DECODE_ERROR", + 21474836586u64 => "BN_ERROR", + 21474836595u64 => "CHECK_INVALID_J_VALUE", + 21474836596u64 => "CHECK_INVALID_Q_VALUE", + 21474836602u64 => "CHECK_PUBKEY_INVALID", + 21474836603u64 => "CHECK_PUBKEY_TOO_LARGE", + 21474836604u64 => "CHECK_PUBKEY_TOO_SMALL", + 21474836597u64 => "CHECK_P_NOT_PRIME", + 21474836598u64 => "CHECK_P_NOT_SAFE_PRIME", + 21474836599u64 => "CHECK_Q_NOT_PRIME", + 21474836584u64 => "DECODE_ERROR", + 21474836590u64 => "INVALID_PARAMETER_NAME", + 21474836594u64 => "INVALID_PARAMETER_NID", + 21474836582u64 => "INVALID_PUBKEY", + 21474836608u64 => "INVALID_SECRET", + 21474836592u64 => "KDF_PARAMETER_ERROR", + 21474836588u64 => "KEYS_NOT_SET", + 21474836605u64 => "MISSING_PUBKEY", + 21474836583u64 => "MODULUS_TOO_LARGE", + 21474836606u64 => "MODULUS_TOO_SMALL", + 21474836600u64 => "NOT_SUITABLE_GENERATOR", + 21474836587u64 => "NO_PARAMETERS_SET", + 21474836580u64 => "NO_PRIVATE_VALUE", + 21474836585u64 => "PARAMETER_ENCODING_ERROR", + 21474836591u64 => "PEER_KEY_ERROR", + 21474836610u64 => "Q_TOO_LARGE", + 21474836593u64 => "SHARED_INFO_ERROR", + 21474836601u64 => "UNABLE_TO_CHECK_GENERATOR", + 42949673074u64 => "BAD_FFC_PARAMETERS", + 42949673062u64 => "BAD_Q_VALUE", + 42949673068u64 => "BN_DECODE_ERROR", + 42949673069u64 => "BN_ERROR", + 42949673064u64 => "DECODE_ERROR", + 42949673066u64 => "INVALID_DIGEST_TYPE", + 42949673072u64 => "INVALID_PARAMETERS", + 42949673061u64 => "MISSING_PARAMETERS", + 42949673071u64 => "MISSING_PRIVATE_KEY", + 42949673063u64 => "MODULUS_TOO_LARGE", + 42949673067u64 => "NO_PARAMETERS_SET", + 42949673065u64 => "PARAMETER_ENCODING_ERROR", + 42949673075u64 => "P_NOT_PRIME", + 42949673073u64 => "Q_NOT_PRIME", + 42949673070u64 => "SEED_LEN_SMALL", + 42949673076u64 => "TOO_MANY_RETRIES", + 158913790052u64 => "CTRL_FAILED", + 158913790062u64 => "DSO_ALREADY_LOADED", + 158913790065u64 => "EMPTY_FILE_STRUCTURE", + 158913790066u64 => "FAILURE", + 158913790053u64 => "FILENAME_TOO_BIG", + 158913790054u64 => "FINISH_FAILED", + 158913790067u64 => "INCORRECT_FILE_SYNTAX", + 158913790055u64 => "LOAD_FAILED", + 158913790061u64 => "NAME_TRANSLATION_FAILED", + 158913790063u64 => "NO_FILENAME", + 158913790056u64 => "NULL_HANDLE", + 158913790064u64 => "SET_FILENAME_FAILED", + 158913790057u64 => "STACK_ERROR", + 158913790058u64 => "SYM_FAILURE", + 158913790059u64 => "UNLOAD_FAILED", + 158913790060u64 => "UNSUPPORTED", + 68719476851u64 => "ASN1_ERROR", + 68719476892u64 => "BAD_SIGNATURE", + 68719476880u64 => "BIGNUM_OUT_OF_RANGE", + 68719476836u64 => "BUFFER_TOO_SMALL", + 68719476901u64 => "CANNOT_INVERT", + 68719476882u64 => "COORDINATES_OUT_OF_RANGE", + 68719476896u64 => "CURVE_DOES_NOT_SUPPORT_ECDH", + 68719476906u64 => "CURVE_DOES_NOT_SUPPORT_ECDSA", + 68719476895u64 => "CURVE_DOES_NOT_SUPPORT_SIGNING", + 68719476878u64 => "DECODE_ERROR", + 68719476854u64 => "DISCRIMINANT_IS_ZERO", + 68719476855u64 => "EC_GROUP_NEW_BY_NAME_FAILURE", + 68719476863u64 => "EXPLICIT_PARAMS_NOT_SUPPORTED", + 68719476902u64 => "FAILED_MAKING_PUBLIC_KEY", + 68719476879u64 => "FIELD_TOO_LARGE", + 68719476883u64 => "GF2M_NOT_SUPPORTED", + 68719476856u64 => "GROUP2PKPARAMETERS_FAILURE", + 68719476857u64 => "I2D_ECPKPARAMETERS_FAILURE", + 68719476837u64 => "INCOMPATIBLE_OBJECTS", + 68719476904u64 => "INVALID_A", + 68719476848u64 => "INVALID_ARGUMENT", + 68719476905u64 => "INVALID_B", + 68719476907u64 => "INVALID_COFACTOR", + 68719476846u64 => "INVALID_COMPRESSED_POINT", + 68719476845u64 => "INVALID_COMPRESSION_BIT", + 68719476877u64 => "INVALID_CURVE", + 68719476887u64 => "INVALID_DIGEST", + 68719476874u64 => "INVALID_DIGEST_TYPE", + 68719476838u64 => "INVALID_ENCODING", + 68719476839u64 => "INVALID_FIELD", + 68719476840u64 => "INVALID_FORM", + 68719476909u64 => "INVALID_GENERATOR", + 68719476858u64 => "INVALID_GROUP_ORDER", + 68719476852u64 => "INVALID_KEY", + 68719476853u64 => "INVALID_LENGTH", + 68719476910u64 => "INVALID_NAMED_GROUP_CONVERSION", + 68719476897u64 => "INVALID_OUTPUT_LENGTH", + 68719476908u64 => "INVALID_P", + 68719476869u64 => "INVALID_PEER_KEY", + 68719476868u64 => "INVALID_PENTANOMIAL_BASIS", + 68719476859u64 => "INVALID_PRIVATE_KEY", + 68719476911u64 => "INVALID_SEED", + 68719476873u64 => "INVALID_TRINOMIAL_BASIS", + 68719476884u64 => "KDF_PARAMETER_ERROR", + 68719476876u64 => "KEYS_NOT_SET", + 68719476872u64 => "LADDER_POST_FAILURE", + 68719476889u64 => "LADDER_PRE_FAILURE", + 68719476898u64 => "LADDER_STEP_FAILURE", + 68719476903u64 => "MISSING_OID", + 68719476860u64 => "MISSING_PARAMETERS", + 68719476861u64 => "MISSING_PRIVATE_KEY", + 68719476893u64 => "NEED_NEW_SETUP_VALUES", + 68719476871u64 => "NOT_A_NIST_PRIME", + 68719476862u64 => "NOT_IMPLEMENTED", + 68719476847u64 => "NOT_INITIALIZED", + 68719476875u64 => "NO_PARAMETERS_SET", + 68719476890u64 => "NO_PRIVATE_VALUE", + 68719476888u64 => "OPERATION_NOT_SUPPORTED", + 68719476870u64 => "PASSED_NULL_PARAMETER", + 68719476885u64 => "PEER_KEY_ERROR", + 68719476891u64 => "POINT_ARITHMETIC_FAILURE", + 68719476842u64 => "POINT_AT_INFINITY", + 68719476899u64 => "POINT_COORDINATES_BLIND_FAILURE", + 68719476843u64 => "POINT_IS_NOT_ON_CURVE", + 68719476894u64 => "RANDOM_NUMBER_GENERATION_FAILED", + 68719476886u64 => "SHARED_INFO_ERROR", + 68719476844u64 => "SLOT_FULL", + 68719476912u64 => "TOO_MANY_RETRIES", + 68719476849u64 => "UNDEFINED_GENERATOR", + 68719476864u64 => "UNDEFINED_ORDER", + 68719476900u64 => "UNKNOWN_COFACTOR", + 68719476865u64 => "UNKNOWN_GROUP", + 68719476850u64 => "UNKNOWN_ORDER", + 68719476867u64 => "UNSUPPORTED_FIELD", + 68719476881u64 => "WRONG_CURVE_PARAMETERS", + 68719476866u64 => "WRONG_ORDER", + 163208757348u64 => "ALREADY_LOADED", + 163208757381u64 => "ARGUMENT_IS_NOT_A_NUMBER", + 163208757382u64 => "CMD_NOT_EXECUTABLE", + 163208757383u64 => "COMMAND_TAKES_INPUT", + 163208757384u64 => "COMMAND_TAKES_NO_INPUT", + 163208757351u64 => "CONFLICTING_ENGINE_ID", + 163208757367u64 => "CTRL_COMMAND_NOT_IMPLEMENTED", + 163208757352u64 => "DSO_FAILURE", + 163208757380u64 => "DSO_NOT_FOUND", + 163208757396u64 => "ENGINES_SECTION_ERROR", + 163208757350u64 => "ENGINE_CONFIGURATION_ERROR", + 163208757353u64 => "ENGINE_IS_NOT_IN_LIST", + 163208757397u64 => "ENGINE_SECTION_ERROR", + 163208757376u64 => "FAILED_LOADING_PRIVATE_KEY", + 163208757377u64 => "FAILED_LOADING_PUBLIC_KEY", + 163208757354u64 => "FINISH_FAILED", + 163208757356u64 => "ID_OR_NAME_MISSING", + 163208757357u64 => "INIT_FAILED", + 163208757358u64 => "INTERNAL_LIST_ERROR", + 163208757391u64 => "INVALID_ARGUMENT", + 163208757385u64 => "INVALID_CMD_NAME", + 163208757386u64 => "INVALID_CMD_NUMBER", + 163208757399u64 => "INVALID_INIT_VALUE", + 163208757398u64 => "INVALID_STRING", + 163208757365u64 => "NOT_INITIALISED", + 163208757360u64 => "NOT_LOADED", + 163208757368u64 => "NO_CONTROL_FUNCTION", + 163208757392u64 => "NO_INDEX", + 163208757373u64 => "NO_LOAD_FUNCTION", + 163208757378u64 => "NO_REFERENCE", + 163208757364u64 => "NO_SUCH_ENGINE", + 163208757394u64 => "UNIMPLEMENTED_CIPHER", + 163208757395u64 => "UNIMPLEMENTED_DIGEST", + 163208757349u64 => "UNIMPLEMENTED_PUBLIC_KEY_METHOD", + 163208757393u64 => "VERSION_INCOMPATIBILITY", + 231928234091u64 => "EMPTY_ESS_CERT_ID_LIST", + 231928234087u64 => "ESS_CERT_DIGEST_ERROR", + 231928234088u64 => "ESS_CERT_ID_NOT_FOUND", + 231928234089u64 => "ESS_CERT_ID_WRONG_ORDER", + 231928234090u64 => "ESS_DIGEST_ALG_UNKNOWN", + 231928234086u64 => "ESS_SIGNING_CERTIFICATE_ERROR", + 231928234084u64 => "ESS_SIGNING_CERT_ADD_ERROR", + 231928234085u64 => "ESS_SIGNING_CERT_V2_ADD_ERROR", + 231928234092u64 => "MISSING_SIGNING_CERTIFICATE_ATTRIBUTE", + 25769803919u64 => "AES_KEY_SETUP_FAILED", + 25769803952u64 => "ARIA_KEY_SETUP_FAILED", + 25769803976u64 => "BAD_ALGORITHM_NAME", + 25769803876u64 => "BAD_DECRYPT", + 25769803971u64 => "BAD_KEY_LENGTH", + 25769803931u64 => "BUFFER_TOO_SMALL", + 25769804001u64 => "CACHE_CONSTANTS_FAILED", + 25769803933u64 => "CAMELLIA_KEY_SETUP_FAILED", + 25769803973u64 => "CANNOT_GET_PARAMETERS", + 25769803974u64 => "CANNOT_SET_PARAMETERS", + 25769803960u64 => "CIPHER_NOT_GCM_MODE", + 25769803898u64 => "CIPHER_PARAMETER_ERROR", + 25769803923u64 => "COMMAND_NOT_SUPPORTED", + 25769803977u64 => "CONFLICTING_ALGORITHM_NAME", + 25769803949u64 => "COPY_ERROR", + 25769803908u64 => "CTRL_NOT_IMPLEMENTED", + 25769803909u64 => "CTRL_OPERATION_NOT_IMPLEMENTED", + 25769803914u64 => "DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH", + 25769803890u64 => "DECODE_ERROR", + 25769803986u64 => "DEFAULT_QUERY_PARSE_ERROR", + 25769803877u64 => "DIFFERENT_KEY_TYPES", + 25769803929u64 => "DIFFERENT_PARAMETERS", + 25769803941u64 => "ERROR_LOADING_SECTION", + 25769803950u64 => "EXPECTING_AN_HMAC_KEY", + 25769803903u64 => "EXPECTING_AN_RSA_KEY", + 25769803904u64 => "EXPECTING_A_DH_KEY", + 25769803905u64 => "EXPECTING_A_DSA_KEY", + 25769803995u64 => "EXPECTING_A_ECX_KEY", + 25769803918u64 => "EXPECTING_A_EC_KEY", + 25769803940u64 => "EXPECTING_A_POLY1305_KEY", + 25769803951u64 => "EXPECTING_A_SIPHASH_KEY", + 25769803964u64 => "FINAL_ERROR", + 25769803990u64 => "GENERATE_ERROR", + 25769803958u64 => "GET_RAW_KEY_FAILED", + 25769803947u64 => "ILLEGAL_SCRYPT_PARAMETERS", + 25769803980u64 => "INACCESSIBLE_DOMAIN_PARAMETERS", + 25769803979u64 => "INACCESSIBLE_KEY", + 25769803910u64 => "INITIALIZATION_ERROR", + 25769803887u64 => "INPUT_NOT_INITIALIZED", + 25769803961u64 => "INVALID_CUSTOM_LENGTH", + 25769803928u64 => "INVALID_DIGEST", + 25769803970u64 => "INVALID_IV_LENGTH", + 25769803939u64 => "INVALID_KEY", + 25769803906u64 => "INVALID_KEY_LENGTH", + 25769803997u64 => "INVALID_LENGTH", + 25769803994u64 => "INVALID_NULL_ALGORITHM", + 25769803924u64 => "INVALID_OPERATION", + 25769803969u64 => "INVALID_PROVIDER_FUNCTIONS", + 25769803962u64 => "INVALID_SALT_LENGTH", + 25769803999u64 => "INVALID_SECRET_LENGTH", + 25769803996u64 => "INVALID_SEED_LENGTH", + 25769803998u64 => "INVALID_VALUE", + 25769803981u64 => "KEYMGMT_EXPORT_FAILURE", + 25769803956u64 => "KEY_SETUP_FAILED", + 25769803989u64 => "LOCKING_NOT_SUPPORTED", + 25769803948u64 => "MEMORY_LIMIT_EXCEEDED", + 25769803935u64 => "MESSAGE_DIGEST_IS_NULL", + 25769803920u64 => "METHOD_NOT_SUPPORTED", + 25769803879u64 => "MISSING_PARAMETERS", + 25769803966u64 => "NOT_ABLE_TO_COPY_CTX", + 25769803954u64 => "NOT_XOF_OR_INVALID_LENGTH", + 25769803907u64 => "NO_CIPHER_SET", + 25769803934u64 => "NO_DEFAULT_DIGEST", + 25769803915u64 => "NO_DIGEST_SET", + 25769803982u64 => "NO_IMPORT_FUNCTION", + 25769803975u64 => "NO_KEYMGMT_AVAILABLE", + 25769803972u64 => "NO_KEYMGMT_PRESENT", + 25769803930u64 => "NO_KEY_SET", + 25769803925u64 => "NO_OPERATION_SET", + 25769803984u64 => "NULL_MAC_PKEY_CTX", + 25769803953u64 => "ONLY_ONESHOT_SUPPORTED", + 25769803927u64 => "OPERATION_NOT_INITIALIZED", + 25769803926u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE", + 25769803978u64 => "OUTPUT_WOULD_OVERFLOW", + 25769803963u64 => "PARAMETER_TOO_LARGE", + 25769803938u64 => "PARTIALLY_OVERLAPPING", + 25769803957u64 => "PBKDF2_ERROR", + 25769803955u64 => "PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED", + 25769803921u64 => "PRIVATE_KEY_DECODE_ERROR", + 25769803922u64 => "PRIVATE_KEY_ENCODE_ERROR", + 25769803882u64 => "PUBLIC_KEY_NOT_RSA", + 25769804003u64 => "SETTING_XOF_FAILED", + 25769803985u64 => "SET_DEFAULT_PROPERTY_FAILURE", + 25769803959u64 => "TOO_MANY_RECORDS", + 25769803988u64 => "UNABLE_TO_ENABLE_LOCKING", + 25769803991u64 => "UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE", + 25769803992u64 => "UNABLE_TO_GET_RANDOM_STRENGTH", + 25769803987u64 => "UNABLE_TO_LOCK_CONTEXT", + 25769803993u64 => "UNABLE_TO_SET_CALLBACKS", + 25769803936u64 => "UNKNOWN_CIPHER", + 25769803937u64 => "UNKNOWN_DIGEST", + 25769803983u64 => "UNKNOWN_KEY_TYPE", + 25769803945u64 => "UNKNOWN_OPTION", + 25769803897u64 => "UNKNOWN_PBE_ALGORITHM", + 25769803932u64 => "UNSUPPORTED_ALGORITHM", + 25769803883u64 => "UNSUPPORTED_CIPHER", + 25769803899u64 => "UNSUPPORTED_KEYLENGTH", + 25769803900u64 => "UNSUPPORTED_KEY_DERIVATION_FUNCTION", + 25769803884u64 => "UNSUPPORTED_KEY_SIZE", + 25769804000u64 => "UNSUPPORTED_KEY_TYPE", + 25769803911u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS", + 25769803901u64 => "UNSUPPORTED_PRF", + 25769803894u64 => "UNSUPPORTED_PRIVATE_KEY_ALGORITHM", + 25769803902u64 => "UNSUPPORTED_SALT_TYPE", + 25769803965u64 => "UPDATE_ERROR", + 25769803946u64 => "WRAP_MODE_NOT_ALLOWED", + 25769803885u64 => "WRONG_FINAL_BLOCK_LENGTH", + 25769803967u64 => "XTS_DATA_UNIT_IS_TOO_LARGE", + 25769803968u64 => "XTS_DUPLICATED_KEYS", + 261993005164u64 => "ASN1_LEN_EXCEEDS_MAX_RESP_LEN", + 261993005156u64 => "CONNECT_FAILURE", + 261993005165u64 => "ERROR_PARSING_ASN1_LENGTH", + 261993005175u64 => "ERROR_PARSING_CONTENT_LENGTH", + 261993005157u64 => "ERROR_PARSING_URL", + 261993005159u64 => "ERROR_RECEIVING", + 261993005158u64 => "ERROR_SENDING", + 261993005184u64 => "FAILED_READING_DATA", + 261993005182u64 => "HEADER_PARSE_ERROR", + 261993005176u64 => "INCONSISTENT_CONTENT_LENGTH", + 261993005179u64 => "INVALID_PORT_NUMBER", + 261993005181u64 => "INVALID_URL_PATH", + 261993005180u64 => "INVALID_URL_SCHEME", + 261993005173u64 => "MAX_RESP_LEN_EXCEEDED", + 261993005166u64 => "MISSING_ASN1_ENCODING", + 261993005177u64 => "MISSING_CONTENT_TYPE", + 261993005167u64 => "MISSING_REDIRECT_LOCATION", + 261993005161u64 => "RECEIVED_ERROR", + 261993005162u64 => "RECEIVED_WRONG_HTTP_VERSION", + 261993005168u64 => "REDIRECTION_FROM_HTTPS_TO_HTTP", + 261993005172u64 => "REDIRECTION_NOT_ENABLED", + 261993005169u64 => "RESPONSE_LINE_TOO_LONG", + 261993005160u64 => "RESPONSE_PARSE_ERROR", + 261993005185u64 => "RETRY_TIMEOUT", + 261993005183u64 => "SERVER_CANCELED_CONNECTION", + 261993005178u64 => "SOCK_NOT_SUPPORTED", + 261993005170u64 => "STATUS_CODE_UNSUPPORTED", + 261993005163u64 => "TLS_NOT_ENABLED", + 261993005171u64 => "TOO_MANY_REDIRECTIONS", + 261993005174u64 => "UNEXPECTED_CONTENT_TYPE", + 34359738470u64 => "OID_EXISTS", + 34359738469u64 => "UNKNOWN_NID", + 34359738471u64 => "UNKNOWN_OBJECT_NAME", + 167503724645u64 => "CERTIFICATE_VERIFY_ERROR", + 167503724646u64 => "DIGEST_ERR", + 167503724650u64 => "DIGEST_NAME_ERR", + 167503724651u64 => "DIGEST_SIZE_ERR", + 167503724666u64 => "ERROR_IN_NEXTUPDATE_FIELD", + 167503724667u64 => "ERROR_IN_THISUPDATE_FIELD", + 167503724647u64 => "MISSING_OCSPSIGNING_USAGE", + 167503724668u64 => "NEXTUPDATE_BEFORE_THISUPDATE", + 167503724648u64 => "NOT_BASIC_RESPONSE", + 167503724649u64 => "NO_CERTIFICATES_IN_CHAIN", + 167503724652u64 => "NO_RESPONSE_DATA", + 167503724653u64 => "NO_REVOKED_TIME", + 167503724674u64 => "NO_SIGNER_KEY", + 167503724654u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 167503724672u64 => "REQUEST_NOT_SIGNED", + 167503724655u64 => "RESPONSE_CONTAINS_NO_REVOCATION_DATA", + 167503724656u64 => "ROOT_CA_NOT_TRUSTED", + 167503724661u64 => "SIGNATURE_FAILURE", + 167503724662u64 => "SIGNER_CERTIFICATE_NOT_FOUND", + 167503724669u64 => "STATUS_EXPIRED", + 167503724670u64 => "STATUS_NOT_YET_VALID", + 167503724671u64 => "STATUS_TOO_OLD", + 167503724663u64 => "UNKNOWN_MESSAGE_DIGEST", + 167503724664u64 => "UNKNOWN_NID", + 167503724673u64 => "UNSUPPORTED_REQUESTORNAME_TYPE", + 257698037861u64 => "COULD_NOT_DECODE_OBJECT", + 257698037862u64 => "DECODER_NOT_FOUND", + 257698037860u64 => "MISSING_GET_PARAMS", + 253403070565u64 => "ENCODER_NOT_FOUND", + 253403070564u64 => "INCORRECT_PROPERTY_QUERY", + 253403070566u64 => "MISSING_GET_PARAMS", + 188978561131u64 => "AMBIGUOUS_CONTENT_TYPE", + 188978561139u64 => "BAD_PASSWORD_READ", + 188978561137u64 => "ERROR_VERIFYING_PKCS12_MAC", + 188978561145u64 => "FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST", + 188978561130u64 => "INVALID_SCHEME", + 188978561136u64 => "IS_NOT_A", + 188978561140u64 => "LOADER_INCOMPLETE", + 188978561141u64 => "LOADING_STARTED", + 188978561124u64 => "NOT_A_CERTIFICATE", + 188978561125u64 => "NOT_A_CRL", + 188978561127u64 => "NOT_A_NAME", + 188978561126u64 => "NOT_A_PRIVATE_KEY", + 188978561146u64 => "NOT_A_PUBLIC_KEY", + 188978561128u64 => "NOT_PARAMETERS", + 188978561147u64 => "NO_LOADERS_FOUND", + 188978561138u64 => "PASSPHRASE_CALLBACK_ERROR", + 188978561132u64 => "PATH_MUST_BE_ABSOLUTE", + 188978561143u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES", + 188978561133u64 => "UI_PROCESS_INTERRUPTED_OR_CANCELLED", + 188978561129u64 => "UNREGISTERED_SCHEME", + 188978561134u64 => "UNSUPPORTED_CONTENT_TYPE", + 188978561142u64 => "UNSUPPORTED_OPERATION", + 188978561144u64 => "UNSUPPORTED_SEARCH_TYPE", + 188978561135u64 => "URI_AUTHORITY_UNSUPPORTED", + 38654705764u64 => "BAD_BASE64_DECODE", + 38654705765u64 => "BAD_DECRYPT", + 38654705766u64 => "BAD_END_LINE", + 38654705767u64 => "BAD_IV_CHARS", + 38654705780u64 => "BAD_MAGIC_NUMBER", + 38654705768u64 => "BAD_PASSWORD_READ", + 38654705781u64 => "BAD_VERSION_NUMBER", + 38654705782u64 => "BIO_WRITE_FAILURE", + 38654705791u64 => "CIPHER_IS_NULL", + 38654705779u64 => "ERROR_CONVERTING_PRIVATE_KEY", + 38654705795u64 => "EXPECTING_DSS_KEY_BLOB", + 38654705783u64 => "EXPECTING_PRIVATE_KEY_BLOB", + 38654705784u64 => "EXPECTING_PUBLIC_KEY_BLOB", + 38654705796u64 => "EXPECTING_RSA_KEY_BLOB", + 38654705792u64 => "HEADER_TOO_LONG", + 38654705785u64 => "INCONSISTENT_HEADER", + 38654705786u64 => "KEYBLOB_HEADER_PARSE_ERROR", + 38654705787u64 => "KEYBLOB_TOO_SHORT", + 38654705793u64 => "MISSING_DEK_IV", + 38654705769u64 => "NOT_DEK_INFO", + 38654705770u64 => "NOT_ENCRYPTED", + 38654705771u64 => "NOT_PROC_TYPE", + 38654705772u64 => "NO_START_LINE", + 38654705773u64 => "PROBLEMS_GETTING_PASSWORD", + 38654705788u64 => "PVK_DATA_TOO_SHORT", + 38654705789u64 => "PVK_TOO_SHORT", + 38654705775u64 => "READ_KEY", + 38654705776u64 => "SHORT_HEADER", + 38654705794u64 => "UNEXPECTED_DEK_IV", + 38654705777u64 => "UNSUPPORTED_CIPHER", + 38654705778u64 => "UNSUPPORTED_ENCRYPTION", + 38654705790u64 => "UNSUPPORTED_KEY_COMPONENTS", + 38654705774u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE", + 150323855460u64 => "CANT_PACK_STRUCTURE", + 150323855481u64 => "CONTENT_TYPE_NOT_DATA", + 150323855461u64 => "DECODE_ERROR", + 150323855462u64 => "ENCODE_ERROR", + 150323855463u64 => "ENCRYPT_ERROR", + 150323855480u64 => "ERROR_SETTING_ENCRYPTED_DATA_TYPE", + 150323855464u64 => "INVALID_NULL_ARGUMENT", + 150323855465u64 => "INVALID_NULL_PKCS12_POINTER", + 150323855472u64 => "INVALID_TYPE", + 150323855466u64 => "IV_GEN_ERROR", + 150323855467u64 => "KEY_GEN_ERROR", + 150323855468u64 => "MAC_ABSENT", + 150323855469u64 => "MAC_GENERATION_ERROR", + 150323855470u64 => "MAC_SETUP_ERROR", + 150323855471u64 => "MAC_STRING_SET_ERROR", + 150323855473u64 => "MAC_VERIFY_FAILURE", + 150323855474u64 => "PARSE_ERROR", + 150323855476u64 => "PKCS12_CIPHERFINAL_ERROR", + 150323855478u64 => "UNKNOWN_DIGEST_ALGORITHM", + 150323855479u64 => "UNSUPPORTED_PKCS12_MODE", + 141733920885u64 => "CERTIFICATE_VERIFY_ERROR", + 141733920912u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER", + 141733920884u64 => "CIPHER_NOT_INITIALIZED", + 141733920886u64 => "CONTENT_AND_DATA_PRESENT", + 141733920920u64 => "CTRL_ERROR", + 141733920887u64 => "DECRYPT_ERROR", + 141733920869u64 => "DIGEST_FAILURE", + 141733920917u64 => "ENCRYPTION_CTRL_FAILURE", + 141733920918u64 => "ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE", + 141733920888u64 => "ERROR_ADDING_RECIPIENT", + 141733920889u64 => "ERROR_SETTING_CIPHER", + 141733920911u64 => "INVALID_NULL_POINTER", + 141733920923u64 => "INVALID_SIGNED_DATA_TYPE", + 141733920890u64 => "NO_CONTENT", + 141733920919u64 => "NO_DEFAULT_DIGEST", + 141733920922u64 => "NO_MATCHING_DIGEST_TYPE_FOUND", + 141733920883u64 => "NO_RECIPIENT_MATCHES_CERTIFICATE", + 141733920891u64 => "NO_SIGNATURES_ON_DATA", + 141733920910u64 => "NO_SIGNERS", + 141733920872u64 => "OPERATION_NOT_SUPPORTED_ON_THIS_TYPE", + 141733920892u64 => "PKCS7_ADD_SIGNATURE_ERROR", + 141733920921u64 => "PKCS7_ADD_SIGNER_ERROR", + 141733920913u64 => "PKCS7_DATASIGN", + 141733920895u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 141733920873u64 => "SIGNATURE_FAILURE", + 141733920896u64 => "SIGNER_CERTIFICATE_NOT_FOUND", + 141733920915u64 => "SIGNING_CTRL_FAILURE", + 141733920916u64 => "SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE", + 141733920897u64 => "SMIME_TEXT_ERROR", + 141733920874u64 => "UNABLE_TO_FIND_CERTIFICATE", + 141733920875u64 => "UNABLE_TO_FIND_MEM_BIO", + 141733920876u64 => "UNABLE_TO_FIND_MESSAGE_DIGEST", + 141733920877u64 => "UNKNOWN_DIGEST_TYPE", + 141733920878u64 => "UNKNOWN_OPERATION", + 141733920879u64 => "UNSUPPORTED_CIPHER_TYPE", + 141733920880u64 => "UNSUPPORTED_CONTENT_TYPE", + 141733920881u64 => "WRONG_CONTENT_TYPE", + 141733920882u64 => "WRONG_PKCS7_TYPE", + 236223201380u64 => "NAME_TOO_LONG", + 236223201381u64 => "NOT_AN_ASCII_CHARACTER", + 236223201382u64 => "NOT_AN_HEXADECIMAL_DIGIT", + 236223201383u64 => "NOT_AN_IDENTIFIER", + 236223201384u64 => "NOT_AN_OCTAL_DIGIT", + 236223201385u64 => "NOT_A_DECIMAL_DIGIT", + 236223201386u64 => "NO_MATCHING_STRING_DELIMITER", + 236223201387u64 => "NO_VALUE", + 236223201388u64 => "PARSE_FAILED", + 236223201389u64 => "STRING_TOO_LONG", + 236223201390u64 => "TRAILING_CHARACTERS", + 244813136056u64 => "ADDITIONAL_INPUT_TOO_LONG", + 244813136045u64 => "ALGORITHM_MISMATCH", + 244813136057u64 => "ALREADY_INSTANTIATED", + 244813135972u64 => "BAD_DECRYPT", + 244813136013u64 => "BAD_ENCODING", + 244813136014u64 => "BAD_LENGTH", + 244813136033u64 => "BAD_TLS_CLIENT_VERSION", + 244813136032u64 => "BN_ERROR", + 244813135974u64 => "CIPHER_OPERATION_FAILED", + 244813136077u64 => "DERIVATION_FUNCTION_INIT_FAILED", + 244813136046u64 => "DIGEST_NOT_ALLOWED", + 244813136105u64 => "EMS_NOT_ENABLED", + 244813136058u64 => "ENTROPY_SOURCE_STRENGTH_TOO_WEAK", + 244813136060u64 => "ERROR_INSTANTIATING_DRBG", + 244813136061u64 => "ERROR_RETRIEVING_ENTROPY", + 244813136062u64 => "ERROR_RETRIEVING_NONCE", + 244813136036u64 => "FAILED_DURING_DERIVATION", + 244813136052u64 => "FAILED_TO_CREATE_LOCK", + 244813136034u64 => "FAILED_TO_DECRYPT", + 244813135993u64 => "FAILED_TO_GENERATE_KEY", + 244813135975u64 => "FAILED_TO_GET_PARAMETER", + 244813135976u64 => "FAILED_TO_SET_PARAMETER", + 244813136047u64 => "FAILED_TO_SIGN", + 244813136099u64 => "FIPS_MODULE_CONDITIONAL_ERROR", + 244813136096u64 => "FIPS_MODULE_ENTERING_ERROR_STATE", + 244813136097u64 => "FIPS_MODULE_IN_ERROR_STATE", + 244813136063u64 => "GENERATE_ERROR", + 244813136037u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE", + 244813136082u64 => "INDICATOR_INTEGRITY_FAILURE", + 244813136053u64 => "INSUFFICIENT_DRBG_STRENGTH", + 244813135980u64 => "INVALID_AAD", + 244813136083u64 => "INVALID_CONFIG_DATA", + 244813136029u64 => "INVALID_CONSTANT_LENGTH", + 244813136048u64 => "INVALID_CURVE", + 244813135983u64 => "INVALID_CUSTOM_LENGTH", + 244813135987u64 => "INVALID_DATA", + 244813135994u64 => "INVALID_DIGEST", + 244813136038u64 => "INVALID_DIGEST_LENGTH", + 244813136090u64 => "INVALID_DIGEST_SIZE", + 244813136102u64 => "INVALID_INPUT_LENGTH", + 244813135995u64 => "INVALID_ITERATION_COUNT", + 244813135981u64 => "INVALID_IV_LENGTH", + 244813136030u64 => "INVALID_KEY", + 244813135977u64 => "INVALID_KEY_LENGTH", + 244813136023u64 => "INVALID_MAC", + 244813136039u64 => "INVALID_MGF1_MD", + 244813135997u64 => "INVALID_MODE", + 244813136089u64 => "INVALID_OUTPUT_LENGTH", + 244813136040u64 => "INVALID_PADDING_MODE", + 244813136070u64 => "INVALID_PUBINFO", + 244813135984u64 => "INVALID_SALT_LENGTH", + 244813136026u64 => "INVALID_SEED_LENGTH", + 244813136051u64 => "INVALID_SIGNATURE_SIZE", + 244813136084u64 => "INVALID_STATE", + 244813135982u64 => "INVALID_TAG", + 244813135990u64 => "INVALID_TAG_LENGTH", + 244813136072u64 => "INVALID_UKM_LENGTH", + 244813136042u64 => "INVALID_X931_DIGEST", + 244813136064u64 => "IN_ERROR_STATE", + 244813135973u64 => "KEY_SETUP_FAILED", + 244813136043u64 => "KEY_SIZE_TOO_SMALL", + 244813136074u64 => "LENGTH_TOO_LARGE", + 244813136075u64 => "MISMATCHING_DOMAIN_PARAMETERS", + 244813136016u64 => "MISSING_CEK_ALG", + 244813136027u64 => "MISSING_CIPHER", + 244813136085u64 => "MISSING_CONFIG_DATA", + 244813136028u64 => "MISSING_CONSTANT", + 244813136000u64 => "MISSING_KEY", + 244813136022u64 => "MISSING_MAC", + 244813136001u64 => "MISSING_MESSAGE_DIGEST", + 244813136081u64 => "MISSING_OID", + 244813136002u64 => "MISSING_PASS", + 244813136003u64 => "MISSING_SALT", + 244813136004u64 => "MISSING_SECRET", + 244813136012u64 => "MISSING_SEED", + 244813136005u64 => "MISSING_SESSION_ID", + 244813136006u64 => "MISSING_TYPE", + 244813136007u64 => "MISSING_XCGHASH", + 244813136086u64 => "MODULE_INTEGRITY_FAILURE", + 244813136093u64 => "NOT_A_PRIVATE_KEY", + 244813136092u64 => "NOT_A_PUBLIC_KEY", + 244813136065u64 => "NOT_INSTANTIATED", + 244813136098u64 => "NOT_PARAMETERS", + 244813136008u64 => "NOT_SUPPORTED", + 244813135985u64 => "NOT_XOF_OR_INVALID_LENGTH", + 244813135986u64 => "NO_KEY_SET", + 244813136049u64 => "NO_PARAMETERS_SET", + 244813136050u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE", + 244813135978u64 => "OUTPUT_BUFFER_TOO_SMALL", + 244813136100u64 => "PARENT_CANNOT_GENERATE_RANDOM_NUMBERS", + 244813136059u64 => "PARENT_CANNOT_SUPPLY_ENTROPY_SEED", + 244813136054u64 => "PARENT_LOCKING_NOT_ENABLED", + 244813136066u64 => "PARENT_STRENGTH_TOO_WEAK", + 244813136091u64 => "PATH_MUST_BE_ABSOLUTE", + 244813136067u64 => "PERSONALISATION_STRING_TOO_LONG", + 244813136044u64 => "PSS_SALTLEN_TOO_SMALL", + 244813136068u64 => "REQUEST_TOO_LARGE_FOR_DRBG", + 244813136078u64 => "REQUIRE_CTR_MODE_CIPHER", + 244813136069u64 => "RESEED_ERROR", + 244813136094u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES", + 244813136101u64 => "SEED_SOURCES_MUST_NOT_HAVE_A_PARENT", + 244813136087u64 => "SELF_TEST_KAT_FAILURE", + 244813136088u64 => "SELF_TEST_POST_FAILURE", + 244813135992u64 => "TAG_NOT_NEEDED", + 244813135991u64 => "TAG_NOT_SET", + 244813135998u64 => "TOO_MANY_RECORDS", + 244813136079u64 => "UNABLE_TO_FIND_CIPHERS", + 244813136071u64 => "UNABLE_TO_GET_PARENT_STRENGTH", + 244813136031u64 => "UNABLE_TO_GET_PASSPHRASE", + 244813136080u64 => "UNABLE_TO_INITIALISE_CIPHERS", + 244813136019u64 => "UNABLE_TO_LOAD_SHA256", + 244813136073u64 => "UNABLE_TO_LOCK_PARENT", + 244813136076u64 => "UNABLE_TO_RESEED", + 244813136017u64 => "UNSUPPORTED_CEK_ALG", + 244813136025u64 => "UNSUPPORTED_KEY_SIZE", + 244813136009u64 => "UNSUPPORTED_MAC_TYPE", + 244813136024u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS", + 244813136095u64 => "URI_AUTHORITY_UNSUPPORTED", + 244813136010u64 => "VALUE_ERROR", + 244813135979u64 => "WRONG_FINAL_BLOCK_LENGTH", + 244813136011u64 => "WRONG_OUTPUT_BUFFER_SIZE", + 244813136055u64 => "XOF_DIGESTS_NOT_ALLOWED", + 244813136020u64 => "XTS_DATA_UNIT_IS_TOO_LARGE", + 244813136021u64 => "XTS_DUPLICATED_KEYS", + 154618822758u64 => "ADDITIONAL_INPUT_TOO_LONG", + 154618822759u64 => "ALREADY_INSTANTIATED", + 154618822761u64 => "ARGUMENT_OUT_OF_RANGE", + 154618822777u64 => "CANNOT_OPEN_FILE", + 154618822785u64 => "DRBG_ALREADY_INITIALIZED", + 154618822760u64 => "DRBG_NOT_INITIALISED", + 154618822762u64 => "ENTROPY_INPUT_TOO_LONG", + 154618822780u64 => "ENTROPY_OUT_OF_RANGE", + 154618822783u64 => "ERROR_ENTROPY_POOL_WAS_IGNORED", + 154618822763u64 => "ERROR_INITIALISING_DRBG", + 154618822764u64 => "ERROR_INSTANTIATING_DRBG", + 154618822765u64 => "ERROR_RETRIEVING_ADDITIONAL_INPUT", + 154618822766u64 => "ERROR_RETRIEVING_ENTROPY", + 154618822767u64 => "ERROR_RETRIEVING_NONCE", + 154618822782u64 => "FAILED_TO_CREATE_LOCK", + 154618822757u64 => "FUNC_NOT_IMPLEMENTED", + 154618822779u64 => "FWRITE_ERROR", + 154618822768u64 => "GENERATE_ERROR", + 154618822795u64 => "INSUFFICIENT_DRBG_STRENGTH", + 154618822769u64 => "INTERNAL_ERROR", + 154618822793u64 => "INVALID_PROPERTY_QUERY", + 154618822770u64 => "IN_ERROR_STATE", + 154618822778u64 => "NOT_A_REGULAR_FILE", + 154618822771u64 => "NOT_INSTANTIATED", + 154618822784u64 => "NO_DRBG_IMPLEMENTATION_SELECTED", + 154618822786u64 => "PARENT_LOCKING_NOT_ENABLED", + 154618822787u64 => "PARENT_STRENGTH_TOO_WEAK", + 154618822772u64 => "PERSONALISATION_STRING_TOO_LONG", + 154618822789u64 => "PREDICTION_RESISTANCE_NOT_SUPPORTED", + 154618822756u64 => "PRNG_NOT_SEEDED", + 154618822781u64 => "RANDOM_POOL_OVERFLOW", + 154618822790u64 => "RANDOM_POOL_UNDERFLOW", + 154618822773u64 => "REQUEST_TOO_LARGE_FOR_DRBG", + 154618822774u64 => "RESEED_ERROR", + 154618822775u64 => "SELFTEST_FAILURE", + 154618822791u64 => "TOO_LITTLE_NONCE_REQUESTED", + 154618822792u64 => "TOO_MUCH_NONCE_REQUESTED", + 154618822799u64 => "UNABLE_TO_CREATE_DRBG", + 154618822800u64 => "UNABLE_TO_FETCH_DRBG", + 154618822797u64 => "UNABLE_TO_GET_PARENT_RESEED_PROP_COUNTER", + 154618822794u64 => "UNABLE_TO_GET_PARENT_STRENGTH", + 154618822796u64 => "UNABLE_TO_LOCK_PARENT", + 154618822788u64 => "UNSUPPORTED_DRBG_FLAGS", + 154618822776u64 => "UNSUPPORTED_DRBG_TYPE", + 17179869284u64 => "ALGORITHM_MISMATCH", + 17179869285u64 => "BAD_E_VALUE", + 17179869286u64 => "BAD_FIXED_HEADER_DECRYPT", + 17179869287u64 => "BAD_PAD_BYTE_COUNT", + 17179869288u64 => "BAD_SIGNATURE", + 17179869290u64 => "BLOCK_TYPE_IS_NOT_01", + 17179869291u64 => "BLOCK_TYPE_IS_NOT_02", + 17179869292u64 => "DATA_GREATER_THAN_MOD_LEN", + 17179869293u64 => "DATA_TOO_LARGE", + 17179869294u64 => "DATA_TOO_LARGE_FOR_KEY_SIZE", + 17179869316u64 => "DATA_TOO_LARGE_FOR_MODULUS", + 17179869295u64 => "DATA_TOO_SMALL", + 17179869306u64 => "DATA_TOO_SMALL_FOR_KEY_SIZE", + 17179869342u64 => "DIGEST_DOES_NOT_MATCH", + 17179869329u64 => "DIGEST_NOT_ALLOWED", + 17179869296u64 => "DIGEST_TOO_BIG_FOR_RSA_KEY", + 17179869308u64 => "DMP1_NOT_CONGRUENT_TO_D", + 17179869309u64 => "DMQ1_NOT_CONGRUENT_TO_D", + 17179869307u64 => "D_E_NOT_CONGRUENT_TO_1", + 17179869317u64 => "FIRST_OCTET_INVALID", + 17179869328u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE", + 17179869341u64 => "INVALID_DIGEST", + 17179869327u64 => "INVALID_DIGEST_LENGTH", + 17179869321u64 => "INVALID_HEADER", + 17179869355u64 => "INVALID_KEYPAIR", + 17179869357u64 => "INVALID_KEY_LENGTH", + 17179869344u64 => "INVALID_LABEL", + 17179869365u64 => "INVALID_LENGTH", + 17179869315u64 => "INVALID_MESSAGE_LENGTH", + 17179869340u64 => "INVALID_MGF1_MD", + 17179869358u64 => "INVALID_MODULUS", + 17179869351u64 => "INVALID_MULTI_PRIME_KEY", + 17179869345u64 => "INVALID_OAEP_PARAMETERS", + 17179869322u64 => "INVALID_PADDING", + 17179869325u64 => "INVALID_PADDING_MODE", + 17179869333u64 => "INVALID_PSS_PARAMETERS", + 17179869330u64 => "INVALID_PSS_SALTLEN", + 17179869359u64 => "INVALID_REQUEST", + 17179869334u64 => "INVALID_SALT_LENGTH", + 17179869360u64 => "INVALID_STRENGTH", + 17179869323u64 => "INVALID_TRAILER", + 17179869326u64 => "INVALID_X931_DIGEST", + 17179869310u64 => "IQMP_NOT_INVERSE_OF_Q", + 17179869349u64 => "KEY_PRIME_NUM_INVALID", + 17179869304u64 => "KEY_SIZE_TOO_SMALL", + 17179869318u64 => "LAST_OCTET_INVALID", + 17179869336u64 => "MGF1_DIGEST_NOT_ALLOWED", + 17179869363u64 => "MISSING_PRIVATE_KEY", + 17179869289u64 => "MODULUS_TOO_LARGE", + 17179869352u64 => "MP_COEFFICIENT_NOT_INVERSE_OF_R", + 17179869353u64 => "MP_EXPONENT_NOT_CONGRUENT_TO_D", + 17179869354u64 => "MP_R_NOT_PRIME", + 17179869324u64 => "NO_PUBLIC_EXPONENT", + 17179869297u64 => "NULL_BEFORE_BLOCK_MISSING", + 17179869356u64 => "N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES", + 17179869311u64 => "N_DOES_NOT_EQUAL_P_Q", + 17179869305u64 => "OAEP_DECODING_ERROR", + 17179869332u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE", + 17179869298u64 => "PADDING_CHECK_FAILED", + 17179869361u64 => "PAIRWISE_TEST_FAILURE", + 17179869343u64 => "PKCS_DECODING_ERROR", + 17179869348u64 => "PSS_SALTLEN_TOO_SMALL", + 17179869362u64 => "PUB_EXPONENT_OUT_OF_RANGE", + 17179869312u64 => "P_NOT_PRIME", + 17179869313u64 => "Q_NOT_PRIME", + 17179869364u64 => "RANDOMNESS_SOURCE_STRENGTH_INSUFFICIENT", + 17179869314u64 => "RSA_OPERATIONS_NOT_SUPPORTED", + 17179869320u64 => "SLEN_CHECK_FAILED", + 17179869319u64 => "SLEN_RECOVERY_FAILED", + 17179869299u64 => "SSLV3_ROLLBACK_ATTACK", + 17179869300u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD", + 17179869301u64 => "UNKNOWN_ALGORITHM_TYPE", + 17179869350u64 => "UNKNOWN_DIGEST", + 17179869335u64 => "UNKNOWN_MASK_DIGEST", + 17179869302u64 => "UNKNOWN_PADDING_TYPE", + 17179869346u64 => "UNSUPPORTED_ENCRYPTION_TYPE", + 17179869347u64 => "UNSUPPORTED_LABEL_SOURCE", + 17179869337u64 => "UNSUPPORTED_MASK_ALGORITHM", + 17179869338u64 => "UNSUPPORTED_MASK_PARAMETER", + 17179869339u64 => "UNSUPPORTED_SIGNATURE_TYPE", + 17179869331u64 => "VALUE_MISSING", + 17179869303u64 => "WRONG_SIGNATURE_LENGTH", + 227633266788u64 => "ASN1_ERROR", + 227633266789u64 => "BAD_SIGNATURE", + 227633266795u64 => "BUFFER_TOO_SMALL", + 227633266798u64 => "DIST_ID_TOO_LARGE", + 227633266800u64 => "ID_NOT_SET", + 227633266799u64 => "ID_TOO_LARGE", + 227633266796u64 => "INVALID_CURVE", + 227633266790u64 => "INVALID_DIGEST", + 227633266791u64 => "INVALID_DIGEST_TYPE", + 227633266792u64 => "INVALID_ENCODING", + 227633266793u64 => "INVALID_FIELD", + 227633266801u64 => "INVALID_PRIVATE_KEY", + 227633266797u64 => "NO_PARAMETERS_SET", + 227633266794u64 => "USER_ID_TOO_LARGE", + 85899346211u64 => "APPLICATION_DATA_AFTER_CLOSE_NOTIFY", + 85899346020u64 => "APP_DATA_IN_HANDSHAKE", + 85899346192u64 => "ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT", + 85899346078u64 => "AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE", + 85899346023u64 => "BAD_CHANGE_CIPHER_SPEC", + 85899346106u64 => "BAD_CIPHER", + 85899346310u64 => "BAD_DATA", + 85899346026u64 => "BAD_DATA_RETURNED_BY_CALLBACK", + 85899346027u64 => "BAD_DECOMPRESSION", + 85899346022u64 => "BAD_DH_VALUE", + 85899346031u64 => "BAD_DIGEST_LENGTH", + 85899346153u64 => "BAD_EARLY_DATA", + 85899346224u64 => "BAD_ECC_CERT", + 85899346226u64 => "BAD_ECPOINT", + 85899346030u64 => "BAD_EXTENSION", + 85899346252u64 => "BAD_HANDSHAKE_LENGTH", + 85899346156u64 => "BAD_HANDSHAKE_STATE", + 85899346025u64 => "BAD_HELLO_REQUEST", + 85899346183u64 => "BAD_HRR_VERSION", + 85899346028u64 => "BAD_KEY_SHARE", + 85899346042u64 => "BAD_KEY_UPDATE", + 85899346212u64 => "BAD_LEGACY_VERSION", + 85899346191u64 => "BAD_LENGTH", + 85899346160u64 => "BAD_PACKET", + 85899346035u64 => "BAD_PACKET_LENGTH", + 85899346036u64 => "BAD_PROTOCOL_VERSION_NUMBER", + 85899346139u64 => "BAD_PSK", + 85899346034u64 => "BAD_PSK_IDENTITY", + 85899346363u64 => "BAD_RECORD_TYPE", + 85899346039u64 => "BAD_RSA_ENCRYPT", + 85899346043u64 => "BAD_SIGNATURE", + 85899346267u64 => "BAD_SRP_A_LENGTH", + 85899346291u64 => "BAD_SRP_PARAMETERS", + 85899346272u64 => "BAD_SRTP_MKI_VALUE", + 85899346273u64 => "BAD_SRTP_PROTECTION_PROFILE_LIST", + 85899346044u64 => "BAD_SSL_FILETYPE", + 85899346304u64 => "BAD_VALUE", + 85899346047u64 => "BAD_WRITE_RETRY", + 85899346173u64 => "BINDER_DOES_NOT_VERIFY", + 85899346048u64 => "BIO_NOT_SET", + 85899346049u64 => "BLOCK_CIPHER_PAD_IS_WRONG", + 85899346050u64 => "BN_LIB", + 85899346154u64 => "CALLBACK_FAILED", + 85899346029u64 => "CANNOT_CHANGE_CIPHER", + 85899346219u64 => "CANNOT_GET_GROUP_NAME", + 85899346051u64 => "CA_DN_LENGTH_MISMATCH", + 85899346317u64 => "CA_KEY_TOO_SMALL", + 85899346318u64 => "CA_MD_TOO_WEAK", + 85899346053u64 => "CCS_RECEIVED_EARLY", + 85899346054u64 => "CERTIFICATE_VERIFY_FAILED", + 85899346297u64 => "CERT_CB_ERROR", + 85899346055u64 => "CERT_LENGTH_MISMATCH", + 85899346138u64 => "CIPHERSUITE_DIGEST_HAS_CHANGED", + 85899346057u64 => "CIPHER_CODE_WRONG_LENGTH", + 85899346146u64 => "CLIENTHELLO_TLSEXT", + 85899346060u64 => "COMPRESSED_LENGTH_TOO_LONG", + 85899346263u64 => "COMPRESSION_DISABLED", + 85899346061u64 => "COMPRESSION_FAILURE", + 85899346227u64 => "COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE", + 85899346062u64 => "COMPRESSION_LIBRARY_ERROR", + 85899346064u64 => "CONNECTION_TYPE_NOT_SET", + 85899346087u64 => "CONTEXT_NOT_DANE_ENABLED", + 85899346320u64 => "COOKIE_GEN_CALLBACK_FAILURE", + 85899346228u64 => "COOKIE_MISMATCH", + 85899346216u64 => "COPY_PARAMETERS_FAILED", + 85899346126u64 => "CUSTOM_EXT_HANDLER_ALREADY_INSTALLED", + 85899346092u64 => "DANE_ALREADY_ENABLED", + 85899346093u64 => "DANE_CANNOT_OVERRIDE_MTYPE_FULL", + 85899346095u64 => "DANE_NOT_ENABLED", + 85899346100u64 => "DANE_TLSA_BAD_CERTIFICATE", + 85899346104u64 => "DANE_TLSA_BAD_CERTIFICATE_USAGE", + 85899346109u64 => "DANE_TLSA_BAD_DATA_LENGTH", + 85899346112u64 => "DANE_TLSA_BAD_DIGEST_LENGTH", + 85899346120u64 => "DANE_TLSA_BAD_MATCHING_TYPE", + 85899346121u64 => "DANE_TLSA_BAD_PUBLIC_KEY", + 85899346122u64 => "DANE_TLSA_BAD_SELECTOR", + 85899346123u64 => "DANE_TLSA_NULL_DATA", + 85899346065u64 => "DATA_BETWEEN_CCS_AND_FINISHED", + 85899346066u64 => "DATA_LENGTH_TOO_LONG", + 85899346067u64 => "DECRYPTION_FAILED", + 85899346201u64 => "DECRYPTION_FAILED_OR_BAD_RECORD_MAC", + 85899346314u64 => "DH_KEY_TOO_SMALL", + 85899346068u64 => "DH_PUBLIC_VALUE_LENGTH_IS_WRONG", + 85899346069u64 => "DIGEST_CHECK_FAILED", + 85899346254u64 => "DTLS_MESSAGE_TOO_BIG", + 85899346229u64 => "DUPLICATE_COMPRESSION_ID", + 85899346238u64 => "ECC_CERT_NOT_FOR_SIGNING", + 85899346294u64 => "ECDH_REQUIRED_FOR_SUITEB_MODE", + 85899346319u64 => "EE_KEY_TOO_SMALL", + 85899346274u64 => "EMPTY_SRTP_PROTECTION_PROFILE_LIST", + 85899346070u64 => "ENCRYPTED_LENGTH_TOO_LONG", + 85899346071u64 => "ERROR_IN_RECEIVED_CIPHER_LIST", + 85899346124u64 => "ERROR_SETTING_TLSA_BASE_DOMAIN", + 85899346114u64 => "EXCEEDS_MAX_FRAGMENT_SIZE", + 85899346072u64 => "EXCESSIVE_MESSAGE_SIZE", + 85899346199u64 => "EXTENSION_NOT_RECEIVED", + 85899346073u64 => "EXTRA_DATA_IN_MESSAGE", + 85899346083u64 => "EXT_LENGTH_MISMATCH", + 85899346325u64 => "FAILED_TO_INIT_ASYNC", + 85899346321u64 => "FRAGMENTED_CLIENT_HELLO", + 85899346074u64 => "GOT_A_FIN_BEFORE_A_CCS", + 85899346075u64 => "HTTPS_PROXY_REQUEST", + 85899346076u64 => "HTTP_REQUEST", + 85899346082u64 => "ILLEGAL_POINT_COMPRESSION", + 85899346300u64 => "ILLEGAL_SUITEB_DIGEST", + 85899346293u64 => "INAPPROPRIATE_FALLBACK", + 85899346260u64 => "INCONSISTENT_COMPRESSION", + 85899346142u64 => "INCONSISTENT_EARLY_DATA_ALPN", + 85899346151u64 => "INCONSISTENT_EARLY_DATA_SNI", + 85899346024u64 => "INCONSISTENT_EXTMS", + 85899346161u64 => "INSUFFICIENT_SECURITY", + 85899346125u64 => "INVALID_ALERT", + 85899346180u64 => "INVALID_CCS_MESSAGE", + 85899346158u64 => "INVALID_CERTIFICATE_OR_ALG", + 85899346200u64 => "INVALID_COMMAND", + 85899346261u64 => "INVALID_COMPRESSION_ALGORITHM", + 85899346203u64 => "INVALID_CONFIG", + 85899346033u64 => "INVALID_CONFIGURATION_NAME", + 85899346202u64 => "INVALID_CONTEXT", + 85899346132u64 => "INVALID_CT_VALIDATION_TYPE", + 85899346040u64 => "INVALID_KEY_UPDATE_TYPE", + 85899346094u64 => "INVALID_MAX_EARLY_DATA", + 85899346305u64 => "INVALID_NULL_CMD_NAME", + 85899346322u64 => "INVALID_SEQUENCE_NUMBER", + 85899346308u64 => "INVALID_SERVERINFO_DATA", + 85899346919u64 => "INVALID_SESSION_ID", + 85899346277u64 => "INVALID_SRP_USERNAME", + 85899346248u64 => "INVALID_STATUS_RESPONSE", + 85899346245u64 => "INVALID_TICKET_KEYS_LENGTH", + 85899346253u64 => "LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED", + 85899346079u64 => "LENGTH_MISMATCH", + 85899346324u64 => "LENGTH_TOO_LONG", + 85899346080u64 => "LENGTH_TOO_SHORT", + 85899346194u64 => "LIBRARY_BUG", + 85899346081u64 => "LIBRARY_HAS_NO_CIPHERS", + 85899346085u64 => "MISSING_DSA_SIGNING_CERT", + 85899346301u64 => "MISSING_ECDSA_SIGNING_CERT", + 85899346176u64 => "MISSING_FATAL", + 85899346210u64 => "MISSING_PARAMETERS", + 85899346230u64 => "MISSING_PSK_KEX_MODES_EXTENSION", + 85899346088u64 => "MISSING_RSA_CERTIFICATE", + 85899346089u64 => "MISSING_RSA_ENCRYPTING_CERT", + 85899346090u64 => "MISSING_RSA_SIGNING_CERT", + 85899346032u64 => "MISSING_SIGALGS_EXTENSION", + 85899346141u64 => "MISSING_SIGNING_CERT", + 85899346278u64 => "MISSING_SRP_PARAM", + 85899346129u64 => "MISSING_SUPPORTED_GROUPS_EXTENSION", + 85899346091u64 => "MISSING_TMP_DH_KEY", + 85899346231u64 => "MISSING_TMP_ECDH_KEY", + 85899346213u64 => "MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA", + 85899346102u64 => "NOT_ON_RECORD_BOUNDARY", + 85899346209u64 => "NOT_REPLACING_CERTIFICATE", + 85899346204u64 => "NOT_SERVER", + 85899346155u64 => "NO_APPLICATION_PROTOCOL", + 85899346096u64 => "NO_CERTIFICATES_RETURNED", + 85899346097u64 => "NO_CERTIFICATE_ASSIGNED", + 85899346099u64 => "NO_CERTIFICATE_SET", + 85899346134u64 => "NO_CHANGE_FOLLOWING_HRR", + 85899346101u64 => "NO_CIPHERS_AVAILABLE", + 85899346103u64 => "NO_CIPHERS_SPECIFIED", + 85899346105u64 => "NO_CIPHER_MATCH", + 85899346251u64 => "NO_CLIENT_CERT_METHOD", + 85899346107u64 => "NO_COMPRESSION_SPECIFIED", + 85899346207u64 => "NO_COOKIE_CALLBACK_SET", + 85899346250u64 => "NO_GOST_CERTIFICATE_SENT_BY_PEER", + 85899346108u64 => "NO_METHOD_SPECIFIED", + 85899346309u64 => "NO_PEM_EXTENSIONS", + 85899346110u64 => "NO_PRIVATE_KEY_ASSIGNED", + 85899346111u64 => "NO_PROTOCOLS_AVAILABLE", + 85899346259u64 => "NO_RENEGOTIATION", + 85899346244u64 => "NO_REQUIRED_DIGEST", + 85899346113u64 => "NO_SHARED_CIPHER", + 85899346330u64 => "NO_SHARED_GROUPS", + 85899346296u64 => "NO_SHARED_SIGNATURE_ALGORITHMS", + 85899346279u64 => "NO_SRTP_PROFILES", + 85899346217u64 => "NO_SUITABLE_DIGEST_ALGORITHM", + 85899346215u64 => "NO_SUITABLE_GROUPS", + 85899346021u64 => "NO_SUITABLE_KEY_SHARE", + 85899346038u64 => "NO_SUITABLE_SIGNATURE_ALGORITHM", + 85899346136u64 => "NO_VALID_SCTS", + 85899346323u64 => "NO_VERIFY_COOKIE_CALLBACK", + 85899346115u64 => "NULL_SSL_CTX", + 85899346116u64 => "NULL_SSL_METHOD_PASSED", + 85899346225u64 => "OCSP_CALLBACK_FAILURE", + 85899346117u64 => "OLD_SESSION_CIPHER_NOT_RETURNED", + 85899346264u64 => "OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED", + 85899346157u64 => "OVERFLOW_ERROR", + 85899346118u64 => "PACKET_LENGTH_TOO_LONG", + 85899346147u64 => "PARSE_TLSEXT", + 85899346190u64 => "PATH_TOO_LONG", + 85899346119u64 => "PEER_DID_NOT_RETURN_A_CERTIFICATE", + 85899346311u64 => "PEM_NAME_BAD_PREFIX", + 85899346312u64 => "PEM_NAME_TOO_SHORT", + 85899346326u64 => "PIPELINE_FAILURE", + 85899346198u64 => "POST_HANDSHAKE_AUTH_ENCODING_ERR", + 85899346208u64 => "PRIVATE_KEY_MISMATCH", + 85899346127u64 => "PROTOCOL_IS_SHUTDOWN", + 85899346143u64 => "PSK_IDENTITY_NOT_FOUND", + 85899346144u64 => "PSK_NO_CLIENT_CB", + 85899346145u64 => "PSK_NO_SERVER_CB", + 85899346131u64 => "READ_BIO_NOT_SET", + 85899346232u64 => "READ_TIMEOUT_EXPIRED", + 85899346133u64 => "RECORD_LENGTH_MISMATCH", + 85899346218u64 => "RECORD_TOO_SMALL", + 85899346255u64 => "RENEGOTIATE_EXT_TOO_LONG", + 85899346256u64 => "RENEGOTIATION_ENCODING_ERR", + 85899346257u64 => "RENEGOTIATION_MISMATCH", + 85899346205u64 => "REQUEST_PENDING", + 85899346206u64 => "REQUEST_SENT", + 85899346135u64 => "REQUIRED_CIPHER_MISSING", + 85899346262u64 => "REQUIRED_COMPRESSION_ALGORITHM_MISSING", + 85899346265u64 => "SCSV_RECEIVED_WHEN_RENEGOTIATING", + 85899346128u64 => "SCT_VERIFICATION_FAILED", + 85899346195u64 => "SERVERHELLO_TLSEXT", + 85899346197u64 => "SESSION_ID_CONTEXT_UNINITIALIZED", + 85899346327u64 => "SHUTDOWN_WHILE_IN_INIT", + 85899346280u64 => "SIGNATURE_ALGORITHMS_ERROR", + 85899346140u64 => "SIGNATURE_FOR_NON_SIGNING_CERTIFICATE", + 85899346281u64 => "SRP_A_CALC", + 85899346282u64 => "SRTP_COULD_NOT_ALLOCATE_PROFILES", + 85899346283u64 => "SRTP_PROTECTION_PROFILE_LIST_TOO_LONG", + 85899346284u64 => "SRTP_UNKNOWN_PROTECTION_PROFILE", + 85899346152u64 => "SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH", + 85899346239u64 => "SSL3_EXT_INVALID_SERVERNAME", + 85899346240u64 => "SSL3_EXT_INVALID_SERVERNAME_TYPE", + 85899346220u64 => "SSL3_SESSION_ID_TOO_LONG", + 85899346962u64 => "SSLV3_ALERT_BAD_CERTIFICATE", + 85899346940u64 => "SSLV3_ALERT_BAD_RECORD_MAC", + 85899346965u64 => "SSLV3_ALERT_CERTIFICATE_EXPIRED", + 85899346964u64 => "SSLV3_ALERT_CERTIFICATE_REVOKED", + 85899346966u64 => "SSLV3_ALERT_CERTIFICATE_UNKNOWN", + 85899346950u64 => "SSLV3_ALERT_DECOMPRESSION_FAILURE", + 85899346960u64 => "SSLV3_ALERT_HANDSHAKE_FAILURE", + 85899346967u64 => "SSLV3_ALERT_ILLEGAL_PARAMETER", + 85899346961u64 => "SSLV3_ALERT_NO_CERTIFICATE", + 85899346930u64 => "SSLV3_ALERT_UNEXPECTED_MESSAGE", + 85899346963u64 => "SSLV3_ALERT_UNSUPPORTED_CERTIFICATE", + 85899346037u64 => "SSL_COMMAND_SECTION_EMPTY", + 85899346045u64 => "SSL_COMMAND_SECTION_NOT_FOUND", + 85899346148u64 => "SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION", + 85899346149u64 => "SSL_HANDSHAKE_FAILURE", + 85899346150u64 => "SSL_LIBRARY_HAS_NO_CIPHERS", + 85899346292u64 => "SSL_NEGATIVE_LENGTH", + 85899346046u64 => "SSL_SECTION_EMPTY", + 85899346056u64 => "SSL_SECTION_NOT_FOUND", + 85899346221u64 => "SSL_SESSION_ID_CALLBACK_FAILED", + 85899346222u64 => "SSL_SESSION_ID_CONFLICT", + 85899346193u64 => "SSL_SESSION_ID_CONTEXT_TOO_LONG", + 85899346223u64 => "SSL_SESSION_ID_HAS_BAD_LENGTH", + 85899346328u64 => "SSL_SESSION_ID_TOO_LONG", + 85899346130u64 => "SSL_SESSION_VERSION_MISMATCH", + 85899346041u64 => "STILL_IN_INIT", + 85899347036u64 => "TLSV13_ALERT_CERTIFICATE_REQUIRED", + 85899347029u64 => "TLSV13_ALERT_MISSING_EXTENSION", + 85899346969u64 => "TLSV1_ALERT_ACCESS_DENIED", + 85899346970u64 => "TLSV1_ALERT_DECODE_ERROR", + 85899346941u64 => "TLSV1_ALERT_DECRYPTION_FAILED", + 85899346971u64 => "TLSV1_ALERT_DECRYPT_ERROR", + 85899346980u64 => "TLSV1_ALERT_EXPORT_RESTRICTION", + 85899347006u64 => "TLSV1_ALERT_INAPPROPRIATE_FALLBACK", + 85899346991u64 => "TLSV1_ALERT_INSUFFICIENT_SECURITY", + 85899347000u64 => "TLSV1_ALERT_INTERNAL_ERROR", + 85899347040u64 => "TLSV1_ALERT_NO_APPLICATION_PROTOCOL", + 85899347020u64 => "TLSV1_ALERT_NO_RENEGOTIATION", + 85899346990u64 => "TLSV1_ALERT_PROTOCOL_VERSION", + 85899346942u64 => "TLSV1_ALERT_RECORD_OVERFLOW", + 85899346968u64 => "TLSV1_ALERT_UNKNOWN_CA", + 85899347035u64 => "TLSV1_ALERT_UNKNOWN_PSK_IDENTITY", + 85899347010u64 => "TLSV1_ALERT_USER_CANCELLED", + 85899347034u64 => "TLSV1_BAD_CERTIFICATE_HASH_VALUE", + 85899347033u64 => "TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE", + 85899347031u64 => "TLSV1_CERTIFICATE_UNOBTAINABLE", + 85899347032u64 => "TLSV1_UNRECOGNIZED_NAME", + 85899347030u64 => "TLSV1_UNSUPPORTED_EXTENSION", + 85899346287u64 => "TLS_ILLEGAL_EXPORTER_LABEL", + 85899346077u64 => "TLS_INVALID_ECPOINTFORMAT_LIST", + 85899346052u64 => "TOO_MANY_KEY_UPDATES", + 85899346329u64 => "TOO_MANY_WARN_ALERTS", + 85899346084u64 => "TOO_MUCH_EARLY_DATA", + 85899346234u64 => "UNABLE_TO_FIND_ECDH_PARAMETERS", + 85899346159u64 => "UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS", + 85899346162u64 => "UNABLE_TO_LOAD_SSL3_MD5_ROUTINES", + 85899346163u64 => "UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES", + 85899346182u64 => "UNEXPECTED_CCS_MESSAGE", + 85899346098u64 => "UNEXPECTED_END_OF_EARLY_DATA", + 85899346214u64 => "UNEXPECTED_EOF_WHILE_READING", + 85899346164u64 => "UNEXPECTED_MESSAGE", + 85899346165u64 => "UNEXPECTED_RECORD", + 85899346196u64 => "UNINITIALIZED", + 85899346166u64 => "UNKNOWN_ALERT_TYPE", + 85899346167u64 => "UNKNOWN_CERTIFICATE_TYPE", + 85899346168u64 => "UNKNOWN_CIPHER_RETURNED", + 85899346169u64 => "UNKNOWN_CIPHER_TYPE", + 85899346306u64 => "UNKNOWN_CMD_NAME", + 85899346059u64 => "UNKNOWN_COMMAND", + 85899346288u64 => "UNKNOWN_DIGEST", + 85899346170u64 => "UNKNOWN_KEY_EXCHANGE_TYPE", + 85899346171u64 => "UNKNOWN_PKEY_TYPE", + 85899346172u64 => "UNKNOWN_PROTOCOL", + 85899346174u64 => "UNKNOWN_SSL_VERSION", + 85899346175u64 => "UNKNOWN_STATE", + 85899346258u64 => "UNSAFE_LEGACY_RENEGOTIATION_DISABLED", + 85899346137u64 => "UNSOLICITED_EXTENSION", + 85899346177u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM", + 85899346235u64 => "UNSUPPORTED_ELLIPTIC_CURVE", + 85899346178u64 => "UNSUPPORTED_PROTOCOL", + 85899346179u64 => "UNSUPPORTED_SSL_VERSION", + 85899346249u64 => "UNSUPPORTED_STATUS_TYPE", + 85899346289u64 => "USE_SRTP_NOT_NEGOTIATED", + 85899346086u64 => "VERSION_TOO_HIGH", + 85899346316u64 => "VERSION_TOO_LOW", + 85899346303u64 => "WRONG_CERTIFICATE_TYPE", + 85899346181u64 => "WRONG_CIPHER_RETURNED", + 85899346298u64 => "WRONG_CURVE", + 85899346184u64 => "WRONG_SIGNATURE_LENGTH", + 85899346185u64 => "WRONG_SIGNATURE_SIZE", + 85899346290u64 => "WRONG_SIGNATURE_TYPE", + 85899346186u64 => "WRONG_SSL_VERSION", + 85899346187u64 => "WRONG_VERSION_NUMBER", + 85899346188u64 => "X509_LIB", + 85899346189u64 => "X509_VERIFICATION_SETUP_PROBLEMS", + 201863463044u64 => "BAD_PKCS7_TYPE", + 201863463045u64 => "BAD_TYPE", + 201863463049u64 => "CANNOT_LOAD_CERT", + 201863463050u64 => "CANNOT_LOAD_KEY", + 201863463012u64 => "CERTIFICATE_VERIFY_ERROR", + 201863463039u64 => "COULD_NOT_SET_ENGINE", + 201863463027u64 => "COULD_NOT_SET_TIME", + 201863463046u64 => "DETACHED_CONTENT", + 201863463028u64 => "ESS_ADD_SIGNING_CERT_ERROR", + 201863463051u64 => "ESS_ADD_SIGNING_CERT_V2_ERROR", + 201863463013u64 => "ESS_SIGNING_CERTIFICATE_ERROR", + 201863463014u64 => "INVALID_NULL_POINTER", + 201863463029u64 => "INVALID_SIGNER_CERTIFICATE_PURPOSE", + 201863463015u64 => "MESSAGE_IMPRINT_MISMATCH", + 201863463016u64 => "NONCE_MISMATCH", + 201863463017u64 => "NONCE_NOT_RETURNED", + 201863463018u64 => "NO_CONTENT", + 201863463019u64 => "NO_TIME_STAMP_TOKEN", + 201863463030u64 => "PKCS7_ADD_SIGNATURE_ERROR", + 201863463031u64 => "PKCS7_ADD_SIGNED_ATTR_ERROR", + 201863463041u64 => "PKCS7_TO_TS_TST_INFO_FAILED", + 201863463020u64 => "POLICY_MISMATCH", + 201863463032u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE", + 201863463033u64 => "RESPONSE_SETUP_ERROR", + 201863463021u64 => "SIGNATURE_FAILURE", + 201863463022u64 => "THERE_MUST_BE_ONE_SIGNER", + 201863463034u64 => "TIME_SYSCALL_ERROR", + 201863463042u64 => "TOKEN_NOT_PRESENT", + 201863463043u64 => "TOKEN_PRESENT", + 201863463023u64 => "TSA_NAME_MISMATCH", + 201863463024u64 => "TSA_UNTRUSTED", + 201863463035u64 => "TST_INFO_SETUP_ERROR", + 201863463036u64 => "TS_DATASIGN", + 201863463037u64 => "UNACCEPTABLE_POLICY", + 201863463038u64 => "UNSUPPORTED_MD_ALGORITHM", + 201863463025u64 => "UNSUPPORTED_VERSION", + 201863463047u64 => "VAR_BAD_VALUE", + 201863463048u64 => "VAR_LOOKUP_FAILURE", + 201863463026u64 => "WRONG_CONTENT_TYPE", + 171798691944u64 => "COMMON_OK_AND_CANCEL_CHARACTERS", + 171798691942u64 => "INDEX_TOO_LARGE", + 171798691943u64 => "INDEX_TOO_SMALL", + 171798691945u64 => "NO_RESULT_BUFFER", + 171798691947u64 => "PROCESSING_ERROR", + 171798691940u64 => "RESULT_TOO_LARGE", + 171798691941u64 => "RESULT_TOO_SMALL", + 171798691949u64 => "SYSASSIGN_ERROR", + 171798691950u64 => "SYSDASSGN_ERROR", + 171798691951u64 => "SYSQIOW_ERROR", + 171798691946u64 => "UNKNOWN_CONTROL_COMMAND", + 171798691948u64 => "UNKNOWN_TTYGET_ERRNO_VALUE", + 171798691952u64 => "USER_DATA_DUPLICATION_UNSUPPORTED", + 146028888182u64 => "BAD_IP_ADDRESS", + 146028888183u64 => "BAD_OBJECT", + 146028888164u64 => "BN_DEC2BN_ERROR", + 146028888165u64 => "BN_TO_ASN1_INTEGER_ERROR", + 146028888213u64 => "DIRNAME_ERROR", + 146028888224u64 => "DISTPOINT_ALREADY_SET", + 146028888197u64 => "DUPLICATE_ZONE_ID", + 146028888233u64 => "EMPTY_KEY_USAGE", + 146028888195u64 => "ERROR_CONVERTING_ZONE", + 146028888208u64 => "ERROR_CREATING_EXTENSION", + 146028888192u64 => "ERROR_IN_EXTENSION", + 146028888201u64 => "EXPECTED_A_SECTION_NAME", + 146028888209u64 => "EXTENSION_EXISTS", + 146028888179u64 => "EXTENSION_NAME_ERROR", + 146028888166u64 => "EXTENSION_NOT_FOUND", + 146028888167u64 => "EXTENSION_SETTING_NOT_SUPPORTED", + 146028888180u64 => "EXTENSION_VALUE_ERROR", + 146028888215u64 => "ILLEGAL_EMPTY_EXTENSION", + 146028888216u64 => "INCORRECT_POLICY_SYNTAX_TAG", + 146028888226u64 => "INVALID_ASNUMBER", + 146028888227u64 => "INVALID_ASRANGE", + 146028888168u64 => "INVALID_BOOLEAN_STRING", + 146028888222u64 => "INVALID_CERTIFICATE", + 146028888172u64 => "INVALID_EMPTY_NAME", + 146028888169u64 => "INVALID_EXTENSION_STRING", + 146028888229u64 => "INVALID_INHERITANCE", + 146028888230u64 => "INVALID_IPADDRESS", + 146028888225u64 => "INVALID_MULTIPLE_RDNS", + 146028888170u64 => "INVALID_NAME", + 146028888171u64 => "INVALID_NULL_ARGUMENT", + 146028888173u64 => "INVALID_NULL_VALUE", + 146028888204u64 => "INVALID_NUMBER", + 146028888205u64 => "INVALID_NUMBERS", + 146028888174u64 => "INVALID_OBJECT_IDENTIFIER", + 146028888202u64 => "INVALID_OPTION", + 146028888198u64 => "INVALID_POLICY_IDENTIFIER", + 146028888217u64 => "INVALID_PROXY_POLICY_SETTING", + 146028888210u64 => "INVALID_PURPOSE", + 146028888228u64 => "INVALID_SAFI", + 146028888199u64 => "INVALID_SECTION", + 146028888207u64 => "INVALID_SYNTAX", + 146028888190u64 => "ISSUER_DECODE_ERROR", + 146028888188u64 => "MISSING_VALUE", + 146028888206u64 => "NEED_ORGANIZATION_AND_NUMBERS", + 146028888232u64 => "NEGATIVE_PATHLEN", + 146028888200u64 => "NO_CONFIG_DATABASE", + 146028888185u64 => "NO_ISSUER_CERTIFICATE", + 146028888191u64 => "NO_ISSUER_DETAILS", + 146028888203u64 => "NO_POLICY_IDENTIFIER", + 146028888218u64 => "NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED", + 146028888178u64 => "NO_PUBLIC_KEY", + 146028888189u64 => "NO_SUBJECT_DETAILS", + 146028888212u64 => "OPERATION_NOT_DEFINED", + 146028888211u64 => "OTHERNAME_ERROR", + 146028888219u64 => "POLICY_LANGUAGE_ALREADY_DEFINED", + 146028888220u64 => "POLICY_PATH_LENGTH", + 146028888221u64 => "POLICY_PATH_LENGTH_ALREADY_DEFINED", + 146028888223u64 => "POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY", + 146028888214u64 => "SECTION_NOT_FOUND", + 146028888186u64 => "UNABLE_TO_GET_ISSUER_DETAILS", + 146028888187u64 => "UNABLE_TO_GET_ISSUER_KEYID", + 146028888175u64 => "UNKNOWN_BIT_STRING_ARGUMENT", + 146028888193u64 => "UNKNOWN_EXTENSION", + 146028888194u64 => "UNKNOWN_EXTENSION_NAME", + 146028888184u64 => "UNKNOWN_OPTION", + 146028888181u64 => "UNSUPPORTED_OPTION", + 146028888231u64 => "UNSUPPORTED_TYPE", + 146028888196u64 => "USER_TOO_LONG", + 47244640366u64 => "AKID_MISMATCH", + 47244640389u64 => "BAD_SELECTOR", + 47244640356u64 => "BAD_X509_FILETYPE", + 47244640374u64 => "BASE64_DECODE_ERROR", + 47244640370u64 => "CANT_CHECK_DH_KEY", + 47244640395u64 => "CERTIFICATE_VERIFICATION_FAILED", + 47244640357u64 => "CERT_ALREADY_IN_HASH_TABLE", + 47244640383u64 => "CRL_ALREADY_DELTA", + 47244640387u64 => "CRL_VERIFY_FAILURE", + 47244640396u64 => "DUPLICATE_ATTRIBUTE", + 47244640397u64 => "ERROR_GETTING_MD_BY_NID", + 47244640398u64 => "ERROR_USING_SIGINF_SET", + 47244640384u64 => "IDP_MISMATCH", + 47244640394u64 => "INVALID_ATTRIBUTES", + 47244640369u64 => "INVALID_DIRECTORY", + 47244640399u64 => "INVALID_DISTPOINT", + 47244640375u64 => "INVALID_FIELD_NAME", + 47244640379u64 => "INVALID_TRUST", + 47244640385u64 => "ISSUER_MISMATCH", + 47244640371u64 => "KEY_TYPE_MISMATCH", + 47244640372u64 => "KEY_VALUES_MISMATCH", + 47244640359u64 => "LOADING_CERT_DIR", + 47244640360u64 => "LOADING_DEFAULTS", + 47244640380u64 => "METHOD_NOT_SUPPORTED", + 47244640390u64 => "NAME_TOO_LONG", + 47244640388u64 => "NEWER_CRL_NOT_NEWER", + 47244640391u64 => "NO_CERTIFICATE_FOUND", + 47244640392u64 => "NO_CERTIFICATE_OR_CRL_FOUND", + 47244640361u64 => "NO_CERT_SET_FOR_US_TO_VERIFY", + 47244640393u64 => "NO_CRL_FOUND", + 47244640386u64 => "NO_CRL_NUMBER", + 47244640381u64 => "PUBLIC_KEY_DECODE_ERROR", + 47244640382u64 => "PUBLIC_KEY_ENCODE_ERROR", + 47244640362u64 => "SHOULD_RETRY", + 47244640363u64 => "UNABLE_TO_FIND_PARAMETERS_IN_CHAIN", + 47244640364u64 => "UNABLE_TO_GET_CERTS_PUBLIC_KEY", + 47244640373u64 => "UNKNOWN_KEY_TYPE", + 47244640365u64 => "UNKNOWN_NID", + 47244640377u64 => "UNKNOWN_PURPOSE_ID", + 47244640400u64 => "UNKNOWN_SIGID_ALGS", + 47244640376u64 => "UNKNOWN_TRUST_ID", + 47244640367u64 => "UNSUPPORTED_ALGORITHM", + 47244640368u64 => "WRONG_LOOKUP_TYPE", + 47244640378u64 => "WRONG_TYPE", +}; + +/// Helper function to create encoded key from (lib, reason) pair +#[inline] +pub fn encode_error_key(lib: i32, reason: i32) -> u64 { + ((lib as u64) << 32) | (reason as u64 & 0xFFFFFFFF) +}