Discussion :

[dafpp]

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]

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]

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]

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

[jlliagre]

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]

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

[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
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'

[gangsoleil]

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]

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