Introdução ao PicoKeys

Sempre use VID/PID da Yubikey

Com o VID/PID configurado para o perfil YubiKey, o PicoKeys (na versão FIDO somente) pode ser reconhecido pelo ykman (YubiKey Manager). É possível consultar as credenciais FIDO2 armazenadas e apagar uma delas pelo identificador:

Terminal

ykman fido credentials list
ykman fido credentials delete <início-do-ID>

Com o ykman, podemos listar e excluir credenciais FIDO2, configurar OTP da Yubikey diretamente no PicoKeys FIDO, gerenciar o PIN entre outras possibilidades. No meu teste, a listagem de credenciais FIDO2 e a exclusão delas funcionaram sem problemas. Outros parâmetros também puderam ser consultados e modificados.

Além disso, foi possível configurar uma credencial Yubico OTP, usando a funcionalidade de slots da YubiKey. Esses slots permitem armazenar configurações de autenticação, como Yubico OTP, HOTP, senhas estáticas e Challenge-Response. Ao pressionar uma única vez, é acionado o slot 1, se forem pressionados duas vezes, é acionado o slot 2.

Minha Recomendação

Minha recomendação

Antes de começar, quero deixar minha recomendação sobre se vale ou não a pena comprar um hardware para usar o firmware do PicoKeys.

A resposta é, depende muito do SEU objetivo.

Eu recomendaria o PicoKeys principalmente se você realmente precisa de uma chave física com suporte a FIDO2 ou um HSM simples para uso pessoal, mas não quer pagar o valor de uma YubiKey 5.

Mas é importante considerar o custo total desse projeto. Para usar o PicoKeys da forma correta, temos que fazer as configurações de segurança recomendadas, e para isso, será necessário comprar a licença do aplicativo oficial, que atualmente custa cerca de 30 euros (aproximadamente R$ 167,32 na cotação usada enquanto escrevo).

Além desse custo, você ainda precisa comprar um dispositivo compatível (como o ESP32-S3), normalmente ele vai custar algo entre R$ 80 e R$ 100, embora esse valor possa variar bastante dependendo da placa, do vendedor, do local da compra e etc.

Caso você não queira pagar o aplicativo, ainda pode fazer tudo manualmente, nesse caso, tem o esforço que vai colocar para configurar e manter a placa atualizada.

Se o objetivo for estudar e entender melhor como funcionam tecnologias como FIDO/FIDO2, HSM e Smart Card, considero o PicoKeys uma opção muito boa, principalmente porque o firmware é aberto. Ele permite testar FIDO, HSM e Smart Card gastando relativamente pouco, se comparado com uma Yubikey.

Agora, se a intenção for usar a chave em um ambiente real, protegendo contas, credenciais ou chaves importantes, minha recomendação muda, você precisa de YubiKey ou alguma outra chave mais séria nesse quesito.

Caso você ainda queira usar o PicoKeys para uso pessoal, é obrigatório a compra do aplicativo oficial (ou fazer toda a proteção manualmente) para que consiga realizar as configurações de segurança disponíveis no projeto.

Introdução ao PicoKeys

O PicoKey é um projeto open source que permite transformar microcontroladores (como alguns modelos baseados em RP2040 e ESP32-S3) em dispositivos de segurança semelhantes a uma chave física de autenticação, como a Yubikey.

Dependendo do firmware que for usado, o dispositivo pode oferecer funções como FIDO2, HSM e OpenPGP & PIV.

A ideia do projeto é disponibilizar uma chave parecida com uma YubiKey, em vez de deixar determinadas credenciais ou chaves privadas armazenadas diretamente no computador, elas podem ficar protegidas dentro do dispositivo físico. A grande diferença é que o PicoKey é um projeto aberto.

Por ser uma solução baseada em hardware genérico e firmware open source, o PicoKey oferece bastante flexibilidade, mas também exige cuidado, diferente de uma YubiKey, onde hardware, o firmware e a cadeia de fabricação são controlados pelo fabricante, no PicoKey, parte da segurança depende também do microcontrolador que for usado, da configuração do firmware e das proteções ativadas no próprio chip.

Compatibilidade com Firefox

Durante os meus testes, o Pico FIDO funcionou corretamente no Google Chrome, incluindo a solicitação do PIN, mas no Firefox, ele não funcionou.

Encontrei relatos anteriores no próprio projeto do Pico FIDO de incompatibilidades específicas com o Firefox no Linux. Segundo os relatos, o Firefox usa a biblioteca authenticator-rs para comunicação CTAP/FIDO, e algumas respostas geradas pelo Pico FIDO já causaram problemas de interpretação nessa implementação.

No entanto, ao compilar manualmente o firmware e mudar o VID/PID para Yubikey, ele passou a funcionar sem problemas no Firefox.

Vale deixar claro que a Yubikey não tem esse problema.

Community vs Enterprise

O PicoKey possui duas formas principais de licenciamento, a Community e a Enterprise. A versão Community é gratuita e distribuída sob a licença AGPLv3, ela é voltada principalmente para uso pessoal, estudos, laboratórios, testes e desenvolvimento de protótipos.

Nós podemos baixar o firmware, estudar o código-fonte, modificar e usar normalmente. Porém, nem tudo são flores, por causa da licença AGPLv3, existem algumas obrigações caso o firmware seja modificado e redistribuído ou usado como parte de determinados serviços de rede.

A versão Enterprise usa uma licença comercial proprietária e é voltada para ambientes de produção, empresas, fabricantes e implantações com vários usuários ou dispositivos. Além da diferença de licença, clientes Enterprise podem receber recursos adicionais.

Para usar um PicoKey pessoalmente como FIDO2, HSM ou OpenPGP, normalmente a versão Community é suficiente.

Picokey App

O PicoKey App é o aplicativo oficial usado para configurar, gerenciar e atualizar dispositivos do ecossistema PicoKeys, incluindo Pico FIDO, Pico HSM e Pico OpenPGP. É com ele que podemos visualizar informações do dispositivo, atualizar o firmware, configurar parâmetros específicos da placa, gerenciar credenciais e habilitar recursos de segurança como Secure Boot e Secure Lock.

O aplicativo também é responsável pelo processo chamado de commissioning, que basicamente adapta uma imagem genérica do firmware para o hardware específico onde ela está sendo executada. Isso é necessário porque o mesmo firmware pode funcionar em diversas placas diferentes, mas algumas características dependem do hardware usado, como:

GPIO usado pelo botão;
LED e comportamento dos indicadores;
identificação da placa;
VID/PID USB;
parâmetros específicos do dispositivo;
algumas configurações de segurança.

A documentação explica que essas informações não podem ser definidas de forma genérica durante a compilação do firmware e precisam ser configuradas posteriormente no dispositivo.

Dentre as funções do PicoKey App, temos:

atualizar o firmware;
configurar VID/PID;
configurar LED e botão;
gerenciar Passkeys;
gerenciar OATH e slots OTP;
gerenciar chaves do Pico HSM;
configurar PIN e SO-PIN;
configurar Secure Boot;
configurar Secure Lock;
realizar factory reset;
gerenciar algumas funções do OpenPGP e PIV.

O PicoKey App não é open source

Embora os firmwares do PicoKeys continuem sendo projetos abertos, o PicoKey App é proprietário e seu código-fonte não é disponibilizado publicamente.

Além disso, o aplicativo requer uma licença paga por dispositivo. Atualmente existem duas licenças:

1 dispositivo: €29,49;
2 dispositivos: €49,49.

A boa noticia é que as licenças são vitalícias.

O firmware em si funciona independente do aplicativo, já que as funcionalidades criptográficas são fornecidas pelo firmware e não pelo PicoKey App. Mesmo sem o App, vamos poder usar o FIDO2, WebAuthn, PIC, OpenPGP, HSM, SSH e etc.

Como a vida nem sempre é um morango, o problema aparece na configuração inicial e no gerenciamento de algumas características específicas do hardware. Nas versões mais novas, o App passou a ser usado para realizar o commissioning (como mencionado acima) e configurar parâmetros específicos da placa.

Portanto, para um uso normal do PicoKey em ambiente de laboratório ou uso pessoal mais simples, não vai precisar tanto do App. Ainda existe uma alternativa para usuários mais "avançados", o firmware pode ser compilado manualmente, junto com os parâmetros específicos da placa que vai usar.

O próprio desenvolvedor confirmou que é possível configurar o PicoKey sem o aplicativo. Isso significa que o PicoKey App não é tecnicamente obrigatório para o funcionamento do PicoKey, mas perdemos bastante dos bons recursos dele, como atualização de firmware e ativação do Secure Boot e/ou Secure Lock.

Gravando o Firmware

O firmware do PicoKeys pode ser instalado usando alguns métodos diferentes, tudo depende do controlador. O mais simples é usar uma imagem pronta, que é fornecida pelo projeto e realizar a gravação diretamente pelo navegador ou compilar o firmware manualmente.

Mais acima, quando falei sobre o App, falei um pouco sobre o commissioning, mas vale deixar claro que instalar o firmware e realizar o commissioning são coisas diferentes. Quando instalamos o firmware, estamos gravando o Pico FIDO, Pico HSM ou Pico OpenPGP no controlador.

Já o commissioning é usado para configurar/personalizar as características do dispositivo, como: VID/PID, identificação USB, LED/botão, algumas opções de segurança e outras configurações específicas do controlador usado

Gravando pelo navegador - ESP32-S2/S3

As placas baseadas em ESP32-S2 ou ESP32-S3 podem receber o firmware direto pelo navegador. Nesse método não precisamos instalar esptool, ESP-IDF ou baixar a imagem manualmente. O navegador vai se comunicar diretamente com o bootloader do ESP32 e gravar o firmware escolhido.

Para colocar um ESP32-S3 no modo de gravação, podemos fazer assim:

Segure o bortão BOOT;
Pressione o botão RESET;
Solte o botão RESET;
Solte o botão BOOT;

Depois basta acessar o ESP32 Flasher, selecionar o firmware desejado e e clicar em Connect.

DFU ou ROM Download Mode?

A documentação do PicoKeys chama esse processo de DFU Mode, porém, o termo usado pela fabricante do ESP32 (Espressif) é ROM Download Mode.

Esse método funciona porque o ESP32 possui um bootloader gravado em ROM pelo próprio fabricante. Então, ao usar a combinação de BOOT + RESET, o microcontrolador inicia nesse bootloader e fica aguardando a gravação de um novo firmware. Quando você grava, o firmware é escrito na flash e o ROM inicia esse firmware.

Depois da gravação, o ESP32 reinicia executando o firmware do PicoKeys.

VID/PID

A instalação do firmware como foi explicada acima usa os parâmetros fornecidos pela imagem disponibilizada pelo projeto. No entanto, esses identificadores podem não ser reconhecidos por algumas ferramentas de terceiros. O próprio ESP32 Flasher recomenda configurar o VID/PID para melhorar a compatibilidade com ferramentas como OpenSC, PKCS#11, ykman, gpg e outras.

O VID (Vendor ID) identifica o fabricante do dispositivo USB, enquanto o PID (Product ID) identifica um produto associado àquele fabricante. Alguns aplicativos usam esses identificadores para localizar dispositivos compatíveis, enquanto outros conseguem identificá-los diretamente pelos protocolos que implementam.

Isso significa que alterar o VID/PID não é obrigatório para usar todas as funcionalidades do firmware, mas pode ser necessário para que determinadas ferramentas reconheçam o dispositivo. Por exemplo, o Pico FIDO usa HID, uma interface USB normalmente suportada pelos sistemas operacionais e navegadores. Dessa forma, o dispositivo pode funcionar como autenticador FIDO2/WebAuthn sem depender do PicoKey App ou de um VID/PID específico de outro fabricante.

Já o Pico HSM usa CCID, que é uma interface para comunicação com dispositivos do tipo smart card. Nesse caso, o reconhecimento pode depender dos identificadores aceitos pelo driver ou pela aplicação usada.

A documentação oficial mostra algumas maneiras de alterar os identificadores USB, sem depender do PicoKey App, que é o método mais fácil de alterar os identificadores, mas eu nunca usei ele.

PicoKey App

O PicoKey App permite selecionar identificadores predefinidos ou informar manualmente um VID/PID. As configurações são aplicadas durante o processo de commissioning, sem necessidade de recompilar o firmware. No entanto, como já vimos, esse procedimento exige pagar pelo aplicativo.

Pico Patcher

Eles também disponibilizam o Pico Patcher, uma ferramenta gratuita que permite alterar os identificadores diretamente pelo navegador, mas só funciona para placas raspberry pi. O procedimento é o seguinte:

Acessar a página do Pico Patcher.
Selecionar um arquivo de firmware no formato .uf2.
Escolher um dos fabricantes disponíveis ou informar um VID/PID personalizado.
Clicar em Patch para gerar uma nova imagem do firmware.
Gravar a imagem modificada no dispositivo.

Entre os presets disponíveis estão YubiKey, Nitrokey, GnuPG e FSIJ. Todo o processamento ocorre localmente no navegador, sem que o firmware modificado seja enviado aos servidores do projeto.

Alteração dinâmica pelo Pico HSM

O Pico HSM também oferece uma alternativa por linha de comando, que usa a ferramenta pico-hsm-tool.py. Segundo a documentação oficial, é possível alterar dinamicamente o VID/PID com o comando:

Terminal

./pico-hsm-tool.py phy vidpid 1234:5678

Os valores 1234:5678 são apenas exemplos e devem ser substituídos pelos identificadores desejados. Após executar o comando com sucesso, é necessário reiniciar o dispositivo para que os novos identificadores sejam usados. Esse método permite modificar o VID/PID sem gerar uma nova imagem de firmware.

Compilação manual

Outra método é configurar os identificadores USB diretamente no código-fonte ou nos parâmetros de compilação do firmware. Os repositórios do Pico HSM e Pico FIDO documentam opções como USB_VID, USB_PID e VIDPID para compilação destinada às placas Raspberry Pi Pico.

No ESP32-S3, é necessário usar -DVIDPID=XXX para especificar qual perfil vamos aplicar. Na tabela abaixo eu vou deixar os nomes de cada perfil que podem ser usados.

Grupo	Perfil	VID:PID
HSM	`NitroHSM`	`20A0:4230`
HSM	`YubiHSM`	`1050:0030`
FIDO	`NitroFIDO2`	`20A0:42B1`
FIDO	`Nitro3`	`20A0:42B2`
FIDO	`Yubikey5`	`1050:0407`
FIDO	`YubikeyNeo`	`1050:0116`
PGP/OpenPGP	`NitroStart`	`20A0:4211`
PGP/OpenPGP	`NitroPro`	`20A0:4108`
PGP/OpenPGP	`Gnuk`	`234B:0000`
PGP/OpenPGP	`GnuPG`	`1209:2440`

Usando um ESP32-S3

Eu comprei um XIAO ESP32-S3 porque ele é recomendado pelo próprio projeto do PicoKeys, principalmente pelo requesito de segurança. A grande vantagem dessa placa é que ela possui recursos de segurança implementados diretamente no hardware, o que melhora a proteção tanto do firmware quanto das chaves armazenadas nele.

Um dos principais recursos é o Secure Boot v2, ele serve para verificar criptograficamente o bootloader e o firmware antes de executar eles, ou seja, depois configurado, um atacante não pode simplesmente gravar um firmware modificado no dispositivo para tentar extrair as chaves da placa. Somente um firmware assinado por uma chave autorizada será executado.

Cuidado com Secure Boot

Mas muita atenção com uso do Secure Boot v2, quando ele for habilitado pelo PicoKeys, apenas firmware do PicoKeys que tenha uma assinatura válida reconhecida pelo dispositivo poderá ser executado.

Isso significa que sua placa passa a funcionar apenas com firmwares assinados pelo PicoKeys e não funciona com outros firmwares, mesmo um reset não vai funcionar para instalar novos firmwares.

Isso ocorre porque o Secure Boot grava no eFuse a referência da chave pública que ele vai passar a aceitar. Então, qualquer novo bootloader ou firmware precisa estar assinado por uma chave correspondente àquela referência. Se você gravar um firmware qualquer sem estar assinado pela chave privada (correspondente a chave pública no eFuse), o ESP32-S3 vai se recusar a executar esse firmware.

Então só habilite Secure Boot quando tiver certeza que a placa não vai mais ser usada para nenhum outra finalidade.

Outro recurso importante dessa placa é o Flash Encryption. Ele tem dois modos de operação, na configuração padrão, o ESP32-S3 gera uma chave XTS-AES na primeira inicialização e a armazena nos eFuses (esse modo é conhecido como Development), protegida contra leitura. O problema é que, no modo Release, é necessário usar um método diferente para gravar novos firmwares: eles precisam ser assinados e depois criptografados com a chave da placa antes da gravação.

Também é possível gerar a chave usada para Flash Encryption no computador, ai podemos gravar ela nos eFuses antes de ativar a criptografia e manter ela no computador para preparar os firmwares antes de gravar eles (esse modo é conhecido como Release). O bom desse modo é que podemos continuar gravando os firmware usando o ROM Download Mode, mas é preciso enviar a imagem já criptografada, para isso é preciso usar --no-stub no Secure Download Mode.

Como o Secure Boot também usa os eFuses, vale deixar claro que ele usa uma área diferente daquela usada pelo Flash Encryption. No Secure Boot, os eFuses guardam uma referência da chave usada para verificar se o firmware está assinado. Já no Flash Encryption, é armazenado a chave usada para criptografar os dados da memória flash.

Quando o PicoKey usa uma área de eFuse para armazenar dados criptográficos, essa área é protegida contra escrita. Isso impede que o conteúdo seja alterado. Além disso, os eFuses são permanentes, ou seja, depois de gravados, os dados não podem simplesmente ser apagados ou restaurados como acontece com uma memória flash.

Outro recurso muito bom é o Secure Lock. Ele grava bloqueios permanentes nas eFuses para impedir alterações em determinadas configurações de segurança. Em teoria quem faz isso é ele, mas nos meus testes, várias proteções foram aplicadas simplesmente por ativar Secure Boot, muitas delas que estão ligadas ao Secure Lock. O JTAG é um exemplo de recurso que foi permanentemente desativado, e o ROM Download está em Secure Download Mode, que limita os comandos disponíveis. Portanto, mesmo sem aplicar o Secure Lock, essas proteções ficam ativas ao habilitar o secure boot. Existem coisas a mais que o Secure Lock faz, mas acho que essas proteções a mais dele fica como um recurso desejável, mas não invalida o uso sem eles.

O ESP32-S3 também possui aceleradores criptográficos em hardware para AES e SHA, além dos periféricos HMAC, RSA Digital Signature (RSA_DS) e RNG. O periférico HMAC pode usar uma chave armazenada nos eFuses sem deixar ela acessível ao software. O RSA_DS também pode usar o HMAC para proteger os parâmetros de uma chave privada RSA e realizar assinaturas sem expor a chave ao firmware.

No Pico HSM, o SDK também ativa a fonte interna de entropia do SAR ADC e usa o RNG de hardware para obter dados aleatórios. O ruído físico do chip é misturado ao RNG, ajudando na geração de chaves e de outros valores aleatórios. Essa fonte é interna do ESP32-S3, ou seja, não é necessário conectar uma antena ou outro componente.

Com essa fonte de entropia ativa, o RNG de hardware do ESP32-S3 usa o ruído físico do SAR ADC para gerar números verdadeiramente aleatórios, em vez de depender apenas de uma sequência pseudoaleatória. O SAR ADC (significa Successive Approximation Register Analog-to-Digital Converter) é um conversor que mede uma tensão analógica e a transforma em um valor digital. No ESP32-S3, o ruído elétrico natural do chip altera ligeiramente essas medições. Com a fonte de entropia ativada, o RNG de hardware aproveita e mistura essas variações para produzir números aleatórios. O ADC não gera os números sozinho, ele fornece uma fonte física de entropia para o RNG.

Isso foi o que eu entendi sobre esse SAR ADC, mas devo deixar claro que foge da minha área de estudo, então estou repassando o que entendi 😅.

cuidado com Secure Boot

Eu já avisei sobre o cuidado que temos que ter em ativar o Secure Boot, mas é bom reforçar sempre, depois de ativado, o Secure Boot não poderá ser desativado.

A partir do momento em que essa proteção for habilitada pelo firmware do PicoKeys, a placa somente vai aceitar os firmwares do PicoKeys ou firmwares que você mesmo assinar (caso tenho feito a compilação manual). No caso do uso do App, tenha certeza de que você não pretende reusar essa placa posteriormente para outros projetos ou firmwares, porque não será possível.

Microcontrolador não é um Secure Element

É importante que eu deixe bem claro que, por mais que o projeto seja interessante e funcional, e mesmo que ele possua uma versão Enterprise, e que o ESP32-S3 possua diversos recursos de segurança, isso não torna o ele equivalente a uma YubiKey ou a um HSM corporativo certificado.

O ESP32-S3 é um microcontrolador criado para ser usado em diversas projetos, ou seja, ele foi criado para ser usado em uma ampla gama de projetos, desde os mais simples até alguns mais avançados. Mas isso não torna o ESP32-S3 um Secure Element, ele não foi desenvolvido especificamente para resistir a ataques físicos avançados, assim como uma Yubikey.

Esse detalhe é inclusive descrito na documentação do projeto PicoKeys. Ataques como decapping, microprobing, fault injection avançado e outras formas de análise física de laboratório estão fora do modelo de ameaça considerado pelo projeto.

Gravando FIDO2 via navegador

Eu vou fazer tudo de forma online, usando as ferramentas disponibilizadas via Browser, o projeto oficial recomenda usar o ESP32 Flasher online. O instalador oficial está disponível em na url: https://www.picokeys.com/esp32-flasher/.

note

Faça todo o processo pelo Google Chrome ou se quiser usar o firefox, que não seja a versão de Snap.

Antes iniciar a gravação do firmware, precisamos colocar o XIAO ESP32-S3 no modo de boot usado para programação. O PicoKeys chama esse modo de DFU Mode. Com a placa conectada ao computador vamos fazer o seguinte:

Mantenha pressionado o botão BOOT (B);
Pressione e solte o botão RESET (R);
Solte o botão BOOT (B).

A placa vai entrar num modo de "aguardando gravação". Com o ESP32-S3 em DFU Mode, acesse o instalador oficial está disponível em na url: https://www.picokeys.com/esp32-flasher/.

Selecione Pico Fido;
Clique em Connect;
Selecione o dispositivo correspondente ao ESP32-S3;
Confirme a conexão;
Inicie a gravação;
Aguarde o processo terminar completamente antes de desconectar a placa.

O próprio site baixa e grava o firmware necessário no ESP32-S3. Depois da gravação, desconecte e reconecte a placa, ela vai subir já com o Pico FIDO.

Agora vamos verificar se o Linux reconhece especificamente a interface FIDO2.

Terminal

# Vamos instalar as ferramentas:
sudo apt update && sudo apt install -y fido2-tools

# Liste os dispositivos:
$ fido2-token -L
/dev/hidraw17: vendor=0x2e8a, product=0x10fe (Pol Henarejos Pico Key)

# Liste as capacidades do nosso fido:
$ fido2-token -I /dev/hidraw17
proto: 0x02
major: 0x08
minor: 0x00
build: 0x00
caps: 0x05 (wink, cbor, msg)
version strings: U2F_V2, FIDO_2_0, FIDO_2_1, FIDO_2_2, FIDO_2_3
extension strings: uvm, credBlob, credProtect, hmac-secret, largeBlobKey, minPinLength, hmac-secret-mc, thirdPartyPayment
algorithms: es256 (public-key), es384 (public-key), unknown (public-key)
aaguid: 89fb94b706c936739b7e30526d968145
options: rk, noalwaysUv, credMgmt, authnrCfg, noclientPin, largeBlobs, perCredMgmtRO, pinUvAuthToken, setMinPINLength, nomakeCredUvNotRqd
fwversion: 0x800
maxmsgsiz: 1024
maxcredcntlst: 16
maxcredlen: 1024
maxlargeblob: 2048
maxrpids in minpinlen: 120
minpinlen: 4
pin protocols: 1, 2
pin retries: 8
pin change required: false
uv retries: undefined

Configurando um PIN

Já falamos sobre o PIN quando expliquei sobre a YubiKey, mais especificamente quando falei sobre autenticação FIDO, ela pode exigir apenas a presença física da chave e um toque, ou a presença da chave mais uma verificação adicional do usuário, como PIN ou biometria.

Ele serve basicamente para confirmar que quem está usando a chave física está autorizado a acessar determinadas funções, como passkeys armazenadas no dispositivo e operações de gerenciamento.

O uso do PIN é opcional para algumas operações, então podemos usar o Pico FIDO sem ele. No entanto, alguns serviços e recursos podem exigir verificação do usuário, tornando o PIN necessário.

Para configurar um PIN, podemos usar o fido2-token:

Terminal

fido2-token -S /dev/hidraw17

Outra forma de configurar o PIN é usando o PicoKey App. O App permite definir o PIN e também ajustar políticas relacionadas a ele, como tamanho mínimo e complexidade.

Para alterar o PIN:

Terminal

fido2-token -C /dev/hidraw17

Para remover o PIN, é necessário fazer um reset do autenticador. Mas tenha cuidado, o reset não apaga somente o PIN. Ele também apaga as credenciais/passkeys armazenadas no dispositivo e restaura o estado FIDO.

Terminal

fido2-token -R /dev/hidraw17

Listar e Deletar Passakeys configuradas

Nós podemos listar as passkeys residentes na chave, mas apenas as que são discoverable e também podemos apagar elas individualmente usando o comando fido2-token. Uma discoverable credential é uma credencial FIDO2 que fica armazenada na chave física e pode ser encontrada por ele sem o site precisar dizer previamente qual credencial usar. Isso é o que permite cenários de passkey/passwordless, em que você pode entrar sem digitar username e senha antes.

Já uma non-discoverable credential funciona de forma diferente, a chave privada também é protegida dentro da chave física, mas a chave física não mantém uma entrada pesquisável daquele login. Nesse cenário, o servidor precisa mandar um Credential ID dizendo qual credencial deve ser usada.

Uma passkey discoverable precisa manter dentro do autenticador um registro persistente com dados suficientes para encontrar aquela conta depois, o problema é que isso consome armazenamento interno da chave, por isso é sempre bom apagar uma que não esteja mais em uso.

Já uma non-discoverable credential normalmente consome muito menos ou quase nada de espaço na chave. Isso acontece porque o servidor quem guarda o Credential ID e o envia de volta no login, a chave deriva ou recupera o material necessário a partir desse identificador, sem precisar manter uma entrada para cada site.

Bug para deletar Passkeys

Existe um bug para deletar as passkeys residentes na chave e atualmente em 06/10/2026 ele ainda continua. Aparentemente é um bug relacionado ao fido2-token/libfido2, mas usando a biblioteca fido2 do Python podemos deletar tranquilamente, vou deixar o código que usei ao final dessa seção.

Terminal

# Vamos ver qual é o /dev/hidrawX da chave:
$ fido2-token -L
/dev/hidraw3: vendor=0x2e8a, product=0x10fe (Pol Henarejos Pico Key)

# Liste as passakeys discoverable cadastradas:
$ sudo fido2-token -L -r /dev/hidraw3
Enter PIN for /dev/hidraw3: 
00: asdasdasdasdafU3lMtcdsffdsdHLsdfsffsOOgd459= teste.com

# Para apagar, deveria ser assim:
$ sudo fido2-token -D -i 'asdasdasdasdafU3lMtcdsffdsdHLsdfsffsOOgd459=' /dev/hidraw3

Script python para fido2

#!/usr/bin/env python3

import getpass
import sys

from fido2.hid import CtapHidDevice
from fido2.ctap2 import Ctap2, ClientPin, CredentialManagement


devices = list(CtapHidDevice.list_devices())

if not devices:
    print("Nenhum dispositivo FIDO encontrado.")
    sys.exit(1)

print("Dispositivos encontrados:", '\n')

for i, dev in enumerate(devices):
    print(f"\t[{i}] {dev}")

idx = int(input("\nEntre com o ID do dispositivo: "))

dev = devices[idx]
ctap = Ctap2(dev)

#print("\nVersões suportadas do CTAP:", ctap.info.versions)
#print("Opções:", ctap.info.options)

pin = getpass.getpass("\nDigite o PIN do FIDO: ")

client_pin = ClientPin(ctap)

token = client_pin.get_pin_token(
    pin,
    permissions=ClientPin.PERMISSION.CREDENTIAL_MGMT,
)

credman = CredentialManagement(
    ctap,
    client_pin.protocol,
    token,
)

print("\nCredenciais discoverable:\n")

all_credentials = []

for rp in credman.enumerate_rps():
    rp_info = rp[CredentialManagement.RESULT.RP]
    rp_hash = rp[CredentialManagement.RESULT.RP_ID_HASH]

    print(f"RP: {rp_info}")

    creds = credman.enumerate_creds(rp_hash)

    for cred in creds:
        descriptor = cred[CredentialManagement.RESULT.CREDENTIAL_ID]
        user = cred[CredentialManagement.RESULT.USER]

        n = len(all_credentials)

        print(f"  [{n}]")
        print(f"      User: {user}")
        print(f"      Credential ID: {descriptor['id'].hex()}")

        all_credentials.append(
            (rp_info, user, descriptor)
        )

if not all_credentials:
    print("Nenhuma credencial discoverable encontrada.")
    sys.exit(0)

print()

choice = input(
    "Digite o número da credencial para apagar ou ENTER para sair: "
)

if choice == "":
    sys.exit(0)

try:
    choice = int(choice)
except ValueError:
    print("Índice inválido.")
    sys.exit(1)

if choice < 0 or choice >= len(all_credentials):
    print("Índice fora do intervalo.")
    sys.exit(1)

rp, user, descriptor = all_credentials[choice]

print("\nVocê selecionou:")
print("RP:", rp)
print("User:", user)
print("Credential ID:", descriptor["id"].hex())

confirm = input("\nDigite APAGAR para confirmar: ")

if confirm != "APAGAR":
    print("Cancelado.")
    sys.exit(0)

try:
    credman.delete_cred(descriptor)
except Exception as e:
    print("\nErro ao apagar a credencial:")
    print(repr(e))
    sys.exit(1)

print("\nCredencial apagada com sucesso.")

Vou deixar na tabela abaixo um resumo do que podemos fazer com o comando fido2-token:

Função do App	Como
Detectar o Pico FIDO	`fido2-token -L`
Ver capacidades/AAGUID	`fido2-token -I <device>`
Definir PIN	`fido2-token -S <device>`
Alterar PIN	`fido2-token -C <device>`
Resetar FIDO	`fido2-token -R <device>`
Listar passkeys	`fido2-token -L -r <device>` + `-L -k`
Ver metadata de passkeys	`fido2-token -I -c <device>`
Deletar passkeys	`fido2-token -D -i ...`
Alterar nome/display name da credencial	`fido2-token -S -c ...`
Ler/gravar/apagar `largeBlob`	`fido2-token -G/-S/-D -b ...`
Ativar `Always UV`	`fido2-token -S -u`
Desativar `Always UV`	`fido2-token -D -u`
Definir tamanho mínimo do PIN	`fido2-token -S -l N`
Criar credenciais manualmente	`fido2-cred`
Testar autenticação/assertion	`fido2-assert`