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