> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/fr/useful-resources/bug-bounty/gitbook-ai-assistant-replay-poc.md).

# PoC de relecture de l’Assistant IA GitBook

Étude de cas PoC de relecture d’actions serveur de l’Assistant IA GitBook couvrant un risque de contournement d’autorisation corrigé, la relecture en mode aperçu, l’impact, les notes de détection et la remédiation.

[Jordanmacia/gitbook-ai-chat-replay-poc](https://github.com/Jordanmacia/gitbook-ai-chat-replay-poc) documente un problème corrigé de GitBook AI Assistant où le flux de requête pour une action de serveur Next.js pouvait être reconstruit à partir de données d'exécution visibles côté client et rejoué via un client local externe.

{% hint style="success" %}
Statut : corrigé. La vulnérabilité a été signalée à GitBook, et le backend applique désormais des contrôles côté serveur sur le droit d'accès, le périmètre et la session. Conservez cette page comme étude de cas historique de bug bounty, et non comme guide d'exploitation en conditions réelles.
{% endhint %}

## Pourquoi c'est important

GitBook présente AI Assistant comme une fonctionnalité payante du plan Ultimate. Si une vue d'aperçu ou de personnalisation expose des métadonnées de backend de production rejouables, et que le backend ne vérifie pas le droit d'accès et le périmètre côté serveur, le problème devient plus qu'un contournement de l'interface : il peut devenir un abus de fonctionnalité payante, un abus d'automatisation et potentiellement un abus de coût des ressources.

<figure><img src="https://raw.githubusercontent.com/Jordanmacia/gitbook-ai-chat-replay-poc/main/ultimate-pricing.png" alt="GitBook Ultimate pricing showing AI Assistant"><figcaption><p>AI Assistant est présenté comme faisant partie de la tarification GitBook Ultimate.</p></figcaption></figure>

<figure><img src="https://raw.githubusercontent.com/Jordanmacia/gitbook-ai-chat-replay-poc/main/preview-assistant.png" alt="GitBook Assistant preview mode"><figcaption><p>Le mode d'aperçu de l'assistant est exposé dans l'interface de personnalisation de GitBook.</p></figcaption></figure>

## Preuve de concept vidéo

{% embed url="<https://github.com/user-attachments/assets/2c265d4a-e3c7-4438-841d-d129600980e0>" %}

## Résumé de la découverte

| Domaine                | Notes                                                                                    |
| ---------------------- | ---------------------------------------------------------------------------------------- |
| Product                | Assistant IA GitBook.                                                                    |
| Type de recherche      | Étude de cas de divulgation responsable / type bug bounty.                               |
| Primitive fondamentale | Rejeu d'une requête d'action serveur.                                                    |
| Action du backend      | `streamAIChatResponse`.                                                                  |
| Risque principal       | Les vérifications de droit d'accès et de périmètre doivent être effectuées côté serveur. |
| Statut                 | Corrigé par GitBook.                                                                     |

La leçon importante est simple : un ID d'action serveur peut être visible dans du JavaScript côté client, mais il ne doit pas servir d'autorisation. Le backend doit quand même vérifier indépendamment le droit au plan, la propriété du site, les limites de l'aperçu/de la session, les contraintes CSRF/origine et les limites de débit.

## Impact

| Zone d'impact                              | Ce qui pourrait mal tourner                                                                      |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------ |
| Contournement d'une fonctionnalité payante | AI Assistant pourrait être utilisé en dehors du parcours d'interface prévu du plan Ultimate.     |
| Abus de l'aperçu                           | Le mode de personnalisation ou d'aperçu pourrait exposer des métadonnées de backend rejouables.  |
| Automatisation                             | Les requêtes à l'assistant pourraient être automatisées depuis un client personnalisé.           |
| Abus de coûts                              | Les ressources d'IA pourraient être consommées sans la barrière de droit d'accès attendue.       |
| Contournement de l'interface               | Les contrôles, invites ou barrières produit côté frontend uniquement pourraient être contournés. |

La gravité suggérée dépend de ce que le backend autorise réellement :

| Comportement confirmé                                                             | Gravité suggérée |
| --------------------------------------------------------------------------------- | ---------------- |
| Le rejeu ne fonctionne que pour les utilisateurs déjà autorisés                   | Moyen            |
| Le rejeu fonctionne depuis l'aperçu/la personnalisation sans droit d'accès payant | Élevé            |
| Le rejeu fonctionne pour n'importe quel site GitBook public sans droit d'accès    | Critique         |
| Le rejeu expose de la documentation privée sans autorisation                      | Critique         |

## Cause racine

Le schéma vulnérable est une erreur de frontière de confiance. Les données d'exécution visibles côté client peuvent aider à reconstruire la requête :

| Éléments exposés                 | Pourquoi c'est important                                                               |
| -------------------------------- | -------------------------------------------------------------------------------------- |
| ID d'action serveur              | Achemine la requête vers l'action backend.                                             |
| `spaceId`                        | Identifie l'espace GitBook.                                                            |
| `pageId`                         | Identifie le contexte de la page.                                                      |
| État RSC/routeur                 | Aide à correspondre à la forme de requête Next.js attendue.                            |
| Structure du corps de requête    | Montre comment l'appel à l'assistant est structuré.                                    |
| Cookies de session du navigateur | Transportent la session de l'utilisateur si elle est capturée lors de tests autorisés. |

Le bug n'est pas que « les actions serveur sont visibles ». Le problème apparaît lorsque le backend accepte une requête rejouée assemblée à partir de métadonnées observables côté client sans revérifier le droit d'accès, la propriété, le périmètre d'aperçu, la validité de session, le CSRF/l'origine et les limites de débit.

## Flux du PoC

Le dépôt contient un PoC Node.js local qui découvre les métadonnées d'exécution et lance un proxy HTTPS local.

```bash
npm start
```

Flux général :

1. Demander une page GitBook ou une URL d'aperçu.
2. Télécharger le HTML de la page.
3. Télécharger les fragments JavaScript de GitBook.
4. Extraire l'ID actuel `streamAIChatResponse` ID d'action serveur.
5. Extraire `spaceId` et `pageId`.
6. Ouvrir Chrome, Chromium ou Edge pour l'authentification.
7. Stocker les valeurs d'exécution requises dans `.env`.
8. Démarrer un proxy HTTPS local.

Puis ouvrir :

```
https://localhost:3001
```

L'interface locale communique avec :

```http
POST /api/chat
```

Le proxy recrée la requête GitBook AI Assistant avec des en-têtes équivalents à :

```http
accept: text/x-component
content-type: text/plain;charset=UTF-8
next-action: <discovered streamAIChatResponse action id>
next-router-state-tree: <router state>
origin: <target GitBook origin>
referer: <target GitBook URL>
cookie: <captured GitBook cookies>
```

Un rejeu réussi renvoie un flux React Server Components contenant des événements de réponse de l'IA. Le proxy local analyse la réponse finale et renvoie une réponse JSON normale pour l'interface du PoC.

## Signaux courants

| Réponse                   | Signification                                               |
| ------------------------- | ----------------------------------------------------------- |
| `400 Requête invalide`    | L'ID d'action serveur est obsolète ou incorrect.            |
| Flux RSC avec `empreinte` | L'action existe, mais le corps ou le contexte est invalide. |
| `401` / `403`             | Session ou autorisation refusée.                            |
| `text/x-component`        | Type de contenu du flux React Server Components attendu.    |

## Exigences

| Exigence   | Notes                                                   |
| ---------- | ------------------------------------------------------- |
| Node.js    | Version 18 ou plus récente.                             |
| Navigateur | Chrome, Chromium ou Microsoft Edge.                     |
| OpenSSL    | Nécessaire dans `PATH` pour le matériel HTTPS local.    |
| OS         | Windows, Linux et macOS sont pris en charge par le PoC. |

## Nettoyage

Utilisez la commande de nettoyage du dépôt après les tests :

```bash
npm run stop
```

Elle supprime les processus PoC en cours d'exécution, les valeurs sensibles, `.env` les fichiers TLS locaux générés et le profil d'authentification dédié du navigateur.

## Correction

Contrôles recommandés :

| Contrôle                                                                        | Objectif                                                             |
| ------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
| Appliquer le droit d'accès au plan à l'intérieur de `streamAIChatResponse`      | Empêcher le contournement de la fonctionnalité payante.              |
| Traiter `next-action` comme des métadonnées de routage                          | Éviter de confondre les ID d'action avec l'autorisation.             |
| Lier les appels d'aperçu à des jetons à courte durée de vie émis par le serveur | Conserver l'accès d'aperçu dans le périmètre de l'aperçu.            |
| Empêcher le rejeu des jetons d'aperçu                                           | Empêcher la réutilisation externe en dehors de la session prévue.    |
| Valider `spaceId` et `pageId` côté serveur                                      | S'assurer que le contexte demandé appartient au périmètre autorisé.  |
| Rejeter le contexte fourni par le client lorsqu'il ne correspond pas            | Empêcher l'échange de contexte.                                      |
| Appliquer le CSRF et des contrôles stricts de `Origine` vérification            | Réduire les abus intersites et automatisés.                          |
| Limiter le débit par utilisateur, organisation, site, IP et session             | Limiter l'automatisation et les abus de coût.                        |
| Surveiller le rejeu automatisé des actions serveur                              | Détecter les schémas de rejeu non liés au navigateur ou inhabituels. |

## Leçons retenues

1. Les fonctionnalités d'aperçu sont des frontières de sécurité lorsqu'elles interagissent avec des backends payants ou de production.
2. Les barrières côté client sont utiles pour l'expérience utilisateur, mais ce ne sont pas des autorisations.
3. Les ID d'action serveur Next.js doivent être traités comme des détails de routage publics.
4. Les fonctionnalités d'IA ont besoin de contrôles de coûts et de droit d'accès autant que de contrôles d'accès aux données.
5. Les rapports de bug bounty sont plus solides lorsqu'ils séparent le comportement observé, l'impact possible et la remédiation recommandée.

## Références

* [Jordanmacia/gitbook-ai-chat-replay-poc](https://github.com/Jordanmacia/gitbook-ai-chat-replay-poc)
* [README du dépôt](https://github.com/Jordanmacia/gitbook-ai-chat-replay-poc/blob/main/README.md)
* [Lanceur de PoC](https://github.com/Jordanmacia/gitbook-ai-chat-replay-poc/tree/main/scripts)
* [Proxy local](https://github.com/Jordanmacia/gitbook-ai-chat-replay-poc/blob/main/server.js)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://hacking-notes.jord4n.pro/fr/useful-resources/bug-bounty/gitbook-ai-assistant-replay-poc.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
