16248620128

Committed 13 Jul 2025 11:27AM UTC coverage: 90.565% (-0.01%) from 90.575%

Build # 16248620128

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4983 from randombit/jack/clang-tidy-cppcoreguidelines-owning-memory

Enable and fix clang-tidy warning cppcoreguidelines-owning-memory

Run Details

99026 of 109342 relevant lines covered (90.57%)

12444574.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.51

/src/lib/ffi/ffi_cert.cpp

/*
* (C) 2015,2017,2018 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/ffi.h>

#include <botan/internal/ffi_pkey.h>
#include <botan/internal/ffi_util.h>
#include <memory>

#if defined(BOTAN_HAS_X509_CERTIFICATES)
   #include <botan/data_src.h>
   #include <botan/x509_crl.h>
   #include <botan/x509cert.h>
   #include <botan/x509path.h>
#endif

extern "C" {

using namespace Botan_FFI;

#if defined(BOTAN_HAS_X509_CERTIFICATES)

BOTAN_FFI_DECLARE_STRUCT(botan_x509_cert_struct, Botan::X509_Certificate, 0x8F628937);

#endif

int botan_x509_cert_load_file(botan_x509_cert_t* cert_obj, const char* cert_path) {
   if(cert_obj == nullptr || cert_path == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }

#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)

   return ffi_guard_thunk(__func__, [=]() -> int {
      auto c = std::make_unique<Botan::X509_Certificate>(cert_path);
      return ffi_new_object(cert_obj, std::move(c));
   });

#else
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_dup(botan_x509_cert_t* cert_obj, botan_x509_cert_t cert) {
   if(cert_obj == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }

#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)

   return ffi_guard_thunk(__func__, [=]() -> int {
      auto c = std::make_unique<Botan::X509_Certificate>(safe_get(cert));
      return ffi_new_object(cert_obj, std::move(c));
   });

#else
   BOTAN_UNUSED(cert);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_load(botan_x509_cert_t* cert_obj, const uint8_t cert_bits[], size_t cert_bits_len) {
   if(cert_obj == nullptr || cert_bits == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }

#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::DataSource_Memory bits(cert_bits, cert_bits_len);
      auto c = std::make_unique<Botan::X509_Certificate>(bits);
      return ffi_new_object(cert_obj, std::move(c));
   });
#else
   BOTAN_UNUSED(cert_bits_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_public_key(botan_x509_cert_t cert, botan_pubkey_t* key) {
   if(key == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }

   *key = nullptr;

#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      auto public_key = safe_get(cert).subject_public_key();
      return ffi_new_object(key, std::move(public_key));
   });
#else
   BOTAN_UNUSED(cert);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_issuer_dn(
   botan_x509_cert_t cert, const char* key, size_t index, uint8_t out[], size_t* out_len) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      auto issuer_info = c.issuer_info(key);
      if(index < issuer_info.size()) {
         return write_str_output(out, out_len, c.issuer_info(key).at(index));
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(cert, key, index, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_subject_dn(
   botan_x509_cert_t cert, const char* key, size_t index, uint8_t out[], size_t* out_len) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      auto subject_info = c.subject_info(key);
      if(index < subject_info.size()) {
         return write_str_output(out, out_len, c.subject_info(key).at(index));
      } else {
         return BOTAN_FFI_ERROR_BAD_PARAMETER;
      }
   });
#else
   BOTAN_UNUSED(cert, key, index, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_to_string(botan_x509_cert_t cert, char out[], size_t* out_len) {
   return copy_view_str(reinterpret_cast<uint8_t*>(out), out_len, botan_x509_cert_view_as_string, cert);
}

int botan_x509_cert_view_as_string(botan_x509_cert_t cert, botan_view_ctx ctx, botan_view_str_fn view) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return invoke_view_callback(view, ctx, c.to_string()); });
#else
   BOTAN_UNUSED(cert, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_allowed_usage(botan_x509_cert_t cert, unsigned int key_usage) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {
      const Botan::Key_Constraints k = static_cast<Botan::Key_Constraints>(key_usage);
      if(c.allowed_usage(k)) {
         return BOTAN_FFI_SUCCESS;
      }
      return 1;
   });
#else
   BOTAN_UNUSED(cert, key_usage);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_destroy(botan_x509_cert_t cert) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_CHECKED_DELETE(cert);
#else
   BOTAN_UNUSED(cert);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_time_starts(botan_x509_cert_t cert, char out[], size_t* out_len) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert,
                          [=](const auto& c) { return write_str_output(out, out_len, c.not_before().to_string()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_time_expires(botan_x509_cert_t cert, char out[], size_t* out_len) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert,
                          [=](const auto& c) { return write_str_output(out, out_len, c.not_after().to_string()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_not_before(botan_x509_cert_t cert, uint64_t* time_since_epoch) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *time_since_epoch = c.not_before().time_since_epoch(); });
#else
   BOTAN_UNUSED(cert, time_since_epoch);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_not_after(botan_x509_cert_t cert, uint64_t* time_since_epoch) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *time_since_epoch = c.not_after().time_since_epoch(); });
#else
   BOTAN_UNUSED(cert, time_since_epoch);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_serial_number(botan_x509_cert_t cert, uint8_t out[], size_t* out_len) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.serial_number()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_fingerprint(botan_x509_cert_t cert, const char* hash, uint8_t out[], size_t* out_len) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_str_output(out, out_len, c.fingerprint(hash)); });
#else
   BOTAN_UNUSED(cert, hash, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_authority_key_id(botan_x509_cert_t cert, uint8_t out[], size_t* out_len) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.authority_key_id()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_subject_key_id(botan_x509_cert_t cert, uint8_t out[], size_t* out_len) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.subject_key_id()); });
#else
   BOTAN_UNUSED(cert, out, out_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_get_public_key_bits(botan_x509_cert_t cert, uint8_t out[], size_t* out_len) {
   return copy_view_bin(out, out_len, botan_x509_cert_view_public_key_bits, cert);
}

int botan_x509_cert_view_public_key_bits(botan_x509_cert_t cert, botan_view_ctx ctx, botan_view_bin_fn view) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert,
                          [=](const auto& c) { return invoke_view_callback(view, ctx, c.subject_public_key_bits()); });
#else
   BOTAN_UNUSED(cert, ctx, view);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_hostname_match(botan_x509_cert_t cert, const char* hostname) {
   if(hostname == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }

#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return c.matches_dns_name(hostname) ? 0 : -1; });
#else
   BOTAN_UNUSED(cert);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_verify(int* result_code,
                           botan_x509_cert_t cert,
                           const botan_x509_cert_t* intermediates,
                           size_t intermediates_len,
                           const botan_x509_cert_t* trusted,
                           size_t trusted_len,
                           const char* trusted_path,
                           size_t required_strength,
                           const char* hostname_cstr,
                           uint64_t reference_time) {
   if(required_strength == 0) {
      required_strength = 110;
   }

#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::string hostname((hostname_cstr == nullptr) ? "" : hostname_cstr);
      const Botan::Usage_Type usage = Botan::Usage_Type::UNSPECIFIED;
      const auto validation_time = reference_time == 0
                                      ? std::chrono::system_clock::now()
                                      : std::chrono::system_clock::from_time_t(static_cast<time_t>(reference_time));

      std::vector<Botan::X509_Certificate> end_certs;
      end_certs.push_back(safe_get(cert));
      for(size_t i = 0; i != intermediates_len; ++i) {
         end_certs.push_back(safe_get(intermediates[i]));
      }

      std::unique_ptr<Botan::Certificate_Store> trusted_from_path;
      std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_extra;
      std::vector<Botan::Certificate_Store*> trusted_roots;

      if(trusted_path && *trusted_path) {
         trusted_from_path = std::make_unique<Botan::Certificate_Store_In_Memory>(trusted_path);
         trusted_roots.push_back(trusted_from_path.get());
      }

      if(trusted_len > 0) {
         trusted_extra = std::make_unique<Botan::Certificate_Store_In_Memory>();
         for(size_t i = 0; i != trusted_len; ++i) {
            trusted_extra->add_certificate(safe_get(trusted[i]));
         }
         trusted_roots.push_back(trusted_extra.get());
      }

      Botan::Path_Validation_Restrictions restrictions(false, required_strength);

      auto validation_result =
         Botan::x509_path_validate(end_certs, restrictions, trusted_roots, hostname, usage, validation_time);

      if(result_code) {
         *result_code = static_cast<int>(validation_result.result());
      }

      if(validation_result.successful_validation()) {
         return 0;
      } else {
         return 1;
      }
   });
#else
   BOTAN_UNUSED(result_code, cert, intermediates, intermediates_len, trusted);
   BOTAN_UNUSED(trusted_len, trusted_path, hostname_cstr, reference_time);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

const char* botan_x509_cert_validation_status(int code) {
   if(code < 0) {
      return nullptr;
   }

#if defined(BOTAN_HAS_X509_CERTIFICATES)
   Botan::Certificate_Status_Code sc = static_cast<Botan::Certificate_Status_Code>(code);
   return Botan::to_string(sc);
#else
   return nullptr;
#endif
}

#if defined(BOTAN_HAS_X509_CERTIFICATES)

BOTAN_FFI_DECLARE_STRUCT(botan_x509_crl_struct, Botan::X509_CRL, 0x2C628910);

#endif

int botan_x509_crl_load_file(botan_x509_crl_t* crl_obj, const char* crl_path) {
   if(crl_obj == nullptr || crl_path == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }

#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)

   return ffi_guard_thunk(__func__, [=]() -> int {
      auto c = std::make_unique<Botan::X509_CRL>(crl_path);
      return ffi_new_object(crl_obj, std::move(c));
   });

#else
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_crl_load(botan_x509_crl_t* crl_obj, const uint8_t crl_bits[], size_t crl_bits_len) {
   if(crl_obj == nullptr || crl_bits == nullptr) {
      return BOTAN_FFI_ERROR_NULL_POINTER;
   }

#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      Botan::DataSource_Memory bits(crl_bits, crl_bits_len);
      auto c = std::make_unique<Botan::X509_CRL>(bits);
      return ffi_new_object(crl_obj, std::move(c));
   });
#else
   BOTAN_UNUSED(crl_bits_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_crl_destroy(botan_x509_crl_t crl) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_CHECKED_DELETE(crl);
#else
   BOTAN_UNUSED(crl);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_is_revoked(botan_x509_crl_t crl, botan_x509_cert_t cert) {
#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return BOTAN_FFI_VISIT(crl, [=](const auto& c) { return c.is_revoked(safe_get(cert)) ? 0 : -1; });
#else
   BOTAN_UNUSED(cert);
   BOTAN_UNUSED(crl);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}

int botan_x509_cert_verify_with_crl(int* result_code,
                                    botan_x509_cert_t cert,
                                    const botan_x509_cert_t* intermediates,
                                    size_t intermediates_len,
                                    const botan_x509_cert_t* trusted,
                                    size_t trusted_len,
                                    const botan_x509_crl_t* crls,
                                    size_t crls_len,
                                    const char* trusted_path,
                                    size_t required_strength,
                                    const char* hostname_cstr,
                                    uint64_t reference_time) {
   if(required_strength == 0) {
      required_strength = 110;
   }

#if defined(BOTAN_HAS_X509_CERTIFICATES)
   return ffi_guard_thunk(__func__, [=]() -> int {
      const std::string hostname((hostname_cstr == nullptr) ? "" : hostname_cstr);
      const Botan::Usage_Type usage = Botan::Usage_Type::UNSPECIFIED;
      const auto validation_time = reference_time == 0
                                      ? std::chrono::system_clock::now()
                                      : std::chrono::system_clock::from_time_t(static_cast<time_t>(reference_time));

      std::vector<Botan::X509_Certificate> end_certs;
      end_certs.push_back(safe_get(cert));
      for(size_t i = 0; i != intermediates_len; ++i) {
         end_certs.push_back(safe_get(intermediates[i]));
      }

      std::unique_ptr<Botan::Certificate_Store> trusted_from_path;
      std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_extra;
      std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_crls;
      std::vector<Botan::Certificate_Store*> trusted_roots;

      if(trusted_path && *trusted_path) {
         trusted_from_path = std::make_unique<Botan::Certificate_Store_In_Memory>(trusted_path);
         trusted_roots.push_back(trusted_from_path.get());
      }

      if(trusted_len > 0) {
         trusted_extra = std::make_unique<Botan::Certificate_Store_In_Memory>();
         for(size_t i = 0; i != trusted_len; ++i) {
            trusted_extra->add_certificate(safe_get(trusted[i]));
         }
         trusted_roots.push_back(trusted_extra.get());
      }

      if(crls_len > 0) {
         trusted_crls = std::make_unique<Botan::Certificate_Store_In_Memory>();
         for(size_t i = 0; i != crls_len; ++i) {
            trusted_crls->add_crl(safe_get(crls[i]));
         }
         trusted_roots.push_back(trusted_crls.get());
      }

      Botan::Path_Validation_Restrictions restrictions(false, required_strength);

      auto validation_result =
         Botan::x509_path_validate(end_certs, restrictions, trusted_roots, hostname, usage, validation_time);

      if(result_code) {
         *result_code = static_cast<int>(validation_result.result());
      }

      if(validation_result.successful_validation()) {
         return 0;
      } else {
         return 1;
      }
   });
#else
   BOTAN_UNUSED(result_code, cert, intermediates, intermediates_len, trusted);
   BOTAN_UNUSED(trusted_len, trusted_path, hostname_cstr, reference_time, crls, crls_len);
   return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
#endif
}
}

1	/*
2	* (C) 2015,2017,2018 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include <botan/ffi.h>
8
9	#include <botan/internal/ffi_pkey.h>
10	#include <botan/internal/ffi_util.h>
11	#include <memory>
12
13	#if defined(BOTAN_HAS_X509_CERTIFICATES)
14	#include <botan/data_src.h>
15	#include <botan/x509_crl.h>
16	#include <botan/x509cert.h>
17	#include <botan/x509path.h>
18	#endif
19
20	extern "C" {
21
22	using namespace Botan_FFI;
23
24	#if defined(BOTAN_HAS_X509_CERTIFICATES)
25
26	BOTAN_FFI_DECLARE_STRUCT(botan_x509_cert_struct, Botan::X509_Certificate, 0x8F628937);	24✔
27
28	#endif
29
30	int botan_x509_cert_load_file(botan_x509_cert_t* cert_obj, const char* cert_path) {	23✔
31	if(cert_obj == nullptr \|\| cert_path == nullptr) {	23✔
32	return BOTAN_FFI_ERROR_NULL_POINTER;
33	}
34
35	#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
36
37	return ffi_guard_thunk(__func__, [=]() -> int {	23✔
38	auto c = std::make_unique<Botan::X509_Certificate>(cert_path);	23✔
39	return ffi_new_object(cert_obj, std::move(c));	23✔
40	});	46✔
41
42	#else
43	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
44	#endif
45	}
46
47	int botan_x509_cert_dup(botan_x509_cert_t* cert_obj, botan_x509_cert_t cert) {	1✔
48	if(cert_obj == nullptr) {	1✔
49	return BOTAN_FFI_ERROR_NULL_POINTER;
50	}
51
52	#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
53
54	return ffi_guard_thunk(__func__, [=]() -> int {	1✔
55	auto c = std::make_unique<Botan::X509_Certificate>(safe_get(cert));	1✔
56	return ffi_new_object(cert_obj, std::move(c));	1✔
57	});	2✔
58
59	#else
60	BOTAN_UNUSED(cert);
61	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
62	#endif
63	}
64
65	int botan_x509_cert_load(botan_x509_cert_t* cert_obj, const uint8_t cert_bits[], size_t cert_bits_len) {	×
66	if(cert_obj == nullptr \|\| cert_bits == nullptr) {	×
67	return BOTAN_FFI_ERROR_NULL_POINTER;
68	}
69
70	#if defined(BOTAN_HAS_X509_CERTIFICATES)
71	return ffi_guard_thunk(__func__, [=]() -> int {	×
72	Botan::DataSource_Memory bits(cert_bits, cert_bits_len);	×
73	auto c = std::make_unique<Botan::X509_Certificate>(bits);	×
74	return ffi_new_object(cert_obj, std::move(c));	×
75	});	×
76	#else
77	BOTAN_UNUSED(cert_bits_len);
78	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
79	#endif
80	}
81
82	int botan_x509_cert_get_public_key(botan_x509_cert_t cert, botan_pubkey_t* key) {	2✔
83	if(key == nullptr) {	2✔
84	return BOTAN_FFI_ERROR_NULL_POINTER;
85	}
86
87	*key = nullptr;	2✔
88
89	#if defined(BOTAN_HAS_X509_CERTIFICATES)
90	return ffi_guard_thunk(__func__, [=]() -> int {	2✔
91	auto public_key = safe_get(cert).subject_public_key();	2✔
92	return ffi_new_object(key, std::move(public_key));	2✔
93	});	4✔
94	#else
95	BOTAN_UNUSED(cert);
96	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
97	#endif
98	}
99
100	int botan_x509_cert_get_issuer_dn(	8✔
101	botan_x509_cert_t cert, const char* key, size_t index, uint8_t out[], size_t* out_len) {
102	#if defined(BOTAN_HAS_X509_CERTIFICATES)
103	return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {	16✔
104	auto issuer_info = c.issuer_info(key);
105	if(index < issuer_info.size()) {
106	return write_str_output(out, out_len, c.issuer_info(key).at(index));
107	} else {
108	return BOTAN_FFI_ERROR_BAD_PARAMETER;
109	}
110	});
111	#else
112	BOTAN_UNUSED(cert, key, index, out, out_len);
113	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
114	#endif
115	}
116
117	int botan_x509_cert_get_subject_dn(	8✔
118	botan_x509_cert_t cert, const char* key, size_t index, uint8_t out[], size_t* out_len) {
119	#if defined(BOTAN_HAS_X509_CERTIFICATES)
120	return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {	16✔
121	auto subject_info = c.subject_info(key);
122	if(index < subject_info.size()) {
123	return write_str_output(out, out_len, c.subject_info(key).at(index));
124	} else {
125	return BOTAN_FFI_ERROR_BAD_PARAMETER;
126	}
127	});
128	#else
129	BOTAN_UNUSED(cert, key, index, out, out_len);
130	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
131	#endif
132	}
133
134	int botan_x509_cert_to_string(botan_x509_cert_t cert, char out[], size_t* out_len) {	2✔
135	return copy_view_str(reinterpret_cast<uint8_t*>(out), out_len, botan_x509_cert_view_as_string, cert);	2✔
136	}
137
138	int botan_x509_cert_view_as_string(botan_x509_cert_t cert, botan_view_ctx ctx, botan_view_str_fn view) {	3✔
139	#if defined(BOTAN_HAS_X509_CERTIFICATES)
140	return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return invoke_view_callback(view, ctx, c.to_string()); });	9✔
141	#else
142	BOTAN_UNUSED(cert, ctx, view);
143	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
144	#endif
145	}
146
147	int botan_x509_cert_allowed_usage(botan_x509_cert_t cert, unsigned int key_usage) {	7✔
148	#if defined(BOTAN_HAS_X509_CERTIFICATES)
149	return BOTAN_FFI_VISIT(cert, [=](const auto& c) -> int {	21✔
150	const Botan::Key_Constraints k = static_cast<Botan::Key_Constraints>(key_usage);
151	if(c.allowed_usage(k)) {
152	return BOTAN_FFI_SUCCESS;
153	}
154	return 1;
155	});
156	#else
157	BOTAN_UNUSED(cert, key_usage);
158	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
159	#endif
160	}
161
162	int botan_x509_cert_destroy(botan_x509_cert_t cert) {	24✔
163	#if defined(BOTAN_HAS_X509_CERTIFICATES)
164	return BOTAN_FFI_CHECKED_DELETE(cert);	24✔
165	#else
166	BOTAN_UNUSED(cert);
167	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
168	#endif
169	}
170
171	int botan_x509_cert_get_time_starts(botan_x509_cert_t cert, char out[], size_t* out_len) {	3✔
172	#if defined(BOTAN_HAS_X509_CERTIFICATES)
173	return BOTAN_FFI_VISIT(cert,	6✔
174	[=](const auto& c) { return write_str_output(out, out_len, c.not_before().to_string()); });
175	#else
176	BOTAN_UNUSED(cert, out, out_len);
177	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
178	#endif
179	}
180
181	int botan_x509_cert_get_time_expires(botan_x509_cert_t cert, char out[], size_t* out_len) {	2✔
182	#if defined(BOTAN_HAS_X509_CERTIFICATES)
183	return BOTAN_FFI_VISIT(cert,	4✔
184	[=](const auto& c) { return write_str_output(out, out_len, c.not_after().to_string()); });
185	#else
186	BOTAN_UNUSED(cert, out, out_len);
187	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
188	#endif
189	}
190
191	int botan_x509_cert_not_before(botan_x509_cert_t cert, uint64_t* time_since_epoch) {	2✔
192	#if defined(BOTAN_HAS_X509_CERTIFICATES)
193	return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *time_since_epoch = c.not_before().time_since_epoch(); });	4✔
194	#else
195	BOTAN_UNUSED(cert, time_since_epoch);
196	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
197	#endif
198	}
199
200	int botan_x509_cert_not_after(botan_x509_cert_t cert, uint64_t* time_since_epoch) {	2✔
201	#if defined(BOTAN_HAS_X509_CERTIFICATES)
202	return BOTAN_FFI_VISIT(cert, [=](const auto& c) { *time_since_epoch = c.not_after().time_since_epoch(); });	4✔
203	#else
204	BOTAN_UNUSED(cert, time_since_epoch);
205	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
206	#endif
207	}
208
209	int botan_x509_cert_get_serial_number(botan_x509_cert_t cert, uint8_t out[], size_t* out_len) {	3✔
210	#if defined(BOTAN_HAS_X509_CERTIFICATES)
211	return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.serial_number()); });	6✔
212	#else
213	BOTAN_UNUSED(cert, out, out_len);
214	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
215	#endif
216	}
217
218	int botan_x509_cert_get_fingerprint(botan_x509_cert_t cert, const char* hash, uint8_t out[], size_t* out_len) {	3✔
219	#if defined(BOTAN_HAS_X509_CERTIFICATES)
220	return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_str_output(out, out_len, c.fingerprint(hash)); });	6✔
221	#else
222	BOTAN_UNUSED(cert, hash, out, out_len);
223	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
224	#endif
225	}
226
227	int botan_x509_cert_get_authority_key_id(botan_x509_cert_t cert, uint8_t out[], size_t* out_len) {	1✔
228	#if defined(BOTAN_HAS_X509_CERTIFICATES)
229	return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.authority_key_id()); });	2✔
230	#else
231	BOTAN_UNUSED(cert, out, out_len);
232	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
233	#endif
234	}
235
236	int botan_x509_cert_get_subject_key_id(botan_x509_cert_t cert, uint8_t out[], size_t* out_len) {	3✔
237	#if defined(BOTAN_HAS_X509_CERTIFICATES)
238	return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return write_vec_output(out, out_len, c.subject_key_id()); });	6✔
239	#else
240	BOTAN_UNUSED(cert, out, out_len);
241	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
242	#endif
243	}
244
245	int botan_x509_cert_get_public_key_bits(botan_x509_cert_t cert, uint8_t out[], size_t* out_len) {	2✔
246	return copy_view_bin(out, out_len, botan_x509_cert_view_public_key_bits, cert);	2✔
247	}
248
249	int botan_x509_cert_view_public_key_bits(botan_x509_cert_t cert, botan_view_ctx ctx, botan_view_bin_fn view) {	3✔
250	#if defined(BOTAN_HAS_X509_CERTIFICATES)
251	return BOTAN_FFI_VISIT(cert,	6✔
252	[=](const auto& c) { return invoke_view_callback(view, ctx, c.subject_public_key_bits()); });
253	#else
254	BOTAN_UNUSED(cert, ctx, view);
255	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
256	#endif
257	}
258
259	int botan_x509_cert_hostname_match(botan_x509_cert_t cert, const char* hostname) {	6✔
260	if(hostname == nullptr) {	6✔
261	return BOTAN_FFI_ERROR_NULL_POINTER;
262	}
263
264	#if defined(BOTAN_HAS_X509_CERTIFICATES)
265	return BOTAN_FFI_VISIT(cert, [=](const auto& c) { return c.matches_dns_name(hostname) ? 0 : -1; });	12✔
266	#else
267	BOTAN_UNUSED(cert);
268	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
269	#endif
270	}
271
272	int botan_x509_cert_verify(int* result_code,	4✔
273	botan_x509_cert_t cert,
274	const botan_x509_cert_t* intermediates,
275	size_t intermediates_len,
276	const botan_x509_cert_t* trusted,
277	size_t trusted_len,
278	const char* trusted_path,
279	size_t required_strength,
280	const char* hostname_cstr,
281	uint64_t reference_time) {
282	if(required_strength == 0) {	4✔
283	required_strength = 110;	3✔
284	}
285
286	#if defined(BOTAN_HAS_X509_CERTIFICATES)
287	return ffi_guard_thunk(__func__, [=]() -> int {	4✔
288	const std::string hostname((hostname_cstr == nullptr) ? "" : hostname_cstr);	4✔
289	const Botan::Usage_Type usage = Botan::Usage_Type::UNSPECIFIED;	4✔
290	const auto validation_time = reference_time == 0	4✔
291	? std::chrono::system_clock::now()	4✔
292	: std::chrono::system_clock::from_time_t(static_cast<time_t>(reference_time));	×
293
294	std::vector<Botan::X509_Certificate> end_certs;	4✔
295	end_certs.push_back(safe_get(cert));	4✔
296	for(size_t i = 0; i != intermediates_len; ++i) {	9✔
297	end_certs.push_back(safe_get(intermediates[i]));	5✔
298	}
299
300	std::unique_ptr<Botan::Certificate_Store> trusted_from_path;	4✔
301	std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_extra;	4✔
302	std::vector<Botan::Certificate_Store*> trusted_roots;	4✔
303
304	if(trusted_path && *trusted_path) {	4✔
305	trusted_from_path = std::make_unique<Botan::Certificate_Store_In_Memory>(trusted_path);	×
306	trusted_roots.push_back(trusted_from_path.get());	×
307	}
308
309	if(trusted_len > 0) {	4✔
310	trusted_extra = std::make_unique<Botan::Certificate_Store_In_Memory>();	8✔
311	for(size_t i = 0; i != trusted_len; ++i) {	8✔
312	trusted_extra->add_certificate(safe_get(trusted[i]));	4✔
313	}
314	trusted_roots.push_back(trusted_extra.get());	4✔
315	}
316
317	Botan::Path_Validation_Restrictions restrictions(false, required_strength);	8✔
318
319	auto validation_result =	4✔
320	Botan::x509_path_validate(end_certs, restrictions, trusted_roots, hostname, usage, validation_time);	4✔
321
322	if(result_code) {	4✔
323	*result_code = static_cast<int>(validation_result.result());	4✔
324	}
325
326	if(validation_result.successful_validation()) {	4✔
327	return 0;
328	} else {
329	return 1;	3✔
330	}
331	});	4✔
332	#else
333	BOTAN_UNUSED(result_code, cert, intermediates, intermediates_len, trusted);
334	BOTAN_UNUSED(trusted_len, trusted_path, hostname_cstr, reference_time);
335	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
336	#endif
337	}
338
339	const char* botan_x509_cert_validation_status(int code) {	11✔
340	if(code < 0) {	11✔
341	return nullptr;
342	}
343
344	#if defined(BOTAN_HAS_X509_CERTIFICATES)
345	Botan::Certificate_Status_Code sc = static_cast<Botan::Certificate_Status_Code>(code);	11✔
346	return Botan::to_string(sc);	11✔
347	#else
348	return nullptr;
349	#endif
350	}
351
352	#if defined(BOTAN_HAS_X509_CERTIFICATES)
353
354	BOTAN_FFI_DECLARE_STRUCT(botan_x509_crl_struct, Botan::X509_CRL, 0x2C628910);	7✔
355
356	#endif
357
358	int botan_x509_crl_load_file(botan_x509_crl_t* crl_obj, const char* crl_path) {	6✔
359	if(crl_obj == nullptr \|\| crl_path == nullptr) {	6✔
360	return BOTAN_FFI_ERROR_NULL_POINTER;
361	}
362
363	#if defined(BOTAN_HAS_X509_CERTIFICATES) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
364
365	return ffi_guard_thunk(__func__, [=]() -> int {	6✔
366	auto c = std::make_unique<Botan::X509_CRL>(crl_path);	6✔
367	return ffi_new_object(crl_obj, std::move(c));	12✔
368	});	12✔
369
370	#else
371	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
372	#endif
373	}
374
375	int botan_x509_crl_load(botan_x509_crl_t* crl_obj, const uint8_t crl_bits[], size_t crl_bits_len) {	1✔
376	if(crl_obj == nullptr \|\| crl_bits == nullptr) {	1✔
377	return BOTAN_FFI_ERROR_NULL_POINTER;
378	}
379
380	#if defined(BOTAN_HAS_X509_CERTIFICATES)
381	return ffi_guard_thunk(__func__, [=]() -> int {	1✔
382	Botan::DataSource_Memory bits(crl_bits, crl_bits_len);	1✔
383	auto c = std::make_unique<Botan::X509_CRL>(bits);	1✔
384	return ffi_new_object(crl_obj, std::move(c));	1✔
385	});	3✔
386	#else
387	BOTAN_UNUSED(crl_bits_len);
388	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
389	#endif
390	}
391
392	int botan_x509_crl_destroy(botan_x509_crl_t crl) {	7✔
393	#if defined(BOTAN_HAS_X509_CERTIFICATES)
394	return BOTAN_FFI_CHECKED_DELETE(crl);	7✔
395	#else
396	BOTAN_UNUSED(crl);
397	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
398	#endif
399	}
400
401	int botan_x509_is_revoked(botan_x509_crl_t crl, botan_x509_cert_t cert) {	6✔
402	#if defined(BOTAN_HAS_X509_CERTIFICATES)
403	return BOTAN_FFI_VISIT(crl, [=](const auto& c) { return c.is_revoked(safe_get(cert)) ? 0 : -1; });	12✔
404	#else
405	BOTAN_UNUSED(cert);
406	BOTAN_UNUSED(crl);
407	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
408	#endif
409	}
410
411	int botan_x509_cert_verify_with_crl(int* result_code,	12✔
412	botan_x509_cert_t cert,
413	const botan_x509_cert_t* intermediates,
414	size_t intermediates_len,
415	const botan_x509_cert_t* trusted,
416	size_t trusted_len,
417	const botan_x509_crl_t* crls,
418	size_t crls_len,
419	const char* trusted_path,
420	size_t required_strength,
421	const char* hostname_cstr,
422	uint64_t reference_time) {
423	if(required_strength == 0) {	12✔
424	required_strength = 110;	2✔
425	}
426
427	#if defined(BOTAN_HAS_X509_CERTIFICATES)
428	return ffi_guard_thunk(__func__, [=]() -> int {	12✔
429	const std::string hostname((hostname_cstr == nullptr) ? "" : hostname_cstr);	14✔
430	const Botan::Usage_Type usage = Botan::Usage_Type::UNSPECIFIED;	12✔
431	const auto validation_time = reference_time == 0	12✔
432	? std::chrono::system_clock::now()	12✔
433	: std::chrono::system_clock::from_time_t(static_cast<time_t>(reference_time));	1✔
434
435	std::vector<Botan::X509_Certificate> end_certs;	12✔
436	end_certs.push_back(safe_get(cert));	12✔
437	for(size_t i = 0; i != intermediates_len; ++i) {	30✔
438	end_certs.push_back(safe_get(intermediates[i]));	18✔
439	}
440
441	std::unique_ptr<Botan::Certificate_Store> trusted_from_path;	12✔
442	std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_extra;	12✔
443	std::unique_ptr<Botan::Certificate_Store_In_Memory> trusted_crls;	12✔
444	std::vector<Botan::Certificate_Store*> trusted_roots;	12✔
445
446	if(trusted_path && *trusted_path) {	12✔
447	trusted_from_path = std::make_unique<Botan::Certificate_Store_In_Memory>(trusted_path);	2✔
448	trusted_roots.push_back(trusted_from_path.get());	2✔
449	}
450
451	if(trusted_len > 0) {	12✔
452	trusted_extra = std::make_unique<Botan::Certificate_Store_In_Memory>();	18✔
453	for(size_t i = 0; i != trusted_len; ++i) {	18✔
454	trusted_extra->add_certificate(safe_get(trusted[i]));	9✔
455	}
456	trusted_roots.push_back(trusted_extra.get());	9✔
457	}
458
459	if(crls_len > 0) {	12✔
460	trusted_crls = std::make_unique<Botan::Certificate_Store_In_Memory>();	10✔
461	for(size_t i = 0; i != crls_len; ++i) {	13✔
462	trusted_crls->add_crl(safe_get(crls[i]));	8✔
463	}
464	trusted_roots.push_back(trusted_crls.get());	5✔
465	}
466
467	Botan::Path_Validation_Restrictions restrictions(false, required_strength);	24✔
468
469	auto validation_result =	12✔
470	Botan::x509_path_validate(end_certs, restrictions, trusted_roots, hostname, usage, validation_time);	12✔
471
472	if(result_code) {	12✔
473	*result_code = static_cast<int>(validation_result.result());	12✔
474	}
475
476	if(validation_result.successful_validation()) {	12✔
477	return 0;
478	} else {
479	return 1;	8✔
480	}
481	});	14✔
482	#else
483	BOTAN_UNUSED(result_code, cert, intermediates, intermediates_len, trusted);
484	BOTAN_UNUSED(trusted_len, trusted_path, hostname_cstr, reference_time, crls, crls_len);
485	return BOTAN_FFI_ERROR_NOT_IMPLEMENTED;
486	#endif
487	}
488	}

randombit / botan / 16248620128

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous