diff --git a/libwvdrmengine/cdm/core/src/crypto_session.cpp b/libwvdrmengine/cdm/core/src/crypto_session.cpp index f1192259..43fe6828 100644 --- a/libwvdrmengine/cdm/core/src/crypto_session.cpp +++ b/libwvdrmengine/cdm/core/src/crypto_session.cpp @@ -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( - const_cast(usage_report->data())); + std::vector 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(&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; } diff --git a/libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp b/libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp index 41b88aad..43fca619 100644 --- a/libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp +++ b/libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp @@ -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); diff --git a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp index cab083c6..e9888f19 100644 --- a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp +++ b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp @@ -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( + const_cast(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(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) { diff --git a/libwvdrmengine/level3/arm/libwvlevel3.a b/libwvdrmengine/level3/arm/libwvlevel3.a index 1ae71fb8..e2f674da 100644 Binary files a/libwvdrmengine/level3/arm/libwvlevel3.a and b/libwvdrmengine/level3/arm/libwvlevel3.a differ diff --git a/libwvdrmengine/level3/mips/libwvlevel3.a b/libwvdrmengine/level3/mips/libwvlevel3.a index 8588d807..5d27332d 100644 Binary files a/libwvdrmengine/level3/mips/libwvlevel3.a and b/libwvdrmengine/level3/mips/libwvlevel3.a differ diff --git a/libwvdrmengine/level3/x86/libwvlevel3.a b/libwvdrmengine/level3/x86/libwvlevel3.a index e2f816b4..9bb13db8 100644 Binary files a/libwvdrmengine/level3/x86/libwvlevel3.a and b/libwvdrmengine/level3/x86/libwvlevel3.a differ diff --git a/libwvdrmengine/oemcrypto/include/OEMCryptoCENC.h b/libwvdrmengine/oemcrypto/include/OEMCryptoCENC.h index 6795772c..0df48229 100644 --- a/libwvdrmengine/oemcrypto/include/OEMCryptoCENC.h +++ b/libwvdrmengine/oemcrypto/include/OEMCryptoCENC.h @@ -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); /* diff --git a/libwvdrmengine/oemcrypto/include/level3.h b/libwvdrmengine/oemcrypto/include/level3.h index 5e79b8bc..8dc57801 100644 --- a/libwvdrmengine/oemcrypto/include/level3.h +++ b/libwvdrmengine/oemcrypto/include/level3.h @@ -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, diff --git a/libwvdrmengine/oemcrypto/include/pst_report.h b/libwvdrmengine/oemcrypto/include/pst_report.h new file mode 100644 index 00000000..cd21e234 --- /dev/null +++ b/libwvdrmengine/oemcrypto/include/pst_report.h @@ -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 +#include +#include + +#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(* (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(* (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(* (buffer_ + kpst_length_offset)); + } + + void set_pst_length(uint8_t value) { + buffer_[kpst_length_offset] = value; + } + + uint8_t padding() const { + return static_cast(* (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_ diff --git a/libwvdrmengine/oemcrypto/mock/src/oemcrypto_mock.cpp b/libwvdrmengine/oemcrypto/mock/src/oemcrypto_mock.cpp index 048d2327..d4c82d56 100644 --- a/libwvdrmengine/oemcrypto/mock/src/oemcrypto_mock.cpp +++ b/libwvdrmengine/oemcrypto/mock/src/oemcrypto_mock.cpp @@ -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(buffer), - *buffer_length); + dump_hex("usage buffer", buffer, *buffer_length); } } return sts; diff --git a/libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.cpp b/libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.cpp index a33f0cdb..ee27f61b 100644 --- a/libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.cpp +++ b/libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.cpp @@ -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 &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(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(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(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; } diff --git a/libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.h b/libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.h index ba3d0df5..03c0f8e2 100644 --- a/libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.h +++ b/libwvdrmengine/oemcrypto/mock/src/oemcrypto_usage_table_mock.h @@ -55,7 +55,7 @@ class UsageTableEntry { bool UpdateTime(); OEMCryptoResult ReportUsage(SessionContext *session, const std::vector &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 &server, diff --git a/libwvdrmengine/oemcrypto/test/oec_session_util.cpp b/libwvdrmengine/oemcrypto/test/oec_session_util.cpp index 046e51ad..9657c34f 100644 --- a/libwvdrmengine/oemcrypto/test/oec_session_util.cpp +++ b/libwvdrmengine/oemcrypto/test/oec_session_util.cpp @@ -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(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(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 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(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(&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) { diff --git a/libwvdrmengine/oemcrypto/test/oec_session_util.h b/libwvdrmengine/oemcrypto/test/oec_session_util.h index 2b5fc720..285bd64a 100644 --- a/libwvdrmengine/oemcrypto/test/oec_session_util.h +++ b/libwvdrmengine/oemcrypto/test/oec_session_util.h @@ -10,6 +10,7 @@ #include #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); diff --git a/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp b/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp index d7c752f8..68c944c6 100644 --- a/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp +++ b/libwvdrmengine/oemcrypto/test/oemcrypto_test.cpp @@ -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(&report); - EXPECT_EQ(48u, sizeof(report)); - uint8_t* field; - field = reinterpret_cast(&report.status); - EXPECT_EQ(20, field - location); - field = reinterpret_cast(&report.clock_security_level); - EXPECT_EQ(21, field - location); - field = reinterpret_cast(&report.pst_length); - EXPECT_EQ(22, field - location); - field = reinterpret_cast(&report.seconds_since_license_received); - EXPECT_EQ(24, field - location); - field = reinterpret_cast(&report.seconds_since_first_decrypt); - EXPECT_EQ(32, field - location); - field = reinterpret_cast(&report.seconds_since_last_decrypt); - EXPECT_EQ(40, field - location); - field = reinterpret_cast(&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());