196 lines
7.3 KiB
C++
196 lines
7.3 KiB
C++
// Copyright 2020 Google LLC. All Rights Reserved. This file and proprietary
|
|
// source code may only be used and distributed under the Widevine Master
|
|
// License Agreement.
|
|
|
|
// These tests perform various end-to-end actions similar to what an application
|
|
// would do. They verify that policies specified on UAT are honored on the
|
|
// device.
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "cdm_engine.h"
|
|
#include "clock.h"
|
|
#include "config_test_env.h"
|
|
#include "initialization_data.h"
|
|
#include "license_request.h"
|
|
#include "log.h"
|
|
#include "metrics_collections.h"
|
|
#include "test_base.h"
|
|
#include "test_printers.h"
|
|
#include "test_sleep.h"
|
|
#include "url_request.h"
|
|
#include "wv_cdm_constants.h"
|
|
#include "wv_cdm_types.h"
|
|
|
|
namespace wvcdm {
|
|
|
|
namespace {
|
|
constexpr int kHttpOk = 200;
|
|
const std::string kCencMimeType = "cenc";
|
|
} // namespace
|
|
|
|
// Core Policy Integration Test
|
|
class CorePIGTest : public WvCdmTestBaseWithEngine {
|
|
protected:
|
|
void SetUp() override {
|
|
WvCdmTestBase::SetUp();
|
|
EnsureProvisioned();
|
|
}
|
|
|
|
void OpenSession(CdmSessionId* session_id) {
|
|
CdmResponseType status = cdm_engine_.OpenSession(
|
|
config_.key_system(), nullptr, nullptr, session_id);
|
|
ASSERT_EQ(NO_ERROR, status);
|
|
ASSERT_TRUE(cdm_engine_.IsOpenSession(*session_id));
|
|
}
|
|
|
|
void CloseSession(const CdmSessionId& session_id) {
|
|
CdmResponseType status = cdm_engine_.CloseSession(session_id);
|
|
ASSERT_EQ(NO_ERROR, status);
|
|
ASSERT_FALSE(cdm_engine_.IsOpenSession(session_id));
|
|
}
|
|
|
|
// Create a license request for the given content_id and requesting the
|
|
// specified license_type.
|
|
void GenerateKeyRequest(const CdmSessionId& session_id,
|
|
const std::string& content_id,
|
|
CdmKeyRequest* key_request,
|
|
CdmLicenseType license_type) {
|
|
video_widevine::WidevinePsshData pssh;
|
|
pssh.set_content_id(content_id);
|
|
const std::string init_data_string = MakePSSH(pssh);
|
|
const InitializationData init_data(kCencMimeType, init_data_string);
|
|
init_data.DumpToLogs();
|
|
CdmAppParameterMap empty_app_parameters;
|
|
CdmKeySetId empty_key_set_id;
|
|
CdmResponseType result = cdm_engine_.GenerateKeyRequest(
|
|
session_id, empty_key_set_id, init_data, license_type,
|
|
empty_app_parameters, key_request);
|
|
ASSERT_EQ(KEY_MESSAGE, result);
|
|
ASSERT_EQ(kKeyRequestTypeInitial, key_request->type);
|
|
}
|
|
|
|
// Send the request to the server and get the response.
|
|
void GetKeyResponse(const CdmKeyRequest& key_request,
|
|
std::string* key_response) {
|
|
const std::string url = config_.license_server() + config_.client_auth();
|
|
UrlRequest url_request(url);
|
|
ASSERT_TRUE(url_request.is_connected());
|
|
|
|
std::string http_response;
|
|
url_request.PostRequest(key_request.message);
|
|
ASSERT_TRUE(url_request.GetResponse(&http_response));
|
|
int status_code = url_request.GetStatusCode(http_response);
|
|
ASSERT_EQ(kHttpOk, status_code);
|
|
|
|
LicenseRequest license_request;
|
|
license_request.GetDrmMessage(http_response, *key_response);
|
|
}
|
|
|
|
// Load the license response into the specified session. Verify it has the
|
|
// correct license type (either streaming or offline).
|
|
void AddKey(const CdmSessionId& session_id, const std::string& key_response,
|
|
CdmLicenseType expected_license_type, CdmKeySetId* key_set_id) {
|
|
CdmLicenseType license_type;
|
|
CdmResponseType status =
|
|
cdm_engine_.AddKey(session_id, key_response, &license_type, key_set_id);
|
|
ASSERT_EQ(KEY_ADDED, status);
|
|
ASSERT_EQ(expected_license_type, license_type);
|
|
}
|
|
|
|
// Reload the license response into the specified session.
|
|
void RestoreKey(const CdmSessionId& session_id,
|
|
const CdmKeySetId& key_set_id) {
|
|
CdmResponseType status = cdm_engine_.RestoreKey(session_id, key_set_id);
|
|
ASSERT_EQ(KEY_ADDED, status);
|
|
}
|
|
|
|
// Use the key to decrypt.
|
|
void Decrypt(const CdmSessionId& session_id, const KeyId& key_id) {
|
|
constexpr size_t buffer_size = 500;
|
|
const std::vector<uint8_t> input(buffer_size, 0);
|
|
std::vector<uint8_t> output(buffer_size, 0);
|
|
const std::vector<uint8_t> iv(KEY_IV_SIZE, 0);
|
|
Decrypt(session_id, key_id, input, iv, &output, NO_ERROR);
|
|
}
|
|
|
|
// Try to use the key to decrypt, but expect the key has expired.
|
|
void FailDecrypt(const CdmSessionId& session_id, const KeyId& key_id) {
|
|
constexpr size_t buffer_size = 500;
|
|
const std::vector<uint8_t> input(buffer_size, 0);
|
|
std::vector<uint8_t> output(buffer_size, 0);
|
|
const std::vector<uint8_t> iv(KEY_IV_SIZE, 0);
|
|
Decrypt(session_id, key_id, input, iv, &output, NEED_KEY);
|
|
}
|
|
|
|
void Decrypt(const CdmSessionId& session_id, const KeyId& key_id,
|
|
const std::vector<uint8_t>& input,
|
|
const std::vector<uint8_t>& iv, std::vector<uint8_t>* output,
|
|
CdmResponseType expected_status) {
|
|
CdmDecryptionParametersV16 params(key_id);
|
|
params.is_secure = false;
|
|
CdmDecryptionSample sample(input.data(), output->data(), 0, input.size(),
|
|
iv);
|
|
CdmDecryptionSubsample subsample(0, input.size());
|
|
sample.subsamples.push_back(subsample);
|
|
params.samples.push_back(sample);
|
|
|
|
CdmResponseType status = cdm_engine_.DecryptV16(session_id, params);
|
|
ASSERT_EQ(expected_status, status);
|
|
}
|
|
};
|
|
|
|
// An offline license with nonce not required.
|
|
TEST_F(CorePIGTest, OfflineNoNonce) {
|
|
const std::string content_id = "2015_tears";
|
|
const KeyId key_id = "0000000000000000";
|
|
|
|
const CdmLicenseType license_type = kLicenseTypeOffline;
|
|
CdmSessionId session_id;
|
|
ASSERT_NO_FATAL_FAILURE(OpenSession(&session_id));
|
|
CdmKeyRequest key_request;
|
|
ASSERT_NO_FATAL_FAILURE(
|
|
GenerateKeyRequest(session_id, content_id, &key_request, license_type));
|
|
std::string key_response;
|
|
ASSERT_NO_FATAL_FAILURE(GetKeyResponse(key_request, &key_response));
|
|
CdmKeySetId key_set_id;
|
|
ASSERT_NO_FATAL_FAILURE(
|
|
AddKey(session_id, key_response, license_type, &key_set_id));
|
|
ASSERT_NO_FATAL_FAILURE(Decrypt(session_id, key_id));
|
|
ASSERT_NO_FATAL_FAILURE(CloseSession(session_id));
|
|
ASSERT_NO_FATAL_FAILURE(OpenSession(&session_id));
|
|
ASSERT_NO_FATAL_FAILURE(RestoreKey(session_id, key_set_id));
|
|
ASSERT_NO_FATAL_FAILURE(Decrypt(session_id, key_id));
|
|
ASSERT_NO_FATAL_FAILURE(CloseSession(session_id));
|
|
}
|
|
|
|
// An offline license with nonce and provider session token.
|
|
TEST_F(CorePIGTest, OfflineWithPST) {
|
|
const std::string content_id = "offline_clip2";
|
|
const KeyId key_id =
|
|
"\x32\x60\xF3\x9E\x12\xCC\xF6\x53\x52\x99\x90\x16\x8A\x35\x83\xFF";
|
|
const CdmLicenseType license_type = kLicenseTypeOffline;
|
|
CdmSessionId session_id;
|
|
ASSERT_NO_FATAL_FAILURE(OpenSession(&session_id));
|
|
CdmKeyRequest key_request;
|
|
ASSERT_NO_FATAL_FAILURE(
|
|
GenerateKeyRequest(session_id, content_id, &key_request, license_type));
|
|
std::string key_response;
|
|
ASSERT_NO_FATAL_FAILURE(GetKeyResponse(key_request, &key_response));
|
|
CdmKeySetId key_set_id;
|
|
ASSERT_NO_FATAL_FAILURE(
|
|
AddKey(session_id, key_response, license_type, &key_set_id));
|
|
ASSERT_NO_FATAL_FAILURE(Decrypt(session_id, key_id));
|
|
ASSERT_NO_FATAL_FAILURE(CloseSession(session_id));
|
|
ASSERT_NO_FATAL_FAILURE(OpenSession(&session_id));
|
|
ASSERT_NO_FATAL_FAILURE(RestoreKey(session_id, key_set_id));
|
|
ASSERT_NO_FATAL_FAILURE(Decrypt(session_id, key_id));
|
|
ASSERT_NO_FATAL_FAILURE(CloseSession(session_id));
|
|
}
|
|
|
|
} // namespace wvcdm
|