zlib: Port fix for CVE-2018-25032 to U-Boot
PATCH 1/1 zlib: Port fix for CVE-2018-25032 to U-Boot
While our copy of zlib is missing upstream commit 263b1a05b04e ("Allow deflatePrime() to insert bits in the middle of a stream.") we do have Z_FIXED support, and so the majority of the code changes in 5c44459c3b28 ("Fix a bug that can crash deflate on some input when using Z_FIXED.") apply here directly and cleanly. As this has been assigned a CVE, lets go and apply these changes.
--- lib/zlib/deflate.c | 64 +++++++++++++++++++++++++++++++++++----------- lib/zlib/deflate.h | 25 ++++++++---------- lib/zlib/trees.c | 50 ++++++++++-------------------------- 3 files changed, 74 insertions(+), 65 deletions(-)
lib/zlib/deflate.c +49 -15
@@ -223,11 +223,6 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,int wrap =1 ;static const char my_version[] =ZLIB_VERSION ; -ushf *overlay; -/* We overlay pending_buf and d_buf+l_buf. This works since the average -* output size for (length,distance) codes is <= 24 bits. -*/ -if (version ==Z_NULL || version[0 ] != my_version[0 ] || stream_size !=sizeof (z_stream)) {return Z_VERSION_ERROR ;
@@ -287,9 +282,47 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, s->lit_bufsize =1 << (memLevel +6 );/* 16K elements by default */ - overlay = (ushf *)ZALLOC (strm, s->lit_bufsize,sizeof (ush)+2 ); - s->pending_buf = (uchf *) overlay; - s->pending_buf_size = (ulg )s->lit_bufsize * (sizeof (ush)+2L ); +/* We overlay pending_buf and sym_buf. This works since the average size +* for length/distance pairs over any compressed block is assured to be 31 +* bits or less. +* +* Analysis: The longest fixed codes are a length code of 8 bits plus 5 +* extra bits, for lengths 131 to 257. The longest fixed distance codes are +* 5 bits plus 13 extra bits, for distances 16385 to 32768. The longest +* possible fixed-codes length/distance pair is then 31 bits total. +* +* sym_buf starts one-fourth of the way into pending_buf. So there are +* three bytes in sym_buf for every four bytes in pending_buf. Each symbol +* in sym_buf is three bytes -- two for the distance and one for the +* literal/length. As each symbol is consumed, the pointer to the next +* sym_buf value to read moves forward three bytes. From that symbol, up to +* 31 bits are written to pending_buf. The closest the written pending_buf +* bits gets to the next sym_buf symbol to read is just before the last +* code is written. At that time, 31*(n-2) bits have been written, just +* after 24*(n-2) bits have been consumed from sym_buf. sym_buf starts at +* 8*n bits into pending_buf. (Note that the symbol buffer fills when n-1 +* symbols are written.) The closest the writing gets to what is unread is +* then n+14 bits. Here n is lit_bufsize, which is 16384 by default, and +* can range from 128 to 32768. +* +* Therefore, at a minimum, there are 142 bits of space between what is +* written and what is read in the overlain buffers, so the symbols cannot +* be overwritten by the compressed data. That space is actually 139 bits, +* due to the three-bit fixed-code block header. +* +* That covers the case where either Z_FIXED is specified, forcing fixed +* codes, or when the use of fixed codes is chosen, because that choice +* results in a smaller compressed block than dynamic codes. That latter +* condition then assures that the above analysis also covers all dynamic +* blocks. A dynamic-code block will only be chosen to be emitted if it has +* fewer bits than a fixed-code block would for the same set of symbols. +* Therefore its average symbol length is assured to be less than 31. So +* the compressed data for a dynamic block also cannot overwrite the +* symbols from which it is being constructed. +*/ + + s->pending_buf = (uchf *)ZALLOC (strm, s->lit_bufsize,4 ); + s->pending_buf_size = (ulg )s->lit_bufsize *4 ;if (s->window ==Z_NULL || s->prev ==Z_NULL || s->head ==Z_NULL || s->pending_buf ==Z_NULL ) {
@@ -298,8 +331,12 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,deflateEnd (strm);return Z_MEM_ERROR ; } - s->d_buf = overlay + s->lit_bufsize/sizeof (ush); - s->l_buf = s->pending_buf + (1 +sizeof (ush))*s->lit_bufsize; + s->sym_buf = s->pending_buf + s->lit_bufsize; + s->sym_end = (s->lit_bufsize -1 ) *3 ; +/* We avoid equality with lit_bufsize*3 because of wraparound at 64K +* on 16 bit machines and because stored blocks are restricted to +* 64K-1 bytes. +*/ s->level = level; s->strategy = strategy;
@@ -935,7 +972,6 @@ int ZEXPORT deflateCopy (dest, source)#else deflate_state *ds;deflate_state *ss; -ushf *overlay;if (source ==Z_NULL || dest ==Z_NULL || source->state ==Z_NULL ) {
@@ -955,8 +991,7 @@ int ZEXPORT deflateCopy (dest, source) ds->window = (Bytef *)ZALLOC (dest, ds->w_size,2 *sizeof (Byte)); ds->prev = (Posf *)ZALLOC (dest, ds->w_size,sizeof (Pos)); ds->head = (Posf *)ZALLOC (dest, ds->hash_size,sizeof (Pos)); - overlay = (ushf *)ZALLOC (dest, ds->lit_bufsize,sizeof (ush)+2 ); - ds->pending_buf = (uchf *) overlay; + ds->pending_buf = (uchf *)ZALLOC (dest, ds->lit_bufsize,4 );if (ds->window ==Z_NULL || ds->prev ==Z_NULL || ds->head ==Z_NULL || ds->pending_buf ==Z_NULL ) {
@@ -970,8 +1005,7 @@ int ZEXPORT deflateCopy (dest, source)zmemcpy (ds->pending_buf, ss->pending_buf, (uInt )ds->pending_buf_size); ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); - ds->d_buf = overlay + ds->lit_bufsize/sizeof (ush); - ds->l_buf = ds->pending_buf + (1 +sizeof (ush))*ds->lit_bufsize; + ds->sym_buf = ds->pending_buf + ds->lit_bufsize; ds->l_desc.dyn_tree = ds->dyn_ltree; ds->d_desc.dyn_tree = ds->dyn_dtree;
lib/zlib/deflate.h +11 -14
@@ -211,7 +211,7 @@ typedef struct internal_state {/* Depth of each subtree used as tie breaker for trees of equal frequency */ -uchf *l_buf;/* buffer for literals or lengths */ +uchf *sym_buf;/* buffer for distances and literals/lengths */ uInt lit_bufsize;/* Size of match buffer for literals/lengths. There are 4 reasons for
@@ -233,13 +233,8 @@ typedef struct internal_state {* - I can't count above 4 */ -uInt last_lit;/* running index in l_buf */ - -ushf *d_buf; -/* Buffer for distances. To simplify the code, d_buf and l_buf have -* the same number of elements. To use different lengths, an extra flag -* array would be necessary. -*/ +uInt sym_next;/* running index in sym_buf */ +uInt sym_end;/* symbol table full when sym_next reaches this */ ulg opt_len;/* bit length of current block with optimal trees */ ulg static_len;/* bit length of current block with static trees */
@@ -318,20 +313,22 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,# define _tr_tally_lit (s, c, flush) \ { uch cc = (c); \ - s->d_buf[s->last_lit] = 0; \ - s->l_buf[s->last_lit++] = cc; \ + s->sym_buf[s->sym_next++] = 0; \ + s->sym_buf[s->sym_next++] = 0; \ + s->sym_buf[s->sym_next++] = cc; \ s->dyn_ltree[cc].Freq++; \ - flush = (s->last_lit == s->lit_bufsize-1); \ + flush = (s->sym_next == s->sym_end); \ }# define _tr_tally_dist (s, distance, length, flush) \ { uch len = (length); \ ush dist = (distance); \ - s->d_buf[s->last_lit] = dist; \ - s->l_buf[s->last_lit++] = len; \ + s->sym_buf[s->sym_next++] = dist; \ + s->sym_buf[s->sym_next++] = dist >> 8; \ + s->sym_buf[s->sym_next++] = len; \ dist--; \ s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ s->dyn_dtree[d_code(dist)].Freq++; \ - flush = (s->last_lit == s->lit_bufsize-1); \ + flush = (s->sym_next == s->sym_end); \ }#else # define _tr_tally_lit (s, c, flush) flush = _tr_tally(s, 0, c)
lib/zlib/trees.c +14 -36
90 lines not on this page · raw message
Signature · 1 line
2.25.1
Quoted 10 lines · Tom Rini
While our copy of zlib is missing upstream commit
263b1a05b04e("AllowdeflatePrime()to insert bits in the middle of a stream.") we do haveZ_FIXEDsupport, and so the majority of the code changes in5c44459c3b28("Fix a bug that can crash deflate on some input when usingZ_FIXED.") apply here directly and cleanly. As this has been assigned a CVE, lets go and apply these changes.
Applied to u-boot/next, thanks!
Signature · 1 line
Tom