webadmin/pico-keys-sdk
1
0
Fork 0
mirror of https://github.com/polhenarejos/pico-keys-sdk synced 2026-05-08 14:06:11 +02:00
Code Issues Packages Projects Releases Wiki Activity

Switching to new style.

Browse Source 
Signed-off-by: Pol Henarejos <pol.henarejos@cttc.es>
This commit is contained in:
Pol Henarejos
2023-02-15 00:10:00 +01:00
parent 12bdcbd1f9
commit 43ef33d60b
16 changed files with 429 additions and 521 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
src/fs/file.c
View File

@@ -42,8 +42,7 @@ extern uint8_t *flash_read(uintptr_t addr);
extern void low_flash_available();
//puts FCI in the RAPDU
void process_fci(const file_t *pe, int fmd)
{
void process_fci(const file_t *pe, int fmd) {
res_APDU_size = 0;
if (fmd) {
res_APDU[res_APDU_size++] = 0x6f;
@@ -60,13 +59,15 @@ void process_fci(const file_t *pe, int fmd)
uint16_t len = ((int (*)(const file_t *, int))(pe->data))(pe, 0);
res_APDU[res_APDU_size++] = (len >> 8) & 0xff;
res_APDU[res_APDU_size++] = len & 0xff;
} else {
}
else {
uint16_t v = file_get_size(pe);
res_APDU[res_APDU_size++] = v >> 8;
res_APDU[res_APDU_size++] = v & 0xff;
}
} else {
memset(res_APDU+res_APDU_size, 0, 2);
}
else {
memset(res_APDU + res_APDU_size, 0, 2);
res_APDU_size += 2;
}
@@ -75,23 +76,25 @@ void process_fci(const file_t *pe, int fmd)
res_APDU[res_APDU_size] = 0;
if (pe->type == FILE_TYPE_INTERNAL_EF) {
res_APDU[res_APDU_size++] |= 0x08;
} else if (pe->type == FILE_TYPE_WORKING_EF) {
}
else if (pe->type == FILE_TYPE_WORKING_EF) {
res_APDU[res_APDU_size++] |= pe->ef_structure & 0x7;
} else if (pe->type == FILE_TYPE_DF) {
}
else if (pe->type == FILE_TYPE_DF) {
res_APDU[res_APDU_size++] |= 0x38;
}
res_APDU[res_APDU_size++] = 0x83;
res_APDU[res_APDU_size++] = 2;
put_uint16_t(pe->fid, res_APDU+res_APDU_size);
put_uint16_t(pe->fid, res_APDU + res_APDU_size);
res_APDU_size += 2;
if (pe->name) {
res_APDU[res_APDU_size++] = 0x84;
res_APDU[res_APDU_size++] = MIN(pe->name[0], 16);
memcpy(res_APDU+res_APDU_size, pe->name+2, MIN(pe->name[0], 16));
memcpy(res_APDU + res_APDU_size, pe->name + 2, MIN(pe->name[0], 16));
res_APDU_size += MIN(pe->name[0], 16);
}
memcpy(res_APDU+res_APDU_size, "\x8A\x01\x05", 3); //life-cycle (5 -> activated)
memcpy(res_APDU + res_APDU_size, "\x8A\x01\x05", 3); //life-cycle (5 -> activated)
res_APDU_size += 3;
uint8_t *meta_data = NULL;
uint8_t meta_size = meta_find(pe->fid, &meta_data);
@@ -99,12 +102,12 @@ void process_fci(const file_t *pe, int fmd)
res_APDU[res_APDU_size++] = 0xA5;
res_APDU[res_APDU_size++] = 0x81;
res_APDU[res_APDU_size++] = meta_size;
memcpy(res_APDU+res_APDU_size, meta_data, meta_size);
memcpy(res_APDU + res_APDU_size, meta_data, meta_size);
res_APDU_size += meta_size;
}
res_APDU[1] = res_APDU_size-2;
res_APDU[1] = res_APDU_size - 2;
if (fmd) {
res_APDU[3] = res_APDU_size-4;
res_APDU[3] = res_APDU_size - 4;
}
}
@@ -114,8 +117,7 @@ file_t dynamic_file[MAX_DYNAMIC_FILES];
bool card_terminated = false;
bool is_parent(const file_t *child, const file_t *parent)
{
bool is_parent(const file_t *child, const file_t *parent) {
if (child == parent) {
return true;
}
@@ -125,23 +127,20 @@ bool is_parent(const file_t *child, const file_t *parent)
return is_parent(&file_entries[child->parent], parent);
}
file_t *get_parent(file_t *f)
{
file_t *get_parent(file_t *f) {
return &file_entries[f->parent];
}
file_t *search_by_name(uint8_t *name, uint16_t namelen)
{
file_t *search_by_name(uint8_t *name, uint16_t namelen) {
for (file_t *p = file_entries; p != file_last; p++) {
if (p->name && *p->name == apdu.nc && memcmp(p->name+1, name, namelen) == 0) {
if (p->name && *p->name == apdu.nc && memcmp(p->name + 1, name, namelen) == 0) {
return p;
}
}
return NULL;
}
file_t *search_by_fid(const uint16_t fid, const file_t *parent, const uint8_t sp)
{
file_t *search_by_fid(const uint16_t fid, const file_t *parent, const uint8_t sp) {
for (file_t *p = file_entries; p != file_last; p++) {
if (p->fid != 0x0000 && p->fid == fid) {
@@ -157,8 +156,7 @@ file_t *search_by_fid(const uint16_t fid, const file_t *parent, const uint8_t sp
return NULL;
}
uint8_t make_path_buf(const file_t *pe, uint8_t *buf, uint8_t buflen, const file_t *top)
{
uint8_t make_path_buf(const file_t *pe, uint8_t *buf, uint8_t buflen, const file_t *top) {
if (!buflen) {
return 0;
}
@@ -166,24 +164,22 @@ uint8_t make_path_buf(const file_t *pe, uint8_t *buf, uint8_t buflen, const file
return 0;
}
put_uint16_t(pe->fid, buf);
return make_path_buf(&file_entries[pe->parent], buf+2, buflen-2, top)+2;
return make_path_buf(&file_entries[pe->parent], buf + 2, buflen - 2, top) + 2;
}
uint8_t make_path(const file_t *pe, const file_t *top, uint8_t *path)
{
uint8_t buf[MAX_DEPTH*2], *p = path;
uint8_t make_path(const file_t *pe, const file_t *top, uint8_t *path) {
uint8_t buf[MAX_DEPTH * 2], *p = path;
put_uint16_t(pe->fid, buf);
uint8_t depth = make_path_buf(&file_entries[pe->parent], buf+2, sizeof(buf)-2, top)+2;
for (int d = depth-2; d >= 0; d -= 2) {
memcpy(p, buf+d, 2);
uint8_t depth = make_path_buf(&file_entries[pe->parent], buf + 2, sizeof(buf) - 2, top) + 2;
for (int d = depth - 2; d >= 0; d -= 2) {
memcpy(p, buf + d, 2);
p += 2;
}
return depth;
}
file_t *search_by_path(const uint8_t *pe_path, uint8_t pathlen, const file_t *parent)
{
uint8_t path[MAX_DEPTH*2];
file_t *search_by_path(const uint8_t *pe_path, uint8_t pathlen, const file_t *parent) {
uint8_t path[MAX_DEPTH * 2];
if (pathlen > sizeof(path)) {
return NULL;
}
@@ -201,26 +197,27 @@ file_t *currentDF = NULL;
const file_t *selected_applet = NULL;
bool isUserAuthenticated = false;
bool authenticate_action(const file_t *ef, uint8_t op)
{
bool authenticate_action(const file_t *ef, uint8_t op) {
uint8_t acl = ef->acl[op];
if (acl == 0x0) {
return true;
} else if (acl == 0xff) {
}
else if (acl == 0xff) {
return false;
} else if (acl == 0x90 || (acl & 0x9F) == 0x10) {
}
else if (acl == 0x90 || (acl & 0x9F) == 0x10) {
// PIN required.
if (isUserAuthenticated) {
return true;
} else {
}
else {
return false;
}
}
return false;
}
void initialize_flash(bool hard)
{
void initialize_flash(bool hard) {
if (hard) {
const uint8_t empty[8] = { 0 };
flash_program_block(end_data_pool, empty, sizeof(empty));
@@ -234,8 +231,7 @@ void initialize_flash(bool hard)
dynamic_files = 0;
}
void scan_region(bool persistent)
{
void scan_region(bool persistent) {
uintptr_t endp = end_data_pool, startp = start_data_pool;
if (persistent) {
endp = end_rom_pool;
@@ -247,15 +243,16 @@ void scan_region(bool persistent)
break;
}
uint16_t fid = flash_read_uint16(base+sizeof(uintptr_t)+sizeof(uintptr_t));
uint16_t fid = flash_read_uint16(base + sizeof(uintptr_t) + sizeof(uintptr_t));
printf("[%x] scan fid %x, len %d\r\n", (unsigned int) base, fid,
flash_read_uint16(base+sizeof(uintptr_t)+sizeof(uintptr_t)+sizeof(uint16_t)));
flash_read_uint16(base + sizeof(uintptr_t) + sizeof(uintptr_t) + sizeof(uint16_t)));
file_t *file = (file_t *) search_by_fid(fid, NULL, SPECIFY_EF);
if (!file) {
file = file_new(fid);
}
if (file) {
file->data = (uint8_t *) (base+sizeof(uintptr_t)+sizeof(uintptr_t)+sizeof(uint16_t));
file->data =
(uint8_t *) (base + sizeof(uintptr_t) + sizeof(uintptr_t) + sizeof(uint16_t));
}
if (flash_read_uintptr(base) == 0x0) {
break;
@@ -263,13 +260,12 @@ void scan_region(bool persistent)
}
}
void wait_flash_finish();
void scan_flash()
{
void scan_flash() {
initialize_flash(false); //soft initialization
if (*(uintptr_t *) flash_read(end_rom_pool) == 0xffffffff &&
*(uintptr_t *) flash_read(end_rom_pool+sizeof(uintptr_t)) == 0xffffffff) {
*(uintptr_t *) flash_read(end_rom_pool + sizeof(uintptr_t)) == 0xffffffff) {
printf("First initialization (or corrupted!)\r\n");
uint8_t empty[sizeof(uintptr_t)*2+sizeof(uint32_t)];
uint8_t empty[sizeof(uintptr_t) * 2 + sizeof(uint32_t)];
memset(empty, 0, sizeof(empty));
flash_program_block(end_data_pool, empty, sizeof(empty));
flash_program_block(end_rom_pool, empty, sizeof(empty));
@@ -281,37 +277,31 @@ void scan_flash()
scan_region(false);
}
uint8_t *file_read(const uint8_t *addr)
{
uint8_t *file_read(const uint8_t *addr) {
return flash_read((uintptr_t) addr);
}
uint16_t file_read_uint16(const uint8_t *addr)
{
uint16_t file_read_uint16(const uint8_t *addr) {
return flash_read_uint16((uintptr_t) addr);
}
uint8_t file_read_uint8(const uint8_t *addr)
{
uint8_t file_read_uint8(const uint8_t *addr) {
return flash_read_uint8((uintptr_t) addr);
}
uint8_t *file_get_data(const file_t *tf)
{
uint8_t *file_get_data(const file_t *tf) {
if (!tf || !tf->data) {
return NULL;
}
return file_read(tf->data+sizeof(uint16_t));
return file_read(tf->data + sizeof(uint16_t));
}
uint16_t file_get_size(const file_t *tf)
{
uint16_t file_get_size(const file_t *tf) {
if (!tf || !tf->data) {
return 0;
}
return file_read_uint16(tf->data);
}
file_t *search_dynamic_file(uint16_t fid)
{
file_t *search_dynamic_file(uint16_t fid) {
for (int i = 0; i < dynamic_files; i++) {
if (dynamic_file[i].fid == fid) {
return &dynamic_file[i];
@@ -320,15 +310,14 @@ file_t *search_dynamic_file(uint16_t fid)
return NULL;
}
int delete_dynamic_file(file_t *f)
{
int delete_dynamic_file(file_t *f) {
if (f == NULL) {
return CCID_ERR_FILE_NOT_FOUND;
}
for (int i = 0; i < dynamic_files; i++) {
if (dynamic_file[i].fid == f->fid) {
for (int j = i+1; j < dynamic_files; j++) {
memcpy(&dynamic_file[j-1], &dynamic_file[j], sizeof(file_t));
for (int j = i + 1; j < dynamic_files; j++) {
memcpy(&dynamic_file[j - 1], &dynamic_file[j], sizeof(file_t));
}
dynamic_files--;
return CCID_OK;
@@ -337,8 +326,7 @@ int delete_dynamic_file(file_t *f)
return CCID_ERR_FILE_NOT_FOUND;
}
file_t *file_new(uint16_t fid)
{
file_t *file_new(uint16_t fid) {
file_t *f;
if ((f = search_dynamic_file(fid)) || (f = search_by_fid(fid, NULL, SPECIFY_EF))) {
return f;
@@ -361,8 +349,7 @@ file_t *file_new(uint16_t fid)
//memset((uint8_t *)f->acl, 0x90, sizeof(f->acl));
return f;
}
int meta_find(uint16_t fid, uint8_t **out)
{
int meta_find(uint16_t fid, uint8_t **out) {
file_t *ef = search_by_fid(EF_META, NULL, SPECIFY_EF);
if (!ef) {
return CCID_ERR_FILE_NOT_FOUND;
@@ -377,15 +364,14 @@ int meta_find(uint16_t fid, uint8_t **out)
uint16_t cfid = (tag_data[0] << 8 | tag_data[1]);
if (cfid == fid) {
if (out) {
*out = tag_data+2;
*out = tag_data + 2;
}
return tag_len-2;
return tag_len - 2;
}
}
return 0;
}
int meta_delete(uint16_t fid)
{
int meta_delete(uint16_t fid) {
file_t *ef = search_by_fid(EF_META, NULL, SPECIFY_EF);
if (!ef) {
return CCID_ERR_FILE_NOT_FOUND;
@@ -395,22 +381,23 @@ int meta_delete(uint16_t fid)
size_t tag_len = 0, data_len = file_get_size(ef);
uint8_t *fdata = NULL;
while (walk_tlv(data, data_len, &p, &tag, &tag_len, &tag_data)) {
uint8_t *tpos = p-tag_len-format_tlv_len(tag_len, NULL)-1;
uint8_t *tpos = p - tag_len - format_tlv_len(tag_len, NULL) - 1;
if (tag_len < 2) {
continue;
}
uint16_t cfid = (tag_data[0] << 8 | tag_data[1]);
if (cfid == fid) {
size_t new_len = data_len-1-tag_len-format_tlv_len(tag_len, NULL);
size_t new_len = data_len - 1 - tag_len - format_tlv_len(tag_len, NULL);
if (new_len == 0) {
flash_clear_file(ef);
} else {
}
else {
fdata = (uint8_t *) calloc(1, new_len);
if (tpos > data) {
memcpy(fdata, data, tpos-data);
memcpy(fdata, data, tpos - data);
}
if (data+data_len > p) {
memcpy(fdata+(tpos-data), p, data+data_len-p);
if (data + data_len > p) {
memcpy(fdata + (tpos - data), p, data + data_len - p);
}
int r = flash_write_data_to_file(ef, fdata, new_len);
free(fdata);
@@ -424,8 +411,7 @@ int meta_delete(uint16_t fid)
}
return CCID_OK;
}
int meta_add(uint16_t fid, const uint8_t *data, uint16_t len)
{
int meta_add(uint16_t fid, const uint8_t *data, uint16_t len) {
int r;
file_t *ef = search_by_fid(EF_META, NULL, SPECIFY_EF);
if (!ef) {
@@ -443,32 +429,34 @@ int meta_add(uint16_t fid, const uint8_t *data, uint16_t len)
}
uint16_t cfid = (tag_data[0] << 8 | tag_data[1]);
if (cfid == fid) {
if (tag_len-2 == len) { //an update
memcpy(p-tag_len+2, data, len);
if (tag_len - 2 == len) { //an update
memcpy(p - tag_len + 2, data, len);
r = flash_write_data_to_file(ef, fdata, ef_size);
free(fdata);
if (r != CCID_OK) {
return CCID_EXEC_ERROR;
}
return CCID_OK;
} else { //needs reallocation
uint8_t *tpos = p-asn1_len_tag(tag, tag_len);
memmove(tpos, p, fdata+ef_size-p);
tpos += fdata+ef_size-p;
volatile uintptr_t meta_offset = tpos-fdata;
ef_size += len - (tag_len-2);
if (len > tag_len-2) {
}
else { //needs reallocation
uint8_t *tpos = p - asn1_len_tag(tag, tag_len);
memmove(tpos, p, fdata + ef_size - p);
tpos += fdata + ef_size - p;
volatile uintptr_t meta_offset = tpos - fdata;
ef_size += len - (tag_len - 2);
if (len > tag_len - 2) {
uint8_t *fdata_new = (uint8_t *) realloc(fdata, ef_size);
if (fdata_new != NULL) {
fdata = fdata_new;
} else {
}
else {
free(fdata);
return CCID_ERR_MEMORY_FATAL;
}
}
uint8_t *f = fdata+meta_offset;
uint8_t *f = fdata + meta_offset;
*f++ = fid & 0xff;
f += format_tlv_len(len+2, f);
f += format_tlv_len(len + 2, f);
*f++ = fid >> 8;
*f++ = fid & 0xff;
memcpy(f, data, len);
@@ -481,14 +469,14 @@ int meta_add(uint16_t fid, const uint8_t *data, uint16_t len)
}
}
}
fdata = (uint8_t *) realloc(fdata, ef_size+asn1_len_tag(fid & 0x1f, len+2));
uint8_t *f = fdata+ef_size;
fdata = (uint8_t *) realloc(fdata, ef_size + asn1_len_tag(fid & 0x1f, len + 2));
uint8_t *f = fdata + ef_size;
*f++ = fid & 0x1f;
f += format_tlv_len(len+2, f);
f += format_tlv_len(len + 2, f);
*f++ = fid >> 8;
*f++ = fid & 0xff;
memcpy(f, data, len);
r = flash_write_data_to_file(ef, fdata, ef_size+asn1_len_tag(fid & 0x1f, len+2));
r = flash_write_data_to_file(ef, fdata, ef_size + asn1_len_tag(fid & 0x1f, len + 2));
free(fdata);
if (r != CCID_OK) {
return CCID_EXEC_ERROR;
@@ -496,13 +484,11 @@ int meta_add(uint16_t fid, const uint8_t *data, uint16_t len)
return CCID_OK;
}
bool file_has_data(file_t *f)
{
bool file_has_data(file_t *f) {
return f != NULL && f->data != NULL && file_get_size(f) > 0;
}
int delete_file(file_t *ef)
{
int delete_file(file_t *ef) {
if (ef == NULL) {
return CCID_OK;
}