Copilot commented on code in PR #3856:
URL: https://github.com/apache/avro/pull/3856#discussion_r3564738297


##########
lang/php/lib/DataFile/AvroDataIOReader.php:
##########
@@ -220,18 +234,68 @@ private function readBlockHeader(): string|int
         return $this->decoder->readLong();
     }
 
+    /**
+     * The maximum number of bytes a single block is allowed to decompress to.
+     */
+    private static function maxDecompressLength(): int
+    {
+        $value = getenv(self::MAX_DECOMPRESS_LENGTH_ENV);
+        if (false !== $value && ctype_digit($value) && (int) $value > 0) {
+            return (int) $value;
+        }
+
+        return self::DEFAULT_MAX_DECOMPRESS_LENGTH;
+    }
+
+    /**
+     * @throws AvroDataIODecompressionSizeException if the length exceeds the 
limit
+     */
+    private static function checkDecompressLength(int $length, int 
$maxLength): void
+    {
+        if ($length > $maxLength) {
+            throw new AvroDataIODecompressionSizeException($maxLength);
+        }
+    }
+
     /**
      * @throws AvroException
      */
     private function gzUncompress(string $compressed): string
     {
-        $datum = gzinflate($compressed);
+        $maxLength = self::maxDecompressLength();
+        $context = inflate_init(ZLIB_ENCODING_RAW);
+        if (false === $context) {
+            throw new AvroException('gzip uncompression failed.');
+        }
 
-        if (false === $datum) {
+        // Inflate in chunks and check the running length after each step so an
+        // over-large (or malicious) block is rejected without materializing 
the
+        // full output, while genuine decompression errors (inflate_add === 
false)
+        // are reported distinctly. Pieces are collected and joined once at the
+        // end to avoid repeatedly reallocating a growing result string.

Review Comment:
   The comment says the oversized block is rejected "without materializing the 
full output", but the implementation still materializes the inflated output in 
chunks (via inflate_add) and only avoids concatenating it into one big string 
until the end. Rewording avoids implying a stronger memory-allocation guarantee 
than the code provides.



-- 
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