fix(security): protect against zip-bomb attacks via inflated row_count

Two independent OOM vectors, both exploitable with files under 200 bytes
claiming 10⁹ rows:

1. ConstantEncoding.Decoder stored n copies of the constant value.
   A ~130-byte file triggers an 8 GB allocation in decode() before
   touching any actual data.
   Fix: store one element only; array reports length=n with O(1) buffer.
   Callers that need all n values replicate from index 0.

2. ScanIterator.expandDictPrimitive pre-allocated n × elemBytes from
   the attacker-controlled codesLayout.rowCount() before reading a
   single code byte. PrimitiveEncoding wraps the mmap'd segment without
   allocating, making the rowCount inflation invisible at decode time.
   Fix: validate bufferCodes >= n in decodeDictLayout before expansion;
   the mmap-bounded buffer makes inflation detectable for direct-mapped
   encodings, and full-decode encodings (bitpacked etc.) already fill
   their buffer to n × elemBytes during decode.

Regression tests in ZipBombTest use row counts safe for CI: 10M for
attack 1 (fails with AssertionError if reverted, not OOM) and 100 for
attack 2 (wrong exception type → clean failure if check is removed).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dfa1

core/src/main/java/io/github/dfa1/vortex/encoding/ConstantEncoding.java

@@ -123,8 +123,7 @@ private static ScalarProtos.ScalarValue buildScalar(PType ptype, long rawBits) {
             return switch (ptype) {
                 case U8, U16, U32, U64 -> ScalarProtos.ScalarValue.newBuilder().setUint64Value(rawBits).build();
                 case I8, I16, I32, I64 -> ScalarProtos.ScalarValue.newBuilder().setInt64Value(rawBits).build();
-                case F32 ->
-                        ScalarProtos.ScalarValue.newBuilder().setF32Value(Float.intBitsToFloat((int) rawBits)).build();
+                case F32 -> ScalarProtos.ScalarValue.newBuilder().setF32Value(Float.intBitsToFloat((int) rawBits)).build();
                 case F64 -> ScalarProtos.ScalarValue.newBuilder().setF64Value(Double.longBitsToDouble(rawBits)).build();
                 default -> throw new VortexException(EncodingId.VORTEX_CONSTANT, "unsupported ptype: " + ptype);
             };
@@ -163,7 +162,7 @@ private static Array decode(DecodeContext ctx) {
             if (ctx.dtype() instanceof DType.Extension ext) {
                 // Decode using the storage dtype, re-wrap with the extension dtype
                 var storageCtx = new DecodeContext(ctx.node(), ext.storageDType(), ctx.rowCount(),
-                        ctx.segmentBuffers(), ctx.registry(), ctx.arena());
+                    ctx.segmentBuffers(), ctx.registry(), ctx.arena());
                 Array storage = decode(storageCtx);
                 return new GenericArray(ctx.dtype(), n, storage.buffer(0));
             }
@@ -176,11 +175,13 @@ private static Array decode(DecodeContext ctx) {
             int elemBytes = ptype.byteSize();
             long rawBits = scalarToRawBits(scalar, ptype);
 
-            MemorySegment outSeg = ctx.arena().allocate(n * elemBytes);
+            // Store one element only. The array reports length=n but the buffer holds
+            // a single copy of the constant — callers that need all n values must
+            // replicate from index 0. This keeps allocation O(1) regardless of rowCount,
+            // which also eliminates the zip-bomb vector via inflated row_count.
+            MemorySegment outSeg = ctx.arena().allocate(elemBytes);
             ByteBuffer out = outSeg.asByteBuffer().order(ByteOrder.LITTLE_ENDIAN);
-            for (long i = 0; i < n; i++) {
-                writeRaw(out, ptype, rawBits);
-            }
+            writeRaw(out, ptype, rawBits);
 
             MemorySegment ro = outSeg.asReadOnly();
             return switch (ptype) {
@@ -220,8 +221,8 @@ private static Array decodeBool(DecodeContext ctx, ScalarProtos.ScalarValue scal
 
         private static Array decodeString(DecodeContext ctx, ScalarProtos.ScalarValue scalar, long n) {
             byte[] strBytes = scalar.hasStringValue()
-                                      ? scalar.getStringValue().getBytes(StandardCharsets.UTF_8)
-                                      : scalar.getBytesValue().toByteArray();
+                                  ? scalar.getStringValue().getBytes(StandardCharsets.UTF_8)
+                                  : scalar.getBytesValue().toByteArray();
 
             int strLen = strBytes.length;
 
@@ -248,7 +249,7 @@ private static long scalarToRawBits(ScalarProtos.ScalarValue scalar, PType ptype
                 case F64_VALUE -> Double.doubleToRawLongBits(scalar.getF64Value());
                 case KIND_NOT_SET -> 0L;
                 default -> throw new VortexException(EncodingId.VORTEX_CONSTANT,
-                        "unexpected scalar kind " + scalar.getKindCase());
+                    "unexpected scalar kind " + scalar.getKindCase());
             };
         }
 

core/src/test/java/io/github/dfa1/vortex/encoding/ConstantEncodingTest.java

@@ -2,6 +2,7 @@
 
 import io.github.dfa1.vortex.core.array.Array;
 import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -11,8 +12,36 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 /// Property: encode then decode is lossless for constant (all-equal) arrays.
+/// Property: decode allocates O(1) memory regardless of rowCount.
 class ConstantEncodingTest {
 
+    @Nested
+    class Decode {
+
+        @Test
+        void decode_largeRowCount_bufferStaysConstantSize() {
+            // Given — 10M rows would allocate 80 MB if the decoder materializes every element;
+            // the correct impl stores exactly one element regardless of logical length.
+            long rowCount = 10_000_000L;
+            var sut = new ConstantEncoding();
+            EncodingRegistry registry = TestRegistry.of(sut);
+
+            // When
+            EncodeResult encoded = sut.encode(DTypes.I64, new long[]{42L}, EncodeTestHelper.testCtx());
+            DecodeContext ctx = EncodeTestHelper.toDecodeContext(encoded, rowCount, DTypes.I64, registry);
+            Array result = sut.decode(ctx);
+
+            // Then
+            assertThat(result.length()).isEqualTo(rowCount);
+            // Constant encoding must not materialize the full array: the backing buffer must
+            // hold exactly one element. Before fix: buffer is rowCount * 8 bytes.
+            assertThat(result.buffer(0).byteSize())
+                    .as("constant encoding must not allocate O(rowCount) memory")
+                    .isEqualTo(Long.BYTES);
+            assertThat(result.buffer(0).get(PTypeIO.LE_LONG, 0L)).isEqualTo(42L);
+        }
+    }
+
     @Nested
     class Encode {
 
@@ -48,11 +77,10 @@ void encodeDecode_i32_isLossless(int[] data) {
             DecodeContext ctx = EncodeTestHelper.toDecodeContext(encoded, data.length, DTypes.I32, registry);
             Array result = sut.decode(ctx);
 
-            // Then
+            // Then — buffer holds one element; logical length is n
             assertThat(result.length()).isEqualTo(data.length);
-            for (int i = 0; i < data.length; i++) {
-                assertThat(result.buffer(0).get(le, (long) i * 4)).as("index %d", i).isEqualTo(data[i]);
-            }
+            assertThat(result.buffer(0).byteSize()).isEqualTo(Integer.BYTES);
+            assertThat(result.buffer(0).get(le, 0L)).isEqualTo(data[0]);
         }
 
         @ParameterizedTest
@@ -68,11 +96,10 @@ void encodeDecode_i64_isLossless(long[] data) {
             DecodeContext ctx = EncodeTestHelper.toDecodeContext(encoded, data.length, DTypes.I64, registry);
             Array result = sut.decode(ctx);
 
-            // Then
+            // Then — buffer holds one element; logical length is n
             assertThat(result.length()).isEqualTo(data.length);
-            for (int i = 0; i < data.length; i++) {
-                assertThat(result.buffer(0).get(le, (long) i * 8)).as("index %d", i).isEqualTo(data[i]);
-            }
+            assertThat(result.buffer(0).byteSize()).isEqualTo(Long.BYTES);
+            assertThat(result.buffer(0).get(le, 0L)).isEqualTo(data[0]);
         }
     }
 }

reader/src/main/java/io/github/dfa1/vortex/scan/ScanIterator.java

@@ -429,6 +429,17 @@ private Array decodeDictLayout(Layout dictLayout, DType dtype, SegmentAllocator
         Array values = decodeLayout(valuesLayout, dtype, arena);
         Array codes = decodeLayout(codesLayout, new DType.Primitive(codesPType, false), arena);
 
+        // Zip-bomb guard: for direct-mapped encodings (e.g. vortex.primitive), the codes
+        // buffer is mmap-bounded and can be much smaller than the claimed rowCount. Reject
+        // before any O(n) allocation so an inflated layout row_count cannot trigger OOM.
+        // Full-decode encodings (e.g. bitpacked) write n * elemBytes to the arena during
+        // decodeLayout above, so their buffer will already match n — check passes for them.
+        long bufferCodes = codes.buffer(0).byteSize() / (long) codesPType.byteSize();
+        if (bufferCodes < n) {
+            throw new VortexException(EncodingId.VORTEX_DICT,
+                    "dict codes: layout row_count=" + n + " exceeds buffer capacity=" + bufferCodes);
+        }
+
         if (values instanceof VarBinArray) {
             MemorySegment valOffsets = values.child(0).buffer(0);
             PType valOffPType = ((DType.Primitive) values.child(0).dtype()).ptype();