grpc 1.69.0 → 1.70.1

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

@@ -117,8 +117,8 @@
 #include <openssl/mem.h>
 #include <openssl/thread.h>
 
-#include "internal.h"
 #include "../../internal.h"
+#include "internal.h"
 
 
 void bn_mont_ctx_init(BN_MONT_CTX *mont) {
@@ -133,7 +133,8 @@ void bn_mont_ctx_cleanup(BN_MONT_CTX *mont) {
 }
 
 BN_MONT_CTX *BN_MONT_CTX_new(void) {
-  BN_MONT_CTX *ret = OPENSSL_malloc(sizeof(BN_MONT_CTX));
+  BN_MONT_CTX *ret =
+      reinterpret_cast<BN_MONT_CTX *>(OPENSSL_malloc(sizeof(BN_MONT_CTX)));
   if (ret == NULL) {
     return NULL;
   }
@@ -156,8 +157,7 @@ BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, const BN_MONT_CTX *from) {
     return to;
   }
 
-  if (!BN_copy(&to->RR, &from->RR) ||
-      !BN_copy(&to->N, &from->N)) {
+  if (!BN_copy(&to->RR, &from->RR) || !BN_copy(&to->N, &from->N)) {
     return NULL;
   }
   to->n0[0] = from->n0[0];
@@ -243,8 +243,7 @@ int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx) {
 
 BN_MONT_CTX *BN_MONT_CTX_new_for_modulus(const BIGNUM *mod, BN_CTX *ctx) {
   BN_MONT_CTX *mont = BN_MONT_CTX_new();
-  if (mont == NULL ||
-      !BN_MONT_CTX_set(mont, mod, ctx)) {
+  if (mont == NULL || !BN_MONT_CTX_set(mont, mod, ctx)) {
     BN_MONT_CTX_free(mont);
     return NULL;
   }
@@ -253,8 +252,7 @@ BN_MONT_CTX *BN_MONT_CTX_new_for_modulus(const BIGNUM *mod, BN_CTX *ctx) {
 
 BN_MONT_CTX *BN_MONT_CTX_new_consttime(const BIGNUM *mod, BN_CTX *ctx) {
   BN_MONT_CTX *mont = BN_MONT_CTX_new();
-  if (mont == NULL ||
-      !bn_mont_ctx_set_N_and_n0(mont, mod) ||
+  if (mont == NULL || !bn_mont_ctx_set_N_and_n0(mont, mod) ||
       !bn_mont_ctx_set_RR_consttime(mont, ctx)) {
     BN_MONT_CTX_free(mont);
     return NULL;
@@ -331,8 +329,7 @@ static int BN_from_montgomery_word(BIGNUM *ret, BIGNUM *r,
   }
 
   int max = 2 * n->width;  // carry is stored separately
-  if (!bn_resize_words(r, max) ||
-      !bn_wexpand(ret, n->width)) {
+  if (!bn_resize_words(r, max) || !bn_wexpand(ret, n->width)) {
     return 0;
   }
 
@@ -348,8 +345,7 @@ int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, const BN_MONT_CTX *mont,
 
   BN_CTX_start(ctx);
   t = BN_CTX_get(ctx);
-  if (t == NULL ||
-      !BN_copy(t, a)) {
+  if (t == NULL || !BN_copy(t, a)) {
     goto err;
   }
 
@@ -425,9 +421,7 @@ int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
 #if defined(OPENSSL_BN_ASM_MONT)
   // |bn_mul_mont| requires at least 128 bits of limbs, at least for x86.
   int num = mont->N.width;
-  if (num >= (128 / BN_BITS2) &&
-      a->width == num &&
-      b->width == num) {
+  if (num >= (128 / BN_BITS2) && a->width == num && b->width == num) {
     if (!bn_wexpand(r, num)) {
       return 0;
     }
@@ -450,8 +444,7 @@ int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
 }
 
 int bn_less_than_montgomery_R(const BIGNUM *bn, const BN_MONT_CTX *mont) {
-  return !BN_is_negative(bn) &&
-         bn_fits_in_words(bn, mont->N.width);
+  return !BN_is_negative(bn) && bn_fits_in_words(bn, mont->N.width);
 }
 
 void bn_to_montgomery_small(BN_ULONG *r, const BN_ULONG *a, size_t num,

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

@@ -63,8 +63,8 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
 #include "../../internal.h"
+#include "internal.h"
 
 
 #define BN_MUL_RECURSIVE_SIZE_NORMAL 16
@@ -181,9 +181,7 @@ int bn_abs_sub_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
   int r_len = a->width < b->width ? b->width : a->width;
   BN_CTX_start(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
-  int ok = tmp != NULL &&
-           bn_wexpand(r, r_len) &&
-           bn_wexpand(tmp, r_len);
+  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;
@@ -208,8 +206,8 @@ static void bn_mul_recursive(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b,
   // |n2| is a power of two.
   assert(n2 != 0 && (n2 & (n2 - 1)) == 0);
   // Check |dna| and |dnb| are in range.
-  assert(-BN_MUL_RECURSIVE_SIZE_NORMAL/2 <= dna && dna <= 0);
-  assert(-BN_MUL_RECURSIVE_SIZE_NORMAL/2 <= dnb && dnb <= 0);
+  assert(-BN_MUL_RECURSIVE_SIZE_NORMAL / 2 <= dna && dna <= 0);
+  assert(-BN_MUL_RECURSIVE_SIZE_NORMAL / 2 <= dnb && dnb <= 0);
 
   // Only call bn_mul_comba 8 if n2 == 8 and the
   // two arrays are complete [steve]
@@ -421,7 +419,7 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
     return 1;
   }
 
-  int ret = 0;
+  int ret = 0, i, top;
   BIGNUM *rr;
   BN_CTX_start(ctx);
   if (r == a || r == b) {
@@ -434,7 +432,7 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
   }
   rr->neg = a->neg ^ b->neg;
 
-  int i = al - bl;
+  i = al - bl;
   if (i == 0) {
     if (al == 8) {
       if (!bn_wexpand(rr, 16)) {
@@ -446,7 +444,7 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
     }
   }
 
-  int top = al + bl;
+  top = al + bl;
   static const int kMulNormalSize = 16;
   if (al >= kMulNormalSize && bl >= kMulNormalSize) {
     if (-1 <= i && i <= 1) {
@@ -471,8 +469,7 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
         // algorithms. Is this optimization necessary? See notes in
         // https://boringssl-review.googlesource.com/q/I0bd604e2cd6a75c266f64476c23a730ca1721ea6
         assert(al >= j && bl >= j);
-        if (!bn_wexpand(t, j * 8) ||
-            !bn_wexpand(rr, j * 4)) {
+        if (!bn_wexpand(t, j * 8) || !bn_wexpand(rr, j * 4)) {
           goto err;
         }
         bn_mul_part_recursive(rr->d, a->d, b->d, j, al - j, bl - j, t->d);
@@ -480,8 +477,7 @@ static int bn_mul_impl(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
         // al <= j && bl <= j. Additionally, we know j <= al or j <= bl, so one
         // 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)) {
+        if (!bn_wexpand(t, j * 4) || !bn_wexpand(rr, j * 2)) {
           goto err;
         }
         bn_mul_recursive(rr->d, a->d, b->d, j, al - j, bl - j, t->d);
@@ -669,7 +665,7 @@ int bn_sqr_consttime(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx) {
     return 1;
   }
 
-  int ret = 0;
+  int ret = 0, max;
   BN_CTX_start(ctx);
   BIGNUM *rr = (a != r) ? r : BN_CTX_get(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
@@ -677,7 +673,7 @@ int bn_sqr_consttime(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx) {
     goto err;
   }
 
-  int max = 2 * al;  // Non-zero (from above)
+  max = 2 * al;  // Non-zero (from above)
   if (!bn_wexpand(rr, max)) {
     goto err;
   }

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

@@ -111,8 +111,8 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
 #include "../../internal.h"
+#include "internal.h"
 
 
 // kPrimes contains the first 1024 primes.
@@ -359,13 +359,14 @@ static int probable_prime_dh(BIGNUM *rnd, int bits, const BIGNUM *add,
 static int probable_prime_dh_safe(BIGNUM *rnd, int bits, const BIGNUM *add,
                                   const BIGNUM *rem, BN_CTX *ctx);
 
-BN_GENCB *BN_GENCB_new(void) { return OPENSSL_zalloc(sizeof(BN_GENCB)); }
+BN_GENCB *BN_GENCB_new(void) {
+  return reinterpret_cast<BN_GENCB *>(OPENSSL_zalloc(sizeof(BN_GENCB)));
+}
 
 void BN_GENCB_free(BN_GENCB *callback) { OPENSSL_free(callback); }
 
 void BN_GENCB_set(BN_GENCB *callback,
-                  int (*f)(int event, int n, struct bn_gencb_st *),
-                  void *arg) {
+                  int (*f)(int event, int n, struct bn_gencb_st *), void *arg) {
   callback->callback = f;
   callback->arg = arg;
 }
@@ -513,9 +514,9 @@ int bn_miller_rabin_init(BN_MILLER_RABIN *miller_rabin, const BN_MONT_CTX *mont,
   miller_rabin->m = BN_CTX_get(ctx);
   miller_rabin->one_mont = BN_CTX_get(ctx);
   miller_rabin->w1_mont = BN_CTX_get(ctx);
-  if (miller_rabin->w1 == NULL ||
-      miller_rabin->m == NULL ||
-      miller_rabin->one_mont == NULL ||
+  if (miller_rabin->w1 == NULL ||        //
+      miller_rabin->m == NULL ||         //
+      miller_rabin->one_mont == NULL ||  //
       miller_rabin->w1_mont == NULL) {
     return 0;
   }
@@ -553,6 +554,7 @@ int bn_miller_rabin_iteration(const BN_MILLER_RABIN *miller_rabin,
   // timing leaks.
   const BIGNUM *w = &mont->N;
   BIGNUM *z = BN_CTX_get(ctx);
+  crypto_word_t is_possibly_prime;
   if (z == NULL ||
       !BN_mod_exp_mont_consttime(z, b, miller_rabin->m, w, ctx, mont) ||
       !BN_to_montgomery(z, z, mont, ctx)) {
@@ -563,7 +565,7 @@ int bn_miller_rabin_iteration(const BN_MILLER_RABIN *miller_rabin,
   // witness for |w|. This is equivalent to going to step 4.7 in the original
   // algorithm. To avoid timing leaks, we run the algorithm to the end for prime
   // inputs.
-  crypto_word_t is_possibly_prime = 0;
+  is_possibly_prime = 0;
 
   // Step 4.4. If z = 1 or z = w-1, b is not a composite witness and w is still
   // possibly prime.
@@ -705,6 +707,7 @@ int BN_primality_test(int *out_is_probably_prime, const BIGNUM *w, int checks,
   BIGNUM *b = BN_CTX_get(ctx);
   BN_MONT_CTX *mont = BN_MONT_CTX_new_consttime(w, ctx);
   BN_MILLER_RABIN miller_rabin;
+  crypto_word_t uniform_iterations = 0;
   if (b == NULL || mont == NULL ||
       // Steps 1-3.
       !bn_miller_rabin_init(&miller_rabin, mont, ctx)) {
@@ -739,7 +742,6 @@ int BN_primality_test(int *out_is_probably_prime, const BIGNUM *w, int checks,
   // Note this blinding does not impact most calls when picking primes because
   // composites are rejected early. Only the two secret primes see extra work.
 
-  crypto_word_t uniform_iterations = 0;
   // Using |constant_time_lt_w| seems to prevent the compiler from optimizing
   // this into two jumps.
   for (int i = 1; constant_time_declassify_w(
@@ -749,7 +751,7 @@ int BN_primality_test(int *out_is_probably_prime, const BIGNUM *w, int checks,
     // Step 4.1-4.2
     int is_uniform;
     if (!bn_rand_secret_range(b, &is_uniform, 2, miller_rabin.w1)) {
-        goto err;
+      goto err;
     }
     uniform_iterations += is_uniform;
 
@@ -818,33 +820,28 @@ int BN_enhanced_miller_rabin_primality_test(
   BN_CTX_start(ctx);
 
   BIGNUM *w1 = BN_CTX_get(ctx);
-  if (w1 == NULL ||
-      !BN_copy(w1, w) ||
-      !BN_sub_word(w1, 1)) {
+  BIGNUM *b, *g, *z, *x, *x1, *m;
+  int a;
+  if (w1 == NULL || !BN_copy(w1, w) || !BN_sub_word(w1, 1)) {
     goto err;
   }
 
   // Write w1 as m*2^a (Steps 1 and 2).
-  int a = 0;
+  a = 0;
   while (!BN_is_bit_set(w1, a)) {
     a++;
   }
-  BIGNUM *m = BN_CTX_get(ctx);
-  if (m == NULL ||
-      !BN_rshift(m, w1, a)) {
+  m = BN_CTX_get(ctx);
+  if (m == NULL || !BN_rshift(m, w1, a)) {
     goto err;
   }
 
-  BIGNUM *b = BN_CTX_get(ctx);
-  BIGNUM *g = BN_CTX_get(ctx);
-  BIGNUM *z = BN_CTX_get(ctx);
-  BIGNUM *x = BN_CTX_get(ctx);
-  BIGNUM *x1 = BN_CTX_get(ctx);
-  if (b == NULL ||
-      g == NULL ||
-      z == NULL ||
-      x == NULL ||
-      x1 == NULL) {
+  b = BN_CTX_get(ctx);
+  g = BN_CTX_get(ctx);
+  z = BN_CTX_get(ctx);
+  x = BN_CTX_get(ctx);
+  x1 = BN_CTX_get(ctx);
+  if (b == NULL || g == NULL || z == NULL || x == NULL || x1 == NULL) {
     goto err;
   }
 
@@ -905,11 +902,9 @@ int BN_enhanced_miller_rabin_primality_test(
       goto err;
     }
 
- composite:
+  composite:
     // Step 4.12-4.14
-    if (!BN_copy(x1, x) ||
-        !BN_sub_word(x1, 1) ||
-        !BN_gcd(g, x1, w, ctx)) {
+    if (!BN_copy(x1, x) || !BN_sub_word(x1, 1) || !BN_gcd(g, x1, w, ctx)) {
       goto err;
     }
     if (BN_cmp_word(g, 1) > 0) {
@@ -921,7 +916,7 @@ int BN_enhanced_miller_rabin_primality_test(
     ret = 1;
     goto err;
 
- loop:
+  loop:
     // Step 4.15
     if (!BN_GENCB_call(cb, BN_GENCB_PRIME_TEST, i - 1)) {
       goto err;
@@ -953,6 +948,7 @@ static int probable_prime_dh(BIGNUM *rnd, int bits, const BIGNUM *add,
   BIGNUM *t1;
 
   BN_CTX_start(ctx);
+  size_t num_primes;
   if ((t1 = BN_CTX_get(ctx)) == NULL) {
     goto err;
   }
@@ -980,7 +976,7 @@ static int probable_prime_dh(BIGNUM *rnd, int bits, const BIGNUM *add,
   }
   // we now have a random number 'rand' to test.
 
-  const size_t num_primes = num_trial_division_primes(rnd);
+  num_primes = num_trial_division_primes(rnd);
 loop:
   for (size_t i = 1; i < num_primes; i++) {
     // check that rnd is a prime
@@ -1009,6 +1005,7 @@ static int probable_prime_dh_safe(BIGNUM *p, int bits, const BIGNUM *padd,
   t1 = BN_CTX_get(ctx);
   q = BN_CTX_get(ctx);
   qadd = BN_CTX_get(ctx);
+  size_t num_primes;
   if (qadd == NULL) {
     goto err;
   }
@@ -1051,7 +1048,7 @@ static int probable_prime_dh_safe(BIGNUM *p, int bits, const BIGNUM *padd,
     goto err;
   }
 
-  const size_t num_primes = num_trial_division_primes(p);
+  num_primes = num_trial_division_primes(p);
 loop:
   for (size_t i = 1; i < num_primes; i++) {
     // check that p and q are prime

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

@@ -174,14 +174,13 @@ int bn_rshift_secret_shift(BIGNUM *r, const BIGNUM *a, unsigned n,
   int ret = 0;
   BN_CTX_start(ctx);
   BIGNUM *tmp = BN_CTX_get(ctx);
-  if (tmp == NULL ||
-      !BN_copy(r, a) ||
-      !bn_wexpand(tmp, r->width)) {
+  unsigned max_bits;
+  if (tmp == NULL || !BN_copy(r, a) || !bn_wexpand(tmp, r->width)) {
     goto err;
   }
 
   // Shift conditionally by powers of two.
-  unsigned max_bits = BN_BITS2 * r->width;
+  max_bits = BN_BITS2 * r->width;
   for (unsigned i = 0; (max_bits >> i) != 0; i++) {
     BN_ULONG mask = (n >> i) & 1;
     mask = 0 - mask;

data/third_party/boringssl-with-bazel/src/crypto/fipsmodule/cipher/{aead.c.inc → aead.cc.inc}

@@ -1,4 +1,4 @@
-/* Copyright (c) 2014, Google Inc.
+/* Copyright 2014 The BoringSSL Authors
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -21,8 +21,8 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
 #include "../../internal.h"
+#include "internal.h"
 
 
 size_t EVP_AEAD_key_length(const EVP_AEAD *aead) { return aead->key_len; }
@@ -39,7 +39,11 @@ void EVP_AEAD_CTX_zero(EVP_AEAD_CTX *ctx) {
 
 EVP_AEAD_CTX *EVP_AEAD_CTX_new(const EVP_AEAD *aead, const uint8_t *key,
                                size_t key_len, size_t tag_len) {
-  EVP_AEAD_CTX *ctx = OPENSSL_malloc(sizeof(EVP_AEAD_CTX));
+  EVP_AEAD_CTX *ctx =
+      reinterpret_cast<EVP_AEAD_CTX *>(OPENSSL_malloc(sizeof(EVP_AEAD_CTX)));
+  if (!ctx) {
+    return NULL;
+  }
   EVP_AEAD_CTX_zero(ctx);
 
   if (EVP_AEAD_CTX_init(ctx, aead, key, key_len, tag_len, NULL)) {
@@ -150,11 +154,13 @@ error:
   return 0;
 }
 
-int EVP_AEAD_CTX_seal_scatter(
-    const EVP_AEAD_CTX *ctx, uint8_t *out, uint8_t *out_tag, size_t
-    *out_tag_len, size_t max_out_tag_len, const uint8_t *nonce, size_t
-    nonce_len, const uint8_t *in, size_t in_len, const uint8_t *extra_in,
-    size_t extra_in_len, const uint8_t *ad, size_t ad_len) {
+int EVP_AEAD_CTX_seal_scatter(const EVP_AEAD_CTX *ctx, uint8_t *out,
+                              uint8_t *out_tag, size_t *out_tag_len,
+                              size_t max_out_tag_len, const uint8_t *nonce,
+                              size_t nonce_len, const uint8_t *in,
+                              size_t in_len, const uint8_t *extra_in,
+                              size_t extra_in_len, const uint8_t *ad,
+                              size_t ad_len) {
   // |in| and |out| may alias exactly, |out_tag| may not alias.
   if (!check_alias(in, in_len, out, in_len) ||
       buffers_alias(out, in_len, out_tag, max_out_tag_len) ||
@@ -187,6 +193,7 @@ int EVP_AEAD_CTX_open(const EVP_AEAD_CTX *ctx, uint8_t *out, size_t *out_len,
                       size_t max_out_len, const uint8_t *nonce,
                       size_t nonce_len, const uint8_t *in, size_t in_len,
                       const uint8_t *ad, size_t ad_len) {
+  size_t plaintext_len;
   if (!check_alias(in, in_len, out, max_out_len)) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_OUTPUT_ALIASES_INPUT);
     goto error;
@@ -194,7 +201,7 @@ int EVP_AEAD_CTX_open(const EVP_AEAD_CTX *ctx, uint8_t *out, size_t *out_len,
 
   if (ctx->aead->open) {
     if (!ctx->aead->open(ctx, out, out_len, max_out_len, nonce, nonce_len, in,
-                        in_len, ad, ad_len)) {
+                         in_len, ad, ad_len)) {
       goto error;
     }
     return 1;
@@ -209,7 +216,7 @@ int EVP_AEAD_CTX_open(const EVP_AEAD_CTX *ctx, uint8_t *out, size_t *out_len,
     goto error;
   }
 
-  size_t plaintext_len = in_len - ctx->tag_len;
+  plaintext_len = in_len - ctx->tag_len;
   if (max_out_len < plaintext_len) {
     OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BUFFER_TOO_SMALL);
     goto error;
@@ -262,6 +269,7 @@ const EVP_AEAD *EVP_AEAD_CTX_aead(const EVP_AEAD_CTX *ctx) { return ctx->aead; }
 int EVP_AEAD_CTX_get_iv(const EVP_AEAD_CTX *ctx, const uint8_t **out_iv,
                         size_t *out_len) {
   if (ctx->aead->get_iv == NULL) {
+    OPENSSL_PUT_ERROR(CIPHER, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
     return 0;
   }
 

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

@@ -64,9 +64,9 @@
 #include <openssl/mem.h>
 #include <openssl/nid.h>
 
-#include "internal.h"
-#include "../service_indicator/internal.h"
 #include "../../internal.h"
+#include "../service_indicator/internal.h"
+#include "internal.h"
 
 
 void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx) {
@@ -74,7 +74,8 @@ void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx) {
 }
 
 EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void) {
-  EVP_CIPHER_CTX *ctx = OPENSSL_malloc(sizeof(EVP_CIPHER_CTX));
+  EVP_CIPHER_CTX *ctx = reinterpret_cast<EVP_CIPHER_CTX *>(
+      OPENSSL_malloc(sizeof(EVP_CIPHER_CTX)));
   if (ctx) {
     EVP_CIPHER_CTX_init(ctx);
   }
@@ -568,9 +569,7 @@ const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx) {
   return ctx->cipher;
 }
 
-int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx) {
-  return ctx->cipher->nid;
-}
+int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx) { return ctx->cipher->nid; }
 
 int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx) {
   return ctx->encrypt;
@@ -710,8 +709,6 @@ int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, uint8_t *out, int *out_len) {
   return EVP_DecryptFinal_ex(ctx, out, out_len);
 }
 
-int EVP_add_cipher_alias(const char *a, const char *b) {
-  return 1;
-}
+int EVP_add_cipher_alias(const char *a, const char *b) { return 1; }
 
 void EVP_CIPHER_CTX_set_flags(const EVP_CIPHER_CTX *ctx, uint32_t flags) {}