[wasm] improve handling of malformed input

test/unittests/wasm/decoder-unittest.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "test/unittests/test-utils.h"
 
 #include "src/objects-inl.h"
 #include "src/wasm/decoder.h"
 #include "src/wasm/wasm-macro-gen.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 class DecoderTest : public TestWithZone {
  public:
   DecoderTest() : decoder(nullptr, nullptr) {}
 
   Decoder decoder;
 };
 
 #define CHECK_UINT32V_INLINE(expected, expected_length, ...)           \
   do {                                                                 \
     const byte data[] = {__VA_ARGS__};                                 \
     decoder.Reset(data, data + sizeof(data));                          \
-    int length;                                                        \
+    unsigned length;                                                   \
     EXPECT_EQ(expected,                                                \
               decoder.checked_read_u32v(decoder.start(), 0, &length)); \
     EXPECT_EQ(expected_length, length);                                \
   } while (false)
 
 #define CHECK_INT32V_INLINE(expected, expected_length, ...)            \
   do {                                                                 \
     const byte data[] = {__VA_ARGS__};                                 \
     decoder.Reset(data, data + sizeof(data));                          \
-    int length;                                                        \
+    unsigned length;                                                   \
     EXPECT_EQ(expected,                                                \
               decoder.checked_read_i32v(decoder.start(), 0, &length)); \
     EXPECT_EQ(expected_length, length);                                \
   } while (false)
 
 #define CHECK_UINT64V_INLINE(expected, expected_length, ...)           \
   do {                                                                 \
     const byte data[] = {__VA_ARGS__};                                 \
     decoder.Reset(data, data + sizeof(data));                          \
-    int length;                                                        \
+    unsigned length;                                                   \
     EXPECT_EQ(expected,                                                \
               decoder.checked_read_u64v(decoder.start(), 0, &length)); \
     EXPECT_EQ(expected_length, length);                                \
   } while (false)
 
 #define CHECK_INT64V_INLINE(expected, expected_length, ...)            \
   do {                                                                 \
     const byte data[] = {__VA_ARGS__};                                 \
     decoder.Reset(data, data + sizeof(data));                          \
-    int length;                                                        \
+    unsigned length;                                                   \
     EXPECT_EQ(expected,                                                \
               decoder.checked_read_i64v(decoder.start(), 0, &length)); \
     EXPECT_EQ(expected_length, length);                                \
   } while (false)
 
 TEST_F(DecoderTest, ReadU32v_OneByte) {
   CHECK_UINT32V_INLINE(0, 1, 0);
   CHECK_UINT32V_INLINE(5, 1, 5);
   CHECK_UINT32V_INLINE(7, 1, 7);
   CHECK_UINT32V_INLINE(9, 1, 9);
@@ skipping 292 matching lines @@
   }
 
   const int32_t max = kMaxInt;
   for (int i = max; i > max - 10; i--) {
     CHECK_INT32V_INLINE(i, 5, U32V_5(i));
   }
 }
 
 TEST_F(DecoderTest, ReadU32v_off_end1) {
   static const byte data[] = {U32V_1(11)};
-  int length = 0;
+  unsigned length = 0;
   decoder.Reset(data, data);
   decoder.checked_read_u32v(decoder.start(), 0, &length);
   EXPECT_EQ(0, length);
   EXPECT_FALSE(decoder.ok());
 }
 
 TEST_F(DecoderTest, ReadU32v_off_end2) {
   static const byte data[] = {U32V_2(1111)};
   for (size_t i = 0; i < sizeof(data); i++) {
-    int length = 0;
+    unsigned length = 0;
     decoder.Reset(data, data + i);
     decoder.checked_read_u32v(decoder.start(), 0, &length);
     EXPECT_EQ(i, length);
     EXPECT_FALSE(decoder.ok());
   }
 }
 
 TEST_F(DecoderTest, ReadU32v_off_end3) {
   static const byte data[] = {U32V_3(111111)};
   for (size_t i = 0; i < sizeof(data); i++) {
-    int length = 0;
+    unsigned length = 0;
     decoder.Reset(data, data + i);
     decoder.checked_read_u32v(decoder.start(), 0, &length);
     EXPECT_EQ(i, length);
     EXPECT_FALSE(decoder.ok());
   }
 }
 
 TEST_F(DecoderTest, ReadU32v_off_end4) {
   static const byte data[] = {U32V_4(11111111)};
   for (size_t i = 0; i < sizeof(data); i++) {
-    int length = 0;
+    unsigned length = 0;
     decoder.Reset(data, data + i);
     decoder.checked_read_u32v(decoder.start(), 0, &length);
     EXPECT_EQ(i, length);
     EXPECT_FALSE(decoder.ok());
   }
 }
 
 TEST_F(DecoderTest, ReadU32v_off_end5) {
   static const byte data[] = {U32V_5(111111111)};
   for (size_t i = 0; i < sizeof(data); i++) {
-    int length = 0;
+    unsigned length = 0;
     decoder.Reset(data, data + i);
     decoder.checked_read_u32v(decoder.start(), 0, &length);
     EXPECT_EQ(i, length);
     EXPECT_FALSE(decoder.ok());
   }
 }
 
 TEST_F(DecoderTest, ReadU32v_extra_bits) {
   byte data[] = {0x80, 0x80, 0x80, 0x80, 0x00};
   for (int i = 1; i < 16; i++) {
     data[4] = static_cast<byte>(i << 4);
-    int length = 0;
+    unsigned length = 0;
     decoder.Reset(data, data + sizeof(data));
     decoder.checked_read_u32v(decoder.start(), 0, &length);
     EXPECT_EQ(5, length);
     EXPECT_FALSE(decoder.ok());
   }
 }
 
 TEST_F(DecoderTest, ReadI32v_extra_bits_negative) {
   // OK for negative signed values to have extra ones.
-  int length = 0;
+  unsigned length = 0;
   byte data[] = {0xff, 0xff, 0xff, 0xff, 0x7f};
   decoder.Reset(data, data + sizeof(data));
   decoder.checked_read_i32v(decoder.start(), 0, &length);
   EXPECT_EQ(5, length);
   EXPECT_TRUE(decoder.ok());
 }
 
 TEST_F(DecoderTest, ReadI32v_extra_bits_positive) {
   // Not OK for positive signed values to have extra ones.
-  int length = 0;
+  unsigned length = 0;
   byte data[] = {0x80, 0x80, 0x80, 0x80, 0x77};
   decoder.Reset(data, data + sizeof(data));
   decoder.checked_read_i32v(decoder.start(), 0, &length);
   EXPECT_EQ(5, length);
   EXPECT_FALSE(decoder.ok());
 }
 
 TEST_F(DecoderTest, ReadU32v_Bits) {
   // A more exhaustive test.
   const int kMaxSize = 5;
@@ skipping 16 matching lines @@
       for (int j = 0; j < kMaxSize; j++) {
         data[j] = static_cast<byte>((val >> (7 * j)) & MASK_7);
       }
       for (int j = 0; j < length - 1; j++) {
         data[j] |= 0x80;
       }
 
       // foreach buffer size 0...5
       for (int limit = 0; limit <= kMaxSize; limit++) {
         decoder.Reset(data, data + limit);
-        int rlen;
+        unsigned rlen;
         uint32_t result = decoder.checked_read_u32v(data, 0, &rlen);
         if (limit < length) {
           EXPECT_FALSE(decoder.ok());
         } else {
           EXPECT_TRUE(decoder.ok());
           EXPECT_EQ(val, result);
           EXPECT_EQ(length, rlen);
         }
       }
     }
@@ skipping 35 matching lines @@
   byte data[kMaxSize];
 
   for (int i = 0; i < 64; i++) {
     const uint64_t val = 1ull << i;
     int index = i / 7;
     data[index] = 1 << (i % 7);
     memset(data, 0x80, index);
 
     for (int limit = 0; limit <= kMaxSize; limit++) {
       decoder.Reset(data, data + limit);
-      int length;
+      unsigned length;
       uint64_t result = decoder.checked_read_u64v(data, 0, &length);
       if (limit <= index) {
         EXPECT_FALSE(decoder.ok());
       } else {
         EXPECT_TRUE(decoder.ok());
         EXPECT_EQ(val, result);
         EXPECT_EQ(index + 1, length);
       }
     }
   }
@@ skipping 20 matching lines @@
       for (int j = 0; j < kMaxSize; j++) {
         data[j] = static_cast<byte>((val >> (7 * j)) & MASK_7);
       }
       for (int j = 0; j < length - 1; j++) {
         data[j] |= 0x80;
       }
 
       // foreach buffer size 0...10
       for (int limit = 0; limit <= kMaxSize; limit++) {
         decoder.Reset(data, data + limit);
-        int rlen;
+        unsigned rlen;
         uint64_t result = decoder.checked_read_u64v(data, 0, &rlen);
         if (limit < length) {
           EXPECT_FALSE(decoder.ok());
         } else {
           EXPECT_TRUE(decoder.ok());
           EXPECT_EQ(val, result);
           EXPECT_EQ(length, rlen);
         }
       }
     }
@@ skipping 21 matching lines @@
       for (int j = 0; j < kMaxSize; j++) {
         data[j] = static_cast<byte>((val >> (7 * j)) & MASK_7);
       }
       for (int j = 0; j < length - 1; j++) {
         data[j] |= 0x80;
       }
 
       // foreach buffer size 0...10
       for (int limit = 0; limit <= kMaxSize; limit++) {
         decoder.Reset(data, data + limit);
-        int rlen;
+        unsigned rlen;
         int64_t result = decoder.checked_read_i64v(data, 0, &rlen);
         if (limit < length) {
           EXPECT_FALSE(decoder.ok());
         } else {
           EXPECT_TRUE(decoder.ok());
           EXPECT_EQ(val, result);
           EXPECT_EQ(length, rlen);
         }
       }
     }
   }
 }
 
 TEST_F(DecoderTest, ReadU64v_extra_bits) {
   byte data[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00};
   for (int i = 1; i < 128; i++) {
     data[9] = static_cast<byte>(i << 1);
-    int length = 0;
+    unsigned length = 0;
     decoder.Reset(data, data + sizeof(data));
     decoder.checked_read_u64v(decoder.start(), 0, &length);
     EXPECT_EQ(10, length);
     EXPECT_FALSE(decoder.ok());
   }
 }
 
 TEST_F(DecoderTest, ReadI64v_extra_bits_negative) {
   // OK for negative signed values to have extra ones.
-  int length = 0;
+  unsigned length = 0;
   byte data[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f};
   decoder.Reset(data, data + sizeof(data));
   decoder.checked_read_i64v(decoder.start(), 0, &length);
   EXPECT_EQ(10, length);
   EXPECT_TRUE(decoder.ok());
 }
 
 TEST_F(DecoderTest, ReadI64v_extra_bits_positive) {
   // Not OK for positive signed values to have extra ones.
-  int length = 0;
+  unsigned length = 0;
   byte data[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x77};
   decoder.Reset(data, data + sizeof(data));
   decoder.checked_read_i64v(decoder.start(), 0, &length);
   EXPECT_EQ(10, length);
   EXPECT_FALSE(decoder.ok());
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8