> For the complete documentation index, see [llms.txt](https://blog.s1rn3tz.ovh/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://blog.s1rn3tz.ovh/autres-outils-utiles/assistance-ia.md).

# Assistance IA

## Codex (OpenAI)

Sources:

* &#x20;<https://www.yeswehack.com/fr/learn-bug-bounty/llm-series-codex>
* <https://learn.chatgpt.com/docs>

### Installation

Suivre les instructions d'installation du [site officiel](https://chatgpt.com/fr-FR/codex/):

```
$ curl -fsSL https://chatgpt.com/codex/install.sh | sh
```

### Environnement de travail

Pour une organisation optimale et sécurisée, créer un répertoire pour chaque cible/programme:

```
$ mkdir target-research
$ cd target-research
$ codex
```

Et créer des répertoires pour chaque éléments et phases des recherches:

```
target-research/
├── scope.md
├── recon/
├── requests/
├── scripts/
├── source/          # optionnel (si le code source est disponible et autorisé)
└── findings/
```

{% hint style="info" %}
Commandes utiles:

* **/model** - permet de choisir le modèle et le niveau d'effort
* **/permissions** - permet de contrôler l'accès des agents IA
* **/status** - permet de voir le status des sessions courantes
* **/agent** - permet de surveiller les threads des différents agent pendant qu'ils fonctionnent en parallèle
  {% endhint %}

## Multi-agentic

Une cible peut générer davantage de pistes de recherche plausibles qu'une seule fenêtre de contexte ne peut en explorer efficacement. Codex peut déléguer des tâches indépendantes à des sous-agents, conserver leurs traces brutes en dehors du fil d'exécution principal et combiner leurs conclusions.

Les sous-agents sont activés par défaut. Avant de les lancer, utilisez la commande `/permissions` pour sélectionner un environnement aux restrictions appropriées. Ils héritent de la sandbox et de la politique d'approbation de la session parente. Demandez ensuite directement à Codex de répartir le travail :

```
Investigate this authorised Bug Bounty target with four subagents.
Use only the assets defined in scope.md and the evidence in this workspace.

- Compare authentication, roles and authorisation boundaries.
- Trace untrusted data into sensitive operations.
- Inspect state changes across caches, queues or multiple requests.
- Look for discrepancies in methods, types, paths and encodings.

Wait for every agent, then return only evidence-backed candidates with
reproducible requests or source references.
```

```
You are an expert Pentester / Bug bounty hunter, find your scope in the scope.md file to first
get the context of your mission.
- Put all your recon processes and analyzes in the /recon folder
- Put all your findings assessments in the /assessments folder
- Put all your verified findings with Descriptions ands PoCs in the /findings folder
- For PoCs and exploits that needs to create a file like files uploads, exploits needing an externaly hosted payload etc use the /poc-files folder

Finally, prefer using the Burp MCP and Playwright MCP for your HTTP requests to keep logs and history of your requests.
```

Utilisez `/agent` dans l'interface en ligne de commande (CLI) pour examiner les threads ou basculer entre eux. Confiez à l'agent principal la gestion du registre des hypothèses ainsi que la validation finale. Le parallélisme n'améliore la couverture que si les agents explorent des idées réellement différentes. Répéter quatre fois la même recherche ne fait qu'augmenter la consommation de jetons.

## Skills

### Format

Un **Skill** est essentiellement un petit « module de savoir-faire » que tu donnes à ChatGPT/Codex.

Il contient :

```markdown
mon-skill/
├── SKILL.md              ← obligatoire
├── scripts/              ← optionnel
├── references/           ← optionnel
├── assets/               ← optionnel
└── agents/
    └── openai.yaml       ← optionnel
```

Le cœur du Skill est donc **`SKILL.md`**.

Il doit au minimum avoir :

```
---
name: mon-skill
description: Explique précisément quand ce skill doit être utilisé. # Le plus important, doit être le plus détaillé possible pour que l'IA puisse savoir à quelle moment elle doit l'utiliser
---

# Instructions

Voici les étapes que l'agent doit suivre...
```

Le `name` et surtout le `description` sont importants : ils permettent à Codex de savoir **quel Skill utiliser pour quelle tâche**.

### Stockage

```
.agents/
└── skills/
    └── mon-skill/
        └── SKILL.md
```

Où,

```
$CWD/.agents/skills/ # correspond aux skills spécifiques au projet
$HOME/.agents/skills/ # correspond aux skills personnels
/etc/codex/skills/ # correspond aux skills "administrateur" dans un environnement machine/container
```

### Utilisation

Il existe deux moyens d'invoquer des skills,

#### Invocation explicite

Tu demandes directement :

```
$mon-skill
```

Dans Codex CLI ou l'extension IDE, `$` permet de mentionner un Skill. `/skills` permet également d'accéder aux Skills disponibles.

#### Invocation automatique

L'invocation automatique se base sur la `description` de tes skills enregistrés comme vu précédemment, c'est l'IA qui détermine si elle doit utiliser le skill en analysant le contenu de la demande et en vérifiant si elle a un lien avec la description d'un skill existant (d'où l'intérêt de bien détailler les descriptions des skills.

### Scripts

Un Skill peut contenir des scripts :

```
my-skill/
├── SKILL.md
└── scripts/
    ├── validate.py
    └── generate_report.py
```

Mais la documentation recommande de **préférer les instructions** lorsque c'est suffisant.

Utilise un script lorsqu'il faut :

* un comportement déterministe ;
* effectuer un traitement complexe ;
* utiliser un outil externe ;
* éviter que le modèle réinvente une procédure ;
* produire systématiquement le même résultat.

En gros :

> **LLM pour le raisonnement, script pour ce qui doit être déterministe.**

### **Références**

Tu peux également embarquer des ressources :

```
my-skill/
├── SKILL.md
├── references/
│   ├── api-spec.md
│   └── conventions.md
└── assets/
    ├── template.json
    └── logo.svg
```

L'idée est de ne pas mettre toute la documentation dans `SKILL.md`.

Le `SKILL.md` explique **comment travailler**.

Les `references/` contiennent plutôt **les connaissances nécessaires**.

### OpenAI YAML

Tu peux ajouter :

```
agents/
  └── openai.yaml
```

Cela permet notamment de définir :

* le nom affiché dans l'interface ;
* une description courte ;
* des icônes ;
* une couleur ;
* un prompt par défaut ;
* la politique d'invocation ;
* des dépendances vers des outils/MCP.

Par exemple :

```
interface:
  display_name: "Code Reviewer"
  short_description: "Review code for bugs and security issues"

policy:
  allow_implicit_invocation: false
```

La partie particulièrement intéressante est :

```
allow_implicit_invocation: false
```

Cela signifie :

> **Codex ne déclenchera pas automatiquement ce Skill.**

Il faudra explicitement faire :

```
$code-reviewer
```

L'invocation explicite continue de fonctionner même lorsque l'invocation implicite est désactivée.

## MCP utiles

### Web

#### Playwright

Playwright est un MCP permettant de donner aux IA un accès à un navigateur web pour effectuer des  actions, lire le Javascript des pages:

```
codex mcp add playwright -- npx -y @playwright/mcp@latest \
  --proxy-server=http://127.0.0.1:8080 \  # To connect it to a proxy like burp or caido
  --ignore-https-errors
```

#### Burp Suite

Le plugin MCP de Burp Suite permet de donner un accès aux IA un accès aux différentes fonctionnalités de burp suite comme lire l'historique des requêtes, créer des tabs dans le repeater etc:

```
codex mcp add burp -- /path/to/java -jar /path/to/mcp-proxy-all.jar \
  --sse-url http://127.0.0.1:9876
```

### Mobile

#### APAIA

APAIA est un MCP permettant de donner aux IA des outils pour utiliser ADB et JADX.

Ressource: <https://github.com/mathis2001/APAIA>

#### Artemis

Artemis est un peu un équivalent de Playwright pour Android, il permet aux IA d'utiliser un appareil Android comme le ferait un humain.

Ressource: <https://github.com/google/artemis#mcp-setup>

### Reverse

#### Ghidra

Le MCP Ghidra donne aux IA l'accès à plus de 200 outils de reverse engineering.

Ressource: <https://github.com/bethington/ghidra-mcp>
