Page MenuHome
Differential D10719 Diff 35329 intern/guardedalloc/tests/guardedalloc_overflow_test.cc

Changeset View

Standalone View

View Options

intern/guardedalloc/tests/guardedalloc_overflow_test.cc

/* Apache License, Version 2.0 */ /* Apache License, Version 2.0 */
#include "testing/testing.h" #include "testing/testing.h"
#include "MEM_guardedalloc.h" #include "BLI_compiler_attrs.h"
#include "guardedalloc_test_base.h" #include "mallocn_intern.h"
/* We expect to abort on integer overflow, to prevent possible exploits. */ /* To prevent possible exploits, allocators should not allocate in case of integer overflow. It
* depends on #MEM_size_safe_multiply returning false in that case. But there doesn't seem to be a
#if defined(__GNUC__) && !defined(__clang__) * clean way to test allocators in Address Sanitizer enabled builds. */
/* Disable since it's the purpose of this test. */
# pragma GCC diagnostic ignored "-Walloc-size-larger-than="
#endif
namespace { namespace {
void MallocArray(size_t len, size_t size) void safe_multiply_pass(const size_t len, const size_t size)
{ {
void *mem = MEM_malloc_arrayN(len, size, "MallocArray"); size_t total_size = 0;
if (mem) { const bool ok = MEM_size_safe_multiply(len, size, &total_size);
MEM_freeN(mem); EXPECT_TRUE(ok);
} EXPECT_TRUE(total_size);
sergeyUnsubmitted
Not Done
Inline Actions

total_size is size_t, so using boolean-typed EXPECT_TRUE seems meaningless to me.
Either explicitly check for EXPECT_GT(total_size, 0) or check for an exact value with EXPECT_EQ().

sergey: `total_size` is `size_t`, so using boolean-typed `EXPECT_TRUE` seems meaningless to me. Either…
} }
void CallocArray(size_t len, size_t size) void safe_multiply_fail(const size_t len, const size_t size)
{ {
void *mem = MEM_calloc_arrayN(len, size, "CallocArray"); size_t total_size = 0;
if (mem) { const bool ok = MEM_size_safe_multiply(len, size, &total_size);
MEM_freeN(mem); EXPECT_FALSE(ok);
EXPECT_TRUE(total_size);
} }
}
} // namespace } // namespace
TEST_F(LockFreeAllocatorTest, LockfreeIntegerOverflow) TEST(AllocatorTest, IntegerOverflow)
{
MallocArray(1, SIZE_MAX);
CallocArray(SIZE_MAX, 1);
MallocArray(SIZE_MAX / 2, 2);
CallocArray(SIZE_MAX / 1234567, 1234567);
EXPECT_EXIT(MallocArray(SIZE_MAX, 2), ABORT_PREDICATE, "");
EXPECT_EXIT(CallocArray(7, SIZE_MAX), ABORT_PREDICATE, "");
EXPECT_EXIT(MallocArray(SIZE_MAX, 12345567), ABORT_PREDICATE, "");
EXPECT_EXIT(CallocArray(SIZE_MAX, SIZE_MAX), ABORT_PREDICATE, "");
}
TEST_F(GuardedAllocatorTest, GuardedIntegerOverflow)
{ {
MallocArray(1, SIZE_MAX); safe_multiply_pass(1, SIZE_MAX);
CallocArray(SIZE_MAX, 1); safe_multiply_pass(SIZE_MAX, 1);
MallocArray(SIZE_MAX / 2, 2); safe_multiply_pass(SIZE_MAX / 2, 2);
CallocArray(SIZE_MAX / 1234567, 1234567); safe_multiply_pass(SIZE_MAX / 1234567, 1234567);
EXPECT_EXIT(MallocArray(SIZE_MAX, 2), ABORT_PREDICATE, ""); safe_multiply_fail(SIZE_MAX, 2);
EXPECT_EXIT(CallocArray(7, SIZE_MAX), ABORT_PREDICATE, ""); safe_multiply_fail(7, SIZE_MAX);
EXPECT_EXIT(MallocArray(SIZE_MAX, 12345567), ABORT_PREDICATE, ""); safe_multiply_fail(SIZE_MAX, 12345567);
EXPECT_EXIT(CallocArray(SIZE_MAX, SIZE_MAX), ABORT_PREDICATE, ""); safe_multiply_fail(SIZE_MAX, SIZE_MAX);
} }