1 /* -*- Mode: C; c-file-style: "bsd" -*- */
3 * easy-tls.c -- generic TLS proxy.
4 * $Id: easy-tls.c,v 1.4 2002/03/05 09:07:16 bodo Exp $
7 (c) Copyright 1999 Bodo Moeller. All rights reserved.
9 This is free software; you can redistributed and/or modify it
10 unter the terms of either
11 - the GNU General Public License as published by the
12 Free Software Foundation, version 1, or (at your option)
15 - the following license:
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that each of the following
22 * 1. Redistributions qualify as "freeware" or "Open Source Software" under
23 * one of the following terms:
25 * (a) Redistributions are made at no charge beyond the reasonable cost of
26 * materials and delivery.
28 * (b) Redistributions are accompanied by a copy of the Source Code
29 * or by an irrevocable offer to provide a copy of the Source Code
30 * for up to three years at the cost of materials and delivery.
31 * Such redistributions must allow further use, modification, and
32 * redistribution of the Source Code under substantially the same
33 * terms as this license.
35 * 2. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
38 * 3. Redistributions in binary form must reproduce the above copyright
39 * notice, this list of conditions and the following disclaimer in
40 * the documentation and/or other materials provided with the
43 * 4. All advertising materials mentioning features or use of this
44 * software must display the following acknowledgment:
45 * "This product includes software developed by Bodo Moeller."
46 * (If available, substitute umlauted o for oe.)
48 * 5. Redistributions of any form whatsoever must retain the following
50 * "This product includes software developed by Bodo Moeller."
52 * THIS SOFTWARE IS PROVIDED BY BODO MOELLER ``AS IS'' AND ANY
53 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
55 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BODO MOELLER OR
56 * HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
57 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
58 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
59 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
61 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
62 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
63 * OF THE POSSIBILITY OF SUCH DAMAGE.
66 * Attribution for OpenSSL library:
68 * This product includes cryptographic software written by Eric Young
69 * (eay@cryptsoft.com). This product includes software written by Tim
70 * Hudson (tjh@cryptsoft.com).
71 * This product includes software developed by the OpenSSL Project
72 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)
75 static char const rcsid
[] =
76 "$Id: easy-tls.c,v 1.4 2002/03/05 09:07:16 bodo Exp $";
85 #include <sys/select.h>
86 #include <sys/socket.h>
89 #include <sys/types.h>
90 #include <sys/utsname.h>
93 #include <openssl/crypto.h>
94 #include <openssl/dh.h>
95 #include <openssl/dsa.h>
96 #include <openssl/err.h>
97 #include <openssl/evp.h>
98 #include <openssl/opensslv.h>
99 #include <openssl/pem.h>
100 #include <openssl/rand.h>
102 #include <openssl/rsa.h>
104 #include <openssl/ssl.h>
105 #include <openssl/x509.h>
106 #include <openssl/x509_vfy.h>
108 #if OPENSSL_VERSION_NUMBER < 0x00904000L /* 0.9.4-dev */
109 # error "This program needs OpenSSL 0.9.4 or later."
112 #include "easy-tls.h" /* include after <openssl/ssl.h> if both are needed */
114 #if TLS_INFO_SIZE > PIPE_BUF
116 # error "PIPE_BUF < 512" /* non-POSIX */
118 # error "TLS_INFO_SIZE > PIPE_BUF"
121 /*****************************************************************************/
127 /* Applications can define:
128 * TLS_APP_PROCESS_INIT -- void ...(int fd, int client_p, void *apparg)
129 * TLS_CUMULATE_ERRORS
131 * TLS_APP_ERRFLUSH -- void ...(int child_p, char *, size_t, void *apparg)
134 #ifndef TLS_APP_PROCESS_INIT
135 # define TLS_APP_PROCESS_INIT(fd, client_p, apparg) ((void) 0)
138 #ifndef TLS_ERROR_BUFSIZ
139 # define TLS_ERROR_BUFSIZ (10*160)
141 #if TLS_ERROR_BUFSIZ < 2 /* {'\n',0} */
142 # error "TLS_ERROR_BUFSIZE is too small."
145 #ifndef TLS_APP_ERRFLUSH
146 # define TLS_APP_ERRFLUSH tls_app_errflush
148 tls_app_errflush(int child_p
, char *errbuf
, size_t num
, void *apparg
)
150 fputs(errbuf
, stderr
);
154 /*****************************************************************************/
157 # define DEBUG_MSG(x) fprintf(stderr," %s\n",x)
158 # define DEBUG_MSG2(x,y) fprintf(stderr, " %s: %d\n",x,y)
159 static int tls_loop_count
= 0;
160 static int tls_select_count
= 0;
162 # define DEBUG_MSG(x) (void)0
163 # define DEBUG_MSG2(x,y) (void)0
166 static void tls_rand_seed_uniquely(void);
167 static void tls_proxy(int clear_fd
, int tls_fd
, int info_fd
, SSL_CTX
*ctx
, int client_p
);
168 static int tls_socket_nonblocking(int fd
);
170 static int tls_child_p
= 0;
171 static void *tls_child_apparg
;
174 struct tls_start_proxy_args
175 tls_start_proxy_defaultargs(void)
177 struct tls_start_proxy_args ret
;
189 * Slice in TLS proxy process at fd.
191 * 0 ok (*pid is set to child's PID if pid != NULL),
194 * (return value encodes place of error)
198 tls_start_proxy(struct tls_start_proxy_args a
, void *apparg
)
200 int fds
[2] = {-1, -1};
201 int infofds
[2] = {-1, -1};
205 DEBUG_MSG2("tls_start_proxy fd", a
.fd
);
206 DEBUG_MSG2("tls_start_proxy client_p", a
.client_p
);
208 if (a
.fd
== -1 || a
.client_p
== -1 || a
.ctx
== NULL
)
214 if (a
.infofd
!= NULL
) {
218 r
= socketpair(AF_UNIX
, SOCK_STREAM
, 0, fds
);
221 if (a
.fd
>= FD_SETSIZE
|| fds
[0] >= FD_SETSIZE
) {
225 if (a
.infofd
!= NULL
) {
241 tls_child_apparg
= apparg
;
243 if (infofds
[0] != -1)
245 TLS_APP_PROCESS_INIT(a
.fd
, a
.client_p
, apparg
);
246 DEBUG_MSG("TLS_APP_PROCESS_INIT");
247 tls_proxy(fds
[0], a
.fd
, infofds
[1], a
.ctx
, a
.client_p
);
252 if (infofds
[1] != -1) {
256 /* install fds[1] in place of fd: */
259 getfd
= fcntl(a
.fd
, F_GETFD
);
260 getfl
= fcntl(a
.fd
, F_GETFL
);
261 r
= dup2(fds
[1], a
.fd
);
269 fcntl(a
.fd
, F_SETFD
, getfd
);
270 if (getfl
& O_NONBLOCK
)
271 (void)tls_socket_nonblocking(a
.fd
);
272 if (a
.infofd
!= NULL
)
273 *a
.infofd
= infofds
[0];
281 if (infofds
[0] != -1)
283 if (infofds
[1] != -1)
288 /*****************************************************************************/
290 static char errbuf
[TLS_ERROR_BUFSIZ
];
291 static size_t errbuf_i
= 0;
294 tls_errflush(void *apparg
)
299 assert(errbuf_i
< sizeof errbuf
);
300 assert(errbuf
[errbuf_i
] == 0);
301 if (errbuf_i
== sizeof errbuf
- 1) {
302 /* make sure we have a newline, even if string has been truncated */
303 errbuf
[errbuf_i
- 1] = '\n';
306 /* TLS_APP_ERRFLUSH may modify the string as needed,
307 * e.g. substitute other characters for \n for convenience */
308 TLS_APP_ERRFLUSH(tls_child_p
, errbuf
, errbuf_i
, apparg
);
314 tls_errprintf(int flush
, void *apparg
, const char *fmt
, ...)
319 if (errbuf_i
< sizeof errbuf
- 1) {
323 n
= (sizeof errbuf
) - errbuf_i
;
324 r
= vsnprintf(errbuf
+ errbuf_i
, n
, fmt
, args
);
330 errbuf_i
= sizeof errbuf
- 1;
331 errbuf
[errbuf_i
] = '\0';
333 assert(errbuf_i
< sizeof errbuf
);
334 assert(errbuf
[errbuf_i
] == 0);
336 #ifndef TLS_CUMULATE_ERRORS
337 tls_errflush(apparg
);
340 tls_errflush(apparg
);
344 /* app_prefix.. are for additional information provided by caller.
345 * If OpenSSL error queue is empty, print default_text ("???" if NULL).
348 tls_openssl_errors(const char *app_prefix_1
, const char *app_prefix_2
, const char *default_text
, void *apparg
)
350 static char reasons
[255];
358 int printed_something
= 0;
362 assert(app_prefix_1
!= NULL
);
363 assert(app_prefix_2
!= NULL
);
365 if (default_text
== NULL
)
366 default_text
= "?""?""?";
368 while ((err
= ERR_get_error_line_data(&file
,&line
,&data
,&flags
)) != 0) {
369 if (reasons_i
< sizeof reasons
) {
373 n
= (sizeof reasons
) - reasons_i
;
374 r
= snprintf(reasons
+ reasons_i
, n
, "%s%s", (reasons_i
> 0 ? ", " : ""), ERR_reason_error_string(err
));
380 reasons_i
= sizeof reasons
;
382 assert(reasons_i
<= sizeof reasons
);
385 errstring
= ERR_error_string(err
, NULL
);
386 assert(errstring
!= NULL
);
387 tls_errprintf(0, apparg
, "OpenSSL error%s%s: %s:%s:%d:%s\n", app_prefix_1
, app_prefix_2
, errstring
, file
, line
, (flags
& ERR_TXT_STRING
) ? data
: "");
388 printed_something
= 1;
391 if (!printed_something
) {
392 assert(reasons_i
== 0);
393 snprintf(reasons
, sizeof reasons
, "%s", default_text
);
394 tls_errprintf(0, apparg
, "OpenSSL error%s%s: %s\n", app_prefix_1
, app_prefix_2
, default_text
);
397 #ifdef TLS_CUMULATE_ERRORS
398 tls_errflush(apparg
);
400 assert(errbuf_i
== 0);
405 /*****************************************************************************/
407 static int tls_init_done
= 0;
410 tls_init(void *apparg
)
415 SSL_load_error_strings();
416 if (!SSL_library_init() /* aka SSLeay_add_ssl_algorithms() */ ) {
417 tls_errprintf(1, apparg
, "SSL_library_init failed.\n");
425 /*****************************************************************************/
428 tls_rand_seed_uniquely(void)
437 data
.time
= time(NULL
);
438 data
.stack
= (void *)&data
;
440 RAND_seed((const void *)&data
, sizeof data
);
447 struct utsname uname
;
456 data
.uname_1
= uname(&data
.uname
);
457 data
.uname_2
= errno
; /* Let's hope that uname fails randomly :-) */
460 data
.euid
= geteuid();
462 data
.egid
= getegid();
464 RAND_seed((const void *)&data
, sizeof data
);
465 tls_rand_seed_uniquely();
468 static int tls_rand_seeded_p
= 0;
470 #define my_MIN_SEED_BYTES 256 /* struct stat can be larger than 128 */
472 tls_rand_seed_from_file(const char *filename
, size_t n
, void *apparg
)
474 /* Seed OpenSSL's random number generator from file.
475 Try to read n bytes if n > 0, whole file if n == 0. */
479 if (tls_init(apparg
) == -1)
483 r
= RAND_load_file(filename
, (n
> 0 && n
< LONG_MAX
) ? (long)n
: LONG_MAX
);
484 /* r is the number of bytes filled into the random number generator,
485 * which are taken from "stat(filename, ...)" in addition to the
488 assert(1 < my_MIN_SEED_BYTES
);
489 /* We need to detect at least those cases when the file does not exist
490 * at all. With current versions of OpenSSL, this should do it: */
492 n
= my_MIN_SEED_BYTES
;
494 tls_errprintf(1, apparg
, "rand_seed_from_file: could not read %d bytes from %s.\n", n
, filename
);
497 tls_rand_seeded_p
= 1;
503 tls_rand_seed_from_memory(const void *buf
, size_t n
)
509 int chunk
= rest
< INT_MAX
? (int)rest
: INT_MAX
;
510 RAND_seed((const char *)buf
+ i
, chunk
);
513 tls_rand_seeded_p
= 1;
517 /*****************************************************************************/
519 struct tls_x509_name_string
{
524 tls_get_x509_subject_name_oneline(X509
*cert
, struct tls_x509_name_string
*namestring
)
529 namestring
->str
[0] = '\0';
533 name
= X509_get_subject_name(cert
); /* does not increment any reference counter */
535 assert(sizeof namestring
->str
>= 4); /* "?" or "...", plus 0 */
538 namestring
->str
[0] = '?';
539 namestring
->str
[1] = 0;
543 X509_NAME_oneline(name
, namestring
->str
, sizeof namestring
->str
);
544 len
= strlen(namestring
->str
);
545 assert(namestring
->str
[len
] == 0);
546 assert(len
< sizeof namestring
->str
);
548 if (len
+1 == sizeof namestring
->str
) {
549 /* (Probably something was cut off.)
550 * Does not really work -- X509_NAME_oneline truncates after
551 * name components, we cannot tell from the result whether
552 * anything is missing. */
554 assert(namestring
->str
[len
] == 0);
555 namestring
->str
[--len
] = '.';
556 namestring
->str
[--len
] = '.';
557 namestring
->str
[--len
] = '.';
562 /*****************************************************************************/
564 /* to hinder OpenSSL from asking for passphrases */
566 no_passphrase_callback(char *buf
, int num
, int w
, void *arg
)
571 #if OPENSSL_VERSION_NUMBER >= 0x00907000L
573 verify_dont_fail_cb(X509_STORE_CTX
*c
, void *unused_arg
)
576 verify_dont_fail_cb(X509_STORE_CTX
*c
)
581 i
= X509_verify_cert(c
); /* sets c->error */
582 #if OPENSSL_VERSION_NUMBER >= 0x00905000L /* don't allow unverified
583 * certificates -- they could
584 * survive session reuse, but
585 * OpenSSL < 0.9.5-dev does not
586 * preserve their verify_result */
594 static DH
*tls_dhe1024
= NULL
; /* generating these takes a while, so do it just once */
597 tls_set_dhe1024(int i
, void *apparg
)
601 const char *seed
[] = { ";-) :-( :-) :-( ",
603 "Random String no. 12",
605 "hackers have even mo", /* from jargon file */
607 unsigned char seedbuf
[20];
611 i
%= sizeof seed
/ sizeof seed
[0];
612 assert(strlen(seed
[i
]) == 20);
613 memcpy(seedbuf
, seed
[i
], 20);
614 dsaparams
= DSA_generate_parameters(1024, seedbuf
, 20, NULL
, NULL
, 0, NULL
);
616 /* random parameters (may take a while) */
617 dsaparams
= DSA_generate_parameters(1024, NULL
, 0, NULL
, NULL
, 0, NULL
);
620 if (dsaparams
== NULL
) {
621 tls_openssl_errors("", "", NULL
, apparg
);
624 dhparams
= DSA_dup_DH(dsaparams
);
626 if (dhparams
== NULL
) {
627 tls_openssl_errors("", "", NULL
, apparg
);
630 if (tls_dhe1024
!= NULL
)
631 DH_free(tls_dhe1024
);
632 tls_dhe1024
= dhparams
;
635 struct tls_create_ctx_args
636 tls_create_ctx_defaultargs(void)
638 struct tls_create_ctx_args ret
;
641 ret
.certificate_file
= NULL
;
644 ret
.verify_depth
= -1;
645 ret
.fail_unless_verified
= 0;
652 tls_create_ctx(struct tls_create_ctx_args a
, void *apparg
)
655 static long context_num
= 0;
657 const char *err_pref_1
= "", *err_pref_2
= "";
659 if (tls_init(apparg
) == -1)
662 ret
= SSL_CTX_new((a
.client_p
? SSLv23_client_method
:SSLv23_server_method
)());
667 SSL_CTX_set_default_passwd_cb(ret
, no_passphrase_callback
);
668 SSL_CTX_set_mode(ret
, SSL_MODE_ENABLE_PARTIAL_WRITE
);
670 if ((a
.certificate_file
!= NULL
) || (a
.key_file
!= NULL
)) {
671 if (a
.key_file
== NULL
) {
672 tls_errprintf(1, apparg
, "Need a key file.\n");
675 if (a
.certificate_file
== NULL
) {
676 tls_errprintf(1, apparg
, "Need a certificate chain file.\n");
680 if (!SSL_CTX_use_PrivateKey_file(ret
, a
.key_file
, SSL_FILETYPE_PEM
))
682 if (!tls_rand_seeded_p
) {
683 /* particularly paranoid people may not like this --
684 * so provide your own random seeding before calling this */
685 if (tls_rand_seed_from_file(a
.key_file
, 0, apparg
) == -1)
688 if (!SSL_CTX_use_certificate_chain_file(ret
, a
.certificate_file
))
690 if (!SSL_CTX_check_private_key(ret
)) {
691 tls_errprintf(1, apparg
, "Private key \"%s\" does not match certificate \"%s\".\n", a
.key_file
, a
.certificate_file
);
696 if ((a
.ca_file
!= NULL
) || (a
.verify_depth
> 0)) {
698 r
= SSL_CTX_set_session_id_context(ret
, (const void *)&context_num
, (unsigned int)sizeof context_num
);
702 SSL_CTX_set_verify(ret
, SSL_VERIFY_PEER
| (a
.fail_unless_verified
? SSL_VERIFY_FAIL_IF_NO_PEER_CERT
: 0), 0);
703 if (!a
.fail_unless_verified
)
704 SSL_CTX_set_cert_verify_callback(ret
, verify_dont_fail_cb
, NULL
);
706 if (a
.verify_depth
> 0)
707 SSL_CTX_set_verify_depth(ret
, a
.verify_depth
);
709 if (a
.ca_file
!= NULL
) {
710 r
= SSL_CTX_load_verify_locations(ret
, a
.ca_file
, NULL
/* no CA-directory */); /* does not report failure if file does not exist ... */
712 err_pref_1
= " while processing certificate file ";
713 err_pref_2
= a
.ca_file
;
718 /* SSL_load_client_CA_file is a misnomer, it just creates a list of CNs. */
719 SSL_CTX_set_client_CA_list(ret
, SSL_load_client_CA_file(a
.ca_file
));
720 /* SSL_CTX_set_client_CA_list does not have a return value;
721 * it does not really need one, but make sure
722 * (we really test if SSL_load_client_CA_file worked) */
723 if (SSL_CTX_get_client_CA_list(ret
) == NULL
) {
724 tls_errprintf(1, apparg
, "Could not set client CA list from \"%s\".\n", a
.ca_file
);
732 if (tls_dhe1024
== NULL
) {
735 RAND_bytes((unsigned char *) &i
, sizeof i
);
736 /* make sure that i is non-negative -- pick one of the provided
742 tls_set_dhe1024(i
, apparg
);
743 if (tls_dhe1024
== NULL
)
747 if (!SSL_CTX_set_tmp_dh(ret
, tls_dhe1024
))
750 /* avoid small subgroup attacks: */
751 SSL_CTX_set_options(ret
, SSL_OP_SINGLE_DH_USE
);
755 if (!a
.client_p
&& a
.export_p
) {
758 tmpkey
= RSA_generate_key(512, RSA_F4
, 0, NULL
);
761 if (!SSL_CTX_set_tmp_rsa(ret
, tmpkey
)) {
765 RSA_free(tmpkey
); /* SSL_CTX_set_tmp_rsa uses a duplicate. */
772 if (!ERR_peek_error())
775 tls_openssl_errors(err_pref_1
, err_pref_2
, NULL
, apparg
);
783 /*****************************************************************************/
786 tls_socket_nonblocking(int fd
)
790 v
= fcntl(fd
, F_GETFL
, 0);
793 return 0; /* already shut down -- ignore */
796 r
= fcntl(fd
, F_SETFL
, v
| O_NONBLOCK
);
799 return 0; /* already shut down -- ignore */
808 return a
> b
? a
: b
;
812 tls_sockets_select(int read_select_1
, int read_select_2
, int write_select_1
, int write_select_2
, int seconds
/* timeout, -1 means no timeout */)
815 fd_set reads
, writes
;
816 struct timeval timeout
;
817 struct timeval
*timeout_p
;
819 assert(read_select_1
>= -1 && read_select_2
>= -1 && write_select_1
>= -1 && write_select_2
>= -1);
820 assert(read_select_1
< FD_SETSIZE
&& read_select_2
< FD_SETSIZE
-1 && write_select_1
< FD_SETSIZE
-1 && write_select_2
< FD_SETSIZE
-1);
822 maxfd
= max(max(read_select_1
, read_select_2
), max(write_select_1
, write_select_2
));
828 for(n
= 0; n
< 4; ++n
) {
831 /* loop over all (i, w) in {0,1}x{0,1} */
834 if (i
== 0 && w
== 0)
836 else if (i
== 1 && w
== 0)
838 else if (i
== 0 && w
== 1)
841 assert(i
== 1 && w
== 1);
854 timeout
.tv_sec
= seconds
;
856 timeout_p
= &timeout
;
860 DEBUG_MSG2("select no.", ++tls_select_count
);
861 select(maxfd
+ 1, &reads
, &writes
, (fd_set
*) NULL
, timeout_p
);
865 /*****************************************************************************/
867 #define TUNNELBUFSIZE (16*1024)
869 char buf
[TUNNELBUFSIZE
];
874 static int tls_connect_attempt(SSL
*, int *write_select
, int *read_select
, int *closed
, int *progress
, const char **err_pref
);
876 static int tls_accept_attempt(SSL
*, int *write_select
, int *read_select
, int *closed
, int *progress
, const char **err_pref
);
878 static int tls_write_attempt(SSL
*, struct tunnelbuf
*, int *write_select
, int *read_select
, int *closed
, int *progress
, const char **err_pref
);
880 static int tls_read_attempt(SSL
*, struct tunnelbuf
*, int *write_select
, int *read_select
, int *closed
, int *progress
, const char **err_pref
);
882 static int write_attempt(int fd
, struct tunnelbuf
*, int *select
, int *closed
, int *progress
);
884 static int read_attempt(int fd
, struct tunnelbuf
*, int *select
, int *closed
, int *progress
);
886 static void write_info(SSL
*ssl
, int *info_fd
)
888 if (*info_fd
!= -1) {
891 struct tls_x509_name_string peer
;
892 char infobuf
[TLS_INFO_SIZE
];
895 DEBUG_MSG("write_info");
896 v
= SSL_get_verify_result(ssl
);
897 v_ok
= (v
== X509_V_OK
) ? 'A' : 'E'; /* Auth./Error */
901 peercert
= SSL_get_peer_certificate(ssl
);
902 tls_get_x509_subject_name_oneline(peercert
, &peer
);
903 if (peercert
!= NULL
)
906 if (peer
.str
[0] == '\0')
907 v_ok
= '0'; /* no cert at all */
909 if (strchr(peer
.str
, '\n')) {
910 /* should not happen, but make sure */
911 *strchr(peer
.str
, '\n') = '\0';
913 r
= snprintf(infobuf
, sizeof infobuf
, "%c:%s\n%s\n", v_ok
, X509_verify_cert_error_string(v
), peer
.str
);
914 DEBUG_MSG2("snprintf", r
);
915 if (r
== -1 || r
>= sizeof infobuf
)
916 r
= sizeof infobuf
- 1;
917 write(*info_fd
, infobuf
, r
);
924 /* tls_proxy expects that all fds are closed after return */
926 tls_proxy(int clear_fd
, int tls_fd
, int info_fd
, SSL_CTX
*ctx
, int client_p
)
928 struct tunnelbuf clear_to_tls
, tls_to_clear
;
931 int closed
, in_handshake
;
932 const char *err_pref_1
= "", *err_pref_2
= "";
933 const char *err_def
= NULL
;
935 assert(clear_fd
!= -1);
936 assert(tls_fd
!= -1);
937 assert(clear_fd
< FD_SETSIZE
);
938 assert(tls_fd
< FD_SETSIZE
);
939 /* info_fd may be -1 */
942 tls_rand_seed_uniquely();
944 tls_socket_nonblocking(clear_fd
);
945 DEBUG_MSG2("clear_fd", clear_fd
);
946 tls_socket_nonblocking(tls_fd
);
947 DEBUG_MSG2("tls_fd", tls_fd
);
952 DEBUG_MSG("SSL_new");
953 if (!SSL_set_fd(ssl
, tls_fd
))
955 rbio
= SSL_get_rbio(ssl
);
956 wbio
= SSL_get_wbio(ssl
); /* should be the same, but who cares */
957 assert(rbio
!= NULL
);
958 assert(wbio
!= NULL
);
960 SSL_set_connect_state(ssl
);
962 SSL_set_accept_state(ssl
);
966 tls_to_clear
.len
= 0;
967 tls_to_clear
.offset
= 0;
968 clear_to_tls
.len
= 0;
969 clear_to_tls
.offset
= 0;
971 err_def
= "I/O error";
973 /* loop finishes as soon as we detect that one side closed;
974 * when all (program and OS) buffers have enough space,
975 * the data from the last succesful read in each direction is transferred
978 int clear_read_select
= 0, clear_write_select
= 0,
979 tls_read_select
= 0, tls_write_select
= 0,
982 unsigned long num_read
= BIO_number_read(rbio
),
983 num_written
= BIO_number_written(wbio
);
985 DEBUG_MSG2("loop iteration", ++tls_loop_count
);
988 DEBUG_MSG("in_handshake");
990 r
= tls_connect_attempt(ssl
, &tls_write_select
, &tls_read_select
, &closed
, &progress
, &err_pref_1
);
992 r
= tls_accept_attempt(ssl
, &tls_write_select
, &tls_read_select
, &closed
, &progress
, &err_pref_1
);
994 write_info(ssl
, &info_fd
);
999 if (!SSL_in_init(ssl
)) {
1001 write_info(ssl
, &info_fd
);
1005 if (clear_to_tls
.len
!= 0 && !in_handshake
) {
1008 r
= tls_write_attempt(ssl
, &clear_to_tls
, &tls_write_select
, &tls_read_select
, &closed
, &progress
, &err_pref_1
);
1013 tls_to_clear
.offset
= 0;
1014 tls_to_clear
.len
= 0;
1018 if (tls_to_clear
.len
!= 0) {
1021 r
= write_attempt(clear_fd
, &tls_to_clear
, &clear_write_select
, &closed
, &progress
);
1026 clear_to_tls
.offset
= 0;
1027 clear_to_tls
.len
= 0;
1032 if (clear_to_tls
.offset
+ clear_to_tls
.len
< sizeof clear_to_tls
.buf
) {
1033 r
= read_attempt(clear_fd
, &clear_to_tls
, &clear_read_select
, &closed
, &progress
);
1037 r
= SSL_shutdown(ssl
);
1038 DEBUG_MSG2("SSL_shutdown", r
);
1043 if (!closed
&& !in_handshake
) {
1044 if (tls_to_clear
.offset
+ tls_to_clear
.len
< sizeof tls_to_clear
.buf
) {
1045 r
= tls_read_attempt(ssl
, &tls_to_clear
, &tls_write_select
, &tls_read_select
, &closed
, &progress
, &err_pref_1
);
1049 r
= SSL_shutdown(ssl
);
1050 DEBUG_MSG2("SSL_shutdown", r
);
1056 DEBUG_MSG("!progress?");
1057 if (num_read
!= BIO_number_read(rbio
) || num_written
!= BIO_number_written(wbio
))
1061 DEBUG_MSG("!progress");
1062 assert(clear_read_select
|| tls_read_select
|| clear_write_select
|| tls_write_select
);
1063 tls_sockets_select(clear_read_select
? clear_fd
: -1, tls_read_select
? tls_fd
: -1, clear_write_select
? clear_fd
: -1, tls_write_select
? tls_fd
: -1, -1);
1070 tls_openssl_errors(err_pref_1
, err_pref_2
, err_def
, tls_child_apparg
);
1077 tls_get_error(SSL
*ssl
, int r
, int *write_select
, int *read_select
, int *closed
, int *progress
)
1079 int err
= SSL_get_error(ssl
, r
);
1081 if (err
== SSL_ERROR_NONE
) {
1090 case SSL_ERROR_ZERO_RETURN
:
1096 case SSL_ERROR_WANT_WRITE
:
1100 case SSL_ERROR_WANT_READ
:
1109 tls_connect_attempt(SSL
*ssl
, int *write_select
, int *read_select
, int *closed
, int *progress
, const char **err_pref
)
1113 DEBUG_MSG("tls_connect_attempt");
1114 n
= SSL_connect(ssl
);
1115 DEBUG_MSG2("SSL_connect",n
);
1116 r
= tls_get_error(ssl
, n
, write_select
, read_select
, closed
, progress
);
1118 *err_pref
= " during SSL_connect";
1123 tls_accept_attempt(SSL
*ssl
, int *write_select
, int *read_select
, int *closed
, int *progress
, const char **err_pref
)
1127 DEBUG_MSG("tls_accept_attempt");
1128 n
= SSL_accept(ssl
);
1129 DEBUG_MSG2("SSL_accept",n
);
1130 r
= tls_get_error(ssl
, n
, write_select
, read_select
, closed
, progress
);
1132 *err_pref
= " during SSL_accept";
1137 tls_write_attempt(SSL
*ssl
, struct tunnelbuf
*buf
, int *write_select
, int *read_select
, int *closed
, int *progress
, const char **err_pref
)
1141 DEBUG_MSG("tls_write_attempt");
1142 n
= SSL_write(ssl
, buf
->buf
+ buf
->offset
, buf
->len
);
1143 DEBUG_MSG2("SSL_write",n
);
1144 r
= tls_get_error(ssl
, n
, write_select
, read_select
, closed
, progress
);
1147 assert(buf
->len
>= 0);
1154 *err_pref
= " during SSL_write";
1159 tls_read_attempt(SSL
*ssl
, struct tunnelbuf
*buf
, int *write_select
, int *read_select
, int *closed
, int *progress
, const char **err_pref
)
1164 DEBUG_MSG("tls_read_attempt");
1165 total
= buf
->offset
+ buf
->len
;
1166 assert(total
< sizeof buf
->buf
);
1167 n
= SSL_read(ssl
, buf
->buf
+ total
, (sizeof buf
->buf
) - total
);
1168 DEBUG_MSG2("SSL_read",n
);
1169 r
= tls_get_error(ssl
, n
, write_select
, read_select
, closed
, progress
);
1172 assert(buf
->offset
+ buf
->len
<= sizeof buf
->buf
);
1175 *err_pref
= " during SSL_read";
1180 get_error(int r
, int *select
, int *closed
, int *progress
)
1189 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
) {
1192 } else if (errno
== EPIPE
) {
1201 static int write_attempt(int fd
, struct tunnelbuf
*buf
, int *select
, int *closed
, int *progress
)
1205 DEBUG_MSG("write_attempt");
1206 n
= write(fd
, buf
->buf
+ buf
->offset
, buf
->len
);
1207 DEBUG_MSG2("write",n
);
1208 r
= get_error(n
, select
, closed
, progress
);
1211 assert(buf
->len
>= 0);
1218 tls_errprintf(1, tls_child_apparg
, "write error: %s\n", strerror(errno
));
1223 read_attempt(int fd
, struct tunnelbuf
*buf
, int *select
, int *closed
, int *progress
)
1228 DEBUG_MSG("read_attempt");
1229 total
= buf
->offset
+ buf
->len
;
1230 assert(total
< sizeof buf
->buf
);
1231 n
= read(fd
, buf
->buf
+ total
, (sizeof buf
->buf
) - total
);
1232 DEBUG_MSG2("read",n
);
1233 r
= get_error(n
, select
, closed
, progress
);
1236 assert(buf
->offset
+ buf
->len
<= sizeof buf
->buf
);
1239 tls_errprintf(1, tls_child_apparg
, "read error: %s\n", strerror(errno
));