[Challenge] Petite idée pour un codage/décodage Vigenère

[DenisHen]

Bonjour à la communauté.
Je suis tombé par hazard sur le codage Vigenère dans Wikipédia et j'ai tout de suite pensé à un petit chalenge pour les membres du Lisp/VLisp.
Le but est simple, grace à une seule commande, coder ou décoder une chaine.
Exemple : 

;;Codage
(setq ChaineACoder (Vigenere "C" Chaine$))
;;Décodage
(setq ChaineDecodee (Vigenere "D" Chaine$))

Je pense aux 255 caractères usuels (sauf les 32 premiers, qui ne sont pas réellement des caractères).
Le résultat du codage pourra se faire avec une ou deux clefs.
Amusez-vous bien, si vous le désirez...
Bien à toi, la communauté.
Denis...

[(gile)]

Salut,

J'ai quelques soucis avec l’énoncé.

1. La fonction Vigenere devrait prendre aussi la clé en argument.
2. Je ne comprends pas : "Je pense aux 255 caractères usuels", dans la page Wikipedia en lien seules les lettres non accentuées sont chiffrées, les autres caractères (apostrophe et espace) ne sont pas encryptés. Par contre, on pourrait respecter la casse.
3. Je ne comprends pas non plus : "une ou deux clefs", dans la page Wikipedia en lien il n'est question que d'une clé.

[VDH-Bruno]

il y a 48 minutes, (gile) a dit :

Salut,

J'ai quelques soucis avec l’énoncé.

1. La fonction Vigenere devrait prendre aussi la clé en argument.
2. Je ne comprends pas : "Je pense aux 255 caractères usuels", dans la page Wikipedia en lien seules les lettres sont chiffrées, les autre caractères (apostrophe et espace) ne sont pas encryptés. Par contre, on pourrait respecter la casse.
3. Je ne comprends pas non plus : "une ou deux clefs", dans la page Wikipedia en lien il n'est question que d'une clé.

Bonjour,

Historiquement le codage/décodage Vigenère dont la table était constitué des 26 caractères alphabétiques, ne tient pas compte de la casse, ni des caractères spéciaux. Le codage étant initialement basé sur une clef, l'introduction d'une seconde clef est le résultat de variantes survenue par la suite.

Edit: Oup's corrigé le lapsus 256 par 26😉

[didier]

Bonjour

J'y ai pensé et j'ai réfléchi, comme quoi tout arrive !
Sans doute vais-je proposer quelque chose si j'arrive à trouver le temps de finaliser.

Je me suis posé la même question que vous sur les 255 caractères.
Pour les espaces, je pense qu'on peut les laisser, pour les accents et autres signes diacritiques, je laisse tomber pour l'instant.

Pour les clés, on peut lancer deux fois le chiffrage avec deux clés différentes, une fois chiffrer avec la clé1 et chiffrer le chiffrage avec la clé2 pour se dédouaner de la reconnaissance des séquences d'apparitions de lettres communes.

Amicalement

[(gile)]

J'attends un peu pour poster ma réponse (chiffrage des 26 caractères alphabétiques non accentués uniquement avec respect de la casse).

[DenisHen]

Bonjour à la communauté.
Je pensais que les 26 caractères ne dépendaient que d'une table par défaut que l'on pouvait "personnaliser" et de ce fait, y ajouter d'autres caractères.

[VDH-Bruno]

Perso je me suis déjà confronté à l'exercice par le passé, ne retrouvant pas mes codes, je retaperais ces quelques lignes quand j'aurais un AutoCAD sous la main...

[(gile)]

il y a une heure, DenisHen a dit :

Bonjour à la communauté.
Je pensais que les 26 caractères ne dépendaient que d'une table par défaut que l'on pouvait "personnaliser" et de ce fait, y ajouter d'autres caractères.

Si on considère une table de 255x255, le code est bien plus simple à mettre en place, mais pour vérifier les résultats "à la main", ça va être plus compliqué...

[DenisHen]

Oui, effectivement @(gile), mais c'est 255-32, si qui n'allège pas beaucoup la vérification "à la main", j'en conviens... 😉 

[didier]

??????????

[VDH-Bruno]

Bonjour,

Très rapidement étant en temps limité...

Le 28/11/2022 à 16:22, VDH-Bruno a dit :

Perso je me suis déjà confronté à l'exercice par le passé, ne retrouvant pas mes codes, je retaperais ces quelques lignes quand j'aurais un AutoCAD sous la main...

J'ai retapé ma version de l'époque basé sur l'intégralité de la table de code ASCII, très proche de l'algorithme décrit dans la page Wikipédia:

(defun vigenere_ASCII (text key mode / i lgkey)
  
  (setq	i     -1
	mode  (if mode + -)
	key   (vl-string->list key)
	lgkey (length key)
  )

  (vl-list->string
    (mapcar '(lambda (x) (setq i (1+ i)) (rem (+ 256 (mode x (nth (rem i lgkey) key))) 256))
	    (vl-string->list text)
    )
  )
)

Pour tester:

_$ (vigenere_ASCII  "J'adore écoute la radio toute la journée" "MUSIQUE" T)
"—|´­ÀǪm>¶¸ÆɪmÁ´iö©¶Äs½Àʹ²u¿ªq¿´ÂÇÁ2¶"
_$ (vigenere_ASCII  "—|´­ÀǪm>¶¸ÆɪmÁ´iö©¶Äs½Àʹ²u¿ªq¿´ÂÇÁ2¶" "MUSIQUE" nil)
"J'adore écoute la radio toute la journée"

Code que j'ai rapidement adapté pour la demande suivant, sans chercher à plus...

Le 28/11/2022 à 15:34, (gile) a dit :

J'attends un peu pour poster ma réponse (chiffrage des 26 caractères alphabétiques non accentués uniquement avec respect de la casse).

Code:

(defun vigenere_26 (text key mode / i lgkey)

  (setq	i     -1
	mode  (if mode + -)
	key   (vl-string->list (strcase key))
	lgkey (length key)
  )

  (vl-list->string
    (mapcar
      '(lambda (x)
	 (cond
	   ((< 64 x 91)
	    (+ (rem
		 (+ 26
		    (mode (- x 65)
			  (- (nth (rem (setq i (1+ i)) lgkey) key) 65)
		    )
		 )
		 26
	       )
	       65
	    )
	   )

	   ((< 96 x 123)
	    (+ (rem
		 (+ 26
		    (mode (- x 97)
			  (- (nth (rem (setq i (1+ i)) lgkey) key) 65)
		    )
		 )
		 26
	       )
	       97
	    )
	   )
	   (T x)
	 )
       )
      (vl-string->list text)
    )
  )
)

Pour tester:

$ (vigenere_26  "J'adore ecouter la radio toute la journee" "MUSIQUE" T)
"V'uvwhy ioimbul pm lslyi xaolm bu naojvuy"
_$ (vigenere_26  "V'uvwhy ioimbul pm lslyi xaolm bu naojvuy" "MUSIQUE" nil)
"J'adore ecouter la radio toute la journee"

(Ps: De mémoire j'avais une autre variante basé sur la création d'une table d'association, un peu plus fastidieuse à réécrire... que de passer par un calcul arithmétique.)

A+ Bruno

[(gile)]

Comme l'énoncé n'est pas très clair, j'ai essayé de faire quelque chose de générique en ajoutant comme argument la liste des caractères à chiffrer.

La fonction de base :

;;; vigenere
;;; Fonction générique de chiffrement/déchiffrement
;;; Utilise le chiffre de Vigenère avec l'alphabet spécifié
;;;
;;; Arguments
;;; op    : opération à effectuer (+ pour le chiffrement, - pour le déchiffrement)
;;; chars : alphabet utilisé (liste de codes ascii des caractères à chiffrer)
;;; str   : chaîne à chiffrer
;;; key   : clé de chiffrement
(defun vigenere	(op chars str key / ks lks lcs i)
  (setq	ks  (mapcar '(lambda (c) (vl-position c chars))
		    (vl-string->list key)
	    )
	lks (length ks)
	lcs (length chars)
	i   0
  )
  (vl-list->string
    (mapcar
      '(lambda (c / n m)
	 (cond
	   ((null (setq n (vl-position c chars))) c)
	   ((null (setq m (nth i ks))) c)
	   (T
	    (setq i (rem (1+ i) lks))
	    (nth (rem (+ lcs (op n m)) lcs) chars)
	   )
	 )
       )
      (vl-string->list str)
    )
  )
)

On peut utiliser cette fonction pour définir deux fonctions génériques, une pour le chiffrement, l'autre pour le déchiffrement.

;;; Fonction générique de chiffrement
(defun encrypt (chars str key) (vigenere + chars str key))

;;; Fonction générique de déchiffrement
(defun decrypt (chars str key) (vigenere - chars str key))

Puis utiliser ces fonctions pour définir différentes fonctions suivant les caractères à chiffrer.
Pour chiffrer uniquement les lettres majuscules non accentuées (comme dans l'exemple de Wikipedia)

(defun encryptUppers (str key)
  (encrypt (vl-string->list "ABCDEFGHIJKLMNOPQRSTUVWXYZ") str key)
)
(defun decryptUppers (str key)
  (decrypt (vl-string->list "ABCDEFGHIJKLMNOPQRSTUVWXYZ") str key)
)

_$ (encryptUppers "J'ADORE  ECOUTER LA RADIO TOUTE LA JOURNEE" "MUSIQUE")
"V'UVWHY  IOIMBUL PM LSLYI XAOLM BU NAOJVUY"
_$ (decryptUppers "V'UVWHY  IOIMBUL PM LSLYI XAOLM BU NAOJVUY" "MUSIQUE")
"J'ADORE  ECOUTER LA RADIO TOUTE LA JOURNEE"

Pour chiffrer toutes les lettres utilisées en français (y compris les lettre accentuées et les liaisons)

(defun encryptLetters (str key)
  (encrypt
    (vl-string->list
      "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ"
    )
    str
    key
  )
)
(defun decryptLetters (str key)
  (decrypt
    (vl-string->list
      "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ"
    )
    str
    key
  )
)

_$ (encryptLetters "[Challenge] Petite idée pour un codage/décodage Vigenère" "CADxp")
"[EhdÎÀgnjÂ] égtlÆT kdë Équu ŒÄ eogXVg/dëZÇfaj ôkghÔcte"
_$ (decryptLetters "[EhdÎÀgnjÂ] égtlÆT kdë Équu ŒÄ eogXVg/dëZÇfaj ôkghÔcte" "CADxp")
"[Challenge] Petite idée pour un codage/décodage Vigenère"

Pour chiffrer tous les caractères de 32 à 255*. On utilise une fonction pour générer une plage de nombres entiers.

;;; range
;;; Génère une plage de nombres entiers (liste)
;;;
;;; Arguments
;;; from : début de la plage
;;; to   : fin de la plage
(defun range (from to)
  (cond
    ((= from to) (list to))
    ((< from to) (cons from (range (1+ from) to)))
    ((< to from) (cons from (range (1- from) to)))
  )
)

;;; Fonctions de chiffrement/déchiffrement des caractères 32 à 255
;;;
;;; Arguments
;;; str : chaîne à chiffrer
;;; key : clé de chiffrement
(defun encryptChars (str key)
  (encrypt (range 32 255) str key)
)
(defun decryptChars (str key)
  (decrypt (range 32 255) str key)
)

_$ (setq crypted (encryptChars "[Challenge] Petite idée pour un codage/décodage Vigenère" "F#4fun"))
"F|§Áº‹q{«²nvhˆ¯É³FlxOºn–r‰¸uÔ#wµ¹¯hCª^±•gu­ºn|l{«ÃV˜h"
_$ (decryptChars crypted "F#4fun")
"[Challenge] Petite idée pour un codage/décodage Vigenère"

* Cette séquence de caractères contient des caractères de contrôle non imprimables.

[VDH-Bruno]

il y a 49 minutes, (gile) a dit :

Comme l'énoncé n'est pas très clair, j'ai essayé de faire quelque chose de générique en ajoutant comme argument la liste des caractères à chiffrer.

(decryptChars "X¨»²¦r|si¯´vu¬i°lqi©j" "(gile)")

😉

[(gile)]

@VDH-Bruno

Ma première version (chiffrage des 26 caractères alphabétiques non accentués uniquement avec respect de la casse) ressemble à la tienne :
 

(defun vigenere	(op str key / map lkey lg)
  (setq	lkey (vl-string->list (strcase key))
	lg   (length lkey)
  )
  (defun map (l i / n m)
    (setq m (- (nth (rem i lg) lkey) 65))
    (cond
      ((null (setq n (car l))) nil)
      ((< 64 n 91)
       (cons
	 (if (<= 0 m 26)
	   (+ 65 (rem (+ 26 (op (- n 65) m)) 26))
	   n
	 )
	 (map (cdr l) (1+ i))
       )
      )
      ((< 96 n 123)
       (cons
	 (if (<= 0 m 26)
	   (+ 97 (rem (+ 26 (op (- n 97) m)) 26))
	   n
	 )
	 (map (cdr l) (1+ i))
       )
      )
      (T (cons n (map (cdr l) i)))
    )
  )
  (vl-list->string (map (vl-string->list str) 0))
)

(defun encode (str key) (vigenere + str key))
(defun decode (str key) (vigenere - str key))

(decode "Wuhvp à kiv, hp q'hs qvog-êhmh wat rogoiw ke uvgcg lxl mpz jbim w'hmvjye." "VDH-Bruno")

[(gile)]

En fait, ma réponse (avec fonction générique) est une conversion en LISP de ce que j'ai développé en F#.

open System

// Fonction de chiffrement/dechiffrement générique.
// Utilise le chiffre de Vigenère avec l'alphabet spécifié
let coding op chars str key =
    let aKey =
        key
        |> Seq.toArray
        |> Array.map (fun chr -> Seq.tryFindIndex (fun c -> c = chr) chars)

    let mutable iKey = 0
    let length = Seq.length chars

    str
    |> Seq.map (fun chr ->
        match Seq.tryFindIndex (fun c -> c = chr) chars with
        | None -> chr
        | Some i ->
            match aKey.[iKey] with
            | None -> chr
            | Some j ->
                iKey <- (iKey + 1) % aKey.Length
                Seq.item ((length + (op i j)) % length) chars)
    |> Seq.toArray
    |> String

// Fonction générique de chiffrement
let encrypt: (seq<char> -> string -> string -> String) = coding (+)
// Fonction générique de déchiffrement
let decrypt: (seq<char> -> string -> string -> String) = coding (-)

// Fonctions de chiffrement/déchiffrement des lettres majuscules
let encryptUppers = encrypt [ 'A' .. 'Z' ]

let decryptUppers = decrypt [ 'A' .. 'Z' ]

// Fonctions de chiffrement/déchiffrement de toutes les lettres
let encryptLetters =
    encrypt "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ"

let decryptLetters =
    decrypt "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ"

// Fonctions de chiffrement/déchiffrement des caractères 32 à 255
let encryptChars = encrypt [ char 32 .. char 255 ]

let decryptChars = decrypt [ char 32 .. char 255 ]

Outre le fait que F# ait un type de données 'char' pour les caractères et qu'une chaîne soit implicitement une séquence de caractères, on peut noter que la définition des fonctions spécifiques à un "alphabet" utilisent l'application partielle permise par la curryfication.

[VDH-Bruno]

Il y a 1 heure, (gile) a dit :

(decode "Wuhvp à kiv, hp q'hs qvog-êhmh wat rogoiw ke rly zcd svus k'uzinhy." "VDH-Bruno")

*temps

Non pas autant que je le souhaiterais, mais il m'en reste tout de même un petit peu pour te décoder (et te déchiffrer 😁)

Sinon même si je ne parle pas couramment le F#, je lirais avec intérêt ces lignes de codes, j'aime bien comprendre les avantages qu'offrent d'autres langages, cela me permet par la suite de réussir à développer des approches différentes pour d'autres problèmes.

[DenisHen]

Bonjour à la communauté.
Un grand merci à tous de vous êtes prêtés à ce petit chalenge. 
(gile) a eu la bonne idée de poster son code original en F#, du coup, je me posais la question de ce que ça donnerait dans d'autre langages (VBA, C#...), car la comparaison de ces différents langages (comme le souligne judicieusement Bruno) donne sujet à réflexion, et je trouve cela très instructif.
Bien à toi, la communauté.
Et merci encore.

[Curlygoth]

En vba tu as un cours de cryptage décryptage sur développez.com 😉

https://mhubiche.developpez.com/Access/cryptage/vigenere/#:~:text=On appelle cryptage de Jules,utilisé ce genre de système.

[DenisHen]

Salut @Curlygoth.
Merci pour ce lien, je viens de le lire, mais je n'ai pas trouvé le "décryptage".
Ou alors, je ne l'ai pas vu... 😉 

[Curlygoth]

C'est a toi de le créé 🙂 mais vu que tu as le code du cryptage tu auras forcément le décryptage 

[(gile)]

Une version en C#.

L'algorithme est le même que celui utilisé plus haut en LISP et F#, mais au delà de la différence de langage (syntaxe), j'ai aussi essayé de de privilégier le paradigme POO (Programmation Orientée Objet) quand LISP et F# privilégient plutôt la Programmation Fonctionnelle.

Définition d'une classe abstraite Vigenere qui expose trois constructeurs (surcharge) et deux méthodes publiques : Encrypt et Decrypt et de trois classes dérivées pour lesquelles la séquence de caractères à chiffrer est définie.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace VigenereEncryption
{
    public abstract class Vigenere
    {
        private char[] chars;
        private delegate int Operator(int i, int j);
        private int encryptOperator(int i, int j) => i + j;
        private int decryptOperator(int i, int j) => i - j;

        public Vigenere(char[] alphabet)
        {
            chars = alphabet;
        }

        public Vigenere(string alphabet)
            : this(alphabet.ToCharArray()) { }

        public Vigenere(IEnumerable<int> ints)
            : this(ints.Select(i => (char)i).ToArray()) { }

        public string Encrypt(string str, string key) =>
            Crypting(encryptOperator, str, key);

        public string Decrypt(string str, string key) =>
            Crypting(decryptOperator, str, key);

        private string Crypting(Operator op, string str, string key)
        {
            var builder = new StringBuilder();
            int keyIndex = 0;
            var keyIndices = new int[key.Length];
            for (int i = 0; i < key.Length; i++)
            {
                keyIndices[i] = Array.IndexOf(chars, key[i]);
            }
            foreach (char chr in str)
            {
                int n = Array.IndexOf(chars, chr);
                int m = keyIndices[keyIndex];
                if (0 <= n && 0 <= m)
                {
                    builder.Append(chars[(chars.Length + op(n, m)) % chars.Length]);
                    keyIndex = (keyIndex + 1) % keyIndices.Length;
                }
                else
                {
                    builder.Append(chr);
                }
            }
            return builder.ToString();
        }
    }

    public class VigenereUppers : Vigenere
    {
        const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        public VigenereUppers() : base(alphabet) { }
    }

    public class VigenereLetters : Vigenere
    {
        const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÂÄÇÉÈÊËÎÏÔÖÙÛÜŸÆŒabcdefghijklmnopqrstuvwxyzàâäçéèêëîïôöùûüÿæœ";
        public VigenereLetters() : base(alphabet) { }
    }

    public class VigenereChars : Vigenere
    {
        static IEnumerable<int> alphabet = Enumerable.Range(32, 224);
        public VigenereChars() : base(alphabet) { }
    }
}

 

On crée un objet d'une classe dérivée de la classe de base Vigenere (une instance de cette classe) et on peut appeller les méthodes Encrypt et Decrypt de cet objet.

var vigenUppers = new VigenereUppers();
string crypted1 = vigenUppers.Encrypt("J'ADORE ECOUTER LA RADIO TOUTE LA JOURNEE", "MUSIQUE");

var vigenLetters = new VigenereLetters();
string crypted2 = vigenLetters.Encrypt("[Challenge] Petite idée pour un codage/décodage Vigenère", "CADxp");

var vigenChars = new VigenereChars();
string crypted3 = vigenChars.Encrypt("[Challenge] Petite idée pour un codage/décodage Vigenère", "F#4fun");

 

[(gile)]

Il y a 10 heures, DenisHen a dit :

Salut @Curlygoth.
Merci pour ce lien, je viens de le lire, mais je n'ai pas trouvé le "décryptage".
Ou alors, je ne l'ai pas vu... 😉 

Si tu lis avec un peu d'attention la page Wikipedia que tu as mise en lien dans ton premier message et que tu essayes un tant soit peu de déchiffrer les codes postés dans les différentes réponses, tu devrais te rendre compte que les méthodes d'encryptage et de décryptage sont plus ou moins identiques.

[DenisHen]

Bonjour à la communauté et merci pour toutes vos réponses.
Je viens de faire mon premier petit test, et je suis tombé sur un petit souci sur le code de @(gile)que je ne comprends pas :

Citation

_$ 
_$ (vigenere + (range 32 255) "C:\Ceci é un tâste" "CadXP")
"f{‡“ŒaMX¥‘a¸:£—¦"
_$ (vigenere - (range 32 255) "f{‡“ŒaMX¥‘a¸:£—¦" "CadXP")
"C:Ceci é un tâste"
_$ 

Tout se code et décode bien, sauf le "\", c'est le caractère ASCII n°47, il se trouve donc dans la plage 32-255.

[Luna]

Coucou,
Le backslash "\" est un peu particulier en lisp car pour qu'il puisse être interprété comme tel en LISP il faut écrire "\\" pour que la chaîne de caractères in fine soit "\". Donc ici, il est normal que le string renvoyé en ligne de commande n'indique pas le "\" puisque si tu fais ce simple test :

Commande: (setq str "C:\ProgramData")
"C:ProgramData"

On voit bien ici que le "\" n'apparaît pas 🙂 Donc si tu veux que ton backslash soit interprété, il te faut le doubler :

Commande: (setq str "C:\\ProgramData")
"C:\\ProgramData"

Et là seulement, il sera interprété correctement. C'est d'ailleurs le soucis justement avec les liens windows d'explorateur de fichier : windows écrit un seul "\" mais pour que les fonctions LISP l'interprète correctement, il faut penser à les doubler pour ne pas avoir de problèmes d'interprétation ! 😉

Bisous,
Luna

[DenisHen]

Coucou.
Mille mercis @Luna, c'est ce dont j'avais un peu peur, car je vais utiliser cette même "phrase" depuis le Lisp autant que depuis le VBA...
Mais je devrais m'en sortir, il suffit juste de savoir qui utilise cette phrase, Lisp ou VBA..
Encore merci, bisous.
Denis...