C9S/boringssl
2
0
Fork 0
mirror of https://boringssl.googlesource.com/boringssl synced 2026-07-21 14:43:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change (void) function prototypes to () in C++ code.

Browse Source 
Resolves `modernize-redundant-void-arg` warning.

Not changing in any C include files, of course.

Bug: 42220000
Change-Id: I8e31131be471b8c310f851cd23a3484931e04e37
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/86288
Auto-Submit: Rudolf Polzer <rpolzer@google.com>
Reviewed-by: David Benjamin <davidben@google.com>
Commit-Queue: Rudolf Polzer <rpolzer@google.com>
Commit-Queue: David Benjamin <davidben@google.com>
This commit is contained in:
Rudolf Polzer
2025-12-30 01:07:26 -08:00
committed by Boringssl LUCI CQ
parent 9f138d0587
commit 5ab5313969
151 changed files with 665 additions and 685 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crypto/abi_self_test.cc
+144 -144
View File
@@ -71,37 +71,37 @@ TEST(ABITest, SanityCheck) {
#if defined(OPENSSL_X86_64) && defined(SUPPORTS_ABI_TEST)
extern "C" {
void abi_test_clobber_rax(void);
void abi_test_clobber_rbx(void);
void abi_test_clobber_rcx(void);
void abi_test_clobber_rdx(void);
void abi_test_clobber_rsi(void);
void abi_test_clobber_rdi(void);
void abi_test_clobber_rbp(void);
void abi_test_clobber_r8(void);
void abi_test_clobber_r9(void);
void abi_test_clobber_r10(void);
void abi_test_clobber_r11(void);
void abi_test_clobber_r12(void);
void abi_test_clobber_r13(void);
void abi_test_clobber_r14(void);
void abi_test_clobber_r15(void);
void abi_test_clobber_xmm0(void);
void abi_test_clobber_xmm1(void);
void abi_test_clobber_xmm2(void);
void abi_test_clobber_xmm3(void);
void abi_test_clobber_xmm4(void);
void abi_test_clobber_xmm5(void);
void abi_test_clobber_xmm6(void);
void abi_test_clobber_xmm7(void);
void abi_test_clobber_xmm8(void);
void abi_test_clobber_xmm9(void);
void abi_test_clobber_xmm10(void);
void abi_test_clobber_xmm11(void);
void abi_test_clobber_xmm12(void);
void abi_test_clobber_xmm13(void);
void abi_test_clobber_xmm14(void);
void abi_test_clobber_xmm15(void);
void abi_test_clobber_rax();
void abi_test_clobber_rbx();
void abi_test_clobber_rcx();
void abi_test_clobber_rdx();
void abi_test_clobber_rsi();
void abi_test_clobber_rdi();
void abi_test_clobber_rbp();
void abi_test_clobber_r8();
void abi_test_clobber_r9();
void abi_test_clobber_r10();
void abi_test_clobber_r11();
void abi_test_clobber_r12();
void abi_test_clobber_r13();
void abi_test_clobber_r14();
void abi_test_clobber_r15();
void abi_test_clobber_xmm0();
void abi_test_clobber_xmm1();
void abi_test_clobber_xmm2();
void abi_test_clobber_xmm3();
void abi_test_clobber_xmm4();
void abi_test_clobber_xmm5();
void abi_test_clobber_xmm6();
void abi_test_clobber_xmm7();
void abi_test_clobber_xmm8();
void abi_test_clobber_xmm9();
void abi_test_clobber_xmm10();
void abi_test_clobber_xmm11();
void abi_test_clobber_xmm12();
void abi_test_clobber_xmm13();
void abi_test_clobber_xmm14();
void abi_test_clobber_xmm15();
} // extern C
TEST(ABITest, X86_64) {
@@ -191,21 +191,21 @@ TEST(ABITest, X86_64) {
#if defined(OPENSSL_X86) && defined(SUPPORTS_ABI_TEST)
extern "C" {
void abi_test_clobber_eax(void);
void abi_test_clobber_ebx(void);
void abi_test_clobber_ecx(void);
void abi_test_clobber_edx(void);
void abi_test_clobber_esi(void);
void abi_test_clobber_edi(void);
void abi_test_clobber_ebp(void);
void abi_test_clobber_xmm0(void);
void abi_test_clobber_xmm1(void);
void abi_test_clobber_xmm2(void);
void abi_test_clobber_xmm3(void);
void abi_test_clobber_xmm4(void);
void abi_test_clobber_xmm5(void);
void abi_test_clobber_xmm6(void);
void abi_test_clobber_xmm7(void);
void abi_test_clobber_eax();
void abi_test_clobber_ebx();
void abi_test_clobber_ecx();
void abi_test_clobber_edx();
void abi_test_clobber_esi();
void abi_test_clobber_edi();
void abi_test_clobber_ebp();
void abi_test_clobber_xmm0();
void abi_test_clobber_xmm1();
void abi_test_clobber_xmm2();
void abi_test_clobber_xmm3();
void abi_test_clobber_xmm4();
void abi_test_clobber_xmm5();
void abi_test_clobber_xmm6();
void abi_test_clobber_xmm7();
} // extern C
TEST(ABITest, X86) {
@@ -247,37 +247,37 @@ TEST(ABITest, X86) {
#if defined(OPENSSL_ARM) && defined(SUPPORTS_ABI_TEST)
extern "C" {
void abi_test_clobber_r0(void);
void abi_test_clobber_r1(void);
void abi_test_clobber_r2(void);
void abi_test_clobber_r3(void);
void abi_test_clobber_r4(void);
void abi_test_clobber_r5(void);
void abi_test_clobber_r6(void);
void abi_test_clobber_r7(void);
void abi_test_clobber_r8(void);
void abi_test_clobber_r9(void);
void abi_test_clobber_r10(void);
void abi_test_clobber_r11(void);
void abi_test_clobber_r12(void);
void abi_test_clobber_r0();
void abi_test_clobber_r1();
void abi_test_clobber_r2();
void abi_test_clobber_r3();
void abi_test_clobber_r4();
void abi_test_clobber_r5();
void abi_test_clobber_r6();
void abi_test_clobber_r7();
void abi_test_clobber_r8();
void abi_test_clobber_r9();
void abi_test_clobber_r10();
void abi_test_clobber_r11();
void abi_test_clobber_r12();
// r13, r14, and r15, are sp, lr, and pc, respectively.
void abi_test_clobber_d0(void);
void abi_test_clobber_d1(void);
void abi_test_clobber_d2(void);
void abi_test_clobber_d3(void);
void abi_test_clobber_d4(void);
void abi_test_clobber_d5(void);
void abi_test_clobber_d6(void);
void abi_test_clobber_d7(void);
void abi_test_clobber_d8(void);
void abi_test_clobber_d9(void);
void abi_test_clobber_d10(void);
void abi_test_clobber_d11(void);
void abi_test_clobber_d12(void);
void abi_test_clobber_d13(void);
void abi_test_clobber_d14(void);
void abi_test_clobber_d15(void);
void abi_test_clobber_d0();
void abi_test_clobber_d1();
void abi_test_clobber_d2();
void abi_test_clobber_d3();
void abi_test_clobber_d4();
void abi_test_clobber_d5();
void abi_test_clobber_d6();
void abi_test_clobber_d7();
void abi_test_clobber_d8();
void abi_test_clobber_d9();
void abi_test_clobber_d10();
void abi_test_clobber_d11();
void abi_test_clobber_d12();
void abi_test_clobber_d13();
void abi_test_clobber_d14();
void abi_test_clobber_d15();
} // extern C
TEST(ABITest, ARM) {
@@ -344,78 +344,78 @@ TEST(ABITest, ARM) {
#if defined(OPENSSL_AARCH64) && defined(SUPPORTS_ABI_TEST)
extern "C" {
void abi_test_clobber_x0(void);
void abi_test_clobber_x1(void);
void abi_test_clobber_x2(void);
void abi_test_clobber_x3(void);
void abi_test_clobber_x4(void);
void abi_test_clobber_x5(void);
void abi_test_clobber_x6(void);
void abi_test_clobber_x7(void);
void abi_test_clobber_x8(void);
void abi_test_clobber_x9(void);
void abi_test_clobber_x10(void);
void abi_test_clobber_x11(void);
void abi_test_clobber_x12(void);
void abi_test_clobber_x13(void);
void abi_test_clobber_x14(void);
void abi_test_clobber_x15(void);
void abi_test_clobber_x16(void);
void abi_test_clobber_x17(void);
void abi_test_clobber_x0();
void abi_test_clobber_x1();
void abi_test_clobber_x2();
void abi_test_clobber_x3();
void abi_test_clobber_x4();
void abi_test_clobber_x5();
void abi_test_clobber_x6();
void abi_test_clobber_x7();
void abi_test_clobber_x8();
void abi_test_clobber_x9();
void abi_test_clobber_x10();
void abi_test_clobber_x11();
void abi_test_clobber_x12();
void abi_test_clobber_x13();
void abi_test_clobber_x14();
void abi_test_clobber_x15();
void abi_test_clobber_x16();
void abi_test_clobber_x17();
// x18 is the platform register and off limits.
void abi_test_clobber_x19(void);
void abi_test_clobber_x20(void);
void abi_test_clobber_x21(void);
void abi_test_clobber_x22(void);
void abi_test_clobber_x23(void);
void abi_test_clobber_x24(void);
void abi_test_clobber_x25(void);
void abi_test_clobber_x26(void);
void abi_test_clobber_x27(void);
void abi_test_clobber_x28(void);
void abi_test_clobber_x29(void);
void abi_test_clobber_x19();
void abi_test_clobber_x20();
void abi_test_clobber_x21();
void abi_test_clobber_x22();
void abi_test_clobber_x23();
void abi_test_clobber_x24();
void abi_test_clobber_x25();
void abi_test_clobber_x26();
void abi_test_clobber_x27();
void abi_test_clobber_x28();
void abi_test_clobber_x29();
void abi_test_clobber_d0(void);
void abi_test_clobber_d1(void);
void abi_test_clobber_d2(void);
void abi_test_clobber_d3(void);
void abi_test_clobber_d4(void);
void abi_test_clobber_d5(void);
void abi_test_clobber_d6(void);
void abi_test_clobber_d7(void);
void abi_test_clobber_d8(void);
void abi_test_clobber_d9(void);
void abi_test_clobber_d10(void);
void abi_test_clobber_d11(void);
void abi_test_clobber_d12(void);
void abi_test_clobber_d13(void);
void abi_test_clobber_d14(void);
void abi_test_clobber_d15(void);
void abi_test_clobber_d16(void);
void abi_test_clobber_d17(void);
void abi_test_clobber_d18(void);
void abi_test_clobber_d19(void);
void abi_test_clobber_d20(void);
void abi_test_clobber_d21(void);
void abi_test_clobber_d22(void);
void abi_test_clobber_d23(void);
void abi_test_clobber_d24(void);
void abi_test_clobber_d25(void);
void abi_test_clobber_d26(void);
void abi_test_clobber_d27(void);
void abi_test_clobber_d28(void);
void abi_test_clobber_d29(void);
void abi_test_clobber_d30(void);
void abi_test_clobber_d31(void);
void abi_test_clobber_d0();
void abi_test_clobber_d1();
void abi_test_clobber_d2();
void abi_test_clobber_d3();
void abi_test_clobber_d4();
void abi_test_clobber_d5();
void abi_test_clobber_d6();
void abi_test_clobber_d7();
void abi_test_clobber_d8();
void abi_test_clobber_d9();
void abi_test_clobber_d10();
void abi_test_clobber_d11();
void abi_test_clobber_d12();
void abi_test_clobber_d13();
void abi_test_clobber_d14();
void abi_test_clobber_d15();
void abi_test_clobber_d16();
void abi_test_clobber_d17();
void abi_test_clobber_d18();
void abi_test_clobber_d19();
void abi_test_clobber_d20();
void abi_test_clobber_d21();
void abi_test_clobber_d22();
void abi_test_clobber_d23();
void abi_test_clobber_d24();
void abi_test_clobber_d25();
void abi_test_clobber_d26();
void abi_test_clobber_d27();
void abi_test_clobber_d28();
void abi_test_clobber_d29();
void abi_test_clobber_d30();
void abi_test_clobber_d31();
void abi_test_clobber_v8_upper(void);
void abi_test_clobber_v9_upper(void);
void abi_test_clobber_v10_upper(void);
void abi_test_clobber_v11_upper(void);
void abi_test_clobber_v12_upper(void);
void abi_test_clobber_v13_upper(void);
void abi_test_clobber_v14_upper(void);
void abi_test_clobber_v15_upper(void);
void abi_test_clobber_v8_upper();
void abi_test_clobber_v9_upper();
void abi_test_clobber_v10_upper();
void abi_test_clobber_v11_upper();
void abi_test_clobber_v12_upper();
void abi_test_clobber_v13_upper();
void abi_test_clobber_v14_upper();
void abi_test_clobber_v15_upper();
} // extern C
TEST(ABITest, AArch64) {
crypto/asn1/a_object.cc
+1 -1
View File
@@ -135,7 +135,7 @@ ASN1_OBJECT *asn1_parse_object(CBS *cbs, CBS_ASN1_TAG tag) {
/*sn=*/nullptr, /*ln=*/nullptr);
}
ASN1_OBJECT *ASN1_OBJECT_new(void) {
ASN1_OBJECT *ASN1_OBJECT_new() {
ASN1_OBJECT *ret;
ret = (ASN1_OBJECT *)OPENSSL_malloc(sizeof(ASN1_OBJECT));
crypto/asn1/a_strnid.cc
+2 -2
View File
@@ -36,7 +36,7 @@ static CRYPTO_MUTEX string_tables_lock = CRYPTO_MUTEX_INIT;
void ASN1_STRING_set_default_mask(unsigned long mask) {}
unsigned long ASN1_STRING_get_default_mask(void) { return B_ASN1_UTF8STRING; }
unsigned long ASN1_STRING_get_default_mask() { return B_ASN1_UTF8STRING; }
int ASN1_STRING_set_default_mask_asc(const char *p) { return 1; }
@@ -199,7 +199,7 @@ err:
return ret;
}
void ASN1_STRING_TABLE_cleanup(void) {}
void ASN1_STRING_TABLE_cleanup() {}
void asn1_get_string_table_for_testing(const ASN1_STRING_TABLE **out_ptr,
size_t *out_len) {
crypto/asn1/asn1_lib.cc
+1 -1
View File
@@ -280,7 +280,7 @@ void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len) {
str->length = len;
}
ASN1_STRING *ASN1_STRING_new(void) {
ASN1_STRING *ASN1_STRING_new() {
return (ASN1_STRING_type_new(V_ASN1_OCTET_STRING));
}
crypto/asn1/internal.h
+2 -2
View File
@@ -71,7 +71,7 @@ struct asn1_object_st {
int flags; // Should we free this one
};
ASN1_OBJECT *ASN1_OBJECT_new(void);
ASN1_OBJECT *ASN1_OBJECT_new();
// asn1_parse_object parses a DER-encoded ASN.1 OBJECT IDENTIFIER from |cbs| and
// write the result to |out|. If |tag| is non-zero, the value is implicitly
@@ -287,7 +287,7 @@ typedef struct {
OPENSSL_EXPORT void asn1_get_string_table_for_testing(
const ASN1_STRING_TABLE **out_ptr, size_t *out_len);
typedef ASN1_VALUE *ASN1_new_func(void);
typedef ASN1_VALUE *ASN1_new_func();
typedef void ASN1_free_func(ASN1_VALUE *a);
typedef ASN1_VALUE *ASN1_d2i_func(ASN1_VALUE **a, const unsigned char **in,
long length);
crypto/asn1/tasn_typ.cc
+4 -4
View File
@@ -22,10 +22,10 @@
// TODO(crbug.com/42290417): While we need |ASN1_ITEM|s, the exposed new, free,
// i2d, and d2i functions should call the underlying implementations directly.
#define IMPLEMENT_ASN1_STRING_FUNCTIONS(sname) \
IMPLEMENT_ASN1_TYPE(sname) \
IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(sname, sname, sname) \
sname *sname##_new(void) { return ASN1_STRING_type_new(V_##sname); } \
#define IMPLEMENT_ASN1_STRING_FUNCTIONS(sname) \
IMPLEMENT_ASN1_TYPE(sname) \
IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(sname, sname, sname) \
sname *sname##_new() { return ASN1_STRING_type_new(V_##sname); } \
void sname##_free(sname *x) { ASN1_STRING_free(x); }
IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
crypto/base64/base64.cc
+1 -1
View File
@@ -78,7 +78,7 @@ int EVP_EncodedLength(size_t *out_len, size_t len) {
return 1;
}
EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void) {
EVP_ENCODE_CTX *EVP_ENCODE_CTX_new() {
return reinterpret_cast<EVP_ENCODE_CTX *>(
OPENSSL_zalloc(sizeof(EVP_ENCODE_CTX)));
}
crypto/bcm_support.h
+3 -3
View File
@@ -29,7 +29,7 @@ extern "C" {
// CRYPTO_init_sysrand initializes long-lived resources needed to draw entropy
// from the operating system, if the operating system requires initialization.
void CRYPTO_init_sysrand(void);
void CRYPTO_init_sysrand();
// CRYPTO_sysrand fills |len| bytes at |buf| with entropy from the operating
// system.
@@ -53,7 +53,7 @@ void RAND_need_entropy(size_t bytes_needed);
//
// This is not reliably supported on all platforms which implement |fork|, so it
// should only be used as a hardening measure.
OPENSSL_EXPORT uint64_t CRYPTO_get_fork_generation(void);
OPENSSL_EXPORT uint64_t CRYPTO_get_fork_generation();
// CRYPTO_fork_detect_force_madv_wipeonfork_for_testing is an internal detail
// used for testing purposes.
@@ -62,7 +62,7 @@ OPENSSL_EXPORT void CRYPTO_fork_detect_force_madv_wipeonfork_for_testing(
// CRYPTO_get_stderr returns stderr. This function exists to avoid BCM needing
// a data dependency on libc.
FILE *CRYPTO_get_stderr(void);
FILE *CRYPTO_get_stderr();
#if defined(__cplusplus)
crypto/bio/bio.cc
+1 -1
View File
@@ -577,7 +577,7 @@ int BIO_set_write_buffer_size(BIO *bio, int buffer_size) { return 0; }
static CRYPTO_MUTEX g_index_lock = CRYPTO_MUTEX_INIT;
static int g_index = BIO_TYPE_START;
int BIO_get_new_index(void) {
int BIO_get_new_index() {
CRYPTO_MUTEX_lock_write(&g_index_lock);
// If |g_index| exceeds 255, it will collide with the flags bits.
int ret = g_index > 255 ? -1 : g_index++;
crypto/bio/bio_mem.cc
+1 -1
View File
@@ -226,7 +226,7 @@ static const BIO_METHOD mem_method = {
mem_new, mem_free, /*callback_ctrl=*/nullptr,
};
const BIO_METHOD *BIO_s_mem(void) { return &mem_method; }
const BIO_METHOD *BIO_s_mem() { return &mem_method; }
int BIO_mem_contents(const BIO *bio, const uint8_t **out_contents,
size_t *out_len) {
crypto/bio/connect.cc
+2 -2
View File
@@ -255,7 +255,7 @@ end:
return ret;
}
static BIO_CONNECT *BIO_CONNECT_new(void) {
static BIO_CONNECT *BIO_CONNECT_new() {
BIO_CONNECT *ret =
reinterpret_cast<BIO_CONNECT *>(OPENSSL_zalloc(sizeof(BIO_CONNECT)));
if (ret == nullptr) {
@@ -453,7 +453,7 @@ static const BIO_METHOD methods_connectp = {
conn_new, conn_free, conn_callback_ctrl,
};
const BIO_METHOD *BIO_s_connect(void) { return &methods_connectp; }
const BIO_METHOD *BIO_s_connect() { return &methods_connectp; }
int BIO_set_conn_hostname(BIO *bio, const char *name) {
return (int)BIO_ctrl(bio, BIO_C_SET_CONNECT, 0, (void *)name);
crypto/bio/fd.cc
+1 -1
View File
@@ -168,7 +168,7 @@ static const BIO_METHOD methods_fdp = {
fd_new, fd_free, /*callback_ctrl=*/nullptr,
};
const BIO_METHOD *BIO_s_fd(void) { return &methods_fdp; }
const BIO_METHOD *BIO_s_fd() { return &methods_fdp; }
#endif // OPENSSL_NO_POSIX_IO
crypto/bio/file.cc
+1 -1
View File
@@ -238,7 +238,7 @@ static const BIO_METHOD methods_filep = {
/*create=*/nullptr, file_free, /*callback_ctrl=*/nullptr,
};
const BIO_METHOD *BIO_s_file(void) { return &methods_filep; }
const BIO_METHOD *BIO_s_file() { return &methods_filep; }
int BIO_get_fp(BIO *bio, FILE **out_file) {
crypto/bio/internal.h
+1 -1
View File
@@ -95,7 +95,7 @@ int bio_socket_nbio(int sock, int on);
// bio_clear_socket_error clears the last system socket error.
//
// TODO(fork): remove all callers of this.
void bio_clear_socket_error(void);
void bio_clear_socket_error();
// bio_sock_error returns the last socket error on |sock|.
int bio_sock_error(int sock);
crypto/bio/pair.cc
+1 -1
View File
@@ -408,7 +408,7 @@ static const BIO_METHOD methods_biop = {
/*callback_ctrl=*/nullptr,
};
static const BIO_METHOD *bio_s_bio(void) { return &methods_biop; }
static const BIO_METHOD *bio_s_bio() { return &methods_biop; }
int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1_len, BIO **bio2_p,
size_t writebuf2_len) {
crypto/bio/socket.cc
+1 -1
View File
@@ -123,7 +123,7 @@ static const BIO_METHOD methods_sockp = {
nullptr /* callback_ctrl */,
};
const BIO_METHOD *BIO_s_socket(void) { return &methods_sockp; }
const BIO_METHOD *BIO_s_socket() { return &methods_sockp; }
BIO *BIO_new_socket(int fd, int close_flag) {
BIO *ret;
crypto/bio/socket_helper.cc
+1 -1
View File
@@ -109,7 +109,7 @@ int bssl::bio_socket_nbio(int sock, int on) {
#endif
}
void bssl::bio_clear_socket_error(void) {}
void bssl::bio_clear_socket_error() {}
int bssl::bio_sock_error(int sock) {
int error;
crypto/buf/buf.cc
+1 -1
View File
@@ -22,7 +22,7 @@
#include "../internal.h"
BUF_MEM *BUF_MEM_new(void) {
BUF_MEM *BUF_MEM_new() {
return reinterpret_cast<BUF_MEM *>(OPENSSL_zalloc(sizeof(BUF_MEM)));
}
crypto/cipher/aead_test.cc
+1 -1
View File
@@ -58,7 +58,7 @@ constexpr uint32_t kSkipIOVec = 1 << 5;
struct KnownAEAD {
const char name[40];
const EVP_AEAD *(*func)(void);
const EVP_AEAD *(*func)();
const char *test_vectors;
uint32_t flags;
crypto/cipher/e_aesctrhmac.cc
+2 -2
View File
@@ -272,10 +272,10 @@ static const EVP_AEAD aead_aes_256_ctr_hmac_sha256 = {
nullptr /* tag_len */,
};
const EVP_AEAD *EVP_aead_aes_128_ctr_hmac_sha256(void) {
const EVP_AEAD *EVP_aead_aes_128_ctr_hmac_sha256() {
return &aead_aes_128_ctr_hmac_sha256;
}
const EVP_AEAD *EVP_aead_aes_256_ctr_hmac_sha256(void) {
const EVP_AEAD *EVP_aead_aes_256_ctr_hmac_sha256() {
return &aead_aes_256_ctr_hmac_sha256;
}
crypto/cipher/e_aeseax.cc
+2 -2
View File
@@ -345,6 +345,6 @@ static const EVP_AEAD aead_aes_256_eax = {
nullptr, // tag_len
};
const EVP_AEAD *EVP_aead_aes_128_eax(void) { return &aead_aes_128_eax; }
const EVP_AEAD *EVP_aead_aes_128_eax() { return &aead_aes_128_eax; }
const EVP_AEAD *EVP_aead_aes_256_eax(void) { return &aead_aes_256_eax; }
const EVP_AEAD *EVP_aead_aes_256_eax() { return &aead_aes_256_eax; }
crypto/cipher/e_aesgcmsiv.cc
+4 -4
View File
@@ -1037,14 +1037,14 @@ const EVP_AEAD aead_aes_256_gcm_siv = {
#if defined(AES_GCM_SIV_ASM)
const EVP_AEAD *EVP_aead_aes_128_gcm_siv(void) {
const EVP_AEAD *EVP_aead_aes_128_gcm_siv() {
if (CRYPTO_is_AVX_capable() && CRYPTO_is_AESNI_capable()) {
return &aead_aes_128_gcm_siv_asm;
}
return &aead_aes_128_gcm_siv;
}
const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void) {
const EVP_AEAD *EVP_aead_aes_256_gcm_siv() {
if (CRYPTO_is_AVX_capable() && CRYPTO_is_AESNI_capable()) {
return &aead_aes_256_gcm_siv_asm;
}
@@ -1053,8 +1053,8 @@ const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void) {
#else
const EVP_AEAD *EVP_aead_aes_128_gcm_siv(void) { return &aead_aes_128_gcm_siv; }
const EVP_AEAD *EVP_aead_aes_128_gcm_siv() { return &aead_aes_128_gcm_siv; }
const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void) { return &aead_aes_256_gcm_siv; }
const EVP_AEAD *EVP_aead_aes_256_gcm_siv() { return &aead_aes_256_gcm_siv; }
#endif // AES_GCM_SIV_ASM
crypto/cipher/e_chacha20poly1305.cc
+2 -4
View File
@@ -392,10 +392,8 @@ static const EVP_AEAD aead_xchacha20_poly1305 = {
nullptr, // tag_len
};
const EVP_AEAD *EVP_aead_chacha20_poly1305(void) {
return &aead_chacha20_poly1305;
}
const EVP_AEAD *EVP_aead_chacha20_poly1305() { return &aead_chacha20_poly1305; }
const EVP_AEAD *EVP_aead_xchacha20_poly1305(void) {
const EVP_AEAD *EVP_aead_xchacha20_poly1305() {
return &aead_xchacha20_poly1305;
}
crypto/cipher/e_des.cc
+7 -7
View File
@@ -59,7 +59,7 @@ static const EVP_CIPHER evp_des_cbc = {
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_cbc(void) { return &evp_des_cbc; }
const EVP_CIPHER *EVP_des_cbc() { return &evp_des_cbc; }
static int des_ecb_cipher_update(EVP_CIPHER_CTX *ctx, uint8_t *out,
const uint8_t *in, size_t len) {
@@ -90,7 +90,7 @@ static const EVP_CIPHER evp_des_ecb = {
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ecb(void) { return &evp_des_ecb; }
const EVP_CIPHER *EVP_des_ecb() { return &evp_des_ecb; }
typedef struct {
union {
@@ -131,7 +131,7 @@ static const EVP_CIPHER evp_des_ede3_cbc = {
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ede3_cbc(void) { return &evp_des_ede3_cbc; }
const EVP_CIPHER *EVP_des_ede3_cbc() { return &evp_des_ede3_cbc; }
static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
const uint8_t *iv, int enc) {
@@ -158,7 +158,7 @@ static const EVP_CIPHER evp_des_ede_cbc = {
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ede_cbc(void) { return &evp_des_ede_cbc; }
const EVP_CIPHER *EVP_des_ede_cbc() { return &evp_des_ede_cbc; }
static int des_ede_ecb_cipher_update(EVP_CIPHER_CTX *ctx, uint8_t *out,
const uint8_t *in, size_t len) {
@@ -190,7 +190,7 @@ static const EVP_CIPHER evp_des_ede = {
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ede(void) { return &evp_des_ede; }
const EVP_CIPHER *EVP_des_ede() { return &evp_des_ede; }
static const EVP_CIPHER evp_des_ede3 = {
/*nid=*/NID_des_ede3_ecb,
@@ -207,6 +207,6 @@ static const EVP_CIPHER evp_des_ede3 = {
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ede3(void) { return &evp_des_ede3; }
const EVP_CIPHER *EVP_des_ede3() { return &evp_des_ede3; }
const EVP_CIPHER *EVP_des_ede3_ecb(void) { return EVP_des_ede3(); }
const EVP_CIPHER *EVP_des_ede3_ecb() { return EVP_des_ede3(); }
crypto/cipher/e_null.cc
+1 -1
View File
@@ -50,4 +50,4 @@ static const EVP_CIPHER n_cipher = {
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_enc_null(void) { return &n_cipher; }
const EVP_CIPHER *EVP_enc_null() { return &n_cipher; }
crypto/cipher/e_rc2.cc
+2 -2
View File
@@ -401,7 +401,7 @@ static const EVP_CIPHER rc2_40_cbc = {
/*ctrl=*/rc2_ctrl,
};
const EVP_CIPHER *EVP_rc2_40_cbc(void) { return &rc2_40_cbc; }
const EVP_CIPHER *EVP_rc2_40_cbc() { return &rc2_40_cbc; }
static const EVP_CIPHER rc2_cbc = {
/*nid=*/NID_rc2_cbc,
@@ -418,4 +418,4 @@ static const EVP_CIPHER rc2_cbc = {
/*ctrl=*/rc2_ctrl,
};
const EVP_CIPHER *EVP_rc2_cbc(void) { return &rc2_cbc; }
const EVP_CIPHER *EVP_rc2_cbc() { return &rc2_cbc; }
crypto/cipher/e_rc4.cc
+1 -1
View File
@@ -53,4 +53,4 @@ static const EVP_CIPHER rc4 = {
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_rc4(void) { return &rc4; }
const EVP_CIPHER *EVP_rc4() { return &rc4; }
crypto/cipher/e_tls.cc
+7 -7
View File
@@ -584,30 +584,30 @@ static const EVP_AEAD aead_des_ede3_cbc_sha1_tls_implicit_iv = {
aead_tls_tag_len,
};
const EVP_AEAD *EVP_aead_aes_128_cbc_sha1_tls(void) {
const EVP_AEAD *EVP_aead_aes_128_cbc_sha1_tls() {
return &aead_aes_128_cbc_sha1_tls;
}
const EVP_AEAD *EVP_aead_aes_128_cbc_sha1_tls_implicit_iv(void) {
const EVP_AEAD *EVP_aead_aes_128_cbc_sha1_tls_implicit_iv() {
return &aead_aes_128_cbc_sha1_tls_implicit_iv;
}
const EVP_AEAD *EVP_aead_aes_128_cbc_sha256_tls(void) {
const EVP_AEAD *EVP_aead_aes_128_cbc_sha256_tls() {
return &aead_aes_128_cbc_sha256_tls;
}
const EVP_AEAD *EVP_aead_aes_256_cbc_sha1_tls(void) {
const EVP_AEAD *EVP_aead_aes_256_cbc_sha1_tls() {
return &aead_aes_256_cbc_sha1_tls;
}
const EVP_AEAD *EVP_aead_aes_256_cbc_sha1_tls_implicit_iv(void) {
const EVP_AEAD *EVP_aead_aes_256_cbc_sha1_tls_implicit_iv() {
return &aead_aes_256_cbc_sha1_tls_implicit_iv;
}
const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls(void) {
const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls() {
return &aead_des_ede3_cbc_sha1_tls;
}
const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls_implicit_iv(void) {
const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls_implicit_iv() {
return &aead_des_ede3_cbc_sha1_tls_implicit_iv;
}
crypto/cipher/get_cipher.cc
+1 -1
View File
@@ -28,7 +28,7 @@
static const struct {
int nid;
const char *name;
const EVP_CIPHER *(*func)(void);
const EVP_CIPHER *(*func)();
} kCiphers[] = {
{NID_aes_128_cbc, "aes-128-cbc", EVP_aes_128_cbc},
{NID_aes_128_ctr, "aes-128-ctr", EVP_aes_128_ctr},
crypto/cipher/internal.h
+2 -2
View File
@@ -142,7 +142,7 @@ static_assert(sizeof(union chacha20_poly1305_open_data) == 48,
static_assert(sizeof(union chacha20_poly1305_seal_data) == 48 + 8 + 8,
"wrong chacha20_poly1305_seal_data size");
inline int chacha20_poly1305_asm_capable(void) {
inline int chacha20_poly1305_asm_capable() {
#if defined(OPENSSL_X86_64)
return CRYPTO_is_SSE4_1_capable();
#elif defined(OPENSSL_AARCH64)
@@ -218,7 +218,7 @@ extern void chacha20_poly1305_seal(uint8_t *out_ciphertext,
#else
inline int chacha20_poly1305_asm_capable(void) { return 0; }
inline int chacha20_poly1305_asm_capable() { return 0; }
inline void chacha20_poly1305_open(uint8_t *out_plaintext,
const uint8_t *ciphertext,
crypto/conf/conf.cc
+3 -3
View File
@@ -78,7 +78,7 @@ CONF *NCONF_new(void *method) {
return conf;
}
CONF_VALUE *CONF_VALUE_new(void) {
CONF_VALUE *CONF_VALUE_new() {
return reinterpret_cast<CONF_VALUE *>(OPENSSL_zalloc(sizeof(CONF_VALUE)));
}
@@ -625,8 +625,8 @@ int CONF_modules_load_file(const char *filename, const char *appname,
void CONF_modules_unload(int all) {}
void CONF_modules_free(void) {}
void CONF_modules_free() {}
void OPENSSL_config(const char *config_name) {}
void OPENSSL_no_config(void) {}
void OPENSSL_no_config() {}
crypto/conf/internal.h
+1 -1
View File
@@ -35,7 +35,7 @@ struct conf_st {
};
// CONF_VALUE_new returns a freshly allocated and zeroed |CONF_VALUE|.
CONF_VALUE *CONF_VALUE_new(void);
CONF_VALUE *CONF_VALUE_new();
// CONF_parse_list takes a list separated by 'sep' and calls |list_cb| giving
// the start and length of each member, optionally stripping leading and
crypto/cpu_aarch64_apple.cc
+1 -1
View File
@@ -43,7 +43,7 @@ static int has_hw_feature(const char *name) {
return value != 0;
}
void OPENSSL_cpuid_setup(void) {
void OPENSSL_cpuid_setup() {
// Apple ARM64 platforms have NEON and cryptography extensions available
// statically, so we do not need to query them. In particular, there sometimes
// are no sysctls corresponding to such features. See below.
crypto/cpu_aarch64_fuchsia.cc
+1 -1
View File
@@ -22,7 +22,7 @@
#include <zircon/types.h>
void OPENSSL_cpuid_setup(void) {
void OPENSSL_cpuid_setup() {
uint32_t hwcap;
zx_status_t rc = zx_system_get_features(ZX_FEATURE_KIND_CPU, &hwcap);
if (rc != ZX_OK || (hwcap & ZX_ARM64_FEATURE_ISA_ASIMD) == 0) {
crypto/cpu_aarch64_linux.cc
+1 -1
View File
@@ -20,7 +20,7 @@
#include <sys/auxv.h>
void OPENSSL_cpuid_setup(void) {
void OPENSSL_cpuid_setup() {
unsigned long hwcap = getauxval(AT_HWCAP);
// See /usr/include/asm/hwcap.h on an aarch64 installation for the source of
crypto/cpu_aarch64_openbsd.cc
+1 -1
View File
@@ -24,7 +24,7 @@
#include "internal.h"
void OPENSSL_cpuid_setup(void) {
void OPENSSL_cpuid_setup() {
int isar0_mib[] = {CTL_MACHDEP, CPU_ID_AA64ISAR0};
uint64_t cpu_id = 0;
size_t len = sizeof(cpu_id);
crypto/cpu_aarch64_sysreg.cc
+2 -2
View File
@@ -49,7 +49,7 @@ static int get_signed_id_field(uint64_t reg, unsigned field) {
}
}
static uint32_t read_armcap(void) {
static uint32_t read_armcap() {
uint32_t armcap = ARMV7_NEON;
uint64_t id_aa64pfr0_el1 = READ_SYSREG("id_aa64pfr0_el1");
@@ -86,7 +86,7 @@ static uint32_t read_armcap(void) {
return armcap;
}
void OPENSSL_cpuid_setup(void) { OPENSSL_armcap_P |= read_armcap(); }
void OPENSSL_cpuid_setup() { OPENSSL_armcap_P |= read_armcap(); }
#endif // OPENSSL_AARCH64 && !OPENSSL_STATIC_ARMCAP &&
// (ANDROID_BAREMETAL || OPENSSL_FREEBSD)
crypto/cpu_aarch64_win.cc
+1 -1
View File
@@ -21,7 +21,7 @@
#include <windows.h>
void OPENSSL_cpuid_setup(void) {
void OPENSSL_cpuid_setup() {
// We do not need to check for the presence of NEON, as Armv8-A always has it
OPENSSL_armcap_P |= ARMV7_NEON;
crypto/cpu_arm_freebsd.cc
+1 -1
View File
@@ -22,7 +22,7 @@
#include <openssl/mem.h>
void OPENSSL_cpuid_setup(void) {
void OPENSSL_cpuid_setup() {
unsigned long hwcap = 0, hwcap2 = 0;
// |elf_aux_info| may fail, in which case |hwcap| and |hwcap2| will be
crypto/cpu_arm_linux.cc
+3 -3
View File
@@ -96,7 +96,7 @@ err:
static int g_needs_hwcap2_workaround;
void OPENSSL_cpuid_setup(void) {
void OPENSSL_cpuid_setup() {
// We ignore the return value of |read_file| and proceed with an empty
// /proc/cpuinfo on error. If |getauxval| works, we will still detect
// capabilities.
@@ -163,9 +163,9 @@ void OPENSSL_cpuid_setup(void) {
OPENSSL_free(cpuinfo_data);
}
int CRYPTO_has_broken_NEON(void) { return 0; }
int CRYPTO_has_broken_NEON() { return 0; }
int CRYPTO_needs_hwcap2_workaround(void) {
int CRYPTO_needs_hwcap2_workaround() {
OPENSSL_init_cpuid();
return g_needs_hwcap2_workaround;
}
crypto/cpu_intel.cc
+1 -1
View File
@@ -146,7 +146,7 @@ void OPENSSL_adjust_ia32cap(uint32_t cap[4], const char *env) {
}
}
void OPENSSL_cpuid_setup(void) {
void OPENSSL_cpuid_setup() {
// Determine the vendor and maximum input value.
uint32_t eax, ebx, ecx, edx;
OPENSSL_cpuid(&eax, &ebx, &ecx, &edx, 0);
crypto/crypto.cc
+16 -16
View File
@@ -71,12 +71,12 @@ uint32_t OPENSSL_get_ia32cap(int idx) {
!defined(OPENSSL_STATIC_ARMCAP)
HIDDEN uint32_t OPENSSL_armcap_P = 0;
uint32_t *OPENSSL_get_armcap_pointer_for_test(void) {
uint32_t *OPENSSL_get_armcap_pointer_for_test() {
OPENSSL_init_cpuid();
return &OPENSSL_armcap_P;
}
uint32_t OPENSSL_get_armcap(void) {
uint32_t OPENSSL_get_armcap() {
OPENSSL_init_cpuid();
return OPENSSL_armcap_P;
}
@@ -84,12 +84,12 @@ uint32_t OPENSSL_get_armcap(void) {
#if defined(NEED_CPUID)
static CRYPTO_once_t once = CRYPTO_ONCE_INIT;
void OPENSSL_init_cpuid(void) { CRYPTO_once(&once, OPENSSL_cpuid_setup); }
void OPENSSL_init_cpuid() { CRYPTO_once(&once, OPENSSL_cpuid_setup); }
#endif
void CRYPTO_library_init(void) {}
void CRYPTO_library_init() {}
int CRYPTO_is_confidential_build(void) {
int CRYPTO_is_confidential_build() {
#if defined(BORINGSSL_CONFIDENTIAL)
return 1;
#else
@@ -97,7 +97,7 @@ int CRYPTO_is_confidential_build(void) {
#endif
}
void CRYPTO_pre_sandbox_init(void) {
void CRYPTO_pre_sandbox_init() {
// Read from /proc/cpuinfo if needed.
OPENSSL_init_cpuid();
// Open /dev/urandom if needed.
@@ -125,26 +125,26 @@ const char *OpenSSL_version(int which) {
}
}
unsigned long SSLeay(void) { return OPENSSL_VERSION_NUMBER; }
unsigned long SSLeay() { return OPENSSL_VERSION_NUMBER; }
unsigned long OpenSSL_version_num(void) { return OPENSSL_VERSION_NUMBER; }
unsigned long OpenSSL_version_num() { return OPENSSL_VERSION_NUMBER; }
int CRYPTO_malloc_init(void) { return 1; }
int CRYPTO_malloc_init() { return 1; }
int OPENSSL_malloc_init(void) { return 1; }
int OPENSSL_malloc_init() { return 1; }
void ENGINE_load_builtin_engines(void) {}
void ENGINE_load_builtin_engines() {}
int ENGINE_register_all_complete(void) { return 1; }
int ENGINE_register_all_complete() { return 1; }
void ENGINE_cleanup(void) {}
void ENGINE_cleanup() {}
void OPENSSL_load_builtin_modules(void) {}
void OPENSSL_load_builtin_modules() {}
int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) {
return 1;
}
void OPENSSL_cleanup(void) {}
void OPENSSL_cleanup() {}
FILE *CRYPTO_get_stderr(void) { return stderr; }
FILE *CRYPTO_get_stderr() { return stderr; }
crypto/digest/digest_extra.cc
+5 -5
View File
@@ -32,7 +32,7 @@
struct nid_to_digest {
int nid;
const EVP_MD *(*md_func)(void);
const EVP_MD *(*md_func)();
const char *short_name;
const char *long_name;
};
@@ -237,7 +237,7 @@ static const EVP_MD evp_md_blake2b256 = {
BLAKE2B_CBLOCK, sizeof(BLAKE2B_CTX),
};
const EVP_MD *EVP_blake2b256(void) { return &evp_md_blake2b256; }
const EVP_MD *EVP_blake2b256() { return &evp_md_blake2b256; }
static_assert(sizeof(BLAKE2B_CTX) <= EVP_MAX_MD_DATA_SIZE);
@@ -266,7 +266,7 @@ static const EVP_MD evp_md_md4 = {
sizeof(MD4_CTX),
};
const EVP_MD *EVP_md4(void) { return &evp_md_md4; }
const EVP_MD *EVP_md4() { return &evp_md_md4; }
static_assert(sizeof(MD4_CTX) <= EVP_MAX_MD_DATA_SIZE);
@@ -289,7 +289,7 @@ static const EVP_MD evp_md_md5 = {
md5_update, md5_final, 64, sizeof(MD5_CTX),
};
const EVP_MD *EVP_md5(void) { return &evp_md_md5; }
const EVP_MD *EVP_md5() { return &evp_md_md5; }
static_assert(sizeof(MD5_CTX) <= EVP_MAX_MD_DATA_SIZE);
@@ -328,6 +328,6 @@ const EVP_MD evp_md_md5_sha1 = {
sizeof(MD5_SHA1_CTX),
};
const EVP_MD *EVP_md5_sha1(void) { return &evp_md_md5_sha1; }
const EVP_MD *EVP_md5_sha1() { return &evp_md_md5_sha1; }
static_assert(sizeof(MD5_SHA1_CTX) <= EVP_MAX_MD_DATA_SIZE);
crypto/digest/digest_test.cc
+1 -1
View File
@@ -43,7 +43,7 @@ struct MD {
// name is the name of the digest.
const char *name;
// md_func is the digest to test.
const EVP_MD *(*func)(void);
const EVP_MD *(*func)();
// one_shot_func is the convenience one-shot version of the
// digest.
uint8_t *(*one_shot_func)(const uint8_t *, size_t, uint8_t *);
crypto/dsa/dsa.cc
+2 -2
View File
@@ -45,7 +45,7 @@ static int dsa_sign_setup(const DSA *dsa, BN_CTX *ctx_in, BIGNUM **out_kinv,
static CRYPTO_EX_DATA_CLASS g_ex_data_class = CRYPTO_EX_DATA_CLASS_INIT;
DSA *DSA_new(void) {
DSA *DSA_new() {
DSA *dsa = reinterpret_cast<DSA *>(OPENSSL_zalloc(sizeof(DSA)));
if (dsa == nullptr) {
return nullptr;
@@ -477,7 +477,7 @@ err:
return ok;
}
DSA_SIG *DSA_SIG_new(void) {
DSA_SIG *DSA_SIG_new() {
return reinterpret_cast<DSA_SIG *>(OPENSSL_zalloc(sizeof(DSA_SIG)));
}
crypto/dsa/dsa_test.cc
+6 -7
View File
@@ -118,14 +118,13 @@ static const uint8_t fips_sig_bad_length[] = {
// fips_sig_bad_r is fips_sig with a bad r value.
static const uint8_t fips_sig_bad_r[] = {
0x30, 0x2d, 0x02, 0x15, 0x00, 0x8c, 0xac, 0x1a, 0xb6, 0x64, 0x10,
0x43, 0x5c, 0xb7, 0x18, 0x1f, 0x95, 0xb1, 0x6a, 0xb9, 0x7c, 0x92,
0xb3, 0x41, 0xc0, 0x02, 0x14, 0x41, 0xe2, 0x34, 0x5f, 0x1f, 0x56,
0xdf, 0x24, 0x58, 0xf4, 0x26, 0xd1, 0x55, 0xb4, 0xba, 0x2d, 0xb6,
0xdc, 0xd8, 0xc8,
0x30, 0x2d, 0x02, 0x15, 0x00, 0x8c, 0xac, 0x1a, 0xb6, 0x64, 0x10, 0x43,
0x5c, 0xb7, 0x18, 0x1f, 0x95, 0xb1, 0x6a, 0xb9, 0x7c, 0x92, 0xb3, 0x41,
0xc0, 0x02, 0x14, 0x41, 0xe2, 0x34, 0x5f, 0x1f, 0x56, 0xdf, 0x24, 0x58,
0xf4, 0x26, 0xd1, 0x55, 0xb4, 0xba, 0x2d, 0xb6, 0xdc, 0xd8, 0xc8,
};
static bssl::UniquePtr<DSA> GetFIPSDSAGroup(void) {
static bssl::UniquePtr<DSA> GetFIPSDSAGroup() {
bssl::UniquePtr<DSA> dsa(DSA_new());
if (!dsa) {
return nullptr;
@@ -143,7 +142,7 @@ static bssl::UniquePtr<DSA> GetFIPSDSAGroup(void) {
return dsa;
}
static bssl::UniquePtr<DSA> GetFIPSDSA(void) {
static bssl::UniquePtr<DSA> GetFIPSDSA() {
bssl::UniquePtr<DSA> dsa = GetFIPSDSAGroup();
if (!dsa) {
return nullptr;
crypto/ecdsa/ecdsa_asn1.cc
+1 -1
View File
@@ -151,7 +151,7 @@ size_t ECDSA_size(const EC_KEY *key) {
return ECDSA_SIG_max_len(group_order_size);
}
ECDSA_SIG *ECDSA_SIG_new(void) {
ECDSA_SIG *ECDSA_SIG_new() {
ECDSA_SIG *sig =
reinterpret_cast<ECDSA_SIG *>(OPENSSL_malloc(sizeof(ECDSA_SIG)));
if (sig == nullptr) {
crypto/engine/engine.cc
+1 -1
View File
@@ -30,7 +30,7 @@ struct engine_st {
ECDSA_METHOD *ecdsa_method;
};
ENGINE *ENGINE_new(void) {
ENGINE *ENGINE_new() {
return reinterpret_cast<ENGINE *>(OPENSSL_zalloc(sizeof(ENGINE)));
}
crypto/err/err.cc
+15 -15
View File
@@ -127,7 +127,7 @@ static void err_state_free(void *statep) {
}
// err_get_state gets the ERR_STATE object for the current thread.
static ERR_STATE *err_get_state(void) {
static ERR_STATE *err_get_state() {
ERR_STATE *state = reinterpret_cast<ERR_STATE *>(
CRYPTO_get_thread_local(OPENSSL_THREAD_LOCAL_ERR));
if (state == nullptr) {
@@ -216,7 +216,7 @@ static uint32_t get_error_values(int inc, int top, const char **file, int *line,
return ret;
}
uint32_t ERR_get_error(void) {
uint32_t ERR_get_error() {
return get_error_values(1 /* inc */, 0 /* bottom */, nullptr, nullptr,
nullptr, nullptr);
}
@@ -231,7 +231,7 @@ uint32_t ERR_get_error_line_data(const char **file, int *line,
return get_error_values(1 /* inc */, 0 /* bottom */, file, line, data, flags);
}
uint32_t ERR_peek_error(void) {
uint32_t ERR_peek_error() {
return get_error_values(0 /* peek */, 0 /* bottom */, nullptr, nullptr,
nullptr, nullptr);
}
@@ -247,7 +247,7 @@ uint32_t ERR_peek_error_line_data(const char **file, int *line,
flags);
}
uint32_t ERR_peek_last_error(void) {
uint32_t ERR_peek_last_error() {
return get_error_values(0 /* peek */, 1 /* top */, nullptr, nullptr, nullptr,
nullptr);
}
@@ -262,7 +262,7 @@ uint32_t ERR_peek_last_error_line_data(const char **file, int *line,
return get_error_values(0 /* peek */, 1 /* top */, file, line, data, flags);
}
void ERR_clear_error(void) {
void ERR_clear_error() {
ERR_STATE *const state = err_get_state();
unsigned i;
@@ -288,7 +288,7 @@ void ERR_remove_thread_state(const CRYPTO_THREADID *tid) {
ERR_clear_error();
}
int ERR_get_next_error_library(void) {
int ERR_get_next_error_library() {
int ret;
CRYPTO_MUTEX_lock_write(&global_next_library_mutex);
@@ -300,7 +300,7 @@ int ERR_get_next_error_library(void) {
void ERR_remove_state(unsigned long pid) { ERR_clear_error(); }
void ERR_clear_system_error(void) { errno = 0; }
void ERR_clear_system_error() { errno = 0; }
// err_string_cmp is a compare function for searching error values with
// |bsearch| in |err_string_lookup|.
@@ -701,7 +701,7 @@ void ERR_set_error_data(char *data, int flags) {
}
}
int ERR_set_mark(void) {
int ERR_set_mark() {
ERR_STATE *const state = err_get_state();
if (state == nullptr || state->bottom == state->top) {
@@ -711,7 +711,7 @@ int ERR_set_mark(void) {
return 1;
}
int ERR_pop_to_mark(void) {
int ERR_pop_to_mark() {
ERR_STATE *const state = err_get_state();
if (state == nullptr) {
@@ -737,15 +737,15 @@ int ERR_pop_to_mark(void) {
return 0;
}
void ERR_load_crypto_strings(void) {}
void ERR_load_crypto_strings() {}
void ERR_free_strings(void) {}
void ERR_free_strings() {}
void ERR_load_BIO_strings(void) {}
void ERR_load_BIO_strings() {}
void ERR_load_ERR_strings(void) {}
void ERR_load_ERR_strings() {}
void ERR_load_RAND_strings(void) {}
void ERR_load_RAND_strings() {}
BSSL_NAMESPACE_BEGIN
@@ -767,7 +767,7 @@ void bssl::ERR_SAVE_STATE_free(ERR_SAVE_STATE *state) {
free(state);
}
ERR_SAVE_STATE *bssl::ERR_save_state(void) {
ERR_SAVE_STATE *bssl::ERR_save_state() {
ERR_STATE *const state = err_get_state();
if (state == nullptr || state->top == state->bottom) {
return nullptr;
crypto/err/internal.h
+1 -1
View File
@@ -33,7 +33,7 @@ OPENSSL_EXPORT void ERR_SAVE_STATE_free(ERR_SAVE_STATE *state);
// ERR_save_state returns a newly-allocated |ERR_SAVE_STATE| structure
// containing the current state of the error queue or NULL on allocation
// error. It should be released with |ERR_SAVE_STATE_free|.
OPENSSL_EXPORT ERR_SAVE_STATE *ERR_save_state(void);
OPENSSL_EXPORT ERR_SAVE_STATE *ERR_save_state();
// ERR_restore_state clears the error queue and replaces it with |state|.
OPENSSL_EXPORT void ERR_restore_state(const ERR_SAVE_STATE *state);
crypto/evp/evp.cc
+6 -6
View File
@@ -34,7 +34,7 @@ OPENSSL_DECLARE_ERROR_REASON(EVP, NOT_XOF_OR_INVALID_LENGTH)
// directory.
OPENSSL_DECLARE_ERROR_REASON(EVP, EMPTY_PSK)
EVP_PKEY *EVP_PKEY_new(void) {
EVP_PKEY *EVP_PKEY_new() {
EVP_PKEY *ret =
reinterpret_cast<EVP_PKEY *>(OPENSSL_zalloc(sizeof(EVP_PKEY)));
if (ret == nullptr) {
@@ -346,15 +346,15 @@ void *EVP_PKEY_get0(const EVP_PKEY *pkey) {
return nullptr;
}
void OpenSSL_add_all_algorithms(void) {}
void OpenSSL_add_all_algorithms() {}
void OPENSSL_add_all_algorithms_conf(void) {}
void OPENSSL_add_all_algorithms_conf() {}
void OpenSSL_add_all_ciphers(void) {}
void OpenSSL_add_all_ciphers() {}
void OpenSSL_add_all_digests(void) {}
void OpenSSL_add_all_digests() {}
void EVP_cleanup(void) {}
void EVP_cleanup() {}
int EVP_PKEY_set1_tls_encodedpoint(EVP_PKEY *pkey, const uint8_t *in,
size_t len) {
crypto/evp/p_dsa.cc
+1 -1
View File
@@ -242,7 +242,7 @@ const EVP_PKEY_ASN1_METHOD dsa_asn1_meth = {
} // namespace
const EVP_PKEY_ALG *EVP_pkey_dsa(void) {
const EVP_PKEY_ALG *EVP_pkey_dsa() {
static const EVP_PKEY_ALG kAlg = {&dsa_asn1_meth};
return &kAlg;
}
crypto/evp/p_ec.cc
+4 -4
View File
@@ -298,22 +298,22 @@ const EVP_PKEY_ASN1_METHOD ec_asn1_meth = {
} // namespace
const EVP_PKEY_ALG *EVP_pkey_ec_p224(void) {
const EVP_PKEY_ALG *EVP_pkey_ec_p224() {
static const EVP_PKEY_ALG_EC kAlg = {{&ec_asn1_meth}, &EC_group_p224};
return &kAlg;
}
const EVP_PKEY_ALG *EVP_pkey_ec_p256(void) {
const EVP_PKEY_ALG *EVP_pkey_ec_p256() {
static const EVP_PKEY_ALG_EC kAlg = {{&ec_asn1_meth}, &EC_group_p256};
return &kAlg;
}
const EVP_PKEY_ALG *EVP_pkey_ec_p384(void) {
const EVP_PKEY_ALG *EVP_pkey_ec_p384() {
static const EVP_PKEY_ALG_EC kAlg = {{&ec_asn1_meth}, &EC_group_p384};
return &kAlg;
}
const EVP_PKEY_ALG *EVP_pkey_ec_p521(void) {
const EVP_PKEY_ALG *EVP_pkey_ec_p521() {
static const EVP_PKEY_ALG_EC kAlg = {{&ec_asn1_meth}, &EC_group_p521};
return &kAlg;
}
crypto/evp/p_ed25519.cc
+1 -1
View File
@@ -324,7 +324,7 @@ const EVP_PKEY_CTX_METHOD ed25519_pkey_meth = {
/*ctrl=*/nullptr,
};
const EVP_PKEY_ALG *EVP_pkey_ed25519(void) {
const EVP_PKEY_ALG *EVP_pkey_ed25519() {
static const EVP_PKEY_ALG kAlg = {&ed25519_asn1_meth};
return &kAlg;
}
crypto/evp/p_rsa.cc
+4 -4
View File
@@ -804,24 +804,24 @@ static int pkey_rsa_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey) {
} // namespace
const EVP_PKEY_ALG *EVP_pkey_rsa(void) {
const EVP_PKEY_ALG *EVP_pkey_rsa() {
static const EVP_PKEY_ALG kAlg = {&rsa_asn1_meth};
return &kAlg;
}
const EVP_PKEY_ALG *EVP_pkey_rsa_pss_sha256(void) {
const EVP_PKEY_ALG *EVP_pkey_rsa_pss_sha256() {
static const EVP_PKEY_ALG_RSA_PSS kAlg = {{&rsa_pss_asn1_meth},
rsa_pss_sha256};
return &kAlg;
}
const EVP_PKEY_ALG *EVP_pkey_rsa_pss_sha384(void) {
const EVP_PKEY_ALG *EVP_pkey_rsa_pss_sha384() {
static const EVP_PKEY_ALG_RSA_PSS kAlg = {{&rsa_pss_asn1_meth},
rsa_pss_sha384};
return &kAlg;
}
const EVP_PKEY_ALG *EVP_pkey_rsa_pss_sha512(void) {
const EVP_PKEY_ALG *EVP_pkey_rsa_pss_sha512() {
static const EVP_PKEY_ALG_RSA_PSS kAlg = {{&rsa_pss_asn1_meth},
rsa_pss_sha512};
return &kAlg;
crypto/evp/p_x25519.cc
+1 -1
View File
@@ -256,7 +256,7 @@ const EVP_PKEY_ASN1_METHOD x25519_asn1_meth = {
} // namespace
const EVP_PKEY_ALG *EVP_pkey_x25519(void) {
const EVP_PKEY_ALG *EVP_pkey_x25519() {
static const EVP_PKEY_ALG kAlg = {&x25519_asn1_meth};
return &kAlg;
}
crypto/ex_data.cc
+1 -1
View File
@@ -136,4 +136,4 @@ void CRYPTO_free_ex_data(CRYPTO_EX_DATA_CLASS *ex_data_class,
ad->sk = nullptr;
}
void CRYPTO_cleanup_all_ex_data(void) {}
void CRYPTO_cleanup_all_ex_data() {}
crypto/fipsmodule/aes/gcm.cc.inc
+1 -1
View File
@@ -594,7 +594,7 @@ void CRYPTO_gcm128_tag(const GCM128_KEY *key, GCM128_CONTEXT *ctx, uint8_t *tag,
}
#if defined(OPENSSL_X86) || defined(OPENSSL_X86_64)
int crypto_gcm_clmul_enabled(void) {
int crypto_gcm_clmul_enabled() {
#if defined(GHASH_ASM_X86) || defined(GHASH_ASM_X86_64)
return CRYPTO_is_PCLMUL_capable() && CRYPTO_is_SSSE3_capable();
#else
crypto/fipsmodule/aes/internal.h
+14 -14
View File
@@ -57,28 +57,28 @@ ctr128_f aes_ctr_set_key(AES_KEY *aes_key, int *out_is_hwaes,
#define HWAES
#define HWAES_ECB
inline int hwaes_capable(void) { return CRYPTO_is_AESNI_capable(); }
inline int hwaes_capable() { return CRYPTO_is_AESNI_capable(); }
#define VPAES
#define VPAES_CBC
inline int vpaes_capable(void) { return CRYPTO_is_SSSE3_capable(); }
inline int vpaes_capable() { return CRYPTO_is_SSSE3_capable(); }
#elif defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64)
#define HWAES
inline int hwaes_capable(void) { return CRYPTO_is_ARMv8_AES_capable(); }
inline int hwaes_capable() { return CRYPTO_is_ARMv8_AES_capable(); }
#if defined(OPENSSL_ARM)
#define BSAES
#define VPAES
inline int bsaes_capable(void) { return CRYPTO_is_NEON_capable(); }
inline int vpaes_capable(void) { return CRYPTO_is_NEON_capable(); }
inline int bsaes_capable() { return CRYPTO_is_NEON_capable(); }
inline int vpaes_capable() { return CRYPTO_is_NEON_capable(); }
#endif
#if defined(OPENSSL_AARCH64)
#define VPAES
#define VPAES_CBC
inline int vpaes_capable(void) { return CRYPTO_is_NEON_capable(); }
inline int vpaes_capable() { return CRYPTO_is_NEON_capable(); }
#endif
#endif
@@ -112,10 +112,10 @@ void aes_hw_encrypt_key_to_decrypt_key(AES_KEY *key);
// worthwhile. However, the aesenclast version requires SSSE3. SSSE3 long
// predates AES-NI, but it's not clear if AES-NI implies SSSE3. In OpenSSL, the
// CCM AES-NI assembly seems to assume it does.
inline int aes_hw_set_encrypt_key_alt_capable(void) {
inline int aes_hw_set_encrypt_key_alt_capable() {
return hwaes_capable() && CRYPTO_is_SSSE3_capable();
}
inline int aes_hw_set_encrypt_key_alt_preferred(void) {
inline int aes_hw_set_encrypt_key_alt_preferred() {
return hwaes_capable() && CRYPTO_is_AVX_capable();
}
int aes_hw_set_encrypt_key_base(const uint8_t *user_key, int bits,
@@ -127,7 +127,7 @@ int aes_hw_set_encrypt_key_alt(const uint8_t *user_key, int bits, AES_KEY *key);
// If HWAES isn't defined then we provide dummy functions for each of the hwaes
// functions.
inline int hwaes_capable(void) { return 0; }
inline int hwaes_capable() { return 0; }
inline int aes_hw_set_encrypt_key(const uint8_t *user_key, int bits,
AES_KEY *key) {
@@ -182,7 +182,7 @@ void vpaes_ctr32_encrypt_blocks_with_bsaes(const uint8_t *in, uint8_t *out,
size_t blocks, const AES_KEY *key,
const uint8_t ivec[16]);
#else
inline int bsaes_capable(void) { return 0; }
inline int bsaes_capable() { return 0; }
// On other platforms, bsaes_capable() will always return false and so the
// following will never be called.
@@ -225,7 +225,7 @@ void vpaes_cbc_encrypt(const uint8_t *in, uint8_t *out, size_t length,
void vpaes_ctr32_encrypt_blocks(const uint8_t *in, uint8_t *out, size_t len,
const AES_KEY *key, const uint8_t ivec[16]);
#else
inline int vpaes_capable(void) { return 0; }
inline int vpaes_capable() { return 0; }
// On other platforms, vpaes_capable() will always return false and so the
// following will never be called.
@@ -358,7 +358,7 @@ typedef struct {
#if defined(OPENSSL_X86) || defined(OPENSSL_X86_64)
// crypto_gcm_clmul_enabled returns one if the CLMUL implementation of GCM is
// used.
int crypto_gcm_clmul_enabled(void);
int crypto_gcm_clmul_enabled();
#endif
// CRYPTO_ghash_init writes a precomputed table of powers of |gcm_key| to
@@ -476,14 +476,14 @@ void aes_gcm_dec_update_vaes_avx512(const uint8_t *in, uint8_t *out, size_t len,
#define GHASH_ASM_ARM
#define GCM_FUNCREF
inline int gcm_pmull_capable(void) { return CRYPTO_is_ARMv8_PMULL_capable(); }
inline int gcm_pmull_capable() { return CRYPTO_is_ARMv8_PMULL_capable(); }
void gcm_init_v8(u128 Htable[16], const uint64_t H[2]);
void gcm_gmult_v8(uint8_t Xi[16], const u128 Htable[16]);
void gcm_ghash_v8(uint8_t Xi[16], const u128 Htable[16], const uint8_t *inp,
size_t len);
inline int gcm_neon_capable(void) { return CRYPTO_is_NEON_capable(); }
inline int gcm_neon_capable() { return CRYPTO_is_NEON_capable(); }
void gcm_init_neon(u128 Htable[16], const uint64_t H[2]);
void gcm_gmult_neon(uint8_t Xi[16], const u128 Htable[16]);
crypto/fipsmodule/bcm.cc
+3 -3
View File
@@ -193,7 +193,7 @@ err:
}
#if !defined(OPENSSL_ASAN)
int BORINGSSL_integrity_test(void) {
int BORINGSSL_integrity_test() {
const uint8_t *const start = BORINGSSL_bcm_text_start;
const uint8_t *const end = BORINGSSL_bcm_text_end;
@@ -268,11 +268,11 @@ int BORINGSSL_integrity_test(void) {
return 1;
}
const uint8_t *FIPS_module_hash(void) { return BORINGSSL_bcm_text_hash; }
const uint8_t *FIPS_module_hash() { return BORINGSSL_bcm_text_hash; }
#endif // OPENSSL_ASAN
void BORINGSSL_FIPS_abort(void) {
void BORINGSSL_FIPS_abort() {
for (;;) {
abort();
exit(1);
crypto/fipsmodule/bn/bn.cc.inc
+2 -2
View File
@@ -30,7 +30,7 @@
// spare.
#define BN_MAX_WORDS (INT_MAX / (4 * BN_BITS2))
BIGNUM *BN_new(void) {
BIGNUM *BN_new() {
BIGNUM *bn = reinterpret_cast<BIGNUM *>(OPENSSL_malloc(sizeof(BIGNUM)));
if (bn == nullptr) {
@@ -43,7 +43,7 @@ BIGNUM *BN_new(void) {
return bn;
}
BIGNUM *BN_secure_new(void) { return BN_new(); }
BIGNUM *BN_secure_new() { return BN_new(); }
void BN_init(BIGNUM *bn) { OPENSSL_memset(bn, 0, sizeof(BIGNUM)); }
crypto/fipsmodule/bn/ctx.cc.inc
+1 -1
View File
@@ -49,7 +49,7 @@ struct bignum_ctx {
bool defer_error_ = false;
} /* BN_CTX */;
BN_CTX *BN_CTX_new(void) { return bssl::New<BN_CTX>(); }
BN_CTX *BN_CTX_new() { return bssl::New<BN_CTX>(); }
void BN_CTX_free(BN_CTX *ctx) { bssl::Delete(ctx); }
crypto/fipsmodule/bn/internal.h
+1 -1
View File
@@ -306,7 +306,7 @@ void bn_mul_mont_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
const BN_ULONG n0[BN_MONT_CTX_N0_LIMBS], size_t num);
#if defined(OPENSSL_X86_64)
inline int bn_mulx_adx_capable(void) {
inline int bn_mulx_adx_capable() {
// MULX is in BMI2.
return CRYPTO_is_BMI2_capable() && CRYPTO_is_ADX_capable();
}
crypto/fipsmodule/bn/montgomery.cc.inc
+1 -1
View File
@@ -37,7 +37,7 @@ void bn_mont_ctx_cleanup(BN_MONT_CTX *mont) {
BN_free(&mont->N);
}
BN_MONT_CTX *BN_MONT_CTX_new(void) {
BN_MONT_CTX *BN_MONT_CTX_new() {
BN_MONT_CTX *ret =
reinterpret_cast<BN_MONT_CTX *>(OPENSSL_malloc(sizeof(BN_MONT_CTX)));
if (ret == nullptr) {
crypto/fipsmodule/bn/prime.cc.inc
+1 -1
View File
@@ -267,7 +267,7 @@ static int probable_prime_dh(BIGNUM *rnd, int bits, const BIGNUM *add,
static int probable_prime_dh_safe(BIGNUM *rnd, int bits, const BIGNUM *add,
const BIGNUM *rem, BN_CTX *ctx);
BN_GENCB *BN_GENCB_new(void) {
BN_GENCB *BN_GENCB_new() {
return reinterpret_cast<BN_GENCB *>(OPENSSL_zalloc(sizeof(BN_GENCB)));
}
crypto/fipsmodule/bn/rsaz_exp.h
+2 -2
View File
@@ -44,9 +44,9 @@ void RSAZ_1024_mod_exp_avx2(BN_ULONG result[16], const BN_ULONG base_norm[16],
BN_ULONG k0,
BN_ULONG storage_words[MOD_EXP_CTIME_STORAGE_LEN]);
inline int rsaz_avx2_capable(void) { return CRYPTO_is_AVX2_capable(); }
inline int rsaz_avx2_capable() { return CRYPTO_is_AVX2_capable(); }
inline int rsaz_avx2_preferred(void) {
inline int rsaz_avx2_preferred() {
if (CRYPTO_is_BMI1_capable() && CRYPTO_is_BMI2_capable() &&
CRYPTO_is_ADX_capable()) {
// If BMI1, BMI2, and ADX are available, x86_64-mont5.pl is faster. See the
crypto/fipsmodule/cipher/cipher.cc.inc
+1 -1
View File
@@ -32,7 +32,7 @@ void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx) {
OPENSSL_memset(ctx, 0, sizeof(EVP_CIPHER_CTX));
}
EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void) {
EVP_CIPHER_CTX *EVP_CIPHER_CTX_new() {
EVP_CIPHER_CTX *ctx = reinterpret_cast<EVP_CIPHER_CTX *>(
OPENSSL_malloc(sizeof(EVP_CIPHER_CTX)));
if (ctx) {
crypto/fipsmodule/cipher/e_aes.cc.inc
+10 -10
View File
@@ -681,19 +681,19 @@ DEFINE_LOCAL_DATA(EVP_CIPHER, aes_hw_256_ecb) {
out->cipher_update = aes_hw_ecb_cipher_update;
}
#define EVP_ECB_CIPHER_FUNCTION(keybits) \
const EVP_CIPHER *EVP_aes_##keybits##_ecb(void) { \
if (hwaes_capable()) { \
return aes_hw_##keybits##_ecb(); \
} \
return aes_##keybits##_ecb_generic(); \
#define EVP_ECB_CIPHER_FUNCTION(keybits) \
const EVP_CIPHER *EVP_aes_##keybits##_ecb() { \
if (hwaes_capable()) { \
return aes_hw_##keybits##_ecb(); \
} \
return aes_##keybits##_ecb_generic(); \
}
#else
#define EVP_ECB_CIPHER_FUNCTION(keybits) \
const EVP_CIPHER *EVP_aes_##keybits##_ecb(void) { \
return aes_##keybits##_ecb_generic(); \
#define EVP_ECB_CIPHER_FUNCTION(keybits) \
const EVP_CIPHER *EVP_aes_##keybits##_ecb() { \
return aes_##keybits##_ecb_generic(); \
}
#endif // HWAES_ECB
@@ -1213,7 +1213,7 @@ DEFINE_METHOD_FUNCTION(EVP_AEAD, EVP_aead_aes_256_gcm_tls13) {
out->openv_detached = aead_aes_gcm_openv_detached;
}
int EVP_has_aes_hardware(void) {
int EVP_has_aes_hardware() {
#if defined(OPENSSL_X86) || defined(OPENSSL_X86_64)
return hwaes_capable() && crypto_gcm_clmul_enabled();
#elif defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64)
crypto/fipsmodule/cmac/cmac.cc.inc
+1 -1
View File
@@ -84,7 +84,7 @@ int AES_CMAC(uint8_t out[16], const uint8_t *key, size_t key_len,
return ok;
}
CMAC_CTX *CMAC_CTX_new(void) {
CMAC_CTX *CMAC_CTX_new() {
CMAC_CTX *ctx = reinterpret_cast<CMAC_CTX *>(OPENSSL_malloc(sizeof(*ctx)));
if (ctx != nullptr) {
CMAC_CTX_init(ctx);
crypto/fipsmodule/delocate.h
+17 -17
View File
@@ -27,13 +27,13 @@
extern "C" { \
extern type bcm_##name; \
type bcm_##name = init_value; \
type *bcm_##name##_bss_get(void) __attribute__((const)); \
type *bcm_##name##_bss_get() __attribute__((const)); \
} /* extern "C" */ \
\
/* The getter functions are exported, but static variables are usually named \
* with short names. Define a static wrapper function so the caller can use \
* a short name, while the symbol itself is prefixed. */ \
static type *name##_bss_get(void) { return bcm_##name##_bss_get(); }
static type *name##_bss_get() { return bcm_##name##_bss_get(); }
// For FIPS builds we require that CRYPTO_ONCE_INIT be zero.
#define DEFINE_STATIC_ONCE(name) \
DEFINE_BSS_GET(CRYPTO_once_t, name, CRYPTO_ONCE_INIT)
@@ -46,29 +46,29 @@
#else
#define DEFINE_BSS_GET(type, name, init_value) \
static type name = init_value; \
static type *name##_bss_get(void) { return &name; }
static type *name##_bss_get() { return &name; }
#define DEFINE_STATIC_ONCE(name) \
static CRYPTO_once_t name = CRYPTO_ONCE_INIT; \
static CRYPTO_once_t *name##_bss_get(void) { return &name; }
static CRYPTO_once_t *name##_bss_get() { return &name; }
#define DEFINE_STATIC_MUTEX(name) \
static CRYPTO_MUTEX name = CRYPTO_MUTEX_INIT; \
static CRYPTO_MUTEX *name##_bss_get(void) { return &name; }
static CRYPTO_MUTEX *name##_bss_get() { return &name; }
#define DEFINE_STATIC_EX_DATA_CLASS(name) \
static CRYPTO_EX_DATA_CLASS name = CRYPTO_EX_DATA_CLASS_INIT; \
static CRYPTO_EX_DATA_CLASS *name##_bss_get(void) { return &name; }
static CRYPTO_EX_DATA_CLASS *name##_bss_get() { return &name; }
#endif
#define DEFINE_DATA(type, name, accessor_decorations) \
DEFINE_BSS_GET(type, name##_storage, {}) \
DEFINE_STATIC_ONCE(name##_once) \
static void name##_do_init(type *out); \
static void name##_init(void) { name##_do_init(name##_storage_bss_get()); } \
accessor_decorations type *name(void) { \
CRYPTO_once(name##_once_bss_get(), name##_init); \
/* See http://c-faq.com/ansi/constmismatch.html for why the following \
* cast is needed. */ \
return (const type *)name##_storage_bss_get(); \
} \
#define DEFINE_DATA(type, name, accessor_decorations) \
DEFINE_BSS_GET(type, name##_storage, {}) \
DEFINE_STATIC_ONCE(name##_once) \
static void name##_do_init(type *out); \
static void name##_init() { name##_do_init(name##_storage_bss_get()); } \
accessor_decorations type *name() { \
CRYPTO_once(name##_once_bss_get(), name##_init); \
/* See http://c-faq.com/ansi/constmismatch.html for why the following \
* cast is needed. */ \
return (const type *)name##_storage_bss_get(); \
} \
static void name##_do_init(type *out)
// DEFINE_METHOD_FUNCTION defines a function named |name| which returns a
crypto/fipsmodule/dh/dh.cc.inc
+2 -2
View File
@@ -29,7 +29,7 @@
#include "internal.h"
DH *DH_new(void) {
DH *DH_new() {
DH *dh = reinterpret_cast<DH *>(OPENSSL_zalloc(sizeof(DH)));
if (dh == nullptr) {
return nullptr;
@@ -379,7 +379,7 @@ int DH_up_ref(DH *dh) {
return 1;
}
DH *DH_get_rfc7919_2048(void) {
DH *DH_get_rfc7919_2048() {
// This is the prime from https://tools.ietf.org/html/rfc7919#appendix-A.1,
// which is specifically approved for FIPS in appendix D of SP 800-56Ar3.
static const BN_ULONG kFFDHE2048Data[] = {
crypto/fipsmodule/digest/digest.cc.inc
+2 -2
View File
@@ -41,7 +41,7 @@ void EVP_MD_CTX_init(EVP_MD_CTX *ctx) {
ctx->pctx_ops = nullptr;
}
EVP_MD_CTX *EVP_MD_CTX_new(void) {
EVP_MD_CTX *EVP_MD_CTX_new() {
EVP_MD_CTX *ctx =
reinterpret_cast<EVP_MD_CTX *>(OPENSSL_malloc(sizeof(EVP_MD_CTX)));
@@ -52,7 +52,7 @@ EVP_MD_CTX *EVP_MD_CTX_new(void) {
return ctx;
}
EVP_MD_CTX *EVP_MD_CTX_create(void) { return EVP_MD_CTX_new(); }
EVP_MD_CTX *EVP_MD_CTX_create() { return EVP_MD_CTX_new(); }
int EVP_MD_CTX_cleanup(EVP_MD_CTX *ctx) {
assert(ctx->pctx == nullptr || ctx->pctx_ops != nullptr);
crypto/fipsmodule/ec/ec_key.cc.inc
+1 -1
View File
@@ -52,7 +52,7 @@ static void ec_wrapped_scalar_free(EC_WRAPPED_SCALAR *scalar) {
OPENSSL_free(scalar);
}
EC_KEY *EC_KEY_new(void) { return EC_KEY_new_method(nullptr); }
EC_KEY *EC_KEY_new() { return EC_KEY_new_method(nullptr); }
EC_KEY *EC_KEY_new_method(const ENGINE *engine) {
EC_KEY *ret = reinterpret_cast<EC_KEY *>(OPENSSL_zalloc(sizeof(EC_KEY)));
crypto/fipsmodule/ec/internal.h
+4 -4
View File
@@ -537,7 +537,7 @@ struct ec_method_st {
const EC_SCALAR *r);
} /* EC_METHOD */;
const EC_METHOD *EC_GFp_mont_method(void);
const EC_METHOD *EC_GFp_mont_method();
struct ec_point_st {
// group is an owning reference to |group|, unless this is
@@ -668,12 +668,12 @@ int ec_GFp_mont_felem_from_bytes(const EC_GROUP *group, EC_FELEM *out,
void ec_GFp_nistp_recode_scalar_bits(crypto_word_t *sign, crypto_word_t *digit,
crypto_word_t in);
const EC_METHOD *EC_GFp_nistp224_method(void);
const EC_METHOD *EC_GFp_nistp256_method(void);
const EC_METHOD *EC_GFp_nistp224_method();
const EC_METHOD *EC_GFp_nistp256_method();
// EC_GFp_nistz256_method is a GFp method using montgomery multiplication, with
// x86-64 optimized P256. See http://eprint.iacr.org/2013/816.
const EC_METHOD *EC_GFp_nistz256_method(void);
const EC_METHOD *EC_GFp_nistz256_method();
// An EC_WRAPPED_SCALAR is an |EC_SCALAR| with a parallel |BIGNUM|
// representation. It exists to support the |EC_KEY_get0_private_key| API.
crypto/fipsmodule/hkdf/hkdf_test.cc
+1 -1
View File
@@ -30,7 +30,7 @@
namespace {
struct HKDFTestVector {
const EVP_MD *(*md_func)(void);
const EVP_MD *(*md_func)();
const uint8_t ikm[80];
const size_t ikm_len;
const uint8_t salt[80];
crypto/fipsmodule/hmac/hmac.cc.inc
+1 -1
View File
@@ -55,7 +55,7 @@ void HMAC_CTX_init(HMAC_CTX *ctx) {
EVP_MD_CTX_init(&ctx->md_ctx);
}
HMAC_CTX *HMAC_CTX_new(void) {
HMAC_CTX *HMAC_CTX_new() {
HMAC_CTX *ctx =
reinterpret_cast<HMAC_CTX *>(OPENSSL_malloc(sizeof(HMAC_CTX)));
if (ctx != nullptr) {
crypto/fipsmodule/mldsa/mldsa.cc.inc
+6 -6
View File
@@ -2238,7 +2238,7 @@ int check_key(const private_key<K, L> *priv) {
DEFINE_STATIC_ONCE(g_mldsa_keygen_self_test_once)
void ensure_keygen_self_test(void) {
void ensure_keygen_self_test() {
CRYPTO_once(g_mldsa_keygen_self_test_once_bss_get(), []() {
if (!keygen_self_test()) {
BORINGSSL_FIPS_abort();
@@ -2248,7 +2248,7 @@ void ensure_keygen_self_test(void) {
DEFINE_STATIC_ONCE(g_mldsa_sign_self_test_once)
void ensure_sign_self_test(void) {
void ensure_sign_self_test() {
CRYPTO_once(g_mldsa_sign_self_test_once_bss_get(), []() {
if (!sign_self_test()) {
BORINGSSL_FIPS_abort();
@@ -2258,7 +2258,7 @@ void ensure_sign_self_test(void) {
DEFINE_STATIC_ONCE(g_mldsa_verify_self_test_once)
void ensure_verify_self_test(void) {
void ensure_verify_self_test() {
CRYPTO_once(g_mldsa_verify_self_test_once_bss_get(), []() {
if (!verify_self_test()) {
BORINGSSL_FIPS_abort();
@@ -2268,9 +2268,9 @@ void ensure_verify_self_test(void) {
#else
void ensure_keygen_self_test(void) {}
void ensure_sign_self_test(void) {}
void ensure_verify_self_test(void) {}
void ensure_keygen_self_test() {}
void ensure_sign_self_test() {}
void ensure_verify_self_test() {}
#endif
crypto/fipsmodule/mlkem/mlkem.cc.inc
+6 -6
View File
@@ -1032,7 +1032,7 @@ static int decap_self_test() {
DEFINE_STATIC_ONCE(g_mlkem_keygen_self_test_once)
void ensure_keygen_self_test(void) {
void ensure_keygen_self_test() {
CRYPTO_once(g_mlkem_keygen_self_test_once_bss_get(), []() {
if (!keygen_self_test()) {
BORINGSSL_FIPS_abort();
@@ -1042,7 +1042,7 @@ void ensure_keygen_self_test(void) {
DEFINE_STATIC_ONCE(g_mlkem_encap_self_test_once)
void ensure_encap_self_test(void) {
void ensure_encap_self_test() {
CRYPTO_once(g_mlkem_encap_self_test_once_bss_get(), []() {
if (!encap_self_test()) {
BORINGSSL_FIPS_abort();
@@ -1052,7 +1052,7 @@ void ensure_encap_self_test(void) {
DEFINE_STATIC_ONCE(g_mlkem_decap_self_test_once)
void ensure_decap_self_test(void) {
void ensure_decap_self_test() {
CRYPTO_once(g_mlkem_decap_self_test_once_bss_get(), []() {
if (!decap_self_test()) {
BORINGSSL_FIPS_abort();
@@ -1062,9 +1062,9 @@ void ensure_decap_self_test(void) {
#else
void ensure_keygen_self_test(void) {}
void ensure_encap_self_test(void) {}
void ensure_decap_self_test(void) {}
void ensure_keygen_self_test() {}
void ensure_encap_self_test() {}
void ensure_decap_self_test() {}
#endif
} // namespace fips
crypto/fipsmodule/rand/internal.h
+5 -5
View File
@@ -27,7 +27,7 @@ extern "C" {
// rand_fork_unsafe_buffering_enabled returns whether fork-unsafe buffering has
// been enabled via |RAND_enable_fork_unsafe_buffering|.
int rand_fork_unsafe_buffering_enabled(void);
int rand_fork_unsafe_buffering_enabled();
// CTR_DRBG_STATE contains the state of a CTR_DRBG based on AES-256. See SP
// 800-90Ar1.
@@ -55,12 +55,12 @@ OPENSSL_EXPORT int CTR_DRBG_init(CTR_DRBG_STATE *drbg, int df,
#if defined(OPENSSL_X86_64) && !defined(OPENSSL_NO_ASM)
inline int have_rdrand(void) { return CRYPTO_is_RDRAND_capable(); }
inline int have_rdrand() { return CRYPTO_is_RDRAND_capable(); }
// have_fast_rdrand returns true if RDRAND is supported and it's reasonably
// fast. Concretely the latter is defined by whether the chip is Intel (fast) or
// not (assumed slow).
inline int have_fast_rdrand(void) {
inline int have_fast_rdrand() {
return CRYPTO_is_RDRAND_capable() && CRYPTO_is_intel_cpu();
}
@@ -75,9 +75,9 @@ int CRYPTO_rdrand_multiple8_buf(uint8_t *buf, size_t len);
#else // OPENSSL_X86_64 && !OPENSSL_NO_ASM
inline int have_rdrand(void) { return 0; }
inline int have_rdrand() { return 0; }
inline int have_fast_rdrand(void) { return 0; }
inline int have_fast_rdrand() { return 0; }
#endif // OPENSSL_X86_64 && !OPENSSL_NO_ASM
crypto/fipsmodule/rand/rand.cc.inc
+2 -2
View File
@@ -91,8 +91,8 @@ struct rand_thread_state {
DEFINE_BSS_GET(struct rand_thread_state *, thread_states_list, nullptr)
DEFINE_STATIC_MUTEX(thread_states_list_lock)
static void rand_thread_state_clear_all(void) __attribute__((destructor));
static void rand_thread_state_clear_all(void) {
static void rand_thread_state_clear_all() __attribute__((destructor));
static void rand_thread_state_clear_all() {
CRYPTO_MUTEX_lock_write(thread_states_list_lock_bss_get());
for (struct rand_thread_state *cur = *thread_states_list_bss_get();
cur != nullptr; cur = cur->next) {
crypto/fipsmodule/rsa/internal.h
+1 -1
View File
@@ -90,7 +90,7 @@ struct rsa_st {
// Default implementations of RSA operations.
const RSA_METHOD *RSA_default_method(void);
const RSA_METHOD *RSA_default_method();
int rsa_default_sign_raw(RSA *rsa, size_t *out_len, uint8_t *out,
size_t max_out, const uint8_t *in, size_t in_len,
crypto/fipsmodule/rsa/rsa.cc.inc
+1 -1
View File
@@ -162,7 +162,7 @@ RSA *RSA_new_private_key_large_e(const BIGNUM *n, const BIGNUM *e,
return rsa;
}
RSA *RSA_new(void) { return RSA_new_method(nullptr); }
RSA *RSA_new() { return RSA_new_method(nullptr); }
RSA *RSA_new_method(const ENGINE *engine) {
RSA *rsa = reinterpret_cast<RSA *>(OPENSSL_zalloc(sizeof(RSA)));
crypto/fipsmodule/self_check/fips.cc.inc
+4 -6
View File
@@ -18,7 +18,7 @@
#include "../delocate.h"
int FIPS_mode(void) {
int FIPS_mode() {
#if defined(BORINGSSL_FIPS) && !defined(OPENSSL_ASAN)
return 1;
#else
@@ -28,9 +28,9 @@ int FIPS_mode(void) {
int FIPS_mode_set(int on) { return on == FIPS_mode(); }
const char *FIPS_module_name(void) { return "BoringCrypto"; }
const char *FIPS_module_name() { return "BoringCrypto"; }
int CRYPTO_has_asm(void) {
int CRYPTO_has_asm() {
#if defined(OPENSSL_NO_ASM)
return 0;
#else
@@ -38,9 +38,7 @@ int CRYPTO_has_asm(void) {
#endif
}
uint32_t FIPS_version(void) {
return 0;
}
uint32_t FIPS_version() { return 0; }
int FIPS_query_algorithm_status(const char *algorithm) {
#if defined(BORINGSSL_FIPS)
crypto/fipsmodule/self_check/self_check.cc.inc
+19 -19
View File
@@ -73,7 +73,7 @@ static int set_bignum(BIGNUM **out, const uint8_t *in, size_t len) {
return *out != nullptr;
}
static RSA *self_test_rsa_key(void) {
static RSA *self_test_rsa_key() {
static const uint8_t kN[] = {
0xd3, 0x3a, 0x62, 0x9f, 0x07, 0x77, 0xb0, 0x18, 0xf3, 0xff, 0xfe, 0xcc,
0xc9, 0xa2, 0xc2, 0x3a, 0xa6, 0x1d, 0xd8, 0xf0, 0x26, 0x5b, 0x38, 0x90,
@@ -206,7 +206,7 @@ static RSA *self_test_rsa_key(void) {
return rsa;
}
static EC_KEY *self_test_ecdsa_key(void) {
static EC_KEY *self_test_ecdsa_key() {
static const uint8_t kQx[] = {
0xc8, 0x15, 0x61, 0xec, 0xf2, 0xe5, 0x4e, 0xde, 0xfe, 0x66, 0x17,
0xdb, 0x1c, 0x7a, 0x34, 0xa7, 0x07, 0x44, 0xdd, 0xb2, 0x61, 0xf2,
@@ -241,7 +241,7 @@ static EC_KEY *self_test_ecdsa_key(void) {
return ec_key;
}
static DH *self_test_dh(void) {
static DH *self_test_dh() {
DH *dh = DH_get_rfc7919_2048();
if (!dh) {
return nullptr;
@@ -283,7 +283,7 @@ err:
// actually exercised, in FIPS mode. (In non-FIPS mode these tests are only run
// when requested by |BORINGSSL_self_test|.)
static int boringssl_self_test_rsa(void) {
static int boringssl_self_test_rsa() {
int ret = 0;
uint8_t output[256];
@@ -380,7 +380,7 @@ err:
return ret;
}
static int boringssl_self_test_ecc(void) {
static int boringssl_self_test_ecc() {
int ret = 0;
EC_KEY *ec_key = nullptr;
EC_POINT *ec_point_in = nullptr;
@@ -506,7 +506,7 @@ err:
return ret;
}
static int boringssl_self_test_ffdh(void) {
static int boringssl_self_test_ffdh() {
int ret = 0;
DH *dh = nullptr;
BIGNUM *ffdhe2048_value = nullptr;
@@ -586,7 +586,7 @@ err:
#if defined(BORINGSSL_FIPS)
static void run_self_test_rsa(void) {
static void run_self_test_rsa() {
FIPS_service_indicator_lock_state();
if (!boringssl_self_test_rsa()) {
BORINGSSL_FIPS_abort();
@@ -596,11 +596,11 @@ static void run_self_test_rsa(void) {
DEFINE_STATIC_ONCE(g_self_test_once_rsa)
void boringssl_ensure_rsa_self_test(void) {
void boringssl_ensure_rsa_self_test() {
CRYPTO_once(g_self_test_once_rsa_bss_get(), run_self_test_rsa);
}
static void run_self_test_ecc(void) {
static void run_self_test_ecc() {
FIPS_service_indicator_lock_state();
if (!boringssl_self_test_ecc()) {
BORINGSSL_FIPS_abort();
@@ -610,11 +610,11 @@ static void run_self_test_ecc(void) {
DEFINE_STATIC_ONCE(g_self_test_once_ecc)
void boringssl_ensure_ecc_self_test(void) {
void boringssl_ensure_ecc_self_test() {
CRYPTO_once(g_self_test_once_ecc_bss_get(), run_self_test_ecc);
}
static void run_self_test_ffdh(void) {
static void run_self_test_ffdh() {
FIPS_service_indicator_lock_state();
if (!boringssl_self_test_ffdh()) {
BORINGSSL_FIPS_abort();
@@ -624,7 +624,7 @@ static void run_self_test_ffdh(void) {
DEFINE_STATIC_ONCE(g_self_test_once_ffdh)
void boringssl_ensure_ffdh_self_test(void) {
void boringssl_ensure_ffdh_self_test() {
CRYPTO_once(g_self_test_once_ffdh_bss_get(), run_self_test_ffdh);
}
@@ -635,7 +635,7 @@ void boringssl_ensure_ffdh_self_test(void) {
//
// These tests are run at process start when in FIPS mode.
int boringssl_self_test_sha256(void) {
int boringssl_self_test_sha256() {
static const uint8_t kInput[16] = {
0xff, 0x3b, 0x85, 0x7d, 0xa7, 0x23, 0x6a, 0x2b,
0xaa, 0x0f, 0x39, 0x6b, 0x51, 0x52, 0x22, 0x17,
@@ -653,7 +653,7 @@ int boringssl_self_test_sha256(void) {
sizeof(kPlaintextSHA256), "SHA-256 KAT");
}
int boringssl_self_test_sha512(void) {
int boringssl_self_test_sha512() {
static const uint8_t kInput[16] = {
0x21, 0x25, 0x12, 0xf8, 0xd2, 0xad, 0x83, 0x22,
0x78, 0x1c, 0x6c, 0x4d, 0x69, 0xa9, 0xda, 0xa1,
@@ -674,7 +674,7 @@ int boringssl_self_test_sha512(void) {
sizeof(kPlaintextSHA512), "SHA-512 KAT");
}
int boringssl_self_test_hmac_sha256(void) {
int boringssl_self_test_hmac_sha256() {
static const uint8_t kInput[16] = {
0xda, 0xd9, 0x12, 0x93, 0xdf, 0xcf, 0x2a, 0x7c,
0x8e, 0xcd, 0x13, 0xfe, 0x35, 0x3f, 0xa7, 0x5b,
@@ -694,7 +694,7 @@ int boringssl_self_test_hmac_sha256(void) {
sizeof(kPlaintextHMACSHA256), "HMAC-SHA-256 KAT");
}
static int boringssl_self_test_fast(void) {
static int boringssl_self_test_fast() {
static const uint8_t kAESKey[16] = {
'B', 'o', 'r', 'i', 'n', 'g', 'C', 'r',
'y', 'p', 't', 'o', ' ', 'K', 'e', 'y',
@@ -1022,7 +1022,7 @@ static int boringssl_self_test_fast(void) {
return 1;
}
int BORINGSSL_self_test(void) {
int BORINGSSL_self_test() {
if (!boringssl_self_test_fast() ||
// When requested to run self tests, also run some of the lazy tests.
!boringssl_self_test_rsa() || //
@@ -1036,7 +1036,7 @@ int BORINGSSL_self_test(void) {
return 1;
}
int BORINGSSL_self_test_all(void) {
int BORINGSSL_self_test_all() {
if (!BORINGSSL_self_test() ||
// When requested to run all self tests, add in the really slow tests.
!boringssl_self_test_slhdsa()) {
@@ -1047,5 +1047,5 @@ int BORINGSSL_self_test_all(void) {
}
#if defined(BORINGSSL_FIPS)
int boringssl_self_test_startup(void) { return boringssl_self_test_fast(); }
int boringssl_self_test_startup() { return boringssl_self_test_fast(); }
#endif
crypto/fipsmodule/service_indicator/internal.h
+8 -8
View File
@@ -34,14 +34,14 @@
// In non-FIPS builds, |FIPS_service_indicator_before_call| always returns zero
// and |FIPS_service_indicator_after_call| always returns one. Thus calls always
// appear to be approved. This is intended to simplify testing.
OPENSSL_EXPORT uint64_t FIPS_service_indicator_before_call(void);
OPENSSL_EXPORT uint64_t FIPS_service_indicator_after_call(void);
OPENSSL_EXPORT uint64_t FIPS_service_indicator_before_call();
OPENSSL_EXPORT uint64_t FIPS_service_indicator_after_call();
#if defined(BORINGSSL_FIPS)
// FIPS_service_indicator_update_state records that an approved service has been
// invoked.
void FIPS_service_indicator_update_state(void);
void FIPS_service_indicator_update_state();
// FIPS_service_indicator_lock_state and |FIPS_service_indicator_unlock_state|
// stop |FIPS_service_indicator_update_state| from actually updating the service
@@ -52,8 +52,8 @@ void FIPS_service_indicator_update_state(void);
//
// This lock nests: i.e. locking twice is fine so long as each lock is paired
// with an unlock. If the (64-bit) counter overflows, the process aborts.
void FIPS_service_indicator_lock_state(void);
void FIPS_service_indicator_unlock_state(void);
void FIPS_service_indicator_lock_state();
void FIPS_service_indicator_unlock_state();
// The following functions may call |FIPS_service_indicator_update_state| if
// their parameter specifies an approved operation.
@@ -72,9 +72,9 @@ void TLSKDF_verify_service_indicator(const EVP_MD *dgst);
// Service indicator functions are no-ops in non-FIPS builds.
inline void FIPS_service_indicator_update_state(void) {}
inline void FIPS_service_indicator_lock_state(void) {}
inline void FIPS_service_indicator_unlock_state(void) {}
inline void FIPS_service_indicator_update_state() {}
inline void FIPS_service_indicator_lock_state() {}
inline void FIPS_service_indicator_unlock_state() {}
inline void AEAD_GCM_verify_service_indicator(
[[maybe_unused]] const EVP_AEAD_CTX *ctx) {}
crypto/fipsmodule/service_indicator/service_indicator.cc.inc
+9 -9
View File
@@ -43,7 +43,7 @@ struct fips_service_indicator_state {
// FIPS 140-3 requires that the module should provide the service indicator
// for approved services irrespective of whether the user queries it or not.
// Hence, it is lazily initialized in any call to an approved service.
static struct fips_service_indicator_state *service_indicator_get(void) {
static struct fips_service_indicator_state *service_indicator_get() {
struct fips_service_indicator_state *indicator =
reinterpret_cast<fips_service_indicator_state *>(CRYPTO_get_thread_local(
OPENSSL_THREAD_LOCAL_FIPS_SERVICE_INDICATOR_STATE));
@@ -69,7 +69,7 @@ static struct fips_service_indicator_state *service_indicator_get(void) {
return indicator;
}
static uint64_t service_indicator_get_counter(void) {
static uint64_t service_indicator_get_counter() {
struct fips_service_indicator_state *indicator = service_indicator_get();
if (indicator == nullptr) {
return 0;
@@ -77,22 +77,22 @@ static uint64_t service_indicator_get_counter(void) {
return indicator->counter;
}
uint64_t FIPS_service_indicator_before_call(void) {
uint64_t FIPS_service_indicator_before_call() {
return service_indicator_get_counter();
}
uint64_t FIPS_service_indicator_after_call(void) {
uint64_t FIPS_service_indicator_after_call() {
return service_indicator_get_counter();
}
void FIPS_service_indicator_update_state(void) {
void FIPS_service_indicator_update_state() {
struct fips_service_indicator_state *indicator = service_indicator_get();
if (indicator && indicator->lock_state == STATE_UNLOCKED) {
indicator->counter++;
}
}
void FIPS_service_indicator_lock_state(void) {
void FIPS_service_indicator_lock_state() {
struct fips_service_indicator_state *indicator = service_indicator_get();
if (indicator == nullptr) {
return;
@@ -113,7 +113,7 @@ void FIPS_service_indicator_lock_state(void) {
indicator->lock_state = new_state;
}
void FIPS_service_indicator_unlock_state(void) {
void FIPS_service_indicator_unlock_state() {
struct fips_service_indicator_state *indicator = service_indicator_get();
if (indicator == nullptr) {
return;
@@ -315,9 +315,9 @@ void TLSKDF_verify_service_indicator(const EVP_MD *md) {
#else
uint64_t FIPS_service_indicator_before_call(void) { return 0; }
uint64_t FIPS_service_indicator_before_call() { return 0; }
uint64_t FIPS_service_indicator_after_call(void) {
uint64_t FIPS_service_indicator_after_call() {
// One is returned so that the return value is always greater than zero, the
// return value of |FIPS_service_indicator_before_call|. This makes everything
// report as "approved" in non-FIPS builds.
crypto/fipsmodule/service_indicator/service_indicator_test.cc
+1 -1
View File
@@ -1012,7 +1012,7 @@ TEST_P(EVPMDServiceIndicatorTest, EVP_Digests) {
static const struct HMACTestVector {
// func is the hash function for HMAC to test.
const EVP_MD *(*func)(void);
const EVP_MD *(*func)();
// expected_digest is the expected digest.
const uint8_t *expected_digest;
// expected to be approved or not.
crypto/fipsmodule/sha/internal.h
+18 -24
View File
@@ -33,14 +33,14 @@ extern "C" {
#define SHA512_ASM_NOHW
#define SHA1_ASM_HW
inline int sha1_hw_capable(void) { return CRYPTO_is_ARMv8_SHA1_capable(); }
inline int sha1_hw_capable() { return CRYPTO_is_ARMv8_SHA1_capable(); }
#define SHA1_ASM_NEON
void sha1_block_data_order_neon(uint32_t state[5], const uint8_t *data,
size_t num);
#define SHA256_ASM_HW
inline int sha256_hw_capable(void) { return CRYPTO_is_ARMv8_SHA256_capable(); }
inline int sha256_hw_capable() { return CRYPTO_is_ARMv8_SHA256_capable(); }
#define SHA256_ASM_NEON
void sha256_block_data_order_neon(uint32_t state[8], const uint8_t *data,
@@ -58,13 +58,13 @@ void sha512_block_data_order_neon(uint64_t state[8], const uint8_t *data,
#define SHA512_ASM_NOHW
#define SHA1_ASM_HW
inline int sha1_hw_capable(void) { return CRYPTO_is_ARMv8_SHA1_capable(); }
inline int sha1_hw_capable() { return CRYPTO_is_ARMv8_SHA1_capable(); }
#define SHA256_ASM_HW
inline int sha256_hw_capable(void) { return CRYPTO_is_ARMv8_SHA256_capable(); }
inline int sha256_hw_capable() { return CRYPTO_is_ARMv8_SHA256_capable(); }
#define SHA512_ASM_HW
inline int sha512_hw_capable(void) { return CRYPTO_is_ARMv8_SHA512_capable(); }
inline int sha512_hw_capable() { return CRYPTO_is_ARMv8_SHA512_capable(); }
#elif !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86)
@@ -73,14 +73,12 @@ inline int sha512_hw_capable(void) { return CRYPTO_is_ARMv8_SHA512_capable(); }
#define SHA512_ASM_NOHW
#define SHA1_ASM_SSSE3
inline int sha1_ssse3_capable(void) {
return CRYPTO_is_SSSE3_capable();
}
inline int sha1_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
void sha1_block_data_order_ssse3(uint32_t state[5], const uint8_t *data,
size_t num);
#define SHA1_ASM_AVX
inline int sha1_avx_capable(void) {
inline int sha1_avx_capable() {
// AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl.
//
// TODO(crbug.com/42290564): Should we enable SHAEXT on 32-bit x86?
@@ -90,14 +88,12 @@ void sha1_block_data_order_avx(uint32_t state[5], const uint8_t *data,
size_t num);
#define SHA256_ASM_SSSE3
inline int sha256_ssse3_capable(void) {
return CRYPTO_is_SSSE3_capable();
}
inline int sha256_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
void sha256_block_data_order_ssse3(uint32_t state[8], const uint8_t *data,
size_t num);
#define SHA256_ASM_AVX
inline int sha256_avx_capable(void) {
inline int sha256_avx_capable() {
// AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl.
//
// TODO(crbug.com/42290564): Should we enable SHAEXT on 32-bit x86?
@@ -107,9 +103,7 @@ void sha256_block_data_order_avx(uint32_t state[8], const uint8_t *data,
size_t num);
#define SHA512_ASM_SSSE3
inline int sha512_ssse3_capable(void) {
return CRYPTO_is_SSSE3_capable();
}
inline int sha512_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
void sha512_block_data_order_ssse3(uint64_t state[8], const uint8_t *data,
size_t num);
@@ -120,12 +114,12 @@ void sha512_block_data_order_ssse3(uint64_t state[8], const uint8_t *data,
#define SHA512_ASM_NOHW
#define SHA1_ASM_HW
inline int sha1_hw_capable(void) {
inline int sha1_hw_capable() {
return CRYPTO_is_x86_SHA_capable() && CRYPTO_is_SSSE3_capable();
}
#define SHA1_ASM_AVX2
inline int sha1_avx2_capable(void) {
inline int sha1_avx2_capable() {
return CRYPTO_is_AVX2_capable() && CRYPTO_is_BMI2_capable() &&
CRYPTO_is_BMI1_capable();
}
@@ -133,7 +127,7 @@ void sha1_block_data_order_avx2(uint32_t state[5], const uint8_t *data,
size_t num);
#define SHA1_ASM_AVX
inline int sha1_avx_capable(void) {
inline int sha1_avx_capable() {
// AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl. Zen
// added the SHA extension, so this is moot on newer AMD CPUs.
return CRYPTO_is_AVX_capable() && CRYPTO_is_intel_cpu();
@@ -142,18 +136,18 @@ void sha1_block_data_order_avx(uint32_t state[5], const uint8_t *data,
size_t num);
#define SHA1_ASM_SSSE3
inline int sha1_ssse3_capable(void) { return CRYPTO_is_SSSE3_capable(); }
inline int sha1_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
void sha1_block_data_order_ssse3(uint32_t state[5], const uint8_t *data,
size_t num);
#define SHA256_ASM_HW
inline int sha256_hw_capable(void) {
inline int sha256_hw_capable() {
// Note that the original assembly did not check SSSE3.
return CRYPTO_is_x86_SHA_capable() && CRYPTO_is_SSSE3_capable();
}
#define SHA256_ASM_AVX
inline int sha256_avx_capable(void) {
inline int sha256_avx_capable() {
// AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl. Zen
// added the SHA extension, so this is moot on newer AMD CPUs.
return CRYPTO_is_AVX_capable() && CRYPTO_is_intel_cpu();
@@ -162,12 +156,12 @@ void sha256_block_data_order_avx(uint32_t state[8], const uint8_t *data,
size_t num);
#define SHA256_ASM_SSSE3
inline int sha256_ssse3_capable(void) { return CRYPTO_is_SSSE3_capable(); }
inline int sha256_ssse3_capable() { return CRYPTO_is_SSSE3_capable(); }
void sha256_block_data_order_ssse3(uint32_t state[8], const uint8_t *data,
size_t num);
#define SHA512_ASM_AVX
inline int sha512_avx_capable(void) {
inline int sha512_avx_capable() {
// AMD CPUs have slow SHLD/SHRD. See also the discussion in sha1-586.pl.
//
// TODO(crbug.com/42290564): Fixing and enabling the AVX2 implementation would
crypto/fipsmodule/slhdsa/slhdsa.cc.inc
+6 -6
View File
@@ -265,7 +265,7 @@ static int verify_self_test() {
DEFINE_STATIC_ONCE(g_slhdsa_keygen_self_test_once)
void ensure_keygen_self_test(void) {
void ensure_keygen_self_test() {
CRYPTO_once(g_slhdsa_keygen_self_test_once_bss_get(), []() {
if (!keygen_self_test()) {
BORINGSSL_FIPS_abort();
@@ -275,7 +275,7 @@ void ensure_keygen_self_test(void) {
DEFINE_STATIC_ONCE(g_slhdsa_sign_self_test_once)
void ensure_sign_self_test(void) {
void ensure_sign_self_test() {
CRYPTO_once(g_slhdsa_sign_self_test_once_bss_get(), []() {
if (!sign_self_test()) {
BORINGSSL_FIPS_abort();
@@ -285,7 +285,7 @@ void ensure_sign_self_test(void) {
DEFINE_STATIC_ONCE(g_slhdsa_verify_self_test_once)
void ensure_verify_self_test(void) {
void ensure_verify_self_test() {
CRYPTO_once(g_slhdsa_verify_self_test_once_bss_get(), []() {
if (!verify_self_test()) {
BORINGSSL_FIPS_abort();
@@ -295,9 +295,9 @@ void ensure_verify_self_test(void) {
#else
void ensure_keygen_self_test(void) {}
void ensure_sign_self_test(void) {}
void ensure_verify_self_test(void) {}
void ensure_keygen_self_test() {}
void ensure_sign_self_test() {}
void ensure_verify_self_test() {}
#endif
crypto/fuzzer_mode.cc
+1 -1
View File
@@ -20,7 +20,7 @@
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
static bssl::Atomic<uint32_t> fuzzer_mode_enabled = 0;
int CRYPTO_fuzzer_mode_enabled(void) { return fuzzer_mode_enabled.load(); }
int CRYPTO_fuzzer_mode_enabled() { return fuzzer_mode_enabled.load(); }
void CRYPTO_set_fuzzer_mode(int enabled) {
fuzzer_mode_enabled.store(!!enabled);
crypto/hpke/hpke.cc
+13 -13
View File
@@ -75,12 +75,12 @@ struct evp_hpke_kem_st {
struct evp_hpke_kdf_st {
uint16_t id;
// We only support HKDF-based KDFs.
const EVP_MD *(*hkdf_md_func)(void);
const EVP_MD *(*hkdf_md_func)();
};
struct evp_hpke_aead_st {
uint16_t id;
const EVP_AEAD *(*aead_func)(void);
const EVP_AEAD *(*aead_func)();
};
@@ -299,7 +299,7 @@ static int x25519_auth_decap(const EVP_HPKE_KEY *key,
return 1;
}
const EVP_HPKE_KEM *EVP_hpke_x25519_hkdf_sha256(void) {
const EVP_HPKE_KEM *EVP_hpke_x25519_hkdf_sha256() {
static const EVP_HPKE_KEM kKEM = {
/*id=*/EVP_HPKE_DHKEM_X25519_HKDF_SHA256,
/*public_key_len=*/X25519_PUBLIC_VALUE_LEN,
@@ -587,7 +587,7 @@ static int p256_auth_decap(const EVP_HPKE_KEY *key, uint8_t *out_shared_secret,
return 1;
}
const EVP_HPKE_KEM *EVP_hpke_p256_hkdf_sha256(void) {
const EVP_HPKE_KEM *EVP_hpke_p256_hkdf_sha256() {
static const EVP_HPKE_KEM kKEM = {
/*id=*/EVP_HPKE_DHKEM_P256_HKDF_SHA256,
/*public_key_len=*/P256_PUBLIC_KEY_LEN,
@@ -701,7 +701,7 @@ static int xwing_decap(const EVP_HPKE_KEY *key, uint8_t *out_shared_secret,
return 1;
}
const EVP_HPKE_KEM *EVP_hpke_xwing(void) {
const EVP_HPKE_KEM *EVP_hpke_xwing() {
static const EVP_HPKE_KEM kKEM = {
/*id=*/EVP_HPKE_XWING,
/*public_key_len=*/XWING_PUBLIC_KEY_LEN,
@@ -871,8 +871,8 @@ static const EVP_HPKE_KEM kMLKEM = {
} // namespace
const EVP_HPKE_KEM *EVP_hpke_mlkem768(void) { return &kMLKEM<MLKEM768HPKE>; }
const EVP_HPKE_KEM *EVP_hpke_mlkem1024(void) { return &kMLKEM<MLKEM1024HPKE>; }
const EVP_HPKE_KEM *EVP_hpke_mlkem768() { return &kMLKEM<MLKEM768HPKE>; }
const EVP_HPKE_KEM *EVP_hpke_mlkem1024() { return &kMLKEM<MLKEM1024HPKE>; }
uint16_t EVP_HPKE_KEM_id(const EVP_HPKE_KEM *kem) { return kem->id; }
@@ -895,7 +895,7 @@ void EVP_HPKE_KEY_cleanup(EVP_HPKE_KEY *key) {
// future.
}
EVP_HPKE_KEY *EVP_HPKE_KEY_new(void) {
EVP_HPKE_KEY *EVP_HPKE_KEY_new() {
EVP_HPKE_KEY *key =
reinterpret_cast<EVP_HPKE_KEY *>(OPENSSL_malloc(sizeof(EVP_HPKE_KEY)));
if (key == nullptr) {
@@ -977,7 +977,7 @@ int EVP_HPKE_KEY_private_key(const EVP_HPKE_KEY *key, uint8_t *out,
// Supported KDFs and AEADs.
const EVP_HPKE_KDF *EVP_hpke_hkdf_sha256(void) {
const EVP_HPKE_KDF *EVP_hpke_hkdf_sha256() {
static const EVP_HPKE_KDF kKDF = {EVP_HPKE_HKDF_SHA256, &EVP_sha256};
return &kKDF;
}
@@ -988,19 +988,19 @@ const EVP_MD *EVP_HPKE_KDF_hkdf_md(const EVP_HPKE_KDF *kdf) {
return kdf->hkdf_md_func();
}
const EVP_HPKE_AEAD *EVP_hpke_aes_128_gcm(void) {
const EVP_HPKE_AEAD *EVP_hpke_aes_128_gcm() {
static const EVP_HPKE_AEAD kAEAD = {EVP_HPKE_AES_128_GCM,
&EVP_aead_aes_128_gcm};
return &kAEAD;
}
const EVP_HPKE_AEAD *EVP_hpke_aes_256_gcm(void) {
const EVP_HPKE_AEAD *EVP_hpke_aes_256_gcm() {
static const EVP_HPKE_AEAD kAEAD = {EVP_HPKE_AES_256_GCM,
&EVP_aead_aes_256_gcm};
return &kAEAD;
}
const EVP_HPKE_AEAD *EVP_hpke_chacha20_poly1305(void) {
const EVP_HPKE_AEAD *EVP_hpke_chacha20_poly1305() {
static const EVP_HPKE_AEAD kAEAD = {EVP_HPKE_CHACHA20_POLY1305,
&EVP_aead_chacha20_poly1305};
return &kAEAD;
@@ -1121,7 +1121,7 @@ void EVP_HPKE_CTX_cleanup(EVP_HPKE_CTX *ctx) {
EVP_AEAD_CTX_cleanup(&ctx->aead_ctx);
}
EVP_HPKE_CTX *EVP_HPKE_CTX_new(void) {
EVP_HPKE_CTX *EVP_HPKE_CTX_new() {
EVP_HPKE_CTX *ctx =
reinterpret_cast<EVP_HPKE_CTX *>(OPENSSL_malloc(sizeof(EVP_HPKE_CTX)));
if (ctx == nullptr) {
crypto/hrss/hrss.cc
+2 -2
View File
@@ -67,7 +67,7 @@
typedef __m128i vec_t;
// vec_capable returns one iff the current platform supports SSE2.
static int vec_capable(void) { return 1; }
static int vec_capable() { return 1; }
// vec_add performs a pair-wise addition of four uint16s from |a| and |b|.
static inline vec_t vec_add(vec_t a, vec_t b) { return _mm_add_epi16(a, b); }
@@ -192,7 +192,7 @@ typedef uint16x8_t vec_t;
// These functions perform the same actions as the SSE2 function of the same
// name, above.
static int vec_capable(void) { return CRYPTO_is_NEON_capable(); }
static int vec_capable() { return CRYPTO_is_NEON_capable(); }
static inline vec_t vec_add(vec_t a, vec_t b) { return a + b; }
crypto/internal.h
+54 -54
View File
@@ -72,13 +72,13 @@ extern "C" {
// OPENSSL_cpuid_setup initializes the platform-specific feature cache. This
// function should not be called directly. Call |OPENSSL_init_cpuid| instead.
void OPENSSL_cpuid_setup(void);
void OPENSSL_cpuid_setup();
// OPENSSL_init_cpuid initializes the platform-specific feature cache, if
// needed. This function is idempotent and may be called concurrently.
void OPENSSL_init_cpuid(void);
void OPENSSL_init_cpuid();
#else
inline void OPENSSL_init_cpuid(void) {}
inline void OPENSSL_init_cpuid() {}
#endif
#if (defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64)) && \
@@ -86,7 +86,7 @@ inline void OPENSSL_init_cpuid(void) {}
// OPENSSL_get_armcap_pointer_for_test returns a pointer to |OPENSSL_armcap_P|
// for unit tests. Any modifications to the value must be made before any other
// function call in BoringSSL.
OPENSSL_EXPORT uint32_t *OPENSSL_get_armcap_pointer_for_test(void);
OPENSSL_EXPORT uint32_t *OPENSSL_get_armcap_pointer_for_test();
#endif
@@ -143,21 +143,21 @@ typedef __uint128_t uint128_t;
// resets the internal malloc counter, to simulate further malloc failures. This
// should be called in between independent tests, at a point where failure from
// a previous test will not impact subsequent ones.
OPENSSL_EXPORT void OPENSSL_reset_malloc_counter_for_testing(void);
OPENSSL_EXPORT void OPENSSL_reset_malloc_counter_for_testing();
// OPENSSL_disable_malloc_failures_for_testing, when malloc testing is enabled,
// disables simulated malloc failures. Calls to |OPENSSL_malloc| will not
// increment the malloc counter or synthesize failures. This may be used to skip
// simulating malloc failures in some region of code.
OPENSSL_EXPORT void OPENSSL_disable_malloc_failures_for_testing(void);
OPENSSL_EXPORT void OPENSSL_disable_malloc_failures_for_testing();
// OPENSSL_enable_malloc_failures_for_testing, when malloc testing is enabled,
// re-enables simulated malloc failures.
OPENSSL_EXPORT void OPENSSL_enable_malloc_failures_for_testing(void);
OPENSSL_EXPORT void OPENSSL_enable_malloc_failures_for_testing();
#else
inline void OPENSSL_reset_malloc_counter_for_testing(void) {}
inline void OPENSSL_disable_malloc_failures_for_testing(void) {}
inline void OPENSSL_enable_malloc_failures_for_testing(void) {}
inline void OPENSSL_reset_malloc_counter_for_testing() {}
inline void OPENSSL_disable_malloc_failures_for_testing() {}
inline void OPENSSL_enable_malloc_failures_for_testing() {}
#endif
#if defined(__has_builtin)
@@ -539,7 +539,7 @@ typedef pthread_once_t CRYPTO_once_t;
//
// The |once| argument must be a |CRYPTO_once_t| that has been initialised with
// the value |CRYPTO_ONCE_INIT|.
OPENSSL_EXPORT void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void));
OPENSSL_EXPORT void CRYPTO_once(CRYPTO_once_t *once, void (*init)());
// Atomics.
@@ -1039,35 +1039,35 @@ static inline uint64_t CRYPTO_rotr_u64(uint64_t value, int shift) {
// BORINGSSL_FIPS_abort is called when a FIPS power-on or continuous test
// fails. It prevents any further cryptographic operations by the current
// process.
void BORINGSSL_FIPS_abort(void) __attribute__((noreturn));
void BORINGSSL_FIPS_abort() __attribute__((noreturn));
// boringssl_self_test_startup runs all startup self tests and returns one on
// success or zero on error. Startup self tests do not include lazy tests.
// Call |BORINGSSL_self_test| to run every self test.
int boringssl_self_test_startup(void);
int boringssl_self_test_startup();
// boringssl_ensure_rsa_self_test checks whether the RSA self-test has been run
// in this address space. If not, it runs it and crashes the address space if
// unsuccessful.
void boringssl_ensure_rsa_self_test(void);
void boringssl_ensure_rsa_self_test();
// boringssl_ensure_ecc_self_test checks whether the ECDSA and ECDH self-test
// has been run in this address space. If not, it runs it and crashes the
// address space if unsuccessful.
void boringssl_ensure_ecc_self_test(void);
void boringssl_ensure_ecc_self_test();
// boringssl_ensure_ffdh_self_test checks whether the FFDH self-test has been
// run in this address space. If not, it runs it and crashes the address space
// if unsuccessful.
void boringssl_ensure_ffdh_self_test(void);
void boringssl_ensure_ffdh_self_test();
#else
// Outside of FIPS mode, the lazy tests are no-ops.
inline void boringssl_ensure_rsa_self_test(void) {}
inline void boringssl_ensure_ecc_self_test(void) {}
inline void boringssl_ensure_ffdh_self_test(void) {}
inline void boringssl_ensure_rsa_self_test() {}
inline void boringssl_ensure_ecc_self_test() {}
inline void boringssl_ensure_ffdh_self_test() {}
#endif // FIPS
@@ -1078,22 +1078,22 @@ int BORINGSSL_check_test(const void *expected, const void *actual,
size_t expected_len, const char *name);
// boringssl_self_test_sha256 performs a SHA-256 KAT.
int boringssl_self_test_sha256(void);
int boringssl_self_test_sha256();
// boringssl_self_test_sha512 performs a SHA-512 KAT.
int boringssl_self_test_sha512(void);
int boringssl_self_test_sha512();
// boringssl_self_test_hmac_sha256 performs an HMAC-SHA-256 KAT.
int boringssl_self_test_hmac_sha256(void);
int boringssl_self_test_hmac_sha256();
// boringssl_self_test_mlkem performs the ML-KEM KATs.
OPENSSL_EXPORT int boringssl_self_test_mlkem(void);
OPENSSL_EXPORT int boringssl_self_test_mlkem();
// boringssl_self_test_mldsa performs the ML-DSA KATs.
OPENSSL_EXPORT int boringssl_self_test_mldsa(void);
OPENSSL_EXPORT int boringssl_self_test_mldsa();
// boringssl_self_test_slhdsa performs the SLH-DSA KATs.
OPENSSL_EXPORT int boringssl_self_test_slhdsa(void);
OPENSSL_EXPORT int boringssl_self_test_slhdsa();
#if defined(BORINGSSL_FIPS_COUNTERS)
void boringssl_fips_inc_counter(enum fips_counter_t counter);
@@ -1148,14 +1148,14 @@ void OPENSSL_adjust_ia32cap(uint32_t cap[4], const char *env);
// See Intel manual, volume 2A, table 3-11.
inline int CRYPTO_is_intel_cpu(void) {
inline int CRYPTO_is_intel_cpu() {
// The reserved bit 30 is used to indicate an Intel CPU.
return (OPENSSL_get_ia32cap(0) & (1u << 30)) != 0;
}
// See Intel manual, volume 2A, table 3-10.
inline int CRYPTO_is_PCLMUL_capable(void) {
inline int CRYPTO_is_PCLMUL_capable() {
#if defined(__PCLMUL__)
return 1;
#else
@@ -1163,7 +1163,7 @@ inline int CRYPTO_is_PCLMUL_capable(void) {
#endif
}
inline int CRYPTO_is_SSSE3_capable(void) {
inline int CRYPTO_is_SSSE3_capable() {
#if defined(__SSSE3__)
return 1;
#else
@@ -1171,7 +1171,7 @@ inline int CRYPTO_is_SSSE3_capable(void) {
#endif
}
inline int CRYPTO_is_SSE4_1_capable(void) {
inline int CRYPTO_is_SSE4_1_capable() {
#if defined(__SSE4_1__)
return 1;
#else
@@ -1179,7 +1179,7 @@ inline int CRYPTO_is_SSE4_1_capable(void) {
#endif
}
inline int CRYPTO_is_MOVBE_capable(void) {
inline int CRYPTO_is_MOVBE_capable() {
#if defined(__MOVBE__)
return 1;
#else
@@ -1187,7 +1187,7 @@ inline int CRYPTO_is_MOVBE_capable(void) {
#endif
}
inline int CRYPTO_is_AESNI_capable(void) {
inline int CRYPTO_is_AESNI_capable() {
#if defined(__AES__)
return 1;
#else
@@ -1198,7 +1198,7 @@ inline int CRYPTO_is_AESNI_capable(void) {
// We intentionally avoid defining a |CRYPTO_is_XSAVE_capable| function. See
// |CRYPTO_cpu_perf_is_like_silvermont|.
inline int CRYPTO_is_AVX_capable(void) {
inline int CRYPTO_is_AVX_capable() {
#if defined(__AVX__)
return 1;
#else
@@ -1206,7 +1206,7 @@ inline int CRYPTO_is_AVX_capable(void) {
#endif
}
inline int CRYPTO_is_RDRAND_capable(void) {
inline int CRYPTO_is_RDRAND_capable() {
// We intentionally do not check |__RDRND__| here. On some AMD processors, we
// will act as if the hardware is RDRAND-incapable, even it actually supports
// it. See cpu_intel.c.
@@ -1215,7 +1215,7 @@ inline int CRYPTO_is_RDRAND_capable(void) {
// See Intel manual, volume 2A, table 3-8.
inline int CRYPTO_is_BMI1_capable(void) {
inline int CRYPTO_is_BMI1_capable() {
#if defined(__BMI__)
return 1;
#else
@@ -1223,7 +1223,7 @@ inline int CRYPTO_is_BMI1_capable(void) {
#endif
}
inline int CRYPTO_is_AVX2_capable(void) {
inline int CRYPTO_is_AVX2_capable() {
#if defined(__AVX2__)
return 1;
#else
@@ -1231,7 +1231,7 @@ inline int CRYPTO_is_AVX2_capable(void) {
#endif
}
inline int CRYPTO_is_BMI2_capable(void) {
inline int CRYPTO_is_BMI2_capable() {
#if defined(__BMI2__)
return 1;
#else
@@ -1239,7 +1239,7 @@ inline int CRYPTO_is_BMI2_capable(void) {
#endif
}
inline int CRYPTO_is_ADX_capable(void) {
inline int CRYPTO_is_ADX_capable() {
#if defined(__ADX__)
return 1;
#else
@@ -1248,7 +1248,7 @@ inline int CRYPTO_is_ADX_capable(void) {
}
// SHA-1 and SHA-256 are defined as a single extension.
inline int CRYPTO_is_x86_SHA_capable(void) {
inline int CRYPTO_is_x86_SHA_capable() {
#if defined(__SHA__)
return 1;
#else
@@ -1266,7 +1266,7 @@ inline int CRYPTO_is_x86_SHA_capable(void) {
// isn't matched by this. Various sources indicate AMD first implemented MOVBE
// and XSAVE at the same time in Jaguar, so it seems like AMD chips will not be
// matched by this. That seems to be the case for other x86(-64) CPUs.
inline int CRYPTO_cpu_perf_is_like_silvermont(void) {
inline int CRYPTO_cpu_perf_is_like_silvermont() {
// WARNING: This MUST NOT be used to guard the execution of the XSAVE
// instruction. This is the "hardware supports XSAVE" bit, not the OSXSAVE bit
// that indicates whether we can safely execute XSAVE. This bit may be set
@@ -1280,7 +1280,7 @@ inline int CRYPTO_cpu_perf_is_like_silvermont(void) {
return !hardware_supports_xsave && CRYPTO_is_MOVBE_capable();
}
inline int CRYPTO_is_AVX512BW_capable(void) {
inline int CRYPTO_is_AVX512BW_capable() {
#if defined(__AVX512BW__)
return 1;
#else
@@ -1288,7 +1288,7 @@ inline int CRYPTO_is_AVX512BW_capable(void) {
#endif
}
inline int CRYPTO_is_AVX512VL_capable(void) {
inline int CRYPTO_is_AVX512VL_capable() {
#if defined(__AVX512VL__)
return 1;
#else
@@ -1300,11 +1300,11 @@ inline int CRYPTO_is_AVX512VL_capable(void) {
// should not be used even if the CPU supports them.
//
// Note that this reuses the bit for the removed MPX feature.
inline int CRYPTO_cpu_avoid_zmm_registers(void) {
inline int CRYPTO_cpu_avoid_zmm_registers() {
return (OPENSSL_get_ia32cap(2) & (1u << 14)) != 0;
}
inline int CRYPTO_is_VAES_capable(void) {
inline int CRYPTO_is_VAES_capable() {
#if defined(__VAES__)
return 1;
#else
@@ -1312,7 +1312,7 @@ inline int CRYPTO_is_VAES_capable(void) {
#endif
}
inline int CRYPTO_is_VPCLMULQDQ_capable(void) {
inline int CRYPTO_is_VPCLMULQDQ_capable() {
#if defined(__VPCLMULQDQ__)
return 1;
#else
@@ -1344,7 +1344,7 @@ inline int CRYPTO_is_VPCLMULQDQ_capable(void) {
#if defined(OPENSSL_STATIC_ARMCAP)
// We assume |CRYPTO_is_*_capable| already checked static capabilities.
inline uint32_t OPENSSL_get_armcap(void) { return 0; }
inline uint32_t OPENSSL_get_armcap() { return 0; }
#else
// OPENSSL_armcap_P contains ARM CPU capabilities as a bitmask of the above
// constants. This should only be accessed with |OPENSSL_get_armcap|.
@@ -1353,7 +1353,7 @@ extern uint32_t OPENSSL_armcap_P;
// OPENSSL_get_armcap initializes the library if needed and returns ARM CPU
// capabilities. It is marked as a const function so duplicate calls can be
// merged by the compiler.
OPENSSL_ATTR_CONST uint32_t OPENSSL_get_armcap(void);
OPENSSL_ATTR_CONST uint32_t OPENSSL_get_armcap();
#endif // OPENSSL_STATIC_ARMCAP
// Normalize some older feature flags to their modern ACLE values.
@@ -1372,7 +1372,7 @@ OPENSSL_ATTR_CONST uint32_t OPENSSL_get_armcap(void);
// CRYPTO_is_NEON_capable returns true if the current CPU has a NEON unit. If
// this is known statically, it is a constant inline function.
inline int CRYPTO_is_NEON_capable(void) {
inline int CRYPTO_is_NEON_capable() {
#if (defined(OPENSSL_STATIC_ARMCAP_NEON) || defined(__ARM_NEON)) && \
!defined(OPENSSL_NO_STATIC_NEON_FOR_TESTING)
return 1;
@@ -1381,7 +1381,7 @@ inline int CRYPTO_is_NEON_capable(void) {
#endif
}
inline int CRYPTO_is_ARMv8_AES_capable(void) {
inline int CRYPTO_is_ARMv8_AES_capable() {
#if defined(OPENSSL_STATIC_ARMCAP_AES) || defined(__ARM_FEATURE_AES)
return 1;
#else
@@ -1389,7 +1389,7 @@ inline int CRYPTO_is_ARMv8_AES_capable(void) {
#endif
}
inline int CRYPTO_is_ARMv8_PMULL_capable(void) {
inline int CRYPTO_is_ARMv8_PMULL_capable() {
#if defined(OPENSSL_STATIC_ARMCAP_PMULL) || defined(__ARM_FEATURE_AES)
return 1;
#else
@@ -1397,7 +1397,7 @@ inline int CRYPTO_is_ARMv8_PMULL_capable(void) {
#endif
}
inline int CRYPTO_is_ARMv8_SHA1_capable(void) {
inline int CRYPTO_is_ARMv8_SHA1_capable() {
// SHA-1 and SHA-2 (only) share |__ARM_FEATURE_SHA2| but otherwise
// are dealt with independently.
#if defined(OPENSSL_STATIC_ARMCAP_SHA1) || defined(__ARM_FEATURE_SHA2)
@@ -1407,7 +1407,7 @@ inline int CRYPTO_is_ARMv8_SHA1_capable(void) {
#endif
}
inline int CRYPTO_is_ARMv8_SHA256_capable(void) {
inline int CRYPTO_is_ARMv8_SHA256_capable() {
// SHA-1 and SHA-2 (only) share |__ARM_FEATURE_SHA2| but otherwise
// are dealt with independently.
#if defined(OPENSSL_STATIC_ARMCAP_SHA256) || defined(__ARM_FEATURE_SHA2)
@@ -1417,7 +1417,7 @@ inline int CRYPTO_is_ARMv8_SHA256_capable(void) {
#endif
}
inline int CRYPTO_is_ARMv8_SHA512_capable(void) {
inline int CRYPTO_is_ARMv8_SHA512_capable() {
// There is no |OPENSSL_STATIC_ARMCAP_SHA512|.
#if defined(__ARM_FEATURE_SHA512)
return 1;
@@ -1461,9 +1461,9 @@ OPENSSL_EXPORT int OPENSSL_vasprintf_internal(char **str, const char *format,
// CRYPTO_fuzzer_mode_enabled returns whether fuzzer mode is enabled. See
// |CRYPTO_set_fuzzer_mode|. In non-fuzzer builds, this function statically
// returns zero so the codepaths will be deleted by the optimizer.
int CRYPTO_fuzzer_mode_enabled(void);
int CRYPTO_fuzzer_mode_enabled();
#else
inline int CRYPTO_fuzzer_mode_enabled(void) { return 0; }
inline int CRYPTO_fuzzer_mode_enabled() { return 0; }
#endif
crypto/lhash/lhash_test.cc
+1 -1
View File
@@ -34,7 +34,7 @@ namespace {
DEFINE_LHASH_OF(char)
static std::unique_ptr<char[]> RandString(void) {
static std::unique_ptr<char[]> RandString() {
unsigned len = 1 + (rand() % 3);
auto ret = std::make_unique<char[]>(len + 1);
crypto/mem.cc
+8 -8
View File
@@ -109,7 +109,7 @@ static uint64_t malloc_number_to_fail = 0;
static int malloc_failure_enabled = 0, break_on_malloc_fail = 0,
any_malloc_failed = 0, disable_malloc_failures = 0;
static void malloc_exit_handler(void) {
static void malloc_exit_handler() {
CRYPTO_MUTEX_lock_read(&malloc_failure_lock);
if (any_malloc_failed) {
// Signal to the test driver that some allocation failed, so it knows to
@@ -119,7 +119,7 @@ static void malloc_exit_handler(void) {
CRYPTO_MUTEX_unlock_read(&malloc_failure_lock);
}
static void init_malloc_failure(void) {
static void init_malloc_failure() {
const char *env = getenv("MALLOC_NUMBER_TO_FAIL");
if (env != nullptr && env[0] != 0) {
char *endptr;
@@ -158,20 +158,20 @@ static int should_fail_allocation() {
return should_fail;
}
void OPENSSL_reset_malloc_counter_for_testing(void) {
void OPENSSL_reset_malloc_counter_for_testing() {
CRYPTO_MUTEX_lock_write(&malloc_failure_lock);
current_malloc_count = 0;
CRYPTO_MUTEX_unlock_write(&malloc_failure_lock);
}
void OPENSSL_disable_malloc_failures_for_testing(void) {
void OPENSSL_disable_malloc_failures_for_testing() {
CRYPTO_MUTEX_lock_write(&malloc_failure_lock);
BSSL_CHECK(!disable_malloc_failures);
disable_malloc_failures = 1;
CRYPTO_MUTEX_unlock_write(&malloc_failure_lock);
}
void OPENSSL_enable_malloc_failures_for_testing(void) {
void OPENSSL_enable_malloc_failures_for_testing() {
CRYPTO_MUTEX_lock_write(&malloc_failure_lock);
BSSL_CHECK(disable_malloc_failures);
disable_malloc_failures = 0;
@@ -179,7 +179,7 @@ void OPENSSL_enable_malloc_failures_for_testing(void) {
}
#else
static int should_fail_allocation(void) { return 0; }
static int should_fail_allocation() { return 0; }
#endif
void *OPENSSL_malloc(size_t size) {
@@ -314,9 +314,9 @@ void OPENSSL_clear_free(void *ptr, size_t unused) { OPENSSL_free(ptr); }
int CRYPTO_secure_malloc_init(size_t size, size_t min_size) { return 0; }
int CRYPTO_secure_malloc_initialized(void) { return 0; }
int CRYPTO_secure_malloc_initialized() { return 0; }
size_t CRYPTO_secure_used(void) { return 0; }
size_t CRYPTO_secure_used() { return 0; }
void *OPENSSL_secure_malloc(size_t size) { return OPENSSL_malloc(size); }
crypto/obj/obj.cc
+4 -4
View File
@@ -45,7 +45,7 @@ static LHASH_OF(ASN1_OBJECT) *global_added_by_long_name = nullptr;
static CRYPTO_MUTEX global_next_nid_lock = CRYPTO_MUTEX_INIT;
static unsigned global_next_nid = NUM_NID;
static int obj_next_nid(void) {
static int obj_next_nid() {
CRYPTO_MUTEX_lock_write(&global_next_nid_lock);
int ret = global_next_nid++;
CRYPTO_MUTEX_unlock_write(&global_next_nid_lock);
@@ -281,7 +281,7 @@ OPENSSL_EXPORT int OBJ_nid2cbb(CBB *out, int nid) {
CBB_add_asn1_element(out, CBS_ASN1_OBJECT, obj->data, obj->length);
}
const ASN1_OBJECT *OBJ_get_undef(void) {
const ASN1_OBJECT *OBJ_get_undef() {
static const ASN1_OBJECT kUndef = {
/*sn=*/SN_undef,
/*ln=*/LN_undef,
@@ -342,7 +342,7 @@ const char *OBJ_nid2ln(int nid) {
return obj->ln;
}
static ASN1_OBJECT *create_object_with_text_oid(int (*get_nid)(void),
static ASN1_OBJECT *create_object_with_text_oid(int (*get_nid)(),
const char *oid,
const char *short_name,
const char *long_name) {
@@ -509,4 +509,4 @@ int OBJ_create(const char *oid, const char *short_name, const char *long_name) {
return op->nid;
}
void OBJ_cleanup(void) {}
void OBJ_cleanup() {}
crypto/pem/pem_info.cc
+2 -2
View File
@@ -30,7 +30,7 @@
#include "internal.h"
static X509_PKEY *X509_PKEY_new(void) {
static X509_PKEY *X509_PKEY_new() {
return reinterpret_cast<X509_PKEY *>(OPENSSL_zalloc(sizeof(X509_PKEY)));
}
@@ -43,7 +43,7 @@ static void X509_PKEY_free(X509_PKEY *x) {
OPENSSL_free(x);
}
static X509_INFO *X509_INFO_new(void) {
static X509_INFO *X509_INFO_new() {
return reinterpret_cast<X509_INFO *>(OPENSSL_zalloc(sizeof(X509_INFO)));
}
crypto/pkcs8/internal.h
+2 -2
View File
@@ -63,8 +63,8 @@ struct pbe_suite {
int pbe_nid;
uint8_t oid[10];
uint8_t oid_len;
const EVP_CIPHER *(*cipher_func)(void);
const EVP_MD *(*md_func)(void);
const EVP_CIPHER *(*cipher_func)();
const EVP_MD *(*md_func)();
// decrypt_init initialize |ctx| for decrypting. The password is specified by
// |pass| and |pass_len|. |param| contains the serialized parameters field of
// the AlgorithmIdentifier.
crypto/pkcs8/p5_pbev2.cc
+1 -1
View File
@@ -49,7 +49,7 @@ static const struct {
uint8_t oid[9];
uint8_t oid_len;
int nid;
const EVP_CIPHER *(*cipher_func)(void);
const EVP_CIPHER *(*cipher_func)();
} kCipherOIDs[] = {
// 1.2.840.113549.3.2
{{0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x03, 0x02},
crypto/pkcs8/pkcs8_x509.cc
+1 -1
View File
@@ -688,7 +688,7 @@ err:
return ret;
}
void PKCS12_PBE_add(void) {}
void PKCS12_PBE_add() {}
struct pkcs12_st {
uint8_t *ber_bytes;

Some files were not shown because too many files have changed in this diff Show More