luna - wolfssl/src/ssl

   1/* ssl_bn.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22#include <wolfssl/wolfcrypt/libwolfssl_sources.h>
  23
  24#include <wolfssl/internal.h>
  25#ifndef WC_NO_RNG
  26    #include <wolfssl/wolfcrypt/random.h>
  27#endif
  28
  29#if !defined(WOLFSSL_SSL_BN_INCLUDED)
  30    #ifndef WOLFSSL_IGNORE_FILE_WARN
  31        #warning ssl_bn.c does not need to be compiled separately from ssl.c
  32    #endif
  33#else
  34
  35/* Check on validity of big number.
  36 *
  37 * Used for parameter validation.
  38 *
  39 * @param [in] bn  Big number.
  40 * @return 1 when bn is not NULL and internal representation is not NULL.
  41 * @return 0 otherwise.
  42 */
  43#define BN_IS_NULL(bn) (((bn) == NULL) || ((bn)->internal == NULL))
  44
  45/*******************************************************************************
  46 * Constructor/Destructor/Initializer APIs
  47 ******************************************************************************/
  48
  49#if defined(OPENSSL_EXTRA) && !defined(NO_ASN)
  50/* Set big number to be negative.
  51 *
  52 * @param [in, out] bn   Big number to make negative.
  53 * @param [in]      neg  Whether number is negative.
  54 * @return  1 on success.
  55 * @return  -1 when bn or internal representation of bn is NULL.
  56 */
  57static int wolfssl_bn_set_neg(WOLFSSL_BIGNUM* bn, int neg)
  58{
  59    int ret = 1;
  60
  61    if (BN_IS_NULL(bn)) {
  62        WOLFSSL_MSG("bn NULL error");
  63        ret = WOLFSSL_FATAL_ERROR;
  64    }
  65#if !defined(WOLFSSL_SP_MATH_ALL) || defined(WOLFSSL_SP_INT_NEGATIVE)
  66    else if (neg) {
  67        mp_setneg((mp_int*)bn->internal);
  68    }
  69    else {
  70        ((mp_int*)bn->internal)->sign = MP_ZPOS;
  71    }
  72#endif
  73
  74    return ret;
  75}
  76#endif /* OPENSSL_EXTRA && !NO_ASN */
  77
  78#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
  79/* Get the internal representation value into an MP integer.
  80 *
  81 * When calling wolfssl_bn_get_value, mpi should be cleared by caller if no
  82 * longer used. ie mp_free(mpi). This is to free data when fastmath is
  83 * disabled since a copy of mpi is made by this function and placed into bn.
  84 *
  85 * @param [in]      bn   Big number to copy value from.
  86 * @param [in, out] mpi  MP integer to copy into.
  87 * @return  1 on success.
  88 * @return  -1 when bn or internal representation of bn is NULL.
  89 * @return  -1 when mpi is NULL.
  90 * @return  -1 when copy fails.
  91 */
  92int wolfssl_bn_get_value(WOLFSSL_BIGNUM* bn, mp_int* mpi)
  93{
  94    int ret = 1;
  95
  96    WOLFSSL_MSG("Entering wolfssl_bn_get_value_mp");
  97
  98    /* Validate parameters. */
  99    if (BN_IS_NULL(bn)) {
 100        WOLFSSL_MSG("bn NULL error");
 101        ret = WOLFSSL_FATAL_ERROR;
 102    }
 103    else if (mpi == NULL) {
 104        WOLFSSL_MSG("mpi NULL error");
 105        ret = WOLFSSL_FATAL_ERROR;
 106    }
 107
 108    /* Copy the internal representation into MP integer. */
 109    if ((ret == 1) && mp_copy((mp_int*)bn->internal, mpi) != MP_OKAY) {
 110        WOLFSSL_MSG("mp_copy error");
 111        ret = WOLFSSL_FATAL_ERROR;
 112    }
 113
 114    return ret;
 115}
 116
 117/* Set big number internal representation to value in mpi.
 118 *
 119 * Will create a new big number if bn points to NULL.
 120 *
 121 * When calling wolfssl_bn_set_value, mpi should be cleared by caller if no
 122 * longer used. ie mp_free(mpi). This is to free data when fastmath is
 123 * disabled since a copy of mpi is made by this function and placed into bn.
 124 *
 125 * @param [in, out] bn   Pointer to big number to have value.
 126 * @param [in]      mpi  MP integer with value to set.
 127 * @return  1 on success.
 128 * @return  -1 when mpi or bn is NULL.
 129 * @return  -1 when creating a new big number fails.
 130 * @return  -1 when copying MP integer fails.
 131 */
 132int wolfssl_bn_set_value(WOLFSSL_BIGNUM** bn, mp_int* mpi)
 133{
 134    int ret = 1;
 135    WOLFSSL_BIGNUM* a = NULL;
 136
 137#ifdef WOLFSSL_DEBUG_OPENSSL
 138    WOLFSSL_ENTER("wolfssl_bn_set_value");
 139#endif
 140
 141    /* Validate parameters. */
 142    if ((bn == NULL) || (mpi == NULL)) {
 143        WOLFSSL_MSG("mpi or bn NULL error");
 144        ret = WOLFSSL_FATAL_ERROR;
 145    }
 146
 147    /* Allocate a new big number if one not passed in. */
 148    if ((ret == 1) && (*bn == NULL)) {
 149        a = wolfSSL_BN_new();
 150        if (a == NULL) {
 151            WOLFSSL_MSG("wolfssl_bn_set_value alloc failed");
 152            ret = WOLFSSL_FATAL_ERROR;
 153        }
 154        *bn = a;
 155    }
 156
 157    /* Copy MP integer value into internal representation of big number. */
 158    if ((ret == 1) && (mp_copy(mpi, (mp_int*)((*bn)->internal)) != MP_OKAY)) {
 159        WOLFSSL_MSG("mp_copy error");
 160        ret = WOLFSSL_FATAL_ERROR;
 161    }
 162
 163    /* Dispose of any allocated big number on error. */
 164    if ((ret == -1) && (a != NULL)) {
 165        wolfSSL_BN_free(a);
 166        *bn = NULL;
 167    }
 168    return ret;
 169}
 170
 171/* Initialize a big number.
 172 *
 173 * Assumes bn is not NULL.
 174 *
 175 * @param [in, out] bn  Big number to initialize.
 176 */
 177static void wolfssl_bn_init(WOLFSSL_BIGNUM* bn)
 178{
 179    /* Clear fields of big number. */
 180    XMEMSET(bn, 0, sizeof(WOLFSSL_BIGNUM));
 181    /* Initialization only fails when passed NULL. */
 182    (void)mp_init(&bn->mpi);
 183    /* Set an internal representation. */
 184    bn->internal = &bn->mpi;
 185}
 186
 187/* Create a new big number.
 188 *
 189 * @return  An allocated and initialized big number on success.
 190 * @return  NULL on failure.
 191 */
 192WOLFSSL_BIGNUM* wolfSSL_BN_new(void)
 193{
 194    WOLFSSL_BIGNUM* bn = NULL;
 195
 196#ifdef WOLFSSL_DEBUG_OPENSSL
 197    WOLFSSL_ENTER("wolfSSL_BN_new");
 198#endif
 199
 200    /* Allocate memory for big number. */
 201    bn = (WOLFSSL_BIGNUM*)XMALLOC(sizeof(WOLFSSL_BIGNUM), NULL,
 202        DYNAMIC_TYPE_BIGINT);
 203    if (bn == NULL) {
 204        WOLFSSL_MSG("wolfSSL_BN_new malloc WOLFSSL_BIGNUM failure");
 205    }
 206    else {
 207        /* Initialize newly allocated object. */
 208        wolfssl_bn_init(bn);
 209    }
 210
 211    return bn;
 212}
 213
 214#if !defined(USE_INTEGER_HEAP_MATH) && !defined(HAVE_WOLF_BIGINT)
 215/* Initialize a big number.
 216 *
 217 * Call this instead of wolfSSL_BN_new() and wolfSSL_BN_free().
 218 *
 219 * Do not call this API after wolfSSL_BN_new() or wolfSSL_BN_init().
 220 *
 221 * @param [in, out] bn  Big number to initialize.
 222 */
 223void wolfSSL_BN_init(WOLFSSL_BIGNUM* bn)
 224{
 225#ifdef WOLFSSL_DEBUG_OPENSSL
 226    WOLFSSL_ENTER("wolfSSL_BN_init");
 227#endif
 228
 229    /* Validate parameter. */
 230    if (bn != NULL) {
 231        /* Initialize big number object. */
 232        wolfssl_bn_init(bn);
 233    }
 234}
 235#endif
 236
 237/* Dispose of big number.
 238 *
 239 * bn is unusable after this call.
 240 *
 241 * @param [in, out] bn  Big number to free.
 242 */
 243void wolfSSL_BN_free(WOLFSSL_BIGNUM* bn)
 244{
 245#ifdef WOLFSSL_DEBUG_OPENSSL
 246    WOLFSSL_ENTER("wolfSSL_BN_free");
 247#endif
 248
 249    /* Validate parameter. */
 250    if (bn != NULL) {
 251        /* Cleanup any internal representation. */
 252        if (bn->internal != NULL) {
 253            /* Free MP integer. */
 254            mp_free(&bn->mpi);
 255        }
 256        /* Dispose of big number object. */
 257        XFREE(bn, NULL, DYNAMIC_TYPE_BIGINT);
 258        /* bn = NULL, don't try to access or double free it */
 259    }
 260}
 261
 262/* Zeroize and dispose of big number.
 263 *
 264 * bn is unusable after this call.
 265 *
 266 * @param [in, out] bn  Big number to clear and free.
 267 */
 268void wolfSSL_BN_clear_free(WOLFSSL_BIGNUM* bn)
 269{
 270#ifdef WOLFSSL_DEBUG_OPENSSL
 271    WOLFSSL_ENTER("wolfSSL_BN_clear_free");
 272#endif
 273
 274    /* Validate parameter. */
 275    if (bn != NULL) {
 276        /* Check for internal representation. */
 277        if (bn->internal != NULL) {
 278            /* Zeroize MP integer. */
 279            mp_forcezero((mp_int*)bn->internal);
 280        }
 281        /* Dispose of big number. */
 282        wolfSSL_BN_free(bn);
 283    }
 284}
 285
 286/* Zeroize big number.
 287 *
 288 * @param [in, out] bn  Big number to clear.
 289 */
 290void wolfSSL_BN_clear(WOLFSSL_BIGNUM* bn)
 291{
 292#ifdef WOLFSSL_DEBUG_OPENSSL
 293    WOLFSSL_ENTER("wolfSSL_BN_clear");
 294#endif
 295
 296    /* Validate parameter. */
 297    if (!BN_IS_NULL(bn)) {
 298        /* Zeroize MP integer. */
 299        mp_forcezero((mp_int*)bn->internal);
 300    }
 301}
 302#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
 303
 304#ifdef OPENSSL_EXTRA
 305
 306static WOLFSSL_BIGNUM* bn_one = NULL;
 307
 308/* Return a big number with the value of one.
 309 *
 310 * @return  A big number with the value one on success.
 311 * @return  NULL on failure.
 312 */
 313const WOLFSSL_BIGNUM* wolfSSL_BN_value_one(void)
 314{
 315    WOLFSSL_BIGNUM* one;
 316
 317    WOLFSSL_ENTER("wolfSSL_BN_value_one");
 318
 319    /* Get the global object. */
 320    one = bn_one;
 321    /* Create a new big number if global not set. */
 322    if ((one == NULL) && ((one = wolfSSL_BN_new()) != NULL)) {
 323        /* Set internal representation to have a value of 1. */
 324        if (mp_set_int((mp_int*)one->internal, 1) != MP_OKAY) {
 325            /* Dispose of big number on error. */
 326            wolfSSL_BN_free(one);
 327            one = NULL;
 328        }
 329        else
 330    #ifndef SINGLE_THREADED
 331        /* Ensure global has not been set by another thread. */
 332        if (bn_one == NULL)
 333    #endif
 334        {
 335            /* Set this big number as the global. */
 336            bn_one = one;
 337        }
 338    #ifndef SINGLE_THREADED
 339        /* Check if another thread has set the global. */
 340        if (bn_one != one) {
 341            /* Dispose of this big number and return the global.  */
 342            wolfSSL_BN_free(one);
 343            one = bn_one;
 344        }
 345    #endif
 346    }
 347
 348    return one;
 349}
 350
 351static void wolfSSL_BN_free_one(void) {
 352    wolfSSL_BN_free(bn_one);
 353    bn_one = NULL;
 354}
 355
 356/* Create a new big number with the same value as the one passed in.
 357 *
 358 * @param [in] bn  Big number to duplicate.
 359 * @return  Big number on success.
 360 * @return  NULL when bn or internal representation of bn is NULL.
 361 * @return  NULL when creating a new big number fails.
 362 * @return  NULL when copying the internal representation fails.
 363 */
 364WOLFSSL_BIGNUM* wolfSSL_BN_dup(const WOLFSSL_BIGNUM* bn)
 365{
 366    int err = 0;
 367    WOLFSSL_BIGNUM* ret = NULL;
 368
 369    WOLFSSL_ENTER("wolfSSL_BN_dup");
 370
 371    /* Validate parameter. */
 372    if (BN_IS_NULL(bn)) {
 373        WOLFSSL_MSG("bn NULL error");
 374        err = 1;
 375    }
 376
 377    /* Create a new big number to return. */
 378    if ((!err) && ((ret = wolfSSL_BN_new()) == NULL)) {
 379        WOLFSSL_MSG("bn new error");
 380        err = 1;
 381    }
 382
 383    if (!err) {
 384        err = (wolfSSL_BN_copy(ret, bn) == NULL);
 385    }
 386
 387    if (err) {
 388         /* Dispose of dynamically allocated data. */
 389         wolfSSL_BN_free(ret);
 390         ret = NULL;
 391    }
 392    return ret;
 393}
 394
 395/* Copy value from bn into another r.
 396 *
 397 * @param [in, out] r   Big number to copy into.
 398 * @param [in]      bn  Big number to copy from.
 399 * @return  Big number copied into on success.
 400 * @return  NULL when r or bn is NULL.
 401 * @return  NULL when copying fails.
 402 */
 403WOLFSSL_BIGNUM* wolfSSL_BN_copy(WOLFSSL_BIGNUM* r, const WOLFSSL_BIGNUM* bn)
 404{
 405    WOLFSSL_ENTER("wolfSSL_BN_copy");
 406
 407    /* Validate parameters. */
 408    if (BN_IS_NULL(r) || BN_IS_NULL(bn)) {
 409        WOLFSSL_MSG("r or bn NULL error");
 410        r = NULL;
 411    }
 412
 413    /* Copy the value in. */
 414    if ((r != NULL) && mp_copy((mp_int*)bn->internal, (mp_int*)r->internal) !=
 415            MP_OKAY) {
 416        WOLFSSL_MSG("mp_copy error");
 417        r = NULL;
 418    }
 419
 420    if (r != NULL) {
 421        /* Copy other fields in a big number. */
 422        r->neg = bn->neg;
 423    }
 424
 425    return r;
 426}
 427
 428
 429/*******************************************************************************
 430 * Encode/Decode APIs.
 431 ******************************************************************************/
 432
 433/* Encode the number is a big-endian byte array.
 434 *
 435 * Assumes byte array is large enough to hold encoding when not NULL.
 436 * Use NULL for byte array to get length.
 437 *
 438 * Return compliant with OpenSSL.
 439 *
 440 * @param [in]  bn  Big number to reduced
 441 * @param [out] r   Byte array to encode into. May be NULL.
 442 * @return  Length of big number in bytes on success.
 443 * @return  -1 when bn is NULL or encoding fails.
 444 */
 445int wolfSSL_BN_bn2bin(const WOLFSSL_BIGNUM* bn, unsigned char* r)
 446{
 447    int ret;
 448
 449    WOLFSSL_ENTER("wolfSSL_BN_bn2bin");
 450
 451    /* Validate parameters. */
 452    if (BN_IS_NULL(bn)) {
 453        WOLFSSL_MSG("NULL bn error");
 454        ret = WOLFSSL_FATAL_ERROR;
 455    }
 456    else {
 457        /* Get the length of the encoding. */
 458        ret = mp_unsigned_bin_size((mp_int*)bn->internal);
 459        /* Encode if byte array supplied. */
 460        if ((r != NULL) && (mp_to_unsigned_bin((mp_int*)bn->internal, r) !=
 461                MP_OKAY)) {
 462            WOLFSSL_MSG("mp_to_unsigned_bin error");
 463            ret = WOLFSSL_FATAL_ERROR;
 464        }
 465    }
 466
 467    return ret;
 468}
 469
 470
 471/* Encode a big number as a big-endian byte array, zero-padded to toLen bytes.
 472 *
 473 * Returns toLen on success, -1 on error (including when the number is too
 474 * large to fit in toLen bytes).
 475 *
 476 * @param [in]  bn     Big number to encode.
 477 * @param [out] r      Buffer to place encoding into. Must be at least toLen
 478 *                     bytes.
 479 * @param [in]  toLen  Desired output length in bytes.
 480 * @return  toLen on success.
 481 * @return  -1 on error.
 482 */
 483int wolfSSL_BN_bn2binpad(const WOLFSSL_BIGNUM* bn, unsigned char* r, int toLen)
 484{
 485    int numBytes;
 486
 487    WOLFSSL_ENTER("wolfSSL_BN_bn2binpad");
 488
 489    /* Validate parameters. */
 490    if (BN_IS_NULL(bn) || (r == NULL) || (toLen < 0)) {
 491        WOLFSSL_MSG("NULL bn, r, or invalid toLen error");
 492        return WOLFSSL_FATAL_ERROR;
 493    }
 494
 495    /* Get the number of bytes needed to encode the big number. */
 496    numBytes = mp_unsigned_bin_size((mp_int*)bn->internal);
 497    if (numBytes < 0) {
 498        WOLFSSL_MSG("mp_unsigned_bin_size error");
 499        return WOLFSSL_FATAL_ERROR;
 500    }
 501    if (numBytes > toLen) {
 502        WOLFSSL_MSG("BN too large for toLen");
 503        return WOLFSSL_FATAL_ERROR;
 504    }
 505
 506    /* Zero-pad leading bytes. */
 507    XMEMSET(r, 0, (size_t)(toLen - numBytes));
 508
 509    /* Encode the big number into the remaining bytes. */
 510    if (numBytes > 0 &&
 511        mp_to_unsigned_bin((mp_int*)bn->internal, r + toLen - numBytes) !=
 512            MP_OKAY) {
 513        WOLFSSL_MSG("mp_to_unsigned_bin error");
 514        return WOLFSSL_FATAL_ERROR;
 515    }
 516
 517    return toLen;
 518}
 519
 520
 521/* Return a big number with value of the decoding of the big-endian byte array.
 522 *
 523 * Returns ret when not NULL.
 524 * Allocates a big number when ret is NULL.
 525 * Assumes str is not NULL.
 526 *
 527 * @param [in]      data  Byte array to decode.
 528 * @param [in]      len   Number of bytes in byte array.
 529 * @param [in, out] ret   Big number to reduced. May be NULL.
 530 * @return  A big number on success.
 531 * @return  NULL on failure.
 532 */
 533WOLFSSL_BIGNUM* wolfSSL_BN_bin2bn(const unsigned char* data, int len,
 534    WOLFSSL_BIGNUM* ret)
 535{
 536    WOLFSSL_BIGNUM* bn = NULL;
 537
 538    WOLFSSL_ENTER("wolfSSL_BN_bin2bn");
 539
 540    /* Validate parameters. */
 541    if (len < 0) {
 542        ret = NULL;
 543    }
 544    /* Allocate a new big number when ret is NULL. */
 545    else if (ret == NULL) {
 546        ret = wolfSSL_BN_new();
 547        bn = ret;
 548    }
 549
 550    /* Check ret is usable. */
 551    if (ret != NULL) {
 552        /* Check internal representation is usable. */
 553        if (ret->internal == NULL) {
 554            ret = NULL;
 555        }
 556        else if (data != NULL) {
 557            /* Decode into big number. */
 558            if (mp_read_unsigned_bin((mp_int*)ret->internal, data, (word32)len)
 559                    != 0) {
 560                WOLFSSL_MSG("mp_read_unsigned_bin failure");
 561                /* Don't return anything on failure. bn will be freed if set. */
 562                ret = NULL;
 563            }
 564            else {
 565                /* Don't free bn as we are returning it. */
 566                bn = NULL;
 567            }
 568        }
 569        else if (data == NULL) {
 570            wolfSSL_BN_zero(ret);
 571            /* Don't free bn as we are returning it. */
 572            bn = NULL;
 573        }
 574    }
 575
 576    /* Dispose of allocated BN not being returned. */
 577    wolfSSL_BN_free(bn);
 578
 579    return ret;
 580}
 581
 582/* Encode the big number value into a string, of the radix, that is allocated.
 583 *
 584 * @param [in] bn     Big number to encode.
 585 * @param [in] radix  Radix to encode to.
 586 * @return  String with encoding on success.
 587 * @return  NULL when bn or internal representation of bn is NULL.
 588 * @return  NULL on failure.
 589 */
 590static char* wolfssl_bn_bn2radix(const WOLFSSL_BIGNUM* bn, int radix)
 591{
 592    int err = 0;
 593    int len = 0;
 594    char* str = NULL;
 595
 596
 597    /* Validate parameter. */
 598    if (BN_IS_NULL(bn)) {
 599        WOLFSSL_MSG("bn NULL error");
 600        err = 1;
 601    }
 602
 603    /* Determine length of encoding. */
 604    if ((!err) && (mp_radix_size((mp_int*)bn->internal, radix, &len) !=
 605            MP_OKAY)) {
 606        WOLFSSL_MSG("mp_radix_size failure");
 607        err = 1;
 608    }
 609
 610    if (!err) {
 611        /* Allocate string. */
 612        str = (char*)XMALLOC((size_t)len, NULL, DYNAMIC_TYPE_OPENSSL);
 613        if (str == NULL) {
 614            WOLFSSL_MSG("BN_bn2hex malloc string failure");
 615            err = 1;
 616        }
 617    }
 618
 619    /* Encode into string using wolfCrypt. */
 620    if ((!err) && (mp_toradix((mp_int*)bn->internal, str, radix) != MP_OKAY)) {
 621        err = 1;
 622    }
 623
 624    if (err) {
 625        /* Dispose of dynamically allocated data. */
 626        XFREE(str, NULL, DYNAMIC_TYPE_OPENSSL);
 627        /* Don't return freed string. */
 628        str = NULL;
 629    }
 630    return str;
 631}
 632
 633/* Encode the big number value into hex string that is allocated.
 634 *
 635 * @param [in] bn  Big number to encode.
 636 * @return  String with encoding on success.
 637 * @return  NULL when bn or internal representation of bn is NULL.
 638 * @return  NULL on failure.
 639 */
 640char* wolfSSL_BN_bn2hex(const WOLFSSL_BIGNUM *bn)
 641{
 642    WOLFSSL_ENTER("wolfSSL_BN_bn2hex");
 643    return wolfssl_bn_bn2radix(bn, MP_RADIX_HEX);
 644}
 645
 646/* Decode string of a radix into a big number.
 647 *
 648 * If bn is a pointer to NULL, then a new big number is allocated and assigned.
 649 *
 650 * Note on use: this function expects str to be an even length. It is
 651 * converting pairs of bytes into 8-bit values. As an example, the RSA
 652 * public exponent is commonly 0x010001. To get it to convert, you need
 653 * to pass in the string "010001", it will fail if you use "10001". This
 654 * is an affect of how Base16_Decode() works.
 655 *
 656 * @param [in, out] bn     Pointer to a big number. May point to NULL.
 657 * @param [in]      str    Hex string to decode.
 658 * @param [in]      radix  Radix to decode from.
 659 * @return  1 on success.
 660 * @return  0 when bn or str is NULL or str is zero length.
 661 * @return  0 when creating a new big number fails.
 662 * @return  0 when decoding fails.
 663 */
 664static int wolfssl_bn_radix2bn(WOLFSSL_BIGNUM** bn, const char* str, int radix)
 665{
 666    int ret = 1;
 667    WOLFSSL_BIGNUM* a = NULL;
 668
 669    /* Validate parameters. */
 670    if ((bn == NULL) || (str == NULL) || (str[0] == '\0')) {
 671        WOLFSSL_MSG("Bad function argument");
 672        ret = 0;
 673    }
 674    /* Check if we have a big number to decode into. */
 675    if ((ret == 1) && (*bn == NULL)) {
 676        /* Allocate a new big number. */
 677        a = wolfSSL_BN_new();
 678        if (a == NULL) {
 679            WOLFSSL_MSG("BN new failed");
 680            ret = 0;
 681        }
 682        /* Return allocated big number. */
 683        *bn = a;
 684    }
 685    /* Decode hex string into internal representation. */
 686    if ((ret == 1) && (mp_read_radix((mp_int*)(*bn)->internal, str, radix) !=
 687            MP_OKAY)) {
 688        WOLFSSL_MSG("Bad read_radix error");
 689        ret = 0;
 690    }
 691
 692    if ((ret == 0) && (a != NULL)) {
 693        /* Dispose of big number. */
 694        wolfSSL_BN_free(a);
 695        /* Don't return freed big number. */
 696        *bn = NULL;
 697    }
 698    return ret;
 699}
 700
 701/* Decode hex string into a big number.
 702 *
 703 * If bn is a pointer to NULL, then a new big number is allocated and assigned.
 704 *
 705 * Note on use: this function expects str to be an even length. It is
 706 * converting pairs of bytes into 8-bit values. As an example, the RSA
 707 * public exponent is commonly 0x010001. To get it to convert, you need
 708 * to pass in the string "010001", it will fail if you use "10001". This
 709 * is an affect of how Base16_Decode() works.
 710 *
 711 * @param [in, out] bn   Pointer to a big number. May point to NULL.
 712 * @param [in]      str  Hex string to decode.
 713 * @return  1 on success.
 714 * @return  0 when bn or str is NULL or str is zero length.
 715 * @return  0 when creating a new big number fails.
 716 * @return  0 when decoding fails.
 717 */
 718int wolfSSL_BN_hex2bn(WOLFSSL_BIGNUM** bn, const char* str)
 719{
 720    WOLFSSL_ENTER("wolfSSL_BN_hex2bn");
 721    return wolfssl_bn_radix2bn(bn, str, MP_RADIX_HEX);
 722}
 723
 724#if defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY)
 725/* Encode big number into decimal string.
 726 *
 727 * @param [in] bn  Big number to encode.
 728 * @return  String with encoding on success.
 729 * @return  NULL when bn or internal representation of bn is NULL.
 730 * @return  NULL on failure.
 731 */
 732char* wolfSSL_BN_bn2dec(const WOLFSSL_BIGNUM *bn)
 733{
 734    WOLFSSL_ENTER("wolfSSL_BN_bn2hex");
 735    return wolfssl_bn_bn2radix(bn, MP_RADIX_DEC);
 736}
 737#else
 738/* Encode big number into decimal string.
 739 *
 740 * @param [in] bn  Big number to encode.
 741 * @return  NULL as implementation not available.
 742 */
 743char* wolfSSL_BN_bn2dec(const WOLFSSL_BIGNUM* bn)
 744{
 745    (void)bn;
 746    WOLFSSL_ENTER("wolfSSL_BN_bn2dec");
 747    return NULL;
 748}
 749#endif /* defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY) */
 750
 751
 752#ifndef NO_RSA
 753/* Decode hex string into a big number.
 754 *
 755 * If bn is a pointer to NULL, then a new big number is allocated and assigned.
 756 *
 757 * Note on use: this function expects str to be an even length. It is
 758 * converting pairs of bytes into 8-bit values. As an example, the RSA
 759 * public exponent is commonly 0x010001. To get it to convert, you need
 760 * to pass in the string "010001", it will fail if you use "10001". This
 761 * is an affect of how Base16_Decode() works.
 762 *
 763 * @param [in, out] bn   Pointer to a big number. May point to NULL.
 764 * @param [in]      str  Hex string to decode.
 765 * @return  1 on success.
 766 * @return  0 when bn or str is NULL or str is zero length.
 767 * @return  0 when creating a new big number fails.
 768 * @return  0 when decoding fails.
 769 */
 770int wolfSSL_BN_dec2bn(WOLFSSL_BIGNUM** bn, const char* str)
 771{
 772    WOLFSSL_ENTER("wolfSSL_BN_bn2dec");
 773    return wolfssl_bn_radix2bn(bn, str, MP_RADIX_DEC);
 774}
 775#else
 776/* Decode hex string into a big number.
 777 *
 778 * @param [in, out] bn   Pointer to a big number. May point to NULL.
 779 * @param [in]      str  Hex string to decode.
 780 * @return  0 as implementation not available..
 781 */
 782int wolfSSL_BN_dec2bn(WOLFSSL_BIGNUM** bn, const char* str)
 783{
 784    (void)bn;
 785    (void)str;
 786    WOLFSSL_ENTER("wolfSSL_BN_bn2dec");
 787    return 0;
 788}
 789#endif
 790
 791/*******************************************************************************
 792 * Get/Set APIs
 793 ******************************************************************************/
 794
 795/* Calculate the number of bytes need to represent big number.
 796 *
 797 * Return compliant with OpenSSL.
 798 *
 799 * @param [in] bn  Big number to use.
 800 * @return  Size of BIGNUM in bytes on success.
 801 * @return  0 when bn or internal representation of bn is NULL.
 802 */
 803int wolfSSL_BN_num_bytes(const WOLFSSL_BIGNUM* bn)
 804{
 805    int ret;
 806
 807    WOLFSSL_ENTER("wolfSSL_BN_num_bytes");
 808
 809    /* Validate parameter. */
 810    if (BN_IS_NULL(bn)) {
 811        ret = 0;
 812    }
 813    else {
 814        /* Get size from wolfCrypt. */
 815        ret = mp_unsigned_bin_size((mp_int*)bn->internal);
 816    }
 817
 818    return ret;
 819}
 820
 821/* Calculate the number of bits need to represent big number.
 822 *
 823 * Return compliant with OpenSSL.
 824 *
 825 * @param [in] bn  Big number to use.
 826 * @return  Size of BIGNUM in bits on success.
 827 * @return  0 when bn or internal representation of bn is NULL.
 828 */
 829int wolfSSL_BN_num_bits(const WOLFSSL_BIGNUM* bn)
 830{
 831    int ret;
 832
 833    WOLFSSL_ENTER("wolfSSL_BN_num_bits");
 834
 835    /* Validate parameter. */
 836    if (BN_IS_NULL(bn)) {
 837        ret = 0;
 838    }
 839    else {
 840        /* Get size from wolfCrypt. */
 841        ret = mp_count_bits((mp_int*)bn->internal);
 842    }
 843
 844    return ret;
 845}
 846
 847/* Indicates whether a big number is negative.
 848 *
 849 * @param [in] bn  Big number to use.
 850 * @return  1 when number is negative.
 851 * @return  0 when number is positive.
 852 * @return  0 when bn is NULL.
 853 */
 854int wolfSSL_BN_is_negative(const WOLFSSL_BIGNUM* bn)
 855{
 856    int ret;
 857
 858    /* Validate parameter. */
 859    if (BN_IS_NULL(bn)) {
 860        ret = 0;
 861    }
 862    else {
 863        /* Check sign with wolfCrypt. */
 864        ret = mp_isneg((mp_int*)bn->internal);
 865    }
 866
 867    return ret;
 868}
 869
 870/* Indicates whether a big number is odd.
 871 *
 872 * Return compliant with OpenSSL.
 873 *
 874 * @param [in] bn  Big number to use.
 875 * @return  1 when number is odd.
 876 * @return  0 when number is even.
 877 * @return  0 when bn or internal representation of bn is NULL.
 878 */
 879int wolfSSL_BN_is_odd(const WOLFSSL_BIGNUM* bn)
 880{
 881    int ret;
 882
 883    WOLFSSL_ENTER("wolfSSL_BN_is_odd");
 884
 885    /* Validate parameter. */
 886    if (BN_IS_NULL(bn)) {
 887        ret = 0;
 888    }
 889    else {
 890        /* wolfCrypt checks whether value is odd. */
 891        ret = (mp_isodd((mp_int*)bn->internal) == MP_YES);
 892    }
 893
 894    return ret;
 895}
 896
 897#ifndef NO_WOLFSSL_STUB
 898/* Mask the lowest n bits.
 899 *
 900 * TODO: mp_mod_2d()
 901 *
 902 * Return compliant with OpenSSL.
 903 *
 904 * @param [in, out] bn  Big number to operation on.
 905 * @param [in]      n   Number of bits.
 906 * @return  0 on failure.
 907 */
 908int wolfSSL_mask_bits(WOLFSSL_BIGNUM* bn, int n)
 909{
 910    (void)bn;
 911    (void)n;
 912    WOLFSSL_ENTER("wolfSSL_BN_mask_bits");
 913    WOLFSSL_STUB("BN_mask_bits");
 914    return 0;
 915}
 916#endif
 917
 918/* Set a bit of the value in a big number.
 919 *
 920 * Return code compliant with OpenSSL.
 921 *
 922 * @param [in, out] bn  Big number to modify.
 923 * @return  1 on success.
 924 * @return  0 when bn or internal representation of bn is NULL.
 925 * @return  0 when failed to set bit.
 926 */
 927int wolfSSL_BN_set_bit(WOLFSSL_BIGNUM* bn, int n)
 928{
 929    int ret = 1;
 930
 931    if (BN_IS_NULL(bn)) {
 932        WOLFSSL_MSG("bn NULL error");
 933        ret = 0;
 934    }
 935    else if (mp_set_bit((mp_int*)bn->internal, n) != MP_OKAY) {
 936        WOLFSSL_MSG("mp_set_bit error");
 937        ret = 0;
 938    }
 939
 940    return ret;
 941}
 942
 943/* Clear a bit of the value in a big number.
 944 *
 945 * Return code compliant with OpenSSL.
 946 *
 947 * @param [in] bn  Big number to check.
 948 * @param [in] n   Inidex of bit to check.
 949 * @return  1 on success.
 950 * @return  0 when bn or internal representation of bn is NULL.
 951 * @return  0 when failed to clear bit.
 952 */
 953int wolfSSL_BN_clear_bit(WOLFSSL_BIGNUM* bn, int n)
 954{
 955    int ret = 1;
 956    WC_DECLARE_VAR(tmp, mp_int, 1, 0);
 957
 958    /* Validate parameters. */
 959    if (BN_IS_NULL(bn) || (n < 0)) {
 960        WOLFSSL_MSG("bn NULL error");
 961        ret = 0;
 962    }
 963    /* Check if bit is set to clear. */
 964    if ((ret == 1) && (mp_is_bit_set((mp_int*)bn->internal, n))) {
 965        /* Allocate a new MP integer to hold bit to clear. */
 966        WC_ALLOC_VAR_EX(tmp, mp_int, 1, NULL, DYNAMIC_TYPE_BIGINT, ret=0);
 967        if (ret == 1) {
 968            /* Reset new MP integer. */
 969            XMEMSET(tmp, 0, sizeof(mp_int));
 970            if (mp_init(tmp) != MP_OKAY) {
 971                ret = 0;
 972            }
 973        }
 974        /* Set the bit to clear into temporary MP integer. */
 975        if ((ret == 1) && (mp_set_bit(tmp, n) != MP_OKAY)) {
 976            ret = 0;
 977        }
 978        /* Clear bit by sutraction. */
 979        if ((ret == 1) && (mp_sub((mp_int*)bn->internal, tmp,
 980                (mp_int*)bn->internal) != MP_OKAY)) {
 981            ret = 0;
 982        }
 983
 984        /* Free any dynamic memory in MP integer. */
 985        mp_clear(tmp);
 986        WC_FREE_VAR_EX(tmp, NULL, DYNAMIC_TYPE_BIGINT);
 987    }
 988
 989    return ret;
 990}
 991
 992/* Returns whether the bit is set in the value of the big number.
 993 *
 994 * When bn is NULL, returns 0.
 995 *
 996 * Return code compliant with OpenSSL.
 997 *
 998 * @param [in] bn  Big number to check.
 999 * @param [in] n   Inidex of bit to check.
1000 * @return  1 if bit set.
1001 * @return  0 otherwise.
1002 */
1003int wolfSSL_BN_is_bit_set(const WOLFSSL_BIGNUM* bn, int n)
1004{
1005    int ret;
1006
1007    /* Check for big number value. */
1008    if (BN_IS_NULL(bn) || (n < 0)) {
1009        WOLFSSL_MSG("bn NULL error");
1010        ret = 0;
1011    }
1012    else {
1013        /* Set bit with wolfCrypt. */
1014        ret = mp_is_bit_set((mp_int*)bn->internal, (mp_digit)n);
1015    }
1016
1017    return ret;
1018}
1019
1020/* Set the big number to the value 0.
1021 *
1022 * @param [in, out] bn  Big number to use.
1023 */
1024void wolfSSL_BN_zero(WOLFSSL_BIGNUM* bn)
1025{
1026    /* Validate parameter. */
1027    if (!BN_IS_NULL(bn)) {
1028        /* Set wolfCrypt representation to 0. */
1029        mp_zero((mp_int*)bn->internal);
1030    }
1031}
1032
1033/* Set the big number to the value 0.
1034 *
1035 * @param [in, out] bn  Big number to use.
1036 * @return  1 on success.
1037 * @return  0 when bn or internal representation of bn is NULL.
1038 */
1039int wolfSSL_BN_one(WOLFSSL_BIGNUM* bn)
1040{
1041    int ret;
1042
1043    /* Validate parameter. */
1044    if (BN_IS_NULL(bn)) {
1045        ret = 0;
1046    }
1047    else {
1048        /* Set to value one. */
1049        ret = wolfSSL_BN_set_word(bn, 1);
1050    }
1051
1052    return ret;
1053}
1054
1055/* Get the value of the MP integer as a word.
1056 *
1057 * Assumes the MP integer value will fit in a word.
1058 *
1059 * @param [in] mp  MP integer.
1060 * @return  Value of MP integer as an unsigned long.
1061 */
1062static WOLFSSL_BN_ULONG wolfssl_bn_get_word_1(mp_int *mp) {
1063#if DIGIT_BIT >= (SIZEOF_LONG * CHAR_BIT)
1064    return (WOLFSSL_BN_ULONG)mp->dp[0];
1065#else
1066    WOLFSSL_BN_ULONG ret = 0UL;
1067    unsigned int i;
1068
1069    for (i = 0; i < (unsigned int)mp->used; ++i) {
1070        ret |= ((WOLFSSL_BN_ULONG)mp->dp[i]) << (DIGIT_BIT * i);
1071    }
1072
1073    return ret;
1074#endif
1075}
1076
1077/* Return the value of big number as an unsigned long if possible.
1078 *
1079 * @param [in] bn  Big number to get value from.
1080 * @return  Value or 0xFFFFFFFFL if bigger than unsigned long.
1081 */
1082WOLFSSL_BN_ULONG wolfSSL_BN_get_word(const WOLFSSL_BIGNUM* bn)
1083{
1084    WOLFSSL_BN_ULONG ret;
1085
1086    WOLFSSL_ENTER("wolfSSL_BN_get_word");
1087
1088    /* Validate parameter. */
1089    if (BN_IS_NULL(bn)) {
1090        WOLFSSL_MSG("Invalid argument");
1091        ret = 0;
1092    }
1093    /* Check whether big number is to fit in an unsigned long. */
1094    else if (wolfSSL_BN_num_bytes(bn) > (int)sizeof(unsigned long)) {
1095        WOLFSSL_MSG("bignum is larger than unsigned long");
1096        ret = WOLFSSL_BN_MAX_VAL;
1097    }
1098    else {
1099        /* Get the word from the internal representation. */
1100        ret = wolfssl_bn_get_word_1((mp_int*)bn->internal);
1101    }
1102
1103    return ret;
1104}
1105
1106/* Set the big number to the value in the word.
1107 *
1108 * Return code compliant with OpenSSL.
1109 *
1110 * @param [in, out] bn  Big number to set.
1111 * @param [in       w   Word to set.
1112 * @return  1 on success.
1113 * @return  0 when bn is NULL or setting value failed.
1114 */
1115int wolfSSL_BN_set_word(WOLFSSL_BIGNUM* bn, unsigned long w)
1116{
1117    int ret = 1;
1118
1119    WOLFSSL_ENTER("wolfSSL_BN_set_word");
1120
1121    /* Validate parameters. */
1122    if (BN_IS_NULL(bn)) {
1123        WOLFSSL_MSG("bn NULL error");
1124        ret = 0;
1125    }
1126
1127    /* Set the word into the internal representation. */
1128    if ((ret == 1) && (mp_set_int((mp_int*)bn->internal, w) != MP_OKAY)) {
1129        WOLFSSL_MSG("mp_init_set_int error");
1130        ret = 0;
1131    }
1132
1133    return ret;
1134}
1135
1136/*******************************************************************************
1137 * Comparison APIs
1138 ******************************************************************************/
1139
1140/* Compares two big numbers. a <=> b
1141 *
1142 * NULL equals NULL
1143 * NULL less than not NULL
1144 * not NULL greater than NULL.
1145 *
1146 * Return compliant with OpenSSL.
1147 *
1148 * @param [in] bn  First big number to compare.
1149 * @param [in] bn  Second big number to compare.
1150 * @return  -1 when a is less than b (a < b).
1151 * @return  0 when a is equal to b (a == b).
1152 * @return  1 when a is greater than b (a > b).
1153 * @return  0 when bn or internal representation of bn is NULL.
1154 */
1155int wolfSSL_BN_cmp(const WOLFSSL_BIGNUM* a, const WOLFSSL_BIGNUM* b)
1156{
1157    int ret;
1158    int bIsNull;
1159
1160    WOLFSSL_ENTER("wolfSSL_BN_cmp");
1161
1162    /* Must know whether b is NULL. */
1163    bIsNull = BN_IS_NULL(b);
1164    /* Check whether a is NULL. */
1165    if (BN_IS_NULL(a)) {
1166        if (bIsNull) {
1167            /* NULL equals NULL. */
1168            ret = 0;
1169        }
1170        else {
1171            ret = -1; /* NULL less than not NULL. */
1172        }
1173    }
1174    else if (bIsNull) {
1175        /* not NULL greater than NULL. */
1176        ret = 1;
1177    }
1178    else {
1179        PRAGMA_GCC_DIAG_PUSH
1180        PRAGMA_GCC("GCC diagnostic ignored \"-Wduplicated-branches\"")
1181        /* Compare big numbers with wolfCrypt. */
1182        ret = mp_cmp((mp_int*)a->internal, (mp_int*)b->internal);
1183        /* Convert wolfCrypt return value. */
1184        if (ret == MP_EQ) {
1185            ret = 0;
1186        }
1187        else if (ret == MP_GT) {
1188            ret = 1;
1189        }
1190        else if (ret == MP_LT) {
1191            ret = -1;
1192        }
1193        else {
1194            /* ignored warning here because the same return value
1195               was intentional */
1196            ret = WOLFSSL_FATAL_ERROR; /* also -1 */
1197        }
1198        PRAGMA_GCC_DIAG_POP
1199    }
1200
1201    return ret;
1202}
1203
1204/* Same as above, but compare absolute value. */
1205int wolfSSL_BN_ucmp(const WOLFSSL_BIGNUM* a, const WOLFSSL_BIGNUM* b)
1206{
1207    int ret = 0;
1208    int bIsNull;
1209
1210    WOLFSSL_ENTER("wolfSSL_BN_ucmp");
1211
1212    /* Must know whether b is NULL. */
1213    bIsNull = BN_IS_NULL(b);
1214    /* Check whether a is NULL. */
1215    if (BN_IS_NULL(a)) {
1216        if (bIsNull) {
1217            /* NULL equals NULL. */
1218            ret = 0;
1219        }
1220        else {
1221            ret = -1; /* NULL less than not NULL. */
1222        }
1223    }
1224    else if (bIsNull) {
1225        /* not NULL greater than NULL. */
1226        ret = 1;
1227    }
1228    else {
1229        /* Neither are NULL; copy to new instances and switch to positive if
1230         * required, compare, and then free.  Must copy because there is
1231         * possibility of switch to positive but they are declared const.
1232         * wolfssl_bn_set_neg() only returns -1 if the bn is NULL, but we
1233         * already check that so we can ignore the return code. Note for
1234         * wolfSSL_BN_is_negative if n=1 then set to positive. */
1235        WOLFSSL_BIGNUM* abs_a = wolfSSL_BN_dup(a);
1236        WOLFSSL_BIGNUM* abs_b = wolfSSL_BN_dup(b);
1237
1238        if (abs_a == NULL || abs_b == NULL) {
1239            WOLFSSL_MSG("wolfSSL_BN_dup failed");
1240            wolfSSL_BN_free(abs_a);
1241            wolfSSL_BN_free(abs_b);
1242            return WOLFSSL_FATAL_ERROR;
1243        }
1244
1245        if (wolfSSL_BN_is_negative(abs_a)) {
1246            wolfssl_bn_set_neg(abs_a, 1);
1247        }
1248
1249        if (wolfSSL_BN_is_negative(abs_b)) {
1250            wolfssl_bn_set_neg(abs_b, 1);
1251        }
1252
1253        ret = wolfSSL_BN_cmp(abs_a, abs_b);
1254        wolfSSL_BN_free(abs_a);
1255        wolfSSL_BN_free(abs_b);
1256    }
1257    return ret;
1258}
1259
1260/* Indicates whether a big number is the value 0.
1261 *
1262 * Return compliant with OpenSSL.
1263 *
1264 * @param [in] bn  Big number to use.
1265 * @return  1 when number is zero.
1266 * @return  0 when number is not zero.
1267 * @return  0 when bn or internal representation of bn is NULL.
1268 */
1269int wolfSSL_BN_is_zero(const WOLFSSL_BIGNUM* bn)
1270{
1271    int ret;
1272
1273    WOLFSSL_ENTER("wolfSSL_BN_is_zero");
1274
1275    /* Validate parameter. */
1276    if (BN_IS_NULL(bn)) {
1277        ret = 0;
1278    }
1279    else {
1280        /* wolfCrypt checks whether value is 0. */
1281        ret = (mp_iszero((mp_int*)bn->internal) == MP_YES);
1282    }
1283
1284    return ret;
1285}
1286
1287/* Indicates whether a big number is the value 1.
1288 *
1289 * Return compliant with OpenSSL.
1290 *
1291 * @param [in] bn  Big number to use.
1292 * @return  1 when number is one.
1293 * @return  0 when number is not one.
1294 * @return  0 when bn or internal representation of bn is NULL.
1295 */
1296int wolfSSL_BN_is_one(const WOLFSSL_BIGNUM* bn)
1297{
1298    int ret;
1299
1300    WOLFSSL_ENTER("wolfSSL_BN_is_one");
1301
1302    /* Validate parameter. */
1303    if (BN_IS_NULL(bn)) {
1304        ret = 0;
1305    }
1306    else {
1307        /* wolfCrypt checks whether value is 1. */
1308        ret = (mp_cmp_d((mp_int*)bn->internal, 1) == MP_EQ);
1309    }
1310
1311    return ret;
1312}
1313
1314/* Indicates whether a big number is the value passed in.
1315 *
1316 * Return compliant with OpenSSL.
1317 *
1318 * @param [in] bn  Big number to use.
1319 * @return  1 when big number is the value.
1320 * @return  0 when big number is not the value.
1321 * @return  0 when bn or internal representation of bn is NULL.
1322 */
1323int wolfSSL_BN_is_word(const WOLFSSL_BIGNUM* bn, WOLFSSL_BN_ULONG w)
1324{
1325    int ret;
1326
1327    WOLFSSL_ENTER("wolfSSL_BN_is_word");
1328
1329    /* Validate parameter. */
1330    if (BN_IS_NULL(bn)) {
1331        WOLFSSL_MSG("bn NULL error");
1332        ret = 0;
1333    }
1334    else
1335#if DIGIT_BIT < (SIZEOF_LONG * CHAR_BIT)
1336    /* When value is greater than what can be stored in one digit - special
1337     * case. */
1338    if (w > (WOLFSSL_BN_ULONG)MP_MASK) {
1339        /* TODO: small stack */
1340        mp_int w_mp;
1341
1342        /* Create a MP to hold the number. */
1343        if (mp_init(&w_mp) != MP_OKAY) {
1344            ret = 0;
1345        }
1346        /* Set the value - held in more than one digit. */
1347        else if (mp_set_int(&w_mp, w) != MP_OKAY) {
1348            ret = 0;
1349        }
1350        else {
1351            /* Compare MP representations. */
1352            ret = (mp_cmp((mp_int *)bn->internal, &w_mp) == MP_EQ);
1353            mp_free(&w_mp);
1354        }
1355    }
1356    else
1357#endif
1358    {
1359        /* wolfCrypt checks whether it is the value. */
1360        ret = (mp_isword((mp_int*)bn->internal, (mp_digit)w) == MP_YES);
1361    }
1362
1363    return ret;
1364}
1365
1366
1367/*******************************************************************************
1368 * Word operation APIs.
1369 ******************************************************************************/
1370
1371enum BN_WORD_OP {
1372    BN_WORD_ADD = 0,
1373    BN_WORD_SUB = 1,
1374    BN_WORD_MUL = 2,
1375    BN_WORD_DIV = 3,
1376    BN_WORD_MOD = 4
1377};
1378
1379/* Helper function for word operations.
1380 *
1381 * @param [in, out] bn  Big number to operate on.
1382 * @param [in]      w   Word to operate with.
1383 * @param [in]      op  Operation to perform. See BN_WORD_OP for valid values.
1384 * @param [out]     mod_res Result of the modulo operation.
1385 * @return  1 on success.
1386 * @return  0 on failure.
1387 */
1388static int bn_word_helper(const WOLFSSL_BIGNUM *bn, WOLFSSL_BN_ULONG w,
1389        enum BN_WORD_OP op, WOLFSSL_BN_ULONG* mod_res)
1390{
1391    int ret = 1;
1392
1393    WOLFSSL_ENTER("bn_word_helper");
1394
1395    /* Validate parameters. */
1396    if (ret == 1 && BN_IS_NULL(bn)) {
1397        WOLFSSL_MSG("bn NULL error");
1398        ret = 0;
1399    }
1400
1401    if (ret == 1) {
1402        int rc = MP_OKAY;
1403#if DIGIT_BIT < (SIZEOF_LONG * CHAR_BIT)
1404        /* When input 'w' is greater than what can be stored in one digit */
1405        if (w > (WOLFSSL_BN_ULONG)MP_MASK) {
1406            DECL_MP_INT_SIZE_DYN(w_mp, sizeof(WOLFSSL_BN_ULONG) * CHAR_BIT,
1407                                       sizeof(WOLFSSL_BN_ULONG) * CHAR_BIT);
1408            NEW_MP_INT_SIZE(w_mp, sizeof(WOLFSSL_BN_ULONG) * CHAR_BIT, NULL,
1409                    DYNAMIC_TYPE_TMP_BUFFER);
1410#ifdef MP_INT_SIZE_CHECK_NULL
1411            if (w_mp == NULL) {
1412                WOLFSSL_MSG("NEW_MP_INT_SIZE error");
1413                ret = 0;
1414            }
1415#endif
1416            if (ret == 1 && mp_set_int(w_mp, w) != MP_OKAY) {
1417                WOLFSSL_MSG("mp_set_int error");
1418                ret = 0;
1419            }
1420            if (ret == 1) {
1421                switch (op) {
1422                    case BN_WORD_ADD:
1423                        rc = mp_add((mp_int*)bn->internal, w_mp,
1424                                (mp_int*)bn->internal);
1425                        break;
1426                    case BN_WORD_SUB:
1427                        rc = mp_sub((mp_int*)bn->internal, w_mp,
1428                                (mp_int*)bn->internal);
1429                        break;
1430                    case BN_WORD_MUL:
1431                        rc = mp_mul((mp_int*)bn->internal, w_mp,
1432                                (mp_int*)bn->internal);
1433                        break;
1434                    case BN_WORD_DIV:
1435                        rc = mp_div((mp_int*)bn->internal, w_mp,
1436                                (mp_int*)bn->internal, NULL);
1437                        break;
1438                    case BN_WORD_MOD:
1439                        rc = mp_mod((mp_int*) bn->internal, w_mp,
1440                                w_mp);
1441                        if (rc == MP_OKAY && mod_res != NULL)
1442                            *mod_res = wolfssl_bn_get_word_1(w_mp);
1443                        break;
1444                    default:
1445                        rc = WOLFSSL_NOT_IMPLEMENTED;
1446                        break;
1447                }
1448            }
1449            FREE_MP_INT_SIZE(w_mp, NULL, DYNAMIC_TYPE_RSA);
1450        }
1451        else
1452#endif
1453        {
1454            switch (op) {
1455                case BN_WORD_ADD:
1456                    rc = mp_add_d((mp_int*)bn->internal, (mp_digit)w,
1457                            (mp_int*)bn->internal);
1458                    break;
1459                case BN_WORD_SUB:
1460                    rc = mp_sub_d((mp_int*)bn->internal, (mp_digit)w,
1461                            (mp_int*)bn->internal);
1462                    break;
1463                case BN_WORD_MUL:
1464                    rc = mp_mul_d((mp_int*)bn->internal, (mp_digit)w,
1465                            (mp_int*)bn->internal);
1466                    break;
1467                case BN_WORD_DIV:
1468#if defined(WOLFSSL_SP_MATH) || defined(WOLFSSL_SP_MATH_ALL)
1469/* copied from sp_int.h */
1470#if (defined(WOLFSSL_SP_MATH_ALL) && !defined(WOLFSSL_RSA_VERIFY_ONLY)) || \
1471    defined(WOLFSSL_KEY_GEN) || defined(HAVE_COMP_KEY) || \
1472    defined(WC_MP_TO_RADIX)
1473                    rc = mp_div_d((mp_int*)bn->internal, (mp_digit)w,
1474                            (mp_int*)bn->internal, NULL);
1475#else
1476                    rc = WOLFSSL_NOT_IMPLEMENTED;
1477#endif
1478#else
1479                    rc = WOLFSSL_NOT_IMPLEMENTED;
1480#endif
1481                    break;
1482                case BN_WORD_MOD:
1483                    {
1484                        mp_digit _mod_res;
1485                        rc = mp_mod_d((mp_int*) bn->internal, (mp_digit) w,
1486                                &_mod_res);
1487                        if (rc == MP_OKAY && mod_res != NULL)
1488                            *mod_res = (WOLFSSL_BN_ULONG)_mod_res;
1489                    }
1490                    break;
1491                default:
1492                    rc = WOLFSSL_NOT_IMPLEMENTED;
1493                    break;
1494            }
1495        }
1496        if (ret == 1 && rc != MP_OKAY) {
1497            WOLFSSL_MSG("mp word operation error or not implemented");
1498            ret = 0;
1499        }
1500    }
1501
1502    WOLFSSL_LEAVE("bn_word_helper", ret);
1503
1504    return ret;
1505}
1506
1507/* Add a word to a big number.
1508 *
1509 * Return code compliant with OpenSSL.
1510 *
1511 * @param [in, out] bn   Big number to operate on.
1512 * @param [in]      w    Word to operate with.
1513 * @return  1 on success.
1514 * @return  0 in failure.
1515 */
1516int wolfSSL_BN_add_word(WOLFSSL_BIGNUM *bn, WOLFSSL_BN_ULONG w)
1517{
1518    int ret;
1519
1520    WOLFSSL_ENTER("wolfSSL_BN_add_word");
1521
1522    ret = bn_word_helper(bn, w, BN_WORD_ADD, NULL);
1523
1524    WOLFSSL_LEAVE("wolfSSL_BN_add_word", ret);
1525
1526    return ret;
1527}
1528
1529/* Subtract a word from a big number.
1530 *
1531 * Return code compliant with OpenSSL.
1532 *
1533 * @param [in, out] bn   Big number to operate on.
1534 * @param [in]      w    Word to operate with.
1535 * @return  1 on success.
1536 * @return  0 in failure.
1537 */
1538int wolfSSL_BN_sub_word(WOLFSSL_BIGNUM* bn, WOLFSSL_BN_ULONG w)
1539{
1540    int ret;
1541
1542    WOLFSSL_ENTER("wolfSSL_BN_sub_word");
1543
1544    ret = bn_word_helper(bn, w, BN_WORD_SUB, NULL);
1545
1546    WOLFSSL_LEAVE("wolfSSL_BN_sub_word", ret);
1547
1548    return ret;
1549}
1550
1551int wolfSSL_BN_mul_word(WOLFSSL_BIGNUM *bn, WOLFSSL_BN_ULONG w)
1552{
1553    int ret;
1554
1555    WOLFSSL_ENTER("wolfSSL_BN_mul_word");
1556
1557    ret = bn_word_helper(bn, w, BN_WORD_MUL, NULL);
1558
1559    WOLFSSL_LEAVE("wolfSSL_BN_mul_word", ret);
1560
1561    return ret;
1562}
1563
1564
1565int wolfSSL_BN_div_word(WOLFSSL_BIGNUM *bn, WOLFSSL_BN_ULONG w)
1566{
1567    int ret;
1568
1569    WOLFSSL_ENTER("wolfSSL_BN_div_word");
1570
1571    ret = bn_word_helper(bn, w, BN_WORD_DIV, NULL);
1572
1573    WOLFSSL_LEAVE("wolfSSL_BN_div_word", ret);
1574
1575    return ret;
1576}
1577
1578#if defined(WOLFSSL_KEY_GEN) && (!defined(NO_RSA) || !defined(NO_DH) || \
1579    !defined(NO_DSA))
1580/* Calculate bn modulo word w. bn % w
1581 *
1582 * Return code compliant with OpenSSL.
1583 *
1584 * @return  Word result on success
1585 * @return  -1 on error
1586 */
1587WOLFSSL_BN_ULONG wolfSSL_BN_mod_word(const WOLFSSL_BIGNUM *bn,
1588    WOLFSSL_BN_ULONG w)
1589{
1590    int ret;
1591    WOLFSSL_BN_ULONG res = 0;
1592
1593    WOLFSSL_ENTER("wolfSSL_BN_mod_word");
1594
1595    ret = bn_word_helper(bn, w, BN_WORD_MOD, &res);
1596
1597    WOLFSSL_LEAVE("wolfSSL_BN_mod_word", ret);
1598
1599    return ret == 1 ? res : (WOLFSSL_BN_ULONG)-1;
1600}
1601#endif /* WOLFSSL_KEY_GEN && (!NO_RSA || !NO_DH || !NO_DSA) */
1602
1603/*******************************************************************************
1604 * Shift APIs
1605 ******************************************************************************/
1606
1607#ifndef WOLFSSL_SP_MATH
1608/* Shift the value in bn left by n bits into r. r = bn << n
1609 *
1610 * Return code compliant with OpenSSL.
1611 *
1612 * @return  1 on success.
1613 * @return  0 when r or bn or internal representation is NULL.
1614 * @return  0 on failure.
1615 */
1616int wolfSSL_BN_lshift(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *bn, int n)
1617{
1618    int ret = 1;
1619
1620    WOLFSSL_ENTER("wolfSSL_BN_lshift");
1621
1622    /* Validate parameters. */
1623    if (BN_IS_NULL(r) || BN_IS_NULL(bn)) {
1624        WOLFSSL_MSG("bn NULL error");
1625        ret = 0;
1626    }
1627    else if (n < 0) {
1628        WOLFSSL_MSG("n value error");
1629        ret = 0;
1630    }
1631
1632    /* Use wolfCrypt perform operation. */
1633    if ((ret == 1) && (mp_mul_2d((mp_int*)bn->internal, n,
1634            (mp_int*)r->internal) != MP_OKAY)) {
1635        WOLFSSL_MSG("mp_mul_2d error");
1636        ret = 0;
1637    }
1638
1639    return ret;
1640}
1641
1642/* Shift the value in bn right by n bits into r. r = bn >> n
1643 *
1644 * Return code compliant with OpenSSL.
1645 *
1646 * @return  1 on success.
1647 * @return  0 when r or bn or internal representation is NULL.
1648 * @return  0 on failure.
1649 */
1650int wolfSSL_BN_rshift(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *bn, int n)
1651{
1652    int ret = 1;
1653
1654    WOLFSSL_ENTER("wolfSSL_BN_rshift");
1655
1656    /* Validate parameters. */
1657    if (BN_IS_NULL(r) || BN_IS_NULL(bn)) {
1658        WOLFSSL_MSG("bn NULL error");
1659        ret = 0;
1660    }
1661    else if (n < 0) {
1662        WOLFSSL_MSG("n value error");
1663        ret = 0;
1664    }
1665
1666    /* Use wolfCrypt perform operation. */
1667    if ((ret == 1) && (mp_div_2d((mp_int*)bn->internal, n, (mp_int*)r->internal,
1668            NULL) != MP_OKAY)) {
1669        WOLFSSL_MSG("mp_mul_2d error");
1670        ret = 0;
1671    }
1672
1673    return ret;
1674}
1675#endif
1676
1677/*******************************************************************************
1678 * Simple Math APIs
1679 ******************************************************************************/
1680
1681/* Add a to b into r. r = a + b
1682 *
1683 * Return code compliant with OpenSSL.
1684 *
1685 * @param [out] r  Big number to put result into.
1686 * @param [in]  a  Big number to be added to.
1687 * @param [in]  b  Big number to add with.
1688 *
1689 * @return  1 on success.
1690 * @return  0 when r, a or b or internal representation is NULL.
1691 * @return  0 on failure.
1692 */
1693int wolfSSL_BN_add(WOLFSSL_BIGNUM *r, WOLFSSL_BIGNUM *a, WOLFSSL_BIGNUM *b)
1694{
1695    int ret = 1;
1696
1697    WOLFSSL_ENTER("wolfSSL_BN_add");
1698
1699    /* Validate parameters. */
1700    if (BN_IS_NULL(r) || BN_IS_NULL(a) || BN_IS_NULL(b)) {
1701        WOLFSSL_MSG("bn NULL error");
1702        ret = 0;
1703    }
1704
1705    /* Add the internal representations into internal representation. */
1706    if ((ret == 1) && (mp_add((mp_int*)a->internal, (mp_int*)b->internal,
1707            (mp_int*)r->internal) != MP_OKAY)) {
1708        WOLFSSL_MSG("mp_add_d error");
1709        ret = 0;
1710    }
1711
1712    return ret;
1713}
1714
1715/* Subtract a from b into r. r = a - b
1716 *
1717 * @param [out] r  Big number to put result into.
1718 * @param [in]  a  Big number to be subtracted from.
1719 * @param [in]  b  Big number to subtract with.
1720 *
1721 * @return  1 on success.
1722 * @return  0 when r, a or b is NULL.
1723 * @return  0 on failure.
1724 */
1725int wolfSSL_BN_sub(WOLFSSL_BIGNUM* r, const WOLFSSL_BIGNUM* a,
1726    const WOLFSSL_BIGNUM* b)
1727{
1728    int ret = 1;
1729
1730    WOLFSSL_ENTER("wolfSSL_BN_sub");
1731
1732    /* Validate parameters. */
1733    if (BN_IS_NULL(r) || BN_IS_NULL(a) || BN_IS_NULL(b)) {
1734        ret = 0;
1735    }
1736
1737    /* Have wolfCrypt perform operation with internal representations. */
1738    if ((ret == 1) && (mp_sub((mp_int*)a->internal,(mp_int*)b->internal,
1739            (mp_int*)r->internal) != MP_OKAY)) {
1740        ret = 0;
1741    }
1742
1743    WOLFSSL_LEAVE("wolfSSL_BN_sub mp_sub", ret);
1744    return ret;
1745}
1746
1747/* Multiply a with b into r. r = a * b
1748 *
1749 * @param [out] r    Big number to put result into.
1750 * @param [in]  a    Big number to be multiplied.
1751 * @param [in]  b    Big number to multiply with.
1752 * @param [in]  ctx  BN context object. Unused.
1753 *
1754 * @return  1 on success.
1755 * @return  0 when r, a or b is NULL.
1756 * @return  0 when internal representation of r, a or b is NULL.
1757 * @return  0 on failure.
1758 */
1759int wolfSSL_BN_mul(WOLFSSL_BIGNUM *r, WOLFSSL_BIGNUM *a, WOLFSSL_BIGNUM *b,
1760    WOLFSSL_BN_CTX *ctx)
1761{
1762    int ret = 1;
1763
1764    (void)ctx;
1765
1766    WOLFSSL_ENTER("wolfSSL_BN_mul");
1767
1768    /* Validate parameters. */
1769    if (BN_IS_NULL(r) || BN_IS_NULL(a) || BN_IS_NULL(b)) {
1770        ret = 0;
1771    }
1772
1773    /* Have wolfCrypt perform operation with internal representations. */
1774    if ((ret == 1) && (mp_mul((mp_int*)a->internal, (mp_int*)b->internal,
1775            (mp_int*)r->internal) != MP_OKAY)) {
1776        ret = 0;
1777    }
1778
1779    WOLFSSL_LEAVE("wolfSSL_BN_mul", ret);
1780    return ret;
1781}
1782
1783#ifndef WOLFSSL_SP_MATH
1784/* Divide a by b into dv and put remainder into rem. dv = a / b, rem = a % b
1785 *
1786 * @param [out] dv   Big number to put division result into.
1787 * @param [out] rem  Big number to put remainder into.
1788 * @param [in]  a    Big number to be divided.
1789 * @param [in]  b    Big number to divide with.
1790 * @param [in]  ctx  BN context object. Unused.
1791 *
1792 * @return  1 on success.
1793 * @return  0 when dv, rem, a or b is NULL.
1794 * @return  0 when internal representation of dv, rem, a or b is NULL.
1795 * @return  0 on failure.
1796 */
1797int wolfSSL_BN_div(WOLFSSL_BIGNUM* dv, WOLFSSL_BIGNUM* rem,
1798    const WOLFSSL_BIGNUM* a, const WOLFSSL_BIGNUM* d, WOLFSSL_BN_CTX* ctx)
1799{
1800    int ret = 1;
1801    WOLFSSL_BIGNUM* res = dv;
1802
1803    /* BN context not needed. */
1804    (void)ctx;
1805
1806    WOLFSSL_ENTER("wolfSSL_BN_div");
1807
1808    if (BN_IS_NULL(res)) {
1809        res = wolfSSL_BN_new();
1810    }
1811
1812    /* Validate parameters. */
1813    if (BN_IS_NULL(res) || BN_IS_NULL(rem) || BN_IS_NULL(a) || BN_IS_NULL(d)) {
1814        ret = 0;
1815    }
1816
1817    /* Have wolfCrypt perform operation with internal representations. */
1818    if ((ret == 1) && (mp_div((mp_int*)a->internal, (mp_int*)d->internal,
1819            (mp_int*)res->internal, (mp_int*)rem->internal) != MP_OKAY)) {
1820        ret = 0;
1821    }
1822
1823    if (res != dv)
1824        wolfSSL_BN_free(res);
1825
1826    WOLFSSL_LEAVE("wolfSSL_BN_div", ret);
1827    return ret;
1828}
1829#endif
1830
1831/* Calculate a mod b into r. r = a % b
1832 *
1833 * @param [out] r    Big number to put result into.
1834 * @param [in]  a    Big number to reduced
1835 * @param [in]  b    Big number to reduce with.
1836 * @param [in]  ctx  BN context object. Unused.
1837 *
1838 * @return  1 on success.
1839 * @return  0 when r, a or b is NULL.
1840 * @return  0 on failure.
1841 */
1842int wolfSSL_BN_mod(WOLFSSL_BIGNUM* r, const WOLFSSL_BIGNUM* a,
1843                  const WOLFSSL_BIGNUM* b, const WOLFSSL_BN_CTX* c)
1844{
1845    int ret = 1;
1846
1847    (void)c;
1848
1849    WOLFSSL_ENTER("wolfSSL_BN_mod");
1850
1851    /* Validate parameters. */
1852    if (BN_IS_NULL(r) || BN_IS_NULL(a) || BN_IS_NULL(b)) {
1853        ret = 0;
1854    }
1855
1856    /* Have wolfCrypt perform operation with internal representations. */
1857    if ((ret == 1) && (mp_mod((mp_int*)a->internal,(mp_int*)b->internal,
1858            (mp_int*)r->internal) != MP_OKAY)) {
1859        ret = 0;
1860    }
1861
1862    WOLFSSL_LEAVE("wolfSSL_BN_mod mp_mod", ret);
1863    return ret;
1864}
1865
1866/*******************************************************************************
1867 * Math and Mod APIs
1868 ******************************************************************************/
1869
1870#ifndef WOLFSSL_SP_MATH
1871/* Add a to b modulo m into r. r = a + b (mod m)
1872 *
1873 * @param [in, out] r    Big number to hold result.
1874 * @param [in]      a    Big number to add to.
1875 * @param [in]      b    Big number to add with.
1876 * @param [in]      m    Big number that is the modulus.
1877 * @param [in]      ctx  BN context. Not used.
1878 * @return  1 on success.
1879 * @return  0 when r, a or b or internal representation is NULL.
1880 * @return  0 on calculation failure.
1881 */
1882int wolfSSL_BN_mod_add(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *a,
1883    const WOLFSSL_BIGNUM *b, const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx)
1884{
1885    int ret = 1;
1886
1887    /* BN context not needed. */
1888    (void)ctx;
1889
1890    WOLFSSL_ENTER("wolfSSL_BN_add");
1891
1892    /* Validate parameters. */
1893    if (BN_IS_NULL(r) || BN_IS_NULL(a) || BN_IS_NULL(b) || BN_IS_NULL(m)) {
1894        WOLFSSL_MSG("bn NULL error");
1895        ret = 0;
1896    }
1897
1898    /* Perform operation with wolfCrypt. */
1899    if ((ret == 1) && (mp_addmod((mp_int*)a->internal, (mp_int*)b->internal,
1900            (mp_int*)m->internal, (mp_int*)r->internal) != MP_OKAY)) {
1901        WOLFSSL_MSG("mp_add_d error");
1902        ret = 0;
1903    }
1904
1905    return ret;
1906}
1907#endif
1908
1909/* Calculate a multiplied by b, mod m into r. r = (a * b) % m
1910 *
1911 * @param [out] r    Big number to put result into.
1912 * @param [in]  a    Base as a big number.
1913 * @param [in]  b    Multiplier as a big number.
1914 * @param [in]  m    Modulus as a big number.
1915 * @param [in]  ctx  BN context object. Unused.
1916 *
1917 * @return  1 on success.
1918 * @return  0 when r, a, b or m is NULL.
1919 * @return  0 on failure.
1920 */
1921int wolfSSL_BN_mod_mul(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *a,
1922    const WOLFSSL_BIGNUM *b, const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx)
1923{
1924    int ret = 1;
1925
1926    /* BN context not needed. */
1927    (void)ctx;
1928
1929    WOLFSSL_ENTER("wolfSSL_BN_mod_mul");
1930
1931    /* Validate parameters. */
1932    if (BN_IS_NULL(r) || BN_IS_NULL(a) || BN_IS_NULL(b) || BN_IS_NULL(m)) {
1933        WOLFSSL_MSG("Bad Argument");
1934        ret = 0;
1935    }
1936
1937    /* Have wolfCrypt perform operation with internal representations. */
1938    if ((ret == 1) && (mp_mulmod((mp_int*)a->internal, (mp_int*)b->internal,
1939            (mp_int*)m->internal, (mp_int*)r->internal)) != MP_OKAY) {
1940        ret = 0;
1941    }
1942
1943    WOLFSSL_LEAVE("wolfSSL_BN_mod_mul", ret);
1944    return ret;
1945}
1946
1947
1948/* Calculate a to the power of e, mod m into r. r = (a ^ e) % m
1949 *
1950 * @param [out] r    Big number to put result into.
1951 * @param [in]  a    Base as a big number.
1952 * @param [in]  e    Exponent as a big number.
1953 * @param [in]  m    Modulus as a big number.
1954 * @param [in]  ctx  BN context object. Unused.
1955 *
1956 * @return  1 on success.
1957 * @return  0 when r, a, p or m is NULL.
1958 * @return  0 on failure.
1959 */
1960int wolfSSL_BN_mod_exp(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *a,
1961    const WOLFSSL_BIGNUM *e, const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx)
1962{
1963    int ret = 1;
1964
1965    /* BN context not needed. */
1966    (void)ctx;
1967
1968    WOLFSSL_ENTER("wolfSSL_BN_mod_exp");
1969
1970    /* Validate parameters. */
1971    if (BN_IS_NULL(r) || BN_IS_NULL(a) || BN_IS_NULL(e) || BN_IS_NULL(m)) {
1972        WOLFSSL_MSG("Bad Argument");
1973        ret = 0;
1974    }
1975
1976    /* Have wolfCrypt perform operation with internal representations. */
1977    if ((ret == 1) && (mp_exptmod((mp_int*)a->internal, (mp_int*)e->internal,
1978            (mp_int*)m->internal, (mp_int*)r->internal)) != MP_OKAY) {
1979        ret = 0;
1980    }
1981
1982    WOLFSSL_LEAVE("wolfSSL_BN_mod_exp", ret);
1983    return ret;
1984}
1985
1986/* Calculate the modular inverse of a mod m into r. r = a^-1 mod m
1987 *
1988 * A new big number is allocated when r is NULL.
1989 *
1990 * @param [in, out] r    Big number to hold result. May be NULL.
1991 * @param [in]      a    Big number to invert.
1992 * @param [in]      m    Big number that is the modulus.
1993 * @param [in]      ctx  BN context. Not used.
1994 * @return  Big number holding result on success.
1995 * @return  NULL on failure.
1996 */
1997WOLFSSL_BIGNUM *wolfSSL_BN_mod_inverse(WOLFSSL_BIGNUM *r, WOLFSSL_BIGNUM *a,
1998    const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx)
1999{
2000    int err = 0;
2001    WOLFSSL_BIGNUM* t = NULL;
2002
2003    /* BN context not needed. */
2004    (void)ctx;
2005
2006    WOLFSSL_ENTER("wolfSSL_BN_mod_inverse");
2007
2008    /* Validate parameters. */
2009    if (BN_IS_NULL(a) || BN_IS_NULL(m) || ((r != NULL) &&
2010            (r->internal == NULL))) {
2011        WOLFSSL_MSG("a or n NULL error");
2012        err = 1;
2013    }
2014    /* Check whether we have a result big number. */
2015    if ((!err) && (r == NULL)) {
2016        /* Allocate a new big number to hold result and be returned. */
2017        t = wolfSSL_BN_new();
2018        if (t == NULL){
2019            WOLFSSL_MSG("WolfSSL_BN_new() failed");
2020            err = 1;
2021        }
2022        r = t;
2023    }
2024
2025    /* Compute inverse of a modulo n and return in r */
2026    if ((!err) && (mp_invmod((mp_int *)a->internal, (mp_int *)m->internal,
2027            (mp_int*)r->internal) != MP_OKAY)) {
2028        WOLFSSL_MSG("mp_invmod() error");
2029        err = 1;
2030    }
2031
2032    if (err) {
2033        wolfSSL_BN_free(t);
2034        r = NULL;
2035    }
2036    return r;
2037}
2038
2039/*******************************************************************************
2040 * Other Math APIs
2041 ******************************************************************************/
2042
2043#if !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN)
2044/* Needed to get mp_gcd. */
2045/* Greatest Common Divisor (GCM) of a and b into r. r = GCD(a, b)
2046 *
2047 * @param [out] r    Big number to put result into.
2048 * @param [in]  a    First big number.
2049 * @param [in]  b    Second big number.
2050 * @param [in]  ctx  BN context object. Unused.
2051 *
2052 * @return  1 on success.
2053 * @return  0 when r, a or b is NULL.
2054 * @return  0 when internal representation of r, a or b is NULL.
2055 * @return  0 on failure.
2056 */
2057int wolfSSL_BN_gcd(WOLFSSL_BIGNUM* r, WOLFSSL_BIGNUM* a, WOLFSSL_BIGNUM* b,
2058    WOLFSSL_BN_CTX* ctx)
2059{
2060    int ret = 1;
2061
2062    /* BN context not needed. */
2063    (void)ctx;
2064
2065    WOLFSSL_ENTER("wolfSSL_BN_gcd");
2066
2067    /* Validate parameters. */
2068    if (BN_IS_NULL(r) || BN_IS_NULL(a) || BN_IS_NULL(b)) {
2069        ret = 0;
2070    }
2071
2072    /* Have wolfCrypt perform operation with internal representations. */
2073    if ((ret == 1) && (mp_gcd((mp_int*)a->internal, (mp_int*)b->internal,
2074            (mp_int*)r->internal) != MP_OKAY)) {
2075        ret = 0;
2076    }
2077
2078    WOLFSSL_LEAVE("wolfSSL_BN_gcd", ret);
2079    return ret;
2080}
2081#endif /* !NO_RSA && WOLFSSL_KEY_GEN */
2082
2083/*******************************************************************************
2084 * Random APIs
2085 ******************************************************************************/
2086
2087/* Generates a random number up to bits long.
2088 *
2089 * @param [in, out] bn       Big number to generate into.
2090 * @param [in]      bits     Number of bits in word.
2091 * @param [in]      top      Whether top bits must be set.
2092 *                           Valid values: WOLFSSL_BN_RAND_TOP_ANY,
2093 *                           WOLFSSL_BN_RAND_TOP_ONE, WOLFSSL_BN_RAND_TOP_TWO.
2094 * @param [in]      bottom   Whether bottom bit must be set.
2095 *                           Valid values: WOLFSSL_BN_RAND_BOTTOM_ANY,
2096                             WOLFSSL_BN_RAND_BOTTOM_ODD.
2097 * @return  1 on success.
2098 * @return  0 when bn is NULL.
2099 * @return  0 when bits is invalid.
2100 * @return  0 when bits and top/bottom are invalid.
2101 * @return  0 when generation fails.
2102 */
2103int wolfSSL_BN_rand(WOLFSSL_BIGNUM* bn, int bits, int top, int bottom)
2104{
2105    int ret = 1;
2106    word32 len = (word32)((bits + 7) / 8);
2107    WC_RNG* rng;
2108
2109    WOLFSSL_ENTER("wolfSSL_BN_rand");
2110
2111    /* Validate parameters. */
2112    if (BN_IS_NULL(bn)) {
2113        WOLFSSL_MSG("Bad argument - bn");
2114        ret = 0;
2115    }
2116    else if (bits < 0) {
2117        WOLFSSL_MSG("Bad argument - bits < 0");
2118        ret = 0;
2119    }
2120    else if ((bits == 0) && ((bottom != WOLFSSL_BN_RAND_BOTTOM_ANY) ||
2121            (top != WOLFSSL_BN_RAND_TOP_ANY))) {
2122        WOLFSSL_MSG("Bad top/bottom - bits == 0");
2123        ret = 0;
2124    }
2125    else if ((bits == 1) && (top > WOLFSSL_BN_RAND_TOP_ONE)) {
2126        WOLFSSL_MSG("Bad top - bits == 1");
2127        ret = 0;
2128    }
2129
2130    /* Handle simple case of zero bits. */
2131    if ((ret == 1) && (bits == 0)) {
2132        mp_zero((mp_int*)bn->internal);
2133    }
2134    else if (ret == 1) {
2135        byte* buff = NULL;
2136
2137        /* Get random to global random to generate bits. */
2138        if ((rng = wolfssl_make_global_rng()) == NULL) {
2139            WOLFSSL_MSG("Failed to use global RNG.");
2140            ret = 0;
2141        }
2142
2143        /* Allocate buffer to hold generated bits. */
2144        if ((ret == 1) && ((buff = (byte*)XMALLOC(len, NULL,
2145                DYNAMIC_TYPE_TMP_BUFFER)) == NULL)) {
2146            WOLFSSL_MSG("Failed to allocate buffer.");
2147            ret = 0;
2148        }
2149        /* Generate bytes to cover bits. */
2150        if ((ret == 1) && wc_RNG_GenerateBlock(rng, buff, len) != 0) {
2151            WOLFSSL_MSG("wc_RNG_GenerateBlock failed");
2152            ret = 0;
2153        }
2154        /* Read bytes in to big number. */
2155        if ((ret == 1) && mp_read_unsigned_bin((mp_int*)bn->internal, buff, len)
2156                != MP_OKAY) {
2157            WOLFSSL_MSG("mp_read_unsigned_bin failed");
2158            ret = 0;
2159        }
2160        /* Dispose of buffer - no longer needed. */
2161        XFREE(buff, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2162
2163        if (ret == 1) {
2164            /* Truncate to requested bit length. */
2165            mp_rshb((mp_int*)bn->internal, 8 - (bits % 8));
2166        }
2167
2168        /* Set top bit when required. */
2169        if ((ret == 1) && (top >= WOLFSSL_BN_RAND_TOP_ONE) &&
2170                (mp_set_bit((mp_int*)bn->internal, bits - 1) != MP_OKAY)) {
2171            WOLFSSL_MSG("Failed to set top bit");
2172            ret = 0;
2173        }
2174        /* Set second top bit when required. */
2175        if ((ret == 1) && (top > WOLFSSL_BN_RAND_TOP_ONE) &&
2176                (mp_set_bit((mp_int*)bn->internal, bits - 2) != MP_OKAY)) {
2177            WOLFSSL_MSG("Failed to set second top bit");
2178            ret = 0;
2179        }
2180        /* Set bottom bit when required. */
2181        if ((ret == 1) && (bottom == WOLFSSL_BN_RAND_BOTTOM_ODD) &&
2182                (mp_set_bit((mp_int*)bn->internal, 0) != MP_OKAY)) {
2183            WOLFSSL_MSG("Failed to set 0th bit");
2184            ret = 0;
2185        }
2186    }
2187
2188    WOLFSSL_LEAVE("wolfSSL_BN_rand", ret);
2189
2190    return ret;
2191}
2192
2193/* Generates a pseudo-random number up to bits long.
2194 *
2195 * Implemented using wolfSSL_BN_rand().
2196 *
2197 * @param [in, out] bn       Big number to generate into.
2198 * @param [in]      bits     Number of bits in word.
2199 * @param [in]      top      Whether top bits must be set.
2200 *                           Valid values: WOLFSSL_BN_RAND_TOP_ANY,
2201 *                           WOLFSSL_BN_RAND_TOP_ONE, WOLFSSL_BN_RAND_TOP_TWO.
2202 * @param [in]      bottom   Whether bottom bit must be set.
2203 *                           Valid values: WOLFSSL_BN_RAND_BOTTOM_ANY,
2204                             WOLFSSL_BN_RAND_BOTTOM_ODD.
2205 * @return  1 on success.
2206 * @return  0 when bn is NULL.
2207 * @return  0 when bits is invalid.
2208 * @return  0 when bits and top/bottom are invalid.
2209 * @return  0 when generation fails.
2210 */
2211int wolfSSL_BN_pseudo_rand(WOLFSSL_BIGNUM* bn, int bits, int top, int bottom)
2212{
2213    return wolfSSL_BN_rand(bn, bits, top, bottom);
2214}
2215
2216/* Maximum number of trials to attempt at generating a number in range. */
2217#define RANGE_MAX_TRIALS    100
2218
2219/* Generate big number to be a value between 0 and range-1.
2220 *
2221 * N = length of range input var
2222 *
2223 * Generate N-bit length numbers until generated number is less than range
2224 * @param [in] r      Big number to generate into.
2225 * @param [in] range  The upper limit of generated number.
2226 * @return  1 on success.
2227 * @return  0 on failure.
2228 */
2229int wolfSSL_BN_rand_range(WOLFSSL_BIGNUM *r, const WOLFSSL_BIGNUM *range)
2230{
2231    int ret = 1;
2232
2233    WOLFSSL_ENTER("wolfSSL_BN_rand_range");
2234
2235    /* Validate parameters. */
2236    if (BN_IS_NULL(r) || BN_IS_NULL(range)) {
2237        WOLFSSL_MSG("Bad parameter");
2238        ret = 0;
2239    }
2240
2241    if (ret == 1) {
2242        /* Calculate number of bits in modulus. */
2243        int n = wolfSSL_BN_num_bits(range);
2244
2245        if (n <= 1) {
2246            /* Modulus is 0 or 1. */
2247            wolfSSL_BN_zero(r);
2248        }
2249        else {
2250            int i;
2251            /* Try generating a number in range for a limited number of trials.
2252             */
2253            for (i = 0; (ret == 1) && (i < RANGE_MAX_TRIALS); i++) {
2254                /* Generate a random number in range. */
2255                if (wolfSSL_BN_pseudo_rand(r, n, WOLFSSL_BN_RAND_TOP_ANY,
2256                        WOLFSSL_BN_RAND_BOTTOM_ANY) == 0) {
2257                    WOLFSSL_MSG("wolfSSL_BN_rand error");
2258                    ret = 0;
2259                }
2260                /* Check if in range. */
2261                else if (wolfSSL_BN_cmp(r, range) < 0) {
2262                    break;
2263                }
2264            }
2265            /* Fail if max trial attempts made. */
2266            if (i >= RANGE_MAX_TRIALS) {
2267                WOLFSSL_MSG("wolfSSL_BN_rand_range too many iterations");
2268                ret = 0;
2269            }
2270        }
2271    }
2272
2273    return ret;
2274}
2275
2276/*******************************************************************************
2277 * Prime APIs
2278 ******************************************************************************/
2279
2280#if defined(WOLFSSL_KEY_GEN) && (!defined(NO_RSA) || !defined(NO_DH) || \
2281    !defined(NO_DSA))
2282
2283/* Generate a prime number.
2284 *
2285 * @param [in, out] prime  Big number to generate into.
2286 * @param [in]      bits   Number of bits in generated number.
2287 * @param [in]      safe   Whether number must be a safe prime.
2288 * @param [in]      add    Value to add when generating. Not used.
2289 * @param [in]      rem    Remainder of number modulo add. Not used.
2290 * @param [in]      cb     Generation callback. Not used.
2291 * @return  1 on success.
2292 * @return  0 when prime is NULL.
2293 * @return  0 when safe required or add or rem is not NULL.
2294 * @return  0 on generation failure.
2295 */
2296int wolfSSL_BN_generate_prime_ex(WOLFSSL_BIGNUM* prime, int bits,
2297    int safe, const WOLFSSL_BIGNUM* add, const WOLFSSL_BIGNUM* rem,
2298    WOLFSSL_BN_GENCB* cb)
2299{
2300    int ret = 1;
2301    WC_DECLARE_VAR(tmpRng, WC_RNG, 1, 0);
2302    WC_RNG* rng = NULL;
2303    int localRng = 0;
2304
2305    /* Callback not used. */
2306    (void)cb;
2307
2308    WOLFSSL_ENTER("wolfSSL_BN_generate_prime_ex");
2309
2310    /* Check unsupported parameters. */
2311    if ((safe == 1) || (add != NULL) || (rem != NULL)) {
2312        ret = 0;
2313    }
2314    /* Validate parameters. */
2315    else if (BN_IS_NULL(prime)) {
2316        ret = 0;
2317    }
2318
2319    /* Create a new RNG or use global. */
2320    if ((ret == 1) && ((rng = wolfssl_make_rng(tmpRng, &localRng)) == NULL)) {
2321        ret = 0;
2322    }
2323
2324    /* Use wolfCrypt to generate a prime. */
2325    if ((ret == 1) && (mp_rand_prime((mp_int*)prime->internal, (bits + 7) / 8,
2326            rng, NULL) != MP_OKAY)) {
2327        ret = 0;
2328    }
2329
2330    if (localRng) {
2331        /* Dispose of local RNG that was created. */
2332        wc_FreeRng(rng);
2333        WC_FREE_VAR_EX(rng, NULL, DYNAMIC_TYPE_RNG);
2334    }
2335
2336    WOLFSSL_LEAVE("wolfSSL_BN_generate_prime_ex", ret);
2337
2338    return ret;
2339}
2340
2341/* Check whether a big number is prime.
2342 *
2343 * Return code compliant with OpenSSL.
2344 *
2345 * @param [in] bn      Big number to check.
2346 * @param [in] checks  Number of Miller-Rabin tests to perform.
2347 * @param [in] ctx     BN context. Not used.
2348 * @param [in] cb      Generation callback. Not used.
2349 * @return  1 when number is prime.
2350 * @return  0 when number is not prime.
2351 * @return  -1 when bn is NULL or failure when checking.
2352 */
2353int wolfSSL_BN_is_prime_ex(const WOLFSSL_BIGNUM *bn, int checks,
2354    WOLFSSL_BN_CTX *ctx, WOLFSSL_BN_GENCB *cb)
2355{
2356    int ret = 1;
2357    WC_RNG* rng    = NULL;
2358    WC_DECLARE_VAR(tmpRng, WC_RNG, 1, 0);
2359    int localRng = 0;
2360    int res = MP_NO;
2361
2362    /* BN context not needed. */
2363    (void)ctx;
2364    (void)cb;
2365
2366    WOLFSSL_ENTER("wolfSSL_BN_is_prime_ex");
2367
2368    if (BN_IS_NULL(bn)) {
2369        WOLFSSL_MSG("bn NULL error");
2370        ret = WOLFSSL_FATAL_ERROR;
2371    }
2372
2373    /* Create a new RNG or use global. */
2374    if ((ret == 1) && ((rng = wolfssl_make_rng(tmpRng, &localRng)) == NULL)) {
2375        ret = WOLFSSL_FATAL_ERROR;
2376    }
2377
2378    if ((ret == 1) && (mp_prime_is_prime_ex((mp_int*)bn->internal, checks, &res,
2379            rng) != MP_OKAY)) {
2380        WOLFSSL_MSG("mp_prime_is_prime_ex error");
2381        ret = WOLFSSL_FATAL_ERROR;
2382    }
2383
2384    if (localRng) {
2385        wc_FreeRng(rng);
2386        WC_FREE_VAR_EX(rng, NULL, DYNAMIC_TYPE_RNG);
2387    }
2388
2389    if ((ret != -1) && (res != MP_YES)) {
2390        WOLFSSL_MSG("mp_prime_is_prime_ex not prime");
2391        ret = 0;
2392    }
2393
2394    return ret;
2395}
2396
2397#endif /* WOLFSSL_KEY_GEN && (!NO_RSA || !NO_DH || !NO_DSA) */
2398
2399/*******************************************************************************
2400 * Print APIs
2401 ******************************************************************************/
2402
2403#if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM) && \
2404    defined(XFPRINTF)
2405/* Print big number to file pointer.
2406 *
2407 * Return code compliant with OpenSSL.
2408 *
2409 * @param [in] fp  File pointer.
2410 * @param [in] bn  Big number to print.
2411 * @return  1 on success.
2412 * @return  0 when fp is a bad file pointer.
2413 * @return  0 when bn is NULL.
2414 * @return  0 when creating hex string fails.
2415 * @return  0 when printing fails.
2416 */
2417int wolfSSL_BN_print_fp(XFILE fp, const WOLFSSL_BIGNUM *bn)
2418{
2419    int ret = 1;
2420    char* buf = NULL;
2421
2422    WOLFSSL_ENTER("wolfSSL_BN_print_fp");
2423
2424    /* Validate parameters. */
2425    if ((fp == XBADFILE) || BN_IS_NULL(bn)) {
2426        WOLFSSL_MSG("bn NULL error");
2427        ret = 0;
2428    }
2429
2430    /* Create a hex string of big number. */
2431    if ((ret == 1) && ((buf = wolfSSL_BN_bn2hex(bn)) == NULL)) {
2432        WOLFSSL_MSG("wolfSSL_BN_bn2hex failure");
2433        ret = 0;
2434    }
2435
2436    /* Print hex string to file pointer. */
2437    if ((ret == 1) && (XFPRINTF(fp, "%s", buf) < 0)) {
2438        ret = 0;
2439    }
2440
2441    /* Dispose of any allocated data. */
2442    XFREE(buf, NULL, DYNAMIC_TYPE_OPENSSL);
2443
2444    return ret;
2445}
2446#endif /* !NO_FILESYSTEM && XFPRINTF */
2447
2448#ifndef NO_WOLFSSL_BN_CTX
2449/*******************************************************************************
2450 * BN_CTX APIs
2451 ******************************************************************************/
2452
2453/* Create a new BN context object.
2454 *
2455 * @return  BN context object on success.
2456 * @return  NULL on failure.
2457 */
2458WOLFSSL_BN_CTX* wolfSSL_BN_CTX_new(void)
2459{
2460    WOLFSSL_BN_CTX* ctx = NULL;
2461
2462    WOLFSSL_ENTER("wolfSSL_BN_CTX_new");
2463    ctx = (WOLFSSL_BN_CTX*)XMALLOC(sizeof(WOLFSSL_BN_CTX), NULL,
2464            DYNAMIC_TYPE_OPENSSL);
2465    if (ctx != NULL) {
2466        XMEMSET(ctx, 0, sizeof(WOLFSSL_BN_CTX));
2467    }
2468
2469    return ctx;
2470}
2471
2472
2473#ifndef NO_WOLFSSL_STUB
2474/* deprecated
2475 *
2476 * Initialize a BN context object.
2477 * This function was removed in OpenSSL 1.1.0 and later.
2478 * Keeping a stub function here for older applications that have BN_CTX_init()
2479 * calls.
2480 *
2481 * @param [in] ctx  Dummy BN context.
2482 */
2483void wolfSSL_BN_CTX_init(WOLFSSL_BN_CTX* ctx)
2484{
2485    (void)ctx;
2486    WOLFSSL_ENTER("wolfSSL_BN_CTX_init");
2487    WOLFSSL_STUB("wolfSSL_BN_CTX_init");
2488    WOLFSSL_MSG("wolfSSL_BN_CTX_init is deprecated");
2489}
2490#endif
2491
2492
2493/* Free a BN context object.
2494 *
2495 * @param [in] ctx  BN context object.
2496 */
2497void wolfSSL_BN_CTX_free(WOLFSSL_BN_CTX* ctx)
2498{
2499    WOLFSSL_ENTER("wolfSSL_BN_CTX_free");
2500    if (ctx != NULL) {
2501        while (ctx->list != NULL) {
2502            struct WOLFSSL_BN_CTX_LIST* tmp = ctx->list;
2503            ctx->list = ctx->list->next;
2504            wolfSSL_BN_free(tmp->bn);
2505            XFREE(tmp, NULL, DYNAMIC_TYPE_OPENSSL);
2506        }
2507        XFREE(ctx, NULL, DYNAMIC_TYPE_OPENSSL);
2508    }
2509}
2510
2511/* Get a big number from the BN context.
2512 *
2513 * @param [in] ctx  BN context object.
2514 * @return  Big number on success.
2515 * @return  NULL on failure.
2516 */
2517WOLFSSL_BIGNUM *wolfSSL_BN_CTX_get(WOLFSSL_BN_CTX *ctx)
2518{
2519    WOLFSSL_BIGNUM* bn = NULL;
2520
2521    WOLFSSL_ENTER("wolfSSL_BN_CTX_get");
2522    if (ctx != NULL) {
2523        struct WOLFSSL_BN_CTX_LIST* node = (struct WOLFSSL_BN_CTX_LIST*)XMALLOC(
2524                sizeof(struct WOLFSSL_BN_CTX_LIST), NULL, DYNAMIC_TYPE_OPENSSL);
2525        if (node != NULL) {
2526            XMEMSET(node, 0, sizeof(struct WOLFSSL_BN_CTX_LIST));
2527            bn = node->bn = wolfSSL_BN_new();
2528            if (node->bn != NULL) {
2529                node->next = ctx->list;
2530                ctx->list = node;
2531            }
2532            else {
2533                XFREE(node, NULL, DYNAMIC_TYPE_OPENSSL);
2534                node = NULL;
2535            }
2536        }
2537    }
2538
2539    return bn;
2540}
2541
2542#ifndef NO_WOLFSSL_STUB
2543/* Start stack of temporary big numbers.
2544 *
2545 * Newly allocated big numbers are returned instead of having a stack.
2546 *
2547 * @param [in] ctx  BN context. Not used.
2548 */
2549void wolfSSL_BN_CTX_start(WOLFSSL_BN_CTX *ctx)
2550{
2551    (void)ctx;
2552
2553    WOLFSSL_ENTER("wolfSSL_BN_CTX_start");
2554    WOLFSSL_STUB("BN_CTX_start");
2555    WOLFSSL_MSG("wolfSSL_BN_CTX_start TBD");
2556}
2557#endif
2558
2559#endif /* NO_WOLFSSL_BN_CTX */
2560
2561/*******************************************************************************
2562 * BN_MONT_CTX APIs
2563 ******************************************************************************/
2564
2565WOLFSSL_BN_MONT_CTX* wolfSSL_BN_MONT_CTX_new(void)
2566{
2567    /* wolfcrypt doesn't need BN MONT context. */
2568    static int mont;
2569    WOLFSSL_ENTER("wolfSSL_BN_MONT_CTX_new");
2570    return (WOLFSSL_BN_MONT_CTX*)&mont;
2571}
2572
2573void wolfSSL_BN_MONT_CTX_free(WOLFSSL_BN_MONT_CTX *mont)
2574{
2575    (void)mont;
2576    WOLFSSL_ENTER("wolfSSL_BN_MONT_CTX_free");
2577    /* Don't do anything since using dummy, static BN context. */
2578}
2579
2580int wolfSSL_BN_MONT_CTX_set(WOLFSSL_BN_MONT_CTX *mont,
2581        const WOLFSSL_BIGNUM *mod, WOLFSSL_BN_CTX *ctx)
2582{
2583    (void) mont;
2584    (void) mod;
2585    (void) ctx;
2586    WOLFSSL_ENTER("wolfSSL_BN_MONT_CTX_set");
2587    return WOLFSSL_SUCCESS;
2588}
2589
2590/* Calculate r = a ^ p % m.
2591 *
2592 * @param [out] r    Big number to store the result.
2593 * @param [in]  a    Base as an unsigned long.
2594 * @param [in]  p    Exponent as a big number.
2595 * @param [in]  m    Modulus as a big number.
2596 * @param [in]  ctx  BN context object. Unused.
2597 * @param [in]  mont Montgomery context object. Unused.
2598 *
2599 * @return  1 on success.
2600 * @return  0 on failure.
2601 */
2602int wolfSSL_BN_mod_exp_mont_word(WOLFSSL_BIGNUM *r, WOLFSSL_BN_ULONG a,
2603        const WOLFSSL_BIGNUM *p, const WOLFSSL_BIGNUM *m, WOLFSSL_BN_CTX *ctx,
2604        WOLFSSL_BN_MONT_CTX *mont)
2605{
2606    WOLFSSL_BIGNUM* tmp = NULL;
2607    int ret = WOLFSSL_SUCCESS;
2608
2609    (void)mont;
2610    WOLFSSL_ENTER("wolfSSL_BN_mod_exp_mont_word");
2611
2612    if (ret == WOLFSSL_SUCCESS && (tmp = wolfSSL_BN_new()) == NULL) {
2613        WOLFSSL_MSG("wolfSSL_BN_new failed");
2614        ret = WOLFSSL_FAILURE;
2615    }
2616    if (ret == WOLFSSL_SUCCESS && (wolfSSL_BN_set_word(tmp, (unsigned long)a))
2617                                   == WC_NO_ERR_TRACE(WOLFSSL_FAILURE)) {
2618        WOLFSSL_MSG("wolfSSL_BN_set_word failed");
2619        ret = WOLFSSL_FAILURE;
2620    }
2621    if (ret == WOLFSSL_SUCCESS)
2622        ret = wolfSSL_BN_mod_exp(r, tmp, p, m, ctx);
2623
2624    wolfSSL_BN_free(tmp);
2625    return ret;
2626}
2627
2628#endif /* OPENSSL_EXTRA */
2629
2630#endif /* !WOLFSSL_SSL_BN_INCLUDED */
2631