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

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);

264
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,22 +4832,18 @@ 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),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_first_decrypt),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_last_decrypt),
kTimeTolerance);
EXPECT_EQ(kActive, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(0, session_.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
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),
kTimeTolerance);
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(
session_.session_id(), &clear_buffer_[0], clear_buffer_.size(), iv_,
@@ -4904,22 +4876,18 @@ 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),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_first_decrypt),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_last_decrypt),
kTimeTolerance);
EXPECT_EQ(kActive, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(0, session_.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
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),
kTimeTolerance);
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(
session_.session_id(), &encrypted[0], encrypted.size(), iv_,
@@ -4961,22 +4929,18 @@ 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),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_first_decrypt),
kTimeTolerance);
EXPECT_NEAR(
0, wvcdm::htonll64(session_.pst_report()->seconds_since_last_decrypt),
kTimeTolerance);
EXPECT_EQ(kActive, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
EXPECT_NEAR(0, session_.pst_report().seconds_since_first_decrypt(),
kTimeTolerance);
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),
kTimeTolerance);
EXPECT_EQ(kInactiveUsed, session_.pst_report().status());
EXPECT_NEAR(0, session_.pst_report().seconds_since_license_received(),
kTimeTolerance);
signature.assign(SHA256_DIGEST_LENGTH, 0);
gen_signature_length = SHA256_DIGEST_LENGTH;
@@ -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());