Skip to content

Commit 6596741

Browse files
committed
Report program data shorter than its header says as InvalidProgram
Program::load reads the 64 header bytes, and then the program, whose size the header states. When the data is shorter than either, the read fails inside the data loader, and the loader's error comes through instead, for example InvalidArgument from BufferDataLoader, although the cause is a malformed program. The program size is already checked against the data for most headers, but not for headers written before segment_data_size existed. When the loader reports its size, Program::load now checks both lengths against it first and returns InvalidProgram. The program size from the header is compared as the 64-bit value it is stored as, before it is narrowed to size_t. Program::load now asks the loader for its size once, and returns the loader's error where it used to abort on a failed size query. A loader that cannot report its size still loads programs whose header does not need it, as before. This changes an error code. Code that expected the loader's error for such truncated program data should expect InvalidProgram. BundledModule with a file that is not a bundled program is one such case, so BundledModuleTest.TestNonBPFile now expects InvalidProgram.
1 parent 25bb87a commit 6596741

3 files changed

Lines changed: 80 additions & 7 deletions

File tree

‎extension/module/test/bundled_module_test.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -55,11 +55,11 @@ TEST_F(BundledModuleTest, TestNonBPFile) {
5555

5656
auto outputs = bundled_module->execute("forward", /*testset_idx=*/0);
5757
EXPECT_EQ(bundled_module->Module::is_loaded(), false);
58-
EXPECT_EQ(outputs.error(), Error::InvalidArgument);
58+
EXPECT_EQ(outputs.error(), Error::InvalidProgram);
5959

6060
auto status =
6161
bundled_module->verify_method_outputs("forward", /*testset_idx=*/0);
62-
EXPECT_EQ(status, Error::InvalidArgument);
62+
EXPECT_EQ(status, Error::InvalidProgram);
6363
}
6464

6565
TEST_F(BundledModuleTest, TestExecuteInvalidMethod) {

‎runtime/executor/program.cpp‎

Lines changed: 24 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -79,8 +79,17 @@ Result<executorch_flatbuffer::ExecutionPlan*> get_execution_plan(
7979
size_t program_size = 0;
8080
size_t segment_base_offset = 0;
8181
size_t segment_data_size = 0;
82+
// Some loaders cannot report their size; programs whose header does not
83+
// need it still load from them.
84+
const Result<size_t> data_size = loader->size();
8285
{
8386
EXECUTORCH_SCOPE_PROF("Program::check_header");
87+
ET_CHECK_OR_RETURN_ERROR(
88+
!data_size.ok() || data_size.get() >= ExtendedHeader::kNumHeadBytes,
89+
InvalidProgram,
90+
"Program data is %zu bytes, shorter than its %zu-byte header",
91+
data_size.get(),
92+
ExtendedHeader::kNumHeadBytes);
8493
Result<FreeableBuffer> header = loader->load(
8594
/*offset=*/0,
8695
ExtendedHeader::kNumHeadBytes,
@@ -91,6 +100,14 @@ Result<executorch_flatbuffer::ExecutionPlan*> get_execution_plan(
91100
Result<ExtendedHeader> eh =
92101
ExtendedHeader::Parse(header->data(), header->size());
93102
if (eh.ok()) {
103+
// Compared before program_size narrows it on 32-bit platforms.
104+
ET_CHECK_OR_RETURN_ERROR(
105+
!data_size.ok() || eh->program_size <= data_size.get(),
106+
InvalidProgram,
107+
"Program size %" PRIu64
108+
" from the header is larger than the %zu bytes of data",
109+
eh->program_size,
110+
data_size.get());
94111
// The header has the program size.
95112
program_size = eh->program_size;
96113
segment_base_offset = eh->segment_base_offset;
@@ -110,7 +127,10 @@ Result<executorch_flatbuffer::ExecutionPlan*> get_execution_plan(
110127
size_t expected = segment_base_offset == 0
111128
? program_size
112129
: segment_base_offset + segment_data_size;
113-
size_t actual = loader->size().get();
130+
if (!data_size.ok()) {
131+
return data_size.error();
132+
}
133+
size_t actual = data_size.get();
114134
ET_CHECK_OR_RETURN_ERROR(
115135
expected <= actual,
116136
InvalidProgram,
@@ -121,11 +141,10 @@ Result<executorch_flatbuffer::ExecutionPlan*> get_execution_plan(
121141
} else if (eh.error() == Error::NotFound) {
122142
// No header; the program consumes the whole file, and there are no
123143
// segments.
124-
auto result = loader->size();
125-
if (!result.ok()) {
126-
return result.error();
144+
if (!data_size.ok()) {
145+
return data_size.error();
127146
}
128-
program_size = result.get();
147+
program_size = data_size.get();
129148
} else {
130149
ET_LOG(Error, "Extended header may be corrupt");
131150
return eh.error();

‎runtime/executor/test/program_test.cpp‎

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -625,6 +625,60 @@ TEST_F(ProgramTest, ShortDataHeader) {
625625
Program::HeaderStatus::ShortData);
626626
}
627627

628+
TEST_F(ProgramTest, LoadShortDataIsInvalidProgram) {
629+
const uint8_t data[8] = {};
630+
BufferDataLoader loader(data, sizeof(data));
631+
EXPECT_EQ(Program::load(&loader).error(), Error::InvalidProgram);
632+
}
633+
634+
namespace {
635+
// Reads the whole program and gives it a header from before segment_data_size
636+
// existed, which a loader of unknown size can still load.
637+
std::vector<uint8_t> read_with_legacy_header(FileDataLoader& loader) {
638+
const size_t size = loader.size().get();
639+
Result<FreeableBuffer> bytes = loader.load(
640+
0, size, DataLoader::SegmentInfo(DataLoader::SegmentInfo::Type::Program));
641+
EXPECT_EQ(bytes.error(), Error::Ok);
642+
const auto* begin = static_cast<const uint8_t*>(bytes->data());
643+
std::vector<uint8_t> data(begin, begin + size);
644+
EXPECT_EQ(std::memcmp(data.data() + 8, "eh00", 4), 0);
645+
const uint64_t no_segment_data_size = 0;
646+
// segment_data_size follows program_size and segment_base_offset.
647+
std::memcpy(data.data() + 32, &no_segment_data_size, sizeof(uint64_t));
648+
return data;
649+
}
650+
651+
class UnknownSizeLoader final : public DataLoader {
652+
public:
653+
UnknownSizeLoader(const void* data, size_t size) : loader_(data, size) {}
654+
Result<FreeableBuffer> load(
655+
size_t offset,
656+
size_t size,
657+
const SegmentInfo& segment_info) const override {
658+
return loader_.load(offset, size, segment_info);
659+
}
660+
Result<size_t> size() const override {
661+
return Error::NotSupported;
662+
}
663+
664+
private:
665+
BufferDataLoader loader_;
666+
};
667+
} // namespace
668+
669+
TEST_F(ProgramTest, LoadLegacyHeaderWithoutDataSize) {
670+
std::vector<uint8_t> data = read_with_legacy_header(*multi_loader_);
671+
UnknownSizeLoader loader(data.data(), data.size());
672+
EXPECT_EQ(Program::load(&loader).error(), Error::Ok);
673+
}
674+
675+
TEST_F(ProgramTest, LoadProgramShorterThanItsHeaderSaysIsInvalidProgram) {
676+
std::vector<uint8_t> data = read_with_legacy_header(*multi_loader_);
677+
// Keep the header, but less than the program size it states.
678+
BufferDataLoader loader(data.data(), Program::kMinHeadBytes + 16);
679+
EXPECT_EQ(Program::load(&loader).error(), Error::InvalidProgram);
680+
}
681+
628682
TEST_F(ProgramTest, IncompatibleHeader) {
629683
// Make a local copy of the header.
630684
size_t data_len = Program::kMinHeadBytes;

0 commit comments

Comments
 (0)