bool CRefWLGen::get_hash_from_string(char* hash_str, sgx_measurement_t* p_hash)
{
if (hash_str == NULL || p_hash == NULL)
{
return false;
}
char* ptr = clean_start(hash_str);
for (size_t count = 0; count < sizeof(sgx_measurement_t); ++count)
{
ptr = clean_start(ptr);
if (*ptr == 0)
{
return false;
}
p_hash->m[count] = (char)strtol(ptr, &ptr, 16);
}
return true;
}
void simulator::initialize(unsigned long initInfectious)
{
/// Initialize before running the simulation
clean_start();
// Set initial infectious individuals
for(int i=0; i<initInfectious; i++)
{
// Warning: initial infectious individuals
// are put in I[1] (_not_ exposed/latent stage)
_indiv[i].set_infectiousStatus(_nE+1);
_indiv[i].set_timeDiseaseAcquisition(0.0);
_id_indiv_I.push_back(i);
}
// intialize counts
_count_I = initInfectious;
_count_S = _popSize - initInfectious;
_count_R = 0;
// initialize vector keeping track of susceptible IDs
for (unsigned long i=initInfectious; i<_indiv.size(); i++) {
_id_indiv_S.push_back(i);
}
// Initialization
double t=0.0;
_time.push_back(t);
_cumIncidence.push_back(initInfectious);
_prevalence.push_back(initInfectious);
_nS.push_back(_popSize - initInfectious);
_nR.push_back(0);
}
bool CRefWLGen::generate_wl()
{
print_line(true, "Building white list...\n");
ref_le_white_list_t* wl = (ref_le_white_list_t*)malloc(REF_LE_WL_SIZE(MAX_NUM_OF_RECORDS));
memset(wl, 0, REF_LE_WL_SIZE(MAX_NUM_OF_RECORDS));
// Init values of white-list
print_line(true, "While list format version: %d\n", WL_FILE_VERSION);
wl->version = WL_FILE_VERSION;
print_line(true, "While list instance version: %d\n", m_version);
wl->wl_version = m_version;
// Read configuration information
print_line(true, "Reading configuration file: %s\n", m_cfgfile);
FILE *cfgfile = fopen(m_cfgfile, "r");
if (!cfgfile)
{
print_line(true, "Failed to open the configuration file '%s'.\n", m_cfgfile);
free(wl);
return false;
}
char line[LINE_LEN];
// TODO: what if line len is not enough?
while (fgets(line, LINE_LEN, cfgfile) != NULL)
{
char* start = clean_start(line);
if (*start == 0)
{
continue;
}
print_line(false, "Entry #%d:\n", wl->entries_count);
if (process_line(line, &(wl->wl_entries[wl->entries_count])) == false)
{
print_line(true, "Failed to process the configuration line.\n");
fclose(cfgfile);
free(wl);
return false;
}
wl->entries_count++;
}
fclose(cfgfile);
print_line(false, "Parsed entries count: %d\n", wl->entries_count);
uint16_t wl_count = wl->entries_count;
reverse_byte_array((uint8_t*)&(wl->version), sizeof(wl->version));
reverse_byte_array((uint8_t*)&(wl->wl_version), sizeof(wl->wl_version));
reverse_byte_array((uint8_t*)&(wl->entries_count), sizeof(wl->entries_count));
print_line(true, "Signing using key file: %s\n", m_keyfile);
sgx_rsa3072_signature_t sig;
if (!set_key_and_sign(m_keyfile, wl, wl_count, &sig))
{
free(wl);
return false;
}
reverse_byte_array((uint8_t*)&sig, sizeof(sgx_rsa3072_signature_t));
print_line(false, "Complete white list (big endian): ");
print_byte_array(false, (uint8_t*)wl, REF_LE_WL_SIZE(wl_count), " ");
print_line(false, "Signature (big endian): ");
print_byte_array(false, (uint8_t*)&sig, sizeof(sgx_rsa3072_signature_t), " ");
print_line(true, "Writing output file: %s\n", m_outfile);
FILE *pOut = fopen(m_outfile, "wb");
size_t written = fwrite(wl, 1, REF_LE_WL_SIZE(wl_count), pOut);
written += fwrite(&sig, 1, sizeof(sgx_rsa3072_signature_t), pOut);
fclose(pOut);
free(wl);
if (written != REF_LE_WL_SIZE(wl_count) + sizeof(sgx_rsa3072_signature_t))
{
return false;
}
print_line(true, "White list generation completed successfully. \n");
return true;
}
bool CRefWLGen::process_line(char *line, ref_le_white_list_entry_t *entry)
{
char *item = strtok(line, ",");
// parse item: allow provision key
item = clean_start(item);
if (strncmp(item, "true", 4) == 0)
{
entry->provision_key = 1;
}
else
{
entry->provision_key = 0;
}
print_line(false, " provision_key: %d\n", entry->provision_key);
// parse item: mr_enclave valid
item = strtok(NULL, ",");
item = clean_start(item);
if (strncmp(item, "true", 4) == 0)
{
entry->match_mr_enclave = 1;
}
else
{
entry->match_mr_enclave = 0;
}
print_line(false, " match_mr_enclave: %d\n", entry->match_mr_enclave);
// parse item: mr_signer hash/file
item = strtok(NULL, ",");
item = clean_start(item);
if (*item != 0)
{ // hash
if (get_hash_from_string(item, &(entry->mr_signer)) == false)
{
return false;
}
item = strtok(NULL, ","); // skip the next item
}
else
{ // file
item = strtok(NULL, ",");
item = clean_start(item);
if (get_hash_from_pubkey_file(item, &(entry->mr_signer)) == false)
{
return false;
}
}
print_line(false, " mr_signer: ");
print_byte_array(false, (uint8_t*)&(entry->mr_signer), sizeof(sgx_measurement_t), " ");
reverse_byte_array((uint8_t*)&(entry->mr_signer), sizeof(entry->mr_signer));
// parse item: mr_enclave hash/file
if (entry->match_mr_enclave == 1)
{
item = strtok(NULL, ",");
item = clean_start(item);
if (*item != 0)
{ // hash
if (get_hash_from_string(item, &(entry->mr_enclave)) == false)
{
return false;
}
item = strtok(NULL, ","); // skip the next item
}
else
{ // file
item = strtok(NULL, ",");
item = clean_start(item);
if (get_hash_from_sigstruct_file(item, &(entry->mr_enclave)) == false)
{
return false;
}
}
print_line(false, " mr_enclave: ");
print_byte_array(false, (uint8_t*)&(entry->mr_enclave), sizeof(sgx_measurement_t), " ");
reverse_byte_array((uint8_t*)&(entry->mr_enclave), sizeof(entry->mr_enclave));
}
print_line(false, " Full entry (big endian): ");
print_byte_array(false, (uint8_t*)entry, sizeof(ref_le_white_list_entry_t), " ");
return true;
}