Test CVE-2018-25032 against the default level and levels 1 and 2.

Added unit test against CVE-2018-25032 with default strategy.

Co-authored-by: Eric Biggers <ebiggers@kernel.org>

Added unit test against CVE-2018-25032.
Sample input from https://www.openwall.com/lists/oss-security/2022/03/26/1.

Co-authored-by: Tavis Ormandy <taviso@users.noreply.github.com>

Added missing -F argument for Z_FIXED strategy in minideflate.

Use size_t types for len arithmetic, matching signature

This suppresses a warning and keeps everything safely the same type.
While it's unlikely that the input for any of this will exceed the size
of an unsigned 32 bit integer, this approach is cleaner than casting and
should not result in a performance degradation.

Use standalone fuzzing runner only when fuzzing engine is not found.

Allow SSE2 and AVX2 functions with -DWITH_UNALIGNED=OFF. Even though they use unaligned loads, they don't result in undefined behavior.

Leverage inline CRC + copy

This brings back a bit of the performance that may have been sacrificed
by reverting the reorganized inflate window. Doing a copy at the same
time as a CRC is basically free.

Fixed clang signed/unsigned warning in chunkcopy_safe.

inflate_p.h:159:18: warning: comparison of integers of different signs: 'int32_t' (aka 'int') and 'size_t' (aka 'unsigned long') [-Wsign-compare]
        tocopy = MIN(non_olap_size, len);
                 ^   ~~~~~~~~~~~~~  ~~~
zbuild.h:74:24: note: expanded from macro 'MIN'
#define MIN(a, b) ((a) > (b) ? (b) : (a))
                    ~  ^  ~

Use specific gcovr version 5.0 due to parser errors with 5.1.
https://github.com/gcovr/gcovr/issues/583

Remove unistd.h include from gzguts.h which is already included from zconf.h via zlib.h.

Use HAVE instead of HAS for variable name for consistency.

Remove detect_leaks=0 from non-ASAN cmake jobs.

Fixed error with compare256_unaligned_avx2 undefined if unaligned access is disabled.

Fixed signed comparison warning in zng_calloc_aligned.

zutil.c: In function ‘zng_calloc_aligned’:
zutil.c:133:20: warning: comparison of integer expressions of different signedness: ‘int32_t’ {aka ‘int’} and ‘long unsigned int’ [-Wsign-compare]

Fixed unused opaque variable in aligned alloc test.

test_aligned_alloc.cc: In function ‘void* zng_calloc_unaligned(void*, unsigned int, unsigned int)’:
test_aligned_alloc.cc:14:34: warning: unused parameter ‘opaque’ [-Wunused-parameter]
test_aligned_alloc.cc: In function ‘void zng_cfree_unaligned(void*, void*)’:
test_aligned_alloc.cc:28:32: warning: unused parameter ‘opaque’ [-Wunused-parameter]

Fixed operator precedence warnings in slide_hash_sse2.

slide_hash_sse2.c(58,5): warning C4554: '&': check operator precedence for possible error; use parentheses to clarify precedence
slide_hash_sse2.c(59,5): warning C4554: '&': check operator precedence for possible error; use parentheses to clarify precedence

Fixed signed/unsigned warning in chunkmemset.

chunkset_tpl.h(107,24): warning C4018: '>': signed/unsigned mismatch

Fixed MSVC warnings in chunkcopy_safe.

inflate_p.h(244,18): warning C4018: '>': signed/unsigned mismatch
inflate_p.h(234,38): warning C4244: 'initializing': conversion from '__int64' to 'int', possible loss of data
inffast.c
inflate_p.h(244,18): warning C4018: '>': signed/unsigned mismatch
inflate_p.h(234,38): warning C4244: 'initializing': conversion from '__int64' to 'int', possible loss of data
inflate.c
inflate_p.h(244,18): warning C4018: '>': signed/unsigned mismatch
inflate_p.h(234,38): warning C4244: 'initializing': conversion from '__int64' to 'int', possible loss of data

Correct typo in functable

Now, I could be wrong about this being an error, but I don't see any discussion suggesting this was intended, so...

Add unit tests for compare256 variants.

Fixed a warning about a comparison of an unsigned with a signed type

Fix an issue with the ubsan for overflow

While this didn't _actually_ cause any issues for us, technically the
_mm512_reduce_add_epi32() intrinsics returns a signed integer and it
does the very last summation in scalar GPRs as signed integers. While
the ALU still did the math properly (the negative representation is the
same addition in hardware, just interpreted differently), the sanitizer
caught window of inputs here definitely outside the range of a signed
integer for this immediate operation.

The solution, as silly as it may seem, would be to implement our own 32
bit horizontal sum function that does all of the work in vector
registers. This allows us to implicitly keep things in vector register
domain and convert at the very end after we've summed the summation.

The compiler's sanitizer doesn't know the wiser and the solution still
results in being correct.

Update language around ABI compatibility with zlib. #1081

Rename adler32_sse41 to adler32_ssse3

As it turns out, the sum of absolute differences instruction _did_ exist
in SSSE3 all along. SSE41 introduced a stranger, less commonly used
variation of the sum of absolute difference instruction.  Knowing this,
the old SSSE3 method can be axed entirely and the SSE41 method can now
be used on CPUs only having SSSE3.

Removing this extra functable entry shrinks the code and allows for a
simpler planned refactor later for the adler checksum and copy elision.

Fixed missing checks around compare256 and longest_match definitions.

Use zmemcmp_2 in 16-bit unaligned compare256 variant.

Revert "Reorganize inflate window layout"

This reverts commit dc3b60841dbfa9cf37be3efb4568f055b4e15580.

Revert "Add back original version of inflate_fast for use with inflateBack."

This reverts commit 2d2dde43b11c40cb58a339ff4a8425bca0091c31.

Revert "DFLTCC update for window optimization from Jim & Nathan"

This reverts commit b4ca25afabba7b4bf74d36e26728006d28df891d.

Added common sanitizer flags for getting optimal stack traces.

Use halt_on_error in sanitizer options.
https://lists.llvm.org/pipermail/cfe-dev/2015-October/045710.html

Make symbolic prefix instance names consistent in NMake GHA workflow.

Fixed misspelling in NO_UNALIGNED flag.

Wrong variable used when detecting unaligned support for sanitize

Added sanitizer tests in configure GitHub Actions workflow.
Added missing OPTIONS environment variable for UBSAN in CMake GitHub workflow.

Use zutil.h which already includes zlib headers.

Remove unused zutil header.

Fix a latent issue with chunkmemset

It would seem that on some platforms, namely those which are
!UNALIGNED64_OK, there was a likelihood of chunkmemset_safe_c copying all
the bytes before passing control flow to chunkcopy, a function which is
explicitly unsafe to be called with a zero length copy.

This fixes that bug for those platforms.

Fix UBSAN's cry afoul

Technically, we weren't actually doing this the way C wants us to,
legally.  The zmemcpy's turn into NOPs for pretty much all > 0
optimization levels and this gets us defined behavior with the
sanitizer, putting the optimized load by arbitrary alignment into the
compiler's hands instead of ours.

Added check for UNALIGNED64_OK when defining zmemcpy_8 and zmemcmp_8.

Added 32-bit GCC build to CMake GitHub Actions.

Make unaligned access being disabled configurable via build scripts.

Move UNALIGNED_OK detection to compile time instead of configure time.

Explicitly install dependencies for wine32.
* Allow downgrading packages to resolve conflicts

Don't use -mtune with ClangCl.

[README] Add missing FORCE_SSE2 for CMake.

Allow bypassing runtime feature check of TZCNT instructions.
* This avoids conditional branch when it's known at build time that TZCNT instructions are always supported

Throw an error when input is raw deflate stream but window_bits is not supplied.

Print help when no arguments supplied to minideflate.

Append extension to output file path based on window_bits when compressing and remove extension from output file path when decompressing.

Added support for -k keep argument to minideflate. By default minideflate will now delete the input file.

Use large default buffer size for minideflate to match minigzip use of GZBUFSIZE.

Include zutil.h for definition of DEF_MEM_LEVEL.

Auto-detect wrapper when inflating and no window_bits specified.

Updated help usage with correct values for window_bits.

Fixed wrong error name when calling inflate in minideflate.

Speed up chunkcopy and memset

This was found to have a significant impact on a highly compressible PNG
for both the encode and decode.  Some deltas show performance improving
as much as 60%+.

For the scenarios where the "dist" is not an even modulus of our chunk
size, we simply repeat the bytes as many times as possible into our
vector registers.  We then copy the entire vector and then advance the
quotient of our chunksize divided by our dist value.

If dist happens to be 1, there's no reason to not just call memset from
libc (this is likely to be just as fast if not faster).

Improve SSE2 slide hash performance

At least on pre-nehalem CPUs, we get a > 50% improvement. This is
mostly due to the fact that we're opportunistically doing aligned loads
instead of unaligned loads.  This is something that is very likely to be
possible, given that the deflate stream initialization uses the zalloc
function, which most libraries don't override.  Our allocator aligns to
64 byte boundaries, meaning we can do aligned loads on even AVX512 for
the zstream->prev and zstream->head pointers. However, only pre-nehalem
CPUs _actually_ benefit from explicitly aligned load instructions.

The other thing being done here is we're unrolling the loop by a factor
of 2 so that we can get a tiny bit more ILP.  This improved performance
by another 5%-7% gain.

Added unit test for zng_calloc_aligned to ensure that it always returns 64-byte aligned memory allocation when requested.

Bypass memory alignment compensation if not using custom allocator.

Added memory alignment compensation functions for users who may be using custom allocators that don't align on the same boundary zlib-ng expects.

IBM Z: Delete stale self-hosted builder containers

Due to things like power outage ExecStop may not run, resulting in a
stale actions-runner container. This would prevent ExecStart from
succeeding, so try deleting such stale containers in ExecStartPre.

Use older version of Google test to support older versions of GCC.
Allow specifying alternative Google test repository and tag.

Ignore code coverage for files in _dep directory.

Compile MSAN instrumented C++ libraries for MSAN build with googletest.

Prefer posix versions of MinGW for compiling against googletest.

Added static versions of c++ libraries on S390X, MinGW, and ppc.

Specify c++ compiler, packages, and flags for Google Test in cmake workflow.

Move CVE-2003-0107 test to Google Tests.

Implement unit testing using Google Test framework.

Added ClangCl instances to GitHub Actions workflow.

Fixed inftrees.c should be compiled with infcover when zlib is a shared library.

Adding some application-specific benchmarks

So far there's only added png encode and decode with predictably
compressible bytes. This gives us a rough idea of more holistic
impacts of performance improvements (and regressions).

An interesting thing found with this, when compared with stock zlib,
we're slower for png decoding at levels 8 & 9. When we are slower, we
are spending a fair amount of time in the chunk copy function. This
probably merits a closer look.

This code creates optionally an alternative benchmark binary that links
with an alternative static zlib implementation. This can be used to
quickly compare between different forks.

Use pclmulqdq accelerated CRC for exported function

We were already using this internally for our CRC calculations, however
the exported function to CRC checksum any arbitrary stream of bytes was
still using a generic C based version that leveraged tables. This
function is now called when len is at least 64 bytes.

Improved adler32 NEON performance by 30-47%

We unlocked some ILP by allowing for independent sums in the loop and
reducing these sums outside of the loop. Additionally, the multiplication
by 32 (now 64) is moved outside of this loop. Similar to the chromium
implementation, this code does straight 8 bit -> 16 bit additions and defers
the fused multiply accumulate outside of the loop.  However, by unrolling by
another factor of 2, the code is measurably faster. The code does fused multiply
accmulates back to as many scratch registers we have room for in order to maximize
ILP for the 16 integer FMAs that need to occur.  The compiler seems to order them
such that the destination register is the same register as the previous instruction,
so perhaps it's not actually able to overlap or maybe the -A73's pipeline is reordering
these instructions, anyway.

On the Odroid-N2, the Cortex-A73 cores are ~30-44% faster on the adler32 benchmark,
and the Cortex-A53 cores are anywhere from 34-47% faster.

Unlocked more ILP in SSE variant of adler checksum

This helps uarchs such as sandybridge more than Yorkfield, but there
were some measurable gains on a Core 2 Quad Q9650 as well. We can sum
to two separate vs2 variables and add them back together at the end,
allowing for some overlapping multiply-adds. This was only about a 9-12%
gain on the Q9650 but it nearly doubled performance on cascade lake and
is likely to have appreciable gains on everything in between those two.

Improve sse41 adler32 performance

Rather than doing opportunistic aligned loads, we can do scalar
unaligned loads into our two halves of the checksum until we hit
alignment.  Then, we can subtract from the max number of sums for the
first run through the loop.

This allows us to force aligned loads for unaligned buffers (likely a
common case for arbitrary runs of memory). This is not meaningful after
Nehalem but pre-Nehalem architectures it makes a substantial difference
to performance and is more foolproof than hoping for an aligned buffer.

Improvement is around 44-50% for unaligned worst case scenarios.

Run libpng tests on push in addition to pull-requests.
Also run oss-fuzz on push to certain branches.

Fix compilation of benchmark when compiler supports, but does not default to enable C++11 or higher.

Use multiple threads when running gcovr.

Exclude unreachable branches from code coverage report.

Added codecov yaml configuration to repository.

Switch to using Codecov GitHub Action.

IBM Z: Install Codecov dependencies on the self-hosted builder

Prevent stale stub functions from being called in deflate_slow

Just in case this is the very first call to longest match, we should
instead assign the function pointer instead of the function itself. This
way, by the time it leaves the stub, the function pointer gets
reassigned. This was found incidentally while debugging something else.

Don't use -march=native when doing LD4 test for ARM/AArch64.

[AArch64] Add missing LD4 test for configure.

Axe the SSE4 compare256 functions

Write an SSE2 optimized compare256

The SSE4 variant uses the unfortunate string comparison instructions from
SSE4.2 which not only don't work on as many CPUs but, are often slower
than the SSE2 counterparts except in very specific circumstances.

This version should be ~2x faster than unaligned_64 for larger strings
and about half the performance of AVX2 comparisons on identical
hardware.

This version is meant to supplement pre AVX hardware. Because of this,
we're performing 1 extra load + compare at the beginning. In the event
that we're doing a full 256 byte comparison (completely equal strings),
this will result in 2 extra SIMD comparisons if the inputs are unaligned.
Given that the loads will be absorbed by L1, this isn't super likely to
be a giant penalty but for something like a core-i first or second gen,
where unaligned loads aren't nearly as expensive, this going to be
_marginally_ slower in the worst case.  This allows us to have half the
loads be aligned, so that the compiler can elide the load and compare by
using a register relative pcmpeqb.

Introduce zmemcmp to use unaligned access for architectures we know support unaligned access, otherwise use memcmp.

Introduce zmemcpy to use unaligned access for architectures we know support unaligned access, otherwise use memcpy.

Simplify chunk_t type to uint64_t with memcpy calls.

Fix compilation with clang-cl on windows

Do not include (system) headers when processing these headers with the
resource compiler, because it might trip over the headers coming from
LLVM.

Update NMake GitHub Actions to use Visual Studio 2022 Enterprise.

Remove unnecessary zutil.h includes.

Fixed short name for CPU features header guard.

Remove duplicate header includes.

Only define CPU variants that require deflate_state when deflate.h has previously been included. This allows us to include cpu_features.h without including zlib.h or name mangling.

Rename CPU feature header and source files for consistency.