[thirdparty/systemd.git] / src / resolve / resolved-dnstls-gnutls.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#if !ENABLE_DNS_OVER_TLS || !DNS_OVER_TLS_USE_GNUTLS
#error This source file requires DNS-over-TLS to be enabled and GnuTLS to be available.
#endif

#include <gnutls/socket.h>

#include "resolved-dns-stream.h"
#include "resolved-dnstls.h"

#if GNUTLS_VERSION_NUMBER >= 0x030600
#define PRIORTY_STRING "NORMAL:-VERS-ALL:+VERS-TLS1.2:+VERS-TLS1.3"
#else
#define PRIORTY_STRING "NORMAL:-VERS-ALL:+VERS-TLS1.2"
#endif
DEFINE_TRIVIAL_CLEANUP_FUNC(gnutls_session_t, gnutls_deinit);

static ssize_t dnstls_stream_writev(gnutls_transport_ptr_t p, const giovec_t *iov, int iovcnt) {
        int r;

        assert(p);

        r = dns_stream_writev((DnsStream*) p, (const struct iovec*) iov, iovcnt, DNS_STREAM_WRITE_TLS_DATA);
        if (r < 0) {
                errno = -r;
                return -1;
        }

        return r;
}

int dnstls_stream_connect_tls(DnsStream *stream, DnsServer *server) {
        _cleanup_(gnutls_deinitp) gnutls_session_t gs;
        int r;

        assert(stream);
        assert(server);

        r = gnutls_init(&gs, GNUTLS_CLIENT | GNUTLS_ENABLE_FALSE_START | GNUTLS_NONBLOCK);
        if (r < 0)
                return r;

        /* As DNS-over-TLS is a recent protocol, older TLS versions can be disabled */
        r = gnutls_priority_set_direct(gs, PRIORTY_STRING, NULL);
        if (r < 0)
                return r;

        r = gnutls_credentials_set(gs, GNUTLS_CRD_CERTIFICATE, stream->manager->dnstls_data.cert_cred);
        if (r < 0)
                return r;

        if (server->dnstls_data.session_data.size > 0) {
                gnutls_session_set_data(gs, server->dnstls_data.session_data.data, server->dnstls_data.session_data.size);

                // Clear old session ticket
                gnutls_free(server->dnstls_data.session_data.data);
                server->dnstls_data.session_data.data = NULL;
                server->dnstls_data.session_data.size = 0;
        }

        if (server->manager->dns_over_tls_mode == DNS_OVER_TLS_YES)
                gnutls_session_set_verify_cert(gs, NULL, 0);

        gnutls_handshake_set_timeout(gs, GNUTLS_DEFAULT_HANDSHAKE_TIMEOUT);

        gnutls_transport_set_ptr2(gs, (gnutls_transport_ptr_t) (long) stream->fd, stream);
        gnutls_transport_set_vec_push_function(gs, &dnstls_stream_writev);

        stream->encrypted = true;
        stream->dnstls_data.handshake = gnutls_handshake(gs);
        if (stream->dnstls_data.handshake < 0 && gnutls_error_is_fatal(stream->dnstls_data.handshake))
                return -ECONNREFUSED;

        stream->dnstls_data.session = TAKE_PTR(gs);

        return 0;
}

void dnstls_stream_free(DnsStream *stream) {
        assert(stream);
        assert(stream->encrypted);

        if (stream->dnstls_data.session)
                gnutls_deinit(stream->dnstls_data.session);
}

int dnstls_stream_on_io(DnsStream *stream, uint32_t revents) {
        int r;

        assert(stream);
        assert(stream->encrypted);
        assert(stream->dnstls_data.session);

        if (stream->dnstls_data.shutdown) {
                r = gnutls_bye(stream->dnstls_data.session, GNUTLS_SHUT_RDWR);
                if (r == GNUTLS_E_AGAIN) {
                        stream->dnstls_events = gnutls_record_get_direction(stream->dnstls_data.session) == 1 ? EPOLLOUT : EPOLLIN;
                        return -EAGAIN;
                } else if (r < 0)
                        log_debug("Failed to invoke gnutls_bye: %s", gnutls_strerror(r));

                stream->dnstls_events = 0;
                stream->dnstls_data.shutdown = false;
                dns_stream_unref(stream);
                return DNSTLS_STREAM_CLOSED;
        } else if (stream->dnstls_data.handshake < 0) {
                stream->dnstls_data.handshake = gnutls_handshake(stream->dnstls_data.session);
                if (stream->dnstls_data.handshake == GNUTLS_E_AGAIN) {
                        stream->dnstls_events = gnutls_record_get_direction(stream->dnstls_data.session) == 1 ? EPOLLOUT : EPOLLIN;
                        return -EAGAIN;
                } else if (stream->dnstls_data.handshake < 0) {
                        log_debug("Failed to invoke gnutls_handshake: %s", gnutls_strerror(stream->dnstls_data.handshake));
                        if (gnutls_error_is_fatal(stream->dnstls_data.handshake))
                                return -ECONNREFUSED;
                }

                stream->dnstls_events = 0;
        }

        return 0;
}

int dnstls_stream_shutdown(DnsStream *stream, int error) {
        int r;

        assert(stream);
        assert(stream->encrypted);
        assert(stream->dnstls_data.session);

        /* Store TLS Ticket for faster successive TLS handshakes */
        if (stream->server && stream->server->dnstls_data.session_data.size == 0 && stream->dnstls_data.handshake == GNUTLS_E_SUCCESS)
                gnutls_session_get_data2(stream->dnstls_data.session, &stream->server->dnstls_data.session_data);

        if (IN_SET(error, ETIMEDOUT, 0)) {
                r = gnutls_bye(stream->dnstls_data.session, GNUTLS_SHUT_RDWR);
                if (r == GNUTLS_E_AGAIN) {
                        if (!stream->dnstls_data.shutdown) {
                                stream->dnstls_data.shutdown = true;
                                dns_stream_ref(stream);
                                return -EAGAIN;
                        }
                } else if (r < 0)
                        log_debug("Failed to invoke gnutls_bye: %s", gnutls_strerror(r));
        }

        return 0;
}

ssize_t dnstls_stream_write(DnsStream *stream, const char *buf, size_t count) {
        ssize_t ss;

        assert(stream);
        assert(stream->encrypted);
        assert(stream->dnstls_data.session);
        assert(buf);

        ss = gnutls_record_send(stream->dnstls_data.session, buf, count);
        if (ss < 0)
                switch(ss) {
                case GNUTLS_E_INTERRUPTED:
                        return -EINTR;
                case GNUTLS_E_AGAIN:
                        return -EAGAIN;
                default:
                        return log_debug_errno(SYNTHETIC_ERRNO(EPIPE),
                                               "Failed to invoke gnutls_record_send: %s",
                                               gnutls_strerror(ss));
                }

        return ss;
}

ssize_t dnstls_stream_read(DnsStream *stream, void *buf, size_t count) {
        ssize_t ss;

        assert(stream);
        assert(stream->encrypted);
        assert(stream->dnstls_data.session);
        assert(buf);

        ss = gnutls_record_recv(stream->dnstls_data.session, buf, count);
        if (ss < 0)
                switch(ss) {
                case GNUTLS_E_INTERRUPTED:
                        return -EINTR;
                case GNUTLS_E_AGAIN:
                        return -EAGAIN;
                default:
                        return log_debug_errno(SYNTHETIC_ERRNO(EPIPE),
                                               "Failed to invoke gnutls_record_recv: %s",
                                               gnutls_strerror(ss));
                }

        return ss;
}

void dnstls_server_free(DnsServer *server) {
        assert(server);

        if (server->dnstls_data.session_data.data)
                gnutls_free(server->dnstls_data.session_data.data);
}

int dnstls_manager_init(Manager *manager) {
        int r;
        assert(manager);

        r = gnutls_certificate_allocate_credentials(&manager->dnstls_data.cert_cred);
        if (r < 0)
                return -ENOMEM;

        r = gnutls_certificate_set_x509_system_trust(manager->dnstls_data.cert_cred);
        if (r < 0)
                log_warning("Failed to load system trust store: %s", gnutls_strerror(r));

        return 0;
}

void dnstls_manager_free(Manager *manager) {
        assert(manager);

        if (manager->dnstls_data.cert_cred)
                gnutls_certificate_free_credentials(manager->dnstls_data.cert_cred);
}
Commit	Line	Data
6016fcb0 IT	1	/* SPDX-License-Identifier: LGPL-2.1+ */
6016fcb0 IT	2
096cbdce	3	#if !ENABLE_DNS_OVER_TLS \|\| !DNS_OVER_TLS_USE_GNUTLS
6016fcb0 IT	4	#error This source file requires DNS-over-TLS to be enabled and GnuTLS to be available.
	5	#endif
	6
6016fcb0 IT	7	#include <gnutls/socket.h>
6016fcb0 IT	8
72938b93 YW	9	#include "resolved-dns-stream.h"
	10	#include "resolved-dnstls.h"
	11
9c0624dc IT	12	#if GNUTLS_VERSION_NUMBER >= 0x030600
	13	#define PRIORTY_STRING "NORMAL:-VERS-ALL:+VERS-TLS1.2:+VERS-TLS1.3"
	14	#else
	15	#define PRIORTY_STRING "NORMAL:-VERS-ALL:+VERS-TLS1.2"
	16	#endif
6016fcb0 IT	17	DEFINE_TRIVIAL_CLEANUP_FUNC(gnutls_session_t, gnutls_deinit);
	18
	19	static ssize_t dnstls_stream_writev(gnutls_transport_ptr_t p, const giovec_t *iov, int iovcnt) {
	20	int r;
	21
	22	assert(p);
	23
	24	r = dns_stream_writev((DnsStream) p, (const struct iovec) iov, iovcnt, DNS_STREAM_WRITE_TLS_DATA);
	25	if (r < 0) {
	26	errno = -r;
	27	return -1;
	28	}
	29
	30	return r;
	31	}
	32
	33	int dnstls_stream_connect_tls(DnsStream stream, DnsServer server) {
	34	_cleanup_(gnutls_deinitp) gnutls_session_t gs;
	35	int r;
	36
	37	assert(stream);
	38	assert(server);
	39
	40	r = gnutls_init(&gs, GNUTLS_CLIENT \| GNUTLS_ENABLE_FALSE_START \| GNUTLS_NONBLOCK);
	41	if (r < 0)
	42	return r;
	43
	44	/* As DNS-over-TLS is a recent protocol, older TLS versions can be disabled */
9c0624dc	45	r = gnutls_priority_set_direct(gs, PRIORTY_STRING, NULL);
6016fcb0 IT	46	if (r < 0)
	47	return r;
	48
e22c5b20	49	r = gnutls_credentials_set(gs, GNUTLS_CRD_CERTIFICATE, stream->manager->dnstls_data.cert_cred);
6016fcb0 IT	50	if (r < 0)
	51	return r;
	52
	53	if (server->dnstls_data.session_data.size > 0) {
	54	gnutls_session_set_data(gs, server->dnstls_data.session_data.data, server->dnstls_data.session_data.size);
	55
	56	// Clear old session ticket
	57	gnutls_free(server->dnstls_data.session_data.data);
	58	server->dnstls_data.session_data.data = NULL;
	59	server->dnstls_data.session_data.size = 0;
	60	}
	61
4310bfc2 IT	62	if (server->manager->dns_over_tls_mode == DNS_OVER_TLS_YES)
	63	gnutls_session_set_verify_cert(gs, NULL, 0);
	64
6016fcb0 IT	65	gnutls_handshake_set_timeout(gs, GNUTLS_DEFAULT_HANDSHAKE_TIMEOUT);
	66
	67	gnutls_transport_set_ptr2(gs, (gnutls_transport_ptr_t) (long) stream->fd, stream);
	68	gnutls_transport_set_vec_push_function(gs, &dnstls_stream_writev);
	69
	70	stream->encrypted = true;
	71	stream->dnstls_data.handshake = gnutls_handshake(gs);
	72	if (stream->dnstls_data.handshake < 0 && gnutls_error_is_fatal(stream->dnstls_data.handshake))
	73	return -ECONNREFUSED;
	74
	75	stream->dnstls_data.session = TAKE_PTR(gs);
	76
	77	return 0;
	78	}
	79
	80	void dnstls_stream_free(DnsStream *stream) {
	81	assert(stream);
	82	assert(stream->encrypted);
	83
	84	if (stream->dnstls_data.session)
	85	gnutls_deinit(stream->dnstls_data.session);
	86	}
	87
04c4d919	88	int dnstls_stream_on_io(DnsStream *stream, uint32_t revents) {
6016fcb0 IT	89	int r;
	90
	91	assert(stream);
	92	assert(stream->encrypted);
	93	assert(stream->dnstls_data.session);
	94
	95	if (stream->dnstls_data.shutdown) {
	96	r = gnutls_bye(stream->dnstls_data.session, GNUTLS_SHUT_RDWR);
ba6aaf57 IT	97	if (r == GNUTLS_E_AGAIN) {
ba6aaf57 IT	98	stream->dnstls_events = gnutls_record_get_direction(stream->dnstls_data.session) == 1 ? EPOLLOUT : EPOLLIN;
6016fcb0	99	return -EAGAIN;
ba6aaf57	100	} else if (r < 0)
6016fcb0 IT	101	log_debug("Failed to invoke gnutls_bye: %s", gnutls_strerror(r));
6016fcb0 IT	102
ba6aaf57	103	stream->dnstls_events = 0;
6016fcb0 IT	104	stream->dnstls_data.shutdown = false;
	105	dns_stream_unref(stream);
	106	return DNSTLS_STREAM_CLOSED;
	107	} else if (stream->dnstls_data.handshake < 0) {
	108	stream->dnstls_data.handshake = gnutls_handshake(stream->dnstls_data.session);
ba6aaf57 IT	109	if (stream->dnstls_data.handshake == GNUTLS_E_AGAIN) {
ba6aaf57 IT	110	stream->dnstls_events = gnutls_record_get_direction(stream->dnstls_data.session) == 1 ? EPOLLOUT : EPOLLIN;
6016fcb0	111	return -EAGAIN;
ba6aaf57	112	} else if (stream->dnstls_data.handshake < 0) {
6016fcb0 IT	113	log_debug("Failed to invoke gnutls_handshake: %s", gnutls_strerror(stream->dnstls_data.handshake));
	114	if (gnutls_error_is_fatal(stream->dnstls_data.handshake))
	115	return -ECONNREFUSED;
	116	}
ba6aaf57 IT	117
ba6aaf57 IT	118	stream->dnstls_events = 0;
6016fcb0 IT	119	}
	120
	121	return 0;
	122	}
	123
	124	int dnstls_stream_shutdown(DnsStream *stream, int error) {
	125	int r;
	126
	127	assert(stream);
	128	assert(stream->encrypted);
	129	assert(stream->dnstls_data.session);
	130
5238e957	131	/* Store TLS Ticket for faster successive TLS handshakes */
6016fcb0 IT	132	if (stream->server && stream->server->dnstls_data.session_data.size == 0 && stream->dnstls_data.handshake == GNUTLS_E_SUCCESS)
	133	gnutls_session_get_data2(stream->dnstls_data.session, &stream->server->dnstls_data.session_data);
	134
	135	if (IN_SET(error, ETIMEDOUT, 0)) {
	136	r = gnutls_bye(stream->dnstls_data.session, GNUTLS_SHUT_RDWR);
	137	if (r == GNUTLS_E_AGAIN) {
	138	if (!stream->dnstls_data.shutdown) {
	139	stream->dnstls_data.shutdown = true;
	140	dns_stream_ref(stream);
	141	return -EAGAIN;
	142	}
	143	} else if (r < 0)
	144	log_debug("Failed to invoke gnutls_bye: %s", gnutls_strerror(r));
	145	}
	146
	147	return 0;
	148	}
	149
	150	ssize_t dnstls_stream_write(DnsStream stream, const char buf, size_t count) {
	151	ssize_t ss;
	152
	153	assert(stream);
	154	assert(stream->encrypted);
	155	assert(stream->dnstls_data.session);
	156	assert(buf);
	157
	158	ss = gnutls_record_send(stream->dnstls_data.session, buf, count);
	159	if (ss < 0)
	160	switch(ss) {
	161	case GNUTLS_E_INTERRUPTED:
	162	return -EINTR;
	163	case GNUTLS_E_AGAIN:
	164	return -EAGAIN;
	165	default:
baaa35ad ZJS	166	return log_debug_errno(SYNTHETIC_ERRNO(EPIPE),
	167	"Failed to invoke gnutls_record_send: %s",
	168	gnutls_strerror(ss));
6016fcb0 IT	169	}
	170
	171	return ss;
	172	}
	173
	174	ssize_t dnstls_stream_read(DnsStream stream, void buf, size_t count) {
	175	ssize_t ss;
	176
	177	assert(stream);
	178	assert(stream->encrypted);
	179	assert(stream->dnstls_data.session);
	180	assert(buf);
	181
	182	ss = gnutls_record_recv(stream->dnstls_data.session, buf, count);
	183	if (ss < 0)
	184	switch(ss) {
	185	case GNUTLS_E_INTERRUPTED:
	186	return -EINTR;
	187	case GNUTLS_E_AGAIN:
	188	return -EAGAIN;
	189	default:
baaa35ad ZJS	190	return log_debug_errno(SYNTHETIC_ERRNO(EPIPE),
	191	"Failed to invoke gnutls_record_recv: %s",
	192	gnutls_strerror(ss));
6016fcb0 IT	193	}
	194
	195	return ss;
	196	}
	197
e22c5b20	198	void dnstls_server_free(DnsServer *server) {
6016fcb0 IT	199	assert(server);
6016fcb0 IT	200
e22c5b20 IT	201	if (server->dnstls_data.session_data.data)
e22c5b20 IT	202	gnutls_free(server->dnstls_data.session_data.data);
6016fcb0 IT	203	}
6016fcb0 IT	204
71a681ae	205	int dnstls_manager_init(Manager *manager) {
e22c5b20 IT	206	int r;
e22c5b20 IT	207	assert(manager);
6016fcb0	208
71a681ae	209	r = gnutls_certificate_allocate_credentials(&manager->dnstls_data.cert_cred);
e22c5b20	210	if (r < 0)
71a681ae IT	211	return -ENOMEM;
71a681ae IT	212
4310bfc2 IT	213	r = gnutls_certificate_set_x509_system_trust(manager->dnstls_data.cert_cred);
	214	if (r < 0)
	215	log_warning("Failed to load system trust store: %s", gnutls_strerror(r));
	216
71a681ae	217	return 0;
e22c5b20	218	}
6016fcb0	219
e22c5b20 IT	220	void dnstls_manager_free(Manager *manager) {
	221	assert(manager);
	222
	223	if (manager->dnstls_data.cert_cred)
	224	gnutls_certificate_free_credentials(manager->dnstls_data.cert_cred);
6016fcb0	225	}