Hakase/openssl-custom
1
0 Fork 0
Code Issues Pull Requests Releases Wiki Activity

Latest update.

Browse Source
This commit is contained in:
Hakase
2020-01-17 19:45:12 +09:00
parent 016df9f433
commit 0f7abb4eb6
1100 changed files with 47785 additions and 16292 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crypto/core_namemap.c
+183 -34
View File
@@ -72,9 +72,11 @@ static void stored_namemap_free(void *vnamemap)
{
OSSL_NAMEMAP *namemap = vnamemap;
/* Pretend it isn't stored, or ossl_namemap_free() will do nothing */
namemap->stored = 0;
ossl_namemap_free(namemap);
if (namemap != NULL) {
/* Pretend it isn't stored, or ossl_namemap_free() will do nothing */
namemap->stored = 0;
ossl_namemap_free(namemap);
}
}
static const OPENSSL_CTX_METHOD stored_namemap_method = {
@@ -87,36 +89,16 @@ static const OPENSSL_CTX_METHOD stored_namemap_method = {
* =============
*/
OSSL_NAMEMAP *ossl_namemap_stored(OPENSSL_CTX *libctx)
int ossl_namemap_empty(OSSL_NAMEMAP *namemap)
{
return openssl_ctx_get_data(libctx, OPENSSL_CTX_NAMEMAP_INDEX,
&stored_namemap_method);
}
int rv = 0;
OSSL_NAMEMAP *ossl_namemap_new(void)
{
OSSL_NAMEMAP *namemap;
CRYPTO_THREAD_read_lock(namemap->lock);
if (namemap->max_number == 0)
rv = 1;
CRYPTO_THREAD_unlock(namemap->lock);
if ((namemap = OPENSSL_zalloc(sizeof(*namemap))) != NULL
&& (namemap->lock = CRYPTO_THREAD_lock_new()) != NULL
&& (namemap->namenum =
lh_NAMENUM_ENTRY_new(namenum_hash, namenum_cmp)) != NULL)
return namemap;
ossl_namemap_free(namemap);
return NULL;
}
void ossl_namemap_free(OSSL_NAMEMAP *namemap)
{
if (namemap == NULL || namemap->stored)
return;
lh_NAMENUM_ENTRY_doall(namemap->namenum, namenum_free);
lh_NAMENUM_ENTRY_free(namemap->namenum);
CRYPTO_THREAD_lock_free(namemap->lock);
OPENSSL_free(namemap);
return rv;
}
typedef struct doall_names_data_st {
@@ -210,8 +192,8 @@ const char *ossl_namemap_num2name(const OSSL_NAMEMAP *namemap, int number,
return data.name;
}
int ossl_namemap_add_n(OSSL_NAMEMAP *namemap, int number,
const char *name, size_t name_len)
int ossl_namemap_add_name_n(OSSL_NAMEMAP *namemap, int number,
const char *name, size_t name_len)
{
NAMENUM_ENTRY *namenum = NULL;
int tmp_number;
@@ -251,10 +233,177 @@ int ossl_namemap_add_n(OSSL_NAMEMAP *namemap, int number,
return 0;
}
int ossl_namemap_add(OSSL_NAMEMAP *namemap, int number, const char *name)
int ossl_namemap_add_name(OSSL_NAMEMAP *namemap, int number, const char *name)
{
if (name == NULL)
return 0;
return ossl_namemap_add_n(namemap, number, name, strlen(name));
return ossl_namemap_add_name_n(namemap, number, name, strlen(name));
}
int ossl_namemap_add_names(OSSL_NAMEMAP *namemap, int number,
const char *names, const char separator)
{
const char *p, *q;
size_t l;
/* Check that we have a namemap */
if (!ossl_assert(namemap != NULL)) {
ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
/*
* Check that no name is an empty string, and that all names have at
* most one numeric identity together.
*/
for (p = names; *p != '\0'; p = (q == NULL ? p + l : q + 1)) {
int this_number;
if ((q = strchr(p, separator)) == NULL)
l = strlen(p); /* offset to \0 */
else
l = q - p; /* offset to the next separator */
this_number = ossl_namemap_name2num_n(namemap, p, l);
if (*p == '\0' || *p == separator) {
ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_BAD_ALGORITHM_NAME);
return 0;
}
if (number == 0) {
number = this_number;
} else if (this_number != 0 && this_number != number) {
ERR_raise_data(ERR_LIB_CRYPTO, CRYPTO_R_CONFLICTING_NAMES,
"\"%.*s\" has an existing different identity %d (from \"%s\")",
l, p, this_number, names);
return 0;
}
}
/* Now that we have checked, register all names */
for (p = names; *p != '\0'; p = (q == NULL ? p + l : q + 1)) {
int this_number;
if ((q = strchr(p, separator)) == NULL)
l = strlen(p); /* offset to \0 */
else
l = q - p; /* offset to the next separator */
this_number = ossl_namemap_add_name_n(namemap, number, p, l);
if (number == 0) {
number = this_number;
} else if (this_number != number) {
ERR_raise_data(ERR_LIB_CRYPTO, ERR_R_INTERNAL_ERROR,
"Got number %d when expecting %d",
this_number, number);
return 0;
}
}
return number;
}
/*-
* Pre-population
* ==============
*/
#ifndef FIPS_MODE
#include <openssl/evp.h>
/* Creates an initial namemap with names found in the legacy method db */
static void get_legacy_evp_names(const char *main_name, const char *alias,
void *arg)
{
int main_id = ossl_namemap_add_name(arg, 0, main_name);
/*
* We could check that the returned value is the same as main_id,
* but since this is a void function, there's no sane way to report
* the error. The best we can do is trust ourselve to keep the legacy
* method database conflict free.
*
* This registers any alias with the same number as the main name.
* Should it be that the current |on| *has* the main name, this is
* simply a no-op.
*/
if (alias != NULL) {
(void)ossl_namemap_add_name(arg, main_id, alias);
}
}
static void get_legacy_cipher_names(const OBJ_NAME *on, void *arg)
{
const EVP_CIPHER *cipher = (void *)OBJ_NAME_get(on->name, on->type);
get_legacy_evp_names(EVP_CIPHER_name(cipher), on->name, arg);
}
static void get_legacy_md_names(const OBJ_NAME *on, void *arg)
{
const EVP_MD *md = (void *)OBJ_NAME_get(on->name, on->type);
/* We don't want the pkey_type names, so we need some extra care */
int snid, lnid;
snid = OBJ_sn2nid(on->name);
lnid = OBJ_ln2nid(on->name);
if (snid != EVP_MD_pkey_type(md) && lnid != EVP_MD_pkey_type(md))
get_legacy_evp_names(EVP_MD_name(md), on->name, arg);
else
get_legacy_evp_names(EVP_MD_name(md), NULL, arg);
}
#endif
/*-
* Constructors / destructors
* ==========================
*/
OSSL_NAMEMAP *ossl_namemap_stored(OPENSSL_CTX *libctx)
{
OSSL_NAMEMAP *namemap =
openssl_ctx_get_data(libctx, OPENSSL_CTX_NAMEMAP_INDEX,
&stored_namemap_method);
#ifndef FIPS_MODE
if (namemap != NULL && ossl_namemap_empty(namemap)) {
/* Before pilfering, we make sure the legacy database is populated */
OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS
| OPENSSL_INIT_ADD_ALL_DIGESTS, NULL);
OBJ_NAME_do_all(OBJ_NAME_TYPE_CIPHER_METH,
get_legacy_cipher_names, namemap);
OBJ_NAME_do_all(OBJ_NAME_TYPE_MD_METH,
get_legacy_md_names, namemap);
}
#endif
return namemap;
}
OSSL_NAMEMAP *ossl_namemap_new(void)
{
OSSL_NAMEMAP *namemap;
if ((namemap = OPENSSL_zalloc(sizeof(*namemap))) != NULL
&& (namemap->lock = CRYPTO_THREAD_lock_new()) != NULL
&& (namemap->namenum =
lh_NAMENUM_ENTRY_new(namenum_hash, namenum_cmp)) != NULL)
return namemap;
ossl_namemap_free(namemap);
return NULL;
}
void ossl_namemap_free(OSSL_NAMEMAP *namemap)
{
if (namemap == NULL || namemap->stored)
return;
lh_NAMENUM_ENTRY_doall(namemap->namenum, namenum_free);
lh_NAMENUM_ENTRY_free(namemap->namenum);
CRYPTO_THREAD_lock_free(namemap->lock);
OPENSSL_free(namemap);
}