Heap buffer overflow in BrotliDecoderDecompressStream via block_length[2] underflow with zero-output dictionary transforms
Categories
(Core :: General, defect)
Tracking
()
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
- Branch: main
- Revision: 6164ea4bacaeaed1f617c11911df7fc32f2e6ec2
- Timestamp: 2026-04-02T19:36:24+00:00
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
- 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.
- 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).
- 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.
- 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.
- 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.
- 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.
- BROTLI_SAFE macro sets result=NEEDS_MORE_INPUT and jumps to saveStateAndReturn. State is saved as BROTLI_STATE_COMMAND_POST_DECODE_LITERALS.
- 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.
- 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.
- 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.
- 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, ...
- 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.
- 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).
- 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.
- 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
- Save gen_stream.py and server.py from external_services/.
- Start the malicious HTTP server: python3 server.py 9999 — wait ~5 seconds for it to generate the 22MB stream.
- Verify with: curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:9999/ (expect 200).
- Launch Firefox (ASAN+UBSan build) and load test.html which executes: fetch('http://127.0.0.1:9999/payload').then(r => r.text())
- 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.
- 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
Comment 1•7 months ago
|
||
Ryan, I see you've updated this the last few times, so maybe you have some idea what to do with this bug.
| Assignee | ||
Comment 2•7 months ago
|
||
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.
Comment 3•7 months ago
|
||
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.
| Reporter | ||
Comment 4•7 months ago
|
||
| Reporter | ||
Comment 5•7 months ago
|
||
| Reporter | ||
Comment 6•7 months ago
|
||
| Reporter | ||
Comment 7•7 months ago
|
||
| Reporter | ||
Comment 8•7 months ago
|
||
| Reporter | ||
Comment 9•7 months ago
|
||
| Reporter | ||
Comment 10•7 months ago
|
||
Updated•7 months ago
|
Updated•7 months ago
|
Updated•7 months ago
|
Updated•7 months ago
|
Comment 14•7 months ago
|
||
Actually, the attached README here says:
Google brotli commit 0ed4268a44 (Feb 27, 2026): "Detect and report invalid stream earlier"
jesup, can you check?
Comment 15•7 months ago
|
||
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
Comment 16•7 months ago
|
||
| Assignee | ||
Comment 17•7 months ago
|
||
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
| Assignee | ||
Comment 18•7 months ago
|
||
Updated•7 months ago
|
| Assignee | ||
Comment 19•7 months ago
|
||
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
| Assignee | ||
Updated•7 months ago
|
Updated•7 months ago
|
Comment 20•7 months ago
|
||
| Assignee | ||
Comment 21•7 months ago
|
||
Original Revision: https://phabricator.services.mozilla.com/D292992
Updated•7 months ago
|
Comment 22•7 months ago
|
||
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
| Assignee | ||
Comment 23•7 months ago
|
||
Original Revision: https://phabricator.services.mozilla.com/D292992
Updated•7 months ago
|
| Assignee | ||
Comment 24•7 months ago
|
||
Original Revision: https://phabricator.services.mozilla.com/D292992
Updated•7 months ago
|
Comment 25•7 months ago
|
||
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
Comment 26•7 months ago
|
||
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
Comment 27•7 months ago
|
||
Updated•7 months ago
|
Updated•7 months ago
|
Updated•7 months ago
|
Updated•7 months ago
|
Comment 28•7 months ago
|
||
| uplift | ||
Comment 29•7 months ago
|
||
| uplift | ||
Comment 30•7 months ago
|
||
| uplift | ||
Updated•7 months ago
|
Updated•7 months ago
|
Updated•2 months ago
|
Updated•19 days ago
|
Description
•