src/certificate_chain.h

   1 /*
   2     Copyright (C) 2013-2021 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
  35 /** @file  src/certificate_chain.h
  36  *  @brief CertificateChain class
  37  */
  38
  39
  40 #ifndef LIBDCP_CERTIFICATE_CHAIN_H
  41 #define LIBDCP_CERTIFICATE_CHAIN_H
  42
  43
  44 #include "certificate.h"
  45 #include "types.h"
  46 #include <boost/filesystem.hpp>
  47 #include <boost/optional.hpp>
  48
  49
  50 namespace xmlpp {
  51         class Node;
  52 }
  53
  54
  55 struct certificates_validation1;
  56 struct certificates_validation2;
  57 struct certificates_validation3;
  58 struct certificates_validation4;
  59 struct certificates_validation5;
  60 struct certificates_validation6;
  61 struct certificates_validation7;
  62 struct certificates_validation8;
  63
  64
  65 namespace dcp {
  66
  67
  68 /** @class CertificateChain
  69  *  @brief A chain of any number of certificates, from root to leaf.
  70  *
  71  *  A CertificateChain object can also (optionally) hold the private key corresponding
  72  *  to the leaf certificate.
  73  */
  74 class CertificateChain
  75 {
  76 public:
  77         CertificateChain () {}
  78
  79         /** Create a chain of certificates for signing things.
  80          *  @param openssl Name of openssl binary (if it is on the path) or full path.
  81          *  @return Directory (which should be deleted by the caller) containing:
  82          *    - ca.self-signed.pem      self-signed root certificate
  83          *    - intermediate.signed.pem intermediate certificate
  84          *    - leaf.key                leaf certificate private key
  85          *    - leaf.signed.pem         leaf certificate
  86          */
  87         CertificateChain (
  88                 boost::filesystem::path openssl,
  89                 std::string organisation = "example.org",
  90                 std::string organisational_unit = "example.org",
  91                 std::string root_common_name = ".smpte-430-2.ROOT.NOT_FOR_PRODUCTION",
  92                 std::string intermediate_common_name = ".smpte-430-2.INTERMEDIATE.NOT_FOR_PRODUCTION",
  93                 std::string leaf_common_name = "CS.smpte-430-2.LEAF.NOT_FOR_PRODUCTION"
  94                 );
  95
  96         /** Read a CertificateChain from a string.
  97          *  @param s A string containing one or more PEM-encoded certificates.
  98          */
  99         explicit CertificateChain (std::string s);
 100
 101         /** Add a certificate to the chain.
 102          *  @param c Certificate to add.
 103          */
 104         void add (Certificate c);
 105
 106         /** Remove a certificate from the chain.
 107          *  @param c Certificate to remove.
 108          */
 109         void remove (Certificate c);
 110
 111         /** Remove the i'th certificate in the chain, as listed
 112          *  from root to leaf.
 113          */
 114         void remove (int i);
 115
 116         /** @return Root certificate */
 117         Certificate root () const;
 118
 119         /** @return Leaf certificate */
 120         Certificate leaf () const;
 121
 122         typedef std::vector<Certificate> List;
 123
 124         /** @return Certificates in order from leaf to root */
 125         List leaf_to_root () const;
 126         /** @return Certificates in order from root to leaf */
 127         List root_to_leaf () const;
 128         List unordered () const;
 129
 130         bool valid (std::string* reason = nullptr) const;
 131
 132         /** Check to see if the chain is valid (i.e. root signs the intermediate, intermediate
 133          *  signs the leaf and so on) and that the private key (if there is one) matches the
 134          *  leaf certificate.
 135          *  @return true if it's ok, false if not.
 136          */
 137         bool chain_valid () const;
 138
 139         /** Check that there is a valid private key for the leaf certificate.
 140          *  Will return true if there are no certificates.
 141          */
 142         bool private_key_valid () const;
 143
 144         /** Add a &lt;Signer&gt; and &lt;ds:Signature&gt; nodes to an XML node.
 145          *  @param parent XML node to add to.
 146          *  @param standard INTEROP or SMPTE.
 147          */
 148         void sign (xmlpp::Element* parent, Standard standard) const;
 149
 150         /** Sign an XML node.
 151          *
 152          *  @param parent Node to sign.
 153          *  @param ns Namespace to use for the signature XML nodes.
 154          */
 155         void add_signature_value (xmlpp::Element* parent, std::string ns, bool add_indentation) const;
 156
 157         boost::optional<std::string> key () const {
 158                 return _key;
 159         }
 160
 161         void set_key (std::string k) {
 162                 _key = k;
 163         }
 164
 165         std::string chain () const;
 166
 167 private:
 168         friend struct ::certificates_validation1;
 169         friend struct ::certificates_validation2;
 170         friend struct ::certificates_validation3;
 171         friend struct ::certificates_validation4;
 172         friend struct ::certificates_validation5;
 173         friend struct ::certificates_validation6;
 174         friend struct ::certificates_validation7;
 175         friend struct ::certificates_validation8;
 176
 177         bool chain_valid (List const & chain) const;
 178
 179         /** Our certificates, not in any particular order */
 180         List _certificates;
 181         /** Leaf certificate's private key, if known, in PEM format */
 182         boost::optional<std::string> _key;
 183 };
 184
 185
 186 }
 187
 188
 189 #endif