Tp / Td

Cours
Ex ...

Table des matières

1) introduction......................................................................................................................................1
2) Bite de parité....................................................................................................................................1
3) checksum..........................................................................................................................................2

1) introduction
On se propose d’étudier deux techniques de détection d’erreurs dans la transmission de données sur
des moyens de communication non fiables. L’adjonction d’un bit de parité est utilisée un peu
partout : c’est la «clé» dans un numéro de sécurité sociale ou de compte bancaire, ou le treizième
chiffre d’un code barre de supermarché.
Quant au codage CRC, c’est la principale méthode de détection d’erreurs utilisée dans les
télécommunications.
Les données transitant sur le réseau sont des séquences de bits que l’on notera 0 ou 1. Ces
séquences de bits sont découpés en mots b0b1 … bn-1 de longueur n > 1, que l’on représentera par un
tableau d’entiers [|b0;b1; ... ;bn-1|], avec bi  [0;1].
Le nombre d’erreurs de transmission du mot b est le nombre de bits ayant changé de valeur après
transmission.

2) Bit de parité
Le «ou exclusif» de deux bits x et y est noté x  y et est défini par la table de valeurs suivante :

Il s’agit de rajouter un bit de parité par exemple pour un caractère ASCII codé sur 7 bits, on ajoute
un huitième bit.
Le bit de parité est le MSB il signifie : qu’une parité PAIRE que l’octet envoyé est constitué d’un
nombre paire de 1. Il est a noté que le bit de parité fait parti de la parité du mot. Ce contrôle est
aussi appelé Vertical Redundancy Check).

Se système gagne en efficacité si il lui est associé un contrôle horizontal, en insérant un mot de
contrôle de parité semblable au bit de parité.
 Tp / Td
Cours
Ex ...

compléter le message suivant

Parité PAIRE
64 32 16 8 4 2 1
Mot a émettre B 66
O 79
N 78
J 74
O 79
U 85
R 82
Clef

3) checksum

Une somme de contrôle sur s bits est obtenue en additionnant des blocs de b bits modulo 2s
Généralement b = 8 bits

exemple
6 a 3 7 d 3
0110 1010 0011 0111 1101 0011

La séquence transmise sera alors 6A37D37416

avec s=8 donc modulo 28=256
• 3 octet 6A 37 D3
• en décimal 106 55 211
somme mod 256= (106+55+211)%256=372%256=116
• 116 en hexadécimal=74

calcul du checksum dans une entête ip :

Le checksum de l'en-tête IP est généralement calculé en utilisant la somme de

contrôle (checksum) complément à un.
 Tp / Td
Cours
Ex ...

1. Divisez l'en-tête IP en mots de 16 bits.

2. Additionnez tous les mots de 16 bits.
3. Ajoutez le report (carry) de l'addition à la somme.
4. Prenez le complément à un de la somme obtenue.

En termes de formules mathématiques, si nous notons les mots de 16 bits comme W0,
W1, ..., Wn, et la somme comme S, le calcul serait représenté comme suit :

S=W 0 +W 1 +W 2 +...+W n
S=S +(S ≫16)
checksum=complément à un de S

Où ">>" représente le décalage de bits vers la droite. Cela garantit que tout report
(carry) est ajouté à la somme.

Il est important de noter que le checksum est utilisé pour détecter des erreurs dans
l'en-tête IP pendant la transmission des données, mais il n'est pas
cryptographiquement sécurisé et ne doit pas être utilisé à des fins de sécurité.

Exemple:
Pour calculer le checksum de l'en-tête IP le checksum est 8EA4 il est important de le mettre a 00 00
pour faire le calcul.
L’entête (45000028df0400007c068ea423f4eb1bc0a8016f), voici les étapes :

Divisez l'en-tête IP en mots de 16 bits :

4500 0028 df04 0000 7c06 0000 23f4 eb1b c0a8 016f
37158 on additionne les valeurs en plaçant le checksum à 00 00

37158 3715 371 37 3 On décale le binaire de 16 donc on divise par 216

ou plus simple on enlève 4 caractères (4 bits *4)

3715B On additionne la retenue

715B 8EA4 On conserve les 2 derniers octet et on complément a 1 (on cherche FFFF)

Additionnez tous les mots de 16 bits : attention tout est en hexadécimal

4500+0028+df04+0000+7c06+8ea4+23f4+eb1b+c0a8+016f=3 7158

Ajoutez le report (carry) de l'addition à la somme :

3 7158+(3 7158>>16)=3 7158+3=3 715B

Prenez le complément à un de la somme obtenue (sur 2 octet on oublie le msb ici il a déjà été pris
en compte dans le calcul précédent):
 Tp / Td
Cours
Ex ...

On cherche en fait a faire 715B-FFFF=8EA4 (vous pouvez repasser en décimal pour faire ce
calcul)
checksum = complément a un de (715B)=8EA4

exercice a l’aide wireshark les exercices ne manque pas !

***entête IP ayant comme checsum 0x a7 0a***

45 00 00 28 c6 9e 00 00 7c 06 00 00 23 f4 eb 1b c0 a8 01 6f

0000
on additionne les valeurs en plaçant le checksum à 00 00

On décale le binaire de 16 donc on divise par 216

ou plus simple on enlève 4 caractères (4 bits *4)

On additionne la retenue

On conserve les 2 derniers octet et on complément a 1 (on cherche FFFF)

compléter le programme php suivant permettant la vérification de vos calcul :

Html et css Php

<html> <?php
<!DOCTYPE html> // Vérifier si le formulaire a été soumis
<html lang="en"> if ($_SERVER["REQUEST_METHOD"] == "POST") {
<head> // Récupérer l'entête IP à partir du formulaire
<meta charset="UTF-8"> $enteteIP = isset($_POST["header"]) ? $_POST["header"] : "";
<meta name="viewport" content="width=device-width, initial- // Appeler la fonction de calcul du checksum
scale=1.0"> $checksum = calculerChecksumIP($enteteIP);
<title>Calcul du Checksum IP</title> // Afficher le résultat
<style> echo "<p>Checksum IP calculé : $checksum</p>";
body { }
font-family: Arial, sans-serif;
margin: 20px; // Fonction PHP pour calculer le checksum IP
} function ??????????????(??????????????) {
form { // Convertir la chaîne hexadécimale en tableau d'octets
max-width: 400px; $enteteIP = hex2bin(str_replace(' ', '', $enteteIPHex));
margin: auto; $checksum = ?????;
padding: 20px; // Calculer la somme des mots de 16 bits
border: 1px solid #ccc; for ($i = 0; $i < strlen($enteteIP); $i += 2) {
border-radius: 5px; $mot16bits = ord($enteteIP[$i]) << 8 | ord($enteteIP[$i + 1]);
} $checksum += $mot16bits;
label { // Gestion du débordement de 16 bits
display: block; if ($checksum > 0xffff) {
margin-bottom: 8px; $checksum = ($checksum & 0xffff) + 1;
} }
input { }
width: 100%; // Prendre le complément à un du résultat
padding: 8px; $checksum = ~$checksum & 0xffff;
margin-bottom: 15px; return dechex($checksum);
box-sizing: border-box; }
} /*
button { 0000 a0 36 bc 2e 29 72 38 07 16 17 e1 24 08 00 45 00 .6..)r8....$..E.
background-color: #4CAF50; 0010 00 28 c6 9e 00 00 7c 06 a7 0a 23 f4 eb 1b c0 a8 .(....|...#.....
color: white; 0020 01 6f 01 bb d8 54 c5 f4 66 ce 43 bc 82 13 50 10 .o...T..f.C...P.
padding: 10px 15px; 0030 07 9d 0a 6e 00 00 00 00 00 00 00 00 ...n........
border: none; ***entête IP ayant comme checsum 0xa7 0a***
border-radius: 5px; 45 00 00 28 c6 9e 00 00 7c 06 00 00 23 f4 eb 1b c0 a8 01 6f */
cursor: pointer; ?>
}
</style>
</head>
 Tp / Td
Cours
Ex ...

<body>
<form method="post" action="">
<label for="header">Entrez l'entête IP :</label>
<textarea name="header" id="header" rows="4"
required></textarea>
<button type="submit">Calculer Checksum</button>
</form>
</body>
</html>

Noter les fonctions php que vous avez appris avec le programme précédent et proposer
l’algorithme

4) le contrôle de redondance cyclique CRC ou fcs

On voit l’entête Ethernet le fsc b6 5e 64 38 est noté comme faux dans wiresark.

38071617e124a036bc2e297208004500005e789f400080060000c0a8016f03441246fadc01bb8d82d4
5b0f87dace50180401d7f100001703030031b9f079a5e2c7bb7061e018a43b0e15961740bd03c9c608
7c57e5327557d90e30021b7252ef1def08092e812b4bb65e6438

4.1) Principe

Le CRC (Cyclic Redundancy Check) est un algorithme de vérification d'erreur utilisé pour détecter
des erreurs dans les données, en particulier lors de la transmission ou du stockage de données
numériques. Il est largement utilisé dans les réseaux informatiques, les communications sans fil, le
stockage de données, et d'autres applications où la précision des données est cruciale.

Voici une explication de base du fonctionnement du CRC :

1. Polynôme générateur : Le CRC utilise un polynôme générateur, qui est une séquence binaire
définie à l'avance. Ce polynôme est utilisé pour effectuer les opérations de division dans le
processus de calcul du CRC.

2. Division binaire : Les données à protéger (par exemple, un message) sont traitées comme un
nombre binaire. Un nombre supplémentaire de bits, appelé "reste", est ajouté à ces données
de manière à ce que la division par le polynôme générateur donne un reste nul. Ce reste est
généralement de taille fixe et est le CRC.

3. Émission du message : Les données originales avec le CRC nouvellement calculé sont
envoyées ou stockées.

4. Vérification du CRC : Lorsque les données sont reçues ou récupérées, le CRC est recalculé à
partir des données reçues. Si le CRC recalculé correspond au CRC inclus avec les données,
 Tp / Td
Cours
Ex ...

cela indique que les données n'ont probablement pas été altérées pendant la transmission ou
le stockage. Sinon, cela suggère la présence d'erreurs.

Le CRC est efficace pour détecter la plupart des erreurs courantes, telles que les bruits de canal ou
les altérations accidentelles des données. Il est principalement utilisé comme un outil de détection
d'erreurs dans des environnements où une petite probabilité d'erreur est acceptable.

4.2) Polynôme, code binaire et division polynomial

Toute transmission de donnée peut être traduit en polynôme où chaque bit donne un coefficient
polynomial correspondant
soit le bloc de données à transmettre de n bits il sera écrit sous la forme de polynôme de degré
N-1 : P(x). Ce P(x) sera divisé par un polynôme générateur G(x). Le quotient de cette division
sera le CRC

Exemple : 1 0 1 0→1. x3 +0. x 2 +1. x1 +0 → x 3 + x

Nb :
Le choix du polynôme générateur est fonction de la qualité du résultat du CRC. Sans rentrer dans
les détails mathématiques, le plus simple est d'utiliser ceux qui sont définie comme étant de bonne
qualité. Les CRC-16 et 32 donne une fiabilité de près de 100% au niveau de l'intégrité de la trame.
Exemples :

Nom Polynôme générateur (le même pour émission et la réception)

CRC-4 x4 + x2 + x1 + 1
CRC-12 x12 + x11 + x3 + x2 + x1 + 1
CRC-16 SDLC (CCITT) x16 + x12 + x5 +1
CRC-16 x16 + x15 + x2 +1
CRC-16 Reverse x16 + x14 + x1 +1
SDLC Reverse x16 + x11 + x4 +1
CRC-32 (ethernet) x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x1 + 1

Pour l’émetteur
• le message à transmettre à l’origine de n bits sera associé à un polynôme de degré n-1 : P(x)
• On choisi le polynôme générateur G(x)
• on calcul P’(x) avec P ' ( x)=P( x)⋅X k ou k et le degré de G(x)
• on divise P’(x) par G(x) pour obtenir le reste R(x) qui sera le crc
P ' (x )
=Q( x )⋅G( x )+ R( x)
G( x )
• l’addition ou la soustraction de P’(x) et de R(x) nous donne le message à transmettre
T (x )= P '( x )− R( x)=P ' ( x)+ R( x )
Pour le récepteur
• Le message reçu R(x) (si tout c’est bien passé c’est le R(x)=T(x) )
• On divise R(x) par le même G(x)
◦ Si on trouve un reste nul il y a une forte probabilité que la transmission soit correcte
 Tp / Td
Cours
Ex ...

◦ Si le reste est non nul il y a une erreur

Exemple :

6 4 3
M 0x5B 1011011 P( x)= X + X + X + X +1
4
G(x) 0x13 10011 G( x )= X + X +1
6 4 3 4 10 8 7 5 4
P’(x) k=4 1011011 0000 P ' ( x)=( X + X + X + X +1)⋅X = X + X + X + X + X
R ' ( x) 1100 3
R ' ( x)= X + X
2

10 8 7 5 4 3 2
T(x) 1011011 1100 P ' ( x)= X + X + X + X + X + X + X

Détail de la division

Division polynomial Division binaire

exercice

vérifier vos calcul avec le programme python suivant :

Prompt utilisé :
calcul de crc en python ayant comme entrée le polynôme message et le polynôme générateur

Python
def calculate_crc(message, generator_polynomial):
# Convertir le message et le polynôme générateur en listes de bits
message_bits = [int(bit) for bit in bin(int(message, 16))[2:]]
generator_bits = [int(bit) for bit in bin(int(generator_polynomial, 16))[2:]]

# Ajouter des zéros à la fin du message pour la division

message_bits += [0] * (len(generator_bits) - 1)

# Effectuer la division binaire

for i in range(len(message_bits) - len(generator_bits) + 1):
if message_bits[i] == 1:
for j in range(len(generator_bits)):
message_bits[i + j] ^= generator_bits[j]

# Récupérer le reste de la division comme CRC

 Tp / Td
Cours
Ex ...

crc = message_bits[-len(generator_bits) + 1:]

# Formater le résultat en hexadécimal

crc_hex = hex(int(''.join(map(str, crc)), 2))[2:].upper()

return crc_hex

# Exemple d'utilisation
message = "45000028DF0400007C068EA423F4EB1BC0A8016F"
generator_polynomial = "04C11DB7"
crc_result = calculate_crc(message, generator_polynomial)

print(f"Message: {message}")
print(f"Polynôme générateur: {generator_polynomial}")
print(f"CRC: {crc_result}")

Traduire l’organigramme en algorithme

A quoi correspond le symbole ^ dans le calcul binaire vous faite le lien avec la soustraction ?
Quelle est le polynôme générateur ?
Quelle est le rôle de l’opérateur <<

organigramme Exemple de calcul binaire

Vérifier la trame de wireshark du début :

CRC-32 (ethernet) x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x1 + 1
en binaire 1 0000 0100 1100 0001 0001 0101 1011 0111
 Tp / Td
Cours
Ex ...

En hexa 1 04C1 1DB7

38071617e124a036bc2e297208004500005e789f400080060000c0a8016
f03441246fadc01bb8d82d45b0f87dace50180401d7f100001703030031b
9f079a5e2c7bb7061e018a43b0e15961740bd03c9c6087c57e5327557d9
0e30021b7252ef1def08092e812b4bb65e6438

On voit l’entête Ethernet le fsc b6 5e 64 38 est noté comme faux dans wiresark.