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