diff --git a/script/manual-test-truncated-input.cc b/script/manual-test-truncated-input.cc new file mode 100644 index 00000000..2fc25d27 --- /dev/null +++ b/script/manual-test-truncated-input.cc @@ -0,0 +1,439 @@ +// Copyright 2023 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// ---------------- + +// manual-test-truncated-input tests that decoding truncated versions of +// well-formed files produces a "truncated input" error. +// +// It tests every M-byte prefix of a valid N-byte file, for every positive M +// that satisfies (M < 65536) or ((N - M) <= 1024). The truncation point is +// either within 64 KiB of the start or 1 KiB of the end. It does not test +// every potential M in between, as that would take O(N**2) time. + +#include +#include +#include +#include +#include +#include +#include +#include + +// Wuffs ships as a "single file C library" or "header file library" as per +// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt +// +// To use that single file as a "foo.c"-like implementation, instead of a +// "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or +// compiling it. +#define WUFFS_IMPLEMENTATION + +// Defining the WUFFS_CONFIG__STATIC_FUNCTIONS macro is optional, but when +// combined with WUFFS_IMPLEMENTATION, it demonstrates making all of Wuffs' +// functions have static storage. +// +// This can help the compiler ignore or discard unused code, which can produce +// faster compiles and smaller binaries. Other motivations are discussed in the +// "ALLOW STATIC IMPLEMENTATION" section of +// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt +#define WUFFS_CONFIG__STATIC_FUNCTIONS + +// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of +// release/c/etc.c choose which parts of Wuffs to build. That file contains the +// entire Wuffs standard library, implementing a variety of codecs and file +// formats. Without this macro definition, an optimizing compiler or linker may +// very well discard Wuffs code for unused codecs, but listing the Wuffs +// modules we use makes that process explicit. Preprocessing means that such +// code simply isn't compiled. +#define WUFFS_CONFIG__MODULES +#define WUFFS_CONFIG__MODULE__ADLER32 +#define WUFFS_CONFIG__MODULE__BASE +#define WUFFS_CONFIG__MODULE__BMP +#define WUFFS_CONFIG__MODULE__BZIP2 +#define WUFFS_CONFIG__MODULE__CRC32 +#define WUFFS_CONFIG__MODULE__DEFLATE +#define WUFFS_CONFIG__MODULE__GIF +#define WUFFS_CONFIG__MODULE__GZIP +#define WUFFS_CONFIG__MODULE__LZW +#define WUFFS_CONFIG__MODULE__NIE +#define WUFFS_CONFIG__MODULE__PNG +#define WUFFS_CONFIG__MODULE__TGA +#define WUFFS_CONFIG__MODULE__ZLIB + +// If building this program in an environment that doesn't easily accommodate +// relative includes, you can use the script/inline-c-relative-includes.go +// program to generate a stand-alone C file. +#include "../release/c/wuffs-unsupported-snapshot.c" + +// ---- + +#ifndef DST_BUFFER_ARRAY_SIZE +#define DST_BUFFER_ARRAY_SIZE (64 * 1024 * 1024) +#endif + +#ifndef WORKBUF_ARRAY_SIZE +#define WORKBUF_ARRAY_SIZE (256 * 1024 * 1024) +#endif + +uint8_t g_dst_buffer_array[DST_BUFFER_ARRAY_SIZE] = {0}; +uint8_t g_workbuf_array[WORKBUF_ARRAY_SIZE] = {0}; + +static int g_num_files_processed; + +static struct { + char buf[PATH_MAX]; + size_t len; +} g_relative_cwd; + +// ---- + +static const char skipped[] = "skipped"; +static const char unsupported_file_format[] = "unsupported file format"; + +static const char* // +handle_image_decoder(wuffs_base__io_buffer src, + int32_t fourcc, + bool full_decode) { + wuffs_base__image_decoder::unique_ptr dec(nullptr, &free); + switch (fourcc) { + case WUFFS_BASE__FOURCC__BMP: + dec = wuffs_bmp__decoder::alloc_as__wuffs_base__image_decoder(); + break; + case WUFFS_BASE__FOURCC__GIF: + dec = wuffs_gif__decoder::alloc_as__wuffs_base__image_decoder(); + break; + case WUFFS_BASE__FOURCC__NIE: + dec = wuffs_nie__decoder::alloc_as__wuffs_base__image_decoder(); + break; + case WUFFS_BASE__FOURCC__PNG: + dec = wuffs_png__decoder::alloc_as__wuffs_base__image_decoder(); + break; + case WUFFS_BASE__FOURCC__TGA: + dec = wuffs_tga__decoder::alloc_as__wuffs_base__image_decoder(); + break; + case WUFFS_BASE__FOURCC__WBMP: + // Unsupported. wuffs_base__magic_number_guess_fourcc can sometimes + // return false positives for WBMP. The WBMP file format doesn't + // start with a "magic" identifier. + return unsupported_file_format; + default: + return unsupported_file_format; + } + + if (!full_decode) { + while (true) { + auto dfc_status = dec->decode_frame_config(nullptr, &src); + if (dfc_status.is_ok()) { + // No-op. + } else if (dfc_status.repr == wuffs_base__note__end_of_data) { + break; + } else { + return dfc_status.message(); + } + } + return nullptr; + } + + wuffs_base__pixel_config pixcfg = {0}; + pixcfg.set(WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL, + WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, 0, 0); + + wuffs_base__pixel_buffer pixbuf = {0}; + auto sfs_status = + pixbuf.set_from_slice(&pixcfg, wuffs_base__make_slice_u8(nullptr, 0)); + if (!sfs_status.is_ok()) { + return sfs_status.message(); + } + + while (true) { + auto df_status = dec->decode_frame( + &pixbuf, &src, WUFFS_BASE__PIXEL_BLEND__SRC, + wuffs_base__make_slice_u8(g_workbuf_array, WORKBUF_ARRAY_SIZE), + nullptr); + if (df_status.is_ok()) { + // No-op. + } else if (df_status.repr == wuffs_base__note__end_of_data) { + break; + } else { + return df_status.message(); + } + } + return nullptr; +} + +static const char* // +handle_io_transformer(wuffs_base__io_buffer src, int32_t fourcc) { + wuffs_base__io_transformer::unique_ptr dec(nullptr, &free); + switch (fourcc) { + case WUFFS_BASE__FOURCC__BZ2: + dec = wuffs_bzip2__decoder::alloc_as__wuffs_base__io_transformer(); + break; + case WUFFS_BASE__FOURCC__GZ: + dec = wuffs_gzip__decoder::alloc_as__wuffs_base__io_transformer(); + break; + case WUFFS_BASE__FOURCC__ZLIB: + dec = wuffs_zlib__decoder::alloc_as__wuffs_base__io_transformer(); + break; + default: + return unsupported_file_format; + } + + while (true) { + auto dst = wuffs_base__ptr_u8__writer(&g_dst_buffer_array[0], + DST_BUFFER_ARRAY_SIZE); + auto df_status = dec->transform_io( + &dst, &src, + wuffs_base__make_slice_u8(g_workbuf_array, WORKBUF_ARRAY_SIZE)); + if (df_status.is_ok()) { + break; + } else if (df_status.repr == wuffs_base__suspension__short_write) { + // No-op. + } else { + return df_status.message(); + } + } + return nullptr; +} + +static const char* // +handle_various(wuffs_base__io_buffer src, int32_t fourcc) { + const char* status_msg; + + status_msg = handle_image_decoder(src, fourcc, false); + if (status_msg != unsupported_file_format) { + if ((status_msg != nullptr) && !strstr(status_msg, "truncated input")) { + return status_msg; + } + return handle_image_decoder(src, fourcc, true); + } + + status_msg = handle_io_transformer(src, fourcc); + if (status_msg != unsupported_file_format) { + return status_msg; + } + + return unsupported_file_format; +} + +static const char* // +handle_range(wuffs_base__io_buffer src, + int32_t fourcc, + size_t wi_min_incl, + size_t wi_max_excl) { + for (size_t wi = wi_min_incl; wi < wi_max_excl; wi++) { + src.meta.wi = wi; + const char* status_msg = handle_various(src, fourcc); + if ((status_msg != nullptr) && strstr(status_msg, "truncated input")) { + continue; + } + printf("when truncated to %zu bytes: ", wi); + if (status_msg) { + return status_msg; + } + return "have ok; want \"truncated input\""; + } + return nullptr; +} + +static const char* // +handle(const uint8_t* ptr, size_t len) { + auto src = wuffs_base__ptr_u8__reader(const_cast(ptr), len, true); + int32_t fourcc = wuffs_base__magic_number_guess_fourcc(src.reader_slice(), + src.meta.closed); + if (fourcc <= 0) { + return skipped; + } + + // Skip any invalid or unsupported input (when decoded in its entirety). + // + // Unsupported includes ignoring wuffs_base__note__i_o_redirect. We don't + // bother testing truncated PNGs-embedded-in-BMPs because we presumably + // already test truncated PNGs. + const char* status_msg = handle_various(src, fourcc); + if (status_msg) { + return skipped; + } + + size_t file_len = src.meta.wi; + if (file_len <= (65536 + 1024)) { + return handle_range(src, fourcc, 1, file_len); + } + + status_msg = handle_range(src, fourcc, 1, 65536); + if (status_msg) { + return status_msg; + } + return handle_range(src, fourcc, file_len - 1024, file_len); +} + +// ---- + +static int // +visit(char* filename); + +static int // +visit_dir(int fd) { + int cwd_fd = open(".", O_RDONLY, 0); + if (fchdir(fd)) { + printf("failed\n"); + fprintf(stderr, "FAIL: fchdir: %s\n", strerror(errno)); + return 1; + } + + DIR* d = fdopendir(fd); + if (!d) { + printf("failed\n"); + fprintf(stderr, "FAIL: fdopendir: %s\n", strerror(errno)); + return 1; + } + + printf("dir\n"); + while (true) { + struct dirent* e = readdir(d); + if (!e) { + break; + } + if ((e->d_name[0] == '\x00') || (e->d_name[0] == '.')) { + continue; + } + int v = visit(e->d_name); + if (v) { + return v; + } + } + + if (closedir(d)) { + fprintf(stderr, "FAIL: closedir: %s\n", strerror(errno)); + return 1; + } + if (fchdir(cwd_fd)) { + fprintf(stderr, "FAIL: fchdir: %s\n", strerror(errno)); + return 1; + } + if (close(cwd_fd)) { + fprintf(stderr, "FAIL: close: %s\n", strerror(errno)); + return 1; + } + return 0; +} + +static int // +visit_reg(int fd, off_t size) { + if ((size < 0) || (0x7FFFFFFF < size)) { + printf("failed\n"); + fprintf(stderr, "FAIL: file size out of bounds"); + return 1; + } + + void* data = NULL; + if (size > 0) { + data = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0); + if (data == MAP_FAILED) { + printf("failed\n"); + fprintf(stderr, "FAIL: mmap: %s\n", strerror(errno)); + return 1; + } + } + + const char* msg = handle((const uint8_t*)(data), size); + if (msg) { + printf("%s\n", msg); + } else { + printf("ok\n"); + } + + if ((size > 0) && munmap(data, size)) { + fprintf(stderr, "FAIL: mmap: %s\n", strerror(errno)); + return 1; + } + if (close(fd)) { + fprintf(stderr, "FAIL: close: %s\n", strerror(errno)); + return 1; + } + return (msg && (msg != skipped)) ? 1 : 0; +} + +static int // +visit(char* filename) { + g_num_files_processed++; + if (!filename || (filename[0] == '\x00')) { + fprintf(stderr, "FAIL: invalid filename\n"); + return 1; + } + int n = printf("- %s%s", g_relative_cwd.buf, filename); + printf("%*s", (60 > n) ? (60 - n) : 1, ""); + fflush(stdout); + + struct stat z; + int fd = open(filename, O_RDONLY, 0); + if (fd == -1) { + printf("failed\n"); + fprintf(stderr, "FAIL: open: %s\n", strerror(errno)); + return 1; + } + if (fstat(fd, &z)) { + printf("failed\n"); + fprintf(stderr, "FAIL: fstat: %s\n", strerror(errno)); + return 1; + } + + if (S_ISREG(z.st_mode)) { + return visit_reg(fd, z.st_size); + } else if (!S_ISDIR(z.st_mode)) { + printf("skipped\n"); + return 0; + } + + size_t old_len = g_relative_cwd.len; + size_t filename_len = strlen(filename); + size_t new_len = old_len + strlen(filename); + bool slash = filename[filename_len - 1] != '/'; + if (slash) { + new_len++; + } + if ((filename_len >= PATH_MAX) || (new_len >= PATH_MAX)) { + printf("failed\n"); + fprintf(stderr, "FAIL: path is too long\n"); + return 1; + } + memcpy(g_relative_cwd.buf + old_len, filename, filename_len); + + if (slash) { + g_relative_cwd.buf[new_len - 1] = '/'; + } + g_relative_cwd.buf[new_len] = '\x00'; + g_relative_cwd.len = new_len; + + int v = visit_dir(fd); + + g_relative_cwd.buf[old_len] = '\x00'; + g_relative_cwd.len = old_len; + return v; +} + +int // +main(int argc, char** argv) { + g_num_files_processed = 0; + g_relative_cwd.len = 0; + + for (int i = 1; i < argc; i++) { + int v = visit(argv[i]); + if (v) { + return v; + } + } + + printf("PASS: %d files processed\n", g_num_files_processed); + return 0; +}