grpc 1.9.1 → 1.10.0.pre1

data/third_party/boringssl/crypto/{digest → fipsmodule/digest}/md32_common.h

@@ -46,70 +46,66 @@
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  * ==================================================================== */
 
-#ifndef OPENSSL_HEADER_MD32_COMMON_H
-#define OPENSSL_HEADER_MD32_COMMON_H
-
 #include <openssl/base.h>
 
 #include <assert.h>
 
-#include "../internal.h"
+#include "../../internal.h"
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
 
-/* This is a generic 32-bit "collector" for message digest algorithms. It
- * collects input character stream into chunks of 32-bit values and invokes the
- * block function that performs the actual hash calculations. To make use of
- * this mechanism, the following macros must be defined before including
- * md32_common.h.
- *
- * One of |DATA_ORDER_IS_BIG_ENDIAN| or |DATA_ORDER_IS_LITTLE_ENDIAN| must be
- * defined to specify the byte order of the input stream.
- *
- * |HASH_CBLOCK| must be defined as the integer block size, in bytes.
- *
- * |HASH_CTX| must be defined as the name of the context structure, which must
- * have at least the following members:
- *
- *     typedef struct <name>_state_st {
- *       uint32_t h[<chaining length> / sizeof(uint32_t)];
- *       uint32_t Nl, Nh;
- *       uint8_t data[HASH_CBLOCK];
- *       unsigned num;
- *       ...
- *     } <NAME>_CTX;
- *
- * <chaining length> is the output length of the hash in bytes, before
- * any truncation (e.g. 64 for SHA-224 and SHA-256, 128 for SHA-384 and
- * SHA-512).
- *
- * |HASH_UPDATE| must be defined as the name of the "Update" function to
- * generate.
- *
- * |HASH_TRANSFORM| must be defined as the  the name of the "Transform"
- * function to generate.
- *
- * |HASH_FINAL| must be defined as the name of "Final" function to generate.
- *
- * |HASH_BLOCK_DATA_ORDER| must be defined as the name of the "Block" function.
- * That function must be implemented manually. It must be capable of operating
- * on *unaligned* input data in its original (data) byte order. It must have
- * this signature:
- *
- *     void HASH_BLOCK_DATA_ORDER(uint32_t *state, const uint8_t *data,
- *                                size_t num);
- *
- * It must update the hash state |state| with |num| blocks of data from |data|,
- * where each block is |HASH_CBLOCK| bytes; i.e. |data| points to a array of
- * |HASH_CBLOCK * num| bytes. |state| points to the |h| member of a |HASH_CTX|,
- * and so will have |<chaining length> / sizeof(uint32_t)| elements.
- *
- * |HASH_MAKE_STRING(c, s)| must be defined as a block statement that converts
- * the hash state |c->h| into the output byte order, storing the result in |s|.
- */
+// This is a generic 32-bit "collector" for message digest algorithms. It
+// collects input character stream into chunks of 32-bit values and invokes the
+// block function that performs the actual hash calculations. To make use of
+// this mechanism, the following macros must be defined before including
+// md32_common.h.
+//
+// One of |DATA_ORDER_IS_BIG_ENDIAN| or |DATA_ORDER_IS_LITTLE_ENDIAN| must be
+// defined to specify the byte order of the input stream.
+//
+// |HASH_CBLOCK| must be defined as the integer block size, in bytes.
+//
+// |HASH_CTX| must be defined as the name of the context structure, which must
+// have at least the following members:
+//
+//     typedef struct <name>_state_st {
+//       uint32_t h[<chaining length> / sizeof(uint32_t)];
+//       uint32_t Nl, Nh;
+//       uint8_t data[HASH_CBLOCK];
+//       unsigned num;
+//       ...
+//     } <NAME>_CTX;
+//
+// <chaining length> is the output length of the hash in bytes, before
+// any truncation (e.g. 64 for SHA-224 and SHA-256, 128 for SHA-384 and
+// SHA-512).
+//
+// |HASH_UPDATE| must be defined as the name of the "Update" function to
+// generate.
+//
+// |HASH_TRANSFORM| must be defined as the  the name of the "Transform"
+// function to generate.
+//
+// |HASH_FINAL| must be defined as the name of "Final" function to generate.
+//
+// |HASH_BLOCK_DATA_ORDER| must be defined as the name of the "Block" function.
+// That function must be implemented manually. It must be capable of operating
+// on *unaligned* input data in its original (data) byte order. It must have
+// this signature:
+//
+//     void HASH_BLOCK_DATA_ORDER(uint32_t *state, const uint8_t *data,
+//                                size_t num);
+//
+// It must update the hash state |state| with |num| blocks of data from |data|,
+// where each block is |HASH_CBLOCK| bytes; i.e. |data| points to a array of
+// |HASH_CBLOCK * num| bytes. |state| points to the |h| member of a |HASH_CTX|,
+// and so will have |<chaining length> / sizeof(uint32_t)| elements.
+//
+// |HASH_MAKE_STRING(c, s)| must be defined as a block statement that converts
+// the hash state |c->h| into the output byte order, storing the result in |s|.
 
 #if !defined(DATA_ORDER_IS_BIG_ENDIAN) && !defined(DATA_ORDER_IS_LITTLE_ENDIAN)
 #error "DATA_ORDER must be defined!"
@@ -176,7 +172,7 @@ extern "C" {
     *((c)++) = (uint8_t)(((l) >> 24) & 0xff); \
   } while (0)
 
-#endif /* DATA_ORDER */
+#endif  // DATA_ORDER
 
 int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len) {
   const uint8_t *data = data_;
@@ -187,7 +183,7 @@ int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len) {
 
   uint32_t l = c->Nl + (((uint32_t)len) << 3);
   if (l < c->Nl) {
-    /* Handle carries. */
+    // Handle carries.
     c->Nh++;
   }
   c->Nh += (uint32_t)(len >> 29);
@@ -202,7 +198,7 @@ int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len) {
       data += n;
       len -= n;
       c->num = 0;
-      /* Keep |c->data| zeroed when unused. */
+      // Keep |c->data| zeroed when unused.
       OPENSSL_memset(c->data, 0, HASH_CBLOCK);
     } else {
       OPENSSL_memcpy(c->data + n, data, len);
@@ -233,14 +229,14 @@ void HASH_TRANSFORM(HASH_CTX *c, const uint8_t *data) {
 
 
 int HASH_FINAL(uint8_t *md, HASH_CTX *c) {
-  /* |c->data| always has room for at least one byte. A full block would have
-   * been consumed. */
+  // |c->data| always has room for at least one byte. A full block would have
+  // been consumed.
   size_t n = c->num;
   assert(n < HASH_CBLOCK);
   c->data[n] = 0x80;
   n++;
 
-  /* Fill the block with zeros if there isn't room for a 64-bit length. */
+  // Fill the block with zeros if there isn't room for a 64-bit length.
   if (n > (HASH_CBLOCK - 8)) {
     OPENSSL_memset(c->data + n, 0, HASH_CBLOCK - n);
     n = 0;
@@ -248,7 +244,7 @@ int HASH_FINAL(uint8_t *md, HASH_CTX *c) {
   }
   OPENSSL_memset(c->data + n, 0, HASH_CBLOCK - 8 - n);
 
-  /* Append a 64-bit length to the block and process it. */
+  // Append a 64-bit length to the block and process it.
   uint8_t *p = c->data + HASH_CBLOCK - 8;
 #if defined(DATA_ORDER_IS_BIG_ENDIAN)
   HOST_l2c(c->Nh, p);
@@ -268,7 +264,5 @@ int HASH_FINAL(uint8_t *md, HASH_CTX *c) {
 
 
 #if defined(__cplusplus)
-} /* extern C */
+}  // extern C
 #endif
-
-#endif /* OPENSSL_HEADER_MD32_COMMON_H */

data/third_party/boringssl/crypto/{ec → fipsmodule/ec}/internal.h

@@ -88,28 +88,28 @@ struct ec_method_st {
   int (*point_get_affine_coordinates)(const EC_GROUP *, const EC_POINT *,
                                       BIGNUM *x, BIGNUM *y, BN_CTX *);
 
-  /* Computes |r = g_scalar*generator + p_scalar*p| if |g_scalar| and |p_scalar|
-   * are both non-null. Computes |r = g_scalar*generator| if |p_scalar| is null.
-   * Computes |r = p_scalar*p| if g_scalar is null. At least one of |g_scalar|
-   * and |p_scalar| must be non-null, and |p| must be non-null if |p_scalar| is
-   * non-null. */
+  // Computes |r = g_scalar*generator + p_scalar*p| if |g_scalar| and |p_scalar|
+  // are both non-null. Computes |r = g_scalar*generator| if |p_scalar| is null.
+  // Computes |r = p_scalar*p| if g_scalar is null. At least one of |g_scalar|
+  // and |p_scalar| must be non-null, and |p| must be non-null if |p_scalar| is
+  // non-null.
   int (*mul)(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
              const EC_POINT *p, const BIGNUM *p_scalar, BN_CTX *ctx);
 
-  /* 'field_mul' and 'field_sqr' can be used by 'add' and 'dbl' so that the
-   * same implementations of point operations can be used with different
-   * optimized implementations of expensive field operations: */
+  // 'field_mul' and 'field_sqr' can be used by 'add' and 'dbl' so that the
+  // same implementations of point operations can be used with different
+  // optimized implementations of expensive field operations:
   int (*field_mul)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a,
                    const BIGNUM *b, BN_CTX *);
   int (*field_sqr)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a, BN_CTX *);
 
   int (*field_encode)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a,
-                      BN_CTX *); /* e.g. to Montgomery */
+                      BN_CTX *);  // e.g. to Montgomery
   int (*field_decode)(const EC_GROUP *, BIGNUM *r, const BIGNUM *a,
-                      BN_CTX *); /* e.g. from Montgomery */
+                      BN_CTX *);  // e.g. from Montgomery
 } /* EC_METHOD */;
 
-extern const EC_METHOD EC_GFp_mont_method;
+const EC_METHOD *EC_GFp_mont_method(void);
 
 struct ec_group_st {
   const EC_METHOD *meth;
@@ -117,22 +117,22 @@ struct ec_group_st {
   EC_POINT *generator;
   BIGNUM order;
 
-  int curve_name; /* optional NID for named curve */
+  int curve_name;  // optional NID for named curve
 
-  const BN_MONT_CTX *mont_data; /* data for ECDSA inverse */
+  const BN_MONT_CTX *order_mont;  // data for ECDSA inverse
 
-  /* The following members are handled by the method functions,
-   * even if they appear generic */
+  // The following members are handled by the method functions,
+  // even if they appear generic
 
-  BIGNUM field; /* For curves over GF(p), this is the modulus. */
+  BIGNUM field;  // For curves over GF(p), this is the modulus.
 
-  BIGNUM a, b; /* Curve coefficients. */
+  BIGNUM a, b;  // Curve coefficients.
 
-  int a_is_minus3; /* enable optimized point arithmetics for special case */
+  int a_is_minus3;  // enable optimized point arithmetics for special case
 
-  BN_MONT_CTX *mont; /* Montgomery structure. */
+  BN_MONT_CTX *mont;  // Montgomery structure.
 
-  BIGNUM one; /* The value one. */
+  BIGNUM one;  // The value one.
 } /* EC_GROUP */;
 
 struct ec_point_st {
@@ -140,22 +140,22 @@ struct ec_point_st {
 
   BIGNUM X;
   BIGNUM Y;
-  BIGNUM Z; /* Jacobian projective coordinates:
-             * (X, Y, Z)  represents  (X/Z^2, Y/Z^3)  if  Z != 0 */
+  BIGNUM Z;  // Jacobian projective coordinates:
+             // (X, Y, Z)  represents  (X/Z^2, Y/Z^3)  if  Z != 0
 } /* EC_POINT */;
 
 EC_GROUP *ec_group_new(const EC_METHOD *meth);
 int ec_group_copy(EC_GROUP *dest, const EC_GROUP *src);
 
-/* ec_group_get_mont_data returns a Montgomery context for operations in the
- * scalar field of |group|. It may return NULL in the case that |group| is not
- * a built-in group. */
-const BN_MONT_CTX *ec_group_get_mont_data(const EC_GROUP *group);
+// ec_group_get_order_mont returns a Montgomery context for operations modulo
+// |group|'s order. It may return NULL in the case that |group| is not a
+// built-in group.
+const BN_MONT_CTX *ec_group_get_order_mont(const EC_GROUP *group);
 
 int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
                 const EC_POINT *p, const BIGNUM *p_scalar, BN_CTX *ctx);
 
-/* method functions in simple.c */
+// method functions in simple.c
 int ec_GFp_simple_group_init(EC_GROUP *);
 void ec_GFp_simple_group_finish(EC_GROUP *);
 int ec_GFp_simple_group_copy(EC_GROUP *, const EC_GROUP *);
@@ -200,7 +200,7 @@ int ec_GFp_simple_field_mul(const EC_GROUP *, BIGNUM *r, const BIGNUM *a,
 int ec_GFp_simple_field_sqr(const EC_GROUP *, BIGNUM *r, const BIGNUM *a,
                             BN_CTX *);
 
-/* method functions in montgomery.c */
+// method functions in montgomery.c
 int ec_GFp_mont_group_init(EC_GROUP *);
 int ec_GFp_mont_group_set_curve(EC_GROUP *, const BIGNUM *p, const BIGNUM *a,
                                 const BIGNUM *b, BN_CTX *);
@@ -222,12 +222,12 @@ int ec_point_set_Jprojective_coordinates_GFp(const EC_GROUP *group,
 
 void ec_GFp_nistp_recode_scalar_bits(uint8_t *sign, uint8_t *digit, uint8_t in);
 
-extern const EC_METHOD EC_GFp_nistp224_method;
-extern const EC_METHOD EC_GFp_nistp256_method;
+const EC_METHOD *EC_GFp_nistp224_method(void);
+const EC_METHOD *EC_GFp_nistp256_method(void);
 
-/* EC_GFp_nistz256_method is a GFp method using montgomery multiplication, with
- * x86-64 optimized P256. See http://eprint.iacr.org/2013/816. */
-extern const EC_METHOD EC_GFp_nistz256_method;
+// EC_GFp_nistz256_method is a GFp method using montgomery multiplication, with
+// x86-64 optimized P256. See http://eprint.iacr.org/2013/816.
+const EC_METHOD *EC_GFp_nistz256_method(void);
 
 struct ec_key_st {
   EC_GROUP *group;
@@ -235,6 +235,10 @@ struct ec_key_st {
   EC_POINT *pub_key;
   BIGNUM *priv_key;
 
+  // fixed_k may contain a specific value of 'k', to be used in ECDSA signing.
+  // This is only for the FIPS power-on tests.
+  BIGNUM *fixed_k;
+
   unsigned int enc_flag;
   point_conversion_form_t conv_form;
 
@@ -245,32 +249,34 @@ struct ec_key_st {
   CRYPTO_EX_DATA ex_data;
 } /* EC_KEY */;
 
-/* curve_data contains data about a built-in elliptic curve. */
-struct curve_data {
-  /* comment is a human-readable string describing the curve. */
-  const char *comment;
-  /* param_len is the number of bytes needed to store a field element. */
-  uint8_t param_len;
-  /* data points to an array of 6*|param_len| bytes which hold the field
-   * elements of the following (in big-endian order): prime, a, b, generator x,
-   * generator y, order. */
-  const uint8_t data[];
-};
-
 struct built_in_curve {
   int nid;
-  uint8_t oid[8];
+  const uint8_t *oid;
   uint8_t oid_len;
-  const struct curve_data *data;
+  // comment is a human-readable string describing the curve.
+  const char *comment;
+  // param_len is the number of bytes needed to store a field element.
+  uint8_t param_len;
+  // params points to an array of 6*|param_len| bytes which hold the field
+  // elements of the following (in big-endian order): prime, a, b, generator x,
+  // generator y, order.
+  const uint8_t *params;
   const EC_METHOD *method;
 };
 
-/* OPENSSL_built_in_curves is terminated with an entry where |nid| is
- * |NID_undef|. */
-extern const struct built_in_curve OPENSSL_built_in_curves[];
+#define OPENSSL_NUM_BUILT_IN_CURVES 4
+
+struct built_in_curves {
+  struct built_in_curve curves[OPENSSL_NUM_BUILT_IN_CURVES];
+};
+
+// OPENSSL_built_in_curves returns a pointer to static information about
+// standard curves. The array is terminated with an entry where |nid| is
+// |NID_undef|.
+const struct built_in_curves *OPENSSL_built_in_curves(void);
 
 #if defined(__cplusplus)
-}  /* extern C */
+}  // extern C
 #endif
 
-#endif  /* OPENSSL_HEADER_EC_INTERNAL_H */
+#endif  // OPENSSL_HEADER_EC_INTERNAL_H

data/third_party/boringssl/crypto/{ec → fipsmodule/ec}/p256-x86_64-table.h

@@ -12,17 +12,17 @@
  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
 
-/* This is the precomputed constant time access table for the code in
- * p256-x86_64.c, for the default generator. The table consists of 37
- * subtables, each subtable contains 64 affine points. The affine points are
- * encoded as eight uint64's, four for the x coordinate and four for the y.
- * Both values are in little-endian order. There are 37 tables because a
- * signed, 6-bit wNAF form of the scalar is used and ceil(256/(6 + 1)) = 37.
- * Within each table there are 64 values because the 6-bit wNAF value can take
- * 64 values, ignoring the sign bit, which is implemented by performing a
- * negation of the affine point when required. We would like to align it to 2MB
- * in order to increase the chances of using a large page but that appears to
- * lead to invalid ELF files being produced. */
+// This is the precomputed constant time access table for the code in
+// p256-x86_64.c, for the default generator. The table consists of 37
+// subtables, each subtable contains 64 affine points. The affine points are
+// encoded as eight uint64's, four for the x coordinate and four for the y.
+// Both values are in little-endian order. There are 37 tables because a
+// signed, 6-bit wNAF form of the scalar is used and ceil(256/(6 + 1)) = 37.
+// Within each table there are 64 values because the 6-bit wNAF value can take
+// 64 values, ignoring the sign bit, which is implemented by performing a
+// negation of the affine point when required. We would like to align it to 2MB
+// in order to increase the chances of using a large page but that appears to
+// lead to invalid ELF files being produced.
 
 static const alignas(4096) BN_ULONG
     ecp_nistz256_precomputed[37][64 * sizeof(P256_POINT_AFFINE) /

data/third_party/boringssl/crypto/{ec → fipsmodule/ec}/p256-x86_64.h

@@ -27,30 +27,30 @@ extern "C" {
 #if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && \
     !defined(OPENSSL_SMALL)
 
-/* P-256 field operations.
- *
- * An element mod P in P-256 is represented as a little-endian array of
- * |P256_LIMBS| |BN_ULONG|s, spanning the full range of values.
- *
- * The following functions take fully-reduced inputs mod P and give
- * fully-reduced outputs. They may be used in-place. */
+// P-256 field operations.
+//
+// An element mod P in P-256 is represented as a little-endian array of
+// |P256_LIMBS| |BN_ULONG|s, spanning the full range of values.
+//
+// The following functions take fully-reduced inputs mod P and give
+// fully-reduced outputs. They may be used in-place.
 
 #define P256_LIMBS (256 / BN_BITS2)
 
-/* ecp_nistz256_neg sets |res| to -|a| mod P. */
+// ecp_nistz256_neg sets |res| to -|a| mod P.
 void ecp_nistz256_neg(BN_ULONG res[P256_LIMBS], const BN_ULONG a[P256_LIMBS]);
 
-/* ecp_nistz256_mul_mont sets |res| to |a| * |b| * 2^-256 mod P. */
+// ecp_nistz256_mul_mont sets |res| to |a| * |b| * 2^-256 mod P.
 void ecp_nistz256_mul_mont(BN_ULONG res[P256_LIMBS],
                            const BN_ULONG a[P256_LIMBS],
                            const BN_ULONG b[P256_LIMBS]);
 
-/* ecp_nistz256_sqr_mont sets |res| to |a| * |a| * 2^-256 mod P. */
+// ecp_nistz256_sqr_mont sets |res| to |a| * |a| * 2^-256 mod P.
 void ecp_nistz256_sqr_mont(BN_ULONG res[P256_LIMBS],
                            const BN_ULONG a[P256_LIMBS]);
 
-/* ecp_nistz256_from_mont sets |res| to |in|, converted from Montgomery domain
- * by multiplying with 1. */
+// ecp_nistz256_from_mont sets |res| to |in|, converted from Montgomery domain
+// by multiplying with 1.
 static inline void ecp_nistz256_from_mont(BN_ULONG res[P256_LIMBS],
                                           const BN_ULONG in[P256_LIMBS]) {
   static const BN_ULONG ONE[P256_LIMBS] = { 1 };
@@ -58,47 +58,47 @@ static inline void ecp_nistz256_from_mont(BN_ULONG res[P256_LIMBS],
 }
 
 
-/* P-256 point operations.
- *
- * The following functions may be used in-place. All coordinates are in the
- * Montgomery domain. */
+// P-256 point operations.
+//
+// The following functions may be used in-place. All coordinates are in the
+// Montgomery domain.
 
-/* A P256_POINT represents a P-256 point in Jacobian coordinates. */
+// A P256_POINT represents a P-256 point in Jacobian coordinates.
 typedef struct {
   BN_ULONG X[P256_LIMBS];
   BN_ULONG Y[P256_LIMBS];
   BN_ULONG Z[P256_LIMBS];
 } P256_POINT;
 
-/* A P256_POINT_AFFINE represents a P-256 point in affine coordinates. Infinity
- * is encoded as (0, 0). */
+// A P256_POINT_AFFINE represents a P-256 point in affine coordinates. Infinity
+// is encoded as (0, 0).
 typedef struct {
   BN_ULONG X[P256_LIMBS];
   BN_ULONG Y[P256_LIMBS];
 } P256_POINT_AFFINE;
 
-/* ecp_nistz256_select_w5 sets |*val| to |in_t[index-1]| if 1 <= |index| <= 16
- * and all zeros (the point at infinity) if |index| is 0. This is done in
- * constant time. */
+// ecp_nistz256_select_w5 sets |*val| to |in_t[index-1]| if 1 <= |index| <= 16
+// and all zeros (the point at infinity) if |index| is 0. This is done in
+// constant time.
 void ecp_nistz256_select_w5(P256_POINT *val, const P256_POINT in_t[16],
                             int index);
 
-/* ecp_nistz256_select_w7 sets |*val| to |in_t[index-1]| if 1 <= |index| <= 64
- * and all zeros (the point at infinity) if |index| is 0. This is done in
- * constant time. */
+// ecp_nistz256_select_w7 sets |*val| to |in_t[index-1]| if 1 <= |index| <= 64
+// and all zeros (the point at infinity) if |index| is 0. This is done in
+// constant time.
 void ecp_nistz256_select_w7(P256_POINT_AFFINE *val,
                             const P256_POINT_AFFINE in_t[64], int index);
 
-/* ecp_nistz256_point_double sets |r| to |a| doubled. */
+// ecp_nistz256_point_double sets |r| to |a| doubled.
 void ecp_nistz256_point_double(P256_POINT *r, const P256_POINT *a);
 
-/* ecp_nistz256_point_add adds |a| to |b| and places the result in |r|. */
+// ecp_nistz256_point_add adds |a| to |b| and places the result in |r|.
 void ecp_nistz256_point_add(P256_POINT *r, const P256_POINT *a,
                             const P256_POINT *b);
 
-/* ecp_nistz256_point_add_affine adds |a| to |b| and places the result in
- * |r|. |a| and |b| must not represent the same point unless they are both
- * infinity. */
+// ecp_nistz256_point_add_affine adds |a| to |b| and places the result in
+// |r|. |a| and |b| must not represent the same point unless they are both
+// infinity.
 void ecp_nistz256_point_add_affine(P256_POINT *r, const P256_POINT *a,
                                    const P256_POINT_AFFINE *b);
 
@@ -107,7 +107,7 @@ void ecp_nistz256_point_add_affine(P256_POINT *r, const P256_POINT *a,
 
 
 #if defined(__cplusplus)
-}  /* extern C++ */
+}  // extern C++
 #endif
 
-#endif  /* OPENSSL_HEADER_EC_P256_X86_64_H */
+#endif  // OPENSSL_HEADER_EC_P256_X86_64_H