Le texte suivant a été obtenu en appliquant le chiffrement de césar (Vu en cours). Ce chiffre résulte d'un texte écrit en langue française dont on a supprimé les espaces.

prdhryvatravbfvgrqrfubzzrfabhfnbssregqnafprfpragfqreavrerfnaarrfnhenvgchsnpvyvgrehar
ivryvoerrgurherhfrfvyrcebterfrageryrfuhznvaffrssrpghnvgrazrzrgrzcfdhryrfcebterffheyr
fpubfrfbeyrerfhygngynobevrhkerffrzoyrcbheprhkqrabgertrarengvbanprdhrfrenvghaenfbvecb
heharasnagqrgebvfnafynpbadhrgrqrsnohyrhkzblrafqrcebqhpgvbaancnfnccbegrynyvoregrznvfy
rfnatbvffrfrgynsnvzcverrapberyrfcebterfgrpuavdhrfsbheavffragyrfzblrafqnarnagveynivru
hznvarrggbhgprdhvnrgrqherzragperrcneyubzzrcebgrfgrenhwbhequhvpbageryrfnezrzragfarfvt
avsvrevrargarpunatrevrafrhyrynfhccerffvbaqrsvavgvirqhevfdhrhavirefryqrynthreerqbaarh
afrafrghapunaprnynfheivrqhzbaqribvynqrfbeznvfabgerynorhedhbgvqvrargabgervaroenaynoyr
qrpvfvbayhggrepbagerynenpvarqhznyrgabapbageryrfrssrgfwrqrgrezvarynhguragvdhrinyrheqh
aubzzrqncerfharfrhyrertyrndhryqrterrgqnafdhryohgyubzzrfrfgyvorerqrfbazbvgbhgrfyrfevp
urffrfqhzbaqrshffragryyrfrageryrfznvafqhaubzzrgbgnyrzragnpdhvfnyvqrrqrcebterfarcrezr
ggebagwnznvfyrzbvaqerqrirybccrzragzbenyqryuhznavgryrqrfgvaqryuhznavgrercbfrfheyrfsbe
prfzbenyrfqryubzzrfvabhfibhybafharivryvoerrgurherhfrvylsnhqenarprffnverzragerabaprzr
agrgerfgevpgvbaynpbzcerurafvbaqnhgehvarcebterffrendhnirpyrcnegntrqrfwbvrfrgqrffbhsse
naprfwrarcrhkpbzcnereyntrarebfvgrqhazbvfrqhawrfhfbhqhatnaquvrgyntrarebfvgrqhardhrypb
adhrsbaqngvbapneartvrnyoregrvafgrva

Implantez, dans le langage de votre choix (préférence donnée au C), une cryptanalyse de ce texte

On considère que la clef de transposition de notre chiffrement suit les mêmes règles que celles vues en cours. Le nombre de colonnes est égal à la longueur de la clef. La transposition se fait suivant l’ordre alphabétique des lettres de la clef. En cas d'égalité, le sens de lecture de la gauche vers la droite est la seconde règle de priorité ́e. On considère la clef de chiffrement par transposition suivante :

        CCMMODULESECURITE

Implantez, dans le langage de votre choix, la détransposition du chiffre suivant :

ltd scs eoh oee eus etn ape ier cvc ete eoe dno nln prt
pet iot tae eok stt fue sem epz dcf epi ohi ldi dec phb
cll lae nrg oaa ieu etn ist vnf fns oer uno rse ede uen
que uqr sis erd euo vte ree nta nce ntr ibi tus erd cct
ile ele afu nat tee eqe iie uiu des uao rar afs nva qis
irs ens nud usi orl era rui qio aes ets mte nss lll dca
eir uem uvs tlm nae mos eeo eeu eay nle sno qoo rea tct
eip zdl scs nps tnc sei uui eyc mdn rra qev uon iil upu
neu nzr tea adt utq cen ios due rue uun duo une edi see
ers tne nts oos eiu ghh aei oea err eor tbg esi rhs vvc
iae iii tml mul vit apo tea loe eir

Sachant que la puissance totale de l'énergie solaire reçue chaque année sur Terre est d'environ 173.10^15 Watts et que la machine actuellement en tête du Green-500 (Novembre 2014) développe une puissance d'environ 5272.10^6 FLOPS/Watt. En considérant qu'une seule opération à virgule flottante est nécessaire pour tester une clé de 128 bits pour un algorithme de chiffrement donné, combien de temps faudrait-il pour tester toutes les clés en utilisant l'intégralité du rayonnement solaire reçu sur Terre pour réaliser cette opération ?

Le texte ci-dessous a été chiffré à l'aide d'une substitution mono-alphabétique. En basant sur les informations contenues à cette URL, procédez à une analyse fréquentielle en vue de retrouver le texte français original.

b'qljbg go bq wlg

b'qljbg, uglcg fgi qlui, qtgd vqujxo bq wlg,
flhhgugcogi f'kpvgpu, fg bqcjqjg go f'giwulo, go f'kqslo,
ouqtguiqlgco pc sxpo fg wuqlulg.
bg kqiquf bgi qiigvsbg gc pc dxlc fgoxpucg.
b'qjqiig gpo wgpu; vqli b'qljbg, qzqco hxuo slgc flcg,
bq uqiipug, go bpl flo: "qbbxci fg dxvwqjclg ;
il bg vqloug fgi flgpe qiiga ixptgco i'gccplg,
bpl ypl jxptgucg b'pcltgui,
m'gc wpli slgc hqlug qpoqco, vxl yp'xc iqlo ypl bg igui.
gcougogcgavxl fxcd, go iqci dgugvxclg."
dqypgosxcsgd qbxui fg mqigu qp wbpi fup,
ipu dgdl, ipu dgbq, ipu oxpo. b'kxvvg f'kxuqdg,
fliqco bg slgc, bg vqb q ouqtgui dkqvwi, c'gpo ip
dg yp'gc hqlo fg sqslb z iqtqlo cxoug qjqiig.
gbbg xhhug f'qtguolu fg oxpo dg ypl ig wqiig,
iqpoqco, qbbqco fg wbqdg gc wbqdg,
sxc giwlxc, flgp iqlo. ixc xhhug qzqco fgwbp,
b'qljbg bpl flo oxpo gc dxbgug :
"cg yplooga wxlco txoug igmxpu,
dqypgosxcsgd, vqvlg ; qflgp ; mg c'ql ypg hqlug
f'pcg sqslbbqufg q vq dxpu :
d'gio pc hxuo vgdkqco dquqdogug.?
vqujxo cg fgvqcfqlo wqi vlgpe.
dg c'gio wqi dg yp'xc duxlo ypg f'gcougu dkga bgi flgpe :
dgo kxccgpu q ixptgco fg vxuogbbgi qcjxliigi.
ugfligpui, giwlxci, jgci q b'qlu juqdlgpe,
qp dxgpu oxpo flhhgugco, i'z ugcfgco xflgpe,
ypxlypg qlcil ypg bq wlg lb hqlbbg fqci dgi blgpe
wxuogu kqslo fg fgpe wquxliigi.

mgqc fg bq hxcoqlcg, bg hqsbgi

Pour ce faire, vous pouvez utiliser l'éditeur de votre choix pourvu qu'il soit pourvu d'une fonction de remplacement d'un caractère par un autre.

L'algorithme One Time Pad (“Masque jetable”) est prouvé “incassable”, cependant, il faut respecter plusieurs conditions drastiques pour qu'il le soit réellement. Dans ce TP, vous exploiterez les faiblesses d'une mauvaise utilisation d'OTP. Afin de chiffrer le fichier chiffre, nous avons utilisé le programme suivant :

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

/* Le programme prend en paramètres :
  - Un fichier d'entrée à chiffrer
  - Un fichier de destination (dont le contenu est perdu s'il existe)
  - Un fichier d'enregistrement de la clé
 */

int main(int argc, char* argv[]) {
  size_t size, buffsize, i;
  int buffer[1024/sizeof(int)];
  FILE* input, *output, *key;
  int rv;

  if (argc<4) {
    fprintf(stderr, "Usage: %s <input file> <output file> <key output file>\n", argv[0]);
    return EXIT_FAILURE;
  }

  /* Ouverture des fichiers. */
  input = fopen(argv[1], "r");
  output = fopen(argv[2], "w");
  key = fopen(argv[3], "w");
  
  if (!input || !output || !key) {
    fprintf(stderr, "Error opening file...\n");
    return EXIT_FAILURE;
  }

  /* Initialisation du générateur de nombres pseudo-aléatoires. */
  /* On utilise la date et l'heure comme "graine" du générateur. */
  srand(time(NULL));
  
  while (!feof(input)) {
    buffsize = fread(buffer, 1, 1024, input);
    for (i=0; i<buffsize/sizeof(int); ++i) {
      rv = rand();
      fwrite(&rv, 1, sizeof(int), key);
      buffer[i] ^= rv;
    }
    fwrite(buffer, buffsize, 1, output);
  }
  fclose(input);
  fclose(output);
  fclose(key);
  return EXIT_SUCCESS;
}

Sachant que le fichier a été chiffré le 21/10/2015 un peu après 16h45, trouvez la clé et déchiffrez le texte.

Cette fois, pour chiffrer le message, on s'est servi du code suivant et d'une clé de 64 bits appliquée en mode ECB.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char* argv[]) {
  FILE* input, *output, *keyfile;
  size_t keysize, chunksize, i;
  char* key, *buffer;
  
  if (argc < 3) {
    fprintf(stderr, "Usage: %s <input file> <output file> <key file>\n", argv[0]);
    return EXIT_FAILURE;
  }
  
  input = fopen(argv[1], "r");
  output = fopen(argv[2], "w");
  keyfile = fopen(argv[3], "r");
  
  if (!input || !output || !keyfile) {
    fprintf(stderr, "Error opening file...\n");
    return EXIT_FAILURE;
  }
  
  fseek(keyfile, 0, SEEK_END);
  keysize = ftell(keyfile);
  fseek(keyfile, 0, SEEK_SET);
  
  key = (char*) malloc(keysize);
  buffer = (char*) malloc(keysize);
  
  if (!key) {
    fprintf(stderr, "Unable to allocate memory (key too large?)\n");
    return EXIT_FAILURE;
  }
  
  fread(key, 1, keysize, keyfile);
  fclose(keyfile);
  
  while (!feof(input)) {
    chunksize = fread(buffer, 1, keysize, input);
    for (i=0; i<chunksize; ++i) {
      buffer[i] ^= key[i];
    }
    fwrite(buffer, 1, chunksize, output);
  }
  fclose(input);
  fclose(output);
  return EXIT_SUCCESS;
}

Sachant que le fichier chiffré ne contenait avant chiffrement que les caractères “ ,.;abcdefghijlmnopqrstuvx\n”, trouvez la clé de chiffrement utilisée.

OpenSSL