crypto/ec/ec_key.c:221: error: BUFFER_OVERRUN_L3
  Offset added: [8, +oo] Size: [0, 67108856] by call to `BN_priv_rand_range`.
Showing all 24 steps of the trace


crypto/ec/ec_key.c:198:1: Parameter `eckey->priv_key->top`
196.   }
197.   
198. > int ec_key_simple_generate_key(EC_KEY *eckey)
199.   {
200.       int ok = 0;

crypto/ec/ec_key.c:221:14: Call
219.   
220.       do
221.           if (!BN_priv_rand_range(priv_key, order))
                    ^
222.               goto err;
223.       while (BN_is_zero(priv_key)) ;

crypto/bn/bn_rand.c:184:1: Parameter `r->top`
  182.   }
  183.   
  184. > int BN_priv_rand_range(BIGNUM *r, const BIGNUM *range)
  185.   {
  186.       return bnrand_range(PRIVATE, r, range);

crypto/bn/bn_rand.c:186:12: Call
  184.   int BN_priv_rand_range(BIGNUM *r, const BIGNUM *range)
  185.   {
  186.       return bnrand_range(PRIVATE, r, range);
                    ^
  187.   }
  188.   

crypto/bn/bn_rand.c:113:1: Parameter `r->top`
    111.   
    112.   /* random number r:  0 <= r < range */
    113. > static int bnrand_range(BNRAND_FLAG flag, BIGNUM *r, const BIGNUM *range)
    114.   {
    115.       int b, n;

crypto/bn/bn_rand.c:128:9: Call
    126.   
    127.       if (n == 1)
    128.           BN_zero(r);
                   ^
    129.       else if (!BN_is_bit_set(range, n - 2) && !BN_is_bit_set(range, n - 3)) {
    130.           /*

crypto/bn/bn_lib.c:387:1: Parameter `a->top`
      385.   }
      386.   
      387. > int BN_set_word(BIGNUM *a, BN_ULONG w)
      388.   {
      389.       bn_check_top(a);

crypto/bn/bn_lib.c:390:9: Call
      388.   {
      389.       bn_check_top(a);
      390.       if (bn_expand(a, (int)sizeof(BN_ULONG) * 8) == NULL)
                     ^
      391.           return 0;
      392.       a->neg = 0;

crypto/bn/bn_lcl.h:651:1: Parameter `a->top`
        649.                            const BIGNUM *add, const BIGNUM *rem, BN_CTX *ctx);
        650.   
        651. > static ossl_inline BIGNUM *bn_expand(BIGNUM *a, int bits)
        652.   {
        653.       if (bits > (INT_MAX - BN_BITS2 + 1))

crypto/bn/bn_lcl.h:659:12: Call
        657.           return a;
        658.   
        659.       return bn_expand2((a),(bits+BN_BITS2-1)/BN_BITS2);
                          ^
        660.   }
        661.   

crypto/bn/bn_lib.c:273:1: Parameter `b->top`
          271.    */
          272.   
          273. > BIGNUM *bn_expand2(BIGNUM *b, int words)
          274.   {
          275.       bn_check_top(b);

crypto/bn/bn_lib.c:278:23: Call
          276.   
          277.       if (words > b->dmax) {
          278.           BN_ULONG *a = bn_expand_internal(b, words);
                                       ^
          279.           if (!a)
          280.               return NULL;

crypto/bn/bn_lib.c:235:1: <Offset trace>
233.   /* This is used by bn_expand2() */
234.   /* The caller MUST check that words > b->dmax before calling this */
235. > static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)
236.   {
237.       BN_ULONG *a = NULL;

crypto/bn/bn_lib.c:235:1: Parameter `b->top`
            233.   /* This is used by bn_expand2() */
            234.   /* The caller MUST check that words > b->dmax before calling this */
            235. > static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)
            236.   {
            237.       BN_ULONG *a = NULL;

crypto/bn/bn_lib.c:235:1: <Length trace>
233.   /* This is used by bn_expand2() */
234.   /* The caller MUST check that words > b->dmax before calling this */
235. > static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)
236.   {
237.       BN_ULONG *a = NULL;

crypto/bn/bn_lib.c:235:1: Parameter `words`
            233.   /* This is used by bn_expand2() */
            234.   /* The caller MUST check that words > b->dmax before calling this */
            235. > static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)
            236.   {
            237.       BN_ULONG *a = NULL;

crypto/bn/bn_lib.c:252:13: Call
            250.           a = OPENSSL_secure_zalloc(words * sizeof(*a));
            251.       else
            252.           a = OPENSSL_zalloc(words * sizeof(*a));
                               ^
            253.       if (a == NULL) {
            254.           BNerr(BN_F_BN_EXPAND_INTERNAL, ERR_R_MALLOC_FAILURE);

crypto/mem.c:218:1: Parameter `num`
              216.   }
              217.   
              218. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
              219.   {
              220.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:220:17: Call
              218.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
              219.   {
              220.       void *ret = CRYPTO_malloc(num, file, line);
                                     ^
              221.   
              222.       FAILTEST();

crypto/mem.c:198:9: Assignment
                196.   
                197.       if (num == 0)
                198.           return NULL;
                               ^
                199.   
                200.       FAILTEST();

crypto/mem.c:220:5: Assignment
              218.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
              219.   {
              220.       void *ret = CRYPTO_malloc(num, file, line);
                         ^
              221.   
              222.       FAILTEST();

crypto/mem.c:225:5: Assignment
              223.       if (ret != NULL)
              224.           memset(ret, 0, num);
              225.       return ret;
                         ^
              226.   }
              227.   

crypto/bn/bn_lib.c:252:9: Assignment
            250.           a = OPENSSL_secure_zalloc(words * sizeof(*a));
            251.       else
            252.           a = OPENSSL_zalloc(words * sizeof(*a));
                           ^
            253.       if (a == NULL) {
            254.           BNerr(BN_F_BN_EXPAND_INTERNAL, ERR_R_MALLOC_FAILURE);

crypto/bn/bn_lib.c:260:9: Array access: Offset added: [8, +oo] Size: [0, 67108856] by call to `BN_priv_rand_range` 
            258.       assert(b->top <= words);
            259.       if (b->top > 0)
            260.           memcpy(a, b->d, sizeof(*a) * b->top);
                           ^
            261.   
            262.       return a;

static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)
{
    BN_ULONG *a = NULL;
    bn_check_top(b);
    if (words > (INT_MAX / (4 * BN_BITS2))) {
        BNerr(BN_F_BN_EXPAND_INTERNAL, BN_R_BIGNUM_TOO_LONG);
        return NULL;
    }
    if (BN_get_flags(b, BN_FLG_STATIC_DATA)) {
        BNerr(BN_F_BN_EXPAND_INTERNAL, BN_R_EXPAND_ON_STATIC_BIGNUM_DATA);
        return NULL;
    }
    if (BN_get_flags(b, BN_FLG_SECURE))
        a = OPENSSL_secure_zalloc(words * sizeof(*a));
    else
        a = OPENSSL_zalloc(words * sizeof(*a));
    if (a == NULL) {
        BNerr(BN_F_BN_EXPAND_INTERNAL, ERR_R_MALLOC_FAILURE);
        return NULL;
    }
    assert(b->top <= words);
    if (b->top > 0)
        memcpy(a, b->d, sizeof(*a) * b->top);
    return a;
}
['int ec_key_simple_generate_key(EC_KEY *eckey)\n{\n    int ok = 0;\n    BN_CTX *ctx = NULL;\n    BIGNUM *priv_key = NULL;\n    const BIGNUM *order = NULL;\n    EC_POINT *pub_key = NULL;\n    if ((ctx = BN_CTX_new()) == NULL)\n        goto err;\n    if (eckey->priv_key == NULL) {\n        priv_key = BN_new();\n        if (priv_key == NULL)\n            goto err;\n    } else\n        priv_key = eckey->priv_key;\n    order = EC_GROUP_get0_order(eckey->group);\n    if (order == NULL)\n        goto err;\n    do\n        if (!BN_priv_rand_range(priv_key, order))\n            goto err;\n    while (BN_is_zero(priv_key)) ;\n    if (eckey->pub_key == NULL) {\n        pub_key = EC_POINT_new(eckey->group);\n        if (pub_key == NULL)\n            goto err;\n    } else\n        pub_key = eckey->pub_key;\n    if (!EC_POINT_mul(eckey->group, pub_key, priv_key, NULL, NULL, ctx))\n        goto err;\n    eckey->priv_key = priv_key;\n    eckey->pub_key = pub_key;\n    ok = 1;\n err:\n    if (eckey->pub_key == NULL)\n        EC_POINT_free(pub_key);\n    if (eckey->priv_key != priv_key)\n        BN_free(priv_key);\n    BN_CTX_free(ctx);\n    return ok;\n}', 'int BN_priv_rand_range(BIGNUM *r, const BIGNUM *range)\n{\n    return bnrand_range(PRIVATE, r, range);\n}', 'static int bnrand_range(BNRAND_FLAG flag, BIGNUM *r, const BIGNUM *range)\n{\n    int b, n;\n    int count = 100;\n    if (range->neg || BN_is_zero(range)) {\n        BNerr(BN_F_BNRAND_RANGE, BN_R_INVALID_RANGE);\n        return 0;\n    }\n    n = BN_num_bits(range);\n    if (n == 1)\n        BN_zero(r);\n    else if (!BN_is_bit_set(range, n - 2) && !BN_is_bit_set(range, n - 3)) {\n        do {\n            b = flag == NORMAL\n                ? BN_rand(r, n + 1, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY)\n                : BN_priv_rand(r, n + 1, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY);\n            if (!b)\n                return 0;\n            if (BN_cmp(r, range) >= 0) {\n                if (!BN_sub(r, r, range))\n                    return 0;\n                if (BN_cmp(r, range) >= 0)\n                    if (!BN_sub(r, r, range))\n                        return 0;\n            }\n            if (!--count) {\n                BNerr(BN_F_BNRAND_RANGE, BN_R_TOO_MANY_ITERATIONS);\n                return 0;\n            }\n        }\n        while (BN_cmp(r, range) >= 0);\n    } else {\n        do {\n            if (!BN_rand(r, n, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY))\n                return 0;\n            if (!--count) {\n                BNerr(BN_F_BNRAND_RANGE, BN_R_TOO_MANY_ITERATIONS);\n                return 0;\n            }\n        }\n        while (BN_cmp(r, range) >= 0);\n    }\n    bn_check_top(r);\n    return 1;\n}', 'int BN_set_word(BIGNUM *a, BN_ULONG w)\n{\n    bn_check_top(a);\n    if (bn_expand(a, (int)sizeof(BN_ULONG) * 8) == NULL)\n        return 0;\n    a->neg = 0;\n    a->d[0] = w;\n    a->top = (w ? 1 : 0);\n    bn_check_top(a);\n    return 1;\n}', 'static ossl_inline BIGNUM *bn_expand(BIGNUM *a, int bits)\n{\n    if (bits > (INT_MAX - BN_BITS2 + 1))\n        return NULL;\n    if (((bits+BN_BITS2-1)/BN_BITS2) <= (a)->dmax)\n        return a;\n    return bn_expand2((a),(bits+BN_BITS2-1)/BN_BITS2);\n}', 'BIGNUM *bn_expand2(BIGNUM *b, int words)\n{\n    bn_check_top(b);\n    if (words > b->dmax) {\n        BN_ULONG *a = bn_expand_internal(b, words);\n        if (!a)\n            return NULL;\n        if (b->d) {\n            OPENSSL_cleanse(b->d, b->dmax * sizeof(b->d[0]));\n            bn_free_d(b);\n        }\n        b->d = a;\n        b->dmax = words;\n    }\n    bn_check_top(b);\n    return b;\n}', 'static BN_ULONG *bn_expand_internal(const BIGNUM *b, int words)\n{\n    BN_ULONG *a = NULL;\n    bn_check_top(b);\n    if (words > (INT_MAX / (4 * BN_BITS2))) {\n        BNerr(BN_F_BN_EXPAND_INTERNAL, BN_R_BIGNUM_TOO_LONG);\n        return NULL;\n    }\n    if (BN_get_flags(b, BN_FLG_STATIC_DATA)) {\n        BNerr(BN_F_BN_EXPAND_INTERNAL, BN_R_EXPAND_ON_STATIC_BIGNUM_DATA);\n        return NULL;\n    }\n    if (BN_get_flags(b, BN_FLG_SECURE))\n        a = OPENSSL_secure_zalloc(words * sizeof(*a));\n    else\n        a = OPENSSL_zalloc(words * sizeof(*a));\n    if (a == NULL) {\n        BNerr(BN_F_BN_EXPAND_INTERNAL, ERR_R_MALLOC_FAILURE);\n        return NULL;\n    }\n    assert(b->top <= words);\n    if (b->top > 0)\n        memcpy(a, b->d, sizeof(*a) * b->top);\n    return a;\n}', 'void *CRYPTO_zalloc(size_t num, const char *file, int line)\n{\n    void *ret = CRYPTO_malloc(num, file, line);\n    FAILTEST();\n    if (ret != NULL)\n        memset(ret, 0, num);\n    return ret;\n}', 'void *CRYPTO_malloc(size_t num, const char *file, int line)\n{\n    void *ret = NULL;\n    INCREMENT(malloc_count);\n    if (malloc_impl != NULL && malloc_impl != CRYPTO_malloc)\n        return malloc_impl(num, file, line);\n    if (num == 0)\n        return NULL;\n    FAILTEST();\n    allow_customize = 0;\n#ifndef OPENSSL_NO_CRYPTO_MDEBUG\n    if (call_malloc_debug) {\n        CRYPTO_mem_debug_malloc(NULL, num, 0, file, line);\n        ret = malloc(num);\n        CRYPTO_mem_debug_malloc(ret, num, 1, file, line);\n    } else {\n        ret = malloc(num);\n    }\n#else\n    (void)(file); (void)(line);\n    ret = malloc(num);\n#endif\n    return ret;\n}']