1 files changed, 114 insertions, 122 deletions

diff --git a/src/lib/libcrypto/dh/dh_key.c b/src/lib/libcrypto/dh/dh_key.c
index d35eb6e740..4fbedd8daa 100644
--- a/src/lib/libcrypto/dh/dh_key.c
+++ b/src/lib/libcrypto/dh/dh_key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: dh_key.c,v 1.18 2014/06/12 15:49:28 deraadt Exp $ */
+/* $OpenBSD: dh_key.c,v 1.19 2014/07/09 13:26:47 miod Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -64,22 +64,22 @@
 
 static int generate_key(DH *dh);
 static int compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh);
-static int dh_bn_mod_exp(const DH *dh, BIGNUM *r,
-                        const BIGNUM *a, const BIGNUM *p,
-                        const BIGNUM *m, BN_CTX *ctx,
-                        BN_MONT_CTX *m_ctx);
+static int dh_bn_mod_exp(const DH *dh, BIGNUM *r, const BIGNUM *a,
+            const BIGNUM *p, const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
 static int dh_init(DH *dh);
 static int dh_finish(DH *dh);
 
-int DH_generate_key(DH *dh)
-        {
+int
+DH_generate_key(DH *dh)
+{
         return dh->meth->generate_key(dh);
-        }
+}
 
-int DH_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
-        {
+int
+DH_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
+{
         return dh->meth->compute_key(key, pub_key, dh);
-        }
+}
 
 static DH_METHOD dh_ossl = {
         .name = "OpenSSL DH Method",
@@ -90,184 +90,176 @@ static DH_METHOD dh_ossl = {
         .finish = dh_finish,
 };
 
-const DH_METHOD *DH_OpenSSL(void)
+const DH_METHOD *
+DH_OpenSSL(void)
 {
         return &dh_ossl;
 }
 
-static int generate_key(DH *dh)
-        {
-        int ok=0;
-        int generate_new_key=0;
+static int
+generate_key(DH *dh)
+{
+        int ok = 0;
+        int generate_new_key = 0;
         unsigned l;
         BN_CTX *ctx;
-        BN_MONT_CTX *mont=NULL;
-        BIGNUM *pub_key=NULL,*priv_key=NULL;
+        BN_MONT_CTX *mont = NULL;
+        BIGNUM *pub_key = NULL, *priv_key = NULL;
 
         ctx = BN_CTX_new();
-        if (ctx == NULL) goto err;
-
-        if (dh->priv_key == NULL)
-                {
-                priv_key=BN_new();
-                if (priv_key == NULL) goto err;
-                generate_new_key=1;
-                }
-        else
-                priv_key=dh->priv_key;
+        if (ctx == NULL)
+                goto err;
 
-        if (dh->pub_key == NULL)
-                {
-                pub_key=BN_new();
-                if (pub_key == NULL) goto err;
-                }
-        else
-                pub_key=dh->pub_key;
+        if (dh->priv_key == NULL) {
+                priv_key = BN_new();
+                if (priv_key == NULL)
+                        goto err;
+                generate_new_key = 1;
+        } else
+                priv_key = dh->priv_key;
 
+        if (dh->pub_key == NULL) {
+                pub_key = BN_new();
+                if (pub_key == NULL)
+                        goto err;
+        } else
+                pub_key = dh->pub_key;
 
-        if (dh->flags & DH_FLAG_CACHE_MONT_P)
-                {
+        if (dh->flags & DH_FLAG_CACHE_MONT_P) {
                 mont = BN_MONT_CTX_set_locked(&dh->method_mont_p,
-                                CRYPTO_LOCK_DH, dh->p, ctx);
+                    CRYPTO_LOCK_DH, dh->p, ctx);
                 if (!mont)
                         goto err;
-                }
+        }
 
-        if (generate_new_key)
-                {
-                if (dh->q)
-                        {
-                        do
-                                {
+        if (generate_new_key) {
+                if (dh->q) {
+                        do {
                                 if (!BN_rand_range(priv_key, dh->q))
                                         goto err;
-                                }
-                        while (BN_is_zero(priv_key) || BN_is_one(priv_key));
-                        }
-                else
-                        {
+                        } while (BN_is_zero(priv_key) || BN_is_one(priv_key));
+                } else {
                         /* secret exponent length */
-                        l = dh->length ? dh->length : BN_num_bits(dh->p)-1;
-                        if (!BN_rand(priv_key, l, 0, 0)) goto err;
-                        }
+                        l = dh->length ? dh->length : BN_num_bits(dh->p) - 1;
+                        if (!BN_rand(priv_key, l, 0, 0))
+                                goto err;
                 }
+        }
 
         {
                 BIGNUM local_prk;
                 BIGNUM *prk;
 
-                if ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) == 0)
-                        {
+                if ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) == 0) {
                         BN_init(&local_prk);
                         prk = &local_prk;
                         BN_with_flags(prk, priv_key, BN_FLG_CONSTTIME);
-                        }
-                else
+                } else
                         prk = priv_key;
 
-                if (!dh->meth->bn_mod_exp(dh, pub_key, dh->g, prk, dh->p, ctx, mont)) goto err;
+                if (!dh->meth->bn_mod_exp(dh, pub_key, dh->g, prk, dh->p, ctx,
+                    mont))
+                        goto err;
         }
                 
-        dh->pub_key=pub_key;
-        dh->priv_key=priv_key;
-        ok=1;
+        dh->pub_key = pub_key;
+        dh->priv_key = priv_key;
+        ok = 1;
 err:
         if (ok != 1)
-                DHerr(DH_F_GENERATE_KEY,ERR_R_BN_LIB);
+                DHerr(DH_F_GENERATE_KEY, ERR_R_BN_LIB);
 
-        if ((pub_key != NULL)  && (dh->pub_key == NULL))  BN_free(pub_key);
-        if ((priv_key != NULL) && (dh->priv_key == NULL)) BN_free(priv_key);
+        if (pub_key != NULL && dh->pub_key == NULL)
+                BN_free(pub_key);
+        if (priv_key != NULL && dh->priv_key == NULL)
+                BN_free(priv_key);
         BN_CTX_free(ctx);
-        return(ok);
-        }
+        return ok;
+}
 
-static int compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
-        {
-        BN_CTX *ctx=NULL;
-        BN_MONT_CTX *mont=NULL;
+static int
+compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
+{
+        BN_CTX *ctx = NULL;
+        BN_MONT_CTX *mont = NULL;
         BIGNUM *tmp;
-        int ret= -1;
+        int ret = -1;
         int check_result;
 
-        if (BN_num_bits(dh->p) > OPENSSL_DH_MAX_MODULUS_BITS)
-                {
-                DHerr(DH_F_COMPUTE_KEY,DH_R_MODULUS_TOO_LARGE);
+        if (BN_num_bits(dh->p) > OPENSSL_DH_MAX_MODULUS_BITS) {
+                DHerr(DH_F_COMPUTE_KEY, DH_R_MODULUS_TOO_LARGE);
                 goto err;
-                }
+        }
 
         ctx = BN_CTX_new();
-        if (ctx == NULL) goto err;
+        if (ctx == NULL)
+                goto err;
         BN_CTX_start(ctx);
         tmp = BN_CTX_get(ctx);
         
-        if (dh->priv_key == NULL)
-                {
-                DHerr(DH_F_COMPUTE_KEY,DH_R_NO_PRIVATE_VALUE);
+        if (dh->priv_key == NULL) {
+                DHerr(DH_F_COMPUTE_KEY, DH_R_NO_PRIVATE_VALUE);
                 goto err;
-                }
+        }
 
-        if (dh->flags & DH_FLAG_CACHE_MONT_P)
-                {
+        if (dh->flags & DH_FLAG_CACHE_MONT_P) {
                 mont = BN_MONT_CTX_set_locked(&dh->method_mont_p,
-                                CRYPTO_LOCK_DH, dh->p, ctx);
-                if ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) == 0)
-                        {
+                    CRYPTO_LOCK_DH, dh->p, ctx);
+                if ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) == 0) {
                         /* XXX */
                         BN_set_flags(dh->priv_key, BN_FLG_CONSTTIME);
-                        }
+                }
                 if (!mont)
                         goto err;
-                }
+        }
 
-        if (!DH_check_pub_key(dh, pub_key, &check_result) || check_result)
-                {
-                DHerr(DH_F_COMPUTE_KEY,DH_R_INVALID_PUBKEY);
+        if (!DH_check_pub_key(dh, pub_key, &check_result) || check_result) {
+                DHerr(DH_F_COMPUTE_KEY, DH_R_INVALID_PUBKEY);
                 goto err;
-                }
+        }
 
-        if (!dh->meth->bn_mod_exp(dh, tmp, pub_key, dh->priv_key,dh->p,ctx,mont))
-                {
-                DHerr(DH_F_COMPUTE_KEY,ERR_R_BN_LIB);
+        if (!dh->meth->bn_mod_exp(dh, tmp, pub_key, dh->priv_key, dh->p, ctx,
+            mont)) {
+                DHerr(DH_F_COMPUTE_KEY, ERR_R_BN_LIB);
                 goto err;
-                }
+        }
 
-        ret=BN_bn2bin(tmp,key);
+        ret = BN_bn2bin(tmp, key);
 err:
-        if (ctx != NULL)
-                {
+        if (ctx != NULL) {
                 BN_CTX_end(ctx);
                 BN_CTX_free(ctx);
-                }
-        return(ret);
         }
+        return ret;
+}
 
-static int dh_bn_mod_exp(const DH *dh, BIGNUM *r,
-                        const BIGNUM *a, const BIGNUM *p,
-                        const BIGNUM *m, BN_CTX *ctx,
-                        BN_MONT_CTX *m_ctx)
-        {
-        /* If a is only one word long and constant time is false, use the faster
+static int
+dh_bn_mod_exp(const DH *dh, BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
+    const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx)
+{
+        /*
+         * If a is only one word long and constant time is false, use the faster
          * exponenentiation function.
          */
-        if (a->top == 1 && ((dh->flags & DH_FLAG_NO_EXP_CONSTTIME) != 0))
-                {
+        if (a->top == 1 && (dh->flags & DH_FLAG_NO_EXP_CONSTTIME) != 0) {
                 BN_ULONG A = a->d[0];
-                return BN_mod_exp_mont_word(r,A,p,m,ctx,m_ctx);
-                }
-        else
-                return BN_mod_exp_mont(r,a,p,m,ctx,m_ctx);
-        }
 
+                return BN_mod_exp_mont_word(r, A, p, m, ctx, m_ctx);
+        } else
+                return BN_mod_exp_mont(r, a, p, m, ctx, m_ctx);
+}
 
-static int dh_init(DH *dh)
-        {
+static int
+dh_init(DH *dh)
+{
         dh->flags |= DH_FLAG_CACHE_MONT_P;
-        return(1);
-        }
+        return 1;
+}
 
-static int dh_finish(DH *dh)
-        {
-        if(dh->method_mont_p)
+static int
+dh_finish(DH *dh)
+{
+        if (dh->method_mont_p)
                 BN_MONT_CTX_free(dh->method_mont_p);
-        return(1);
-        }
+        return 1;
+}