Säkerhet

HTTP2Shell: Brotli-sårbarheten CVE-2026-111497 hotar applikationer

HTTP-klientattack via sårbara versioner av Google Brotli

CVE-2026-111497 i Brotli-avkodaren kan orsaka minneskorruption och RCE. Så påverkas Node.js, Python, Bun, Envoy, Istio och Docker.

HTTP2Shell: luka Brotli CVE-2026-111497 zagraża aplikacjom

Den kritiska sårbarheten CVE-2026-111497 i Brotli-avkodaren visade sig vara ett betydligt bredare problem än vad namnet Node2Shell först antydde. Felet finns nämligen inte i Node.js självt, utan i koden i Googles Brotli-bibliotek, som används av många runtime-miljöer, HTTP-bibliotek, proxyservrar, service mesh-system och applikationer.

Sårbarheten klassificeras som out-of-bounds write, det vill säga en skrivning utanför det tillåtna minnesområdet. En manipulerad Brotli-ström kan leda till att processens minne skadas, att processen kraschar, att delar av minnet avslöjas och, under vissa förhållanden, potentiellt även till fjärrkörning av kod.

Problemet gäller inte bara Node.js-applikationer. Dess påverkan har bland annat bekräftats för Python-paketet Brotli, Bun, Envoy och Istio-konfigurationer som använder Brotli-dekomprimering. Den sårbara koden kan också finnas som ett systemberoende, ett bibliotek som länkats statiskt till applikationen eller en del av en containeravbildning.

Detta är ett bra exempel på en sårbarhet i software supply chain: en sårbarhet långt ner i teknikstacken sprids till många till synes oberoende produkter.

Vad är Brotli och varför förekommer det i så många applikationer?

Brotli är en förlustfri komprimeringsalgoritm som utvecklas av Google. Den används i stor utsträckning i HTTP-kommunikation för att minska storleken på data som skickas, till exempel HTML, CSS, JavaScript, JSON och API-svar.

I HTTP-trafik kan den bland annat förekomma i headern:

Content-Encoding: br

Ett standardscenario ser ut så här:

HTML / JSON / JavaScript
        |
        v
Brotli encoder
        |
        v
compressed data
        |
        v
network
        |
        v
Brotli decoder
        |
        v
original content

CVE-2026-111497 finns på avkodarsidan, inte i koden som ansvarar för själva komprimeringen av data.

Denna skillnad är avgörande.

En server som använder Brotli enbart för att komprimera sina egna svar som skickas till webbläsaren blir inte automatiskt sårbar via denna väg. Risken uppstår när en applikation eller infrastrukturell komponent dekomprimerar Brotli-data som kontrolleras av en opålitlig källa.

Vad orsakar CVE-2026-111497 exakt?

Problemet finns i Googles Brotli-avkodare, i filen:

c/dec/decode.c

och i logiken som hanterar byte av blocktyp under dekomprimering.

En viktig del är funktionen:

DecodeBlockTypeAndLength()

Brotli använder olika blocktyper och kodningsstrukturer under avkodningen. Avkodaren måste bland annat kunna skilja mellan situationer där:

data är giltiga

eller:

mer indata behövs

eller:

strömmen är ogiltig

I den sårbara versionen kunde ett specifikt ogiltigt fall vid byte av block behandlas på ungefär samma sätt som en tillfällig brist på data.

I praktiken innebar det att avkodaren kunde fortsätta arbeta trots att den borde ha avslutat behandlingen med ett formatfel.

Den förenklade mekanismen ser ut så här:

malformed Brotli stream
        |
        v
invalid block switch
        |
        v
avkodaren borde returnera:
FORMAT ERROR

istället:
NEED MORE INPUT
        |
        v
avkodaren fortsätter
        |
        v
internt tillstånd blir ogiltigt
        |
        v
skrivning utanför förväntad buffert

Node.js beskriver problemet som en möjlighet att fortsätta skriva data till en liten intern buffert efter att avkodaren redan hamnat i ett ogiltigt tillstånd.

Resultatet blir memory corruption.

Out-of-bounds write – varför är det så farligt?

http2shell brotli cve 2026 111497 2.warsaw.media

Out-of-bounds write innebär att programmet skriver data utanför det minnesområde som har reserverats för dem.

I en normal situation ska processen bara arbeta inom den tilldelade bufferten:

[ valid buffer                      ]
[ 0 1 2 3 4 5 6 7 ]

Vid ett fel kan skrivningen se ut så här:

[ valid buffer      ][ other memory ]
[ 0 1 2 3 4 5 6 7 ][ X X X X X X ]
                       ^
                       |
                 oavsiktlig skrivning

Om en angripare kan kontrollera de data som skrivs och processens minneslayout på ett lämpligt sätt kan konsekvenserna bli betydligt allvarligare än att applikationen bara kraschar.

Det officiella säkerhetsmeddelandet nämner följande möjliga konsekvenser:

  • denial of service,
  • memory disclosure,
  • skada på processens tillstånd,
  • potentiell arbitrary code execution eller remote code execution.

Det betyder dock inte att alla sårbara system omedelbart kan tas över med en färdig exploit.

Finns det en fungerande RCE-exploit?

Detta är en av de viktigaste punkterna i hela historien.

Upstream-projektet Brotli och delar av säkerhetsmeddelandena beskriver sårbarheten som något som kan leda till körning av godtycklig kod. Node.js använder uttryckligen formuleringen att felet kan leda till remote code execution.

Samtidigt betonar Red Hat att det den 24 oktober 2026 inte finns någon offentlig och tillförlitlig RCE-exploit som stabilt kan ta över en sårbar process.

Mekanismer som:

ASLR
NX
FORTIFY_SOURCE
SELinux

försvårar omvandlingen av minnesfelet till praktisk kodkörning.

Den tekniskt korrekta formuleringen är därför:

CVE-2026-111497 är ett fjärråtkomligt memory corruption-fel som kan leda till RCE, men möjligheten att utnyttja det på ett tillförlitligt sätt beror på den specifika runtime-miljön, kompileringen, konfigurationen och systemets skydd.

Sårbarheten bör alltså inte bagatelliseras, men den bör inte heller beskrivas som en universell “one-click shell” som fungerar på alla system.

Varför anger vissa CVSS 9.2 Critical medan andra anger High?

Olika klassificeringar förekommer i källorna.

För själva Brotli-biblioteket och Python-paketet anger PyPA CVSS v4.0 9.2 – Critical.

Node.js har klassificerat CVE:t som High.

Red Hat har för sina produkter använt bedömningen Important samt CVSS 3.1 på 8.1. De betonar bland annat kraven på en manipulerad ström och de minnesskydd som finns i RHEL-system.

Detta är ingen motsägelse.

CVSS och risknivån kan bero på:

  • hur biblioteket är integrerat,
  • om den sårbara funktionen är tillgänglig,
  • standardkonfigurationen,
  • operativsystemets skydd,
  • hur opålitliga data når systemet.

Viktigare än själva CVSS-numret är därför att fastställa:

Dekomprimerar den aktuella processen verkligen Brotli-data som kommer från en angripare?

Attacken kan riktas mot både servern och HTTP-klienten

http2shell brotli cve 2026 111497 3.warsaw.media

En intressant aspekt av sårbarheten är att opålitliga data kan flöda i flera olika riktningar.

Attack mot servern

Om en applikation tar emot komprimerade request bodies och dekomprimerar:

Content-Encoding: br

kan en angripare försöka skicka en manipulerad Brotli-ström.

Modellen ser då ut så här:

angripare
   |
   | skadlig Brotli-begäran
   v
applikation / proxy
   |
   | Brotli-avkodare
   v
minneskorruption

Alla applikationer hanterar inte Brotli i request bodies.

Sårbarheten uppstår först när klientkontrollerade data faktiskt når den sårbara avkodaren.

Attack mot HTTP-klienten

Det andra scenariot är särskilt viktigt för applikationer som gör utgående anslutningar.

Föreställ dig följande kod:

const response = await fetch(userProvidedUrl)

Applikationen ansluter till en server som kontrolleras av angriparen.

Servern svarar:

HTTP/1.1 200 OK
Content-Encoding: br

och skickar en specialkonstruerad ström.

Om HTTP-klienten som används automatiskt dekomprimerar Brotli-svaret går data direkt till den sårbara avkodaren:

applikation
     |
     | HTTP-begäran
     v
angriparkontrollerad server
     |
     | skadligt Brotli-svar
     v
HTTP-klient
     |
     | automatisk dekomprimering
     v
sårbar Brotli-avkodare

Detta kan vara särskilt viktigt för:

  • crawlers,
  • scrapers,
  • system för URL-förhandsvisningar,
  • webhook-parsers,
  • proxyservrar,
  • säkerhetsskannrar,
  • system som hämtar dokument,
  • integrationstjänster,
  • AI-agenter som använder Internet.

I sådana projekt bör man inte bara kontrollera den egna koden, utan även IT-system- och API-integrationer, eftersom dekomprimeringen kan ske automatiskt inuti HTTP-klienten.

Node2Shell är egentligen inte en sårbarhet i Node.js

Det första brett omdiskuterade säkerhetsmeddelandet publicerades inom Node.js-ekosystemet.

Därifrån kommer namnet:

Node2Shell

Node.js paketerar dock en egen kopia av Brotli, och det är just koden i detta bibliotek som innehåller sårbarheten.

Problemet gäller de stödda linjerna:

Node.js 22.x
Node.js 24.x
Node.js 26.x

De korrigerade versionerna som publicerades den 21 oktober 2026 är:

Node.js-linje Version med korrigering
Node.js 22 22.23.4
Node.js 24 24.22.1
Node.js 26 26.12.1

Node.js-uppdateringarna innehåller en korrigering som motsvarar Googles upstream-ändring i Brotli.

Om applikationen körs på en äldre version i någon av dessa linjer bör runtime-miljön uppdateras.

Särskilt uppmärksamma bör projekt som använder:

node:zlib
BrotliDecompress
custom HTTP decompression

och andra bibliotek som skickar opålitliga data till den inbyggda Brotli-avkodaren.

Python använder också den sårbara koden

Efter att informationen om Node.js publicerats visade det sig att samma problem även gäller Python-ekosystemet.

Paketet:

Brotli

som finns på PyPI är en binding till Googles Brotli-kod.

Det handlar alltså inte om två oberoende sårbarheter:

Node.js-bugg
Python-bugg

Det handlar om ett problem:

Google Brotli decoder
        |
        +--> Node.js
        |
        +--> Python Brotli

PyPA publicerade säkerhetsmeddelandet PYSEC-2026-4322.

Den korrigerade versionen av Python-paketet:

Brotli 1.2.1

innehåller upstream-korrigeringen.

Det är också viktigt att applikationskoden inte uttryckligen behöver innehålla:

import brotli

Applikationen kan använda ett HTTP-bibliotek som automatiskt aktiverar Brotli-stöd om det nödvändiga paketet finns i miljön.

Detta är ytterligare ett exempel på att sårbarheten kan finnas i ett transitive dependency och inte direkt i applikationskoden.

Bun – sårbarheten kan nås via fetch()

Bun paketerar också Google Brotli.

Projektets officiella säkerhetsmeddelande anger:

affected:
>= 1.0.21, < 1.4.4

fixed:
1.4.4

Bun 1.4.3 innehöll Brotli 1.2.0.

Det är särskilt viktigt att populära API:er kan leda till avkodaren, bland annat:

fetch()
node:zlib
DecompressionStream("brotli")

fetch() hanterar komprimerade HTTP-svar automatiskt. En applikation som hämtar data från en opålitlig server kan därför omedvetet köra den sårbara koden.

Om applikationen har kompilerats som en fristående executable med Bun räcker det inte att uppdatera verktyget.

Artefakten måste byggas om, eftersom runtime-miljön kan vara direkt inlagd i den körbara filen.

Envoy – kritisk risk i proxyskiktet

CVE-2026-111497 har även nått Envoy.

Envoys officiella säkerhetsmeddelande klassificerar problemet som Critical och anger möjlighet till:

  • memory corruption,
  • memory disclosure,
  • denial of service,
  • potentiell arbitrary code execution.

Sårbarheten gäller distributioner där följande har konfigurerats:

Brotli decompressor

De korrigerade versionerna är:

Envoy Version med korrigering
1.40 1.40.0
1.39 1.39.3
1.38 1.38.6
1.37 1.37.8
1.36 1.36.12

Det betyder inte att varje publik Envoy automatiskt är sårbar.

Det avgörande är om Brotli-dekomprimeraren används aktivt.

Detta är särskilt viktigt i mikrotjänstarkitekturer, API-gateways och Kubernetes-miljöer, där HTTP-trafik automatiskt kan behandlas i flera infrastrukturlager.

Istio kräver också uppmärksamhet

Istio använder Envoy som proxylager.

Därför kan problemet även gälla Istio-konfigurationer som aktiverar Brotli-dekomprimering, till exempel genom ett lämpligt EnvoyFilter.

Korrigeringar finns bland annat i:

Istio 1.29.9
Istio 1.30.6
Istio 1.31.2

Man måste samtidigt ta hänsyn till supportcykeln för de olika linjerna. Att en teknisk korrigering finns i en gammal gren betyder inte att det är lämpligt att stanna kvar på en version som inte längre stöds.

I produktionsmiljöer bör uppdateringen vara en del av en bredare policy för DevOps, infrastruktur och systemförvaltning, inte en engångsreaktion på ett enskilt CVE.

Sårbara versioner av Google Brotli

Enligt det officiella säkerhetsmeddelandet är följande versioner sårbara:

1.0.3 - 1.0.9
1.1.0
1.2.0

De korrigerade versionerna i respektive linje är:

1.0.10
1.1.1
1.2.1

Det säkraste valet för ett aktivt utvecklat projekt är att gå över till den aktuella versionen med support, i stället för att stanna kvar på en gammal gren bara för att den har fått en enskild patch.

Korrigeringen var känd tidigare, men först inte som en säkerhetssårbarhet

En intressant del av historien bakom CVE-2026-111497 är en commit i Google Brotli:

0ed4268a4401abcb4472096340477cf4af7d1a2b

med rubriken:

Detect and report invalid stream earlier.

Ändringen skiljer bland annat en ogiltig blockväxling från en situation som kräver ytterligare data.

Ett nytt fel lades till:

BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH

Tack vare detta avbryter avkodaren arbetet i stället för att fortsätta med ett ogiltigt tillstånd.

Det viktiga supply chain-problemet var att kodkorrigeringen hade funnits tidigare, men att dess säkerhetsmässiga betydelse inte först identifierades.

Följande scenario är därför möjligt:

bug fixed upstream
        |
        v
not recognized as security issue
        |
        v
downstream projects do not urgently backport
        |
        v
CVE published later
        |
        v
many ecosystems must patch at once

Det visar varför det inte alltid räcker att enbart bevaka CVE-nummer.

Varför är HTTP2Shell ett mer träffande namn än Node2Shell?

Node2Shell antyder:

Node.js vulnerability

Den verkliga modellen ser snarare ut så här:

Google Brotli
     |
     +--> Node.js
     |
     +--> Python
     |
     +--> Bun
     |
     +--> Envoy
     |
     +--> Istio
     |
     +--> OS packages
     |
     +--> statically linked applications
     |
     +--> other HTTP software

Därför har beteckningen:

HTTP2Shell

börjat förekomma i branschanalyser.

Det är dock inte det officiella namnet på sårbarheten.

Den officiella identifieraren är fortfarande:

CVE-2026-111497

Node2Shell och HTTP2Shell bör därför ses som mediala namn som hjälper till att beskriva problemets omfattning.

Docker – det räcker inte att starta om containern

Sårbarheten är särskilt lätt att missa i containerbaserade miljöer.

Anta att avbildningen byggdes med en sårbar runtime-miljö:

FROM node:24

Om den körande avbildningen innehåller en sårbar version av Node.js eller systemets Brotli-bibliotek löser följande kommando ingenting:

docker restart app

Containern startas om med exakt samma binärfiler.

Den korrekta processen bör se ut så här:

update base image / dependency
        |
        v
update lock files
        |
        v
build new image
        |
        v
security scan
        |
        v
deploy new image
        |
        v
verify runtime versions

I praktiken är det lämpligt att kontrollera versionen direkt inuti den körande containern:

docker exec <container> node -v

Kontrollera även systempaket och applikationens beroenden.

Detta är ett bra exempel på varför containersäkerhet kräver regelbunden uppdatering av avbildningar, inte bara omstarter av tjänster.

Systempaket kan ha ett gammalt versionsnummer och ändå innehålla korrigeringen

I Linux-miljöer måste man ta hänsyn till ytterligare en detalj.

Distributioner som Debian och Red Hat backportar ofta säkerhetskorrigeringar till äldre versioner av paket.

Debian 13 korrigerade CVE-2026-111497 i paketet:

brotli 1.1.0-2+deb13u1

Även om upstream-versionen fortfarande innehåller 1.1.0 har distributionspaketet korrigeringen.

En enkel jämförelse:

installed version < 1.2.1

kan därför ge fel resultat.

I Linux-system bör man kontrollera:

  • säkerhetsmeddelandet för den aktuella distributionen,
  • CVE-statusen för den aktuella versionen,
  • distributionspaketets fullständiga versionsnummer,
  • tillgängliga säkerhetsuppdateringar.

Detta är särskilt viktigt i äldre miljöer där modernisering av legacy-system kan skjutas upp i flera år och systemberoenden börjar avvika kraftigt från aktuell upstream.

Hur kontrollerar man om en applikation kan vara sårbar?

Att bara hitta ordet brotli i projektet avgör inte om det finns en exploaterbar väg.

Flera frågor måste besvaras.

1. Har applikationen en sårbar Brotli-implementation?

Kontrollera:

runtime
dependencies
transitive dependencies
system packages
container image
statically linked libraries

2. Dekomprimerar applikationen Brotli?

Leta bland annat efter:

Content-Encoding: br
Accept-Encoding: br
BrotliDecompress
node:zlib
DecompressionStream
HTTP client auto-decompression
proxy decompressor

3. Kan data komma från en opålitlig källa?

Den största risken uppstår när indata kontrolleras av:

internet user
external server
webhook sender
user-provided URL
external API
untrusted proxy peer

4. Är processen exponerad utan autentisering?

Om angriparen inte behöver ett konto eller andra behörigheter ökar den verkliga risken.

5. Har komponenten som används redan korrigerats?

Kontrollera säkerhetsmeddelandet från den specifika produktens leverantör, inte bara en generell CVE-databas.

Vad bör man göra nu?

http2shell brotli cve 2026 111497 4.warsaw.media

Om Brotli förekommer i miljön är det lämpligt att följa en enkel ordning.

Node.js

Uppdatera till minst:

22.23.4
24.22.1
26.12.1

beroende på vilken stödd linje som används.

Python

Uppdatera:

Brotli >= 1.2.1

Om brotlicffi används bör man installera en version som innehåller upstream-korrigeringen och kontrollera projektets säkerhetsmeddelande.

Bun

Uppdatera till:

Bun >= 1.4.4

och bygg om en executable som skapats med Bun om den innehåller runtime-miljön.

Envoy

Byt till en korrigerad version i en stödd gren, bland annat:

1.40.0
1.39.3
1.38.6
1.37.8

Istio

Använd en korrigerad version som fortfarande stöds.

Linux-system

Installera de säkerhetsuppdateringar som distributionen tillhandahåller.

Docker och CI/CD

Bygg om avbildningarna från grunden med korrigerade beroenden, kör en säkerhetsskanning och verifiera versionerna i de processer som faktiskt körs.

Sådana åtgärder bör vara en del av det regelbundna underhållet och utvecklingen av applikationer och programvara, särskilt för publikt exponerade applikationer.

Vad gör man om en uppdatering ännu inte är möjlig?

Den bästa lösningen är fortfarande att installera korrigeringen.

Om det inte kan göras omedelbart är en tillfällig riskreducerande åtgärd att ta bort den väg som leder opålitliga data till Brotli-avkodaren.

Beroende på arkitekturen kan det innebära att:

  • inaktivera valfritt Brotli-stöd,
  • avvisa request bodies med Content-Encoding: br,
  • ta bort br från Accept-Encoding,
  • inaktivera automatisk dekomprimering av svar,
  • begränsa anslutningar till betrodda värdar,
  • inaktivera Brotli-dekomprimeraren i proxyn,
  • införa nätverksbegränsningar för den sårbara tjänsten.

Man måste dock vara uppmärksam på en detalj.

Att bara ta bort:

Accept-Encoding: br

garanterar inte säkerheten.

En skadlig server kan svara med:

Content-Encoding: br

även om klienten inte begärde det.

Om biblioteket automatiskt behandlar en sådan header kan den sårbara vägen fortfarande aktiveras.

Mitigeringen måste därför blockera dekomprimeringen innan data når den sårbara avkodaren.

Varför är CVE-2026-111497 viktigt för software supply chain?

Den mest intressanta aspekten av HTTP2Shell är inte själva felet i komprimeringsalgoritmen.

Det är hur felet sprids.

En utvecklare kan skriva en applikation med:

Nuxt
Node.js
Python API
microservice
proxy

och aldrig medvetet lägga till Google Brotli i projektet.

Trots det kan den sårbara koden hamna i produktion som:

bundled runtime dependency
transitive Python dependency
system package
proxy dependency
container layer
statically linked library

Det innebär att den klassiska frågan:

“Använder vi det här biblioteket?”

inte längre räcker.

En bättre fråga är:

“Innehåller någon komponent i vårt körande system den här koden, och kan opålitliga data nå den?”

Detta är en grundläggande skillnad i säkerhetsanalysen av moderna applikationer.

Alla system med Brotli är inte praktiskt sårbara

Kritiska CVE:er kan lätt leda till överdrivna tolkningar.

Det räcker inte att konstatera:

Brotli installed
=
RCE

Det verkliga villkoret är mer komplext:

vulnerable decoder
        +
attacker-controlled Brotli stream
        +
reachable decompression path
        =
exposure

Dessutom beror framgångsrik kodkörning på plattformen och minnesskydden.

Prioriteringen bör därför ta hänsyn till den verkliga attackvägen.

Högsta prioritet bör ges till system som:

  • är offentligt tillgängliga,
  • automatiskt dekomprimerar Brotli,
  • hämtar innehåll från adresser som kontrolleras av användare,
  • behandlar request bodies med Content-Encoding: br,
  • använder proxyservrar med aktiv Brotli-dekomprimerare,
  • kör okorrigerade runtime-miljöer.

HTTP2Shell visar problemet med beroenden som inte syns i applikationskoden

CVE-2026-111497 illustrerar ett modernt säkerhetsproblem väl.

Sårbarheten finns i en enda fil i ett C-bibliotek.

Konsekvenserna uppstår samtidigt i:

Node.js
Python
Bun
Envoy
Istio
Linux distributions
containers
HTTP clients
custom applications

Det visar att gränsen mellan applikations- och infrastruktursäkerhet i praktiken håller på att försvinna.

En frontend eller backend kan vara korrekt skriven och ändå vara sårbar på grund av en del inbyggd native-kod flera lager längre ner.

Sammanfattning

CVE-2026-111497 är en kritisk sårbarhet av typen out-of-bounds write i Googles Brotli-avkodare.

Det är inte enbart ett Node.js-problem.

Den sårbara koden har hamnat i många projekt och miljöer, bland annat:

  • Node.js,
  • Python Brotli,
  • Bun,
  • Envoy,
  • Istio,
  • systempaket och applikationer som paketerar biblioteket.

En manipulerad Brotli-ström kan leda till minneskorruption i processen, informationsläckage, denial of service och potentiellt även fjärrkörning av kod.

Samtidigt är inte alla system som har Brotli automatiskt exploaterbara. Det avgörande villkoret är att en angripare kan leverera data till den sårbara dekomprimeringsvägen.

De viktigaste åtgärderna är:

identify affected components
        |
        v
verify decompression paths
        |
        v
update runtime / library
        |
        v
rebuild containers and binaries
        |
        v
redeploy
        |
        v
verify running versions

För publika system och komponenter som automatiskt dekomprimerar data från Internet bör uppdateringen prioriteras.

HTTP2Shell visar också något större: en enskild sårbarhet i ett lågnivåbibliotek kan inom några dagar bli ett problem för flera programmeringsspråk, runtime-miljöer, proxyservrar och hela molnplattformar.

Källor