grpc 1.69.0 → 1.71.0

data/third_party/boringssl-with-bazel/src/crypto/{rsa_extra/rsa_crypt.c → rsa/rsa_crypt.cc}

@@ -1,69 +1,27 @@
-/* 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/base.h>
 
 #include <limits.h>
 
-#include <openssl/err.h>
-#include <openssl/rsa.h>
 #include <openssl/bn.h>
-#include <openssl/rand.h>
-#include <openssl/mem.h>
+#include <openssl/err.h>
 #include <openssl/evp.h>
+#include <openssl/mem.h>
+#include <openssl/rand.h>
+#include <openssl/rsa.h>
 
 #include "../fipsmodule/bn/internal.h"
 #include "../fipsmodule/rsa/internal.h"
@@ -128,7 +86,7 @@ int RSA_padding_add_PKCS1_OAEP_mgf1(uint8_t *to, size_t to_len,
     goto out;
   }
 
-  dbmask = OPENSSL_malloc(emlen - mdlen);
+  dbmask = reinterpret_cast<uint8_t *>(OPENSSL_malloc(emlen - mdlen));
   if (dbmask == NULL) {
     goto out;
   }
@@ -161,92 +119,95 @@ int RSA_padding_check_PKCS1_OAEP_mgf1(uint8_t *out, size_t *out_len,
                                       const EVP_MD *mgf1md) {
   uint8_t *db = NULL;
 
-  if (md == NULL) {
-    md = EVP_sha1();
-  }
-  if (mgf1md == NULL) {
-    mgf1md = md;
-  }
+  {
+    if (md == NULL) {
+      md = EVP_sha1();
+    }
+    if (mgf1md == NULL) {
+      mgf1md = md;
+    }
 
-  size_t mdlen = EVP_MD_size(md);
+    size_t mdlen = EVP_MD_size(md);
 
-  // The encoded message is one byte smaller than the modulus to ensure that it
-  // doesn't end up greater than the modulus. Thus there's an extra "+1" here
-  // compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2.
-  if (from_len < 1 + 2 * mdlen + 1) {
-    // 'from_len' is the length of the modulus, i.e. does not depend on the
-    // particular ciphertext.
-    goto decoding_err;
-  }
+    // The encoded message is one byte smaller than the modulus to ensure that
+    // it doesn't end up greater than the modulus. Thus there's an extra "+1"
+    // here compared to https://tools.ietf.org/html/rfc2437#section-9.1.1.2.
+    if (from_len < 1 + 2 * mdlen + 1) {
+      // 'from_len' is the length of the modulus, i.e. does not depend on the
+      // particular ciphertext.
+      goto decoding_err;
+    }
 
-  size_t dblen = from_len - mdlen - 1;
-  db = OPENSSL_malloc(dblen);
-  if (db == NULL) {
-    goto err;
-  }
+    size_t dblen = from_len - mdlen - 1;
+    db = reinterpret_cast<uint8_t *>(OPENSSL_malloc(dblen));
+    if (db == NULL) {
+      goto err;
+    }
 
-  const uint8_t *maskedseed = from + 1;
-  const uint8_t *maskeddb = from + 1 + mdlen;
+    const uint8_t *maskedseed = from + 1;
+    const uint8_t *maskeddb = from + 1 + mdlen;
 
-  uint8_t seed[EVP_MAX_MD_SIZE];
-  if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) {
-    goto err;
-  }
-  for (size_t i = 0; i < mdlen; i++) {
-    seed[i] ^= maskedseed[i];
-  }
+    uint8_t seed[EVP_MAX_MD_SIZE];
+    if (!PKCS1_MGF1(seed, mdlen, maskeddb, dblen, mgf1md)) {
+      goto err;
+    }
+    for (size_t i = 0; i < mdlen; i++) {
+      seed[i] ^= maskedseed[i];
+    }
 
-  if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) {
-    goto err;
-  }
-  for (size_t i = 0; i < dblen; i++) {
-    db[i] ^= maskeddb[i];
-  }
+    if (!PKCS1_MGF1(db, dblen, seed, mdlen, mgf1md)) {
+      goto err;
+    }
+    for (size_t i = 0; i < dblen; i++) {
+      db[i] ^= maskeddb[i];
+    }
 
-  uint8_t phash[EVP_MAX_MD_SIZE];
-  if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) {
-    goto err;
-  }
+    uint8_t phash[EVP_MAX_MD_SIZE];
+    if (!EVP_Digest(param, param_len, phash, NULL, md, NULL)) {
+      goto err;
+    }
 
-  crypto_word_t bad = ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen));
-  bad |= ~constant_time_is_zero_w(from[0]);
+    crypto_word_t bad =
+        ~constant_time_is_zero_w(CRYPTO_memcmp(db, phash, mdlen));
+    bad |= ~constant_time_is_zero_w(from[0]);
+
+    crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W;
+    size_t one_index = 0;
+    for (size_t i = mdlen; i < dblen; i++) {
+      crypto_word_t equals1 = constant_time_eq_w(db[i], 1);
+      crypto_word_t equals0 = constant_time_eq_w(db[i], 0);
+      one_index =
+          constant_time_select_w(looking_for_one_byte & equals1, i, one_index);
+      looking_for_one_byte =
+          constant_time_select_w(equals1, 0, looking_for_one_byte);
+      bad |= looking_for_one_byte & ~equals0;
+    }
 
-  crypto_word_t looking_for_one_byte = CONSTTIME_TRUE_W;
-  size_t one_index = 0;
-  for (size_t i = mdlen; i < dblen; i++) {
-    crypto_word_t equals1 = constant_time_eq_w(db[i], 1);
-    crypto_word_t equals0 = constant_time_eq_w(db[i], 0);
-    one_index =
-        constant_time_select_w(looking_for_one_byte & equals1, i, one_index);
-    looking_for_one_byte =
-        constant_time_select_w(equals1, 0, looking_for_one_byte);
-    bad |= looking_for_one_byte & ~equals0;
-  }
+    bad |= looking_for_one_byte;
 
-  bad |= looking_for_one_byte;
+    // Whether the overall padding was valid or not in OAEP is public.
+    if (constant_time_declassify_w(bad)) {
+      goto decoding_err;
+    }
 
-  // Whether the overall padding was valid or not in OAEP is public.
-  if (constant_time_declassify_w(bad)) {
-    goto decoding_err;
-  }
+    // Once the padding is known to be valid, the output length is also public.
+    static_assert(sizeof(size_t) <= sizeof(crypto_word_t),
+                  "size_t does not fit in crypto_word_t");
+    one_index = constant_time_declassify_w(one_index);
 
-  // Once the padding is known to be valid, the output length is also public.
-  static_assert(sizeof(size_t) <= sizeof(crypto_word_t),
-                "size_t does not fit in crypto_word_t");
-  one_index = constant_time_declassify_w(one_index);
+    one_index++;
+    size_t mlen = dblen - one_index;
+    if (max_out < mlen) {
+      OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
+      goto err;
+    }
 
-  one_index++;
-  size_t mlen = dblen - one_index;
-  if (max_out < mlen) {
-    OPENSSL_PUT_ERROR(RSA, RSA_R_DATA_TOO_LARGE);
-    goto err;
+    OPENSSL_memcpy(out, db + one_index, mlen);
+    *out_len = mlen;
+    OPENSSL_free(db);
+    return 1;
   }
 
-  OPENSSL_memcpy(out, db + one_index, mlen);
-  *out_len = mlen;
-  OPENSSL_free(db);
-  return 1;
-
 decoding_err:
   // To avoid chosen ciphertext attacks, the error message should not reveal
   // which kind of decoding error happened.
@@ -406,7 +367,7 @@ int RSA_encrypt(RSA *rsa, size_t *out_len, uint8_t *out, size_t max_out,
   BN_CTX_start(ctx);
   f = BN_CTX_get(ctx);
   result = BN_CTX_get(ctx);
-  buf = OPENSSL_malloc(rsa_size);
+  buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(rsa_size));
   if (!f || !result || !buf) {
     goto err;
   }
@@ -483,7 +444,7 @@ static int rsa_default_decrypt(RSA *rsa, size_t *out_len, uint8_t *out,
     buf = out;
   } else {
     // Allocate a temporary buffer to hold the padded plaintext.
-    buf = OPENSSL_malloc(rsa_size);
+    buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(rsa_size));
     if (buf == NULL) {
       goto err;
     }

data/third_party/boringssl-with-bazel/src/crypto/rsa/rsa_extra.cc

@@ -0,0 +1,19 @@
+// Copyright 2024 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.
+
+#include <openssl/rsa.h>
+
+int RSA_blinding_on(RSA *rsa, BN_CTX *ctx) { return 1; }
+
+void RSA_blinding_off(RSA *rsa) {}

data/third_party/boringssl-with-bazel/src/crypto/rsa/rsa_print.cc

@@ -0,0 +1,27 @@
+// Copyright 2006-2017 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/rsa.h>
+
+#include <openssl/evp.h>
+
+
+int RSA_print(BIO *bio, const RSA *rsa, int indent) {
+  EVP_PKEY *pkey = EVP_PKEY_new();
+  int ret = pkey != NULL &&
+            EVP_PKEY_set1_RSA(pkey, (RSA *)rsa) &&
+            EVP_PKEY_print_private(bio, pkey, indent, NULL);
+  EVP_PKEY_free(pkey);
+  return ret;
+}

data/third_party/boringssl-with-bazel/src/crypto/sha/sha1.cc

@@ -0,0 +1,52 @@
+// Copyright 2024 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.
+
+#include <openssl/sha.h>
+
+#include <openssl/mem.h>
+
+#include "../fipsmodule/bcm_interface.h"
+
+int SHA1_Init(SHA_CTX *sha) {
+  BCM_sha1_init(sha);
+  return 1;
+}
+
+int SHA1_Update(SHA_CTX *sha, const void *data, size_t len) {
+  BCM_sha1_update(sha, data, len);
+  return 1;
+}
+
+int SHA1_Final(uint8_t out[SHA_DIGEST_LENGTH], SHA_CTX *sha) {
+  BCM_sha1_final(out, sha);
+  return 1;
+}
+
+uint8_t *SHA1(const uint8_t *data, size_t len, uint8_t out[SHA_DIGEST_LENGTH]) {
+  SHA_CTX ctx;
+  BCM_sha1_init(&ctx);
+  BCM_sha1_update(&ctx, data, len);
+  BCM_sha1_final(out, &ctx);
+  OPENSSL_cleanse(&ctx, sizeof(ctx));
+  return out;
+}
+
+void SHA1_Transform(SHA_CTX *sha, const uint8_t block[SHA_CBLOCK]) {
+  BCM_sha1_transform(sha, block);
+}
+
+void CRYPTO_fips_186_2_prf(uint8_t *out, size_t out_len,
+                           const uint8_t xkey[SHA_DIGEST_LENGTH]) {
+  BCM_fips_186_2_prf(out, out_len, xkey);
+}

data/third_party/boringssl-with-bazel/src/crypto/sha/sha256.cc

@@ -0,0 +1,87 @@
+// Copyright 2024 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.
+
+#include <openssl/sha.h>
+
+#include <openssl/mem.h>
+
+#include "../fipsmodule/bcm_interface.h"
+
+
+int SHA224_Init(SHA256_CTX *sha) {
+  BCM_sha224_init(sha);
+  return 1;
+}
+
+int SHA224_Update(SHA256_CTX *sha, const void *data, size_t len) {
+  BCM_sha224_update(sha, data, len);
+  return 1;
+}
+
+int SHA224_Final(uint8_t out[SHA224_DIGEST_LENGTH], SHA256_CTX *sha) {
+  BCM_sha224_final(out, sha);
+  return 1;
+}
+
+uint8_t *SHA224(const uint8_t *data, size_t len,
+                uint8_t out[SHA224_DIGEST_LENGTH]) {
+  SHA256_CTX ctx;
+  BCM_sha224_init(&ctx);
+  BCM_sha224_update(&ctx, data, len);
+  BCM_sha224_final(out, &ctx);
+  OPENSSL_cleanse(&ctx, sizeof(ctx));
+  return out;
+}
+
+int SHA256_Init(SHA256_CTX *sha) {
+  BCM_sha256_init(sha);
+  return 1;
+}
+
+int SHA256_Update(SHA256_CTX *sha, const void *data, size_t len) {
+  BCM_sha256_update(sha, data, len);
+  return 1;
+}
+
+int SHA256_Final(uint8_t out[SHA256_DIGEST_LENGTH], SHA256_CTX *sha) {
+  // TODO(bbe): This overflow check one of the few places a low-level hash
+  // 'final' function can fail. SHA-512 does not have a corresponding check.
+  // The BCM function is infallible and will abort if this is done incorrectly.
+  // we should verify nothing crashes with this removed and eliminate the 0
+  // return.
+  if (sha->md_len > SHA256_DIGEST_LENGTH) {
+    return 0;
+  }
+  BCM_sha256_final(out, sha);
+  return 1;
+}
+
+uint8_t *SHA256(const uint8_t *data, size_t len,
+                uint8_t out[SHA256_DIGEST_LENGTH]) {
+  SHA256_CTX ctx;
+  BCM_sha256_init(&ctx);
+  BCM_sha256_update(&ctx, data, len);
+  BCM_sha256_final(out, &ctx);
+  OPENSSL_cleanse(&ctx, sizeof(ctx));
+  return out;
+}
+
+void SHA256_Transform(SHA256_CTX *sha, const uint8_t block[SHA256_CBLOCK]) {
+  BCM_sha256_transform(sha, block);
+}
+
+void SHA256_TransformBlocks(uint32_t state[8], const uint8_t *data,
+                            size_t num_blocks) {
+  BCM_sha256_transform_blocks(state, data, num_blocks);
+}

data/third_party/boringssl-with-bazel/src/crypto/sha/sha512.cc

@@ -0,0 +1,104 @@
+// Copyright 2024 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.
+
+#include <openssl/sha.h>
+
+#include <openssl/mem.h>
+
+#include "../fipsmodule/bcm_interface.h"
+
+
+int SHA384_Init(SHA512_CTX *sha) {
+  BCM_sha384_init(sha);
+  return 1;
+}
+
+int SHA384_Update(SHA512_CTX *sha, const void *data, size_t len) {
+  BCM_sha384_update(sha, data, len);
+  return 1;
+}
+
+int SHA384_Final(uint8_t out[SHA384_DIGEST_LENGTH], SHA512_CTX *sha) {
+  BCM_sha384_final(out, sha);
+  return 1;
+}
+
+uint8_t *SHA384(const uint8_t *data, size_t len,
+                uint8_t out[SHA384_DIGEST_LENGTH]) {
+  SHA512_CTX ctx;
+  BCM_sha384_init(&ctx);
+  BCM_sha384_update(&ctx, data, len);
+  BCM_sha384_final(out, &ctx);
+  OPENSSL_cleanse(&ctx, sizeof(ctx));
+  return out;
+}
+
+int SHA512_256_Init(SHA512_CTX *sha) {
+  BCM_sha512_256_init(sha);
+  return 1;
+}
+
+int SHA512_256_Update(SHA512_CTX *sha, const void *data, size_t len) {
+  BCM_sha512_256_update(sha, data, len);
+  return 1;
+}
+
+int SHA512_256_Final(uint8_t out[SHA512_256_DIGEST_LENGTH], SHA512_CTX *sha) {
+  BCM_sha512_256_final(out, sha);
+  return 1;
+}
+
+uint8_t *SHA512_256(const uint8_t *data, size_t len,
+                uint8_t out[SHA512_256_DIGEST_LENGTH]) {
+  SHA512_CTX ctx;
+  BCM_sha512_256_init(&ctx);
+  BCM_sha512_256_update(&ctx, data, len);
+  BCM_sha512_256_final(out, &ctx);
+  OPENSSL_cleanse(&ctx, sizeof(ctx));
+  return out;
+}
+
+int SHA512_Init(SHA512_CTX *sha) {
+  BCM_sha512_init(sha);
+  return 1;
+}
+
+int SHA512_Update(SHA512_CTX *sha, const void *data, size_t len) {
+  BCM_sha512_update(sha, data, len);
+  return 1;
+}
+
+int SHA512_Final(uint8_t out[SHA512_DIGEST_LENGTH], SHA512_CTX *sha) {
+  // Historically this function retured failure if passed NULL, even
+  // though other final functions do not.
+  if (out == NULL) {
+    return 0;
+  }
+  BCM_sha512_final(out, sha);
+  return 1;
+}
+
+uint8_t *SHA512(const uint8_t *data, size_t len,
+                uint8_t out[SHA512_DIGEST_LENGTH]) {
+  SHA512_CTX ctx;
+  BCM_sha512_init(&ctx);
+  BCM_sha512_update(&ctx, data, len);
+  BCM_sha512_final(out, &ctx);
+  OPENSSL_cleanse(&ctx, sizeof(ctx));
+  return out;
+}
+
+void SHA512_Transform(SHA512_CTX *sha, const uint8_t block[SHA512_CBLOCK]) {
+  BCM_sha512_transform(sha, block);
+}

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

@@ -1,16 +1,16 @@
-/* Copyright (c) 2019, 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 2019 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.
 
 #include <stdint.h>
 #include <string.h>