widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace PST Report with buffer

Browse Source 
Merge from Widevine repo of http://go/wvgerrit/23044

On some platforms, the compiler will not pack structures.  This CL
replaces the OECrypto_PST_Report packed structure with a simple buffer
of uint8_t.  This changes the signature of OEMCrypto_ReportUsage as
part of OEMCrypto v13.

There is also a new wrapper class that test code, the mock, and debug
code can use to access data in the report.

The old packed structure definition is moved to the level 3, where we
use a compiler that packs sructs when asked nicely.

arm/libwvlevel3.a  Level3 Library 4445 Jan 20 2017 11:29:15
x86/libwvlevel3.a  Level3 Library 4464 Jan 20 2017 11:10:49
mips/libwvlevel3.a  Level3 Library 4465 Jan 20 2017 10:56:08

b/32180083

Change-Id: Ie138f034cb12780a2f8636888cebf022c52169e5
This commit is contained in:
Fred Gylys-Colwell
2017-01-20 19:02:20 -08:00
parent a494eeafdc
commit 7152957e42
15 changed files with 341 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
libwvdrmengine/cdm/core/src/crypto_session.cpp
View File

@@ -13,6 +13,7 @@
#include "crypto_key.h"
#include "log.h"
#include "properties.h"
#include "pst_report.h"
#include "string_conversions.h"
#include "wv_cdm_constants.h"
@@ -835,65 +836,65 @@ CdmResponseType CryptoSession::GenerateUsageReport(
}
}
usage_report->resize(usage_length);
OEMCrypto_PST_Report* report = reinterpret_cast<OEMCrypto_PST_Report*>(
const_cast<char*>(usage_report->data()));
std::vector<uint8_t> buffer(usage_length);
status = OEMCrypto_ReportUsage(oec_session_id_, pst,
provider_session_token.length(), report,
&usage_length);
provider_session_token.length(),
&buffer[0], &usage_length);
if (OEMCrypto_SUCCESS != status) {
LOGE("CryptoSession::GenerateUsageReport: Report Usage error=%ld", status);
return UNKNOWN_ERROR;
}
if (usage_length != usage_report->length()) {
usage_report->resize(usage_length);
if (usage_length != buffer.size()) {
buffer.resize(usage_length);
}
(*usage_report) = std::string(reinterpret_cast<const char *>(&buffer[0]),
buffer.size());
OEMCrypto_PST_Report pst_report;
Unpacked_PST_Report pst_report(&buffer[0]);
*usage_duration_status = kUsageDurationsInvalid;
if (usage_length < sizeof(pst_report)) {
if (usage_length < pst_report.report_size()) {
LOGE("CryptoSession::GenerateUsageReport: usage report too small=%ld",
usage_length);
return NO_ERROR; // usage report available but no duration information
}
memcpy(&pst_report, usage_report->data(), sizeof(pst_report));
if (kUnused == pst_report.status) {
if (kUnused == pst_report.status()) {
*usage_duration_status = kUsageDurationPlaybackNotBegun;
return NO_ERROR;
}
LOGV("OEMCrypto_PST_Report.status: %d\n", pst_report.status);
LOGV("OEMCrypto_PST_Report.status: %d\n", pst_report.status());
LOGV("OEMCrypto_PST_Report.clock_security_level: %d\n",
pst_report.clock_security_level);
LOGV("OEMCrypto_PST_Report.pst_length: %d\n", pst_report.pst_length);
LOGV("OEMCrypto_PST_Report.padding: %d\n", pst_report.padding);
pst_report.clock_security_level());
LOGV("OEMCrypto_PST_Report.pst_length: %d\n",
pst_report.pst_length());
LOGV("OEMCrypto_PST_Report.padding: %d\n", pst_report.padding());
LOGV("OEMCrypto_PST_Report.seconds_since_license_received: %lld\n",
ntohll64(pst_report.seconds_since_license_received));
pst_report.seconds_since_license_received());
LOGV("OEMCrypto_PST_Report.seconds_since_first_decrypt: %lld\n",
ntohll64(pst_report.seconds_since_first_decrypt));
pst_report.seconds_since_first_decrypt());
LOGV("OEMCrypto_PST_Report.seconds_since_last_decrypt: %lld\n",
ntohll64(pst_report.seconds_since_last_decrypt));
pst_report.seconds_since_last_decrypt());
LOGV("OEMCrypto_PST_Report: %s\n", b2a_hex(*usage_report).c_str());
if (kInactiveUnused == pst_report.status) {
if (kInactiveUnused == pst_report.status()) {
*usage_duration_status = kUsageDurationPlaybackNotBegun;
return NO_ERROR;
}
// Before OEMCrypto v13, When usage report state is inactive, we have to
// deduce whether the license was ever used.
if (kInactive == pst_report.status &&
(0 > ntohll64(pst_report.seconds_since_first_decrypt) ||
ntohll64(pst_report.seconds_since_license_received) <
ntohll64(pst_report.seconds_since_first_decrypt))) {
if (kInactive == pst_report.status() &&
(0 > pst_report.seconds_since_first_decrypt() ||
pst_report.seconds_since_license_received() <
pst_report.seconds_since_first_decrypt())) {
*usage_duration_status = kUsageDurationPlaybackNotBegun;
return NO_ERROR;
}
*usage_duration_status = kUsageDurationsValid;
*seconds_since_started = ntohll64(pst_report.seconds_since_first_decrypt);
*seconds_since_last_played = ntohll64(pst_report.seconds_since_last_decrypt);
*seconds_since_started = pst_report.seconds_since_first_decrypt();
*seconds_since_last_played = pst_report.seconds_since_last_decrypt();
return NO_ERROR;
}

4
libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp
View File

@@ -184,7 +184,7 @@ typedef OEMCryptoResult (*L1_DeactivateUsageEntry_V12_t)(const uint8_t* pst,
typedef OEMCryptoResult (*L1_ReportUsage_t)(OEMCrypto_SESSION session,
const uint8_t* pst,
size_t pst_length,
OEMCrypto_PST_Report* buffer,
uint8_t* buffer,
size_t* buffer_length);
typedef OEMCryptoResult (*L1_DeleteUsageEntry_t)(
OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length,
@@ -1443,7 +1443,7 @@ extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION sess
extern "C" OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
const uint8_t* pst,
size_t pst_length,
OEMCrypto_PST_Report* buffer,
uint8_t* buffer,
size_t* buffer_length) {
if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
LevelSession pair = kAdapter->get(session);

29
libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp
View File

@@ -17,6 +17,7 @@
#include "oemcrypto_adapter.h"
#include "OEMCryptoCENC.h"
#include "properties.h"
#include "pst_report.h"
#include "string_conversions.h"
#include "test_base.h"
#include "url_request.h"
@@ -566,25 +567,25 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
EXPECT_TRUE(!existing_license.session_usage_table_entry().empty());
// Verify usage report
OEMCrypto_PST_Report usage_report;
memcpy(&usage_report, existing_license.session_usage_table_entry().data(),
sizeof(usage_report));
EXPECT_EQ(sizeof(usage_report) + usage_report.pst_length,
uint8_t *buffer = reinterpret_cast<uint8_t *>(
const_cast<char *>(existing_license.session_usage_table_entry().data()));
Unpacked_PST_Report usage_report(buffer);
EXPECT_EQ(usage_report.report_size(),
existing_license.session_usage_table_entry().size());
EXPECT_EQ(kInactiveUsed, usage_report.status);
EXPECT_EQ(id.provider_session_token().size(), usage_report.pst_length);
std::string pst(existing_license.session_usage_table_entry().data() +
sizeof(OEMCrypto_PST_Report),
usage_report.pst_length);
EXPECT_EQ(kInactiveUsed, usage_report.status());
EXPECT_EQ(id.provider_session_token().size(),
usage_report.pst_length());
std::string pst(reinterpret_cast<char *>(usage_report.pst()),
usage_report.pst_length());
EXPECT_EQ(id.provider_session_token(), pst);
EXPECT_LE(kInsecureClock, usage_report.clock_security_level);
EXPECT_LE(kInsecureClock, usage_report.clock_security_level());
int64_t seconds_since_license_received =
htonll64(usage_report.seconds_since_license_received);
int64_t seconds_since_license_received
= usage_report.seconds_since_license_received();
int64_t seconds_since_first_decrypt =
htonll64(usage_report.seconds_since_first_decrypt);
usage_report.seconds_since_first_decrypt();
int64_t seconds_since_last_decrypt =
htonll64(usage_report.seconds_since_last_decrypt);
usage_report.seconds_since_last_decrypt();
// Detect licenses that were never used
if (seconds_since_first_decrypt < 0 ||
seconds_since_first_decrypt > seconds_since_license_received) {

BIN
libwvdrmengine/level3/arm/libwvlevel3.a
View File

Binary file not shown.

BIN
libwvdrmengine/level3/mips/libwvlevel3.a
View File

Binary file not shown.

BIN
libwvdrmengine/level3/x86/libwvlevel3.a
View File

Binary file not shown.

8
libwvdrmengine/oemcrypto/include/OEMCryptoCENC.h
View File

@@ -249,7 +249,12 @@ typedef enum OEMCrypto_Usage_Entry_Status {
/*
* OEMCrypto_PST_Report is used to report an entry from the Usage Table.
*
* Platforms that have compilers that support packed structures, may use the
* following definition. Other platforms may use the header pst_report.h which
* defines a wrapper class.
*/
#if 0 // If your compiler supports __attribute__((packed)).
typedef struct {
uint8_t signature[20]; // -- HMAC SHA1 of the rest of the report.
uint8_t status; // current status of entry. (OEMCrypto_Usage_Entry_Status)
@@ -261,6 +266,7 @@ typedef struct {
int64_t seconds_since_last_decrypt; // now - time_of_last_decrypt
uint8_t pst[];
} __attribute__((packed)) OEMCrypto_PST_Report;
#endif
/*
* OEMCrypto_Clock_Security_Level.
@@ -2696,7 +2702,7 @@ OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION session,
/* TODO(fredgc): copy text from http://go/wvgerrit/22887 */
OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
const uint8_t* pst, size_t pst_length,
OEMCrypto_PST_Report* buffer,
uint8_t* buffer,
size_t* buffer_length);
/*

2
libwvdrmengine/oemcrypto/include/level3.h
View File

@@ -231,7 +231,7 @@ OEMCryptoResult Level3_DeactivateUsageEntry(OEMCrypto_SESSION session,
OEMCryptoResult Level3_ReportUsage(OEMCrypto_SESSION session,
const uint8_t *pst,
size_t pst_length,
OEMCrypto_PST_Report *buffer,
uint8_t *buffer,
size_t *buffer_length);
OEMCryptoResult Level3_DeleteUsageEntry(OEMCrypto_SESSION session,
const uint8_t* pst,

146
libwvdrmengine/oemcrypto/include/pst_report.h Normal file
View File

@@ -0,0 +1,146 @@
// Copyright 2017 Google Inc. All Rights Reserved.
/*********************************************************************
* pst_report.h
*
* Reference APIs needed to support Widevine's crypto algorithms.
*********************************************************************/
#ifndef PST_REPORT_H_
#define PST_REPORT_H_
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include "OEMCryptoCENC.h"
#include "string_conversions.h" // needed for htonll64.
namespace wvcdm {
class Unpacked_PST_Report {
public:
// This object does not own the buffer, and does not check that buffer
// is not null.
Unpacked_PST_Report(uint8_t *buffer) : buffer_(buffer) {}
// Copy and move semantics of this class is like that of a pointer.
Unpacked_PST_Report(const Unpacked_PST_Report& other) :
buffer_(other.buffer_) {}
Unpacked_PST_Report& operator=(const Unpacked_PST_Report& other) {
buffer_ = other.buffer_;
return *this;
}
size_t report_size() const {
return pst_length() + kraw_pst_report_size;
}
static size_t report_size(size_t pst_length) {
return pst_length + kraw_pst_report_size;
}
uint8_t status() const {
return static_cast<uint8_t>(* (buffer_ + kstatus_offset));
}
void set_status(uint8_t value) {
buffer_[kstatus_offset] = value;
}
uint8_t* signature() {
return buffer_ + ksignature_offset;
}
uint8_t clock_security_level() const {
return static_cast<uint8_t>(* (buffer_ + kclock_security_level_offset));
}
void set_clock_security_level(uint8_t value) {
buffer_[kclock_security_level_offset] = value;
}
uint8_t pst_length() const {
return static_cast<uint8_t>(* (buffer_ + kpst_length_offset));
}
void set_pst_length(uint8_t value) {
buffer_[kpst_length_offset] = value;
}
uint8_t padding() const {
return static_cast<uint8_t>(* (buffer_ + kpadding_offset));
}
void set_padding(uint8_t value) {
buffer_[kpadding_offset] = value;
}
// In host byte order.
int64_t seconds_since_license_received() const {
int64_t time;
memcpy(&time, buffer_ + kseconds_since_license_received_offset,
sizeof(int64_t));
return wvcdm::ntohll64(time);
}
// Parameter time is in host byte order.
void set_seconds_since_license_received(int64_t time) const {
time = wvcdm::ntohll64(time);
memcpy(buffer_ + kseconds_since_license_received_offset, &time,
sizeof(int64_t));
}
// In host byte order.
int64_t seconds_since_first_decrypt() const {
int64_t time;
memcpy(&time, buffer_ + kseconds_since_first_decrypt_offset,
sizeof(int64_t));
return wvcdm::ntohll64(time);
}
// Parameter time is in host byte order.
void set_seconds_since_first_decrypt(int64_t time) const {
time = wvcdm::ntohll64(time);
memcpy(buffer_ + kseconds_since_first_decrypt_offset, &time,
sizeof(int64_t));
}
// In host byte order.
int64_t seconds_since_last_decrypt() const {
int64_t time;
memcpy(&time, buffer_ + kseconds_since_last_decrypt_offset,
sizeof(int64_t));
return wvcdm::ntohll64(time);
}
// Parameter time is in host byte order.
void set_seconds_since_last_decrypt(int64_t time) const {
time = wvcdm::ntohll64(time);
memcpy(buffer_ + kseconds_since_last_decrypt_offset, &time,
sizeof(int64_t));
}
uint8_t* pst() {
return (buffer_ + kpst_offset);
}
private:
uint8_t *buffer_;
// Size of the PST_Report without the pst string.
static const size_t kraw_pst_report_size = 48;
static const size_t ksignature_offset = 0;
static const size_t kstatus_offset = 20;
static const size_t kclock_security_level_offset = 21;
static const size_t kpst_length_offset = 22;
static const size_t kpadding_offset = 23;
static const size_t kseconds_since_license_received_offset = 24;
static const size_t kseconds_since_first_decrypt_offset = 32;
static const size_t kseconds_since_last_decrypt_offset = 40;
static const size_t kpst_offset = 48;
};
} // namespace wvcdm
#endif // PST_REPORT_H_

5
libwvdrmengine/oemcrypto/mock/src/oemcrypto_mock.cpp
View File

@@ -1691,7 +1691,7 @@ extern "C"
OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
const uint8_t *pst,
size_t pst_length,
OEMCrypto_PST_Report *buffer,
uint8_t *buffer,
size_t *buffer_length) {
if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
LOGI("-- OEMCryptoResult OEMCrypto_ReportUsage(\n");
@@ -1722,8 +1722,7 @@ OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
crypto_engine->usage_table()->UpdateTable();
if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
dump_hex("usage buffer", reinterpret_cast<uint8_t*>(buffer),
*buffer_length);
dump_hex("usage buffer", buffer, *buffer_length);
}
}
return sts;

29
libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.cpp
View File

@@ -20,6 +20,7 @@
#include "oemcrypto_engine_mock.h"
#include "oemcrypto_logging.h"
#include "properties.h"
#include "pst_report.h"
#include "string_conversions.h"
#include "wv_cdm_constants.h"
@@ -98,9 +99,9 @@ bool UsageTableEntry::UpdateTime() {
OEMCryptoResult UsageTableEntry::ReportUsage(SessionContext *session,
const std::vector<uint8_t> &pst,
OEMCrypto_PST_Report *buffer,
uint8_t *buffer,
size_t *buffer_length) {
size_t length_needed = sizeof(OEMCrypto_PST_Report) + pst.size();
size_t length_needed = wvcdm::Unpacked_PST_Report::report_size(pst.size());
if (*buffer_length < length_needed) {
*buffer_length = length_needed;
return OEMCrypto_ERROR_SHORT_BUFFER;
@@ -109,21 +110,19 @@ OEMCryptoResult UsageTableEntry::ReportUsage(SessionContext *session,
LOGE("ReportUsage: buffer was null pointer.");
return OEMCrypto_ERROR_INVALID_CONTEXT;
}
wvcdm::Unpacked_PST_Report pst_report(buffer);
int64_t now = time(NULL);
buffer->seconds_since_license_received =
wvcdm::htonll64(now - time_of_license_received_);
buffer->seconds_since_first_decrypt =
wvcdm::htonll64(now - time_of_first_decrypt_);
buffer->seconds_since_last_decrypt =
wvcdm::htonll64(now - time_of_last_decrypt_);
buffer->status = status_;
buffer->clock_security_level = kSecureTimer;
buffer->pst_length = static_cast<uint8_t>(pst.size());
memcpy(buffer->pst, &pst[0], length_needed - sizeof(OEMCrypto_PST_Report));
unsigned int md_len = sizeof(buffer->signature);
pst_report.set_seconds_since_license_received(now - time_of_license_received_);
pst_report.set_seconds_since_first_decrypt(now - time_of_first_decrypt_);
pst_report.set_seconds_since_last_decrypt(now - time_of_last_decrypt_);
pst_report.set_status(status_);
pst_report.set_clock_security_level(kSecureTimer);
pst_report.set_pst_length(static_cast<uint8_t>(pst.size()));
memcpy(pst_report.pst(), &pst[0], pst.size());
unsigned int md_len = SHA_DIGEST_LENGTH;
if (!HMAC(EVP_sha1(), &mac_key_client_[0], mac_key_client_.size(),
reinterpret_cast<uint8_t *>(buffer) + SHA_DIGEST_LENGTH,
length_needed - SHA_DIGEST_LENGTH, buffer->signature, &md_len)) {
buffer + SHA_DIGEST_LENGTH, length_needed - SHA_DIGEST_LENGTH,
pst_report.signature(), &md_len)) {
LOGE("UsageTableEntry: could not compute signature.");
return OEMCrypto_ERROR_UNKNOWN_FAILURE;
}

2
libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.h
View File

@@ -55,7 +55,7 @@ class UsageTableEntry {
bool UpdateTime();
OEMCryptoResult ReportUsage(SessionContext *session,
const std::vector<uint8_t> &pst,
OEMCrypto_PST_Report *buffer,
uint8_t *buffer,
size_t *buffer_length);
// Set them if not set, verify if already set.
bool VerifyOrSetMacKeys(const std::vector<uint8_t> &server,

22
libwvdrmengine/oemcrypto/test/oec_session_util.cpp
View File

@@ -819,17 +819,17 @@ void Session::GenerateReport(const std::string& pst, bool expect_success,
size_t length = 0;
OEMCryptoResult sts = OEMCrypto_ReportUsage(
session_id(), reinterpret_cast<const uint8_t*>(pst.c_str()), pst.length(),
pst_report(), &length);
&pst_report_buffer_[0], &length);
if (expect_success) {
ASSERT_EQ(OEMCrypto_ERROR_SHORT_BUFFER, sts);
}
if (sts == OEMCrypto_ERROR_SHORT_BUFFER) {
ASSERT_LE(sizeof(OEMCrypto_PST_Report), length);
ASSERT_EQ(wvcdm::Unpacked_PST_Report::report_size(pst.length()), length);
pst_report_buffer_.resize(length);
}
sts = OEMCrypto_ReportUsage(session_id(),
reinterpret_cast<const uint8_t*>(pst.c_str()),
pst.length(), pst_report(), &length);
pst.length(), &pst_report_buffer_[0], &length);
if (!expect_success) {
ASSERT_NE(OEMCrypto_SUCCESS, sts);
return;
@@ -838,18 +838,14 @@ void Session::GenerateReport(const std::string& pst, bool expect_success,
vector<uint8_t> computed_signature(SHA_DIGEST_LENGTH);
unsigned int sig_len = SHA_DIGEST_LENGTH;
HMAC(EVP_sha1(), &mac_key_client_[0], mac_key_client_.size(),
reinterpret_cast<uint8_t*>(pst_report()) + SHA_DIGEST_LENGTH,
&pst_report_buffer_[SHA_DIGEST_LENGTH],
length - SHA_DIGEST_LENGTH, &computed_signature[0], &sig_len);
EXPECT_EQ(0, memcmp(&computed_signature[0], pst_report()->signature,
EXPECT_EQ(0, memcmp(&computed_signature[0], pst_report().signature(),
SHA_DIGEST_LENGTH));
EXPECT_GE(kInactiveUnused, pst_report()->status);
EXPECT_GE(kHardwareSecureClock, pst_report()->clock_security_level);
EXPECT_EQ(pst.length(), pst_report()->pst_length);
EXPECT_EQ(0, memcmp(pst.c_str(), pst_report()->pst, pst.length()));
}
OEMCrypto_PST_Report* Session::pst_report() {
return reinterpret_cast<OEMCrypto_PST_Report*>(&pst_report_buffer_[0]);
EXPECT_GE(kInactiveUnused, pst_report().status());
EXPECT_GE(kHardwareSecureClock, pst_report().clock_security_level());
EXPECT_EQ(pst.length(), pst_report().pst_length());
EXPECT_EQ(0, memcmp(pst.c_str(), pst_report().pst(), pst.length()));
}
void Session::DeleteEntry(const std::string& pst) {

9
libwvdrmengine/oemcrypto/test/oec_session_util.h
View File

@@ -10,6 +10,7 @@
#include <vector>
#include "oec_device_features.h"
#include "pst_report.h"
#include "wv_cdm_constants.h"
using namespace std;
@@ -253,9 +254,11 @@ class Session {
// order to verify signatures.
void GenerateReport(const std::string& pst, bool expect_success = true,
Session* other = 0);
// Returns a pointer to the usage report generated by the previous call to
// GenerateReport.
OEMCrypto_PST_Report* pst_report();
// Returns a pointer-like thing to the usage report generated by the previous
// call to GenerateReport.
wvcdm::Unpacked_PST_Report pst_report() {
return wvcdm::Unpacked_PST_Report(&pst_report_buffer_[0]);
}
// Creates a signed delete usage table entry message and calls
// OEMCrypto_DeleteUsageEntry on it.
void DeleteEntry(const std::string& pst);

240
libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp
View File

@@ -4312,9 +4312,9 @@ class UsageTableTest : public GenericCryptoTest {
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_UpdateUsageTable());
s.GenerateReport(pst);
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report()->status);
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(0,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.close());
}
@@ -4351,27 +4351,6 @@ class UsageTableTestWithMAC : public UsageTableTest,
}
};
TEST_F(UsageTableTest, PSTReportSizes) {
OEMCrypto_PST_Report report;
uint8_t* location = reinterpret_cast<uint8_t*>(&report);
EXPECT_EQ(48u, sizeof(report));
uint8_t* field;
field = reinterpret_cast<uint8_t*>(&report.status);
EXPECT_EQ(20, field - location);
field = reinterpret_cast<uint8_t*>(&report.clock_security_level);
EXPECT_EQ(21, field - location);
field = reinterpret_cast<uint8_t*>(&report.pst_length);
EXPECT_EQ(22, field - location);
field = reinterpret_cast<uint8_t*>(&report.seconds_since_license_received);
EXPECT_EQ(24, field - location);
field = reinterpret_cast<uint8_t*>(&report.seconds_since_first_decrypt);
EXPECT_EQ(32, field - location);
field = reinterpret_cast<uint8_t*>(&report.seconds_since_last_decrypt);
EXPECT_EQ(40, field - location);
field = reinterpret_cast<uint8_t*>(&report.pst);
EXPECT_EQ(48, field - location);
}
TEST_P(UsageTableTestWithMAC, OnlineLicense) {
std::string pst = "my_pst";
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_UpdateUsageTable());
@@ -4389,25 +4368,22 @@ TEST_P(UsageTableTestWithMAC, OnlineLicense) {
s.GenerateReport(pst); // test repeated report generation
s.GenerateReport(pst);
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report()->status);
EXPECT_NEAR(0,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.TestDecryptCTR());
s.GenerateReport(pst);
EXPECT_EQ(kActive, s.pst_report()->status);
EXPECT_NEAR(0,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
EXPECT_EQ(kActive, s.pst_report().status());
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(0, wvcdm::htonll64(s.pst_report()->seconds_since_first_decrypt),
EXPECT_NEAR(0, s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(0, wvcdm::htonll64(s.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(DeactivatePST(pst));
ASSERT_NO_FATAL_FAILURE(s.GenerateReport(pst));
EXPECT_EQ(kInactiveUsed, s.pst_report()->status);
EXPECT_NEAR(0,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
EXPECT_EQ(kInactiveUsed, s.pst_report().status());
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(
s.TestDecryptCTR(false, OEMCrypto_ERROR_UNKNOWN_FAILURE));
@@ -4436,17 +4412,17 @@ TEST_P(UsageTableTestWithMAC, OnlineLicenseWithRefresh) {
s.get_nonce(), OEMCrypto_SUCCESS));
s.GenerateReport(pst);
time_t report_generated = time(NULL);
EXPECT_EQ(kActive, s.pst_report()->status);
EXPECT_EQ(kActive, s.pst_report().status());
// license received at LoadKeys, not at RefreshKeys.
EXPECT_NEAR(report_generated - loaded,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
// First decrypt was just after LoadKeys.
EXPECT_NEAR(report_generated - loaded,
wvcdm::htonll64(s.pst_report()->seconds_since_first_decrypt),
s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
// Last decrypt just before report generated.
EXPECT_NEAR(0, wvcdm::htonll64(s.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
}
@@ -4555,7 +4531,7 @@ TEST_F(UsageTableTest, FiftyEntries) {
char c = 'A' + i;
pst = pst + c;
s.GenerateReport(pst, true, &sessions[i]);
EXPECT_EQ(kUnused, s.pst_report()->status);
EXPECT_EQ(kUnused, s.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s.close());
}
sleep(kShortSleep);
@@ -4582,14 +4558,14 @@ TEST_F(UsageTableTest, FiftyEntries) {
char c = 'A' + i;
pst = pst + c;
s.GenerateReport(pst, true, &sessions[i]);
EXPECT_EQ(kUnused, s.pst_report()->status);
EXPECT_EQ(kUnused, s.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s.close());
}
ASSERT_NO_FATAL_FAILURE(s1.close());
ASSERT_NO_FATAL_FAILURE(
s1.open()); // Make sure s1's entry is still in the table.
s1.GenerateReport(pst1);
EXPECT_EQ(kUnused, s1.pst_report()->status);
EXPECT_EQ(kUnused, s1.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s1.close());
}
@@ -4611,7 +4587,7 @@ TEST_P(UsageTableTestWithMAC, DeleteUnusedEntry) {
Session s2;
ASSERT_NO_FATAL_FAILURE(s2.open());
s2.GenerateReport(pst, true, &s);
EXPECT_EQ(kUnused, s2.pst_report()->status);
EXPECT_EQ(kUnused, s2.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s2.DeleteEntry(pst));
ASSERT_NO_FATAL_FAILURE(s2.close());
@@ -4641,7 +4617,7 @@ TEST_P(UsageTableTestWithMAC, DeleteActiveEntry) {
Session s2;
ASSERT_NO_FATAL_FAILURE(s2.open());
ASSERT_NO_FATAL_FAILURE(s2.GenerateReport(pst, true, &s));
EXPECT_EQ(kActive, s2.pst_report()->status);
EXPECT_EQ(kActive, s2.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s2.DeleteEntry(pst));
ASSERT_NO_FATAL_FAILURE(s2.close());
@@ -4696,7 +4672,7 @@ TEST_P(UsageTableTestWithMAC, DeleteInactiveEntry) {
Session s2;
ASSERT_NO_FATAL_FAILURE(s2.open());
s2.GenerateReport(pst, true, &s);
EXPECT_EQ(kInactiveUsed, s2.pst_report()->status);
EXPECT_EQ(kInactiveUsed, s2.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s2.DeleteEntry(pst));
ASSERT_NO_FATAL_FAILURE(s2.close());
@@ -4740,7 +4716,7 @@ TEST_P(UsageTableTestWithMAC, DeleteEntryBadSignature) {
Session s3;
ASSERT_NO_FATAL_FAILURE(s3.open());
s3.GenerateReport(pst, true, &s);
EXPECT_EQ(kUnused, s3.pst_report()->status);
EXPECT_EQ(kUnused, s3.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s3.close());
}
@@ -4778,7 +4754,7 @@ TEST_P(UsageTableTestWithMAC, DeleteEntryWrongSession) {
Session s3;
ASSERT_NO_FATAL_FAILURE(s3.open());
s3.GenerateReport(pst, true, &s);
EXPECT_EQ(kUnused, s3.pst_report()->status);
EXPECT_EQ(kUnused, s3.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s3.close());
}
@@ -4816,7 +4792,7 @@ TEST_P(UsageTableTestWithMAC, DeleteEntryBadRange) {
Session s3;
ASSERT_NO_FATAL_FAILURE(s3.open());
s3.GenerateReport(pst, true, &s);
EXPECT_EQ(kUnused, s3.pst_report()->status);
EXPECT_EQ(kUnused, s3.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s3.close());
}
@@ -4856,21 +4832,17 @@ TEST_P(UsageTableTestWithMAC, GenericCryptoEncrypt) {
ASSERT_EQ(OEMCrypto_SUCCESS, sts);
EXPECT_EQ(expected_encrypted, encrypted);
session_.GenerateReport(pst);
EXPECT_EQ(kActive, session_.pst_report()->status);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_license_received),
EXPECT_EQ(kActive, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_first_decrypt),
EXPECT_NEAR(0, session_.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(0, session_.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(DeactivatePST(pst));
ASSERT_NO_FATAL_FAILURE(session_.GenerateReport(pst));
EXPECT_EQ(kInactiveUsed, session_.pst_report()->status);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_license_received),
EXPECT_EQ(kInactiveUsed, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
encrypted.assign(clear_buffer_.size(), 0);
sts = OEMCrypto_Generic_Encrypt(
@@ -4904,21 +4876,17 @@ TEST_P(UsageTableTestWithMAC, GenericCryptoDecrypt) {
ASSERT_EQ(OEMCrypto_SUCCESS, sts);
EXPECT_EQ(clear_buffer_, resultant);
session_.GenerateReport(pst);
EXPECT_EQ(kActive, session_.pst_report()->status);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_license_received),
EXPECT_EQ(kActive, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_first_decrypt),
EXPECT_NEAR(0, session_.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(0, session_.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(DeactivatePST(pst));
session_.GenerateReport(pst);
EXPECT_EQ(kInactiveUsed, session_.pst_report()->status);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_license_received),
EXPECT_EQ(kInactiveUsed, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
resultant.assign(encrypted.size(), 0);
sts = OEMCrypto_Generic_Decrypt(
@@ -4961,21 +4929,17 @@ TEST_P(UsageTableTestWithMAC, GenericCryptoSign) {
ASSERT_EQ(expected_signature, signature);
session_.GenerateReport(pst);
EXPECT_EQ(kActive, session_.pst_report()->status);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_license_received),
EXPECT_EQ(kActive, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_first_decrypt),
EXPECT_NEAR(0, session_.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(0, session_.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(DeactivatePST(pst));
ASSERT_NO_FATAL_FAILURE(session_.GenerateReport(pst));
EXPECT_EQ(kInactiveUsed, session_.pst_report()->status);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_license_received),
EXPECT_EQ(kInactiveUsed, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
signature.assign(SHA256_DIGEST_LENGTH, 0);
@@ -5012,21 +4976,18 @@ TEST_P(UsageTableTestWithMAC, GenericCryptoVerify) {
ASSERT_EQ(OEMCrypto_SUCCESS, sts);
session_.GenerateReport(pst);
EXPECT_EQ(kActive, session_.pst_report()->status);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_license_received),
EXPECT_EQ(kActive, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_first_decrypt),
EXPECT_NEAR(0, session_.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(0, session_.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(DeactivatePST(pst));
ASSERT_NO_FATAL_FAILURE(session_.GenerateReport(pst));
EXPECT_EQ(kInactiveUsed, session_.pst_report()->status);
EXPECT_EQ(kInactiveUsed, session_.pst_report().status());
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_license_received),
0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
sts = OEMCrypto_Generic_Verify(session_.session_id(), &clear_buffer_[0],
@@ -5062,17 +5023,17 @@ TEST_P(UsageTableTestWithMAC, OfflineLicenseRefresh) {
kAllKeys, wvoec_mock::kControlNonceOrEntry, 0, OEMCrypto_SUCCESS));
s.GenerateReport(pst);
time_t report_generated = time(NULL);
EXPECT_EQ(kActive, s.pst_report()->status);
EXPECT_EQ(kActive, s.pst_report().status());
// license received at LoadKeys, not at RefreshKeys.
EXPECT_NEAR(report_generated - loaded,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
// First decrypt was just after LoadKeys.
EXPECT_NEAR(report_generated - loaded,
wvcdm::htonll64(s.pst_report()->seconds_since_first_decrypt),
s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
// Last decrypt just before report generated.
EXPECT_NEAR(0, wvcdm::htonll64(s.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
}
@@ -5089,19 +5050,19 @@ TEST_P(UsageTableTestWithMAC, ReloadOfflineLicense) {
ASSERT_NO_FATAL_FAILURE(s.LoadTestKeys(pst, new_mac_keys_));
s.GenerateReport(pst);
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report()->status);
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(0,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.TestDecryptCTR());
s.GenerateReport(pst);
EXPECT_EQ(kActive, s.pst_report()->status);
EXPECT_EQ(kActive, s.pst_report().status());
EXPECT_NEAR(0,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(0, wvcdm::htonll64(s.pst_report()->seconds_since_first_decrypt),
EXPECT_NEAR(0, s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(0, wvcdm::htonll64(s.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.close());
}
@@ -5120,42 +5081,42 @@ TEST_P(UsageTableTestWithMAC, ReloadOfflineLicenseWithRefresh) {
ASSERT_NO_FATAL_FAILURE(s.LoadTestKeys(pst, new_mac_keys_));
s.GenerateReport(pst);
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report()->status);
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(0,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.TestDecryptCTR());
time_t decrypt_time = time(NULL);
s.GenerateReport(pst);
time_t report_generated = time(NULL);
EXPECT_EQ(kActive, s.pst_report()->status);
EXPECT_EQ(kActive, s.pst_report().status());
// license received at first LoadKeys.
EXPECT_NEAR(report_generated - loaded,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
// First decrypt was just after second LoadKeys.
EXPECT_NEAR(report_generated - decrypt_time,
wvcdm::htonll64(s.pst_report()->seconds_since_first_decrypt),
s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(report_generated - decrypt_time,
wvcdm::htonll64(s.pst_report()->seconds_since_last_decrypt),
s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
size_t kAllKeys = 1;
ASSERT_NO_FATAL_FAILURE(s.RefreshTestKeys(
kAllKeys, wvoec_mock::kControlNonceOrEntry, 0, OEMCrypto_SUCCESS));
s.GenerateReport(pst);
report_generated = time(NULL);
EXPECT_EQ(kActive, s.pst_report()->status);
EXPECT_EQ(kActive, s.pst_report().status());
// license received at LoadKeys, not at RefreshKeys.
EXPECT_NEAR(report_generated - loaded,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
// First decrypt was just after LoadKeys.
EXPECT_NEAR(report_generated - decrypt_time,
wvcdm::htonll64(s.pst_report()->seconds_since_first_decrypt),
s.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
// Last decrypt just before report generated.
EXPECT_NEAR(0, wvcdm::htonll64(s.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(0, s.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.close());
}
@@ -5189,7 +5150,7 @@ TEST_P(UsageTableTestWithMAC, BadReloadOfflineLicense) {
ASSERT_NO_FATAL_FAILURE(InstallTestSessionKeys(&s));
ASSERT_NO_FATAL_FAILURE(s.LoadTestKeys(pst, new_mac_keys_));
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report()->status);
EXPECT_EQ(kUnused, s.pst_report().status());
}
// An offline license should not load on the first call if the nonce is bad.
@@ -5247,9 +5208,9 @@ TEST_P(UsageTableTestWithMAC, DeactivateOfflineLicense) {
ASSERT_NO_FATAL_FAILURE(
s.TestDecryptCTR(false, OEMCrypto_ERROR_UNKNOWN_FAILURE));
s.GenerateReport(pst);
EXPECT_EQ(kInactiveUsed, s.pst_report()->status);
EXPECT_EQ(kInactiveUsed, s.pst_report().status());
EXPECT_NEAR(0,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.close());
@@ -5270,7 +5231,7 @@ TEST_P(UsageTableTestWithMAC, DeactivateOfflineLicense) {
Session s3;
ASSERT_NO_FATAL_FAILURE(s3.open());
s3.GenerateReport(pst, true, &s);
EXPECT_EQ(kInactiveUsed, s3.pst_report()->status);
EXPECT_EQ(kInactiveUsed, s3.pst_report().status());
}
TEST_P(UsageTableTestWithMAC, BadRange) {
@@ -5362,31 +5323,31 @@ TEST_F(UsageTableTest, TimingTest) {
time_t report_generated3 = time(NULL);
s3.GenerateReport(pst3);
EXPECT_EQ(kInactiveUsed, s1.pst_report()->status);
EXPECT_EQ(kInactiveUsed, s1.pst_report().status());
EXPECT_NEAR(report_generated1 - loaded1,
wvcdm::htonll64(s1.pst_report()->seconds_since_license_received),
s1.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(report_generated1 - first_decrypt1,
wvcdm::htonll64(s1.pst_report()->seconds_since_first_decrypt),
s1.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(report_generated1 - second_decrypt,
wvcdm::htonll64(s1.pst_report()->seconds_since_last_decrypt),
s1.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
EXPECT_EQ(kActive, s2.pst_report()->status);
EXPECT_EQ(kActive, s2.pst_report().status());
EXPECT_NEAR(report_generated2 - loaded2,
wvcdm::htonll64(s2.pst_report()->seconds_since_license_received),
s2.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(report_generated2 - first_decrypt2,
wvcdm::htonll64(s2.pst_report()->seconds_since_first_decrypt),
s2.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
EXPECT_NEAR(report_generated2 - third_decrypt,
wvcdm::htonll64(s2.pst_report()->seconds_since_last_decrypt),
s2.pst_report().seconds_since_last_decrypt(),
kTimeTolerance);
EXPECT_EQ(kUnused, s3.pst_report()->status);
EXPECT_EQ(kUnused, s3.pst_report().status());
EXPECT_NEAR(report_generated3 - loaded3,
wvcdm::htonll64(s3.pst_report()->seconds_since_license_received),
s3.pst_report().seconds_since_license_received(),
kTimeTolerance);
// We don't expect first or last decrypt for unused report.
}
@@ -5406,9 +5367,9 @@ TEST_F(UsageTableTest, VerifyUsageTimes) {
const int kLicenseReceivedTimeTolerance = kSpeedMultiplier;
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_UpdateUsageTable());
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report()->status);
EXPECT_NEAR(wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
0, kLicenseReceivedTimeTolerance);
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kLicenseReceivedTimeTolerance);
const time_t kDotIntervalInSeconds = 5;
const time_t kIdleInSeconds = 20;
@@ -5427,8 +5388,8 @@ TEST_F(UsageTableTest, VerifyUsageTimes) {
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_UpdateUsageTable());
s.GenerateReport(pst);
EXPECT_EQ(kUnused, s.pst_report()->status);
EXPECT_NEAR(wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
EXPECT_EQ(kUnused, s.pst_report().status());
EXPECT_NEAR(s.pst_report().seconds_since_license_received(),
kIdleInSeconds, kLicenseReceivedTimeTolerance);
cout << "Start simulated playback..." << endl;
@@ -5438,7 +5399,7 @@ TEST_F(UsageTableTest, VerifyUsageTimes) {
do {
ASSERT_NO_FATAL_FAILURE(s.TestDecryptCTR());
s.GenerateReport(pst);
EXPECT_EQ(kActive, s.pst_report()->status);
EXPECT_EQ(kActive, s.pst_report().status());
playback_time = time(NULL) - start_time;
ASSERT_LE(0, playback_time);
if (playback_time >= dot_time) {
@@ -5451,14 +5412,14 @@ TEST_F(UsageTableTest, VerifyUsageTimes) {
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_UpdateUsageTable());
s.GenerateReport(pst);
EXPECT_NEAR(wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
EXPECT_NEAR(s.pst_report().seconds_since_license_received(),
playback_time + kIdleInSeconds, kLicenseReceivedTimeTolerance);
EXPECT_NEAR(wvcdm::htonll64(s.pst_report()->seconds_since_first_decrypt),
EXPECT_NEAR(s.pst_report().seconds_since_first_decrypt(),
playback_time, kUsageTableTimeTolerance);
EXPECT_NEAR(wvcdm::htonll64(s.pst_report()->seconds_since_last_decrypt), 0,
EXPECT_NEAR(s.pst_report().seconds_since_last_decrypt(), 0,
kUsageTableTimeTolerance);
EXPECT_NEAR(wvcdm::htonll64(s.pst_report()->seconds_since_first_decrypt) -
wvcdm::htonll64(s.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(s.pst_report().seconds_since_first_decrypt() -
s.pst_report().seconds_since_last_decrypt(),
playback_time, kUsageTableTimeTolerance);
cout << "Wait another " << kIdleInSeconds
@@ -5475,17 +5436,17 @@ TEST_F(UsageTableTest, VerifyUsageTimes) {
// |<------------------------------------| = seconds_since_license_received
ASSERT_EQ(OEMCrypto_SUCCESS, OEMCrypto_UpdateUsageTable());
s.GenerateReport(pst);
EXPECT_NEAR(wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
EXPECT_NEAR(s.pst_report().seconds_since_license_received(),
playback_time + 2 * kIdleInSeconds,
kLicenseReceivedTimeTolerance);
EXPECT_NEAR(wvcdm::htonll64(s.pst_report()->seconds_since_first_decrypt),
EXPECT_NEAR(s.pst_report().seconds_since_first_decrypt(),
playback_time + kIdleInSeconds, kUsageTableTimeTolerance);
EXPECT_NEAR(wvcdm::htonll64(s.pst_report()->seconds_since_last_decrypt),
EXPECT_NEAR(s.pst_report().seconds_since_last_decrypt(),
kIdleInSeconds, kUsageTableTimeTolerance);
ASSERT_NO_FATAL_FAILURE(DeactivatePST(pst));
ASSERT_NO_FATAL_FAILURE(s.GenerateReport(pst));
EXPECT_EQ(kInactiveUsed, s.pst_report()->status);
EXPECT_EQ(kInactiveUsed, s.pst_report().status());
ASSERT_NO_FATAL_FAILURE(
s.TestDecryptCTR(false, OEMCrypto_ERROR_UNKNOWN_FAILURE));
}
@@ -5538,9 +5499,8 @@ TEST_F(UsageTableTest, PSTLargeBuffer) {
ASSERT_NO_FATAL_FAILURE(
s.TestDecryptCTR(false, OEMCrypto_ERROR_UNKNOWN_FAILURE));
ASSERT_NO_FATAL_FAILURE(s.GenerateReport(pst));
EXPECT_EQ(kInactiveUsed, s.pst_report()->status);
EXPECT_NEAR(0,
wvcdm::htonll64(s.pst_report()->seconds_since_license_received),
EXPECT_EQ(kInactiveUsed, s.pst_report().status());
EXPECT_NEAR(0, s.pst_report().seconds_since_license_received(),
kTimeTolerance);
ASSERT_NO_FATAL_FAILURE(s.close());
@@ -5561,7 +5521,7 @@ TEST_F(UsageTableTest, PSTLargeBuffer) {
Session s3;
ASSERT_NO_FATAL_FAILURE(s3.open());
ASSERT_NO_FATAL_FAILURE(s3.GenerateReport(pst, true, &s));
EXPECT_EQ(kInactiveUsed, s3.pst_report()->status);
EXPECT_EQ(kInactiveUsed, s3.pst_report().status());
}
TEST_F(UsageTableTest, DeleteEntryLargeBuffer) {
@@ -5583,7 +5543,7 @@ TEST_F(UsageTableTest, DeleteEntryLargeBuffer) {
Session s2;
ASSERT_NO_FATAL_FAILURE(s2.open());
ASSERT_NO_FATAL_FAILURE(s2.GenerateReport(pst, true, &s));
EXPECT_EQ(kActive, s2.pst_report()->status);
EXPECT_EQ(kActive, s2.pst_report().status());
ASSERT_NO_FATAL_FAILURE(s2.DeleteEntry(pst));
ASSERT_NO_FATAL_FAILURE(s2.close());