Si vous êtes développeur freelance et avez déjà cherché à protéger votre code, le rendre illisible, vous savez ce qu’est l’obfuscation. Mais, savez-vous comment la mettre en place et l’utiliser ? Connaissez-vous son niveau d’efficacité ?
Dans cet article, nous allons faire le point sur ce procédé visant à brouiller le code !
L’obfuscation, qu’est-ce que c’est ?
Avant toute chose, faisons le point sur ce qu’est exactement l’obfuscation.
L’obfuscation (aussi appelée offuscation, en français, ou code impénétrable), est un procédé visant à suffisamment transformer un code informatique pour qu’il devienne illisible, ou très peu lisible, par un être humain.
Il ne faut donc pas confondre cette méthode avec le chiffrement. Le chiffrement transforme (à l’aide d’une clé en général), alors que l’obfuscation ne fait que cacher. Une chaîne de caractères chiffrée aura besoin d’être déchiffrée pour être lue ; l’obfuscation ne fera que la rendre moins lisible.
Un code ne doit pas et ne peut pas être chiffré, sinon il ne sera pas exécutable (ou interprétable) par une machine ou un navigateur. Il deviendra inutilisable.
La seule solution pour compliquer son interprétation est donc l’obfuscation.
Pourquoi obfusquer son code ?
Il y a plusieurs raisons qui peuvent pousser un développeur, ou une équipe, à vouloir cacher un code source.
Pour plus de sécurité
Déjà, le plus évident, c’est pour une raison de sécurité.
On peut vouloir cacher son code, soit parce qu’il peut contenir des données sensibles, soit pour éviter qu’il soit copié et modifié. Par exemple, si on a écrit un algorithme complexe en JavaScript et qu’on veut éviter qu’il soit récupéré, on peut utiliser des techniques d’obfuscation.
Attention toutefois, nous l’avons dit, l’obfuscation n’est pas un chiffrement. Ce procédé ne permet que de rendre plus difficile la lecture d’un code, mais cela ne l’empêche pas !
Il existe même des outils pour inverser l’obfuscation. Et même s’ils ne permettent pas une lecture parfaite du code, ils la facilitent beaucoup.
Pour optimiser le code
Comme nous le verrons, l’obfuscation (partielle) est parfois automatiquement faite lors du build d’un projet. C’est par exemple le cas avec les frameworks JavaScript front-end.
Dans ce cas, le but n’est pas d’empêcher la lecture du code, mais plutôt d’optimiser le programme. Un code obfusqué, au moins via ces builders, sera plus condensé, raccourci, optimisé – on parle alors de minification. Nous avons d’ailleurs écrit un article complet dédié à la minification d’un code source.
La finalité est de rendre les fichiers plus légers, pour qu’ils soient chargés plus rapidement, et ainsi optimiser le fonctionnement d’un site ou d’une web app.
Pour le loisir
La troisième raison d’utiliser cette méthode, qui peut paraître plus anecdotique, c’est l’obfuscation pour le loisir.
Obfusquer est en effet devenu une discipline à part entière, qui fait même l’objet de concours !
Le plus connu d’entre eux, c’est le IOCCC (International Obfuscated C Code Contest), qui demande à ses participants d’obfusquer un code, sans autre idée que de le rendre compliqué, en incluant une certaine part artistique. Lors de ce concours, on a par exemple vu un simulateur de vol dont le code source a été obfusqué de manière à ressembler à un avion.
Vous pouvez trouver quelques exemples sur la page Wikipédia dédiée au concours.
Comment obfusquer son code ?
Maintenant que nous avons vu ce qu’était l’obfuscation, voyons comment ce procédé fonctionne, et comment le mettre en place !
Comment fonctionne l’obfuscation, techniquement
L’obfuscation consiste à rendre un code illisible. Quelle qu’en soit la raison, on retrouvera donc les mêmes pratiques, les mêmes modifications au sein d’un programme :
- la modification des noms des variables, fonctions, classes, etc. ;
- la suppression de tout commentaire ;
- le retrait de tout espace et indentation inutile.
Si le but est maintenant purement sécuritaire (ou artistique), et qu’on met le côté optimisation de côté, il est possible d’aller encore plus loin, en remplaçant par exemple les lettres dans les noms de variables, fonctions, mais aussi dans les chaînes de caractères, par leurs codes hexadécimaux.
Obfusquer pour optimiser, via un minifier / uglifier
Une des options pour obfusquer un code, c’est d’utiliser un minifier, ou uglifier. On les utilise dans une optique d’optimisation, afin de rendre le code le plus compact possible, tout en le gardant exécutable ou interprétable par une machine ou un moteur d’interprétation.
La plupart du temps, ils sont inclus avec les frameworks qu’on utilise, et automatiquement appelés lors d’une compilation.
Il existe toutefois des alternatives, comme des sites web en ligne vous permettant de minifier un code que vous fournissez. Citons par exemple JSCompress pour JavaScript, ou CleanCSS pour du CSS.
Obfusquer pour empêcher la lecture
Si on cherche à empêcher la lecture du code, la minification ne sera peut-être pas suffisante. Elle compliquera la lecture, mais via des outils aidant à désobfusquer le code, on ne l’empêchera pas.
Il existe des outils rendant le code illisible, mais toujours interprétable par une machine.
C’est le cas, par exemple pour du JavaScript, de JSFuck, qui rend le code complètement illisible, ou d’obfuscator.io, qui, bien qu’employant une technique d’obfuscation différente, empêche lui aussi la lecture d’un code source.
Ces techniques sont idéales pour rendre un code illisible, mais elles ne l’optimisent pas. On ne gagnera donc pas en temps de chargement, c’est même parfois le contraire, et c’est là la différence avec la minification.
Quelques exemples de code obfusqué
Pour bien se rendre compte de ce qu’est l’obfuscation, le mieux est de voir du code avant et après l’utilisation de ce procédé.
Par minification
D’abord, voyons du code avant et après minification. Prenons l’exemple classique du JavaScript, avec le programme suivant :
// JavaScript code to minify here:
function hi() {
console.log("Hello World!");
}
hi();En utilisant un algo minifiant le code JavaScript, nous obtenons le résultat suivant :
function hi(){console.log("Hello World!")}hi();Comme nous le voyons, espaces inutiles, commentaires et sauts de lignes ont été supprimés. Soit, au final, une compression de 47,19% du code dans cet exemple !
Par obfuscation brute
Voyons maintenant ce que donne l’obfuscation d’un morceau de code JavaScript, dans le simple but de le rendre illisible. Reprenons le même exemple :
// Paste your JavaScript code here
function hi() {
console.log("Hello World!");
}
hi();En utilisant obfuscator.io, le code en sortie ressemblera à :
function _0x5da1(){var _0x2e0050=['3746380WRlixV','10kYljze','66AqkdCg','23600QCIMRU','log','1261638PDweXt','Hello\x20World!','298415DxuBvW','144aTfmdI','203861wiKYjT','79406HSRMzy','779036zPOsbS'];_0x5da1=function(){return _0x2e0050;};return _0x5da1();}function _0x53d9(_0x19a8cc,_0xd4add8){var _0x5da1af=_0x5da1();return _0x53d9=function(_0x53d921,_0x3e179e){_0x53d921=_0x53d921-0x154;var _0x210eed=_0x5da1af[_0x53d921];return _0x210eed;},_0x53d9(_0x19a8cc,_0xd4add8);}(function(_0x36153f,_0x237084){var _0x460c03=_0x53d9,_0x2c481e=_0x36153f();while(!![]){try{var _0x5ca361=parseInt(_0x460c03(0x157))/0x1+parseInt(_0x460c03(0x15a))/0x2+-parseInt(_0x460c03(0x155))/0x3+-parseInt(_0x460c03(0x15b))/0x4*(-parseInt(_0x460c03(0x15d))/0x5)+-parseInt(_0x460c03(0x15e))/0x6*(parseInt(_0x460c03(0x159))/0x7)+-parseInt(_0x460c03(0x15f))/0x8*(-parseInt(_0x460c03(0x158))/0x9)+parseInt(_0x460c03(0x15c))/0xa;if(_0x5ca361===_0x237084)break;else _0x2c481e['push'](_0x2c481e['shift']());}catch(_0x1d07b7){_0x2c481e['push'](_0x2c481e['shift']());}}}(_0x5da1,0x63bff));function hi(){var _0x48918e=_0x53d9;console[_0x48918e(0x154)](_0x48918e(0x156));}hi();Le code devient complètement illisible, mais pas plus optimisé ! Au contraire, comme nous pouvons le constater, il est même bien plus long, et les fichiers JavaScript seront donc plus lourds.
Quant à l’autre site que nous avons cité, JSFuck, il est impossible de donner un exemple ici, car le moindre code généré est beaucoup trop long pour être affiché.
Conclusion
Nous l’avons vu dans cet article, l’obfuscation est une technique connue et utilisée par les développeurs pour modifier un code, dans trois buts différents : par optimisation, pour le rendre illisible, ou par loisir.
Quelle que soit la technique d’obfuscation choisie, il faut savoir qu’un code obfusqué n’est pas vraiment plus sûr qu’un code classique. À l’aide d’outils de désobfuscation et d’un peu de patience, il est possible de déchiffrer tout morceau de code. Si on doit sécuriser un programme, notamment parce qu’on y stocke des données sensibles, ce n’est donc pas la meilleure solution. Il faudra peut-être plus s’orienter sur le stockage de certains éléments dans des endroits moins accessibles et visibles, comme un serveur.
Et vous, dans quel but faites-vous de l’obfuscation ? Quelle technique utilisez-vous ? Dites-nous tout en commentaire !
