Skip to content
Extraits de code Groupes Projets
Valider 2a1d3a2e rédigé par Yannick Chistel's avatar Yannick Chistel
Parcourir les fichiers

correction coquilles code vigenere

parent d0b705b5
Aucune branche associée trouvée
Aucune étiquette associée trouvée
Aucune requête de fusion associée trouvée
Pipeline #86562 réussi
Stage: build
Stage: deploy
Masquer les modifications d'espaces
En ligne Côte à côte
source/content/code_vigenere.rst
+ 2
− 2
Voir le fichier @ 2a1d3a2e
......@@ -40,7 +40,7 @@ La classe ``CodeVigenere`` construit un objet avec les attributs ``cle`` qui con
self.alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ "
#. Ajouter cette classe dans un notebook ou un fichier Python.
#. On souhaite ajouter une méthode ``chiffrer`` qui prend en paramètre un message écrit avec les caractères de ``alphabet`` et qui renvoie le message chiffrer.
#. On souhaite ajouter une méthode ``chiffrer`` qui prend en paramètre un message écrit avec les caractères de ``alphabet`` et qui renvoie le message chiffré.
Par exemple, on crée un objet ``CodeVigenere`` avec la clé de chiffrement ``NSI``. On chiffre le message ``BONJOUR``. On donne ci-après les instructions Python :
......@@ -53,7 +53,7 @@ La classe ``CodeVigenere`` construit un objet avec les attributs ``cle`` qui con
.. note::
On peut ajouter dans la classe le code de la méthode ``decaler`` écrite pour la classe ``CodeCesar`` et l'utiliser pour effectueur les différents décalage.
On peut ajouter dans la classe le code de la méthode ``decaler`` écrite pour la classe ``CodeCesar`` et l'utiliser pour effectuer les différents décalages.
#. Écrire le code de la méthode ``dechiffrer`` qui prend en paramètre un message chiffré et qui renvoie le message initial avant le chiffrement.
......
source/nb/exercice cryptographie symétrique.ipynb 0 → 100644
+ 2
− 0
Voir le fichier @ 2a1d3a2e
%% Cell type:markdown id: tags:
# Exercice 1
1. Calculer en Python 154^45. Expliquer la valeur obtenue.
%% Cell type:code id: tags:
``` python
154^45
```
%% Output
%% Cell type:markdown id: tags:
On a donc 154^45=183. Pour expliquer ce résultat, il faut convertir chaque nombre en binaire:
- $154 = 128+16+8+2$ donc $154_{10} = 10011010_{2}$
- $45 = 32+8+4+1$ donc $45_{10} = 10011010_{2}$
En posant l'opération logique bit à bit: $10011010 \oplus 10011010 = 10110111$
En effectuant une conversion en base 10, on obtient : $128+32+16+4+2+1=183$
%% Cell type:markdown id: tags:
2. Calculer en Python A'^z. Expliquer la valeur obtenue.
Avant le calcul, on doit procéder à la conversion décimale des caractère correspondant à leur écriture en binaire. Pour retrouver la valeur décimale d'un caractère, on utilise la fonction `ord` de python.
- 'A' s'écrit sur 1 octet et dans la table ASCII, on a la valeur décimale : ord('A')=65
- 'z' s'écrit sur 1 octet et dans la table ASCII, on a la valeur décimale : ord('z')=122
Ensuite, on calcule 65^122 = 59
Pour retrouver le caractère associé à la valeur décimale 59, on utilise la fonction `chr` de Python. Finalement, on obtient le caratère point-virgule.
%% Cell type:code id: tags:
``` python
chr(ord('A')^ord('z'))
```
%% Output
';'
%% Cell type:markdown id: tags:
Exercice 2
--------
1. Écrire la fonction `chiffrer(msg,cle)` qui a 2 paramètres, `msg` une chaine de caractères qui est le message à chiffrer et `cle` qui est la clef de chiffrement. Cette fonction renvoie une chaine de caractères correspondant au mot chiffré avec l’opérateur XOR.
Si la clef de chiffrement est plus courte que le message à chiffrer, celle-ci est répétée jusqu'à la fin du message.
2. Chiffrer le message `BONJOUR` avec la clef de chiffrement `12xy`.
3. Déchiffrer votre message chiffré et vérifier qu’on obtient bien le message initial.
%% Cell type:code id: tags:
``` python
def chiffrer(msg,cle):
msg_chiffre = ''
for i in range(len(msg)):
k = i % len(cle)
msg_chiffre += chr(ord(msg[i])^ord(cle[k]))
return msg_chiffre
m = chiffrer('BONJOUR LE MONDE','12xy')
print(m)
m = chiffrer(m,'12xy')
print(m)
```
%% Output
s}63~g*Y}wX4~|<<
BONJOUR LE MONDE
%% Cell type:code id: tags:
``` python
chiffrer('NSI','123')
```
%% Output
'\x7faz'
%% Cell type:code id: tags:
``` python
chr(ord('N')^ord('1'))
```
%% Output
'\x7f'
%% Cell type:code id: tags:
``` python
chr(ord('S')^ord('2'))
```
%% Output
'a'
%% Cell type:code id: tags:
``` python
chr(ord('I')^ord('3'))
```
%% Output
'z'
%% Cell type:markdown id: tags:
Exercice 3
--------
On peut écrire un programme qui met en place les conditions du chiffrement de Vernam.
On convertira les chaines de caractères en binaire avec la fonction bytes. Cette fonction a 2 paramètres :
- Le premier paramètre est la chaine de caractères constituant le message à convertir en binaire.
- Le second paramètre est l’encodage à utiliser.
**Exemples :**
- bytes(’bonjour’,’utf8’) donne b’bonjour’
- bytes(’bonjour’,’latin1’) donne b’bonjour’
- bytes(’lycée’,’utf8’) donne b’lyc\xc3\xa9e’
- bytes(’lycée’,’latin1’) donne b’lyc\xe9e’
1) Pourquoi y a-t-il une différence en convertissant le mot lycée et pas pour le mot bonjour ?
2) Écrire la fonction cle_alea qui prend en paramètre une longueur de message et renvoie une clé de chiffrement
constitué de caractères imprimables choisis au hasard dans la table ASCII.
3) Écrire la fonction chiffrer(msg,cle) qui a 2 paramètres, msg une chaine de caractères qui est le message à
chiffrer et cle qui est la clef de chiffrement. Cette fonction renvoie la chaine de caractères correspondant
au message chiffré avec l’opérateur XOR et la clé de chiffrement utilisée. Cette fonction suit l’algorithme
suivant :
- On crée une chaine binaire vide renvoyée par la fonction ;
- On convertit en binaire le message à chiffre ;
- On crée une clé de chiffrement aléatoire de même longueur que le message convertie en binaire ;
- Avec une boucle, on parcourt le message binaire et on lui applique le XOR avec la clé. Le résultat est
concaténé à la chaine binaire à renvoyer ;
- On finit en renvoyant le message chiffré et la clé de chiffrement.
4) La fonction dechiffrer(msg,cle) a deux paramètres :
- Le message chiffré msg
- La clé de chiffrement utilisée pour chiffre le message.
Cette fonction renvoie le message chiffré en clair.
Écrire le code python de cette fonction.
5) Chiffrer le message ’La cryptographie symétrique est fantastique’. Vérifier ensuite que vous pouvez le déchiffrer.
6) Recommencer avec un message contenant des caractères spéciaux et accentués.
7) Que remarquez-vous si on utilise l’encodage UTF8 ?
%% Cell type:code id: tags:
``` python
from random import randint
def cle_alea(longueur):
cle = ''
for i in range(longueur):
cle += chr(randint(33,127))
return cle
def chiffrer(message):
msg_chiffre = b''
msg = bytes(message,'latin1')
cle = bytes(cle_alea(len(msg)),'latin1')
for i in range(len(msg)):
msg_chiffre += bytes(chr((msg[i]^cle[i])),'latin1')
return (msg_chiffre,cle)
def dechiffrer(msg,key):
msg_clair = ''
for i in range(len(msg)):
msg_clair += chr(msg[i]^key[i])
return msg_clair
m,k = chiffrer("La cryptographie est symétrique puisque la clé utilisée est la même pour chiffrer et déchiffrer")
print(m)
msg = dechiffrer(m,k)
print(msg)
```
%% Output
b'm&I\\\x10.6=\x00%8&,Z\'6h;5N\x13\x1cU.\xbe\x04U",\x01\\^V+VL8I S":\x06W4\xd2z\r\x1a_\x01[$\x9e,Q\x06/G^H<u \xcfD\x1a\x1e"&E)\x0b\x1e\x06>ICT;"s.2i+\xdc<Y\x01<9@7V'
La cryptographie est symétrique puisque la clé utilisée est la même pour chiffrer et déchiffrer
%% Cell type:code id: tags:
``` python
m = bytes('bonjour','utf8')
c = bytes(cle_alea(len('bonjour')),'utf8')
print(m,c)
```
%% Output
b'bonjour' b'OGOP)YX'
%% Cell type:code id: tags:
``` python
e = b''
for i in range(len(m)):
e += bytes(chr(m[i]^c[i]),'utf8')
print(e)
```
%% Output
b'-(!:F,*'
0% ou .
You are about to add 0 people to the discussion. Proceed with caution.
Terminez d'abord l'édition de ce message.
Veuillez vous inscrire ou vous pour commenter