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