Obfuscation en Caml Light : Deux Astuces

Aujourd'hui je vais vous montrer deux astuces qu'il est possible d'exploiter en Caml Light afin d'obfusquer vos programmes. Cet article s'adresse aussi bien aux néophytes qu'aux habitué.es du langage : les syntaxes présentées sont simples, et souvent méconnues - puisque dépréciées pour écrire du beau code.

Si vous êtes en prépa, vous n'êtes pas sans savoir que Caml Light est maintenant le seul langage officiellement au programme de l'option info. Aussi, n'hésitez pas à abuser de ces astuces pour diviser vos notes par deux.

:)

C'est quoi "l'Obfuscation" ?

L'obfuscation d'un code source est le procédé qui consiste à le rendre difficilement compréhensible par un humain, tout en le laissant parfaitement interprétable par la machine. Parfois afin de protéger son programme de la rétro-ingénierie ; parfois par simple intérêt du programmeur pour l'aspect créatif de la pratique. Le concours international annuel d'obfuscation en C (l'IOCCC) permet d'avoir un aperçu du niveau d'entropie atteint aujourd'hui...

Ici le programme d'Endoh1, arrivé en 4ème position de l'IOCCC 2016

Aujourd'hui on va en faire pour le fun et à un degré de complexité moindre : je vais simplement vous présenter deux astuces, ça sera à vous de jouer avec et de le combiner dans tous les sens !

En Caml Light

Astuce 1 : Des Collisions de Caractère

Le Caml est un langage français ! C'est l'un des rares à accepter les accents dans le nom des variables. Pour l'interpréteur la variable "élément" est donc différente de la variable "element".

Cependant le langage accepte également des caractères spéciaux qui sont curieusement remplacés par d'autres lors de la compilation ! Exactement comme si vous initialisiez une variable "élément", et qu'elle soit accessible par "element" !

En pratique les lignes suivantes...

let ™ = 1 in T;;
let š = 2 in s;;
let Š = 3 in S;;
let œ = 4 in o;;
let Π= 5 in O;;
let ƒ = 6 in f;;

...sont interprétées ainsi :

#let ™ = 1 in T;;
- : int = 1
#let š = 2 in s;;
- : int = 2
#let Š = 3 in S;;
- : int = 3
#let œ = 4 in o;;
- : int = 4
#let Π= 5 in O;;
- : int = 5
#let ƒ = 6 in f;;
- : int = 6

Il est à noter que ces remplacements peuvent également se faire sur des mots réservés. Ainsi, "for" peut tout à fait s'écrire "ƒœr", sans altérer l’exécution normale du programme.

De la même manière, les points (utiles par exemple pour les floats ou les tableaux) peuvent être remplacés par les caractères "•" et "…" sans que cela ne pose de problème à l'interpréteur.

Ici la ligne...

let a = [|8•;7…6|] in a•(0) +• a…(0) +… 9•1;;

...s’exécute parfaitement :

#let a = [|8•;7…6|] in a•(0) +• a…(0) +… 9•1;;
- : float = 25.1

Et la fonction...

let ™Œ™Œ =
let œo = ref 1• in
ƒœr Œ = 1 tœ 9 dœ
oœ := (fun s -> float_of_int(O)*…š)(!œœ);
dœne;
!oo;;

...s'appelle de la manière suivante :

#TOTO;;
- : float = 362880.0

C'est moche ? Alors nous sommes sur la bonne voie.

Astuce 2 : Des Instructions avant une Condition

Ici ça s'explique en deux mots : pour chaque structure syntaxique impliquant une condition, on peut précéder cette condition d'instructions qui seront exécutées quoi qu'il arrive.

Partons d'un exemple : normalement, un if s'écrit :

[instruction1]; if [condition] then [instruction2];

Et bien  il est possible de condenser cette syntaxe sous la forme :

if [instruction1];[condition] then [instruction2];

...
Sur une série d'exemple ça donne :

Pour le if :

#let a = ref 0 in if incr a; !a = 1 then print_string("oui");;
oui- : unit = ()

Pour le for (ici j'ai un peu joué en utilisant un int et une référence qui portent le même nom) :

#let j = ref 9 in for j = 0 to print_string("deb");incr j; !j do print_int(j) done; !j;;
deb012345678910- : int = 10

Pour le when :

let rec foo x =
let j = ref 1 in match x with
| y when (incr j; !j = y) -> y
| y -> print_int(y - !j); foo (y - 1);; 

#foo 12;;
10987654321- : int = 2

Sachez qu'on peut en tirer un équivalent de la boucle do... while en Caml.

Et oui ! Le do...while que - personne - n'utilise et absent dans la moitié des langages (dont le Caml) peut être implémenté par une syntaxe de la forme :

while [instructions];[condition] do () done;

 Honnêtement, j'ai un faible pour cette structure.

#let a = ref 0 in while incr a; !a < 10 do () done; !a;;- : int = 10

Embêtez vos profs d'info, et ne respectez plus jamais aucune indentation...

Bon code !