tools/dcpdecryptmxf.cc

   1 /*
   2     Copyright (C) 2016-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 #include "atmos_asset.h"
  36 #include "atmos_asset_reader.h"
  37 #include "atmos_asset_writer.h"
  38 #include "atmos_frame.h"
  39 #include "crypto_context.h"
  40 #include "decrypted_kdm.h"
  41 #include "encrypted_kdm.h"
  42 #include "exceptions.h"
  43 #include "key.h"
  44 #include "mono_picture_asset.h"
  45 #include "mono_picture_asset_writer.h"
  46 #include "util.h"
  47 #include "version.h"
  48 #include <asdcp/AS_DCP.h>
  49 #include <getopt.h>
  50 #include <iostream>
  51 #include <string>
  52
  53
  54 using std::cerr;
  55 using std::cout;
  56 using std::shared_ptr;
  57 using std::string;
  58 using boost::optional;
  59
  60
  61 static void
  62 help (string n)
  63 {
  64         cerr << "Re-write a MXF (decrypting it if required)\n"
  65              << "Syntax: " << n << " [OPTION] <MXF>]\n"
  66              << "  --version          show libdcp version\n"
  67              << "  -v, --verbose      be verbose\n"
  68              << "  -h, --help         show this help\n"
  69              << "  -o, --output       output filename\n"
  70              << "  -k, --kdm          KDM file\n"
  71              << "  -p, --private-key  private key file\n"
  72              << "  -t, --type         MXF type: picture or atmos\n"
  73              << "  -i, --ignore-hmac  don't raise an error if HMACs don't agree\n";
  74 }
  75
  76 template <class T, class U>
  77 void copy (T const& in, shared_ptr<U> writer, bool ignore_hmac)
  78 {
  79         auto reader = in.start_read();
  80         reader->set_check_hmac (!ignore_hmac);
  81         for (int64_t i = 0; i < in.intrinsic_duration(); ++i) {
  82                 auto frame = reader->get_frame (i);
  83                 writer->write (frame->data(), frame->size());
  84         }
  85         writer->finalize();
  86 };
  87
  88
  89 int
  90 main (int argc, char* argv[])
  91 {
  92         dcp::init ();
  93
  94         bool verbose = false;
  95         optional<boost::filesystem::path> output_file;
  96         optional<boost::filesystem::path> kdm_file;
  97         optional<boost::filesystem::path> private_key_file;
  98         bool ignore_hmac = false;
  99
 100         enum class Type {
 101                 PICTURE,
 102                 ATMOS,
 103         };
 104
 105         optional<Type> type;
 106
 107         int option_index = 0;
 108         while (true) {
 109                 struct option long_options[] = {
 110                         { "version", no_argument, 0, 'A' },
 111                         { "verbose", no_argument, 0, 'v' },
 112                         { "help", no_argument, 0, 'h' },
 113                         { "output", required_argument, 0, 'o'},
 114                         { "kdm", required_argument, 0, 'k'},
 115                         { "private-key", required_argument, 0, 'p'},
 116                         { "type", required_argument, 0, 't' },
 117                         { "ignore-hmac", no_argument, 0, 'i' },
 118                         { 0, 0, 0, 0 }
 119                 };
 120
 121                 int c = getopt_long (argc, argv, "Avho:k:p:t:i", long_options, &option_index);
 122
 123                 if (c == -1) {
 124                         break;
 125                 }
 126
 127                 switch (c) {
 128                 case 'A':
 129                         cout << "libdcp version " << dcp::version << "\n";
 130                         exit (EXIT_SUCCESS);
 131                 case 'v':
 132                         verbose = true;
 133                         break;
 134                 case 'h':
 135                         help (argv[0]);
 136                         exit (EXIT_SUCCESS);
 137                 case 'o':
 138                         output_file = optarg;
 139                         break;
 140                 case 'k':
 141                         kdm_file = optarg;
 142                         break;
 143                 case 'p':
 144                         private_key_file = optarg;
 145                         break;
 146                 case 't':
 147                         if (strcmp(optarg, "picture") == 0) {
 148                                 type = Type::PICTURE;
 149                         } else if (strcmp(optarg, "atmos") == 0) {
 150                                 type = Type::ATMOS;
 151                         } else {
 152                                 cerr << "Unknown MXF type " << optarg << "\n";
 153                                 exit (EXIT_FAILURE);
 154                         }
 155                         break;
 156                 case 'i':
 157                         ignore_hmac = true;
 158                         break;
 159                 }
 160         }
 161
 162         if (optind >= argc) {
 163                 help (argv[0]);
 164                 exit (EXIT_FAILURE);
 165         }
 166
 167         boost::filesystem::path input_file = argv[optind];
 168
 169         if (!output_file) {
 170                 cerr << "You must specify -o or --output\n";
 171                 exit (EXIT_FAILURE);
 172         }
 173
 174         if (!kdm_file) {
 175                 cerr << "You must specify -k or --kdm\n";
 176                 exit (EXIT_FAILURE);
 177         }
 178
 179         if (!private_key_file) {
 180                 cerr << "You must specify -p or --private-key\n";
 181                 exit (EXIT_FAILURE);
 182         }
 183
 184         if (!type) {
 185                 cerr << "You must specify -t or --type\n";
 186                 exit (EXIT_FAILURE);
 187         }
 188
 189         dcp::EncryptedKDM encrypted_kdm (dcp::file_to_string (kdm_file.get ()));
 190         dcp::DecryptedKDM decrypted_kdm (encrypted_kdm, dcp::file_to_string (private_key_file.get()));
 191
 192         auto add_key = [verbose](dcp::MXF& mxf, dcp::DecryptedKDM const& kdm) {
 193                 auto key_id = mxf.key_id();
 194                 if (key_id) {
 195                         if (verbose) {
 196                                 cout << "Asset is encrypted.\n";
 197                         }
 198                         auto keys = kdm.keys();
 199                         auto key = std::find_if (keys.begin(), keys.end(), [key_id](dcp::DecryptedKDMKey const& k) { return k.id() == *key_id; });
 200                         if (key == keys.end()) {
 201                                 cout << "No key found in KDM.\n";
 202                                 exit(EXIT_FAILURE);
 203                         }
 204                         if (verbose) {
 205                                 cout << "Key found in KDM.\n";
 206                         }
 207                         mxf.set_key (key->key());
 208                 }
 209         };
 210
 211         try {
 212                 switch (*type) {
 213                 case Type::ATMOS:
 214                 {
 215                         dcp::AtmosAsset in (input_file);
 216                         add_key (in, decrypted_kdm);
 217                         dcp::AtmosAsset out (
 218                                 in.edit_rate(),
 219                                 in.first_frame(),
 220                                 in.max_channel_count(),
 221                                 in.max_object_count(),
 222                                 in.atmos_version()
 223                                 );
 224                         auto writer = out.start_write(output_file.get());
 225                         copy (in, writer, ignore_hmac);
 226                         break;
 227                 }
 228                 case Type::PICTURE:
 229                 {
 230                         dcp::MonoPictureAsset in (input_file);
 231                         add_key (in, decrypted_kdm);
 232                         dcp::MonoPictureAsset out (in.edit_rate(), dcp::Standard::SMPTE);
 233                         auto writer = out.start_write(output_file.get(), dcp::PictureAsset::Behaviour::MAKE_NEW);
 234                         copy (in, writer, ignore_hmac);
 235                         break;
 236                 }
 237                 }
 238         } catch (dcp::ReadError& e) {
 239                 cerr << "Read error: " << e.what() << "\n";
 240                 return EXIT_FAILURE;
 241         }
 242
 243         return 0;
 244 }