/*

 * Copyright (C) 2007-2012 Free Software Foundation, Inc.

 *

 * Author: Simon Josefsson

 *

 * 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/>

 *

 */

/* This file contains support functions for 'TLS Handshake Message for

 * Supplemental Data' (RFC 4680).

 *

 * The idea here is simple.  gnutls_handshake() in gnuts_handshake.c

 * will call _gnutls_gen_supplemental and _gnutls_parse_supplemental

 * when some extension requested that supplemental data be sent or

 * received.  Extension request this by setting the flags

 * do_recv_supplemental or do_send_supplemental in the session.

 *

 * The functions in this file iterate through the _gnutls_supplemental

 * array, and calls the send/recv functions for each respective data

 * type.

 *

 * The receive function of each data type is responsible for decoding

 * its own data.  If the extension did not expect to receive

 * supplemental data, it should return GNUTLS_E_UNEXPECTED_PACKET.

 * Otherwise, it just parse the data as normal.

 *

 * The send function needs to append the 2-byte data format type, and

 * append the 2-byte length of its data, and the data.  If it doesn't

 * want to send any data, it is fine to return without doing anything.

 */

#include "gnutls_int.h"

#include <gnutls/gnutls.h>

#include "supplemental.h"

#include "errors.h"

#include "num.h"

typedef struct gnutls_supplemental_entry_st {

	char *name;

	gnutls_supplemental_data_format_type_t type;

	gnutls_supp_recv_func supp_recv_func;

	gnutls_supp_send_func supp_send_func;

} gnutls_supplemental_entry_st;

static size_t suppfunc_size = 0;

static gnutls_supplemental_entry_st *suppfunc = NULL;

/**

 * gnutls_supplemental_get_name:

 * @type: is a supplemental data format type

 *

 * Convert a #gnutls_supplemental_data_format_type_t value to a

 * string.

 *

 * Returns: a string that contains the name of the specified

 *   supplemental data format type, or %NULL for unknown types.

 **/

const char

    *gnutls_supplemental_get_name(gnutls_supplemental_data_format_type_t

				  type)

{

	size_t i;

	for (i = 0; i < suppfunc_size; i++) {

		if (suppfunc[i].type == type)

			return suppfunc[i].name;

	}

	return NULL;

}

void _gnutls_supplemental_deinit(void)

{

	unsigned i;

	for (i = 0; i < suppfunc_size; i++) {

		gnutls_free(suppfunc[i].name);

	}

	gnutls_free(suppfunc);

	suppfunc = NULL;

	suppfunc_size = 0;

}

static gnutls_supp_recv_func

get_supp_func_recv(gnutls_session_t session, gnutls_supplemental_data_format_type_t type)

{

	size_t i;

	for (i = 0; i < session->internals.rsup_size; i++) {

		if (session->internals.rsup[i].type == type)

			return session->internals.rsup[i].supp_recv_func;

	}

	for (i = 0; i < suppfunc_size; i++) {

		if (suppfunc[i].type == type)

			return suppfunc[i].supp_recv_func;

	}

	return NULL;

}

static int gen_supplemental(gnutls_session_t session, const gnutls_supplemental_entry_st *supp,

			    gnutls_buffer_st * buf)

{

	int ret;

	gnutls_supp_send_func supp_send = supp->supp_send_func;

	size_t sizepos = buf->length;

	/* Make room for supplement type and length byte length field. */

	ret = _gnutls_buffer_append_data(buf, "\0\0\0\0", 4);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	ret = supp_send(session, buf);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	/* If data were added, store type+length, otherwise reset. */

	if (buf->length > sizepos + 4) {

		buf->data[sizepos] = (supp->type >> 8) & 0xFF;

		buf->data[sizepos + 1] = supp->type & 0xFF;

		buf->data[sizepos + 2] =

		    ((buf->length - sizepos - 4) >> 8) & 0xFF;

		buf->data[sizepos + 3] =

		    (buf->length - sizepos - 4) & 0xFF;

	} else

		buf->length -= 4;

	return 0;

}

int

_gnutls_gen_supplemental(gnutls_session_t session, gnutls_buffer_st * buf)

{

	size_t i;

	int ret;

	unsigned init_pos = buf->length;

	/* Make room for 3 byte length field. */

	ret = _gnutls_buffer_append_data(buf, "\0\0\0", 3);

	if (ret < 0) {

		gnutls_assert();

		return ret;

	}

	for (i = 0; i < session->internals.rsup_size; i++) {

		ret = gen_supplemental(session, &session->internals.rsup[i], buf);

		if (ret < 0)

			return gnutls_assert_val(ret);

	}

	for (i = 0; i < suppfunc_size; i++) {

		ret = gen_supplemental(session, &suppfunc[i], buf);

		if (ret < 0)

			return gnutls_assert_val(ret);

	}

	i = buf->length - init_pos - 3;

	buf->data[init_pos] = (i >> 16) & 0xFF;

	buf->data[init_pos+1] = (i >> 8) & 0xFF;

	buf->data[init_pos+2] = i & 0xFF;

	_gnutls_debug_log

	    ("EXT[%p]: Sending %d bytes of supplemental data\n", session,

	     (int) buf->length);

	return buf->length - init_pos;

}

int

_gnutls_parse_supplemental(gnutls_session_t session,

			   const uint8_t * data, int datalen)

{

	const uint8_t *p = data;

	size_t dsize = datalen;

	size_t total_size;

	DECR_LEN(dsize, 3);

	total_size = _gnutls_read_uint24(p);

	p += 3;

	if (dsize != total_size) {

		gnutls_assert();

		return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;

	}

	do {

		uint16_t supp_data_type;

		uint16_t supp_data_length;

		gnutls_supp_recv_func recv_func;

		DECR_LEN(dsize, 2);

		supp_data_type = _gnutls_read_uint16(p);

		p += 2;

		DECR_LEN(dsize, 2);

		supp_data_length = _gnutls_read_uint16(p);

		p += 2;

		_gnutls_debug_log

		    ("EXT[%p]: Got supplemental type=%02x length=%d\n",

		     session, supp_data_type, supp_data_length);

		recv_func = get_supp_func_recv(session, supp_data_type);

		if (recv_func) {

			int ret = recv_func(session, p, supp_data_length);

			if (ret < 0) {

				gnutls_assert();

				return ret;

			}

		} else {

			gnutls_assert();

			return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;

		}

		DECR_LEN(dsize, supp_data_length);

		p += supp_data_length;

	}

	while (dsize > 0);

	return 0;

}

static int

_gnutls_supplemental_register(gnutls_supplemental_entry_st *entry)

{

	gnutls_supplemental_entry_st *p;

	unsigned i;

	for (i = 0; i < suppfunc_size; i++) {

		if (entry->type == suppfunc[i].type)

			return gnutls_assert_val(GNUTLS_E_ALREADY_REGISTERED);

	}

	p = gnutls_realloc_fast(suppfunc,

				sizeof(*suppfunc) * (suppfunc_size + 1));

	if (!p) {

		gnutls_assert();

		return GNUTLS_E_MEMORY_ERROR;

	}

	suppfunc = p;

	memcpy(&suppfunc[suppfunc_size], entry, sizeof(*entry));

	suppfunc_size++;

	return GNUTLS_E_SUCCESS;

}

/**

 * gnutls_supplemental_register:

 * @name: the name of the supplemental data to register

 * @type: the type of the supplemental data format

 * @recv_func: the function to receive the data

 * @send_func: the function to send the data

 *

 * This function will register a new supplemental data type (rfc4680).

 * The registered data will remain until gnutls_global_deinit()

 * is called. The provided @type must be an unassigned type in

 * %gnutls_supplemental_data_format_type_t. If the type is already

 * registered or handled by GnuTLS internally %GNUTLS_E_ALREADY_REGISTERED

 * will be returned.

 *

 * This function is not thread safe. As supplemental data are not defined under

 * TLS 1.3, this function will disable TLS 1.3 support globally.

 *

 * Returns: %GNUTLS_E_SUCCESS on success, otherwise a negative error code.

 *

 * Since: 3.4.0

 **/

int

gnutls_supplemental_register(const char *name, gnutls_supplemental_data_format_type_t type,

			     gnutls_supp_recv_func recv_func, gnutls_supp_send_func send_func)

{

	gnutls_supplemental_entry_st tmp_entry;

	int ret;

	tmp_entry.name = gnutls_strdup(name);

	tmp_entry.type = type;

	tmp_entry.supp_recv_func = recv_func;

	tmp_entry.supp_send_func = send_func;

	ret = _gnutls_supplemental_register(&tmp_entry);

	if (ret < 0) {

		gnutls_free(tmp_entry.name);

	}

	_gnutls_disable_tls13 = 1;

	return ret;

}

/**

 * gnutls_session_supplemental_register:

 * @session: the session for which this will be registered

 * @name: the name of the supplemental data to register

 * @type: the type of the supplemental data format

 * @recv_func: the function to receive the data

 * @send_func: the function to send the data

 * @flags: must be zero

 *

 * This function will register a new supplemental data type (rfc4680).

 * The registered supplemental functions will be used for that specific

 * session. The provided @type must be an unassigned type in

 * %gnutls_supplemental_data_format_type_t.

 *

 * If the type is already registered or handled by GnuTLS internally

 * %GNUTLS_E_ALREADY_REGISTERED will be returned.

 *

 * As supplemental data are not defined under TLS 1.3, this function will

 * disable TLS 1.3 support for the given session.

 *

 * Returns: %GNUTLS_E_SUCCESS on success, otherwise a negative error code.

 *

 * Since: 3.5.5

 **/

int

gnutls_session_supplemental_register(gnutls_session_t session, const char *name,

				     gnutls_supplemental_data_format_type_t type,

				     gnutls_supp_recv_func recv_func,

				     gnutls_supp_send_func send_func,

				     unsigned flags)

{

	gnutls_supplemental_entry_st tmp_entry;

	gnutls_supplemental_entry_st *p;

	unsigned i;

	tmp_entry.name = NULL;

	tmp_entry.type = type;

	tmp_entry.supp_recv_func = recv_func;

	tmp_entry.supp_send_func = send_func;

	for (i = 0; i < suppfunc_size; i++) {

		if (type == suppfunc[i].type)

			return gnutls_assert_val(GNUTLS_E_ALREADY_REGISTERED);

	}

	p = gnutls_realloc(session->internals.rsup,

			   sizeof(gnutls_supplemental_entry_st)*(session->internals.rsup_size + 1));

	if (!p)

		return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);

	session->internals.rsup = p;

	memcpy(&session->internals.rsup[session->internals.rsup_size], &tmp_entry, sizeof(tmp_entry));

	session->internals.rsup_size++;

	session->internals.flags |= INT_FLAG_NO_TLS13;

	return GNUTLS_E_SUCCESS;

}

/**

 * gnutls_supplemental_recv:

 * @session: is a #gnutls_session_t type.

 * @do_recv_supplemental: non-zero in order to expect supplemental data

 *

 * This function is to be called by an extension handler to

 * instruct gnutls to attempt to receive supplemental data

 * during the handshake process.

 *

 * Since: 3.4.0

 **/

void

gnutls_supplemental_recv(gnutls_session_t session, unsigned do_recv_supplemental)

{

	session->security_parameters.do_recv_supplemental = do_recv_supplemental;

}

/**

 * gnutls_supplemental_send:

 * @session: is a #gnutls_session_t type.

 * @do_send_supplemental: non-zero in order to send supplemental data

 *

 * This function is to be called by an extension handler to

 * instruct gnutls to send supplemental data during the handshake process.

 *

 * Since: 3.4.0

 **/

void

gnutls_supplemental_send(gnutls_session_t session, unsigned do_send_supplemental)

{

	session->security_parameters.do_send_supplemental = do_send_supplemental;

}