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