/src/openssl/crypto/bn/bn_blind.c

Source (jump to first uncovered line)
/* crypto/bn/bn_blind.c */
/* ====================================================================
 * 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
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    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
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. All advertising materials mentioning features or use of this
 *    software must display the following acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
 *
 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For written permission, please contact
 *    openssl-core@openssl.org.
 *
 * 5. Products derived from this software may not be called "OpenSSL"
 *    nor may "OpenSSL" appear in their names without prior written
 *    permission of the OpenSSL Project.
 *
 * 6. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by the OpenSSL Project
 *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
 *
 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 * ====================================================================
 *
 * This product includes cryptographic software written by Eric Young
 * (eay@cryptsoft.com).  This product includes software written by Tim
 * Hudson (tjh@cryptsoft.com).
 *
 */
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
 * This package is an SSL implementation written
 * by Eric Young (eay@cryptsoft.com).
 * The implementation was written so as to conform with Netscapes SSL.
 *
 * This library is free for commercial and non-commercial use as long as
 * the following conditions are aheared to.  The following conditions
 * apply to all code found in this distribution, be it the RC4, RSA,
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
 * included with this distribution is covered by the same copyright terms
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
 *
 * Copyright remains Eric Young's, and as such any Copyright notices in
 * the code are not to be removed.
 * If this package is used in a product, Eric Young should be given attribution
 * as the author of the parts of the library used.
 * This can be in the form of a textual message at program startup or
 * in documentation (online or textual) provided with the package.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the copyright
 *    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 the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    "This product includes cryptographic software written by
 *     Eric Young (eay@cryptsoft.com)"
 *    The word 'cryptographic' can be left out if the rouines from the library
 *    being used are not cryptographic related :-).
 * 4. If you include any Windows specific code (or a derivative thereof) from
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
 *
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * The licence and distribution terms for any publically available version or
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
 * copied and put under another distribution licence
 * [including the GNU Public Licence.]
 */

#include <stdio.h>
#include "cryptlib.h"
#include "bn_lcl.h"

#define BN_BLINDING_COUNTER     32

struct bn_blinding_st {
    BIGNUM *A;
    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;
    int counter;
    unsigned long flags;
    BN_MONT_CTX *m_ctx;
    int (*bn_mod_exp) (BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
                       const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx);
};

BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod)
{
    BN_BLINDING *ret = NULL;

    bn_check_top(mod);

    if ((ret = (BN_BLINDING *)OPENSSL_malloc(sizeof(BN_BLINDING))) == NULL) {
        BNerr(BN_F_BN_BLINDING_NEW, ERR_R_MALLOC_FAILURE);
        return (NULL);
    }
    memset(ret, 0, sizeof(BN_BLINDING));
    if (A != NULL) {
        if ((ret->A = BN_dup(A)) == NULL)
            goto err;
    }
    if (Ai != NULL) {
        if ((ret->Ai = BN_dup(Ai)) == NULL)
            goto err;
    }

    /* 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);

    /*
     * Set the counter to the special value -1 to indicate that this is
     * never-used fresh blinding that does not need updating before first
     * use.
     */
    ret->counter = -1;
    CRYPTO_THREADID_current(&ret->tid);
    return (ret);
 err:
    if (ret != NULL)
        BN_BLINDING_free(ret);
    return (NULL);
}

void BN_BLINDING_free(BN_BLINDING *r)
{
    if (r == NULL)
        return;

    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);
}

int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx)
{
    int ret = 0;

    if ((b->A == NULL) || (b->Ai == NULL)) {
        BNerr(BN_F_BN_BLINDING_UPDATE, BN_R_NOT_INITIALIZED);
        goto err;
    }

    if (b->counter == -1)
        b->counter = 0;

    if (++b->counter == BN_BLINDING_COUNTER && b->e != NULL &&
        !(b->flags & BN_BLINDING_NO_RECREATE)) {
        /* re-create blinding parameters */
        if (!BN_BLINDING_create_param(b, NULL, NULL, ctx, NULL, NULL))
            goto err;
    } else if (!(b->flags & BN_BLINDING_NO_UPDATE)) {
        if (!BN_mod_mul(b->A, b->A, b->A, b->mod, ctx))
            goto err;
        if (!BN_mod_mul(b->Ai, b->Ai, b->Ai, b->mod, ctx))
            goto err;
    }

    ret = 1;
 err:
    if (b->counter == BN_BLINDING_COUNTER)
        b->counter = 0;
    return (ret);
}

int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx)
{
    return BN_BLINDING_convert_ex(n, NULL, b, 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_EX, BN_R_NOT_INITIALIZED);
        return (0);
    }

    if (b->counter == -1)
        /* Fresh blinding, doesn't need updating. */
        b->counter = 0;
    else if (!BN_BLINDING_update(b, ctx))
        return (0);

    if (r != NULL) {
        if (!BN_copy(r, b->Ai))
            ret = 0;
    }

    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)
{
    return BN_BLINDING_invert_ex(n, NULL, b, ctx);
}

int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b,
                          BN_CTX *ctx)
{
    int ret;

    bn_check_top(n);

    if (r != NULL)
        ret = BN_mod_mul(n, n, r, b->mod, ctx);
    else {
        if (b->Ai == NULL) {
            BNerr(BN_F_BN_BLINDING_INVERT_EX, BN_R_NOT_INITIALIZED);
            return (0);
        }
        ret = BN_mod_mul(n, n, b->Ai, b->mod, ctx);
    }

    bn_check_top(n);
    return (ret);
}

#ifndef OPENSSL_NO_DEPRECATED
unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *b)
{
    return b->thread_id;
}

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)
{
    return b->flags;
}

void BN_BLINDING_set_flags(BN_BLINDING *b, unsigned long flags)
{
    b->flags = flags;
}

BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b,
                                      const BIGNUM *e, BIGNUM *m, BN_CTX *ctx,
                                      int (*bn_mod_exp) (BIGNUM *r,
                                                         const BIGNUM *a,
                                                         const BIGNUM *p,
                                                         const BIGNUM *m,
                                                         BN_CTX *ctx,
                                                         BN_MONT_CTX *m_ctx),
                                      BN_MONT_CTX *m_ctx)
{
    int retry_counter = 32;
    BN_BLINDING *ret = NULL;

    if (b == NULL)
        ret = BN_BLINDING_new(NULL, NULL, m);
    else
        ret = b;

    if (ret == NULL)
        goto err;

    if (ret->A == NULL && (ret->A = BN_new()) == NULL)
        goto err;
    if (ret->Ai == NULL && (ret->Ai = BN_new()) == NULL)
        goto err;

    if (e != NULL) {
        if (ret->e != NULL)
            BN_free(ret->e);
        ret->e = BN_dup(e);
    }
    if (ret->e == NULL)
        goto err;

    if (bn_mod_exp != NULL)
        ret->bn_mod_exp = bn_mod_exp;
    if (m_ctx != NULL)
        ret->m_ctx = m_ctx;

    do {
        if (!BN_rand_range(ret->A, ret->mod))
            goto err;
        if (BN_mod_inverse(ret->Ai, ret->A, ret->mod, ctx) == NULL) {
            /*
             * 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 (retry_counter-- == 0) {
                    BNerr(BN_F_BN_BLINDING_CREATE_PARAM,
                          BN_R_TOO_MANY_ITERATIONS);
                    goto err;
                }
                ERR_clear_error();
            } else
                goto err;
        } else
            break;
    } while (1);

    if (ret->bn_mod_exp != NULL && ret->m_ctx != NULL) {
        if (!ret->bn_mod_exp
            (ret->A, ret->A, ret->e, ret->mod, ctx, ret->m_ctx))
            goto err;
    } else {
        if (!BN_mod_exp(ret->A, ret->A, ret->e, ret->mod, ctx))
            goto err;
    }

    return ret;
 err:
    if (b == NULL && ret != NULL) {
        BN_BLINDING_free(ret);
        ret = NULL;
    }

    return ret;
}

Coverage Report

Created: 2022-11-30 06:20

Line	Count	Source (jump to first uncovered line)
1		/* crypto/bn/bn_blind.c */
2		/* ====================================================================
3		* Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
4		*
5		* Redistribution and use in source and binary forms, with or without
6		* modification, are permitted provided that the following conditions
7		* are met:
8		*
9		* 1. Redistributions of source code must retain the above copyright
10		* notice, this list of conditions and the following disclaimer.
11		*
12		* 2. Redistributions in binary form must reproduce the above copyright
13		* notice, this list of conditions and the following disclaimer in
14		* the documentation and/or other materials provided with the
15		* distribution.
16		*
17		* 3. All advertising materials mentioning features or use of this
18		* software must display the following acknowledgment:
19		* "This product includes software developed by the OpenSSL Project
20		* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
21		*
22		* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
23		* endorse or promote products derived from this software without
24		* prior written permission. For written permission, please contact
25		* openssl-core@openssl.org.
26		*
27		* 5. Products derived from this software may not be called "OpenSSL"
28		* nor may "OpenSSL" appear in their names without prior written
29		* permission of the OpenSSL Project.
30		*
31		* 6. Redistributions of any form whatsoever must retain the following
32		* acknowledgment:
33		* "This product includes software developed by the OpenSSL Project
34		* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
35		*
36		* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
37		* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
39		* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
40		* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
42		* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43		* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
45		* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
46		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
47		* OF THE POSSIBILITY OF SUCH DAMAGE.
48		* ====================================================================
49		*
50		* This product includes cryptographic software written by Eric Young
51		* (eay@cryptsoft.com). This product includes software written by Tim
52		* Hudson (tjh@cryptsoft.com).
53		*
54		*/
55		/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
56		* All rights reserved.
57		*
58		* This package is an SSL implementation written
59		* by Eric Young (eay@cryptsoft.com).
60		* The implementation was written so as to conform with Netscapes SSL.
61		*
62		* This library is free for commercial and non-commercial use as long as
63		* the following conditions are aheared to. The following conditions
64		* apply to all code found in this distribution, be it the RC4, RSA,
65		* lhash, DES, etc., code; not just the SSL code. The SSL documentation
66		* included with this distribution is covered by the same copyright terms
67		* except that the holder is Tim Hudson (tjh@cryptsoft.com).
68		*
69		* Copyright remains Eric Young's, and as such any Copyright notices in
70		* the code are not to be removed.
71		* If this package is used in a product, Eric Young should be given attribution
72		* as the author of the parts of the library used.
73		* This can be in the form of a textual message at program startup or
74		* in documentation (online or textual) provided with the package.
75		*
76		* Redistribution and use in source and binary forms, with or without
77		* modification, are permitted provided that the following conditions
78		* are met:
79		* 1. Redistributions of source code must retain the copyright
80		* notice, this list of conditions and the following disclaimer.
81		* 2. Redistributions in binary form must reproduce the above copyright
82		* notice, this list of conditions and the following disclaimer in the
83		* documentation and/or other materials provided with the distribution.
84		* 3. All advertising materials mentioning features or use of this software
85		* must display the following acknowledgement:
86		* "This product includes cryptographic software written by
87		* Eric Young (eay@cryptsoft.com)"
88		* The word 'cryptographic' can be left out if the rouines from the library
89		* being used are not cryptographic related :-).
90		* 4. If you include any Windows specific code (or a derivative thereof) from
91		* the apps directory (application code) you must include an acknowledgement:
92		* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
93		*
94		* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
95		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
96		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
97		* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
98		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
99		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
100		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
101		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
102		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
103		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
104		* SUCH DAMAGE.
105		*
106		* The licence and distribution terms for any publically available version or
107		* derivative of this code cannot be changed. i.e. this code cannot simply be
108		* copied and put under another distribution licence
109		* [including the GNU Public Licence.]
110		*/
111
112		#include <stdio.h>
113		#include "cryptlib.h"
114		#include "bn_lcl.h"
115
116	0	#define BN_BLINDING_COUNTER 32
117
118		struct bn_blinding_st {
119		BIGNUM *A;
120		BIGNUM *Ai;
121		BIGNUM *e;
122		BIGNUM mod; / just a reference */
123		#ifndef OPENSSL_NO_DEPRECATED
124		unsigned long thread_id; /* added in OpenSSL 0.9.6j and 0.9.7b; used
125		* only by crypto/rsa/rsa_eay.c, rsa_lib.c */
126		#endif
127		CRYPTO_THREADID tid;
128		int counter;
129		unsigned long flags;
130		BN_MONT_CTX *m_ctx;
131		int (bn_mod_exp) (BIGNUM r, const BIGNUM a, const BIGNUM p,
132		const BIGNUM m, BN_CTX ctx, BN_MONT_CTX *m_ctx);
133		};
134
135		BN_BLINDING BN_BLINDING_new(const BIGNUM A, const BIGNUM Ai, BIGNUM mod)
136	0	{
137	0	BN_BLINDING *ret = NULL;
138
139	0	bn_check_top(mod);
140
141	0	if ((ret = (BN_BLINDING *)OPENSSL_malloc(sizeof(BN_BLINDING))) == NULL) {
142	0	BNerr(BN_F_BN_BLINDING_NEW, ERR_R_MALLOC_FAILURE);
143	0	return (NULL);
144	0	}
145	0	memset(ret, 0, sizeof(BN_BLINDING));
146	0	if (A != NULL) {
147	0	if ((ret->A = BN_dup(A)) == NULL)
148	0	goto err;
149	0	}
150	0	if (Ai != NULL) {
151	0	if ((ret->Ai = BN_dup(Ai)) == NULL)
152	0	goto err;
153	0	}
154
155		/* save a copy of mod in the BN_BLINDING structure */
156	0	if ((ret->mod = BN_dup(mod)) == NULL)
157	0	goto err;
158	0	if (BN_get_flags(mod, BN_FLG_CONSTTIME) != 0)
159	0	BN_set_flags(ret->mod, BN_FLG_CONSTTIME);
160
161		/*
162		* Set the counter to the special value -1 to indicate that this is
163		* never-used fresh blinding that does not need updating before first
164		* use.
165		*/
166	0	ret->counter = -1;
167	0	CRYPTO_THREADID_current(&ret->tid);
168	0	return (ret);
169	0	err:
170	0	if (ret != NULL)
171	0	BN_BLINDING_free(ret);
172	0	return (NULL);
173	0	}
174
175		void BN_BLINDING_free(BN_BLINDING *r)
176	0	{
177	0	if (r == NULL)
178	0	return;
179
180	0	if (r->A != NULL)
181	0	BN_free(r->A);
182	0	if (r->Ai != NULL)
183	0	BN_free(r->Ai);
184	0	if (r->e != NULL)
185	0	BN_free(r->e);
186	0	if (r->mod != NULL)
187	0	BN_free(r->mod);
188	0	OPENSSL_free(r);
189	0	}
190
191		int BN_BLINDING_update(BN_BLINDING b, BN_CTX ctx)
192	0	{
193	0	int ret = 0;
194
195	0	if ((b->A == NULL) \|\| (b->Ai == NULL)) {
196	0	BNerr(BN_F_BN_BLINDING_UPDATE, BN_R_NOT_INITIALIZED);
197	0	goto err;
198	0	}
199
200	0	if (b->counter == -1)
201	0	b->counter = 0;
202
203	0	if (++b->counter == BN_BLINDING_COUNTER && b->e != NULL &&
204	0	!(b->flags & BN_BLINDING_NO_RECREATE)) {
205		/* re-create blinding parameters */
206	0	if (!BN_BLINDING_create_param(b, NULL, NULL, ctx, NULL, NULL))
207	0	goto err;
208	0	} else if (!(b->flags & BN_BLINDING_NO_UPDATE)) {
209	0	if (!BN_mod_mul(b->A, b->A, b->A, b->mod, ctx))
210	0	goto err;
211	0	if (!BN_mod_mul(b->Ai, b->Ai, b->Ai, b->mod, ctx))
212	0	goto err;
213	0	}
214
215	0	ret = 1;
216	0	err:
217	0	if (b->counter == BN_BLINDING_COUNTER)
218	0	b->counter = 0;
219	0	return (ret);
220	0	}
221
222		int BN_BLINDING_convert(BIGNUM n, BN_BLINDING b, BN_CTX *ctx)
223	0	{
224	0	return BN_BLINDING_convert_ex(n, NULL, b, ctx);
225	0	}
226
227		int BN_BLINDING_convert_ex(BIGNUM n, BIGNUM r, BN_BLINDING b, BN_CTX ctx)
228	0	{
229	0	int ret = 1;
230
231	0	bn_check_top(n);
232
233	0	if ((b->A == NULL) \|\| (b->Ai == NULL)) {
234	0	BNerr(BN_F_BN_BLINDING_CONVERT_EX, BN_R_NOT_INITIALIZED);
235	0	return (0);
236	0	}
237
238	0	if (b->counter == -1)
239		/* Fresh blinding, doesn't need updating. */
240	0	b->counter = 0;
241	0	else if (!BN_BLINDING_update(b, ctx))
242	0	return (0);
243
244	0	if (r != NULL) {
245	0	if (!BN_copy(r, b->Ai))
246	0	ret = 0;
247	0	}
248
249	0	if (!BN_mod_mul(n, n, b->A, b->mod, ctx))
250	0	ret = 0;
251
252	0	return ret;
253	0	}
254
255		int BN_BLINDING_invert(BIGNUM n, BN_BLINDING b, BN_CTX *ctx)
256	0	{
257	0	return BN_BLINDING_invert_ex(n, NULL, b, ctx);
258	0	}
259
260		int BN_BLINDING_invert_ex(BIGNUM n, const BIGNUM r, BN_BLINDING *b,
261		BN_CTX *ctx)
262	0	{
263	0	int ret;
264
265	0	bn_check_top(n);
266
267	0	if (r != NULL)
268	0	ret = BN_mod_mul(n, n, r, b->mod, ctx);
269	0	else {
270	0	if (b->Ai == NULL) {
271	0	BNerr(BN_F_BN_BLINDING_INVERT_EX, BN_R_NOT_INITIALIZED);
272	0	return (0);
273	0	}
274	0	ret = BN_mod_mul(n, n, b->Ai, b->mod, ctx);
275	0	}
276
277	0	bn_check_top(n);
278	0	return (ret);
279	0	}
280
281		#ifndef OPENSSL_NO_DEPRECATED
282		unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *b)
283	0	{
284	0	return b->thread_id;
285	0	}
286
287		void BN_BLINDING_set_thread_id(BN_BLINDING *b, unsigned long n)
288	0	{
289	0	b->thread_id = n;
290	0	}
291		#endif
292
293		CRYPTO_THREADID BN_BLINDING_thread_id(BN_BLINDING b)
294	0	{
295	0	return &b->tid;
296	0	}
297
298		unsigned long BN_BLINDING_get_flags(const BN_BLINDING *b)
299	0	{
300	0	return b->flags;
301	0	}
302
303		void BN_BLINDING_set_flags(BN_BLINDING *b, unsigned long flags)
304	0	{
305	0	b->flags = flags;
306	0	}
307
308		BN_BLINDING BN_BLINDING_create_param(BN_BLINDING b,
309		const BIGNUM e, BIGNUM m, BN_CTX *ctx,
310		int (bn_mod_exp) (BIGNUM r,
311		const BIGNUM *a,
312		const BIGNUM *p,
313		const BIGNUM *m,
314		BN_CTX *ctx,
315		BN_MONT_CTX *m_ctx),
316		BN_MONT_CTX *m_ctx)
317	0	{
318	0	int retry_counter = 32;
319	0	BN_BLINDING *ret = NULL;
320
321	0	if (b == NULL)
322	0	ret = BN_BLINDING_new(NULL, NULL, m);
323	0	else
324	0	ret = b;
325
326	0	if (ret == NULL)
327	0	goto err;
328
329	0	if (ret->A == NULL && (ret->A = BN_new()) == NULL)
330	0	goto err;
331	0	if (ret->Ai == NULL && (ret->Ai = BN_new()) == NULL)
332	0	goto err;
333
334	0	if (e != NULL) {
335	0	if (ret->e != NULL)
336	0	BN_free(ret->e);
337	0	ret->e = BN_dup(e);
338	0	}
339	0	if (ret->e == NULL)
340	0	goto err;
341
342	0	if (bn_mod_exp != NULL)
343	0	ret->bn_mod_exp = bn_mod_exp;
344	0	if (m_ctx != NULL)
345	0	ret->m_ctx = m_ctx;
346
347	0	do {
348	0	if (!BN_rand_range(ret->A, ret->mod))
349	0	goto err;
350	0	if (BN_mod_inverse(ret->Ai, ret->A, ret->mod, ctx) == NULL) {
351		/*
352		* this should almost never happen for good RSA keys
353		*/
354	0	unsigned long error = ERR_peek_last_error();
355	0	if (ERR_GET_REASON(error) == BN_R_NO_INVERSE) {
356	0	if (retry_counter-- == 0) {
357	0	BNerr(BN_F_BN_BLINDING_CREATE_PARAM,
358	0	BN_R_TOO_MANY_ITERATIONS);
359	0	goto err;
360	0	}
361	0	ERR_clear_error();
362	0	} else
363	0	goto err;
364	0	} else
365	0	break;
366	0	} while (1);
367
368	0	if (ret->bn_mod_exp != NULL && ret->m_ctx != NULL) {
369	0	if (!ret->bn_mod_exp
370	0	(ret->A, ret->A, ret->e, ret->mod, ctx, ret->m_ctx))
371	0	goto err;
372	0	} else {
373	0	if (!BN_mod_exp(ret->A, ret->A, ret->e, ret->mod, ctx))
374	0	goto err;
375	0	}
376
377	0	return ret;
378	0	err:
379	0	if (b == NULL && ret != NULL) {
380	0	BN_BLINDING_free(ret);
381	0	ret = NULL;
382	0	}
383
384	0	return ret;
385	0	}