diff options
Diffstat (limited to '')
| -rw-r--r-- | lib/priority.c | 4053 |
1 files changed, 4053 insertions, 0 deletions
diff --git a/lib/priority.c b/lib/priority.c new file mode 100644 index 0000000..efa4d90 --- /dev/null +++ b/lib/priority.c @@ -0,0 +1,4053 @@ +/* + * Copyright (C) 2004-2015 Free Software Foundation, Inc. + * Copyright (C) 2015-2019 Red Hat, Inc. + * + * Author: Nikos Mavrogiannopoulos + * + * This file is part of GnuTLS. + * + * The GnuTLS is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/> + * + */ + +/* Here lies the code of the gnutls_*_set_priority() functions. + */ + +#include "gnutls_int.h" +#include "algorithms.h" +#include "errors.h" +#include <num.h> +#include <gnutls/x509.h> +#include <c-ctype.h> +#include <hello_ext.h> +#include <c-strcase.h> +#include "fips.h" +#include "errno.h" +#include "ext/srp.h" +#include <gnutls/gnutls.h> +#include "profiles.h" +#include "c-strcase.h" +#include "inih/ini.h" +#include "locks.h" +#include "profiles.h" +#include "name_val_array.h" + +#define MAX_ELEMENTS GNUTLS_MAX_ALGORITHM_NUM + +#define ENABLE_PROFILE(c, profile) do { \ + c->additional_verify_flags &= 0x00ffffff; \ + c->additional_verify_flags |= GNUTLS_PROFILE_TO_VFLAGS(profile); \ + c->level = _gnutls_profile_to_sec_level(profile); \ + } while(0) + +/* This function is used by the test suite */ +char *_gnutls_resolve_priorities(const char* priorities); + +/* This variable points to either a constant value (DEFAULT_PRIORITY_STRING or + * externally assigned) or heap-allocated + * system_wide_config.default_priority_string. We can't move this to the + * system_wide_config struct, because this variable is part of (private) ABI + * exported for testing. + */ +const char *_gnutls_default_priority_string = DEFAULT_PRIORITY_STRING; + +static void prio_remove(priority_st * priority_list, unsigned int algo); +static void prio_add(priority_st * priority_list, unsigned int algo); +static void +break_list(char *etag, + char *broken_etag[MAX_ELEMENTS], int *size); + +typedef void (bulk_rmadd_func) (priority_st * priority_list, const int *); + +inline static void _set_priority(priority_st * st, const int *list) +{ + int num = 0, i; + + while (list[num] != 0) + num++; + if (num > MAX_ALGOS) + num = MAX_ALGOS; + st->num_priorities = num; + + for (i = 0; i < num; i++) { + st->priorities[i] = list[i]; + } + + return; +} + +inline static void _add_priority(priority_st * st, const int *list) +{ + int num, i, j, init; + + init = i = st->num_priorities; + + for (num = 0; list[num] != 0; ++num) { + if (i + 1 > MAX_ALGOS) { + return; + } + + for (j = 0; j < init; j++) { + if (st->priorities[j] == (unsigned) list[num]) { + break; + } + } + + if (j == init) { + st->priorities[i++] = list[num]; + st->num_priorities++; + } + } + + return; +} + +static void _clear_priorities(priority_st * st, const int *list) +{ + memset(st, 0, sizeof(*st)); +} + +static void _clear_given_priorities(priority_st * st, const int *list) +{ + unsigned i; + + for (i=0;list[i]!=0;i++) { + prio_remove(st, list[i]); + } +} + +static const int _supported_groups_dh[] = { + GNUTLS_GROUP_FFDHE2048, + GNUTLS_GROUP_FFDHE3072, + GNUTLS_GROUP_FFDHE4096, + GNUTLS_GROUP_FFDHE6144, + GNUTLS_GROUP_FFDHE8192, + 0 +}; + +static const int _supported_groups_ecdh[] = { + GNUTLS_GROUP_SECP256R1, + GNUTLS_GROUP_SECP384R1, + GNUTLS_GROUP_SECP521R1, + GNUTLS_GROUP_X25519, /* RFC 8422 */ + GNUTLS_GROUP_X448, /* RFC 8422 */ + 0 +}; + +static const int _supported_groups_gost[] = { +#ifdef ENABLE_GOST + GNUTLS_GROUP_GC256A, + GNUTLS_GROUP_GC256B, + GNUTLS_GROUP_GC256C, + GNUTLS_GROUP_GC256D, + GNUTLS_GROUP_GC512A, + GNUTLS_GROUP_GC512B, + GNUTLS_GROUP_GC512C, +#endif + 0 +}; + +static const int _supported_groups_normal[] = { + GNUTLS_GROUP_SECP256R1, + GNUTLS_GROUP_SECP384R1, + GNUTLS_GROUP_SECP521R1, + GNUTLS_GROUP_X25519, /* RFC 8422 */ + GNUTLS_GROUP_X448, /* RFC 8422 */ + + /* These should stay last as our default behavior + * is to send key shares for two top types (GNUTLS_KEY_SHARE_TOP2) + * and we wouldn't want to have these sent by all clients + * by default as they are quite expensive CPU-wise. */ + GNUTLS_GROUP_FFDHE2048, + GNUTLS_GROUP_FFDHE3072, + GNUTLS_GROUP_FFDHE4096, + GNUTLS_GROUP_FFDHE6144, + GNUTLS_GROUP_FFDHE8192, + 0 +}; +static const int* supported_groups_normal = _supported_groups_normal; + +static const int _supported_groups_secure128[] = { + GNUTLS_GROUP_SECP256R1, + GNUTLS_GROUP_SECP384R1, + GNUTLS_GROUP_SECP521R1, + GNUTLS_GROUP_X25519, /* RFC 8422 */ + GNUTLS_GROUP_X448, /* RFC 8422 */ + GNUTLS_GROUP_FFDHE2048, + GNUTLS_GROUP_FFDHE3072, + GNUTLS_GROUP_FFDHE4096, + GNUTLS_GROUP_FFDHE6144, + GNUTLS_GROUP_FFDHE8192, + 0 +}; +static const int* supported_groups_secure128 = _supported_groups_secure128; + +static const int _supported_groups_suiteb128[] = { + GNUTLS_GROUP_SECP256R1, + GNUTLS_GROUP_SECP384R1, + 0 +}; +static const int* supported_groups_suiteb128 = _supported_groups_suiteb128; + +static const int _supported_groups_suiteb192[] = { + GNUTLS_GROUP_SECP384R1, + 0 +}; +static const int* supported_groups_suiteb192 = _supported_groups_suiteb192; + +static const int _supported_groups_secure192[] = { + GNUTLS_GROUP_SECP384R1, + GNUTLS_GROUP_SECP521R1, + GNUTLS_GROUP_FFDHE8192, + 0 +}; +static const int* supported_groups_secure192 = _supported_groups_secure192; + +static const int protocol_priority[] = { + GNUTLS_TLS1_3, + GNUTLS_TLS1_2, + GNUTLS_TLS1_1, + GNUTLS_TLS1_0, + GNUTLS_DTLS1_2, + GNUTLS_DTLS1_0, + 0 +}; + +/* contains all the supported TLS protocols, intended to be used for eliminating them + */ +static const int stream_protocol_priority[] = { + GNUTLS_TLS1_3, + GNUTLS_TLS1_2, + GNUTLS_TLS1_1, + GNUTLS_TLS1_0, + 0 +}; + +/* contains all the supported DTLS protocols, intended to be used for eliminating them + */ +static const int dgram_protocol_priority[] = { + GNUTLS_DTLS1_2, + GNUTLS_DTLS1_0, + GNUTLS_DTLS0_9, + 0 +}; + +static const int dtls_protocol_priority[] = { + GNUTLS_DTLS1_2, + GNUTLS_DTLS1_0, + 0 +}; + +static const int _protocol_priority_suiteb[] = { + GNUTLS_TLS1_2, + 0 +}; +static const int* protocol_priority_suiteb = _protocol_priority_suiteb; + +static const int _kx_priority_performance[] = { + GNUTLS_KX_RSA, +#ifdef ENABLE_ECDHE + GNUTLS_KX_ECDHE_ECDSA, + GNUTLS_KX_ECDHE_RSA, +#endif +#ifdef ENABLE_DHE + GNUTLS_KX_DHE_RSA, +#endif + 0 +}; +static const int* kx_priority_performance = _kx_priority_performance; + +static const int _kx_priority_pfs[] = { +#ifdef ENABLE_ECDHE + GNUTLS_KX_ECDHE_ECDSA, + GNUTLS_KX_ECDHE_RSA, +#endif +#ifdef ENABLE_DHE + GNUTLS_KX_DHE_RSA, +#endif + 0 +}; +static const int* kx_priority_pfs = _kx_priority_pfs; + +static const int _kx_priority_suiteb[] = { + GNUTLS_KX_ECDHE_ECDSA, + 0 +}; +static const int* kx_priority_suiteb = _kx_priority_suiteb; + +static const int _kx_priority_secure[] = { + /* The ciphersuites that offer forward secrecy take + * precedence + */ +#ifdef ENABLE_ECDHE + GNUTLS_KX_ECDHE_ECDSA, + GNUTLS_KX_ECDHE_RSA, +#endif + GNUTLS_KX_RSA, + /* KX-RSA is now ahead of DHE-RSA and DHE-DSS due to the compatibility + * issues the DHE ciphersuites have. That is, one cannot enforce a specific + * security level without dropping the connection. + */ +#ifdef ENABLE_DHE + GNUTLS_KX_DHE_RSA, +#endif + /* GNUTLS_KX_ANON_DH: Man-in-the-middle prone, don't add! + */ + 0 +}; +static const int* kx_priority_secure = _kx_priority_secure; + +static const int _kx_priority_gost[] = { +#ifdef ENABLE_GOST + GNUTLS_KX_VKO_GOST_12, +#endif + 0, +}; +static const int* kx_priority_gost = _kx_priority_gost; + +static const int _cipher_priority_performance_default[] = { + GNUTLS_CIPHER_AES_128_GCM, + GNUTLS_CIPHER_AES_256_GCM, + GNUTLS_CIPHER_CHACHA20_POLY1305, + GNUTLS_CIPHER_AES_128_CCM, + GNUTLS_CIPHER_AES_256_CCM, + GNUTLS_CIPHER_AES_128_CBC, + GNUTLS_CIPHER_AES_256_CBC, + 0 +}; + +static const int _cipher_priority_performance_no_aesni[] = { + GNUTLS_CIPHER_CHACHA20_POLY1305, + GNUTLS_CIPHER_AES_128_GCM, + GNUTLS_CIPHER_AES_256_GCM, + GNUTLS_CIPHER_AES_128_CCM, + GNUTLS_CIPHER_AES_256_CCM, + GNUTLS_CIPHER_AES_128_CBC, + GNUTLS_CIPHER_AES_256_CBC, + 0 +}; + +/* If GCM and AES acceleration is available then prefer + * them over anything else. Overall we prioritise AEAD + * over legacy ciphers, and 256-bit over 128 (for future + * proof). + */ +static const int _cipher_priority_normal_default[] = { + GNUTLS_CIPHER_AES_256_GCM, + GNUTLS_CIPHER_CHACHA20_POLY1305, + GNUTLS_CIPHER_AES_256_CCM, + + GNUTLS_CIPHER_AES_256_CBC, + + GNUTLS_CIPHER_AES_128_GCM, + GNUTLS_CIPHER_AES_128_CCM, + + GNUTLS_CIPHER_AES_128_CBC, + 0 +}; + +static const int cipher_priority_performance_fips[] = { + GNUTLS_CIPHER_AES_128_GCM, + GNUTLS_CIPHER_AES_128_CCM, + GNUTLS_CIPHER_AES_256_GCM, + GNUTLS_CIPHER_AES_256_CCM, + + GNUTLS_CIPHER_AES_128_CBC, + GNUTLS_CIPHER_AES_256_CBC, + 0 +}; + +static const int cipher_priority_normal_fips[] = { + GNUTLS_CIPHER_AES_256_GCM, + GNUTLS_CIPHER_AES_256_CCM, + GNUTLS_CIPHER_AES_256_CBC, + + GNUTLS_CIPHER_AES_128_GCM, + GNUTLS_CIPHER_AES_128_CBC, + GNUTLS_CIPHER_AES_128_CCM, + 0 +}; + + +static const int _cipher_priority_suiteb128[] = { + GNUTLS_CIPHER_AES_256_GCM, + GNUTLS_CIPHER_AES_128_GCM, + 0 +}; +static const int* cipher_priority_suiteb128 = _cipher_priority_suiteb128; + +static const int _cipher_priority_suiteb192[] = { + GNUTLS_CIPHER_AES_256_GCM, + 0 +}; +static const int* cipher_priority_suiteb192 = _cipher_priority_suiteb192; + + +static const int _cipher_priority_secure128[] = { + GNUTLS_CIPHER_AES_256_GCM, + GNUTLS_CIPHER_CHACHA20_POLY1305, + GNUTLS_CIPHER_AES_256_CBC, + GNUTLS_CIPHER_AES_256_CCM, + + GNUTLS_CIPHER_AES_128_GCM, + GNUTLS_CIPHER_AES_128_CBC, + GNUTLS_CIPHER_AES_128_CCM, + 0 +}; +static const int *cipher_priority_secure128 = _cipher_priority_secure128; + + +static const int _cipher_priority_secure192[] = { + GNUTLS_CIPHER_AES_256_GCM, + GNUTLS_CIPHER_CHACHA20_POLY1305, + GNUTLS_CIPHER_AES_256_CBC, + GNUTLS_CIPHER_AES_256_CCM, + 0 +}; +static const int* cipher_priority_secure192 = _cipher_priority_secure192; + +static const int _sign_priority_default[] = { + GNUTLS_SIGN_RSA_SHA256, + GNUTLS_SIGN_RSA_PSS_SHA256, + GNUTLS_SIGN_RSA_PSS_RSAE_SHA256, + GNUTLS_SIGN_ECDSA_SHA256, + GNUTLS_SIGN_ECDSA_SECP256R1_SHA256, + + GNUTLS_SIGN_EDDSA_ED25519, + + GNUTLS_SIGN_RSA_SHA384, + GNUTLS_SIGN_RSA_PSS_SHA384, + GNUTLS_SIGN_RSA_PSS_RSAE_SHA384, + GNUTLS_SIGN_ECDSA_SHA384, + GNUTLS_SIGN_ECDSA_SECP384R1_SHA384, + + GNUTLS_SIGN_EDDSA_ED448, + + GNUTLS_SIGN_RSA_SHA512, + GNUTLS_SIGN_RSA_PSS_SHA512, + GNUTLS_SIGN_RSA_PSS_RSAE_SHA512, + + GNUTLS_SIGN_ECDSA_SHA512, + GNUTLS_SIGN_ECDSA_SECP521R1_SHA512, + + GNUTLS_SIGN_RSA_SHA1, + GNUTLS_SIGN_ECDSA_SHA1, + + 0 +}; +static const int* sign_priority_default = _sign_priority_default; + +static const int _sign_priority_suiteb128[] = { + GNUTLS_SIGN_ECDSA_SHA256, + GNUTLS_SIGN_ECDSA_SECP256R1_SHA256, + GNUTLS_SIGN_ECDSA_SHA384, + GNUTLS_SIGN_ECDSA_SECP384R1_SHA384, + 0 +}; +static const int* sign_priority_suiteb128 = _sign_priority_suiteb128; + +static const int _sign_priority_suiteb192[] = { + GNUTLS_SIGN_ECDSA_SHA384, + GNUTLS_SIGN_ECDSA_SECP384R1_SHA384, + 0 +}; +static const int* sign_priority_suiteb192 = _sign_priority_suiteb192; + +static const int _sign_priority_secure128[] = { + GNUTLS_SIGN_RSA_SHA256, + GNUTLS_SIGN_RSA_PSS_SHA256, + GNUTLS_SIGN_RSA_PSS_RSAE_SHA256, + GNUTLS_SIGN_ECDSA_SHA256, + GNUTLS_SIGN_ECDSA_SECP256R1_SHA256, + + GNUTLS_SIGN_EDDSA_ED25519, + + GNUTLS_SIGN_RSA_SHA384, + GNUTLS_SIGN_RSA_PSS_SHA384, + GNUTLS_SIGN_RSA_PSS_RSAE_SHA384, + GNUTLS_SIGN_ECDSA_SHA384, + GNUTLS_SIGN_ECDSA_SECP384R1_SHA384, + + GNUTLS_SIGN_EDDSA_ED448, + + GNUTLS_SIGN_RSA_SHA512, + GNUTLS_SIGN_RSA_PSS_SHA512, + GNUTLS_SIGN_RSA_PSS_RSAE_SHA512, + GNUTLS_SIGN_ECDSA_SHA512, + GNUTLS_SIGN_ECDSA_SECP521R1_SHA512, + + 0 +}; +static const int* sign_priority_secure128 = _sign_priority_secure128; + +static const int _sign_priority_secure192[] = { + GNUTLS_SIGN_RSA_SHA384, + GNUTLS_SIGN_RSA_PSS_SHA384, + GNUTLS_SIGN_RSA_PSS_RSAE_SHA384, + GNUTLS_SIGN_ECDSA_SHA384, + GNUTLS_SIGN_ECDSA_SECP384R1_SHA384, + GNUTLS_SIGN_EDDSA_ED448, + GNUTLS_SIGN_RSA_SHA512, + GNUTLS_SIGN_RSA_PSS_SHA512, + GNUTLS_SIGN_RSA_PSS_RSAE_SHA512, + GNUTLS_SIGN_ECDSA_SHA512, + GNUTLS_SIGN_ECDSA_SECP521R1_SHA512, + + 0 +}; +static const int* sign_priority_secure192 = _sign_priority_secure192; + +static const int _sign_priority_gost[] = { +#ifdef ENABLE_GOST + GNUTLS_SIGN_GOST_256, + GNUTLS_SIGN_GOST_512, +#endif + 0 +}; +static const int* sign_priority_gost = _sign_priority_gost; + +static const int mac_priority_normal_default[] = { + GNUTLS_MAC_SHA1, + GNUTLS_MAC_AEAD, + 0 +}; + +static const int mac_priority_normal_fips[] = { + GNUTLS_MAC_SHA1, + GNUTLS_MAC_AEAD, + 0 +}; + +static const int *cipher_priority_performance = _cipher_priority_performance_default; +static const int *cipher_priority_normal = _cipher_priority_normal_default; +static const int *mac_priority_normal = mac_priority_normal_default; + +static const int _cipher_priority_gost[] = { +#ifdef ENABLE_GOST + GNUTLS_CIPHER_GOST28147_TC26Z_CNT, +#endif + 0 +}; +static const int *cipher_priority_gost = _cipher_priority_gost; + +static const int _mac_priority_gost[] = { +#ifdef ENABLE_GOST + GNUTLS_MAC_GOST28147_TC26Z_IMIT, +#endif + 0 +}; +static const int *mac_priority_gost = _mac_priority_gost; + +/* if called with replace the default priorities with the FIPS140 ones */ +void _gnutls_priority_update_fips(void) +{ + cipher_priority_performance = cipher_priority_performance_fips; + cipher_priority_normal = cipher_priority_normal_fips; + mac_priority_normal = mac_priority_normal_fips; +} + +void _gnutls_priority_update_non_aesni(void) +{ + /* if we have no AES acceleration in performance mode + * prefer fast stream ciphers */ + if (_gnutls_fips_mode_enabled() == 0) { + cipher_priority_performance = _cipher_priority_performance_no_aesni; + } +} + +static const int _mac_priority_suiteb[] = { + GNUTLS_MAC_AEAD, + 0 +}; +static const int* mac_priority_suiteb = _mac_priority_suiteb; + +static const int _mac_priority_secure128[] = { + GNUTLS_MAC_SHA1, + GNUTLS_MAC_AEAD, + 0 +}; +static const int* mac_priority_secure128 = _mac_priority_secure128; + +static const int _mac_priority_secure192[] = { + GNUTLS_MAC_AEAD, + 0 +}; +static const int* mac_priority_secure192 = _mac_priority_secure192; + +static const int cert_type_priority_default[] = { + GNUTLS_CRT_X509, + 0 +}; + +static const int cert_type_priority_all[] = { + GNUTLS_CRT_X509, + GNUTLS_CRT_RAWPK, + 0 +}; + +typedef void (rmadd_func) (priority_st * priority_list, unsigned int alg); + +static void prio_remove(priority_st * priority_list, unsigned int algo) +{ + unsigned int i; + + for (i = 0; i < priority_list->num_priorities; i++) { + if (priority_list->priorities[i] == algo) { + priority_list->num_priorities--; + if ((priority_list->num_priorities - i) > 0) + memmove(&priority_list->priorities[i], + &priority_list->priorities[i + 1], + (priority_list->num_priorities - + i) * + sizeof(priority_list-> + priorities[0])); + priority_list->priorities[priority_list-> + num_priorities] = 0; + break; + } + } + + return; +} + +static void prio_add(priority_st * priority_list, unsigned int algo) +{ + unsigned int i, l = priority_list->num_priorities; + + if (l >= MAX_ALGOS) + return; /* can't add it anyway */ + + for (i = 0; i < l; ++i) { + if (algo == priority_list->priorities[i]) + return; /* if it exists */ + } + + priority_list->priorities[l] = algo; + priority_list->num_priorities++; + + return; +} + + +/** + * gnutls_priority_set: + * @session: is a #gnutls_session_t type. + * @priority: is a #gnutls_priority_t type. + * + * Sets the priorities to use on the ciphers, key exchange methods, + * and macs. Note that this function is expected to be called once + * per session; when called multiple times (e.g., before a re-handshake, + * the caller should make sure that any new settings are not incompatible + * with the original session). + * + * Returns: %GNUTLS_E_SUCCESS on success, or an error code on error. + **/ +int +gnutls_priority_set(gnutls_session_t session, gnutls_priority_t priority) +{ + int ret; + + if (priority == NULL || priority->protocol.num_priorities == 0 || + priority->cs.size == 0) + return gnutls_assert_val(GNUTLS_E_NO_PRIORITIES_WERE_SET); + + /* set the current version to the first in the chain, if this is + * the call before the initial handshake. During a re-handshake + * we do not set the version to avoid overriding the currently + * negotiated version. */ + if (!session->internals.handshake_in_progress && + !session->internals.initial_negotiation_completed) { + ret = _gnutls_set_current_version(session, + priority->protocol.priorities[0]); + if (ret < 0) + return gnutls_assert_val(ret); + } + + /* At this point the provided priorities passed the sanity tests */ + + if (session->internals.priorities) + gnutls_priority_deinit(session->internals.priorities); + + gnutls_atomic_increment(&priority->usage_cnt); + session->internals.priorities = priority; + + if (priority->no_tickets != 0) { + session->internals.flags |= GNUTLS_NO_TICKETS; + } + + if (priority->no_tickets_tls12 != 0) { + /* when PFS is explicitly requested, disable session tickets for TLS 1.2 */ + session->internals.flags |= GNUTLS_NO_TICKETS_TLS12; + } + + ADD_PROFILE_VFLAGS(session, priority->additional_verify_flags); + + /* mirror variables */ +#undef COPY_TO_INTERNALS +#define COPY_TO_INTERNALS(xx) session->internals.xx = priority->_##xx + COPY_TO_INTERNALS(allow_large_records); + COPY_TO_INTERNALS(allow_small_records); + COPY_TO_INTERNALS(no_etm); + COPY_TO_INTERNALS(no_ext_master_secret); + COPY_TO_INTERNALS(allow_key_usage_violation); + COPY_TO_INTERNALS(allow_wrong_pms); + COPY_TO_INTERNALS(dumbfw); + COPY_TO_INTERNALS(dh_prime_bits); + + return 0; +} + + +#define LEVEL_NONE "NONE" +#define LEVEL_NORMAL "NORMAL" +#define LEVEL_PFS "PFS" +#define LEVEL_PERFORMANCE "PERFORMANCE" +#define LEVEL_SECURE128 "SECURE128" +#define LEVEL_SECURE192 "SECURE192" +#define LEVEL_SECURE256 "SECURE256" +#define LEVEL_SUITEB128 "SUITEB128" +#define LEVEL_SUITEB192 "SUITEB192" +#define LEVEL_LEGACY "LEGACY" +#define LEVEL_SYSTEM "SYSTEM" + +struct priority_groups_st { + const char *name; + const char *alias; + const int **proto_list; + const int **cipher_list; + const int **mac_list; + const int **kx_list; + const int **sign_list; + const int **group_list; + unsigned profile; + int sec_param; + bool no_tickets; + bool no_tickets_tls12; +}; + +static const struct priority_groups_st pgroups[] = +{ + {.name = LEVEL_NORMAL, + .cipher_list = &cipher_priority_normal, + .mac_list = &mac_priority_normal, + .kx_list = &kx_priority_secure, + .sign_list = &sign_priority_default, + .group_list = &supported_groups_normal, + .profile = GNUTLS_PROFILE_LOW, + .sec_param = GNUTLS_SEC_PARAM_WEAK + }, + {.name = LEVEL_PFS, + .cipher_list = &cipher_priority_normal, + .mac_list = &mac_priority_secure128, + .kx_list = &kx_priority_pfs, + .sign_list = &sign_priority_default, + .group_list = &supported_groups_normal, + .profile = GNUTLS_PROFILE_LOW, + .sec_param = GNUTLS_SEC_PARAM_WEAK, + .no_tickets_tls12 = 1 + }, + {.name = LEVEL_SECURE128, + .alias = "SECURE", + .cipher_list = &cipher_priority_secure128, + .mac_list = &mac_priority_secure128, + .kx_list = &kx_priority_secure, + .sign_list = &sign_priority_secure128, + .group_list = &supported_groups_secure128, + /* The profile should have been HIGH but if we don't allow + * SHA-1 (80-bits) as signature algorithm we are not able + * to connect anywhere with this level */ + .profile = GNUTLS_PROFILE_LOW, + .sec_param = GNUTLS_SEC_PARAM_LOW + }, + {.name = LEVEL_SECURE192, + .alias = LEVEL_SECURE256, + .cipher_list = &cipher_priority_secure192, + .mac_list = &mac_priority_secure192, + .kx_list = &kx_priority_secure, + .sign_list = &sign_priority_secure192, + .group_list = &supported_groups_secure192, + .profile = GNUTLS_PROFILE_HIGH, + .sec_param = GNUTLS_SEC_PARAM_HIGH + }, + {.name = LEVEL_SUITEB128, + .proto_list = &protocol_priority_suiteb, + .cipher_list = &cipher_priority_suiteb128, + .mac_list = &mac_priority_suiteb, + .kx_list = &kx_priority_suiteb, + .sign_list = &sign_priority_suiteb128, + .group_list = &supported_groups_suiteb128, + .profile = GNUTLS_PROFILE_SUITEB128, + .sec_param = GNUTLS_SEC_PARAM_HIGH + }, + {.name = LEVEL_SUITEB192, + .proto_list = &protocol_priority_suiteb, + .cipher_list = &cipher_priority_suiteb192, + .mac_list = &mac_priority_suiteb, + .kx_list = &kx_priority_suiteb, + .sign_list = &sign_priority_suiteb192, + .group_list = &supported_groups_suiteb192, + .profile = GNUTLS_PROFILE_SUITEB192, + .sec_param = GNUTLS_SEC_PARAM_ULTRA + }, + {.name = LEVEL_LEGACY, + .cipher_list = &cipher_priority_normal, + .mac_list = &mac_priority_normal, + .kx_list = &kx_priority_secure, + .sign_list = &sign_priority_default, + .group_list = &supported_groups_normal, + .sec_param = GNUTLS_SEC_PARAM_VERY_WEAK + }, + {.name = LEVEL_PERFORMANCE, + .cipher_list = &cipher_priority_performance, + .mac_list = &mac_priority_normal, + .kx_list = &kx_priority_performance, + .sign_list = &sign_priority_default, + .group_list = &supported_groups_normal, + .profile = GNUTLS_PROFILE_LOW, + .sec_param = GNUTLS_SEC_PARAM_WEAK + }, + { + .name = NULL, + } +}; + +#define SET_PROFILE(to_set) \ + profile = GNUTLS_VFLAGS_TO_PROFILE(priority_cache->additional_verify_flags); \ + if (profile == 0 || profile > to_set) { \ + priority_cache->additional_verify_flags &= ~GNUTLS_VFLAGS_PROFILE_MASK; \ + priority_cache->additional_verify_flags |= GNUTLS_PROFILE_TO_VFLAGS(to_set); \ + } + +#define SET_LEVEL(to_set) \ + if (priority_cache->level == 0 || (unsigned)priority_cache->level > (unsigned)to_set) \ + priority_cache->level = to_set + +static +int check_level(const char *level, gnutls_priority_t priority_cache, + int add) +{ + bulk_rmadd_func *func; + unsigned profile = 0; + unsigned i; + int j; + const cipher_entry_st *centry; + + if (add) + func = _add_priority; + else + func = _set_priority; + + for (i=0;;i++) { + if (pgroups[i].name == NULL) + return 0; + + if (c_strcasecmp(level, pgroups[i].name) == 0 || + (pgroups[i].alias != NULL && c_strcasecmp(level, pgroups[i].alias) == 0)) { + if (pgroups[i].proto_list != NULL) + func(&priority_cache->protocol, *pgroups[i].proto_list); + func(&priority_cache->_cipher, *pgroups[i].cipher_list); + func(&priority_cache->_kx, *pgroups[i].kx_list); + func(&priority_cache->_mac, *pgroups[i].mac_list); + func(&priority_cache->_sign_algo, *pgroups[i].sign_list); + func(&priority_cache->_supported_ecc, *pgroups[i].group_list); + + if (pgroups[i].profile != 0) { + SET_PROFILE(pgroups[i].profile); /* set certificate level */ + } + SET_LEVEL(pgroups[i].sec_param); /* set DH params level */ + priority_cache->no_tickets = pgroups[i].no_tickets; + priority_cache->no_tickets_tls12 = pgroups[i].no_tickets_tls12; + if (priority_cache->have_cbc == 0) { + for (j=0;(*pgroups[i].cipher_list)[j]!=0;j++) { + centry = cipher_to_entry((*pgroups[i].cipher_list)[j]); + if (centry != NULL && centry->type == CIPHER_BLOCK) { + priority_cache->have_cbc = 1; + break; + } + } + } + return 1; + } + } +} + +static void enable_compat(gnutls_priority_t c) +{ + ENABLE_PRIO_COMPAT(c); +} +static void enable_server_key_usage_violations(gnutls_priority_t c) +{ + c->allow_server_key_usage_violation = 1; +} +static void enable_allow_small_records(gnutls_priority_t c) +{ + c->_allow_small_records = 1; +} +static void enable_dumbfw(gnutls_priority_t c) +{ + c->_dumbfw = 1; +} +static void enable_no_extensions(gnutls_priority_t c) +{ + c->no_extensions = 1; +} +static void enable_no_ext_master_secret(gnutls_priority_t c) +{ + c->_no_ext_master_secret = 1; +} +static void enable_no_etm(gnutls_priority_t c) +{ + c->_no_etm = 1; +} +static void enable_force_etm(gnutls_priority_t c) +{ + c->force_etm = 1; +} +static void enable_no_tickets(gnutls_priority_t c) +{ + c->no_tickets = 1; +} +static void enable_no_tickets_tls12(gnutls_priority_t c) +{ + c->no_tickets_tls12 = 1; +} +static void disable_wildcards(gnutls_priority_t c) +{ + c->additional_verify_flags |= GNUTLS_VERIFY_DO_NOT_ALLOW_WILDCARDS; +} +static void enable_profile_very_weak(gnutls_priority_t c) +{ + ENABLE_PROFILE(c, GNUTLS_PROFILE_VERY_WEAK); +} +static void enable_profile_low(gnutls_priority_t c) +{ + ENABLE_PROFILE(c, GNUTLS_PROFILE_LOW); +} +static void enable_profile_legacy(gnutls_priority_t c) +{ + ENABLE_PROFILE(c, GNUTLS_PROFILE_LEGACY); +} +static void enable_profile_medium(gnutls_priority_t c) +{ + ENABLE_PROFILE(c, GNUTLS_PROFILE_MEDIUM); +} +static void enable_profile_high(gnutls_priority_t c) +{ + ENABLE_PROFILE(c, GNUTLS_PROFILE_HIGH); +} +static void enable_profile_ultra(gnutls_priority_t c) +{ + ENABLE_PROFILE(c, GNUTLS_PROFILE_ULTRA); +} +static void enable_profile_future(gnutls_priority_t c) +{ + ENABLE_PROFILE(c, GNUTLS_PROFILE_FUTURE); +} +static void enable_profile_suiteb128(gnutls_priority_t c) +{ + ENABLE_PROFILE(c, GNUTLS_PROFILE_SUITEB128); +} +static void enable_profile_suiteb192(gnutls_priority_t c) +{ + ENABLE_PROFILE(c, GNUTLS_PROFILE_SUITEB128); +} +static void enable_safe_renegotiation(gnutls_priority_t c) +{ + c->sr = SR_SAFE; + +} +static void enable_unsafe_renegotiation(gnutls_priority_t c) +{ + c->sr = SR_UNSAFE; +} +static void enable_partial_safe_renegotiation(gnutls_priority_t c) +{ + c->sr = SR_PARTIAL; +} +static void disable_safe_renegotiation(gnutls_priority_t c) +{ + c->sr = SR_DISABLED; +} +static void enable_fallback_scsv(gnutls_priority_t c) +{ + c->fallback = 1; +} +static void enable_latest_record_version(gnutls_priority_t c) +{ + c->min_record_version = 0; +} +static void enable_ssl3_record_version(gnutls_priority_t c) +{ + c->min_record_version = 1; +} +static void enable_verify_allow_rsa_md5(gnutls_priority_t c) +{ + c->additional_verify_flags |= + GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5; +} +static void enable_verify_allow_sha1(gnutls_priority_t c) +{ + c->additional_verify_flags |= + GNUTLS_VERIFY_ALLOW_SIGN_WITH_SHA1; +} +static void enable_verify_allow_broken(gnutls_priority_t c) +{ + c->additional_verify_flags |= + GNUTLS_VERIFY_ALLOW_BROKEN; +} +static void disable_crl_checks(gnutls_priority_t c) +{ + c->additional_verify_flags |= + GNUTLS_VERIFY_DISABLE_CRL_CHECKS; +} +static void enable_server_precedence(gnutls_priority_t c) +{ + c->server_precedence = 1; +} +static void disable_tls13_compat_mode(gnutls_priority_t c) +{ + c->tls13_compat_mode = false; +} +static void dummy_func(gnutls_priority_t c) +{ +} + +#include <priority_options.h> + +struct cfg { + bool allowlisting; + bool ktls_enabled; + + name_val_array_t priority_strings; + char *priority_string; + char *default_priority_string; + gnutls_certificate_verification_profiles_t verification_profile; + + gnutls_cipher_algorithm_t ciphers[MAX_ALGOS+1]; + gnutls_mac_algorithm_t macs[MAX_ALGOS+1]; + gnutls_group_t groups[MAX_ALGOS+1]; + gnutls_kx_algorithm_t kxs[MAX_ALGOS+1]; + gnutls_sign_algorithm_t sigs[MAX_ALGOS+1]; + gnutls_protocol_t versions[MAX_ALGOS+1]; + + gnutls_digest_algorithm_t hashes[MAX_ALGOS+1]; + gnutls_ecc_curve_t ecc_curves[MAX_ALGOS+1]; + gnutls_sign_algorithm_t sigs_for_cert[MAX_ALGOS+1]; +}; + +static inline void +cfg_deinit(struct cfg *cfg) +{ + if (cfg->priority_strings) { + _name_val_array_clear(&cfg->priority_strings); + } + gnutls_free(cfg->priority_string); + gnutls_free(cfg->default_priority_string); +} + +/* Lock for reading and writing system_wide_config */ +GNUTLS_RWLOCK(system_wide_config_rwlock); +static struct cfg system_wide_config; + +static unsigned fail_on_invalid_config = 0; +static const char *system_priority_file = SYSTEM_PRIORITY_FILE; +static time_t system_priority_last_mod = 0; +static unsigned system_priority_file_loaded = 0; + +#define GLOBAL_SECTION "global" +#define CUSTOM_PRIORITY_SECTION "priorities" +#define OVERRIDES_SECTION "overrides" +#define MAX_ALGO_NAME 2048 + +bool _gnutls_allowlisting_mode(void) +{ + return system_wide_config.allowlisting; +} + +static void _clear_default_system_priority(void) +{ + gnutls_free(system_wide_config.default_priority_string); + system_wide_config.default_priority_string = NULL; + + _gnutls_default_priority_string = DEFAULT_PRIORITY_STRING; +} + +gnutls_certificate_verification_profiles_t _gnutls_get_system_wide_verification_profile(void) +{ + return system_wide_config.verification_profile; +} + +/* removes spaces */ +static char *clear_spaces(const char *str, char out[MAX_ALGO_NAME]) +{ + const char *p = str; + unsigned i = 0; + + while (c_isspace(*p)) + p++; + + while (!c_isspace(*p) && *p != 0) { + out[i++] = *p; + p++; + + if (i >= MAX_ALGO_NAME-1) + break; + } + out[i] = 0; + return out; +} + +struct ini_ctx { + struct cfg cfg; + + gnutls_digest_algorithm_t *hashes; + size_t hashes_size; + gnutls_sign_algorithm_t *sigs; + size_t sigs_size; + gnutls_sign_algorithm_t *sigs_for_cert; + size_t sigs_for_cert_size; + gnutls_protocol_t *versions; + size_t versions_size; + gnutls_ecc_curve_t *curves; + size_t curves_size; +}; + +static inline void +ini_ctx_deinit(struct ini_ctx *ctx) +{ + cfg_deinit(&ctx->cfg); + gnutls_free(ctx->hashes); + gnutls_free(ctx->sigs); + gnutls_free(ctx->sigs_for_cert); + gnutls_free(ctx->versions); + gnutls_free(ctx->curves); +} + +static inline void +cfg_steal(struct cfg *dst, struct cfg *src) +{ + dst->verification_profile = src->verification_profile; + + dst->priority_strings = src->priority_strings; + src->priority_strings = NULL; + + dst->priority_string = src->priority_string; + src->priority_string = NULL; + + dst->default_priority_string = src->default_priority_string; + src->default_priority_string = NULL; + + dst->allowlisting = src->allowlisting; + dst->ktls_enabled = src->ktls_enabled; + memcpy(dst->ciphers, src->ciphers, sizeof(src->ciphers)); + memcpy(dst->macs, src->macs, sizeof(src->macs)); + memcpy(dst->groups, src->groups, sizeof(src->groups)); + memcpy(dst->kxs, src->kxs, sizeof(src->kxs)); + memcpy(dst->hashes, src->hashes, sizeof(src->hashes)); + memcpy(dst->ecc_curves, src->ecc_curves, sizeof(src->ecc_curves)); + memcpy(dst->sigs, src->sigs, sizeof(src->sigs)); + memcpy(dst->sigs_for_cert, src->sigs_for_cert, + sizeof(src->sigs_for_cert)); +} + +/* + * synchronizing changes from struct cfg to global `lib/algorithms` arrays + */ + +/* global side-effect! modifies `flags` in `hash_algorithms[]` */ +static inline int /* allowlisting-only */ +_cfg_hashes_remark(struct cfg* cfg) +{ + size_t i; + _gnutls_digest_mark_insecure_all(); + for (i = 0; cfg->hashes[i] != 0; i++) { + int ret = _gnutls_digest_set_secure(cfg->hashes[i], 1); + if (unlikely(ret < 0)) { + return gnutls_assert_val(ret); + } + } + return 0; +} + +/* global side-effect! modifies `flags` in `sign_algorithms[]` */ +static inline int /* allowlisting-only */ +_cfg_sigs_remark(struct cfg* cfg) +{ + size_t i; + _gnutls_sign_mark_insecure_all(_INSECURE); + for (i = 0; cfg->sigs[i] != 0; i++) { + int ret = _gnutls_sign_set_secure(cfg->sigs[i], + _INSECURE_FOR_CERTS); + if (unlikely(ret < 0)) { + return gnutls_assert_val(ret); + } + } + for (i = 0; cfg->sigs_for_cert[i] != 0; i++) { + int ret = _gnutls_sign_set_secure(cfg->sigs_for_cert[i], + _SECURE); + if (unlikely(ret < 0)) { + return gnutls_assert_val(ret); + } + } + return 0; +} + +/* global side-effect! modifies `supported` in `sup_versions[]` */ +static inline int /* allowlisting-only */ +_cfg_versions_remark(struct cfg* cfg) +{ + size_t i; + _gnutls_version_mark_disabled_all(); + for (i = 0; cfg->versions[i] != 0; i++) { + int ret = _gnutls_protocol_set_enabled(cfg->versions[i], 1); + if (unlikely(ret < 0)) { + return gnutls_assert_val(ret); + } + } + return 0; +} + +/* global side-effect! modifies `supported` in `ecc_curves[]` */ +static inline int /* allowlisting-only */ +_cfg_ecc_curves_remark(struct cfg* cfg) +{ + size_t i; + _gnutls_ecc_curve_mark_disabled_all(); + for (i = 0; cfg->ecc_curves[i] != 0; i++) { + int ret = _gnutls_ecc_curve_set_enabled(cfg->ecc_curves[i], 1); + if (unlikely(ret < 0)) { + return gnutls_assert_val(ret); + } + } + return 0; +} + +/* + * setting arrays of struct cfg: from other arrays + */ + +static inline int /* allowlisting-only */ +cfg_hashes_set_array(struct cfg* cfg, + gnutls_digest_algorithm_t* src, size_t len) +{ + if (unlikely(len >= MAX_ALGOS)) { + return gnutls_assert_val(GNUTLS_A_INTERNAL_ERROR); + } + if (len) { + memcpy(cfg->hashes, + src, sizeof(gnutls_digest_algorithm_t) * len); + } + cfg->hashes[len] = 0; + return _cfg_hashes_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_sigs_set_arrays(struct cfg* cfg, + gnutls_sign_algorithm_t* src, size_t len, + gnutls_sign_algorithm_t* src_for_cert, size_t len_for_cert) +{ + if (unlikely(len >= MAX_ALGOS)) { + return gnutls_assert_val(GNUTLS_A_INTERNAL_ERROR); + } + if (unlikely(len_for_cert >= MAX_ALGOS)) { + return gnutls_assert_val(GNUTLS_A_INTERNAL_ERROR); + } + if (len) { + memcpy(cfg->sigs, src, sizeof(gnutls_sign_algorithm_t) * len); + } + if (len_for_cert) { + memcpy(cfg->sigs_for_cert, src_for_cert, + sizeof(gnutls_sign_algorithm_t) * len_for_cert); + } + cfg->sigs[len] = 0; + cfg->sigs_for_cert[len_for_cert] = 0; + return _cfg_sigs_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_versions_set_array(struct cfg* cfg, gnutls_protocol_t* src, size_t len) +{ + if (unlikely(len >= MAX_ALGOS)) { + return gnutls_assert_val(GNUTLS_A_INTERNAL_ERROR); + } + if (len) { + memcpy(cfg->versions, src, sizeof(gnutls_protocol_t) * len); + } + cfg->versions[len] = 0; + return _cfg_versions_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_ecc_curves_set_array(struct cfg* cfg, gnutls_ecc_curve_t* src, size_t len) +{ + if (unlikely(len >= MAX_ALGOS)) { + return gnutls_assert_val(GNUTLS_A_INTERNAL_ERROR); + } + if (len) { + memcpy(cfg->ecc_curves, src, sizeof(gnutls_ecc_curve_t) * len); + } + cfg->ecc_curves[len] = 0; + return _cfg_ecc_curves_remark(cfg); +} + +/* + * appending to arrays of struct cfg + */ + +/* polymorphic way to DRY this operation. other possible approaches: + * 1. just unmacro (long) + * 2. cast to ints and write a function operating on ints + * (hacky, every call is +4 lines, needs a portable static assert) + * 3. macro whole functions, not just this operation (harder to find/read) + */ +#define APPEND_TO_NULL_TERMINATED_ARRAY(dst, element) \ + do { \ + size_t i; \ + for (i = 0; dst[i] != 0; i++) { \ + if (dst[i] == element) { \ + return 0; \ + } \ + } \ + if (unlikely(i >= MAX_ALGOS)) { \ + return gnutls_assert_val(GNUTLS_A_INTERNAL_ERROR); \ + } \ + dst[i] = element; \ + dst[i + 1] = 0; \ + } while (0) + +static inline int /* allowlisting-only */ +cfg_hashes_add(struct cfg *cfg, gnutls_digest_algorithm_t dig) +{ + _gnutls_debug_log("cfg: enabling digest algorithm %s\n", + gnutls_digest_get_name(dig)); + APPEND_TO_NULL_TERMINATED_ARRAY(cfg->hashes, dig); + return _cfg_hashes_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_sigs_add(struct cfg *cfg, gnutls_sign_algorithm_t sig) +{ + _gnutls_debug_log("cfg: enabling signature algorithm " + "(for non-certificate usage) " + "%s\n", gnutls_sign_get_name(sig)); + APPEND_TO_NULL_TERMINATED_ARRAY(cfg->sigs, sig); + return _cfg_sigs_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_sigs_for_cert_add(struct cfg *cfg, gnutls_sign_algorithm_t sig) +{ + _gnutls_debug_log("cfg: enabling signature algorithm" + "(for certificate usage) " + "%s\n", gnutls_sign_get_name(sig)); + APPEND_TO_NULL_TERMINATED_ARRAY(cfg->sigs_for_cert, sig); + return _cfg_sigs_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_versions_add(struct cfg *cfg, gnutls_protocol_t prot) +{ + _gnutls_debug_log("cfg: enabling version %s\n", + gnutls_protocol_get_name(prot)); + APPEND_TO_NULL_TERMINATED_ARRAY(cfg->versions, prot); + return _cfg_versions_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_ecc_curves_add(struct cfg *cfg, gnutls_ecc_curve_t curve) +{ + _gnutls_debug_log("cfg: enabling curve %s\n", + gnutls_ecc_curve_get_name(curve)); + APPEND_TO_NULL_TERMINATED_ARRAY(cfg->ecc_curves, curve); + return _cfg_ecc_curves_remark(cfg); +} + +#undef APPEND_TO_NULL_TERMINATED_ARRAY + +/* + * removing from arrays of struct cfg + */ + +/* polymorphic way to DRY this removal, see APPEND_TO_NULL_TERMINATED_ARRAY */ +#define REMOVE_FROM_NULL_TERMINATED_ARRAY(dst, element) \ + do { \ + size_t i, j; \ + for (i = 0; dst[i] != 0; i++) { \ + if (dst[i] == element) { \ + for (j = i; dst[j] != 0; j++) { \ + dst[j] = dst[j + 1]; \ + } \ + } \ + } \ + } while (0) + +static inline int /* allowlisting-only */ +cfg_hashes_remove(struct cfg *cfg, gnutls_digest_algorithm_t dig) +{ + _gnutls_debug_log("cfg: disabling digest algorithm %s\n", + gnutls_digest_get_name(dig)); + REMOVE_FROM_NULL_TERMINATED_ARRAY(cfg->hashes, dig); + return _cfg_hashes_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_sigs_remove(struct cfg *cfg, gnutls_sign_algorithm_t sig) +{ + _gnutls_debug_log("cfg: disabling signature algorithm " + "(for non-certificate usage) " + "%s\n", gnutls_sign_get_name(sig)); + REMOVE_FROM_NULL_TERMINATED_ARRAY(cfg->sigs, sig); + return _cfg_sigs_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_sigs_for_cert_remove(struct cfg *cfg, gnutls_sign_algorithm_t sig) +{ + _gnutls_debug_log("cfg: disabling signature algorithm" + "(for certificate usage) " + "%s\n", gnutls_sign_get_name(sig)); + REMOVE_FROM_NULL_TERMINATED_ARRAY(cfg->sigs_for_cert, sig); + return _cfg_sigs_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_versions_remove(struct cfg *cfg, gnutls_protocol_t prot) +{ + _gnutls_debug_log("cfg: disabling version %s\n", + gnutls_protocol_get_name(prot)); + REMOVE_FROM_NULL_TERMINATED_ARRAY(cfg->versions, prot); + return _cfg_versions_remark(cfg); +} + +static inline int /* allowlisting-only */ +cfg_ecc_curves_remove(struct cfg *cfg, gnutls_ecc_curve_t curve) +{ + _gnutls_debug_log("cfg: disabling curve %s\n", + gnutls_ecc_curve_get_name(curve)); + REMOVE_FROM_NULL_TERMINATED_ARRAY(cfg->ecc_curves, curve); + return _cfg_ecc_curves_remark(cfg); +} + +static inline int +cfg_apply(struct cfg *cfg, struct ini_ctx *ctx) +{ + size_t i; + int ret; + + cfg_steal(cfg, &ctx->cfg); + + if (cfg->default_priority_string) { + _gnutls_default_priority_string = cfg->default_priority_string; + } + + if (cfg->allowlisting) { + /* also updates `flags` of global `hash_algorithms[]` */ + ret = cfg_hashes_set_array(cfg, ctx->hashes, ctx->hashes_size); + if (unlikely(ret < 0)) { + return gnutls_assert_val(ret); + } + /* also updates `flags` of global `sign_algorithms[]` */ + ret = cfg_sigs_set_arrays(cfg, ctx->sigs, ctx->sigs_size, + ctx->sigs_for_cert, + ctx->sigs_for_cert_size); + if (unlikely(ret < 0)) { + return gnutls_assert_val(ret); + } + /* also updates `supported` field of global `sup_versions[]` */ + ret = cfg_versions_set_array(cfg, + ctx->versions, ctx->versions_size); + if (unlikely(ret < 0)) { + return gnutls_assert_val(ret); + } + /* also updates `supported` field of global `ecc_curves[]` */ + ret = cfg_ecc_curves_set_array(cfg, + ctx->curves, ctx->curves_size); + if (unlikely(ret < 0)) { + return gnutls_assert_val(ret); + } + } else { + /* updates same global arrays as above, but doesn't store + * the algorithms into the `struct cfg` as allowlisting does. + * blocklisting doesn't allow relaxing the restrictions */ + for (i = 0; i < ctx->hashes_size; i++) { + ret = _gnutls_digest_mark_insecure(ctx->hashes[i]); + if (unlikely(ret < 0)) { + return ret; + } + } + for (i = 0; i < ctx->sigs_size; i++) { + ret = _gnutls_sign_mark_insecure(ctx->sigs[i], + _INSECURE); + if (unlikely(ret < 0)) { + return ret; + } + } + for (i = 0; i < ctx->sigs_for_cert_size; i++) { + ret = _gnutls_sign_mark_insecure(ctx->sigs_for_cert[i], _INSECURE_FOR_CERTS); + if (unlikely(ret < 0)) { + return ret; + } + } + for (i = 0; i < ctx->versions_size; i++) { + ret = _gnutls_version_mark_disabled(ctx->versions[i]); + if (unlikely(ret < 0)) { + return ret; + } + } + for (i = 0; i < ctx->curves_size; i++) { + ret = _gnutls_ecc_curve_mark_disabled(ctx->curves[i]); + if (unlikely(ret < 0)) { + return ret; + } + } + } + + return 0; +} + +/* This function parses the global section of the configuration file. + */ +static int global_ini_handler(void *ctx, const char *section, const char *name, const char *value) +{ + char *p; + char str[MAX_ALGO_NAME]; + struct cfg *cfg = ctx; + + if (section != NULL && c_strcasecmp(section, GLOBAL_SECTION) == 0) { + if (c_strcasecmp(name, "override-mode") == 0) { + p = clear_spaces(value, str); + if (c_strcasecmp(p, "allowlist") == 0) { + cfg->allowlisting = true; + } else if (c_strcasecmp(p, "blocklist") == 0) { + cfg->allowlisting = false; + } else { + _gnutls_debug_log("cfg: unknown override mode %s\n", + p); + if (fail_on_invalid_config) + return 0; + } + } else if (c_strcasecmp(name, "ktls") == 0) { + p = clear_spaces(value, str); + if (c_strcasecmp(p, "true") == 0) { + cfg->ktls_enabled = true; + } else { + _gnutls_debug_log("cfg: unknown ktls mode %s\n", + p); + if (fail_on_invalid_config) + return 0; + } + } else { + _gnutls_debug_log("unknown parameter %s\n", name); + if (fail_on_invalid_config) + return 0; + } + } + + return 1; +} + +static bool +override_allowed(bool allowlisting, const char *name) +{ + static const struct { + const char *allowlist_name; + const char *blocklist_name; + } names[] = { + { "secure-hash", "insecure-hash" }, + { "secure-sig", "insecure-sig" }, + { "secure-sig-for-cert", "insecure-sig-for-cert" }, + { "enabled-version", "disabled-version" }, + { "enabled-curve", "disabled-curve" }, + { "tls-enabled-cipher", "tls-disabled-cipher" }, + { "tls-enabled-group", "tls-disabled-group" }, + { "tls-enabled-kx", "tls-disabled-kx" }, + { "tls-enabled-mac", "tls-disabled-mac" } + }; + size_t i; + + for (i = 0; i < sizeof(names) / sizeof(names[0]); i++) { + if (c_strcasecmp(name, + allowlisting ? + names[i].blocklist_name : + names[i].allowlist_name) == 0) + return false; + } + + return true; +} + +/* This function parses a gnutls configuration file. Updating internal settings + * according to the parsed configuration is done by cfg_apply. + */ +static int cfg_ini_handler(void *_ctx, const char *section, const char *name, const char *value) +{ + char *p; + int ret; + unsigned i; + char str[MAX_ALGO_NAME]; + struct ini_ctx *ctx = _ctx; + struct cfg *cfg = &ctx->cfg; + + /* Note that we intentionally overwrite the value above; inih does + * not use that value after we handle it. */ + + /* Parse sections */ + if (section == NULL || section[0] == 0 || c_strcasecmp(section, CUSTOM_PRIORITY_SECTION)==0) { + _gnutls_debug_log("cfg: adding priority: %s -> %s\n", name, value); + + ret = _name_val_array_append(&cfg->priority_strings, name, value); + if (ret < 0) + return 0; + } else if (c_strcasecmp(section, OVERRIDES_SECTION)==0) { + if (!override_allowed(cfg->allowlisting, name)) { + _gnutls_debug_log("cfg: %s is not allowed in this mode\n", + name); + if (fail_on_invalid_config) + return 0; + } else if (c_strcasecmp(name, "default-priority-string")==0) { + if (cfg->default_priority_string) { + gnutls_free(cfg->default_priority_string); + cfg->default_priority_string = NULL; + } + p = clear_spaces(value, str); + _gnutls_debug_log("cfg: setting default-priority-string to %s\n", p); + if (strlen(p) > 0) { + cfg->default_priority_string = gnutls_strdup(p); + if (!cfg->default_priority_string) { + _gnutls_debug_log("cfg: failed setting default-priority-string\n"); + return 0; + } + } else { + _gnutls_debug_log("cfg: empty default-priority-string, using default\n"); + if (fail_on_invalid_config) + return 0; + } + } else if (c_strcasecmp(name, "insecure-hash") == 0 || + c_strcasecmp(name, "secure-hash") == 0) { + gnutls_digest_algorithm_t dig, *tmp; + + p = clear_spaces(value, str); + + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: marking hash %s as secure\n", + p); + } else { + _gnutls_debug_log("cfg: marking hash %s as insecure\n", + p); + } + + dig = gnutls_digest_get_id(p); + if (dig == GNUTLS_DIG_UNKNOWN) { + _gnutls_debug_log("cfg: found unknown hash %s in %s\n", + p, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + tmp = _gnutls_reallocarray(ctx->hashes, + ctx->hashes_size + 1, + sizeof(gnutls_digest_algorithm_t)); + if (!tmp) { + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: failed marking hash %s as secure\n", + p); + } else { + _gnutls_debug_log("cfg: failed marking hash %s as insecure\n", + p); + } + if (fail_on_invalid_config) + return 0; + goto exit; + } + + ctx->hashes = tmp; + ctx->hashes[ctx->hashes_size] = dig; + ctx->hashes_size++; + } else if (c_strcasecmp(name, "insecure-sig") == 0 || + c_strcasecmp(name, "secure-sig") == 0) { + gnutls_sign_algorithm_t sig, *tmp; + + p = clear_spaces(value, str); + + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: marking signature %s as secure\n", + p); + } else { + _gnutls_debug_log("cfg: marking signature %s as insecure\n", + p); + } + + sig = gnutls_sign_get_id(p); + if (sig == GNUTLS_SIGN_UNKNOWN) { + _gnutls_debug_log("cfg: found unknown signature algorithm %s in %s\n", + p, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + tmp = _gnutls_reallocarray(ctx->sigs, + ctx->sigs_size + 1, + sizeof(gnutls_sign_algorithm_t)); + if (!tmp) { + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: failed marking signature %s as secure\n", + p); + } else { + _gnutls_debug_log("cfg: failed marking signature %s as insecure\n", + p); + } + if (fail_on_invalid_config) + return 0; + goto exit; + } + + ctx->sigs = tmp; + ctx->sigs[ctx->sigs_size] = sig; + ctx->sigs_size++; + } else if (c_strcasecmp(name, "insecure-sig-for-cert") == 0 || + c_strcasecmp(name, "secure-sig-for-cert") == 0) { + gnutls_sign_algorithm_t sig, *tmp; + + p = clear_spaces(value, str); + + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: marking signature %s as secure for certs\n", + p); + } else { + _gnutls_debug_log("cfg: marking signature %s as insecure for certs\n", + p); + } + + sig = gnutls_sign_get_id(p); + if (sig == GNUTLS_SIGN_UNKNOWN) { + _gnutls_debug_log("cfg: found unknown signature algorithm %s in %s\n", + p, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + tmp = _gnutls_reallocarray(ctx->sigs_for_cert, + ctx->sigs_for_cert_size + 1, + sizeof(gnutls_sign_algorithm_t)); + if (!tmp) { + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: failed marking signature %s as secure for certs\n", + p); + } else { + _gnutls_debug_log("cfg: failed marking signature %s as insecure for certs\n", + p); + } + if (fail_on_invalid_config) + return 0; + goto exit; + } + + ctx->sigs_for_cert = tmp; + ctx->sigs_for_cert[ctx->sigs_for_cert_size] = sig; + ctx->sigs_for_cert_size++; + } else if (c_strcasecmp(name, "disabled-version") == 0 || + c_strcasecmp(name, "enabled-version") == 0) { + gnutls_protocol_t prot, *tmp; + + p = clear_spaces(value, str); + + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: enabling version %s\n", + p); + } else { + _gnutls_debug_log("cfg: disabling version %s\n", + p); + } + + prot = gnutls_protocol_get_id(p); + if (prot == GNUTLS_VERSION_UNKNOWN) { + _gnutls_debug_log("cfg: found unknown version %s in %s\n", + p, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + tmp = _gnutls_reallocarray(ctx->versions, + ctx->versions_size + 1, + sizeof(gnutls_protocol_t)); + if (!tmp) { + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: failed enabling version %s\n", + p); + } else { + _gnutls_debug_log("cfg: failed disabling version %s\n", + p); + } + if (fail_on_invalid_config) + return 0; + goto exit; + } + + ctx->versions = tmp; + ctx->versions[ctx->versions_size] = prot; + ctx->versions_size++; + } else if (c_strcasecmp(name, "disabled-curve") == 0 || + c_strcasecmp(name, "enabled-curve") == 0) { + gnutls_ecc_curve_t curve, *tmp; + + p = clear_spaces(value, str); + + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: enabling curve %s\n", + p); + } else { + _gnutls_debug_log("cfg: disabling curve %s\n", + p); + } + + curve = gnutls_ecc_curve_get_id(p); + if (curve == GNUTLS_ECC_CURVE_INVALID) { + _gnutls_debug_log("cfg: found unknown curve %s in %s\n", + p, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + tmp = _gnutls_reallocarray(ctx->curves, + ctx->curves_size + 1, + sizeof(gnutls_ecc_curve_t)); + if (!tmp) { + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: failed enabling curve %s\n", + p); + } else { + _gnutls_debug_log("cfg: failed disabling curve %s\n", + p); + } + if (fail_on_invalid_config) + return 0; + goto exit; + } + + ctx->curves = tmp; + ctx->curves[ctx->curves_size] = curve; + ctx->curves_size++; + } else if (c_strcasecmp(name, "min-verification-profile")==0) { + gnutls_certificate_verification_profiles_t profile; + profile = gnutls_certificate_verification_profile_get_id(value); + + if (profile == GNUTLS_PROFILE_UNKNOWN) { + _gnutls_debug_log("cfg: found unknown profile %s in %s\n", + value, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + + cfg->verification_profile = profile; + } else if (c_strcasecmp(name, "tls-disabled-cipher") == 0 || + c_strcasecmp(name, "tls-enabled-cipher") == 0) { + gnutls_cipher_algorithm_t algo; + + p = clear_spaces(value, str); + + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: enabling cipher %s for TLS\n", + p); + } else { + _gnutls_debug_log("cfg: disabling cipher %s for TLS\n", + p); + } + + algo = gnutls_cipher_get_id(p); + if (algo == GNUTLS_CIPHER_UNKNOWN) { + _gnutls_debug_log("cfg: unknown algorithm %s listed at %s\n", + p, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + + i = 0; + while (cfg->ciphers[i] != 0) + i++; + + if (i > MAX_ALGOS-1) { + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: too many (%d) enabled ciphers from %s\n", + i, name); + } else { + _gnutls_debug_log("cfg: too many (%d) disabled ciphers from %s\n", + i, name); + } + if (fail_on_invalid_config) + return 0; + goto exit; + } + cfg->ciphers[i] = algo; + cfg->ciphers[i+1] = 0; + + } else if (c_strcasecmp(name, "tls-disabled-mac") == 0 || + c_strcasecmp(name, "tls-enabled-mac") == 0) { + gnutls_mac_algorithm_t algo; + + p = clear_spaces(value, str); + + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: enabling MAC %s for TLS\n", + p); + } else { + _gnutls_debug_log("cfg: disabling MAC %s for TLS\n", + p); + } + + algo = gnutls_mac_get_id(p); + if (algo == 0) { + _gnutls_debug_log("cfg: unknown algorithm %s listed at %s\n", + p, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + + i = 0; + while (cfg->macs[i] != 0) + i++; + + if (i > MAX_ALGOS-1) { + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: too many (%d) enabled MACs from %s\n", + i, name); + } else { + _gnutls_debug_log("cfg: too many (%d) disabled MACs from %s\n", + i, name); + } + if (fail_on_invalid_config) + return 0; + goto exit; + } + cfg->macs[i] = algo; + cfg->macs[i+1] = 0; + } else if (c_strcasecmp(name, "tls-disabled-group") == 0 || + c_strcasecmp(name, "tls-enabled-group") == 0) { + gnutls_group_t algo; + + p = clear_spaces(value, str); + + if (c_strncasecmp(p, "GROUP-", 6) == 0) + p += 6; + + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: enabling group %s for TLS\n", + p); + } else { + _gnutls_debug_log("cfg: disabling group %s for TLS\n", + p); + } + + algo = _gnutls_group_get_id(p); + if (algo == 0) { + _gnutls_debug_log("cfg: unknown group %s listed at %s\n", + p, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + + i = 0; + while (cfg->groups[i] != 0) + i++; + + if (i > MAX_ALGOS-1) { + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: too many (%d) enabled groups from %s\n", + i, name); + } else { + _gnutls_debug_log("cfg: too many (%d) disabled groups from %s\n", + i, name); + } + if (fail_on_invalid_config) + return 0; + goto exit; + } + cfg->groups[i] = algo; + cfg->groups[i+1] = 0; + } else if (c_strcasecmp(name, "tls-disabled-kx") == 0 || + c_strcasecmp(name, "tls-enabled-kx") == 0) { + unsigned algo; + + p = clear_spaces(value, str); + + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: enabling key exchange %s for TLS\n", + p); + } else { + _gnutls_debug_log("cfg: disabling key exchange %s for TLS\n", + p); + } + + algo = gnutls_kx_get_id(p); + if (algo == 0) { + _gnutls_debug_log("cfg: unknown key exchange %s listed at %s\n", + p, name); + if (fail_on_invalid_config) + return 0; + goto exit; + } + + i = 0; + while (cfg->kxs[i] != 0) + i++; + + if (i > MAX_ALGOS-1) { + if (cfg->allowlisting) { + _gnutls_debug_log("cfg: too many (%d) enabled key exchanges from %s\n", + i, name); + } else { + _gnutls_debug_log("cfg: too many (%d) disabled key exchanges from %s\n", + i, name); + } + if (fail_on_invalid_config) + return 0; + goto exit; + } + cfg->kxs[i] = algo; + cfg->kxs[i+1] = 0; + } else { + _gnutls_debug_log("unknown parameter %s\n", name); + if (fail_on_invalid_config) + return 0; + } + } else if (c_strcasecmp(section, GLOBAL_SECTION) != 0) { + _gnutls_debug_log("cfg: unknown section %s\n", + section); + if (fail_on_invalid_config) + return 0; + } + + exit: + return 1; +} + +static int /* not locking system_wide_config */ +construct_system_wide_priority_string(gnutls_buffer_st* buf) +{ + int ret; + size_t i; + + _gnutls_buffer_init(buf); + + ret = _gnutls_buffer_append_str(buf, "NONE"); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + + for (i = 0; system_wide_config.kxs[i] != 0; i++) { + ret = _gnutls_buffer_append_str(buf, ":+"); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + + ret = _gnutls_buffer_append_str(buf, + gnutls_kx_get_name(system_wide_config.kxs[i])); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + } + + for (i = 0; system_wide_config.groups[i] != 0; i++) { + ret = _gnutls_buffer_append_str(buf, ":+GROUP-"); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + + ret = _gnutls_buffer_append_str(buf, + gnutls_group_get_name(system_wide_config.groups[i])); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + } + + for (i = 0; system_wide_config.ciphers[i] != 0; i++) { + ret = _gnutls_buffer_append_str(buf, ":+"); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + + ret = _gnutls_buffer_append_str(buf, + gnutls_cipher_get_name(system_wide_config.ciphers[i])); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + } + + for (i = 0; system_wide_config.macs[i] != 0; i++) { + ret = _gnutls_buffer_append_str(buf, ":+"); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + + ret = _gnutls_buffer_append_str(buf, + gnutls_mac_get_name(system_wide_config.macs[i])); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + } + + for (i = 0; system_wide_config.sigs[i] != 0; i++) { + ret = _gnutls_buffer_append_str(buf, ":+SIGN-"); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + + ret = _gnutls_buffer_append_str(buf, + gnutls_sign_get_name(system_wide_config.sigs[i])); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + } + + for (i = 0; system_wide_config.versions[i] != 0; i++) { + ret = _gnutls_buffer_append_str(buf, ":+VERS-"); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + + ret = _gnutls_buffer_append_str(buf, + gnutls_protocol_get_name(system_wide_config.versions[i])); + if (ret < 0) { + _gnutls_buffer_clear(buf); + return ret; + } + } + return 0; +} + +static int /* not locking system_wide_config */ +update_system_wide_priority_string(void) +{ + /* doesn't do locking, _gnutls_update_system_priorities does */ + gnutls_buffer_st buf; + int ret; + + ret = construct_system_wide_priority_string(&buf); + if (ret < 0) { + _gnutls_debug_log("cfg: unable to construct " + "system-wide priority string: %s", + gnutls_strerror(ret)); + _gnutls_buffer_clear(&buf); + return ret; + } + + gnutls_free(system_wide_config.priority_string); + system_wide_config.priority_string = gnutls_strdup((char *)buf.data); + _gnutls_buffer_clear(&buf); + + return 0; +} + +static int _gnutls_update_system_priorities(bool defer_system_wide) +{ + int ret, err = 0; + struct stat sb; + FILE *fp; + gnutls_buffer_st buf; + struct ini_ctx ctx; + + ret = gnutls_rwlock_rdlock(&system_wide_config_rwlock); + if (ret < 0) { + return gnutls_assert_val(ret); + } + + if (stat(system_priority_file, &sb) < 0) { + _gnutls_debug_log("cfg: unable to access: %s: %d\n", + system_priority_file, errno); + goto out; + } + + if (system_priority_file_loaded && + system_priority_last_mod == sb.st_mtime) { + _gnutls_debug_log("cfg: system priority %s has not changed\n", + system_priority_file); + if (system_wide_config.priority_string) { + goto out; /* nothing to do */ + } + } + + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + + ret = gnutls_rwlock_wrlock(&system_wide_config_rwlock); + if (ret < 0) { + return gnutls_assert_val(ret); + } + + /* Another thread could have successfully re-read system-wide config, + * skip re-reading if the mtime it has used is exactly the same. + */ + if (system_priority_file_loaded) { + system_priority_file_loaded = + (system_priority_last_mod == sb.st_mtime); + } + + if (!system_priority_file_loaded) { + _name_val_array_clear(&system_wide_config.priority_strings); + + gnutls_free(system_wide_config.priority_string); + system_wide_config.priority_string = NULL; + + fp = fopen(system_priority_file, "re"); + if (fp == NULL) { + _gnutls_debug_log("cfg: unable to open: %s: %d\n", + system_priority_file, errno); + goto out; + } + /* Parsing the configuration file needs to be done in 2 phases: + * first parsing the [global] section + * and then the other sections, + * because the [global] section modifies the parsing behavior. + */ + memset(&ctx, 0, sizeof(ctx)); + err = ini_parse_file(fp, global_ini_handler, &ctx); + if (!err) { + if (fseek(fp, 0L, SEEK_SET) < 0) { + _gnutls_debug_log("cfg: unable to rewind: %s\n", + system_priority_file); + if (fail_on_invalid_config) + exit(1); + } + err = ini_parse_file(fp, cfg_ini_handler, &ctx); + } + fclose(fp); + if (err) { + ini_ctx_deinit(&ctx); + _gnutls_debug_log("cfg: unable to parse: %s: %d\n", + system_priority_file, err); + goto out; + } + cfg_apply(&system_wide_config, &ctx); + ini_ctx_deinit(&ctx); + _gnutls_debug_log("cfg: loaded system config %s mtime %lld\n", + system_priority_file, + (unsigned long long)sb.st_mtime); + + } + + if (system_wide_config.allowlisting) { + if (defer_system_wide) { + /* try constructing a priority string, + * but don't apply it yet, at this point + * we're only interested in whether we can */ + ret = construct_system_wide_priority_string(&buf); + _gnutls_buffer_clear(&buf); + _gnutls_debug_log("cfg: deferred setting " + "system-wide priority string\n"); + } else { + ret = update_system_wide_priority_string(); + _gnutls_debug_log("cfg: finalized " + "system-wide priority string\n"); + } + if (ret < 0) { + _gnutls_debug_log("cfg: unable to build priority string: %s\n", + gnutls_strerror(ret)); + if (fail_on_invalid_config) + exit(1); + goto out; + } + } + + system_priority_file_loaded = 1; + system_priority_last_mod = sb.st_mtime; + + out: + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + + if (err && fail_on_invalid_config) { + exit(1); + } + + return ret; +} + +void _gnutls_prepare_to_load_system_priorities(void) +{ + const char *p; + int ret; + + p = secure_getenv("GNUTLS_SYSTEM_PRIORITY_FILE"); + if (p != NULL) + system_priority_file = p; + + p = secure_getenv("GNUTLS_SYSTEM_PRIORITY_FAIL_ON_INVALID"); + if (p != NULL && p[0] == '1' && p[1] == 0) + fail_on_invalid_config = 1; + + ret = _gnutls_update_system_priorities(true /* defer_system_wide */); + if (ret < 0) { + _gnutls_debug_log("failed to update system priorities: %s\n", + gnutls_strerror(ret)); + } +} + +void _gnutls_unload_system_priorities(void) +{ + _name_val_array_clear(&system_wide_config.priority_strings); + gnutls_free(system_wide_config.priority_string); + _clear_default_system_priority(); + system_priority_last_mod = 0; +} + +/** + * gnutls_get_system_config_file: + * + * Returns the filename of the system wide configuration + * file to be loaded by the library. + * + * Returns: a constant pointer to the config file path + * + * Since: 3.6.9 + **/ +const char *gnutls_get_system_config_file(void) +{ + return system_priority_file; +} + +#define S(str) ((str!=NULL)?str:"") + +/* Returns the new priorities if a priority string prefixed + * with '@' is provided, or just a copy of the provided + * priorities, appended with any additional present in + * the priorities string. + * + * The returned string must be released using gnutls_free(). + */ +char *_gnutls_resolve_priorities(const char* priorities) +{ + const char *p = priorities; + char *additional = NULL; + char *resolved = NULL; + const char *ss, *ss_next; + unsigned ss_len, ss_next_len; + size_t n, n2 = 0; + int ret; + + while (c_isspace(*p)) { + p++; + } + + /* Cannot reduce further. */ + if (*p != '@') { + return gnutls_strdup(p); + } + + ss = p+1; + additional = strchr(ss, ':'); + if (additional) { + additional++; + } + + /* Always try to refresh the cached data, to allow it to be + * updated without restarting all applications. + */ + ret = _gnutls_update_system_priorities(false /* defer_system_wide */); + if (ret < 0) { + _gnutls_debug_log("failed to update system priorities: %s\n", + gnutls_strerror(ret)); + } + + do { + ss_next = strchr(ss, ','); + if (ss_next) { + if (additional && ss_next > additional) { + ss_next = NULL; + } else { + ss_next++; + } + } + + if (ss_next) { + ss_len = ss_next - ss - 1; + ss_next_len = additional - ss_next - 1; + } else if (additional) { + ss_len = additional - ss - 1; + ss_next_len = 0; + } else { + ss_len = strlen(ss); + ss_next_len = 0; + } + + ret = gnutls_rwlock_rdlock(&system_wide_config_rwlock); + if (ret < 0) { + _gnutls_debug_log("cannot read system priority strings: %s\n", + gnutls_strerror(ret)); + break; + } + if (system_wide_config.allowlisting && + ss_len == sizeof(LEVEL_SYSTEM) - 1 && + strncmp(LEVEL_SYSTEM, ss, ss_len) == 0) { + p = system_wide_config.priority_string; + } else { + p = _name_val_array_value(system_wide_config.priority_strings, ss, ss_len); + } + + _gnutls_debug_log("resolved '%.*s' to '%s', next '%.*s'\n", + ss_len, ss, S(p), ss_next_len, S(ss_next)); + + if (p) { + n = strlen(p); + if (additional) { + n2 = strlen(additional); + } + + resolved = gnutls_malloc(n+n2+1+1); + if (resolved) { + memcpy(resolved, p, n); + if (additional) { + resolved[n] = ':'; + memcpy(&resolved[n+1], additional, n2); + resolved[n+n2+1] = 0; + } else { + resolved[n] = 0; + } + } + } + + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + + ss = ss_next; + } while (ss && !resolved); + + if (resolved) { + _gnutls_debug_log("selected priority string: %s\n", resolved); + } else { + _gnutls_debug_log("unable to resolve %s\n", priorities); + } + + return resolved; +} + +static void add_ec(gnutls_priority_t priority_cache) +{ + const gnutls_group_entry_st *ge; + unsigned i; + + for (i = 0; i < priority_cache->_supported_ecc.num_priorities; i++) { + ge = _gnutls_id_to_group(priority_cache->_supported_ecc.priorities[i]); + if (ge != NULL && priority_cache->groups.size < sizeof(priority_cache->groups.entry)/sizeof(priority_cache->groups.entry[0])) { + /* do not add groups which do not correspond to enabled ciphersuites */ + if (!ge->curve) + continue; + priority_cache->groups.entry[priority_cache->groups.size++] = ge; + } + } +} + +static void add_dh(gnutls_priority_t priority_cache) +{ + const gnutls_group_entry_st *ge; + unsigned i; + + for (i = 0; i < priority_cache->_supported_ecc.num_priorities; i++) { + ge = _gnutls_id_to_group(priority_cache->_supported_ecc.priorities[i]); + if (ge != NULL && priority_cache->groups.size < sizeof(priority_cache->groups.entry)/sizeof(priority_cache->groups.entry[0])) { + /* do not add groups which do not correspond to enabled ciphersuites */ + if (!ge->prime) + continue; + priority_cache->groups.entry[priority_cache->groups.size++] = ge; + priority_cache->groups.have_ffdhe = 1; + } + } +} + +/* This function was originally precalculating ciphersuite-specific items, however + * it has now extended to much more than that. It provides a consistency check to + * set parameters, and in cases it applies policy specific items. + */ +static int set_ciphersuite_list(gnutls_priority_t priority_cache) +{ + unsigned i, j, z; + const gnutls_cipher_suite_entry_st *ce; + const gnutls_sign_entry_st *se; + unsigned have_ec = 0; + unsigned have_dh = 0; + unsigned tls_sig_sem = 0; + const version_entry_st *tlsmax = NULL, *vers; + const version_entry_st *dtlsmax = NULL; + const version_entry_st *tlsmin = NULL; + const version_entry_st *dtlsmin = NULL; + unsigned have_tls13 = 0, have_srp = 0; + unsigned have_pre_tls12 = 0, have_tls12 = 0; + unsigned have_psk = 0, have_null = 0, have_rsa_psk = 0; + gnutls_digest_algorithm_t prf_digest; + int ret = 0; + + /* have_psk indicates that a PSK key exchange compatible + * with TLS1.3 is enabled. */ + + priority_cache->cs.size = 0; + priority_cache->sigalg.size = 0; + priority_cache->groups.size = 0; + priority_cache->groups.have_ffdhe = 0; + + /* The following requires a lock so there are no inconsistencies in the + * members of system_wide_config loaded from the config file. */ + ret = gnutls_rwlock_rdlock(&system_wide_config_rwlock); + if (ret < 0) { + return gnutls_assert_val(ret); + } + + /* in blocklisting mode, apply system wide disablement of key exchanges, + * groups, MACs, and ciphers. */ + if (!system_wide_config.allowlisting) { + /* disable key exchanges which are globally disabled */ + z = 0; + while (system_wide_config.kxs[z] != 0) { + for (i = j = 0; i < priority_cache->_kx.num_priorities; i++) { + if (priority_cache->_kx.priorities[i] != system_wide_config.kxs[z]) + priority_cache->_kx.priorities[j++] = priority_cache->_kx.priorities[i]; + } + priority_cache->_kx.num_priorities = j; + z++; + } + + /* disable groups which are globally disabled */ + z = 0; + while (system_wide_config.groups[z] != 0) { + for (i = j = 0; i < priority_cache->_supported_ecc.num_priorities; i++) { + if (priority_cache->_supported_ecc.priorities[i] != system_wide_config.groups[z]) + priority_cache->_supported_ecc.priorities[j++] = priority_cache->_supported_ecc.priorities[i]; + } + priority_cache->_supported_ecc.num_priorities = j; + z++; + } + + /* disable ciphers which are globally disabled */ + z = 0; + while (system_wide_config.ciphers[z] != 0) { + for (i = j = 0; i < priority_cache->_cipher.num_priorities; i++) { + if (priority_cache->_cipher.priorities[i] != system_wide_config.ciphers[z]) + priority_cache->_cipher.priorities[j++] = priority_cache->_cipher.priorities[i]; + } + priority_cache->_cipher.num_priorities = j; + z++; + } + + /* disable MACs which are globally disabled */ + z = 0; + while (system_wide_config.macs[z] != 0) { + for (i = j = 0; i < priority_cache->_mac.num_priorities; i++) { + if (priority_cache->_mac.priorities[i] != system_wide_config.macs[z]) + priority_cache->_mac.priorities[j++] = priority_cache->_mac.priorities[i]; + } + priority_cache->_mac.num_priorities = j; + z++; + } + } + + for (j=0;j<priority_cache->_cipher.num_priorities;j++) { + if (priority_cache->_cipher.priorities[j] == GNUTLS_CIPHER_NULL) { + have_null = 1; + break; + } + } + + for (i = 0; i < priority_cache->_kx.num_priorities; i++) { + if (IS_SRP_KX(priority_cache->_kx.priorities[i])) { + have_srp = 1; + } else if (_gnutls_kx_is_psk(priority_cache->_kx.priorities[i])) { + if (priority_cache->_kx.priorities[i] == GNUTLS_KX_RSA_PSK) + have_rsa_psk = 1; + else + have_psk = 1; + } + } + + /* disable TLS versions which are added but are unsupported */ + for (i = j = 0; i < priority_cache->protocol.num_priorities; i++) { + vers = version_to_entry(priority_cache->protocol.priorities[i]); + if (!vers || vers->supported || + (system_wide_config.allowlisting && \ + vers->supported_revertible)) + priority_cache->protocol.priorities[j++] = priority_cache->protocol.priorities[i]; + } + priority_cache->protocol.num_priorities = j; + + + /* if we have NULL ciphersuites, SRP, or RSA-PSK enabled remove TLS1.3+ + * protocol versions; they cannot be negotiated under TLS1.3. */ + if (have_null || have_srp || have_rsa_psk || priority_cache->no_extensions) { + for (i = j = 0; i < priority_cache->protocol.num_priorities; i++) { + vers = version_to_entry(priority_cache->protocol.priorities[i]); + if (!vers || !vers->tls13_sem) + priority_cache->protocol.priorities[j++] = priority_cache->protocol.priorities[i]; + } + priority_cache->protocol.num_priorities = j; + } + + for (i = 0; i < priority_cache->protocol.num_priorities; i++) { + vers = version_to_entry(priority_cache->protocol.priorities[i]); + if (!vers) + continue; + + if (vers->transport == GNUTLS_STREAM) { /* TLS */ + tls_sig_sem |= vers->tls_sig_sem; + if (vers->tls13_sem) + have_tls13 = 1; + + if (vers->id == GNUTLS_TLS1_2) + have_tls12 = 1; + else if (vers->id < GNUTLS_TLS1_2) + have_pre_tls12 = 1; + + if (tlsmax == NULL || vers->age > tlsmax->age) + tlsmax = vers; + if (tlsmin == NULL || vers->age < tlsmin->age) + tlsmin = vers; + } else { /* dtls */ + tls_sig_sem |= vers->tls_sig_sem; + + /* we need to introduce similar handling to above + * when DTLS1.3 is supported */ + + if (dtlsmax == NULL || vers->age > dtlsmax->age) + dtlsmax = vers; + if (dtlsmin == NULL || vers->age < dtlsmin->age) + dtlsmin = vers; + } + } + + /* DTLS or TLS protocols must be present */ + if ((!tlsmax || !tlsmin) && (!dtlsmax || !dtlsmin)) { + ret = gnutls_assert_val(GNUTLS_E_NO_PRIORITIES_WERE_SET); + goto out; + } + + priority_cache->have_psk = have_psk; + + /* if we are have TLS1.3+ do not enable any key exchange algorithms, + * the protocol doesn't require any. */ + if (tlsmin && tlsmin->tls13_sem && !have_psk) { + if (!dtlsmin || (dtlsmin && dtlsmin->tls13_sem)) + priority_cache->_kx.num_priorities = 0; + } + + /* Add TLS 1.3 ciphersuites (no KX) */ + for (j=0;j<priority_cache->_cipher.num_priorities;j++) { + for (z=0;z<priority_cache->_mac.num_priorities;z++) { + ce = cipher_suite_get( + 0, priority_cache->_cipher.priorities[j], + priority_cache->_mac.priorities[z]); + if (ce == NULL) + continue; + + prf_digest = MAC_TO_DIG(ce->prf); + if (prf_digest == GNUTLS_DIG_UNKNOWN) + continue; + if (_gnutls_digest_is_insecure(prf_digest)) + continue; + + if (priority_cache->cs.size < MAX_CIPHERSUITE_SIZE) + priority_cache->cs.entry[priority_cache->cs.size++] = ce; + } + } + + for (i = 0; i < priority_cache->_kx.num_priorities; i++) { + for (j=0;j<priority_cache->_cipher.num_priorities;j++) { + for (z=0;z<priority_cache->_mac.num_priorities;z++) { + ce = cipher_suite_get( + priority_cache->_kx.priorities[i], + priority_cache->_cipher.priorities[j], + priority_cache->_mac.priorities[z]); + if (ce == NULL) + continue; + + prf_digest = MAC_TO_DIG(ce->prf); + if (prf_digest == GNUTLS_DIG_UNKNOWN) + continue; + if (_gnutls_digest_is_insecure(prf_digest)) + continue; + + if (priority_cache->cs.size == MAX_CIPHERSUITE_SIZE) + continue; + priority_cache->cs.entry[priority_cache->cs.size++] = ce; + if (!have_ec && (_gnutls_kx_is_ecc(ce->kx_algorithm) || + _gnutls_kx_is_vko_gost(ce->kx_algorithm))) { + have_ec = 1; + add_ec(priority_cache); + } + if (!have_dh && _gnutls_kx_is_dhe(ce->kx_algorithm)) { + have_dh = 1; + add_dh(priority_cache); + } + } + } + } + + if (have_tls13 && (!have_ec || !have_dh)) { + /* scan groups to determine have_ec and have_dh */ + for (i=0; i < priority_cache->_supported_ecc.num_priorities; i++) { + const gnutls_group_entry_st *ge; + ge = _gnutls_id_to_group(priority_cache->_supported_ecc.priorities[i]); + if (ge) { + if (ge->curve && !have_ec) { + add_ec(priority_cache); + have_ec = 1; + } else if (ge->prime && !have_dh) { + add_dh(priority_cache); + have_dh = 1; + } + + if (have_dh && have_ec) + break; + } + } + + } + + for (i = 0; i < priority_cache->_sign_algo.num_priorities; i++) { + se = _gnutls_sign_to_entry(priority_cache->_sign_algo.priorities[i]); + if (se != NULL && priority_cache->sigalg.size < sizeof(priority_cache->sigalg.entry)/sizeof(priority_cache->sigalg.entry[0])) { + /* if the signature algorithm semantics is not + * compatible with the protocol's, or the algorithm is + * marked as insecure, then skip. */ + if ((se->aid.tls_sem & tls_sig_sem) == 0 || + !_gnutls_sign_is_secure2(se, system_wide_config.allowlisting ? + GNUTLS_SIGN_FLAG_ALLOW_INSECURE_REVERTIBLE : + 0)) { + continue; + } + priority_cache->sigalg.entry[priority_cache->sigalg.size++] = se; + } + } + + _gnutls_debug_log("added %d protocols, %d ciphersuites, %d sig algos and %d groups into priority list\n", + priority_cache->protocol.num_priorities, + priority_cache->cs.size, priority_cache->sigalg.size, + priority_cache->groups.size); + + if (priority_cache->sigalg.size == 0) { + /* no signature algorithms; eliminate TLS 1.2 or DTLS 1.2 and later */ + priority_st newp; + newp.num_priorities = 0; + + /* we need to eliminate TLS 1.2 or DTLS 1.2 and later protocols */ + for (i = 0; i < priority_cache->protocol.num_priorities; i++) { + if (priority_cache->protocol.priorities[i] < GNUTLS_TLS1_2) { + newp.priorities[newp.num_priorities++] = priority_cache->protocol.priorities[i]; + } else if (priority_cache->protocol.priorities[i] >= GNUTLS_DTLS_VERSION_MIN && + priority_cache->protocol.priorities[i] < GNUTLS_DTLS1_2) { + newp.priorities[newp.num_priorities++] = priority_cache->protocol.priorities[i]; + } + } + memcpy(&priority_cache->protocol, &newp, sizeof(newp)); + } + + if (unlikely(priority_cache->protocol.num_priorities == 0)) { + ret = gnutls_assert_val(GNUTLS_E_NO_PRIORITIES_WERE_SET); + goto out; + } +#ifndef ENABLE_SSL3 + else if (unlikely(priority_cache->protocol.num_priorities == 1 && priority_cache->protocol.priorities[0] == GNUTLS_SSL3)) { + ret = gnutls_assert_val(GNUTLS_E_NO_PRIORITIES_WERE_SET); + goto out; + } +#endif + + if (unlikely(priority_cache->cs.size == 0)) { + ret = gnutls_assert_val(GNUTLS_E_NO_PRIORITIES_WERE_SET); + goto out; + } + + /* when TLS 1.3 is available we must have groups set; additionally + * we require TLS1.2 to be enabled if TLS1.3 is asked for, and + * a pre-TLS1.2 protocol is there; that is because servers which + * do not support TLS1.3 will negotiate TLS1.2 if seen a TLS1.3 handshake */ + if (unlikely((!have_psk && tlsmax && tlsmax->id >= GNUTLS_TLS1_3 && priority_cache->groups.size == 0)) || + (!have_tls12 && have_pre_tls12 && have_tls13)) { + for (i = j = 0; i < priority_cache->protocol.num_priorities; i++) { + vers = version_to_entry(priority_cache->protocol.priorities[i]); + if (!vers || vers->transport != GNUTLS_STREAM || !vers->tls13_sem) + priority_cache->protocol.priorities[j++] = priority_cache->protocol.priorities[i]; + } + priority_cache->protocol.num_priorities = j; + } + + /* ensure that the verification profile is not lower from the configured */ + if (system_wide_config.verification_profile) { + gnutls_sec_param_t level = priority_cache->level; + gnutls_sec_param_t system_wide_level = _gnutls_profile_to_sec_level(system_wide_config.verification_profile); + + if (level < system_wide_level) { + ENABLE_PROFILE(priority_cache, system_wide_config.verification_profile); + } + } + + out: + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return ret; +} + +/** + * gnutls_priority_init2: + * @priority_cache: is a #gnutls_priority_t type. + * @priorities: is a string describing priorities (may be %NULL) + * @err_pos: In case of an error this will have the position in the string the error occurred + * @flags: zero or %GNUTLS_PRIORITY_INIT_DEF_APPEND + * + * Sets priorities for the ciphers, key exchange methods, and macs. + * The @priority_cache should be deinitialized + * using gnutls_priority_deinit(). + * + * The #priorities option allows you to specify a colon + * separated list of the cipher priorities to enable. + * Some keywords are defined to provide quick access + * to common preferences. + * + * When @flags is set to %GNUTLS_PRIORITY_INIT_DEF_APPEND then the @priorities + * specified will be appended to the default options. + * + * Unless there is a special need, use the "NORMAL" keyword to + * apply a reasonable security level, or "NORMAL:%%COMPAT" for compatibility. + * + * "PERFORMANCE" means all the "secure" ciphersuites are enabled, + * limited to 128 bit ciphers and sorted by terms of speed + * performance. + * + * "LEGACY" the NORMAL settings for GnuTLS 3.2.x or earlier. There is + * no verification profile set, and the allowed DH primes are considered + * weak today. + * + * "NORMAL" means all "secure" ciphersuites. The 256-bit ciphers are + * included as a fallback only. The ciphers are sorted by security + * margin. + * + * "PFS" means all "secure" ciphersuites that support perfect forward secrecy. + * The 256-bit ciphers are included as a fallback only. + * The ciphers are sorted by security margin. + * + * "SECURE128" means all "secure" ciphersuites of security level 128-bit + * or more. + * + * "SECURE192" means all "secure" ciphersuites of security level 192-bit + * or more. + * + * "SUITEB128" means all the NSA SuiteB ciphersuites with security level + * of 128. + * + * "SUITEB192" means all the NSA SuiteB ciphersuites with security level + * of 192. + * + * "NONE" means nothing is enabled. This disables everything, including protocols. + * + * "@@KEYWORD1,KEYWORD2,..." The system administrator imposed settings. + * The provided keyword(s) will be expanded from a configuration-time + * provided file - default is: /etc/gnutls/config. + * Any attributes that follow it, will be appended to the expanded + * string. If multiple keywords are provided, separated by commas, + * then the first keyword that exists in the configuration file + * will be used. At least one of the keywords must exist, or this + * function will return an error. Typical usage would be to specify + * an application specified keyword first, followed by "SYSTEM" as + * a default fallback. e.g., "@LIBVIRT,SYSTEM:!-VERS-SSL3.0" will + * first try to find a config file entry matching "LIBVIRT", but if + * that does not exist will use the entry for "SYSTEM". If "SYSTEM" + * does not exist either, an error will be returned. In all cases, + * the SSL3.0 protocol will be disabled. The system priority file + * entries should be formatted as "KEYWORD=VALUE", e.g., + * "SYSTEM=NORMAL:+ARCFOUR-128". + * + * Special keywords are "!", "-" and "+". + * "!" or "-" appended with an algorithm will remove this algorithm. + * "+" appended with an algorithm will add this algorithm. + * + * Check the GnuTLS manual section "Priority strings" for detailed + * information. + * + * Examples: + * + * "NONE:+VERS-TLS-ALL:+MAC-ALL:+RSA:+AES-128-CBC:+SIGN-ALL:+COMP-NULL" + * + * "NORMAL:+ARCFOUR-128" means normal ciphers plus ARCFOUR-128. + * + * "SECURE128:-VERS-SSL3.0" means that only secure ciphers are + * and enabled, SSL3.0 is disabled. + * + * "NONE:+VERS-TLS-ALL:+AES-128-CBC:+RSA:+SHA1:+COMP-NULL:+SIGN-RSA-SHA1", + * + * "NONE:+VERS-TLS-ALL:+AES-128-CBC:+ECDHE-RSA:+SHA1:+COMP-NULL:+SIGN-RSA-SHA1:+CURVE-SECP256R1", + * + * "SECURE256:+SECURE128", + * + * Note that "NORMAL:%%COMPAT" is the most compatible mode. + * + * A %NULL @priorities string indicates the default priorities to be + * used (this is available since GnuTLS 3.3.0). + * + * Returns: On syntax error %GNUTLS_E_INVALID_REQUEST is returned, + * %GNUTLS_E_SUCCESS on success, or an error code. + * + * Since: 3.6.3 + **/ +int +gnutls_priority_init2(gnutls_priority_t * priority_cache, + const char *priorities, const char **err_pos, + unsigned flags) +{ + gnutls_buffer_st buf; + const char *ep; + int ret; + + if (flags & GNUTLS_PRIORITY_INIT_DEF_APPEND) { + if (priorities == NULL) + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); + + if (err_pos) + *err_pos = priorities; + + _gnutls_buffer_init(&buf); + + ret = _gnutls_buffer_append_str(&buf, _gnutls_default_priority_string); + if (ret < 0) { + _gnutls_buffer_clear(&buf); + return gnutls_assert_val(ret); + } + + ret = _gnutls_buffer_append_str(&buf, ":"); + if (ret < 0) { + _gnutls_buffer_clear(&buf); + return gnutls_assert_val(ret); + } + + ret = _gnutls_buffer_append_str(&buf, priorities); + if (ret < 0) { + _gnutls_buffer_clear(&buf); + return gnutls_assert_val(ret); + } + + ret = gnutls_priority_init(priority_cache, (const char*)buf.data, &ep); + if (ret < 0 && ep != (const char*)buf.data && ep != NULL) { + ptrdiff_t diff = (ptrdiff_t)ep-(ptrdiff_t)buf.data; + unsigned hlen = strlen(_gnutls_default_priority_string)+1; + + if (err_pos && diff > hlen) { + *err_pos = priorities + diff - hlen; + } + } + _gnutls_buffer_clear(&buf); + return ret; + } else { + return gnutls_priority_init(priority_cache, priorities, err_pos); + } +} + +#define PRIO_MATCH(name) c_strncasecmp(&broken_list[i][1], name, sizeof(name) - 1) + +/** + * gnutls_priority_init: + * @priority_cache: is a #gnutls_priority_t type. + * @priorities: is a string describing priorities (may be %NULL) + * @err_pos: In case of an error this will have the position in the string the error occurred + * + * For applications that do not modify their crypto settings per release, consider + * using gnutls_priority_init2() with %GNUTLS_PRIORITY_INIT_DEF_APPEND flag + * instead. We suggest to use centralized crypto settings handled by the GnuTLS + * library, and applications modifying the default settings to their needs. + * + * This function is identical to gnutls_priority_init2() with zero + * flags. + * + * A %NULL @priorities string indicates the default priorities to be + * used (this is available since GnuTLS 3.3.0). + * + * Returns: On syntax error %GNUTLS_E_INVALID_REQUEST is returned, + * %GNUTLS_E_SUCCESS on success, or an error code. + **/ +int +gnutls_priority_init(gnutls_priority_t * priority_cache, + const char *priorities, const char **err_pos) +{ + char *broken_list[MAX_ELEMENTS]; + int broken_list_size = 0, i = 0, j; + char *darg = NULL; + unsigned ikeyword_set = 0; + int algo; + int ret; + rmadd_func *fn; + bulk_rmadd_func *bulk_fn; + bulk_rmadd_func *bulk_given_fn; + const cipher_entry_st *centry; + unsigned resolved_match = 1; + + if (err_pos) + *err_pos = priorities; + + *priority_cache = + gnutls_calloc(1, sizeof(struct gnutls_priority_st)); + if (*priority_cache == NULL) { + gnutls_assert(); + return GNUTLS_E_MEMORY_ERROR; + } + + /* for now unsafe renegotiation is default on everyone. To be removed + * when we make it the default. + */ + (*priority_cache)->sr = SR_PARTIAL; + /* For now TLS 1.3 middlebox compatibility mode is enabled by default. + * This will eventually be disabled by default and moved to the %COMPAT + * setting. + */ + (*priority_cache)->tls13_compat_mode = true; + (*priority_cache)->min_record_version = 1; + gnutls_atomic_init(&(*priority_cache)->usage_cnt); + + if (system_wide_config.allowlisting && !priorities) { + priorities = "@" LEVEL_SYSTEM; + } + if (priorities == NULL) { + priorities = _gnutls_default_priority_string; + resolved_match = 0; + } + + darg = _gnutls_resolve_priorities(priorities); + if (darg == NULL) { + gnutls_assert(); + goto error; + } + + if (strcmp(darg, priorities) != 0) + resolved_match = 0; + + break_list(darg, broken_list, &broken_list_size); + /* This is our default set of protocol version, certificate types. + */ + if (c_strcasecmp(broken_list[0], LEVEL_NONE) != 0) { + _set_priority(&(*priority_cache)->protocol, + protocol_priority); + _set_priority(&(*priority_cache)->client_ctype, + cert_type_priority_default); + _set_priority(&(*priority_cache)->server_ctype, + cert_type_priority_default); + _set_priority(&(*priority_cache)->_sign_algo, + sign_priority_default); + _set_priority(&(*priority_cache)->_supported_ecc, + supported_groups_normal); + i = 0; + } else { + ikeyword_set = 1; + i = 1; + } + + for (; i < broken_list_size; i++) { + if (check_level(broken_list[i], *priority_cache, ikeyword_set) != 0) { + ikeyword_set = 1; + continue; + } else if (broken_list[i][0] == '!' + || broken_list[i][0] == '+' + || broken_list[i][0] == '-') { + if (broken_list[i][0] == '+') { + fn = prio_add; + bulk_fn = _add_priority; + bulk_given_fn = _add_priority; + } else { + fn = prio_remove; + bulk_fn = _clear_priorities; + bulk_given_fn = _clear_given_priorities; + } + + if (broken_list[i][0] == '+' + && check_level(&broken_list[i][1], + *priority_cache, 1) != 0) { + continue; + } else if ((algo = + gnutls_mac_get_id(&broken_list[i][1])) + != GNUTLS_MAC_UNKNOWN) { + fn(&(*priority_cache)->_mac, algo); + } else if ((centry = cipher_name_to_entry(&broken_list[i][1])) != NULL) { + if (_gnutls_cipher_exists(centry->id)) { + fn(&(*priority_cache)->_cipher, centry->id); + if (centry->type == CIPHER_BLOCK) + (*priority_cache)->have_cbc = 1; + } + } else if ((algo = + _gnutls_kx_get_id(&broken_list[i][1])) != + GNUTLS_KX_UNKNOWN) { + if (algo != GNUTLS_KX_INVALID) + fn(&(*priority_cache)->_kx, algo); + } else if (PRIO_MATCH("VERS-") == 0) { + if (PRIO_MATCH("VERS-TLS-ALL") == 0) { + bulk_given_fn(&(*priority_cache)-> + protocol, + stream_protocol_priority); + } else if (PRIO_MATCH("VERS-DTLS-ALL") == 0) { + bulk_given_fn(&(*priority_cache)-> + protocol, + (bulk_given_fn==_add_priority)?dtls_protocol_priority:dgram_protocol_priority); + } else if (PRIO_MATCH("VERS-ALL") == 0) { + bulk_fn(&(*priority_cache)-> + protocol, + protocol_priority); + } else { + if ((algo = + gnutls_protocol_get_id + (&broken_list[i][6])) != + GNUTLS_VERSION_UNKNOWN) { + fn(&(*priority_cache)-> + protocol, algo); + } else + goto error; + + } + } /* now check if the element is something like -ALGO */ + else if (PRIO_MATCH("COMP-") == 0) { + /* ignore all compression methods */ + continue; + } /* now check if the element is something like -ALGO */ + else if (PRIO_MATCH("CURVE-") == 0) { + if (PRIO_MATCH("CURVE-ALL") == 0) { + bulk_fn(&(*priority_cache)-> + _supported_ecc, + supported_groups_normal); + } else { + if ((algo = + gnutls_ecc_curve_get_id + (&broken_list[i][7])) != + GNUTLS_ECC_CURVE_INVALID) + fn(&(*priority_cache)-> + _supported_ecc, algo); + else + goto error; + } + } else if (PRIO_MATCH("GROUP-") == 0) { + if (PRIO_MATCH("GROUP-ALL") == 0) { + bulk_fn(&(*priority_cache)-> + _supported_ecc, + supported_groups_normal); + } else if (PRIO_MATCH("GROUP-DH-ALL") == 0) { + bulk_given_fn(&(*priority_cache)-> + _supported_ecc, + _supported_groups_dh); + } else if (PRIO_MATCH("GROUP-EC-ALL") == 0) { + bulk_given_fn(&(*priority_cache)-> + _supported_ecc, + _supported_groups_ecdh); + } else if (PRIO_MATCH("GROUP-GOST-ALL") == 0) { + bulk_given_fn(&(*priority_cache)-> + _supported_ecc, + _supported_groups_gost); + } else { + if ((algo = + _gnutls_group_get_id + (&broken_list[i][7])) != + GNUTLS_GROUP_INVALID) + fn(&(*priority_cache)-> + _supported_ecc, algo); + else + goto error; + } + } else if (PRIO_MATCH("CTYPE-") == 0) { + // Certificate types + if (PRIO_MATCH("CTYPE-ALL") == 0) { + // Symmetric cert types, all types allowed + bulk_fn(&(*priority_cache)->client_ctype, + cert_type_priority_all); + bulk_fn(&(*priority_cache)->server_ctype, + cert_type_priority_all); + } else if (PRIO_MATCH("CTYPE-CLI-") == 0) { + // Client certificate types + if (PRIO_MATCH("CTYPE-CLI-ALL") == 0) { + // All client cert types allowed + bulk_fn(&(*priority_cache)->client_ctype, + cert_type_priority_all); + } else if ((algo = gnutls_certificate_type_get_id + (&broken_list[i][11])) != GNUTLS_CRT_UNKNOWN) { + // Specific client cert type allowed + fn(&(*priority_cache)->client_ctype, algo); + } else goto error; + } else if (PRIO_MATCH("CTYPE-SRV-") == 0) { + // Server certificate types + if (PRIO_MATCH("CTYPE-SRV-ALL") == 0) { + // All server cert types allowed + bulk_fn(&(*priority_cache)->server_ctype, + cert_type_priority_all); + } else if ((algo = gnutls_certificate_type_get_id + (&broken_list[i][11])) != GNUTLS_CRT_UNKNOWN) { + // Specific server cert type allowed + fn(&(*priority_cache)->server_ctype, algo); + } else goto error; + } else { // Symmetric certificate type + if ((algo = gnutls_certificate_type_get_id + (&broken_list[i][7])) != GNUTLS_CRT_UNKNOWN) { + fn(&(*priority_cache)->client_ctype, algo); + fn(&(*priority_cache)->server_ctype, algo); + } else if (PRIO_MATCH("CTYPE-OPENPGP") == 0) { + /* legacy openpgp option - ignore */ + continue; + } else goto error; + } + } else if (PRIO_MATCH("SIGN-") == 0) { + if (PRIO_MATCH("SIGN-ALL") == 0) { + bulk_fn(&(*priority_cache)-> + _sign_algo, + sign_priority_default); + } else if (PRIO_MATCH("SIGN-GOST-ALL") == 0) { + bulk_fn(&(*priority_cache)-> + _sign_algo, + sign_priority_gost); + } else { + if ((algo = + gnutls_sign_get_id + (&broken_list[i][6])) != + GNUTLS_SIGN_UNKNOWN) + fn(&(*priority_cache)-> + _sign_algo, algo); + else + goto error; + } + } else if (PRIO_MATCH("MAC-") == 0) { + if (PRIO_MATCH("MAC-ALL") == 0) { + bulk_fn(&(*priority_cache)->_mac, + mac_priority_normal); + } else if (PRIO_MATCH("MAC-GOST-ALL") == 0) { + bulk_fn(&(*priority_cache)->_mac, + mac_priority_gost); + } + } else if (PRIO_MATCH("CIPHER-") == 0) { + if (PRIO_MATCH("CIPHER-ALL") == 0) { + bulk_fn(&(*priority_cache)->_cipher, + cipher_priority_normal); + } else if (PRIO_MATCH("CIPHER-GOST-ALL") == 0) { + bulk_fn(&(*priority_cache)->_cipher, + cipher_priority_gost); + } + } else if (PRIO_MATCH("KX-") == 0) { + if (PRIO_MATCH("KX-ALL") == 0) { + bulk_fn(&(*priority_cache)->_kx, + kx_priority_secure); + } else if (PRIO_MATCH("KX-GOST-ALL") == 0) { + bulk_fn(&(*priority_cache)->_kx, + kx_priority_gost); + } + } else if (PRIO_MATCH("GOST") == 0) { + bulk_given_fn(&(*priority_cache)->_supported_ecc, + _supported_groups_gost); + bulk_fn(&(*priority_cache)->_sign_algo, + sign_priority_gost); + bulk_fn(&(*priority_cache)->_mac, + mac_priority_gost); + bulk_fn(&(*priority_cache)->_cipher, + cipher_priority_gost); + bulk_fn(&(*priority_cache)->_kx, + kx_priority_gost); + } else + goto error; + } else if (broken_list[i][0] == '%') { + const struct priority_options_st * o; + /* to add a new option modify + * priority_options.gperf */ + o = in_word_set(&broken_list[i][1], strlen(&broken_list[i][1])); + if (o == NULL) { + goto error; + } + o->func(*priority_cache); + } else + goto error; + } + + ret = set_ciphersuite_list(*priority_cache); + if (ret < 0) { + if (err_pos) + *err_pos = priorities; + goto error_cleanup; + } + + gnutls_free(darg); + + return 0; + + error: + if (err_pos != NULL && i < broken_list_size && resolved_match) { + *err_pos = priorities; + for (j = 0; j < i; j++) { + (*err_pos) += strlen(broken_list[j]) + 1; + } + } + ret = GNUTLS_E_INVALID_REQUEST; + + error_cleanup: + free(darg); + gnutls_priority_deinit(*priority_cache); + *priority_cache = NULL; + + return ret; +} + +/** + * gnutls_priority_deinit: + * @priority_cache: is a #gnutls_priority_t type. + * + * Deinitializes the priority cache. + **/ +void gnutls_priority_deinit(gnutls_priority_t priority_cache) +{ + if (priority_cache == NULL) + return; + + /* Note that here we care about the following two cases: + * 1. Multiple sessions or different threads holding a reference + a global reference + * 2. One session holding a reference with a possible global reference + * + * As such, it will never be that two threads reach the + * zero state at the same time, unless the global reference + * is cleared too, which is invalid state. + */ + if (gnutls_atomic_val(&priority_cache->usage_cnt) == 0) { + gnutls_atomic_deinit(&priority_cache->usage_cnt); + gnutls_free(priority_cache); + return; + } else { + gnutls_atomic_decrement(&priority_cache->usage_cnt); + } +} + + +/** + * gnutls_priority_set_direct: + * @session: is a #gnutls_session_t type. + * @priorities: is a string describing priorities + * @err_pos: In case of an error this will have the position in the string the error occurred + * + * Sets the priorities to use on the ciphers, key exchange methods, + * and macs. This function avoids keeping a + * priority cache and is used to directly set string priorities to a + * TLS session. For documentation check the gnutls_priority_init(). + * + * To use a reasonable default, consider using gnutls_set_default_priority(), + * or gnutls_set_default_priority_append() instead of this function. + * + * Returns: On syntax error %GNUTLS_E_INVALID_REQUEST is returned, + * %GNUTLS_E_SUCCESS on success, or an error code. + **/ +int +gnutls_priority_set_direct(gnutls_session_t session, + const char *priorities, const char **err_pos) +{ + gnutls_priority_t prio; + int ret; + + ret = gnutls_priority_init(&prio, priorities, err_pos); + if (ret < 0) { + gnutls_assert(); + return ret; + } + + ret = gnutls_priority_set(session, prio); + if (ret < 0) { + gnutls_assert(); + return ret; + } + + /* ensure that the session holds the only reference for the struct */ + gnutls_priority_deinit(prio); + + return 0; +} + +/* Breaks a list of "xxx", "yyy", to a character array, of + * MAX_COMMA_SEP_ELEMENTS size; Note that the given string is modified. + */ +static void +break_list(char *list, + char *broken_list[MAX_ELEMENTS], int *size) +{ + char *p = list; + + *size = 0; + + do { + broken_list[*size] = p; + + (*size)++; + + p = strchr(p, ':'); + if (p) { + *p = 0; + p++; /* move to next entry and skip white + * space. + */ + while (*p == ' ') + p++; + } + } + while (p != NULL && *size < MAX_ELEMENTS); +} + +/** + * gnutls_set_default_priority: + * @session: is a #gnutls_session_t type. + * + * Sets the default priority on the ciphers, key exchange methods, + * and macs. This is the recommended method of + * setting the defaults, in order to promote consistency between applications + * using GnuTLS, and to allow GnuTLS using applications to update settings + * in par with the library. For client applications which require + * maximum compatibility consider calling gnutls_session_enable_compatibility_mode() + * after this function. + * + * For an application to specify additional options to priority string + * consider using gnutls_set_default_priority_append(). + * + * To allow a user to override the defaults (e.g., when a user interface + * or configuration file is available), the functions + * gnutls_priority_set_direct() or gnutls_priority_set() can + * be used. + * + * Returns: %GNUTLS_E_SUCCESS on success, or an error code. + * + * Since: 2.1.4 + **/ +int gnutls_set_default_priority(gnutls_session_t session) +{ + return gnutls_priority_set_direct(session, NULL, NULL); +} + +/** + * gnutls_set_default_priority_append: + * @session: is a #gnutls_session_t type. + * @add_prio: is a string describing priorities to be appended to default + * @err_pos: In case of an error this will have the position in the string the error occurred + * @flags: must be zero + * + * Sets the default priority on the ciphers, key exchange methods, + * and macs with the additional options in @add_prio. This is the recommended method of + * setting the defaults when only few additional options are to be added. This promotes + * consistency between applications using GnuTLS, and allows GnuTLS using applications + * to update settings in par with the library. + * + * The @add_prio string should start as a normal priority string, e.g., + * '-VERS-TLS-ALL:+VERS-TLS1.3:%%COMPAT' or '%%FORCE_ETM'. That is, it must not start + * with ':'. + * + * To allow a user to override the defaults (e.g., when a user interface + * or configuration file is available), the functions + * gnutls_priority_set_direct() or gnutls_priority_set() can + * be used. + * + * Returns: %GNUTLS_E_SUCCESS on success, or an error code. + * + * Since: 3.6.3 + **/ +int gnutls_set_default_priority_append(gnutls_session_t session, + const char *add_prio, + const char **err_pos, + unsigned flags) +{ + gnutls_priority_t prio; + int ret; + + ret = gnutls_priority_init2(&prio, add_prio, err_pos, GNUTLS_PRIORITY_INIT_DEF_APPEND); + if (ret < 0) { + gnutls_assert(); + return ret; + } + + ret = gnutls_priority_set(session, prio); + if (ret < 0) { + gnutls_assert(); + return ret; + } + + /* ensure that the session holds the only reference for the struct */ + gnutls_priority_deinit(prio); + + return 0; +} + +/** + * gnutls_priority_ecc_curve_list: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list + * + * Get a list of available elliptic curves in the priority + * structure. + * + * Deprecated: This function has been replaced by + * gnutls_priority_group_list() since 3.6.0. + * + * Returns: the number of items, or an error code. + * + * Since: 3.0 + **/ +int +gnutls_priority_ecc_curve_list(gnutls_priority_t pcache, + const unsigned int **list) +{ + unsigned i; + + if (pcache->_supported_ecc.num_priorities == 0) + return 0; + + *list = pcache->_supported_ecc.priorities; + + /* to ensure we don't confuse the caller, we do not include + * any FFDHE groups. This may return an incomplete list. */ + for (i=0;i<pcache->_supported_ecc.num_priorities;i++) + if (pcache->_supported_ecc.priorities[i] > GNUTLS_ECC_CURVE_MAX) + return i; + + return pcache->_supported_ecc.num_priorities; +} + +/** + * gnutls_priority_group_list: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list + * + * Get a list of available groups in the priority + * structure. + * + * Returns: the number of items, or an error code. + * + * Since: 3.6.0 + **/ +int +gnutls_priority_group_list(gnutls_priority_t pcache, + const unsigned int **list) +{ + if (pcache->_supported_ecc.num_priorities == 0) + return 0; + + *list = pcache->_supported_ecc.priorities; + return pcache->_supported_ecc.num_priorities; +} + +/** + * gnutls_priority_kx_list: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list + * + * Get a list of available key exchange methods in the priority + * structure. + * + * Returns: the number of items, or an error code. + * Since: 3.2.3 + **/ +int +gnutls_priority_kx_list(gnutls_priority_t pcache, + const unsigned int **list) +{ + if (pcache->_kx.num_priorities == 0) + return 0; + + *list = pcache->_kx.priorities; + return pcache->_kx.num_priorities; +} + +/** + * gnutls_priority_cipher_list: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list + * + * Get a list of available ciphers in the priority + * structure. + * + * Returns: the number of items, or an error code. + * Since: 3.2.3 + **/ +int +gnutls_priority_cipher_list(gnutls_priority_t pcache, + const unsigned int **list) +{ + if (pcache->_cipher.num_priorities == 0) + return 0; + + *list = pcache->_cipher.priorities; + return pcache->_cipher.num_priorities; +} + +/** + * gnutls_priority_mac_list: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list + * + * Get a list of available MAC algorithms in the priority + * structure. + * + * Returns: the number of items, or an error code. + * Since: 3.2.3 + **/ +int +gnutls_priority_mac_list(gnutls_priority_t pcache, + const unsigned int **list) +{ + if (pcache->_mac.num_priorities == 0) + return 0; + + *list = pcache->_mac.priorities; + return pcache->_mac.num_priorities; +} + +/** + * gnutls_priority_compression_list: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list + * + * Get a list of available compression method in the priority + * structure. + * + * Returns: the number of methods, or an error code. + * Since: 3.0 + **/ +int +gnutls_priority_compression_list(gnutls_priority_t pcache, + const unsigned int **list) +{ + static const unsigned int priority[1] = {GNUTLS_COMP_NULL}; + + *list = priority; + return 1; +} + +/** + * gnutls_priority_protocol_list: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list + * + * Get a list of available TLS version numbers in the priority + * structure. + * + * Returns: the number of protocols, or an error code. + * Since: 3.0 + **/ +int +gnutls_priority_protocol_list(gnutls_priority_t pcache, + const unsigned int **list) +{ + if (pcache->protocol.num_priorities == 0) + return 0; + + *list = pcache->protocol.priorities; + return pcache->protocol.num_priorities; +} + +/** + * gnutls_priority_sign_list: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list + * + * Get a list of available signature algorithms in the priority + * structure. + * + * Returns: the number of algorithms, or an error code. + * Since: 3.0 + **/ +int +gnutls_priority_sign_list(gnutls_priority_t pcache, + const unsigned int **list) +{ + if (pcache->_sign_algo.num_priorities == 0) + return 0; + + *list = pcache->_sign_algo.priorities; + return pcache->_sign_algo.num_priorities; +} + +/** + * gnutls_priority_certificate_type_list: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list + * + * Get a list of available certificate types in the priority + * structure. + * + * As of version 3.6.4 this function is an alias for + * gnutls_priority_certificate_type_list2 with the target parameter + * set to: + * - GNUTLS_CTYPE_SERVER, if the %SERVER_PRECEDENCE option is set + * - GNUTLS_CTYPE_CLIENT, otherwise. + * + * Returns: the number of certificate types, or an error code. + * Since: 3.0 + **/ +int +gnutls_priority_certificate_type_list(gnutls_priority_t pcache, + const unsigned int **list) +{ + gnutls_ctype_target_t target = + pcache->server_precedence ? GNUTLS_CTYPE_SERVER : GNUTLS_CTYPE_CLIENT; + + return gnutls_priority_certificate_type_list2(pcache, list, target); +} + +/** + * gnutls_priority_certificate_type_list2: + * @pcache: is a #gnutls_priority_t type. + * @list: will point to an integer list. + * @target: is a #gnutls_ctype_target_t type. Valid arguments are + * GNUTLS_CTYPE_CLIENT and GNUTLS_CTYPE_SERVER + * + * Get a list of available certificate types for the given target + * in the priority structure. + * + * Returns: the number of certificate types, or an error code. + * + * Since: 3.6.4 + **/ +int +gnutls_priority_certificate_type_list2(gnutls_priority_t pcache, + const unsigned int **list, gnutls_ctype_target_t target) +{ + switch (target) { + case GNUTLS_CTYPE_CLIENT: + if(pcache->client_ctype.num_priorities > 0) { + *list = pcache->client_ctype.priorities; + return pcache->client_ctype.num_priorities; + } + break; + case GNUTLS_CTYPE_SERVER: + if(pcache->server_ctype.num_priorities > 0) { + *list = pcache->server_ctype.priorities; + return pcache->server_ctype.num_priorities; + } + break; + default: + // Invalid target given + gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); + } + + // Found a matching target but non of them had any ctypes set + return 0; +} + +/** + * gnutls_priority_string_list: + * @iter: an integer counter starting from zero + * @flags: one of %GNUTLS_PRIORITY_LIST_INIT_KEYWORDS, %GNUTLS_PRIORITY_LIST_SPECIAL + * + * Can be used to iterate all available priority strings. + * Due to internal implementation details, there are cases where this + * function can return the empty string. In that case that string should be ignored. + * When no strings are available it returns %NULL. + * + * Returns: a priority string + * Since: 3.4.0 + **/ +const char * +gnutls_priority_string_list(unsigned iter, unsigned int flags) +{ + if (flags & GNUTLS_PRIORITY_LIST_INIT_KEYWORDS) { + if (iter >= (sizeof(pgroups)/sizeof(pgroups[0]))-1) + return NULL; + return pgroups[iter].name; + } else if (flags & GNUTLS_PRIORITY_LIST_SPECIAL) { + if (iter >= (sizeof(wordlist)/sizeof(wordlist[0]))-1) + return NULL; + return wordlist[iter].name; + } + return NULL; +} + +bool _gnutls_config_is_ktls_enabled(void){ + return system_wide_config.ktls_enabled; +} + +/* + * high-level interface for overriding configuration files + */ + +static inline bool /* not locking system_wide_config */ +system_wide_config_is_malleable(void) { + if (!system_wide_config.allowlisting) { + _gnutls_audit_log(NULL, "allowlisting is not enabled!\n"); + return false; + } + if (system_wide_config.priority_string) { + _gnutls_audit_log(NULL, "priority strings have already been " + "initialized!\n"); + return false; + } + return true; +} + +/** + * gnutls_digest_set_secure: + * @dig: is a digest algorithm + * @secure: whether to mark the digest algorithm secure + * + * Modify the previous system wide setting that marked @dig as secure + * or insecure. This only has effect when the algorithm is enabled + * through the allowlisting mode in the configuration file, or when + * the setting is modified with a prior call to this function. + * + * Since: 3.7.3 + */ +int +gnutls_digest_set_secure(gnutls_digest_algorithm_t dig, unsigned int secure) +{ +#ifndef DISABLE_SYSTEM_CONFIG + int ret; + ret = gnutls_rwlock_wrlock(&system_wide_config_rwlock); + if (ret < 0) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(ret); + } + if (!system_wide_config_is_malleable()) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); + } + + if (secure) { + ret = cfg_hashes_add(&system_wide_config, dig); + } else { + ret = cfg_hashes_remove(&system_wide_config, dig); + } + + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return ret; +#else + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); +#endif +} + +/** + * gnutls_sign_set_secure: + * @sign: the sign algorithm + * @secure: whether to mark the sign algorithm secure + * + * Modify the previous system wide setting that marked @sign as secure + * or insecure. Calling this function is allowed + * only if allowlisting mode is set in the configuration file, + * and only if the system-wide TLS priority string + * has not been initialized yet. + * The intended usage is to provide applications with a way + * to expressly deviate from the distribution or site defaults + * inherited from the configuration file. + * The modification is composable with further modifications + * performed through the priority string mechanism. + * + * This function is not thread-safe and is intended to be called + * in the main thread at the beginning of the process execution. + * + * Even when @secure is true, @sign is not marked as secure for the + * use in certificates. Use gnutls_sign_set_secure_for_certs() to + * mark it secure as well for certificates. + * + * Returns: 0 on success or negative error code otherwise. + * + * Since: 3.7.3 + */ +int +gnutls_sign_set_secure(gnutls_sign_algorithm_t sign, unsigned int secure) +{ +#ifndef DISABLE_SYSTEM_CONFIG + int ret; + ret = gnutls_rwlock_wrlock(&system_wide_config_rwlock); + if (ret < 0) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(ret); + } + if (!system_wide_config_is_malleable()) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); + } + + if (secure) { + ret = cfg_sigs_add(&system_wide_config, sign); + } else { + ret = cfg_sigs_remove(&system_wide_config, sign); + if (ret < 0) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return ret; + } + /* irregularity, distrusting also means distrusting for certs */ + ret = cfg_sigs_for_cert_remove(&system_wide_config, sign); + } + + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return ret; +#else + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); +#endif +} + + +/** + * gnutls_sign_set_secure_for_certs: + * @sign: the sign algorithm + * @secure: whether to mark the sign algorithm secure for certificates + * + * Modify the previous system wide setting that marked @sign as secure + * or insecure for the use in certificates. Calling this fuction is allowed + * only if allowlisting mode is set in the configuration file, + * and only if the system-wide TLS priority string + * has not been initialized yet. + * The intended usage is to provide applications with a way + * to expressly deviate from the distribution or site defaults + * inherited from the configuration file. + * The modification is composable with further modifications + * performed through the priority string mechanism. + * + * This function is not thread-safe and is intended to be called + * in the main thread at the beginning of the process execution. + + * When @secure is true, @sign is marked as secure for any use unlike + * gnutls_sign_set_secure(). Otherwise, it is marked as insecure only + * for the use in certificates. Use gnutls_sign_set_secure() to mark + * it insecure for any uses. + * + * Returns: 0 on success or negative error code otherwise. + * + * Since: 3.7.3 + */ +int +gnutls_sign_set_secure_for_certs(gnutls_sign_algorithm_t sign, + unsigned int secure) +{ +#ifndef DISABLE_SYSTEM_CONFIG + int ret; + ret = gnutls_rwlock_wrlock(&system_wide_config_rwlock); + if (ret < 0) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(ret); + } + if (!system_wide_config_is_malleable()) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); + } + + if (secure) { + /* irregularity, trusting for certs means trusting in general */ + ret = cfg_sigs_add(&system_wide_config, sign); + if (ret < 0) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return ret; + } + ret = cfg_sigs_for_cert_add(&system_wide_config, sign); + } else { + ret = cfg_sigs_for_cert_remove(&system_wide_config, sign); + } + + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return ret; +#else + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); +#endif +} + +/** + * gnutls_protocol_set_enabled: + * @version: is a (gnutls) version number + * @enabled: whether to enable the protocol + * + * Control the previous system-wide setting that marked @version as + * enabled or disabled. Calling this fuction is allowed + * only if allowlisting mode is set in the configuration file, + * and only if the system-wide TLS priority string + * has not been initialized yet. + * The intended usage is to provide applications with a way + * to expressly deviate from the distribution or site defaults + * inherited from the configuration file. + * The modification is composable with further modifications + * performed through the priority string mechanism. + * + * This function is not thread-safe and is intended to be called + * in the main thread at the beginning of the process execution. + * + * Returns: 0 on success or negative error code otherwise. + * + * Since: 3.7.3 + */ +int /* allowlisting-only */ /* not thread-safe */ +gnutls_protocol_set_enabled(gnutls_protocol_t version, unsigned int enabled) +{ +#ifndef DISABLE_SYSTEM_CONFIG + int ret; + ret = gnutls_rwlock_wrlock(&system_wide_config_rwlock); + if (ret < 0) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(ret); + } + if (!system_wide_config_is_malleable()) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); + } + + if (enabled) { + ret = cfg_versions_add(&system_wide_config, version); + } else { + ret = cfg_versions_remove(&system_wide_config, version); + } + + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return ret; +#else + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); +#endif +} + +/** + * gnutls_ecc_curve_set_enabled: + * @curve: is an ECC curve + * @enabled: whether to enable the curve + * + * Modify the previous system wide setting that marked @curve as + * enabled or disabled. Calling this fuction is allowed + * only if allowlisting mode is set in the configuration file, + * and only if the system-wide TLS priority string + * has not been initialized yet. + * The intended usage is to provide applications with a way + * to expressly deviate from the distribution or site defaults + * inherited from the configuration file. + * The modification is composable with further modifications + * performed through the priority string mechanism. + * + * This function is not thread-safe and is intended to be called + * in the main thread at the beginning of the process execution. + * + * Returns: 0 on success or negative error code otherwise. + * + * Since: 3.7.3 + */ +int +gnutls_ecc_curve_set_enabled(gnutls_ecc_curve_t curve, unsigned int enabled) +{ +#ifndef DISABLE_SYSTEM_CONFIG + int ret; + ret = gnutls_rwlock_wrlock(&system_wide_config_rwlock); + if (ret < 0) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(ret); + } + if (!system_wide_config_is_malleable()) { + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); + } + + if (enabled) { + ret = cfg_ecc_curves_add(&system_wide_config, curve); + } else { + ret = cfg_ecc_curves_remove(&system_wide_config, curve); + } + + (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); + return ret; +#else + return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); +#endif +} |