grpc 1.84.1 → 1.85.0.pre1

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

@@ -21,7 +21,7 @@
 #define EVP_R_DIFFERENT_KEY_TYPES 103
 #define EVP_R_DIFFERENT_PARAMETERS 104
 #define EVP_R_ENCODE_ERROR 105
-#define EVP_R_EXPECTING_AN_EC_KEY_KEY 106
+#define EVP_R_EXPECTING_A_EC_KEY 106
 #define EVP_R_EXPECTING_AN_RSA_KEY 107
 #define EVP_R_EXPECTING_A_DSA_KEY 108
 #define EVP_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 109
@@ -41,7 +41,7 @@
 #define EVP_R_NO_OPERATION_SET 123
 #define EVP_R_NO_PARAMETERS_SET 124
 #define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 125
-#define EVP_R_OPERATON_NOT_INITIALIZED 126
+#define EVP_R_OPERATION_NOT_INITIALIZED 126
 #define EVP_R_UNKNOWN_PUBLIC_KEY_TYPE 127
 #define EVP_R_UNSUPPORTED_ALGORITHM 128
 #define EVP_R_UNSUPPORTED_PUBLIC_KEY_TYPE 129
@@ -54,5 +54,12 @@
 #define EVP_R_EMPTY_PSK 136
 #define EVP_R_INVALID_BUFFER_SIZE 137
 #define EVP_R_EXPECTING_A_DH_KEY 138
+#define EVP_R_PRIVATE_KEY_WAS_NOT_SEED 139
+#define EVP_R_MISSING_PUBLIC_KEY 140
+#define EVP_R_INVALID_CIPHERTEXT_LENGTH 141
+#define EVP_R_INVALID_SECRET_LENGTH 142
+
+// Compatibility defines.
+#define EVP_R_OPERATON_NOT_INITIALIZED EVP_R_OPERATION_NOT_INITIALIZED
 
 #endif  // OPENSSL_HEADER_EVP_ERRORS_H

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

@@ -15,9 +15,7 @@
 #ifndef OPENSSL_HEADER_EX_DATA_H
 #define OPENSSL_HEADER_EX_DATA_H
 
-#include <openssl/base.h>   // IWYU pragma: export
-
-#include <openssl/stack.h>
+#include <openssl/base.h>  // IWYU pragma: export
 
 #if defined(__cplusplus)
 extern "C" {
@@ -31,18 +29,15 @@ extern "C" {
 // duplicated.
 
 
-typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
-
-
 // Type-specific functions.
 
 #if 0  // Sample
 
 // Each type that supports ex_data provides three functions:
 
-// TYPE_get_ex_new_index allocates a new index for |TYPE|. An optional
-// |free_func| argument may be provided which is called when the owning object
-// is destroyed. See |CRYPTO_EX_free| for details. The |argl| and |argp|
+// TYPE_get_ex_new_index allocates a new index for `TYPE`. An optional
+// `free_func` argument may be provided which is called when the owning object
+// is destroyed. See `CRYPTO_EX_free` for details. The `argl` and `argp`
 // arguments are opaque values that are passed to the callback. It returns the
 // new index or a negative number on error.
 OPENSSL_EXPORT int TYPE_get_ex_new_index(long argl, void *argp,
@@ -50,24 +45,24 @@ OPENSSL_EXPORT int TYPE_get_ex_new_index(long argl, void *argp,
                                          CRYPTO_EX_dup *dup_unused,
                                          CRYPTO_EX_free *free_func);
 
-// TYPE_set_ex_data sets an extra data pointer on |t|. The |index| argument
-// must have been returned from a previous call to |TYPE_get_ex_new_index|.
+// TYPE_set_ex_data sets an extra data pointer on `t`. The `index` argument
+// must have been returned from a previous call to `TYPE_get_ex_new_index`.
 OPENSSL_EXPORT int TYPE_set_ex_data(TYPE *t, int index, void *arg);
 
-// TYPE_get_ex_data returns an extra data pointer for |t|, or NULL if no such
-// pointer exists. The |index| argument should have been returned from a
-// previous call to |TYPE_get_ex_new_index|.
+// TYPE_get_ex_data returns an extra data pointer for `t`, or NULL if no such
+// pointer exists. The `index` argument should have been returned from a
+// previous call to `TYPE_get_ex_new_index`.
 OPENSSL_EXPORT void *TYPE_get_ex_data(const TYPE *t, int index);
 
 // Some types additionally preallocate index zero, with all callbacks set to
 // NULL. Applications that do not need the general ex_data machinery may use
 // this instead.
 
-// TYPE_set_app_data sets |t|'s application data pointer to |arg|. It returns
+// TYPE_set_app_data sets `t`'s application data pointer to `arg`. It returns
 // one on success and zero on error.
 OPENSSL_EXPORT int TYPE_set_app_data(TYPE *t, void *arg);
 
-// TYPE_get_app_data returns the application data pointer for |t|, or NULL if no
+// TYPE_get_app_data returns the application data pointer for `t`, or NULL if no
 // such pointer exists.
 OPENSSL_EXPORT void *TYPE_get_app_data(const TYPE *t);
 
@@ -76,20 +71,27 @@ OPENSSL_EXPORT void *TYPE_get_app_data(const TYPE *t);
 
 // Callback types.
 
+// CRYPTO_EX_DATA, in the public API, is an opaque struct that is never returned
+// from the library.
+typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
+
 // CRYPTO_EX_free is a callback function that is called when an object of the
 // class with extra data pointers is being destroyed. For example, if this
-// callback has been passed to |SSL_get_ex_new_index| then it may be called each
-// time an |SSL*| is destroyed.
+// callback has been passed to `SSL_get_ex_new_index` then it may be called each
+// time an `SSL*` is destroyed.
+//
+// `parent` and `ad` will be NULL. Historically, the parent object was passed in
+// `parent`, but accessing the pointer was not safe because `parent` was in the
+// process of being destroyed. If the callback has access to some other pointer
+// to the parent object, it must not pass the pointer to any BoringSSL APIs.
+// Mid-destruction, invariants on the parent object no longer hold.
 //
-// The callback is passed the to-be-destroyed object (i.e. the |SSL*|) in
-// |parent|. As |parent| will shortly be destroyed, callers must not perform
-// operations that would increment its reference count, pass ownership, or
-// assume the object outlives the function call. The arguments |argl| and |argp|
-// contain opaque values that were given to |CRYPTO_get_ex_new_index_ex|.
+// The arguments `argl` and `argp` contain opaque values that were given to
+// `CRYPTO_get_ex_new_index_ex`.
 //
-// This callback may be called with a NULL value for |ptr| if |parent| has no
+// This callback may be called with a NULL value for `ptr` if the object has no
 // value set for this index. However, the callbacks may also be skipped entirely
-// if no extra data pointers are set on |parent| at all.
+// if no extra data pointers are set on the object at all.
 typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
                             int index, long argl, void *argp);
 
@@ -103,17 +105,10 @@ OPENSSL_EXPORT void CRYPTO_cleanup_all_ex_data(void);
 typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
                           void **from_d, int index, long argl, void *argp);
 
-
-// Private structures.
-
 // CRYPTO_EX_unused is a placeholder for an unused callback. It is aliased to
 // int to ensure non-NULL callers fail to compile rather than fail silently.
 typedef int CRYPTO_EX_unused;
 
-struct crypto_ex_data_st {
-  STACK_OF(void) *sk;
-};
-
 
 #if defined(__cplusplus)
 }  // extern C

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

@@ -26,8 +26,8 @@ extern "C" {
 
 
 // HKDF computes HKDF (as specified by RFC 5869) of initial keying material
-// |secret| with |salt| and |info| using |digest|, and outputs |out_len| bytes
-// to |out_key|. It returns one on success and zero on error.
+// `secret` with `salt` and `info` using `digest`, and outputs `out_len` bytes
+// to `out_key`. It returns one on success and zero on error.
 //
 // HKDF is an Extract-and-Expand algorithm. It does not do any key stretching,
 // and as such, is not suited to be used alone to generate a key from a
@@ -38,8 +38,8 @@ OPENSSL_EXPORT int HKDF(uint8_t *out_key, size_t out_len, const EVP_MD *digest,
                         const uint8_t *info, size_t info_len);
 
 // HKDF_extract computes a HKDF PRK (as specified by RFC 5869) from initial
-// keying material |secret| and salt |salt| using |digest|, and outputs
-// |out_len| bytes to |out_key|. The maximum output size is |EVP_MAX_MD_SIZE|.
+// keying material `secret` and salt `salt` using `digest`, and outputs
+// `out_len` bytes to `out_key`. The maximum output size is `EVP_MAX_MD_SIZE`.
 // It returns one on success and zero on error.
 //
 // WARNING: This function orders the inputs differently from RFC 5869
@@ -51,8 +51,8 @@ OPENSSL_EXPORT int HKDF_extract(uint8_t *out_key, size_t *out_len,
                                 size_t salt_len);
 
 // HKDF_expand computes a HKDF OKM (as specified by RFC 5869) of length
-// |out_len| from the PRK |prk| and info |info| using |digest|, and outputs
-// the result to |out_key|. It returns one on success and zero on error.
+// `out_len` from the PRK `prk` and info `info` using `digest`, and outputs
+// the result to `out_key`. It returns one on success and zero on error.
 OPENSSL_EXPORT int HKDF_expand(uint8_t *out_key, size_t out_len,
                                const EVP_MD *digest, const uint8_t *prk,
                                size_t prk_len, const uint8_t *info,

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

@@ -30,11 +30,11 @@ extern "C" {
 
 // One-shot operation.
 
-// HMAC calculates the HMAC of |data_len| bytes of |data|, using the given key
-// and hash function, and writes the result to |out|. On entry, |out| must
-// contain at least |EVP_MD_size| bytes of space. The actual length of the
-// result is written to |*out_len|. An output size of |EVP_MAX_MD_SIZE| will
-// always be large enough. It returns |out| or NULL on error.
+// HMAC calculates the HMAC of `data_len` bytes of `data`, using the given key
+// and hash function, and writes the result to `out`. On entry, `out` must
+// contain at least `EVP_MD_size` bytes of space. The actual length of the
+// result is written to `*out_len`. An output size of `EVP_MAX_MD_SIZE` will
+// always be large enough. It returns `out` or NULL on error.
 OPENSSL_EXPORT uint8_t *HMAC(const EVP_MD *evp_md, const void *key,
                              size_t key_len, const uint8_t *data,
                              size_t data_len, uint8_t *out,
@@ -43,48 +43,48 @@ OPENSSL_EXPORT uint8_t *HMAC(const EVP_MD *evp_md, const void *key,
 
 // Incremental operation.
 
-// HMAC_CTX_init initialises |ctx| for use in an HMAC operation. It's assumed
+// HMAC_CTX_init initialises `ctx` for use in an HMAC operation. It's assumed
 // that HMAC_CTX objects will be allocated on the stack thus no allocation
 // function is provided.
 OPENSSL_EXPORT void HMAC_CTX_init(HMAC_CTX *ctx);
 
-// HMAC_CTX_new allocates and initialises a new |HMAC_CTX| and returns it, or
-// NULL on allocation failure. The caller must use |HMAC_CTX_free| to release
+// HMAC_CTX_new allocates and initialises a new `HMAC_CTX` and returns it, or
+// NULL on allocation failure. The caller must use `HMAC_CTX_free` to release
 // the resulting object.
 OPENSSL_EXPORT HMAC_CTX *HMAC_CTX_new(void);
 
-// HMAC_CTX_cleanup frees data owned by |ctx|. It does not free |ctx| itself.
+// HMAC_CTX_cleanup frees data owned by `ctx`. It does not free `ctx` itself.
 OPENSSL_EXPORT void HMAC_CTX_cleanup(HMAC_CTX *ctx);
 
-// HMAC_CTX_cleanse zeros the digest state from |ctx| and then performs the
-// actions of |HMAC_CTX_cleanup|.
+// HMAC_CTX_cleanse zeros the digest state from `ctx` and then performs the
+// actions of `HMAC_CTX_cleanup`.
 OPENSSL_EXPORT void HMAC_CTX_cleanse(HMAC_CTX *ctx);
 
-// HMAC_CTX_free calls |HMAC_CTX_cleanup| and then frees |ctx| itself.
+// HMAC_CTX_free calls `HMAC_CTX_cleanup` and then frees `ctx` itself.
 OPENSSL_EXPORT void HMAC_CTX_free(HMAC_CTX *ctx);
 
-// HMAC_Init_ex sets up an initialised |HMAC_CTX| to use |md| as the hash
-// function and |key| as the key. For a non-initial call, |md| may be NULL, in
+// HMAC_Init_ex sets up an initialised `HMAC_CTX` to use `md` as the hash
+// function and `key` as the key. For a non-initial call, `md` may be NULL, in
 // which case the previous hash function will be used. If the hash function has
-// not changed and |key| is NULL, |ctx| reuses the previous key. It returns one
+// not changed and `key` is NULL, `ctx` reuses the previous key. It returns one
 // on success or zero on allocation failure.
 //
 // WARNING: NULL and empty keys are ambiguous on non-initial calls. Passing NULL
-// |key| but repeating the previous |md| reuses the previous key rather than the
+// `key` but repeating the previous `md` reuses the previous key rather than the
 // empty key.
 OPENSSL_EXPORT int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, size_t key_len,
                                 const EVP_MD *md, ENGINE *impl);
 
-// HMAC_Update hashes |data_len| bytes from |data| into the current HMAC
-// operation in |ctx|. It returns one.
+// HMAC_Update hashes `data_len` bytes from `data` into the current HMAC
+// operation in `ctx`. It returns one.
 OPENSSL_EXPORT int HMAC_Update(HMAC_CTX *ctx, const uint8_t *data,
                                size_t data_len);
 
-// HMAC_Final completes the HMAC operation in |ctx| and writes the result to
-// |out| and the sets |*out_len| to the length of the result. On entry, |out|
-// must contain at least |HMAC_size| bytes of space. An output size of
-// |EVP_MAX_MD_SIZE| will always be large enough. It returns one on success or
-// zero on allocation failure.
+// HMAC_Final completes the HMAC operation in `ctx` and writes the result to
+// `out`. If `out_len` is not `NULL` then it writes the length of the result to
+// `*out_len`. On entry, `out` must contain at least `HMAC_size` bytes of
+// space. An output size of `EVP_MAX_MD_SIZE` will always be large enough. It
+// returns one on success or zero on allocation failure.
 OPENSSL_EXPORT int HMAC_Final(HMAC_CTX *ctx, uint8_t *out,
                               unsigned int *out_len);
 
@@ -92,18 +92,18 @@ OPENSSL_EXPORT int HMAC_Final(HMAC_CTX *ctx, uint8_t *out,
 // Utility functions.
 
 // HMAC_size returns the size, in bytes, of the HMAC that will be produced by
-// |ctx|. On entry, |ctx| must have been setup with |HMAC_Init_ex|.
+// `ctx`. On entry, `ctx` must have been setup with `HMAC_Init_ex`.
 OPENSSL_EXPORT size_t HMAC_size(const HMAC_CTX *ctx);
 
-// HMAC_CTX_get_md returns |ctx|'s hash function.
+// HMAC_CTX_get_md returns `ctx`'s hash function.
 OPENSSL_EXPORT const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx);
 
-// HMAC_CTX_copy_ex sets |dest| equal to |src|. On entry, |dest| must have been
-// initialised by calling |HMAC_CTX_init|. It returns one on success and zero
+// HMAC_CTX_copy_ex sets `dest` equal to `src`. On entry, `dest` must have been
+// initialised by calling `HMAC_CTX_init`. It returns one on success and zero
 // on error.
 OPENSSL_EXPORT int HMAC_CTX_copy_ex(HMAC_CTX *dest, const HMAC_CTX *src);
 
-// HMAC_CTX_reset calls |HMAC_CTX_cleanup| followed by |HMAC_CTX_init|.
+// HMAC_CTX_reset calls `HMAC_CTX_cleanup` followed by `HMAC_CTX_init`.
 OPENSSL_EXPORT void HMAC_CTX_reset(HMAC_CTX *ctx);
 
 
@@ -112,9 +112,9 @@ OPENSSL_EXPORT void HMAC_CTX_reset(HMAC_CTX *ctx);
 OPENSSL_EXPORT int HMAC_Init(HMAC_CTX *ctx, const void *key, int key_len,
                              const EVP_MD *md);
 
-// HMAC_CTX_copy calls |HMAC_CTX_init| on |dest| and then sets it equal to
-// |src|. On entry, |dest| must /not/ be initialised for an operation with
-// |HMAC_Init_ex|. It returns one on success and zero on error.
+// HMAC_CTX_copy calls `HMAC_CTX_init` on `dest` and then sets it equal to
+// `src`. On entry, `dest` must /not/ be initialised for an operation with
+// `HMAC_Init_ex`. It returns one on success and zero on error.
 OPENSSL_EXPORT int HMAC_CTX_copy(HMAC_CTX *dest, const HMAC_CTX *src);