Il en existe beaucoup et leur liste évolue avec la montée en puissance des calculateurs. En effet, aucun algorithme ne peut assurer une sécurité absolue, il peut seulement assurer un niveau de difficulté important pour le compromettre.

Ou calcul d'un condensé de document. L'objectif est de construire un condensé de taille fixe de tout type de document, tel qu'il soit:

1. impossible d'avoir le même condensé pour des documents différents (collision),
2. impossible de reconstituer, même partiellement un document d'après son condensé.

Les plus connus étant:

• MD-5 dont on a fait la preuve qu'il était possible d'obtenir des collisions et donc de falsifier un message de telle sorte qu'il présente le même condensé MD-5 que l'original. Il est donc désormais déconseillé de l'utiliser.
• Les diverses versions de SHA (Secure Hash Algorithm) dont la version SHA-256 qui produit toujours un condensé de … 265 bits, est couramment utilisé dans les suites TLS.

Le principe de signature fait toujours intervenir une paire de clés publique/privée. La signature d'un document se fait de la manière suivante:

1. calcul d'un condensé (hachage) du message, ce condensé ayant une taille fixe quelque soit celle du message à signer, uniquement fonction du protocole de hachage utilisé,
2. le condensé obtenu est chiffré avec la clé privée de l'auteur du message,
3. le message lui-même circule en clair. Il n'y a donc pas de confidentialité. Mais:
4. si le message est modifié, même très succinctement, comme par exemple ajouter ou supprimer une virgule, un point, son condensé n'aura plus aucun rapport avec le condensé initial.
5. le destinataire calcule le condensé du message reçu, déchiffre le condensé chiffré avec la clé publique de l'émetteur et compare les deux condensés. S'ils sont différents, c'est que le message a été altéré pendant son transport et donc peut être répudié par son émetteur.

Les algorithmes de signature les plus utilisés:

• RSA créé par Ronald Rivest, Adi Shamir et Leonard Adleman en 1977 et breveté (autrement-dit, propriétaire) par le MIT en 1983. Le brevet étant tombé dans le domaine public en 2000¹⁾ est désormais librement utilisable. Ce chiffrement permet la création d'une paire de clés pour le chiffrement asymétrique. Il est donc également utilisable pour le chiffrement de données.

• DSA (Digital Signature Algorithm) qui, comme son nom l'indique, n'assure que le chiffrement d'un condensé par une clé privée et en aucune manière ne peut être utilisé pour rendre un message confidentiel.

• ECDSA (Elliptic Curve Digital Signature Algorithm) est une évolution de DSA qui met en œuvre le principe des courbes elliptiques. Seuls les matheux de haut niveau peuvent comprendre…

• DSS (Digital Signature Standard) est donc un standard qui définit comment créer et vérifier des signatures numériques qui assurent l'authentification, l'intégrité et la non-répudiation des données électroniques. C'est donc une façon standardisée de signer un document, qui fait appel à ce qui a été vu plus haut:
  • un hachage avec l'une des variantes SHA‑1, SHA‑224, SHA‑256, SHA‑384 ou SHA‑512,
  • un algorithme de signature comme DSA, RSA ou ECDSA,
  • une paire de clés publique/privée.

C'est la partie qui assure la confidentialité de l'échange et qui se fait dans le cadre de HTTPS avec une clé de session et un algorithme de chiffrement symétrique. Les plus courants:

1. DES (Data Encryption Standard) désormais hors d'age, avec sa clé de seulement 56 bits.
2. AES (Advanced Encryption Standard) pour l'instant, considéré comme le plus sûr et le plus performant, s'il utilise une clé de 256 bits.
3. ChaCha20 et même ChaCha20-Poly1305 qui combine le chiffrement et l'authentification.

Tous les éléments nécessaires à l'authentification du serveur contacté se trouvent dans le certificat X509 qu'il présente à ses clients. Pour le reste, c'est-à-dire le transfert de données dans un sens comme dans l'autre doit être:

1. confidentiel, une clé de chiffrement symétrique devra être mise en place de façon sécurisée,
2. l'intégrité des données devra être assurée par un hachage signé.

Le partage d'une clé de session de façon sécurisée a été mis au point dans la décennie 1970 par deux mathématiciens spécialisés dans la cryptographie.

Whitfield Diffie et Martin Hellman, s'inspirant des puzzles de Ralph Merkel, mettent au point une procédure permettant la mise au point d'un secret partagé au vu de tous les indiscrets, sans que ces derniers puissent le récupérer.

Alice et Bob sont les préposés historiques à l'explication de cette procédure. Compte-tenu du niveau de spécialisation des auteurs de la procédure, l'explication détaillée nécessite un bagage mathématique largement hors du commun des mortels. Aussi, Alice (en rose) et Bob (en bleu, comme il se doit) vont se contenter d'une approche très schématique, en considérant quelques concepts mathématiques comme des dogmes²⁾ et les valeurs numériques utilisées ridiculement petites par rapport à la réalité des faits..

1. Alice et Bob conviennent publiquement:
   • d'un très grand nombre premier p (nous nous arrêterons à 13 pour simplifier),
   • d'un générateur G plus petit que p, mais racine primitive modulo p³⁾, 6 par exemple.
     
     
2. Alice et Bob vont maintenant tirer au sort un nombre qui sera leur clé privée. Ici aussi voyons petit:
   • 5 pour Alice,
   • 4 pour Bob.
     
     
3. Alice et Bob vont construire une clé publique en utilisant l'algorithme:
   (G^^{clé privée})modulo p
   • (6^⁵)mod 13 = 2 pour Alice,
   • (6^⁴)mod 13 = 9 pour Bob
     
     
4. Alice et Bob s'échangent leur clé publique au vu et au su de tous les indiscrets
   
   
5. Alice et Bob calculent alors le secret partagé avec la formule suivante:
   (clé_publique_de_l'autre^^{sa_propre_clé_privée}) modulo p:
   
   • Pour Alice: (9^⁵) mod 13 = 3,
   • Pour Bob: (2^⁴) mod 13 = 3 !

Étonnant non ? Et ça marche avec n'importe quel nombre premier dans p et n’importe quelle racine primitive modulo p. C'est n'est ni magique ni miraculeux, c'est juste mathématique.

Les observateurs indiscrets ont vu passer p, G, les clés publiques d'Alice et de Bob, mais pas leur clé privée. C’est l'information qui leur manque pour mener à bien leur opération d'espionnage.

Une attaque par force brute (recherche systématique des clés privées) prendra d'autant plus de temps que p sera grand, sans oublier qu'il doit être premier.

Cependant, une faiblesse existe dans le cas d'une attaque de type «man in the middle», due en réalité à la faiblesse du protocole ARP en IPv4. C'est donc une faiblesse qui n'est accessible que depuis le réseau du client ou celui du serveur.

Ceci illustrait la version originale de DH. AUjourd'hui, c'est plutôt Elliptic curve Diffie–Hellman, abrégé ECDH) qui est utilisé, mathématiquement bien plus complexe encore. Le concept cependant reste le même: la sécurité est assurée par le principe de paires de clés privée/publique.

Lorsque l'on dispose d'un nombre premier quelconque p, il est possible de définir une suite d'entiers sans trous allant de 0 à p-1. Par exemple pour le nombre premier 13: [0,1,2,3,4,5,6,7,8,9,10,11,12].

Si l'on prend un nombre entier quelconque appartenant à cette suite, G, alors nous pouvons calculer la suite des résultats de (G^i) mod p pour tout entier i appartenant à l'intervalle [0,p-1]. Un simple programme en python le fera simplement:

#!/usr/bin/env python3
# Ce programme attend deux arguments dans cet ordre:
#  - un entier représentant le nombre premier 'p'
#  - un entier représentant l'entier 'G'
# Il effectue le calcul  (G^i) mod p avec 
# 'i' variant de 1 à p-1
# et affiche la liste des résultats obtenus

import sys
def calcul(p,G):
	E=[]
	for k in range(1,p):
		E.append(G**k%p)
	return E
p = int(sys.argv[1])
G = int(sys.argv[2])
R = calcul(p,G)
print(R)

Si nous l'invoquons avec p=13 et G=4 nous obtenons:

[4, 3, 12, 9, 10, 1, 4, 3, 12, 9, 10, 1]

Le résultat est une suite récurrente ici retrouvée deux fois. Si nous l'invoquons avec p=13 et G=5 nous obtenons:

[5, 12, 8, 1, 5, 12, 8, 1, 5, 12, 8, 1]

Le résultat est une suite récurrente ici retrouvée trois fois. Si maintenant, nous l’invoquons avec p=13 et G=6:

[6, 10, 8, 9, 2, 12, 7, 3, 5, 4, 11, 1]

Le résultat est une suite qui contient tout l'ensemble [1,12], une seule fois Dans le désordre, mais tout de même. ce qui détermine le fait que 6 est une racine primitive modulo 13. Nous pouvons de même démontrer que 2 et 7 sont également de racines primitives modulo 13

Un programme un peu plus sophistiqué qui affiche la suite récurrente obtenue de façon ordonnée et déduit si G est racine primitive ou non:

def main(args):
	def calcul(p,G):
		E=[]
		for k in range(1,p):
			E.append(G**k%p)
		return sorted(set(E))
	p = int(sys.argv[1])
	G = int(sys.argv[2])
	R = calcul(p,G)
	print(R)
	if len(R) == p-1:
		print("{} est une racine primitive de {}".format(G,p))
	else:
		print("{} n'est pas une racine primitive de {}".format(G,p))

if __name__ == '__main__':
	import sys
	sys.exit(main(sys.argv))