1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "devoir1.h"
char *lettres = "abcdefghijklmnopqrstuvwxz";
char *encrypt(char *message, char *key) {
int keylength = strlen(key);
int messlength = strlen(message);
int nrows = ceil(messlength*1.0/keylength);
/* allocation d'un tableau pour stocker le message déchiffré */
char *tab = malloc((nrows*keylength+1)*sizeof(char));
if (!tab) {
printf("Erreur d'allocation de mémoire dans encrypt\n");
exit(-1);
}
/* remplissage du vecteur selon la règle */
int i;
for (i = 0; i < messlength; i++)
tab[(i % keylength)*nrows+(i/keylength)] = message[i];
/* remplissage de la fin aléatoirement */
for (; i < nrows*keylength; i++)
tab[(i % keylength)*nrows+(i/keylength)] = lettres[rand() % 26];
tab[i] = '\0';
/* rotation des colonnes selon la clé */
for (i = 0; i < keylength; i++) {
rotate(tab+i*nrows, (key[i]-'m'), nrows);
}
return tab;
}
int search_pattern(char *pattern, char *message) {
int n,i,j;
int messlenght = strlen(message);
int pattlenght = strlen(pattern);
for (i=0,j=0;i<messlenght && j<pattlenght;i++)
{
if(message[i]==pattern[j])
{
if(j==0)
{n=i;
}
j=j+1;
}
if(message[i]!=pattern[j])
{j=0;
n=0;
}
}
if (j==pattlenght) /* Si la clé à été trouvée alors j aura été incrémenté jusqu'à ce que
j soit égal à la taille du pattern. */
return n; /* On retourne l'emplacement du message où j vaut 0 */
else
return -1;
}
char *decrypt(char *message, char *key) {
int keylength = strlen(key);
int messlength = strlen(message);
int nrows = ceil(messlength*1.0/keylength);
/* allocation d'un tableau pour stocker le message chiffré*/
char *tab = malloc((nrows*keylength+1)*sizeof(char));
/* rotation des colonnes selon la clé */
int i;
for (i = 0; i < keylength; i++) {
rotate(message+i*nrows, (-1)*(key[i]-'m'), nrows);
}
/* On remet les les caractère dans l'ordre selon la règle */
for (i = 0; i < messlength; i++)
{
tab[i] = message[(i % keylength)*nrows+(i/keylength)];
}
return tab;
}
char *test_all_key_permutations(char *encmessage, char *pattern, char *key) {
int keylenght = strlen(key);
char tab = decrypt(encmessage,key);
while (search_pattern(pattern,tab)== (-1))
{
key = permut(key,0,keylenght);
tab = decrypt(encmessage,key);
}
return key;
}
void swap(char *a, char *b){
char c;
c = *a;
*a = *b;
*b = c;
}
char *permut(char*a,int l,int r)
{
if (l==r)
{return a;
}
else
{
int i;
for(i=0;i<=r;i++)
{
swap((a+1),(a+i));
permut(a,l+1,r);
swap((a+1),(a+i));
}
}
}
void rotate(char *arr, int d, int n) {
char *T = malloc(n*sizeof(char));
int i;
while (d<=(-1)*n || d>=n)
{
/* Si le déplacement demander est plus grand que la taille de la chaine
alors on peut remplacer ce deplacement par le reste de ca division par la taille
de la chaine */
d = d%n;
}
for(i = 0; i<n; i++)
{
T[i]= arr[i];
}
for(i=0; i<n;i++)
{
if ((i-d)<0) /* Cas ou le déplacement nous fait sortir des limites par la gauche */
{
arr[i] = T[n+i-d];
}
if ((i-d)>(n-1)) /* Cas où le deplacement nous fait sortir des limites par la droite */
{
arr[i] = T[i-d-n];
}
if ((i-d)>=0 && (i-d)<=n-1) /* Cas de base */
{
arr[i] = T[i-d];
}
}
free(T);
} |
