Source release v3.3.0

core/test/generic_crypto_unittest.cpp

@@ -10,8 +10,7 @@
 #include <string>
 
 #include "cdm_engine.h"
-
-#include "default_service_certificate.h"
+#include "config_test_env.h"
 #include "license_request.h"
 #include "log.h"
 #include "oec_session_util.h"
@@ -25,6 +24,52 @@ namespace {
 
 const std::string kKeySystem = "com.widevine.alpha";
 
+std::string g_provisioning_server;
+std::string g_license_service_certificate;
+std::string g_provisioning_service_certificate;
+
+/*
+ * Locate the portion of the server's response message that is between
+ * the strings jason_start_substr and json_end_substr. Returns the string
+ * through *result. If the start substring match fails, assume the entire
+ * string represents a serialized protobuf mesaage and return true with
+ * the entire string. If the end_substring match fails, return false with
+ * an empty *result.
+ */
+bool ExtractSignedMessage(const std::string& response,
+                          const std::string& json_start_substr,
+                          const std::string& json_end_substr,
+                          std::string* result) {
+  std::string b64_string;
+  size_t start = response.find(json_start_substr);
+
+  if (start == response.npos) {
+    // Assume web safe protobuf
+    b64_string.assign(response);
+  } else {
+    // Assume JSON-wrapped protobuf
+    size_t end = response.find(json_end_substr,
+                               start + json_start_substr.length());
+    if (end == response.npos) {
+      LOGE("ExtractSignedMessage cannot locate end substring");
+      result->clear();
+      return false;
+    }
+    size_t b64_string_size = end - start - json_start_substr.length();
+    b64_string.assign(response, start + json_start_substr.length(),
+                      b64_string_size);
+  }
+
+  if (b64_string.empty()) {
+    LOGE("Response message is empty");
+    result->clear();
+    return false;
+  }
+
+  result->swap(b64_string);
+  return true;
+}
+
 }  // namespace
 
 namespace wvcdm {
@@ -34,6 +79,15 @@ class WvGenericOperationsTest : public testing::Test {
   virtual void SetUp() {
     ::testing::Test::SetUp();
 
+    ConfigTestEnv config(kContentProtectionStagingPlusProv30);
+
+    g_provisioning_service_certificate.assign(
+        config.provisioning_service_certificate());
+    g_license_service_certificate.assign(config.license_service_certificate());
+    g_provisioning_server.assign(config.provisioning_server());
+
+    cdm_engine_ = NULL;
+
     // TODO(fredgc or gmorgan): This should be updated for provisioning 3.0
     // Load test keybox. This keybox will be used by any CryptoSession
     // created by the CDM under test.
@@ -42,6 +96,8 @@ class WvGenericOperationsTest : public testing::Test {
     // Perform CdmEngine setup
     cdm_engine_ = new CdmEngine(&file_system_);
 
+    Provision();
+
     CdmResponseType status =
         cdm_engine_->OpenSession(kKeySystem, NULL, NULL, &session_id_);
     if (status == NEED_PROVISIONING) {
@@ -66,7 +122,9 @@ class WvGenericOperationsTest : public testing::Test {
 
   virtual void TearDown() {
     oec_util_session_.close();
-    cdm_engine_->CloseSession(session_id_);
+    if (cdm_engine_ != NULL) {
+      cdm_engine_->CloseSession(session_id_);
+    }
     // OEMCrypto_Terminate() will be performed during the test class's
     // destruction (specifically by the CryptoSession destructor)
   }
@@ -156,26 +214,55 @@ class WvGenericOperationsTest : public testing::Test {
   }
 
  protected:
-  void Provision() {
+
+  virtual void Provision() {
+    LOGE("WvCdmEnginePreProvTest::Provision: url=%s",
+         g_provisioning_server.c_str());
     CdmProvisioningRequest prov_request;
     std::string provisioning_server_url;
     CdmCertificateType cert_type = kCertificateWidevine;
     std::string cert_authority;
     std::string cert, wrapped_key;
-    cdm_engine_->SetServiceCertificate(kDefaultServiceCertificate);
-    ASSERT_EQ(NO_ERROR,
-              cdm_engine_->GetProvisioningRequest(
-                  cert_type, cert_authority, &prov_request,
-                  &provisioning_server_url));
+    ASSERT_EQ(NO_ERROR, cdm_engine_->SetServiceCertificate(
+        g_provisioning_service_certificate));
+    ASSERT_EQ(NO_ERROR, cdm_engine_->GetProvisioningRequest(
+        cert_type, cert_authority, &prov_request,
+        &provisioning_server_url));
+
+    LOGV("WvCdmEnginePreProvTest::Provision: req=%s", prov_request.c_str());
+
+    // Ignore URL provided by CdmEngine.  Use ours, as configured
+    // for test vs. production server.
+    provisioning_server_url.assign(g_provisioning_server);
     UrlRequest url_request(provisioning_server_url);
     EXPECT_TRUE(url_request.is_connected());
     url_request.PostCertRequestInQueryString(prov_request);
-    std::string message;
-    bool ok = url_request.GetResponse(&message);
+    std::string http_message;
+    bool ok = url_request.GetResponse(&http_message);
     EXPECT_TRUE(ok);
+
+    LOGV("WvCdmEnginePreProvTest::Provision: http_message: \n%s\n",
+         http_message.c_str());
+
+    // extract provisioning response from received message
+    // Extracts signed response from JSON string, decodes base64 signed response
+    const std::string kMessageStart = "\"signedResponse\": \"";
+    const std::string kMessageEnd = "\"";
+    std::string base64_response;
+    EXPECT_TRUE (ExtractSignedMessage(http_message, kMessageStart, kMessageEnd,
+                                      &base64_response)) <<
+        "Failed to extract signed serialized response from JSON response";
+
+    LOGV("WvCdmEnginePreProvTest::Provision: extracted response "
+         "message: \n%s\n", base64_response.c_str());
+
     ASSERT_EQ(NO_ERROR,
-              cdm_engine_->HandleProvisioningResponse(message, &cert,
-                                                      &wrapped_key));
+              cdm_engine_->HandleProvisioningResponse(base64_response,
+                                                     &cert, &wrapped_key));
+
+    ASSERT_EQ(NO_ERROR,
+              cdm_engine_->SetServiceCertificate(
+                  g_license_service_certificate));
   }
 
   // This CryptoSession object handles Initialization and Termination