diff --git a/.gitignore b/.gitignore
index be1c10e9..bc983be9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@ build/
 # Cargo
 target/
 Cargo.lock
+rules/rustls/rustls.h
 
 # Python
 *.pyc
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 61db1dc1..ae53fbda 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -135,6 +135,8 @@ add_custom_target("check"
 
 set(RULES_IR_DIR "${CMAKE_BINARY_DIR}/rules")
 
+set(RUSTLS_HEADER "${PROJECT_SOURCE_DIR}/rules/rustls/rustls.h")
+
 file(GLOB rule_subdirs ${PROJECT_SOURCE_DIR}/rules/*)
 set(cpp_rules_ir_outputs)
 set(rust_rules_ir_outputs)
@@ -151,7 +153,7 @@ foreach(_rule_dir IN LISTS rule_subdirs)
     OUTPUT ${_out}
     COMMAND ${CMAKE_COMMAND} -E make_directory ${_out_dir}
     COMMAND $<TARGET_FILE:cpp-rule-preprocessor> --dir ${_rule_dir} --out ${_out}
-    DEPENDS ${_srcs} ${PROJECT_SOURCE_DIR}/cpp2rust/cpp_rule_preprocessor.cpp
+    DEPENDS ${_srcs} ${PROJECT_SOURCE_DIR}/cpp2rust/cpp_rule_preprocessor.cpp ${RUSTLS_HEADER}
     VERBATIM
   )
   list(APPEND cpp_rules_ir_outputs ${_out})
@@ -171,7 +173,7 @@ file(GLOB_RECURSE rule_preprocessor_sources
      ${PROJECT_SOURCE_DIR}/rule-preprocessor/src/*.rs)
 
 add_custom_command(
-  OUTPUT ${rust_rules_ir_outputs}
+  OUTPUT ${rust_rules_ir_outputs} ${RUSTLS_HEADER}
   COMMAND cargo +${RUST_STABLE_VERSION} build --release --manifest-path "${PROJECT_SOURCE_DIR}/rules/Cargo.toml"
   COMMAND ${CMAKE_COMMAND} -E env
           CARGO_TARGET_DIR=${CMAKE_BINARY_DIR}/target_preprocessor
diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 17eeece4..e780b740 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -1808,6 +1808,11 @@ std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
   auto type_as_string = GetUnsafeTypeAsString(ty);
 
   if (ty->isFloatingType() || incl_type) {
+    if (expr->getValue().isZero()) {
+      if (auto init = Mapper::MapInitializer(ty); !init.empty()) {
+        return init;
+      }
+    }
     return std::format("{}_{}", num_as_string.c_str(), type_as_string);
   }
 
diff --git a/cpp2rust/cpp_rule_preprocessor.cpp b/cpp2rust/cpp_rule_preprocessor.cpp
index e1421bce..51e10c48 100644
--- a/cpp2rust/cpp_rule_preprocessor.cpp
+++ b/cpp2rust/cpp_rule_preprocessor.cpp
@@ -29,6 +29,7 @@
 #include <string>
 
 #include "compat/platform_flags.h"
+#include "converter/converter_lib.h"
 #include "converter/mapper.h"
 
 namespace fs = std::filesystem;
@@ -109,14 +110,15 @@ class Callback : public clang::ast_matchers::MatchFinder::MatchCallback {
       }
       return;
     }
-    if (auto var = R.Nodes.getNodeAs<clang::TypeAliasDecl>("tvar")) {
-      clang::QualType type;
-      if (auto *tdecl = var->getDescribedAliasTemplate()) {
-        type = lookupType(tdecl);
-      } else {
-        type = var->getUnderlyingType();
+    if (auto var = R.Nodes.getNodeAs<clang::TypedefNameDecl>("tvar")) {
+      clang::QualType type = var->getUnderlyingType();
+      if (auto *alias = llvm::dyn_cast<clang::TypeAliasDecl>(var)) {
+        if (auto *tdecl = alias->getDescribedAliasTemplate()) {
+          type = lookupType(tdecl);
+        }
       }
-      out_.try_emplace(var->getQualifiedNameAsString(), Mapper::ToString(type));
+      auto src = Mapper::ToString(type, Mapper::ScalarSugar::kPreserve);
+      out_.try_emplace(var->getQualifiedNameAsString(), std::move(src));
       return;
     }
 
@@ -707,7 +709,7 @@ class ActionFactory : public clang::tooling::FrontendActionFactory {
         &cb_);
 
     finder_.addMatcher(
-        typeAliasDecl(matchesName("(^|::)t[0-9]+$"), isExpansionInMainFile())
+        typedefNameDecl(matchesName("(^|::)t[0-9]+$"), isExpansionInMainFile())
             .bind("tvar"),
         &cb_);
 
diff --git a/rule-preprocessor/src/semantic.rs b/rule-preprocessor/src/semantic.rs
index 6dbef216..5f2dabb4 100644
--- a/rule-preprocessor/src/semantic.rs
+++ b/rule-preprocessor/src/semantic.rs
@@ -46,7 +46,7 @@ fn build_rustc_args(crate_root: &Path) -> Vec<String> {
     args.push("-L".to_string());
     args.push(format!("dependency={}", deps.display()));
 
-    for dep in &["libcc2rs", "libc", "brotli_sys"] {
+    for dep in &["libcc2rs", "libc", "brotli_sys", "rustls_ffi"] {
         if let Some(rlib) = find_rlib(deps.as_path(), dep) {
             args.push("--extern".to_string());
             args.push(format!("{}={}", dep, rlib.display()));
diff --git a/rules/build.rs b/rules/build.rs
index 6a996e9e..d3f4613e 100644
--- a/rules/build.rs
+++ b/rules/build.rs
@@ -30,6 +30,14 @@ fn main() {
     println!("cargo:rerun-if-changed=build.rs");
     println!("cargo:rerun-if-changed=Cargo.toml");
 
+    println!("cargo:rerun-if-env-changed=DEP_RUSTLS_FFI_INCLUDE");
+    let inc = env::var("DEP_RUSTLS_FFI_INCLUDE")
+        .expect("rustls-ffi did not export its include dir (DEP_RUSTLS_FFI_INCLUDE)");
+    let src = Path::new(&inc).join("rustls.h");
+    let dst = crate_root.join("rustls").join("rustls.h");
+    fs::copy(&src, &dst)
+        .unwrap_or_else(|e| panic!("failed to copy {} to {}: {e}", src.display(), dst.display()));
+
     // Generate modules that include absolute paths
     let mut buf = String::new();
     for f in files {
diff --git a/rules/rustls/src.c b/rules/rustls/src.c
new file mode 100644
index 00000000..6308d307
--- /dev/null
+++ b/rules/rustls/src.c
@@ -0,0 +1,248 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include "rustls.h"
+
+typedef rustls_connection *t1;
+typedef const rustls_connection *t2;
+typedef const rustls_certificate *t3;
+typedef rustls_str t4;
+typedef rustls_result t5;
+typedef rustls_io_result t6;
+typedef rustls_tls_version t7;
+
+rustls_result f1() { return RUSTLS_RESULT_OK; }
+rustls_result f2() { return RUSTLS_RESULT_NULL_PARAMETER; }
+rustls_result f3() { return RUSTLS_RESULT_PLAINTEXT_EMPTY; }
+rustls_result f4() { return RUSTLS_RESULT_UNEXPECTED_EOF; }
+
+rustls_tls_version f5() { return RUSTLS_TLS_VERSION_TLSV1_2; }
+rustls_tls_version f6() { return RUSTLS_TLS_VERSION_TLSV1_3; }
+
+rustls_result f7(rustls_connection *conn, uint8_t *buf, size_t count,
+                 size_t *out_n) {
+  return rustls_connection_read(conn, buf, count, out_n);
+}
+rustls_result f8(rustls_connection *conn, const uint8_t *buf, size_t count,
+                 size_t *out_n) {
+  return rustls_connection_write(conn, buf, count, out_n);
+}
+rustls_result f9(rustls_connection *conn) {
+  return rustls_connection_process_new_packets(conn);
+}
+bool f10(const rustls_connection *conn) {
+  return rustls_connection_wants_read(conn);
+}
+bool f11(const rustls_connection *conn) {
+  return rustls_connection_wants_write(conn);
+}
+bool f12(const rustls_connection *conn) {
+  return rustls_connection_is_handshaking(conn);
+}
+void f13(rustls_connection *conn) {
+  return rustls_connection_send_close_notify(conn);
+}
+void f14(rustls_connection *conn, void *userdata) {
+  return rustls_connection_set_userdata(conn, userdata);
+}
+void f15(const rustls_connection *conn, const uint8_t **protocol_out,
+         size_t *protocol_out_len) {
+  return rustls_connection_get_alpn_protocol(conn, protocol_out,
+                                             protocol_out_len);
+}
+uint16_t f16(const rustls_connection *conn) {
+  return rustls_connection_get_protocol_version(conn);
+}
+rustls_str f17(const rustls_connection *conn) {
+  return rustls_connection_get_negotiated_ciphersuite_name(conn);
+}
+rustls_str f18(const rustls_connection *conn) {
+  return rustls_connection_get_negotiated_key_exchange_group_name(conn);
+}
+const rustls_certificate *f19(const rustls_connection *conn, size_t i) {
+  return rustls_connection_get_peer_certificate(conn, i);
+}
+void f20(rustls_connection *conn) { return rustls_connection_free(conn); }
+
+typedef rustls_client_config *t8;
+typedef const rustls_client_config *t9;
+typedef rustls_client_config_builder *t10;
+typedef const rustls_client_config_builder *t11;
+typedef rustls_certified_key *t12;
+typedef const rustls_certified_key *t13;
+typedef rustls_crypto_provider *t14;
+typedef const rustls_crypto_provider *t15;
+typedef rustls_crypto_provider_builder *t16;
+typedef const rustls_crypto_provider_builder *t17;
+typedef rustls_root_cert_store *t18;
+typedef const rustls_root_cert_store *t19;
+typedef rustls_root_cert_store_builder *t20;
+typedef const rustls_root_cert_store_builder *t21;
+typedef rustls_server_cert_verifier *t22;
+typedef const rustls_server_cert_verifier *t23;
+typedef rustls_web_pki_server_cert_verifier_builder *t24;
+typedef const rustls_web_pki_server_cert_verifier_builder *t25;
+typedef rustls_supported_ciphersuite *t26;
+typedef const rustls_supported_ciphersuite *t27;
+typedef rustls_slice_bytes t28;
+typedef rustls_verify_server_cert_params t29;
+
+rustls_result f21(rustls_client_config_builder *builder,
+                  const rustls_client_config **config_out) {
+  return rustls_client_config_builder_build(builder, config_out);
+}
+void f22(rustls_client_config_builder *config) {
+  return rustls_client_config_builder_free(config);
+}
+rustls_result f23(const rustls_crypto_provider *provider,
+                  const uint16_t *tls_versions, size_t tls_versions_len,
+                  rustls_client_config_builder **builder_out) {
+  return rustls_client_config_builder_new_custom(provider, tls_versions,
+                                                 tls_versions_len, builder_out);
+}
+rustls_result f24(rustls_client_config_builder *builder,
+                  const rustls_slice_bytes *protocols, size_t len) {
+  return rustls_client_config_builder_set_alpn_protocols(builder, protocols,
+                                                         len);
+}
+rustls_result f25(rustls_client_config_builder *builder,
+                  const rustls_certified_key *const *certified_keys,
+                  size_t certified_keys_len) {
+  return rustls_client_config_builder_set_certified_key(builder, certified_keys,
+                                                        certified_keys_len);
+}
+void f26(rustls_client_config_builder *builder,
+         const rustls_server_cert_verifier *verifier) {
+  return rustls_client_config_builder_set_server_verifier(builder, verifier);
+}
+void f27(const rustls_client_config *config) {
+  return rustls_client_config_free(config);
+}
+rustls_result f28(const rustls_client_config *config, const char *server_name,
+                  rustls_connection **conn_out) {
+  return rustls_client_connection_new(config, server_name, conn_out);
+}
+
+rustls_result f29(const rustls_certificate *cert, const uint8_t **out_der_data,
+                  size_t *out_der_len) {
+  return rustls_certificate_get_der(cert, out_der_data, out_der_len);
+}
+rustls_result f30(const uint8_t *cert_chain, size_t cert_chain_len,
+                  const uint8_t *private_key, size_t private_key_len,
+                  const rustls_certified_key **certified_key_out) {
+  return rustls_certified_key_build(cert_chain, cert_chain_len, private_key,
+                                    private_key_len, certified_key_out);
+}
+void f31(const rustls_certified_key *key) {
+  return rustls_certified_key_free(key);
+}
+rustls_result f32(const rustls_certified_key *key) {
+  return rustls_certified_key_keys_match(key);
+}
+rustls_result f33(rustls_root_cert_store_builder *builder, const uint8_t *pem,
+                  size_t pem_len, bool strict) {
+  return rustls_root_cert_store_builder_add_pem(builder, pem, pem_len, strict);
+}
+rustls_result f34(rustls_root_cert_store_builder *builder,
+                  const rustls_root_cert_store **root_cert_store_out) {
+  return rustls_root_cert_store_builder_build(builder, root_cert_store_out);
+}
+void f35(rustls_root_cert_store_builder *builder) {
+  return rustls_root_cert_store_builder_free(builder);
+}
+rustls_result f36(rustls_root_cert_store_builder *builder, const char *filename,
+                  bool strict) {
+  return rustls_root_cert_store_builder_load_roots_from_file(builder, filename,
+                                                             strict);
+}
+rustls_root_cert_store_builder *f37() {
+  return rustls_root_cert_store_builder_new();
+}
+void f38(const rustls_root_cert_store *store) {
+  return rustls_root_cert_store_free(store);
+}
+
+rustls_result f39(rustls_crypto_provider_builder *builder,
+                  const rustls_crypto_provider **provider_out) {
+  return rustls_crypto_provider_builder_build(builder, provider_out);
+}
+void f40(rustls_crypto_provider_builder *builder) {
+  return rustls_crypto_provider_builder_free(builder);
+}
+rustls_result f41(rustls_crypto_provider_builder **builder_out) {
+  return rustls_crypto_provider_builder_new_from_default(builder_out);
+}
+rustls_result f42(rustls_crypto_provider_builder *builder,
+                  const rustls_supported_ciphersuite *const *cipher_suites,
+                  size_t cipher_suites_len) {
+  return rustls_crypto_provider_builder_set_cipher_suites(builder, cipher_suites,
+                                                          cipher_suites_len);
+}
+void f43(const rustls_crypto_provider *provider) {
+  return rustls_crypto_provider_free(provider);
+}
+const rustls_supported_ciphersuite *f44(size_t index) {
+  return rustls_default_crypto_provider_ciphersuites_get(index);
+}
+size_t f45() { return rustls_default_crypto_provider_ciphersuites_len(); }
+rustls_result f46(uint8_t *buff, size_t len) {
+  return rustls_default_crypto_provider_random(buff, len);
+}
+
+rustls_result f47(rustls_server_cert_verifier **verifier_out) {
+  return rustls_platform_server_cert_verifier(verifier_out);
+}
+void f48(rustls_server_cert_verifier *verifier) {
+  return rustls_server_cert_verifier_free(verifier);
+}
+rustls_result f49(rustls_web_pki_server_cert_verifier_builder *builder,
+                  const uint8_t *crl_pem, size_t crl_pem_len) {
+  return rustls_web_pki_server_cert_verifier_builder_add_crl(builder, crl_pem,
+                                                             crl_pem_len);
+}
+rustls_result f50(rustls_web_pki_server_cert_verifier_builder *builder,
+                  rustls_server_cert_verifier **verifier_out) {
+  return rustls_web_pki_server_cert_verifier_builder_build(builder,
+                                                           verifier_out);
+}
+void f51(rustls_web_pki_server_cert_verifier_builder *builder) {
+  return rustls_web_pki_server_cert_verifier_builder_free(builder);
+}
+rustls_web_pki_server_cert_verifier_builder *
+f52(const rustls_root_cert_store *store) {
+  return rustls_web_pki_server_cert_verifier_builder_new(store);
+}
+
+uint16_t f53(const rustls_supported_ciphersuite *supported_ciphersuite) {
+  return rustls_supported_ciphersuite_get_suite(supported_ciphersuite);
+}
+rustls_tls_version
+f54(const rustls_supported_ciphersuite *supported_ciphersuite) {
+  return rustls_supported_ciphersuite_protocol_version(supported_ciphersuite);
+}
+
+rustls_str f55() { return rustls_version(); }
+
+void f56(unsigned int result, char *buf, size_t len, size_t *out_n) {
+  return rustls_error(result, buf, len, out_n);
+}
+bool f57(unsigned int result) { return rustls_result_is_cert_error(result); }
+
+rustls_io_result f58(rustls_connection *conn, rustls_read_callback callback,
+                     void *userdata, size_t *out_n) {
+  return rustls_connection_read_tls(conn, callback, userdata, out_n);
+}
+rustls_io_result f59(rustls_connection *conn, rustls_write_callback callback,
+                     void *userdata, size_t *out_n) {
+  return rustls_connection_write_tls(conn, callback, userdata, out_n);
+}
+rustls_result f60(rustls_client_config_builder *builder,
+                  rustls_keylog_log_callback log_cb,
+                  rustls_keylog_will_log_callback will_log_cb) {
+  return rustls_client_config_builder_set_key_log(builder, log_cb, will_log_cb);
+}
+rustls_result f61(rustls_client_config_builder *config_builder,
+                  rustls_verify_server_cert_callback callback) {
+  return rustls_client_config_builder_dangerous_set_certificate_verifier(
+      config_builder, callback);
+}
diff --git a/rules/rustls/tgt_unsafe.rs b/rules/rustls/tgt_unsafe.rs
new file mode 100644
index 00000000..289594c2
--- /dev/null
+++ b/rules/rustls/tgt_unsafe.rs
@@ -0,0 +1,491 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+fn t1() -> *mut ::rustls_ffi::connection::rustls_connection {
+    std::ptr::null_mut()
+}
+fn t2() -> *const ::rustls_ffi::connection::rustls_connection {
+    std::ptr::null()
+}
+fn t3() -> *const ::rustls_ffi::certificate::rustls_certificate<'static> {
+    std::ptr::null()
+}
+fn t4() -> ::rustls_ffi::rslice::rustls_str<'static> {
+    unsafe { std::mem::zeroed() }
+}
+fn t5() -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::rustls_result::Ok
+}
+fn t6() -> ::rustls_ffi::rustls_io_result {
+    ::rustls_ffi::rustls_io_result(0)
+}
+fn t7() -> ::rustls_ffi::enums::rustls_tls_version {
+    ::rustls_ffi::enums::rustls_tls_version::Unknown
+}
+
+unsafe fn f1() -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::rustls_result::Ok
+}
+unsafe fn f2() -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::rustls_result::NullParameter
+}
+unsafe fn f3() -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::rustls_result::PlaintextEmpty
+}
+unsafe fn f4() -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::rustls_result::UnexpectedEof
+}
+
+unsafe fn f5() -> i32 {
+    ::rustls_ffi::enums::rustls_tls_version::Tlsv1_2 as i32
+}
+unsafe fn f6() -> i32 {
+    ::rustls_ffi::enums::rustls_tls_version::Tlsv1_3 as i32
+}
+
+unsafe fn f7(
+    a0: *mut ::rustls_ffi::connection::rustls_connection,
+    a1: *mut u8,
+    a2: u64,
+    a3: *mut u64,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_read(
+        a0,
+        a1,
+        a2 as usize,
+        a3 as *mut usize,
+    )
+}
+unsafe fn f8(
+    a0: *mut ::rustls_ffi::connection::rustls_connection,
+    a1: *const u8,
+    a2: u64,
+    a3: *mut u64,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_write(
+        a0,
+        a1,
+        a2 as usize,
+        a3 as *mut usize,
+    )
+}
+unsafe fn f9(a0: *mut ::rustls_ffi::connection::rustls_connection) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_process_new_packets(a0)
+}
+unsafe fn f10(a0: *const ::rustls_ffi::connection::rustls_connection) -> bool {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_wants_read(a0)
+}
+unsafe fn f11(a0: *const ::rustls_ffi::connection::rustls_connection) -> bool {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_wants_write(a0)
+}
+unsafe fn f12(a0: *const ::rustls_ffi::connection::rustls_connection) -> bool {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_is_handshaking(a0)
+}
+unsafe fn f13(a0: *mut ::rustls_ffi::connection::rustls_connection) {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_send_close_notify(a0)
+}
+unsafe fn f14(a0: *mut ::rustls_ffi::connection::rustls_connection, a1: *mut std::ffi::c_void) {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_set_userdata(a0, a1)
+}
+unsafe fn f15(
+    a0: *const ::rustls_ffi::connection::rustls_connection,
+    a1: *mut *const u8,
+    a2: *mut u64,
+) {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_get_alpn_protocol(
+        a0,
+        a1,
+        a2 as *mut usize,
+    )
+}
+unsafe fn f16(a0: *const ::rustls_ffi::connection::rustls_connection) -> u16 {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_get_protocol_version(a0)
+}
+unsafe fn f17(
+    a0: *const ::rustls_ffi::connection::rustls_connection,
+) -> ::rustls_ffi::rslice::rustls_str<'static> {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_get_negotiated_ciphersuite_name(
+        a0,
+    )
+}
+unsafe fn f18(
+    a0: *const ::rustls_ffi::connection::rustls_connection,
+) -> ::rustls_ffi::rslice::rustls_str<'static> {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_get_negotiated_key_exchange_group_name(a0)
+}
+unsafe fn f19(
+    a0: *const ::rustls_ffi::connection::rustls_connection,
+    a1: u64,
+) -> *const ::rustls_ffi::certificate::rustls_certificate<'static> {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_get_peer_certificate(
+        a0,
+        a1 as usize,
+    )
+}
+unsafe fn f20(a0: *mut ::rustls_ffi::connection::rustls_connection) {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_free(a0)
+}
+
+fn t8() -> *mut ::rustls_ffi::client::rustls_client_config {
+    std::ptr::null_mut()
+}
+fn t9() -> *const ::rustls_ffi::client::rustls_client_config {
+    std::ptr::null()
+}
+fn t10() -> *mut ::rustls_ffi::client::rustls_client_config_builder {
+    std::ptr::null_mut()
+}
+fn t11() -> *const ::rustls_ffi::client::rustls_client_config_builder {
+    std::ptr::null()
+}
+fn t12() -> *mut ::rustls_ffi::certificate::rustls_certified_key {
+    std::ptr::null_mut()
+}
+fn t13() -> *const ::rustls_ffi::certificate::rustls_certified_key {
+    std::ptr::null()
+}
+fn t14() -> *mut ::rustls_ffi::crypto_provider::rustls_crypto_provider {
+    std::ptr::null_mut()
+}
+fn t15() -> *const ::rustls_ffi::crypto_provider::rustls_crypto_provider {
+    std::ptr::null()
+}
+fn t16() -> *mut ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder {
+    std::ptr::null_mut()
+}
+fn t17() -> *const ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder {
+    std::ptr::null()
+}
+fn t18() -> *mut ::rustls_ffi::certificate::rustls_root_cert_store {
+    std::ptr::null_mut()
+}
+fn t19() -> *const ::rustls_ffi::certificate::rustls_root_cert_store {
+    std::ptr::null()
+}
+fn t20() -> *mut ::rustls_ffi::certificate::rustls_root_cert_store_builder {
+    std::ptr::null_mut()
+}
+fn t21() -> *const ::rustls_ffi::certificate::rustls_root_cert_store_builder {
+    std::ptr::null()
+}
+fn t22() -> *mut ::rustls_ffi::verifier::rustls_server_cert_verifier {
+    std::ptr::null_mut()
+}
+fn t23() -> *const ::rustls_ffi::verifier::rustls_server_cert_verifier {
+    std::ptr::null()
+}
+fn t24() -> *mut ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder {
+    std::ptr::null_mut()
+}
+fn t25() -> *const ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder {
+    std::ptr::null()
+}
+fn t26() -> *mut ::rustls_ffi::cipher::rustls_supported_ciphersuite {
+    std::ptr::null_mut()
+}
+fn t27() -> *const ::rustls_ffi::cipher::rustls_supported_ciphersuite {
+    std::ptr::null()
+}
+fn t28() -> ::rustls_ffi::rslice::rustls_slice_bytes<'static> {
+    unsafe { std::mem::zeroed() }
+}
+fn t29() -> ::rustls_ffi::client::rustls_verify_server_cert_params<'static> {
+    unsafe { std::mem::zeroed() }
+}
+
+unsafe fn f21(
+    a0: *mut ::rustls_ffi::client::rustls_client_config_builder,
+    a1: *mut *const ::rustls_ffi::client::rustls_client_config,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::client::rustls_client_config_builder::rustls_client_config_builder_build(a0, a1)
+}
+unsafe fn f22(a0: *mut ::rustls_ffi::client::rustls_client_config_builder) {
+    ::rustls_ffi::client::rustls_client_config_builder::rustls_client_config_builder_free(a0)
+}
+unsafe fn f23(
+    a0: *const ::rustls_ffi::crypto_provider::rustls_crypto_provider,
+    a1: *const u16,
+    a2: u64,
+    a3: *mut *mut ::rustls_ffi::client::rustls_client_config_builder,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::client::rustls_client_config_builder::rustls_client_config_builder_new_custom(
+        a0,
+        a1,
+        a2 as usize,
+        a3,
+    )
+}
+unsafe fn f24(
+    a0: *mut ::rustls_ffi::client::rustls_client_config_builder,
+    a1: *const ::rustls_ffi::rslice::rustls_slice_bytes<'static>,
+    a2: u64,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::client::rustls_client_config_builder::rustls_client_config_builder_set_alpn_protocols(a0, a1, a2 as usize)
+}
+unsafe fn f25(
+    a0: *mut ::rustls_ffi::client::rustls_client_config_builder,
+    a1: *const *const ::rustls_ffi::certificate::rustls_certified_key,
+    a2: u64,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::client::rustls_client_config_builder::rustls_client_config_builder_set_certified_key(a0, a1, a2 as usize)
+}
+unsafe fn f26(
+    a0: *mut ::rustls_ffi::client::rustls_client_config_builder,
+    a1: *const ::rustls_ffi::verifier::rustls_server_cert_verifier,
+) {
+    ::rustls_ffi::client::rustls_client_config_builder::rustls_client_config_builder_set_server_verifier(a0, a1)
+}
+unsafe fn f27(a0: *const ::rustls_ffi::client::rustls_client_config) {
+    ::rustls_ffi::client::rustls_client_config::rustls_client_config_free(a0)
+}
+unsafe fn f28(
+    a0: *const ::rustls_ffi::client::rustls_client_config,
+    a1: *const u8,
+    a2: *mut *mut ::rustls_ffi::connection::rustls_connection,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::client::rustls_client_config::rustls_client_connection_new(
+        a0,
+        a1 as *const ::std::ffi::c_char,
+        a2,
+    )
+}
+
+unsafe fn f29(
+    a0: *const ::rustls_ffi::certificate::rustls_certificate<'static>,
+    a1: *mut *const u8,
+    a2: *mut u64,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::certificate::rustls_certificate_get_der(a0, a1, a2 as *mut usize)
+}
+unsafe fn f30(
+    a0: *const u8,
+    a1: u64,
+    a2: *const u8,
+    a3: u64,
+    a4: *mut *const ::rustls_ffi::certificate::rustls_certified_key,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::certificate::rustls_certified_key::rustls_certified_key_build(
+        a0,
+        a1 as usize,
+        a2,
+        a3 as usize,
+        a4,
+    )
+}
+unsafe fn f31(a0: *const ::rustls_ffi::certificate::rustls_certified_key) {
+    ::rustls_ffi::certificate::rustls_certified_key::rustls_certified_key_free(a0)
+}
+unsafe fn f32(
+    a0: *const ::rustls_ffi::certificate::rustls_certified_key,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::certificate::rustls_certified_key::rustls_certified_key_keys_match(a0)
+}
+unsafe fn f33(
+    a0: *mut ::rustls_ffi::certificate::rustls_root_cert_store_builder,
+    a1: *const u8,
+    a2: u64,
+    a3: bool,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::certificate::rustls_root_cert_store_builder::rustls_root_cert_store_builder_add_pem(a0, a1, a2 as usize, a3)
+}
+unsafe fn f34(
+    a0: *mut ::rustls_ffi::certificate::rustls_root_cert_store_builder,
+    a1: *mut *const ::rustls_ffi::certificate::rustls_root_cert_store,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::certificate::rustls_root_cert_store_builder::rustls_root_cert_store_builder_build(
+        a0, a1,
+    )
+}
+unsafe fn f35(a0: *mut ::rustls_ffi::certificate::rustls_root_cert_store_builder) {
+    ::rustls_ffi::certificate::rustls_root_cert_store_builder::rustls_root_cert_store_builder_free(
+        a0,
+    )
+}
+unsafe fn f36(
+    a0: *mut ::rustls_ffi::certificate::rustls_root_cert_store_builder,
+    a1: *const u8,
+    a2: bool,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::certificate::rustls_root_cert_store_builder::rustls_root_cert_store_builder_load_roots_from_file(a0, a1 as *const ::std::ffi::c_char, a2)
+}
+unsafe fn f37() -> *mut ::rustls_ffi::certificate::rustls_root_cert_store_builder {
+    ::rustls_ffi::certificate::rustls_root_cert_store_builder::rustls_root_cert_store_builder_new()
+}
+unsafe fn f38(a0: *const ::rustls_ffi::certificate::rustls_root_cert_store) {
+    ::rustls_ffi::certificate::rustls_root_cert_store::rustls_root_cert_store_free(a0)
+}
+
+unsafe fn f39(
+    a0: *mut ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder,
+    a1: *mut *const ::rustls_ffi::crypto_provider::rustls_crypto_provider,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder_build(a0, a1)
+}
+unsafe fn f40(a0: *mut ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder) {
+    ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder_free(a0)
+}
+unsafe fn f41(
+    a0: *mut *mut ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder_new_from_default(a0)
+}
+unsafe fn f42(
+    a0: *mut ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder,
+    a1: *const *const ::rustls_ffi::cipher::rustls_supported_ciphersuite,
+    a2: u64,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::crypto_provider::rustls_crypto_provider_builder_set_cipher_suites(
+        a0,
+        a1,
+        a2 as usize,
+    )
+}
+unsafe fn f43(a0: *const ::rustls_ffi::crypto_provider::rustls_crypto_provider) {
+    ::rustls_ffi::crypto_provider::rustls_crypto_provider_free(a0)
+}
+unsafe fn f44(a0: u64) -> *const ::rustls_ffi::cipher::rustls_supported_ciphersuite {
+    ::rustls_ffi::crypto_provider::rustls_default_crypto_provider_ciphersuites_get(a0 as usize)
+}
+unsafe fn f45() -> u64 {
+    ::rustls_ffi::crypto_provider::rustls_default_crypto_provider_ciphersuites_len() as u64
+}
+unsafe fn f46(a0: *mut u8, a1: u64) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::crypto_provider::rustls_default_crypto_provider_random(a0, a1 as usize)
+}
+
+unsafe fn f47(
+    a0: *mut *mut ::rustls_ffi::verifier::rustls_server_cert_verifier,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::verifier::rustls_server_cert_verifier::rustls_platform_server_cert_verifier(a0)
+}
+unsafe fn f48(a0: *mut ::rustls_ffi::verifier::rustls_server_cert_verifier) {
+    ::rustls_ffi::verifier::rustls_server_cert_verifier::rustls_server_cert_verifier_free(a0)
+}
+unsafe fn f49(
+    a0: *mut ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder,
+    a1: *const u8,
+    a2: u64,
+) -> ::rustls_ffi::rustls_result {
+    unsafe extern "C" {
+        fn rustls_web_pki_server_cert_verifier_builder_add_crl(
+            builder: *mut ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder,
+            crl_pem: *const u8,
+            crl_pem_len: usize,
+        ) -> ::rustls_ffi::rustls_result;
+    }
+    rustls_web_pki_server_cert_verifier_builder_add_crl(a0, a1, a2 as usize)
+}
+unsafe fn f50(
+    a0: *mut ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder,
+    a1: *mut *mut ::rustls_ffi::verifier::rustls_server_cert_verifier,
+) -> ::rustls_ffi::rustls_result {
+    unsafe extern "C" {
+        fn rustls_web_pki_server_cert_verifier_builder_build(
+            builder: *mut ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder,
+            verifier_out: *mut *mut ::rustls_ffi::verifier::rustls_server_cert_verifier,
+        ) -> ::rustls_ffi::rustls_result;
+    }
+    rustls_web_pki_server_cert_verifier_builder_build(a0, a1)
+}
+unsafe fn f51(a0: *mut ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder) {
+    unsafe extern "C" {
+        fn rustls_web_pki_server_cert_verifier_builder_free(
+            builder: *mut ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder,
+        );
+    }
+    rustls_web_pki_server_cert_verifier_builder_free(a0)
+}
+unsafe fn f52(
+    a0: *const ::rustls_ffi::certificate::rustls_root_cert_store,
+) -> *mut ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder {
+    unsafe extern "C" {
+        fn rustls_web_pki_server_cert_verifier_builder_new(
+            store: *const ::rustls_ffi::certificate::rustls_root_cert_store,
+        ) -> *mut ::rustls_ffi::verifier::rustls_web_pki_server_cert_verifier_builder;
+    }
+    rustls_web_pki_server_cert_verifier_builder_new(a0)
+}
+
+unsafe fn f53(a0: *const ::rustls_ffi::cipher::rustls_supported_ciphersuite) -> u16 {
+    ::rustls_ffi::cipher::rustls_supported_ciphersuite::rustls_supported_ciphersuite_get_suite(a0)
+}
+unsafe fn f54(
+    a0: *const ::rustls_ffi::cipher::rustls_supported_ciphersuite,
+) -> ::rustls_ffi::enums::rustls_tls_version {
+    ::rustls_ffi::cipher::rustls_supported_ciphersuite_protocol_version(a0)
+}
+
+unsafe fn f55() -> ::rustls_ffi::rslice::rustls_str<'static> {
+    ::rustls_ffi::version::rustls_version()
+}
+
+unsafe fn f56(a0: u32, a1: *mut u8, a2: u64, a3: *mut u64) {
+    ::rustls_ffi::rustls_result::rustls_error(
+        a0,
+        a1 as *mut ::std::ffi::c_char,
+        a2 as usize,
+        a3 as *mut usize,
+    )
+}
+unsafe fn f57(a0: u32) -> bool {
+    ::rustls_ffi::rustls_result::rustls_result_is_cert_error(a0)
+}
+
+unsafe fn f58(
+    a0: *mut ::rustls_ffi::connection::rustls_connection,
+    a1: unsafe fn(*mut ::libc::c_void, *mut u8, u64, *mut u64) -> i32,
+    a2: *mut ::libc::c_void,
+    a3: *mut u64,
+) -> i32 {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_read_tls(
+        a0,
+        std::mem::transmute::<*const (), ::rustls_ffi::io::rustls_read_callback>(a1 as *const ()),
+        a2,
+        a3 as *mut usize,
+    )
+    .0
+}
+unsafe fn f59(
+    a0: *mut ::rustls_ffi::connection::rustls_connection,
+    a1: unsafe fn(*mut ::libc::c_void, *const u8, u64, *mut u64) -> i32,
+    a2: *mut ::libc::c_void,
+    a3: *mut u64,
+) -> i32 {
+    ::rustls_ffi::connection::rustls_connection::rustls_connection_write_tls(
+        a0,
+        std::mem::transmute::<*const (), ::rustls_ffi::io::rustls_write_callback>(a1 as *const ()),
+        a2,
+        a3 as *mut usize,
+    )
+    .0
+}
+unsafe fn f60(
+    a0: *mut ::rustls_ffi::client::rustls_client_config_builder,
+    a1: unsafe fn(::rustls_ffi::rslice::rustls_str<'static>, *const u8, u64, *const u8, u64),
+    a2: Option<unsafe fn(::rustls_ffi::rslice::rustls_str<'static>) -> i32>,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::client::rustls_client_config_builder::rustls_client_config_builder_set_key_log(
+        a0,
+        std::mem::transmute::<*const (), ::rustls_ffi::keylog::rustls_keylog_log_callback>(
+            a1 as *const (),
+        ),
+        std::mem::transmute::<
+            Option<unsafe fn(::rustls_ffi::rslice::rustls_str<'static>) -> i32>,
+            ::rustls_ffi::keylog::rustls_keylog_will_log_callback,
+        >(a2),
+    )
+}
+unsafe fn f61(
+    a0: *mut ::rustls_ffi::client::rustls_client_config_builder,
+    a1: unsafe fn(
+        *mut ::libc::c_void,
+        *const ::rustls_ffi::client::rustls_verify_server_cert_params<'static>,
+    ) -> ::rustls_ffi::rustls_result,
+) -> ::rustls_ffi::rustls_result {
+    ::rustls_ffi::client::rustls_client_config_builder::rustls_client_config_builder_dangerous_set_certificate_verifier(
+        a0,
+        std::mem::transmute::<*const (), ::rustls_ffi::client::rustls_verify_server_cert_callback>(
+            a1 as *const (),
+        ),
+    )
+}
diff --git a/rules/src/modules.rs b/rules/src/modules.rs
index efd63874..9a7971c5 100644
--- a/rules/src/modules.rs
+++ b/rules/src/modules.rs
@@ -80,6 +80,8 @@ pub mod pair_tgt_unsafe;
 pub mod poll_tgt_unsafe;
 #[path = r#"../pwd/tgt_unsafe.rs"#]
 pub mod pwd_tgt_unsafe;
+#[path = r#"../rustls/tgt_unsafe.rs"#]
+pub mod rustls_tgt_unsafe;
 #[path = r#"../select/tgt_unsafe.rs"#]
 pub mod select_tgt_unsafe;
 #[path = r#"../signal/tgt_unsafe.rs"#]