crypto/asn1/a_int.c:545: error: NULL_DEREFERENCE
  pointer `null` is dereferenced by call to `ASN1_STRING_set()` at line 545, column 9.
Showing all 78 steps of the trace


crypto/asn1/a_int.c:519:1: start of procedure bn_to_asn1_string()
517.   }
518.   
519. > static ASN1_STRING *bn_to_asn1_string(const BIGNUM *bn, ASN1_STRING *ai,
520.                                         int atype)
521.   {

crypto/asn1/a_int.c:525:9: Taking true branch
523.       int len;
524.   
525.       if (ai == NULL) {
               ^
526.           ret = ASN1_STRING_type_new(atype);
527.       } else {

crypto/asn1/a_int.c:526:9: 
524.   
525.       if (ai == NULL) {
526. >         ret = ASN1_STRING_type_new(atype);
527.       } else {
528.           ret = ai;

crypto/asn1/asn1_lib.c:349:1: start of procedure ASN1_STRING_type_new()
  347.   }
  348.   
  349. > ASN1_STRING *ASN1_STRING_type_new(int type)
  350.   {
  351.       ASN1_STRING *ret;

crypto/asn1/asn1_lib.c:353:5: 
  351.       ASN1_STRING *ret;
  352.   
  353. >     ret = OPENSSL_zalloc(sizeof(*ret));
  354.       if (ret == NULL) {
  355.           ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);

crypto/mem.c:157:1: start of procedure CRYPTO_zalloc()
    155.   }
    156.   
    157. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
    158.   {
    159.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:159:5: 
    157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
    158.   {
    159. >     void *ret = CRYPTO_malloc(num, file, line);
    160.   
    161.       if (ret != NULL)

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
      118.   }
      119.   
      120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
      121.   {
      122.       void *ret = NULL;

crypto/mem.c:122:5: 
      120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
      121.   {
      122. >     void *ret = NULL;
      123.   
      124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
      122.       void *ret = NULL;
      123.   
      124.       if (num <= 0)
                     ^
      125.           return NULL;
      126.   

crypto/mem.c:127:5: 
      125.           return NULL;
      126.   
      127. >     allow_customize = 0;
      128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
      129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
      135.       }
      136.   #else
      137. >     (void)file;
      138.       (void)line;
      139.       ret = malloc(num);

crypto/mem.c:138:5: 
      136.   #else
      137.       (void)file;
      138. >     (void)line;
      139.       ret = malloc(num);
      140.   #endif

crypto/mem.c:139:5: 
      137.       (void)file;
      138.       (void)line;
      139. >     ret = malloc(num);
      140.   #endif
      141.   

crypto/mem.c:154:5: 
      152.   #endif
      153.   
      154. >     return ret;
      155.   }
      156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
      153.   
      154.       return ret;
      155. > }
      156.   
      157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:161:9: Taking true branch
    159.       void *ret = CRYPTO_malloc(num, file, line);
    160.   
    161.       if (ret != NULL)
                   ^
    162.           memset(ret, 0, num);
    163.       return ret;

crypto/mem.c:162:9: 
    160.   
    161.       if (ret != NULL)
    162. >         memset(ret, 0, num);
    163.       return ret;
    164.   }

crypto/mem.c:163:5: 
    161.       if (ret != NULL)
    162.           memset(ret, 0, num);
    163. >     return ret;
    164.   }
    165.   

crypto/mem.c:164:1: return from a call to CRYPTO_zalloc
    162.           memset(ret, 0, num);
    163.       return ret;
    164. > }
    165.   
    166.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/asn1/asn1_lib.c:354:9: Taking false branch
  352.   
  353.       ret = OPENSSL_zalloc(sizeof(*ret));
  354.       if (ret == NULL) {
                 ^
  355.           ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);
  356.           return (NULL);

crypto/asn1/asn1_lib.c:358:5: 
  356.           return (NULL);
  357.       }
  358. >     ret->type = type;
  359.       return (ret);
  360.   }

crypto/asn1/asn1_lib.c:359:5: 
  357.       }
  358.       ret->type = type;
  359. >     return (ret);
  360.   }
  361.   

crypto/asn1/asn1_lib.c:360:1: return from a call to ASN1_STRING_type_new
  358.       ret->type = type;
  359.       return (ret);
  360. > }
  361.   
  362.   void ASN1_STRING_free(ASN1_STRING *a)

crypto/asn1/a_int.c:532:9: Taking false branch
530.       }
531.   
532.       if (ret == NULL) {
               ^
533.           ASN1err(ASN1_F_BN_TO_ASN1_STRING, ERR_R_NESTED_ASN1_ERROR);
534.           goto err;

crypto/asn1/a_int.c:537:9: 
535.       }
536.   
537. >     if (BN_is_negative(bn) && !BN_is_zero(bn))
538.           ret->type |= V_ASN1_NEG_INTEGER;
539.   

crypto/bn/bn_lib.c:919:1: start of procedure BN_is_negative()
  917.   }
  918.   
  919. > int BN_is_negative(const BIGNUM *a)
  920.   {
  921.       return (a->neg != 0);

crypto/bn/bn_lib.c:921:13: Condition is true
  919.   int BN_is_negative(const BIGNUM *a)
  920.   {
  921.       return (a->neg != 0);
                     ^
  922.   }
  923.   

crypto/bn/bn_lib.c:921:5: 
  919.   int BN_is_negative(const BIGNUM *a)
  920.   {
  921. >     return (a->neg != 0);
  922.   }
  923.   

crypto/bn/bn_lib.c:922:1: return from a call to BN_is_negative
  920.   {
  921.       return (a->neg != 0);
  922. > }
  923.   
  924.   int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont,

crypto/asn1/a_int.c:537:9: Taking true branch
535.       }
536.   
537.       if (BN_is_negative(bn) && !BN_is_zero(bn))
               ^
538.           ret->type |= V_ASN1_NEG_INTEGER;
539.   

crypto/asn1/a_int.c:537:32: 
535.       }
536.   
537. >     if (BN_is_negative(bn) && !BN_is_zero(bn))
538.           ret->type |= V_ASN1_NEG_INTEGER;
539.   

crypto/bn/bn_lib.c:899:1: start of procedure BN_is_zero()
  897.   }
  898.   
  899. > int BN_is_zero(const BIGNUM *a)
  900.   {
  901.       return a->top == 0;

crypto/bn/bn_lib.c:901:12: Condition is false
  899.   int BN_is_zero(const BIGNUM *a)
  900.   {
  901.       return a->top == 0;
                    ^
  902.   }
  903.   

crypto/bn/bn_lib.c:901:5: 
  899.   int BN_is_zero(const BIGNUM *a)
  900.   {
  901. >     return a->top == 0;
  902.   }
  903.   

crypto/bn/bn_lib.c:902:1: return from a call to BN_is_zero
  900.   {
  901.       return a->top == 0;
  902. > }
  903.   
  904.   int BN_is_one(const BIGNUM *a)

crypto/asn1/a_int.c:537:32: Taking true branch
535.       }
536.   
537.       if (BN_is_negative(bn) && !BN_is_zero(bn))
                                      ^
538.           ret->type |= V_ASN1_NEG_INTEGER;
539.   

crypto/asn1/a_int.c:538:9: 
536.   
537.       if (BN_is_negative(bn) && !BN_is_zero(bn))
538. >         ret->type |= V_ASN1_NEG_INTEGER;
539.   
540.       len = BN_num_bytes(bn);

crypto/asn1/a_int.c:540:5: 
538.           ret->type |= V_ASN1_NEG_INTEGER;
539.   
540. >     len = BN_num_bytes(bn);
541.   
542.       if (len == 0)

crypto/bn/bn_lib.c:215:1: start of procedure BN_num_bits()
  213.   }
  214.   
  215. > int BN_num_bits(const BIGNUM *a)
  216.   {
  217.       int i = a->top - 1;

crypto/bn/bn_lib.c:217:5: 
  215.   int BN_num_bits(const BIGNUM *a)
  216.   {
  217. >     int i = a->top - 1;
  218.       bn_check_top(a);
  219.   

crypto/bn/bn_lib.c:220:9: 
  218.       bn_check_top(a);
  219.   
  220. >     if (BN_is_zero(a))
  221.           return 0;
  222.       return ((i * BN_BITS2) + BN_num_bits_word(a->d[i]));

crypto/bn/bn_lib.c:899:1: start of procedure BN_is_zero()
    897.   }
    898.   
    899. > int BN_is_zero(const BIGNUM *a)
    900.   {
    901.       return a->top == 0;

crypto/bn/bn_lib.c:901:12: Condition is false
    899.   int BN_is_zero(const BIGNUM *a)
    900.   {
    901.       return a->top == 0;
                      ^
    902.   }
    903.   

crypto/bn/bn_lib.c:901:5: 
    899.   int BN_is_zero(const BIGNUM *a)
    900.   {
    901. >     return a->top == 0;
    902.   }
    903.   

crypto/bn/bn_lib.c:902:1: return from a call to BN_is_zero
    900.   {
    901.       return a->top == 0;
    902. > }
    903.   
    904.   int BN_is_one(const BIGNUM *a)

crypto/bn/bn_lib.c:220:9: Taking false branch
  218.       bn_check_top(a);
  219.   
  220.       if (BN_is_zero(a))
                 ^
  221.           return 0;
  222.       return ((i * BN_BITS2) + BN_num_bits_word(a->d[i]));

crypto/bn/bn_lib.c:222:5: Skipping BN_num_bits_word(): empty list of specs
  220.       if (BN_is_zero(a))
  221.           return 0;
  222.       return ((i * BN_BITS2) + BN_num_bits_word(a->d[i]));
             ^
  223.   }
  224.   

crypto/bn/bn_lib.c:223:1: return from a call to BN_num_bits
  221.           return 0;
  222.       return ((i * BN_BITS2) + BN_num_bits_word(a->d[i]));
  223. > }
  224.   
  225.   static void bn_free_d(BIGNUM *a)

crypto/asn1/a_int.c:542:9: Taking false branch
540.       len = BN_num_bytes(bn);
541.   
542.       if (len == 0)
               ^
543.           len = 1;
544.   

crypto/asn1/a_int.c:545:9: 
543.           len = 1;
544.   
545. >     if (ASN1_STRING_set(ret, NULL, len) == 0) {
546.           ASN1err(ASN1_F_BN_TO_ASN1_STRING, ERR_R_MALLOC_FAILURE);
547.           goto err;

crypto/asn1/asn1_lib.c:308:1: start of procedure ASN1_STRING_set()
  306.   }
  307.   
  308. > int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)
  309.   {
  310.       unsigned char *c;

crypto/asn1/asn1_lib.c:311:5: 
  309.   {
  310.       unsigned char *c;
  311. >     const char *data = _data;
  312.   
  313.       if (len < 0) {

crypto/asn1/asn1_lib.c:313:9: Taking false branch
  311.       const char *data = _data;
  312.   
  313.       if (len < 0) {
                 ^
  314.           if (data == NULL)
  315.               return (0);

crypto/asn1/asn1_lib.c:319:10: Taking false branch
  317.               len = strlen(data);
  318.       }
  319.       if ((str->length < len) || (str->data == NULL)) {
                  ^
  320.           c = str->data;
  321.           str->data = OPENSSL_realloc(c, len + 1);

crypto/asn1/asn1_lib.c:319:33: Taking true branch
  317.               len = strlen(data);
  318.       }
  319.       if ((str->length < len) || (str->data == NULL)) {
                                         ^
  320.           c = str->data;
  321.           str->data = OPENSSL_realloc(c, len + 1);

crypto/asn1/asn1_lib.c:320:9: 
  318.       }
  319.       if ((str->length < len) || (str->data == NULL)) {
  320. >         c = str->data;
  321.           str->data = OPENSSL_realloc(c, len + 1);
  322.           if (str->data == NULL) {

crypto/asn1/asn1_lib.c:321:9: 
  319.       if ((str->length < len) || (str->data == NULL)) {
  320.           c = str->data;
  321. >         str->data = OPENSSL_realloc(c, len + 1);
  322.           if (str->data == NULL) {
  323.               ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);

crypto/mem.c:166:1: start of procedure CRYPTO_realloc()
    164.   }
    165.   
    166. > void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)
    167.   {
    168.       if (str == NULL)

crypto/mem.c:168:9: Taking true branch
    166.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)
    167.   {
    168.       if (str == NULL)
                   ^
    169.           return CRYPTO_malloc(num, file, line);
    170.   

crypto/mem.c:169:9: 
    167.   {
    168.       if (str == NULL)
    169. >         return CRYPTO_malloc(num, file, line);
    170.   
    171.       if (num == 0) {

crypto/mem.c:120:1: start of procedure CRYPTO_malloc()
      118.   }
      119.   
      120. > void *CRYPTO_malloc(size_t num, const char *file, int line)
      121.   {
      122.       void *ret = NULL;

crypto/mem.c:122:5: 
      120.   void *CRYPTO_malloc(size_t num, const char *file, int line)
      121.   {
      122. >     void *ret = NULL;
      123.   
      124.       if (num <= 0)

crypto/mem.c:124:9: Taking false branch
      122.       void *ret = NULL;
      123.   
      124.       if (num <= 0)
                     ^
      125.           return NULL;
      126.   

crypto/mem.c:127:5: 
      125.           return NULL;
      126.   
      127. >     allow_customize = 0;
      128.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
      129.       if (call_malloc_debug) {

crypto/mem.c:137:5: 
      135.       }
      136.   #else
      137. >     (void)file;
      138.       (void)line;
      139.       ret = malloc(num);

crypto/mem.c:138:5: 
      136.   #else
      137.       (void)file;
      138. >     (void)line;
      139.       ret = malloc(num);
      140.   #endif

crypto/mem.c:139:5: 
      137.       (void)file;
      138.       (void)line;
      139. >     ret = malloc(num);
      140.   #endif
      141.   

crypto/mem.c:154:5: 
      152.   #endif
      153.   
      154. >     return ret;
      155.   }
      156.   

crypto/mem.c:155:1: return from a call to CRYPTO_malloc
      153.   
      154.       return ret;
      155. > }
      156.   
      157.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:191:1: return from a call to CRYPTO_realloc
    189.       return realloc(str, num);
    190.   
    191. > }
    192.   
    193.   void *CRYPTO_clear_realloc(void *str, size_t old_len, size_t num,

crypto/asn1/asn1_lib.c:322:13: Taking false branch
  320.           c = str->data;
  321.           str->data = OPENSSL_realloc(c, len + 1);
  322.           if (str->data == NULL) {
                     ^
  323.               ASN1err(ASN1_F_ASN1_STRING_SET, ERR_R_MALLOC_FAILURE);
  324.               str->data = c;

crypto/asn1/asn1_lib.c:328:5: 
  326.           }
  327.       }
  328. >     str->length = len;
  329.       if (data != NULL) {
  330.           memcpy(str->data, data, len);

crypto/asn1/asn1_lib.c:329:9: Taking true branch
  327.       }
  328.       str->length = len;
  329.       if (data != NULL) {
                 ^
  330.           memcpy(str->data, data, len);
  331.           /* an allowance for strings :-) */

crypto/asn1/asn1_lib.c:330:9: 
  328.       str->length = len;
  329.       if (data != NULL) {
  330. >         memcpy(str->data, data, len);
  331.           /* an allowance for strings :-) */
  332.           str->data[len] = '\0';

crypto/asn1/asn1_lib.c:332:9: 
  330.           memcpy(str->data, data, len);
  331.           /* an allowance for strings :-) */
  332. >         str->data[len] = '\0';
  333.       }
  334.       return (1);

crypto/asn1/asn1_lib.c:334:5: 
  332.           str->data[len] = '\0';
  333.       }
  334. >     return (1);
  335.   }
  336.   

crypto/asn1/asn1_lib.c:335:1: return from a call to ASN1_STRING_set
  333.       }
  334.       return (1);
  335. > }
  336.   
  337.   void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len)
