OCCrypto

Quelques éléments de
Cryptographie
SageMath et Python (3OCmath)
Cruptos (χρυπτoς) : caché, dissimulé
Graphein (γραφιν) : écrire
Jean-Philippe Javet
www.javmath.ch
Table des matières
1 Un doigt d’algorithmique, intro à SageMath 1

1.1 Algorithmes, pseudo-code, SageMath . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Variables et listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Opérations sur les variables du type nombre . . . . . . . . . . . . . . . . . . 4
1.2.2 Opérations sur les variables du type liste . . . . . . . . . . . . . . . . . . . . 6
1.2.3 Opérations sur les variables du type string . . . . . . . . . . . . . . . . . . . 7
1.3 Les boucles for. . . ou while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 Les conditions : if. . . ou if. . . else. . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5 Affichage avancé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6 Une fonction qui en appelle une autre . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.7 Pour aller un peu plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Nombres premiers 15
2.1 Quoi de plus simple qu’un nombre premier ? . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Test de primalité d’un nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3 Le crible d’Ératosthène . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4 Pour aller un peu plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3 Chiffrement de César et congruence 25

3.1 Trois exercices en guise d’introduction . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2 Quelques éléments sur la congruence . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.3 La cryptographie, le chiffrement de César . . . . . . . . . . . . . . . . . . . . . . . . 28
3.4 Pour aller un peu plus loin au sujet de la congruence . . . . . . . . . . . . . . . . . 34
3.5 Et la division modulo n ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4 Chiffrement affine, algorithmes d’Euclide et Bézout 41

4.1 Le chiffrement affine (début) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
4.2 PGDC, Algorithme d’Euclide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.3 L’égalité de Bézout (ou identité de Bézout) . . . . . . . . . . . . . . . . . . . . . . . 46
4.4 Le chiffrement affine (suite) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.5 Un exemple de cryptanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.6 Un exemple de chiffrement polyalphabétique . . . . . . . . . . . . . . . . . . . . . . 54
I
II
5 La cryptographie à clé publique : RSA 57

5.1 Quelques nouveaux outils mathématiques . . . . . . . . . . . . . . . . . . . . . . . . 57
5.2 La cryptographie à clé publique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
5.3 La cryptographie et les transactions bancaires (WEB) . . . . . . . . . . . . . . . . . 65
5.4 Il n’y a pas que la base 10 dans la vie. . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.5 Quelques bases utilisées dans le passé ou actuellement : . . . . . . . . . . . . . . . 68
5.6 Conversion d’une base vers une autre : . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.7 Les opérations en binaire (ou toute autre base. . . ) : . . . . . . . . . . . . . . . . . . 70
A Bibliographie 73
A Quelques éléments de solutions I

A.1 Un doigt d’algorithmique avec SageMath . . . . . . . . . . . . . . . . . . . . . . . . I
A.2 Nombres premiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VI
A.3 Codage de César et congruence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XII
A.4 Codage affine, algorithmes d’Euclide et Bézout . . . . . . . . . . . . . . . . . . . . . XVIII
A.5 La cryptographie à clé publique : RSA . . . . . . . . . . . . . . . . . . . . . . . . . XXV
Malgré le soin apporté lors de sa conception, le polycopié que vous avez entre les mains contient certainement
quelques erreurs et coquilles. Merci de participer à son amélioration en m’envoyant un mail :
jeanphilippe.javet@vd.educanet2.ch
Merci ;-)
Un doigt d’algorithmique, intro à SageMath
1
1.1 Algorithmes, pseudo-code, SageMath
Introduction: Un algorithme est un moyen pour un humain de présenter la réso-

lution par calcul d’un problème à une autre personne physique (un
autre humain) ou virtuelle (un calculateur). En effet, un algorithme
est un énoncé dans un langage bien défini d’une suite d’opérations
permettant de résoudre par calcul un problème.
Les algorithmes, dont on a retrouvé des descriptions exhaustives,
ont été utilisés dès l’époque des Babyloniens (env. 1500 av. J-C.)
pour des calculs concernant le commerce et les impôts. L’algorithme
le plus célèbre est celui qui se trouve dans le livre 7 des Éléments
d’Euclide. Il permet de trouver le plus grand diviseur commun, ou
PGDC, de deux nombres (env. 300 av. J-C.).
L’algorithmique a été systématisée par le mathématicien perse Al
Khuwarizmi, auteur d’un ouvrage (souvent traduit par l’algèbre et
le balancement) qui décrit des méthodes de calculs algébriques.
Actuellement, un algorithme énonce une résolution sous la forme
Al Khuwarizmi
d’une série d’opérations à effectuer. La mise en œuvre de l’al-
(env. 780 - 850)
gorithme consiste en l’écriture de ces opérations dans un langage de
programmation et constitue alors la brique de base d’un programme
informatique.
En programmation, le pseudo-code est une façon de décrire un
Projet algorithme sans référence à un langage de programmation en
particulier.
Algorithme(s)
L’écriture en pseudo-code permet souvent de bien prendre toute la
Pseudo-code
mesure de la difficulté de la mise en œuvre de l’algorithme, et de
développer une démarche structurée dans la construction de celui-ci.
Programmation Il n’existe pas de réelle convention d’écriture pour le pseudo-code.
dans un langage
à choisir La dernière étape consistera à traduire le pseudo-code en langage de
programmation afin de pouvoir faire « tourner » cet algorithme sur
un calculateur. Le langage de programmation que nous utiliserons
Produit fini
est celui implémenté dans SageMath. Il est basé sur un langage
moderne appelé le Python.
Observons ceci sur un premier exemple :
1
2 CHAPITRE 1. UN DOIGT D’ALGORITHMIQUE, INTRO À SAGEMATH
Projet: Concevoir un programme permettant de calculer le résultat du

calcul :
1 ¨ 2 ¨ 3 ¨ ... ¨ n
que l’on note n! (n factorielle). Ce programme devra pouvoir calculer
par exemple 17 !.
1re étape: Le pseudo-code :
fonction factoriellepnq :
pÐ1
pour k P r1 , ns :
pÐp¨k
retourner p
Avant de transcrire ce pseudo-code sur SageMath, il est important

de le tester “à la main” afin de vérifier que celui-ci permet bien de
calculer ce que l’on désire. Ceci peut se faire à l’aide d’un tableau :
Variables
n k p
Entrée
Initialisation
1re boucle
2e boucle
3e boucle
...........
2e étape: Programmation en SageMath :
def factorielle ( n ):
p =1
for k in [1.. n ]:
p=p*k
return p
Après avoir validé cette fonction en appuyant simultanément sur les
touches [Majuscule] et [Retour], on obtient :
factorielle (17)
|355687428096000
Exercice 1.1 Programmer les lignes ci-dessus dans SageMath puis vérifier la valeur
obtenue pour 17 !
Calculer ainsi 40 ! puis 100 !
CHAPITRE 1. UN DOIGT D’ALGORITHMIQUE, INTRO À SAGEMATH 3
Remarque: Vous avez constaté que SageMath a respecté automatiquement l’in-

dentation des lignes. Les blocs de code (fonctions, instructions
if, boucles for ou while etc.) sont définis par leur indentation. L’in-
dentation démarre le bloc et la désindendation le termine. Si vous
ne respectez pas ces décalages de 4 espaces (ou 1 tabulation), vous
obtiendrez probablement un message d’erreur.
Pour mettre un bloc dans un bloc, il suffit donc de décaler le
deuxième par rapport au premier, comme on le voit ci-dessus.
Exercice 1.2 Et si les résultats partiels des calculs nous intéressent, on peut
créer une liste dans laquelle on va stocker toutes les factorielles
précédentes. Programmer les lignes suivantes :
def newfactorielle ( n ):
p =1; Liste =[]
for k in [1.. n ]:
p=p*k
Liste = Liste +[ p ]
return Liste
Et vérifiez que vous obtenez bien :
newfactorielle (7)
|[1 , 2 , 6 , 24 , 120 , 720 , 5040]
1.2 Variables et listes

Une variable informatique est une “case mémoire” qui permet de
stocker une information.
‚ Elle peut être du type nombre :
nombre =12
print nombre
|12
On affecte une valeur à une variable par le signe =.
La commande print permet d’en afficher le contenu.
‚ Elle peut être du type chaîne de caractères (string) :

texte = " Un premier texte "
print texte
| Un premier texte
Une chaîne de caractères doit toujours être encadrée par des
guillemets simples ’. . .’ ou doubles ". . . ".
‚ Elle peut être du type liste :

Listevide =[]
Listenombre =[2 ,4 ,6]
Listetexte =[ " Bonjour " ," Salut " ]
print Listevide , Listenombre , Listetexte
|[] [2 , 4 , 6] [ ’ Bonjour ’ , ’ Salut ’]
En séparant chaque item par une virgule, il est possible d’en
afficher (print) plusieurs successivement.
‚ Elle peut être du type booléen :

Test = True
print Test
| True
Les variables de type booléen peuvent prendre deux valeurs :
False, True. Elles seront utilisées lors de conditions de type
“Si. . . alors. . .” ou “Tant que”.
1.2.1 Opérations sur les variables du type nombre

On peut effectuer des opérations mathématiques sur les variables.
Par exemple, on peut augmenter une variable de 1 :
n =3
n = n +1
print n
|4
Le pseudo-code correspondant sera :
nÐ3
nÐn`1
afficher n
On peut également proposer cette opération sous la forme d’une

fonction dont le pseudo-code est :
fonction successeurpnq :
nÐn`1
retourner n
Celle-ci permet de calculer puis de retourner (Return n) le succes-

seur du nombre indiqué.
3 4
n n`1
Exercice 1.3 Traduire le pseudo-code précédent en une fonction SageMath afin

d’obtenir :
successeur (3)
|4
Que va faire la commande suivante ?
successeur ( successeur (3))
Exercice 1.4 Voici un pseudo-code :
fonction mysterepa,bq :
aÐa`b
bÐa´b
aÐa´b
retourner a,b
a) Tester ce pseudo-code “à la main” en utilisant les couples de

nombres (7,5) puis (3,9). Quel résultat obtient-on ?
b) Programmer en SageMath cet algorithme et vérifier que :
mystere (2 ,10)
|(10 ,2)
Remarque: Dans l’exercice précédent, la fonction mystere(a,b) admet 2 valeurs

en entrée (input) et 2 valeurs en sortie (output). On peut donc
symboliser ceci par le schéma :
p2 , 10q p10 , 2q
pa , bq pb , aq
1.2.2 Opérations sur les variables du type liste

‚ Une liste est une collection ordonnée d’objets qui est délimitée
par des crochets :
Maliste =[2 ,4 ,6 ,8 ,10]
‚ On accède à un élément d’une liste au moyen de son index. L’in-

dexage débute à 0. Donc pour récupérer le 4e élément de la liste,
il s’agira de proposer :
Maliste [3]
|8
‚ La taille d’une liste s’obtient avec la commande len :

len ( Maliste )
|5
‚ Voici deux petits algorithmes permettant de parcourir une liste

et d’afficher chacun de ses éléments :
for index in [0.. len ( Maliste ) -1]:
print Maliste [ index ]
Ou de façon plus élégante et concise :
for element in Maliste :
print element
Les 2 fourniront :
|2
|4
|6
|8
|10
‚ Pour ajouter un élément en queue de liste, par exemple 12 :

Maliste = Maliste +[12]
Et ainsi :
print Maliste
|[2 ,4 ,6 ,8 ,10 ,12]
‚ Lorsque l’on crée une liste par ajout d’éléments, il faut toujours
s’assurer que cette liste ait été définie préalablement. La fonction
suivante va engendrer une erreur :
def liste (a , b ):
Maliste = Maliste +[ a ]+[ b ]
return Maliste
En effet, on obtient plusieurs lignes dont la dernière :
liste (2 ,3)
| Error in lines 1 -1
|(...)
| local variable ’ Liste ’ referenced before assignment
La liste Maliste doit donc être initialisée vide au début de la
fonction :
def liste (a , b ):
Maliste =[]
Maliste = Maliste +[ a ]+[ b ]
return Maliste
Et ainsi :
liste (2 ,3)
|[2 , 3]
‚ Pour fusionner (concaténer) deux listes, on utilise une démarche

semblable :
Liste1 =[ " coucou " ," salut " ]
Liste2 =[1 ,2]
Liste3 = Liste1 + Liste2
print Liste3
|[ ’ coucou ’ , ’ salut ’ , 1 , 2]
1.2.3 Opérations sur les variables du type string

Une chaîne de caractères (string) est un objet délimité par des apos-
trophes simples ou doubles (guillemets) et dont les manipulations
ressemblent à celles d’une liste :
chaine1 = " Bonjour "
chaine2 = " cher "
chaine3 = " ami "
chaine = chaine1 + chaine2 + chaine3
print len ( chaine1 )
print chaine
print chaine [2]
|8
| Bonjour cher ami
|n
ou encore :
for lettre in chaine3 :
print lettre
|a
|m
|i
1.3 Les boucles for. . . ou while. . .

La structure de boucles sert à répéter une opération un nombre de
fois n déterminé à l’avance (for i in [1..n]) :) ou tant qu’une condition
est respectée (while . . . :).
for . . . in . . . : Les boucles de type for permettent d’effectuer les mêmes calculs pour
toutes les valeurs entières d’un compteur k P ta, . . . ,bu. L’exemple
suivant affiche le début de la table de multiplication par 7 :
Mult7 =[]
for k in [1..5]:
Mult7 = Mult7 +[ k *7]
print Mult7
|[7 , 14 , 21 , 28 , 35]
Attention de ne pas oublier d’initialiser la liste Mult7 avant d’y
ajouter les multiples.
Exercice 1.5 a) Créer la liste L1 des nombres compris entre -3 et 3.

b) Créer la liste L2 des carrés des nombres compris entre -2 et 4.
c) Créer la liste L3 en fusionnant les 2 listes.
d) Créer la liste L4 qui contiendra à chaque index la somme des
termes correspondants des listes L1 et L2.
Vous obtiendrez :
|[ -3 , -2 , -1 , 0 , 1 , 2 , 3]
|[4 , 1 , 0 , 1 , 4 , 9 , 16]
|[ -3 , -2 , -1 , 0 , 1 , 2 , 3 , 4 , 1 , 0 , 1 , 4 , 9 , 16]
|[1 , -1 , -1 , 1 , 5 , 11 , 19]
while: L’autre famille de boucles est constituée des boucles tant que. Comme
les boucles de type for, elles permettent d’effectuer un certain nombre
de fois les mêmes instructions ; en revanche le nombre de répétitions
n’est pas fixé au début, mais dépend de la réalisation d’une condition.
L’exemple suivant calcule et stocke dans une liste les multiples de 7
inférieurs à 60 :
Mult7 =[]; k =1
while 7* k <60:
Mult7 = Mult7 +[7* k ]
k = k +1
print Mult7
|[7 , 14 , 21 , 28 , 35 , 42 , 49 , 56]
Exercice 1.6 a) Proposer le pseudo-code de cette dernière programmation.

b) Tester votre pseudo-code “à la main”.
c) Reconvertir votre pseudo-code en une programmation SageMath.
Exercice 1.7 On considère le pseudo-code suivant :
fonction mysterepnq :
pÐ1
kÐ1
tant que k ă n ` 1 :
pÐp¨k
k Ðk`1
retourner p
a) De quel algorithme s’agit-il ? Quel nombre obtient-on en tes-

tant ce pseudo-code “à la main” pour n “ 3.
b) Le programmer en SageMath et contrôler que l’on obtient :
mystere (11)
|39916800
fonction divmodpn,pq :
jÐ0
tant que n ą“ p :
nÐn´p
j Ðj`1
retourner j,n
a) De quel algorithme s’agit-il ?

Quels nombres obtient-on en le testant à la main pour les
paires de nombres (17,6) puis (20,5).
b) Le programmer en SageMath et contrôler que l’on obtient :
divmod (142 ,6)
|(23 , 4)
Remarque: Les deux nombres obtenus précédemment joueront un rôle très

important par la suite. Nous utiliserons les fonctions existantes dans
SageMath :
‚ Le quotient de la division d’un nombre n par p s’obtient à
l’aide de la commande :
142//6
|23
‚ Le reste de la division d’un nombre n par p s’obtient à l’aide
de la commande :
142%6
|4
Cette dernière commande se lit : 142 modulo 6 et donne 4.
1.4 Les conditions : if. . . ou if. . . else. . .

Une autre instruction importante est le test : les instructions exécu-
tées dépendent alors de la valeur booléenne (True ou False) d’une
condition. La structure et deux syntaxes possibles de cette instruc-
tion sont les suivantes :
if une condition : if une condition :

une suite une suite
d’instructions d’instructions
... else:
d’autres
instructions
...
Le formalisme des conditions seront identiques à celles utilisées pour

les boucles while :
Pseudo-code Code Sagemath

si a “ 1 if a==1
si a ‰ 1 if a<>1
si a ě 1 if a>=1
si a ă 1 ou b ą 2 if a<1 or b>2
si a est pair if a%2==0
1.5 Affichage avancé

Supposons que l’on veuille réaliser l’affichage suivant :
| le cube de 1 vaut 1
On constate que l’affichage mélange des nombres, du texte et l’affi-
chage d’une réponse à un calcul. Ceci se réalise en concaténant les
différents objets dans la commande print en les séparant par une
virgule. Il s’agira de proposer :
for n in [1..4]:
print " le cube de " ,n , " vaut " ,n ^3
Exercice 1.9 Pour la réalisation du graphe de la fonction f définie par

f pxq “ x3 ´ x2 ` 2, vous aurez besoin d’un tableau de valeurs.
Utiliser SageMath pour le créer.
1.6 Une fonction qui en appelle une autre

Jusqu’à maintenant, nous avons croisé deux types de programmation
permettant d’obtenir un résultat semblable.
Par exemple, si on désire calculer le nombre 5 !, on peut proposer
l’une des deux démarches suivantes :
p =1 def factorielle ( n ):
for k in [1..5]: p =1
p=p*k for k in [1.. n ]:
print p p=p*k
|120 return p
puis
factorielle (5)
|120
La deuxième démarche est beaucoup plus élégante, car elle permettra

de réutiliser cette fonction en étant “appelée” par une autre fonction.
En utilisant les 2 fonctions successeur(n) et factorielle(n) croisées

précédemment. Quelle valeur va-t-être retournée à la commande :
factorielle ( successeur (2))
Exercice 1.10 a) Recopier et valider la fonction factorielle(n) proposée ci-dessus.

b) On considère le pseudo-code suivant :
fonction sommefactopnq :
somme Ð 0
pour k P r0..ns :
somme “ somme ` 1{f actoriellepkq
afficher somme
c) Que permet de calculer cette fonction ?

Montrer à la main que pour n “ 3 le résultat sera de 8/3.
d) Le programmer en SageMath après avoir recopié et validé la
fonction factorielle proposée ci-dessus, contrôler que l’on obtient :
En code fractionnaire : ou en code à virgule 1 :

sommefacto (4) N ( sommefacto (4))
|65/24 |2. 708333 333333 33
1 1
6 8
e) Calculer puis en déduire une approximation de .
ÿ ÿ
k“0
k! k“0
k!
1. La commande SageMath N(nombre) permet de convertir le résultat d’un calcul (code fractionnaire) en un
nombre en code décimal.
Exercice 1.11 En appliquant une démarche comparable, calculer les sommes sui-
vantes :
1
7 12
i
a) b)
ÿ ÿ
lnp3k ` 1q 2i ´ 1
a
k“3 i“5
Indication : - la fonction correspondant à la racine est sqrt(. . .).

- la fonction correspondant au log naturel est log(. . .).
fonction factopnq :
si n “ 0 :
retourner 1
else:
retourner n ¨ f actopn ´ 1q
a) Programmer cette fonction facto et contrôler que vous obtenez

bien :
facto (5)
|120
b) En quoi l’algorithme de cette dernière fonction peut paraître

étrange, mais aussi diablement efficace ?
c) On considère la nouvelle fonction appelée Combinaison définie
par :
n!
Combinaisonpn , pq “
p! ¨ pn ´ pq!
En utilisant la fonction facto(n), proposer la fonction
combi(n,p) et vérifiez que vous obtenez :
combi (9 ,3)
|84
1.7 Pour aller un peu plus loin
La suite de Syracuse: Cette suite de nombre ressemble à un jeu de calcul. On prend

n’importe quel nombre entier plus grand que 1 ; s’il est pair, on le
divise par 2 ; s’il est impair, on le multiplie par 3 et on ajoute 1. En
réitérant l’opération plusieurs fois, on obtient une suite de nombres
qui, semble-t-il, finit toujours par aboutir à la même séquence.
Cette suite de Syracuse se définit de la manière suivante :
$
’
’
’ u1 “ N (valeur initiale entière)
&
si un est paire
# u
n
2
’
’ un`1 “
3un ` 1 si un est impaire.
’
%
La conjecture affirme que, quel que soit le terme initial N de

la suite, celle-ci finit inexorablement par boucler sur 4, 2, 1. Par
exemple, en commençant par N “ 6, nous obtenons la suite :
6 , 3 , 10 , 5 , 16 , 8 , 4 , 2 , 1 , 4 , 2 , 1 , . . .
Sous son apparente simplicité, elle défie encore les mathématiciens

actuels.
La naissance de ce problème semble se situer autour des années 1950 ;
il fut proposé aux étudiants de l’université américaine de Syracuse.
Cette conjecture mobilisa tant les mathématiciens durant les années
60, en pleine guerre froide, qu’une blague courut selon laquelle ce
problème serait l’œuvre d’un complot soviétique pour ralentir la recherche
américaine. Plus sérieusement, le mathématicien Paul Erdös dit à propos
de cette conjecture : « les mathématiques ne sont pas encore prêtes
pour de tels problèmes ». Il proposa une offre de 500 $ à quiconque lui
donnerait une solution. On cherche encore . . .
Exercice 1.13 a) Proposer une première fonction syra(n) qui permet de calculer
le terme suivant le nombre n proposé tout en respectant la règle
ci-dessus. Par exemple :
syra (6)
|3
b) Proposer deuxième fonction suitesyra(n) qui permet de créer une

liste des 12 premiers termes de la suite :
suitesyra (6 ,12)
|[6 , 3 , 10 , 5 , 16 , 8 , 4 , 2 , 1 , 4 , 2 , 1 , 4]
c) En utilisant, par exemple, la commande while, vérifier la conjec-

ture pour des valeurs initiales de 2 à 100.
Nombres premiers
2
2.1 Quoi de plus simple qu’un nombre premier ?
Rappel: Un entier naturel est dit premier s’il est supérieur ou égal à 2 et
n’est divisible que par 1 et lui-même.
Quoi de plus simple ?: Et pourtant, ils renferment tant de mystères que les plus grands esprits
depuis des siècles n’ont toujours pas réussi à en percer tous les secrets, et
ce malgré les énormes progrès technologiques et les investissements colos-
saux consentis par les pouvoirs tant civils que militaires pour assurer ou
percer la confidentialité des transmissions de toutes natures qui continue
de dépendre d’une meilleure connaissance des nombres premiers, ce que
nous verrons un peu plus loin.
Qui sont-ils ? Combien sont-ils ? Où sont-ils ? À quoi servent-ils ? Nous
essaierons de donner quelques éléments de réponses à ces questions.
Mais tout d’abord, pourquoi jouent-ils un rôle si important ?
Fondamentalement, il existe deux manières d’engendrer N:
N
‚ si on veut engendrer en utilisant l’addition, on s’aperçoit que
le nombre 1 nous suffit : on « fabrique » 2 en additionnant 1 avec
lui-même ; 3 en additionnant 1 avec 2, etc.
‚ si on veut engendrer N
en utilisant la multiplication, là, les
choses se compliquent. Pour « fabriquer » 2, il faut le créer ; même
problème pour 3. On fabrique 4 en multipliant 2 avec lui-même,
mais il faut créer 5. On fabrique 6 en multipliant 3 avec 2. On
crée 7. On fabrique 8 à partir de 2. On fabrique 9 à partir de 3.
On fabrique 10 à partir de 2 et 5, etc.
Les nombres que l’on est obligé de créer sont les briques nécessaires
à fabriquer tous les autres. C’est bien plus compliqué que l’addition
me direz-vous, mais la multiplication est plus « puissante » et
nous permet d’aller bien plus vite et plus loin.
Les nombres premiers sont donc ces éléments qui nous permettent
de fabriquer tous les autres. Un des premiers problèmes étudiés a
été de savoir s’ils peuvent tenir dans une boîte, comme les Legos
dans la chambre d’un enfant. Euclide a répondu à cette question il
Euclide d’Alexandrie y a vingt-trois siècles et la réponse est non.
-325 à -265 av. J.-C. Pour le prouver, nous aurons besoin d’un résultat intermédiaire :
15
16 CHAPITRE 2. NOMBRES PREMIERS
Proposition: Tout entier naturel n admet au moins un diviseur premier.
Preuve: En effet, soit n est premier et il est divisible par lui-même, soit
n n’est pas premier et il admet un certain nombre de diviseurs.
Appelons p le plus petit de ces diviseurs. p est premier, car sinon p
aurait un diviseur d, plus petit que p, et qui diviserait n.
Théorème: Il y a une infinité de nombres premiers.
Preuve: Raisonnons par l’absurde et supposons qu’il existe exactement n

nombres premiers qu’on nommera p1 , p2 , . . ., pn . Appelons N le
nombre
N “ pp1 ¨ p2 ¨ . . . ¨ pn q ` 1
Il est plus grand que tous les pi , donc il n’est pas premier. Ainsi, il
admet un diviseur premier p qui est un des pi , puisqu’il n’y a qu’eux.
Nous avons alors :
p divise N “ p1 ¨ p2 ¨ . . . ¨ pn ` 1
*
ùñ p divise N ´p1 ¨. . .¨pn “ 1
p divise p1 ¨ p2 ¨ . . . pn
Donc p “ 1 ce qui est absurde puisqu’il est premier. Ainsi, cette

contradiction nous assure qu’il ne peut exister de plus grand nombre
premier. Il y a donc une infinité et l’aventure ne fait que commencer.
Quelques records: ‚ Le 4 février 2005, Martin Nowak a battu le record du plus

grand nombre premier connu alors : 225 964 951 ´1 en faisant tra-
1 1
vailler plus de 50 jours durant un Pentium 4 (2,4 GHz). Cette

découverte s’est faite dans le cadre du programme GIMPS 1 de
recherche de grand nombre. Nowak est un chasseur de grand
nombre et ophtalmologiste allemand à ses heures perdues ;-).
‚ Le GIMPS a pu remporter le 23 août 2008, la première ré-
compense de 100’000 USD offerte par l’Electronic Frontier
Foundation pour la découverte du premier nombre premier
de plus de dix millions de chiffres (243 112 609 ´ 1). Les règles
1 1
de répartition de la récompense sont prévues par le GIMPS :

l’internaute qui trouve le nombre, le GIMPS, des oeuvres cari-
tatives et les autres internautes qui participent au GIMPS et
trouvent des nombres premiers.
‚ L’Electronic Frontier Foundation offre d’autres récompenses
de 100’000, 150’000 et de 250’000 USD pour, respectivement,
la découverte de nombres premiers de plus de dix millions,
cent millions et un milliard de chiffres. À bon entendeur ! ! !
1. Great Internet Mersenne Prime Search est un projet de calcul partagé où les volontaires utilisent un logiciel
pour chercher les nombres premiers de Mersenne de la forme 2p ´ 1, avec p premier.
CHAPITRE 2. NOMBRES PREMIERS 17
‚ L’actuel plus grand nombre premier connu :
277 232 917 ´ 1 formé de 23’249’425 chiffres

1 1
fut découvert le 26 décembre 2017 par Jonathan Pace. Celui-ci

offre du temps de calcul à GIMPS depuis 14 ans. Son PC,
équipé du processeur Intel i5-6000, a eu besoin de 6 jours de
calculs intensifs pour s’assurer que ce nombre est bien premier.
Jonathan Pace Pace a reçu 3000 $ pour sa contribution.
Admin. système (FedEx)
Exercice 2.1 2 ¨ 3 ` 1 “ ...

2 ¨ 3 ¨ 5 ` 1 “ ...
2 ¨ 3 ¨ 5 ¨ 7 ` 1 “ ...
2 ¨ 3 ¨ 5 ¨ 7 ¨ 11 ` 1 “ . . . etc . . .
a) Peut-on affirmer que le résultat de ces calculs est forcément
un nombre premier ?
b) Considérons : 2 ¨ 3 ¨ 5 ¨ 7 ¨ 11 ¨ 13 ` 1
‚ Justifier qu’il n’est pas divisible par 2, 3, 5, 7, 11, 13
‚ Mais n’est-il pas divisible par au moins un autre nombre
premier ? (à tester à la calculatrice)
Exercice 2.2 Démontrer que la proposition suivante est fausse :
@n P N, n2 ´ n ` 41 est un nombre premier

Indication : Pour démontrer qu’une proposition est fausse, il suffit de
trouver un contre-exemple, c’est-à-dire une valeur (naïve ?) de n, ne
vérifiant pas la proposition.
Exercice 2.3 a) Écrire le pseudo-code est_premier permettant de tester si un

nombre est premier.
Indication : Dans la remarque, en bas de page 9, nous avons déjà
défini la fonction a mod b qui donne le reste de la division de a par
b. Ainsi 5 est un nombre premier car :
5 mod 2, 5 mod 3, 5 mod 4 sont toujours différents de 0.
b) Vérifier votre pseudo-code “à la main” pour les nombres 6 et 7.
c) Programmer-le en SageMath puis contrôler que vous obtenez :
est_premier (1321)
| True
est_premier (1322)
| False
2.2 Test de primalité d’un nombre

Question: Il est facile de vérifier de tête que 7, 13 ou 31 sont des nombres pre-
miers. Quelle méthode adopter pour montrer que 1321 est premier ?
Premier algorithme: Essayer toutes les divisions de 1321 par D, pour D allant de 2 à
1320. Si aucune division ne “tombe juste”, alors on peut affirmer
que 1321 est premier.
C’est probablement un algorithme semblable à celui que vous avez
proposé dans l’exercice précédent.
def est_premier ( p ):
if p ==0 or p ==1:
return False
else :
if p ==2:
return True
else :
for k in [2.. p -1]:
if p % k ==0:
return False
return True
On obtient alors :
est_premier (1321)
| True
Cet algorithme peut être optimisé. Proposer 1319 calculs lorsque
36 peuvent suffire. . .
2e démarche: Observons les tableaux suivants :

diviseur 2 3 4 5 6 7 8 9 10
quotient 660,5 440,3 330,3 264,2 220,2 188,7 165,1 146,8 132,1
diviseur 11 12 13 14 15 16 17 18 19
quotient 120,1 110,1 101,6 94,36 88,07 82,56 77,71 73,39 69,53
diviseur 20 21 22 23 24 25 26 27 28
quotient 66,05 62,90 60,05 57,43 55,04 52,84 50,81 48,93 47,18
diviseur 29 30 31 32 33 34 35 36 37
quotient 45,55 44,03 42,61 41,28 40,03 38,85 37,74 36,69 35,70
Le tableau semble incomplet : il resterait encore à essayer les quo-

tients de 38 à 1320, mais cela est-il vraiment nécessaire ?
Nous observons qu’à partir de 37, les quotients sont plus petits que
les diviseurs. Aucun de ces quotients pour un diviseur supérieur
à 37 ne peut être entier puisque cela signifierait que 1321 était
déjà divisible par ce quotient. Mais aucune division par un nombre
inférieur à 37 n’a donné de quotient entier. D’où la simplification
suivante :
Deuxième algorithme: Essayer ‰ toutes les divisions de 1321 par D, pour D allant de 2 à
2
1321 ` 1.
“?
Ainsi donc, nous sommes passés de 1320 divisions à 36 divisions.

Ceci est un gain appréciable de temps.
Exercice 2.4 Traduire ce deuxième algorithme en un nouveau pseudo-code, puis

proposer une fonction SageMath dont le nom est est_premier2.
?
Indication : la fonction correspondante à n s’écrit sqrt(n).
Exercice 2.5 Leonard Euler proposa une formule permettant de générer une
multitude de nombres premiers :
f pnq “ n2 ´ n ` 41 nP N
a) Proposer une fonction euler(n) qui, appelant la fonction
est_premier2(n), permet de vérifier la formule d’Euler pour la
valeur de n proposée.
b) Vérifier que f p2q, f p40q sont premiers, mais f p41q, f p42q ne
le sont pas.
En modifiant votre fonction :
c) Montrer que pour n P r0 ; 100s, la formule d’Euler fournit dans
Leonard Euler près de 86% des cas un nombre premier.
(1707-1783) d) Parmi les nombres n P r0 ; 100s, lesquels ne fournissent pas un
nombre premier ?
Troisième algorithme: On peut encore améliorer la méthode en “?essayant

‰ que les divisions
par les nombres premiers inférieurs à 1321 ` 1, à condition de
disposer d’une liste des nombres premiers. Si vous avez une telle
liste jusqu’à 1000, cela permet de tester rapidement si un nombre
inférieur à 10002 est premier. Observons ceci à la page suivante.
2. rns est un codage exprimant la partie entière du nombre réel n et correspondant à l’entier qui lui est
immédiatement inférieur ou égal. La fonction correspondante en Python est int().
2.3 Le crible d’Ératosthène

Comment créer une liste des nombres premiers ?
Le principe est ancien puisqu’il est attribué au grec Ératosthène 3
On écrit les entiers de?2 à n puis on barre les multiples des nombres
premiers inférieurs à n. Les entiers restants sont premiers.
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100
La méthode peut paraître efficace à la main, mais elle devient

inutilisable pour une table de nombres premiers allant jusqu’à 10’000
(par exemple).
On peut alors utiliser la procédure SageMath ci-dessous :
1 def crible ( n ) :
2 L = [0.. n ]
3 L [1] = 0 # L [1]=0 , car 1 n ’ est pas un nombre premier
4 i = 2 # on commence avec le nombre i =2
5 while i <= n :
6 j = i + i
7 while j <= n :
8 L[j] = 0 # multiples de i remplace par 0
9 j = j + i
10 i = i + 1 # considerer le nombre i suivant
11 while i < n and L [ i ] == 0 : # tant qu ’ il est nul
12 i = i + 1 # passer au suivant
13 M = [] # liste vide qui contiendra les nbres premiers
14 for j in [0.. n ]:
15 if L [ j ] <> 0: # si le nombre est pas nul
16 M = M + [ L [ j ]] # l ’ ajouter a la liste
17 return M
3. Né 276 années av. J.-C., directeur de la Bibliothèque d’Alexandrie, on lui doit aussi une approximation du
diamètre de la Terre. Devenu aveugle, il s’est laissé mourir de faim...
et on obtient :
crible (100)
| [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]
Exercice 2.6 Après avoir téléchargé le fichier crible.sagews sur www.javmath.ch,

importer ce fichier sur votre environnement et utilisez-le pour générer
la liste des nombres premiers :
a) plus petits ou égaux à 1’000 ;
b) plus petits ou égaux à 100’000 ;
c) plus petits ou égaux à 100’000’000.
Si vous perdez patience, vous pouvez interrompre le déroulement d’une
fonction (d’une procédure) en utilisant la commande Stop du menu
situé en haut de la page web ou en rechargeant la page avec Restart .
Exercice 2.7 Afin de bien décoder la fonction crible, écrire le pseudo-code corres-
pondant.
Tester votre pseudo-code pour n “ 7 en observant le contenu de la
liste L en cours de calculs.
Théorème: Tout entier n supérieur à 2 admet une et une seule (à l’ordre près
des termes) décomposition en produit fini de nombres premiers.
Par exemple, 150 “ 2 ¨ 3 ¨ 52 , les facteurs premiers ne sont pas forcément
distincts. On a alors l’habitude d’écrire la décomposition sous la forme :
n “ pα1 1 ¨ pα2 2 ¨ . . . ¨ pαnn
Nous ne démontrons pas ce théorème, par contre, nous pouvons uti-

liser la fonction crible mise au point précédemment pour décomposer
un nombre « informatiquement ». Cette fonction est téléchargeable
sur www.javmath.ch sous le nom Decomp.sagews.
def decomp ( n ):
Div = []
P = crible ( n ) # P contient la liste des nbres prem . <= n
for j in [0.. len ( P ) -1]:
while n % P [ j ]==0:
# tant que n divisible par l ’ element j de P
Div = Div + [ P [ j ]]
# on ajoute a Div ce div . premier
n = n / P[j]
# on divise n par ce div . premier
return Div
et on obtient :
decomp (12200)
| [2 , 2 , 2 , 5 , 5 , 61]
Pour être honnête, il existe la fonction factor qui donne directement
la décomposition d’un nombre en facteurs premiers.
factor (12200)
| 2^3 * 5^2 * 61
Exercice 2.8 Afin de bien décoder la fonction decomp, écrire le pseudo-code

correspondant puis testez-le “à la main” avec quelques valeurs.
Exercice 2.9 a) À l’aide du pseudo-code que vous avez proposé dans l’exer-
cice précédent, reconstituez la fonction decomp et testez-la sur
SageMath.
b) 168’399 n’étant pas un nombre premier, factorisez-le avec avec
votre fonction decomp puis avec la fonction factor proposée par
SageMath.
Remarque: Vous avez dû constater que toutes les fonctions proposées pour
factoriser en nombres premiers ou déterminer des nombres premiers
sont rapides au début, mais deviennent inefficaces avec des grands
nombres. Estimons le nombre de divisions à effectuer pour tester
267 ´ 1, qui vaut approximativement 1,47 ¨ 1020 . On constate qu’il
s’écrit avec 21 chiffres. Sa racine carrée vaut approximativement
12’000’000’000. Il faudra donc un peu plus de 12 milliards de divi-
sions, certaines à dix chiffres ! Bon courage !
(F. Cole a calculé en 1903 que 267 ´ 1 “ 193707721 ¨ 761838257287)
Une nouvelle commande: SageMath propose une fonction is_prime(. . .), qui permet de contrô-
ler si un nombre est premier, et ceci même s’il est grand.
is_prime (2^67 -1)

| False
N’hésitez pas à l’utiliser pour les exercices qui suivent.
Exercice 2.10 Vérifier que 2’027’651’281 n’est pas un nombre premier. Factorisez-le.
Exercice 2.11 À quoi correspond la fonction suivante ?
def mystere ( n ):
Liste =[]
i =2
while len ( Liste ) < n :
if is_prime ( i ):
Liste = Liste + [ i ]
i = i + 1
return Liste
2.4 Pour aller un peu plus loin

Les exercices suivants sont à réaliser en effectuant une ou plusieurs
fonctions sur SageMath après avoir écrit et contrôlé votre pseudo-
code.
Exercice 2.12 On appelle F erpnq le ne nombre de Fermat qui se calcule à l’aide

de :
F erpnq “ 22 ` 1
n
Pierre de Fermat, mathématicien français, pensait que F erpnq était

premier pour tout n P . N
Montrer qu’il se trompait.
Pierre de Fermat
(1607(?) -1665)
Exercice 2.13 Dans un inédit de Marcel Pagnol, celui-ci affirme que le nombre :
N “ n ` pn ` 2q ` npn ` 2q
est premier si n est impair. Qu’en pensez-vous ?
Exercice 2.14 Est-il possible de trouver un nombre premier p tel que p ` 100 et
p ` 200 soient aussi premiers ?
Exercice 2.15 On pose A “ 101! ` 1.

a) Montrer que les 100 nombres consécutifs A ` 1, A ` 2, . . .,
A ` 100 ne sont pas premiers.
b) Pouvez-vous trouver, à l’aide de SageMath, la plus petite série
de 100 nombres consécutifs dont aucun n’est premier ?
Exercice 2.16 Pour tout entier naturel n, on pose Mn “ 2n ´ 1 appelé nombres

de Mersenne en l’honneur de l’abbé Marin Mersenne. Celui-ci est
l’auteur de la proposition suivante :
Si Mn est premier alors n aussi
qu’il aurait par ailleurs démontrée. Il fournit également une liste

des nombres premiers « de Mersenne » jusqu’à l’exposant 257, qui
Marin Mersenne se révélera fausse : elle incluait par erreur 67 et 257, et omettait 61,
(1588 -1648) 89 et 1077.
À l’aide de SageMath :
a) Établir la liste des entiers 1 ď n ď 100 pour lesquels Mn est
premier.
b) Vérifier que si n n’est pas premier alors Mn non plus.
c) Que peut-on alors en déduire ?
d) Calculer M67 . Est-il premier ?
(Ce résultat fut obtenu en 1903 par Nelson Cole après 20 ans de
travail à la main.)
e) La proposition suivante :
Si n est premier alors Mn aussi.
est-elle exacte ?
Voici encore quelques informations à propos des premiers de Mer-
senne :
‚ Le 8e nombre de Mersenne premier a été découvert en 1772
par Euler.
‚ La liste des 12 premiers nombres de Mersenne premiers a été
définitivement établie en 1947.
‚ L’arrivée des ordinateurs a permis d’accélérer les découvertes.
Comme déjà mentionné, le record actuel est établi avec le
nombre M777232917 . Vous pouvez télécharger un fichier conte-
nant les chiffres de ce nombre sur http://www.mersenne.org.
Ne vous avisez pas d’imprimer ce fichier, car il vous faudrait
près de 6’840 pages entièrement remplies.
Chiffrement de César et congruence
3
3.1 Trois exercices en guise d’introduction
‚ Une question de dates
Un élève qui aime bien les congés le jour de son anniversaire constate qu’en 2008, le 6 décembre
tombait un samedi. Comment peut-il savoir, sans trop se fatiguer, si en 2009 puis en 2010
son anniversaire tombera sur un week-end ?
‚ On prépare la crypto
Imaginons une bande de papier infinie sur laquelle, on place les lettres de l’alphabet dans l’ordre
alphabétique puis arrivé à Z, on recommence à A comme le suggère la figure ci-dessous :
…
B …
A B … Z A B … Z A B … …
… …
0 1 … 25 26 27 … 51 52 53
a) Montrer qu’en 79e position, on retrouvera une lettre B.

b) Quelle sera la lettre située en 212e position ?
c) Quelles seront les positions des huit premières lettres G que nous rencontrerons en
déroulant la bande ?
‚ Le jeu de Fort Boyard

Dans une épreuve de ce jeu télévisé, un candidat est opposé au « maître
des Jeux ». Face à un alignement de bâtonnets (ici : 23), chacun doit, à
tour de rôle, retirer 1, 2 ou 3 bâtonnets, au choix. Celui qui retire le dernier
bâtonnet a perdu.
Montrer que, pour gagner, le candidat doit laisser, à chaque étape, un nombre de bâtonnets
dont le reste par la division par 4 est de 1.
25
26 CHAPITRE 3. CHIFFREMENT DE CÉSAR ET CONGRUENCE
3.2 Quelques éléments sur la congruence
À propos du 2e ex.: ‚ Montrer qu’en 79e position, on retrouvera une lettre B.

En effet, 79 “ 26 ¨ 3 ` 1. On aura donc parcouru complètement 3
fois l’alphabet et on se retrouvera à une lettre équivalente à celle
correspondante au chiffre 1, soit B.
‚ Quelle sera la lettre située en 212e position ?
212{26 « 8,15. On doit donc parcourir 8 fois l’alphabet complet et
on se retrouve à l’équivalent de la 212 ´ 8 ¨ 26 lettre de l’alphabet,
c’est-à-dire la lettre E (correspondant à 4).
‚ Quelles seront les positions des huit premières lettres G que nous
rencontrerons en déroulant la bande ?
Il s’agira de 6 , puis 6 + 26 = 32 , puis 6 ` 2 ¨ 26 “ 58, puis
6 ` 3 ¨ 26 “ 84 etc. . .
On constate alors que 6, 32, 58, 84 sont 4 nombres dont le reste de
la division par 26 vaut 6. On dit alors que ces nombres sont
congrus modulo 26.
Définition: On fixe un entier naturel n, supérieur ou égal à 2. On dit que deux
nombres x et y sont congrus modulo n, et on note
x”y pmod nq
s’ils ont le même reste (positif) dans leurs divisions respectives par n.
Exemple 1: Montrer que 365 ” 15 ” 1 pmod 7q.
Exemple 2: Montrer que 18 ” ´17 pmod 7q.
Exercice 3.1 Déterminer si 17 est congru à 5 modulo 6 et si 24 et 14 sont congrus

modulo 6.
CHAPITRE 3. CHIFFREMENT DE CÉSAR ET CONGRUENCE 27
Exercice 3.2 Sur la droite graduée ci-dessous, colorier en rouge les entiers congrus
à 0 mod 3, en bleu ceux congrus à 1 mod 3 et en vert ceux congrus
à 2 mod 3. Que constatez-vous ?
´4 ´3 ´2 ´1 0 1 2 3 4 5 6 7
Exercice 3.3 Justifier l’affirmation suivante :

Tout nombre est ainsi congru modulo n à un unique nombre entier
compris entre 0 et n ´ 1.
Exercice 3.4 Déterminer si chacun des entiers suivants est congru à 22 pmod 17q :
a) 80 b) 103 c) ´29 d) ´122
Définition: Soit x un entier et n un entier positif. On désigne par x pmod nq

le reste de la division de x par n.
Exercice 3.5 Évaluer les quantités suivantes :
a) 13 pmod 3q b) 155 pmod 19q

c) ´97 pmod 11q d) ´221 pmod 23q
SageMath: La fonction % permet de calculer le reste de la division par n :
212%7
| 2
Ainsi donc 212 ” 2 pmod 7q.
Exercice 3.6 a) Vérifier à l’aide de SageMath que :
189 ” 918 pmod 7q
b) Résoudre à l’aide de SageMath l’équation :
18n ” n18 pmod 7q
Nous reviendrons plus précisément sur cette notion de congruence

à la fin du chapitre. Mais concentrons-nous sur une utilisation en
cryptographie.
3.3 La cryptographie, le chiffrement de César
Introduction: Depuis les temps historiques les plus reculés, les hommes ont utilisé di-
verses méthodes pour chiffrer des messages et rendre ceux-ci inintelligibles
à des lecteurs indésirables. C’est essentiellement dans les domaines mili-
taires et diplomatiques que le chiffrement de messages était utilisé. Les
Anglais, avec des mathématiciens comme Alan Turing, se sont illustrés
pendant la Seconde Guerre mondiale, en décryptant les messages que
la marine allemande chiffrait avec la machine Enigma dont le principe
remontait à la fin de la Première Guerre mondiale. Aujourd’hui, le champ
d’application de la cryptologie s’est élargi et a trouvé un regain d’actualité
avec les problèmes posés par la sécurité des transactions bancaires, des
transmissions de fichiers et de bases de données sous forme électronique.
Nous entrons, en effet, dans un jeu qui se joue avec trois personnages : le
Alan Turing premier envoie un message au second, le problème étant alors d’interdire
Mathématicien anglais l’accès de ce message au troisième. On peut, bien sûr, envisager des
(1912 ´ 1954) parades physiques visant à faire que le troisième personnage ne puisse
accéder au message, mais l’expérience montre que ces parades sont trop
souvent déjouées par l’adversaire. Une façon de procéder est de chiffrer
le message de façon à ce que, même intercepté, il ne puisse être lu par le
troisième personnage.
Les deux premiers joueurs qui jouent ensemble contre le troisième auront
gagné :
‚ s’ils peuvent chiffrer et déchiffrer facilement des messages, et ce
dans un temps humainement raisonnable ;
‚ si le troisième personnage, le cryptanalyste ne peut décrypter le
message, même avec la puissance calculatoire des ordinateurs, en
un temps raisonnable.
Nous présentons des modes de chiffrement basés sur des principes

de congruence arithmétique.
Le premier des systèmes de chiffrement que nous présenterons est
emprunté à Jules César (100 - 44 avant Jésus-Christ).
Un principe commun à tous ces modes de chiffrement est de trans-
former chaque lettre de l’alphabet ou chaque signe du système
symbolique utilisé en un nombre ; c’est d’ailleurs ce qui justifie
l’usage du terme “chiffrement”. Ainsi, on peut faire correspondre à
Buste de Jules César
effectué de son vivant
découvert à Arles en 2007
chaque lettre de l’alphabet français un nombre compris entre 0 et
25.
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
On pourrait aussi inclure les signes de ponctuation, un symbole

pour marquer les blancs et aussi ces signes que sont les chiffres eux-
mêmes pour représenter des nombres. Pour des raisons de simplicité,
nous ne le ferons pas : nous nous restreindrons donc aux vingt-
six lettres de notre alphabet : cela est suffisant pour montrer les
principes de chiffrement, de déchiffrement usant de congruences
arithmétiques. Cela suffit également pour montrer comment un
cryptanalyste peut tenter de découvrir la signification du message
chiffré. C’est un système qui, à une lettre du message en clair,
associe une lettre le plus souvent différente pour former le message
chiffré. De tels systèmes de chiffrement sont parfois appelés systèmes
monoalphabétiques : chaque lettre de l’alphabet est transformée
en une autre par substitution.
Cela peut paraître rudimentaire, mais il y a cependant “26 !” façons
d’envisager une telle correspondance entre lettres, puisqu’il y a 26 !
permutations des lettres de l’alphabet. Or
26 ! = 403’291’461’126’605’635’584’000’000
Cela montre qu’un cryptanalyste ne pourrait sans doute sérieusement

envisager toutes les permutations possibles 1 .
Une exigence, toujours actuelle, est que le chiffrement comme le dé-
chiffrement puissent se faire rapidement. Jules César, qui à l’époque
ne devait pas craindre les cryptanalystes, avait un système simple :
chaque lettre de l’alphabet était remplacée par la lettre située trois
rangs plus loin dans l’alphabet (A → D ; B → E ; ...) quand cela
était possible ; aux trois dernières lettres X, Y, Z correspondaient
les trois premières A, B, C.
Cela peut se décrire facilement en terme de congruence : soit M
l’équivalent numérique d’une lettre de l’alphabet en clair et M 1
l’équivalent numérique de la lettre chiffrée correspondante. On a :
M 1 ” M ` 3 pmod 26q
La correspondance obtenue donne ainsi :
Alphabet A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
en clair 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Alphabet Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó Ó
Alphabet 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 0 1 2
chiffré D E F G H I J K L M N O P Q R S T U V W X Y Z A B C
Illustrons la procédure de chiffrement de César avec un exemple :

soit à chiffrer le message :
CE MESSAGE EST SECRET

1. Si on exige que chaque lettre soit chiffrée par une lettre différente d’elle-même, il n’y a plus 26 ! possibilités
mais « seulement » 148’362’637’348’470’135’821’287’825. Ce qui reste supérieur à 1026 possibilités. . .
Dans ce premier exemple, nous laissons les blancs des textes pour en
faciliter la lecture, mais il conviendra de les supprimer ! Les blancs
seraient autant d’indices mis à la disposition des cryptanalystes. De plus,
seules les lettres majuscules seront utilisées
En passant par les équivalents numériques, on obtient :

message en clair C E M E S S A G E E S T S E C R E T
P 2 4 12 4 18 18 0 6 4 4 18 19 18 4 2 17 4 19
P ` 3 pmod 26q 5 7 15 7 21 21 3 9 7 7 21 22 21 7 5 20 7 22
message chiffré F H P H V V D J H H V W V H F U H W
Le message chiffré, le “cryptogramme” est donc :
FH PHVVDJH HVW VHFUHW
En éliminant les espaces, on obtient :
FHPHVVDJHHVWVHFUHW
Certes, les “officiers du chiffre” de Jules César n’usaient sûrement

pas de congruence modulo 26 : ici, on voit que le chiffrement peut
se faire directement sans passer par les équivalents numériques des
lettres de l’alphabet. L’exemple a simplement le mérite de nous
rappeler un fait historique et de nous montrer le principe de l’usage
Que vous inspire
de congruences arithmétiques pour élaborer des chiffrements.
ce dessin ?
Vous trouvez cette méthode de cryptographie naïve ? ?
Exercice 3.7 Chiffrer à la main le message suivant :
TU QUOQUE MI FILI
Exercice 3.8 Déchiffrer à la main le message suivant :
DYHFDHVDUPRULWXULWHVDOXWDQW
Comment déchiffrer ?: Pour chiffrer, on décale le rang des lettres de trois vers la droite,
pour déchiffrer on décale les lettres du cryptogramme de trois rangs
vers la gauche de l’alphabet : les lettres A, B, C, quant à elles sont
transformées en X, Y, Z.
Traduisons cette façon de faire “arithmétiquement” avec les équiva-
lents numériques.
Si M 1 est le symbole d’une lettre chiffrée, M le symbole de la lettre
en clair lui correspondant, on a :
M ” M 1 ´ 3 pmod 26q ou M ” M 1 ` 23 pmod 26q

Asterix : Le devin
Goscinny - Uderzo
Et avec SageMath ?: 1re étape : Chiffrer le message en clair. On utilise la commande :
ord(. . .)
qui permet de transcrire les lettres d’un message en code ASCII :

ord ( " P " )
| 80
Le code ASCII. . . Mais savez-vous de quoi il s’agit ?
La mémoire de l’ordinateur conserve toutes les données sous forme numé-
rique. Il n’existe pas de méthode pour stocker directement les caractères.
Chaque caractère possède donc son équivalent numérique : c’est le code
ASCII (American Standard Code for Information Interchange). Le code
ASCII de base permettait de chiffrer 128 caractères :
‚ Les codes 0 à 31 ne sont pas à proprement parler des caractères. On les
appelle caractères de contrôle, car ils permettent de faire des actions
telles que : retour à la ligne ou bip sonore.
‚ Les codes 48 à 57 représentent les chiffres.
‚ Les codes 65 à 90 représentent les majuscules.
‚ Les codes 97 à 122 représentent les minuscules.
La fonction :
def code_ascii ( message_clair ):
Liste =[]
for lettre in message_clair :
ascii = ord ( lettre )
Liste = Liste +[ ascii ]
return ( Liste )
permet de
code_ascii ( " PAX " )
| [80 ,65 ,88]
2e étape : Soustraire 65 à chaque code ASCII afin de faire corres-

pondre 0 à A, 1 à B . . . :
def chiffre ( Liste ):

New_Liste =[]
for nbre in Liste :
nbre = nbre -65
New_Liste = New_Liste +[ nbre ]
return ( New_Liste )
permet de
chiffre ([80 ,65 ,88])
| [15 ,0 ,23]
3e étape : Ajouter 3 pour effectuer le décalage de 3 lettres et ne

pas oublier d’imposer la valeur modulo 26 :
def liste_plustrois ( New_Liste ):

Liste_code =[]
for nbre in New_Liste :
nbre =( nbre +3)%26
Liste_code = Liste_code +[ nbre ]
return ( Liste_code )
permet de
liste_plustrois ([15 ,0 ,23])
| [18 ,3 ,0]
4e étape : Retranscrire en une liste de caractères (avec la fonction

chr(. . .)), puis la traduire en chaîne de caractères :
def message_crypt ( Liste_code ):

Message_code =[]
for nbre in Liste_code :
lettre = chr ( nbre +65)
Message_code = Message_code +[ lettre ]
Message_crypt = " " . join ( Message_code )
return ( Message_crypt )
pour obtenir finalement :
message_crypt ([18 ,3 ,0])
| " SDA "
Il s’agit maintenant de proposer une unique fonction pour effectuer
ces différentes étapes. C’est le sujet de l’exercice suivant.
Exercice 3.9 Programmer cette fonction sur SageMath :
fonction cesarpmessage_clairq :
message_code Ð rs
pour lettre dans message_clair :
ascii Ð ordplettreq ´ 65
ascii_crypt Ð pascii ` 3q mod 26
lettre_crypt Ð chrpascii_crypt ` 65q
message_code Ð message_code`rlettre_crypts
message_crypt Ð ””.joinpmessage_codeq
retourner message_crypt
Contrôler votre fonction à l’aide de 2 :

cesar ( " A V E C A E S A R M O R I T U R I T E S A L U T A N T " )
|" DYHFDHVDUPRULWXULWHVDOXWDQW "
2. Afin d’éviter les éventuelles erreurs de transcription des chaînes de caractères des exercices qui suivent, vous
pouvez les retrouver sur http://www.javmath.ch afin de les copier-coller.
Remarque: Le code ASCII a été mis au point pour la langue anglaise. Il ne

contient donc pas de caractères accentués et pas de caractères spéci-
fiques à une langue. Pour coder ces caractères, il faudrait recourir à
un autre code : Le code ASCII étendu que nous n’utiliserons pas.
Exercice 3.10 Chiffrer le cryptogramme suivant :
Le chiffrement est l’art de coder un message
en respectant les contraintes induites par la méthode de César.
Exercice 3.11 En adaptant la fonction cesar, déchiffrer
LOHVWWHPSVGHSDVVHUDDXWUHFKRVH
Généralisation: Le système de chiffrement de César est un cas particulier de chiffre-

ment par translation arithmétique :
M 1 ” M ` k pmod 26q où k est la clé du chiffrement.
Il y a 26 transformations de ce type incluant “le chiffrement de

César” pour k “ 3 et “la transformation identique” pour k “ 0.
Exercice 3.12 Programmer la fonction transl puis vérifier que, pour la clé k “ 13,
le chiffrement de la phrase donnera :
transl ( " A V E C A E S A R M O R I T U R I T E S A L U T A N T " ,13)

|" NIRPNRFNEZBEVGHEVGRFNYHGNAG "
Ce décalage de 13 lettres, appelé Rot13, a été et est encore souvent

utilisé sur le web pour éviter que votre texte ou image ne soit lu ou
vu involontairement, par exemple pour :
‚ camoufler la solution d’une devinette ;
‚ ne pas révéler la fin d’un film ou d’un livre ;
‚ éviter de choquer si vous utilisez une image un peu crue.
Exercice 3.13 Sachant que la clé de chiffrement est k “ 12, déchiffrer
“XQETAYYQEODAUQZFQZOQCGUXEPQEUDQZF”
Exercice 3.14 Même en ne connaissant pas la clé de chiffrement, déchiffrer
“ARZDVIRZJDZVLOVKIVCVGIVDZVIUREJLE
MZCCRXVHLVCVJVTFEURIFDV”
3.4 Pour aller un peu plus loin au sujet de la congruence
Rappel: Rappelons ici la définition de congruence :

On dit que deux nombres x et y sont congrus modulo n, et on
note x ” y pmod nq s’ils ont le même reste dans leurs divisions
respectives par n, pn P t2, 3, 4, . . .uq.
Proposition: x ” y pmod nq ðñ xý “k¨n avec k P . . . . . .
Exemple 3: ‚ 365 ” 15 pmod 7q car

‚ Comme 3337 – 4 est un multiple de 3 alors
Preuve:
Exercice 3.15 Les propositions suivantes sont-elles vraies ou fausses ? (justifier)

a) 471 ” 11 pmod 23q.
b) 370 ” 17 pmod 13q.
c) 29 ” ´121 pmod 5q.
d) L’égalité 914 “ 19 ¨ 47 ` 21 permet de déduire les congruences :
914 ” 21 pmod 19q et 914 ” 21 pmod 47q.
e) Tout entier est congru modulo 3 à l’un des nombres 0, 1 ou 2.
f) Si a ” b pmod nq et si b ” c pmod nq alors a ” c pmod nq.
g) Si a ” b pmod nq et si a ” c pmod nq alors a2 ” b ¨ c pmod nq
et 2a ” b ` c pmod nq.
Théorème: On peut additionner et multiplier les congruences modulo n :
si x ” y pmod nq et x1 ” y 1 pmod nq, alors

ˇ
ˇ x ` x1 ” y ` y 1 pmod nq
ˇ
ˇ x ´ x1 ” y ´ y 1 pmod nq
ˇ
ˇ x ¨ x1 ” y ¨ y 1 pmod nq
ˇ
N
ˇ
ˇ xp ” y p pmod nq @p P
On dit alors que la relation de congruence est compatible avec

l’addition, la soustraction et la multiplication.
Preuve: cf. page suivante.
Exemple 4:
Exemple 5: ‚ Calculer 3243 pmod 7q
‚ Calculer 2120 pmod 13q
Preuve:
ˇ
ˇ x ` x1 ” y ` y 1 pmod nq
ˇ
ˇ x ´ x1 ” y ´ y 1 pmod nq
ˇ
ˇ x ¨ x1 ” y ¨ y 1 pmod nq
ˇ
N
ˇ
ˇ xp ” y p pmod nq @p P
Exercice 3.16 Calculer, sans calculatrice
a) 73 ` 231 525 pmod 5q b) 212 ´ 414 pmod 5q

c) 21 342 ¨ 59 pmod 5q d) 26 pmod 5q
e) 176 pmod 5q
Exercice 3.17 Déterminer le reste de la division de
a) 3527 par 7 b) 8935 par 11 c) 7720 par 13

Exercice 3.18 Démontrer les congruences suivantes :
a) 35228 ` 84501 ” 0 pmod 17q
b) 2 ¨ 352008 ´ 3 ¨ 842010 ” 16 pmod 17q
Exercice 3.19 Quel est le chiffre des unités de 41 5687 (sans SageMath. . . ) ?
Indication : le chiffre des unités d’un entier n est le reste de la division
de n par . . .
3.5 Et la division modulo n ?
Introduction: Nous avons constaté que la relation de congruence est compatible

avec les opérations d’addition, de soustraction, de multiplication et
d’exponentiation.
Qu’en est-il de la division ? Peut-elle même être définie ?
‚ Que peut signifier 3{2 pmod 5q ?
‚ Pourtant, on peut donner un sens à ce calcul :
‚ Essayons de résoudre cette équation par tâtonnement :

Un outil: La table de multiplication modulo 5 :
¨ 0 1 2 3 4
0
1
2
3
4
‚ En déduire la solution de 2 ¨ x ” 3 pmod 5q.
‚ Résoudre x2 ” 4 pmod 5q.
Exercice 3.20 Résoudre les équations suivantes :
a) 4 ¨ x ” 2 pmod 5q b) 3 ¨ x ” 1 pmod 5q
Remarque: Dans ce dernier cas, on dit que 2 est l’inverse de 3 modulo 5 car :
3¨2”1 pmod 5q
Exercice 3.21 Déterminer l’inverse de 4 pmod 5q
Exercice 3.22 Compléter les tables de multiplication pmod nq suivantes :

•Pour n “ 2 •Pour n “ 3
¨ 0 1 ¨ 0 1 2
0 0
1 1
2
¨ 0 1 2 3 ¨ 0 1 2 3 4 5
0 0
1 1
2 2
3 3
4
5
Exercice 3.23 À l’aide des tables de multiplication de l’exercice précédent :

1) Résoudre les équations suivantes :
a) 2 ¨ x ” 0 pmod 3q b) 3 ¨ x ” 2 pmod 4q
c) 5 ¨ x ” 2 pmod 6q
2) Même consigne :
a) 2 ¨ x ” 3 pmod 4q b) 3 ¨ x ” 5 pmod 6q
c) 2 ¨ x ” 0 pmod 6q
3) Montrer, à l’aide de plusieurs exemples, que le produit de 2
nombres non nuls peut donner un nombre nul modulo n.
4) Le tableau pour n “ 4 admet une ligne (et une colonne) singulière.
Laquelle et pourquoi. Qu’en est-il pour le tableau pour n “ 6 ?
Qu’en pensez-vous pour le tableau pour n “ 8 ?
5) Déterminer :
a) l’inverse de 3 modulo 4 b) l’inverse de 2 modulo 4
c) l’inverse de 5 modulo 6 d) l’inverse de 4 modulo 6
Que constatez-vous ?
Exercice 3.24 1) Montrer que chaque nombre non nul modulo 7 admet un inverse.
a) 4 ¨ x ” 3 pmod 7q b) 5 ¨ x ” 0 pmod 7q
c) 12 ¨ x ” 20 pmod 7q
Exercice 3.25 Après avoir observé que 3 est l’inverse de 6 modulo 17, résoudre :
a) 6 ¨ x ” 9 pmod 17q b) 6 ¨ x ” 11 pmod 17q
Exercice 3.26 1) Constituer la table d’addition modulo 6.

a) 4 ` x ” 2 pmod 6q b) 5 ` x ” 2 pmod 6q
3) Montrer que la table d’addition modulo 6 n’est pas indispensable
pour les calculs précédents. Comment l’expliquez-vous ?
4) À l’aide des tables précédentes, résoudre :
a) 2 ` 5x ” 5 pmod 6q b) 3 ` 2x ” 4 pmod 6q
c) ´3 ` 2x ” 1 pmod 6q
Chiffrement affine, algorithmes d’Euclide et Bézout
4
4.1 Le chiffrement affine (début)
Introduction: On peut généraliser le chiffrement vu dans le chapitre précédent en

considérant la fonction :
M 1 ” a ¨ M ` b pmod 26q
que l’on appelle chiffrement affine.

C’est bien une généralisation, car on retrouve le chiffrement de César
avec a “ 1 et b “ 3.
Comme l’on travaille “modulo 26”, on peut se contenter de choisir
les entiers a et b compris entre 0 et 25.
Peut-on choisir n’importe quelles valeurs pour les clés de chif-
frement a et b ? Si non, quelles conditions doit-on leur imposer ?
Avant de pouvoir répondre à cette question mathématiquement,
commençons par quelques recherches à la main puis à l’aide de
SageMath.
Exercice 4.1 Montrer que si l’on choisit a “ 3 et b “ 5, alors le caractère chiffré
“L” correspond au caractère “C” en clair.
Exercice 4.2 Le but de cet exercice est d’observer l’influence du choix des clés a
et b dans le chiffrement d’un caractère.
‚ Avec a “ 1, b “ 0, nous obtenons le tableau de conversion :
en clair 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Alphabet 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
chiffré A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
On a vu mieux comme chiffrement. . .
en clair 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Alphabet 0 2 4 6 8 10 12 14 16 18 20 22 24 0 2 4 6 8 10 12 14 16 18 20 22 24
chiffré A C E G I K M O Q S U W Y A C E G I K M O Q S U W Y
a) Expliquer pourquoi ces clés a et b de chiffrement affine ne
doivent pas être utilisées.
41
42 CHAPITRE 4. CHIFFREMENT AFFINE, ALGORITHMES D’EUCLIDE ET BÉZOUT
en clair 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Alphabet 0 3 6 9 12 15 18 21 24 1 4 7 10 13 16 19 22 25 2 5 8 11 14 17 20 23
chiffré A D G J M P S V Y B E H K N Q T W Z C F I L O R U X
b) En quoi ces deux clés a et b sont-elles maintenant bien choisies ?
‚ Avec a “ 4, b “ 1, concentrons-nous sur les 2 lignes du milieu du

tableau de conversion :
en clair 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
chiffré 1 5 9 13 17 21 25 3 7 11 15 19 23 1 5 9 13 17 21 25 3 7 11 15 19 23
c) Qu’en est-il du choix de cette clé ?

d) À l’aide de SageMath, compléter le tableau suivant avec a “ 10
et b “ 2.
en clair 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
chiffré 2 12 22
e) Voici le début de la liste des valeurs de a permettant d’avoir

une clé bijective. Complétez-la (à l’aide de SageMath) :
a P t1 ; 3 ; 5 ; . . . . . . u
Que pouvez-vous dire au sujet de ces nombres ?

f) Expliquez en quoi le choix de la clé b n’influence pas la bijec-
tivité du chiffrement.
g) Montrer qu’il y a au total 311 clés utilisables assurant un bon
chiffrement bijectif.
Exemple 1: Chiffrer, à la main, le message “Le roi est mort” à l’aide d’un
chiffrement affine avec a “ 3, b “ 5.
message L E R O I E S T M O R T
en clair
message
chiffré
CHAPITRE 4. CHIFFREMENT AFFINE, ALGORITHMES D’EUCLIDE ET BÉZOUT 43
Exercice 4.3 Chiffrer, à la main, le message “Alea jacta est” à l’aide d’un chiffre-
ment affine avec a “ 7, b “ 3.
Exercice 4.4 Après avoir proposé le pseudo-code, proposer une fonction af-
fine(phrase,a,b) permettant à l’aide de SageMath de chiffrer une
phrase avec les clés a et b. Contrôler que :
affine ( " CAMARCHE " ,5 ,13)

| " XNVNUXWH "
Exercice 4.5 a) Chiffrer la phrase “C’est un trou de verdure où chante une

rivière” avec les clés de chiffrement a “ 7 et b “ 19.
b) Montrer que les clés a “ 15 et b “ 1 permettent de déchiffrer
la phrase obtenue en a) afin de retrouver en clair la phrase
d’Arthur Rimbaud.
Exercice 4.6 En chiffrant une phrase à l’aide des clés a “ 9 et b “ 19, on a

obtenu :
“CQTAPLDGDZIYTZMTLNOD”
Utiliser SageMath pour décrypter le message et en déduire les clés
de chiffrement.
Remarque: Dans l’exercice précédent, on constate que même en connaissant la

clé de chiffrement, ce n’est pas très pratique de faire une attaque
exhaustive. On pourrait néanmoins, à l’aide d’une bonne program-
mation limiter notre recherche aux 311 possibilités. Les paragraphes
suivants nous fourniront une démarche mathématique, mais pour
lesquels, nous devons définir de nouveaux outils mathématiques.
4.2 PGDC, Algorithme d’Euclide
Définition: On dit que deux nombres entiers relatifs non nuls a et b sont pre-
miers entre eux lorsqu’ils n’admettent pas de diviseur commun
autre que le nombre 1.
Définitions équivalentes: ‚ On dit que deux nombres entiers relatifs non nuls a et b sont
premiers entre eux lorsque leur PGDC est égal à 1.
‚ On dit que deux nombres entiers relatifs non nuls a et b sont
a
premiers entre eux lorsque la fraction est irréductible.
b
Exemple 2: Les nombres 725 et 58 sont-ils premiers entre eux ?
Exercice 4.7 Déterminer :
a) PGDC(35, 84) b) PGDC(39, 52)

c) PGDC(48, 54) d) PGDC(60, 45)
Exercice 4.8 Les couples de nombres suivants sont-ils premiers entre eux ?
a) 122 et 49 b) 352 et 33
Exercice 4.9 Calculer le PGDC de 4539 et 1958.
Algorithme d’Euclide: L’algorithme suivant permet de calculer le PGDC(4539, 1958).

4539 “ 2 ¨ 1958 ` 623 pr0 “ 623q
1958 “ 3 ¨ 623 ` 89 pr1 “ 89q
623 “ 7 ¨ 89 ` 0 pr2 “ 0q
Le dernier reste non nul étant 89, alors PGDC(4539, 1958) = 89.
Cet algorithme, permettant donc de déterminer le plus grand diviseur
commun de deux entiers dont on ne connaît pas la factorisation, a déjà
Une des plus anciennes été décrit dans le livre VII des Éléments d’Euclide vers 300 av. J.-C
versions connues
Appliquons plusieurs fois cet algorithme avant de peut-être (?) le
des Éléments.
justifier.
Exemple 3: Déterminer le PGDC(1365, 558).
Exercice 4.10 À l’aide de l’algorithme d’Euclide, déterminer le PGDC des couples

de nombres :
a) 777 et 441 b) 2004 et 9185 c) 1600 et 259

Exercice 4.11 Les entiers 5617 et 1515 sont-ils premiers entre eux ?
Euclide généralisé: Soit a et b deux entiers naturels non nuls. La suite des divisions
euclidiennes :
‚ de a par b a “ q 0 ¨ b ` r0
‚ de b par r0 (si r0 ‰ 0) b “ q1 ¨ r0 ` r1
‚ de r0 par r1 (si r1 ‰ 0) r0 “ q2 ¨ r1 ` r2
.. ..
. .
‚ de rn´1 par rn (si rn ‰ 0) rn´1 “ qn`1 ¨ rn ` rn`1
finit par s’arrêter, la suite des restes ri finissant par être nulle.
Le dernier reste non nul est alors le PGDC de a et b
Cet algorithme peut également être présenté sous la forme d’un

organigramme :
a et b deux entiers
naturels non nuls
r ≡ a (mod b)
OUI NON
r≠0
a prend la valeur de b
PGDC(a , b) = b

b prend la valeur de r
r ≡ a (mod b)
Exercice 4.12 Après avoir proposé le pseudo-code, programmer une fonction

reste(a,b) donnant la liste de tous les restes partiels r0 , r1 , r2 , . . . , 0
apparaissant dans l’algorithme d’Euclide appliqué sur a et b :
reste (4539 ,1958)

|[623 ,89 ,0]
Exercice 4.13 Transformer la fonction précédente afin d’obtenir l’écriture complète

de l’algorithme, c’est-à-dire :
euclide (4539 ,1958)

|4539 = 2 * 1958 + 623
|1958 = 3 * 623 + 89
|623 = 7 * 89 + 0
| le PGDC vaut donc 89
Exercice 4.14 Voici le pseudo-code d’une fonction mystère. Étudiez-le, programmez-

le sur SageMath. Que remarquez-vous ?
fonction mystere pa,bq :

si b ““ 0 :
resultat Ð a
sinon:
r Ð a mod b
resultat Ð mysterepb,rq
retourner resultat
4.3 L’égalité de Bézout (ou identité de Bézout)
L’égalité de Bézout: Soit a et b deux entiers relatifs non nuls et D leur PGDC. Il existe
deux entiers relatifs u et v tels que :
au ` bv “ D
Exemple 4: Nous avons montré que PGDC(4539, 1958) = 89. L’encadré précé-
dent affirme donc qu’il existe deux entiers u et v tels que :
4539u ` 1958v “ 89.
Contrôlons que u “ ´3 et v “ 7 vérifient effectivement cette égalité :
Étienne Bézout
(1730 – 1783)
Question: Mais comment obtenir ces 2 entiers u et v ?

Exemple 5: À l’aide de l’algorithme d’Euclide, montrer que PGDC(62, 43) = 1

puis en déduire les 2 valeurs entières u et v vérifiant :
62u ` 43v “ 1
Exercice 4.15 a) En utilisant l’algorithme d’Euclide, démontrer que 383 et 127

sont premiers entre eux, puis déterminer des entiers relatifs u et
v tels que 383u ` 127v “ 1.
b) Qu’en est-il des valeurs u “ 64 et v “ ´193 et
u “ ´317 et v “ 956 ?
c) Qu’en déduisez-vous ?
Théorème de Bézout: Soit a et b deux entiers relatifs non nuls.

a et b sont premiers il existe deux entiers relatifs
ðñ
entre eux u et v tels que au ` bv “ 1
Exercice 4.16 Utiliser la fonction euclide développée précédemment afin de guider

le calcul “à la main” des entiers relatifs u et v vérifiant :
a) 73u ` 17v “ 1
b) 62u ` 43v “ 1. En déduire une solution de 62u1 ` 43v 1 “ 5
c) 2244u ` 780v “ 12
Exercice 4.17 a) Le but de cet exercice est de programmer SageMath afin de

proposer un algorithme permettant de déterminer les entiers
u et v vérifiant 2244u ` 780v “ 12 (cf. exercice précédent).
Commençons par étudier ceci à la main.
L’idée générale est, après avoir initialisé le processus, d’expri-
mer à chaque étape le reste des divisions euclidiennes comme
combinaison linéaire des 2 nombres de départ (ici 2244 et 780) :
• Initialisation : 2244 “ 1 ¨ 2244 ` 0 ¨ 780 p1 ; 0q

780 “ 0 ¨ 2244 ` 1 ¨ 780 p0 ; 1q
Euclide Reste
• 2244 “ 2 ¨ 780 ` 684 684 “ 2244 ´ 2 ¨ 780 (1 ; 0q ´ 2p0 ; 1q p1 ; ´2q
• 780 “ 1 ¨ 684 ` 96 96 “ 780 ´ 1 ¨ 684 p0 ; 1q ´ 1p1 ; ´2q p´1 ; 3q
• 684 “ 7 ¨ 96 ` 12 12 “ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. . . . ; . . . . q
• 96 “ . . . . . . . . . . . . . . . . . . . . “ . . . . . . . . . . . . . . . . .
Compléter le tableau ci-dessus. Le reste nous intéressant, étant le

dernier non nul, montrer que vous obtenez u “ 8 et v “ ´23.
b) Effectuer de même avec l’équation :
1534u ` 180v “ PGDCp1534,180q
c) Effectuer de même avec l’équation :
744u ` 123v “ PGDCp744,123q
d) Afin de contrôler vos réponses, télécharger le fichier (OpenOf-

fice) euclidebezout.ods se trouvant sur :
http://www.javmath.ch.
Étudier la programmation des cellules du tableau proposant
les coefficients de Bézout, puis adaptez pour SageMath cet
algorithme (à l’aide d’un pseudo-code ?). Contrôlez que
bezout (744 ,123)
| " u = -20 et v = 121 "
Exercice 4.18 À l’aide de vos fonctions euclide et bezout développées sur SageMath,
déterminer les PGDC des deux nombres proposés ainsi que les
coefficients u et v de l’égalité de Bézout
a) 322 et 17 b) 512 et 28 c) 1321 et 314
SageMath: La fonction préprogrammée gcd de SageMath permet de calculer le

PGDC de 2 nombres :
gcd (1321 ,314)

| 1
4.4 Le chiffrement affine (suite)
Introduction: Pour se remettre ce type de chiffrement en mémoire, reparcourez le

premier paragraphe de ce chapitre.
Exercice 4.19 Montrer que le choix de la clé a “ 13 induit que toutes les lettres
ayant un équivalent numérique pair seront chiffrées de la même
façon.
On rappelle qu’un tel choix de clé ne convient pas, car on doit exiger
qu’à deux lettres différentes au départ correspondent deux lettres chiffrées
différentes.
Qu’est-ce que cette condition implique pour les valeurs possibles de a ?
Théorème: La condition nécessaire et suffisante pour satisfaire à cette exigence

est que a soit premier avec 26 (revoyez l’exercice 4.2).
Question: On sait, après avoir fait un choix de a satisfaisant (par exple a “ 7),
chiffrer un texte grâce à un chiffrement affine. Peut-on alors toujours
le déchiffrer ?
Oui, bien sûr ! On est assuré de pouvoir déchiffrer, car la transfor-
mation affine assure une correspondance terme à terme entre toutes
les lettres de l’alphabet, c’est une bijection et vous avez dû voir dans
un cours de base qu’il existe alors une transformation réciproque.
Cependant, on peut se demander si la recherche des clés de déchif-
frement peut se faire via l’utilisation d’une opération arithmétique
modulo 26. La réponse est oui ; on le montre en utilisant Bézout :
‚ a est premier avec 26, donc PGDC(a , 26) = 1. Ainsi, d’après
Bézout, il existe a1 et v tel que :
a ¨ a1 ` 26v “ 1
ou, modulo 26 :
Il existe a1 tel que a ¨ a1 ” 1 pmod 26q
On observe alors que a1 est un inverse de a modulo 26.

‚ Soit M 1 une lettre chiffrée, correspondante en clair à M . On
connaît M 1 , on veut retrouver M . On sait (quand on est dans
le secret du chiffrement) que :
M 1 ” a ¨ M ` b pmod 26q | ´b
M 1 ´ b ” a ¨ M pmod 26q | a1 ¨ . . .
a1 pM 1 ´ bq ” a1 ¨ a ¨ M pmod 26q | distr, inv
a1 ¨ M 1 ´ a1 ¨ b ” M pmod 26q
ou encore : M ” a1 ¨ M 1 ` pá1 ¨ bq pmod 26q
Ce qui montre l’existence d’une transformation affine de déchif-

frement, réciproque de la transformation affine de chiffrement. On
peut encore mentionner que le déchiffrement affine est unique.
Exemple 6: On considère la phrase “LACLEESTDANSLABOITE” que nous

chiffrons à l’aide du chiffrement affine M 1 “ 7M ` 10 pmod 26q.
Nous obtiendrons :
“JKYJMMGNFKXGJKREONM”
‚ Pour trouver a1 (l’inverse de a mod 26), une des deux clés du

déchiffrement, on va utiliser l’algorithme de Bézout :
7 ¨ a1 ” 1 pmod 26q
7 ¨ a1 “ 1 ` k ¨ 26
´26 ¨ k ` 7 ¨ a1 “ 1 (puis en posant ´k “ u et a1 “ v)
26u ` 7v “ 1
‚ En utilisant l’algorithme de Bézout (SageMath), on obtient :
v “ a1 “ ´11 ” 15 pmod 26q
‚ On obtient b1 grâce à la relation :
b1 “ á1 ¨ b “ 11 ¨ 10 “ 110 ” 6 pmod 26q
‚ Ainsi donc, la transformation affine de déchiffrement est :
M ” 15 ¨ M 1 ` 6 pmod 26q
Exercice 4.20 Sans utiliser SageMath, on considère les clés de chiffrement affine
a “ 11 et b “ 22.
On s’intéresse alors aux clés de déchiffrement a1 et b1 .
a) Montrer que a1 “ 19 est l’inverse de a pmod 26q.
b) Montrer que b1 “ 24 est l’autre clé.
c) Montrer que le chiffrement affine de la lettre “C” correspond
à “S”, puis que les clés de déchiffrement a1 “ 19 et b1 “ 24
retransforme bien “S” en “C”.
Exercice 4.21 On sait que Roméo a envoyé à Juliette le message chiffré suivant 1 :
“ZXTHAWBNJQBDQIEZMBJOHADRDQIIZB”.
Habituellement, il utilise toujours les mêmes clés : a “ 19 et b “ 3

‚ Sans utiliser SageMath :
a) Calculer a1 puis b1 .
b) Déterminer la lettre en clair correspondant à la première
lettre chiffrée Z.
‚ Avec SageMath :
c) À l’aide de votre fonction affine(phrase,a,b) de l’exercice
4.4, retrouver le message original.
Exercice 4.22 À l’aide des différentes fonctions développées sous SageMath, dé-
chiffrer le message suivant sachant qu’il a été chiffré avec les clés
a “ 23 et b “ 23 :
“LSVZHKKLRHKKXZSEXVQXRQLI”.
Nous allons, dans le paragraphe suivant, nous servir de ce mode de

chiffrement pour voir comment pouvaient procéder ceux qui, sans
connaître les clés de chiffrement et de déchiffrement, tentaient de
décrypter les textes chiffrés, ceux que la littérature moderne désigne
par le terme de “cryptanalystes”.
1. Afin d’éviter les éventuelles erreurs de transcription des chaînes de caractères des exercices qui suivent, vous
pouvez les retrouver sur http://www.javmath.ch afin de les copier-coller.
4.5 Un exemple de cryptanalyse
La cryptanalyse: Elle désigne l’ensemble des procédés pouvant être mis en œuvre
pour percer à jour un texte chiffré, sans connaître, à priori, la ou
les clés de chiffrement et de déchiffrement.
Plaçons-nous dans le cas où le cryptanalyste sait, cependant, que
le mode de chiffrement est une transformation affine du genre de
celles vues dans les paragraphes précédents. Il lui reste à découvrir
les clés a et b ayant servis à faire la transformation. Il pourra alors,
sans difficulté, procéder au déchiffrement.
On l’a vu, il y a 311 transformations affines possibles : il est toujours
possible “théoriquement” d’envisager chacune de ces transformations
et d’examiner, avec le cryptogramme ce que chacune d’entre elles
produit comme texte supposé en clair. On le devine, cela va être bien
fastidieux ! C’est encore un principe retenu aujourd’hui ; la recherche
d’une clé de déchiffrement est toujours réalisable théoriquement,
mais les “codeurs” choisissent des systèmes de chiffrement tels que
la découverte de la clé demande plusieurs années de calculs à des
ordinateurs puissants.
Exemple 7: Supposons que nous ayons à rendre clair le message suivant :
“YMQMGGKAMMGNNELGMYZMN”.
En sachant qu’il a été chiffré au moyen d’une transformation affine.

À ce stade, le cryptanalyste dispose d’une arme redoutable qui
peut lui éviter bien des heures de labeur fastidieux : les lettres
de l’alphabet n’apparaissent pas avec la même fréquence
dans une langue donnée ! Certaines sont rares, d’autres plus
fréquentes. C’est ainsi qu’en français, la lettre la plus fréquente est
le E suivi du S puis du A.
Avec un peu de chance, cet ordre “fréquentiel” va être suivi, à
quelque chose près, par les lettres du texte à déchiffrer : ceci sera
d’autant plus vrai que le texte sera long et, aussi, d’autant plus
que le texte à décrypter appartiendra à une famille analogue aux
textes ayant servi à établir la table des fréquences. Ici, dans le court
message que nous avons à décrypter, la lettre la plus fréquente est le
M qui apparaît six fois, suivi du G qui apparaît quatre fois. Faisons
alors l’hypothèse que le M correspond au E et le G au S.
Passons aux équivalents numériques :
chiffré clair
M Ñ 12 ,Ñ 4 ÑE
G Ñ 6 ,Ñ 18 Ñ S
Les clés de déchiffrement, a1 et b1 doivent alors vérifier les deux

équations (deux comme le nombre de paramètres à déterminer) :
‚ 4 ” 12a1 ` b1 pmod 26q (M ,Ñ E)
‚ 18 ” 6a1 ` b1 pmod 26q (G ,Ñ S)
Nous sommes donc ramenés à résoudre un système de 2 équations à

2 inconnues modulo 26.
Ces équations sont souvent désignées par le terme de Diophantiennes
(du nom du mathématicien grec Diophante vers 350 qui a beaucoup
travaillé à la résolution de ce genre d’équations).
Les règles élémentaires de calcul sur des congruences de même
module nous permettent d’opérer quasiment comme pour la résolu-
tion de systèmes d’équations classiques : nous ne pouvons faire de
divisions, mais nous pouvons faire des multiplications.
4 ” 12a1 ` b1 pmod 26q 1 (1)

"
18 ” 6a1 ` b1 pmod 26q ´1 (2)

´14 ” 6a1 pmod 26q
‚ Si a1 vérifie cette équation, il existe k P Z tel que

6a1 “ ´14 ` 26 ¨ k
ou encore 3a1 “ ´7 ` 13 ¨ k qui s’écrit donc 3a1 ” 6 pmod 13q.

‚ Multiplions par 9 qui est l’inverse de 3 modulo 13 :
a1 ” 2 pmod 13q
Donc a1 P t2 ; 15 ; 28 ; . . .u.
Modulo 26, cela nous donne a1 ” 2 pmod 26q ou a1 ” 15
pmod 26q. Comme de plus a1 doit être premier avec 26 pour
être admissible, cela nous donne comme seule solution possible
a1 “ 15.
‚ De (1) ou (2), on déduit que b1 “ 6.
On retrouve ainsi la transformation affine de déchiffrement :
affine ( " Y M Q M G G K A M M G N N E L G M Y Z M N " ,15 ,6)
| " CEMESSAGEESTTOPSECRET "
Cet exemple montre qu’une analyse statistique des fréquences de

lettres permet facilement de briser un cryptogramme quand on sait
que celui-ci est le fruit d’une transformation affine monoalphabé-
tique.
Exercice 4.23 En appliquant une démarche analogue, retrouver les clés de chiffre-
ment vérifiant :
clair chiffré
E Ñ 4 ,Ñ 12 Ñ M
S Ñ 18 ,Ñ 6ÑG
Exercice 4.24 “Casser” cette épitaphe célèbre

(à récupérer en format texte sur le site : www.javmath.ch )
OFVVFSGBXVGPBPWXGDHQXFRMXM
PDOEFSGXBXVGWRPZRPGFOOKXSMWXSD
HQKXMFSSXXVZRPWFCXBRVFAXRSXVVXXSFDB
BROXWFVPYPXHXOFKGPXORPVVFADRXVXBDRCKPGM
RSOKXHPXKMRCXGOXSMFSGWFMDRUPXHXPWOFVVFX
SBDKXWXVXOGPXHXMXVFCPXFCFSGMXOKXSMKXRSX
XODRVXXGBPSZFSVOWRVGFKMPWXRGRSQXWXSIFS
GZRPFOKXVFCDPKFGGXPSGWFHDPGPXMXWFT
XIPSFWMXVDSOXKXOXKPGMRSXHDKGHFWE
XRKXRVXVDSOXKXWRPVRKCXBRGZRFGK
XFSSXXVMXGDRGBXBPMXMRPVVDSFTX
4.6 Un exemple de chiffrement polyalphabétique
La lutte se trouve engagée entre “codeurs” et “cryptanalystes”. Les

premiers doivent anticiper le travail des seconds pour essayer de leur
rendre la tâche malaisée, voire impossible.
On peut citer, avant d’envisager des moyens plus récents, un système
de chiffrement proposé par Blaise de Vigenère qui a publié en
particulier un “Traité des chiffres” (1586) qui est à la fois un manuel
d’épigraphie et un véritable livre de cryptographie diplomatique.
Son procédé emprunte à celui de César en le complexifiant : on
opère des translations sur les lettres du texte à chiffrer en fonction
d’un mot-clé indiquant les translations à opérer selon le rang des
Blaise de Vigenère lettres dans le texte. Illustrons-en le principe avec un exemple : le
(1523 - 1596) mot-clé est CODE.
message C E M E S S A G E E S T S E C R E T
en clair 2 4 12 4 18 18 0 6 4 4 18 19 18 4 2 17 4 19
Clé C O D E C O D E C O D E C O D E C O
"bout à bout" 2 14 3 4 2 14 3 4 2 14 3 4 2 14 3 4 2 14
message 4 18 15 8 20 6 3 10 6 18 21 23 20 18 5 21 6 7
chiffré E S P I U G D K G S V X U S F V G H
Comme il y a 4 lettres dans le mot CODE, les lettres de rang 1

modulo 4 dans le texte vont subir une translation de 2 (l’équivalent
numérique de C), puis les lettres de rang 2 modulo 4 vont subir une
translation de 14 (l’équivalent numérique de O) etc. . .
Le mot-clé est simple à transmettre, les modes de chiffrement et
de déchiffrement sont simples. C’est encore ce principe de chiffre-
ment qui était utilisé par les Allemands pendant la Seconde Guerre
mondiale et qui était automatisé avec la machine Enigma. Le cryp-
tanalyste est en difficulté pour utiliser la fréquence des lettres, du
moins tant qu’il n’a pas d’autres indications sur la longueur du
mot-clé. En effet, la lettre E a été chiffrée successivement par S, I,
G, S, S et G.
Les régularités dans la langue ou la recherche de mots probables
dans le texte peuvent permettre de deviner cette longueur. . . C’est
ce que les Anglais ont réussi à faire à plusieurs reprises durant la
guerre.
Il s’agit dans les exercices suivants de programmer SageMath afin
de chiffrer et/ou déchiffrer des messages à l’aide de cette méthode.
Exercice 4.25 a) Combien de fois faudra-t-il mettre bout à bout la clé “BO” pour
chiffrer le message :
“MONPREMIERMESSAGE” ?
b) Combien de fois faudra-t-il mettre bout à bout une clé de n

caractères pour chiffrer un message de m caractères (m ą n) ?
c) Proposer une fonction SageMath permettant de chiffrer un texte
à l’aide d’une clé :
vigenere ( " ETVOICILEDERNIER " ," MACLEF " )

| " QTXZMHULGOIWZIGC "
Exercice 4.26 Pour finir, déchiffrer le message suivant sachant que la clé de chif-
frement était “BIENVU” :
“OMQNIKVMDCVMMMWVOYBZWPMSQBSTMUQPMPV”
La cryptographie à clé publique : RSA
5
5.1 Quelques nouveaux outils mathématiques
Rappel: ‚ Deux nombres d et e sont dits inverses modulo n si :
d ¨ e ” 1 pmod nq.
‚ d admet un inverse modulo n ssi d et n sont premiers entre eux.

Exemple 1: Déterminer l’inverse de 7 modulo 20 (sans utiliser Bézout).
Exercice 5.1 Concevoir une fonction invmod(d,n) sur SageMath permettant de

calculer e, l’inverse d’un nombre d modulo n. Par exemple :
invmod (5 ,1848)
|1109
Exercice 5.2 À l’aide de votre fonction, déterminer

a) l’inverse de 5 modulo 39 ;
b) l’inverse de 37 modulo 123456789.
SageMath: Vous avez peut-être constaté que votre fonction peut être particuliè-
rement lente. On peut alors utiliser la fonction prédéfinie :
inverse_mod (37 ,123456789)

|3336670
Définition: On appelle exponentiation modulaire les calculs du type :
ab pmod nq
Exercice 5.3 À l’aide de SageMath, calculer
a) 551 pmod 97q b) 1122 pmod 167q

c) 123456789987654321 pmod 11q
57
58 CHAPITRE 5. LA CRYPTOGRAPHIE À CLÉ PUBLIQUE : RSA
SageMath: La fonction power_mod(a,b,n) permet d’obtenir directement :
power_mod (123456789 ,987654321 ,11)

|5
5.2 La cryptographie à clé publique
Introduction: Dans les années 1970, la cryptographie n’est plus seulement l’apanage
des militaires. Les banques, pour la sécurité de leurs transactions,
sont devenues de grandes consommatrices de messages chiffrés. Les
chiffrements disponibles alors sont sûrs, eu égard aux possibilités
d’attaques contemporaines. Le problème essentiel est alors la distri-
bution des clés, ce secret que l’envoyeur et le destinataire doivent
partager pour pouvoir respectivement chiffrer et déchiffrer. Les ar-
mées et les états ont recours aux valises diplomatiques pour ces
échanges, mais ceci n’est pas accessible aux civils...
En 1976, Whitfield Diffie et Martin Hellman proposent une nouvelle

façon de chiffrer, qui contourne cet écueil. Commençons par expliquer
leur procédé de façon imagée. Un ami doit vous faire parvenir un
message très important par la poste, mais vous n’avez pas confiance
en votre facteur que vous soupçonnez d’ouvrir vos lettres. Comment
être sûr de recevoir ce message sans qu’il soit lu ? Vous commencez
par envoyer à votre ami un cadenas sans sa clé, mais en position
ouverte. Celui-ci glisse alors le message dans une boîte qu’il ferme à
l’aide du cadenas, puis il vous envoie cette boîte. Le facteur ne peut
pas ouvrir cette boîte, car la seule clé le permettant est en votre
possession.
CHAPITRE 5. LA CRYPTOGRAPHIE À CLÉ PUBLIQUE : RSA 59
La cryptographie à clé publique repose exactement sur ce principe.

Mais il s’agira de créer deux clés différentes : une permettant de
chiffrer (clé publique) et une deuxième, ne pouvant se déduire de la
précédente permettant de déchiffrer le message (clé privée).
clé publique clé privée
On dispose d’une fonction f sur les entiers, qui possède un inverse

g. On suppose qu’on peut fabriquer un tel couple pf ; gq, mais
que connaissant uniquement f , il est impossible (ou du moins très
difficile) de retrouver g.
f est la clé publique, que vous pouvez révéler à quiconque. Si Alice
veut vous envoyer un message M , elle le chiffre à l’aide de f et vous
transmet M 1 , sans aucune précaution. g est la clé privée, elle reste
en votre seule possession. Vous déchiffrez le message en calculant :
gpf pM qq “ gpM 1 q “ M.
La connaissance de f par un tiers ne compromet pas la sécurité de

l’envoi des messages chiffrés, puisqu’elle ne permet pas de retrouver
g. Il est possible de donner librement f , qui mérite bien son nom de
clé publique.
‚ Mais, comment trouver de telles fonctions f et g ?
Diffie et Hellman n’ont pas eux-mêmes proposé de fonctions satisfai-
santes, mais dès 1977, R. Rivest, A. Shamir et L. Adleman trouvent
une solution possible, la meilleure et la plus utilisée à ce jour, la
cryptographie RSA.
Adi Ronald Len

Shamir Rivest Adleman
La grande réussite de leur travail en commun est sans doute due au

fait que leurs compétences se complètent.
‚ Rivest est un grand spécialiste de la cryptographie.
‚ Shamir est au contraire un spécialiste de la cryptanalyse, dont
le but est de casser les protections mises en place par la cryp-
tographie : il est notamment connu pour avoir cassé en 1982 le
cryptosystème de Merkle-Hellman.
‚ Adleman, quant à lui, représentait le grain de folie du groupe : il
travaillait à l’époque sur la bio-informatique, en gros, des ordina-
teurs utilisant de l’ADN pour faire leurs calculs. Ça vous place le
personnage.
Le principe général: ‚ Il est “facile” de fabriquer de grands nombres premiers p et q
(pour fixer les idées, 100 chiffres).
La commande SageMath next_prime fournit instantanément le
nombre premier qui suit le nombre proposé. Par exemple :
next_prime (12345678910)
| 12345678923
‚ Étant donné un nombre entier n “ p ¨ q produit de 2 grands

nombres premiers, il est très difficile de retrouver les facteurs p
et q.
Marche à suivre: Alice doit envoyer un message à Bob, elle a donc besoin de la clé
publique RSA de Bob. Voici les différentes étapes :
1) Il choisit p et q deux grands nombres premiers (plus de 100

chiffres).
Bob
2) Il calcule n “ p ¨ q.
Le nombre n, le modulo RSA, a environ 200 chiffres. Il est
publique alors que p et q sont gardés secrets.
3) Il calcule ϕpnq “ pp ´ 1qpq ´ 1q,

qui s’appelle la fonction d’Euler, et qui doit rester secret.
Retrouver ϕpnq sans connaître p et q est aussi difficile que de
factoriser n.
4) Il choisit un nombre e en s’assurant que PGDCpe , ϕpnqq “ 1.

Il s’agira de l’exposant de chiffrement RSA .
5) Il calcule d, inverse de e modulo ϕpnq et garde secret le couple

pn , dq.
Il s’agira de la clé privée RSA. Il la garde secrète afin de
pouvoir déchiffrer par la suite le message transmis par Alice.
6) Il transmet (ou publie dans un annuaire) le couple pn , eq.

Ce couple s’appelle la clé publique RSA.
7) Elle convertit son message “texte” en un nombre M compris

entre 0 et n.
Alice
8) Elle calcule M 1 ” M e pmod nq et envoie ce message chiffré M 1 .
À l’aide d’un logiciel (comme SageMath par exemple).
9) Pour le déchiffrer, il calcule M ” pM 1 qd pmod nq à l’aide de sa

clé privée d.
Ceci lui permet de retrouver le message d’origine, car :
Bob
pM 1 qd ” pM e qd pmod nq ” M e¨d pmod nq ” M pmod nq.
10) Il reconvertit ce nombre en un message clair.
Exemple 2: Une compagnie veut instaurer un système de commandes sur Inter-

net. Elle instaure donc un chiffrement à clé publique (RSA) pour la
transmission du numéro de carte de crédit. Le numéro de carte de
crédit est un numéro de 16 chiffres auquel on ajoute les 4 chiffres qui
correspondent à la date d’expiration, soit un nombre de 20 chiffres.
‚ La compagnie choisit donc p et q deux grands nombres premiers
p “ 9760959751111112041886431
q “ 8345523998678341256491111.
‚ Ceci donne n “ p ¨ q et ϕpnq “ pp ´ 1qpq ´ 1q :

n “ 81460323853031154412157864943449033559900223014841
ϕpnq “ 81460323853031154412157846836965283770446924637300
‚ La compagnie choisit sa clé de chiffrement e “ 45879256903 et

calcule son inverse d pmod ϕpnqq :
d “ 61424931651866171450267589992180175612167475740167
Un client dont le numéro de sa carte de crédit est 1234 5678 9098

7654 et la date d’expiration est le 01/06 enverra donc “le message”
M = 12345678909876540106.
‚ Le logiciel d’envoi calcule M 1 ” M e pmod nq :

M 1 “ 6251765106260591109794074603619900234555266946485.
‚ Le nombre M 1 est transmis. À la réception le logiciel de la

compagnie calcule :
pM 1 qd ” 12345678909876540106 pmod nq.
Qui correspond donc bien au n° de la carte de crédit ainsi que sa
date d’expiration.
Dans la réalité, les entiers p et q choisis ne sont pas encore assez grands
et un ordinateur pourrait factoriser n dans un temps convenable.
Exercice 5.4 À l’aide de SageMath, contrôler que toutes les valeurs 1 proposées
dans l’exemple précédent (p, q, n, ϕpnq, e, d, M 1 ) vérifient bien les
conditions de la marche à suivre.
Rappelons quelques commandes pratiques de SageMath :
is_prime( ), gcd( ), power_mod( , , ), . . .
Exercice 5.5 Effectuer la démarche de chiffrement avec la clé pn ,eq proposée :
p51201345568138081747 , 158792633q
sur le même numéro de carte de crédit M .

a) Calculer M 1 le message chiffré correspondant à ce numéro.
b) Vérifier que la clé ci-dessous permet de retrouver le numéro.
d “ 39115303732664896793
Exemple 3: Alice a pris connaissance de la clé publique de Bob : (253 , 3), où

253 correspond à n et 3 à e. Elle veut lui envoyer le message OUI.
Elle chiffre le message selon le code standard : 14 pour O, 20 pour
U et 8 pour I.
O U I
M (en clair) 14 20 08
M 1 ” M 3 pmod 253q 214 157 006
Le message chiffréé est donc 214 157 006.
Exercice 5.6 À l’aide de SageMath, déterminer dans ce cas simple, les 2 nombres
premiers p et q, ϕpnq et la clé d de déchiffrement. Assurez-vous, en
déchiffrant le message, que vous obtenez bien le message OUI en
clair.
1. Ces différentes valeurs peuvent être retrouvées et recopiées sur http://www.javmath.ch

Remarque: Sur un long texte, la démarche proposée dans l’exemple précédent

n’aurait pas tenu longtemps à une analyse statistique de fréquences
des lettres. On peut alors tenter de chiffrer le message en le consi-
dérant en un unique bloc (exercice suivant) ou en le découpant en
blocs de deux lettres (digramme), comme le montrera le prochain
exemple.
Exercice 5.7 Suite de l’exemple 2 :

Si Alice avait voulu transmettre son message en un seul bloc, elle
aurait calculé 1420083 modulo 253.
a) Montrer en quoi cette démarche n’aurait pas permis de déchif-
frer le message correctement.
b) Elle décide alors d’utiliser les nombres premiers p “ 5147 et
q “ 7351. Montrer que la clé e “ 307 est compatible puis
chiffrer ce message en un bloc.
c) Calculer la clé d de déchiffrement et assurez-vous du message
déchiffrer.
Exemple 4: Chiffrement d’un message par blocs (digrammes)

Supposons que la clé publique de Bob soit p1943 ,5q. Alice veut lui
envoyer le message :
OKPOURLUNDI
Elle convertit ces lettres en chiffres comme d’habitude :
O K P O U R L U N D I
14 10 15 14 20 17 11 20 13 03 08
Afin d’obtenir exactement 6 blocs de 2 lettres, elle ajoute deux zéros

à la fin du chiffre. Elle obtient :
OK PO UR LU ND IA
14 10 15 14 20 17 11 20 13 03 08 00
Alice va numériser les digrammes de la manière suivante :

Le digramme OK devient d1 “ 14 ¨ 261 ` 10 “ 374.
Le digramme PO devient d2 “ 15 ¨ 261 ` 14 “ 404.
Etc. . .
En utilisant la clé publique de Bob, elle obtient ainsi :
OK PO UR LU ND IA
M 374 404 537 306 341 208
M 1 “ M 5 pmod 1943q 1932 635 68 1705 71 660
Elle peut envoyer le message :

‚ soit directement sous sa forme numérique :
1932 635 68 1705 71 660
‚ soit en convertissant ces nombres, selon le même principe, en
lettres :
1932 “ 2 ¨ 262 ` 22 ¨ 26 ` 8 qui correspond au trigramme CWI.
635 “ 24 ¨ 26 ` 11 qui correspond au digramme YL.
Etc. . .
M 1 “ M 5 pmod 1943q 1932 635 68 1705 71 660

M CWI YL CQ CNP CT ZK
Elle enverra donc le message :
CWI YL CQ CNP CT ZK
Bob recevant ce message, il le déchiffre à l’aide de sa clé privée

pn “ 1943 , d “ 1109q :
CWI YL CQ CNP CT ZK
M 1
1932 635 68 1705 71 660
M ” pM q1 1109
pmod 1943q 374 404 537 306 341 208
14 ¨ 26 ` 10 15 ¨ 26 ` 14 20 ¨ 26 ` 17 11 ¨ 26 ` 20 13 ¨ 26 ` 03 08 ¨ 26 ` 00
OK PO UR LU ND I(A)
Le A terminal étant dû à la technique de chiffrement, il doit donc

être supprimé.
Exercice 5.8 a) Chiffrer, à l’aide de digrammes, le message JETAIME à l’aide

de la clé publique p2077 , 19q.
b) Retrouver la clé privée d puis déchiffrer ce nouveau message :
3 261 833.
Exercice 5.9 En appliquant une démarche comparable, mais en décomposant le

message en trigrammes, montrer que le message YES chiffré à l’aide
de la clé publique p46927 , 39423q devient BFIC.
Exercice 5.10 Votre professeur d’OC envoie votre moyenne au secrétariat via un
courriel chiffré en RSA. La clé publique du secrétariat est p55 , 7q et
le message chiffré envoyé est 25.
Quelle est votre moyenne ?
Remarque: Les algorithmes à clé publique (on parle aussi de chiffrement asymétrique)
ont pourtant un grave défaut : ils sont lents, beaucoup plus lents que leurs
homologues symétriques. Pour des applications où il faut échanger de
nombreuses données, ils sont inutilisables en pratique. On a alors recours
à des cryptosystèmes hybrides. On échange des clés pour un chiffrement
asymétrique grâce à la cryptographie à clé publique, ce qui permet de
sécuriser la communication de la clé. On utilise ensuite un algorithme de
chiffrement symétrique. Le célèbre PGP, notamment utilisé pour chiffrer
le courrier électronique, fonctionne sur ce principe.
5.3 La cryptographie et les transactions bancaires (WEB)
Comment ça marche ?: La majorité des transactions sécurisées sur Internet utilisent l’algo-
rithme RSA avec des clés publiques de différentes tailles. En voici
une, fictive, qui pourrait être celle de votre banque :
ED 74 A7 6C D3 3A E3 77 0B BC FC DF E5 0D 32 C4 35 10 86 D8 B8 89 5E F8 AC 23 14
1D 27 7F D3 FA 78 4F 55 60 0B 6A C9 C0 83 0B 90 A0 5F 6B 69 2A F7 12 23 44 25 A7 C0
5F 96 28 35 EB B4 C8 BE DE 3C 35 59 EF 92 49 17 F6 1D A6 6B 75 3E 78 BD 9C 6C 14
0A 7C 09 35 29 9C C2 B9 F2 1C 77 2C 57 1F D4 04 0B 09 C6 1D A4 F4 13 27 45 0B 2C D7
8B B5 9C 75 5C 38 AF 18 78 04 9B F6 A6 0E DD EB 18 AE 2A 8D 96 35 28 63 48 F2 A5
92 C0 4C D5 4B 02 39 38 35 73 74 04 CE 6C F6 CB F1 55 08 FC EA DA 17 C6 A7 7C C0
EE E7 0B FB CB 99 B3 11 94 C4 26 A1 C5 EE 31 FC CB 1F F2 89 0F A9 CD E1 10 E6
0F 96 D3 6B FE D0 65 F7 A0 95 95 31 35 96 13 74 8F 7D 08 13 6E 1D DA 8F 7C 59 FC 62
BC 0F CD 80 72 3E 2D 29 4A 8C 78 C0 23 86 6D EF FB 8C C3 3F 73 0C AE 24 5D 25 90
86 44 DD 81 45 A5 A6 37 81 0F 7D
Il s’agit d’un nombre hexadécimal, c’est-à-dire écrit en base 16. Si

on le convertissait en base 10 (cf. paragraphe suivant), on obtien-
drait :
237 116 167 108 . . . 15 125
En vous loguant sur le site de votre banque, une phase d’authenti-
fication a eu lieu sans que le vous ne vous en rendiez compte. En
effet, lorsque vous arrivez sur une page sécurisées (https) via votre
navigateur, celui-ci vérifie également l’identité de la banque via une
autorité de certification. Si le certificat n’est pas valable ou s’il
est manquant, le navigateur le signale au client. Un tel certificat
peut être consulté en cliquant sur le cadenas d’une page sécurisée.
En voici un exemple :
Une autorité de certification est une organisation qui recense des

clés publiques associées et leurs propriétaires légitimes. Lors d’une
communication sécurisée, les deux parties font confiance à cette
organisation. Quand le navigateur du client reçoit la clé publique
de la banque, il peut contacter l’autorité de certification pour lui
demander si la clé publique appartient effectivement à cette banque.
Il va de soi que la réponse est signée (sous forme également chiffrée)
par l’autorité de certification. Étant donné que la banque utilise une
clé publique certifiée par l’autorité de certification, un site frauduleux
qui imiterait le site de la banque ne peut pas envoyer sa propre clé
sans que le navigateur ne le détecte. Lorsque cette étape s’est donc
passée sans encombre, vous devrez préciser votre nom d’utilisateur
avec différents mots de passe personnels (NIP) selon le protocole
proposé par votre banque. C’est la phase d’authentification du client.
Vous pourrez alors enfin effectuer votre transaction bancaire.
Pour plus d’informations sur le sujet :
https://fr.wikipedia.org/wiki/Infrastructure_à_clés_publiques
5.4 Il n’y a pas que la base 10 dans la vie. . .
Introduction: Le système numérique utilisé aujourd’hui par les humains est

construit à l’aide de dix différents symboles, soient :
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Y a-t-il une raison particulière pour laquelle les humains ont choisi
10 différents symboles plutôt que 3 ou 77. Certains disent que c’est
par pur hasard, tandis que d’autres suggèrent que c’est parce que
nous sommes munis de 10 doigts. Nous ne le saurons probablement
jamais d’une façon certaine.
En mathématiques, on dit que notre système numérique est en
base 10 puisqu’on y trouve que dix symboles différents. On peut
visualiser ceci sur un compteur électrique :
2 0 0
..
2 0 .
2 0 9
2 1 0
.. ..
2 . .
2 9 9
3 0 0
Ainsi le nombre 4322 peut s’écrire sous la forme :
4000 ` 300 ` 20 ` 2
ou plutôt
4 ¨ 10 ` 3 ¨ 102 ` 2 ¨ 101 ` 2 ¨ 100
3
Mais il est tout à fait possible de faire des mathématiques avec

seulement deux symboles (on dit qu’il s’agit d’un système numérique
en base 2). Ce système numérique construit qu’avec les symboles
0 et 1 est un système communément appelé le système numérique
binaire. Le système numérique binaire est précisément celui utilisé
par les ordinateurs pour faire les calculs.
Visualisons ceci à nouveau sur un compteur qui tourne :
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
Ainsi le nombre 1011010 peut s’écrire sous la forme :

1 ¨ 26 ` 0 ¨ 25 ` 1 ¨ 24 ` 1 ¨ 23 ` 0 ¨ 22 ` 1 ¨ 21 ` 0 ¨ 20
Le système numérique en base 3 veut dire un système où tous les
nombres ne sont faits qu’avec trois symboles, soient 0, 1, 2.
Un berger de l’antiquité aurait très bien pu compter ses moutons
comme suit :
1, 2, 10, 11, 12, 20, 21, 22, 100, 101, 102, 110, 111, 112, 120, 121,
122, 200, 201, 202, 210, 211, 212, 220, 221, 222, 1000, . . .
Pour ne pas confondre le “100 en base 3” du berger avec notre “100
en base 10” (puisque que de toute évidence ils représentent des
quantités différentes) on écrit 1003 comme abréviation de “100 en
base 3”.
En comptant très attentivement on voit que pour le berger, 1113
moutons correspondent à 13 “ 1310 moutons pour nous.
En effet :
5.5 Quelques bases utilisées dans le passé ou actuellement :

‚ les base 2 (système binaire), base 8 (système octal), base 16
(système hexadécimal) sont utilisées en informatique ;
‚ la base 10 (système décimal), la plus commune, aujourd’hui
la référence dans le domaine des sciences ;
‚ la base 12 (système duodécimal), de manière embryonnaire,
a été utilisée par les Égyptiens pour le compte en heures et
mois ;
‚ la base 20 (système vigésimal) a été utilisée par les Mayas
et les Aztèques, ainsi que de manières alternatives en France
(dont on garde en l’héritage pour quatre-vingts) ;
‚ la base 26 utilisée en cryptographie pour chiffrer les 26 carac-
tères de l’alphabet ;
‚ la base 60 (système sexagésimal), dans la mesure du temps
et des angles, il a été utilisé par les Sumériens, les Akkadiens,
puis les Babyloniens ;
‚ la base 150 ou base indienne, utilisée notamment dans la table
astronomique appelée Table indienne d’al-Khawarizmi.
5.6 Conversion d’une base vers une autre :

Lorsque l’on veut passer d’une base à une autre, on utilisera la
méthode décrite dans les exemples ci-dessous, en utilisant éventuel-
lement la base 10 comme « pont » :
Exemple 5: ‚ Convertir en base 10 le nombre : 1010012
‚ Convertir en base 3 le nombre : 3410

‚ Convertir en base 5 le nombre 12314
Exercice 5.11 Convertir les nombres suivants en base 10
a) 1101010012 b) 1101010013
c) 4445 d) 199311
e) 7A616
On utilise les lettres A à F pour noter les “chiffres” de 10 à 15 dans la base 16
Exercice 5.12 Convertir
a) 25510 en base deux b) 5610 en base sept

c) 203410 en base onze
Utiliser éventuellement la lettre A pour représenter le dixième “chiffre” de la
base onze
Exercice 5.13 Convertir
a) 557 en base deux b) 324 en base sept
Une 2e méthode: Reprenons la conversion du dernier de l’exercice 5.12 :

203410 ñ . . . . . . 11
Exercice 5.14 Contrôler vos réponses obtenues en a) et b) de l’exercice 5.12 à

l’aide de cette nouvelle méthode.
Exercice Défi: Proposer une fonction SageMath permettant de convertir un nombre

de la base 10 en une autre base.
Exemple 6: ‚ Convertir 2 en base 10 “le nombre” : COU26
‚ Convertir en base 26 le nombre : 2310110
Exercice 5.15 Convertir en base 10 ou en base 26 les “nombres proposés”
a) 999210 b) NON26
5.7 Les opérations en binaire (ou toute autre base. . . ) :

Le fait de travailler en base 2 ne change rien aux règles profondes qui
lient les nombres. On peut donc dire qu’en binaire, les opérateurs
existant en base 10 s’appliquent avec les mêmes règles.
Exemple 7: ‚ L’addition : 1102 ` 102 “ . . .
2.
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
Exemple 8: ‚ La multiplication 10102 ¨ 1102 “ . . .
Remarque: La soustraction et la division me direz-vous. . . Et bien ça marche

aussi. . . Mais je vous laisse découvrir ceci dans le cadre d’un cours
de math plus sérieux. . . ou sur Internet ©.
Exercice 5.16 Effectuer les opérations suivantes dans les bases indiquées, puis
après conversion en base 10, vérifier le résultat :
a) 1202113 ` 201013 b) 11012 ¨ 100012

c) A9712 ` 4B12 d) AA11 ¨ 1211
A
Bibliographie
Bibliographie
1. SIMON SINGH, Histoire des codes secrets, Livre de Poche, 2001
2. DIDIER MULLER, Les codes secrets décryptés, City Editions, 2007
3. DIDIER MULLER, Les 9 couronnes, Société jurassienne d’Emulation, 2009
Sur le WEB
1. Le site compagnon du polycopié :
www.javmath.ch
2. Ars Cryptographica :
www.apprendre-en-ligne.net/crypto
3. La Cryptogr@phie expliquée :
www.bibmath.net/crypto
À propos de SageMath et Python

1. SageMath sur la plateforme Cocalc, l’interface que nous utilisons :
https://cocalc.com/
2. SageMath, le site de référence en français (tutoriels, téléchargement. . .) :
www.sagemath.org/fr/
3. Calcul mathématique avec Sage (un mode d’emploi en pdf de 460 pages. . .)
http://dl.lateralis.org/public/sagebook/sagebook-web-20130530.pdf
73
Quelques éléments de solutions
A
A.1 Un doigt d’algorithmique avec SageMath
Exercice 1.1:
factorielle (40)
|815915283247897734345611269596115894272000000000
factorielle (100)
| 9 3 3 2 6 2 1 5 4 4 3 9 4 4 1 5 2 6 8 1 6 9 9 2 3 8 8 5 6 2 6 6 7 0 0 4 9 0 7 1 5 9 6 8 2 6 (...)
Exercice 1.2:
Pas de corrigé
Exercice 1.3:
def successeur ( n ):
n = n +1
return n
Exercice 1.4:
a) Il permute les 2 valeurs a et b. On peut s’en convaincre à l’aide du tableau :
Variables
a b
Entrée 7 5
aÐa`b 12 5
bÐa´b 12 7
aÐa´b 5 7
b) Il s’agit de :
def mystere (a , b ):
a=a+b
b =a - b
a =a - b
return a , b
I
II ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Exercice 1.5:
L1 =[]; L2 =[]; L3 =[]; L4 =[];
for i in [ -3..3]:
L1 = L1 +[ i ]
print L1
for i in [ -2..4]:
L2 = L2 +[ i ^2]
print L2
L3 = L1 + L2
print L3
for i in [0..6]:
L4 = L4 +[ L1 [ i ]+ L2 [ i ]]
print L4
Exercice 1.6:
a) Le pseudo-code :
M ult7 Ð liste vide

kÐ1
tant que 7 ¨ k ă 60 :
ajouter 7 ¨ k dans M ult7
k “k`1
afficher M ult7
Exercice 1.7:
a) Il s’agit à nouveau de calculer la factorielle : n!
Le pseudo-code “testé à la main” donne pour n “ 3 :
Variables
n k p
Entrée 3 - -
Initialisation - 1 1
1re boucle 3 2 1
2e boucle 3 3 2
3e boucle 3 4 6
b)
def mystere ( n ):
p =1
k =1
while k < n +1:
p=p*k
k = k +1
return p
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS III
Exercice 1.8:
a) Cette fonction permet de calculer le quotient et le reste de la division de n par p.
On peut s’en convaincre en “testant à la main” le pseudo-code avec n “ 17 et p “ 6 :
Variables
n p j
Entrée 17 6 -
Initialisation - - 0
1re boucle 11 6 1
2e boucle 5 6 2
Et en effet : 17 “ 2 ¨ 6 ` 5
b)
def divmod (n , p ):
j =0
while n >= p :
n =n - p
j = j +1
return j , n
Exercice 1.9:
On peut par exemple proposer :
def tableau ( min , max ):

for x in [ min .. max ]:
print " si x = " ,x , " alors f ( " ,x , " )= " ,x ^3 - x ^2+2
Ce qui donnera :
tableau ( -3 ,3)
| si x = -3 alors f ( -3 )= -34
| si x = -2 alors f ( -2 )= -10
| si x = -1 alors f ( -1 )= 0
| si x = 0 alors f ( 0 )= 2
| si x = 1 alors f ( 1 )= 2
| si x = 2 alors f ( 2 )= 6
| si x = 3 alors f ( 3 )= 20
Exercice 1.10:
1
n
c) Elle permet de calculer
ÿ
k“0
k!
d) Cette fonction permet de calculer le quotient et le reste de la division de n par p.

On peut s’en convaincre en “testant à la main” le pseudo-code avec n “ 3 :
IV ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Variables
n somme k
Entrée 3 - -
Initialisation - 0 -
1re boucle 3 1 0
2e boucle 3 1`1 1
3e boucle 3 1`1` 1
2
2
4e boucle 3 1`1` ` 1
2
1
6
“ 8
3
3
e)
def sommefacto ( n ):
somme =0
for k in [0.. n ]:
somme = somme +1/ factorielle ( k )
return ( somme )
e) Vous obtiendrez l’approximation d’un nombre bien connu . . . :
N ( sommefacto (6)) N ( sommefacto (100))

|2. 718055 555555 56 |2. 718281 828459 05
Exercice 1.11:
a) On considère une première fonction monlog :
def monlog ( n ):
return log (3* n +1)
qui sera ensuite appelé dans une deuxième fonction pour donner le résultat :
def masomme ( min , max ):

somme =0
for i in [ min .. max ]:
somme = somme +1/ monlog ( i )
return N ( somme )
masomme (3 ,7)
|1. 847978 212420 55
12
i
b) Démarche comparable. On obtient : – 16.859914
ÿ
2i ´ 1
a
i“5
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS V
Exercice 1.12:
a) def facto ( n ):
if n ==0:
return 1
else :
return n * facto (n -1)
b) Cette troisième façon d’obtenir n! est certainement la plus subtile, car à l’intérieur de la
fonction elle-même, la commande factorielle est appelée.
On appelle ceci une fonction récursive.
c) def combi (n , p ):
c = facto ( n )/( facto ( p )* facto (n - p ))
return c
Exercice 1.13:
a) def syra ( n ):
if n %2==0:
return ( n /2)
else :
return (3* n +1)
b) def suitesyra (N , nbre ):

Liste =[ N ]
for k in [1.. nbre ]:
Liste = Liste +[ syra ( Liste [k -1])]
return Liste
c) Pas de corrigé proposé. . . Exercice Défi

VI ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
A.2 Nombres premiers

Exercice 2.1:
a) Non
b) ‚ On peut affirmer que le nombre 301 031 “ 2 ¨ 3 ¨ 5 ¨ 7 ¨ 11 ¨ 13 ` 1 ne contient pas dans
sa décomposition en nombres premiers les nombres 2, 3, 5, 7, 11, 13 en reproduisant le
raisonnement du théorème précédent.
‚ On ne peut par contre pas exclure que ce nombre puisse être composé de nombres premiers
plus grands que 13. Et ici 301 031 “ 59 ¨ 509. Pour aller un petit peu plus loin dans cet
exercice :
Supposons que nous connaissions comme nombres premiers les seuls nombres 2, 3 et 5. Le
procédé nous permet de calculer le nombre 2 ¨ 3 ¨ 5 ` 1 “ 31 qui est premier. On trouve d’autres
nombres premiers en répétant le processus : 2 ¨ 3 ¨ 5 ¨ 31 ` 1 “ 931. Le nombre obtenu est cette fois
composé : 931 “ 72 ¨ 19 et les facteurs 7 et 19 sont premiers. Notre liste est alors 2, 3, 5, 7, 19 et
31, et l’on peut recommencer autant de fois que l’on veut.
Va-t-on ainsi pouvoir générer la liste de tous les nombres premiers ?
Dans l’état des connaissances actuelles, on ne sait pas si cette liste contiendra effectivement
tous les nombres premiers.
Exercice 2.2:
n “ 41 nous fournit un contre-exemple, car n2 ´ n ` 41 sera alors forcément un multiple de 41.
Exercice 2.3:
fonction est_premier pnq :
pour k P r2 , n ´ 1s :
si n mod k ““ 0 :
retourner False
retourner True
def est_premier ( n ):
for k in [2.. n -1]:
if n % k ==0:
return False
return True
Exercice 2.4:
fonction est_premier2 pnq :
si n ““ 0 ou n ““ 1 :
retourner False
sinon:
si n ““ 2 :
retourner True
sinon: ?
maxi Ð r n s ` 1
pour k P r2 , maxis :
si n mod k ““ 0 :
retourner False
retourner True
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS VII
def est_premier2 ( n ):
if n ==0 or n ==1:
return False
else :
if n ==2:
return True
else :
maxi = int ( sqrt ( n ))+1
for k in [2.. maxi ]:
if n % k ==0:
return False
return True
Exercice 2.5:
a)
def euler ( n ):
f = n ^2 - n +41
print est_premier2 ( f )
b) Ce qui donne
euler (2)
| True
euler (40)
| True
euler (41)
| False
euler (42)
| False
c) + d) Nouvelle fonction :
def euler2 ( n ):
L =[]
for i in [0.. n ]:
f = i ^2 - i +41
if est_premier2 ( f )== False :
L = L +[ i ]
print ( L )
val =100*(101 - len ( L ))/101
print " Il y a donc " ,(101 - len ( L )) ,
" nombres premiers , soit dans : " ,
N ( val , digits =3) , " % des cas "
Ce qui donne :
euler2 (100)
|[41 , 42 , 45 , 50 , 57 , 66 , 77 , 82 , 83 , 85 , 88 , 90 , 92 , 97]
| Il y a donc 87 nombres premiers , soit dans : 86.1 % des cas
VIII ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Exercice 2.6:
a) + b) On obtient (extrait) :
crible (1000)
| [2 , 3 , 5 , 7 , 11 , 13 , ... , 983 , 991 , 997]
crible (100000)
| [2 , 3 , 5 , 7 , 11 , 13 , ... , 99971 , 99989 , 99991]
Exercice 2.7:
fonction criblepnq :
L Ð r0..ns
Lr1s Ð 0
iÐ2
tant que i ď n :
j Ðiì
tant que j ď n :
Lrjs Ð 0
j Ðjì
iÐi`1
tant que i ă n et Lris “ 0 :
iÐi`1
M Ð rs
pour j de 0 jusqu’à n :
si Lrjs ‰ 0 :
M Ð M ` rLrjss
retourner M
Exercice 2.8:
fonction decomppnq :
Div Ð rs
P Ð criblepnq
pour j de 0 jusqu’à card pP q ´ 1 1 :
tant que n mod P rjs “ 0 :
Div Ð Div ` rP rjss
n Ð n{P rjs
retourner Div
1. card(P), c’est à dire cardinalité de l’ensemble P exprime, en mathématiques, le nombre d’éléments de

l’ensemble P . La commande SageMath correspondante est donc len(P).
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS IX
Exercice 2.9: decomp (168399)

|[3 , 3 , 3 , 3 , 3 , 3 , 3 , 7 , 11]
factor (168399)
|3^7 * 7 * 11
Exercice 2.10: is_prime (2027651281); factor (2027651281)

| False
|44021 * 46061
Pierre de Fermat a réussi à obtenir cette factorisation en 1643.
Ce résultat, qui est déjà impressionnant pour un ordinateur, l’est encore plus pour Fermat !
Exercice 2.11:
Cette fonction permet de déterminer les n premiers nombres premiers. Par exemple :
mystere (14)
|[2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 , 29 , 31 , 37 , 41 , 43]
Exercice 2.12:
Vous obtiendrez (par exemple) :
| Fer (0)=3 est premier

| Fer (5)=4294967297 n ’ est pas premier
| Fer ( 6 ) = 1 8 4 4 6 7 4 4 0 7 3 7 0 9 5 5 1 6 1 7 n ’ est pas premier
Actuellement, on ne connaît que 5 nombres de Fermat premiers, ceux cités ci-dessus p0 ď n ď 4q.
Un exemple possible de programmation SageMath :
def Fer ( n ):
for i in [0.. n ]:
k =2^(2^( i ))+1
if is_prime ( k ):
print " Fer ( " ,i , " )= " ,k , " est premier "
else :
print " Fer ( " ,i , " )= " ,k , " n ’ est pas premier "
X ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Exercice 2.13:
Vous obtiendrez (par exemple) :
| La conjecture de Pagnol est vraie pour 1

| La conjecture de Pagnol est fausse pour 9
def Pagnol ( n ):
for i in [0.. n ]:
impair =2* i +1
pagnol = impair +( impair +2)+ impair *( impair +2)
if is_prime ( pagnol ):
print " La conjecture de Pagnol est vraie pour " , impair
else :
print " La conjecture de Pagnol est fausse pour " , impair
Exercice 2.14:
Vous obtiendrez :
| p et p +100 premiers : [3 , 7 , 13 , 31 , 37 , 67 , 73 , 79 , 97]

|p , p +100 et p +200 premiers : liste vide
def possible ( n ):
L =[] , M =[]
for i in [2.. n ]:
if is_prime ( i ):
if is_prime ( i +100):
L = L +[ i ]
if is_prime ( i +200):
M = M +[ i ]
if len ( L )==0:
print " p et p +100 premiers : liste vide "
else :
print " p et p +100 premiers : " ,L
if len ( M )==0:
print "p , p +100 et p +200 premiers : liste vide "
else :
print "p , p +100 et p +200 premiers : " ,L
Exercice 2.15:
Je vous met au défi. . . Et si on faisait un petit concours. J’attends votre réponse par mail ;-)
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS XI
Exercice 2.16:
Voici quelques pistes de réponses proposées :
a) Liste des nombres de Mersenne premier inférieur à 100 :

mersennea (100)
| [2 , 3 , 5 , 7 , 13 , 17 , 31 , 61 , 89]
obtenue à l’aide de :
def mercennea ( n ):
liste =[]
for i in [1.. n ]:
if is_prime (2^ i -1):
liste = liste +[ i ]
return liste
b) On ne trouve effectivement pas de Mn premier pour n non premier :

mersenneb (1000)
| je n ’ en ai pas trouv é
obtenue à l’aide de :
def mercenneb ( n ):
for i in [1.. n ]:
if is_prime ( i )== False and is_prime (2^ i -1):
print " j ’ ai trouv é un contre exemple pour n = " ,i
print " je n ’ en ai pas trouv é "
c) Mn est premier ùñ n est premier.

d) M67 n’est pas premier. Par exemple
factor (2^(67) -1)
| 193707721 * 761838257287
e) Cette proposition est fausse. M67 en est un contre-exemple.

Sans aucune programmation, pouvez-vous exhiber d’autres contre-exemples ?
XII ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
A.3 Codage de César et congruence

Exercice d’intro :
‚ En 2009, le 6 décembre sera un dimanche et en 2010, un lundi. Sans tenir compte des années
bissextiles, on constate que
365 “ 7 ¨ 52 ` 1
Ainsi donc, la date du 6 décembre est décalée d’un jour par année.
‚ Les réponses se trouvent à la suite de la donnée.
‚ Il faut imaginer la partie « à l’envers ». Quelle doit être la configuration pour être sûr de
gagner au prochain coup ? et on remonte ainsi chronologiquement jusqu’à la position de
départ. (utilisez des allumettes pour vous convaincre de cette stratégie)
Exercice 3.1:
‚ Oui 17 ” 5 pmod 6q car 17 “ 2 ¨ 6 ` 5
5“0¨6`5
‚ Non 24 ı 14 pmod 6q car 24 “ 4 ¨ 6 ` 0
14 “ 2 ¨ 6 ` 2
Exercice 3.2:
Tous les entiers sont coloriés selon la séquence :
. . . – rouge – bleu – vert – rouge – bleu – vert – rouge – . . .
On partitionne ainsi les entiers en 3 familles :
t. . . , ´3, 0, 3, 6, . . . u ; t. . . , ´2, 1, 4, 7, . . . u ; t. . . , ´4, ´1, 2, 5, . . . u
Ce résultat se généralise quelque soit n l’entier modulo.
Exercice 3.3:
Par exemple, observons la situation modulo 3 :
… … 3(a …
0 1 2 3a 3a 3a 3(a 3(a +1
+0 +1 +2 +1
)+
+1
)+ )+
0 1 2
Lors d’une division par n, le reste de celle-ci est forcément un nombre compris entre 0 et n ´ 1.
Ainsi quelque soit le nombre choisit, il sera congru à un nombre entier compris entre 0 et n ´ 1.
Exercice 3.4:
a) Non car 80 “ 4 ¨ 17 ` 12 ñ 80 ” 12 pmod 17q
b) Non car 103 “ 6 ¨ 17 ` 1 ñ 103 ” 1 pmod 17q
c) Oui car ´29 “ ´2 ¨ 17 ` 5 ñ ´29 ” 5 pmod 17q
d) Non car ´122 “ ´8 ¨ 17 ` 14 ñ ´122 ” 14 pmod 17q
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS XIII
Exercice 3.5:
a) 1 b) 3 c) 2 d) 9
Exercice 3.6:
a) Il suffit de comparer 18ˆ(9)%7 avec 9ˆ(18)%7
b) Une fonction comme par exemple :
def equation ( n ):
for i in [0.. n ]:
if 18^( i )%7== i ^(18)%7:
print " n = " ,i , " verifie bien l ’ equation "
permet de se convaincre que n semble devoir être un multiple de 3, non multiple de 7.
Exercice 3.7:
WXTXRTXHPLILOL
“Toi aussi, mon fils !”, ou les derniers mots
de César mourant, criant à Brutus, qu’il
aimait comme son propre fils, sa
douloureuse surprise de le voir parmi ses
assassins : quoi de plus connu ? Si connu,
en fait, que nombre d’entre nous sont
encore capables de le dire en latin :
tu quoque, mi fili...
Dessin de John Leech dans :“The Comic History of Rome”
Exercice 3.8:
AVE CAESAR MORITURI TE SALUTANT
Exercice 3.9: def cesar ( message_clair ):

message_code =[]
ascii = ord ( lettre ) -65
ascii_crypt =( ascii +3)%26
lettre_crypt = chr ( ascii_crypt +65)
message_code = message_code +[ lettre_crypt ]
message_crypt = " " . join ( message_code )
return ( message_crypt )
XIV ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Exercice 3.10:
À l’aide de la fonction cesar, on obtient :
cesar ( " L E C H I F F R E M E N T E S T L A R T D E C O D E R U N M E S S A G E " )

| " OHFKLIIUHPHQWHVWODUWGHFRGHUXQPHVVDJH "
Exercice 3.11:
“Il est temps de passer à autre chose”
Exercice 3.12: def transl ( texte_clair , k ):

message_code =[]
for lettre in texte_clair :
ascii_crypt =( ascii + k )%26
Exercice 3.13:
“Les hommes croient en ce qu’ils désirent” (phase attribuée à César)
Exercice 3.14:
Pour résoudre cet exercice, vous avez deux possibilités : soit repérer les lettres les plus fréquentes,
qui correspondent aux lettres les plus fréquentes de la langue française (E, A puis S), soit tenter
une attaque exhaustive, c’est-à-dire essayer toutes les clés, ce qui n’est pas long ici, puisqu’il y
en a que 25. Vous obtiendrez pour la clé k “ 17 :
“J’aimerais mieux être le premier dans un village que le second à Rome” (phase attribuée à César)
Malgré (ou à cause de) sa simplicité, cette méthode de chiffrement fut encore employée par des officiers
sudistes pendant la guerre de Sécession et par l’armée russe en 1915.
Exercice 3.15:
a) Vrai car 471 – 11 = 460 qui est bien un multiple de 23.
b) Faux car 370 – 17 = 353 qui n’est pas un multiple de 13.
c) Vrai car 29 – (-121) = 150 qui est bien un multiple de 5.
d) Vrai.
e) Vrai. (cf. exercice 3.2)
f) Vrai, voici le début de la preuve que je vous laisse compléter :
*
a ” b pmod nq ðñ a “ k ¨ n ` . . .
ùñ a “ k ¨ n ` pk 1 ¨ . . . ` . . . q
b ” c pmod nq ðñ b “ k 1 ¨ . . . ` . . .
a “ p. . . ` . . . q ¨ n ` . . . ðñ a ” . . . pmod . . . q
g) Vrai dans les 2 cas, il s’agit d’effectuer deux preuves très semblables à celle de la question
précédente.
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS XV
Exercice 3.16:
a) 73 ` 231 525 ” 3 pmod 5q car :
73 ” 3 pmod 5q et 231 525 ” 0 pmod 5q
b) 212 ´ 414 ” 3 pmod 5q car :
212 ” 2 pmod 5q et 414 ” ´1 pmod 5q
c) 21 342 ¨ 59 ” 3 pmod 5q car :
21 342 ” 2 pmod 5q et 59 ” 4 pmod 5q
d) 26 ” 4 pmod 5q
e) 176 ” 26 pmod 5q ” 4 pmod 5q
Exercice 3.17:
a) 3527 ” 027 pmod 7q car 35 ” 0 pmod 7q ; le reste de la division par 7 est de 0.
b) 89 35
”135
pmod 11q car 89 ” 1 pmod 11q ; le reste de la division par 11 est de 1.
c) 7720 ” p´1q20 pmod 13q car 77 ” ´1 pmod 13q ; le reste de la division par 13 est de 1.
Exercice 3.18:
a) 35228 ` 84501 ” 1228 ` p´1q501 pmod 17q ” 0 pmod 17q
b) 2 ¨ 352009 ´ 3 ¨ 842010 ” 2 ¨ 12009 ´ 3 ¨ p´1q2010 pmod 17q
” 2 ´ 3 pmod 17q ” 16 pmod 17q
Exercice 3.19:
Le chiffre des unités d’un entier n est le reste de la division de n par 10.
41 5687 ” 87 pmod 10q
” 643 ¨ 8 pmod 10q
” 43 ¨ 8 pmod 10q
” 4 ¨ 8 pmod 10q
” 2 pmod 10q
Le chiffre des unités est donc 2. Efficace comme démarche. . . non ?
Exercice 3.20:
a) x ” 3 pmod 5q b) x ” 2 pmod 5q
Exercice 3.21:
l’inverse de 4 pmod 5q est 4 pmod 5q car 4 ¨ 4 “ 16 – 1 pmod 5q.
XVI ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Exercice 3.22:
Les tables de multiplications :
¨ 0 1 ¨ 0 1 2
0 0 0 0 0 0 0
1 0 1 1 0 1 2
2 0 2 1
¨ 0 1 2 3 ¨ 0 1 2 3 4 5
0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 2 3 1 0 1 2 3 4 5
2 0 2 0 2 2 0 2 4 0 2 4
3 0 3 2 1 3 0 3 0 3 0 3
4 0 4 2 0 4 2
5 0 5 4 3 2 1
Exercice 3.23:
1) a) x ” 0 pmod 3q b) x ” 2 pmod 4q c) x ” 4 pmod 6q
2) a) pas de solution b) pas de solution c) x ” 0 ou x ” 3 pmod 6q
3) si n “ 4 : ‚ 2 ¨ 2 ” 0 pmod 4q
si n “ 6 : ‚ 3 ¨ 2 ” 0 pmod 6q ‚ 2 ¨ 3 ” 0 pmod 6q
‚ 3 ¨ 4 ” 0 pmod 6q ‚ 4 ¨ 3 ” 0 pmod 6q
4) Il s’agit de la ligne 2 grisée, elle ne contient pas de 1 (inverse
0 1 2 3
modulo) et pas de 3.
¨
0 0 0 0 0
Pour n “ 6, les 3 lignes correspondantes à 2, 3 et 4 sont 1 0 1 2 3
également “incomplètes”. 2 0 2 0 2
Pour n “ 8, les lignes 2, 4 et 6 seront probablement 3 0 3 2 1
“incomplètes”.
Devinez-vous pourquoi ? Vérifiez-le en constituant le tableau.
5) a) x ” 3 pmod 4q b) pas d’inverse
c) x ” 5 pmod 6q d) pas d’inverse
Exercice 3.24:
¨ 0 1 2 3 4 5 6
1) Il s’agit de l’observer dans la table de multiplication 0 0 0 0 0 0 0 0
correspondante. 1 0 1 2 3 4 5 6
2 0 2 4 6 1 3 5
2) a) x ” 6 pmod 7q
3 0 3 6 2 5 1 4
b) x ” 0 pmod 7q 4 0 4 1 5 2 6 3
5 0 5 3 1 6 4 2
c) x ” 4 pmod 7q
6 0 6 5 4 3 2 1
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS XVII
Exercice 3.25:
3 est bien l’inverse de 6 modulo 17 car 6 ¨ 3 “ 18 ” 1 pmod 17q
6 ¨ x ” 9 pmod 17q 6 ¨ x ” 11 pmod 17q

3 ¨ 6 ¨ x ” 3 ¨ 9 pmod 17q 3 ¨ 6 ¨ x ” 3 ¨ 11 pmod 17q
1 ¨ x ” 27 pmod 17q 1 ¨ x ” 33 pmod 17q
x ” 10 pmod 17q x ” 16 pmod 17q
Exercice 3.26:
2) a) x ” 4 pmod 6q
b) x ” 3 pmod 6q Table d’addition :
` 0 1 2 3 4 5
3) Ce type d’équations se manipule “naturellement” par 0 0 1 2 3 4 5
une soustraction des deux côtés du égal. 1 1 2 3 4 5 0
2 2 3 4 5 0 1
3 3 4 5 0 1 2
4) a) x ” 3 pmod 6q 4 4 5 0 1 2 3
b) pas de solution 5 5 0 1 2 3 4
c) x ” 2 ou x ” 5 pmod 6q
XVIII ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
A.4 Codage affine, algorithmes d’Euclide et Bézout

Exercice 4.1:
En effet, Le chiffre correspondant à C est 2. Comme
2 ¨ 3 ` 5 ” 11 pmod 26q
ce dernier chiffre correspond bien à la lettre L.
Exercice 4.2:
a) Cette clé n’est pas bijective (one-to-one en anglais), c’est-à-dire qu’à 2 lettres différentes
(par exemple A et N) correspondent une unique lettre de codage (A). Comment pourra-t-on
alors définir la fonction réciproque permettant de revenir au message clair ?
b) Cette clé est bijective, il n’y a pas de risque d’ambiguïté dans la correspondance des lettres
en clairs et celles codées.
c) À nouveau, cette clé n’est pas bijective. À éviter donc. . .
d) Tableau de conversion :
en clair 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
codé 2 12 22 6 16 0 10 20 4 14 24 8 18 2 12 22 6 16 0 10 20 4 14 24 8 18
En SageMath, en considérant les clés b “ 0 et a variant de 1 à 26, on peut proposer
def tableau ( clefa ):

Liste =[]
for a in [1.. clefa ]:
for i in [0..25]:
Liste = Liste +[ a * i %26]
print " On obtient " , Liste , " pour a = " ,a
Liste =[]
e) a P t1 ; 3 ; 5 ; 7 ; 9 ; 11 ; 15 ; 17 ; 19 ; 21 ; 23 ; 25u. Contrairement aux autres, ces 12 nombres

n’ont pas de facteur commun avec 26.
f) Le nombre b agissant comme une translation, on peut toujours « revenir en arrière » par
une translation de ´b.
g) Il y a 12 possibilités de choix pour a et 26 pour b. Ceci donne donc 12 ¨ 26 “ 312
possibilités auxquelles il est judicieux d’enlever les clés a “ 1, b “ 0.
Exercice 4.3:
“DCFDODRGDFZG”
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS XIX
Exercice 4.4:
Une fonction possible :
def affine ( message_clair ,a , b ):

message_code =[]
ascii_crypt =( a * ascii + b )%26
Exercice 4.5:
“HVPWDGWINDOVKVIODIVNDHQTGWVDGVIXKXVIV”
Exercice 4.6:
Dans l’état de nos connaissances en programmation, il n’y a pas d’autres manières que de tenter
une attaque exhaustive (appelé aussi attaque par force brute) en testant les 12 ¨ 26 possibilités.
Il reste à trouver visuellement parmi les 312 résultats affichés, celui qui correspond à une phrase
cohérente.
Il s’agissait de la clé de déchiffrement a “ 3 et b “ 21 pour la phrase :
“BRAVOCENESTPASFACILE”
Une fonction SageMath possible :
def attaque ( message ):

for a in [1 ,3 ,5 ,7 ,9 ,11 ,15 ,17 ,19 ,21 ,23 ,25]:
for b in [0..25]:
print affine ( message ,a , b ) , " avec a = " ,a , " et b = " ,b
Cette fonction attaque appelle donc la fonction affine que vous avez programmé et utilisé dans
les exercices précédents.
Exercice 4.7:
a) 7 b) 13 c) 6 d) 15
Exercice 4.8:
a) Oui, car le PGDC(122, 49) = 1
b) Non car le PGDC(352, 33) = 11
Exercice 4.9:
PGDC(4539, 1958) = 89.
La méthode par décomposition en facteurs premiers montre déjà ici ses limites. Les calculs sont
relativement longs et fastidieux. La suite des éléments théoriques nous fournira un moyen beaucoup plus
élégant : L’algorithme d’Euclide.
XX ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Exercice 4.10:
a) 21 b) 167 c) 1 les nombres 1600 et 259 sont donc premiers entre eux.
Exercice 4.11:
Oui, car le PGDC(5617, 1515) = 1
Exercice 4.12: def reste (a , b ):

Liste =[]
reste = a % b
while reste < >0:
a=b
b = reste
Liste = Liste +[ reste ]
reste = a % b
Liste = Liste +[0]
return Liste
Exercice 4.13: def euclide (a , b ):

reste = a % b
while reste < >0:
quotient = a // b
reste = a % b
print a , " = " , quotient , " * " ,b , " + " , reste
a=b
b = reste
print " le PGDC vaut donc " ,a
Exercice 4.14:
Il s’agit d’une fonction récursive, c’est-à-dire qu’à l’intérieur de sa programmation, elle contient
un appel à elle-même. On obtient alors :
mystere (4539 ,1958)

|89
qui correspond au PGDC des 2 nombres. Programmé dans SageMath :
def mystere (a , b ):
if b ==0:
resultat = a
else :
r=a%b
resultat = mystere (b , r )
return ( resultat )
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS XXI
Exercice 4.15:
a) algorithme d’Euclide : 383 “ 3 ¨ 127 ` 2 (1)
127 “ 63 ¨ 2 ` 1 (2)
2“2¨1`0
Le dernier reste non nul vaut bien 1
‚ D’après l’égalité (2), on peut écrire : 1 “ 127 ´ 63 ¨ 2 (3)
‚ D’après l’égalité (1), on peut écrire : 2 “ 383 ´ 3 ¨ 127 que l’on substitue dans (3)
Ainsi 1 “ 127 ´ 63 ¨ p383 ´ 3 ¨ 127q “ ´63 ¨ 383 ` 190 ¨ 127.
On obtient alors : u “ ´63 et v “ 190.
b) Les valeurs proposées vérifient également 383u ` 127v “ 1.
c) Le couple pu , vq obtenu à l’aide de l’algorithme d’Euclide fournit une solution de l’équation,
mais cette solution n’est pas unique.
Exercice 4.16:
a) u “ 7 et v “ ´30
b) u “ ´9 et v “ 13 puis u1 “ ´9 ¨ 5 “ ´45 et v 1 “ 13 ¨ 5 “ 65
c) u “ 8 et v “ ´23
Exercice 4.17:
b) On utilise le même type de tableau que la partie a)
• Initialisation : 1534 “ 1 ¨ 1534 ` 0 ¨ 180 p1 ; 0q
180 “ 0 ¨ 1534 ` 1 ¨ 180 p0 ; 1q
Euclide Reste
• 1534 “ 8 ¨ 180 ` 94 94 “ 1534 ´ 8 ¨ 180 (1 ; 0q ´ 8p0 ; 1q p1 ; ´8q
• 180 “ 1 ¨ 94 ` 86 86 “ 180 ´ 1 ¨ 94 p0 ; 1q ´ 1p1 ; ´8q p´1 ; 9q
• 94 “ 1 ¨ 86 ` 8 8 “ 94 ´ 1 ¨ 86 p1 ; ´8q ´ 1p´1 ; 9q p2 ; ´17q
• 86 “ 10 ¨ 8 ` 6 6 “ 86 ´ 10 ¨ 8 p´1 ; 9q ´ 10p2 ; ´17q p´21 ; 179q
• 8“1¨6`2 2“8´1¨6 p2 ; ´17q ´ 1p´21 ; 179q p23 ; ´196q
• 6“3¨2`0 reste de zéro
Ainsi u “ 23 et v “ ´196
c) u “ ´20 et v “ 121
d) Voici une programmation SageMath. Mais ne le regardez pas trop vite. . . Le but est que
vous programmiez vous-même cette fonction !!
XXII ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
def bezout (a , b ):
U =[1 ,0]
V =[0 ,1]
i =1
reste = a % b
while reste < >0:
quotient = a // b
i = i +1
newu = U [i -2] - quotient * U [i -1]
newv = V [i -2] - quotient * V [i -1]
U = U +[ newu ]
V = V +[ newv ]
a=b
b = reste
reste = a % b
print " u = " ,U [ i ] , " et v = " ,V [ i ]
Exercice 4.18:
a) PGDC(322,17) = 1 p´1q ¨ 322 ` 19 ¨ 17 “ 1
b) PGDC(512,28) = 4 p´3q ¨ 512 ` 55 ¨ 28 “ 4
c) PGDC(1321,314) = 1 29 ¨ 1321 ` p´122q ¨ 314 “ 1
Exercice 4.19:
Soit P “ 2k l’équivalent numérique pair d’une première lettre et P 1 “ 2k 1 l’équivalent numérique
pair d’une deuxième lettre.
On obtient : C ” 13 ¨ p2kq ` b pmod 26q c’est-à-dire C ” b pmod 26q
Mais aussi : C 1 ” 13 ¨ p2k 1 q ` b pmod 26q c’est-à-dire C 1 ” b pmod 26q
Ces deux lettres seront donc codées de la même façon. Et ceci sera toujours vrai quelque soit le
choix de ces lettres à équivalent numérique pair.
Exercice 4.20:
a) Il suffit de montrer que a ¨ a1 ” 1 pmod 26q. Ce qui est bien le cas ici.
b) b1 “ á1 ¨ b “ ´19 ¨ 22 “ ´418 ” 24 pmod 26q
c) 11 ¨ 2 ` 22 “ 44 ” 18 pmod 26q
19 ¨ 18 ` 24 “ 366 ” 2 pmod 26q
Exercice 4.21:
a) a1 “ 11 et b1 “ 19
b) Il s’agit de la lettre I.
c) “IMUSTBEGONEANDLIVEORSTAYANDDIE”
Roméo et Juliette : Act 3, Scene 5 de William Shakespeare
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS XXIII
Exercice 4.22:
Il s’agit de :
“ETSIONNECONNAITPASLACLEF”
avec les clés a1 “ 17 et b1 “ 25.
Exercice 4.23:
Il s’agit de résoudre le système :
12 ” 4a ` b pmod 26q
#
6 ” 18a ` b pmod 26q
Vous obtiendrez les clés a “ 7 et b “ 10.
Exercice 4.24: Il s’agissait des clés de déchiffrement : a1 “ 19 et b1 “ 9.

Sur la tombe de Diophante, on pouvait lire :
Passant, c’est ici le tombeau de Diophante
C’est lui qui t’apprend le nombre d’années qu’il a vécu
Sa jeunesse en a occupé la sixième partie
Puis sa joue se couvrit d’un premier duvet pendant la douzième
Il passa encore le septième de sa vie avant de prendre une épouse
Diophante
et, cinq ans plus tard, il eut un bel enfant qui
d’Alexandrie
après avoir atteint la moitié de l’âge final de son père,
Mathématicien grec
périt d’une mort malheureuse
(200 – 284 env.)
Son père lui survécut quatre années
De tout ceci, déduis son âge
Pourrez-vous résoudre cette énigme célèbre, c’est-à-dire l’âge de sa mort ?

XXIV ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Exercice 4.25:
a) Au moins 9 fois (c’est-à-dire r17{2s ` 1)
b) Au moins rm{ns ` 1 fois
c)
def vigenere ( message , cle ):
message_code =[]
cle_code =[]
new_cle =[]
new_message =[]
# liste ascii du message

for lettre in message :
message_code = message_code +[ ascii ]
# liste ascii de la cle

for lettre in cle :
cle_code = cle_code +[ ascii ]
# adapter la taille de la cle

for i in [1..( len ( message_code )// len ( cle ))+1]:
new_cle = new_cle + cle_code
# ajouter les 2 listes et conv . en ascii

for i in [0.. len ( message_code ) -1]:
ascii =( message_code [ i ]+ new_cle [ i ])%26+65
new_message = new_message +[ chr ( ascii )]
# conversion en chaine de caracteres

Message_crypt = " " . join ( new_message )
return Message_crypt
Exercice 4.26:
Il suffit de remplacer un + par un – dans la fonction précédente.
Et si vous alliez directement faire un tour sur Ars Cryptographica :
www.apprendre-en-ligne.net/crypto
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS XXV
A.5 La cryptographie à clé publique : RSA

Exercice 5.1: def invmod (d , n ):
if gcd (d , n ) < >1:
return " doivent etre premiers entre eux !! "
else :
e =0; i =1
while e ==0:
if i * d % n ==1:
e=i
i = i +1
return ( e )
Exercice 5.2:
a) 8 b) 3336670
Exercice 5.3:
a) 69 car
5^51%97
|69
b) 7
c) Le calcul de 123456789ˆ987654321%11 risque bien de vous faire perdre patience. . ..
N’hésitez pas à l’interrompre avec le bouton : Stop
XXVI ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Exercice 5.4:
On peut proposer par exemple :
def controle (p ,q ,e , M ):
if is_prime ( p ) and is_prime ( q ):
print " p et q premiers : OUI "
else :
print " p et q premiers : NON "
n=p*q
print " n : " ,n
phi_n =( p -1)*( q -1)
print " phi ( n ): " , phi_n
if gcd (e , phi_n ):
print " e et phi ( n ) premiers entre eux : OUI "
else :
print " e et phi ( n ) premiers entre eux : NON "
d = inverse_mod (e , phi_n )
print " cl é priv é e : " ,d
M_prime = power_mod (M ,e , n )
print " message code : " , M_prime
new_M = power_mod ( M_prime ,d , n )
print " message decode : " , new_M
if new_M == M :
print " Tout est en ordre ; -) "
else :
print " Il y a comme un probleme : -/ "
qui fournira :
controle (9 760 95 975 11 111 120 41 886 431 , 834 55 239 986 78 341 25 649 111 1 ,
45879256903 ,12345678909876540106)
| p et q premiers : OUI
|n: 81460323853031154412157864943449033559900223014841
| phi ( n ): 8 1 4 6 0 3 2 3 8 5 3 0 3 1 1 5 4 4 1 2 1 5 7 8 4 6 8 3 6 9 6 5 2 8 3 7 7 0 4 4 6 9 2 4 6 3 7 3 0 0
| e et phi ( n ) premiers entre eux : OUI
| cl é priv é e : 6 1 4 2 4 9 3 1 6 5 1 8 6 6 1 7 1 4 5 0 2 6 7 5 8 9 9 9 2 1 8 0 1 7 5 6 1 2 1 6 7 4 7 5 7 4 0 1 6 7
| message code : 6 2 5 1 7 6 5 1 0 6 2 6 0 5 9 1 1 0 9 7 9 4 0 7 4 6 0 3 6 1 9 9 0 0 2 3 4 5 5 5 2 6 6 9 4 6 4 8 5
| message decode : 1 2 3 4 5 6 7 8 9 09 8 7 6 5 4 0 1 0 6
| Tout est en ordre ; -)}
Exercice 5.5:
a) M 1 ” M e pmod nq “ 8341481710297804401
b) pM 1 qd pmod nq “ 12345678909876540106. (Ok ! !)
ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS XXVII
Exercice 5.6:
‚ p “ 11, q “ 23, ϕpnq “ 220, d “ 147
‚ 214147 ” 14 pmod 253q Ñ O

‚ 157147 ” 20 pmod 253q Ñ U
‚ 6147 ” 8 pmod 253q Ñ I
Exercice 5.7:
a) 1420083 ” 124 pmod 253q. La clé d, obtenue dans l’exercice précédent étant de 147, on
obtient : 124147 ” 75 pmod 253q qui ne correspond pas à ce qui est attendu !
b) On obtient les valeurs suivantes :
‚ n “ 5147 ¨ 7351 “ 37835597 ;
‚ ϕpnq “ 5146 ¨ 7350 “ 37823100 ;
‚ PGDC(37823100 ; 307) = 1 ;
‚ 142008307 ” 36481808 pmod 37835597q.
c) d “ 34743043 est l’inverse de e modulo ϕpnq et on obtient :
3648180834743043 ” 142008 pmod 37835597q.
Exercice 5.8:
a) Il s’agit de 1377 1565 508 1913
JE TA IM EA
M 238 494 220 104
M 1 “ M 19 pmod 2077q 1377 1565 508 1913
b) En factorisant 2077, on obtient p “ 31 et q “ 67 donc ϕpnq “ 1980 et finalement d “ 1459.
M1 3 261 833
M “ pM 1 q1459 pmod 2077q 43 21 364
1 ¨ 26 ` 17 0 ¨ 26 ` 21 14 ¨ 26 ` 0
BR AV O(A)
BRAVO !!
Exercice 5.9:
Pas de corrigé.
Exercice 5.10:
Votre moyenne est 5 car :
p “ 5, q “ 11, ϕpnq “ 40, d “ 23 et finalement 2523 ” 5 pmod 55q.

XXVIII ANNEXE A. QUELQUES ÉLÉMENTS DE SOLUTIONS
Exercice 5.11:
a) 42510 b) 901910 c) 12410
d) 252210 e) 195810
Exercice 5.12:
a) 111111112 b) 1107 c) 158A11
Exercice 5.13:
a) 1010002 b) 207
Exercice 5.14:
Pas de réponse proposée
Exercice 5.15:
a) OUI26 b) 916510
Exercice 5.16:
a) 2110123 ðñ 59910 b) 110111012 ðñ 22110
c) B2612 ðñ 161410 d) 119911 ðñ 156010
Si vous souhaitez commander ou utiliser ce polycopié dans vos
classes, merci de prendre contact avec son auteur en passant par
son site web :
www.javmath.ch
Quelques éléments de cryptographie (07 . 2018) CADEV - no 30’077

Langue

OCCrypto

Transféré par

Informations du document

Description :

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

OCCrypto

Transféré par

Description :

Droits d'auteur :

Quelques éléments de

1 Un doigt d’algorithmique, intro à SageMath 1

3 Chiffrement de César et congruence 25

4 Chiffrement affine, algorithmes d’Euclide et Bézout 41

5 La cryptographie à clé publique : RSA 57

A Quelques éléments de solutions I

Introduction: Un algorithme est un moyen pour un humain de présenter la réso-

Projet: Concevoir un programme permettant de calculer le résultat du

Avant de transcrire ce pseudo-code sur SageMath, il est important

Remarque: Vous avez constaté que SageMath a respecté automatiquement l’in-

1.2 Variables et listes

‚ Elle peut être du type chaîne de caractères (string) :

‚ Elle peut être du type liste :

‚ Elle peut être du type booléen :

1.2.1 Opérations sur les variables du type nombre

On peut également proposer cette opération sous la forme d’une

Celle-ci permet de calculer puis de retourner (Return n) le succes-

Exercice 1.3 Traduire le pseudo-code précédent en une fonction SageMath afin

Exercice 1.4 Voici un pseudo-code :

a) Tester ce pseudo-code “à la main” en utilisant les couples de

Remarque: Dans l’exercice précédent, la fonction mystere(a,b) admet 2 valeurs

1.2.2 Opérations sur les variables du type liste

‚ On accède à un élément d’une liste au moyen de son index. L’in-

‚ La taille d’une liste s’obtient avec la commande len :

‚ Voici deux petits algorithmes permettant de parcourir une liste

‚ Pour ajouter un élément en queue de liste, par exemple 12 :

‚ Pour fusionner (concaténer) deux listes, on utilise une démarche

1.2.3 Opérations sur les variables du type string

1.3 Les boucles for. . . ou while. . .

Exercice 1.5 a) Créer la liste L1 des nombres compris entre -3 et 3.

Exercice 1.6 a) Proposer le pseudo-code de cette dernière programmation.

Exercice 1.7 On considère le pseudo-code suivant :

a) De quel algorithme s’agit-il ? Quel nombre obtient-on en tes-

Exercice 1.8 On considère le pseudo-code suivant :

a) De quel algorithme s’agit-il ?

Remarque: Les deux nombres obtenus précédemment joueront un rôle très

1.4 Les conditions : if. . . ou if. . . else. . .

if une condition : if une condition :

Le formalisme des conditions seront identiques à celles utilisées pour

Pseudo-code Code Sagemath

1.5 Affichage avancé

Exercice 1.9 Pour la réalisation du graphe de la fonction f définie par

1.6 Une fonction qui en appelle une autre

La deuxième démarche est beaucoup plus élégante, car elle permettra

En utilisant les 2 fonctions successeur(n) et factorielle(n) croisées

Exercice 1.10 a) Recopier et valider la fonction factorielle(n) proposée ci-dessus.

c) Que permet de calculer cette fonction ?

En code fractionnaire : ou en code à virgule 1 :

Indication : - la fonction correspondant à la racine est sqrt(. . .).

Exercice 1.12 On considère le pseudo-code suivant :

a) Programmer cette fonction facto et contrôler que vous obtenez

b) En quoi l’algorithme de cette dernière fonction peut paraître

1.7 Pour aller un peu plus loin

La suite de Syracuse: Cette suite de nombre ressemble à un jeu de calcul. On prend

La conjecture affirme que, quel que soit le terme initial N de

Sous son apparente simplicité, elle défie encore les mathématiciens

b) Proposer deuxième fonction suitesyra(n) qui permet de créer une

c) En utilisant, par exemple, la commande while, vérifier la conjec-

Proposition: Tout entier naturel n admet au moins un diviseur premier.

Théorème: Il y a une infinité de nombres premiers.

Preuve: Raisonnons par l’absurde et supposons qu’il existe exactement n

Donc p “ 1 ce qui est absurde puisqu’il est premier. Ainsi, cette

Quelques records: ‚ Le 4 février 2005, Martin Nowak a battu le record du plus