Lob a KNF grenade into the ecdsa code.

8 files changed, 288 insertions, 312 deletions

diff --git a/lib/libcrypto/ecdsa/ecdsa.h b/lib/libcrypto/ecdsa/ecdsa.h
index ad716c24a55..530ab265bb3 100644
--- a/lib/libcrypto/ecdsa/ecdsa.h
+++ b/lib/libcrypto/ecdsa/ecdsa.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecdsa.h,v 1.3 2014/11/17 20:25:50 miod Exp $ */
+/* $OpenBSD: ecdsa.h,v 1.4 2015/02/08 13:35:06 jsing Exp $ */
 /**
  * \file   crypto/ecdsa/ecdsa.h Include file for the OpenSSL ECDSA functions
  * \author Written by Nils Larsch for the OpenSSL project
@@ -11,7 +11,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
@@ -79,11 +79,11 @@ typedef struct ECDSA_SIG_st ECDSA_SIG;
 
 struct ecdsa_method {
 	const char *name;
-	ECDSA_SIG *(*ecdsa_do_sign)(const unsigned char *dgst, int dgst_len, 
+	ECDSA_SIG *(*ecdsa_do_sign)(const unsigned char *dgst, int dgst_len,
 	    const BIGNUM *inv, const BIGNUM *rp, EC_KEY *eckey);
-	int (*ecdsa_sign_setup)(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv, 
+	int (*ecdsa_sign_setup)(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
 	    BIGNUM **r);
-	int (*ecdsa_do_verify)(const unsigned char *dgst, int dgst_len, 
+	int (*ecdsa_do_verify)(const unsigned char *dgst, int dgst_len,
 	    const ECDSA_SIG *sig, EC_KEY *eckey);
 #if 0
 	int (*init)(EC_KEY *eckey);
@@ -114,18 +114,18 @@ ECDSA_SIG *ECDSA_SIG_new(void);
 /** frees a ECDSA_SIG structure
  *  \param  sig  pointer to the ECDSA_SIG structure
  */
-void	  ECDSA_SIG_free(ECDSA_SIG *sig);
+void ECDSA_SIG_free(ECDSA_SIG *sig);
 
 /** DER encode content of ECDSA_SIG object (note: this function modifies *pp
  *  (*pp += length of the DER encoded signature)).
  *  \param  sig  pointer to the ECDSA_SIG object
  *  \param  pp   pointer to a unsigned char pointer for the output or NULL
- *  \return the length of the DER encoded ECDSA_SIG object or 0 
+ *  \return the length of the DER encoded ECDSA_SIG object or 0
  */
-int	  i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp);
+int i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp);
 
 /** Decodes a DER encoded ECDSA signature (note: this function changes *pp
- *  (*pp += len)). 
+ *  (*pp += len)).
  *  \param  sig  pointer to ECDSA_SIG pointer (may be NULL)
  *  \param  pp   memory buffer with the DER encoded signature
  *  \param  len  length of the buffer
@@ -140,20 +140,21 @@ ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp, long len);
  *  \param  eckey     EC_KEY object containing a private EC key
  *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
  */
-ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst,int dgst_len,EC_KEY *eckey);
+ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len,
+    EC_KEY *eckey);
 
 /** Computes ECDSA signature of a given hash value using the supplied
  *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
  *  \param  dgst     pointer to the hash value to sign
  *  \param  dgstlen  length of the hash value
  *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
- *  \param  rp       BIGNUM with a pre-computed rp value (optioanl), 
+ *  \param  rp       BIGNUM with a pre-computed rp value (optioanl),
  *                   see ECDSA_sign_setup
  *  \param  eckey    EC_KEY object containing a private EC key
  *  \return pointer to a ECDSA_SIG structure or NULL if an error occurred
  */
-ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen, 
-		const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey);
+ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen,
+    const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey);
 
 /** Verifies that the supplied signature is a valid ECDSA
  *  signature of the supplied hash value using the supplied public key.
@@ -164,15 +165,15 @@ ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen,
  *  \return 1 if the signature is valid, 0 if the signature is invalid
  *          and -1 on error
  */
-int	  ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
-		const ECDSA_SIG *sig, EC_KEY* eckey);
+int ECDSA_do_verify(const unsigned char *dgst, int dgst_len,
+    const ECDSA_SIG *sig, EC_KEY* eckey);
 
 const ECDSA_METHOD *ECDSA_OpenSSL(void);
 
 /** Sets the default ECDSA method
  *  \param  meth  new default ECDSA_METHOD
  */
-void	  ECDSA_set_default_method(const ECDSA_METHOD *meth);
+void ECDSA_set_default_method(const ECDSA_METHOD *meth);
 
 /** Returns the default ECDSA method
  *  \return pointer to ECDSA_METHOD structure containing the default method
@@ -182,15 +183,15 @@ const ECDSA_METHOD *ECDSA_get_default_method(void);
 /** Sets method to be used for the ECDSA operations
  *  \param  eckey  EC_KEY object
  *  \param  meth   new method
- *  \return 1 on success and 0 otherwise 
+ *  \return 1 on success and 0 otherwise
  */
-int 	  ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth);
+int ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth);
 
 /** Returns the maximum length of the DER encoded signature
  *  \param  eckey  EC_KEY object
  *  \return numbers of bytes required for the DER encoded signature
  */
-int	  ECDSA_size(const EC_KEY *eckey);
+int ECDSA_size(const EC_KEY *eckey);
 
 /** Precompute parts of the signing operation
  *  \param  eckey  EC_KEY object containing a private EC key
@@ -199,8 +200,8 @@ int	  ECDSA_size(const EC_KEY *eckey);
  *  \param  rp     BIGNUM pointer for x coordinate of k * generator
  *  \return 1 on success and 0 otherwise
  */
-int 	  ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv, 
-		BIGNUM **rp);
+int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
+    BIGNUM **rp);
 
 /** Computes ECDSA signature of a given hash value using the supplied
  *  private key (note: sig must point to ECDSA_size(eckey) bytes of memory).
@@ -212,8 +213,8 @@ int 	  ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv,
  *  \param  eckey    EC_KEY object containing a private EC key
  *  \return 1 on success and 0 otherwise
  */
-int	  ECDSA_sign(int type, const unsigned char *dgst, int dgstlen, 
-		unsigned char *sig, unsigned int *siglen, EC_KEY *eckey);
+int ECDSA_sign(int type, const unsigned char *dgst, int dgstlen,
+    unsigned char *sig, unsigned int *siglen, EC_KEY *eckey);
 
 
 /** Computes ECDSA signature of a given hash value using the supplied
@@ -224,19 +225,19 @@ int	  ECDSA_sign(int type, const unsigned char *dgst, int dgstlen,
  *  \param  sig      buffer to hold the DER encoded signature
  *  \param  siglen   pointer to the length of the returned signature
  *  \param  kinv     BIGNUM with a pre-computed inverse k (optional)
- *  \param  rp       BIGNUM with a pre-computed rp value (optioanl), 
+ *  \param  rp       BIGNUM with a pre-computed rp value (optioanl),
  *                   see ECDSA_sign_setup
  *  \param  eckey    EC_KEY object containing a private EC key
  *  \return 1 on success and 0 otherwise
  */
-int	  ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen, 
-		unsigned char *sig, unsigned int *siglen, const BIGNUM *kinv,
-		const BIGNUM *rp, EC_KEY *eckey);
+int ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen,
+    unsigned char *sig, unsigned int *siglen, const BIGNUM *kinv,
+    const BIGNUM *rp, EC_KEY *eckey);
 
 /** Verifies that the given signature is valid ECDSA signature
  *  of the supplied hash value using the specified public key.
  *  \param  type     this parameter is ignored
- *  \param  dgst     pointer to the hash value 
+ *  \param  dgst     pointer to the hash value
  *  \param  dgstlen  length of the hash value
  *  \param  sig      pointer to the DER encoded signature
  *  \param  siglen   length of the DER encoded signature
@@ -244,14 +245,14 @@ int	  ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen,
  *  \return 1 if the signature is valid, 0 if the signature is invalid
  *          and -1 on error
  */
-int 	  ECDSA_verify(int type, const unsigned char *dgst, int dgstlen, 
-		const unsigned char *sig, int siglen, EC_KEY *eckey);
+int ECDSA_verify(int type, const unsigned char *dgst, int dgstlen,
+    const unsigned char *sig, int siglen, EC_KEY *eckey);
 
 /* the standard ex_data functions */
-int 	  ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new 
-		*new_func, CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
-int 	  ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg);
-void 	  *ECDSA_get_ex_data(EC_KEY *d, int idx);
+int ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
+    CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
+int ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg);
+void *ECDSA_get_ex_data(EC_KEY *d, int idx);
 
 
 /* BEGIN ERROR CODES */
diff --git a/lib/libcrypto/ecdsa/ecs_asn1.c b/lib/libcrypto/ecdsa/ecs_asn1.c
index 351c1e9ba55..f62df3a8170 100644
--- a/lib/libcrypto/ecdsa/ecs_asn1.c
+++ b/lib/libcrypto/ecdsa/ecs_asn1.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecs_asn1.c,v 1.2 2014/06/12 15:49:29 deraadt Exp $ */
+/* $OpenBSD: ecs_asn1.c,v 1.3 2015/02/08 13:35:07 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 2000-2002 The OpenSSL Project.  All rights reserved.
  *
@@ -7,7 +7,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
diff --git a/lib/libcrypto/ecdsa/ecs_err.c b/lib/libcrypto/ecdsa/ecs_err.c
index 721b53c3f4b..26efc135e34 100644
--- a/lib/libcrypto/ecdsa/ecs_err.c
+++ b/lib/libcrypto/ecdsa/ecs_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecs_err.c,v 1.3 2014/07/10 22:45:57 jsing Exp $ */
+/* $OpenBSD: ecs_err.c,v 1.4 2015/02/08 13:35:07 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
  *
@@ -7,7 +7,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
@@ -71,39 +71,36 @@
 #define ERR_FUNC(func) ERR_PACK(ERR_LIB_ECDSA,func,0)
 #define ERR_REASON(reason) ERR_PACK(ERR_LIB_ECDSA,0,reason)
 
-static ERR_STRING_DATA ECDSA_str_functs[]=
-	{
-{ERR_FUNC(ECDSA_F_ECDSA_CHECK),	"ECDSA_CHECK"},
-{ERR_FUNC(ECDSA_F_ECDSA_DATA_NEW_METHOD),	"ECDSA_DATA_NEW_METHOD"},
-{ERR_FUNC(ECDSA_F_ECDSA_DO_SIGN),	"ECDSA_do_sign"},
-{ERR_FUNC(ECDSA_F_ECDSA_DO_VERIFY),	"ECDSA_do_verify"},
-{ERR_FUNC(ECDSA_F_ECDSA_SIGN_SETUP),	"ECDSA_sign_setup"},
-{0,NULL}
-	};
+static ERR_STRING_DATA ECDSA_str_functs[]= {
+	{ERR_FUNC(ECDSA_F_ECDSA_CHECK),	"ECDSA_CHECK"},
+	{ERR_FUNC(ECDSA_F_ECDSA_DATA_NEW_METHOD),	"ECDSA_DATA_NEW_METHOD"},
+	{ERR_FUNC(ECDSA_F_ECDSA_DO_SIGN),	"ECDSA_do_sign"},
+	{ERR_FUNC(ECDSA_F_ECDSA_DO_VERIFY),	"ECDSA_do_verify"},
+	{ERR_FUNC(ECDSA_F_ECDSA_SIGN_SETUP),	"ECDSA_sign_setup"},
+	{0, NULL}
+};
 
-static ERR_STRING_DATA ECDSA_str_reasons[]=
-	{
-{ERR_REASON(ECDSA_R_BAD_SIGNATURE)       ,"bad signature"},
-{ERR_REASON(ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE),"data too large for key size"},
-{ERR_REASON(ECDSA_R_ERR_EC_LIB)          ,"err ec lib"},
-{ERR_REASON(ECDSA_R_MISSING_PARAMETERS)  ,"missing parameters"},
-{ERR_REASON(ECDSA_R_NEED_NEW_SETUP_VALUES),"need new setup values"},
-{ERR_REASON(ECDSA_R_NON_FIPS_METHOD)     ,"non fips method"},
-{ERR_REASON(ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED),"random number generation failed"},
-{ERR_REASON(ECDSA_R_SIGNATURE_MALLOC_FAILED),"signature malloc failed"},
-{0,NULL}
-	};
+static ERR_STRING_DATA ECDSA_str_reasons[]= {
+	{ERR_REASON(ECDSA_R_BAD_SIGNATURE)       , "bad signature"},
+	{ERR_REASON(ECDSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE), "data too large for key size"},
+	{ERR_REASON(ECDSA_R_ERR_EC_LIB)          , "err ec lib"},
+	{ERR_REASON(ECDSA_R_MISSING_PARAMETERS)  , "missing parameters"},
+	{ERR_REASON(ECDSA_R_NEED_NEW_SETUP_VALUES), "need new setup values"},
+	{ERR_REASON(ECDSA_R_NON_FIPS_METHOD)     , "non fips method"},
+	{ERR_REASON(ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED), "random number generation failed"},
+	{ERR_REASON(ECDSA_R_SIGNATURE_MALLOC_FAILED), "signature malloc failed"},
+	{0, NULL}
+};
 
 #endif
 
-void ERR_load_ECDSA_strings(void)
-	{
+void
+ERR_load_ECDSA_strings(void)
+{
 #ifndef OPENSSL_NO_ERR
-
-	if (ERR_func_error_string(ECDSA_str_functs[0].error) == NULL)
-		{
-		ERR_load_strings(0,ECDSA_str_functs);
-		ERR_load_strings(0,ECDSA_str_reasons);
-		}
-#endif
+	if (ERR_func_error_string(ECDSA_str_functs[0].error) == NULL) {
+		ERR_load_strings(0, ECDSA_str_functs);
+		ERR_load_strings(0, ECDSA_str_reasons);
 	}
+#endif
+}
diff --git a/lib/libcrypto/ecdsa/ecs_lib.c b/lib/libcrypto/ecdsa/ecs_lib.c
index 6cdf4c124b0..dba888cb48a 100644
--- a/lib/libcrypto/ecdsa/ecs_lib.c
+++ b/lib/libcrypto/ecdsa/ecs_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecs_lib.c,v 1.8 2015/02/07 13:19:15 doug Exp $ */
+/* $OpenBSD: ecs_lib.c,v 1.9 2015/02/08 13:35:07 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
  *
@@ -7,7 +7,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
@@ -70,21 +70,23 @@ static void *ecdsa_data_new(void);
 static void *ecdsa_data_dup(void *);
 static void  ecdsa_data_free(void *);
 
-void ECDSA_set_default_method(const ECDSA_METHOD *meth)
+void
+ECDSA_set_default_method(const ECDSA_METHOD *meth)
 {
 	default_ECDSA_method = meth;
 }
 
-const ECDSA_METHOD *ECDSA_get_default_method(void)
+const ECDSA_METHOD *
+ECDSA_get_default_method(void)
 {
-	if(!default_ECDSA_method) 
-		{
+	if (!default_ECDSA_method) {
 		default_ECDSA_method = ECDSA_OpenSSL();
-		}
+	}
 	return default_ECDSA_method;
 }
 
-int ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth)
+int
+ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth)
 {
 	ECDSA_DATA *ecdsa;
 
@@ -94,26 +96,25 @@ int ECDSA_set_method(EC_KEY *eckey, const ECDSA_METHOD *meth)
 		return 0;
 
 #ifndef OPENSSL_NO_ENGINE
-	if (ecdsa->engine)
-	{
+	if (ecdsa->engine) {
 		ENGINE_finish(ecdsa->engine);
 		ecdsa->engine = NULL;
 	}
 #endif
-        ecdsa->meth = meth;
+	ecdsa->meth = meth;
 
-        return 1;
+	return 1;
 }
 
-static ECDSA_DATA *ECDSA_DATA_new_method(ENGINE *engine)
+static ECDSA_DATA *
+ECDSA_DATA_new_method(ENGINE *engine)
 {
 	ECDSA_DATA *ret;
 
 	ret = malloc(sizeof(ECDSA_DATA));
-	if (ret == NULL)
-	{
+	if (ret == NULL) {
 		ECDSAerr(ECDSA_F_ECDSA_DATA_NEW_METHOD, ERR_R_MALLOC_FAILURE);
-		return(NULL);
+		return (NULL);
 	}
 
 	ret->init = NULL;
@@ -123,12 +124,11 @@ static ECDSA_DATA *ECDSA_DATA_new_method(ENGINE *engine)
 #ifndef OPENSSL_NO_ENGINE
 	if (!ret->engine)
 		ret->engine = ENGINE_get_default_ECDSA();
-	if (ret->engine)
-	{
+	if (ret->engine) {
 		ret->meth = ENGINE_get_ECDSA(ret->engine);
-		if (!ret->meth)
-		{
-			ECDSAerr(ECDSA_F_ECDSA_DATA_NEW_METHOD, ERR_R_ENGINE_LIB);
+		if (!ret->meth) {
+			ECDSAerr(ECDSA_F_ECDSA_DATA_NEW_METHOD,
+			    ERR_R_ENGINE_LIB);
 			ENGINE_finish(ret->engine);
 			free(ret);
 			return NULL;
@@ -138,15 +138,17 @@ static ECDSA_DATA *ECDSA_DATA_new_method(ENGINE *engine)
 
 	ret->flags = ret->meth->flags;
 	CRYPTO_new_ex_data(CRYPTO_EX_INDEX_ECDSA, ret, &ret->ex_data);
-	return(ret);
+	return (ret);
 }
 
-static void *ecdsa_data_new(void)
+static void *
+ecdsa_data_new(void)
 {
 	return (void *)ECDSA_DATA_new_method(NULL);
 }
 
-static void *ecdsa_data_dup(void *data)
+static void *
+ecdsa_data_dup(void *data)
 {
 	ECDSA_DATA *r = (ECDSA_DATA *)data;
 
@@ -157,7 +159,8 @@ static void *ecdsa_data_dup(void *data)
 	return ecdsa_data_new();
 }
 
-static void ecdsa_data_free(void *data)
+static void
+ecdsa_data_free(void *data)
 {
 	ECDSA_DATA *r = (ECDSA_DATA *)data;
 
@@ -172,38 +175,37 @@ static void ecdsa_data_free(void *data)
 	free(r);
 }
 
-ECDSA_DATA *ecdsa_check(EC_KEY *key)
+ECDSA_DATA *
+ecdsa_check(EC_KEY *key)
 {
 	ECDSA_DATA *ecdsa_data;
- 
+
 	void *data = EC_KEY_get_key_method_data(key, ecdsa_data_dup,
-					ecdsa_data_free, ecdsa_data_free);
-	if (data == NULL)
-	{
+	    ecdsa_data_free, ecdsa_data_free);
+	if (data == NULL) {
 		ecdsa_data = (ECDSA_DATA *)ecdsa_data_new();
 		if (ecdsa_data == NULL)
 			return NULL;
 		data = EC_KEY_insert_key_method_data(key, (void *)ecdsa_data,
-			   ecdsa_data_dup, ecdsa_data_free, ecdsa_data_free);
-		if (data != NULL)
-			{
+		    ecdsa_data_dup, ecdsa_data_free, ecdsa_data_free);
+		if (data != NULL) {
 			/* Another thread raced us to install the key_method
 			 * data and won. */
 			ecdsa_data_free(ecdsa_data);
 			ecdsa_data = (ECDSA_DATA *)data;
-			}
-	}
-	else
+		}
+	} else
 		ecdsa_data = (ECDSA_DATA *)data;
 
 	return ecdsa_data;
 }
 
-int ECDSA_size(const EC_KEY *r)
+int
+ECDSA_size(const EC_KEY *r)
 {
-	int ret,i;
+	int ret, i;
 	ASN1_INTEGER bs;
-	BIGNUM	*order=NULL;
+	BIGNUM	*order = NULL;
 	unsigned char buf[4];
 	const EC_GROUP *group;
 
@@ -213,48 +215,50 @@ int ECDSA_size(const EC_KEY *r)
 	if (group == NULL)
 		return 0;
 
-	if ((order = BN_new()) == NULL) return 0;
-	if (!EC_GROUP_get_order(group,order,NULL))
-	{
+	if ((order = BN_new()) == NULL)
+		return 0;
+	if (!EC_GROUP_get_order(group, order, NULL)) {
 		BN_clear_free(order);
 		return 0;
-	} 
-	i=BN_num_bits(order);
-	bs.length=(i+7)/8;
-	bs.data=buf;
-	bs.type=V_ASN1_INTEGER;
+	}
+	i = BN_num_bits(order);
+	bs.length = (i + 7) / 8;
+	bs.data = buf;
+	bs.type = V_ASN1_INTEGER;
 	/* If the top bit is set the asn1 encoding is 1 larger. */
-	buf[0]=0xff;	
+	buf[0] = 0xff;
 
-	i=i2d_ASN1_INTEGER(&bs,NULL);
-	i+=i; /* r and s */
-	ret=ASN1_object_size(1,i,V_ASN1_SEQUENCE);
+	i = i2d_ASN1_INTEGER(&bs, NULL);
+	i += i; /* r and s */
+	ret = ASN1_object_size(1, i, V_ASN1_SEQUENCE);
 	BN_clear_free(order);
-	return(ret);
+	return (ret);
 }
 
-
-int ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
-	     CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
+int
+ECDSA_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
+    CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
 {
 	return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ECDSA, argl, argp,
-				new_func, dup_func, free_func);
+	    new_func, dup_func, free_func);
 }
 
-int ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg)
+int
+ECDSA_set_ex_data(EC_KEY *d, int idx, void *arg)
 {
 	ECDSA_DATA *ecdsa;
 	ecdsa = ecdsa_check(d);
 	if (ecdsa == NULL)
 		return 0;
-	return(CRYPTO_set_ex_data(&ecdsa->ex_data,idx,arg));
+	return (CRYPTO_set_ex_data(&ecdsa->ex_data, idx, arg));
 }
 
-void *ECDSA_get_ex_data(EC_KEY *d, int idx)
+void *
+ECDSA_get_ex_data(EC_KEY *d, int idx)
 {
 	ECDSA_DATA *ecdsa;
 	ecdsa = ecdsa_check(d);
 	if (ecdsa == NULL)
 		return NULL;
-	return(CRYPTO_get_ex_data(&ecdsa->ex_data,idx));
+	return (CRYPTO_get_ex_data(&ecdsa->ex_data, idx));
 }
diff --git a/lib/libcrypto/ecdsa/ecs_locl.h b/lib/libcrypto/ecdsa/ecs_locl.h
index e47f6794ac7..24d866ae646 100644
--- a/lib/libcrypto/ecdsa/ecs_locl.h
+++ b/lib/libcrypto/ecdsa/ecs_locl.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecs_locl.h,v 1.3 2014/11/17 20:25:50 miod Exp $ */
+/* $OpenBSD: ecs_locl.h,v 1.4 2015/02/08 13:35:07 jsing Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project
  */
@@ -10,7 +10,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
diff --git a/lib/libcrypto/ecdsa/ecs_ossl.c b/lib/libcrypto/ecdsa/ecs_ossl.c
index 0dde5386ffa..31102138c0a 100644
--- a/lib/libcrypto/ecdsa/ecs_ossl.c
+++ b/lib/libcrypto/ecdsa/ecs_ossl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecs_ossl.c,v 1.5 2014/07/12 16:03:37 miod Exp $ */
+/* $OpenBSD: ecs_ossl.c,v 1.6 2015/02/08 13:35:07 jsing Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project
  */
@@ -10,7 +10,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
@@ -63,12 +63,12 @@
 #include <openssl/obj_mac.h>
 #include <openssl/bn.h>
 
-static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dlen, 
-		const BIGNUM *, const BIGNUM *, EC_KEY *eckey);
-static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp, 
-		BIGNUM **rp);
-static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len, 
-		const ECDSA_SIG *sig, EC_KEY *eckey);
+static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dlen,
+    const BIGNUM *, const BIGNUM *, EC_KEY *eckey);
+static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,
+    BIGNUM **rp);
+static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len,
+    const ECDSA_SIG *sig, EC_KEY *eckey);
 
 static ECDSA_METHOD openssl_ecdsa_meth = {
 	.name = "OpenSSL ECDSA method",
@@ -77,65 +77,58 @@ static ECDSA_METHOD openssl_ecdsa_meth = {
 	.ecdsa_do_verify = ecdsa_do_verify
 };
 
-const ECDSA_METHOD *ECDSA_OpenSSL(void)
+const ECDSA_METHOD *
+ECDSA_OpenSSL(void)
 {
 	return &openssl_ecdsa_meth;
 }
 
-static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,
-		BIGNUM **rp)
+static int
+ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)
 {
 	BN_CTX   *ctx = NULL;
 	BIGNUM	 *k = NULL, *r = NULL, *order = NULL, *X = NULL;
-	EC_POINT *tmp_point=NULL;
+	EC_POINT *tmp_point = NULL;
 	const EC_GROUP *group;
 	int 	 ret = 0;
 
-	if (eckey == NULL || (group = EC_KEY_get0_group(eckey)) == NULL)
-	{
+	if (eckey == NULL || (group = EC_KEY_get0_group(eckey)) == NULL) {
 		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_PASSED_NULL_PARAMETER);
 		return 0;
 	}
 
-	if (ctx_in == NULL) 
-	{
-		if ((ctx = BN_CTX_new()) == NULL)
-		{
-			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_MALLOC_FAILURE);
+	if (ctx_in == NULL) {
+		if ((ctx = BN_CTX_new()) == NULL) {
+			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,
+			    ERR_R_MALLOC_FAILURE);
 			return 0;
 		}
-	}
-	else
+	} else
 		ctx = ctx_in;
 
-	k     = BN_new();	/* this value is later returned in *kinvp */
-	r     = BN_new();	/* this value is later returned in *rp    */
+	k = BN_new();	/* this value is later returned in *kinvp */
+	r = BN_new();	/* this value is later returned in *rp    */
 	order = BN_new();
-	X     = BN_new();
-	if (!k || !r || !order || !X)
-	{
+	X = BN_new();
+	if (!k || !r || !order || !X) {
 		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_MALLOC_FAILURE);
 		goto err;
 	}
-	if ((tmp_point = EC_POINT_new(group)) == NULL)
-	{
+	if ((tmp_point = EC_POINT_new(group)) == NULL) {
 		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
 		goto err;
 	}
-	if (!EC_GROUP_get_order(group, order, ctx))
-	{
+	if (!EC_GROUP_get_order(group, order, ctx)) {
 		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
 		goto err;
 	}
-	
-	do
-	{
-		/* get random k */	
+
+	do {
+		/* get random k */
 		do
-			if (!BN_rand_range(k, order))
-			{
+			if (!BN_rand_range(k, order)) {
 				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,
-				 ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED);	
+				    ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED);
 				goto err;
 			}
 		while (BN_is_zero(k));
@@ -143,23 +136,23 @@ static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,
 		/* We do not want timing information to leak the length of k,
 		 * so we compute G*k using an equivalent scalar of fixed
 		 * bit-length. */
-
-		if (!BN_add(k, k, order)) goto err;
+		if (!BN_add(k, k, order))
+			goto err;
 		if (BN_num_bits(k) <= BN_num_bits(order))
-			if (!BN_add(k, k, order)) goto err;
+			if (!BN_add(k, k, order))
+				goto err;
 
 		/* compute r the x-coordinate of generator * k */
-		if (!EC_POINT_mul(group, tmp_point, k, NULL, NULL, ctx))
-		{
+		if (!EC_POINT_mul(group, tmp_point, k, NULL, NULL, ctx)) {
 			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_EC_LIB);
 			goto err;
 		}
-		if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field)
-		{
+		if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) ==
+		    NID_X9_62_prime_field) {
 			if (!EC_POINT_get_affine_coordinates_GFp(group,
-				tmp_point, X, NULL, ctx))
-			{
-				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_EC_LIB);
+			    tmp_point, X, NULL, ctx)) {
+				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,
+				    ERR_R_EC_LIB);
 				goto err;
 			}
 		}
@@ -167,53 +160,52 @@ static int ecdsa_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp,
 		else /* NID_X9_62_characteristic_two_field */
 		{
 			if (!EC_POINT_get_affine_coordinates_GF2m(group,
-				tmp_point, X, NULL, ctx))
-			{
-				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,ERR_R_EC_LIB);
+			    tmp_point, X, NULL, ctx)) {
+				ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP,
+				    ERR_R_EC_LIB);
 				goto err;
 			}
 		}
 #endif
-		if (!BN_nnmod(r, X, order, ctx))
-		{
+		if (!BN_nnmod(r, X, order, ctx)) {
 			ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
 			goto err;
 		}
-	}
-	while (BN_is_zero(r));
+	} while (BN_is_zero(r));
 
 	/* compute the inverse of k */
-	if (!BN_mod_inverse(k, k, order, ctx))
-	{
+	if (!BN_mod_inverse(k, k, order, ctx)) {
 		ECDSAerr(ECDSA_F_ECDSA_SIGN_SETUP, ERR_R_BN_LIB);
-		goto err;	
+		goto err;
 	}
 	/* clear old values if necessary */
 	BN_clear_free(*rp);
 	BN_clear_free(*kinvp);
 	/* save the pre-computed values  */
-	*rp    = r;
+	*rp = r;
 	*kinvp = k;
 	ret = 1;
+
 err:
 	if (!ret) {
 		BN_clear_free(k);
 		BN_clear_free(r);
 	}
-	if (ctx_in == NULL) 
+	if (ctx_in == NULL)
 		BN_CTX_free(ctx);
 	BN_free(order);
 	EC_POINT_free(tmp_point);
 	BN_clear_free(X);
-	return(ret);
+	return (ret);
 }
 
 
-static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dgst_len, 
-		const BIGNUM *in_kinv, const BIGNUM *in_r, EC_KEY *eckey)
+static ECDSA_SIG *
+ecdsa_do_sign(const unsigned char *dgst, int dgst_len,
+    const BIGNUM *in_kinv, const BIGNUM *in_r, EC_KEY *eckey)
 {
 	int     ok = 0, i;
-	BIGNUM *kinv=NULL, *s, *m=NULL,*tmp=NULL,*order=NULL;
+	BIGNUM *kinv = NULL, *s, *m = NULL, *tmp = NULL, *order = NULL;
 	const BIGNUM *ckinv;
 	BN_CTX     *ctx = NULL;
 	const EC_GROUP   *group;
@@ -221,33 +213,29 @@ static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dgst_len,
 	ECDSA_DATA *ecdsa;
 	const BIGNUM *priv_key;
 
-	ecdsa    = ecdsa_check(eckey);
-	group    = EC_KEY_get0_group(eckey);
+	ecdsa = ecdsa_check(eckey);
+	group = EC_KEY_get0_group(eckey);
 	priv_key = EC_KEY_get0_private_key(eckey);
-	
-	if (group == NULL || priv_key == NULL || ecdsa == NULL)
-	{
+
+	if (group == NULL || priv_key == NULL || ecdsa == NULL) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_PASSED_NULL_PARAMETER);
 		return NULL;
 	}
 
 	ret = ECDSA_SIG_new();
-	if (!ret)
-	{
+	if (!ret) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_MALLOC_FAILURE);
 		return NULL;
 	}
 	s = ret->s;
 
 	if ((ctx = BN_CTX_new()) == NULL || (order = BN_new()) == NULL ||
-		(tmp = BN_new()) == NULL || (m = BN_new()) == NULL)
-	{
+	    (tmp = BN_new()) == NULL || (m = BN_new()) == NULL) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_MALLOC_FAILURE);
 		goto err;
 	}
 
-	if (!EC_GROUP_get_order(group, order, ctx))
-	{
+	if (!EC_GROUP_get_order(group, order, ctx)) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_EC_LIB);
 		goto err;
 	}
@@ -257,73 +245,61 @@ static ECDSA_SIG *ecdsa_do_sign(const unsigned char *dgst, int dgst_len,
 	 */
 	if (8 * dgst_len > i)
 		dgst_len = (i + 7)/8;
-	if (!BN_bin2bn(dgst, dgst_len, m))
-	{
+	if (!BN_bin2bn(dgst, dgst_len, m)) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
 		goto err;
 	}
 	/* If still too long truncate remaining bits with a shift */
-	if ((8 * dgst_len > i) && !BN_rshift(m, m, 8 - (i & 0x7)))
-	{
+	if ((8 * dgst_len > i) && !BN_rshift(m, m, 8 - (i & 0x7))) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
 		goto err;
 	}
-	do
-	{
-		if (in_kinv == NULL || in_r == NULL)
-		{
-			if (!ECDSA_sign_setup(eckey, ctx, &kinv, &ret->r))
-			{
-				ECDSAerr(ECDSA_F_ECDSA_DO_SIGN,ERR_R_ECDSA_LIB);
+	do {
+		if (in_kinv == NULL || in_r == NULL) {
+			if (!ECDSA_sign_setup(eckey, ctx, &kinv, &ret->r)) {
+				ECDSAerr(ECDSA_F_ECDSA_DO_SIGN,
+				    ERR_R_ECDSA_LIB);
 				goto err;
 			}
 			ckinv = kinv;
-		}
-		else
-		{
-			ckinv  = in_kinv;
-			if (BN_copy(ret->r, in_r) == NULL)
-			{
-				ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_MALLOC_FAILURE);
+		} else {
+			ckinv = in_kinv;
+			if (BN_copy(ret->r, in_r) == NULL) {
+				ECDSAerr(ECDSA_F_ECDSA_DO_SIGN,
+				    ERR_R_MALLOC_FAILURE);
 				goto err;
 			}
 		}
 
-		if (!BN_mod_mul(tmp, priv_key, ret->r, order, ctx))
-		{
+		if (!BN_mod_mul(tmp, priv_key, ret->r, order, ctx)) {
 			ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
 			goto err;
 		}
-		if (!BN_mod_add_quick(s, tmp, m, order))
-		{
+		if (!BN_mod_add_quick(s, tmp, m, order)) {
 			ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
 			goto err;
 		}
-		if (!BN_mod_mul(s, s, ckinv, order, ctx))
-		{
+		if (!BN_mod_mul(s, s, ckinv, order, ctx)) {
 			ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ERR_R_BN_LIB);
 			goto err;
 		}
-		if (BN_is_zero(s))
-		{
+		if (BN_is_zero(s)) {
 			/* if kinv and r have been supplied by the caller
 			 * don't to generate new kinv and r values */
-			if (in_kinv != NULL && in_r != NULL)
-			{
-				ECDSAerr(ECDSA_F_ECDSA_DO_SIGN, ECDSA_R_NEED_NEW_SETUP_VALUES);
+			if (in_kinv != NULL && in_r != NULL) {
+				ECDSAerr(ECDSA_F_ECDSA_DO_SIGN,
+				    ECDSA_R_NEED_NEW_SETUP_VALUES);
 				goto err;
 			}
-		}
-		else
+		} else
 			/* s != 0 => we have a valid signature */
 			break;
-	}
-	while (1);
+	} while (1);
 
 	ok = 1;
+
 err:
-	if (!ok)
-	{
+	if (!ok) {
 		ECDSA_SIG_free(ret);
 		ret = NULL;
 	}
@@ -335,8 +311,9 @@ err:
 	return ret;
 }
 
-static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len,
-		const ECDSA_SIG *sig, EC_KEY *eckey)
+static int
+ecdsa_do_verify(const unsigned char *dgst, int dgst_len, const ECDSA_SIG *sig,
+    EC_KEY *eckey)
 {
 	int ret = -1, i;
 	BN_CTX   *ctx;
@@ -347,47 +324,41 @@ static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len,
 
 	/* check input values */
 	if (eckey == NULL || (group = EC_KEY_get0_group(eckey)) == NULL ||
-	    (pub_key = EC_KEY_get0_public_key(eckey)) == NULL || sig == NULL)
-	{
+	    (pub_key = EC_KEY_get0_public_key(eckey)) == NULL || sig == NULL) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_MISSING_PARAMETERS);
 		return -1;
 	}
 
 	ctx = BN_CTX_new();
-	if (!ctx)
-	{
+	if (!ctx) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_MALLOC_FAILURE);
 		return -1;
 	}
 	BN_CTX_start(ctx);
-	order = BN_CTX_get(ctx);	
-	u1    = BN_CTX_get(ctx);
-	u2    = BN_CTX_get(ctx);
-	m     = BN_CTX_get(ctx);
-	X     = BN_CTX_get(ctx);
-	if (!X)
-	{
+	order = BN_CTX_get(ctx);
+	u1 = BN_CTX_get(ctx);
+	u2 = BN_CTX_get(ctx);
+	m = BN_CTX_get(ctx);
+	X = BN_CTX_get(ctx);
+	if (!X) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
 		goto err;
 	}
-	
-	if (!EC_GROUP_get_order(group, order, ctx))
-	{
+
+	if (!EC_GROUP_get_order(group, order, ctx)) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);
 		goto err;
 	}
 
-	if (BN_is_zero(sig->r)          || BN_is_negative(sig->r) || 
+	if (BN_is_zero(sig->r)          || BN_is_negative(sig->r) ||
 	    BN_ucmp(sig->r, order) >= 0 || BN_is_zero(sig->s)  ||
-	    BN_is_negative(sig->s)      || BN_ucmp(sig->s, order) >= 0)
-	{
+	    BN_is_negative(sig->s)      || BN_ucmp(sig->s, order) >= 0) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ECDSA_R_BAD_SIGNATURE);
 		ret = 0;	/* signature is invalid */
 		goto err;
 	}
 	/* calculate tmp1 = inv(S) mod order */
-	if (!BN_mod_inverse(u2, sig->s, order, ctx))
-	{
+	if (!BN_mod_inverse(u2, sig->s, order, ctx)) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
 		goto err;
 	}
@@ -398,45 +369,38 @@ static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len,
 	 */
 	if (8 * dgst_len > i)
 		dgst_len = (i + 7)/8;
-	if (!BN_bin2bn(dgst, dgst_len, m))
-	{
+	if (!BN_bin2bn(dgst, dgst_len, m)) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
 		goto err;
 	}
 	/* If still too long truncate remaining bits with a shift */
-	if ((8 * dgst_len > i) && !BN_rshift(m, m, 8 - (i & 0x7)))
-	{
+	if ((8 * dgst_len > i) && !BN_rshift(m, m, 8 - (i & 0x7))) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
 		goto err;
 	}
 	/* u1 = m * tmp mod order */
-	if (!BN_mod_mul(u1, m, u2, order, ctx))
-	{
+	if (!BN_mod_mul(u1, m, u2, order, ctx)) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
 		goto err;
 	}
 	/* u2 = r * w mod q */
-	if (!BN_mod_mul(u2, sig->r, u2, order, ctx))
-	{
+	if (!BN_mod_mul(u2, sig->r, u2, order, ctx)) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
 		goto err;
 	}
 
-	if ((point = EC_POINT_new(group)) == NULL)
-	{
+	if ((point = EC_POINT_new(group)) == NULL) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_MALLOC_FAILURE);
 		goto err;
 	}
-	if (!EC_POINT_mul(group, point, u1, pub_key, u2, ctx))
-	{
+	if (!EC_POINT_mul(group, point, u1, pub_key, u2, ctx)) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);
 		goto err;
 	}
-	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field)
-	{
+	if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) ==
+	    NID_X9_62_prime_field) {
 		if (!EC_POINT_get_affine_coordinates_GFp(group,
-			point, X, NULL, ctx))
-		{
+		    point, X, NULL, ctx)) {
 			ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);
 			goto err;
 		}
@@ -445,20 +409,19 @@ static int ecdsa_do_verify(const unsigned char *dgst, int dgst_len,
 	else /* NID_X9_62_characteristic_two_field */
 	{
 		if (!EC_POINT_get_affine_coordinates_GF2m(group,
-			point, X, NULL, ctx))
-		{
+		    point, X, NULL, ctx)) {
 			ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_EC_LIB);
 			goto err;
 		}
 	}
-#endif	
-	if (!BN_nnmod(u1, X, order, ctx))
-	{
+#endif
+	if (!BN_nnmod(u1, X, order, ctx)) {
 		ECDSAerr(ECDSA_F_ECDSA_DO_VERIFY, ERR_R_BN_LIB);
 		goto err;
 	}
 	/*  if the signature is correct u1 is equal to sig->r */
 	ret = (BN_ucmp(u1, sig->r) == 0);
+
 err:
 	BN_CTX_end(ctx);
 	BN_CTX_free(ctx);
diff --git a/lib/libcrypto/ecdsa/ecs_sign.c b/lib/libcrypto/ecdsa/ecs_sign.c
index 55bb02d57fa..029a0cb562c 100644
--- a/lib/libcrypto/ecdsa/ecs_sign.c
+++ b/lib/libcrypto/ecdsa/ecs_sign.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecs_sign.c,v 1.5 2014/10/18 17:20:40 jsing Exp $ */
+/* $OpenBSD: ecs_sign.c,v 1.6 2015/02/08 13:35:07 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
  *
@@ -7,7 +7,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
@@ -60,35 +60,39 @@
 #include <openssl/engine.h>
 #endif
 
-ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dlen, EC_KEY *eckey)
+ECDSA_SIG *
+ECDSA_do_sign(const unsigned char *dgst, int dlen, EC_KEY *eckey)
 {
 	return ECDSA_do_sign_ex(dgst, dlen, NULL, NULL, eckey);
 }
 
-ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dlen,
-	const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey)
+ECDSA_SIG *
+ECDSA_do_sign_ex(const unsigned char *dgst, int dlen, const BIGNUM *kinv,
+    const BIGNUM *rp, EC_KEY *eckey)
 {
 	ECDSA_DATA *ecdsa = ecdsa_check(eckey);
+
 	if (ecdsa == NULL)
 		return NULL;
 	return ecdsa->meth->ecdsa_do_sign(dgst, dlen, kinv, rp, eckey);
 }
 
-int ECDSA_sign(int type, const unsigned char *dgst, int dlen, unsigned char 
-		*sig, unsigned int *siglen, EC_KEY *eckey)
+int
+ECDSA_sign(int type, const unsigned char *dgst, int dlen, unsigned char *sig,
+    unsigned int *siglen, EC_KEY *eckey)
 {
 	return ECDSA_sign_ex(type, dgst, dlen, sig, siglen, NULL, NULL, eckey);
 }
 
-int ECDSA_sign_ex(int type, const unsigned char *dgst, int dlen, unsigned char 
-	*sig, unsigned int *siglen, const BIGNUM *kinv, const BIGNUM *r, 
-	EC_KEY *eckey)
+int
+ECDSA_sign_ex(int type, const unsigned char *dgst, int dlen, unsigned char *sig,
+    unsigned int *siglen, const BIGNUM *kinv, const BIGNUM *r, EC_KEY *eckey)
 {
 	ECDSA_SIG *s;
+
 	s = ECDSA_do_sign_ex(dgst, dlen, kinv, r, eckey);
-	if (s == NULL)
-	{
-		*siglen=0;
+	if (s == NULL) {
+		*siglen = 0;
 		return 0;
 	}
 	*siglen = i2d_ECDSA_SIG(s, &sig);
@@ -96,11 +100,12 @@ int ECDSA_sign_ex(int type, const unsigned char *dgst, int dlen, unsigned char
 	return 1;
 }
 
-int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp, 
-		BIGNUM **rp)
+int
+ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)
 {
 	ECDSA_DATA *ecdsa = ecdsa_check(eckey);
+
 	if (ecdsa == NULL)
 		return 0;
-	return ecdsa->meth->ecdsa_sign_setup(eckey, ctx_in, kinvp, rp); 
+	return ecdsa->meth->ecdsa_sign_setup(eckey, ctx_in, kinvp, rp);
 }
diff --git a/lib/libcrypto/ecdsa/ecs_vrf.c b/lib/libcrypto/ecdsa/ecs_vrf.c
index b1e66af80a0..a4b627ace65 100644
--- a/lib/libcrypto/ecdsa/ecs_vrf.c
+++ b/lib/libcrypto/ecdsa/ecs_vrf.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ecs_vrf.c,v 1.4 2015/01/28 04:14:31 beck Exp $ */
+/* $OpenBSD: ecs_vrf.c,v 1.5 2015/02/08 13:35:07 jsing Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project
  */
@@ -10,7 +10,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
@@ -69,42 +69,48 @@
  *      0: incorrect signature
  *     -1: error
  */
-int ECDSA_do_verify(const unsigned char *dgst, int dgst_len, 
-		const ECDSA_SIG *sig, EC_KEY *eckey)
-	{
+int
+ECDSA_do_verify(const unsigned char *dgst, int dgst_len, const ECDSA_SIG *sig,
+    EC_KEY *eckey)
+{
 	ECDSA_DATA *ecdsa = ecdsa_check(eckey);
+
 	if (ecdsa == NULL)
 		return 0;
 	return ecdsa->meth->ecdsa_do_verify(dgst, dgst_len, sig, eckey);
-	}
+}
 
 /* returns
  *      1: correct signature
  *      0: incorrect signature
  *     -1: error
  */
-int ECDSA_verify(int type, const unsigned char *dgst, int dgst_len,
-		const unsigned char *sigbuf, int sig_len, EC_KEY *eckey)
- 	{
+int
+ECDSA_verify(int type, const unsigned char *dgst, int dgst_len,
+    const unsigned char *sigbuf, int sig_len, EC_KEY *eckey)
+{
 	ECDSA_SIG *s;
 	unsigned char *der = NULL;
 	const unsigned char *p = sigbuf;
 	int derlen = -1;
-	int ret=-1;
+	int ret = -1;
 
 	s = ECDSA_SIG_new();
-	if (s == NULL) return(ret);
-	if (d2i_ECDSA_SIG(&s, &p, sig_len) == NULL) goto err;
+	if (s == NULL)
+		return (ret);
+	if (d2i_ECDSA_SIG(&s, &p, sig_len) == NULL)
+		goto err;
 	/* Ensure signature uses DER and doesn't have trailing garbage */
 	derlen = i2d_ECDSA_SIG(s, &der);
 	if (derlen != sig_len || memcmp(sigbuf, der, derlen))
 		goto err;
-	ret=ECDSA_do_verify(dgst, dgst_len, s, eckey);
+	ret = ECDSA_do_verify(dgst, dgst_len, s, eckey);
+
 err:
 	if (derlen > 0) {
 		explicit_bzero(der, derlen);
 		free(der);
 	}
 	ECDSA_SIG_free(s);
-	return(ret);
-	}
+	return (ret);
+}