2 Unix SMB/CIFS implementation.
4 transport layer security handling code
6 Copyright (C) Andrew Tridgell 2004-2005
7 Copyright (C) Stefan Metzmacher 2004
8 Copyright (C) Andrew Bartlett 2006
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "lib/events/events.h"
26 #include "lib/socket/socket.h"
29 #include "gnutls/gnutls.h"
33 #if defined(HAVE_GNUTLS_DATUM) && !defined(HAVE_GNUTLS_DATUM_T)
34 typedef gnutls_datum gnutls_datum_t;
37 /* hold persistent tls data */
39 gnutls_certificate_credentials x509_cred;
40 gnutls_dh_params dh_params;
45 /* hold per connection tls data */
47 struct socket_context *socket;
51 gnutls_session session;
56 const char *plain_chars;
58 gnutls_certificate_credentials xcred;
63 BOOL tls_enabled(struct socket_context *sock)
65 struct tls_context *tls;
69 if (strcmp(sock->backend_name, "tls") != 0) {
72 tls = talloc_get_type(sock->private_data, struct tls_context);
76 return tls->tls_enabled;
82 static const struct socket_ops tls_socket_ops;
84 static NTSTATUS tls_socket_init(struct socket_context *sock)
87 case SOCKET_TYPE_STREAM:
90 return NT_STATUS_INVALID_PARAMETER;
93 sock->backend_name = "tls";
98 #define TLSCHECK(call) do { \
101 DEBUG(0,("TLS %s - %s\n", #call, gnutls_strerror(ret))); \
108 callback for reading from a socket
110 static ssize_t tls_pull(gnutls_transport_ptr ptr, void *buf, size_t size)
112 struct tls_context *tls = talloc_get_type(ptr, struct tls_context);
116 if (tls->have_first_byte) {
117 *(uint8_t *)buf = tls->first_byte;
118 tls->have_first_byte = False;
122 status = socket_recv(tls->socket, buf, size, &nread);
123 if (NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE)) {
126 if (NT_STATUS_IS_ERR(status)) {
127 EVENT_FD_NOT_READABLE(tls->fde);
128 EVENT_FD_NOT_WRITEABLE(tls->fde);
132 if (!NT_STATUS_IS_OK(status)) {
133 EVENT_FD_READABLE(tls->fde);
137 if (tls->output_pending) {
138 EVENT_FD_WRITEABLE(tls->fde);
141 EVENT_FD_READABLE(tls->fde);
147 callback for writing to a socket
149 static ssize_t tls_push(gnutls_transport_ptr ptr, const void *buf, size_t size)
151 struct tls_context *tls = talloc_get_type(ptr, struct tls_context);
156 if (!tls->tls_enabled) {
160 b.data = discard_const(buf);
163 status = socket_send(tls->socket, &b, &nwritten);
164 if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
168 if (!NT_STATUS_IS_OK(status)) {
169 EVENT_FD_WRITEABLE(tls->fde);
172 if (size != nwritten) {
173 EVENT_FD_WRITEABLE(tls->fde);
179 destroy a tls session
181 static int tls_destructor(struct tls_context *tls)
184 ret = gnutls_bye(tls->session, GNUTLS_SHUT_WR);
186 DEBUG(0,("TLS gnutls_bye failed - %s\n", gnutls_strerror(ret)));
193 possibly continue the handshake process
195 static NTSTATUS tls_handshake(struct tls_context *tls)
199 if (tls->done_handshake) {
203 ret = gnutls_handshake(tls->session);
204 if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
205 if (gnutls_record_get_direction(tls->session) == 1) {
206 EVENT_FD_WRITEABLE(tls->fde);
208 return STATUS_MORE_ENTRIES;
211 DEBUG(0,("TLS gnutls_handshake failed - %s\n", gnutls_strerror(ret)));
212 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
214 tls->done_handshake = True;
219 possibly continue an interrupted operation
221 static NTSTATUS tls_interrupted(struct tls_context *tls)
225 if (!tls->interrupted) {
228 if (gnutls_record_get_direction(tls->session) == 1) {
229 ret = gnutls_record_send(tls->session, NULL, 0);
231 ret = gnutls_record_recv(tls->session, NULL, 0);
233 if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
234 return STATUS_MORE_ENTRIES;
236 tls->interrupted = False;
241 see how many bytes are pending on the connection
243 static NTSTATUS tls_socket_pending(struct socket_context *sock, size_t *npending)
245 struct tls_context *tls = talloc_get_type(sock->private_data, struct tls_context);
246 if (!tls->tls_enabled || tls->tls_detect) {
247 return socket_pending(tls->socket, npending);
249 *npending = gnutls_record_check_pending(tls->session);
250 if (*npending == 0) {
251 NTSTATUS status = socket_pending(tls->socket, npending);
252 if (*npending == 0) {
253 /* seems to be a gnutls bug */
262 receive data either by tls or normal socket_recv
264 static NTSTATUS tls_socket_recv(struct socket_context *sock, void *buf,
265 size_t wantlen, size_t *nread)
269 struct tls_context *tls = talloc_get_type(sock->private_data, struct tls_context);
271 if (tls->tls_enabled && tls->tls_detect) {
272 status = socket_recv(tls->socket, &tls->first_byte, 1, nread);
273 NT_STATUS_NOT_OK_RETURN(status);
274 if (*nread == 0) return NT_STATUS_OK;
275 tls->tls_detect = False;
276 /* look for the first byte of a valid HTTP operation */
277 if (strchr(tls->plain_chars, tls->first_byte)) {
279 tls->tls_enabled = False;
280 *(uint8_t *)buf = tls->first_byte;
283 tls->have_first_byte = True;
286 if (!tls->tls_enabled) {
287 return socket_recv(tls->socket, buf, wantlen, nread);
290 status = tls_handshake(tls);
291 NT_STATUS_NOT_OK_RETURN(status);
293 status = tls_interrupted(tls);
294 NT_STATUS_NOT_OK_RETURN(status);
296 ret = gnutls_record_recv(tls->session, buf, wantlen);
297 if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
298 if (gnutls_record_get_direction(tls->session) == 1) {
299 EVENT_FD_WRITEABLE(tls->fde);
301 tls->interrupted = True;
302 return STATUS_MORE_ENTRIES;
305 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
313 send data either by tls or normal socket_recv
315 static NTSTATUS tls_socket_send(struct socket_context *sock,
316 const DATA_BLOB *blob, size_t *sendlen)
320 struct tls_context *tls = talloc_get_type(sock->private_data, struct tls_context);
322 if (!tls->tls_enabled) {
323 return socket_send(tls->socket, blob, sendlen);
326 status = tls_handshake(tls);
327 NT_STATUS_NOT_OK_RETURN(status);
329 status = tls_interrupted(tls);
330 NT_STATUS_NOT_OK_RETURN(status);
332 ret = gnutls_record_send(tls->session, blob->data, blob->length);
333 if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) {
334 if (gnutls_record_get_direction(tls->session) == 1) {
335 EVENT_FD_WRITEABLE(tls->fde);
337 tls->interrupted = True;
338 return STATUS_MORE_ENTRIES;
341 DEBUG(0,("gnutls_record_send of %d failed - %s\n", (int)blob->length, gnutls_strerror(ret)));
342 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
345 tls->output_pending = (ret < blob->length);
351 initialise global tls state
353 struct tls_params *tls_initialise(TALLOC_CTX *mem_ctx)
355 struct tls_params *params;
357 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
358 const char *keyfile = private_path(tmp_ctx, lp_tls_keyfile());
359 const char *certfile = private_path(tmp_ctx, lp_tls_certfile());
360 const char *cafile = private_path(tmp_ctx, lp_tls_cafile());
361 const char *crlfile = private_path(tmp_ctx, lp_tls_crlfile());
362 const char *dhpfile = private_path(tmp_ctx, lp_tls_dhpfile());
363 void tls_cert_generate(TALLOC_CTX *, const char *, const char *, const char *);
365 params = talloc(mem_ctx, struct tls_params);
366 if (params == NULL) {
367 talloc_free(tmp_ctx);
371 if (!lp_tls_enabled() || keyfile == NULL || *keyfile == 0) {
372 params->tls_enabled = False;
373 talloc_free(tmp_ctx);
377 if (!file_exist(cafile)) {
378 tls_cert_generate(params, keyfile, certfile, cafile);
381 ret = gnutls_global_init();
382 if (ret < 0) goto init_failed;
384 gnutls_certificate_allocate_credentials(¶ms->x509_cred);
385 if (ret < 0) goto init_failed;
387 if (cafile && *cafile) {
388 ret = gnutls_certificate_set_x509_trust_file(params->x509_cred, cafile,
389 GNUTLS_X509_FMT_PEM);
391 DEBUG(0,("TLS failed to initialise cafile %s\n", cafile));
396 if (crlfile && *crlfile) {
397 ret = gnutls_certificate_set_x509_crl_file(params->x509_cred,
399 GNUTLS_X509_FMT_PEM);
401 DEBUG(0,("TLS failed to initialise crlfile %s\n", crlfile));
406 ret = gnutls_certificate_set_x509_key_file(params->x509_cred,
408 GNUTLS_X509_FMT_PEM);
410 DEBUG(0,("TLS failed to initialise certfile %s and keyfile %s\n",
416 ret = gnutls_dh_params_init(¶ms->dh_params);
417 if (ret < 0) goto init_failed;
419 if (dhpfile && *dhpfile) {
420 gnutls_datum_t dhparms;
422 dhparms.data = (uint8_t *)file_load(dhpfile, &size, mem_ctx);
425 DEBUG(0,("Failed to read DH Parms from %s\n", dhpfile));
430 ret = gnutls_dh_params_import_pkcs3(params->dh_params, &dhparms, GNUTLS_X509_FMT_PEM);
431 if (ret < 0) goto init_failed;
433 ret = gnutls_dh_params_generate2(params->dh_params, DH_BITS);
434 if (ret < 0) goto init_failed;
437 gnutls_certificate_set_dh_params(params->x509_cred, params->dh_params);
439 params->tls_enabled = True;
441 talloc_free(tmp_ctx);
445 DEBUG(0,("GNUTLS failed to initialise - %s\n", gnutls_strerror(ret)));
446 params->tls_enabled = False;
447 talloc_free(tmp_ctx);
453 setup for a new connection
455 struct socket_context *tls_init_server(struct tls_params *params,
456 struct socket_context *socket,
457 struct fd_event *fde,
458 const char *plain_chars)
460 struct tls_context *tls;
462 struct socket_context *new_sock;
465 nt_status = socket_create_with_ops(socket, &tls_socket_ops, &new_sock,
467 socket->flags | SOCKET_FLAG_ENCRYPT);
468 if (!NT_STATUS_IS_OK(nt_status)) {
472 tls = talloc(new_sock, struct tls_context);
477 tls->socket = socket;
479 if (talloc_reference(tls, fde) == NULL) {
480 talloc_free(new_sock);
483 if (talloc_reference(tls, socket) == NULL) {
484 talloc_free(new_sock);
488 new_sock->private_data = tls;
490 if (!params->tls_enabled) {
491 talloc_free(new_sock);
495 TLSCHECK(gnutls_init(&tls->session, GNUTLS_SERVER));
497 talloc_set_destructor(tls, tls_destructor);
499 TLSCHECK(gnutls_set_default_priority(tls->session));
500 TLSCHECK(gnutls_credentials_set(tls->session, GNUTLS_CRD_CERTIFICATE,
502 gnutls_certificate_server_set_request(tls->session, GNUTLS_CERT_REQUEST);
503 gnutls_dh_set_prime_bits(tls->session, DH_BITS);
504 gnutls_transport_set_ptr(tls->session, (gnutls_transport_ptr)tls);
505 gnutls_transport_set_pull_function(tls->session, (gnutls_pull_func)tls_pull);
506 gnutls_transport_set_push_function(tls->session, (gnutls_push_func)tls_push);
507 gnutls_transport_set_lowat(tls->session, 0);
509 tls->plain_chars = plain_chars;
511 tls->tls_detect = True;
513 tls->tls_detect = False;
516 tls->output_pending = False;
517 tls->done_handshake = False;
518 tls->have_first_byte = False;
519 tls->tls_enabled = True;
520 tls->interrupted = False;
522 new_sock->state = SOCKET_STATE_SERVER_CONNECTED;
527 DEBUG(0,("TLS init connection failed - %s\n", gnutls_strerror(ret)));
528 talloc_free(new_sock);
534 setup for a new client connection
536 struct socket_context *tls_init_client(struct socket_context *socket,
537 struct fd_event *fde)
539 struct tls_context *tls;
541 const int cert_type_priority[] = { GNUTLS_CRT_X509, GNUTLS_CRT_OPENPGP, 0 };
543 struct socket_context *new_sock;
546 nt_status = socket_create_with_ops(socket, &tls_socket_ops, &new_sock,
548 socket->flags | SOCKET_FLAG_ENCRYPT);
549 if (!NT_STATUS_IS_OK(nt_status)) {
553 tls = talloc(new_sock, struct tls_context);
554 if (tls == NULL) return NULL;
556 tls->socket = socket;
558 if (talloc_reference(tls, fde) == NULL) {
561 if (talloc_reference(tls, socket) == NULL) {
564 new_sock->private_data = tls;
566 cafile = private_path(tls, lp_tls_cafile());
567 if (!cafile || !*cafile) {
571 gnutls_global_init();
573 gnutls_certificate_allocate_credentials(&tls->xcred);
574 gnutls_certificate_set_x509_trust_file(tls->xcred, cafile, GNUTLS_X509_FMT_PEM);
576 TLSCHECK(gnutls_init(&tls->session, GNUTLS_CLIENT));
577 TLSCHECK(gnutls_set_default_priority(tls->session));
578 gnutls_certificate_type_set_priority(tls->session, cert_type_priority);
579 TLSCHECK(gnutls_credentials_set(tls->session, GNUTLS_CRD_CERTIFICATE, tls->xcred));
581 talloc_set_destructor(tls, tls_destructor);
583 gnutls_transport_set_ptr(tls->session, (gnutls_transport_ptr)tls);
584 gnutls_transport_set_pull_function(tls->session, (gnutls_pull_func)tls_pull);
585 gnutls_transport_set_push_function(tls->session, (gnutls_push_func)tls_push);
586 gnutls_transport_set_lowat(tls->session, 0);
587 tls->tls_detect = False;
589 tls->output_pending = False;
590 tls->done_handshake = False;
591 tls->have_first_byte = False;
592 tls->tls_enabled = True;
593 tls->interrupted = False;
595 new_sock->state = SOCKET_STATE_CLIENT_CONNECTED;
600 DEBUG(0,("TLS init connection failed - %s\n", gnutls_strerror(ret)));
601 tls->tls_enabled = False;
605 static NTSTATUS tls_socket_set_option(struct socket_context *sock, const char *option, const char *val)
607 set_socket_options(socket_get_fd(sock), option);
611 static char *tls_socket_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
613 struct tls_context *tls = talloc_get_type(sock->private_data, struct tls_context);
614 return socket_get_peer_name(tls->socket, mem_ctx);
617 static struct socket_address *tls_socket_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
619 struct tls_context *tls = talloc_get_type(sock->private_data, struct tls_context);
620 return socket_get_peer_addr(tls->socket, mem_ctx);
623 static struct socket_address *tls_socket_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
625 struct tls_context *tls = talloc_get_type(sock->private_data, struct tls_context);
626 return socket_get_my_addr(tls->socket, mem_ctx);
629 static int tls_socket_get_fd(struct socket_context *sock)
631 struct tls_context *tls = talloc_get_type(sock->private_data, struct tls_context);
632 return socket_get_fd(tls->socket);
635 static const struct socket_ops tls_socket_ops = {
637 .fn_init = tls_socket_init,
638 .fn_recv = tls_socket_recv,
639 .fn_send = tls_socket_send,
640 .fn_pending = tls_socket_pending,
642 .fn_set_option = tls_socket_set_option,
644 .fn_get_peer_name = tls_socket_get_peer_name,
645 .fn_get_peer_addr = tls_socket_get_peer_addr,
646 .fn_get_my_addr = tls_socket_get_my_addr,
647 .fn_get_fd = tls_socket_get_fd
650 BOOL tls_support(struct tls_params *params)
652 return params->tls_enabled;
657 /* for systems without tls we just fail the operations, and the caller
658 * will retain the original socket */
660 struct tls_params *tls_initialise(TALLOC_CTX *mem_ctx)
662 return talloc_new(mem_ctx);
666 setup for a new connection
668 struct socket_context *tls_init_server(struct tls_params *params,
669 struct socket_context *socket,
670 struct fd_event *fde,
671 const char *plain_chars)
678 setup for a new client connection
680 struct socket_context *tls_init_client(struct socket_context *socket,
681 struct fd_event *fde)
686 BOOL tls_support(struct tls_params *params)