SmartCard: conservare certificati e chiavi SSH

Dopo essere diventato notaio per StartSSL, mi sono reso conto di quanto sia scomodo collegarsi da un solo browser, e quanto possa essere insicuro installare il proprio client certificate su ogni browser che si intende usare. Mi sono così deciso a cercare una smartcard in grado di gestire internamente l'autenticazione, comoda da trasportare e sicura.

La scelta è ricaduta sulla MyEID di Aventra (sotto Smartcard), economica (meno di 10€ cad. se se ne prendono almeno 5) e versatile (80kB di memoria, supporta fino a 14 PIN!).

Dopo alcuni giorni di trepidante attesa, stamattina mi è arrivato il pacchetto. Ovviamente mi sono fiondato immediatamente a vedere come utilizzare le card.

Ero quasi completamente a digiuno del funzionamento del toolkit per PKCS15 (ho però studiato sia la crittografia a chiave pubblica -- per OpenAlarm -- che il funzionamento a basso livello delle card -- per un progetto collaterale mirato al "riciclaggio" di vecchie SIM -- ), quindi ci ho messo un po' a capire alcune cose che, effettivamente, sono logiche:

1. I vari PIN sono indipendenti dagli altri oggetti memorizzati
2. Ogni oggetto può essere "libero" o protetto da un PIN
3. C'è un PIN che è riservato all'amministratore e non può essere usato per proteggere gli accessi agli oggetti

Nel seguito, copierò molto da OpenSC.org, a cui rimando per eventuali chiarimenti.

Per iniziare, è necessario disporre di un lettore compatibile PC/SC e supportato da OpenSC. Darò per scontata l'installazione dei pacchetti necessari (se ricordo bene, almeno libpcsc-lite, ccid, opensc-0.12.0 e libopensc3 -- con opensc-0.11.3 non sono riuscito a far funzionare le MyEID!).

Per verificare che il lettore sia supportato, si può usare :

$ pkcs11-tool -L
Available slots:
Slot 0 (0xffffffff): Virtual hotplug slot
  (empty)
Slot 1 (0x1): Gemalto GemPC Twin 00 00
  (empty)
Slot 2 (0x2): Gemalto GemPC Twin 00 00
  (empty)
Slot 3 (0x3): Gemalto GemPC Twin 00 00
  (empty)
Slot 4 (0x4): Gemalto GemPC Twin 00 00
  (empty)
$ pkcs11-tool -L
Available slots:
Slot 0 (0xffffffff): Virtual hotplug slot
  (empty)
Slot 1 (0x1): Gemalto GemPC Twin 00 00
  (empty)
Slot 2 (0x2): Gemalto GemPC Twin 00 00
  (empty)
Slot 3 (0x3): Gemalto GemPC Twin 00 00
  (empty)
Slot 4 (0x4): Gemalto GemPC Twin 00 00
  (empty)
Slot 5 (0x5): Gemalto GemPC Twin 01 00
  (empty)
Slot 6 (0x6): Gemalto GemPC Twin 01 00
  (empty)
Slot 7 (0x7): Gemalto GemPC Twin 01 00
  (empty)
Slot 8 (0x8): Gemalto GemPC Twin 01 00
  (empty)

Qui ho fatto due prove, per vedere se erano previsti 4 lettori o se ogni lettore offre 4 slot. Buona la seconda. Ma devo ancora capire cosa questo implichi.

Ora che si sa che il lettore è compatibile, è necessario inizializzare la card:

$ pkcs15-init -C --pin 1111 --puk 1111
Using reader with a card: Gemalto GemPC Twin 00 00
New Security Officer PIN (Optional - press return for no PIN).
Please enter Security Officer PIN: 
Please type again to verify: 
Unblock Code for New User PIN (Optional - press return for no PIN).
Please enter User unblocking PIN (PUK): 
Please type again to verify:

Qui viene creata (-C) una nuova struttura PKCS15. PIN e PUK servono solo per evitare varie richieste a vuoto: PIN e PUK per il Security Officer (l'amministratore della card, praticamente l'account root, che ha accesso completo e può anche "riformattare" la card -- ma neppure il S.O. può accedere alle chiavi private!) vengono comunque chiesti da linea di comando. Il PIN del S.O. verrà poi richiesto per molte operazioni.

Poi si inizializzano i PIN/PUK necessari per le proprie esigenze. Io ne ho creati due: uno per l'autenticazione ed un altro per le firme. Se le vostre esigenze lo richiedono, potete crearne fino a 14 (su card MyEID... su altre potrebbe essere possibile crearne uno solo, o anche di più).

$ pkcs15-init -P -a 1 -l "Auth PIN"
Using reader with a card: Gemalto GemPC Twin 00 00
New User PIN.
Please enter User PIN: 
Please type again to verify: 
Unblock Code for New User PIN (Optional - press return for no PIN).
Please enter User unblocking PIN (PUK): 
Please type again to verify: 
Security officer PIN [Security Officer PIN] required.
Please enter Security officer PIN [Security Officer PIN]: 

$ pkcs15-init -P -a 2 -l "Sign PIN"
Using reader with a card: Gemalto GemPC Twin 00 00
New User PIN.
Please enter User PIN: 
Please type again to verify: 
Unblock Code for New User PIN (Optional - press return for no PIN).
Please enter User unblocking PIN (PUK): 
Please type again to verify: 
Security officer PIN [Security Officer PIN] required.
Please enter Security officer PIN [Security Officer PIN]: 

Qui si crea un nuovo PIN (-P) in prima (e poi seconda) posizione (-a 1 / -a 2) e gli si assegna un'etichetta (utile poi per sapere quale PIN inserire più avanti). Come potete notare viene richiesto ogni volta anche il PIN del S.O., poiché si stanno modificando dati "base" della card.

Una volta creati i vari PIN, si può "finalizzare" la card. Questa operazione, in pratica, dovrebbe semplicemente attivare i controlli di accesso:

$ pkcs15-init -F
Using reader with a card: Gemalto GemPC Twin 00 00

Da notare che non viene chiesto nulla.

Dopo aver esportato il mio certificato da Firefox (e dopo averlo collaudato su un altro Firefox, tanto per essere tranquillo) in startssl.p12, lo importo nella card:

$ pkcs15-init -S startssl.p12 -f PKCS12 -a 1
Using reader with a card: Gemalto GemPC Twin 00 00
error:23076071:PKCS12 routines:PKCS12_parse:mac verify failure
Please enter passphrase to unlock secret key: 
Importing 3 certificates:
  0: /description=******-****************/O=Persona Not Validated/CN=StartCom Free Certificate Member/emailAddress=*******@*********
  1: /C=IL/O=StartCom Ltd./OU=Secure Digital Certificate Signing/CN=StartCom Certification Authority
  2: /C=IL/O=StartCom Ltd./OU=Secure Digital Certificate Signing/CN=StartCom Class 1 Primary Intermediate Client CA
User PIN [Auth PIN] required.
Please enter User PIN [Auth PIN]: 

Qui importo un certificato (-S file) in formato PKCS12 (-f PKCS12) e l'accesso alla chiave segreta richiede il pin n.1 ("Auth PIN").

Fatto questo, verifico che sulla card ci sia tutto:

$ pkcs15-tool -c -C --list-pins
Using reader with a card: Gemalto GemPC Twin 00 00
X.509 Certificate [/description=******-****************/O=Persona Not Validated/CN=StartCom Free Certificate Member/emailAddress=*******@*********]
        Object Flags   : [0x2], modifiable
        Authority      : no
        Path           : 3f0050154301
        ID             : 4a3ba138834****************335b31ed205b6
        Encoded serial : 02 03 01****

X.509 Certificate [/C=IL/O=StartCom Ltd./OU=Secure Digital Certificate Signing/CN=StartCom Certification Authority]
        Object Flags   : [0x2], modifiable
        Authority      : yes
        Path           : 3f0050154302
        ID             : 509b7413aa02db7808cf0c378e61a7ecc4f29745
        Encoded serial : 02 01 01

X.509 Certificate [/C=IL/O=StartCom Ltd./OU=Secure Digital Certificate Signing/CN=StartCom Class 1 Primary Intermediate Client CA]
        Object Flags   : [0x2], modifiable
        Authority      : yes
        Path           : 3f0050154303
        ID             : 6b4d6361e8c647c2ad9a055c051139ccdfdb1885
        Encoded serial : 02 01 1E

PIN [Security Officer PIN]
        Object Flags   : [0x3], private, modifiable
        ID             : ff
        Flags          : [0xB0], initialized, needs-padding, soPin
        Length         : min_len:4, max_len:8, stored_len:8
        Pad char       : 0xFF
        Reference      : 3
        Type           : ascii-numeric
        Path           : 

PIN [Auth PIN]
        Object Flags   : [0x3], private, modifiable
        ID             : 01
        Flags          : [0x30], initialized, needs-padding
        Length         : min_len:4, max_len:8, stored_len:8
        Pad char       : 0xFF
        Reference      : 1
        Type           : ascii-numeric
        Path           : 

PIN [Sign PIN]
        Object Flags   : [0x3], private, modifiable
        ID             : 02
        Flags          : [0x30], initialized, needs-padding
        Length         : min_len:4, max_len:8, stored_len:8
        Pad char       : 0xFF
        Reference      : 2
        Type           : ascii-numeric
        Path           : 

Interessante l'indicazione del path degli oggetti: 3F00 (root) / 5015 (PKCS15) / 430x... Può tornare utile per accedere direttamente "a basso livello" alla card.

A questo punto, ho cancellato da Firefox il mio client certificate (BRRR!), ed ho caricato un nuovo "Dispositivo di sicurezza" (il modulo da usare, in Mandriva, è /usr/lib/opensc-pkcs11.so ).
A parte il fatto che autenticandomi sul sito di StartSSL mi chiede anche il PIN per la firma (ma posso non darlo, basta premere ESC o cliccare su "Annulla"), funziona perfettamente. A meno che non togliate e reinseriate la card: in tal caso, per Firefox la chiave sarà sbloccata, mentre per la card sarà bloccata. È sufficiente tornare nella schermata di gestione, selezionare il PIN erroneamente considerato "aperto" e cliccare "chiudi". Oppure chiudere e rilanciare Firefox. Potrebbe anche solo essere un bug in Firefox 4.0beta...

Visto che portarsi dietro una smart card è comodo, vorrei usarla anche per gestire l'autenticazione SSH. Decisamente l'appetito vien mangiando

Per questo inizio installando engine_pkcs11, richiesto da OpenSSL. Fatto questo:

$ pkcs15-init -G rsa/2048 -a 1 -u decrypt,sign -l SSH
Using reader with a card: Gemalto GemPC Twin 00 00
User PIN [Auth PIN] required.
Please enter User PIN [Auth PIN]: 

Ho dovuto usare sia decrypt che sign poiché l'handshake di SSH li usa entrambi...
Questa fase può richiedere anche un minuto. Dipende dalla lunghezza scelta e, forse, anche dalla chiave (a volte ha impiegato 15s, altre 50s...).

Ora verifico che la chiave sia stata aggiunta:

$ pkcs15-tool -k --list-public-keys
Using reader with a card: Gemalto GemPC Twin 00 00
Private RSA Key [Private Key]
[...questa è quella del certificato per StartSSL...]

Private RSA Key [SSH]
        Object Flags   : [0x3], private, modifiable
        Usage          : [0x2E], decrypt, sign, signRecover, unwrap
        Access Flags   : [0x1D], sensitive, alwaysSensitive, neverExtract, local
        ModLength      : 2048
        Key ref        : 2
        Native         : yes
        Path           : 3f0050154b02
        Auth ID        : 01
        ID             : 9a1fa509c036d00e14fcd09e2cc4623d11254fcf

Public RSA Key [SSH]
        Object Flags   : [0x2], modifiable
        Usage          : [0xD1], encrypt, wrap, verify, verifyRecover
        Access Flags   : [0x0]
        ModLength      : 2048
        Key ref        : 0
        Native         : no
        Path           : 3f0050155501
        ID             : 9a1fa509c036d00e14fcd09e2cc4623d11254fcf

Da notare "sensitive" e "neverExtract": questa chiave privata non può lasciare la card per nessun motivo!
Se volete una sicurezza minore, potete usare rsa/1024. Oppure creare altre chiavi a sicurezza diversa. Con le label potete identificare facilmente quale ID corrisponde a quale chiave. L'ID della chiave privata è uguale all'ID della chiave pubblica, quindi potreste usare anche solo -k, senza --list-public-keys .

Le chiavi possono essere rimosse dalla card con pkcs15-init -D privkey --id 9a1f..fcf e pkcs15-init -D pubkey --id 9a1f..fcf.

Per permettere il login remoto, devo esportare la chiave pubblica per il mio ~/.ssh/authorized_keys sul server :

$ pkcs15-tool --read-ssh-key 9a1fa509c036d00e14fcd09e2cc4623d11254fcf
Using reader with a card: Gemalto GemPC Twin 00 00
2048 65537 20015055298168735343931698895893302218606119627306143296144578697900435878107067996166978424908105742403196312097281539413963604832215491264596571713709758444518097915035505582970682318805600964172484283736281843760797737928237814880158105225499576427621754271639889630755296638945552141639374608813958108825889688667297632929536819638638784568467561167430780781902166352193640833129842893922376759333170787762102020743236028197425147611528143962684572073952632597099520281998089593667632722784516793213504400230962124961887995287708559823196657591893107543450761926218346768663627789322880040993394283130095613940773
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCejL5Jp5h2MblIY/DY2XvIMx/RhMaPTtq2bTA88DkcuWR8yR3BspUZ3VNHbhrnNpeUqDvmOipRBxATeHRY7m01qU2c4bMtYzp7RBjdG3pf10l15FqHv9qWfBcLFTqFhEf5+qBJANLiAkgERfcOTrZZg5Ize1tK8Bn0T4Kktp96Z9ruiSK1jTWywnPYWLKwWsq+qS6h4v7PERjjKN0bg081aVQEjPtmmqRUcetYgdqpIspKwmwTG+dLXeAJBzwhdNUVfKzsZfAknPcptD2GfJCkMmQrlmLNhdvNeSYZ0NQgVZ/SMUm1CDk65AY/LF1LzXYEQyYqnb/D6+4HpPu40pQl

La parte da mettere sul server è quella da ssh-rsa (compreso) in poi.

Ed ora il test:

$ ssh -o PKCS11Provider=/usr/lib/opensc-pkcs11.so pvs
Enter PIN for 'MyEID (Auth PIN)': 
Linux pvs.csshl.org 2.6.26-2-486 #1 Thu Nov 25 01:49:20 UTC 2010 i686

FUNZIONA! Un pelo lento e chiede il PIN, ma FUNZIONA!
Per non dover inserire ogni volta -o PKCS11Provider=/usr/lib/opensc-pkcs11.so, si può semplicemente usare:
$echo PKCS11Provider /usr/lib/opensc-pkcs11.so >> ~/.ssh/config

Il difetto di questo sistema è che non potete "rimbalzare" su un host remoto, a meno che a questo host remoto non sia collegato un altro lettore con un'altra card... Ma per questo si può sempre usare un id_rsa "standard" sul server! Un sistema non esclude l'altro.