grpc 1.84.1 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/include/openssl/cmac.h

@@ -30,8 +30,8 @@ extern "C" {
 
 // One-shot functions.
 
-// AES_CMAC calculates the 16-byte, CMAC authenticator of |in_len| bytes of
-// |in| and writes it to |out|. The |key_len| may be 16 or 32 bytes to select
+// AES_CMAC calculates the 16-byte, CMAC authenticator of `in_len` bytes of
+// `in` and writes it to `out`. The `key_len` may be 16 or 32 bytes to select
 // between AES-128 and AES-256. It returns one on success or zero on error.
 OPENSSL_EXPORT int AES_CMAC(uint8_t out[16], const uint8_t *key, size_t key_len,
                             const uint8_t *in, size_t in_len);
@@ -39,36 +39,36 @@ OPENSSL_EXPORT int AES_CMAC(uint8_t out[16], const uint8_t *key, size_t key_len,
 
 // Incremental interface.
 
-// CMAC_CTX_new allocates a fresh |CMAC_CTX| and returns it, or NULL on
+// CMAC_CTX_new allocates a fresh `CMAC_CTX` and returns it, or NULL on
 // error.
 OPENSSL_EXPORT CMAC_CTX *CMAC_CTX_new(void);
 
-// CMAC_CTX_free frees a |CMAC_CTX|.
+// CMAC_CTX_free frees a `CMAC_CTX`.
 OPENSSL_EXPORT void CMAC_CTX_free(CMAC_CTX *ctx);
 
-// CMAC_CTX_copy sets |out| to be a duplicate of the current state |in|. It
+// CMAC_CTX_copy sets `out` to be a duplicate of the current state `in`. It
 // returns one on success and zero on error.
 OPENSSL_EXPORT int CMAC_CTX_copy(CMAC_CTX *out, const CMAC_CTX *in);
 
-// CMAC_Init configures |ctx| to use the given |key| and |cipher|. The CMAC RFC
-// only specifies the use of AES-128 thus |key_len| should be 16 and |cipher|
-// should be |EVP_aes_128_cbc()|. However, this implementation also supports
-// AES-256 by setting |key_len| to 32 and |cipher| to |EVP_aes_256_cbc()|. The
-// |engine| argument is ignored.
+// CMAC_Init configures `ctx` to use the given `key` and `cipher`. The CMAC RFC
+// only specifies the use of AES-128 thus `key_len` should be 16 and `cipher`
+// should be `EVP_aes_128_cbc()`. However, this implementation also supports
+// AES-256 by setting `key_len` to 32 and `cipher` to `EVP_aes_256_cbc()`. The
+// `engine` argument is ignored.
 //
 // It returns one on success or zero on error.
 OPENSSL_EXPORT int CMAC_Init(CMAC_CTX *ctx, const void *key, size_t key_len,
                              const EVP_CIPHER *cipher, ENGINE *engine);
 
 
-// CMAC_Reset resets |ctx| so that a fresh message can be authenticated.
+// CMAC_Reset resets `ctx` so that a fresh message can be authenticated.
 OPENSSL_EXPORT int CMAC_Reset(CMAC_CTX *ctx);
 
-// CMAC_Update processes |in_len| bytes of message from |in|. It returns one on
+// CMAC_Update processes `in_len` bytes of message from `in`. It returns one on
 // success or zero on error.
 OPENSSL_EXPORT int CMAC_Update(CMAC_CTX *ctx, const uint8_t *in, size_t in_len);
 
-// CMAC_Final sets |*out_len| to 16 and, if |out| is not NULL, writes 16 bytes
+// CMAC_Final sets `*out_len` to 16 and, if `out` is not NULL, writes 16 bytes
 // of authenticator to it. It returns one on success or zero on error.
 OPENSSL_EXPORT int CMAC_Final(CMAC_CTX *ctx, uint8_t *out, size_t *out_len);
 

data/third_party/boringssl-with-bazel/include/openssl/cms.h

@@ -31,15 +31,16 @@ extern "C" {
 // for S/MIME, is out of scope for BoringSSL.
 //
 // As this library is intentionally not a general CMS implementation, BoringSSL
-// continues to define |OPENSSL_NO_CMS|, so that most callers turn off their
+// continues to define `OPENSSL_NO_CMS`, so that most callers turn off their
 // general-purpose CMS code. In callers that are compatible with this subset,
-// the |BORINGSSL_NO_NO_CMS| build option can be used to suppress
-// |OPENSSL_NO_CMS|.
+// the `BORINGSSL_NO_NO_CMS` build option can be used to suppress
+// `OPENSSL_NO_CMS`.
+
 
 DECLARE_STACK_OF(X509)
 
 // CMS_* are flags that can be passed to functions in this library. Their
-// interpretation is specified in the corresponding functinos.
+// interpretation is specified in the corresponding functions.
 #define CMS_NOCERTS 0x2
 #define CMS_DETACHED 0x40
 #define CMS_BINARY 0x80
@@ -50,79 +51,79 @@ DECLARE_STACK_OF(X509)
 #define CMS_USE_KEYID 0x10000
 #define CMS_NO_SIGNING_TIME 0x400000
 
-// CMS_sign returns a newly-allocated |CMS_ContentInfo| structure for building a
+// CMS_sign returns a newly-allocated `CMS_ContentInfo` structure for building a
 // SignedData (RFC 5652), or NULL on error.
 //
-// |certs| must be NULL or zero length. BoringSSL does not support embedding
+// `certs` must be NULL or zero length. BoringSSL does not support embedding
 // certificates in SignedData.
 //
-// |flags| must contain |CMS_DETACHED|, which indicates an external signature.
+// `flags` must contain `CMS_DETACHED`, which indicates an external signature.
 // BoringSSL only supports generating external signatures and does not support
 // embedding encapsulated content directly in a SignedData.
 //
-// If |pkey| is non-NULL, |CMS_add1_signer| is automatically called with
-// |signcert|, |pkey|, a default hash of SHA-256, and |flags|. |flags| will then
-// additionally be interpreted as in |CMS_add1_signer|.
+// If `pkey` is non-NULL, `CMS_add1_signer` is automatically called with
+// `signcert`, `pkey`, a default hash of SHA-256, and `flags`. `flags` will then
+// additionally be interpreted as in `CMS_add1_signer`.
 //
-// If |CMS_PARTIAL| or |CMS_STREAM| is set in |flags|, the object will be left
-// incomplete. |data| will then be ignored and should be NULL. The caller can
-// then continue configuring it and finalizing it with |CMS_final|. Otherwise,
-// the object will be finalized with |data| and |flags| passed to |CMS_final|.
+// If `CMS_PARTIAL` or `CMS_STREAM` is set in `flags`, the object will be left
+// incomplete. `data` will then be ignored and should be NULL. The caller can
+// then continue configuring it and finalizing it with `CMS_final`. Otherwise,
+// the object will be finalized with `data` and `flags` passed to `CMS_final`.
 OPENSSL_EXPORT CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey,
                                          STACK_OF(X509) *certs, BIO *data,
                                          uint32_t flags);
 
-// CMS_ContentInfo_free releases memory associated with |cms|.
+// CMS_ContentInfo_free releases memory associated with `cms`.
 OPENSSL_EXPORT void CMS_ContentInfo_free(CMS_ContentInfo *cms);
 
-// CMS_add1_signer adds a signer to |cms|, which must be a SignedData created by
-// |CMS_sign|, with the |CMS_PARTIAL| flag set. The signer will use |signcert|,
-// |pkey|, and |md| for the signing certificate, private key, and digest
+// CMS_add1_signer adds a signer to `cms`, which must be a SignedData created by
+// `CMS_sign`, with the `CMS_PARTIAL` flag set. The signer will use `signcert`,
+// `pkey`, and `md` for the signing certificate, private key, and digest
 // algorithm, respectively. It returns a non-NULL pointer to the signer on
-// success, and NULL on error. The signer is owned by |cms| and should not be
+// success, and NULL on error. The signer is owned by `cms` and should not be
 // released by the caller.
 //
-// |flags| is interpreted as follows:
+// `flags` is interpreted as follows:
 //
-// - |CMS_PARTIAL| must not be set. BoringSSL does not support configuring a
+// - `CMS_PARTIAL` must not be set. BoringSSL does not support configuring a
 //   signer in multiple steps.
 //
-// - |CMS_NOCERTS| must be set. BoringSSL does not support embedding
+// - `CMS_NOCERTS` must be set. BoringSSL does not support embedding
 //   certificates in SignedData.
 //
-// - |CMS_NOATTR| must be set. BoringSSL does not support attributes in
+// - `CMS_NOATTR` must be set. BoringSSL does not support attributes in
 //   SignedData.
 //
-// - If |CMS_USE_KEYID| is set, SignerInfos will be identified by subject key
-//   identifier instead of issuer and serial number. |signcert| must then have
+// - If `CMS_USE_KEYID` is set, SignerInfos will be identified by subject key
+//   identifier instead of issuer and serial number. `signcert` must then have
 //   the subject key identifier extension.
 //
-// BoringSSL currently only supports one signer per |CMS_ContentInfo|.
+// BoringSSL currently only supports one signer per `CMS_ContentInfo`.
 // Subsequent calls will fail. Additionally, only RSA keys are currently
-// supported for |pkey|.
+// supported for `pkey`.
 OPENSSL_EXPORT CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms,
                                                X509 *signcert, EVP_PKEY *pkey,
                                                const EVP_MD *md,
                                                uint32_t flags);
 
-// CMS_final finalizes constructing |cms|, which must have been initialized with
-// the |CMS_PARTIAL| flag. |data| is read, until EOF, as the data to be
+// CMS_final finalizes constructing `cms`, which must have been initialized with
+// the `CMS_PARTIAL` flag. `data` is read, until EOF, as the data to be
 // processed by CMS. It returns one on success and zero on error.
 //
-// |CMS_BINARY| must be set in |flags|. BoringSSL does not support translating
+// `CMS_BINARY` must be set in `flags`. BoringSSL does not support translating
 // inputs according to S/MIME.
 //
-// |dcont| must be NULL. What a non-NULL |dcont| does is not clearly documented
+// `dcont` must be NULL. What a non-NULL `dcont` does is not clearly documented
 // by OpenSSL, and there are no tests to demonstrate its behavior.
 OPENSSL_EXPORT int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont,
                              uint32_t flags);
 
-// i2d_CMS_bio encodes |cms| as a DER-encoded ContentInfo structure (RFC 5652).
+// i2d_CMS_bio encodes `cms` as a DER-encoded ContentInfo structure (RFC 5652).
 // It returns one on success and zero on failure.
 OPENSSL_EXPORT int i2d_CMS_bio(BIO *out, CMS_ContentInfo *cms);
 
-// i2d_CMS_bio_stream calls |i2d_CMS_bio|. |in| must be NULL and |flags| must
-// not contain |CMS_STREAM|. BoringSSL does not support any streaming modes for
+// i2d_CMS_bio_stream calls `i2d_CMS_bio`. `in` must be NULL and `flags` must
+// not contain `CMS_STREAM`. BoringSSL does not support any streaming modes for
 // CMS.
 OPENSSL_EXPORT int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in,
                                       int flags);

data/third_party/boringssl-with-bazel/include/openssl/conf.h

@@ -18,7 +18,6 @@
 #include <openssl/base.h>   // IWYU pragma: export
 
 #include <openssl/stack.h>
-#include <openssl/lhash.h>
 
 #if defined(__cplusplus)
 extern "C" {
@@ -37,7 +36,7 @@ extern "C" {
 //   [section_name]
 //   key2=value2
 //
-// Config files are represented by a |CONF|. Use of this module is strongly
+// Config files are represented by a `CONF`. Use of this module is strongly
 // discouraged. It is a remnant of the OpenSSL command-line tool. Parsing an
 // untrusted input as a config file risks string injection and denial of service
 // vulnerabilities.
@@ -50,35 +49,34 @@ struct conf_value_st {
 };
 
 DEFINE_STACK_OF(CONF_VALUE)
-DECLARE_LHASH_OF(CONF_VALUE)
 
 
-// NCONF_new returns a fresh, empty |CONF|, or NULL on error. The |method|
+// NCONF_new returns a fresh, empty `CONF`, or NULL on error. The `method`
 // argument must be NULL.
 OPENSSL_EXPORT CONF *NCONF_new(void *method);
 
-// NCONF_free frees all the data owned by |conf| and then |conf| itself.
+// NCONF_free frees all the data owned by `conf` and then `conf` itself.
 OPENSSL_EXPORT void NCONF_free(CONF *conf);
 
-// NCONF_load parses the file named |filename| and adds the values found to
-// |conf|. It returns one on success and zero on error. In the event of an
-// error, if |out_error_line| is not NULL, |*out_error_line| is set to the
+// NCONF_load parses the file named `filename` and adds the values found to
+// `conf`. It returns one on success and zero on error. In the event of an
+// error, if `out_error_line` is not NULL, `*out_error_line` is set to the
 // number of the line that contained the error.
 OPENSSL_EXPORT int NCONF_load(CONF *conf, const char *filename,
                               long *out_error_line);
 
-// NCONF_load_bio acts like |NCONF_load| but reads from |bio| rather than from
+// NCONF_load_bio acts like `NCONF_load` but reads from `bio` rather than from
 // a named file.
 OPENSSL_EXPORT int NCONF_load_bio(CONF *conf, BIO *bio, long *out_error_line);
 
-// NCONF_get_section returns a stack of values for a given section in |conf|.
-// If |section| is NULL, the default section is returned. It returns NULL on
+// NCONF_get_section returns a stack of values for a given section in `conf`.
+// If `section` is NULL, the default section is returned. It returns NULL on
 // error.
 OPENSSL_EXPORT const STACK_OF(CONF_VALUE) *NCONF_get_section(
     const CONF *conf, const char *section);
 
-// NCONF_get_string returns the value of the key |name|, in section |section|.
-// The |section| argument may be NULL to indicate the default section. It
+// NCONF_get_string returns the value of the key `name`, in section `section`.
+// The `section` argument may be NULL to indicate the default section. It
 // returns the value or NULL on error.
 OPENSSL_EXPORT const char *NCONF_get_string(const CONF *conf,
                                             const char *section,
@@ -93,11 +91,14 @@ OPENSSL_EXPORT const char *NCONF_get_string(const CONF *conf,
 #define CONF_MFLAGS_IGNORE_MISSING_FILE 0
 
 // CONF_modules_load_file returns one. BoringSSL is defined to have no config
-// file options, thus loading from |filename| always succeeds by doing nothing.
+// file options, thus loading from `filename` always succeeds by doing nothing.
 OPENSSL_EXPORT int CONF_modules_load_file(const char *filename,
                                           const char *appname,
                                           unsigned long flags);
 
+// CONF_modules_unload does nothing.
+OPENSSL_EXPORT void CONF_modules_unload(int all);
+
 // CONF_modules_free does nothing.
 OPENSSL_EXPORT void CONF_modules_free(void);
 

data/third_party/boringssl-with-bazel/include/openssl/crypto.h

@@ -15,14 +15,14 @@
 #ifndef OPENSSL_HEADER_CRYPTO_H
 #define OPENSSL_HEADER_CRYPTO_H
 
-#include <openssl/base.h>   // IWYU pragma: export
+#include <openssl/base.h>  // IWYU pragma: export
 #include <openssl/sha.h>
 
-// Upstream OpenSSL defines |OPENSSL_malloc|, etc., in crypto.h rather than
+// Upstream OpenSSL defines `OPENSSL_malloc`, etc., in crypto.h rather than
 // mem.h.
 #include <openssl/mem.h>
 
-// Upstream OpenSSL defines |CRYPTO_LOCK|, etc., in crypto.h rather than
+// Upstream OpenSSL defines `CRYPTO_LOCK`, etc., in crypto.h rather than
 // thread.h.
 #include <openssl/thread.h>
 
@@ -100,7 +100,7 @@ OPENSSL_EXPORT int FIPS_mode(void);
 
 // fips_counter_t denotes specific APIs/algorithms. A counter is maintained for
 // each in FIPS mode so that tests can be written to assert that the expected,
-// FIPS functions are being called by a certain peice of code.
+// FIPS functions are being called by a certain piece of code.
 enum fips_counter_t {
   fips_counter_evp_aes_128_gcm = 0,
   fips_counter_evp_aes_256_gcm = 1,
@@ -111,7 +111,7 @@ enum fips_counter_t {
 };
 
 // FIPS_read_counter returns a counter of the number of times the specific
-// function denoted by |counter| has been used. This always returns zero unless
+// function denoted by `counter` has been used. This always returns zero unless
 // BoringSSL was built with BORINGSSL_FIPS_COUNTERS defined.
 OPENSSL_EXPORT size_t FIPS_read_counter(enum fips_counter_t counter);
 
@@ -129,7 +129,7 @@ OPENSSL_EXPORT size_t FIPS_read_counter(enum fips_counter_t counter);
 #define OPENSSL_DIR 4
 
 // OpenSSL_version is a compatibility function that returns the string
-// "BoringSSL" if |which| is |OPENSSL_VERSION| and placeholder strings
+// "BoringSSL" if `which` is `OPENSSL_VERSION` and placeholder strings
 // otherwise.
 OPENSSL_EXPORT const char *OpenSSL_version(int which);
 
@@ -139,7 +139,7 @@ OPENSSL_EXPORT const char *OpenSSL_version(int which);
 #define SSLEAY_PLATFORM OPENSSL_PLATFORM
 #define SSLEAY_DIR OPENSSL_DIR
 
-// SSLeay_version calls |OpenSSL_version|.
+// SSLeay_version calls `OpenSSL_version`.
 OPENSSL_EXPORT const char *SSLeay_version(int which);
 
 // SSLeay is a compatibility function that returns OPENSSL_VERSION_NUMBER from
@@ -162,6 +162,9 @@ OPENSSL_EXPORT void ENGINE_load_builtin_engines(void);
 // ENGINE_register_all_complete returns one.
 OPENSSL_EXPORT int ENGINE_register_all_complete(void);
 
+// ENGINE_cleanup does nothing.
+OPENSSL_EXPORT void ENGINE_cleanup(void);
+
 // OPENSSL_load_builtin_modules does nothing.
 OPENSSL_EXPORT void OPENSSL_load_builtin_modules(void);
 
@@ -193,8 +196,8 @@ OPENSSL_EXPORT int OPENSSL_init_crypto(uint64_t opts,
 // OPENSSL_cleanup does nothing.
 OPENSSL_EXPORT void OPENSSL_cleanup(void);
 
-// FIPS_mode_set returns one if |on| matches whether BoringSSL was built with
-// |BORINGSSL_FIPS| and zero otherwise.
+// FIPS_mode_set returns one if `on` matches whether BoringSSL was built with
+// `BORINGSSL_FIPS` and zero otherwise.
 OPENSSL_EXPORT int FIPS_mode_set(int on);
 
 // FIPS_module_name returns the name of the FIPS module.
@@ -205,13 +208,12 @@ OPENSSL_EXPORT const uint8_t *FIPS_module_hash(void);
 
 // FIPS_version returns the version of the FIPS module, or zero if the build
 // isn't exactly at a verified version. The version, expressed in base 10, will
-// be a date in the form yyyymmddXX where XX is often "00", but can be
-// incremented if multiple versions are defined on a single day.
+// be a date in the form yyyymmdd.
 //
-// (This format exceeds a |uint32_t| in the year 4294.)
+// (This format exceeds a `uint32_t` in the year 4294.)
 OPENSSL_EXPORT uint32_t FIPS_version(void);
 
-// FIPS_query_algorithm_status returns one if |algorithm| is FIPS validated in
+// FIPS_query_algorithm_status returns one if `algorithm` is FIPS validated in
 // the current BoringSSL and zero otherwise.
 OPENSSL_EXPORT int FIPS_query_algorithm_status(const char *algorithm);
 

data/third_party/boringssl-with-bazel/include/openssl/ctrdrbg.h

@@ -15,7 +15,7 @@
 #ifndef OPENSSL_HEADER_CTRDRBG_H
 #define OPENSSL_HEADER_CTRDRBG_H
 
-#include <openssl/base.h>   // IWYU pragma: export
+#include <openssl/base.h>  // IWYU pragma: export
 
 #if defined(__cplusplus)
 extern "C" {
@@ -29,43 +29,77 @@ extern "C" {
 //
 // CTR_DRBG_STATE contains the state of a FIPS AES-CTR-based pseudo-random
 // number generator. If BoringSSL was built in FIPS mode then this is a FIPS
-// Approved algorithm.
+// Approved algorithm. BoringSSL supports CTR-DRBG both with, and without, a
+// derivation function.
 
-// CTR_DRBG_ENTROPY_LEN is the number of bytes of input entropy. See SP
-// 800-90Ar1, table 3.
+// CTR_DRBG_MIN_ENTROPY_LEN is the minimum number of bytes of input entropy
+// when using a derivation function. See SP 800-90Ar1, table 3.
+#define CTR_DRBG_MIN_ENTROPY_LEN 32
+
+// CTR_DRBG_MAX_ENTROPY_LEN is the maximum number of bytes of input entropy
+// when using a derivation function. This is an implementation limitation.
+#define CTR_DRBG_MAX_ENTROPY_LEN 64
+
+// CTR_DRBG_ENTROPY_LEN is a fixed amount of entropy required when not using a
+// derivation function.
 #define CTR_DRBG_ENTROPY_LEN 48
 
+// The length of a seed, when using a derivation function. See SP 800-90Ar1,
+// table 3.
+#define CTR_DRBG_SEED_LEN (32 + CTR_DRBG_NONCE_LEN)
+
+// CTR_DRBG_NONCE_LEN is the number of bytes of input nonce. This only applies
+// when using a derivation function.
+#define CTR_DRBG_NONCE_LEN 16
+
 // CTR_DRBG_MAX_GENERATE_LENGTH is the maximum number of bytes that can be
-// generated in a single call to |CTR_DRBG_generate|.
+// generated in a single call to `CTR_DRBG_generate`.
 #define CTR_DRBG_MAX_GENERATE_LENGTH 65536
 
-// CTR_DRBG_new returns an initialized |CTR_DRBG_STATE|, or NULL if either
-// allocation failed or if |personalization_len| is invalid.
+// CTR_DRBG_new returns an initialized `CTR_DRBG_STATE`, or NULL if either
+// allocation failed or if `personalization_len` is invalid. This DRBG will not
+// use a derivation function.
 OPENSSL_EXPORT CTR_DRBG_STATE *CTR_DRBG_new(
     const uint8_t entropy[CTR_DRBG_ENTROPY_LEN], const uint8_t *personalization,
     size_t personalization_len);
 
-// CTR_DRBG_free frees |state| if non-NULL, or else does nothing.
-OPENSSL_EXPORT void CTR_DRBG_free(CTR_DRBG_STATE* state);
+// CTR_DRBG_new_df returns an initialized `CTR_DRBG_STATE`, or NULL if either
+// allocation failed or if an argument is invalid. This DRBG will use a
+// derivation function.
+OPENSSL_EXPORT CTR_DRBG_STATE *CTR_DRBG_new_df(
+    const uint8_t *entropy, size_t entropy_len,
+    const uint8_t nonce[CTR_DRBG_NONCE_LEN], const uint8_t *personalization,
+    size_t personalization_len);
+
+// CTR_DRBG_free frees `state` if non-NULL, or else does nothing.
+OPENSSL_EXPORT void CTR_DRBG_free(CTR_DRBG_STATE *state);
 
-// CTR_DRBG_reseed reseeds |drbg| given |CTR_DRBG_ENTROPY_LEN| bytes of entropy
-// in |entropy| and, optionally, up to |CTR_DRBG_ENTROPY_LEN| bytes of
+// CTR_DRBG_reseed reseeds `drbg` given `CTR_DRBG_ENTROPY_LEN` bytes of entropy
+// in `entropy` and, optionally, up to `CTR_DRBG_SEED_LEN` bytes of
 // additional data. It returns one on success or zero on error.
 OPENSSL_EXPORT int CTR_DRBG_reseed(CTR_DRBG_STATE *drbg,
                                    const uint8_t entropy[CTR_DRBG_ENTROPY_LEN],
                                    const uint8_t *additional_data,
                                    size_t additional_data_len);
 
-// CTR_DRBG_generate processes to up |CTR_DRBG_ENTROPY_LEN| bytes of additional
-// data (if any) and then writes |out_len| random bytes to |out|, where
-// |out_len| <= |CTR_DRBG_MAX_GENERATE_LENGTH|. It returns one on success or
+// CTR_DRBG_reseed_ex acts like `CTR_DRBG_reseed` but with variable-length
+// entropy input, up to `CTR_DRBG_MAX_ENTROPY_LEN`.
+OPENSSL_EXPORT int CTR_DRBG_reseed_ex(CTR_DRBG_STATE *drbg,
+                                      const uint8_t *entropy,
+                                      size_t entropy_len,
+                                      const uint8_t *additional_data,
+                                      size_t additional_data_len);
+
+// CTR_DRBG_generate processes to up `CTR_DRBG_ENTROPY_LEN` bytes of additional
+// data (if any) and then writes `out_len` random bytes to `out`, where
+// `out_len` <= `CTR_DRBG_MAX_GENERATE_LENGTH`. It returns one on success or
 // zero on error.
 OPENSSL_EXPORT int CTR_DRBG_generate(CTR_DRBG_STATE *drbg, uint8_t *out,
                                      size_t out_len,
                                      const uint8_t *additional_data,
                                      size_t additional_data_len);
 
-// CTR_DRBG_clear zeroises the state of |drbg|.
+// CTR_DRBG_clear zeroises the state of `drbg`.
 OPENSSL_EXPORT void CTR_DRBG_clear(CTR_DRBG_STATE *drbg);
 
 

data/third_party/boringssl-with-bazel/include/openssl/curve25519.h

@@ -37,12 +37,12 @@ extern "C" {
 #define X25519_PUBLIC_VALUE_LEN 32
 #define X25519_SHARED_KEY_LEN 32
 
-// X25519_keypair sets |out_public_value| and |out_private_key| to a freshly
+// X25519_keypair sets `out_public_value` and `out_private_key` to a freshly
 // generated, public–private key pair.
 OPENSSL_EXPORT void X25519_keypair(uint8_t out_public_value[32],
                                    uint8_t out_private_key[32]);
 
-// X25519 writes a shared key to |out_shared_key| that is calculated from the
+// X25519 writes a shared key to `out_shared_key` that is calculated from the
 // given private key and the peer's public value. It returns one on success and
 // zero on error.
 //
@@ -53,7 +53,7 @@ OPENSSL_EXPORT int X25519(uint8_t out_shared_key[32],
                           const uint8_t peer_public_value[32]);
 
 // X25519_public_from_private calculates a Diffie-Hellman public value from the
-// given private key and writes it to |out_public_value|.
+// given private key and writes it to `out_public_value`.
 OPENSSL_EXPORT void X25519_public_from_private(uint8_t out_public_value[32],
                                                const uint8_t private_key[32]);
 
@@ -72,20 +72,20 @@ OPENSSL_EXPORT void X25519_public_from_private(uint8_t out_public_value[32],
 #define ED25519_PUBLIC_KEY_LEN 32
 #define ED25519_SIGNATURE_LEN 64
 
-// ED25519_keypair sets |out_public_key| and |out_private_key| to a freshly
+// ED25519_keypair sets `out_public_key` and `out_private_key` to a freshly
 // generated, public–private key pair.
 OPENSSL_EXPORT void ED25519_keypair(uint8_t out_public_key[32],
                                     uint8_t out_private_key[64]);
 
-// ED25519_sign sets |out_sig| to be a signature of |message_len| bytes from
-// |message| using |private_key|. It returns one on success or zero on
+// ED25519_sign sets `out_sig` to be a signature of `message_len` bytes from
+// `message` using `private_key`. It returns one on success or zero on
 // allocation failure.
 OPENSSL_EXPORT int ED25519_sign(uint8_t out_sig[64], const uint8_t *message,
                                 size_t message_len,
                                 const uint8_t private_key[64]);
 
-// ED25519_verify returns one iff |signature| is a valid signature, by
-// |public_key| of |message_len| bytes from |message|. It returns zero
+// ED25519_verify returns one iff `signature` is a valid signature, by
+// `public_key` of `message_len` bytes from `message`. It returns zero
 // otherwise.
 OPENSSL_EXPORT int ED25519_verify(const uint8_t *message, size_t message_len,
                                   const uint8_t signature[64],
@@ -118,12 +118,12 @@ enum spake2_role_t {
   spake2_role_bob,
 };
 
-// SPAKE2_CTX_new creates a new |SPAKE2_CTX| (which can only be used for a
+// SPAKE2_CTX_new creates a new `SPAKE2_CTX` (which can only be used for a
 // single execution of the protocol). SPAKE2 requires the symmetry of the two
-// parties to be broken which is indicated via |my_role| – each party must pass
+// parties to be broken which is indicated via `my_role` – each party must pass
 // a different value for this argument.
 //
-// The |my_name| and |their_name| arguments allow optional, opaque names to be
+// The `my_name` and `their_name` arguments allow optional, opaque names to be
 // bound into the protocol. For example MAC addresses, hostnames, usernames
 // etc. These values are not exposed and can avoid context-confusion attacks
 // when a password is shared between several devices.
@@ -132,19 +132,19 @@ OPENSSL_EXPORT SPAKE2_CTX *SPAKE2_CTX_new(
     const uint8_t *my_name, size_t my_name_len,
     const uint8_t *their_name, size_t their_name_len);
 
-// SPAKE2_CTX_free frees |ctx| and all the resources that it has allocated.
+// SPAKE2_CTX_free frees `ctx` and all the resources that it has allocated.
 OPENSSL_EXPORT void SPAKE2_CTX_free(SPAKE2_CTX *ctx);
 
 // SPAKE2_MAX_MSG_SIZE is the maximum size of a SPAKE2 message.
 #define SPAKE2_MAX_MSG_SIZE 32
 
-// SPAKE2_generate_msg generates a SPAKE2 message given |password|, writes
-// it to |out| and sets |*out_len| to the number of bytes written.
+// SPAKE2_generate_msg generates a SPAKE2 message given `password`, writes
+// it to `out` and sets `*out_len` to the number of bytes written.
 //
-// At most |max_out_len| bytes are written to |out| and, in order to ensure
-// success, |max_out_len| should be at least |SPAKE2_MAX_MSG_SIZE| bytes.
+// At most `max_out_len` bytes are written to `out` and, in order to ensure
+// success, `max_out_len` should be at least `SPAKE2_MAX_MSG_SIZE` bytes.
 //
-// This function can only be called once for a given |SPAKE2_CTX|.
+// This function can only be called once for a given `SPAKE2_CTX`.
 //
 // It returns one on success and zero on error.
 OPENSSL_EXPORT int SPAKE2_generate_msg(SPAKE2_CTX *ctx, uint8_t *out,
@@ -157,8 +157,8 @@ OPENSSL_EXPORT int SPAKE2_generate_msg(SPAKE2_CTX *ctx, uint8_t *out,
 #define SPAKE2_MAX_KEY_SIZE 64
 
 // SPAKE2_process_msg completes the SPAKE2 exchange given the peer's message in
-// |their_msg|, writes at most |max_out_key_len| bytes to |out_key| and sets
-// |*out_key_len| to the number of bytes written.
+// `their_msg`, writes at most `max_out_key_len` bytes to `out_key` and sets
+// `*out_key_len` to the number of bytes written.
 //
 // The resulting keying material is suitable for:
 //    - Using directly in a key-confirmation step: i.e. each side could
@@ -167,13 +167,13 @@ OPENSSL_EXPORT int SPAKE2_generate_msg(SPAKE2_CTX *ctx, uint8_t *out,
 //   -  Using as input keying material to HKDF to generate a variety of subkeys
 //      for encryption etc.
 //
-// If |max_out_key_key| is smaller than the amount of key material generated
+// If `max_out_key_key` is smaller than the amount of key material generated
 // then the key is silently truncated. If you want to ensure that no truncation
-// occurs then |max_out_key| should be at least |SPAKE2_MAX_KEY_SIZE|.
+// occurs then `max_out_key` should be at least `SPAKE2_MAX_KEY_SIZE`.
 //
-// You must call |SPAKE2_generate_msg| on a given |SPAKE2_CTX| before calling
-// this function. On successful return, |ctx| is complete and calling
-// |SPAKE2_CTX_free| is the only acceptable operation on it.
+// You must call `SPAKE2_generate_msg` on a given `SPAKE2_CTX` before calling
+// this function. On successful return, `ctx` is complete and calling
+// `SPAKE2_CTX_free` is the only acceptable operation on it.
 //
 // Returns one on success or zero on error.
 OPENSSL_EXPORT int SPAKE2_process_msg(SPAKE2_CTX *ctx, uint8_t *out_key,