/*

 * 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 "profiles.h"

#include "name_val_array.h"

#define MAX_ELEMENTS 64

#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);

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[] = {

	GNUTLS_KX_VKO_GOST_12,

	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_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[] = {

	GNUTLS_SIGN_GOST_256,

	GNUTLS_SIGN_GOST_512,

	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[] = {

	GNUTLS_CIPHER_GOST28147_TC26Z_CNT,

	0

};

static const int *cipher_priority_gost = _cipher_priority_gost;

static const int _mac_priority_gost[] = {

	GNUTLS_MAC_GOST28147_TC26Z_IMIT,

	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) {

		/* when PFS is explicitly requested, disable session tickets */

		session->internals.flags |= GNUTLS_NO_TICKETS;

	}

	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"

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;

};

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 = 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;

			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;