Un code obfusqué que je n'arrive pas à comprendre

Je suis tombé par hasard sur ce code qui donne les nombres premiers strictement inférieur à 100:

Code:

---

1 2 3

_(__,___,____){___/__<=1?_(__,___+1,____):!(___%__)?_(__,___+1,0):___%__==___/   __&&!____?(printf("%d\t",___/__),_(__,___+1,0)):___%__>1&&___%__<___/__?_(__,1+ ___,____+!(___/__%(___%__))):___<__*__?_(__,___+1,____):0;}main(){_(0x64,0,0);}

---

trouvé ici : http://fr.wiktionary.org/wiki/obfuscation

Mais je ne comprends rien. C'est quoi tout ces '__' et tout ces ?%> , etc...
Comment ça se fait que ça se compile?

Merci d'avance.

J'ai l'impression que c'est un "code a trou". En gros faut que tu remplaces les '_'. Cependant ca me parait bizarre. Si ce n'est pas le cas je serais ravi d'avoir l'explication aussi. ;)

Il doit manquer des déclarations et/ou utiliser des petites fonctionnalités offertes par certains compilos.

Chaque _ est une variable...
Il faut "bien regarder", mais _ (1 underscore) n'est pas la même variable que __ (2 underscores collés).

L'obfuscation utilise déjà des variables difficiles à différencier par leur nom "avec nos yeux humains".

Les "? :" ce des ternaires, une autre façon de coder un if/then/else.

les > et < sont des décalages de bits il me semble.
Et le % est le "mod"/modulo d'un nombre.

EDIT : je crois qu'il y a 4 variables cachées : 1 _, 2 _, 3 _ et 4 _.

EDIT2 : en ayant "recomposé" le code ça donne :

Code:

---

1 2 3 4 5 6 7 8 9 10

myfunc(__, var3, var4) { var3 /__ <= 1 ? myfunc(__,var3+1,var4) : ! (var3 % __) ? myfunc(__, var3 + 1, 0) : var3 % __ == var3 / __ && ! var4 ? (printf("%d\t", var3 / __), myfunc(__, var3 + 1, 0)) : var3 % __ > 1 && var3 % __ < var3 / __ ? myfunc(__, 1 + var3, var4 + ! (var3 / __ % (var3 % __))) : var3 < __ * __ ? myfunc(__, var3 + 1, var4) : 0;   }   main() { myfunc(0x64, 0, 0); }

---

EDIT3 : et avec des if/then/else :

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

myfunc(__, var3, var4) { if (var3 / __ <= 1) myfunc(__, var3 + 1, var4); else { if (!(var3 % __)) myfunc(__, var3 + 1, 0); else { if (var3 % __ == var3 / __ && !var4) { printf("%dt", var3 / __); myfunc(__, var3 + 1, 0); } else { if (var3 % __ > 1 && var3 % __ < var3 / __) myfunc(__, 1 + var3, var4 + !(var3 / __ % (var3 % __))); else { if (var3 < __ * __) myfunc(__, var3 + 1, var4); else 0; } } } } }   main() { myfunc(0x64, 0, 0); }

---

EDIT4 :
Tu comprendras ainsi que....
1) jouer avec des _ en noms de variables ça obfusque pas mal le code déjà... difficile de dire combien il y a de _ à première vue ! :P
2) ...simplement mettre un terme useless tel que "var1", "var2", ... suffit pour ne pas comprendre à quoi sert cette variable.... car là, si tu me dis que ça coule de source pour toi ce que le code fait... bravo, tu ne devrais même pas poster dans la section "débutant" ! :D

Morale : nomme BIEN tes variables pour permettre à d'autre de réutiliser... ou utilise des _ pour que plus personne ne puisse le reprendre.

Le code est, dans l'état actuel du C, incorrect :

1- La définition de la fonction _ ne comporte pas le type des paramètres __ , ___, ____ .

2- La déclaration des fonctions _ et main ne spécifie pas le type de retour

3- Il est fait amplement usage de l'opérateur ternaire ?: sous la forme "condition ? val1 : val2" où parfois val1 ou val2 est un appel (récursif) à la fonction _ . Celle-ci doit donc renvoyer une valeur mais elle ne comporte pas de return. (Cette restriction n'existe pas dans une configuration if then else)

Code:

---

1 2 3

int _(int __,int ___,int ____){return ___/__<=1?_(__,___+1,____):!(___%__)?_(__,___+1,0):___%__==___/   __&&!____?(printf("%d\t",___/__),_(__,___+1,0)):___%__>1&&___%__<___/__?_(__,1+ ___,____+!(___/__%(___%__))):___<__*__?_(__,___+1,____):0;}int main(){_(0x64,0,0); return 0;}

---

devrait être compilable (si on ajoute l'include de <stdio.h>).

Citation:

---

Envoyé par dafpp

Mais je ne comprends rien. C'est quoi tout ces '__' et tout ces ?%> , etc...
Comment ça se fait que ça se compile?

---

En fait, pour lire ce code, il faut que tu fasses l'inverse de l'obfuscation.

Comment obfusquer un code ?
Rennomer toutes les variables par des noms de variables valables en C, mais difficilement lisibles par l'humain. Ici, _ est une variable, __ (2 underscore) en est une autre, etc --> c'est difficile a lire pour toi, mais pour le compilateur, c'est aussi clair que ma_variable_de_boucle, ...
Piege 1 : _ est un nom de fonction, pas de variable !
Ensuite enleve tout ce qui est mots-clefs, autant que possible. Par exemple :
#define __ for te permettre d'ecrire __ (;0;);{_(___);} au lieu de for (;0;) ; { ma_fonction (mon_entier);}D'ailleurs, si tu remarques bien, il y a un ; apres ma boucle for : c'est pour faire croire que l'appel a ma_fonction est dans la boucle alors que ce n'est pas le cas : c'est l'instruction vide qui est dans la boucle (et d'ailleurs on ne rentre pas dans la boucle), et l'appel a la fonction se fait une seule fois.

Petit a petit, tu arriveras a retrouver un code a peu pres clair. En melangeant les deux solutions deja proposees, on trouve le code suivant :

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>   int myfunc(int myvar, int var3, int var4) { if (var3 / myvar <= 1) myfunc(myvar, var3 + 1, var4); else { if (!(var3 % myvar)) myfunc(myvar, var3 + 1, 0); else { if (var3 % myvar == var3 / myvar && !var4) { printf("%d\t", var3 / myvar); myfunc(myvar, var3 + 1, 0); } else { if (var3 % myvar > 1 && var3 % myvar < var3 / myvar) myfunc(myvar, 1 + var3, var4 + !(var3 / myvar % (var3 % myvar))); else { if (var3 < myvar * myvar) myfunc(myvar, var3 + 1, var4); else return 0; } } } } }   int main(void) { myfunc(100, 0, 0); }

---

Citation:

---

Envoyé par dafpp

Mais je ne comprends rien. C'est quoi tout ces '__' et tout ces ?%> , etc...
Comment ça se fait que ça se compile?

Merci d'avance.

---

Salut
Pour plus d'infos, tu peux aller voir ici http://fr.wikipedia.org/wiki/Interna...C_Code_Contest :aie: :ccool:

Citation:

---

Envoyé par diogene

Le code est, dans l'état actuel du C, incorrect

---

Beaucoup de compilateurs acceptent cependant ce code qui est valide pour les standards plus anciens que le C99, standard à partir duquel le typage implicite "int" a été supprimé.

C'est vrai, mais il y a un warning pour te le signaler normalement ;)

C'est vrai avec la plupart des compilateurs C, mais gcc qui est sans doute l'un des plus utilisés requiers une option pour afficher ces warnings:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

$ cc b.c "b.c", line 1: warning: old-style declaration or incorrect type for: _ "b.c", line 1: warning: no explicit type given for parameter: __ "b.c", line 1: warning: no explicit type given for parameter: ___ "b.c", line 1: warning: no explicit type given for parameter: ____ "b.c", line 3: warning: implicit function declaration: printf "b.c", line 3: warning: old-style declaration or incorrect type for: main $ gcc b.c $ gcc -std=c99 b.c b.c:1: warning: return type defaults to `int' b.c: In function `_': b.c:1: warning: type of "__" defaults to "int" b.c:1: warning: type of "___" defaults to "int" b.c:1: warning: type of "____" defaults to "int" b.c:3: warning: implicit declaration of function `printf' b.c: At top level: b.c:3: warning: return type defaults to `int'

---

je l'ai refais de mon côté, et j'ai mieux compris.
J'essaie pas d'imaginer ce qu'ils peuvent faire certaines entreprises pour rendre très difficile la rétro-ingénierie. Il doit avoir des algos qui font ça je suppose?

Merci pour toutes ces précisions.

Citation:

---

Envoyé par dafpp

je l'ai refais de mon côté, et j'ai mieux compris.
J'essaie pas d'imaginer ce qu'ils peuvent faire certaines entreprises pour rendre très difficile la rétro-ingénierie. Il doit avoir des algos qui font ça je suppose?

---

Ce ne sont pas des algos mais des logiciels qui prennent un code source, analysent chaque variable et chaque fonction puis les remplacent par des noms de variables type aaa01 aaa02 etc...

Ce qui n'empêche pas que quand on veut vraiment passer outre on peut toujours. Je me souviens Assassin's Creed I. Ils avaient annoncé que ce serait le jeu impiratable de chez les impiratables; avec connexion internet obligatoire pour pouvoir jouer. Une semaine après, le crack sortait sur les réseaux parallèles...

L'intention d’embêter est présente, donc c'est toujours crackable, mais c'est surtout pénible (je suppose) à faire.

Citation:

---

Ce qui n'empêche pas que quand on veut vraiment passer outre on peut toujours. Je me souviens Assassin's Creed I. Ils avaient annoncé que ce serait le jeu impiratable de chez les impiratables; avec connexion internet obligatoire pour pouvoir jouer. Une semaine après, le crack sortait sur les réseaux parallèles...

---

Faire ce genre d'annonce est la dernière chose à faire son l'on veut que son produit reste inviolé longtemps ! :mouarf:

Citation:

---

Envoyé par jlliagre

C'est vrai avec la plupart des compilateurs C, mais gcc qui est sans doute l'un des plus utilisés requiers une option pour afficher ces warnings:

Code:

---

1 2 3 4 5 6 7 8

$ cc b.c ... "b.c", line 3: warning: old-style declaration or incorrect type for: main $ gcc b.c $ gcc -std=c99 b.c b.c:1: warning: return type defaults to `int' ... b.c:3: warning: return type defaults to `int'

---

---

Par défaut, gcc compile implicitement avec l'option -std=gnu90 (=gnu89) et il est très plausible que cette extension accepte les retours implicites.

J'ai entendu dire qu'en C89 :
- pour une fonction sans type, le compilateur suppose qu'il s'agit d'une fonction renvoyant un int
- le main, sans return, renvoie la valeur de la dernière fonction appelée.

Et pour C99 apparemment, sans return dans le main, cela fait un return(0) (tout s'est bien passé, on est arrivé au bout de la fonction main "normalement" sans erreur).

Si le code est encore plus ancien, rien ne m'étonne franchement...
Par exemple :

Code:

---

1 2 3 4 5

main(argc, argv) int argc; char** argv; { ... }

---

Citation:

---

Envoyé par Metalman

- pour une fonction sans type, le compilateur suppose qu'il s'agit d'une fonction renvoyant un int

---

Oui.
C’est la règle du implicit int, qui a été dépréciée (ou carrément supprimée, je ne sais plus) en C99.

Citation:

---

Envoyé par Metalman

- le main, sans return, renvoie la valeur de la dernière fonction appelée.

---

Non.
C’est implementation-defined si tu fais du C freestanding :

Citation:

---

Envoyé par The C89 Draft — 2.1.2.1 Freestanding environment

The effect of program termination in a freestanding environment is implementation-defined.

---

En C hosted, c’est undefined :

Citation:

---

Envoyé par The C89 Draft — 2.1.2.2 Hosted environment

If the main function executes a return that specifies no value, the termination status returned to the host environment is undefined.

---

Citation:

---

Envoyé par Metalman

Et pour C99 apparemment, sans return dans le main, cela fait un return(0) (tout s'est bien passé, on est arrivé au bout de la fonction main "normalement" sans erreur).

---

Oui, c’est comme en C++ :

Citation:

---

Envoyé par ISO/IEC 9899:TC3 — 5.1.2.2.3 Program termination

reaching the } that terminates the main function returns a value of 0.

---

Citation:

---

Envoyé par Metalman

Si le code est encore plus ancien, rien ne m'étonne franchement...
Par exemple :

Code:

---

1 2 3 4 5

main(argc, argv) int argc; char** argv; { ... }

---

---

Ha, les bonnes vielles déclarations du C pré-ANSI (qui ne sont pas équivalentes aux prototypes de fonction que l’on utilise habituellement, cf. ISO/IEC 9899:TC3 — 6.9.1 Function definitions pour la différence entre les deux).
Ça permet de faire du code magnifique du genre :

Code:

---

1 2 3 4 5 6 7 8

void foo(bar, baz, qux) int bar; char baz; int* qux; { /* Do something. */ }   int main(void) { foo(42, "foobarbazqux", 1024.8); return 0; }

---

gcc (gcc -ansi -pedantic -Wall -Wextra) va nous compiler ça sans broncher (à part des avertissements unused parameter). Idem pour clang (à une époque, maintenant je crois qu’il gueule là-dessus).

Citation:

---

Envoyé par Bktero

Par défaut, gcc compile implicitement avec l'option -std=gnu90 (=gnu89) et il est très plausible que cette extension accepte les retours implicites.

---

Plus que plausible. C'est seulement à partir de 1999 que le typage implicite n'a plus fait partie du standard. En 1989/90, il était donc toujours supporté.

Citation:

---

Envoyé par grim7reaper

Ha, les bonnes vielles déclarations du C pré-ANSI (qui ne sont pas équivalentes aux prototypes de fonction que l’on utilise habituellement, cf. ISO/IEC 9899:TC3 — 6.9.1 Function definitions pour la différence entre les deux).
Ça permet de faire du code magnifique du genre :

Code:

---

int main(void)

---

---

Me semble même que le mot clef "void" n'était pas à mettre à cette époque...

Citation:

---

Envoyé par Sve@r

Me semble même que le mot clef "void" n'était pas à mettre à cette époque...

---

C‘est fort probable.
Il me semble même que le type void n’existait pas en pré-ANSI (on utilisait donc char* à la place de void* pour avoir un pointeur générique), mais je ne retrouve plus de source à ce sujet :/

Édit : Ha, voilà :)

Citation:

---

By 1982 it was clear that C needed formal standardization. The best approximation to a standard, the first edition of K&R, no longer described the language in actual use; in particular, it mentioned neither the void or enum types.

---

Source : The Development of the C Language
Et :

Citation:

---

In the earliest versions of C, functions with no specific result defaulted to a return type of int and functions with no arguments simply had empty argument lists. Pointers to untyped data were declared as integers or pointers to char.

---

Source : Wikipédia (c’est une source qui vaut ce qu’elle vaut, mais ça va dans le sens de la précédente).
Je savais bien que je n’avais pas rêvé :D

int f(void) et int f() ne sont pas identiques.

int f(void) déclare une fonction qui ne prend aucun arguments.

int f() déclare une fonction sans spécifier le nombre et le type des arguments.

Citation:

---

Envoyé par matafan

int f(void) et int f() ne sont pas identiques.

int f(void) déclare une fonction qui ne prend aucun arguments.

int f() déclare une fonction sans spécifier le nombre et le type des arguments.

---

Ça dépend.
Dans la définition d’une fonction, c’est la même chose.
Dans la déclaration d’une fonction, tu as raison.

Citation:

---

Envoyé par ISO/IEC 9899:TC3 — 6.7.5.3 Function declarators (including prototypes)

An identifier list declares only the identifiers of the parameters of the function. An empty list in a function declarator that is part of a definition of that function specifies that the function has no parameters. The empty list in a function declarator that is not part of a definition of that function specifies that no information about the number or types of the parameters is supplied.

---

Mais oui, la liste de paramètre vide pour « pas d’argument » date de la vieille époque ou void n’existait pas. Maintenant, il faut privilégier l’usage de void (même si l’autre peut parfois encore fonctionner) car l’autre est obsolète :

Citation:

---

Envoyé par ISO/IEC 9899:TC3 — 6.11.6 Function declarators

The use of function declarators with empty parentheses (not prototype-format parameter type declarators) is an obsolescent feature.

---

Grillé :aie:

+1 pour grim7reaper

Heureux d'avoir lancé les recherches dans les vieilles normes pour expliquer certaines choses ! :mrgreen: