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

**dafpp** · 04/10/2013, 11h46

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**imperio** · 04/10/2013, 11h55

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.

**Metalman** · 04/10/2013, 11h57

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

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" !

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

**diogene** · 04/10/2013, 13h01

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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>).

**gangsoleil** · 04/10/2013, 17h13

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
}

**Sve@r** · 04/10/2013, 19h29

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

**jlliagre** · 05/10/2013, 02h47

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é.

**Bktero** · 05/10/2013, 19h59

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

**jlliagre** · 06/10/2013, 09h57

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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'

**dafpp** · 07/10/2013, 19h02

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.

**Sve@r** · 07/10/2013, 19h08

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...

**dafpp** · 07/10/2013, 19h32

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

**Obsidian** · 07/10/2013, 22h08

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 !

**Bktero** · 07/10/2013, 22h14

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**Metalman** · 07/10/2013, 23h42

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
main(argc, argv)
int argc; char** argv;
{
...
}

**grim7reaper** · 08/10/2013, 06h06

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.

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 :

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 :

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.

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++ :

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.

Envoyé par Metalman

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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).

**jlliagre** · 08/10/2013, 09h22

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é.

**Sve@r** · 08/10/2013, 09h37

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

int main(void)

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

**grim7reaper** · 08/10/2013, 09h49

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à

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 :

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é

**matafan** · 08/10/2013, 17h28

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.

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

C

Discussions similaires

Partager

Partager