brotli 0.9.0 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e39135e3c6e289c1b4f233d8e0bec31f1cfb6be48f63280b5a7609965b88459
-  data.tar.gz: 5f0bae9eb2e35baf822e7eff9e8432e24043893afe29c70506050d41c073bbaa
+  metadata.gz: 035e04e32804b36b5525cf4ba7688e19a199288e0056fcfceeeac67f11f72c9f
+  data.tar.gz: 8ce5e925a781060c0d46dfebd69beb367c62622fb808ef247906e0bf2229aaa8
 SHA512:
-  metadata.gz: 46ae27522c3cb015279531a8d6b91af3afcd40a0b61c552db76e7caa9562a547f8f4e2f09873f5e113314cbc0ffe811fcfdc9a0c02b84aa2df4ade1d005857e9
-  data.tar.gz: cc393196d928f8d761b83bf7f04415c7f1ddd1b2f113008063e9b99615004adf00af95171932d009efeeb0e6ad2f5edb3c26196610475b08a4e5db0d56e5e201
+  metadata.gz: 70c2bdf0f5028d80f5f0c578f89bf2c6818de1c9c4f795fe61aeeffbbcf570353d97699ce02f9e44e713f54e34fd9c0a745d9b6f3ef9e7f9b62e5ffc6f1b0707
+  data.tar.gz: dd17edfde50109928ca623452044288b6d369cd6a29706727248623f8ad6d03ea89857fd668e67ca01b22a1baf39b27fbd47c86635a2455ec1c1d2400c4c5d77

data/ext/brotli/brotli.c

@@ -74,6 +74,7 @@ typedef struct {
     BrotliDecoderResult r;
     uint8_t* dict;
     size_t dict_len;
+    int oom;
 } brotli_inflate_args_t;
 
 static void
@@ -116,14 +117,19 @@ brotli_inflate_no_gvl(void *arg)
         if (r != BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
             break;
         }
-        append_buffer(buffer, output, BUFSIZ);
+        if (append_buffer(buffer, output, BUFSIZ) != 0) {
+            args->oom = 1;
+            break;
+        }
         available_out = BUFSIZ;
         next_out = output;
     }
 
     if (r == BROTLI_DECODER_RESULT_SUCCESS) {
         if (next_out != output) {
-            append_buffer(buffer, output, next_out - output);
+            if (append_buffer(buffer, output, next_out - output) != 0) {
+                args->oom = 1;
+            }
         }
     }
     args->r = r;
@@ -166,6 +172,10 @@ brotli_inflate(int argc, VALUE *argv, VALUE self)
     args.len = (size_t)RSTRING_LEN(str);
     args.s = brotli_decoder_state_create();
     args.buffer = create_buffer(BUFSIZ);
+    if (!args.buffer) {
+        brotli_inflate_cleanup(&args);
+        rb_raise(rb_eNoMemError, "failed to allocate decompression buffer");
+    }
     args.r = BROTLI_DECODER_RESULT_ERROR;
 
     if (!NIL_P(dict)) {
@@ -180,6 +190,12 @@ brotli_inflate(int argc, VALUE *argv, VALUE self)
     RB_GC_GUARD(str);
     RB_GC_GUARD(dict);
 
+    /* Check before args.r: a failed final append leaves r at SUCCESS. */
+    if (args.oom) {
+        brotli_inflate_cleanup(&args);
+        rb_raise(rb_eNoMemError, "failed to allocate decompression buffer");
+    }
+
     if (args.r == BROTLI_DECODER_RESULT_SUCCESS) {
         int state = 0;
         value = rb_protect(brotli_inflate_take_result, (VALUE)&args, &state);
@@ -324,6 +340,7 @@ typedef struct {
     buffer_t* buffer;
     BROTLI_BOOL finished;
     BrotliEncoderPreparedDictionary* prepared_dict;
+    int oom;
 } brotli_deflate_args_t;
 
 static void
@@ -364,7 +381,11 @@ brotli_deflate_no_gvl(void *arg)
             args->finished = BROTLI_FALSE;
             break;
         } else {
-            append_buffer(buffer, output, next_out - output);
+            if (append_buffer(buffer, output, next_out - output) != 0) {
+                args->oom = 1;
+                args->finished = BROTLI_FALSE;
+                break;
+            }
             available_out = BUFSIZ;
             next_out = output;
 
@@ -418,6 +439,10 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
     }
     max_compressed_size = BrotliEncoderMaxCompressedSize(args.len);
     args.buffer = create_buffer(max_compressed_size);
+    if (!args.buffer) {
+        brotli_deflate_cleanup(&args);
+        rb_raise(rb_eNoMemError, "failed to allocate compression buffer");
+    }
     args.finished = BROTLI_FALSE;
 
     args.prepared_dict = NULL;
@@ -443,6 +468,10 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
     rb_thread_call_without_gvl(brotli_deflate_no_gvl, &args, NULL, NULL);
     RB_GC_GUARD(str);
     RB_GC_GUARD(dict);
+    if (args.oom) {
+        brotli_deflate_cleanup(&args);
+        rb_raise(rb_eNoMemError, "failed to allocate compression buffer");
+    }
     if (args.finished == BROTLI_TRUE) {
         int state = 0;
         value = rb_protect(brotli_deflate_take_result, (VALUE)&args, &state);

data/ext/brotli/buffer.c

@@ -1,18 +1,32 @@
 #include "buffer.h"
-#include "ruby/ruby.h"
 
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 
 #define BUFFER_INITIAL_SIZE 1024
 
+/*
+ * append_buffer runs inside rb_thread_call_without_gvl. A failing Ruby
+ * allocator there raises NoMemoryError past the caller's cleanup, so this
+ * buffer uses malloc/realloc/free and reports failure through return values.
+ */
+
 buffer_t*
 create_buffer(size_t initial)
 {
-    buffer_t *buffer = ruby_xmalloc(sizeof(*buffer));
+    buffer_t *buffer = malloc(sizeof(*buffer));
+
+    if (!buffer) {
+        return NULL;
+    }
     buffer->used = 0;
     buffer->size = initial > 0 ? initial : BUFFER_INITIAL_SIZE;
-    buffer->ptr = ruby_xmalloc(buffer->size);
+    buffer->ptr = malloc(buffer->size);
+    if (!buffer->ptr) {
+        free(buffer);
+        return NULL;
+    }
     return buffer;
 }
 
@@ -23,8 +37,8 @@ delete_buffer(buffer_t* buffer)
         return;
     }
 
-    ruby_xfree(buffer->ptr);
-    ruby_xfree(buffer);
+    free(buffer->ptr);
+    free(buffer);
 }
 
 static size_t
@@ -42,27 +56,37 @@ buffer_size_for(size_t current, size_t required)
     return size;
 }
 
-static void
+static int
 expand_buffer(buffer_t* buffer, size_t required)
 {
-    buffer->size = buffer_size_for(buffer->size, required);
-    buffer->ptr = ruby_xrealloc(buffer->ptr, buffer->size);
+    size_t size = buffer_size_for(buffer->size, required);
+    char* ptr = realloc(buffer->ptr, size);
+
+    if (!ptr) {
+        return -1;
+    }
+    buffer->ptr = ptr;
+    buffer->size = size;
+    return 0;
 }
 
-void
+int
 append_buffer(buffer_t* buffer, const void* ptr, size_t size)
 {
     size_t required;
 
     if (size == 0) {
-        return;
+        return 0;
     }
 
     required = buffer->used + size;
     if (required > buffer->size) {
-        expand_buffer(buffer, required);
+        if (expand_buffer(buffer, required) != 0) {
+            return -1;
+        }
     }
 
     memcpy(buffer->ptr + buffer->used, ptr, size);
     buffer->used += size;
+    return 0;
 }

data/ext/brotli/buffer.h

@@ -9,8 +9,10 @@ typedef struct {
     size_t used;
 } buffer_t;
 
+/* Never raise, so they are safe without the GVL. create_buffer returns NULL
+ * and append_buffer returns -1 when allocation fails. */
 buffer_t* create_buffer(size_t initial);
 void delete_buffer(buffer_t* buffer);
-void append_buffer(buffer_t* buffer, const void* ptr, size_t size);
+int append_buffer(buffer_t* buffer, const void* ptr, size_t size);
 
 #endif /* BUFFER_H */

data/ext/brotli/extconf.rb

@@ -106,7 +106,9 @@ def system_brotli_available?
               have_header("brotli/shared_dictionary.h") &&
               have_func("BrotliEncoderPrepareDictionary", "brotli/encode.h") &&
               have_func("BrotliEncoderAttachPreparedDictionary", "brotli/encode.h") &&
-              have_func("BrotliDecoderAttachDictionary", "brotli/decode.h")
+              have_func("BrotliDecoderAttachDictionary", "brotli/decode.h") &&
+              # CVE-2026-111497: patched decoders (1.2.1+, or distro backports) define this error code.
+              have_const("BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH", "brotli/decode.h")
 
   restore_mkmf_flags(flags) unless available
   available
@@ -127,5 +129,19 @@ if use_vendored_brotli
   $INCFLAGS << " -Ienc -Idec -Icommon -Iinclude"
 end
 
+# Leak-harness build hooks (inert unless the env var is set).
+# One append reaches brotli.c, buffer.c, and the vendored sources, because
+# add_vendored_sources_to_makefile rewrites ORIG_SRCS/OBJS after create_makefile.
+if ENV["BROTLI_DEBUG"] || ENV["BROTLI_ASAN"]
+  # Append -O0 last so it overrides any earlier optimization flag already in
+  # $CFLAGS (-O2/-O3/-Os/-Ofast/bare -O) -- the last -O on the command line wins
+  # for both gcc and clang. A gsub(/-O\d/) would miss -Os/-Ofast/-O.
+  $CFLAGS << " -O0 -g3 -fno-omit-frame-pointer"
+end
+if ENV["BROTLI_ASAN"]
+  $CFLAGS  << " -fsanitize=address"
+  $LDFLAGS << " -fsanitize=address"
+end
+
 create_makefile("brotli/brotli")
 add_vendored_sources_to_makefile if use_vendored_brotli

data/lib/brotli/version.rb

@@ -1,3 +1,3 @@
 module Brotli
-  VERSION = '0.9.0'
+  VERSION = '0.9.2'
 end

data/vendor/brotli/c/common/version.h

@@ -19,7 +19,7 @@
 
 #define BROTLI_VERSION_MAJOR 1
 #define BROTLI_VERSION_MINOR 2
-#define BROTLI_VERSION_PATCH 0
+#define BROTLI_VERSION_PATCH 1
 
 #define BROTLI_VERSION BROTLI_MAKE_HEX_VERSION(                     \
   BROTLI_VERSION_MAJOR, BROTLI_VERSION_MINOR, BROTLI_VERSION_PATCH)
@@ -33,7 +33,7 @@
  */
 
 #define BROTLI_ABI_CURRENT  3
-#define BROTLI_ABI_REVISION 0
+#define BROTLI_ABI_REVISION 1
 #define BROTLI_ABI_AGE      2
 
 #if BROTLI_VERSION_MAJOR != (BROTLI_ABI_CURRENT - BROTLI_ABI_AGE)

data/vendor/brotli/c/dec/decode.c

@@ -1176,7 +1176,7 @@ static BrotliDecoderErrorCode DecodeContextMap(brotli_reg_t context_map_size,
 
 /* Decodes a command or literal and updates block type ring-buffer.
    Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
+static BROTLI_INLINE BrotliDecoderErrorCode 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[
@@ -1187,7 +1187,7 @@ static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
   brotli_reg_t* ringbuffer = &s->block_type_rb[tree_type * 2];
   brotli_reg_t block_type;
   if (max_block_type <= 1) {
-    return BROTLI_FALSE;
+    return BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH;
   }
 
   /* Read 0..15 + 3..39 bits. */
@@ -1197,11 +1197,13 @@ static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
   } else {
     BrotliBitReaderState memento;
     BrotliBitReaderSaveState(br, &memento);
-    if (!SafeReadSymbol(type_tree, br, &block_type)) return BROTLI_FALSE;
+    if (!SafeReadSymbol(type_tree, br, &block_type)) {
+      return BROTLI_DECODER_NEEDS_MORE_INPUT;
+    }
     if (!SafeReadBlockLength(s, &s->block_length[tree_type], len_tree, br)) {
       s->substate_read_block_length = BROTLI_STATE_READ_BLOCK_LENGTH_NONE;
       BrotliBitReaderRestoreState(br, &memento);
-      return BROTLI_FALSE;
+      return BROTLI_DECODER_NEEDS_MORE_INPUT;
     }
   }
 
@@ -1217,7 +1219,7 @@ static BROTLI_INLINE BROTLI_BOOL DecodeBlockTypeAndLength(
   }
   ringbuffer[0] = ringbuffer[1];
   ringbuffer[1] = block_type;
-  return BROTLI_TRUE;
+  return BROTLI_DECODER_SUCCESS;
 }
 
 static BROTLI_INLINE void DetectTrivialLiteralBlockTypes(
@@ -1254,62 +1256,68 @@ static BROTLI_INLINE void PrepareLiteralDecoding(BrotliDecoderState* s) {
 
 /* Decodes the block type and updates the state for literal context.
    Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeLiteralBlockSwitchInternal(
+static BROTLI_INLINE BrotliDecoderErrorCode DecodeLiteralBlockSwitchInternal(
     int safe, BrotliDecoderState* s) {
-  if (!DecodeBlockTypeAndLength(safe, s, 0)) {
-    return BROTLI_FALSE;
+  BrotliDecoderErrorCode result = DecodeBlockTypeAndLength(safe, s, 0);
+  if (result != BROTLI_DECODER_SUCCESS) {
+    return result;
   }
   PrepareLiteralDecoding(s);
-  return BROTLI_TRUE;
+  return BROTLI_DECODER_SUCCESS;
 }
 
-static void BROTLI_NOINLINE DecodeLiteralBlockSwitch(BrotliDecoderState* s) {
-  DecodeLiteralBlockSwitchInternal(0, s);
+static BROTLI_NOINLINE BrotliDecoderErrorCode
+DecodeLiteralBlockSwitch(BrotliDecoderState* s) {
+  return DecodeLiteralBlockSwitchInternal(0, s);
 }
 
-static BROTLI_BOOL BROTLI_NOINLINE SafeDecodeLiteralBlockSwitch(
+static BROTLI_NOINLINE BrotliDecoderErrorCode SafeDecodeLiteralBlockSwitch(
     BrotliDecoderState* s) {
   return DecodeLiteralBlockSwitchInternal(1, s);
 }
 
 /* Block switch for insert/copy length.
    Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeCommandBlockSwitchInternal(
+static BROTLI_INLINE BrotliDecoderErrorCode DecodeCommandBlockSwitchInternal(
     int safe, BrotliDecoderState* s) {
-  if (!DecodeBlockTypeAndLength(safe, s, 1)) {
-    return BROTLI_FALSE;
+  BrotliDecoderErrorCode result = DecodeBlockTypeAndLength(safe, s, 1);
+  if (result != BROTLI_DECODER_SUCCESS) {
+    return result;
   }
   s->htree_command = s->insert_copy_hgroup.htrees[s->block_type_rb[3]];
-  return BROTLI_TRUE;
+  return BROTLI_DECODER_SUCCESS;
 }
 
-static void BROTLI_NOINLINE DecodeCommandBlockSwitch(BrotliDecoderState* s) {
-  DecodeCommandBlockSwitchInternal(0, s);
+static BROTLI_NOINLINE BrotliDecoderErrorCode
+DecodeCommandBlockSwitch(BrotliDecoderState* s) {
+  return DecodeCommandBlockSwitchInternal(0, s);
 }
 
-static BROTLI_BOOL BROTLI_NOINLINE SafeDecodeCommandBlockSwitch(
-    BrotliDecoderState* s) {
+static BROTLI_NOINLINE BrotliDecoderErrorCode
+SafeDecodeCommandBlockSwitch(BrotliDecoderState* s) {
   return DecodeCommandBlockSwitchInternal(1, s);
 }
 
 /* Block switch for distance codes.
    Reads 3..54 bits. */
-static BROTLI_INLINE BROTLI_BOOL DecodeDistanceBlockSwitchInternal(
+static BROTLI_INLINE BrotliDecoderErrorCode DecodeDistanceBlockSwitchInternal(
     int safe, BrotliDecoderState* s) {
-  if (!DecodeBlockTypeAndLength(safe, s, 2)) {
-    return BROTLI_FALSE;
+  BrotliDecoderErrorCode result = DecodeBlockTypeAndLength(safe, s, 2);
+  if (result != BROTLI_DECODER_SUCCESS) {
+    return result;
   }
   s->dist_context_map_slice = s->dist_context_map +
       (s->block_type_rb[5] << BROTLI_DISTANCE_CONTEXT_BITS);
   s->dist_htree_index = s->dist_context_map_slice[s->distance_context];
-  return BROTLI_TRUE;
+  return BROTLI_DECODER_SUCCESS;
 }
 
-static void BROTLI_NOINLINE DecodeDistanceBlockSwitch(BrotliDecoderState* s) {
-  DecodeDistanceBlockSwitchInternal(0, s);
+static BROTLI_NOINLINE BrotliDecoderErrorCode
+DecodeDistanceBlockSwitch(BrotliDecoderState* s) {
+  return DecodeDistanceBlockSwitchInternal(0, s);
 }
 
-static BROTLI_BOOL BROTLI_NOINLINE SafeDecodeDistanceBlockSwitch(
+static BROTLI_NOINLINE BrotliDecoderErrorCode SafeDecodeDistanceBlockSwitch(
     BrotliDecoderState* s) {
   return DecodeDistanceBlockSwitchInternal(1, s);
 }
@@ -1940,6 +1948,9 @@ static BROTLI_INLINE BROTLI_BOOL CheckInputAmount(
   return BrotliCheckInputAmount(br);
 }
 
+/* NB: METHOD should return BROTLI_FALSE only in case there is not enough input;
+       in case of "unsafe" execution, when input is guaranteed to be sufficient,
+       result is ignored. */
 #define BROTLI_SAFE(METHOD)                       \
   {                                               \
     if (safe) {                                   \
@@ -1952,6 +1963,22 @@ static BROTLI_INLINE BROTLI_BOOL CheckInputAmount(
     }                                             \
   }
 
+/* NB: METHOD should return BROTLI_DECODER_SUCCESS, BROTLI_DECODER_ERROR_*, or
+   BROTLI_DECODER_NEEDS_MORE_INPUT; the later two break the processing. */
+#define BROTLI_SAFE_WITH_STATUS(METHOD)         \
+  {                                             \
+    BrotliDecoderErrorCode status;              \
+    if (safe) {                                 \
+      status = Safe##METHOD;                    \
+    } else {                                    \
+      status = METHOD;                          \
+    }                                           \
+    if (status != BROTLI_DECODER_SUCCESS) {     \
+      result = status;                          \
+      goto saveStateAndReturn;                  \
+    }                                           \
+  }
+
 static BROTLI_INLINE BrotliDecoderErrorCode ProcessCommandsInternal(
     int safe, BrotliDecoderState* s) {
   int pos = s->pos;
@@ -1991,7 +2018,7 @@ CommandBegin:
     goto saveStateAndReturn;
   }
   if (BROTLI_PREDICT_FALSE(s->block_length[1] == 0)) {
-    BROTLI_SAFE(DecodeCommandBlockSwitch(s));
+    BROTLI_SAFE_WITH_STATUS(DecodeCommandBlockSwitch(s));
     goto CommandBegin;
   }
   /* Read the insert/copy length in the command. */
@@ -2136,7 +2163,7 @@ CommandPostDecodeLiterals:
   } else {
     /* Read distance code in the command, unless it was implicitly zero. */
     if (BROTLI_PREDICT_FALSE(s->block_length[2] == 0)) {
-      BROTLI_SAFE(DecodeDistanceBlockSwitch(s));
+      BROTLI_SAFE_WITH_STATUS(DecodeDistanceBlockSwitch(s));
     }
     BROTLI_SAFE(ReadDistance(s, br));
   }
@@ -2330,7 +2357,7 @@ CommandPostWrapCopy:
   }
 
 NextLiteralBlock:
-  BROTLI_SAFE(DecodeLiteralBlockSwitch(s));
+  BROTLI_SAFE_WITH_STATUS(DecodeLiteralBlockSwitch(s));
   goto CommandInner;
 
 saveStateAndReturn:
@@ -2552,6 +2579,8 @@ BrotliDecoderResult BrotliDecoderDecompressStream(
         if (result != BROTLI_DECODER_SUCCESS) {
           break;
         }
+        BROTLI_DCHECK(s->meta_block_remaining_len <=
+                      (int)BROTLI_BLOCK_SIZE_CAP);
         BROTLI_LOG_UINT(s->is_last_metablock);
         BROTLI_LOG_UINT(s->meta_block_remaining_len);
         BROTLI_LOG_UINT(s->is_metadata);

data/vendor/brotli/c/include/brotli/decode.h

@@ -85,9 +85,7 @@ typedef enum {
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_1, -14) SEPARATOR              \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, PADDING_2, -15) SEPARATOR              \
   BROTLI_ERROR_CODE(_ERROR_FORMAT_, DISTANCE, -16) SEPARATOR               \
-                                                                           \
-  /* -17 code is reserved */                                               \
-                                                                           \
+  BROTLI_ERROR_CODE(_ERROR_FORMAT_, BLOCK_SWITCH, -17) SEPARATOR           \
   BROTLI_ERROR_CODE(_ERROR_, COMPOUND_DICTIONARY, -18) SEPARATOR           \
   BROTLI_ERROR_CODE(_ERROR_, DICTIONARY_NOT_SET, -19) SEPARATOR            \
   BROTLI_ERROR_CODE(_ERROR_, INVALID_ARGUMENTS, -20) SEPARATOR             \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brotli
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.2
 platform: ruby
 authors:
 - miyucy