/* Copyright (c) 2002-2009 Dovecot authors, see the included COPYING file */

 #include "common.h"

 #include "array.h"

 #include "ioloop.h"

 #include "network.h"

 #include "ostream.h"

 #include "read-full.h"

 #include "llist.h"

 #include "ssl-proxy.h"

 #include <fcntl.h>

 #include <unistd.h>

 #include <sys/stat.h>

 #ifdef HAVE_OPENSSL

 #include <openssl/crypto.h>

 #include <openssl/x509.h>

 #include <openssl/pem.h>

 #include <openssl/ssl.h>

 #include <openssl/err.h>

 #include <openssl/rand.h>

 #define DOVECOT_SSL_DEFAULT_CIPHER_LIST "ALL:!LOW:!SSLv2"

 /* Check every 30 minutes if parameters file has been updated */

 #define SSL_PARAMFILE_CHECK_INTERVAL (60*30)

 enum ssl_io_action {

 	SSL_ADD_INPUT,

 	SSL_REMOVE_INPUT,

 	SSL_ADD_OUTPUT,

 	SSL_REMOVE_OUTPUT

 };

 struct ssl_proxy {

 	int refcount;

 	struct ssl_proxy *prev, *next;

 	SSL *ssl;

 	struct ip_addr ip;

 	int fd_ssl, fd_plain;

 	struct io *io_ssl_read, *io_ssl_write, *io_plain_read, *io_plain_write;

 	unsigned char plainout_buf[1024];

 	unsigned int plainout_size;

 	unsigned char sslout_buf[1024];

 	unsigned int sslout_size;

 	ssl_handshake_callback_t *handshake_callback;

 	void *handshake_context;

 	char *last_error;

 	unsigned int handshaked:1;

 	unsigned int destroyed:1;

 	unsigned int cert_received:1;

 	unsigned int cert_broken:1;

 	unsigned int client:1;

 };

 struct ssl_parameters {

 	const char *fname;

 	time_t last_mtime, last_check;

 	int fd;

 	DH *dh_512, *dh_1024;

 };

 static int extdata_index;

 static SSL_CTX *ssl_server_ctx;

 static SSL_CTX *ssl_client_ctx;

 static unsigned int ssl_proxy_count;

 static struct ssl_proxy *ssl_proxies;

 static struct ssl_parameters ssl_params;

 static int ssl_username_nid;

 static void plain_read(struct ssl_proxy *proxy);

 static void ssl_read(struct ssl_proxy *proxy);

 static void ssl_write(struct ssl_proxy *proxy);

 static void ssl_step(struct ssl_proxy *proxy);

 static void ssl_proxy_destroy(struct ssl_proxy *proxy);

 static void ssl_proxy_unref(struct ssl_proxy *proxy);

 static void ssl_params_corrupted(const char *path)

 {

 	i_fatal("Corrupted SSL parameters file: %s/%s "

 		"(delete it and also the one in %s)",

 		getenv("LOGIN_DIR"), path, PKG_STATEDIR);

 }

 static void read_next(struct ssl_parameters *params, void *data, size_t size)

 {

 	int ret;

 	if ((ret = read_full(params->fd, data, size)) < 0)

 		i_fatal("read(%s) failed: %m", params->fname);

 	if (ret == 0)

 		ssl_params_corrupted(params->fname);

 }

 static bool read_dh_parameters_next(struct ssl_parameters *params)

 {

 	unsigned char *buf;

 	const unsigned char *cbuf;

 	unsigned int len;

 	int bits;

 	/* read bit size. 0 ends the DH parameters list. */

 	read_next(params, &bits, sizeof(bits));

 	if (bits == 0)

 		return FALSE;

 	/* read data size. */

 	read_next(params, &len, sizeof(len));

 	if (len > 1024*100) /* should be enough? */

 		ssl_params_corrupted(params->fname);

 	buf = i_malloc(len);

 	read_next(params, buf, len);

 	cbuf = buf;

 	switch (bits) {

 	case 512:

 		params->dh_512 = d2i_DHparams(NULL, &cbuf, len);

 		break;

 	case 1024:

 		params->dh_1024 = d2i_DHparams(NULL, &cbuf, len);

 		break;

 	default:

 		ssl_params_corrupted(params->fname);

 	}

 	i_free(buf);

 	return TRUE;

 }

 static void ssl_free_parameters(struct ssl_parameters *params)

 {

 	if (params->dh_512 != NULL) {

 		DH_free(params->dh_512);

                 params->dh_512 = NULL;

 	}

 	if (params->dh_1024 != NULL) {

 		DH_free(params->dh_1024);

                 params->dh_1024 = NULL;

 	}

 }

 static void ssl_read_parameters(struct ssl_parameters *params)

 {

 	struct stat st;

 	ssize_t ret;

 	char c;

 	bool warned = FALSE;

 	/* we'll wait until parameter file exists */

 	for (;;) {

 		params->fd = open(params->fname, O_RDONLY);

 		if (params->fd != -1)

 			break;

 		if (errno != ENOENT) {

 			i_fatal("Can't open SSL parameter file %s: %m",

 				params->fname);

 		}

 		if (!warned) {

 			i_warning("Waiting for SSL parameter file %s",

 				  params->fname);

 			warned = TRUE;

 		}

 		sleep(1);

 	}

 	if (fstat(params->fd, &st) < 0)

 		i_error("fstat(%s) failed: %m", params->fname);

 	else

 		params->last_mtime = st.st_mtime;

 	ssl_free_parameters(params);

 	while (read_dh_parameters_next(params)) ;

 	if ((ret = read_full(params->fd, &c, 1)) < 0)

 		i_fatal("read(%s) failed: %m", params->fname);

 	else if (ret != 0) {

 		/* more data than expected */

 		ssl_params_corrupted(params->fname);

 	}

 	if (close(params->fd) < 0)

 		i_error("close() failed: %m");

 	params->fd = -1;

 }

 static void ssl_refresh_parameters(struct ssl_parameters *params)

 {

 	struct stat st;

 	if (params->last_check > ioloop_time - SSL_PARAMFILE_CHECK_INTERVAL)

 		return;

 	params->last_check = ioloop_time;

 	if (params->last_mtime == 0)

 		ssl_read_parameters(params);

 	else {

 		if (stat(params->fname, &st) < 0)

 			i_error("stat(%s) failed: %m", params->fname);

 		else if (st.st_mtime != params->last_mtime)

 			ssl_read_parameters(params);

 	}

 }

 static void ssl_set_io(struct ssl_proxy *proxy, enum ssl_io_action action)

 {

 	switch (action) {

 	case SSL_ADD_INPUT:

 		if (proxy->io_ssl_read != NULL)

 			break;

 		proxy->io_ssl_read = io_add(proxy->fd_ssl, IO_READ,

 					    ssl_step, proxy);

 		break;

 	case SSL_REMOVE_INPUT:

 		if (proxy->io_ssl_read != NULL)

 			io_remove(&proxy->io_ssl_read);

 		break;

 	case SSL_ADD_OUTPUT:

 		if (proxy->io_ssl_write != NULL)

 			break;

 		proxy->io_ssl_write = io_add(proxy->fd_ssl, IO_WRITE,

 					     ssl_step, proxy);

 		break;

 	case SSL_REMOVE_OUTPUT:

 		if (proxy->io_ssl_write != NULL)

 			io_remove(&proxy->io_ssl_write);

 		break;

 	}

 }

 static void plain_block_input(struct ssl_proxy *proxy, bool block)

 {

 	if (block) {

 		if (proxy->io_plain_read != NULL)

 			io_remove(&proxy->io_plain_read);

 	} else {

 		if (proxy->io_plain_read == NULL) {

 			proxy->io_plain_read = io_add(proxy->fd_plain, IO_READ,

 						      plain_read, proxy);

 		}

 	}

 }

 static void plain_read(struct ssl_proxy *proxy)

 {

 	ssize_t ret;

 	bool corked = FALSE;

 	if (proxy->sslout_size == sizeof(proxy->sslout_buf)) {

 		/* buffer full, block input until it's written */

 		plain_block_input(proxy, TRUE);

 		return;

 	}

 	proxy->refcount++;

 	while (proxy->sslout_size < sizeof(proxy->sslout_buf) &&

 	       !proxy->destroyed) {

 		ret = net_receive(proxy->fd_plain,

 				  proxy->sslout_buf + proxy->sslout_size,

 				  sizeof(proxy->sslout_buf) -

 				  proxy->sslout_size);

 		if (ret <= 0) {

 			if (ret < 0)

 				ssl_proxy_destroy(proxy);

 			break;

 		} else {

 			proxy->sslout_size += ret;

 			if (!corked) {

 				net_set_cork(proxy->fd_ssl, TRUE);

 				corked = TRUE;

 			}

 			ssl_write(proxy);

 		}

 	}

 	if (corked)

 		net_set_cork(proxy->fd_ssl, FALSE);

 	ssl_proxy_unref(proxy);

 }

 static void plain_write(struct ssl_proxy *proxy)

 {

 	ssize_t ret;

 	proxy->refcount++;

 	ret = net_transmit(proxy->fd_plain, proxy->plainout_buf,

 			   proxy->plainout_size);

 	if (ret < 0)

 		ssl_proxy_destroy(proxy);

 	else {

 		proxy->plainout_size -= ret;

 		memmove(proxy->plainout_buf, proxy->plainout_buf + ret,

 			proxy->plainout_size);

 		if (proxy->plainout_size > 0) {

 			if (proxy->io_plain_write == NULL) {

 				proxy->io_plain_write =

 					io_add(proxy->fd_plain, IO_WRITE,

 					       plain_write, proxy);

 			}

 		} else {

 			if (proxy->io_plain_write != NULL)

 				io_remove(&proxy->io_plain_write);

 		}

 		ssl_set_io(proxy, SSL_ADD_INPUT);

 		if (SSL_pending(proxy->ssl) > 0)

 			ssl_read(proxy);

 	}

 	ssl_proxy_unref(proxy);

 }

 static const char *ssl_last_error(void)

 {

 	unsigned long err;

 	char *buf;

 	size_t err_size = 256;

 	err = ERR_get_error();

 	if (err == 0) {

 		if (errno != 0)

 			return strerror(errno);

 		return "Unknown error";

 	}

 	buf = t_malloc(err_size);

 	buf[err_size-1] = '\0';

 	ERR_error_string_n(err, buf, err_size-1);

 	return buf;

 }

 static void ssl_handle_error(struct ssl_proxy *proxy, int ret,

 			     const char *func_name)

 {

 	const char *errstr = NULL;

 	int err;

 	proxy->refcount++;

 	i_free_and_null(proxy->last_error);

 	err = SSL_get_error(proxy->ssl, ret);

 	switch (err) {

 	case SSL_ERROR_WANT_READ:

 		ssl_set_io(proxy, SSL_ADD_INPUT);

 		break;

 	case SSL_ERROR_WANT_WRITE:

 		ssl_set_io(proxy, SSL_ADD_OUTPUT);

 		break;

 	case SSL_ERROR_SYSCALL:

 		/* eat up the error queue */

 		if (ERR_peek_error() != 0)

 			errstr = ssl_last_error();

 		else if (ret != 0)

 			errstr = strerror(errno);

 		else {

 			/* EOF. */

 			errstr = "Disconnected";

 			break;

 		}

 		errstr = t_strdup_printf("%s syscall failed: %s",

 					 func_name, errstr);

 		break;

 	case SSL_ERROR_ZERO_RETURN:

 		/* clean connection closing */

 		ssl_proxy_destroy(proxy);

 		break;

 	case SSL_ERROR_SSL:

 		if (ERR_GET_REASON(ERR_peek_error()) == ERR_R_MALLOC_FAILURE) {

 			i_error("OpenSSL malloc() failed. "

 				"You may need to increase login_process_size");

 		}

 		errstr = t_strdup_printf("%s failed: %s",

 					 func_name, ssl_last_error());

 		break;

 	default:

 		errstr = t_strdup_printf("%s failed: unknown failure %d (%s)",

 					 func_name, err, ssl_last_error());

 		break;

 	}

 	if (errstr != NULL) {

 		proxy->last_error = i_strdup(errstr);

 		ssl_proxy_destroy(proxy);

 	}

 	ssl_proxy_unref(proxy);

 }

 static void ssl_handshake(struct ssl_proxy *proxy)

 {

 	int ret;

 	if (proxy->client) {

 		ret = SSL_connect(proxy->ssl);

 		if (ret != 1) {

 			ssl_handle_error(proxy, ret, "SSL_connect()");

 			return;

 		}

 	} else {

 		ret = SSL_accept(proxy->ssl);

 		if (ret != 1) {

 			ssl_handle_error(proxy, ret, "SSL_accept()");

 			return;

 		}

 	}

 	i_free_and_null(proxy->last_error);

 	proxy->handshaked = TRUE;

 	ssl_set_io(proxy, SSL_ADD_INPUT);

 	plain_block_input(proxy, FALSE);

 	if (proxy->handshake_callback != NULL) {

 		if (proxy->handshake_callback(proxy->handshake_context) < 0)

 			ssl_proxy_destroy(proxy);

 	}

 }

 static void ssl_read(struct ssl_proxy *proxy)

 {

 	int ret;

 	while (proxy->plainout_size < sizeof(proxy->plainout_buf) &&

 	       !proxy->destroyed) {

 		ret = SSL_read(proxy->ssl,

 			       proxy->plainout_buf + proxy->plainout_size,

 			       sizeof(proxy->plainout_buf) -

 			       proxy->plainout_size);

 		if (ret <= 0) {

 			ssl_handle_error(proxy, ret, "SSL_read()");

 			break;

 		} else {

 			i_free_and_null(proxy->last_error);

 			proxy->plainout_size += ret;

 			plain_write(proxy);

 		}

 	}

 }

 static void ssl_write(struct ssl_proxy *proxy)

 {

 	int ret;

 	ret = SSL_write(proxy->ssl, proxy->sslout_buf, proxy->sslout_size);

 	if (ret <= 0)

 		ssl_handle_error(proxy, ret, "SSL_write()");

 	else {

 		i_free_and_null(proxy->last_error);

 		proxy->sslout_size -= ret;

 		memmove(proxy->sslout_buf, proxy->sslout_buf + ret,

 			proxy->sslout_size);

 		ssl_set_io(proxy, proxy->sslout_size > 0 ?

 			   SSL_ADD_OUTPUT : SSL_REMOVE_OUTPUT);

 		plain_block_input(proxy, FALSE);

 	}

 }

 static void ssl_step(struct ssl_proxy *proxy)

 {

 	proxy->refcount++;

 	if (!proxy->handshaked)

 		ssl_handshake(proxy);

 	if (proxy->handshaked) {

 		if (proxy->plainout_size == sizeof(proxy->plainout_buf))

 			ssl_set_io(proxy, SSL_REMOVE_INPUT);

 		else

 			ssl_read(proxy);

 		if (proxy->sslout_size == 0)

 			ssl_set_io(proxy, SSL_REMOVE_OUTPUT);

 		else {

 			net_set_cork(proxy->fd_ssl, TRUE);

 			ssl_write(proxy);

 			net_set_cork(proxy->fd_ssl, FALSE);

 		}

 	}

 	ssl_proxy_unref(proxy);

 }

 static int ssl_proxy_new_common(SSL_CTX *ssl_ctx, int fd, struct ip_addr *ip,

 				struct ssl_proxy **proxy_r)

 {

 	struct ssl_proxy *proxy;

 	SSL *ssl;

 	int sfd[2];

 	i_assert(fd != -1);

 	*proxy_r = NULL;

 	if (!ssl_initialized) {

 		i_error("SSL support not enabled in configuration");

 		return -1;

 	}

 	ssl_refresh_parameters(&ssl_params);

 	ssl = SSL_new(ssl_ctx);

 	if (ssl == NULL) {

 		i_error("SSL_new() failed: %s", ssl_last_error());

 		return -1;

 	}

 	if (SSL_set_fd(ssl, fd) != 1) {

 		i_error("SSL_set_fd() failed: %s", ssl_last_error());

 		SSL_free(ssl);

 		return -1;

 	}

 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, sfd) < 0) {

 		i_error("socketpair() failed: %m");

 		SSL_free(ssl);

 		return -1;

 	}

 	net_set_nonblock(sfd[0], TRUE);

 	net_set_nonblock(sfd[1], TRUE);

 	net_set_nonblock(fd, TRUE);

 	proxy = i_new(struct ssl_proxy, 1);

 	proxy->refcount = 2;

 	proxy->ssl = ssl;

 	proxy->fd_ssl = fd;

 	proxy->fd_plain = sfd[0];

 	proxy->ip = *ip;

         SSL_set_ex_data(ssl, extdata_index, proxy);

 	ssl_proxy_count++;

 	DLLIST_PREPEND(&ssl_proxies, proxy);

 	main_ref();

 	*proxy_r = proxy;

 	return sfd[1];

 }

 int ssl_proxy_new(int fd, struct ip_addr *ip, struct ssl_proxy **proxy_r)

 {

 	int ret;

 	if ((ret = ssl_proxy_new_common(ssl_server_ctx, fd, ip, proxy_r)) < 0)

 		return -1;

 	ssl_step(*proxy_r);

 	return ret;

 }

 int ssl_proxy_client_new(int fd, struct ip_addr *ip,

 			 ssl_handshake_callback_t *callback, void *context,

 			 struct ssl_proxy **proxy_r)

 {

 	int ret;

 	if ((ret = ssl_proxy_new_common(ssl_client_ctx, fd, ip, proxy_r)) < 0)

 		return -1;

 	(*proxy_r)->handshake_callback = callback;

 	(*proxy_r)->handshake_context = context;

 	(*proxy_r)->client = TRUE;

 	ssl_step(*proxy_r);

 	return ret;

 }

 bool ssl_proxy_has_valid_client_cert(const struct ssl_proxy *proxy)

 {

 	return proxy->cert_received && !proxy->cert_broken;

 }

 bool ssl_proxy_has_broken_client_cert(struct ssl_proxy *proxy)

 {

 	return proxy->cert_received && proxy->cert_broken;

 }

 const char *ssl_proxy_get_peer_name(struct ssl_proxy *proxy)

 {

 	X509 *x509;

 	char *name;

 	int len;

 	if (!ssl_proxy_has_valid_client_cert(proxy))

 		return NULL;

 	x509 = SSL_get_peer_certificate(proxy->ssl);

 	if (x509 == NULL)

 		return NULL; /* we should have had it.. */

 	len = X509_NAME_get_text_by_NID(X509_get_subject_name(x509),

 					ssl_username_nid, NULL, 0);

 	if (len < 0)

 		name = "";

 	else {

 		name = t_malloc(len + 1);

 		if (X509_NAME_get_text_by_NID(X509_get_subject_name(x509),

 					ssl_username_nid, name, len + 1) < 0)

 			name = "";

 		else if (strlen(name) != (size_t)len) {

 			/* NUL characters in name. Someone's trying to fake

 			   being another user? Don't allow it. */

 			name = "";

 		}

 	}

 	X509_free(x509);

 	return *name == '\0' ? NULL : name;

 }

 bool ssl_proxy_is_handshaked(const struct ssl_proxy *proxy)

 {

 	return proxy->handshaked;

 }

 const char *ssl_proxy_get_last_error(const struct ssl_proxy *proxy)

 {

 	return proxy->last_error;

 }

 const char *ssl_proxy_get_security_string(struct ssl_proxy *proxy)

 {

 	SSL_CIPHER *cipher;

 #ifdef HAVE_SSL_COMPRESSION

 	const COMP_METHOD *comp;

 #endif

 	int bits, alg_bits;

 	const char *comp_str;

 	if (!proxy->handshaked)

 		return "";

 	cipher = SSL_get_current_cipher(proxy->ssl);

 	bits = SSL_CIPHER_get_bits(cipher, &alg_bits);

 #ifdef HAVE_SSL_COMPRESSION

 	comp = SSL_get_current_compression(proxy->ssl);

 	comp_str = comp == NULL ? "" :

 		t_strconcat(" ", SSL_COMP_get_name(comp), NULL);

 #else

 	comp_str = NULL;

 #endif

 	return t_strdup_printf("%s with cipher %s (%d/%d bits)%s",

 			       SSL_get_version(proxy->ssl),

 			       SSL_CIPHER_get_name(cipher),

 			       bits, alg_bits, comp_str);

 }

 void ssl_proxy_free(struct ssl_proxy *proxy)

 {

 	ssl_proxy_unref(proxy);

 }

 static void ssl_proxy_unref(struct ssl_proxy *proxy)

 {

 	if (--proxy->refcount > 0)

 		return;

 	i_assert(proxy->refcount == 0);

 	SSL_free(proxy->ssl);

 	i_free(proxy);

 	main_unref();

 }

 static void ssl_proxy_destroy(struct ssl_proxy *proxy)

 {

 	if (proxy->destroyed)

 		return;

 	proxy->destroyed = TRUE;

 	ssl_proxy_count--;

 	DLLIST_REMOVE(&ssl_proxies, proxy);

 	if (proxy->io_ssl_read != NULL)

 		io_remove(&proxy->io_ssl_read);

 	if (proxy->io_ssl_write != NULL)

 		io_remove(&proxy->io_ssl_write);

 	if (proxy->io_plain_read != NULL)

 		io_remove(&proxy->io_plain_read);

 	if (proxy->io_plain_write != NULL)

 		io_remove(&proxy->io_plain_write);

 	(void)SSL_shutdown(proxy->ssl);

 	(void)net_disconnect(proxy->fd_ssl);

 	(void)net_disconnect(proxy->fd_plain);

 	ssl_proxy_unref(proxy);

 	main_listen_start();

 }

 static RSA *ssl_gen_rsa_key(SSL *ssl ATTR_UNUSED,

 			    int is_export ATTR_UNUSED, int keylength)

 {

 	return RSA_generate_key(keylength, RSA_F4, NULL, NULL);

 }

 static DH *ssl_tmp_dh_callback(SSL *ssl ATTR_UNUSED,

 			       int is_export, int keylength)

 {

 	/* Well, I'm not exactly sure why the logic in here is this.

 	   It's the same as in Postfix, so it can't be too wrong. */

 	if (is_export && keylength == 512 && ssl_params.dh_512 != NULL)

 		return ssl_params.dh_512;

 	return ssl_params.dh_1024;

 }

 static void ssl_info_callback(const SSL *ssl, int where, int ret)

 {

 	struct ssl_proxy *proxy;

 	proxy = SSL_get_ex_data(ssl, extdata_index);

 	if ((where & SSL_CB_ALERT) != 0) {

 		i_warning("SSL alert: where=0x%x, ret=%d: %s %s [%s]",

 			  where, ret, SSL_alert_type_string_long(ret),

 			  SSL_alert_desc_string_long(ret),

 			  net_ip2addr(&proxy->ip));

 	} else {

 		i_warning("SSL BIO failed: where=0x%x, ret=%d: %s [%s]",

 			  where, ret, SSL_state_string_long(ssl),

 			  net_ip2addr(&proxy->ip));

 	}

 }

 static int ssl_verify_client_cert(int preverify_ok, X509_STORE_CTX *ctx)

 {

 	SSL *ssl;

         struct ssl_proxy *proxy;

 	ssl = X509_STORE_CTX_get_ex_data(ctx,

 					 SSL_get_ex_data_X509_STORE_CTX_idx());

 	proxy = SSL_get_ex_data(ssl, extdata_index);

 	proxy->cert_received = TRUE;

 	if (verbose_ssl || (verbose_auth && !preverify_ok)) {

 		char buf[1024];

 		X509_NAME *subject;

 		subject = X509_get_subject_name(ctx->current_cert);

 		(void)X509_NAME_oneline(subject, buf, sizeof(buf));

 		buf[sizeof(buf)-1] = '\0'; /* just in case.. */

 		if (!preverify_ok)

 			i_info("Invalid certificate: %s: %s", X509_verify_cert_error_string(ctx->error),buf);

 		else

 			i_info("Valid certificate: %s", buf);

 	}

 	if (!preverify_ok)

 		proxy->cert_broken = TRUE;

 	/* Return success anyway, because if ssl_require_client_cert=no we

 	   could still allow authentication. */

 	return 1;

 }

 static int

 pem_password_callback(char *buf, int size, int rwflag ATTR_UNUSED,

 		      void *userdata)

 {

 	if (userdata == NULL) {

 		i_error("SSL private key file is password protected, "

 			"but password isn't given");

 		return 0;

 	}

 	if (i_strocpy(buf, userdata, size) < 0)

 		return 0;

 	return strlen(buf);

 }

 unsigned int ssl_proxy_get_count(void)

 {

 	return ssl_proxy_count;

 }

 static bool is_pem_key_file(const char *path)

 {

 	char buf[4096];

 	int fd, ret;

 	/* this code is used only for giving a better error message,

 	   so it needs to catch only the normal key files */

 	fd = open(path, O_RDONLY);

 	if (fd == -1)

 		return FALSE;

 	ret = read(fd, buf, sizeof(buf)-1);

 	close(fd);

 	if (ret <= 0)

 		return FALSE;

 	buf[ret] = '\0';

 	return strstr(buf, "PRIVATE KEY---") != NULL;

 }

 static void ssl_proxy_ctx_init(SSL_CTX *ssl_ctx)

 {

 	const char *cafile;

 	SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL);

 	cafile = getenv("SSL_CA_FILE");

 	if (cafile != NULL) {

 		if (SSL_CTX_load_verify_locations(ssl_ctx, cafile, NULL) != 1) {

 			i_fatal("Can't load CA file %s: %s",

 				cafile, ssl_last_error());

 		}

 	}

 	if (verbose_ssl)

 		SSL_CTX_set_info_callback(ssl_ctx, ssl_info_callback);

 	if (SSL_CTX_need_tmp_RSA(ssl_ctx))

 		SSL_CTX_set_tmp_rsa_callback(ssl_ctx, ssl_gen_rsa_key);

 	SSL_CTX_set_tmp_dh_callback(ssl_ctx, ssl_tmp_dh_callback);

 }

 static void ssl_proxy_ctx_verify_client(SSL_CTX *ssl_ctx)

 {

 	const char *cafile;

 #if OPENSSL_VERSION_NUMBER >= 0x00907000L

 	X509_STORE *store;

 	store = SSL_CTX_get_cert_store(ssl_ctx);

 	X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK |

 			     X509_V_FLAG_CRL_CHECK_ALL);

 #endif

 	cafile = getenv("SSL_CA_FILE");

 	SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE,

 			   ssl_verify_client_cert);

 	SSL_CTX_set_client_CA_list(ssl_ctx, SSL_load_client_CA_file(cafile));

 }

 static void ssl_proxy_init_server(const char *certfile, const char *keyfile)

 {

 	const char *cipher_list, *username_field;

 	char *password;

 	unsigned long err;

 	password = getenv("SSL_KEY_PASSWORD");

 	if ((ssl_server_ctx = SSL_CTX_new(SSLv23_server_method())) == NULL)

 		i_fatal("SSL_CTX_new() failed");

 	ssl_proxy_ctx_init(ssl_server_ctx);

 	cipher_list = getenv("SSL_CIPHER_LIST");

 	if (cipher_list == NULL)

 		cipher_list = DOVECOT_SSL_DEFAULT_CIPHER_LIST;

 	if (SSL_CTX_set_cipher_list(ssl_server_ctx, cipher_list) != 1) {

 		i_fatal("Can't set cipher list to '%s': %s",

 			cipher_list, ssl_last_error());

 	}

 	if (SSL_CTX_use_certificate_chain_file(ssl_server_ctx, certfile) != 1) {

 		err = ERR_peek_error();

 		if (ERR_GET_LIB(err) != ERR_LIB_PEM ||

 		    ERR_GET_REASON(err) != PEM_R_NO_START_LINE) {

 			i_fatal("Can't load certificate file %s: %s",

 				certfile, ssl_last_error());

 		} else if (is_pem_key_file(certfile)) {

 			i_fatal("Can't load certificate file %s: "

 				"The file contains a private key "

 				"(you've mixed ssl_cert_file and ssl_key_file settings)",

 				certfile);

 		} else {

 			i_fatal("Can't load certificate file %s: "

 				"The file doesn't contain a certificate.",

 				certfile);

 		}

 	}

         SSL_CTX_set_default_passwd_cb(ssl_server_ctx, pem_password_callback);

         SSL_CTX_set_default_passwd_cb_userdata(ssl_server_ctx, password);

 	if (SSL_CTX_use_PrivateKey_file(ssl_server_ctx, keyfile,

 					SSL_FILETYPE_PEM) != 1) {

 		err = ERR_peek_error();

 		if (ERR_GET_LIB(err) == ERR_LIB_X509 &&

 		    ERR_GET_REASON(err) == X509_R_KEY_VALUES_MISMATCH) {

 			i_fatal("Can't load private key file %s: "

 				"Key is for a different cert than %s",

 				keyfile, certfile);

 		} else {

 			i_fatal("Can't load private key file %s: %s",

 				keyfile, ssl_last_error());

 		}

 	}

 	if (getenv("SSL_VERIFY_CLIENT_CERT") != NULL)

 		ssl_proxy_ctx_verify_client(ssl_server_ctx);

 	username_field = getenv("SSL_CERT_USERNAME_FIELD");

 	if (username_field == NULL)

 		ssl_username_nid = NID_commonName;

 	else {

 		ssl_username_nid = OBJ_txt2nid(username_field);

 		if (ssl_username_nid == NID_undef) {

 			i_fatal("Invalid ssl_cert_username_field: %s",

 				username_field);

 		}

 	}

 }

 static void ssl_proxy_init_client(void)

 {

 	if ((ssl_client_ctx = SSL_CTX_new(SSLv23_client_method())) == NULL)

 		i_fatal("SSL_CTX_new() failed");

 	ssl_proxy_ctx_init(ssl_client_ctx);

 	ssl_proxy_ctx_verify_client(ssl_client_ctx);

 }

 void ssl_proxy_init(void)

 {

 	static char dovecot[] = "dovecot";

 	const char *certfile, *keyfile;

 	unsigned char buf;

 	memset(&ssl_params, 0, sizeof(ssl_params));

 	certfile = getenv("SSL_CERT_FILE");

 	keyfile = getenv("SSL_KEY_FILE");

 	ssl_params.fname = getenv("SSL_PARAM_FILE");

 	if (certfile == NULL || keyfile == NULL || ssl_params.fname == NULL) {

 		/* SSL support is disabled */

 		return;

 	}

 	SSL_library_init();

 	SSL_load_error_strings();

 	extdata_index = SSL_get_ex_new_index(0, dovecot, NULL, NULL, NULL);

 	ssl_proxy_init_server(certfile, keyfile);

 	ssl_proxy_init_client();

 	/* PRNG initialization might want to use /dev/urandom, make sure it

 	   does it before chrooting. We might not have enough entropy at

 	   the first try, so this function may fail. It's still been

 	   initialized though. */

 	(void)RAND_bytes(&buf, 1);

 	ssl_proxy_count = 0;

         ssl_proxies = NULL;

 	ssl_initialized = TRUE;

 }

 void ssl_proxy_deinit(void)

 {

 	if (!ssl_initialized)

 		return;

 	while (ssl_proxies != NULL)

 		ssl_proxy_destroy(ssl_proxies);

 	ssl_free_parameters(&ssl_params);

 	SSL_CTX_free(ssl_server_ctx);

 	SSL_CTX_free(ssl_client_ctx);

 	EVP_cleanup();

 	ERR_free_strings();

 }

 #endif