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

Fix emulation build.

Browse source 
Signed-off-by: Pol Henarejos <pol.henarejos@cttc.es>
This commit is contained in:
Pol Henarejos 2024-08-23 14:24:17 +02:00
parent 65fea84df1
commit 90842bb8f7
No known key found for this signature in database
GPG key ID: C0095B7870A4CCD3
6 changed files with 154 additions and 167 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
pico_keys_sdk_import.cmake
View file

@ -175,7 +175,7 @@ set(INCLUDES ${INCLUDES}
${CMAKE_CURRENT_LIST_DIR}/mbedtls/library
)
if(USB_ITF_HID OR ENABLE_EMULATION)
if(USB_ITF_HID)
set(MBEDTLS_SOURCES ${MBEDTLS_SOURCES}
${CMAKE_CURRENT_LIST_DIR}/mbedtls/library/x509write_crt.c
${CMAKE_CURRENT_LIST_DIR}/mbedtls/library/x509_create.c
@ -195,6 +195,15 @@ if(USB_ITF_HID OR ENABLE_EMULATION)
)
endif()
if (USB_ITF_CCID)
set(SOURCES ${SOURCES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/ccid/ccid.c
)
set(INCLUDES ${INCLUDES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/ccid
)
endif()
set(LIBRARIES
pico_stdlib
pico_multicore
@ -250,14 +259,6 @@ if (ENABLE_EMULATION)
${CMAKE_CURRENT_LIST_DIR}/src/usb/emulation
)
else()
if (${USB_ITF_CCID})
set(SOURCES ${SOURCES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/ccid/ccid.c
)
set(INCLUDES ${INCLUDES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/ccid
)
endif()
set(SOURCES ${SOURCES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/usb_descriptors.c

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

@ -19,15 +19,18 @@
#include "pico_keys.h"
#if !defined(ENABLE_EMULATION) && !defined(ESP_PLATFORM)
#include "hardware/rtc.h"
#endif
#ifndef ESP_PLATFORM
#include "bsp/board.h"
#else
#endif
#ifdef ESP_PLATFORM
static portMUX_TYPE mutex = portMUX_INITIALIZER_UNLOCKED;
#endif
#ifndef ENABLE_EMULATION
#include "tusb.h"
#include "ccid.h"
#include "device/usbd_pvt.h"
#else
#include "emulation.h"
#endif
#include "ccid.h"
#include "usb_descriptors.h"
#include "apdu.h"
#include "usb.h"
@ -142,9 +145,9 @@ void tud_vendor_rx_cb(uint8_t itf) {
tlen = 0xFFFF;
}
else {
tlen = len;
tlen = (uint16_t)len;
}
tlen = tud_vendor_n_read(itf, ccid_rx[itf].buffer + ccid_rx[itf].w_ptr, tlen);
tlen = (uint16_t)tud_vendor_n_read(itf, ccid_rx[itf].buffer + ccid_rx[itf].w_ptr, tlen);
ccid_rx[itf].w_ptr += tlen;
driver_process_usb_packet_ccid(itf, tlen);
len -= tlen;
@ -160,7 +163,7 @@ void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes) {
last_write_result[itf] = WRITE_SUCCESS;
ccid_header_t *lresp = &ccid_response_last[itf];
if (lresp->bMessageType != CCID_DATA_BLOCK_RET || lresp->dwLength != 0 || lresp->bSlot != 0 || lresp->abRFU0 != CCID_CMD_STATUS_TIMEEXT) {
ccid_tx[itf].r_ptr += sent_bytes;
ccid_tx[itf].r_ptr += (uint16_t)sent_bytes;
}
}
if (ccid_tx[itf].r_ptr >= ccid_tx[itf].w_ptr) {
@ -185,15 +188,19 @@ int driver_write_ccid(uint8_t itf, const uint8_t *tx_buffer, uint16_t buffer_siz
if (r == buffer_size) {
r = tud_vendor_n_flush(itf);
}
#ifdef ENABLE_EMULATION
tud_vendor_tx_cb(itf, r);
#endif
return r;
}
int driver_process_usb_packet_ccid(uint8_t itf, uint16_t rx_read) {
(void) rx_read;
if (ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr >= 10) {
driver_init_ccid(itf);
//printf("ccid_process %ld %d %x %x %d\n",ccid_header[itf]->dwLength,rx_read-10,ccid_header[itf]->bMessageType,ccid_header[itf]->bSeq,ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr - 10);
if (ccid_header[itf]->dwLength <= ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr - 10){
ccid_rx[itf].r_ptr += ccid_header[itf]->dwLength + 10;
if (ccid_header[itf]->dwLength <= (uint32_t)(ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr - 10)){
ccid_rx[itf].r_ptr += (uint16_t)(ccid_header[itf]->dwLength + 10);
if (ccid_rx[itf].r_ptr >= ccid_rx[itf].w_ptr) {
ccid_rx[itf].r_ptr = ccid_rx[itf].w_ptr = 0;
}
@ -214,7 +221,7 @@ int driver_process_usb_packet_ccid(uint8_t itf, uint16_t rx_read) {
else if (ccid_header[itf]->bMessageType == CCID_POWER_ON) {
size_t size_atr = (ccid_atr ? ccid_atr[0] : 0);
ccid_resp_fast[itf]->bMessageType = CCID_DATA_BLOCK_RET;
ccid_resp_fast[itf]->dwLength = size_atr;
ccid_resp_fast[itf]->dwLength = (uint32_t)size_atr;
ccid_resp_fast[itf]->bSlot = 0;
ccid_resp_fast[itf]->bSeq = ccid_header[itf]->bSeq;
ccid_resp_fast[itf]->abRFU0 = 0;
@ -225,7 +232,7 @@ int driver_process_usb_packet_ccid(uint8_t itf, uint16_t rx_read) {
//card_start(apdu_thread);
}
ccid_status = 0;
driver_write_ccid(itf, (const uint8_t *)ccid_resp_fast[itf], size_atr + 10);
driver_write_ccid(itf, (const uint8_t *)ccid_resp_fast[itf], (uint16_t)(size_atr + 10));
}
else if (ccid_header[itf]->bMessageType == CCID_POWER_OFF) {
if (ccid_status == 0) {
@ -264,22 +271,20 @@ int driver_process_usb_packet_ccid(uint8_t itf, uint16_t rx_read) {
}
else if (ccid_header[itf]->bMessageType == CCID_XFR_BLOCK) {
apdu.rdata = &ccid_response[itf]->apdu;
apdu_sent = apdu_process(itf, &ccid_header[itf]->apdu, ccid_header[itf]->dwLength);
apdu_sent = apdu_process(itf, &ccid_header[itf]->apdu, (uint16_t)ccid_header[itf]->dwLength);
#ifndef ENABLE_EMULATION
if (apdu_sent > 0) {
card_start(sc_itf_to_usb_itf(itf), apdu_thread);
usb_send_event(EV_CMD_AVAILABLE);
}
#endif
}
return apdu_sent;
return (uint16_t)apdu_sent;
}
}
return 0;
}
bool driver_mounted_ccid(uint8_t itf) {
return tud_vendor_n_mounted(itf);
}
void driver_exec_timeout_ccid(uint8_t itf) {
ccid_resp_fast[itf]->bMessageType = CCID_DATA_BLOCK_RET;
ccid_resp_fast[itf]->dwLength = 0;
@ -306,6 +311,12 @@ void driver_exec_finished_cont_ccid(uint8_t itf, uint16_t size_next, uint16_t of
}
void ccid_task() {
#ifdef ENABLE_EMULATION
uint16_t rx_len = emul_read(ITF_CCID);
if (rx_len) {
tud_vendor_rx_cb(ITF_CCID);
}
#else
for (int itf = 0; itf < ITF_SC_TOTAL; itf++) {
int status = card_status(sc_itf_to_usb_itf(itf));
if (status == CCID_OK) {
@ -320,8 +331,11 @@ void ccid_task() {
}
}
}
#endif
}
#ifndef ENABLE_EMULATION
#define USB_CONFIG_ATT_ONE TU_BIT(7)
#define MAX_USB_POWER 1
@ -429,3 +443,4 @@ usbd_class_driver_t const *usbd_app_driver_get_cb(uint8_t *driver_count) {
*driver_count = 1;
return &ccid_driver;
}
#endif

92
src/usb/emulation/emulation.c
View file

@ -164,16 +164,6 @@ int emul_init(char *host, uint16_t port) {
return 0;
}
uint8_t *driver_prepare_response_emul(uint8_t itf) {
apdu.rdata = usb_get_tx(itf);
#ifdef USB_ITF_HID
if (itf == ITF_HID) {
apdu.rdata += 7;
}
#endif
return apdu.rdata;
}
socket_t get_sock_itf(uint8_t itf) {
#ifdef USB_ITF_CCID
if (itf == ITF_CCID) {
@ -188,11 +178,6 @@ socket_t get_sock_itf(uint8_t itf) {
return INVALID_SOCKET;
}
extern void tud_hid_report_complete_cb(uint8_t instance, uint8_t const *report, uint16_t len);
const uint8_t *complete_report = NULL;
uint16_t complete_len = 0;
extern uint8_t last_write_result[ITF_TOTAL];
extern uint16_t send_buffer_size[ITF_TOTAL];
uint16_t driver_write_emul(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size) {
uint16_t size = htons(buffer_size);
socket_t sock = get_sock_itf(itf);
@ -210,28 +195,10 @@ uint16_t driver_write_emul(uint8_t itf, const uint8_t *buffer, uint16_t buffer_s
msleep(10);
}
} while (ret <= 0);
#ifdef USB_ITF_HID
if (itf == ITF_HID) {
last_write_result[itf] = WRITE_PENDING;
complete_report = buffer;
complete_len = buffer_size;
}
#endif
emul_tx_size = buffer_size;
return buffer_size;
}
uint32_t emul_write_offset(uint8_t itf, uint16_t size, uint16_t offset) {
if (size > 0) {
//DEBUG_PAYLOAD(usb_get_tx(itf)+offset, size);
return usb_write_offset(itf, size, offset);
}
return 0;
}
uint32_t emul_write(uint8_t itf, uint16_t size) {
return emul_write_offset(itf, size, 0);
}
void driver_exec_finished_cont_emul(uint8_t itf, uint16_t size_next, uint16_t offset) {
#ifdef USB_ITF_HID
if (itf == ITF_HID) {
@ -240,62 +207,14 @@ void driver_exec_finished_cont_emul(uint8_t itf, uint16_t size_next, uint16_t of
#endif
#ifdef USB_ITF_CCID
if (itf == ITF_CCID) {
emul_write_offset(itf, size_next, offset);
driver_exec_finished_cont_ccid(itf, size_next, offset);
}
#endif
}
int driver_process_usb_packet_emul(uint8_t itf, uint16_t len) {
if (len > 0) {
#ifdef USB_ITF_CCID
if (itf == ITF_CCID) {
uint8_t *data = usb_get_rx(itf);
if (len == 1) {
uint8_t c = data[0];
if (c == 4) {
driver_write_emul(itf, ccid_atr ? ccid_atr + 1 : NULL, ccid_atr ? ccid_atr[0] : 0);
}
}
else {
uint16_t sent = 0;
DEBUG_PAYLOAD(data, len);
if ((sent = apdu_process(itf, data, len)) > 0) {
process_apdu();
apdu_finish();
}
if (sent > 0) {
uint16_t ret = apdu_next();
DEBUG_PAYLOAD(apdu.rdata, ret);
emul_write(itf, ret);
}
}
}
#endif
#ifdef USB_ITF_HID
if (itf == ITF_HID) {
if (driver_process_usb_packet_hid(len) > 0) {
if (thread_type == 1) {
process_apdu();
apdu_finish();
finished_data_size = apdu_next();
}
else if (thread_type == 2) {
apdu.sw = cbor_parse(cmd, cbor_data, cbor_len);
if (apdu.sw == 0) {
DEBUG_DATA(res_APDU + 1, res_APDU_size);
}
finished_data_size = res_APDU_size + 1;
}
driver_exec_finished_hid(finished_data_size);
}
}
#endif
}
usb_clear_rx(itf);
return 0;
}
uint8_t emul_rx[USB_BUFFER_SIZE];
uint16_t emul_rx_size = 0, emul_tx_size = 0;
uint16_t emul_read(uint8_t itf) {
/* First we look for a client */
#ifdef USB_ITF_HID
@ -359,8 +278,9 @@ uint16_t emul_read(uint8_t itf) {
len = ntohs(len);
if (len > 0) {
while (true) {
valread = recv(sock, (char *)usb_get_rx(itf), len, 0);
valread = recv(sock, (char *)emul_rx, len, 0);
if (valread > 0) {
emul_rx_size = valread;
return (uint16_t)valread;
}
msleep(10);

49
src/usb/emulation/emulation.h
View file

@ -19,6 +19,55 @@
#define _EMULATION_H_
#include <stdint.h>
#include <stdlib.h>
#include "usb.h"
#ifdef _MSC_VER
#include <windows.h>
#endif
extern int emul_init(char *host, uint16_t port);
extern uint8_t emul_rx[USB_BUFFER_SIZE];
extern uint16_t emul_rx_size, emul_tx_size;
extern uint16_t driver_write_emul(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size);
extern uint16_t emul_read(uint8_t itf);
#ifdef USB_ITF_HID
typedef uint8_t hid_report_type_t;
#endif
#ifdef USB_ITF_CCID
static inline uint32_t tud_vendor_n_available(uint8_t itf) {
(void) itf;
return emul_rx_size;
}
static inline uint32_t tud_vendor_n_read(uint8_t itf, uint8_t *buffer, uint32_t n) {
(void) itf;
if (n > emul_rx_size) {
n = emul_rx_size;
}
memcpy(buffer, emul_rx, n);
emul_rx_size = 0;
return n;
}
extern void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes);
static inline uint32_t tud_vendor_n_write(uint8_t itf, const uint8_t *buffer, uint32_t n) {
uint16_t ret = driver_write_emul(ITF_CCID, buffer, (uint16_t)n);
tud_vendor_tx_cb(itf, ret);
return ret;
}
static inline uint32_t tud_vendor_n_flush(uint8_t itf) {
(void) itf;
return emul_tx_size;
}
#endif
#ifdef USB_ITF_HID
extern void tud_hid_report_complete_cb(uint8_t instance, uint8_t const *report, uint16_t len);
static inline bool tud_hid_n_report(uint8_t itf, uint8_t report_id, const uint8_t *buffer, uint32_t n) {
(void) itf;
(void) report_id;
uint16_t ret = driver_write_emul(ITF_HID, buffer, (uint16_t)n);
return ret > 0;
}
#endif
#endif // _EMULATION_H_

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

@ -22,6 +22,8 @@
#else
static portMUX_TYPE mutex = portMUX_INITIALIZER_UNLOCKED;
#endif
#else
#include "emulation.h"
#endif
#include "ctap_hid.h"
#include "pico_keys.h"
@ -95,18 +97,12 @@ uint16_t *get_send_buffer_size(uint8_t itf) {
// USB HID
//--------------------------------------------------------------------+
#ifndef ENABLE_EMULATION
uint16_t (*hid_get_report_cb)(uint8_t, uint8_t, hid_report_type_t, uint8_t *, uint16_t) = NULL;
// Invoked when received GET_REPORT control request
// Application must fill buffer report's content and return its length.
// Return zero will cause the stack to STALL request
uint16_t tud_hid_get_report_cb(uint8_t itf,
uint8_t report_id,
hid_report_type_t report_type,
uint8_t *buffer,
uint16_t reqlen) {
uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t *buffer, uint16_t reqlen) {
// TODO not Implemented
(void) itf;
(void) report_id;
@ -120,7 +116,6 @@ uint16_t tud_hid_get_report_cb(uint8_t itf,
}
return reqlen;
}
#endif
uint32_t hid_write_offset(uint16_t size, uint16_t offset) {
if (hid_tx[ITF_HID_CTAP].buffer[offset] != 0x81) {
@ -201,45 +196,6 @@ static void send_hid_report(uint8_t report_id) {
default: break;
}
}
void hid_task() {
int proc_pkt = 0;
if (hid_rx[ITF_HID_CTAP].w_ptr - hid_rx[ITF_HID_CTAP].r_ptr >= 64) {
//proc_pkt = driver_process_usb_packet_hid(64);
}
if (proc_pkt == 0) {
driver_process_usb_nopacket_hid();
}
int status = card_status(ITF_HID);
if (status == CCID_OK) {
driver_exec_finished_hid(finished_data_size);
}
else if (status == CCID_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) {
if (driver_write_hid(ITF_HID_CTAP, hid_tx[ITF_HID_CTAP].buffer + hid_tx[ITF_HID_CTAP].r_ptr, 64) > 0) {
}
}
/* Keyboard ITF */
// Poll every 10ms
const uint32_t interval_ms = 10;
static uint32_t start_ms = 0;
if (board_millis() - start_ms < interval_ms) {
return;
}
start_ms += interval_ms;
// Remote wakeup
if (tud_suspended() && keyboard_buffer_len > 0) {
tud_remote_wakeup();
}
else {
send_hid_report(REPORT_ID_KEYBOARD);
}
}
#endif
void tud_hid_report_complete_cb(uint8_t instance, uint8_t const *report, uint16_t len) {
@ -284,7 +240,6 @@ void tud_hid_report_complete_cb(uint8_t instance, uint8_t const *report, uint16_
}
}
#ifndef ENABLE_EMULATION
int driver_write_hid(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size) {
if (last_write_result[itf] == WRITE_PENDING) {
return 0;
@ -294,11 +249,11 @@ int driver_write_hid(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size) {
if (last_write_result[itf] == WRITE_FAILED) {
return 0;
}
#ifdef ENABLE_EMULATION
tud_hid_report_complete_cb(ITF_HID, buffer, buffer_size);
#endif
return MIN(64, buffer_size);
}
#endif
#ifndef ENABLE_EMULATION
int (*hid_set_report_cb)(uint8_t, uint8_t, hid_report_type_t, uint8_t const *, uint16_t) = NULL;
// Invoked when received SET_REPORT control request or
@ -320,7 +275,6 @@ void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t rep
}
}
}
#endif
uint32_t last_cmd_time = 0, last_packet_time = 0;
int ctap_error(uint8_t error) {
@ -523,9 +477,7 @@ int driver_process_usb_packet_hid(uint16_t read) {
else {
select_app(u2f_aid + 1, u2f_aid[0]);
}
//if (thread_type != 1)
#ifndef ENABLE_EMULATION
#endif
thread_type = 1;
if (msg_packet.current_len == msg_packet.len && msg_packet.len > 0) {
@ -571,6 +523,7 @@ int driver_process_usb_packet_hid(uint16_t read) {
// echo back anything we received from host
//tud_hid_report(0, buffer, bufsize);
//printf("END\n");
#ifndef ENABLE_EMULATION
if (apdu_sent > 0) {
if (apdu_sent == 1) {
card_start(ITF_HID, apdu_thread);
@ -580,6 +533,7 @@ int driver_process_usb_packet_hid(uint16_t read) {
}
usb_send_event(EV_CMD_AVAILABLE);
}
#endif
}
return apdu_sent;
}
@ -625,3 +579,50 @@ void driver_exec_finished_cont_hid(uint8_t itf, uint16_t size_next, uint16_t off
//send_buffer_size[ITF_HID_CTAP] -= MIN(64 - 7, send_buffer_size[ITF_HID_CTAP]);
}
}
void hid_task() {
#ifdef ENABLE_EMULATION
uint16_t rx_len = emul_read(ITF_HID);
if (rx_len) {
tud_hid_set_report_cb(ITF_HID, 0, 0, emul_rx, rx_len);
}
#else
int proc_pkt = 0;
if (hid_rx[ITF_HID_CTAP].w_ptr - hid_rx[ITF_HID_CTAP].r_ptr >= 64) {
//proc_pkt = driver_process_usb_packet_hid(64);
}
if (proc_pkt == 0) {
driver_process_usb_nopacket_hid();
}
int status = card_status(ITF_HID);
if (status == CCID_OK) {
driver_exec_finished_hid(finished_data_size);
}
else if (status == CCID_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) {
if (driver_write_hid(ITF_HID_CTAP, hid_tx[ITF_HID_CTAP].buffer + hid_tx[ITF_HID_CTAP].r_ptr, 64) > 0) {
}
}
/* Keyboard ITF */
// Poll every 10ms
const uint32_t interval_ms = 10;
static uint32_t start_ms = 0;
if (board_millis() - start_ms < interval_ms) {
return;
}
start_ms += interval_ms;
// Remote wakeup
if (tud_suspended() && keyboard_buffer_len > 0) {
tud_remote_wakeup();
}
else {
send_hid_report(REPORT_ID_KEYBOARD);
}
#endif
}

1
src/usb/usb.h
View file

@ -113,6 +113,7 @@ extern void driver_exec_finished_cont_emul(uint8_t itf, uint16_t size_next, uint
#endif
#define USB_BUFFER_SIZE 2048 // Size of USB buffer"
PACK(
typedef struct {
uint8_t buffer[USB_BUFFER_SIZE];