9#include <botan/internal/os_utils.h>
11#include <botan/exceptn.h>
12#include <botan/mem_ops.h>
13#include <botan/internal/parsing.h>
14#include <botan/internal/target_info.h>
16#if defined(BOTAN_HAS_CPUID)
17 #include <botan/internal/cpuid.h>
26#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
33 #include <sys/resource.h>
34 #include <sys/types.h>
40#if defined(BOTAN_TARGET_OS_IS_EMSCRIPTEN)
41 #include <emscripten/emscripten.h>
44#if defined(BOTAN_TARGET_OS_HAS_GETAUXVAL) || defined(BOTAN_TARGET_OS_HAS_ELF_AUX_INFO)
48#if defined(BOTAN_TARGET_OS_HAS_WIN32)
52 #if defined(BOTAN_BUILD_COMPILER_IS_MSVC)
53 #include <libloaderapi.h>
54 #include <stringapiset.h>
58#if defined(BOTAN_TARGET_OS_IS_IOS) || defined(BOTAN_TARGET_OS_IS_MACOS)
59 #include <mach/vm_statistics.h>
60 #include <sys/sysctl.h>
61 #include <sys/types.h>
64#if defined(BOTAN_TARGET_OS_HAS_PRCTL)
65 #include <sys/prctl.h>
68#if defined(BOTAN_TARGET_OS_IS_FREEBSD) || defined(BOTAN_TARGET_OS_IS_OPENBSD) || defined(BOTAN_TARGET_OS_IS_DRAGONFLY)
69 #include <pthread_np.h>
72#if defined(BOTAN_TARGET_OS_IS_HAIKU)
73 #include <kernel/OS.h>
79#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
81#elif defined(BOTAN_TARGET_OS_HAS_WIN32)
82 return ::GetCurrentProcessId();
83#elif defined(BOTAN_TARGET_OS_IS_LLVM) || defined(BOTAN_TARGET_OS_IS_NONE)
86 #error "Missing get_process_id"
92#if defined(BOTAN_TARGET_OS_HAS_GETAUXVAL) || defined(BOTAN_TARGET_OS_HAS_ELF_AUX_INFO)
93 #define BOTAN_TARGET_HAS_AUXVAL_INTERFACE
96std::optional<unsigned long> auxval_hwcap() {
99#elif defined(BOTAN_TARGET_HAS_AUXVAL_INTERFACE)
108std::optional<unsigned long> auxval_hwcap2() {
109#if defined(AT_HWCAP2)
111#elif defined(BOTAN_TARGET_HAS_AUXVAL_INTERFACE)
120std::optional<unsigned long> get_auxval(std::optional<unsigned long>
id) {
122#if defined(BOTAN_TARGET_OS_HAS_GETAUXVAL)
123 return ::getauxval(*
id);
124#elif defined(BOTAN_TARGET_OS_HAS_ELF_AUX_INFO)
125 unsigned long auxinfo = 0;
126 if(::elf_aux_info(
static_cast<int>(*
id), &auxinfo,
sizeof(auxinfo)) == 0) {
138 if(
const auto hwcap = get_auxval(auxval_hwcap())) {
141 const auto hwcap2 = get_auxval(auxval_hwcap2()).value_or(0);
142 return std::make_pair(*hwcap, hwcap2);
154bool running_in_privileged_state() {
155#if defined(AT_SECURE)
156 if(
const auto at_secure = get_auxval(AT_SECURE)) {
157 return at_secure != 0;
161#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
162 return (::getuid() != ::geteuid()) || (::getgid() != ::getegid());
173#if defined(BOTAN_TARGET_OS_HAS_WIN32)
175 ::QueryPerformanceCounter(&tv);
178#elif defined(BOTAN_USE_GCC_INLINE_ASM)
182 #if defined(BOTAN_TARGET_ARCH_IS_X86_64)
184 uint32_t rtc_low = 0;
185 uint32_t rtc_high = 0;
186 asm volatile(
"rdtsc" :
"=d"(rtc_high),
"=a"(rtc_low));
187 rtc = (
static_cast<uint64_t
>(rtc_high) << 32) | rtc_low;
189 #elif defined(BOTAN_TARGET_ARCH_IS_X86_FAMILY) && defined(BOTAN_HAS_CPUID)
192 uint32_t rtc_low = 0;
193 uint32_t rtc_high = 0;
194 asm volatile(
"rdtsc" :
"=d"(rtc_high),
"=a"(rtc_low));
195 rtc = (
static_cast<uint64_t
>(rtc_high) << 32) | rtc_low;
198 #elif defined(BOTAN_TARGET_ARCH_IS_PPC64)
201 uint32_t rtc_low = 0;
202 uint32_t rtc_high = 0;
203 uint32_t rtc_high2 = 0;
204 asm volatile(
"mftbu %0" :
"=r"(rtc_high));
205 asm volatile(
"mftb %0" :
"=r"(rtc_low));
206 asm volatile(
"mftbu %0" :
"=r"(rtc_high2));
208 if(rtc_high == rtc_high2) {
209 rtc = (
static_cast<uint64_t
>(rtc_high) << 32) | rtc_low;
214 #elif defined(BOTAN_TARGET_ARCH_IS_ALPHA)
215 asm volatile(
"rpcc %0" :
"=r"(rtc));
217 #elif defined(BOTAN_TARGET_ARCH_IS_SPARC64) && !defined(BOTAN_TARGET_OS_IS_OPENBSD)
219 asm volatile(
"rd %%tick, %0" :
"=r"(rtc));
221 #elif defined(BOTAN_TARGET_ARCH_IS_IA64)
222 asm volatile(
"mov %0=ar.itc" :
"=r"(rtc));
224 #elif defined(BOTAN_TARGET_ARCH_IS_S390X)
225 asm volatile(
"stck 0(%0)" : :
"a"(&rtc) :
"memory",
"cc");
227 #elif defined(BOTAN_TARGET_ARCH_IS_HPPA)
228 asm volatile(
"mfctl 16,%0" :
"=r"(rtc));
242#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
244 #if defined(_SC_NPROCESSORS_ONLN)
245 const long cpu_online = ::sysconf(_SC_NPROCESSORS_ONLN);
247 return static_cast<size_t>(cpu_online);
251 #if defined(_SC_NPROCESSORS_CONF)
252 const long cpu_conf = ::sysconf(_SC_NPROCESSORS_CONF);
254 return static_cast<size_t>(cpu_conf);
260#if defined(BOTAN_TARGET_OS_HAS_THREADS)
263 const size_t hw_concur = std::thread::hardware_concurrency();
278#if defined(BOTAN_TARGET_OS_IS_EMSCRIPTEN)
279 return emscripten_get_now();
289#if defined(BOTAN_TARGET_OS_HAS_CLOCK_GETTIME)
292 const clockid_t clock_types[] = {
293 #if defined(CLOCK_MONOTONIC_HR)
296 #if defined(CLOCK_MONOTONIC_RAW)
299 #if defined(CLOCK_MONOTONIC)
302 #if defined(CLOCK_PROCESS_CPUTIME_ID)
303 CLOCK_PROCESS_CPUTIME_ID,
305 #if defined(CLOCK_THREAD_CPUTIME_ID)
306 CLOCK_THREAD_CPUTIME_ID,
310 for(
const clockid_t clock : clock_types) {
311 struct timespec ts {};
313 if(::clock_gettime(clock, &ts) == 0) {
314 return (
static_cast<uint64_t
>(ts.tv_sec) * 1000000000) +
static_cast<uint64_t
>(ts.tv_nsec);
319#if defined(BOTAN_TARGET_OS_HAS_SYSTEM_CLOCK)
321 const auto now = std::chrono::high_resolution_clock::now().time_since_epoch();
322 return std::chrono::duration_cast<std::chrono::nanoseconds>(now).count();
329#if defined(BOTAN_TARGET_OS_HAS_CLOCK_GETTIME)
330 struct timespec ts {};
332 if(::clock_gettime(CLOCK_REALTIME, &ts) == 0) {
333 return (
static_cast<uint64_t
>(ts.tv_sec) * 1000000000) +
static_cast<uint64_t
>(ts.tv_nsec);
337#if defined(BOTAN_TARGET_OS_HAS_SYSTEM_CLOCK)
338 const auto now = std::chrono::system_clock::now().time_since_epoch();
339 return std::chrono::duration_cast<std::chrono::nanoseconds>(now).count();
341 throw Not_Implemented(
"OS::get_system_timestamp_ns this system does not support a clock");
346#if defined(BOTAN_TARGET_OS_HAS_CLOCK_GETTIME) && defined(CLOCK_THREAD_CPUTIME_ID)
349 static const bool usable = []() {
350 struct timespec res {};
351 return ::clock_getres(CLOCK_THREAD_CPUTIME_ID, &res) == 0 && res.tv_sec == 0 && res.tv_nsec <= 10000;
355 struct timespec ts {};
357 if(::clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) == 0) {
358 return (
static_cast<uint64_t
>(ts.tv_sec) * 1000000000) +
static_cast<uint64_t
>(ts.tv_nsec);
369#if defined(BOTAN_TARGET_OS_HAS_WIN32)
370 if(::localtime_s(&tm, &time) != 0) {
373#elif defined(BOTAN_TARGET_OS_HAS_POSIX1)
374 if(::localtime_r(&time, &tm) ==
nullptr) {
378 if(
auto tmp = std::localtime(&time)) {
385 std::ostringstream oss;
386 oss << std::put_time(&tm, format.c_str());
391 const size_t default_page_size = 4096;
393#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
394 const long p = ::sysconf(_SC_PAGESIZE);
396 return static_cast<size_t>(p);
398 return default_page_size;
400#elif defined(BOTAN_TARGET_OS_HAS_VIRTUAL_LOCK)
402 SYSTEM_INFO sys_info;
403 ::GetSystemInfo(&sys_info);
404 return sys_info.dwPageSize;
406 return default_page_size;
419 const size_t max_locked_kb = 512;
425#if defined(RLIMIT_MEMLOCK) && defined(BOTAN_TARGET_OS_HAS_POSIX1) && defined(BOTAN_TARGET_OS_HAS_POSIX_MLOCK)
426 const size_t mlock_requested =
429 if(mlock_requested > 0) {
430 struct ::rlimit limits {};
432 ::getrlimit(RLIMIT_MEMLOCK, &limits);
434 if(limits.rlim_cur < limits.rlim_max) {
435 limits.rlim_cur = limits.rlim_max;
436 ::setrlimit(RLIMIT_MEMLOCK, &limits);
437 ::getrlimit(RLIMIT_MEMLOCK, &limits);
440 return std::min<size_t>(limits.rlim_cur, mlock_requested * 1024);
443#elif defined(BOTAN_TARGET_OS_HAS_VIRTUAL_LOCK)
444 const size_t mlock_requested =
447 SIZE_T working_min = 0, working_max = 0;
448 if(!::GetProcessWorkingSetSize(::GetCurrentProcess(), &working_min, &working_max)) {
459 if(working_min > overhead) {
460 const size_t lockable_bytes = working_min - overhead;
461 return std::min<size_t>(lockable_bytes, mlock_requested * 1024);
474 if(running_in_privileged_state()) {
478#if defined(BOTAN_TARGET_OS_HAS_WIN32) && \
479 (defined(BOTAN_BUILD_COMPILER_IS_MSVC) || defined(BOTAN_BUILD_COMPILER_IS_CLANGCL))
480 const std::string
name(name_view);
484 if(getenv_s(&req_size,
nullptr, 0,
name.c_str()) != 0 || req_size == 0) {
489 std::string val(req_size,
'\0');
490 if(getenv_s(&req_size, val.data(), val.size(),
name.c_str()) != 0) {
494 value_out = std::string(val.c_str());
497 const std::string
name(name_view);
498 if(
const char* val = std::getenv(
name.c_str())) {
510 if(
const auto sz =
parse_sz(value)) {
518#if defined(BOTAN_TARGET_OS_HAS_POSIX1) && defined(BOTAN_TARGET_OS_HAS_POSIX_MLOCK)
523 #if defined(BOTAN_TARGET_OS_IS_IOS) || defined(BOTAN_TARGET_OS_IS_MACOS)
526 static constexpr int default_locked_fd = 255;
527 int locked_fd = default_locked_fd;
530 if(locked_fdl < 240 || locked_fdl > 255) {
531 locked_fdl = default_locked_fd;
533 locked_fd =
static_cast<int>(locked_fdl);
535 return VM_MAKE_TAG(locked_fd);
542 int flags = MAP_PRIVATE;
544 #if defined(MAP_ANONYMOUS)
545 flags |= MAP_ANONYMOUS;
546 #elif defined(MAP_ANON)
550 #if defined(MAP_CONCEAL)
551 flags |= MAP_CONCEAL;
552 #elif defined(MAP_NOCORE)
560 int prot = PROT_READ | PROT_WRITE;
562 #if defined(PROT_MAX)
563 prot |= PROT_MAX(prot);
574 std::vector<void*> result;
576#if(defined(BOTAN_TARGET_OS_HAS_POSIX1) && defined(BOTAN_TARGET_OS_HAS_POSIX_MLOCK)) || \
577 defined(BOTAN_TARGET_OS_HAS_VIRTUAL_LOCK)
579 result.reserve(count);
583 #if defined(BOTAN_TARGET_OS_HAS_POSIX1) && defined(BOTAN_TARGET_OS_HAS_POSIX_MLOCK)
584 static const int locked_fd = get_locked_fd();
587 for(
size_t i = 0; i != count; ++i) {
590 #if defined(BOTAN_TARGET_OS_HAS_POSIX1) && defined(BOTAN_TARGET_OS_HAS_POSIX_MLOCK)
591 ptr = ::mmap(
nullptr,
598 if(ptr == MAP_FAILED) {
603 if(::mlock(
static_cast<uint8_t*
>(ptr) + page_size, page_size) != 0) {
604 ::munmap(ptr, 3 * page_size);
608 #if defined(MADV_DONTDUMP)
610 ::madvise(
static_cast<uint8_t*
>(ptr) + page_size, page_size, MADV_DONTDUMP);
613 #elif defined(BOTAN_TARGET_OS_HAS_VIRTUAL_LOCK)
614 ptr = ::VirtualAlloc(
nullptr, 3 * page_size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
619 if(::VirtualLock(
static_cast<uint8_t*
>(ptr) + page_size, page_size) == 0) {
620 ::VirtualFree(ptr, 0, MEM_RELEASE);
625 std::memset(ptr, 0, 3 * page_size);
627 #if defined(BOTAN_TARGET_OS_HAS_PRCTL) && defined(PR_SET_VMA) && defined(PR_SET_VMA_ANON_NAME)
629 static constexpr char page_name[] =
"Botan mlock pool";
631 const int rc = ::prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, ptr, 3 * page_size, page_name);
640 result.push_back(
static_cast<uint8_t*
>(ptr) + page_size);
650#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
652 ::mprotect(page, page_size, PROT_READ | PROT_WRITE);
653#elif defined(BOTAN_TARGET_OS_HAS_VIRTUAL_LOCK)
656 ::VirtualProtect(page, page_size, PAGE_READWRITE, &old_perms);
664#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
666 ::mprotect(page, page_size, PROT_NONE);
667#elif defined(BOTAN_TARGET_OS_HAS_VIRTUAL_LOCK)
670 ::VirtualProtect(page, page_size, PAGE_NOACCESS, &old_perms);
677#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
681static uint64_t g_fork_generation = 1;
683void atfork_in_child() {
684 g_fork_generation += 1;
686 if(g_fork_generation == 0) {
687 g_fork_generation = 1;
692 const int rc = ::pthread_atfork(
nullptr,
705#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
706 static std::once_flag g_atfork_initialized;
707 std::call_once(g_atfork_initialized, setup_atfork);
708 return g_fork_generation;
728 for(
void* ptr : pages) {
735#if defined(BOTAN_TARGET_OS_HAS_POSIX1) && defined(BOTAN_TARGET_OS_HAS_POSIX_MLOCK)
736 ::munlock(ptr, page_size);
737 ::munmap(
static_cast<uint8_t*
>(ptr) - page_size, 3 * page_size);
738#elif defined(BOTAN_TARGET_OS_HAS_VIRTUAL_LOCK)
739 ::VirtualUnlock(ptr, page_size);
740 ::VirtualFree(
static_cast<uint8_t*
>(ptr) - page_size, 0, MEM_RELEASE);
745#if defined(BOTAN_TARGET_OS_HAS_THREADS)
746void OS::set_thread_name(std::thread& thread,
const std::string&
name) {
747 #if defined(BOTAN_TARGET_OS_IS_LINUX) || defined(BOTAN_TARGET_OS_IS_FREEBSD) || defined(BOTAN_TARGET_OS_IS_DRAGONFLY)
748 static_cast<void>(pthread_setname_np(thread.native_handle(),
name.c_str()));
749 #elif defined(BOTAN_TARGET_OS_IS_OPENBSD)
750 static_cast<void>(pthread_set_name_np(thread.native_handle(),
name.c_str()));
751 #elif defined(BOTAN_TARGET_OS_IS_NETBSD)
752 static_cast<void>(pthread_setname_np(thread.native_handle(),
"%s",
const_cast<char*
>(
name.c_str())));
753 #elif defined(BOTAN_TARGET_OS_HAS_WIN32) && defined(BOTAN_BUILD_COMPILER_IS_MSVC)
754 typedef HRESULT(WINAPI * std_proc)(HANDLE, PCWSTR);
755 HMODULE kern = GetModuleHandleA(
"KernelBase.dll");
756 std_proc set_thread_name =
reinterpret_cast<std_proc
>(GetProcAddress(kern,
"SetThreadDescription"));
757 if(set_thread_name) {
759 auto sz = MultiByteToWideChar(CP_UTF8, 0,
name.data(), -1,
nullptr, 0);
762 if(MultiByteToWideChar(CP_UTF8, 0,
name.data(), -1, &w[0], sz) > 0) {
763 (void)set_thread_name(thread.native_handle(), w.c_str());
767 #elif defined(BOTAN_TARGET_OS_IS_HAIKU)
768 auto thread_id = get_pthread_thread_id(thread.native_handle());
769 static_cast<void>(rename_thread(thread_id,
name.c_str()));
778#if defined(BOTAN_TARGET_OS_HAS_POSIX1) && !defined(BOTAN_TARGET_OS_IS_EMSCRIPTEN)
790::sigjmp_buf g_sigill_jmp_buf;
791::pthread_t g_sigill_probe_thread;
792struct sigaction g_sigill_prev_action;
796void botan_sigill_handler(
int sig) {
797 if(::pthread_equal(::pthread_self(), g_sigill_probe_thread) != 0) {
798 siglongjmp(g_sigill_jmp_buf, 1);
807 ::sigaction(sig, &g_sigill_prev_action,
nullptr);
815 volatile int probe_result = -3;
817#if defined(BOTAN_TARGET_OS_HAS_POSIX1) && !defined(BOTAN_TARGET_OS_IS_EMSCRIPTEN)
819 #if defined(BOTAN_TARGET_OS_HAS_THREADS)
821 static std::mutex g_sigill_probe_mutex;
822 const std::lock_guard<std::mutex>
lock(g_sigill_probe_mutex);
825 struct sigaction sigaction {};
827 sigaction.sa_handler = botan_sigill_handler;
828 sigemptyset(&sigaction.sa_mask);
829 sigaction.sa_flags = 0;
831 g_sigill_probe_thread = ::pthread_self();
833 int rc = ::sigaction(SIGILL, &sigaction, &g_sigill_prev_action);
836 throw System_Error(
"run_cpu_instruction_probe sigaction failed", errno);
839 rc = sigsetjmp(g_sigill_jmp_buf, 1);
843 probe_result = probe_fn();
850 rc = ::sigaction(SIGILL, &g_sigill_prev_action,
nullptr);
852 throw System_Error(
"run_cpu_instruction_probe sigaction restore failed", errno);
863#if defined(BOTAN_TARGET_OS_HAS_POSIX1)
866 POSIX_Echo_Suppression() : m_stdin_fd(fileno(stdin)), m_old_termios{} {
867 if(::tcgetattr(m_stdin_fd, &m_old_termios) != 0) {
868 throw System_Error(
"Getting terminal status failed", errno);
871 struct termios noecho_flags = m_old_termios;
872 noecho_flags.c_lflag &= ~ECHO;
873 noecho_flags.c_lflag |= ECHONL;
875 if(::tcsetattr(m_stdin_fd, TCSANOW, &noecho_flags) != 0) {
876 throw System_Error(
"Clearing terminal echo bit failed", errno);
880 void reenable_echo()
override {
882 if(::tcsetattr(m_stdin_fd, TCSANOW, &m_old_termios) != 0) {
883 throw System_Error(
"Restoring terminal echo bit failed", errno);
889 ~POSIX_Echo_Suppression()
override {
895 POSIX_Echo_Suppression(
const POSIX_Echo_Suppression& other) =
delete;
896 POSIX_Echo_Suppression(POSIX_Echo_Suppression&& other) =
delete;
897 POSIX_Echo_Suppression& operator=(
const POSIX_Echo_Suppression& other) =
delete;
898 POSIX_Echo_Suppression& operator=(POSIX_Echo_Suppression&& other) =
delete;
902 struct termios m_old_termios;
905 return std::make_unique<POSIX_Echo_Suppression>();
907#elif defined(BOTAN_TARGET_OS_HAS_WIN32)
911 Win32_Echo_Suppression() : m_input_handle(::GetStdHandle(STD_INPUT_HANDLE)) {
912 if(::GetConsoleMode(m_input_handle, &m_console_state) == 0)
913 throw System_Error(
"Getting console mode failed", ::GetLastError());
915 DWORD new_mode = ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT;
916 if(::SetConsoleMode(m_input_handle, new_mode) == 0)
917 throw System_Error(
"Setting console mode failed", ::GetLastError());
920 void reenable_echo()
override {
921 if(m_input_handle != INVALID_HANDLE_VALUE) {
922 if(::SetConsoleMode(m_input_handle, m_console_state) == 0)
923 throw System_Error(
"Setting console mode failed", ::GetLastError());
924 m_input_handle = INVALID_HANDLE_VALUE;
928 ~Win32_Echo_Suppression()
override {
934 Win32_Echo_Suppression(
const Win32_Echo_Suppression& other) =
delete;
935 Win32_Echo_Suppression(Win32_Echo_Suppression&& other) =
delete;
936 Win32_Echo_Suppression& operator=(
const Win32_Echo_Suppression& other) =
delete;
937 Win32_Echo_Suppression& operator=(Win32_Echo_Suppression&& other) =
delete;
940 HANDLE m_input_handle;
941 DWORD m_console_state;
944 return std::make_unique<Win32_Echo_Suppression>();
static bool has(CPUID::Feature feat)
bool fork_detected() const
size_t get_memory_locking_limit()
uint64_t BOTAN_TEST_API get_high_resolution_clock()
size_t BOTAN_TEST_API get_cpu_available()
std::unique_ptr< Echo_Suppression > BOTAN_UNSTABLE_API suppress_echo_on_terminal()
size_t read_env_variable_sz(std::string_view var_name, size_t def_value=0)
void page_allow_access(void *page)
std::string BOTAN_TEST_API format_time(time_t time, const std::string &format)
bool read_env_variable(std::string &value_out, std::string_view var_name)
void page_prohibit_access(void *page)
std::optional< std::pair< unsigned long, unsigned long > > get_auxval_hwcap()
int BOTAN_TEST_API run_cpu_instruction_probe(const std::function< int()> &probe_fn)
std::vector< void * > allocate_locked_pages(size_t count)
size_t system_page_size()
uint64_t BOTAN_TEST_API get_system_timestamp_ns()
std::optional< uint64_t > BOTAN_TEST_API get_thread_cpu_time_ns()
void free_locked_pages(const std::vector< void * > &pages)
uint32_t BOTAN_TEST_API get_process_id()
uint64_t BOTAN_TEST_API get_cpu_cycle_counter()
uint64_t BOTAN_TEST_API get_fork_generation()
std::optional< size_t > parse_sz(std::string_view input, bool require_canonical)
secure_vector< T > lock(const std::vector< T > &in)
void secure_scrub_memory(void *ptr, size_t n)