Chiffre XOR - XOR cipher

En cryptographie , le chiffrement XOR simple est un type de chiffrement additif , un algorithme de chiffrement qui fonctionne selon les principes :

A 0 = A,${\style d'affichage \oplus }$

A A = 0,${\style d'affichage \oplus }$

A B = B A,${\style d'affichage \oplus }$${\style d'affichage \oplus }$

(A B) C = A (B C),${\style d'affichage \oplus }$${\style d'affichage \oplus }$${\style d'affichage \oplus }$${\style d'affichage \oplus }$

(B A) A = B 0 = B,${\style d'affichage \oplus }$${\style d'affichage \oplus }$${\style d'affichage \oplus }$

où désigne l'opération de disjonction exclusive (XOR). Cette opération est parfois appelée addition de module 2 (ou soustraction, qui est identique). Avec cette logique, une chaîne de texte peut être chiffrée en appliquant l'opérateur XOR au niveau du bit à chaque caractère utilisant une clé donnée. Pour déchiffrer la sortie, il suffit de réappliquer la fonction XOR avec la clé pour supprimer le chiffrement. ${\style d'affichage \oplus }$

Exemple

Par exemple, la chaîne "Wiki" ( 01010111 01101001 01101011 01101001 en ASCII 8 bits ) peut être chiffrée avec la clé répétitive 11110011 comme suit :

	01010111 01101001 01101011 01101001
${\style d'affichage \oplus }$	11110011 11110011 11110011 11110011
=	10100100 10011010 10011000 10011010

Et inversement, pour le décryptage :

	10100100 10011010 10011000 10011010
${\style d'affichage \oplus }$	11110011 11110011 11110011 11110011
=	01010111 01101001 01101011 01101001

Utilisation et sécurité

L'opérateur XOR est extrêmement courant en tant que composant dans des chiffrements plus complexes. En soi, en utilisant une clé à répétition constante, un simple chiffrement XOR peut être trivialement cassé à l'aide d' une analyse de fréquence . Si le contenu d'un message peut être deviné ou autrement connu, la clé peut être révélée. Son principal mérite est qu'il est simple à mettre en œuvre et que l'opération XOR est peu coûteuse en calcul. Un simple chiffrement XOR à répétition (c'est-à-dire utilisant la même clé pour une opération xor sur l'ensemble des données) est donc parfois utilisé pour cacher des informations dans les cas où aucune sécurité particulière n'est requise. Le chiffrement XOR est souvent utilisé dans les logiciels malveillants informatiques pour rendre la rétro-ingénierie plus difficile.

Si la clé est aléatoire et est au moins aussi longue que le message, le chiffrement XOR est beaucoup plus sûr que lorsqu'il y a une répétition de clé dans un message. Lorsque le flux de clés est généré par un générateur de nombres pseudo-aléatoires , le résultat est un chiffrement de flux . Avec une clé vraiment aléatoire , le résultat est un pavé unique , incassable en théorie .

Dans n'importe lequel de ces chiffrements, l'opérateur XOR est vulnérable à une attaque de texte en clair connu , puisque texte en clair ciphertext = key . Il est également trivial de retourner des bits arbitraires dans le texte en clair déchiffré en manipulant le texte chiffré. C'est ce qu'on appelle la malléabilité . ${\style d'affichage \oplus }$

Utilité en cryptographie

La principale raison pour laquelle XOR est si utile en cryptographie est qu'il est « parfaitement équilibré » ; pour une entrée de texte en clair donnée 0 ou 1, le résultat du texte chiffré est également susceptible d'être 0 ou 1 pour un bit de clé vraiment aléatoire.

Le tableau ci-dessous montre les quatre paires possibles de texte en clair et de bits de clé. Il est clair que si rien n'est connu sur la clé ou le texte en clair, rien ne peut être déterminé à partir du texte chiffré seul.

D'autres opérations logiques telles que AND ou OR n'ont pas un tel mappage (par exemple, AND produirait trois 0 et un 1, donc sachant qu'un bit de texte chiffré est un 0 implique qu'il y a 2/3 de chance que le texte en clair d'origine bit était un 0, par opposition à la 1/2 chance idéale dans le cas de XOR)

Exemple d'implémentation

Exemple utilisant le langage de programmation Python .

from os import urandom

def genkey(length: int) -> bytes:
    """Generate key."""
    return urandom(length)

def xor_strings(s, t) -> bytes:
    """xor two strings together."""
    if isinstance(s, str):
        # Text strings contain single characters
        return b"".join(chr(ord(a) ^ ord(b)) for a, b in zip(s, t))
    else:
        # Bytes objects contain integer values in the range 0-255
        return bytes([a ^ b for a, b in zip(s, t)])

message = 'This is a secret message'
print('Message:', message)

key = genkey(len(message))
print('Key:', key)

cipherText = xor_strings(message.encode('utf8'), key)
print('cipherText:', cipherText)
print('decrypted:', xor_strings(cipherText, key).decode('utf8'))

# Verify
if xor_strings(cipherText, key).decode('utf8') == message:
    print('Unit test passed')
else:
    print('Unit test failed')

Voir également

• Chiffre Vernam
• Chiffre de Vigenère

Les références

Remarques

Citations

Sources