Ceci est destiné à ceux qui veulent tester rapidement Zyrox, ou apprendre à l'intégrer dans un projet cmake.

Suivez les étapes dans le dépôt Zyrox Template.

À partir des sources

installez llvm :

clonez et compilez zyrox :

Configuration du plugin Python (Post-Compilation)

assurez-vous d'avoir python3 et pip installés.

Configurer un environnement (recommandé)

Installation globale

Utilisation

Utilisation rapide

Après l'offuscation, exécutez PyPlugin.py pour chiffrer les tables de saut :

Avec CMake

Consultez le dépôt Zyrox Template pour un exemple d'intégration CMake.

Contacts

Je comprends que c'est un sujet complexe, et ce projet était surtout à des fins éducatives, ainsi que pour servir BSD Brawl. Si vous avez des questions, ou simplement envie de discuter, n'hésitez pas à me contacter :

• Discord : @s.b
• Email : [email protected] ou [email protected]
• Serveur Discord

toute aide, via des pull requests ou des issues, est appréciée !

Comment ça fonctionne

ZyroxPlugin.cpp enregistre le pass, puis lie siphash (plus de détails plus tard) et appelle StringEncryption pour chiffrer les chaînes.

La raison pour laquelle nous chiffrons les chaînes tôt est que la logique de déchiffrement soit elle aussi offusquée plus tard.

Ensuite, il appelle ModuleUtils::ExpandCustomAnnotations et QuickConfig::RegisterPasses pour analyser toutes les expressions __attribute__((annotate("..."))) et exécuter la configuration QuickJs (située dans ZyroxConfig.js)

Chaque fonction est offusquée en appelant Zyrox::RunOnFunction situé dans ZyroxCore.cpp, plus de documentation à ce sujet sera fournie à l'avenir.

Utilitaire supplémentaire

Les commutateurs créent des tables de saut et les nœuds PHI sont gênants à traiter, donc nous utilisons FunctionUtils et BasicBlockUtils pour les aplatir (en instructions if) et les rétrograder respectivement.

Passes

oh là là, par où commencer

• Basic Block Splitter
• Control Flow Flattening
• Indirect Branching
• Simple Indirect Branching
• Mixed Boolean Arithmetic

tous les arguments des plugins js sont dans index.d.ts, donc ils ne seront pas abordés dans cette documentation.

pour la documentation des annotations, cliquez ici

Basic Block Splitter

Ce pass divise et mélange un bloc de base en blocs plus petits. Supposons que nous ayons ceci :

qui est compilé en :

en utilisant Basic Block Splitter avec cette configuration :

il devient :

maintenant, cela ne sera pas très différent pour une si petite fonction, mais remarquez comment il a divisé un bloc de base ? c'est utile combiné avec d'autres passes comme Control Flow Flattening

Control Flow Flattening

Oh, ce pass a le plus de fonctionnalités parmi tous, lol. Je vais commencer par expliquer comment il fonctionne, puis sa configuration. Supposons que nous ayons ce code :

chaque bloc de base (A, B et C) se voit attribuer un état unique du dispatcher, exemple : (simplifié)

ensuite nous injectons un bloc dispatcher qui contrôle tout et le code devient :

maintenant cela a quelques défauts que l'offuscateur corrige. Comme vous le voyez, puisque nous avons une seule variable dispatcher, il est facile de désoffusquer cela car nous savons où un bloc va après avoir défini l'état. Facile à corriger !

passons en revue les options une par une :

• UseFunctionResolverChance : injecte une fonction pour vérifier l'état, donc au lieu de faire if (state == expected_state), il fait if (injected_resolver(state)). exemple :
  root@kitploit:~

  bool __fastcall cff_resolve_state_check_3585(__int64 a1)
  {
      return a1 == 0x288A6154F8A5E3E2LL;
  }
  

• UseGlobalStateVariablesChance : sauvegarde la valeur d'état à comparer dans une variable globale :
  root@kitploit:~

  bool __fastcall cff_resolve_state_check_506(__int64 a1)
  {
      return a1 == qword_1B20D8;
  }
  

• UseOpaqueTransformationChance : offusque la vérification en une transformation qui ne donnera vrai que pour un état spécifique :
  root@kitploit:~

  bool __fastcall cff_resolve_state_check_7901(__int64 a1)
  {
      return ((((a1 ^ 0xEA9E45BB6099BC6ELL) + qword_1C64D8) << qword_1A63F0)
                 | (((a1 ^ 0xEA9E45BB6099BC6ELL)
                     + qword_1C64D8) >> qword_1ACE98)) == qword_1B0B80;
  }
  

• UseGlobalVariableOpaquesChance : utilise une variable globale au lieu d'un nombre lors de l'utilisation de UseOpaqueTransformationChance, comme vous l'avez remarqué dans l'exemple ci-dessus. (qword_1C64D8, qword_1A63F0, qword_1ACE98)
• UseSipHashedStateChance : utilise une minuscule fonction siphash personnalisée pour vérifier l'état. Donc if (state == 23872) devient quelque chose comme if (siphash(state) == 3874872081) rendant plus difficile de trouver vers quel bloc on saute. le bloc ferait state = 23872 lorsque la condition de destination est hachée. chaque appel siphash utilise des valeurs aléatoires pour rendre son émulation plus difficile.
• CloneSipHashChance : clone et tente même, si possible, d'inliner la fonction siphash créant ainsi plus d'une copie, ce qui rend le hook d'une seule fonction insuffisant. il est très fortement recommandé d'utiliser cela car cela n'augmente que la taille du binaire et n'affecte pas les performances.

Indirect Branching

supposons que nous ayons ce code :

il se transformerait en :

lorsque ce pass est utilisé, le plugin produira un fichier zyrox_tables.txt à utiliser par PyPlugin.py.

PyPlugin.py chiffrera les tables de saut et corrigera les entrées de relocalisation, puis fera pointer le relocateur vers jump_table[0] de chaque table. un relocateur fait essentiellement ceci : target.writePointer(base.add(value)), donc en définissant value à 0, nous faisons en sorte que le relocateur nous donne l'adresse de base et la mette dans la table de saut à l'exécution, et nous l'utilisons avec le goto pour générer l'adresse d'exécution. sur arm32 en mode thumb le pass ajoute automatiquement | 1 après le déchiffrement.

pour utiliser PyPlugin.py faites simplement ce qui suit :

(si vous utilisez venv, activez-le d'abord)

passer --android est important si vous ciblez la version arm64 car la version x86_64 a une signature de relocateur différente.

vous pouvez aussi passer --out (par défaut le même fichier que --in) et --tables (par défaut zyrox_tables.txt)

Simple Indirect Branching

bien que le branching indirect semble génial, il a aussi un impact sur les performances car il déchiffre les pointeurs à l'exécution, voici une version simple qui n'affecte pas les performances, où cela :

devient :

bien que cela semble simple et facilement cassable (je suis d'accord), cela suffit pour casser IDA et Ghidra sans affecter les performances.

Mixed Boolean Arithmetic

également connu sous le nom de MBA Sub (Mixed Boolean Arithmetic Substitution), convertit des opérations simples en opérations complexes qui donnent la même sortie. il utilise un ensemble prédéfini. exemple :

vous pouvez voir la liste complète dans Passes/MBASub.cpp si vous êtes intéressé.

Zyrox Annotations

il suffit de consulter index.d.ts. le parseur d'annotations utilise le même ordre. pour marquer une fonction, faites simplement ce qui suit :

codes d'annotation :

• Basic Block Splitter : bbs
• Control Flow Flattening : cff
• Indirect Branching : ibr
• Simple Indirect Branching : sibr
• Mixed Boolean Arithmetic : mba

exemple : dans index.d.ts nous voyons :

maintenant voilà le truc, le premier argument et celui partagé par tous les passes est PassIterations, donc ce sera le premier argument dans les annotations. pour annoter quelque chose avec bbs nous faisons :

cela signifie : exécute Basic Block Splitter sur hello_world 1 fois avec min size = 15, max size = 30 et chance = 100.

vous pouvez aussi combiner des passes :

cela signifie exécuter Basic Block Splitter puis Indirect Branching et ensuite Simple Indirect Branching sur hello_world. Ils s'exécuteront dans l'ordre de définition de gauche à droite.