593 lines
15 KiB
C
593 lines
15 KiB
C
#include <stdlib.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
|
|
|
|
enum {
|
|
OFFSET_CLA = 0,
|
|
OFFSET_INS,
|
|
OFFSET_P1,
|
|
OFFSET_P2,
|
|
OFFSET_LC,
|
|
OFFSET_DATA
|
|
};
|
|
|
|
typedef enum
|
|
{
|
|
// contract defined struct
|
|
TYPE_CUSTOM = 0,
|
|
// native types
|
|
TYPE_SOL_INT,
|
|
TYPE_SOL_UINT,
|
|
TYPE_SOL_ADDRESS,
|
|
TYPE_SOL_BOOL,
|
|
TYPE_SOL_STRING,
|
|
TYPE_SOL_BYTE,
|
|
TYPE_SOL_BYTES_FIX,
|
|
TYPE_SOL_BYTES_DYN,
|
|
TYPES_COUNT
|
|
} e_type;
|
|
|
|
typedef enum
|
|
{
|
|
ARRAY_DYNAMIC = 0,
|
|
ARRAY_FIXED_SIZE
|
|
} e_array_type;
|
|
|
|
|
|
// APDUs INS
|
|
#define INS_STRUCT_DEF 0x18
|
|
#define INS_STRUCT_IMPL 0x1A
|
|
|
|
// TypeDesc masks
|
|
#define TYPE_MASK (0xF)
|
|
#define ARRAY_MASK (1 << 7)
|
|
#define TYPESIZE_MASK (1 << 6)
|
|
|
|
// Solidity typename mask
|
|
#define TYPENAME_MORE_TYPE (1 << 7)
|
|
#define TYPENAME_ENUM (0xF)
|
|
|
|
#define SIZE_MEM_BUFFER 1024
|
|
uint8_t mem_buffer[SIZE_MEM_BUFFER];
|
|
uint16_t mem_idx;
|
|
|
|
uint8_t *typenames_array;
|
|
uint8_t *structs_array;
|
|
uint8_t *current_struct_fields_array;
|
|
|
|
// lib functions
|
|
const uint8_t *get_array_in_mem(const uint8_t *ptr, uint8_t *const array_size)
|
|
{
|
|
*array_size = *ptr;
|
|
return (ptr + 1);
|
|
}
|
|
|
|
static inline const uint8_t *get_string_in_mem(const uint8_t *ptr, uint8_t *const string_length)
|
|
{
|
|
return get_array_in_mem(ptr, string_length);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
uint8_t get_struct_field_typedesc(const uint8_t *ptr)
|
|
{
|
|
return *ptr;
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
bool struct_field_is_array(const uint8_t *ptr)
|
|
{
|
|
return (get_struct_field_typedesc(ptr) & ARRAY_MASK);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
bool struct_field_has_typesize(const uint8_t *ptr)
|
|
{
|
|
return (get_struct_field_typedesc(ptr) & TYPESIZE_MASK);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
e_type struct_field_type(const uint8_t *ptr)
|
|
{
|
|
return (get_struct_field_typedesc(ptr) & TYPE_MASK);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
// TODO: Extra check inside or not
|
|
uint8_t get_struct_field_typesize(const uint8_t *ptr)
|
|
{
|
|
return *(ptr + 1);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
const uint8_t *get_struct_field_custom_typename(const uint8_t *ptr,
|
|
uint8_t *const length)
|
|
{
|
|
ptr += 1; // skip TypeDesc
|
|
return get_string_in_mem(ptr, length);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
const uint8_t *get_struct_field_sol_typename(const uint8_t *ptr,
|
|
uint8_t *const length)
|
|
{
|
|
e_type field_type;
|
|
const uint8_t *typename_ptr;
|
|
uint8_t typenames_count;
|
|
bool more_type;
|
|
bool typename_found;
|
|
|
|
field_type = struct_field_type(ptr);
|
|
typename_ptr = get_array_in_mem(typenames_array, &typenames_count);
|
|
typename_found = false;
|
|
while (typenames_count-- > 0)
|
|
{
|
|
more_type = true;
|
|
while (more_type)
|
|
{
|
|
more_type = *typename_ptr & TYPENAME_MORE_TYPE;
|
|
e_type type_enum = *typename_ptr & TYPENAME_ENUM;
|
|
if (type_enum == field_type)
|
|
{
|
|
typename_found = true;
|
|
}
|
|
typename_ptr += 1;
|
|
}
|
|
typename_ptr = get_string_in_mem(typename_ptr, length);
|
|
if (typename_found) return typename_ptr;
|
|
typename_ptr += *length;
|
|
}
|
|
return NULL; // Not found
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
const uint8_t *get_struct_field_typename(const uint8_t *ptr,
|
|
uint8_t *const length)
|
|
{
|
|
if (struct_field_type(ptr) == TYPE_CUSTOM)
|
|
{
|
|
return get_struct_field_custom_typename(ptr, length);
|
|
}
|
|
return get_struct_field_sol_typename(ptr, length);
|
|
}
|
|
|
|
// ptr must point to the beginning of a depth level
|
|
e_array_type struct_field_array_depth(const uint8_t *ptr,
|
|
uint8_t *const array_size)
|
|
{
|
|
if (*ptr == ARRAY_FIXED_SIZE)
|
|
{
|
|
*array_size = *(ptr + 1);
|
|
}
|
|
return *ptr;
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field level
|
|
const uint8_t *get_next_struct_field_array_lvl(const uint8_t *ptr)
|
|
{
|
|
switch (*ptr)
|
|
{
|
|
case ARRAY_DYNAMIC:
|
|
break;
|
|
case ARRAY_FIXED_SIZE:
|
|
ptr += 1;
|
|
break;
|
|
default:
|
|
// should not be in here :^)
|
|
break;
|
|
}
|
|
return ptr + 1;
|
|
}
|
|
|
|
// Skips TypeDesc and TypeSize/Length+TypeName
|
|
// Came to be since it is used in multiple functions
|
|
// TODO: Find better name
|
|
const uint8_t *struct_field_half_skip(const uint8_t *ptr)
|
|
{
|
|
const uint8_t *field_ptr;
|
|
uint8_t size;
|
|
|
|
field_ptr = ptr;
|
|
ptr += 1; // skip TypeDesc
|
|
if (struct_field_type(field_ptr) == TYPE_CUSTOM)
|
|
{
|
|
get_string_in_mem(ptr, &size);
|
|
ptr += (1 + size); // skip typename
|
|
}
|
|
else if (struct_field_has_typesize(field_ptr))
|
|
{
|
|
ptr += 1; // skip TypeSize
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
const uint8_t *get_struct_field_array_lvls_array(const uint8_t *ptr,
|
|
uint8_t *const length)
|
|
{
|
|
ptr = struct_field_half_skip(ptr);
|
|
return get_array_in_mem(ptr, length);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
const uint8_t *get_struct_field_keyname(const uint8_t *ptr,
|
|
uint8_t *const length)
|
|
{
|
|
const uint8_t *field_ptr;
|
|
uint8_t size;
|
|
|
|
field_ptr = ptr;
|
|
ptr = struct_field_half_skip(ptr);
|
|
if (struct_field_is_array(field_ptr))
|
|
{
|
|
ptr = get_array_in_mem(ptr, &size);
|
|
while (size-- > 0)
|
|
{
|
|
ptr = get_next_struct_field_array_lvl(ptr);
|
|
}
|
|
}
|
|
return get_string_in_mem(ptr, length);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct field
|
|
const uint8_t *get_next_struct_field(const uint8_t *ptr)
|
|
{
|
|
uint8_t length;
|
|
|
|
ptr = get_struct_field_keyname(ptr, &length);
|
|
return (ptr + length);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct
|
|
const uint8_t *get_struct_name(const uint8_t *ptr, uint8_t *const length)
|
|
{
|
|
return get_string_in_mem(ptr, length);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct
|
|
const uint8_t *get_struct_fields_array(const uint8_t *ptr,
|
|
uint8_t *const length)
|
|
{
|
|
uint8_t name_length;
|
|
|
|
get_struct_name(ptr, &name_length);
|
|
ptr += (1 + name_length); // skip length
|
|
return get_array_in_mem(ptr, length);
|
|
}
|
|
|
|
// ptr must point to the beginning of a struct
|
|
const uint8_t *get_next_struct(const uint8_t *ptr)
|
|
{
|
|
uint8_t fields_count;
|
|
|
|
ptr = get_struct_fields_array(ptr, &fields_count);
|
|
while (fields_count-- > 0)
|
|
{
|
|
ptr = get_next_struct_field(ptr);
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
// ptr must point to the size of the structs array
|
|
const uint8_t *get_structs_array(const uint8_t *ptr, uint8_t *const length)
|
|
{
|
|
return get_array_in_mem(ptr, length);
|
|
}
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
bool set_struct_name(uint8_t *data)
|
|
{
|
|
// increment number of structs
|
|
*structs_array += 1;
|
|
|
|
// copy length
|
|
mem_buffer[mem_idx++] = data[OFFSET_LC];
|
|
|
|
// copy name
|
|
memmove(&mem_buffer[mem_idx], &data[OFFSET_DATA], data[OFFSET_LC]);
|
|
mem_idx += data[OFFSET_LC];
|
|
|
|
// initialize number of fields
|
|
current_struct_fields_array = &mem_buffer[mem_idx];
|
|
mem_buffer[mem_idx++] = 0;
|
|
return true;
|
|
}
|
|
|
|
bool set_struct_field(uint8_t *data)
|
|
{
|
|
uint8_t data_idx = OFFSET_DATA;
|
|
uint8_t type_desc, len;
|
|
|
|
// increment number of struct fields
|
|
*current_struct_fields_array += 1;
|
|
|
|
// copy TypeDesc
|
|
type_desc = data[data_idx++];
|
|
mem_buffer[mem_idx++] = type_desc;
|
|
|
|
// check TypeSize flag in TypeDesc
|
|
if (type_desc & TYPESIZE_MASK)
|
|
{
|
|
// copy TypeSize
|
|
mem_buffer[mem_idx++] = data[data_idx++];
|
|
}
|
|
else if ((type_desc & TYPE_MASK) == TYPE_CUSTOM)
|
|
{
|
|
len = data[data_idx++];
|
|
// copy custom struct name length
|
|
mem_buffer[mem_idx++] = len;
|
|
// copy name
|
|
memmove(&mem_buffer[mem_idx], &data[data_idx], len);
|
|
mem_idx += len;
|
|
data_idx += len;
|
|
}
|
|
if (type_desc & ARRAY_MASK)
|
|
{
|
|
len = data[data_idx++];
|
|
mem_buffer[mem_idx++] = len;
|
|
while (len-- > 0)
|
|
{
|
|
mem_buffer[mem_idx++] = data[data_idx];
|
|
switch (data[data_idx++])
|
|
{
|
|
case ARRAY_DYNAMIC: // nothing to do
|
|
break;
|
|
case ARRAY_FIXED_SIZE:
|
|
mem_buffer[mem_idx++] = data[data_idx++];
|
|
break;
|
|
default:
|
|
// should not be in here :^)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// copy length
|
|
len = data[data_idx++];
|
|
mem_buffer[mem_idx++] = len;
|
|
|
|
// copy name
|
|
memmove(&mem_buffer[mem_idx], &data[data_idx], len);
|
|
mem_idx += len;
|
|
return true;
|
|
}
|
|
|
|
|
|
void dump_mem(void)
|
|
{
|
|
uint8_t structs_count;
|
|
const uint8_t *struct_ptr;
|
|
//
|
|
uint8_t fields_count;
|
|
const uint8_t *field_ptr;
|
|
//
|
|
uint8_t lvls_count;
|
|
const uint8_t *lvl_ptr;
|
|
|
|
const uint8_t *name;
|
|
uint8_t name_length;
|
|
//
|
|
uint8_t array_size;
|
|
uint8_t byte_size;
|
|
|
|
|
|
struct_ptr = get_structs_array(structs_array, &structs_count);
|
|
while (structs_count-- > 0)
|
|
{
|
|
name = get_struct_name(struct_ptr, &name_length);
|
|
fwrite(name, sizeof(*name), name_length, stdout);
|
|
printf("(");
|
|
field_ptr = get_struct_fields_array(struct_ptr, &fields_count);
|
|
for (int idx = 0; idx < fields_count; ++idx)
|
|
{
|
|
if (idx > 0) printf(",");
|
|
name = get_struct_field_typename(field_ptr, &name_length);
|
|
fwrite(name, sizeof(*name), name_length, stdout);
|
|
if (struct_field_has_typesize(field_ptr))
|
|
{
|
|
byte_size = get_struct_field_typesize(field_ptr);
|
|
switch(struct_field_type(field_ptr))
|
|
{
|
|
case TYPE_SOL_INT:
|
|
case TYPE_SOL_UINT:
|
|
printf("%u", (byte_size * 8));
|
|
break;
|
|
case TYPE_SOL_BYTES_FIX:
|
|
printf("%u", byte_size);
|
|
break;
|
|
default:
|
|
// should not be in here :^)
|
|
break;
|
|
}
|
|
}
|
|
if (struct_field_is_array(field_ptr))
|
|
{
|
|
lvl_ptr = get_struct_field_array_lvls_array(field_ptr, &lvls_count);
|
|
while (lvls_count-- > 0)
|
|
{
|
|
printf("[");
|
|
switch (struct_field_array_depth(lvl_ptr, &array_size))
|
|
{
|
|
case ARRAY_DYNAMIC:
|
|
break;
|
|
case ARRAY_FIXED_SIZE:
|
|
printf("%u", array_size);
|
|
break;
|
|
default:
|
|
// should not be in here :^)
|
|
break;
|
|
}
|
|
printf("]");
|
|
lvl_ptr = get_next_struct_field_array_lvl(lvl_ptr);
|
|
}
|
|
}
|
|
printf(" ");
|
|
name = get_struct_field_keyname(field_ptr, &name_length);
|
|
fwrite(name, sizeof(*name), name_length, stdout);
|
|
|
|
field_ptr = get_next_struct_field(field_ptr);
|
|
}
|
|
printf(")\n");
|
|
struct_ptr = get_next_struct(struct_ptr);
|
|
}
|
|
return;
|
|
}
|
|
|
|
bool handle_apdu(uint8_t *data)
|
|
{
|
|
switch (data[OFFSET_INS])
|
|
{
|
|
case INS_STRUCT_DEF:
|
|
switch (data[OFFSET_P2])
|
|
{
|
|
case 0x00:
|
|
set_struct_name(data);
|
|
break;
|
|
case 0xFF:
|
|
set_struct_field(data);
|
|
break;
|
|
default:
|
|
printf("Unknown P2 0x%x for APDU 0x%x\n", data[OFFSET_P2], data[OFFSET_INS]);
|
|
return false;
|
|
}
|
|
break;
|
|
case INS_STRUCT_IMPL:
|
|
break;
|
|
default:
|
|
printf("Unrecognized APDU");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool init_typenames(void)
|
|
{
|
|
char *typenames_str[] = {
|
|
"int",
|
|
"uint",
|
|
"address",
|
|
"bool",
|
|
"string",
|
|
"byte",
|
|
"bytes"
|
|
};
|
|
int enum_to_idx[][2] = {
|
|
{ TYPE_SOL_INT, 0 },
|
|
{ TYPE_SOL_UINT, 1},
|
|
{ TYPE_SOL_ADDRESS, 2 },
|
|
{ TYPE_SOL_BOOL, 3 },
|
|
{ TYPE_SOL_STRING, 4 },
|
|
{ TYPE_SOL_BYTE, 5 },
|
|
{ TYPE_SOL_BYTES_FIX, 6 },
|
|
{ TYPE_SOL_BYTES_DYN, 6 }
|
|
};
|
|
bool first_match;
|
|
|
|
typenames_array = &mem_buffer[mem_idx++];
|
|
*typenames_array = 0;
|
|
// loop over typenames
|
|
for (size_t s_idx = 0;
|
|
s_idx < (sizeof(typenames_str) / sizeof(typenames_str[0]));
|
|
++s_idx)
|
|
{
|
|
first_match = true;
|
|
// loop over enum/typename pairs
|
|
for (size_t e_idx = 0;
|
|
e_idx < (sizeof(enum_to_idx) / sizeof(enum_to_idx[0]));
|
|
++e_idx)
|
|
{
|
|
if (s_idx == (size_t)enum_to_idx[e_idx][1]) // match
|
|
{
|
|
mem_buffer[mem_idx] = enum_to_idx[e_idx][0];
|
|
if (!first_match) // in case of a previous match, mark it
|
|
{
|
|
mem_buffer[mem_idx - 1] |= TYPENAME_MORE_TYPE;
|
|
}
|
|
mem_idx += 1;
|
|
first_match = false;
|
|
}
|
|
}
|
|
|
|
if (!first_match) // if at least one match was found
|
|
{
|
|
mem_buffer[mem_idx++] = strlen(typenames_str[s_idx]);
|
|
// copy typename
|
|
memcpy(&mem_buffer[mem_idx],
|
|
typenames_str[s_idx],
|
|
mem_buffer[mem_idx - 1]);
|
|
// increment mem idx by typename length
|
|
mem_idx += mem_buffer[mem_idx - 1];
|
|
}
|
|
// increment array size
|
|
*typenames_array += 1;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void init_heap(void)
|
|
{
|
|
// init global variables
|
|
mem_idx = 0;
|
|
|
|
init_typenames();
|
|
|
|
// set types pointer
|
|
structs_array = &mem_buffer[mem_idx];
|
|
|
|
// create len(types)
|
|
mem_buffer[mem_idx++] = 0;
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
uint8_t buf[256];
|
|
uint8_t idx;
|
|
int state;
|
|
uint8_t payload_size;
|
|
|
|
init_heap();
|
|
|
|
state = OFFSET_CLA;
|
|
idx = 0;
|
|
while (true)
|
|
{
|
|
if (fread(&buf[idx], sizeof(buf[0]), 1, stdin) == 0) break;
|
|
switch (state)
|
|
{
|
|
case OFFSET_CLA:
|
|
case OFFSET_INS:
|
|
case OFFSET_P1:
|
|
case OFFSET_P2:
|
|
state += 1;
|
|
idx += 1;
|
|
break;
|
|
case OFFSET_LC:
|
|
payload_size = buf[idx];
|
|
state = OFFSET_DATA;
|
|
idx += 1;
|
|
break;
|
|
case OFFSET_DATA:
|
|
if (--payload_size == 0)
|
|
{
|
|
handle_apdu(buf);
|
|
state = OFFSET_CLA;
|
|
idx = 0;
|
|
}
|
|
else idx += 1;
|
|
break;
|
|
default:
|
|
printf("Unexpected APDU state!\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
dump_mem();
|
|
printf("\n%d bytes used in RAM\n", mem_idx);
|
|
return EXIT_SUCCESS;
|
|
}
|