Source release v3.0.0-0-g8d3792b-ce + third_party

Change-Id: I399e71ddfffcd436171d1c60283c63ab4658e0b1

oemcrypto/test/oemcrypto_test.h

@@ -0,0 +1,41 @@
+#ifndef CDM_OEMCRYPTO_TEST_H_
+#define CDM_OEMCRYPTO_TEST_H_
+
+#include "OEMCryptoCENC.h"
+#include "wv_keybox.h"
+
+namespace wvoec {
+
+class DeviceFeatures {
+ public:
+  enum DeriveMethod {      // Method to use derive session keys.
+    NO_METHOD,             // Cannot derive known session keys.
+    LOAD_TEST_KEYBOX,      // Call LoadTestKeybox before deriving keys.
+    LOAD_TEST_RSA_KEY,     // Call LoadTestRSAKey before deriving keys.
+    EXISTING_TEST_KEYBOX,  // Keybox is already the test keybox.
+    FORCE_TEST_KEYBOX,     // User requested calling InstallKeybox.
+  };
+
+  enum DeriveMethod derive_key_method;
+  bool uses_keybox;        // Device uses a keybox to derive session keys.
+  bool uses_certificate;   // Device uses a certificate to derive session keys.
+  bool loads_certificate;  // Device can load a certificate from the server.
+  bool generic_crypto;     // Device supports generic crypto.
+  bool cast_receiver;      // Device supports alternate rsa signature padding.
+  bool usage_table;        // Device saves usage information.
+  uint32_t api_version;
+
+  void Initialize(bool is_cast_receiver, bool force_load_test_keybox);
+  std::string RestrictFilter(const std::string& initial_filter);
+
+ private:
+  void PickDerivedKey();
+  bool IsTestKeyboxInstalled();
+  void FilterOut(std::string* current_filter, const std::string& new_filter);
+};
+
+extern DeviceFeatures global_features;
+
+}  // namespace wvoec
+
+#endif  // CDM_OEMCRYPTO_TEST_H_

oemcrypto/test/oemcrypto_test_android.cpp

@@ -0,0 +1,114 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// OEMCrypto unit tests - extra tests required for Android platform.
+//
+// The Widevine CDM system can be built on many platforms, with different
+// capabilities. For example, some platforms do not require usage tables,
+// and some can have a pre-installed certificate and do not need a keybox.
+// On Android, these features are not optional.  This set of unit tests
+// verify that these features are implemented.
+//
+// In the file oemcrypto_test.cpp, the unit tests only verify correct
+// functionality for functions that are implemented.  Android devices must pass
+// unit tests in both files.
+
+#include <gtest/gtest.h>
+
+#include "OEMCryptoCENC.h"
+
+namespace wvoec {
+
+// These tests are required for LollyPop Android devices.
+class OEMCryptoAndroidLMPTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+    ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_Initialize());
+  }
+
+  virtual void TearDown() {
+    OEMCrypto_Terminate();
+  }
+};
+
+// Android devices must have a keybox.
+TEST_F(OEMCryptoAndroidLMPTest, GetKeyDataImplemented) {
+  uint8_t key_data[256];
+  size_t key_data_len = sizeof(key_data);
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_GetKeyData(key_data, &key_data_len));
+}
+
+TEST_F(OEMCryptoAndroidLMPTest, MinVersionNumber9) {
+  uint32_t version = OEMCrypto_APIVersion();
+  ASSERT_LE(9u, version);
+}
+
+TEST_F(OEMCryptoAndroidLMPTest, ValidKeyboxTest) {
+  ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_IsKeyboxValid());
+}
+
+TEST_F(OEMCryptoAndroidLMPTest, RewrapDeviceRSAKeyImplemented) {
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_RewrapDeviceRSAKey(0, NULL, 0, NULL, 0, NULL,
+                                         NULL, 0, NULL, NULL, NULL));
+}
+
+TEST_F(OEMCryptoAndroidLMPTest, RSASignatureImplemented) {
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_GenerateRSASignature(0, NULL, 0, NULL, NULL,
+                                           kSign_RSASSA_PSS));
+}
+
+TEST_F(OEMCryptoAndroidLMPTest, GenericCryptoImplemented) {
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_Generic_Encrypt(0, NULL, 0, NULL,
+                                      OEMCrypto_AES_CBC_128_NO_PADDING, NULL));
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_Generic_Decrypt(0, NULL, 0, NULL,
+                                      OEMCrypto_AES_CBC_128_NO_PADDING, NULL));
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_Generic_Sign(0, NULL, 0,
+                                   OEMCrypto_HMAC_SHA256, NULL, NULL));
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_Generic_Verify(0, NULL, 0,
+                                     OEMCrypto_HMAC_SHA256, NULL, 0));
+}
+
+TEST_F(OEMCryptoAndroidLMPTest, SupportsUsageTable) {
+  ASSERT_TRUE(OEMCrypto_SupportsUsageTable());
+}
+
+TEST_F(OEMCryptoAndroidLMPTest, Level1Required) {
+  const char* char_level = OEMCrypto_SecurityLevel();
+  std::string security_level(char_level ? char_level : "");
+  EXPECT_EQ("L1", security_level)
+      << "The security level is " << security_level << ". but we expect L1.\n"
+      << "If you are testing a device that should be L3 or L2, please\n"
+      << "repeat the tests with the flag --gtest_filter=\"*-*Level1Required\"";
+}
+
+// These tests are required for M Android devices.
+class OEMCryptoAndroidMNCTest : public  OEMCryptoAndroidLMPTest {};
+
+TEST_F(OEMCryptoAndroidMNCTest, MinVersionNumber10) {
+  uint32_t version = OEMCrypto_APIVersion();
+  ASSERT_GE(version, 10u);
+}
+
+TEST_F(OEMCryptoAndroidMNCTest, LoadsTestKeyboxImplemented) {
+  ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_LoadTestKeybox());
+}
+
+TEST_F(OEMCryptoAndroidMNCTest, NumberOfSessionsImplemented) {
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_GetNumberOfOpenSessions(NULL));
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_GetMaxNumberOfSessions(NULL));
+}
+
+TEST_F(OEMCryptoAndroidMNCTest, QueryKeyControlImplemented) {
+  ASSERT_NE(OEMCrypto_ERROR_NOT_IMPLEMENTED,
+            OEMCrypto_QueryKeyControl(0, NULL, 0, NULL, NULL));
+}
+
+}  // namespace wvoec

oemcrypto/test/oemcrypto_test_main.cpp

@@ -0,0 +1,43 @@
+#include <gtest/gtest.h>
+#include <iostream>
+
+#include "log.h"
+#include "oemcrypto_test.h"
+#include "OEMCryptoCENC.h"
+#include "properties.h"
+
+static void acknowledge_cast() {
+  std::cout
+      << "==================================================================\n"
+      << "= This device is expected to load x509 certs as a cast receiver. =\n"
+      << "==================================================================\n";
+}
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  wvcdm::Properties::Init();
+  wvcdm::g_cutoff = wvcdm::LOG_INFO;
+  bool is_cast_receiver = false;
+  bool force_load_test_keybox = false;
+  bool filter_tests = true;
+  for(int i=0; i < argc; i++) {
+    if (!strcmp(argv[i], "--cast")) {
+      acknowledge_cast();
+      is_cast_receiver = true;
+    }
+    if (!strcmp(argv[i], "--force_load_test_keybox")) {
+      force_load_test_keybox = true;
+    }
+    if (!strcmp(argv[i], "--no_filter")) {
+      filter_tests  = false;
+    }
+  }
+  wvoec::global_features.Initialize(is_cast_receiver, force_load_test_keybox);
+  // If the user requests --no_filter, we don't change the filter, otherwise, we
+  // filter out features that are not supported.
+  if (filter_tests) {
+    ::testing::GTEST_FLAG(filter)
+        = wvoec::global_features.RestrictFilter(::testing::GTEST_FLAG(filter));
+  }
+  return RUN_ALL_TESTS();
+}