Initial Code Drop

This is the initial code drop of the reference implementation and
test cases for the Widevine Whitebox API.

In this drop, the full reference implementation for the AEAD
white-box is provided and all test cases verifying the top-level
behave have are enabled. Since the implementations can vary so much
the testing is mostly left to verifying the return codes for specific
parameter conditions.

A full reference implementation for the license white-box is provided,
however not all tests are implemented or enabled. A number of tests
have been disabled as they required a loaded license and test licenses
are still being worked on.

The two license white-box API functions that are the further from
competition are ProcessLicenseResponse() and MaskedDecryt().
ProcessLicenseResponse() is still being worked on and MaskedDecrypt()
is waiting on Decrypt() to be fully functional.

Most tests focus on verifying return code for specific parameter
conditions, but as test licenses are created, tests looking to test
the internal behaviour of license management will be added to
ProcessLicenseResponse(), Decrypt(), and MaskedDecrypt().

chromium_deps/base/BUILD

@@ -0,0 +1,22 @@
+# Copyright 2020 Google LLC. All Rights Reserved.
+
+cc_library(
+    name = "base",
+    srcs = [
+        "base64.cc",
+        "strings/string_number_conversions.cc",
+    ],
+    hdrs = [
+        "base64.h",
+        "logging.h",
+        "strings/string_number_conversions.h",
+    ],
+    strip_include_prefix = "//chromium_deps",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//external:gflags",
+        "//external:glog",
+        "@abseil_repo//absl/base",
+        "@abseil_repo//absl/strings",
+    ],
+)

chromium_deps/base/base64.cc

@@ -0,0 +1,63 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#include "base/base64.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace base {
+
+namespace {
+
+static const char kBase64Codes[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+// Calculates a/b using round-up division (only works for numbers
+// greater than 0).
+constexpr size_t CeilDivide(size_t a, size_t b) {
+  return ((a - 1) / b) + 1;
+}
+
+}  // namespace
+
+void Base64Encode(const std::string& input, std::string* output) {
+  if (input.empty()) {
+    output->clear();
+    return;
+  }
+
+  // |temp| stores a 24-bit block that is treated as an array where insertions
+  // occur from high to low.
+  uint32_t temp = 0;
+  size_t out_index = 0;
+  const size_t out_size = CeilDivide(input.size(), 3) * 4;
+  std::string result(out_size, '\0');
+  for (size_t i = 0; i < input.size(); i++) {
+    // "insert" 8-bits of data
+    temp = (temp << 8) | (input[i] & 0x0FF);
+
+    if (i % 3 == 2) {
+      result[out_index++] = kBase64Codes[(temp >> 18) & 0x3f];
+      result[out_index++] = kBase64Codes[(temp >> 12) & 0x3f];
+      result[out_index++] = kBase64Codes[(temp >> 6) & 0x3f];
+      result[out_index++] = kBase64Codes[temp & 0x3f];
+      temp = 0;
+    }
+  }
+
+  if (input.size() % 3 == 1) {
+    result[out_index++] = kBase64Codes[(temp >> 18) & 0x3f];
+    result[out_index++] = kBase64Codes[(temp >> 12) & 0x3f];
+    result[out_index++] = '=';
+    result[out_index++] = '=';
+  } else if (input.size() % 3 == 2) {
+    result[out_index++] = kBase64Codes[(temp >> 18) & 0x3f];
+    result[out_index++] = kBase64Codes[(temp >> 12) & 0x3f];
+    result[out_index++] = kBase64Codes[(temp >> 6) & 0x3f];
+    result[out_index++] = '=';
+  }
+
+  output->swap(result);
+}
+
+}  // namespace base

chromium_deps/base/base64.h

@@ -0,0 +1,18 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef BASE_BASE64_H_
+#define BASE_BASE64_H_
+
+#include <string>
+
+namespace base {
+
+// Encodes the input string in base64.
+// Note that the Chromium code uses base::StringPiece for |input|, but to
+// avoid dragging in too much code, use std::string instead (which is
+// convertable to base::StringPiece automatically).
+void Base64Encode(const std::string& input, std::string* output);
+
+}  // namespace base
+
+#endif  // BASE_BASE64_H_

chromium_deps/base/logging.h

@@ -0,0 +1,10 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef BASE_LOGGING_H_
+#define BASE_LOGGING_H_
+
+// See https://github.com/google/glog/blob/master/doc/glog.html
+#define GLOG_NO_ABBREVIATED_SEVERITIES
+#include "glog/logging.h"
+
+#endif  // BASE_LOGGING_H_

chromium_deps/base/strings/string_number_conversions.cc

@@ -0,0 +1,14 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#include "base/strings/string_number_conversions.h"
+
+#include "absl/strings/escaping.h"
+
+namespace base {
+
+std::string HexEncode(const void* bytes, size_t size) {
+  return absl::BytesToHexString(
+      std::string(reinterpret_cast<const char*>(bytes), size));
+}
+
+}  // namespace base

chromium_deps/base/strings/string_number_conversions.h

@@ -0,0 +1,17 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
+#define BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string>
+
+namespace base {
+
+// Returns a hex string representation of a binary buffer.
+std::string HexEncode(const void* bytes, size_t size);
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_

chromium_deps/cdm/keys/BUILD

@@ -0,0 +1,16 @@
+# Copyright 2020 Google LLC. All Rights Reserved.
+
+cc_library(
+    name = "api",
+    hdrs = ["certs.h"],
+    strip_include_prefix = "//chromium_deps",
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "dev_certs",
+    srcs = ["dev_rsa_drm_certificate.cc"],
+    strip_include_prefix = "//chromium_deps",
+    visibility = ["//visibility:public"],
+    deps = [":api"],
+)

chromium_deps/cdm/keys/certs.h

@@ -0,0 +1,17 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef CDM_KEYS_CERTS_H_
+#define CDM_KEYS_CERTS_H_
+
+#include <stdint.h>
+#include <cstddef>
+
+namespace wvcdm {
+
+// RsaDrmCertificate Generated by the Keysmith provisioning service.
+extern const uint8_t kRsaDrmCertificate[];
+extern const size_t kRsaDrmCertificateSize;
+
+}  // namespace wvcdm
+
+#endif  // CDM_KEYS_CERTS_H_

chromium_deps/cdm/keys/dev_rsa_drm_certificate.cc

@@ -0,0 +1,116 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#include "cdm/keys/certs.h"
+
+namespace wvcdm {
+
+const uint8_t kRsaDrmCertificate[] = {
+    0x0a, 0xae, 0x02, 0x08, 0x02, 0x12, 0x10, 0x71, 0x39, 0x67, 0x63, 0x66,
+    0xff, 0xfc, 0x41, 0x52, 0x1b, 0x73, 0x8b, 0xaf, 0xd5, 0xd7, 0xb5, 0x18,
+    0xf2, 0xf5, 0x88, 0xdb, 0x05, 0x22, 0x8e, 0x02, 0x30, 0x82, 0x01, 0x0a,
+    0x02, 0x82, 0x01, 0x01, 0x00, 0xa5, 0x95, 0xe5, 0xd2, 0xa2, 0x4a, 0x95,
+    0xf7, 0x92, 0xda, 0x7c, 0x4c, 0x1e, 0x4c, 0x12, 0xdf, 0x87, 0x06, 0xef,
+    0x65, 0x92, 0x14, 0x52, 0x23, 0x8d, 0x88, 0x77, 0x35, 0x69, 0xf5, 0x97,
+    0x95, 0x5b, 0xb9, 0x3f, 0xdb, 0x96, 0x68, 0x49, 0x6d, 0x9a, 0x5e, 0x05,
+    0x37, 0x30, 0xad, 0x0d, 0xc9, 0x2a, 0x98, 0xfc, 0x20, 0x16, 0xc8, 0x9d,
+    0x12, 0x8a, 0x1d, 0xea, 0xb8, 0x91, 0xd6, 0xc3, 0x95, 0x32, 0xdb, 0x8b,
+    0x0d, 0x69, 0xf2, 0xae, 0xe7, 0x7c, 0x8c, 0x04, 0x83, 0xcd, 0xe8, 0xf7,
+    0x4d, 0xdf, 0xf1, 0xc9, 0xf7, 0x28, 0xcd, 0x1a, 0x39, 0xf6, 0xcf, 0x14,
+    0xb9, 0x61, 0x8b, 0xb4, 0xdf, 0xa3, 0x6a, 0xbe, 0x3b, 0x96, 0x39, 0x48,
+    0x2e, 0x4e, 0x19, 0xe4, 0x87, 0xb8, 0xcf, 0xbf, 0xb7, 0xf6, 0x60, 0xb2,
+    0x56, 0x57, 0x1f, 0x54, 0x21, 0x17, 0xc3, 0x83, 0x61, 0x4f, 0xa1, 0xa2,
+    0x56, 0x65, 0x27, 0x45, 0x10, 0xc2, 0x83, 0x68, 0x8f, 0xf1, 0xf6, 0x78,
+    0xa0, 0x44, 0x96, 0x76, 0xac, 0x3c, 0x32, 0x57, 0x66, 0xbf, 0x40, 0xc0,
+    0x9d, 0xf2, 0x84, 0x59, 0x8d, 0x1d, 0x5c, 0xb8, 0x50, 0x52, 0x2c, 0x95,
+    0x50, 0xec, 0xc2, 0x43, 0x65, 0x82, 0xc4, 0xc1, 0xdf, 0xb0, 0x52, 0x46,
+    0x84, 0x57, 0x15, 0xb7, 0xe7, 0x61, 0xfb, 0x0a, 0x11, 0x61, 0x65, 0x7c,
+    0x00, 0xe2, 0x18, 0x37, 0xb1, 0x8a, 0x3e, 0x5f, 0xc4, 0xe0, 0xaf, 0x75,
+    0x72, 0xb6, 0x97, 0xee, 0xf0, 0xf0, 0x9e, 0x42, 0xf7, 0xec, 0x8d, 0xff,
+    0x76, 0x29, 0xe1, 0xdc, 0xa7, 0xf7, 0x80, 0x82, 0xf1, 0x69, 0x9a, 0xd4,
+    0xfc, 0x00, 0xd2, 0x48, 0x22, 0x70, 0x06, 0xce, 0xea, 0xc2, 0x4f, 0x67,
+    0x69, 0x0f, 0x72, 0xd3, 0x77, 0xde, 0xeb, 0x49, 0x4c, 0xfb, 0x2a, 0xd3,
+    0x97, 0xcf, 0x65, 0x34, 0xb7, 0x43, 0xb4, 0x67, 0x01, 0x02, 0x03, 0x01,
+    0x00, 0x01, 0x28, 0xc0, 0x4f, 0x12, 0x80, 0x02, 0x31, 0xa9, 0x72, 0x76,
+    0x10, 0x33, 0x98, 0xb5, 0xba, 0x64, 0xc7, 0xd9, 0xb2, 0x33, 0xea, 0x93,
+    0x7c, 0xc6, 0x76, 0xd4, 0x12, 0x2d, 0x60, 0x5e, 0xc8, 0xb6, 0x28, 0xf6,
+    0x94, 0xb8, 0xb5, 0x9c, 0x30, 0xad, 0xdd, 0xe2, 0x2e, 0xf4, 0x83, 0x31,
+    0x60, 0xd3, 0x32, 0xe6, 0x3c, 0xdf, 0x02, 0x5c, 0xe5, 0xa2, 0x2e, 0x7e,
+    0x27, 0xc4, 0xd1, 0x75, 0x86, 0x80, 0x6e, 0x1e, 0xc2, 0xa0, 0x27, 0x9d,
+    0xe0, 0x06, 0xdb, 0xb0, 0x8c, 0xda, 0xb4, 0x60, 0x0f, 0x62, 0x9b, 0x40,
+    0x62, 0x59, 0x4f, 0x49, 0x55, 0x8e, 0x71, 0x67, 0xdd, 0x1c, 0x02, 0xdf,
+    0x22, 0x8b, 0xdb, 0xb4, 0x00, 0x9e, 0x5f, 0x2e, 0xf0, 0xdb, 0x8a, 0x75,
+    0xc7, 0xef, 0x51, 0x51, 0xd5, 0x99, 0xc3, 0x1d, 0x8f, 0x58, 0x6d, 0x1f,
+    0x70, 0x1a, 0xca, 0x35, 0x92, 0xfe, 0xd5, 0x06, 0x2a, 0x0b, 0x54, 0x4f,
+    0xd1, 0x59, 0xf7, 0xa7, 0xf3, 0xd7, 0xfc, 0xc0, 0xf6, 0xd2, 0x3e, 0x69,
+    0xf7, 0x8e, 0xf9, 0x36, 0x69, 0x4d, 0xdd, 0xae, 0xd5, 0x9c, 0x7b, 0xf5,
+    0xd4, 0x24, 0x11, 0x03, 0xd2, 0x9b, 0xd1, 0x3a, 0xe3, 0xc4, 0x00, 0x00,
+    0x43, 0x39, 0xe7, 0x42, 0x95, 0x2b, 0x4e, 0x67, 0xa8, 0xde, 0xf2, 0xd0,
+    0x64, 0xf1, 0xd5, 0x94, 0x3f, 0x92, 0x1d, 0xc2, 0x90, 0x20, 0x3d, 0xad,
+    0x28, 0xef, 0xef, 0x9d, 0x7e, 0x8a, 0xc9, 0xff, 0x78, 0xb0, 0x22, 0x49,
+    0x96, 0xfc, 0xb7, 0x7e, 0xb6, 0x56, 0x64, 0x13, 0x1c, 0x20, 0xfb, 0x5d,
+    0xd9, 0x30, 0xcd, 0xcd, 0x44, 0x30, 0xc3, 0x2b, 0x58, 0x80, 0x8f, 0xb0,
+    0x13, 0xe8, 0xa0, 0x86, 0xc8, 0x83, 0x30, 0x84, 0xd8, 0x32, 0xd6, 0x3c,
+    0x42, 0x1c, 0x03, 0xa3, 0x97, 0x7c, 0x46, 0x66, 0x74, 0x28, 0x3b, 0xc3,
+    0x87, 0xa0, 0x54, 0xf7, 0x20, 0x6c, 0x12, 0x95, 0x60, 0xb7, 0x78, 0x8c,
+    0x1a, 0xb4, 0x05, 0x0a, 0xae, 0x02, 0x08, 0x01, 0x12, 0x10, 0xa9, 0x1a,
+    0x6e, 0x6c, 0x1b, 0xdd, 0xd5, 0x51, 0xb7, 0x79, 0x92, 0x85, 0xf8, 0x36,
+    0x98, 0xeb, 0x18, 0x96, 0xf4, 0x88, 0xdb, 0x05, 0x22, 0x8e, 0x02, 0x30,
+    0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0x9a, 0x67, 0x88, 0x01,
+    0x3a, 0x17, 0x7b, 0x2d, 0x4e, 0xb3, 0xff, 0xc1, 0x8a, 0x0e, 0x7e, 0x2c,
+    0x83, 0xe4, 0x38, 0x0f, 0x56, 0x85, 0x8f, 0xb0, 0x1e, 0x47, 0x03, 0x8e,
+    0x99, 0x3a, 0xee, 0x9a, 0x24, 0x35, 0x60, 0xce, 0x31, 0x4f, 0x71, 0x76,
+    0x1a, 0x24, 0x02, 0x77, 0x84, 0x82, 0x73, 0xdd, 0x27, 0x22, 0x05, 0x8e,
+    0xb1, 0xc7, 0x2e, 0x71, 0xab, 0x29, 0xb8, 0xe2, 0xe7, 0x86, 0x93, 0xd1,
+    0xee, 0xab, 0x33, 0xe0, 0xe3, 0x1b, 0xe0, 0x4a, 0x3f, 0xd2, 0xe0, 0x8c,
+    0x16, 0x44, 0x9b, 0xe3, 0x3b, 0xd0, 0x54, 0x86, 0x2c, 0xba, 0x2e, 0xe4,
+    0xf2, 0xa9, 0x6a, 0x2c, 0xff, 0x28, 0x32, 0x9d, 0xb1, 0x7c, 0x8b, 0x34,
+    0xd2, 0xf9, 0x64, 0x91, 0xf1, 0x05, 0xe6, 0x47, 0xb7, 0xd9, 0xb6, 0x52,
+    0x64, 0xd7, 0x0f, 0x02, 0x10, 0xee, 0x6a, 0xef, 0x3b, 0x85, 0x4c, 0xdf,
+    0x8c, 0xa9, 0x44, 0x12, 0x29, 0xe5, 0x60, 0x43, 0x37, 0x14, 0x14, 0x14,
+    0x71, 0xa1, 0x62, 0xb1, 0x27, 0xe2, 0xb5, 0xf1, 0x08, 0xb9, 0x84, 0x8c,
+    0xea, 0x80, 0x31, 0x9a, 0x1c, 0xd9, 0xce, 0xac, 0x47, 0x7b, 0xd0, 0x0f,
+    0xf6, 0x81, 0x3e, 0xc1, 0x67, 0xa7, 0x62, 0xd8, 0x8d, 0xb9, 0xba, 0xbf,
+    0xc8, 0x34, 0x3d, 0xa0, 0x6b, 0xcc, 0x71, 0x2c, 0x61, 0xf3, 0x1a, 0xbb,
+    0x6b, 0x3a, 0xdd, 0x18, 0xf5, 0x14, 0x3f, 0x5a, 0xb9, 0x18, 0x70, 0x14,
+    0xfe, 0x1a, 0x44, 0x3c, 0xab, 0x61, 0xeb, 0x56, 0x8d, 0x78, 0x30, 0xb1,
+    0x56, 0x0e, 0xb8, 0x9e, 0x67, 0xa4, 0xd4, 0x45, 0xcc, 0x89, 0xdf, 0x9a,
+    0x26, 0xf4, 0xce, 0x72, 0x2c, 0x01, 0x2b, 0x76, 0xe2, 0xb3, 0x3b, 0x4e,
+    0x58, 0x42, 0x8c, 0x8d, 0xd9, 0x22, 0xad, 0xe3, 0x69, 0x1a, 0x0d, 0xfe,
+    0xb3, 0x4a, 0x57, 0xcf, 0xad, 0xa9, 0x9b, 0x2f, 0xcf, 0xba, 0xbe, 0x57,
+    0x02, 0x03, 0x01, 0x00, 0x01, 0x28, 0xc0, 0x4f, 0x12, 0x80, 0x03, 0x72,
+    0x0e, 0x99, 0x92, 0xd3, 0xfe, 0x38, 0x15, 0x29, 0xcf, 0x2f, 0x70, 0x78,
+    0x92, 0x30, 0x3b, 0x3f, 0x43, 0xe5, 0x9c, 0xaf, 0xc5, 0x18, 0xe1, 0x4c,
+    0x3c, 0xc8, 0xc6, 0xb9, 0x71, 0xd0, 0x16, 0x51, 0x19, 0xf1, 0x30, 0x41,
+    0xfa, 0x9e, 0x74, 0x6b, 0xce, 0xb3, 0x8e, 0xc5, 0x86, 0xc2, 0xce, 0x1c,
+    0x36, 0x00, 0xa7, 0x74, 0x7f, 0x1f, 0xd1, 0xe9, 0xff, 0x1e, 0xd8, 0x93,
+    0xd2, 0x75, 0x16, 0x86, 0x67, 0x1d, 0xdc, 0x3e, 0x4e, 0x32, 0xe7, 0xc3,
+    0x6d, 0xf2, 0xd1, 0xfd, 0xd2, 0xa2, 0xa7, 0x8c, 0x17, 0xe5, 0x3f, 0x3a,
+    0xd7, 0x23, 0xa6, 0xfb, 0x29, 0xf1, 0xee, 0xc6, 0xf0, 0x20, 0xf0, 0xb8,
+    0x04, 0x8d, 0xd5, 0x85, 0x30, 0xc4, 0xb6, 0xec, 0x9e, 0x79, 0x54, 0x9d,
+    0x44, 0x55, 0x34, 0x45, 0xb9, 0x51, 0xf4, 0xc9, 0x17, 0x7e, 0xdd, 0xe1,
+    0xb1, 0x77, 0x24, 0x12, 0x71, 0x08, 0x09, 0xbc, 0xf4, 0x29, 0xa6, 0x63,
+    0x01, 0x00, 0x89, 0xa7, 0xb0, 0xd3, 0xe0, 0xc4, 0x46, 0x9c, 0x61, 0x06,
+    0x23, 0xa3, 0x15, 0x52, 0x39, 0x80, 0x34, 0x4e, 0xb7, 0x4e, 0xd9, 0x1f,
+    0x72, 0x48, 0x4a, 0xdc, 0xf0, 0x0c, 0xfa, 0x69, 0x4c, 0x62, 0x29, 0x06,
+    0x82, 0xc3, 0x54, 0x96, 0xbe, 0xfa, 0xb9, 0x0f, 0xbd, 0x53, 0x26, 0x3e,
+    0x89, 0xbc, 0xa7, 0xdc, 0xb7, 0x7a, 0xfe, 0xfd, 0x96, 0xa8, 0xfe, 0x00,
+    0x6d, 0xd3, 0x7f, 0xf3, 0xab, 0x1c, 0x9f, 0x43, 0x99, 0x40, 0x62, 0xd4,
+    0xce, 0x21, 0xcd, 0x63, 0x15, 0xce, 0x1b, 0xfe, 0x91, 0xc6, 0xcc, 0x3d,
+    0x42, 0x8c, 0x1e, 0xee, 0x4b, 0x8a, 0xf3, 0xbb, 0xcb, 0x91, 0x1f, 0xed,
+    0x7e, 0x68, 0xc5, 0x34, 0xb9, 0x53, 0x51, 0x8c, 0x23, 0x4b, 0x8c, 0xc7,
+    0x34, 0x3f, 0x70, 0x83, 0x7c, 0xa6, 0xce, 0x8c, 0x31, 0x1e, 0xbf, 0x56,
+    0xf5, 0x68, 0x87, 0x1b, 0x04, 0xec, 0x5b, 0x89, 0x80, 0x30, 0x35, 0x23,
+    0xd1, 0x2d, 0x22, 0xc8, 0x7f, 0xdd, 0x02, 0x4c, 0xa4, 0xbc, 0x3a, 0xa8,
+    0xe6, 0x98, 0x92, 0xe6, 0xc0, 0xc0, 0x79, 0x5f, 0x87, 0xde, 0xfc, 0x88,
+    0x33, 0xff, 0x3a, 0x3a, 0xd0, 0xdf, 0x09, 0x8a, 0x4e, 0x50, 0xa1, 0xa5,
+    0x73, 0xdf, 0x26, 0xc6, 0x1a, 0x38, 0xff, 0xef, 0x43, 0x30, 0x89, 0xac,
+    0x45, 0xec, 0xc9, 0x73, 0xc4, 0x18, 0x53, 0xa8, 0x36, 0x5f, 0xb4, 0x45,
+    0xc9, 0x43, 0xaf, 0xe8, 0x90, 0xaf, 0xae, 0x32, 0x2d, 0x15, 0xd8, 0x19,
+    0x07, 0x30, 0x0f, 0x57, 0xab, 0x6d, 0x21, 0x3c, 0x73, 0x63, 0x4c, 0x17,
+    0x7b, 0xeb, 0x3a, 0xb5, 0x19, 0x1e, 0xa7, 0x85, 0xf5, 0x67, 0x6b, 0x1f,
+    0x72, 0x39, 0xb1, 0x5c, 0xb7, 0xff, 0x1b, 0xe1, 0x01, 0x0f, 0x82, 0x7e,
+    0xbe, 0xaa, 0xd7, 0x63, 0xbe, 0x75, 0x04, 0x94, 0xa7, 0xf9, 0xd2};
+
+const size_t kRsaDrmCertificateSize = sizeof(kRsaDrmCertificate);
+
+}  // namespace wvcdm

chromium_deps/cdm/protos/BUILD

@@ -0,0 +1,13 @@
+# Copyright 2020 Google LLC. All Rights Reserved.
+
+# Protobuf generated code doesn't like it when include prefixes are
+# stripped off. So this is a stub to mimic the protobuf C++ header.
+cc_library(
+    name = "license_protocol_proto",
+    hdrs = ["license_protocol.pb.h"],
+    strip_include_prefix = "//chromium_deps",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//chromium_deps/cdm/protos/defs:license_protocol_proto",
+    ],
+)

chromium_deps/cdm/protos/defs/BUILD

@@ -0,0 +1,34 @@
+# Copyright 2020 Google LLC. All Rights Reserved.
+
+# Protocol buffer definitions for Widevine Services.
+package(default_visibility = ["//visibility:public"])
+
+load("@com_google_protobuf//:protobuf.bzl", "cc_proto_library")
+
+cc_proto_library(
+    name = "client_identification_proto",
+    srcs = ["client_identification.proto"],
+    default_runtime = "@com_google_protobuf//:protobuf",
+    protoc = "@com_google_protobuf//:protoc",
+)
+
+cc_proto_library(
+    name = "license_protocol_proto",
+    srcs = ["license_protocol.proto"],
+    default_runtime = "@com_google_protobuf//:protobuf",
+    protoc = "@com_google_protobuf//:protoc",
+    deps = [
+        ":client_identification_proto",
+        ":remote_attestation_proto",
+    ],
+)
+
+cc_proto_library(
+    name = "remote_attestation_proto",
+    srcs = ["remote_attestation.proto"],
+    default_runtime = "@com_google_protobuf//:protobuf",
+    protoc = "@com_google_protobuf//:protoc",
+    deps = [
+        ":client_identification_proto",
+    ],
+)

chromium_deps/cdm/protos/defs/client_identification.proto

@@ -0,0 +1,124 @@
+// Copyright 2016 Google LLC. All rights reserved.
+
+// Author: tinskip@google.com (Thomas Inskip)
+//
+// Description:
+//   ClientIdentification messages used by provisioning and license protocols.
+
+syntax = "proto2";
+
+package video_widevine;
+
+option optimize_for = LITE_RUNTIME;
+
+// ClientIdentification message used to authenticate the client device.
+message ClientIdentification {
+  enum TokenType {
+    KEYBOX = 0;
+    DRM_DEVICE_CERTIFICATE = 1;
+    REMOTE_ATTESTATION_CERTIFICATE = 2;
+    OEM_DEVICE_CERTIFICATE = 3;
+  }
+
+  message NameValue {
+    optional string name = 1;
+    optional string value = 2;
+  }
+
+  // Capabilities which not all clients may support. Used for the license
+  // exchange protocol only.
+  message ClientCapabilities {
+    enum HdcpVersion {
+      HDCP_NONE = 0;
+      HDCP_V1 = 1;
+      HDCP_V2 = 2;
+      HDCP_V2_1 = 3;
+      HDCP_V2_2 = 4;
+      HDCP_V2_3 = 5;
+      HDCP_NO_DIGITAL_OUTPUT = 0xff;
+    }
+
+    enum CertificateKeyType {
+      RSA_2048 = 0;
+      RSA_3072 = 1;
+      ECC_SECP256R1 = 2;
+      ECC_SECP384R1 = 3;
+      ECC_SECP521R1 = 4;
+    }
+
+    enum AnalogOutputCapabilities {
+      ANALOG_OUTPUT_UNKNOWN = 0;
+      ANALOG_OUTPUT_NONE = 1;
+      ANALOG_OUTPUT_SUPPORTED = 2;
+      ANALOG_OUTPUT_SUPPORTS_CGMS_A = 3;
+    }
+
+    optional bool client_token = 1 [default = false];
+    optional bool session_token = 2 [default = false];
+    optional bool video_resolution_constraints = 3 [default = false];
+    optional HdcpVersion max_hdcp_version = 4 [default = HDCP_NONE];
+    optional uint32 oem_crypto_api_version = 5;
+    // Client has hardware support for protecting the usage table, such as
+    // storing the generation number in secure memory.  For Details, see:
+    // https://docs.google.com/document/d/1Mm8oB51SYAgry62mEuh_2OEkabikBiS61kN7HsDnh9Y/edit#heading=h.xgjl2srtytjt
+    optional bool anti_rollback_usage_table = 6 [default = false];
+    // The client shall report |srm_version| if available.
+    optional uint32 srm_version = 7;
+    // A device may have SRM data, and report a version, but may not be capable
+    // of updating SRM data.
+    optional bool can_update_srm = 8 [default = false];
+    repeated CertificateKeyType supported_certificate_key_type = 9;
+    optional AnalogOutputCapabilities analog_output_capabilities = 10
+        [default = ANALOG_OUTPUT_UNKNOWN];
+    optional bool can_disable_analog_output = 11 [default = false];
+    // Clients can indicate a performance level supported by OEMCrypto.
+    // This will allow applications and providers to choose an appropriate
+    // quality of content to serve. Currently defined tiers are
+    // 1 (low), 2 (medium) and 3 (high). Any other value indicate that
+    // the resource rating is unavailable or reporting erroneous values
+    // for that device. For details see,
+    // https://docs.google.com/document/d/1wodSYK-Unj3AgTSXqujWuBCAFC00qF85G1AhfLtqdko
+    optional uint32 resource_rating_tier = 12 [default = 0];
+  }
+
+  message ClientCredentials {
+    optional TokenType type = 1 [default = KEYBOX];
+    optional bytes token = 2;
+  }
+
+  // Type of factory-provisioned device root of trust. Optional.
+  optional TokenType type = 1 [default = KEYBOX];
+  // Factory-provisioned device root of trust. Required.
+  optional bytes token = 2;
+  // Optional client information name/value pairs.
+  repeated NameValue client_info = 3;
+  // Client token generated by the content provider. Optional.
+  optional bytes provider_client_token = 4;
+  // Number of licenses received by the client to which the token above belongs.
+  // Only present if client_token is specified.
+  optional uint32 license_counter = 5;
+  // List of non-baseline client capabilities.
+  optional ClientCapabilities client_capabilities = 6;
+  // Serialized VmpData message. Optional.
+  optional bytes vmp_data = 7;
+  // Optional field that may contain additional provisioning credentials.
+  repeated ClientCredentials device_credentials = 8;
+}
+
+// EncryptedClientIdentification message used to hold ClientIdentification
+// messages encrypted for privacy purposes.
+message EncryptedClientIdentification {
+  // Provider ID for which the ClientIdentifcation is encrypted (owner of
+  // service certificate).
+  optional string provider_id = 1;
+  // Serial number for the service certificate for which ClientIdentification is
+  // encrypted.
+  optional bytes service_certificate_serial_number = 2;
+  // Serialized ClientIdentification message, encrypted with the privacy key
+  // using AES-128-CBC with PKCS#5 padding.
+  optional bytes encrypted_client_id = 3;
+  // Initialization vector needed to decrypt encrypted_client_id.
+  optional bytes encrypted_client_id_iv = 4;
+  // AES-128 privacy key, encrypted with the service public key using RSA-OAEP.
+  optional bytes encrypted_privacy_key = 5;
+}

chromium_deps/cdm/protos/defs/license_protocol.proto

@@ -0,0 +1,453 @@
+// Copyright 2016 Google LLC. All rights reserved.
+//
+// Description:
+//   Definitions of the protocol buffer messages used in the Widevine license
+//   exchange protocol, described in Widevine license exchange protocol document
+// TODO(yawenyu): find out a right way to strip out all the doc link.
+// MOE:begin_strip
+// Design doc at:
+//   http://doc/1cng6cDnchbDQDymLEd5MxMc_laS3EDv6IsoW3IzpgwQ
+// MOE:end_strip
+
+syntax = "proto2";
+
+package video_widevine;
+
+import "chromium_deps/cdm/protos/defs/client_identification.proto";
+import "chromium_deps/cdm/protos/defs/remote_attestation.proto";
+
+option optimize_for = LITE_RUNTIME;
+
+enum LicenseType {
+  STREAMING = 1;
+  OFFLINE = 2;
+}
+
+enum PlatformVerificationStatus {
+  // The platform is not verified.
+  PLATFORM_UNVERIFIED = 0;
+  // Tampering detected on the platform.
+  PLATFORM_TAMPERED = 1;
+  // The platform has been verified by means of software.
+  PLATFORM_SOFTWARE_VERIFIED = 2;
+  // The platform has been verified by means of hardware (e.g. secure boot).
+  PLATFORM_HARDWARE_VERIFIED = 3;
+  // Platform verification was not performed.
+  PLATFORM_NO_VERIFICATION = 4;
+  // Platform and secure storage capability have been verified by means of
+  // software.
+  PLATFORM_SECURE_STORAGE_SOFTWARE_VERIFIED = 5;
+}
+
+// LicenseIdentification is propagated from LicenseRequest to License,
+// incrementing version with each iteration.
+message LicenseIdentification {
+  optional bytes request_id = 1;
+  optional bytes session_id = 2;
+  optional bytes purchase_id = 3;
+  optional LicenseType type = 4;
+  optional int32 version = 5;
+  optional bytes provider_session_token = 6;
+}
+
+message License {
+  // LINT.IfChange
+  message Policy {
+    // Indicates that playback of the content is allowed.
+    optional bool can_play = 1 [default = false];
+
+    // Indicates that the license may be persisted to non-volatile
+    // storage for offline use.
+    optional bool can_persist = 2 [default = false];
+
+    // Indicates that renewal of this license is allowed.
+    optional bool can_renew = 3 [default = false];
+
+    // For the |*duration*| fields, playback must halt when
+    // license_start_time (seconds since the epoch (UTC)) +
+    // license_duration_seconds is exceeded. A value of 0
+    // indicates that there is no limit to the duration.
+
+    // Indicates the rental window.
+    optional int64 rental_duration_seconds = 4 [default = 0];
+
+    // Indicates the viewing window, once playback has begun.
+    optional int64 playback_duration_seconds = 5 [default = 0];
+
+    // Indicates the time window for this specific license.
+    optional int64 license_duration_seconds = 6 [default = 0];
+
+    // The |renewal*| fields only apply if |can_renew| is true.
+
+    // The window of time, in which playback is allowed to continue while
+    // renewal is attempted, yet unsuccessful due to backend problems with
+    // the license server.
+    optional int64 renewal_recovery_duration_seconds = 7 [default = 0];
+
+    // All renewal requests for this license shall be directed to the
+    // specified URL.
+    optional string renewal_server_url = 8;
+
+    // How many seconds after license_start_time, before renewal is first
+    // attempted.
+    optional int64 renewal_delay_seconds = 9 [default = 0];
+
+    // Specifies the delay in seconds between subsequent license
+    // renewal requests, in case of failure.
+    optional int64 renewal_retry_interval_seconds = 10 [default = 0];
+
+    // Indicates that the license shall be sent for renewal when usage is
+    // started.
+    optional bool renew_with_usage = 11 [default = false];
+
+    // Indicates to client that license renewal and release requests ought to
+    // include ClientIdentification (client_id).
+    optional bool always_include_client_id = 12 [default = false];
+
+    // Duration of grace period before playback_duration_seconds (short window)
+    // goes into effect. Optional.
+    optional int64 play_start_grace_period_seconds = 13 [default = 0];
+
+    // Enables "soft enforcement" of playback_duration_seconds, letting the user
+    // finish playback even if short window expires. Optional.
+    optional bool soft_enforce_playback_duration = 14 [default = false];
+  }
+  // LINT.ThenChange(//depot/google3/google/chrome/widevine/licensedata/v1/license_policy.proto)
+
+  message KeyContainer {
+    enum KeyType {
+      SIGNING = 1;           // Exactly one key of this type must appear.
+      CONTENT = 2;           // Content key.
+      KEY_CONTROL = 3;       // Key control block for license renewals. No key.
+      OPERATOR_SESSION = 4;  // wrapped keys for auxiliary crypto operations.
+      ENTITLEMENT = 5;       // Entitlement keys.
+      OEM_CONTENT = 6;       // Partner-specific content key.
+    }
+
+    // The SecurityLevel enumeration allows the server to communicate the level
+    // of robustness required by the client, in order to use the key.
+    enum SecurityLevel {
+      // Software-based whitebox crypto is required.
+      SW_SECURE_CRYPTO = 1;
+
+      // Software crypto and an obfuscated decoder is required.
+      SW_SECURE_DECODE = 2;
+
+      // The key material and crypto operations must be performed within a
+      // hardware backed trusted execution environment.
+      HW_SECURE_CRYPTO = 3;
+
+      // The crypto and decoding of content must be performed within a hardware
+      // backed trusted execution environment.
+      HW_SECURE_DECODE = 4;
+
+      // The crypto, decoding and all handling of the media (compressed and
+      // uncompressed) must be handled within a hardware backed trusted
+      // execution environment.
+      HW_SECURE_ALL = 5;
+    }
+
+    message KeyControl {
+      // MOE:begin_strip
+      // |key_control| is documented here:
+      //   http://doc/1pHSJ2IKL0axmQz2gmDZ7olxPWb_ZcULaJrYwDZAeS7k/edit#heading=h.pua7563f80h6
+      // MOE:end_strip
+      // If present, the key control must be communicated to the secure
+      // environment prior to any usage. This message is automatically generated
+      // by the Widevine License Server SDK.
+      optional bytes key_control_block = 1;
+      optional bytes iv = 2;
+    }
+
+    message OutputProtection {
+      // Indicates whether HDCP is required on digital outputs, and which
+      // version should be used.
+      enum HDCP {
+        HDCP_NONE = 0;
+        HDCP_V1 = 1;
+        HDCP_V2 = 2;
+        HDCP_V2_1 = 3;
+        HDCP_V2_2 = 4;
+        HDCP_V2_3 = 5;
+        HDCP_NO_DIGITAL_OUTPUT = 0xff;
+      }
+      optional HDCP hdcp = 1 [default = HDCP_NONE];
+
+      // Indicate the CGMS setting to be inserted on analog output.
+      enum CGMS {
+        CGMS_NONE = 42;
+        COPY_FREE = 0;
+        COPY_ONCE = 2;
+        COPY_NEVER = 3;
+      }
+      optional CGMS cgms_flags = 2 [default = CGMS_NONE];
+
+      enum HdcpSrmRule {
+        HDCP_SRM_RULE_NONE = 0;
+        // In 'required_protection', this means most current SRM is required.
+        // Update the SRM on the device. If update cannot happen,
+        // do not allow the key.
+        // In 'requested_protection', this means most current SRM is requested.
+        // Update the SRM on the device. If update cannot happen,
+        // allow use of the key anyway.
+        CURRENT_SRM = 1;
+      }
+      optional HdcpSrmRule hdcp_srm_rule = 3 [default = HDCP_SRM_RULE_NONE];
+      // Optional requirement to indicate analog output is not allowed.
+      optional bool disable_analog_output = 4 [default = false];
+      // Optional requirement to indicate digital output is not allowed.
+      optional bool disable_digital_output = 5 [default = false];
+    }
+
+    message VideoResolutionConstraint {
+      // Minimum and maximum video resolutions in the range (height x width).
+      optional uint32 min_resolution_pixels = 1;
+      optional uint32 max_resolution_pixels = 2;
+      // Optional output protection requirements for this range. If not
+      // specified, the OutputProtection in the KeyContainer applies.
+      optional OutputProtection required_protection = 3;
+    }
+
+    message OperatorSessionKeyPermissions {
+      // Permissions/key usage flags for operator service keys
+      // (type = OPERATOR_SESSION).
+      optional bool allow_encrypt = 1 [default = false];
+      optional bool allow_decrypt = 2 [default = false];
+      optional bool allow_sign = 3 [default = false];
+      optional bool allow_signature_verify = 4 [default = false];
+    }
+
+    optional bytes id = 1;
+    optional bytes iv = 2;
+    optional bytes key = 3;
+    optional KeyType type = 4;
+    optional SecurityLevel level = 5 [default = SW_SECURE_CRYPTO];
+    optional OutputProtection required_protection = 6;
+    // NOTE: Use of requested_protection is not recommended as it is only
+    // supported on a small number of platforms.
+    optional OutputProtection requested_protection = 7;
+    optional KeyControl key_control = 8;
+    optional OperatorSessionKeyPermissions operator_session_key_permissions = 9;
+    // Optional video resolution constraints. If the video resolution of the
+    // content being decrypted/decoded falls within one of the specified ranges,
+    // the optional required_protections may be applied. Otherwise an error will
+    // be reported.
+    // NOTE: Use of this feature is not recommended, as it is only supported on
+    // a small number of platforms.
+    repeated VideoResolutionConstraint video_resolution_constraints = 10;
+    // Optional flag to indicate the key must only be used if the client
+    // supports anti rollback of the user table.  Content provider can query the
+    // client capabilities to determine if the client support this feature.
+    optional bool anti_rollback_usage_table = 11 [default = false];
+    // Optional not limited to commonly known track types such as SD, HD.
+    // It can be some provider defined label to identify the track.
+    optional string track_label = 12;
+  }
+  // LINT.ThenChange(//depot/google3/google/chrome/widevine/licensedata/v1/key_container.proto)
+
+  optional LicenseIdentification id = 1;
+  optional Policy policy = 2;
+  repeated KeyContainer key = 3;
+  // Time of the request in seconds (UTC) as set in
+  // LicenseRequest.request_time.  If this time is not set in the request,
+  // the local time at the license service is used in this field.
+  optional int64 license_start_time = 4;
+  // TODO(b/65054419): Deprecate remote_attestation_verified in favor of
+  // platform_verification_status, below.
+  optional bool remote_attestation_verified = 5 [default = false];
+  // Client token generated by the content provider. Optional.
+  optional bytes provider_client_token = 6;
+  // 4cc code specifying the CENC protection scheme as defined in the CENC 3.0
+  // specification. Propagated from Widevine PSSH box. Optional.
+  optional uint32 protection_scheme = 7;
+  // 8 byte verification field "HDCPDATA" followed by unsigned 32 bit minimum
+  // HDCP SRM version (whether the version is for HDCP1 SRM or HDCP2 SRM
+  // depends on client max_hdcp_version).
+  // MOE:begin_strip
+  // Additional details at:
+  //   http://doc/1MYwkQjcdeP7eMAZGeYCvjlXMO0MqRKTUYk2SlsoSXXc/#heading=h.8l3xqpa3rvfi.
+  // MOE:end_strip
+  optional bytes srm_requirement = 8;
+  // If present this contains a signed SRM file (either HDCP1 SRM or HDCP2 SRM
+  // depending on client max_hdcp_version) that should be installed on the
+  // client device.
+  optional bytes srm_update = 9;
+  // Indicates the status of any type of platform verification performed by the
+  // server.
+  optional PlatformVerificationStatus platform_verification_status = 10
+      [default = PLATFORM_NO_VERIFICATION];
+  // IDs of the groups for which keys are delivered in this license, if any.
+  repeated bytes group_ids = 11;
+}
+
+enum ProtocolVersion {
+  VERSION_2_0 = 20;
+  VERSION_2_1 = 21;
+  VERSION_2_2 = 22;
+}
+
+message LicenseRequest {
+  message ContentIdentification {
+    message WidevinePsshData {
+      repeated bytes pssh_data = 1;
+      optional LicenseType license_type = 2;
+      optional bytes request_id = 3;  // Opaque, client-specified.
+    }
+
+    message WebmKeyId {
+      optional bytes header = 1;
+      optional LicenseType license_type = 2;
+      optional bytes request_id = 3;  // Opaque, client-specified.
+    }
+
+    message ExistingLicense {
+      optional LicenseIdentification license_id = 1;
+      optional int64 seconds_since_started = 2;
+      optional int64 seconds_since_last_played = 3;
+      optional bytes session_usage_table_entry = 4;
+    }
+
+    message InitData {
+      enum InitDataType {
+        CENC = 1;
+        WEBM = 2;
+      }
+
+      optional InitDataType init_data_type = 1 [default = CENC];
+      optional bytes init_data = 2;
+      optional LicenseType license_type = 3;
+      optional bytes request_id = 4;
+    }
+
+    oneof content_id_variant {
+      // Exactly one of these must be present.
+      WidevinePsshData widevine_pssh_data = 1;
+      WebmKeyId webm_key_id = 2;
+      ExistingLicense existing_license = 3;
+      InitData init_data = 4;
+    }
+  }
+
+  enum RequestType {
+    NEW = 1;
+    RENEWAL = 2;
+    RELEASE = 3;
+  }
+
+  // The client_id provides information authenticating the calling device.  It
+  // contains the Widevine keybox token that was installed on the device at the
+  // factory.  This field or encrypted_client_id below is required for a valid
+  // license request, but both should never be present in the same request.
+  optional ClientIdentification client_id = 1;
+  optional ContentIdentification content_id = 2;
+  optional RequestType type = 3;
+  // Time of the request in seconds (UTC) as set by the client.
+  optional int64 request_time = 4;
+  // Old-style decimal-encoded string key control nonce.
+  optional bytes key_control_nonce_deprecated = 5;
+  optional ProtocolVersion protocol_version = 6 [default = VERSION_2_0];
+  // New-style uint32 key control nonce, please use instead of
+  // key_control_nonce_deprecated.
+  optional uint32 key_control_nonce = 7;
+  // Encrypted ClientIdentification message, used for privacy purposes.
+  optional EncryptedClientIdentification encrypted_client_id = 8;
+}
+
+message LicenseError {
+  enum Error {
+    // The device credentials are invalid. The device must re-provision.
+    INVALID_DRM_DEVICE_CERTIFICATE = 1;
+    // The device credentials have been revoked. Re-provisioning is not
+    // possible.
+    REVOKED_DRM_DEVICE_CERTIFICATE = 2;
+    // The service is currently unavailable due to the backend being down
+    // or similar circumstances.
+    SERVICE_UNAVAILABLE = 3;
+  }
+  optional Error error_code = 1;
+}
+
+message MetricData {
+  enum MetricType {
+    // The time spent in the 'stage', specified in microseconds.
+    LATENCY = 1;
+    // The UNIX epoch timestamp at which the 'stage' was first accessed in
+    // microseconds.
+    TIMESTAMP = 2;
+  }
+
+  message TypeValue {
+    optional MetricType type = 1;
+    // The value associated with 'type'.  For example if type == LATENCY, the
+    // value would be the time in microseconds spent in this 'stage'.
+    optional int64 value = 2 [default = 0];
+  }
+
+  // 'stage' that is currently processing the SignedMessage.  Required.
+  optional string stage_name = 1;
+  // metric and associated value.
+  repeated TypeValue metric_data = 2;
+}
+
+message VersionInfo {
+  // License SDK version reported by the Widevine License SDK. This field
+  // is populated automatically by the SDK.
+  optional string license_sdk_version = 1;
+  // Version of the service hosting the license SDK. This field is optional.
+  // It may be provided by the hosting service.
+  optional string license_service_version = 2;
+}
+
+message SignedMessage {
+  enum MessageType {
+    LICENSE_REQUEST = 1;
+    LICENSE = 2;
+    ERROR_RESPONSE = 3;
+    SERVICE_CERTIFICATE_REQUEST = 4;
+    SERVICE_CERTIFICATE = 5;
+    SUB_LICENSE = 6;
+    CAS_LICENSE_REQUEST = 7;
+    CAS_LICENSE = 8;
+    EXTERNAL_LICENSE_REQUEST = 9;
+    EXTERNAL_LICENSE = 10;
+  }
+
+  enum SessionKeyType {
+    UNDEFINED = 0;
+    WRAPPED_AES_KEY = 1;
+    EPHERMERAL_ECC_PUBLIC_KEY = 2;
+  }
+  optional MessageType type = 1;
+  optional bytes msg = 2;
+  // Required field that contains the signature of the bytes of msg.
+  // For license requests, the signing algorithm is determined by the
+  // certificate contained in the request.
+  // For license responses, the signing algorithm is HMAC with signing key based
+  // on |session_key|.
+  optional bytes signature = 3;
+  // If populated, the contents of this field will be signaled by the
+  // |session_key_type| type. If the |session_key_type| is WRAPPED_AES_KEY the
+  // key is the bytes of an encrypted AES key. If the |session_key_type| is
+  // EPHERMERAL_ECC_PUBLIC_KEY the field contains the bytes of an RFC5208 ASN1
+  // serialized ECC public key.
+  optional bytes session_key = 4;
+  // Remote attestation data which will be present in the initial license
+  // request for ChromeOS client devices operating in verified mode. Remote
+  // attestation challenge data is |msg| field above. Optional.
+  optional RemoteAttestation remote_attestation = 5;
+  // MOE:begin_strip
+  // Design doc at:
+  //   http://doc/1LqEzxw1v2CVBx_zv5lVX55FcGKjx6JLnFdXjEUbNTOQ
+  // MOE:end_strip
+
+  repeated MetricData metric_data = 6;
+  // Version information from the SDK and license service. This information is
+  // provided in the license response.
+  optional VersionInfo service_version_info = 7;
+  // Optional field that contains the algorithm type used to generate the
+  // session_key and signature in a LICENSE message.
+  optional SessionKeyType session_key_type = 8 [default = WRAPPED_AES_KEY];
+  // The core message is the simple serialization of fields used by OEMCrypto.
+  // This field was introduced in OEMCrypto API v16.
+  optional bytes oemcrypto_core_message = 9;
+}

chromium_deps/cdm/protos/defs/remote_attestation.proto

@@ -0,0 +1,24 @@
+// Copyright 2017 Google LLC. All rights reserved.
+//
+// Description:
+//   Remote attestation is used by ChromeOS device to authenticate itself
+//   to Widevine services for both licensing and keybox provisioning.
+
+syntax = "proto2";
+
+package video_widevine;
+
+import "chromium_deps/cdm/protos/defs/client_identification.proto";
+
+option optimize_for = LITE_RUNTIME;
+
+message RemoteAttestation {
+  // Encrypted ClientIdentification message containing the device remote
+  // attestation certificate. Required.
+  optional EncryptedClientIdentification certificate = 1;
+  // Bytes of salt which were added to the remote attestation challenge prior to
+  // signing it. Required.
+  optional bytes salt = 2;
+  // Signed remote attestation challenge + salt. Required.
+  optional bytes signature = 3;
+}

chromium_deps/cdm/protos/license_protocol.pb.h

@@ -0,0 +1,10 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef CDM_PROTOS_LICENSE_PROTOCOL_PB_H_
+#define CDM_PROTOS_LICENSE_PROTOCOL_PB_H_
+
+// Protobuf generated code doesn't like it when include prefixes are stripped
+// off. So simply including the actual generated protobuf C++ header.
+#include "chromium_deps/cdm/protos/defs/license_protocol.pb.h"
+
+#endif  // CDM_PROTOS_LICENSE_PROTOCOL_PB_H_

chromium_deps/testing/BUILD

@@ -0,0 +1,15 @@
+# Copyright 2020 Google LLC. All Rights Reserved.
+
+cc_library(
+    name = "gtest",
+    hdrs = [
+        "include/gmock/gmock.h",
+        "include/gtest/gtest.h",
+    ],
+    strip_include_prefix = "//chromium_deps",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//external:gtest",
+        "//external:gtest_main",
+    ],
+)

chromium_deps/testing/include/gmock/gmock.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef TESTING_GMOCK_INCLUDE_GMOCK_H_
+#define TESTING_GMOCK_INCLUDE_GMOCK_H_
+
+#include "gmock/gmock.h"
+
+#endif  // TESTING_GMOCK_INCLUDE_GMOCK_H_

chromium_deps/testing/include/gtest/gtest.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef TESTING_GUNIT_INCLUDE_GUNIT_H_
+#define TESTING_GUNIT_INCLUDE_GUNIT_H_
+
+#include "gtest/gtest.h"
+
+#endif  // TESTING_GUNIT_INCLUDE_GUNIT_H_

chromium_deps/third_party/boringssl/BUILD

@@ -0,0 +1,27 @@
+# Copyright 2020 Google LLC. All Rights Reserved.
+
+cc_library(
+    name = "boringssl",
+    hdrs = [
+        "src/include/openssl/aead.h",
+        "src/include/openssl/aes.h",
+        "src/include/openssl/bio.h",
+        "src/include/openssl/bn.h",
+        "src/include/openssl/bytestring.h",
+        "src/include/openssl/cmac.h",
+        "src/include/openssl/err.h",
+        "src/include/openssl/evp.h",
+        "src/include/openssl/hmac.h",
+        "src/include/openssl/mem.h",
+        "src/include/openssl/pem.h",
+        "src/include/openssl/rand.h",
+        "src/include/openssl/rsa.h",
+        "src/include/openssl/sha.h",
+        "src/include/openssl/x509.h",
+    ],
+    strip_include_prefix = "//chromium_deps",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//external:boringssl",
+    ],
+)

chromium_deps/third_party/boringssl/src/include/openssl/aead.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_AEAD_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_AEAD_H_
+
+#include "openssl/aead.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_AEAD_H_

chromium_deps/third_party/boringssl/src/include/openssl/aes.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_AES_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_AES_H_
+
+#include "openssl/aes.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_AES_H_

chromium_deps/third_party/boringssl/src/include/openssl/bio.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_BIO_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_BIO_H_
+
+#include "openssl/bio.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_BIO_H_

chromium_deps/third_party/boringssl/src/include/openssl/bn.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_BN_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_BN_H_
+
+#include "openssl/bn.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_BN_H_

chromium_deps/third_party/boringssl/src/include/openssl/bytestring.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_BYTESTRING_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_BYTESTRING_H_
+
+#include "openssl/bytestring.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_BYTESTRING_H_

chromium_deps/third_party/boringssl/src/include/openssl/cmac.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_CMAC_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_CMAC_H_
+
+#include "openssl/cmac.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_CMAC_H_

chromium_deps/third_party/boringssl/src/include/openssl/err.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_ERR_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_ERR_H_
+
+#include "openssl/err.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_ERR_H_

chromium_deps/third_party/boringssl/src/include/openssl/evp.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_EVP_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_EVP_H_
+
+#include "openssl/evp.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_EVP_H_

chromium_deps/third_party/boringssl/src/include/openssl/hmac.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_HMAC_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_HMAC_H_
+
+#include "openssl/hmac.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_HMAC_H_

chromium_deps/third_party/boringssl/src/include/openssl/mem.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_MEM_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_MEM_H_
+
+#include "openssl/mem.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_MEM_H_

chromium_deps/third_party/boringssl/src/include/openssl/pem.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_PEM_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_PEM_H_
+
+#include "openssl/pem.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_PEM_H_

chromium_deps/third_party/boringssl/src/include/openssl/rand.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_RAND_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_RAND_H_
+
+#include "openssl/rand.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_RAND_H_

chromium_deps/third_party/boringssl/src/include/openssl/rsa.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_RSA_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_RSA_H_
+
+#include "openssl/rsa.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_RSA_H_

chromium_deps/third_party/boringssl/src/include/openssl/sha.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_SHA_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_SHA_H_
+
+#include "openssl/sha.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_SHA_H_

chromium_deps/third_party/boringssl/src/include/openssl/x509.h

@@ -0,0 +1,8 @@
+// Copyright 2020 Google LLC. All Rights Reserved.
+
+#ifndef THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_X509_H_
+#define THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_X509_H_
+
+#include "openssl/x509.h"
+
+#endif  // THIRD_PARTY_BORINGSSL_SRC_INCLUDE_OPENSSL_X509_H_