Somme précise en ASCII

Version imprimable

Bonsoir à tous,

Je suis actuellement étudiant en sécurité informatique et plus précisément en software engineering. L'une de nos compétences étant d'appréhender le fonctionnement de chaque programme en détail, nous sommes parfois confrontés à des sortes de défis, qu'on appelle régulièrement des 'CTF'.

L'un des CTF était de trouver une clé précise pour le programme. Pour faire simple : pour gagner le CTF, on devait entrer la bonne clé.
Bref après quelques bidouillages (inutile de vous poster le code, c'est en assembleur et je pense que certains ne maîtrisent pas ici :/) j'ai eu quelques indices :

- La clé doit faire au moins 5 de longueur
- Le premier caractère de la clé doit être un ASCII aléatoire entre 32 et 128
- Le second caractère est un '@'
- et enfin le troisième, quatrième et cinquième doivent être la somme (en ASCII) équivalentes toutes les trois à 300

On nous a demandé le tout de faire un programme trouvant toutes les combinaisons possibles pour la clé, en C et en python. J'ai réussi la partie python assez facilement (2 ans que je l'étudie), mais le C que nous venons de commencer il y a deux semaines je bloque un peu.

J'ai essayé de chercher comment faire la somme de tous les ASCII sur des fofo anglais mais j'ai rien trouvé qui puisse m'aider
Pour l'étape 1,2 et 3, j'ai bien réussi :
Code:

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 #include <stdio.h> #include <stdlib.h> #include <time.h> #include <string.h> #define ASCII_S 32 #define ASCII_E 126 char* genString(size_t length) { int i; char* toGen = malloc(length + 1); for(i=0;i<length;++i) { toGen[i] = (char)(rand()%(ASCII_E-ASCII_S))+ASCII_S; } toGen[i] = '\0'; return toGen; } char* genSecondLength(char* string) { char toAdd = '@'; strncat(string,&toAdd,1); // printf("%s",string); return string; } int main(void) { srand(time(NULL)); char *firstLengthKey = genString(1); genSecondLength(firstLengthKey); }
Voilà, si quelqu'un pouvait me donner un indice parce que là je bloque totalement :(

PS : La partie Python est la suivante :
Code:

1 2 3 4 5 6 7 8 9 10 import random charset = 'abcdefgijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_-+|`~?/.,' key = charset[random.randint(0, len(charset) - 1)] key += '@' key2 = "" while len(key2) == 0 or key2[-1] not in charset: key2 = charset[random.randint(0, len(charset) - 1)] key2 += charset[random.randint(0, len(charset) - 1)] key2 += chr(300 - ord(key2[-1]) - ord(key2[-2])) print(key + key2)
Merci à tous

05/04/2020, 00h20
fxlxnn
Rebonjour!

Je pense avoir une piste :
Code:

1 2 3 4 5 6 7 char *gen = genString(3); for(int k=0;k<4000;++k) { if(gen[1] + gen[2] + gen[3] == 300) { printf("%s",gen); } }
malgré que cela ne m'affiche rien. Mais là j'ai l'impression de comparer directement des caractères et non leur valeur, un cast peut-être ?
Désolé pour mes questions débiles j'avoue que j'aurais du peut-être relire mes cours :D

En C, un caractère ASCII est juste un entier sur 7 bits (valeur entre 0 et 127) et donc on s'en fiche du type, signé ou pas. Dans la librairie C c'est un int. Moi je préfère unsigned char, pour l'UTF-8 :mrgreen:
En C, il y a une différence entre les double quotes et les simple quotes. Les double quotes sont pour les chaînes de caractères "Hello World". Alors que les simple quotes, seulement pour 1 simple caractère 'A' qui est juste un code ASCII.
Donc coder int c = 53 ou int c = '5' est équivalent ... mais 1 est + pratique :zoubi:
Pour mettre en minuscule en C : if ((c >= 'A') && (c <= 'Z')) { c -= ('A' + 'a'); } : on teste si le caractère est majuscule (entre A et Z inclus) et on retranche A et on ajoute a (les codes ASCII des lettres sont dans l'ordre alphabétique). C'est ultra-simple :wow:

Ensuite, une petite précision, comme ta clef a une taille fixe 5, seulement un tableau suffit. Et même :mrgreen:, si elle n'avait pas de taille fixe, 1 solution en C c'est de trouver la taille "assez large" pour ne pas déborder ... afin d'éviter l'allocation dynamique malloc/ free même si cela permet une meilleure gestion de la mémoire.
Donc int key[5] = {0};.

"Le premier caractère de la clé doit être un ASCII aléatoire entre 32 et 128"
Le code ascii termine à 127. Le code 128 n'existe pas :mrgreen: À toi de vérifier avec une table s'il ne faut pas faire un décalage (+ 1)
Code:

1 2 3 unsigned char ascii_code; for(ascii_code=32; ascii_code < 128; ++ascii_code) { key[0] = ascii_code; }
"Le second caractère est un '@'"
key[1] = '@';.

"le troisième, quatrième et cinquième doivent être la somme (en ASCII) équivalentes toutes les trois à 300"
En brute force :aie: :aie:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 unsigned char ascii_code1, ascii_code2, ascii_code3; for(ascii_code1=0; ascii_code1 < 128; ++ascii_code1) { for(ascii_code2=0; ascii_code2 < 128; ++ascii_code2) { for(ascii_code3=0; ascii_code3 < 128; ++ascii_code3) { if ((ascii_code1 + ascii_code2 + ascii_code3) == 300) { // found key[2] = ascii_code1; key[3] = ascii_code2; key[4] = ascii_code3; } } } }

Salut !

Merci de ta réponse détaillée, j'ai pu corriger plusieurs trucs et j'ai supprimé mes deux fonctions inutile (j'avoue que c'est plus simple de faire key[1] = '@' que faire un strncat ...)

J'ai tout implémenter dans une fonction du coup :
Code:

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 #include <stdio.h> #include <stdlib.h> #include <time.h> #include <string.h> char *genSolution(void) { unsigned char ascii_code,ascii_code1, ascii_code2, ascii_code3; int key[5] = {0}; for(ascii_code=32; ascii_code < 128; ++ascii_code) { key[0] = ascii_code; } key[1] = '@'; for(ascii_code1=0; ascii_code1 < 128; ++ascii_code1) { for(ascii_code2=0; ascii_code2 < 128; ++ascii_code2) { for(ascii_code3=0; ascii_code3 < 128; ++ascii_code3) { if ((ascii_code1 + ascii_code2 + ascii_code3) == 300) { key[2] = ascii_code1; key[3] = ascii_code2; key[4] = ascii_code3; } } } } return (char*)key; } int main(void) { srand(time(NULL)); printf("%s",genSolution()); }
Le seul truc que je comprends pas, c'est l'affichage D:
J'ai l'impression que ton code ne génère que des chiffres, alors que le code ASCII peut très bien comporter des lettres (minuscule/majuscule)
Et quand j'essaye de compiler ça me met '(null)'

En fait ce que je comprends pas c'est l'affichage en char de quelque chose qui est en int (int key)...

Merci!

05/04/2020, 00h48
foetus

Une chaîne de caractère en C doit être terminée par le caractère final/ sentinelle '\0' Si tu l'affiches avec le format %s, cela ne va pas fonctionner - tu vas afficher ta clef + ce qui suit jusqu'au caractère '\0' :aie: :aie:

Donc 2 solutions.
Soit tu affiches caractère par caractère : printf("key: %c%c%c%c%c\n", key[0], key[1], key[2], key[3], key[4]); avec le format %c pour afficher 1 caractère. (et éventuellement tu peux faire une boucle pour l'affichage)

Soit il faut créer ta clef avec 1 caractère de + pour le caractère final/ sentinelle int key[6] = {0};.

Document officielle de la fonction printf pour tous les formats (<- lien cplusplus.com en anglais)

Si cela te fais NULL, c'est parce que tu retournes une variable locale qui est détruite à la fin de l'appel :aie: :aie: il faut lire les cours
05/04/2020, 00h50
fxlxnn

En fait pour être plus clair, je comprends pas comment on pourrait print la solution parce que :

la clé est de type int

key[0] peut être soit une lettre soit un chiffre soit un caractère illisible (du genre ?,'%#...)
key[1] est un caractère illisible aussi (@)
key[2] key[3] key[4] peuvent être tous les trois soit un ensemble de chiffres, soit des lettres également

Ce que je comprends pas , c'est comment on va print ça ?

On peut pas faire

Code:

printf("%d",key)

parce que dans ce cas là on aura que des chiffres, en plus, comment on forcera l'affichage du '@' ? (et qui nous dit que la solution comporte uniquement des chiffres

Bref je nage dans l'ambiguité totale sur ce concept en C, si tu pouvais m'aider ^^

Merci à toi

Un code à l'arrache non optimisé "brute force" :mrgreen: ... qui fonctionne mais peut avoir des parties à revoir/ boguées :wow:
Pour l'affichage :wow:, il faut utiliser la version échappée pour les caractères non imprimables ... qui est + ou - standard. Table of escape sequences en C, lien wiki en anglais.

Le code est un peu long, parce que j'ai créé un tableau de codes dynamique, et on ajoute code par code ... avec un type code assez flexible.
Si tu respectes l'interface, tu n'as pas besoin de te prendre la tête avec les allocations dynamiques et autres ... tu peux te concentrer sur l'algo de génération de code :zoubi: (<- du moins dans 1 premier temps et/ ou si le code est correct)
Il y a 326688 codes au final :whistle:

Code:

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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
#include <stdio.h>
#include <stdlib.h> /* srand, rand */
#include <time.h>   /* time */
#include <string.h> /* memset */
 
 
#define G_LIST_KEYS_CHUNK 7
 
 
typedef unsigned char t_code;
 
 
typedef struct s_one_key {
    t_code val[5];
} t_one_key;
 
 
typedef struct s_list_keys {
    t_one_key* list;
 
    size_t capacity;
    size_t nb_keys;
} t_list_keys;
 
 
/* Forward Declarations */
 
/* XXX: pos is 1-based */
void one_key_add(t_one_key*, t_code, size_t pos);
 
void one_key_copy(t_one_key*, t_one_key*);
 
void one_key_print(t_one_key*);
 
unsigned char one_key_test_printable(t_one_key*);
 
unsigned char one_key_test_valid(t_one_key*);
 
void one_key_reset(t_one_key*);
 
 
unsigned char list_keys_add_one_key(t_list_keys*, t_one_key*);
 
void list_keys_delete(t_list_keys*);
 
/* XXX: pos is 1-based */
unsigned char list_keys_get_key(t_list_keys*, t_one_key*, size_t pos);
 
size_t list_keys_get_nb_keys(t_list_keys*);
 
void list_keys_init(t_list_keys*);
 
void list_keys_print(t_list_keys*);
 
 
unsigned char generate_keys(t_list_keys* list) {
    unsigned char is_ok;
 
    if (list != NULL) {
        t_one_key key;
        t_code code1, code3, code4, code5;
 
        one_key_reset(&key);
        one_key_add(&key, '@', 2);
 
        is_ok = 1;
 
        for(code1=32; (is_ok && (code1 < 128)); ++code1) {
            for(code3=0; (is_ok && (code3 < 128)); ++code3) {
                for(code4=0; (is_ok && (code4 < 128)); ++code4) {
                    for(code5=0; (is_ok && (code5 < 128)); ++code5) {
 
                        if ((code3 + code4 + code5) == 300) {
                            one_key_add(&key, code1, 1);
                            one_key_add(&key, code3, 3);
                            one_key_add(&key, code4, 4);
                            one_key_add(&key, code5, 5);
 
                            if ( list_keys_add_one_key(list, &key) ) {
                                one_key_reset(&key);
                                one_key_add(&key, '@', 2);
                            } else {
                                is_ok = 0;
                            }
                        }
                    }
                }
            }
        }
    } else {
        is_ok = 0;
    }
 
    return is_ok;
}
 
 
/*****************************************************************************/
 
int main(int argc, char* argv[])
{
    t_list_keys list;
 
    list_keys_init(&list);
 
    if ( generate_keys(&list) ) {
        size_t nb_keys;
 
        list_keys_print(&list);
 
        nb_keys = list_keys_get_nb_keys(&list);
 
        printf("\ngenerate_keys - found %lu key%s", nb_keys, ((nb_keys > 1)? "s\n": "\n"));
 
        if (nb_keys > 10) {
            t_one_key key;
            size_t keyX;
 
            printf("\nList of random keys:\n");
 
            srand( time(NULL) );
 
            for(keyX=1; keyX <= 10; ++keyX) {
                printf("- key %02lu: ", keyX);
 
                if ( list_keys_get_key(&list, &key, (rand() % nb_keys + 1)) ) {
                    one_key_print(&key);
                    printf("\n");
                } else {
                    printf("[error]\n");
                }
            }
        }
    } else {
        printf("main - error : generate_keys\n");
    }
 
    list_keys_delete(&list);
 
 
    return EXIT_SUCCESS;
}
 
 
/*****************************************************************************/
 
/* XXX: pos is 1-based */
void one_key_add(t_one_key* key, t_code c, size_t pos) {
    if ((key != NULL) && (c < 128) && (pos > 0) && (pos <= 5)) {
        key->val[pos - 1] = c;
    }
}
 
 
void one_key_copy(t_one_key* from, t_one_key* to) {
    if ((from != NULL) && (to != NULL)) {
        memcpy(to, from, sizeof(t_one_key));
    }
}
 
 
void one_key_print(t_one_key* key) {
    if (key != NULL) {
        size_t codeX;
        t_code code;
 
        for(codeX=0; codeX < 5; ++codeX) {
            code = key->val[codeX];
 
            if ((code >= 33 /* '!' */) && (code <= 126 /* '~' */)) { // printable characters without space/ 32, 0x20
                printf("%c", code);
            } else {
                printf("\\x%x", code);
            }
        }
    }
}
 
 
unsigned char one_key_test_printable(t_one_key* key) {
    unsigned char is_ok;
 
    if (key != NULL) {
        size_t codeX;
        t_code code;
 
        for(codeX=0, is_ok=1; (is_ok && (codeX < 5)); ++codeX) {
            code = key->val[codeX];
 
            if ((code < 32 /* ' ' */) || (code > 126 /* '~' */)) {
                is_ok = 0;
            }
        }
 
    }
 
    return is_ok;
}
 
 
unsigned char one_key_test_valid(t_one_key* key) {
    unsigned char is_ok;
 
    if (key != NULL) {
        size_t codeX;
 
        for(codeX=0, is_ok=1; (is_ok && (codeX < 5)); ++codeX) {
            if (key->val[codeX] > 127) {
                is_ok = 0;
            }
        }
 
    }
 
    return is_ok;
}
 
 
void one_key_reset(t_one_key* key) {
    if (key != NULL) {
//      0XFF is an invalid ASCII code
        memset(key, 0xFF, (5 * sizeof(t_code)));
    }
}
 
 
/*****************************************************************************/
 
unsigned char list_keys_add_one_key(t_list_keys* list, t_one_key* one_key) {
    unsigned char  ret;
 
    if ((list != NULL) && (one_key != NULL)) {
        if (list->capacity < (list->nb_keys + 1)) {
            t_one_key* tmp = realloc(list->list, sizeof(t_one_key) * (G_LIST_KEYS_CHUNK  + list->capacity));
 
            if (tmp != NULL) {
                list->list      = tmp;
                list->capacity += G_LIST_KEYS_CHUNK;
 
                ret = 1;
            } else {
                ret = 0;
            }
        } else {
            ret = 1;
        }
 
        if (ret) {
            one_key_copy(one_key, (list->list + list->nb_keys));
 
            ++(list->nb_keys);
        }
    } else {
        ret = 0;
    }
 
    return ret;
}
 
 
void list_keys_delete(t_list_keys* list) {
    if (list != NULL) {
        if (list->list != NULL) { free(list->list); }
 
        list_keys_init(list);
    }
}
 
 
/* XXX: pos is 1-based */
unsigned char list_keys_get_key(t_list_keys* list, t_one_key* key, size_t pos) {
    unsigned char ret;
 
    if ((list != NULL) && (key != NULL) && (pos > 0) && (pos <= list->nb_keys)) {
        one_key_copy((list->list + pos - 1), key);
 
        ret = 1;
    } else {
        ret = 0;
    }
 
    return ret;
}
 
 
size_t list_keys_get_nb_keys(t_list_keys* list) {
    size_t nb_keys;
 
    if (list != NULL) {
        nb_keys = list->nb_keys;
    } else {
        nb_keys = 0;
    }
 
    return nb_keys;
}
 
 
void list_keys_init(t_list_keys* list) {
    if (list != NULL) {
        list->list     = NULL;
        list->capacity = 0;
        list->nb_keys  = 0;
    }
}
 
 
void list_keys_print(t_list_keys* list) {
    if (list != NULL) {
        t_one_key* code;
        size_t key, nb_keys;
        int nb_digits;
 
        nb_digits = 0;
        nb_keys   = list->nb_keys;
 
        while (nb_keys > 9) {
            ++nb_digits;
            nb_keys /= 10;
        }
 
        ++nb_digits;
        nb_keys = list->nb_keys;
 
        for(key=0; key < nb_keys; ++key) {
            code = (list->list + key);
 
            printf("Key %*lu: ", nb_digits, (key + 1));
            one_key_print(code);
 
            if ( one_key_test_valid(code) ) {
                printf("%s", (( one_key_test_printable(code) )? " [printable]\n": "\n"));
            } else {
                printf(" [invalid]\n");
            }
        }
    }
}

Édit 1 : Mon allocation dynamique était fausse (:aie:), j'ai rajouté une petite gestion d'erreur et 2 tests (si le code est valide et s'il est affichable) (par contre l'espace est affiché en hexadécimal \x20)

Édit 2 : Ajout d'un accesseur de clef, avec un affichage aléatoire de 10 clefs (mais il faut lire la documentation de rand qui dit que le modulo n'est pas terrible pour de l'aléatoire :wow:)

Bonjour,

En ne considérant pas le caractère 127 car il n'est pas affichable, on trouve plus que 300200 combinaisons.

Code:

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
#include <stdio.h>
 
int main()
{
	char  txt[5+1] = {'\0'};
	const int  charMin = 0x20;
	const int  charMax = 0x7e;
	int  compteur = 0;
 
	for ( int  c0 = charMin ; c0 <= charMax ; ++c0 ) {
		for ( int  c2 = charMin ; c2 <= charMax ; ++c2 ) {
			for ( int  c3 = charMin ; c3 <= charMax ; ++c3 ) {
				int  c4 = 300 - c2 - c3;
				if ( c4 < charMin  ||  c4 > charMax )
					continue;
				txt[0] = (char)c0;
				txt[1] = '@';
				txt[2] = (char)c2;
				txt[3] = (char)c3;
				txt[4] = (char)c4;
				//printf( "%s\t", txt );
				++compteur;
			}
		}
	}
	printf( "\nnb de codes : %d\n", compteur );
}

07/04/2020, 21h11
Sve@r

Bonjour

Citation:

Envoyé par fxlxnn

En fait pour être plus clair, je comprends pas comment on pourrait print la solution parce que :

la clé est de type int

key[0] peut être soit une lettre soit un chiffre soit un caractère illisible (du genre ?,'%#...)
key[1] est un caractère illisible aussi (@)
key[2] key[3] key[4] peuvent être tous les trois soit un ensemble de chiffres, soit des lettres également

Il te faut comprendre les fondamentaux et la réponse viendra d'elle-même.
Un char c'est un nombre compris entre 0 (0x00) et 255 (0xff). En faisant correspondre ce nombre avec une table de référence (la table ascii) on obtient un caractère. Par exemple le nombre 48 (ou 0x30) est référencé comme le caractère '0'. Autre exemple le nombre 97 (0x61) est référencé comme le caractère 'a'.
Et (parenthèse) c'est parce que notre alphabet a été reproduit à l'identique dans la table ascii que les opérations sur les caractères tombent juste. Ainsi 'a' + 1 donnera 97 + 1 soit 98 qui, comme par hasard, est référencé comme le caractère 'b' ce qui autorise le raccourci 'a' + 1 = 'b' qui, si on inverse les membres de l'équation, devient alors 'b' - 'a' = 1.

Ensuite il y a printf(). C'est une fonction qui est capable si on lui demande d'afficher non pas le nombre mais sa représentation ascii (il suffit de demander le format "%c").
Donc toutes tes key[x] ce ne sont que des nombres. Et selon la façon dont tu les affiches, tu auras soit des nombres à l'écran soit les caractères ascii correspondants.

Citation:

Envoyé par fxlxnn

Ce que je comprends pas , c'est comment on va print ça ?

En le demandant à printf(). Le seul souci c'est que dans les 255 caractères ascii certains ne sont pas représentables à l'écran (le caractère "Escape" par exemple). Donc si une de tes key[x] contient un tel caractère, ça te fera une couille à l'écran. Toutefois tu as à ta disposition la fonction isprint() qui te dit si le caractère qu'elle reçoit est ou n'est pas affichable. Donc une boucle, un test et une décision et c'est réglé.
19/04/2020, 22h17
Bayard

Au niveau du code posté par foetus:

Code:

if (list->capacity < (list->nb_keys + 1)) {

La variable list->capacity est utilisée sans avoir été initialisée.

Bonne soirée.
19/04/2020, 22h35
foetus

Citation:

Envoyé par Bayard

La variable list->capacity est utilisée sans avoir été initialisée.

Explique moi comment tu as eu cette affirmation :koi: un avertissement du compilateur ? un plantage ? au doigt mouillé ?

Parce que c'est normal :wow: c'est la fonction qui list_keys_init qui initialise la structure - elle fait office de constructeur.
Et elle est appelée en premier - et sa précondition if (list != NULL) est valide.
19/04/2020, 22h51
Bayard

Bonsoir

Au temps pour moi.
Je m'excuse, j'ai mal relu.
Bonne soirée.

Cordialement