cups/tls-gnutls.c

   1 /*
   2  * TLS support code for CUPS using GNU TLS.
   3  *
   4  * Copyright 2007-2016 by Apple Inc.
   5  * Copyright 1997-2007 by Easy Software Products, all rights reserved.
   6  *
   7  * These coded instructions, statements, and computer programs are the
   8  * property of Apple Inc. and are protected by Federal copyright
   9  * law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  10  * which should have been included with this file.  If this file is
  11  * missing or damaged, see the license at "http://www.cups.org/".
  12  *
  13  * This file is subject to the Apple OS-Developed Software exception.
  14  */
  15
  16 /**** This file is included from tls.c ****/
  17
  18 /*
  19  * Include necessary headers...
  20  */
  21
  22 #include <sys/stat.h>
  23
  24
  25 /*
  26  * Local globals...
  27  */
  28
  29 static int              tls_auto_create = 0;
  30                                         /* Auto-create self-signed certs? */
  31 static char             *tls_common_name = NULL;
  32                                         /* Default common name */
  33 static gnutls_x509_crl_t tls_crl = NULL;/* Certificate revocation list */
  34 static char             *tls_keypath = NULL;
  35                                         /* Server cert keychain path */
  36 static _cups_mutex_t    tls_mutex = _CUPS_MUTEX_INITIALIZER;
  37                                         /* Mutex for keychain/certs */
  38 static int              tls_options = -1;/* Options for TLS connections */
  39
  40
  41 /*
  42  * Local functions...
  43  */
  44
  45 static gnutls_x509_crt_t http_gnutls_create_credential(http_credential_t *credential);
  46 static const char       *http_gnutls_default_path(char *buffer, size_t bufsize);
  47 static void             http_gnutls_load_crl(void);
  48 static const char       *http_gnutls_make_path(char *buffer, size_t bufsize, const char *dirname, const char *filename, const char *ext);
  49 static ssize_t          http_gnutls_read(gnutls_transport_ptr_t ptr, void *data, size_t length);
  50 static ssize_t          http_gnutls_write(gnutls_transport_ptr_t ptr, const void *data, size_t length);
  51
  52
  53 /*
  54  * 'cupsMakeServerCredentials()' - Make a self-signed certificate and private key pair.
  55  *
  56  * @since CUPS 2.0/OS 10.10@
  57  */
  58
  59 int                                     /* O - 1 on success, 0 on failure */
  60 cupsMakeServerCredentials(
  61     const char *path,                   /* I - Path to keychain/directory */
  62     const char *common_name,            /* I - Common name */
  63     int        num_alt_names,           /* I - Number of subject alternate names */
  64     const char **alt_names,             /* I - Subject Alternate Names */
  65     time_t     expiration_date)         /* I - Expiration date */
  66 {
  67   gnutls_x509_crt_t     crt;            /* Self-signed certificate */
  68   gnutls_x509_privkey_t key;            /* Encryption private key */
  69   char                  temp[1024],     /* Temporary directory name */
  70                         crtfile[1024],  /* Certificate filename */
  71                         keyfile[1024];  /* Private key filename */
  72   cups_lang_t           *language;      /* Default language info */
  73   cups_file_t           *fp;            /* Key/cert file */
  74   unsigned char         buffer[8192];   /* Buffer for x509 data */
  75   size_t                bytes;          /* Number of bytes of data */
  76   unsigned char         serial[4];      /* Serial number buffer */
  77   time_t                curtime;        /* Current time */
  78   int                   result;         /* Result of GNU TLS calls */
  79
  80
  81   DEBUG_printf(("cupsMakeServerCredentials(path=\"%s\", common_name=\"%s\", num_alt_names=%d, alt_names=%p, expiration_date=%d)", path, common_name, num_alt_names, alt_names, (int)expiration_date));
  82
  83  /*
  84   * Filenames...
  85   */
  86
  87   if (!path)
  88     path = http_gnutls_default_path(temp, sizeof(temp));
  89
  90   if (!path || !common_name)
  91   {
  92     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
  93     return (0);
  94   }
  95
  96   http_gnutls_make_path(crtfile, sizeof(crtfile), path, common_name, "crt");
  97   http_gnutls_make_path(keyfile, sizeof(keyfile), path, common_name, "key");
  98
  99  /*
 100   * Create the encryption key...
 101   */
 102
 103   DEBUG_puts("1cupsMakeServerCredentials: Creating key pair.");
 104
 105   gnutls_x509_privkey_init(&key);
 106   gnutls_x509_privkey_generate(key, GNUTLS_PK_RSA, 2048, 0);
 107
 108   DEBUG_puts("1cupsMakeServerCredentials: Key pair created.");
 109
 110  /*
 111   * Save it...
 112   */
 113
 114   bytes = sizeof(buffer);
 115
 116   if ((result = gnutls_x509_privkey_export(key, GNUTLS_X509_FMT_PEM, buffer, &bytes)) < 0)
 117   {
 118     DEBUG_printf(("1cupsMakeServerCredentials: Unable to export private key: %s", gnutls_strerror(result)));
 119     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, gnutls_strerror(result), 0);
 120     gnutls_x509_privkey_deinit(key);
 121     return (0);
 122   }
 123   else if ((fp = cupsFileOpen(keyfile, "w")) != NULL)
 124   {
 125     DEBUG_printf(("1cupsMakeServerCredentials: Writing private key to \"%s\".", keyfile));
 126     cupsFileWrite(fp, (char *)buffer, bytes);
 127     cupsFileClose(fp);
 128   }
 129   else
 130   {
 131     DEBUG_printf(("1cupsMakeServerCredentials: Unable to create private key file \"%s\": %s", keyfile, strerror(errno)));
 132     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0);
 133     gnutls_x509_privkey_deinit(key);
 134     return (0);
 135   }
 136
 137  /*
 138   * Create the self-signed certificate...
 139   */
 140
 141   DEBUG_puts("1cupsMakeServerCredentials: Generating self-signed X.509 certificate.");
 142
 143   language  = cupsLangDefault();
 144   curtime   = time(NULL);
 145   serial[0] = curtime >> 24;
 146   serial[1] = curtime >> 16;
 147   serial[2] = curtime >> 8;
 148   serial[3] = curtime;
 149
 150   gnutls_x509_crt_init(&crt);
 151   if (strlen(language->language) == 5)
 152     gnutls_x509_crt_set_dn_by_oid(crt, GNUTLS_OID_X520_COUNTRY_NAME, 0,
 153                                   language->language + 3, 2);
 154   else
 155     gnutls_x509_crt_set_dn_by_oid(crt, GNUTLS_OID_X520_COUNTRY_NAME, 0,
 156                                   "US", 2);
 157   gnutls_x509_crt_set_dn_by_oid(crt, GNUTLS_OID_X520_COMMON_NAME, 0,
 158                                 common_name, strlen(common_name));
 159   gnutls_x509_crt_set_dn_by_oid(crt, GNUTLS_OID_X520_ORGANIZATION_NAME, 0,
 160                                 common_name, strlen(common_name));
 161   gnutls_x509_crt_set_dn_by_oid(crt, GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME,
 162                                 0, "Unknown", 7);
 163   gnutls_x509_crt_set_dn_by_oid(crt, GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME, 0,
 164                                 "Unknown", 7);
 165   gnutls_x509_crt_set_dn_by_oid(crt, GNUTLS_OID_X520_LOCALITY_NAME, 0,
 166                                 "Unknown", 7);
 167 /*  gnutls_x509_crt_set_dn_by_oid(crt, GNUTLS_OID_PKCS9_EMAIL, 0,
 168                                 ServerAdmin, strlen(ServerAdmin));*/
 169   gnutls_x509_crt_set_key(crt, key);
 170   gnutls_x509_crt_set_serial(crt, serial, sizeof(serial));
 171   gnutls_x509_crt_set_activation_time(crt, curtime);
 172   gnutls_x509_crt_set_expiration_time(crt, curtime + 10 * 365 * 86400);
 173   gnutls_x509_crt_set_ca_status(crt, 0);
 174   if (num_alt_names > 0)
 175     gnutls_x509_crt_set_subject_alternative_name(crt, GNUTLS_SAN_DNSNAME, alt_names[0]);
 176   gnutls_x509_crt_set_key_purpose_oid(crt, GNUTLS_KP_TLS_WWW_SERVER, 0);
 177   gnutls_x509_crt_set_key_usage(crt, GNUTLS_KEY_KEY_ENCIPHERMENT);
 178   gnutls_x509_crt_set_version(crt, 3);
 179
 180   bytes = sizeof(buffer);
 181   if (gnutls_x509_crt_get_key_id(crt, 0, buffer, &bytes) >= 0)
 182     gnutls_x509_crt_set_subject_key_id(crt, buffer, bytes);
 183
 184   gnutls_x509_crt_sign(crt, crt, key);
 185
 186  /*
 187   * Save it...
 188   */
 189
 190   bytes = sizeof(buffer);
 191   if ((result = gnutls_x509_crt_export(crt, GNUTLS_X509_FMT_PEM, buffer, &bytes)) < 0)
 192   {
 193     DEBUG_printf(("1cupsMakeServerCredentials: Unable to export public key and X.509 certificate: %s", gnutls_strerror(result)));
 194     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, gnutls_strerror(result), 0);
 195     gnutls_x509_crt_deinit(crt);
 196     gnutls_x509_privkey_deinit(key);
 197     return (0);
 198   }
 199   else if ((fp = cupsFileOpen(crtfile, "w")) != NULL)
 200   {
 201     DEBUG_printf(("1cupsMakeServerCredentials: Writing public key and X.509 certificate to \"%s\".", crtfile));
 202     cupsFileWrite(fp, (char *)buffer, bytes);
 203     cupsFileClose(fp);
 204   }
 205   else
 206   {
 207     DEBUG_printf(("1cupsMakeServerCredentials: Unable to create public key and X.509 certificate file \"%s\": %s", crtfile, strerror(errno)));
 208     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0);
 209     gnutls_x509_crt_deinit(crt);
 210     gnutls_x509_privkey_deinit(key);
 211     return (0);
 212   }
 213
 214  /*
 215   * Cleanup...
 216   */
 217
 218   gnutls_x509_crt_deinit(crt);
 219   gnutls_x509_privkey_deinit(key);
 220
 221   DEBUG_puts("1cupsMakeServerCredentials: Successfully created credentials.");
 222
 223   return (1);
 224 }
 225
 226
 227 /*
 228  * 'cupsSetServerCredentials()' - Set the default server credentials.
 229  *
 230  * Note: The server credentials are used by all threads in the running process.
 231  * This function is threadsafe.
 232  *
 233  * @since CUPS 2.0/OS 10.10@
 234  */
 235
 236 int                                     /* O - 1 on success, 0 on failure */
 237 cupsSetServerCredentials(
 238     const char *path,                   /* I - Path to keychain/directory */
 239     const char *common_name,            /* I - Default common name for server */
 240     int        auto_create)             /* I - 1 = automatically create self-signed certificates */
 241 {
 242   char  temp[1024];                     /* Default path buffer */
 243
 244
 245   DEBUG_printf(("cupsSetServerCredentials(path=\"%s\", common_name=\"%s\", auto_create=%d)", path, common_name, auto_create));
 246
 247  /*
 248   * Use defaults as needed...
 249   */
 250
 251   if (!path)
 252     path = http_gnutls_default_path(temp, sizeof(temp));
 253
 254  /*
 255   * Range check input...
 256   */
 257
 258   if (!path || !common_name)
 259   {
 260     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
 261     return (0);
 262   }
 263
 264   _cupsMutexLock(&tls_mutex);
 265
 266  /*
 267   * Free old values...
 268   */
 269
 270   if (tls_keypath)
 271     _cupsStrFree(tls_keypath);
 272
 273   if (tls_common_name)
 274     _cupsStrFree(tls_common_name);
 275
 276  /*
 277   * Save the new values...
 278   */
 279
 280   tls_keypath     = _cupsStrAlloc(path);
 281   tls_auto_create = auto_create;
 282   tls_common_name = _cupsStrAlloc(common_name);
 283
 284   _cupsMutexUnlock(&tls_mutex);
 285
 286   return (1);
 287 }
 288
 289
 290 /*
 291  * 'httpCopyCredentials()' - Copy the credentials associated with the peer in
 292  *                           an encrypted connection.
 293  *
 294  * @since CUPS 1.5/macOS 10.7@
 295  */
 296
 297 int                                     /* O - Status of call (0 = success) */
 298 httpCopyCredentials(
 299     http_t       *http,                 /* I - Connection to server */
 300     cups_array_t **credentials)         /* O - Array of credentials */
 301 {
 302   unsigned              count;          /* Number of certificates */
 303   const gnutls_datum_t *certs;          /* Certificates */
 304
 305
 306   DEBUG_printf(("httpCopyCredentials(http=%p, credentials=%p)", http, credentials));
 307
 308   if (credentials)
 309     *credentials = NULL;
 310
 311   if (!http || !http->tls || !credentials)
 312     return (-1);
 313
 314   *credentials = cupsArrayNew(NULL, NULL);
 315   certs        = gnutls_certificate_get_peers(http->tls, &count);
 316
 317   DEBUG_printf(("1httpCopyCredentials: certs=%p, count=%u", certs, count));
 318
 319   if (certs && count)
 320   {
 321     while (count > 0)
 322     {
 323       httpAddCredential(*credentials, certs->data, certs->size);
 324       certs ++;
 325       count --;
 326     }
 327   }
 328
 329   return (0);
 330 }
 331
 332
 333 /*
 334  * '_httpCreateCredentials()' - Create credentials in the internal format.
 335  */
 336
 337 http_tls_credentials_t                  /* O - Internal credentials */
 338 _httpCreateCredentials(
 339     cups_array_t *credentials)          /* I - Array of credentials */
 340 {
 341   (void)credentials;
 342
 343   return (NULL);
 344 }
 345
 346
 347 /*
 348  * '_httpFreeCredentials()' - Free internal credentials.
 349  */
 350
 351 void
 352 _httpFreeCredentials(
 353     http_tls_credentials_t credentials) /* I - Internal credentials */
 354 {
 355   (void)credentials;
 356 }
 357
 358
 359 /*
 360  * 'httpCredentialsAreValidForName()' - Return whether the credentials are valid for the given name.
 361  *
 362  * @since CUPS 2.0/OS 10.10@
 363  */
 364
 365 int                                     /* O - 1 if valid, 0 otherwise */
 366 httpCredentialsAreValidForName(
 367     cups_array_t *credentials,          /* I - Credentials */
 368     const char   *common_name)          /* I - Name to check */
 369 {
 370   gnutls_x509_crt_t     cert;           /* Certificate */
 371   int                   result = 0;     /* Result */
 372
 373
 374   cert = http_gnutls_create_credential((http_credential_t *)cupsArrayFirst(credentials));
 375   if (cert)
 376   {
 377     result = gnutls_x509_crt_check_hostname(cert, common_name) != 0;
 378
 379     if (result)
 380     {
 381       int               i,              /* Looping var */
 382                         count;          /* Number of revoked certificates */
 383       unsigned char     cserial[1024],  /* Certificate serial number */
 384                         rserial[1024];  /* Revoked serial number */
 385       size_t            cserial_size,   /* Size of cert serial number */
 386                         rserial_size;   /* Size of revoked serial number */
 387
 388       _cupsMutexLock(&tls_mutex);
 389
 390       count = gnutls_x509_crl_get_crt_count(tls_crl);
 391
 392       if (count > 0)
 393       {
 394         cserial_size = sizeof(cserial);
 395         gnutls_x509_crt_get_serial(cert, cserial, &cserial_size);
 396
 397         for (i = 0; i < count; i ++)
 398         {
 399           rserial_size = sizeof(rserial);
 400           if (!gnutls_x509_crl_get_crt_serial(tls_crl, i, rserial, &rserial_size, NULL) && cserial_size == rserial_size && !memcmp(cserial, rserial, rserial_size))
 401           {
 402             result = 0;
 403             break;
 404           }
 405         }
 406       }
 407
 408       _cupsMutexUnlock(&tls_mutex);
 409     }
 410
 411     gnutls_x509_crt_deinit(cert);
 412   }
 413
 414   return (result);
 415 }
 416
 417
 418 /*
 419  * 'httpCredentialsGetTrust()' - Return the trust of credentials.
 420  *
 421  * @since CUPS 2.0/OS 10.10@
 422  */
 423
 424 http_trust_t                            /* O - Level of trust */
 425 httpCredentialsGetTrust(
 426     cups_array_t *credentials,          /* I - Credentials */
 427     const char   *common_name)          /* I - Common name for trust lookup */
 428 {
 429   http_trust_t          trust = HTTP_TRUST_OK;
 430                                         /* Trusted? */
 431   gnutls_x509_crt_t     cert;           /* Certificate */
 432   cups_array_t          *tcreds = NULL; /* Trusted credentials */
 433   _cups_globals_t       *cg = _cupsGlobals();
 434                                         /* Per-thread globals */
 435
 436
 437   if (!common_name)
 438   {
 439     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No common name specified."), 1);
 440     return (HTTP_TRUST_UNKNOWN);
 441   }
 442
 443   if ((cert = http_gnutls_create_credential((http_credential_t *)cupsArrayFirst(credentials))) == NULL)
 444   {
 445     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Unable to create credentials from array."), 1);
 446     return (HTTP_TRUST_UNKNOWN);
 447   }
 448
 449   if (cg->any_root < 0)
 450   {
 451     _cupsSetDefaults();
 452     http_gnutls_load_crl();
 453   }
 454
 455  /*
 456   * Look this common name up in the default keychains...
 457   */
 458
 459   httpLoadCredentials(NULL, &tcreds, common_name);
 460
 461   if (tcreds)
 462   {
 463     char        credentials_str[1024],  /* String for incoming credentials */
 464                 tcreds_str[1024];       /* String for saved credentials */
 465
 466     httpCredentialsString(credentials, credentials_str, sizeof(credentials_str));
 467     httpCredentialsString(tcreds, tcreds_str, sizeof(tcreds_str));
 468
 469     if (strcmp(credentials_str, tcreds_str))
 470     {
 471      /*
 472       * Credentials don't match, let's look at the expiration date of the new
 473       * credentials and allow if the new ones have a later expiration...
 474       */
 475
 476       if (!cg->trust_first)
 477       {
 478        /*
 479         * Do not trust certificates on first use...
 480         */
 481
 482         _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Trust on first use is disabled."), 1);
 483
 484         trust = HTTP_TRUST_INVALID;
 485       }
 486       else if (httpCredentialsGetExpiration(credentials) <= httpCredentialsGetExpiration(tcreds))
 487       {
 488        /*
 489         * The new credentials are not newly issued...
 490         */
 491
 492         _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("New credentials are older than stored credentials."), 1);
 493
 494         trust = HTTP_TRUST_INVALID;
 495       }
 496       else if (!httpCredentialsAreValidForName(credentials, common_name))
 497       {
 498        /*
 499         * The common name does not match the issued certificate...
 500         */
 501
 502         _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("New credentials are not valid for name."), 1);
 503
 504         trust = HTTP_TRUST_INVALID;
 505       }
 506       else if (httpCredentialsGetExpiration(tcreds) < time(NULL))
 507       {
 508        /*
 509         * Save the renewed credentials...
 510         */
 511
 512         trust = HTTP_TRUST_RENEWED;
 513
 514         httpSaveCredentials(NULL, credentials, common_name);
 515       }
 516     }
 517
 518     httpFreeCredentials(tcreds);
 519   }
 520   else if (cg->validate_certs && !httpCredentialsAreValidForName(credentials, common_name))
 521   {
 522     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No stored credentials, not valid for name."), 1);
 523     trust = HTTP_TRUST_INVALID;
 524   }
 525   else if (!cg->trust_first)
 526   {
 527    /*
 528     * See if we have a site CA certificate we can compare...
 529     */
 530
 531     if (!httpLoadCredentials(NULL, &tcreds, "site"))
 532     {
 533       if (cupsArrayCount(credentials) != (cupsArrayCount(tcreds) + 1))
 534       {
 535        /*
 536         * Certificate isn't directly generated from the CA cert...
 537         */
 538
 539         trust = HTTP_TRUST_INVALID;
 540       }
 541       else
 542       {
 543        /*
 544         * Do a tail comparison of the two certificates...
 545         */
 546
 547         http_credential_t       *a, *b;         /* Certificates */
 548
 549         for (a = (http_credential_t *)cupsArrayFirst(tcreds), b = (http_credential_t *)cupsArrayIndex(credentials, 1);
 550              a && b;
 551              a = (http_credential_t *)cupsArrayNext(tcreds), b = (http_credential_t *)cupsArrayNext(credentials))
 552           if (a->datalen != b->datalen || memcmp(a->data, b->data, a->datalen))
 553             break;
 554
 555         if (a || b)
 556           trust = HTTP_TRUST_INVALID;
 557       }
 558
 559       if (trust != HTTP_TRUST_OK)
 560         _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Credentials do not validate against site CA certificate."), 1);
 561     }
 562     else
 563     {
 564       _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Trust on first use is disabled."), 1);
 565       trust = HTTP_TRUST_INVALID;
 566     }
 567   }
 568
 569   if (trust == HTTP_TRUST_OK && !cg->expired_certs)
 570   {
 571     time_t      curtime;                /* Current date/time */
 572
 573     time(&curtime);
 574     if (curtime < gnutls_x509_crt_get_activation_time(cert) ||
 575         curtime > gnutls_x509_crt_get_expiration_time(cert))
 576     {
 577       _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Credentials have expired."), 1);
 578       trust = HTTP_TRUST_EXPIRED;
 579     }
 580   }
 581
 582   if (trust == HTTP_TRUST_OK && !cg->any_root && cupsArrayCount(credentials) == 1)
 583   {
 584     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Self-signed credentials are blocked."), 1);
 585     trust = HTTP_TRUST_INVALID;
 586   }
 587
 588   gnutls_x509_crt_deinit(cert);
 589
 590   return (trust);
 591 }
 592
 593
 594 /*
 595  * 'httpCredentialsGetExpiration()' - Return the expiration date of the credentials.
 596  *
 597  * @since CUPS 2.0/OS 10.10@
 598  */
 599
 600 time_t                                  /* O - Expiration date of credentials */
 601 httpCredentialsGetExpiration(
 602     cups_array_t *credentials)          /* I - Credentials */
 603 {
 604   gnutls_x509_crt_t     cert;           /* Certificate */
 605   time_t                result = 0;     /* Result */
 606
 607
 608   cert = http_gnutls_create_credential((http_credential_t *)cupsArrayFirst(credentials));
 609   if (cert)
 610   {
 611     result = gnutls_x509_crt_get_expiration_time(cert);
 612     gnutls_x509_crt_deinit(cert);
 613   }
 614
 615   return (result);
 616 }
 617
 618
 619 /*
 620  * 'httpCredentialsString()' - Return a string representing the credentials.
 621  *
 622  * @since CUPS 2.0/OS 10.10@
 623  */
 624
 625 size_t                                  /* O - Total size of credentials string */
 626 httpCredentialsString(
 627     cups_array_t *credentials,          /* I - Credentials */
 628     char         *buffer,               /* I - Buffer or @code NULL@ */
 629     size_t       bufsize)               /* I - Size of buffer */
 630 {
 631   http_credential_t     *first;         /* First certificate */
 632   gnutls_x509_crt_t     cert;           /* Certificate */
 633
 634
 635   DEBUG_printf(("httpCredentialsString(credentials=%p, buffer=%p, bufsize=" CUPS_LLFMT ")", credentials, buffer, CUPS_LLCAST bufsize));
 636
 637   if (!buffer)
 638     return (0);
 639
 640   if (buffer && bufsize > 0)
 641     *buffer = '\0';
 642
 643   if ((first = (http_credential_t *)cupsArrayFirst(credentials)) != NULL &&
 644       (cert = http_gnutls_create_credential(first)) != NULL)
 645   {
 646     char                name[256];      /* Common name associated with cert */
 647     size_t              namelen;        /* Length of name */
 648     time_t              expiration;     /* Expiration date of cert */
 649     _cups_md5_state_t   md5_state;      /* MD5 state */
 650     unsigned char       md5_digest[16]; /* MD5 result */
 651
 652     namelen = sizeof(name) - 1;
 653     if (gnutls_x509_crt_get_dn_by_oid(cert, GNUTLS_OID_X520_COMMON_NAME, 0, 0, name, &namelen) >= 0)
 654       name[namelen] = '\0';
 655     else
 656       strlcpy(name, "unknown", sizeof(name));
 657
 658     expiration = gnutls_x509_crt_get_expiration_time(cert);
 659
 660     _cupsMD5Init(&md5_state);
 661     _cupsMD5Append(&md5_state, first->data, (int)first->datalen);
 662     _cupsMD5Finish(&md5_state, md5_digest);
 663
 664     snprintf(buffer, bufsize, "%s / %s / %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X", name, httpGetDateString(expiration), md5_digest[0], md5_digest[1], md5_digest[2], md5_digest[3], md5_digest[4], md5_digest[5], md5_digest[6], md5_digest[7], md5_digest[8], md5_digest[9], md5_digest[10], md5_digest[11], md5_digest[12], md5_digest[13], md5_digest[14], md5_digest[15]);
 665
 666     gnutls_x509_crt_deinit(cert);
 667   }
 668
 669   DEBUG_printf(("1httpCredentialsString: Returning \"%s\".", buffer));
 670
 671   return (strlen(buffer));
 672 }
 673
 674
 675 /*
 676  * 'httpLoadCredentials()' - Load X.509 credentials from a keychain file.
 677  *
 678  * @since CUPS 2.0/OS 10.10@
 679  */
 680
 681 int                                     /* O - 0 on success, -1 on error */
 682 httpLoadCredentials(
 683     const char   *path,                 /* I  - Keychain/PKCS#12 path */
 684     cups_array_t **credentials,         /* IO - Credentials */
 685     const char   *common_name)          /* I  - Common name for credentials */
 686 {
 687   cups_file_t           *fp;            /* Certificate file */
 688   char                  filename[1024], /* filename.crt */
 689                         temp[1024],     /* Temporary string */
 690                         line[256];      /* Base64-encoded line */
 691   unsigned char         *data = NULL;   /* Buffer for cert data */
 692   size_t                alloc_data = 0, /* Bytes allocated */
 693                         num_data = 0;   /* Bytes used */
 694   int                   decoded;        /* Bytes decoded */
 695   int                   in_certificate = 0;
 696                                         /* In a certificate? */
 697
 698
 699   if (!credentials || !common_name)
 700     return (-1);
 701
 702   if (!path)
 703     path = http_gnutls_default_path(temp, sizeof(temp));
 704   if (!path)
 705     return (-1);
 706
 707   http_gnutls_make_path(filename, sizeof(filename), path, common_name, "crt");
 708
 709   if ((fp = cupsFileOpen(filename, "r")) == NULL)
 710     return (-1);
 711
 712   while (cupsFileGets(fp, line, sizeof(line)))
 713   {
 714     if (!strcmp(line, "-----BEGIN CERTIFICATE-----"))
 715     {
 716       if (in_certificate)
 717       {
 718        /*
 719         * Missing END CERTIFICATE...
 720         */
 721
 722         httpFreeCredentials(*credentials);
 723         *credentials = NULL;
 724         break;
 725       }
 726
 727       in_certificate = 1;
 728     }
 729     else if (!strcmp(line, "-----END CERTIFICATE-----"))
 730     {
 731       if (!in_certificate || !num_data)
 732       {
 733        /*
 734         * Missing data...
 735         */
 736
 737         httpFreeCredentials(*credentials);
 738         *credentials = NULL;
 739         break;
 740       }
 741
 742       if (!*credentials)
 743         *credentials = cupsArrayNew(NULL, NULL);
 744
 745       if (httpAddCredential(*credentials, data, num_data))
 746       {
 747         httpFreeCredentials(*credentials);
 748         *credentials = NULL;
 749         break;
 750       }
 751
 752       num_data       = 0;
 753       in_certificate = 0;
 754     }
 755     else if (in_certificate)
 756     {
 757       if (alloc_data == 0)
 758       {
 759         data       = malloc(2048);
 760         alloc_data = 2048;
 761
 762         if (!data)
 763           break;
 764       }
 765       else if ((num_data + strlen(line)) >= alloc_data)
 766       {
 767         unsigned char *tdata = realloc(data, alloc_data + 1024);
 768                                         /* Expanded buffer */
 769
 770         if (!tdata)
 771         {
 772           httpFreeCredentials(*credentials);
 773           *credentials = NULL;
 774           break;
 775         }
 776
 777         data       = tdata;
 778         alloc_data += 1024;
 779       }
 780
 781       decoded = alloc_data - num_data;
 782       httpDecode64_2((char *)data + num_data, &decoded, line);
 783       num_data += (size_t)decoded;
 784     }
 785   }
 786
 787   cupsFileClose(fp);
 788
 789   if (in_certificate)
 790   {
 791    /*
 792     * Missing END CERTIFICATE...
 793     */
 794
 795     httpFreeCredentials(*credentials);
 796     *credentials = NULL;
 797   }
 798
 799   if (data)
 800     free(data);
 801
 802   return (*credentials ? 0 : -1);
 803 }
 804
 805
 806 /*
 807  * 'httpSaveCredentials()' - Save X.509 credentials to a keychain file.
 808  *
 809  * @since CUPS 2.0/OS 10.10@
 810  */
 811
 812 int                                     /* O - -1 on error, 0 on success */
 813 httpSaveCredentials(
 814     const char   *path,                 /* I - Keychain/PKCS#12 path */
 815     cups_array_t *credentials,          /* I - Credentials */
 816     const char   *common_name)          /* I - Common name for credentials */
 817 {
 818   cups_file_t           *fp;            /* Certificate file */
 819   char                  filename[1024], /* filename.crt */
 820                         nfilename[1024],/* filename.crt.N */
 821                         temp[1024],     /* Temporary string */
 822                         line[256];      /* Base64-encoded line */
 823   const unsigned char   *ptr;           /* Pointer into certificate */
 824   ssize_t               remaining;      /* Bytes left */
 825   http_credential_t     *cred;          /* Current credential */
 826
 827
 828   if (!credentials || !common_name)
 829     return (-1);
 830
 831   if (!path)
 832     path = http_gnutls_default_path(temp, sizeof(temp));
 833   if (!path)
 834     return (-1);
 835
 836   http_gnutls_make_path(filename, sizeof(filename), path, common_name, "crt");
 837   snprintf(nfilename, sizeof(nfilename), "%s.N", filename);
 838
 839   if ((fp = cupsFileOpen(nfilename, "w")) == NULL)
 840     return (-1);
 841
 842   fchmod(cupsFileNumber(fp), 0600);
 843
 844   for (cred = (http_credential_t *)cupsArrayFirst(credentials);
 845        cred;
 846        cred = (http_credential_t *)cupsArrayNext(credentials))
 847   {
 848     cupsFilePuts(fp, "-----BEGIN CERTIFICATE-----\n");
 849     for (ptr = cred->data, remaining = (ssize_t)cred->datalen; remaining > 0; remaining -= 45, ptr += 45)
 850     {
 851       httpEncode64_2(line, sizeof(line), (char *)ptr, remaining > 45 ? 45 : remaining);
 852       cupsFilePrintf(fp, "%s\n", line);
 853     }
 854     cupsFilePuts(fp, "-----END CERTIFICATE-----\n");
 855   }
 856
 857   cupsFileClose(fp);
 858
 859   return (rename(nfilename, filename));
 860 }
 861
 862
 863 /*
 864  * 'http_gnutls_create_credential()' - Create a single credential in the internal format.
 865  */
 866
 867 static gnutls_x509_crt_t                        /* O - Certificate */
 868 http_gnutls_create_credential(
 869     http_credential_t *credential)              /* I - Credential */
 870 {
 871   int                   result;                 /* Result from GNU TLS */
 872   gnutls_x509_crt_t     cert;                   /* Certificate */
 873   gnutls_datum_t        datum;                  /* Data record */
 874
 875
 876   DEBUG_printf(("3http_gnutls_create_credential(credential=%p)", credential));
 877
 878   if (!credential)
 879     return (NULL);
 880
 881   if ((result = gnutls_x509_crt_init(&cert)) < 0)
 882   {
 883     DEBUG_printf(("4http_gnutls_create_credential: init error: %s", gnutls_strerror(result)));
 884     return (NULL);
 885   }
 886
 887   datum.data = credential->data;
 888   datum.size = credential->datalen;
 889
 890   if ((result = gnutls_x509_crt_import(cert, &datum, GNUTLS_X509_FMT_DER)) < 0)
 891   {
 892     DEBUG_printf(("4http_gnutls_create_credential: import error: %s", gnutls_strerror(result)));
 893
 894     gnutls_x509_crt_deinit(cert);
 895     return (NULL);
 896   }
 897
 898   return (cert);
 899 }
 900
 901
 902 /*
 903  * 'http_gnutls_default_path()' - Get the default credential store path.
 904  */
 905
 906 static const char *                     /* O - Path or NULL on error */
 907 http_gnutls_default_path(char   *buffer,/* I - Path buffer */
 908                          size_t bufsize)/* I - Size of path buffer */
 909 {
 910   const char *home = getenv("HOME");    /* HOME environment variable */
 911
 912
 913   if (getuid() && home)
 914   {
 915     snprintf(buffer, bufsize, "%s/.cups", home);
 916     if (access(buffer, 0))
 917     {
 918       DEBUG_printf(("1http_gnutls_default_path: Making directory \"%s\".", buffer));
 919       if (mkdir(buffer, 0700))
 920       {
 921         DEBUG_printf(("1http_gnutls_default_path: Failed to make directory: %s", strerror(errno)));
 922         return (NULL);
 923       }
 924     }
 925
 926     snprintf(buffer, bufsize, "%s/.cups/ssl", home);
 927     if (access(buffer, 0))
 928     {
 929       DEBUG_printf(("1http_gnutls_default_path: Making directory \"%s\".", buffer));
 930       if (mkdir(buffer, 0700))
 931       {
 932         DEBUG_printf(("1http_gnutls_default_path: Failed to make directory: %s", strerror(errno)));
 933         return (NULL);
 934       }
 935     }
 936   }
 937   else
 938     strlcpy(buffer, CUPS_SERVERROOT "/ssl", bufsize);
 939
 940   DEBUG_printf(("1http_gnutls_default_path: Using default path \"%s\".", buffer));
 941
 942   return (buffer);
 943 }
 944
 945
 946 /*
 947  * 'http_gnutls_load_crl()' - Load the certificate revocation list, if any.
 948  */
 949
 950 static void
 951 http_gnutls_load_crl(void)
 952 {
 953   _cupsMutexLock(&tls_mutex);
 954
 955   if (!gnutls_x509_crl_init(&tls_crl))
 956   {
 957     cups_file_t         *fp;            /* CRL file */
 958     char                filename[1024], /* site.crl */
 959                         line[256];      /* Base64-encoded line */
 960     unsigned char       *data = NULL;   /* Buffer for cert data */
 961     size_t              alloc_data = 0, /* Bytes allocated */
 962                         num_data = 0;   /* Bytes used */
 963     int                 decoded;        /* Bytes decoded */
 964     gnutls_datum_t      datum;          /* Data record */
 965
 966
 967     http_gnutls_make_path(filename, sizeof(filename), CUPS_SERVERROOT, "site", "crl");
 968
 969     if ((fp = cupsFileOpen(filename, "r")) != NULL)
 970     {
 971       while (cupsFileGets(fp, line, sizeof(line)))
 972       {
 973         if (!strcmp(line, "-----BEGIN X509 CRL-----"))
 974         {
 975           if (num_data)
 976           {
 977            /*
 978             * Missing END X509 CRL...
 979             */
 980
 981             break;
 982           }
 983         }
 984         else if (!strcmp(line, "-----END X509 CRL-----"))
 985         {
 986           if (!num_data)
 987           {
 988            /*
 989             * Missing data...
 990             */
 991
 992             break;
 993           }
 994
 995           datum.data = data;
 996           datum.size = num_data;
 997
 998           gnutls_x509_crl_import(tls_crl, &datum, GNUTLS_X509_FMT_PEM);
 999
1000           num_data = 0;
1001         }
1002         else
1003         {
1004           if (alloc_data == 0)
1005           {
1006             data       = malloc(2048);
1007             alloc_data = 2048;
1008
1009             if (!data)
1010               break;
1011           }
1012           else if ((num_data + strlen(line)) >= alloc_data)
1013           {
1014             unsigned char *tdata = realloc(data, alloc_data + 1024);
1015                                             /* Expanded buffer */
1016
1017             if (!tdata)
1018               break;
1019
1020             data       = tdata;
1021             alloc_data += 1024;
1022           }
1023
1024           decoded = alloc_data - num_data;
1025           httpDecode64_2((char *)data + num_data, &decoded, line);
1026           num_data += (size_t)decoded;
1027         }
1028       }
1029
1030       cupsFileClose(fp);
1031
1032       if (data)
1033         free(data);
1034     }
1035   }
1036
1037   _cupsMutexUnlock(&tls_mutex);
1038 }
1039
1040
1041 /*
1042  * 'http_gnutls_make_path()' - Format a filename for a certificate or key file.
1043  */
1044
1045 static const char *                     /* O - Filename */
1046 http_gnutls_make_path(
1047     char       *buffer,                 /* I - Filename buffer */
1048     size_t     bufsize,                 /* I - Size of buffer */
1049     const char *dirname,                /* I - Directory */
1050     const char *filename,               /* I - Filename (usually hostname) */
1051     const char *ext)                    /* I - Extension */
1052 {
1053   char  *bufptr,                        /* Pointer into buffer */
1054         *bufend = buffer + bufsize - 1; /* End of buffer */
1055
1056
1057   snprintf(buffer, bufsize, "%s/", dirname);
1058   bufptr = buffer + strlen(buffer);
1059
1060   while (*filename && bufptr < bufend)
1061   {
1062     if (_cups_isalnum(*filename) || *filename == '-' || *filename == '.')
1063       *bufptr++ = *filename;
1064     else
1065       *bufptr++ = '_';
1066
1067     filename ++;
1068   }
1069
1070   if (bufptr < bufend)
1071     *bufptr++ = '.';
1072
1073   strlcpy(bufptr, ext, (size_t)(bufend - bufptr + 1));
1074
1075   return (buffer);
1076 }
1077
1078
1079 /*
1080  * 'http_gnutls_read()' - Read function for the GNU TLS library.
1081  */
1082
1083 static ssize_t                          /* O - Number of bytes read or -1 on error */
1084 http_gnutls_read(
1085     gnutls_transport_ptr_t ptr,         /* I - Connection to server */
1086     void                   *data,       /* I - Buffer */
1087     size_t                 length)      /* I - Number of bytes to read */
1088 {
1089   http_t        *http;                  /* HTTP connection */
1090   ssize_t       bytes;                  /* Bytes read */
1091
1092
1093   DEBUG_printf(("6http_gnutls_read(ptr=%p, data=%p, length=%d)", ptr, data, (int)length));
1094
1095   http = (http_t *)ptr;
1096
1097   if (!http->blocking)
1098   {
1099    /*
1100     * Make sure we have data before we read...
1101     */
1102
1103     while (!_httpWait(http, http->wait_value, 0))
1104     {
1105       if (http->timeout_cb && (*http->timeout_cb)(http, http->timeout_data))
1106         continue;
1107
1108       http->error = ETIMEDOUT;
1109       return (-1);
1110     }
1111   }
1112
1113   bytes = recv(http->fd, data, length, 0);
1114   DEBUG_printf(("6http_gnutls_read: bytes=%d", (int)bytes));
1115   return (bytes);
1116 }
1117
1118
1119 /*
1120  * 'http_gnutls_write()' - Write function for the GNU TLS library.
1121  */
1122
1123 static ssize_t                          /* O - Number of bytes written or -1 on error */
1124 http_gnutls_write(
1125     gnutls_transport_ptr_t ptr,         /* I - Connection to server */
1126     const void             *data,       /* I - Data buffer */
1127     size_t                 length)      /* I - Number of bytes to write */
1128 {
1129   ssize_t bytes;                        /* Bytes written */
1130
1131
1132   DEBUG_printf(("6http_gnutls_write(ptr=%p, data=%p, length=%d)", ptr, data,
1133                 (int)length));
1134   bytes = send(((http_t *)ptr)->fd, data, length, 0);
1135   DEBUG_printf(("http_gnutls_write: bytes=%d", (int)bytes));
1136
1137   return (bytes);
1138 }
1139
1140
1141 /*
1142  * '_httpTLSInitialize()' - Initialize the TLS stack.
1143  */
1144
1145 void
1146 _httpTLSInitialize(void)
1147 {
1148  /*
1149   * Initialize GNU TLS...
1150   */
1151
1152   gnutls_global_init();
1153 }
1154
1155
1156 /*
1157  * '_httpTLSPending()' - Return the number of pending TLS-encrypted bytes.
1158  */
1159
1160 size_t                                  /* O - Bytes available */
1161 _httpTLSPending(http_t *http)           /* I - HTTP connection */
1162 {
1163   return (gnutls_record_check_pending(http->tls));
1164 }
1165
1166
1167 /*
1168  * '_httpTLSRead()' - Read from a SSL/TLS connection.
1169  */
1170
1171 int                                     /* O - Bytes read */
1172 _httpTLSRead(http_t *http,              /* I - Connection to server */
1173              char   *buf,               /* I - Buffer to store data */
1174              int    len)                /* I - Length of buffer */
1175 {
1176   ssize_t       result;                 /* Return value */
1177
1178
1179   result = gnutls_record_recv(http->tls, buf, (size_t)len);
1180
1181   if (result < 0 && !errno)
1182   {
1183    /*
1184     * Convert GNU TLS error to errno value...
1185     */
1186
1187     switch (result)
1188     {
1189       case GNUTLS_E_INTERRUPTED :
1190           errno = EINTR;
1191           break;
1192
1193       case GNUTLS_E_AGAIN :
1194           errno = EAGAIN;
1195           break;
1196
1197       default :
1198           errno = EPIPE;
1199           break;
1200     }
1201
1202     result = -1;
1203   }
1204
1205   return ((int)result);
1206 }
1207
1208
1209 /*
1210  * '_httpTLSSetCredentials()' - Set the TLS credentials.
1211  */
1212
1213 int                                     /* O - Status of connection */
1214 _httpTLSSetCredentials(http_t *http)    /* I - Connection to server */
1215 {
1216   (void)http;
1217
1218   return (0);
1219 }
1220
1221
1222 /*
1223  * '_httpTLSSetOptions()' - Set TLS protocol and cipher suite options.
1224  */
1225
1226 void
1227 _httpTLSSetOptions(int options)         /* I - Options */
1228 {
1229   tls_options = options;
1230 }
1231
1232
1233 /*
1234  * '_httpTLSStart()' - Set up SSL/TLS support on a connection.
1235  */
1236
1237 int                                     /* O - 0 on success, -1 on failure */
1238 _httpTLSStart(http_t *http)             /* I - Connection to server */
1239 {
1240   char                  hostname[256],  /* Hostname */
1241                         *hostptr;       /* Pointer into hostname */
1242   int                   status;         /* Status of handshake */
1243   gnutls_certificate_credentials_t *credentials;
1244                                         /* TLS credentials */
1245   char                  priority_string[1024];
1246                                         /* Priority string */
1247
1248
1249   DEBUG_printf(("3_httpTLSStart(http=%p)", http));
1250
1251   if (tls_options < 0)
1252   {
1253     DEBUG_puts("4_httpTLSStart: Setting defaults.");
1254     _cupsSetDefaults();
1255     DEBUG_printf(("4_httpTLSStart: tls_options=%x", tls_options));
1256   }
1257
1258   if (http->mode == _HTTP_MODE_SERVER && !tls_keypath)
1259   {
1260     DEBUG_puts("4_httpTLSStart: cupsSetServerCredentials not called.");
1261     http->error  = errno = EINVAL;
1262     http->status = HTTP_STATUS_ERROR;
1263     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Server credentials not set."), 1);
1264
1265     return (-1);
1266   }
1267
1268   credentials = (gnutls_certificate_credentials_t *)
1269                     malloc(sizeof(gnutls_certificate_credentials_t));
1270   if (credentials == NULL)
1271   {
1272     DEBUG_printf(("8_httpStartTLS: Unable to allocate credentials: %s",
1273                   strerror(errno)));
1274     http->error  = errno;
1275     http->status = HTTP_STATUS_ERROR;
1276     _cupsSetHTTPError(HTTP_STATUS_ERROR);
1277
1278     return (-1);
1279   }
1280
1281   gnutls_certificate_allocate_credentials(credentials);
1282   status = gnutls_init(&http->tls, http->mode == _HTTP_MODE_CLIENT ? GNUTLS_CLIENT : GNUTLS_SERVER);
1283   if (!status)
1284     status = gnutls_set_default_priority(http->tls);
1285
1286   if (status)
1287   {
1288     http->error  = EIO;
1289     http->status = HTTP_STATUS_ERROR;
1290
1291     DEBUG_printf(("4_httpTLSStart: Unable to initialize common TLS parameters: %s", gnutls_strerror(status)));
1292     _cupsSetError(IPP_STATUS_ERROR_CUPS_PKI, gnutls_strerror(status), 0);
1293
1294     gnutls_deinit(http->tls);
1295     gnutls_certificate_free_credentials(*credentials);
1296     free(credentials);
1297     http->tls = NULL;
1298
1299     return (-1);
1300   }
1301
1302   if (http->mode == _HTTP_MODE_CLIENT)
1303   {
1304    /*
1305     * Client: get the hostname to use for TLS...
1306     */
1307
1308     if (httpAddrLocalhost(http->hostaddr))
1309     {
1310       strlcpy(hostname, "localhost", sizeof(hostname));
1311     }
1312     else
1313     {
1314      /*
1315       * Otherwise make sure the hostname we have does not end in a trailing dot.
1316       */
1317
1318       strlcpy(hostname, http->hostname, sizeof(hostname));
1319       if ((hostptr = hostname + strlen(hostname) - 1) >= hostname &&
1320           *hostptr == '.')
1321         *hostptr = '\0';
1322     }
1323
1324     status = gnutls_server_name_set(http->tls, GNUTLS_NAME_DNS, hostname, strlen(hostname));
1325   }
1326   else
1327   {
1328    /*
1329     * Server: get certificate and private key...
1330     */
1331
1332     char        crtfile[1024],          /* Certificate file */
1333                 keyfile[1024];          /* Private key file */
1334     int         have_creds = 0;         /* Have credentials? */
1335
1336     if (http->fields[HTTP_FIELD_HOST][0])
1337     {
1338      /*
1339       * Use hostname for TLS upgrade...
1340       */
1341
1342       strlcpy(hostname, http->fields[HTTP_FIELD_HOST], sizeof(hostname));
1343     }
1344     else
1345     {
1346      /*
1347       * Resolve hostname from connection address...
1348       */
1349
1350       http_addr_t       addr;           /* Connection address */
1351       socklen_t         addrlen;        /* Length of address */
1352
1353       addrlen = sizeof(addr);
1354       if (getsockname(http->fd, (struct sockaddr *)&addr, &addrlen))
1355       {
1356         DEBUG_printf(("4_httpTLSStart: Unable to get socket address: %s", strerror(errno)));
1357         hostname[0] = '\0';
1358       }
1359       else if (httpAddrLocalhost(&addr))
1360         hostname[0] = '\0';
1361       else
1362       {
1363         httpAddrLookup(&addr, hostname, sizeof(hostname));
1364         DEBUG_printf(("4_httpTLSStart: Resolved socket address to \"%s\".", hostname));
1365       }
1366     }
1367
1368     if (isdigit(hostname[0] & 255) || hostname[0] == '[')
1369       hostname[0] = '\0';               /* Don't allow numeric addresses */
1370
1371     if (hostname[0])
1372     {
1373      /*
1374       * First look in the CUPS keystore...
1375       */
1376
1377       http_gnutls_make_path(crtfile, sizeof(crtfile), tls_keypath, hostname, "crt");
1378       http_gnutls_make_path(keyfile, sizeof(keyfile), tls_keypath, hostname, "key");
1379
1380       if (access(crtfile, R_OK) || access(keyfile, R_OK))
1381       {
1382        /*
1383         * No CUPS-managed certs, look for CA certs...
1384         */
1385
1386         char cacrtfile[1024], cakeyfile[1024];  /* CA cert files */
1387
1388         snprintf(cacrtfile, sizeof(cacrtfile), "/etc/letsencrypt/live/%s/fullchain.pem", hostname);
1389         snprintf(cakeyfile, sizeof(cakeyfile), "/etc/letsencrypt/live/%s/privkey.pem", hostname);
1390
1391         if ((access(cacrtfile, R_OK) || access(cakeyfile, R_OK)) && (hostptr = strchr(hostname, '.')) != NULL)
1392         {
1393          /*
1394           * Try just domain name...
1395           */
1396
1397           hostptr ++;
1398           if (strchr(hostptr, '.'))
1399           {
1400             snprintf(cacrtfile, sizeof(cacrtfile), "/etc/letsencrypt/live/%s/fullchain.pem", hostptr);
1401             snprintf(cakeyfile, sizeof(cakeyfile), "/etc/letsencrypt/live/%s/privkey.pem", hostptr);
1402           }
1403         }
1404
1405         if (!access(cacrtfile, R_OK) && !access(cakeyfile, R_OK))
1406         {
1407          /*
1408           * Use the CA certs...
1409           */
1410
1411           strlcpy(crtfile, cacrtfile, sizeof(crtfile));
1412           strlcpy(keyfile, cakeyfile, sizeof(keyfile));
1413         }
1414       }
1415
1416       have_creds = !access(crtfile, R_OK) && !access(keyfile, R_OK);
1417     }
1418     else if (tls_common_name)
1419     {
1420      /*
1421       * First look in the CUPS keystore...
1422       */
1423
1424       http_gnutls_make_path(crtfile, sizeof(crtfile), tls_keypath, tls_common_name, "crt");
1425       http_gnutls_make_path(keyfile, sizeof(keyfile), tls_keypath, tls_common_name, "key");
1426
1427       if (access(crtfile, R_OK) || access(keyfile, R_OK))
1428       {
1429        /*
1430         * No CUPS-managed certs, look for CA certs...
1431         */
1432
1433         char cacrtfile[1024], cakeyfile[1024];  /* CA cert files */
1434
1435         snprintf(cacrtfile, sizeof(cacrtfile), "/etc/letsencrypt/live/%s/fullchain.pem", tls_common_name);
1436         snprintf(cakeyfile, sizeof(cakeyfile), "/etc/letsencrypt/live/%s/privkey.pem", tls_common_name);
1437
1438         if ((access(cacrtfile, R_OK) || access(cakeyfile, R_OK)) && (hostptr = strchr(tls_common_name, '.')) != NULL)
1439         {
1440          /*
1441           * Try just domain name...
1442           */
1443
1444           hostptr ++;
1445           if (strchr(hostptr, '.'))
1446           {
1447             snprintf(cacrtfile, sizeof(cacrtfile), "/etc/letsencrypt/live/%s/fullchain.pem", hostptr);
1448             snprintf(cakeyfile, sizeof(cakeyfile), "/etc/letsencrypt/live/%s/privkey.pem", hostptr);
1449           }
1450         }
1451
1452         if (!access(cacrtfile, R_OK) && !access(cakeyfile, R_OK))
1453         {
1454          /*
1455           * Use the CA certs...
1456           */
1457
1458           strlcpy(crtfile, cacrtfile, sizeof(crtfile));
1459           strlcpy(keyfile, cakeyfile, sizeof(keyfile));
1460         }
1461       }
1462
1463       have_creds = !access(crtfile, R_OK) && !access(keyfile, R_OK);
1464     }
1465
1466     if (!have_creds && tls_auto_create && (hostname[0] || tls_common_name))
1467     {
1468       DEBUG_printf(("4_httpTLSStart: Auto-create credentials for \"%s\".", hostname[0] ? hostname : tls_common_name));
1469
1470       if (!cupsMakeServerCredentials(tls_keypath, hostname[0] ? hostname : tls_common_name, 0, NULL, time(NULL) + 365 * 86400))
1471       {
1472         DEBUG_puts("4_httpTLSStart: cupsMakeServerCredentials failed.");
1473         http->error  = errno = EINVAL;
1474         http->status = HTTP_STATUS_ERROR;
1475         _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Unable to create server credentials."), 1);
1476
1477         return (-1);
1478       }
1479     }
1480
1481     DEBUG_printf(("4_httpTLSStart: Using certificate \"%s\" and private key \"%s\".", crtfile, keyfile));
1482
1483     if (!status)
1484       status = gnutls_certificate_set_x509_key_file(*credentials, crtfile, keyfile, GNUTLS_X509_FMT_PEM);
1485   }
1486
1487   if (!status)
1488     status = gnutls_credentials_set(http->tls, GNUTLS_CRD_CERTIFICATE, *credentials);
1489
1490   if (status)
1491   {
1492     http->error  = EIO;
1493     http->status = HTTP_STATUS_ERROR;
1494
1495     DEBUG_printf(("4_httpTLSStart: Unable to complete client/server setup: %s", gnutls_strerror(status)));
1496     _cupsSetError(IPP_STATUS_ERROR_CUPS_PKI, gnutls_strerror(status), 0);
1497
1498     gnutls_deinit(http->tls);
1499     gnutls_certificate_free_credentials(*credentials);
1500     free(credentials);
1501     http->tls = NULL;
1502
1503     return (-1);
1504   }
1505
1506   strlcpy(priority_string, "NORMAL", sizeof(priority_string));
1507
1508   if (tls_options & _HTTP_TLS_DENY_TLS10)
1509     strlcat(priority_string, ":+VERS-TLS-ALL:-VERS-TLS1.0:-VERS-SSL3.0", sizeof(priority_string));
1510   else if (tls_options & _HTTP_TLS_ALLOW_SSL3)
1511     strlcat(priority_string, ":+VERS-TLS-ALL", sizeof(priority_string));
1512   else
1513     strlcat(priority_string, ":+VERS-TLS-ALL:-VERS-SSL3.0", sizeof(priority_string));
1514
1515   if (!(tls_options & _HTTP_TLS_ALLOW_RC4))
1516     strlcat(priority_string, ":-ARCFOUR-128", sizeof(priority_string));
1517
1518   if (!(tls_options & _HTTP_TLS_ALLOW_DH))
1519     strlcat(priority_string, ":!ANON-DH", sizeof(priority_string));
1520
1521 #ifdef HAVE_GNUTLS_PRIORITY_SET_DIRECT
1522   gnutls_priority_set_direct(http->tls, priority_string, NULL);
1523
1524 #else
1525   gnutls_priority_t priority;           /* Priority */
1526
1527   gnutls_priority_init(&priority, priority_string, NULL);
1528   gnutls_priority_set(http->tls, priority);
1529   gnutls_priority_deinit(priority);
1530 #endif /* HAVE_GNUTLS_PRIORITY_SET_DIRECT */
1531
1532   gnutls_transport_set_ptr(http->tls, (gnutls_transport_ptr_t)http);
1533   gnutls_transport_set_pull_function(http->tls, http_gnutls_read);
1534 #ifdef HAVE_GNUTLS_TRANSPORT_SET_PULL_TIMEOUT_FUNCTION
1535   gnutls_transport_set_pull_timeout_function(http->tls, (gnutls_pull_timeout_func)httpWait);
1536 #endif /* HAVE_GNUTLS_TRANSPORT_SET_PULL_TIMEOUT_FUNCTION */
1537   gnutls_transport_set_push_function(http->tls, http_gnutls_write);
1538
1539   while ((status = gnutls_handshake(http->tls)) != GNUTLS_E_SUCCESS)
1540   {
1541     DEBUG_printf(("5_httpStartTLS: gnutls_handshake returned %d (%s)",
1542                   status, gnutls_strerror(status)));
1543
1544     if (gnutls_error_is_fatal(status))
1545     {
1546       http->error  = EIO;
1547       http->status = HTTP_STATUS_ERROR;
1548
1549       _cupsSetError(IPP_STATUS_ERROR_CUPS_PKI, gnutls_strerror(status), 0);
1550
1551       gnutls_deinit(http->tls);
1552       gnutls_certificate_free_credentials(*credentials);
1553       free(credentials);
1554       http->tls = NULL;
1555
1556       return (-1);
1557     }
1558   }
1559
1560   http->tls_credentials = credentials;
1561
1562   return (0);
1563 }
1564
1565
1566 /*
1567  * '_httpTLSStop()' - Shut down SSL/TLS on a connection.
1568  */
1569
1570 void
1571 _httpTLSStop(http_t *http)              /* I - Connection to server */
1572 {
1573   int   error;                          /* Error code */
1574
1575
1576   error = gnutls_bye(http->tls, http->mode == _HTTP_MODE_CLIENT ? GNUTLS_SHUT_RDWR : GNUTLS_SHUT_WR);
1577   if (error != GNUTLS_E_SUCCESS)
1578     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, gnutls_strerror(errno), 0);
1579
1580   gnutls_deinit(http->tls);
1581   http->tls = NULL;
1582
1583   if (http->tls_credentials)
1584   {
1585     gnutls_certificate_free_credentials(*(http->tls_credentials));
1586     free(http->tls_credentials);
1587     http->tls_credentials = NULL;
1588   }
1589 }
1590
1591
1592 /*
1593  * '_httpTLSWrite()' - Write to a SSL/TLS connection.
1594  */
1595
1596 int                                     /* O - Bytes written */
1597 _httpTLSWrite(http_t     *http,         /* I - Connection to server */
1598               const char *buf,          /* I - Buffer holding data */
1599               int        len)           /* I - Length of buffer */
1600 {
1601   ssize_t       result;                 /* Return value */
1602
1603
1604   DEBUG_printf(("2http_write_ssl(http=%p, buf=%p, len=%d)", http, buf, len));
1605
1606   result = gnutls_record_send(http->tls, buf, (size_t)len);
1607
1608   if (result < 0 && !errno)
1609   {
1610    /*
1611     * Convert GNU TLS error to errno value...
1612     */
1613
1614     switch (result)
1615     {
1616       case GNUTLS_E_INTERRUPTED :
1617           errno = EINTR;
1618           break;
1619
1620       case GNUTLS_E_AGAIN :
1621           errno = EAGAIN;
1622           break;
1623
1624       default :
1625           errno = EPIPE;
1626           break;
1627     }
1628
1629     result = -1;
1630   }
1631
1632   DEBUG_printf(("3http_write_ssl: Returning %d.", (int)result));
1633
1634   return ((int)result);
1635 }