grpc 1.69.0 → 1.70.1

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

@@ -1,5 +1,5 @@
-/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
- * project 1999.
+/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
+ * 1999.
  */
 /* ====================================================================
  * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
@@ -67,9 +67,9 @@
 #include <openssl/nid.h>
 #include <openssl/rand.h>
 
-#include "internal.h"
 #include "../bytestring/internal.h"
 #include "../internal.h"
+#include "internal.h"
 
 
 static int pkcs12_encode_password(const char *in, size_t in_len, uint8_t **out,
@@ -85,16 +85,14 @@ static int pkcs12_encode_password(const char *in, size_t in_len, uint8_t **out,
   CBS_init(&cbs, (const uint8_t *)in, in_len);
   while (CBS_len(&cbs) != 0) {
     uint32_t c;
-    if (!CBS_get_utf8(&cbs, &c) ||
-        !CBB_add_ucs2_be(&cbb, c)) {
+    if (!CBS_get_utf8(&cbs, &c) || !CBB_add_ucs2_be(&cbb, c)) {
       OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_INVALID_CHARACTERS);
       goto err;
     }
   }
 
   // Terminate the result with a UCS-2 NUL.
-  if (!CBB_add_ucs2_be(&cbb, 0) ||
-      !CBB_finish(&cbb, out, out_len)) {
+  if (!CBB_add_ucs2_be(&cbb, 0) || !CBB_finish(&cbb, out, out_len)) {
     goto err;
   }
 
@@ -121,105 +119,108 @@ int pkcs12_key_gen(const char *pass, size_t pass_len, const uint8_t *salt,
   EVP_MD_CTX_init(&ctx);
   uint8_t *pass_raw = NULL, *I = NULL;
   size_t pass_raw_len = 0, I_len = 0;
-  // If |pass| is NULL, we use the empty string rather than {0, 0} as the raw
-  // password.
-  if (pass != NULL &&
-      !pkcs12_encode_password(pass, pass_len, &pass_raw, &pass_raw_len)) {
-    goto err;
-  }
-
-  // In the spec, |block_size| is called "v", but measured in bits.
-  size_t block_size = EVP_MD_block_size(md);
-
-  // 1. Construct a string, D (the "diversifier"), by concatenating v/8 copies
-  // of ID.
-  uint8_t D[EVP_MAX_MD_BLOCK_SIZE];
-  OPENSSL_memset(D, id, block_size);
-
-  // 2. Concatenate copies of the salt together to create a string S of length
-  // v(ceiling(s/v)) bits (the final copy of the salt may be truncated to
-  // create S). Note that if the salt is the empty string, then so is S.
-  //
-  // 3. Concatenate copies of the password together to create a string P of
-  // length v(ceiling(p/v)) bits (the final copy of the password may be
-  // truncated to create P).  Note that if the password is the empty string,
-  // then so is P.
-  //
-  // 4. Set I=S||P to be the concatenation of S and P.
-  if (salt_len + block_size - 1 < salt_len ||
-      pass_raw_len + block_size - 1 < pass_raw_len) {
-    OPENSSL_PUT_ERROR(PKCS8, ERR_R_OVERFLOW);
-    goto err;
-  }
-  size_t S_len = block_size * ((salt_len + block_size - 1) / block_size);
-  size_t P_len = block_size * ((pass_raw_len + block_size - 1) / block_size);
-  I_len = S_len + P_len;
-  if (I_len < S_len) {
-    OPENSSL_PUT_ERROR(PKCS8, ERR_R_OVERFLOW);
-    goto err;
-  }
 
-  I = OPENSSL_malloc(I_len);
-  if (I_len != 0 && I == NULL) {
-    goto err;
-  }
+  {
+    // If |pass| is NULL, we use the empty string rather than {0, 0} as the raw
+    // password.
+    if (pass != NULL &&
+        !pkcs12_encode_password(pass, pass_len, &pass_raw, &pass_raw_len)) {
+      goto err;
+    }
 
-  for (size_t i = 0; i < S_len; i++) {
-    I[i] = salt[i % salt_len];
-  }
-  for (size_t i = 0; i < P_len; i++) {
-    I[i + S_len] = pass_raw[i % pass_raw_len];
-  }
+    // In the spec, |block_size| is called "v", but measured in bits.
+    size_t block_size = EVP_MD_block_size(md);
+
+    // 1. Construct a string, D (the "diversifier"), by concatenating v/8 copies
+    // of ID.
+    uint8_t D[EVP_MAX_MD_BLOCK_SIZE];
+    OPENSSL_memset(D, id, block_size);
+
+    // 2. Concatenate copies of the salt together to create a string S of length
+    // v(ceiling(s/v)) bits (the final copy of the salt may be truncated to
+    // create S). Note that if the salt is the empty string, then so is S.
+    //
+    // 3. Concatenate copies of the password together to create a string P of
+    // length v(ceiling(p/v)) bits (the final copy of the password may be
+    // truncated to create P).  Note that if the password is the empty string,
+    // then so is P.
+    //
+    // 4. Set I=S||P to be the concatenation of S and P.
+    if (salt_len + block_size - 1 < salt_len ||
+        pass_raw_len + block_size - 1 < pass_raw_len) {
+      OPENSSL_PUT_ERROR(PKCS8, ERR_R_OVERFLOW);
+      goto err;
+    }
+    size_t S_len = block_size * ((salt_len + block_size - 1) / block_size);
+    size_t P_len = block_size * ((pass_raw_len + block_size - 1) / block_size);
+    I_len = S_len + P_len;
+    if (I_len < S_len) {
+      OPENSSL_PUT_ERROR(PKCS8, ERR_R_OVERFLOW);
+      goto err;
+    }
 
-  while (out_len != 0) {
-    // A. Set A_i=H^r(D||I). (i.e., the r-th hash of D||I,
-    // H(H(H(... H(D||I))))
-    uint8_t A[EVP_MAX_MD_SIZE];
-    unsigned A_len;
-    if (!EVP_DigestInit_ex(&ctx, md, NULL) ||
-        !EVP_DigestUpdate(&ctx, D, block_size) ||
-        !EVP_DigestUpdate(&ctx, I, I_len) ||
-        !EVP_DigestFinal_ex(&ctx, A, &A_len)) {
+    I = reinterpret_cast<uint8_t *>(OPENSSL_malloc(I_len));
+    if (I_len != 0 && I == NULL) {
       goto err;
     }
-    for (uint32_t iter = 1; iter < iterations; iter++) {
+
+    for (size_t i = 0; i < S_len; i++) {
+      I[i] = salt[i % salt_len];
+    }
+    for (size_t i = 0; i < P_len; i++) {
+      I[i + S_len] = pass_raw[i % pass_raw_len];
+    }
+
+    while (out_len != 0) {
+      // A. Set A_i=H^r(D||I). (i.e., the r-th hash of D||I,
+      // H(H(H(... H(D||I))))
+      uint8_t A[EVP_MAX_MD_SIZE];
+      unsigned A_len;
       if (!EVP_DigestInit_ex(&ctx, md, NULL) ||
-          !EVP_DigestUpdate(&ctx, A, A_len) ||
+          !EVP_DigestUpdate(&ctx, D, block_size) ||
+          !EVP_DigestUpdate(&ctx, I, I_len) ||
           !EVP_DigestFinal_ex(&ctx, A, &A_len)) {
         goto err;
       }
-    }
+      for (uint32_t iter = 1; iter < iterations; iter++) {
+        if (!EVP_DigestInit_ex(&ctx, md, NULL) ||
+            !EVP_DigestUpdate(&ctx, A, A_len) ||
+            !EVP_DigestFinal_ex(&ctx, A, &A_len)) {
+          goto err;
+        }
+      }
 
-    size_t todo = out_len < A_len ? out_len : A_len;
-    OPENSSL_memcpy(out, A, todo);
-    out += todo;
-    out_len -= todo;
-    if (out_len == 0) {
-      break;
-    }
+      size_t todo = out_len < A_len ? out_len : A_len;
+      OPENSSL_memcpy(out, A, todo);
+      out += todo;
+      out_len -= todo;
+      if (out_len == 0) {
+        break;
+      }
 
-    // B. Concatenate copies of A_i to create a string B of length v bits (the
-    // final copy of A_i may be truncated to create B).
-    uint8_t B[EVP_MAX_MD_BLOCK_SIZE];
-    for (size_t i = 0; i < block_size; i++) {
-      B[i] = A[i % A_len];
-    }
+      // B. Concatenate copies of A_i to create a string B of length v bits (the
+      // final copy of A_i may be truncated to create B).
+      uint8_t B[EVP_MAX_MD_BLOCK_SIZE];
+      for (size_t i = 0; i < block_size; i++) {
+        B[i] = A[i % A_len];
+      }
 
-    // C. Treating I as a concatenation I_0, I_1, ..., I_(k-1) of v-bit blocks,
-    // where k=ceiling(s/v)+ceiling(p/v), modify I by setting I_j=(I_j+B+1) mod
-    // 2^v for each j.
-    assert(I_len % block_size == 0);
-    for (size_t i = 0; i < I_len; i += block_size) {
-      unsigned carry = 1;
-      for (size_t j = block_size - 1; j < block_size; j--) {
-        carry += I[i + j] + B[j];
-        I[i + j] = (uint8_t)carry;
-        carry >>= 8;
+      // C. Treating I as a concatenation I_0, I_1, ..., I_(k-1) of v-bit
+      // blocks, where k=ceiling(s/v)+ceiling(p/v), modify I by setting
+      // I_j=(I_j+B+1) mod 2^v for each j.
+      assert(I_len % block_size == 0);
+      for (size_t i = 0; i < I_len; i += block_size) {
+        unsigned carry = 1;
+        for (size_t j = block_size - 1; j < block_size; j--) {
+          carry += I[i + j] + B[j];
+          I[i + j] = (uint8_t)carry;
+          carry >>= 8;
+        }
       }
     }
-  }
 
-  ret = 1;
+    ret = 1;
+  }
 
 err:
   OPENSSL_free(I);
@@ -260,8 +261,7 @@ static int pkcs12_pbe_decrypt_init(const struct pbe_suite *suite,
   if (!CBS_get_asn1(param, &pbe_param, CBS_ASN1_SEQUENCE) ||
       !CBS_get_asn1(&pbe_param, &salt, CBS_ASN1_OCTETSTRING) ||
       !CBS_get_asn1_uint64(&pbe_param, &iterations) ||
-      CBS_len(&pbe_param) != 0 ||
-      CBS_len(param) != 0) {
+      CBS_len(&pbe_param) != 0 || CBS_len(param) != 0) {
     OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_DECODE_ERROR);
     return 0;
   }
@@ -319,8 +319,7 @@ static const struct pbe_suite *get_pkcs12_pbe_suite(int pbe_nid) {
   for (unsigned i = 0; i < OPENSSL_ARRAY_SIZE(kBuiltinPBE); i++) {
     if (kBuiltinPBE[i].pbe_nid == pbe_nid &&
         // If |cipher_func| or |md_func| are missing, this is a PBES2 scheme.
-        kBuiltinPBE[i].cipher_func != NULL &&
-        kBuiltinPBE[i].md_func != NULL) {
+        kBuiltinPBE[i].cipher_func != NULL && kBuiltinPBE[i].md_func != NULL) {
       return &kBuiltinPBE[i];
     }
   }
@@ -346,8 +345,7 @@ int pkcs12_pbe_encrypt_init(CBB *out, EVP_CIPHER_CTX *ctx, int alg,
       !CBB_add_asn1(&algorithm, &param, CBS_ASN1_SEQUENCE) ||
       !CBB_add_asn1(&param, &salt_cbb, CBS_ASN1_OCTETSTRING) ||
       !CBB_add_bytes(&salt_cbb, salt, salt_len) ||
-      !CBB_add_asn1_uint64(&param, iterations) ||
-      !CBB_flush(out)) {
+      !CBB_add_asn1_uint64(&param, iterations) || !CBB_flush(out)) {
     return 0;
   }
 
@@ -359,17 +357,18 @@ int pkcs8_pbe_decrypt(uint8_t **out, size_t *out_len, CBS *algorithm,
                       const char *pass, size_t pass_len, const uint8_t *in,
                       size_t in_len) {
   int ret = 0;
-  uint8_t *buf = NULL;;
+  uint8_t *buf = NULL;
+  ;
   EVP_CIPHER_CTX ctx;
   EVP_CIPHER_CTX_init(&ctx);
 
   CBS obj;
+  const struct pbe_suite *suite = NULL;
   if (!CBS_get_asn1(algorithm, &obj, CBS_ASN1_OBJECT)) {
     OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_DECODE_ERROR);
     goto err;
   }
 
-  const struct pbe_suite *suite = NULL;
   for (unsigned i = 0; i < OPENSSL_ARRAY_SIZE(kBuiltinPBE); i++) {
     if (CBS_mem_equal(&obj, kBuiltinPBE[i].oid, kBuiltinPBE[i].oid_len)) {
       suite = &kBuiltinPBE[i];
@@ -386,7 +385,7 @@ int pkcs8_pbe_decrypt(uint8_t **out, size_t *out_len, CBS *algorithm,
     goto err;
   }
 
-  buf = OPENSSL_malloc(in_len);
+  buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(in_len));
   if (buf == NULL) {
     goto err;
   }
@@ -450,75 +449,77 @@ int PKCS8_marshal_encrypted_private_key(CBB *out, int pbe_nid,
   EVP_CIPHER_CTX ctx;
   EVP_CIPHER_CTX_init(&ctx);
 
-  // Generate a random salt if necessary.
-  if (salt == NULL) {
-    if (salt_len == 0) {
-      salt_len = PKCS5_SALT_LEN;
-    }
+  {
+    // Generate a random salt if necessary.
+    if (salt == NULL) {
+      if (salt_len == 0) {
+        salt_len = PKCS5_SALT_LEN;
+      }
 
-    salt_buf = OPENSSL_malloc(salt_len);
-    if (salt_buf == NULL ||
-        !RAND_bytes(salt_buf, salt_len)) {
-      goto err;
+      salt_buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(salt_len));
+      if (salt_buf == NULL || !RAND_bytes(salt_buf, salt_len)) {
+        goto err;
+      }
+
+      salt = salt_buf;
     }
 
-    salt = salt_buf;
-  }
+    if (iterations <= 0) {
+      iterations = PKCS12_DEFAULT_ITER;
+    }
 
-  if (iterations <= 0) {
-    iterations = PKCS12_DEFAULT_ITER;
-  }
+    // Serialize the input key.
+    CBB plaintext_cbb;
+    if (!CBB_init(&plaintext_cbb, 128) ||
+        !EVP_marshal_private_key(&plaintext_cbb, pkey) ||
+        !CBB_finish(&plaintext_cbb, &plaintext, &plaintext_len)) {
+      CBB_cleanup(&plaintext_cbb);
+      goto err;
+    }
 
-  // Serialize the input key.
-  CBB plaintext_cbb;
-  if (!CBB_init(&plaintext_cbb, 128) ||
-      !EVP_marshal_private_key(&plaintext_cbb, pkey) ||
-      !CBB_finish(&plaintext_cbb, &plaintext, &plaintext_len)) {
-    CBB_cleanup(&plaintext_cbb);
-    goto err;
-  }
+    CBB epki;
+    if (!CBB_add_asn1(out, &epki, CBS_ASN1_SEQUENCE)) {
+      goto err;
+    }
 
-  CBB epki;
-  if (!CBB_add_asn1(out, &epki, CBS_ASN1_SEQUENCE)) {
-    goto err;
-  }
+    // TODO(davidben): OpenSSL has since extended |pbe_nid| to control either
+    // the PBES1 scheme or the PBES2 PRF. E.g. passing |NID_hmacWithSHA256| will
+    // select PBES2 with HMAC-SHA256 as the PRF. Implement this if anything uses
+    // it. See 5693a30813a031d3921a016a870420e7eb93ec90 in OpenSSL.
+    int alg_ok;
+    if (pbe_nid == -1) {
+      alg_ok =
+          PKCS5_pbe2_encrypt_init(&epki, &ctx, cipher, (uint32_t)iterations,
+                                  pass, pass_len, salt, salt_len);
+    } else {
+      alg_ok =
+          pkcs12_pbe_encrypt_init(&epki, &ctx, pbe_nid, (uint32_t)iterations,
+                                  pass, pass_len, salt, salt_len);
+    }
+    if (!alg_ok) {
+      goto err;
+    }
 
-  // TODO(davidben): OpenSSL has since extended |pbe_nid| to control either the
-  // PBES1 scheme or the PBES2 PRF. E.g. passing |NID_hmacWithSHA256| will
-  // select PBES2 with HMAC-SHA256 as the PRF. Implement this if anything uses
-  // it. See 5693a30813a031d3921a016a870420e7eb93ec90 in OpenSSL.
-  int alg_ok;
-  if (pbe_nid == -1) {
-    alg_ok = PKCS5_pbe2_encrypt_init(&epki, &ctx, cipher, (uint32_t)iterations,
-                                     pass, pass_len, salt, salt_len);
-  } else {
-    alg_ok = pkcs12_pbe_encrypt_init(&epki, &ctx, pbe_nid, (uint32_t)iterations,
-                                     pass, pass_len, salt, salt_len);
-  }
-  if (!alg_ok) {
-    goto err;
-  }
+    size_t max_out = plaintext_len + EVP_CIPHER_CTX_block_size(&ctx);
+    if (max_out < plaintext_len) {
+      OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_TOO_LONG);
+      goto err;
+    }
 
-  size_t max_out = plaintext_len + EVP_CIPHER_CTX_block_size(&ctx);
-  if (max_out < plaintext_len) {
-    OPENSSL_PUT_ERROR(PKCS8, PKCS8_R_TOO_LONG);
-    goto err;
-  }
+    CBB ciphertext;
+    uint8_t *ptr;
+    int n1, n2;
+    if (!CBB_add_asn1(&epki, &ciphertext, CBS_ASN1_OCTETSTRING) ||
+        !CBB_reserve(&ciphertext, &ptr, max_out) ||
+        !EVP_CipherUpdate(&ctx, ptr, &n1, plaintext, plaintext_len) ||
+        !EVP_CipherFinal_ex(&ctx, ptr + n1, &n2) ||
+        !CBB_did_write(&ciphertext, n1 + n2) || !CBB_flush(out)) {
+      goto err;
+    }
 
-  CBB ciphertext;
-  uint8_t *ptr;
-  int n1, n2;
-  if (!CBB_add_asn1(&epki, &ciphertext, CBS_ASN1_OCTETSTRING) ||
-      !CBB_reserve(&ciphertext, &ptr, max_out) ||
-      !EVP_CipherUpdate(&ctx, ptr, &n1, plaintext, plaintext_len) ||
-      !EVP_CipherFinal_ex(&ctx, ptr + n1, &n2) ||
-      !CBB_did_write(&ciphertext, n1 + n2) ||
-      !CBB_flush(out)) {
-    goto err;
+    ret = 1;
   }
 
-  ret = 1;
-
 err:
   OPENSSL_free(plaintext);
   OPENSSL_free(salt_buf);