summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/bn/bn_div.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/bn/bn_div.c')
-rw-r--r--src/lib/libcrypto/bn/bn_div.c299
1 files changed, 27 insertions, 272 deletions
diff --git a/src/lib/libcrypto/bn/bn_div.c b/src/lib/libcrypto/bn/bn_div.c
index 8655eb118e..580d1201bc 100644
--- a/src/lib/libcrypto/bn/bn_div.c
+++ b/src/lib/libcrypto/bn/bn_div.c
@@ -169,31 +169,22 @@ int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d,
169#endif /* OPENSSL_NO_ASM */ 169#endif /* OPENSSL_NO_ASM */
170 170
171 171
172/* BN_div[_no_branch] computes dv := num / divisor, rounding towards 172/* BN_div computes dv := num / divisor, rounding towards zero, and sets up
173 * zero, and sets up rm such that dv*divisor + rm = num holds. 173 * rm such that dv*divisor + rm = num holds.
174 * Thus: 174 * Thus:
175 * dv->neg == num->neg ^ divisor->neg (unless the result is zero) 175 * dv->neg == num->neg ^ divisor->neg (unless the result is zero)
176 * rm->neg == num->neg (unless the remainder is zero) 176 * rm->neg == num->neg (unless the remainder is zero)
177 * If 'dv' or 'rm' is NULL, the respective value is not returned. 177 * If 'dv' or 'rm' is NULL, the respective value is not returned.
178 */ 178 */
179static int BN_div_no_branch(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num,
180 const BIGNUM *divisor, BN_CTX *ctx);
181int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor, 179int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
182 BN_CTX *ctx) 180 BN_CTX *ctx)
183 { 181 {
184 int norm_shift,i,loop; 182 int norm_shift,i,j,loop;
185 BIGNUM *tmp,wnum,*snum,*sdiv,*res; 183 BIGNUM *tmp,wnum,*snum,*sdiv,*res;
186 BN_ULONG *resp,*wnump; 184 BN_ULONG *resp,*wnump;
187 BN_ULONG d0,d1; 185 BN_ULONG d0,d1;
188 int num_n,div_n; 186 int num_n,div_n;
189 187
190 if ((BN_get_flags(num, BN_FLG_CONSTTIME) != 0) || (BN_get_flags(divisor, BN_FLG_CONSTTIME) != 0))
191 {
192 return BN_div_no_branch(dv, rm, num, divisor, ctx);
193 }
194
195 bn_check_top(dv);
196 bn_check_top(rm);
197 bn_check_top(num); 188 bn_check_top(num);
198 bn_check_top(divisor); 189 bn_check_top(divisor);
199 190
@@ -219,6 +210,7 @@ int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
219 res=BN_CTX_get(ctx); 210 res=BN_CTX_get(ctx);
220 else res=dv; 211 else res=dv;
221 if (sdiv == NULL || res == NULL) goto err; 212 if (sdiv == NULL || res == NULL) goto err;
213 tmp->neg=0;
222 214
223 /* First we normalise the numbers */ 215 /* First we normalise the numbers */
224 norm_shift=BN_BITS2-((BN_num_bits(divisor))%BN_BITS2); 216 norm_shift=BN_BITS2-((BN_num_bits(divisor))%BN_BITS2);
@@ -230,17 +222,17 @@ int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
230 div_n=sdiv->top; 222 div_n=sdiv->top;
231 num_n=snum->top; 223 num_n=snum->top;
232 loop=num_n-div_n; 224 loop=num_n-div_n;
225
233 /* Lets setup a 'window' into snum 226 /* Lets setup a 'window' into snum
234 * This is the part that corresponds to the current 227 * This is the part that corresponds to the current
235 * 'area' being divided */ 228 * 'area' being divided */
236 wnum.neg = 0; 229 BN_init(&wnum);
237 wnum.d = &(snum->d[loop]); 230 wnum.d= &(snum->d[loop]);
238 wnum.top = div_n; 231 wnum.top= div_n;
239 /* only needed when BN_ucmp messes up the values between top and max */ 232 wnum.dmax= snum->dmax+1; /* a bit of a lie */
240 wnum.dmax = snum->dmax - loop; /* so we don't step out of bounds */
241 233
242 /* Get the top 2 words of sdiv */ 234 /* Get the top 2 words of sdiv */
243 /* div_n=sdiv->top; */ 235 /* i=sdiv->top; */
244 d0=sdiv->d[div_n-1]; 236 d0=sdiv->d[div_n-1];
245 d1=(div_n == 1)?0:sdiv->d[div_n-2]; 237 d1=(div_n == 1)?0:sdiv->d[div_n-2];
246 238
@@ -258,28 +250,19 @@ int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor,
258 250
259 if (BN_ucmp(&wnum,sdiv) >= 0) 251 if (BN_ucmp(&wnum,sdiv) >= 0)
260 { 252 {
261 /* If BN_DEBUG_RAND is defined BN_ucmp changes (via 253 if (!BN_usub(&wnum,&wnum,sdiv)) goto err;
262 * bn_pollute) the const bignum arguments =>
263 * clean the values between top and max again */
264 bn_clear_top2max(&wnum);
265 bn_sub_words(wnum.d, wnum.d, sdiv->d, div_n);
266 *resp=1; 254 *resp=1;
255 res->d[res->top-1]=1;
267 } 256 }
268 else 257 else
269 res->top--; 258 res->top--;
270 /* if res->top == 0 then clear the neg value otherwise decrease
271 * the resp pointer */
272 if (res->top == 0) 259 if (res->top == 0)
273 res->neg = 0; 260 res->neg = 0;
274 else 261 resp--;
275 resp--;
276 262
277 for (i=0; i<loop-1; i++, wnump--, resp--) 263 for (i=0; i<loop-1; i++)
278 { 264 {
279 BN_ULONG q,l0; 265 BN_ULONG q,l0;
280 /* the first part of the loop uses the top two words of
281 * snum and sdiv to calculate a BN_ULONG q such that
282 * | wnum - sdiv * q | < sdiv */
283#if defined(BN_DIV3W) && !defined(OPENSSL_NO_ASM) 266#if defined(BN_DIV3W) && !defined(OPENSSL_NO_ASM)
284 BN_ULONG bn_div_3_words(BN_ULONG*,BN_ULONG,BN_ULONG); 267 BN_ULONG bn_div_3_words(BN_ULONG*,BN_ULONG,BN_ULONG);
285 q=bn_div_3_words(wnump,d1,d0); 268 q=bn_div_3_words(wnump,d1,d0);
@@ -363,252 +346,27 @@ X) -> 0x%08X\n",
363#endif /* !BN_DIV3W */ 346#endif /* !BN_DIV3W */
364 347
365 l0=bn_mul_words(tmp->d,sdiv->d,div_n,q); 348 l0=bn_mul_words(tmp->d,sdiv->d,div_n,q);
349 wnum.d--; wnum.top++;
366 tmp->d[div_n]=l0; 350 tmp->d[div_n]=l0;
367 wnum.d--; 351 for (j=div_n+1; j>0; j--)
368 /* ingore top values of the bignums just sub the two 352 if (tmp->d[j-1]) break;
369 * BN_ULONG arrays with bn_sub_words */ 353 tmp->top=j;
370 if (bn_sub_words(wnum.d, wnum.d, tmp->d, div_n+1))
371 {
372 /* Note: As we have considered only the leading
373 * two BN_ULONGs in the calculation of q, sdiv * q
374 * might be greater than wnum (but then (q-1) * sdiv
375 * is less or equal than wnum)
376 */
377 q--;
378 if (bn_add_words(wnum.d, wnum.d, sdiv->d, div_n))
379 /* we can't have an overflow here (assuming
380 * that q != 0, but if q == 0 then tmp is
381 * zero anyway) */
382 (*wnump)++;
383 }
384 /* store part of the result */
385 *resp = q;
386 }
387 bn_correct_top(snum);
388 if (rm != NULL)
389 {
390 /* Keep a copy of the neg flag in num because if rm==num
391 * BN_rshift() will overwrite it.
392 */
393 int neg = num->neg;
394 BN_rshift(rm,snum,norm_shift);
395 if (!BN_is_zero(rm))
396 rm->neg = neg;
397 bn_check_top(rm);
398 }
399 BN_CTX_end(ctx);
400 return(1);
401err:
402 bn_check_top(rm);
403 BN_CTX_end(ctx);
404 return(0);
405 }
406
407
408/* BN_div_no_branch is a special version of BN_div. It does not contain
409 * branches that may leak sensitive information.
410 */
411static int BN_div_no_branch(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num,
412 const BIGNUM *divisor, BN_CTX *ctx)
413 {
414 int norm_shift,i,loop;
415 BIGNUM *tmp,wnum,*snum,*sdiv,*res;
416 BN_ULONG *resp,*wnump;
417 BN_ULONG d0,d1;
418 int num_n,div_n;
419
420 bn_check_top(dv);
421 bn_check_top(rm);
422 bn_check_top(num);
423 bn_check_top(divisor);
424
425 if (BN_is_zero(divisor))
426 {
427 BNerr(BN_F_BN_DIV_NO_BRANCH,BN_R_DIV_BY_ZERO);
428 return(0);
429 }
430
431 BN_CTX_start(ctx);
432 tmp=BN_CTX_get(ctx);
433 snum=BN_CTX_get(ctx);
434 sdiv=BN_CTX_get(ctx);
435 if (dv == NULL)
436 res=BN_CTX_get(ctx);
437 else res=dv;
438 if (sdiv == NULL || res == NULL) goto err;
439
440 /* First we normalise the numbers */
441 norm_shift=BN_BITS2-((BN_num_bits(divisor))%BN_BITS2);
442 if (!(BN_lshift(sdiv,divisor,norm_shift))) goto err;
443 sdiv->neg=0;
444 norm_shift+=BN_BITS2;
445 if (!(BN_lshift(snum,num,norm_shift))) goto err;
446 snum->neg=0;
447
448 /* Since we don't know whether snum is larger than sdiv,
449 * we pad snum with enough zeroes without changing its
450 * value.
451 */
452 if (snum->top <= sdiv->top+1)
453 {
454 if (bn_wexpand(snum, sdiv->top + 2) == NULL) goto err;
455 for (i = snum->top; i < sdiv->top + 2; i++) snum->d[i] = 0;
456 snum->top = sdiv->top + 2;
457 }
458 else
459 {
460 if (bn_wexpand(snum, snum->top + 1) == NULL) goto err;
461 snum->d[snum->top] = 0;
462 snum->top ++;
463 }
464
465 div_n=sdiv->top;
466 num_n=snum->top;
467 loop=num_n-div_n;
468 /* Lets setup a 'window' into snum
469 * This is the part that corresponds to the current
470 * 'area' being divided */
471 wnum.neg = 0;
472 wnum.d = &(snum->d[loop]);
473 wnum.top = div_n;
474 /* only needed when BN_ucmp messes up the values between top and max */
475 wnum.dmax = snum->dmax - loop; /* so we don't step out of bounds */
476
477 /* Get the top 2 words of sdiv */
478 /* div_n=sdiv->top; */
479 d0=sdiv->d[div_n-1];
480 d1=(div_n == 1)?0:sdiv->d[div_n-2];
481
482 /* pointer to the 'top' of snum */
483 wnump= &(snum->d[num_n-1]);
484
485 /* Setup to 'res' */
486 res->neg= (num->neg^divisor->neg);
487 if (!bn_wexpand(res,(loop+1))) goto err;
488 res->top=loop-1;
489 resp= &(res->d[loop-1]);
490
491 /* space for temp */
492 if (!bn_wexpand(tmp,(div_n+1))) goto err;
493
494 /* if res->top == 0 then clear the neg value otherwise decrease
495 * the resp pointer */
496 if (res->top == 0)
497 res->neg = 0;
498 else
499 resp--;
500
501 for (i=0; i<loop-1; i++, wnump--, resp--)
502 {
503 BN_ULONG q,l0;
504 /* the first part of the loop uses the top two words of
505 * snum and sdiv to calculate a BN_ULONG q such that
506 * | wnum - sdiv * q | < sdiv */
507#if defined(BN_DIV3W) && !defined(OPENSSL_NO_ASM)
508 BN_ULONG bn_div_3_words(BN_ULONG*,BN_ULONG,BN_ULONG);
509 q=bn_div_3_words(wnump,d1,d0);
510#else
511 BN_ULONG n0,n1,rem=0;
512
513 n0=wnump[0];
514 n1=wnump[-1];
515 if (n0 == d0)
516 q=BN_MASK2;
517 else /* n0 < d0 */
518 {
519#ifdef BN_LLONG
520 BN_ULLONG t2;
521
522#if defined(BN_LLONG) && defined(BN_DIV2W) && !defined(bn_div_words)
523 q=(BN_ULONG)(((((BN_ULLONG)n0)<<BN_BITS2)|n1)/d0);
524#else
525 q=bn_div_words(n0,n1,d0);
526#ifdef BN_DEBUG_LEVITTE
527 fprintf(stderr,"DEBUG: bn_div_words(0x%08X,0x%08X,0x%08\
528X) -> 0x%08X\n",
529 n0, n1, d0, q);
530#endif
531#endif
532
533#ifndef REMAINDER_IS_ALREADY_CALCULATED
534 /*
535 * rem doesn't have to be BN_ULLONG. The least we
536 * know it's less that d0, isn't it?
537 */
538 rem=(n1-q*d0)&BN_MASK2;
539#endif
540 t2=(BN_ULLONG)d1*q;
541
542 for (;;)
543 {
544 if (t2 <= ((((BN_ULLONG)rem)<<BN_BITS2)|wnump[-2]))
545 break;
546 q--;
547 rem += d0;
548 if (rem < d0) break; /* don't let rem overflow */
549 t2 -= d1;
550 }
551#else /* !BN_LLONG */
552 BN_ULONG t2l,t2h,ql,qh;
553
554 q=bn_div_words(n0,n1,d0);
555#ifdef BN_DEBUG_LEVITTE
556 fprintf(stderr,"DEBUG: bn_div_words(0x%08X,0x%08X,0x%08\
557X) -> 0x%08X\n",
558 n0, n1, d0, q);
559#endif
560#ifndef REMAINDER_IS_ALREADY_CALCULATED
561 rem=(n1-q*d0)&BN_MASK2;
562#endif
563 354
564#if defined(BN_UMULT_LOHI) 355 j=wnum.top;
565 BN_UMULT_LOHI(t2l,t2h,d1,q); 356 if (!BN_sub(&wnum,&wnum,tmp)) goto err;
566#elif defined(BN_UMULT_HIGH)
567 t2l = d1 * q;
568 t2h = BN_UMULT_HIGH(d1,q);
569#else
570 t2l=LBITS(d1); t2h=HBITS(d1);
571 ql =LBITS(q); qh =HBITS(q);
572 mul64(t2l,t2h,ql,qh); /* t2=(BN_ULLONG)d1*q; */
573#endif
574 357
575 for (;;) 358 snum->top=snum->top+wnum.top-j;
576 {
577 if ((t2h < rem) ||
578 ((t2h == rem) && (t2l <= wnump[-2])))
579 break;
580 q--;
581 rem += d0;
582 if (rem < d0) break; /* don't let rem overflow */
583 if (t2l < d1) t2h--; t2l -= d1;
584 }
585#endif /* !BN_LLONG */
586 }
587#endif /* !BN_DIV3W */
588 359
589 l0=bn_mul_words(tmp->d,sdiv->d,div_n,q); 360 if (wnum.neg)
590 tmp->d[div_n]=l0;
591 wnum.d--;
592 /* ingore top values of the bignums just sub the two
593 * BN_ULONG arrays with bn_sub_words */
594 if (bn_sub_words(wnum.d, wnum.d, tmp->d, div_n+1))
595 { 361 {
596 /* Note: As we have considered only the leading
597 * two BN_ULONGs in the calculation of q, sdiv * q
598 * might be greater than wnum (but then (q-1) * sdiv
599 * is less or equal than wnum)
600 */
601 q--; 362 q--;
602 if (bn_add_words(wnum.d, wnum.d, sdiv->d, div_n)) 363 j=wnum.top;
603 /* we can't have an overflow here (assuming 364 if (!BN_add(&wnum,&wnum,sdiv)) goto err;
604 * that q != 0, but if q == 0 then tmp is 365 snum->top+=wnum.top-j;
605 * zero anyway) */
606 (*wnump)++;
607 } 366 }
608 /* store part of the result */ 367 *(resp--)=q;
609 *resp = q; 368 wnump--;
610 } 369 }
611 bn_correct_top(snum);
612 if (rm != NULL) 370 if (rm != NULL)
613 { 371 {
614 /* Keep a copy of the neg flag in num because if rm==num 372 /* Keep a copy of the neg flag in num because if rm==num
@@ -618,13 +376,10 @@ X) -> 0x%08X\n",
618 BN_rshift(rm,snum,norm_shift); 376 BN_rshift(rm,snum,norm_shift);
619 if (!BN_is_zero(rm)) 377 if (!BN_is_zero(rm))
620 rm->neg = neg; 378 rm->neg = neg;
621 bn_check_top(rm);
622 } 379 }
623 bn_correct_top(res);
624 BN_CTX_end(ctx); 380 BN_CTX_end(ctx);
625 return(1); 381 return(1);
626err: 382err:
627 bn_check_top(rm);
628 BN_CTX_end(ctx); 383 BN_CTX_end(ctx);
629 return(0); 384 return(0);
630 } 385 }
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-08-04 15:49:52 +0000