grpc 1.80.0 → 1.81.0

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

@@ -56,18 +56,19 @@ static int bn_gcd_consttime(BIGNUM *r, unsigned *out_shift, const BIGNUM *x,
   }
 
   // This is a constant-time implementation of Stein's algorithm (binary GCD).
-  bssl::BN_CTXScope scope(ctx);
+  int ret = 0;
+  BN_CTX_start(ctx);
   BIGNUM *u = BN_CTX_get(ctx);
   BIGNUM *v = BN_CTX_get(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
   unsigned x_bits, y_bits, num_iters, shift;
-  if (u == nullptr || v == nullptr || tmp == nullptr ||  //
+  if (u == NULL || v == NULL || tmp == NULL ||  //
       !BN_copy(u, x) ||                         //
       !BN_copy(v, y) ||                         //
       !bn_resize_words(u, width) ||             //
       !bn_resize_words(v, width) ||             //
       !bn_resize_words(tmp, width)) {
-    return 0;
+    goto err;
   }
 
   // Each loop iteration halves at least one of |u| and |v|. Thus we need at
@@ -77,7 +78,7 @@ static int bn_gcd_consttime(BIGNUM *r, unsigned *out_shift, const BIGNUM *x,
   num_iters = x_bits + y_bits;
   if (num_iters < x_bits) {
     OPENSSL_PUT_ERROR(BN, BN_R_BIGNUM_TOO_LONG);
-    return 0;
+    goto err;
   }
 
   shift = 0;
@@ -113,7 +114,11 @@ static int bn_gcd_consttime(BIGNUM *r, unsigned *out_shift, const BIGNUM *x,
   }
 
   *out_shift = shift;
-  return bn_set_words(r, v->d, width);
+  ret = bn_set_words(r, v->d, width);
+
+err:
+  BN_CTX_end(ctx);
+  return ret;
 }
 
 int BN_gcd(BIGNUM *r, const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx) {
@@ -123,11 +128,12 @@ int BN_gcd(BIGNUM *r, const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx) {
 
 int bn_is_relatively_prime(int *out_relatively_prime, const BIGNUM *x,
                            const BIGNUM *y, BN_CTX *ctx) {
-  bssl::BN_CTXScope scope(ctx);
+  int ret = 0;
+  BN_CTX_start(ctx);
   unsigned shift;
   BIGNUM *gcd = BN_CTX_get(ctx);
-  if (gcd == nullptr || !bn_gcd_consttime(gcd, &shift, x, y, ctx)) {
-    return 0;
+  if (gcd == NULL || !bn_gcd_consttime(gcd, &shift, x, y, ctx)) {
+    goto err;
   }
 
   // Check that 2^|shift| * |gcd| is one.
@@ -140,20 +146,25 @@ int bn_is_relatively_prime(int *out_relatively_prime, const BIGNUM *x,
     }
     *out_relatively_prime = mask == 0;
   }
+  ret = 1;
 
-  return 1;
+err:
+  BN_CTX_end(ctx);
+  return ret;
 }
 
 int bn_lcm_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx) {
-  bssl::BN_CTXScope scope(ctx);
+  BN_CTX_start(ctx);
   unsigned shift;
   BIGNUM *gcd = BN_CTX_get(ctx);
-  return gcd != nullptr &&  //
-         bn_mul_consttime(r, a, b, ctx) &&
-         bn_gcd_consttime(gcd, &shift, a, b, ctx) &&
-         // |gcd| has a secret bit width.
-         bn_div_consttime(r, nullptr, r, gcd, /*divisor_min_bits=*/0, ctx) &&
-         bn_rshift_secret_shift(r, r, shift, ctx);
+  int ret = gcd != NULL &&  //
+            bn_mul_consttime(r, a, b, ctx) &&
+            bn_gcd_consttime(gcd, &shift, a, b, ctx) &&
+            // |gcd| has a secret bit width.
+            bn_div_consttime(r, NULL, r, gcd, /*divisor_min_bits=*/0, ctx) &&
+            bn_rshift_secret_shift(r, r, shift, ctx);
+  BN_CTX_end(ctx);
+  return ret;
 }
 
 int bn_mod_inverse_consttime(BIGNUM *r, int *out_no_inverse, const BIGNUM *a,
@@ -196,7 +207,8 @@ int bn_mod_inverse_consttime(BIGNUM *r, int *out_no_inverse, const BIGNUM *a,
     a_width = n_width;
   }
 
-  bssl::BN_CTXScope scope(ctx);
+  int ret = 0;
+  BN_CTX_start(ctx);
   BIGNUM *u = BN_CTX_get(ctx);
   BIGNUM *v = BN_CTX_get(ctx);
   BIGNUM *A = BN_CTX_get(ctx);
@@ -206,14 +218,14 @@ int bn_mod_inverse_consttime(BIGNUM *r, int *out_no_inverse, const BIGNUM *a,
   BIGNUM *tmp = BN_CTX_get(ctx);
   BIGNUM *tmp2 = BN_CTX_get(ctx);
   size_t a_bits, num_iters, n_bits;
-  if (u == nullptr ||       //
-      v == nullptr ||       //
-      A == nullptr ||       //
-      B == nullptr ||       //
-      C == nullptr ||       //
-      D == nullptr ||       //
-      tmp == nullptr ||     //
-      tmp2 == nullptr ||    //
+  if (u == NULL ||       //
+      v == NULL ||       //
+      A == NULL ||       //
+      B == NULL ||       //
+      C == NULL ||       //
+      D == NULL ||       //
+      tmp == NULL ||     //
+      tmp2 == NULL ||    //
       !BN_copy(u, a) ||  //
       !BN_copy(v, n) ||  //
       !BN_one(A) ||      //
@@ -230,7 +242,7 @@ int bn_mod_inverse_consttime(BIGNUM *r, int *out_no_inverse, const BIGNUM *a,
       // |tmp| and |tmp2| may be used at either size.
       !bn_resize_words(tmp, n_width) ||  //
       !bn_resize_words(tmp2, n_width)) {
-    return 0;
+    goto err;
   }
 
   // Each loop iteration halves at least one of |u| and |v|. Thus we need at
@@ -242,7 +254,7 @@ int bn_mod_inverse_consttime(BIGNUM *r, int *out_no_inverse, const BIGNUM *a,
   num_iters = a_bits + n_bits;
   if (num_iters < a_bits) {
     OPENSSL_PUT_ERROR(BN, BN_R_BIGNUM_TOO_LONG);
-    return 0;
+    goto err;
   }
 
   // Before and after each loop iteration, the following hold:
@@ -316,8 +328,12 @@ int bn_mod_inverse_consttime(BIGNUM *r, int *out_no_inverse, const BIGNUM *a,
   if (constant_time_declassify_int(!BN_is_one(u))) {
     *out_no_inverse = 1;
     OPENSSL_PUT_ERROR(BN, BN_R_NO_INVERSE);
-    return 0;
+    goto err;
   }
 
-  return BN_copy(r, A) != nullptr;
+  ret = BN_copy(r, A) != NULL;
+
+err:
+  BN_CTX_end(ctx);
+  return ret;
 }

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

@@ -42,29 +42,32 @@ int bn_jacobi(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx) {
     return -2;
   }
 
-  bssl::BN_CTXScope scope(ctx);
+  int ret = -2;
+  BN_CTX_start(ctx);
   BIGNUM *A = BN_CTX_get(ctx);
   BIGNUM *B = BN_CTX_get(ctx);
   if (B == NULL) {
-    return -2;
+    goto end;
   }
 
   if (!BN_copy(A, a) ||
       !BN_copy(B, b)) {
-    return -2;
+    goto end;
   }
 
   // Adapted from logic to compute the Kronecker symbol, originally implemented
   // according to Henri Cohen, "A Course in Computational Algebraic Number
   // Theory" (algorithm 1.4.10).
 
-  int ret = 1;
+  ret = 1;
+
   while (1) {
     // Cohen's step 3:
 
     // B is positive and odd
     if (BN_is_zero(A)) {
-      return BN_is_one(B) ? ret : 0;
+      ret = BN_is_one(B) ? ret : 0;
+      goto end;
     }
 
     // now A is non-zero
@@ -73,7 +76,8 @@ int bn_jacobi(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx) {
       i++;
     }
     if (!BN_rshift(A, A, i)) {
-      return -2;
+      ret = -2;
+      goto end;
     }
     if (i & 1) {
       // i is odd
@@ -89,11 +93,16 @@ int bn_jacobi(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx) {
 
     // (A, B) := (B mod |A|, |A|)
     if (!BN_nnmod(B, B, A, ctx)) {
-      return -2;
+      ret = -2;
+      goto end;
     }
     BIGNUM *tmp = A;
     A = B;
     B = tmp;
     tmp->neg = 0;
   }
+
+end:
+  BN_CTX_end(ctx);
+  return ret;
 }

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

@@ -245,13 +245,21 @@ static int BN_from_montgomery_word(BIGNUM *ret, BIGNUM *r,
 
 int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, const BN_MONT_CTX *mont,
                        BN_CTX *ctx) {
-  bssl::BN_CTXScope scope(ctx);
-  BIGNUM *t = BN_CTX_get(ctx);
+  int ret = 0;
+  BIGNUM *t;
+
+  BN_CTX_start(ctx);
+  t = BN_CTX_get(ctx);
   if (t == NULL || !BN_copy(t, a)) {
-    return 0;
+    goto err;
   }
 
-  return BN_from_montgomery_word(r, t, mont);
+  ret = BN_from_montgomery_word(r, t, mont);
+
+err:
+  BN_CTX_end(ctx);
+
+  return ret;
 }
 
 int bn_one_to_montgomery(BIGNUM *r, const BN_MONT_CTX *mont, BN_CTX *ctx) {
@@ -278,28 +286,34 @@ static int bn_mod_mul_montgomery_fallback(BIGNUM *r, const BIGNUM *a,
                                           const BIGNUM *b,
                                           const BN_MONT_CTX *mont,
                                           BN_CTX *ctx) {
-  bssl::BN_CTXScope scope(ctx);
+  int ret = 0;
+
+  BN_CTX_start(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
   if (tmp == NULL) {
-    return 0;
+    goto err;
   }
 
   if (a == b) {
     if (!bn_sqr_consttime(tmp, a, ctx)) {
-      return 0;
+      goto err;
     }
   } else {
     if (!bn_mul_consttime(tmp, a, b, ctx)) {
-      return 0;
+      goto err;
     }
   }
 
   // reduce from aRR to aR
   if (!BN_from_montgomery_word(r, tmp, mont)) {
-    return 0;
+    goto err;
   }
 
-  return 1;
+  ret = 1;
+
+err:
+  BN_CTX_end(ctx);
+  return ret;
 }
 
 int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,

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

@@ -137,14 +137,15 @@ int bn_abs_sub_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
   int cl = a->width < b->width ? a->width : b->width;
   int dl = a->width - b->width;
   int r_len = a->width < b->width ? b->width : a->width;
-  bssl::BN_CTXScope scope(ctx);
+  BN_CTX_start(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
-  if (tmp == nullptr || !bn_wexpand(r, r_len) || !bn_wexpand(tmp, r_len)) {
-    return 0;
+  int ok = tmp != NULL && bn_wexpand(r, r_len) && bn_wexpand(tmp, r_len);
+  if (ok) {
+    bn_abs_sub_part_words(r->d, a->d, b->d, cl, dl, tmp->d);
+    r->width = r_len;
   }
-  bn_abs_sub_part_words(r->d, a->d, b->d, cl, dl, tmp->d);
-  r->width = r_len;
-  return 1;
+  BN_CTX_end(ctx);
+  return ok;
 }
 
 // Karatsuba recursive multiplication algorithm
@@ -376,13 +377,13 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
     return 1;
   }
 
-  int i, top;
+  int ret = 0, i, top;
   BIGNUM *rr;
-  bssl::BN_CTXScope scope(ctx);
+  BN_CTX_start(ctx);
   if (r == a || r == b) {
     rr = BN_CTX_get(ctx);
     if (rr == NULL) {
-      return 0;
+      goto err;
     }
   } else {
     rr = r;
@@ -393,7 +394,7 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
   if (i == 0) {
     if (al == 8) {
       if (!bn_wexpand(rr, 16)) {
-        return 0;
+        goto err;
       }
       rr->width = 16;
       bn_mul_comba8(rr->d, a->d, b->d);
@@ -420,7 +421,7 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
       assert(j <= al || j <= bl);
       BIGNUM *t = BN_CTX_get(ctx);
       if (t == NULL) {
-        return 0;
+        goto err;
       }
       if (al > j || bl > j) {
         // We know |al| and |bl| are at most one from each other, so if al > j,
@@ -431,7 +432,7 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
         // https://boringssl-review.googlesource.com/q/I0bd604e2cd6a75c266f64476c23a730ca1721ea6
         assert(al >= j && bl >= j);
         if (!bn_wexpand(t, j * 8) || !bn_wexpand(rr, j * 4)) {
-          return 0;
+          goto err;
         }
         bn_mul_part_recursive(rr->d, a->d, b->d, j, al - j, bl - j, t->d);
       } else {
@@ -439,7 +440,7 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
         // of al - j or bl - j is zero. The other, by the bound on |i| above, is
         // zero or -1. Thus, we can use |bn_mul_recursive|.
         if (!bn_wexpand(t, j * 4) || !bn_wexpand(rr, j * 2)) {
-          return 0;
+          goto err;
         }
         bn_mul_recursive(rr->d, a->d, b->d, j, al - j, bl - j, t->d);
       }
@@ -449,16 +450,20 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
   }
 
   if (!bn_wexpand(rr, top)) {
-    return 0;
+    goto err;
   }
   rr->width = top;
   bn_mul_normal(rr->d, a->d, al, b->d, bl);
 
 end:
   if (r != rr && !BN_copy(r, rr)) {
-    return 0;
+    goto err;
   }
-  return 1;
+  ret = 1;
+
+err:
+  BN_CTX_end(ctx);
+  return ret;
 }
 
 int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx) {
@@ -622,16 +627,17 @@ int bn_sqr_consttime(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx) {
     return 1;
   }
 
-  bssl::BN_CTXScope scope(ctx);
+  int ret = 0, max;
+  BN_CTX_start(ctx);
   BIGNUM *rr = (a != r) ? r : BN_CTX_get(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
   if (!rr || !tmp) {
-    return 0;
+    goto err;
   }
 
-  int max = 2 * al;  // Non-zero (from above)
+  max = 2 * al;  // Non-zero (from above)
   if (!bn_wexpand(rr, max)) {
-    return 0;
+    goto err;
   }
 
   if (al == 4) {
@@ -652,12 +658,12 @@ int bn_sqr_consttime(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx) {
       // cryptographic primitives.
       if (al != 0 && (al & (al - 1)) == 0) {
         if (!bn_wexpand(tmp, al * 4)) {
-          return 0;
+          goto err;
         }
         bn_sqr_recursive(rr->d, a->d, al, tmp->d);
       } else {
         if (!bn_wexpand(tmp, max)) {
-          return 0;
+          goto err;
         }
         bn_sqr_normal(rr->d, a->d, al, tmp->d);
       }
@@ -668,9 +674,13 @@ int bn_sqr_consttime(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx) {
   rr->width = max;
 
   if (rr != r && !BN_copy(r, rr)) {
-    return 0;
+    goto err;
   }
-  return 1;
+  ret = 1;
+
+err:
+  BN_CTX_end(ctx);
+  return ret;
 }
 
 int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx) {