Updated README (git repo & text typos).

README.md

@@ -1,20 +1,5 @@
 # CryptAfinity
 
-  1. Description
-    1. Auteurs
-  2. Pre-requis
-    1. Sur un systeme Debian GNU/Linux
-    2. Sur un systeme Apple MacOSX (≥10.3)
-    3. Sur un systeme Microsoft Windows
-  3. Se procurer CryptAfinity
-  4. Utiliser CryptAfinity
-    1. Compilation
-    2. Utilisation
-  5. Documentation
-    1. Code
-    2. Decodeur "Afine"
-    3. Decodeur "Vigenere"
-
 ## 1. Description
 
 CryptAfinity est un logiciel libre permettant de dechiffrer des texte
@@ -40,12 +25,14 @@ version de developpement si compilez le programme vous-meme):
 
   * glib-2.0
 
+
 ### 2.1. Sur un systeme Debian GNU/Linux
 
 Il vous suffit de taper (en tant qu'administrateur) les commandes suivantes
 pour installer le necessaire: 
 
-# apt-get install libglib-2.0-dev
+  # apt-get install libglib-2.0-dev
+
 
 ### 2.2. Sur un systeme Apple MacOS X (>= 10.3)
 
@@ -53,18 +40,21 @@ Il est necessaire d'avoir installe les autotools (automake,
 autoconf...) dans leur derniere version. À partir de la, il
 suffit de taper les commandes suivantes dans un terminal :
 
-# sudo fink install glib2-dev
+  # sudo fink install glib2-dev
+
 
 ### 2.3. Sur un systeme Microsoft Windows
 
 Cela ne fut pas (encore) teste, mais il est tres probable que cela
 fonctionne sous Cygwin.
 
+
 ## 3. Se procurer CryptAfinity
 
 Vous pouvez telecharger la derniere archive des sources, ou bien directement
 la version la plus recente du projet sur le depot Subversion du projet.
 
+
 ### 3.1. L'archive des sources
 
 Elle est disponible a l'adresse :
@@ -72,40 +62,39 @@ Elle est disponible a l'adresse :
 [http://glenux2.free.fr/pub/projets/CryptAfinity/archives/](http://glenux2.fre
 e.fr/pub/projets/CryptAfinity/archives/)
 
+
 ### 3.2. Le depot Subversion
 
 Afin d'obtenir les sources les plus a jour, vous pouvez utiliser le logiciel
-de controle de sources Subversion
+de controle de sources Git :
 
-$ svn checkout http://repository.glenux.ath.cx/svn/CryptAfinity/
+  $ git clone https://github.com/glenux/cryptaffinity.git
 
-Il n'y a pas de mot de passe, il suffit donc de presser la touche "Entree"
-pour l'utilisateur "anonymous", si ce dernier vous est demande.
 
 ## 4. Utiliser CryptAfinity
 
+
 ### 4.1. Compilation
 
-Commencez par decompressez l'archive.
+Si vous avez téléchargé une archive, commencez par la decompressez :
 
-$ tar -xzvf CryptAfinity-0.1.tar.gz
+  $ tar -xzvf CryptAfinity-0.2.tar.gz
 
-Rendez vous ensuite dans le dossier qui vient d'etre cree lors de la
+Rendez vous ensuite dans le dossier qui vient d'etre crée lors de la
 decompression.
 
-$ cd CryptAfinity-0.2
+  $ cd CryptAfinity-0.2
 
 Puis lancez l'auto-configuration du logiciel, puis la compilation.
 
-$ ./autogen
+  $ ./autogen
-
+  $ ./configure
-$ ./configure
+  $ make
-
-$ make
 
 Le programme sous forme binaire se trouvera alors dans le sous-dossier
 src/tools/, sous le nom break_afinity
 
+
 ### 4.2. Utilisation
 
 CryptAfinity necessite de nombreux parametres, avec la syntaxe suivante:
@@ -117,27 +106,27 @@ Ou les parametres sont les suivants:  &nbs
 p_place_holder;   
 
 -a, --alphabet <file> 
-Fichier contenant les lettres de l'alphabet, dans l'ordre.
+: Fichier contenant les lettres de l'alphabet, dans l'ordre.
 
-  
 -e, --epsilon <float>
-Tolerance pour le test des clefs.
+: Tolerance pour le test des clefs.
 
 -f, --frequencies <float>
-Proportion moyenne que representent les 9 lettres "prioritaires" dans le texte
+: Proportion moyenne que representent les 9 lettres "prioritaires" dans le texte
 clair.
 
 -k, --keylength <int>      
-Taille de la clef maximul (obsolete)
+: Taille de la clef maximul (obsolete)
 
 -p, --priorities <file>
-Lettres ordonnees par frequence decroissante d'apparition dans le texte clair.
+: Lettres ordonnees par frequence decroissante d'apparition dans le texte clair.
 
 -t, --text <file>
-Fichier contenant le texte chiffre.
+: Fichier contenant le texte chiffre.
 
 -m, --mode <a|v>
-Selection du mode "Afine" ou "Vigenere"
+: Selection du mode "Afine" ou "Vigenere"
+
 
 ## 5. Documentation
 
@@ -151,116 +140,69 @@ doc/html de l'application, ou en suivant [ce lien](html/index.html).
 On genere l'espace des clefs possibles pour l'alphabet donne
 en entree:
 
-int alpha_size; //taille de l'alphabet
+  int alpha_size; //taille de l'alphabet
+  std::list<int> orb; // nombre premiers avec alpha_size
+  MathTools mt; // bibliotheque d'outils mathematiques
+  std::list<KeyAfine> keyList;
+  std::list<int>::iterator orbIt;
+  
+  for (i=1; i<alpha_size; i++){
+      if (mt.pgcd(i, alpha_size) == 1) {
+  	orb.push_back(i);
+      }
+  }
+  // 1 - generer l'espace des 312 clefs
+  for (orbIt = orb.begin(); orbIt != orb.end(); orbIt++){
+      KeyAfine key;
+      key.setCoefA((*orbIt));
+      for (i=0; i<alpha_size; i++){
+  	key.setCoefB(i);
+  	keyList.push_back(key);
+      }
+  }
 
-std::list<int> orb; // nombre premiers avec alpha_size
-
-MathTools mt; // bibliotheque d'outils mathematiques
-
-std::list<KeyAfine> keyList;
-
-std::list<int>::iterator orbIt;
-
-for (i=1; i<alpha_size; i++){
-
-    if (mt.pgcd(i,
-alpha_size) == 1) {
-
-   
-    orb.push_back(i);
-
-    }
-
-}
-
-// 1 - generer l'espace des 312 clefs
-
-for (orbIt = orb.begin(); orbIt != orb.end(); orbIt++){
-
-    KeyAfine key;
-
-   
-key.setCoefA((*orbIt));
-
-    for (i=0;
-i<alpha_size; i++){
-
-   
-    key.setCoefB(i);
-
-   
-   
-keyList.push_back(key);
-
-    }
-
-}
 
 Puis on fait une attaque par analyse de frequence sur les textes obtenus par
 "decodage" du texte chiffre avec les clefs essayees.
 
-float frequencies; // frequence cumulee des 9 lettres les
+  float frequencies; // frequence cumulee des 9 lettres les
-plus presentes
+  plus presentes
+  float epsilon; // marge d'erreur
+  std::list<KeyAfine>::iterator kLIt;
 
-float epsilon; // marge d'erreur
+  for (kLIt = keyList.begin(); kLIt != keyList.end(); kLIt++){
+      float score = 0;
+      printf("Trying key %s\n", (*kLIt).toString().c_str());
 
-std::list<KeyAfine>::iterator kLIt;
+      plainText = codec.decode(cypherText, *kLIt);   
+      plainText.setAlphabet(this->_config.getAlphabet());
 
-for (kLIt = keyList.begin(); kLIt != keyList.end(); kLIt++){
+      for (int i=0; i<9; i++){
+	  score +=   plainText.getCountOf(prio_conf[i]);
+      }
 
-    float score = 0;
+      score = score / plainText.size();
 
-    printf("Trying key
+      if (fabs(score - frequencies) < epsilon){
-%s\n", (*kLIt).toString().c_str());
+	  printf("KEY =
+		  %s\n",(*kLIt).toString().c_str());
 
-  
+	  printf("PLAIN TEXT(%f) = %s\n", fabs
-    plainText =
+		  (score-frequencies),
-codec.decode(cypherText,
-*kLIt);   
 
-   
+		  plainText.toAlphabet().c_str());
-plainText.setAlphabet(this->_config.getAlphabet());
+      }
+  }
 
-    for (int i=0; i<9;
-i++){
-
-   
-    score +=
-plainText.getCountOf(prio_conf[i]);
-
-    }
-
-    score = score /
-plainText.size();
-
-    if (fabs(score -
-frequencies) < epsilon){
-
-      printf("KEY =
-%s\n",(*kLIt).toString().c_str());
-
-   
-  printf("PLAIN TEXT(%f) = %s\n", fabs
-(score-frequencies),
-
-     
-  plainText.toAlphabet().c_str());
-
-    }
-
-  
-}
 
 ### 5.3. Principe du "decodeur Vigenere"
 
-On commence par faire recuperer les groupes de carateres qui se repetent dans
+On commence par détecter les groupes de carateres qui se repetent dans le
-le texte.
+texte.
 
-  
+Une fois ces groupes repétes de lettres obtenus (dans l'ordre decroissant en
-Une fois les groupes repetes de lettres de plus grande longueur obtenus (dans
+fonction de leur longueur), on calcule la distance separant les deux premiers
-l'ordre decroissant en fonction de la longueur), on calcule la distance
+groupes (note d1) puis la distance entre les deux suivant (d2).
-separant les deux premiers groupes (note d1) puis la distance entre les deux
-suivant (d2).
 
 On pose K = PGCD(d1, d2). Il est fortement probable que K soit un multiple de
 la longueur de la clef. L'hypothese sous-jacente est que ces groupes de
@@ -268,7 +210,7 @@ lettres sont issue du chiffrement des memes bouts de mots avec les memes 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 repetitions.
 
-  
+
 L'etape suivante consiste a faire une analyse de frequence en decoupant le
 texte en K colonnes. On classe ensuite les lettres
 apparaissant dans les colonnes en fonction de leur nombre d'apparitions.