void print_type(struct object_heap* oh, struct Object* o) {
struct Object* traits;
struct Object* traitsWindow;
struct OopArray* x;
if (object_is_smallint(o)) {
fprintf(stderr, "%" PRIdPTR " (0x%" PRIuPTR ")\n", object_to_smallint(o), object_to_smallint(o));
return;
}
if (object_type(o) == TYPE_BYTE_ARRAY) {
fprintf(stderr, "(");
print_byte_array(o);
fprintf(stderr, ") ");
/*return;*/
}
x = o->map->delegates;
if (!x || array_size(x) < 1) goto fail;
traitsWindow = x->elements[0];
{
if (traitsWindow == oh->cached.compiled_method_window) {
fprintf(stderr, "(method #");
print_byte_array((struct Object*)(((struct CompiledMethod*)o)->method->selector));
fprintf(stderr, ")");
}
}
x = traitsWindow->map->delegates;
if (!x || array_size(x) < 1) goto fail;
traits = x->elements[array_size(x)-1];
if (o == oh->cached.nil) {
fprintf(stderr, "nil\n");
} else if (o == oh->cached.true_object) {
fprintf(stderr, "true\n");
} else if (o == oh->cached.false_object) {
fprintf(stderr, "false\n");
} else {
print_printname(oh, o);
fprintf(stderr, "(");
print_printname(oh, traits);
fprintf(stderr, ")\n");
}
return;
fail:
fprintf(stderr, "<unknown type>\n");
}
Chunk* load_chunk(std::ifstream& stream, int x, int z)
{
ByteString bytes;
uint32_t metadataOffset = 4 * (x + z * 32);
stream.seekg(metadataOffset);
bytes = read_bytes_from_stream(stream, 4);
uint32_t offset = bytes.read<uint32_t>() >> 8;
if(offset == 0) {
return NULL;
}
stream.seekg(4096 * offset);
bytes = read_bytes_from_stream(stream, 5);
uint32_t bytecount = bytes.read<uint32_t>();
bytes = read_bytes_from_stream(stream, bytecount - 1);
// decompress
unsigned long uncompressedLength;
ByteString uncompressedData(CHUNK_INFLATE_MAX);
std::cout << uncompress(uncompressedData.bytes(), &uncompressedLength, bytes.bytes(), bytecount - 1) << std::endl;;
//std::cout << uncompressedLength << std::endl;
print_byte_array(uncompressedData.bytes(), uncompressedLength);
return read_chunk(ByteString(uncompressedData));
}
bool_t print_printname(struct object_heap* oh, struct Object* o) {
word_t i;
struct Map* map = o->map;
struct SlotTable* slotTable = map->slotTable;
word_t limit = slot_table_capacity(slotTable);
for (i=0; i < limit; i++) {
if (slotTable->slots[i].name == (struct Symbol*)oh->cached.nil) continue;
if (strncmp((char*)slotTable->slots[i].name->elements, "printName", 9) == 0) {
struct Object* obj = object_slot_value_at_offset(o, object_to_smallint(slotTable->slots[i].offset));
if (object_is_smallint(obj) || object_type(obj) != TYPE_BYTE_ARRAY) {
return FALSE;
} else {
print_byte_array(obj);
return TRUE;
}
}
}
return FALSE;
}
void typeArrayKlass::oop_print_on(oop obj, outputStream* st) {
arrayKlass::oop_print_on(obj, st);
typeArrayOop ta = typeArrayOop(obj);
int print_len = MIN2((intx) ta->length(), MaxElementPrintSize);
switch (element_type()) {
case T_BOOLEAN: print_boolean_array(ta, print_len, st); break;
case T_CHAR: print_char_array(ta, print_len, st); break;
case T_FLOAT: print_float_array(ta, print_len, st); break;
case T_DOUBLE: print_double_array(ta, print_len, st); break;
case T_BYTE: print_byte_array(ta, print_len, st); break;
case T_SHORT: print_short_array(ta, print_len, st); break;
case T_INT: print_int_array(ta, print_len, st); break;
case T_LONG: print_long_array(ta, print_len, st); break;
default: ShouldNotReachHere();
}
int remaining = ta->length() - print_len;
if (remaining > 0) {
tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
}
}
bool CRefWLGen::set_key_and_sign(const char* prikey_file, ref_le_white_list_t *p_wl, uint16_t wl_count, sgx_rsa3072_signature_t* p_signature)
{
rsa_params_t rsa_params;
int key_type;
if (!parse_key_file(prikey_file, &rsa_params, &key_type))
{
return false;
}
rsa_params.e[0] = 3;
sgx_rsa3072_key_t rsa_key;
memcpy(&(rsa_key.mod), &(rsa_params.n), sizeof(rsa_key.mod));
memcpy(&(rsa_key.d), &(rsa_params.d), sizeof(rsa_key.d));
memcpy(&(rsa_key.e), &(rsa_params.e), sizeof(rsa_key.e));
memcpy(&(p_wl->signer_pubkey.mod), &(rsa_params.n), sizeof(p_wl->signer_pubkey.mod));
memcpy(&(p_wl->signer_pubkey.exp), &(rsa_params.e), sizeof(p_wl->signer_pubkey.exp));
print_line(false, " Signer public key modolus: ");
print_byte_array(false, (uint8_t*)&(p_wl->signer_pubkey.mod), sizeof(p_wl->signer_pubkey.mod), " ");
print_line(false, " Signer public key exponent: %d\n", p_wl->signer_pubkey.exp);
reverse_byte_array((uint8_t*)&(p_wl->signer_pubkey.mod), sizeof(p_wl->signer_pubkey.mod));
reverse_byte_array((uint8_t*)&(p_wl->signer_pubkey.exp), sizeof(p_wl->signer_pubkey.exp));
int len = REF_LE_WL_SIZE(wl_count);
sgx_status_t res = sgx_rsa3072_sign((const uint8_t*) p_wl, len, &rsa_key, p_signature);
if (res != SGX_SUCCESS)
{
return false;
}
return true;
}
void print_object_with_depth(struct object_heap* oh, struct Object* o, word_t depth, word_t max_depth) {
struct Map* map;
word_t i;
if (depth >= max_depth || object_is_smallint(o)) {
fprintf(stderr, "(depth limit reached) "); print_object(o);
return;
}
if (o == oh->cached.nil) {
fprintf(stderr, "<object NilObject>\n");
return;
}
map = o->map;
print_object(o);
if (object_hash(o) >= ID_HASH_RESERVED) {
indent(depth); fprintf(stderr, "<object is free/reserved>\n");
return;
}
indent(depth); fprintf(stderr, "{\n");
if (object_type(o) == TYPE_BYTE_ARRAY) {
indent(depth); fprintf(stderr, "bytes: ");
print_byte_array(o); fprintf(stderr, "\n");
}
if (object_type(o) == TYPE_OOP_ARRAY) {
struct OopArray* array = (struct OopArray*)o;
indent(depth); fprintf(stderr, "size(array) = %" PRIdPTR "\n", object_array_size(o));
for (i=0; i < object_array_size(o); i++) {
indent(depth); fprintf(stderr, "array[%" PRIdPTR "]: ", i); print_object_with_depth(oh, array->elements[i], depth+1, max_depth);
if (object_array_size(o) - i > 10) {
indent(depth); fprintf(stderr, "...\n");
i = object_array_size(o) - 2;
}
}
}
indent(depth);
fprintf(stderr, "map flags: %" PRIdPTR " (%s)\n",
object_to_smallint(map->flags),
((((word_t)map->flags & MAP_FLAG_RESTRICT_DELEGATION)==0)? "delegation not restricted":"delegation restricted"));
{
/*print if delegate*/
struct OopArray* delegates = map->delegates;
word_t offset = object_array_offset((struct Object*)delegates);
word_t limit = object_total_size((struct Object*)delegates);
for (i = 0; offset != limit; offset += sizeof(word_t), i++) {
struct Object* delegate = object_slot_value_at_offset((struct Object*)delegates, offset);
indent(depth); fprintf(stderr, "delegate[%" PRIdPTR "] = ", i);
print_object_with_depth(oh, delegate,
(((word_t)map->flags & MAP_FLAG_RESTRICT_DELEGATION) == 0)? depth+1 : max(max_depth-1, depth+1), max_depth);
}
}
{/*if?*/
struct SlotTable* slotTable = map->slotTable;
word_t limit = slot_table_capacity(map->slotTable);
indent(depth); fprintf(stderr, "slot count: %" PRIdPTR "\n", object_to_smallint(map->slotCount));
for (i=0; i < limit; i++) {
if (slotTable->slots[i].name == (struct Symbol*)oh->cached.nil) continue;
indent(depth);
fprintf(stderr, "slot[%" PRIdPTR "]['", i); print_symbol(slotTable->slots[i].name); fprintf(stderr, "'] = ");
{
struct Object* obj = object_slot_value_at_offset(o, object_to_smallint(slotTable->slots[i].offset));
if (object_is_smallint(obj) || object_type(obj) != TYPE_BYTE_ARRAY) {
print_object(obj);
} else {
print_byte_array(obj); fprintf(stderr, "\n");
}
}
}
}
/*indent(depth); fprintf(stderr, "map = "); print_object_with_depth(oh, (struct Object*)map, depth+1, max_depth);*/
/*roles */
{
struct RoleTable* roleTable = map->roleTable;
word_t limit = role_table_capacity(roleTable);
indent(depth); fprintf(stderr, "role table capacity: %" PRIdPTR "\n", limit);
for (i = 0; i < limit; i++) {
if (roleTable->roles[i].name == (struct Symbol*)oh->cached.nil) {continue;}
else {
indent(depth); fprintf(stderr, "role[%" PRIdPTR "]['", i); print_symbol(roleTable->roles[i].name);
fprintf(stderr, "'] @ 0x%04" PRIxPTR "\n", object_to_smallint(roleTable->roles[i].rolePositions));
#if 0
print_object_with_depth(oh, (struct Object*)roleTable->roles[i].methodDefinition, max_depth, max_depth);
#endif
if (limit - i > 50 && depth >= 2) {
indent(depth); fprintf(stderr, "...\n");
i = limit - 3;
}
}
}
}
indent(depth); fprintf(stderr, "}\n");
}
void print_backtrace(struct object_heap* oh) {
word_t depth = 0, detail_depth = -1 /*raise this to print verbose args in stack longer*/;
struct Interpreter* i = oh->cached.interpreter;
struct Closure* closure = (struct Closure*)i->method;
word_t codePointer = i->codePointer;
word_t fp = i->framePointer;
word_t sp = i->stackPointer;
word_t codeSize = i->codeSize;
word_t resultStackPointer = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_RESULT_STACK_POINTER]);
struct LexicalContext* lc = (struct LexicalContext*)i->stack->elements[fp - FRAME_OFFSET_LEXICAL_CONTEXT];;
fprintf(stderr, "printing backtrace from fp=%" PRIdPTR ", sp=%" PRIdPTR "\n", fp, i->stackPointer);
do {
word_t j;
struct Object** vars;
word_t input_count = object_to_smallint(closure->method->inputVariables);
word_t local_count = object_to_smallint(closure->method->localVariables);
vars = (closure->method->heapAllocate == oh->cached.true_object)? (&lc->variables[0]) : (&i->stack->elements[fp]);
fprintf(stderr, "------------------------------\n");
fprintf(stderr, "FP: %" PRIdPTR "\n", fp);
fprintf(stderr, "SP: %" PRIdPTR "\n", sp);
fprintf(stderr, "IP: %" PRIdPTR "/%" PRIdPTR "\n", codePointer, codeSize);
fprintf(stderr, "result: %" PRIdPTR "\n", resultStackPointer);
fprintf(stderr, "code: %p\n", closure->method->code);
fprintf(stderr, "selector #"); print_byte_array((struct Object*)(closure->method->selector)); fprintf(stderr, "\n");
fprintf(stderr, "regs: %" PRIdPTR "\n", object_to_smallint(closure->method->registerCount));
fprintf(stderr, "heap alloc: %s\n", (closure->method->heapAllocate == oh->cached.true_object)? "true" : "false");
for (j = 0; j < input_count; j++) {
fprintf(stderr, "arg[%" PRIdPTR "] (%p) = ", j, (void*)vars[j]);
if (depth > detail_depth) {
print_type(oh, vars[j]);
} else {
print_detail(oh, vars[j]);
}
}
if (closure->method->heapAllocate == oh->cached.true_object) {
for (j = 0; j < local_count; j++) {
fprintf(stderr, "var[%" PRIdPTR "] (%p)= ", j, (void*)lc->variables[j]);
if (depth > detail_depth) {
print_type(oh, lc->variables[j]);
} else {
print_detail(oh, lc->variables[j]);
}
}
} else {
for (j = input_count; j < input_count + local_count; j++) {
fprintf(stderr, "var[%" PRIdPTR "] (%p) = ", j - input_count, (void*)vars[j]);
if (depth > detail_depth) {
print_type(oh, vars[j]);
} else {
print_detail(oh, vars[j]);
}
}
}
/*order matters here*/
codePointer = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_CODE_POINTER]);
fp = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_PREVIOUS_FRAME_POINTER]);
if (fp < FUNCTION_FRAME_SIZE) break;
sp = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_BEFORE_CALL_STACK_POINTER]);
resultStackPointer = object_to_smallint(i->stack->elements[fp - FRAME_OFFSET_RESULT_STACK_POINTER]);
closure = (struct Closure*)i->stack->elements[fp - FRAME_OFFSET_METHOD];
lc = (struct LexicalContext*)i->stack->elements[fp - FRAME_OFFSET_LEXICAL_CONTEXT];
codeSize = array_size(closure->method->code);
depth++;
} while (fp >= FUNCTION_FRAME_SIZE);
}
int
main(
int argc,
char *argv[]
) {
char *qemu_host;
char *qemu_port;
VSCMsgHeader mhHeader;
VSCMsgError *error_msg;
int rv;
int dwSendLength;
int dwRecvLength;
uint8_t pbRecvBuffer[APDUBufSize];
uint8_t pbSendBuffer[APDUBufSize];
VReaderStatus reader_status;
VReader *reader = NULL;
VCardEmulOptions *command_line_options = NULL;
char *cert_names[MAX_CERTS];
char *emul_args = NULL;
int cert_count = 0;
int c;
while ((c = getopt(argc, argv, "c:e:pd:")) != -1) {
switch (c) {
case 'c':
if (cert_count >= MAX_CERTS) {
printf("too many certificates (max = %d)\n", MAX_CERTS);
exit(5);
}
cert_names[cert_count++] = optarg;
break;
case 'e':
emul_args = optarg;
break;
case 'p':
print_usage();
exit(4);
break;
case 'd':
verbose = get_id_from_string(optarg, 1);
break;
}
}
if (argc - optind != 2) {
print_usage();
exit(4);
}
if (cert_count > 0) {
char *new_args;
int len, i;
/* if we've given some -c options, we clearly we want do so some
* software emulation. add that emulation now. this is NSS Emulator
* specific */
if (emul_args == NULL) {
emul_args = (char *)"db=\"/etc/pki/nssdb\"";
}
#define SOFT_STRING ",soft=(,Virtual Reader,CAC,,"
/* 2 == close paren & null */
len = strlen(emul_args) + strlen(SOFT_STRING) + 2;
for (i = 0; i < cert_count; i++) {
len += strlen(cert_names[i])+1; /* 1 == comma */
}
new_args = g_malloc(len);
strcpy(new_args, emul_args);
strcat(new_args, SOFT_STRING);
for (i = 0; i < cert_count; i++) {
strcat(new_args, cert_names[i]);
strcat(new_args, ",");
}
strcat(new_args, ")");
emul_args = new_args;
}
if (emul_args) {
command_line_options = vcard_emul_options(emul_args);
}
qemu_host = g_strdup(argv[argc - 2]);
qemu_port = g_strdup(argv[argc - 1]);
sock = connect_to_qemu(qemu_host, qemu_port);
if (sock == -1) {
fprintf(stderr, "error opening socket, exiting.\n");
exit(5);
}
qemu_mutex_init(&write_lock);
qemu_mutex_init(&pending_reader_lock);
qemu_cond_init(&pending_reader_condition);
vcard_emul_init(command_line_options);
printf("> ");
fflush(stdout);
/* Send init message, Host responds (and then we send reader attachments) */
VSCMsgInit init = {
.version = htonl(VSCARD_VERSION),
.magic = VSCARD_MAGIC,
.capabilities = {0}
};
send_msg(VSC_Init, mhHeader.reader_id, &init, sizeof(init));
do {
fd_set fds;
FD_ZERO(&fds);
FD_SET(1, &fds);
FD_SET(sock, &fds);
/* waiting on input from the socket */
rv = select(sock+1, &fds, NULL, NULL, NULL);
if (rv < 0) {
/* handle error */
perror("select");
return 7;
}
if (FD_ISSET(1, &fds)) {
do_command();
}
if (!FD_ISSET(sock, &fds)) {
continue;
}
rv = read(sock, &mhHeader, sizeof(mhHeader));
if (rv < sizeof(mhHeader)) {
/* Error */
if (rv < 0) {
perror("header read error\n");
} else {
fprintf(stderr, "header short read %d\n", rv);
}
return 8;
}
mhHeader.type = ntohl(mhHeader.type);
mhHeader.reader_id = ntohl(mhHeader.reader_id);
mhHeader.length = ntohl(mhHeader.length);
if (verbose) {
printf("Header: type=%d, reader_id=%u length=%d (0x%x)\n",
mhHeader.type, mhHeader.reader_id, mhHeader.length,
mhHeader.length);
}
switch (mhHeader.type) {
case VSC_APDU:
case VSC_Flush:
case VSC_Error:
case VSC_Init:
rv = read(sock, pbSendBuffer, mhHeader.length);
break;
default:
fprintf(stderr, "Unexpected message of type 0x%X\n", mhHeader.type);
return 0;
}
switch (mhHeader.type) {
case VSC_APDU:
if (rv < 0) {
/* Error */
fprintf(stderr, "read error\n");
close(sock);
return 8;
}
if (verbose) {
printf(" recv APDU: ");
print_byte_array(pbSendBuffer, mhHeader.length);
}
/* Transmit received APDU */
dwSendLength = mhHeader.length;
dwRecvLength = sizeof(pbRecvBuffer);
reader = vreader_get_reader_by_id(mhHeader.reader_id);
reader_status = vreader_xfr_bytes(reader,
pbSendBuffer, dwSendLength,
pbRecvBuffer, &dwRecvLength);
if (reader_status == VREADER_OK) {
mhHeader.length = dwRecvLength;
if (verbose) {
printf(" send response: ");
print_byte_array(pbRecvBuffer, mhHeader.length);
}
send_msg(VSC_APDU, mhHeader.reader_id,
pbRecvBuffer, dwRecvLength);
} else {
rv = reader_status; /* warning: not meaningful */
send_msg(VSC_Error, mhHeader.reader_id, &rv, sizeof(uint32_t));
}
vreader_free(reader);
reader = NULL; /* we've freed it, don't use it by accident
again */
break;
case VSC_Flush:
/* TODO: actually flush */
send_msg(VSC_FlushComplete, mhHeader.reader_id, NULL, 0);
break;
case VSC_Error:
error_msg = (VSCMsgError *) pbSendBuffer;
if (error_msg->code == VSC_SUCCESS) {
qemu_mutex_lock(&pending_reader_lock);
if (pending_reader) {
vreader_set_id(pending_reader, mhHeader.reader_id);
vreader_free(pending_reader);
pending_reader = NULL;
qemu_cond_signal(&pending_reader_condition);
}
qemu_mutex_unlock(&pending_reader_lock);
break;
}
printf("warning: qemu refused to add reader\n");
if (error_msg->code == VSC_CANNOT_ADD_MORE_READERS) {
/* clear pending reader, qemu can't handle any more */
qemu_mutex_lock(&pending_reader_lock);
if (pending_reader) {
pending_reader = NULL;
/* make sure the event loop doesn't hang */
qemu_cond_signal(&pending_reader_condition);
}
qemu_mutex_unlock(&pending_reader_lock);
}
break;
case VSC_Init:
if (on_host_init(&mhHeader, (VSCMsgInit *)pbSendBuffer) < 0) {
return -1;
}
break;
default:
printf("Default\n");
return 0;
}
} while (rv >= 0);
return 0;
}
static void *
event_thread(void *arg)
{
unsigned char atr[MAX_ATR_LEN];
int atr_len = MAX_ATR_LEN;
VEvent *event = NULL;
unsigned int reader_id;
while (1) {
const char *reader_name;
event = vevent_wait_next_vevent();
if (event == NULL) {
break;
}
reader_id = vreader_get_id(event->reader);
if (reader_id == VSCARD_UNDEFINED_READER_ID &&
event->type != VEVENT_READER_INSERT) {
/* ignore events from readers qemu has rejected */
/* if qemu is still deciding on this reader, wait to see if need to
* forward this event */
qemu_mutex_lock(&pending_reader_lock);
if (!pending_reader || (pending_reader != event->reader)) {
/* wasn't for a pending reader, this reader has already been
* rejected by qemu */
qemu_mutex_unlock(&pending_reader_lock);
vevent_delete(event);
continue;
}
/* this reader hasn't been told its status from qemu yet, wait for
* that status */
while (pending_reader != NULL) {
qemu_cond_wait(&pending_reader_condition, &pending_reader_lock);
}
qemu_mutex_unlock(&pending_reader_lock);
/* now recheck the id */
reader_id = vreader_get_id(event->reader);
if (reader_id == VSCARD_UNDEFINED_READER_ID) {
/* this reader was rejected */
vevent_delete(event);
continue;
}
/* reader was accepted, now forward the event */
}
switch (event->type) {
case VEVENT_READER_INSERT:
/* tell qemu to insert a new CCID reader */
/* wait until qemu has responded to our first reader insert
* before we send a second. That way we won't confuse the responses
* */
qemu_mutex_lock(&pending_reader_lock);
while (pending_reader != NULL) {
qemu_cond_wait(&pending_reader_condition, &pending_reader_lock);
}
pending_reader = vreader_reference(event->reader);
qemu_mutex_unlock(&pending_reader_lock);
reader_name = vreader_get_name(event->reader);
if (verbose > 10) {
printf(" READER INSERT: %s\n", reader_name);
}
send_msg(VSC_ReaderAdd,
reader_id, /* currerntly VSCARD_UNDEFINED_READER_ID */
NULL, 0 /* TODO reader_name, strlen(reader_name) */);
break;
case VEVENT_READER_REMOVE:
/* future, tell qemu that an old CCID reader has been removed */
if (verbose > 10) {
printf(" READER REMOVE: %u\n", reader_id);
}
send_msg(VSC_ReaderRemove, reader_id, NULL, 0);
break;
case VEVENT_CARD_INSERT:
/* get the ATR (intended as a response to a power on from the
* reader */
atr_len = MAX_ATR_LEN;
vreader_power_on(event->reader, atr, &atr_len);
/* ATR call functions as a Card Insert event */
if (verbose > 10) {
printf(" CARD INSERT %u: ", reader_id);
print_byte_array(atr, atr_len);
}
send_msg(VSC_ATR, reader_id, atr, atr_len);
break;
case VEVENT_CARD_REMOVE:
/* Card removed */
if (verbose > 10) {
printf(" CARD REMOVE %u:\n", reader_id);
}
send_msg(VSC_CardRemove, reader_id, NULL, 0);
break;
default:
break;
}
vevent_delete(event);
}
return NULL;
}
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;
}