[projet ISN] chiffrement de vigénère Résolu/Fermé

Question

on doit rendre ce projet à la fin de l'année, j'ai commencé a faire ça mais je sais pas quoi faire après. Notre pros était sensé nous aider mais avec le confinement ça va être compliqué.

def genere_cle_vigenere(msg_clair: str, cle_vig: str) -> str:
    '''
    fonction renvoyant la clé de vigenère rallongée
    param msg_clair : message
    param cle_vig : clé
    return : la clé rallongée
    '''
    long_msg_clair = len(msg_clair)
    if len(cle_vig)>= long_msg_clair:
        return cle_vig[:long_msg_clair]
    else:
        res = cle_vig
        i = 0
        while len(res)<long_msg_clair:
            res = res + cle_vig[i%3]
            i = i + 1
        return res

ALPHABET = '0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def crypte_lettre_vig(car_clair: str, car_cle_vig: str) -> str:
    '''
    fonction renvoyant le caractère de vigenère
    param car_clair: un caractère du msg_clair
    param car_cle_vig: le caractère de la cle_vig associé
    return: le caractère de vigenère
    '''
    
    return ALPHABET[(ALPHABET.index(car_clair.upper()) + ALPHABET.index(car_cle_vig.upper())) % 37]

'''msg_clair -> msg_vigenere -> msg_transpo'''

print(genere_cle_vigenere('bonjour', 'riz'))
print(genere_cle_vigenere('bon', 'riz'))

print(crypte_lettre_vig('J', 'R'))

Phil_1857 · Accepted Answer

Je te renvoie le programme, car il y avait une erreur dans la fonction
genere_cle_vigenere
En effet il faut écrire cle = cle + cle_vig[i%len(cle_vig)] et non pas
cle = cle + cle_vig[i%3]
sinon, ca ne marche pas pour n'importe quelle longueur de clé !
Et le codage Vigenère est maintenant dans une fonction

# -*- coding:Latin-1 -*-

ALPHABET = '0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ'
CLE_SECRETE = 'LOLA'

def genere_cle_vigenere(msg_clair: str, cle_vig: str) -> str: 
	''' 
	Renvoie la clé vigenère ajustée à la longueur du message clair
	'''

if (len(cle_vig) >= len(msg_clair)):
		cle = cle_vig[:len(msg_clair)]
	else:
		cle = cle_vig
		i = 0
		while(len(cle) < len(msg_clair)):
			cle = cle + cle_vig[i%len(cle_vig)]
			i += 1

return cle

def codage_vigenere(message_clair, cle):
	''' Codage du message clair avec la cle'''

message_code = ''

for k in range (len(message_clair)):
		try:
			message_code += ALPHABET[(ALPHABET.index(message_clair[k])+ALPHABET.index(cle[k]))%len(ALPHABET)]
		except:
			print('
Erreur {} inexistant dans ALPHABET: {}'.format(message_clair[k], ALPHABET))

return message_code

#Saisie du message
print('
')
print('''Codage d'un message'''.center(50,'*'))
message_clair = input('
Entrez le message à coder : ')

#L'alphabet est en majuscules, donc le message doit l'etre aussi
message_clair = message_clair.upper()

#Longueur de la clé = longueur du message clair
cle = genere_cle_vigenere(message_clair, CLE_SECRETE)

#Codage
message_code = codage_vigenere(message_clair, cle)
print('>>> ', message_code)

input('

Appuyer sur enter pour quitter ...')

Phil_1857 · Answer

Bonjour lola_2015,

Ca devrait ressembler à çà, non? :

# -*- coding:Latin-1 -*-

ALPHABET = '0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ'
CLE_SECRETE = 'LOLA'

def genere_cle_vigenere(msg_clair: str, cle_vig: str) -> str: 
	''' 
	Renvoie la clé vigenère ajustée à la longueur du message clair
	'''

if (len(cle_vig) >= len(msg_clair)):
		cle = cle_vig[:len(msg_clair)]
	else:
		cle = cle_vig
		i = 0
		while(len(cle) < len(msg_clair)):
			cle = cle + cle_vig[i%3]
			i += 1

return cle

#Saisie du message
print('
')
print('''Codage d'un message'''.center(50,'*'))
message_clair = input('
Entrez le message à coder : ')

#L'alphabet est en majuscules, donc le message doit l'etre aussi
message_clair = message_clair.upper()

#Longueur de la clé = longueur du message clair
cle = genere_cle_vigenere(message_clair, CLE_SECRETE)

#Codage
for k in range (len(message_clair)):
	try:
		print(ALPHABET[(ALPHABET.index(message_clair[k])+ALPHABET.index(cle[k]))%len(ALPHABET)], end = '')
	except:
		print('
Erreur -> {} inexistant dans ALPHABET: {}'.format(message_clair[k], ALPHABET))

input('

Appuyer sur enter pour quitter ...')


A part çà, tu as du taper un peu rapidement, mais je suppose que tu voulais écrire

"Notre prof était censé" et non pas "Notre pros était sensé"

(bien que je ne doute pas un seul instant que le prof en question ne soit également sensé :-) )

Phil_1857 · Answer

Bonjour lola_2015,

1) La fonction pour la longueur de la clé, on l'a déjà:
def genere_cle_vigenere(msg_clair: str, cle_vig: str) -> str: 

2) Pour attribuer un chiffre aux lettres, on le fait dans l'instruction suivante:
print(ALPHABET[(ALPHABET.index(message_clair[k])+ALPHABET.index(cle[k]))%len(ALPHABET)], end = '')

ALPHABET.index(message_clair[k]) renvoie la position de la k ieme lettre du message clair dans ALPHABET, par exemple, si la lettre est A çà renvoie 11

3) La fonction pour le codage Vigenère: je n'ai pas mis çà dans une fonction, mais on peut le faire aussi, le codage on le fait ici:

for k in range (len(message_clair)):
	try:
		print(ALPHABET[(ALPHABET.index(message_clair[k])+ALPHABET.index(cle[k]))%len(ALPHABET)], end = '')
	except:
		print('
Erreur -> {} inexistant dans ALPHABET: {}'.format(message_clair[k], ALPHABET))


As-tu récupéré mon programme et l'as-tu testé ?
 il fonctionne et répond bien au problème posé
On entre un message en clair et il renvoie le message codé avec la CLE_SECRETE = 'LOLA'
Cà donne çà:


Est-ce qu'il te manque encore quelque chose ?
y-a-t-il des choses que tu ne comprends pas ?
Dis-moi tout

Phil_1857 · Answer

OK,

Par contre la transposition rectangulaire, je ne connais pas du tout …

Phil_1857 · Answer

Oui, on fait l'inverse, il faut soustraire les index au lieu d'additionner :

Puisque l'index d'une lettre codée dans ALPHABET = index lettre du clair + index lettre de la cle :

message_code += ALPHABET[(ALPHABET.index(message_clair[k])+ALPHABET.index(cle[k]))%len(ALPHABET)]

pour retrouver l'index du clair, il faut donc faire index du codé - index de la cle

Donc faire une fonction similaire à codage_vigenere  :  decodage_vigenere, qui reçoit en arguments le message codé (mis en majuscule)  et la cle (calculée avec genere_cle_vigenere)
et faire et remplacer l'instruction ci-dessus par:

message_clair += ALPHABET[(ALPHABET.index(message_code[k])-ALPHABET.index(cle[k]))%len(ALPHABET)]

à la place de message_code+= ……..

(si tu fais un copié/collé de codage_vigenere, n'oublie pas de remplacer message_clair par message_code et in versement :-) )

Phil_1857 · Answer

Bonjour lola_2015,

a += 1, c'est un raccourci pour a = a + 1

un dictionnaire, c'est un genre de liste avec des clés pour accéder directement aux éléments:

mon_dico = {'nom':'toto', 'age', '20'}

print(mon_dico['nom'])   #affiche toto

#les cles et les valeurs ne sont pas forcément de chaines de caractères:
mon_dico = {0:10, 1:20}
print(mon_dico[0])


Il y a plein de docs à ce sujet sur le net   :-)

Phil_1857 · Answer

Bonjour lola_2015,

pourquoi me demandes-tu çà ?

Sinon, as-tu vu ma dernière réponse du 29 à 18h40 : le programme Vigenère réécrit avec les dictionnaires ?

Et ma réponse dans l'autre demande à propos des transpositions rectangulaires ?

Phil_1857 · Answer

Pas de problème !

C'est toujours un plaisir de t'aider   :-)

[projet ISN] chiffrement de vigénère

8 réponses

Discussions similaires