193 lines
8.3 KiB
C
193 lines
8.3 KiB
C
// Copyright 2020 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
// use this file except in compliance with the License. You may obtain a copy of
|
|
// the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
// License for the specific language governing permissions and limitations under
|
|
// the License.
|
|
|
|
#include "dice/dice.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "dice/ops.h"
|
|
|
|
#define DICE_CODE_SIZE DICE_HASH_SIZE
|
|
#define DICE_CONFIG_SIZE DICE_INLINE_CONFIG_SIZE
|
|
#define DICE_AUTHORITY_SIZE DICE_HASH_SIZE
|
|
#define DICE_MODE_SIZE 1
|
|
|
|
static const uint8_t kAsymSalt[] = {
|
|
0x63, 0xB6, 0xA0, 0x4D, 0x2C, 0x07, 0x7F, 0xC1, 0x0F, 0x63, 0x9F,
|
|
0x21, 0xDA, 0x79, 0x38, 0x44, 0x35, 0x6C, 0xC2, 0xB0, 0xB4, 0x41,
|
|
0xB3, 0xA7, 0x71, 0x24, 0x03, 0x5C, 0x03, 0xF8, 0xE1, 0xBE, 0x60,
|
|
0x35, 0xD3, 0x1F, 0x28, 0x28, 0x21, 0xA7, 0x45, 0x0A, 0x02, 0x22,
|
|
0x2A, 0xB1, 0xB3, 0xCF, 0xF1, 0x67, 0x9B, 0x05, 0xAB, 0x1C, 0xA5,
|
|
0xD1, 0xAF, 0xFB, 0x78, 0x9C, 0xCD, 0x2B, 0x0B, 0x3B};
|
|
static const size_t kAsymSaltSize = 64;
|
|
|
|
static const uint8_t kIdSalt[] = {
|
|
0xDB, 0xDB, 0xAE, 0xBC, 0x80, 0x20, 0xDA, 0x9F, 0xF0, 0xDD, 0x5A,
|
|
0x24, 0xC8, 0x3A, 0xA5, 0xA5, 0x42, 0x86, 0xDF, 0xC2, 0x63, 0x03,
|
|
0x1E, 0x32, 0x9B, 0x4D, 0xA1, 0x48, 0x43, 0x06, 0x59, 0xFE, 0x62,
|
|
0xCD, 0xB5, 0xB7, 0xE1, 0xE0, 0x0F, 0xC6, 0x80, 0x30, 0x67, 0x11,
|
|
0xEB, 0x44, 0x4A, 0xF7, 0x72, 0x09, 0x35, 0x94, 0x96, 0xFC, 0xFF,
|
|
0x1D, 0xB9, 0x52, 0x0B, 0xA5, 0x1C, 0x7B, 0x29, 0xEA};
|
|
static const size_t kIdSaltSize = 64;
|
|
|
|
DiceResult DiceDeriveCdiPrivateKeySeed(
|
|
void* context, const uint8_t cdi_attest[DICE_CDI_SIZE],
|
|
uint8_t cdi_private_key_seed[DICE_PRIVATE_KEY_SEED_SIZE]) {
|
|
// Use the CDI as input key material, with fixed salt and info.
|
|
return DiceKdf(context, /*length=*/DICE_PRIVATE_KEY_SEED_SIZE, cdi_attest,
|
|
/*ikm_size=*/DICE_CDI_SIZE, kAsymSalt, kAsymSaltSize,
|
|
/*info=*/(const uint8_t*)"Key Pair", /*info_size=*/8,
|
|
cdi_private_key_seed);
|
|
}
|
|
|
|
DiceResult DiceDeriveCdiCertificateId(void* context,
|
|
const uint8_t* cdi_public_key,
|
|
size_t cdi_public_key_size,
|
|
uint8_t id[DICE_ID_SIZE]) {
|
|
// Use the public key as input key material, with fixed salt and info.
|
|
DiceResult result =
|
|
DiceKdf(context, /*length=*/20, cdi_public_key, cdi_public_key_size,
|
|
kIdSalt, kIdSaltSize,
|
|
/*info=*/(const uint8_t*)"ID", /*info_size=*/2, id);
|
|
if (result == kDiceResultOk) {
|
|
// Clear the top bit to keep the integer positive.
|
|
id[0] &= ~0x80;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
DiceResult DiceMainFlow(void* context,
|
|
const uint8_t current_cdi_attest[DICE_CDI_SIZE],
|
|
const uint8_t current_cdi_seal[DICE_CDI_SIZE],
|
|
const DiceInputValues* input_values,
|
|
size_t next_cdi_certificate_buffer_size,
|
|
uint8_t* next_cdi_certificate,
|
|
size_t* next_cdi_certificate_actual_size,
|
|
uint8_t next_cdi_attest[DICE_CDI_SIZE],
|
|
uint8_t next_cdi_seal[DICE_CDI_SIZE]) {
|
|
// This implementation serializes the inputs for a one-shot hash. On some
|
|
// platforms, using a multi-part hash operation may be more optimal. The
|
|
// combined input buffer has this layout:
|
|
// ---------------------------------------------------------------------------
|
|
// | Code Input | Config Input | Authority Input | Mode Input | Hidden Input |
|
|
// ---------------------------------------------------------------------------
|
|
const size_t kCodeOffset = 0;
|
|
const size_t kConfigOffset = kCodeOffset + DICE_CODE_SIZE;
|
|
const size_t kAuthorityOffset = kConfigOffset + DICE_CONFIG_SIZE;
|
|
const size_t kModeOffset = kAuthorityOffset + DICE_AUTHORITY_SIZE;
|
|
const size_t kHiddenOffset = kModeOffset + DICE_MODE_SIZE;
|
|
|
|
DiceResult result = kDiceResultOk;
|
|
|
|
// Declare buffers that get cleaned up on 'goto out'.
|
|
uint8_t input_buffer[DICE_CODE_SIZE + DICE_CONFIG_SIZE + DICE_AUTHORITY_SIZE +
|
|
DICE_MODE_SIZE + DICE_HIDDEN_SIZE];
|
|
uint8_t attest_input_hash[DICE_HASH_SIZE];
|
|
uint8_t seal_input_hash[DICE_HASH_SIZE];
|
|
uint8_t current_cdi_private_key_seed[DICE_PRIVATE_KEY_SEED_SIZE];
|
|
uint8_t next_cdi_private_key_seed[DICE_PRIVATE_KEY_SEED_SIZE];
|
|
|
|
// Assemble the input buffer.
|
|
memcpy(&input_buffer[kCodeOffset], input_values->code_hash, DICE_CODE_SIZE);
|
|
if (input_values->config_type == kDiceConfigTypeInline) {
|
|
memcpy(&input_buffer[kConfigOffset], input_values->config_value,
|
|
DICE_CONFIG_SIZE);
|
|
} else if (!input_values->config_descriptor) {
|
|
result = kDiceResultInvalidInput;
|
|
goto out;
|
|
} else {
|
|
result = DiceHash(context, input_values->config_descriptor,
|
|
input_values->config_descriptor_size,
|
|
&input_buffer[kConfigOffset]);
|
|
if (result != kDiceResultOk) {
|
|
goto out;
|
|
}
|
|
}
|
|
memcpy(&input_buffer[kAuthorityOffset], input_values->authority_hash,
|
|
DICE_AUTHORITY_SIZE);
|
|
input_buffer[kModeOffset] = input_values->mode;
|
|
memcpy(&input_buffer[kHiddenOffset], input_values->hidden, DICE_HIDDEN_SIZE);
|
|
|
|
// Hash the appropriate input values for both attestation and sealing. For
|
|
// attestation all the inputs are used, and for sealing only the authority,
|
|
// mode, and hidden inputs are used.
|
|
result =
|
|
DiceHash(context, input_buffer, sizeof(input_buffer), attest_input_hash);
|
|
if (result != kDiceResultOk) {
|
|
goto out;
|
|
}
|
|
result = DiceHash(context, &input_buffer[kAuthorityOffset],
|
|
DICE_AUTHORITY_SIZE + DICE_MODE_SIZE + DICE_HIDDEN_SIZE,
|
|
seal_input_hash);
|
|
if (result != kDiceResultOk) {
|
|
goto out;
|
|
}
|
|
|
|
// Compute the next CDI values. For each of these the current CDI value is
|
|
// used as input key material and the input hash is used as salt.
|
|
result = DiceKdf(context, /*length=*/DICE_CDI_SIZE, current_cdi_attest,
|
|
/*ikm_size=*/DICE_CDI_SIZE, attest_input_hash,
|
|
/*salt_size=*/DICE_HASH_SIZE,
|
|
/*info=*/(const uint8_t*)"CDI_Attest", /*info_size=*/10,
|
|
next_cdi_attest);
|
|
if (result != kDiceResultOk) {
|
|
goto out;
|
|
}
|
|
result = DiceKdf(
|
|
context, /*length=*/DICE_CDI_SIZE, current_cdi_seal,
|
|
/*ikm_size=*/DICE_CDI_SIZE, seal_input_hash, /*salt_size=*/DICE_HASH_SIZE,
|
|
/*info=*/(const uint8_t*)"CDI_Seal", /*info_size=*/8, next_cdi_seal);
|
|
if (result != kDiceResultOk) {
|
|
goto out;
|
|
}
|
|
|
|
// Create the CDI certificate only if it is required (i.e. non-null/non-zero
|
|
// values are provided for the next CDI certificate parameters).
|
|
if (next_cdi_certificate == NULL &&
|
|
next_cdi_certificate_actual_size == NULL &&
|
|
next_cdi_certificate_buffer_size == 0) {
|
|
goto out;
|
|
}
|
|
|
|
// Derive asymmetric private key seeds from the attestation CDI values.
|
|
result = DiceDeriveCdiPrivateKeySeed(context, current_cdi_attest,
|
|
current_cdi_private_key_seed);
|
|
if (result != kDiceResultOk) {
|
|
goto out;
|
|
}
|
|
result = DiceDeriveCdiPrivateKeySeed(context, next_cdi_attest,
|
|
next_cdi_private_key_seed);
|
|
if (result != kDiceResultOk) {
|
|
goto out;
|
|
}
|
|
|
|
// Generate a certificate for |next_cdi_private_key_seed| with
|
|
// |current_cdi_private_key_seed| as the authority.
|
|
result = DiceGenerateCertificate(
|
|
context, next_cdi_private_key_seed, current_cdi_private_key_seed,
|
|
input_values, next_cdi_certificate_buffer_size, next_cdi_certificate,
|
|
next_cdi_certificate_actual_size);
|
|
|
|
out:
|
|
// Clear sensitive memory.
|
|
DiceClearMemory(context, sizeof(input_buffer), input_buffer);
|
|
DiceClearMemory(context, sizeof(attest_input_hash), attest_input_hash);
|
|
DiceClearMemory(context, sizeof(seal_input_hash), seal_input_hash);
|
|
DiceClearMemory(context, sizeof(current_cdi_private_key_seed),
|
|
current_cdi_private_key_seed);
|
|
DiceClearMemory(context, sizeof(next_cdi_private_key_seed),
|
|
next_cdi_private_key_seed);
|
|
return result;
|
|
}
|