Closed Bug 2029458 (CVE-2026-111497) Opened 7 months ago Closed 7 months ago

Heap buffer overflow in BrotliDecoderDecompressStream via block_length[2] underflow with zero-output dictionary transforms

Categories

(Core :: General, defect)

defect

Tracking

()

RESOLVED FIXED
151 Branch
Tracking Status
firefox-esr115 150+ fixed
firefox-esr140 150+ fixed
firefox149 --- wontfix
firefox150 + fixed
firefox151 + fixed

People

(Reporter: bugmon, Assigned: RyanVM)

Details

(5 keywords, Whiteboard: [prefs-checked][pp1][adv-main150+r][adv-esr140.10+r][adv-esr115.35+r])

Attachments

(6 files, 4 external files, 1 obsolete file)

The brotli decoder vendored in Firefox contains a heap buffer overflow that can be triggered by a malicious HTTP server serving a crafted ~22MB brotli-compressed response. The decoder initializes block_length[2] to BROTLI_BLOCK_SIZE_CAP (1<<24 = 16,777,216) under the assumption that no metablock can issue more distance codes than its declared output size. However, the dictionary transform path at decode.c:2247 permits zero-output transforms when distance_code > 120 — each such command decrements block_length[2] without consuming any of meta_block_remaining_len. After 16M such commands, block_length[2] reaches zero while the metablock is still active.

When block_length[2]==0 and num_block_types[2]==1 (the default), DecodeBlockTypeAndLength returns BROTLI_FALSE at decode.c:1189 because there is no block-type tree to read. The BROTLI_SAFE macro at decode.c:2139 misinterprets this BROTLI_FALSE as BROTLI_DECODER_NEEDS_MORE_INPUT and jumps to saveStateAndReturn. The streaming retry loop at decode.c:2444-2455 then assumes one more input byte will allow progress: it writes that byte to s->buffer.u8[s->buffer_length++] and retries. Since the bug is structural rather than input-shortage, the retry hits the same BROTLI_FALSE indefinitely, and buffer_length grows past 8 with no bound check (BROTLI_DCHECK is compiled out in release builds).

The BrotliDecoderState struct places buffer_length (uint64_t), pos (int), max_backward_distance (int), max_distance (int), ringbuffer_size, ringbuffer_mask, dist_rb_idx, dist_rb[4], error_code, meta_block_remaining_len, and the ringbuffer pointer immediately after the 8-byte buffer.u8[] array. The attacker controls every byte written, allowing them to set buffer_length carefully (e.g., u8[8]=0x08 to keep the loop sequential), then overwrite pos with an arbitrary 32-bit offset and max_distance/max_backward_distance with values that bypass bounds checks. Once the unsafe ProcessCommands path activates, memmove16(&s->ringbuffer[pos], ...) at decode.c:2283 writes 16 bytes at an attacker-chosen heap offset. With further bytes the attacker can also corrupt the ringbuffer pointer itself for arbitrary write-what-where. This is a remote, no-interaction memory corruption — visiting any webpage that fetches a brotli resource from an attacker-controlled origin (or a MitM on plain HTTP) is sufficient.

Build Info

Affected Code

File: modules/brotli/dec/state.c, line 112-119

void BrotliDecoderStateMetablockBegin(BrotliDecoderState* s) {
  s->meta_block_remaining_len = 0;
  s->block_length[0] = BROTLI_BLOCK_SIZE_CAP;
  s->block_length[1] = BROTLI_BLOCK_SIZE_CAP;
  s->block_length[2] = BROTLI_BLOCK_SIZE_CAP;   /* Assumes max 16M distance codes */
  s->num_block_types[0] = 1;
  s->num_block_types[1] = 1;
  s->num_block_types[2] = 1;                    /* Single type → no block-switch tree */

File: modules/brotli/dec/state.h, line 264-280

  /* Temporary storage for remaining input. Brotli stream format is designed in
     a way, that 64 bits are enough to make progress in decoding. */
  union {
    uint64_t u64;
    uint8_t u8[8];
  } buffer;
  brotli_reg_t buffer_length;   /* uint64_t on 64-bit — first thing overwritten */

  int pos;                       /* used as ringbuffer index */
  int max_backward_distance;
  int max_distance;
  int ringbuffer_size;
  int ringbuffer_mask;
  int dist_rb_idx;
  int dist_rb[4];
  int error_code;
  int meta_block_remaining_len;

  uint8_t* ringbuffer;           /* eventually overwritable too */

File: modules/brotli/dec/state.h, line 388-390

/* Literal/Command/Distance block size maximum; same as maximum metablock size;
   used as block size when there is no block switching. */
#define BROTLI_BLOCK_SIZE_CAP (1U << 24)

File: modules/brotli/dec/decode.c, line 2241-2253

        } else {
          len = BrotliTransformDictionaryWord(&s->ringbuffer[pos], word, len,
              transforms, transform_idx);
          BROTLI_LOG(("[ProcessCommandsInternal] dictionary word: [%.*s],"
                      " transform_idx = %d, transformed: [%.*s]\n",
                      i, word, transform_idx, len, &s->ringbuffer[pos]));
          if (len == 0 && s->distance_code <= 120) {     /* BUG: distance_code > 120 escapes */
            BROTLI_LOG(("Invalid length-0 dictionary word after transform\n"));
            return BROTLI_FAILURE(BROTLI_DECODER_ERROR_FORMAT_TRANSFORM);
          }
        }
        pos += len;                                       /* len==0 → no progress */
        s->meta_block_remaining_len -= len;               /* len==0 → not consumed */

File: modules/brotli/dec/decode.c, line 1854

  --s->block_length[2];   /* Decremented unconditionally per distance code */

File: modules/brotli/dec/decode.c, line 1179-1191

static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
    int safe, BrotliDecoderState* s, int tree_type) {
  brotli_reg_t max_block_type = s->num_block_types[tree_type];
  const HuffmanCode* type_tree = &s->block_type_trees[
      tree_type * BROTLI_HUFFMAN_MAX_SIZE_258];
  const HuffmanCode* len_tree = &s->block_len_trees[
      tree_type * BROTLI_HUFFMAN_MAX_SIZE_26];
  BrotliBitReader* br = &s->br;
  brotli_reg_t* ringbuffer = &s->block_type_rb[tree_type * 2];
  brotli_reg_t block_type;
  if (max_block_type <= 1) {
    return BROTLI_FALSE;   /* BUG: returned to BROTLI_SAFE which treats it as NEEDS_MORE_INPUT */
  }

File: modules/brotli/dec/decode.c, line 1943-1953

#define BROTLI_SAFE(METHOD)                       \
  {                                               \
    if (safe) {                                   \
      if (!Safe##METHOD) {                        \
        result = BROTLI_DECODER_NEEDS_MORE_INPUT; \  /* Misinterprets structural FALSE */
        goto saveStateAndReturn;                  \
      }                                           \
    } else {                                      \
      METHOD;                                     \
    }                                             \
  }

File: modules/brotli/dec/decode.c, line 2138-2141

    if (BROTLI_PREDICT_FALSE(s->block_length[2] == 0)) {
      BROTLI_SAFE(DecodeDistanceBlockSwitch(s));   /* → BROTLI_FALSE → NEEDS_MORE_INPUT */
    }
    BROTLI_SAFE(ReadDistance(s, br));

File: modules/brotli/dec/decode.c, line 2444-2456

          } else if (*available_in != 0) {
            /* Not enough data in buffer, but can take one more byte from
               input stream. */
            result = BROTLI_DECODER_SUCCESS;
            BROTLI_DCHECK(s->buffer_length < 8);              /* COMPILED OUT in release */
            s->buffer.u8[s->buffer_length] = **next_in;        /* OOB WRITE: index 8, 9, 10... */
            s->buffer_length++;
            BrotliBitReaderSetInput(br, &s->buffer.u8[0], s->buffer_length);
            (*next_in)++;
            (*available_in)--;
            /* Retry with more data in buffer. */
            continue;                                          /* Loops forever — bug never clears */
          }

File: modules/brotli/common/platform.h, line 464-470

#if defined(BROTLI_DEBUG) || defined(BROTLI_ENABLE_LOG)
#define BROTLI_ENABLE_DUMP_DEFAULT 1
#define BROTLI_DCHECK(x) assert(x)
#else
#define BROTLI_ENABLE_DUMP_DEFAULT 0
#define BROTLI_DCHECK(x)              /* No-op in release — no protection */
#endif

File: modules/brotli/dec/decode.c, line 2270-2283

  } else {
    int src_start = (pos - s->distance_code) & s->ringbuffer_mask;
    uint8_t* copy_dst = &s->ringbuffer[pos];   /* pos is ATTACKER-CONTROLLED via overflow */
    uint8_t* copy_src = &s->ringbuffer[src_start];
    int dst_end = pos + i;
    int src_end = src_start + i;
    /* Update the recent distances cache. */
    s->dist_rb[s->dist_rb_idx & 3] = s->distance_code;
    ++s->dist_rb_idx;
    s->meta_block_remaining_len -= i;
    /* There are 32+ bytes of slack in the ring-buffer allocation.
       Also, we have 16 short codes, that make these 16 bytes irrelevant
       in the ring-buffer. Let's copy over them as a first guess. */
    memmove16(copy_dst, copy_src);   /* 16-byte heap write at attacker offset */

The vulnerability arises from an interaction between four pieces of code. (1) BrotliDecoderStateMetablockBegin in state.c assumes block_length[2]=16M is sufficient because a metablock cannot output more than 16M bytes — but it failed to account for commands that produce zero output. (2) The dictionary transform path explicitly permits len==0 when distance_code>120, creating the zero-output gadget. (3) DecodeBlockTypeAndLength returns BROTLI_FALSE when there is only one block type, which is semantically 'no block switch needed' but is indistinguishable from 'not enough input bits' to the BROTLI_SAFE macro. (4) The streaming retry loop trusts that NEEDS_MORE_INPUT means progress is possible with more bytes, and has only a debug-build assertion guarding the array bound. The BrotliDecoderState struct layout places critical state (buffer_length, pos, max_distance, ringbuffer pointer) immediately after the overflowed 8-byte buffer, turning a linear overflow into full decoder state corruption and ultimately a controlled heap write.

Exploit Chain

  1. Attacker-controlled HTTP server (or MitM on plain HTTP, or attacker-controlled subresource on any visited page) serves an HTTP response with Content-Encoding: br.
  2. The brotli stream header declares WBITS=10 (1KB ringbuffer), a 16MB metablock with NPOSTFIX=3, NDIRECT=0, 1 literal block type, 2 insert/copy block types (with initial block_length[1] > 16M to avoid that counter exhausting), and 1 distance block type (so num_block_types[2]=1 and block_length[2] is set to BROTLI_BLOCK_SIZE_CAP=16777216 by BrotliDecoderStateMetablockBegin in state.c).
  3. Single-symbol Huffman trees are encoded so each command is just 11 bits: cmd_code=130 (insert=0, copy=4, explicit distance) and distance code 184 with 11 extra bits = 4, yielding distance_code = 49121 + 4*8 = 49153.
  4. Since pos=0 (no output yet) max_distance=0, so 49153 > max_distance routes to the dictionary path. transform_idx = (49153-1)>>10 = 48 = OMIT_LAST_7. Applying OMIT_LAST_7 to a 4-byte word yields len = max(0, 4-7) = 0. Since distance_code=49153 > 120, decode.c:2247 does NOT reject this — pos += 0, meta_block_remaining_len -= 0.
  5. Each such command decrements block_length[2] (decode.c:1854) once. After 16,777,216 commands (~22MB of input, ~5-10 seconds CPU under ASAN), block_length[2]==0, but meta_block_remaining_len is still 16M and pos is still 0.
  6. The next iteration hits 'if (s->block_length[2] == 0)' at decode.c:2138, calling SafeDecodeDistanceBlockSwitch → DecodeBlockTypeAndLength(safe=1, s, 2). Since num_block_types[2]==1, decode.c:1189 returns BROTLI_FALSE.
  7. BROTLI_SAFE macro sets result=NEEDS_MORE_INPUT and jumps to saveStateAndReturn. State is saved as BROTLI_STATE_COMMAND_POST_DECODE_LITERALS.
  8. The attacker delivers 3 trailing zero bytes in the same network chunk: SafeReadSymbol's BrotliSafeGetBits(15) pulls 2 of them, leaving 1 byte unconsumed → s->buffer_length=1.
  9. Attacker sends a second network chunk. BrotliDecoderDecompressStream is called again with available_in>0 and buffer_length>=1, taking the path at decode.c:2417 which sets result=NEEDS_MORE_INPUT and enters the retry loop.
  10. The state machine re-enters CommandPostDecodeLiterals, immediately hits block_length[2]==0 again, gets BROTLI_FALSE again, returns NEEDS_MORE_INPUT again. Critically, br->next_in != br->last_in (the buffer wasn't consumed) and *available_in != 0.
  11. decode.c:2444-2455 fires: write next_in[0] at u8[buffer_length], increment buffer_length, retry. The retry hits the same structural BROTLI_FALSE — no progress is ever made. buffer_length grows: 2, 3, 4, 5, 6, 7, 8 (OOB), 9, 10, ...
  12. Bytes 8-15 of the second chunk overwrite buffer_length itself. The attacker sets byte at offset 7 (which becomes u8[8] = LSB of buffer_length) to 0x08 and bytes 8-14 to 0x00, so after the post-write increment buffer_length becomes 9 — keeping the loop sequential.
  13. Bytes 15-18 of the second chunk overwrite s->pos with an arbitrary 32-bit value (e.g., 0x10000000). Bytes 19-22 overwrite max_backward_distance, bytes 23-26 overwrite max_distance (set both to 0x7FFFFFFF so the bounds check at decode.c:2145 doesn't recompute max_distance, and any decoded distance < 0x7FFFFFFF takes the COPY path).
  14. Once buffer_length reaches a value where CheckInputAmount succeeds in the unsafe path, ProcessCommands runs with pos = 0x10000000. The COPY branch at decode.c:2272 computes copy_dst = &s->ringbuffer[0x10000000] and decode.c:2283 calls memmove16(copy_dst, copy_src) — a 16-byte heap write 256MB past a 1KB allocation.
  15. By writing further the attacker can also corrupt ringbuffer_mask, dist_rb, error_code, meta_block_remaining_len, and the ringbuffer pointer itself, yielding repeatable arbitrary heap writes sufficient for content-process RCE.

Steps to Reproduce

  1. Save gen_stream.py and server.py from external_services/.
  2. Start the malicious HTTP server: python3 server.py 9999 — wait ~5 seconds for it to generate the 22MB stream.
  3. Verify with: curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:9999/ (expect 200).
  4. Launch Firefox (ASAN+UBSan build) and load test.html which executes: fetch('http://127.0.0.1:9999/payload').then(r => r.text())
  5. After ~5-15 seconds (16M command decode loop), the content process crashes with UBSan: 'index 8 out of bounds for type uint8_t[8]' at /firefox/modules/brotli/dec/decode.c:2449.
  6. In a release build (BROTLI_DCHECK compiled out, no UBSan), the loop continues silently corrupting BrotliDecoderState fields, and the second-stage heap write at decode.c:2283 fires.

Security Impact

  • Severity: Critical
  • Attacker capability: A network attacker who can serve HTTP responses to the victim — i.e., any web server the user visits, any third-party origin embedded as a subresource, or a MitM on a plain-HTTP connection — can corrupt the BrotliDecoderState struct in the content process with fully attacker-controlled bytes. The struct layout gives byte-precise control over buffer_length (loop control), pos (used directly as a ringbuffer array index), max_backward_distance and max_distance (bounds-check bypass), ringbuffer_size, ringbuffer_mask, dist_rb[], error_code, meta_block_remaining_len, and ultimately the ringbuffer pointer itself. This yields a controlled heap write at &s->ringbuffer[attacker_pos] via memmove16, escalatable to arbitrary write-what-where by overwriting the ringbuffer pointer. This is a textbook RCE primitive in the content process. The only attacker cost is bandwidth (~22MB) and ~5-10 seconds of victim CPU time before the corruption begins.
  • Preconditions: None beyond standard web browsing. The victim must load a webpage that fetches any resource (HTML, JS, CSS, JSON, image, font, fetch/XHR — anything) from an attacker-controlled origin over HTTP or HTTPS. brotli is enabled by default and advertised in Accept-Encoding for all requests. No user interaction beyond page load. No non-default prefs. No special build configuration. The ~22MB payload size is large but well within normal web traffic and can be streamed.

ASAN Report

/firefox/modules/brotli/dec/decode.c:2449:13: runtime error: index 8 out of bounds for type 'uint8_t[8]' (aka 'unsigned char[8]')
    #0 0x7660eb5d32a7 in BrotliDecoderDecompressStream /firefox/modules/brotli/dec/decode.c:2449:44
    #1 0x7660e88c0cd8 in mozilla::net::nsHTTPCompressConv::BrotliHandler(nsIInputStream*, void*, char const*, unsigned int, unsigned int, unsigned int*) /firefox/netwerk/streamconv/converters/nsHTTPCompressConv.cpp:502:11
    #2 0x7660e7c438d7 in nsStringInputStream::ReadSegments(nsresult (*)(nsIInputStream*, void*, char const*, unsigned int, unsigned int, unsigned int*), void*, unsigned int, unsigned int*) /firefox/xpcom/io/nsStringStream.cpp:311:17
    #3 0x7660e88c3484 in mozilla::net::nsHTTPCompressConv::OnDataAvailable(nsIRequest*, nsIInputStream*, unsigned long, unsigned int) /firefox/netwerk/streamconv/converters/nsHTTPCompressConv.cpp:897:18
    #4 0x7660e8d0b553 in mozilla::net::HttpChannelChild::DoOnDataAvailable(nsIRequest*, nsIInputStream*, unsigned long, unsigned int) /firefox/netwerk/protocol/http/HttpChannelChild.cpp:832:29
    #5 0x7660e8d09387 in mozilla::net::HttpChannelChild::OnTransportAndData(nsresult const&, nsresult const&, unsigned long const&, nsTSubstring<char> const&) /firefox/netwerk/protocol/http/HttpChannelChild.cpp:725:3
    #6 0x7660e918ca23 in mozilla::net::ChannelEventQueue::FlushQueue() /firefox/netwerk/ipc/ChannelEventQueue.cpp:81:14
    #7 0x7660e91dcc11 in mozilla::net::ChannelEventQueue::MaybeFlushQueue() /firefox/netwerk/ipc/ChannelEventQueue.h:348:5
    #8 0x7660e91dcc11 in mozilla::net::ChannelEventQueue::CompleteResume() /firefox/netwerk/ipc/ChannelEventQueue.h:333:5
    #9 0x7660e91dcc11 in mozilla::net::ChannelEventQueue::ResumeInternal()::CompleteResumeRunnable::Run() /firefox/netwerk/ipc/ChannelEventQueue.cpp:140:17
    #10 0x7660e7cdbfd7 in mozilla::TaskQueue::Runner::Run() /firefox/xpcom/threads/TaskQueue.cpp:309:20
    #11 0x7660e7d038a7 in nsThreadPool::Run() /firefox/xpcom/threads/nsThreadPool.cpp:444:14
    #12 0x7660e7cf6a9a in nsThread::ProcessNextEvent(bool, bool*) /firefox/xpcom/threads/nsThread.cpp:1173:16
    #13 0x7660e7cff469 in NS_ProcessNextEvent(nsIThread*, bool) /firefox/xpcom/threads/nsThreadUtils.cpp:465:10
    #14 0x7660e976c091 in mozilla::ipc::MessagePumpForNonMainThreads::Run(base::MessagePump::Delegate*) /firefox/ipc/glue/MessagePump.cpp:297:20
    #15 0x7660e95adde4 in MessageLoop::RunInternal() /firefox/ipc/chromium/src/base/message_loop.cc:371:10
    #16 0x7660e95adde4 in MessageLoop::RunHandler() /firefox/ipc/chromium/src/base/message_loop.cc:364:3
    #17 0x7660e95adde4 in MessageLoop::Run() /firefox/ipc/chromium/src/base/message_loop.cc:346:3
    #18 0x7660e7ceef60 in nsThread::ThreadFunc(void*) /firefox/xpcom/threads/nsThread.cpp:374:10
    #19 0x7a6113aeb88f in _pt_root /firefox/nsprpub/pr/src/pthreads/ptthread.c:191:3
    #20 0x5c386a87bbf6 in asan_thread_start(void*) _asan_rtl_:28
    #21 0x7a61142f7aa3 in pthread_condattr_setpshared ??:?
    #22 0x7a6114384a63 in clone ??:0:0

SUMMARY: UndefinedBehaviorSanitizer: out-of-bounds-index /firefox/modules/brotli/dec/decode.c:2449:13

Ryan, I see you've updated this the last few times, so maybe you have some idea what to do with this bug.

Group: core-security → dom-core-security
Flags: needinfo?(ryanvm)

https://github.com/google/brotli/blob/master/SECURITY.md suggests that it should go through Google's regular vulnerability reporting process. I don't have any more specific knowledge around this library, however.

Flags: needinfo?(ryanvm)

jesup, maybe you could figure out what to do with this? It does look like the code right around where the OOB access is hasn't changed from upstream but I don't know if it is actually vulnerable or not. Thanks.

Flags: needinfo?(rjesup)
Attached file test.html —
Attached patch fix.patch — — Splinter Review
Attached file server.py —
Attached file gen_stream.py —
Attached file gen_stream.cpython-312.pyc (obsolete) —
Attached file README.md —
Attached file crash_stack.txt —
Whiteboard: [prefs-checked]
Whiteboard: [prefs-checked] → [prefs-checked][pp1]
Attachment #9565764 - Attachment is obsolete: true
Flags: needinfo?(rjesup)

Actually, the attached README here says:

Google brotli commit 0ed4268a44 (Feb 27, 2026): "Detect and report invalid stream earlier"

jesup, can you check?

Flags: needinfo?(rjesup)

Probably we should update to cfa184a997ac19454d5a3ae97f6d600aac2445a6 which was rolled into chromium 2 weeks ago. If there are other recent sec fixes this would pick them up

Flags: needinfo?(rjesup)

The most recent commit to the repo looks very-much like a sec fix too, so here's a Try push that takes us right up to that:
https://treeherder.mozilla.org/jobs?repo=try&revision=7004aee113f57cf2fc3c32795da9be5ce14d1d5a

Attached file (secure) —
Assignee: nobody → ryanvm
Status: UNCONFIRMED → ASSIGNED
Ever confirmed: true

Comment on attachment 9568019 [details]
(secure)

Security Approval Request

  • How easily could an exploit be constructed based on the patch?: From the initial comment in the bug, it sounds like it could be done pretty easily.
  • Do comments in the patch, the check-in comment, or tests included in the patch paint a bulls-eye on the security problem?: No
  • Which branches (beta, release, and/or ESR) are affected by this flaw, and do the release status flags reflect this affected/unaffected state correctly?: all
  • If not all supported branches, which bug introduced the flaw?: None
  • Do you have backports for the affected branches?: No
  • If not, how different, hard to create, and risky will they be?: Should be a clean cherry-pick to Beta. The ESR branches will be a bit more involved, but I did a bit of looking at them already and think it'll be pretty manageable.
  • How likely is this patch to cause regressions; how much testing does it need?: Unlikely, it's used in various parts of our codebase with good automated test coverage and also has upstream test coverage and a stable API.
  • Is the patch ready to land after security approval is given?: Yes
  • Is Android affected?: Yes
Attachment #9568019 - Flags: sec-approval?
Attachment #9568019 - Flags: sec-approval? → sec-approval+
Pushed by rvandermeulen@mozilla.com: https://github.com/mozilla-firefox/firefox/commit/85313de359ce https://hg.mozilla.org/integration/autoland/rev/128116e9e732 Update Brotli to upstream revision 4792c8e4c4235f6b501f13dbd07a8b4b253eee21. r=jesup
Attachment #9568210 - Flags: approval-mozilla-beta?

firefox-beta Uplift Approval Request

  • User impact if declined/Reason for urgency: sec-high
  • Code covered by automated testing?: yes
  • Fix verified in Nightly?: no
  • Needs manual QE testing?: no
  • Steps to reproduce for manual QE testing:
  • Risk associated with taking this patch: low
  • Explanation of risk level: Brotli has a stable API and is used enough throughout our codebase that any regressions are likely to be caught in automation.
  • String changes made/needed?: none
  • Is Android affected?: yes
Attachment #9568250 - Flags: approval-mozilla-esr140?
Attachment #9568255 - Flags: approval-mozilla-esr115?

firefox-esr140 Uplift Approval Request

  • User impact if declined/Reason for urgency: sec-high
  • Code covered by automated testing?: yes
  • Fix verified in Nightly?: no
  • Needs manual QE testing?: no
  • Steps to reproduce for manual QE testing:
  • Risk associated with taking this patch: low
  • Explanation of risk level: Brotli has a stable API and is used enough throughout our codebase that any regressions are likely to be caught in automation.
  • String changes made/needed?: none
  • Is Android affected?: yes

firefox-esr115 Uplift Approval Request

  • User impact if declined/Reason for urgency: sec-high
  • Code covered by automated testing?: yes
  • Fix verified in Nightly?: no
  • Needs manual QE testing?: no
  • Steps to reproduce for manual QE testing:
  • Risk associated with taking this patch: low
  • Explanation of risk level: Brotli has a stable API and is used enough throughout our codebase that any regressions are likely to be caught in automation.
  • String changes made/needed?: none
  • Is Android affected?: yes
Group: dom-core-security → core-security-release
Status: ASSIGNED → RESOLVED
Closed: 7 months ago
Resolution: --- → FIXED
Target Milestone: --- → 151 Branch
Attachment #9568210 - Flags: approval-mozilla-beta? → approval-mozilla-beta+
Attachment #9568250 - Flags: approval-mozilla-esr140? → approval-mozilla-esr140+
Attachment #9568255 - Flags: approval-mozilla-esr115? → approval-mozilla-esr115+
QA Whiteboard: [sec] [uplift] [qa-triage-done-c151/b150]
Whiteboard: [prefs-checked][pp1] → [prefs-checked][pp1][adv-main150+r][adv-esr140.10+r][adv-esr115.35+r]
Group: core-security-release
Alias: CVE-2026-111497
You need to log in before you can comment on or make changes to this bug.

Attachment

General

Created:
Updated:
Size: