grpc 1.9.1 → 1.10.0.pre1

data/third_party/boringssl/crypto/pool/internal.h

@@ -39,7 +39,7 @@ struct crypto_buffer_pool_st {
 
 
 #if defined(__cplusplus)
-} /* extern C */
+}  // extern C
 #endif
 
-#endif /* OPENSSL_HEADER_POOL_INTERNAL_H */
+#endif  // OPENSSL_HEADER_POOL_INTERNAL_H

data/third_party/boringssl/crypto/pool/pool.c

@@ -125,8 +125,8 @@ CRYPTO_BUFFER *CRYPTO_BUFFER_new(const uint8_t *data, size_t len,
   CRYPTO_MUTEX_unlock_write(&pool->lock);
 
   if (!inserted) {
-    /* We raced to insert |buf| into the pool and lost, or else there was an
-     * error inserting. */
+    // We raced to insert |buf| into the pool and lost, or else there was an
+    // error inserting.
     OPENSSL_free(buf->data);
     OPENSSL_free(buf);
     return duplicate;
@@ -147,9 +147,9 @@ void CRYPTO_BUFFER_free(CRYPTO_BUFFER *buf) {
   CRYPTO_BUFFER_POOL *const pool = buf->pool;
   if (pool == NULL) {
     if (CRYPTO_refcount_dec_and_test_zero(&buf->references)) {
-      /* If a reference count of zero is observed, there cannot be a reference
-       * from any pool to this buffer and thus we are able to free this
-       * buffer. */
+      // If a reference count of zero is observed, there cannot be a reference
+      // from any pool to this buffer and thus we are able to free this
+      // buffer.
       OPENSSL_free(buf->data);
       OPENSSL_free(buf);
     }
@@ -163,10 +163,10 @@ void CRYPTO_BUFFER_free(CRYPTO_BUFFER *buf) {
     return;
   }
 
-  /* We have an exclusive lock on the pool, therefore no concurrent lookups can
-   * find this buffer and increment the reference count. Thus, if the count is
-   * zero there are and can never be any more references and thus we can free
-   * this buffer. */
+  // We have an exclusive lock on the pool, therefore no concurrent lookups can
+  // find this buffer and increment the reference count. Thus, if the count is
+  // zero there are and can never be any more references and thus we can free
+  // this buffer.
   void *found = lh_CRYPTO_BUFFER_delete(pool->bufs, buf);
   assert(found != NULL);
   assert(found == buf);
@@ -177,12 +177,12 @@ void CRYPTO_BUFFER_free(CRYPTO_BUFFER *buf) {
 }
 
 int CRYPTO_BUFFER_up_ref(CRYPTO_BUFFER *buf) {
-  /* This is safe in the case that |buf->pool| is NULL because it's just
-   * standard reference counting in that case.
-   *
-   * This is also safe if |buf->pool| is non-NULL because, if it were racing
-   * with |CRYPTO_BUFFER_free| then the two callers must have independent
-   * references already and so the reference count will never hit zero. */
+  // This is safe in the case that |buf->pool| is NULL because it's just
+  // standard reference counting in that case.
+  //
+  // This is also safe if |buf->pool| is non-NULL because, if it were racing
+  // with |CRYPTO_BUFFER_free| then the two callers must have independent
+  // references already and so the reference count will never hit zero.
   CRYPTO_refcount_inc(&buf->references);
   return 1;
 }

data/third_party/boringssl/crypto/{rand → rand_extra}/deterministic.c

@@ -20,15 +20,15 @@
 
 #include <openssl/chacha.h>
 
-#include "internal.h"
 #include "../internal.h"
+#include "../fipsmodule/rand/internal.h"
 
 
-/* g_num_calls is the number of calls to |CRYPTO_sysrand| that have occured.
- *
- * TODO(davidben): This is intentionally not thread-safe. If the fuzzer mode is
- * ever used in a multi-threaded program, replace this with a thread-local. (A
- * mutex would not be deterministic.) */
+// g_num_calls is the number of calls to |CRYPTO_sysrand| that have occurred.
+//
+// This is intentionally not thread-safe. If the fuzzer mode is ever used in a
+// multi-threaded program, replace this with a thread-local. (A mutex would not
+// be deterministic.)
 static uint64_t g_num_calls = 0;
 
 void RAND_reset_for_fuzzing(void) { g_num_calls = 0; }
@@ -45,4 +45,4 @@ void CRYPTO_sysrand(uint8_t *out, size_t requested) {
   g_num_calls++;
 }
 
-#endif  /* BORINGSSL_UNSAFE_DETERMINISTIC_MODE */
+#endif  // BORINGSSL_UNSAFE_DETERMINISTIC_MODE

data/third_party/boringssl/crypto/rand_extra/forkunsafe.c

@@ -0,0 +1,46 @@
+/* Copyright (c) 2017, 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/rand.h>
+
+#include <stdlib.h>
+
+#include "../fipsmodule/rand/internal.h"
+
+
+// g_buffering_enabled is true if fork-unsafe buffering has been enabled.
+static int g_buffering_enabled = 0;
+
+// g_lock protects |g_buffering_enabled|.
+static struct CRYPTO_STATIC_MUTEX g_lock = CRYPTO_STATIC_MUTEX_INIT;
+
+#if !defined(OPENSSL_WINDOWS)
+void RAND_enable_fork_unsafe_buffering(int fd) {
+  // We no longer support setting the file-descriptor with this function.
+  if (fd != -1) {
+    abort();
+  }
+
+  CRYPTO_STATIC_MUTEX_lock_write(&g_lock);
+  g_buffering_enabled = 1;
+  CRYPTO_STATIC_MUTEX_unlock_write(&g_lock);
+}
+#endif
+
+int rand_fork_unsafe_buffering_enabled(void) {
+  CRYPTO_STATIC_MUTEX_lock_read(&g_lock);
+  const int ret = g_buffering_enabled;
+  CRYPTO_STATIC_MUTEX_unlock_read(&g_lock);
+  return ret;
+}

data/third_party/boringssl/crypto/{rand → rand_extra}/fuchsia.c

@@ -19,20 +19,20 @@
 #include <limits.h>
 #include <stdlib.h>
 
-#include <magenta/syscalls.h>
+#include <zircon/syscalls.h>
 
-#include "internal.h"
+#include "../fipsmodule/rand/internal.h"
 
 void CRYPTO_sysrand(uint8_t *out, size_t requested) {
   while (requested > 0) {
-    size_t output_bytes_this_pass = MX_CPRNG_DRAW_MAX_LEN;
+    size_t output_bytes_this_pass = ZX_CPRNG_DRAW_MAX_LEN;
     if (requested < output_bytes_this_pass) {
       output_bytes_this_pass = requested;
     }
     size_t bytes_drawn;
-    mx_status_t status =
-        mx_cprng_draw(out, output_bytes_this_pass, &bytes_drawn);
-    if (status != NO_ERROR) {
+    zx_status_t status =
+        zx_cprng_draw(out, output_bytes_this_pass, &bytes_drawn);
+    if (status != ZX_OK) {
       abort();
     }
     requested -= bytes_drawn;
@@ -40,4 +40,4 @@ void CRYPTO_sysrand(uint8_t *out, size_t requested) {
   }
 }
 
-#endif /* OPENSSL_FUCHSIA && !BORINGSSL_UNSAFE_DETERMINISTIC_MODE */
+#endif  // OPENSSL_FUCHSIA && !BORINGSSL_UNSAFE_DETERMINISTIC_MODE

data/third_party/boringssl/crypto/rand_extra/rand_extra.c

@@ -0,0 +1,70 @@
+/* Copyright (c) 2017, 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/rand.h>
+
+#include <limits.h>
+
+
+void RAND_seed(const void *buf, int num) {
+  // OpenSSH calls |RAND_seed| before jailing on the assumption that any needed
+  // file descriptors etc will be opened.
+  uint8_t unused;
+  RAND_bytes(&unused, sizeof(unused));
+}
+
+int RAND_load_file(const char *path, long num) {
+  if (num < 0) {  // read the "whole file"
+    return 1;
+  } else if (num <= INT_MAX) {
+    return (int) num;
+  } else {
+    return INT_MAX;
+  }
+}
+
+const char *RAND_file_name(char *buf, size_t num) { return NULL; }
+
+void RAND_add(const void *buf, int num, double entropy) {}
+
+int RAND_egd(const char *path) {
+  return 255;
+}
+
+int RAND_poll(void) {
+  return 1;
+}
+
+int RAND_status(void) {
+  return 1;
+}
+
+static const struct rand_meth_st kSSLeayMethod = {
+  RAND_seed,
+  RAND_bytes,
+  RAND_cleanup,
+  RAND_add,
+  RAND_pseudo_bytes,
+  RAND_status,
+};
+
+RAND_METHOD *RAND_SSLeay(void) {
+  return (RAND_METHOD*) &kSSLeayMethod;
+}
+
+const RAND_METHOD *RAND_get_rand_method(void) { return RAND_SSLeay(); }
+
+void RAND_set_rand_method(const RAND_METHOD *method) {}
+
+void RAND_cleanup(void) {}

data/third_party/boringssl/crypto/{rand → rand_extra}/windows.c

@@ -23,16 +23,16 @@ OPENSSL_MSVC_PRAGMA(warning(push, 3))
 
 #include <windows.h>
 
-/* #define needed to link in RtlGenRandom(), a.k.a. SystemFunction036.  See the
- * "Community Additions" comment on MSDN here:
- * http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx */
+// #define needed to link in RtlGenRandom(), a.k.a. SystemFunction036.  See the
+// "Community Additions" comment on MSDN here:
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa387694.aspx
 #define SystemFunction036 NTAPI SystemFunction036
 #include <ntsecapi.h>
 #undef SystemFunction036
 
 OPENSSL_MSVC_PRAGMA(warning(pop))
 
-#include "internal.h"
+#include "../fipsmodule/rand/internal.h"
 
 
 void CRYPTO_sysrand(uint8_t *out, size_t requested) {
@@ -50,4 +50,4 @@ void CRYPTO_sysrand(uint8_t *out, size_t requested) {
   return;
 }
 
-#endif  /* OPENSSL_WINDOWS && !BORINGSSL_UNSAFE_DETERMINISTIC_MODE */
+#endif  // OPENSSL_WINDOWS && !BORINGSSL_UNSAFE_DETERMINISTIC_MODE

data/third_party/boringssl/crypto/refcount_c11.c

@@ -25,7 +25,7 @@
 #include <openssl/type_check.h>
 
 
-/* See comment above the typedef of CRYPTO_refcount_t about these tests. */
+// See comment above the typedef of CRYPTO_refcount_t about these tests.
 static_assert(alignof(CRYPTO_refcount_t) == alignof(_Atomic CRYPTO_refcount_t),
               "_Atomic alters the needed alignment of a reference count");
 static_assert(sizeof(CRYPTO_refcount_t) == sizeof(_Atomic CRYPTO_refcount_t),
@@ -64,4 +64,4 @@ int CRYPTO_refcount_dec_and_test_zero(CRYPTO_refcount_t *in_count) {
   }
 }
 
-#endif  /* OPENSSL_C11_ATOMIC */
+#endif  // OPENSSL_C11_ATOMIC

data/third_party/boringssl/crypto/refcount_lock.c

@@ -50,4 +50,4 @@ int CRYPTO_refcount_dec_and_test_zero(CRYPTO_refcount_t *count) {
   return ret;
 }
 
-#endif  /* OPENSSL_C11_ATOMIC */
+#endif  // OPENSSL_C11_ATOMIC

data/third_party/boringssl/crypto/{rsa → rsa_extra}/rsa_asn1.c

@@ -64,7 +64,7 @@
 #include <openssl/err.h>
 #include <openssl/mem.h>
 
-#include "internal.h"
+#include "../fipsmodule/rsa/internal.h"
 #include "../bytestring/internal.h"
 #include "../internal.h"
 
@@ -87,7 +87,7 @@ static int parse_integer(CBS *cbs, BIGNUM **out) {
 
 static int marshal_integer(CBB *cbb, BIGNUM *bn) {
   if (bn == NULL) {
-    /* An RSA object may be missing some components. */
+    // An RSA object may be missing some components.
     OPENSSL_PUT_ERROR(RSA, RSA_R_VALUE_MISSING);
     return 0;
   }
@@ -124,10 +124,10 @@ RSA *RSA_parse_public_key(CBS *cbs) {
 }
 
 RSA *RSA_parse_public_key_buggy(CBS *cbs) {
-  /* Estonian IDs issued between September 2014 to September 2015 are
-   * broken. See https://crbug.com/532048 and https://crbug.com/534766.
-   *
-   * TODO(davidben): Remove this code and callers in March 2016. */
+  // Estonian IDs issued between September 2014 to September 2015 are
+  // broken. See https://crbug.com/532048 and https://crbug.com/534766.
+  //
+  // TODO(davidben): Remove this code and callers in March 2016.
   return parse_public_key(cbs, 1 /* buggy */);
 }
 
@@ -169,40 +169,11 @@ int RSA_public_key_to_bytes(uint8_t **out_bytes, size_t *out_len,
   return 1;
 }
 
-/* kVersionTwoPrime and kVersionMulti are the supported values of the version
- * field of an RSAPrivateKey structure (RFC 3447). */
+// kVersionTwoPrime is the value of the version field for a two-prime
+// RSAPrivateKey structure (RFC 3447).
 static const uint64_t kVersionTwoPrime = 0;
-static const uint64_t kVersionMulti = 1;
-
-/* rsa_parse_additional_prime parses a DER-encoded OtherPrimeInfo from |cbs| and
- * advances |cbs|. It returns a newly-allocated |RSA_additional_prime| on
- * success or NULL on error. The |r| and |mont| fields of the result are set to
- * NULL. */
-static RSA_additional_prime *rsa_parse_additional_prime(CBS *cbs) {
-  RSA_additional_prime *ret = OPENSSL_malloc(sizeof(RSA_additional_prime));
-  if (ret == NULL) {
-    OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
-    return 0;
-  }
-  OPENSSL_memset(ret, 0, sizeof(RSA_additional_prime));
-
-  CBS child;
-  if (!CBS_get_asn1(cbs, &child, CBS_ASN1_SEQUENCE) ||
-      !parse_integer(&child, &ret->prime) ||
-      !parse_integer(&child, &ret->exp) ||
-      !parse_integer(&child, &ret->coeff) ||
-      CBS_len(&child) != 0) {
-    OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_ENCODING);
-    RSA_additional_prime_free(ret);
-    return NULL;
-  }
-
-  return ret;
-}
 
 RSA *RSA_parse_private_key(CBS *cbs) {
-  BN_CTX *ctx = NULL;
-  BIGNUM *product_of_primes_so_far = NULL;
   RSA *ret = RSA_new();
   if (ret == NULL) {
     return NULL;
@@ -216,7 +187,7 @@ RSA *RSA_parse_private_key(CBS *cbs) {
     goto err;
   }
 
-  if (version != kVersionTwoPrime && version != kVersionMulti) {
+  if (version != kVersionTwoPrime) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_VERSION);
     goto err;
   }
@@ -232,50 +203,6 @@ RSA *RSA_parse_private_key(CBS *cbs) {
     goto err;
   }
 
-  if (version == kVersionMulti) {
-    /* Although otherPrimeInfos is written as OPTIONAL in RFC 3447, it later
-     * says "[otherPrimeInfos] shall be omitted if version is 0 and shall
-     * contain at least one instance of OtherPrimeInfo if version is 1." The
-     * OPTIONAL is just so both versions share a single definition. */
-    CBS other_prime_infos;
-    if (!CBS_get_asn1(&child, &other_prime_infos, CBS_ASN1_SEQUENCE) ||
-        CBS_len(&other_prime_infos) == 0) {
-      OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_ENCODING);
-      goto err;
-    }
-    ret->additional_primes = sk_RSA_additional_prime_new_null();
-    if (ret->additional_primes == NULL) {
-      OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
-      goto err;
-    }
-
-    ctx = BN_CTX_new();
-    product_of_primes_so_far = BN_new();
-    if (ctx == NULL ||
-        product_of_primes_so_far == NULL ||
-        !BN_mul(product_of_primes_so_far, ret->p, ret->q, ctx)) {
-      goto err;
-    }
-
-    while (CBS_len(&other_prime_infos) > 0) {
-      RSA_additional_prime *ap = rsa_parse_additional_prime(&other_prime_infos);
-      if (ap == NULL) {
-        goto err;
-      }
-      if (!sk_RSA_additional_prime_push(ret->additional_primes, ap)) {
-        OPENSSL_PUT_ERROR(RSA, ERR_R_MALLOC_FAILURE);
-        RSA_additional_prime_free(ap);
-        goto err;
-      }
-      ap->r = BN_dup(product_of_primes_so_far);
-      if (ap->r == NULL ||
-          !BN_mul(product_of_primes_so_far, product_of_primes_so_far,
-                  ap->prime, ctx)) {
-        goto err;
-      }
-    }
-  }
-
   if (CBS_len(&child) != 0) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_BAD_ENCODING);
     goto err;
@@ -286,13 +213,9 @@ RSA *RSA_parse_private_key(CBS *cbs) {
     goto err;
   }
 
-  BN_CTX_free(ctx);
-  BN_free(product_of_primes_so_far);
   return ret;
 
 err:
-  BN_CTX_free(ctx);
-  BN_free(product_of_primes_so_far);
   RSA_free(ret);
   return NULL;
 }
@@ -310,13 +233,9 @@ RSA *RSA_private_key_from_bytes(const uint8_t *in, size_t in_len) {
 }
 
 int RSA_marshal_private_key(CBB *cbb, const RSA *rsa) {
-  const int is_multiprime =
-      sk_RSA_additional_prime_num(rsa->additional_primes) > 0;
-
   CBB child;
   if (!CBB_add_asn1(cbb, &child, CBS_ASN1_SEQUENCE) ||
-      !CBB_add_asn1_uint64(&child,
-                           is_multiprime ? kVersionMulti : kVersionTwoPrime) ||
+      !CBB_add_asn1_uint64(&child, kVersionTwoPrime) ||
       !marshal_integer(&child, rsa->n) ||
       !marshal_integer(&child, rsa->e) ||
       !marshal_integer(&child, rsa->d) ||
@@ -324,35 +243,8 @@ int RSA_marshal_private_key(CBB *cbb, const RSA *rsa) {
       !marshal_integer(&child, rsa->q) ||
       !marshal_integer(&child, rsa->dmp1) ||
       !marshal_integer(&child, rsa->dmq1) ||
-      !marshal_integer(&child, rsa->iqmp)) {
-    OPENSSL_PUT_ERROR(RSA, RSA_R_ENCODE_ERROR);
-    return 0;
-  }
-
-  CBB other_prime_infos;
-  if (is_multiprime) {
-    if (!CBB_add_asn1(&child, &other_prime_infos, CBS_ASN1_SEQUENCE)) {
-      OPENSSL_PUT_ERROR(RSA, RSA_R_ENCODE_ERROR);
-      return 0;
-    }
-    for (size_t i = 0; i < sk_RSA_additional_prime_num(rsa->additional_primes);
-         i++) {
-      RSA_additional_prime *ap =
-          sk_RSA_additional_prime_value(rsa->additional_primes, i);
-      CBB other_prime_info;
-      if (!CBB_add_asn1(&other_prime_infos, &other_prime_info,
-                        CBS_ASN1_SEQUENCE) ||
-          !marshal_integer(&other_prime_info, ap->prime) ||
-          !marshal_integer(&other_prime_info, ap->exp) ||
-          !marshal_integer(&other_prime_info, ap->coeff) ||
-          !CBB_flush(&other_prime_infos)) {
-        OPENSSL_PUT_ERROR(RSA, RSA_R_ENCODE_ERROR);
-        return 0;
-      }
-    }
-  }
-
-  if (!CBB_flush(cbb)) {
+      !marshal_integer(&child, rsa->iqmp) ||
+      !CBB_flush(cbb)) {
     OPENSSL_PUT_ERROR(RSA, RSA_R_ENCODE_ERROR);
     return 0;
   }