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 2 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, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include "lib/events/events.h"
27 #include "lib/socket/socket.h"
30 #include "gnutls/gnutls.h"
34 #if defined(HAVE_GNUTLS_DATUM) && !defined(HAVE_GNUTLS_DATUM_T)
35 typedef gnutls_datum gnutls_datum_t
;
38 /* hold persistent tls data */
40 gnutls_certificate_credentials x509_cred
;
41 gnutls_dh_params dh_params
;
46 /* hold per connection tls data */
48 struct socket_context
*socket
;
52 gnutls_session session
;
57 const char *plain_chars
;
59 gnutls_certificate_credentials xcred
;
64 BOOL
tls_enabled(struct socket_context
*sock
)
66 struct tls_context
*tls
;
70 if (strcmp(sock
->backend_name
, "tls") != 0) {
73 tls
= talloc_get_type(sock
->private_data
, struct tls_context
);
77 return tls
->tls_enabled
;
83 static const struct socket_ops tls_socket_ops
;
85 static NTSTATUS
tls_socket_init(struct socket_context
*sock
)
88 case SOCKET_TYPE_STREAM
:
91 return NT_STATUS_INVALID_PARAMETER
;
94 sock
->backend_name
= "tls";
99 #define TLSCHECK(call) do { \
102 DEBUG(0,("TLS %s - %s\n", #call, gnutls_strerror(ret))); \
109 callback for reading from a socket
111 static ssize_t
tls_pull(gnutls_transport_ptr ptr
, void *buf
, size_t size
)
113 struct tls_context
*tls
= talloc_get_type(ptr
, struct tls_context
);
117 if (tls
->have_first_byte
) {
118 *(uint8_t *)buf
= tls
->first_byte
;
119 tls
->have_first_byte
= False
;
123 status
= socket_recv(tls
->socket
, buf
, size
, &nread
);
124 if (NT_STATUS_EQUAL(status
, NT_STATUS_END_OF_FILE
)) {
127 if (NT_STATUS_IS_ERR(status
)) {
128 EVENT_FD_NOT_READABLE(tls
->fde
);
129 EVENT_FD_NOT_WRITEABLE(tls
->fde
);
133 if (!NT_STATUS_IS_OK(status
)) {
134 EVENT_FD_READABLE(tls
->fde
);
138 if (tls
->output_pending
) {
139 EVENT_FD_WRITEABLE(tls
->fde
);
142 EVENT_FD_READABLE(tls
->fde
);
148 callback for writing to a socket
150 static ssize_t
tls_push(gnutls_transport_ptr ptr
, const void *buf
, size_t size
)
152 struct tls_context
*tls
= talloc_get_type(ptr
, struct tls_context
);
157 if (!tls
->tls_enabled
) {
161 b
.data
= discard_const(buf
);
164 status
= socket_send(tls
->socket
, &b
, &nwritten
);
165 if (NT_STATUS_EQUAL(status
, STATUS_MORE_ENTRIES
)) {
169 if (!NT_STATUS_IS_OK(status
)) {
170 EVENT_FD_WRITEABLE(tls
->fde
);
173 if (size
!= nwritten
) {
174 EVENT_FD_WRITEABLE(tls
->fde
);
180 destroy a tls session
182 static int tls_destructor(struct tls_context
*tls
)
185 ret
= gnutls_bye(tls
->session
, GNUTLS_SHUT_WR
);
187 DEBUG(0,("TLS gnutls_bye failed - %s\n", gnutls_strerror(ret
)));
194 possibly continue the handshake process
196 static NTSTATUS
tls_handshake(struct tls_context
*tls
)
200 if (tls
->done_handshake
) {
204 ret
= gnutls_handshake(tls
->session
);
205 if (ret
== GNUTLS_E_INTERRUPTED
|| ret
== GNUTLS_E_AGAIN
) {
206 if (gnutls_record_get_direction(tls
->session
) == 1) {
207 EVENT_FD_WRITEABLE(tls
->fde
);
209 return STATUS_MORE_ENTRIES
;
212 DEBUG(0,("TLS gnutls_handshake failed - %s\n", gnutls_strerror(ret
)));
213 return NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
215 tls
->done_handshake
= True
;
220 possibly continue an interrupted operation
222 static NTSTATUS
tls_interrupted(struct tls_context
*tls
)
226 if (!tls
->interrupted
) {
229 if (gnutls_record_get_direction(tls
->session
) == 1) {
230 ret
= gnutls_record_send(tls
->session
, NULL
, 0);
232 ret
= gnutls_record_recv(tls
->session
, NULL
, 0);
234 if (ret
== GNUTLS_E_INTERRUPTED
|| ret
== GNUTLS_E_AGAIN
) {
235 return STATUS_MORE_ENTRIES
;
237 tls
->interrupted
= False
;
242 see how many bytes are pending on the connection
244 static NTSTATUS
tls_socket_pending(struct socket_context
*sock
, size_t *npending
)
246 struct tls_context
*tls
= talloc_get_type(sock
->private_data
, struct tls_context
);
247 if (!tls
->tls_enabled
|| tls
->tls_detect
) {
248 return socket_pending(tls
->socket
, npending
);
250 *npending
= gnutls_record_check_pending(tls
->session
);
251 if (*npending
== 0) {
252 NTSTATUS status
= socket_pending(tls
->socket
, npending
);
253 if (*npending
== 0) {
254 /* seems to be a gnutls bug */
263 receive data either by tls or normal socket_recv
265 static NTSTATUS
tls_socket_recv(struct socket_context
*sock
, void *buf
,
266 size_t wantlen
, size_t *nread
)
270 struct tls_context
*tls
= talloc_get_type(sock
->private_data
, struct tls_context
);
272 if (tls
->tls_enabled
&& tls
->tls_detect
) {
273 status
= socket_recv(tls
->socket
, &tls
->first_byte
, 1, nread
);
274 NT_STATUS_NOT_OK_RETURN(status
);
275 if (*nread
== 0) return NT_STATUS_OK
;
276 tls
->tls_detect
= False
;
277 /* look for the first byte of a valid HTTP operation */
278 if (strchr(tls
->plain_chars
, tls
->first_byte
)) {
280 tls
->tls_enabled
= False
;
281 *(uint8_t *)buf
= tls
->first_byte
;
284 tls
->have_first_byte
= True
;
287 if (!tls
->tls_enabled
) {
288 return socket_recv(tls
->socket
, buf
, wantlen
, nread
);
291 status
= tls_handshake(tls
);
292 NT_STATUS_NOT_OK_RETURN(status
);
294 status
= tls_interrupted(tls
);
295 NT_STATUS_NOT_OK_RETURN(status
);
297 ret
= gnutls_record_recv(tls
->session
, buf
, wantlen
);
298 if (ret
== GNUTLS_E_INTERRUPTED
|| ret
== GNUTLS_E_AGAIN
) {
299 if (gnutls_record_get_direction(tls
->session
) == 1) {
300 EVENT_FD_WRITEABLE(tls
->fde
);
302 tls
->interrupted
= True
;
303 return STATUS_MORE_ENTRIES
;
306 return NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
314 send data either by tls or normal socket_recv
316 static NTSTATUS
tls_socket_send(struct socket_context
*sock
,
317 const DATA_BLOB
*blob
, size_t *sendlen
)
321 struct tls_context
*tls
= talloc_get_type(sock
->private_data
, struct tls_context
);
323 if (!tls
->tls_enabled
) {
324 return socket_send(tls
->socket
, blob
, sendlen
);
327 status
= tls_handshake(tls
);
328 NT_STATUS_NOT_OK_RETURN(status
);
330 status
= tls_interrupted(tls
);
331 NT_STATUS_NOT_OK_RETURN(status
);
333 ret
= gnutls_record_send(tls
->session
, blob
->data
, blob
->length
);
334 if (ret
== GNUTLS_E_INTERRUPTED
|| ret
== GNUTLS_E_AGAIN
) {
335 if (gnutls_record_get_direction(tls
->session
) == 1) {
336 EVENT_FD_WRITEABLE(tls
->fde
);
338 tls
->interrupted
= True
;
339 return STATUS_MORE_ENTRIES
;
342 DEBUG(0,("gnutls_record_send of %d failed - %s\n", (int)blob
->length
, gnutls_strerror(ret
)));
343 return NT_STATUS_UNEXPECTED_NETWORK_ERROR
;
346 tls
->output_pending
= (ret
< blob
->length
);
352 initialise global tls state
354 struct tls_params
*tls_initialise(TALLOC_CTX
*mem_ctx
)
356 struct tls_params
*params
;
358 TALLOC_CTX
*tmp_ctx
= talloc_new(mem_ctx
);
359 const char *keyfile
= private_path(tmp_ctx
, lp_tls_keyfile());
360 const char *certfile
= private_path(tmp_ctx
, lp_tls_certfile());
361 const char *cafile
= private_path(tmp_ctx
, lp_tls_cafile());
362 const char *crlfile
= private_path(tmp_ctx
, lp_tls_crlfile());
363 const char *dhpfile
= private_path(tmp_ctx
, lp_tls_dhpfile());
364 void tls_cert_generate(TALLOC_CTX
*, const char *, const char *, const char *);
366 params
= talloc(mem_ctx
, struct tls_params
);
367 if (params
== NULL
) {
368 talloc_free(tmp_ctx
);
372 if (!lp_tls_enabled() || keyfile
== NULL
|| *keyfile
== 0) {
373 params
->tls_enabled
= False
;
374 talloc_free(tmp_ctx
);
378 if (!file_exist(cafile
)) {
379 tls_cert_generate(params
, keyfile
, certfile
, cafile
);
382 ret
= gnutls_global_init();
383 if (ret
< 0) goto init_failed
;
385 gnutls_certificate_allocate_credentials(¶ms
->x509_cred
);
386 if (ret
< 0) goto init_failed
;
388 if (cafile
&& *cafile
) {
389 ret
= gnutls_certificate_set_x509_trust_file(params
->x509_cred
, cafile
,
390 GNUTLS_X509_FMT_PEM
);
392 DEBUG(0,("TLS failed to initialise cafile %s\n", cafile
));
397 if (crlfile
&& *crlfile
) {
398 ret
= gnutls_certificate_set_x509_crl_file(params
->x509_cred
,
400 GNUTLS_X509_FMT_PEM
);
402 DEBUG(0,("TLS failed to initialise crlfile %s\n", crlfile
));
407 ret
= gnutls_certificate_set_x509_key_file(params
->x509_cred
,
409 GNUTLS_X509_FMT_PEM
);
411 DEBUG(0,("TLS failed to initialise certfile %s and keyfile %s\n",
417 ret
= gnutls_dh_params_init(¶ms
->dh_params
);
418 if (ret
< 0) goto init_failed
;
421 gnutls_datum_t dhparms
;
423 dhparms
.data
= (uint8_t *)file_load(dhpfile
, &size
, mem_ctx
);
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
)