test/src/client.c

   1 /* A little hacked up program that makes a TCP/IP call and reads a script to
   2 drive it, for testing Exim server code running as a daemon. It's got a bit
   3 messy with the addition of support for either OpenSSL or GnuTLS. The code for
   4 those was hacked out of Exim itself, then code for OpenSSL OCSP stapling was
   5 ripped from the openssl ocsp and s_client utilities. */
   6
   7 /* ANSI C standard includes */
   8
   9 #include <ctype.h>
  10 #include <signal.h>
  11 #include <stdarg.h>
  12 #include <stddef.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <time.h>
  17
  18 /* Unix includes */
  19
  20 #include <errno.h>
  21 #include <dirent.h>
  22 #include <sys/types.h>
  23
  24 #include <netinet/in_systm.h>
  25 #include <netinet/in.h>
  26 #include <netinet/ip.h>
  27
  28 #include <netdb.h>
  29 #include <arpa/inet.h>
  30 #include <sys/time.h>
  31 #include <sys/resource.h>
  32 #include <sys/socket.h>
  33 #include <sys/stat.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <utime.h>
  37
  38 #ifdef AF_INET6
  39 #define HAVE_IPV6 1
  40 #endif
  41
  42 #ifndef S_ADDR_TYPE
  43 #define S_ADDR_TYPE u_long
  44 #endif
  45
  46 typedef unsigned char uschar;
  47
  48 #define CS   (char *)
  49 #define US   (unsigned char *)
  50
  51 #define FALSE         0
  52 #define TRUE          1
  53
  54
  55
  56 static int sigalrm_seen = 0;
  57
  58
  59 /* TLS support can be optionally included, either for OpenSSL or GnuTLS. The
  60 latter needs a whole pile of tables. */
  61 #ifdef HAVE_OPENSSL
  62 # define HAVE_TLS
  63 # include <openssl/crypto.h>
  64 # include <openssl/x509.h>
  65 # include <openssl/pem.h>
  66 # include <openssl/ssl.h>
  67 # include <openssl/err.h>
  68 # include <openssl/rand.h>
  69
  70 # if OPENSSL_VERSION_NUMBER < 0x0090806fL && !defined(DISABLE_OCSP) && !defined(OPENSSL_NO_TLSEXT)
  71 #  warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
  72 #  define DISABLE_OCSP
  73 # endif
  74 # ifndef DISABLE_OCSP
  75 #  include <openssl/ocsp.h>
  76 # endif
  77 #endif
  78
  79
  80 #ifdef HAVE_GNUTLS
  81 # define HAVE_TLS
  82 # include <gnutls/gnutls.h>
  83 # include <gnutls/x509.h>
  84 # if GNUTLS_VERSION_NUMBER >= 0x030103
  85 #  define HAVE_OCSP
  86 #  include <gnutls/ocsp.h>
  87 # endif
  88 # ifndef GNUTLS_NO_EXTENSIONS
  89 #  define GNUTLS_NO_EXTENSIONS 0
  90 # endif
  91
  92 # define DH_BITS      768
  93
  94 /* Local static variables for GNUTLS */
  95
  96 static gnutls_dh_params dh_params = NULL;
  97
  98 static gnutls_certificate_credentials_t x509_cred = NULL;
  99 static gnutls_session tls_session = NULL;
 100
 101 static int  ssl_session_timeout = 200;
 102
 103 /* Priorities for TLS algorithms to use. */
 104
 105 static const int protocol_priority[16] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 };
 106
 107 static const int kx_priority[16] = {
 108   GNUTLS_KX_RSA,
 109   GNUTLS_KX_DHE_DSS,
 110   GNUTLS_KX_DHE_RSA,
 111   0 };
 112
 113 static int default_cipher_priority[16] = {
 114   GNUTLS_CIPHER_AES_256_CBC,
 115   GNUTLS_CIPHER_AES_128_CBC,
 116   GNUTLS_CIPHER_3DES_CBC,
 117   GNUTLS_CIPHER_ARCFOUR_128,
 118   0 };
 119
 120 static const int mac_priority[16] = {
 121   GNUTLS_MAC_SHA,
 122   GNUTLS_MAC_MD5,
 123   0 };
 124
 125 static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
 126 static const int cert_type_priority[16] = { GNUTLS_CRT_X509, 0 };
 127
 128 #endif  /*HAVE_GNUTLS*/
 129
 130
 131
 132 #ifdef HAVE_TLS
 133 char * ocsp_stapling = NULL;
 134 #endif
 135
 136
 137 /*************************************************
 138 *            SIGALRM handler - crash out         *
 139 *************************************************/
 140
 141 static void
 142 sigalrm_handler_crash(int sig)
 143 {
 144 sig = sig;    /* Keep picky compilers happy */
 145 printf("\nClient timed out\n");
 146 exit(99);
 147 }
 148
 149
 150 /*************************************************
 151 *            SIGALRM handler - set flag          *
 152 *************************************************/
 153
 154 static void
 155 sigalrm_handler_flag(int sig)
 156 {
 157 sig = sig;    /* Keep picky compilers happy */
 158 sigalrm_seen = 1;
 159 }
 160
 161
 162
 163 /****************************************************************************/
 164 /****************************************************************************/
 165
 166 #ifdef HAVE_OPENSSL
 167
 168 X509_STORE *
 169 setup_verify(BIO *bp, char *CAfile, char *CApath)
 170 {
 171         X509_STORE *store;
 172         X509_LOOKUP *lookup;
 173         if(!(store = X509_STORE_new())) goto end;
 174         lookup=X509_STORE_add_lookup(store,X509_LOOKUP_file());
 175         if (lookup == NULL) goto end;
 176         if (CAfile) {
 177                 if(!X509_LOOKUP_load_file(lookup,CAfile,X509_FILETYPE_PEM)) {
 178                         BIO_printf(bp, "Error loading file %s\n", CAfile);
 179                         goto end;
 180                 }
 181         } else X509_LOOKUP_load_file(lookup,NULL,X509_FILETYPE_DEFAULT);
 182
 183         lookup=X509_STORE_add_lookup(store,X509_LOOKUP_hash_dir());
 184         if (lookup == NULL) goto end;
 185         if (CApath) {
 186                 if(!X509_LOOKUP_add_dir(lookup,CApath,X509_FILETYPE_PEM)) {
 187                         BIO_printf(bp, "Error loading directory %s\n", CApath);
 188                         goto end;
 189                 }
 190         } else X509_LOOKUP_add_dir(lookup,NULL,X509_FILETYPE_DEFAULT);
 191
 192         ERR_clear_error();
 193         return store;
 194         end:
 195         X509_STORE_free(store);
 196         return NULL;
 197 }
 198
 199
 200 #ifndef DISABLE_OCSP
 201 static int
 202 tls_client_stapling_cb(SSL *s, void *arg)
 203 {
 204 const unsigned char *p;
 205 int len;
 206 OCSP_RESPONSE *rsp;
 207 OCSP_BASICRESP *bs;
 208 char *CAfile = NULL;
 209 X509_STORE *store = NULL;
 210 int ret = 1;
 211
 212 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
 213 /*BIO_printf(arg, "OCSP response: ");*/
 214 if (!p)
 215         {
 216         BIO_printf(arg, "no response received\n");
 217         return 1;
 218         }
 219 if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
 220         {
 221         BIO_printf(arg, "response parse error\n");
 222         BIO_dump_indent(arg, (char *)p, len, 4);
 223         return 0;
 224         }
 225 if(!(bs = OCSP_response_get1_basic(rsp)))
 226   {
 227   BIO_printf(arg, "error parsing response\n");
 228   return 0;
 229   }
 230
 231 CAfile = ocsp_stapling;
 232 if(!(store = setup_verify(arg, CAfile, NULL)))
 233   {
 234   BIO_printf(arg, "error in cert setup\n");
 235   return 0;
 236   }
 237
 238 /* No file of alternate certs, no options */
 239 if(OCSP_basic_verify(bs, NULL, store, 0) <= 0)
 240   {
 241   BIO_printf(arg, "Response Verify Failure\n");
 242   ERR_print_errors(arg);
 243   ret = 0;
 244   }
 245 else
 246   BIO_printf(arg, "Response verify OK\n");
 247
 248 X509_STORE_free(store);
 249 return ret;
 250 }
 251 #endif
 252
 253
 254 /*************************************************
 255 *         Start an OpenSSL TLS session           *
 256 *************************************************/
 257
 258 int
 259 tls_start(int sock, SSL **ssl, SSL_CTX *ctx)
 260 {
 261 int rc;
 262 static const unsigned char *sid_ctx = US"exim";
 263
 264 RAND_load_file("client.c", -1);   /* Not *very* random! */
 265
 266 *ssl = SSL_new (ctx);
 267 SSL_set_session_id_context(*ssl, sid_ctx, strlen(CS sid_ctx));
 268 SSL_set_fd (*ssl, sock);
 269 SSL_set_connect_state(*ssl);
 270
 271 #ifndef DISABLE_OCSP
 272 if (ocsp_stapling)
 273   {
 274   SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
 275   SSL_CTX_set_tlsext_status_arg(ctx, BIO_new_fp(stdout, BIO_NOCLOSE));
 276   SSL_set_tlsext_status_type(*ssl, TLSEXT_STATUSTYPE_ocsp);
 277   }
 278 #endif
 279
 280 signal(SIGALRM, sigalrm_handler_flag);
 281 sigalrm_seen = 0;
 282 alarm(5);
 283 rc = SSL_connect (*ssl);
 284 alarm(0);
 285
 286 if (sigalrm_seen)
 287   {
 288   printf("SSL_connect timed out\n");
 289   return 0;
 290   }
 291
 292 if (rc <= 0)
 293   {
 294   ERR_print_errors_fp(stdout);
 295   return 0;
 296   }
 297
 298 printf("SSL connection using %s\n", SSL_get_cipher (*ssl));
 299 return 1;
 300 }
 301
 302
 303 /*************************************************
 304 *           SSL Information callback             *
 305 *************************************************/
 306
 307 static void
 308 info_callback(SSL *s, int where, int ret)
 309 {
 310 where = where;
 311 ret = ret;
 312 printf("SSL info: %s\n", SSL_state_string_long(s));
 313 }
 314 #endif
 315
 316
 317 /****************************************************************************/
 318 /****************************************************************************/
 319
 320
 321 #ifdef HAVE_GNUTLS
 322 /*************************************************
 323 *            Handle GnuTLS error                 *
 324 *************************************************/
 325
 326 /* Called from lots of places when errors occur before actually starting to do
 327 the TLS handshake, that is, while the session is still in clear.
 328
 329 Argument:
 330   prefix    prefix text
 331   err       a GnuTLS error number, or 0 if local error
 332
 333 Returns:    doesn't - it dies
 334 */
 335
 336 static void
 337 gnutls_error(uschar *prefix, int err)
 338 {
 339 fprintf(stderr, "GnuTLS connection error: %s:", prefix);
 340 if (err != 0) fprintf(stderr, " %s", gnutls_strerror(err));
 341 fprintf(stderr, "\n");
 342 exit(98);
 343 }
 344
 345
 346
 347 /*************************************************
 348 *             Setup up DH parameters             *
 349 *************************************************/
 350
 351 /* For the test suite, the parameters should always be available in the spool
 352 directory. */
 353
 354 static void
 355 init_dh(void)
 356 {
 357 int fd;
 358 int ret;
 359 gnutls_datum m;
 360 uschar filename[200];
 361 struct stat statbuf;
 362
 363 /* Initialize the data structures for holding the parameters */
 364
 365 ret = gnutls_dh_params_init(&dh_params);
 366 if (ret < 0) gnutls_error(US"init dh_params", ret);
 367
 368 /* Open the cache file for reading and if successful, read it and set up the
 369 parameters. */
 370
 371 fd = open("aux-fixed/gnutls-params", O_RDONLY, 0);
 372 if (fd < 0)
 373   {
 374   fprintf(stderr, "Failed to open spool/gnutls-params: %s\n", strerror(errno));
 375   exit(97);
 376   }
 377
 378 if (fstat(fd, &statbuf) < 0)
 379   {
 380   (void)close(fd);
 381   return gnutls_error(US"TLS cache stat failed", 0);
 382   }
 383
 384 m.size = statbuf.st_size;
 385 m.data = malloc(m.size);
 386 if (m.data == NULL)
 387   return gnutls_error(US"memory allocation failed", 0);
 388 if (read(fd, m.data, m.size) != m.size)
 389   return gnutls_error(US"TLS cache read failed", 0);
 390 (void)close(fd);
 391
 392 ret = gnutls_dh_params_import_pkcs3(dh_params, &m, GNUTLS_X509_FMT_PEM);
 393 if (ret < 0) return gnutls_error(US"DH params import", ret);
 394 free(m.data);
 395 }
 396
 397
 398
 399
 400 /*************************************************
 401 *            Initialize for GnuTLS               *
 402 *************************************************/
 403
 404 /*
 405 Arguments:
 406   certificate     certificate file
 407   privatekey      private key file
 408 */
 409
 410 static void
 411 tls_init(uschar *certificate, uschar *privatekey)
 412 {
 413 int rc;
 414
 415 rc = gnutls_global_init();
 416 if (rc < 0) gnutls_error(US"gnutls_global_init", rc);
 417
 418 /* Read D-H parameters from the cache file. */
 419
 420 init_dh();
 421
 422 /* Create the credentials structure */
 423
 424 rc = gnutls_certificate_allocate_credentials(&x509_cred);
 425 if (rc < 0) gnutls_error(US"certificate_allocate_credentials", rc);
 426
 427 /* Set the certificate and private keys */
 428
 429 if (certificate != NULL)
 430   {
 431   rc = gnutls_certificate_set_x509_key_file(x509_cred, CS certificate,
 432     CS privatekey, GNUTLS_X509_FMT_PEM);
 433   if (rc < 0) gnutls_error("gnutls_certificate", rc);
 434   }
 435
 436 /* Associate the parameters with the x509 credentials structure. */
 437
 438 gnutls_certificate_set_dh_params(x509_cred, dh_params);
 439
 440 /* set the CA info for server-cert verify */
 441 if (ocsp_stapling)
 442   gnutls_certificate_set_x509_trust_file(x509_cred, ocsp_stapling,
 443         GNUTLS_X509_FMT_PEM);
 444 }
 445
 446
 447
 448 /*************************************************
 449 *        Initialize a single GNUTLS session      *
 450 *************************************************/
 451
 452 static gnutls_session
 453 tls_session_init(void)
 454 {
 455 gnutls_session session;
 456
 457 gnutls_init(&session, GNUTLS_CLIENT | GNUTLS_NO_EXTENSIONS);
 458
 459 gnutls_cipher_set_priority(session, default_cipher_priority);
 460 gnutls_compression_set_priority(session, comp_priority);
 461 gnutls_kx_set_priority(session, kx_priority);
 462 gnutls_protocol_set_priority(session, protocol_priority);
 463 gnutls_mac_set_priority(session, mac_priority);
 464
 465 gnutls_cred_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
 466
 467 gnutls_dh_set_prime_bits(session, DH_BITS);
 468 gnutls_db_set_cache_expiration(session, ssl_session_timeout);
 469
 470 return session;
 471 }
 472 #endif
 473
 474
 475 /****************************************************************************/
 476 /****************************************************************************/
 477
 478
 479
 480
 481 /*************************************************
 482 *                 Main Program                   *
 483 *************************************************/
 484
 485 const char * const HELP_MESSAGE = "\n\
 486 Usage: client\n"
 487 #ifdef HAVE_TLS
 488 "\
 489           [-tls-on-connect]\n\
 490           [-ocsp]\n"
 491 #endif
 492 "\
 493           [-tn] n seconds timeout\n\
 494           <IP address>\n\
 495           <port>\n\
 496           [<outgoing interface>]\n\
 497           [<cert file>]\n\
 498           [<key file>]\n\
 499 \n";
 500
 501 int main(int argc, char **argv)
 502 {
 503 struct sockaddr *s_ptr;
 504 struct sockaddr_in s_in4;
 505 char *interface = NULL;
 506 char *address = NULL;
 507 char *certfile = NULL;
 508 char *keyfile = NULL;
 509 char *end = NULL;
 510 int argi = 1;
 511 int host_af, port, s_len, rc, sock, save_errno;
 512 int timeout = 5;
 513 int tls_active = 0;
 514 int sent_starttls = 0;
 515 int tls_on_connect = 0;
 516 long tmplong;
 517
 518 #if HAVE_IPV6
 519 struct sockaddr_in6 s_in6;
 520 #endif
 521
 522 #ifdef HAVE_OPENSSL
 523 SSL_CTX* ctx;
 524 SSL*     ssl;
 525 #endif
 526
 527 unsigned char outbuffer[10240];
 528 unsigned char inbuffer[10240];
 529 unsigned char *inptr = inbuffer;
 530
 531 *inptr = 0;   /* Buffer empty */
 532
 533 /* Options */
 534
 535 while (argc >= argi + 1 && argv[argi][0] == '-')
 536   {
 537   if (strcmp(argv[argi], "-help") == 0 ||
 538       strcmp(argv[argi], "--help") == 0 ||
 539       strcmp(argv[argi], "-h") == 0)
 540     {
 541     puts(HELP_MESSAGE);
 542     exit(0);
 543     }
 544   if (strcmp(argv[argi], "-tls-on-connect") == 0)
 545     {
 546     tls_on_connect = 1;
 547     argi++;
 548     }
 549 #ifdef HAVE_TLS
 550   else if (strcmp(argv[argi], "-ocsp") == 0)
 551     {
 552     if (argc < ++argi + 1)
 553       {
 554       fprintf(stderr, "Missing required certificate file for ocsp option\n");
 555       exit(96);
 556       }
 557     ocsp_stapling = argv[argi++];
 558     }
 559
 560 #endif
 561   else if (argv[argi][1] == 't' && isdigit(argv[argi][2]))
 562     {
 563     tmplong = strtol(argv[argi]+2, &end, 10);
 564     if (end == argv[argi]+2 || *end)
 565       {
 566       fprintf(stderr, "Failed to parse seconds from option <%s>\n",
 567         argv[argi]);
 568       exit(95);
 569       }
 570     if (tmplong > 10000L)
 571       {
 572       fprintf(stderr, "Unreasonably long wait of %ld seconds requested\n",
 573         tmplong);
 574       exit(94);
 575       }
 576     if (tmplong < 0L)
 577       {
 578       fprintf(stderr, "Timeout must not be negative (%ld)\n", tmplong);
 579       exit(93);
 580       }
 581     timeout = (int) tmplong;
 582     argi++;
 583     }
 584   else
 585     {
 586     fprintf(stderr, "Unrecognized option %s\n", argv[argi]);
 587     exit(92);
 588     }
 589   }
 590
 591 /* Mandatory 1st arg is IP address */
 592
 593 if (argc < argi+1)
 594   {
 595   fprintf(stderr, "No IP address given\n");
 596   exit(91);
 597   }
 598
 599 address = argv[argi++];
 600 host_af = (strchr(address, ':') != NULL)? AF_INET6 : AF_INET;
 601
 602 /* Mandatory 2nd arg is port */
 603
 604 if (argc < argi+1)
 605   {
 606   fprintf(stderr, "No port number given\n");
 607   exit(90);
 608   }
 609
 610 port = atoi(argv[argi++]);
 611
 612 /* Optional next arg is interface */
 613
 614 if (argc > argi &&
 615   (isdigit((unsigned char)argv[argi][0]) || argv[argi][0] == ':'))
 616     interface = argv[argi++];
 617
 618 /* Any more arguments are the name of a certificate file and key file */
 619
 620 if (argc > argi) certfile = argv[argi++];
 621 if (argc > argi) keyfile = argv[argi++];
 622
 623
 624 #if HAVE_IPV6
 625 /* For an IPv6 address, use an IPv6 sockaddr structure. */
 626
 627 if (host_af == AF_INET6)
 628   {
 629   s_ptr = (struct sockaddr *)&s_in6;
 630   s_len = sizeof(s_in6);
 631   }
 632 else
 633 #endif
 634
 635 /* For an IPv4 address, use an IPv4 sockaddr structure,
 636 even on an IPv6 system. */
 637
 638   {
 639   s_ptr = (struct sockaddr *)&s_in4;
 640   s_len = sizeof(s_in4);
 641   }
 642
 643 printf("Connecting to %s port %d ... ", address, port);
 644
 645 sock = socket(host_af, SOCK_STREAM, 0);
 646 if (sock < 0)
 647   {
 648   printf("socket creation failed: %s\n", strerror(errno));
 649   exit(89);
 650   }
 651
 652 /* Bind to a specific interface if requested. On an IPv6 system, this has
 653 to be of the same family as the address we are calling. On an IPv4 system the
 654 test is redundant, but it keeps the code tidier. */
 655
 656 if (interface != NULL)
 657   {
 658   int interface_af = (strchr(interface, ':') != NULL)? AF_INET6 : AF_INET;
 659
 660   if (interface_af == host_af)
 661     {
 662     #if HAVE_IPV6
 663
 664     /* Set up for IPv6 binding */
 665
 666     if (host_af == AF_INET6)
 667       {
 668       memset(&s_in6, 0, sizeof(s_in6));
 669       s_in6.sin6_family = AF_INET6;
 670       s_in6.sin6_port = 0;
 671       if (inet_pton(AF_INET6, interface, &s_in6.sin6_addr) != 1)
 672         {
 673         printf("Unable to parse \"%s\"", interface);
 674         exit(88);
 675         }
 676       }
 677     else
 678     #endif
 679
 680     /* Set up for IPv4 binding */
 681
 682       {
 683       memset(&s_in4, 0, sizeof(s_in4));
 684       s_in4.sin_family = AF_INET;
 685       s_in4.sin_port = 0;
 686       s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(interface);
 687       }
 688
 689     /* Bind */
 690
 691     if (bind(sock, s_ptr, s_len) < 0)
 692       {
 693       printf("Unable to bind outgoing SMTP call to %s: %s",
 694         interface, strerror(errno));
 695       exit(87);
 696       }
 697     }
 698   }
 699
 700 /* Set up a remote IPv6 address */
 701
 702 #if HAVE_IPV6
 703 if (host_af == AF_INET6)
 704   {
 705   memset(&s_in6, 0, sizeof(s_in6));
 706   s_in6.sin6_family = AF_INET6;
 707   s_in6.sin6_port = htons(port);
 708   if (inet_pton(host_af, address, &s_in6.sin6_addr) != 1)
 709     {
 710     printf("Unable to parse \"%s\"", address);
 711     exit(86);
 712     }
 713   }
 714 else
 715 #endif
 716
 717 /* Set up a remote IPv4 address */
 718
 719   {
 720   memset(&s_in4, 0, sizeof(s_in4));
 721   s_in4.sin_family = AF_INET;
 722   s_in4.sin_port = htons(port);
 723   s_in4.sin_addr.s_addr = (S_ADDR_TYPE)inet_addr(address);
 724   }
 725
 726 /* SIGALRM handler crashes out */
 727
 728 signal(SIGALRM, sigalrm_handler_crash);
 729 alarm(timeout);
 730 rc = connect(sock, s_ptr, s_len);
 731 save_errno = errno;
 732 alarm(0);
 733
 734 /* A failure whose error code is "Interrupted system call" is in fact
 735 an externally applied timeout if the signal handler has been run. */
 736
 737 if (rc < 0)
 738   {
 739   close(sock);
 740   printf("connect failed: %s\n", strerror(save_errno));
 741   exit(85);
 742   }
 743
 744 printf("connected\n");
 745
 746
 747 /* --------------- Set up for OpenSSL --------------- */
 748
 749 #ifdef HAVE_OPENSSL
 750 SSL_library_init();
 751 SSL_load_error_strings();
 752
 753 ctx = SSL_CTX_new(SSLv23_method());
 754 if (ctx == NULL)
 755   {
 756   printf ("SSL_CTX_new failed\n");
 757   exit(84);
 758   }
 759
 760 if (certfile != NULL)
 761   {
 762   if (!SSL_CTX_use_certificate_file(ctx, certfile, SSL_FILETYPE_PEM))
 763     {
 764     printf("SSL_CTX_use_certificate_file failed\n");
 765     exit(83);
 766     }
 767   printf("Certificate file = %s\n", certfile);
 768   }
 769
 770 if (keyfile != NULL)
 771   {
 772   if (!SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM))
 773     {
 774     printf("SSL_CTX_use_PrivateKey_file failed\n");
 775     exit(82);
 776     }
 777   printf("Key file = %s\n", keyfile);
 778   }
 779
 780 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_BOTH);
 781 SSL_CTX_set_timeout(ctx, 200);
 782 SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
 783 #endif
 784
 785
 786 /* --------------- Set up for GnuTLS --------------- */
 787
 788 #ifdef HAVE_GNUTLS
 789 if (certfile != NULL) printf("Certificate file = %s\n", certfile);
 790 if (keyfile != NULL) printf("Key file = %s\n", keyfile);
 791 tls_init(certfile, keyfile);
 792 tls_session = tls_session_init();
 793 #ifdef HAVE_OCSP
 794 if (ocsp_stapling)
 795   gnutls_ocsp_status_request_enable_client(tls_session, NULL, 0, NULL);
 796 #endif
 797 gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr)sock);
 798
 799 /* When the server asks for a certificate and the client does not have one,
 800 there is a SIGPIPE error in the gnutls_handshake() function for some reason
 801 that is not understood. As luck would have it, this has never hit Exim itself
 802 because it ignores SIGPIPE errors. Doing the same here allows it all to work as
 803 one wants. */
 804
 805 signal(SIGPIPE, SIG_IGN);
 806 #endif
 807
 808 /* ---------------------------------------------- */
 809
 810
 811 /* Start TLS session if configured to do so without STARTTLS */
 812
 813 #ifdef HAVE_TLS
 814 if (tls_on_connect)
 815   {
 816   printf("Attempting to start TLS\n");
 817
 818   #ifdef HAVE_OPENSSL
 819   tls_active = tls_start(sock, &ssl, ctx);
 820   #endif
 821
 822   #ifdef HAVE_GNUTLS
 823   sigalrm_seen = FALSE;
 824   alarm(timeout);
 825   tls_active = gnutls_handshake(tls_session) >= 0;
 826   alarm(0);
 827   #endif
 828
 829   if (!tls_active)
 830     printf("Failed to start TLS\n");
 831   #if defined(HAVE_GNUTLS) && defined(HAVE_OCSP)
 832   else if (  ocsp_stapling
 833           && gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
 834     printf("Failed to verify certificate status\n");
 835   #endif
 836   else
 837     printf("Succeeded in starting TLS\n");
 838   }
 839 #endif
 840
 841 while (fgets(CS outbuffer, sizeof(outbuffer), stdin) != NULL)
 842   {
 843   int n = (int)strlen(CS outbuffer);
 844
 845   /* Strip trailing newline */
 846   if (outbuffer[n-1] == '\n') outbuffer[--n] = 0;
 847
 848   /* Expect incoming */
 849
 850   if (strncmp(CS outbuffer, "??? ", 4) == 0)
 851     {
 852     unsigned char *lineptr;
 853     printf("%s\n", outbuffer);
 854
 855     if (*inptr == 0)   /* Refill input buffer */
 856       {
 857       if (tls_active)
 858         {
 859         #ifdef HAVE_OPENSSL
 860         rc = SSL_read (ssl, inbuffer, sizeof(inbuffer) - 1);
 861         #endif
 862         #ifdef HAVE_GNUTLS
 863         rc = gnutls_record_recv(tls_session, CS inbuffer, sizeof(inbuffer) - 1);
 864         #endif
 865         }
 866       else
 867         {
 868         alarm(timeout);
 869         rc = read(sock, inbuffer, sizeof(inbuffer));
 870         alarm(0);
 871         }
 872
 873       if (rc < 0)
 874         {
 875         printf("Read error %s\n", strerror(errno));
 876         exit(81)  ;
 877         }
 878       else if (rc == 0)
 879         {
 880         printf("Unexpected EOF read\n");
 881         close(sock);
 882         exit(80);
 883         }
 884       else
 885         {
 886         inbuffer[rc] = 0;
 887         inptr = inbuffer;
 888         }
 889       }
 890
 891     lineptr = inptr;
 892     while (*inptr != 0 && *inptr != '\r' && *inptr != '\n') inptr++;
 893     if (*inptr != 0)
 894       {
 895       *inptr++ = 0;
 896       if (*inptr == '\n') inptr++;
 897       }
 898
 899     printf("<<< %s\n", lineptr);
 900     if (strncmp(CS lineptr, CS outbuffer + 4, (int)strlen(CS outbuffer) - 4) != 0)
 901       {
 902       printf("\n******** Input mismatch ********\n");
 903       exit(79);
 904       }
 905
 906     #ifdef HAVE_TLS
 907     if (sent_starttls)
 908       {
 909       if (lineptr[0] == '2')
 910         {
 911 int rc;
 912         unsigned int verify;
 913
 914         printf("Attempting to start TLS\n");
 915         fflush(stdout);
 916
 917         #ifdef HAVE_OPENSSL
 918         tls_active = tls_start(sock, &ssl, ctx);
 919         #endif
 920
 921         #ifdef HAVE_GNUTLS
 922         sigalrm_seen = FALSE;
 923         alarm(timeout);
 924         tls_active = gnutls_handshake(tls_session) >= 0;
 925         alarm(0);
 926         #endif
 927
 928         if (!tls_active)
 929           {
 930           printf("Failed to start TLS\n");
 931           fflush(stdout);
 932           }
 933         #ifdef HAVE_GNUTLS
 934         else if (ocsp_stapling)
 935           {
 936           if ((rc= gnutls_certificate_verify_peers2(tls_session, &verify)) < 0)
 937             {
 938             printf("Failed to verify certificate: %s\n", gnutls_strerror(rc));
 939             fflush(stdout);
 940             }
 941           else if (verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED))
 942             {
 943             printf("Bad certificate\n");
 944             fflush(stdout);
 945             }
 946           #ifdef HAVE_OCSP
 947           else if (gnutls_ocsp_status_request_is_checked(tls_session, 0) == 0)
 948             {
 949             printf("Failed to verify certificate status\n");
 950               {
 951               gnutls_datum_t stapling;
 952               gnutls_ocsp_resp_t resp;
 953               gnutls_datum_t printed;
 954               if (  (rc= gnutls_ocsp_status_request_get(tls_session, &stapling)) == 0
 955                  && (rc= gnutls_ocsp_resp_init(&resp)) == 0
 956                  && (rc= gnutls_ocsp_resp_import(resp, &stapling)) == 0
 957                  && (rc= gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_FULL, &printed)) == 0
 958                  )
 959                 {
 960                 fprintf(stderr, "%.4096s", printed.data);
 961                 gnutls_free(printed.data);
 962                 }
 963               else
 964                 (void) fprintf(stderr,"ocsp decode: %s", gnutls_strerror(rc));
 965               }
 966             fflush(stdout);
 967             }
 968           #endif
 969           }
 970         #endif
 971         else
 972           printf("Succeeded in starting TLS\n");
 973         }
 974       else printf("Abandoning TLS start attempt\n");
 975       }
 976     sent_starttls = 0;
 977     #endif
 978     }
 979
 980   /* Wait for a bit before proceeding */
 981
 982   else if (strncmp(CS outbuffer, "+++ ", 4) == 0)
 983     {
 984     printf("%s\n", outbuffer);
 985     sleep(atoi(CS outbuffer + 4));
 986     }
 987
 988   /* Send outgoing, but barf if unconsumed incoming */
 989
 990   else
 991     {
 992     unsigned char *escape;
 993
 994     if (*inptr != 0)
 995       {
 996       printf("Unconsumed input: %s", inptr);
 997       printf("   About to send: %s\n", outbuffer);
 998       exit(78);
 999       }
1000
1001     #ifdef HAVE_TLS
1002
1003     /* Shutdown TLS */
1004
1005     if (strcmp(CS outbuffer, "stoptls") == 0 ||
1006         strcmp(CS outbuffer, "STOPTLS") == 0)
1007       {
1008       if (!tls_active)
1009         {
1010         printf("STOPTLS read when TLS not active\n");
1011         exit(77);
1012         }
1013       printf("Shutting down TLS encryption\n");
1014
1015       #ifdef HAVE_OPENSSL
1016       SSL_shutdown(ssl);
1017       SSL_free(ssl);
1018       #endif
1019
1020       #ifdef HAVE_GNUTLS
1021       gnutls_bye(tls_session, GNUTLS_SHUT_WR);
1022       gnutls_deinit(tls_session);
1023       tls_session = NULL;
1024       gnutls_global_deinit();
1025       #endif
1026
1027       tls_active = 0;
1028       continue;
1029       }
1030
1031     /* Remember that we sent STARTTLS */
1032
1033     sent_starttls = (strcmp(CS outbuffer, "starttls") == 0 ||
1034                      strcmp(CS outbuffer, "STARTTLS") == 0);
1035
1036     /* Fudge: if the command is "starttls_wait", we send the starttls bit,
1037     but we haven't set the flag, so that there is no negotiation. This is for
1038     testing the server's timeout. */
1039
1040     if (strcmp(CS outbuffer, "starttls_wait") == 0)
1041       {
1042       outbuffer[8] = 0;
1043       n = 8;
1044       }
1045     #endif
1046
1047     printf(">>> %s\n", outbuffer);
1048     strcpy(CS outbuffer + n, "\r\n");
1049
1050     /* Turn "\n" and "\r" into the relevant characters. This is a hack. */
1051
1052     while ((escape = US strstr(CS outbuffer, "\\r")) != NULL)
1053       {
1054       *escape = '\r';
1055       memmove(escape + 1, escape + 2,  (n + 2) - (escape - outbuffer) - 2);
1056       n--;
1057       }
1058
1059     while ((escape = US strstr(CS outbuffer, "\\n")) != NULL)
1060       {
1061       *escape = '\n';
1062       memmove(escape + 1, escape + 2,  (n + 2) - (escape - outbuffer) - 2);
1063       n--;
1064       }
1065
1066     /* OK, do it */
1067
1068     alarm(timeout);
1069     if (tls_active)
1070       {
1071       #ifdef HAVE_OPENSSL
1072         rc = SSL_write (ssl, outbuffer, n + 2);
1073       #endif
1074       #ifdef HAVE_GNUTLS
1075         rc = gnutls_record_send(tls_session, CS outbuffer, n + 2);
1076         if (rc < 0)
1077           {
1078           printf("GnuTLS write error: %s\n", gnutls_strerror(rc));
1079           exit(76);
1080           }
1081       #endif
1082       }
1083     else
1084       {
1085       rc = write(sock, outbuffer, n + 2);
1086       }
1087     alarm(0);
1088
1089     if (rc < 0)
1090       {
1091       printf("Write error: %s\n", strerror(errno));
1092       exit(75);
1093       }
1094     }
1095   }
1096
1097 printf("End of script\n");
1098 close(sock);
1099
1100 exit(0);
1101 }
1102
1103 /* End of client.c */