grpc 1.27.0.pre1 → 1.30.1

data/third_party/{boringssl → boringssl-with-bazel/src}/crypto/fipsmodule/ec/simple.c

@@ -101,22 +101,13 @@ void ec_GFp_simple_group_finish(EC_GROUP *group) {
 int ec_GFp_simple_group_set_curve(EC_GROUP *group, const BIGNUM *p,
                                   const BIGNUM *a, const BIGNUM *b,
                                   BN_CTX *ctx) {
-  int ret = 0;
-  BN_CTX *new_ctx = NULL;
-
   // p must be a prime > 3
   if (BN_num_bits(p) <= 2 || !BN_is_odd(p)) {
     OPENSSL_PUT_ERROR(EC, EC_R_INVALID_FIELD);
     return 0;
   }
 
-  if (ctx == NULL) {
-    ctx = new_ctx = BN_CTX_new();
-    if (ctx == NULL) {
-      return 0;
-    }
-  }
-
+  int ret = 0;
   BN_CTX_start(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
   if (tmp == NULL) {
@@ -131,33 +122,23 @@ int ec_GFp_simple_group_set_curve(EC_GROUP *group, const BIGNUM *p,
   // Store the field in minimal form, so it can be used with |BN_ULONG| arrays.
   bn_set_minimal_width(&group->field);
 
-  // group->a
-  if (!BN_nnmod(tmp, a, &group->field, ctx) ||
-      !ec_bignum_to_felem(group, &group->a, tmp)) {
+  if (!ec_bignum_to_felem(group, &group->a, a) ||
+      !ec_bignum_to_felem(group, &group->b, b) ||
+      !ec_bignum_to_felem(group, &group->one, BN_value_one())) {
     goto err;
   }
 
   // group->a_is_minus3
-  if (!BN_add_word(tmp, 3)) {
+  if (!BN_copy(tmp, a) ||
+      !BN_add_word(tmp, 3)) {
     goto err;
   }
   group->a_is_minus3 = (0 == BN_cmp(tmp, &group->field));
 
-  // group->b
-  if (!BN_nnmod(tmp, b, &group->field, ctx) ||
-      !ec_bignum_to_felem(group, &group->b, tmp)) {
-    goto err;
-  }
-
-  if (!ec_bignum_to_felem(group, &group->one, BN_value_one())) {
-    goto err;
-  }
-
   ret = 1;
 
 err:
   BN_CTX_end(ctx);
-  BN_CTX_free(new_ctx);
   return ret;
 }
 
@@ -190,24 +171,6 @@ void ec_GFp_simple_point_set_to_infinity(const EC_GROUP *group,
   ec_GFp_simple_point_init(point);
 }
 
-int ec_GFp_simple_point_set_affine_coordinates(const EC_GROUP *group,
-                                               EC_RAW_POINT *point,
-                                               const BIGNUM *x,
-                                               const BIGNUM *y) {
-  if (x == NULL || y == NULL) {
-    OPENSSL_PUT_ERROR(EC, ERR_R_PASSED_NULL_PARAMETER);
-    return 0;
-  }
-
-  if (!ec_bignum_to_felem(group, &point->X, x) ||
-      !ec_bignum_to_felem(group, &point->Y, y)) {
-    return 0;
-  }
-  OPENSSL_memcpy(&point->Z, &group->one, sizeof(EC_FELEM));
-
-  return 1;
-}
-
 void ec_GFp_simple_invert(const EC_GROUP *group, EC_RAW_POINT *point) {
   ec_felem_neg(group, &point->Y, &point->Y);
 }
@@ -219,10 +182,6 @@ int ec_GFp_simple_is_at_infinity(const EC_GROUP *group,
 
 int ec_GFp_simple_is_on_curve(const EC_GROUP *group,
                               const EC_RAW_POINT *point) {
-  if (ec_GFp_simple_is_at_infinity(group, point)) {
-    return 1;
-  }
-
   // We have a curve defined by a Weierstrass equation
   //      y^2 = x^3 + a*x + b.
   // The point to consider is given in Jacobian projective coordinates
@@ -231,6 +190,9 @@ int ec_GFp_simple_is_on_curve(const EC_GROUP *group,
   // into
   //      Y^2 = X^3 + a*X*Z^4 + b*Z^6.
   // To test this, we add up the right-hand side in 'rh'.
+  //
+  // This function may be used when double-checking the secret result of a point
+  // multiplication, so we proceed in constant-time.
 
   void (*const felem_mul)(const EC_GROUP *, EC_FELEM *r, const EC_FELEM *a,
                           const EC_FELEM *b) = group->meth->felem_mul;
@@ -242,128 +204,114 @@ int ec_GFp_simple_is_on_curve(const EC_GROUP *group,
   felem_sqr(group, &rh, &point->X);
 
   EC_FELEM tmp, Z4, Z6;
-  if (!ec_felem_equal(group, &point->Z, &group->one)) {
-    felem_sqr(group, &tmp, &point->Z);
-    felem_sqr(group, &Z4, &tmp);
-    felem_mul(group, &Z6, &Z4, &tmp);
-
-    // rh := (rh + a*Z^4)*X
-    if (group->a_is_minus3) {
-      ec_felem_add(group, &tmp, &Z4, &Z4);
-      ec_felem_add(group, &tmp, &tmp, &Z4);
-      ec_felem_sub(group, &rh, &rh, &tmp);
-      felem_mul(group, &rh, &rh, &point->X);
-    } else {
-      felem_mul(group, &tmp, &Z4, &group->a);
-      ec_felem_add(group, &rh, &rh, &tmp);
-      felem_mul(group, &rh, &rh, &point->X);
-    }
-
-    // rh := rh + b*Z^6
-    felem_mul(group, &tmp, &group->b, &Z6);
-    ec_felem_add(group, &rh, &rh, &tmp);
+  felem_sqr(group, &tmp, &point->Z);
+  felem_sqr(group, &Z4, &tmp);
+  felem_mul(group, &Z6, &Z4, &tmp);
+
+  // rh := rh + a*Z^4
+  if (group->a_is_minus3) {
+    ec_felem_add(group, &tmp, &Z4, &Z4);
+    ec_felem_add(group, &tmp, &tmp, &Z4);
+    ec_felem_sub(group, &rh, &rh, &tmp);
   } else {
-    // rh := (rh + a)*X
-    ec_felem_add(group, &rh, &rh, &group->a);
-    felem_mul(group, &rh, &rh, &point->X);
-    // rh := rh + b
-    ec_felem_add(group, &rh, &rh, &group->b);
+    felem_mul(group, &tmp, &Z4, &group->a);
+    ec_felem_add(group, &rh, &rh, &tmp);
   }
 
+  // rh := (rh + a*Z^4)*X
+  felem_mul(group, &rh, &rh, &point->X);
+
+  // rh := rh + b*Z^6
+  felem_mul(group, &tmp, &group->b, &Z6);
+  ec_felem_add(group, &rh, &rh, &tmp);
+
   // 'lh' := Y^2
   felem_sqr(group, &tmp, &point->Y);
-  return ec_felem_equal(group, &tmp, &rh);
-}
 
-int ec_GFp_simple_cmp(const EC_GROUP *group, const EC_RAW_POINT *a,
-                      const EC_RAW_POINT *b) {
-  // Note this function returns zero if |a| and |b| are equal and 1 if they are
-  // not equal.
-  if (ec_GFp_simple_is_at_infinity(group, a)) {
-    return ec_GFp_simple_is_at_infinity(group, b) ? 0 : 1;
-  }
+  ec_felem_sub(group, &tmp, &tmp, &rh);
+  BN_ULONG not_equal = ec_felem_non_zero_mask(group, &tmp);
 
-  if (ec_GFp_simple_is_at_infinity(group, b)) {
-    return 1;
-  }
+  // If Z = 0, the point is infinity, which is always on the curve.
+  BN_ULONG not_infinity = ec_felem_non_zero_mask(group, &point->Z);
 
-  int a_Z_is_one = ec_felem_equal(group, &a->Z, &group->one);
-  int b_Z_is_one = ec_felem_equal(group, &b->Z, &group->one);
+  return 1 & ~(not_infinity & not_equal);
+}
 
-  if (a_Z_is_one && b_Z_is_one) {
-    return !ec_felem_equal(group, &a->X, &b->X) ||
-           !ec_felem_equal(group, &a->Y, &b->Y);
-  }
+int ec_GFp_simple_points_equal(const EC_GROUP *group, const EC_RAW_POINT *a,
+                               const EC_RAW_POINT *b) {
+  // This function is implemented in constant-time for two reasons. First,
+  // although EC points are usually public, their Jacobian Z coordinates may be
+  // secret, or at least are not obviously public. Second, more complex
+  // protocols will sometimes manipulate secret points.
+  //
+  // This does mean that we pay a 6M+2S Jacobian comparison when comparing two
+  // publicly affine points costs no field operations at all. If needed, we can
+  // restore this optimization by keeping better track of affine vs. Jacobian
+  // forms. See https://crbug.com/boringssl/326.
+
+  // If neither |a| or |b| is infinity, we have to decide whether
+  //     (X_a/Z_a^2, Y_a/Z_a^3) = (X_b/Z_b^2, Y_b/Z_b^3),
+  // or equivalently, whether
+  //     (X_a*Z_b^2, Y_a*Z_b^3) = (X_b*Z_a^2, Y_b*Z_a^3).
 
   void (*const felem_mul)(const EC_GROUP *, EC_FELEM *r, const EC_FELEM *a,
                           const EC_FELEM *b) = group->meth->felem_mul;
   void (*const felem_sqr)(const EC_GROUP *, EC_FELEM *r, const EC_FELEM *a) =
       group->meth->felem_sqr;
 
-  // We have to decide whether
-  //     (X_a/Z_a^2, Y_a/Z_a^3) = (X_b/Z_b^2, Y_b/Z_b^3),
-  // or equivalently, whether
-  //     (X_a*Z_b^2, Y_a*Z_b^3) = (X_b*Z_a^2, Y_b*Z_a^3).
-
   EC_FELEM tmp1, tmp2, Za23, Zb23;
-  const EC_FELEM *tmp1_, *tmp2_;
-  if (!b_Z_is_one) {
-    felem_sqr(group, &Zb23, &b->Z);
-    felem_mul(group, &tmp1, &a->X, &Zb23);
-    tmp1_ = &tmp1;
-  } else {
-    tmp1_ = &a->X;
-  }
-  if (!a_Z_is_one) {
-    felem_sqr(group, &Za23, &a->Z);
-    felem_mul(group, &tmp2, &b->X, &Za23);
-    tmp2_ = &tmp2;
-  } else {
-    tmp2_ = &b->X;
-  }
+  felem_sqr(group, &Zb23, &b->Z);         // Zb23 = Z_b^2
+  felem_mul(group, &tmp1, &a->X, &Zb23);  // tmp1 = X_a * Z_b^2
+  felem_sqr(group, &Za23, &a->Z);         // Za23 = Z_a^2
+  felem_mul(group, &tmp2, &b->X, &Za23);  // tmp2 = X_b * Z_a^2
+  ec_felem_sub(group, &tmp1, &tmp1, &tmp2);
+  const BN_ULONG x_not_equal = ec_felem_non_zero_mask(group, &tmp1);
+
+  felem_mul(group, &Zb23, &Zb23, &b->Z);  // Zb23 = Z_b^3
+  felem_mul(group, &tmp1, &a->Y, &Zb23);  // tmp1 = Y_a * Z_b^3
+  felem_mul(group, &Za23, &Za23, &a->Z);  // Za23 = Z_a^3
+  felem_mul(group, &tmp2, &b->Y, &Za23);  // tmp2 = Y_b * Z_a^3
+  ec_felem_sub(group, &tmp1, &tmp1, &tmp2);
+  const BN_ULONG y_not_equal = ec_felem_non_zero_mask(group, &tmp1);
+  const BN_ULONG x_and_y_equal = ~(x_not_equal | y_not_equal);
+
+  const BN_ULONG a_not_infinity = ec_felem_non_zero_mask(group, &a->Z);
+  const BN_ULONG b_not_infinity = ec_felem_non_zero_mask(group, &b->Z);
+  const BN_ULONG a_and_b_infinity = ~(a_not_infinity | b_not_infinity);
+
+  const BN_ULONG equal =
+      a_and_b_infinity | (a_not_infinity & b_not_infinity & x_and_y_equal);
+  return equal & 1;
+}
 
-  // Compare  X_a*Z_b^2  with  X_b*Z_a^2.
-  if (!ec_felem_equal(group, tmp1_, tmp2_)) {
-    return 1;  // The points differ.
-  }
+int ec_affine_jacobian_equal(const EC_GROUP *group, const EC_AFFINE *a,
+                             const EC_RAW_POINT *b) {
+  // If |b| is not infinity, we have to decide whether
+  //     (X_a, Y_a) = (X_b/Z_b^2, Y_b/Z_b^3),
+  // or equivalently, whether
+  //     (X_a*Z_b^2, Y_a*Z_b^3) = (X_b, Y_b).
 
-  if (!b_Z_is_one) {
-    felem_mul(group, &Zb23, &Zb23, &b->Z);
-    felem_mul(group, &tmp1, &a->Y, &Zb23);
-    // tmp1_ = &tmp1
-  } else {
-    tmp1_ = &a->Y;
-  }
-  if (!a_Z_is_one) {
-    felem_mul(group, &Za23, &Za23, &a->Z);
-    felem_mul(group, &tmp2, &b->Y, &Za23);
-    // tmp2_ = &tmp2
-  } else {
-    tmp2_ = &b->Y;
-  }
+  void (*const felem_mul)(const EC_GROUP *, EC_FELEM *r, const EC_FELEM *a,
+                          const EC_FELEM *b) = group->meth->felem_mul;
+  void (*const felem_sqr)(const EC_GROUP *, EC_FELEM *r, const EC_FELEM *a) =
+      group->meth->felem_sqr;
 
-  // Compare  Y_a*Z_b^3  with  Y_b*Z_a^3.
-  if (!ec_felem_equal(group, tmp1_, tmp2_)) {
-    return 1;  // The points differ.
-  }
+  EC_FELEM tmp, Zb2;
+  felem_sqr(group, &Zb2, &b->Z);        // Zb2 = Z_b^2
+  felem_mul(group, &tmp, &a->X, &Zb2);  // tmp = X_a * Z_b^2
+  ec_felem_sub(group, &tmp, &tmp, &b->X);
+  const BN_ULONG x_not_equal = ec_felem_non_zero_mask(group, &tmp);
 
-  // The points are equal.
-  return 0;
-}
+  felem_mul(group, &tmp, &a->Y, &Zb2);  // tmp = Y_a * Z_b^2
+  felem_mul(group, &tmp, &tmp, &b->Z);  // tmp = Y_a * Z_b^3
+  ec_felem_sub(group, &tmp, &tmp, &b->Y);
+  const BN_ULONG y_not_equal = ec_felem_non_zero_mask(group, &tmp);
+  const BN_ULONG x_and_y_equal = ~(x_not_equal | y_not_equal);
 
-int ec_GFp_simple_mont_inv_mod_ord_vartime(const EC_GROUP *group,
-                                           EC_SCALAR *out,
-                                           const EC_SCALAR *in) {
-  // This implementation (in fact) runs in constant time,
-  // even though for this interface it is not mandatory.
-
-  // out = in^-1 in the Montgomery domain. This is
-  // |ec_scalar_to_montgomery| followed by |ec_scalar_inv_montgomery|, but
-  // |ec_scalar_inv_montgomery| followed by |ec_scalar_from_montgomery| is
-  // equivalent and slightly more efficient.
-  ec_scalar_inv_montgomery(group, out, in);
-  ec_scalar_from_montgomery(group, out, out);
-  return 1;
+  const BN_ULONG b_not_infinity = ec_felem_non_zero_mask(group, &b->Z);
+
+  const BN_ULONG equal = b_not_infinity & x_and_y_equal;
+  return equal & 1;
 }
 
 int ec_GFp_simple_cmp_x_coordinate(const EC_GROUP *group, const EC_RAW_POINT *p,
@@ -378,3 +326,32 @@ int ec_GFp_simple_cmp_x_coordinate(const EC_GROUP *group, const EC_RAW_POINT *p,
   return ec_get_x_coordinate_as_scalar(group, &x, p) &&
          ec_scalar_equal_vartime(group, &x, r);
 }
+
+void ec_GFp_simple_felem_to_bytes(const EC_GROUP *group, uint8_t *out,
+                                  size_t *out_len, const EC_FELEM *in) {
+  size_t len = BN_num_bytes(&group->field);
+  for (size_t i = 0; i < len; i++) {
+    out[i] = in->bytes[len - 1 - i];
+  }
+  *out_len = len;
+}
+
+int ec_GFp_simple_felem_from_bytes(const EC_GROUP *group, EC_FELEM *out,
+                                   const uint8_t *in, size_t len) {
+  if (len != BN_num_bytes(&group->field)) {
+    OPENSSL_PUT_ERROR(EC, EC_R_DECODE_ERROR);
+    return 0;
+  }
+
+  OPENSSL_memset(out, 0, sizeof(EC_FELEM));
+  for (size_t i = 0; i < len; i++) {
+    out->bytes[i] = in[len - 1 - i];
+  }
+
+  if (!bn_less_than_words(out->words, group->field.d, group->field.width)) {
+    OPENSSL_PUT_ERROR(EC, EC_R_DECODE_ERROR);
+    return 0;
+  }
+
+  return 1;
+}

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/ec/simple_mul.c

@@ -0,0 +1,270 @@
+/* Copyright (c) 2018, 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. */
+
+#include <openssl/ec.h>
+
+#include <assert.h>
+
+#include "internal.h"
+#include "../bn/internal.h"
+#include "../../internal.h"
+
+
+void ec_GFp_mont_mul(const EC_GROUP *group, EC_RAW_POINT *r,
+                     const EC_RAW_POINT *p, const EC_SCALAR *scalar) {
+  // This is a generic implementation for uncommon curves that not do not
+  // warrant a tuned one. It uses unsigned digits so that the doubling case in
+  // |ec_GFp_mont_add| is always unreachable, erring on safety and simplicity.
+
+  // Compute a table of the first 32 multiples of |p| (including infinity).
+  EC_RAW_POINT precomp[32];
+  ec_GFp_simple_point_set_to_infinity(group, &precomp[0]);
+  ec_GFp_simple_point_copy(&precomp[1], p);
+  for (size_t j = 2; j < OPENSSL_ARRAY_SIZE(precomp); j++) {
+    if (j & 1) {
+      ec_GFp_mont_add(group, &precomp[j], &precomp[1], &precomp[j - 1]);
+    } else {
+      ec_GFp_mont_dbl(group, &precomp[j], &precomp[j / 2]);
+    }
+  }
+
+  // Divide bits in |scalar| into windows.
+  unsigned bits = BN_num_bits(&group->order);
+  int r_is_at_infinity = 1;
+  for (unsigned i = bits - 1; i < bits; i--) {
+    if (!r_is_at_infinity) {
+      ec_GFp_mont_dbl(group, r, r);
+    }
+    if (i % 5 == 0) {
+      // Compute the next window value.
+      const size_t width = group->order.width;
+      uint8_t window = bn_is_bit_set_words(scalar->words, width, i + 4) << 4;
+      window |= bn_is_bit_set_words(scalar->words, width, i + 3) << 3;
+      window |= bn_is_bit_set_words(scalar->words, width, i + 2) << 2;
+      window |= bn_is_bit_set_words(scalar->words, width, i + 1) << 1;
+      window |= bn_is_bit_set_words(scalar->words, width, i);
+
+      // Select the entry in constant-time.
+      EC_RAW_POINT tmp;
+      OPENSSL_memset(&tmp, 0, sizeof(EC_RAW_POINT));
+      for (size_t j = 0; j < OPENSSL_ARRAY_SIZE(precomp); j++) {
+        BN_ULONG mask = constant_time_eq_w(j, window);
+        ec_point_select(group, &tmp, mask, &precomp[j], &tmp);
+      }
+
+      if (r_is_at_infinity) {
+        ec_GFp_simple_point_copy(r, &tmp);
+        r_is_at_infinity = 0;
+      } else {
+        ec_GFp_mont_add(group, r, r, &tmp);
+      }
+    }
+  }
+  if (r_is_at_infinity) {
+    ec_GFp_simple_point_set_to_infinity(group, r);
+  }
+}
+
+void ec_GFp_mont_mul_base(const EC_GROUP *group, EC_RAW_POINT *r,
+                          const EC_SCALAR *scalar) {
+  ec_GFp_mont_mul(group, r, &group->generator->raw, scalar);
+}
+
+static void ec_GFp_mont_batch_precomp(const EC_GROUP *group, EC_RAW_POINT *out,
+                                      size_t num, const EC_RAW_POINT *p) {
+  assert(num > 1);
+  ec_GFp_simple_point_set_to_infinity(group, &out[0]);
+  ec_GFp_simple_point_copy(&out[1], p);
+  for (size_t j = 2; j < num; j++) {
+    if (j & 1) {
+      ec_GFp_mont_add(group, &out[j], &out[1], &out[j - 1]);
+    } else {
+      ec_GFp_mont_dbl(group, &out[j], &out[j / 2]);
+    }
+  }
+}
+
+static void ec_GFp_mont_batch_get_window(const EC_GROUP *group,
+                                         EC_RAW_POINT *out,
+                                         const EC_RAW_POINT precomp[17],
+                                         const EC_SCALAR *scalar, unsigned i) {
+  const size_t width = group->order.width;
+  uint8_t window = bn_is_bit_set_words(scalar->words, width, i + 4) << 5;
+  window |= bn_is_bit_set_words(scalar->words, width, i + 3) << 4;
+  window |= bn_is_bit_set_words(scalar->words, width, i + 2) << 3;
+  window |= bn_is_bit_set_words(scalar->words, width, i + 1) << 2;
+  window |= bn_is_bit_set_words(scalar->words, width, i) << 1;
+  if (i > 0) {
+    window |= bn_is_bit_set_words(scalar->words, width, i - 1);
+  }
+  uint8_t sign, digit;
+  ec_GFp_nistp_recode_scalar_bits(&sign, &digit, window);
+
+  // Select the entry in constant-time.
+  OPENSSL_memset(out, 0, sizeof(EC_RAW_POINT));
+  for (size_t j = 0; j < 17; j++) {
+    BN_ULONG mask = constant_time_eq_w(j, digit);
+    ec_point_select(group, out, mask, &precomp[j], out);
+  }
+
+  // Negate if necessary.
+  EC_FELEM neg_Y;
+  ec_felem_neg(group, &neg_Y, &out->Y);
+  BN_ULONG sign_mask = sign;
+  sign_mask = 0u - sign_mask;
+  ec_felem_select(group, &out->Y, sign_mask, &neg_Y, &out->Y);
+}
+
+void ec_GFp_mont_mul_batch(const EC_GROUP *group, EC_RAW_POINT *r,
+                           const EC_RAW_POINT *p0, const EC_SCALAR *scalar0,
+                           const EC_RAW_POINT *p1, const EC_SCALAR *scalar1,
+                           const EC_RAW_POINT *p2, const EC_SCALAR *scalar2) {
+  EC_RAW_POINT precomp[3][17];
+  ec_GFp_mont_batch_precomp(group, precomp[0], 17, p0);
+  ec_GFp_mont_batch_precomp(group, precomp[1], 17, p1);
+  if (p2 != NULL) {
+    ec_GFp_mont_batch_precomp(group, precomp[2], 17, p2);
+  }
+
+  // Divide bits in |scalar| into windows.
+  unsigned bits = BN_num_bits(&group->order);
+  int r_is_at_infinity = 1;
+  for (unsigned i = bits; i <= bits; i--) {
+    if (!r_is_at_infinity) {
+      ec_GFp_mont_dbl(group, r, r);
+    }
+    if (i % 5 == 0) {
+      EC_RAW_POINT tmp;
+      ec_GFp_mont_batch_get_window(group, &tmp, precomp[0], scalar0, i);
+      if (r_is_at_infinity) {
+        ec_GFp_simple_point_copy(r, &tmp);
+        r_is_at_infinity = 0;
+      } else {
+        ec_GFp_mont_add(group, r, r, &tmp);
+      }
+
+      ec_GFp_mont_batch_get_window(group, &tmp, precomp[1], scalar1, i);
+      ec_GFp_mont_add(group, r, r, &tmp);
+
+      if (p2 != NULL) {
+        ec_GFp_mont_batch_get_window(group, &tmp, precomp[2], scalar2, i);
+        ec_GFp_mont_add(group, r, r, &tmp);
+      }
+    }
+  }
+  if (r_is_at_infinity) {
+    ec_GFp_simple_point_set_to_infinity(group, r);
+  }
+}
+
+static unsigned ec_GFp_mont_comb_stride(const EC_GROUP *group) {
+  return (BN_num_bits(&group->field) + EC_MONT_PRECOMP_COMB_SIZE - 1) /
+         EC_MONT_PRECOMP_COMB_SIZE;
+}
+
+int ec_GFp_mont_init_precomp(const EC_GROUP *group, EC_PRECOMP *out,
+                             const EC_RAW_POINT *p) {
+  // comb[i - 1] stores the ith element of the comb. That is, if i is
+  // b4 * 2^4 + b3 * 2^3 + ... + b0 * 2^0, it stores k * |p|, where k is
+  // b4 * 2^(4*stride) + b3 * 2^(3*stride) + ... + b0 * 2^(0*stride). stride
+  // here is |ec_GFp_mont_comb_stride|. We store at index i - 1 because the 0th
+  // comb entry is always infinity.
+  EC_RAW_POINT comb[(1 << EC_MONT_PRECOMP_COMB_SIZE) - 1];
+  unsigned stride = ec_GFp_mont_comb_stride(group);
+
+  // We compute the comb sequentially by the highest set bit. Initially, all
+  // entries up to 2^0 are filled.
+  comb[(1 << 0) - 1] = *p;
+  for (unsigned i = 1; i < EC_MONT_PRECOMP_COMB_SIZE; i++) {
+    // Compute entry 2^i by doubling the entry for 2^(i-1) |stride| times.
+    unsigned bit = 1 << i;
+    ec_GFp_mont_dbl(group, &comb[bit - 1], &comb[bit / 2 - 1]);
+    for (unsigned j = 1; j < stride; j++) {
+      ec_GFp_mont_dbl(group, &comb[bit - 1], &comb[bit - 1]);
+    }
+    // Compute entries from 2^i + 1 to 2^i + (2^i - 1) by adding entry 2^i to
+    // a previous entry.
+    for (unsigned j = 1; j < bit; j++) {
+      ec_GFp_mont_add(group, &comb[bit + j - 1], &comb[bit - 1], &comb[j - 1]);
+    }
+  }
+
+  // Store the comb in affine coordinates to shrink the table. (This reduces
+  // cache pressure and makes the constant-time selects faster.)
+  OPENSSL_STATIC_ASSERT(
+      OPENSSL_ARRAY_SIZE(comb) == OPENSSL_ARRAY_SIZE(out->comb),
+      "comb sizes did not match");
+  return ec_jacobian_to_affine_batch(group, out->comb, comb,
+                                     OPENSSL_ARRAY_SIZE(comb));
+}
+
+static void ec_GFp_mont_get_comb_window(const EC_GROUP *group,
+                                        EC_RAW_POINT *out,
+                                        const EC_PRECOMP *precomp,
+                                        const EC_SCALAR *scalar, unsigned i) {
+  const size_t width = group->order.width;
+  unsigned stride = ec_GFp_mont_comb_stride(group);
+  // Select the bits corresponding to the comb shifted up by |i|.
+  unsigned window = 0;
+  for (unsigned j = 0; j < EC_MONT_PRECOMP_COMB_SIZE; j++) {
+    window |= bn_is_bit_set_words(scalar->words, width, j * stride + i)
+              << j;
+  }
+
+  // Select precomp->comb[window - 1]. If |window| is zero, |match| will always
+  // be zero, which will leave |out| at infinity.
+  OPENSSL_memset(out, 0, sizeof(EC_RAW_POINT));
+  for (unsigned j = 0; j < OPENSSL_ARRAY_SIZE(precomp->comb); j++) {
+    BN_ULONG match = constant_time_eq_w(window, j + 1);
+    ec_felem_select(group, &out->X, match, &precomp->comb[j].X, &out->X);
+    ec_felem_select(group, &out->Y, match, &precomp->comb[j].Y, &out->Y);
+  }
+  BN_ULONG is_infinity = constant_time_is_zero_w(window);
+  ec_felem_select(group, &out->Z, is_infinity, &out->Z, &group->one);
+}
+
+void ec_GFp_mont_mul_precomp(const EC_GROUP *group, EC_RAW_POINT *r,
+                             const EC_PRECOMP *p0, const EC_SCALAR *scalar0,
+                             const EC_PRECOMP *p1, const EC_SCALAR *scalar1,
+                             const EC_PRECOMP *p2, const EC_SCALAR *scalar2) {
+  unsigned stride = ec_GFp_mont_comb_stride(group);
+  int r_is_at_infinity = 1;
+  for (unsigned i = stride - 1; i < stride; i--) {
+    if (!r_is_at_infinity) {
+      ec_GFp_mont_dbl(group, r, r);
+    }
+
+    EC_RAW_POINT tmp;
+    ec_GFp_mont_get_comb_window(group, &tmp, p0, scalar0, i);
+    if (r_is_at_infinity) {
+      ec_GFp_simple_point_copy(r, &tmp);
+      r_is_at_infinity = 0;
+    } else {
+      ec_GFp_mont_add(group, r, r, &tmp);
+    }
+
+    if (p1 != NULL) {
+      ec_GFp_mont_get_comb_window(group, &tmp, p1, scalar1, i);
+      ec_GFp_mont_add(group, r, r, &tmp);
+    }
+
+    if (p2 != NULL) {
+      ec_GFp_mont_get_comb_window(group, &tmp, p2, scalar2, i);
+      ec_GFp_mont_add(group, r, r, &tmp);
+    }
+  }
+  if (r_is_at_infinity) {
+    ec_GFp_simple_point_set_to_infinity(group, r);
+  }
+}