From: Thierry Quemerais Date: Thu, 19 Mar 2015 19:40:25 +0000 (+0100) Subject: Added a way to add custom supplemental data from public API. X-Git-Tag: gnutls_3_4_0~164 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=c16a06a2a35e4d0ca489c477e2acf210f3c9dbfc;p=thirdparty%2Fgnutls.git Added a way to add custom supplemental data from public API. Signed-off-by: Thierry Quemerais --- diff --git a/lib/gnutls_supplemental.c b/lib/gnutls_supplemental.c index e515273e74..4d61fabe5b 100644 --- a/lib/gnutls_supplemental.c +++ b/lib/gnutls_supplemental.c @@ -43,16 +43,12 @@ * want to send any data, it is fine to return without doing anything. */ +#include #include "gnutls_int.h" #include "gnutls_supplemental.h" #include "gnutls_errors.h" #include "gnutls_num.h" -typedef int (*supp_recv_func) (gnutls_session_t session, - const uint8_t * data, size_t data_size); -typedef int (*supp_send_func) (gnutls_session_t session, - gnutls_buffer_st * buf); - typedef struct { const char *name; gnutls_supplemental_data_format_type_t type; @@ -60,9 +56,8 @@ typedef struct { supp_send_func supp_send_func; } gnutls_supplemental_entry; -gnutls_supplemental_entry _gnutls_supplemental[] = { - {0, 0, 0, 0} -}; +static size_t suppfunc_size = 0; +static gnutls_supplemental_entry *suppfunc = NULL; /** * gnutls_supplemental_get_name: @@ -78,11 +73,12 @@ const char *gnutls_supplemental_get_name(gnutls_supplemental_data_format_type_t type) { - gnutls_supplemental_entry *p; + size_t i; - for (p = _gnutls_supplemental; p->name != NULL; p++) - if (p->type == type) - return p->name; + for (i = 0; i < suppfunc_size; i++) { + if (suppfunc[i].type == type) + return suppfunc[i].name; + } return NULL; } @@ -90,11 +86,12 @@ const char static supp_recv_func get_supp_func_recv(gnutls_supplemental_data_format_type_t type) { - gnutls_supplemental_entry *p; + size_t i; - for (p = _gnutls_supplemental; p->name != NULL; p++) - if (p->type == type) - return p->supp_recv_func; + for (i = 0; i < suppfunc_size; i++) { + if (suppfunc[i].type == type) + return suppfunc[i].supp_recv_func; + } return NULL; } @@ -102,6 +99,7 @@ get_supp_func_recv(gnutls_supplemental_data_format_type_t type) int _gnutls_gen_supplemental(gnutls_session_t session, gnutls_buffer_st * buf) { + size_t i; gnutls_supplemental_entry *p; int ret; @@ -112,7 +110,8 @@ _gnutls_gen_supplemental(gnutls_session_t session, gnutls_buffer_st * buf) return ret; } - for (p = _gnutls_supplemental; p->name; p++) { + for (i = 0; i < suppfunc_size; i++) { + p = &suppfunc[i]; supp_send_func supp_send = p->supp_send_func; size_t sizepos = buf->length; @@ -205,3 +204,49 @@ _gnutls_parse_supplemental(gnutls_session_t session, return 0; } + +int +_gnutls_supplemental_register(gnutls_supplemental_entry *entry) +{ + gnutls_supplemental_entry *p; + + 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; +} + +int +gnutls_supplemental_register(const char *name, gnutls_supplemental_data_format_type_t type, supp_recv_func recv_func, supp_send_func send_func) +{ + gnutls_supplemental_entry tmp_entry; + + tmp_entry.name = name; + tmp_entry.type = type; + tmp_entry.supp_recv_func = recv_func; + tmp_entry.supp_send_func = send_func; + + return _gnutls_supplemental_register(&tmp_entry); +} + +void +gnutls_do_recv_supplemental(gnutls_session_t session, int do_recv_supplemental) +{ + session->security_parameters.do_recv_supplemental = do_recv_supplemental; +} + +void +gnutls_do_send_supplemental(gnutls_session_t session, int do_send_supplemental) +{ + session->security_parameters.do_send_supplemental = do_send_supplemental; +} diff --git a/lib/includes/gnutls/gnutls.h.in b/lib/includes/gnutls/gnutls.h.in index 14eccc72b8..1385836448 100644 --- a/lib/includes/gnutls/gnutls.h.in +++ b/lib/includes/gnutls/gnutls.h.in @@ -1057,9 +1057,7 @@ unsigned gnutls_session_etm_status(gnutls_session_t session); * * Enumeration of different supplemental data types (RFC 4680). */ -typedef enum { - GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0 -} gnutls_supplemental_data_format_type_t; +typedef int gnutls_supplemental_data_format_type_t; const char *gnutls_supplemental_get_name(gnutls_supplemental_data_format_type_t type); @@ -2275,6 +2273,21 @@ int gnutls_ext_register(const char *name, int type, gnutls_ext_parse_type_t pars gnutls_ext_deinit_data_func deinit_func, gnutls_ext_pack_func pack_func, gnutls_ext_unpack_func unpack_func, gnutls_ext_epoch_func epoch_func); +/* Public supplemental data related functions */ + +typedef int (*supp_recv_func) (gnutls_session_t session, + const unsigned char * data, size_t data_size); +typedef int (*supp_send_func) (gnutls_session_t session, + gnutls_buffer_st * buf); + +int gnutls_supplemental_register(const char *name, + gnutls_supplemental_data_format_type_t type, + supp_recv_func supp_recv_func, supp_send_func supp_send_func); + +void gnutls_do_recv_supplemental(gnutls_session_t session, int do_recv_supplemental); + +void gnutls_do_send_supplemental(gnutls_session_t session, int do_send_supplemental); + /* FIPS140-2 related functions */ int gnutls_fips140_mode_enabled(void); diff --git a/lib/libgnutls.map b/lib/libgnutls.map index 3baf1c04f0..0b6b44bedd 100644 --- a/lib/libgnutls.map +++ b/lib/libgnutls.map @@ -1021,6 +1021,9 @@ GNUTLS_3_4 gnutls_crypto_register_digest; gnutls_ext_register; gnutls_buffer_append_data; + gnutls_supplemental_register; + gnutls_do_recv_supplemental; + gnutls_do_send_supplemental; local: *; }; diff --git a/tests/Makefile.am b/tests/Makefile.am index 69e944d62e..eeb17699d9 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -89,7 +89,7 @@ ctests = mini-record-2 simple gc set_pkcs12_cred certder certuniqueid \ mini-chain-unsorted x509-verify-with-crl mini-dtls-mtu \ mini-dtls-record-asym openpgp-callback key-import-export \ mini-dtls-fork mini-dtls-pthread mini-key-material x509cert-invalid \ - strict-der mini-extension + strict-der mini-extension mini-supplementaldata mini_dtls_pthread_LDADD = $(LDADD) -lpthread diff --git a/tests/mini-supplementaldata.c b/tests/mini-supplementaldata.c new file mode 100644 index 0000000000..0945c1b31e --- /dev/null +++ b/tests/mini-supplementaldata.c @@ -0,0 +1,320 @@ +/* + * Copyright (C) 2004-2012 Free Software Foundation, Inc. + * + * Author: Thierry Quemerais + * + * 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 General Public License + * along with GnuTLS; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +/* Parts copied from GnuTLS example programs. */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include + +#if defined(_WIN32) + +/* socketpair isn't supported on Win32. */ +int main(int argc, char **argv) +{ + exit(77); +} + +#else + +#include +#include +#include +#if !defined(_WIN32) +#include +#endif +#include +#include + +#include "utils.h" + +/* A very basic TLS client, with supplemental data + */ + +const char *side = ""; + +static void tls_log_func(int level, const char *str) +{ + fprintf(stderr, "%s|<%d>| %s", side, level, str); +} + +#define TLS_SUPPLEMENTALDATATYPE_SAMPLE 0xBABE + +static int TLS_SUPPLEMENTALDATA_client_sent = 0; +static int TLS_SUPPLEMENTALDATA_client_received = 0; +static int TLS_SUPPLEMENTALDATA_server_sent = 0; +static int TLS_SUPPLEMENTALDATA_server_received = 0; + +static const unsigned char supp_data[] = +{ + 0xFE, + 0xED +}; + +int supp_client_recv_func(gnutls_session_t session, const unsigned char *buf, size_t buflen) +{ + TLS_SUPPLEMENTALDATA_client_received = 1; + + if (buflen != sizeof(supp_data)) + fail("supp_client_recv_func: Invalid input buffer len\n"); + + if (memcmp(buf, supp_data, sizeof(supp_data)) != 0) + fail("supp_client_recv_func: Invalid input buffer data\n"); + + return GNUTLS_E_SUCCESS; +} + +int supp_client_send_func(gnutls_session_t session, gnutls_buffer_st * buf) +{ + TLS_SUPPLEMENTALDATA_client_sent = 1; + gnutls_buffer_append_data(buf, supp_data, sizeof(supp_data)); + return GNUTLS_E_SUCCESS; +} + +int supp_server_recv_func(gnutls_session_t session, const unsigned char *buf, size_t buflen) +{ + TLS_SUPPLEMENTALDATA_server_received = 1; + + if (buflen != sizeof(supp_data)) + fail("supp_server_recv_func: Invalid input buffer len\n"); + + if (memcmp(buf, supp_data, sizeof(supp_data)) != 0) + fail("supp_server_recv_func: Invalid input buffer data\n"); + + return GNUTLS_E_SUCCESS; +} + +int supp_server_send_func(gnutls_session_t session, gnutls_buffer_st * buf) +{ + TLS_SUPPLEMENTALDATA_server_sent = 1; + gnutls_buffer_append_data(buf, supp_data, sizeof(supp_data)); + return GNUTLS_E_SUCCESS; +} + +static void client(int sd) +{ + int ret; + gnutls_session_t session; + gnutls_certificate_credentials_t clientx509cred; + + global_init(); + gnutls_global_set_log_function(tls_log_func); + if (debug) + gnutls_global_set_log_level(4711); + + side = "client"; + + gnutls_certificate_allocate_credentials(&clientx509cred); + + /* Initialize TLS session + */ + gnutls_init(&session, GNUTLS_CLIENT); + + /* Use default priorities */ + gnutls_priority_set_direct(session, "PERFORMANCE:+ANON-ECDH:+ANON-DH", + NULL); + + /* put the anonymous credentials to the current session + */ + gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, + clientx509cred); + + gnutls_transport_set_int(session, sd); + + gnutls_do_recv_supplemental(session, 1); + gnutls_do_send_supplemental(session, 1); + + gnutls_supplemental_register("supplemental_client", TLS_SUPPLEMENTALDATATYPE_SAMPLE, supp_client_recv_func, supp_client_send_func); + + /* Perform the TLS handshake + */ + ret = gnutls_handshake(session); + + if (ret < 0) { + fail("client: Handshake failed\n"); + gnutls_perror(ret); + goto end; + } else { + if (debug) + success("client: Handshake was completed\n"); + } + + if (TLS_SUPPLEMENTALDATA_client_sent != 1 || TLS_SUPPLEMENTALDATA_client_received != 1) + fail("client: extension not properly sent/received\n"); + + gnutls_bye(session, GNUTLS_SHUT_RDWR); + +end: + close(sd); + + gnutls_deinit(session); + + gnutls_certificate_free_credentials(clientx509cred); + + gnutls_global_deinit(); +} + +/* This is a sample TLS 1.0 server, for extension + */ + +static unsigned char server_cert_pem[] = + "-----BEGIN CERTIFICATE-----\n" + "MIICVjCCAcGgAwIBAgIERiYdMTALBgkqhkiG9w0BAQUwGTEXMBUGA1UEAxMOR251\n" + "VExTIHRlc3QgQ0EwHhcNMDcwNDE4MTMyOTIxWhcNMDgwNDE3MTMyOTIxWjA3MRsw\n" + "GQYDVQQKExJHbnVUTFMgdGVzdCBzZXJ2ZXIxGDAWBgNVBAMTD3Rlc3QuZ251dGxz\n" + "Lm9yZzCBnDALBgkqhkiG9w0BAQEDgYwAMIGIAoGA17pcr6MM8C6pJ1aqU46o63+B\n" + "dUxrmL5K6rce+EvDasTaDQC46kwTHzYWk95y78akXrJutsoKiFV1kJbtple8DDt2\n" + "DZcevensf9Op7PuFZKBroEjOd35znDET/z3IrqVgbtm2jFqab7a+n2q9p/CgMyf1\n" + "tx2S5Zacc1LWn9bIjrECAwEAAaOBkzCBkDAMBgNVHRMBAf8EAjAAMBoGA1UdEQQT\n" + "MBGCD3Rlc3QuZ251dGxzLm9yZzATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHQ8B\n" + "Af8EBQMDB6AAMB0GA1UdDgQWBBTrx0Vu5fglyoyNgw106YbU3VW0dTAfBgNVHSME\n" + "GDAWgBTpPBz7rZJu5gakViyi4cBTJ8jylTALBgkqhkiG9w0BAQUDgYEAaFEPTt+7\n" + "bzvBuOf7+QmeQcn29kT6Bsyh1RHJXf8KTk5QRfwp6ogbp94JQWcNQ/S7YDFHglD1\n" + "AwUNBRXwd3riUsMnsxgeSDxYBfJYbDLeohNBsqaPDJb7XailWbMQKfAbFQ8cnOxg\n" + "rOKLUQRWJ0K3HyXRMhbqjdLIaQiCvQLuizo=\n" "-----END CERTIFICATE-----\n"; + +const gnutls_datum_t server_cert = { server_cert_pem, + sizeof(server_cert_pem) +}; + +static unsigned char server_key_pem[] = + "-----BEGIN RSA PRIVATE KEY-----\n" + "MIICXAIBAAKBgQDXulyvowzwLqknVqpTjqjrf4F1TGuYvkrqtx74S8NqxNoNALjq\n" + "TBMfNhaT3nLvxqResm62ygqIVXWQlu2mV7wMO3YNlx696ex/06ns+4VkoGugSM53\n" + "fnOcMRP/PciupWBu2baMWppvtr6far2n8KAzJ/W3HZLllpxzUtaf1siOsQIDAQAB\n" + "AoGAYAFyKkAYC/PYF8e7+X+tsVCHXppp8AoP8TEZuUqOZz/AArVlle/ROrypg5kl\n" + "8YunrvUdzH9R/KZ7saNZlAPLjZyFG9beL/am6Ai7q7Ma5HMqjGU8kTEGwD7K+lbG\n" + "iomokKMOl+kkbY/2sI5Czmbm+/PqLXOjtVc5RAsdbgvtmvkCQQDdV5QuU8jap8Hs\n" + "Eodv/tLJ2z4+SKCV2k/7FXSKWe0vlrq0cl2qZfoTUYRnKRBcWxc9o92DxK44wgPi\n" + "oMQS+O7fAkEA+YG+K9e60sj1K4NYbMPAbYILbZxORDecvP8lcphvwkOVUqbmxOGh\n" + "XRmTZUuhBrJhJKKf6u7gf3KWlPl6ShKEbwJASC118cF6nurTjuLf7YKARDjNTEws\n" + "qZEeQbdWYINAmCMj0RH2P0mvybrsXSOD5UoDAyO7aWuqkHGcCLv6FGG+qwJAOVqq\n" + "tXdUucl6GjOKKw5geIvRRrQMhb/m5scb+5iw8A4LEEHPgGiBaF5NtJZLALgWfo5n\n" + "hmC8+G8F0F78znQtPwJBANexu+Tg5KfOnzSILJMo3oXiXhf5PqXIDmbN0BKyCKAQ\n" + "LfkcEcUbVfmDaHpvzwY9VEaoMOKVLitETXdNSxVpvWM=\n" + "-----END RSA PRIVATE KEY-----\n"; + +const gnutls_datum_t server_key = { server_key_pem, + sizeof(server_key_pem) +}; + +int err, ret; +char topbuf[512]; +gnutls_session_t session; +int optval = 1; + +static void server(int sd) +{ + gnutls_certificate_credentials_t serverx509cred; + + /* this must be called once in the program + */ + global_init(); + gnutls_global_set_log_function(tls_log_func); + if (debug) + gnutls_global_set_log_level(4711); + + side = "server"; + + gnutls_certificate_allocate_credentials(&serverx509cred); + gnutls_certificate_set_x509_key_mem(serverx509cred, + &server_cert, &server_key, + GNUTLS_X509_FMT_PEM); + + gnutls_init(&session, GNUTLS_SERVER); + + /* avoid calling all the priority functions, since the defaults + * are adequate. + */ + gnutls_priority_set_direct(session, "PERFORMANCE:+ANON-ECDH:+ANON-DH", + NULL); + + gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, + serverx509cred); + + gnutls_do_recv_supplemental(session, 1); + gnutls_do_send_supplemental(session, 1); + + gnutls_supplemental_register("supplemental_server", TLS_SUPPLEMENTALDATATYPE_SAMPLE, supp_server_recv_func, supp_server_send_func); + + gnutls_transport_set_int(session, sd); + ret = gnutls_handshake(session); + if (ret < 0) { + close(sd); + gnutls_deinit(session); + fail("server: Handshake has failed (%s)\n\n", + gnutls_strerror(ret)); + return; + } + if (debug) + success("server: Handshake was completed\n"); + + if (TLS_SUPPLEMENTALDATA_server_sent != 1 || TLS_SUPPLEMENTALDATA_server_received != 1) + fail("server: extension not properly sent/received\n"); + + /* do not wait for the peer to close the connection. + */ + gnutls_bye(session, GNUTLS_SHUT_WR); + + close(sd); + gnutls_deinit(session); + + gnutls_certificate_free_credentials(serverx509cred); + + gnutls_global_deinit(); + + if (debug) + success("server: finished\n"); +} + +void doit(void) +{ + pid_t child; + int sockets[2]; + + err = socketpair(AF_UNIX, SOCK_STREAM, 0, sockets); + if (err == -1) { + perror("socketpair"); + fail("socketpair failed\n"); + return; + } + + child = fork(); + if (child < 0) { + perror("fork"); + fail("fork"); + return; + } + + if (child) { + int status; + /* parent */ + server(sockets[0]); + wait(&status); + } else + client(sockets[1]); +} + +#endif /* _WIN32 */