grpc 1.84.1 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/fipsmodule/bn/add.cc.inc

@@ -23,6 +23,8 @@
 #include "internal.h"
 
 
+using namespace bssl;
+
 int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b) {
   const BIGNUM *tmp;
   int a_neg = a->neg, ret;
@@ -59,8 +61,8 @@ int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b) {
   return ret;
 }
 
-int bn_uadd_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b) {
-  // Widths are public, so we normalize to make |a| the larger one.
+int bssl::bn_uadd_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b) {
+  // Widths are public, so we normalize to make `a` the larger one.
   if (a->width < b->width) {
     const BIGNUM *tmp = a;
     a = b;
@@ -179,9 +181,9 @@ int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b) {
   return 1;
 }
 
-int bn_usub_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b) {
-  // |b| may have more words than |a| given non-minimal inputs, but all words
-  // beyond |a->width| must then be zero.
+int bssl::bn_usub_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b) {
+  // `b` may have more words than `a` given non-minimal inputs, but all words
+  // beyond `a->width` must then be zero.
   int b_width = b->width;
   if (b_width > a->width) {
     if (!bn_fits_in_words(b, a->width)) {

data/third_party/boringssl-with-bazel/crypto/fipsmodule/bn/asm/x86_64-gcc.cc.inc

@@ -72,23 +72,23 @@
 #include "../internal.h"
 
 
+using namespace bssl;
+
 #undef mul
 #undef mul_add
 
 // "m"(a), "+m"(r)	is the way to favor DirectPath µ-code;
-// "g"(0)		let the compiler to decide where does it
-//			want to keep the value of zero;
 #define mul_add(r, a, word, carry)                                         \
   do {                                                                     \
     BN_ULONG high, low;                                                    \
     __asm__("mulq %3" : "=a"(low), "=d"(high) : "a"(word), "m"(a) : "cc"); \
-    __asm__("addq %2,%0; adcq %3,%1"                                       \
+    __asm__("addq %2,%0; adcq $0,%1"                                       \
             : "+r"(carry), "+d"(high)                                      \
-            : "a"(low), "g"(0)                                             \
+            : "a"(low)                                                     \
             : "cc");                                                       \
-    __asm__("addq %2,%0; adcq %3,%1"                                       \
+    __asm__("addq %2,%0; adcq $0,%1"                                       \
             : "+m"(r), "+d"(high)                                          \
-            : "r"(carry), "g"(0)                                           \
+            : "r"(carry)                                                   \
             : "cc");                                                       \
     (carry) = high;                                                        \
   } while (0)
@@ -97,18 +97,34 @@
   do {                                                                     \
     BN_ULONG high, low;                                                    \
     __asm__("mulq %3" : "=a"(low), "=d"(high) : "a"(word), "g"(a) : "cc"); \
-    __asm__("addq %2,%0; adcq %3,%1"                                       \
+    __asm__("addq %2,%0; adcq $0,%1"                                       \
             : "+r"(carry), "+d"(high)                                      \
-            : "a"(low), "g"(0)                                             \
+            : "a"(low)                                                     \
             : "cc");                                                       \
     (r) = (carry);                                                         \
     (carry) = high;                                                        \
   } while (0)
-#undef sqr
-#define sqr(r0, r1, a) __asm__("mulq %2" : "=a"(r0), "=d"(r1) : "a"(a) : "cc");
 
-BN_ULONG bn_mul_add_words(BN_ULONG *rp, const BN_ULONG *ap, size_t num,
-                          BN_ULONG w) {
+// r0:r1:carry = r0:r1 + a^2 + carry:0
+#define sqr_add(r0, r1, a, carry)                               \
+  do {                                                          \
+    BN_ULONG high, low;                                         \
+    /* lo:hi = a^2 */                                           \
+    __asm__("mulq %2" : "=a"(low), "=d"(high) : "a"(a) : "cc"); \
+    /* carry:hi = lo:hi + carry:0 = a^2 + carry */              \
+    __asm__("addq %2,%0; adcq $0,%1"                            \
+            : "+r"(carry), "+d"(high)                           \
+            : "a"(low)                                          \
+            : "cc");                                            \
+    /* r0:r1:carry = carry:hi + r0:r1 */                        \
+    __asm__("addq %2,%0; adcq %3,%1; movq $0, %2; adcq $0, %2"  \
+            : "+m"(r0), "+m"(r1), "+r"(carry)                   \
+            : "d"(high)                                         \
+            : "cc");                                            \
+  } while (0)
+
+BN_ULONG bssl::bn_mul_add_words(BN_ULONG *rp, const BN_ULONG *ap, size_t num,
+                                BN_ULONG w) {
   BN_ULONG c1 = 0;
 
   if (num == 0) {
@@ -140,8 +156,8 @@ BN_ULONG bn_mul_add_words(BN_ULONG *rp, const BN_ULONG *ap, size_t num,
   return c1;
 }
 
-BN_ULONG bn_mul_words(BN_ULONG *rp, const BN_ULONG *ap, size_t num,
-                      BN_ULONG w) {
+BN_ULONG bssl::bn_mul_words(BN_ULONG *rp, const BN_ULONG *ap, size_t num,
+                            BN_ULONG w) {
   BN_ULONG c1 = 0;
 
   if (num == 0) {
@@ -171,35 +187,36 @@ BN_ULONG bn_mul_words(BN_ULONG *rp, const BN_ULONG *ap, size_t num,
   return c1;
 }
 
-void bn_sqr_words(BN_ULONG *r, const BN_ULONG *a, size_t n) {
+void bssl::bn_sqr_add_words(BN_ULONG *r, const BN_ULONG *a, size_t n) {
   if (n == 0) {
     return;
   }
 
+  BN_ULONG carry = 0;
   while (n & ~3) {
-    sqr(r[0], r[1], a[0]);
-    sqr(r[2], r[3], a[1]);
-    sqr(r[4], r[5], a[2]);
-    sqr(r[6], r[7], a[3]);
+    sqr_add(r[0], r[1], a[0], carry);
+    sqr_add(r[2], r[3], a[1], carry);
+    sqr_add(r[4], r[5], a[2], carry);
+    sqr_add(r[6], r[7], a[3], carry);
     a += 4;
     r += 8;
     n -= 4;
   }
   if (n) {
-    sqr(r[0], r[1], a[0]);
+    sqr_add(r[0], r[1], a[0], carry);
     if (--n == 0) {
       return;
     }
-    sqr(r[2], r[3], a[1]);
+    sqr_add(r[2], r[3], a[1], carry);
     if (--n == 0) {
       return;
     }
-    sqr(r[4], r[5], a[2]);
+    sqr_add(r[4], r[5], a[2], carry);
   }
 }
 
-BN_ULONG bn_add_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
-                      size_t n) {
+BN_ULONG bssl::bn_add_words(BN_ULONG *rp, const BN_ULONG *ap,
+                            const BN_ULONG *bp, size_t n) {
   BN_ULONG ret;
   size_t i = 0;
 
@@ -219,15 +236,15 @@ BN_ULONG bn_add_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
       "	dec	%1		\n"
       "	jnz	1b		\n"
       "	sbbq	%0,%0		\n"
-      : "=&r"(ret), "+c"(n), "+r"(i)
+      : "=&r"(ret), "+&c"(n), "+&r"(i)
       : "r"(rp), "r"(ap), "r"(bp)
       : "cc", "memory");
 
   return ret & 1;
 }
 
-BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
-                      size_t n) {
+BN_ULONG bssl::bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap,
+                            const BN_ULONG *bp, size_t n) {
   BN_ULONG ret;
   size_t i = 0;
 
@@ -247,7 +264,7 @@ BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
       "	dec	%1		\n"
       "	jnz	1b		\n"
       "	sbbq	%0,%0		\n"
-      : "=&r"(ret), "+c"(n), "+r"(i)
+      : "=&r"(ret), "+&c"(n), "+&r"(i)
       : "r"(rp), "r"(ap), "r"(bp)
       : "cc", "memory");
 
@@ -265,9 +282,9 @@ BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
   do {                                                               \
     BN_ULONG t1, t2;                                                 \
     __asm__("mulq %3" : "=a"(t1), "=d"(t2) : "a"(a), "m"(b) : "cc"); \
-    __asm__("addq %3,%0; adcq %4,%1; adcq %5,%2"                     \
-            : "+r"(c0), "+r"(c1), "+r"(c2)                           \
-            : "r"(t1), "r"(t2), "g"(0)                               \
+    __asm__("addq %3,%0; adcq %4,%1; adcq $0,%2"                     \
+            : "+&r"(c0), "+r"(c1), "+r"(c2)                          \
+            : "r"(t1), "r"(t2)                                       \
             : "cc");                                                 \
   } while (0)
 
@@ -275,9 +292,9 @@ BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
   do {                                                            \
     BN_ULONG t1, t2;                                              \
     __asm__("mulq %2" : "=a"(t1), "=d"(t2) : "a"((a)[i]) : "cc"); \
-    __asm__("addq %3,%0; adcq %4,%1; adcq %5,%2"                  \
-            : "+r"(c0), "+r"(c1), "+r"(c2)                        \
-            : "r"(t1), "r"(t2), "g"(0)                            \
+    __asm__("addq %3,%0; adcq %4,%1; adcq $0,%2"                  \
+            : "+&r"(c0), "+r"(c1), "+r"(c2)                       \
+            : "r"(t1), "r"(t2)                                    \
             : "cc");                                              \
   } while (0)
 
@@ -285,19 +302,20 @@ BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
   do {                                                               \
     BN_ULONG t1, t2;                                                 \
     __asm__("mulq %3" : "=a"(t1), "=d"(t2) : "a"(a), "m"(b) : "cc"); \
-    __asm__("addq %3,%0; adcq %4,%1; adcq %5,%2"                     \
-            : "+r"(c0), "+r"(c1), "+r"(c2)                           \
-            : "r"(t1), "r"(t2), "g"(0)                               \
+    __asm__("addq %3,%0; adcq %4,%1; adcq $0,%2"                     \
+            : "+&r"(c0), "+r"(c1), "+r"(c2)                          \
+            : "r"(t1), "r"(t2)                                       \
             : "cc");                                                 \
-    __asm__("addq %3,%0; adcq %4,%1; adcq %5,%2"                     \
-            : "+r"(c0), "+r"(c1), "+r"(c2)                           \
-            : "r"(t1), "r"(t2), "g"(0)                               \
+    __asm__("addq %3,%0; adcq %4,%1; adcq $0,%2"                     \
+            : "+&r"(c0), "+r"(c1), "+r"(c2)                          \
+            : "r"(t1), "r"(t2)                                       \
             : "cc");                                                 \
   } while (0)
 
 #define sqr_add_c2(a, i, j, c0, c1, c2) mul_add_c2((a)[i], (a)[j], c0, c1, c2)
 
-void bn_mul_comba8(BN_ULONG r[16], const BN_ULONG a[8], const BN_ULONG b[8]) {
+void bssl::bn_mul_comba8(BN_ULONG r[16], const BN_ULONG a[8],
+                         const BN_ULONG b[8]) {
   BN_ULONG c1, c2, c3;
 
   c1 = 0;
@@ -399,7 +417,8 @@ void bn_mul_comba8(BN_ULONG r[16], const BN_ULONG a[8], const BN_ULONG b[8]) {
   r[15] = c1;
 }
 
-void bn_mul_comba4(BN_ULONG r[8], const BN_ULONG a[4], const BN_ULONG b[4]) {
+void bssl::bn_mul_comba4(BN_ULONG r[8], const BN_ULONG a[4],
+                         const BN_ULONG b[4]) {
   BN_ULONG c1, c2, c3;
 
   c1 = 0;
@@ -437,7 +456,7 @@ void bn_mul_comba4(BN_ULONG r[8], const BN_ULONG a[4], const BN_ULONG b[4]) {
   r[7] = c2;
 }
 
-void bn_sqr_comba8(BN_ULONG r[16], const BN_ULONG a[8]) {
+void bssl::bn_sqr_comba8(BN_ULONG r[16], const BN_ULONG a[8]) {
   BN_ULONG c1, c2, c3;
 
   c1 = 0;
@@ -511,7 +530,7 @@ void bn_sqr_comba8(BN_ULONG r[16], const BN_ULONG a[8]) {
   r[15] = c1;
 }
 
-void bn_sqr_comba4(BN_ULONG r[8], const BN_ULONG a[4]) {
+void bssl::bn_sqr_comba4(BN_ULONG r[8], const BN_ULONG a[4]) {
   BN_ULONG c1, c2, c3;
 
   c1 = 0;

data/third_party/boringssl-with-bazel/crypto/fipsmodule/bn/bn.cc.inc

@@ -21,20 +21,23 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
+#include "../../mem_internal.h"
 #include "../delocate.h"
 #include "internal.h"
 
 
-// BN_MAX_WORDS is the maximum number of words allowed in a |BIGNUM|. It is
-// sized so byte and bit counts of a |BIGNUM| always fit in |int|, with room to
+using namespace bssl;
+
+// BN_MAX_WORDS is the maximum number of words allowed in a `BIGNUM`. It is
+// sized so byte and bit counts of a `BIGNUM` always fit in `int`, with room to
 // spare.
 #define BN_MAX_WORDS (INT_MAX / (4 * BN_BITS2))
 
-BIGNUM *BN_new(void) {
-  BIGNUM *bn = reinterpret_cast<BIGNUM *>(OPENSSL_malloc(sizeof(BIGNUM)));
+BIGNUM *BN_new() {
+  BIGNUM *bn = New<BIGNUM>();
 
-  if (bn == NULL) {
-    return NULL;
+  if (bn == nullptr) {
+    return nullptr;
   }
 
   OPENSSL_memset(bn, 0, sizeof(BIGNUM));
@@ -43,12 +46,12 @@ BIGNUM *BN_new(void) {
   return bn;
 }
 
-BIGNUM *BN_secure_new(void) { return BN_new(); }
+BIGNUM *BN_secure_new() { return BN_new(); }
 
 void BN_init(BIGNUM *bn) { OPENSSL_memset(bn, 0, sizeof(BIGNUM)); }
 
 void BN_free(BIGNUM *bn) {
-  if (bn == NULL) {
+  if (bn == nullptr) {
     return;
   }
 
@@ -57,9 +60,9 @@ void BN_free(BIGNUM *bn) {
   }
 
   if (bn->flags & BN_FLG_MALLOCED) {
-    OPENSSL_free(bn);
+    Delete(bn);
   } else {
-    bn->d = NULL;
+    bn->d = nullptr;
   }
 }
 
@@ -68,18 +71,18 @@ void BN_clear_free(BIGNUM *bn) { BN_free(bn); }
 BIGNUM *BN_dup(const BIGNUM *src) {
   BIGNUM *copy;
 
-  if (src == NULL) {
-    return NULL;
+  if (src == nullptr) {
+    return nullptr;
   }
 
   copy = BN_new();
-  if (copy == NULL) {
-    return NULL;
+  if (copy == nullptr) {
+    return nullptr;
   }
 
   if (!BN_copy(copy, src)) {
     BN_free(copy);
-    return NULL;
+    return nullptr;
   }
 
   return copy;
@@ -91,7 +94,7 @@ BIGNUM *BN_copy(BIGNUM *dest, const BIGNUM *src) {
   }
 
   if (!bn_wexpand(dest, src->width)) {
-    return NULL;
+    return nullptr;
   }
 
   OPENSSL_memcpy(dest->d, src->d, sizeof(src->d[0]) * src->width);
@@ -102,7 +105,7 @@ BIGNUM *BN_copy(BIGNUM *dest, const BIGNUM *src) {
 }
 
 void BN_clear(BIGNUM *bn) {
-  if (bn->d != NULL) {
+  if (bn->d != nullptr) {
     OPENSSL_memset(bn->d, 0, bn->dmax * sizeof(bn->d[0]));
   }
 
@@ -120,25 +123,25 @@ DEFINE_METHOD_FUNCTION(BIGNUM, BN_value_one) {
 }
 
 // BN_num_bits_word returns the minimum number of bits needed to represent the
-// value in |l|.
+// value in `l`.
 unsigned BN_num_bits_word(BN_ULONG l) {
-  // |BN_num_bits| is often called on RSA prime factors. These have public bit
+  // `BN_num_bits` is often called on RSA prime factors. These have public bit
   // lengths, but all bits beyond the high bit are secret, so count bits in
   // constant time.
   BN_ULONG x, mask;
   int bits = (l != 0);
 
 #if BN_BITS2 > 32
-  // Look at the upper half of |x|. |x| is at most 64 bits long.
+  // Look at the upper half of `x`. `x` is at most 64 bits long.
   x = l >> 32;
-  // Set |mask| to all ones if |x| (the top 32 bits of |l|) is non-zero and all
+  // Set `mask` to all ones if `x` (the top 32 bits of `l`) is non-zero and all
   // all zeros otherwise.
   mask = 0u - x;
   mask = (0u - (mask >> (BN_BITS2 - 1)));
-  // If |x| is non-zero, the lower half is included in the bit count in full,
+  // If `x` is non-zero, the lower half is included in the bit count in full,
   // and we count the upper half. Otherwise, we count the lower half.
   bits += 32 & mask;
-  l ^= (x ^ l) & mask;  // |l| is |x| if |mask| and remains |l| otherwise.
+  l ^= (x ^ l) & mask;  // `l` is `x` if `mask` and remains `l` otherwise.
 #endif
 
   // The remaining blocks are analogous iterations at lower powers of two.
@@ -227,18 +230,18 @@ int BN_set_u64(BIGNUM *bn, uint64_t value) {
 #endif
 }
 
-int bn_set_words(BIGNUM *bn, const BN_ULONG *words, size_t num) {
+int bssl::bn_set_words(BIGNUM *bn, const BN_ULONG *words, size_t num) {
   if (!bn_wexpand(bn, num)) {
     return 0;
   }
   OPENSSL_memmove(bn->d, words, num * sizeof(BN_ULONG));
-  // |bn_wexpand| verified that |num| isn't too large.
+  // `bn_wexpand` verified that `num` isn't too large.
   bn->width = (int)num;
   bn->neg = 0;
   return 1;
 }
 
-void bn_set_static_words(BIGNUM *bn, const BN_ULONG *words, size_t num) {
+void bssl::bn_set_static_words(BIGNUM *bn, const BN_ULONG *words, size_t num) {
   if ((bn->flags & BN_FLG_STATIC_DATA) == 0) {
     OPENSSL_free(bn->d);
   }
@@ -251,8 +254,8 @@ void bn_set_static_words(BIGNUM *bn, const BN_ULONG *words, size_t num) {
   bn->flags |= BN_FLG_STATIC_DATA;
 }
 
-int bn_fits_in_words(const BIGNUM *bn, size_t num) {
-  // All words beyond |num| must be zero.
+int bssl::bn_fits_in_words(const BIGNUM *bn, size_t num) {
+  // All words beyond `num` must be zero.
   BN_ULONG mask = 0;
   for (size_t i = num; i < (size_t)bn->width; i++) {
     mask |= bn->d[i];
@@ -260,7 +263,7 @@ int bn_fits_in_words(const BIGNUM *bn, size_t num) {
   return mask == 0;
 }
 
-int bn_copy_words(BN_ULONG *out, size_t num, const BIGNUM *bn) {
+int bssl::bn_copy_words(BN_ULONG *out, size_t num, const BIGNUM *bn) {
   if (bn->neg) {
     OPENSSL_PUT_ERROR(BN, BN_R_NEGATIVE_NUMBER);
     return 0;
@@ -290,7 +293,7 @@ void BN_set_negative(BIGNUM *bn, int sign) {
   }
 }
 
-int bn_wexpand(BIGNUM *bn, size_t words) {
+int bssl::bn_wexpand(BIGNUM *bn, size_t words) {
   BN_ULONG *a;
 
   if (words <= (size_t)bn->dmax) {
@@ -308,7 +311,7 @@ int bn_wexpand(BIGNUM *bn, size_t words) {
   }
 
   a = reinterpret_cast<BN_ULONG *>(OPENSSL_calloc(words, sizeof(BN_ULONG)));
-  if (a == NULL) {
+  if (a == nullptr) {
     return 0;
   }
 
@@ -321,7 +324,7 @@ int bn_wexpand(BIGNUM *bn, size_t words) {
   return 1;
 }
 
-int bn_expand(BIGNUM *bn, size_t bits) {
+int bssl::bn_expand(BIGNUM *bn, size_t bits) {
   if (bits + BN_BITS2 - 1 < bits) {
     OPENSSL_PUT_ERROR(BN, BN_R_BIGNUM_TOO_LONG);
     return 0;
@@ -329,7 +332,7 @@ int bn_expand(BIGNUM *bn, size_t bits) {
   return bn_wexpand(bn, (bits + BN_BITS2 - 1) / BN_BITS2);
 }
 
-int bn_resize_words(BIGNUM *bn, size_t words) {
+int bssl::bn_resize_words(BIGNUM *bn, size_t words) {
   if ((size_t)bn->width <= words) {
     if (!bn_wexpand(bn, words)) {
       return 0;
@@ -349,8 +352,8 @@ int bn_resize_words(BIGNUM *bn, size_t words) {
   return 1;
 }
 
-void bn_select_words(BN_ULONG *r, BN_ULONG mask, const BN_ULONG *a,
-                     const BN_ULONG *b, size_t num) {
+void bssl::bn_select_words(BN_ULONG *r, BN_ULONG mask, const BN_ULONG *a,
+                           const BN_ULONG *b, size_t num) {
   for (size_t i = 0; i < num; i++) {
     static_assert(sizeof(BN_ULONG) <= sizeof(crypto_word_t),
                   "crypto_word_t is too small");
@@ -358,7 +361,7 @@ void bn_select_words(BN_ULONG *r, BN_ULONG mask, const BN_ULONG *a,
   }
 }
 
-int bn_minimal_width(const BIGNUM *bn) {
+int bssl::bn_minimal_width(const BIGNUM *bn) {
   int ret = bn->width;
   while (ret > 0 && bn->d[ret - 1] == 0) {
     ret--;
@@ -366,7 +369,7 @@ int bn_minimal_width(const BIGNUM *bn) {
   return ret;
 }
 
-void bn_set_minimal_width(BIGNUM *bn) {
+void bssl::bn_set_minimal_width(BIGNUM *bn) {
   bn->width = bn_minimal_width(bn);
   if (bn->width == 0) {
     bn->neg = 0;

data/third_party/boringssl-with-bazel/crypto/fipsmodule/bn/bytes.cc.inc

@@ -19,10 +19,13 @@
 
 #include "internal.h"
 
-void bn_big_endian_to_words(BN_ULONG *out, size_t out_len, const uint8_t *in,
-                            size_t in_len) {
-  // The caller should have sized |out| to fit |in| without truncating. This
-  // condition ensures we do not overflow |out|, so use a runtime check.
+
+using namespace bssl;
+
+void bssl::bn_big_endian_to_words(BN_ULONG *out, size_t out_len,
+                                  const uint8_t *in, size_t in_len) {
+  // The caller should have sized `out` to fit `in` without truncating. This
+  // condition ensures we do not overflow `out`, so use a runtime check.
   BSSL_CHECK(in_len <= out_len * sizeof(BN_ULONG));
 
   // Load whole words.
@@ -49,28 +52,29 @@ void bn_big_endian_to_words(BN_ULONG *out, size_t out_len, const uint8_t *in,
 }
 
 BIGNUM *BN_bin2bn(const uint8_t *in, size_t len, BIGNUM *ret) {
-  BIGNUM *bn = NULL;
-  if (ret == NULL) {
+  BIGNUM *bn = nullptr;
+  if (ret == nullptr) {
     bn = BN_new();
-    if (bn == NULL) {
-      return NULL;
+    if (bn == nullptr) {
+      return nullptr;
     }
     ret = bn;
   }
 
   if (len == 0) {
     ret->width = 0;
+    ret->neg = 0;
     return ret;
   }
 
   size_t num_words = ((len - 1) / BN_BYTES) + 1;
   if (!bn_wexpand(ret, num_words)) {
     BN_free(bn);
-    return NULL;
+    return nullptr;
   }
 
-  // |bn_wexpand| must check bounds on |num_words| to write it into
-  // |ret->dmax|.
+  // `bn_wexpand` must check bounds on `num_words` to write it into
+  // `ret->dmax`.
   assert(num_words <= INT_MAX);
   ret->width = (int)num_words;
   ret->neg = 0;
@@ -80,11 +84,11 @@ BIGNUM *BN_bin2bn(const uint8_t *in, size_t len, BIGNUM *ret) {
 }
 
 BIGNUM *BN_lebin2bn(const uint8_t *in, size_t len, BIGNUM *ret) {
-  BIGNUM *bn = NULL;
-  if (ret == NULL) {
+  BIGNUM *bn = nullptr;
+  if (ret == nullptr) {
     bn = BN_new();
-    if (bn == NULL) {
-      return NULL;
+    if (bn == nullptr) {
+      return nullptr;
     }
     ret = bn;
   }
@@ -95,13 +99,14 @@ BIGNUM *BN_lebin2bn(const uint8_t *in, size_t len, BIGNUM *ret) {
     return ret;
   }
 
-  // Reserve enough space in |ret|.
+  // Reserve enough space in `ret`.
   size_t num_words = ((len - 1) / BN_BYTES) + 1;
   if (!bn_wexpand(ret, num_words)) {
     BN_free(bn);
-    return NULL;
+    return nullptr;
   }
   ret->width = (int)num_words;
+  ret->neg = 0;
 
   // Make sure the top bytes will be zeroed.
   ret->d[num_words - 1] = 0;
@@ -116,8 +121,8 @@ BIGNUM *BN_le2bn(const uint8_t *in, size_t len, BIGNUM *ret) {
   return BN_lebin2bn(in, len, ret);
 }
 
-// fits_in_bytes returns one if the |num_words| words in |words| can be
-// represented in |num_bytes| bytes.
+// fits_in_bytes returns one if the `num_words` words in `words` can be
+// represented in `num_bytes` bytes.
 static int fits_in_bytes(const BN_ULONG *words, size_t num_words,
                          size_t num_bytes) {
   const uint8_t *bytes = (const uint8_t *)words;
@@ -129,7 +134,7 @@ static int fits_in_bytes(const BN_ULONG *words, size_t num_words,
   return mask == 0;
 }
 
-void bn_assert_fits_in_bytes(const BIGNUM *bn, size_t num) {
+void bssl::bn_assert_fits_in_bytes(const BIGNUM *bn, size_t num) {
   const uint8_t *bytes = (const uint8_t *)bn->d;
   size_t tot_bytes = bn->width * sizeof(BN_ULONG);
   if (tot_bytes > num) {
@@ -141,8 +146,8 @@ void bn_assert_fits_in_bytes(const BIGNUM *bn, size_t num) {
   }
 }
 
-void bn_words_to_big_endian(uint8_t *out, size_t out_len, const BN_ULONG *in,
-                            size_t in_len) {
+void bssl::bn_words_to_big_endian(uint8_t *out, size_t out_len,
+                                  const BN_ULONG *in, size_t in_len) {
   // The caller should have selected an output length without truncation.
   declassify_assert(fits_in_bytes(in, in_len, out_len));
 

data/third_party/boringssl-with-bazel/crypto/fipsmodule/bn/cmp.cc.inc

@@ -22,6 +22,8 @@
 #include "../../internal.h"
 
 
+using namespace bssl;
+
 static int bn_cmp_words_consttime(const BN_ULONG *a, size_t a_len,
                                   const BN_ULONG *b, size_t b_len) {
   static_assert(sizeof(BN_ULONG) <= sizeof(crypto_word_t),
@@ -36,7 +38,7 @@ static int bn_cmp_words_consttime(const BN_ULONG *a, size_t a_len,
         constant_time_select_int(eq, ret, constant_time_select_int(lt, -1, 1));
   }
 
-  // If |a| or |b| has non-zero words beyond |min|, they take precedence.
+  // If `a` or `b` has non-zero words beyond `min`, they take precedence.
   if (a_len < b_len) {
     crypto_word_t mask = 0;
     for (size_t i = a_len; i < b_len; i++) {
@@ -59,10 +61,10 @@ int BN_ucmp(const BIGNUM *a, const BIGNUM *b) {
 }
 
 int BN_cmp(const BIGNUM *a, const BIGNUM *b) {
-  if ((a == NULL) || (b == NULL)) {
-    if (a != NULL) {
+  if ((a == nullptr) || (b == nullptr)) {
+    if (a != nullptr) {
       return -1;
-    } else if (b != NULL) {
+    } else if (b != nullptr) {
       return 1;
     } else {
       return 0;
@@ -70,7 +72,7 @@ int BN_cmp(const BIGNUM *a, const BIGNUM *b) {
   }
 
   // We do not attempt to process the sign bit in constant time. Negative
-  // |BIGNUM|s should never occur in crypto, only calculators.
+  // `BIGNUM`s should never occur in crypto, only calculators.
   if (a->neg != b->neg) {
     if (a->neg) {
       return -1;
@@ -82,7 +84,7 @@ int BN_cmp(const BIGNUM *a, const BIGNUM *b) {
   return a->neg ? -ret : ret;
 }
 
-int bn_less_than_words(const BN_ULONG *a, const BN_ULONG *b, size_t len) {
+int bssl::bn_less_than_words(const BN_ULONG *a, const BN_ULONG *b, size_t len) {
   return bn_cmp_words_consttime(a, len, b, len) < 0;
 }
 
@@ -141,7 +143,7 @@ int BN_is_pow2(const BIGNUM *bn) {
 
 int BN_equal_consttime(const BIGNUM *a, const BIGNUM *b) {
   BN_ULONG mask = 0;
-  // If |a| or |b| has more words than the other, all those words must be zero.
+  // If `a` or `b` has more words than the other, all those words must be zero.
   for (int i = a->width; i < b->width; i++) {
     mask |= b->d[i];
   }