src/decrypted_kdm.cc

   1 /*
   2     Copyright (C) 2013-2017 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 #include "decrypted_kdm.h"
  35 #include "decrypted_kdm_key.h"
  36 #include "encrypted_kdm.h"
  37 #include "reel_mxf.h"
  38 #include "reel_asset.h"
  39 #include "util.h"
  40 #include "exceptions.h"
  41 #include "cpl.h"
  42 #include "certificate_chain.h"
  43 #include "dcp_assert.h"
  44 #include "compose.hpp"
  45 #include <asdcp/AS_DCP.h>
  46 #include <asdcp/KM_util.h>
  47 #include <openssl/rsa.h>
  48 #include <openssl/pem.h>
  49 #include <openssl/err.h>
  50 #include <boost/foreach.hpp>
  51
  52 using std::list;
  53 using std::vector;
  54 using std::string;
  55 using std::setw;
  56 using std::setfill;
  57 using std::hex;
  58 using std::pair;
  59 using std::map;
  60 using boost::shared_ptr;
  61 using boost::optional;
  62 using namespace dcp;
  63
  64 /* Magic value specified by SMPTE S430-1-2006 */
  65 static uint8_t smpte_structure_id[] = { 0xf1, 0xdc, 0x12, 0x44, 0x60, 0x16, 0x9a, 0x0e, 0x85, 0xbc, 0x30, 0x06, 0x42, 0xf8, 0x66, 0xab };
  66
  67 static void
  68 put (uint8_t ** d, string s)
  69 {
  70         memcpy (*d, s.c_str(), s.length());
  71         (*d) += s.length();
  72 }
  73
  74 static void
  75 put (uint8_t ** d, uint8_t const * s, int N)
  76 {
  77         memcpy (*d, s, N);
  78         (*d) += N;
  79 }
  80
  81 void
  82 DecryptedKDM::put_uuid (uint8_t ** d, string id)
  83 {
  84         /* 32 hex digits plus some hyphens */
  85         DCP_ASSERT (id.length() == 36);
  86 #ifdef LIBDCP_WINDOWS
  87         __mingw_sscanf (
  88 #else
  89         sscanf (
  90 #endif
  91                 id.c_str(),
  92                 "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx",
  93                 *d + 0, *d + 1, *d + 2, *d + 3, *d + 4, *d + 5, *d + 6, *d + 7,
  94                 *d + 8, *d + 9, *d + 10, *d + 11, *d + 12, *d + 13, *d + 14, *d + 15
  95                 );
  96
  97         *d += 16;
  98 }
  99
 100 string
 101 DecryptedKDM::get_uuid (unsigned char ** p)
 102 {
 103         char buffer[37];
 104 #ifdef LIBDCP_WINDOWS
 105         __mingw_snprintf (
 106 #else
 107         snprintf (
 108 #endif
 109                 buffer, sizeof(buffer), "%02hhx%02hhx%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx",
 110                 (*p)[0], (*p)[1], (*p)[2], (*p)[3], (*p)[4], (*p)[5], (*p)[6], (*p)[7],
 111                 (*p)[8], (*p)[9], (*p)[10], (*p)[11], (*p)[12], (*p)[13], (*p)[14], (*p)[15]
 112                 );
 113
 114         *p += 16;
 115         return buffer;
 116 }
 117
 118 static string
 119 get (uint8_t ** p, int N)
 120 {
 121         string g;
 122         for (int i = 0; i < N; ++i) {
 123                 g += **p;
 124                 (*p)++;
 125         }
 126
 127         return g;
 128 }
 129
 130 DecryptedKDM::DecryptedKDM (EncryptedKDM const & kdm, string private_key)
 131 {
 132         /* Read the private key */
 133
 134         BIO* bio = BIO_new_mem_buf (const_cast<char *> (private_key.c_str ()), -1);
 135         if (!bio) {
 136                 throw MiscError ("could not create memory BIO");
 137         }
 138
 139         RSA* rsa = PEM_read_bio_RSAPrivateKey (bio, 0, 0, 0);
 140         if (!rsa) {
 141                 throw FileError ("could not read RSA private key file", private_key, errno);
 142         }
 143
 144         /* Use the private key to decrypt the keys */
 145
 146         BOOST_FOREACH (string const & i, kdm.keys ()) {
 147                 /* Decode the base-64-encoded cipher value from the KDM */
 148                 unsigned char cipher_value[256];
 149                 int const cipher_value_len = base64_decode (i, cipher_value, sizeof (cipher_value));
 150
 151                 /* Decrypt it */
 152                 unsigned char * decrypted = new unsigned char[RSA_size(rsa)];
 153                 int const decrypted_len = RSA_private_decrypt (cipher_value_len, cipher_value, decrypted, rsa, RSA_PKCS1_OAEP_PADDING);
 154                 if (decrypted_len == -1) {
 155                         delete[] decrypted;
 156 #if OPENSSL_VERSION_NUMBER > 0x10100000L
 157                         throw KDMDecryptionError (ERR_error_string (ERR_get_error(), 0), cipher_value_len, RSA_bits(rsa));
 158 #else
 159                         throw KDMDecryptionError (ERR_error_string (ERR_get_error(), 0), cipher_value_len, rsa->n->dmax);
 160 #endif
 161                 }
 162
 163                 unsigned char* p = decrypted;
 164                 switch (decrypted_len) {
 165                 case 134:
 166                 {
 167                         /* Inter-op */
 168                         /* 0 is structure id (fixed sequence specified by standard) [16 bytes] */
 169                         p += 16;
 170                         /* 16 is is signer thumbprint [20 bytes] */
 171                         p += 20;
 172                         /* 36 is CPL id [16 bytes] */
 173                         string const cpl_id = get_uuid (&p);
 174                         /* 52 is key id [16 bytes] */
 175                         string const key_id = get_uuid (&p);
 176                         /* 68 is not-valid-before (a string) [25 bytes] */
 177                         p += 25;
 178                         /* 93 is not-valid-after (a string) [25 bytes] */
 179                         p += 25;
 180                         /* 118 is the key [ASDCP::KeyLen bytes] */
 181                         add_key (optional<string>(), key_id, Key (p), cpl_id, INTEROP);
 182                         break;
 183                 }
 184                 case 138:
 185                 {
 186                         /* SMPTE */
 187                         /* 0 is structure id (fixed sequence specified by standard) [16 bytes] */
 188                         DCP_ASSERT (memcmp (p, smpte_structure_id, 16) == 0);
 189                         p += 16;
 190                         /* 16 is is signer thumbprint [20 bytes] */
 191                         p += 20;
 192                         /* 36 is CPL id [16 bytes] */
 193                         string const cpl_id = get_uuid (&p);
 194                         /* 52 is key type [4 bytes] */
 195                         string const key_type = get (&p, 4);
 196                         /* 56 is key id [16 bytes] */
 197                         string const key_id = get_uuid (&p);
 198                         /* 72 is not-valid-before (a string) [25 bytes] */
 199                         p += 25;
 200                         /* 97 is not-valid-after (a string) [25 bytes] */
 201                         p += 25;
 202                         /* 112 is the key [ASDCP::KeyLen bytes] */
 203                         add_key (key_type, key_id, Key (p), cpl_id, SMPTE);
 204                         break;
 205                 }
 206                 default:
 207                         DCP_ASSERT (false);
 208                 }
 209
 210                 delete[] decrypted;
 211         }
 212
 213         RSA_free (rsa);
 214         BIO_free (bio);
 215
 216         _annotation_text = kdm.annotation_text ();
 217         _content_title_text = kdm.content_title_text ();
 218         _issue_date = kdm.issue_date ();
 219 }
 220
 221 DecryptedKDM::DecryptedKDM (
 222         LocalTime not_valid_before,
 223         LocalTime not_valid_after,
 224         string annotation_text,
 225         string content_title_text,
 226         string issue_date
 227         )
 228         : _not_valid_before (not_valid_before)
 229         , _not_valid_after (not_valid_after)
 230         , _annotation_text (annotation_text)
 231         , _content_title_text (content_title_text)
 232         , _issue_date (issue_date)
 233 {
 234
 235 }
 236
 237 DecryptedKDM::DecryptedKDM (
 238         string cpl_id,
 239         map<shared_ptr<const ReelMXF>, Key> keys,
 240         LocalTime not_valid_before,
 241         LocalTime not_valid_after,
 242         string annotation_text,
 243         string content_title_text,
 244         string issue_date
 245         )
 246         : _not_valid_before (not_valid_before)
 247         , _not_valid_after (not_valid_after)
 248         , _annotation_text (annotation_text)
 249         , _content_title_text (content_title_text)
 250         , _issue_date (issue_date)
 251 {
 252         for (map<shared_ptr<const ReelMXF>, Key>::const_iterator i = keys.begin(); i != keys.end(); ++i) {
 253                 add_key (i->first->key_type(), i->first->key_id().get(), i->second, cpl_id, SMPTE);
 254         }
 255 }
 256
 257 DecryptedKDM::DecryptedKDM (
 258         shared_ptr<const CPL> cpl,
 259         Key key,
 260         LocalTime not_valid_before,
 261         LocalTime not_valid_after,
 262         string annotation_text,
 263         string content_title_text,
 264         string issue_date
 265         )
 266         : _not_valid_before (not_valid_before)
 267         , _not_valid_after (not_valid_after)
 268         , _annotation_text (annotation_text)
 269         , _content_title_text (content_title_text)
 270         , _issue_date (issue_date)
 271 {
 272         /* Create DecryptedKDMKey objects for each encryptable asset */
 273         bool did_one = false;
 274         BOOST_FOREACH(shared_ptr<const ReelAsset> i, cpl->reel_assets ()) {
 275                 shared_ptr<const ReelMXF> mxf = boost::dynamic_pointer_cast<const ReelMXF> (i);
 276                 if (mxf && mxf->key_id ()) {
 277                         add_key (mxf->key_type(), mxf->key_id().get(), key, cpl->id(), SMPTE);
 278                         did_one = true;
 279                 }
 280         }
 281
 282         if (!did_one) {
 283                 throw NotEncryptedError (cpl->id ());
 284         }
 285 }
 286
 287 /** @param type (MDIK, MDAK etc.)
 288  *  @param key_id Key ID.
 289  *  @param key The actual symmetric key.
 290  *  @param cpl_id ID of CPL that the key is for.
 291  */
 292 void
 293 DecryptedKDM::add_key (optional<string> type, string key_id, Key key, string cpl_id, Standard standard)
 294 {
 295         _keys.push_back (DecryptedKDMKey (type, key_id, key, cpl_id, standard));
 296 }
 297
 298 void
 299 DecryptedKDM::add_key (DecryptedKDMKey key)
 300 {
 301         _keys.push_back (key);
 302 }
 303
 304 EncryptedKDM
 305 DecryptedKDM::encrypt (
 306         shared_ptr<const CertificateChain> signer, Certificate recipient, vector<Certificate> trusted_devices, Formulation formulation
 307         ) const
 308 {
 309         list<pair<string, string> > key_ids;
 310         list<string> keys;
 311         BOOST_FOREACH (DecryptedKDMKey const & i, _keys) {
 312                 /* We're making SMPTE keys so we must have a type for each one */
 313                 DCP_ASSERT (i.type());
 314                 key_ids.push_back (make_pair (i.type().get(), i.id ()));
 315
 316                 /* XXX: SMPTE only */
 317                 uint8_t block[138];
 318                 uint8_t* p = block;
 319
 320                 put (&p, smpte_structure_id, 16);
 321
 322                 base64_decode (signer->leaf().thumbprint (), p, 20);
 323                 p += 20;
 324
 325                 put_uuid (&p, i.cpl_id ());
 326                 put (&p, i.type().get());
 327                 put_uuid (&p, i.id ());
 328                 put (&p, _not_valid_before.as_string ());
 329                 put (&p, _not_valid_after.as_string ());
 330                 put (&p, i.key().value(), ASDCP::KeyLen);
 331
 332                 /* Encrypt using the projector's public key */
 333                 RSA* rsa = recipient.public_key ();
 334                 unsigned char encrypted[RSA_size(rsa)];
 335                 int const encrypted_len = RSA_public_encrypt (p - block, block, encrypted, rsa, RSA_PKCS1_OAEP_PADDING);
 336                 if (encrypted_len == -1) {
 337                         throw MiscError (String::compose ("Could not encrypt KDM (%1)", ERR_error_string (ERR_get_error(), 0)));
 338                 }
 339
 340                 /* Lazy overallocation */
 341                 char out[encrypted_len * 2];
 342                 Kumu::base64encode (encrypted, encrypted_len, out, encrypted_len * 2);
 343                 int const N = strlen (out);
 344                 string lines;
 345                 for (int i = 0; i < N; ++i) {
 346                         if (i > 0 && (i % 64) == 0) {
 347                                 lines += "\n";
 348                         }
 349                         lines += out[i];
 350                 }
 351
 352                 keys.push_back (lines);
 353         }
 354
 355         string device_list_description = recipient.subject_common_name ();
 356         if (device_list_description.find (".") != string::npos) {
 357                 device_list_description = device_list_description.substr (device_list_description.find (".") + 1);
 358         }
 359
 360         return EncryptedKDM (
 361                 signer,
 362                 recipient,
 363                 trusted_devices,
 364                 _keys.front().cpl_id (),
 365                 _content_title_text,
 366                 _annotation_text,
 367                 _not_valid_before,
 368                 _not_valid_after,
 369                 formulation,
 370                 key_ids,
 371                 keys
 372                 );
 373 }