mirrors/pico-keys-sdk
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename CCID_ codes to PICOKEY_

Browse source 
Signed-off-by: Pol Henarejos <pol.henarejos@cttc.es>
This commit is contained in:
Pol Henarejos 2024-11-05 18:21:24 +01:00
parent 242e357a74
commit 6625678c30
No known key found for this signature in database
GPG key ID: C0095B7870A4CCD3
14 changed files with 95 additions and 95 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/apdu.c
View file

@ -56,7 +56,7 @@ int process_apdu() {
}
}
if (INS(apdu) == 0xA4 && P1(apdu) == 0x04 && (P2(apdu) == 0x00 || P2(apdu) == 0x4)) { //select by AID
if (select_app(apdu.data, apdu.nc) == CCID_OK) {
if (select_app(apdu.data, apdu.nc) == PICOKEY_OK) {
return SW_OK();
}
return SW_FILE_NOT_FOUND();

6
src/asn1.c
View file

@ -20,17 +20,17 @@
int asn1_ctx_init(uint8_t *data, uint16_t len, asn1_ctx_t *ctx) {
if (!ctx) {
return CCID_ERR_NULL_PARAM;
return PICOKEY_ERR_NULL_PARAM;
}
ctx->data = data;
ctx->len = len;
return CCID_OK;
return PICOKEY_OK;
}
int asn1_ctx_clear(asn1_ctx_t *ctx) {
ctx->data = NULL;
ctx->len = 0;
return CCID_OK;
return PICOKEY_OK;
}
uint16_t asn1_len(asn1_ctx_t *ctx) {

4
src/crypto_utils.c
View file

@ -82,7 +82,7 @@ int aes_encrypt(const uint8_t *key, const uint8_t *iv, uint16_t key_size, int mo
}
int r = mbedtls_aes_setkey_enc(&aes, key, key_size);
if (r != 0) {
return CCID_EXEC_ERROR;
return PICOKEY_EXEC_ERROR;
}
if (mode == PICO_KEYS_AES_MODE_CBC) {
return mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_ENCRYPT, len, tmp_iv, data, data);
@ -101,7 +101,7 @@ int aes_decrypt(const uint8_t *key, const uint8_t *iv, uint16_t key_size, int mo
}
int r = mbedtls_aes_setkey_dec(&aes, key, key_size);
if (r != 0) {
return CCID_EXEC_ERROR;
return PICOKEY_EXEC_ERROR;
}
if (mode == PICO_KEYS_AES_MODE_CBC) {
return mbedtls_aes_crypt_cbc(&aes, MBEDTLS_AES_DECRYPT, len, tmp_iv, data, data);

28
src/eac.c
View file

@ -97,10 +97,10 @@ int sm_sign(uint8_t *in, size_t in_len, uint8_t *out) {
int sm_unwrap() {
uint8_t sm_indicator = (CLA(apdu) >> 2) & 0x3;
if (sm_indicator == 0) {
return CCID_OK;
return PICOKEY_OK;
}
int r = sm_verify();
if (r != CCID_OK) {
if (r != PICOKEY_OK) {
return r;
}
apdu.ne = sm_get_le();
@ -126,23 +126,23 @@ int sm_unwrap() {
}
if (!body) {
apdu.nc = 0;
return CCID_OK;
return PICOKEY_OK;
}
if (is87 && *body++ != 0x1) {
return CCID_WRONG_PADDING;
return PICOKEY_WRONG_PADDING;
}
sm_update_iv();
aes_decrypt(sm_kenc, sm_iv, 128, PICO_KEYS_AES_MODE_CBC, body, body_size);
memmove(apdu.data, body, body_size);
apdu.nc = sm_remove_padding(apdu.data, body_size);
DEBUG_PAYLOAD(apdu.data, (int) apdu.nc);
return CCID_OK;
return PICOKEY_OK;
}
int sm_wrap() {
uint8_t sm_indicator = (CLA(apdu) >> 2) & 0x3;
if (sm_indicator == 0) {
return CCID_OK;
return PICOKEY_OK;
}
uint8_t input[4096];
size_t input_len = 0;
@ -153,7 +153,7 @@ int sm_wrap() {
mbedtls_mpi_copy(&sm_mSSC, &ssc);
int r = mbedtls_mpi_write_binary(&ssc, input, sm_blocksize);
if (r != 0) {
return CCID_EXEC_ERROR;
return PICOKEY_EXEC_ERROR;
}
input_len += sm_blocksize;
mbedtls_mpi_free(&ssc);
@ -203,7 +203,7 @@ int sm_wrap() {
apdu.ne = res_APDU_size;
}
set_res_sw(0x90, 0x00);
return CCID_OK;
return PICOKEY_OK;
}
uint16_t sm_get_le() {
@ -243,7 +243,7 @@ int sm_verify() {
data_len += sm_blocksize;
}
if (data_len + (add_header ? sm_blocksize : 0) > 4096) {
return CCID_WRONG_LENGTH;
return PICOKEY_WRONG_LENGTH;
}
mbedtls_mpi ssc;
mbedtls_mpi_init(&ssc);
@ -253,7 +253,7 @@ int sm_verify() {
input_len += sm_blocksize;
mbedtls_mpi_free(&ssc);
if (r != 0) {
return CCID_EXEC_ERROR;
return PICOKEY_EXEC_ERROR;
}
if (add_header) {
input[input_len++] = CLA(apdu);
@ -286,7 +286,7 @@ int sm_verify() {
}
}
if (!mac) {
return CCID_WRONG_DATA;
return PICOKEY_WRONG_DATA;
}
if (some_added) {
input[input_len++] = 0x80;
@ -295,12 +295,12 @@ int sm_verify() {
uint8_t signature[16];
r = sm_sign(input, input_len, signature);
if (r != 0) {
return CCID_EXEC_ERROR;
return PICOKEY_EXEC_ERROR;
}
if (memcmp(signature, mac, mac_len) == 0) {
return CCID_OK;
return PICOKEY_OK;
}
return CCID_VERIFICATION_FAILED;
return PICOKEY_VERIFICATION_FAILED;
}
uint16_t sm_remove_padding(const uint8_t *data, uint16_t data_len) {

48
src/fs/file.c
View file

@ -332,7 +332,7 @@ file_t *search_dynamic_file(uint16_t fid) {
int delete_dynamic_file(file_t *f) {
if (f == NULL) {
return CCID_ERR_FILE_NOT_FOUND;
return PICOKEY_ERR_FILE_NOT_FOUND;
}
for (int i = 0; i < dynamic_files; i++) {
if (dynamic_file[i].fid == f->fid) {
@ -340,10 +340,10 @@ int delete_dynamic_file(file_t *f) {
memcpy(&dynamic_file[j - 1], &dynamic_file[j], sizeof(file_t));
}
dynamic_files--;
return CCID_OK;
return PICOKEY_OK;
}
}
return CCID_ERR_FILE_NOT_FOUND;
return PICOKEY_ERR_FILE_NOT_FOUND;
}
file_t *file_new(uint16_t fid) {
@ -396,7 +396,7 @@ uint16_t meta_find(uint16_t fid, uint8_t **out) {
int meta_delete(uint16_t fid) {
file_t *ef = search_file(EF_META);
if (!ef) {
return CCID_ERR_FILE_NOT_FOUND;
return PICOKEY_ERR_FILE_NOT_FOUND;
}
uint16_t tag = 0x0;
uint8_t *tag_data = NULL, *p = NULL;
@ -425,21 +425,21 @@ int meta_delete(uint16_t fid) {
}
int r = file_put_data(ef, fdata, new_len);
free(fdata);
if (r != CCID_OK) {
return CCID_EXEC_ERROR;
if (r != PICOKEY_OK) {
return PICOKEY_EXEC_ERROR;
}
}
low_flash_available();
break;
}
}
return CCID_OK;
return PICOKEY_OK;
}
int meta_add(uint16_t fid, const uint8_t *data, uint16_t len) {
int r;
file_t *ef = search_file(EF_META);
if (!ef) {
return CCID_ERR_FILE_NOT_FOUND;
return PICOKEY_ERR_FILE_NOT_FOUND;
}
uint16_t ef_size = file_get_size(ef);
uint8_t *fdata = (uint8_t *) calloc(1, ef_size);
@ -459,10 +459,10 @@ int meta_add(uint16_t fid, const uint8_t *data, uint16_t len) {
memcpy(p - tag_len + 2, data, len);
r = file_put_data(ef, fdata, ef_size);
free(fdata);
if (r != CCID_OK) {
return CCID_EXEC_ERROR;
if (r != PICOKEY_OK) {
return PICOKEY_EXEC_ERROR;
}
return CCID_OK;
return PICOKEY_OK;
}
else { //needs reallocation
uint8_t *tpos = p - asn1_len_tag(tag, tag_len);
@ -477,7 +477,7 @@ int meta_add(uint16_t fid, const uint8_t *data, uint16_t len) {
}
else {
free(fdata);
return CCID_ERR_MEMORY_FATAL;
return PICOKEY_ERR_MEMORY_FATAL;
}
}
uint8_t *f = fdata + meta_offset;
@ -488,10 +488,10 @@ int meta_add(uint16_t fid, const uint8_t *data, uint16_t len) {
memcpy(f, data, len);
r = file_put_data(ef, fdata, ef_size);
free(fdata);
if (r != CCID_OK) {
return CCID_EXEC_ERROR;
if (r != PICOKEY_OK) {
return PICOKEY_EXEC_ERROR;
}
return CCID_OK;
return PICOKEY_OK;
}
}
}
@ -504,10 +504,10 @@ int meta_add(uint16_t fid, const uint8_t *data, uint16_t len) {
memcpy(f, data, len);
r = file_put_data(ef, fdata, ef_size + (uint16_t)asn1_len_tag(fid & 0x1f, len + 2));
free(fdata);
if (r != CCID_OK) {
return CCID_EXEC_ERROR;
if (r != PICOKEY_OK) {
return PICOKEY_EXEC_ERROR;
}
return CCID_OK;
return PICOKEY_OK;
}
bool file_has_data(file_t *f) {
@ -516,15 +516,15 @@ bool file_has_data(file_t *f) {
int delete_file(file_t *ef) {
if (ef == NULL) {
return CCID_OK;
return PICOKEY_OK;
}
meta_delete(ef->fid);
if (flash_clear_file(ef) != CCID_OK) {
return CCID_EXEC_ERROR;
if (flash_clear_file(ef) != PICOKEY_OK) {
return PICOKEY_EXEC_ERROR;
}
if (delete_dynamic_file(ef) != CCID_OK) {
return CCID_EXEC_ERROR;
if (delete_dynamic_file(ef) != PICOKEY_OK) {
return PICOKEY_EXEC_ERROR;
}
low_flash_available();
return CCID_OK;
return PICOKEY_OK;
}

14
src/fs/flash.c
View file

@ -128,7 +128,7 @@ uintptr_t allocate_free_addr(uint16_t size, bool persistent) {
int flash_clear_file(file_t *file) {
if (file == NULL || file->data == NULL) {
return CCID_OK;
return PICOKEY_OK;
}
uintptr_t base_addr =
(uintptr_t)(file->data - sizeof(uintptr_t) - sizeof(uint16_t) - sizeof(uintptr_t));
@ -144,18 +144,18 @@ int flash_clear_file(file_t *file) {
flash_program_uintptr(base_addr + sizeof(uintptr_t), 0);
file->data = NULL;
//printf("na %lx->%lx\n",prev_addr,flash_read_uintptr(prev_addr));
return CCID_OK;
return PICOKEY_OK;
}
int flash_write_data_to_file_offset(file_t *file, const uint8_t *data, uint16_t len,
uint16_t offset) {
if (!file) {
return CCID_ERR_NULL_PARAM;
return PICOKEY_ERR_NULL_PARAM;
}
uint16_t size_file_flash = file->data ? flash_read_uint16((uintptr_t) file->data) : 0;
uint8_t *old_data = NULL;
if (offset + len > FLASH_SECTOR_SIZE || offset > size_file_flash) {
return CCID_ERR_NO_MEMORY;
return PICOKEY_ERR_NO_MEMORY;
}
if (file->data) { //already in flash
if (offset + len <= size_file_flash) { //it fits, no need to move it
@ -163,7 +163,7 @@ int flash_write_data_to_file_offset(file_t *file, const uint8_t *data, uint16_t
if (data) {
flash_program_block((uintptr_t) file->data + sizeof(uint16_t) + offset, data, len);
}
return CCID_OK;
return PICOKEY_OK;
}
else { //we clear the old file
flash_clear_file(file);
@ -180,7 +180,7 @@ int flash_write_data_to_file_offset(file_t *file, const uint8_t *data, uint16_t
uintptr_t new_addr = allocate_free_addr(len, (file->type & FILE_PERSISTENT) == FILE_PERSISTENT);
//printf("na %x\n",new_addr);
if (new_addr == 0x0) {
return CCID_ERR_NO_MEMORY;
return PICOKEY_ERR_NO_MEMORY;
}
file->data = (uint8_t *) new_addr + sizeof(uintptr_t) + sizeof(uint16_t) + sizeof(uintptr_t); //next addr+fid+prev addr
flash_program_halfword(new_addr + sizeof(uintptr_t) + sizeof(uintptr_t), file->fid);
@ -191,7 +191,7 @@ int flash_write_data_to_file_offset(file_t *file, const uint8_t *data, uint16_t
if (old_data) {
free(old_data);
}
return CCID_OK;
return PICOKEY_OK;
}
int flash_write_data_to_file(file_t *file, const uint8_t *data, uint16_t len) {
return flash_write_data_to_file_offset(file, data, len, 0);

14
src/fs/low_flash.c
View file

@ -224,24 +224,24 @@ int flash_program_block(uintptr_t addr, const uint8_t *data, size_t len) {
page_flash_t *p = NULL;
if (!data || len == 0) {
return CCID_ERR_NULL_PARAM;
return PICOKEY_ERR_NULL_PARAM;
}
mutex_enter_blocking(&mtx_flash);
if (ready_pages == TOTAL_FLASH_PAGES) {
mutex_exit(&mtx_flash);
printf("ERROR: ALL FLASH PAGES CACHED\n");
return CCID_ERR_NO_MEMORY;
return PICOKEY_ERR_NO_MEMORY;
}
if (!(p = find_free_page(addr))) {
mutex_exit(&mtx_flash);
printf("ERROR: FLASH CANNOT FIND A PAGE (rare error)\n");
return CCID_ERR_MEMORY_FATAL;
return PICOKEY_ERR_MEMORY_FATAL;
}
memcpy(&p->page[addr & (FLASH_SECTOR_SIZE - 1)], data, len);
//printf("Flash: modified page %X with data %x at [%x]\n",(uintptr_t)addr,(uintptr_t)data,addr&(FLASH_SECTOR_SIZE-1));
mutex_exit(&mtx_flash);
return CCID_OK;
return PICOKEY_OK;
}
int flash_program_halfword(uintptr_t addr, uint16_t data) {
@ -305,19 +305,19 @@ int flash_erase_page(uintptr_t addr, size_t page_size) {
if (ready_pages == TOTAL_FLASH_PAGES) {
mutex_exit(&mtx_flash);
printf("ERROR: ALL FLASH PAGES CACHED\n");
return CCID_ERR_NO_MEMORY;
return PICOKEY_ERR_NO_MEMORY;
}
if (!(p = find_free_page(addr))) {
printf("ERROR: FLASH CANNOT FIND A PAGE (rare error)\n");
mutex_exit(&mtx_flash);
return CCID_ERR_MEMORY_FATAL;
return PICOKEY_ERR_MEMORY_FATAL;
}
p->erase = true;
p->ready = false;
p->page_size = page_size;
mutex_exit(&mtx_flash);
return CCID_OK;
return PICOKEY_OK;
}
bool flash_check_blank(const uint8_t *p_start, size_t size) {

12
src/fs/phy.c
View file

@ -24,7 +24,7 @@ phy_data_t phy_data;
int phy_serialize_data(const phy_data_t *phy, uint8_t *data, uint16_t *len) {
if (!phy || !data || !len) {
return CCID_ERR_NULL_PARAM;
return PICOKEY_ERR_NULL_PARAM;
}
uint8_t *p = data;
if (phy->vidpid_present) {
@ -46,12 +46,12 @@ int phy_serialize_data(const phy_data_t *phy, uint8_t *data, uint16_t *len) {
*p++ = phy->opts >> 8;
*p++ = phy->opts & 0xff;
*len = p - data;
return CCID_OK;
return PICOKEY_OK;
}
#include <stdio.h>
int phy_unserialize_data(const uint8_t *data, uint16_t len, phy_data_t *phy) {
if (!phy || !data || !len) {
return CCID_ERR_NULL_PARAM;
return PICOKEY_ERR_NULL_PARAM;
}
memset(phy, 0, sizeof(phy_data_t));
const uint8_t *p = data;
@ -80,7 +80,7 @@ int phy_unserialize_data(const uint8_t *data, uint16_t len, phy_data_t *phy) {
break;
}
}
return CCID_OK;
return PICOKEY_OK;
}
int phy_init() {
@ -89,11 +89,11 @@ int phy_init() {
const uint8_t *data = file_get_data(ef_phy);
DEBUG_DATA(data, file_get_size(ef_phy));
int ret = phy_unserialize_data(data, file_get_size(ef_phy), &phy_data);
if (ret != CCID_OK) {
if (ret != PICOKEY_OK) {
return ret;
}
}
return CCID_OK;
return PICOKEY_OK;
}
#endif

10
src/main.c
View file

@ -67,26 +67,26 @@ int register_app(int (*select_aid)(app_t *, uint8_t), const uint8_t *aid) {
int select_app(const uint8_t *aid, size_t aid_len) {
if (current_app && current_app->aid && (current_app->aid + 1 == aid || !memcmp(current_app->aid + 1, aid, aid_len))) {
current_app->select_aid(current_app, 0);
return CCID_OK;
return PICOKEY_OK;
}
for (int a = 0; a < num_apps; a++) {
if (!memcmp(apps[a].aid + 1, aid, MIN(aid_len, apps[a].aid[0]))) {
if (current_app) {
if (current_app->aid && !memcmp(current_app->aid + 1, aid, aid_len)) {
current_app->select_aid(current_app, 1);
return CCID_OK;
return PICOKEY_OK;
}
if (current_app->unload) {
current_app->unload();
}
}
current_app = &apps[a];
if (current_app->select_aid(current_app, 1) == CCID_OK) {
return CCID_OK;
if (current_app->select_aid(current_app, 1) == PICOKEY_OK) {
return PICOKEY_OK;
}
}
}
return CCID_ERR_FILE_NOT_FOUND;
return PICOKEY_ERR_FILE_NOT_FOUND;
}
int (*button_pressed_cb)(uint8_t) = NULL;

28
src/pico_keys.h
View file

@ -139,20 +139,20 @@ extern uint32_t button_timeout;
#define SW_OK() set_res_sw(0x90, 0x00)
#define CCID_OK 0
#define CCID_ERR_NO_MEMORY -1000
#define CCID_ERR_MEMORY_FATAL -1001
#define CCID_ERR_NULL_PARAM -1002
#define CCID_ERR_FILE_NOT_FOUND -1003
#define CCID_ERR_BLOCKED -1004
#define CCID_NO_LOGIN -1005
#define CCID_EXEC_ERROR -1006
#define CCID_WRONG_LENGTH -1007
#define CCID_WRONG_DATA -1008
#define CCID_WRONG_DKEK -1009
#define CCID_WRONG_SIGNATURE -1010
#define CCID_WRONG_PADDING -1011
#define CCID_VERIFICATION_FAILED -1012
#define PICOKEY_OK 0
#define PICOKEY_ERR_NO_MEMORY -1000
#define PICOKEY_ERR_MEMORY_FATAL -1001
#define PICOKEY_ERR_NULL_PARAM -1002
#define PICOKEY_ERR_FILE_NOT_FOUND -1003
#define PICOKEY_ERR_BLOCKED -1004
#define PICOKEY_NO_LOGIN -1005
#define PICOKEY_EXEC_ERROR -1006
#define PICOKEY_WRONG_LENGTH -1007
#define PICOKEY_WRONG_DATA -1008
#define PICOKEY_WRONG_DKEK -1009
#define PICOKEY_WRONG_SIGNATURE -1010
#define PICOKEY_WRONG_PADDING -1011
#define PICOKEY_VERIFICATION_FAILED -1012
#if defined(ENABLE_EMULATION) || defined(ESP_PLATFORM)
#define PICO_UNIQUE_BOARD_ID_SIZE_BYTES 8

6
src/rescue.c
View file

@ -36,7 +36,7 @@ int rescue_select(app_t *a, uint8_t force) {
if (force) {
scan_flash();
}
return CCID_OK;
return PICOKEY_OK;
}
INITIALIZER ( rescue_ctor ) {
@ -44,7 +44,7 @@ INITIALIZER ( rescue_ctor ) {
}
int rescue_unload() {
return CCID_OK;
return PICOKEY_OK;
}
int cmd_write() {
@ -55,7 +55,7 @@ int cmd_write() {
if (P1(apdu) == 0x1) { // PHY
#ifndef ENABLE_EMULATION
int ret = phy_unserialize_data(apdu.data, apdu.nc, &phy_data);
if (ret == CCID_OK) {
if (ret == PICOKEY_OK) {
file_put_data(ef_phy, apdu.data, apdu.nc);
}
#endif

6
src/usb/ccid/ccid.c
View file

@ -130,7 +130,7 @@ int driver_init_ccid(uint8_t itf) {
//ccid_tx[itf].w_ptr = ccid_tx[itf].r_ptr = 0;
return CCID_OK;
return PICOKEY_OK;
}
void tud_vendor_rx_cb(uint8_t itf) {
@ -302,10 +302,10 @@ void driver_exec_finished_cont_ccid(uint8_t itf, uint16_t size_next, uint16_t of
void ccid_task() {
for (int itf = 0; itf < ITF_SC_TOTAL; itf++) {
int status = card_status(sc_itf_to_usb_itf(itf));
if (status == CCID_OK) {
if (status == PICOKEY_OK) {
driver_exec_finished_ccid(itf, finished_data_size);
}
else if (status == CCID_ERR_BLOCKED) {
else if (status == PICOKEY_ERR_BLOCKED) {
driver_exec_timeout_ccid(itf);
}
if (ccid_tx[itf].w_ptr > ccid_tx[itf].r_ptr) {

4
src/usb/hid/hid.c
View file

@ -598,10 +598,10 @@ void hid_task() {
driver_process_usb_nopacket_hid();
}
int status = card_status(ITF_HID);
if (status == CCID_OK) {
if (status == PICOKEY_OK) {
driver_exec_finished_hid(finished_data_size);
}
else if (status == CCID_ERR_BLOCKED) {
else if (status == PICOKEY_ERR_BLOCKED) {
send_keepalive();
}
if (hid_tx[ITF_HID_CTAP].w_ptr > hid_tx[ITF_HID_CTAP].r_ptr && last_write_result[ITF_HID_CTAP] != WRITE_PENDING) {

8
src/usb/usb.c
View file

@ -177,7 +177,7 @@ int card_status(uint8_t itf) {
if (m == EV_EXEC_FINISHED) {
timeout_stop();
led_set_mode(MODE_MOUNTED);
return CCID_OK;
return PICOKEY_OK;
}
#ifndef ENABLE_EMULATION
else if (m == EV_PRESS_BUTTON) {
@ -185,16 +185,16 @@ int card_status(uint8_t itf) {
queue_try_add(&usb_to_card_q, &flag);
}
#endif
return CCID_ERR_FILE_NOT_FOUND;
return PICOKEY_ERR_FILE_NOT_FOUND;
}
else {
if (timeout > 0) {
if (timeout + timeout_counter[itf] < board_millis()) {
timeout = board_millis();
return CCID_ERR_BLOCKED;
return PICOKEY_ERR_BLOCKED;
}
}
}
}
return CCID_ERR_FILE_NOT_FOUND;
return PICOKEY_ERR_FILE_NOT_FOUND;
}