grpc 1.81.1 → 1.85.0

data/third_party/boringssl-with-bazel/crypto/asn1/tasn_fre.cc

@@ -21,13 +21,16 @@
 
 #include "internal.h"
 
+
+using namespace bssl;
+
 // Free up an ASN1 structure
 
 void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it) {
   ASN1_item_ex_free(&val, it);
 }
 
-void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+void bssl::ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   if (!pval) {
     return;
   }
@@ -50,9 +53,9 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
 
     case ASN1_ITYPE_CHOICE: {
       const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
-      ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
+      ASN1_aux_cb *asn1_cb = aux != nullptr ? aux->asn1_cb : nullptr;
       if (asn1_cb) {
-        if (asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL) == 2) {
+        if (asn1_cb(ASN1_OP_FREE_PRE, pval, it, nullptr) == 2) {
           return;
         }
       }
@@ -63,10 +66,10 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
         ASN1_template_free(pchval, tt);
       }
       if (asn1_cb) {
-        asn1_cb(ASN1_OP_FREE_POST, pval, it, NULL);
+        asn1_cb(ASN1_OP_FREE_POST, pval, it, nullptr);
       }
       OPENSSL_free(*pval);
-      *pval = NULL;
+      *pval = nullptr;
       break;
     }
 
@@ -84,15 +87,15 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
         return;
       }
       const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
-      ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
+      ASN1_aux_cb *asn1_cb = aux != nullptr ? aux->asn1_cb : nullptr;
       if (asn1_cb) {
-        if (asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL) == 2) {
+        if (asn1_cb(ASN1_OP_FREE_PRE, pval, it, nullptr) == 2) {
           return;
         }
       }
       asn1_enc_free(pval, it);
       // If we free up as normal we will invalidate any ANY DEFINED BY
-      // field and we wont be able to determine the type of the field it
+      // field and we won't be able to determine the type of the field it
       // defines. So free up in reverse order.
       for (int i = it->tcount - 1; i >= 0; i--) {
         const ASN1_TEMPLATE *seqtt = asn1_do_adb(pval, &it->templates[i], 0);
@@ -103,16 +106,16 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
         ASN1_template_free(pseqval, seqtt);
       }
       if (asn1_cb) {
-        asn1_cb(ASN1_OP_FREE_POST, pval, it, NULL);
+        asn1_cb(ASN1_OP_FREE_POST, pval, it, nullptr);
       }
       OPENSSL_free(*pval);
-      *pval = NULL;
+      *pval = nullptr;
       break;
     }
   }
 }
 
-void ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
+void bssl::ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
   if (tt->flags & ASN1_TFLG_SK_MASK) {
     STACK_OF(ASN1_VALUE) *sk = (STACK_OF(ASN1_VALUE) *)*pval;
     for (size_t i = 0; i < sk_ASN1_VALUE_num(sk); i++) {
@@ -120,16 +123,16 @@ void ASN1_template_free(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
       ASN1_item_ex_free(&vtmp, ASN1_ITEM_ptr(tt->item));
     }
     sk_ASN1_VALUE_free(sk);
-    *pval = NULL;
+    *pval = nullptr;
   } else {
     ASN1_item_ex_free(pval, ASN1_ITEM_ptr(tt->item));
   }
 }
 
-void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
-  // Historically, |it->funcs| for primitive types contained an
-  // |ASN1_PRIMITIVE_FUNCS| table of calbacks.
-  assert(it->funcs == NULL);
+void bssl::ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+  // Historically, `it->funcs` for primitive types contained an
+  // `ASN1_PRIMITIVE_FUNCS` table of callbacks.
+  assert(it->funcs == nullptr);
 
   int utype = it->itype == ASN1_ITYPE_MSTRING ? -1 : it->utype;
   switch (utype) {
@@ -149,7 +152,7 @@ void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
       break;
 
     case V_ASN1_ANY:
-      if (*pval != NULL) {
+      if (*pval != nullptr) {
         asn1_type_cleanup((ASN1_TYPE *)*pval);
         OPENSSL_free(*pval);
       }
@@ -157,8 +160,8 @@ void ASN1_primitive_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
 
     default:
       ASN1_STRING_free((ASN1_STRING *)*pval);
-      *pval = NULL;
+      *pval = nullptr;
       break;
   }
-  *pval = NULL;
+  *pval = nullptr;
 }

data/third_party/boringssl-with-bazel/crypto/asn1/tasn_new.cc

@@ -22,9 +22,12 @@
 #include <openssl/obj.h>
 
 #include "../internal.h"
+#include "../mem_internal.h"
 #include "internal.h"
 
 
+using namespace bssl;
+
 static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
 static int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
 static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
@@ -32,17 +35,17 @@ static int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
 static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
 
 ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it) {
-  ASN1_VALUE *ret = NULL;
+  ASN1_VALUE *ret = nullptr;
   if (ASN1_item_ex_new(&ret, it) > 0) {
     return ret;
   }
-  return NULL;
+  return nullptr;
 }
 
 // Allocate an ASN1 structure
 
-int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
-  const ASN1_TEMPLATE *tt = NULL;
+int bssl::ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+  const ASN1_TEMPLATE *tt = nullptr;
   const ASN1_EXTERN_FUNCS *ef;
   ASN1_VALUE **pseqval;
   int i;
@@ -75,9 +78,9 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
 
     case ASN1_ITYPE_CHOICE: {
       const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
-      ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
+      ASN1_aux_cb *asn1_cb = aux != nullptr ? aux->asn1_cb : nullptr;
       if (asn1_cb) {
-        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
+        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, nullptr);
         if (!i) {
           goto auxerr;
         }
@@ -90,7 +93,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
         goto memerr;
       }
       asn1_set_choice_selector(pval, -1, it);
-      if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL)) {
+      if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, nullptr)) {
         goto auxerr2;
       }
       break;
@@ -98,9 +101,9 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
 
     case ASN1_ITYPE_SEQUENCE: {
       const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
-      ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
+      ASN1_aux_cb *asn1_cb = aux != nullptr ? aux->asn1_cb : nullptr;
       if (asn1_cb) {
-        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
+        i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, nullptr);
         if (!i) {
           goto auxerr;
         }
@@ -120,7 +123,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
           goto memerr2;
         }
       }
-      if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL)) {
+      if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, nullptr)) {
         goto auxerr2;
       }
       break;
@@ -143,7 +146,7 @@ auxerr:
 static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   switch (it->itype) {
     case ASN1_ITYPE_EXTERN:
-      *pval = NULL;
+      *pval = nullptr;
       break;
 
     case ASN1_ITYPE_PRIMITIVE:
@@ -160,7 +163,7 @@ static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it) {
 
     case ASN1_ITYPE_CHOICE:
     case ASN1_ITYPE_SEQUENCE:
-      *pval = NULL;
+      *pval = nullptr;
       break;
   }
 }
@@ -175,7 +178,7 @@ static int ASN1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
   // If ANY DEFINED BY nothing to do
 
   if (tt->flags & ASN1_TFLG_ADB_MASK) {
-    *pval = NULL;
+    *pval = nullptr;
     return 1;
   }
   // If SET OF or SEQUENCE OF, its a STACK
@@ -199,7 +202,7 @@ done:
 static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
   // If ADB or STACK just NULL the field
   if (tt->flags & (ASN1_TFLG_ADB_MASK | ASN1_TFLG_SK_MASK)) {
-    *pval = NULL;
+    *pval = nullptr;
   } else {
     asn1_item_clear(pval, ASN1_ITEM_ptr(tt->item));
   }
@@ -213,9 +216,9 @@ static int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
     return 0;
   }
 
-  // Historically, |it->funcs| for primitive types contained an
-  // |ASN1_PRIMITIVE_FUNCS| table of calbacks.
-  assert(it->funcs == NULL);
+  // Historically, `it->funcs` for primitive types contained an
+  // `ASN1_PRIMITIVE_FUNCS` table of callbacks.
+  assert(it->funcs == nullptr);
 
   int utype;
   if (it->itype == ASN1_ITYPE_MSTRING) {
@@ -237,12 +240,11 @@ static int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
       return 1;
 
     case V_ASN1_ANY: {
-      ASN1_TYPE *typ =
-          reinterpret_cast<ASN1_TYPE *>(OPENSSL_malloc(sizeof(ASN1_TYPE)));
+      ASN1_TYPE *typ = New<ASN1_TYPE>();
       if (!typ) {
         return 0;
       }
-      typ->value.ptr = NULL;
+      typ->value.ptr = nullptr;
       typ->type = -1;
       *pval = (ASN1_VALUE *)typ;
       break;
@@ -260,9 +262,9 @@ static int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
 
 static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   int utype;
-  // Historically, |it->funcs| for primitive types contained an
-  // |ASN1_PRIMITIVE_FUNCS| table of calbacks.
-  assert(it == NULL || it->funcs == NULL);
+  // Historically, `it->funcs` for primitive types contained an
+  // `ASN1_PRIMITIVE_FUNCS` table of callbacks.
+  assert(it == nullptr || it->funcs == nullptr);
   if (!it || (it->itype == ASN1_ITYPE_MSTRING)) {
     utype = -1;
   } else {
@@ -271,6 +273,6 @@ static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   if (utype == V_ASN1_BOOLEAN) {
     *(ASN1_BOOLEAN *)pval = (ASN1_BOOLEAN)it->size;
   } else {
-    *pval = NULL;
+    *pval = nullptr;
   }
 }

data/third_party/boringssl-with-bazel/crypto/asn1/tasn_typ.cc

@@ -19,10 +19,15 @@
 #include "internal.h"
 
 
-#define IMPLEMENT_ASN1_STRING_FUNCTIONS(sname)                         \
-  IMPLEMENT_ASN1_TYPE(sname)                                           \
-  IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(sname, sname, sname)     \
-  sname *sname##_new(void) { return ASN1_STRING_type_new(V_##sname); } \
+using namespace bssl;
+
+// TODO(crbug.com/42290417): While we need `ASN1_ITEM`s, the exposed new, free,
+// i2d, and d2i functions should call the underlying implementations directly.
+
+#define IMPLEMENT_ASN1_STRING_FUNCTIONS(sname)                     \
+  IMPLEMENT_ASN1_TYPE(sname)                                       \
+  IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(sname, sname, sname) \
+  sname *sname##_new() { return ASN1_STRING_type_new(V_##sname); } \
   void sname##_free(sname *x) { ASN1_STRING_free(x); }
 
 IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
@@ -46,17 +51,26 @@ IMPLEMENT_ASN1_FUNCTIONS_const(ASN1_NULL)
 IMPLEMENT_ASN1_TYPE(ASN1_OBJECT)
 
 IMPLEMENT_ASN1_TYPE(ASN1_ANY)
-IMPLEMENT_ASN1_TYPE(ASN1_ANY_AS_STRING)
 
 // Just swallow an ASN1_SEQUENCE in an ASN1_STRING
 IMPLEMENT_ASN1_TYPE(ASN1_SEQUENCE)
 
 IMPLEMENT_ASN1_FUNCTIONS_const_fname(ASN1_TYPE, ASN1_ANY, ASN1_TYPE)
 
+BSSL_NAMESPACE_BEGIN
+
 IMPLEMENT_ASN1_MSTRING(DISPLAYTEXT, B_ASN1_DISPLAYTEXT)
+
+BSSL_NAMESPACE_END
+
 IMPLEMENT_ASN1_FUNCTIONS_const_fname(ASN1_STRING, DISPLAYTEXT, DISPLAYTEXT)
 
+BSSL_NAMESPACE_BEGIN
+
 IMPLEMENT_ASN1_MSTRING(DIRECTORYSTRING, B_ASN1_DIRECTORYSTRING)
+
+BSSL_NAMESPACE_END
+
 IMPLEMENT_ASN1_FUNCTIONS_const_fname(ASN1_STRING, DIRECTORYSTRING,
                                      DIRECTORYSTRING)
 

data/third_party/boringssl-with-bazel/crypto/asn1/tasn_utl.cc

@@ -22,26 +22,27 @@
 #include <openssl/mem.h>
 #include <openssl/obj.h>
 #include <openssl/pool.h>
-#include <openssl/thread.h>
 
 #include "../internal.h"
 #include "internal.h"
 
 
+using namespace bssl;
+
 // Utility functions for manipulating fields and offsets
 
 // Add 'offset' to 'addr'
 #define offset2ptr(addr, offset) (void *)(((char *)(addr)) + (offset))
 
 // Given an ASN1_ITEM CHOICE type return the selector value
-int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+int bssl::asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   int *sel = reinterpret_cast<int *>(offset2ptr(*pval, it->utype));
   return *sel;
 }
 
 // Given an ASN1_ITEM CHOICE type set the selector value, return old value.
-int asn1_set_choice_selector(ASN1_VALUE **pval, int value,
-                             const ASN1_ITEM *it) {
+int bssl::asn1_set_choice_selector(ASN1_VALUE **pval, int value,
+                                   const ASN1_ITEM *it) {
   int *sel, ret;
   sel = reinterpret_cast<int *>(offset2ptr(*pval, it->utype));
   ret = *sel;
@@ -52,26 +53,27 @@ int asn1_set_choice_selector(ASN1_VALUE **pval, int value,
 static CRYPTO_refcount_t *asn1_get_references(ASN1_VALUE **pval,
                                               const ASN1_ITEM *it) {
   if (it->itype != ASN1_ITYPE_SEQUENCE) {
-    return NULL;
+    return nullptr;
   }
   const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
   if (!aux || !(aux->flags & ASN1_AFLG_REFCOUNT)) {
-    return NULL;
+    return nullptr;
   }
   return reinterpret_cast<CRYPTO_refcount_t *>(
       offset2ptr(*pval, aux->ref_offset));
 }
 
-void asn1_refcount_set_one(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+void bssl::asn1_refcount_set_one(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   CRYPTO_refcount_t *references = asn1_get_references(pval, it);
-  if (references != NULL) {
+  if (references != nullptr) {
     *references = 1;
   }
 }
 
-int asn1_refcount_dec_and_test_zero(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+int bssl::asn1_refcount_dec_and_test_zero(ASN1_VALUE **pval,
+                                          const ASN1_ITEM *it) {
   CRYPTO_refcount_t *references = asn1_get_references(pval, it);
-  if (references != NULL) {
+  if (references != nullptr) {
     return CRYPTO_refcount_dec_and_test_zero(references);
   }
   return 1;
@@ -81,33 +83,32 @@ static ASN1_ENCODING *asn1_get_enc_ptr(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   assert(it->itype == ASN1_ITYPE_SEQUENCE);
   const ASN1_AUX *aux;
   if (!pval || !*pval) {
-    return NULL;
+    return nullptr;
   }
   aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
   if (!aux || !(aux->flags & ASN1_AFLG_ENCODING)) {
-    return NULL;
+    return nullptr;
   }
   return reinterpret_cast<ASN1_ENCODING *>(offset2ptr(*pval, aux->enc_offset));
 }
 
-void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+void bssl::asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   ASN1_ENCODING *enc = asn1_get_enc_ptr(pval, it);
   if (enc) {
-    enc->enc = NULL;
+    enc->enc = nullptr;
     enc->len = 0;
-    enc->buf = NULL;
   }
 }
 
-void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
+void bssl::asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
   ASN1_ENCODING *enc = asn1_get_enc_ptr(pval, it);
   if (enc) {
     asn1_encoding_clear(enc);
   }
 }
 
-int asn1_enc_save(ASN1_VALUE **pval, const uint8_t *in, size_t in_len,
-                  const ASN1_ITEM *it, CRYPTO_BUFFER *buf) {
+int bssl::asn1_enc_save(ASN1_VALUE **pval, const uint8_t *in, size_t in_len,
+                        const ASN1_ITEM *it) {
   ASN1_ENCODING *enc;
   enc = asn1_get_enc_ptr(pval, it);
   if (!enc) {
@@ -115,52 +116,34 @@ int asn1_enc_save(ASN1_VALUE **pval, const uint8_t *in, size_t in_len,
   }
 
   asn1_encoding_clear(enc);
-  if (buf != NULL) {
-    assert(CRYPTO_BUFFER_data(buf) <= in &&
-           in + in_len <= CRYPTO_BUFFER_data(buf) + CRYPTO_BUFFER_len(buf));
-    CRYPTO_BUFFER_up_ref(buf);
-    enc->buf = buf;
-    enc->enc = (uint8_t *)in;
-  } else {
-    enc->enc = reinterpret_cast<uint8_t *>(OPENSSL_memdup(in, in_len));
-    if (!enc->enc) {
-      return 0;
-    }
+  enc->enc = reinterpret_cast<uint8_t *>(OPENSSL_memdup(in, in_len));
+  if (!enc->enc) {
+    return 0;
   }
 
   enc->len = in_len;
   return 1;
 }
 
-void asn1_encoding_clear(ASN1_ENCODING *enc) {
-  if (enc->buf != NULL) {
-    CRYPTO_BUFFER_free(enc->buf);
-  } else {
-    OPENSSL_free(enc->enc);
-  }
-  enc->enc = NULL;
+void bssl::asn1_encoding_clear(ASN1_ENCODING *enc) {
+  OPENSSL_free(enc->enc);
+  enc->enc = nullptr;
   enc->len = 0;
-  enc->buf = NULL;
 }
 
-int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval,
-                     const ASN1_ITEM *it) {
+int bssl::asn1_enc_restore(Span<const uint8_t> *out, ASN1_VALUE **pval,
+                           const ASN1_ITEM *it) {
   ASN1_ENCODING *enc = asn1_get_enc_ptr(pval, it);
   if (!enc || enc->len == 0) {
     return 0;
   }
-  if (out) {
-    OPENSSL_memcpy(*out, enc->enc, enc->len);
-    *out += enc->len;
-  }
-  if (len) {
-    *len = enc->len;
-  }
+  *out = Span(enc->enc, enc->len);
   return 1;
 }
 
 // Given an ASN1_TEMPLATE get a pointer to a field
-ASN1_VALUE **asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
+ASN1_VALUE **bssl::asn1_get_field_ptr(ASN1_VALUE **pval,
+                                      const ASN1_TEMPLATE *tt) {
   ASN1_VALUE **pvaltmp =
       reinterpret_cast<ASN1_VALUE **>(offset2ptr(*pval, tt->offset));
   // NOTE for BOOLEAN types the field is just a plain int so we can't return
@@ -170,8 +153,8 @@ ASN1_VALUE **asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
 
 // Handle ANY DEFINED BY template, find the selector, look up the relevant
 // ASN1_TEMPLATE in the table and return it.
-const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
-                                 int nullerr) {
+const ASN1_TEMPLATE *bssl::asn1_do_adb(ASN1_VALUE **pval,
+                                       const ASN1_TEMPLATE *tt, int nullerr) {
   const ASN1_ADB *adb;
   const ASN1_ADB_TABLE *atbl;
   ASN1_VALUE **sfld;
@@ -188,7 +171,7 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
 
   // Check if NULL
   int selector;
-  if (*sfld == NULL) {
+  if (*sfld == nullptr) {
     if (!adb->null_tt) {
       goto err;
     }
@@ -225,5 +208,18 @@ err:
   if (nullerr) {
     OPENSSL_PUT_ERROR(ASN1, ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE);
   }
-  return NULL;
+  return nullptr;
+}
+
+CBS_ASN1_TAG bssl::asn1_tag_to_cbs(int aclass, int tag) {
+  if ((aclass & ASN1_TFLG_TAG_CLASS) != aclass ||  //
+      tag < 0 || static_cast<CBS_ASN1_TAG>(tag) > CBS_ASN1_TAG_NUMBER_MASK ||
+      // Universal tag zero is reserved and should never appear in a template.
+      // This file treats the zero tag as a sentinel value.
+      (aclass == 0 && tag == 0)) {
+    OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
+    return 0;
+  }
+  return ((static_cast<CBS_ASN1_TAG>(aclass)) << CBS_ASN1_TAG_SHIFT) |
+         static_cast<CBS_ASN1_TAG>(tag);
 }

data/third_party/boringssl-with-bazel/crypto/base64/base64.cc

@@ -19,22 +19,24 @@
 #include <string.h>
 
 #include "../internal.h"
+#include "../mem_internal.h"
 
 
-// constant_time_lt_args_8 behaves like |constant_time_lt_8| but takes |uint8_t|
+using namespace bssl;
+
+// constant_time_lt_args_8 behaves like `constant_time_lt_8` but takes `uint8_t`
 // arguments for a slightly simpler implementation.
-static inline uint8_t constant_time_lt_args_8(uint8_t a, uint8_t b) {
+static uint8_t constant_time_lt_args_8(uint8_t a, uint8_t b) {
   crypto_word_t aw = a;
   crypto_word_t bw = b;
-  // |crypto_word_t| is larger than |uint8_t|, so |aw| and |bw| have the same
-  // MSB. |aw| < |bw| iff MSB(|aw| - |bw|) is 1.
+  // `crypto_word_t` is larger than `uint8_t`, so `aw` and `bw` have the same
+  // MSB. `aw` < `bw` iff MSB(`aw` - `bw`) is 1.
   return constant_time_msb_w(aw - bw);
 }
 
-// constant_time_in_range_8 returns |CONSTTIME_TRUE_8| if |min| <= |a| <= |max|
-// and |CONSTTIME_FALSE_8| otherwise.
-static inline uint8_t constant_time_in_range_8(uint8_t a, uint8_t min,
-                                               uint8_t max) {
+// constant_time_in_range_8 returns `CONSTTIME_TRUE_8` if `min` <= `a` <= `max`
+// and `CONSTTIME_FALSE_8` otherwise.
+static uint8_t constant_time_in_range_8(uint8_t a, uint8_t min, uint8_t max) {
   a -= min;
   return constant_time_lt_args_8(a, max - min + 1);
 }
@@ -54,7 +56,7 @@ static uint8_t conv_bin2ascii(uint8_t a) {
   return ret;
 }
 
-static_assert(sizeof(((EVP_ENCODE_CTX *)(NULL))->data) % 3 == 0,
+static_assert(sizeof(((EVP_ENCODE_CTX *)nullptr)->data) % 3 == 0,
               "data length must be a multiple of base64 chunk size");
 
 int EVP_EncodedLength(size_t *out_len, size_t len) {
@@ -78,12 +80,9 @@ int EVP_EncodedLength(size_t *out_len, size_t len) {
   return 1;
 }
 
-EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void) {
-  return reinterpret_cast<EVP_ENCODE_CTX *>(
-      OPENSSL_zalloc(sizeof(EVP_ENCODE_CTX)));
-}
+EVP_ENCODE_CTX *EVP_ENCODE_CTX_new() { return New<EVP_ENCODE_CTX>(); }
 
-void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx) { OPENSSL_free(ctx); }
+void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx) { Delete(ctx); }
 
 void EVP_EncodeInit(EVP_ENCODE_CTX *ctx) {
   OPENSSL_memset(ctx, 0, sizeof(EVP_ENCODE_CTX));
@@ -243,7 +242,7 @@ static uint8_t base64_ascii_to_bin(uint8_t a) {
 }
 
 // base64_decode_quad decodes a single “quad” (i.e. four characters) of base64
-// data and writes up to three bytes to |out|. It sets |*out_num_bytes| to the
+// data and writes up to three bytes to `out`. It sets `*out_num_bytes` to the
 // number of bytes written, which will be less than three if the quad ended
 // with padding.  It returns one on success or zero on error.
 static int base64_decode_quad(uint8_t *out, size_t *out_num_bytes,

data/third_party/boringssl-with-bazel/crypto/bcm_support.h

@@ -19,38 +19,19 @@
 
 #include <stdio.h>
 
-// Provided by libcrypto, called from BCM
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
+BSSL_NAMESPACE_BEGIN
 
 // Provided by libcrypto, called from BCM
 
 // CRYPTO_init_sysrand initializes long-lived resources needed to draw entropy
 // from the operating system, if the operating system requires initialization.
-void CRYPTO_init_sysrand(void);
+void CRYPTO_init_sysrand();
 
-// CRYPTO_sysrand fills |len| bytes at |buf| with entropy from the operating
+// CRYPTO_sysrand fills `len` bytes at `buf` with entropy from the operating
 // system.
 void CRYPTO_sysrand(uint8_t *buf, size_t len);
 
-// CRYPTO_sysrand_if_available fills |len| bytes at |buf| with entropy from the
-// operating system, or early /dev/urandom data, and returns 1, _if_ the entropy
-// pool is initialized or if getrandom() is not available and not in FIPS mode.
-// Otherwise it will not block and will instead fill |buf| with all zeros and
-// return 0.
-int CRYPTO_sysrand_if_available(uint8_t *buf, size_t len);
-
-// CRYPTO_sysrand_for_seed fills |len| bytes at |buf| with entropy from the
-// operating system. It may draw from the |GRND_RANDOM| pool on Android,
-// depending on the vendor's configuration.
-void CRYPTO_sysrand_for_seed(uint8_t *buf, size_t len);
-
-// RAND_need_entropy is called whenever the BCM module has stopped because it
-// has run out of entropy.
-void RAND_need_entropy(size_t bytes_needed);
-
 // crypto_get_fork_generation returns the fork generation number for the current
 // process, or zero if not supported on the platform. The fork generation number
 // is a non-zero, strictly-monotonic counter with the property that, if queried
@@ -63,9 +44,9 @@ void RAND_need_entropy(size_t bytes_needed);
 // the save fork generation. Note this logic transparently handles platforms
 // which always return zero.
 //
-// This is not reliably supported on all platforms which implement |fork|, so it
+// This is not reliably supported on all platforms which implement `fork`, so it
 // should only be used as a hardening measure.
-OPENSSL_EXPORT uint64_t CRYPTO_get_fork_generation(void);
+OPENSSL_EXPORT uint64_t CRYPTO_get_fork_generation();
 
 // CRYPTO_fork_detect_force_madv_wipeonfork_for_testing is an internal detail
 // used for testing purposes.
@@ -74,11 +55,8 @@ OPENSSL_EXPORT void CRYPTO_fork_detect_force_madv_wipeonfork_for_testing(
 
 // CRYPTO_get_stderr returns stderr. This function exists to avoid BCM needing
 // a data dependency on libc.
-FILE *CRYPTO_get_stderr(void);
-
+FILE *CRYPTO_get_stderr();
 
-#if defined(__cplusplus)
-}  // extern C
-#endif
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_BCM_SUPPORT_H