/*
- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
#include "crypto/asn1.h"
#include "obj_local.h"
-/* obj_dat.h is generated from objects.h by obj_dat.pl */
+/* obj_dat.h is generated from objects.txt and obj_mac.{num,h} by obj_dat.pl */
#include "obj_dat.h"
-/*
- * If we don't have suitable TSAN support, we'll use a lock for generation of
- * new NIDs. This will be slower of course.
- */
-#ifndef tsan_ld_acq
-# define OBJ_USE_LOCK_FOR_NEW_NID
-#endif
-
DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn);
DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln);
DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
static LHASH_OF(ADDED_OBJ) *added = NULL;
static CRYPTO_RWLOCK *ossl_obj_lock = NULL;
-#ifdef OBJ_USE_LOCK_FOR_NEW_NID
+#ifdef TSAN_REQUIRES_LOCKING
static CRYPTO_RWLOCK *ossl_obj_nid_lock = NULL;
#endif
{
CRYPTO_THREAD_lock_free(ossl_obj_lock);
ossl_obj_lock = NULL;
-#ifdef OBJ_USE_LOCK_FOR_NEW_NID
+#ifdef TSAN_REQUIRES_LOCKING
CRYPTO_THREAD_lock_free(ossl_obj_nid_lock);
ossl_obj_nid_lock = NULL;
#endif
DEFINE_RUN_ONCE_STATIC(obj_lock_initialise)
{
- /* Make sure we've loaded config before checking for any "added" objects */
- OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
-
ossl_obj_lock = CRYPTO_THREAD_lock_new();
if (ossl_obj_lock == NULL)
return 0;
-#ifdef OBJ_USE_LOCK_FOR_NEW_NID
+#ifdef TSAN_REQUIRES_LOCKING
ossl_obj_nid_lock = CRYPTO_THREAD_lock_new();
if (ossl_obj_nid_lock == NULL) {
objs_free_locks();
static ossl_inline int ossl_init_added_lock(void)
{
+#ifndef OPENSSL_NO_AUTOLOAD_CONFIG
+ /* Make sure we've loaded config before checking for any "added" objects */
+ OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL);
+#endif
return RUN_ONCE(&ossl_obj_lock_init, obj_lock_initialise);
}
a = ca->obj;
switch (ca->type) {
case ADDED_DATA:
- ret = a->length << 20L;
+ ret = (unsigned long)a->length << 20UL;
p = (unsigned char *)a->data;
for (i = 0; i < a->length; i++)
ret ^= p[i] << ((i * 3) % 24);
objs_free_locks();
}
+/*
+ * Requires that the ossl_obj_lock be held
+ * if TSAN_REQUIRES_LOCKING defined
+ */
+static int obj_new_nid_unlocked(int num)
+{
+ static TSAN_QUALIFIER int new_nid = NUM_NID;
+#ifdef TSAN_REQUIRES_LOCKING
+ int i;
+
+ i = new_nid;
+ new_nid += num;
+
+ return i;
+#else
+ return tsan_add(&new_nid, num);
+#endif
+}
+
int OBJ_new_nid(int num)
{
-#ifdef OBJ_USE_LOCK_FOR_NEW_NID
- static int new_nid = NUM_NID;
+#ifdef TSAN_REQUIRES_LOCKING
int i;
- if (!CRYPTO_THREAD_write_lock(ossl_obj_nid_lock)) {
+ if (!ossl_obj_write_lock(1)) {
ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_WRITE_LOCK);
return NID_undef;
}
- i = new_nid;
- new_nid += num;
- CRYPTO_THREAD_unlock(ossl_obj_nid_lock);
+
+ i = obj_new_nid_unlocked(num);
+
+ ossl_obj_unlock(1);
+
return i;
#else
- static TSAN_QUALIFIER int new_nid = NUM_NID;
-
- return tsan_add(&new_nid, num);
+ return obj_new_nid_unlocked(num);
#endif
}
|| (o->sn != NULL
&& (ao[ADDED_SNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
|| (o->ln != NULL
- && (ao[ADDED_LNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)) {
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
+ && (ao[ADDED_LNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL))
goto err2;
- }
if (!ossl_obj_write_lock(lock)) {
ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_WRITE_LOCK);
if (added == NULL) {
added = lh_ADDED_OBJ_new(added_obj_hash, added_obj_cmp);
if (added == NULL) {
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OBJ, ERR_R_CRYPTO_LIB);
goto err;
}
}
ADDED_OBJ ad, *adp = NULL;
ASN1_OBJECT ob;
- if (n == NID_undef)
- return NULL;
- if (n >= 0 && n < NUM_NID && nid_objs[n].nid != NID_undef)
- return (ASN1_OBJECT *)&(nid_objs[n]);
+ if (n == NID_undef
+ || (n > 0 && n < NUM_NID && nid_objs[n].nid != NID_undef))
+ return (ASN1_OBJECT *)&(nid_objs[n]);
ad.type = ADDED_NID;
ad.obj = &ob;
int i, j;
if (!no_name) {
- if ((nid = OBJ_sn2nid(s)) != NID_undef ||
- (nid = OBJ_ln2nid(s)) != NID_undef) {
+ if ((nid = OBJ_sn2nid(s)) != NID_undef
+ || (nid = OBJ_ln2nid(s)) != NID_undef) {
return OBJ_nid2obj(nid);
}
if (!ossl_isdigit(*s)) {
if (j < 0)
return NULL;
- if ((buf = OPENSSL_malloc(j)) == NULL) {
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(j)) == NULL)
return NULL;
- }
p = buf;
/* Write out tag+length */
first = 1;
bl = NULL;
+ /*
+ * RFC 2578 (STD 58) says this about OBJECT IDENTIFIERs:
+ *
+ * > 3.5. OBJECT IDENTIFIER values
+ * >
+ * > An OBJECT IDENTIFIER value is an ordered list of non-negative
+ * > numbers. For the SMIv2, each number in the list is referred to as a
+ * > sub-identifier, there are at most 128 sub-identifiers in a value,
+ * > and each sub-identifier has a maximum value of 2^32-1 (4294967295
+ * > decimal).
+ *
+ * So a legitimate OID according to this RFC is at most (32 * 128 / 7),
+ * i.e. 586 bytes long.
+ *
+ * Ref: https://datatracker.ietf.org/doc/html/rfc2578#section-3.5
+ */
+ if (len > 586)
+ goto err;
+
while (len > 0) {
l = 0;
use_bn = 0;
for (;;) {
unsigned char c = *p++;
+
len--;
- if ((len == 0) && (c & 0x80))
+ if (len == 0 && (c & 0x80) != 0)
goto err;
if (use_bn) {
if (!BN_add_word(bl, c & 0x7f))
goto err;
- } else
+ } else {
l |= c & 0x7f;
- if (!(c & 0x80))
+ }
+ if ((c & 0x80) == 0)
break;
- if (!use_bn && (l > (ULONG_MAX >> 7L))) {
+ if (!use_bn && l > (ULONG_MAX >> 7L)) {
if (bl == NULL && (bl = BN_new()) == NULL)
goto err;
if (!BN_set_word(bl, l))
if (use_bn) {
if (!BN_lshift(bl, bl, 7))
goto err;
- } else
+ } else {
l <<= 7L;
+ }
}
if (first) {
if (use_bn) {
if (!BN_sub_word(bl, 80))
goto err;
- } else
+ } else {
l -= 80;
+ }
} else {
i = (int)(l / 40);
l -= (long)(i * 40);
}
- if (buf && (buf_len > 1)) {
+ if (buf != NULL && buf_len > 1) {
*buf++ = i + '0';
*buf = '\0';
buf_len--;
if (!bndec)
goto err;
i = strlen(bndec);
- if (buf) {
+ if (buf != NULL) {
if (buf_len > 1) {
*buf++ = '.';
*buf = '\0';
} else {
BIO_snprintf(tbuf, sizeof(tbuf), ".%lu", l);
i = strlen(tbuf);
- if (buf && (buf_len > 0)) {
+ if (buf && buf_len > 0) {
OPENSSL_strlcpy(buf, tbuf, buf_len);
if (i > buf_len) {
buf += buf_len;
if (p == NULL) {
const char *base_ = base;
int l, h, i = 0, c = 0;
+ char *p1;
for (i = 0; i < num; ++i) {
- p = &(base_[i * size]);
- c = (*cmp) (key, p);
+ p1 = &(base_[i * size]);
+ c = (*cmp) (key, p1);
if (c == 0
|| (c < 0 && (flags & OBJ_BSEARCH_VALUE_ON_NOMATCH)))
- return p;
+ return p1;
}
}
#endif
ASN1_OBJECT *tmpoid = NULL;
int ok = 0;
+ /* With no arguments at all, nothing can be done */
+ if (oid == NULL && sn == NULL && ln == NULL) {
+ ERR_raise(ERR_LIB_OBJ, ERR_R_PASSED_INVALID_ARGUMENT);
+ return 0;
+ }
+
/* Check to see if short or long name already present */
if ((sn != NULL && OBJ_sn2nid(sn) != NID_undef)
|| (ln != NULL && OBJ_ln2nid(ln) != NID_undef)) {
ERR_raise(ERR_LIB_OBJ, OBJ_R_OID_EXISTS);
- goto err;
+ return 0;
}
- /* Convert numerical OID string to an ASN1_OBJECT structure */
- tmpoid = OBJ_txt2obj(oid, 1);
- if (tmpoid == NULL)
- goto err;
+ if (oid != NULL) {
+ /* Convert numerical OID string to an ASN1_OBJECT structure */
+ tmpoid = OBJ_txt2obj(oid, 1);
+ if (tmpoid == NULL)
+ return 0;
+ } else {
+ /* Create a no-OID ASN1_OBJECT */
+ tmpoid = ASN1_OBJECT_new();
+ if (tmpoid == NULL) {
+ ERR_raise(ERR_LIB_OBJ, ERR_R_ASN1_LIB);
+ return 0;
+ }
+ }
if (!ossl_obj_write_lock(1)) {
ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_WRITE_LOCK);
+ ASN1_OBJECT_free(tmpoid);
return 0;
}
/* If NID is not NID_undef then object already exists */
- if (ossl_obj_obj2nid(tmpoid, 0) != NID_undef) {
+ if (oid != NULL
+ && ossl_obj_obj2nid(tmpoid, 0) != NID_undef) {
ERR_raise(ERR_LIB_OBJ, OBJ_R_OID_EXISTS);
goto err;
}
- tmpoid->nid = OBJ_new_nid(1);
+ tmpoid->nid = obj_new_nid_unlocked(1);
+
+ if (tmpoid->nid == NID_undef)
+ goto err;
+
tmpoid->sn = (char *)sn;
tmpoid->ln = (char *)ln;
projects / thirdparty / openssl.git / blobdiff