Comment configurer votre propre autorité de certification avec OpenSSL
Comment configurer votre propre autorité de certification avec OpenSSL
Principe de la cryptographie à clé publique
Connue aussi sous le nom de cryptographie asymétrique résout le problème de deux entités communiquant
en toute sécurité sans jamais échanger une clé commune, en utilisant deux clés liées, une privée, une publique.
Le texte chiffré avec la clé publique ne peut être déchiffré que par la clé privée, et les signatures vérifiables avec la clé publique ne peuvent être créées avec la clé privée.
Mais si les deux entités ne se connaissent pas encore elles ont un moyen de savoir avec certitude qu’une clé publique correspond à la clé privée de l’autre identité.
En d’autres termes, quand Alice parle à Bob, Bob dit à Alice “c’est ma clef publique K, utilise-la pour communiquer avec moi” Alice a besoin de savoir que c’est vraiment à Bob clé publique et non celle d’Eve.
La solution habituelle à ce problème consiste à utiliser une PKI.
Public Key Infrastructure - PKI
Une PKI est un arrangement qui lie des clés publiques à des identités au moyen d’une Autorité de certification (AC).
Une AC est un tiers de confiance centralisé dont la clé publique est déjà connue.
De cette façon, quand Alice parle à Bob, Bob montre à Alice un message signé par Trent, à qui Alice connaît et fait confiance, qui dit “cette clé publique K appartient à Bob”.
Ce message signé s’appelle un certificat et peut contenir d’autres informations.
Alice est capable de vérifier la signature à l’aide de la clé publique de Trent et peut savoir parler avec confiance à Bob.
Il est également courant d’avoir une chaîne de confiance. Alice parle à Bob, Trent le fait ne connaît pas Bob mais connaît Carol qui connaît Bob, alors Bob montre à Alice une chaîne de certificats, un de Carol indiquant quelle clé appartient à Bob et un de Trent qui dit quelle clé appartient à Carol. Même sans connaître Carol, Alice peut vérifier le certificat de Trent, être sûr de la clé de Carol et si sa confiance à Trent est transitif, alors elle peut aussi faire confiance à Carol pour savoir qui est Bob.
Note:
Il existe une solution intéressante pour l’authentification publique de la clé publique
l’information est le schéma web-of-trust, qui utilise des tiers
attestations de certificats auto-signés.
X.509
X.509 est une norme de l’Union internationale des télécommunications pour PKI. Il définit entre autres le format des certificats de clé publique. Défini sur ces RFC :
Un certificat numérique X.509 v3 a cette structure :
- Certificate
- Version
- Serial Number
- Algorithm ID
- Issuer
- Validity
- Not Before
- Not After
- Subject
- Subject public key info
- Issuer Unique Identifier (optional)
- Subject Unique Identifier (optional)
- Extensions (optional)
- ...
- Certificate Signature Algorithm
- Certificate Signature
Version, Serial, Algorithm ID and Validity
- Version - Indicates X.509 version. Should be 3 (value 0x2).
- Serial - Unique positive integer assigned by the CA to each certificate.
- Algorithm ID - Must be the same as the field “Certificate Signature Algorithm”
- Validity - Two dates that form the period when the certificate is valid.
Issuer and Subject
Chacun a un nom distinctif (DN), unique par autorité de certification. Un DN, décrit dans RFC1779, se compose d’une seule ligne avec ces valeurs:
- CN - CommonName
- L - LocalityName
- ST - StateOrProvinceName
- O - OrganizationName
- OU - OrganizationalUnitName
- C - CountryName
Example:
`C=PT, ST=Lisboa, L=Lisboa, O=Foo Org, OU=Bar Sector, CN=foo.org/emailAddress=admin@foo.org`
L’autorité de certification signataire peut ne pas exiger toutes les valeurs.
Lors de la connexion à un serveur HTTPS, les navigateurs vérifient la valeur CN et celle-ci
doit être conforme au domaine. Les certificats génériques commencent généralement par
un * dans le CN pour autoriser n’importe quel sous-domaine. e.g. CN=*.example.com
Notez que les navigateurs rejetteront le caractère générique pour le domaine nu, c’est-à-dire
example.com n’est pas conforme à *.example.com.
Cependant, un certificat peut être utilisé pour un serveur HTTPS qui répond sur plusieurs domaines différents.
Des domaines supplémentaires peuvent être spécifiés dans l’extension Subject Alternative Names.
Subject public key info
Contient l’algorithme de clé publique et ses paramètres spécifiques. par exemple.:
- algorithm: rsa encryption
- key size: 2048
- exponent: 0x10001
- modulus: 00:ec:82:3f:78:b6...
Issuer and Subject Unique Identifiers
Introduit dans la version 2 pour permettre la réutilisation des noms d’émetteur et de sujet.
Par exemple, supposons qu’une Authorité de Certification fasse faillite et que son nom soit supprimé de la liste publique du pays, après un certain temps, une autre AC portant le même nom peut s’enregistrer même si elle n’est pas liée à la première.
A mon hunble avis, tout cela est très idiot. Sans surprise, l’IETF recommande de ne pas réutiliser les noms d’émetteur et de sujet.
Extensions
Introduit dans la version 3. Une autorité de certification peut utiliser des extensions pour émettre un certificat uniquement dans un but précis, par exemple uniquement pour les serveurs http. Les extensions peuvent être critiques ou non critiques. Les non critiques peuvent être ignorées, tandis que critique doit être appliquée et l’ensemble du certificat doit être rejeté si le système ne reconnaît pas une extension critique.
Quelques extensions standards :
- Subject Key Identifier
- Authority Key Identifier
- Subject Alternative Name
- Basic Constraints
Authority and Subject Key Identifiers
Utilisé lorsqu’une entité possède plusieurs clés de signature. L’identité peut être vérifiée par le nom et le numéro de série ou par cette clé identifiant.
Un identifiant est le hachage SHA-1 160 bits de la clé publique, ou simplement le premier 60 bits précédés des bits 0100.
Subject Alternative Name
Peut contenir des noms DNS ou des adresses IP supplémentaires lorsque le certificat est valide, c’est-à-dire en plus de celui spécifié dans CN.
Basic Constraints
Si le sujet est un CA et éventuellement la longueur maximale de profondeur de parcours de certification.
Un cas concret
Supposons que nous ayons besoin d’un certificat signé pour un serveur HTTPS. Cela signifie que nous avons besoin d’un certificat pour le domaine (ou les domaines) où le serveur sera disponible.
Nous avons besoin d’un certificat que le navigateur peut vérifier et dire à l’utilisateur qu’il est sur les bons serveurs du domaine de l’URL qu’il a tapé et qu’une connexion sécurisée est établie.
Les navigateurs utilisent un magasin de certificats qui contient une liste d’autorités de certification. Pour vérifier votre vous pouvez aller dans les paramètres de votre navigateur, rechercher la section Certificats, peut-être que dans Sécurité ou Avancé, il devrait y avoir une sorte de gestionnaire de certificats.
Le magasin de certificats du navigateur doit comporter plusieurs sections, l’une d’elles, probablement vide est pour les certificats clients, puisque HTTPS peut également authentifier le client via des certificats, bien que cela ne soit pas utilisé sauf pour certains environnements d’entreprise très spécifiques. La section que vous souhaitez consulter est la section “Autorités” où l’autorité de certification les certificats sont stockés. Votre navigateur a très probablement des certificats de VeriSign, Comodo, GeoTrust, Microsoft, etc…
Nous avons donc besoin d’un certificat indiquant que notre clé appartient à notre domaine émis (signé) par l’une de ces entités. Ou nous pouvons aussi le faire émettre par un entité intermédiaire, celle qui a été autorisée par l’une des AC à émettre certificats.
Si vous effectuez une recherche sur le Web pour “certificats SSL”, vous trouverez de nombreux vendeurs de certificats numériques. Vous constaterez que les certificats « génériques » sont généralement un peu plus cher.
Wildcard certificates
Un certificat générique est un certificat qui peut être utilisé avec plusieurs sous-domaines d’un domaine.
Les navigateurs recherchent le CN (nom commun) dans le champ d’objet qui doit être un domaine ou un caractère générique comme *.example.com.
Les navigateurs accepteront un certificat avec CN *.example.org pour www.example.org, login.example.org ou bo.example.org. Mais le “nu”
domaine example.org ne fonctionnera pas.
Des domaines supplémentaires (y compris le domaine nu) peuvent être ajoutés dans l’extension “SubjectAltName”.
Pour vérifier cela, dirigez votre navigateur vers https://mozilla.org (ou un autre serveur HTTPS), puis cliquez sur l’icône de verrouillage avant l’URL, il devrait y avoir un moyen pour voir le certificat utilisé. Cochez le nom commun du sujet et le extension Nom alternatif du sujet.
OpenSSL
OpenSSL est une boîte à outils de cryptographie. Contient de nombreuses sous-commandes, chacune avec sa propre page de manuel, par ex. ca(1), req(1) , x509(1).
La plupart des outils d’OpenSSL traitent les paramètres -in et -out. Habituellement, vous pouvez également inspecter les fichiers en spécifiant -in <file> et -noout,
vous aussi spécifiez quelle partie du contenu vous intéresse, pour tout voir, utilisez -text. Exemples ci-dessous.
Generate Keys and Certificate Signing Request (CSR)
Générer une clé RSA pour la CA (Authorité de Certification):
$ openssl genrsa -out example.org.key 2048
Generating RSA private key, 2048 bit long modulus
.........................................+++
openssl genrsa est l’outil pour générer des clés rsa.
2048 est la taille de la clé.
Cela a créé un fichier example.org.key qui contient la clé privée.
Vous pouvez utiliser l’outil openssl rsa pour inspecter la clé.
$ openssl rsa -in example.org.key -noout -text
Private-Key: (2048 bit)
modulus:
00:ad:d8:71:1f:ab:a7:df:a6:c3:7e:d8:1f:fd:81:
b0:5a:a8:9d:51:2b:15:c2:98:95:9e:fe:3b:7c:bd:
...
publicExponent: 65537 (0x10001)
privateExponent:
7b:a9:ba:96:b7:c9:bb:eb:69:a7:62:60:27:39:c8:
d4:44:9b:5b:b0:d5:52:ce:ad:a8:22:da:f8:19:c2:
...
prime1:
00:d3:98:05:f5:49:48:11:f1:46:71:09:6c:b4:cb:
e6:3e:6f:a1:41:9a:36:43:c3:22:20:06:d1:aa:dd:
...
prime2:
00:d2:54:5e:cc:15:72:3d:5f:b2:64:ab:4f:42:a6:
15:79:ca:7a:e0:ef:dd:a7:f3:25:f2:f1:75:b2:33:
...
exponent1:
02:bf:5f:9c:6e:c6:2b:cd:79:3f:b0:82:a3:da:5d:
f4:03:99:11:74:02:2e:61:13:49:5d:2d:4d:cd:b1:
...
exponent2:
79:6c:c1:e9:9a:3c:00:98:9d:b9:a6:78:b4:a6:83:
61:73:76:ab:23:6f:58:c5:73:d4:24:77:e9:30:10:
...
coefficient:
17:53:93:4a:48:b0:63:9a:71:0e:37:fb:18:ad:be:
4e:d0:6e:af:6c:bc:7b:ff:44:c6:93:9a:23:03:51:
...
En option, la clé publique rsa peut être extraite de la clé privée:
$ openssl rsa -in example.org.key -pubout -out example.org.pubkey
$ openssl rsa -in example.org.pubkey -pubin -noout -text
Public-Key: (2048 bit)
Modulus:
00:ad:d8:71:1f:ab:a7:df:a6:c3:7e:d8:1f:fd:81:
b0:5a:a8:9d:51:2b:15:c2:98:95:9e:fe:3b:7c:bd:
...
Exponent: 65537 (0x10001)
Toute copie de la clé privée ne doit être aidée que par l’entité qui va être certifié. Cela signifie que la clé ne doit jamais être envoyée à quelqu’un d’autre,
y compris l’émetteur du certificat.
Nous générons maintenant une demande de signature de certificat qui contient certaines des informations que nous voulons être inclus dans le certificat.
Pour prouver la propriété de la clé privée, le CSR est signé avec le titulaire de la clé privée (subject's private key).
Générer un CSR (Certifcate Signing Request):
$ openssl req -new -key example.org.key -out example.org.csr
Vous êtes sur le point d’être invité à saisir des informations qui seront intégrées à votre demande de certificat.
Ce que vous êtes sur le point d’entrer est ce qu’on appelle un nom distinctif ou un DN (Distinguished Name).
Il y a pas mal de champs mais vous pouvez en laisser des vides
Pour certains champs, il y aura une valeur par défaut, Si vous entrez ‘.’, le champ sera laissé vide.
Country Name (2 letter code) [AU]:PT
State or Province Name (full name) [Some-State]:Lisboa
Locality Name (eg, city) []:Lisboa
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Example Org
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:*.example.org
Email Address []:
Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:
On peut alors jeter un œil au contenu du CSR :
$ openssl req -in example.org.csr -noout -text
Certificate Request:
Data:
Version: 0 (0x0)
Subject: C=PT, ST=Lisboa, L=Lisboa, O=Example Org, CN=*.example.org
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
Public-Key: (2048 bit)
Modulus:
00:ad:d8:71:1f:ab:a7:df:a6:c3:7e:d8:1f:fd:81:
b0:5a:a8:9d:51:2b:15:c2:98:95:9e:fe:3b:7c:bd:
...
Exponent: 65537 (0x10001)
Attributes:
a0:00
Signature Algorithm: sha1WithRSAEncryption
5d:f0:d4:d8:85:4c:e7:dd:6d:f2:bd:05:0f:57:8b:d8:0a:40:
09:10:ad:ab:cc:5b:a1:92:cb:5d:56:16:7f:0b:23:91:32:06:
...
Le certificat est ensuite envoyé à l’émetteur, et s’il approuve la demande une attestation doit être renvoyée.
Assurez-vous que votre algorithme de signature n’est pas MD5. Les anciennes configurations d’OpenSSL
ont default_md = md5 par défaut. Les navigateurs rejettent les certificats qui utilisent md5 comme algorithme de signature parce qu’il a été jugé non sécurisé.
Notez qu’il n’y a pas d’extensions, pour ajouter des extensions un fichier de configuration supplémentaire est nécessaire. Cela rend le processus un peu plus compliqué, donc lorsque vous achetez un certificat générique, vous n’avez généralement pas besoin de spécifier l’extension SubjectAltName pour le domaine nu car l’émetteur le fera pour vous.
Voici un exemple de fichier de configuration pour un CSR :
# The main section is named req because the command we are using is req
# (openssl req ...)
[ req ]
# This specifies the default key size in bits. If not specified then 512 is
# used. It is used if the -new option is used. It can be overridden by using
# the -newkey option.
default_bits = 2048
# This is the default filename to write a private key to. If not specified the
# key is written to standard output. This can be overridden by the -keyout
# option.
default_keyfile = oats.key
# If this is set to no then if a private key is generated it is not encrypted.
# This is equivalent to the -nodes command line option. For compatibility
# encrypt_rsa_key is an equivalent option.
encrypt_key = no
# This option specifies the digest algorithm to use. Possible values include
# md5 sha1 mdc2. If not present then MD5 is used. This option can be overridden
# on the command line.
default_md = sha1
# if set to the value no this disables prompting of certificate fields and just
# takes values from the config file directly. It also changes the expected
# format of the distinguished_name and attributes sections.
prompt = no
# if set to the value yes then field values to be interpreted as UTF8 strings,
# by default they are interpreted as ASCII. This means that the field values,
# whether prompted from a terminal or obtained from a configuration file, must
# be valid UTF8 strings.
utf8 = yes
# This specifies the section containing the distinguished name fields to
# prompt for when generating a certificate or certificate request.
distinguished_name = my_req_distinguished_name
# this specifies the configuration file section containing a list of extensions
# to add to the certificate request. It can be overridden by the -reqexts
# command line switch. See the x509v3_config(5) manual page for details of the
# extension section format.
req_extensions = my_extensions
[ my_req_distinguished_name ]
C = PT
ST = Lisboa
L = Lisboa
O = Oats In The Water
CN = *.oats.org
[ my_extensions ]
basicConstraints=CA:FALSE
subjectAltName=@my_subject_alt_names
subjectKeyIdentifier = hash
[ my_subject_alt_names ]
DNS.1 = *.oats.org
DNS.2 = *.oats.net
DNS.3 = *.oats.in
DNS.4 = oats.org
DNS.5 = oats.net
DNS.6 = oats.in
Notez les différents noms DNS. Étant donné que l’analyseur de configuration ne permet pas
plusieurs valeurs pour le même nom, nous utilisons le @my_subject_alt_names et
DNS.# avec des numéros différents.
Avec cette configuration, nous pouvons créer un CSR avec les extensions appropriées :
$ openssl req -new -out oats.csr -config oats.conf
Generating a 2048 bit RSA private key
.............+++
....................................+++
writing new private key to 'oats.key'
-----
Parce que nous n’avons pas spécifié de clé, OpenSSL utilise les informations de notre configuration (default_bits et default_keyfile) pour en créer un.
Voyons le résultat :
$ openssl req -in oats.csr -noout -text
Certificate Request:
Data:
Version: 0 (0x0)
Subject: C=PT, ST=Lisboa, L=Lisboa, O=Oats In The Water, CN=*.oats.org
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
Public-Key: (2048 bit)
Modulus:
00:a2:58:fc:57:32:4d:40:aa:62:92:65:86:1d:6b:
4f:3e:11:a6:b5:36:f2:48:d2:23:2a:8f:bb:a0:a4:
...
Exponent: 65537 (0x10001)
Attributes:
Requested Extensions:
X509v3 Basic Constraints:
CA:FALSE
X509v3 Subject Alternative Name:
DNS:*.oats.org, DNS:*.oats.net, DNS:*.oats.in, DNS:oats.org, DNS:oats.net, DNS:oats.in
X509v3 Subject Key Identifier:
C6:0E:59:B3:1A:FF:1A:A2:FF:F3:DC:76:21:F0:92:FC:57:88:05:6D
Signature Algorithm: sha1WithRSAEncryption
0d:45:6c:21:65:20:72:68:30:91:5f:fa:b8:c3:62:a0:66:a2:
96:6f:76:4a:ba:ca:e3:1d:9e:eb:47:d4:93:87:88:83:a2:f5:
...
Maintenant, nous pouvons voir qu’il y a une section Request Extensions avec notre convoité Champ Subject Alternative Name.
Une autorité de certification peut toujours supprimer ces champs ou les remplacer lors de l’émission de votre certificat.
Les inclure dans votre CSR ne garantit pas qu’ils seront dans le certificat final.
CA Key and self-signed Certificate
Jouons maintenant la partie CA. Générez une clé pour le sujet. C’est la même chose que nous avons fait pour notre sujet.
$ openssl genrsa -out ca.key 2048
Generating RSA private key, 2048 bit long modulus
......................................................+++
.......+++
e is 65537 (0x10001)
Générez un certificat auto-signé pour l’autorité de certification (CA) :
$ openssl req -new -x509 -key ca.key -out ca.crt
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]:PT
State or Province Name (full name) [Some-State]:Lisboa
Locality Name (eg, city) []:Lisboa
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Sz CA
Organizational Unit Name (eg, section) []:SZ CA
Common Name (e.g. server FQDN or YOUR name) []:
Email Address []:An optional company name []:
OpenSSL utilise les informations que vous spécifiez pour compiler un certificat X.509 à l’aide des informations demandées à l’utilisateur,
la clé publique qui est extraite de la clé privée spécifiée qui est également utilisée pour générer la signature.
Si nous souhaitons inclure des extensions dans le certificat auto-signé, nous pourrions utiliser un fichier de configuration comme nous l’avons fait pour le CSR mais nous utiliserions x509_extensions au lieu de req_extensions.
Signing
Voici un moyen très simple de signer un certificat :
$ openssl x509 -req -in example.org.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out example.org.crt
Signature ok
subject=/C=PT/ST=Lisboa/L=Lisboa/O=Example Org/CN=*.example.org
Getting CA Private Key
Chaque certificat émis doit contenir un numéro de série unique attribué par l’AC.
Il doit être unique pour chaque certificat délivré par une autorité de certification donnée.
OpenSSL conserve les numéros de série utilisés dans un fichier, par défaut il a le même nom que le fichier de certificat CA avec l’extension a remplacer par srl.
Ainsi, un fichier nommé ca.srl est créé :
$ cat ca.srl
ED4B4A80662B1B4C
Cette commande produit le fichier example.org.crt que nous pouvons examiner :
$ openssl x509 -in example.org.crt -noout -text
Certificate:
Data:
Version: 1 (0x0)
Serial Number: 17098842325572590412 (0xed4b4a80662b1b4c)
Signature Algorithm: sha1WithRSAEncryption
Issuer: C=PT, ST=Lisboa, L=Lisboa, O=Sz CA, OU=SZ CA
Validity
Not Before: Mar 20 22:46:43 2014 GMT
Not After : Apr 19 22:46:43 2014 GMT
Subject: C=PT, ST=Lisboa, L=Lisboa, O=Example Org, CN=*.example.org
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
Public-Key: (2048 bit)
Modulus:
00:ad:d8:71:1f:ab:a7:df:a6:c3:7e:d8:1f:fd:81:
b0:5a:a8:9d:51:2b:15:c2:98:95:9e:fe:3b:7c:bd:
Exponent: 65537 (0x10001)
Signature Algorithm: sha1WithRSAEncryption
05:21:5c:0f:4c:3c:9a:76:7f:3f:fb:fa:e0:09:03:05:c5:16:
bf:4b:ac:60:d8:86:fc:b2:42:3e:5e:19:45:2a:e2:01:83:67:
Remarquez le numéro de série, en hexadécimal est exactement le contenu du fichier créé portant le nom ca.srl.
J’ai ensuite configuré un serveur https en utilisant le certificat et la clé sur le port 1443 en utilisant bud. Bud est un terminateur TLS, c’est-à-dire qu’il extrait les connexions https entrantes et les proxies dans un serveur principal en tant que simple http. J’ai forwardé les connexions des buds vers un serveur http statique avec un index.html très simple.
J’ai également ajouté la ligne 127.0.0.1 www.example.org à mon /etc/hosts pour faire en sorte que la machine résolve le domaine sur l’adresse de loopback.
J’ai ensuite pointé mon navigateur vers https://www.example.org:1443/. Le navigateur s’est immédiatement plaint que le certificat était invalide car il n’incluait pas
la chaîne de signature. Cela signifie que le certificat indique que l’entité C=PT, ST=Lisboa, L=Lisboa, O=Example Org, CN=*.example.org est certifié par
l’entité C=PT, ST=Lisboa, L=Lisboa, O=Sz CA, OU=SZ CA mais il n’y a pas des informations sur la personne qui certifie cette deuxième entité, et puisque l’entité n’est pas
connu du navigateur, le certificat est réputé invalide.
Une chose que nous pouvons faire est de créer un autre fichier contenant le certificat de example.org et le certificat de la CA.
$ cat example.org.crt ca.crt > example.org.bundle.crt
Aprés ça, mon navigateur, Firefox, a toujours rejeté le certificat, mais maintenant avec un message différent. Maintenant, il se plaignait que le SZ CA n’était pas un entité de confiance.
J’ai donc ouvert les paramètres de mon navigateur et ajouté le certificat de la CA dans la Section Autorités dans le magasin de certificats.
Et maintenant ça marche !
Eh bien… Le navigateur ne donne aucun avertissement. Mais il ne montre pas l’icone vert que vous avez probablement déjà l’habitude de voir
Cela est dû à la validation étendue, une extension que nous n’avons pas incluse dans le certificat qui exige généralement que l’autorité de certification vérifie l’identification légale du sujet. Juste pour vérifier, on peut demander au navigateur d’exporter le certificat dans un fichier que nous pouvons interroger avec openssl :
$ openssl x509 -in github.com.crt -noout -text
Certificate:
Data:
Version: 3 (0x2)
Serial Number:
04:7f:be:2e:4b:de:00:84:d2:ca:f8:e3:ec:fe:70:58
Signature Algorithm: sha1WithRSAEncryption
Issuer: C=US, O=DigiCert Inc, OU=www.digicert.com, CN=DigiCert High Assurance EV CA-1
Validity
Not Before: Jun 10 00:00:00 2013 GMT
Not After : Sep 2 12:00:00 2015 GMT
Subject: businessCategory=Private Organization/1.3.6.1.4.1.311.60.2.1.3=US/1.3.6.1.4.1.311.60.2.1.2=Delaware/serialNumber=5157550/street=548 4th Street/postalCode=94107, C=US, ST=California, L=San Francisco, O=GitHub, Inc., CN=github.com
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
Public-Key: (2048 bit)
Modulus:
00:ed:d3:89:c3:5d:70:72:09:f3:33:4f:1a:72:74:
d9:b6:5a:95:50:bb:68:61:9f:f7:fb:1f:19:e1:da:
...
Exponent: 65537 (0x10001)
X509v3 extensions:
X509v3 Authority Key Identifier:
keyid:4C:58:CB:25:F0:41:4F:52:F4:28:C8:81:43:9B:A6:A8:A0:E6:92:E5
X509v3 Subject Key Identifier:
87:D1:8F:19:6E:E4:87:6F:53:8C:77:91:07:50:DF:A3:BF:55:47:20
X509v3 Subject Alternative Name:
DNS:github.com, DNS:www.github.com
X509v3 Key Usage: critical
Digital Signature, Key Encipherment
X509v3 Extended Key Usage:
TLS Web Server Authentication, TLS Web Client Authentication
X509v3 CRL Distribution Points:
Full Name:
URI:http://crl3.digicert.com/evca1-g2.crl
Full Name:
URI:http://crl4.digicert.com/evca1-g2.crl
X509v3 Certificate Policies:
Policy: 2.16.840.1.114412.2.1
CPS: http://www.digicert.com/ssl-cps-repository.htm
User Notice:
Explicit Text:
Authority Information Access:
OCSP - URI:http://ocsp.digicert.com
CA Issuers - URI:http://cacerts.digicert.com/DigiCertHighAssuranceEVCA-1.crt
X509v3 Basic Constraints: critical
CA:FALSE
Signature Algorithm: sha1WithRSAEncryption
5f:15:6d:67:c3:3a:d5:a3:de:16:9c:45:33:26:d5:3d:c9:16:
74:34:ca:87:48:1b:14:90:6d:f5:ab:47:86:b9:f5:b8:e3:01:
...
L’extension pertinente pour Extended Validation (EV) est Certificate Policies.
Les vendeurs de certificats refuseront d’émettre des certificats génériques avec EV, car cabforum.org, l’organisme de réglementation régissant l’émission de certificats SSL EV
décidé que c’est un grand non non. Les certificats EV peuvent cependant avoir autant SubjectAltName comme vous le souhaitez.
openssl ca
Vous pouvez également signer des CSR avec le ca(1).
Nous avons d’abord besoin d’un fichier de configuration ca.conf :
# we use 'ca' as the default section because we're usign the ca command
# we use 'ca' as the default section because we're usign the ca command
[ ca ]
default_ca = my_ca
[ my_ca ]
# a text file containing the next serial number to use in hex. Mandatory.
# This file must be present and contain a valid serial number.
serial = ./serial
# the text database file to use. Mandatory. This file must be present though
# initially it will be empty.
database = ./index.txt
# specifies the directory where new certificates will be placed. Mandatory.
new_certs_dir = ./newcerts
# the file containing the CA certificate. Mandatory
certificate = ./ca.crt
# the file contaning the CA private key. Mandatory
private_key = ./ca.key
# the message digest algorithm. Remember to not use MD5
default_md = sha1
# for how many days will the signed certificate be valid
default_days = 365
# a section with a set of variables corresponding to DN fields
policy = my_policy
[ my_policy ]
# if the value is "match" then the field value must match the same field in the
# CA certificate. If the value is "supplied" then it must be present.
# Optional means it may be present. Any fields not mentioned are silently
# deleted.
countryName = match
stateOrProvinceName = supplied
organizationName = supplied
commonName = supplied
organizationalUnitName = optional
commonName = supplied
[ ca ]
default_ca = my_ca
[ my_ca ]
# a text file containing the next serial number to use in hex. Mandatory.
# This file must be present and contain a valid serial number.
serial = ./serial
# the text database file to use. Mandatory. This file must be present though
# initially it will be empty.
database = ./index.txt
# specifies the directory where new certificates will be placed. Mandatory.
new_certs_dir = ./newcerts
# the file containing the CA certificate. Mandatory
certificate = ./ca.crt
# the file contaning the CA private key. Mandatory
private_key = ./ca.key
# the message digest algorithm. Remember to not use MD5
default_md = sha1
# for how many days will the signed certificate be valid
default_days = 365
# a section with a set of variables corresponding to DN fields
policy = my_policy
[ my_policy ]
# if the value is "match" then the field value must match the same field in the
# CA certificate. If the value is "supplied" then it must be present.
# Optional means it may be present. Any fields not mentioned are silently
# deleted.
countryName = match
stateOrProvinceName = supplied
organizationName = supplied
commonName = supplied
organizationalUnitName = optional
commonName = supplied
N’oubliez pas que vous pouvez utiliser man ca non seulement pour voir des détails sur les options et les commandes, mais aussi sur les sections de configuration ainsi que les paramètres correspondants.
Nous devons d’abord mettre en place une structure. Le fichier de configuration attend un répertoire newcerts et les fichiers index.txt et serial :
$ mkdir newcerts
$ touch index.txt
$ echo '01' > serial
Et maintenant nous pouvons enfin signer le certificat :
$ openssl ca -config ca.cnf -out example.org.crt -infiles example.org.csr
Using configuration from ca.cnf
Check that the request matches the signature
Signature ok
The Subject's Distinguished Name is as follows
countryName :PRINTABLE:'PT'
stateOrProvinceName :ASN.1 12:'Lisboa'
localityName :ASN.1 12:'Lisboa'
organizationName :ASN.1 12:'Example Org'
commonName :ASN.1 12:'*.example.org'
Certificate is to be certified until Mar 21 01:13:36 2015 GMT (365 days)
Sign the certificate? [y/n]:y
1 out of 1 certificate requests certified, commit? [y/n]y
Write out database with 1 new entries
Data Base Updated
Si nous souhaitons ajouter des extensions, voire conserver les extensions envoyées dans un CSR
(openssl les supprimera lors de la signature), alors nous devons également inclure cette configuration.
Ceci est un fichier de configuration supplémentaire oats.extensions.cnf :
basicConstraints=CA:FALSE
subjectAltName=@my_subject_alt_names
subjectKeyIdentifier = hash
[ my_subject_alt_names ]
DNS.1 = *.oats.org
DNS.2 = *.oats.net
DNS.3 = *.oats.in
DNS.4 = oats.org
DNS.5 = oats.net
DNS.6 = oats.in
Et maintenant:
$ openssl ca -config ca.cnf -out oats.crt -extfile oats.extensions.cnf -in oats.csr
Using configuration from ca.cnf
Check that the request matches the signature
Signature ok
The Subject's Distinguished Name is as follows
countryName :PRINTABLE:'PT'
stateOrProvinceName :PRINTABLE:'Lisboa'
localityName :PRINTABLE:'Lisboa'
organizationName :PRINTABLE:'Oats In The Water'
commonName :T61STRING:'*.oats.org'
Certificate is to be certified until Mar 21 01:43:11 2015 GMT (365 days)
Sign the certificate? [y/n]:y
1 out of 1 certificate requests certified, commit? [y/n]y
Write out database with 1 new entries
Data Base Updated
Nous avons un certificat qui inclut les SubjectAltNames que nous voulions :
$ openssl x509 -in oats.crt -noout -text
Certificate:
Data:
Version: 3 (0x2)
Serial Number: 2 (0x2)
Signature Algorithm: sha1WithRSAEncryption
Issuer: C=PT, ST=Lisboa, L=Lisboa, O=Sz CA, OU=SZ CA
Validity
Not Before: Mar 21 01:43:11 2014 GMT
Not After : Mar 21 01:43:11 2015 GMT
Subject: C=PT, ST=Lisboa, O=Oats In The Water, CN=*.oats.org
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
Public-Key: (2048 bit)
Modulus:
00:a2:58:fc:57:32:4d:40:aa:62:92:65:86:1d:6b:
4f:3e:11:a6:b5:36:f2:48:d2:23:2a:8f:bb:a0:a4:
...
Exponent: 65537 (0x10001)
X509v3 extensions:
X509v3 Basic Constraints:
CA:FALSE
X509v3 Subject Alternative Name:
DNS:*.oats.org, DNS:*.oats.net, DNS:*.oats.in, DNS:oats.org, DNS:oats.net, DNS:oats.in
X509v3 Subject Key Identifier:
C6:0E:59:B3:1A:FF:1A:A2:FF:F3:DC:76:21:F0:92:FC:57:88:05:6D
Signature Algorithm: sha1WithRSAEncryption
89:7e:7d:67:1e:98:85:78:a1:f2:81:4c:b4:8c:f9:80:cd:47:
a9:94:94:a3:f0:dd:36:d3:e3:48:93:77:4a:31:16:03:79:9c:
...
Nous pouvons vérifier que le certificat est correct :
$ openssl verify -CAfile ca.crt oats.crt
oats.crt: OK
That is all
Je sais qu’il y a beaucoup de choses que je n’ai pas couvertes, des choses importantes comme les CRL.