[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico] [volume] [parte]
OpenSSL (1) è una realizzazione in forma di software libero dei protocolli SSL/TLS (Secure socket layer e Transport layer security) per la certificazione e la comunicazione cifrata. Inizialmente, il progetto si chiamava SSLeay, ma da quando l'autore originale lo ha dovuto interrompere, questo è stato ripreso da un gruppo indipendente che lo ha ribattezzato in OpenSSL.
OpenSSL si compone di alcune librerie che permettono di incorporare le funzionalità dei protocolli SSL/TLS all'interno di programmi di comunicazione, oltre a una serie di programmi di servizio per la gestione delle chiavi e dei certificati, arrivando eventualmente anche alla gestione di un'autorità di certificazione.
Questi programmi, in particolare, potrebbero essere compilati in modo da distinguersi in più file eseguibili, oppure in modo da generare un solo eseguibile monolitico: openssl. In questi capitoli, in cui si fa riferimento a OpenSSL, si presume che si tratti di un eseguibile unico.
Non esiste una definizione ben precisa di dove devono essere collocati i file che compongono la configurazione e gli strumenti di OpenSSL. Quando si installa OpenSSL da un pacchetto fatto per la propria distribuzione GNU/Linux, è importante scoprire dove vengono collocati i file delle chiavi e dei certificati, così come la collocazione del file di configurazione openssl.cnf. Intuitivamente si potranno cercare questi file a partire dalla directory /etc/; in particolare, le chiavi potrebbero essere collocate a partire da /etc/ssl/ o da /etc/openssl/.
Quando gli strumenti di OpenSSL sono organizzati in un solo eseguibile monolitico, la sintassi per i comandi relativi si esprime sinteticamente nel modo seguente:
openssl comando [opzioni]
Tabella 199.1. Alcuni comandi di OpenSSL.
| Comando | Descrizione |
| openssl req | Gestione delle richieste di certificazione. |
| openssl ca | Gestione relativa all'autorità di certificazione. |
| openssl crl | Gestione del certificato delle revoche. |
| openssl genrsa | Generazione di parametri RSA. |
| openssl rsa | Conversione del formato di una chiave privata o di un certificato. |
| openssl x509 | Gestione dei dati dei certificati X.509. |
La tabella 199.1 elenca brevemente alcuni dei comandi più importanti. Per avere una guida rapida alle opzioni di ogni comando, basta utilizzare un'opzione non valida, per esempio -h:
$ openssl ca -h
L'esempio mostra in che modo ottenere l'elenco delle opzioni del comando openssl ca; comunque, in mancanza di altra documentazione, conviene stampare e tenere a portata di mano queste guide:
$ openssl req -h > guida.txt
$ openssl crl -h >> guida.txt
$ openssl ca -h >> guida.txt
$ openssl genrsa -h >> guida.txt
$ openssl x509 -h >> guida.txt
Alcuni di questi comandi hanno in comune delle opzioni, che vale la pena di descrivere subito, prima di mostrare degli esempi, nei quali si potrà concentrare l'attenzione sulle altre opzioni specifiche. La tabella 199.2 mostra questo elenco di opzioni tipiche.
Tabella 199.2. Alcune opzioni frequenti nei comandi di OpenSSL.
Prima di descrivere la configurazione di OpenSSL, viene mostrato tecnicamente il modo per richiedere un certificato, o per realizzarne un proprio senza valore. Infatti, in generale, la configurazione standard dovrebbe essere più che sufficiente per il raggiungimento di questo obiettivo. È il caso di ricordare che un certificato è un file contenente la chiave pubblica del suo titolare, firmata da un'autorità di certificazione che garantisce la sua validità e anche la correttezza degli altri dati.
Per mettere in piedi un servizio che utilizzi i protocolli SSL/TLS, occorre predisporre dei file contenenti chiavi e certificati. Di solito, quando si installano servizi che utilizzano questi protocolli, la procedura di installazione si prende cura di predisporre automaticamente i file necessari per consentire il funzionamento, senza che le certificazioni che si ottengono abbiano alcun valore. In generale si comincia dalla creazione o dalla definizione di un file contenente dati casuali, come punto di partenza per generare una chiave privata, quindi si passa alla creazione di una richiesta di certificazione, oppure alla creazione di un certificato auto-firmato, senza valore.
Un file casuale può essere creato in vari modi, per esempio mettendo assieme alcuni file,
$ cat file_a file_b file_c > file_casuale
magari rielaborandoli in qualche modo, oppure prelevando un po' di caratteri dal file /dev/random:
$ dd if=/dev/random of=file_casuale bs=1b count=1k
Per generare una chiave privata in chiaro, si utilizza il comando openssl genrsa, in un modo simile a quello seguente, dove in particolare viene utilizzato il file file_casuale come origine di dati casuali, ottenendo il file chiave_privata.pem di 1 024 bit:
$ openssl genrsa -rand file_casuale -out chiave_privata.pem 1024
Eventualmente, per creare una chiave privata cifrata, basta aggiungere un'opzione a scelta tra -des, -des3 e -idea, che stanno a indicare rispettivamente gli algoritmi DES, DES-triplo e IDEA. Viene mostrato il caso in cui si utilizza l'opzione -des3:
$ openssl genrsa -des3 -rand file_casuale <-'
`->-out chiave_privata_protetta.pem 1024[Invio]
Enter PEM passphrase: ********[Invio]
Verifying password - Enter PEM pass phrase: ********[Invio]
Volendo riportare la chiave privata in chiaro, si usa il comando openssl rsa, in modo simile all'esempio seguente:
$ openssl rsa -in chiave_privata_protetta.pem -out chiave_privata.pem[Invio]
Enter PEM passphrase: ********[Invio]
In modo analogo funziona l'operazione di protezione di una chiave; in pratica si aggiunge l'opzione attraverso cui si specifica il tipo di algoritmo:
$ openssl rsa -des3 -in chiave_privata.pem -out chiave_privata_protetta.pem
Teoricamente, il certificato che identifica e garantisce l'identità del servizio che si gestisce, deve essere fornito da un'autorità di certificazione. In questo caso, per farlo, deve ricevere un documento intermedio, definibile come una richiesta di certificazione. La chiave pubblica che vi viene inserita si ottiene a partire dalla chiave privata, mentre gli altri dati necessari per il certificato che si vuole ottenere si inseriscono in modo interattivo. È interessante vedere come avviene:
$ openssl req -new -key chiave_privata.pem -out richiesta.pem[Invio]
You are about to be asked to enter information that will be incorporated into your certificate request. What you are about to enter is what is called a Distinguished Name or a DN. There are quite a few fields but you can leave some blank For some fields there will be a default value, If you enter '.', the field will be left blank.
Country Name (2 letter code) [AU]:IT[Invio]
State or Province Name (full name) [Some-State]:Italia[Invio]
Locality Name (eg, city) []:Tiziopoli[Invio]
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Dinkel[Invio]
Organizational Unit Name (eg, section) []:.[Invio]
Common Name (eg, YOUR name) []:dinkel.brot.dg[Invio]
Email address []:tizio@dinkel.brot.dg[Invio]
Please enter the following 'extra' attributes to be sent with your certificate request
A challenge password []:super segretissimo[Invio]
An optional company name []:Dinkel[Invio]
Le informazioni che si inviano in questo modo sono molto importanti e il significato preciso varia a seconda del contesto per il quale si richiede la certificazione. Sarà l'autorità per la certificazione a stabilire quali informazioni servono precisamente.
Per verificare il contenuto del certificato, che nel suo formato PEM non è leggibile direttamente, si può usare il comando openssl req con l'opzione -text:
$ openssl req -text -in richiesta.pem[Invio]
Certificate Request:
Data:
Version: 0 (0x0)
Subject: C=IT, ST=Italia, L=Tiziopoli, O=Dinkel, CN=dinkel.brot.dg...
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
RSA Public Key: (1024 bit)
Modulus (1024 bit):
00:ce:0d:cd:08:86:fd:b5:cb:14:56:51:04:73:38:
15:77:39:2d:3b:10:17:06:7c:64:0d:69:14:67:cd:
...
67:f7:ef:b1:71:af:24:77:64:66:64:0f:85:a6:64:
16:c2:69:26:59:0a:d9:4b:8d
Exponent: 65537 (0x10001)
Attributes:
unstructuredName :Dinkel
challengePassword :super segretissimo
Signature Algorithm: md5WithRSAEncryption
8f:25:9f:68:3a:67:4c:6d:e6:eb:52:4a:ca:73:74:47:85:14:
ca:d6:6c:6d:24:3b:6c:37:59:ec:f8:fb:0b:a9:74:d6:1c:0f:
...
02:60:16:fd:2e:9b:09:af:11:03:82:74:16:ae:57:a7:90:f5:
e1:a5
Per generare in proprio il certificato auto-firmato, in modo da attivare ugualmente il servizio anche se non si può dimostrare di essere chi si afferma di essere, si può aggiungere l'opzione -x509. Anche in questo caso vengono richieste tutte le informazioni già viste.
$ openssl req -new -x509 -key chiave_privata.pem <-'
`->-out richiesta.pem[Invio]
In alcuni casi può essere necessario unire la chiave privata, in chiaro, assieme al certificato; questo accade in particolare quando si allestisce un servente HTTP Apache-SSL. Di solito la chiave privata non può essere cifrata, perché deve essere letta da un servizio autonomo che non può interrogare un utente. Si deve ottenere una cosa simile a quella seguente:
-----BEGIN RSA PRIVATE KEY----- MIICXQIBAAKBgQDzUS4vA9NPNGAhHp71jGLk9lyJ6GfFK2R+AtMmWDKWvwhVOA8l eY13ouz6XW0ts7s91FYlSTbp0Ed5tLKHZFu8guuza3jzpqFE/wrW/eJ7/RYW0cOZ ... +7JyXBGaA4Srn/iw9cUCQQDEr5yuQa426I6psxfvUiK+HKS2kfRBbKKHj2NYh6nv GgMhY9NiG+SGEDfkOw9rIVifb9yXs6f4CajQTb4qVl2X -----END RSA PRIVATE KEY----- -----BEGIN CERTIFICATE----- MIICMTCCAZoCAQAwDQYJKoZIhvcNAQEEBQAwYTELMAkGA1UEBhMCcXExCzAJBgNV BAgTAnd3MQswCQYDVQQHEwJlZTELMAkGA1UEChMCcnIxCzAJBgNVBAsTAnR0MQsw ... 3kNqIB5Iun0kdDqdJYQj9G5Ca+dlRCxrPY6bVCnlD3A8+RULjyGrT6D45QtoXKx+ quIhIni++XBHqe+RyWBD70XTWvw0+zoyrHNHG96k9eLlPIgHrQ== -----END CERTIFICATE----- |
L'aggregazione può essere fatta a mano (attraverso cat), oppure si può utilizzare un comando unico che crea la chiave privata (di dimensione predefinita) e anche il certificato autoprodotto:
$ openssl req -new -x509 -nodes -out certificato.pem <-'
`->-keyout certificato.pem
In questo esempio è stata usata l'opzione -keyout per dirigere la chiave privata nello stesso file del certificato; inoltre, è stata usata l'opzione -nodes per evitare la protezione della chiave che in questi casi deve essere usata in chiaro.
Come verrà mostrato anche in seguito, il file del certificato, con o senza la chiave privata acclusa, deve essere raggiungibile attraverso un nome corrispondente al suo codice di controllo, con l'aggiunta dell'estensione .0. Questo valore si ottiene con un comando simile a quello che si vede:
$ openssl x509 -hash -noout -in certificato.pem
Per generare un collegamento simbolico come si fa di solito, si potrebbe usare il comando seguente:
$ ln -s certificato.pem `openssl x509 -hash -noout <-'
`->-in certificato.pem`.0
La configurazione di OpenSSL si attua normalmente attraverso il file openssl.cnf, che potrebbe trovarsi collocato nella directory /etc/ssl/. Osservandone il contenuto, si intuisce che il simbolo # serve a introdurre un commento, fino alla fine della riga relativa; inoltre si comprende che le righe vuote e quelle bianche vengono ignorate come i commenti; infine, si vede che le direttive del file sono degli assegnamenti a variabili, che se necessario si espandono con il prefisso $, e le direttive sono raggruppate in sezioni individuabili da un titolo tra parentesi quadre.
È importante osservare che le sezioni sono organizzate in modo gerarchico, a partire dai nomi dei comandi di OpenSSL. In pratica, per il comando openssl req si prende in considerazione la sezione [ req ], che poi può a sua volta richiamare altre sottosezioni.
Dal momento che è già stato mostrato in che modo si ottiene una richiesta di certificato, attraverso il comando openssl req, vale la pena di dare un'occhiata a un estratto della configurazione relativa, per comprendere un po' meglio come leggere questo file.
[ req ] default_bits = 1024 default_keyfile = privkey.pem distinguished_name = req_distinguished_name attributes = req_attributes x509_extensions = v3_ca # The extentions to add to the self signed cert [ req_distinguished_name ] countryName = Country Name (2 letter code) countryName_default = AU countryName_min = 2 countryName_max = 2 stateOrProvinceName = State or Province Name (full name) stateOrProvinceName_default = Some-State localityName = Locality Name (eg, city) |
È importante osservare che alcune variabili vengono assegnate con il nome di una sottosezione; in questo caso si tratta in particolare di distinguished_name a cui viene attribuita la sottosezione [ req_distinguished_name ], all'interno della quale vengono definite le informazioni che sono richieste in fase di costruzione del certificato.
Nelle prossime sezioni verrà mostrato come simulare la gestione di un'autorità di certificazione attraverso OpenSSL. Il file di configurazione standard dovrebbe essere neutro rispetto a questo problema, incorporando una sezione [ ca ] particolare, utile per fare delle prove:
[ ca ] default_ca = CA_default # The default ca section #################################################################### [ CA_default ] dir = ./demoCA # Where everything is kept certs = $dir/certs # Where the issued certs are kept crl_dir = $dir/crl # Where the issued crl are kept database = $dir/index.txt # database index file. new_certs_dir = $dir/newcerts # default place for new certs. certificate = $dir/cacert.pem # The CA certificate serial = $dir/serial # The current serial number crl = $dir/crl.pem # The current CRL private_key = $dir/private/cakey.pem# The private key RANDFILE = $dir/private/.rand # private random number file |
È importante osservare che la sezione [ ca ] contiene una sola direttiva, default_ca, con la quale si specifica la sottosezione da prendere in considerazione. In questo caso, la sottosezione è denominata [ CA_default ] e viene mostrata solo in parte. Si intende che, volendo fare le cose sul serio, è sufficiente ricopiare la sottosezione [ CA_default ], anche più volte, attribuendogli nomi differenti, modificando eventualmente la direttiva default_ca in modo da selezionare la sottosezione preferita.
Per il momento è bene osservare che con la direttiva dir viene definita una variabile, che poi viene presa in considerazione di nuovo, espandendola con l'aggiunta del prefisso $ ($dir), nei valori da assegnare ad altre variabili. Questa variabile serve a definire la directory di partenza a partire dalla quale vanno collocati una serie di file che riguardano l'amministrazione dell'autorità di certificazione. Inizialmente, viene indicata una directory che appare volutamente improbabile, ./demoCA/, proprio per fare capire che prima di lavorare sul serio occorre pensarci bene e mettere mano alla configurazione. Comunque, per le simulazioni che si vogliono mostrare, vale la pena di creare le directory ./demoCA/certs/, ./demoCA/newcerts/, ./demoCA/crl/ e ./demoCA/private/, o altre directory equivalenti in base alla propria configurazione effettiva.
Nella sezione che descrive il funzionamento del comando openssl ca, deve apparire anche l'indicazione del tipo di politica che l'autorità di certificazione intende attuare per rilasciare i certificati. Naturalmente, quello che può essere definito qui è solo qualche aspetto che riguarda la definizione del nome distintivo del titolare. Quello che segue è un altro estratto del file di configurazione in cui si vede l'assegnamento del nome di una sottosezione alla variabile policy.
policy = policy_match # For the CA policy [ policy_match ] countryName = match stateOrProvinceName = match organizationName = match organizationalUnitName = optional commonName = supplied emailAddress = optional [ policy_anything ] countryName = optional stateOrProvinceName = optional localityName = optional organizationName = optional organizationalUnitName = optional commonName = supplied emailAddress = optional |
In questo caso, la sottosezione [ policy_match ] specifica che i campi del paese, della regione e dell'organizzazione, devono corrispondere con gli stessi dati del certificato della stessa autorità di certificazione. In pratica, questo servirebbe a limitare l'accesso all'autorità soltanto a chi appartiene alla stessa area e anche alla stessa organizzazione (ciò fa pensare a un'autorità di certificazione aziendale, competente solo nell'ambito della propria azienda). Per il resto, solo il campo CN deve essere fornito, mentre gli altri sono facoltativi.
Sotto alla sottosezione appena descritta, appare anche un'altra sottosezione simile, con il nome [ policy_anything ], in cui verrebbe concesso quasi tutto, a parte l'obbligo di fornire il CN.
L'utilizzo di OpenSSL per la gestione di un'autorità di certificazione richiede la conoscenza di molti dettagli sul funzionamento di questo sistema. In generale, il file di configurazione predefinito consente di ottenere delle richieste di certificati o di generare dei certificati fittizi auto-firmati. In questo gruppo di sezioni si vuole mostrare schematicamente l'uso di OpenSSL nella gestione di un'autorità di certificazione, anche con qualche esempio, ma senza l'intenzione di arrivare a ottenere dei certificati realistici.
La creazione di un'autorità di certificazione autonoma, ovvero di un'autorità principale (root), che non abbia ottenuto a sua volta un certificato da un'autorità di livello superiore, deve realizzare la sua chiave privata e il suo certificato auto-firmato. Diversamente, se dipendesse dalla certificazione di un'altra autorità, dovrebbe predisporre la propria richiesta, sottoporla all'autorità superiore da cui dovrebbe ottenere il certificato.
Viene mostrato nuovamente il procedimento necessario per creare la chiave privata. In questo caso si fa riferimento alla porzione di configurazione che è stata mostrata in precedenza, dove tutti i file utilizzati si articolano a partire dalla directory ./demoCA/. In particolare, si suppone che ./demoCA/private/.rand sia un file contenente informazioni casuali:
$ openssl genrsa -des3 -out ./demoCA/private/cakey.pem <-'
`->-rand ./demoCA/private/.rand
Ecco che in questo modo si ottiene la chiave privata nel file ./demoCA/private/cakey.pem, cifrata con l'algoritmo DES-triplo. Il certificato auto-firmato viene generato con il comando seguente, con il quale si ottiene il file ./demoCA/cacert.pem:
$ openssl req -new -x509 -days 730 -key ./demoCA/private/cakey.pem <-'
`->-out ./demoCA/cacert.pem
Si osservi in particolare che è stato indicato espressamente il periodo di validità del certificato, in 730 giorni, pari a due anni. La visualizzazione del contenuto del certificato si può fare con il comando seguente:
$ openssl x509 -text -in ./demoCA/cacert.pem
Il certificato, in quanto tale, va conservato anche nella directory destinata a contenere la copia di quelli che verranno rilasciati in qualità di autorità di certificazione. Dal pezzo di configurazione mostrato in precedenza, la directory in questione è ./demoCA/certs/. Questi file devono avere un nome che inizia con il loro numero di serie; dal momento che il numero del certificato dell'autorità stessa è il numero zero, il file deve chiamarsi obbligatoriamente ./demoCA/certs/00.pem:
$ cp ./demoCA/cacert.pem ./demoCA/certs/00.pem
Inoltre, i file in quella directory devono essere abbinati, ognuno, a un collegamento simbolico che esprime il codice di controllo del file stesso, più l'estensione .0:
$ cd ./demoCA/certs
$ ln -s 00.pem `openssl x509 -hash -noout -in 00.pem`.0
Per le operazioni di rilascio dei certificati, ovvero della firma di questi a partire dai file di richiesta relativi, occorre prendere confidenza con l'uso di alcuni file, contenenti rispettivamente l'indice dei certificati rilasciati e il numero di serie successivo che potrà essere utilizzato. Come è già stato spiegato in un altro capitolo, i certificati rilasciati da un'autorità di certificazione hanno un numero seriale progressivo; in base al pezzo di configurazione mostrato in precedenza, questo numero viene conservato nel file demoCA/serial. Il numero in questione viene annotato secondo una notazione esadecimale, tradotta in caratteri normali, ma senza alcun prefisso. In pratica, dopo aver predisposto il certificato della stessa autorità, occorre mettere in questo file la riga seguente, conclusa da un codice di interruzione di riga finale e nulla altro:
01 |
La creazione dei certificati incrementerà automaticamente questo numero;(2) inoltre, se non verrà specificato il file da creare, si otterrà direttamente un file corrispondente al suo numero di serie, con l'aggiunta dell'estensione consueta, collocato nella directory prevista per l'accumulo provvisorio: demoCA/newcerts/ nel caso della configurazione di esempio a cui si continua a fare riferimento.
La creazione di un certificato aggiorna anche il file che ne contiene l'indice, che potrebbe essere demoCA/index.txt. Inizialmente, dopo la creazione del certificato dell'autorità stessa, questo indice è semplicemente un file vuoto; con la creazione dei certificati successivi, viene aggiunta una riga per ognuno di questi, che va intesa come un record suddiviso in campi separati da un carattere di tabulazione singolo. Viene mostrato subito l'esempio del record relativo a un primo certificato (diviso in due righe per motivi tipografici):
V 001213190753Z 01 unknown (segue) |
Nell'esempio non si vede, ma c'è un terzo campo nullo prima del valore 01. I campi hanno il significato seguente:
lo stato del certificato, attraverso una lettera: «R», revocato, «E», scaduto, «V», valido;
la data di scadenza, scritta attraverso una stringa di cifre numeriche terminate da una lettera «Z» maiuscola, dove le coppie di cifre rappresentano rispettivamente: anno, mese, giorno, ore, minuti, secondi (AAMMGGHHMMSSZ);
la data di revoca del certificato, scritta esattamente come nel caso del secondo campo, solitamente assente, a indicare che il certificato è ancora valido;
il numero di serie in esadecimale;
la collocazione del certificato (attualmente si tratta sempre della parola chiave unknown);
i dati del titolare del certificato, ovvero il nome distintivo e l'indirizzo di posta elettronica di questo.
La creazione, ovvero la firma di un certificato si ottiene con il comando openssl ca, fornendo in particolare il file contenente la richiesta. Per esempio, se si vuole accettare la richiesta costituita dal file richiesta.pem, si potrebbe agire nel modo seguente:
$ openssl ca -in richiesta.pem
Avendo indicato esclusivamente il nome del file che contiene la richiesta, le altre informazioni sono state prese dalla configurazione. In base a quanto previsto dall'esempio mostrato inizialmente, per la firma è stata usata la chiave contenuta nel file demoCA/private/cakey.pem, il file del certificato è stato creato nella directory demoCA/newcerts/, con un nome corrispondente al suo numero di serie e con la solita estensione .pem, ma soprattutto, è stata usata la sezione predefinita nel file di configurazione, ovvero [ CA_default ]. Volendo dichiarare tutto in modo esplicito, lo stesso comando avrebbe dovuto essere espresso nel modo seguente:
$ openssl ca -name CA_default -keyfile demoCA/private/cakey.pem <-'
`->-in richiesta.pem -out demoCA/newcerts/`cat demoCA/serial`
Questo comando richiede alcune conferme:
Using configuration from /usr/lib/ssl/openssl.cnf Check that the request matches the signature Signature ok The Subjects Distinguished Name is as follows countryName :PRINTABLE:'IT' stateOrProvinceName :PRINTABLE:'Italia' localityName :PRINTABLE:'Tiziopoli' organizationName :PRINTABLE:'Dinkel' commonName :PRINTABLE:'dinkel.brot.dg' emailAddress :IA5STRING:'tizio@dinkel.brot.dg' Certificate is to be certified until Dec 13 19:28:38 2000 GMT (365 days)
Sign the certificate? [y/n]:y[Invio]
1 out of 1 certificate requests certified, commit? [y/n]:y[Invio]
... Data Base Updated
Una volta creato un certificato nel modo descritto, questo va collocato nella sua posizione definitiva, che in questo caso è la directory demoCA/certs/, dove va creato il solito collegamento simbolico che rappresenta il suo codice di controllo (come è già stato mostrato più volte).
Se si incontra la necessità di revocare dei certificati prima della loro scadenza normale, si deve pubblicare un elenco di revoca, o CRL (Certificate revocation list). Questo elenco si produce con OpenSSL a cominciare dalla modifica del file contenente l'elenco dei certificati (./demoCA/index.txt), sostituendo la lettera «V» con la lettera «R» e inserendo la scadenza anticipata nel terzo campo. L'esempio seguente mostra il caso di due certificati che vengono revocati prima della scadenza:
R 001213192838Z 000113192840Z 01 unknown /C=IT/ST=Italia/... R 001213202243Z 000113192840Z 02 unknown /C=IT/ST=Italia/... |
Successivamente, basta usare il comando openssl ca, con l'opzione -gencrl:
$ openssl ca -gencrl -out ./demoCA/crl/crl.pem
Con questo esempio, viene creato il file ./demoCA/crl/crl.pem, contenente questo elenco di revoca, il cui contenuto può essere riletto con il comando seguente:
$ openssl crl -text -in ./demoCA/crl/crl.pem
Certificate Revocation List (CRL):
Version 1 (0x0)
Signature Algorithm: md5WithRSAEncryption
Issuer: /C=IT/ST=Italia/L=Treviso/O=Dinkel/CN=dinkel.brot.dg...
Last Update: Jan 15 20:35:52 2000 GMT
Next Update: Feb 14 20:35:52 2000 GMT
Revoked Certificates:
Serial Number: 01
Revocation Date: Jan 13 19:28:40 2000 GMT
Serial Number: 02
Revocation Date: Jan 13 19:28:40 2000 GMT
Signature Algorithm: md5WithRSAEncryption
32:e1:97:92:96:2f:0c:e4:df:bb:9c:82:a5:e3:5b:51:69:f5:
51:ad:1b:b2:98:eb:35:a6:c8:7f:d9:29:1f:b2:1e:cc:da:84:
...
31:27:4a:21:4c:7a:bc:85:73:cd:ff:15:9d:cb:81:b3:0b:82:
73:50
In generale, con OpenSSL si lavora con file (richieste, certificati, elenchi di revoca, ecc.) in formato PEM, che è in pratica una forma compatta dei dati, utilizzando però solo il codice ASCII a 7 bit. Ci sono situazioni in cui è necessario convertire questo formato in un altro, oppure è necessario acquisire dei dati da un formato diverso dal solito. In generale, quando si usano comandi che possono ricevere dati in ingresso, o quando si devono generare dati in uscita, sempre relativi a certificati e affini, si possono usare rispettivamente le opzioni -inform e -outform, seguite dalla sigla del formato (non sono disponibili sempre tutti). Vengono mostrati alcuni esempi.
$ openssl x509 -in certificato.pem -outform der -out certificato.der
In questo modo si ottiene la conversione del certificato certificato.pem nel file certificato.der, che risulta in formato DER (binario).
$ openssl crl -in crl.pem -outform der -out crl.der
Converte l'elenco di revoca crl.pem in formato DER, nel file crl.der.
OpenSSL
SSL-Apache/OpenSSL/SSLeay Handbücher, DFN-PCA, 2000
R. Housley, W. Ford, W. Polk, D. Solo, RFC 2459: Internet X.509 Public Key Infrastructure -- Certificate and CRL Profile 1999
<http://www.cis.ohio-state.edu/cgi-bin/rfc/rfc2459.html>
<http://www.cis.ohio-state.edu/cs/Services/rfc/rfc-text/rfc2459.txt>
daniele @ swlibero.org1) OpenSSL licenza speciale + SSLeay
2) È importante ribadire che se questo file contiene il valore n, l'ultimo certificato che è stato creato è quello corrispondente al numero n-1.
Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome introduzione_a_openssl.html
[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico]