ColinLeeo opened a new issue, #1113:
URL: https://github.com/apache/tsfile/issues/1113

   ### Language
   
   C++
   
   ### Description
   
   `decode_block()` in every SPRINTZ decoder takes a short (RLE / Gorilla) 
block's value count straight from the header and writes that many values into 
`current_buffer_`, which only holds `block_size_ + 1` = 9 values. The count is 
never validated against the buffer size, so a malformed value page produces a 
heap out-of-bounds write while reading a file.
   
   A short block starts with a header byte whose MSB is set; the value count is 
the low seven bits:
   
   - `cpp/src/encoding/int32_sprintz_decoder.h:134`
   - `cpp/src/encoding/int64_sprintz_decoder.h:134`
   - `cpp/src/encoding/float_sprintz_decoder.h:132`
   - `cpp/src/encoding/double_sprintz_decoder.h:131`
   
   so `decode_size_` can be up to 127, and the loop immediately below (`:136` 
in int32, the same shape in the other three) writes `decode_size_` values into 
the 9-element buffer created at `int32_sprintz_decoder.h:45`. Both the 
per-value and the batch read paths reach this through `decode_block()`.
   
   A short block from the encoder always holds 1..8 values, but the decoder 
never enforces that. Int32/Int64 short blocks use the RLE decoder, whose 
pattern format can express a single run of up to 2^31 values in a few bytes; a 
crafted page therefore keeps `read_int` succeeding for all 127 iterations. 
Verified with this 6-byte page fed to `Int32SprintzDecoder`:
   
   ```
   0xFF        short-block header, decode_size = 127
   0x04        RLE pattern length (4 bytes)
   0x01        RLE bit width
   0xFE 0x01   RLE tag: run of 127
   0x00        run value
   ```
   
   Running the same pattern through `Int32RleDecoder` returns 127 successful 
reads, i.e. `decode_block()` would write `current_buffer_[9]` .. 
`current_buffer_[126]`, past the end of the vector. FLOAT/DOUBLE short blocks 
are Gorilla-encoded and reach the same loop bound with a different crafted 
payload.
   
   Java fails cleanly on this input: `IntSprintzDecoder.decodeBlock()` uses the 
same unvalidated `decodeSize`, but writes into a Java array, so it throws 
`ArrayIndexOutOfBoundsException`. The C++ decoder should reject the block 
instead of corrupting memory.
   
   Pre-existing: found while working on #1110 (batch decode) and intentionally 
left out of that PR.
   
   ### Steps to reproduce
   
   - Run the C++ test suite with `-DENABLE_ASAN=ON` and feed an INT32 SPRINTZ 
decoder a value page starting with the bytes above; ASAN reports a 
heap-buffer-overflow in `decode_block()`.
   - Without a sanitizer: replicate the loop with the same page and observe 127 
successful `read_int`/`read_int32` calls, more than the 9-element buffer can 
hold.
   
   ### Expected behavior
   
   `decode_block()` returns an error (matching Java) instead of writing past 
`current_buffer_`, with a regression test that feeds an over-counted short 
block header for all four types.
   


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to