#include "gnutls_int.h"
#include "errors.h"
+#include "secrets.h"
#include <num.h>
#include <state.h>
#include <algorithms.h>
+#define EXPORTER_LABEL "exporter"
+
/**
* gnutls_prf_raw:
* @session: is a #gnutls_session_t type.
* Apply the TLS Pseudo-Random-Function (PRF) on the master secret
* and the provided data.
*
+ * This function only works with the TLS versions prior to 1.3. In
+ * TLS 1.3, the use of PRF is replaced with HKDF (HMAC-based Key
+ * Derivation Function) based on the multi-stage key scheduling.
+ *
* 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
* @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,
+ * Exports keyring 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 @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.
+ * 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
size_t context_size, const char *context,
size_t outsize, char *out)
{
- char *pctx = NULL;
+ const version_entry_st *vers = get_version(session);
int ret;
if (context != NULL && context_size > 65535) {
return GNUTLS_E_INVALID_REQUEST;
}
- if (context != NULL) {
- pctx = gnutls_malloc(context_size+2);
- if (!pctx) {
+ if (vers && vers->tls13_sem) {
+ uint8_t secret[MAX_HASH_SIZE];
+ uint8_t digest[MAX_HASH_SIZE];
+ unsigned digest_size = session->security_parameters.prf->output_size;
+
+ /* exporter_master_secret might not be set, when
+ * handshake is in progress */
+ if (session->internals.handshake_in_progress) {
gnutls_assert();
- return GNUTLS_E_MEMORY_ERROR;
+ return GNUTLS_E_INVALID_REQUEST;
}
- memcpy(pctx+2, context, context_size);
- _gnutls_write_uint16(context_size, (void*)pctx);
- context_size += 2;
- }
+ ret = _tls13_derive_secret(session, label, label_size, NULL, 0,
+ session->key.ap_expkey, secret);
+ if (ret < 0)
+ return gnutls_assert_val(ret);
+
+ ret = gnutls_hash_fast((gnutls_digest_algorithm_t)session->security_parameters.prf->id,
+ context, context_size, digest);
+ if (ret < 0)
+ return gnutls_assert_val(ret);
+
+ ret = _tls13_expand_secret(session, EXPORTER_LABEL, sizeof(EXPORTER_LABEL)-1,
+ digest, digest_size,
+ secret, outsize, out);
+ } else {
+ char *pctx = NULL;
- ret = gnutls_prf(session, label_size, label, 0,
- context_size, pctx, outsize, out);
+ 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);
+ }
- gnutls_free(pctx);
return ret;
}
* and the provided data, seeded with the client and server random fields.
* For the key expansion specified in RFC5705 see gnutls_prf_rfc5705().
*
+ * This function only works with the TLS versions prior to 1.3. In
+ * TLS 1.3, the use of PRF is replaced with HKDF (HMAC-based Key
+ * Derivation Function) based on the multi-stage key scheduling.
+ *
* 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
--- /dev/null
+/*
+ * Copyright (C) 2015-2017 Red Hat, Inc.
+ *
+ * This file is part of GnuTLS.
+ *
+ * GnuTLS is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuTLS 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
+ * 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 <http://www.gnu.org/licenses/>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#if !defined(__linux__) || !defined(__GNUC__)
+
+int main(int argc, char **argv)
+{
+ exit(77);
+}
+
+#else
+
+#include <string.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <gnutls/gnutls.h>
+#include <gnutls/crypto.h>
+
+#include "cert-common.h"
+#include "utils.h"
+
+static void terminate(void);
+
+/* This program tests whether the gnutls_prf() works as
+ * expected.
+ */
+
+static void server_log_func(int level, const char *str)
+{
+ fprintf(stderr, "server|<%d>| %s", level, str);
+}
+
+static void client_log_func(int level, const char *str)
+{
+ fprintf(stderr, "client|<%d>| %s", level, str);
+}
+
+/* These are global */
+static pid_t child;
+
+static const
+gnutls_datum_t hrnd = {(void*)"\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 32};
+static const
+gnutls_datum_t hsrnd = {(void*)"\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 32};
+
+int __attribute__ ((visibility ("protected")))
+gnutls_rnd(gnutls_rnd_level_t level, void *data, size_t len)
+{
+ memset(data, 0xff, len);
+
+ /* Flip the first byte to avoid infinite loop in the RSA
+ * blinding code of Nettle */
+ if (len > 0)
+ memset(data, 0x0, 1);
+ return 0;
+}
+
+static void dump(const char *name, const uint8_t *data, unsigned data_size)
+{
+ unsigned i;
+
+ fprintf(stderr, "%s", name);
+ for (i=0;i<data_size;i++)
+ fprintf(stderr, "\\x%.2x", (unsigned)data[i]);
+ fprintf(stderr, "\n");
+}
+
+#define TRY(label_size, label, extra_size, extra, size, exp) \
+ { \
+ ret = gnutls_prf_rfc5705(session, label_size, label, extra_size, extra, size, \
+ (void*)key_material); \
+ if (ret < 0) { \
+ fprintf(stderr, "gnutls_prf_rfc5705: error in %d\n", __LINE__); \
+ gnutls_perror(ret); \
+ exit(1); \
+ } \
+ if (memcmp(key_material, exp, size) != 0) { \
+ fprintf(stderr, "gnutls_prf_rfc5705: output doesn't match for '%s'\n", label); \
+ dump("got ", key_material, size); \
+ dump("expected ", exp, size); \
+ exit(1); \
+ } \
+ }
+
+static void check_prfs(gnutls_session_t session)
+{
+ unsigned char key_material[512];
+ int ret;
+
+ TRY(13, "key expansion", 0, NULL, 34, (uint8_t*)"\xb1\xc3\x5e\x95\x9f\xf7\x5f\x91\x40\x85\xd7\xe8\xe7\x87\x0f\xb3\x78\xec\xbf\x40\x22\xcb\x24\x6e\x85\x91\xa4\xda\xa0\x48\xa5\xb9\x17\x65");
+ TRY(6, "hello", 0, NULL, 31, (uint8_t*)"\x85\x18\x53\x95\xa8\x60\xa5\x75\xd9\xc3\x34\xa3\x45\xa4\x90\xf0\x9c\x3a\xe3\xcf\x9a\x56\x4c\xcc\xeb\xba\x62\x2f\x36\x68\x84");
+ TRY(7, "context", 5, "abcd\xfa", 31, (uint8_t*)"\xf4\x49\x53\xf2\x8a\xcc\x59\x52\xa2\x29\x7d\xf4\x2f\x41\x92\x27\x6f\xc5\x1f\x52\xdb\x9a\xa5\x28\x33\x90\x28\x25\x52\x9f\x03");
+ TRY(12, "null-context", 0, "", 31, (uint8_t*)"\x91\xb6\xe5\xaf\x3c\x7d\x75\x0a\x66\xe2\xd9\x3d\x57\x2c\x70\x73\x6f\xe2\x8f\x44\x5a\x22\x86\x46\x6b\xe9\x30\xc4\xf4\x0b\x7c");
+}
+
+static void client(int fd)
+{
+ gnutls_session_t session;
+ int ret;
+ gnutls_certificate_credentials_t clientx509cred;
+ const char *err;
+ /* Need to enable anonymous KX specifically. */
+
+ global_init();
+
+ if (debug) {
+ gnutls_global_set_log_function(client_log_func);
+ gnutls_global_set_log_level(4711);
+ }
+
+ gnutls_certificate_allocate_credentials(&clientx509cred);
+
+ /* Initialize TLS session
+ */
+ gnutls_init(&session, GNUTLS_CLIENT);
+
+ /* Use default priorities */
+ ret = gnutls_priority_set_direct(session,
+ "NONE:+VERS-TLS1.3:+AES-256-GCM:+AEAD:+SIGN-RSA-PSS-SHA384:+GROUP-SECP256R1",
+ &err);
+ if (ret < 0) {
+ fail("client: priority set failed (%s): %s\n",
+ gnutls_strerror(ret), err);
+ exit(1);
+ }
+
+ ret = gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE,
+ clientx509cred);
+ if (ret < 0)
+ exit(1);
+
+ gnutls_handshake_set_random(session, &hrnd);
+ gnutls_transport_set_int(session, fd);
+
+ /* Perform the TLS handshake
+ */
+ do {
+ ret = gnutls_handshake(session);
+ }
+ while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
+
+ if (ret < 0) {
+ fail("client: Handshake failed: %s\n", strerror(ret));
+ exit(1);
+ } else {
+ if (debug)
+ success("client: Handshake was completed\n");
+ }
+
+ if (debug)
+ success("client: TLS version is: %s\n",
+ gnutls_protocol_get_name
+ (gnutls_protocol_get_version(session)));
+
+ ret = gnutls_cipher_get(session);
+ if (ret != GNUTLS_CIPHER_AES_256_GCM) {
+ fprintf(stderr, "negotiated unexpected cipher: %s\n", gnutls_cipher_get_name(ret));
+ exit(1);
+ }
+
+ ret = gnutls_mac_get(session);
+ if (ret != GNUTLS_MAC_AEAD) {
+ fprintf(stderr, "negotiated unexpected mac: %s\n", gnutls_mac_get_name(ret));
+ exit(1);
+ }
+
+ check_prfs(session);
+
+ gnutls_bye(session, GNUTLS_SHUT_WR);
+
+ close(fd);
+
+ gnutls_deinit(session);
+
+ gnutls_certificate_free_credentials(clientx509cred);
+
+ gnutls_global_deinit();
+}
+
+static void terminate(void)
+{
+ int status = 0;
+
+ kill(child, SIGTERM);
+ wait(&status);
+ exit(1);
+}
+
+static void server(int fd)
+{
+ int ret;
+ gnutls_session_t session;
+ gnutls_certificate_credentials_t serverx509cred;
+
+ /* this must be called once in the program
+ */
+ global_init();
+
+ if (debug) {
+ gnutls_global_set_log_function(server_log_func);
+ gnutls_global_set_log_level(4711);
+ }
+
+ gnutls_certificate_allocate_credentials(&serverx509cred);
+
+ gnutls_init(&session, GNUTLS_SERVER);
+
+ /* avoid calling all the priority functions, since the defaults
+ * are adequate.
+ */
+ ret = gnutls_priority_set_direct(session,
+ "NORMAL:-VERS-ALL:+VERS-TLS1.3:-KX-ALL", NULL);
+ if (ret < 0) {
+ fail("server: priority set failed (%s)\n\n",
+ gnutls_strerror(ret));
+ terminate();
+ }
+
+ gnutls_certificate_set_x509_key_mem(serverx509cred,
+ &server_cert, &server_key,
+ GNUTLS_X509_FMT_PEM);
+ gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE,
+ serverx509cred);
+
+ gnutls_handshake_set_random(session, &hsrnd);
+ gnutls_transport_set_int(session, fd);
+
+ do {
+ ret = gnutls_handshake(session);
+ }
+ while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
+ if (ret < 0) {
+ close(fd);
+ gnutls_deinit(session);
+ fail("server: Handshake has failed (%s)\n\n",
+ gnutls_strerror(ret));
+ terminate();
+ }
+ if (debug)
+ success("server: Handshake was completed\n");
+
+ if (debug)
+ success("server: TLS version is: %s\n",
+ gnutls_protocol_get_name
+ (gnutls_protocol_get_version(session)));
+
+ /* do not wait for the peer to close the connection.
+ */
+ gnutls_bye(session, GNUTLS_SHUT_WR);
+
+ close(fd);
+ gnutls_deinit(session);
+
+ gnutls_certificate_free_credentials(serverx509cred);
+
+ gnutls_global_deinit();
+
+ if (debug)
+ success("server: finished\n");
+}
+
+void doit(void)
+{
+ int fd[2];
+ int ret;
+
+ signal(SIGPIPE, SIG_IGN);
+
+ ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
+ if (ret < 0) {
+ perror("socketpair");
+ exit(1);
+ }
+
+ child = fork();
+ if (child < 0) {
+ perror("fork");
+ fail("fork");
+ exit(1);
+ }
+
+ if (child) {
+ int status;
+ /* parent */
+
+ server(fd[0]);
+ wait(&status);
+ check_wait_status(status);
+ } else {
+ close(fd[0]);
+ client(fd[1]);
+ exit(0);
+ }
+}
+
+#endif /* _WIN32 */
projects / thirdparty / gnutls.git / commitdiff
