crypto/x509v3/v3_skey.c:149: error: MEMORY_LEAK
  memory dynamically allocated by call to `ASN1_OCTET_STRING_new()` at line 114, column 16 is not reachable after line 149, column 5.
Showing all 43 steps of the trace


crypto/x509v3/v3_skey.c:103:1: start of procedure s2i_skey_id()
101.   }
102.   
103. > static ASN1_OCTET_STRING *s2i_skey_id(X509V3_EXT_METHOD *method,
104.                                         X509V3_CTX *ctx, char *str)
105.   {

crypto/x509v3/v3_skey.c:111:9: Taking false branch
109.       unsigned int diglen;
110.   
111.       if (strcmp(str, "hash"))
               ^
112.           return s2i_ASN1_OCTET_STRING(method, ctx, str);
113.   

crypto/x509v3/v3_skey.c:114:9: 
112.           return s2i_ASN1_OCTET_STRING(method, ctx, str);
113.   
114. >     if ((oct = ASN1_OCTET_STRING_new()) == NULL) {
115.           X509V3err(X509V3_F_S2I_SKEY_ID, ERR_R_MALLOC_FAILURE);
116.           return NULL;

crypto/asn1/tasn_typ.c:76:1: start of procedure ASN1_OCTET_STRING_new()
  74.   }
  75.   
  76. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
  77.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
  78.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_ENUMERATED)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

crypto/asn1/tasn_typ.c:76:1: return from a call to ASN1_OCTET_STRING_new
  74.   }
  75.   
  76. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
  77.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
  78.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_ENUMERATED)

crypto/x509v3/v3_skey.c:114:9: Taking false branch
112.           return s2i_ASN1_OCTET_STRING(method, ctx, str);
113.   
114.       if ((oct = ASN1_OCTET_STRING_new()) == NULL) {
               ^
115.           X509V3err(X509V3_F_S2I_SKEY_ID, ERR_R_MALLOC_FAILURE);
116.           return NULL;

crypto/x509v3/v3_skey.c:119:9: Taking true branch
117.       }
118.   
119.       if (ctx && (ctx->flags == CTX_TEST))
               ^
120.           return oct;
121.   

crypto/x509v3/v3_skey.c:119:17: Taking false branch
117.       }
118.   
119.       if (ctx && (ctx->flags == CTX_TEST))
                       ^
120.           return oct;
121.   

crypto/x509v3/v3_skey.c:122:10: Taking false branch
120.           return oct;
121.   
122.       if (!ctx || (!ctx->subject_req && !ctx->subject_cert)) {
                ^
123.           X509V3err(X509V3_F_S2I_SKEY_ID, X509V3_R_NO_PUBLIC_KEY);
124.           goto err;

crypto/x509v3/v3_skey.c:122:19: Taking true branch
120.           return oct;
121.   
122.       if (!ctx || (!ctx->subject_req && !ctx->subject_cert)) {
                         ^
123.           X509V3err(X509V3_F_S2I_SKEY_ID, X509V3_R_NO_PUBLIC_KEY);
124.           goto err;

crypto/x509v3/v3_skey.c:122:40: Taking true branch
120.           return oct;
121.   
122.       if (!ctx || (!ctx->subject_req && !ctx->subject_cert)) {
                                              ^
123.           X509V3err(X509V3_F_S2I_SKEY_ID, X509V3_R_NO_PUBLIC_KEY);
124.           goto err;

crypto/x509v3/v3_skey.c:123:9: Skipping ERR_put_error(): empty list of specs
121.   
122.       if (!ctx || (!ctx->subject_req && !ctx->subject_cert)) {
123.           X509V3err(X509V3_F_S2I_SKEY_ID, X509V3_R_NO_PUBLIC_KEY);
               ^
124.           goto err;
125.       }

crypto/x509v3/v3_skey.c:148:2: 
146.       return oct;
147.   
148. >  err:
149.       ASN1_OCTET_STRING_free(oct);
150.       return NULL;

crypto/x509v3/v3_skey.c:149:5: 
147.   
148.    err:
149. >     ASN1_OCTET_STRING_free(oct);
150.       return NULL;
151.   }

crypto/asn1/tasn_typ.c:76:1: start of procedure ASN1_OCTET_STRING_free()
  74.   }
  75.   
  76. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
  77.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
  78.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_ENUMERATED)

crypto/asn1/asn1_lib.c:361:1: start of procedure ASN1_STRING_free()
    359.   }
    360.   
    361. > void ASN1_STRING_free(ASN1_STRING *a)
    362.   {
    363.       if (a == NULL)

crypto/asn1/asn1_lib.c:363:9: Taking false branch
    361.   void ASN1_STRING_free(ASN1_STRING *a)
    362.   {
    363.       if (a == NULL)
                   ^
    364.           return;
    365.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))

crypto/asn1/asn1_lib.c:365:11: Taking false branch
    363.       if (a == NULL)
    364.           return;
    365.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))
                     ^
    366.           OPENSSL_free(a->data);
    367.       if (!(a->flags & ASN1_STRING_FLAG_EMBED))

crypto/asn1/asn1_lib.c:367:11: Taking false branch
    365.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))
    366.           OPENSSL_free(a->data);
    367.       if (!(a->flags & ASN1_STRING_FLAG_EMBED))
                     ^
    368.           OPENSSL_free(a);
    369.   }

crypto/asn1/asn1_lib.c:367:5: 
    365.       if (!(a->flags & ASN1_STRING_FLAG_NDEF))
    366.           OPENSSL_free(a->data);
    367. >     if (!(a->flags & ASN1_STRING_FLAG_EMBED))
    368.           OPENSSL_free(a);
    369.   }

crypto/asn1/asn1_lib.c:369:1: return from a call to ASN1_STRING_free
    367.       if (!(a->flags & ASN1_STRING_FLAG_EMBED))
    368.           OPENSSL_free(a);
    369. > }
    370.   
    371.   void ASN1_STRING_clear_free(ASN1_STRING *a)

crypto/asn1/tasn_typ.c:76:1: return from a call to ASN1_OCTET_STRING_free
  74.   }
  75.   
  76. > IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)
  77.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_INTEGER)
  78.   IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_ENUMERATED)

static ASN1_OCTET_STRING *s2i_skey_id(X509V3_EXT_METHOD *method,
                                      X509V3_CTX *ctx, char *str)
{
    ASN1_OCTET_STRING *oct;
    ASN1_BIT_STRING *pk;
    unsigned char pkey_dig[EVP_MAX_MD_SIZE];
    unsigned int diglen;
    if (strcmp(str, "hash"))
        return s2i_ASN1_OCTET_STRING(method, ctx, str);
    if ((oct = ASN1_OCTET_STRING_new()) == NULL) {
        X509V3err(X509V3_F_S2I_SKEY_ID, ERR_R_MALLOC_FAILURE);
        return NULL;
    }
    if (ctx && (ctx->flags == CTX_TEST))
        return oct;
    if (!ctx || (!ctx->subject_req && !ctx->subject_cert)) {
        X509V3err(X509V3_F_S2I_SKEY_ID, X509V3_R_NO_PUBLIC_KEY);
        goto err;
    }
    if (ctx->subject_req)
        pk = ctx->subject_req->req_info.pubkey->public_key;
    else
        pk = ctx->subject_cert->cert_info.key->public_key;
    if (!pk) {
        X509V3err(X509V3_F_S2I_SKEY_ID, X509V3_R_NO_PUBLIC_KEY);
        goto err;
    }
    if (!EVP_Digest
        (pk->data, pk->length, pkey_dig, &diglen, EVP_sha1(), NULL))
        goto err;
    if (!ASN1_OCTET_STRING_set(oct, pkey_dig, diglen)) {
        X509V3err(X509V3_F_S2I_SKEY_ID, ERR_R_MALLOC_FAILURE);
        goto err;
    }
    return oct;
 err:
    ASN1_OCTET_STRING_free(oct);
    return NULL;
}
['static ASN1_OCTET_STRING *s2i_skey_id(X509V3_EXT_METHOD *method,\n                                      X509V3_CTX *ctx, char *str)\n{\n    ASN1_OCTET_STRING *oct;\n    ASN1_BIT_STRING *pk;\n    unsigned char pkey_dig[EVP_MAX_MD_SIZE];\n    unsigned int diglen;\n    if (strcmp(str, "hash"))\n        return s2i_ASN1_OCTET_STRING(method, ctx, str);\n    if ((oct = ASN1_OCTET_STRING_new()) == NULL) {\n        X509V3err(X509V3_F_S2I_SKEY_ID, ERR_R_MALLOC_FAILURE);\n        return NULL;\n    }\n    if (ctx && (ctx->flags == CTX_TEST))\n        return oct;\n    if (!ctx || (!ctx->subject_req && !ctx->subject_cert)) {\n        X509V3err(X509V3_F_S2I_SKEY_ID, X509V3_R_NO_PUBLIC_KEY);\n        goto err;\n    }\n    if (ctx->subject_req)\n        pk = ctx->subject_req->req_info.pubkey->public_key;\n    else\n        pk = ctx->subject_cert->cert_info.key->public_key;\n    if (!pk) {\n        X509V3err(X509V3_F_S2I_SKEY_ID, X509V3_R_NO_PUBLIC_KEY);\n        goto err;\n    }\n    if (!EVP_Digest\n        (pk->data, pk->length, pkey_dig, &diglen, EVP_sha1(), NULL))\n        goto err;\n    if (!ASN1_OCTET_STRING_set(oct, pkey_dig, diglen)) {\n        X509V3err(X509V3_F_S2I_SKEY_ID, ERR_R_MALLOC_FAILURE);\n        goto err;\n    }\n    return oct;\n err:\n    ASN1_OCTET_STRING_free(oct);\n    return NULL;\n}', 'IMPLEMENT_ASN1_STRING_FUNCTIONS(ASN1_OCTET_STRING)', 'ASN1_STRING *ASN1_STRING_type_new(int type)\n{\n    ASN1_STRING *ret;\n    ret = OPENSSL_zalloc(sizeof(*ret));\n    if (ret == NULL) {\n        ASN1err(ASN1_F_ASN1_STRING_TYPE_NEW, ERR_R_MALLOC_FAILURE);\n        return (NULL);\n    }\n    ret->type = type;\n    return (ret);\n}', 'void *CRYPTO_zalloc(size_t num, const char *file, int line)\n{\n    void *ret = CRYPTO_malloc(num, file, line);\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    if (num <= 0)\n        return NULL;\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;\n    (void)line;\n    ret = malloc(num);\n#endif\n#ifndef OPENSSL_CPUID_OBJ\n    if (ret && (num > 2048)) {\n        extern unsigned char cleanse_ctr;\n        ((unsigned char *)ret)[0] = cleanse_ctr;\n    }\n#endif\n    return ret;\n}', 'void ASN1_STRING_free(ASN1_STRING *a)\n{\n    if (a == NULL)\n        return;\n    if (!(a->flags & ASN1_STRING_FLAG_NDEF))\n        OPENSSL_free(a->data);\n    if (!(a->flags & ASN1_STRING_FLAG_EMBED))\n        OPENSSL_free(a);\n}']