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

Update Tests For New RSA

Browse Source 
In this code drop we update the reference implementation and tests to
use 1024 bit RSA keys (as per the plans for RSA V2).

Since RSA V2 also changes to support single-key and dual-key modes,
the benchmarking tests have been updated to use both so that we can
test the difference in performance.

This brings the partner repo in sync with the interal repo at commit
566966d75d552ba1654e3f43fdb37aa812f7fb8c.
This commit is contained in:
Aaron Vaage
2021-04-29 09:25:13 -07:00
parent f936dd2983
commit ac8b2f59ea
8 changed files with 227 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
whitebox/api/license_whitebox_benchmark.cc
View File

@@ -10,6 +10,7 @@
#include "api/license_whitebox.h" #include "api/license_whitebox.h"
#include "api/test_license_builder.h" #include "api/test_license_builder.h"
#include "api/test_license_whitebox_keys.h" #include "api/test_license_whitebox_keys.h"
#include "base/check_op.h"
#include "benchmarking/data_source.h" #include "benchmarking/data_source.h"
#include "crypto_utils/crypto_util.h" #include "crypto_utils/crypto_util.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
@@ -30,7 +31,8 @@ void LicenseWhiteboxBenchmark::SetUp() {
ASSERT_TRUE(encryption_public_key_); ASSERT_TRUE(encryption_public_key_);
} }
License LicenseWhiteboxBenchmark::CreateLicense() const { License LicenseWhiteboxBenchmark::CreateLicense(
WB_LicenseKeyMode key_mode) const {
TestLicenseBuilder license_builder; TestLicenseBuilder license_builder;
license_builder.AddSigningKey(TestLicenseBuilder::DefaultSigningKey()); license_builder.AddSigningKey(TestLicenseBuilder::DefaultSigningKey());
// Use secure crypto as it will work with both Decrypt() and // Use secure crypto as it will work with both Decrypt() and
@@ -38,7 +40,19 @@ License LicenseWhiteboxBenchmark::CreateLicense() const {
license_builder.AddContentKey(SecurityLevel::kSoftwareSecureCrypto, key_id_, license_builder.AddContentKey(SecurityLevel::kSoftwareSecureCrypto, key_id_,
key_); key_);
auto server = TestServer::CreateDualKey(); std::unique_ptr<TestServer> server;
switch (key_mode) {
case WB_LICENSE_KEY_MODE_SINGLE_KEY:
server = TestServer::CreateSingleKey();
break;
case WB_LICENSE_KEY_MODE_DUAL_KEY:
server = TestServer::CreateDualKey();
break;
default:
CHECK(false) << "Could not create test server, Unknown key mode.";
break;
}
License license; License license;
license_builder.Build(*server, &license); license_builder.Build(*server, &license);

6
whitebox/api/license_whitebox_benchmark.h
View File

@@ -20,8 +20,12 @@ class LicenseWhiteboxBenchmark : public ::testing::Test {
protected: protected:
virtual void SetUp() override; virtual void SetUp() override;
License CreateLicense() const; // 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;
// Sign the message using the default HMAC signing key.
std::vector<uint8_t> SignAsServer(const std::vector<uint8_t>& message) const; std::vector<uint8_t> SignAsServer(const std::vector<uint8_t>& message) const;
DataSource& Data() { return data_source_; } DataSource& Data() { return data_source_; }

2
whitebox/api/license_whitebox_decrypt_benchmark.cc
View File

@@ -45,7 +45,7 @@ class LicenseWhiteboxDecryptBenchmark
ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK); ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK);
const auto license = CreateLicense(); const auto license = CreateLicense(WB_LICENSE_KEY_MODE_DUAL_KEY);
ASSERT_EQ(WB_License_ProcessLicenseResponse( ASSERT_EQ(WB_License_ProcessLicenseResponse(
whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY, whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY,
license.core_message.data(), license.core_message.size(), license.core_message.data(), license.core_message.size(),

64
whitebox/api/license_whitebox_process_license_response_benchmark.cc
View File

@@ -16,21 +16,30 @@ namespace {
// work around this, use a fixed number of iterations. // work around this, use a fixed number of iterations.
constexpr size_t kIterations = 100; constexpr size_t kIterations = 100;
} // namespace } // namespace
class LicenseWhiteboxProcessLicenseResponseBenchmark class LicenseWhiteboxProcessLicenseResponseBenchmark
: public LicenseWhiteboxBenchmark { : public LicenseWhiteboxBenchmark,
public testing::WithParamInterface<WB_LicenseKeyMode> {
protected: protected:
void SetUp() override { void SetUp() override {
LicenseWhiteboxBenchmark::SetUp(); LicenseWhiteboxBenchmark::SetUp();
license_ = CreateLicense();
key_mode_ = GetParam();
license_ = CreateLicense(key_mode_);
} }
void TearDown() override { WB_License_Delete(whitebox_); } void TearDown() override { WB_License_Delete(whitebox_); }
// Tells which key mode to use for process license response. We need to test
// with both single-key and dual-key.
WB_LicenseKeyMode key_mode_;
WB_License_Whitebox* whitebox_; WB_License_Whitebox* whitebox_;
License license_; License license_;
}; };
TEST_F(LicenseWhiteboxProcessLicenseResponseBenchmark, TEST_P(LicenseWhiteboxProcessLicenseResponseBenchmark,
CreateAndProcessLicenseResponseAndDelete) { CreateAndProcessLicenseResponseAndDelete) {
Timer timer; Timer timer;
Sampler sampler; Sampler sampler;
@@ -45,12 +54,12 @@ TEST_F(LicenseWhiteboxProcessLicenseResponseBenchmark,
ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK); ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK);
ASSERT_EQ(WB_License_ProcessLicenseResponse( ASSERT_EQ(WB_License_ProcessLicenseResponse(
whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY, whitebox_, key_mode_, license_.core_message.data(),
license_.core_message.data(), license_.core_message.size(), license_.core_message.size(), license_.message.data(),
license_.message.data(), license_.message.size(), license_.message.size(), license_.signature.data(),
license_.signature.data(), license_.signature.size(), license_.signature.size(), license_.session_key.data(),
license_.session_key.data(), license_.session_key.size(), license_.session_key.size(), license_.request.data(),
license_.request.data(), license_.request.size()), license_.request.size()),
WB_RESULT_OK); WB_RESULT_OK);
WB_License_Delete(whitebox_); WB_License_Delete(whitebox_);
@@ -64,7 +73,7 @@ TEST_F(LicenseWhiteboxProcessLicenseResponseBenchmark,
sampler, license_.message.size()); sampler, license_.message.size());
} }
TEST_F(LicenseWhiteboxProcessLicenseResponseBenchmark, TEST_P(LicenseWhiteboxProcessLicenseResponseBenchmark,
CreateAndProcessLicenseResponse) { CreateAndProcessLicenseResponse) {
Timer timer; Timer timer;
Sampler sampler; Sampler sampler;
@@ -78,12 +87,12 @@ TEST_F(LicenseWhiteboxProcessLicenseResponseBenchmark,
ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK); ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK);
ASSERT_EQ(WB_License_ProcessLicenseResponse( ASSERT_EQ(WB_License_ProcessLicenseResponse(
whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY, whitebox_, key_mode_, license_.core_message.data(),
license_.core_message.data(), license_.core_message.size(), license_.core_message.size(), license_.message.data(),
license_.message.data(), license_.message.size(), license_.message.size(), license_.signature.data(),
license_.signature.data(), license_.signature.size(), license_.signature.size(), license_.session_key.data(),
license_.session_key.data(), license_.session_key.size(), license_.session_key.size(), license_.request.data(),
license_.request.data(), license_.request.size()), license_.request.size()),
WB_RESULT_OK); WB_RESULT_OK);
sampler.Push(timer.Get()); sampler.Push(timer.Get());
@@ -96,7 +105,7 @@ TEST_F(LicenseWhiteboxProcessLicenseResponseBenchmark,
license_.message.size()); license_.message.size());
} }
TEST_F(LicenseWhiteboxProcessLicenseResponseBenchmark, ProcessLicenseResponse) { TEST_P(LicenseWhiteboxProcessLicenseResponseBenchmark, ProcessLicenseResponse) {
Timer timer; Timer timer;
Sampler sampler; Sampler sampler;
@@ -109,12 +118,12 @@ TEST_F(LicenseWhiteboxProcessLicenseResponseBenchmark, ProcessLicenseResponse) {
timer.Reset(); timer.Reset();
ASSERT_EQ(WB_License_ProcessLicenseResponse( ASSERT_EQ(WB_License_ProcessLicenseResponse(
whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY, whitebox_, key_mode_, license_.core_message.data(),
license_.core_message.data(), license_.core_message.size(), license_.core_message.size(), license_.message.data(),
license_.message.data(), license_.message.size(), license_.message.size(), license_.signature.data(),
license_.signature.data(), license_.signature.size(), license_.signature.size(), license_.session_key.data(),
license_.session_key.data(), license_.session_key.size(), license_.session_key.size(), license_.request.data(),
license_.request.data(), license_.request.size()), license_.request.size()),
WB_RESULT_OK); WB_RESULT_OK);
sampler.Push(timer.Get()); sampler.Push(timer.Get());
@@ -126,4 +135,13 @@ TEST_F(LicenseWhiteboxProcessLicenseResponseBenchmark, ProcessLicenseResponse) {
PrettyPrint("License White-box Process License Duration", sampler, PrettyPrint("License White-box Process License Duration", sampler,
license_.message.size()); license_.message.size());
} }
INSTANTIATE_TEST_SUITE_P(SingleKey,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(WB_LICENSE_KEY_MODE_SINGLE_KEY));
INSTANTIATE_TEST_SUITE_P(DualKey,
LicenseWhiteboxProcessLicenseResponseBenchmark,
::testing::Values(WB_LICENSE_KEY_MODE_DUAL_KEY));
} // namespace widevine } // namespace widevine

36
whitebox/api/license_whitebox_sign_benchmark.cc
View File

@@ -23,7 +23,9 @@ constexpr size_t kIterations = 100;
} // namespace } // namespace
class LicenseWhiteboxSignBenchmark : public LicenseWhiteboxBenchmark { class LicenseWhiteboxSignBenchmark
: public LicenseWhiteboxBenchmark,
public testing::WithParamInterface<WB_LicenseKeyMode> {
protected: protected:
void SetUp() override { void SetUp() override {
LicenseWhiteboxBenchmark::SetUp(); LicenseWhiteboxBenchmark::SetUp();
@@ -31,28 +33,34 @@ class LicenseWhiteboxSignBenchmark : public LicenseWhiteboxBenchmark {
message_ = Data().Get(kMessageSize); message_ = Data().Get(kMessageSize);
signature_.resize(kSignatureSize); signature_.resize(kSignatureSize);
key_mode_ = GetParam();
ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK); ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK);
const auto license = CreateLicense(); const auto license = CreateLicense(key_mode_);
ASSERT_EQ(WB_License_ProcessLicenseResponse( ASSERT_EQ(WB_License_ProcessLicenseResponse(
whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY, whitebox_, key_mode_, license.core_message.data(),
license.core_message.data(), license.core_message.size(), license.core_message.size(), license.message.data(),
license.message.data(), license.message.size(), license.message.size(), license.signature.data(),
license.signature.data(), license.signature.size(), license.signature.size(), license.session_key.data(),
license.session_key.data(), license.session_key.size(), license.session_key.size(), license.request.data(),
license.request.data(), license.request.size()), license.request.size()),
WB_RESULT_OK); WB_RESULT_OK);
} }
void TearDown() override { WB_License_Delete(whitebox_); } void TearDown() override { WB_License_Delete(whitebox_); }
// Tells which key mode to use for process license response. We need to test
// with both single-key and dual-key.
WB_LicenseKeyMode key_mode_;
WB_License_Whitebox* whitebox_; WB_License_Whitebox* whitebox_;
std::vector<uint8_t> message_; std::vector<uint8_t> message_;
std::vector<uint8_t> signature_; std::vector<uint8_t> signature_;
}; };
TEST_F(LicenseWhiteboxSignBenchmark, SignLicenseRequest) { TEST_P(LicenseWhiteboxSignBenchmark, SignLicenseRequest) {
Timer timer; Timer timer;
Sampler sampler; Sampler sampler;
@@ -70,7 +78,7 @@ TEST_F(LicenseWhiteboxSignBenchmark, SignLicenseRequest) {
message_.size()); message_.size());
} }
TEST_F(LicenseWhiteboxSignBenchmark, SignRenewalRequest) { TEST_P(LicenseWhiteboxSignBenchmark, SignRenewalRequest) {
Timer timer; Timer timer;
Sampler sampler; Sampler sampler;
@@ -87,4 +95,12 @@ TEST_F(LicenseWhiteboxSignBenchmark, SignRenewalRequest) {
PrettyPrint("License White-box Sign Renewal Request Duration", sampler, PrettyPrint("License White-box Sign Renewal Request Duration", sampler,
message_.size()); message_.size());
} }
INSTANTIATE_TEST_SUITE_P(SingleKey,
LicenseWhiteboxSignBenchmark,
::testing::Values(WB_LICENSE_KEY_MODE_SINGLE_KEY));
INSTANTIATE_TEST_SUITE_P(DualKey,
LicenseWhiteboxSignBenchmark,
::testing::Values(WB_LICENSE_KEY_MODE_DUAL_KEY));
} // namespace widevine } // namespace widevine

2
whitebox/api/license_whitebox_verify_benchmark.cc
View File

@@ -29,7 +29,7 @@ class LicenseWhiteboxVerifyBenchmark : public LicenseWhiteboxBenchmark {
ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK); ASSERT_EQ(WB_License_Create(&whitebox_), WB_RESULT_OK);
const auto license = CreateLicense(); const auto license = CreateLicense(WB_LICENSE_KEY_MODE_DUAL_KEY);
ASSERT_EQ(WB_License_ProcessLicenseResponse( ASSERT_EQ(WB_License_ProcessLicenseResponse(
whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY, whitebox_, WB_LICENSE_KEY_MODE_DUAL_KEY,
license.core_message.data(), license.core_message.size(), license.core_message.data(), license.core_message.size(),

378
whitebox/api/test_license_whitebox_keys_general.cc
View File

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

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

@@ -324,11 +324,6 @@ WB_Result WB_License_ProcessLicenseResponse(WB_License_Whitebox* whitebox,
return WB_RESULT_INVALID_PARAMETER; return WB_RESULT_INVALID_PARAMETER;
} }
if (session_key_size != 256) {
DVLOG(1) << "Invalid parameter: invalid session key size.";
return WB_RESULT_INVALID_PARAMETER;
}
const RsaPrivateKey* private_key = nullptr; const RsaPrivateKey* private_key = nullptr;
switch (license_key_mode) { switch (license_key_mode) {
@@ -349,6 +344,15 @@ WB_Result WB_License_ProcessLicenseResponse(WB_License_Whitebox* whitebox,
CHECK(private_key); CHECK(private_key);
// Defer checking the session key size until we know which private key we are
// going to use. This will allow us to verify the session key size using the
// private key (rather than using a fixed number).
if (session_key_size != private_key->KeySize()) {
DVLOG(1) << "Invalid parameter: session key size (" << session_key_size
<< " != " << private_key->KeySize() << ").";
return WB_RESULT_INVALID_PARAMETER;
}
// From talking with Intertrust, they suggested allowing an invalid session // From talking with Intertrust, they suggested allowing an invalid session
// key to propogate through the system, leading to the message verification // key to propogate through the system, leading to the message verification
// failing. While we could do that, in the reference, we opt to just return // failing. While we could do that, in the reference, we opt to just return