grpc 1.84.0 → 1.85.0.pre1

data/third_party/boringssl-with-bazel/crypto/dsa/dsa_asn1.cc

@@ -21,65 +21,70 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
 #include "../bytestring/internal.h"
+#include "../mem_internal.h"
+#include "internal.h"
+
 
+using namespace bssl;
 
 // This function is in dsa_asn1.c rather than dsa.c because it is reachable from
-// |EVP_PKEY| parsers. This makes it easier for the static linker to drop most
+// `EVP_PKEY` parsers. This makes it easier for the static linker to drop most
 // of the DSA implementation.
-int dsa_check_key(const DSA *dsa) {
+int bssl::dsa_check_key(const DSAImpl *dsa) {
   if (!dsa->p || !dsa->q || !dsa->g) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_MISSING_PARAMETERS);
     return 0;
   }
 
   // Fully checking for invalid DSA groups is expensive, so security and
-  // correctness of the signature scheme depend on how |dsa| was computed. I.e.
+  // correctness of the signature scheme depend on how `dsa` was computed. I.e.
   // we leave "assurance of domain parameter validity" from FIPS 186-4 to the
   // caller. However, we check bounds on all values to avoid DoS vectors even
   // when domain parameters are invalid. In particular, signing will infinite
-  // loop if |g| is zero.
-  if (BN_is_negative(dsa->p) || BN_is_negative(dsa->q) || BN_is_zero(dsa->p) ||
-      BN_is_zero(dsa->q) || !BN_is_odd(dsa->p) || !BN_is_odd(dsa->q) ||
-      // |q| must be a prime divisor of |p - 1|, which implies |q < p|.
-      BN_cmp(dsa->q, dsa->p) >= 0 ||
-      // |g| is in the multiplicative group of |p|.
-      BN_is_negative(dsa->g) || BN_is_zero(dsa->g) ||
-      BN_cmp(dsa->g, dsa->p) >= 0) {
+  // loop if `g` is zero.
+  if (BN_is_negative(dsa->p.get()) || BN_is_negative(dsa->q.get()) ||
+      BN_is_zero(dsa->p.get()) || BN_is_zero(dsa->q.get()) ||
+      !BN_is_odd(dsa->p.get()) || !BN_is_odd(dsa->q.get()) ||
+      // `q` must be a prime divisor of `p - 1`, which implies `q < p`.
+      BN_cmp(dsa->q.get(), dsa->p.get()) >= 0 ||
+      // `g` is in the multiplicative group of `p`.
+      BN_is_negative(dsa->g.get()) || BN_is_zero(dsa->g.get()) ||
+      BN_cmp(dsa->g.get(), dsa->p.get()) >= 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_INVALID_PARAMETERS);
     return 0;
   }
 
   // FIPS 186-4 allows only three different sizes for q.
-  unsigned q_bits = BN_num_bits(dsa->q);
+  unsigned q_bits = BN_num_bits(dsa->q.get());
   if (q_bits != 160 && q_bits != 224 && q_bits != 256) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_BAD_Q_VALUE);
     return 0;
   }
 
-  // Bound |dsa->p| to avoid a DoS vector. Note this limit is much larger than
+  // Bound `dsa->p` to avoid a DoS vector. Note this limit is much larger than
   // the one in FIPS 186-4, which only allows L = 1024, 2048, and 3072.
-  if (BN_num_bits(dsa->p) > OPENSSL_DSA_MAX_MODULUS_BITS) {
+  if (BN_num_bits(dsa->p.get()) > OPENSSL_DSA_MAX_MODULUS_BITS) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_MODULUS_TOO_LARGE);
     return 0;
   }
 
-  if (dsa->pub_key != NULL) {
-    // The public key is also in the multiplicative group of |p|.
-    if (BN_is_negative(dsa->pub_key) || BN_is_zero(dsa->pub_key) ||
-        BN_cmp(dsa->pub_key, dsa->p) >= 0) {
+  if (dsa->pub_key != nullptr) {
+    // The public key is also in the multiplicative group of `p`.
+    if (BN_is_negative(dsa->pub_key.get()) || BN_is_zero(dsa->pub_key.get()) ||
+        BN_cmp(dsa->pub_key.get(), dsa->p.get()) >= 0) {
       OPENSSL_PUT_ERROR(DSA, DSA_R_INVALID_PARAMETERS);
       return 0;
     }
   }
 
-  if (dsa->priv_key != NULL) {
+  if (dsa->priv_key != nullptr) {
     // The private key is a non-zero element of the scalar field, determined by
-    // |q|.
-    if (BN_is_negative(dsa->priv_key) ||
-        constant_time_declassify_int(BN_is_zero(dsa->priv_key)) ||
-        constant_time_declassify_int(BN_cmp(dsa->priv_key, dsa->q) >= 0)) {
+    // `q`.
+    if (BN_is_negative(dsa->priv_key.get()) ||
+        constant_time_declassify_int(BN_is_zero(dsa->priv_key.get())) ||
+        constant_time_declassify_int(
+            BN_cmp(dsa->priv_key.get(), dsa->q.get()) >= 0)) {
       OPENSSL_PUT_ERROR(DSA, DSA_R_INVALID_PARAMETERS);
       return 0;
     }
@@ -88,17 +93,17 @@ int dsa_check_key(const DSA *dsa) {
   return 1;
 }
 
-static int parse_integer(CBS *cbs, BIGNUM **out) {
-  assert(*out == NULL);
-  *out = BN_new();
-  if (*out == NULL) {
+static int parse_integer(CBS *cbs, UniquePtr<BIGNUM> *out) {
+  assert(*out == nullptr);
+  out->reset(BN_new());
+  if (*out == nullptr) {
     return 0;
   }
-  return BN_parse_asn1_unsigned(cbs, *out);
+  return BN_parse_asn1_unsigned(cbs, out->get());
 }
 
 static int marshal_integer(CBB *cbb, BIGNUM *bn) {
-  if (bn == NULL) {
+  if (bn == nullptr) {
     // A DSA object may be missing some components.
     OPENSSL_PUT_ERROR(DSA, ERR_R_PASSED_NULL_PARAMETER);
     return 0;
@@ -108,18 +113,21 @@ static int marshal_integer(CBB *cbb, BIGNUM *bn) {
 
 DSA_SIG *DSA_SIG_parse(CBS *cbs) {
   DSA_SIG *ret = DSA_SIG_new();
-  if (ret == NULL) {
-    return NULL;
+  if (ret == nullptr) {
+    return nullptr;
   }
   CBS child;
+  UniquePtr<BIGNUM> r, s;
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
-      !parse_integer(&child, &ret->r) ||
-      !parse_integer(&child, &ret->s) ||
+      !parse_integer(&child, &r) ||
+      !parse_integer(&child, &s) ||
       CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
     DSA_SIG_free(ret);
-    return NULL;
+    return nullptr;
   }
+  ret->r = r.release();
+  ret->s = s.release();
   return ret;
 }
 
@@ -136,9 +144,9 @@ int DSA_SIG_marshal(CBB *cbb, const DSA_SIG *sig) {
 }
 
 DSA *DSA_parse_public_key(CBS *cbs) {
-  DSA *ret = DSA_new();
-  if (ret == NULL) {
-    return NULL;
+  UniquePtr<DSAImpl> ret(FromOpaque(DSA_new()));
+  if (ret == nullptr) {
+    return nullptr;
   }
   CBS child;
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
@@ -148,26 +156,23 @@ DSA *DSA_parse_public_key(CBS *cbs) {
       !parse_integer(&child, &ret->g) ||
       CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
-    goto err;
+    return nullptr;
   }
-  if (!dsa_check_key(ret)) {
-    goto err;
+  if (!dsa_check_key(ret.get())) {
+    return nullptr;
   }
-  return ret;
-
-err:
-  DSA_free(ret);
-  return NULL;
+  return ret.release();
 }
 
 int DSA_marshal_public_key(CBB *cbb, const DSA *dsa) {
+  const auto *impl = FromOpaque(dsa);
+
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_SEQUENCE) ||
-      !marshal_integer(&child, dsa->pub_key) ||
-      !marshal_integer(&child, dsa->p) ||
-      !marshal_integer(&child, dsa->q) ||
-      !marshal_integer(&child, dsa->g) ||
-      !CBB_flush(cbb)) {
+      !marshal_integer(&child, impl->pub_key.get()) ||
+      !marshal_integer(&child, impl->p.get()) ||
+      !marshal_integer(&child, impl->q.get()) ||
+      !marshal_integer(&child, impl->g.get()) || !CBB_flush(cbb)) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_ENCODE_ERROR);
     return 0;
   }
@@ -175,9 +180,9 @@ int DSA_marshal_public_key(CBB *cbb, const DSA *dsa) {
 }
 
 DSA *DSA_parse_parameters(CBS *cbs) {
-  DSA *ret = DSA_new();
-  if (ret == NULL) {
-    return NULL;
+  UniquePtr<DSAImpl> ret(FromOpaque(DSA_new()));
+  if (ret == nullptr) {
+    return nullptr;
   }
   CBS child;
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
@@ -186,25 +191,22 @@ DSA *DSA_parse_parameters(CBS *cbs) {
       !parse_integer(&child, &ret->g) ||
       CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
-    goto err;
+    return nullptr;
   }
-  if (!dsa_check_key(ret)) {
-    goto err;
+  if (!dsa_check_key(ret.get())) {
+    return nullptr;
   }
-  return ret;
-
-err:
-  DSA_free(ret);
-  return NULL;
+  return ret.release();
 }
 
 int DSA_marshal_parameters(CBB *cbb, const DSA *dsa) {
+  const auto *impl = FromOpaque(dsa);
+
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_SEQUENCE) ||
-      !marshal_integer(&child, dsa->p) ||
-      !marshal_integer(&child, dsa->q) ||
-      !marshal_integer(&child, dsa->g) ||
-      !CBB_flush(cbb)) {
+      !marshal_integer(&child, impl->p.get()) ||
+      !marshal_integer(&child, impl->q.get()) ||
+      !marshal_integer(&child, impl->g.get()) || !CBB_flush(cbb)) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_ENCODE_ERROR);
     return 0;
   }
@@ -212,9 +214,9 @@ int DSA_marshal_parameters(CBB *cbb, const DSA *dsa) {
 }
 
 DSA *DSA_parse_private_key(CBS *cbs) {
-  DSA *ret = DSA_new();
-  if (ret == NULL) {
-    return NULL;
+  UniquePtr<DSAImpl> ret(FromOpaque(DSA_new()));
+  if (ret == nullptr) {
+    return nullptr;
   }
 
   CBS child;
@@ -222,12 +224,12 @@ DSA *DSA_parse_private_key(CBS *cbs) {
   if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
       !CBS_get_asn1_uint64(&child, &version)) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
-    goto err;
+    return nullptr;
   }
 
   if (version != 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_BAD_VERSION);
-    goto err;
+    return nullptr;
   }
 
   if (!parse_integer(&child, &ret->p) ||
@@ -237,29 +239,26 @@ DSA *DSA_parse_private_key(CBS *cbs) {
       !parse_integer(&child, &ret->priv_key) ||
       CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_DECODE_ERROR);
-    goto err;
+    return nullptr;
   }
-  if (!dsa_check_key(ret)) {
-    goto err;
+  if (!dsa_check_key(ret.get())) {
+    return nullptr;
   }
 
-  return ret;
-
-err:
-  DSA_free(ret);
-  return NULL;
+  return ret.release();
 }
 
 int DSA_marshal_private_key(CBB *cbb, const DSA *dsa) {
+  const auto *impl = FromOpaque(dsa);
+
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_SEQUENCE) ||
       !CBB_add_asn1_uint64(&child, 0 /* version */) ||
-      !marshal_integer(&child, dsa->p) ||
-      !marshal_integer(&child, dsa->q) ||
-      !marshal_integer(&child, dsa->g) ||
-      !marshal_integer(&child, dsa->pub_key) ||
-      !marshal_integer(&child, dsa->priv_key) ||
-      !CBB_flush(cbb)) {
+      !marshal_integer(&child, impl->p.get()) ||
+      !marshal_integer(&child, impl->q.get()) ||
+      !marshal_integer(&child, impl->g.get()) ||
+      !marshal_integer(&child, impl->pub_key.get()) ||
+      !marshal_integer(&child, impl->priv_key.get()) || !CBB_flush(cbb)) {
     OPENSSL_PUT_ERROR(DSA, DSA_R_ENCODE_ERROR);
     return 0;
   }
@@ -267,113 +266,41 @@ int DSA_marshal_private_key(CBB *cbb, const DSA *dsa) {
 }
 
 DSA_SIG *d2i_DSA_SIG(DSA_SIG **out_sig, const uint8_t **inp, long len) {
-  if (len < 0) {
-    return NULL;
-  }
-  CBS cbs;
-  CBS_init(&cbs, *inp, (size_t)len);
-  DSA_SIG *ret = DSA_SIG_parse(&cbs);
-  if (ret == NULL) {
-    return NULL;
-  }
-  if (out_sig != NULL) {
-    DSA_SIG_free(*out_sig);
-    *out_sig = ret;
-  }
-  *inp = CBS_data(&cbs);
-  return ret;
+  return D2IFromCBS(out_sig, inp, len, DSA_SIG_parse);
 }
 
 int i2d_DSA_SIG(const DSA_SIG *in, uint8_t **outp) {
-  CBB cbb;
-  if (!CBB_init(&cbb, 0) ||
-      !DSA_SIG_marshal(&cbb, in)) {
-    CBB_cleanup(&cbb);
-    return -1;
-  }
-  return CBB_finish_i2d(&cbb, outp);
+  return I2DFromCBB(
+      /*initial_capacity=*/256, outp,
+      [&](CBB *cbb) -> bool { return DSA_SIG_marshal(cbb, in); });
 }
 
 DSA *d2i_DSAPublicKey(DSA **out, const uint8_t **inp, long len) {
-  if (len < 0) {
-    return NULL;
-  }
-  CBS cbs;
-  CBS_init(&cbs, *inp, (size_t)len);
-  DSA *ret = DSA_parse_public_key(&cbs);
-  if (ret == NULL) {
-    return NULL;
-  }
-  if (out != NULL) {
-    DSA_free(*out);
-    *out = ret;
-  }
-  *inp = CBS_data(&cbs);
-  return ret;
+  return D2IFromCBS(out, inp, len, DSA_parse_public_key);
 }
 
 int i2d_DSAPublicKey(const DSA *in, uint8_t **outp) {
-  CBB cbb;
-  if (!CBB_init(&cbb, 0) ||
-      !DSA_marshal_public_key(&cbb, in)) {
-    CBB_cleanup(&cbb);
-    return -1;
-  }
-  return CBB_finish_i2d(&cbb, outp);
+  return I2DFromCBB(
+      /*initial_capacity=*/256, outp,
+      [&](CBB *cbb) -> bool { return DSA_marshal_public_key(cbb, in); });
 }
 
 DSA *d2i_DSAPrivateKey(DSA **out, const uint8_t **inp, long len) {
-  if (len < 0) {
-    return NULL;
-  }
-  CBS cbs;
-  CBS_init(&cbs, *inp, (size_t)len);
-  DSA *ret = DSA_parse_private_key(&cbs);
-  if (ret == NULL) {
-    return NULL;
-  }
-  if (out != NULL) {
-    DSA_free(*out);
-    *out = ret;
-  }
-  *inp = CBS_data(&cbs);
-  return ret;
+  return D2IFromCBS(out, inp, len, DSA_parse_private_key);
 }
 
 int i2d_DSAPrivateKey(const DSA *in, uint8_t **outp) {
-  CBB cbb;
-  if (!CBB_init(&cbb, 0) ||
-      !DSA_marshal_private_key(&cbb, in)) {
-    CBB_cleanup(&cbb);
-    return -1;
-  }
-  return CBB_finish_i2d(&cbb, outp);
+  return I2DFromCBB(
+      /*initial_capacity=*/256, outp,
+      [&](CBB *cbb) -> bool { return DSA_marshal_private_key(cbb, in); });
 }
 
 DSA *d2i_DSAparams(DSA **out, const uint8_t **inp, long len) {
-  if (len < 0) {
-    return NULL;
-  }
-  CBS cbs;
-  CBS_init(&cbs, *inp, (size_t)len);
-  DSA *ret = DSA_parse_parameters(&cbs);
-  if (ret == NULL) {
-    return NULL;
-  }
-  if (out != NULL) {
-    DSA_free(*out);
-    *out = ret;
-  }
-  *inp = CBS_data(&cbs);
-  return ret;
+  return D2IFromCBS(out, inp, len, DSA_parse_parameters);
 }
 
 int i2d_DSAparams(const DSA *in, uint8_t **outp) {
-  CBB cbb;
-  if (!CBB_init(&cbb, 0) ||
-      !DSA_marshal_parameters(&cbb, in)) {
-    CBB_cleanup(&cbb);
-    return -1;
-  }
-  return CBB_finish_i2d(&cbb, outp);
+  return I2DFromCBB(
+      /*initial_capacity=*/256, outp,
+      [&](CBB *cbb) -> bool { return DSA_marshal_parameters(cbb, in); });
 }

data/third_party/boringssl-with-bazel/crypto/dsa/internal.h

@@ -17,38 +17,40 @@
 
 #include <openssl/dsa.h>
 
-#include <openssl/thread.h>
-
 #include "../internal.h"
+#include "../mem_internal.h"
+
+
+DECLARE_OPAQUE_STRUCT(dsa_st, DSAImpl)
 
-#if defined(__cplusplus)
-extern "C" {
-#endif
+BSSL_NAMESPACE_BEGIN
 
+class DSAImpl : public dsa_st, public RefCounted<DSAImpl> {
+ public:
+  DSAImpl();
 
-struct dsa_st {
-  BIGNUM *p;
-  BIGNUM *q;
-  BIGNUM *g;
+  UniquePtr<BIGNUM> p;
+  UniquePtr<BIGNUM> q;
+  UniquePtr<BIGNUM> g;
 
-  BIGNUM *pub_key;
-  BIGNUM *priv_key;
+  UniquePtr<BIGNUM> pub_key;
+  UniquePtr<BIGNUM> priv_key;
 
   // Normally used to cache montgomery values
-  CRYPTO_MUTEX method_mont_lock;
-  BN_MONT_CTX *method_mont_p;
-  BN_MONT_CTX *method_mont_q;
-  CRYPTO_refcount_t references;
+  mutable Mutex method_mont_lock;
+  mutable UniquePtr<BN_MONT_CTX> method_mont_p;
+  mutable UniquePtr<BN_MONT_CTX> method_mont_q;
   CRYPTO_EX_DATA ex_data;
+
+ private:
+  friend RefCounted;
+  ~DSAImpl();
 };
 
-// dsa_check_key performs cheap self-checks on |dsa|, and ensures it is within
+// dsa_check_key performs cheap self-checks on `dsa`, and ensures it is within
 // DoS bounds. It returns one on success and zero on error.
-int dsa_check_key(const DSA *dsa);
-
+int dsa_check_key(const DSAImpl *dsa);
 
-#if defined(__cplusplus)
-}  // extern C
-#endif
+BSSL_NAMESPACE_END
 
 #endif  // OPENSSL_HEADER_CRYPTO_DSA_INTERNAL_H