#ifndef OPENSSL_HEADER_CRYPTO_INTERNAL_H
#define OPENSSL_HEADER_CRYPTO_INTERNAL_H
#include <openssl/ex_data.h>
#include <openssl/stack.h>
#include <openssl/thread.h>
#include <assert.h>
#include <string.h>
#if defined(BORINGSSL_CONSTANT_TIME_VALIDATION)
#include <valgrind/memcheck.h>
#endif
#if !defined(__cplusplus)
#if defined(_MSC_VER)
#define alignas(x) __declspec(align(x))
#define alignof __alignof
#else
#include <stdalign.h>
#endif
#endif
#if defined(OPENSSL_THREADS) && \
(!defined(OPENSSL_WINDOWS) || defined(__MINGW32__))
#include <pthread.h>
#define OPENSSL_PTHREADS
#endif
#if defined(OPENSSL_THREADS) && !defined(OPENSSL_PTHREADS) && \
defined(OPENSSL_WINDOWS)
#define OPENSSL_WINDOWS_THREADS
OPENSSL_MSVC_PRAGMA(warning(push, 3))
#include <windows.h>
OPENSSL_MSVC_PRAGMA(warning(pop))
#endif
#if defined(__cplusplus)
extern "C" {
#endif
#if defined(OPENSSL_X86) || defined(OPENSSL_X86_64) || defined(OPENSSL_ARM) || \
defined(OPENSSL_AARCH64) || defined(OPENSSL_PPC64LE)
void OPENSSL_cpuid_setup(void);
#endif
#if (defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64)) && \
!defined(OPENSSL_STATIC_ARMCAP)
OPENSSL_EXPORT uint32_t *OPENSSL_get_armcap_pointer_for_test(void);
#endif
#if (!defined(_MSC_VER) || defined(__clang__)) && defined(OPENSSL_64_BIT)
#define BORINGSSL_HAS_UINT128
typedef __int128_t int128_t;
typedef __uint128_t uint128_t;
#if !defined(_MSC_VER) || !defined(__clang__)
#define BORINGSSL_CAN_DIVIDE_UINT128
#endif
#endif
#define OPENSSL_ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
#if defined(__cplusplus) && __cplusplus >= 201703L
#define OPENSSL_FALLTHROUGH [[fallthrough]]
#elif defined(__cplusplus) && __cplusplus >= 201103L && defined(__clang__)
#define OPENSSL_FALLTHROUGH [[clang::fallthrough]]
#elif defined(__cplusplus) && __cplusplus >= 201103L && defined(__GNUC__) && \
__GNUC__ >= 7
#define OPENSSL_FALLTHROUGH [[gnu::fallthrough]]
#elif defined(__GNUC__) && __GNUC__ >= 7
#define OPENSSL_FALLTHROUGH __attribute__ ((fallthrough))
#elif defined(__clang__)
#if __has_attribute(fallthrough) && __clang_major__ >= 5
#define OPENSSL_FALLTHROUGH __attribute__ ((fallthrough))
#else
#define OPENSSL_FALLTHROUGH
#endif
#else
#define OPENSSL_FALLTHROUGH
#endif
#if defined(__SSE2__) && !defined(OPENSSL_NO_SSE2_FOR_TESTING)
#define OPENSSL_SSE2
#endif
static inline int buffers_alias(const uint8_t *a, size_t a_len,
const uint8_t *b, size_t b_len) {
uintptr_t a_u = (uintptr_t)a;
uintptr_t b_u = (uintptr_t)b;
return a_u + a_len > b_u && b_u + b_len > a_u;
}
#if defined(OPENSSL_64_BIT)
typedef uint64_t crypto_word_t;
#elif defined(OPENSSL_32_BIT)
typedef uint32_t crypto_word_t;
#else
#error "Must define either OPENSSL_32_BIT or OPENSSL_64_BIT"
#endif
#define CONSTTIME_TRUE_W ~((crypto_word_t)0)
#define CONSTTIME_FALSE_W ((crypto_word_t)0)
#define CONSTTIME_TRUE_8 ((uint8_t)0xff)
#define CONSTTIME_FALSE_8 ((uint8_t)0)
static inline crypto_word_t value_barrier_w(crypto_word_t a) {
#if !defined(OPENSSL_NO_ASM) && (defined(__GNUC__) || defined(__clang__))
__asm__("" : "+r"(a) : );
#endif
return a;
}
static inline uint32_t value_barrier_u32(uint32_t a) {
#if !defined(OPENSSL_NO_ASM) && (defined(__GNUC__) || defined(__clang__))
__asm__("" : "+r"(a) : );
#endif
return a;
}
static inline uint64_t value_barrier_u64(uint64_t a) {
#if !defined(OPENSSL_NO_ASM) && (defined(__GNUC__) || defined(__clang__))
__asm__("" : "+r"(a) : );
#endif
return a;
}
static inline crypto_word_t constant_time_msb_w(crypto_word_t a) {
return 0u - (a >> (sizeof(a) * 8 - 1));
}
static inline crypto_word_t constant_time_lt_w(crypto_word_t a,
crypto_word_t b) {
return constant_time_msb_w(a^((a^b)|((a-b)^a)));
}
static inline uint8_t constant_time_lt_8(crypto_word_t a, crypto_word_t b) {
return (uint8_t)(constant_time_lt_w(a, b));
}
static inline crypto_word_t constant_time_ge_w(crypto_word_t a,
crypto_word_t b) {
return ~constant_time_lt_w(a, b);
}
static inline uint8_t constant_time_ge_8(crypto_word_t a, crypto_word_t b) {
return (uint8_t)(constant_time_ge_w(a, b));
}
static inline crypto_word_t constant_time_is_zero_w(crypto_word_t a) {
return constant_time_msb_w(~a & (a - 1));
}
static inline uint8_t constant_time_is_zero_8(crypto_word_t a) {
return (uint8_t)(constant_time_is_zero_w(a));
}
static inline crypto_word_t constant_time_eq_w(crypto_word_t a,
crypto_word_t b) {
return constant_time_is_zero_w(a ^ b);
}
static inline uint8_t constant_time_eq_8(crypto_word_t a, crypto_word_t b) {
return (uint8_t)(constant_time_eq_w(a, b));
}
static inline crypto_word_t constant_time_eq_int(int a, int b) {
return constant_time_eq_w((crypto_word_t)(a), (crypto_word_t)(b));
}
static inline uint8_t constant_time_eq_int_8(int a, int b) {
return constant_time_eq_8((crypto_word_t)(a), (crypto_word_t)(b));
}
static inline crypto_word_t constant_time_select_w(crypto_word_t mask,
crypto_word_t a,
crypto_word_t b) {
return (value_barrier_w(mask) & a) | (value_barrier_w(~mask) & b);
}
static inline uint8_t constant_time_select_8(uint8_t mask, uint8_t a,
uint8_t b) {
return (uint8_t)(constant_time_select_w(mask, a, b));
}
static inline int constant_time_select_int(crypto_word_t mask, int a, int b) {
return (int)(constant_time_select_w(mask, (crypto_word_t)(a),
(crypto_word_t)(b)));
}
#if defined(BORINGSSL_CONSTANT_TIME_VALIDATION)
#define CONSTTIME_SECRET(x, y) VALGRIND_MAKE_MEM_UNDEFINED(x, y)
#define CONSTTIME_DECLASSIFY(x, y) VALGRIND_MAKE_MEM_DEFINED(x, y)
#else
#define CONSTTIME_SECRET(x, y)
#define CONSTTIME_DECLASSIFY(x, y)
#endif
#if !defined(OPENSSL_THREADS)
typedef uint32_t CRYPTO_once_t;
#define CRYPTO_ONCE_INIT 0
#elif defined(OPENSSL_WINDOWS_THREADS)
typedef INIT_ONCE CRYPTO_once_t;
#define CRYPTO_ONCE_INIT INIT_ONCE_STATIC_INIT
#elif defined(OPENSSL_PTHREADS)
typedef pthread_once_t CRYPTO_once_t;
#define CRYPTO_ONCE_INIT PTHREAD_ONCE_INIT
#else
#error "Unknown threading library"
#endif
OPENSSL_EXPORT void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void));
#define CRYPTO_REFCOUNT_MAX 0xffffffff
OPENSSL_EXPORT void CRYPTO_refcount_inc(CRYPTO_refcount_t *count);
OPENSSL_EXPORT int CRYPTO_refcount_dec_and_test_zero(CRYPTO_refcount_t *count);
#if !defined(OPENSSL_THREADS)
struct CRYPTO_STATIC_MUTEX {
char padding; };
#define CRYPTO_STATIC_MUTEX_INIT { 0 }
#elif defined(OPENSSL_WINDOWS_THREADS)
struct CRYPTO_STATIC_MUTEX {
SRWLOCK lock;
};
#define CRYPTO_STATIC_MUTEX_INIT { SRWLOCK_INIT }
#elif defined(OPENSSL_PTHREADS)
struct CRYPTO_STATIC_MUTEX {
pthread_rwlock_t lock;
};
#define CRYPTO_STATIC_MUTEX_INIT { PTHREAD_RWLOCK_INITIALIZER }
#else
#error "Unknown threading library"
#endif
OPENSSL_EXPORT void CRYPTO_MUTEX_init(CRYPTO_MUTEX *lock);
OPENSSL_EXPORT void CRYPTO_MUTEX_lock_read(CRYPTO_MUTEX *lock);
OPENSSL_EXPORT void CRYPTO_MUTEX_lock_write(CRYPTO_MUTEX *lock);
OPENSSL_EXPORT void CRYPTO_MUTEX_unlock_read(CRYPTO_MUTEX *lock);
OPENSSL_EXPORT void CRYPTO_MUTEX_unlock_write(CRYPTO_MUTEX *lock);
OPENSSL_EXPORT void CRYPTO_MUTEX_cleanup(CRYPTO_MUTEX *lock);
OPENSSL_EXPORT void CRYPTO_STATIC_MUTEX_lock_read(
struct CRYPTO_STATIC_MUTEX *lock);
OPENSSL_EXPORT void CRYPTO_STATIC_MUTEX_lock_write(
struct CRYPTO_STATIC_MUTEX *lock);
OPENSSL_EXPORT void CRYPTO_STATIC_MUTEX_unlock_read(
struct CRYPTO_STATIC_MUTEX *lock);
OPENSSL_EXPORT void CRYPTO_STATIC_MUTEX_unlock_write(
struct CRYPTO_STATIC_MUTEX *lock);
#if defined(__cplusplus)
extern "C++" {
BSSL_NAMESPACE_BEGIN
namespace internal {
template <void (*LockFunc)(CRYPTO_MUTEX *), void (*ReleaseFunc)(CRYPTO_MUTEX *)>
class MutexLockBase {
public:
explicit MutexLockBase(CRYPTO_MUTEX *mu) : mu_(mu) {
assert(mu_ != nullptr);
LockFunc(mu_);
}
~MutexLockBase() { ReleaseFunc(mu_); }
MutexLockBase(const MutexLockBase<LockFunc, ReleaseFunc> &) = delete;
MutexLockBase &operator=(const MutexLockBase<LockFunc, ReleaseFunc> &) =
delete;
private:
CRYPTO_MUTEX *const mu_;
};
}
using MutexWriteLock =
internal::MutexLockBase<CRYPTO_MUTEX_lock_write, CRYPTO_MUTEX_unlock_write>;
using MutexReadLock =
internal::MutexLockBase<CRYPTO_MUTEX_lock_read, CRYPTO_MUTEX_unlock_read>;
BSSL_NAMESPACE_END
} #endif
typedef enum {
OPENSSL_THREAD_LOCAL_ERR = 0,
OPENSSL_THREAD_LOCAL_RAND,
OPENSSL_THREAD_LOCAL_TEST,
NUM_OPENSSL_THREAD_LOCALS,
} thread_local_data_t;
typedef void (*thread_local_destructor_t)(void *);
OPENSSL_EXPORT void *CRYPTO_get_thread_local(thread_local_data_t value);
OPENSSL_EXPORT int CRYPTO_set_thread_local(
thread_local_data_t index, void *value,
thread_local_destructor_t destructor);
typedef struct crypto_ex_data_func_st CRYPTO_EX_DATA_FUNCS;
DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
typedef struct {
struct CRYPTO_STATIC_MUTEX lock;
STACK_OF(CRYPTO_EX_DATA_FUNCS) *meth;
uint8_t num_reserved;
} CRYPTO_EX_DATA_CLASS;
#define CRYPTO_EX_DATA_CLASS_INIT {CRYPTO_STATIC_MUTEX_INIT, NULL, 0}
#define CRYPTO_EX_DATA_CLASS_INIT_WITH_APP_DATA \
{CRYPTO_STATIC_MUTEX_INIT, NULL, 1}
OPENSSL_EXPORT int CRYPTO_get_ex_new_index(CRYPTO_EX_DATA_CLASS *ex_data_class,
int *out_index, long argl,
void *argp,
CRYPTO_EX_free *free_func);
OPENSSL_EXPORT int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int index, void *val);
OPENSSL_EXPORT void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int index);
OPENSSL_EXPORT void CRYPTO_new_ex_data(CRYPTO_EX_DATA *ad);
OPENSSL_EXPORT void CRYPTO_free_ex_data(CRYPTO_EX_DATA_CLASS *ex_data_class,
void *obj, CRYPTO_EX_DATA *ad);
#if defined(__GNUC__) && __GNUC__ >= 2
static inline uint16_t CRYPTO_bswap2(uint16_t x) {
return __builtin_bswap16(x);
}
static inline uint32_t CRYPTO_bswap4(uint32_t x) {
return __builtin_bswap32(x);
}
static inline uint64_t CRYPTO_bswap8(uint64_t x) {
return __builtin_bswap64(x);
}
#elif defined(_MSC_VER)
OPENSSL_MSVC_PRAGMA(warning(push, 3))
#include <stdlib.h>
OPENSSL_MSVC_PRAGMA(warning(pop))
#pragma intrinsic(_byteswap_uint64, _byteswap_ulong, _byteswap_ushort)
static inline uint16_t CRYPTO_bswap2(uint16_t x) {
return _byteswap_ushort(x);
}
static inline uint32_t CRYPTO_bswap4(uint32_t x) {
return _byteswap_ulong(x);
}
static inline uint64_t CRYPTO_bswap8(uint64_t x) {
return _byteswap_uint64(x);
}
#else
static inline uint16_t CRYPTO_bswap2(uint16_t x) {
return (x >> 8) | (x << 8);
}
static inline uint32_t CRYPTO_bswap4(uint32_t x) {
x = (x >> 16) | (x << 16);
x = ((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8);
return x;
}
static inline uint64_t CRYPTO_bswap8(uint64_t x) {
return CRYPTO_bswap4(x >> 32) | (((uint64_t)CRYPTO_bswap4(x)) << 32);
}
#endif
#if defined(__cplusplus)
extern "C++" {
static inline const void *OPENSSL_memchr(const void *s, int c, size_t n) {
if (n == 0) {
return NULL;
}
return memchr(s, c, n);
}
static inline void *OPENSSL_memchr(void *s, int c, size_t n) {
if (n == 0) {
return NULL;
}
return memchr(s, c, n);
}
} #else
static inline void *OPENSSL_memchr(const void *s, int c, size_t n) {
if (n == 0) {
return NULL;
}
return memchr(s, c, n);
}
#endif
static inline int OPENSSL_memcmp(const void *s1, const void *s2, size_t n) {
if (n == 0) {
return 0;
}
return memcmp(s1, s2, n);
}
static inline void *OPENSSL_memcpy(void *dst, const void *src, size_t n) {
if (n == 0) {
return dst;
}
return memcpy(dst, src, n);
}
static inline void *OPENSSL_memmove(void *dst, const void *src, size_t n) {
if (n == 0) {
return dst;
}
return memmove(dst, src, n);
}
static inline void *OPENSSL_memset(void *dst, int c, size_t n) {
if (n == 0) {
return dst;
}
return memset(dst, c, n);
}
#if defined(BORINGSSL_FIPS)
void BORINGSSL_FIPS_abort(void) __attribute__((noreturn));
#endif
int boringssl_fips_self_test(const uint8_t *module_hash,
size_t module_hash_len);
#if defined(__cplusplus)
} #endif
#endif