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

Moving from U2F to CTAP1.

Browse Source 
Signed-off-by: Pol Henarejos <pol.henarejos@cttc.es>
This commit is contained in:
Pol Henarejos
2022-09-08 17:35:40 +02:00
parent 7491021102
commit 867d4637ee
4 changed files with 127 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/usb/ccid/usb_descriptors.c
View File

@@ -183,7 +183,7 @@ char const* string_desc_arr [] =
{ {
(const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409) (const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409)
"Pol Henarejos", // 1: Manufacturer "Pol Henarejos", // 1: Manufacturer
"Pico HSM", // 2: Product "Pico HSM CCID", // 2: Product
"11223344", // 3: Serials, should use chip ID "11223344", // 3: Serials, should use chip ID
"Pico HSM Config", // 4: Vendor Interface "Pico HSM Config", // 4: Vendor Interface
"Pico HSM Interface" "Pico HSM Interface"

66
src/usb/hid/u2f_hid.h → src/usb/hid/ctap_hid.h
View File

@@ -1,9 +1,22 @@
// Common U2F HID transport header - Review Draft /*
// 2014-10-08 * This file is part of the Pico HSM SDK distribution (https://github.com/polhenarejos/pico-hsm-sdk).
// Editor: Jakob Ehrensvard, Yubico, jakob@yubico.com * Copyright (c) 2022 Pol Henarejos.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __U2FHID_H_INCLUDED__ #ifndef _CTAP_HID_H_
#define __U2FHID_H_INCLUDED__ #define _CTAP_HID_H_
#ifdef _MSC_VER // Windows #ifdef _MSC_VER // Windows
typedef unsigned char uint8_t; typedef unsigned char uint8_t;
@@ -45,7 +58,7 @@ typedef struct {
uint8_t data[HID_RPT_SIZE - 5]; // Data payload uint8_t data[HID_RPT_SIZE - 5]; // Data payload
} cont; } cont;
}; };
}__packed U2FHID_FRAME; }__packed CTAPHID_FRAME;
#define FRAME_TYPE(f) ((f)->type & TYPE_MASK) #define FRAME_TYPE(f) ((f)->type & TYPE_MASK)
#define FRAME_CMD(f) ((f)->init.cmd & ~TYPE_MASK) #define FRAME_CMD(f) ((f)->init.cmd & ~TYPE_MASK)
@@ -55,36 +68,36 @@ typedef struct {
// HID usage- and usage-page definitions // HID usage- and usage-page definitions
#define FIDO_USAGE_PAGE 0xf1d0 // FIDO alliance HID usage page #define FIDO_USAGE_PAGE 0xf1d0 // FIDO alliance HID usage page
#define FIDO_USAGE_U2FHID 0x01 // U2FHID usage for top-level collection #define FIDO_USAGE_CTAPHID 0x01 // CTAPHID usage for top-level collection
#define FIDO_USAGE_DATA_IN 0x20 // Raw IN data report #define FIDO_USAGE_DATA_IN 0x20 // Raw IN data report
#define FIDO_USAGE_DATA_OUT 0x21 // Raw OUT data report #define FIDO_USAGE_DATA_OUT 0x21 // Raw OUT data report
// General constants // General constants
#define U2FHID_IF_VERSION 2 // Current interface implementation version #define CTAPHID_IF_VERSION 2 // Current interface implementation version
#define U2FHID_TRANS_TIMEOUT 3000 // Default message timeout in ms #define CTAPHID_TRANS_TIMEOUT 3000 // Default message timeout in ms
// U2FHID native commands // CTAPHID native commands
#define U2FHID_PING (TYPE_INIT | 0x01) // Echo data through local processor only #define CTAPHID_PING (TYPE_INIT | 0x01) // Echo data through local processor only
#define U2FHID_MSG (TYPE_INIT | 0x03) // Send U2F message frame #define CTAPHID_MSG (TYPE_INIT | 0x03) // Send CTAP message frame
#define U2FHID_LOCK (TYPE_INIT | 0x04) // Send lock channel command #define CTAPHID_LOCK (TYPE_INIT | 0x04) // Send lock channel command
#define U2FHID_INIT (TYPE_INIT | 0x06) // Channel initialization #define CTAPHID_INIT (TYPE_INIT | 0x06) // Channel initialization
#define U2FHID_WINK (TYPE_INIT | 0x08) // Send device identification wink #define CTAPHID_WINK (TYPE_INIT | 0x08) // Send device identification wink
#define U2FHID_SYNC (TYPE_INIT | 0x3c) // Protocol resync command #define CTAPHID_SYNC (TYPE_INIT | 0x3c) // Protocol resync command
#define U2FHID_ERROR (TYPE_INIT | 0x3f) // Error response #define CTAPHID_ERROR (TYPE_INIT | 0x3f) // Error response
#define U2FHID_VENDOR_FIRST (TYPE_INIT | 0x40) // First vendor defined command #define CTAPHID_VENDOR_FIRST (TYPE_INIT | 0x40) // First vendor defined command
#define U2FHID_VENDOR_LAST (TYPE_INIT | 0x7f) // Last vendor defined command #define CTAPHID_VENDOR_LAST (TYPE_INIT | 0x7f) // Last vendor defined command
// U2FHID_INIT command defines // CTAPHID_INIT command defines
#define INIT_NONCE_SIZE 8 // Size of channel initialization challenge #define INIT_NONCE_SIZE 8 // Size of channel initialization challenge
#define CAPFLAG_WINK 0x01 // Device supports WINK command #define CAPFLAG_WINK 0x01 // Device supports WINK command
typedef struct { typedef struct {
uint8_t nonce[INIT_NONCE_SIZE]; // Client application nonce uint8_t nonce[INIT_NONCE_SIZE]; // Client application nonce
}__packed U2FHID_INIT_REQ; }__packed CTAPHID_INIT_REQ;
typedef struct { typedef struct {
uint8_t nonce[INIT_NONCE_SIZE]; // Client application nonce uint8_t nonce[INIT_NONCE_SIZE]; // Client application nonce
@@ -94,17 +107,17 @@ typedef struct {
uint8_t versionMinor; // Minor version number uint8_t versionMinor; // Minor version number
uint8_t versionBuild; // Build version number uint8_t versionBuild; // Build version number
uint8_t capFlags; // Capabilities flags uint8_t capFlags; // Capabilities flags
}__packed U2FHID_INIT_RESP; }__packed CTAPHID_INIT_RESP;
// U2FHID_SYNC command defines // CTAPHID_SYNC command defines
typedef struct { typedef struct {
uint8_t nonce; // Client application nonce uint8_t nonce; // Client application nonce
} U2FHID_SYNC_REQ; } CTAPHID_SYNC_REQ;
typedef struct { typedef struct {
uint8_t nonce; // Client application nonce uint8_t nonce; // Client application nonce
} U2FHID_SYNC_RESP; } CTAPHID_SYNC_RESP;
// Low-level error codes. Return as negatives. // Low-level error codes. Return as negatives.
@@ -123,5 +136,4 @@ typedef struct {
} }
#endif #endif
#endif // __U2FHID_H_INCLUDED__ #endif // _CTAP_HID_H_

164
src/usb/hid/hid.c
View File

@@ -16,21 +16,21 @@
*/ */
#include "tusb.h" #include "tusb.h"
#include "u2f_hid.h" #include "ctap_hid.h"
#include "hsm.h" #include "hsm.h"
#include "hsm_version.h" #include "hsm_version.h"
#include "apdu.h" #include "apdu.h"
#include "usb.h" #include "usb.h"
#include "bsp/board.h" #include "bsp/board.h"
#define U2F_MAX_PACKET_SIZE (64 - 7 + 128 * (64 - 5)) #define CTAP_MAX_PACKET_SIZE (64 - 7 + 128 * (64 - 5))
static bool mounted = false; static bool mounted = false;
typedef struct msg_packet { typedef struct msg_packet {
uint16_t len; uint16_t len;
uint16_t current_len; uint16_t current_len;
uint8_t data[U2F_MAX_PACKET_SIZE]; uint8_t data[CTAP_MAX_PACKET_SIZE];
} __packed msg_packet_t; } __packed msg_packet_t;
msg_packet_t msg_packet = { 0 }; msg_packet_t msg_packet = { 0 };
@@ -44,15 +44,15 @@ bool driver_mounted() {
return mounted; return mounted;
} }
U2FHID_FRAME *u2f_req = NULL, *u2f_resp = NULL; CTAPHID_FRAME *ctap_req = NULL, *ctap_resp = NULL;
int driver_init() { int driver_init() {
tud_init(BOARD_TUD_RHPORT); tud_init(BOARD_TUD_RHPORT);
u2f_req = (U2FHID_FRAME *)usb_get_rx(); ctap_req = (CTAPHID_FRAME *)usb_get_rx();
apdu.header = u2f_req->init.data; apdu.header = ctap_req->init.data;
u2f_resp = (U2FHID_FRAME *)usb_get_tx(); ctap_resp = (CTAPHID_FRAME *)usb_get_tx();
apdu.rdata = u2f_resp->init.data; apdu.rdata = ctap_resp->init.data;
return 0; return 0;
} }
@@ -96,11 +96,11 @@ void tud_hid_report_complete_cb(uint8_t instance, uint8_t const* report, /*uint1
uint8_t seq = report[4] & TYPE_MASK ? 0 : report[4]+1; uint8_t seq = report[4] & TYPE_MASK ? 0 : report[4]+1;
if (send_buffer_size > 0) if (send_buffer_size > 0)
{ {
u2f_resp->cid = u2f_req->cid; ctap_resp->cid = ctap_req->cid;
u2f_resp->cont.seq = seq; ctap_resp->cont.seq = seq;
hid_write_offset(64, (uint8_t *)u2f_resp - (usb_get_tx())); hid_write_offset(64, (uint8_t *)ctap_resp - (usb_get_tx()));
send_buffer_size -= MIN(64 - 5, send_buffer_size); send_buffer_size -= MIN(64 - 5, send_buffer_size);
u2f_resp = (U2FHID_FRAME *)((uint8_t *)u2f_resp + 64 - 5); ctap_resp = (CTAPHID_FRAME *)((uint8_t *)ctap_resp + 64 - 5);
} }
} }
@@ -125,13 +125,13 @@ void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t rep
usb_rx(buffer, bufsize); usb_rx(buffer, bufsize);
} }
int u2f_error(uint8_t error) { int ctap_error(uint8_t error) {
u2f_resp = (U2FHID_FRAME *)usb_get_tx(); ctap_resp = (CTAPHID_FRAME *)usb_get_tx();
memset(u2f_resp, 0, sizeof(U2FHID_FRAME)); memset(ctap_resp, 0, sizeof(CTAPHID_FRAME));
u2f_resp->cid = u2f_req->cid; ctap_resp->cid = ctap_req->cid;
u2f_resp->init.cmd = U2FHID_ERROR; ctap_resp->init.cmd = CTAPHID_ERROR;
u2f_resp->init.bcntl = 1; ctap_resp->init.bcntl = 1;
u2f_resp->init.data[0] = error; ctap_resp->init.data[0] = error;
hid_write(64); hid_write(64);
usb_clear_rx(); usb_clear_rx();
return 0; return 0;
@@ -139,7 +139,7 @@ int u2f_error(uint8_t error) {
uint8_t last_cmd = 0; uint8_t last_cmd = 0;
uint8_t last_seq = 0; uint8_t last_seq = 0;
U2FHID_FRAME last_req = { 0 }; CTAPHID_FRAME last_req = { 0 };
uint32_t lock = 0; uint32_t lock = 0;
int driver_process_usb_packet(uint16_t read) { int driver_process_usb_packet(uint16_t read) {
@@ -147,101 +147,101 @@ int driver_process_usb_packet(uint16_t read) {
if (read >= 5) if (read >= 5)
{ {
DEBUG_PAYLOAD(usb_get_rx(),64); DEBUG_PAYLOAD(usb_get_rx(),64);
memset(u2f_resp, 0, sizeof(U2FHID_FRAME)); memset(ctap_resp, 0, sizeof(CTAPHID_FRAME));
if (u2f_req->cid == 0x0 || (u2f_req->cid == CID_BROADCAST && u2f_req->init.cmd != U2FHID_INIT)) if (ctap_req->cid == 0x0 || (ctap_req->cid == CID_BROADCAST && ctap_req->init.cmd != CTAPHID_INIT))
return u2f_error(ERR_SYNC_FAIL); return ctap_error(ERR_SYNC_FAIL);
if (board_millis() < lock && u2f_req->cid != last_req.cid) if (board_millis() < lock && ctap_req->cid != last_req.cid)
return u2f_error(ERR_CHANNEL_BUSY); return ctap_error(ERR_CHANNEL_BUSY);
if (FRAME_TYPE(u2f_req) == TYPE_INIT) if (FRAME_TYPE(ctap_req) == TYPE_INIT)
{ {
if (MSG_LEN(u2f_req) > U2F_MAX_PACKET_SIZE) if (MSG_LEN(ctap_req) > CTAP_MAX_PACKET_SIZE)
return u2f_error(ERR_INVALID_LEN); return ctap_error(ERR_INVALID_LEN);
if (msg_packet.len > 0 && last_req.cid != u2f_req->cid) //We are in a transaction if (msg_packet.len > 0 && last_req.cid != ctap_req->cid) //We are in a transaction
return u2f_error(ERR_CHANNEL_BUSY); return ctap_error(ERR_CHANNEL_BUSY);
printf("command %x\n", FRAME_CMD(u2f_req)); printf("command %x\n", FRAME_CMD(ctap_req));
printf("len %d\n", MSG_LEN(u2f_req)); printf("len %d\n", MSG_LEN(ctap_req));
msg_packet.len = msg_packet.current_len = 0; msg_packet.len = msg_packet.current_len = 0;
if (MSG_LEN(u2f_req) > 64 - 7) if (MSG_LEN(ctap_req) > 64 - 7)
{ {
msg_packet.len = MSG_LEN(u2f_req); msg_packet.len = MSG_LEN(ctap_req);
memcpy(msg_packet.data + msg_packet.current_len, u2f_req->init.data, 64-7); memcpy(msg_packet.data + msg_packet.current_len, ctap_req->init.data, 64-7);
msg_packet.current_len += 64 - 7; msg_packet.current_len += 64 - 7;
} }
memcpy(&last_req, u2f_req, sizeof(U2FHID_FRAME)); memcpy(&last_req, ctap_req, sizeof(CTAPHID_FRAME));
last_cmd = u2f_req->init.cmd; last_cmd = ctap_req->init.cmd;
last_seq = 0; last_seq = 0;
} }
else { else {
if (msg_packet.len == 0) //Received a cont with a prior init pkt if (msg_packet.len == 0) //Received a cont with a prior init pkt
return 0; return 0;
if (last_seq != u2f_req->cont.seq) if (last_seq != ctap_req->cont.seq)
return u2f_error(ERR_INVALID_SEQ); return ctap_error(ERR_INVALID_SEQ);
if (last_req.cid == u2f_req->cid) { if (last_req.cid == ctap_req->cid) {
memcpy(msg_packet.data + msg_packet.current_len, u2f_req->cont.data, MIN(64 - 5, msg_packet.len - msg_packet.current_len)); memcpy(msg_packet.data + msg_packet.current_len, ctap_req->cont.data, MIN(64 - 5, msg_packet.len - msg_packet.current_len));
msg_packet.current_len += MIN(64 - 5, msg_packet.len - msg_packet.current_len); msg_packet.current_len += MIN(64 - 5, msg_packet.len - msg_packet.current_len);
memcpy(&last_req, u2f_req, sizeof(U2FHID_FRAME)); memcpy(&last_req, ctap_req, sizeof(CTAPHID_FRAME));
} }
//else // Received a cont from another channel. Silently discard //else // Received a cont from another channel. Silently discard
last_seq++; last_seq++;
} }
if (u2f_req->init.cmd == U2FHID_INIT) { if (ctap_req->init.cmd == CTAPHID_INIT) {
u2f_resp = (U2FHID_FRAME *)usb_get_tx(); ctap_resp = (CTAPHID_FRAME *)usb_get_tx();
U2FHID_INIT_REQ *req = (U2FHID_INIT_REQ *)u2f_req->init.data; CTAPHID_INIT_REQ *req = (CTAPHID_INIT_REQ *)ctap_req->init.data;
U2FHID_INIT_RESP *resp = (U2FHID_INIT_RESP *)u2f_resp->init.data; CTAPHID_INIT_RESP *resp = (CTAPHID_INIT_RESP *)ctap_resp->init.data;
memcpy(resp->nonce, req->nonce, sizeof(resp->nonce)); memcpy(resp->nonce, req->nonce, sizeof(resp->nonce));
resp->cid = 0x01000000; resp->cid = 0x01000000;
resp->versionInterface = U2FHID_IF_VERSION; resp->versionInterface = CTAPHID_IF_VERSION;
resp->versionMajor = HSM_SDK_VERSION_MAJOR; resp->versionMajor = HSM_SDK_VERSION_MAJOR;
resp->versionMinor = HSM_SDK_VERSION_MINOR; resp->versionMinor = HSM_SDK_VERSION_MINOR;
resp->capFlags = CAPFLAG_WINK; resp->capFlags = CAPFLAG_WINK;
u2f_resp->cid = CID_BROADCAST; ctap_resp->cid = CID_BROADCAST;
u2f_resp->init.cmd = U2FHID_INIT; ctap_resp->init.cmd = CTAPHID_INIT;
u2f_resp->init.bcntl = 17; ctap_resp->init.bcntl = 17;
u2f_resp->init.bcnth = 0; ctap_resp->init.bcnth = 0;
hid_write(64); hid_write(64);
current_app = apps[0].select_aid(&apps[0]); current_app = apps[0].select_aid(&apps[0]);
card_start(); card_start();
DEBUG_PAYLOAD((uint8_t *)u2f_resp, u2f_resp->init.bcntl+7); DEBUG_PAYLOAD((uint8_t *)ctap_resp, ctap_resp->init.bcntl+7);
} }
else if (u2f_req->init.cmd == U2FHID_WINK) { else if (ctap_req->init.cmd == CTAPHID_WINK) {
if (MSG_LEN(u2f_req) != 0) { if (MSG_LEN(ctap_req) != 0) {
return u2f_error(ERR_INVALID_LEN); return ctap_error(ERR_INVALID_LEN);
} }
u2f_resp = (U2FHID_FRAME *)usb_get_tx(); ctap_resp = (CTAPHID_FRAME *)usb_get_tx();
memcpy(u2f_resp, u2f_req, sizeof(U2FHID_FRAME)); memcpy(ctap_resp, ctap_req, sizeof(CTAPHID_FRAME));
sleep_ms(1000); //For blinking the device during 1 seg sleep_ms(1000); //For blinking the device during 1 seg
hid_write(64); hid_write(64);
} }
else if (u2f_req->init.cmd == U2FHID_PING || u2f_req->init.cmd == U2FHID_SYNC) { else if (ctap_req->init.cmd == CTAPHID_PING || ctap_req->init.cmd == CTAPHID_SYNC) {
u2f_resp = (U2FHID_FRAME *)usb_get_tx(); ctap_resp = (CTAPHID_FRAME *)usb_get_tx();
memcpy(u2f_resp, u2f_req, sizeof(U2FHID_FRAME)); memcpy(ctap_resp, ctap_req, sizeof(CTAPHID_FRAME));
hid_write(64); hid_write(64);
} }
else if (u2f_req->init.cmd == U2FHID_LOCK) { else if (ctap_req->init.cmd == CTAPHID_LOCK) {
if (MSG_LEN(u2f_req) != 1) if (MSG_LEN(ctap_req) != 1)
return u2f_error(ERR_INVALID_LEN); return ctap_error(ERR_INVALID_LEN);
if (u2f_req->init.data[0] > 10) if (ctap_req->init.data[0] > 10)
return u2f_error(ERR_INVALID_PAR); return ctap_error(ERR_INVALID_PAR);
lock = board_millis() + u2f_req->init.data[0] * 1000; lock = board_millis() + ctap_req->init.data[0] * 1000;
u2f_resp = (U2FHID_FRAME *)usb_get_tx(); ctap_resp = (CTAPHID_FRAME *)usb_get_tx();
memset(u2f_resp, 0, 64); memset(ctap_resp, 0, 64);
u2f_resp->cid = u2f_req->cid; ctap_resp->cid = ctap_req->cid;
u2f_resp->init.cmd = u2f_req->init.cmd; ctap_resp->init.cmd = ctap_req->init.cmd;
hid_write(64); hid_write(64);
} }
else if ((u2f_req->init.cmd == U2FHID_MSG && msg_packet.len == 0) || (msg_packet.len == msg_packet.current_len && msg_packet.len > 0)) { else if ((ctap_req->init.cmd == CTAPHID_MSG && msg_packet.len == 0) || (msg_packet.len == msg_packet.current_len && msg_packet.len > 0)) {
if (msg_packet.current_len == msg_packet.len && msg_packet.len > 0) if (msg_packet.current_len == msg_packet.len && msg_packet.len > 0)
apdu_sent = apdu_process(msg_packet.data, msg_packet.len); apdu_sent = apdu_process(msg_packet.data, msg_packet.len);
else else
apdu_sent = apdu_process(u2f_req->init.data, MSG_LEN(u2f_req)); apdu_sent = apdu_process(ctap_req->init.data, MSG_LEN(ctap_req));
DEBUG_PAYLOAD(apdu.data, (int)apdu.nc); DEBUG_PAYLOAD(apdu.data, (int)apdu.nc);
msg_packet.len = msg_packet.current_len = 0; //Reset the transaction msg_packet.len = msg_packet.current_len = 0; //Reset the transaction
} }
else { else {
if (msg_packet.len == 0) if (msg_packet.len == 0)
return u2f_error(ERR_INVALID_CMD); return ctap_error(ERR_INVALID_CMD);
} }
// echo back anything we received from host // echo back anything we received from host
//tud_hid_report(0, buffer, bufsize); //tud_hid_report(0, buffer, bufsize);
@@ -256,10 +256,10 @@ void driver_exec_timeout() {
} }
uint8_t *driver_prepare_response() { uint8_t *driver_prepare_response() {
u2f_resp = (U2FHID_FRAME *)usb_get_tx(); ctap_resp = (CTAPHID_FRAME *)usb_get_tx();
apdu.rdata = u2f_resp->init.data; apdu.rdata = ctap_resp->init.data;
memset(usb_get_tx(), 0, 4096); memset(usb_get_tx(), 0, 4096);
return u2f_resp->init.data; return ctap_resp->init.data;
} }
void driver_exec_finished(size_t size_next) { void driver_exec_finished(size_t size_next) {
@@ -268,13 +268,13 @@ void driver_exec_finished(size_t size_next) {
void driver_exec_finished_cont(size_t size_next, size_t offset) { void driver_exec_finished_cont(size_t size_next, size_t offset) {
offset -= 7; offset -= 7;
u2f_resp = (U2FHID_FRAME *)(usb_get_tx() + offset); ctap_resp = (CTAPHID_FRAME *)(usb_get_tx() + offset);
u2f_resp->cid = u2f_req->cid; ctap_resp->cid = ctap_req->cid;
u2f_resp->init.cmd = last_cmd; ctap_resp->init.cmd = last_cmd;
u2f_resp->init.bcnth = size_next >> 8; ctap_resp->init.bcnth = size_next >> 8;
u2f_resp->init.bcntl = size_next & 0xff; ctap_resp->init.bcntl = size_next & 0xff;
hid_write_offset(64, offset); hid_write_offset(64, offset);
u2f_resp = (U2FHID_FRAME *)((uint8_t *)u2f_resp + 64 - 5); ctap_resp = (CTAPHID_FRAME *)((uint8_t *)ctap_resp + 64 - 5);
send_buffer_size = size_next; send_buffer_size = size_next;
send_buffer_size -= MIN(64-7, send_buffer_size); send_buffer_size -= MIN(64-7, send_buffer_size);

10
src/usb/hid/usb_descriptors.c
View File

@@ -24,7 +24,7 @@
*/ */
#include "tusb.h" #include "tusb.h"
#include "u2f_hid.h" #include "ctap_hid.h"
#include "pico/unique_id.h" #include "pico/unique_id.h"
#include "hsm_version.h" #include "hsm_version.h"
@@ -71,9 +71,9 @@ uint8_t const * tud_descriptor_device_cb(void)
// HID Report Descriptor // HID Report Descriptor
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
#define TUD_HID_REPORT_DESC_U2F(report_size, ...) \ #define TUD_HID_REPORT_DESC_CTAP(report_size, ...) \
HID_USAGE_PAGE_N ( FIDO_USAGE_PAGE, 2 ),\ HID_USAGE_PAGE_N ( FIDO_USAGE_PAGE, 2 ),\
HID_USAGE ( FIDO_USAGE_U2FHID ),\ HID_USAGE ( FIDO_USAGE_CTAPHID ),\
HID_COLLECTION ( HID_COLLECTION_APPLICATION ),\ HID_COLLECTION ( HID_COLLECTION_APPLICATION ),\
/* Report ID if any */\ /* Report ID if any */\
__VA_ARGS__ \ __VA_ARGS__ \
@@ -95,7 +95,7 @@ uint8_t const * tud_descriptor_device_cb(void)
uint8_t const desc_hid_report[] = uint8_t const desc_hid_report[] =
{ {
TUD_HID_REPORT_DESC_U2F(CFG_TUD_HID_EP_BUFSIZE) TUD_HID_REPORT_DESC_CTAP(CFG_TUD_HID_EP_BUFSIZE)
}; };
// Invoked when received GET HID REPORT DESCRIPTOR // Invoked when received GET HID REPORT DESCRIPTOR
@@ -148,7 +148,7 @@ char const* string_desc_arr [] =
{ {
(const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409) (const char[]) { 0x09, 0x04 }, // 0: is supported language is English (0x0409)
"Pol Henarejos", // 1: Manufacturer "Pol Henarejos", // 1: Manufacturer
"Pico HSM", // 2: Product "Pico HSM HID", // 2: Product
"123456", // 3: Serials, should use chip ID "123456", // 3: Serials, should use chip ID
}; };