[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


227. Introduzione a OpenSSL

OpenSSL è 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, e di una serie di programmi di utilità 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 questo capitolo, e negli altri in cui si fa riferimento a OpenSSL, si presume che si tratti di un eseguibile unico.

227.1 Collocazione e impostazione

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, e dove si trova il 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>]

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.

Tabella 227.1: Alcuni comandi di OpenSSL.

La tabella 227.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 227.2 mostra questo elenco di opzioni tipiche.

Opzione Descrizione
-in <file> Definisce un file in ingresso adatto al contesto.
-out <file> Definisce un file in uscita adatto al contesto.
-noout Non emette il risultato.
-text Emette le informazioni in forma di testo leggibile.
-hash Emette il codice di controllo relativo al contesto.
-inform <formato> Specifica il formato dei dati in ingresso.
-outform <formato> Specifica il formato dei dati in uscita.

Tabella 227.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.

227.2 Procedimento per ottenere un certificato

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.

227.2.1 File contenente dati casuali

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

227.2.2 Chiave privata

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, e si ottiene il file `chiave_privata.pem' di 1024 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 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 (segue)
  -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

227.2.3 Richiesta di certificazione

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, e 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

227.2.4 Certificato fittizio

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 fondere assieme la chiave privata, in chiaro, e il 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 (segue)
  -keyout certificato.pem

In questo esempio è stata usata l'opzione `-keyout' per dirigere la chiave privata nello stesso file del certificato, e anche 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

227.3 Cenni sulla configurazione di OpenSSL

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 che 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, ed eventualmente modificare 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.

227.3.1 Politica dell'autorità di certificazione

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.

227.4 Simulazione dell'allestimento e del funzionamento di un'autorità di certificazione

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 senza l'intenzione di arrivare a ottenere dei certificati realistici.

227.4.1 Autorità di certificazione autonoma

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 (segue)
  -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 (segue)
  -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, e dal momento che il numero del certificato dell'autorità stessa è il numero zero, obbligatoriamente, il file deve chiamarsi `./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

227.4.2 Rilascio di certificazioni

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: l'indice dei certificati rilasciati e il prossimo numero di serie da utilizzare. 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, e 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
    /C=IT/ST=Italia/O=Dinkel/CN=dinkel.brot.dg/Email=tizio@dinkel.brot.dg

Nell'esempio non si vede, ma c'è un terzo campo nullo prima del valore `01'. I campi hanno il significato seguente:

  1. lo stato del certificato, attraverso una lettera: «R», revocato, «E», scaduto, «V», valido;

  2. 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 (`<AAMMGGHHMMSS>Z');

  3. la data di revoca del certificato, che si scrive esattamente come nel caso del secondo campo, e di solito è mancante, a indicare che il certificato è ancora valido;

  4. il numero di serie in esadecimale;

  5. la collocazione del certificato, e attualmente si tratta sempre della parola chiave `unknown';

  6. 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', e 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 (segue)
  -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 in questo modo, questo va collocato nella sua posizione definitiva, che in questo caso è la directory `demoCA/certs/', e lì va creato il solito collegamento simbolico che rappresenta il suo codice di controllo (come è già stato mostrato più volte).

227.4.3 Revoca dei certificati

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

227.4.4 Conversione nei formati

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 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'.

227.5 Riferimenti

---------------------------

Appunti Linux 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.it


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]