granicus.if.org Git - postgresql/blob - src/interfaces/libpq/fe-secure.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * fe-secure.c
   4  *        functions related to setting up a secure connection to the backend.
   5  *        Secure connections are expected to provide confidentiality,
   6  *        message integrity and endpoint authentication.
   7  *
   8  *
   9  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
  10  * Portions Copyright (c) 1994, Regents of the University of California
  11  *
  12  *
  13  * IDENTIFICATION
  14  *        $PostgreSQL: pgsql/src/interfaces/libpq/fe-secure.c,v 1.115 2009/01/01 17:24:03 momjian Exp $
  15  *
  16  * NOTES
  17  *
  18  *        We don't provide informational callbacks here (like
  19  *        info_cb() in be-secure.c), since there's mechanism to
  20  *        display that information to the client.
  21  *
  22  *-------------------------------------------------------------------------
  23  */
  24
  25 #include "postgres_fe.h"
  26
  27 #include <signal.h>
  28 #include <fcntl.h>
  29 #include <ctype.h>
  30
  31 #include "libpq-fe.h"
  32 #include "fe-auth.h"
  33 #include "pqsignal.h"
  34
  35 #ifdef WIN32
  36 #include "win32.h"
  37 #else
  38 #include <sys/socket.h>
  39 #include <unistd.h>
  40 #include <netdb.h>
  41 #include <netinet/in.h>
  42 #ifdef HAVE_NETINET_TCP_H
  43 #include <netinet/tcp.h>
  44 #endif
  45 #include <arpa/inet.h>
  46 #endif
  47
  48 #include <sys/stat.h>
  49
  50 #ifdef ENABLE_THREAD_SAFETY
  51 #ifdef WIN32
  52 #include "pthread-win32.h"
  53 #else
  54 #include <pthread.h>
  55 #endif
  56 #endif
  57
  58 #ifdef USE_SSL
  59
  60 #include <openssl/ssl.h>
  61 #include <openssl/bio.h>
  62 #if (SSLEAY_VERSION_NUMBER >= 0x00907000L)
  63 #include <openssl/conf.h>
  64 #endif
  65 #if (SSLEAY_VERSION_NUMBER >= 0x00907000L) && !defined(OPENSSL_NO_ENGINE)
  66 #include <openssl/engine.h>
  67 #endif
  68
  69
  70 #ifndef WIN32
  71 #define USER_CERT_FILE          ".postgresql/postgresql.crt"
  72 #define USER_KEY_FILE           ".postgresql/postgresql.key"
  73 #define ROOT_CERT_FILE          ".postgresql/root.crt"
  74 #define ROOT_CRL_FILE           ".postgresql/root.crl"
  75 #else
  76 /* On Windows, the "home" directory is already PostgreSQL-specific */
  77 #define USER_CERT_FILE          "postgresql.crt"
  78 #define USER_KEY_FILE           "postgresql.key"
  79 #define ROOT_CERT_FILE          "root.crt"
  80 #define ROOT_CRL_FILE           "root.crl"
  81 #endif
  82
  83 #ifndef HAVE_ERR_SET_MARK
  84 /* These don't exist in OpenSSL before 0.9.8 */
  85 #define ERR_set_mark()          ((void) 0)
  86 #define ERR_pop_to_mark()       ((void) 0)
  87 #endif
  88
  89 static bool verify_peer_name_matches_certificate(PGconn *);
  90 static int      verify_cb(int ok, X509_STORE_CTX *ctx);
  91 static int      client_cert_cb(SSL *, X509 **, EVP_PKEY **);
  92 static int      init_ssl_system(PGconn *conn);
  93 static void destroy_ssl_system(void);
  94 static int      initialize_SSL(PGconn *);
  95 static void destroySSL(void);
  96 static PostgresPollingStatusType open_client_SSL(PGconn *);
  97 static void close_SSL(PGconn *);
  98 static char *SSLerrmessage(void);
  99 static void SSLerrfree(char *buf);
 100
 101 static bool pq_initssllib = true;
 102 static SSL_CTX *SSL_context = NULL;
 103
 104 #ifdef ENABLE_THREAD_SAFETY
 105 static int ssl_open_connections = 0;
 106
 107 #ifndef WIN32
 108 static pthread_mutex_t ssl_config_mutex = PTHREAD_MUTEX_INITIALIZER;
 109 #else
 110 static pthread_mutex_t ssl_config_mutex = NULL;
 111 static long win32_ssl_create_mutex = 0;
 112 #endif
 113
 114 #endif  /* ENABLE_THREAD_SAFETY */
 115
 116 #endif /* SSL */
 117
 118
 119 /*
 120  * Macros to handle disabling and then restoring the state of SIGPIPE handling.
 121  * Note that DISABLE_SIGPIPE() must appear at the start of a block.
 122  */
 123
 124 #ifndef WIN32
 125 #ifdef ENABLE_THREAD_SAFETY
 126
 127 #define DISABLE_SIGPIPE(failaction) \
 128         sigset_t        osigmask; \
 129         bool            sigpipe_pending; \
 130         bool            got_epipe = false; \
 131 \
 132         if (pq_block_sigpipe(&osigmask, &sigpipe_pending) < 0) \
 133                 failaction
 134
 135 #define REMEMBER_EPIPE(cond) \
 136         do { \
 137                 if (cond) \
 138                         got_epipe = true; \
 139         } while (0)
 140
 141 #define RESTORE_SIGPIPE() \
 142         pq_reset_sigpipe(&osigmask, sigpipe_pending, got_epipe)
 143
 144 #else   /* !ENABLE_THREAD_SAFETY */
 145
 146 #define DISABLE_SIGPIPE(failaction) \
 147         pqsigfunc       oldsighandler = pqsignal(SIGPIPE, SIG_IGN)
 148
 149 #define REMEMBER_EPIPE(cond)
 150
 151 #define RESTORE_SIGPIPE() \
 152         pqsignal(SIGPIPE, oldsighandler)
 153
 154 #endif  /* ENABLE_THREAD_SAFETY */
 155 #else   /* WIN32 */
 156
 157 #define DISABLE_SIGPIPE(failaction)
 158 #define REMEMBER_EPIPE(cond)
 159 #define RESTORE_SIGPIPE()
 160
 161 #endif  /* WIN32 */
 162
 163 /* ------------------------------------------------------------ */
 164 /*                       Procedures common to all secure sessions                       */
 165 /* ------------------------------------------------------------ */
 166
 167
 168 /*
 169  *      Exported function to allow application to tell us it's already
 170  *      initialized OpenSSL.
 171  */
 172 void
 173 PQinitSSL(int do_init)
 174 {
 175 #ifdef USE_SSL
 176         pq_initssllib = do_init;
 177 #endif
 178 }
 179
 180 /*
 181  *      Initialize global context
 182  */
 183 int
 184 pqsecure_initialize(PGconn *conn)
 185 {
 186         int                     r = 0;
 187
 188 #ifdef USE_SSL
 189         r = initialize_SSL(conn);
 190 #endif
 191
 192         return r;
 193 }
 194
 195 /*
 196  *      Destroy global context
 197  */
 198 void
 199 pqsecure_destroy(void)
 200 {
 201 #ifdef USE_SSL
 202         destroySSL();
 203 #endif
 204 }
 205
 206 /*
 207  *      Attempt to negotiate secure session.
 208  */
 209 PostgresPollingStatusType
 210 pqsecure_open_client(PGconn *conn)
 211 {
 212 #ifdef USE_SSL
 213         /* First time through? */
 214         if (conn->ssl == NULL)
 215         {
 216                 if (!(conn->ssl = SSL_new(SSL_context)) ||
 217                         !SSL_set_app_data(conn->ssl, conn) ||
 218                         !SSL_set_fd(conn->ssl, conn->sock))
 219                 {
 220                         char       *err = SSLerrmessage();
 221
 222                         printfPQExpBuffer(&conn->errorMessage,
 223                                    libpq_gettext("could not establish SSL connection: %s\n"),
 224                                                           err);
 225                         SSLerrfree(err);
 226                         close_SSL(conn);
 227                         return PGRES_POLLING_FAILED;
 228                 }
 229
 230                 /*
 231                  * Initialize errorMessage to empty.  This allows open_client_SSL() to
 232                  * detect whether client_cert_cb() has stored a message.
 233                  */
 234                 resetPQExpBuffer(&conn->errorMessage);
 235         }
 236         /* Begin or continue the actual handshake */
 237         return open_client_SSL(conn);
 238 #else
 239         /* shouldn't get here */
 240         return PGRES_POLLING_FAILED;
 241 #endif
 242 }
 243
 244 /*
 245  *      Close secure session.
 246  */
 247 void
 248 pqsecure_close(PGconn *conn)
 249 {
 250 #ifdef USE_SSL
 251         if (conn->ssl)
 252                 close_SSL(conn);
 253 #endif
 254 }
 255
 256 /*
 257  *      Read data from a secure connection.
 258  */
 259 ssize_t
 260 pqsecure_read(PGconn *conn, void *ptr, size_t len)
 261 {
 262         ssize_t         n;
 263
 264 #ifdef USE_SSL
 265         if (conn->ssl)
 266         {
 267                 int                     err;
 268
 269                 /* SSL_read can write to the socket, so we need to disable SIGPIPE */
 270                 DISABLE_SIGPIPE(return -1);
 271
 272 rloop:
 273                 n = SSL_read(conn->ssl, ptr, len);
 274                 err = SSL_get_error(conn->ssl, n);
 275                 switch (err)
 276                 {
 277                         case SSL_ERROR_NONE:
 278                                 break;
 279                         case SSL_ERROR_WANT_READ:
 280                                 n = 0;
 281                                 break;
 282                         case SSL_ERROR_WANT_WRITE:
 283
 284                                 /*
 285                                  * Returning 0 here would cause caller to wait for read-ready,
 286                                  * which is not correct since what SSL wants is wait for
 287                                  * write-ready.  The former could get us stuck in an infinite
 288                                  * wait, so don't risk it; busy-loop instead.
 289                                  */
 290                                 goto rloop;
 291                         case SSL_ERROR_SYSCALL:
 292                                 {
 293                                         char            sebuf[256];
 294
 295                                         if (n == -1)
 296                                         {
 297                                                 REMEMBER_EPIPE(SOCK_ERRNO == EPIPE);
 298                                                 printfPQExpBuffer(&conn->errorMessage,
 299                                                                         libpq_gettext("SSL SYSCALL error: %s\n"),
 300                                                         SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
 301                                         }
 302                                         else
 303                                         {
 304                                                 printfPQExpBuffer(&conn->errorMessage,
 305                                                  libpq_gettext("SSL SYSCALL error: EOF detected\n"));
 306
 307                                                 SOCK_ERRNO_SET(ECONNRESET);
 308                                                 n = -1;
 309                                         }
 310                                         break;
 311                                 }
 312                         case SSL_ERROR_SSL:
 313                                 {
 314                                         char       *err = SSLerrmessage();
 315
 316                                         printfPQExpBuffer(&conn->errorMessage,
 317                                                                           libpq_gettext("SSL error: %s\n"), err);
 318                                         SSLerrfree(err);
 319                                 }
 320                                 /* fall through */
 321                         case SSL_ERROR_ZERO_RETURN:
 322                                 SOCK_ERRNO_SET(ECONNRESET);
 323                                 n = -1;
 324                                 break;
 325                         default:
 326                                 printfPQExpBuffer(&conn->errorMessage,
 327                                                   libpq_gettext("unrecognized SSL error code: %d\n"),
 328                                                                   err);
 329                                 n = -1;
 330                                 break;
 331                 }
 332
 333                 RESTORE_SIGPIPE();
 334         }
 335         else
 336 #endif
 337                 n = recv(conn->sock, ptr, len, 0);
 338
 339         return n;
 340 }
 341
 342 /*
 343  *      Write data to a secure connection.
 344  */
 345 ssize_t
 346 pqsecure_write(PGconn *conn, const void *ptr, size_t len)
 347 {
 348         ssize_t         n;
 349
 350         DISABLE_SIGPIPE(return -1);
 351
 352 #ifdef USE_SSL
 353         if (conn->ssl)
 354         {
 355                 int                     err;
 356
 357                 n = SSL_write(conn->ssl, ptr, len);
 358                 err = SSL_get_error(conn->ssl, n);
 359                 switch (err)
 360                 {
 361                         case SSL_ERROR_NONE:
 362                                 break;
 363                         case SSL_ERROR_WANT_READ:
 364
 365                                 /*
 366                                  * Returning 0 here causes caller to wait for write-ready,
 367                                  * which is not really the right thing, but it's the best we
 368                                  * can do.
 369                                  */
 370                                 n = 0;
 371                                 break;
 372                         case SSL_ERROR_WANT_WRITE:
 373                                 n = 0;
 374                                 break;
 375                         case SSL_ERROR_SYSCALL:
 376                                 {
 377                                         char            sebuf[256];
 378
 379                                         if (n == -1)
 380                                         {
 381                                                 REMEMBER_EPIPE(SOCK_ERRNO == EPIPE);
 382                                                 printfPQExpBuffer(&conn->errorMessage,
 383                                                                         libpq_gettext("SSL SYSCALL error: %s\n"),
 384                                                         SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
 385                                         }
 386                                         else
 387                                         {
 388                                                 printfPQExpBuffer(&conn->errorMessage,
 389                                                  libpq_gettext("SSL SYSCALL error: EOF detected\n"));
 390                                                 SOCK_ERRNO_SET(ECONNRESET);
 391                                                 n = -1;
 392                                         }
 393                                         break;
 394                                 }
 395                         case SSL_ERROR_SSL:
 396                                 {
 397                                         char       *err = SSLerrmessage();
 398
 399                                         printfPQExpBuffer(&conn->errorMessage,
 400                                                                           libpq_gettext("SSL error: %s\n"), err);
 401                                         SSLerrfree(err);
 402                                 }
 403                                 /* fall through */
 404                         case SSL_ERROR_ZERO_RETURN:
 405                                 SOCK_ERRNO_SET(ECONNRESET);
 406                                 n = -1;
 407                                 break;
 408                         default:
 409                                 printfPQExpBuffer(&conn->errorMessage,
 410                                                   libpq_gettext("unrecognized SSL error code: %d\n"),
 411                                                                   err);
 412                                 n = -1;
 413                                 break;
 414                 }
 415         }
 416         else
 417 #endif
 418         {
 419                 n = send(conn->sock, ptr, len, 0);
 420                 REMEMBER_EPIPE(n < 0 && SOCK_ERRNO == EPIPE);
 421         }
 422
 423         RESTORE_SIGPIPE();
 424
 425         return n;
 426 }
 427
 428 /* ------------------------------------------------------------ */
 429 /*                                                SSL specific code                                             */
 430 /* ------------------------------------------------------------ */
 431 #ifdef USE_SSL
 432
 433 /*
 434  *      Certificate verification callback
 435  *
 436  *      This callback allows us to log intermediate problems during
 437  *      verification, but there doesn't seem to be a clean way to get
 438  *      our PGconn * structure.  So we can't log anything!
 439  *
 440  *      This callback also allows us to override the default acceptance
 441  *      criteria (e.g., accepting self-signed or expired certs), but
 442  *      for now we accept the default checks.
 443  */
 444 static int
 445 verify_cb(int ok, X509_STORE_CTX *ctx)
 446 {
 447         return ok;
 448 }
 449
 450
 451 /*
 452  * Check if a wildcard certificate matches the server hostname.
 453  *
 454  * The rule for this is:
 455  *  1. We only match the '*' character as wildcard
 456  *  2. We match only wildcards at the start of the string
 457  *  3. The '*' character does *not* match '.', meaning that we match only
 458  *     a single pathname component.
 459  *  4. We don't support more than one '*' in a single pattern.
 460  *
 461  * This is roughly in line with RFC2818, but contrary to what most browsers
 462  * appear to be implementing (point 3 being the difference)
 463  *
 464  * Matching is always cone case-insensitive, since DNS is case insensitive.
 465  */
 466 static int
 467 wildcard_certificate_match(const char *pattern, const char *string)
 468 {
 469         int lenpat = strlen(pattern);
 470         int lenstr = strlen(string);
 471
 472         /* If we don't start with a wildcard, it's not a match (rule 1 & 2) */
 473         if (lenpat < 3 ||
 474                 pattern[0] != '*' ||
 475                 pattern[1] != '.')
 476                 return 0;
 477
 478         if (lenpat > lenstr)
 479                 /* If pattern is longer than the string, we can never match */
 480                 return 0;
 481
 482         if (pg_strcasecmp(pattern+1, string+lenstr-lenpat+1) != 0)
 483                 /* If string does not end in pattern (minus the wildcard), we don't match */
 484                 return 0;
 485
 486         if (strchr(string, '.') < string+lenstr-lenpat)
 487                 /* If there is a dot left of where the pattern started to match, we don't match (rule 3) */
 488                 return 0;
 489
 490         /* String ended with pattern, and didn't have a dot before, so we match */
 491         return 1;
 492 }
 493
 494
 495 /*
 496  *      Verify that common name resolves to peer.
 497  */
 498 static bool
 499 verify_peer_name_matches_certificate(PGconn *conn)
 500 {
 501         /*
 502          * If told not to verify the peer name, don't do it. Return
 503          * 0 indicating that the verification was successful.
 504          */
 505         if(strcmp(conn->sslverify, "cn") != 0)
 506                 return true;
 507
 508         if (conn->pghostaddr)
 509         {
 510                 printfPQExpBuffer(&conn->errorMessage,
 511                                                   libpq_gettext("verified SSL connections are only supported when connecting to a hostname"));
 512                 return false;
 513         }
 514         else
 515         {
 516                 /*
 517                  * Connect by hostname.
 518                  *
 519                  * XXX: Should support alternate names here
 520                  */
 521                 if (pg_strcasecmp(conn->peer_cn, conn->pghost) == 0)
 522                         /* Exact name match */
 523                         return true;
 524                 else if (wildcard_certificate_match(conn->peer_cn, conn->pghost))
 525                         /* Matched wildcard certificate */
 526                         return true;
 527                 else
 528                 {
 529                         printfPQExpBuffer(&conn->errorMessage,
 530                                                           libpq_gettext("server common name '%s' does not match hostname '%s'"),
 531                                                           conn->peer_cn, conn->pghost);
 532                         return false;
 533                 }
 534         }
 535 }
 536
 537 /*
 538  *      Callback used by SSL to load client cert and key.
 539  *      This callback is only called when the server wants a
 540  *      client cert.
 541  *
 542  *      Since BIO functions can set OpenSSL error codes, we must
 543  *      reset the OpenSSL error stack on *every* exit from this
 544  *      function once we've started using BIO.
 545  *
 546  *      Must return 1 on success, 0 on no data or error.
 547  */
 548 static int
 549 client_cert_cb(SSL *ssl, X509 **x509, EVP_PKEY **pkey)
 550 {
 551         char            homedir[MAXPGPATH];
 552         struct stat buf;
 553
 554 #ifndef WIN32
 555         struct stat buf2;
 556         FILE       *fp;
 557 #endif
 558         char            fnbuf[MAXPGPATH];
 559         BIO                *bio;
 560         PGconn     *conn = (PGconn *) SSL_get_app_data(ssl);
 561         char            sebuf[256];
 562
 563         if (!pqGetHomeDirectory(homedir, sizeof(homedir)))
 564         {
 565                 printfPQExpBuffer(&conn->errorMessage,
 566                                                   libpq_gettext("could not get user information\n"));
 567                 return 0;
 568         }
 569
 570         /* read the user certificate */
 571         if (conn->sslcert)
 572                 strncpy(fnbuf, conn->sslcert, sizeof(fnbuf));
 573         else
 574                 snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, USER_CERT_FILE);
 575
 576         /*
 577          * OpenSSL <= 0.9.8 lacks error stack handling, which means it's likely to
 578          * report wrong error messages if access to the cert file fails. Do our
 579          * own check for the readability of the file to catch the majority of such
 580          * problems before OpenSSL gets involved.
 581          */
 582 #ifndef HAVE_ERR_SET_MARK
 583         {
 584                 FILE       *fp2;
 585
 586                 if ((fp2 = fopen(fnbuf, "r")) == NULL)
 587                 {
 588                         printfPQExpBuffer(&conn->errorMessage,
 589                            libpq_gettext("could not open certificate file \"%s\": %s\n"),
 590                                                           fnbuf, pqStrerror(errno, sebuf, sizeof(sebuf)));
 591                         return 0;
 592                 }
 593                 fclose(fp2);
 594         }
 595 #endif
 596
 597         /* save OpenSSL error stack */
 598         ERR_set_mark();
 599
 600         if ((bio = BIO_new_file(fnbuf, "r")) == NULL)
 601         {
 602                 printfPQExpBuffer(&conn->errorMessage,
 603                            libpq_gettext("could not open certificate file \"%s\": %s\n"),
 604                                                   fnbuf, pqStrerror(errno, sebuf, sizeof(sebuf)));
 605                 ERR_pop_to_mark();
 606                 return 0;
 607         }
 608
 609         if (PEM_read_bio_X509(bio, x509, NULL, NULL) == NULL)
 610         {
 611                 char       *err = SSLerrmessage();
 612
 613                 printfPQExpBuffer(&conn->errorMessage,
 614                            libpq_gettext("could not read certificate file \"%s\": %s\n"),
 615                                                   fnbuf, err);
 616                 SSLerrfree(err);
 617                 BIO_free(bio);
 618                 ERR_pop_to_mark();
 619                 return 0;
 620         }
 621
 622         BIO_free(bio);
 623
 624         /*
 625          * Read the SSL key. If a key is specified, treat it as an engine:key combination
 626          * if there is colon present - we don't support files with colon in the name. The
 627          * exception is if the second character is a colon, in which case it can be a Windows
 628          * filename with drive specification.
 629          */
 630         if (conn->sslkey && strlen(conn->sslkey) > 0)
 631         {
 632 #if (SSLEAY_VERSION_NUMBER >= 0x00907000L) && !defined(OPENSSL_NO_ENGINE)
 633                 if (strchr(conn->sslkey, ':')
 634 #ifdef WIN32
 635                         && conn->sslkey[1] != ':'
 636 #endif
 637                    )
 638                 {
 639                         /* Colon, but not in second character, treat as engine:key */
 640                         ENGINE     *engine_ptr;
 641                         char       *engine_str = strdup(conn->sslkey);
 642                         char       *engine_colon = strchr(engine_str, ':');
 643
 644                         *engine_colon = '\0';   /* engine_str now has engine name */
 645                         engine_colon++;                 /* engine_colon now has key name */
 646
 647                         engine_ptr = ENGINE_by_id(engine_str);
 648                         if (engine_ptr == NULL)
 649                         {
 650                                 char       *err = SSLerrmessage();
 651
 652                                 printfPQExpBuffer(&conn->errorMessage,
 653                                                                   libpq_gettext("could not load SSL engine \"%s\": %s\n"),
 654                                                                   engine_str, err);
 655                                 SSLerrfree(err);
 656                                 free(engine_str);
 657                                 ERR_pop_to_mark();
 658                                 return 0;
 659                         }
 660
 661                         *pkey = ENGINE_load_private_key(engine_ptr, engine_colon,
 662                                                                                         NULL, NULL);
 663                         if (*pkey == NULL)
 664                         {
 665                                 char       *err = SSLerrmessage();
 666
 667                                 printfPQExpBuffer(&conn->errorMessage,
 668                                                                   libpq_gettext("could not read private SSL key \"%s\" from engine \"%s\": %s\n"),
 669                                                                   engine_colon, engine_str, err);
 670                                 SSLerrfree(err);
 671                                 free(engine_str);
 672                                 ERR_pop_to_mark();
 673                                 return 0;
 674                         }
 675                         free(engine_str);
 676
 677                         fnbuf[0] = '\0'; /* indicate we're not going to load from a file */
 678                 }
 679                 else
 680 #endif /* support for SSL engines */
 681                 {
 682                         /* PGSSLKEY is not an engine, treat it as a filename */
 683                         strncpy(fnbuf, conn->sslkey, sizeof(fnbuf));
 684                 }
 685         }
 686         else
 687         {
 688                 /* No PGSSLKEY specified, load default file */
 689                 snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, USER_KEY_FILE);
 690         }
 691
 692         if (fnbuf[0] != '\0')
 693         {
 694                 /* read the user key from file */
 695
 696                 if (stat(fnbuf, &buf) != 0)
 697                 {
 698                         printfPQExpBuffer(&conn->errorMessage,
 699                                                           libpq_gettext("certificate present, but not private key file \"%s\"\n"),
 700                                                           fnbuf);
 701                         ERR_pop_to_mark();
 702                         return 0;
 703                 }
 704 #ifndef WIN32
 705                 if (!S_ISREG(buf.st_mode) || buf.st_mode & (S_IRWXG | S_IRWXO))
 706                 {
 707                         printfPQExpBuffer(&conn->errorMessage,
 708                         libpq_gettext("private key file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n"),
 709                                                           fnbuf);
 710                         ERR_pop_to_mark();
 711                         return 0;
 712                 }
 713 #endif
 714
 715                 if ((bio = BIO_new_file(fnbuf, "r")) == NULL)
 716                 {
 717                         printfPQExpBuffer(&conn->errorMessage,
 718                            libpq_gettext("could not open private key file \"%s\": %s\n"),
 719                                                           fnbuf, pqStrerror(errno, sebuf, sizeof(sebuf)));
 720                         ERR_pop_to_mark();
 721                         return 0;
 722                 }
 723 #ifndef WIN32
 724                 BIO_get_fp(bio, &fp);
 725                 if (fstat(fileno(fp), &buf2) == -1 ||
 726                         buf.st_dev != buf2.st_dev || buf.st_ino != buf2.st_ino)
 727                 {
 728                         printfPQExpBuffer(&conn->errorMessage,
 729                                                           libpq_gettext("private key file \"%s\" changed during execution\n"), fnbuf);
 730                         ERR_pop_to_mark();
 731                         return 0;
 732                 }
 733 #endif
 734
 735                 if (PEM_read_bio_PrivateKey(bio, pkey, NULL, NULL) == NULL)
 736                 {
 737                         char       *err = SSLerrmessage();
 738
 739                         printfPQExpBuffer(&conn->errorMessage,
 740                            libpq_gettext("could not read private key file \"%s\": %s\n"),
 741                                                           fnbuf, err);
 742                         SSLerrfree(err);
 743
 744                         BIO_free(bio);
 745                         ERR_pop_to_mark();
 746                         return 0;
 747                 }
 748
 749                 BIO_free(bio);
 750         }
 751
 752         /* verify that the cert and key go together */
 753         if (!X509_check_private_key(*x509, *pkey))
 754         {
 755                 char       *err = SSLerrmessage();
 756
 757                 printfPQExpBuffer(&conn->errorMessage,
 758                                                   libpq_gettext("certificate does not match private key file \"%s\": %s\n"),
 759                                                   fnbuf, err);
 760                 SSLerrfree(err);
 761                 ERR_pop_to_mark();
 762                 return 0;
 763         }
 764
 765         ERR_pop_to_mark();
 766
 767         return 1;
 768 }
 769
 770 #ifdef ENABLE_THREAD_SAFETY
 771 /*
 772  *      Callback functions for OpenSSL internal locking
 773  */
 774
 775 static unsigned long
 776 pq_threadidcallback(void)
 777 {
 778         /*
 779          * This is not standards-compliant.  pthread_self() returns pthread_t, and
 780          * shouldn't be cast to unsigned long, but CRYPTO_set_id_callback requires
 781          * it, so we have to do it.
 782          */
 783         return (unsigned long) pthread_self();
 784 }
 785
 786 static pthread_mutex_t *pq_lockarray;
 787
 788 static void
 789 pq_lockingcallback(int mode, int n, const char *file, int line)
 790 {
 791         if (mode & CRYPTO_LOCK)
 792         {
 793                 if (pthread_mutex_lock(&pq_lockarray[n]))
 794                         PGTHREAD_ERROR("failed to lock mutex");
 795         }
 796         else
 797         {
 798                 if (pthread_mutex_unlock(&pq_lockarray[n]))
 799                         PGTHREAD_ERROR("failed to unlock mutex");
 800         }
 801 }
 802 #endif   /* ENABLE_THREAD_SAFETY */
 803
 804 /*
 805  * Initialize SSL system. In threadsafe mode, this includes setting
 806  * up OpenSSL callback functions to do thread locking.
 807  *
 808  * If the caller has told us (through PQinitSSL) that he's taking care
 809  * of SSL, we expect that callbacks are already set, and won't try to
 810  * override it.
 811  *
 812  * The conn parameter is only used to be able to pass back an error
 813  * message - no connection local setup is made.
 814  */
 815 static int
 816 init_ssl_system(PGconn *conn)
 817 {
 818 #ifdef ENABLE_THREAD_SAFETY
 819 #ifdef WIN32
 820         /* Also see similar code in fe-connect.c, default_threadlock() */
 821         if (ssl_config_mutex == NULL)
 822         {
 823                 while (InterlockedExchange(&win32_ssl_create_mutex, 1) == 1)
 824                          /* loop, another thread own the lock */ ;
 825                 if (ssl_config_mutex == NULL)
 826                 {
 827                         if (pthread_mutex_init(&ssl_config_mutex, NULL))
 828                                 return -1;
 829                 }
 830                 InterlockedExchange(&win32_ssl_create_mutex, 0);
 831         }
 832 #endif
 833         if (pthread_mutex_lock(&ssl_config_mutex))
 834                 return -1;
 835
 836         if (pq_initssllib)
 837         {
 838                 /*
 839                  * If necessary, set up an array to hold locks for OpenSSL. OpenSSL will
 840                  * tell us how big to make this array.
 841                  */
 842                 if (pq_lockarray == NULL)
 843                 {
 844                         int i;
 845
 846                         pq_lockarray = malloc(sizeof(pthread_mutex_t) * CRYPTO_num_locks());
 847                         if (!pq_lockarray)
 848                         {
 849                                 pthread_mutex_unlock(&ssl_config_mutex);
 850                                 return -1;
 851                         }
 852                         for (i = 0; i < CRYPTO_num_locks(); i++)
 853                         {
 854                                 if (pthread_mutex_init(&pq_lockarray[i], NULL))
 855                                 {
 856                                         free(pq_lockarray);
 857                                         pq_lockarray = NULL;
 858                                         pthread_mutex_unlock(&ssl_config_mutex);
 859                                         return -1;
 860                                 }
 861                         }
 862                 }
 863
 864                 if (ssl_open_connections++ == 0)
 865                 {
 866                         /* These are only required for threaded SSL applications */
 867                         CRYPTO_set_id_callback(pq_threadidcallback);
 868                         CRYPTO_set_locking_callback(pq_lockingcallback);
 869                 }
 870         }
 871 #endif /* ENABLE_THREAD_SAFETY */
 872
 873         if (!SSL_context)
 874         {
 875                 if (pq_initssllib)
 876                 {
 877 #if SSLEAY_VERSION_NUMBER >= 0x00907000L
 878                         OPENSSL_config(NULL);
 879 #endif
 880                         SSL_library_init();
 881                         SSL_load_error_strings();
 882                 }
 883                 SSL_context = SSL_CTX_new(TLSv1_method());
 884                 if (!SSL_context)
 885                 {
 886                         char       *err = SSLerrmessage();
 887
 888                         printfPQExpBuffer(&conn->errorMessage,
 889                                                  libpq_gettext("could not create SSL context: %s\n"),
 890                                                           err);
 891                         SSLerrfree(err);
 892 #ifdef ENABLE_THREAD_SAFETY
 893                         pthread_mutex_unlock(&ssl_config_mutex);
 894 #endif
 895                         return -1;
 896                 }
 897         }
 898
 899 #ifdef ENABLE_THREAD_SAFETY
 900         pthread_mutex_unlock(&ssl_config_mutex);
 901 #endif
 902         return 0;
 903 }
 904
 905 /*
 906  *      This function is needed because if the libpq library is unloaded
 907  *      from the application, the callback functions will no longer exist when
 908  *      SSL used by other parts of the system.  For this reason,
 909  *      we unregister the SSL callback functions when the last libpq
 910  *      connection is closed.
 911  *
 912  *      Callbacks are only set when we're compiled in threadsafe mode, so
 913  *      we only need to remove them in this case.
 914  */
 915 static void
 916 destroy_ssl_system(void)
 917 {
 918 #ifdef ENABLE_THREAD_SAFETY
 919         /* Mutex is created in initialize_ssl_system() */
 920         if (pthread_mutex_lock(&ssl_config_mutex))
 921                 return;
 922
 923         if (pq_initssllib)
 924         {
 925                 if (ssl_open_connections > 0)
 926                         --ssl_open_connections;
 927
 928                 if (ssl_open_connections == 0)
 929                 {
 930                         /* No connections left, unregister all callbacks */
 931                         CRYPTO_set_locking_callback(NULL);
 932                         CRYPTO_set_id_callback(NULL);
 933
 934                         /*
 935                          * We don't free the lock array. If we get another connection
 936                          * from the same caller, we will just re-use it with the existing
 937                          * mutexes.
 938                          *
 939                          * This means we leak a little memory on repeated load/unload
 940                          * of the library.
 941                          */
 942                 }
 943         }
 944
 945         pthread_mutex_unlock(&ssl_config_mutex);
 946 #endif
 947         return;
 948 }
 949
 950 /*
 951  *      Initialize SSL context.
 952  */
 953 static int
 954 initialize_SSL(PGconn *conn)
 955 {
 956         struct stat buf;
 957         char            homedir[MAXPGPATH];
 958         char            fnbuf[MAXPGPATH];
 959
 960         if (init_ssl_system(conn))
 961                 return -1;
 962
 963         /*
 964          * If sslverify is set to anything other than "none", perform certificate
 965          * verification. If set to "cn" we will also do further verifications after
 966          * the connection has been completed.
 967          */
 968
 969         /* Set up to verify server cert, if root.crt is present */
 970         if (pqGetHomeDirectory(homedir, sizeof(homedir)))
 971         {
 972                 if (conn->sslrootcert)
 973                         strncpy(fnbuf, conn->sslrootcert, sizeof(fnbuf));
 974                 else
 975                         snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, ROOT_CERT_FILE);
 976
 977                 if (stat(fnbuf, &buf) == 0)
 978                 {
 979                         X509_STORE *cvstore;
 980
 981                         if (!SSL_CTX_load_verify_locations(SSL_context, fnbuf, NULL))
 982                         {
 983                                 char       *err = SSLerrmessage();
 984
 985                                 printfPQExpBuffer(&conn->errorMessage,
 986                                                                   libpq_gettext("could not read root certificate file \"%s\": %s\n"),
 987                                                                   fnbuf, err);
 988                                 SSLerrfree(err);
 989                                 return -1;
 990                         }
 991
 992                         if ((cvstore = SSL_CTX_get_cert_store(SSL_context)) != NULL)
 993                         {
 994                                 if (conn->sslcrl)
 995                                         strncpy(fnbuf, conn->sslcrl, sizeof(fnbuf));
 996                                 else
 997                                         snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, ROOT_CRL_FILE);
 998
 999                                 /* setting the flags to check against the complete CRL chain */
1000                                 if (X509_STORE_load_locations(cvstore, fnbuf, NULL) != 0)
1001 /* OpenSSL 0.96 does not support X509_V_FLAG_CRL_CHECK */
1002 #ifdef X509_V_FLAG_CRL_CHECK
1003                                         X509_STORE_set_flags(cvstore,
1004                                                   X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
1005                                 /* if not found, silently ignore;  we do not require CRL */
1006 #else
1007                                 {
1008                                         char       *err = SSLerrmessage();
1009
1010                                         printfPQExpBuffer(&conn->errorMessage,
1011                                                                           libpq_gettext("SSL library does not support CRL certificates (file \"%s\")\n"),
1012                                                                           fnbuf);
1013                                         SSLerrfree(err);
1014                                         return -1;
1015                                 }
1016 #endif
1017                         }
1018
1019                         SSL_CTX_set_verify(SSL_context, SSL_VERIFY_PEER, verify_cb);
1020                 }
1021                 else
1022                 {
1023                         if (strcmp(conn->sslverify, "none") != 0)
1024                         {
1025                                 printfPQExpBuffer(&conn->errorMessage,
1026                                                                   libpq_gettext("root certificate file (%s) not found"), fnbuf);
1027                                 return -1;
1028                         }
1029                 }
1030         }
1031         else
1032         {
1033                 if (strcmp(conn->sslverify, "none") != 0)
1034                 {
1035                         printfPQExpBuffer(&conn->errorMessage,
1036                                                           libpq_gettext("cannot find home directory to locate root certificate file"));
1037                         return -1;
1038                 }
1039         }
1040
1041         /* set up mechanism to provide client certificate, if available */
1042         SSL_CTX_set_client_cert_cb(SSL_context, client_cert_cb);
1043
1044         return 0;
1045 }
1046
1047 static void
1048 destroySSL(void)
1049 {
1050         destroy_ssl_system();
1051 }
1052
1053 /*
1054  *      Attempt to negotiate SSL connection.
1055  */
1056 static PostgresPollingStatusType
1057 open_client_SSL(PGconn *conn)
1058 {
1059         int                     r;
1060
1061         r = SSL_connect(conn->ssl);
1062         if (r <= 0)
1063         {
1064                 int                     err = SSL_get_error(conn->ssl, r);
1065
1066                 switch (err)
1067                 {
1068                         case SSL_ERROR_WANT_READ:
1069                                 return PGRES_POLLING_READING;
1070
1071                         case SSL_ERROR_WANT_WRITE:
1072                                 return PGRES_POLLING_WRITING;
1073
1074                         case SSL_ERROR_SYSCALL:
1075                                 {
1076                                         char            sebuf[256];
1077
1078                                         if (r == -1)
1079                                                 printfPQExpBuffer(&conn->errorMessage,
1080                                                                         libpq_gettext("SSL SYSCALL error: %s\n"),
1081                                                         SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf)));
1082                                         else
1083                                                 printfPQExpBuffer(&conn->errorMessage,
1084                                                  libpq_gettext("SSL SYSCALL error: EOF detected\n"));
1085                                         close_SSL(conn);
1086                                         return PGRES_POLLING_FAILED;
1087                                 }
1088                         case SSL_ERROR_SSL:
1089                                 {
1090                                         /*
1091                                          * If there are problems with the local certificate files,
1092                                          * these will be detected by client_cert_cb() which is
1093                                          * called from SSL_connect().  We want to return that
1094                                          * error message and not the rather unhelpful error that
1095                                          * OpenSSL itself returns.      So check to see if an error
1096                                          * message was already stored.
1097                                          */
1098                                         if (conn->errorMessage.len == 0)
1099                                         {
1100                                                 char       *err = SSLerrmessage();
1101
1102                                                 printfPQExpBuffer(&conn->errorMessage,
1103                                                                                   libpq_gettext("SSL error: %s\n"),
1104                                                                                   err);
1105                                                 SSLerrfree(err);
1106                                         }
1107                                         close_SSL(conn);
1108                                         return PGRES_POLLING_FAILED;
1109                                 }
1110
1111                         default:
1112                                 printfPQExpBuffer(&conn->errorMessage,
1113                                                   libpq_gettext("unrecognized SSL error code: %d\n"),
1114                                                                   err);
1115                                 close_SSL(conn);
1116                                 return PGRES_POLLING_FAILED;
1117                 }
1118         }
1119
1120         /*
1121          * We already checked the server certificate in initialize_SSL()
1122          * using SSL_CTX_set_verify() if root.crt exists.
1123          */
1124
1125         /* pull out server distinguished and common names */
1126         conn->peer = SSL_get_peer_certificate(conn->ssl);
1127         if (conn->peer == NULL)
1128         {
1129                 char       *err = SSLerrmessage();
1130
1131                 printfPQExpBuffer(&conn->errorMessage,
1132                                         libpq_gettext("certificate could not be obtained: %s\n"),
1133                                                   err);
1134                 SSLerrfree(err);
1135                 close_SSL(conn);
1136                 return PGRES_POLLING_FAILED;
1137         }
1138
1139         X509_NAME_oneline(X509_get_subject_name(conn->peer),
1140                                           conn->peer_dn, sizeof(conn->peer_dn));
1141         conn->peer_dn[sizeof(conn->peer_dn) - 1] = '\0';
1142
1143         X509_NAME_get_text_by_NID(X509_get_subject_name(conn->peer),
1144                                                           NID_commonName, conn->peer_cn, SM_USER);
1145         conn->peer_cn[SM_USER] = '\0';
1146
1147         if (!verify_peer_name_matches_certificate(conn))
1148         {
1149                 close_SSL(conn);
1150                 return PGRES_POLLING_FAILED;
1151         }
1152
1153         /* SSL handshake is complete */
1154         return PGRES_POLLING_OK;
1155 }
1156
1157 /*
1158  *      Close SSL connection.
1159  */
1160 static void
1161 close_SSL(PGconn *conn)
1162 {
1163         if (conn->ssl)
1164         {
1165                 DISABLE_SIGPIPE((void) 0);
1166                 SSL_shutdown(conn->ssl);
1167                 SSL_free(conn->ssl);
1168                 conn->ssl = NULL;
1169                 pqsecure_destroy();
1170                 /* We have to assume we got EPIPE */
1171                 REMEMBER_EPIPE(true);
1172                 RESTORE_SIGPIPE();
1173         }
1174
1175         if (conn->peer)
1176         {
1177                 X509_free(conn->peer);
1178                 conn->peer = NULL;
1179         }
1180 }
1181
1182 /*
1183  * Obtain reason string for last SSL error
1184  *
1185  * Some caution is needed here since ERR_reason_error_string will
1186  * return NULL if it doesn't recognize the error code.  We don't
1187  * want to return NULL ever.
1188  */
1189 static char ssl_nomem[] = "out of memory allocating error description";
1190
1191 #define SSL_ERR_LEN 128
1192
1193 static char *
1194 SSLerrmessage(void)
1195 {
1196         unsigned long errcode;
1197         const char *errreason;
1198         char       *errbuf;
1199
1200         errbuf = malloc(SSL_ERR_LEN);
1201         if (!errbuf)
1202                 return ssl_nomem;
1203         errcode = ERR_get_error();
1204         if (errcode == 0)
1205         {
1206                 snprintf(errbuf, SSL_ERR_LEN, libpq_gettext("no SSL error reported"));
1207                 return errbuf;
1208         }
1209         errreason = ERR_reason_error_string(errcode);
1210         if (errreason != NULL)
1211         {
1212                 strlcpy(errbuf, errreason, SSL_ERR_LEN);
1213                 return errbuf;
1214         }
1215         snprintf(errbuf, SSL_ERR_LEN, libpq_gettext("SSL error code %lu"), errcode);
1216         return errbuf;
1217 }
1218
1219 static void
1220 SSLerrfree(char *buf)
1221 {
1222         if (buf != ssl_nomem)
1223                 free(buf);
1224 }
1225
1226 /*
1227  *      Return pointer to OpenSSL object.
1228  */
1229 void *
1230 PQgetssl(PGconn *conn)
1231 {
1232         if (!conn)
1233                 return NULL;
1234         return conn->ssl;
1235 }
1236 #else                                                   /* !USE_SSL */
1237
1238 void *
1239 PQgetssl(PGconn *conn)
1240 {
1241         return NULL;
1242 }
1243 #endif   /* USE_SSL */
1244
1245
1246 #if defined(ENABLE_THREAD_SAFETY) && !defined(WIN32)
1247
1248 /*
1249  *      Block SIGPIPE for this thread.  This prevents send()/write() from exiting
1250  *      the application.
1251  */
1252 int
1253 pq_block_sigpipe(sigset_t *osigset, bool *sigpipe_pending)
1254 {
1255         sigset_t        sigpipe_sigset;
1256         sigset_t        sigset;
1257
1258         sigemptyset(&sigpipe_sigset);
1259         sigaddset(&sigpipe_sigset, SIGPIPE);
1260
1261         /* Block SIGPIPE and save previous mask for later reset */
1262         SOCK_ERRNO_SET(pthread_sigmask(SIG_BLOCK, &sigpipe_sigset, osigset));
1263         if (SOCK_ERRNO)
1264                 return -1;
1265
1266         /* We can have a pending SIGPIPE only if it was blocked before */
1267         if (sigismember(osigset, SIGPIPE))
1268         {
1269                 /* Is there a pending SIGPIPE? */
1270                 if (sigpending(&sigset) != 0)
1271                         return -1;
1272
1273                 if (sigismember(&sigset, SIGPIPE))
1274                         *sigpipe_pending = true;
1275                 else
1276                         *sigpipe_pending = false;
1277         }
1278         else
1279                 *sigpipe_pending = false;
1280
1281         return 0;
1282 }
1283
1284 /*
1285  *      Discard any pending SIGPIPE and reset the signal mask.
1286  *
1287  * Note: we are effectively assuming here that the C library doesn't queue
1288  * up multiple SIGPIPE events.  If it did, then we'd accidentally leave
1289  * ours in the queue when an event was already pending and we got another.
1290  * As long as it doesn't queue multiple events, we're OK because the caller
1291  * can't tell the difference.
1292  *
1293  * The caller should say got_epipe = FALSE if it is certain that it
1294  * didn't get an EPIPE error; in that case we'll skip the clear operation
1295  * and things are definitely OK, queuing or no.  If it got one or might have
1296  * gotten one, pass got_epipe = TRUE.
1297  *
1298  * We do not want this to change errno, since if it did that could lose
1299  * the error code from a preceding send().      We essentially assume that if
1300  * we were able to do pq_block_sigpipe(), this can't fail.
1301  */
1302 void
1303 pq_reset_sigpipe(sigset_t *osigset, bool sigpipe_pending, bool got_epipe)
1304 {
1305         int                     save_errno = SOCK_ERRNO;
1306         int                     signo;
1307         sigset_t        sigset;
1308
1309         /* Clear SIGPIPE only if none was pending */
1310         if (got_epipe && !sigpipe_pending)
1311         {
1312                 if (sigpending(&sigset) == 0 &&
1313                         sigismember(&sigset, SIGPIPE))
1314                 {
1315                         sigset_t        sigpipe_sigset;
1316
1317                         sigemptyset(&sigpipe_sigset);
1318                         sigaddset(&sigpipe_sigset, SIGPIPE);
1319
1320                         sigwait(&sigpipe_sigset, &signo);
1321                 }
1322         }
1323
1324         /* Restore saved block mask */
1325         pthread_sigmask(SIG_SETMASK, osigset, NULL);
1326
1327         SOCK_ERRNO_SET(save_errno);
1328 }
1329
1330 #endif   /* ENABLE_THREAD_SAFETY && !WIN32 */