Confidentialité

Objectifs de certification

LPIC 1

1. Cryptologie

La cryptologie est la science qui englobe la cryptographie — l'écriture secrète – et la cryptanalyse – l'analyse de cette dernière.

La confidentialité n'est que l'une des facettes de la cryptologie. Elle permet également :

  • l'authentification ou l'authentification forte d'un message : l'assurance qu'un individu est bien l'auteur du message chiffré ;
  • la non-répudiation est le fait de s'assurer qu'un contrat ne peut être remis en cause par l'une des parties.
  • l'intégrité : on peut vérifier que le message n'a pas été manipulé sans autorisation ou par erreur ;
  • la preuve à divulgation nulle de connaissance — par exemple d'identité —, on peut prouver que l'on connaît un secret sans le révéler ;
  • et autres, dont l'anonymat et la mise en gage.

Les premières méthodes de chiffrement remontent à l’Antiquité et se sont améliorées, avec la fabrication de différentes machines de chiffrement, pour obtenir un rôle majeur lors de la Première Guerre mondiale et de la Seconde Guerre mondiale. (voir https://fr.wikipedia.org/wiki/Histoire_de_la_cryptologie).

La cryptologie a très longtemps été considérée comme une arme de guerre.

La cryptologie est essentiale à la sécurité des transactions de commerce électronique.

2. Cryptographie

La cryptographie est une des disciplines de la cryptologie s'attachant à protéger des messages (assurant confidentialité, authenticité et intégrité) en s'aidant souvent de secrets ou clés. Elle se distingue de la stéganographie qui fait passer inaperçu un message dans un autre message alors que la cryptographie rend un message inintelligible à autre que qui-de-droit.

La cryptographie se scinde en deux parties nettement différenciées :

  • d'une part la cryptographie à clef secrète, encore appelée symétrique ou bien classique ;
  • d'autre part la cryptographie à clef publique, dite également asymétrique ou moderne.

La première est la plus ancienne, on peut la faire remonter à l'Égypte de l'an 2000 av. J.-C. en passant par Jules César ; la seconde remonte à l'article de W. Diffie et M. Hellman, New directions in cryptography daté de 1976.

Toutes deux visent à assurer la confidentialité de l'information, mais la cryptographie à clef secrète nécessite au préalable la mise en commun entre les destinataires d'une certaine information : la clé (symétrique), nécessaire au chiffrement ainsi qu'au déchiffrement des messages.

Dans le cadre de la cryptographie à clé publique, ce n'est plus nécessaire. En effet, les clés sont alors différentes, ne peuvent se déduire l'une de l'autre, et servent à faire des opérations opposées, d'où l'asymétrie entre les opérations de chiffrement et de déchiffrement.

Bien que beaucoup plus récente et malgré d'énormes avantages – signature numérique, échange de clés... – la cryptographie à clef publique ne remplace pas totalement celle à clef secrète, qui pour des raisons de vitesse de chiffrement et parfois de simplicité reste présente. À ce titre, signalons la date du dernier standard américain en la matière, l'AES : décembre 2001, ce qui prouve la vitalité encore actuelle de la cryptographie symétrique.

2.1. Algorithmes de chiffrement faible (facilement déchiffrables)

Les premiers algorithmes utilisés pour le chiffrement d'une information étaient assez rudimentaires dans leur ensemble. Ils consistaient notamment au remplacement de caractères par d'autres. La confidentialité de l'algorithme de chiffrement était donc la pierre angulaire de ce système pour éviter un décryptage rapide.

Exemples d'algorithmes de chiffrement faibles :

  • ROT13 (rotation de 13 caractères, sans clé) ;
  • Chiffre de César (décalage de trois lettres dans l'alphabet sur la gauche).
  • Chiffre de Vigenère (introduit la notion de clé)

Pour s'amuser avec ces algorithmes vous pouvez vous référer aux sites https://asecuritysite.com/ ou http://www.cryptool-online.org/ ou encore, parmi d'autres ressources, la libraire python pycipher : http://pycipher.readthedocs.io/en/master/.

2.2. Algorithmes de cryptographie symétrique (à clé secrète)

Les algorithmes de chiffrement symétrique se fondent sur une même clé pour chiffrer et déchiffrer un message. L'un des problèmes de cette technique est que la clé, qui doit rester totalement confidentielle, doit être transmise au correspondant de façon sûre. La mise en œuvre peut s'avérer difficile, surtout avec un grand nombre de correspondants car il faut autant de clés que de correspondants.

Quelques algorithmes de chiffrement symétrique très utilisés :

  • Chiffre de Vernam (le seul offrant une sécurité théorique absolue, à condition que la clé ait au moins la même longueur que le message, qu'elle ne soit utilisée qu'une seule fois à chiffrer et qu'elle soit totalement aléatoire)
  • DES
  • 3DES
  • AES
  • RC4
  • RC5
  • MISTY1
  • et bien d'autres.

On distingue deux catégories de chiffrement symétrique :

  • Le chiffrement par bloc (en anglais block cipher) est une des deux grandes catégories de chiffrements modernes en cryptographie symétrique, l'autre étant le chiffrement par flot. La principale différence vient du découpage des données en blocs de taille généralement fixe. La taille de bloc est comprise entre 32 et 512 bits, dans le milieu des années 1990 le standard était de 64 bits mais depuis 2000 et le concours AES le standard est de 128 bits.

  • Le chiffrement de flux ou chiffrement par flot (en anglais stream cipher). Un chiffrement par flot arrive à traiter les données de longueur quelconque et n'a pas besoin de les découper. Un chiffrement par flot se présente souvent sous la forme d'un générateur de nombres pseudo-aléatoires avec lequel on opère un XOR entre un bit à la sortie du générateur et un bit provenant des données.

La recommendation du RGS_v-2-0_B1 indique taille minimale des clés symétriques à 128 bits.

2.3. Modes de chiffrement par bloc

En cryptographie, un mode d'opération est la manière de traiter les blocs de texte clairs et chiffrés au sein d'un algorithme de chiffrement par bloc. Historiquement, les modes d'opération ont été abondamment étudiés pour leur propriétés de propagation d'erreurs lors de divers scénarios de modification de données durant le chiffrement. Les développements suivants ont considéré que la protection de l'intégrité était un objectif à atteindre par des moyens complètement différents. Mais aujourd'hui il existe des modes d'opérations qui associent chiffrement et authentification de manière efficace.

Plusieurs modes existent, certains sont plus vulnérables que d'autres :

  • Dictionnaire de codes (Electronic Code Book, ECB)
  • Enchaînement des blocs (Cipher Block Chaining, CBC)
  • Chiffrement à rétroaction (Cipher Feedback, CFB)
  • Chiffrement à rétroaction de sortie (Output Feedback, OFB)
  • Chiffrement basé sur un compteur (CounTeR, CTR)
  • Chiffrement avec vol de texte (CipherText Stealing, CTS)
  • Compteur avec CBC-MAC, voir l'article CCMP
  • EAX (inventé par David Wagner et al.)
  • CWC (à deux passes)

3. Exercices de chiffrement symétrique

3.1. Chiffement symétrique avec vim

vim -x vimtest.cry

3.2. Chiffrement de fichier avec openssl

# openssl list-cipher-commands
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
camellia-128-cbc
camellia-128-ecb
camellia-192-cbc
camellia-192-ecb
camellia-256-cbc
camellia-256-ecb
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
rc4
rc4-40
seed
seed-cbc
seed-cfb
seed-ecb
seed-ofb

Créer un fichier clair.

# echo "0123456789" > clair-text.txt
# cat clair-text.txt
0123456789

Codage base-64.

# openssl enc -base64 -in clair-text.txt
MDEyMzQ1Njc4OQo=

Chiffrement AES.

# openssl enc -aes-256-cbc -in clair-text.txt -out enc-text.bin
enter aes-256-cbc encryption password:
Verifying - enter aes-256-cbc encryption password:
# cat enc-text.bin
Salted__Ă�%��j�J�%���z-l��[0

Déchiffrement.

# openssl enc -aes-256-cbc -d -in enc-text.bin -out decryp-text.txt
enter aes-256-cbc decryption password:
# cat decryp-text.txt
0123456789

4. Cryptographie asymétrique

4.1. Algorithmes de cryptographie asymétrique

Pour résoudre le problème de l'échange de clés, la cryptographie asymétrique a été mise au point dans les années 1970. Elle se base sur le principe de deux clés :

  • une publique, permettant le chiffrement ;
  • une privée, permettant le déchiffrement.

Comme son nom l'indique, la clé publique est mise à la disposition de quiconque désire chiffrer un message. Ce dernier ne pourra être déchiffré qu'avec la clé privée, qui doit rester confidentielle.

Ceci dit le rôle des clés est interchangeable : on peut chiffrer avec une clé privées et déchiffrer avec une clé publique.

Quelques algorithmes de cryptographie asymétrique très utilisés :

  • RSA (chiffrement et signature);
  • DSA (signature);
  • Protocole d'échange de clés Diffie-Hellman (échange de clé);
  • et d'autres ; voir cette liste plus complète d'algorithmes de cryptographie asymétrique.

Le principal inconvénient de RSA et des autres algorithmes à clés publiques est leur grande lenteur par rapport aux algorithmes à clés secrètes. RSA est par exemple 1000 fois plus lent que DES. En pratique, dans le cadre de la confidentialité, on s'en sert pour chiffrer un nombre aléatoire qui sert ensuite de clé secrète pour un algorithme de chiffrement symétrique. C'est le principe qu'utilisent des logiciels comme PGP par exemple.

La cryptographie asymétrique est également utilisée pour assurer l'authenticité d'un message. L'empreinte du message est chiffrée à l'aide de la clé privée et est jointe au message. Les destinataires déchiffrent ensuite le cryptogramme à l'aide de la clé publique et retrouvent normalement l'empreinte. Cela leur assure que l'émetteur est bien l'auteur du message. On parle alors de signature ou encore de scellement.

La propriété des algorithmes asymétriques est qu'un message chiffré par une clé publique n'est lisible que par le propriétaire de la clé privée correspondante. À l'inverse, un message chiffré par une clé privée sera lisible par tous ceux qui possèdent la clé publique correspondante.

Ainsi avec sa clé privée, Anne :

  • signe ses messages ;
  • lit (déchiffre) les messages qui lui sont adressés.

4.2. Fonctions de hachage

Une fonction de hachage est une fonction qui convertit un grand ensemble en un plus petit ensemble, l'empreinte. Il est impossible de la déchiffrer pour revenir à l'ensemble d'origine, ce n'est donc pas une technique de chiffrement.

Quelques fonctions de hachage très utilisées :

  • MD5 ;
  • SHA-1 ;
  • SHA-256 ; et d'autres ; voir cette liste plus complète d'algorithmes de hachage.

L'empreinte d'un message ne dépasse généralement pas 256 bits (maximum 512 bits pour SHA-512) et permet de vérifier son intégrité.

Grâce à la valeur de hachage, on peut discriminer deux objets apparemment proches, ce qui peut être utilisé pour garantir l'intégrité des objets, autrement dit leur non modification par un acteur malveillant.

Le salage (salting en anglais) consiste à ajouter une chaîne de caractères (un nonce) à l'information avant le hachage. Par exemple, dans un cadre cryptographique, au lieu de pratiquer le hachage sur le mot de passe seul, on peut le faire sur le résultat de la concaténation du mot de passe avec une autre chaîne de caractères pseudo-aléatoire, obtenue par un hachage de l'identifiant (login) concaténé avec le mot de passe. Les deux fonctions de hachage (celle qu'on utilise pour générer la chaîne pseudo-aléatoire et celle qu'on applique au résultat) peuvent être différentes (par exemple SHA-1 et MD5).

Cela permet de renforcer la sécurité de cette fonction.

En effet, en l'absence de salage, il est possible de cracker le système à l'aide de tables de hachage correspondant à des valeurs (telles que des mots de passe) souvent utilisées, par exemple les tables arc-en-ciel.

Le simple ajout d'un sel (ou nonce) avant hachage rend l'utilisation de ces tables caduque, et le craquage doit faire appel à des méthodes telles que l'attaque par force brute (cette méthode, consistant à tester toutes les valeurs possibles, prend tellement de temps avec un bon mot de passe que l'on ne peut plus qualifier cela de crackage).

5. Cryptographie hybride

La cryptographie hybride est un système de cryptographie faisant appel aux deux grandes familles de systèmes cryptographiques : la cryptographie asymétrique et la cryptographie symétrique. Les logiciels comme PGP et GnuPG reposent sur ce concept qui permet de combiner les avantages des deux systèmes.

La cryptographie asymétrique propose aussi une autre primitive cryptographique pouvant être associée à un chiffrement symétrique, il s’agit de l’échange de clés (en) ; un exemple est l’échange de clés Diffie-Hellman. Cette méthode, couplée avec un mécanisme d’authentification, est par exemple utilisée par TLS.

La cryptographie asymétrique est intrinsèquement lente à cause des calculs complexes qui y sont associés, alors que la cryptographie symétrique brille par sa rapidité. Toutefois, cette dernière souffre d'une grave lacune, on doit transmettre les clés de manière sécurisée (sur un canal authentifié). Pour pallier ce défaut, on recourt à la cryptographie asymétrique qui travaille avec une paire de clés : la clé privée et la clé publique. La cryptographie hybride combine les deux systèmes afin de bénéficier des avantages (rapidité de la cryptographie symétrique pour le contenu du message) et utilisation de la cryptographie "lente" uniquement pour la clé.

La plupart des systèmes hybrides procèdent de la manière suivante. Une clé aléatoire, appellée clé de session, est générée pour l’algorithme symétrique (3DES, IDEA, AES et bien d'autres encore), cette clé fait généralement entre 128 et 512 bits selon les algorithmes. L'algorithme de chiffrement symétrique est ensuite utilisé pour chiffrer le message. Dans le cas d'un chiffrement par blocs, on doit utiliser un mode d'opération comme CBC, cela permet de chiffrer un message de taille supérieure à celle d'un bloc.

La clé de session quant à elle, se voit chiffrée grâce à la clé publique du destinataire, c'est ici qu'intervient la cryptographie asymétrique (RSA ou ElGamal). Comme la clé est courte, ce chiffrement prend peu de temps. Chiffrer l'ensemble du message avec un algorithme asymétrique serait bien plus coûteux, c'est pourquoi on préfère passer par un algorithme symétrique. Il suffit ensuite d'envoyer le message chiffré avec l'algorithme symétrique et accompagné de la clé chiffrée correspondante. Le destinataire déchiffre la clé symétrique avec sa clé privée et via un déchiffrement symétrique, retrouve le message.

Il est très courant d'ajouter des authentifications et des signatures aux messages envoyés. On utilise pour cela des fonctions de hachage (MD5, SHA-1 ou des codes authentificateurs comme HMAC).

6. Exercices de cryptographie asymétrique

6.1. Générer l'emprunte d'un fichier

$ echo "fichier" > fichier.txt
$ echo "cichier" > fichier2.txt
$ openssl dgst -md5 < fichier.txt
(stdin)= f177a99d010fa7406403cd2136e7644e

$ openssl dgst -md5 < fichier2.txt
(stdin)= ced7ffe67001ba15b5a4ef4d0d20269a
$ openssl dgst -sha1 < fichier.txt
(stdin)= 47629f27e6f98a000d9a51907fa706e676d6eee8

$ openssl dgst -sha1 < fichier2.txt
(stdin)= 828968c2043569a701bfaf2e8cf94a612e3ec410
$ openssl dgst -sha256 < fichier.txt
(stdin)= 07ae4c332cc992ea1086d067b0e720a914e601c9d3b016f9952cd8a05e03cdfc

$ openssl dgst -sha256 < fichier2.txt
(stdin)= ceb3564c37c7775d5d5611724de0f566dc7d6f5797f1e16da9ccdb3efa7f7b84
$ openssl dgst -sha512 < fichier.txt
(stdin)= 69f0cc9551f59aee2496c9ff4f492325c9cb1379a6a83c36ddd1e5e3f751344da52435306f9c1cf00cc68ba4e97fa2e84123e01f50b0227dfbb6cc63e1530c95
$ openssl dgst -sha512 < fichier2.txt
(stdin)= 778c653c8381416901e9fd0ab2fa01b6c65171594906ab48c60d81cdf8596cd3091f391213ed834e187fdee6c4d0f96100d7672ea5f5db65ab23abef020b919d

Aussi on peut utiliser les binaires md5sum, sha1sum, sha224sum, sha256sum, sha384sum, sha512sum.

Par exemple :

$ sha1sum fichier.txt
47629f27e6f98a000d9a51907fa706e676d6eee8  fichier.txt
$ sha1sum fichier.txt > fichier.txt.sha1
$ sha1sum -c fichier.txt.sha1
fichier.txt: Réussi

6.2. Exercices de chiffrement asymétrique

Alice génère un couple de clés :

$ openssl genrsa -out cle.pem 2048
Generating RSA private key, 2048 bit long modulus
...........................................+++
...................+++
e is 65537 (0x10001)

Alice extrait sa clé publique et la transmet à Bob :

$ openssl rsa -in cle.pem -pubout -out pub.pem
writing RSA key

Bob envoie un mot de passe chiffré avec la clé publique d'Alice :

$ echo secret | openssl rsautl -inkey pub.pem -pubin -out crypto.dat -encrypt
$ cat crypto.dat
��=|˂ʔ1���EU�u5����~�s
���"4��Nf
�Z_�&fmp}UÏ��+��[��G��\��!m�4�;!����q����>��2�`D�EV��@��y��2�A���+9��M�KG#��^��<d�@�C"�!v�t�*|��^�8�z�$��`R�;.�;� X����jD1��!�׀\�`��Z?89
 ּ

z,Z*�

Alice déchiffre le mot de passe :

$ openssl rsautl -inkey cle.pem -in crypto.dat -decrypt
secret

6.3. Exercice de signature numérique

Alice calcule l'empreinte d'un fichier en sha1 et la signe avec la clé privée avec openssl :

$ echo "test" > fic_a_signer.txt
$ openssl dgst -sha1 fic_a_signer.txt > sign.sha1
$ openssl rsautl -sign -in sign.sha1 -inkey cle.pem -out clair.sig

Bob reçoit le fichier et la signature, il recalcule l'emprunte et il déchiffre la signature avec la clé publique d'Alice. Si les deux valeurs sont identiques le message est bien signé.

$ openssl dgst -sha1 fic_a_signer.txt
SHA1(fic_a_signer.txt)= 4e1243bd22c66e76c2ba9eddc1f91394e57f9f83
$ openssl rsautl -verify -in clair.sig -inkey pub.pem -pubin
SHA1(fic_a_signer.txt)= 4e1243bd22c66e76c2ba9eddc1f91394e57f9f83

7. PGP

Pretty Good Privacy (en français : « assez bonne confidentialité »), plus connu sous le sigle PGP, est un logiciel de chiffrement cryptographique, développé et diffusé aux États-Unis par Philip Zimmermann en 1991.

PGP se propose de garantir la confidentialité et l'authentification pour la communication des données. Il est souvent utilisé pour la signature de données, le chiffrement et le déchiffrement des textes, des courriels, fichiers, répertoires et partitions de disque entier pour accroître la sécurité des communications par courriel. Utilisant la cryptographie asymétrique mais également la cryptographie symétrique, il fait partie des logiciels de cryptographie hybride.

PGP et les produits similaires suivent le standard OpenPGP (RFC 4880) pour le chiffrement et le déchiffrement de données.

7.1. Fonctionnement de PGP

Avec PGP, il devient possible de vérifier si un message provient bien de l'origine (via les signatures cryptographiques), ainsi que de chiffrer des messages afin qu'un seul destinataire puisse les lire. En bref, chaque utilisateur crée une paire de clés de chiffrement asymétriques (une publique, l'autre privée), et distribue la clé publique. Les signatures effectuées avec la clé privée peuvent être vérifiées en utilisant la clé publique correspondante et les messages chiffrés utilisant la clé publique sont déchiffrables en utilisant la clé privée correspondante. Ce fonctionnement a été initialement décrit dans le document RFC 19917.

PGP offre des services d'authentification, de confidentialité, de compression et de segmentation, tout en étant compatible avec de nombreux systèmes de messagerie électronique.

7.2. Authentification

L'expéditeur crée un condensat de son message (avec par exemple SHA-1), chiffre ce condensat avec sa clé privée et l'ajoute en début de message. Le destinataire déchiffre l'ajout en début de message avec la clé publique de l'émetteur et en extrait le condensat. Il calcule ensuite lui-même un condensat du message en utilisant la même fonction de condensat et le compare à celui qu'il a déchiffré ; même résultat ⇒ expéditeur authentifié et message intègre. Le couple clé publique/clé privée peut être fourni par RSA ou DSA ;

7.3. Confidentialité

(chiffrer des messages à transmettre ou des fichiers à enregistrer) : génération d'une clé secrète de taille 128 bits par exemple (nommée clé de session, valable pour un seul fichier ou un seul message). Le message ou le fichier est chiffré au moyen de cette clé de session avec un algorithme de cryptographie symétrique. Puis cette clé secrète est chiffrée au moyen de la clé publique RSA ou DSA du destinataire et ajoutée au début du message ou du fichier. Le destinataire du message déchiffre l'en-tête du message avec sa clé privée RSA ou DSA et en extrait la clé secrète qui lui permet de déchiffrer le message. Pour que la sécurité de l'échange soit plus sûr il ne faudrait pas utiliser le chiffrement sans authentification. PGP générant des clés très souvent (à chaque fichier ou message), le générateur aléatoire associé à PGP doit être particulièrement efficace afin de ne pas générer des séquences de clés prévisibles ;

7.4. Compression

Utilisation de ZIP appliqué après la signature mais avant le chiffrement (l'entropie induite par la compression rend plus difficile la cryptanalyse du fichier ou du message) ;

7.5. Compatibilité

Comme certains systèmes de messagerie ne permettent l'utilisation que du format ASCII, PGP contourne cette limitation en convertissant chaque flot binaire de 8 bits en caractères ASCII imprimables (conversion Radix-64 : 3 octets binaires sont convertis en 4 octets ASCII tout en contenant un CRC pour détecter les erreurs de transmission) ; la taille des messages grossit de 33 % mais la compression compense largement ce phénomène. PGP applique une conversion Radix-64 systématiquement, que le message original soit déjà au format ASCII ou pas ;

7.6. Segmentation et ré-assemblage

Pour outrepasser certaines contraintes (taille maximum des messages), après tous les traitements précédents PGP peut tronçonner le message original en segments de taille fixe. L'en-tête contenant la clé secrète ne sera positionnée que dans le premier segment. Le destinataire met en mémoire la clé secrète, récupère tous les segments, en retire les en-têtes inutiles, ré-assemble le message avant de le déchiffrer, le décompresser et vérifier sa signature.

8. Exercices GPG

8.1. Chiffrer un texte clair avec GPG

$ echo "test" > texte.txt
$ gpg --symmetric texte.txt

┌──────────────────────────────────────────────────────────┐
│ Entrez la phrase de passe                                │
│                                                          │
│                                                          │
│ Phrase de passe ********________________________________ │
│                                                          │
│        <OK>                                <Cancel>      │
└──────────────────────────────────────────────────────────┘

$ ls texte.*
texte.txt  texte.txt.gpg

$ $ cat texte.txt.gpg
 ih�J��$)��cg��q�͆�H]<�JW�ķÐdcC�_6��=q�[

8.2. Déchiffrer un texte gpg

$ gpg --decrypt texte.txt.gpg
gpg: données chiffrées avec CAST5
gpg: chiffré avec 1 phrase de passe
test
gpg: Attention : l'intégrité du message n'était pas protégée
$ gpg --output texte.txt.dec --decrypt texte.txt.gpg
gpg: données chiffrées avec CAST5
gpg: chiffré avec 1 phrase de passe
gpg: Attention : l'intégrité du message n'était pas protégée

$ cat texte.txt.dec
test

8.3. Chiffrer et signer des messages

Dans ce scénario Bob envoit un message chiffré à Alice et Alice signe un message à destination de Bob. Dans notre cas, Alice et Bob sont deux utilisateurs du système.

  • Créer des utilisateurs alice et bob
# adduser alice
# echo testtest | passwd --stdin alice
# gpasswd -a alice wheel

# adduser bob
# echo testtest | passwd --stdin bob
# gpasswd -a bob wheel
  • Création d'un dossier partagé

/tmp est un lieu partagé par excellence

# ls -ld /tmp
drwxrwxrwt. 20 root root 4096 28 sep 18:43 /tmp
  • Créer des clés dans la session de Alice Alice <alice@localhost>
$ su - alice
$ sudo gpg --gen-key

[sudo] password for alice:
gpg (GnuPG) 2.0.22; Copyright (C) 2013 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

gpg: répertoire « /root/.gnupg » créé
gpg: nouveau fichier de configuration « /root/.gnupg/gpg.conf » créé
gpg: Attention : les options de « /root/.gnupg/gpg.conf » ne sont pas encore actives cette fois
gpg: le porte-clefs « /root/.gnupg/secring.gpg » a été créé
gpg: le porte-clefs « /root/.gnupg/pubring.gpg » a été créé
Sélectionnez le type de clef désiré :
   (1) RSA et RSA (par défaut)
   (2) DSA et Elgamal
   (3) DSA (signature seule)
   (4) RSA (signature seule)
Quel est votre choix ?
les clefs RSA peuvent faire entre 1024 et 4096 bits de longueur.
Quelle taille de clef désirez-vous ? (2048)
La taille demandée est 2048 bits
Veuillez indiquer le temps pendant lequel cette clef devrait être valable.
         0 = la clef n'expire pas
      <n>  = la clef expire dans n jours
      <n>w = la clef expire dans n semaines
      <n>m = la clef expire dans n mois
      <n>y = la clef expire dans n ans
Pendant combien de temps la clef est-elle valable ? (0)
La clef n'expire pas du tout
Est-ce correct ? (o/N) o

GnuPG doit construire une identité pour identifier la clef.

Nom réel : Alice
Adresse électronique : alice@localhost
Commentaire :
Vous avez sélectionné cette identité :
    « Alice <alice@localhost> »

Faut-il modifier le (N)om, le (C)ommentaire, l'(A)dresse électronique
ou (O)ui/(Q)uitter ? O
Une phrase de passe est nécessaire pour protéger votre clef secrète.

De nombreux octets aléatoires doivent être générés. Vous devriez faire
autre chose (taper au clavier, déplacer la souris, utiliser les disques)
pendant la génération de nombres premiers ; cela donne au générateur de
nombres aléatoires une meilleure chance d'obtenir suffisamment d'entropie.
De nombreux octets aléatoires doivent être générés. Vous devriez faire
autre chose (taper au clavier, déplacer la souris, utiliser les disques)
pendant la génération de nombres premiers ; cela donne au générateur de
nombres aléatoires une meilleure chance d'obtenir suffisamment d'entropie.
gpg: /root/.gnupg/trustdb.gpg : base de confiance créée
gpg: clef CDB148EC marquée de confiance ultime.
les clefs publique et secrète ont été créées et signées.

gpg: vérification de la base de confiance
gpg: 3 marginale(s) nécessaire(s), 1 complète(s) nécessaire(s),
     modèle de confiance PGP
gpg: profondeur : 0  valables :   1  signées :   0
     confiance : 0 i., 0 n.d., 0 j., 0 m., 0 t., 1 u.
pub   2048R/CDB148EC 2016-09-28
 Empreinte de la clef = 7E68 6D3E 937C F4B0 AA5D  787C C638 9CF9 CDB1 48EC
uid                  Alice <alice@localhost>
sub   2048R/FF629C2C 2016-09-28
  • Exportation et publication de la clé
sudo gpg --armor --export "Alice" > /tmp/alice.asc
  • Bob importe la clé publique d'Alice
$ su - bob
$ gpg --armor --import /tmp/alice.asc
gpg: répertoire « /home/bob/.gnupg » créé
gpg: nouveau fichier de configuration « /home/bob/.gnupg/gpg.conf » créé
gpg: Attention : les options de « /home/bob/.gnupg/gpg.conf » ne sont pas encore actives cette fois
gpg: le porte-clefs « /home/bob/.gnupg/secring.gpg » a été créé
gpg: le porte-clefs « /home/bob/.gnupg/pubring.gpg » a été créé
gpg: /home/bob/.gnupg/trustdb.gpg : base de confiance créée
gpg: clef CDB148EC : clef publique « Alice <alice@localhost> » importée
gpg:       Quantité totale traitée : 1
gpg:                     importées : 1  (RSA: 1)
  • Bob envoie un message chiffré à Alice
$ su - bob

$ echo "secret pour Alice" > bob_to_alice.txt

$ sudo gpg -r Alice --encrypt --armor -o /tmp/bob_to_alice.enc bob_to_alice.txt
  • Alice déchiffre le message avec sa clé privée
$ su - alice

$ sudo gpg /tmp/bob_to_alice.enc

Une phrase de passe est nécessaire pour déverrouiller la clef secrète de
l'utilisateur : « Alice <alice@localhost> »
clef RSA de 2048 bits, identifiant FF629C2C, créée le 2016-09-28 (identifiant de clef principale CDB148EC)

gpg: chiffré avec une clef RSA de 2048 bits, identifiant FF629C2C, créée le 2016-09-28
      « Alice <alice@localhost> »
gpg: /tmp/bob_to_alice.enc : suffixe inconnu
Entrez le nouveau nom de fichier [bob_to_alice.txt]:

$ cat bob_to_alice.txt
secret pour Alice
  • Lister son trousseau de clés
$ su - alice

$ sudo gpg --list-public-keys
/root/.gnupg/pubring.gpg
------------------------
pub   2048R/CDB148EC 2016-09-28
uid                  Alice <alice@localhost>
sub   2048R/FF629C2C 2016-09-28

[alice@localhost ~]$ sudo gpg --list-secret-keys
/root/.gnupg/secring.gpg
------------------------
sec   2048R/CDB148EC 2016-09-28
uid                  Alice <alice@localhost>
ssb   2048R/FF629C2C 2016-09-28
  • Alice crée et signe un message
$ su - alice

$ echo "Peux-tu vérifier la signature ? signé Alice" > alice_to_bob.txt

$ sudo gpg --clearsign -u Alice alice_to_bob.txt

Une phrase de passe est nécessaire pour déverrouiller la clef secrète de
l'utilisateur : « Alice <alice@localhost> »
clef RSA de 2048 bits, identifiant CDB148EC, créée le 2016-09-28

$ cp alice_to_bob.txt* /tmp
  • Bob vérifie ce message
$ su - bob
$ cat /tmp/alice_to_bob.txt
Peux-tu vérifier la signature ? signé Alice
$ gpg --verify /tmp/alice_to_bob.txt.asc
gpg: Signature faite le mer 28 sep 2016 19:26:55 CEST avec la clef RSA d'identifiant CDB148EC
gpg: Bonne signature de « Alice <alice@localhost> »
gpg: Attention : cette clef n'est pas certifiée avec une signature de confiance.
gpg:             Rien n'indique que la signature appartient à son propriétaire.
Empreinte de clef principale : 7E68 6D3E 937C F4B0 AA5D  787C C638 9CF9 CDB1 48EC

8.4. Logiciels graphiques PGP

Tous ces exercices sont certainement plus éloquants avec un véritable logiciel de messagerie. Pour inspiration, Mailvelope (https://www.mailvelope.com/) est une solution qui s'intègre aux webmail comme extension Chrome ou addon Firefox.

Source : https://www.mailvelope.com/en/help, https://www.mailvelope.com/en/faq#keys

Gestion des clés

Message chiffré

9. Chiffrement de fichiers en ligne de commande

Pour l'exhaustivité, se référer à http://backreference.org/2014/08/15/file-encryption-on-the-command-line/ :

  • Openssl
  • GPG
  • aespipe
  • mcrypt
  • aescrypt
  • ccrypt
  • 7-zip

10. Cryptanalyse

La cryptanalyse est la science qui consiste à décrypter un message chiffré, c’est-à-dire tenter de déchiffrer ce message sans posséder la clé de chiffrement. Le processus par lequel on tente de comprendre un message en particulier est appelé une attaque.

Une attaque est souvent caractérisée par les données qu'elle nécessite :

  • attaque sur texte chiffré seul (ciphertext-only en anglais) : le cryptanalyste possède des exemplaires chiffrés des messages, il peut faire des hypothèses sur les messages originaux qu'il ne possède pas. La cryptanalyse est plus ardue de par le manque d'informations à disposition.
  • attaque à texte clair connu (known-plaintext attack en anglais) : le cryptanalyste possède des messages ou des parties de messages en clair ainsi que les versions chiffrées. La cryptanalyse linéaire fait partie de cette catégorie.
  • attaque à texte clair choisi (chosen-plaintext attack en anglais) : le cryptanalyste possède des messages en clair, il peut créer les versions chiffrées de ces messages avec l'algorithme que l'on peut dès lors considérer comme une boîte noire. La cryptanalyse différentielle est un exemple d'attaque à texte clair choisi.
  • attaque à texte chiffré choisi (chosen-ciphertext attack en anglais) : le cryptanalyste possède des messages chiffrés et demande la version en clair de certains de ces messages pour mener l'attaque.

Source : https://fr.wikipedia.org/wiki/Cryptanalyse

11. Attaques

11.1. Attaques

  • Faille intrinsèques
  • Fuite de bases de données
  • Rainbow Tables
  • Attaque par dictionnaire
  • Attaque Bruteforce
  • MiTM

11.2. Outils

  • Aircrack-ng
  • John the Ripper
  • Hashcat
  • Medusa
  • THC-Hydra

11.3. Vecteurs d'attaque

  • Attaque MiTM
  • Base de données

11.4. Activités

  • Chiffrer un fichier (gpg, openssl, luks, truecrypt)
  • Chiffrer un courrier
  • Calculer et vérifier une empreinte de fichier
  • Certificat autosigné
  • PKI
  • Monter un tunnel SSL
  • Routage OpenVPN
  • Gestion des politiques de mot de passe (Windows/PAM)
  • Eprouver des mots de passe (hash système SHA, LM/NTLM, cookie MD5, WEP, WPA)

11.5. Cassage

  • John the Ripper

  • Hashcat

  • Medusa ?

Hashcat sur https://www.ovh.com/fr/serveurs_dedies/details-servers-range-GPU-id-GTX-970.xml

Cf. Cassage WPA (aircrack-ng)

11.6. Attaques en ligne

11.7. Contre-mesures -> Fail2ban, snort

  • Cibles : personnes (niveau)

11.8. Attaques hors ligne

Notion de Leak / fuite

Mots de passes déjà cassés

Dictionnaire + règles de mutation

Masque : un mot de passe commence toujours par une majuscule et se termine en général par des chiffres

Les politiques de mot de passe peuvent induire les casseurs dans l'attaque de règles minimales PACK pemet de générer ces masques.

1 X GTX-970 : https://www.ovh.com/fr/serveurs_dedies/details-servers-range-GPU-id-GTX-970.xml et https://gist.github.com/epixoip/e885edc473e74398faf6

MD5 : 10 milliard /s SHA-1 : quelques milliard /s SHA-512 : 100 millions /s

11.9. Stockage et choix du mot de passe

Un mot de passe aléatoire de 15 caractères peut tenir sur 100 ans

Gestionnaires de mot de passe

Problème du stockage

  • en clair
  • en MD5 / SHA1

Notions de Salt : https://fr.wikipedia.org/wiki/Salage_(cryptographie)

Recommandation SHA512 + Salt → recalcul de condensat pour chaque utilisateur, autant de tentative que de comptes. Si le Salt n'est pas fourni, il faut le générer et recalculer le condensat pour chaque utilisateur. D'où la recommandation d'une taille critique de salt.

Pepper du site ? Il est plus facile de prendre les salt et les hashs dans les BD.

Optimisation avec plusieurs hashages

Recommandation fonctions de hachage :

Attaques Side Channel : https://fr.wikipedia.org/wiki/Attaque_par_canal_auxiliaire

Recommandation sur les mots de passes :

  • Longueur : 15
  • Complexité
  • Multiplicité aléatoire
  • Stockage : gestionnaire de mot de passe + génération
  • Fonctions solides (pas MD5/SHA1, B-Crypt/ scrypt, et Salt)
  • Attention aux capacités de chiffrement des serveurs
  • D'abord protection locale (DB), puis en ligne (selon l'efficacité en ligne).

Sources

12. Systèmes de fichiers chiffrés

Notes

  • cryptcat

Sources

Commentaires