grpc 1.69.0 → 1.70.1

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2020, Google Inc.
+/* Copyright 2020 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -134,13 +134,11 @@ static int cbb_add_prefixed_point(CBB *out, const EC_GROUP *group,
   if (prefix_point) {
     CBB child;
     if (!CBB_add_u16_length_prefixed(out, &child) ||
-        !point_to_cbb(&child, group, point) ||
-        !CBB_flush(out)) {
+        !point_to_cbb(&child, group, point) || !CBB_flush(out)) {
       return 0;
     }
   } else {
-    if (!point_to_cbb(out, group, point) ||
-        !CBB_flush(out)) {
+    if (!point_to_cbb(out, group, point) || !CBB_flush(out)) {
       return 0;
     }
   }
@@ -186,10 +184,10 @@ static int pmbtoken_compute_keys(const PMBTOKEN_METHOD *method,
                                  const EC_SCALAR *xs, const EC_SCALAR *ys) {
   const EC_GROUP *group = method->group;
   EC_JACOBIAN pub[3];
-  if (!ec_point_mul_scalar_precomp(group, &pub[0], &method->g_precomp,
-                                   x0, &method->h_precomp, y0, NULL, NULL) ||
-      !ec_point_mul_scalar_precomp(group, &pub[1], &method->g_precomp,
-                                   x1, &method->h_precomp, y1, NULL, NULL) ||
+  if (!ec_point_mul_scalar_precomp(group, &pub[0], &method->g_precomp, x0,
+                                   &method->h_precomp, y0, NULL, NULL) ||
+      !ec_point_mul_scalar_precomp(group, &pub[1], &method->g_precomp, x1,
+                                   &method->h_precomp, y1, NULL, NULL) ||
       !ec_point_mul_scalar_precomp(method->group, &pub[2], &method->g_precomp,
                                    xs, &method->h_precomp, ys, NULL, NULL)) {
     OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_KEYGEN_FAILURE);
@@ -326,14 +324,16 @@ static STACK_OF(TRUST_TOKEN_PRETOKEN) *pmbtoken_blind(
   SHA512_CTX hash_ctx;
 
   const EC_GROUP *group = method->group;
-  STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens = sk_TRUST_TOKEN_PRETOKEN_new_null();
+  STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens =
+      sk_TRUST_TOKEN_PRETOKEN_new_null();
   if (pretokens == NULL) {
     goto err;
   }
 
   for (size_t i = 0; i < count; i++) {
     // Insert |pretoken| into |pretokens| early to simplify error-handling.
-    TRUST_TOKEN_PRETOKEN *pretoken = OPENSSL_malloc(sizeof(TRUST_TOKEN_PRETOKEN));
+    TRUST_TOKEN_PRETOKEN *pretoken = reinterpret_cast<TRUST_TOKEN_PRETOKEN *>(
+        OPENSSL_malloc(sizeof(TRUST_TOKEN_PRETOKEN)));
     if (pretoken == NULL ||
         !sk_TRUST_TOKEN_PRETOKEN_push(pretokens, pretoken)) {
       TRUST_TOKEN_PRETOKEN_free(pretoken);
@@ -424,8 +424,7 @@ static int hash_c_dleq(const PMBTOKEN_METHOD *method, EC_SCALAR *out,
       !point_to_cbb(&cbb, method->group, S) ||
       !point_to_cbb(&cbb, method->group, W) ||
       !point_to_cbb(&cbb, method->group, K0) ||
-      !point_to_cbb(&cbb, method->group, K1) ||
-      !CBB_finish(&cbb, &buf, &len) ||
+      !point_to_cbb(&cbb, method->group, K1) || !CBB_finish(&cbb, &buf, &len) ||
       !method->hash_c(method->group, out, buf, len)) {
     goto err;
   }
@@ -492,8 +491,7 @@ static int hash_c_batch(const PMBTOKEN_METHOD *method, EC_SCALAR *out,
   if (!CBB_init(&cbb, 0) ||
       !CBB_add_bytes(&cbb, kDLEQBatchLabel, sizeof(kDLEQBatchLabel)) ||
       !CBB_add_bytes(&cbb, CBB_data(points), CBB_len(points)) ||
-      !CBB_add_u16(&cbb, (uint16_t)index) ||
-      !CBB_finish(&cbb, &buf, &len) ||
+      !CBB_add_u16(&cbb, (uint16_t)index) || !CBB_finish(&cbb, &buf, &len) ||
       !method->hash_c(method->group, out, buf, len)) {
     goto err;
   }
@@ -537,7 +535,7 @@ static int dleq_generate(const PMBTOKEN_METHOD *method, CBB *cbb,
 
   // Setup the DLEQ proof.
   EC_SCALAR ks0, ks1;
-  if (// ks0, ks1 <- Zp
+  if (  // ks0, ks1 <- Zp
       !ec_random_nonzero_scalar(group, &ks0, kDefaultAdditionalData) ||
       !ec_random_nonzero_scalar(group, &ks1, kDefaultAdditionalData) ||
       // Ks = ks0*(G;T) + ks1*(H;S)
@@ -561,7 +559,7 @@ static int dleq_generate(const PMBTOKEN_METHOD *method, CBB *cbb,
                     &priv->pub1_precomp);
 
   EC_SCALAR k0, k1, minus_co, uo, vo;
-  if (// k0, k1 <- Zp
+  if (  // k0, k1 <- Zp
       !ec_random_nonzero_scalar(group, &k0, kDefaultAdditionalData) ||
       !ec_random_nonzero_scalar(group, &k1, kDefaultAdditionalData) ||
       // Kb = k0*(G;T) + k1*(H;S)
@@ -626,8 +624,7 @@ static int dleq_generate(const PMBTOKEN_METHOD *method, CBB *cbb,
   ec_scalar_add(group, &vs, &ks1, &vs);
 
   // Store DLEQ2 proof in transcript.
-  if (!scalar_to_cbb(cbb, group, &cs) ||
-      !scalar_to_cbb(cbb, group, &us) ||
+  if (!scalar_to_cbb(cbb, group, &cs) || !scalar_to_cbb(cbb, group, &us) ||
       !scalar_to_cbb(cbb, group, &vs)) {
     return 0;
   }
@@ -658,12 +655,9 @@ static int dleq_generate(const PMBTOKEN_METHOD *method, CBB *cbb,
   ec_scalar_select(group, &v1, mask, &vb, &vo);
 
   // Store DLEQOR2 proof in transcript.
-  if (!scalar_to_cbb(cbb, group, &c0) ||
-      !scalar_to_cbb(cbb, group, &c1) ||
-      !scalar_to_cbb(cbb, group, &u0) ||
-      !scalar_to_cbb(cbb, group, &u1) ||
-      !scalar_to_cbb(cbb, group, &v0) ||
-      !scalar_to_cbb(cbb, group, &v1)) {
+  if (!scalar_to_cbb(cbb, group, &c0) || !scalar_to_cbb(cbb, group, &c1) ||
+      !scalar_to_cbb(cbb, group, &u0) || !scalar_to_cbb(cbb, group, &u1) ||
+      !scalar_to_cbb(cbb, group, &v0) || !scalar_to_cbb(cbb, group, &v1)) {
     return 0;
   }
 
@@ -699,8 +693,7 @@ static int dleq_verify(const PMBTOKEN_METHOD *method, CBS *cbs,
 
   // Decode the DLEQ proof.
   EC_SCALAR cs, us, vs;
-  if (!scalar_from_cbs(cbs, group, &cs) ||
-      !scalar_from_cbs(cbs, group, &us) ||
+  if (!scalar_from_cbs(cbs, group, &cs) || !scalar_from_cbs(cbs, group, &us) ||
       !scalar_from_cbs(cbs, group, &vs)) {
     OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE);
     return 0;
@@ -720,12 +713,9 @@ static int dleq_verify(const PMBTOKEN_METHOD *method, CBS *cbs,
 
   // Decode the DLEQOR proof.
   EC_SCALAR c0, c1, u0, u1, v0, v1;
-  if (!scalar_from_cbs(cbs, group, &c0) ||
-      !scalar_from_cbs(cbs, group, &c1) ||
-      !scalar_from_cbs(cbs, group, &u0) ||
-      !scalar_from_cbs(cbs, group, &u1) ||
-      !scalar_from_cbs(cbs, group, &v0) ||
-      !scalar_from_cbs(cbs, group, &v1)) {
+  if (!scalar_from_cbs(cbs, group, &c0) || !scalar_from_cbs(cbs, group, &c1) ||
+      !scalar_from_cbs(cbs, group, &u0) || !scalar_from_cbs(cbs, group, &u1) ||
+      !scalar_from_cbs(cbs, group, &v0) || !scalar_from_cbs(cbs, group, &v1)) {
     OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE);
     return 0;
   }
@@ -736,7 +726,7 @@ static int dleq_verify(const PMBTOKEN_METHOD *method, CBS *cbs,
   EC_SCALAR minus_c0, minus_c1;
   ec_scalar_neg(group, &minus_c0, &c0);
   ec_scalar_neg(group, &minus_c1, &c1);
-  if (// K0 = u0*(G;T) + v0*(H;S) - c0*(pub0;W)
+  if (  // K0 = u0*(G;T) + v0*(H;S) - c0*(pub0;W)
       !mul_public_3(group, &jacobians[idx_K00], g, &u0, &method->h, &v0, &pub0,
                     &minus_c0) ||
       !mul_public_3(group, &jacobians[idx_K01], T, &u0, S, &v0, W, &minus_c0) ||
@@ -800,120 +790,124 @@ static int pmbtoken_sign(const PMBTOKEN_METHOD *method,
   }
 
   int ret = 0;
-  EC_JACOBIAN *Tps = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Sps = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Wps = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Wsps = OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN));
-  EC_SCALAR *es = OPENSSL_calloc(num_to_issue, sizeof(EC_SCALAR));
+  EC_JACOBIAN *Tps = reinterpret_cast<EC_JACOBIAN *>(
+      OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN)));
+  EC_JACOBIAN *Sps = reinterpret_cast<EC_JACOBIAN *>(
+      OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN)));
+  EC_JACOBIAN *Wps = reinterpret_cast<EC_JACOBIAN *>(
+      OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN)));
+  EC_JACOBIAN *Wsps = reinterpret_cast<EC_JACOBIAN *>(
+      OPENSSL_calloc(num_to_issue, sizeof(EC_JACOBIAN)));
+  EC_SCALAR *es = reinterpret_cast<EC_SCALAR *>(
+      OPENSSL_calloc(num_to_issue, sizeof(EC_SCALAR)));
   CBB batch_cbb;
   CBB_zero(&batch_cbb);
-  if (!Tps ||
-      !Sps ||
-      !Wps ||
-      !Wsps ||
-      !es ||
-      !CBB_init(&batch_cbb, 0) ||
-      !point_to_cbb(&batch_cbb, method->group, &key->pubs) ||
-      !point_to_cbb(&batch_cbb, method->group, &key->pub0) ||
-      !point_to_cbb(&batch_cbb, method->group, &key->pub1)) {
-    goto err;
-  }
 
-  for (size_t i = 0; i < num_to_issue; i++) {
-    EC_AFFINE Tp_affine;
-    EC_JACOBIAN Tp;
-    if (!cbs_get_prefixed_point(cbs, group, &Tp_affine, method->prefix_point)) {
-      OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE);
+  {
+    if (!Tps || !Sps || !Wps || !Wsps || !es || !CBB_init(&batch_cbb, 0) ||
+        !point_to_cbb(&batch_cbb, method->group, &key->pubs) ||
+        !point_to_cbb(&batch_cbb, method->group, &key->pub0) ||
+        !point_to_cbb(&batch_cbb, method->group, &key->pub1)) {
       goto err;
     }
-    ec_affine_to_jacobian(group, &Tp, &Tp_affine);
 
-    EC_SCALAR xb, yb;
-    BN_ULONG mask = ((BN_ULONG)0) - (private_metadata & 1);
-    ec_scalar_select(group, &xb, mask, &key->x1, &key->x0);
-    ec_scalar_select(group, &yb, mask, &key->y1, &key->y0);
+    for (size_t i = 0; i < num_to_issue; i++) {
+      EC_AFFINE Tp_affine;
+      EC_JACOBIAN Tp;
+      if (!cbs_get_prefixed_point(cbs, group, &Tp_affine,
+                                  method->prefix_point)) {
+        OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE);
+        goto err;
+      }
+      ec_affine_to_jacobian(group, &Tp, &Tp_affine);
+
+      EC_SCALAR xb, yb;
+      BN_ULONG mask = ((BN_ULONG)0) - (private_metadata & 1);
+      ec_scalar_select(group, &xb, mask, &key->x1, &key->x0);
+      ec_scalar_select(group, &yb, mask, &key->y1, &key->y0);
+
+      uint8_t s[TRUST_TOKEN_NONCE_SIZE];
+      RAND_bytes(s, TRUST_TOKEN_NONCE_SIZE);
+      // The |jacobians| and |affines| contain Sp, Wp, and Wsp.
+      EC_JACOBIAN jacobians[3];
+      EC_AFFINE affines[3];
+      if (!method->hash_s(group, &jacobians[0], &Tp_affine, s) ||
+          !ec_point_mul_scalar_batch(group, &jacobians[1], &Tp, &xb,
+                                     &jacobians[0], &yb, NULL, NULL) ||
+          !ec_point_mul_scalar_batch(group, &jacobians[2], &Tp, &key->xs,
+                                     &jacobians[0], &key->ys, NULL, NULL) ||
+          !ec_jacobian_to_affine_batch(group, affines, jacobians, 3) ||
+          !CBB_add_bytes(cbb, s, TRUST_TOKEN_NONCE_SIZE) ||
+          !cbb_add_prefixed_point(cbb, group, &affines[1],
+                                  method->prefix_point) ||
+          !cbb_add_prefixed_point(cbb, group, &affines[2],
+                                  method->prefix_point)) {
+        goto err;
+      }
+
+      if (!point_to_cbb(&batch_cbb, group, &Tp_affine) ||
+          !point_to_cbb(&batch_cbb, group, &affines[0]) ||
+          !point_to_cbb(&batch_cbb, group, &affines[1]) ||
+          !point_to_cbb(&batch_cbb, group, &affines[2])) {
+        goto err;
+      }
+      Tps[i] = Tp;
+      Sps[i] = jacobians[0];
+      Wps[i] = jacobians[1];
+      Wsps[i] = jacobians[2];
+
+      if (!CBB_flush(cbb)) {
+        goto err;
+      }
+    }
 
-    uint8_t s[TRUST_TOKEN_NONCE_SIZE];
-    RAND_bytes(s, TRUST_TOKEN_NONCE_SIZE);
-    // The |jacobians| and |affines| contain Sp, Wp, and Wsp.
-    EC_JACOBIAN jacobians[3];
-    EC_AFFINE affines[3];
-    if (!method->hash_s(group, &jacobians[0], &Tp_affine, s) ||
-        !ec_point_mul_scalar_batch(group, &jacobians[1], &Tp, &xb,
-                                   &jacobians[0], &yb, NULL, NULL) ||
-        !ec_point_mul_scalar_batch(group, &jacobians[2], &Tp, &key->xs,
-                                   &jacobians[0], &key->ys, NULL, NULL) ||
-        !ec_jacobian_to_affine_batch(group, affines, jacobians, 3) ||
-        !CBB_add_bytes(cbb, s, TRUST_TOKEN_NONCE_SIZE) ||
-        !cbb_add_prefixed_point(cbb, group, &affines[1],
-                                method->prefix_point) ||
-        !cbb_add_prefixed_point(cbb, group, &affines[2],
-                                method->prefix_point)) {
-      goto err;
+    // The DLEQ batching construction is described in appendix B of
+    // https://eprint.iacr.org/2020/072/20200324:214215. Note the additional
+    // computations all act on public inputs.
+    for (size_t i = 0; i < num_to_issue; i++) {
+      if (!hash_c_batch(method, &es[i], &batch_cbb, i)) {
+        goto err;
+      }
     }
 
-    if (!point_to_cbb(&batch_cbb, group, &Tp_affine) ||
-        !point_to_cbb(&batch_cbb, group, &affines[0]) ||
-        !point_to_cbb(&batch_cbb, group, &affines[1]) ||
-        !point_to_cbb(&batch_cbb, group, &affines[2])) {
+    EC_JACOBIAN Tp_batch, Sp_batch, Wp_batch, Wsp_batch;
+    if (!ec_point_mul_scalar_public_batch(group, &Tp_batch,
+                                          /*g_scalar=*/NULL, Tps, es,
+                                          num_to_issue) ||
+        !ec_point_mul_scalar_public_batch(group, &Sp_batch,
+                                          /*g_scalar=*/NULL, Sps, es,
+                                          num_to_issue) ||
+        !ec_point_mul_scalar_public_batch(group, &Wp_batch,
+                                          /*g_scalar=*/NULL, Wps, es,
+                                          num_to_issue) ||
+        !ec_point_mul_scalar_public_batch(group, &Wsp_batch,
+                                          /*g_scalar=*/NULL, Wsps, es,
+                                          num_to_issue)) {
       goto err;
     }
-    Tps[i] = Tp;
-    Sps[i] = jacobians[0];
-    Wps[i] = jacobians[1];
-    Wsps[i] = jacobians[2];
 
-    if (!CBB_flush(cbb)) {
+    CBB proof;
+    if (!CBB_add_u16_length_prefixed(cbb, &proof) ||
+        !dleq_generate(method, &proof, key, &Tp_batch, &Sp_batch, &Wp_batch,
+                       &Wsp_batch, private_metadata) ||
+        !CBB_flush(cbb)) {
       goto err;
     }
-  }
 
-  // The DLEQ batching construction is described in appendix B of
-  // https://eprint.iacr.org/2020/072/20200324:214215. Note the additional
-  // computations all act on public inputs.
-  for (size_t i = 0; i < num_to_issue; i++) {
-    if (!hash_c_batch(method, &es[i], &batch_cbb, i)) {
+    // Skip over any unused requests.
+    size_t point_len = ec_point_byte_len(group, POINT_CONVERSION_UNCOMPRESSED);
+    size_t token_len = point_len;
+    if (method->prefix_point) {
+      token_len += 2;
+    }
+    if (!CBS_skip(cbs, token_len * (num_requested - num_to_issue))) {
+      OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE);
       goto err;
     }
-  }
 
-  EC_JACOBIAN Tp_batch, Sp_batch, Wp_batch, Wsp_batch;
-  if (!ec_point_mul_scalar_public_batch(group, &Tp_batch,
-                                        /*g_scalar=*/NULL, Tps, es,
-                                        num_to_issue) ||
-      !ec_point_mul_scalar_public_batch(group, &Sp_batch,
-                                        /*g_scalar=*/NULL, Sps, es,
-                                        num_to_issue) ||
-      !ec_point_mul_scalar_public_batch(group, &Wp_batch,
-                                        /*g_scalar=*/NULL, Wps, es,
-                                        num_to_issue) ||
-      !ec_point_mul_scalar_public_batch(group, &Wsp_batch,
-                                        /*g_scalar=*/NULL, Wsps, es,
-                                        num_to_issue)) {
-    goto err;
-  }
-
-  CBB proof;
-  if (!CBB_add_u16_length_prefixed(cbb, &proof) ||
-      !dleq_generate(method, &proof, key, &Tp_batch, &Sp_batch, &Wp_batch,
-                     &Wsp_batch, private_metadata) ||
-      !CBB_flush(cbb)) {
-    goto err;
-  }
-
-  // Skip over any unused requests.
-  size_t point_len = ec_point_byte_len(group, POINT_CONVERSION_UNCOMPRESSED);
-  size_t token_len = point_len;
-  if (method->prefix_point) {
-    token_len += 2;
-  }
-  if (!CBS_skip(cbs, token_len * (num_requested - num_to_issue))) {
-    OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE);
-    goto err;
+    ret = 1;
   }
 
-  ret = 1;
-
 err:
   OPENSSL_free(Tps);
   OPENSSL_free(Sps);
@@ -936,20 +930,20 @@ static STACK_OF(TRUST_TOKEN) *pmbtoken_unblind(
 
   int ok = 0;
   STACK_OF(TRUST_TOKEN) *ret = sk_TRUST_TOKEN_new_null();
-  EC_JACOBIAN *Tps = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Sps = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Wps = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
-  EC_JACOBIAN *Wsps = OPENSSL_calloc(count, sizeof(EC_JACOBIAN));
-  EC_SCALAR *es = OPENSSL_calloc(count, sizeof(EC_SCALAR));
+  EC_JACOBIAN *Tps = reinterpret_cast<EC_JACOBIAN *>(
+      OPENSSL_calloc(count, sizeof(EC_JACOBIAN)));
+  EC_JACOBIAN *Sps = reinterpret_cast<EC_JACOBIAN *>(
+      OPENSSL_calloc(count, sizeof(EC_JACOBIAN)));
+  EC_JACOBIAN *Wps = reinterpret_cast<EC_JACOBIAN *>(
+      OPENSSL_calloc(count, sizeof(EC_JACOBIAN)));
+  EC_JACOBIAN *Wsps = reinterpret_cast<EC_JACOBIAN *>(
+      OPENSSL_calloc(count, sizeof(EC_JACOBIAN)));
+  EC_SCALAR *es =
+      reinterpret_cast<EC_SCALAR *>(OPENSSL_calloc(count, sizeof(EC_SCALAR)));
   CBB batch_cbb;
   CBB_zero(&batch_cbb);
-  if (ret == NULL ||
-      Tps == NULL ||
-      Sps == NULL ||
-      Wps == NULL ||
-      Wsps == NULL ||
-      es == NULL ||
-      !CBB_init(&batch_cbb, 0) ||
+  if (ret == NULL || Tps == NULL || Sps == NULL || Wps == NULL ||
+      Wsps == NULL || es == NULL || !CBB_init(&batch_cbb, 0) ||
       !point_to_cbb(&batch_cbb, method->group, &key->pubs) ||
       !point_to_cbb(&batch_cbb, method->group, &key->pub0) ||
       !point_to_cbb(&batch_cbb, method->group, &key->pub1)) {
@@ -1018,8 +1012,7 @@ static STACK_OF(TRUST_TOKEN) *pmbtoken_unblind(
     TRUST_TOKEN *token =
         TRUST_TOKEN_new(CBB_data(&token_cbb), CBB_len(&token_cbb));
     CBB_cleanup(&token_cbb);
-    if (token == NULL ||
-        !sk_TRUST_TOKEN_push(ret, token)) {
+    if (token == NULL || !sk_TRUST_TOKEN_push(ret, token)) {
       TRUST_TOKEN_free(token);
       goto err;
     }
@@ -1163,8 +1156,7 @@ static int pmbtoken_exp1_hash_s(const EC_GROUP *group, EC_JACOBIAN *out,
   CBB cbb;
   uint8_t *buf = NULL;
   size_t len;
-  if (!CBB_init(&cbb, 0) ||
-      !point_to_cbb(&cbb, group, t) ||
+  if (!CBB_init(&cbb, 0) || !point_to_cbb(&cbb, group, t) ||
       !CBB_add_bytes(&cbb, s, TRUST_TOKEN_NONCE_SIZE) ||
       !CBB_finish(&cbb, &buf, &len) ||
       !ec_hash_to_curve_p384_xmd_sha512_sswu_draft07(
@@ -1336,8 +1328,7 @@ static int pmbtoken_exp2_hash_s(const EC_GROUP *group, EC_JACOBIAN *out,
   CBB cbb;
   uint8_t *buf = NULL;
   size_t len;
-  if (!CBB_init(&cbb, 0) ||
-      !point_to_cbb(&cbb, group, t) ||
+  if (!CBB_init(&cbb, 0) || !point_to_cbb(&cbb, group, t) ||
       !CBB_add_bytes(&cbb, s, TRUST_TOKEN_NONCE_SIZE) ||
       !CBB_finish(&cbb, &buf, &len) ||
       !ec_hash_to_curve_p384_xmd_sha512_sswu_draft07(
@@ -1383,8 +1374,7 @@ static void pmbtoken_exp2_init_method_impl(void) {
       0x1c, 0x2c, 0x72, 0x25, 0xf0, 0x4a, 0x45, 0x23, 0x2d, 0x57, 0x93,
       0x0e, 0xb2, 0x55, 0xb8, 0x57, 0x25, 0x4c, 0x1e, 0xdb, 0xfd, 0x58,
       0x70, 0x17, 0x9a, 0xbb, 0x9e, 0x5e, 0x93, 0x9e, 0x92, 0xd3, 0xe8,
-      0x25, 0x62, 0xbf, 0x59, 0xb2, 0xd2, 0x3d, 0x71, 0xff
-  };
+      0x25, 0x62, 0xbf, 0x59, 0xb2, 0xd2, 0x3d, 0x71, 0xff};
 
   pmbtoken_exp2_ok = pmbtoken_init_method(
       &pmbtoken_exp2_method, EC_group_p384(), kH, sizeof(kH),
@@ -1510,12 +1500,11 @@ static int pmbtoken_pst1_hash_s(const EC_GROUP *group, EC_JACOBIAN *out,
   CBB cbb;
   uint8_t *buf = NULL;
   size_t len;
-  if (!CBB_init(&cbb, 0) ||
-      !point_to_cbb(&cbb, group, t) ||
+  if (!CBB_init(&cbb, 0) || !point_to_cbb(&cbb, group, t) ||
       !CBB_add_bytes(&cbb, s, TRUST_TOKEN_NONCE_SIZE) ||
       !CBB_finish(&cbb, &buf, &len) ||
-      !ec_hash_to_curve_p384_xmd_sha384_sswu(
-          group, out, kHashSLabel, sizeof(kHashSLabel), buf, len)) {
+      !ec_hash_to_curve_p384_xmd_sha384_sswu(group, out, kHashSLabel,
+                                             sizeof(kHashSLabel), buf, len)) {
     goto err;
   }
 
@@ -1530,15 +1519,15 @@ err:
 static int pmbtoken_pst1_hash_c(const EC_GROUP *group, EC_SCALAR *out,
                                 uint8_t *buf, size_t len) {
   const uint8_t kHashCLabel[] = "PMBTokens PST V1 HashC";
-  return ec_hash_to_scalar_p384_xmd_sha384(
-      group, out, kHashCLabel, sizeof(kHashCLabel), buf, len);
+  return ec_hash_to_scalar_p384_xmd_sha384(group, out, kHashCLabel,
+                                           sizeof(kHashCLabel), buf, len);
 }
 
 static int pmbtoken_pst1_hash_to_scalar(const EC_GROUP *group, EC_SCALAR *out,
                                         uint8_t *buf, size_t len) {
   const uint8_t kHashLabel[] = "PMBTokens PST V1 HashToScalar";
-  return ec_hash_to_scalar_p384_xmd_sha384(
-      group, out, kHashLabel, sizeof(kHashLabel), buf, len);
+  return ec_hash_to_scalar_p384_xmd_sha384(group, out, kHashLabel,
+                                           sizeof(kHashLabel), buf, len);
 }
 
 static int pmbtoken_pst1_ok = 0;
@@ -1557,8 +1546,7 @@ static void pmbtoken_pst1_init_method_impl(void) {
       0xa2, 0x32, 0xf4, 0x22, 0x40, 0x07, 0x2d, 0x9b, 0x6f, 0xab, 0xff,
       0x2a, 0x92, 0x03, 0xb1, 0x73, 0x09, 0x1a, 0x6a, 0x4a, 0xc2, 0x4c,
       0xac, 0x13, 0x59, 0xf4, 0x28, 0x0e, 0x78, 0x69, 0xa5, 0xdf, 0x0d,
-      0x74, 0xeb, 0x14, 0xca, 0x8a, 0x32, 0xbb, 0xd3, 0x91
-  };
+      0x74, 0xeb, 0x14, 0xca, 0x8a, 0x32, 0xbb, 0xd3, 0x91};
 
   pmbtoken_pst1_ok = pmbtoken_init_method(
       &pmbtoken_pst1_method, EC_group_p384(), kH, sizeof(kH),

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

@@ -1,4 +1,4 @@
-/* Copyright (c) 2019, Google Inc.
+/* Copyright 2019 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -118,11 +118,12 @@ void TRUST_TOKEN_PRETOKEN_free(TRUST_TOKEN_PRETOKEN *pretoken) {
 }
 
 TRUST_TOKEN *TRUST_TOKEN_new(const uint8_t *data, size_t len) {
-  TRUST_TOKEN *ret = OPENSSL_zalloc(sizeof(TRUST_TOKEN));
+  TRUST_TOKEN *ret =
+      reinterpret_cast<TRUST_TOKEN *>(OPENSSL_zalloc(sizeof(TRUST_TOKEN)));
   if (ret == NULL) {
     return NULL;
   }
-  ret->data = OPENSSL_memdup(data, len);
+  ret->data = reinterpret_cast<uint8_t *>(OPENSSL_memdup(data, len));
   if (len != 0 && ret->data == NULL) {
     OPENSSL_free(ret);
     return NULL;
@@ -183,7 +184,7 @@ int TRUST_TOKEN_derive_key_from_secret(
   }
 
   if (!method->derive_key_from_secret(&priv_cbb, &pub_cbb, secret,
-                                        secret_len)) {
+                                      secret_len)) {
     return 0;
   }
 
@@ -204,7 +205,8 @@ TRUST_TOKEN_CLIENT *TRUST_TOKEN_CLIENT_new(const TRUST_TOKEN_METHOD *method,
     return NULL;
   }
 
-  TRUST_TOKEN_CLIENT *ret = OPENSSL_zalloc(sizeof(TRUST_TOKEN_CLIENT));
+  TRUST_TOKEN_CLIENT *ret = reinterpret_cast<TRUST_TOKEN_CLIENT *>(
+      OPENSSL_zalloc(sizeof(TRUST_TOKEN_CLIENT)));
   if (ret == NULL) {
     return NULL;
   }
@@ -266,8 +268,7 @@ static int trust_token_client_begin_issuance_impl(
   int ret = 0;
   CBB request;
   STACK_OF(TRUST_TOKEN_PRETOKEN) *pretokens = NULL;
-  if (!CBB_init(&request, 0) ||
-      !CBB_add_u16(&request, count)) {
+  if (!CBB_init(&request, 0) || !CBB_add_u16(&request, count)) {
     goto err;
   }
 
@@ -306,17 +307,14 @@ int TRUST_TOKEN_CLIENT_begin_issuance_over_message(
 }
 
 
-STACK_OF(TRUST_TOKEN) *
-    TRUST_TOKEN_CLIENT_finish_issuance(TRUST_TOKEN_CLIENT *ctx,
-                                       size_t *out_key_index,
-                                       const uint8_t *response,
-                                       size_t response_len) {
+STACK_OF(TRUST_TOKEN) *TRUST_TOKEN_CLIENT_finish_issuance(
+    TRUST_TOKEN_CLIENT *ctx, size_t *out_key_index, const uint8_t *response,
+    size_t response_len) {
   CBS in;
   CBS_init(&in, response, response_len);
   uint16_t count;
   uint32_t key_id;
-  if (!CBS_get_u16(&in, &count) ||
-      !CBS_get_u32(&in, &key_id)) {
+  if (!CBS_get_u16(&in, &count) || !CBS_get_u32(&in, &key_id)) {
     OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_FAILURE);
     return NULL;
   }
@@ -397,8 +395,7 @@ int TRUST_TOKEN_CLIENT_finish_redemption(TRUST_TOKEN_CLIENT *ctx,
   }
 
   if (!CBS_get_u16_length_prefixed(&in, &srr) ||
-      !CBS_get_u16_length_prefixed(&in, &sig) ||
-      CBS_len(&in) != 0) {
+      !CBS_get_u16_length_prefixed(&in, &sig) || CBS_len(&in) != 0) {
     OPENSSL_PUT_ERROR(TRUST_TOKEN, TRUST_TOKEN_R_DECODE_ERROR);
     return 0;
   }
@@ -444,7 +441,8 @@ TRUST_TOKEN_ISSUER *TRUST_TOKEN_ISSUER_new(const TRUST_TOKEN_METHOD *method,
     return NULL;
   }
 
-  TRUST_TOKEN_ISSUER *ret = OPENSSL_zalloc(sizeof(TRUST_TOKEN_ISSUER));
+  TRUST_TOKEN_ISSUER *ret = reinterpret_cast<TRUST_TOKEN_ISSUER *>(
+      OPENSSL_zalloc(sizeof(TRUST_TOKEN_ISSUER)));
   if (ret == NULL) {
     return NULL;
   }
@@ -500,7 +498,7 @@ int TRUST_TOKEN_ISSUER_set_metadata_key(TRUST_TOKEN_ISSUER *ctx,
   }
   OPENSSL_free(ctx->metadata_key);
   ctx->metadata_key_len = 0;
-  ctx->metadata_key = OPENSSL_memdup(key, len);
+  ctx->metadata_key = reinterpret_cast<uint8_t *>(OPENSSL_memdup(key, len));
   if (ctx->metadata_key == NULL) {
     return 0;
   }
@@ -550,8 +548,7 @@ int TRUST_TOKEN_ISSUER_issue(const TRUST_TOKEN_ISSUER *ctx, uint8_t **out,
 
   int ret = 0;
   CBB response;
-  if (!CBB_init(&response, 0) ||
-      !CBB_add_u16(&response, num_to_issue) ||
+  if (!CBB_init(&response, 0) || !CBB_add_u16(&response, num_to_issue) ||
       !CBB_add_u32(&response, public_metadata)) {
     goto err;
   }
@@ -620,11 +617,12 @@ static int trust_token_issuer_redeem_impl(
 
   uint8_t *client_data_buf = NULL;
   size_t client_data_len = 0;
+  TRUST_TOKEN *token;
   if (!CBS_stow(&client_data, &client_data_buf, &client_data_len)) {
     goto err;
   }
 
-  TRUST_TOKEN *token = TRUST_TOKEN_new(nonce, TRUST_TOKEN_NONCE_SIZE);
+  token = TRUST_TOKEN_new(nonce, TRUST_TOKEN_NONCE_SIZE);
   if (token == NULL) {
     goto err;
   }