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

Merges to android Pi release (part: 1)

Browse Source 
Below are a set of CLs being merged from the wv cdm repo to the android repo.

* Fix handling of OEM Cert public key.

  Author: Srujan Gaddam <srujzs@google.com>

  [ Merge of http://go/wvgerrit/27921 ]

  This is a potential fix for b/36656190. Set aside public
  key on first call to get the public key, and use it afterwards.
  This gets rid of extra calls to OEMCrypto_GetOEMPublicCertificate(),
  which has side-effect of staging the OEM private key.

  This also fixes a problem where the public cert string was
  not being trimmed to match the size returned by
  OEMCrypto_GetOEMPublicCertificate().

* Complete provisioning request/response for Provisioning 3.0

  Author: Gene Morgan <gmorgan@google.com>

  [ Merge of http://go/wvgerrit/27780 ]

  Fix bug on provisioning request path where GenerateDerivedKeys()
  was being called when preparing to generate the signature.

  Add message signature verification, and call correct OEMCrypto
  routine to rewrap the private key (OEMCrypto_RewrapDeviceRSAKey30).

* Implement Cdm::deleteAllUsageRecords()

  Author: Gene Morgan <gmorgan@google.com>

  [ Merge of http://go/wvgerrit/27780 ]

  Delete all usage records for current origin.  Removes usage
  records from file system and retains the PSTs.  The deletes
  any usage entries matching those PSTs held by OEMCrypto.

  BUG: 35319024

* Remove stringencoders library from third_party.

  Author: Jacob Trimble <modmaker@google.com>

  [ Merge of http://go/wvgerrit/27585 ]

  We have a fork of the stringencoders library that we use for base64
  encoding.  This reimplements base64 encoding to remove the extra
  dependency and to reduce the amount of code.

* Add Cdm::deleteUsageRecord() based on key_set_id.

  Author: Gene Morgan <gmorgan@google.com>

  [ Merge of http://go/wvgerrit/27605 ]

  Delete specified usage record from file system usage info and
  from OEMCrypto.

  BUG: 35319024

* Modifiable OEMCrypto

  Author: Fred Gylys-Colwell <fredgc@google.com>

  [ Merge of http://go/wvgerrit/24729 ]

  This CL adds a new variant of the OEMCrypto mock code that adjusts its
  behavior based on a configuration file.  This is intended for
  testing.

  For example, a tester can set current_hdcp to 2 in the options.txt
  file, push it to the device, and verify that a license is granted for
  HDCP 2.0.  Then the tester can edit the value of current_hdcp to 1 and
  push the file to the device.  Playback should stop because the license
  is no longer valid.

  This variant uses a real level 1 liboemcrypto.so to push data to a
  secure buffer.  That means we can test playback for a license that
  requires secure buffers on an Android device with real secure buffers.

  BUG: 35141278
  BUG: 37353534

BUG: 71650075
Test: Not currently passing. Will be addressed in a subsequent
      commit in the chain.

Change-Id: I58443c510919e992bb455192e70373490a00e2b6
This commit is contained in:
Rahul Frias
2018-01-05 17:05:18 -08:00
parent e34f83cdce
commit 0419b55222
120 changed files with 5402 additions and 6827 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -78,7 +78,6 @@ typedef enum OEMCryptoResult {
OEMCrypto_ERROR_LICENSE_INACTIVE = 47,
OEMCrypto_ERROR_ENTRY_NEEDS_UPDATE = 48,
OEMCrypto_ERROR_ENTRY_IN_USE = 49,
OEMCrypto_ERROR_USAGE_TABLE_UNRECOVERABLE = 50, // Reserved. Do not use.
} OEMCryptoResult;
/*

3
libwvdrmengine/oemcrypto/mock/Android.mk
View File

@@ -26,7 +26,6 @@ LOCAL_C_INCLUDES += \
$(LOCAL_PATH)/../include \
$(LOCAL_PATH)/src \
vendor/widevine/libwvdrmengine/cdm/core/include \
vendor/widevine/libwvdrmengine/third_party/stringencoders/src \
LOCAL_SHARED_LIBRARIES := \
libcutils \
@@ -39,7 +38,7 @@ LOCAL_SHARED_LIBRARIES := \
LOCAL_STATIC_LIBRARIES := \
libcdm_utils \
libcrypto \
libcrypto_static \
# Proprietary modules are put in vendor/lib instead of /system/lib.
LOCAL_PROPRIETARY_MODULE := true

765
libwvdrmengine/oemcrypto/mock/src/oem_cert.h
View File

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

4
libwvdrmengine/oemcrypto/mock/src/oemcrypto_auth_mock.h
View File

@@ -8,7 +8,7 @@
#include <stdint.h>
#include <vector>
#include "openssl/rsa.h"
#include <openssl/rsa.h>
#include "OEMCryptoCENC.h" // Needed for enums only.
#include "oemcrypto_key_mock.h"
@@ -44,7 +44,7 @@ class AuthenticationRoot {
return keybox().key_data_length();
}
const uint8_t* const DeviceToken() {
const uint8_t* DeviceToken() {
return keybox().key_data();
}

123
libwvdrmengine/oemcrypto/mock/src/oemcrypto_engine_device_properties_mod.cpp
View File

@@ -34,9 +34,14 @@
// an OEMCryptoResult and returned.
// srm_load_version: If this is set, then it will be used as the
// new srm version after loading an SRM -- ignoring the contents of the SRM.
// If srm_load_version is -1, then the buffer passed into LoadSRM will be
// parsed.
// srm_blacklisted_device_attached: If set to "1", then a
// oemcrypto will act as if a blacklisted device is attached -- i.e.
// playback will be restricted to the local display only.
// srm_attached_device_id: If nonzero, the id of a blacklisted device.
// If this id is in the revocation list of an SRM file when it is loaded,
// playback will be restricted to the local display only.
// security_patch_level: This is the value returned by
// OEMCrypto_Security_Patch_Level. If the key control block requires a
// higher level, then OEMCrypto_LoadKeys will fail.
@@ -72,6 +77,7 @@
#include "oemcrypto_engine_mock.h"
#include "oemcrypto_logging.h"
#include "properties.h"
#include "string_conversions.h"
namespace wvoec_mock {
namespace {
@@ -126,9 +132,9 @@ class AndroidModifiableCryptoEngine : public CryptoEngine {
}
while (!feof(file)) {
char name[80 + 1];
int value;
if (fscanf(file, "%80s %d", name, &value)) {
LOGV("Option %s = %d", name, value);
int64_t value;
if (fscanf(file, "%80s %lld", name, &value)) {
LOGD("Option %s = %lld", name, value);
options_[std::string(name)] = value;
}
}
@@ -136,17 +142,17 @@ class AndroidModifiableCryptoEngine : public CryptoEngine {
InitializeLogging();
}
int GetOption(const std::string &key, int default_value) {
int64_t GetOption(const std::string &key, int64_t default_value) {
MaybeReadOptionsFile();
if (options_.find(key) == options_.end() ) {
LOGV("Option %s not set. Using default %d", key.c_str(), default_value);
LOGW("Option %s not set. Using default %lld", key.c_str(), default_value);
return default_value;
}
return options_[key];
}
void InitializeLogging() {
int log_level = GetOption("log_level", 3);
int log_level = GetOption("log_level", wvcdm::LOG_DEBUG);
int categories = 0;
if (GetOption("kLoggingTraceOEMCryptoCalls", 0) > 0)
categories |= kLoggingTraceOEMCryptoCalls;
@@ -362,6 +368,19 @@ class AndroidModifiableCryptoEngine : public CryptoEngine {
}
}
// Convert uint24 or uint40 into a uint64.
int64_t unpack_odd_bytes(const uint8_t *buffer, size_t length) {
uint8_t small_buffer[8];
memset(small_buffer, 0, 8);
if (length > 8) {
LOGE("OEMCrypto Mock: programmer error. unpack %d bytes.", length);
length = 8;
}
size_t offset = 8 - length;
memcpy(small_buffer + offset, buffer, length);
return wvcdm::htonll64(*reinterpret_cast<const int64_t*>(small_buffer));
}
OEMCryptoResult load_srm(const uint8_t *buffer, size_t buffer_length) {
if (!srm_update_supported()) {
LOGE("OEMCrypto mock update not supported, but load_srm called.");
@@ -384,29 +403,65 @@ class AndroidModifiableCryptoEngine : public CryptoEngine {
srm_loaded_ = true;
return OEMCrypto_SUCCESS;
}
if (buffer_length < 4) {
LOGE("OEMCrypto mock bad buffer size: %d.", buffer_length);
if (buffer_length < 395) {
LOGE("OEMCrypto mock bad buffer size: %ld < 395.", buffer_length);
return OEMCrypto_ERROR_SHORT_BUFFER;
}
uint8_t srm_id = buffer[0];
uint8_t first_nibble = srm_id >> 4;
uint8_t second_nibble = srm_id & 0x0F;
uint8_t srm_id = buffer[0] >> 4;
uint8_t hdcp2_indicator = buffer[0] & 0x0F;
uint8_t reserved = buffer[1];
uint16_t version = htons(*reinterpret_cast<const uint16_t *>(&buffer[2]));
if (reserved)
if (reserved) {
LOGE("OEMCrypto mock. SRM's second byte nonzero: %02X.", reserved);
if (first_nibble == 8 && second_nibble == 0) {
LOGI("OEMCrypto mock loading HDCP1 SRM. version = %d.", version);
} else if (first_nibble == 9 && second_nibble == 1) {
LOGI("OEMCrypto mock loading HDCP2 SRM. version = %d.", version);
return OEMCrypto_ERROR_INVALID_CONTEXT;
}
uint8_t generation = buffer[4];
if (generation > 1) {
LOGW("OEMCrypto mock. SRM Generation number is %d, but only first gen is parsed.",
generation);
LOGW("If the revoked device is in a a later generation, it will not be recognized.");
}
int64_t length = unpack_odd_bytes(buffer + 5, 3); // 24 bits.
if (length + 5 != buffer_length) {
LOGW("OEMCrypto mock. SRM length is %lld = 0x%llx, but I expected %zd = 0x%zx.",
length, length, buffer_length - 5, buffer_length - 5);
}
int64_t count = 0;
const uint8_t *ids;
if (srm_id == 8 && hdcp2_indicator == 0) {
// https://www.digital-cp.com/sites/default/files/specifications/HDCP%20Specification%20Rev1_4_Secure.pdf
count = buffer[8];
LOGI("OEMCrypto mock loading HDCP1 SRM. version = %d. count=%lld.",
version, count);
ids = buffer + 9;
if (buffer_length < 9 + count*5) {
LOGE("OEMCrypto mock bad buffer size for count = %lld: %d < %lld.",
count, buffer_length, 12 + count*5);
return OEMCrypto_ERROR_SHORT_BUFFER;
}
} else if (srm_id == 9 && hdcp2_indicator == 1) {
// https://www.digital-cp.com/sites/default/files/specifications/HDCP%20on%20HDMI%20Specification%20Rev2_2_Final1.pdf
count = unpack_odd_bytes(buffer + 8, 2) >> 6; // 10 bits = 2 bytes - 6.
LOGI("OEMCrypto mock loading HDCP2 SRM. version = %d. count=%lld.",
version, count);
ids = buffer + 12;
if (buffer_length < 12 + count*5) {
LOGE("OEMCrypto mock bad buffer size for count: %d < %ld.",
buffer_length, 12 + count*5);
return OEMCrypto_ERROR_SHORT_BUFFER;
}
} else {
LOGE("OEMCrypto mock bad buffer start: %02X%02X%02X%02X...", buffer[0],
buffer[1], buffer[2], buffer[3]);
return OEMCrypto_ERROR_INVALID_CONTEXT;
}
// Note: we ignore the signature. Use system property srm_load_fail to
// simulate a bad signature.
for(size_t i = 0; i < count; i++) {
int64_t id = unpack_odd_bytes(ids + 5*i, 5);
srm_revocation_list_.push_back(id);
LOGI("OEMCrypto mock SRM revokes device %lld = 0x%llx", id, id);
}
srm_loaded_ = true;
srm_version_ = version;
return OEMCrypto_SUCCESS;
}
@@ -421,6 +476,9 @@ class AndroidModifiableCryptoEngine : public CryptoEngine {
}
bool srm_blacklisted_device_attached() {
if (GetOption("srm_load_version", -1) < 0) {
return scan_revoked_list();
}
static int blacklisted = 0;
int new_value = GetOption("srm_blacklisted_device_attached", 0);
if (new_value != blacklisted) {
@@ -431,6 +489,31 @@ class AndroidModifiableCryptoEngine : public CryptoEngine {
return blacklisted > 0;
}
bool scan_revoked_list() {
static int64_t old_attached_id = 0;
int64_t attached_id = GetOption("srm_attached_device_id", 0);
bool print_all_ids = false;
if (attached_id != old_attached_id) {
LOGD("OEMCrypto mock -- ID of attached device is %lld = 0x%lld",
attached_id, attached_id);
old_attached_id = attached_id;
print_all_ids = true;
}
for (size_t i = 0; i < srm_revocation_list_.size(); i++) {
if (print_all_ids) {
LOGD("OEMCrypto mock: %d) revoked id %lld = 0x%lld.", i,
srm_revocation_list_[i], srm_revocation_list_[i]);
}
if (srm_revocation_list_[i] == attached_id) {
LOGD("OEMCrypto mock: attached device %lld = 0x%lld is revoked.",
attached_id, attached_id);
return true;
}
}
LOGD("OEMCrypto mock: attached device %lld is not revoked.", attached_id);
return false;
}
virtual void adjust_destination(OEMCrypto_DestBufferDesc *out_description,
size_t data_length, uint8_t subsample_flags) {
if (out_description->type != OEMCrypto_BufferType_Secure) return;
@@ -488,8 +571,10 @@ class AndroidModifiableCryptoEngine : public CryptoEngine {
// Current srm version. Before an SRM has been loaded, this will be set from
// the system property.
int srm_version_;
// List of forbidden/revoked devices.
std::vector<int64_t> srm_revocation_list_;
std::map<std::string, int> options_;
std::map<std::string, int64_t> options_;
std::string options_file_;
bool level1_valid_;

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

@@ -59,7 +59,7 @@ class CryptoEngine {
size_t DeviceRootTokenLength() { return root_of_trust_.DeviceTokenLength(); }
const uint8_t* const DeviceRootToken() {
const uint8_t* DeviceRootToken() {
return root_of_trust_.DeviceToken();
}

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

@@ -1314,6 +1314,9 @@ extern "C" OEMCryptoResult OEMCrypto_GetHDCPCapability(
if (maximum == NULL) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
*current = crypto_engine->config_current_hdcp_capability();
*maximum = crypto_engine->config_maximum_hdcp_capability();
if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
LOGI("-- current_hdcp=%d, max_hdcp=%d\n", *current, *maximum);
}
return OEMCrypto_SUCCESS;
}
@@ -1602,15 +1605,14 @@ extern "C" OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
}
extern "C" OEMCryptoResult OEMCrypto_DeleteUsageEntry(
OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length,
const uint8_t* message, size_t message_length, const uint8_t* signature,
size_t signature_length) {
OEMCrypto_SESSION, const uint8_t*, size_t, const uint8_t*, size_t,
const uint8_t*, size_t) {
// TODO(fredgc): delete this.
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(const uint8_t* pst,
size_t pst_length) {
extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(const uint8_t*,
size_t) {
// TODO(fredgc): delete this.
return OEMCrypto_ERROR_NOT_IMPLEMENTED;
}
@@ -1637,7 +1639,12 @@ extern "C" bool OEMCrypto_IsSRMUpdateSupported() {
LOGE("OEMCrypto_IsSRMUpdateSupported: OEMCrypto Not Initialized.");
return false;
}
return crypto_engine->srm_update_supported();
bool result = crypto_engine->srm_update_supported();
if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
LOGI("-- OEMCryptoResult OEMCrypto_IsSRMUpdateSupported returning %s\n",
result ? "TRUE" : "FALSE");
}
return result;
}
extern "C" OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(uint16_t* version) {
@@ -1651,7 +1658,13 @@ extern "C" OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(uint16_t* version) {
if (crypto_engine->config_local_display_only()) {
return OEMCrypto_LOCAL_DISPLAY_ONLY;
}
return crypto_engine->current_srm_version(version);
OEMCryptoResult result = crypto_engine->current_srm_version(version);
if (result == OEMCrypto_SUCCESS &&
LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
LOGI("-- OEMCryptoResult OEMCrypto_GetCurrentSRMVersion returning %d\n",
*version);
}
return result;
}
extern "C" OEMCryptoResult OEMCrypto_LoadSRM(const uint8_t* buffer,

8
libwvdrmengine/oemcrypto/mock/src/oemcrypto_rsa_key_shared.cpp
View File

@@ -48,8 +48,12 @@ bool RSA_shared_ptr::LoadPkcs8RsaKey(const uint8_t* buffer, size_t length) {
bool success = true;
PKCS8_PRIV_KEY_INFO* pkcs8_pki = d2i_PKCS8_PRIV_KEY_INFO_bio(bio, NULL);
if (pkcs8_pki == NULL) {
LOGE("[LoadPkcs8RsaKey(): d2i_PKCS8_PRIV_KEY_INFO_bio returned NULL]");
success = false;
BIO_reset(bio);
pkcs8_pki = d2i_PKCS8_PRIV_KEY_INFO_bio(bio, NULL);
if (pkcs8_pki == NULL) {
LOGE("[LoadPkcs8RsaKey(): d2i_PKCS8_PRIV_KEY_INFO_bio returned NULL]");
success = false;
}
}
EVP_PKEY* evp = NULL;
if (success) {

17
libwvdrmengine/oemcrypto/mock/src/oemcrypto_session.cpp
View File

@@ -192,14 +192,9 @@ bool SessionContext::GenerateSignature(const uint8_t* message,
return false;
}
const uint8_t *mac_key = NULL;
if (mac_key_client_.size() == wvcdm::MAC_KEY_SIZE) {
// If we have a mac key, use it.
mac_key = &mac_key_client_[0];
} else if (usage_entry_status_ == kUsageEntryLoaded) {
// If not, but we have a usage entry, use its key.
mac_key = usage_entry_->mac_key_client();
} else {
if (mac_key_client_.empty() ||
mac_key_client_.size() != wvcdm::MAC_KEY_SIZE) {
LOGE("[GenerateSignature(): No MAC Key]");
return false;
}
@@ -209,7 +204,7 @@ bool SessionContext::GenerateSignature(const uint8_t* message,
}
unsigned int md_len = *signature_length;
if (HMAC(EVP_sha256(), mac_key, wvcdm::MAC_KEY_SIZE, message,
if (HMAC(EVP_sha256(), &mac_key_client_[0], mac_key_client_.size(), message,
message_length, signature, &md_len)) {
*signature_length = md_len;
return true;
@@ -426,6 +421,8 @@ OEMCryptoResult SessionContext::LoadKeys(
LOGW("[LoadKeys: SRM blacklisted device attached]");
srm_requirements_status_ = InvalidSRMVersion;
} else {
LOGI("[LoadKeys: SRM Versions is %d, required: %d]",
current_version, minimum_version);
srm_requirements_status_ = ValidSRMVersion;
}
}
@@ -736,7 +733,7 @@ bool SessionContext::LoadRSAKey(const uint8_t* pkcs8_rsa_key,
return false;
}
if ((memcmp(pkcs8_rsa_key, "SIGN", 4) == 0)) {
uint32_t* schemes_n = (uint32_t*)(pkcs8_rsa_key + 4);
const uint32_t* schemes_n = (const uint32_t*)(pkcs8_rsa_key + 4);
allowed_schemes_ = htonl(*schemes_n);
pkcs8_rsa_key += 8;
rsa_key_length -= 8;

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

@@ -69,8 +69,6 @@ class UsageTableEntry {
void set_index(int32_t index) { data_.index = index; }
uint32_t index() { return data_.index; }
static size_t SignedEntrySize();
const uint8_t* mac_key_server() { return data_.mac_key_server; }
const uint8_t* mac_key_client() { return data_.mac_key_client; }
private:
UsageTable* usage_table_; // Owner of this object.
@@ -81,11 +79,8 @@ class UsageTableEntry {
class UsageTable {
public:
UsageTable(CryptoEngine* ce, wvcdm::FileSystem* /* file_system */)
: ce_(ce),
/* TODO: unused: file_system_(file_system), */
header_loaded_(false),
old_table_(NULL){};
explicit UsageTable(CryptoEngine* ce)
: ce_(ce), header_loaded_(false), old_table_(NULL){};
~UsageTable();
OEMCryptoResult CreateNewUsageEntry(SessionContext* session,
@@ -128,7 +123,6 @@ class UsageTable {
bool LoadGenerationNumber(bool or_make_new_one);
CryptoEngine* ce_;
/* TODO: unused: wvcdm::FileSystem* file_system_; */
bool header_loaded_;
int64_t master_generation_number_;
std::vector<int64_t> generation_numbers_;

4
libwvdrmengine/oemcrypto/test/Android.mk
View File

@@ -6,10 +6,8 @@ LOCAL_MODULE:=oemcrypto_test
LOCAL_MODULE_TAGS := tests
LOCAL_MODULE_OWNER := widevine
LOCAL_PROPRIETARY_MODULE := true
# When built, explicitly put it in the DATA/bin directory.
LOCAL_MODULE_PATH := $(TARGET_OUT_DATA)/bin
LOCAL_PROPRIETARY_MODULE := true
ifneq ($(TARGET_ENABLE_MEDIADRM_64), true)
LOCAL_MODULE_TARGET_ARCH := arm x86 mips

3
libwvdrmengine/oemcrypto/test/common.mk
View File

@@ -16,7 +16,6 @@ LOCAL_C_INCLUDES += \
$(LOCAL_PATH)/../include \
$(LOCAL_PATH)/../mock/src \
vendor/widevine/libwvdrmengine/cdm/core/include \
vendor/widevine/libwvdrmengine/third_party/stringencoders/src \
LOCAL_STATIC_LIBRARIES := \
libcdm \
@@ -31,7 +30,7 @@ LOCAL_SHARED_LIBRARIES := \
libcutils \
libdl \
liblog \
libmedia_omx \
libmedia \
libstagefright_foundation \
libutils \
libz \

2
libwvdrmengine/oemcrypto/test/oec_device_features.cpp
View File

@@ -218,6 +218,8 @@ const char* ProvisioningMethodName(OEMCrypto_ProvisioningMethod method) {
case OEMCrypto_OEMCertificate:
return "OEMCrypto_OEMCertificate";
}
// Not reachable
return "";
}
} // namespace wvoec

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

@@ -589,35 +589,45 @@ void Session::LoadOEMCert(bool verify_cert) {
openssl_ptr<BIO, BIO_vfree> bio(
BIO_new_mem_buf(&public_cert[0], public_cert_length));
ASSERT_TRUE(bio.NotNull());
openssl_ptr<X509, X509_free> cert(
PEM_read_bio_X509(bio.get(), NULL, 0, NULL));
openssl_ptr<PKCS7, PKCS7_free> cert(
d2i_PKCS7_bio(bio.get(), NULL));
ASSERT_TRUE(cert.NotNull());
openssl_ptr<EVP_PKEY, EVP_PKEY_free> pubkey(X509_get_pubkey(cert.get()));
ASSERT_TRUE(pubkey.NotNull());
public_rsa_ = EVP_PKEY_get1_RSA(pubkey.get());
if (!public_rsa_) {
cout << "d2i_RSAPrivateKey failed.\n";
dump_openssl_error();
ASSERT_TRUE(NULL != public_rsa_);
}
if (verify_cert) {
vector<char> buffer(80);
X509_NAME* name = X509_get_subject_name(cert.get());
printf(" OEM Certificate Name: %s\n",
X509_NAME_oneline(name, &buffer[0], buffer.size()));
openssl_ptr<X509_STORE, X509_STORE_free> store(X509_STORE_new());
ASSERT_TRUE(store.NotNull());
openssl_ptr<X509_STORE_CTX, X509_STORE_CTX_free> store_ctx(
X509_STORE_CTX_new());
ASSERT_TRUE(store_ctx.NotNull());
X509_STORE_CTX_init(store_ctx.get(), store.get(), cert.get(), NULL);
// TODO(fredgc): Verify cert is signed by Google.
int result = X509_verify_cert(store_ctx.get());
ASSERT_GE(0, result) << " OEM Cert not valid. "
<< X509_verify_cert_error_string(store_ctx->error);
if (result == 0) {
printf("Cert not verified: %s.\n",
X509_verify_cert_error_string(store_ctx->error));
EXPECT_EQ(OBJ_obj2nid(cert->type), NID_pkcs7_signed);
STACK_OF(X509)* certs = cert->d.sign->cert;
for (int i = 0; certs && i < sk_X509_num(certs); i++) {
X509* x509_cert = sk_X509_value(certs, i);
openssl_ptr<EVP_PKEY, EVP_PKEY_free> pubkey(X509_get_pubkey(x509_cert));
ASSERT_TRUE(pubkey.NotNull());
if (i == 0) {
public_rsa_ = EVP_PKEY_get1_RSA(pubkey.get());
if (!public_rsa_) {
cout << "d2i_RSAPrivateKey failed.\n";
dump_openssl_error();
ASSERT_TRUE(NULL != public_rsa_);
}
}
if (verify_cert) {
vector<char> buffer(80);
X509_NAME* name = X509_get_subject_name(x509_cert);
printf(" OEM Certificate Name: %s\n",
X509_NAME_oneline(name, &buffer[0], buffer.size()));
openssl_ptr<X509_STORE, X509_STORE_free> store(X509_STORE_new());
ASSERT_TRUE(store.NotNull());
openssl_ptr<X509_STORE_CTX, X509_STORE_CTX_free> store_ctx(
X509_STORE_CTX_new());
ASSERT_TRUE(store_ctx.NotNull());
X509_STORE_CTX_init(store_ctx.get(), store.get(), x509_cert, NULL);
// TODO(fredgc): Verify cert is signed by Google.
int result = X509_verify_cert(store_ctx.get());
ASSERT_GE(0, result) << " OEM Cert not valid. "
<< X509_verify_cert_error_string(store_ctx->error);
if (result == 0) {
printf("Cert not verified: %s.\n",
X509_verify_cert_error_string(store_ctx->error));
}
}
}
}
@@ -673,6 +683,7 @@ void Session::RewrapRSAKey(const struct RSAPrivateKeyMessage& encrypted,
wrapped_key->clear();
}
}
void Session::RewrapRSAKey30(const struct RSAPrivateKeyMessage& encrypted,
const std::vector<uint8_t>& encrypted_message_key,
vector<uint8_t>* wrapped_key, bool force) {
@@ -786,9 +797,11 @@ void Session::VerifyRSASignature(const vector<uint8_t>& message,
RSA_Padding_Scheme padding_scheme) {
EXPECT_TRUE(NULL != public_rsa_)
<< "No public RSA key loaded in test code.\n";
EXPECT_EQ(static_cast<size_t>(RSA_size(public_rsa_)), signature_length)
<< "Signature size is wrong. " << signature_length << ", should be "
<< RSA_size(public_rsa_) << "\n";
if (padding_scheme == kSign_RSASSA_PSS) {
openssl_ptr<EVP_PKEY, EVP_PKEY_free> pkey(EVP_PKEY_new());
ASSERT_EQ(1, EVP_PKEY_set1_RSA(pkey.get(), public_rsa_));
@@ -927,9 +940,6 @@ void Session::GenerateReport(const std::string& pst,
EXPECT_GE(kHardwareSecureClock, pst_report().clock_security_level());
EXPECT_EQ(pst.length(), pst_report().pst_length());
EXPECT_EQ(0, memcmp(pst.c_str(), pst_report().pst(), pst.length()));
// Also, we the session to be able to sign the release message with the
// correct mac keys from the usage table entry.
ASSERT_NO_FATAL_FAILURE(VerifyClientSignature());
}
void Session::VerifyPST(const Test_PST_Report& expected) {

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

@@ -18,7 +18,9 @@ using namespace std;
// GTest requires PrintTo to be in the same namespace as the thing it prints,
// which is std::vector in this case.
namespace std {
void PrintTo(const vector<uint8_t>& value, ostream* os);
} // namespace std
namespace wvoec {
@@ -293,8 +295,7 @@ class Session {
wvcdm::Unpacked_PST_Report pst_report() {
return wvcdm::Unpacked_PST_Report(&pst_report_buffer_[0]);
}
// Verify the values in the PST report. The signature should have been
// verified in GenerateReport, above.
// Verify the PST report.
void VerifyPST(const Test_PST_Report& report);
// Generate and Verify the Usage Report. If any time is greater than 10
// minutes, it is assumed to be an absolute time, and time_since will be

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

@@ -590,7 +590,6 @@ TEST_F(OEMCryptoProv30Test, OEMCertSignatureLargeBuffer) {
ASSERT_NO_FATAL_FAILURE(s.LoadOEMCert());
OEMCryptoResult sts;
// Sign a Message
static size_t kMaxMessageSize = 8 * 1024;
vector<uint8_t> data(kMaxMessageSize);
RAND_pseudo_bytes(&data[0], data.size());
size_t signature_length = 0;
@@ -1198,7 +1197,7 @@ TEST_P(SessionTestAlternateVerification, LoadKeys) {
if (target_api_ > 8 && target_api_ < 100) {
snprintf(buffer, 5, "kc%02d", target_api_);
}
for (size_t i = 0; i < s.num_keys(); i++) {
for (unsigned int i = 0; i < s.num_keys(); i++) {
memcpy(s.license().keys[i].control.verification, buffer, 4);
}
ASSERT_NO_FATAL_FAILURE(s.EncryptAndSign());
@@ -1332,19 +1331,21 @@ TEST_F(OEMCryptoSessionTests, AntiRollbackHardwareRequired) {
TEST_F(OEMCryptoSessionTests, CheckMinimumPatchLevel) {
uint8_t patch_level = OEMCrypto_Security_Patch_Level();
printf(" Current Patch Level: %u.\n", patch_level);
Session s;
ASSERT_NO_FATAL_FAILURE(s.open());
ASSERT_NO_FATAL_FAILURE(InstallTestSessionKeys(&s));
ASSERT_NO_FATAL_FAILURE(s.FillSimpleMessage(
0, patch_level << wvoec_mock::kControlSecurityPatchLevelShift, 0));
ASSERT_NO_FATAL_FAILURE(s.EncryptAndSign());
ASSERT_EQ(
OEMCrypto_SUCCESS,
OEMCrypto_LoadKeys(s.session_id(), s.message_ptr(), s.message_size(),
&s.signature()[0], s.signature().size(),
s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), NULL, 0, NULL));
{
Session s;
ASSERT_NO_FATAL_FAILURE(s.open());
ASSERT_NO_FATAL_FAILURE(InstallTestSessionKeys(&s));
ASSERT_NO_FATAL_FAILURE(s.FillSimpleMessage(
0, patch_level << wvoec_mock::kControlSecurityPatchLevelShift, 0));
ASSERT_NO_FATAL_FAILURE(s.EncryptAndSign());
ASSERT_EQ(
OEMCrypto_SUCCESS,
OEMCrypto_LoadKeys(s.session_id(), s.message_ptr(), s.message_size(),
&s.signature()[0], s.signature().size(),
s.encrypted_license().mac_key_iv,
s.encrypted_license().mac_keys, s.num_keys(),
s.key_array(), NULL, 0, NULL));
}
if (patch_level < 0x3F) {
Session s;
ASSERT_NO_FATAL_FAILURE(s.open());
@@ -4373,7 +4374,7 @@ class GenericCryptoKeyIdLengthTest : public GenericCryptoTest {
}
}
void TestWithKey(unsigned int key_index) {
void TestWithKey(int key_index) {
ASSERT_LT(key_index, session_.num_keys());
EncryptAndLoadKeys();
vector<uint8_t> encrypted;