2443fe807a
odk directory copied from wvgerrit. branch oemcrypto-v16 commit 0c9a7dc Bug: 140758896 Test: odk_test Change-Id: I0c631f771b794468a63e4395f6b9c3b60a1dfd4f
685 lines
24 KiB
C++
685 lines
24 KiB
C++
/*
|
|
* Copyright 2019 Google LLC. All Rights Reserved. This file and proprietary
|
|
* source code may only be used and distributed under the Widevine Master
|
|
* License Agreement.
|
|
*/
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <ctime>
|
|
#include <fstream>
|
|
#include <functional>
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <endian.h>
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "odk.h"
|
|
#include "odk_test.h"
|
|
#include "oec_util.h"
|
|
|
|
using namespace oec_util;
|
|
|
|
size_t ODK_FieldLength(ODK_FieldType type) {
|
|
switch (type) {
|
|
case ODK_UINT32:
|
|
return sizeof(uint32_t);
|
|
case ODK_UINT64:
|
|
return sizeof(uint64_t);
|
|
case ODK_SUBSTRING:
|
|
return sizeof(uint32_t) + sizeof(uint32_t);
|
|
case ODK_DEVICEID:
|
|
return ODK_DEVICE_ID_LEN_MAX;
|
|
case ODK_HASH:
|
|
return ODK_SHA256_HASH_SIZE;
|
|
default:
|
|
return SIZE_MAX;
|
|
}
|
|
}
|
|
|
|
size_t ODK_AllocSize(ODK_FieldType type) {
|
|
if (type == ODK_SUBSTRING) {
|
|
return sizeof(OEMCrypto_Substring);
|
|
}
|
|
return ODK_FieldLength(type);
|
|
}
|
|
|
|
OEMCryptoResult ODK_WriteSingleField(uint8_t* const buf,
|
|
const ODK_Field* const field) {
|
|
if (!buf || !field || !field->value) {
|
|
return ODK_ERROR_CORE_MESSAGE;
|
|
}
|
|
switch (field->type) {
|
|
case ODK_UINT32: {
|
|
uint32_t u32 = htobe32(*static_cast<uint32_t*>(field->value));
|
|
memcpy(buf, &u32, sizeof(u32));
|
|
break;
|
|
}
|
|
case ODK_UINT64: {
|
|
uint64_t u64 = htobe64(*static_cast<uint64_t*>(field->value));
|
|
memcpy(buf, &u64, sizeof(u64));
|
|
break;
|
|
}
|
|
case ODK_SUBSTRING: {
|
|
OEMCrypto_Substring* s = static_cast<OEMCrypto_Substring*>(field->value);
|
|
uint32_t off = htobe32(s->offset);
|
|
uint32_t len = htobe32(s->length);
|
|
memcpy(buf, &off, sizeof(off));
|
|
memcpy(buf + sizeof(off), &len, sizeof(len));
|
|
break;
|
|
}
|
|
case ODK_DEVICEID:
|
|
case ODK_HASH: {
|
|
const size_t field_len = ODK_FieldLength(field->type);
|
|
const uint8_t* const id = static_cast<uint8_t*>(field->value);
|
|
memcpy(buf, id, field_len);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
return ODK_ERROR_CORE_MESSAGE;
|
|
}
|
|
return OEMCrypto_SUCCESS;
|
|
}
|
|
|
|
OEMCryptoResult ODK_ReadSingleField(const uint8_t* const buf,
|
|
const ODK_Field* const field) {
|
|
if (!field || !field->value) {
|
|
return ODK_ERROR_CORE_MESSAGE;
|
|
}
|
|
switch (field->type) {
|
|
case ODK_UINT32: {
|
|
memcpy(field->value, buf, sizeof(uint32_t));
|
|
uint32_t* u32p = static_cast<uint32_t*>(field->value);
|
|
*u32p = be32toh(*u32p);
|
|
break;
|
|
}
|
|
case ODK_UINT64: {
|
|
memcpy(field->value, buf, sizeof(uint64_t));
|
|
uint64_t* u64p = static_cast<uint64_t*>(field->value);
|
|
*u64p = be64toh(*u64p);
|
|
break;
|
|
}
|
|
case ODK_SUBSTRING: {
|
|
OEMCrypto_Substring* s = static_cast<OEMCrypto_Substring*>(field->value);
|
|
uint32_t off = 0;
|
|
uint32_t len = 0;
|
|
memcpy(&off, buf, sizeof(off));
|
|
memcpy(&len, buf + sizeof(off), sizeof(len));
|
|
s->offset = be32toh(off);
|
|
s->length = be32toh(len);
|
|
break;
|
|
}
|
|
case ODK_DEVICEID:
|
|
case ODK_HASH: {
|
|
const size_t field_len = ODK_FieldLength(field->type);
|
|
uint8_t* const id = static_cast<uint8_t*>(field->value);
|
|
memcpy(id, buf, field_len);
|
|
break;
|
|
}
|
|
default:
|
|
return ODK_ERROR_CORE_MESSAGE;
|
|
}
|
|
return OEMCrypto_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Parameters:
|
|
* [in] size_in: buffer size
|
|
* [out] size_out: bytes processed
|
|
*/
|
|
OEMCryptoResult ODK_IterFields(ODK_FieldMode mode, uint8_t* const buf,
|
|
const size_t size_in, size_t* size_out,
|
|
std::vector<ODK_Field>& fields) {
|
|
if (!buf || !size_out) {
|
|
return ODK_ERROR_CORE_MESSAGE;
|
|
}
|
|
size_t off = 0, off2 = 0;
|
|
for (size_t i = 0; i < fields.size(); i++) {
|
|
if (__builtin_add_overflow(off, ODK_FieldLength(fields[i].type), &off2) ||
|
|
off2 > size_in) {
|
|
return ODK_ERROR_CORE_MESSAGE;
|
|
}
|
|
uintptr_t base = reinterpret_cast<uintptr_t>(buf);
|
|
if (__builtin_add_overflow(base, off, &base)) {
|
|
return ODK_ERROR_CORE_MESSAGE;
|
|
}
|
|
uint8_t* const buf_off = buf + off;
|
|
if (mode == ODK_WRITE) {
|
|
ODK_WriteSingleField(buf_off, &fields[i]);
|
|
} else if (mode == ODK_READ) {
|
|
ODK_ReadSingleField(buf_off, &fields[i]);
|
|
} else {
|
|
return ODK_ERROR_CORE_MESSAGE;
|
|
}
|
|
off = off2;
|
|
}
|
|
*size_out = off;
|
|
if (*size_out > size_in) {
|
|
return ODK_ERROR_CORE_MESSAGE;
|
|
}
|
|
return OEMCrypto_SUCCESS;
|
|
}
|
|
|
|
OEMCryptoResult ODK_ReadFields(const uint8_t* const buf, const size_t size_in,
|
|
size_t* size_out,
|
|
std::vector<ODK_Field>& fields) {
|
|
return ODK_IterFields(ODK_READ, const_cast<uint8_t*>(buf), size_in, size_out,
|
|
fields);
|
|
}
|
|
|
|
OEMCryptoResult ODK_WriteFields(uint8_t* const buf, const size_t size_in,
|
|
size_t* size_out,
|
|
std::vector<ODK_Field>& fields) {
|
|
return ODK_IterFields(ODK_WRITE, buf, size_in, size_out, fields);
|
|
}
|
|
|
|
void expect_eq_buf(const void* s1, const void* s2, size_t n) {
|
|
if (memcmp(s1, s2, n)) {
|
|
const void* buffers[] = {s1, s2};
|
|
for (int i = 0; i < 2; i++) {
|
|
char _tmp[] = "/tmp/fileXXXXXX";
|
|
mkstemp(_tmp);
|
|
std::string tmp(_tmp);
|
|
std::fstream out(tmp, std::ios::out | std::ios::binary);
|
|
out.write((char*)buffers[i], n);
|
|
out.close();
|
|
std:
|
|
std::cerr << "buffer " << i << " dumped to " << tmp << std::endl;
|
|
}
|
|
FAIL();
|
|
}
|
|
}
|
|
|
|
template <typename T, typename F, typename G>
|
|
void ValidateRequest(uint32_t message_type,
|
|
std::vector<ODK_Field>& extra_fields,
|
|
const F& odk_prepare_func, const G& kdo_parse_func) {
|
|
uint32_t message_size = 0;
|
|
uint32_t api_version = 16;
|
|
uint32_t nonce = 0xdeadbeef;
|
|
uint32_t session_id = 0xcafebabe;
|
|
ODK_NonceValues nonce_values{api_version, nonce, session_id};
|
|
std::vector<ODK_Field> total_fields = {
|
|
{ODK_UINT32, &message_type}, {ODK_UINT32, &message_size},
|
|
{ODK_UINT32, &api_version}, {ODK_UINT32, &nonce},
|
|
{ODK_UINT32, &session_id},
|
|
};
|
|
|
|
total_fields.insert(total_fields.end(), extra_fields.begin(),
|
|
extra_fields.end());
|
|
for (auto& field : total_fields) {
|
|
message_size += ODK_FieldLength(field.type);
|
|
}
|
|
|
|
uint8_t* buf = new uint8_t[message_size]();
|
|
uint8_t* buf2 = new uint8_t[message_size]();
|
|
size_t bytes_written = message_size;
|
|
|
|
EXPECT_EQ(OEMCrypto_SUCCESS,
|
|
odk_prepare_func(buf, &bytes_written, &nonce_values));
|
|
EXPECT_EQ(bytes_written, message_size);
|
|
|
|
EXPECT_EQ(OEMCrypto_SUCCESS, ODK_IterFields(ODK_WRITE, buf2, SIZE_MAX,
|
|
&bytes_written, total_fields));
|
|
EXPECT_EQ(bytes_written, message_size);
|
|
|
|
expect_eq_buf(buf, buf2, message_size);
|
|
|
|
// odk kdo roundtrip
|
|
T t = {};
|
|
std::string oemcrypto_core_message(reinterpret_cast<char*>(buf),
|
|
message_size);
|
|
EXPECT_TRUE(kdo_parse_func(oemcrypto_core_message, &t));
|
|
nonce_values.api_version = t.api_version;
|
|
nonce_values.nonce = t.nonce;
|
|
nonce_values.session_id = t.session_id;
|
|
EXPECT_EQ(OEMCrypto_SUCCESS,
|
|
odk_prepare_func(buf2, &bytes_written, &nonce_values));
|
|
EXPECT_EQ(bytes_written, message_size);
|
|
expect_eq_buf(buf, buf2, message_size);
|
|
|
|
delete[] buf;
|
|
delete[] buf2;
|
|
}
|
|
|
|
/**
|
|
* Template arguments:
|
|
* T: kdo input struct
|
|
* F: odk deserializer
|
|
* G: kdo serializer
|
|
*/
|
|
template <typename T, typename F, typename G>
|
|
void ValidateResponse(uint32_t message_type,
|
|
std::vector<ODK_Field>& extra_fields,
|
|
const F& odk_parse_func, const G& kdo_prepare_func) {
|
|
uint32_t message_size = 0;
|
|
uint32_t api_version = 16;
|
|
uint32_t nonce = 0xdeadbeef;
|
|
uint32_t session_id = 0xcafebabe;
|
|
std::vector<ODK_Field> total_fields = {
|
|
{ODK_UINT32, &message_type}, {ODK_UINT32, &message_size},
|
|
{ODK_UINT32, &api_version}, {ODK_UINT32, &nonce},
|
|
{ODK_UINT32, &session_id},
|
|
};
|
|
|
|
uint32_t header_size = 0;
|
|
for (auto& field : total_fields) {
|
|
header_size += ODK_FieldLength(field.type);
|
|
}
|
|
|
|
total_fields.insert(total_fields.end(), extra_fields.begin(),
|
|
extra_fields.end());
|
|
for (auto& field : total_fields) {
|
|
message_size += ODK_FieldLength(field.type);
|
|
}
|
|
|
|
uint8_t* buf = new uint8_t[message_size]();
|
|
uint8_t* zero = new uint8_t[message_size]();
|
|
size_t bytes_read = 0, bytes_written = 0;
|
|
|
|
T t = {};
|
|
t.api_version = api_version;
|
|
t.nonce = nonce;
|
|
t.session_id = session_id;
|
|
|
|
// serialize input to buf
|
|
EXPECT_EQ(OEMCrypto_SUCCESS, ODK_IterFields(ODK_WRITE, buf, SIZE_MAX,
|
|
&bytes_written, total_fields));
|
|
EXPECT_EQ(bytes_written, message_size);
|
|
|
|
// zero-out input
|
|
EXPECT_EQ(OEMCrypto_SUCCESS, ODK_IterFields(ODK_READ, zero, bytes_written,
|
|
&bytes_read, extra_fields));
|
|
EXPECT_TRUE(bytes_written > bytes_read &&
|
|
bytes_written - bytes_read == header_size);
|
|
|
|
// parse buf with odk
|
|
ODK_NonceValues nonce_values{api_version, nonce, session_id};
|
|
EXPECT_EQ(OEMCrypto_SUCCESS,
|
|
odk_parse_func(buf, bytes_written, &nonce_values));
|
|
|
|
// serialize odk output to oemcrypto_core_message
|
|
std::string oemcrypto_core_message;
|
|
EXPECT_TRUE(kdo_prepare_func(t, &oemcrypto_core_message));
|
|
EXPECT_EQ(bytes_written, message_size);
|
|
|
|
expect_eq_buf(buf, oemcrypto_core_message.data(), message_size);
|
|
delete[] buf;
|
|
delete[] zero;
|
|
}
|
|
|
|
TEST(OdkTest, SerializeFields) {
|
|
uint32_t x[] = {0, 1, 2};
|
|
uint64_t y[] = {3ll << 32, 4ll << 32, 5ll << 32};
|
|
OEMCrypto_Substring s = {.offset = 6, .length = 7};
|
|
std::vector<ODK_Field> fields = {
|
|
{ODK_UINT32, &x[0]}, {ODK_UINT32, &x[1]}, {ODK_UINT32, &x[2]},
|
|
{ODK_UINT64, &y[0]}, {ODK_UINT64, &y[1]}, {ODK_UINT64, &y[2]},
|
|
{ODK_SUBSTRING, &s},
|
|
};
|
|
uint8_t buf[1024] = {0};
|
|
uint8_t buf2[1024] = {0};
|
|
size_t bytes_read = 0, bytes_written = 0;
|
|
ODK_IterFields(ODK_WRITE, buf, SIZE_MAX, &bytes_read, fields);
|
|
ODK_IterFields(ODK_READ, buf, bytes_read, &bytes_written, fields);
|
|
ODK_IterFields(ODK_WRITE, buf2, SIZE_MAX, &bytes_read, fields);
|
|
|
|
expect_eq_buf(buf, buf2, bytes_read);
|
|
}
|
|
|
|
TEST(OdkTest, SerializeFieldsStress) {
|
|
const int n = 1024;
|
|
std::vector<ODK_Field> fields(n);
|
|
std::srand(0);
|
|
size_t total_size = 0;
|
|
for (int i = 0; i < n; i++) {
|
|
fields[i].type = static_cast<ODK_FieldType>(std::rand() %
|
|
static_cast<int>(ODK_NUMTYPES));
|
|
size_t field_size = ODK_AllocSize(fields[i].type);
|
|
fields[i].value = malloc(ODK_AllocSize(fields[i].type));
|
|
total_size += ODK_FieldLength(fields[i].type);
|
|
}
|
|
|
|
uint8_t* buf = new uint8_t[total_size];
|
|
for (int i = 0; i < total_size; i++) {
|
|
buf[i] = std::rand() & 0xff;
|
|
}
|
|
|
|
size_t bytes_read = 0, bytes_written = 0;
|
|
uint8_t* buf2 = new uint8_t[total_size];
|
|
ODK_IterFields(ODK_READ, buf, total_size, &bytes_read, fields);
|
|
EXPECT_EQ(bytes_read, total_size);
|
|
ODK_IterFields(ODK_WRITE, buf2, total_size, &bytes_written, fields);
|
|
EXPECT_EQ(bytes_written, total_size);
|
|
|
|
expect_eq_buf(buf, buf2, total_size);
|
|
|
|
// cleanup
|
|
for (int i = 0; i < n; i++) {
|
|
free(fields[i].value);
|
|
}
|
|
delete[] buf;
|
|
delete[] buf2;
|
|
}
|
|
|
|
TEST(OdkTest, LicenseRequest) {
|
|
std::vector<ODK_Field> empty;
|
|
auto odk_prepare_func = [&](uint8_t* const buf, size_t* size,
|
|
ODK_NonceValues* nonce_values) {
|
|
return ODK_PrepareCoreLicenseRequest(buf, SIZE_MAX, size, nonce_values);
|
|
};
|
|
auto kdo_parse_func = ParseLicenseRequest;
|
|
ValidateRequest<ODK_LicenseRequest>(ODK_License_Request_Type, empty,
|
|
odk_prepare_func, kdo_parse_func);
|
|
}
|
|
|
|
TEST(OdkTest, RenewalRequest) {
|
|
uint64_t system_time_seconds = 0xBADDCAFE000FF1CE;
|
|
std::vector<ODK_Field> extra_fields = {
|
|
{ODK_UINT64, &system_time_seconds},
|
|
};
|
|
ODK_ClockValues clock_values = {0};
|
|
auto odk_prepare_func = [&](uint8_t* const buf, size_t* size,
|
|
const ODK_NonceValues* nonce_values) {
|
|
return ODK_PrepareCoreRenewalRequest(buf, SIZE_MAX, size, nonce_values,
|
|
&clock_values, system_time_seconds);
|
|
};
|
|
auto kdo_parse_func = [&](const std::string& oemcrypto_core_message,
|
|
ODK_RenewalRequest* core_renewal_request) {
|
|
bool ok = ParseRenewalRequest(oemcrypto_core_message, core_renewal_request);
|
|
if (ok) {
|
|
system_time_seconds = core_renewal_request->playback_time;
|
|
}
|
|
return ok;
|
|
};
|
|
ValidateRequest<ODK_RenewalRequest>(ODK_Renewal_Request_Type, extra_fields,
|
|
odk_prepare_func, kdo_parse_func);
|
|
}
|
|
|
|
TEST(OdkTest, ProvisionRequest) {
|
|
uint32_t device_id_length = DEVICE_ID_MAX / 2;
|
|
uint8_t device_id[DEVICE_ID_MAX] = {0};
|
|
memset(device_id, 0xff, device_id_length);
|
|
std::vector<ODK_Field> extra_fields = {
|
|
{ODK_UINT32, &device_id_length},
|
|
{ODK_DEVICEID, device_id},
|
|
};
|
|
auto odk_prepare_func = [&](uint8_t* const buf, size_t* size,
|
|
const ODK_NonceValues* nonce_values) {
|
|
return ODK_PrepareCoreProvisioningRequest(buf, SIZE_MAX, size, nonce_values,
|
|
device_id, device_id_length);
|
|
};
|
|
auto kdo_parse_func =
|
|
[&](const std::string& oemcrypto_core_message,
|
|
ODK_ProvisioningRequest* core_provisioning_request) {
|
|
bool ok = ParseProvisioningRequest(oemcrypto_core_message,
|
|
core_provisioning_request);
|
|
if (ok) {
|
|
const std::string& device_id_str =
|
|
core_provisioning_request->device_id;
|
|
device_id_length = device_id_str.size();
|
|
memcpy(device_id, device_id_str.data(), device_id_length);
|
|
}
|
|
return ok;
|
|
};
|
|
ValidateRequest<ODK_ProvisioningRequest>(ODK_Provisioning_Request_Type,
|
|
extra_fields, odk_prepare_func,
|
|
kdo_parse_func);
|
|
}
|
|
|
|
TEST(OdkTest, LicenseResponse) {
|
|
ODK_ParsedLicense parsed_license = {
|
|
.enc_mac_keys_iv = {.offset = 0, .length = 1},
|
|
.enc_mac_keys = {.offset = 2, .length = 3},
|
|
.pst = {.offset = 4, .length = 5},
|
|
.srm_restriction_data = {.offset = 6, .length = 7},
|
|
.license_type = 8,
|
|
.nonce_required = 0xDEADC0DE,
|
|
.timer_limits =
|
|
{
|
|
.soft_expiry = 9,
|
|
.earliest_playback_start_seconds = 10,
|
|
.latest_playback_start_seconds = 11,
|
|
.initial_playback_duration_seconds = 12,
|
|
.renewal_playback_duration_seconds = 13,
|
|
.license_duration_seconds = 14,
|
|
},
|
|
.request_hash = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
|
|
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
|
|
22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
|
|
.key_array_length = 3,
|
|
.key_array =
|
|
{
|
|
{
|
|
.key_id = {.offset = 15, .length = 16},
|
|
.key_data_iv = {.offset = 17, .length = 18},
|
|
.key_data = {.offset = 19, .length = 20},
|
|
.key_control_iv = {.offset = 21, .length = 22},
|
|
.key_control = {.offset = 23, .length = 24},
|
|
},
|
|
{
|
|
.key_id = {.offset = 25, .length = 26},
|
|
.key_data_iv = {.offset = 27, .length = 28},
|
|
.key_data = {.offset = 29, .length = 30},
|
|
.key_control_iv = {.offset = 31, .length = 32},
|
|
.key_control = {.offset = 33, .length = 34},
|
|
},
|
|
{
|
|
.key_id = {.offset = 35, .length = 36},
|
|
.key_data_iv = {.offset = 37, .length = 38},
|
|
.key_data = {.offset = 39, .length = 40},
|
|
.key_control_iv = {.offset = 41, .length = 42},
|
|
.key_control = {.offset = 43, .length = 44},
|
|
},
|
|
},
|
|
};
|
|
|
|
uint32_t message_type = ODK_License_Response_Type;
|
|
std::vector<ODK_Field> extra_fields = {
|
|
{ODK_SUBSTRING, &parsed_license.enc_mac_keys_iv},
|
|
{ODK_SUBSTRING, &parsed_license.enc_mac_keys},
|
|
{ODK_SUBSTRING, &parsed_license.pst},
|
|
{ODK_SUBSTRING, &parsed_license.srm_restriction_data},
|
|
{ODK_UINT32, &parsed_license.license_type},
|
|
{ODK_UINT32, &parsed_license.nonce_required},
|
|
{ODK_UINT32, &parsed_license.timer_limits.soft_expiry},
|
|
{ODK_UINT64,
|
|
&parsed_license.timer_limits.earliest_playback_start_seconds},
|
|
{ODK_UINT64, &parsed_license.timer_limits.latest_playback_start_seconds},
|
|
{ODK_UINT64,
|
|
&parsed_license.timer_limits.initial_playback_duration_seconds},
|
|
{ODK_UINT64,
|
|
&parsed_license.timer_limits.renewal_playback_duration_seconds},
|
|
{ODK_UINT64, &parsed_license.timer_limits.license_duration_seconds},
|
|
{ODK_HASH, &parsed_license.request_hash},
|
|
{ODK_UINT32, &parsed_license.key_array_length},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[0].key_id},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[0].key_data_iv},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[0].key_data},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[0].key_control_iv},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[0].key_control},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[1].key_id},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[1].key_data_iv},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[1].key_data},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[1].key_control_iv},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[1].key_control},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[2].key_id},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[2].key_data_iv},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[2].key_data},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[2].key_control_iv},
|
|
{ODK_SUBSTRING, &parsed_license.key_array[2].key_control},
|
|
};
|
|
|
|
uint8_t request_hash[ODK_SHA256_HASH_SIZE] = {};
|
|
memcpy(request_hash, parsed_license.request_hash, ODK_SHA256_HASH_SIZE);
|
|
auto odk_parse_func = [&](const uint8_t* buf, size_t size,
|
|
ODK_NonceValues* nonce_values) {
|
|
return ODK_ParseLicense(buf, size + 128, size, 1, 0, request_hash, nullptr,
|
|
nullptr, nonce_values, &parsed_license);
|
|
};
|
|
auto kdo_prepare_func = [&](const ODK_LicenseRequest& core_request,
|
|
std::string* oemcrypto_core_message) {
|
|
return CreateCoreLicenseResponse(parsed_license, core_request,
|
|
oemcrypto_core_message);
|
|
};
|
|
ValidateResponse<ODK_LicenseRequest>(ODK_License_Response_Type, extra_fields,
|
|
odk_parse_func, kdo_prepare_func);
|
|
}
|
|
|
|
TEST(OdkTest, RenewalResponse) {
|
|
uint64_t system_time = 0xfaceb00c;
|
|
uint64_t playback_clock = 11;
|
|
uint64_t playback_timer = 12;
|
|
uint64_t message_playback_clock = 10;
|
|
std::vector<ODK_Field> extra_fields = {
|
|
{ODK_UINT64, &message_playback_clock},
|
|
};
|
|
|
|
ODK_TimerLimits timer_limits = {
|
|
.soft_expiry = 0,
|
|
.earliest_playback_start_seconds = 0,
|
|
.latest_playback_start_seconds = 100,
|
|
.initial_playback_duration_seconds = 10,
|
|
.renewal_playback_duration_seconds = 20,
|
|
.license_duration_seconds = 100,
|
|
};
|
|
|
|
ODK_ClockValues clock_values = {
|
|
.time_of_license_signed = 0,
|
|
.time_of_first_decrypt = system_time - playback_clock,
|
|
.time_of_last_decrypt = 0,
|
|
.time_when_timer_expires = system_time + playback_timer,
|
|
.timer_status = 0,
|
|
.status = kUnused,
|
|
};
|
|
|
|
auto odk_parse_func = [&](const uint8_t* buf, size_t size,
|
|
ODK_NonceValues* nonce_values) {
|
|
OEMCryptoResult err =
|
|
ODK_ParseRenewal(buf, size, size, nonce_values, system_time,
|
|
&timer_limits, &clock_values, &playback_timer);
|
|
|
|
EXPECT_EQ(ODK_SET_TIMER, err);
|
|
EXPECT_EQ(timer_limits.renewal_playback_duration_seconds, playback_timer);
|
|
EXPECT_EQ(clock_values.time_when_timer_expires,
|
|
system_time + playback_timer);
|
|
|
|
// manually restore message_playback_clock since ODK_ParseRenewal doesn't
|
|
// generate output
|
|
message_playback_clock = 10;
|
|
return OEMCrypto_SUCCESS;
|
|
};
|
|
auto kdo_prepare_func = [&](ODK_RenewalRequest& core_request,
|
|
std::string* oemcrypto_core_message) {
|
|
core_request.playback_time = message_playback_clock;
|
|
return CreateCoreRenewalResponse(core_request, oemcrypto_core_message);
|
|
};
|
|
ValidateResponse<ODK_RenewalRequest>(ODK_Renewal_Response_Type, extra_fields,
|
|
odk_parse_func, kdo_prepare_func);
|
|
}
|
|
|
|
TEST(OdkTest, ProvisionResponse) {
|
|
uint32_t device_id_length = DEVICE_ID_MAX / 2;
|
|
uint8_t device_id[DEVICE_ID_MAX] = {0};
|
|
memset(device_id, 0xff, device_id_length);
|
|
|
|
ODK_ParsedProvisioning parsed_response = {
|
|
.enc_private_key = {.offset = 0, .length = 1},
|
|
.enc_private_key_iv = {.offset = 2, .length = 3},
|
|
.encrypted_message_key = {.offset = 4, .length = 5},
|
|
};
|
|
|
|
std::vector<ODK_Field> extra_fields = {
|
|
{ODK_UINT32, &device_id_length},
|
|
{ODK_DEVICEID, device_id},
|
|
{ODK_UINT32, &parsed_response.key_type},
|
|
{ODK_SUBSTRING, &parsed_response.enc_private_key},
|
|
{ODK_SUBSTRING, &parsed_response.enc_private_key_iv},
|
|
{ODK_SUBSTRING, &parsed_response.encrypted_message_key},
|
|
};
|
|
|
|
auto odk_parse_func = [&](const uint8_t* buf, size_t size,
|
|
ODK_NonceValues* nonce_values) {
|
|
// restore device id because it is not part of parsed_response
|
|
device_id_length = DEVICE_ID_MAX / 2;
|
|
memset(device_id, 0xff, device_id_length);
|
|
OEMCryptoResult err =
|
|
ODK_ParseProvisioning(buf, size + 16, size, nonce_values, device_id,
|
|
device_id_length, &parsed_response);
|
|
return err;
|
|
};
|
|
auto kdo_prepare_func = [&](ODK_ProvisioningRequest& core_request,
|
|
std::string* oemcrypto_core_message) {
|
|
core_request.device_id.assign(reinterpret_cast<char*>(device_id),
|
|
device_id_length);
|
|
return CreateCoreProvisioningResponse(parsed_response, core_request,
|
|
oemcrypto_core_message);
|
|
};
|
|
ValidateResponse<ODK_ProvisioningRequest>(ODK_Provisioning_Response_Type,
|
|
extra_fields, odk_parse_func,
|
|
kdo_prepare_func);
|
|
}
|
|
|
|
TEST(OdkSizeTest, LicenseRequest) {
|
|
uint8_t* message = nullptr;
|
|
size_t message_length = 0;
|
|
size_t core_message_length = 0;
|
|
uint32_t api_version = 0;
|
|
uint32_t nonce = 0;
|
|
uint32_t session_id = 0;
|
|
ODK_NonceValues nonce_values{api_version, nonce, session_id};
|
|
EXPECT_EQ(OEMCrypto_ERROR_SHORT_BUFFER,
|
|
ODK_PrepareCoreLicenseRequest(message, message_length,
|
|
&core_message_length, &nonce_values));
|
|
// All messages have at least a five 4-byte fields.
|
|
size_t minimum_message_size = 5 * 4;
|
|
EXPECT_GE(core_message_length, minimum_message_size);
|
|
}
|
|
|
|
TEST(OdkSizeTest, RenewalRequest) {
|
|
uint8_t* message = nullptr;
|
|
size_t message_length = 0;
|
|
size_t core_message_length = 0;
|
|
uint32_t api_version = 0;
|
|
uint32_t nonce = 0;
|
|
uint32_t session_id = 0;
|
|
ODK_ClockValues clock_values = {};
|
|
clock_values.time_of_first_decrypt = 10;
|
|
uint64_t system_time_seconds = 15;
|
|
ODK_NonceValues nonce_values{api_version, nonce, session_id};
|
|
EXPECT_EQ(OEMCrypto_ERROR_SHORT_BUFFER,
|
|
ODK_PrepareCoreRenewalRequest(message, message_length,
|
|
&core_message_length, &nonce_values,
|
|
&clock_values, system_time_seconds));
|
|
// All messages have at least a five 4-byte fields.
|
|
size_t minimum_message_size = 5 * 4;
|
|
EXPECT_GE(core_message_length, minimum_message_size);
|
|
}
|
|
|
|
TEST(OdkSizeTest, ProvisioningRequest) {
|
|
uint8_t* message = nullptr;
|
|
size_t message_length = 0;
|
|
size_t core_message_length = 0;
|
|
uint32_t api_version = 0;
|
|
uint32_t nonce = 0;
|
|
uint32_t session_id = 0;
|
|
uint8_t* device_id = nullptr;
|
|
uint32_t device_id_length = 0;
|
|
ODK_NonceValues nonce_values{api_version, nonce, session_id};
|
|
EXPECT_EQ(OEMCrypto_ERROR_SHORT_BUFFER,
|
|
ODK_PrepareCoreProvisioningRequest(
|
|
message, message_length, &core_message_length, &nonce_values,
|
|
nullptr, device_id_length));
|
|
// All messages have at least a five 4-byte fields.
|
|
size_t minimum_message_size = 5 * 4;
|
|
EXPECT_GE(core_message_length, minimum_message_size);
|
|
}
|