dconstruct

Animation de désassemblage et décompilation complète

dconstruct est un outil de rétro-ingénierie pour les fichiers DC-Script utilisés dans The Last of Us Part II. Il dispose d'un désassembleur et d'un décompilateur.

Il produit des fichiers .asm contenant les structures et bytecode désassemblés, ainsi que des fichiers .dcpl (DC Pseudo Language) contenant du pseudo-code proche du C.

Vous pouvez également modifier des fichiers via la ligne de commande, y compris remplacer des structures entières avec peu d'effort. Cela rend la création de mods qui changent simplement quelques valeurs dans les fichiers .bin extrêmement facile.

Principales fonctionnalités

[]= ``` - ``: L'adresse mémoire de la structure que vous souhaitez modifier (en hexadécimal, commençant par `0x`. Le plus simple est de la copier-coller depuis une version désassemblée du fichier que vous voulez modifier). - ``: L'index de la variable membre à l'intérieur de la structure. Équivalent au nombre que vous pouvez voir à gauche du membre. - ``: La nouvelle valeur à attribuer à ce membre. Doit être de la même taille. (les ints et floats sont de taille 4, les sids/structs sont de taille 8). Le programme NE vérifiera PAS que les structures sont du même type.

Cela produira ensuite un fichier nommé `my_bin_file.bin.asm` dans le même répertoire que votre fichier d'entrée. Vous pouvez ensuite ouvrir ce fichier à l'aide d'un éditeur de texte/code. Je recommande d'utiliser quelque chose comme VSCode qui offre des fonctionnalités de recherche avancées et est adapté aux fichiers volumineux. Le bloc-notes Windows standard n'est pas recommandé. Pour décompiler un fichier, ajoutez le drapeau `--decompile` lors de l'exécution de la commande. # Arguments de ligne de commande - `-i` - fichier ou dossier d'entrée. Peut être omis si le chemin d'entrée est passé comme premier argument. - `-o` - chemin de sortie. Si votre chemin d'entrée est un dossier, cela ne peut pas être un fichier. Si aucune sortie n'est spécifiée, le fichier .txt sera placé à côté du fichier d'entrée. Si l'entrée est un dossier et qu'aucune sortie n'est spécifiée, le programme créera un répertoire "output" dans le répertoire de travail actuel et y placera tous les fichiers. - La base sid est chargée à partir de `sidbase.bin` situé à côté de l'exécutable. - `--no_decompile` - ne pas émettre de code pseudo décompilé dans un fichier .dcpl. Le fichier sera placé à côté du fichier .asm. Ceci est faux par défaut. - `--no_optimize` - ne pas optimiser et nettoyer le code dcpl. Cela implique l'inlining des appels de fonctions, la suppression des variables inutilisées, la transformation des boucles for compatibles en boucles foreach, et la conversion de certaines chaînes if-else en expressions match. - `--pascal_case` - convertir les noms de fonctions du jeu en casse Pascal dans la sortie dcpl, par exemple get-boolean -> GetBoolean. - `--graphs` - émettre des fichiers .svg contenant des graphes de flux de contrôle pour toutes les fonctions décompilées. Chaque fichier .bin obtient son propre dossier contenant tous ses graphes. Cela ralentit **considérablement** la vitesse de décompilation, il n'est donc pas recommandé lors de la décompilation d'un grand nombre de fichiers en même temps. - `--emit_once` - interdit à la même structure d'être émise deux fois dans le désassemblage. Si une structure apparaît plusieurs fois, seule la première instance sera entièrement émise, et toutes les autres occurrences seront remplacées par une balise `ALREADY_EMITTED`. Cela peut réduire considérablement la taille du fichier. - `-e` - effectuer une modification. Plus d'informations dans la section ci-dessous. - `--edit_file` - fournir un fichier d'édition. Un fichier d'édition contient une modification par ligne. Il utilise la même syntaxe que le drapeau -e. # Qu'est-ce qu'un désassembleur ? Un [désassembleur](https://en.wikipedia.org/wiki/Disassembler) est un outil qui lit des instructions binaires (aussi appelées [bytecode](https://en.wikipedia.org/wiki/Bytecode) ou [code machine](https://en.wikipedia.org/wiki/Machine_code)) et traduit chacune en une version lisible par l'humain appelée [mnémotechnique](https://en.wikipedia.org/wiki/Assembly_language#Mnemonics). Les désassembleurs ne tentent généralement pas d'interpréter beaucoup la signification de ces instructions et les transforment simplement 1-1 en leurs versions lisibles. Par exemple, les instructions :```arm 15 00 00 00 4A 01 01 00 43 31 01 00 1C 00 00 01

À partir de cela, il est virtuellement impossible de dire ce que fait le code. ## Code désassemblé avec étiquettes & table des symboles```arm sqrt-sign = script-lambda [0x9A8D8] { [1 args] 0000 0x09A928 43 00 31 00 Move r0, r49 r0 = arg_0 0001 0x09A930 15 01 00 00 LookupPointer r1, 0 r1 = ST[0] -> <absf> 0002 0x09A938 43 02 00 00 Move r2, r0 r2 = arg_0 0003 0x09A940 43 31 02 00 Move r49, r2 r49 = arg_0 0004 0x09A948 1B 01 01 01 Call r1, r1, 1 r1 = absf(arg_0) 0005 0x09A950 43 02 00 00 Move r2, r0 r2 = arg_0 0006 0x09A958 40 03 01 00 LoadStaticFloatImm r3, 1 r3 = ST[1] -> <0.000000> 0007 0x09A960 24 02 02 03 FGreaterThanEqual r2, r2, r3 r2 = r2 >= r3 0008 0x09A968 2F 0B 02 00 BranchIfNot r2, 0xB IF NOT r2 => L_0 0009 0x09A970 40 02 02 00 LoadStaticFloatImm r2, 2 r2 = ST[2] -> <1.000000> 000A 0x09A978 2D 0C 00 00 Branch 0xC GOTO => L_1 L_0: 000B 0x09A980 40 02 03 00 LoadStaticFloatImm r2, 3 r2 = ST[3] -> <-1.000000> L_1: 000C 0x09A988 43 03 02 00 Move r3, r2 r3 = -1.000000 000D 0x09A990 15 04 04 00 LookupPointer r4, 4 r4 = ST[4] -> <sqrt> 000E 0x09A998 43 05 01 00 Move r5, r1 r5 = RET_absf 000F 0x09A9A0 43 31 05 00 Move r49, r5 r49 = RET_absf 0010 0x09A9A8 1C 04 04 01 CallFf r4, r4, 1 r4 = sqrt(RET_absf) 0011 0x09A9B0 07 03 03 04 FMul r3, r3, r4 -1.000000 = -1.000000 * RET_sqrt 0012 0x09A9B8 43 01 03 00 Move r1, r3 r1 = -1.000000 0013 0x09A9C0 00 01 01 00 Return r1 Return SYMBOL TABLE: 0000 0x09A9C8 function: absf 0001 0x09A9D0 float: 0.000000 0002 0x09A9D8 float: 1.000000 0003 0x09A9E0 float: -1.000000 0004 0x09A9E8 function: sqrt }

[4] firearm-gameplay-def [0x11C28] { [0] float 0.7 // might represent the rate of fire, so i want to lower it for my mod ... } ``` Pour remplacer la première variable membre (index 0) par la valeur flottante 0.5, la commande d'édition serait : `-e 0x11C28[0]=0.5` La structure que nous voulons éditer est à `0x11C28`, et nous voulons la première variable membre (le 0 à gauche du flottant). Nous mettons ensuite la nouvelle valeur après le `=`, 0.5 dans ce cas. Si l'édition a réussi, le programme affichera un message indiquant que la valeur a été changée de `0.7->0.5`. Pour un fichier d'édition, supprimez simplement le `-e` et mettez une édition par ligne : ### edit_file.txt 0x11C28[0]=0.5 0x11C28[1]=0.2 ... ## Types de variables membres Les structures peuvent avoir différents types de variables membres : - `float` - Spécifiez des valeurs décimales avec un point (par exemple 0.5). - `int` - Spécifiez des valeurs entières sans point (par exemple 42). - `sid` (identifiant de chaîne) - (plus d'informations ci-dessous) - `string` - actuellement non pris en charge pour le remplacement - `structure` - en remplaçant un pointeur (plus d'informations ci-dessous) ### Remplacement de sid par recherche de nom : `-e 0xABC[5]=ellie` Cela recherche la valeur "ellie" dans la sidbase courante. Si elle n'existe pas, un avertissement est émis et aucune édition n'est appliquée. Si la valeur est trouvée, la valeur de hachage réelle (un grand nombre) remplacera la valeur actuelle à la variable membre. ### Remplacement de sid par surcharge manuelle directe du hachage : `-e 0xABC[5]=#XXXXXXXXXXXXXXXX` Le # indique une valeur de hachage brute, qui sera appliquée directement sans recherche. ### Remplacement de structures membres Si une structure contient une autre structure comme membre, vous pouvez remplacer la structure membre entière en lui assignant l'adresse d'une autre structure. Par exemple, supposons que vous ayez ce qui suit :```c++ [4] weapon-gameplay-def [0x0C523] { ... [7] firearm-gameplay-def [0x11C28] { ... } } ``` Donc `weapon-gameplay-def` contient un `firearm-gameplay-def`. Pour remplacer le `firearm-gameplay-def` à l'intérieur du `weapon-gameplay-def` par un autre `firearm-gameplay-def` situé à l'adresse `0x0ABC`, la modification sera : `-e 0x11C28[7]=0x0ABC` # Extension VS Code pour le langage DCPL VS Code permet de créer des extensions personnalisées pour ajouter la coloration syntaxique à des langages personnalisés. dconstruct est livré avec un fichier .vsix qui ajoute cette prise en charge pour l'extension de fichier .dcpl. Parce que c'est un langage à usage unique qui n'est pas vraiment destiné à la programmation quotidienne, je ne télécharge pas l'extension sur le marketplace, et je la fournis plutôt sous forme de fichier .vsix brut. Pour installer cette extension dans votre VS Code, exécutez la commande suivante :```shell code --install-extension <path/to/extension/dcpl-lint-0.0.1.vsix> ``` ou ouvrez la palette de commandes avec CTRL+SHIFT+P et tapez "Install extension via VSIX" et sélectionnez le fichier .vsix. Après cela, votre code .dcpl devrait ressembler à ceci : ![dcpl_code](https://assets.kitploit.com/production/public/readmes/13048/8b4ab26ab7952a91a015d1376d3101bcad17c65602ed9c2b5c1587cb1d1a9f3c.png) # Problèmes connus Le décompilateur n'est actuellement pas 100% complet et est donc dans un état "expérimental". Si vous obtenez des avertissements lors de la décompilation, ne vous inquiétez pas car ces fonctions ne sont actuellement pas prises en charge, mais le seront espérons-le à l'avenir. En dehors de cela, il y a plusieurs problèmes connus pour le moment : - les fonctions à expression unique avec court-circuitage intensif (en particulier celles dans les structures) ne sont pas encore implémentées. J'ai commencé à travailler sur l'algorithme pour celles-ci mais je ne sais pas combien de temps cela prendra, même si cela figure en tête de liste des priorités - certains types sont incorrects, en particulier les types d'arguments - les blocs if vides dans les instructions if/else peuvent causer une indentation étrange. Ce n'est pas toujours de ma faute, car certaines branches ne font en fait aucun travail réel, ce qui est difficile à détecter En plus de ceux-ci, il y a quelques problèmes qui ne seront probablement pas corrigés : - retourner des données inutiles lorsqu'on ne sait pas si une fonction est void ou non - beaucoup de code redondant # Fonctionnalités prévues - un format de sortie complet pour Racket et Python # Remerciements spéciaux - **icemesh** – pour avoir fourni les [structures sous-jacentes des fichiers DC](https://github.com/icemesh/dc/tree/main/t2) et [son désassembleur](https://github.com/icemesh/t2-dc-disasm), qui ont largement servi d'inspiration. - **Specilizer** – pour son DC-Tool, également une inspiration pour ce programme. - **uxh** – pour ses connaissances en scripting. - **bigdragon** & **Wedge** pour les tests bêta - Toute la communauté de modding Discord – pour leur amabilité et leur aide. ## Soutien Tous mes outils et mods seront toujours 100% gratuits, mais des programmes comme celui-ci demandent beaucoup de travail. Si vous souhaitez me soutenir, vous pouvez visiter mon Ko-fi : [![Ko-fi](https://img.shields.io/badge/Donate-Ko--fi-ff5f5f.svg)](https://ko-fi.com/deepquantum) ## Licence Les fichiers que vous créez avec ce mod sont entièrement vôtres et vous êtes libre d'en faire ce que vous voulez. Un crédit serait apprécié mais n'est pas strictement requis. Le programme lui-même est sous licence [Creative Commons Attribution - Pas d'Utilisation Commerciale - Pas de Modification 4.0 International](https://creativecommons.org/licenses/by-nc-nd/4.0/). Cela signifie que vous êtes autorisé à partager le programme avec d'autres si vous donnez du crédit, mais vous n'êtes actuellement pas autorisé à le modifier ni à le monétiser.

dconstruct

Populaires

Comment utiliser

Qu'est-ce qu'un décompilateur ?

Exemples

La fonction sqrt-sign()

Octets originaux```arm

Graphe de flot de contrôle

Pseudocode final```rust

Après```c

Après```c#

Après```scala

Édition

Syntaxe des modifications

Exemple