1 files changed, 212 insertions, 231 deletions

diff --git a/lib/libssl/src/crypto/ec/ec_ameth.c b/lib/libssl/src/crypto/ec/ec_ameth.c
index 0e6381f5439..9b52c3cbfc8 100644
--- a/lib/libssl/src/crypto/ec/ec_ameth.c
+++ b/lib/libssl/src/crypto/ec/ec_ameth.c
@@ -9,7 +9,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -65,54 +65,51 @@
 #endif
 #include "asn1_locl.h"
 
-static int eckey_param2type(int *pptype, void **ppval, EC_KEY *ec_key)
-	{
-	const EC_GROUP  *group;
+static int 
+eckey_param2type(int *pptype, void **ppval, EC_KEY * ec_key)
+{
+	const EC_GROUP *group;
 	int nid;
-	if (ec_key == NULL || (group = EC_KEY_get0_group(ec_key)) == NULL) 
-	{
+	if (ec_key == NULL || (group = EC_KEY_get0_group(ec_key)) == NULL) {
 		ECerr(EC_F_ECKEY_PARAM2TYPE, EC_R_MISSING_PARAMETERS);
 		return 0;
 	}
-	if (EC_GROUP_get_asn1_flag(group)
-                     && (nid = EC_GROUP_get_curve_name(group)))
+	if (EC_GROUP_get_asn1_flag(group) &&
+	    (nid = EC_GROUP_get_curve_name(group))) {
 		/* we have a 'named curve' => just set the OID */
-		{
 		*ppval = OBJ_nid2obj(nid);
 		*pptype = V_ASN1_OBJECT;
-		}
-	else	/* explicit parameters */
-		{
+	} else {
+		/* explicit parameters */
 		ASN1_STRING *pstr = NULL;
 		pstr = ASN1_STRING_new();
 		if (!pstr)
 			return 0;
 		pstr->length = i2d_ECParameters(ec_key, &pstr->data);
-		if (pstr->length <= 0)
-			{
+		if (pstr->length <= 0) {
 			ASN1_STRING_free(pstr);
 			ECerr(EC_F_ECKEY_PARAM2TYPE, ERR_R_EC_LIB);
 			return 0;
-			}
+		}
 		*ppval = pstr;
 		*pptype = V_ASN1_SEQUENCE;
-		}
-	return 1;
 	}
+	return 1;
+}
 
-static int eckey_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
-	{
+static int 
+eckey_pub_encode(X509_PUBKEY * pk, const EVP_PKEY * pkey)
+{
 	EC_KEY *ec_key = pkey->pkey.ec;
 	void *pval = NULL;
 	int ptype;
 	unsigned char *penc = NULL, *p;
 	int penclen;
 
-	if (!eckey_param2type(&ptype, &pval, ec_key))
-		{
+	if (!eckey_param2type(&ptype, &pval, ec_key)) {
 		ECerr(EC_F_ECKEY_PUB_ENCODE, ERR_R_EC_LIB);
 		return 0;
-		}
+	}
 	penclen = i2o_ECPublicKey(ec_key, NULL);
 	if (penclen <= 0)
 		goto err;
@@ -124,9 +121,9 @@ static int eckey_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
 	if (penclen <= 0)
 		goto err;
 	if (X509_PUBKEY_set0_param(pk, OBJ_nid2obj(EVP_PKEY_EC),
-				ptype, pval, penc, penclen))
+		ptype, pval, penc, penclen))
 		return 1;
-	err:
+err:
 	if (ptype == V_ASN1_OBJECT)
 		ASN1_OBJECT_free(pval);
 	else
@@ -134,37 +131,36 @@ static int eckey_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
 	if (penc)
 		free(penc);
 	return 0;
-	}
+}
 
-static EC_KEY *eckey_type2param(int ptype, void *pval)
-	{
+static EC_KEY *
+eckey_type2param(int ptype, void *pval)
+{
 	EC_KEY *eckey = NULL;
-	if (ptype == V_ASN1_SEQUENCE)
-		{
+
+	if (ptype == V_ASN1_SEQUENCE) {
 		ASN1_STRING *pstr = pval;
 		const unsigned char *pm = NULL;
 		int pmlen;
+
 		pm = pstr->data;
 		pmlen = pstr->length;
-		if (!(eckey = d2i_ECParameters(NULL, &pm, pmlen)))
-			{
+		if (!(eckey = d2i_ECParameters(NULL, &pm, pmlen))) {
 			ECerr(EC_F_ECKEY_TYPE2PARAM, EC_R_DECODE_ERROR);
 			goto ecerr;
-			}
 		}
-	else if (ptype == V_ASN1_OBJECT)
-		{
+	} else if (ptype == V_ASN1_OBJECT) {
 		ASN1_OBJECT *poid = pval;
 		EC_GROUP *group;
 
-		/* type == V_ASN1_OBJECT => the parameters are given
-		 * by an asn1 OID
+		/*
+		 * type == V_ASN1_OBJECT => the parameters are given by an
+		 * asn1 OID
 		 */
-		if ((eckey = EC_KEY_new()) == NULL)
-			{
+		if ((eckey = EC_KEY_new()) == NULL) {
 			ECerr(EC_F_ECKEY_TYPE2PARAM, ERR_R_MALLOC_FAILURE);
 			goto ecerr;
-			}
+		}
 		group = EC_GROUP_new_by_curve_name(OBJ_obj2nid(poid));
 		if (group == NULL)
 			goto ecerr;
@@ -172,23 +168,22 @@ static EC_KEY *eckey_type2param(int ptype, void *pval)
 		if (EC_KEY_set_group(eckey, group) == 0)
 			goto ecerr;
 		EC_GROUP_free(group);
-		}
-	else
-		{
+	} else {
 		ECerr(EC_F_ECKEY_TYPE2PARAM, EC_R_DECODE_ERROR);
 		goto ecerr;
-		}
+	}
 
 	return eckey;
 
-	ecerr:
+ecerr:
 	if (eckey)
 		EC_KEY_free(eckey);
 	return NULL;
-	}
+}
 
-static int eckey_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
-	{
+static int 
+eckey_pub_decode(EVP_PKEY * pkey, X509_PUBKEY * pubkey)
+{
 	const unsigned char *p = NULL;
 	void *pval;
 	int ptype, pklen;
@@ -201,44 +196,42 @@ static int eckey_pub_decode(EVP_PKEY *pkey, X509_PUBKEY *pubkey)
 
 	eckey = eckey_type2param(ptype, pval);
 
-	if (!eckey)
-		{
+	if (!eckey) {
 		ECerr(EC_F_ECKEY_PUB_DECODE, ERR_R_EC_LIB);
 		return 0;
-		}
-
+	}
 	/* We have parameters now set public key */
-	if (!o2i_ECPublicKey(&eckey, &p, pklen))
-		{
+	if (!o2i_ECPublicKey(&eckey, &p, pklen)) {
 		ECerr(EC_F_ECKEY_PUB_DECODE, EC_R_DECODE_ERROR);
 		goto ecerr;
-		}
-
+	}
 	EVP_PKEY_assign_EC_KEY(pkey, eckey);
 	return 1;
 
-	ecerr:
+ecerr:
 	if (eckey)
 		EC_KEY_free(eckey);
 	return 0;
-	}
+}
 
-static int eckey_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b)
-	{
-	int  r;
+static int 
+eckey_pub_cmp(const EVP_PKEY * a, const EVP_PKEY * b)
+{
+	int r;
 	const EC_GROUP *group = EC_KEY_get0_group(b->pkey.ec);
-	const EC_POINT *pa = EC_KEY_get0_public_key(a->pkey.ec),
-	               *pb = EC_KEY_get0_public_key(b->pkey.ec);
+	const EC_POINT *pa = EC_KEY_get0_public_key(a->pkey.ec), *pb = EC_KEY_get0_public_key(b->pkey.ec);
+
 	r = EC_POINT_cmp(group, pa, pb, NULL);
 	if (r == 0)
 		return 1;
 	if (r == 1)
 		return 0;
 	return -2;
-	}
+}
 
-static int eckey_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
-	{
+static int 
+eckey_priv_decode(EVP_PKEY * pkey, PKCS8_PRIV_KEY_INFO * p8)
+{
 	const unsigned char *p = NULL;
 	void *pval;
 	int ptype, pklen;
@@ -255,100 +248,92 @@ static int eckey_priv_decode(EVP_PKEY *pkey, PKCS8_PRIV_KEY_INFO *p8)
 		goto ecliberr;
 
 	/* We have parameters now set private key */
-	if (!d2i_ECPrivateKey(&eckey, &p, pklen))
-		{
+	if (!d2i_ECPrivateKey(&eckey, &p, pklen)) {
 		ECerr(EC_F_ECKEY_PRIV_DECODE, EC_R_DECODE_ERROR);
 		goto ecerr;
-		}
-
+	}
 	/* calculate public key (if necessary) */
-	if (EC_KEY_get0_public_key(eckey) == NULL)
-		{
+	if (EC_KEY_get0_public_key(eckey) == NULL) {
 		const BIGNUM *priv_key;
 		const EC_GROUP *group;
 		EC_POINT *pub_key;
-		/* the public key was not included in the SEC1 private
-		 * key => calculate the public key */
-		group   = EC_KEY_get0_group(eckey);
+		/*
+		 * the public key was not included in the SEC1 private key =>
+		 * calculate the public key
+		 */
+		group = EC_KEY_get0_group(eckey);
 		pub_key = EC_POINT_new(group);
-		if (pub_key == NULL)
-			{
+		if (pub_key == NULL) {
 			ECerr(EC_F_ECKEY_PRIV_DECODE, ERR_R_EC_LIB);
 			goto ecliberr;
-			}
-		if (!EC_POINT_copy(pub_key, EC_GROUP_get0_generator(group)))
-			{
+		}
+		if (!EC_POINT_copy(pub_key, EC_GROUP_get0_generator(group))) {
 			EC_POINT_free(pub_key);
 			ECerr(EC_F_ECKEY_PRIV_DECODE, ERR_R_EC_LIB);
 			goto ecliberr;
-			}
+		}
 		priv_key = EC_KEY_get0_private_key(eckey);
-		if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, NULL))
-			{
+		if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, NULL)) {
 			EC_POINT_free(pub_key);
 			ECerr(EC_F_ECKEY_PRIV_DECODE, ERR_R_EC_LIB);
 			goto ecliberr;
-			}
-		if (EC_KEY_set_public_key(eckey, pub_key) == 0)
-			{
+		}
+		if (EC_KEY_set_public_key(eckey, pub_key) == 0) {
 			EC_POINT_free(pub_key);
 			ECerr(EC_F_ECKEY_PRIV_DECODE, ERR_R_EC_LIB);
 			goto ecliberr;
-			}
-		EC_POINT_free(pub_key);
 		}
-
+		EC_POINT_free(pub_key);
+	}
 	EVP_PKEY_assign_EC_KEY(pkey, eckey);
 	return 1;
 
-	ecliberr:
+ecliberr:
 	ECerr(EC_F_ECKEY_PRIV_DECODE, ERR_R_EC_LIB);
-	ecerr:
+ecerr:
 	if (eckey)
 		EC_KEY_free(eckey);
 	return 0;
-	}
+}
 
-static int eckey_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
+static int 
+eckey_priv_encode(PKCS8_PRIV_KEY_INFO * p8, const EVP_PKEY * pkey)
 {
-	EC_KEY		*ec_key;
-	unsigned char	*ep, *p;
-	int 		eplen, ptype;
-	void		*pval;
-	unsigned int    tmp_flags, old_flags;
+	EC_KEY *ec_key;
+	unsigned char *ep, *p;
+	int eplen, ptype;
+	void *pval;
+	unsigned int tmp_flags, old_flags;
 
 	ec_key = pkey->pkey.ec;
 
-	if (!eckey_param2type(&ptype, &pval, ec_key))
-		{
+	if (!eckey_param2type(&ptype, &pval, ec_key)) {
 		ECerr(EC_F_ECKEY_PRIV_ENCODE, EC_R_DECODE_ERROR);
 		return 0;
-		}
-
+	}
 	/* set the private key */
 
-	/* do not include the parameters in the SEC1 private key
-	 * see PKCS#11 12.11 */
+	/*
+	 * do not include the parameters in the SEC1 private key see PKCS#11
+	 * 12.11
+	 */
 	old_flags = EC_KEY_get_enc_flags(ec_key);
 	tmp_flags = old_flags | EC_PKEY_NO_PARAMETERS;
 	EC_KEY_set_enc_flags(ec_key, tmp_flags);
 	eplen = i2d_ECPrivateKey(ec_key, NULL);
-	if (!eplen)
-	{
+	if (!eplen) {
 		EC_KEY_set_enc_flags(ec_key, old_flags);
 		ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_EC_LIB);
 		return 0;
 	}
 	ep = (unsigned char *) malloc(eplen);
-	if (!ep)
-	{
+	if (!ep) {
 		EC_KEY_set_enc_flags(ec_key, old_flags);
 		ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
 		return 0;
 	}
 	p = ep;
-	if (!i2d_ECPrivateKey(ec_key, &p))
-	{
+	if (!i2d_ECPrivateKey(ec_key, &p)) {
 		EC_KEY_set_enc_flags(ec_key, old_flags);
 		free(ep);
 		ECerr(EC_F_ECKEY_PRIV_ENCODE, ERR_R_EC_LIB);
@@ -358,49 +343,50 @@ static int eckey_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
 	EC_KEY_set_enc_flags(ec_key, old_flags);
 
 	if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(NID_X9_62_id_ecPublicKey), 0,
-				ptype, pval, ep, eplen))
+		ptype, pval, ep, eplen))
 		return 0;
 
 	return 1;
 }
 
-static int int_ec_size(const EVP_PKEY *pkey)
-	{
+static int 
+int_ec_size(const EVP_PKEY * pkey)
+{
 	return ECDSA_size(pkey->pkey.ec);
-	}
+}
 
-static int ec_bits(const EVP_PKEY *pkey)
-	{
+static int 
+ec_bits(const EVP_PKEY * pkey)
+{
 	BIGNUM *order = BN_new();
 	const EC_GROUP *group;
 	int ret;
 
-	if (!order)
-		{
+	if (!order) {
 		ERR_clear_error();
 		return 0;
-		}
+	}
 	group = EC_KEY_get0_group(pkey->pkey.ec);
-	if (!EC_GROUP_get_order(group, order, NULL))
-		{
+	if (!EC_GROUP_get_order(group, order, NULL)) {
 		ERR_clear_error();
 		return 0;
-		}
-
+	}
 	ret = BN_num_bits(order);
 	BN_free(order);
 	return ret;
-	}
+}
 
-static int ec_missing_parameters(const EVP_PKEY *pkey)
-	{
+static int 
+ec_missing_parameters(const EVP_PKEY * pkey)
+{
 	if (EC_KEY_get0_group(pkey->pkey.ec) == NULL)
 		return 1;
 	return 0;
-	}
+}
 
-static int ec_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
-	{
+static int 
+ec_copy_parameters(EVP_PKEY * to, const EVP_PKEY * from)
+{
 	EC_GROUP *group = EC_GROUP_dup(EC_KEY_get0_group(from->pkey.ec));
 	if (group == NULL)
 		return 0;
@@ -408,79 +394,70 @@ static int ec_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from)
 		return 0;
 	EC_GROUP_free(group);
 	return 1;
-	}
+}
 
-static int ec_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b)
-	{
-	const EC_GROUP *group_a = EC_KEY_get0_group(a->pkey.ec),
-	               *group_b = EC_KEY_get0_group(b->pkey.ec);
+static int 
+ec_cmp_parameters(const EVP_PKEY * a, const EVP_PKEY * b)
+{
+	const EC_GROUP *group_a = EC_KEY_get0_group(a->pkey.ec), *group_b = EC_KEY_get0_group(b->pkey.ec);
 	if (EC_GROUP_cmp(group_a, group_b, NULL))
 		return 0;
 	else
 		return 1;
-	}
+}
 
-static void int_ec_free(EVP_PKEY *pkey)
-	{
+static void 
+int_ec_free(EVP_PKEY * pkey)
+{
 	EC_KEY_free(pkey->pkey.ec);
-	}
+}
 
-static int do_EC_KEY_print(BIO *bp, const EC_KEY *x, int off, int ktype)
-	{
-	unsigned char *buffer=NULL;
+static int 
+do_EC_KEY_print(BIO * bp, const EC_KEY * x, int off, int ktype)
+{
+	unsigned char *buffer = NULL;
 	const char *ecstr;
-	size_t	buf_len=0, i;
-	int     ret=0, reason=ERR_R_BIO_LIB;
-	BIGNUM  *pub_key=NULL, *order=NULL;
-	BN_CTX  *ctx=NULL;
+	size_t buf_len = 0, i;
+	int ret = 0, reason = ERR_R_BIO_LIB;
+	BIGNUM *pub_key = NULL, *order = NULL;
+	BN_CTX *ctx = NULL;
 	const EC_GROUP *group;
 	const EC_POINT *public_key;
 	const BIGNUM *priv_key;
- 
-	if (x == NULL || (group = EC_KEY_get0_group(x)) == NULL)
-		{
+
+	if (x == NULL || (group = EC_KEY_get0_group(x)) == NULL) {
 		reason = ERR_R_PASSED_NULL_PARAMETER;
 		goto err;
-		}
-
+	}
 	ctx = BN_CTX_new();
-	if (ctx == NULL)
-		{
+	if (ctx == NULL) {
 		reason = ERR_R_MALLOC_FAILURE;
 		goto err;
-		}
-
-	if (ktype > 0)
-		{
+	}
+	if (ktype > 0) {
 		public_key = EC_KEY_get0_public_key(x);
 		if ((pub_key = EC_POINT_point2bn(group, public_key,
-			EC_KEY_get_conv_form(x), NULL, ctx)) == NULL)
-			{
+			    EC_KEY_get_conv_form(x), NULL, ctx)) == NULL) {
 			reason = ERR_R_EC_LIB;
 			goto err;
-			}
-		if (pub_key)
-			buf_len = (size_t)BN_num_bytes(pub_key);
 		}
-
-	if (ktype == 2)
-		{
+		if (pub_key)
+			buf_len = (size_t) BN_num_bytes(pub_key);
+	}
+	if (ktype == 2) {
 		priv_key = EC_KEY_get0_private_key(x);
-		if (priv_key && (i = (size_t)BN_num_bytes(priv_key)) > buf_len)
+		if (priv_key && (i = (size_t) BN_num_bytes(priv_key)) > buf_len)
 			buf_len = i;
-		}
-	else
+	} else
 		priv_key = NULL;
 
-	if (ktype > 0)
-		{
+	if (ktype > 0) {
 		buf_len += 10;
-		if ((buffer = malloc(buf_len)) == NULL)
-			{
+		if ((buffer = malloc(buf_len)) == NULL) {
 			reason = ERR_R_MALLOC_FAILURE;
 			goto err;
-			}
 		}
+	}
 	if (ktype == 2)
 		ecstr = "Private-Key";
 	else if (ktype == 1)
@@ -495,9 +472,10 @@ static int do_EC_KEY_print(BIO *bp, const EC_KEY *x, int off, int ktype)
 	if (!EC_GROUP_get_order(group, order, NULL))
 		goto err;
 	if (BIO_printf(bp, "%s: (%d bit)\n", ecstr,
-		BN_num_bits(order)) <= 0) goto err;
-  
-	if ((priv_key != NULL) && !ASN1_bn_print(bp, "priv:", priv_key, 
+		BN_num_bits(order)) <= 0)
+		goto err;
+
+	if ((priv_key != NULL) && !ASN1_bn_print(bp, "priv:", priv_key,
 		buffer, off))
 		goto err;
 	if ((pub_key != NULL) && !ASN1_bn_print(bp, "pub: ", pub_key,
@@ -505,11 +483,11 @@ static int do_EC_KEY_print(BIO *bp, const EC_KEY *x, int off, int ktype)
 		goto err;
 	if (!ECPKParameters_print(bp, group, off))
 		goto err;
-	ret=1;
+	ret = 1;
 err:
 	if (!ret)
- 		ECerr(EC_F_DO_EC_KEY_PRINT, reason);
-	if (pub_key) 
+		ECerr(EC_F_DO_EC_KEY_PRINT, reason);
+	if (pub_key)
 		BN_free(pub_key);
 	if (order)
 		BN_free(order);
@@ -517,71 +495,75 @@ err:
 		BN_CTX_free(ctx);
 	if (buffer != NULL)
 		free(buffer);
-	return(ret);
-	}
+	return (ret);
+}
 
-static int eckey_param_decode(EVP_PKEY *pkey,
-					const unsigned char **pder, int derlen)
-	{
+static int 
+eckey_param_decode(EVP_PKEY * pkey,
+    const unsigned char **pder, int derlen)
+{
 	EC_KEY *eckey;
-	if (!(eckey = d2i_ECParameters(NULL, pder, derlen)))
-		{
+	if (!(eckey = d2i_ECParameters(NULL, pder, derlen))) {
 		ECerr(EC_F_ECKEY_PARAM_DECODE, ERR_R_EC_LIB);
 		return 0;
-		}
+	}
 	EVP_PKEY_assign_EC_KEY(pkey, eckey);
 	return 1;
-	}
+}
 
-static int eckey_param_encode(const EVP_PKEY *pkey, unsigned char **pder)
-	{
+static int 
+eckey_param_encode(const EVP_PKEY * pkey, unsigned char **pder)
+{
 	return i2d_ECParameters(pkey->pkey.ec, pder);
-	}
+}
 
-static int eckey_param_print(BIO *bp, const EVP_PKEY *pkey, int indent,
-							ASN1_PCTX *ctx)
-	{
+static int 
+eckey_param_print(BIO * bp, const EVP_PKEY * pkey, int indent,
+    ASN1_PCTX * ctx)
+{
 	return do_EC_KEY_print(bp, pkey->pkey.ec, indent, 0);
-	}
+}
 
-static int eckey_pub_print(BIO *bp, const EVP_PKEY *pkey, int indent,
-							ASN1_PCTX *ctx)
-	{
+static int 
+eckey_pub_print(BIO * bp, const EVP_PKEY * pkey, int indent,
+    ASN1_PCTX * ctx)
+{
 	return do_EC_KEY_print(bp, pkey->pkey.ec, indent, 1);
-	}
+}
 
 
-static int eckey_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent,
-							ASN1_PCTX *ctx)
-	{
+static int 
+eckey_priv_print(BIO * bp, const EVP_PKEY * pkey, int indent,
+    ASN1_PCTX * ctx)
+{
 	return do_EC_KEY_print(bp, pkey->pkey.ec, indent, 2);
-	}
+}
 
-static int old_ec_priv_decode(EVP_PKEY *pkey,
-					const unsigned char **pder, int derlen)
-	{
+static int 
+old_ec_priv_decode(EVP_PKEY * pkey,
+    const unsigned char **pder, int derlen)
+{
 	EC_KEY *ec;
-	if (!(ec = d2i_ECPrivateKey (NULL, pder, derlen)))
-		{
+	if (!(ec = d2i_ECPrivateKey(NULL, pder, derlen))) {
 		ECerr(EC_F_OLD_EC_PRIV_DECODE, EC_R_DECODE_ERROR);
 		return 0;
-		}
+	}
 	EVP_PKEY_assign_EC_KEY(pkey, ec);
 	return 1;
-	}
+}
 
-static int old_ec_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
-	{
+static int 
+old_ec_priv_encode(const EVP_PKEY * pkey, unsigned char **pder)
+{
 	return i2d_ECPrivateKey(pkey->pkey.ec, pder);
-	}
+}
 
-static int ec_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
-	{
-	switch (op)
-		{
-		case ASN1_PKEY_CTRL_PKCS7_SIGN:
-		if (arg1 == 0)
-			{
+static int 
+ec_pkey_ctrl(EVP_PKEY * pkey, int op, long arg1, void *arg2)
+{
+	switch (op) {
+	case ASN1_PKEY_CTRL_PKCS7_SIGN:
+		if (arg1 == 0) {
 			int snid, hnid;
 			X509_ALGOR *alg1, *alg2;
 			PKCS7_SIGNER_INFO_get0_algs(arg2, NULL, &alg1, &alg2);
@@ -591,41 +573,40 @@ static int ec_pkey_ctrl(EVP_PKEY *pkey, int op, long arg1, void *arg2)
 			if (hnid == NID_undef)
 				return -1;
 			if (!OBJ_find_sigid_by_algs(&snid, hnid, EVP_PKEY_id(pkey)))
-				return -1; 
+				return -1;
 			X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, 0);
-			}
+		}
 		return 1;
 #ifndef OPENSSL_NO_CMS
-		case ASN1_PKEY_CTRL_CMS_SIGN:
-		if (arg1 == 0)
-			{
+	case ASN1_PKEY_CTRL_CMS_SIGN:
+		if (arg1 == 0) {
 			int snid, hnid;
 			X509_ALGOR *alg1, *alg2;
 			CMS_SignerInfo_get0_algs(arg2, NULL, NULL,
-								&alg1, &alg2);
+			    &alg1, &alg2);
 			if (alg1 == NULL || alg1->algorithm == NULL)
 				return -1;
 			hnid = OBJ_obj2nid(alg1->algorithm);
 			if (hnid == NID_undef)
 				return -1;
 			if (!OBJ_find_sigid_by_algs(&snid, hnid, EVP_PKEY_id(pkey)))
-				return -1; 
+				return -1;
 			X509_ALGOR_set0(alg2, OBJ_nid2obj(snid), V_ASN1_UNDEF, 0);
-			}
+		}
 		return 1;
 #endif
 
-		case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
-		*(int *)arg2 = NID_sha1;
+	case ASN1_PKEY_CTRL_DEFAULT_MD_NID:
+		*(int *) arg2 = NID_sha1;
 		return 2;
 
-		default:
+	default:
 		return -2;
 
-		}
-
 	}
 
+}
+
 const EVP_PKEY_ASN1_METHOD eckey_asn1_meth = {
 	.pkey_id = EVP_PKEY_EC,
 	.pkey_base_id = EVP_PKEY_EC,