Comme les élèves d'ICN tendent à être à l'aise avec bash (et pas seulement cowsay!), une séance de cryptographie peut rapidement être faite en bash, qui ne nécessite pas de boucler sur les lettres du message à coder (la boucle étant remplacée par un "pipe"). Une difficulté lorsqu'on veut faire de la cryptographie (et particulièrement avec l'algorithme d'Al Kindi qui est basé sur la statistique) est d'obtenir un texte à crypter, sans avoir à écrire des lignes et des lignes de texte. La ligne suivante permet d'obtenir un texte de longueur raisonnable:

man factor > message.txt

Après ça, on va crypter le fichier message.txt et écrire le résultat dans un autre fichier codé.txt. Par exemple, pour remplacer les "a" par des "?" on fait

cat message.txt | tr "a" "?" > codé.txt

("tr" veut dire "traduire" ou "translater": Le chiffre de César est, géométriquement parlant, une translation). Avec less codé.txt on voit que le message codé commence par

NOM
       f?ctor - F?ctoriser des nombres

SYNOPSIS
       f?ctor [NOMBRE]...
       f?ctor OPTION

Il ne reste plus qu'à recommencer pour les autres lettres de l'alphabet, pour que le message soit codé! Le chiffre de Cesar consiste à remplacer chaque lettre de l'alphabet par celle qui se trouve 3 rangs (par exemple) plus loin dans l'alphabet. Ici, remplacer "a" par "d", "b" par "e" etc. Mais du coup, on doit remplacer "z" par "c": La permutation opérée sur l'alphabet est cyclique. Ce codage se fait avec

cat message.txt | tr "a-z" "d-za-c" > codé.txt

Les minuscules sont maitenant cryptées:

NOM
       idfwru - Fdfwrulvhu ghv qrpeuhv

SYNOPSIS
       idfwru [NOMBRE]...
       idfwru OPTION

Le plus simple pour coder aussi les majuscules est de faire

cat message.txt | tr "A-z" "D-zA-C" > codé.txt

Cet algorithme de cryptage est loin d'être parfait: Les chiffres ne sont pas cryptés, l'abondance de o' montre que "o" code "l" (qui est la lettre le plus souvent suivie d'une apostrophe), etc. Mais le décryptage est facile avec tr: Il suffit d'inverser les deux chaînes de caractères définissant le codage:

cat codé.txt | tr "D-zA-C" "A-z"

Les élèves peuvent choisir leur propre codage soit avec des variantes comme "F-zA-E" soit carrément en écrivant une permutation lettre après lettre, comme

tr "a-z" "azertyuiopqsdfghjklmwxcvbn"

Il reste alors du temps pour faire un peu de cryptanalyse avec l'algorithme d'Al Kindi: La lettre "e" étant la plus fréquente dans un texte en français, on compte les lettres dans le texte codé pour chercher laquelle intervient le plus souvent. Ou plutôt, on va demander à grep de compter: grep est un petit robot qui parcourt le texte pour chercher la lettre qu'on lui a demandé de chercher, de la même manière qu'un cochon du Périgord parcourt les arbres pour y chercher des truffes. Pour compter les "w" du message en clair, on peut faire

cat message.txt | grep w

Le problème c'est que ça affiche toutes les lignes contenant un "w", pas seulement le "w" lui-même:

       Aide en ligne de  GNU  coreutils :  <http://www.gnu.org/software/coreu‐
       Copyright © 2014 Free Software Foundation, Inc.  Licence  GPLv3+ :  GNU
       Documentation complète : <http://www.gnu.org/software/coreutils/factor>
       <fblinux  AT  wanadoo  DOT   fr>   et   les   membres   de   la   liste

La troisième ligne par exemple contient trois fois de suite la lettre "w"; compter les lignes fausserait les statistiques sur ce texte; et compter les lettres aussi, puisque d'autres lettres que les "w" sont affichées aussi. Pour mieux voir les "w", on peut faire

cat message.txt | grep --color w

Si grep sait dessiner en couleurs, il sait aussi faire le tri, et la variante suivante affiche tous les "w", uniquement eux, et un seul par ligne:

cat message.txt | grep -o w

Il suffit alors de compter les lignes du résultat avec "word count" (option -l comme "lignes"):

cat message.txt | grep -o w | wc -l

Pour savoir quelle est la lettre qui code "e", il suffit de recommencer ça sur le message codé, lettre après lettre, et regarder quelle est la lettre la plus fréquente. Pour cela, on va quand même boucler, sur les lettres de l'alphabet. Avec des choses comme

echo {a..z}
for l in {a..z}; do echo $l; done
for l in {a..z}; do printf $l; done
for l in {a..z}; do (printf $l\ ); done
for l in {a..z}; do (printf $l\ ; cat codé.txt | grep -o $l | wc -l); done


Ce script affiche un tableau (qu'il est tout-à-fait possible d'enregistrer dans un fichier csv à l'aide d'une redirection) et dont voici le début:

a 0
b 0
c 0
d 68
e 15
f 39
g 32
h 124
i 24
j 20
k 12
l 74
m 3
n 1

Avec le tableau complet, on voit que la lettre "h" est de loin la plus fréquente et on infère que "e" est codé par "h". Si on sait qu'il s'agit d'un chiffre de Cesar, on a fini de décrypter; sinon on continue avec la lettre "r" qui est la deuxième lettre la plus fréquente (et le "u" apparaît 96 fois dans le message codé).

Après la cryptanalyse, ou à la place si le temps manque, on peut créer une commande de cryptage, ce qui est l'occasion de faire de la création numérique (c'est le nom de la matière enseignée après tout), et d'aborder les tests. On crée un fichier nommé crypter.sh et on y écrit les lignes suivantes (avec nano par exemple, on peut le faire dans une autre console pour la commodité):

#!/bin/bash

if [[ $# -ne 2 ]]; then
	echo "Utilisation de cette commande :"
	echo "Il faut deux noms de fichiers :"
	echo " * Le premier est le fichier texte à coder"
	echo " * Le second est le fichier qui contiendra le texte codé"
	else
	cat $1 | tr "A-z" "D-zA-C" > $2
	fi

En cours d'élaboration on teste le fichier avec des choses comme echo $1 ou echo $#. Pour tester le fichier, on doit le rendre exécutable avec

chmod +x crypter.sh

Ensuite on crypte un fichier avec

./crypter.sh message.txt codé.txt

On peut même crypter par lot avec ce genre de boucle (qui renomme les "txt" en "cesar"):

for f in *.txt; do (touch ${f%.txt}.cesar; ./crypter.sh $f ${f%.txt}.cesar); done

Remarque: L'extension "sh" est facultative, et ne pas la mettre renforce l'impression d'avoir créé une nouvelle commande dans bash.

 ___________
( Dyh Fhvdu )
 -----------
   o
    o
        .--.
       |o_o |
       |:_/ |
      //   \ \
     (|     | )
    /'\_   _/`\
    \___)=(___/