src/certificate_chain.cc

   1 /*
   2     Copyright (C) 2013-2016 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     libdcp is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34 /** @file  src/signer_chain.cc
  35  *  @brief Functions to make signer chains.
  36  */
  37
  38 #include "certificate_chain.h"
  39 #include "exceptions.h"
  40 #include "util.h"
  41 #include "dcp_assert.h"
  42 #include "compose.hpp"
  43 #include <asdcp/KM_util.h>
  44 #include <libcxml/cxml.h>
  45 #include <libxml++/libxml++.h>
  46 #include <xmlsec/xmldsig.h>
  47 #include <xmlsec/dl.h>
  48 #include <xmlsec/app.h>
  49 #include <xmlsec/crypto.h>
  50 #include <openssl/sha.h>
  51 #include <openssl/bio.h>
  52 #include <openssl/evp.h>
  53 #include <openssl/pem.h>
  54 #include <openssl/rsa.h>
  55 #include <boost/filesystem.hpp>
  56 #include <boost/algorithm/string.hpp>
  57 #include <boost/foreach.hpp>
  58 #include <fstream>
  59 #include <iostream>
  60
  61 using std::string;
  62 using std::ofstream;
  63 using std::ifstream;
  64 using std::runtime_error;
  65 using namespace dcp;
  66
  67 /** Run a shell command.
  68  *  @param cmd Command to run (UTF8-encoded).
  69  */
  70 static void
  71 command (string cmd)
  72 {
  73 #ifdef LIBDCP_WINDOWS
  74         /* We need to use CreateProcessW on Windows so that the UTF-8/16 mess
  75            is handled correctly.
  76         */
  77         int const wn = MultiByteToWideChar (CP_UTF8, 0, cmd.c_str(), -1, 0, 0);
  78         wchar_t* buffer = new wchar_t[wn];
  79         if (MultiByteToWideChar (CP_UTF8, 0, cmd.c_str(), -1, buffer, wn) == 0) {
  80                 delete[] buffer;
  81                 return;
  82         }
  83
  84         int code = 1;
  85
  86         STARTUPINFOW startup_info;
  87         memset (&startup_info, 0, sizeof (startup_info));
  88         startup_info.cb = sizeof (startup_info);
  89         PROCESS_INFORMATION process_info;
  90
  91         /* XXX: this doesn't actually seem to work; failing commands end up with
  92            a return code of 0
  93         */
  94         if (CreateProcessW (0, buffer, 0, 0, FALSE, CREATE_NO_WINDOW, 0, 0, &startup_info, &process_info)) {
  95                 WaitForSingleObject (process_info.hProcess, INFINITE);
  96                 DWORD c;
  97                 if (GetExitCodeProcess (process_info.hProcess, &c)) {
  98                         code = c;
  99                 }
 100                 CloseHandle (process_info.hProcess);
 101                 CloseHandle (process_info.hThread);
 102         }
 103
 104         delete[] buffer;
 105 #else
 106         cmd += " 2> /dev/null";
 107         int const r = system (cmd.c_str ());
 108         int const code = WEXITSTATUS (r);
 109 #endif
 110         if (code) {
 111                 throw dcp::MiscError (String::compose ("error %1 in %2 within %3", code, cmd, boost::filesystem::current_path().string()));
 112         }
 113 }
 114
 115 /** Extract a public key from a private key and create a SHA1 digest of it.
 116  *  @param private_key Private key
 117  *  @param openssl openssl binary name (or full path if openssl is not on the system path).
 118  *  @return SHA1 digest of corresponding public key, with escaped / characters.
 119  */
 120 static string
 121 public_key_digest (boost::filesystem::path private_key, boost::filesystem::path openssl)
 122 {
 123         boost::filesystem::path public_name = private_key.string() + ".public";
 124
 125         /* Create the public key from the private key */
 126         command (String::compose("\"%1\" rsa -outform PEM -pubout -in %2 -out %3", openssl.string(), private_key.string(), public_name.string ()));
 127
 128         /* Read in the public key from the file */
 129
 130         string pub;
 131         ifstream f (public_name.string().c_str ());
 132         if (!f.good ()) {
 133                 throw dcp::MiscError ("public key not found");
 134         }
 135
 136         bool read = false;
 137         while (f.good ()) {
 138                 string line;
 139                 getline (f, line);
 140                 if (line.length() >= 10 && line.substr(0, 10) == "-----BEGIN") {
 141                         read = true;
 142                 } else if (line.length() >= 8 && line.substr(0, 8) == "-----END") {
 143                         break;
 144                 } else if (read) {
 145                         pub += line;
 146                 }
 147         }
 148
 149         /* Decode the base64 of the public key */
 150
 151         unsigned char buffer[512];
 152         int const N = dcp::base64_decode (pub, buffer, 1024);
 153
 154         /* Hash it with SHA1 (without the first 24 bytes, for reasons that are not entirely clear) */
 155
 156         SHA_CTX context;
 157         if (!SHA1_Init (&context)) {
 158                 throw dcp::MiscError ("could not init SHA1 context");
 159         }
 160
 161         if (!SHA1_Update (&context, buffer + 24, N - 24)) {
 162                 throw dcp::MiscError ("could not update SHA1 digest");
 163         }
 164
 165         unsigned char digest[SHA_DIGEST_LENGTH];
 166         if (!SHA1_Final (digest, &context)) {
 167                 throw dcp::MiscError ("could not finish SHA1 digest");
 168         }
 169
 170         char digest_base64[64];
 171         string dig = Kumu::base64encode (digest, SHA_DIGEST_LENGTH, digest_base64, 64);
 172 #ifdef LIBDCP_WINDOWS
 173         boost::replace_all (dig, "/", "\\/");
 174 #else
 175         boost::replace_all (dig, "/", "\\\\/");
 176 #endif
 177         return dig;
 178 }
 179
 180 CertificateChain::CertificateChain (
 181         boost::filesystem::path openssl,
 182         string organisation,
 183         string organisational_unit,
 184         string root_common_name,
 185         string intermediate_common_name,
 186         string leaf_common_name
 187         )
 188 {
 189         boost::filesystem::path directory = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path ();
 190         boost::filesystem::create_directories (directory);
 191
 192         boost::filesystem::path const cwd = boost::filesystem::current_path ();
 193         boost::filesystem::current_path (directory);
 194
 195         string quoted_openssl = "\"" + openssl.string() + "\"";
 196
 197         command (quoted_openssl + " genrsa -out ca.key 2048");
 198
 199         {
 200                 ofstream f ("ca.cnf");
 201                 f << "[ req ]\n"
 202                   << "distinguished_name = req_distinguished_name\n"
 203                   << "x509_extensions   = v3_ca\n"
 204                   << "[ v3_ca ]\n"
 205                   << "basicConstraints = critical,CA:true,pathlen:3\n"
 206                   << "keyUsage = keyCertSign,cRLSign\n"
 207                   << "subjectKeyIdentifier = hash\n"
 208                   << "authorityKeyIdentifier = keyid:always,issuer:always\n"
 209                   << "[ req_distinguished_name ]\n"
 210                   << "O = Unique organization name\n"
 211                   << "OU = Organization unit\n"
 212                   << "CN = Entity and dnQualifier\n";
 213         }
 214
 215         string const ca_subject = "/O=" + organisation +
 216                 "/OU=" + organisational_unit +
 217                 "/CN=" + root_common_name +
 218                 "/dnQualifier=" + public_key_digest ("ca.key", openssl);
 219
 220         {
 221                 command (
 222                         String::compose (
 223                                 "%1 req -new -x509 -sha256 -config ca.cnf -days 3650 -set_serial 5"
 224                                 " -subj \"%2\" -key ca.key -outform PEM -out ca.self-signed.pem",
 225                                 quoted_openssl, ca_subject
 226                                 )
 227                         );
 228         }
 229
 230         command (quoted_openssl + " genrsa -out intermediate.key 2048");
 231
 232         {
 233                 ofstream f ("intermediate.cnf");
 234                 f << "[ default ]\n"
 235                   << "distinguished_name = req_distinguished_name\n"
 236                   << "x509_extensions = v3_ca\n"
 237                   << "[ v3_ca ]\n"
 238                   << "basicConstraints = critical,CA:true,pathlen:2\n"
 239                   << "keyUsage = keyCertSign,cRLSign\n"
 240                   << "subjectKeyIdentifier = hash\n"
 241                   << "authorityKeyIdentifier = keyid:always,issuer:always\n"
 242                   << "[ req_distinguished_name ]\n"
 243                   << "O = Unique organization name\n"
 244                   << "OU = Organization unit\n"
 245                   << "CN = Entity and dnQualifier\n";
 246         }
 247
 248         string const inter_subject = "/O=" + organisation +
 249                 "/OU=" + organisational_unit +
 250                 "/CN=" + intermediate_common_name +
 251                 "/dnQualifier=" + public_key_digest ("intermediate.key", openssl);
 252
 253         {
 254                 command (
 255                         String::compose (
 256                                 "%1 req -new -config intermediate.cnf -days 3649 -subj \"%2\" -key intermediate.key -out intermediate.csr",
 257                                 quoted_openssl, inter_subject
 258                                 )
 259                         );
 260         }
 261
 262         command (
 263                 quoted_openssl +
 264                 " x509 -req -sha256 -days 3649 -CA ca.self-signed.pem -CAkey ca.key -set_serial 6"
 265                 " -in intermediate.csr -extfile intermediate.cnf -extensions v3_ca -out intermediate.signed.pem"
 266                 );
 267
 268         command (quoted_openssl + " genrsa -out leaf.key 2048");
 269
 270         {
 271                 ofstream f ("leaf.cnf");
 272                 f << "[ default ]\n"
 273                   << "distinguished_name = req_distinguished_name\n"
 274                   << "x509_extensions   = v3_ca\n"
 275                   << "[ v3_ca ]\n"
 276                   << "basicConstraints = critical,CA:false\n"
 277                   << "keyUsage = digitalSignature,keyEncipherment\n"
 278                   << "subjectKeyIdentifier = hash\n"
 279                   << "authorityKeyIdentifier = keyid,issuer:always\n"
 280                   << "[ req_distinguished_name ]\n"
 281                   << "O = Unique organization name\n"
 282                   << "OU = Organization unit\n"
 283                   << "CN = Entity and dnQualifier\n";
 284         }
 285
 286         string const leaf_subject = "/O=" + organisation +
 287                 "/OU=" + organisational_unit +
 288                 "/CN=" + leaf_common_name +
 289                 "/dnQualifier=" + public_key_digest ("leaf.key", openssl);
 290
 291         {
 292                 command (
 293                         String::compose (
 294                                 "%1 req -new -config leaf.cnf -days 3648 -subj \"%2\" -key leaf.key -outform PEM -out leaf.csr",
 295                                 quoted_openssl, leaf_subject
 296                                 )
 297                         );
 298         }
 299
 300         command (
 301                 quoted_openssl +
 302                 " x509 -req -sha256 -days 3648 -CA intermediate.signed.pem -CAkey intermediate.key"
 303                 " -set_serial 7 -in leaf.csr -extfile leaf.cnf -extensions v3_ca -out leaf.signed.pem"
 304                 );
 305
 306         boost::filesystem::current_path (cwd);
 307
 308         _certificates.push_back (dcp::Certificate (dcp::file_to_string (directory / "ca.self-signed.pem")));
 309         _certificates.push_back (dcp::Certificate (dcp::file_to_string (directory / "intermediate.signed.pem")));
 310         _certificates.push_back (dcp::Certificate (dcp::file_to_string (directory / "leaf.signed.pem")));
 311
 312         _key = dcp::file_to_string (directory / "leaf.key");
 313
 314         boost::filesystem::remove_all (directory);
 315 }
 316
 317 CertificateChain::CertificateChain (string s)
 318 {
 319         while (true) {
 320                 try {
 321                         Certificate c;
 322                         s = c.read_string (s);
 323                         _certificates.push_back (c);
 324                 } catch (MiscError& e) {
 325                         /* Failed to read a certificate, just stop */
 326                         break;
 327                 }
 328         }
 329
 330         if (!attempt_reorder ()) {
 331                 throw MiscError ("could not find certificate chain order");
 332         }
 333 }
 334
 335 /** @return Root certificate */
 336 Certificate
 337 CertificateChain::root () const
 338 {
 339         DCP_ASSERT (!_certificates.empty());
 340         return _certificates.front ();
 341 }
 342
 343 /** @return Leaf certificate */
 344 Certificate
 345 CertificateChain::leaf () const
 346 {
 347         DCP_ASSERT (!_certificates.empty());
 348         return _certificates.back ();
 349 }
 350
 351 /** @return Certificates in order from root to leaf */
 352 CertificateChain::List
 353 CertificateChain::root_to_leaf () const
 354 {
 355         return _certificates;
 356 }
 357
 358 /** @return Certificates in order from leaf to root */
 359 CertificateChain::List
 360 CertificateChain::leaf_to_root () const
 361 {
 362         List c = _certificates;
 363         c.reverse ();
 364         return c;
 365 }
 366
 367 /** Add a certificate to the end of the chain.
 368  *  @param c Certificate to add.
 369  */
 370 void
 371 CertificateChain::add (Certificate c)
 372 {
 373         _certificates.push_back (c);
 374 }
 375
 376 /** Remove a certificate from the chain.
 377  *  @param c Certificate to remove.
 378  */
 379 void
 380 CertificateChain::remove (Certificate c)
 381 {
 382         _certificates.remove (c);
 383 }
 384
 385 /** Remove the i'th certificate in the list, as listed
 386  *  from root to leaf.
 387  */
 388 void
 389 CertificateChain::remove (int i)
 390 {
 391         List::iterator j = _certificates.begin ();
 392         while (j != _certificates.end () && i > 0) {
 393                 --i;
 394                 ++j;
 395         }
 396
 397         if (j != _certificates.end ()) {
 398                 _certificates.erase (j);
 399         }
 400 }
 401
 402 /** Check to see if the chain is valid (i.e. root signs the intermediate, intermediate
 403  *  signs the leaf and so on) and that the private key (if there is one) matches the
 404  *  leaf certificate.
 405  *  @return true if it's ok, false if not.
 406  */
 407 bool
 408 CertificateChain::valid () const
 409 {
 410         /* Check the certificate chain */
 411
 412         X509_STORE* store = X509_STORE_new ();
 413         if (!store) {
 414                 return false;
 415         }
 416
 417         for (List::const_iterator i = _certificates.begin(); i != _certificates.end(); ++i) {
 418
 419                 List::const_iterator j = i;
 420                 ++j;
 421                 if (j ==  _certificates.end ()) {
 422                         break;
 423                 }
 424
 425                 if (!X509_STORE_add_cert (store, i->x509 ())) {
 426                         X509_STORE_free (store);
 427                         return false;
 428                 }
 429
 430                 X509_STORE_CTX* ctx = X509_STORE_CTX_new ();
 431                 if (!ctx) {
 432                         X509_STORE_free (store);
 433                         return false;
 434                 }
 435
 436                 X509_STORE_set_flags (store, 0);
 437                 if (!X509_STORE_CTX_init (ctx, store, j->x509 (), 0)) {
 438                         X509_STORE_CTX_free (ctx);
 439                         X509_STORE_free (store);
 440                         return false;
 441                 }
 442
 443                 int v = X509_verify_cert (ctx);
 444                 X509_STORE_CTX_free (ctx);
 445
 446                 if (v == 0) {
 447                         X509_STORE_free (store);
 448                         return false;
 449                 }
 450         }
 451
 452         X509_STORE_free (store);
 453
 454         /* Check that the leaf certificate matches the private key, if there is one */
 455
 456         if (!_key) {
 457                 return true;
 458         }
 459
 460         BIO* bio = BIO_new_mem_buf (const_cast<char *> (_key->c_str ()), -1);
 461         if (!bio) {
 462                 throw MiscError ("could not create memory BIO");
 463         }
 464
 465         RSA* private_key = PEM_read_bio_RSAPrivateKey (bio, 0, 0, 0);
 466         RSA* public_key = leaf().public_key ();
 467
 468 #if OPENSSL_VERSION_NUMBER > 0x10100000L
 469 #warning "Using new OpenSSL API"
 470         BIGNUM const * private_key_n;
 471         RSA_get0_key(private_key, &private_key_n, 0, 0);
 472         BIGNUM const * public_key_n;
 473         RSA_get0_key(public_key, &public_key_n, 0, 0);
 474         bool const valid = !BN_cmp (private_key_n, public_key_n);
 475 #else
 476         bool const valid = !BN_cmp (private_key->n, public_key->n);
 477 #endif
 478         BIO_free (bio);
 479
 480         return valid;
 481 }
 482
 483 /** @return true if the chain is now in order from root to leaf,
 484  *  false if no correct order was found.
 485  */
 486 bool
 487 CertificateChain::attempt_reorder ()
 488 {
 489         List original = _certificates;
 490         _certificates.sort ();
 491         do {
 492                 if (valid ()) {
 493                         return true;
 494                 }
 495         } while (std::next_permutation (_certificates.begin(), _certificates.end ()));
 496
 497         _certificates = original;
 498         return false;
 499 }
 500
 501 /** Add a &lt;Signer&gt; and &lt;ds:Signature&gt; nodes to an XML node.
 502  *  @param parent XML node to add to.
 503  *  @param standard INTEROP or SMPTE.
 504  */
 505 void
 506 CertificateChain::sign (xmlpp::Element* parent, Standard standard) const
 507 {
 508         /* <Signer> */
 509
 510         xmlpp::Element* signer = parent->add_child("Signer");
 511         xmlpp::Element* data = signer->add_child("X509Data", "dsig");
 512         xmlpp::Element* serial_element = data->add_child("X509IssuerSerial", "dsig");
 513         serial_element->add_child("X509IssuerName", "dsig")->add_child_text (leaf().issuer());
 514         serial_element->add_child("X509SerialNumber", "dsig")->add_child_text (leaf().serial());
 515         data->add_child("X509SubjectName", "dsig")->add_child_text (leaf().subject());
 516
 517         /* <Signature> */
 518
 519         xmlpp::Element* signature = parent->add_child("Signature", "dsig");
 520
 521         xmlpp::Element* signed_info = signature->add_child ("SignedInfo", "dsig");
 522         signed_info->add_child("CanonicalizationMethod", "dsig")->set_attribute ("Algorithm", "http://www.w3.org/TR/2001/REC-xml-c14n-20010315");
 523
 524         if (standard == INTEROP) {
 525                 signed_info->add_child("SignatureMethod", "dsig")->set_attribute("Algorithm", "http://www.w3.org/2000/09/xmldsig#rsa-sha1");
 526         } else {
 527                 signed_info->add_child("SignatureMethod", "dsig")->set_attribute("Algorithm", "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256");
 528         }
 529
 530         xmlpp::Element* reference = signed_info->add_child("Reference", "dsig");
 531         reference->set_attribute ("URI", "");
 532
 533         xmlpp::Element* transforms = reference->add_child("Transforms", "dsig");
 534         transforms->add_child("Transform", "dsig")->set_attribute (
 535                 "Algorithm", "http://www.w3.org/2000/09/xmldsig#enveloped-signature"
 536                 );
 537
 538         reference->add_child("DigestMethod", "dsig")->set_attribute("Algorithm", "http://www.w3.org/2000/09/xmldsig#sha1");
 539         /* This will be filled in by the signing later */
 540         reference->add_child("DigestValue", "dsig");
 541
 542         signature->add_child("SignatureValue", "dsig");
 543         signature->add_child("KeyInfo", "dsig");
 544         add_signature_value (signature, "dsig");
 545 }
 546
 547
 548 /** Sign an XML node.
 549  *
 550  *  @param parent Node to sign.
 551  *  @param ns Namespace to use for the signature XML nodes.
 552  */
 553 void
 554 CertificateChain::add_signature_value (xmlpp::Node* parent, string ns) const
 555 {
 556         cxml::Node cp (parent);
 557         xmlpp::Node* key_info = cp.node_child("KeyInfo")->node ();
 558
 559         /* Add the certificate chain to the KeyInfo child node of parent */
 560         BOOST_FOREACH (Certificate const & i, leaf_to_root ()) {
 561                 xmlpp::Element* data = key_info->add_child("X509Data", ns);
 562
 563                 {
 564                         xmlpp::Element* serial = data->add_child("X509IssuerSerial", ns);
 565                         serial->add_child("X509IssuerName", ns)->add_child_text (i.issuer ());
 566                         serial->add_child("X509SerialNumber", ns)->add_child_text (i.serial ());
 567                 }
 568
 569                 data->add_child("X509Certificate", ns)->add_child_text (i.certificate());
 570         }
 571
 572         xmlSecDSigCtxPtr signature_context = xmlSecDSigCtxCreate (0);
 573         if (signature_context == 0) {
 574                 throw MiscError ("could not create signature context");
 575         }
 576
 577         signature_context->signKey = xmlSecCryptoAppKeyLoadMemory (
 578                 reinterpret_cast<const unsigned char *> (_key->c_str()), _key->size(), xmlSecKeyDataFormatPem, 0, 0, 0
 579                 );
 580
 581         if (signature_context->signKey == 0) {
 582                 throw runtime_error ("could not read private key");
 583         }
 584
 585         /* XXX: set key name to the PEM string: this can't be right! */
 586         if (xmlSecKeySetName (signature_context->signKey, reinterpret_cast<const xmlChar *> (_key->c_str())) < 0) {
 587                 throw MiscError ("could not set key name");
 588         }
 589
 590         int const r = xmlSecDSigCtxSign (signature_context, parent->cobj ());
 591         if (r < 0) {
 592                 throw MiscError (String::compose ("could not sign (%1)", r));
 593         }
 594
 595         xmlSecDSigCtxDestroy (signature_context);
 596 }
 597
 598 string
 599 CertificateChain::chain () const
 600 {
 601         string o;
 602         BOOST_FOREACH (Certificate const &i, root_to_leaf ()) {
 603                 o += i.certificate(true);
 604         }
 605
 606         return o;
 607 }