Chaînes chiffrées à l’exécution

Aujourd’hui, nous allons passer en revue les bases des chaînes chiffrées à l’exécution, pourquoi devons-nous chiffrer nos chaînes et apprendre à créer les nôtres.

Dans cet article, vous comprendrez et apprendrez :

  • Qu’est-ce que le chiffrement et le déchiffrement à l’exécution?
  • Pourquoi avez-vous besoin de chiffrer vos chaînes
  • Voyez comment n’importe qui peut voir vos données sensibles
  • Créez votre propre cryptage personnalisé

Qu’est-ce que le chiffrement et le déchiffrement à l’exécution?

Il s’agit de données chiffrées et/ou déchiffrées lors de l’exécution d’un programme (logiciel, application). Les données peuvent être de tout type à partir de blocs de mémoire, de trafic réseau, de chaînes, etc.

L’une des méthodes les plus couramment utilisées à cette fin est l’obscurcissement (de base). Les autres mécanismes (avancés) impliquent la mutation/virtualisation du code compilé.

Aujourd’hui, nous allons nous concentrer sur un mécanisme utilisant l’obfuscation XOR .

Pourquoi chiffrer les chaînes?

Au moment où vous lancez votre logiciel, tout est visible en mémoire. Cela s’applique également à vos utilisateurs finaux, ce qui signifie qu’ils peuvent tout voir.

L’une des premières choses qu’un attaquant fera est de rechercher des chaînes dans votre logiciel. Cela lui permettra de tout comprendre de votre logiciel avec un minimum d’effort.

Si vous stockez des données sensibles (comme des mots de passe ou des licences), il est essentiel de ne pas les conserver en texte brut. Les garder en texte brut facilitera la vie d’un attaquant.

Il existe plusieurs façons d’analyser votre logiciel. Les méthodes les plus connues et les plus courantes sont l’analyse statique et d’exécution.

Examinons un exemple simple utilisant une application console:

Sample non-encrypted 1

Nous compilons ceci en mode Release (pour éviter toute information de débogage laissée à l’intérieur). Continuons et testons l’analyse statique et d’exécution.

Test d’analyse statique

Dans l’analyse statique, le logiciel n’a pas besoin de s’exécuter. Cela dit, ouvrons l’exemple dans Ghidra .

Dans la capture d’écran ci-dessous, vous pouvez voir que l’exemple est compilé sans aucune information de débogage:

Sample non-encrypted 1-1

Si nous recherchons des chaînes, vous pouvez voir que toutes nos informations sensibles sont visibles:

Sample non-encrypted 1-2

Une fois que vous avez mis en surbrillance la chaîne, vous pouvez ouvrir la vue du décompilateur et voir tout le code pertinent:

Sample non-encrypted 1-3

Assez triste hein ? 😕 Imaginez que vous avez travaillé sur votre logiciel incroyable pendant des mois et que vous êtes prêt à le vendre.

Je pense que le reste est explicite, mais je suis sûr que vous avez compris.

Ce qui est encore plus triste, c’est que c’est si simple que même un enfant de 12 ans peut le faire. (et certains le font réellement)

Test d’analyse d’exécution

Dans l’analyse d’exécution, le logiciel doit s’exécuter (exécuter). Cela signifie que nous devons utiliser un logiciel pour ouvrir le processus et le lire (normalement un débogueur).

Cependant, un débogueur n’est pas vraiment nécessaire à cette fin. Nous pouvons simplement télécharger un outil gratuit comme Process Hacker et ouvrir le processus:

Sample non-encrypted 2

C’était plutôt simple non ? Et gardez à l’esprit que nous n’avons même pas joint de débogueur. Une personne qualifiée et déterminée utilisera un débogueur.

Lorsque vous attachez un débogueur, vous voyez beaucoup plus, mais cette discussion est pour un autre jour.

Création de chaînes chiffrées à l’exécution

Il existe de nombreuses façons d’y parvenir:

  • En utilisant un logiciel tiers comme VMProtect , Themida .
  • Chiffrement de chaîne de temps de compilation comme xorstr .
  • Utiliser des méthodes personnalisées

Les 2 premières options pourraient ne pas répondre à vos besoins. Il y a beaucoup de hauts et de bas pour chacun d’eux, dont nous ne discuterons pas à ce stade.

Une chose que vous devez comprendre est que la popularité est synonyme de risque. Lorsque vous utilisez des éléments trouvés au hasard sur Google, quelqu’un le sait déjà.

La plupart des gens ont développé un outil contre votre outil. C’est juste la façon dont les choses sont. Ils le font pour un défi, ou pour voler votre travail, mais ils le font.

Dans cet esprit, vous devez vous rendre sur mesure. Vous pouvez créer votre propre cryptage de chaîne du niveau de base au niveau avancé.

Le plan

  • Créer une solution facile à utiliser
  • Gardez les chaînes cryptées à tout moment
  • Décryptage uniquement lorsque vous en avez besoin
  • Placez les cordes dans un emplacement aléatoire (facultatif - non couvert)
  • Détruisez les cordes après les avoir utilisées (facultatif – non couvert)

La solution

Commencez par définir nos chaînes une par une sous forme de tableau:

Step 1

Le tableau peut contenir un nombre illimité de chaînes avec une limite de longueur de 256.

Je sais que c’est une tâche ardue, surtout si vos cordes sont longues. Ceci est juste pour la démonstration et plus tard nous créerons une solution plus pratique.

L’idée est de chiffrer chaque caractère de la chaîne. Je vais utiliser un simple cryptage XOR pour cela.

Ci-dessous, vous pouvez voir un exemple de la façon dont cela fonctionnerait:

Step 2

Ce qui précède n’a rien de compliqué, c’est clair et simple mais assez puissant. Vous pouvez l’utiliser dans une application console.

Après avoir compilé et exécuté, le résultat est des octets illisibles pour l’œil humain:

Step 3

Voilà, votre propre petit logiciel pour créer des chaînes chiffrées à l’exécution. 😏

Le résultat

Il est temps de mettre notre solution en pratique. Créons un autre exemple à cet effet et ajoutons notre code:

Step 4

Remarquez 2 choses importantes :

  • J’ai laissé quelques chaînes en texte brut pour que vous puissiez voir la différence
  • Les fonctions de déchiffrement ont besoin de la longueur (plus sur cela plus tard)

Nous compilons ce qui précède en mode Release et l’exécutons. Le nouvel échantillon fonctionne normalement:

Step 5

Si nous ouvrons le nouveau logiciel Sample dans IDA (ou Ghidra), les chaînes que nous avons chiffrées ne sont pas visibles:

Step 6

J’ai mentionné qu’il y a une chaîne intentionnellement laissée claire dans cet échantillon. La raison en est que nous pouvons les suivre pour voir le code:

Step 7

J’ai dû faire défiler vers le bas pour atteindre le texte dans l’image ci-dessus. Vous pouvez voir à quel point le code compilé est différent.

Nous avons résolu le problème d’analyse statique, passons à l’exécution.

Ouvrez-le dans Process Hacker:

Step 8

Voila! Nous avons également résolu le problème d’analyse d’exécution 😎

En savoir plus sur les chaînes chiffrées

L’exemple ci-dessus n’est pas très pratique. Définir chaque chaîne manuellement est une tâche ardue, ainsi que spécifier la longueur de la chaîne à chaque fois.

Idéalement, nous aurions besoin des éléments suivants:

  • Lire un fichier texte pour les chaînes
  • Écrire dans un fichier texte les chaînes résultantes
  • Ajout des séquences d’échappement aux chaînes pour éviter de spécifier la longueur à chaque fois.
  • Ajouter XOR plus complexe ou toute autre méthode (facultatif)
  • Placez les chaînes sur des emplacements aléatoires (facultatif)

J’ai préparé une belle solution pour que vous puissiez jouer avec. Vous pouvez tester tout ce qui est écrit dans cet article et également disposer de votre propre outil prêt à l’emploi pour créer des chaînes chiffrées à l’exécution.

Il comprend 4 projets :

  • RuntimeStringEcryptor qui lit les chaînes d’un fichier texte, les chiffre, puis les écrit dans un autre fichier texte.
  • Sample est la console simple utilisée pour démontrer avec IDA.
  • SampleEncryptedStrings est la console simple avec des chaînes chiffrées à démontrer avec IDA.
  • SimpleRuntimeStringEncryption est le terrain de jeu initial où vous pouvez tester cette méthode.

Remarques:

  • Si vous n’ajoutez pas de séquence d’échappement, le décryptage ne saura pas quand “s’arrêter”. Le résultat étant en charabia/données nulles jusqu’à ce qu’il atteigne la taille de tableau définie.
  • Assurez-vous de changer les touches XOR que j’ai utilisées dans mon exemple.
  • Évitez d’utiliser les mêmes mots plusieurs fois. Ils vont générer les mêmes octets et c’est un risque d’être détecté.

Télécharger

Pour télécharger la solution prête à l’emploi, pensez à soutenir ce blog 😘

Become a Patron