---
title: REA-Ingénierie inverse pour Votre Agent de codage
url: https://rea.tools/fr/
---

Ingénierie inverse, avec votre agent de codage

# Découvrez comment fonctionne un logiciel.

Posez à votre agent de programmation une question sur une application, un jeu ou un site. REA lui fournit les outils pour examiner le code derrière la réponse.

[Démarrer](https://rea.tools/get-started/)
[Voir un exemple ↓](https://rea.tools/fr/#dinosaur)

## Mettre en place REA

Copiez ce prompt dans votre agent de programmation :

Votre agent de codage

Installe REA et connecte-le à cet agent de programmation avec npx rea-agents@latest setup. Présente-moi d’abord les changements prévus et attends mon accord. Vérifie ensuite l’installation.

Ou exécutez cette commande dans le terminal :

`npx rea-agents@latest setup`

Vérifiez et approuvez les changements prévus, puis redémarrez votre agent.


Options de configuration


Autres options d'installation : [curl →](https://rea.tools/get-started/#curl-installation)

Première fois, ou manquant Node.js ou un agent de codage? [Suivez le guide de configuration étape par étape →](https://rea.tools/get-started/)

[Créer des environnements RL →](https://rea.tools/fr/#rl-environments)

Enregistrez une application web pour entraîner et tester des agents.

[Vitrines →](https://rea.tools/fr/showcase/)

Investigations et démonstrations interactives.

[Blog →](https://rea.tools/fr/blog/)

Méthodes et notes de reconstruction.

## Comment ça fonctionne

La rétro-ingénierie consiste à comprendre un logiciel en examinant le programme lui-même. Avec REA, votre agent peut suivre le code, expliquer une fonction et vous aider à la reproduire.

1. ### Poser une question sur une fonction

   Donnez à votre agent un programme ou une page et une question.
2. ### Examiner le programme

   REA aide votre agent à lire le code et à observer ce que fait le programme pendant son exécution.
3. ### Comprendre, puis essayer une modification

   Votre agent utilise les résultats pour expliquer ou reproduire la fonction.

Voir toute l'investigation de la Calculatrice

Pourquoi 200 + 10% donne-t-il 220 dans la Calculatrice ?

### Suivre les instructions pas à pas

Instructions d'origine x64 · sélectionnées 

```
0x180124945: MOV EAX, dword ptr [R13 + 0x18]
0x180124949: CMP EAX, 0x5c
0x18012494c: JZ 0x180124aba
0x180124952: CMP EAX, 0x5b
0x180124955: JZ 0x180124aba
0x18012495b: MOV EDX, 0x64
0x180124960: LEA RCX, [RSP + 0x160]
0x180124968: CALL 0x180122650
0x18012496e: LEA RDX, [R13 + 0x160]
0x180124975: LEA RCX, [RSP + 0x78]
0x18012497a: CALL 0x180109720
0x18012497f: MOV RSI, RAX
0x180124982: MOV qword ptr [RSP + 0x28], RAX
0x180124987: LEA RDX, [RSP + 0x160]
0x18012498f: MOV RCX, RAX
0x180124992: CALL 0x180123190
; … value-copy instructions omitted …
0x180124a14: MOV RDX, RDI
0x180124a17: LEA RCX, [RSP + 0xf8]
0x180124a1f: CALL 0x180109720
0x180124a24: LEA R8, [RSP + 0x30]
0x180124a29: MOV RDX, RAX
0x180124a2c: LEA RCX, [RSP + 0xb8]
0x180124a34: CALL 0x180123c10
```



01 \* Quelle branche?

“**0x5b? 0x5c?** Deux sauts au même endroit. De quels opérateurs s'agit-il?”

Recherchez les identifiants de commande, puis étiquetez la branche.

0x5b
:   Diviser ÷

0x5c
:   Multiplier ×

02 · Que font les fonctions appelées ?

"100 est clair. Les appels ne sont que des adresses. **Lequel divise? Quelle valeur entre?**”

Inspectez les fonctions d'assistance et tracez les valeurs stockées.

0x64
:   100

…123190
:   Diviser

03 \* Quelle est la règle?

"Ce chemin se multiplie par l'autre entrée. Donc **10% signifie 10% de 200** après +.”

Nommez les opérandes et vérifiez les deux chemins d'opérateur.

200 × 10 / 100
**20**

![](https://rea.tools/assets/localized/fr/figures/analyst-thinking.svg)

Raisonnement d'expert illustratif

**Vous décodez les instructions, suivez les appels de fonction et reconstruisez le calcul.**

Poser la même question à votre agent

Exemple d'invite \* Calculatrice

Utilisation REA pour inspecter Windows Calculatrice. Pourquoi 200 + 10% donne-t-il 220?

Exemple de réponse · basé sur les résultats

Après +, le bouton % prend **un pourcentage du premier nombre.**

`10% of 200 = 20`**200 + 20 = 220**

REA fournit
:   Les instructions du gestionnaire, le code décompilé et les appels.

Votre agent explique
:   Quelle branche s'applique, ce qu'elle calcule et comment la reconstruire.

Assemblage sélectionné à partir de la DLL de calculatrice installée. Les réflexions et la réponse illustrent les résultats. [Continuez avec l'exemple de la calculatrice ↓](https://rea.tools/fr/#calculator)

Essayons deux exemples : changer la vitesse d'un jeu, puis reproduire le bouton % de la Calculatrice.

Exemple 01 \* Jeu de dinosaures de Chrome

## Pourquoi le dinosaure accélère-t-il ?

Le jeu accélère à mesure que vous courez. Pour le reproduire avec un réglage de vitesse, il faut d'abord comprendre comment cette vitesse évolue.

### 1. Poser une question sur la vitesse

Exemple de question · Jeu du dinosaure

Utilisez REA pour inspecter ce jeu de dinosaures. Pourquoi ça va plus vite? Affichez la règle de vitesse, puis créez une petite version avec une vitesse réglable.

### 2. Trouver la règle de vitesse

REA permet à l'agent de lire le code du jeu en cours d'exécution. La vitesse commence à 6 et augmente un peu à chaque mise à jour tant qu'elle est inférieure à 13.

### 3. Jouer au résultat

Nous avons reproduit cette règle dans le mini-jeu ci-dessous et ajouté un curseur de vitesse. Appuyez sur Jouer, puis choisissez votre vitesse.

Vitesse 6.0
 Utilisez la règle d'accélération récupérée

Règle d'origine: commencez à 6, puis augmentez vers 13.

Déplacez le curseur pour définir votre propre vitesse. L'espace ou le saut efface un cactus.



Activez JavaScript pour jouer. Vous pouvez toujours lire la règle et ouvrir le code source ci-dessous.

[Ouvrir le laboratoire de vitesse →](https://rea.tools/fr/examples/dino-lab/)

Voir le script, les vérifications et comment essayer l'analyse

Cible inspectée: [édition de navigateur dérivée du Chromium de wayou](https://wayou.github.io/t-rex-runner/).

REA \* chargé index.js \* lignes sélectionnées

```
if (this.currentSpeed < this.config.MAX_SPEED) {
  this.currentSpeed += this.config.ACCELERATION;
}
```

Commencez à 6 heures. Ajouter 0.001 chaque mise à jour sans collision, alors que la vitesse est inférieure 13.

Ce que fait chaque partie

1. 01 · REA

   Lire le script du jeu en cours d'exécution

   Renvoyez son code et ses paramètres réels à l'agent.
2. 02 · Votre agent

   Reconstruire la règle, ajouter un contrôle

   Utilisez l'accélération récupérée dans un petit jeu avec un curseur de vitesse.
3. 03 \* Vous

   Changez la vitesse et jouez

   Essayez l'accélération d'origine, puis choisissez votre propre rythme.

REA a inspecté l'édition du navigateur HTTP via une connexion de débogage locale et a renvoyé le fichier chargé `index.js`, y compris sa source et son résumé.

Paramètres sélectionnés à partir du script inspecté

```
ACCELERATION: 0.001,
MAX_SPEED: 13,
SPEED: 6
```

Nous avons appelé la fonction de mise à jour du jeu d'origine dans une vérification contrôlée du navigateur, avec les obstacles et la planification automatique désactivés. Après 4 000 mises à jour, la vitesse était de 10,0; après 10 000, elle était de 13,0, arrondie à une décimale.

Le nouveau mini-jeu conserve cette règle de vitesse. Son code de dessin, de saut et de collision est une petite implémentation pédagogique. [Ouvrir le laboratoire](https://rea.tools/fr/examples/dino-lab/) pour voir le nouveau code et exécuter le même contrôle de vitesse.

Pour inspecter la cible vous-même, suivez les instructions [étapes de connexion du navigateur](https://rea.tools/fr/guides/browser/#prepare) en utilisant [la page des dinosaures](https://wayou.github.io/t-rex-runner/). Donnez à votre agent cette URL de page et votre point de terminaison de débogage local, puis copiez l'invite ci-dessus.

[Code de vitesse inspecté](https://github.com/wayou/t-rex-runner/blob/5455bfa408ec6b707c7300ff194b7390733a766d/index.js#L565-L571) ·  [Auteurs de Chromium \* Licence BSD](https://rea.tools/assets/licenses/dinosaur.txt)

Exemple 02 · Windows Calculatrice

## Recréez le bouton % de la calculatrice.

Le bouton % agit différemment après + et ×. Retrouvons les deux règles et essayons-les dans une petite calculatrice.

### 1. Poser une question sur le bouton %

Exemple de question · Calculatrice

Utilisez REA pour inspecter le bouton % de la calculatrice Windows. Récupérez les règles après + et×, puis créez une petite calculatrice qui utilise les deux.

### 2. Trouver les deux règles

REA aide l'agent à lire le code du bouton %. Ce code applique deux règles différentes :

Avec +
:   Prenez 10% du premier nombre.`10% of 200 = 20 → 200 + 20 = 220`

Avec ×
:   Transformez 10% en 0,1.`200 × 0.1 = 20`

### 3. Essayer le bouton %

Nous avons reproduit les deux règles ci-dessous. Choisissez + ou ×, appuyez sur %, puis sur =.

200 +
**20**

10% de 200 = 20. Alors 200 + 20 = 220.

Illustration interactive de la règle du pourcentage inspecté.

Voir le vrai code et comment la réponse a été vérifiée

Pour cet exemple, `previous = 200` et `current = 10`.

Résumé lisible du gestionnaire %

```
if (operation == multiply || operation == divide) {
  percent = current / 100;
} else {
  percent = current * previous / 100;
}
```

De l'application installée à un bouton % fonctionnel

1. 01 · REA lit calc.exe

   Il lance l'application Calculatrice

   Le code s'ouvre `ms-calculator:`. L'agent sélectionne ensuite la bibliothèque de l'application installée.
2. 02 \* REA lit la bibliothèque

   Renvoie le code du gestionnaire %

   La fonction vérifie l'opérateur et utilise la constante `100`.
3. 03 \* Votre agent l'interprète

   Expliquer et reproduire les règles

   Vérifiez la branche avec la source de Microsoft, puis essayez + et × ci-dessus.

REA \* instructions d'origine sélectionnées

```
0x180124945: MOV EAX, dword ptr [R13 + 0x18]
0x180124949: CMP EAX, 0x5c
0x18012494c: JZ 0x180124aba
0x180124952: CMP EAX, 0x5b
0x180124955: JZ 0x180124aba
0x18012495b: MOV EDX, 0x64
```

Identifiants de l'opérateur \* Source de Microsoft

```
#define IDC_MUL 92      // 0x5c
#define IDC_DIV 91      // 0x5b
#define IDC_PERCENT 118 // 0x76

0x64 = 100
```

Inspecté avec la version 4.1.0 de REA: Calculatrice 11.2508.4.0, x64 de Windows. Le résumé lisible utilise des noms de la source publique de Microsoft pour expliquer la branche récupérée.

[Pourcentage de mise en œuvre](https://github.com/microsoft/calculator/blob/d125246a4e19842ce1332e6c7839cf0e110027d8/src/CalcManager/CEngine/scifunc.cpp#L98-L111) · [Scénarios de test de Microsoft](https://github.com/microsoft/calculator/blob/d125246a4e19842ce1332e6c7839cf0e110027d8/src/CalculatorUnitTests/CalculatorManagerTest.cpp#L350-L370) · [Guide de configuration natif](https://rea.tools/guides/native/)

## Études de cas REA.

Explorez une fonction d'une application ou d'un jeu publié, avec du code et des résultats vérifiés.

[Vitrines →](https://rea.tools/fr/showcase/)

Pour Android · APK analyse

### Comment un authentificateur génère un code de connexion

Suivez le code de connexion à six chiffres d'Aegis dans son APK publié, puis déplacez l'horloge de démonstration pour comprendre pourquoi il change toutes les 30 secondes.

[Lire l'étude de cas Android](https://rea.tools/showcase/aegis/)

Electron \* Traçage des fonctionnalités

### Comment Notion copie du texte et du code HTML

Suivez le JavaScript empaqueté de Notion jusqu'au presse-papiers système pour voir comment une copie préserve les données riches des blocs.

[Lire l'étude de cas Notion](https://rea.tools/fr/showcase/notion/)

Reconstruction indigène ·

### Calcul de la position sonore gauche/droite de DX-Ball

Retrouvez comment la position d'une balle devient un son à gauche ou à droite dans un jeu Windows de 1996.

[Lire l'étude de cas DX-Ball](https://rea.tools/fr/showcase/dx-ball/)

## Créer des environnements RL

Transformez une session enregistrée d’application web en environnement exécutable pour entraîner et tester des agents IA.

Votre agent enregistre les requêtes du navigateur et les réponses de l’application. REA utilise ces données pour créer un environnement local où les agents peuvent s’exercer sans exécuter l’application d’origine.

Pour permettre la suppression d’un dossier, l’enregistrement doit montrer le dossier avant sa suppression et confirmer qu’il n’existe plus ensuite.

[Guide de création d’un environnement](https://rea.tools/guides/rl-environments/) · [Voir la démo sur X](https://x.com/reatools/status/2112574822584918075?s=20)

Configurez REA dans votre agent, puis adaptez l’URL et les tâches sur les dossiers à votre application :

Votre agent de codage

Utilise REA pour créer un environnement RL à partir de mon application web de test à `http://127.0.0.1:3000`. Couvre la liste, la création, le renommage et la suppression de dossiers. Tu peux créer et supprimer des dossiers de test. Ne modifie pas les données existantes. Enregistre-le dans un dossier nommé `my-env`, vérifie les opérations disponibles et explique-moi comment le lancer.

Exemple de prompt. Adaptez l’URL et les tâches sur les dossiers à votre application.

Votre première enquête

## Essayez REA sur une petite application.

Téléchargez notre exemple de Notes, tracez son exportation CSV et vérifiez une entrée modifiée.

[Essayez l'exemple guidé](https://rea.tools/fr/first-investigation/)

## Choisissez votre cible.

Ces guides couvrent l'installation et une première investigation pour chaque type de logiciel.

### Programmes en code machine

Inspectez les fonctions, les chaînes, les références et les relations d'appel de fonction dans les exécutables et les bibliothèques.

[Guide d'analyse des programmes en code machine](https://rea.tools/guides/native/)

### JavaScript & Electron

Suivez le code d’une application de bureau écrite en JavaScript.

[Flux de travail des applications](https://rea.tools/guides/javascript/)

### Activité du navigateur et de l'exécution

Capturez l'activité du navigateur ou du processus sélectionné, puis comparez les résultats entre les exécutions.

[Guide d'observation du navigateur](https://rea.tools/fr/guides/browser/)

Essayer un projet plus ambitieux

Exemple d'invite \* Site Web

Utilisez REA pour inspecter https://rea.tools/. Clonez ce site pour moi.

Oui, celui-ci.

Exemple d'invite \* Reconstruction du jeu

Utilisez REA pour reconstruire ce jeu à partir de son exécutable. Récupérez la logique de jeu en C et testez-la par rapport à l'original.

[Voir l'étude de cas DX-Ball →](https://rea.tools/fr/showcase/dx-ball/)

## Des questions ?

[Consultez la FAQ](https://rea.tools/fr/faq/) pour obtenir de l’aide à l’installation et des réponses aux questions courantes.

[Rejoignez Discord](https://discord.gg/GkcryMnJDM) pour obtenir de l’aide et discuter de vos investigations.

Signalez un bug ou proposez une fonctionnalité dans [GitHub Issues](https://github.com/morluto/rea/issues/new/choose).
