| OLD | NEW |
|---|
| (Empty) |
| 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 #define BN_BLINDING_COUNTER 32 | |
| 117 | |
| 118 struct bn_blinding_st | |
| 119 { | |
| 120 BIGNUM *A; | |
| 121 BIGNUM *Ai; | |
| 122 BIGNUM *e; | |
| 123 BIGNUM *mod; /* just a reference */ | |
| 124 #ifndef OPENSSL_NO_DEPRECATED | |
| 125 unsigned long thread_id; /* added in OpenSSL 0.9.6j and 0.9.7b; | |
| 126 * used only by crypto/rsa/rsa_eay.c, rsa_lib.c
*/ | |
| 127 #endif | |
| 128 CRYPTO_THREADID tid; | |
| 129 int counter; | |
| 130 unsigned long flags; | |
| 131 BN_MONT_CTX *m_ctx; | |
| 132 int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
| 133 const BIGNUM *m, BN_CTX *ctx, | |
| 134 BN_MONT_CTX *m_ctx); | |
| 135 }; | |
| 136 | |
| 137 BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod) | |
| 138 { | |
| 139 BN_BLINDING *ret=NULL; | |
| 140 | |
| 141 bn_check_top(mod); | |
| 142 | |
| 143 if ((ret=(BN_BLINDING *)OPENSSL_malloc(sizeof(BN_BLINDING))) == NULL) | |
| 144 { | |
| 145 BNerr(BN_F_BN_BLINDING_NEW,ERR_R_MALLOC_FAILURE); | |
| 146 return(NULL); | |
| 147 } | |
| 148 memset(ret,0,sizeof(BN_BLINDING)); | |
| 149 if (A != NULL) | |
| 150 { | |
| 151 if ((ret->A = BN_dup(A)) == NULL) goto err; | |
| 152 } | |
| 153 if (Ai != NULL) | |
| 154 { | |
| 155 if ((ret->Ai = BN_dup(Ai)) == NULL) goto err; | |
| 156 } | |
| 157 | |
| 158 /* save a copy of mod in the BN_BLINDING structure */ | |
| 159 if ((ret->mod = BN_dup(mod)) == NULL) goto err; | |
| 160 if (BN_get_flags(mod, BN_FLG_CONSTTIME) != 0) | |
| 161 BN_set_flags(ret->mod, BN_FLG_CONSTTIME); | |
| 162 | |
| 163 /* Set the counter to the special value -1 | |
| 164 * to indicate that this is never-used fresh blinding | |
| 165 * that does not need updating before first use. */ | |
| 166 ret->counter = -1; | |
| 167 CRYPTO_THREADID_current(&ret->tid); | |
| 168 return(ret); | |
| 169 err: | |
| 170 if (ret != NULL) BN_BLINDING_free(ret); | |
| 171 return(NULL); | |
| 172 } | |
| 173 | |
| 174 void BN_BLINDING_free(BN_BLINDING *r) | |
| 175 { | |
| 176 if(r == NULL) | |
| 177 return; | |
| 178 | |
| 179 if (r->A != NULL) BN_free(r->A ); | |
| 180 if (r->Ai != NULL) BN_free(r->Ai); | |
| 181 if (r->e != NULL) BN_free(r->e ); | |
| 182 if (r->mod != NULL) BN_free(r->mod); | |
| 183 OPENSSL_free(r); | |
| 184 } | |
| 185 | |
| 186 int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx) | |
| 187 { | |
| 188 int ret=0; | |
| 189 | |
| 190 if ((b->A == NULL) || (b->Ai == NULL)) | |
| 191 { | |
| 192 BNerr(BN_F_BN_BLINDING_UPDATE,BN_R_NOT_INITIALIZED); | |
| 193 goto err; | |
| 194 } | |
| 195 | |
| 196 if (b->counter == -1) | |
| 197 b->counter = 0; | |
| 198 | |
| 199 if (++b->counter == BN_BLINDING_COUNTER && b->e != NULL && | |
| 200 !(b->flags & BN_BLINDING_NO_RECREATE)) | |
| 201 { | |
| 202 /* re-create blinding parameters */ | |
| 203 if (!BN_BLINDING_create_param(b, NULL, NULL, ctx, NULL, NULL)) | |
| 204 goto err; | |
| 205 } | |
| 206 else if (!(b->flags & BN_BLINDING_NO_UPDATE)) | |
| 207 { | |
| 208 if (!BN_mod_mul(b->A,b->A,b->A,b->mod,ctx)) goto err; | |
| 209 if (!BN_mod_mul(b->Ai,b->Ai,b->Ai,b->mod,ctx)) goto err; | |
| 210 } | |
| 211 | |
| 212 ret=1; | |
| 213 err: | |
| 214 if (b->counter == BN_BLINDING_COUNTER) | |
| 215 b->counter = 0; | |
| 216 return(ret); | |
| 217 } | |
| 218 | |
| 219 int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx) | |
| 220 { | |
| 221 return BN_BLINDING_convert_ex(n, NULL, b, ctx); | |
| 222 } | |
| 223 | |
| 224 int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *ctx) | |
| 225 { | |
| 226 int ret = 1; | |
| 227 | |
| 228 bn_check_top(n); | |
| 229 | |
| 230 if ((b->A == NULL) || (b->Ai == NULL)) | |
| 231 { | |
| 232 BNerr(BN_F_BN_BLINDING_CONVERT_EX,BN_R_NOT_INITIALIZED); | |
| 233 return(0); | |
| 234 } | |
| 235 | |
| 236 if (b->counter == -1) | |
| 237 /* Fresh blinding, doesn't need updating. */ | |
| 238 b->counter = 0; | |
| 239 else if (!BN_BLINDING_update(b,ctx)) | |
| 240 return(0); | |
| 241 | |
| 242 if (r != NULL) | |
| 243 { | |
| 244 if (!BN_copy(r, b->Ai)) ret=0; | |
| 245 } | |
| 246 | |
| 247 if (!BN_mod_mul(n,n,b->A,b->mod,ctx)) ret=0; | |
| 248 | |
| 249 return ret; | |
| 250 } | |
| 251 | |
| 252 int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx) | |
| 253 { | |
| 254 return BN_BLINDING_invert_ex(n, NULL, b, ctx); | |
| 255 } | |
| 256 | |
| 257 int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, BN_CTX *ct
x) | |
| 258 { | |
| 259 int ret; | |
| 260 | |
| 261 bn_check_top(n); | |
| 262 | |
| 263 if (r != NULL) | |
| 264 ret = BN_mod_mul(n, n, r, b->mod, ctx); | |
| 265 else | |
| 266 { | |
| 267 if (b->Ai == NULL) | |
| 268 { | |
| 269 BNerr(BN_F_BN_BLINDING_INVERT_EX,BN_R_NOT_INITIALIZED); | |
| 270 return(0); | |
| 271 } | |
| 272 ret = BN_mod_mul(n, n, b->Ai, b->mod, ctx); | |
| 273 } | |
| 274 | |
| 275 bn_check_top(n); | |
| 276 return(ret); | |
| 277 } | |
| 278 | |
| 279 #ifndef OPENSSL_NO_DEPRECATED | |
| 280 unsigned long BN_BLINDING_get_thread_id(const BN_BLINDING *b) | |
| 281 { | |
| 282 return b->thread_id; | |
| 283 } | |
| 284 | |
| 285 void BN_BLINDING_set_thread_id(BN_BLINDING *b, unsigned long n) | |
| 286 { | |
| 287 b->thread_id = n; | |
| 288 } | |
| 289 #endif | |
| 290 | |
| 291 CRYPTO_THREADID *BN_BLINDING_thread_id(BN_BLINDING *b) | |
| 292 { | |
| 293 return &b->tid; | |
| 294 } | |
| 295 | |
| 296 unsigned long BN_BLINDING_get_flags(const BN_BLINDING *b) | |
| 297 { | |
| 298 return b->flags; | |
| 299 } | |
| 300 | |
| 301 void BN_BLINDING_set_flags(BN_BLINDING *b, unsigned long flags) | |
| 302 { | |
| 303 b->flags = flags; | |
| 304 } | |
| 305 | |
| 306 BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b, | |
| 307 const BIGNUM *e, BIGNUM *m, BN_CTX *ctx, | |
| 308 int (*bn_mod_exp)(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, | |
| 309 const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx), | |
| 310 BN_MONT_CTX *m_ctx) | |
| 311 { | |
| 312 int retry_counter = 32; | |
| 313 BN_BLINDING *ret = NULL; | |
| 314 | |
| 315 if (b == NULL) | |
| 316 ret = BN_BLINDING_new(NULL, NULL, m); | |
| 317 else | |
| 318 ret = b; | |
| 319 | |
| 320 if (ret == NULL) | |
| 321 goto err; | |
| 322 | |
| 323 if (ret->A == NULL && (ret->A = BN_new()) == NULL) | |
| 324 goto err; | |
| 325 if (ret->Ai == NULL && (ret->Ai = BN_new()) == NULL) | |
| 326 goto err; | |
| 327 | |
| 328 if (e != NULL) | |
| 329 { | |
| 330 if (ret->e != NULL) | |
| 331 BN_free(ret->e); | |
| 332 ret->e = BN_dup(e); | |
| 333 } | |
| 334 if (ret->e == NULL) | |
| 335 goto err; | |
| 336 | |
| 337 if (bn_mod_exp != NULL) | |
| 338 ret->bn_mod_exp = bn_mod_exp; | |
| 339 if (m_ctx != NULL) | |
| 340 ret->m_ctx = m_ctx; | |
| 341 | |
| 342 do { | |
| 343 if (!BN_rand_range(ret->A, ret->mod)) goto err; | |
| 344 if (BN_mod_inverse(ret->Ai, ret->A, ret->mod, ctx) == NULL) | |
| 345 { | |
| 346 /* this should almost never happen for good RSA keys */ | |
| 347 unsigned long error = ERR_peek_last_error(); | |
| 348 if (ERR_GET_REASON(error) == BN_R_NO_INVERSE) | |
| 349 { | |
| 350 if (retry_counter-- == 0) | |
| 351 { | |
| 352 BNerr(BN_F_BN_BLINDING_CREATE_PARAM, | |
| 353 BN_R_TOO_MANY_ITERATIONS); | |
| 354 goto err; | |
| 355 } | |
| 356 ERR_clear_error(); | |
| 357 } | |
| 358 else | |
| 359 goto err; | |
| 360 } | |
| 361 else | |
| 362 break; | |
| 363 } while (1); | |
| 364 | |
| 365 if (ret->bn_mod_exp != NULL && ret->m_ctx != NULL) | |
| 366 { | |
| 367 if (!ret->bn_mod_exp(ret->A, ret->A, ret->e, ret->mod, ctx, ret-
>m_ctx)) | |
| 368 goto err; | |
| 369 } | |
| 370 else | |
| 371 { | |
| 372 if (!BN_mod_exp(ret->A, ret->A, ret->e, ret->mod, ctx)) | |
| 373 goto err; | |
| 374 } | |
| 375 | |
| 376 return ret; | |
| 377 err: | |
| 378 if (b == NULL && ret != NULL) | |
| 379 { | |
| 380 BN_BLINDING_free(ret); | |
| 381 ret = NULL; | |
| 382 } | |
| 383 | |
| 384 return ret; | |
| 385 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2072073002:
Delete bundled copy of OpenSSL and replace with README. (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/openssl@master