Stricter bound checks to ensure buffer sizes are sufficient

Author: flanglet

src/test/TestTransforms.cpp

@@ -20,6 +20,8 @@ limitations under the License.
 #include "../types.hpp"
 #include "../util/strings.hpp"
 #include "../transform/AliasCodec.hpp"
+#include "../transform/BWT.hpp"
+#include "../transform/BWTS.hpp"
 #include "../transform/EXECodec.hpp"
 #include "../transform/FSDCodec.hpp"
 #include "../transform/LZCodec.hpp"
@@ -494,6 +496,53 @@ static int testZRLTMalformed()
     return 0;
 }
 
+static int testTransformCapacityValidation()
+{
+    cout << endl
+         << "Transform capacity validation" << endl;
+
+    Context ctx;
+    ctx.putInt("bsVersion", BS_VERSION);
+    kanzi::byte src[2] = { kanzi::byte(1), kanzi::byte(2) };
+    kanzi::byte dst[2] = { kanzi::byte(0x7E), kanzi::byte(0x7E) };
+
+    {
+        BWT tf;
+        SliceArray<kanzi::byte> input(src, 1, 0);
+        SliceArray<kanzi::byte> output(dst, 2, 0);
+
+        if (tf.forward(input, output, 2) != false) {
+            cout << "BWT should reject oversized input count" << endl;
+            return 1;
+        }
+    }
+
+    {
+        BWTS tf;
+        SliceArray<kanzi::byte> input(src, 2, 0);
+        SliceArray<kanzi::byte> output(dst, 0, 0);
+
+        if (tf.forward(input, output, 1) != false) {
+            cout << "BWTS should reject oversized output count" << endl;
+            return 1;
+        }
+    }
+
+    {
+        SBRT tf(SBRT::MODE_RANK, ctx);
+        SliceArray<kanzi::byte> input(src, 2, 1);
+        SliceArray<kanzi::byte> output(dst, 2, 0);
+
+        if (tf.forward(input, output, 2) != false) {
+            cout << "SBRT should reject oversized remaining input count" << endl;
+            return 1;
+        }
+    }
+
+    cout << "Transform capacity validation passed" << endl;
+    return 0;
+}
+
 static Transform<kanzi::byte>* getByteTransform(string name, Context& ctx)
 {
     if (name.compare("SRT") == 0)
@@ -999,6 +1048,11 @@ int TestTransforms_main(int argc, const char* argv[])
 
         res = testZRLTMalformed();
 
+        if (res != 0)
+            return res;
+
+        res = testTransformCapacityValidation();
+
         if (res != 0)
             return res;
 

src/transform/BWT.cpp

@@ -100,7 +100,10 @@ bool BWT::forward(SliceArray<kanzi::byte>& input, SliceArray<kanzi::byte>& outpu
     if (!SliceArray<kanzi::byte>::isValid(output))
         throw invalid_argument("BWT: Invalid output block");
 
-    if (count > MAX_BLOCK_SIZE)
+    if ((count < 0) ||
+        (count > input._length - input._index) ||
+        (count > output._length - output._index) ||
+        (count > MAX_BLOCK_SIZE))
         return false;
 
     if (count == 1) {

src/transform/BWTS.cpp

@@ -36,6 +36,11 @@ bool BWTS::forward(SliceArray<kanzi::byte>& input, SliceArray<kanzi::byte>& outp
     if (!SliceArray<kanzi::byte>::isValid(output))
         throw invalid_argument("BWTS: Invalid output block");
 
+    if ((count < 0) ||
+        (count > input._length - input._index) ||
+        (count > output._length - output._index))
+        return false;
+
     if (count > MAX_BLOCK_SIZE) {
         // Not a recoverable error: instead of silently fail the transform,
         // issue a fatal error.

src/transform/SBRT.cpp

@@ -54,6 +54,11 @@ bool SBRT::forward(SliceArray<kanzi::byte>& input, SliceArray<kanzi::byte>& outp
     if (!SliceArray<kanzi::byte>::isValid(output))
         throw std::invalid_argument("SBRT: Invalid output block");
 
+    if ((count < 0) ||
+        (count > input._length - input._index) ||
+        (count > output._length - output._index))
+        return false;
+
     // Aliasing
     const kanzi::byte* src = &input._array[input._index];
     kanzi::byte* dst = &output._array[output._index];