Give parameters names in prototypes.

[oweals/openssl.git] / crypto / bn / bn_blind.c

diff --git a/crypto/bn/bn_blind.c b/crypto/bn/bn_blind.c
index 1f41740c956952fea973331af58f07c98d523850..2dc677c739bda71f1f3c88f348c31c8ec4319fe2 100644 (file)
--- a/crypto/bn/bn_blind.c
+++ b/crypto/bn/bn_blind.c
@@ -1,6 +1,6 @@
 /* crypto/bn/bn_blind.c */
 /* ====================================================================
- * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -109,6 +109,8 @@
  * [including the GNU Public Licence.]
  */
 
+#define OPENSSL_FIPSAPI
+
 #include <stdio.h>
 #include "cryptlib.h"
 #include "bn_lcl.h"
@@ -121,8 +123,11 @@ struct bn_blinding_st
        BIGNUM *Ai;
        BIGNUM *e;
        BIGNUM *mod; /* just a reference */
+#ifndef OPENSSL_NO_DEPRECATED
        unsigned long thread_id; /* added in OpenSSL 0.9.6j and 0.9.7b;
                                  * used only by crypto/rsa/rsa_eay.c, rsa_lib.c */
+#endif
+       CRYPTO_THREADID tid;
        unsigned int  counter;
        unsigned long flags;
        BN_MONT_CTX *m_ctx;
@@ -151,8 +156,14 @@ BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod)
                {
                if ((ret->Ai = BN_dup(Ai)) == NULL) goto err;
                }
-       ret->mod = mod;
+
+       /* save a copy of mod in the BN_BLINDING structure */
+       if ((ret->mod = BN_dup(mod)) == NULL) goto err;
+       if (BN_get_flags(mod, BN_FLG_CONSTTIME) != 0)
+               BN_set_flags(ret->mod, BN_FLG_CONSTTIME);
+
        ret->counter = BN_BLINDING_COUNTER;
+       CRYPTO_THREADID_current(&ret->tid);
        return(ret);
 err:
        if (ret != NULL) BN_BLINDING_free(ret);
@@ -167,6 +178,7 @@ void BN_BLINDING_free(BN_BLINDING *r)
        if (r->A  != NULL) BN_free(r->A );
        if (r->Ai != NULL) BN_free(r->Ai);
        if (r->e  != NULL) BN_free(r->e );
+       if (r->mod != NULL) BN_free(r->mod); 
        OPENSSL_free(r);
        }
 
@@ -207,18 +219,24 @@ int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
 
 int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx)
        {
+       int ret = 1;
+
        bn_check_top(n);
 
        if ((b->A == NULL) || (b->Ai == NULL))
                {
-               BNerr(BN_F_BN_BLINDING_CONVERT,BN_R_NOT_INITIALIZED);
+               BNerr(BN_F_BN_BLINDING_CONVERT_EX,BN_R_NOT_INITIALIZED);
                return(0);
                }
 
        if (r != NULL)
-               BN_copy(r, b->Ai);
+               {
+               if (!BN_copy(r, b->Ai)) ret=0;
+               }
 
-       return BN_mod_mul(n,n,b->A,b->mod,ctx);
+       if (!BN_mod_mul(n,n,b->A,b->mod,ctx)) ret=0;
+       
+       return ret;
        }
 
 int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
@@ -233,7 +251,7 @@ int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *ct
        bn_check_top(n);
        if ((b->A == NULL) || (b->Ai == NULL))
                {
-               BNerr(BN_F_BN_BLINDING_INVERT,BN_R_NOT_INITIALIZED);
+               BNerr(BN_F_BN_BLINDING_INVERT_EX,BN_R_NOT_INITIALIZED);
                return(0);
                }
 
@@ -251,6 +269,7 @@ int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *ct
        return(ret);
        }
 
+#ifndef OPENSSL_NO_DEPRECATED
 unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *b)
        {
        return b->thread_id;
@@ -260,6 +279,12 @@ void BN_BLINDING_set_thread_id(BN_BLINDING *b, unsigned long n)
        {
        b->thread_id = n;
        }
+#endif
+
+CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *b)
+       {
+       return &b->tid;
+       }
 
 unsigned long BN_BLINDING_get_flags(const BN_BLINDING *b)
        {
@@ -278,7 +303,6 @@ BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
        BN_MONT_CTX *m_ctx)
 {
        int    retry_counter = 32;
-       BIGNUM *a, *ai;
        BN_BLINDING *ret = NULL;
 
        if (b == NULL)
@@ -309,12 +333,12 @@ BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
                ret->m_ctx = m_ctx;
 
        do {
+               int rv;
                if (!BN_rand_range(ret->A, ret->mod)) goto err;
-               if (BN_mod_inverse(ret->Ai, ret->A, ret->mod, ctx) == NULL)
+               if (!int_bn_mod_inverse(ret->Ai, ret->A, ret->mod, ctx, &rv))
                        {
                        /* this should almost never happen for good RSA keys */
-                       unsigned long error = ERR_peek_last_error();
-                       if (ERR_GET_REASON(error) == BN_R_NO_INVERSE)
+                       if (rv)
                                {
                                if (retry_counter-- == 0)
                                {
@@ -322,7 +346,6 @@ BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
                                                BN_R_TOO_MANY_ITERATIONS);
                                        goto err;
                                }
-                               ERR_clear_error();
                                }
                        else
                                goto err;
@@ -352,4 +375,3 @@ err:
 
        return ret;
 }
-