/*
 * Copyright (C) 2002-2015 Free Software Foundation, Inc.
 * Copyright (C) 2014-2015 Nikos Mavrogiannopoulos
 * Copyright (C) 2016-2017 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/>
 *
 */

/* Functions for the TLS PRF handling.
 */

#include "gnutls_int.h"
#include "errors.h"
#include "handshake.h"
#include "secrets.h"
#include "num.h"
#include "state.h"
#include "algorithms.h"

/**
 * gnutls_prf_raw:
 * @session: is a #gnutls_session_t type.
 * @label_size: length of the @label variable.
 * @label: label used in PRF computation, typically a short string.
 * @seed_size: length of the @seed variable.
 * @seed: optional extra data to seed the PRF with.
 * @outsize: size of pre-allocated output buffer to hold the output.
 * @out: pre-allocated buffer to hold the generated data.
 *
 * Apply the TLS Pseudo-Random-Function (PRF) on the master secret
 * and the provided data.
 *
 * The @label variable usually contains a string denoting the purpose
 * for the generated data.  The @seed usually contains data such as the
 * client and server random, perhaps together with some additional
 * data that is added to guarantee uniqueness of the output for a
 * particular purpose.
 *
 * Because the output is not guaranteed to be unique for a particular
 * session unless @seed includes the client random and server random
 * fields (the PRF would output the same data on another connection
 * resumed from the first one), it is not recommended to use this
 * function directly.  The gnutls_prf() function seeds the PRF with the
 * client and server random fields directly, and is recommended if you
 * want to generate pseudo random data unique for each session.
 *
 * Note: This function will only operate under TLS versions prior to 1.3.
 * In TLS1.3 the use of PRF is replaced with HKDF and the generic
 * exporters like gnutls_prf_rfc5705() should be used instead. Under
 * TLS1.3 this function returns %GNUTLS_E_INVALID_REQUEST.
 *
 * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
 **/
int gnutls_prf_raw(gnutls_session_t session, size_t label_size,
		   const char *label, size_t seed_size, const char *seed,
		   size_t outsize, char *out)
{
	int ret;
	const version_entry_st *vers = get_version(session);

	if (vers && vers->tls13_sem)
		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	if (session->security_parameters.prf == NULL)
		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	ret = _gnutls_prf_raw(session->security_parameters.prf->id,
			      GNUTLS_MASTER_SIZE,
			      session->security_parameters.master_secret,
			      label_size, label, seed_size, (uint8_t *)seed,
			      outsize, out);

	return ret;
}

static int _tls13_derive_exporter(const mac_entry_st *prf,
				  gnutls_session_t session, size_t label_size,
				  const char *label, size_t context_size,
				  const char *context, size_t outsize,
				  char *out, bool early)
{
	uint8_t secret[MAX_HASH_SIZE];
	uint8_t digest[MAX_HASH_SIZE];
	unsigned digest_size = prf->output_size;
	int ret;

	ret = _tls13_derive_secret2(prf, label, label_size, NULL, 0,
				    session->key.proto.tls13.ap_expkey, secret);
	if (ret < 0)
		return gnutls_assert_val(ret);

	ret = gnutls_hash_fast((gnutls_digest_algorithm_t)prf->id, context,
			       context_size, digest);
	if (ret < 0)
		return gnutls_assert_val(ret);

	return _tls13_expand_secret2(prf, EXPORTER_LABEL,
				     sizeof(EXPORTER_LABEL) - 1, digest,
				     digest_size, secret, outsize, out);
}

/**
 * gnutls_prf_rfc5705:
 * @session: is a #gnutls_session_t type.
 * @label_size: length of the @label variable.
 * @label: label used in PRF computation, typically a short string.
 * @context_size: length of the @extra variable.
 * @context: optional extra data to seed the PRF with.
 * @outsize: size of pre-allocated output buffer to hold the output.
 * @out: pre-allocated buffer to hold the generated data.
 *
 * Exports keying material from TLS/DTLS session to an application, as
 * specified in RFC5705.
 *
 * In the TLS versions prior to 1.3, it applies the TLS
 * Pseudo-Random-Function (PRF) on the master secret and the provided
 * data, seeded with the client and server random fields.
 *
 * In TLS 1.3, it applies HKDF on the exporter master secret derived
 * from the master secret.
 *
 * The @label variable usually contains a string denoting the purpose
 * for the generated data.
 *
 * The @context variable can be used to add more data to the seed, after
 * the random variables.  It can be used to make sure the
 * generated output is strongly connected to some additional data
 * (e.g., a string used in user authentication). 
 *
 * The output is placed in @out, which must be pre-allocated.
 *
 * Note that, to provide the RFC5705 context, the @context variable
 * must be non-null.
 *
 * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
 *
 * Since: 3.4.4
 **/
int gnutls_prf_rfc5705(gnutls_session_t session, size_t label_size,
		       const char *label, size_t context_size,
		       const char *context, size_t outsize, char *out)
{
	const version_entry_st *vers = get_version(session);
	int ret;

	if (session->security_parameters.prf == NULL)
		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	if (vers && vers->tls13_sem) {
		ret = _tls13_derive_exporter(session->security_parameters.prf,
					     session, label_size, label,
					     context_size, context, outsize,
					     out, 0);
	} else {
		char *pctx = NULL;

		if (context != NULL && context_size > 65535) {
			gnutls_assert();
			return GNUTLS_E_INVALID_REQUEST;
		}

		if (context != NULL) {
			pctx = gnutls_malloc(context_size + 2);
			if (!pctx) {
				gnutls_assert();
				return GNUTLS_E_MEMORY_ERROR;
			}

			memcpy(pctx + 2, context, context_size);
			_gnutls_write_uint16(context_size, (void *)pctx);
			context_size += 2;
		}

		ret = gnutls_prf(session, label_size, label, 0, context_size,
				 pctx, outsize, out);

		gnutls_free(pctx);
	}

	return ret;
}

/**
 * gnutls_prf_early:
 * @session: is a #gnutls_session_t type.
 * @label_size: length of the @label variable.
 * @label: label used in PRF computation, typically a short string.
 * @context_size: length of the @extra variable.
 * @context: optional extra data to seed the PRF with.
 * @outsize: size of pre-allocated output buffer to hold the output.
 * @out: pre-allocated buffer to hold the generated data.
 *
 * This function is similar to gnutls_prf_rfc5705(), but only works in
 * TLS 1.3 or later to export early keying material.
 *
 * Note that the keying material is only available after the
 * ClientHello message is processed and before the application traffic
 * keys are established.  Therefore this function shall be called in a
 * handshake hook function for %GNUTLS_HANDSHAKE_CLIENT_HELLO.
 *
 * The @label variable usually contains a string denoting the purpose
 * for the generated data.
 *
 * The @context variable can be used to add more data to the seed, after
 * the random variables.  It can be used to make sure the
 * generated output is strongly connected to some additional data
 * (e.g., a string used in user authentication).
 *
 * The output is placed in @out, which must be pre-allocated.
 *
 * Note that, to provide the RFC5705 context, the @context variable
 * must be non-null.
 *
 * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
 *
 * Since: 3.6.8
 **/
int gnutls_prf_early(gnutls_session_t session, size_t label_size,
		     const char *label, size_t context_size,
		     const char *context, size_t outsize, char *out)
{
	if (session->internals.initial_negotiation_completed ||
	    session->key.binders[0].prf == NULL)
		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	return _tls13_derive_exporter(session->key.binders[0].prf, session,
				      label_size, label, context_size, context,
				      outsize, out, 1);
}

/**
 * gnutls_prf:
 * @session: is a #gnutls_session_t type.
 * @label_size: length of the @label variable.
 * @label: label used in PRF computation, typically a short string.
 * @server_random_first: non-zero if server random field should be first in seed
 * @extra_size: length of the @extra variable.
 * @extra: optional extra data to seed the PRF with.
 * @outsize: size of pre-allocated output buffer to hold the output.
 * @out: pre-allocated buffer to hold the generated data.
 *
 * Applies the TLS Pseudo-Random-Function (PRF) on the master secret
 * and the provided data, seeded with the client and server random fields.
 * For the key expansion specified in RFC5705 see gnutls_prf_rfc5705().
 *
 * The @label variable usually contains a string denoting the purpose
 * for the generated data.  The @server_random_first indicates whether
 * the client random field or the server random field should be first
 * in the seed.  Non-zero indicates that the server random field is first,
 * 0 that the client random field is first.
 *
 * The @extra variable can be used to add more data to the seed, after
 * the random variables.  It can be used to make sure the
 * generated output is strongly connected to some additional data
 * (e.g., a string used in user authentication).
 *
 * The output is placed in @out, which must be pre-allocated.
 *
 * Note: This function produces identical output with gnutls_prf_rfc5705()
 * when @server_random_first is set to 0 and @extra is %NULL. Under TLS1.3
 * this function will only operate when these conditions are true, or otherwise
 * return %GNUTLS_E_INVALID_REQUEST.
 *
 * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
 **/
int gnutls_prf(gnutls_session_t session, size_t label_size, const char *label,
	       int server_random_first, size_t extra_size, const char *extra,
	       size_t outsize, char *out)
{
	int ret;
	uint8_t *seed;
	const version_entry_st *vers = get_version(session);
	size_t seedsize = 2 * GNUTLS_RANDOM_SIZE + extra_size;

	if (vers && vers->tls13_sem) {
		if (extra == NULL && server_random_first == 0)
			return gnutls_prf_rfc5705(session, label_size, label,
						  extra_size, extra, outsize,
						  out);
		else
			return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
	}

	if (session->security_parameters.prf == NULL)
		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);

	seed = gnutls_malloc(seedsize);
	if (!seed) {
		gnutls_assert();
		return GNUTLS_E_MEMORY_ERROR;
	}

	memcpy(seed,
	       server_random_first ?
		       session->security_parameters.server_random :
		       session->security_parameters.client_random,
	       GNUTLS_RANDOM_SIZE);
	memcpy(seed + GNUTLS_RANDOM_SIZE,
	       server_random_first ?
		       session->security_parameters.client_random :
		       session->security_parameters.server_random,
	       GNUTLS_RANDOM_SIZE);

	if (extra && extra_size) {
		memcpy(seed + 2 * GNUTLS_RANDOM_SIZE, extra, extra_size);
	}

	ret = _gnutls_prf_raw(session->security_parameters.prf->id,
			      GNUTLS_MASTER_SIZE,
			      session->security_parameters.master_secret,
			      label_size, label, seedsize, seed, outsize, out);

	gnutls_free(seed);

	return ret;
}