300 lines
10 KiB
C++
300 lines
10 KiB
C++
// Copyright 2013 Google Inc. All Rights Reserved.
|
|
// These tests are for the cdm engine, and code below it in the stack. In
|
|
// particular, we assume that the OEMCrypo layer works, and has a valid keybox.
|
|
// This is because we need a valid RSA certificate, and will attempt to connect
|
|
// to the provisioning server to request one if we don't.
|
|
|
|
#include <errno.h>
|
|
#include <getopt.h>
|
|
|
|
#include <string>
|
|
|
|
#include "cdm_engine.h"
|
|
#include "config_test_env.h"
|
|
#include "gtest/gtest.h"
|
|
#include "initialization_data.h"
|
|
#include "license_request.h"
|
|
#include "log.h"
|
|
#include "properties.h"
|
|
#include "scoped_ptr.h"
|
|
#include "string_conversions.h"
|
|
#include "test_printers.h"
|
|
#include "url_request.h"
|
|
#include "wv_cdm_constants.h"
|
|
#include "wv_cdm_types.h"
|
|
|
|
namespace {
|
|
// Http OK response code.
|
|
const int kHttpOk = 200;
|
|
|
|
// Default license server, can be configured using --server command line option
|
|
// Default key id (pssh), can be configured using --keyid command line option
|
|
std::string g_client_auth;
|
|
wvcdm::KeyId g_key_id_pssh;
|
|
wvcdm::KeyId g_key_id_unwrapped;
|
|
wvcdm::CdmKeySystem g_key_system;
|
|
std::string g_license_server;
|
|
wvcdm::KeyId g_wrong_key_id;
|
|
|
|
const std::string kCencMimeType = "video/mp4";
|
|
const std::string kWebmMimeType = "video/webm";
|
|
|
|
} // namespace
|
|
|
|
namespace wvcdm {
|
|
|
|
class WvCdmEngineTest : public testing::Test {
|
|
public:
|
|
virtual void SetUp() {
|
|
CdmResponseType status = cdm_engine_.OpenSession(g_key_system, NULL, &session_id_);
|
|
if (status == NEED_PROVISIONING) {
|
|
Provision();
|
|
status = cdm_engine_.OpenSession(g_key_system, NULL, &session_id_);
|
|
}
|
|
ASSERT_EQ(NO_ERROR, status);
|
|
ASSERT_NE("", session_id_) << "Could not open CDM session.";
|
|
}
|
|
|
|
virtual void TearDown() { cdm_engine_.CloseSession(session_id_); }
|
|
|
|
protected:
|
|
void Provision() {
|
|
CdmProvisioningRequest prov_request;
|
|
std::string provisioning_server_url;
|
|
CdmCertificateType cert_type = kCertificateWidevine;
|
|
std::string cert_authority;
|
|
std::string cert, wrapped_key;
|
|
ASSERT_EQ(NO_ERROR,
|
|
cdm_engine_.GetProvisioningRequest(cert_type,
|
|
cert_authority,
|
|
&prov_request,
|
|
&provisioning_server_url));
|
|
UrlRequest url_request(provisioning_server_url);
|
|
url_request.PostCertRequestInQueryString(prov_request);
|
|
std::string message;
|
|
bool ok = url_request.GetResponse(&message);
|
|
EXPECT_TRUE(ok);
|
|
ASSERT_EQ(NO_ERROR,
|
|
cdm_engine_.HandleProvisioningResponse(message,
|
|
&cert, &wrapped_key));
|
|
}
|
|
|
|
void GenerateKeyRequest(const std::string& key_id,
|
|
const std::string& init_data_type_string) {
|
|
CdmAppParameterMap app_parameters;
|
|
std::string server_url;
|
|
CdmKeySetId key_set_id;
|
|
|
|
InitializationData init_data(init_data_type_string, key_id);
|
|
|
|
EXPECT_EQ(KEY_MESSAGE,
|
|
cdm_engine_.GenerateKeyRequest(
|
|
session_id_, key_set_id, init_data, kLicenseTypeStreaming,
|
|
app_parameters, &key_msg_, &server_url, NULL));
|
|
}
|
|
|
|
void GenerateRenewalRequest() {
|
|
EXPECT_EQ(KEY_MESSAGE, cdm_engine_.GenerateRenewalRequest(
|
|
session_id_, &key_msg_, &server_url_));
|
|
}
|
|
|
|
std::string GetKeyRequestResponse(const std::string& server_url,
|
|
const std::string& client_auth) {
|
|
return GetKeyRequestResponse(server_url, client_auth, true);
|
|
}
|
|
|
|
std::string FailToGetKeyRequestResponse(const std::string& server_url,
|
|
const std::string& client_auth) {
|
|
return GetKeyRequestResponse(server_url, client_auth, false);
|
|
}
|
|
|
|
// posts a request and extracts the drm message from the response
|
|
std::string GetKeyRequestResponse(const std::string& server_url,
|
|
const std::string& client_auth,
|
|
bool expect_success) {
|
|
// Use secure connection and chunk transfer coding.
|
|
UrlRequest url_request(server_url + client_auth);
|
|
if (!url_request.is_connected()) {
|
|
return "";
|
|
}
|
|
|
|
url_request.PostRequest(key_msg_);
|
|
std::string response;
|
|
bool ok = url_request.GetResponse(&response);
|
|
LOGD("response: %s\n", response.c_str());
|
|
EXPECT_TRUE(ok);
|
|
|
|
int status_code = url_request.GetStatusCode(response);
|
|
if (expect_success) EXPECT_EQ(kHttpOk, status_code);
|
|
|
|
if (status_code != kHttpOk) {
|
|
return "";
|
|
} else {
|
|
std::string drm_msg;
|
|
LicenseRequest lic_request;
|
|
lic_request.GetDrmMessage(response, drm_msg);
|
|
LOGV("drm msg: %u bytes\r\n%s", drm_msg.size(),
|
|
HexEncode(reinterpret_cast<const uint8_t*>(drm_msg.data()),
|
|
drm_msg.size()).c_str());
|
|
return drm_msg;
|
|
}
|
|
}
|
|
|
|
void VerifyNewKeyResponse(const std::string& server_url,
|
|
const std::string& client_auth) {
|
|
std::string resp = GetKeyRequestResponse(server_url, client_auth);
|
|
CdmKeySetId key_set_id;
|
|
EXPECT_EQ(wvcdm::KEY_ADDED,
|
|
cdm_engine_.AddKey(session_id_, resp, &key_set_id));
|
|
}
|
|
|
|
void VerifyRenewalKeyResponse(const std::string& server_url,
|
|
const std::string& client_auth) {
|
|
std::string resp = GetKeyRequestResponse(server_url, client_auth);
|
|
EXPECT_EQ(wvcdm::KEY_ADDED, cdm_engine_.RenewKey(session_id_, resp));
|
|
}
|
|
|
|
CdmEngine cdm_engine_;
|
|
std::string key_msg_;
|
|
std::string session_id_;
|
|
std::string server_url_;
|
|
};
|
|
|
|
// Test that provisioning works, even if device is already provisioned.
|
|
TEST_F(WvCdmEngineTest, ProvisioningTest) {
|
|
Provision();
|
|
}
|
|
|
|
TEST_F(WvCdmEngineTest, BaseIsoBmffMessageTest) {
|
|
GenerateKeyRequest(g_key_id_pssh, kCencMimeType);
|
|
GetKeyRequestResponse(g_license_server, g_client_auth);
|
|
}
|
|
|
|
// TODO(juce): Set up with correct test data.
|
|
TEST_F(WvCdmEngineTest, DISABLED_BaseWebmMessageTest) {
|
|
GenerateKeyRequest(g_key_id_unwrapped, kWebmMimeType);
|
|
GetKeyRequestResponse(g_license_server, g_client_auth);
|
|
}
|
|
|
|
TEST_F(WvCdmEngineTest, WrongMessageTest) {
|
|
std::string wrong_message = a2bs_hex(g_wrong_key_id);
|
|
GenerateKeyRequest(wrong_message, kCencMimeType);
|
|
|
|
// We should receive a response with no license, i.e. the extracted license
|
|
// response message should be empty.
|
|
ASSERT_EQ("", FailToGetKeyRequestResponse(g_license_server, g_client_auth));
|
|
}
|
|
|
|
TEST_F(WvCdmEngineTest, NormalDecryptionIsoBmff) {
|
|
GenerateKeyRequest(g_key_id_pssh, kCencMimeType);
|
|
VerifyNewKeyResponse(g_license_server, g_client_auth);
|
|
}
|
|
|
|
// TODO(juce): Set up with correct test data.
|
|
TEST_F(WvCdmEngineTest, DISABLED_NormalDecryptionWebm) {
|
|
GenerateKeyRequest(g_key_id_unwrapped, kWebmMimeType);
|
|
VerifyNewKeyResponse(g_license_server, g_client_auth);
|
|
}
|
|
|
|
TEST_F(WvCdmEngineTest, LicenseRenewal) {
|
|
GenerateKeyRequest(g_key_id_pssh, kCencMimeType);
|
|
VerifyNewKeyResponse(g_license_server, g_client_auth);
|
|
|
|
GenerateRenewalRequest();
|
|
VerifyRenewalKeyResponse(server_url_.empty() ? g_license_server : server_url_,
|
|
g_client_auth);
|
|
}
|
|
|
|
} // namespace wvcdm
|
|
|
|
int main(int argc, char** argv) {
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
wvcdm::InitLogging(argc, argv);
|
|
|
|
wvcdm::ConfigTestEnv config(wvcdm::kContentProtectionServer);
|
|
g_client_auth.assign(config.client_auth());
|
|
g_key_system.assign(config.key_system());
|
|
g_wrong_key_id.assign(config.wrong_key_id());
|
|
|
|
// The following variables are configurable through command line options.
|
|
g_license_server.assign(config.license_server());
|
|
g_key_id_pssh.assign(config.key_id());
|
|
std::string license_server(g_license_server);
|
|
|
|
int show_usage = 0;
|
|
static const struct option long_options[] = {
|
|
{"keyid", required_argument, NULL, 'k'},
|
|
{"server", required_argument, NULL, 's'},
|
|
{NULL, 0, NULL, '\0'}};
|
|
|
|
int option_index = 0;
|
|
int opt = 0;
|
|
while ((opt = getopt_long(argc, argv, "k:s:v", long_options,
|
|
&option_index)) != -1) {
|
|
switch (opt) {
|
|
case 'k': {
|
|
g_key_id_pssh.clear();
|
|
g_key_id_pssh.assign(optarg);
|
|
break;
|
|
}
|
|
case 's': {
|
|
g_license_server.clear();
|
|
g_license_server.assign(optarg);
|
|
break;
|
|
}
|
|
case 'v': {
|
|
// This option _may_ have already been consumed by wvcdm::InitLogging()
|
|
// above, depending on the platform-specific logging implementation.
|
|
// We only tell getopt about it so that it is not an error. We ignore
|
|
// the option here when seen.
|
|
// TODO: Stop passing argv to InitLogging, and instead set the log
|
|
// level here through the logging API. We should keep all command-line
|
|
// parsing at the application level, rather than split between various
|
|
// apps and various platform-specific logging implementations.
|
|
break;
|
|
}
|
|
case '?': {
|
|
show_usage = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (show_usage) {
|
|
std::cout << std::endl;
|
|
std::cout << "usage: " << argv[0] << " [options]" << std::endl << std::endl;
|
|
std::cout << " enclose multiple arguments in '' when using adb shell"
|
|
<< std::endl;
|
|
std::cout << " e.g. adb shell '" << argv[0] << " --server=\"url\"'"
|
|
<< std::endl << std::endl;
|
|
|
|
std::cout << std::setw(30) << std::left << " --server=<server_url>";
|
|
std::cout
|
|
<< "configure the license server url, please include http[s] in the url"
|
|
<< std::endl;
|
|
std::cout << std::setw(30) << std::left << " ";
|
|
std::cout << "default: " << license_server << std::endl;
|
|
|
|
std::cout << std::setw(30) << std::left << " --keyid=<key_id>";
|
|
std::cout << "configure the key id or pssh, in hex format" << std::endl;
|
|
std::cout << std::setw(30) << std::left << " default keyid:";
|
|
std::cout << g_key_id_pssh << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
std::cout << std::endl;
|
|
std::cout << "Server: " << g_license_server << std::endl;
|
|
std::cout << "KeyID: " << g_key_id_pssh << std::endl << std::endl;
|
|
|
|
g_key_id_pssh = wvcdm::a2bs_hex(g_key_id_pssh);
|
|
config.set_license_server(g_license_server);
|
|
config.set_key_id(g_key_id_pssh);
|
|
|
|
// Extract the key ID from the PSSH box.
|
|
wvcdm::InitializationData extractor(wvcdm::CENC_INIT_DATA_FORMAT,
|
|
g_key_id_pssh);
|
|
g_key_id_unwrapped = extractor.data();
|
|
|
|
return RUN_ALL_TESTS();
|
|
}
|