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

Update repo with latest changes

Browse Source 
This updates the repo to match the internal repo at commit:
521466f84993e273105bd41d930c00cf6d61008f
This commit is contained in:
Jacob Trimble
2021-07-02 11:11:15 -07:00
parent ac8b2f59ea
commit 06a325cfaf
43 changed files with 1752 additions and 1461 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
whitebox/api/aead_whitebox.h
View File

@@ -62,6 +62,9 @@ void WB_Aead_Delete(WB_Aead_Whitebox* whitebox);
// should be at least |input_data_size| + 22 to allow room for the nonce and the
// verification tag.
//
// This must support |input_data| and |output_data| pointing to the same buffer
// (in-place encrypt).
//
// Args:
// whitebox (in) : The white-box containing the keys for encryption.
//
@@ -94,6 +97,9 @@ WB_Result WB_Aead_Encrypt(const WB_Aead_Whitebox* whitebox,
// Decrypts |input_data| and writes the plaintext to |output_data|. |input_data|
// must have been encrypted using WB_Aead_Encrypt() with the same |whitebox|.
//
// This must support |input_data| and |output_data| pointing to the same buffer
// (in-place decrypt).
//
// Args:
// whitebox (in) : The white-box containing the keys for decryption.
//

23
whitebox/api/aead_whitebox_encrypt_test.cc
View File

@@ -59,6 +59,29 @@ TEST_F(AeadWhiteboxEncryptTest, Success) {
ASSERT_GT(output_size, input_.size());
}
// This also validates Decrypt in-place.
TEST_F(AeadWhiteboxEncryptTest, InPlace) {
size_t output_size = kDefaultOutputSize;
std::vector<uint8_t> output(output_size);
// Copy the input to the first part of the output. Then pass the original
// size in input, but the real size as output.
ASSERT_GE(output_size, input_.size());
memcpy(output.data(), input_.data(), input_.size());
ASSERT_EQ(WB_Aead_Encrypt(whitebox_, output.data(), input_.size(),
output.data(), &output_size),
WB_RESULT_OK);
output.resize(output_size);
ASSERT_EQ(WB_Aead_Decrypt(whitebox_, output.data(), output.size(),
output.data(), &output_size),
WB_RESULT_OK);
output.resize(output_size);
ASSERT_EQ(output, input_);
}
TEST_F(AeadWhiteboxEncryptTest, InvalidParameterForNullWhitebox) {
size_t output_size = kDefaultOutputSize;
std::vector<uint8_t> output(output_size);

119
whitebox/api/golden_data.cc
View File

@@ -3,84 +3,87 @@
#include "api/golden_data.h"
namespace widevine {
namespace {
GoldenData::Content CreateContent(const std::vector<uint8_t>& plaintext,
const std::vector<uint8_t>& ciphertext,
const AesIv& iv,
const AesKey& key,
const KeyId& undefined_key_id,
const KeyId& software_crypto_key_id,
const KeyId& software_decode_key_id,
const KeyId& hardware_key_id) {
GoldenData::Content content;
content.plaintext = plaintext;
content.ciphertext = ciphertext;
content.iv = iv;
content.undefined_key.id = undefined_key_id;
content.undefined_key.level = SecurityLevel::kUndefined;
content.undefined_key.key = key;
content.software_crypto_key.id = software_crypto_key_id;
content.software_crypto_key.level = SecurityLevel::kSoftwareSecureCrypto;
content.software_crypto_key.key = key;
content.software_decode_key.id = software_decode_key_id;
content.software_decode_key.level = SecurityLevel::kSoftwareSecureDecode;
content.software_decode_key.key = key;
content.hardware_key.id = hardware_key_id;
content.hardware_key.level = SecurityLevel::kHardwareSecureCrypto;
content.hardware_key.key = key;
return content;
}
} // namespace
GoldenData::GoldenData() {
// Content generated with:
// openssl aes-128-cbc -e -in data.txt
// -K EBDD62F16814D27B68EF122AFCE4AE3C
// -iv 30313233343536373839303132333435 | xxd -i
// Extra padding was stripped off.
cbc_content_ = {
/* plaintext */ {'t', 'h', 'i', 's', ' ', 'i', 's', ' ', 't', 'h', 'e',
' ', 'p', 'l', 'a', 'i', 'n', 't', 'e', 'x', 't', ' ',
':', ' ', '3', '2', ' ', 'b', 'y', 't', 'e', 's'},
/* ciphertext */
{0x5e, 0x60, 0x0d, 0x3c, 0x29, 0xb9, 0x49, 0x4c, 0x65, 0x67, 0x7e,
0x87, 0x82, 0x9d, 0x47, 0x58, 0xb9, 0x86, 0xd0, 0x39, 0x6a, 0x67,
0x2c, 0x53, 0xe9, 0xbc, 0x99, 0x5b, 0x23, 0x34, 0x9f, 0xf8},
/* key */
{0xEB, 0xDD, 0x62, 0xF1, 0x68, 0x14, 0xD2, 0x7B, 0x68, 0xEF, 0x12, 0x2A,
0xFC, 0xE4, 0xAE, 0x3C},
/* iv */
cbc_content_ = CreateContent(
/* plaintext= */ {'t', 'h', 'i', 's', ' ', 'i', 's', ' ', 't', 'h', 'e',
' ', 'p', 'l', 'a', 'i', 'n', 't', 'e', 'x', 't', ' ',
':', ' ', '3', '2', ' ', 'b', 'y', 't', 'e', 's'},
/* ciphertext= */ {0x5e, 0x60, 0x0d, 0x3c, 0x29, 0xb9, 0x49, 0x4c,
0x65, 0x67, 0x7e, 0x87, 0x82, 0x9d, 0x47, 0x58,
0xb9, 0x86, 0xd0, 0x39, 0x6a, 0x67, 0x2c, 0x53,
0xe9, 0xbc, 0x99, 0x5b, 0x23, 0x34, 0x9f, 0xf8},
/* iv= */
{0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30, 0x31,
0x32, 0x33, 0x34, 0x35},
};
cbc_crypto_key_ = {
SecurityLevel::kSoftwareSecureCrypto,
{0xFF, 0, 0, 0},
&cbc_content_,
};
cbc_decode_key_ = {
SecurityLevel::kSoftwareSecureDecode,
{0xFF, 1, 0, 0},
&cbc_content_,
};
cbc_hardware_key_ = {
SecurityLevel::kHardwareSecureCrypto,
{0xFF, 2, 0, 0},
&cbc_content_,
};
/* key= */
{0xEB, 0xDD, 0x62, 0xF1, 0x68, 0x14, 0xD2, 0x7B, 0x68, 0xEF, 0x12, 0x2A,
0xFC, 0xE4, 0xAE, 0x3C},
/* undefined_key_id= */ {0xFF, 0, 0, 0},
/* software_crypto_key_id= */ {0xFF, 1, 0, 0},
/* software_decode_key_id= */ {0xFF, 2, 0, 0},
/* hardware_key_id= */ {0xFF, 3, 0, 0});
// Content generated with:
// openssl aes-128-ctr -e -in data.txt
// -K dd3c6cd4ea73b99d55f2e0357e1f560f
// -iv d50c08b31fc09e9e748431ca972334e6 | xxd -i
ctr_content_ = {
ctr_content_ = CreateContent(
/* plaintext */ {'T', 'h', 'i', 'r', 't', 'y', '-', 't', 'w', 'o', ' ',
'b', 'y', 't', 'e', 's', ' ', 'o', 'f', ' ', 'r', 'a',
'n', 'd', 'o', 'm', ' ', 'd', 'a', 't', 'a', '.'},
/* ciphertext */
{0x5d, 0x83, 0xdd, 0xb9, 0xed, 0x18, 0x2f, 0x10, 0xbf, 0x6f, 0x4d,
0xb0, 0xb3, 0xeb, 0x0d, 0x20, 0xd7, 0x7e, 0x9a, 0x3a, 0xc4, 0x41,
0xcf, 0x0a, 0xb3, 0xae, 0x02, 0x01, 0x0a, 0xf2, 0x72, 0x72},
/* key */
{0xdd, 0x3c, 0x6c, 0xd4, 0xea, 0x73, 0xb9, 0x9d, 0x55, 0xf2, 0xe0, 0x35,
0x7e, 0x1f, 0x56, 0x0f},
/* ciphertext */ {0x5d, 0x83, 0xdd, 0xb9, 0xed, 0x18, 0x2f, 0x10,
0xbf, 0x6f, 0x4d, 0xb0, 0xb3, 0xeb, 0x0d, 0x20,
0xd7, 0x7e, 0x9a, 0x3a, 0xc4, 0x41, 0xcf, 0x0a,
0xb3, 0xae, 0x02, 0x01, 0x0a, 0xf2, 0x72, 0x72},
/* iv */
{0xd5, 0x0c, 0x08, 0xb3, 0x1f, 0xc0, 0x9e, 0x9e, 0x74, 0x84, 0x31, 0xca,
0x97, 0x23, 0x34, 0xe6},
};
ctr_crypto_key_ = {
SecurityLevel::kSoftwareSecureCrypto,
{0xFF, 3, 0, 0},
&ctr_content_,
};
ctr_decode_key_ = {
SecurityLevel::kSoftwareSecureDecode,
{0xFF, 4, 0, 0},
&ctr_content_,
};
ctr_hardware_key_ = {
SecurityLevel::kHardwareSecureCrypto,
{0xFF, 5, 0, 0},
&ctr_content_,
};
/* key */
{0xdd, 0x3c, 0x6c, 0xd4, 0xea, 0x73, 0xb9, 0x9d, 0x55, 0xf2, 0xe0, 0x35,
0x7e, 0x1f, 0x56, 0x0f},
/* undefined_key_id= */ {0xFF, 4, 0, 0},
/* software_crypto_key_id= */ {0xFF, 5, 0, 0},
/* software_decode_key_id= */ {0xFF, 6, 0, 0},
/* hardware_key_id= */ {0xFF, 7, 0, 0});
}
KeyId GoldenData::GetFreeId() {

32
whitebox/api/golden_data.h
View File

@@ -8,7 +8,7 @@
#include <vector>
#include "api/test_key_types.h"
#include "cdm/protos/license_protocol.pb.h"
#include "license_protocol.pb.h"
namespace widevine {
@@ -17,40 +17,30 @@ class GoldenData {
struct Content {
std::vector<uint8_t> plaintext;
std::vector<uint8_t> ciphertext;
AesKey key;
AesIv iv;
};
struct Key {
SecurityLevel level;
KeyId id;
const Content* content;
// IV used to encrypt the plaintext.
AesIv iv;
// All the keys available to decrypt the ciphertext and get the plaintext.
// Every key here should have the same AES key, but the security level and
// ids will be different.
ContentKeyData undefined_key;
ContentKeyData software_crypto_key;
ContentKeyData software_decode_key;
ContentKeyData hardware_key;
};
GoldenData();
const Content& CBCContent() const { return cbc_content_; }
const Key& CBCCryptoKey() const { return cbc_crypto_key_; }
const Key& CBCDecodeKey() const { return cbc_decode_key_; }
const Key& CBCHardwareKey() const { return cbc_hardware_key_; }
const Content& CTRContent() const { return ctr_content_; }
const Key& CTRCryptoKey() const { return ctr_crypto_key_; }
const Key& CTRDecodeKey() const { return ctr_decode_key_; }
const Key& CTRHardwareKey() const { return ctr_hardware_key_; }
KeyId GetFreeId();
private:
Content cbc_content_;
Key cbc_crypto_key_;
Key cbc_decode_key_;
Key cbc_hardware_key_;
Content ctr_content_;
Key ctr_crypto_key_;
Key ctr_decode_key_;
Key ctr_hardware_key_;
uint8_t next_id_ = 0;
};

18
whitebox/api/license_whitebox.h
View File

@@ -90,7 +90,9 @@ void WB_License_Delete(WB_License_Whitebox* whitebox);
//
// license_request_size (in) : The number of bytes in the license_request.
//
// signature (out) : The generated signature for |license_request|.
// signature (out) : The generated signature for |license_request|. This can be
// null if |*signature_size| is 0; this should return
// WB_RESULT_BUFFER_TOO_SMALL and fill |signature_size|.
//
// signature_size (in/out) : As input, this contains the max number of bytes
// that can be written to |signature|. As output, |signature_size| is set to
@@ -245,7 +247,9 @@ WB_Result WB_License_QueryKeyStatus(const WB_License_Whitebox* whitebox,
//
// message_size (in) : The number of bytes in |message|.
//
// signature (out) : The output parameter used to return the signature.
// signature (out) : The output parameter used to return the signature. This
// can be null if |*signature_size| is 0; this should return
// WB_RESULT_BUFFER_TOO_SMALL and fill |signature_size|.
//
// signature_size (in/out) : As input, this contains the max number of bytes
// that can be written to |signature|. As output, |signature_size| is set to
@@ -315,7 +319,9 @@ WB_Result WB_License_VerifyRenewalResponse(const WB_License_Whitebox* whitebox,
// key_id_size (in) : The number of bytes in |key_id|.
//
// secret_string (out) : The output parameter used to return the secret string
// that can be passed to WB_License_Unmask().
// that can be passed to WB_License_Unmask(). This can be null if
// |*secret_string_size| is 0; this should return WB_RESULT_BUFFER_TOO_SMALL
// and fill |secret_string_size|.
//
// secret_string_size (in/out) : As input, this contains the max number of
// bytes that can be written to |secret_string|. As output,
@@ -349,6 +355,9 @@ WB_Result WB_License_GetSecretString(const WB_License_Whitebox* whitebox,
// Decrypts |input_data| and writes the plaintext to |output_data|.
//
// This must support |input_data| and |output_data| pointing to the same buffer
// (in-place decrypt).
//
// Args:
// whitebox (in) : The white-box containing the keys needed to decrypt
// |input_data|.
@@ -410,6 +419,9 @@ WB_Result WB_License_Decrypt(const WB_License_Whitebox* whitebox,
// |masked_output_data|. The obfuscated plaintext can be deobfuscated using
// WB_License_GetSecretString() and WB_License_Unmask().
//
// This must support |input_data| and |output_data| pointing to the same buffer
// (in-place decrypt).
//
// Args:
// whitebox (in) : The white-box containing the keys needed to decrypt
// |input_data|.

30
whitebox/api/license_whitebox_benchmark.cc
View File

@@ -21,8 +21,12 @@ constexpr size_t kBlockSize = 16; // This must align with the AES block size.
} // namespace
void LicenseWhiteboxBenchmark::SetUp() {
key_id_ = data_source_.Get<4>(); // We use size=4 for all our test key ids.
key_ = data_source_.Get<kBlockSize>();
// We use size=4 for all our test key ids.
key_data_.id = data_source_.Get<4>();
key_data_.key = data_source_.Get<kBlockSize>();
// Use secure crypto as it will work with both Decrypt() and MaskedDecrypt().
key_data_.level = SecurityLevel::kSoftwareSecureCrypto;
iv_ = data_source_.Get<kBlockSize>();
const auto public_key_data = GetEncryptionKey().public_key;
@@ -31,14 +35,24 @@ void LicenseWhiteboxBenchmark::SetUp() {
ASSERT_TRUE(encryption_public_key_);
}
License LicenseWhiteboxBenchmark::CreateLicense(
WB_LicenseKeyMode key_mode) const {
License LicenseWhiteboxBenchmark::CreateLicense(WB_LicenseKeyMode key_mode,
int number_of_content_keys,
SecurityLevel security_level) {
TestLicenseBuilder license_builder;
license_builder.AddSigningKey(TestLicenseBuilder::DefaultSigningKey());
// Use secure crypto as it will work with both Decrypt() and
// MaskedDecrypt().
license_builder.AddContentKey(SecurityLevel::kSoftwareSecureCrypto, key_id_,
key_);
// Update the first key to match the security level.
key_data_.level = security_level;
license_builder.AddContentKey(key_data_);
CHECK_GE(number_of_content_keys, 1);
for (int i = 1; i < number_of_content_keys; ++i) {
ContentKeyData key;
key.id = data_source_.Get<4>();
key.key = data_source_.Get<kBlockSize>();
key.level = security_level;
license_builder.AddContentKey(key);
}
std::unique_ptr<TestServer> server;

21
whitebox/api/license_whitebox_benchmark.h
View File

@@ -20,19 +20,22 @@ class LicenseWhiteboxBenchmark : public ::testing::Test {
protected:
virtual void SetUp() override;
// Create a new license. The given key mode will change how the license is
// encrypted and signed. The white-box instance is expected to use the correct
// key mode in order to process the license response.
License CreateLicense(WB_LicenseKeyMode key_mode) const;
// Create a new license with the specified number of content keys using the
// security_level provided. The first content key will use
// kSoftwareSecureCrypto, while the remainder will be specified by
// |security_level|. The given key mode will change how the license is
// encrypted and signed. The white-box instance is expected to use the
// correct key mode in order to process the license response.
License CreateLicense(WB_LicenseKeyMode key_mode,
int number_of_content_keys,
SecurityLevel security_level);
// Sign the message using the default HMAC signing key.
std::vector<uint8_t> SignAsServer(const std::vector<uint8_t>& message) const;
DataSource& Data() { return data_source_; }
const KeyId& ContentKeyId() const { return key_id_; }
const AesKey& ContentKey() const { return key_; }
const ContentKeyData& ContentKey() const { return key_data_; }
const AesIv& ContentIV() const { return iv_; }
@@ -40,8 +43,8 @@ class LicenseWhiteboxBenchmark : public ::testing::Test {
DataSource data_source_;
std::unique_ptr<RsaPublicKey> encryption_public_key_;
KeyId key_id_;
AesKey key_;
ContentKeyData key_data_;
AesIv iv_;
};

31
whitebox/api/license_whitebox_decrypt_benchmark.cc
View File

@@ -45,7 +45,8 @@ class LicenseWhiteboxDecryptBenchmark
ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK);
const auto license = CreateLicense(WB_LICENSE_KEY_MODE_DUAL_KEY);
const auto license = CreateLicense(WB_LICENSE_KEY_MODE_DUAL_KEY, 1,
SecurityLevel::kSoftwareSecureCrypto);
ASSERT_EQ(WB_License_ProcessLicenseResponse(
whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY,
license.core_message.data(), license.core_message.size(),
@@ -75,7 +76,7 @@ TEST_P(LicenseWhiteboxDecryptBenchmark, DecryptCBCThroughput) {
size_t plaintext_size = plaintext_.size();
ASSERT_EQ(WB_RESULT_OK,
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
ContentKeyId().data(), ContentKeyId().size(),
ContentKey().id.data(), ContentKey().id.size(),
ciphertext_.data(), ciphertext_.size(),
ContentIV().data(), ContentIV().size(),
plaintext_.data(), &plaintext_size));
@@ -93,7 +94,7 @@ TEST_P(LicenseWhiteboxDecryptBenchmark, DecryptCTRThroughput) {
size_t plaintext_size = plaintext_.size();
ASSERT_EQ(WB_RESULT_OK,
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CTR,
ContentKeyId().data(), ContentKeyId().size(),
ContentKey().id.data(), ContentKey().id.size(),
ciphertext_.data(), ciphertext_.size(),
ContentIV().data(), ContentIV().size(),
plaintext_.data(), &plaintext_size));
@@ -108,8 +109,8 @@ TEST_P(LicenseWhiteboxDecryptBenchmark, MaskedDecryptCBCThroughput) {
size_t mask_size = mask.size();
ASSERT_EQ(WB_RESULT_OK,
WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC, ContentKeyId().data(),
ContentKeyId().size(), mask.data(), &mask_size));
whitebox_, WB_CIPHER_MODE_CBC, ContentKey().id.data(),
ContentKey().id.size(), mask.data(), &mask_size));
mask.resize(mask_size);
Timer timer;
@@ -121,10 +122,10 @@ TEST_P(LicenseWhiteboxDecryptBenchmark, MaskedDecryptCBCThroughput) {
size_t plaintext_size = plaintext_.size();
ASSERT_EQ(WB_RESULT_OK,
WB_License_MaskedDecrypt(
whitebox_, WB_CIPHER_MODE_CBC, ContentKeyId().data(),
ContentKeyId().size(), ciphertext_.data(), ciphertext_.size(),
ContentIV().data(), ContentIV().size(), masked_text_.data(),
&plaintext_size));
whitebox_, WB_CIPHER_MODE_CBC, ContentKey().id.data(),
ContentKey().id.size(), ciphertext_.data(),
ciphertext_.size(), ContentIV().data(), ContentIV().size(),
masked_text_.data(), &plaintext_size));
WB_License_Unmask(masked_text_.data(), 0, plaintext_size, mask.data(),
mask.size(), plaintext_.data());
@@ -140,8 +141,8 @@ TEST_P(LicenseWhiteboxDecryptBenchmark, MaskedDecryptCTRThroughput) {
size_t mask_size = mask.size();
ASSERT_EQ(WB_RESULT_OK,
WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CTR, ContentKeyId().data(),
ContentKeyId().size(), mask.data(), &mask_size));
whitebox_, WB_CIPHER_MODE_CTR, ContentKey().id.data(),
ContentKey().id.size(), mask.data(), &mask_size));
mask.resize(mask_size);
Timer timer;
@@ -153,10 +154,10 @@ TEST_P(LicenseWhiteboxDecryptBenchmark, MaskedDecryptCTRThroughput) {
size_t plaintext_size = plaintext_.size();
ASSERT_EQ(WB_RESULT_OK,
WB_License_MaskedDecrypt(
whitebox_, WB_CIPHER_MODE_CTR, ContentKeyId().data(),
ContentKeyId().size(), ciphertext_.data(), ciphertext_.size(),
ContentIV().data(), ContentIV().size(), masked_text_.data(),
&plaintext_size));
whitebox_, WB_CIPHER_MODE_CTR, ContentKey().id.data(),
ContentKey().id.size(), ciphertext_.data(),
ciphertext_.size(), ContentIV().data(), ContentIV().size(),
masked_text_.data(), &plaintext_size));
WB_License_Unmask(masked_text_.data(), 0, plaintext_size, mask.data(),
mask.size(), plaintext_.data());

515
whitebox/api/license_whitebox_decrypt_test.cc
View File

@@ -42,21 +42,11 @@ class LicenseWhiteboxDecryptTest : public LicenseWhiteboxTestBase,
builder.SetSettings(settings);
builder.GetSettings().padding = padding_;
builder.AddContentKey(golden_data_.CBCCryptoKey().level,
golden_data_.CBCCryptoKey().id,
golden_data_.CBCCryptoKey().content->key);
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
builder.AddContentKey(golden_data_.CBCContent().software_decode_key);
builder.AddContentKey(golden_data_.CBCContent().hardware_key);
builder.AddContentKey(golden_data_.CTRCryptoKey().level,
golden_data_.CTRCryptoKey().id,
golden_data_.CTRCryptoKey().content->key);
builder.AddContentKey(golden_data_.CBCDecodeKey().level,
golden_data_.CBCDecodeKey().id,
golden_data_.CBCDecodeKey().content->key);
builder.AddContentKey(golden_data_.CBCHardwareKey().level,
golden_data_.CBCHardwareKey().id,
golden_data_.CBCHardwareKey().content->key);
builder.AddContentKey(golden_data_.CTRContent().software_crypto_key);
builder.AddOperatorSessionKey(non_content_key_id_);
@@ -91,36 +81,76 @@ TEST_P(LicenseWhiteboxDecryptTest, CryptoKeyWithCbcDataInCbcMode) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
plaintext_.resize(plaintext_size_);
ASSERT_EQ(plaintext_, golden_data_.CBCCryptoKey().content->plaintext);
ASSERT_EQ(plaintext_, golden_data_.CBCContent().plaintext);
}
TEST_P(LicenseWhiteboxDecryptTest, InPlaceDecryptionCbc) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
memcpy(plaintext_.data(), golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size());
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
plaintext_.data(), plaintext_.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
plaintext_.resize(plaintext_size_);
ASSERT_EQ(plaintext_, golden_data_.CBCContent().plaintext);
}
TEST_P(LicenseWhiteboxDecryptTest, CryptoKeyWithCtrDataInCtrMode) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CTRCryptoKey().id.data(),
golden_data_.CTRCryptoKey().id.size(),
golden_data_.CTRCryptoKey().content->ciphertext.data(),
golden_data_.CTRCryptoKey().content->ciphertext.size(),
golden_data_.CTRCryptoKey().content->iv.data(),
golden_data_.CTRCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CTRContent().software_crypto_key.id.data(),
golden_data_.CTRContent().software_crypto_key.id.size(),
golden_data_.CTRContent().ciphertext.data(),
golden_data_.CTRContent().ciphertext.size(),
golden_data_.CTRContent().iv.data(),
golden_data_.CTRContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
plaintext_.resize(plaintext_size_);
ASSERT_EQ(plaintext_, golden_data_.CTRCryptoKey().content->plaintext);
ASSERT_EQ(plaintext_, golden_data_.CTRContent().plaintext);
}
TEST_P(LicenseWhiteboxDecryptTest, InPlaceDecryptionCtr) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
memcpy(plaintext_.data(), golden_data_.CTRContent().ciphertext.data(),
golden_data_.CTRContent().ciphertext.size());
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CTRContent().software_crypto_key.id.data(),
golden_data_.CTRContent().software_crypto_key.id.size(),
plaintext_.data(), plaintext_.size(),
golden_data_.CTRContent().iv.data(),
golden_data_.CTRContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
plaintext_.resize(plaintext_size_);
ASSERT_EQ(plaintext_, golden_data_.CTRContent().plaintext);
}
// We try to decrypt CBC encrypted data in CTR mode. All operations should be
@@ -129,18 +159,18 @@ TEST_P(LicenseWhiteboxDecryptTest, CryptoKeyWithCbcDataInCtrMode) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
plaintext_.resize(plaintext_size_);
ASSERT_NE(plaintext_, golden_data_.CBCCryptoKey().content->plaintext);
ASSERT_NE(plaintext_, golden_data_.CBCContent().plaintext);
}
// We try to decrypt CTR encrypted data in CBC mode. All operations should be
@@ -149,18 +179,18 @@ TEST_P(LicenseWhiteboxDecryptTest, CryptoKeyWithCtrDataInCbcMode) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CTRCryptoKey().id.data(),
golden_data_.CTRCryptoKey().id.size(),
golden_data_.CTRCryptoKey().content->ciphertext.data(),
golden_data_.CTRCryptoKey().content->ciphertext.size(),
golden_data_.CTRCryptoKey().content->iv.data(),
golden_data_.CTRCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CTRContent().software_crypto_key.id.data(),
golden_data_.CTRContent().software_crypto_key.id.size(),
golden_data_.CTRContent().ciphertext.data(),
golden_data_.CTRContent().ciphertext.size(),
golden_data_.CTRContent().iv.data(),
golden_data_.CTRContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
plaintext_.resize(plaintext_size_);
ASSERT_NE(plaintext_, golden_data_.CTRCryptoKey().content->plaintext);
ASSERT_NE(plaintext_, golden_data_.CTRContent().plaintext);
}
// Try decrypting two different sets of content to make sure that two
@@ -169,53 +199,53 @@ TEST_P(LicenseWhiteboxDecryptTest, SuccessWithMultipleKeys) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
plaintext_.resize(plaintext_size_);
ASSERT_EQ(plaintext_, golden_data_.CBCCryptoKey().content->plaintext);
ASSERT_EQ(plaintext_, golden_data_.CBCContent().plaintext);
// Reset our output buffer.
plaintext_.clear();
plaintext_size_ = golden_data_.CTRDecodeKey().content->plaintext.size();
plaintext_size_ = golden_data_.CTRContent().plaintext.size();
plaintext_.resize(plaintext_size_);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CTRCryptoKey().id.data(),
golden_data_.CTRCryptoKey().id.size(),
golden_data_.CTRCryptoKey().content->ciphertext.data(),
golden_data_.CTRCryptoKey().content->ciphertext.size(),
golden_data_.CTRCryptoKey().content->iv.data(),
golden_data_.CTRCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CTRContent().software_crypto_key.id.data(),
golden_data_.CTRContent().software_crypto_key.id.size(),
golden_data_.CTRContent().ciphertext.data(),
golden_data_.CTRContent().ciphertext.size(),
golden_data_.CTRContent().iv.data(),
golden_data_.CTRContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
plaintext_.resize(plaintext_size_);
ASSERT_EQ(plaintext_, golden_data_.CTRCryptoKey().content->plaintext);
ASSERT_EQ(plaintext_, golden_data_.CTRContent().plaintext);
}
TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForNullWhitebox) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(nullptr, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_Decrypt(
nullptr, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForInvalidCipherMode) {
@@ -228,13 +258,14 @@ TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForInvalidCipherMode) {
const WB_CipherMode invalid_mode = static_cast<WB_CipherMode>(0xFF);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, invalid_mode, golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
whitebox_, invalid_mode,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
@@ -242,45 +273,45 @@ TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForNullKeyId) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC, nullptr,
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC, nullptr,
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForZeroKeyIdSize) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(), 0,
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(), 0,
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForNullInputData) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(), nullptr,
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
nullptr, golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
// AES CBC requires that the input be block aligned (multiple of 16). CTR does
@@ -289,15 +320,15 @@ TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForInvalidCBCInputDataSize) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
14, golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(), 14,
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
// The white-box (using any cipher mode) should reject input with size zero.
@@ -305,30 +336,30 @@ TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForZeroInputDataSize) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
0, golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(), 0,
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForNullIV) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC, golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(), nullptr,
golden_data_.CBCCryptoKey().content->iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(), nullptr,
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
// IV size should be 16. Any number other than 16 should fail.
@@ -336,31 +367,30 @@ TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForInvalidIVSize) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(), 9,
plaintext_.data(), &plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(), 9, plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForNullOutput) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
nullptr, &plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), nullptr, &plaintext_size_),
WB_RESULT_INVALID_PARAMETER);
}
TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForNullOutputSize) {
@@ -368,14 +398,14 @@ TEST_P(LicenseWhiteboxDecryptTest, InvalidParameterForNullOutputSize) {
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), nullptr),
WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(), nullptr),
WB_RESULT_INVALID_PARAMETER);
}
@@ -386,15 +416,14 @@ TEST_P(LicenseWhiteboxDecryptTest, KeyUnavailableForMissingKeyId) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC, missing_key_id_.data(),
missing_key_id_.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_KEY_UNAVAILABLE);
ASSERT_EQ(WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
missing_key_id_.data(), missing_key_id_.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_KEY_UNAVAILABLE);
}
TEST_P(LicenseWhiteboxDecryptTest, KeyUnavailableForNonContentKey) {
@@ -404,11 +433,11 @@ TEST_P(LicenseWhiteboxDecryptTest, KeyUnavailableForNonContentKey) {
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
non_content_key_id_.data(), non_content_key_id_.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_KEY_UNAVAILABLE);
}
@@ -419,15 +448,14 @@ TEST_P(LicenseWhiteboxDecryptTest,
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCHardwareKey().id.data(),
golden_data_.CBCHardwareKey().id.size(),
golden_data_.CBCHardwareKey().content->ciphertext.data(),
golden_data_.CBCHardwareKey().content->ciphertext.size(),
golden_data_.CBCHardwareKey().content->iv.data(),
golden_data_.CBCHardwareKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
ASSERT_EQ(WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().hardware_key.id.data(),
golden_data_.CBCContent().hardware_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_INSUFFICIENT_SECURITY_LEVEL);
}
@@ -437,16 +465,16 @@ TEST_P(LicenseWhiteboxDecryptTest, InsufficientSecurityLevelForDecodeKey) {
// Use the software decode key as they are limited to
// WB_License_Decrypt().
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCDecodeKey().id.data(),
golden_data_.CBCDecodeKey().id.size(),
golden_data_.CBCDecodeKey().content->ciphertext.data(),
golden_data_.CBCDecodeKey().content->ciphertext.size(),
golden_data_.CBCDecodeKey().content->iv.data(),
golden_data_.CBCDecodeKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_INSUFFICIENT_SECURITY_LEVEL);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_decode_key.id.data(),
golden_data_.CBCContent().software_decode_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INSUFFICIENT_SECURITY_LEVEL);
}
TEST_P(LicenseWhiteboxDecryptTest, BufferTooSmall) {
@@ -457,21 +485,20 @@ TEST_P(LicenseWhiteboxDecryptTest, BufferTooSmall) {
// using a constant here.
plaintext_size_ = 8;
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_BUFFER_TOO_SMALL);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_BUFFER_TOO_SMALL);
// We don't use padding so the reported plaintext size should be the same as
// the cipher text size.
ASSERT_EQ(plaintext_size_,
golden_data_.CBCCryptoKey().content->ciphertext.size());
ASSERT_EQ(plaintext_size_, golden_data_.CBCContent().ciphertext.size());
}
TEST_P(LicenseWhiteboxDecryptTest, InvalidState) {
@@ -479,16 +506,16 @@ TEST_P(LicenseWhiteboxDecryptTest, InvalidState) {
// WB_RESULT_INVALID_STATE is that no key can be found and keys are provided
// via a license.
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_INVALID_STATE);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_INVALID_STATE);
}
TEST_P(LicenseWhiteboxDecryptTest, KeyUnavailableForInvalidKey) {
@@ -499,16 +526,16 @@ TEST_P(LicenseWhiteboxDecryptTest, KeyUnavailableForInvalidKey) {
settings.include_content_key_iv = false;
LoadLicense(settings);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_KEY_UNAVAILABLE);
ASSERT_EQ(WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
golden_data_.CBCContent().ciphertext.data(),
golden_data_.CBCContent().ciphertext.size(),
golden_data_.CBCContent().iv.data(),
golden_data_.CBCContent().iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_KEY_UNAVAILABLE);
}
INSTANTIATE_TEST_SUITE_P(NoPadding,

182
whitebox/api/license_whitebox_get_secret_string_test.cc
View File

@@ -31,17 +31,12 @@ class LicenseWhiteboxGetSecretStringTest : public LicenseWhiteboxTestBase {
TestLicenseBuilder builder;
builder.SetSettings(settings);
builder.AddContentKey(golden_data_.CBCCryptoKey().level,
golden_data_.CBCCryptoKey().id,
golden_data_.CBCCryptoKey().content->key);
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
builder.AddContentKey(golden_data_.CBCContent().software_decode_key);
builder.AddContentKey(golden_data_.CBCContent().hardware_key);
builder.AddContentKey(golden_data_.CBCDecodeKey().level,
golden_data_.CBCDecodeKey().id,
golden_data_.CBCDecodeKey().content->key);
builder.AddContentKey(golden_data_.CBCHardwareKey().level,
golden_data_.CBCHardwareKey().id,
golden_data_.CBCHardwareKey().content->key);
builder.AddContentKey(golden_data_.CTRContent().software_crypto_key);
builder.AddContentKey(golden_data_.CTRContent().software_decode_key);
builder.AddOperatorSessionKey(non_content_key_id_);
@@ -73,12 +68,12 @@ TEST_F(LicenseWhiteboxGetSecretStringTest, SuccessForCBCWithCryptoKey) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_OK);
ASSERT_GT(secret_string_size_, 0u);
}
@@ -86,12 +81,12 @@ TEST_F(LicenseWhiteboxGetSecretStringTest, SuccessForCTRWithCryptoKey) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CTRContent().software_crypto_key.id.data(),
golden_data_.CTRContent().software_crypto_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_OK);
ASSERT_GT(secret_string_size_, 0u);
}
@@ -99,12 +94,12 @@ TEST_F(LicenseWhiteboxGetSecretStringTest, SuccessForCBCWithDecodeKey) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCDecodeKey().id.data(),
golden_data_.CBCDecodeKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_decode_key.id.data(),
golden_data_.CBCContent().software_decode_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_OK);
ASSERT_GT(secret_string_size_, 0u);
}
@@ -112,12 +107,12 @@ TEST_F(LicenseWhiteboxGetSecretStringTest, SuccessForCTRWithDecodeKey) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CBCDecodeKey().id.data(),
golden_data_.CBCDecodeKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_OK);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CTR,
golden_data_.CTRContent().software_decode_key.id.data(),
golden_data_.CTRContent().software_decode_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_OK);
ASSERT_GT(secret_string_size_, 0u);
}
@@ -125,12 +120,12 @@ TEST_F(LicenseWhiteboxGetSecretStringTest, InvalidParameterForNullWhitebox) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_GetSecretString(nullptr, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_GetSecretString(
nullptr, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_INVALID_PARAMETER);
}
TEST_F(LicenseWhiteboxGetSecretStringTest,
@@ -144,9 +139,10 @@ TEST_F(LicenseWhiteboxGetSecretStringTest,
const WB_CipherMode invalid_mode = static_cast<WB_CipherMode>(0xFF);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, invalid_mode, golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(), secret_string_.data(),
&secret_string_size_),
whitebox_, invalid_mode,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_INVALID_PARAMETER);
}
@@ -154,22 +150,36 @@ TEST_F(LicenseWhiteboxGetSecretStringTest, InvalidParameterForNullKeyId) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC, nullptr,
golden_data_.CBCCryptoKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC, nullptr,
golden_data_.CBCContent().software_crypto_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_INVALID_PARAMETER);
}
TEST_F(LicenseWhiteboxGetSecretStringTest, InvalidParameterForZeroKeyIdSize) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(), 0,
secret_string_.data(), &secret_string_size_),
WB_RESULT_INVALID_PARAMETER);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(), 0,
secret_string_.data(), &secret_string_size_),
WB_RESULT_INVALID_PARAMETER);
}
TEST_F(LicenseWhiteboxGetSecretStringTest, CanProbeSizeWithNullString) {
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
secret_string_size_ = 0;
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
nullptr, &secret_string_size_),
WB_RESULT_BUFFER_TOO_SMALL);
ASSERT_GT(secret_string_size_, 0);
}
TEST_F(LicenseWhiteboxGetSecretStringTest,
@@ -177,10 +187,11 @@ TEST_F(LicenseWhiteboxGetSecretStringTest,
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
nullptr, &secret_string_size_),
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
nullptr, &secret_string_size_),
WB_RESULT_INVALID_PARAMETER);
}
@@ -189,10 +200,11 @@ TEST_F(LicenseWhiteboxGetSecretStringTest,
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
secret_string_.data(), nullptr),
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
secret_string_.data(), nullptr),
WB_RESULT_INVALID_PARAMETER);
}
@@ -228,12 +240,12 @@ TEST_F(LicenseWhiteboxGetSecretStringTest,
TestLicenseBuilder::Settings settings;
LoadLicense(settings);
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCHardwareKey().id.data(),
golden_data_.CBCHardwareKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_INSUFFICIENT_SECURITY_LEVEL);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().hardware_key.id.data(),
golden_data_.CBCContent().hardware_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_INSUFFICIENT_SECURITY_LEVEL);
}
TEST_F(LicenseWhiteboxGetSecretStringTest, BufferTooSmall) {
@@ -245,12 +257,12 @@ TEST_F(LicenseWhiteboxGetSecretStringTest, BufferTooSmall) {
// as it would not introduce enough variation to be effective. We avoid using
// zero here so that we can verify that we are not just checking for zero.
secret_string_size_ = 1;
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_BUFFER_TOO_SMALL);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_BUFFER_TOO_SMALL);
// Make sure that the output included the required size. We don't know what
// it is, so we rely on checking that it is just bigger than the "too small"
@@ -262,12 +274,12 @@ TEST_F(LicenseWhiteboxGetSecretStringTest, InvalidState) {
// Purposely do not load a license so that we won't have any keys, causing
// use to be in an invalid state.
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_INVALID_STATE);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_INVALID_STATE);
}
TEST_F(LicenseWhiteboxGetSecretStringTest, KeyUnavailableForInvalidKey) {
@@ -278,12 +290,12 @@ TEST_F(LicenseWhiteboxGetSecretStringTest, KeyUnavailableForInvalidKey) {
settings.include_content_key_iv = false;
LoadLicense(settings);
ASSERT_EQ(
WB_License_GetSecretString(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_KEY_UNAVAILABLE);
ASSERT_EQ(WB_License_GetSecretString(
whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCContent().software_crypto_key.id.data(),
golden_data_.CBCContent().software_crypto_key.id.size(),
secret_string_.data(), &secret_string_size_),
WB_RESULT_KEY_UNAVAILABLE);
}
} // namespace widevine

47
whitebox/api/license_whitebox_key_control_block_test.cc
View File

@@ -21,11 +21,6 @@ class LicenseWhiteboxKeyControlBlockTest
server_ = TestServer::CreateDualKey();
}
void AddKeyToLicense(const GoldenData::Key& key,
TestLicenseBuilder* license) {
license->AddContentKey(key.level, key.id, key.content->key);
}
TestLicenseBuilder::KeyControlBlock kcb_;
TestLicenseBuilder::OdkVersion odk_;
@@ -41,9 +36,10 @@ TEST_P(LicenseWhiteboxKeyControlBlockTest, Decrypt) {
builder.GetSettings().key_control_block = kcb_;
builder.GetSettings().odk_version = odk_;
const auto& cbc_test_data = golden_data_.CBCCryptoKey();
const auto& content = golden_data_.CBCContent();
const auto& key = content.software_crypto_key;
AddKeyToLicense(cbc_test_data, &builder);
builder.AddContentKey(key);
License license;
builder.Build(*server_, &license);
@@ -57,18 +53,16 @@ TEST_P(LicenseWhiteboxKeyControlBlockTest, Decrypt) {
license.request.data(), license.request.size()),
WB_RESULT_OK);
std::vector<uint8_t> plaintext(cbc_test_data.content->ciphertext.size());
std::vector<uint8_t> plaintext(content.ciphertext.size());
size_t plaintext_size = plaintext.size();
// Make sure we can actually decrypt some data.
ASSERT_EQ(WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
cbc_test_data.id.data(), cbc_test_data.id.size(),
cbc_test_data.content->ciphertext.data(),
cbc_test_data.content->ciphertext.size(),
cbc_test_data.content->iv.data(),
cbc_test_data.content->iv.size(),
plaintext.data(), &plaintext_size),
WB_RESULT_OK);
ASSERT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC, key.id.data(),
key.id.size(), content.ciphertext.data(),
content.ciphertext.size(), content.iv.data(),
content.iv.size(), plaintext.data(), &plaintext_size),
WB_RESULT_OK);
}
TEST_P(LicenseWhiteboxKeyControlBlockTest, MaskedDecrypt) {
@@ -76,9 +70,10 @@ TEST_P(LicenseWhiteboxKeyControlBlockTest, MaskedDecrypt) {
builder.GetSettings().key_control_block = kcb_;
builder.GetSettings().odk_version = odk_;
const auto& cbc_test_data = golden_data_.CBCDecodeKey();
const auto& content = golden_data_.CBCContent();
const auto& key = content.software_decode_key;
AddKeyToLicense(cbc_test_data, &builder);
builder.AddContentKey(key);
License license;
builder.Build(*server_, &license);
@@ -92,18 +87,16 @@ TEST_P(LicenseWhiteboxKeyControlBlockTest, MaskedDecrypt) {
license.request.data(), license.request.size()),
WB_RESULT_OK);
std::vector<uint8_t> plaintext(cbc_test_data.content->ciphertext.size());
std::vector<uint8_t> plaintext(content.ciphertext.size());
size_t plaintext_size = plaintext.size();
// Make sure we can actually decrypt some data.
ASSERT_EQ(
WB_License_MaskedDecrypt(
whitebox_, WB_CIPHER_MODE_CBC, cbc_test_data.id.data(),
cbc_test_data.id.size(), cbc_test_data.content->ciphertext.data(),
cbc_test_data.content->ciphertext.size(),
cbc_test_data.content->iv.data(), cbc_test_data.content->iv.size(),
plaintext.data(), &plaintext_size),
WB_RESULT_OK);
ASSERT_EQ(WB_License_MaskedDecrypt(
whitebox_, WB_CIPHER_MODE_CBC, key.id.data(), key.id.size(),
content.ciphertext.data(), content.ciphertext.size(),
content.iv.data(), content.iv.size(), plaintext.data(),
&plaintext_size),
WB_RESULT_OK);
}
INSTANTIATE_TEST_SUITE_P(

26
whitebox/api/license_whitebox_license_key_mode.cc
View File

@@ -74,21 +74,19 @@ class LicenseWhiteboxLicenseKeyMode
license.request.size());
}
void Decrypt(const GoldenData::Key& golden_data) {
size_t plaintext_size = golden_data.content->plaintext.size();
void Decrypt(const GoldenData::Content& content, const ContentKeyData& key) {
size_t plaintext_size = content.plaintext.size();
std::vector<uint8_t> plaintext(plaintext_size);
ASSERT_EQ(WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data.id.data(), golden_data.id.size(),
golden_data.content->ciphertext.data(),
golden_data.content->ciphertext.size(),
golden_data.content->iv.data(),
golden_data.content->iv.size(),
plaintext.data(), &plaintext_size),
ASSERT_EQ(WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC, key.id.data(),
key.id.size(), content.ciphertext.data(),
content.ciphertext.size(), content.iv.data(),
content.iv.size(), plaintext.data(),
&plaintext_size),
WB_RESULT_OK);
plaintext.resize(plaintext_size);
ASSERT_EQ(plaintext, golden_data.content->plaintext);
ASSERT_EQ(plaintext, content.plaintext);
}
std::unique_ptr<TestServer> server_;
@@ -117,18 +115,18 @@ TEST_P(LicenseWhiteboxLicenseKeyMode, SignAndProcessLicense) {
SignLicenseRequest(*server);
const auto& golden_data = golden_data_.CBCCryptoKey();
const auto& content = golden_data_.CBCContent();
const auto& key = content.software_crypto_key;
TestLicenseBuilder builder;
builder.AddContentKey(golden_data.level, golden_data.id,
golden_data.content->key);
builder.AddContentKey(key);
License license;
builder.Build(*server, &license);
if (should_pass_) {
ASSERT_EQ(LoadLicense(license, client_mode_), WB_RESULT_OK);
Decrypt(golden_data);
Decrypt(content, key);
} else {
ASSERT_NE(LoadLicense(license, client_mode_), WB_RESULT_OK);
}

901
whitebox/api/license_whitebox_masked_decrypt_test.cc
View File

File diff suppressed because it is too large Load Diff

80
whitebox/api/license_whitebox_process_license_response_benchmark.cc
View File

@@ -2,6 +2,7 @@
#include <stddef.h>
#include <stdint.h>
#include <tuple>
#include "api/license_whitebox.h"
#include "api/license_whitebox_benchmark.h"
@@ -14,19 +15,27 @@ namespace widevine {
namespace {
// The white-box implementation is slow, so the build bots keep timing out. To
// work around this, use a fixed number of iterations.
constexpr size_t kIterations = 100;
constexpr size_t kIterations = 10;
} // namespace
// This test takes 3 parameters. The first (key mode) will change how the
// license is encrypted and signed. The second (int) determines the number of
// content keys in the license. The third (security level) determines the
// security level of the content keys other than the first one (which is
// always kSoftwareSecureCrypto so that it works with both Decrypt() and
// MaskedDecrypt()).
class LicenseWhiteboxProcessLicenseResponseBenchmark
: public LicenseWhiteboxBenchmark,
public testing::WithParamInterface<WB_LicenseKeyMode> {
public ::testing::WithParamInterface<
std::tuple<WB_LicenseKeyMode, int, SecurityLevel>> {
protected:
void SetUp() override {
LicenseWhiteboxBenchmark::SetUp();
key_mode_ = GetParam();
key_mode_ = ::testing::get<0>(GetParam());
license_ = CreateLicense(key_mode_);
license_ = CreateLicense(key_mode_, ::testing::get<1>(GetParam()),
::testing::get<2>(GetParam()));
}
void TearDown() override { WB_License_Delete(whitebox_); }
@@ -39,6 +48,23 @@ class LicenseWhiteboxProcessLicenseResponseBenchmark
License license_;
};
TEST_P(LicenseWhiteboxProcessLicenseResponseBenchmark, ProcessLicenseCreate) {
Timer timer;
Sampler sampler;
for (size_t i = 0; i < kIterations; i++) {
timer.Reset();
ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK);
sampler.Push(timer.Get());
WB_License_Delete(whitebox_);
whitebox_ = nullptr;
}
PrettyPrint("License White-box License Create Duration", sampler,
license_.message.size());
}
TEST_P(LicenseWhiteboxProcessLicenseResponseBenchmark,
CreateAndProcessLicenseResponseAndDelete) {
Timer timer;
@@ -136,12 +162,46 @@ TEST_P(LicenseWhiteboxProcessLicenseResponseBenchmark, ProcessLicenseResponse) {
license_.message.size());
}
INSTANTIATE_TEST_SUITE_P(SingleKey,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(WB_LICENSE_KEY_MODE_SINGLE_KEY));
INSTANTIATE_TEST_SUITE_P(
SingleKeyWithSingleKeyServer,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(std::make_tuple(WB_LICENSE_KEY_MODE_SINGLE_KEY,
1,
SecurityLevel::kSoftwareSecureCrypto)));
INSTANTIATE_TEST_SUITE_P(DualKey,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(WB_LICENSE_KEY_MODE_DUAL_KEY));
INSTANTIATE_TEST_SUITE_P(
FiveCryptoKeysWithSingleKeyServer,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(std::make_tuple(WB_LICENSE_KEY_MODE_SINGLE_KEY,
5,
SecurityLevel::kSoftwareSecureCrypto)));
INSTANTIATE_TEST_SUITE_P(
FiveDecodeKeysWithSingleKeyServer,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(std::make_tuple(WB_LICENSE_KEY_MODE_SINGLE_KEY,
5,
SecurityLevel::kSoftwareSecureDecode)));
INSTANTIATE_TEST_SUITE_P(
SingleKeyWithDualKeyServer,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(std::make_tuple(WB_LICENSE_KEY_MODE_DUAL_KEY,
1,
SecurityLevel::kSoftwareSecureCrypto)));
INSTANTIATE_TEST_SUITE_P(
FiveCryptoKeysWithDualKeyServer,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(std::make_tuple(WB_LICENSE_KEY_MODE_DUAL_KEY,
5,
SecurityLevel::kSoftwareSecureCrypto)));
INSTANTIATE_TEST_SUITE_P(
FiveDecodeKeysWithDualKeyServer,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(std::make_tuple(WB_LICENSE_KEY_MODE_DUAL_KEY,
5,
SecurityLevel::kSoftwareSecureDecode)));
} // namespace widevine

4
whitebox/api/license_whitebox_process_license_response_core_message_test.cc
View File

@@ -18,7 +18,7 @@ class LicenseWhiteboxProcessLicenseResponseWithCoreMessageTest
void UseLicenseWithoutSigningKey(OdkVersion odk_version) {
TestLicenseBuilder builder;
builder.GetSettings().odk_version = odk_version;
builder.AddStubbedContentKey();
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
const auto server = TestServer::CreateDualKey();
builder.Build(*server, &license_);
@@ -31,7 +31,7 @@ class LicenseWhiteboxProcessLicenseResponseWithCoreMessageTest
builder.GetSettings().odk_version = odk_version;
builder.AddSigningKey(TestLicenseBuilder::DefaultSigningKey());
builder.AddStubbedContentKey();
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
auto server = TestServer::CreateDualKey();
builder.Build(*server, &license_);

6
whitebox/api/license_whitebox_process_license_response_test.cc
View File

@@ -30,7 +30,7 @@ class LicenseWhiteboxProcessLicenseResponseTest
void UseLicenseWithoutSigningKey() {
TestLicenseBuilder builder;
builder.AddStubbedContentKey();
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
builder.Build(*server_, &license_);
}
@@ -39,7 +39,7 @@ class LicenseWhiteboxProcessLicenseResponseTest
builder.GetSettings().padding = padding;
builder.AddSigningKey(TestLicenseBuilder::DefaultSigningKey());
builder.AddStubbedContentKey();
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
builder.Build(*server_, &license_);
}
@@ -98,7 +98,7 @@ TEST_F(LicenseWhiteboxProcessLicenseResponseTest,
builder.AddSigningKey(TestLicenseBuilder::DefaultSigningKey());
builder.AddSigningKey(TestLicenseBuilder::DefaultSigningKey());
builder.AddStubbedContentKey();
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
builder.Build(*server_, &license_);
ASSERT_EQ(WB_License_ProcessLicenseResponse(

48
whitebox/api/license_whitebox_query_content_key_status_test.cc
View File

@@ -28,8 +28,8 @@ class LicenseWhiteboxQueryContentKeyStatus
protected:
void SetUp() override {
LicenseWhiteboxTestBase::SetUp();
decrypt_key_ = &golden_data_.CBCCryptoKey();
masked_decrypt_key_ = &golden_data_.CBCDecodeKey();
decrypt_key_ = &golden_data_.CBCContent().software_crypto_key;
masked_decrypt_key_ = &golden_data_.CBCContent().software_decode_key;
std::tie(license_parsing_, padding_) = GetParam();
@@ -40,9 +40,7 @@ class LicenseWhiteboxQueryContentKeyStatus
builder_.SetSettings(settings);
}
void AddKey(const GoldenData::Key* key) {
builder_.AddContentKey(key->level, key->id, key->content->key);
}
void AddKey(const ContentKeyData* key) { builder_.AddContentKey(*key); }
WB_Result LoadLicense() {
TestLicenseBuilder::Settings settings = builder_.GetSettings();
@@ -82,8 +80,8 @@ class LicenseWhiteboxQueryContentKeyStatus
license.request.size());
}
const GoldenData::Key* decrypt_key_;
const GoldenData::Key* masked_decrypt_key_;
const ContentKeyData* decrypt_key_;
const ContentKeyData* masked_decrypt_key_;
private:
std::unique_ptr<TestServer> server_;
@@ -180,14 +178,18 @@ TEST_P(LicenseWhiteboxQueryContentKeyStatus, InvalidKeyForNoKeyData) {
SetSettings(settings);
AddKey(decrypt_key_);
ASSERT_EQ(LoadLicense(), WB_RESULT_OK);
// Allow either a parsing error, or success and no keys loaded.
WB_Result result = LoadLicense();
if (result != WB_RESULT_INVALID_PARAMETER) {
ASSERT_EQ(result, WB_RESULT_OK);
WB_KeyStatus key_state;
ASSERT_EQ(WB_License_QueryKeyStatus(whitebox_, WB_KEY_QUERY_TYPE_CONTENT_KEY,
decrypt_key_->id.data(),
decrypt_key_->id.size(), &key_state),
WB_RESULT_OK);
ASSERT_EQ(key_state, WB_KEY_STATUS_INVALID);
WB_KeyStatus key_state;
ASSERT_EQ(WB_License_QueryKeyStatus(
whitebox_, WB_KEY_QUERY_TYPE_CONTENT_KEY,
decrypt_key_->id.data(), decrypt_key_->id.size(), &key_state),
WB_RESULT_OK);
ASSERT_EQ(key_state, WB_KEY_STATUS_INVALID);
}
}
TEST_P(LicenseWhiteboxQueryContentKeyStatus, InvalidKeyForShortKeyData) {
@@ -197,14 +199,18 @@ TEST_P(LicenseWhiteboxQueryContentKeyStatus, InvalidKeyForShortKeyData) {
SetSettings(settings);
AddKey(decrypt_key_);
ASSERT_EQ(LoadLicense(), WB_RESULT_OK);
// Allow either a parsing error, or success and no keys loaded.
WB_Result result = LoadLicense();
if (result != WB_RESULT_INVALID_PARAMETER) {
ASSERT_EQ(result, WB_RESULT_OK);
WB_KeyStatus key_state;
ASSERT_EQ(WB_License_QueryKeyStatus(whitebox_, WB_KEY_QUERY_TYPE_CONTENT_KEY,
decrypt_key_->id.data(),
decrypt_key_->id.size(), &key_state),
WB_RESULT_OK);
ASSERT_EQ(key_state, WB_KEY_STATUS_INVALID);
WB_KeyStatus key_state;
ASSERT_EQ(WB_License_QueryKeyStatus(
whitebox_, WB_KEY_QUERY_TYPE_CONTENT_KEY,
decrypt_key_->id.data(), decrypt_key_->id.size(), &key_state),
WB_RESULT_OK);
ASSERT_EQ(key_state, WB_KEY_STATUS_INVALID);
}
}
TEST_P(LicenseWhiteboxQueryContentKeyStatus, InvalidKeyForLongKeyData) {

4
whitebox/api/license_whitebox_query_signing_key_status_test.cc
View File

@@ -61,9 +61,7 @@ class LicenseWhiteboxQuerySigningKeyStatus
// ODK requires there to be at least one content key or else it will fail
// to create the core message.
const auto& content_key = &golden_data_.CBCCryptoKey();
builder_.AddContentKey(content_key->level, content_key->id,
content_key->content->key);
builder_.AddContentKey(golden_data_.CBCContent().software_crypto_key);
auto server = TestServer::CreateDualKey();

57
whitebox/api/license_whitebox_security_level_test.cc
View File

@@ -37,8 +37,25 @@ class LicenseWhiteboxSecurityLevelTest
TEST_P(LicenseWhiteboxSecurityLevelTest, CanLoadAndUseKey) {
TestLicenseBuilder builder;
builder.GetSettings().key_control_block = key_control_block_;
builder.AddContentKey(security_level_, golden_data_.CBCCryptoKey().id,
golden_data_.CBCCryptoKey().content->key);
const auto& content = golden_data_.CBCContent();
const ContentKeyData* key = nullptr;
switch (security_level_) {
case SecurityLevel::kUndefined:
key = &content.undefined_key;
break;
case SecurityLevel::kSoftwareSecureCrypto:
key = &content.software_crypto_key;
break;
default:
ASSERT_FALSE(true);
break;
}
builder.AddContentKey(*key);
auto server = TestServer::CreateDualKey();
@@ -54,7 +71,7 @@ TEST_P(LicenseWhiteboxSecurityLevelTest, CanLoadAndUseKey) {
license.request.data(), license.request.size()),
WB_RESULT_OK);
plaintext_size_ = golden_data_.CBCCryptoKey().content->ciphertext.size();
plaintext_size_ = golden_data_.CBCContent().ciphertext.size();
plaintext_.resize(plaintext_size_);
// Make sure that the key was loaded successfully even if the security level
@@ -63,30 +80,22 @@ TEST_P(LicenseWhiteboxSecurityLevelTest, CanLoadAndUseKey) {
// Use EXPECT instead of ASSERT so that we can see the result of both decrypt
// calls before failing the test.
EXPECT_EQ(
WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC,
golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(),
plaintext_.data(), &plaintext_size_),
WB_RESULT_OK);
EXPECT_EQ(WB_License_Decrypt(whitebox_, WB_CIPHER_MODE_CBC, key->id.data(),
key->id.size(), content.ciphertext.data(),
content.ciphertext.size(), content.iv.data(),
content.iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
plaintext_size_ = golden_data_.CBCCryptoKey().content->ciphertext.size();
plaintext_size_ = content.ciphertext.size();
plaintext_.resize(plaintext_size_);
EXPECT_EQ(
WB_License_MaskedDecrypt(
whitebox_, WB_CIPHER_MODE_CBC, golden_data_.CBCCryptoKey().id.data(),
golden_data_.CBCCryptoKey().id.size(),
golden_data_.CBCCryptoKey().content->ciphertext.data(),
golden_data_.CBCCryptoKey().content->ciphertext.size(),
golden_data_.CBCCryptoKey().content->iv.data(),
golden_data_.CBCCryptoKey().content->iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
EXPECT_EQ(WB_License_MaskedDecrypt(
whitebox_, WB_CIPHER_MODE_CBC, key->id.data(), key->id.size(),
content.ciphertext.data(), content.ciphertext.size(),
content.iv.data(), content.iv.size(), plaintext_.data(),
&plaintext_size_),
WB_RESULT_OK);
}
INSTANTIATE_TEST_SUITE_P(

5
whitebox/api/license_whitebox_sign_benchmark.cc
View File

@@ -19,7 +19,7 @@ namespace {
constexpr size_t kMessageSize = 4 * 1024;
constexpr size_t kSignatureSize = 256;
constexpr size_t kIterations = 100;
constexpr size_t kIterations = 10;
} // namespace
@@ -37,7 +37,8 @@ class LicenseWhiteboxSignBenchmark
ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK);
const auto license = CreateLicense(key_mode_);
const auto license =
CreateLicense(key_mode_, 1, SecurityLevel::kSoftwareSecureCrypto);
ASSERT_EQ(WB_License_ProcessLicenseResponse(
whitebox_, key_mode_, license.core_message.data(),
license.core_message.size(), license.message.data(),

9
whitebox/api/license_whitebox_sign_license_request_test.cc
View File

@@ -98,6 +98,15 @@ TEST_F(LicenseWhiteboxSignLicenseRequestTest,
WB_RESULT_INVALID_PARAMETER);
}
TEST_F(LicenseWhiteboxSignLicenseRequestTest, CanProbeSizeWithNullSignature) {
signature_size_ = 0;
ASSERT_EQ(WB_License_SignLicenseRequest(whitebox_, license_.request.data(),
license_.request.size(), nullptr,
&signature_size_),
WB_RESULT_BUFFER_TOO_SMALL);
ASSERT_GT(signature_size_, 0);
}
TEST_F(LicenseWhiteboxSignLicenseRequestTest,
InvalidParameterForNullSignatureSize) {
ASSERT_EQ(WB_License_SignLicenseRequest(whitebox_, license_.request.data(),

17
whitebox/api/license_whitebox_sign_renewal_request_test.cc
View File

@@ -32,7 +32,7 @@ class LicenseWhiteboxSignRenewalRequestTest : public LicenseWhiteboxTestBase {
builder.AddSigningKey(signing_key_);
// Add a throw away key. We just need a key in the license since a license
// should always have a content key.
builder.AddStubbedContentKey();
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
auto server = TestServer::CreateDualKey();
@@ -142,6 +142,19 @@ TEST_F(LicenseWhiteboxSignRenewalRequestTest,
WB_RESULT_INVALID_PARAMETER);
}
TEST_F(LicenseWhiteboxSignRenewalRequestTest, CanProbeSizeWithNullSignature) {
TestLicenseBuilder::Settings settings;
settings.padding = TestLicenseBuilder::Padding::kNone;
LoadLicense(settings);
signature_size_ = 0;
ASSERT_EQ(WB_License_SignRenewalRequest(whitebox_, garbage_request_.data(),
garbage_request_.size(), nullptr,
&signature_size_),
WB_RESULT_BUFFER_TOO_SMALL);
ASSERT_GT(signature_size_, 0);
}
TEST_F(LicenseWhiteboxSignRenewalRequestTest,
InvalidParameterForNullSignature) {
TestLicenseBuilder::Settings settings;
@@ -202,7 +215,7 @@ TEST_F(LicenseWhiteboxSignRenewalRequestTest, KeyUnavailableForNoSigningKey) {
// Make a license with no signing key but has a content key. Every license
// must have a content key.
TestLicenseBuilder builder;
builder.AddStubbedContentKey();
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
auto server = TestServer::CreateDualKey();

494
whitebox/api/license_whitebox_uat_test.cc
View File

@@ -12,244 +12,286 @@ namespace widevine {
namespace {
const uint8_t kMessage[] = {
0x0a, 0x2a, 0x0a, 0x10, 0x53, 0xbc, 0x88, 0x54, 0x04, 0xfc, 0x85, 0xbd,
0x75, 0xce, 0x15, 0x2a, 0x06, 0xb5, 0x1f, 0xc5, 0x12, 0x10, 0x53, 0xbc,
0x88, 0x54, 0x04, 0xfc, 0x85, 0xbd, 0x75, 0xce, 0x15, 0x2a, 0x06, 0xb5,
0x1f, 0xc5, 0x1a, 0x00, 0x20, 0x01, 0x28, 0x00, 0x12, 0x12, 0x08, 0x01,
0x10, 0x01, 0x18, 0x01, 0x20, 0x80, 0xa3, 0x05, 0x28, 0x80, 0xa3, 0x05,
0x30, 0x80, 0xa3, 0x05, 0x1a, 0x66, 0x12, 0x10, 0x94, 0x40, 0xfa, 0xa2,
0xd0, 0xe2, 0xa4, 0x80, 0xb4, 0x74, 0x68, 0x91, 0x0a, 0xb9, 0xe4, 0x6a,
0x1a, 0x50, 0x30, 0xe2, 0xcb, 0x71, 0xa1, 0x92, 0xb7, 0xc8, 0x3f, 0xd9,
0x00, 0x2e, 0xf0, 0xf8, 0xb1, 0xe6, 0x9e, 0x62, 0xca, 0x27, 0xb3, 0xa7,
0x26, 0x19, 0x73, 0x9e, 0xf8, 0xc2, 0x8e, 0x6f, 0xea, 0xb3, 0x5b, 0x01,
0xa6, 0xe8, 0x9b, 0x84, 0x1b, 0x9e, 0xaf, 0xe2, 0xa1, 0xff, 0x4a, 0xca,
0xcf, 0x84, 0x3f, 0x36, 0xaa, 0x17, 0xa6, 0x0a, 0x0a, 0xe2, 0xcc, 0x12,
0xb1, 0x9f, 0xac, 0x05, 0xdf, 0xe7, 0x00, 0xad, 0xc4, 0xa5, 0xd4, 0x4d,
0x46, 0x01, 0xbb, 0xcc, 0x18, 0x7e, 0x4d, 0xb5, 0x05, 0x2a, 0x20, 0x01,
0x1a, 0x52, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x12, 0x10, 0xf1, 0xed,
0x57, 0xf4, 0xad, 0x5d, 0x0e, 0x2c, 0xf9, 0x78, 0xc9, 0xe4, 0x4d, 0x2e,
0xcc, 0x68, 0x1a, 0x20, 0xd7, 0xf5, 0x15, 0x85, 0x3b, 0x33, 0xea, 0x8e,
0x40, 0xef, 0x2a, 0xd0, 0x8f, 0x96, 0x69, 0xb6, 0xf9, 0xdd, 0x63, 0x8f,
0x80, 0x7e, 0x68, 0x02, 0xc7, 0x74, 0x55, 0x5d, 0xd4, 0x17, 0x45, 0x09,
0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x62, 0x02, 0x48, 0x44,
0x1a, 0x52, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x12, 0x10, 0xdb, 0x38,
0x5d, 0x4a, 0x0d, 0x80, 0x37, 0x42, 0x10, 0x60, 0x0d, 0x24, 0x03, 0xde,
0xd0, 0x3c, 0x1a, 0x20, 0x22, 0xab, 0x33, 0xb9, 0xe5, 0x16, 0xa2, 0x6d,
0x5a, 0x42, 0x45, 0xd4, 0x0e, 0x47, 0x0c, 0xf3, 0x6c, 0x1f, 0x20, 0xd9,
0x0e, 0x79, 0xd7, 0xb7, 0x34, 0xc1, 0xbe, 0xd2, 0x6b, 0x01, 0xff, 0x73,
0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x62, 0x02, 0x48, 0x44,
0x1a, 0x55, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x12, 0x10, 0xdd, 0xfb,
0x7a, 0x27, 0x34, 0xd4, 0xec, 0xcf, 0x01, 0x9c, 0xbd, 0x84, 0xe3, 0xf0,
0xbd, 0xc6, 0x1a, 0x20, 0x11, 0x0c, 0xa2, 0xc3, 0xb8, 0x95, 0xaf, 0x48,
0x80, 0x57, 0xd1, 0x39, 0xec, 0xd7, 0x09, 0x5a, 0x95, 0x31, 0xf8, 0x3f,
0xa0, 0x6d, 0x9c, 0xad, 0x10, 0x70, 0xa4, 0x6b, 0x6a, 0x5c, 0xca, 0x73,
0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x62, 0x05, 0x41, 0x55,
0x44, 0x49, 0x4f, 0x1a, 0x52, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x12,
0x10, 0xcb, 0xac, 0x50, 0x57, 0x81, 0xcd, 0x04, 0xf6, 0x71, 0xb2, 0xc2,
0x08, 0x86, 0x12, 0x78, 0x58, 0x1a, 0x20, 0x71, 0x0e, 0xd7, 0xa2, 0x8c,
0x64, 0x75, 0x0b, 0x11, 0x9e, 0x48, 0x47, 0x0c, 0x2d, 0x78, 0x48, 0x1c,
0x98, 0x2f, 0x14, 0x51, 0x15, 0x2a, 0x05, 0xe8, 0x84, 0x6e, 0x61, 0xc2,
0x26, 0x82, 0xe6, 0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x62,
0x02, 0x48, 0x44, 0x1a, 0x52, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x12,
0x10, 0xa6, 0xd4, 0xb8, 0x0a, 0x37, 0x46, 0xf6, 0xc8, 0x59, 0x5a, 0x30,
0x96, 0x39, 0x16, 0x29, 0x1e, 0x1a, 0x20, 0xff, 0xe7, 0xb2, 0x9e, 0x98,
0x40, 0x33, 0xce, 0x9e, 0xcf, 0x85, 0x60, 0x52, 0x43, 0x38, 0xe6, 0x1b,
0x07, 0x10, 0xfa, 0x71, 0xa8, 0x66, 0x0f, 0xd6, 0x9a, 0x09, 0xac, 0xb1,
0x47, 0xe4, 0x19, 0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x62,
0x02, 0x53, 0x44, 0x1a, 0x52, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x12,
0x10, 0x57, 0x43, 0x24, 0x10, 0x4d, 0xd3, 0xcf, 0x6e, 0xef, 0x37, 0xce,
0x5b, 0xba, 0xd1, 0x61, 0x62, 0x1a, 0x20, 0x54, 0xec, 0xbb, 0xc7, 0x4b,
0xa6, 0x3f, 0x17, 0xcc, 0x5e, 0xb8, 0x20, 0x41, 0x9e, 0xcf, 0xe2, 0x9f,
0x03, 0x9d, 0x79, 0xd0, 0x06, 0x0b, 0x0e, 0x6e, 0xf4, 0x9e, 0x93, 0x92,
0x50, 0x19, 0xbd, 0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x62,
0x02, 0x53, 0x44, 0x1a, 0x52, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x12,
0x10, 0xd7, 0x93, 0x22, 0x74, 0xf1, 0x0b, 0x61, 0x26, 0x7e, 0x16, 0xd5,
0x88, 0x5f, 0x70, 0x2b, 0x3d, 0x1a, 0x20, 0xb2, 0x21, 0xc6, 0xb4, 0x65,
0xf1, 0x00, 0x07, 0x11, 0x0e, 0xe4, 0x67, 0x3c, 0xb4, 0x4c, 0xc9, 0xe9,
0x82, 0x5e, 0xbc, 0x2a, 0x2a, 0xf0, 0x68, 0x45, 0xfe, 0xd2, 0xce, 0xea,
0xae, 0xfb, 0x9a, 0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x62,
0x02, 0x53, 0x44, 0x1a, 0x52, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x36, 0x12,
0x10, 0x96, 0x9e, 0xc6, 0xcb, 0xc0, 0xbf, 0xf5, 0x83, 0xef, 0xc9, 0xe7,
0xbb, 0x2a, 0x1a, 0xce, 0x0b, 0x1a, 0x20, 0xe0, 0x23, 0x16, 0x1e, 0x00,
0x05, 0xc0, 0xfe, 0x97, 0x47, 0x5f, 0x75, 0x69, 0x8c, 0x09, 0x8b, 0x3e,
0x93, 0x1b, 0xa4, 0x84, 0x4b, 0xd3, 0xb1, 0x77, 0xd4, 0x42, 0xee, 0x7e,
0xf5, 0xe4, 0x0c, 0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x62,
0x02, 0x53, 0x44, 0x20, 0xb2, 0x88, 0xc6, 0xfa, 0x05, 0x38, 0x00,
0x0a, 0x38, 0x0a, 0x10, 0x0b, 0x66, 0x84, 0x0b, 0x99, 0x6a, 0x03, 0xac,
0xdc, 0x64, 0x29, 0x5f, 0xb4, 0xbf, 0xbc, 0x3b, 0x12, 0x10, 0x0b, 0x66,
0x84, 0x0b, 0x99, 0x6a, 0x03, 0xac, 0xdc, 0x64, 0x29, 0x5f, 0xb4, 0xbf,
0xbc, 0x3b, 0x1a, 0x00, 0x20, 0x01, 0x28, 0x00, 0x38, 0x80, 0xa3, 0x05,
0x40, 0x80, 0xa3, 0x05, 0x48, 0xe4, 0xa4, 0xd9, 0x86, 0x06, 0x12, 0x17,
0x08, 0x01, 0x10, 0x01, 0x18, 0x01, 0x20, 0x80, 0xa3, 0x05, 0x28, 0x80,
0xa3, 0x05, 0x30, 0x80, 0xa3, 0x05, 0x38, 0x80, 0xe7, 0x84, 0x0f, 0x1a,
0x66, 0x12, 0x10, 0xc5, 0xe6, 0xb9, 0xb5, 0x64, 0xc2, 0x00, 0x1d, 0x6b,
0xfc, 0x41, 0x93, 0xe0, 0xae, 0x3b, 0x4f, 0x1a, 0x50, 0xeb, 0xa5, 0x03,
0xd5, 0x9a, 0x0b, 0xca, 0xe0, 0xe2, 0x48, 0xbb, 0x8a, 0xcc, 0xb4, 0x29,
0xf6, 0xa3, 0x70, 0x3c, 0xa7, 0x6f, 0x93, 0x13, 0x2b, 0x95, 0x82, 0x2d,
0xb0, 0xd0, 0xd8, 0xa3, 0xd7, 0x9b, 0x85, 0xea, 0xfc, 0xdf, 0x0c, 0x54,
0x95, 0x9d, 0x5f, 0x68, 0xf7, 0xf8, 0x86, 0x19, 0xaa, 0xe6, 0xaa, 0x2c,
0xe7, 0xe4, 0x98, 0x25, 0x3f, 0x7d, 0x16, 0xfb, 0x6c, 0x9c, 0x7a, 0x44,
0x36, 0xeb, 0x2b, 0xe6, 0x06, 0xb7, 0x00, 0xcb, 0x49, 0xbc, 0x07, 0x1a,
0xb7, 0xd0, 0xd3, 0x85, 0xa3, 0x20, 0x01, 0x1a, 0x66, 0x0a, 0x10, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x33, 0x12, 0x10, 0x98, 0x21, 0xd7, 0x57, 0xfe, 0xa0, 0x10,
0x76, 0x54, 0x4f, 0x72, 0x18, 0x42, 0xab, 0x9a, 0xed, 0x1a, 0x20, 0x86,
0x42, 0x40, 0x2b, 0x4e, 0x38, 0x1a, 0x0c, 0x7d, 0x29, 0x1a, 0x44, 0x4a,
0x68, 0x24, 0xc8, 0x34, 0x31, 0xf2, 0xd0, 0x2a, 0x07, 0x84, 0xfe, 0x51,
0xb0, 0x8d, 0x8f, 0x05, 0x05, 0x25, 0x55, 0x20, 0x02, 0x28, 0x01, 0x32,
0x00, 0x3a, 0x00, 0x42, 0x12, 0x0a, 0x10, 0x6b, 0x63, 0x31, 0x36, 0x00,
0x01, 0x51, 0x80, 0x01, 0x63, 0xab, 0xd0, 0x80, 0x00, 0x00, 0x08, 0x62,
0x02, 0x48, 0x44, 0x1a, 0x66, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x12,
0x10, 0x01, 0xc9, 0x40, 0x76, 0x7a, 0x89, 0xb6, 0xce, 0x46, 0x24, 0xc9,
0x2d, 0xec, 0xd8, 0xa3, 0xae, 0x1a, 0x20, 0x6a, 0x76, 0x89, 0x53, 0xf1,
0xb1, 0xef, 0x2e, 0x97, 0x34, 0x75, 0xfe, 0x17, 0x31, 0xbf, 0x08, 0x9f,
0x73, 0x5e, 0xab, 0x66, 0x33, 0x81, 0x99, 0xf6, 0xe7, 0x8b, 0x10, 0x46,
0x47, 0xc4, 0xf8, 0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x42,
0x12, 0x0a, 0x10, 0x6b, 0x63, 0x31, 0x36, 0x00, 0x01, 0x51, 0x80, 0x01,
0x63, 0xab, 0xd0, 0x80, 0x00, 0x00, 0x08, 0x62, 0x02, 0x48, 0x44, 0x1a,
0x69, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x12, 0x10, 0xa1, 0x2c, 0xfe,
0xdf, 0xf5, 0x83, 0x95, 0xa8, 0x15, 0xec, 0xad, 0x23, 0x02, 0x6a, 0xc2,
0x96, 0x1a, 0x20, 0x76, 0xd6, 0xef, 0x6f, 0x2d, 0x7e, 0xd0, 0x9c, 0x5e,
0x1e, 0x58, 0x63, 0x82, 0x1d, 0xe0, 0xe5, 0x6d, 0x62, 0x8a, 0x89, 0xc2,
0xe3, 0xce, 0xd7, 0xc3, 0xe8, 0x75, 0x8b, 0x64, 0x81, 0x6f, 0x8a, 0x20,
0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x42, 0x12, 0x0a, 0x10, 0x6b,
0x63, 0x31, 0x36, 0x00, 0x01, 0x51, 0x80, 0x01, 0x63, 0xab, 0xd0, 0x80,
0x00, 0x00, 0x08, 0x62, 0x05, 0x41, 0x55, 0x44, 0x49, 0x4f, 0x1a, 0x66,
0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x37, 0x12, 0x10, 0xf5, 0x88, 0x10, 0xa5,
0x8b, 0x02, 0xca, 0x94, 0x75, 0xd7, 0xd6, 0x98, 0x2e, 0x65, 0x87, 0x2b,
0x1a, 0x20, 0x43, 0x36, 0x3d, 0x05, 0xeb, 0xb4, 0x92, 0x7c, 0x9e, 0xc5,
0x86, 0xff, 0xe7, 0x6a, 0x5d, 0xb2, 0x35, 0x6d, 0x1e, 0xc8, 0x6e, 0xde,
0x27, 0xfa, 0xac, 0xd3, 0x3d, 0x6e, 0xcc, 0x42, 0x6c, 0xa5, 0x20, 0x02,
0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x42, 0x12, 0x0a, 0x10, 0x6b, 0x63,
0x31, 0x36, 0x00, 0x01, 0x51, 0x80, 0x01, 0x63, 0xab, 0xd0, 0x80, 0x00,
0x00, 0x08, 0x62, 0x02, 0x48, 0x44, 0x1a, 0x66, 0x0a, 0x10, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x31, 0x12, 0x10, 0xdf, 0x81, 0x18, 0xb6, 0xf0, 0xf6, 0xef, 0x8a,
0x66, 0xd1, 0x0b, 0x30, 0x6b, 0x15, 0x76, 0x70, 0x1a, 0x20, 0x44, 0xea,
0x2c, 0xec, 0xe7, 0x93, 0x9e, 0xfb, 0xc2, 0xca, 0xb9, 0x83, 0x74, 0xcb,
0x0f, 0x89, 0x7b, 0x05, 0xb3, 0xea, 0x12, 0xc2, 0x63, 0xf4, 0x17, 0x8c,
0x62, 0xd5, 0xce, 0xe7, 0x7f, 0xa3, 0x20, 0x02, 0x28, 0x01, 0x32, 0x00,
0x3a, 0x00, 0x42, 0x12, 0x0a, 0x10, 0x6b, 0x63, 0x31, 0x36, 0x00, 0x01,
0x51, 0x80, 0x01, 0x63, 0xab, 0xd0, 0x80, 0x00, 0x00, 0x08, 0x62, 0x02,
0x53, 0x44, 0x1a, 0x66, 0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x12, 0x10,
0x49, 0x68, 0x4d, 0x67, 0x0c, 0xdd, 0xbb, 0x57, 0xcc, 0xce, 0x83, 0x3f,
0x4b, 0xcf, 0x7f, 0x8a, 0x1a, 0x20, 0x38, 0x91, 0x22, 0xc0, 0x7e, 0x89,
0xe4, 0x40, 0xa3, 0x55, 0x7e, 0x65, 0x6e, 0x7d, 0x2a, 0xad, 0x8f, 0x17,
0x70, 0x5d, 0xe3, 0x4a, 0x92, 0x12, 0x26, 0x10, 0x11, 0x4e, 0x78, 0x9a,
0x2d, 0xa1, 0x20, 0x02, 0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x42, 0x12,
0x0a, 0x10, 0x6b, 0x63, 0x31, 0x36, 0x00, 0x01, 0x51, 0x80, 0x01, 0x63,
0xab, 0xd0, 0x80, 0x00, 0x00, 0x08, 0x62, 0x02, 0x53, 0x44, 0x1a, 0x66,
0x0a, 0x10, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x35, 0x12, 0x10, 0xc8, 0x2d, 0x4d, 0x9c,
0x1b, 0xbe, 0x00, 0xb3, 0x48, 0x6b, 0x57, 0xe5, 0x1e, 0x13, 0x14, 0xc9,
0x1a, 0x20, 0x5a, 0x01, 0xbd, 0x78, 0xa0, 0x24, 0x10, 0xba, 0xde, 0xf1,
0x1c, 0x29, 0x12, 0x87, 0x9e, 0x5f, 0xf7, 0x60, 0xd6, 0x06, 0x96, 0x0e,
0x2e, 0x77, 0x08, 0x6e, 0xda, 0x15, 0xac, 0x05, 0x43, 0xc5, 0x20, 0x02,
0x28, 0x01, 0x32, 0x00, 0x3a, 0x00, 0x42, 0x12, 0x0a, 0x10, 0x6b, 0x63,
0x31, 0x36, 0x00, 0x01, 0x51, 0x80, 0x01, 0x63, 0xab, 0xd0, 0x80, 0x00,
0x00, 0x08, 0x62, 0x02, 0x53, 0x44, 0x1a, 0x66, 0x0a, 0x10, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x36, 0x12, 0x10, 0x83, 0x61, 0x7c, 0xa2, 0x1a, 0x00, 0xe3, 0x7b,
0x02, 0x41, 0x3d, 0xc6, 0x42, 0x06, 0x6f, 0x51, 0x1a, 0x20, 0xef, 0x46,
0xa3, 0x3f, 0x88, 0x0d, 0x1c, 0x89, 0xa4, 0xed, 0xe5, 0x7e, 0xeb, 0x03,
0x5c, 0x75, 0x34, 0x6a, 0x5a, 0x7d, 0xf7, 0xcf, 0x96, 0x3d, 0x18, 0x8e,
0xd2, 0x09, 0xf2, 0x64, 0x37, 0x27, 0x20, 0x02, 0x28, 0x01, 0x32, 0x00,
0x3a, 0x00, 0x42, 0x12, 0x0a, 0x10, 0x6b, 0x63, 0x31, 0x36, 0x00, 0x01,
0x51, 0x80, 0x01, 0x63, 0xab, 0xd0, 0x80, 0x00, 0x00, 0x08, 0x62, 0x02,
0x53, 0x44, 0x20, 0xe4, 0xa4, 0xd9, 0x86, 0x06, 0x38, 0x00,
};
const uint8_t kSignature[] = {
0x34, 0x7e, 0xc1, 0xa9, 0x3e, 0x1d, 0x66, 0x77, 0x5d, 0xac, 0xe8,
0x8b, 0xc0, 0x37, 0x3e, 0x4c, 0x9b, 0xe5, 0x9c, 0x25, 0x04, 0xed,
0x3f, 0x66, 0x6e, 0x6c, 0x51, 0x42, 0x57, 0x7f, 0x6c, 0x53,
0x78, 0xfb, 0xe1, 0x05, 0xc8, 0x36, 0xe6, 0x12, 0x64, 0xbf, 0x26,
0x91, 0x46, 0x11, 0xa1, 0xe5, 0x3b, 0xf0, 0x39, 0x42, 0x34, 0x26,
0x0a, 0xbd, 0x54, 0xe8, 0x69, 0xeb, 0x78, 0x76, 0x4e, 0xab,
};
const uint8_t kSessionKey[] = {
0x21, 0xd8, 0x3b, 0x58, 0xda, 0xa9, 0x3a, 0x1c, 0xdb, 0xfb, 0x54, 0xff,
0x0d, 0x30, 0xcd, 0x00, 0xff, 0x52, 0xc4, 0xed, 0x5c, 0xf9, 0xc9, 0x1c,
0x7b, 0x41, 0x48, 0xc0, 0x98, 0xa9, 0x74, 0x99, 0x79, 0xa0, 0x75, 0xc3,
0x50, 0xf0, 0xac, 0xfa, 0xec, 0xc4, 0xc0, 0x34, 0x06, 0x5b, 0xb9, 0xaa,
0x6d, 0xcf, 0x71, 0x69, 0xf0, 0x5e, 0x8f, 0x6b, 0x50, 0x9a, 0x16, 0x54,
0xa7, 0x72, 0x11, 0x50, 0xf9, 0xec, 0x8d, 0xcc, 0x3a, 0x23, 0x16, 0x84,
0x78, 0xea, 0xaa, 0xbd, 0x6f, 0xd9, 0x88, 0x5f, 0xa8, 0x82, 0x3c, 0x05,
0x53, 0xe7, 0x76, 0x5f, 0xe3, 0x7a, 0x4a, 0xe5, 0xeb, 0x45, 0x9d, 0x04,
0x45, 0xe8, 0x9a, 0x4a, 0x10, 0x02, 0x63, 0x97, 0x35, 0x68, 0x87, 0xc4,
0xe3, 0xaa, 0xbd, 0x1b, 0xe7, 0xa2, 0xd4, 0x52, 0xb0, 0xea, 0x2d, 0x2f,
0x59, 0x62, 0x7e, 0xb4, 0x6b, 0xe0, 0x06, 0x7a, 0xee, 0x98, 0x21, 0x74,
0xec, 0x99, 0x61, 0x55, 0x9b, 0x1d, 0xf9, 0x5d, 0x6f, 0x80, 0x87, 0xdd,
0xf3, 0x7b, 0x5d, 0x98, 0xb6, 0x37, 0x6a, 0x0a, 0x83, 0x5e, 0x36, 0x08,
0x8a, 0xf4, 0xcd, 0x9e, 0x5c, 0x7d, 0xec, 0xf2, 0x4e, 0x5b, 0x4d, 0xac,
0x9a, 0xab, 0xb1, 0x80, 0xc9, 0x58, 0xa0, 0x1d, 0x19, 0x16, 0x0b, 0xd5,
0xea, 0xe7, 0xfc, 0xfd, 0x4e, 0x04, 0x98, 0xa1, 0x8d, 0x79, 0xb0, 0xa7,
0xb5, 0x44, 0xfc, 0x12, 0xd2, 0x04, 0x7d, 0x53, 0x02, 0xfd, 0x70, 0x21,
0xef, 0xfd, 0x64, 0x11, 0x48, 0x03, 0xc4, 0x66, 0x7a, 0x29, 0xc3, 0x83,
0xfc, 0xee, 0xad, 0x9a, 0x4c, 0x97, 0x64, 0x0a, 0x9e, 0x72, 0x42, 0xc1,
0x1f, 0x32, 0x29, 0x80, 0xcf, 0xb9, 0xdc, 0x1d, 0x81, 0x92, 0x13, 0xfe,
0x85, 0x50, 0x53, 0x4a, 0x0a, 0xa2, 0x24, 0x52, 0x26, 0x9a, 0x65, 0x28,
0x13, 0x26, 0xae, 0xf3,
0x90, 0xce, 0xab, 0x08, 0x31, 0xfa, 0x7c, 0xc4, 0x9c, 0xf4, 0x03, 0xe8,
0x6f, 0xa8, 0x81, 0xd0, 0x60, 0xa1, 0xd5, 0x90, 0x86, 0x04, 0x86, 0xbb,
0x32, 0xea, 0x44, 0xff, 0xba, 0x88, 0x34, 0x10, 0xef, 0x0f, 0x1a, 0xe2,
0x80, 0xa9, 0xf6, 0x26, 0x17, 0x56, 0xe5, 0x1c, 0xd2, 0x92, 0xb7, 0x2d,
0xb5, 0x8c, 0x6b, 0x11, 0x5b, 0x67, 0xe6, 0x1a, 0xa2, 0x58, 0x2b, 0x3d,
0xc1, 0x76, 0x4b, 0xf8, 0x4e, 0x71, 0x69, 0xab, 0xdb, 0x3b, 0xdf, 0xca,
0x62, 0xe0, 0x95, 0x91, 0x2d, 0x4f, 0x52, 0x7e, 0xd6, 0x42, 0xb7, 0xd1,
0xd5, 0x5b, 0x1b, 0xc5, 0xde, 0x23, 0x45, 0xa3, 0xd6, 0x3f, 0x2c, 0x69,
0xcb, 0xb6, 0xfd, 0x38, 0xdd, 0xa4, 0xb8, 0x53, 0xff, 0xa8, 0x06, 0x80,
0x31, 0x7c, 0x16, 0x26, 0xd1, 0x20, 0x4b, 0x96, 0x57, 0xdd, 0x96, 0xf5,
0x04, 0x80, 0x9b, 0x1e, 0x7a, 0xca, 0x8d, 0xb2,
};
const uint8_t kLicenseRequest[] = {
0x0a, 0x88, 0x0b, 0x08, 0x01, 0x12, 0xed, 0x09, 0x0a, 0xb0, 0x02, 0x08,
0x02, 0x12, 0x10, 0x0c, 0x36, 0x48, 0x86, 0x75, 0xa1, 0x84, 0x53, 0x4d,
0xbc, 0x55, 0x96, 0xc9, 0xf4, 0xaf, 0x0a, 0x18, 0x97, 0xe7, 0xdd, 0xf8,
0x05, 0x22, 0x8e, 0x02, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01,
0x00, 0xae, 0xa6, 0xa8, 0xea, 0xdd, 0xac, 0x6f, 0xb4, 0x41, 0x47, 0xcb,
0x18, 0x81, 0xeb, 0xdf, 0x4f, 0x17, 0xf7, 0x17, 0xc0, 0xab, 0x6f, 0x47,
0x50, 0xbf, 0xe4, 0x8c, 0xc9, 0x45, 0x24, 0x5e, 0x1c, 0x2e, 0x86, 0x9f,
0xcb, 0x47, 0x05, 0xf9, 0xfe, 0x91, 0x90, 0xaf, 0xbd, 0x22, 0x14, 0x47,
0xa7, 0x34, 0x39, 0x79, 0x44, 0xe9, 0x92, 0x83, 0x4a, 0x80, 0xa8, 0x2a,
0xe6, 0x9f, 0x2b, 0xb7, 0xda, 0x2a, 0xd2, 0xae, 0x57, 0x5b, 0xfa, 0xb6,
0xdf, 0xca, 0x3e, 0xb1, 0xb8, 0x42, 0x0b, 0xde, 0x46, 0x36, 0xdb, 0x42,
0x33, 0x8b, 0xda, 0x5c, 0x60, 0x44, 0x7c, 0x99, 0xb4, 0x98, 0xb4, 0x1e,
0xd8, 0x25, 0x6d, 0x67, 0x84, 0xc9, 0x67, 0xde, 0x05, 0xe6, 0x06, 0xb5,
0xb5, 0xca, 0xbc, 0xfa, 0xb0, 0xa7, 0x46, 0x29, 0x3f, 0x63, 0x47, 0x9d,
0x70, 0x8d, 0xa2, 0x8d, 0x22, 0xc6, 0xeb, 0x06, 0xd4, 0x5c, 0x3b, 0x62,
0x98, 0xc7, 0xda, 0x16, 0x8f, 0x17, 0x59, 0xd5, 0xcb, 0xd1, 0x5d, 0xe3,
0xe1, 0x07, 0xe6, 0x97, 0x87, 0xf4, 0x22, 0x53, 0xfa, 0xf9, 0xa9, 0xf5,
0xeb, 0xd7, 0x55, 0xdf, 0x32, 0x2d, 0x4e, 0x07, 0x86, 0x25, 0x44, 0x93,
0xd6, 0xf7, 0xc6, 0xf9, 0x78, 0x91, 0x24, 0x1e, 0xd4, 0x6b, 0xe3, 0x4a,
0xff, 0x4a, 0x3a, 0xb9, 0x89, 0x90, 0x61, 0x87, 0xb9, 0x41, 0x45, 0x02,
0xfd, 0xd0, 0xc5, 0x5a, 0x98, 0x41, 0x88, 0xa4, 0xe3, 0xe2, 0xa2, 0x9d,
0x9a, 0x90, 0x3f, 0x44, 0x8e, 0x3a, 0xe1, 0xd1, 0xe9, 0x79, 0x9a, 0xc6,
0xe2, 0x7c, 0x8e, 0x9c, 0x3d, 0xb2, 0xe0, 0x26, 0x5a, 0x46, 0x13, 0xc8,
0x43, 0x9f, 0xf7, 0x51, 0x7e, 0xbb, 0x55, 0x6d, 0xcc, 0x97, 0x38, 0xdb,
0xa4, 0x4b, 0x96, 0x40, 0xe5, 0x2d, 0x8f, 0x43, 0xe3, 0x21, 0x15, 0xda,
0x34, 0x97, 0x7a, 0x9e, 0xbb, 0x02, 0x03, 0x01, 0x00, 0x01, 0x28, 0xe8,
0x3d, 0x48, 0x01, 0x12, 0x80, 0x02, 0xa2, 0x05, 0x30, 0x91, 0xed, 0xc2,
0x17, 0xfd, 0x92, 0x5c, 0x69, 0x1f, 0xb4, 0x82, 0x35, 0x75, 0xcb, 0x48,
0x22, 0x07, 0x54, 0x72, 0x05, 0x86, 0x2e, 0xa1, 0x98, 0xc9, 0x46, 0x07,
0xc9, 0x26, 0x6b, 0x05, 0x56, 0xa2, 0xa6, 0x5b, 0xe3, 0xba, 0x80, 0xd0,
0x01, 0xb3, 0xbd, 0x9f, 0x7b, 0x15, 0xe3, 0xe6, 0xad, 0x85, 0xe6, 0x92,
0x35, 0xec, 0x9b, 0x18, 0x7e, 0x1d, 0x39, 0x93, 0xfb, 0x0b, 0x2c, 0xe8,
0xa0, 0xee, 0x6e, 0x27, 0x8f, 0x08, 0x99, 0xc7, 0xd6, 0x08, 0x1f, 0xe5,
0xd4, 0x9b, 0x30, 0x83, 0x31, 0xf8, 0x49, 0x05, 0x9b, 0xa0, 0x30, 0xaa,
0xc1, 0x61, 0xd4, 0xec, 0x81, 0x28, 0xe1, 0x80, 0x17, 0x09, 0xdc, 0x35,
0xb8, 0xdc, 0xd3, 0x46, 0x7b, 0xa6, 0xad, 0x44, 0x90, 0x17, 0x99, 0x8e,
0x43, 0xd4, 0x35, 0x00, 0x98, 0x6c, 0xe5, 0xc3, 0x2e, 0xad, 0x80, 0xa6,
0x35, 0x3e, 0xed, 0xb2, 0x22, 0xe0, 0xad, 0x8a, 0xd0, 0x1a, 0x5e, 0x27,
0x29, 0xe2, 0xd9, 0x01, 0x2d, 0xf3, 0xe8, 0xb8, 0xa5, 0x6d, 0x8b, 0xfb,
0x1c, 0x8e, 0x77, 0xa1, 0xe0, 0x8e, 0x64, 0x1b, 0xfb, 0x3a, 0x05, 0x2f,
0x96, 0x6f, 0xe7, 0x86, 0xff, 0x75, 0x8f, 0xdf, 0x3d, 0xf4, 0x2d, 0x7a,
0xfc, 0x76, 0x0d, 0xf1, 0xde, 0x60, 0xe7, 0x4b, 0xc1, 0x87, 0xb0, 0x3f,
0xa3, 0xe6, 0x37, 0xf1, 0xf0, 0x0a, 0x9e, 0x99, 0xe2, 0x7f, 0x6a, 0x99,
0xe1, 0xde, 0x2c, 0x23, 0x8d, 0xc6, 0x2d, 0xe8, 0x4d, 0x4a, 0x2b, 0x02,
0xf2, 0xc1, 0xea, 0xae, 0x9d, 0x2f, 0xb3, 0xee, 0x84, 0xe9, 0xb8, 0xe4,
0x7b, 0x62, 0x47, 0x9c, 0xf0, 0xed, 0x80, 0x37, 0xcf, 0x92, 0xc5, 0xae,
0xbb, 0x32, 0x31, 0xb4, 0xd7, 0xc4, 0xce, 0xa3, 0x4e, 0xb6, 0xd6, 0xe9,
0x72, 0x5f, 0xd1, 0xe5, 0xa0, 0xf1, 0xfb, 0x79, 0xb1, 0xa8, 0x1a, 0xb4,
0x05, 0x0a, 0xae, 0x02, 0x08, 0x01, 0x12, 0x10, 0x65, 0x80, 0x2c, 0x9b,
0x62, 0x5e, 0x5a, 0x31, 0x9c, 0x33, 0xdc, 0x1c, 0xb7, 0xc3, 0xc6, 0xd4,
0x18, 0xe3, 0xa5, 0xbd, 0xd0, 0x05, 0x22, 0x8e, 0x02, 0x30, 0x82, 0x01,
0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xb8, 0x05, 0x02, 0x04, 0x3c, 0x2a,
0x8a, 0x0f, 0xd8, 0xd2, 0x5c, 0x61, 0x3e, 0x1e, 0x3e, 0x3b, 0x5e, 0x34,
0x9f, 0x33, 0x2f, 0x04, 0x51, 0x6a, 0x75, 0x10, 0xd3, 0x80, 0x21, 0xa5,
0x62, 0x9b, 0x9a, 0xa0, 0x27, 0xae, 0xad, 0x3c, 0x75, 0x9b, 0x7a, 0xfe,
0x70, 0xbe, 0xd6, 0x5f, 0x3d, 0xf6, 0x86, 0x0f, 0xf5, 0xeb, 0x60, 0xb9,
0x83, 0xa3, 0xff, 0xa3, 0x3f, 0xde, 0x06, 0xf3, 0xb7, 0x30, 0x14, 0xdf,
0xc8, 0x45, 0xab, 0x37, 0x1c, 0x66, 0x00, 0x56, 0x2e, 0x9d, 0x90, 0x4f,
0x84, 0x2b, 0x8b, 0xa4, 0xa5, 0xd9, 0x20, 0x0f, 0xfa, 0x3e, 0xd4, 0x5d,
0x70, 0x55, 0x20, 0xa5, 0xc3, 0x72, 0xa8, 0x89, 0xf9, 0xe3, 0x14, 0x38,
0x62, 0x34, 0xc6, 0x89, 0x7a, 0xe6, 0x55, 0x85, 0x1f, 0xcd, 0x9a, 0xdb,
0x4e, 0xf9, 0x12, 0x6c, 0x78, 0x38, 0x6e, 0xa9, 0x3b, 0xcb, 0x25, 0xba,
0x3e, 0xc4, 0x75, 0xc5, 0x5c, 0x60, 0x8e, 0x77, 0x1c, 0x76, 0x3a, 0xb0,
0x25, 0x06, 0xf9, 0xb0, 0x72, 0x52, 0xd6, 0xab, 0xf7, 0xea, 0x64, 0xb1,
0xeb, 0xde, 0x7b, 0x95, 0xc6, 0x40, 0x76, 0x90, 0x53, 0x3b, 0xd6, 0x89,
0x0b, 0x92, 0x74, 0xc1, 0x60, 0x66, 0xf7, 0x4f, 0xc4, 0x01, 0xea, 0x35,
0x5f, 0x0a, 0x02, 0x10, 0x68, 0x14, 0xd4, 0x9b, 0xf0, 0xc8, 0x9e, 0x6e,
0x1f, 0x8d, 0xb2, 0xa4, 0x78, 0x41, 0xcd, 0x0d, 0xad, 0x79, 0x32, 0x96,
0xa1, 0x07, 0xc3, 0x62, 0x23, 0x40, 0x4f, 0x2b, 0xf1, 0xfc, 0xa1, 0x6f,
0xd0, 0xa4, 0xb9, 0x82, 0x63, 0x4d, 0xb6, 0x24, 0x07, 0xf8, 0xf1, 0x4a,
0xca, 0xe3, 0xb0, 0x5a, 0x03, 0x8b, 0xd3, 0xe4, 0xbb, 0xba, 0xe4, 0x39,
0x1b, 0xbf, 0xa7, 0xa4, 0x7f, 0xb9, 0xd0, 0x1d, 0xe8, 0x57, 0xea, 0x88,
0xe5, 0xe3, 0x6e, 0xe3, 0x6e, 0x24, 0x58, 0x59, 0xfc, 0x0f, 0x02, 0x03,
0x01, 0x00, 0x01, 0x28, 0xe8, 0x3d, 0x12, 0x80, 0x03, 0x7e, 0x06, 0x58,
0x1a, 0x01, 0x91, 0x84, 0xab, 0x57, 0x2a, 0xfd, 0xca, 0xdd, 0xd0, 0x3f,
0x16, 0x1c, 0xe6, 0x82, 0x00, 0xf8, 0xe6, 0xf8, 0xad, 0x16, 0x19, 0x47,
0x36, 0x0b, 0xc8, 0xd4, 0x9c, 0x0d, 0x68, 0x00, 0x9b, 0x1c, 0x46, 0x44,
0xf9, 0xb3, 0xf3, 0xfb, 0x6d, 0xdf, 0xd9, 0x2e, 0xf9, 0x2d, 0xe6, 0x2d,
0x41, 0xd4, 0x59, 0xd2, 0x9d, 0x81, 0xbf, 0xae, 0xf3, 0x97, 0x0a, 0x3a,
0x39, 0xd2, 0x5b, 0x26, 0x62, 0xec, 0xb0, 0x3b, 0x2d, 0xa7, 0xb6, 0x83,
0x02, 0xfa, 0xa6, 0xdd, 0x98, 0xd9, 0x5a, 0x14, 0x3c, 0xc8, 0xc1, 0xcb,
0x6a, 0xdd, 0xa7, 0x6d, 0x2e, 0xe9, 0xc3, 0x72, 0x3f, 0xaf, 0x95, 0xa2,
0x9c, 0xdc, 0x3e, 0x96, 0x8b, 0x68, 0x21, 0xa9, 0x1c, 0x05, 0x1c, 0xa2,
0x80, 0xa8, 0x66, 0x69, 0x71, 0x0a, 0x1a, 0xd7, 0xa4, 0x4b, 0xf9, 0x21,
0x80, 0x27, 0x46, 0x0d, 0xf6, 0x94, 0xe2, 0xe9, 0x27, 0x03, 0x96, 0xdf,
0x22, 0x19, 0x63, 0xf2, 0x1e, 0xe6, 0xaa, 0x22, 0x0a, 0x5e, 0xe4, 0xa4,
0xd0, 0xfe, 0xb3, 0xd5, 0x3e, 0xb5, 0x73, 0x2f, 0x8f, 0x91, 0xe9, 0xa9,
0x6b, 0x3b, 0x8b, 0xe2, 0x84, 0xc5, 0x13, 0x39, 0xea, 0x28, 0x4d, 0x4d,
0x0e, 0xdd, 0x55, 0xb6, 0xad, 0x56, 0xf7, 0x41, 0x64, 0x20, 0xe0, 0x5e,
0x05, 0x9f, 0x97, 0x34, 0xa9, 0x6b, 0xe2, 0x5a, 0xa4, 0x45, 0x60, 0xdb,
0xa8, 0xc3, 0x87, 0x55, 0xa4, 0x2a, 0x82, 0xbd, 0x7f, 0x88, 0xed, 0xd1,
0x9d, 0xf3, 0x46, 0xa6, 0x67, 0xb3, 0x3b, 0x81, 0x14, 0xc7, 0x6a, 0x88,
0x38, 0xc4, 0x23, 0xd8, 0x24, 0xa5, 0x0b, 0x23, 0x25, 0x1a, 0x08, 0x81,
0x36, 0xd6, 0xe8, 0xf4, 0x75, 0x29, 0x9d, 0x2a, 0xfd, 0x46, 0xce, 0xa5,
0x1b, 0x5c, 0xbd, 0xf7, 0x89, 0xa5, 0x72, 0x12, 0x5c, 0xd2, 0x4f, 0xbb,
0x81, 0x3b, 0x38, 0x7a, 0x10, 0xcd, 0x2a, 0x30, 0xe3, 0x44, 0x76, 0x34,
0xab, 0x34, 0x08, 0xf9, 0x6b, 0x9c, 0xf3, 0xd9, 0x88, 0x96, 0xd4, 0x05,
0xf3, 0xf5, 0x40, 0xd9, 0xc5, 0x79, 0x62, 0x76, 0x0f, 0xcd, 0x17, 0x7c,
0xdd, 0x10, 0x1e, 0xb8, 0xa4, 0x14, 0x8b, 0x9c, 0x29, 0xce, 0xd5, 0xea,
0xd6, 0x45, 0xa9, 0x5b, 0x69, 0x8f, 0x1c, 0xdc, 0x6e, 0x1d, 0xb6, 0x67,
0x8b, 0x85, 0x07, 0x41, 0x86, 0x08, 0x0d, 0x68, 0xd1, 0x3c, 0xd3, 0x7e,
0x07, 0xb1, 0x6d, 0xe3, 0x70, 0xcd, 0x9a, 0xfb, 0x9b, 0x25, 0x56, 0x4a,
0x73, 0xa3, 0x0e, 0x2a, 0xf8, 0x08, 0x5e, 0xa3, 0x7d, 0x31, 0x0c, 0x47,
0x4f, 0x0e, 0x67, 0xac, 0x00, 0xca, 0x99, 0x2a, 0x52, 0x96, 0xfa, 0xed,
0xad, 0x7a, 0xa0, 0x6e, 0xcd, 0x79, 0x0f, 0x1e, 0x3d, 0x42, 0x65, 0x58,
0xfa, 0x98, 0x38, 0x3e, 0x3c, 0xd2, 0xed, 0x48, 0x30, 0x1a, 0x1b, 0x0a,
0x11, 0x61, 0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72,
0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x06, 0x78, 0x38, 0x36, 0x2d,
0x36, 0x34, 0x1a, 0x16, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e,
0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x06, 0x47, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x1a, 0x17, 0x0a, 0x0a, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f,
0x6e, 0x61, 0x6d, 0x65, 0x12, 0x09, 0x43, 0x68, 0x72, 0x6f, 0x6d, 0x65,
0x43, 0x44, 0x4d, 0x1a, 0x16, 0x0a, 0x0d, 0x70, 0x6c, 0x61, 0x74, 0x66,
0x6f, 0x72, 0x6d, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x05, 0x4c, 0x69,
0x6e, 0x75, 0x78, 0x1a, 0x24, 0x0a, 0x14, 0x77, 0x69, 0x64, 0x65, 0x76,
0x69, 0x6e, 0x65, 0x5f, 0x63, 0x64, 0x6d, 0x5f, 0x76, 0x65, 0x72, 0x73,
0x69, 0x6f, 0x6e, 0x12, 0x0c, 0x34, 0x2e, 0x31, 0x30, 0x2e, 0x31, 0x36,
0x38, 0x36, 0x2e, 0x39, 0x36, 0x32, 0x08, 0x08, 0x00, 0x10, 0x00, 0x18,
0x01, 0x20, 0x00, 0x12, 0x3f, 0x0a, 0x3d, 0x0a, 0x27, 0x08, 0x01, 0x12,
0x01, 0x30, 0x1a, 0x0d, 0x77, 0x69, 0x64, 0x65, 0x76, 0x69, 0x6e, 0x65,
0x5f, 0x74, 0x65, 0x73, 0x74, 0x22, 0x0a, 0x32, 0x30, 0x31, 0x35, 0x5f,
0x74, 0x65, 0x61, 0x72, 0x73, 0x2a, 0x05, 0x41, 0x55, 0x44, 0x49, 0x4f,
0x10, 0x01, 0x1a, 0x10, 0x53, 0xbc, 0x88, 0x54, 0x04, 0xfc, 0x85, 0xbd,
0x75, 0xce, 0x15, 0x2a, 0x06, 0xb5, 0x1f, 0xc5, 0x18, 0x01, 0x20, 0xb2,
0x88, 0xc6, 0xfa, 0x05, 0x30, 0x15,
0x0a, 0x9f, 0x0b, 0x08, 0x01, 0x12, 0x83, 0x0a, 0x0a, 0xc3, 0x02, 0x08,
0x02, 0x12, 0x10, 0xa6, 0x06, 0x35, 0x4e, 0x21, 0xbd, 0xa5, 0x68, 0xfe,
0x68, 0x8d, 0x2b, 0x43, 0x43, 0x43, 0x0a, 0x18, 0xd8, 0xd2, 0xda, 0x85,
0x06, 0x22, 0x8c, 0x01, 0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0x9c,
0x54, 0xb3, 0x2f, 0x66, 0xe3, 0xd2, 0xb8, 0xee, 0x22, 0xa0, 0x3c, 0x76,
0x06, 0x67, 0xd8, 0xc1, 0xbc, 0xe6, 0xbe, 0x6f, 0xb3, 0x93, 0xee, 0xd4,
0xe6, 0xcb, 0x11, 0x00, 0xb5, 0x16, 0x49, 0xe1, 0x8e, 0xcc, 0xea, 0xbe,
0xc6, 0x45, 0x34, 0xfc, 0x13, 0xed, 0x0a, 0x90, 0x22, 0xe0, 0x6d, 0x6f,
0xaf, 0x64, 0xa8, 0xc2, 0x05, 0xf9, 0x2c, 0x51, 0x52, 0xd4, 0x42, 0x47,
0xfe, 0x03, 0x99, 0xf1, 0x03, 0x7e, 0x09, 0x08, 0x65, 0x50, 0xb9, 0x36,
0x8f, 0x62, 0xc5, 0x1a, 0x18, 0x27, 0xb8, 0xf3, 0x89, 0x53, 0x5a, 0x9d,
0xfb, 0xe4, 0x9b, 0xb4, 0xea, 0x48, 0x7c, 0x0f, 0x30, 0x02, 0x82, 0x6c,
0xf7, 0xb6, 0xf7, 0x82, 0x1f, 0xbb, 0x0b, 0x87, 0x95, 0xd0, 0xda, 0x7e,
0xb9, 0x0e, 0x58, 0xa3, 0x6d, 0xde, 0x50, 0x4d, 0xa0, 0x21, 0x1b, 0x72,
0xf3, 0x97, 0xbf, 0x98, 0xab, 0xb1, 0x5b, 0x02, 0x03, 0x01, 0x00, 0x01,
0x28, 0x93, 0xab, 0x01, 0x48, 0x01, 0x5a, 0x91, 0x01, 0x0a, 0x8c, 0x01,
0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xb5, 0xdf, 0x28, 0x81, 0xfc,
0x29, 0x80, 0xe4, 0xe6, 0x49, 0x6e, 0x62, 0xe5, 0xf3, 0x23, 0x99, 0x59,
0x54, 0x84, 0x1b, 0xf1, 0xde, 0x27, 0x8b, 0xe6, 0x22, 0xec, 0x02, 0x68,
0x58, 0x6e, 0x5b, 0x11, 0x90, 0x7a, 0xb3, 0xb3, 0x35, 0xab, 0x02, 0xb7,
0xf6, 0xd8, 0x74, 0xef, 0x90, 0xd8, 0xab, 0xb1, 0x44, 0x04, 0x7e, 0x15,
0x02, 0xac, 0x9d, 0x1e, 0x4e, 0xef, 0x9c, 0xdf, 0x31, 0xdb, 0x7a, 0x03,
0xd6, 0xa9, 0xfe, 0x6e, 0xd6, 0x4e, 0x5d, 0xaf, 0xdd, 0x63, 0x62, 0x5e,
0xa9, 0x56, 0x82, 0x2c, 0x09, 0x26, 0xc5, 0x61, 0x58, 0xf2, 0x04, 0xd5,
0x0a, 0x40, 0x22, 0xb7, 0x9a, 0x46, 0x4d, 0x88, 0x2c, 0x75, 0x8f, 0xc1,
0x18, 0x6a, 0xf8, 0xf6, 0x5d, 0xb1, 0x77, 0x24, 0xcb, 0x0e, 0x0f, 0x99,
0x38, 0x7c, 0x0a, 0x4a, 0xd1, 0xda, 0xef, 0x35, 0x80, 0x60, 0x56, 0xbc,
0xe9, 0x16, 0xf7, 0x02, 0x03, 0x01, 0x00, 0x01, 0x10, 0x01, 0x12, 0x80,
0x02, 0x9b, 0x38, 0xd0, 0x18, 0xc4, 0xff, 0x1c, 0xd8, 0x70, 0x6e, 0x12,
0xb2, 0x84, 0xfd, 0x61, 0x0a, 0x95, 0x2f, 0xe5, 0x77, 0x36, 0x38, 0xeb,
0x9c, 0x3d, 0xa3, 0x97, 0xe0, 0x71, 0x2e, 0x04, 0xa0, 0x1b, 0xff, 0x31,
0x97, 0x43, 0x31, 0xe5, 0xac, 0x9f, 0xfa, 0xc8, 0xa7, 0xe2, 0x11, 0x2a,
0x68, 0x06, 0x9e, 0x05, 0x68, 0xa7, 0x12, 0x13, 0x72, 0x3c, 0xb0, 0x93,
0x46, 0x4a, 0x85, 0xbe, 0x45, 0x39, 0xd1, 0x8f, 0xaf, 0xb1, 0x97, 0x47,
0x22, 0x55, 0x44, 0x1d, 0xac, 0x64, 0x3b, 0xe1, 0x38, 0x29, 0x11, 0x9c,
0xda, 0x56, 0x2f, 0x28, 0x25, 0x91, 0x4e, 0x5e, 0x59, 0xe4, 0xc9, 0x1c,
0xf0, 0x8b, 0xda, 0x52, 0x8d, 0x40, 0xe6, 0xe0, 0x89, 0xf8, 0xa1, 0x16,
0x29, 0x1b, 0xfa, 0xaf, 0x18, 0xf6, 0x87, 0x94, 0x1b, 0x17, 0x8f, 0x49,
0xc6, 0x76, 0x24, 0x13, 0xd8, 0x5e, 0x95, 0x08, 0x47, 0x7b, 0xda, 0x11,
0x41, 0xf9, 0x5b, 0x4a, 0x39, 0x09, 0x76, 0x06, 0xd2, 0xd9, 0xdc, 0x57,
0x05, 0xbc, 0x97, 0x36, 0xfb, 0xaa, 0xfa, 0x92, 0x65, 0x2f, 0x88, 0x68,
0x11, 0xea, 0x07, 0x3e, 0x0a, 0x0e, 0xce, 0x66, 0xba, 0xac, 0x99, 0x01,
0xf9, 0xe8, 0x75, 0x92, 0xdc, 0x48, 0xef, 0x55, 0xf5, 0x5c, 0x2b, 0x3c,
0x58, 0xf0, 0x1a, 0xf3, 0xb8, 0xa7, 0x7a, 0xba, 0x69, 0x54, 0xd1, 0xee,
0x7f, 0x88, 0xc6, 0x7e, 0xf6, 0xed, 0x5e, 0x52, 0x9d, 0x94, 0x98, 0x9f,
0x75, 0xd9, 0x1f, 0xa2, 0x65, 0xb2, 0x0c, 0xd7, 0x66, 0x4f, 0xb0, 0xfe,
0xc6, 0xbb, 0x2f, 0x0d, 0x7b, 0x64, 0x38, 0x47, 0x56, 0x53, 0x3b, 0x24,
0xc0, 0x80, 0xf9, 0x78, 0x98, 0xe0, 0x38, 0xb2, 0x66, 0x40, 0xfe, 0x72,
0x0f, 0xc5, 0x5a, 0x48, 0x43, 0xb1, 0x22, 0xd7, 0xcb, 0x19, 0x2f, 0xf8,
0x81, 0x17, 0x6b, 0x7c, 0x09, 0x1a, 0xb7, 0x05, 0x0a, 0xb1, 0x02, 0x08,
0x01, 0x12, 0x10, 0x6a, 0x77, 0x52, 0x7d, 0x1e, 0x88, 0x1c, 0x88, 0xef,
0xcf, 0x40, 0x9e, 0xba, 0x65, 0xad, 0xa0, 0x18, 0xe8, 0xde, 0x84, 0x82,
0x06, 0x22, 0x8e, 0x02, 0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01,
0x00, 0xb6, 0xc1, 0x1a, 0x4a, 0x1c, 0x69, 0x0d, 0xa5, 0x59, 0xc4, 0x94,
0xcd, 0x19, 0x64, 0x85, 0xaa, 0x1e, 0x48, 0x3f, 0x9d, 0xfa, 0x3a, 0x70,
0x73, 0xc1, 0xb8, 0xda, 0x0c, 0xba, 0xd6, 0x51, 0xbe, 0x90, 0x73, 0xd2,
0x7f, 0xd6, 0x5f, 0xbf, 0xf5, 0xb5, 0x34, 0xc1, 0x2c, 0x48, 0xa0, 0x21,
0x55, 0x0f, 0x6b, 0xdb, 0x0a, 0xfa, 0xe5, 0xa1, 0x3e, 0xb1, 0x1b, 0x19,
0x3d, 0xd6, 0x35, 0x87, 0x26, 0x2f, 0x48, 0x04, 0x06, 0x11, 0xc1, 0xb8,
0x6d, 0x0d, 0x30, 0x4e, 0xff, 0xe2, 0x2d, 0xb7, 0xc1, 0x50, 0xaf, 0xc2,
0x90, 0x20, 0xfc, 0x6f, 0x25, 0xac, 0xd7, 0xcd, 0x2b, 0x34, 0x54, 0xbc,
0xcc, 0xed, 0xdb, 0x77, 0xab, 0xf2, 0x99, 0xbe, 0xc8, 0x71, 0x62, 0x6a,
0xed, 0x09, 0xce, 0x9d, 0xd3, 0xec, 0xef, 0x00, 0x73, 0xbc, 0x06, 0x9b,
0xd2, 0x7a, 0xf5, 0x71, 0xfa, 0xa7, 0xd1, 0xd4, 0x33, 0xb6, 0x05, 0x4b,
0x3d, 0x70, 0xdb, 0xa3, 0xd0, 0x99, 0x88, 0x27, 0x86, 0x41, 0x83, 0xd0,
0x13, 0xa6, 0xf0, 0x64, 0xd9, 0xd4, 0x87, 0x6a, 0x6b, 0x44, 0x33, 0x5b,
0xa4, 0x1f, 0x23, 0x2e, 0xba, 0x6e, 0x74, 0xc3, 0x52, 0x92, 0xe8, 0xdc,
0x76, 0xdb, 0x18, 0x75, 0x51, 0x15, 0x86, 0x26, 0x34, 0x39, 0xf6, 0xbe,
0x61, 0xf0, 0xe6, 0x24, 0x43, 0x1e, 0x11, 0x0f, 0x8c, 0x02, 0xba, 0xd8,
0x81, 0x47, 0xf7, 0xe4, 0xc0, 0x86, 0x73, 0xa5, 0xaa, 0x1d, 0xf5, 0x29,
0x27, 0x09, 0x66, 0xab, 0x1e, 0xe4, 0x37, 0x25, 0x67, 0x2d, 0x8c, 0x06,
0x0a, 0xb3, 0xb2, 0xf2, 0x9c, 0xaa, 0x4c, 0x60, 0x38, 0xe6, 0xe4, 0x28,
0x65, 0x49, 0x5d, 0xf6, 0xb4, 0x1e, 0x52, 0xc3, 0x7d, 0x39, 0x35, 0x8d,
0x77, 0x30, 0x58, 0x75, 0x83, 0x92, 0x47, 0x8c, 0xa1, 0xdb, 0x91, 0x84,
0xf1, 0x49, 0x1a, 0x16, 0xd9, 0x02, 0x03, 0x01, 0x00, 0x01, 0x28, 0x93,
0xab, 0x01, 0x48, 0x01, 0x12, 0x80, 0x03, 0x5d, 0x5b, 0xb2, 0xa3, 0x4b,
0x3e, 0x36, 0x8d, 0x63, 0x44, 0xfb, 0x22, 0x2e, 0xee, 0xb3, 0x1a, 0x67,
0xf3, 0xf8, 0xab, 0xa4, 0x7f, 0x87, 0x26, 0xd9, 0xbc, 0xf7, 0xdf, 0x79,
0xff, 0xf0, 0x10, 0xe1, 0x21, 0x34, 0xb7, 0x44, 0xf8, 0xcb, 0x38, 0xa3,
0xbb, 0x60, 0xa8, 0x4c, 0x2a, 0xda, 0xb3, 0xeb, 0x7f, 0x25, 0x7a, 0xb3,
0xe4, 0x4f, 0x43, 0xca, 0x6d, 0x9c, 0xe9, 0x5f, 0xa1, 0x4b, 0xde, 0x90,
0x93, 0x9d, 0x32, 0x0a, 0x30, 0x43, 0xff, 0x27, 0x2d, 0xa1, 0xea, 0x1e,
0x35, 0x11, 0xbd, 0xf6, 0x16, 0x55, 0xec, 0x8f, 0xf1, 0x28, 0x3f, 0x86,
0x86, 0x31, 0x4c, 0x4f, 0x34, 0x70, 0xf4, 0x37, 0xfc, 0x0c, 0x5b, 0xd3,
0xe9, 0x12, 0x6c, 0x42, 0xb8, 0xf2, 0x54, 0x42, 0x48, 0xe7, 0x08, 0x26,
0xfd, 0x5b, 0xe0, 0xe8, 0xe3, 0x95, 0x11, 0x88, 0xba, 0xfe, 0xaa, 0xaa,
0x92, 0x30, 0xc5, 0x35, 0x18, 0xd7, 0xf2, 0x4a, 0x26, 0xf6, 0xfb, 0x15,
0x44, 0xe6, 0xa2, 0x47, 0x4b, 0x18, 0xd1, 0x97, 0x1c, 0x42, 0x31, 0x67,
0x82, 0x59, 0x2d, 0x58, 0x19, 0x29, 0x78, 0x27, 0xed, 0xf8, 0x37, 0x2b,
0x07, 0xbb, 0x75, 0xea, 0xb4, 0xbd, 0x2f, 0xa2, 0xdd, 0x33, 0xc7, 0x5c,
0x1a, 0xa8, 0x54, 0x6d, 0x2a, 0x3c, 0xb8, 0xd9, 0xf6, 0xbc, 0xa8, 0xd4,
0x4d, 0x34, 0xbb, 0xa6, 0x43, 0xad, 0x91, 0xac, 0xac, 0x7d, 0x10, 0x29,
0xe6, 0xf9, 0x41, 0xc9, 0xa2, 0xe5, 0xb9, 0x34, 0x39, 0x5a, 0x1f, 0xb7,
0x8b, 0x2a, 0x19, 0x97, 0xa7, 0x31, 0x95, 0x03, 0x99, 0x16, 0xa2, 0x83,
0xf9, 0xd8, 0xbb, 0x87, 0xab, 0x54, 0xc7, 0x3a, 0x88, 0x26, 0x68, 0xbd,
0xb5, 0x00, 0xc8, 0x31, 0x63, 0x30, 0x4c, 0x09, 0x46, 0xb8, 0x92, 0xd7,
0xe8, 0xf7, 0xe1, 0x41, 0xb2, 0x1a, 0x00, 0x7a, 0xce, 0x15, 0x1e, 0x87,
0x41, 0x00, 0x7e, 0x62, 0x3a, 0xc8, 0xd5, 0xd4, 0x97, 0xf4, 0x98, 0x10,
0xf3, 0x86, 0x8d, 0xa7, 0x99, 0xb8, 0x06, 0xc9, 0x21, 0xcf, 0x03, 0x71,
0x90, 0xe4, 0x71, 0x0d, 0x48, 0xed, 0xa8, 0x23, 0x6c, 0x7b, 0x31, 0xa5,
0xfe, 0x05, 0x5e, 0x3c, 0x02, 0xe4, 0x32, 0xce, 0xc6, 0x5a, 0x07, 0xd4,
0xbe, 0x73, 0x7e, 0xe2, 0x8e, 0x94, 0x52, 0xae, 0x25, 0x59, 0x09, 0xc0,
0x72, 0x2a, 0xd4, 0xb6, 0x52, 0xed, 0x44, 0x5b, 0x8a, 0xa5, 0xaf, 0xc8,
0xfd, 0x94, 0x51, 0xdb, 0x00, 0x23, 0x61, 0xe6, 0xf4, 0x0f, 0xe2, 0xd1,
0x0f, 0xa4, 0xc0, 0xd3, 0x22, 0x99, 0x0e, 0xa8, 0xf3, 0xe6, 0xa4, 0x2a,
0xfd, 0xf2, 0x6b, 0x46, 0x41, 0x99, 0xf3, 0xb3, 0x29, 0xa4, 0x9f, 0xb8,
0x52, 0xfd, 0xad, 0x27, 0x39, 0x3a, 0x4c, 0xe2, 0xcb, 0xd6, 0x11, 0xa5,
0x7a, 0xc7, 0x79, 0x46, 0x96, 0xb7, 0x4a, 0x1a, 0x1b, 0x0a, 0x11, 0x61,
0x72, 0x63, 0x68, 0x69, 0x74, 0x65, 0x63, 0x74, 0x75, 0x72, 0x65, 0x5f,
0x6e, 0x61, 0x6d, 0x65, 0x12, 0x06, 0x78, 0x38, 0x36, 0x2d, 0x36, 0x34,
0x1a, 0x16, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79, 0x5f,
0x6e, 0x61, 0x6d, 0x65, 0x12, 0x06, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
0x1a, 0x17, 0x0a, 0x0a, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x6e, 0x61,
0x6d, 0x65, 0x12, 0x09, 0x43, 0x68, 0x72, 0x6f, 0x6d, 0x65, 0x43, 0x44,
0x4d, 0x1a, 0x16, 0x0a, 0x0d, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72,
0x6d, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x05, 0x4c, 0x69, 0x6e, 0x75,
0x78, 0x1a, 0x23, 0x0a, 0x14, 0x77, 0x69, 0x64, 0x65, 0x76, 0x69, 0x6e,
0x65, 0x5f, 0x63, 0x64, 0x6d, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
0x6e, 0x12, 0x0b, 0x34, 0x2e, 0x31, 0x30, 0x2e, 0x30, 0x2e, 0x32, 0x30,
0x32, 0x30, 0x32, 0x0a, 0x08, 0x01, 0x10, 0x00, 0x18, 0x01, 0x20, 0x00,
0x28, 0x10, 0x12, 0x3c, 0x0a, 0x3a, 0x0a, 0x24, 0x08, 0x01, 0x12, 0x01,
0x35, 0x1a, 0x0d, 0x77, 0x69, 0x64, 0x65, 0x76, 0x69, 0x6e, 0x65, 0x5f,
0x74, 0x65, 0x73, 0x74, 0x22, 0x0a, 0x32, 0x30, 0x31, 0x35, 0x5f, 0x74,
0x65, 0x61, 0x72, 0x73, 0x2a, 0x02, 0x53, 0x44, 0x10, 0x01, 0x1a, 0x10,
0x0b, 0x66, 0x84, 0x0b, 0x99, 0x6a, 0x03, 0xac, 0xdc, 0x64, 0x29, 0x5f,
0xb4, 0xbf, 0xbc, 0x3b, 0x18, 0x01, 0x20, 0xe4, 0xa4, 0xd9, 0x86, 0x06,
0x30, 0x15, 0x38, 0xd0, 0xd7, 0x8e, 0x0b,
};
const uint8_t kCoreMessage[] = {
0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0xc8, 0x00, 0x05, 0x00, 0x10,
0x01, 0x63, 0xab, 0xd0, 0x82, 0x87, 0xf6, 0xac, 0x00, 0x00, 0x00, 0x57,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x00, 0x50,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x51, 0x80,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x51, 0x80, 0x00, 0x00, 0x00, 0x00,
0x01, 0xe1, 0x33, 0x80, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xbf,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0xd1, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x00, 0xe3, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x01, 0x27, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x01, 0x39,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x01, 0x4b, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x01, 0x8f, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x01, 0xa1, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x01, 0xb3,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x01, 0xfa,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0x0c, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x02, 0x1e, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x02, 0x62, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0x74,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0x86, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0xca, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x02, 0xdc, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0xee,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x03, 0x32,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x03, 0x44, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x03, 0x56, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x03, 0x9a, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x03, 0xac,
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x03, 0xbe, 0x00, 0x00, 0x00, 0x10,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0f,
0x00, 0x00, 0x00, 0x10, 0x1a, 0xe1, 0x53, 0x83, 0x05, 0x9f, 0x0d, 0xe1,
0x9c, 0x7c, 0x45, 0xd3, 0xf0, 0x2c, 0x2b, 0xe2, 0xca, 0xdf, 0x22, 0x34,
0x38, 0xea, 0x2d, 0xf4, 0x35, 0x6a, 0x96, 0xac, 0x90, 0x57, 0x05, 0xb7,
};
const size_t kMessageSize = sizeof(kMessage);
const size_t kLicenseRequestSize = sizeof(kLicenseRequest);
const size_t kSignatureSize = sizeof(kSignature);
const size_t kSessionKeySize = sizeof(kSessionKey);
// The pointer for core message must be non-null, but the length needs to be
// zero.
const uint8_t kCoreMessage[] = {0};
const size_t kCoreMessageSize = 0;
const size_t kCoreMessageSize = sizeof(kCoreMessage);
const uint8_t kPlaintext[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

5
whitebox/api/license_whitebox_verify_benchmark.cc
View File

@@ -29,7 +29,8 @@ class LicenseWhiteboxVerifyBenchmark : public LicenseWhiteboxBenchmark {
ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK);
const auto license = CreateLicense(WB_LICENSE_KEY_MODE_DUAL_KEY);
const auto license = CreateLicense(WB_LICENSE_KEY_MODE_DUAL_KEY, 1,
SecurityLevel::kSoftwareSecureCrypto);
ASSERT_EQ(WB_License_ProcessLicenseResponse(
whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY,
license.core_message.data(), license.core_message.size(),
@@ -49,7 +50,7 @@ class LicenseWhiteboxVerifyBenchmark : public LicenseWhiteboxBenchmark {
};
TEST_F(LicenseWhiteboxVerifyBenchmark, VerifyRenewalResponse) {
constexpr size_t kIterations = 100;
constexpr size_t kIterations = 10;
Timer timer;
Sampler sampler;

4
whitebox/api/license_whitebox_verify_renewal_response_test.cc
View File

@@ -32,7 +32,7 @@ class LicenseWhiteboxVerifyRenewalResponseTest
builder.SetSettings(settings);
builder.AddSigningKey(signing_key);
builder.AddStubbedContentKey();
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
auto server = TestServer::CreateDualKey();
@@ -229,7 +229,7 @@ TEST_F(LicenseWhiteboxVerifyRenewalResponseTest,
// Create a license with no signing key and one content key (every license
// must have a content key).
widevine::TestLicenseBuilder builder;
builder.AddStubbedContentKey();
builder.AddContentKey(golden_data_.CBCContent().software_crypto_key);
auto server = TestServer::CreateDualKey();

48
whitebox/api/remote_attestation_and_verification_test.cc
View File

@@ -116,25 +116,27 @@ class RemoteAttestationAndVerificationTest
mode_ = DisableOverride(key, mode_);
}
content_ = golden_data_.CBCContent();
switch (key) {
case Key::kCrypto:
key_ = golden_data_.CBCCryptoKey();
key_ = content_.software_crypto_key;
break;
case Key::kDecode:
key_ = golden_data_.CBCDecodeKey();
key_ = content_.software_decode_key;
break;
case Key::kHardware:
key_ = golden_data_.CBCHardwareKey();
key_ = content_.hardware_key;
break;
}
}
WB_Result LoadLicense(const GoldenData::Key& key,
WB_Result LoadLicense(const ContentKeyData& key,
RemoteAttestation remote_attestation,
VerificationStatus verification_status,
Padding padding) {
TestLicenseBuilder builder;
builder.AddContentKey(key.level, key.id, key.content->key);
builder.AddContentKey(key);
builder.GetSettings().remote_attestation = remote_attestation;
builder.GetSettings().verification_status = verification_status;
builder.GetSettings().padding = padding;
@@ -153,30 +155,30 @@ class RemoteAttestationAndVerificationTest
license.request.size());
}
WB_Result Decrypt(const GoldenData::Key& key) {
size_t plaintext_size = key.content->ciphertext.size();
WB_Result Decrypt(const GoldenData::Content& content,
const ContentKeyData& key) {
size_t plaintext_size = content.ciphertext.size();
plaintext_.resize(plaintext_size);
auto result = WB_License_Decrypt(
whitebox_, WB_CIPHER_MODE_CBC, key.id.data(), key.id.size(),
key.content->ciphertext.data(), key.content->ciphertext.size(),
key.content->iv.data(), key.content->iv.size(), plaintext_.data(),
&plaintext_size);
content.ciphertext.data(), content.ciphertext.size(), content.iv.data(),
content.iv.size(), plaintext_.data(), &plaintext_size);
plaintext_.resize(plaintext_size);
return result;
}
WB_Result MaskedDecrypt(const GoldenData::Key& key) {
size_t masked_text_size = key.content->ciphertext.size();
WB_Result MaskedDecrypt(const GoldenData::Content& content,
const ContentKeyData& key) {
size_t masked_text_size = content.ciphertext.size();
std::vector<uint8_t> masked_text(masked_text_size);
auto result = WB_License_MaskedDecrypt(
whitebox_, WB_CIPHER_MODE_CBC, key.id.data(), key.id.size(),
key.content->ciphertext.data(), key.content->ciphertext.size(),
key.content->iv.data(), key.content->iv.size(), masked_text.data(),
&masked_text_size);
content.ciphertext.data(), content.ciphertext.size(), content.iv.data(),
content.iv.size(), masked_text.data(), &masked_text_size);
masked_text.resize(masked_text_size);
@@ -210,11 +212,13 @@ class RemoteAttestationAndVerificationTest
}
Padding padding_;
GoldenData::Key key_;
RemoteAttestation ra_;
VerificationStatus vmp_;
Mode mode_;
GoldenData::Content content_;
ContentKeyData key_;
// This is the buffer used to store the output of each decrypt and unmask
// call.
std::vector<uint8_t> plaintext_;
@@ -225,21 +229,21 @@ TEST_P(RemoteAttestationAndVerificationTest, Decrypt) {
switch (mode_) {
case Mode::kDecryptPass:
ASSERT_EQ(Decrypt(key_), WB_RESULT_OK);
ASSERT_EQ(plaintext_, key_.content->plaintext);
ASSERT_EQ(Decrypt(content_, key_), WB_RESULT_OK);
ASSERT_EQ(plaintext_, content_.plaintext);
break;
case Mode::kDecryptFail:
ASSERT_NE(Decrypt(key_), WB_RESULT_OK);
ASSERT_NE(Decrypt(content_, key_), WB_RESULT_OK);
break;
case Mode::kMaskedDecryptPass:
ASSERT_EQ(MaskedDecrypt(key_), WB_RESULT_OK);
ASSERT_EQ(plaintext_, key_.content->plaintext);
ASSERT_EQ(MaskedDecrypt(content_, key_), WB_RESULT_OK);
ASSERT_EQ(plaintext_, content_.plaintext);
break;
case Mode::kMaskedDecryptFail:
ASSERT_NE(MaskedDecrypt(key_), WB_RESULT_OK);
ASSERT_NE(MaskedDecrypt(content_, key_), WB_RESULT_OK);
break;
}
}

8
whitebox/api/test_key_types.h
View File

@@ -30,6 +30,14 @@ enum class SecurityLevel {
kUndefined,
};
struct ContentKeyData {
// The unique key id for this key. Any instance with this id should contain
// the same level and key as this.
KeyId id;
SecurityLevel level;
AesKey key;
};
} // namespace widevine
#endif // WHITEBOX_API_TEST_KEY_TYPES_H_

20
whitebox/api/test_license_builder.cc
View File

@@ -236,7 +236,7 @@ std::vector<uint8_t> GetPadding(TestLicenseBuilder::Padding padding) {
return {};
}
void AddContentKeyToContainer(const TestLicenseBuilder::ContentKey& key_data,
void AddContentKeyToContainer(const ContentKeyData& key_data,
const TestLicenseBuilder::Settings& settings,
const std::string& container_key,
video_widevine::License_KeyContainer* container) {
@@ -414,22 +414,8 @@ void TestLicenseBuilder::AddSigningKey(const SigningKey& key) {
signing_keys_.push_back(key);
}
void TestLicenseBuilder::AddStubbedContentKey() {
content_keys_.emplace_back();
auto& key_data = content_keys_.back();
key_data.level = SecurityLevel::kSoftwareSecureCrypto;
key_data.id = {0, 0, 0, 0};
key_data.key = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
}
void TestLicenseBuilder::AddContentKey(SecurityLevel level,
const KeyId& id,
const AesKey& key) {
content_keys_.emplace_back();
auto& key_data = content_keys_.back();
key_data.level = level;
key_data.id = id;
key_data.key = key;
void TestLicenseBuilder::AddContentKey(const ContentKeyData& key) {
content_keys_.push_back(key);
}
void TestLicenseBuilder::AddOperatorSessionKey(const KeyId& id) {

25
whitebox/api/test_license_builder.h
View File

@@ -9,7 +9,7 @@
#include "api/test_key_types.h"
#include "api/test_server.h"
#include "cdm/protos/license_protocol.pb.h"
#include "license_protocol.pb.h"
namespace widevine {
@@ -28,21 +28,6 @@ struct License {
class TestLicenseBuilder {
public:
struct ContentKey {
KeyId id;
AesKey key;
// Default to the security level being undefined in the key container. When
// undefined, the key should be treated as if it is "software secure
// crypto".
//
// However, when we use the key control block, the security level in the key
// container does not matter as the key control block will always have the
// security level.
SecurityLevel level = SecurityLevel::kUndefined;
};
// Signing keys must be 512 bits (64 bytes).
using SigningKey = std::array<uint8_t, 64>;
@@ -125,11 +110,7 @@ class TestLicenseBuilder {
void AddSigningKey(const SigningKey& key);
// Add a content key so that there is some key in the license. This should not
// be used with AddContentKey().
void AddStubbedContentKey();
void AddContentKey(SecurityLevel level, const KeyId& id, const AesKey& key);
void AddContentKey(const ContentKeyData& key);
// The key id will matter as we will need to reference it, but the key won't
// matter since we are only using it as a means to verify that a non-content
@@ -156,7 +137,7 @@ class TestLicenseBuilder {
Settings settings_;
std::vector<ContentKey> content_keys_;
std::vector<ContentKeyData> content_keys_;
std::vector<SigningKey> signing_keys_;
std::vector<KeyId> operator_session_keys_;
};

284
whitebox/api/test_license_whitebox_keys_uat.cc
View File

@@ -2,164 +2,166 @@
#include "api/test_license_whitebox_keys.h"
// When the license response was collected for the UAT tests, the license server
// only supported a single key. In order for the UAT tests to work, the
// encryption and signing keys must be the same key.
namespace widevine {
namespace {
constexpr uint8_t kDevicePublicKey[] = {
0x30, 0x82, 0x01, 0x0a, 0x02, 0x82, 0x01, 0x01, 0x00, 0xae, 0xa6, 0xa8,
0xea, 0xdd, 0xac, 0x6f, 0xb4, 0x41, 0x47, 0xcb, 0x18, 0x81, 0xeb, 0xdf,
0x4f, 0x17, 0xf7, 0x17, 0xc0, 0xab, 0x6f, 0x47, 0x50, 0xbf, 0xe4, 0x8c,
0xc9, 0x45, 0x24, 0x5e, 0x1c, 0x2e, 0x86, 0x9f, 0xcb, 0x47, 0x05, 0xf9,
0xfe, 0x91, 0x90, 0xaf, 0xbd, 0x22, 0x14, 0x47, 0xa7, 0x34, 0x39, 0x79,
0x44, 0xe9, 0x92, 0x83, 0x4a, 0x80, 0xa8, 0x2a, 0xe6, 0x9f, 0x2b, 0xb7,
0xda, 0x2a, 0xd2, 0xae, 0x57, 0x5b, 0xfa, 0xb6, 0xdf, 0xca, 0x3e, 0xb1,
0xb8, 0x42, 0x0b, 0xde, 0x46, 0x36, 0xdb, 0x42, 0x33, 0x8b, 0xda, 0x5c,
0x60, 0x44, 0x7c, 0x99, 0xb4, 0x98, 0xb4, 0x1e, 0xd8, 0x25, 0x6d, 0x67,
0x84, 0xc9, 0x67, 0xde, 0x05, 0xe6, 0x06, 0xb5, 0xb5, 0xca, 0xbc, 0xfa,
0xb0, 0xa7, 0x46, 0x29, 0x3f, 0x63, 0x47, 0x9d, 0x70, 0x8d, 0xa2, 0x8d,
0x22, 0xc6, 0xeb, 0x06, 0xd4, 0x5c, 0x3b, 0x62, 0x98, 0xc7, 0xda, 0x16,
0x8f, 0x17, 0x59, 0xd5, 0xcb, 0xd1, 0x5d, 0xe3, 0xe1, 0x07, 0xe6, 0x97,
0x87, 0xf4, 0x22, 0x53, 0xfa, 0xf9, 0xa9, 0xf5, 0xeb, 0xd7, 0x55, 0xdf,
0x32, 0x2d, 0x4e, 0x07, 0x86, 0x25, 0x44, 0x93, 0xd6, 0xf7, 0xc6, 0xf9,
0x78, 0x91, 0x24, 0x1e, 0xd4, 0x6b, 0xe3, 0x4a, 0xff, 0x4a, 0x3a, 0xb9,
0x89, 0x90, 0x61, 0x87, 0xb9, 0x41, 0x45, 0x02, 0xfd, 0xd0, 0xc5, 0x5a,
0x98, 0x41, 0x88, 0xa4, 0xe3, 0xe2, 0xa2, 0x9d, 0x9a, 0x90, 0x3f, 0x44,
0x8e, 0x3a, 0xe1, 0xd1, 0xe9, 0x79, 0x9a, 0xc6, 0xe2, 0x7c, 0x8e, 0x9c,
0x3d, 0xb2, 0xe0, 0x26, 0x5a, 0x46, 0x13, 0xc8, 0x43, 0x9f, 0xf7, 0x51,
0x7e, 0xbb, 0x55, 0x6d, 0xcc, 0x97, 0x38, 0xdb, 0xa4, 0x4b, 0x96, 0x40,
0xe5, 0x2d, 0x8f, 0x43, 0xe3, 0x21, 0x15, 0xda, 0x34, 0x97, 0x7a, 0x9e,
0xbb, 0x02, 0x03, 0x01, 0x00, 0x01,
constexpr uint8_t kSigningPublicKey[] = {
0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0x9c, 0x54, 0xb3, 0x2f, 0x66,
0xe3, 0xd2, 0xb8, 0xee, 0x22, 0xa0, 0x3c, 0x76, 0x06, 0x67, 0xd8, 0xc1,
0xbc, 0xe6, 0xbe, 0x6f, 0xb3, 0x93, 0xee, 0xd4, 0xe6, 0xcb, 0x11, 0x00,
0xb5, 0x16, 0x49, 0xe1, 0x8e, 0xcc, 0xea, 0xbe, 0xc6, 0x45, 0x34, 0xfc,
0x13, 0xed, 0x0a, 0x90, 0x22, 0xe0, 0x6d, 0x6f, 0xaf, 0x64, 0xa8, 0xc2,
0x05, 0xf9, 0x2c, 0x51, 0x52, 0xd4, 0x42, 0x47, 0xfe, 0x03, 0x99, 0xf1,
0x03, 0x7e, 0x09, 0x08, 0x65, 0x50, 0xb9, 0x36, 0x8f, 0x62, 0xc5, 0x1a,
0x18, 0x27, 0xb8, 0xf3, 0x89, 0x53, 0x5a, 0x9d, 0xfb, 0xe4, 0x9b, 0xb4,
0xea, 0x48, 0x7c, 0x0f, 0x30, 0x02, 0x82, 0x6c, 0xf7, 0xb6, 0xf7, 0x82,
0x1f, 0xbb, 0x0b, 0x87, 0x95, 0xd0, 0xda, 0x7e, 0xb9, 0x0e, 0x58, 0xa3,
0x6d, 0xde, 0x50, 0x4d, 0xa0, 0x21, 0x1b, 0x72, 0xf3, 0x97, 0xbf, 0x98,
0xab, 0xb1, 0x5b, 0x02, 0x03, 0x01, 0x00, 0x01,
};
constexpr uint8_t kDevicePrivateKey[] = {
0x30, 0x82, 0x04, 0xa4, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
0xae, 0xa6, 0xa8, 0xea, 0xdd, 0xac, 0x6f, 0xb4, 0x41, 0x47, 0xcb, 0x18,
0x81, 0xeb, 0xdf, 0x4f, 0x17, 0xf7, 0x17, 0xc0, 0xab, 0x6f, 0x47, 0x50,
0xbf, 0xe4, 0x8c, 0xc9, 0x45, 0x24, 0x5e, 0x1c, 0x2e, 0x86, 0x9f, 0xcb,
0x47, 0x05, 0xf9, 0xfe, 0x91, 0x90, 0xaf, 0xbd, 0x22, 0x14, 0x47, 0xa7,
0x34, 0x39, 0x79, 0x44, 0xe9, 0x92, 0x83, 0x4a, 0x80, 0xa8, 0x2a, 0xe6,
0x9f, 0x2b, 0xb7, 0xda, 0x2a, 0xd2, 0xae, 0x57, 0x5b, 0xfa, 0xb6, 0xdf,
0xca, 0x3e, 0xb1, 0xb8, 0x42, 0x0b, 0xde, 0x46, 0x36, 0xdb, 0x42, 0x33,
0x8b, 0xda, 0x5c, 0x60, 0x44, 0x7c, 0x99, 0xb4, 0x98, 0xb4, 0x1e, 0xd8,
0x25, 0x6d, 0x67, 0x84, 0xc9, 0x67, 0xde, 0x05, 0xe6, 0x06, 0xb5, 0xb5,
0xca, 0xbc, 0xfa, 0xb0, 0xa7, 0x46, 0x29, 0x3f, 0x63, 0x47, 0x9d, 0x70,
0x8d, 0xa2, 0x8d, 0x22, 0xc6, 0xeb, 0x06, 0xd4, 0x5c, 0x3b, 0x62, 0x98,
0xc7, 0xda, 0x16, 0x8f, 0x17, 0x59, 0xd5, 0xcb, 0xd1, 0x5d, 0xe3, 0xe1,
0x07, 0xe6, 0x97, 0x87, 0xf4, 0x22, 0x53, 0xfa, 0xf9, 0xa9, 0xf5, 0xeb,
0xd7, 0x55, 0xdf, 0x32, 0x2d, 0x4e, 0x07, 0x86, 0x25, 0x44, 0x93, 0xd6,
0xf7, 0xc6, 0xf9, 0x78, 0x91, 0x24, 0x1e, 0xd4, 0x6b, 0xe3, 0x4a, 0xff,
0x4a, 0x3a, 0xb9, 0x89, 0x90, 0x61, 0x87, 0xb9, 0x41, 0x45, 0x02, 0xfd,
0xd0, 0xc5, 0x5a, 0x98, 0x41, 0x88, 0xa4, 0xe3, 0xe2, 0xa2, 0x9d, 0x9a,
0x90, 0x3f, 0x44, 0x8e, 0x3a, 0xe1, 0xd1, 0xe9, 0x79, 0x9a, 0xc6, 0xe2,
0x7c, 0x8e, 0x9c, 0x3d, 0xb2, 0xe0, 0x26, 0x5a, 0x46, 0x13, 0xc8, 0x43,
0x9f, 0xf7, 0x51, 0x7e, 0xbb, 0x55, 0x6d, 0xcc, 0x97, 0x38, 0xdb, 0xa4,
0x4b, 0x96, 0x40, 0xe5, 0x2d, 0x8f, 0x43, 0xe3, 0x21, 0x15, 0xda, 0x34,
0x97, 0x7a, 0x9e, 0xbb, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
0x00, 0x56, 0x73, 0xe7, 0x1f, 0xc3, 0xb5, 0x4c, 0xe2, 0x24, 0x82, 0x5e,
0x55, 0x76, 0x52, 0x85, 0x0a, 0xc8, 0xe9, 0x26, 0x57, 0xd8, 0x44, 0xd0,
0x3f, 0x77, 0x8d, 0xb1, 0xe7, 0x1b, 0x93, 0xc2, 0x06, 0x1f, 0x3d, 0xc2,
0xb1, 0xc4, 0x29, 0x80, 0x33, 0x74, 0x68, 0xf3, 0xa5, 0x22, 0xce, 0x79,
0x1d, 0x9a, 0x6b, 0x6c, 0xcd, 0x20, 0xf5, 0xc6, 0x89, 0xc5, 0x9f, 0xf9,
0x04, 0x89, 0xfc, 0x01, 0x19, 0x3c, 0xa3, 0x67, 0x6b, 0x94, 0xfb, 0x49,
0x35, 0x04, 0x0e, 0xfe, 0xb8, 0x1f, 0xf1, 0x72, 0x08, 0xbd, 0xb4, 0xd1,
0x53, 0x64, 0xc2, 0x25, 0x81, 0xfd, 0xc4, 0xd3, 0xed, 0x22, 0xbd, 0xde,
0x9a, 0xce, 0x04, 0x16, 0xff, 0x13, 0x17, 0x98, 0x3e, 0xc1, 0x3b, 0xc7,
0x0d, 0x03, 0x1b, 0x82, 0xd8, 0x99, 0x24, 0xd0, 0xdc, 0x30, 0xcf, 0xcd,
0x6e, 0x5e, 0x9d, 0xfd, 0x51, 0x1e, 0xb8, 0x4e, 0x7b, 0x54, 0x83, 0x9b,
0x4f, 0xf8, 0xa6, 0x03, 0xc1, 0x96, 0xf1, 0x6d, 0xc0, 0xa7, 0x17, 0xbd,
0xf1, 0x60, 0xcb, 0xe2, 0x05, 0xa5, 0x9b, 0x05, 0x2e, 0xaf, 0xdc, 0xa7,
0x88, 0xde, 0x53, 0x42, 0xa9, 0xf4, 0x0f, 0xae, 0xf9, 0x96, 0xe9, 0x2c,
0xa6, 0xe8, 0x9d, 0x2c, 0x6b, 0xbc, 0xd8, 0x0f, 0x09, 0x5f, 0x64, 0xb2,
0x21, 0x6f, 0xc0, 0x79, 0x3d, 0x6e, 0xad, 0x93, 0x79, 0x35, 0x87, 0x9a,
0x41, 0xcc, 0x06, 0x24, 0xf0, 0x62, 0x09, 0xfe, 0x46, 0x9a, 0x38, 0xee,
0xc0, 0xc8, 0x08, 0xce, 0x65, 0xda, 0xe4, 0x89, 0x1a, 0xfb, 0xe9, 0x53,
0x0c, 0xd1, 0x80, 0x40, 0xfd, 0xc4, 0x97, 0xf8, 0x19, 0x4e, 0x03, 0x90,
0x4a, 0xda, 0xfd, 0x13, 0x27, 0x89, 0xde, 0x12, 0x8d, 0x52, 0x5a, 0x07,
0xf1, 0x9a, 0xa4, 0x54, 0x98, 0x86, 0xb2, 0x78, 0x76, 0xbf, 0x3a, 0xa9,
0x8b, 0xed, 0xc7, 0x8b, 0x31, 0x02, 0x81, 0x81, 0x00, 0xe2, 0xf3, 0xab,
0x53, 0x7b, 0xee, 0x36, 0xdb, 0xca, 0xa8, 0x74, 0x03, 0xdd, 0xe2, 0xce,
0x87, 0xe2, 0x8c, 0x55, 0x8e, 0xd4, 0x0f, 0x32, 0xec, 0xd2, 0xf9, 0x8b,
0x1f, 0x93, 0xdb, 0x84, 0xd2, 0x42, 0xe1, 0xc7, 0x21, 0x24, 0x2e, 0x36,
0x0c, 0x02, 0x5d, 0x49, 0xea, 0xe0, 0x42, 0xd7, 0x7a, 0x3e, 0xc8, 0x51,
0x92, 0x39, 0x56, 0x10, 0xd7, 0x90, 0x67, 0xa3, 0x34, 0xd6, 0xc2, 0x4a,
0x33, 0x74, 0xfd, 0xe2, 0x7e, 0xe1, 0x3e, 0x59, 0xd7, 0x36, 0x6d, 0x7d,
0xd4, 0xd8, 0x82, 0xfb, 0x2f, 0x1e, 0x5e, 0x32, 0xcd, 0xc3, 0x0a, 0x7f,
0xbd, 0xb0, 0xb3, 0xf9, 0x77, 0x75, 0xb9, 0x0c, 0x63, 0x54, 0xff, 0x25,
0xa3, 0xaf, 0x4a, 0x70, 0x61, 0x32, 0x91, 0xde, 0xfb, 0x95, 0x25, 0xb4,
0x06, 0x98, 0x9d, 0xeb, 0x49, 0xc8, 0xe0, 0xc0, 0x7e, 0x45, 0xfb, 0xe5,
0xf8, 0x72, 0x5b, 0x6b, 0x19, 0x02, 0x81, 0x81, 0x00, 0xc5, 0x01, 0x4b,
0xb7, 0x5f, 0x6d, 0xbc, 0xa6, 0x8c, 0xb8, 0xeb, 0xa5, 0xff, 0x0b, 0xd7,
0x15, 0xd7, 0xef, 0xf6, 0xc9, 0xfe, 0x69, 0xcc, 0xe5, 0xbd, 0x5c, 0xa8,
0x05, 0xa0, 0x4d, 0x3b, 0x1f, 0xa6, 0xcc, 0x37, 0x7b, 0xb1, 0x46, 0xf2,
0xc7, 0x67, 0xcd, 0xc1, 0x20, 0xc4, 0x14, 0xbd, 0x0e, 0x01, 0xa7, 0xd6,
0x3c, 0xe8, 0x18, 0x9d, 0x71, 0x71, 0x37, 0x2a, 0xc0, 0x45, 0x6a, 0x54,
0xe8, 0x63, 0xf0, 0x6e, 0xd2, 0x9f, 0x95, 0x3b, 0xde, 0xb3, 0xc5, 0x60,
0x57, 0x3d, 0xed, 0xef, 0x57, 0xcb, 0x3d, 0x35, 0x3a, 0x2e, 0x5d, 0xb8,
0x0e, 0xf8, 0xff, 0xd2, 0xca, 0xdd, 0xce, 0x0b, 0x10, 0x53, 0xb4, 0xdb,
0x53, 0xf6, 0x02, 0xa5, 0xf1, 0x23, 0x4d, 0x21, 0x6e, 0xc7, 0x52, 0x5a,
0x7a, 0x5d, 0x88, 0x32, 0xa8, 0x65, 0x50, 0x21, 0xf5, 0x81, 0x3f, 0x96,
0xd4, 0x57, 0x48, 0x66, 0xf3, 0x02, 0x81, 0x81, 0x00, 0xdd, 0x83, 0xd6,
0x62, 0x9a, 0xe1, 0x0c, 0xfc, 0x84, 0x96, 0xdc, 0xfd, 0xf5, 0x31, 0xee,
0x42, 0x25, 0x76, 0xb1, 0xff, 0xc1, 0xad, 0xc0, 0x17, 0xf5, 0x68, 0x8a,
0x49, 0x5d, 0x08, 0xf3, 0x60, 0x42, 0xd5, 0x9a, 0x86, 0x17, 0x89, 0x5f,
0x49, 0x63, 0x79, 0x68, 0xaf, 0x6f, 0x0a, 0xee, 0xc4, 0xab, 0xc8, 0xdc,
0x0d, 0x6c, 0x17, 0x3c, 0x43, 0x1a, 0xf8, 0x7d, 0x0d, 0x12, 0xdc, 0xfa,
0x8d, 0xb5, 0x10, 0x25, 0x65, 0x90, 0x36, 0x4a, 0x7c, 0x4b, 0xec, 0x9c,
0xd8, 0x06, 0x27, 0xfa, 0x41, 0xa8, 0x53, 0x6b, 0x24, 0xf8, 0xcd, 0x23,
0x97, 0xa3, 0x84, 0x56, 0xe7, 0x29, 0xa9, 0x5f, 0x95, 0x08, 0x9e, 0x2d,
0x3f, 0xd1, 0xd5, 0x47, 0x51, 0x27, 0x89, 0xc7, 0x6a, 0x29, 0xce, 0x6e,
0x23, 0xce, 0x0c, 0xbd, 0x5d, 0xfc, 0x4a, 0x9a, 0xb7, 0xe5, 0x59, 0x13,
0xc2, 0xe6, 0xe3, 0xa1, 0xe9, 0x02, 0x81, 0x81, 0x00, 0xc3, 0x6f, 0x98,
0xa4, 0xae, 0x97, 0xd7, 0xb9, 0xc6, 0x0a, 0xc1, 0x43, 0xa8, 0xf4, 0x1f,
0x08, 0xfd, 0x72, 0x81, 0xfa, 0x3b, 0x58, 0xcc, 0x3a, 0xf1, 0x93, 0x54,
0xe0, 0x57, 0xf9, 0xa5, 0xf8, 0xad, 0x69, 0x14, 0x75, 0xb2, 0x15, 0x77,
0x4d, 0xd8, 0xad, 0xa6, 0xb5, 0x11, 0xb0, 0x9d, 0x28, 0xa2, 0xfd, 0xd4,
0xac, 0x11, 0x78, 0x31, 0xe0, 0xd3, 0x76, 0xee, 0x03, 0x56, 0x19, 0xb9,
0x67, 0xdd, 0x95, 0x2c, 0xeb, 0xe8, 0x02, 0x8d, 0x25, 0x4e, 0x64, 0x35,
0x41, 0xf7, 0x1e, 0xee, 0xfc, 0xc2, 0x93, 0xd3, 0x15, 0x07, 0xe0, 0x53,
0x73, 0x0f, 0x14, 0x03, 0x12, 0xdb, 0xdd, 0xc6, 0xde, 0x08, 0x9c, 0x77,
0xa5, 0x20, 0x7d, 0xda, 0x0f, 0x91, 0x7c, 0xb7, 0xf9, 0x04, 0xe5, 0xae,
0xfa, 0x8b, 0x85, 0x4c, 0xf3, 0xff, 0xa5, 0xf2, 0x3a, 0x72, 0x61, 0x1a,
0x09, 0x47, 0x19, 0x7d, 0x7f, 0x02, 0x81, 0x80, 0x65, 0xce, 0x33, 0x53,
0xca, 0xfb, 0xe0, 0x29, 0x83, 0x12, 0x93, 0x6c, 0xd9, 0xeb, 0x3b, 0xaa,
0xc5, 0xc4, 0xd1, 0xb0, 0x01, 0x85, 0xba, 0xc7, 0x6d, 0xdb, 0x3f, 0x86,
0x06, 0x4c, 0x7e, 0xc4, 0x64, 0x65, 0x14, 0x5d, 0x9c, 0xe9, 0x54, 0x62,
0x5c, 0xf2, 0x6e, 0xe3, 0x14, 0x80, 0x48, 0x0c, 0xbc, 0xb4, 0xa1, 0xb6,
0x6d, 0x2f, 0xa3, 0x21, 0xc0, 0xfc, 0x45, 0xa9, 0x2e, 0x3d, 0x34, 0x2d,
0x05, 0x39, 0x4f, 0x4b, 0xf1, 0x8c, 0xd3, 0x61, 0xbb, 0x80, 0x2d, 0xa3,
0x50, 0x5c, 0xe0, 0xf4, 0xcd, 0xff, 0x95, 0xdc, 0xa8, 0x23, 0x8f, 0x92,
0x69, 0xcd, 0x36, 0x8a, 0xba, 0xa5, 0xe3, 0xfe, 0xce, 0x8e, 0x67, 0xc5,
0x54, 0x41, 0x8c, 0x44, 0xc5, 0x50, 0x55, 0x7a, 0x7c, 0x91, 0xc9, 0x2e,
0x9e, 0x32, 0x63, 0x37, 0x42, 0x68, 0x29, 0x76, 0x41, 0xdb, 0x77, 0xfd,
0xcb, 0x6a, 0x73, 0x10,
constexpr uint8_t kEncryptionPublicKey[] = {
0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xb5, 0xdf, 0x28, 0x81, 0xfc,
0x29, 0x80, 0xe4, 0xe6, 0x49, 0x6e, 0x62, 0xe5, 0xf3, 0x23, 0x99, 0x59,
0x54, 0x84, 0x1b, 0xf1, 0xde, 0x27, 0x8b, 0xe6, 0x22, 0xec, 0x02, 0x68,
0x58, 0x6e, 0x5b, 0x11, 0x90, 0x7a, 0xb3, 0xb3, 0x35, 0xab, 0x02, 0xb7,
0xf6, 0xd8, 0x74, 0xef, 0x90, 0xd8, 0xab, 0xb1, 0x44, 0x04, 0x7e, 0x15,
0x02, 0xac, 0x9d, 0x1e, 0x4e, 0xef, 0x9c, 0xdf, 0x31, 0xdb, 0x7a, 0x03,
0xd6, 0xa9, 0xfe, 0x6e, 0xd6, 0x4e, 0x5d, 0xaf, 0xdd, 0x63, 0x62, 0x5e,
0xa9, 0x56, 0x82, 0x2c, 0x09, 0x26, 0xc5, 0x61, 0x58, 0xf2, 0x04, 0xd5,
0x0a, 0x40, 0x22, 0xb7, 0x9a, 0x46, 0x4d, 0x88, 0x2c, 0x75, 0x8f, 0xc1,
0x18, 0x6a, 0xf8, 0xf6, 0x5d, 0xb1, 0x77, 0x24, 0xcb, 0x0e, 0x0f, 0x99,
0x38, 0x7c, 0x0a, 0x4a, 0xd1, 0xda, 0xef, 0x35, 0x80, 0x60, 0x56, 0xbc,
0xe9, 0x16, 0xf7, 0x02, 0x03, 0x01, 0x00, 0x01,
};
constexpr uint8_t kSigningPrivateKey[] = {
0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0x9c,
0x54, 0xb3, 0x2f, 0x66, 0xe3, 0xd2, 0xb8, 0xee, 0x22, 0xa0, 0x3c, 0x76,
0x06, 0x67, 0xd8, 0xc1, 0xbc, 0xe6, 0xbe, 0x6f, 0xb3, 0x93, 0xee, 0xd4,
0xe6, 0xcb, 0x11, 0x00, 0xb5, 0x16, 0x49, 0xe1, 0x8e, 0xcc, 0xea, 0xbe,
0xc6, 0x45, 0x34, 0xfc, 0x13, 0xed, 0x0a, 0x90, 0x22, 0xe0, 0x6d, 0x6f,
0xaf, 0x64, 0xa8, 0xc2, 0x05, 0xf9, 0x2c, 0x51, 0x52, 0xd4, 0x42, 0x47,
0xfe, 0x03, 0x99, 0xf1, 0x03, 0x7e, 0x09, 0x08, 0x65, 0x50, 0xb9, 0x36,
0x8f, 0x62, 0xc5, 0x1a, 0x18, 0x27, 0xb8, 0xf3, 0x89, 0x53, 0x5a, 0x9d,
0xfb, 0xe4, 0x9b, 0xb4, 0xea, 0x48, 0x7c, 0x0f, 0x30, 0x02, 0x82, 0x6c,
0xf7, 0xb6, 0xf7, 0x82, 0x1f, 0xbb, 0x0b, 0x87, 0x95, 0xd0, 0xda, 0x7e,
0xb9, 0x0e, 0x58, 0xa3, 0x6d, 0xde, 0x50, 0x4d, 0xa0, 0x21, 0x1b, 0x72,
0xf3, 0x97, 0xbf, 0x98, 0xab, 0xb1, 0x5b, 0x02, 0x03, 0x01, 0x00, 0x01,
0x02, 0x81, 0x80, 0x40, 0x61, 0xf7, 0xab, 0xd1, 0x7d, 0x89, 0x46, 0xc5,
0x38, 0x38, 0x72, 0xbe, 0x0e, 0xd4, 0x4c, 0xe6, 0x39, 0x34, 0x74, 0x80,
0x8f, 0x5e, 0x20, 0xf1, 0xc8, 0x9d, 0x20, 0x03, 0x01, 0x11, 0x4d, 0x5b,
0x1a, 0x13, 0x15, 0xa8, 0x7d, 0x02, 0x7a, 0x98, 0x48, 0x62, 0x8a, 0xc3,
0xa2, 0xc1, 0x78, 0x00, 0x93, 0xa4, 0xea, 0x85, 0x81, 0xad, 0x45, 0x8d,
0xb6, 0x85, 0x99, 0x48, 0x89, 0xfa, 0x14, 0x12, 0x6d, 0x9f, 0x2f, 0x85,
0xda, 0xeb, 0x69, 0x51, 0x21, 0x3c, 0x70, 0x45, 0xc7, 0x32, 0xd2, 0x83,
0xa1, 0x3f, 0xbc, 0x5a, 0x53, 0x84, 0x2b, 0xde, 0xc3, 0x80, 0x33, 0x9e,
0x67, 0x60, 0xad, 0x38, 0xaa, 0x3b, 0xde, 0xd7, 0x30, 0xe0, 0xa9, 0xd0,
0x78, 0x46, 0xc8, 0x23, 0x9f, 0xcf, 0xc4, 0x7c, 0x2d, 0x56, 0x1e, 0xc3,
0x21, 0x02, 0x35, 0xe7, 0xbf, 0xf4, 0x8f, 0x12, 0x76, 0x6d, 0x89, 0x02,
0x41, 0x00, 0xd8, 0x7f, 0x34, 0xd2, 0x3b, 0x51, 0x7f, 0xe9, 0x42, 0x02,
0x9d, 0xea, 0x31, 0x55, 0x80, 0xab, 0xea, 0x09, 0x85, 0x3f, 0x06, 0x16,
0x79, 0x6e, 0x2c, 0x47, 0x65, 0xe7, 0x0f, 0xf5, 0x2e, 0x52, 0x5c, 0x49,
0xcc, 0xd5, 0xf4, 0xcb, 0x67, 0xfa, 0x1b, 0x42, 0x2f, 0x5a, 0x73, 0x67,
0x2e, 0x53, 0xcd, 0x4b, 0x5b, 0xfa, 0xe7, 0x9e, 0x8f, 0xbe, 0x4b, 0x32,
0x72, 0x21, 0xfb, 0x99, 0x3b, 0xa9, 0x02, 0x41, 0x00, 0xb8, 0xdb, 0x13,
0x64, 0x1e, 0x81, 0x4f, 0x85, 0xc3, 0xbe, 0xc8, 0x21, 0xcd, 0x2b, 0x57,
0x1c, 0x61, 0x16, 0xcb, 0x93, 0x0a, 0x31, 0xb8, 0x24, 0xbc, 0xb7, 0xf8,
0x5c, 0xde, 0x9c, 0x8e, 0x0f, 0x91, 0x21, 0xf7, 0x3a, 0x98, 0x9d, 0x3f,
0xf9, 0x2a, 0x1a, 0x52, 0x3a, 0x13, 0x5a, 0x9b, 0x5c, 0x37, 0x44, 0x0a,
0x35, 0x19, 0xac, 0xaa, 0x7e, 0xa6, 0xbb, 0xdb, 0x31, 0x5a, 0x88, 0x07,
0x63, 0x02, 0x40, 0x25, 0xaf, 0x7e, 0xf2, 0x59, 0x81, 0x06, 0x53, 0x04,
0x3a, 0x90, 0x62, 0x83, 0xd3, 0xee, 0x61, 0xfe, 0x8b, 0x49, 0xb6, 0x7e,
0xc8, 0xca, 0xba, 0x72, 0xda, 0xba, 0xd2, 0x4d, 0xe4, 0xcf, 0xfb, 0x66,
0x35, 0x32, 0x82, 0xcb, 0xe9, 0xdc, 0x5f, 0x9c, 0xff, 0x18, 0x5f, 0x16,
0x57, 0x8f, 0xa8, 0xe6, 0xc3, 0x87, 0x6f, 0x55, 0x82, 0x34, 0x63, 0x5b,
0x93, 0x9c, 0x6a, 0x6d, 0xf1, 0x6e, 0x81, 0x02, 0x40, 0x67, 0x6a, 0x68,
0x56, 0xc2, 0x9a, 0x25, 0x1a, 0xf8, 0x7f, 0x6b, 0x07, 0x3d, 0xf8, 0xd9,
0x2b, 0x0f, 0x45, 0xe9, 0x6d, 0xc1, 0x6e, 0x3f, 0x4e, 0x8e, 0x25, 0x7d,
0xd4, 0xb6, 0xd5, 0x6e, 0xc4, 0x56, 0xb5, 0x61, 0xd2, 0x6e, 0x3e, 0xca,
0xe3, 0x62, 0x22, 0x87, 0x8d, 0xe5, 0xf5, 0xf2, 0xa4, 0x8c, 0x66, 0x8c,
0x2f, 0x58, 0xc5, 0xb8, 0x3c, 0x52, 0x9b, 0x15, 0xed, 0x6e, 0x70, 0x5b,
0x71, 0x02, 0x41, 0x00, 0x93, 0xbd, 0x21, 0x13, 0x72, 0x56, 0xaa, 0xd7,
0xef, 0x3a, 0xa7, 0xc4, 0x00, 0x42, 0x56, 0xa9, 0x17, 0xd1, 0x08, 0x44,
0x29, 0x10, 0x6d, 0x0d, 0x50, 0x2c, 0x49, 0x1d, 0x6b, 0x3f, 0x84, 0x5c,
0xe8, 0x69, 0x1f, 0x83, 0xa8, 0xc2, 0x59, 0x88, 0x6a, 0x18, 0x02, 0x42,
0xfb, 0xf2, 0x85, 0x64, 0x2b, 0x42, 0xc5, 0xc4, 0x8d, 0xc4, 0x28, 0x13,
0x95, 0x3c, 0x96, 0x61, 0x21, 0x61, 0x01, 0x9b,
};
constexpr uint8_t kEncryptionPrivateKey[] = {
0x30, 0x82, 0x02, 0x5e, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xb5,
0xdf, 0x28, 0x81, 0xfc, 0x29, 0x80, 0xe4, 0xe6, 0x49, 0x6e, 0x62, 0xe5,
0xf3, 0x23, 0x99, 0x59, 0x54, 0x84, 0x1b, 0xf1, 0xde, 0x27, 0x8b, 0xe6,
0x22, 0xec, 0x02, 0x68, 0x58, 0x6e, 0x5b, 0x11, 0x90, 0x7a, 0xb3, 0xb3,
0x35, 0xab, 0x02, 0xb7, 0xf6, 0xd8, 0x74, 0xef, 0x90, 0xd8, 0xab, 0xb1,
0x44, 0x04, 0x7e, 0x15, 0x02, 0xac, 0x9d, 0x1e, 0x4e, 0xef, 0x9c, 0xdf,
0x31, 0xdb, 0x7a, 0x03, 0xd6, 0xa9, 0xfe, 0x6e, 0xd6, 0x4e, 0x5d, 0xaf,
0xdd, 0x63, 0x62, 0x5e, 0xa9, 0x56, 0x82, 0x2c, 0x09, 0x26, 0xc5, 0x61,
0x58, 0xf2, 0x04, 0xd5, 0x0a, 0x40, 0x22, 0xb7, 0x9a, 0x46, 0x4d, 0x88,
0x2c, 0x75, 0x8f, 0xc1, 0x18, 0x6a, 0xf8, 0xf6, 0x5d, 0xb1, 0x77, 0x24,
0xcb, 0x0e, 0x0f, 0x99, 0x38, 0x7c, 0x0a, 0x4a, 0xd1, 0xda, 0xef, 0x35,
0x80, 0x60, 0x56, 0xbc, 0xe9, 0x16, 0xf7, 0x02, 0x03, 0x01, 0x00, 0x01,
0x02, 0x81, 0x80, 0x58, 0x31, 0x52, 0xcf, 0x55, 0x9c, 0x3a, 0xa8, 0xc5,
0x13, 0x2e, 0xb8, 0x3e, 0x91, 0xdc, 0xdd, 0x6b, 0xf8, 0x13, 0xe8, 0x09,
0x2d, 0x95, 0x37, 0xbd, 0xed, 0x89, 0x4c, 0xd1, 0x94, 0xb0, 0x4e, 0xf1,
0x01, 0x82, 0xbe, 0xc9, 0x54, 0x69, 0x0c, 0xf4, 0x70, 0x7b, 0x1e, 0x99,
0x5d, 0x3f, 0xf4, 0x62, 0x0d, 0x7d, 0xb0, 0x36, 0x38, 0x09, 0xc4, 0x57,
0x02, 0x28, 0x27, 0x86, 0x04, 0x03, 0x4d, 0x21, 0x96, 0x5c, 0xdc, 0xcf,
0xd8, 0x72, 0xa7, 0x98, 0x78, 0x14, 0x38, 0x41, 0x2c, 0x2f, 0xa4, 0x77,
0xec, 0x3e, 0x76, 0x80, 0x04, 0xba, 0xa2, 0xb6, 0x63, 0xbe, 0xa6, 0x7d,
0xf2, 0x7e, 0x95, 0xaf, 0x15, 0xb3, 0x17, 0x26, 0xd9, 0x1f, 0x01, 0x27,
0xda, 0x20, 0xe2, 0x62, 0xb4, 0xf2, 0xb9, 0x05, 0xf3, 0x86, 0x95, 0x92,
0x45, 0x73, 0xd7, 0xd3, 0xa0, 0x1c, 0xcc, 0x89, 0xf3, 0x27, 0x81, 0x02,
0x41, 0x00, 0xec, 0x3c, 0x1d, 0xdd, 0xd4, 0xae, 0x09, 0xd8, 0x81, 0xa9,
0xfc, 0xc3, 0x46, 0xa3, 0xf1, 0x37, 0x9f, 0x7d, 0xc0, 0x70, 0x52, 0xab,
0x34, 0x25, 0xc3, 0xf6, 0x43, 0xe0, 0x08, 0xc5, 0x8b, 0x91, 0x23, 0x83,
0x79, 0xac, 0x46, 0xf7, 0x63, 0xb8, 0x5c, 0x3d, 0xd6, 0x78, 0x67, 0xd4,
0x19, 0xcf, 0x6c, 0x27, 0x5e, 0xea, 0x28, 0x81, 0x7b, 0xf8, 0xfd, 0x25,
0xa5, 0x35, 0x15, 0x63, 0x94, 0x47, 0x02, 0x41, 0x00, 0xc5, 0x16, 0xa5,
0x1b, 0x0d, 0xeb, 0x48, 0xce, 0x2b, 0x55, 0xef, 0xd1, 0x69, 0xa2, 0x78,
0x12, 0x32, 0x72, 0x89, 0xa8, 0x3b, 0xbb, 0x07, 0x1d, 0x89, 0x36, 0x5b,
0x7d, 0x41, 0xc0, 0xcf, 0xef, 0xad, 0x29, 0xda, 0x3e, 0x11, 0x80, 0xe7,
0x97, 0xac, 0x7f, 0x18, 0xa9, 0xb5, 0x76, 0x60, 0xf3, 0x42, 0x01, 0xa4,
0xa3, 0xf2, 0x05, 0x91, 0x58, 0x90, 0x83, 0x53, 0xa1, 0x74, 0x7c, 0x2f,
0xd1, 0x02, 0x41, 0x00, 0xb2, 0xf4, 0x3f, 0x73, 0xc2, 0x1f, 0x2d, 0x1a,
0x33, 0xef, 0x7f, 0xa8, 0xb6, 0x24, 0x8f, 0x20, 0xa1, 0xd3, 0x73, 0x2a,
0x23, 0x95, 0xc9, 0xe5, 0x29, 0xf3, 0xae, 0x2b, 0x52, 0xb9, 0xc3, 0x26,
0x69, 0x8e, 0xb9, 0x67, 0x46, 0x43, 0x35, 0xe9, 0x7d, 0x06, 0xe3, 0x27,
0x47, 0x10, 0x27, 0x95, 0x37, 0xcb, 0x03, 0x5d, 0xc2, 0xdd, 0x83, 0xfa,
0x74, 0x5a, 0x46, 0x32, 0x56, 0x47, 0x9f, 0x15, 0x02, 0x41, 0x00, 0x97,
0x0b, 0x3d, 0xc9, 0xb8, 0x27, 0x23, 0x8a, 0xed, 0xe7, 0x54, 0x7d, 0xd7,
0x49, 0x2e, 0x60, 0x33, 0xcd, 0x57, 0xf6, 0x58, 0xa0, 0x83, 0x59, 0x7d,
0x78, 0xed, 0x30, 0xd7, 0x9d, 0x9f, 0x3e, 0x7e, 0x25, 0x5f, 0x1e, 0xc6,
0x67, 0x56, 0x16, 0x05, 0x9a, 0xfa, 0x19, 0xc5, 0xfa, 0x4d, 0x5e, 0xe0,
0xad, 0x45, 0xb2, 0x67, 0x9f, 0x20, 0xbf, 0x11, 0x31, 0xb4, 0x7c, 0x3e,
0x3b, 0x96, 0xa1, 0x02, 0x41, 0x00, 0x94, 0x82, 0x10, 0x66, 0xfe, 0xed,
0x68, 0x3b, 0x7f, 0xfb, 0x50, 0x3d, 0x35, 0xa0, 0x34, 0x0b, 0xc7, 0xbf,
0x5c, 0x7e, 0x01, 0x59, 0x77, 0xbb, 0xb2, 0xdf, 0x21, 0xbf, 0x1f, 0x67,
0x82, 0xd5, 0xca, 0x81, 0x8c, 0x99, 0xbf, 0x0c, 0x0f, 0xe6, 0x86, 0xd7,
0x32, 0x25, 0xa0, 0x63, 0x31, 0xa3, 0x2f, 0xd0, 0x89, 0x12, 0x2f, 0x2b,
0x95, 0x82, 0x28, 0xe3, 0x70, 0x3e, 0x7f, 0x04, 0xaa, 0x99,
};
std::vector<uint8_t> AsVector(const uint8_t* data, size_t length) {
return std::vector<uint8_t>(data, data + length);
}
// Since we are going to return the same key for encryption and signing, create
// a common function for them to both call.
WhiteboxKey GetKey() {
WhiteboxKey key;
key.private_key = AsVector(kDevicePrivateKey, sizeof(kDevicePrivateKey));
key.public_key = AsVector(kDevicePublicKey, sizeof(kDevicePublicKey));
return key;
}
} // namespace
WhiteboxKey GetEncryptionKey() {
return GetKey();
WhiteboxKey key;
key.private_key =
AsVector(kEncryptionPrivateKey, sizeof(kEncryptionPrivateKey));
key.public_key = AsVector(kEncryptionPublicKey, sizeof(kEncryptionPublicKey));
return key;
}
WhiteboxKey GetSigningKey() {
return GetKey();
WhiteboxKey key;
key.private_key = AsVector(kSigningPrivateKey, sizeof(kSigningPrivateKey));
key.public_key = AsVector(kSigningPublicKey, sizeof(kSigningPublicKey));
return key;
}
} // namespace widevine

4
whitebox/benchmarking/measurements.cc
View File

@@ -68,10 +68,10 @@ void PrettyPrint(const std::string& title,
LOG(INFO) << title;
LOG(INFO) << " Sample Size: " << samples.SampleSize() << " ("
<< per_sample_size << " bytes)";
LOG(INFO) << " Min (0%): " << percentiles.Get(0).count() << " us";
LOG(INFO) << " Min (1%): " << percentiles.Get(1).count() << " us";
LOG(INFO) << " 25%: " << percentiles.Get(25).count() << " us";
LOG(INFO) << " Median (50%): " << percentiles.Get(50).count() << " us";
LOG(INFO) << " 75%: " << percentiles.Get(75).count() << " us";
LOG(INFO) << " 75%: " << percentiles.Get(75).count() << " us";
LOG(INFO) << " Max (100%): " << percentiles.Get(100).count() << " us";
}

2
whitebox/chromium_deps/cdm/protos/BUILD
View File

@@ -5,7 +5,7 @@
cc_library(
name = "license_protocol_proto",
hdrs = ["license_protocol.pb.h"],
strip_include_prefix = "//chromium_deps",
strip_include_prefix = "//chromium_deps/cdm/protos",
visibility = ["//visibility:public"],
deps = [
"//chromium_deps/cdm/protos/defs:license_protocol_proto",

2
whitebox/crypto_utils/aes_cbc_decryptor.cc
View File

@@ -14,6 +14,8 @@ namespace {
constexpr size_t kAesBlockSize = 16;
} // namespace
AesCbcDecryptor::~AesCbcDecryptor() {}
bool AesCbcDecryptor::SetKey(const uint8_t* key, size_t key_size) {
DCHECK(key);

2
whitebox/crypto_utils/aes_cbc_decryptor.h
View File

@@ -12,6 +12,8 @@ namespace widevine {
class AesCbcDecryptor {
public:
virtual ~AesCbcDecryptor();
// Prepares the encryptor with the key.
virtual bool SetKey(const uint8_t* key, size_t key_size);

2
whitebox/crypto_utils/aes_cbc_encryptor.cc
View File

@@ -14,6 +14,8 @@ namespace {
constexpr size_t kAesBlockSize = 16;
} // namespace
AesCbcEncryptor::~AesCbcEncryptor() {}
bool AesCbcEncryptor::SetKey(const uint8_t* key, size_t key_size) {
DCHECK(key);

2
whitebox/crypto_utils/aes_cbc_encryptor.h
View File

@@ -12,6 +12,8 @@ namespace widevine {
class AesCbcEncryptor {
public:
virtual ~AesCbcEncryptor();
// Prepares the encryptor with the key.
virtual bool SetKey(const uint8_t* key, size_t key_size);

2
whitebox/crypto_utils/aes_ctr_encryptor.cc
View File

@@ -26,6 +26,8 @@ bool Increment64(uint8_t* counter) {
} // namespace
AesCtrEncryptor::~AesCtrEncryptor() {}
bool AesCtrEncryptor::SetKey(const uint8_t* key, size_t key_size) {
DCHECK(key);

2
whitebox/crypto_utils/aes_ctr_encryptor.h
View File

@@ -12,6 +12,8 @@ namespace widevine {
class AesCtrEncryptor {
public:
virtual ~AesCtrEncryptor();
// Prepares the encryptor with the key.
virtual bool SetKey(const uint8_t* key, size_t key_size);

4
whitebox/reference/impl/content_key.h
View File

@@ -8,7 +8,7 @@
#include <string>
#include "api/license_whitebox.h"
#include "cdm/protos/license_protocol.pb.h"
#include "license_protocol.pb.h"
namespace widevine {
@@ -40,4 +40,4 @@ ContentKey CreateContentKey(
} // namespace widevine
#endif // WHITEBOX_REFERENCE_IMPL_CONTENT_KEY_H_
#endif // WHITEBOX_REFERENCE_IMPL_CONTENT_KEY_H_

2
whitebox/reference/impl/license_parser.h
View File

@@ -5,7 +5,7 @@
#include <map>
#include <string>
#include "cdm/protos/license_protocol.pb.h"
#include "license_protocol.pb.h"
#include "reference/impl/content_key.h"
#include "reference/impl/odk.h"
#include "reference/impl/renewal_key.h"

104
whitebox/reference/impl/license_whitebox_impl.cc
View File

@@ -12,11 +12,11 @@
#include "base/check.h"
#include "base/check_op.h"
#include "base/logging.h"
#include "cdm/protos/license_protocol.pb.h"
#include "crypto_utils/aes_cbc_decryptor.h"
#include "crypto_utils/aes_ctr_encryptor.h"
#include "crypto_utils/crypto_util.h"
#include "crypto_utils/rsa_key.h"
#include "license_protocol.pb.h"
#include "oemcrypto/odk/include/odk.h"
#include "oemcrypto/odk/include/odk_message.h"
#include "oemcrypto/odk/include/odk_structs.h"
@@ -81,6 +81,16 @@ uint8_t InverseMaskingFunction1(uint8_t input) {
return mapping[input];
}
bool CheckAndUpdateSize(size_t min_size, size_t* out_size) {
const bool good = *out_size >= min_size;
if (!good) {
DVLOG(1) << "Buffer too small: needs " << min_size << ", but was "
<< *out_size << ".";
}
*out_size = min_size;
return good;
}
} // namespace
// The white-box type can't be in the namespace as it is declared in the header.
@@ -148,7 +158,7 @@ WB_Result DecryptBuffer(WB_CipherMode mode,
size_t iv_size,
uint8_t* output_data,
size_t* output_data_size) {
if (!input_data || !iv || !output_data || !output_data_size) {
if (!input_data || !iv || !output_data_size) {
DVLOG(1) << "Invalid parameter: null pointer.";
return WB_RESULT_INVALID_PARAMETER;
}
@@ -158,6 +168,16 @@ WB_Result DecryptBuffer(WB_CipherMode mode,
return WB_RESULT_INVALID_PARAMETER;
}
// There is no padding, so the output will be the same length as the input.
if (!CheckAndUpdateSize(input_data_size, output_data_size)) {
return WB_RESULT_BUFFER_TOO_SMALL;
}
if (!output_data) {
DVLOG(1) << "Invalid parameter: null pointer.";
return WB_RESULT_INVALID_PARAMETER;
}
// Data must be "block aligned" for CBC. CTR does not have this requirement.
if (mode == WB_CIPHER_MODE_CBC && input_data_size % AES_BLOCK_SIZE != 0) {
DVLOG(1) << "Invalid parameter: bad block size.";
@@ -171,14 +191,6 @@ WB_Result DecryptBuffer(WB_CipherMode mode,
return WB_RESULT_INVALID_PARAMETER;
}
// There is no padding, so the output will be the same length as the input.
if (*output_data_size < input_data_size) {
DVLOG(1) << "Buffer too small: needs " << input_data_size << " but got "
<< *output_data_size << ".";
*output_data_size = input_data_size;
return WB_RESULT_BUFFER_TOO_SMALL;
}
// If we passed a key to this function, it should be the correct size. If it
// wasn't, we should not have saved the content key.
CHECK(key) << "Missing key data";
@@ -191,15 +203,13 @@ WB_Result DecryptBuffer(WB_CipherMode mode,
AesCbcDecryptor decryptor;
CHECK(decryptor.SetKey(key, key_size));
*output_data_size = input_data_size;
CHECK(decryptor.Decrypt(iv, iv_size, input_data, input_data_size,
output_data));
} else if (mode == WB_CIPHER_MODE_CTR) {
AesCtrDecryptor decryptor;
CHECK(decryptor.SetKey(key, key_size));
// Encrypt and Decrypt for CBC use the same interface.
*output_data_size = input_data_size;
// Encrypt and Decrypt for CTR use the same interface.
CHECK(decryptor.Encrypt(iv, iv_size, input_data, input_data_size,
output_data));
} else {
@@ -249,15 +259,26 @@ WB_Result WB_License_SignLicenseRequest(const WB_License_Whitebox* whitebox,
size_t license_request_size,
uint8_t* signature,
size_t* signature_size) {
if (!whitebox || !license_request || !signature || !signature_size) {
if (!whitebox || !signature_size) {
DVLOG(1) << "Invalid parameter: null pointer.";
return WB_RESULT_INVALID_PARAMETER;
}
const size_t real_sign_size = whitebox->signing_key->KeySize();
if (!CheckAndUpdateSize(real_sign_size, signature_size)) {
return WB_RESULT_BUFFER_TOO_SMALL;
}
// Only check after checking for short buffer so callers can query the size
// without a buffer.
if (license_request_size == 0) {
DVLOG(1) << "Invalid parameter: array size 0.";
return WB_RESULT_INVALID_PARAMETER;
}
if (!license_request || !signature) {
DVLOG(1) << "Invalid parameter: null pointer.";
return WB_RESULT_INVALID_PARAMETER;
}
std::string result;
@@ -267,14 +288,8 @@ WB_Result WB_License_SignLicenseRequest(const WB_License_Whitebox* whitebox,
std::string(license_request, license_request + license_request_size),
&result));
if (!widevine::MemCopy(result.data(), result.size(), signature,
*signature_size)) {
DVLOG(1) << "Buffer too small: signature needs " << result.size() << ".";
*signature_size = result.size();
return WB_RESULT_BUFFER_TOO_SMALL;
}
*signature_size = result.size();
CHECK(widevine::MemCopy(result.data(), result.size(), signature,
*signature_size));
return WB_RESULT_OK;
}
@@ -501,7 +516,16 @@ WB_Result WB_License_SignRenewalRequest(const WB_License_Whitebox* whitebox,
size_t message_size,
uint8_t* signature,
size_t* signature_size) {
if (!whitebox || !message || !signature || !signature_size) {
if (!whitebox || !message || !signature_size) {
DVLOG(1) << "Invalid parameter: null pointer.";
return WB_RESULT_INVALID_PARAMETER;
}
if (!CheckAndUpdateSize(SHA256_DIGEST_LENGTH, signature_size)) {
return WB_RESULT_BUFFER_TOO_SMALL;
}
if (!signature) {
DVLOG(1) << "Invalid parameter: null pointer.";
return WB_RESULT_INVALID_PARAMETER;
}
@@ -532,15 +556,8 @@ WB_Result WB_License_SignRenewalRequest(const WB_License_Whitebox* whitebox,
whitebox->renewal_key->client.end()),
std::string(message, message + message_size));
if (!widevine::MemCopy(computed_signature.data(), computed_signature.size(),
signature, *signature_size)) {
DVLOG(1) << "Buffer too small: signature needs "
<< computed_signature.size() << ".";
*signature_size = computed_signature.size();
return WB_RESULT_BUFFER_TOO_SMALL;
}
*signature_size = computed_signature.size();
CHECK(widevine::MemCopy(computed_signature.data(), computed_signature.size(),
signature, *signature_size));
return WB_RESULT_OK;
}
@@ -600,7 +617,7 @@ WB_Result WB_License_GetSecretString(const WB_License_Whitebox* whitebox,
size_t key_id_size,
uint8_t* secret_string,
size_t* secret_string_size) {
if (!whitebox || !key_id || !secret_string || !secret_string_size) {
if (!whitebox || !key_id || !secret_string_size) {
DVLOG(1) << "Invalid parameter: null pointer.";
return WB_RESULT_INVALID_PARAMETER;
}
@@ -615,6 +632,16 @@ WB_Result WB_License_GetSecretString(const WB_License_Whitebox* whitebox,
return WB_RESULT_INVALID_PARAMETER;
}
const auto secret_pattern = GetSecretStringFor(mode);
if (!CheckAndUpdateSize(secret_pattern.size(), secret_string_size)) {
return WB_RESULT_BUFFER_TOO_SMALL;
}
if (!secret_string) {
DVLOG(1) << "Invalid parameter: null pointer.";
return WB_RESULT_INVALID_PARAMETER;
}
if (key_id_size == 0) {
DVLOG(1) << "Invalid parameter: array size 0.";
return WB_RESULT_INVALID_PARAMETER;
@@ -640,15 +667,8 @@ WB_Result WB_License_GetSecretString(const WB_License_Whitebox* whitebox,
return WB_RESULT_INSUFFICIENT_SECURITY_LEVEL;
}
const auto secret_pattern = GetSecretStringFor(mode);
if (!widevine::MemCopy(secret_pattern.data(), secret_pattern.size(),
secret_string, *secret_string_size)) {
DVLOG(1) << "Buffer too small: needs " << secret_pattern.size() << ".";
*secret_string_size = secret_pattern.size();
return WB_RESULT_BUFFER_TOO_SMALL;
}
*secret_string_size = secret_pattern.size();
CHECK(widevine::MemCopy(secret_pattern.data(), secret_pattern.size(),
secret_string, *secret_string_size));
return WB_RESULT_OK;
}

14
whitebox/reference/impl/odk.cc
View File

@@ -28,22 +28,22 @@ WB_Result GetODKContext(const std::string& combined_message,
ODK_Message_Create(mutable_message.data(), mutable_message.size());
ODK_Message_SetSize(&msg, core_message_size);
const ODK_MessageStatus message_status = ODK_Message_GetStatus(&msg);
if (message_status != MESSAGE_STATUS_OK) {
DVLOG(1) << "Invalid core message status: " << message_status;
return WB_RESULT_INVALID_SIGNATURE;
}
ODK_LicenseResponse license_response{{{0, 0, {}}}, NULL, {0}};
license_response.parsed_license = &(context->license);
Unpack_ODK_LicenseResponse(&msg, &license_response);
const ODK_MessageStatus message_status = ODK_Message_GetStatus(&msg);
if (message_status != MESSAGE_STATUS_OK) {
DVLOG(1) << "Invalid core message status: 0x" << std::hex << message_status;
return WB_RESULT_INVALID_PARAMETER;
}
const auto& core_message = license_response.request.core_message;
if (core_message.message_type != ODK_License_Response_Type) {
DVLOG(1) << "Failed core message type: " << core_message.message_type;
return WB_RESULT_INVALID_SIGNATURE;
return WB_RESULT_INVALID_PARAMETER;
}
context->major_version = core_message.nonce_values.api_major_version;

2
whitebox/reference/impl/protobuf_license_parser.h
View File

@@ -3,7 +3,7 @@
#ifndef WHITEBOX_REFERENCE_IMPL_PROTOBUF_LICENSE_PARSER_H_
#define WHITEBOX_REFERENCE_IMPL_PROTOBUF_LICENSE_PARSER_H_
#include "cdm/protos/license_protocol.pb.h"
#include "license_protocol.pb.h"
#include "reference/impl/content_key.h"
#include "reference/impl/license_parser.h"