$ openssl version
OpenSSL 0.9.8o 01 Jun 2010

$ openssl version -a
OpenSSL 0.9.8o 01 Jun 2010
built on: Mon Feb 11 21:27:58 UTC 2013
platform: debian-i386-i686/cmov
options:  bn(64,32) md2(int) rc4(idx,int) des(ptr,risc1,16,long) blowfish(idx)
compiler: gcc -fPIC -DOPENSSL_PIC -DZLIB -DOPENSSL_THREADS -D_REENTRANT -DDSO_DLFCN -DHAVE_DLFCN_H -DL_ENDIAN -DTERMIO -O3 -march=i686 -Wa,--noexecstack -g -Wall -DOPENSSL_BN_ASM_PART_WORDS -DOPENSSL_IA32_SSE2 -DSHA1_ASM -DMD5_ASM -DRMD160_ASM -DAES_ASM
OPENSSLDIR: "/usr/lib/ssl"
$

$ openssl help
openssl:Error: 'help' is an invalid command.
 
Standard commands
asn1parse      ca             ciphers        crl            crl2pkcs7
dgst           dh             dhparam        dsa            dsaparam
ec             ecparam        enc            engine         errstr
gendh          gendsa         genrsa         nseq           ocsp
passwd         pkcs12         pkcs7          pkcs8          prime
rand           req            rsa            rsautl         s_client
s_server       s_time         sess_id        smime          speed
spkac          verify         version        x509
 
Message Digest commands (see the `dgst' command for more details)
md2            md4            md5            rmd160         sha
sha1
 
Cipher commands (see the `enc' command for more details)
aes-128-cbc    aes-128-ecb    aes-192-cbc    aes-192-ecb    aes-256-cbc
aes-256-ecb    base64         bf             bf-cbc         bf-cfb
bf-ecb         bf-ofb         cast           cast-cbc       cast5-cbc
cast5-cfb      cast5-ecb      cast5-ofb      des            des-cbc
des-cfb        des-ecb        des-ede        des-ede-cbc    des-ede-cfb
des-ede-ofb    des-ede3       des-ede3-cbc   des-ede3-cfb   des-ede3-ofb
des-ofb        des3           desx           rc2            rc2-40-cbc
rc2-64-cbc     rc2-cbc        rc2-cfb        rc2-ecb        rc2-ofb

Comme indiqué, il est possible d'afficher les détails des sous-commandes dgst et enc.

$ openssl dgst -h
unknown option '-h'
options are
-c              to output the digest with separating colons
-d              to output debug info
-hex            output as hex dump
-binary         output in binary form
-sign   file    sign digest using private key in file
-verify file    verify a signature using public key in file
-prverify file  verify a signature using private key in file
-keyform arg    key file format (PEM or ENGINE)
-signature file signature to verify
-binary         output in binary form
-hmac key       create hashed MAC with key
-engine e       use engine e, possibly a hardware device.
-md5            to use the md5 message digest algorithm (default)
-md4            to use the md4 message digest algorithm
-md2            to use the md2 message digest algorithm
-sha1           to use the sha1 message digest algorithm
-sha            to use the sha message digest algorithm
-sha224         to use the sha224 message digest algorithm
-sha256         to use the sha256 message digest algorithm
-sha384         to use the sha384 message digest algorithm
-sha512         to use the sha512 message digest algorithm
-mdc2           to use the mdc2 message digest algorithm
-ripemd160      to use the ripemd160 message digest algorithm

$ openssl enc -h
unknown option '-h'
options are
-in <file>     input file
-out <file>    output file
-pass <arg>    pass phrase source
-e             encrypt
-d             decrypt
-a/-base64     base64 encode/decode, depending on encryption flag
-k             passphrase is the next argument
-kfile         passphrase is the first line of the file argument
-md            the next argument is the md to use to create a key
                 from a passphrase.  One of md2, md5, sha or sha1
-K/-iv         key/iv in hex is the next argument
-[pP]          print the iv/key (then exit if -P)
-bufsize <n>   buffer size
-engine e      use engine e, possibly a hardware device.
Cipher Types
-aes-128-cbc               -aes-128-cfb               -aes-128-cfb1
-aes-128-cfb8              -aes-128-ecb               -aes-128-ofb
-aes-192-cbc               -aes-192-cfb               -aes-192-cfb1
-aes-192-cfb8              -aes-192-ecb               -aes-192-ofb
-aes-256-cbc               -aes-256-cfb               -aes-256-cfb1
-aes-256-cfb8              -aes-256-ecb               -aes-256-ofb
-aes128                    -aes192                    -aes256
-bf                        -bf-cbc                    -bf-cfb
-bf-ecb                    -bf-ofb                    -blowfish
-cast                      -cast-cbc                  -cast5-cbc
-cast5-cfb                 -cast5-ecb                 -cast5-ofb
-des                       -des-cbc                   -des-cfb
-des-cfb1                  -des-cfb8                  -des-ecb
-des-ede                   -des-ede-cbc               -des-ede-cfb
-des-ede-ofb               -des-ede3                  -des-ede3-cbc
-des-ede3-cfb              -des-ede3-cfb1             -des-ede3-cfb8
-des-ede3-ofb              -des-ofb                   -des3
-desx                      -desx-cbc                  -rc2
-rc2-40-cbc                -rc2-64-cbc                -rc2-cbc
-rc2-cfb                   -rc2-ecb                   -rc2-ofb
-rc4                       -rc4-40

L'option speed permet de tester les capacités du sytème pour encrypter des données avec les différents algorithmes de cryptage pendant une période donnée.

$ openssl speed
Doing md2 for 3s on 16 size blocks: 149573 md2's in 2.54s
Doing md2 for 3s on 64 size blocks: 82254 md2's in 2.74s
Doing md2 for 3s on 256 size blocks: 26039 md2's in 2.58s
Doing md2 for 3s on 1024 size blocks: 8149 md2's in 2.93s
Doing md2 for 3s on 8192 size blocks: 1072 md2's in 2.99s
Doing md4 for 3s on 16 size blocks: 3651107 md4's in 2.87s
Doing md4 for 3s on 64 size blocks: 3393515 md4's in 3.00s
Doing md4 for 3s on 256 size blocks: 2340602 md4's in 2.99s
Doing md4 for 3s on 1024 size blocks: 1045777 md4's in 3.00s
Doing md4 for 3s on 8192 size blocks: 167900 md4's in 2.96s
Doing md5 for 3s on 16 size blocks: 3080791 md5's in 2.99s
Doing md5 for 3s on 64 size blocks: 2599131 md5's in 3.00s
Doing md5 for 3s on 256 size blocks: 1577068 md5's in 2.87s
Doing md5 for 3s on 1024 size blocks: 666677 md5's in 2.99s
Doing md5 for 3s on 8192 size blocks: 102011 md5's in 2.99s
...

Pour l'exemple, mon système est capable d'encrypter 666 677 fichiers de 1024 octets en 3s maximum.

Il est possible d'effectuer le test sur un algorithme précis :

$ openssl speed sha256
Doing sha256 for 3s on 16 size blocks: 1626266 sha256's in 2.94s
Doing sha256 for 3s on 64 size blocks: 958515 sha256's in 3.00s
Doing sha256 for 3s on 256 size blocks: 415732 sha256's in 2.99s
Doing sha256 for 3s on 1024 size blocks: 127673 sha256's in 2.99s
Doing sha256 for 3s on 8192 size blocks: 16527 sha256's in 2.87s
OpenSSL 0.9.8o 01 Jun 2010
built on: Mon Feb 11 21:27:58 UTC 2013
options:bn(64,32) md2(int) rc4(idx,int) des(ptr,risc1,16,long) aes(partial) blowfish(idx)
compiler: gcc -fPIC -DOPENSSL_PIC -DZLIB -DOPENSSL_THREADS -D_REENTRANT -DDSO_DLFCN -DHAVE_DLFCN_H -DL_ENDIAN -DTERMIO -O3 -march=i686 -Wa,--noexecstack -g -Wall -DOPENSSL_BN_ASM_PART_WORDS -DOPENSSL_IA32_SSE2 -DSHA1_ASM -DMD5_ASM -DRMD160_ASM -DAES_ASM
available timing options: TIMES TIMEB HZ=100 [sysconf value]
timing function used: times
The 'numbers' are in 1000s of bytes per second processed.
type             16 bytes     64 bytes    256 bytes   1024 bytes   8192 bytes
sha256            8850.43k    20448.32k    35594.45k    43724.80k    47173.93k

Il est possible également de tester les performances SSL d'un serveur distant :

$ openssl s_time -connect google.fr:443 -www / -new -ssl3
No CIPHER specified
Collecting connection statistics for 30 seconds
333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
 
186 connections in 0.20s; 930.00 connections/user sec, bytes read 183024
186 connections in 31 real seconds, 984 bytes read per connection

Il est possible également de simuler un serveur SSL pour effectuer le test de performance :

1 - Générer un certificat pour le serveur simulé (répondre aux questions posées)

$ openssl req -x509 -nodes -days 365 -newkey rsa:4096 -keyout cert.pem -out cert.pem

2 - Démarrage du serveur simulé

$ openssl s_server -cert cert.pem -www

3 - Dans un autre terminal, tester les performances du serveur simulé

$ openssl s_time -connect localhost:4433 -www / -new -ssl3
No CIPHER specified
Collecting connection statistics for 30 seconds
333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333...
33333333333333333333333333
 
3301 connections in 6.07s; 543.82 connections/user sec, bytes read 8506677
3301 connections in 31 real seconds, 2577 bytes read per connection

Pour encoder une chaîne de caractères en base64, utiliser la commande suivante :

$ echo -n "ceci est mon mot de passe" | openssl base64
Y2VjaSBlc3QgbW9uIG1vdCBkZSBwYXNzZQ==

Pour encoder une chaîne de caractères en md5, utiliser la commande suivante :

$ echo -n 'ceci est un mot de passe' | openssl md5
7c1cc4a1a08c9352b50151dfa5d6edf3

Encodage en BASE64

Encoder le contenu d'un fichier sur la sortie standard :

$ cat fic1
systèmes
$ openssl enc -base64 -in fic1
c3lzdMOobWVzCg==

Encoder le contenu d'un fichier et écrire le résultat dans un autre fichier :

$ openssl enc -base64 -in fic1 -out fic1.enc
$ cat fic1.enc
c3lzdMOobWVzCg==

Encoder une chaine de caractères :

$ echo -n "secret" | openssl enc -base64
c2VjcmV0

Ne pas oublier d'ajouter l'option -n à la commande echo sinon un retour chariot sera ajouté à la chaine encodée.

Décoder une chaine de caractères :

$ echo "c2VjcmV0" | openssl enc -base64 -d
secret

Décoder le contenu d'un fichier sur la sortie standard :

$ openssl enc -base64 -in fic1.enc -d
systèmes

Décoder le contenu d'un fichier et écrire le résultat dans un autre fichier :

$ openssl enc -base64 -d -in fic1.enc -out fic1.dec
$ cat fic1.dec
systèmes

Chiffrer un fichier avec un algorithme de chiffrement et un mot de passe

1 - Choisir un algorithme de chiffrement :

$ openssl list-cipher-commands

Voir également la page de manuel de la commande enc.

2 - Chiffrer un fichier avec l'algorithme DES3 et écrire le contenu dans un autre fichier (génération d'un fichier binaire) :

$ openssl enc -des3 -salt -in fic1 -out fic1.des3
enter des-ede3-cbc encryption password:
Verifying - enter des-ede3-cbc encryption password:
$ cat fic1.des3
Salted__d▒j▒G(▒▒r▒d}▒i▒7▒▒▒▒M▒#

Pour le déchiffrage (indication du mot de passe avec l'option -pass) :

$ openssl enc -des3 -d -salt -in fic1.des3 -out file.txt -pass pass:aaaa
$ cat file.txt
systèmes

Chiffrage DES3 mais avec un encodage en BASE64 (pour un envoi par mail par exemple) :

$ openssl enc -des3 -a -salt -in fic1 -out fic1.des3
enter des-ede3-cbc encryption password:
Verifying - enter des-ede3-cbc encryption password:
$ cat fic1.des3
U2FsdGVkX1/Cl8Jr0Aw/3eDLegGPc7meTjWbUQZcNkw=

Pour le déchiffrage :

$ openssl enc -des3 -d -a -salt -in fic1.des3 -out file.txt
enter des-ede3-cbc decryption password:
$ cat file.txt
systèmes

Pour chiffrer un fichier en indiquant le mot de passe dans la ligne de commande (avec l'option -pass) :

$ openssl enc -des3 -salt -in fic1 -out fic1.des3 -pass pass:aaaa

Pour déchiffrer un fichier en indiquant le mot de passe dans un fichier :

$ openssl enc -des3 -salt -in fic1 -out fic1.des3 -pass file:/root/pass

Dans ce cas, seule la première ligne du fichier est utilisée comme mot de passe ou phrase de passe.

Pour afficher la clé de contrôle d'un fichier, il suffit d'utiliser la sous-commande dgst suivi de l'algorithme voulu.

$ openssl dgst -md5 /var/log/syslog
MD5(/var/log/syslog)= 16973fc98773afeea8b0c9c3be3ab677
$ openssl dgst -sha1 /var/log/syslog
SHA1(/var/log/syslog)= 3b0634f6793d5ed1a6260a585ea92d22badc2070

Il existe également une commande propre à chaque algorithme et qui retourne le même résultat :

$ md5sum /var/log/syslog
16973fc98773afeea8b0c9c3be3ab677  /var/log/syslog
$ sha1sum /var/log/syslog
3b0634f6793d5ed1a6260a585ea92d22badc2070  /var/log/syslog

Il est possible également de signer la clé de contrôle d'un fichier à l'aide d'une clé privée afin d'éviter toute modification sans permission :

Génération du fichier syslog.sha1 contenant la clé de contrôle et sécurisé par une clé privée (mykey2.pem).

Cliquez ici pour la génération des clés.

$ openssl dgst -sha1 -sign mykey2.pem -out syslog.sha1 /var/log/syslog

Il ne faut pas oublier de distribuer avec le fichier contenant la clé de contrôle (syslog.sha1) le fichier contenant la clé publique correspondant à la clé privée utilisée (pubkey.pem).

Par contre, ce qu'il ne faut surtout pas faire : distribuer sa clé privée (mykey2.pem).
Il faut la garder bien au chaud dans un endroit bien secret.

Pour la vérification de la clé de contrôle sécurisée, il suffit d'utiliser la commande suivante en y indiquant la clé publique correspondante à la clé privée utilisée lors de la génération de la clé de contrôle sécurisée.

$ openssl dgst -sha1 -verify pubkey.pem -signature syslog.sha1 /var/log/syslog
Verified OK

Pour exporter un certificat PEM au format PKCS#12 :

1 - Générer le certificat au format PEM :

$ openssl req -x509 -nodes -days 365 -subj '/C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com' -newkey rsa:1024 -keyout mycert.pem -out mycert.pem
Generating a 1024 bit RSA private key
...........++++++
............++++++
writing new private key to 'mycert.pem'
-----

2 - Exporter le certificat au format PKCS#12 :

$ openssl pkcs12 -export -out mycert.pfx -in mycert.pem -name "My Certificate"

Renseigner un phrase de passe si nécessaire.

Convertir un certificat PKCS#12 au format PEM :

$ openssl pkcs12 -in mycert.pfx -out mycert2.pem -nodes

Saisir la phrase de passe si nécessaire.

Pour protéger la clé privée à l'aide d'une phrase de passe :

$ openssl pkcs12 -in mycert.pfx -out mycert2.pem

La saisie d'une phrase de passe pour la protection de la clé privée est obligatoire.

La commande suivante affiche toutes les informations du certificat indiqué :

$ openssl x509 -text -in mycert.pem

Qui a émis le certificat ?

$ openssl x509 -noout -in mycert.pem -issuer
issuer= /C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com

Pour qui a-t-il été émis ?

$ openssl x509 -noout -in mycert.pem -subject
subject= /C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com

Quelle est sa période de validité ?

$ openssl x509 -noout -in mycert.pem -dates
notBefore=Apr  9 15:28:28 2013 GMT
notAfter=Apr  9 15:28:28 2014 GMT

Toutes les infos précédentes :

$ openssl x509 -noout -in mycert.pem -issuer -subject -dates
issuer= /C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com
subject= /C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com
notBefore=Apr  9 15:28:28 2013 GMT
notAfter=Apr  9 15:28:28 2014 GMT

Quelle est sa valeur de hachage ?

$ openssl x509 -noout -in mycert.pem -hash
bf163efd

Quelle est son empreinte MD5 ?

$ openssl x509 -noout -in mycert.pem -fingerprint
SHA1 Fingerprint=C1:CD:DD:29:D1:8D:23:63:6D:3F:71:AD:7E:29:DE:26:FF:D4:11:17

Et à partir d'un certificat d'un site internet (plus de détail openssl : Récupérer un certificat distant)

$ echo | openssl s_client -connect quennec.fr:443 2>&1 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' | openssl x509 -text -noout -in -

Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            04:f8:64:c9:8c:bb:f8:c9:6a:fd:3f:b9:b2:42:a0:c5:9c:ab
        Signature Algorithm: sha256WithRSAEncryption
        Issuer: C = US, O = Let's Encrypt, CN = R3
        Validity
            Not Before: Mar 11 07:02:14 2024 GMT
            Not After : Jun  9 07:02:13 2024 GMT
        Subject: CN = quennec.fr
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
                RSA Public-Key: (2048 bit)
                Modulus:
                    00:b3:d3:a3:d3:f3:2c:f8:75:d0:71:5f:8f:8d:c4:
                    ...
                    83:f0:69:50:7a:fe:ce:a5:48:64:e1:5a:41:a0:a3:
                    8b:25
                Exponent: 65537 (0x10001)
        X509v3 extensions:
            X509v3 Key Usage: critical
                Digital Signature, Key Encipherment
            X509v3 Extended Key Usage:
                TLS Web Server Authentication, TLS Web Client Authentication
            X509v3 Basic Constraints: critical
                CA:FALSE
            X509v3 Subject Key Identifier:
                F0:5D:1D:A5:87:7D:61:1D:AB:74:A4:DE:14:34:F4:D7:3A:52:56:F5
            X509v3 Authority Key Identifier:
                keyid:14:2E:B3:17:B7:58:56:CB:AE:50:09:40:E6:1F:AF:9D:8B:14:C2:C6

            Authority Information Access:
                OCSP - URI:http://r3.o.lencr.org
                CA Issuers - URI:http://r3.i.lencr.org/

            X509v3 Subject Alternative Name:
                DNS:*.quennec.fr, DNS:quennec.fr
            X509v3 Certificate Policies:
                Policy: 2.23.140.1.2.1

            CT Precertificate SCTs:
                Signed Certificate Timestamp:
                    Version   : v1 (0x0)
                    Log ID    : 3B:53:77:75:3E:2D:B9:80:4E:8B:30:5B:06:FE:40:3B:
                                67:D8:4F:C3:F4:C7:BD:00:0D:2D:72:6F:E1:FA:D4:17
                    Timestamp : Mar 11 08:02:14.835 2024 GMT
                    Extensions: none
                    Signature : ecdsa-with-SHA256
                                30:46:02:21:00:C6:D5:B3:6D:A4:45:49:25:9B:47:C9:
                                21:20:61:57:67:E9:EB:5A:EB:3F:80:87:3E:EF:41:F6:
                                7C:CD:2C:46:61:02:21:00:D8:27:12:05:AF:5E:9A:0D:
                                91:E9:DA:C5:5A:27:27:25:1D:31:56:A3:6D:4D:26:21:
                                5D:E9:08:B0:5F:1E:5F:88
                Signed Certificate Timestamp:
                    Version   : v1 (0x0)
                    Log ID    : 76:FF:88:3F:0A:B6:FB:95:51:C2:61:CC:F5:87:BA:34:
                                B4:A4:CD:BB:29:DC:68:42:0A:9F:E6:67:4C:5A:3A:74
                    Timestamp : Mar 11 08:02:14.890 2024 GMT
                    Extensions: none
                    Signature : ecdsa-with-SHA256
                                30:44:02:20:41:9E:16:0F:BF:95:4F:FA:23:4F:A4:06:
                                ...
                                0F:CB:99:8B:E9:87
    Signature Algorithm: sha256WithRSAEncryption
         0c:dd:53:bc:97:e0:18:39:94:19:fa:28:7c:67:b9:35:a4:ca:
         ...
         04:ee:d9:9

De nos jours, il est conseillé de générer des clés d'une longueur de 2048 bits pour une meilleure sécurité.

Pour un serveur Apache (configuration SSL), il est conseillé de générer des clés sans phrase de passe. Dans le cas contraire, à chaque démarrage du service Apache, la phrase de passe sera demandée.

Avec OpenSSL, la clé privée contient également les informations de la clé publique. Il n'est donc pas nécessaire de générer la clé publique séparément.

Génération d'une clé RSA

Générer une clé simple :

$ openssl genrsa

Générer une clé de 2048 bits et la sauvegarder dans un fichier :

$ openssl genrsa -out mykey.pem 2048

Idem mais avec un cryptage DES3 et une phrase de passe :

$ openssl genrsa -des3 -out mykey.pem 2048

Génération d'une clé publique RSA

$ openssl rsa -in mykey.pem -pubout

Génération d'une clé DSA

Les clés DSA sont utilisées pour la signature d'objets divers.

Le processus de génération se déroule en deux étapes.

Premièrement, générer les paramètres permettant la génération de la clé :

$ openssl dsaparam -out dsaparam.pem 2048

Puis, générer la clé en fonction des paramètres générés ci-dessus :

$ openssl gendsa -des3 -out privkey.pem dsaparam.pem

Une phrase de passe est demandée lors de la génération de la clé DSA.

Pour ne pas avoir de phrase de passe, il suffit de supprimer le paramètre "-des3".

Supprimer la phrase de passe d'une clé privée RSA

Cette commande permet de générer une nouvelle clé privée (newkey.pem) à partir de celle protégée par une phrase de passe (mykey.pem).

$ openssl rsa -in mykey.pem -out newkey.pem

Supprimer la phrase de passe d'un certificat

Pour l'exemple, nous allons créer un certificat crypté (mycert.pem).
Ce fichier (mycert.pem) contiendra la clé privée et le certificat public et sera protégé par une phrase de passe.

$ openssl req -x509 -days 365 -subj '/C=FR/ST=Loire Atlantique/L=Ancenis/CN=www.monsite.fr/emailAddress=toto@gmail.com' -newkey rsa:2048-keyout mycert.pem -out mycert.pem

Le décryptage du certificat se déroule en deux étapes :

Génération de la clé privée à partir du certificat crypté (mycert.pem) vers le nouveau certificat (newcert.pem) :

$ openssl rsa -in mycert.pem -out newcert.pem

Ajout du certificat public dans le nouveau certificat (newcert.pem) :

$ openssl x509 -in mycert.pem >>newcert.pem

Générer une chaine aléatoire de 128 octets encodée en BASE64 :

$ openssl rand -base64 128
2/X1yDvXHdAsDYPBmToCNYFI9Vjhtt4ynVMFCcMfV0jJm+EytH22MEyMs7XV4rbB
6CdddwCD0T3sYu7hCF+Q5Dy72S3LKhZL5cbB8gaf2l+Guv/GCU/oiYTezRwLsAaN
82Sig1bnsyJeI3q67PsLS2yUhWTXiyRxv6/69EL/i30=

Générer une chaine aléatoire de 16 octets encodée en HEX :

$ openssl rand -hex 16
e114c246088060ef2af0b4f4f518b875

Générer un fichier binaire de 1024 octets :

$ openssl rand -out random-data.bin 1024
$ ls -l random-data.bin
-rw-r--r-- 1 root root 1024 Apr 11 18:21 random-data.bin

Générer une chaine aléatoire de 64 octets en utilisant le fichier spécial /dev/urandom et encodée avec la commande openssl en BASE64 :

$ head -c 64 /dev/urandom | openssl enc -base64
3wZ9RXe5bwCKzfEUElHOEJNb97SNN7QfKetKdSfAXvNhaiyCwWBWBEJupPAM2K/Q
6zx09thfwss2ffCGvencfg==

Un petit enchainement de commandes permettant de générer des mots de passe aléatoires :

$ echo $(head -c 32 /dev/urandom | strings -1) | sed 's/[[:space:]]//g'
18EC2Wl1-W

Générer un fichier d'une taille aléatoire comprise entre 0 et 50 Mo à l'aide de la fonction interne $RANDOM (50 Mo = 1024*1024*50):

$ openssl rand -out random-data.txt $(($RANDOM * 1024 * 1024 * 50 / 32767))

La fonction interne $RANDOM génère un nombre aléatoire compris entre 0 et 32767.

Générer un fichier texte de 10Mo

$ openssl rand -hex $((1024*1024*5)) > 10mbFile

1 byte étant égal à 2 caractères hexadécimal, il faut donc penser à diviser par 2 la taille du fichier désiré.

Crypter simplement un mot de passe :

$ openssl passwd MyPasswd
hMTFVzaMHJcaA

Le mot de passe à crypter ne peut excéder 8 caractères.

Ajouter un "salt" au mot de passe à crypter (mot de passe salé ;o) :

$ openssl passwd -salt 12 MyPasswd
12q97u.MW0POc

Dans ce cas précis, le "salt" ne doit pas excéder 2 caractères.

Crypter un mot de passe avec l'algorithme MD5 :

$ openssl passwd -1 MyPasswd
$1$339eK0sF$MCPIqzRKLIWsKG1kXnQiw1

Pas de limitation au niveau de la longueur du mot de passe.

Idem mais en ajoutant un "salt" :

$ openssl passwd -1 -salt 12345678 MyPasswd
$1$12345678$I3fjXxePlXzjbz7gjOzwW0

Dans ce cas, le "salt" ne doit pas excéder 8 caractères.

Idem, mais avec un "salt" généré aléatoirement :

$ openssl passwd -1 -salt $(openssl rand -base64 8) MyPasswd
$1$nSQ9OINA$1a2pvpNHjYo41N0n6FqbQ.

Par défaut, OpenSSL utilise le fichier de configuration "/etc/ssl/openssl.cnf" pour la génération des certificats.

Pour utiliser un fichier de configuration personnalisé, il suffit d'ajouter l'argument "-config {fichier_de_configuration_personnalisé}" à la commande openssl.

Avant de pouvoir générer un certificat, il faut obligatoirement générer une clé RSA ou DSA.

Tout est expliqué ici.

Dans les exemples suivants, la clé privée "mykey.pem" sera utilisée pour la génération des certificats.

Création d'une autorité de certification (permettant de signer les demandes de certificats)

Pour générer ses propres certificats, sans passer par une autorité de certification externe :

$ openssl req -new -x509 -key mykey.pem -out ca.crt -days 1095

On indique pour le paramètre "-out" le nom de l'autorité de certification à générer puis la durée de validité en jour avec le paramètre "-days"
Cette autorité de certification permettra de signer les futures demandes de certificats auto-signés.
Cette génération est à faire une seule fois.
Le Common Name à indiquer ne doit correspondre à aucun nom de domaine ayant besoin d'un certificat.
Cette autorité de certification peut-être mis à disposition du public afin d'être intégré dans les différents navigateurs comme étant une autorité de certification reconnue.

Création d'une demande de certificat

Une demande de certificat peut être utilisée sur un site comme http://www.cacert.org/ afin d'obtenir un certificat reconnu par une autorité de certification ou afin d'être signé par le certificat ca.crt généré ci-dessus.

$ openssl req -new -key mykey.pem -out mondomaine.csr

La demande "cert.csr" peut ensuite être transmise à l'autorité de certification qui fournira par la suite le certificat résultant.
Le Common Name à indiquer doit correspondre au nom de domaine pour lequel vous souhaitez un certificat.

Génération du certificat final

A l'aide du certificat de certification généré au tout début (ca.crt), nous allons générer le certificat correspondant à la demande (mondomain.csr) générée ci-dessus.

$ openssl x509 -req -in mondomaine.csr -out mondomaine.pem -CA ca.crt -CAkey mykey.pem -CAcreateserial -CAserial ca.srl -days 90

L'option -CAcreateserial est à utiliser seulement la première fois.
Ceci va générer un identifiant (ca.srl).
Lors des prochaines certification (pour renouvellement ou pour d'autres domaines) l'identifiant, contenu dans le fichier ca.srl, sera incrémenté à l'aide de l'option -CAserial ca.srl

Avec Apache, il est possible d'utiliser des fichiers d'authentification pour protéger des répertoires web.

Pour générer ces fichiers d'authentification, il est nécessaire d'utiliser la commande htdigest.

La commande htdigest inscrit les données d'authentification obligatoirement dans un fichier.

Pour afficher ces mêmes informations mais uniquement sur la sortie standard (pour x raisons) il est nécessaire d'utiliser la commande openssl.

Voici un script qui permet de saisir les informations d'authentification et affiche le résultat sur la sortie standard :

$ cat htdigest.sh
#!/bin/bash
 
echo "Creation d'une authentification Apache"
echo "-----------------------------------------------"
 
read -p "Votre nom : " NAME
read -p "Apache AuthName: " AUTHNAME
read -s -p "Votre mot de passe : " PASS; echo
 
printf "%s:%s:%s\n" \
  "$NAME" \
  "$AUTHNAME" \
  $(printf "${NAME}:${AUTHNAME}:${PASS}" | openssl dgst -md5)
 
exit 0

Exécution du script :

$ ./htdigest.sh
Creation d'une authentification Apache
-----------------------------------------------
Votre nom : toto
Apache AuthName: monSite
Votre mot de passe :
toto:monSite:ffdcd4a53fb7dd716ec2d017e93bc563

OpenSSL possède une sous-commande qui permet de tester si le nombre passé en paramètre est un nombre premier.

$ openssl prime 2
2 is prime
$ openssl prime 3
3 is prime
$ openssl prime 4
4 is not prime
$ openssl prime 11
B is prime

Le résultat est retourné sous forme hexadécimale.

En ajoutant l'option "-hex", il est possible de tester une chaine hexadécimale :

$ openssl prime 449
1C1 is prime

La représentation hexadécimale du nombre 449 est donc 1C1

$ openssl prime -hex 1C1
1C1 is prime

En prime, un petit enchainement de commandes permettant d'obtenir la liste des 168 nombres premiers inférieurs à 1000.

$ for i in $(seq 0 1000); do \
result=$(openssl prime $i) \
echo $result | grep  -q "is prime$" \
if [[ $? -eq 0 ]]; then \
echo $i \
fi
done | column -x
2       3       5       7       11      13      17      19      23      29      31      37      41      43      47      53
59      61      67      71      73      79      83      89      97      101     103     107     109     113     127     131
137     139     149     151     157     163     167     173     179     181     191     193     197     199     211     223
227     229     233     239     241     251     257     263     269     271     277     281     283     293     307     311
313     317     331     337     347     349     353     359     367     373     379     383     389     397     401     409
419     421     431     433     439     443     449     457     461     463     467     479     487     491     499     503
509     521     523     541     547     557     563     569     571     577     587     593     599     601     607     613
617     619     631     641     643     647     653     659     661     673     677     683     691     701     709     719
727     733     739     743     751     757     761     769     773     787     797     809     811     821     823     827
829     839     853     857     859     863     877     881     883     887     907     911     919     929     937     941
947     953     967     971     977     983     991     997

Le script suivant permet de récupérer le contenu du certificat du site indiqué en paramètre (le port est facultatif, par défaut le port 443 est utilisé).

$ cat getCertificates.sh
#!/bin/sh
 
HOST=$1
PORT=${2:-443}
 
echo | \
openssl s_client -connect ${HOST}:${PORT} 2>&1 | \
sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p'
 
exit 0
$

On l'exécute en lui indiquant en paramètre le nom du site et le port (facultatif).

$ ./getCertificates.sh youtube.fr 443
-----BEGIN CERTIFICATE-----
MIIF/DCCBWWgAwIBAgIKKZeNqAABAACBuDANBgkqhkiG9w0BAQUFADBGMQswCQYD
VQQGEwJVUzETMBEGA1UEChMKR29vZ2xlIEluYzEiMCAGA1UEAxMZR29vZ2xlIElu
...
Xl7/nc7F5HgE0c+bGsAYuCoYBsDNYs8/AUTnSTeih8U9mSRRDFb9NxMkQqUWPSXO
sh4FktaXQJBJRi4IAfuUDk28c9A0Bv1ygO3FqiSu6QJ3axESCoGmF26XqDwvJtFq
-----END CERTIFICATE-----

et le certificat s'affiche à l'écran.

Voir également CURL: Afficher les informations SSL d'un domaine

Voir également openssl : Extraire les informations d'un certificat

Voici une commande permettant de générer, en une seule fois, une paire de clé (publique/privée) et une demande de certificat CSR afin d'obtenir, auprès de cacert.org par exemple, un certificat X509 associant votre clé publique générée et le nom de domaine que vous souhaitez protéger avec TLS.

$ openssl req -nodes -newkey rsa:2048 -sha256 -keyout ma_cle.key -out ma_demande.csr

Avec cette commande, nous allons créer une clé RSA de 2048 bits.

Les autres arguments de la ligne de commandes indiquent que la clé privée sera stockée dans le fichier ma_cle.key et la demande CSR sera stockée dans le fichier ma_demande.csr.

Une série de questions vous est posée.
Les deux questions les plus importantes sont celles correspondantes au common name et à l'adresse mail de contact.

Ne renseignez surtout pas de mot de passe sinon il vous sera demandé à chaque démarrage du serveur web.
Un peu contraignant lors de tâches de maintenance automatisées.

Pour vérifier la demande CSR:

$ openssl req -text -noout -verify -in ma_demande.csr

Reste à transmettre à l'autorité de certification (cacert.org par exemple - certificat gratuit) la demande CSR.

Il est possible d'utiliser la commande openssl pour se connecter à un serveur STMP en utilisant la sécurité TLS,

Dans l'exemple suivant, l'option -CAfile /etc/ssl/certs/ca-certificates.crt permet d'indiquer l'autorité de certification dans le cas d'un certificat auto signé.

# openssl s_client -starttls smtp -crlf -CAfile /etc/ssl/certs/ca-certificates.crt -connect smtp.server.fr:25

CONNECTED(00000003)
depth=0 CN = localhost.localdomain
verify return:1
---
Certificate chain
 0 s:/CN=localhost.localdomain
   i:/CN=localhost.localdomain
---
Server certificate
-----BEGIN CERTIFICATE-----
MIIBtzCCASACCQCupdgFIYzFVDANBgkqhkiG9w0BAQUFADAgMR4w
b2NhbGhvaW4wHhcNMTEwNDI2MTkxMDM1WhcNMjEwNDIzMTkx
MDM1WjAgMR4wHAYDVQQDExVsb2NhbGhvc3QubG9jYWxkb21ha
hvcNAQEBBQADgY0AMIGJZS3OcCHjbQNa++F/J4WGFk6r7ICl9Ls0
ybT+1CzbFG1xE71NeRhbHkLGigZa5422afsqq/b3LBIpMX17B/gtuo+
QKRckuo+20BUqHFye7ZAVXSsw+bqmm9D0vB4uw9IwyE75jEAqU1
QX7RAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAe1iHUXoGSTj3Fv3
2Yg1EFtNm/RSYxdHV8jY6W6CtwNatN+EQqmWlfhtOSCWgXriUjX5
E4uEocf6x/vDrVkpU11u+0xDUYshmrLyk2nmX6wbopwQttAE9PLw
ahQBiuj+sz38OW8=
-----END CERTIFICATE-----
subject=/CN=localhost.localdomain
issuer=/CN=localhost.localdomain
---
No client certificate CA names sent
---
SSL handshake has read 1021 bytes and written 456 bytes
---
New, TLSv1/SSLv3, Cipher is ECDHE-RSA-AES256-GCM-SHA384
Server public key is 1024 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
SSL-Session:
    Protocol  : TLSv1.2
    Cipher    : ECDHE-RSA-AES256-GCM-SHA384
    Session-ID: D2A784125E749B8C74015978412B9B6E47DDA37BFB83FD4FEE8E6ED21BE79C92
    Session-ID-ctx:
    Master-Key: 631649B5A6A2F5272137C421AFB2F2E86CD483ED2FE8099BCDC9068A11EE7087F
    Key-Arg   : None
    PSK identity: None
    PSK identity hint: None
    SRP username: None
    Start Time: 1478726847
    Timeout   : 300 (sec)
    Verify return code: 0 (ok)
---
250 DSN
mail from: one@mail.fr
250 2.1.0 Ok
rcpt to: two@mail.fr
250 2.1.5 Ok
data
354 End data with <CR><LF>.<CR><LF>
from: one@mail.fr
to: two@mail.fr
subject: send mail with TLS connection

Voluptatem veniam quasi nisi voluptatum incidunt autem. Sed provident minus ab temporibus sed. Quia blanditiis consequatur assumenda aut hic. Minima cum qui quidem dicta velit quod voluptas. Dolorem aliquam animi consequatur.

Minima alias sint libero et. Et et in ratione similique iusto aut consectetur. Sed voluptatibus modi fuga ut quibusdam ut consectetur voluptas.
.
250 2.0.0 Ok: queued as 145A53700157
quit
221 2.0.0 Bye
closed

Très utile pour tester un serveur STMP