get_size_from_delta() inflates up to 20 bytes into stack-allocated delta_head[] and passes delta_head + sizeof(delta_head) to get_delta_hdr_size() twice, even when Z_STREAM_END stopped after fewer than 20 bytes. Meanwhile, get_delta_hdr_size() uses a do-while loop that unconditionally dereferences *data before checking data < top and returns a partial size when a varint's continuation bit is still set at top.
On a corrupt local packfile, a delta inflating to fewer than 20 bytes reads uninitialized stack bytes, and a 20-byte header whose bytes all have 0x80 set leaves data == top after the base-size read so the second get_delta_hdr_size() call reads 1 byte past delta_head[20].
Replace get_delta_hdr_size() with decode_delta_hdr_size(), returning -1 on EOF, unterminated varints, or size_t shift overflow so neither get_size_from_delta() nor patch_delta() treats a truncated varint as a zero-byte size, and bound top by stream.total_out.
Signed-off-by: Dominik Maier <dmnk@google.com> --- delta.h | 31 +++++++++++---- packfile.c | 11 ++++-- patch-delta.c | 6 +-- t/t5300-pack-object.sh | 86 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 120 insertions(+), 14 deletions(-)
Show changes to 4 files +120 −14
delta.h, packfile.c, patch-delta.c, t/t5300-pack-object.sh
diff --git a/delta.h b/delta.h index 42a211905d..9a7c0ad496 100644 --- a/delta.h +++ b/delta.h @@ -85,20 +85,35 @@ void *patch_delta(const void *src_buf, size_t src_size, /* * This must be called twice on the delta data buffer, first to get the * expected source buffer size, and again to get the target buffer size. + * Returns 0 on success and -1 on truncated or overflowing varints. */ -static inline size_t get_delta_hdr_size(const unsigned char **datap, - const unsigned char *top) +static inline int decode_delta_hdr_size(const unsigned char **datap, + const unsigned char *top, + size_t *sizep) { const unsigned char *data = *datap; size_t cmd, size = 0; - int i = 0; - do { + unsigned int i = 0; + + while (data < top) { cmd = *data++; - size |= st_left_shift(cmd & 0x7f, i); - i += 7; - } while (cmd & 0x80 && data < top); + if (i >= bitsizeof(size_t)) { + if (cmd & 0x7f) + return -1; + } else { + if (unsigned_left_shift_overflows(cmd & 0x7f, i)) + return -1; + size |= (cmd & 0x7f) << i; + i += 7; + } + if (!(cmd & 0x80)) { + *datap = data; + *sizep = size; + return 0; + } + } *datap = data; - return size; + return -1; } #endif diff --git a/packfile.c b/packfile.c index b32b4cd75d..bb6d0219ac 100644 --- a/packfile.c +++ b/packfile.c @@ -890,8 +890,9 @@ size_t get_size_from_delta(struct packed_git *p, struct pack_window **w_curs, off_t curpos) { - const unsigned char *data; + const unsigned char *data, *top; unsigned char delta_head[20], *in; + size_t size; git_zstream stream; int st; @@ -933,12 +934,16 @@ size_t get_size_from_delta(struct packed_git *p, * the result size. */ data = delta_head; + top = delta_head + stream.total_out; /* ignore base size */ - get_delta_hdr_size(&data, delta_head+sizeof(delta_head)); + if (decode_delta_hdr_size(&data, top, &size) < 0) + return 0; /* Read the result size */ - return get_delta_hdr_size(&data, delta_head+sizeof(delta_head)); + if (decode_delta_hdr_size(&data, top, &size) < 0) + return 0; + return size; } int unpack_object_header(struct packed_git *p, diff --git a/patch-delta.c b/patch-delta.c index 42199fa956..3e29e81f4e 100644 --- a/patch-delta.c +++ b/patch-delta.c @@ -27,12 +27,12 @@ void *patch_delta(const void *src_buf, size_t src_size, top = (const unsigned char *) delta_buf + delta_size; /* make sure the orig file size matches what we expect */ - size = get_delta_hdr_size(&data, top); - if (size != src_size) + if (decode_delta_hdr_size(&data, top, &size) < 0 || size != src_size) return NULL; /* now the result size */ - size = get_delta_hdr_size(&data, top); + if (decode_delta_hdr_size(&data, top, &size) < 0) + return NULL; dst_buf = xmallocz(size); out = dst_buf; diff --git a/t/t5300-pack-object.sh b/t/t5300-pack-object.sh index e5ce478484..972671abfc 100755 --- a/t/t5300-pack-object.sh +++ b/t/t5300-pack-object.sh @@ -766,4 +766,90 @@ test_expect_success '--path-walk thin pack' ' git -C server index-pack --fix-thin --stdin <out.pack ' +test_expect_success 'delta header decoding rejects truncated and unterminated varints' ' + test_when_finished "rm -rf delta-bounds" && + git init delta-bounds && + ( + cd delta-bounds && + printf "hello" >delta_base && + printf "\005\201\200\200" >corrupt_delta && + test_must_fail test-tool delta -p delta_base corrupt_delta delta_out && + : >empty_base && + printf "\200\200\200\200" >corrupt_empty_delta && + test_must_fail test-tool delta -p empty_base corrupt_empty_delta delta_out && + + test-tool genrandom base 4096 >base && + cat base >file && + test-tool genrandom oldtail 512 >>file && + git add file && + git commit -m base && + cat base >file && + test-tool genrandom newtail 1024 >>file && + git add file && + git commit -m delta && + git -c pack.writeReverseIndex=false repack -ad --window=10 --depth=10 && + idx=$(ls .git/objects/pack/pack-*.idx) && + pack=${idx%.idx}.pack && + chmod +w "$pack" "$idx" && + cp "$pack" "$pack.orig" && + cp "$idx" "$idx.orig" && + delta_line=$(git verify-pack -v "$idx" | awk '\''NF >= 7 && $2 == "blob" { print $1, $5; exit }'\'') && + delta_oid=${delta_line% *} && + offset=${delta_line#* } && + test -n "$delta_oid" && + test -n "$offset" && + algo=$(git rev-parse --show-object-format) && + + for mode in unterm oob trunc + do + cp "$pack.orig" "$pack" && + cp "$idx.orig" "$idx" && + chmod +w "$pack" "$idx" && + "$PERL_PATH" -MCompress::Zlib=compress -MDigest::SHA=sha1,sha256 -e '\'' + my ($pfile, $ifile, $off, $algo, $mode) = @ARGV; + my $hsz = ($algo eq "sha256") ? 32 : 20; + my $hash = ($algo eq "sha256") ? \&sha256 : \&sha1; + local $/; + + open my $pfh, "+<:raw", $pfile or die $!; + my $pdata = <$pfh>; + my $p = $off; + my $c = ord(substr($pdata, $p++, 1)); + my $type = ($c >> 4) & 7; + while ($c & 0x80) { $c = ord(substr($pdata, $p++, 1)); } + if ($type == 6) { + $c = ord(substr($pdata, $p++, 1)); + while ($c & 0x80) { $c = ord(substr($pdata, $p++, 1)); } + } elsif ($type == 7) { + $p += $hsz; + } else { + die "expected delta object, got type $type"; + } + my $raw = ($mode eq "unterm") ? + pack("C*", 0x81, (0x80) x 8, 0x00, 0xaa, (0x80) x 9) : + ($mode eq "oob") ? + pack("C*", (0x80) x 20) : + pack("C*", 0x05); + my $z = compress($raw); + die "compressed stream too large" if $p + length($z) > length($pdata) - $hsz; + substr($pdata, $p, length($z)) = $z; + my $psum = $hash->(substr($pdata, 0, -$hsz)); + substr($pdata, -$hsz, $hsz) = $psum; + seek $pfh, 0, 0 or die $!; + print $pfh $pdata or die $!; + close $pfh or die $!; + + open my $ifh, "+<:raw", $ifile or die $!; + my $idata = <$ifh>; + substr($idata, -2 * $hsz, $hsz) = $psum; + substr($idata, -$hsz, $hsz) = $hash->(substr($idata, 0, -$hsz)); + seek $ifh, 0, 0 or die $!; + print $ifh $idata or die $!; + close $ifh or die $!; + '\'' "$pack" "$idx" "$offset" "$algo" "$mode" && + test_must_fail git cat-file -s "$delta_oid" || return 1 + done + ) +' + test_done
-- 2.56.1.750.gf70dc682cf-goog