grpc 1.68.1 → 1.71.0

data/third_party/boringssl-with-bazel/src/crypto/kyber/internal.h

@@ -1,16 +1,16 @@
-/* Copyright (c) 2023, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+// Copyright 2023 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #ifndef OPENSSL_HEADER_CRYPTO_KYBER_INTERNAL_H
 #define OPENSSL_HEADER_CRYPTO_KYBER_INTERNAL_H

data/third_party/boringssl-with-bazel/src/crypto/kyber/{kyber.c → kyber.cc}

@@ -1,16 +1,16 @@
-/* Copyright (c) 2023, Google Inc.
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+// Copyright 2023 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #define OPENSSL_UNSTABLE_EXPERIMENTAL_KYBER
 #include <openssl/experimental/kyber.h>
@@ -21,8 +21,8 @@
 #include <openssl/bytestring.h>
 #include <openssl/rand.h>
 
+#include "../fipsmodule/keccak/internal.h"
 #include "../internal.h"
-#include "../keccak/internal.h"
 #include "./internal.h"
 
 
@@ -135,20 +135,25 @@ static const uint16_t kModRoots[128] = {
 
 // reduce_once reduces 0 <= x < 2*kPrime, mod kPrime.
 static uint16_t reduce_once(uint16_t x) {
-  assert(x < 2 * kPrime);
+  declassify_assert(x < 2 * kPrime);
   const uint16_t subtracted = x - kPrime;
   uint16_t mask = 0u - (subtracted >> 15);
-  // On Aarch64, omitting a |value_barrier_u16| results in a 2x speedup of Kyber
-  // overall and Clang still produces constant-time code using `csel`. On other
-  // platforms & compilers on godbolt that we care about, this code also
-  // produces constant-time output.
+  // Although this is a constant-time select, we omit a value barrier here.
+  // Value barriers impede auto-vectorization (likely because it forces the
+  // value to transit through a general-purpose register). On AArch64, this is a
+  // difference of 2x.
+  //
+  // We usually add value barriers to selects because Clang turns consecutive
+  // selects with the same condition into a branch instead of CMOV/CSEL. This
+  // condition does not occur in Kyber, so omitting it seems to be safe so far,
+  // but see |scalar_centered_binomial_distribution_eta_2_with_prf|.
   return (mask & x) | (~mask & subtracted);
 }
 
 // constant time reduce x mod kPrime using Barrett reduction. x must be less
 // than kPrime + 2×kPrime².
 static uint16_t reduce(uint32_t x) {
-  assert(x < kPrime + 2u * kPrime * kPrime);
+  declassify_assert(x < kPrime + 2u * kPrime * kPrime);
   uint64_t product = (uint64_t)x * kBarrettMultiplier;
   uint32_t quotient = (uint32_t)(product >> kBarrettShift);
   uint32_t remainder = x - quotient * kPrime;
@@ -337,16 +342,21 @@ static void scalar_centered_binomial_distribution_eta_2_with_prf(
   for (int i = 0; i < DEGREE; i += 2) {
     uint8_t byte = entropy[i / 2];
 
-    uint16_t value = kPrime;
-    value += (byte & 1) + ((byte >> 1) & 1);
+    uint16_t value = (byte & 1) + ((byte >> 1) & 1);
     value -= ((byte >> 2) & 1) + ((byte >> 3) & 1);
-    out->c[i] = reduce_once(value);
+    // Add |kPrime| if |value| underflowed. See |reduce_once| for a discussion
+    // on why the value barrier is omitted. While this could have been written
+    // reduce_once(value + kPrime), this is one extra addition and small range
+    // of |value| tempts some versions of Clang to emit a branch.
+    uint16_t mask = 0u - (value >> 15);
+    out->c[i] = value + (kPrime & mask);
 
     byte >>= 4;
-    value = kPrime;
-    value += (byte & 1) + ((byte >> 1) & 1);
+    value = (byte & 1) + ((byte >> 1) & 1);
     value -= ((byte >> 2) & 1) + ((byte >> 3) & 1);
-    out->c[i + 1] = reduce_once(value);
+    // See above.
+    mask = 0u - (value >> 15);
+    out->c[i + 1] = value + (kPrime & mask);
   }
 }
 
@@ -470,7 +480,9 @@ static int scalar_decode(scalar *out, const uint8_t *in, int bits) {
       element_bits_done += chunk_bits;
     }
 
-    if (element >= kPrime) {
+    // An element is only out of range in the case of invalid input, in which
+    // case it is okay to leak the comparison.
+    if (constant_time_declassify_int(element >= kPrime)) {
       return 0;
     }
     out->c[i] = element;
@@ -518,7 +530,7 @@ static uint16_t compress(uint16_t x, int bits) {
   //   0 <= remainder <= kHalfPrime round to 0
   //   kHalfPrime < remainder <= kPrime + kHalfPrime round to 1
   //   kPrime + kHalfPrime < remainder < 2 * kPrime round to 2
-  assert(remainder < 2u * kPrime);
+  declassify_assert(remainder < 2u * kPrime);
   quotient += 1 & constant_time_lt_w(kHalfPrime, remainder);
   quotient += 1 & constant_time_lt_w(kPrime + kHalfPrime, remainder);
   return quotient & ((1 << bits) - 1);
@@ -565,6 +577,8 @@ static void vector_decompress(vector *a, int bits) {
   }
 }
 
+namespace {
+
 struct public_key {
   vector t;
   uint8_t rho[32];
@@ -597,12 +611,15 @@ static struct private_key *private_key_from_external(
   return (struct private_key *)external;
 }
 
+}  // namespace
+
 // Calls |KYBER_generate_key_external_entropy| with random bytes from
 // |RAND_bytes|.
 void KYBER_generate_key(uint8_t out_encoded_public_key[KYBER_PUBLIC_KEY_BYTES],
                         struct KYBER_private_key *out_private_key) {
   uint8_t entropy[KYBER_GENERATE_KEY_ENTROPY];
   RAND_bytes(entropy, sizeof(entropy));
+  CONSTTIME_SECRET(entropy, sizeof(entropy));
   KYBER_generate_key_external_entropy(out_encoded_public_key, out_private_key,
                                       entropy);
 }
@@ -631,6 +648,8 @@ void KYBER_generate_key_external_entropy(
   hash_g(hashed, entropy, 32);
   const uint8_t *const rho = hashed;
   const uint8_t *const sigma = hashed + 32;
+  // rho is public.
+  CONSTTIME_DECLASSIFY(rho, 32);
   OPENSSL_memcpy(priv->pub.rho, hashed, sizeof(priv->pub.rho));
   matrix_expand(&priv->pub.m, rho);
   uint8_t counter = 0;
@@ -641,6 +660,8 @@ void KYBER_generate_key_external_entropy(
   vector_ntt(&error);
   matrix_mult_transpose(&priv->pub.t, &priv->pub.m, &priv->s);
   vector_add(&priv->pub.t, &error);
+  // t is part of the public key and thus is public.
+  CONSTTIME_DECLASSIFY(&priv->pub.t, sizeof(priv->pub.t));
 
   CBB cbb;
   CBB_init_fixed(&cbb, out_encoded_public_key, KYBER_PUBLIC_KEY_BYTES);
@@ -702,6 +723,7 @@ void KYBER_encap(uint8_t out_ciphertext[KYBER_CIPHERTEXT_BYTES],
                  const struct KYBER_public_key *public_key) {
   uint8_t entropy[KYBER_ENCAP_ENTROPY];
   RAND_bytes(entropy, KYBER_ENCAP_ENTROPY);
+  CONSTTIME_SECRET(entropy, KYBER_ENCAP_ENTROPY);
   KYBER_encap_external_entropy(out_ciphertext, out_shared_secret, public_key,
                                entropy);
 }
@@ -725,6 +747,8 @@ void KYBER_encap_external_entropy(
   uint8_t prekey_and_randomness[64];
   hash_g(prekey_and_randomness, input, sizeof(input));
   encrypt_cpa(out_ciphertext, pub, entropy, prekey_and_randomness + 32);
+  // The ciphertext is public.
+  CONSTTIME_DECLASSIFY(out_ciphertext, KYBER_CIPHERTEXT_BYTES);
   hash_h(prekey_and_randomness + 32, out_ciphertext, KYBER_CIPHERTEXT_BYTES);
   kdf(out_shared_secret, KYBER_SHARED_SECRET_BYTES, prekey_and_randomness,
       sizeof(prekey_and_randomness));

data/third_party/boringssl-with-bazel/src/crypto/lhash/internal.h

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #ifndef OPENSSL_HEADER_LHASH_INTERNAL_H
 #define OPENSSL_HEADER_LHASH_INTERNAL_H
@@ -172,32 +130,32 @@ OPENSSL_EXPORT void OPENSSL_lh_doall_arg(_LHASH *lh,
   typedef int (*lhash_##type##_cmp_func)(const type *, const type *);          \
   typedef uint32_t (*lhash_##type##_hash_func)(const type *);                  \
                                                                                \
-  OPENSSL_INLINE int lh_##type##_call_cmp_func(lhash_cmp_func func,            \
-                                               const void *a, const void *b) { \
+  inline int lh_##type##_call_cmp_func(lhash_cmp_func func, const void *a,     \
+                                       const void *b) {                        \
     return ((lhash_##type##_cmp_func)func)((const type *)a, (const type *)b);  \
   }                                                                            \
                                                                                \
-  OPENSSL_INLINE uint32_t lh_##type##_call_hash_func(lhash_hash_func func,     \
-                                                     const void *a) {          \
+  inline uint32_t lh_##type##_call_hash_func(lhash_hash_func func,             \
+                                             const void *a) {                  \
     return ((lhash_##type##_hash_func)func)((const type *)a);                  \
   }                                                                            \
                                                                                \
-  OPENSSL_INLINE LHASH_OF(type) *lh_##type##_new(                              \
-      lhash_##type##_hash_func hash, lhash_##type##_cmp_func comp) {           \
+  inline LHASH_OF(type) *lh_##type##_new(lhash_##type##_hash_func hash,        \
+                                         lhash_##type##_cmp_func comp) {       \
     return (LHASH_OF(type) *)OPENSSL_lh_new((lhash_hash_func)hash,             \
                                             (lhash_cmp_func)comp);             \
   }                                                                            \
                                                                                \
-  OPENSSL_INLINE void lh_##type##_free(LHASH_OF(type) *lh) {                   \
+  inline void lh_##type##_free(LHASH_OF(type) *lh) {                           \
     OPENSSL_lh_free((_LHASH *)lh);                                             \
   }                                                                            \
                                                                                \
-  OPENSSL_INLINE size_t lh_##type##_num_items(const LHASH_OF(type) *lh) {      \
+  inline size_t lh_##type##_num_items(const LHASH_OF(type) *lh) {              \
     return OPENSSL_lh_num_items((const _LHASH *)lh);                           \
   }                                                                            \
                                                                                \
-  OPENSSL_INLINE type *lh_##type##_retrieve(const LHASH_OF(type) *lh,          \
-                                            const type *data) {                \
+  inline type *lh_##type##_retrieve(const LHASH_OF(type) *lh,                  \
+                                    const type *data) {                        \
     return (type *)OPENSSL_lh_retrieve((const _LHASH *)lh, data,               \
                                        lh_##type##_call_hash_func,             \
                                        lh_##type##_call_cmp_func);             \
@@ -208,13 +166,12 @@ OPENSSL_EXPORT void OPENSSL_lh_doall_arg(_LHASH *lh,
     const void *key;                                                           \
   } LHASH_CMP_KEY_##type;                                                      \
                                                                                \
-  OPENSSL_INLINE int lh_##type##_call_cmp_key(const void *key,                 \
-                                              const void *value) {             \
+  inline int lh_##type##_call_cmp_key(const void *key, const void *value) {    \
     const LHASH_CMP_KEY_##type *cb = (const LHASH_CMP_KEY_##type *)key;        \
     return cb->cmp_key(cb->key, (const type *)value);                          \
   }                                                                            \
                                                                                \
-  OPENSSL_INLINE type *lh_##type##_retrieve_key(                               \
+  inline type *lh_##type##_retrieve_key(                                       \
       const LHASH_OF(type) *lh, const void *key, uint32_t key_hash,            \
       int (*cmp_key)(const void *key, const type *value)) {                    \
     LHASH_CMP_KEY_##type cb = {cmp_key, key};                                  \
@@ -222,8 +179,8 @@ OPENSSL_EXPORT void OPENSSL_lh_doall_arg(_LHASH *lh,
                                            lh_##type##_call_cmp_key);          \
   }                                                                            \
                                                                                \
-  OPENSSL_INLINE int lh_##type##_insert(LHASH_OF(type) *lh, type **old_data,   \
-                                        type *data) {                          \
+  inline int lh_##type##_insert(LHASH_OF(type) *lh, type **old_data,           \
+                                type *data) {                                  \
     void *old_data_void = NULL;                                                \
     int ret = OPENSSL_lh_insert((_LHASH *)lh, &old_data_void, data,            \
                                 lh_##type##_call_hash_func,                    \
@@ -232,8 +189,7 @@ OPENSSL_EXPORT void OPENSSL_lh_doall_arg(_LHASH *lh,
     return ret;                                                                \
   }                                                                            \
                                                                                \
-  OPENSSL_INLINE type *lh_##type##_delete(LHASH_OF(type) *lh,                  \
-                                          const type *data) {                  \
+  inline type *lh_##type##_delete(LHASH_OF(type) *lh, const type *data) {      \
     return (type *)OPENSSL_lh_delete((_LHASH *)lh, data,                       \
                                      lh_##type##_call_hash_func,               \
                                      lh_##type##_call_cmp_func);               \
@@ -244,13 +200,13 @@ OPENSSL_EXPORT void OPENSSL_lh_doall_arg(_LHASH *lh,
     void *arg;                                                                 \
   } LHASH_DOALL_##type;                                                        \
                                                                                \
-  OPENSSL_INLINE void lh_##type##_call_doall_arg(void *value, void *arg) {     \
+  inline void lh_##type##_call_doall_arg(void *value, void *arg) {             \
     const LHASH_DOALL_##type *cb = (const LHASH_DOALL_##type *)arg;            \
     cb->doall_arg((type *)value, cb->arg);                                     \
   }                                                                            \
                                                                                \
-  OPENSSL_INLINE void lh_##type##_doall_arg(                                   \
-      LHASH_OF(type) *lh, void (*func)(type *, void *), void *arg) {           \
+  inline void lh_##type##_doall_arg(LHASH_OF(type) *lh,                        \
+                                    void (*func)(type *, void *), void *arg) { \
     LHASH_DOALL_##type cb = {func, arg};                                       \
     OPENSSL_lh_doall_arg((_LHASH *)lh, lh_##type##_call_doall_arg, &cb);       \
   }                                                                            \

data/third_party/boringssl-with-bazel/src/crypto/lhash/{lhash.c → lhash.cc}

@@ -1,58 +1,16 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/lhash.h>
 
@@ -62,8 +20,8 @@
 
 #include <openssl/mem.h>
 
-#include "internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
 // kMinNumBuckets is the minimum size of the buckets array in an |_LHASH|.
@@ -104,13 +62,14 @@ struct lhash_st {
 };
 
 _LHASH *OPENSSL_lh_new(lhash_hash_func hash, lhash_cmp_func comp) {
-  _LHASH *ret = OPENSSL_zalloc(sizeof(_LHASH));
+  _LHASH *ret = reinterpret_cast<_LHASH *>(OPENSSL_zalloc(sizeof(_LHASH)));
   if (ret == NULL) {
     return NULL;
   }
 
   ret->num_buckets = kMinNumBuckets;
-  ret->buckets = OPENSSL_calloc(ret->num_buckets, sizeof(LHASH_ITEM *));
+  ret->buckets = reinterpret_cast<LHASH_ITEM **>(
+      OPENSSL_calloc(ret->num_buckets, sizeof(LHASH_ITEM *)));
   if (ret->buckets == NULL) {
     OPENSSL_free(ret);
     return NULL;
@@ -208,11 +167,11 @@ static void lh_rebucket(_LHASH *lh, const size_t new_num_buckets) {
   size_t i, alloc_size;
 
   alloc_size = sizeof(LHASH_ITEM *) * new_num_buckets;
-  if (alloc_size / sizeof(LHASH_ITEM*) != new_num_buckets) {
+  if (alloc_size / sizeof(LHASH_ITEM *) != new_num_buckets) {
     return;
   }
 
-  new_buckets = OPENSSL_zalloc(alloc_size);
+  new_buckets = reinterpret_cast<LHASH_ITEM **>(OPENSSL_zalloc(alloc_size));
   if (new_buckets == NULL) {
     return;
   }
@@ -282,7 +241,7 @@ int OPENSSL_lh_insert(_LHASH *lh, void **old_data, void *data,
   }
 
   // An element equal to |data| doesn't exist in the hash table yet.
-  item = OPENSSL_malloc(sizeof(LHASH_ITEM));
+  item = reinterpret_cast<LHASH_ITEM *>(OPENSSL_malloc(sizeof(LHASH_ITEM)));
   if (item == NULL) {
     return 0;
   }
@@ -312,7 +271,7 @@ void *OPENSSL_lh_delete(_LHASH *lh, const void *data,
 
   item = *next_ptr;
   *next_ptr = item->next;
-  ret = item->data;
+  ret = reinterpret_cast<LHASH_ITEM *>(item->data);
   OPENSSL_free(item);
 
   lh->num_items--;

data/third_party/boringssl-with-bazel/src/crypto/{fipsmodule/md4/md4.c.inc → md4/md4.cc}

@@ -1,66 +1,24 @@
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.] */
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #include <openssl/md4.h>
 
 #include <stdlib.h>
 #include <string.h>
 
-#include "../../internal.h"
-#include "../digest/md32_common.h"
+#include "../fipsmodule/digest/md32_common.h"
+#include "../internal.h"
 
 
 uint8_t *MD4(const uint8_t *data, size_t len, uint8_t out[MD4_DIGEST_LENGTH]) {
@@ -83,7 +41,8 @@ int MD4_Init(MD4_CTX *md4) {
   return 1;
 }
 
-void md4_block_data_order(uint32_t *state, const uint8_t *data, size_t num);
+static void md4_block_data_order(uint32_t *state, const uint8_t *data,
+                                 size_t num);
 
 void MD4_Transform(MD4_CTX *c, const uint8_t data[MD4_CBLOCK]) {
   md4_block_data_order(c->h, data, 1);
@@ -91,7 +50,8 @@ void MD4_Transform(MD4_CTX *c, const uint8_t data[MD4_CBLOCK]) {
 
 int MD4_Update(MD4_CTX *c, const void *data, size_t len) {
   crypto_md32_update(&md4_block_data_order, c->h, c->data, MD4_CBLOCK, &c->num,
-                     &c->Nh, &c->Nl, data, len);
+                     &c->Nh, &c->Nl, reinterpret_cast<const uint8_t *>(data),
+                     len);
   return 1;
 }
 
@@ -131,7 +91,8 @@ int MD4_Final(uint8_t out[MD4_DIGEST_LENGTH], MD4_CTX *c) {
     (a) = CRYPTO_rotl_u32(a, s);           \
   } while (0)
 
-void md4_block_data_order(uint32_t *state, const uint8_t *data, size_t num) {
+static void md4_block_data_order(uint32_t *state, const uint8_t *data,
+                                 size_t num) {
   uint32_t A, B, C, D;
   uint32_t X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15;
 
@@ -231,10 +192,3 @@ void md4_block_data_order(uint32_t *state, const uint8_t *data, size_t num) {
     D = state[3] += D;
   }
 }
-
-#undef F
-#undef G
-#undef H
-#undef R0
-#undef R1
-#undef R2