free null cleanup finale
Don't check for NULL before calling OPENSSL_free Reviewed-by: Richard Levitte <levitte@openssl.org>
This commit is contained in:
parent
33fbca83dc
commit
b548a1f11c
173 changed files with 509 additions and 1012 deletions
|
@ -2165,9 +2165,7 @@ void jpake_client_auth(BIO *out, BIO *conn, const char *secret)
|
|||
|
||||
BIO_puts(out, "JPAKE authentication succeeded, setting PSK\n");
|
||||
|
||||
if (psk_key)
|
||||
OPENSSL_free(psk_key);
|
||||
|
||||
OPENSSL_free(psk_key);
|
||||
psk_key = BN_bn2hex(JPAKE_get_shared_key(ctx));
|
||||
|
||||
BIO_pop(bconn);
|
||||
|
@ -2197,9 +2195,7 @@ void jpake_server_auth(BIO *out, BIO *conn, const char *secret)
|
|||
|
||||
BIO_puts(out, "JPAKE authentication succeeded, setting PSK\n");
|
||||
|
||||
if (psk_key)
|
||||
OPENSSL_free(psk_key);
|
||||
|
||||
OPENSSL_free(psk_key);
|
||||
psk_key = BN_bn2hex(JPAKE_get_shared_key(ctx));
|
||||
|
||||
BIO_pop(bconn);
|
||||
|
|
|
@ -321,11 +321,9 @@ int asn1parse_main(int argc, char **argv)
|
|||
ERR_print_errors(bio_err);
|
||||
if (buf != NULL)
|
||||
BUF_MEM_free(buf);
|
||||
if (name != NULL)
|
||||
OPENSSL_free(name);
|
||||
if (header != NULL)
|
||||
OPENSSL_free(header);
|
||||
if (strictpem && str != NULL)
|
||||
OPENSSL_free(name);
|
||||
OPENSSL_free(header);
|
||||
if (strictpem)
|
||||
OPENSSL_free(str);
|
||||
ASN1_TYPE_free(at);
|
||||
if (osk != NULL)
|
||||
|
|
12
apps/ca.c
12
apps/ca.c
|
@ -2271,8 +2271,7 @@ static int do_revoke(X509 *x509, CA_DB *db, int type, char *value)
|
|||
ok = 1;
|
||||
end:
|
||||
for (i = 0; i < DB_NUMBER; i++) {
|
||||
if (row[i] != NULL)
|
||||
OPENSSL_free(row[i]);
|
||||
OPENSSL_free(row[i]);
|
||||
}
|
||||
return (ok);
|
||||
}
|
||||
|
@ -2339,8 +2338,7 @@ static int get_certificate_status(const char *serial, CA_DB *db)
|
|||
}
|
||||
end:
|
||||
for (i = 0; i < DB_NUMBER; i++) {
|
||||
if (row[i] != NULL)
|
||||
OPENSSL_free(row[i]);
|
||||
OPENSSL_free(row[i]);
|
||||
}
|
||||
return (ok);
|
||||
}
|
||||
|
@ -2564,8 +2562,7 @@ int make_revoked(X509_REVOKED *rev, const char *str)
|
|||
|
||||
end:
|
||||
|
||||
if (tmp)
|
||||
OPENSSL_free(tmp);
|
||||
OPENSSL_free(tmp);
|
||||
ASN1_OBJECT_free(hold);
|
||||
ASN1_GENERALIZEDTIME_free(comp_time);
|
||||
ASN1_ENUMERATED_free(rtmp);
|
||||
|
@ -2719,8 +2716,7 @@ int unpack_revinfo(ASN1_TIME **prevtm, int *preason, ASN1_OBJECT **phold,
|
|||
|
||||
end:
|
||||
|
||||
if (tmp)
|
||||
OPENSSL_free(tmp);
|
||||
OPENSSL_free(tmp);
|
||||
ASN1_GENERALIZEDTIME_free(comp_time);
|
||||
|
||||
return ret;
|
||||
|
|
12
apps/cms.c
12
apps/cms.c
|
@ -1121,12 +1121,9 @@ int cms_main(int argc, char **argv)
|
|||
sk_OPENSSL_STRING_free(sksigners);
|
||||
if (skkeys)
|
||||
sk_OPENSSL_STRING_free(skkeys);
|
||||
if (secret_key)
|
||||
OPENSSL_free(secret_key);
|
||||
if (secret_keyid)
|
||||
OPENSSL_free(secret_keyid);
|
||||
if (pwri_tmp)
|
||||
OPENSSL_free(pwri_tmp);
|
||||
OPENSSL_free(secret_key);
|
||||
OPENSSL_free(secret_keyid);
|
||||
OPENSSL_free(pwri_tmp);
|
||||
ASN1_OBJECT_free(econtent_type);
|
||||
if (rr)
|
||||
CMS_ReceiptRequest_free(rr);
|
||||
|
@ -1152,8 +1149,7 @@ int cms_main(int argc, char **argv)
|
|||
BIO_free(in);
|
||||
BIO_free(indata);
|
||||
BIO_free_all(out);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passin);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
|
|
@ -451,8 +451,7 @@ int dgst_main(int argc, char **argv)
|
|||
sk_OPENSSL_STRING_free(sigopts);
|
||||
if (macopts)
|
||||
sk_OPENSSL_STRING_free(macopts);
|
||||
if (sigbuf)
|
||||
OPENSSL_free(sigbuf);
|
||||
OPENSSL_free(sigbuf);
|
||||
BIO_free(bmd);
|
||||
return (ret);
|
||||
}
|
||||
|
|
|
@ -275,10 +275,8 @@ int dsa_main(int argc, char **argv)
|
|||
end:
|
||||
BIO_free_all(out);
|
||||
DSA_free(dsa);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
if (passout)
|
||||
OPENSSL_free(passout);
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passout);
|
||||
return (ret);
|
||||
}
|
||||
#else /* !OPENSSL_NO_DSA */
|
||||
|
|
|
@ -271,10 +271,8 @@ int ec_main(int argc, char **argv)
|
|||
BIO_free(in);
|
||||
BIO_free_all(out);
|
||||
EC_KEY_free(eckey);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
if (passout)
|
||||
OPENSSL_free(passout);
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passout);
|
||||
return (ret);
|
||||
}
|
||||
#else /* !OPENSSL_NO_EC */
|
||||
|
|
|
@ -489,8 +489,7 @@ int ecparam_main(int argc, char **argv)
|
|||
BN_free(ec_gen);
|
||||
BN_free(ec_order);
|
||||
BN_free(ec_cofactor);
|
||||
if (buffer)
|
||||
OPENSSL_free(buffer);
|
||||
OPENSSL_free(buffer);
|
||||
BIO_free(in);
|
||||
BIO_free_all(out);
|
||||
EC_GROUP_free(group);
|
||||
|
|
|
@ -564,10 +564,8 @@ int enc_main(int argc, char **argv)
|
|||
}
|
||||
end:
|
||||
ERR_print_errors(bio_err);
|
||||
if (strbuf != NULL)
|
||||
OPENSSL_free(strbuf);
|
||||
if (buff != NULL)
|
||||
OPENSSL_free(buff);
|
||||
OPENSSL_free(strbuf);
|
||||
OPENSSL_free(buff);
|
||||
BIO_free(in);
|
||||
BIO_free_all(out);
|
||||
BIO_free(benc);
|
||||
|
@ -575,8 +573,7 @@ int enc_main(int argc, char **argv)
|
|||
#ifdef ZLIB
|
||||
BIO_free(bzl);
|
||||
#endif
|
||||
if (pass)
|
||||
OPENSSL_free(pass);
|
||||
OPENSSL_free(pass);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
|
|
@ -252,10 +252,8 @@ static int util_verbose(ENGINE *e, int verbose, BIO *out, const char *indent)
|
|||
}
|
||||
OPENSSL_free(name);
|
||||
name = NULL;
|
||||
if (desc) {
|
||||
OPENSSL_free(desc);
|
||||
desc = NULL;
|
||||
}
|
||||
OPENSSL_free(desc);
|
||||
desc = NULL;
|
||||
/* Move to the next command */
|
||||
num = ENGINE_ctrl(e, ENGINE_CTRL_GET_NEXT_CMD_TYPE, num, NULL, NULL);
|
||||
} while (num > 0);
|
||||
|
@ -265,10 +263,8 @@ static int util_verbose(ENGINE *e, int verbose, BIO *out, const char *indent)
|
|||
err:
|
||||
if (cmds)
|
||||
sk_OPENSSL_STRING_pop_free(cmds, identity);
|
||||
if (name)
|
||||
OPENSSL_free(name);
|
||||
if (desc)
|
||||
OPENSSL_free(desc);
|
||||
OPENSSL_free(name);
|
||||
OPENSSL_free(desc);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -182,8 +182,7 @@ int gendsa_main(int argc, char **argv)
|
|||
BIO_free(in);
|
||||
BIO_free_all(out);
|
||||
DSA_free(dsa);
|
||||
if (passout)
|
||||
OPENSSL_free(passout);
|
||||
OPENSSL_free(passout);
|
||||
return (ret);
|
||||
}
|
||||
#else /* !OPENSSL_NO_DSA */
|
||||
|
|
|
@ -235,8 +235,7 @@ int genpkey_main(int argc, char **argv)
|
|||
EVP_PKEY_CTX_free(ctx);
|
||||
BIO_free_all(out);
|
||||
BIO_free(in);
|
||||
if (pass)
|
||||
OPENSSL_free(pass);
|
||||
OPENSSL_free(pass);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -218,8 +218,7 @@ int genrsa_main(int argc, char **argv)
|
|||
BN_GENCB_free(cb);
|
||||
RSA_free(rsa);
|
||||
BIO_free_all(out);
|
||||
if (passout)
|
||||
OPENSSL_free(passout);
|
||||
OPENSSL_free(passout);
|
||||
if (ret != 0)
|
||||
ERR_print_errors(bio_err);
|
||||
return (ret);
|
||||
|
|
19
apps/ocsp.c
19
apps/ocsp.c
|
@ -271,12 +271,9 @@ int ocsp_main(int argc, char **argv)
|
|||
req_timeout = atoi(opt_arg());
|
||||
break;
|
||||
case OPT_URL:
|
||||
if (thost)
|
||||
OPENSSL_free(thost);
|
||||
if (tport)
|
||||
OPENSSL_free(tport);
|
||||
if (tpath)
|
||||
OPENSSL_free(tpath);
|
||||
OPENSSL_free(thost);
|
||||
OPENSSL_free(tport);
|
||||
OPENSSL_free(tpath);
|
||||
if (!OCSP_parse_url(opt_arg(), &host, &port, &path, &use_ssl)) {
|
||||
BIO_printf(bio_err, "%s Error parsing URL\n", prog);
|
||||
goto end;
|
||||
|
@ -753,13 +750,9 @@ int ocsp_main(int argc, char **argv)
|
|||
sk_X509_pop_free(sign_other, X509_free);
|
||||
sk_X509_pop_free(verify_other, X509_free);
|
||||
sk_CONF_VALUE_pop_free(headers, X509V3_conf_free);
|
||||
|
||||
if (thost)
|
||||
OPENSSL_free(thost);
|
||||
if (tport)
|
||||
OPENSSL_free(tport);
|
||||
if (tpath)
|
||||
OPENSSL_free(tpath);
|
||||
OPENSSL_free(thost);
|
||||
OPENSSL_free(tport);
|
||||
OPENSSL_free(tpath);
|
||||
|
||||
return (ret);
|
||||
}
|
||||
|
|
|
@ -509,18 +509,15 @@ int main(int argc, char *argv[])
|
|||
}
|
||||
ret = 1;
|
||||
end:
|
||||
if (copied_argv)
|
||||
OPENSSL_free(copied_argv);
|
||||
if (to_free)
|
||||
OPENSSL_free(to_free);
|
||||
OPENSSL_free(copied_argv);
|
||||
OPENSSL_free(to_free);
|
||||
if (config != NULL) {
|
||||
NCONF_free(config);
|
||||
config = NULL;
|
||||
}
|
||||
if (prog != NULL)
|
||||
lh_FUNCTION_free(prog);
|
||||
if (arg.argv != NULL)
|
||||
OPENSSL_free(arg.argv);
|
||||
OPENSSL_free(arg.argv);
|
||||
|
||||
BIO_free(bio_in);
|
||||
BIO_free_all(bio_out);
|
||||
|
|
|
@ -284,10 +284,8 @@ int passwd_main(int argc, char **argv)
|
|||
|
||||
end:
|
||||
ERR_print_errors(bio_err);
|
||||
if (salt_malloc)
|
||||
OPENSSL_free(salt_malloc);
|
||||
if (passwd_malloc)
|
||||
OPENSSL_free(passwd_malloc);
|
||||
OPENSSL_free(salt_malloc);
|
||||
OPENSSL_free(passwd_malloc);
|
||||
BIO_free(in);
|
||||
return (ret);
|
||||
}
|
||||
|
|
|
@ -556,10 +556,8 @@ int pkcs12_main(int argc, char **argv)
|
|||
BIO_free_all(out);
|
||||
if (canames)
|
||||
sk_OPENSSL_STRING_free(canames);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
if (passout)
|
||||
OPENSSL_free(passout);
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passout);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
|
|
@ -343,10 +343,8 @@ int pkcs8_main(int argc, char **argv)
|
|||
EVP_PKEY_free(pkey);
|
||||
BIO_free_all(out);
|
||||
BIO_free(in);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
if (passout)
|
||||
OPENSSL_free(passout);
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passout);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -208,10 +208,8 @@ int pkey_main(int argc, char **argv)
|
|||
EVP_PKEY_free(pkey);
|
||||
BIO_free_all(out);
|
||||
BIO_free(in);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
if (passout)
|
||||
OPENSSL_free(passout);
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passout);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -322,12 +322,9 @@ int pkeyutl_main(int argc, char **argv)
|
|||
EVP_PKEY_CTX_free(ctx);
|
||||
BIO_free(in);
|
||||
BIO_free_all(out);
|
||||
if (buf_in)
|
||||
OPENSSL_free(buf_in);
|
||||
if (buf_out)
|
||||
OPENSSL_free(buf_out);
|
||||
if (sig)
|
||||
OPENSSL_free(sig);
|
||||
OPENSSL_free(buf_in);
|
||||
OPENSSL_free(buf_out);
|
||||
OPENSSL_free(sig);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -413,10 +410,7 @@ static EVP_PKEY_CTX *init_ctx(int *pkeysize,
|
|||
}
|
||||
|
||||
end:
|
||||
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
|
||||
OPENSSL_free(passin);
|
||||
return ctx;
|
||||
|
||||
}
|
||||
|
|
|
@ -886,15 +886,12 @@ int req_main(int argc, char **argv)
|
|||
if (gen_eng)
|
||||
ENGINE_free(gen_eng);
|
||||
#endif
|
||||
if (keyalgstr)
|
||||
OPENSSL_free(keyalgstr);
|
||||
OPENSSL_free(keyalgstr);
|
||||
X509_REQ_free(req);
|
||||
X509_free(x509ss);
|
||||
ASN1_INTEGER_free(serial);
|
||||
if (passargin && passin)
|
||||
OPENSSL_free(passin);
|
||||
if (passargout && passout)
|
||||
OPENSSL_free(passout);
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passout);
|
||||
OBJ_cleanup();
|
||||
return (ret);
|
||||
}
|
||||
|
|
|
@ -388,10 +388,8 @@ int rsa_main(int argc, char **argv)
|
|||
end:
|
||||
BIO_free_all(out);
|
||||
RSA_free(rsa);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
if (passout)
|
||||
OPENSSL_free(passout);
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passout);
|
||||
return (ret);
|
||||
}
|
||||
#else /* !OPENSSL_NO_RSA */
|
||||
|
|
|
@ -315,12 +315,9 @@ int rsautl_main(int argc, char **argv)
|
|||
RSA_free(rsa);
|
||||
BIO_free(in);
|
||||
BIO_free_all(out);
|
||||
if (rsa_in)
|
||||
OPENSSL_free(rsa_in);
|
||||
if (rsa_out)
|
||||
OPENSSL_free(rsa_out);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(rsa_in);
|
||||
OPENSSL_free(rsa_out);
|
||||
OPENSSL_free(passin);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -1985,24 +1985,18 @@ int s_client_main(int argc, char **argv)
|
|||
SSL_free(con);
|
||||
}
|
||||
#if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
|
||||
if (next_proto.data)
|
||||
OPENSSL_free(next_proto.data);
|
||||
OPENSSL_free(next_proto.data);
|
||||
#endif
|
||||
SSL_CTX_free(ctx);
|
||||
X509_free(cert);
|
||||
sk_X509_CRL_pop_free(crls, X509_CRL_free);
|
||||
EVP_PKEY_free(key);
|
||||
sk_X509_pop_free(chain, X509_free);
|
||||
if (pass)
|
||||
OPENSSL_free(pass);
|
||||
OPENSSL_free(pass);
|
||||
X509_VERIFY_PARAM_free(vpm);
|
||||
ssl_excert_free(exc);
|
||||
sk_OPENSSL_STRING_free(ssl_args);
|
||||
SSL_CONF_CTX_free(cctx);
|
||||
#ifndef OPENSSL_NO_JPAKE
|
||||
if (jpake_secret && psk_key)
|
||||
OPENSSL_free(psk_key);
|
||||
#endif
|
||||
OPENSSL_clear_free(cbuf, BUFSIZZ);
|
||||
OPENSSL_clear_free(sbuf, BUFSIZZ);
|
||||
OPENSSL_clear_free(mbuf, BUFSIZZ);
|
||||
|
|
|
@ -1956,10 +1956,6 @@ int s_server_main(int argc, char *argv[])
|
|||
ssl_excert_free(exc);
|
||||
sk_OPENSSL_STRING_free(ssl_args);
|
||||
SSL_CONF_CTX_free(cctx);
|
||||
#ifndef OPENSSL_NO_JPAKE
|
||||
if (jpake_secret && psk_key)
|
||||
OPENSSL_free(psk_key);
|
||||
#endif
|
||||
BIO_free(bio_s_out);
|
||||
bio_s_out = NULL;
|
||||
BIO_free(bio_s_msg);
|
||||
|
@ -2931,8 +2927,7 @@ static int www_body(char *hostname, int s, int stype, unsigned char *context)
|
|||
err:
|
||||
if (ret >= 0)
|
||||
BIO_printf(bio_s_out, "ACCEPT\n");
|
||||
if (buf != NULL)
|
||||
OPENSSL_free(buf);
|
||||
OPENSSL_free(buf);
|
||||
BIO_free_all(io);
|
||||
return (ret);
|
||||
}
|
||||
|
@ -3065,8 +3060,7 @@ static int rev_body(char *hostname, int s, int stype, unsigned char *context)
|
|||
|
||||
err:
|
||||
|
||||
if (buf != NULL)
|
||||
OPENSSL_free(buf);
|
||||
OPENSSL_free(buf);
|
||||
BIO_free_all(io);
|
||||
return (ret);
|
||||
}
|
||||
|
|
|
@ -354,8 +354,7 @@ int do_server(int port, int type, int *ret,
|
|||
} else
|
||||
sock = accept_socket;
|
||||
i = (*cb) (name, sock, type, context);
|
||||
if (name != NULL)
|
||||
OPENSSL_free(name);
|
||||
OPENSSL_free(name);
|
||||
if (type == SOCK_STREAM)
|
||||
SHUTDOWN2(sock);
|
||||
if (naccept != -1)
|
||||
|
|
|
@ -664,8 +664,7 @@ int smime_main(int argc, char **argv)
|
|||
BIO_free(in);
|
||||
BIO_free(indata);
|
||||
BIO_free_all(out);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passin);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
|
|
@ -2529,8 +2529,6 @@ static void multiblock_speed(const EVP_CIPHER *evp_cipher)
|
|||
fprintf(stdout, "\n");
|
||||
}
|
||||
|
||||
if (inp)
|
||||
OPENSSL_free(inp);
|
||||
if (out)
|
||||
OPENSSL_free(out);
|
||||
OPENSSL_free(inp);
|
||||
OPENSSL_free(out);
|
||||
}
|
||||
|
|
|
@ -240,7 +240,6 @@ int spkac_main(int argc, char **argv)
|
|||
BIO_free(in);
|
||||
BIO_free_all(out);
|
||||
EVP_PKEY_free(pkey);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passin);
|
||||
return (ret);
|
||||
}
|
||||
|
|
37
apps/srp.c
37
apps/srp.c
|
@ -384,10 +384,8 @@ int srp_main(int argc, char **argv)
|
|||
errorline, configfile);
|
||||
goto end;
|
||||
}
|
||||
if (tofree) {
|
||||
OPENSSL_free(tofree);
|
||||
tofree = NULL;
|
||||
}
|
||||
OPENSSL_free(tofree);
|
||||
tofree = NULL;
|
||||
|
||||
/* Lets get the config section we are using */
|
||||
if (section == NULL) {
|
||||
|
@ -519,26 +517,16 @@ int srp_main(int argc, char **argv)
|
|||
row[DB_srpgN] = BUF_strdup(gNid);
|
||||
|
||||
if (!row[DB_srpid] || !row[DB_srpgN] || !row[DB_srptype]
|
||||
|| !row[DB_srpverifier] || !row[DB_srpsalt] || (userinfo
|
||||
&&
|
||||
(!(row
|
||||
[DB_srpinfo]
|
||||
=
|
||||
BUF_strdup
|
||||
(userinfo))))
|
||||
|| !row[DB_srpverifier] || !row[DB_srpsalt]
|
||||
|| (userinfo &&
|
||||
(!(row [DB_srpinfo] = BUF_strdup (userinfo))))
|
||||
|| !update_index(db, row)) {
|
||||
if (row[DB_srpid])
|
||||
OPENSSL_free(row[DB_srpid]);
|
||||
if (row[DB_srpgN])
|
||||
OPENSSL_free(row[DB_srpgN]);
|
||||
if (row[DB_srpinfo])
|
||||
OPENSSL_free(row[DB_srpinfo]);
|
||||
if (row[DB_srptype])
|
||||
OPENSSL_free(row[DB_srptype]);
|
||||
if (row[DB_srpverifier])
|
||||
OPENSSL_free(row[DB_srpverifier]);
|
||||
if (row[DB_srpsalt])
|
||||
OPENSSL_free(row[DB_srpsalt]);
|
||||
OPENSSL_free(row[DB_srpid]);
|
||||
OPENSSL_free(row[DB_srpgN]);
|
||||
OPENSSL_free(row[DB_srpinfo]);
|
||||
OPENSSL_free(row[DB_srptype]);
|
||||
OPENSSL_free(row[DB_srpverifier]);
|
||||
OPENSSL_free(row[DB_srpsalt]);
|
||||
goto end;
|
||||
}
|
||||
doupdatedb = 1;
|
||||
|
@ -676,8 +664,7 @@ int srp_main(int argc, char **argv)
|
|||
|
||||
if (verbose)
|
||||
BIO_printf(bio_err, "SRP terminating with code %d.\n", ret);
|
||||
if (tofree)
|
||||
OPENSSL_free(tofree);
|
||||
OPENSSL_free(tofree);
|
||||
if (ret)
|
||||
ERR_print_errors(bio_err);
|
||||
if (randfile)
|
||||
|
|
|
@ -955,8 +955,7 @@ int x509_main(int argc, char **argv)
|
|||
ASN1_INTEGER_free(sno);
|
||||
sk_ASN1_OBJECT_pop_free(trust, ASN1_OBJECT_free);
|
||||
sk_ASN1_OBJECT_pop_free(reject, ASN1_OBJECT_free);
|
||||
if (passin)
|
||||
OPENSSL_free(passin);
|
||||
OPENSSL_free(passin);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
@ -996,8 +995,7 @@ static ASN1_INTEGER *x509_load_serial(char *CAfile, char *serialfile,
|
|||
goto end;
|
||||
|
||||
end:
|
||||
if (buf)
|
||||
OPENSSL_free(buf);
|
||||
OPENSSL_free(buf);
|
||||
BN_free(serial);
|
||||
return bs;
|
||||
}
|
||||
|
|
|
@ -168,8 +168,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
|
|||
s = NULL;
|
||||
|
||||
ret->length = (int)len;
|
||||
if (ret->data != NULL)
|
||||
OPENSSL_free(ret->data);
|
||||
OPENSSL_free(ret->data);
|
||||
ret->data = s;
|
||||
ret->type = V_ASN1_BIT_STRING;
|
||||
if (a != NULL)
|
||||
|
|
|
@ -75,8 +75,7 @@ int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
|
|||
|
||||
a->type = V_ASN1_ENUMERATED;
|
||||
if (a->length < (int)(sizeof(long) + 1)) {
|
||||
if (a->data != NULL)
|
||||
OPENSSL_free(a->data);
|
||||
OPENSSL_free(a->data);
|
||||
if ((a->data = OPENSSL_malloc(sizeof(long) + 1)) != NULL)
|
||||
memset((char *)a->data, 0, sizeof(long) + 1);
|
||||
}
|
||||
|
|
|
@ -243,8 +243,7 @@ ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
|
|||
ASN1err(ASN1_F_ASN1_GENERALIZEDTIME_ADJ, ERR_R_MALLOC_FAILURE);
|
||||
return (NULL);
|
||||
}
|
||||
if (s->data != NULL)
|
||||
OPENSSL_free(s->data);
|
||||
OPENSSL_free(s->data);
|
||||
s->data = (unsigned char *)p;
|
||||
}
|
||||
|
||||
|
|
|
@ -258,8 +258,7 @@ ASN1_INTEGER *c2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **pp,
|
|||
memcpy(s, p, (int)len);
|
||||
}
|
||||
|
||||
if (ret->data != NULL)
|
||||
OPENSSL_free(ret->data);
|
||||
OPENSSL_free(ret->data);
|
||||
ret->data = s;
|
||||
ret->length = (int)len;
|
||||
if (a != NULL)
|
||||
|
@ -327,8 +326,7 @@ ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
|
|||
p += len;
|
||||
}
|
||||
|
||||
if (ret->data != NULL)
|
||||
OPENSSL_free(ret->data);
|
||||
OPENSSL_free(ret->data);
|
||||
ret->data = s;
|
||||
ret->length = (int)len;
|
||||
if (a != NULL)
|
||||
|
@ -349,8 +347,7 @@ int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)
|
|||
unsigned char buf[sizeof(long) + 1];
|
||||
|
||||
if (a->length < (int)(sizeof(long) + 1)) {
|
||||
if (a->data != NULL)
|
||||
OPENSSL_free(a->data);
|
||||
OPENSSL_free(a->data);
|
||||
if ((a->data = OPENSSL_malloc(sizeof(long) + 1)) != NULL)
|
||||
memset((char *)a->data, 0, sizeof(long) + 1);
|
||||
}
|
||||
|
|
|
@ -190,11 +190,9 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
|
|||
if (*out) {
|
||||
free_out = 0;
|
||||
dest = *out;
|
||||
if (dest->data) {
|
||||
dest->length = 0;
|
||||
OPENSSL_free(dest->data);
|
||||
dest->data = NULL;
|
||||
}
|
||||
OPENSSL_free(dest->data);
|
||||
dest->data = NULL;
|
||||
dest->length = 0;
|
||||
dest->type = str_type;
|
||||
} else {
|
||||
free_out = 1;
|
||||
|
|
|
@ -313,8 +313,7 @@ ASN1_OBJECT *c2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp,
|
|||
/* once detached we can change it */
|
||||
if ((data == NULL) || (ret->length < length)) {
|
||||
ret->length = 0;
|
||||
if (data != NULL)
|
||||
OPENSSL_free(data);
|
||||
OPENSSL_free(data);
|
||||
data = OPENSSL_malloc(length);
|
||||
if (data == NULL) {
|
||||
i = ERR_R_MALLOC_FAILURE;
|
||||
|
@ -368,16 +367,13 @@ void ASN1_OBJECT_free(ASN1_OBJECT *a)
|
|||
#ifndef CONST_STRICT /* disable purely for compile-time strict
|
||||
* const checking. Doing this on a "real"
|
||||
* compile will cause memory leaks */
|
||||
if (a->sn != NULL)
|
||||
OPENSSL_free((void *)a->sn);
|
||||
if (a->ln != NULL)
|
||||
OPENSSL_free((void *)a->ln);
|
||||
OPENSSL_free((void*)a->sn);
|
||||
OPENSSL_free((void*)a->ln);
|
||||
#endif
|
||||
a->sn = a->ln = NULL;
|
||||
}
|
||||
if (a->flags & ASN1_OBJECT_FLAG_DYNAMIC_DATA) {
|
||||
if (a->data != NULL)
|
||||
OPENSSL_free((void *)a->data);
|
||||
OPENSSL_free((void*)a->data);
|
||||
a->data = NULL;
|
||||
a->length = 0;
|
||||
}
|
||||
|
|
|
@ -190,8 +190,7 @@ int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1, X509_ALGOR *algor2,
|
|||
ASN1err(ASN1_F_ASN1_SIGN, ERR_R_EVP_LIB);
|
||||
goto err;
|
||||
}
|
||||
if (signature->data != NULL)
|
||||
OPENSSL_free(signature->data);
|
||||
OPENSSL_free(signature->data);
|
||||
signature->data = buf_out;
|
||||
buf_out = NULL;
|
||||
signature->length = outl;
|
||||
|
@ -300,8 +299,7 @@ int ASN1_item_sign_ctx(const ASN1_ITEM *it,
|
|||
ASN1err(ASN1_F_ASN1_ITEM_SIGN_CTX, ERR_R_EVP_LIB);
|
||||
goto err;
|
||||
}
|
||||
if (signature->data != NULL)
|
||||
OPENSSL_free(signature->data);
|
||||
OPENSSL_free(signature->data);
|
||||
signature->data = buf_out;
|
||||
buf_out = NULL;
|
||||
signature->length = outl;
|
||||
|
|
|
@ -218,8 +218,7 @@ ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t,
|
|||
ASN1err(ASN1_F_ASN1_UTCTIME_ADJ, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
if (s->data != NULL)
|
||||
OPENSSL_free(s->data);
|
||||
OPENSSL_free(s->data);
|
||||
s->data = (unsigned char *)p;
|
||||
}
|
||||
|
||||
|
|
|
@ -384,10 +384,8 @@ void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst,
|
|||
void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth)
|
||||
{
|
||||
if (ameth && (ameth->pkey_flags & ASN1_PKEY_DYNAMIC)) {
|
||||
if (ameth->pem_str)
|
||||
OPENSSL_free(ameth->pem_str);
|
||||
if (ameth->info)
|
||||
OPENSSL_free(ameth->info);
|
||||
OPENSSL_free(ameth->pem_str);
|
||||
OPENSSL_free(ameth->info);
|
||||
OPENSSL_free(ameth);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -280,10 +280,8 @@ static ASN1_TYPE *generate_v3(char *str, X509V3_CTX *cnf, int depth,
|
|||
ret = d2i_ASN1_TYPE(NULL, &cp, len);
|
||||
|
||||
err:
|
||||
if (orig_der)
|
||||
OPENSSL_free(orig_der);
|
||||
if (new_der)
|
||||
OPENSSL_free(new_der);
|
||||
OPENSSL_free(orig_der);
|
||||
OPENSSL_free(new_der);
|
||||
|
||||
return ret;
|
||||
|
||||
|
@ -510,8 +508,7 @@ static ASN1_TYPE *asn1_multi(int utype, const char *section, X509V3_CTX *cnf,
|
|||
|
||||
bad:
|
||||
|
||||
if (der)
|
||||
OPENSSL_free(der);
|
||||
OPENSSL_free(der);
|
||||
|
||||
sk_ASN1_TYPE_pop_free(sk, ASN1_TYPE_free);
|
||||
if (sect)
|
||||
|
|
|
@ -335,8 +335,7 @@ int ASN1_STRING_set(ASN1_STRING *str, const void *_data, int len)
|
|||
|
||||
void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len)
|
||||
{
|
||||
if (str->data)
|
||||
OPENSSL_free(str->data);
|
||||
OPENSSL_free(str->data);
|
||||
str->data = data;
|
||||
str->length = len;
|
||||
}
|
||||
|
@ -366,7 +365,7 @@ void ASN1_STRING_free(ASN1_STRING *a)
|
|||
{
|
||||
if (a == NULL)
|
||||
return;
|
||||
if (a->data && !(a->flags & ASN1_STRING_FLAG_NDEF))
|
||||
if (!(a->flags & ASN1_STRING_FLAG_NDEF))
|
||||
OPENSSL_free(a->data);
|
||||
OPENSSL_free(a);
|
||||
}
|
||||
|
|
|
@ -854,12 +854,9 @@ static MIME_HEADER *mime_hdr_new(char *name, char *value)
|
|||
return mhdr;
|
||||
|
||||
err:
|
||||
if (tmpname != NULL)
|
||||
OPENSSL_free(tmpname);
|
||||
if (tmpval != NULL)
|
||||
OPENSSL_free(tmpval);
|
||||
if (mhdr != NULL)
|
||||
OPENSSL_free(mhdr);
|
||||
OPENSSL_free(tmpname);
|
||||
OPENSSL_free(tmpval);
|
||||
OPENSSL_free(mhdr);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -895,12 +892,9 @@ static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value)
|
|||
goto err;
|
||||
return 1;
|
||||
err:
|
||||
if (tmpname != NULL)
|
||||
OPENSSL_free(tmpname);
|
||||
if (tmpval != NULL)
|
||||
OPENSSL_free(tmpval);
|
||||
if (mparam != NULL)
|
||||
OPENSSL_free(mparam);
|
||||
OPENSSL_free(tmpname);
|
||||
OPENSSL_free(tmpval);
|
||||
OPENSSL_free(mparam);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -947,10 +941,8 @@ static MIME_PARAM *mime_param_find(MIME_HEADER *hdr, char *name)
|
|||
|
||||
static void mime_hdr_free(MIME_HEADER *hdr)
|
||||
{
|
||||
if (hdr->name)
|
||||
OPENSSL_free(hdr->name);
|
||||
if (hdr->value)
|
||||
OPENSSL_free(hdr->value);
|
||||
OPENSSL_free(hdr->name);
|
||||
OPENSSL_free(hdr->value);
|
||||
if (hdr->params)
|
||||
sk_MIME_PARAM_pop_free(hdr->params, mime_param_free);
|
||||
OPENSSL_free(hdr);
|
||||
|
@ -958,10 +950,8 @@ static void mime_hdr_free(MIME_HEADER *hdr)
|
|||
|
||||
static void mime_param_free(MIME_PARAM *param)
|
||||
{
|
||||
if (param->param_name)
|
||||
OPENSSL_free(param->param_name);
|
||||
if (param->param_value)
|
||||
OPENSSL_free(param->param_value);
|
||||
OPENSSL_free(param->param_name);
|
||||
OPENSSL_free(param->param_value);
|
||||
OPENSSL_free(param);
|
||||
}
|
||||
|
||||
|
|
|
@ -77,10 +77,8 @@ ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, ASN1_STRING **oct)
|
|||
} else
|
||||
octmp = *oct;
|
||||
|
||||
if (octmp->data) {
|
||||
OPENSSL_free(octmp->data);
|
||||
octmp->data = NULL;
|
||||
}
|
||||
OPENSSL_free(octmp->data);
|
||||
octmp->data = NULL;
|
||||
|
||||
if (!(octmp->length = ASN1_item_i2d(obj, &octmp->data, it))) {
|
||||
ASN1err(ASN1_F_ASN1_ITEM_PACK, ASN1_R_ENCODE_ERROR);
|
||||
|
|
|
@ -183,8 +183,7 @@ static int asn1_bio_free(BIO *b)
|
|||
|
||||
if (ctx == NULL)
|
||||
return 0;
|
||||
if (ctx->buf)
|
||||
OPENSSL_free(ctx->buf);
|
||||
OPENSSL_free(ctx->buf);
|
||||
OPENSSL_free(ctx);
|
||||
b->init = 0;
|
||||
b->ptr = NULL;
|
||||
|
|
|
@ -143,8 +143,7 @@ BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it)
|
|||
|
||||
err:
|
||||
BIO_free(asn_bio);
|
||||
if (ndef_aux)
|
||||
OPENSSL_free(ndef_aux);
|
||||
OPENSSL_free(ndef_aux);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -186,8 +185,7 @@ static int ndef_prefix_free(BIO *b, unsigned char **pbuf, int *plen,
|
|||
|
||||
ndef_aux = *(NDEF_SUPPORT **)parg;
|
||||
|
||||
if (ndef_aux->derbuf)
|
||||
OPENSSL_free(ndef_aux->derbuf);
|
||||
OPENSSL_free(ndef_aux->derbuf);
|
||||
|
||||
ndef_aux->derbuf = NULL;
|
||||
*pbuf = NULL;
|
||||
|
|
|
@ -154,8 +154,7 @@ int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size)
|
|||
sp = OPENSSL_realloc(s, (unsigned int)num + i * 2);
|
||||
if (sp == NULL) {
|
||||
ASN1err(ASN1_F_A2I_ASN1_ENUMERATED, ERR_R_MALLOC_FAILURE);
|
||||
if (s != NULL)
|
||||
OPENSSL_free(s);
|
||||
OPENSSL_free(s);
|
||||
goto err;
|
||||
}
|
||||
s = sp;
|
||||
|
|
|
@ -168,8 +168,7 @@ int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size)
|
|||
sp = OPENSSL_realloc_clean(s, slen, num + i * 2);
|
||||
if (sp == NULL) {
|
||||
ASN1err(ASN1_F_A2I_ASN1_INTEGER, ERR_R_MALLOC_FAILURE);
|
||||
if (s != NULL)
|
||||
OPENSSL_free(s);
|
||||
OPENSSL_free(s);
|
||||
goto err;
|
||||
}
|
||||
s = sp;
|
||||
|
|
|
@ -160,8 +160,7 @@ int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size)
|
|||
sp = OPENSSL_realloc(s, (unsigned int)num + i * 2);
|
||||
if (sp == NULL) {
|
||||
ASN1err(ASN1_F_A2I_ASN1_STRING, ERR_R_MALLOC_FAILURE);
|
||||
if (s != NULL)
|
||||
OPENSSL_free(s);
|
||||
OPENSSL_free(s);
|
||||
goto err;
|
||||
}
|
||||
s = sp;
|
||||
|
|
|
@ -249,8 +249,7 @@ int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflags,
|
|||
}
|
||||
ret = 1;
|
||||
err:
|
||||
if (m != NULL)
|
||||
OPENSSL_free(m);
|
||||
OPENSSL_free(m);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
@ -299,8 +298,7 @@ int X509_ocspid_print(BIO *bp, X509 *x)
|
|||
|
||||
return (1);
|
||||
err:
|
||||
if (der != NULL)
|
||||
OPENSSL_free(der);
|
||||
OPENSSL_free(der);
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
|
|
@ -765,7 +765,7 @@ static int asn1_d2i_ex_primitive(ASN1_VALUE **pval,
|
|||
*in = p;
|
||||
ret = 1;
|
||||
err:
|
||||
if (free_cont && buf.data)
|
||||
if (free_cont)
|
||||
OPENSSL_free(buf.data);
|
||||
return ret;
|
||||
}
|
||||
|
@ -882,8 +882,7 @@ static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
|
|||
}
|
||||
/* If we've already allocated a buffer use it */
|
||||
if (*free_cont) {
|
||||
if (stmp->data)
|
||||
OPENSSL_free(stmp->data);
|
||||
OPENSSL_free(stmp->data);
|
||||
stmp->data = (unsigned char *)cont; /* UGLY CAST! RL */
|
||||
stmp->length = len;
|
||||
*free_cont = 0;
|
||||
|
|
|
@ -100,8 +100,7 @@ ASN1_PCTX *ASN1_PCTX_new(void)
|
|||
|
||||
void ASN1_PCTX_free(ASN1_PCTX *p)
|
||||
{
|
||||
if (p)
|
||||
OPENSSL_free(p);
|
||||
OPENSSL_free(p);
|
||||
}
|
||||
|
||||
unsigned long ASN1_PCTX_get_flags(ASN1_PCTX *p)
|
||||
|
|
|
@ -86,8 +86,7 @@ ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx))
|
|||
|
||||
void ASN1_SCTX_free(ASN1_SCTX *p)
|
||||
{
|
||||
if (p)
|
||||
OPENSSL_free(p);
|
||||
OPENSSL_free(p);
|
||||
}
|
||||
|
||||
const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p)
|
||||
|
|
|
@ -154,8 +154,7 @@ void asn1_enc_free(ASN1_VALUE **pval, const ASN1_ITEM *it)
|
|||
ASN1_ENCODING *enc;
|
||||
enc = asn1_get_enc_ptr(pval, it);
|
||||
if (enc) {
|
||||
if (enc->enc)
|
||||
OPENSSL_free(enc->enc);
|
||||
OPENSSL_free(enc->enc);
|
||||
enc->enc = NULL;
|
||||
enc->len = 0;
|
||||
enc->modified = 1;
|
||||
|
@ -170,8 +169,7 @@ int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen,
|
|||
if (!enc)
|
||||
return 1;
|
||||
|
||||
if (enc->enc)
|
||||
OPENSSL_free(enc->enc);
|
||||
OPENSSL_free(enc->enc);
|
||||
enc->enc = OPENSSL_malloc(inlen);
|
||||
if (!enc->enc)
|
||||
return 0;
|
||||
|
|
|
@ -106,7 +106,6 @@ void X509_INFO_free(X509_INFO *x)
|
|||
X509_free(x->x509);
|
||||
X509_CRL_free(x->crl);
|
||||
X509_PKEY_free(x->x_pkey);
|
||||
if (x->enc_data != NULL)
|
||||
OPENSSL_free(x->enc_data);
|
||||
OPENSSL_free(x->enc_data);
|
||||
OPENSSL_free(x);
|
||||
}
|
||||
|
|
|
@ -113,7 +113,7 @@ void X509_PKEY_free(X509_PKEY *x)
|
|||
X509_ALGOR_free(x->enc_algor);
|
||||
ASN1_OCTET_STRING_free(x->enc_pkey);
|
||||
EVP_PKEY_free(x->dec_pkey);
|
||||
if ((x->key_data != NULL) && (x->key_free))
|
||||
if (x->key_free)
|
||||
OPENSSL_free(x->key_data);
|
||||
OPENSSL_free(x);
|
||||
}
|
||||
|
|
|
@ -340,8 +340,7 @@ int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj,
|
|||
if (!X509_ALGOR_set0(pub->algor, aobj, ptype, pval))
|
||||
return 0;
|
||||
if (penc) {
|
||||
if (pub->public_key->data)
|
||||
OPENSSL_free(pub->public_key->data);
|
||||
OPENSSL_free(pub->public_key->data);
|
||||
pub->public_key->data = penc;
|
||||
pub->public_key->length = penclen;
|
||||
/* Set number of unused bits to zero */
|
||||
|
|
|
@ -103,8 +103,7 @@ static int x509_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
|
|||
break;
|
||||
|
||||
case ASN1_OP_D2I_POST:
|
||||
if (ret->name != NULL)
|
||||
OPENSSL_free(ret->name);
|
||||
OPENSSL_free(ret->name);
|
||||
ret->name = X509_NAME_oneline(ret->cert_info->subject, NULL, 0);
|
||||
break;
|
||||
|
||||
|
@ -119,9 +118,7 @@ static int x509_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
|
|||
NAME_CONSTRAINTS_free(ret->nc);
|
||||
sk_IPAddressFamily_pop_free(ret->rfc3779_addr, IPAddressFamily_free);
|
||||
ASIdentifiers_free(ret->rfc3779_asid);
|
||||
|
||||
if (ret->name != NULL)
|
||||
OPENSSL_free(ret->name);
|
||||
OPENSSL_free(ret->name);
|
||||
break;
|
||||
|
||||
}
|
||||
|
|
|
@ -572,8 +572,7 @@ int BIO_get_accept_socket(char *host, int bind_mode)
|
|||
}
|
||||
ret = 1;
|
||||
err:
|
||||
if (str != NULL)
|
||||
OPENSSL_free(str);
|
||||
OPENSSL_free(str);
|
||||
if ((ret == 0) && (s != INVALID_SOCKET)) {
|
||||
closesocket(s);
|
||||
s = INVALID_SOCKET;
|
||||
|
|
|
@ -127,10 +127,8 @@ static int buffer_free(BIO *a)
|
|||
if (a == NULL)
|
||||
return (0);
|
||||
b = (BIO_F_BUFFER_CTX *)a->ptr;
|
||||
if (b->ibuf != NULL)
|
||||
OPENSSL_free(b->ibuf);
|
||||
if (b->obuf != NULL)
|
||||
OPENSSL_free(b->obuf);
|
||||
OPENSSL_free(b->ibuf);
|
||||
OPENSSL_free(b->obuf);
|
||||
OPENSSL_free(a->ptr);
|
||||
a->ptr = NULL;
|
||||
a->init = 0;
|
||||
|
@ -339,8 +337,7 @@ static long buffer_ctrl(BIO *b, int cmd, long num, void *ptr)
|
|||
p1 = OPENSSL_malloc((int)num);
|
||||
if (p1 == NULL)
|
||||
goto malloc_error;
|
||||
if (ctx->ibuf != NULL)
|
||||
OPENSSL_free(ctx->ibuf);
|
||||
OPENSSL_free(ctx->ibuf);
|
||||
ctx->ibuf = p1;
|
||||
}
|
||||
ctx->ibuf_off = 0;
|
||||
|
|
|
@ -128,8 +128,7 @@ static int linebuffer_free(BIO *a)
|
|||
if (a == NULL)
|
||||
return (0);
|
||||
b = (BIO_LINEBUFFER_CTX *)a->ptr;
|
||||
if (b->obuf != NULL)
|
||||
OPENSSL_free(b->obuf);
|
||||
OPENSSL_free(b->obuf);
|
||||
OPENSSL_free(a->ptr);
|
||||
a->ptr = NULL;
|
||||
a->init = 0;
|
||||
|
|
|
@ -116,8 +116,7 @@ static int nbiof_free(BIO *a)
|
|||
{
|
||||
if (a == NULL)
|
||||
return (0);
|
||||
if (a->ptr != NULL)
|
||||
OPENSSL_free(a->ptr);
|
||||
OPENSSL_free(a->ptr);
|
||||
a->ptr = NULL;
|
||||
a->init = 0;
|
||||
a->flags = 0;
|
||||
|
|
|
@ -151,10 +151,8 @@ static void BIO_ACCEPT_free(BIO_ACCEPT *a)
|
|||
if (a == NULL)
|
||||
return;
|
||||
|
||||
if (a->param_addr != NULL)
|
||||
OPENSSL_free(a->param_addr);
|
||||
if (a->addr != NULL)
|
||||
OPENSSL_free(a->addr);
|
||||
OPENSSL_free(a->param_addr);
|
||||
OPENSSL_free(a->addr);
|
||||
BIO_free(a->bio_chain);
|
||||
OPENSSL_free(a);
|
||||
}
|
||||
|
@ -353,8 +351,7 @@ static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr)
|
|||
if (ptr != NULL) {
|
||||
if (num == 0) {
|
||||
b->init = 1;
|
||||
if (data->param_addr != NULL)
|
||||
OPENSSL_free(data->param_addr);
|
||||
OPENSSL_free(data->param_addr);
|
||||
data->param_addr = BUF_strdup(ptr);
|
||||
} else if (num == 1) {
|
||||
data->accept_nbio = (ptr != NULL);
|
||||
|
|
|
@ -170,10 +170,7 @@ static int bio_free(BIO *bio)
|
|||
if (b->peer)
|
||||
bio_destroy_pair(bio);
|
||||
|
||||
if (b->buf != NULL) {
|
||||
OPENSSL_free(b->buf);
|
||||
}
|
||||
|
||||
OPENSSL_free(b->buf);
|
||||
OPENSSL_free(b);
|
||||
|
||||
return 1;
|
||||
|
@ -507,10 +504,8 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
|
|||
size_t new_size = num;
|
||||
|
||||
if (b->size != new_size) {
|
||||
if (b->buf) {
|
||||
OPENSSL_free(b->buf);
|
||||
b->buf = NULL;
|
||||
}
|
||||
OPENSSL_free(b->buf);
|
||||
b->buf = NULL;
|
||||
b->size = new_size;
|
||||
}
|
||||
ret = 1;
|
||||
|
|
|
@ -148,8 +148,7 @@ static int conn_state(BIO *b, BIO_CONNECT *c)
|
|||
*q = '\0';
|
||||
break;
|
||||
}
|
||||
if (c->param_port != NULL)
|
||||
OPENSSL_free(c->param_port);
|
||||
OPENSSL_free(c->param_port);
|
||||
c->param_port = BUF_strdup(p);
|
||||
}
|
||||
}
|
||||
|
@ -308,10 +307,8 @@ void BIO_CONNECT_free(BIO_CONNECT *a)
|
|||
if (a == NULL)
|
||||
return;
|
||||
|
||||
if (a->param_hostname != NULL)
|
||||
OPENSSL_free(a->param_hostname);
|
||||
if (a->param_port != NULL)
|
||||
OPENSSL_free(a->param_port);
|
||||
OPENSSL_free(a->param_hostname);
|
||||
OPENSSL_free(a->param_port);
|
||||
OPENSSL_free(a);
|
||||
}
|
||||
|
||||
|
@ -455,12 +452,10 @@ static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
|
|||
if (ptr != NULL) {
|
||||
b->init = 1;
|
||||
if (num == 0) {
|
||||
if (data->param_hostname != NULL)
|
||||
OPENSSL_free(data->param_hostname);
|
||||
OPENSSL_free(data->param_hostname);
|
||||
data->param_hostname = BUF_strdup(ptr);
|
||||
} else if (num == 1) {
|
||||
if (data->param_port != NULL)
|
||||
OPENSSL_free(data->param_port);
|
||||
OPENSSL_free(data->param_port);
|
||||
data->param_port = BUF_strdup(ptr);
|
||||
} else if (num == 2) {
|
||||
char buf[16];
|
||||
|
@ -468,16 +463,14 @@ static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
|
|||
|
||||
BIO_snprintf(buf, sizeof buf, "%d.%d.%d.%d",
|
||||
p[0], p[1], p[2], p[3]);
|
||||
if (data->param_hostname != NULL)
|
||||
OPENSSL_free(data->param_hostname);
|
||||
OPENSSL_free(data->param_hostname);
|
||||
data->param_hostname = BUF_strdup(buf);
|
||||
memcpy(&(data->ip[0]), ptr, 4);
|
||||
} else if (num == 3) {
|
||||
char buf[DECIMAL_SIZE(int) + 1];
|
||||
|
||||
BIO_snprintf(buf, sizeof buf, "%d", *(int *)ptr);
|
||||
if (data->param_port != NULL)
|
||||
OPENSSL_free(data->param_port);
|
||||
OPENSSL_free(data->param_port);
|
||||
data->param_port = BUF_strdup(buf);
|
||||
data->port = *(int *)ptr;
|
||||
}
|
||||
|
|
|
@ -245,8 +245,7 @@ static int dgram_free(BIO *a)
|
|||
return 0;
|
||||
|
||||
data = (bio_dgram_data *)a->ptr;
|
||||
if (data != NULL)
|
||||
OPENSSL_free(data);
|
||||
OPENSSL_free(data);
|
||||
|
||||
return (1);
|
||||
}
|
||||
|
@ -1110,8 +1109,7 @@ static int dgram_sctp_free(BIO *a)
|
|||
|
||||
data = (bio_dgram_sctp_data *) a->ptr;
|
||||
if (data != NULL) {
|
||||
if (data->saved_message.data != NULL)
|
||||
OPENSSL_free(data->saved_message.data);
|
||||
OPENSSL_free(data->saved_message.data);
|
||||
OPENSSL_free(data);
|
||||
}
|
||||
|
||||
|
@ -1413,8 +1411,7 @@ static int dgram_sctp_write(BIO *b, const char *in, int inl)
|
|||
BIOerr(BIO_F_DGRAM_SCTP_WRITE, ERR_R_MALLOC_FAILURE);
|
||||
return -1;
|
||||
}
|
||||
if (data->saved_message.data)
|
||||
OPENSSL_free(data->saved_message.data);
|
||||
OPENSSL_free(data->saved_message.data);
|
||||
data->saved_message.data = tmp;
|
||||
memcpy(data->saved_message.data, in, inl);
|
||||
data->saved_message.length = inl;
|
||||
|
|
|
@ -1131,8 +1131,7 @@ int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p,
|
|||
BN_MONT_CTX_free(mont);
|
||||
if (powerbuf != NULL) {
|
||||
OPENSSL_cleanse(powerbuf, powerbufLen);
|
||||
if (powerbufFree)
|
||||
OPENSSL_free(powerbufFree);
|
||||
OPENSSL_free(powerbufFree);
|
||||
}
|
||||
BN_CTX_end(ctx);
|
||||
return (ret);
|
||||
|
|
|
@ -561,8 +561,7 @@ int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|||
ret = BN_GF2m_mod_mul_arr(r, a, b, arr, ctx);
|
||||
bn_check_top(r);
|
||||
err:
|
||||
if (arr)
|
||||
OPENSSL_free(arr);
|
||||
OPENSSL_free(arr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -620,8 +619,7 @@ int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx)
|
|||
ret = BN_GF2m_mod_sqr_arr(r, a, arr, ctx);
|
||||
bn_check_top(r);
|
||||
err:
|
||||
if (arr)
|
||||
OPENSSL_free(arr);
|
||||
OPENSSL_free(arr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -1037,8 +1035,7 @@ int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
|||
ret = BN_GF2m_mod_exp_arr(r, a, b, arr, ctx);
|
||||
bn_check_top(r);
|
||||
err:
|
||||
if (arr)
|
||||
OPENSSL_free(arr);
|
||||
OPENSSL_free(arr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -1097,8 +1094,7 @@ int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx)
|
|||
ret = BN_GF2m_mod_sqrt_arr(r, a, arr, ctx);
|
||||
bn_check_top(r);
|
||||
err:
|
||||
if (arr)
|
||||
OPENSSL_free(arr);
|
||||
OPENSSL_free(arr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -1228,8 +1224,7 @@ int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
|
|||
ret = BN_GF2m_mod_solve_quad_arr(r, a, arr, ctx);
|
||||
bn_check_top(r);
|
||||
err:
|
||||
if (arr)
|
||||
OPENSSL_free(arr);
|
||||
OPENSSL_free(arr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -67,7 +67,6 @@
|
|||
signed char *bn_compute_wNAF(const BIGNUM *scalar, int w, size_t *ret_len)
|
||||
{
|
||||
int window_val;
|
||||
int ok = 0;
|
||||
signed char *r = NULL;
|
||||
int sign = 1;
|
||||
int bit, next_bit, mask;
|
||||
|
@ -176,17 +175,12 @@ signed char *bn_compute_wNAF(const BIGNUM *scalar, int w, size_t *ret_len)
|
|||
BNerr(BN_F_BN_COMPUTE_WNAF, ERR_R_INTERNAL_ERROR);
|
||||
goto err;
|
||||
}
|
||||
len = j;
|
||||
ok = 1;
|
||||
*ret_len = j;
|
||||
return r;
|
||||
|
||||
err:
|
||||
if (!ok) {
|
||||
OPENSSL_free(r);
|
||||
r = NULL;
|
||||
}
|
||||
if (ok)
|
||||
*ret_len = len;
|
||||
return r;
|
||||
OPENSSL_free(r);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int bn_get_top(const BIGNUM *a)
|
||||
|
|
|
@ -246,7 +246,7 @@ void BN_free(BIGNUM *a)
|
|||
if (a == NULL)
|
||||
return;
|
||||
bn_check_top(a);
|
||||
if ((a->d != NULL) && !(BN_get_flags(a, BN_FLG_STATIC_DATA)))
|
||||
if (!BN_get_flags(a, BN_FLG_STATIC_DATA))
|
||||
OPENSSL_free(a->d);
|
||||
if (a->flags & BN_FLG_MALLOCED)
|
||||
OPENSSL_free(a);
|
||||
|
@ -378,8 +378,7 @@ BIGNUM *bn_expand2(BIGNUM *b, int words)
|
|||
BN_ULONG *a = bn_expand_internal(b, words);
|
||||
if (!a)
|
||||
return NULL;
|
||||
if (b->d)
|
||||
OPENSSL_free(b->d);
|
||||
OPENSSL_free(b->d);
|
||||
b->d = a;
|
||||
b->dmax = words;
|
||||
}
|
||||
|
|
|
@ -156,15 +156,12 @@ char *BN_bn2dec(const BIGNUM *a)
|
|||
}
|
||||
ok = 1;
|
||||
err:
|
||||
if (bn_data != NULL)
|
||||
OPENSSL_free(bn_data);
|
||||
OPENSSL_free(bn_data);
|
||||
BN_free(t);
|
||||
if (!ok && buf) {
|
||||
OPENSSL_free(buf);
|
||||
buf = NULL;
|
||||
}
|
||||
|
||||
return (buf);
|
||||
if (ok)
|
||||
return buf;
|
||||
OPENSSL_free(buf);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int BN_hex2bn(BIGNUM **bn, const char *a)
|
||||
|
|
|
@ -351,7 +351,6 @@ int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
|
|||
ret = 1;
|
||||
|
||||
err:
|
||||
if (k_bytes)
|
||||
OPENSSL_free(k_bytes);
|
||||
OPENSSL_free(k_bytes);
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -404,8 +404,7 @@ static int cms_RecipientInfo_ktri_encrypt(CMS_ContentInfo *cms,
|
|||
EVP_PKEY_CTX_free(pctx);
|
||||
ktri->pctx = NULL;
|
||||
}
|
||||
if (ek)
|
||||
OPENSSL_free(ek);
|
||||
OPENSSL_free(ek);
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
@ -472,7 +471,7 @@ static int cms_RecipientInfo_ktri_decrypt(CMS_ContentInfo *cms,
|
|||
err:
|
||||
EVP_PKEY_CTX_free(ktri->pctx);
|
||||
ktri->pctx = NULL;
|
||||
if (!ret && ek)
|
||||
if (!ret)
|
||||
OPENSSL_free(ek);
|
||||
|
||||
return ret;
|
||||
|
@ -712,7 +711,7 @@ static int cms_RecipientInfo_kekri_encrypt(CMS_ContentInfo *cms,
|
|||
|
||||
err:
|
||||
|
||||
if (!r && wkey)
|
||||
if (!r)
|
||||
OPENSSL_free(wkey);
|
||||
OPENSSL_cleanse(&actx, sizeof(actx));
|
||||
|
||||
|
@ -785,7 +784,7 @@ static int cms_RecipientInfo_kekri_decrypt(CMS_ContentInfo *cms,
|
|||
|
||||
err:
|
||||
|
||||
if (!r && ukey)
|
||||
if (!r)
|
||||
OPENSSL_free(ukey);
|
||||
OPENSSL_cleanse(&actx, sizeof(actx));
|
||||
|
||||
|
|
|
@ -154,8 +154,7 @@ int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr)
|
|||
if (!r)
|
||||
CMSerr(CMS_F_CMS_ADD1_RECEIPTREQUEST, ERR_R_MALLOC_FAILURE);
|
||||
|
||||
if (rrder)
|
||||
OPENSSL_free(rrder);
|
||||
OPENSSL_free(rrder);
|
||||
|
||||
return r;
|
||||
|
||||
|
|
|
@ -268,7 +268,7 @@ static int cms_kek_cipher(unsigned char **pout, size_t *poutlen,
|
|||
|
||||
err:
|
||||
OPENSSL_cleanse(kek, keklen);
|
||||
if (!rv && out)
|
||||
if (!rv)
|
||||
OPENSSL_free(out);
|
||||
EVP_CIPHER_CTX_cleanup(&kari->ctx);
|
||||
EVP_PKEY_CTX_free(kari->pctx);
|
||||
|
@ -300,8 +300,7 @@ int CMS_RecipientInfo_kari_decrypt(CMS_ContentInfo *cms,
|
|||
cek = NULL;
|
||||
rv = 1;
|
||||
err:
|
||||
if (cek)
|
||||
OPENSSL_free(cek);
|
||||
OPENSSL_free(cek);
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
|
|
@ -420,7 +420,7 @@ int cms_RecipientInfo_pwri_crypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri,
|
|||
|
||||
EVP_CIPHER_CTX_cleanup(&kekctx);
|
||||
|
||||
if (!r && key)
|
||||
if (!r)
|
||||
OPENSSL_free(key);
|
||||
X509_ALGOR_free(kekalg);
|
||||
|
||||
|
|
|
@ -728,8 +728,7 @@ int CMS_SignerInfo_sign(CMS_SignerInfo *si)
|
|||
return 1;
|
||||
|
||||
err:
|
||||
if (abuf)
|
||||
OPENSSL_free(abuf);
|
||||
OPENSSL_free(abuf);
|
||||
EVP_MD_CTX_cleanup(mctx);
|
||||
return 0;
|
||||
|
||||
|
|
|
@ -151,8 +151,7 @@ static int zlib_stateful_init(COMP_CTX *ctx)
|
|||
CRYPTO_set_ex_data(&ctx->ex_data, zlib_stateful_ex_idx, state);
|
||||
return 1;
|
||||
err:
|
||||
if (state)
|
||||
OPENSSL_free(state);
|
||||
OPENSSL_free(state);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -606,18 +605,14 @@ static long bio_zlib_ctrl(BIO *b, int cmd, long num, void *ptr)
|
|||
}
|
||||
|
||||
if (ibs != -1) {
|
||||
if (ctx->ibuf) {
|
||||
OPENSSL_free(ctx->ibuf);
|
||||
ctx->ibuf = NULL;
|
||||
}
|
||||
OPENSSL_free(ctx->ibuf);
|
||||
ctx->ibuf = NULL;
|
||||
ctx->ibufsize = ibs;
|
||||
}
|
||||
|
||||
if (obs != -1) {
|
||||
if (ctx->obuf) {
|
||||
OPENSSL_free(ctx->obuf);
|
||||
ctx->obuf = NULL;
|
||||
}
|
||||
OPENSSL_free(ctx->obuf);
|
||||
ctx->obuf = NULL;
|
||||
ctx->obufsize = obs;
|
||||
}
|
||||
ret = 1;
|
||||
|
|
|
@ -273,8 +273,7 @@ CONF_VALUE *_CONF_new_section(CONF *conf, const char *section)
|
|||
if (!ok) {
|
||||
if (sk != NULL)
|
||||
sk_CONF_VALUE_free(sk);
|
||||
if (v != NULL)
|
||||
OPENSSL_free(v);
|
||||
OPENSSL_free(v);
|
||||
v = NULL;
|
||||
}
|
||||
return (v);
|
||||
|
|
|
@ -393,14 +393,12 @@ static int def_load_bio(CONF *conf, BIO *in, long *line)
|
|||
}
|
||||
if (buff != NULL)
|
||||
BUF_MEM_free(buff);
|
||||
if (section != NULL)
|
||||
OPENSSL_free(section);
|
||||
OPENSSL_free(section);
|
||||
return (1);
|
||||
err:
|
||||
if (buff != NULL)
|
||||
BUF_MEM_free(buff);
|
||||
if (section != NULL)
|
||||
OPENSSL_free(section);
|
||||
OPENSSL_free(section);
|
||||
if (line != NULL)
|
||||
*line = eline;
|
||||
BIO_snprintf(btmp, sizeof btmp, "%ld", eline);
|
||||
|
@ -410,12 +408,9 @@ static int def_load_bio(CONF *conf, BIO *in, long *line)
|
|||
conf->data = NULL;
|
||||
}
|
||||
if (v != NULL) {
|
||||
if (v->name != NULL)
|
||||
OPENSSL_free(v->name);
|
||||
if (v->value != NULL)
|
||||
OPENSSL_free(v->value);
|
||||
if (v != NULL)
|
||||
OPENSSL_free(v);
|
||||
OPENSSL_free(v->name);
|
||||
OPENSSL_free(v->value);
|
||||
OPENSSL_free(v);
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
|
@ -595,8 +590,7 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from)
|
|||
buf->data[to++] = *(from++);
|
||||
}
|
||||
buf->data[to] = '\0';
|
||||
if (*pto != NULL)
|
||||
OPENSSL_free(*pto);
|
||||
OPENSSL_free(*pto);
|
||||
*pto = buf->data;
|
||||
OPENSSL_free(buf);
|
||||
return (1);
|
||||
|
|
|
@ -383,10 +383,8 @@ static int module_init(CONF_MODULE *pmod, char *name, char *value,
|
|||
|
||||
memerr:
|
||||
if (imod) {
|
||||
if (imod->name)
|
||||
OPENSSL_free(imod->name);
|
||||
if (imod->value)
|
||||
OPENSSL_free(imod->value);
|
||||
OPENSSL_free(imod->name);
|
||||
OPENSSL_free(imod->value);
|
||||
OPENSSL_free(imod);
|
||||
}
|
||||
|
||||
|
|
|
@ -187,8 +187,7 @@ static int dh_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
|
|||
return 1;
|
||||
|
||||
err:
|
||||
if (penc)
|
||||
OPENSSL_free(penc);
|
||||
OPENSSL_free(penc);
|
||||
ASN1_STRING_free(str);
|
||||
|
||||
return 0;
|
||||
|
@ -292,8 +291,7 @@ static int dh_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
|
|||
return 1;
|
||||
|
||||
err:
|
||||
if (dp != NULL)
|
||||
OPENSSL_free(dp);
|
||||
OPENSSL_free(dp);
|
||||
ASN1_STRING_free(params);
|
||||
ASN1_STRING_clear_free(prkey);
|
||||
return 0;
|
||||
|
@ -422,8 +420,7 @@ static int do_dh_print(BIO *bp, const DH *x, int indent,
|
|||
err:
|
||||
DHerr(DH_F_DO_DH_PRINT, reason);
|
||||
}
|
||||
if (m != NULL)
|
||||
OPENSSL_free(m);
|
||||
OPENSSL_free(m);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
@ -481,11 +478,9 @@ static int int_dh_param_copy(DH *to, const DH *from, int is_x942)
|
|||
return 0;
|
||||
if (!int_dh_bn_cpy(&to->j, from->j))
|
||||
return 0;
|
||||
if (to->seed) {
|
||||
OPENSSL_free(to->seed);
|
||||
to->seed = NULL;
|
||||
to->seedlen = 0;
|
||||
}
|
||||
OPENSSL_free(to->seed);
|
||||
to->seed = NULL;
|
||||
to->seedlen = 0;
|
||||
if (from->seed) {
|
||||
to->seed = BUF_memdup(from->seed, from->seedlen);
|
||||
if (!to->seed)
|
||||
|
|
|
@ -180,8 +180,7 @@ int DH_KDF_X9_42(unsigned char *out, size_t outlen,
|
|||
}
|
||||
rv = 1;
|
||||
err:
|
||||
if (der)
|
||||
OPENSSL_free(der);
|
||||
OPENSSL_free(der);
|
||||
EVP_MD_CTX_cleanup(&mctx);
|
||||
return rv;
|
||||
}
|
||||
|
|
|
@ -198,8 +198,7 @@ void DH_free(DH *r)
|
|||
BN_clear_free(r->g);
|
||||
BN_clear_free(r->q);
|
||||
BN_clear_free(r->j);
|
||||
if (r->seed)
|
||||
OPENSSL_free(r->seed);
|
||||
OPENSSL_free(r->seed);
|
||||
BN_clear_free(r->counter);
|
||||
BN_clear_free(r->pub_key);
|
||||
BN_clear_free(r->priv_key);
|
||||
|
|
|
@ -153,8 +153,7 @@ static void pkey_dh_cleanup(EVP_PKEY_CTX *ctx)
|
|||
{
|
||||
DH_PKEY_CTX *dctx = ctx->data;
|
||||
if (dctx) {
|
||||
if (dctx->kdf_ukm)
|
||||
OPENSSL_free(dctx->kdf_ukm);
|
||||
OPENSSL_free(dctx->kdf_ukm);
|
||||
ASN1_OBJECT_free(dctx->kdf_oid);
|
||||
OPENSSL_free(dctx);
|
||||
}
|
||||
|
@ -230,8 +229,7 @@ static int pkey_dh_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
|
|||
return 1;
|
||||
|
||||
case EVP_PKEY_CTRL_DH_KDF_UKM:
|
||||
if (dctx->kdf_ukm)
|
||||
OPENSSL_free(dctx->kdf_ukm);
|
||||
OPENSSL_free(dctx->kdf_ukm);
|
||||
dctx->kdf_ukm = p2;
|
||||
if (p2)
|
||||
dctx->kdf_ukmlen = p1;
|
||||
|
|
|
@ -169,8 +169,7 @@ static int dsa_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
|
|||
return 1;
|
||||
|
||||
err:
|
||||
if (penc)
|
||||
OPENSSL_free(penc);
|
||||
OPENSSL_free(penc);
|
||||
ASN1_STRING_free(str);
|
||||
|
||||
return 0;
|
||||
|
@ -329,8 +328,7 @@ static int dsa_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
|
|||
return 1;
|
||||
|
||||
err:
|
||||
if (dp != NULL)
|
||||
OPENSSL_free(dp);
|
||||
OPENSSL_free(dp);
|
||||
ASN1_STRING_free(params);
|
||||
ASN1_STRING_clear_free(prkey);
|
||||
return 0;
|
||||
|
@ -471,8 +469,7 @@ static int do_dsa_print(BIO *bp, const DSA *x, int off, int ptype)
|
|||
goto err;
|
||||
ret = 1;
|
||||
err:
|
||||
if (m != NULL)
|
||||
OPENSSL_free(m);
|
||||
OPENSSL_free(m);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
@ -562,8 +559,7 @@ static int dsa_sig_print(BIO *bp, const X509_ALGOR *sigalg,
|
|||
goto err;
|
||||
rv = 1;
|
||||
err:
|
||||
if (m)
|
||||
OPENSSL_free(m);
|
||||
OPENSSL_free(m);
|
||||
DSA_SIG_free(dsa_sig);
|
||||
return rv;
|
||||
}
|
||||
|
|
|
@ -644,8 +644,7 @@ int dsa_builtin_paramgen2(DSA *ret, size_t L, size_t N,
|
|||
if (h_ret != NULL)
|
||||
*h_ret = h;
|
||||
}
|
||||
if (seed)
|
||||
OPENSSL_free(seed);
|
||||
OPENSSL_free(seed);
|
||||
if (seed_out != seed_tmp)
|
||||
OPENSSL_free(seed_tmp);
|
||||
if (ctx)
|
||||
|
|
|
@ -113,8 +113,7 @@ static int pkey_dsa_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
|
|||
static void pkey_dsa_cleanup(EVP_PKEY_CTX *ctx)
|
||||
{
|
||||
DSA_PKEY_CTX *dctx = ctx->data;
|
||||
if (dctx)
|
||||
OPENSSL_free(dctx);
|
||||
OPENSSL_free(dctx);
|
||||
}
|
||||
|
||||
static int pkey_dsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig,
|
||||
|
|
|
@ -143,8 +143,7 @@ static int dl_load(DSO *dso)
|
|||
return (1);
|
||||
err:
|
||||
/* Cleanup! */
|
||||
if (filename != NULL)
|
||||
OPENSSL_free(filename);
|
||||
OPENSSL_free(filename);
|
||||
if (ptr != NULL)
|
||||
shl_unload(ptr);
|
||||
return (0);
|
||||
|
|
|
@ -182,8 +182,7 @@ static int dlfcn_load(DSO *dso)
|
|||
return (1);
|
||||
err:
|
||||
/* Cleanup! */
|
||||
if (filename != NULL)
|
||||
OPENSSL_free(filename);
|
||||
OPENSSL_free(filename);
|
||||
if (ptr != NULL)
|
||||
dlclose(ptr);
|
||||
return (0);
|
||||
|
|
|
@ -162,11 +162,8 @@ int DSO_free(DSO *dso)
|
|||
}
|
||||
|
||||
sk_void_free(dso->meth_data);
|
||||
if (dso->filename != NULL)
|
||||
OPENSSL_free(dso->filename);
|
||||
if (dso->loaded_filename != NULL)
|
||||
OPENSSL_free(dso->loaded_filename);
|
||||
|
||||
OPENSSL_free(dso->filename);
|
||||
OPENSSL_free(dso->loaded_filename);
|
||||
OPENSSL_free(dso);
|
||||
return (1);
|
||||
}
|
||||
|
@ -360,8 +357,7 @@ int DSO_set_filename(DSO *dso, const char *filename)
|
|||
return (0);
|
||||
}
|
||||
BUF_strlcpy(copied, filename, strlen(filename) + 1);
|
||||
if (dso->filename)
|
||||
OPENSSL_free(dso->filename);
|
||||
OPENSSL_free(dso->filename);
|
||||
dso->filename = copied;
|
||||
return (1);
|
||||
}
|
||||
|
|
|
@ -267,10 +267,8 @@ static int vms_load(DSO *dso)
|
|||
return (1);
|
||||
err:
|
||||
/* Cleanup! */
|
||||
if (p != NULL)
|
||||
OPENSSL_free(p);
|
||||
if (filename != NULL)
|
||||
OPENSSL_free(filename);
|
||||
OPENSSL_free(p);
|
||||
OPENSSL_free(filename);
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
|
|
@ -183,10 +183,8 @@ static int win32_load(DSO *dso)
|
|||
return (1);
|
||||
err:
|
||||
/* Cleanup ! */
|
||||
if (filename != NULL)
|
||||
OPENSSL_free(filename);
|
||||
if (p != NULL)
|
||||
OPENSSL_free(p);
|
||||
OPENSSL_free(filename);
|
||||
OPENSSL_free(p);
|
||||
if (h != NULL)
|
||||
FreeLibrary(h);
|
||||
return (0);
|
||||
|
|
|
@ -132,8 +132,7 @@ static int eckey_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
|
|||
ASN1_OBJECT_free(pval);
|
||||
else
|
||||
ASN1_STRING_free(pval);
|
||||
if (penc)
|
||||
OPENSSL_free(penc);
|
||||
OPENSSL_free(penc);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -503,8 +502,7 @@ static int do_EC_KEY_print(BIO *bp, const EC_KEY *x, int off, int ktype)
|
|||
BN_free(pub_key);
|
||||
BN_free(order);
|
||||
BN_CTX_free(ctx);
|
||||
if (buffer != NULL)
|
||||
OPENSSL_free(buffer);
|
||||
OPENSSL_free(buffer);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
|
|
@ -525,10 +525,8 @@ static int ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
|
|||
ok = 1;
|
||||
|
||||
err:
|
||||
if (buffer_1)
|
||||
OPENSSL_free(buffer_1);
|
||||
if (buffer_2)
|
||||
OPENSSL_free(buffer_2);
|
||||
OPENSSL_free(buffer_1);
|
||||
OPENSSL_free(buffer_2);
|
||||
BN_free(tmp_1);
|
||||
BN_free(tmp_2);
|
||||
return (ok);
|
||||
|
@ -628,8 +626,7 @@ static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *group,
|
|||
if (!param)
|
||||
ECPARAMETERS_free(ret);
|
||||
BN_free(tmp);
|
||||
if (buffer)
|
||||
OPENSSL_free(buffer);
|
||||
OPENSSL_free(buffer);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -840,8 +837,7 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params)
|
|||
|
||||
/* extract seed (optional) */
|
||||
if (params->curve->seed != NULL) {
|
||||
if (ret->seed != NULL)
|
||||
OPENSSL_free(ret->seed);
|
||||
OPENSSL_free(ret->seed);
|
||||
if (!(ret->seed = OPENSSL_malloc(params->curve->seed->length))) {
|
||||
ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
|
@ -1193,8 +1189,7 @@ int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
|
|||
}
|
||||
ok = 1;
|
||||
err:
|
||||
if (buffer)
|
||||
OPENSSL_free(buffer);
|
||||
OPENSSL_free(buffer);
|
||||
if (priv_key)
|
||||
EC_PRIVATEKEY_free(priv_key);
|
||||
return (ok ? ret : 0);
|
||||
|
|
|
@ -232,8 +232,7 @@ int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
|
|||
dest->asn1_form = src->asn1_form;
|
||||
|
||||
if (src->seed) {
|
||||
if (dest->seed)
|
||||
OPENSSL_free(dest->seed);
|
||||
OPENSSL_free(dest->seed);
|
||||
dest->seed = OPENSSL_malloc(src->seed_len);
|
||||
if (dest->seed == NULL)
|
||||
return 0;
|
||||
|
@ -241,8 +240,7 @@ int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
|
|||
return 0;
|
||||
dest->seed_len = src->seed_len;
|
||||
} else {
|
||||
if (dest->seed)
|
||||
OPENSSL_free(dest->seed);
|
||||
OPENSSL_free(dest->seed);
|
||||
dest->seed = NULL;
|
||||
dest->seed_len = 0;
|
||||
}
|
||||
|
@ -382,11 +380,9 @@ point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP
|
|||
|
||||
size_t EC_GROUP_set_seed(EC_GROUP *group, const unsigned char *p, size_t len)
|
||||
{
|
||||
if (group->seed) {
|
||||
OPENSSL_free(group->seed);
|
||||
group->seed = NULL;
|
||||
group->seed_len = 0;
|
||||
}
|
||||
OPENSSL_free(group->seed);
|
||||
group->seed = NULL;
|
||||
group->seed_len = 0;
|
||||
|
||||
if (!len || !p)
|
||||
return 1;
|
||||
|
|
|
@ -555,10 +555,8 @@ int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
|
|||
err:
|
||||
BN_CTX_free(new_ctx);
|
||||
EC_POINT_free(tmp);
|
||||
if (wsize != NULL)
|
||||
OPENSSL_free(wsize);
|
||||
if (wNAF_len != NULL)
|
||||
OPENSSL_free(wNAF_len);
|
||||
OPENSSL_free(wsize);
|
||||
OPENSSL_free(wNAF_len);
|
||||
if (wNAF != NULL) {
|
||||
signed char **w;
|
||||
|
||||
|
@ -573,9 +571,7 @@ int ec_wNAF_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
|
|||
|
||||
OPENSSL_free(val);
|
||||
}
|
||||
if (val_sub != NULL) {
|
||||
OPENSSL_free(val_sub);
|
||||
}
|
||||
OPENSSL_free(val_sub);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -148,8 +148,7 @@ static void pkey_ec_cleanup(EVP_PKEY_CTX *ctx)
|
|||
if (dctx) {
|
||||
EC_GROUP_free(dctx->gen_group);
|
||||
EC_KEY_free(dctx->co_key);
|
||||
if (dctx->kdf_ukm)
|
||||
OPENSSL_free(dctx->kdf_ukm);
|
||||
OPENSSL_free(dctx->kdf_ukm);
|
||||
OPENSSL_free(dctx);
|
||||
}
|
||||
}
|
||||
|
@ -359,8 +358,7 @@ static int pkey_ec_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
|
|||
return 1;
|
||||
|
||||
case EVP_PKEY_CTRL_EC_KDF_UKM:
|
||||
if (dctx->kdf_ukm)
|
||||
OPENSSL_free(dctx->kdf_ukm);
|
||||
OPENSSL_free(dctx->kdf_ukm);
|
||||
dctx->kdf_ukm = p2;
|
||||
if (p2)
|
||||
dctx->kdf_ukmlen = p1;
|
||||
|
|
|
@ -325,8 +325,7 @@ int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off)
|
|||
BN_free(order);
|
||||
BN_free(cofactor);
|
||||
BN_CTX_free(ctx);
|
||||
if (buffer != NULL)
|
||||
OPENSSL_free(buffer);
|
||||
OPENSSL_free(buffer);
|
||||
return (ret);
|
||||
}
|
||||
|
||||
|
|
|
@ -1573,12 +1573,9 @@ int ec_GFp_nistp224_points_mul(const EC_GROUP *group, EC_POINT *r,
|
|||
BN_CTX_end(ctx);
|
||||
EC_POINT_free(generator);
|
||||
BN_CTX_free(new_ctx);
|
||||
if (secrets != NULL)
|
||||
OPENSSL_free(secrets);
|
||||
if (pre_comp != NULL)
|
||||
OPENSSL_free(pre_comp);
|
||||
if (tmp_felems != NULL)
|
||||
OPENSSL_free(tmp_felems);
|
||||
OPENSSL_free(secrets);
|
||||
OPENSSL_free(pre_comp);
|
||||
OPENSSL_free(tmp_felems);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue