1 files changed, 64 insertions, 74 deletions

diff --git a/src/regress/lib/libcrypto/ecdsa/ecdsatest.c b/src/regress/lib/libcrypto/ecdsa/ecdsatest.c
index 810fef61bb..a7fcf52bee 100644
--- a/src/regress/lib/libcrypto/ecdsa/ecdsatest.c
+++ b/src/regress/lib/libcrypto/ecdsa/ecdsatest.c
@@ -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
@@ -58,13 +58,13 @@
 /* ====================================================================
  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  *
- * Portions of the attached software ("Contribution") are developed by 
+ * Portions of the attached software ("Contribution") are developed by
  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
  *
  * The Contribution is licensed pursuant to the OpenSSL open source
  * license provided above.
  *
- * The elliptic curve binary polynomial software is originally written by 
+ * The elliptic curve binary polynomial software is originally written by
  * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems Laboratories.
  *
  */
@@ -89,7 +89,7 @@ int test_builtin(BIO *);
 
 /* some tests from the X9.62 draft */
 int x9_62_test_internal(BIO *out, int nid, const char *r_in, const char *s_in)
-        {
+{
         int     ret = 0;
         const char message[] = "abc";
         unsigned char digest[20];
@@ -150,10 +150,10 @@ x962_int_err:
                 BN_free(s);
         EVP_MD_CTX_cleanup(&md_ctx);
         return ret;
-        }
+}
 
 int test_builtin(BIO *out)
-        {
+{
         EC_builtin_curve *curves = NULL;
         size_t          crv_len = 0, n = 0;
         EC_KEY          *eckey = NULL, *wrong_eckey = NULL;
@@ -166,13 +166,12 @@ int test_builtin(BIO *out)
         unsigned char   *raw_buf = NULL;
         unsigned int    sig_len, degree, r_len, s_len, bn_len, buf_len;
         int             nid, ret =  0;
-        
+
         /* fill digest values with some random data */
         arc4random_buf(digest, 20);
         arc4random_buf(wrong_digest, 20);
 
-        /* create and verify a ecdsa signature with every availble curve
-         * (with ) */
+        /* create and verify a ecdsa signature with every available curve */
         BIO_printf(out, "\ntesting ECDSA_sign() and ECDSA_verify() "
                 "with some internal curves:\n");
 
@@ -181,21 +180,18 @@ int test_builtin(BIO *out)
 
         curves = reallocarray(NULL, sizeof(EC_builtin_curve), crv_len);
 
-        if (curves == NULL)
-                {
+        if (curves == NULL) {
                 BIO_printf(out, "malloc error\n");
                 goto builtin_err;
-                }
-        
-        if (!EC_get_builtin_curves(curves, crv_len))
-                {
+        }
+
+        if (!EC_get_builtin_curves(curves, crv_len)) {
                 BIO_printf(out, "unable to get internal curves\n");
                 goto builtin_err;
-                }
+        }
 
         /* now create and verify a signature for every curve */
-        for (n = 0; n < crv_len; n++)
-                {
+        for (n = 0; n < crv_len; n++) {
                 unsigned char dirt, offset;
 
                 nid = curves[n].nid;
@@ -211,20 +207,18 @@ int test_builtin(BIO *out)
                         goto builtin_err;
                 EC_GROUP_free(group);
                 degree = EC_GROUP_get_degree(EC_KEY_get0_group(eckey));
-                if (degree < 160)
-                        /* drop the curve */ 
-                        {
+                if (degree < 160) {
+                        /* drop the curve */
                         EC_KEY_free(eckey);
                         eckey = NULL;
                         continue;
-                        }
+                }
                 BIO_printf(out, "%s: ", OBJ_nid2sn(nid));
                 /* create key */
-                if (!EC_KEY_generate_key(eckey))
-                        {
+                if (!EC_KEY_generate_key(eckey)) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 /* create second key */
                 if ((wrong_eckey = EC_KEY_new()) == NULL)
                         goto builtin_err;
@@ -234,88 +228,83 @@ int test_builtin(BIO *out)
                 if (EC_KEY_set_group(wrong_eckey, group) == 0)
                         goto builtin_err;
                 EC_GROUP_free(group);
-                if (!EC_KEY_generate_key(wrong_eckey))
-                        {
+                if (!EC_KEY_generate_key(wrong_eckey)) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
 
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
                 /* check key */
-                if (!EC_KEY_check_key(eckey))
-                        {
+                if (!EC_KEY_check_key(eckey)) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
                 /* create signature */
                 sig_len = ECDSA_size(eckey);
                 if ((signature = malloc(sig_len)) == NULL)
                         goto builtin_err;
-                if (!ECDSA_sign(0, digest, 20, signature, &sig_len, eckey))
-                        {
+                if (!ECDSA_sign(0, digest, 20, signature, &sig_len, eckey)) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
                 /* verify signature */
-                if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) != 1)
-                        {
+                if (ECDSA_verify(0, digest, 20, signature, sig_len,
+                    eckey) != 1) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
                 /* verify signature with the wrong key */
-                if (ECDSA_verify(0, digest, 20, signature, sig_len, 
-                        wrong_eckey) == 1)
-                        {
+                if (ECDSA_verify(0, digest, 20, signature, sig_len,
+                        wrong_eckey) == 1) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
                 /* wrong digest */
                 if (ECDSA_verify(0, wrong_digest, 20, signature, sig_len,
-                        eckey) == 1)
-                        {
+                    eckey) == 1) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
                 /* wrong length */
                 if (ECDSA_verify(0, digest, 20, signature, sig_len - 1,
-                        eckey) == 1)
-                        {
+                    eckey) == 1) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
 
-                /* Modify a single byte of the signature: to ensure we don't
+                /*
+                 * Modify a single byte of the signature: to ensure we don't
                  * garble the ASN1 structure, we read the raw signature and
-                 * modify a byte in one of the bignums directly. */
+                 * modify a byte in one of the bignums directly.
+                 */
                 sig_ptr = signature;
-                if ((ecdsa_sig = d2i_ECDSA_SIG(NULL, &sig_ptr, sig_len)) == NULL)
-                        {
+                if ((ecdsa_sig = d2i_ECDSA_SIG(NULL, &sig_ptr,
+                    sig_len)) == NULL) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
 
                 /* Store the two BIGNUMs in raw_buf. */
                 r_len = BN_num_bytes(ecdsa_sig->r);
                 s_len = BN_num_bytes(ecdsa_sig->s);
                 bn_len = (degree + 7) / 8;
-                if ((r_len > bn_len) || (s_len > bn_len))
-                        {
+                if ((r_len > bn_len) || (s_len > bn_len)) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 buf_len = 2 * bn_len;
                 if ((raw_buf = calloc(1, buf_len)) == NULL)
                         goto builtin_err;
@@ -328,32 +317,32 @@ int test_builtin(BIO *out)
                 raw_buf[offset] ^= dirt;
                 /* Now read the BIGNUMs back in from raw_buf. */
                 if ((BN_bin2bn(raw_buf, bn_len, ecdsa_sig->r) == NULL) ||
-                        (BN_bin2bn(raw_buf + bn_len, bn_len, ecdsa_sig->s) == NULL))
+                    (BN_bin2bn(raw_buf + bn_len, bn_len, ecdsa_sig->s) == NULL))
                         goto builtin_err;
 
                 sig_ptr2 = signature;
                 sig_len = i2d_ECDSA_SIG(ecdsa_sig, &sig_ptr2);
-                if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) == 1)
-                        {
+                if (ECDSA_verify(0, digest, 20, signature, sig_len,
+                    eckey) == 1) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 /* Sanity check: undo the modification and verify signature. */
                 raw_buf[offset] ^= dirt;
                 if ((BN_bin2bn(raw_buf, bn_len, ecdsa_sig->r) == NULL) ||
-                        (BN_bin2bn(raw_buf + bn_len, bn_len, ecdsa_sig->s) == NULL))
+                    (BN_bin2bn(raw_buf + bn_len, bn_len, ecdsa_sig->s) == NULL))
                         goto builtin_err;
 
                 sig_ptr2 = signature;
                 sig_len = i2d_ECDSA_SIG(ecdsa_sig, &sig_ptr2);
-                if (ECDSA_verify(0, digest, 20, signature, sig_len, eckey) != 1)
-                        {
+                if (ECDSA_verify(0, digest, 20, signature, sig_len,
+                    eckey) != 1) {
                         BIO_printf(out, " failed\n");
                         goto builtin_err;
-                        }
+                }
                 BIO_printf(out, ".");
                 (void)BIO_flush(out);
-                
+
                 BIO_printf(out, " ok\n");
                 /* cleanup */
                 /* clean bogus errors */
@@ -368,9 +357,9 @@ int test_builtin(BIO *out)
                 ecdsa_sig = NULL;
                 free(raw_buf);
                 raw_buf = NULL;
-                }
+        }
 
-        ret = 1;        
+        ret = 1;
 builtin_err:
         if (eckey)
                 EC_KEY_free(eckey);
@@ -383,10 +372,10 @@ builtin_err:
         free(curves);
 
         return ret;
-        }
+}
 
 int main(void)
-        {
+{
         int     ret = 1;
         BIO     *out;
 
@@ -395,13 +384,14 @@ int main(void)
         ERR_load_crypto_strings();
 
         /* the tests */
-        if (!test_builtin(out)) goto err;
-        
+        if (!test_builtin(out))
+                goto err;
+
         ret = 0;
-err:    
-        if (ret)        
+err:
+        if (ret)
                 BIO_printf(out, "\nECDSA test failed\n");
-        else 
+        else
                 BIO_printf(out, "\nECDSA test passed\n");
         if (ret)
                 ERR_print_errors(out);
@@ -412,4 +402,4 @@ err:
         if (out != NULL)
                 BIO_free(out);
         return ret;
-        }       
+}