0bb367c9b4
git-svn-id: https://websvn.glenux.net/svn/Upoc/cryptaffinity/trunk@1333 eaee96b3-f302-0410-b096-c6cfd47f7835
456 lines
12 KiB
HTML
456 lines
12 KiB
HTML
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
<html lang="fr-fr"><head>
|
|
|
|
|
|
<meta content="text/html;charset=ISO-8859-1" http-equiv="Content-Type">
|
|
|
|
|
|
|
|
<link rel="stylesheet" type="text/css" href="cryptafinity.css">
|
|
|
|
|
|
|
|
|
|
|
|
<title>CryptAfinity</title><meta content="Glenn ROLLAND" name="author"></head>
|
|
|
|
<body style="direction: ltr;">
|
|
|
|
<div style="text-align: justify;" class="page code">
|
|
<h1>CryptAfinity</h1>
|
|
|
|
<ol>
|
|
|
|
<li><a href="#1._Description">Description</a></li>
|
|
|
|
<ol>
|
|
|
|
<li><a href="#1.1._Auteurs">Auteurs</a></li>
|
|
|
|
</ol>
|
|
|
|
<li><a href="#2._Pr%E9-requis">Pré-requis</a></li>
|
|
|
|
<ol>
|
|
|
|
<li><a href="#2.1._Sur_un_syst%E8me_Debian_GNULinux">Sur un
|
|
système Debian GNU/Linux</a></li>
|
|
|
|
<li><a href="#2.2._Sur_un_syst%E8me_Apple_MacOS_X_">Sur un
|
|
système Apple MacOSX (≥10.3)</a></li>
|
|
|
|
<li><a href="#2.3._Sur_un_syst%E8me_Microsoft_Windows">Sur
|
|
un système Microsoft Windows</a></li>
|
|
|
|
</ol>
|
|
|
|
<li><a href="#3._Se_procurer_MiniFTPc">Se procurer
|
|
CryptAfinity</a></li>
|
|
|
|
<li><a href="#4._Utiliser_MiniFTPc">Utiliser CryptAfinity</a></li>
|
|
|
|
<ol>
|
|
|
|
<li><a href="#4.1._Compilation">Compilation</a></li>
|
|
|
|
<li><a href="#4.2._Utilisation">Utilisation</a></li>
|
|
|
|
</ol>
|
|
|
|
<li><a href="#5._Documentation">Documentation</a></li>
|
|
<ol>
|
|
<li><a href="#5.1._Code">Code</a></li>
|
|
<li><a href="#5.2._Principe_du_d%E9codeur_Afine">Décodeur "Afine"</a></li>
|
|
<li><a href="#5.3._Principe_du_d%E9codeur_Vigen%E8re">Décodeur "Vigenère"</a></li>
|
|
</ol>
|
|
|
|
|
|
</ol>
|
|
|
|
<h2><a name="1._Description"></a>1.
|
|
<a name="Description"></a>Description</h2>
|
|
|
|
<p>CryptAfinity est un logiciel
|
|
libre permettant de déchiffrer des texte
|
|
obfusqués par des systèmes Afines ou l'algorithme
|
|
de Vigenère. Il possède les
|
|
caractéristiques
|
|
suivantes :</p>
|
|
|
|
<ul>
|
|
|
|
<li>Il est distribué
|
|
sous la licence <a href="http://www.gnu.org/copyleft/gpl.html">GNU
|
|
General Public License</a></li>
|
|
|
|
<li>Il est
|
|
écrit en C++.</li>
|
|
|
|
<li>Il
|
|
implémente
|
|
pour l'instant uniquement une analyse par fréquences,
|
|
à partir d'une liste de "priorités" de lettres
|
|
dans un texte clair, et de la proportion que représentent
|
|
les X premieres lettres "prioritaires" dans le texte.</li>
|
|
|
|
</ul>
|
|
|
|
<h3><span style="font-weight: bold;"></span>1.1.
|
|
Auteurs</h3>
|
|
|
|
<p>CryptAfinity a
|
|
été entièrement
|
|
réalisé par Glenn ROLLAND <<a href="mailto:glenux@fr.st">glenux@fr.st</a>> et Roland LAURÈS <<a href="mailto:shamox@mac.com">shamox@mac.com</a>>
|
|
à l'occasion de travaux pratiques du cours de système du
|
|
Master 2 Ingénierie Informatique -
|
|
Systèmes, Réseaux et Internet.</p>
|
|
|
|
<h2><a name="2._Pré-requis"></a>2.
|
|
Pré-requis</h2>
|
|
|
|
<p>CryptAfinity
|
|
nécessite les bibliothèques de fonctions
|
|
suivantes (dans
|
|
leur version de développement si compilez le programme
|
|
vous-même):</p>
|
|
|
|
<ul>
|
|
|
|
<li>glib-2.0</li>
|
|
|
|
</ul>
|
|
|
|
<h3><a name="2.1._Sur_un_système_Debian_GNULinux"></a>2.1.
|
|
Sur un système
|
|
Debian GNU/Linux</h3>
|
|
|
|
<p>Il vous suffit de taper (en
|
|
tant qu'administrateur) les
|
|
commandes suivantes pour installer le nécessaire: </p>
|
|
|
|
<p class="code"># apt-get
|
|
install libglib-2.0-dev</p>
|
|
|
|
<h3><a name="2.2._Sur_un_système_Apple_MacOS_X_"></a>2.2.
|
|
Sur un système Apple MacOS X (>= 10.3)</h3>
|
|
|
|
<p>
|
|
Il est nécessaire d'avoir installé <span style="font-style: italic;"></span>les <span style="font-style: italic;">autotools</span>
|
|
(automake, autoconf...) dans leur dernière
|
|
version. À partir de là, il suffit de
|
|
taper les commandes suivantes dans un terminal :</p>
|
|
|
|
<p class="code"># sudo fink
|
|
install glib2-dev</p>
|
|
|
|
<h3><a name="2.3._Sur_un_système_Microsoft_Windows"></a>2.3.
|
|
Sur un système Microsoft Windows</h3>
|
|
|
|
Cela ne fut pas (encore) testé, mais il est très
|
|
probable que cela fonctionne sous Cygwin.<br>
|
|
|
|
<h2><a name="3._Se_procurer_MiniFTPc"></a>3.
|
|
Se procurer CryptAfinity</h2>
|
|
|
|
<p>
|
|
Vous
|
|
pouvez télécharger la dernière archive
|
|
des
|
|
sources, ou bien directement la version la plus récente du
|
|
projet sur le dépôt Subversion du projet.</p>
|
|
|
|
<h3>3.1. L'archive des sources</h3>
|
|
|
|
<p>
|
|
Elle est disponible à l'adresse : </p>
|
|
|
|
<a href="http://glenux2.free.fr/pub/projets/CryptAfinity/archives/">http://glenux2.free.fr/pub/projets/CryptAfinity/archives/</a><br>
|
|
|
|
<h3>3.2. Le
|
|
dépôt Subversion</h3>
|
|
|
|
<p>Afin d'obtenir les sources les
|
|
plus à jour, vous pouvez utiliser le logiciel de
|
|
contrôle de sources Subversion </p>
|
|
|
|
<p class="code">$ svn
|
|
checkout http://repository.glenux.ath.cx/svn/CryptAfinity/</p>
|
|
|
|
<p>Il n'y a pas de mot de passe,
|
|
il suffit donc de presser la touche
|
|
"Entrée" pour l'utilisateur "anonymous", si ce dernier vous
|
|
est
|
|
demandé.</p>
|
|
|
|
<h2><a name="4._Utiliser_MiniFTPc"></a>4.
|
|
Utiliser CryptAfinity</h2>
|
|
|
|
<h3><a name="4.1._Compilation"></a>4.1.
|
|
Compilation</h3>
|
|
|
|
<p>Commencez par
|
|
décompressez l'archive.</p>
|
|
|
|
<p class="code">$ tar -xzvf
|
|
CryptAfinity-0.1.tar.gz</p>
|
|
|
|
<p>Rendez vous ensuite dans le
|
|
dossier qui vient d'être créé lors de
|
|
la décompression.</p>
|
|
|
|
<p class="code">$ cd
|
|
CryptAfinity-0.2</p>
|
|
|
|
<p>Puis lancez
|
|
l'auto-configuration du logiciel, puis la compilation.</p>
|
|
|
|
<p class="code">$ ./autogen<br>
|
|
|
|
$ ./configure<br>
|
|
|
|
$ make</p>
|
|
|
|
<p>Le programme sous forme binaire
|
|
se trouvera alors dans le sous-dossier <span class="code">src/tools/</span>,
|
|
sous le nom <span class="code">break_afinity</span></p>
|
|
|
|
<h3><a name="4.2._Utilisation"></a>4.2.
|
|
Utilisation</h3>
|
|
|
|
<p>
|
|
CryptAfinity nécessite de nombreux paramètres, avec la
|
|
syntaxe suivante:</p>
|
|
|
|
<p class="code">Usage:
|
|
break_afinity -a <fichier> -e <float> -f
|
|
<float> -p <fichier> -t
|
|
<fichier> -m <br>
|
|
|
|
</p>
|
|
|
|
<p>
|
|
Où les paramètres sont les
|
|
suivants: </p>
|
|
|
|
<table style="text-align: left; width: 100%;" border="0" cellpadding="2" cellspacing="2">
|
|
|
|
<tbody>
|
|
|
|
<tr>
|
|
|
|
<td>-a, --alphabet
|
|
<file> </td>
|
|
|
|
<td>Fichier contenant les
|
|
lettres de l'alphabet, dans l'ordre.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td><br>
|
|
|
|
-e, --epsilon <float></td>
|
|
|
|
<td>Tolerance pour le test
|
|
des clefs.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td>-f, --frequencies
|
|
<float></td>
|
|
|
|
<td>Proportion moyenne que
|
|
représentent les 9 lettres "prioritaires" dans le texte
|
|
clair.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td>-k, --keylength
|
|
<int> </td>
|
|
|
|
<td>Taille de la clef
|
|
maximul (obsolète)</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td>-p, --priorities
|
|
<file></td>
|
|
|
|
<td>Lettres
|
|
ordonnées par fréquence décroissante
|
|
d'apparition dans le texte clair.</td>
|
|
|
|
</tr>
|
|
|
|
<tr>
|
|
|
|
<td>-t, --text
|
|
<file></td>
|
|
|
|
<td>Fichier contenant le
|
|
texte chiffré.</td>
|
|
|
|
</tr>
|
|
<tr>
|
|
|
|
<td>-m, --mode <a|v></td>
|
|
|
|
<td>Selection du mode "Afine" ou "Vigenère"</td>
|
|
|
|
</tr>
|
|
|
|
</tbody>
|
|
</table>
|
|
|
|
<h2><a name="5._Documentation"></a>5.
|
|
Documentation</h2>
|
|
|
|
<h3><a name="5.1._Code"></a>5.1. Code</h3>
|
|
|
|
<p>Vous pouvez trouver la documentation du code de CryptAfinity dans le
|
|
dossier <span class="code">doc/html</span>
|
|
de l'application, ou en suivant <a href="html/index.html">ce lien</a>.</p>
|
|
|
|
<h3><a name="5.2._Principe_du_décodeur_Afine"></a>5.2. Principe du "décodeur Afine"</h3>
|
|
|
|
<p>On génère l'espace des clefs possibles pour l'alphabet donné en entrée:</p>
|
|
|
|
<p class="code">int alpha_size; //taille de l'alphabet<br>
|
|
|
|
std::list<int> orb; // nombre premiers avec alpha_size<br>
|
|
|
|
MathTools mt; // bibliotheque d'outils mathématiques<br>
|
|
|
|
std::list<KeyAfine> keyList;<br>
|
|
|
|
std::list<int>::iterator orbIt;</p>
|
|
|
|
<p class="code">for (i=1; i<alpha_size; i++){<br>
|
|
|
|
if (mt.pgcd(i, alpha_size) == 1) {<br>
|
|
|
|
orb.push_back(i);<br>
|
|
|
|
}<br>
|
|
|
|
}<br>
|
|
|
|
// 1 - générer l'espace des 312 clefs<br>
|
|
|
|
for (orbIt = orb.begin(); orbIt != orb.end(); orbIt++){<br>
|
|
|
|
KeyAfine key;<br>
|
|
|
|
key.setCoefA((*orbIt));<br>
|
|
|
|
for (i=0; i<alpha_size; i++){<br>
|
|
|
|
key.setCoefB(i);<br>
|
|
|
|
keyList.push_back(key);<br>
|
|
|
|
}<br>
|
|
|
|
}</p>
|
|
|
|
<p>Puis on fait une attaque par analyse de fréquence sur les textes
|
|
obtenus par "décodage" du texte chiffré avec les clefs essayées.</p>
|
|
|
|
<p class="code">float frequencies; // fréquence cumulée des 9 lettres les plus présentes<br>
|
|
|
|
float epsilon; // marge d'erreur</p>
|
|
|
|
<p style="text-align: left;" class="code">std::list<KeyAfine>::iterator kLIt;<br>
|
|
|
|
for (kLIt = keyList.begin(); kLIt != keyList.end(); kLIt++){<br>
|
|
|
|
float score = 0;<br>
|
|
|
|
printf("Trying key %s\n", (*kLIt).toString().c_str());<br>
|
|
|
|
<br>
|
|
|
|
plainText = codec.decode(cypherText, *kLIt); <br>
|
|
|
|
plainText.setAlphabet(this->_config.getAlphabet());<br>
|
|
|
|
for (int i=0; i<9; i++){<br>
|
|
|
|
score += plainText.getCountOf(prio_conf[i]);<br>
|
|
|
|
}<br>
|
|
|
|
score = score / plainText.size();<br>
|
|
|
|
if (fabs(score - frequencies) < epsilon){<br>
|
|
|
|
printf("KEY = %s\n",(*kLIt).toString().c_str());<br>
|
|
|
|
printf("PLAIN TEXT(%f) = %s\n", fabs(score-frequencies),<br>
|
|
|
|
plainText.toAlphabet().c_str());<br>
|
|
|
|
}<br>
|
|
|
|
<br>
|
|
|
|
}</p>
|
|
|
|
|
|
<h3><a name="5.3._Principe_du_décodeur_Vigenère"></a>5.3. Principe du "décodeur Vigenère"</h3>
|
|
<div style="text-align: justify;">
|
|
On commence par faire récupérer les groupes de caratères qui se répètent dans le texte.<br>
|
|
|
|
<br>
|
|
Une fois les groupes répétés de lettres de plus
|
|
grande longueur obtenus (dans l'ordre décroissant en fonction de
|
|
la longueur), on calcule la distance
|
|
séparant les deux premiers groupes (note d1) puis la distance
|
|
entre les deux suivant (d2). <br>
|
|
On pose K = PGCD(d1, d2). Il est fortement probable que K soit un
|
|
multiple de la longueur de la clef. L'hypothèse sous-jacente est
|
|
que ces groupes de lettres sont issue du chiffrement des mêmes
|
|
bouts de mots avec les mêmes bouts de la clef. Si le K = 1 on
|
|
peut raisonnablement supposer que ce n'est pas le cas, et qu'il n'y a pas de répétitions.<br>
|
|
|
|
<br>
|
|
L'étape suivante consiste à faire une analyse de
|
|
fréquence en découpant le texte en K colonnes. On
|
|
classe ensuite les lettres apparaissant dans les colonnes en fonction
|
|
de leur nombre d'apparitions. <br>
|
|
Dans un monde utopique, il suffirait de calculer la distance entre la
|
|
lettre apparaissant le plus souvent dans la colonne, et celle
|
|
apparaissant le plus souvent dans le langage attendu pour le texte
|
|
clair (l'anglais en l'occurrence). <br>
|
|
Cependant il arrive fréquemment que l'ordre de lettre soit
|
|
légèrement changé par rapport au résultat
|
|
attendu. Dans le programme, on calcule donc pour chaque colonne les
|
|
distances entre les X lettres les plus fréquentes dans la
|
|
colonne et la lettre la plus fréquente dans le langage.<br>
|
|
On génère ensuite un espace de X ^ K clefs a partir des
|
|
combinaisons de ces différents décalages obtenus sur
|
|
chaque colonne.<br>
|
|
<br>
|
|
Enfin, on décode ensuite le texte avec chacune des clef
|
|
générées, et en fonction de données
|
|
statistiques
|
|
relative à notre connaissance préalable du texte et d'une
|
|
petite marge d'erreur, on filtre les texte déchiffrés.<br>
|
|
(Exemple: les 9 lettres les plus fréquentes représentent 70% du texte, et on une marge de +/- 4%). <br>
|
|
En jouant sur la marge d'erreur, on laisse passer plus ou moins de
|
|
textes déchiffrés, parmi lesquels devrait se trouver le
|
|
texte clair attendu.<br>
|
|
|
|
|
|
</div>
|
|
</div>
|
|
|
|
|
|
</body></html>
|