/* A little hacked up program that makes a TCP/IP call and reads a script to
drive it, for testing Exim server code running as a daemon. It's got a bit
messy with the addition of support for either OpenSSL or GnuTLS. The code for
-those was hacked out of Exim itself. */
+those was hacked out of Exim itself, then code for OpenSSL OCSP stapling was
+ripped from the openssl ocsp and s_client utilities. */
/* ANSI C standard includes */
/* TLS support can be optionally included, either for OpenSSL or GnuTLS. The
latter needs a whole pile of tables. */
-
#ifdef HAVE_OPENSSL
-#define HAVE_TLS
-#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 HAVE_TLS
+# include <openssl/crypto.h>
+# include <openssl/x509.h>
+# include <openssl/pem.h>
+# include <openssl/ssl.h>
+# include <openssl/err.h>
+# include <openssl/rand.h>
+
+# if OPENSSL_VERSION_NUMBER < 0x0090806fL && !defined(DISABLE_OCSP) && !defined(OPENSSL_NO_TLSEXT)
+# warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
+# define DISABLE_OCSP
+# endif
+# ifndef DISABLE_OCSP
+# include <openssl/ocsp.h>
+# endif
#endif
#ifdef HAVE_GNUTLS
-#define HAVE_TLS
-#include <gnutls/gnutls.h>
-#include <gnutls/x509.h>
+# define HAVE_TLS
+# include <gnutls/gnutls.h>
+# include <gnutls/x509.h>
+# if GNUTLS_VERSION_NUMBER >= 0x030103
+# define HAVE_OCSP
+# include <gnutls/ocsp.h>
+# endif
-#define DH_BITS 768
+# define DH_BITS 768
/* Local static variables for GNUTLS */
static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
static const int cert_type_priority[16] = { GNUTLS_CRT_X509, 0 };
-#endif
+#endif /*HAVE_GNUTLS*/
+
+#ifdef HAVE_TLS
+char * ocsp_stapling = NULL;
+#endif
/*************************************************
/****************************************************************************/
#ifdef HAVE_OPENSSL
+
+X509_STORE *
+setup_verify(BIO *bp, char *CAfile, char *CApath)
+{
+ X509_STORE *store;
+ X509_LOOKUP *lookup;
+ if(!(store = X509_STORE_new())) goto end;
+ lookup=X509_STORE_add_lookup(store,X509_LOOKUP_file());
+ if (lookup == NULL) goto end;
+ if (CAfile) {
+ if(!X509_LOOKUP_load_file(lookup,CAfile,X509_FILETYPE_PEM)) {
+ BIO_printf(bp, "Error loading file %s\n", CAfile);
+ goto end;
+ }
+ } else X509_LOOKUP_load_file(lookup,NULL,X509_FILETYPE_DEFAULT);
+
+ lookup=X509_STORE_add_lookup(store,X509_LOOKUP_hash_dir());
+ if (lookup == NULL) goto end;
+ if (CApath) {
+ if(!X509_LOOKUP_add_dir(lookup,CApath,X509_FILETYPE_PEM)) {
+ BIO_printf(bp, "Error loading directory %s\n", CApath);
+ goto end;
+ }
+ } else X509_LOOKUP_add_dir(lookup,NULL,X509_FILETYPE_DEFAULT);
+
+ ERR_clear_error();
+ return store;
+ end:
+ X509_STORE_free(store);
+ return NULL;
+}
+
+
+#ifndef DISABLE_OCSP
+static int
+tls_client_stapling_cb(SSL *s, void *arg)
+{
+const unsigned char *p;
+int len;
+OCSP_RESPONSE *rsp;
+OCSP_BASICRESP *bs;
+char *CAfile = NULL;
+X509_STORE *store = NULL;
+int ret = 1;
+
+len = SSL_get_tlsext_status_ocsp_resp(s, &p);
+/*BIO_printf(arg, "OCSP response: ");*/
+if (!p)
+ {
+ BIO_printf(arg, "no response received\n");
+ return 1;
+ }
+if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
+ {
+ BIO_printf(arg, "response parse error\n");
+ BIO_dump_indent(arg, (char *)p, len, 4);
+ return 0;
+ }
+if(!(bs = OCSP_response_get1_basic(rsp)))
+ {
+ BIO_printf(arg, "error parsing response\n");
+ return 0;
+ }
+
+CAfile = ocsp_stapling;
+if(!(store = setup_verify(arg, CAfile, NULL)))
+ {
+ BIO_printf(arg, "error in cert setup\n");
+ return 0;
+ }
+
+/* No file of alternate certs, no options */
+if(OCSP_basic_verify(bs, NULL, store, 0) <= 0)
+ {
+ BIO_printf(arg, "Response Verify Failure\n");
+ ERR_print_errors(arg);
+ ret = 0;
+ }
+else
+ BIO_printf(arg, "Response verify OK\n");
+
+X509_STORE_free(store);
+return ret;
+}
+#endif
+
+
/*************************************************
* Start an OpenSSL TLS session *
*************************************************/
-int tls_start(int sock, SSL **ssl, SSL_CTX *ctx)
+int
+tls_start(int sock, SSL **ssl, SSL_CTX *ctx)
{
int rc;
-static const char *sid_ctx = "exim";
+static const unsigned char *sid_ctx = US"exim";
RAND_load_file("client.c", -1); /* Not *very* random! */
*ssl = SSL_new (ctx);
-SSL_set_session_id_context(*ssl, sid_ctx, strlen(sid_ctx));
+SSL_set_session_id_context(*ssl, sid_ctx, strlen(CS sid_ctx));
SSL_set_fd (*ssl, sock);
SSL_set_connect_state(*ssl);
+#ifndef DISABLE_OCSP
+if (ocsp_stapling)
+ {
+ SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
+ SSL_CTX_set_tlsext_status_arg(ctx, BIO_new_fp(stdout, BIO_NOCLOSE));
+ SSL_set_tlsext_status_type(*ssl, TLSEXT_STATUSTYPE_ocsp);
+ }
+#endif
+
signal(SIGALRM, sigalrm_handler_flag);
sigalrm_seen = 0;
alarm(5);
fprintf(stderr, "GnuTLS connection error: %s:", prefix);
if (err != 0) fprintf(stderr, " %s", gnutls_strerror(err));
fprintf(stderr, "\n");
-exit(1);
+exit(98);
}
if (fd < 0)
{
fprintf(stderr, "Failed to open spool/gnutls-params: %s\n", strerror(errno));
- exit(1);
+ exit(97);
}
if (fstat(fd, &statbuf) < 0)
/* Associate the parameters with the x509 credentials structure. */
gnutls_certificate_set_dh_params(x509_cred, dh_params);
+
+/* set the CA info for server-cert verify */
+if (ocsp_stapling)
+ gnutls_certificate_set_x509_trust_file(x509_cred, ocsp_stapling,
+ GNUTLS_X509_FMT_PEM);
}
*************************************************/
const char * const HELP_MESSAGE = "\n\
-Usage: client\n\
+Usage: client\n"
+#ifdef HAVE_TLS
+"\
+ [-tls-on-connect]\n\
+ [-ocsp]\n"
+#endif
+"\
+ [-tn] n seconds timeout\n\
<IP address>\n\
<port>\n\
[<outgoing interface>]\n\
char *end = NULL;
int argi = 1;
int host_af, port, s_len, rc, sock, save_errno;
-int timeout = 1;
+int timeout = 5;
int tls_active = 0;
int sent_starttls = 0;
int tls_on_connect = 0;
strcmp(argv[argi], "--help") == 0 ||
strcmp(argv[argi], "-h") == 0)
{
- printf(HELP_MESSAGE);
+ puts(HELP_MESSAGE);
exit(0);
}
if (strcmp(argv[argi], "-tls-on-connect") == 0)
tls_on_connect = 1;
argi++;
}
+#ifdef HAVE_TLS
+ else if (strcmp(argv[argi], "-ocsp") == 0)
+ {
+ if (argc < ++argi + 1)
+ {
+ fprintf(stderr, "Missing required certificate file for ocsp option\n");
+ exit(96);
+ }
+ ocsp_stapling = argv[argi++];
+ }
+
+#endif
else if (argv[argi][1] == 't' && isdigit(argv[argi][2]))
{
tmplong = strtol(argv[argi]+2, &end, 10);
{
fprintf(stderr, "Failed to parse seconds from option <%s>\n",
argv[argi]);
- exit(1);
+ exit(95);
}
if (tmplong > 10000L)
{
- fprintf(stderr, "Unreasonably long wait of %d seconds requested\n",
+ fprintf(stderr, "Unreasonably long wait of %ld seconds requested\n",
tmplong);
- exit(1);
+ exit(94);
}
if (tmplong < 0L)
{
- fprintf(stderr, "Timeout must not be negative (%d)\n", tmplong);
- exit(1);
+ fprintf(stderr, "Timeout must not be negative (%ld)\n", tmplong);
+ exit(93);
}
timeout = (int) tmplong;
argi++;
else
{
fprintf(stderr, "Unrecognized option %s\n", argv[argi]);
- exit(1);
+ exit(92);
}
}
if (argc < argi+1)
{
fprintf(stderr, "No IP address given\n");
- exit(1);
+ exit(91);
}
address = argv[argi++];
if (argc < argi+1)
{
fprintf(stderr, "No port number given\n");
- exit(1);
+ exit(90);
}
port = atoi(argv[argi++]);
if (sock < 0)
{
printf("socket creation failed: %s\n", strerror(errno));
- exit(1);
+ exit(89);
}
/* Bind to a specific interface if requested. On an IPv6 system, this has
if (inet_pton(AF_INET6, interface, &s_in6.sin6_addr) != 1)
{
printf("Unable to parse \"%s\"", interface);
- exit(1);
+ exit(88);
}
}
else
{
printf("Unable to bind outgoing SMTP call to %s: %s",
interface, strerror(errno));
- exit(1);
+ exit(87);
}
}
}
if (inet_pton(host_af, address, &s_in6.sin6_addr) != 1)
{
printf("Unable to parse \"%s\"", address);
- exit(1);
+ exit(86);
}
}
else
if (rc < 0)
{
close(sock);
- printf("failed: %s\n", strerror(save_errno));
- exit(1);
+ printf("connect failed: %s\n", strerror(save_errno));
+ exit(85);
}
printf("connected\n");
if (ctx == NULL)
{
printf ("SSL_CTX_new failed\n");
- exit(1);
+ exit(84);
}
if (certfile != NULL)
if (!SSL_CTX_use_certificate_file(ctx, certfile, SSL_FILETYPE_PEM))
{
printf("SSL_CTX_use_certificate_file failed\n");
- exit(1);
+ exit(83);
}
printf("Certificate file = %s\n", certfile);
}
if (!SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM))
{
printf("SSL_CTX_use_PrivateKey_file failed\n");
- exit(1);
+ exit(82);
}
printf("Key file = %s\n", keyfile);
}
if (keyfile != NULL) printf("Key file = %s\n", keyfile);
tls_init(certfile, keyfile);
tls_session = tls_session_init();
+#ifdef HAVE_OCSP
+if (ocsp_stapling)
+ gnutls_ocsp_status_request_enable_client(tls_session, NULL, 0, NULL);
+#endif
gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr)sock);
/* When the server asks for a certificate and the client does not have one,
if (!tls_active)
printf("Failed to start TLS\n");
+ #if defined(HAVE_GNUTLS) && defined(HAVE_OCSP)
+ else if ( ocsp_stapling
+ && gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
+ printf("Failed to verify certificate status\n");
+ #endif
else
printf("Succeeded in starting TLS\n");
}
#endif
-while (fgets(outbuffer, sizeof(outbuffer), stdin) != NULL)
+while (fgets(CS outbuffer, sizeof(outbuffer), stdin) != NULL)
{
- int n = (int)strlen(outbuffer);
+ int n = (int)strlen(CS outbuffer);
while (n > 0 && isspace(outbuffer[n-1])) n--;
outbuffer[n] = 0;
/* Expect incoming */
- if (strncmp(outbuffer, "??? ", 4) == 0)
+ if (strncmp(CS outbuffer, "??? ", 4) == 0)
{
unsigned char *lineptr;
printf("%s\n", outbuffer);
if (rc < 0)
{
printf("Read error %s\n", strerror(errno));
- exit(1) ;
+ exit(81) ;
}
else if (rc == 0)
{
printf("Unexpected EOF read\n");
close(sock);
- exit(1);
+ exit(80);
}
else
{
}
printf("<<< %s\n", lineptr);
- if (strncmp(lineptr, outbuffer + 4, (int)strlen(outbuffer) - 4) != 0)
+ if (strncmp(CS lineptr, CS outbuffer + 4, (int)strlen(CS outbuffer) - 4) != 0)
{
printf("\n******** Input mismatch ********\n");
- exit(1);
+ exit(79);
}
#ifdef HAVE_TLS
{
if (lineptr[0] == '2')
{
+int rc;
+ unsigned int verify;
+
printf("Attempting to start TLS\n");
fflush(stdout);
printf("Failed to start TLS\n");
fflush(stdout);
}
+ #ifdef HAVE_GNUTLS
+ else if (ocsp_stapling)
+ {
+ if ((rc= gnutls_certificate_verify_peers2(tls_session, &verify)) < 0)
+ {
+ printf("Failed to verify certificate: %s\n", gnutls_strerror(rc));
+ fflush(stdout);
+ }
+ else if (verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED))
+ {
+ printf("Bad certificate\n");
+ fflush(stdout);
+ }
+ #ifdef HAVE_OCSP
+ else if (gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
+ {
+ printf("Failed to verify certificate status\n");
+ {
+ gnutls_datum_t stapling;
+ gnutls_ocsp_resp_t resp;
+ gnutls_datum_t printed;
+ if ( (rc= gnutls_ocsp_status_request_get(tls_session, &stapling)) == 0
+ && (rc= gnutls_ocsp_resp_init(&resp)) == 0
+ && (rc= gnutls_ocsp_resp_import(resp, &stapling)) == 0
+ && (rc= gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_FULL, &printed)) == 0
+ )
+ {
+ fprintf(stderr, "%.4096s", printed.data);
+ gnutls_free(printed.data);
+ }
+ else
+ (void) fprintf(stderr,"ocsp decode: %s", gnutls_strerror(rc));
+ }
+ fflush(stdout);
+ }
+ #endif
+ }
+ #endif
else
printf("Succeeded in starting TLS\n");
}
/* Wait for a bit before proceeding */
- else if (strncmp(outbuffer, "+++ ", 4) == 0)
+ else if (strncmp(CS outbuffer, "+++ ", 4) == 0)
{
printf("%s\n", outbuffer);
- sleep(atoi(outbuffer + 4));
+ sleep(atoi(CS outbuffer + 4));
}
/* Send outgoing, but barf if unconsumed incoming */
{
printf("Unconsumed input: %s", inptr);
printf(" About to send: %s\n", outbuffer);
- exit(1);
+ exit(78);
}
#ifdef HAVE_TLS
/* Shutdown TLS */
- if (strcmp(outbuffer, "stoptls") == 0 ||
- strcmp(outbuffer, "STOPTLS") == 0)
+ if (strcmp(CS outbuffer, "stoptls") == 0 ||
+ strcmp(CS outbuffer, "STOPTLS") == 0)
{
if (!tls_active)
{
printf("STOPTLS read when TLS not active\n");
- exit(1);
+ exit(77);
}
printf("Shutting down TLS encryption\n");
/* Remember that we sent STARTTLS */
- sent_starttls = (strcmp(outbuffer, "starttls") == 0 ||
- strcmp(outbuffer, "STARTTLS") == 0);
+ sent_starttls = (strcmp(CS outbuffer, "starttls") == 0 ||
+ strcmp(CS outbuffer, "STARTTLS") == 0);
/* Fudge: if the command is "starttls_wait", we send the starttls bit,
but we haven't set the flag, so that there is no negotiation. This is for
testing the server's timeout. */
- if (strcmp(outbuffer, "starttls_wait") == 0)
+ if (strcmp(CS outbuffer, "starttls_wait") == 0)
{
outbuffer[8] = 0;
n = 8;
#endif
printf(">>> %s\n", outbuffer);
- strcpy(outbuffer + n, "\r\n");
+ strcpy(CS outbuffer + n, "\r\n");
/* Turn "\n" and "\r" into the relevant characters. This is a hack. */
- while ((escape = strstr(outbuffer, "\\r")) != NULL)
+ while ((escape = US strstr(CS outbuffer, "\\r")) != NULL)
{
*escape = '\r';
memmove(escape + 1, escape + 2, (n + 2) - (escape - outbuffer) - 2);
n--;
}
- while ((escape = strstr(outbuffer, "\\n")) != NULL)
+ while ((escape = US strstr(CS outbuffer, "\\n")) != NULL)
{
*escape = '\n';
memmove(escape + 1, escape + 2, (n + 2) - (escape - outbuffer) - 2);
if (rc < 0)
{
printf("GnuTLS write error: %s\n", gnutls_strerror(rc));
- exit(1);
+ exit(76);
}
#endif
}
if (rc < 0)
{
printf("Write error: %s\n", strerror(errno));
- exit(1);
+ exit(75);
}
}
}
git://git.exim.org / exim.git / blobdiff