Add files using upload-large-folder tool

local-test-commons-compress-full-01-vuln_5/afc-commons-compress/src/test/resources/COMPRESS-477/split_zip_created_by_winrar/file_to_compare_1

@@ -0,0 +1,1297 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ * http://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.
+ */
+package org.apache.commons.compress.archivers.zip;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.zip.CRC32;
+import java.util.zip.DataFormatException;
+import java.util.zip.Inflater;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipException;
+
+import org.apache.commons.compress.archivers.ArchiveEntry;
+import org.apache.commons.compress.archivers.ArchiveInputStream;
+import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
+import org.apache.commons.compress.compressors.deflate64.Deflate64CompressorInputStream;
+import org.apache.commons.compress.utils.ArchiveUtils;
+import org.apache.commons.compress.utils.IOUtils;
+import org.apache.commons.compress.utils.InputStreamStatistics;
+
+import static org.apache.commons.compress.archivers.zip.ZipConstants.DWORD;
+import static org.apache.commons.compress.archivers.zip.ZipConstants.SHORT;
+import static org.apache.commons.compress.archivers.zip.ZipConstants.WORD;
+import static org.apache.commons.compress.archivers.zip.ZipConstants.ZIP64_MAGIC;
+
+/**
+ * Implements an input stream that can read Zip archives.
+ *
+ * <p>As of Apache Commons Compress it transparently supports Zip64
+ * extensions and thus individual entries and archives larger than 4
+ * GB or with more than 65536 entries.</p>
+ *
+ * <p>The {@link ZipFile} class is preferred when reading from files
+ * as {@link ZipArchiveInputStream} is limited by not being able to
+ * read the central directory header before returning entries.  In
+ * particular {@link ZipArchiveInputStream}</p>
+ *
+ * <ul>
+ *
+ *  <li>may return entries that are not part of the central directory
+ *  at all and shouldn't be considered part of the archive.</li>
+ *
+ *  <li>may return several entries with the same name.</li>
+ *
+ *  <li>will not return internal or external attributes.</li>
+ *
+ *  <li>may return incomplete extra field data.</li>
+ *
+ *  <li>may return unknown sizes and CRC values for entries until the
+ *  next entry has been reached if the archive uses the data
+ *  descriptor feature.</li>
+ *
+ * </ul>
+ *
+ * @see ZipFile
+ * @NotThreadSafe
+ */
+public class ZipArchiveInputStream extends ArchiveInputStream implements InputStreamStatistics {
+
+    /** The zip encoding to use for file names and the file comment. */
+    private final ZipEncoding zipEncoding;
+
+    // the provided encoding (for unit tests)
+    final String encoding;
+
+    /** Whether to look for and use Unicode extra fields. */
+    private final boolean useUnicodeExtraFields;
+
+    /** Wrapped stream, will always be a PushbackInputStream. */
+    private final InputStream in;
+
+    /** Inflater used for all deflated entries. */
+    private final Inflater inf = new Inflater(true);
+
+    /** Buffer used to read from the wrapped stream. */
+    private final ByteBuffer buf = ByteBuffer.allocate(ZipArchiveOutputStream.BUFFER_SIZE);
+
+    /** The entry that is currently being read. */
+    private CurrentEntry current = null;
+
+    /** Whether the stream has been closed. */
+    private boolean closed = false;
+
+    /** Whether the stream has reached the central directory - and thus found all entries. */
+    private boolean hitCentralDirectory = false;
+
+    /**
+     * When reading a stored entry that uses the data descriptor this
+     * stream has to read the full entry and caches it.  This is the
+     * cache.
+     */
+    private ByteArrayInputStream lastStoredEntry = null;
+
+    /** Whether the stream will try to read STORED entries that use a data descriptor. */
+    private boolean allowStoredEntriesWithDataDescriptor = false;
+
+    /** Count decompressed bytes for current entry */
+    private long uncompressedCount = 0;
+
+    private static final int LFH_LEN = 30;
+    /*
+      local file header signature     WORD
+      version needed to extract       SHORT
+      general purpose bit flag        SHORT
+      compression method              SHORT
+      last mod file time              SHORT
+      last mod file date              SHORT
+      crc-32                          WORD
+      compressed size                 WORD
+      uncompressed size               WORD
+      file name length                SHORT
+      extra field length              SHORT
+    */
+
+    private static final int CFH_LEN = 46;
+    /*
+        central file header signature   WORD
+        version made by                 SHORT
+        version needed to extract       SHORT
+        general purpose bit flag        SHORT
+        compression method              SHORT
+        last mod file time              SHORT
+        last mod file date              SHORT
+        crc-32                          WORD
+        compressed size                 WORD
+        uncompressed size               WORD
+        file name length                SHORT
+        extra field length              SHORT
+        file comment length             SHORT
+        disk number start               SHORT
+        internal file attributes        SHORT
+        external file attributes        WORD
+        relative offset of local header WORD
+    */
+
+    private static final long TWO_EXP_32 = ZIP64_MAGIC + 1;
+
+    // cached buffers - must only be used locally in the class (COMPRESS-172 - reduce garbage collection)
+    private final byte[] lfhBuf = new byte[LFH_LEN];
+    private final byte[] skipBuf = new byte[1024];
+    private final byte[] shortBuf = new byte[SHORT];
+    private final byte[] wordBuf = new byte[WORD];
+    private final byte[] twoDwordBuf = new byte[2 * DWORD];
+
+    private int entriesRead = 0;
+
+    /**
+     * Create an instance using UTF-8 encoding
+     * @param inputStream the stream to wrap
+     */
+    public ZipArchiveInputStream(final InputStream inputStream) {
+        this(inputStream, ZipEncodingHelper.UTF8);
+    }
+
+    /**
+     * Create an instance using the specified encoding
+     * @param inputStream the stream to wrap
+     * @param encoding the encoding to use for file names, use null
+     * for the platform's default encoding
+     * @since 1.5
+     */
+    public ZipArchiveInputStream(final InputStream inputStream, final String encoding) {
+        this(inputStream, encoding, true);
+    }
+
+    /**
+     * Create an instance using the specified encoding
+     * @param inputStream the stream to wrap
+     * @param encoding the encoding to use for file names, use null
+     * for the platform's default encoding
+     * @param useUnicodeExtraFields whether to use InfoZIP Unicode
+     * Extra Fields (if present) to set the file names.
+     */
+    public ZipArchiveInputStream(final InputStream inputStream, final String encoding, final boolean useUnicodeExtraFields) {
+        this(inputStream, encoding, useUnicodeExtraFields, false);
+    }
+
+    /**
+     * Create an instance using the specified encoding
+     * @param inputStream the stream to wrap
+     * @param encoding the encoding to use for file names, use null
+     * for the platform's default encoding
+     * @param useUnicodeExtraFields whether to use InfoZIP Unicode
+     * Extra Fields (if present) to set the file names.
+     * @param allowStoredEntriesWithDataDescriptor whether the stream
+     * will try to read STORED entries that use a data descriptor
+     * @since 1.1
+     */
+    public ZipArchiveInputStream(final InputStream inputStream,
+                                 final String encoding,
+                                 final boolean useUnicodeExtraFields,
+                                 final boolean allowStoredEntriesWithDataDescriptor) {
+        this.encoding = encoding;
+        zipEncoding = ZipEncodingHelper.getZipEncoding(encoding);
+        this.useUnicodeExtraFields = useUnicodeExtraFields;
+        in = new PushbackInputStream(inputStream, buf.capacity());
+        this.allowStoredEntriesWithDataDescriptor =
+            allowStoredEntriesWithDataDescriptor;
+        // haven't read anything so far
+        buf.limit(0);
+    }
+
+    public ZipArchiveEntry getNextZipEntry() throws IOException {
+        uncompressedCount = 0;
+
+        boolean firstEntry = true;
+        if (closed || hitCentralDirectory) {
+            return null;
+        }
+        if (current != null) {
+            closeEntry();
+            firstEntry = false;
+        }
+
+        long currentHeaderOffset = getBytesRead();
+        try {
+            if (firstEntry) {
+                // split archives have a special signature before the
+                // first local file header - look for it and fail with
+                // the appropriate error message if this is a split
+                // archive.
+                readFirstLocalFileHeader(lfhBuf);
+            } else {
+                readFully(lfhBuf);
+            }
+        } catch (final EOFException e) { //NOSONAR
+            return null;
+        }
+
+        final ZipLong sig = new ZipLong(lfhBuf);
+        if (!sig.equals(ZipLong.LFH_SIG)) {
+            if (sig.equals(ZipLong.CFH_SIG) || sig.equals(ZipLong.AED_SIG) || isApkSigningBlock(lfhBuf)) {
+                hitCentralDirectory = true;
+                skipRemainderOfArchive();
+                return null;
+            }
+            throw new ZipException(String.format("Unexpected record signature: 0X%X", sig.getValue()));
+        }
+
+        int off = WORD;
+        current = new CurrentEntry();
+
+        final int versionMadeBy = ZipShort.getValue(lfhBuf, off);
+        off += SHORT;
+        current.entry.setPlatform((versionMadeBy >> ZipFile.BYTE_SHIFT) & ZipFile.NIBLET_MASK);
+
+        final GeneralPurposeBit gpFlag = GeneralPurposeBit.parse(lfhBuf, off);
+        final boolean hasUTF8Flag = gpFlag.usesUTF8ForNames();
+        final ZipEncoding entryEncoding = hasUTF8Flag ? ZipEncodingHelper.UTF8_ZIP_ENCODING : zipEncoding;
+        current.hasDataDescriptor = gpFlag.usesDataDescriptor();
+        current.entry.setGeneralPurposeBit(gpFlag);
+
+        off += SHORT;
+
+        current.entry.setMethod(ZipShort.getValue(lfhBuf, off));
+        off += SHORT;
+
+        final long time = ZipUtil.dosToJavaTime(ZipLong.getValue(lfhBuf, off));
+        current.entry.setTime(time);
+        off += WORD;
+
+        ZipLong size = null, cSize = null;
+        if (!current.hasDataDescriptor) {
+            current.entry.setCrc(ZipLong.getValue(lfhBuf, off));
+            off += WORD;
+
+            cSize = new ZipLong(lfhBuf, off);
+            off += WORD;
+
+            size = new ZipLong(lfhBuf, off);
+            off += WORD;
+        } else {
+            off += 3 * WORD;
+        }
+
+        final int fileNameLen = ZipShort.getValue(lfhBuf, off);
+
+        off += SHORT;
+
+        final int extraLen = ZipShort.getValue(lfhBuf, off);
+        off += SHORT; // NOSONAR - assignment as documentation
+
+        final byte[] fileName = new byte[fileNameLen];
+        readFully(fileName);
+        current.entry.setName(entryEncoding.decode(fileName), fileName);
+        if (hasUTF8Flag) {
+            current.entry.setNameSource(ZipArchiveEntry.NameSource.NAME_WITH_EFS_FLAG);
+        }
+
+        final byte[] extraData = new byte[extraLen];
+        readFully(extraData);
+        current.entry.setExtra(extraData);
+
+        if (!hasUTF8Flag && useUnicodeExtraFields) {
+            ZipUtil.setNameAndCommentFromExtraFields(current.entry, fileName, null);
+        }
+
+        processZip64Extra(size, cSize);
+
+        current.entry.setLocalHeaderOffset(currentHeaderOffset);
+        current.entry.setDataOffset(getBytesRead());
+        current.entry.setStreamContiguous(true);
+
+        ZipMethod m = ZipMethod.getMethodByCode(current.entry.getMethod());
+        if (current.entry.getCompressedSize() != ArchiveEntry.SIZE_UNKNOWN) {
+            if (ZipUtil.canHandleEntryData(current.entry) && m != ZipMethod.STORED && m != ZipMethod.DEFLATED) {
+                InputStream bis = new BoundedInputStream(in, current.entry.getCompressedSize());
+                switch (m) {
+                case UNSHRINKING:
+                    current.in = new UnshrinkingInputStream(bis);
+                    break;
+                case IMPLODING:
+                    current.in = new ExplodingInputStream(
+                        current.entry.getGeneralPurposeBit().getSlidingDictionarySize(),
+                        current.entry.getGeneralPurposeBit().getNumberOfShannonFanoTrees(),
+                        bis);
+                    break;
+                case BZIP2:
+                    current.in = new BZip2CompressorInputStream(bis);
+                    break;
+                case ENHANCED_DEFLATED:
+                    current.in = new Deflate64CompressorInputStream(bis);
+                    break;
+                default:
+                    // we should never get here as all supported methods have been covered
+                    // will cause an error when read is invoked, don't throw an exception here so people can
+                    // skip unsupported entries
+                    break;
+                }
+            }
+        } else if (m == ZipMethod.ENHANCED_DEFLATED) {
+            current.in = new Deflate64CompressorInputStream(in);
+        }
+
+        entriesRead++;
+        return current.entry;
+    }
+
+    /**
+     * Fills the given array with the first local file header and
+     * deals with splitting/spanning markers that may prefix the first
+     * LFH.
+     */
+    private void readFirstLocalFileHeader(final byte[] lfh) throws IOException {
+        readFully(lfh);
+        final ZipLong sig = new ZipLong(lfh);
+        if (sig.equals(ZipLong.DD_SIG)) {
+            throw new UnsupportedZipFeatureException(UnsupportedZipFeatureException.Feature.SPLITTING);
+        }
+
+        if (sig.equals(ZipLong.SINGLE_SEGMENT_SPLIT_MARKER)) {
+            // The archive is not really split as only one segment was
+            // needed in the end.  Just skip over the marker.
+            final byte[] missedLfhBytes = new byte[4];
+            readFully(missedLfhBytes);
+            System.arraycopy(lfh, 4, lfh, 0, LFH_LEN - 4);
+            System.arraycopy(missedLfhBytes, 0, lfh, LFH_LEN - 4, 4);
+        }
+    }
+
+    /**
+     * Records whether a Zip64 extra is present and sets the size
+     * information from it if sizes are 0xFFFFFFFF and the entry
+     * doesn't use a data descriptor.
+     */
+    private void processZip64Extra(final ZipLong size, final ZipLong cSize) {
+        final Zip64ExtendedInformationExtraField z64 =
+            (Zip64ExtendedInformationExtraField)
+            current.entry.getExtraField(Zip64ExtendedInformationExtraField.HEADER_ID);
+        current.usesZip64 = z64 != null;
+        if (!current.hasDataDescriptor) {
+            if (z64 != null // same as current.usesZip64 but avoids NPE warning
+                    && (ZipLong.ZIP64_MAGIC.equals(cSize) || ZipLong.ZIP64_MAGIC.equals(size)) ) {
+                current.entry.setCompressedSize(z64.getCompressedSize().getLongValue());
+                current.entry.setSize(z64.getSize().getLongValue());
+            } else if (cSize != null && size != null) {
+                current.entry.setCompressedSize(cSize.getValue());
+                current.entry.setSize(size.getValue());
+            }
+        }
+    }
+
+    @Override
+    public ArchiveEntry getNextEntry() throws IOException {
+        return getNextZipEntry();
+    }
+
+    /**
+     * Whether this class is able to read the given entry.
+     *
+     * <p>May return false if it is set up to use encryption or a
+     * compression method that hasn't been implemented yet.</p>
+     * @since 1.1
+     */
+    @Override
+    public boolean canReadEntryData(final ArchiveEntry ae) {
+        if (ae instanceof ZipArchiveEntry) {
+            final ZipArchiveEntry ze = (ZipArchiveEntry) ae;
+            return ZipUtil.canHandleEntryData(ze)
+                && supportsDataDescriptorFor(ze)
+                && supportsCompressedSizeFor(ze);
+        }
+        return false;
+    }
+
+    @Override
+    public int read(final byte[] buffer, final int offset, final int length) throws IOException {
+        if (length == 0) {
+            return 0;
+        }
+        if (closed) {
+            throw new IOException("The stream is closed");
+        }
+
+        if (current == null) {
+            return -1;
+        }
+
+        // avoid int overflow, check null buffer
+        if (offset > buffer.length || length < 0 || offset < 0 || buffer.length - offset < length) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+
+        ZipUtil.checkRequestedFeatures(current.entry);
+        if (!supportsDataDescriptorFor(current.entry)) {
+            throw new UnsupportedZipFeatureException(UnsupportedZipFeatureException.Feature.DATA_DESCRIPTOR,
+                    current.entry);
+        }
+        if (!supportsCompressedSizeFor(current.entry)) {
+            throw new UnsupportedZipFeatureException(UnsupportedZipFeatureException.Feature.UNKNOWN_COMPRESSED_SIZE,
+                    current.entry);
+        }
+
+        int read;
+        if (current.entry.getMethod() == ZipArchiveOutputStream.STORED) {
+            read = readStored(buffer, offset, length);
+        } else if (current.entry.getMethod() == ZipArchiveOutputStream.DEFLATED) {
+            read = readDeflated(buffer, offset, length);
+        } else if (current.entry.getMethod() == ZipMethod.UNSHRINKING.getCode()
+                || current.entry.getMethod() == ZipMethod.IMPLODING.getCode()
+                || current.entry.getMethod() == ZipMethod.ENHANCED_DEFLATED.getCode()
+                || current.entry.getMethod() == ZipMethod.BZIP2.getCode()) {
+            read = current.in.read(buffer, offset, length);
+        } else {
+            throw new UnsupportedZipFeatureException(ZipMethod.getMethodByCode(current.entry.getMethod()),
+                    current.entry);
+        }
+
+        if (read >= 0) {
+            current.crc.update(buffer, offset, read);
+            uncompressedCount += read;
+        }
+
+        return read;
+    }
+
+    /**
+     * @since 1.17
+     */
+    @Override
+    public long getCompressedCount() {
+        if (current.entry.getMethod() == ZipArchiveOutputStream.STORED) {
+            return current.bytesRead;
+        } else if (current.entry.getMethod() == ZipArchiveOutputStream.DEFLATED) {
+            return getBytesInflated();
+        } else if (current.entry.getMethod() == ZipMethod.UNSHRINKING.getCode()) {
+            return ((UnshrinkingInputStream) current.in).getCompressedCount();
+        } else if (current.entry.getMethod() == ZipMethod.IMPLODING.getCode()) {
+            return ((ExplodingInputStream) current.in).getCompressedCount();
+        } else if (current.entry.getMethod() == ZipMethod.ENHANCED_DEFLATED.getCode()) {
+            return ((Deflate64CompressorInputStream) current.in).getCompressedCount();
+        } else if (current.entry.getMethod() == ZipMethod.BZIP2.getCode()) {
+            return ((BZip2CompressorInputStream) current.in).getCompressedCount();
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * @since 1.17
+     */
+    @Override
+    public long getUncompressedCount() {
+        return uncompressedCount;
+    }
+
+    /**
+     * Implementation of read for STORED entries.
+     */
+    private int readStored(final byte[] buffer, final int offset, final int length) throws IOException {
+
+        if (current.hasDataDescriptor) {
+            if (lastStoredEntry == null) {
+                readStoredEntry();
+            }
+            return lastStoredEntry.read(buffer, offset, length);
+        }
+
+        final long csize = current.entry.getSize();
+        if (current.bytesRead >= csize) {
+            return -1;
+        }
+
+        if (buf.position() >= buf.limit()) {
+            buf.position(0);
+            final int l = in.read(buf.array());
+            if (l == -1) {
+                buf.limit(0);
+                throw new IOException("Truncated ZIP file");
+            }
+            buf.limit(l);
+
+            count(l);
+            current.bytesReadFromStream += l;
+        }
+
+        int toRead = Math.min(buf.remaining(), length);
+        if ((csize - current.bytesRead) < toRead) {
+            // if it is smaller than toRead then it fits into an int
+            toRead = (int) (csize - current.bytesRead);
+        }
+        buf.get(buffer, offset, toRead);
+        current.bytesRead += toRead;
+        return toRead;
+    }
+
+    /**
+     * Implementation of read for DEFLATED entries.
+     */
+    private int readDeflated(final byte[] buffer, final int offset, final int length) throws IOException {
+        final int read = readFromInflater(buffer, offset, length);
+        if (read <= 0) {
+            if (inf.finished()) {
+                return -1;
+            } else if (inf.needsDictionary()) {
+                throw new ZipException("This archive needs a preset dictionary"
+                                       + " which is not supported by Commons"
+                                       + " Compress.");
+            } else if (read == -1) {
+                throw new IOException("Truncated ZIP file");
+            }
+        }
+        return read;
+    }
+
+    /**
+     * Potentially reads more bytes to fill the inflater's buffer and
+     * reads from it.
+     */
+    private int readFromInflater(final byte[] buffer, final int offset, final int length) throws IOException {
+        int read = 0;
+        do {
+            if (inf.needsInput()) {
+                final int l = fill();
+                if (l > 0) {
+                    current.bytesReadFromStream += buf.limit();
+                } else if (l == -1) {
+                    return -1;
+                } else {
+                    break;
+                }
+            }
+            try {
+                read = inf.inflate(buffer, offset, length);
+            } catch (final DataFormatException e) {
+                throw (IOException) new ZipException(e.getMessage()).initCause(e);
+            }
+        } while (read == 0 && inf.needsInput());
+        return read;
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (!closed) {
+            closed = true;
+            try {
+                in.close();
+            } finally {
+                inf.end();
+            }
+        }
+    }
+
+    /**
+     * Skips over and discards value bytes of data from this input
+     * stream.
+     *
+     * <p>This implementation may end up skipping over some smaller
+     * number of bytes, possibly 0, if and only if it reaches the end
+     * of the underlying stream.</p>
+     *
+     * <p>The actual number of bytes skipped is returned.</p>
+     *
+     * @param value the number of bytes to be skipped.
+     * @return the actual number of bytes skipped.
+     * @throws IOException - if an I/O error occurs.
+     * @throws IllegalArgumentException - if value is negative.
+     */
+    @Override
+    public long skip(final long value) throws IOException {
+        if (value >= 0) {
+            long skipped = 0;
+            while (skipped < value) {
+                final long rem = value - skipped;
+                final int x = read(skipBuf, 0, (int) (skipBuf.length > rem ? rem : skipBuf.length));
+                if (x == -1) {
+                    return skipped;
+                }
+                skipped += x;
+            }
+            return skipped;
+        }
+        throw new IllegalArgumentException();
+    }
+
+    /**
+     * Checks if the signature matches what is expected for a zip file.
+     * Does not currently handle self-extracting zips which may have arbitrary
+     * leading content.
+     *
+     * @param signature the bytes to check
+     * @param length    the number of bytes to check
+     * @return true, if this stream is a zip archive stream, false otherwise
+     */
+    public static boolean matches(final byte[] signature, final int length) {
+        if (length < ZipArchiveOutputStream.LFH_SIG.length) {
+            return false;
+        }
+
+        return checksig(signature, ZipArchiveOutputStream.LFH_SIG) // normal file
+            || checksig(signature, ZipArchiveOutputStream.EOCD_SIG) // empty zip
+            || checksig(signature, ZipArchiveOutputStream.DD_SIG) // split zip
+            || checksig(signature, ZipLong.SINGLE_SEGMENT_SPLIT_MARKER.getBytes());
+    }
+
+    private static boolean checksig(final byte[] signature, final byte[] expected) {
+        for (int i = 0; i < expected.length; i++) {
+            if (signature[i] != expected[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Closes the current ZIP archive entry and positions the underlying
+     * stream to the beginning of the next entry. All per-entry variables
+     * and data structures are cleared.
+     * <p>
+     * If the compressed size of this entry is included in the entry header,
+     * then any outstanding bytes are simply skipped from the underlying
+     * stream without uncompressing them. This allows an entry to be safely
+     * closed even if the compression method is unsupported.
+     * <p>
+     * In case we don't know the compressed size of this entry or have
+     * already buffered too much data from the underlying stream to support
+     * uncompression, then the uncompression process is completed and the
+     * end position of the stream is adjusted based on the result of that
+     * process.
+     *
+     * @throws IOException if an error occurs
+     */
+    private void closeEntry() throws IOException {
+        if (closed) {
+            throw new IOException("The stream is closed");
+        }
+        if (current == null) {
+            return;
+        }
+
+        // Ensure all entry bytes are read
+        if (currentEntryHasOutstandingBytes()) {
+            drainCurrentEntryData();
+        } else {
+            // this is guaranteed to exhaust the stream
+            skip(Long.MAX_VALUE); //NOSONAR
+
+            final long inB = current.entry.getMethod() == ZipArchiveOutputStream.DEFLATED
+                       ? getBytesInflated() : current.bytesRead;
+
+            // this is at most a single read() operation and can't
+            // exceed the range of int
+            final int diff = (int) (current.bytesReadFromStream - inB);
+
+            // Pushback any required bytes
+            if (diff > 0) {
+                pushback(buf.array(), buf.limit() - diff, diff);
+                current.bytesReadFromStream -= diff;
+            }
+
+            // Drain remainder of entry if not all data bytes were required
+            if (currentEntryHasOutstandingBytes()) {
+                drainCurrentEntryData();
+            }
+        }
+
+        if (lastStoredEntry == null && current.hasDataDescriptor) {
+            readDataDescriptor();
+        }
+
+        inf.reset();
+        buf.clear().flip();
+        current = null;
+        lastStoredEntry = null;
+    }
+
+    /**
+     * If the compressed size of the current entry is included in the entry header
+     * and there are any outstanding bytes in the underlying stream, then
+     * this returns true.
+     *
+     * @return true, if current entry is determined to have outstanding bytes, false otherwise
+     */
+    private boolean currentEntryHasOutstandingBytes() {
+        return current.bytesReadFromStream <= current.entry.getCompressedSize()
+                && !current.hasDataDescriptor;
+    }
+
+    /**
+     * Read all data of the current entry from the underlying stream
+     * that hasn't been read, yet.
+     */
+    private void drainCurrentEntryData() throws IOException {
+        long remaining = current.entry.getCompressedSize() - current.bytesReadFromStream;
+        while (remaining > 0) {
+            final long n = in.read(buf.array(), 0, (int) Math.min(buf.capacity(), remaining));
+            if (n < 0) {
+                throw new EOFException("Truncated ZIP entry: "
+                                       + ArchiveUtils.sanitize(current.entry.getName()));
+            }
+            count(n);
+            remaining -= n;
+        }
+    }
+
+    /**
+     * Get the number of bytes Inflater has actually processed.
+     *
+     * <p>for Java &lt; Java7 the getBytes* methods in
+     * Inflater/Deflater seem to return unsigned ints rather than
+     * longs that start over with 0 at 2^32.</p>
+     *
+     * <p>The stream knows how many bytes it has read, but not how
+     * many the Inflater actually consumed - it should be between the
+     * total number of bytes read for the entry and the total number
+     * minus the last read operation.  Here we just try to make the
+     * value close enough to the bytes we've read by assuming the
+     * number of bytes consumed must be smaller than (or equal to) the
+     * number of bytes read but not smaller by more than 2^32.</p>
+     */
+    private long getBytesInflated() {
+        long inB = inf.getBytesRead();
+        if (current.bytesReadFromStream >= TWO_EXP_32) {
+            while (inB + TWO_EXP_32 <= current.bytesReadFromStream) {
+                inB += TWO_EXP_32;
+            }
+        }
+        return inB;
+    }
+
+    private int fill() throws IOException {
+        if (closed) {
+            throw new IOException("The stream is closed");
+        }
+        final int length = in.read(buf.array());
+        if (length > 0) {
+            buf.limit(length);
+            count(buf.limit());
+            inf.setInput(buf.array(), 0, buf.limit());
+        }
+        return length;
+    }
+
+    private void readFully(final byte[] b) throws IOException {
+        readFully(b, 0);
+    }
+
+    private void readFully(final byte[] b, final int off) throws IOException {
+        final int len = b.length - off;
+        final int count = IOUtils.readFully(in, b, off, len);
+        count(count);
+        if (count < len) {
+            throw new EOFException();
+        }
+    }
+
+    private void readDataDescriptor() throws IOException {
+        readFully(wordBuf);
+        ZipLong val = new ZipLong(wordBuf);
+        if (ZipLong.DD_SIG.equals(val)) {
+            // data descriptor with signature, skip sig
+            readFully(wordBuf);
+            val = new ZipLong(wordBuf);
+        }
+        current.entry.setCrc(val.getValue());
+
+        // if there is a ZIP64 extra field, sizes are eight bytes
+        // each, otherwise four bytes each.  Unfortunately some
+        // implementations - namely Java7 - use eight bytes without
+        // using a ZIP64 extra field -
+        // https://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7073588
+
+        // just read 16 bytes and check whether bytes nine to twelve
+        // look like one of the signatures of what could follow a data
+        // descriptor (ignoring archive decryption headers for now).
+        // If so, push back eight bytes and assume sizes are four
+        // bytes, otherwise sizes are eight bytes each.
+        readFully(twoDwordBuf);
+        final ZipLong potentialSig = new ZipLong(twoDwordBuf, DWORD);
+        if (potentialSig.equals(ZipLong.CFH_SIG) || potentialSig.equals(ZipLong.LFH_SIG)) {
+            pushback(twoDwordBuf, DWORD, DWORD);
+            current.entry.setCompressedSize(ZipLong.getValue(twoDwordBuf));
+            current.entry.setSize(ZipLong.getValue(twoDwordBuf, WORD));
+        } else {
+            current.entry.setCompressedSize(ZipEightByteInteger.getLongValue(twoDwordBuf));
+            current.entry.setSize(ZipEightByteInteger.getLongValue(twoDwordBuf, DWORD));
+        }
+    }
+
+    /**
+     * Whether this entry requires a data descriptor this library can work with.
+     *
+     * @return true if allowStoredEntriesWithDataDescriptor is true,
+     * the entry doesn't require any data descriptor or the method is
+     * DEFLATED or ENHANCED_DEFLATED.
+     */
+    private boolean supportsDataDescriptorFor(final ZipArchiveEntry entry) {
+        return !entry.getGeneralPurposeBit().usesDataDescriptor()
+
+                || (allowStoredEntriesWithDataDescriptor && entry.getMethod() == ZipEntry.STORED)
+                || entry.getMethod() == ZipEntry.DEFLATED
+                || entry.getMethod() == ZipMethod.ENHANCED_DEFLATED.getCode();
+    }
+
+    /**
+     * Whether the compressed size for the entry is either known or
+     * not required by the compression method being used.
+     */
+    private boolean supportsCompressedSizeFor(final ZipArchiveEntry entry) {
+        return entry.getCompressedSize() != ArchiveEntry.SIZE_UNKNOWN
+            || entry.getMethod() == ZipEntry.DEFLATED
+            || entry.getMethod() == ZipMethod.ENHANCED_DEFLATED.getCode()
+            || (entry.getGeneralPurposeBit().usesDataDescriptor()
+                && allowStoredEntriesWithDataDescriptor
+                && entry.getMethod() == ZipEntry.STORED);
+    }
+
+    private static final String USE_ZIPFILE_INSTEAD_OF_STREAM_DISCLAIMER =
+        " while reading a stored entry using data descriptor. Either the archive is broken"
+        + " or it can not be read using ZipArchiveInputStream and you must use ZipFile."
+        + " A common cause for this is a ZIP archive containing a ZIP archive."
+        + " See http://commons.apache.org/proper/commons-compress/zip.html#ZipArchiveInputStream_vs_ZipFile";
+
+    /**
+     * Caches a stored entry that uses the data descriptor.
+     *
+     * <ul>
+     *   <li>Reads a stored entry until the signature of a local file
+     *     header, central directory header or data descriptor has been
+     *     found.</li>
+     *   <li>Stores all entry data in lastStoredEntry.</p>
+     *   <li>Rewinds the stream to position at the data
+     *     descriptor.</li>
+     *   <li>reads the data descriptor</li>
+     * </ul>
+     *
+     * <p>After calling this method the entry should know its size,
+     * the entry's data is cached and the stream is positioned at the
+     * next local file or central directory header.</p>
+     */
+    private void readStoredEntry() throws IOException {
+        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        int off = 0;
+        boolean done = false;
+
+        // length of DD without signature
+        final int ddLen = current.usesZip64 ? WORD + 2 * DWORD : 3 * WORD;
+
+        while (!done) {
+            final int r = in.read(buf.array(), off, ZipArchiveOutputStream.BUFFER_SIZE - off);
+            if (r <= 0) {
+                // read the whole archive without ever finding a
+                // central directory
+                throw new IOException("Truncated ZIP file");
+            }
+            if (r + off < 4) {
+                // buffer too small to check for a signature, loop
+                off += r;
+                continue;
+            }
+
+            done = bufferContainsSignature(bos, off, r, ddLen);
+            if (!done) {
+                off = cacheBytesRead(bos, off, r, ddLen);
+            }
+        }
+        if (current.entry.getCompressedSize() != current.entry.getSize()) {
+            throw new ZipException("compressed and uncompressed size don't match"
+                                   + USE_ZIPFILE_INSTEAD_OF_STREAM_DISCLAIMER);
+        }
+        final byte[] b = bos.toByteArray();
+        if (b.length != current.entry.getSize()) {
+            throw new ZipException("actual and claimed size don't match"
+                                   + USE_ZIPFILE_INSTEAD_OF_STREAM_DISCLAIMER);
+        }
+        lastStoredEntry = new ByteArrayInputStream(b);
+    }
+
+    private static final byte[] LFH = ZipLong.LFH_SIG.getBytes();
+    private static final byte[] CFH = ZipLong.CFH_SIG.getBytes();
+    private static final byte[] DD = ZipLong.DD_SIG.getBytes();
+
+    /**
+     * Checks whether the current buffer contains the signature of a
+     * &quot;data descriptor&quot;, &quot;local file header&quot; or
+     * &quot;central directory entry&quot;.
+     *
+     * <p>If it contains such a signature, reads the data descriptor
+     * and positions the stream right after the data descriptor.</p>
+     */
+    private boolean bufferContainsSignature(final ByteArrayOutputStream bos, final int offset, final int lastRead, final int expectedDDLen)
+            throws IOException {
+
+        boolean done = false;
+        for (int i = 0; !done && i < offset + lastRead - 4; i++) {
+            if (buf.array()[i] == LFH[0] && buf.array()[i + 1] == LFH[1]) {
+                int expectDDPos = i;
+                if (i >= expectedDDLen &&
+                    (buf.array()[i + 2] == LFH[2] && buf.array()[i + 3] == LFH[3])
+                    || (buf.array()[i] == CFH[2] && buf.array()[i + 3] == CFH[3])) {
+                    // found a LFH or CFH:
+                    expectDDPos = i - expectedDDLen;
+                    done = true;
+                }
+                else if (buf.array()[i + 2] == DD[2] && buf.array()[i + 3] == DD[3]) {
+                    // found DD:
+                    done = true;
+                }
+                if (done) {
+                    // * push back bytes read in excess as well as the data
+                    //   descriptor
+                    // * copy the remaining bytes to cache
+                    // * read data descriptor
+                    pushback(buf.array(), expectDDPos, offset + lastRead - expectDDPos);
+                    bos.write(buf.array(), 0, expectDDPos);
+                    readDataDescriptor();
+                }
+            }
+        }
+        return done;
+    }
+
+    /**
+     * If the last read bytes could hold a data descriptor and an
+     * incomplete signature then save the last bytes to the front of
+     * the buffer and cache everything in front of the potential data
+     * descriptor into the given ByteArrayOutputStream.
+     *
+     * <p>Data descriptor plus incomplete signature (3 bytes in the
+     * worst case) can be 20 bytes max.</p>
+     */
+    private int cacheBytesRead(final ByteArrayOutputStream bos, int offset, final int lastRead, final int expecteDDLen) {
+        final int cacheable = offset + lastRead - expecteDDLen - 3;
+        if (cacheable > 0) {
+            bos.write(buf.array(), 0, cacheable);
+            System.arraycopy(buf.array(), cacheable, buf.array(), 0, expecteDDLen + 3);
+            offset = expecteDDLen + 3;
+        } else {
+            offset += lastRead;
+        }
+        return offset;
+    }
+
+    private void pushback(final byte[] buf, final int offset, final int length) throws IOException {
+        ((PushbackInputStream) in).unread(buf, offset, length);
+        pushedBackBytes(length);
+    }
+
+    // End of Central Directory Record
+    //   end of central dir signature    WORD
+    //   number of this disk             SHORT
+    //   number of the disk with the
+    //   start of the central directory  SHORT
+    //   total number of entries in the
+    //   central directory on this disk  SHORT
+    //   total number of entries in
+    //   the central directory           SHORT
+    //   size of the central directory   WORD
+    //   offset of start of central
+    //   directory with respect to
+    //   the starting disk number        WORD
+    //   .ZIP file comment length        SHORT
+    //   .ZIP file comment               up to 64KB
+    //
+
+    /**
+     * Reads the stream until it find the "End of central directory
+     * record" and consumes it as well.
+     */
+    private void skipRemainderOfArchive() throws IOException {
+        // skip over central directory. One LFH has been read too much
+        // already.  The calculation discounts file names and extra
+        // data so it will be too short.
+        realSkip((long) entriesRead * CFH_LEN - LFH_LEN);
+        findEocdRecord();
+        realSkip((long) ZipFile.MIN_EOCD_SIZE - WORD /* signature */ - SHORT /* comment len */);
+        readFully(shortBuf);
+        // file comment
+        realSkip(ZipShort.getValue(shortBuf));
+    }
+
+    /**
+     * Reads forward until the signature of the &quot;End of central
+     * directory&quot; record is found.
+     */
+    private void findEocdRecord() throws IOException {
+        int currentByte = -1;
+        boolean skipReadCall = false;
+        while (skipReadCall || (currentByte = readOneByte()) > -1) {
+            skipReadCall = false;
+            if (!isFirstByteOfEocdSig(currentByte)) {
+                continue;
+            }
+            currentByte = readOneByte();
+            if (currentByte != ZipArchiveOutputStream.EOCD_SIG[1]) {
+                if (currentByte == -1) {
+                    break;
+                }
+                skipReadCall = isFirstByteOfEocdSig(currentByte);
+                continue;
+            }
+            currentByte = readOneByte();
+            if (currentByte != ZipArchiveOutputStream.EOCD_SIG[2]) {
+                if (currentByte == -1) {
+                    break;
+                }
+                skipReadCall = isFirstByteOfEocdSig(currentByte);
+                continue;
+            }
+            currentByte = readOneByte();
+            if (currentByte == -1
+                || currentByte == ZipArchiveOutputStream.EOCD_SIG[3]) {
+                break;
+            }
+            skipReadCall = isFirstByteOfEocdSig(currentByte);
+        }
+    }
+
+    /**
+     * Skips bytes by reading from the underlying stream rather than
+     * the (potentially inflating) archive stream - which {@link
+     * #skip} would do.
+     *
+     * Also updates bytes-read counter.
+     */
+    private void realSkip(final long value) throws IOException {
+        if (value >= 0) {
+            long skipped = 0;
+            while (skipped < value) {
+                final long rem = value - skipped;
+                final int x = in.read(skipBuf, 0, (int) (skipBuf.length > rem ? rem : skipBuf.length));
+                if (x == -1) {
+                    return;
+                }
+                count(x);
+                skipped += x;
+            }
+            return;
+        }
+        throw new IllegalArgumentException();
+    }
+
+    /**
+     * Reads bytes by reading from the underlying stream rather than
+     * the (potentially inflating) archive stream - which {@link #read} would do.
+     *
+     * Also updates bytes-read counter.
+     */
+    private int readOneByte() throws IOException {
+        final int b = in.read();
+        if (b != -1) {
+            count(1);
+        }
+        return b;
+    }
+
+    private boolean isFirstByteOfEocdSig(final int b) {
+        return b == ZipArchiveOutputStream.EOCD_SIG[0];
+    }
+
+    private static final byte[] APK_SIGNING_BLOCK_MAGIC = new byte[] {
+        'A', 'P', 'K', ' ', 'S', 'i', 'g', ' ', 'B', 'l', 'o', 'c', 'k', ' ', '4', '2',
+    };
+    private static final BigInteger LONG_MAX = BigInteger.valueOf(Long.MAX_VALUE);
+
+    /**
+     * Checks whether this might be an APK Signing Block.
+     *
+     * <p>Unfortunately the APK signing block does not start with some kind of signature, it rather ends with one. It
+     * starts with a length, so what we do is parse the suspect length, skip ahead far enough, look for the signature
+     * and if we've found it, return true.</p>
+     *
+     * @param suspectLocalFileHeader the bytes read from the underlying stream in the expectation that they would hold
+     * the local file header of the next entry.
+     *
+     * @return true if this looks like a APK signing block
+     *
+     * @see <a href="https://source.android.com/security/apksigning/v2">https://source.android.com/security/apksigning/v2</a>
+     */
+    private boolean isApkSigningBlock(byte[] suspectLocalFileHeader) throws IOException {
+        // length of block excluding the size field itself
+        BigInteger len = ZipEightByteInteger.getValue(suspectLocalFileHeader);
+        // LFH has already been read and all but the first eight bytes contain (part of) the APK signing block,
+        // also subtract 16 bytes in order to position us at the magic string
+        BigInteger toSkip = len.add(BigInteger.valueOf(DWORD - suspectLocalFileHeader.length
+            - (long) APK_SIGNING_BLOCK_MAGIC.length));
+        byte[] magic = new byte[APK_SIGNING_BLOCK_MAGIC.length];
+
+        try {
+            if (toSkip.signum() < 0) {
+                // suspectLocalFileHeader contains the start of suspect magic string
+                int off = suspectLocalFileHeader.length + toSkip.intValue();
+                // length was shorter than magic length
+                if (off < DWORD) {
+                    return false;
+                }
+                int bytesInBuffer = Math.abs(toSkip.intValue());
+                System.arraycopy(suspectLocalFileHeader, off, magic, 0, Math.min(bytesInBuffer, magic.length));
+                if (bytesInBuffer < magic.length) {
+                    readFully(magic, bytesInBuffer);
+                }
+            } else {
+                while (toSkip.compareTo(LONG_MAX) > 0) {
+                    realSkip(Long.MAX_VALUE);
+                    toSkip = toSkip.add(LONG_MAX.negate());
+                }
+                realSkip(toSkip.longValue());
+                readFully(magic);
+            }
+        } catch (EOFException ex) { //NOSONAR
+            // length was invalid
+            return false;
+        }
+        return Arrays.equals(magic, APK_SIGNING_BLOCK_MAGIC);
+    }
+
+    /**
+     * Structure collecting information for the entry that is
+     * currently being read.
+     */
+    private static final class CurrentEntry {
+
+        /**
+         * Current ZIP entry.
+         */
+        private final ZipArchiveEntry entry = new ZipArchiveEntry();
+
+        /**
+         * Does the entry use a data descriptor?
+         */
+        private boolean hasDataDescriptor;
+
+        /**
+         * Does the entry have a ZIP64 extended information extra field.
+         */
+        private boolean usesZip64;
+
+        /**
+         * Number of bytes of entry content read by the client if the
+         * entry is STORED.
+         */
+        private long bytesRead;
+
+        /**
+         * Number of bytes of entry content read from the stream.
+         *
+         * <p>This may be more than the actual entry's length as some
+         * stuff gets buffered up and needs to be pushed back when the
+         * end of the entry has been reached.</p>
+         */
+        private long bytesReadFromStream;
+
+        /**
+         * The checksum calculated as the current entry is read.
+         */
+        private final CRC32 crc = new CRC32();
+
+        /**
+         * The input stream decompressing the data for shrunk and imploded entries.
+         */
+        private InputStream in;
+    }
+
+    /**
+     * Bounded input stream adapted from commons-io
+     */
+    private class BoundedInputStream extends InputStream {
+
+        /** the wrapped input stream */
+        private final InputStream in;
+
+        /** the max length to provide */
+        private final long max;
+
+        /** the number of bytes already returned */
+        private long pos = 0;
+
+        /**
+         * Creates a new <code>BoundedInputStream</code> that wraps the given input
+         * stream and limits it to a certain size.
+         *
+         * @param in The wrapped input stream
+         * @param size The maximum number of bytes to return
+         */
+        public BoundedInputStream(final InputStream in, final long size) {
+            this.max = size;
+            this.in = in;
+        }
+
+        @Override
+        public int read() throws IOException {
+            if (max >= 0 && pos >= max) {
+                return -1;
+            }
+            final int result = in.read();
+            pos++;
+            count(1);
+            current.bytesReadFromStream++;
+            return result;
+        }
+
+        @Override
+        public int read(final byte[] b) throws IOException {
+            return this.read(b, 0, b.length);
+        }
+
+        @Override
+        public int read(final byte[] b, final int off, final int len) throws IOException {
+            if (len == 0) {
+                return 0;
+            }
+            if (max >= 0 && pos >= max) {
+                return -1;
+            }
+            final long maxRead = max >= 0 ? Math.min(len, max - pos) : len;
+            final int bytesRead = in.read(b, off, (int) maxRead);
+
+            if (bytesRead == -1) {
+                return -1;
+            }
+
+            pos += bytesRead;
+            count(bytesRead);
+            current.bytesReadFromStream += bytesRead;
+            return bytesRead;
+        }
+
+        @Override
+        public long skip(final long n) throws IOException {
+            final long toSkip = max >= 0 ? Math.min(n, max - pos) : n;
+            final long skippedBytes = IOUtils.skip(in, toSkip);
+            pos += skippedBytes;
+            return skippedBytes;
+        }
+
+        @Override
+        public int available() throws IOException {
+            if (max >= 0 && pos >= max) {
+                return 0;
+            }
+            return in.available();
+        }
+    }
+}

local-test-commons-compress-full-01-vuln_5/afc-commons-compress/src/test/resources/COMPRESS-477/split_zip_created_by_zip/file_to_compare_1

@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ * http://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.
+ */
+package org.apache.commons.compress.archivers.dump;
+
+
+/**
+ * Unsupported compression algorithm. The dump archive uses an unsupported
+ * compression algorithm (BZLIB2 or LZO).
+ */
+public class UnsupportedCompressionAlgorithmException
+    extends DumpArchiveException {
+    private static final long serialVersionUID = 1L;
+
+    public UnsupportedCompressionAlgorithmException() {
+        super("this file uses an unsupported compression algorithm.");
+    }
+
+    public UnsupportedCompressionAlgorithmException(final String alg) {
+        super("this file uses an unsupported compression algorithm: " + alg +
+            ".");
+    }
+}

local-test-commons-compress-full-01-vuln_5/afc-commons-compress/src/test/resources/COMPRESS-477/split_zip_created_by_zip/file_to_compare_2

@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ * http://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.
+ */
+
+package org.apache.commons.compress.compressors.deflate;
+
+import java.util.zip.Deflater;
+
+/**
+ * Parameters for the Deflate compressor.
+ * @since 1.9
+ */
+public class DeflateParameters {
+
+    private boolean zlibHeader = true;
+    private int compressionLevel = Deflater.DEFAULT_COMPRESSION;
+
+    /**
+     * Whether or not the zlib header shall be written (when
+     * compressing) or expected (when decompressing).
+     * @return true if zlib header shall be written
+     */
+    public boolean withZlibHeader() {
+        return zlibHeader;
+    }
+
+    /**
+     * Sets the zlib header presence parameter.
+     *
+     * <p>This affects whether or not the zlib header will be written
+     * (when compressing) or expected (when decompressing).</p>
+     *
+     * @param zlibHeader true if zlib header shall be written
+     */
+    public void setWithZlibHeader(final boolean zlibHeader) {
+        this.zlibHeader = zlibHeader;
+    }
+
+    /**
+     * The compression level.
+     * @see #setCompressionLevel
+     * @return the compression level
+     */
+    public int getCompressionLevel() {
+        return compressionLevel;
+    }
+
+    /**
+     * Sets the compression level.
+     *
+     * @param compressionLevel the compression level (between 0 and 9)
+     * @see Deflater#NO_COMPRESSION
+     * @see Deflater#BEST_SPEED
+     * @see Deflater#DEFAULT_COMPRESSION
+     * @see Deflater#BEST_COMPRESSION
+     */
+    public void setCompressionLevel(final int compressionLevel) {
+        if (compressionLevel < -1 || compressionLevel > 9) {
+            throw new IllegalArgumentException("Invalid Deflate compression level: " + compressionLevel);
+        }
+        this.compressionLevel = compressionLevel;
+    }
+
+}

local-test-commons-compress-full-01-vuln_5/afc-commons-compress/src/test/resources/org/apache/commons/compress/COMPRESS-661/testARofText.ar

@@ -0,0 +1,5 @@
+!<arch>
+testTXT.txt/    1262968202  500   500   100644  47        `
+Test d'indexation de Txt
+http://www.apache.org
+

local-test-commons-compress-full-01-vuln_5/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_length-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/0              1454693980  1000  1000  100664  1.23      `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-full-01-vuln_5/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_long_namelen_gnu1-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/9999999999     1454693980  1000  1000  100664  14        `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-full-01-vuln_5/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_long_namelen_gnu2-fail.ar

@@ -0,0 +1,6 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/29             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-full-01-vuln_5/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_modified-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/0              9e99999999  1000  1000  100664  14        `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-full-01-vuln_5/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_user-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/0              1454693980  9e99  1000  100664  14        `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/.dockerignore

@@ -0,0 +1,9 @@
+cifuzz/test_data/*
+
+# Copied from .gitignore.
+.vscode/
+*.pyc
+build
+*~
+.DS_Store
+*.swp

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/build_specified_commit.py

@@ -0,0 +1,410 @@
+# Copyright 2019 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Module to build a image from a specific commit, branch or pull request.
+
+This module is allows each of the OSS Fuzz projects fuzzers to be built
+from a specific point in time. This feature can be used for implementations
+like continuious integration fuzzing and bisection to find errors
+"""
+import argparse
+import bisect
+import datetime
+import os
+import collections
+import json
+import logging
+import re
+import shutil
+import tempfile
+
+import helper
+import repo_manager
+import retry
+import utils
+
+BuildData = collections.namedtuple(
+    'BuildData', ['project_name', 'engine', 'sanitizer', 'architecture'])
+
+_GIT_DIR_MARKER = 'gitdir: '
+_IMAGE_BUILD_TRIES = 3
+
+
+class BaseBuilderRepo:
+  """Repo of base-builder images."""
+
+  def __init__(self):
+    self.timestamps = []
+    self.digests = []
+
+  def add_digest(self, timestamp, digest):
+    """Add a digest."""
+    self.timestamps.append(timestamp)
+    self.digests.append(digest)
+
+  def find_digest(self, timestamp):
+    """Find the latest image before the given timestamp."""
+    index = bisect.bisect_right(self.timestamps, timestamp)
+    if index > 0:
+      return self.digests[index - 1]
+
+    logging.error('Failed to find suitable base-builder.')
+    return None
+
+
+def _replace_gitdir(src_dir, file_path):
+  """Replace gitdir with a relative path."""
+  with open(file_path) as handle:
+    lines = handle.readlines()
+
+  new_lines = []
+  for line in lines:
+    if line.startswith(_GIT_DIR_MARKER):
+      absolute_path = line[len(_GIT_DIR_MARKER):].strip()
+      if not os.path.isabs(absolute_path):
+        # Already relative.
+        return
+
+      current_dir = os.path.dirname(file_path)
+      # Rebase to /src rather than the host src dir.
+      base_dir = current_dir.replace(src_dir, '/src')
+      relative_path = os.path.relpath(absolute_path, base_dir)
+      logging.info('Replacing absolute submodule gitdir from %s to %s',
+                   absolute_path, relative_path)
+
+      line = _GIT_DIR_MARKER + relative_path
+
+    new_lines.append(line)
+
+  with open(file_path, 'w') as handle:
+    handle.write(''.join(new_lines))
+
+
+def _make_gitdirs_relative(src_dir):
+  """Make gitdirs relative."""
+  for root_dir, _, files in os.walk(src_dir):
+    for filename in files:
+      if filename != '.git':
+        continue
+
+      file_path = os.path.join(root_dir, filename)
+      _replace_gitdir(src_dir, file_path)
+
+
+def _replace_base_builder_digest(dockerfile_path, digest):
+  """Replace the base-builder digest in a Dockerfile."""
+  with open(dockerfile_path) as handle:
+    lines = handle.readlines()
+
+  new_lines = []
+  for line in lines:
+    if line.strip().startswith('FROM'):
+      line = 'FROM ghcr.io/aixcc-finals/base-builder@' + digest + '\n'
+
+    new_lines.append(line)
+
+  with open(dockerfile_path, 'w') as handle:
+    handle.write(''.join(new_lines))
+
+
+def copy_src_from_docker(project_name, host_dir):
+  """Copy /src from docker to the host."""
+  # Copy /src to host.
+  image_name = 'gcr.io/oss-fuzz/' + project_name
+  src_dir = os.path.join(host_dir, 'src')
+  if os.path.exists(src_dir):
+    shutil.rmtree(src_dir, ignore_errors=True)
+
+  docker_args = [
+      '-v',
+      host_dir + ':/out',
+      image_name,
+      'cp',
+      '-r',
+      '-p',
+      '/src',
+      '/out',
+  ]
+  helper.docker_run(docker_args)
+
+  # Submodules can have gitdir entries which point to absolute paths. Make them
+  # relative, as otherwise we can't do operations on the checkout on the host.
+  _make_gitdirs_relative(src_dir)
+  return src_dir
+
+
+@retry.wrap(_IMAGE_BUILD_TRIES, 2)
+def _build_image_with_retries(project_name):
+  """Build image with retries."""
+  return helper.build_image_impl(helper.Project(project_name))
+
+
+def get_required_post_checkout_steps(dockerfile_path):
+  """Get required post checkout steps (best effort)."""
+
+  checkout_pattern = re.compile(r'\s*RUN\s*(git|svn|hg)')
+
+  # If the build.sh is copied from upstream, we need to copy it again after
+  # changing the revision to ensure correct building.
+  post_run_pattern = re.compile(r'\s*RUN\s*(.*build\.sh.*(\$SRC|/src).*)')
+
+  with open(dockerfile_path) as handle:
+    lines = handle.readlines()
+
+  subsequent_run_cmds = []
+  for i, line in enumerate(lines):
+    if checkout_pattern.match(line):
+      subsequent_run_cmds = []
+      continue
+
+    match = post_run_pattern.match(line)
+    if match:
+      workdir = helper.workdir_from_lines(lines[:i])
+      command = match.group(1)
+      subsequent_run_cmds.append((workdir, command))
+
+  return subsequent_run_cmds
+
+
+# pylint: disable=too-many-locals
+def build_fuzzers_from_commit(commit,
+                              build_repo_manager,
+                              host_src_path,
+                              build_data,
+                              base_builder_repo=None):
+  """Builds a OSS-Fuzz fuzzer at a specific commit SHA.
+
+  Args:
+    commit: The commit SHA to build the fuzzers at.
+    build_repo_manager: The OSS-Fuzz project's repo manager to be built at.
+    build_data: A struct containing project build information.
+    base_builder_repo: A BaseBuilderRepo.
+  Returns:
+    0 on successful build or error code on failure.
+  """
+  oss_fuzz_repo_manager = repo_manager.RepoManager(helper.OSS_FUZZ_DIR)
+  num_retry = 1
+
+  def cleanup():
+    # Re-copy /src for a clean checkout every time.
+    copy_src_from_docker(build_data.project_name,
+                         os.path.dirname(host_src_path))
+    build_repo_manager.fetch_all_remotes()
+
+  projects_dir = os.path.join('projects', build_data.project_name)
+  dockerfile_path = os.path.join(projects_dir, 'Dockerfile')
+
+  for i in range(num_retry + 1):
+    build_repo_manager.checkout_commit(commit, clean=False)
+
+    post_checkout_steps = get_required_post_checkout_steps(dockerfile_path)
+    for workdir, post_checkout_step in post_checkout_steps:
+      logging.info('Running post-checkout step `%s` in %s.', post_checkout_step,
+                   workdir)
+      helper.docker_run([
+          '-w',
+          workdir,
+          '-v',
+          host_src_path + ':' + '/src',
+          'gcr.io/oss-fuzz/' + build_data.project_name,
+          '/bin/bash',
+          '-c',
+          post_checkout_step,
+      ])
+
+    project = helper.Project(build_data.project_name)
+    result = helper.build_fuzzers_impl(project=project,
+                                       clean=True,
+                                       engine=build_data.engine,
+                                       sanitizer=build_data.sanitizer,
+                                       architecture=build_data.architecture,
+                                       env_to_add=None,
+                                       source_path=host_src_path,
+                                       mount_path='/src')
+    if result or i == num_retry:
+      break
+
+    # Retry with an OSS-Fuzz builder container that's closer to the project
+    # commit date.
+    commit_date = build_repo_manager.commit_date(commit)
+
+    # Find first change in the projects/<PROJECT> directory before the project
+    # commit date.
+    oss_fuzz_commit, _, _ = oss_fuzz_repo_manager.git([
+        'log', '--before=' + commit_date.isoformat(), '-n1', '--format=%H',
+        projects_dir
+    ],
+                                                      check_result=True)
+    oss_fuzz_commit = oss_fuzz_commit.strip()
+    if not oss_fuzz_commit:
+      logging.info(
+          'Could not find first OSS-Fuzz commit prior to upstream commit. '
+          'Falling back to oldest integration commit.')
+
+      # Find the oldest commit.
+      oss_fuzz_commit, _, _ = oss_fuzz_repo_manager.git(
+          ['log', '--reverse', '--format=%H', projects_dir], check_result=True)
+
+      oss_fuzz_commit = oss_fuzz_commit.splitlines()[0].strip()
+
+    if not oss_fuzz_commit:
+      logging.error('Failed to get oldest integration commit.')
+      break
+
+    logging.info('Build failed. Retrying on earlier OSS-Fuzz commit %s.',
+                 oss_fuzz_commit)
+
+    # Check out projects/<PROJECT> dir to the commit that was found.
+    oss_fuzz_repo_manager.git(['checkout', oss_fuzz_commit, projects_dir],
+                              check_result=True)
+
+    # Also use the closest base-builder we can find.
+    if base_builder_repo:
+      base_builder_digest = base_builder_repo.find_digest(commit_date)
+      if not base_builder_digest:
+        return False
+
+      logging.info('Using base-builder with digest %s.', base_builder_digest)
+      _replace_base_builder_digest(dockerfile_path, base_builder_digest)
+
+    # Rebuild image and re-copy src dir since things in /src could have changed.
+    if not _build_image_with_retries(build_data.project_name):
+      logging.error('Failed to rebuild image.')
+      return False
+
+    cleanup()
+
+  cleanup()
+  return result
+
+
+def detect_main_repo(project_name, repo_name=None, commit=None):
+  """Checks a docker image for the main repo of an OSS-Fuzz project.
+
+  Note: The default is to use the repo name to detect the main repo.
+
+  Args:
+    project_name: The name of the oss-fuzz project.
+    repo_name: The name of the main repo in an OSS-Fuzz project.
+    commit: A commit SHA that is associated with the main repo.
+
+  Returns:
+    A tuple containing (the repo's origin, the repo's path).
+  """
+
+  if not repo_name and not commit:
+    logging.error(
+        'Error: can not detect main repo without a repo_name or a commit.')
+    return None, None
+  if repo_name and commit:
+    logging.info(
+        'Both repo name and commit specific. Using repo name for detection.')
+
+  # Change to oss-fuzz main directory so helper.py runs correctly.
+  utils.chdir_to_root()
+  if not _build_image_with_retries(project_name):
+    logging.error('Error: building %s image failed.', project_name)
+    return None, None
+  docker_image_name = 'gcr.io/oss-fuzz/' + project_name
+  command_to_run = [
+      'docker', 'run', '--rm', '-t', docker_image_name, 'python3',
+      os.path.join('/opt', 'cifuzz', 'detect_repo.py')
+  ]
+  if repo_name:
+    command_to_run.extend(['--repo_name', repo_name])
+  else:
+    command_to_run.extend(['--example_commit', commit])
+  out, _, _ = utils.execute(command_to_run)
+  match = re.search(r'\bDetected repo: ([^ ]+) ([^ ]+)', out.rstrip())
+  if match and match.group(1) and match.group(2):
+    return match.group(1), match.group(2)
+
+  logging.error('Failed to detect repo:\n%s', out)
+  return None, None
+
+
+def load_base_builder_repo():
+  """Get base-image digests."""
+  gcloud_path = shutil.which('gcloud')
+  if not gcloud_path:
+    logging.warning('gcloud not found in PATH.')
+    return None
+
+  result, _, _ = utils.execute([
+      gcloud_path,
+      'container',
+      'images',
+      'list-tags',
+      'ghcr.io/aixcc-finals/base-builder',
+      '--format=json',
+      '--sort-by=timestamp',
+  ],
+                               check_result=True)
+  result = json.loads(result)
+
+  repo = BaseBuilderRepo()
+  for image in result:
+    timestamp = datetime.datetime.fromisoformat(
+        image['timestamp']['datetime']).astimezone(datetime.timezone.utc)
+    repo.add_digest(timestamp, image['digest'])
+
+  return repo
+
+
+def main():
+  """Main function."""
+  logging.getLogger().setLevel(logging.INFO)
+
+  parser = argparse.ArgumentParser(
+      description='Build fuzzers at a specific commit')
+  parser.add_argument('--project_name',
+                      help='The name of the project where the bug occurred.',
+                      required=True)
+  parser.add_argument('--commit',
+                      help='The newest commit SHA to be bisected.',
+                      required=True)
+  parser.add_argument('--engine',
+                      help='The default is "libfuzzer".',
+                      default='libfuzzer')
+  parser.add_argument('--sanitizer',
+                      default='address',
+                      help='The default is "address".')
+  parser.add_argument('--architecture', default='x86_64')
+
+  args = parser.parse_args()
+
+  repo_url, repo_path = detect_main_repo(args.project_name, commit=args.commit)
+
+  if not repo_url or not repo_path:
+    raise ValueError('Main git repo can not be determined.')
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    host_src_dir = copy_src_from_docker(args.project_name, tmp_dir)
+    build_repo_manager = repo_manager.RepoManager(
+        os.path.join(host_src_dir, os.path.basename(repo_path)))
+    base_builder_repo = load_base_builder_repo()
+
+    build_data = BuildData(project_name=args.project_name,
+                           engine=args.engine,
+                           sanitizer=args.sanitizer,
+                           architecture=args.architecture)
+    if not build_fuzzers_from_commit(args.commit,
+                                     build_repo_manager,
+                                     host_src_dir,
+                                     build_data,
+                                     base_builder_repo=base_builder_repo):
+      raise RuntimeError('Failed to build.')
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/config_utils.py

@@ -0,0 +1,283 @@
+# Copyright 2021 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Module for getting the configuration CIFuzz needs to run."""
+
+import enum
+import importlib
+import logging
+import os
+import sys
+
+import environment
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import platform_config
+import constants
+
+SANITIZERS = ['address', 'memory', 'undefined', 'coverage']
+
+# TODO(metzman): Set these on config objects so there's one source of truth.
+DEFAULT_ENGINE = 'libfuzzer'
+
+# This module deals a lot with env variables. Many of these will be set by users
+# and others beyond CIFuzz's control. Thus, you should be careful about using
+# the environment.py helpers for getting env vars, since it can cause values
+# that should be interpreted as strings to be returned as other types (bools or
+# ints for example). The environment.py helpers should not be used for values
+# that are supposed to be strings.
+
+
+def _get_sanitizer():
+  return os.getenv('SANITIZER', constants.DEFAULT_SANITIZER).lower()
+
+
+def _get_architecture():
+  return os.getenv('ARCHITECTURE', constants.DEFAULT_ARCHITECTURE).lower()
+
+
+def _is_dry_run():
+  """Returns True if configured to do a dry run."""
+  return environment.get_bool('DRY_RUN', False)
+
+
+def _get_language():
+  """Returns the project language."""
+  # Get language from environment. We took this approach because the convenience
+  # given to OSS-Fuzz users by not making them specify the language again (and
+  # getting it from the project.yaml) is outweighed by the complexity in
+  # implementing this. A lot of the complexity comes from our unittests not
+  # setting a proper projet at this point.
+  return os.getenv('LANGUAGE', constants.DEFAULT_LANGUAGE)
+
+
+def _get_extra_environment_variables():
+  """Gets extra environment variables specified by the user with
+  CFL_EXTRA_$NAME=$VALUE."""
+  return [key for key in os.environ if key.startswith('CFL_EXTRA_')]
+
+
+# pylint: disable=too-many-instance-attributes
+
+
+class ConfigError(Exception):
+  """Error for invalid configuration."""
+
+
+class BaseConfig:
+  """Object containing constant configuration for CIFuzz."""
+
+  class Platform(enum.Enum):
+    """Enum representing the different platforms CIFuzz runs on."""
+    EXTERNAL_GITHUB = 0  # Non-OSS-Fuzz on GitHub actions.
+    INTERNAL_GITHUB = 1  # OSS-Fuzz on GitHub actions.
+    INTERNAL_GENERIC_CI = 2  # OSS-Fuzz on any CI.
+    EXTERNAL_GENERIC_CI = 3  # Non-OSS-Fuzz on any CI.
+
+  @property
+  def is_github(self):
+    """Returns True if running on GitHub."""
+    return self.cfl_platform == 'github'
+
+  def __init__(self):
+    # Need to set these before calling self.platform.
+    self.oss_fuzz_project_name = os.getenv('OSS_FUZZ_PROJECT_NAME')
+    self.cfl_platform = os.getenv('CFL_PLATFORM')
+    logging.debug('Is github: %s.', self.is_github)
+
+    self.platform_conf = _get_platform_config(self.cfl_platform)
+    self.base_commit = self.platform_conf.base_commit
+    self.base_ref = self.platform_conf.base_ref
+    self.pr_ref = self.platform_conf.pr_ref
+    self.workspace = self.platform_conf.workspace
+    self.project_src_path = self.platform_conf.project_src_path
+    self.actor = self.platform_conf.actor
+    self.token = self.platform_conf.token
+    self.project_repo_owner = self.platform_conf.project_repo_owner
+    self.project_repo_name = self.platform_conf.project_repo_name
+    self.filestore = self.platform_conf.filestore
+
+    # This determines if builds are done using docker in docker
+    # rather than the normal method which is sibling containers.
+    self.docker_in_docker = self.platform_conf.docker_in_docker
+
+    self.dry_run = _is_dry_run()  # Check if failures should not be reported.
+    self.sanitizer = _get_sanitizer()
+    self.architecture = _get_architecture()
+    self.language = _get_language()
+    self.low_disk_space = environment.get_bool('LOW_DISK_SPACE', False)
+
+    self.git_store_repo = os.environ.get('GIT_STORE_REPO')
+    self.git_store_branch = os.environ.get('GIT_STORE_BRANCH')
+    self.git_store_branch_coverage = os.environ.get('GIT_STORE_BRANCH_COVERAGE',
+                                                    self.git_store_branch)
+    self.cloud_bucket = os.environ.get('CLOUD_BUCKET')
+    self.no_clusterfuzz_deployment = environment.get_bool(
+        'NO_CLUSTERFUZZ_DEPLOYMENT', False)
+    self.build_integration_path = (
+        constants.DEFAULT_EXTERNAL_BUILD_INTEGRATION_PATH)
+
+    self.parallel_fuzzing = environment.get_bool('PARALLEL_FUZZING', False)
+    self.extra_environment_variables = _get_extra_environment_variables()
+    self.output_sarif = environment.get_bool('OUTPUT_SARIF', False)
+
+    # TODO(metzman): Fix tests to create valid configurations and get rid of
+    # CIFUZZ_TEST here and in presubmit.py.
+    if not os.getenv('CIFUZZ_TEST') and not self.validate():
+      raise ConfigError('Invalid Configuration.')
+
+  def validate(self):
+    """Returns False if the configuration is invalid."""
+    # Do validation here so that unittests don't need to make a fully-valid
+    # config.
+    # pylint: disable=too-many-return-statements
+    if not self.workspace:
+      logging.error('Must set WORKSPACE.')
+      return False
+
+    if self.sanitizer not in SANITIZERS:
+      logging.error('Invalid SANITIZER: %s. Must be one of: %s.',
+                    self.sanitizer, SANITIZERS)
+      return False
+
+    if self.architecture not in constants.ARCHITECTURES:
+      logging.error('Invalid ARCHITECTURE: %s. Must be one of: %s.',
+                    self.architecture, constants.ARCHITECTURES)
+      return False
+
+    if self.architecture == 'i386' and self.sanitizer != 'address':
+      logging.error(
+          'ARCHITECTURE=i386 can be used with SANITIZER=address only.')
+      return False
+
+    if self.language not in constants.LANGUAGES:
+      logging.error('Invalid LANGUAGE: %s. Must be one of: %s.', self.language,
+                    constants.LANGUAGES)
+      return False
+
+    if not self.project_repo_name:
+      logging.error('Must set REPOSITORY.')
+      return False
+
+    return True
+
+  @property
+  def is_internal(self):
+    """Returns True if this is an OSS-Fuzz project."""
+    return bool(self.oss_fuzz_project_name)
+
+  @property
+  def platform(self):
+    """Returns the platform CIFuzz is runnning on."""
+    if not self.is_internal:
+      if not self.is_github:
+        return self.Platform.EXTERNAL_GENERIC_CI
+      return self.Platform.EXTERNAL_GITHUB
+
+    if self.is_github:
+      return self.Platform.INTERNAL_GITHUB
+    return self.Platform.INTERNAL_GENERIC_CI
+
+  @property
+  def is_coverage(self):
+    """Returns True if this CIFuzz run (building fuzzers and running them) for
+    generating a coverage report."""
+    return self.sanitizer == 'coverage'
+
+
+def _get_platform_config(cfl_platform):
+  """Returns the CI environment object for |cfl_platform|."""
+  module_name = f'platform_config.{cfl_platform}'
+  try:
+    cls = importlib.import_module(module_name).PlatformConfig
+  except ImportError:
+    cls = platform_config.BasePlatformConfig
+  return cls()
+
+
+class RunFuzzersConfig(BaseConfig):
+  """Class containing constant configuration for running fuzzers in CIFuzz."""
+
+  MODES = ['batch', 'code-change', 'coverage', 'prune']
+
+  def __init__(self):
+    super().__init__()
+    # TODO(metzman): Pick a better default for pruning.
+    self.fuzz_seconds = int(os.environ.get('FUZZ_SECONDS', 600))
+    self.mode = os.environ.get('MODE', 'code-change').lower()
+    if self.is_coverage:
+      self.mode = 'coverage'
+
+    self.report_unreproducible_crashes = environment.get_bool(
+        'REPORT_UNREPRODUCIBLE_CRASHES', False)
+
+    self.minimize_crashes = environment.get_bool('MINIMIZE_CRASHES', False)
+    if self.mode == 'batch':
+      logging.warning(
+          'Minimizing crashes reduces fuzzing time in batch fuzzing.')
+    self.report_timeouts = environment.get_bool('REPORT_TIMEOUTS', False)
+    self.report_ooms = environment.get_bool('REPORT_OOMS', True)
+    self.upload_all_crashes = environment.get_bool('UPLOAD_ALL_CRASHES', False)
+
+    # TODO(metzman): Fix tests to create valid configurations and get rid of
+    # CIFUZZ_TEST here and in presubmit.py.
+    if not os.getenv('CIFUZZ_TEST') and not self._run_config_validate():
+      raise ConfigError('Invalid Run Configuration.')
+
+  def _run_config_validate(self):
+    """Do extra validation on RunFuzzersConfig.__init__(). Do not name this
+    validate or else it will be called when using the parent's __init__ and will
+    fail. Returns True if valid."""
+    if self.mode not in self.MODES:
+      logging.error('Invalid MODE: %s. Must be one of %s.', self.mode,
+                    self.MODES)
+      return False
+
+    return True
+
+
+class BuildFuzzersConfig(BaseConfig):
+  """Class containing constant configuration for building fuzzers in CIFuzz."""
+
+  def __init__(self):
+    """Get the configuration from CIFuzz from the environment. These variables
+    are set by GitHub or the user."""
+    super().__init__()
+    self.git_sha = self.platform_conf.git_sha
+    self.git_url = self.platform_conf.git_url
+
+    self.allowed_broken_targets_percentage = os.getenv(
+        'ALLOWED_BROKEN_TARGETS_PERCENTAGE')
+    self.bad_build_check = environment.get_bool('BAD_BUILD_CHECK', True)
+
+    self.keep_unaffected_fuzz_targets = environment.get_bool(
+        'KEEP_UNAFFECTED_FUZZ_TARGETS')
+
+    self.upload_build = environment.get_bool('UPLOAD_BUILD', False)
+    if not self.keep_unaffected_fuzz_targets:
+      has_base_for_diff = (self.base_ref or self.base_commit)
+      if not has_base_for_diff:
+        logging.info(
+            'Keeping all fuzzers because there is nothing to diff against.')
+        self.keep_unaffected_fuzz_targets = True
+      elif self.upload_build:
+        logging.info('Keeping all fuzzers because we are uploading build.')
+        self.keep_unaffected_fuzz_targets = True
+      elif self.sanitizer == 'coverage':
+        logging.info('Keeping all fuzzers because we are doing coverage.')
+        self.keep_unaffected_fuzz_targets = True
+
+    if self.sanitizer == 'coverage':
+      self.bad_build_check = False

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/filestore_utils_test.py

@@ -0,0 +1,50 @@
+# Copyright 2021 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Tests for filestore_utils."""
+import unittest
+from unittest import mock
+
+import parameterized
+
+import platform_config
+import filestore
+from filestore import github_actions
+import filestore_utils
+import test_helpers
+
+
+class GetFilestoreTest(unittest.TestCase):
+  """Tests for get_filestore."""
+
+  @parameterized.parameterized.expand([
+      ({
+          'cfl_platform': 'github',
+      }, github_actions.GithubActionsFilestore),
+  ])
+  def test_get_filestore(self, config_kwargs, filestore_cls):
+    """Tests that get_filestore returns the right filestore given a certain
+    platform."""
+    run_config = test_helpers.create_run_config(**config_kwargs)
+    filestore_impl = filestore_utils.get_filestore(run_config)
+    self.assertIsInstance(filestore_impl, filestore_cls)
+
+  @mock.patch('config_utils.BaseConfig.platform', return_value='other')
+  @mock.patch('config_utils._get_platform_config',
+              return_value=platform_config.BasePlatformConfig())
+  def test_get_filestore_unsupported_platform(self, _, __):
+    """Tests that get_filestore exceptions given a platform it doesn't
+    support."""
+    run_config = test_helpers.create_run_config()
+    with self.assertRaises(filestore.FilestoreError):
+      filestore_utils.get_filestore(run_config)

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/fuzz_target_test.py

@@ -0,0 +1,298 @@
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Tests the functionality of the fuzz_target module."""
+
+import os
+import shutil
+import tempfile
+import unittest
+from unittest import mock
+
+import certifi
+# Importing this later causes import failures with pytest for some reason.
+# TODO(ochang): Figure out why.
+import parameterized
+import google.cloud.ndb  # pylint: disable=unused-import
+from pyfakefs import fake_filesystem_unittest
+from clusterfuzz.fuzz import engine
+
+import clusterfuzz_deployment
+import fuzz_target
+import test_helpers
+import workspace_utils
+
+# NOTE: This integration test relies on
+# https://github.com/google/oss-fuzz/tree/master/projects/example project.
+EXAMPLE_PROJECT = 'example'
+
+# An example fuzzer that triggers an error.
+EXAMPLE_FUZZER = 'example_crash_fuzzer'
+
+# Mock return values for engine_impl.reproduce.
+EXECUTE_SUCCESS_RESULT = engine.ReproduceResult([], 0, 0, '')
+EXECUTE_FAILURE_RESULT = engine.ReproduceResult([], 1, 0, '')
+
+TEST_DATA_PATH = os.path.join(os.path.dirname(__file__), 'test_data')
+
+
+def _create_config(**kwargs):
+  """Creates a config object and then sets every attribute that is a key in
+  |kwargs| to the corresponding value. Asserts that each key in |kwargs| is an
+  attribute of Config."""
+  defaults = {
+      'cfl_platform': 'github',
+      'oss_fuzz_project_name': EXAMPLE_PROJECT,
+      'workspace': '/workspace'
+  }
+  for default_key, default_value in defaults.items():
+    if default_key not in kwargs:
+      kwargs[default_key] = default_value
+
+  return test_helpers.create_run_config(**kwargs)
+
+
+def _create_deployment(**kwargs):
+  config = _create_config(**kwargs)
+  workspace = workspace_utils.Workspace(config)
+  return clusterfuzz_deployment.get_clusterfuzz_deployment(config, workspace)
+
+
+@mock.patch('utils.get_container_name', return_value='container')
+class IsReproducibleTest(fake_filesystem_unittest.TestCase):
+  """Tests the is_reproducible method in the fuzz_target.FuzzTarget class."""
+
+  def setUp(self):
+    """Sets up example fuzz target to test is_reproducible method."""
+    self.fuzz_target_name = 'fuzz-target'
+    deployment = _create_deployment()
+    self.config = deployment.config
+    self.workspace = deployment.workspace
+    self.fuzz_target_path = os.path.join(self.workspace.out,
+                                         self.fuzz_target_name)
+    self.setUpPyfakefs()
+    self.fs.create_file(self.fuzz_target_path)
+    self.testcase_path = '/testcase'
+    self.fs.create_file(self.testcase_path)
+
+    self.target = fuzz_target.FuzzTarget(self.fuzz_target_path,
+                                         fuzz_target.REPRODUCE_ATTEMPTS,
+                                         self.workspace, deployment,
+                                         deployment.config)
+
+    # ClusterFuzz requires ROOT_DIR.
+    root_dir = os.environ['ROOT_DIR']
+    test_helpers.patch_environ(self, empty=True)
+    os.environ['ROOT_DIR'] = root_dir
+
+  # There's an extremely bad issue that happens if this test is run: Other tests
+  # in this file fail in CI with stacktraces using referencing fakefs even if
+  # the tests do not use fakefs.
+  # TODO(metzman): Stop using fakefs.
+  @mock.patch('os.chmod')
+  @unittest.skip('Skip because of weird failures.')
+  def test_repro_timed_out(self, mock_chmod, mock_get_container_name):
+    """Tests that is_reproducible behaves correctly when reproduction times
+    out."""
+    del mock_get_container_name
+    del mock_chmod
+
+    with mock.patch(
+        'clusterfuzz._internal.bot.fuzzers.libFuzzer.engine.LibFuzzerEngine.'
+        'reproduce',
+        side_effect=TimeoutError):
+      self.assertFalse(
+          self.target.is_reproducible('/testcase', self.target.target_path, []))
+
+  def test_reproducible(self, _):
+    """Tests that is_reproducible returns True if crash is detected and that
+    is_reproducible uses the correct command to reproduce a crash."""
+    all_repro = [EXECUTE_FAILURE_RESULT] * fuzz_target.REPRODUCE_ATTEMPTS
+    with mock.patch('clusterfuzz.fuzz.get_engine') as mock_get_engine:
+      mock_get_engine().reproduce.side_effect = all_repro
+
+      result = self.target.is_reproducible(self.testcase_path,
+                                           self.fuzz_target_path, [])
+      mock_get_engine().reproduce.assert_called_once_with(
+          '/workspace/build-out/fuzz-target',
+          '/testcase',
+          arguments=[],
+          max_time=30)
+      self.assertTrue(result)
+      self.assertEqual(1, mock_get_engine().reproduce.call_count)
+
+  def test_flaky(self, _):
+    """Tests that is_reproducible returns True if crash is detected on the last
+    attempt."""
+    last_time_repro = [EXECUTE_SUCCESS_RESULT] * 9 + [EXECUTE_FAILURE_RESULT]
+    with mock.patch('clusterfuzz.fuzz.get_engine') as mock_get_engine:
+      mock_get_engine().reproduce.side_effect = last_time_repro
+      self.assertTrue(
+          self.target.is_reproducible(self.testcase_path, self.fuzz_target_path,
+                                      []))
+      self.assertEqual(fuzz_target.REPRODUCE_ATTEMPTS,
+                       mock_get_engine().reproduce.call_count)
+
+  def test_nonexistent_fuzzer(self, _):
+    """Tests that is_reproducible raises an error if it could not attempt
+    reproduction because the fuzzer doesn't exist."""
+    with self.assertRaises(fuzz_target.ReproduceError):
+      self.target.is_reproducible(self.testcase_path, '/non-existent-path', [])
+
+  def test_unreproducible(self, _):
+    """Tests that is_reproducible returns False for a crash that did not
+    reproduce."""
+    all_unrepro = [EXECUTE_SUCCESS_RESULT] * fuzz_target.REPRODUCE_ATTEMPTS
+    with mock.patch('clusterfuzz.fuzz.get_engine') as mock_get_engine:
+      mock_get_engine().reproduce.side_effect = all_unrepro
+      result = self.target.is_reproducible(self.testcase_path,
+                                           self.fuzz_target_path, [])
+      self.assertFalse(result)
+
+
+class IsCrashReportableTest(fake_filesystem_unittest.TestCase):
+  """Tests the is_crash_reportable method of FuzzTarget."""
+
+  def setUp(self):
+    """Sets up example fuzz target to test is_crash_reportable method."""
+    self.setUpPyfakefs()
+    self.fuzz_target_path = '/example/do_stuff_fuzzer'
+    deployment = _create_deployment()
+    self.target = fuzz_target.FuzzTarget(self.fuzz_target_path, 100,
+                                         deployment.workspace, deployment,
+                                         deployment.config)
+    self.oss_fuzz_build_path = '/oss-fuzz-build'
+    self.fs.create_file(self.fuzz_target_path)
+    self.oss_fuzz_target_path = os.path.join(
+        self.oss_fuzz_build_path, os.path.basename(self.fuzz_target_path))
+    self.fs.create_file(self.oss_fuzz_target_path)
+    self.testcase_path = '/testcase'
+    self.fs.create_file(self.testcase_path, contents='')
+
+    # Do this to prevent pyfakefs from messing with requests.
+    self.fs.add_real_directory(os.path.dirname(certifi.__file__))
+
+  @mock.patch('fuzz_target.FuzzTarget.is_reproducible',
+              side_effect=[True, False])
+  @mock.patch('logging.info')
+  def test_new_reproducible_crash(self, mock_info, _):
+    """Tests that a new reproducible crash returns True."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      self.target.out_dir = tmp_dir
+      self.assertTrue(self.target.is_crash_reportable(self.testcase_path, []))
+    mock_info.assert_called_with(
+        'The crash is not reproducible on previous build. '
+        'Code change (pr/commit) introduced crash.')
+
+  # yapf: disable
+  @parameterized.parameterized.expand([
+      # Reproducible on PR build, but also reproducible on OSS-Fuzz.
+      ([True, True],),
+
+      # Not reproducible on PR build, but somehow reproducible on OSS-Fuzz.
+      # Unlikely to happen in real world except if test is flaky.
+      ([False, True],),
+
+      # Not reproducible on PR build, and not reproducible on OSS-Fuzz.
+      ([False, False],),
+  ])
+  # yapf: enable
+  def test_invalid_crash(self, is_reproducible_retvals):
+    """Tests that a nonreportable crash causes the method to return False."""
+    with mock.patch('fuzz_target.FuzzTarget.is_reproducible',
+                    side_effect=is_reproducible_retvals):
+      with mock.patch('clusterfuzz_deployment.OSSFuzz.download_latest_build',
+                      return_value=self.oss_fuzz_build_path):
+        self.assertFalse(self.target.is_crash_reportable(
+            self.testcase_path, []))
+
+  @mock.patch('logging.info')
+  @mock.patch('fuzz_target.FuzzTarget.is_reproducible', return_value=[True])
+  def test_reproducible_no_oss_fuzz_target(self, _, mock_info):
+    """Tests that is_crash_reportable returns True when a crash reproduces on
+    the PR build but the target is not in the OSS-Fuzz build (usually because it
+    is new)."""
+    os.remove(self.oss_fuzz_target_path)
+
+    def is_reproducible_side_effect(testcase, target_path, reproduce_arguments):
+      del testcase
+      del reproduce_arguments
+      if os.path.dirname(target_path) == self.oss_fuzz_build_path:
+        raise fuzz_target.ReproduceError()
+      return True
+
+    with mock.patch(
+        'fuzz_target.FuzzTarget.is_reproducible',
+        side_effect=is_reproducible_side_effect) as mock_is_reproducible:
+      with mock.patch('clusterfuzz_deployment.OSSFuzz.download_latest_build',
+                      return_value=self.oss_fuzz_build_path):
+        self.assertTrue(self.target.is_crash_reportable(self.testcase_path, []))
+    mock_is_reproducible.assert_any_call(self.testcase_path,
+                                         self.oss_fuzz_target_path, [])
+    mock_info.assert_called_with(
+        'Could not run previous build of target to determine if this code '
+        'change (pr/commit) introduced crash. Assuming crash was newly '
+        'introduced.')
+
+
+class FuzzTest(fake_filesystem_unittest.TestCase):
+  """Fuzz test."""
+
+  def setUp(self):
+    """Sets up example fuzz target."""
+    self.setUpPyfakefs()
+    deployment = _create_deployment()
+    config = deployment.config
+    workspace = deployment.workspace
+    self.fuzz_target = fuzz_target.FuzzTarget('/path/fuzz-target', 10,
+                                              workspace, deployment, config)
+
+  def test_get_fuzz_target_artifact(self):
+    """Tests that get_fuzz_target_artifact works as intended."""
+    # pylint: disable=protected-access
+    fuzz_target_artifact = self.fuzz_target._target_artifact_path()
+    self.assertEqual('/workspace/out/artifacts/fuzz-target/address',
+                     fuzz_target_artifact)
+
+
+class TimeoutIntegrationTest(unittest.TestCase):
+  """Tests handling of fuzzer timeout (timeout crashes reported by
+  libFuzzer)."""
+  TIMEOUT_FUZZER_NAME = 'timeout_fuzzer'
+
+  @parameterized.parameterized.expand([(True, True), (False, False)])
+  def test_timeout_reported(self, report_timeouts, expect_crash):
+    """Tests that timeouts are not reported."""
+    with test_helpers.temp_dir_copy(TEST_DATA_PATH) as temp_dir:
+      fuzz_target_path = os.path.join(temp_dir, 'build-out',
+                                      self.TIMEOUT_FUZZER_NAME)
+      shutil.copy(os.path.join(temp_dir, self.TIMEOUT_FUZZER_NAME),
+                  fuzz_target_path)
+      deployment = _create_deployment(workspace=temp_dir,
+                                      report_timeouts=report_timeouts)
+      config = deployment.config
+      fuzz_target_obj = fuzz_target.FuzzTarget(fuzz_target_path,
+                                               fuzz_target.REPRODUCE_ATTEMPTS,
+                                               deployment.workspace, deployment,
+                                               config)
+      with mock.patch('clusterfuzz._internal.bot.fuzzers.libfuzzer.'
+                      'fix_timeout_argument_for_reproduction') as _:
+        with mock.patch(
+            'clusterfuzz._internal.bot.fuzzers.libFuzzer.fuzzer.get_arguments',
+            return_value=['-timeout=1', '-rss_limit_mb=2560']):
+          fuzz_result = fuzz_target_obj.fuzz()
+    self.assertEqual(bool(fuzz_result.testcase), expect_crash)
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/get_coverage.py

@@ -0,0 +1,208 @@
+# Copyright 2021 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Module for determining coverage of fuzz targets."""
+import json
+import logging
+import os
+import sys
+
+import http_utils
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import utils
+
+# The path to get OSS-Fuzz project's latest report json file.`
+OSS_FUZZ_LATEST_COVERAGE_INFO_PATH = 'oss-fuzz-coverage/latest_report_info/'
+
+
+# pylint: disable=too-few-public-methods
+class CoverageError(Exception):
+  """Exceptions for project coverage."""
+
+
+class BaseCoverage:
+  """Gets coverage data for a project."""
+
+  def __init__(self, repo_path):
+    self.repo_path = _normalize_repo_path(repo_path)
+
+  def get_files_covered_by_target(self, target):
+    """Returns a list of source files covered by the specific fuzz target.
+
+    Args:
+      target: The name of the fuzz target whose coverage is requested.
+
+    Returns:
+      A list of files that the fuzz target covers or None.
+    """
+    target_cov = self.get_target_coverage(target)
+    if not target_cov:
+      logging.info('No coverage available for %s.', target)
+      return None
+
+    coverage_per_file = get_coverage_per_file(target_cov)
+    if not coverage_per_file:
+      logging.info('No files found in coverage report.')
+      return None
+
+    affected_file_list = []
+    for file_cov in coverage_per_file:
+      norm_file_path = os.path.normpath(file_cov['filename'])
+      if not norm_file_path.startswith(self.repo_path):
+        # Exclude files outside of the main repo.
+        continue
+
+      if not is_file_covered(file_cov):
+        # Don't consider a file affected if code in it is never executed.
+        continue
+
+      # TODO(metzman): It's weird to me that we access file_cov['filename']
+      # again and not norm_file_path, figure out if this makes sense.
+      relative_path = utils.remove_prefix(file_cov['filename'], self.repo_path)
+      affected_file_list.append(relative_path)
+
+    return affected_file_list
+
+  def get_target_coverage(self, target):
+    """Get the coverage report for a specific fuzz target.
+
+    Args:
+      target: The name of the fuzz target whose coverage is requested.
+
+    Returns:
+      The target's coverage json dict or None on failure.
+    """
+    raise NotImplementedError('Child class must implement method.')
+
+
+class OSSFuzzCoverage(BaseCoverage):
+  """Gets coverage data for a project from OSS-Fuzz."""
+
+  def __init__(self, repo_path, oss_fuzz_project_name):
+    """Constructor for OSSFuzzCoverage."""
+    super().__init__(repo_path)
+    self.oss_fuzz_project_name = oss_fuzz_project_name
+    self.fuzzer_stats_url = _get_oss_fuzz_fuzzer_stats_dir_url(
+        self.oss_fuzz_project_name)
+    if self.fuzzer_stats_url is None:
+      raise CoverageError('Could not get latest coverage.')
+
+  def get_target_coverage(self, target):
+    """Get the coverage report for a specific fuzz target.
+
+    Args:
+      target: The name of the fuzz target whose coverage is requested.
+
+    Returns:
+      The target's coverage json dict or None on failure.
+    """
+    if not self.fuzzer_stats_url:
+      return None
+
+    target_url = utils.url_join(self.fuzzer_stats_url, target + '.json')
+    return http_utils.get_json_from_url(target_url)
+
+
+def _get_oss_fuzz_latest_cov_report_info(oss_fuzz_project_name):
+  """Gets and returns a dictionary containing the latest coverage report info
+  for |project|."""
+  latest_report_info_url = utils.url_join(utils.GCS_BASE_URL,
+                                          OSS_FUZZ_LATEST_COVERAGE_INFO_PATH,
+                                          oss_fuzz_project_name + '.json')
+  latest_cov_info = http_utils.get_json_from_url(latest_report_info_url)
+  if latest_cov_info is None:
+    logging.error('Could not get the coverage report json from url: %s.',
+                  latest_report_info_url)
+    return None
+  return latest_cov_info
+
+
+def _get_oss_fuzz_fuzzer_stats_dir_url(oss_fuzz_project_name):
+  """Gets latest coverage report info for a specific OSS-Fuzz project from
+  GCS.
+
+  Args:
+    oss_fuzz_project_name: The name of the project.
+
+  Returns:
+    The projects coverage report info in json dict or None on failure.
+  """
+  latest_cov_info = _get_oss_fuzz_latest_cov_report_info(oss_fuzz_project_name)
+
+  if not latest_cov_info:
+    return None
+
+  if 'fuzzer_stats_dir' not in latest_cov_info:
+    logging.error('fuzzer_stats_dir not in latest coverage info.')
+    return None
+
+  fuzzer_stats_dir_gs_url = latest_cov_info['fuzzer_stats_dir']
+  fuzzer_stats_dir_url = utils.gs_url_to_https(fuzzer_stats_dir_gs_url)
+  return fuzzer_stats_dir_url
+
+
+class FilesystemCoverage(BaseCoverage):
+  """Class that gets a project's coverage from the filesystem."""
+
+  def __init__(self, repo_path, project_coverage_dir):
+    super().__init__(repo_path)
+    self.project_coverage_dir = project_coverage_dir
+
+  def get_target_coverage(self, target):
+    """Get the coverage report for a specific fuzz target.
+
+    Args:
+      target: The name of the fuzz target whose coverage is requested.
+
+    Returns:
+      The target's coverage json dict or None on failure.
+    """
+    logging.info('Getting coverage for %s from filesystem.', target)
+    fuzzer_stats_json_path = os.path.join(self.project_coverage_dir,
+                                          'fuzzer_stats', target + '.json')
+    if not os.path.exists(fuzzer_stats_json_path):
+      logging.warning('%s does not exist.', fuzzer_stats_json_path)
+      return None
+
+    with open(fuzzer_stats_json_path) as fuzzer_stats_json_file_handle:
+      try:
+        return json.load(fuzzer_stats_json_file_handle)
+      except json.decoder.JSONDecodeError as err:
+        logging.error('Could not decode: %s. Error: %s.',
+                      fuzzer_stats_json_path, err)
+        return None
+
+
+def is_file_covered(file_cov):
+  """Returns whether the file is covered."""
+  return file_cov['summary']['regions']['covered']
+
+
+def get_coverage_per_file(target_cov):
+  """Returns the coverage per file within |target_cov|."""
+  try:
+    return target_cov['data'][0]['files']
+  except (IndexError, TypeError, KeyError):
+    logging.error('target_cov: %s is malformed.', target_cov)
+    return None
+
+
+def _normalize_repo_path(repo_path):
+  """Normalizes and returns |repo_path| to make sure cases like /src/curl and
+  /src/curl/ are both handled."""
+  repo_path = os.path.normpath(repo_path)
+  if not repo_path.endswith('/'):
+    repo_path += '/'
+  return repo_path

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/http_utils.py

@@ -0,0 +1,118 @@
+# Copyright 2021 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Utility module for HTTP."""
+import json
+import logging
+import os
+import sys
+import tempfile
+import zipfile
+
+import requests
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import retry
+
+_DOWNLOAD_URL_RETRIES = 3
+_DOWNLOAD_URL_BACKOFF = 1
+_HTTP_REQUEST_TIMEOUT = 10
+
+
+def download_and_unpack_zip(url, extract_directory, headers=None):
+  """Downloads and unpacks a zip file from an HTTP URL.
+
+  Args:
+    url: A url to the zip file to be downloaded and unpacked.
+    extract_directory: The path where the zip file should be extracted to.
+    headers: (Optional) HTTP headers to send with the download request.
+
+  Returns:
+    True on success.
+  """
+  if headers is None:
+    headers = {}
+
+  if not os.path.exists(extract_directory):
+    logging.error('Extract directory: %s does not exist.', extract_directory)
+    return False
+
+  # Gives the temporary zip file a unique identifier in the case that
+  # that download_and_unpack_zip is done in parallel.
+  with tempfile.NamedTemporaryFile(suffix='.zip') as tmp_file:
+    if not download_url(url, tmp_file.name, headers=headers):
+      return False
+
+    try:
+      with zipfile.ZipFile(tmp_file.name, 'r') as zip_file:
+        zip_file.extractall(extract_directory)
+    except zipfile.BadZipFile:
+      logging.error('Error unpacking zip from %s. Bad Zipfile.', url)
+      return False
+
+  return True
+
+
+def download_url(*args, **kwargs):
+  """Wrapper around _download_url that returns False if _download_url
+  exceptions."""
+  try:
+    return _download_url(*args, **kwargs)
+  except Exception:  # pylint: disable=broad-except
+    return False
+
+
+def get_json_from_url(url):
+  """Gets a json object from a specified HTTP URL.
+
+  Args:
+    url: The url of the json to be downloaded.
+
+  Returns:
+    A dictionary deserialized from JSON or None on failure.
+  """
+  try:
+    return requests.get(url, timeout=_HTTP_REQUEST_TIMEOUT).json()
+  except (ValueError, TypeError, json.JSONDecodeError,
+          requests.exceptions.ReadTimeout) as err:
+    logging.error('Loading json from url %s failed with: %s.', url, str(err))
+    return None
+
+
+@retry.wrap(_DOWNLOAD_URL_RETRIES, _DOWNLOAD_URL_BACKOFF)
+def _download_url(url, filename, headers=None):
+  """Downloads the file located at |url|, using HTTP to |filename|.
+
+  Args:
+    url: A url to a file to download.
+    filename: The path the file should be downloaded to.
+    headers: (Optional) HTTP headers to send with the download request.
+
+  Returns:
+    True on success.
+  """
+  if headers is None:
+    headers = {}
+
+  response = requests.get(url, headers=headers)
+
+  if response.status_code != 200:
+    logging.error('Unable to download from: %s. Code: %d. Content: %s.', url,
+                  response.status_code, response.content)
+    return False
+
+  with open(filename, 'wb') as file_handle:
+    file_handle.write(response.content)
+
+  return True

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/cifuzz/run_fuzzers.py

@@ -0,0 +1,321 @@
+# Copyright 2021 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Module for running fuzzers."""
+import enum
+import logging
+import os
+import sys
+import time
+
+import clusterfuzz_deployment
+import fuzz_target
+import generate_coverage_report
+import workspace_utils
+import sarif_utils
+
+# pylint: disable=wrong-import-position,import-error
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import utils
+
+
+class RunFuzzersResult(enum.Enum):
+  """Enum result from running fuzzers."""
+  ERROR = 0
+  BUG_FOUND = 1
+  NO_BUG_FOUND = 2
+
+
+class BaseFuzzTargetRunner:
+  """Base class for fuzzer runners."""
+
+  def __init__(self, config):
+    self.config = config
+    self.workspace = workspace_utils.Workspace(config)
+    self.clusterfuzz_deployment = (
+        clusterfuzz_deployment.get_clusterfuzz_deployment(
+            self.config, self.workspace))
+
+    # Set by the initialize method.
+    self.fuzz_target_paths = None
+
+  def get_fuzz_targets(self):
+    """Returns fuzz targets in out directory."""
+    return utils.get_fuzz_targets(self.workspace.out)
+
+  def initialize(self):
+    """Initialization method. Must be called before calling run_fuzz_targets.
+    Returns True on success."""
+    # Use a separate initialization function so we can return False on failure
+    # instead of exceptioning like we need to do if this were done in the
+    # __init__ method.
+
+    logging.info('Using %s sanitizer.', self.config.sanitizer)
+
+    # TODO(metzman) Add a check to ensure we aren't over time limit.
+    if not self.config.fuzz_seconds or self.config.fuzz_seconds < 1:
+      logging.error(
+          'Fuzz_seconds argument must be greater than 1, but was: %s.',
+          self.config.fuzz_seconds)
+      return False
+
+    if not os.path.exists(self.workspace.out):
+      logging.error('Out directory: %s does not exist.', self.workspace.out)
+      return False
+
+    if not os.path.exists(self.workspace.artifacts):
+      os.makedirs(self.workspace.artifacts)
+    elif (not os.path.isdir(self.workspace.artifacts) or
+          os.listdir(self.workspace.artifacts)):
+      logging.error('Artifacts path: %s exists and is not an empty directory.',
+                    self.workspace.artifacts)
+      return False
+
+    self.fuzz_target_paths = self.get_fuzz_targets()
+    logging.info('Fuzz targets: %s', self.fuzz_target_paths)
+    if not self.fuzz_target_paths:
+      logging.error('No fuzz targets were found in out directory: %s.',
+                    self.workspace.out)
+      return False
+
+    return True
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Cleans up after running |fuzz_target_obj|."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def run_fuzz_target(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Fuzzes with |fuzz_target_obj| and returns the result."""
+    raise NotImplementedError('Child class must implement method.')
+
+  @property
+  def quit_on_bug_found(self):
+    """Property that is checked to determine if fuzzing should quit after first
+    bug is found."""
+    raise NotImplementedError('Child class must implement method.')
+
+  def create_fuzz_target_obj(self, target_path, run_seconds):
+    """Returns a fuzz target object."""
+    return fuzz_target.FuzzTarget(target_path, run_seconds, self.workspace,
+                                  self.clusterfuzz_deployment, self.config)
+
+  def run_fuzz_targets(self):
+    """Runs fuzz targets. Returns True if a bug was found."""
+    fuzzers_left_to_run = len(self.fuzz_target_paths)
+
+    # Make a copy since we will mutate it.
+    fuzz_seconds = self.config.fuzz_seconds
+
+    min_seconds_per_fuzzer = fuzz_seconds // fuzzers_left_to_run
+    bug_found = False
+    for target_path in self.fuzz_target_paths:
+      # By doing this, we can ensure that every fuzz target runs for at least
+      # min_seconds_per_fuzzer, but that other fuzzers will have longer to run
+      # if one ends early.
+      run_seconds = max(fuzz_seconds // fuzzers_left_to_run,
+                        min_seconds_per_fuzzer)
+
+      target = self.create_fuzz_target_obj(target_path, run_seconds)
+      start_time = time.time()
+      result = self.run_fuzz_target(target)
+      self.cleanup_after_fuzz_target_run(target)
+
+      # It's OK if this goes negative since we take max when determining
+      # run_seconds.
+      fuzz_seconds -= time.time() - start_time
+
+      fuzzers_left_to_run -= 1
+      if not result.testcase or not result.stacktrace:
+        logging.info('Fuzzer %s finished running without reportable crashes.',
+                     target.target_name)
+        continue
+
+      bug_found = True
+      if self.quit_on_bug_found:
+        logging.info('Bug found. Stopping fuzzing.')
+        break
+
+    # pylint: disable=undefined-loop-variable
+    if not target_path:
+      logging.error('Ran no fuzz targets.')
+    elif self.config.output_sarif:
+      # TODO(metzman): Handle multiple crashes.
+      write_fuzz_result_to_sarif(result, target_path, self.workspace)
+    self.clusterfuzz_deployment.upload_crashes()
+    return bug_found
+
+
+def write_fuzz_result_to_sarif(fuzz_result, target_path, workspace):
+  """Write results of fuzzing to SARIF."""
+  logging.info('Writing sarif results.')
+  sarif_utils.write_stacktrace_to_sarif(fuzz_result.stacktrace, target_path,
+                                        workspace)
+
+
+class PruneTargetRunner(BaseFuzzTargetRunner):
+  """Runner that prunes corpora."""
+
+  @property
+  def quit_on_bug_found(self):
+    return False
+
+  def run_fuzz_target(self, fuzz_target_obj):
+    """Prunes with |fuzz_target_obj| and returns the result."""
+    result = fuzz_target_obj.prune()
+    logging.debug('Corpus path contents: %s.', os.listdir(result.corpus_path))
+    self.clusterfuzz_deployment.upload_corpus(fuzz_target_obj.target_name,
+                                              result.corpus_path,
+                                              replace=True)
+    return result
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Cleans up after pruning with |fuzz_target_obj|."""
+    fuzz_target_obj.free_disk_if_needed()
+
+
+NON_FUZZ_TARGETS_FOR_COVERAGE = {
+    'llvm-symbolizer',
+    'jazzer_agent_deploy.jar',
+    'jazzer_driver',
+    'jazzer_driver_with_sanitizer',
+}
+
+
+def is_coverage_fuzz_target(file_path):
+  """Returns whether |file_path| is a fuzz target binary for the purposes of a
+  coverage report. Inspired by infra/base-images/base-runner/coverage."""
+  if not os.path.isfile(file_path):
+    return False
+  if not utils.is_executable(file_path):
+    return False
+  filename = os.path.basename(file_path)
+  return filename not in NON_FUZZ_TARGETS_FOR_COVERAGE
+
+
+def get_coverage_fuzz_targets(out):
+  """Returns a list of fuzz targets in |out| for coverage."""
+  # We only want fuzz targets from the root because during the coverage build,
+  # a lot of the image's filesystem is copied into /out for the purpose of
+  # generating coverage reports.
+  fuzz_targets = []
+  for filename in os.listdir(out):
+    file_path = os.path.join(out, filename)
+    if is_coverage_fuzz_target(file_path):
+      fuzz_targets.append(file_path)
+  return fuzz_targets
+
+
+class CoverageTargetRunner(BaseFuzzTargetRunner):
+  """Runner that runs the 'coverage' command."""
+
+  @property
+  def quit_on_bug_found(self):
+    raise NotImplementedError('Not implemented for CoverageTargetRunner.')
+
+  def get_fuzz_targets(self):
+    """Returns fuzz targets in out directory."""
+    return get_coverage_fuzz_targets(self.workspace.out)
+
+  def run_fuzz_targets(self):
+    """Generates a coverage report. Always returns False since it never finds
+    any bugs."""
+    generate_coverage_report.generate_coverage_report(
+        self.fuzz_target_paths, self.workspace, self.clusterfuzz_deployment,
+        self.config)
+    return False
+
+  def run_fuzz_target(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Fuzzes with |fuzz_target_obj| and returns the result."""
+    raise NotImplementedError('Not implemented for CoverageTargetRunner.')
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Cleans up after running |fuzz_target_obj|."""
+    raise NotImplementedError('Not implemented for CoverageTargetRunner.')
+
+
+class CiFuzzTargetRunner(BaseFuzzTargetRunner):
+  """Runner for fuzz targets used in CI (patch-fuzzing) context."""
+
+  @property
+  def quit_on_bug_found(self):
+    return True
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    """Cleans up after running |fuzz_target_obj|."""
+    fuzz_target_obj.free_disk_if_needed()
+
+  def run_fuzz_target(self, fuzz_target_obj):  # pylint: disable=no-self-use
+    return fuzz_target_obj.fuzz()
+
+
+class BatchFuzzTargetRunner(BaseFuzzTargetRunner):
+  """Runner for fuzz targets used in batch fuzzing context."""
+
+  @property
+  def quit_on_bug_found(self):
+    return False
+
+  def run_fuzz_target(self, fuzz_target_obj):
+    """Fuzzes with |fuzz_target_obj| and returns the result."""
+    result = fuzz_target_obj.fuzz(batch=True)
+    logging.debug('Corpus path contents: %s.', os.listdir(result.corpus_path))
+    self.clusterfuzz_deployment.upload_corpus(fuzz_target_obj.target_name,
+                                              result.corpus_path)
+    return result
+
+  def cleanup_after_fuzz_target_run(self, fuzz_target_obj):
+    """Cleans up after running |fuzz_target_obj|."""
+    # This must be done after we upload the corpus, otherwise it will be deleted
+    # before we get a chance to upload it. We can't delete the fuzz target
+    # because it is needed when we upload the build.
+    fuzz_target_obj.free_disk_if_needed(delete_fuzz_target=False)
+
+
+_MODE_RUNNER_MAPPING = {
+    'batch': BatchFuzzTargetRunner,
+    'coverage': CoverageTargetRunner,
+    'prune': PruneTargetRunner,
+    'code-change': CiFuzzTargetRunner,
+}
+
+
+def get_fuzz_target_runner(config):
+  """Returns a fuzz target runner object based on the mode of
+  |config|."""
+  runner = _MODE_RUNNER_MAPPING[config.mode](config)
+  logging.info('run fuzzers MODE is: %s. Runner: %s.', config.mode, runner)
+  return runner
+
+
+def run_fuzzers(config):  # pylint: disable=too-many-locals
+  """Runs fuzzers for a specific OSS-Fuzz project.
+
+  Args:
+    config: A RunFuzzTargetsConfig.
+
+  Returns:
+    A RunFuzzersResult enum value indicating what happened during fuzzing.
+  """
+  fuzz_target_runner = get_fuzz_target_runner(config)
+  if not fuzz_target_runner.initialize():
+    # We didn't fuzz at all because of internal (CIFuzz) errors. And we didn't
+    # find any bugs.
+    return RunFuzzersResult.ERROR
+
+  if not fuzz_target_runner.run_fuzz_targets():
+    # We fuzzed successfully, but didn't find any bugs (in the fuzz target).
+    return RunFuzzersResult.NO_BUG_FOUND
+
+  # We fuzzed successfully and found bug(s) in the fuzz targets.
+  return RunFuzzersResult.BUG_FOUND

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/constants.py

@@ -0,0 +1,49 @@
+# Copyright 2021 Google LLC
+#
+# 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
+#
+#      http://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.
+#
+################################################################################
+"""Constants for OSS-Fuzz."""
+
+DEFAULT_EXTERNAL_BUILD_INTEGRATION_PATH = '.clusterfuzzlite'
+
+DEFAULT_LANGUAGE = 'c++'
+DEFAULT_SANITIZER = 'address'
+DEFAULT_ARCHITECTURE = 'x86_64'
+DEFAULT_ENGINE = 'libfuzzer'
+LANGUAGES = [
+    'c',
+    'c++',
+    'go',
+    'javascript',
+    'jvm',
+    'python',
+    'rust',
+    'swift',
+    'ruby',
+]
+LANGUAGES_WITH_COVERAGE_SUPPORT = [
+    'c', 'c++', 'go', 'jvm', 'python', 'rust', 'swift', 'javascript', 'ruby'
+]
+SANITIZERS = [
+    'address',
+    'none',
+    'memory',
+    'undefined',
+    'thread',
+    'coverage',
+    'introspector',
+    'hwaddress',
+]
+ARCHITECTURES = ['i386', 'x86_64', 'aarch64']
+ENGINES = ['libfuzzer', 'afl', 'honggfuzz', 'centipede', 'none', 'wycheproof']

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/Makefile

@@ -0,0 +1,41 @@
+.POSIX:
+CXX     = clang++
+CFLAGS = -std=c++17 -Wall -Wextra -O3 -g3 -Werror
+
+all: SystemSan target target_file target_dns
+
+SystemSan: SystemSan.cpp inspect_dns.cpp inspect_utils.cpp
+	$(CXX) $(CFLAGS) -lpthread -o $@ $^
+
+# Needs atheris.
+python-test: all
+	./SystemSan python shell_injection_poc_fuzzer.py
+
+target: target.cpp
+	$(CXX) $(CFLAGS) -fsanitize=address,fuzzer -o $@ $^
+
+target_file: target_file.cpp
+	$(CXX) $(CFLAGS) -fsanitize=address,fuzzer -o $@ $^
+
+target_dns: target_dns.cpp
+	$(CXX) $(CFLAGS) -fsanitize=address,fuzzer -o $@ $^
+
+test:  all vuln.dict
+	./SystemSan ./target -dict=vuln.dict
+	./SystemSan ./target_file -dict=vuln.dict
+	./SystemSan ./target_dns -dict=vuln.dict
+
+pytorch-lightning-1.5.10:
+	cp SystemSan.cpp PoEs/pytorch-lightning-1.5.10/; \
+	cd PoEs/pytorch-lightning-1.5.10/; \
+	docker build . --tag syssan_pytorch-lightning; \
+	docker run -t systemsan_pytorch-lightning:latest;
+
+node-shell-quote-v1.7.3:
+	cp SystemSan.cpp PoEs/node-shell-quote-v1.7.3/; \
+	cd PoEs/node-shell-quote-v1.7.3/; \
+	docker build . --tag systemsan_node-shell-quote; \
+	docker run -t systemsan_node-shell-quote:latest;
+
+clean:
+	rm -f SystemSan /tmp/tripwire target target_file target_dns

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/PoEs/node-shell-quote-v1.7.3/build.sh

@@ -0,0 +1,22 @@
+#!/bin/bash -eu
+# Copyright 2022 Google LLC
+#
+# 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
+#
+#      http://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.
+#
+################################################################################
+
+# Build and install project (using current CFLAGS, CXXFLAGS).
+npm install ./node-shell-quote/
+
+# Build fuzzers.
+npm i -g @gitlab-org/jsfuzz

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/PoEs/pytorch-lightning-1.5.10/Makefile

@@ -0,0 +1,12 @@
+.POSIX:
+CXX     = clang++
+CFLAGS = -std=c++17 -Wall -Wextra -O3 -g3
+
+SystemSan: SystemSan.cpp
+	$(CXX) $(CFLAGS) -lpthread -o $@ $^
+
+run: clean SystemSan fuzz_pytorch_lightning.py
+	./SystemSan ./fuzz_pytorch_lightning.py -dict=vuln.dict
+
+clean:
+	rm -f SystemSan /tmp/tripwire

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/README.md

@@ -0,0 +1,66 @@
+# System Sanitizers
+
+We use `ptrace` to instrument system calls made by the target program to detect
+various vulnerabilities.
+
+## Command injection
+
+This detector currently works by
+
+- Checking if `execve` is called with `/tmp/tripwire` (which comes from our dictionary).
+- Checking if `execve` is invoking a shell with invalid syntax. This is likely
+  caused by our input.
+
+## Arbitrary file open
+
+TODO: documentation.
+
+## Proof of concept
+
+### Cleanup
+Note this will delete /tmp/tripwire if it exists.
+```shell
+make clean
+```
+
+### Run test
+Note this will overwrite /tmp/tripwire if it exists.
+```shell
+make test
+```
+
+Look for one of the following lines:
+
+> ===BUG DETECTED: Shell injection===
+
+which indicates the detection of executing the planted `/tmp/tripwire`.
+
+
+> ===BUG DETECTED: Shell corruption===
+
+which indicates the detection of executing a syntactic erroneous command.
+
+
+### Command injection PoC in Python with `pytorch-lightning`
+With `SystemSan`, [`Artheris`](https://github.com/google/atheris) can detect a shell injection bug in [version v1.5.10 of `pytorch-lightning`](https://github.com/PyTorchLightning/pytorch-lightning/tree/1.5.0).
+```shell
+make pytorch-lightning-1.5.10
+```
+
+### Command injection PoC in JavaScript with `shell-quote`
+With `SystemSan`, [`Jsfuzz`](https://gitlab.com/gitlab-org/security-products/analyzers/fuzzers/jsfuzz) can detect a shell corrpution bug in [the latest version (v1.7.3) of `shell-quote`](https://github.com/substack/node-shell-quote) without any seed.
+```shell
+make node-shell-quote-v1.7.3
+```
+This is based on [a shell injection exploit report](https://wh0.github.io/2021/10/28/shell-quote-rce-exploiting.html) of [version v1.7.2 of `shell-quote`](https://github.com/substack/node-shell-quote/tree/v1.7.2).
+`SystemSan` can also discover the same shell injection bug with a corpus file containing:
+```
+`:`/tmp/tripwire``:`
+```
+
+## Trophies
+
+- <https://github.com/syoyo/tinygltf/issues/368>
+- <https://github.com/substack/node-shell-quote/issues/54>
+
+

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/SystemSan.cpp

@@ -0,0 +1,493 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * 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
+
+ *      http://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.
+ */
+/* A detector that uses ptrace to identify shell injection vulnerabilities. */
+
+/* C standard library */
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+
+/* POSIX */
+#include <sys/stat.h>
+#include <sys/user.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+/* Linux */
+#include <sys/ptrace.h>
+#include <syscall.h>
+#include <fcntl.h>
+
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "inspect_utils.h"
+#include "inspect_dns.h"
+
+#define DEBUG_LOGS 0
+
+#if DEBUG_LOGS
+#define debug_log(...)            \
+  do {                            \
+    fprintf(stderr, __VA_ARGS__); \
+    fflush(stdout);               \
+    fputc('\n', stderr);          \
+  } while (0)
+#else
+#define debug_log(...)
+#endif
+
+#define fatal_log(...)            \
+  do {                            \
+    fprintf(stderr, __VA_ARGS__); \
+    fputc('\n', stderr);          \
+    exit(EXIT_FAILURE);           \
+  } while (0)
+
+// The magic string that we'll use to detect full control over the command
+// executed.
+const std::string kTripWire = "/tmp/tripwire";
+// Shell injection bug confirmed with /tmp/tripwire.
+const std::string kInjectionError = "Shell injection";
+// Shell corruption bug detected based on syntax error.
+const std::string kCorruptionError = "Shell corruption";
+// The magic string that we'll use to detect arbitrary file open
+const std::string kFzAbsoluteDirectory = "/fz/";
+// Arbitrary file open in /fz/
+const std::string kArbitraryFileOpenError = "Arbitrary file open";
+// Assuming only shorter (than this constant) top dir are legitly used.
+constexpr int kRootDirMaxLength = 16;
+
+// The PID of the root process we're fuzzing.
+pid_t g_root_pid;
+
+// Map of a PID/TID its PID/TID creator and wether it ran exec.
+std::map<pid_t, ThreadParent> root_pids;
+
+// Assuming the longest pathname is "/bin/bash".
+constexpr int kShellPathnameLength = 20;
+
+// Syntax error messages of each shell.
+const std::map<std::string, std::set<std::string>> kShellSyntaxErrors = {
+    {"bash",
+     {
+         ": command not found",  // General
+         ": syntax error",       // Unfinished " or ' or ` or if, leading | or ;
+         ": missing `]'",        // Unfinished [
+         ": event not found",    // ! leads large numbers
+         ": No such file or directory",  // Leading < or /
+     }},
+    {"csh",
+     {
+         ": Command not found.",         // General
+         ": Missing }.",                 // Unfinished {
+         "Too many ('s.",                // Unfinished (
+         "Invalid null command.",        // Leading | or < or >
+         "Missing name for redirect.",   // Single < or >
+         ": No match.",                  // Leading ? or [ or *
+         "Modifier failed.",             // Leading ^
+         "No previous left hand side.",  // A ^
+         ": No such job.",               // Leading %
+         ": No current job.",            // A %
+         ": Undefined variable.",        // Containing $
+         ": Event not found.",           // ! leads large numbers
+         // TODO: Make this more specific.
+         "Unmatched",  // Unfinished " or ' or `, leading ;
+     }},
+    {"dash",
+     {
+         "not found",     // General
+         "Syntax error",  // Unfinished " or ' or ` or if, leading | or ; or &
+         "missing ]",     // Unfinished [
+         "No such file",  // Leading <
+     }},
+    {"zsh",
+     {
+         ": command not found",                // General
+         ": syntax error",                     // Unfinished " or ' or `
+         ": ']' expected",                     // Unfinished [
+         ": no such file or directory",        // Leading < or /
+         ": parse error near",                 // Leading |, or &
+         ": no such user or named directory",  // Leading ~
+     }},
+};
+
+// Shells used by Processes.
+std::map<pid_t, std::string> g_shell_pids;
+
+struct Tracee {
+  pid_t pid;
+  bool syscall_enter = true;
+
+  Tracee(pid_t pid) : pid(pid) {}
+};
+
+pid_t run_child(char **argv) {
+  // Run the program under test with its args as a child process
+  pid_t pid = fork();
+  switch (pid) {
+    case -1:
+      fatal_log("Fork failed: %s", strerror(errno));
+    case 0:
+      raise(SIGSTOP);
+      execvp(argv[0], argv);
+      fatal_log("execvp: %s", strerror(errno));
+  }
+  return pid;
+}
+
+// Construct a string with the memory specified in a register.
+std::string read_string(pid_t pid, unsigned long reg, unsigned long length) {
+  auto memory = read_memory(pid, reg, length);
+  if (!memory.size()) {
+    return "";
+  }
+
+  std::string content(reinterpret_cast<char *>(memory.data()),
+                      std::min(memory.size(), length));
+  return content;
+}
+
+void inspect_for_injection(pid_t pid, const user_regs_struct &regs) {
+  // Inspect a PID's registers for the sign of shell injection.
+  std::string path = read_string(pid, regs.rdi, kTripWire.length());
+  if (!path.length()) {
+    return;
+  }
+  debug_log("inspecting");
+  if (path == kTripWire) {
+    report_bug(kInjectionError, pid);
+  }
+}
+
+std::string get_pathname(pid_t pid, const user_regs_struct &regs) {
+  // Parse the pathname from the memory specified in the RDI register.
+  std::string pathname = read_string(pid, regs.rdi, kShellPathnameLength);
+  debug_log("Pathname is %s (len %lu)\n", pathname.c_str(), pathname.length());
+  return pathname;
+}
+
+std::string match_shell(std::string binary_pathname);
+
+// Identify the exact shell behind sh
+std::string identify_sh(std::string path) {
+  char shell_pathname[kShellPathnameLength];
+  auto written = readlink(path.c_str(), shell_pathname, kShellPathnameLength - 1);
+  if (written == -1) {
+    std::cerr << "Cannot query which shell is behind sh: readlink failed on "
+              << path << ": "
+              << strerror(errno) << "\n";
+    std::cerr << "Assuming the shell is dash\n";
+    return "dash";
+  }
+  shell_pathname[written] = '\0';
+
+  debug_log("sh links to %s\n", shell_pathname);
+  std::string shell_pathname_str(shell_pathname);
+
+  return match_shell(shell_pathname_str);
+}
+
+std::string match_shell(std::string binary_pathname) {
+  // Identify the name of the shell used in the pathname.
+  if (!binary_pathname.length()) {
+    return "";
+  }
+
+  // We use c_str() to accept only the null terminated string.
+  std::string binary_name = binary_pathname.substr(
+      binary_pathname.find_last_of("/") + 1).c_str();
+
+  debug_log("Binary is %s (%lu)\n", binary_name.c_str(),
+            binary_name.length());
+
+  for (const auto &item : kShellSyntaxErrors) {
+    std::string known_shell = item.first;
+    if (binary_name == "sh") {
+      debug_log("Matched sh: Needs to identify which specific shell it is.\n");
+      return identify_sh(binary_pathname);
+    }
+    if (binary_name == known_shell) {
+      debug_log("Matched %s\n", binary_name.c_str());
+      return known_shell;
+    }
+  }
+  return "";
+}
+
+std::string get_shell(pid_t pid, const user_regs_struct &regs) {
+  // Get shell name used in a process.
+  std::string binary_pathname = get_pathname(pid, regs);
+  return match_shell(binary_pathname);
+}
+
+void match_error_pattern(std::string buffer, std::string shell, pid_t pid) {
+  auto error_patterns = kShellSyntaxErrors.at(shell);
+  for (const auto &pattern : error_patterns) {
+    if (buffer.find(pattern) != std::string::npos) {
+      std::cerr << "--- Found a sign of shell corruption ---\n"
+                << buffer.c_str()
+                << "\n----------------------------------------\n";
+      // If a shell corruption error happens, kill its parent.
+      auto parent = root_pids[pid];
+      while (!parent.ran_exec) {
+        if (parent.parent_tid == g_root_pid) {
+          break;
+        }
+        parent = root_pids[parent.parent_tid];
+      }
+      report_bug(kCorruptionError, parent.parent_tid);
+    }
+  }
+}
+
+void inspect_for_corruption(pid_t pid, const user_regs_struct &regs) {
+  // Inspect a PID's registers for shell corruption.
+  std::string buffer = read_string(pid, regs.rsi, regs.rdx);
+  debug_log("Write buffer: %s\n", buffer.c_str());
+  match_error_pattern(buffer, g_shell_pids[pid], pid);
+}
+
+void log_file_open(std::string path, int flags, pid_t pid) {
+  report_bug(kArbitraryFileOpenError, pid);
+  std::cerr << "===File opened: " << path.c_str() << ", flags = " << flags << ",";
+  switch (flags & 3) {
+    case O_RDONLY:
+      std::cerr << "O_RDONLY";
+      break;
+    case O_WRONLY:
+      std::cerr << "O_WRONLY";
+      break;
+    case O_RDWR:
+      std::cerr << "O_RDWR";
+      break;
+    default:
+      std::cerr << "unknown";
+  }
+  std::cerr << "===\n";
+}
+
+bool has_unprintable(const std::string &value) {
+  for (size_t i = 0; i < value.length(); i++) {
+    if (value[i] & 0x80) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void inspect_for_arbitrary_file_open(pid_t pid, const user_regs_struct &regs) {
+  // Inspect a PID's register for the sign of arbitrary file open.
+  std::string path = read_string(pid, regs.rsi, kRootDirMaxLength);
+  if (!path.length()) {
+    return;
+  }
+  if (path.substr(0, kFzAbsoluteDirectory.length()) == kFzAbsoluteDirectory) {
+    log_file_open(path, regs.rdx, pid);
+    return;
+  }
+  if (path[0] == '/' && path.length() > 1) {
+    std::string path_absolute_topdir = path;
+    size_t root_dir_end = path.find('/', 1);
+    if (root_dir_end != std::string::npos) {
+      path_absolute_topdir = path.substr(0, root_dir_end);
+    }
+    if (has_unprintable(path_absolute_topdir)) {
+      struct stat dirstat;
+      if (stat(path_absolute_topdir.c_str(), &dirstat) != 0) {
+        log_file_open(path, regs.rdx, pid);
+      }
+    }
+  }
+}
+
+int trace(std::map<pid_t, Tracee> pids) {
+  unsigned long exit_status = 0;
+  while (!pids.empty()) {
+    std::vector<pid_t> new_pids;
+
+    auto it = pids.begin();
+
+    while (it != pids.end()) {
+      auto pid = it->first;
+      auto &tracee = it->second;
+      int status = 0;
+
+      int result = waitpid(pid, &status, __WALL | WNOHANG);
+      if (result == -1) {
+        it = pids.erase(it);
+        continue;
+      }
+
+      if (result == 0) {
+        // Nothing to report yet.
+        ++it;
+        continue;
+      }
+
+      if (WIFEXITED(status) || WIFSIGNALED(status)) {
+        debug_log("%d exited", pid);
+        it = pids.erase(it);
+        // Remove pid from the watchlist when it exits
+        g_shell_pids.erase(pid);
+        root_pids.erase(pid);
+        continue;
+      }
+
+      // ptrace sets 0x80 for syscalls (with PTRACE_O_TRACESYSGOOD set).
+      bool is_syscall =
+          WIFSTOPPED(status) && WSTOPSIG(status) == (SIGTRAP | 0x80);
+      int sig = 0;
+      if (!is_syscall) {
+        // Handle generic signal.
+        siginfo_t siginfo;
+        if (ptrace(PTRACE_GETSIGINFO, pid, nullptr, &siginfo) == -1) {
+          debug_log("ptrace(PTRACE_GETSIGINFO, %d): %s", pid, strerror(errno));
+          continue;
+        }
+        sig = siginfo.si_signo;
+        debug_log("forwarding signal %d to %d", sig, pid);
+      }
+
+      if ((status >> 8 == (SIGTRAP | (PTRACE_EVENT_EXIT << 8)))) {
+        debug_log("%d exiting", pid);
+        if (pid == g_root_pid) {
+          if (ptrace(PTRACE_GETEVENTMSG, pid, 0, &exit_status) == -1) {
+            debug_log("ptrace(PTRACE_GETEVENTMSG, %d): %s", pid, strerror(errno));
+          }
+          debug_log("got exit status from root process: %lu", exit_status);
+        }
+
+        if (ptrace(PTRACE_DETACH, pid, 0, 0) == -1) {
+          debug_log("ptrace(PTRACE_DETACH, %d): %s", pid, strerror(errno));
+        }
+        continue;
+      }
+
+      if (WIFSTOPPED(status) &&
+          (status >> 8 == (SIGTRAP | (PTRACE_EVENT_CLONE << 8)) ||
+           status >> 8 == (SIGTRAP | (PTRACE_EVENT_FORK << 8)) ||
+           status >> 8 == (SIGTRAP | (PTRACE_EVENT_VFORK << 8)))) {
+        long new_pid;
+        if (ptrace(PTRACE_GETEVENTMSG, pid, 0, &new_pid) == -1) {
+          debug_log("ptrace(PTRACE_GETEVENTMSG, %d): %s", pid, strerror(errno));
+          continue;
+        }
+        debug_log("forked %ld", new_pid);
+        new_pids.push_back(new_pid);
+        root_pids.emplace(new_pid, ThreadParent(pid));
+      }
+
+      if (is_syscall) {
+        user_regs_struct regs;
+        if (ptrace(PTRACE_GETREGS, pid, 0, &regs) == -1) {
+          debug_log("ptrace(PTRACE_GETREGS, %d): %s", pid, strerror(errno));
+          continue;
+        }
+
+        if (tracee.syscall_enter) {
+          if (regs.orig_rax == __NR_execve) {
+            // This is a new process.
+            auto parent = root_pids[pid];
+            parent.ran_exec = true;
+            root_pids[pid] = parent;
+            inspect_for_injection(pid, regs);
+            std::string shell = get_shell(pid, regs);
+            if (shell != "") {
+              debug_log("Shell parsed: %s", shell.c_str());
+              g_shell_pids.insert(std::make_pair(pid, shell));
+            }
+          }
+
+          inspect_dns_syscalls(pid, regs);
+
+          if (regs.orig_rax == __NR_openat) {
+            // TODO(metzman): Re-enable this once we have config/flag support.
+            // inspect_for_arbitrary_file_open(pid, regs);
+          }
+
+          if (regs.orig_rax == __NR_write &&
+              g_shell_pids.find(pid) != g_shell_pids.end()) {
+            debug_log("Inspecting the `write` buffer of shell process %d.",
+                      pid);
+            inspect_for_corruption(pid, regs);
+          }
+        }
+
+        // TODO: Check for commands with invalid syntax passed to /bin/sh and
+        // other shells.
+        // TODO: It's possible the process we're fuzzing can communicate with
+        // another process to execute code. Our check wouldn't catch this
+        // currently.
+        tracee.syscall_enter = !tracee.syscall_enter;
+      }
+
+      if (ptrace(PTRACE_SYSCALL, pid, nullptr, sig) == -1) {
+        debug_log("ptrace(PTRACE_SYSCALL, %d): %s", pid, strerror(errno));
+        continue;
+      }
+
+      ++it;
+    }
+
+    for (const auto &pid : new_pids) {
+      pids.emplace(pid, Tracee(pid));
+    }
+  }
+  return static_cast<int>(exit_status >> 8);
+}
+
+int main(int argc, char **argv) {
+  if (argc <= 1) {
+    fatal_log("Expecting at least one arguments, received %d", argc - 1);
+  }
+
+  // Create an executable tripwire file, as programs may check for existence
+  // before actually calling exec.
+  std::ofstream tripwire(kTripWire);
+  tripwire.close();
+  chmod(kTripWire.c_str(), 0755);
+
+  pid_t pid = run_child(argv + 1);
+
+  long options = PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACEFORK |
+                 PTRACE_O_TRACEVFORK | PTRACE_O_TRACECLONE |
+                 PTRACE_O_TRACEEXIT;
+
+  if (ptrace(PTRACE_SEIZE, pid, nullptr, options) == -1) {
+    fatal_log("ptrace(PTRACE_SEIZE): %s", strerror(errno));
+  }
+
+  if (waitpid(pid, nullptr, __WALL) == -1) {
+    fatal_log("waitpid: %s", strerror(errno));
+  }
+
+  if (ptrace(PTRACE_SYSCALL, pid, 0, 0) == -1) {
+    fatal_log("ptrace(PTRACE_SYSCALL): %s", strerror(errno));
+  }
+
+  g_root_pid = pid;
+  std::map<pid_t, Tracee> pids;
+  pids.emplace(pid, Tracee(pid));
+  root_pids.emplace(pid, ThreadParent(pid));
+  return trace(pids);
+}

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/inspect_dns.cpp

@@ -0,0 +1,236 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * 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
+
+ *      http://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.
+ */
+/* A detector that uses ptrace to identify shell injection vulnerabilities. */
+
+/* POSIX */
+#include <sys/user.h>
+#include <unistd.h>
+
+/* Linux */
+#include <arpa/inet.h>
+#include <syscall.h>
+#include <sys/ptrace.h>
+
+#include <iostream>
+
+#include "inspect_utils.h"
+
+
+// Arbitrary domain name resolution.
+const std::string kArbitraryDomainNameResolution = "Arbitrary domain name resolution";
+
+// Global constant for one file descriptor about of a DNS socket
+int kFdDns = 0;
+const size_t kDnsHeaderLen = 12;
+
+
+void inspect_for_arbitrary_dns_connect(pid_t pid, const user_regs_struct &regs) {
+  auto memory = read_memory(pid, regs.rsi, sizeof(struct sockaddr_in));
+  if (memory.size()) {
+    struct sockaddr_in * sa = reinterpret_cast<struct sockaddr_in *>(memory.data());
+    if (sa->sin_family == AF_INET && htons(sa->sin_port) == 53) {
+      // save file descriptor for later sendmmsg
+      kFdDns = regs.rdi;
+    }
+  }
+}
+
+struct DnsHeader {
+  uint16_t tx_id;
+  uint16_t flags;
+  uint16_t questions;
+  uint16_t answers;
+  uint16_t nameservers;
+  uint16_t additional;
+};
+
+struct DnsHeader parse_dns_header(std::vector<std::byte> data) {
+  struct DnsHeader h;
+  h.tx_id = (((uint16_t) data[0]) << 8) | ((uint16_t) data[1]);
+  h.flags = (((uint16_t) data[2]) << 8) | ((uint16_t) data[3]);
+  h.questions = (((uint16_t) data[4]) << 8) | ((uint16_t) data[5]);
+  h.answers = (((uint16_t) data[6]) << 8) | ((uint16_t) data[7]);
+  h.nameservers = (((uint16_t) data[8]) << 8) | ((uint16_t) data[9]);
+  h.additional = (((uint16_t) data[10]) << 8) | ((uint16_t) data[11]);
+  return h;
+}
+
+bool dns_flags_standard_query(uint16_t flags) {
+  if ((flags & 0x8000) == 0) {
+    // Query, not response.
+    if (((flags & 0x7800) >> 11) == 0) {
+      // Opcode 0 is standard query.
+      if ((flags & 0x0200) == 0) {
+        // Message is not truncated.
+        if ((flags & 0x0040) == 0) {
+          // Z-bit reserved flag is unset.
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+struct DnsRequest {
+  // Start of name in the byte vector.
+  size_t offset;
+  // End of name in the byte vector.
+  size_t end;
+  // Length of top level domain.
+  uint8_t tld_size;
+  // Number of levels/dots in domain name.
+  size_t nb_levels;
+  // DNS type like A is 1.
+  uint16_t dns_type;
+  // DNS class like IN is 1.
+  uint16_t dns_class;
+};
+
+struct DnsRequest parse_dns_request(std::vector<std::byte> data, size_t offset) {
+  struct DnsRequest r;
+  r.offset = offset;
+  r.tld_size = 0;
+  r.nb_levels = 0;
+  while(offset < data.size()) {
+    uint8_t rlen = uint8_t(data[offset]);
+    if (rlen == 0) {
+      offset++;
+      break;
+    }
+    r.nb_levels++;
+    offset += rlen+1;
+    r.tld_size = rlen;
+  }
+  if (offset <= 4 + data.size()) {
+    r.end = offset;
+    r.dns_type = (((uint16_t) data[offset]) << 8) | ((uint16_t) data[offset+1]);
+    r.dns_class = (((uint16_t) data[offset+2]) << 8) | ((uint16_t) data[offset+3]);
+  } else {
+    r.end = data.size();
+  }
+  return r;
+}
+
+void log_dns_request(struct DnsRequest r, std::vector<std::byte> data) {
+  size_t offset = r.offset;
+  std::cerr << "===Domain resolved: ";
+  while(offset < r.end) {
+    uint8_t rlen = uint8_t(data[offset]);
+    if (rlen == 0) {
+      break;
+    }
+    std::cerr << '.';
+    for (uint8_t i = 1; i < rlen+1; i++) {
+      std::cerr << (char) data[offset + i];
+    }
+    offset += rlen+1;
+  }
+  std::cerr << "===\n";
+  std::cerr << "===DNS request type: " << r.dns_type << ", class: " << r.dns_class << "===\n";
+}
+
+void inspect_for_arbitrary_dns_pkt(std::vector<std::byte> data, pid_t pid) {
+  if (data.size() < kDnsHeaderLen + 1) {
+    return;
+  }
+  struct DnsHeader h = parse_dns_header(data);
+  if (h.questions != 1) {
+    return;
+  }
+  if (h.answers != 0 || h.nameservers != 0) {
+    return;
+  }
+  if (!dns_flags_standard_query(h.flags)) {
+    return;
+  }
+
+  struct DnsRequest req = parse_dns_request(data, kDnsHeaderLen);
+  // Alert if the top level domain is only one character and
+  // if there is more than just the TLD.
+  if (req.tld_size == 1 && req.nb_levels > 1 && req.end < data.size()) {
+    report_bug(kArbitraryDomainNameResolution, pid);
+    log_dns_request(req, data);
+  }
+}
+
+void inspect_for_arbitrary_dns_fdbuffer(pid_t pid, const user_regs_struct &regs) {
+  if (kFdDns > 0 && kFdDns == (int) regs.rdi) {
+    auto memory = read_memory(pid, regs.rsi, regs.rdx);
+    if (memory.size()) {
+      inspect_for_arbitrary_dns_pkt(memory, pid);
+    }
+  }
+}
+
+void inspect_for_arbitrary_dns_iov(pid_t pid, unsigned long iov) {
+  auto memory = read_memory(pid, iov, sizeof(struct iovec));
+  if (memory.size()) {
+    struct iovec * iovec = reinterpret_cast<struct iovec *>(memory.data());
+    memory = read_memory(pid, (unsigned long) iovec->iov_base, iovec->iov_len);
+    if (memory.size()) {
+      inspect_for_arbitrary_dns_pkt(memory, pid);
+    }
+  }
+}
+
+void inspect_for_arbitrary_dns_sendmsg(pid_t pid, const user_regs_struct &regs) {
+  if (kFdDns > 0 && kFdDns == (int) regs.rdi) {
+    auto memory = read_memory(pid, regs.rsi, sizeof(struct msghdr));
+    if (memory.size()) {
+      struct msghdr * msg = reinterpret_cast<struct msghdr *>(memory.data());
+      if (msg->msg_iovlen == 1) {
+        inspect_for_arbitrary_dns_iov(pid, (unsigned long) msg->msg_iov);
+      }
+    }
+  }
+}
+
+void inspect_for_arbitrary_dns_sendmmsg(pid_t pid, const user_regs_struct &regs) {
+  if (kFdDns > 0 && kFdDns == (int) regs.rdi) {
+    auto memory = read_memory(pid, regs.rsi, sizeof(struct mmsghdr));
+    if (memory.size()) {
+      struct mmsghdr * msg = reinterpret_cast<struct mmsghdr *>(memory.data());
+      if (msg->msg_hdr.msg_iovlen == 1) {
+        inspect_for_arbitrary_dns_iov(pid, (unsigned long) msg->msg_hdr.msg_iov);
+      }
+    }
+  }
+}
+
+void inspect_dns_syscalls(pid_t pid, const user_regs_struct &regs) {
+  switch (regs.orig_rax) {
+    case __NR_connect:
+      inspect_for_arbitrary_dns_connect(pid, regs);
+      break;
+    case __NR_close:
+      if (kFdDns > 0 && kFdDns == (int) regs.rdi) {
+        // reset DNS file descriptor on close
+        kFdDns = 0;
+      }
+      break;
+    case __NR_sendmmsg:
+      inspect_for_arbitrary_dns_sendmmsg(pid, regs);
+      break;
+    case __NR_sendmsg:
+      inspect_for_arbitrary_dns_sendmsg(pid, regs);
+      break;
+    case __NR_sendto:
+      // fallthrough
+    case __NR_write:
+      inspect_for_arbitrary_dns_fdbuffer(pid, regs);
+  }
+}

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/inspect_utils.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * 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
+
+ *      http://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.
+ */
+/* A detector that uses ptrace to identify DNS arbitrary resolutions. */
+
+
+/* POSIX */
+#include <unistd.h>
+
+#include <string>
+#include <vector>
+
+// Structure to know which thread id triggered the bug.
+struct ThreadParent {
+  // Parent thread ID, ie creator.
+  pid_t parent_tid;
+  // Current thread ID ran exec to become another process.
+  bool ran_exec = false;
+
+  ThreadParent() : parent_tid(0) {}
+  ThreadParent(pid_t tid) : parent_tid(tid) {}
+};
+
+std::vector<std::byte> read_memory(pid_t pid, unsigned long long address,
+                                   size_t size);
+
+void report_bug(std::string bug_type, pid_t tid);

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/target.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * 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
+
+ *      http://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.
+*/
+/* A sample target program under test,
+ * /tmp/tripwire or other commands will be injected into its shell command */
+
+#include <stdlib.h>
+#include <string>
+#include <iostream>
+
+extern "C" int LLVMFuzzerTestOneInput(char* data, size_t size) {
+  std::string str(data, size);
+  std::cout << "INPUT" << str << std::endl;
+  system(str.c_str());
+  return 0;
+}

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/target_dns.cpp

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2022 Google LLC
+
+ * 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
+
+ *      http://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.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+#include <iostream>
+
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+
+extern "C" int LLVMFuzzerTestOneInput(char* data, size_t size) {
+  std::string str(data, size);
+  std::cout << "INPUT" << str << std::endl;
+
+  struct addrinfo *result = NULL;
+
+  getaddrinfo(str.c_str(), NULL, NULL, &result);
+  if (result) {
+    freeaddrinfo(result);
+  }
+
+  return 0;
+}

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/SystemSan/vuln.dict

@@ -0,0 +1,3 @@
+"/tmp/tripwire"
+"/fz/"
+"f.z"

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/chronos/build_cache_local.sh

@@ -0,0 +1,163 @@
+#!/bin/bash -eu
+# Copyright 2024 Google LLC
+#
+# 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
+#
+#      http://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.
+#
+################################################################################
+
+_PROJECT=$1
+_FUZZING_LANGUAGE=$2
+_SANITIZER=${3:-address}
+
+BASE=$PWD
+
+# Final image is either ccache or replay script, depending on which worked.
+FINAL_IMAGE_NAME=us-central1-docker.pkg.dev/oss-fuzz/oss-fuzz-gen/${_PROJECT}-ofg-cached-${_SANITIZER}
+
+# Always build an image with ccache.
+CCACHE_IMAGE_NAME=us-central1-docker.pkg.dev/oss-fuzz/oss-fuzz-gen/${_PROJECT}-ofg-ccache-${_SANITIZER}
+
+# Step 1: build the base image
+cd projects/${_PROJECT}
+docker build -t gcr.io/oss-fuzz/${_PROJECT} .
+
+
+# Step 2: create a container where `compile` has run which enables ccaching
+#         and also generates a replay build script.
+cd ${BASE}
+mkdir -p ccaches/${_PROJECT}
+mkdir -p build/out/${_PROJECT}
+B_START=$SECONDS
+
+docker container rm -f ${_PROJECT}-origin-${_SANITIZER}
+
+docker run \
+  --env=SANITIZER=${_SANITIZER} \
+  --env=CCACHE_DIR=/workspace/ccache \
+  --env=FUZZING_LANGUAGE=${_FUZZING_LANGUAGE} \
+  --env=CAPTURE_REPLAY_SCRIPT=1 \
+  --name=${_PROJECT}-origin-${_SANITIZER} \
+  -v=$PWD/ccaches/${_PROJECT}/ccache:/workspace/ccache \
+  -v=$PWD/build/out/${_PROJECT}/:/out/ \
+  gcr.io/oss-fuzz/${_PROJECT} \
+  /bin/bash -c \
+  "export PATH=/ccache/bin:\$PATH && compile"
+B_TIME=$(($SECONDS - $B_START))
+
+# Step 3: save (commit, locally) the cached container as an image
+docker container commit -c "ENV REPLAY_ENABLED=1" -c "ENV CAPTURE_REPLAY_SCRIPT=" ${_PROJECT}-origin-${_SANITIZER} $FINAL_IMAGE_NAME
+
+# Step 4: save the list of executables created from a vanilla build. This is
+#         needed for validating if replay and ccaching works.
+# notes: run a shell the container with e.g.
+# `docker run --entrypoint /bin/bash  -it local/ossfuzz/htslib-origin-address`
+executables_vanilla="$(find ./build/out/${_PROJECT} -executable -type f | sort)"
+
+
+# Step 5: Build with replay enabled, and validate the executables are the same
+# in terms of naming.
+# Note that an important step is removing everything in $OUT/ which is done
+# in the docker command.
+R_START=$SECONDS
+docker run \
+  --rm \
+  --env=SANITIZER=${_SANITIZER} \
+  --env=FUZZING_LANGUAGE=${_FUZZING_LANGUAGE} \
+  -v=$PWD/build/out/${_PROJECT}/:/out/ \
+  --name=${_PROJECT}-origin-${_SANITIZER}-replay-recached \
+  $FINAL_IMAGE_NAME \
+  /bin/bash -c \
+  "export PATH=/ccache/bin:\$PATH && rm -rf /out/* && compile"
+R_TIME=$(($SECONDS - $R_START))
+
+# Step 6: Extract the newly build executables
+executables_replay="$(find ./build/out/${_PROJECT}/ -executable -type f | sort)"
+
+echo "Executables vanilla: "
+echo ${executables_vanilla}
+
+echo "------------------------------------------------------"
+echo "Executables replay: "
+echo ${executables_replay}
+
+REPLAY_WORKED=
+
+# Step 7: match executables from vanilla builds and replay builds.
+#         If this step is successful, then the process can exit as it's ready.
+if [[ "$executables_replay" == "$executables_vanilla" ]]
+then
+  REPLAY_WORKED=1
+
+  if [ -z "${RUN_ALL+1}" ]; then
+    echo "${_PROJECT}: Replay worked."
+    echo "${_PROJECT}: Compile times: Vanilla=${B_TIME}; Replay=${R_TIME};"
+    exit 0
+  fi
+else
+  echo "${_PROJECT}: Replay did not work"
+  R_TIME="N/A"
+fi
+
+# Step 8: prepare Dockerfile for ccache
+cp -rf ccaches/${_PROJECT}/ccache ./projects/${_PROJECT}/ccache-cache
+
+infra/experimental/chronos/prepare-ccache ${_PROJECT}
+
+cd projects/${_PROJECT}
+
+# Step 9: Build an image with CCache's new items (modifications are done on the
+#         dockerfile)
+docker build -t $CCACHE_IMAGE_NAME .
+
+cd ${BASE}
+
+# Step 10: Run a `compile` with ccache's image.
+# Run the ccache build
+A_START=$SECONDS
+docker run \
+  --rm \
+  --env=SANITIZER=${_SANITIZER} \
+  --env=FUZZING_LANGUAGE=${_FUZZING_LANGUAGE} \
+  --name=${_PROJECT}-origin-${_SANITIZER}-recached \
+  -v=$PWD/build/out/${_PROJECT}/:/out/ \
+  $CCACHE_IMAGE_NAME \
+  /bin/bash -c \
+  "export PATH=/ccache/bin:\$PATH && rm -rf /out/* && compile"
+A_TIME=$(($SECONDS - $A_START))
+
+# Step 11: extract the executables from the ccache build
+executables_ccache="$(find ./build/out/${_PROJECT}/ -executable -type f | sort)"
+
+
+# Step 12: validate the ccache builds are successful
+if [[ "$executables_ccache" == "$executables_vanilla" ]]
+then
+  echo "${_PROJECT}: Compile times: Vanilla=${B_TIME}; Replay=${R_TIME}; CCache=${A_TIME};"
+
+  if [[ -z "${REPLAY_WORKED}" || ${R_TIME} -gt ${A_TIME} ]]; then
+    if [ ${R_TIME} -gt ${A_TIME} ]; then
+      echo "Replay was slower than ccache."
+    fi
+
+    # Replay didn't work or was slower, so make the default "cached" image use the ccache one.
+    docker image tag \
+      $CCACHE_IMAGE_NAME \
+      $FINAL_IMAGE_NAME
+  fi
+
+  exit 0
+else
+  echo "${_PROJECT}: Replay and ccaching did not work."
+  exit 1
+fi
+

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/chronos/build_on_cloudbuild.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Copyright 2024 Google LLC
+#
+# 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
+#
+#      http://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.
+#
+################################################################################
+PROJECT=$1
+FUZZING_LANGUAGE=$2
+
+gcloud builds submit "https://github.com/google/oss-fuzz" \
+  --async \
+  --git-source-revision=master \
+  --config=cloudbuild.yaml \
+  --substitutions=_PROJECT=$PROJECT,_FUZZING_LANGUAGE=$FUZZING_LANGUAGE \
+  --project=oss-fuzz \
+  --region=us-central1

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/chronos/cloudbuild.yaml

@@ -0,0 +1,58 @@
+# Copyright 2024 Google LLC
+#
+# 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
+#
+#      http://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.
+#
+################################################################################
+# CloudBuild for generating Chronos-cached images.
+# Supports building by way of ccache now.
+# High-level steps:
+# 1) Build image for project
+# 2) Run an ASAN build and store ccache
+# 3) Copy ccache cache to host and copy into project's OSS-Fuzz folder
+# 4) Build image for project and copy ccache in, storing image as *-ofg-cache-address
+# 5) Run an coverage build and store ccache
+# 6) Copy ccache cache to host and copy into project's OSS-Fuzz folder
+# 7) Build image for project and copy ccache in, storing image as *-ofg-cache-coverage
+# TODO (David): add support for use of dedicated replay_build.sh
+steps:
+- name: 'gcr.io/cloud-builders/docker'
+  entrypoint: /bin/bash
+  args:
+  - /workspace/infra/experimental/chronos/build_cache_local.sh
+  - ${_PROJECT}
+  - ${_FUZZING_LANGUAGE}
+  - address
+  env:
+  - RUN_ALL=1
+- name: 'gcr.io/cloud-builders/docker'
+  entrypoint: /bin/bash
+  args:
+  - /workspace/infra/experimental/chronos/build_cache_local.sh
+  - ${_PROJECT}
+  - ${_FUZZING_LANGUAGE}
+  - coverage
+  env:
+  - RUN_ALL=1
+images:
+- us-central1-docker.pkg.dev/oss-fuzz/oss-fuzz-gen/${_PROJECT}-ofg-cached-address
+- us-central1-docker.pkg.dev/oss-fuzz/oss-fuzz-gen/${_PROJECT}-ofg-cached-coverage
+- us-central1-docker.pkg.dev/oss-fuzz/oss-fuzz-gen/${_PROJECT}-ofg-ccache-address
+- us-central1-docker.pkg.dev/oss-fuzz/oss-fuzz-gen/${_PROJECT}-ofg-ccache-coverage
+timeout: 72000s  # 20 hours, same as build_lib.py
+logsBucket: oss-fuzz-gcb-logs
+tags:
+- ${_PROJECT}
+- chronos
+options:
+  pool:
+    name: projects/oss-fuzz/locations/us-central1/workerPools/buildpool-chronos

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/chronos/cloudbuild_all.yaml

@@ -0,0 +1,34 @@
+# Copyright 2024 Google LLC
+#
+# 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
+#
+#      http://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.
+#
+################################################################################
+# CloudBuild for generating Chronos-cached images.
+steps:
+- name: 'gcr.io/cloud-builders/docker'
+  args:
+  - build
+  - -t
+  - gcloud
+  - .
+  dir: infra/experimental/chronos
+- name: 'gcloud'
+  args:
+  - infra/experimental/chronos/build_all.sh
+  entrypoint: /bin/bash
+timeout: 1800s
+serviceAccount: 'projects/oss-fuzz/serviceAccounts/llm-eval@oss-fuzz.iam.gserviceaccount.com'
+options:
+  logging: CLOUD_LOGGING_ONLY
+tags:
+- chronos-all

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/chronos/e2e-replay-build.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/bash
+# Copyright 2024 Google LLC
+#
+# 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
+#
+#      http://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.
+#
+################################################################################
+
+# Sample projects: simd, wt, libheif, htslib
+PROJECT=liblouis
+LOG=replay-${PROJECT}.txt
+OUT1=replay-out-${PROJECT}-1
+OUT2=replay-out-${PROJECT}-2
+python infra/helper.py build_image --no-pull  "$PROJECT"
+
+# AddressSanitizer.
+mkdir -p build/out/${PROJECT}
+echo "start" >> ${LOG}
+echo $(date +%Y:%m:%d:%H:%M:%S) >> ${LOG}
+# Remove container name we are about to use.
+docker container rm "${PROJECT}-origin-asan"
+
+# Build once, clean container if needed
+docker run -v $PWD/build/out/${PROJECT}:/out \
+    -ti --entrypoint="/bin/sh" \
+    --env FUZZING_LANGUAGE=c  --env SANITIZER="address" \
+    --name "${PROJECT}-origin-asan" \
+    "gcr.io/oss-fuzz/${PROJECT}" -c "compile"
+
+# Copy outs and log data
+cp -rf $PWD/build/out/${PROJECT} ${OUT1}
+rm -rf $PWD/build/out/${PROJECT}
+ls -la $PWD/build/out/ >> ${LOG}
+echo "next" >> ${LOG}
+echo $(date +%Y:%m:%d:%H:%M:%S) >> ${LOG}
+docker commit "${PROJECT}-origin-asan" "gcr.io/oss-fuzz/${PROJECT}-ofg-cached-asan"
+
+# Run the replay command
+docker run -v $PWD/build/out/${PROJECT}:/out \
+    -e REPLAY_ENABLED=1 -ti --entrypoint="/bin/sh" \
+    --env FUZZING_LANGUAGE=c --env SANITIZER="address" \
+    "gcr.io/oss-fuzz/${PROJECT}-ofg-cached-asan" -c "compile"
+echo "finish" >> ${LOG}
+echo $(date +%Y:%m:%d:%H:%M:%S) >> ${LOG}
+cp -rf $PWD/build/out/${PROJECT} ${OUT2}
+
+# Now match the artifacts
+SUCCESS=$(infra/experimental/chronos/match_artifacts $OUT1 $OUT2)
+
+if [[ $SUCCESS -eq 0 ]]; then
+  echo "SUCCESS REPLAY" >> ${LOG}
+else
+  echo "FAIL REPLAY" >> ${LOG}
+fi

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/chronos/match_artifacts.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/bash -eux
+# Copyright 2024 Google LLC
+#
+# 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
+#
+#      http://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.
+#
+################################################################################
+
+CMP1=$1
+CMP2=$2
+
+for exec1 in $(find $CMP1/ -type f -executable); do
+  base=$(basename $exec1)
+
+  exec2=$CMP2/${base}
+  if [ ! -f ${exec2} ]; then
+    exit 1
+  fi
+
+  comparison=$(cmp --silent $exec1 $exec2; echo $?)
+  if [[ $comparison -ne 0 ]]; then
+    exit 1
+  fi
+done
+
+exit 0

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/experimental/chronos/prepare-replay-rebuild

@@ -0,0 +1,21 @@
+#!/usr/bin/bash
+# Copyright 2024 Google LLC
+#
+# 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
+#
+#      http://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.
+#
+################################################################################
+
+PROJECT=$1
+{
+    echo "ENV REPLAY_ENABLED=1";
+} >> "projects/$PROJECT/Dockerfile"

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/helper_test.py

@@ -0,0 +1,239 @@
+# Copyright 2021 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Tests for helper.py"""
+
+import datetime
+import os
+import tempfile
+import unittest
+from unittest import mock
+
+from pyfakefs import fake_filesystem_unittest
+
+import constants
+import helper
+import templates
+
+# pylint: disable=no-self-use,protected-access
+
+
+class ShellTest(unittest.TestCase):
+  """Tests 'shell' command."""
+
+  @mock.patch('helper.docker_run')
+  @mock.patch('helper.build_image_impl')
+  def test_base_runner_debug(self, _, __):
+    """Tests that shell base-runner-debug works as intended."""
+    image_name = 'base-runner-debug'
+    unparsed_args = ['shell', image_name]
+    parser = helper.get_parser()
+    args = helper.parse_args(parser, unparsed_args)
+    args.sanitizer = 'address'
+    result = helper.shell(args)
+    self.assertTrue(result)
+
+
+class BuildImageImplTest(unittest.TestCase):
+  """Tests for build_image_impl."""
+
+  @mock.patch('helper.docker_build')
+  def test_no_cache(self, mock_docker_build):
+    """Tests that cache=False is handled properly."""
+    image_name = 'base-image'
+    helper.build_image_impl(helper.Project(image_name), cache=False)
+    self.assertIn('--no-cache', mock_docker_build.call_args_list[0][0][0])
+
+  @mock.patch('helper.docker_build')
+  @mock.patch('helper.pull_images')
+  def test_pull(self, mock_pull_images, _):
+    """Tests that pull=True is handled properly."""
+    image_name = 'base-image'
+    project = helper.Project(image_name, is_external=True)
+    self.assertTrue(helper.build_image_impl(project, pull=True))
+    mock_pull_images.assert_called_with('c++')
+
+  @mock.patch('helper.docker_build')
+  def test_base_image(self, mock_docker_build):
+    """Tests that build_image_impl works as intended with a base-image."""
+    image_name = 'base-image'
+    self.assertTrue(helper.build_image_impl(helper.Project(image_name)))
+    build_dir = os.path.join(helper.OSS_FUZZ_DIR,
+                             'infra/base-images/base-image')
+    mock_docker_build.assert_called_with([
+        '-t', 'ghcr.io/aixcc-finals/base-image', '--file',
+        os.path.join(build_dir, 'Dockerfile'), build_dir
+    ])
+
+  @mock.patch('helper.docker_build')
+  def test_oss_fuzz_project(self, mock_docker_build):
+    """Tests that build_image_impl works as intended with an OSS-Fuzz
+    project."""
+    project_name = 'example'
+    self.assertTrue(helper.build_image_impl(helper.Project(project_name)))
+    build_dir = os.path.join(helper.OSS_FUZZ_DIR, 'projects', project_name)
+    mock_docker_build.assert_called_with([
+        '-t', 'gcr.io/oss-fuzz/example', '--file',
+        os.path.join(build_dir, 'Dockerfile'), build_dir
+    ])
+
+  @mock.patch('helper.docker_build')
+  def test_external_project(self, mock_docker_build):
+    """Tests that build_image_impl works as intended with a non-OSS-Fuzz
+    project."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+      project_src_path = os.path.join(temp_dir, 'example')
+      os.mkdir(project_src_path)
+      build_integration_path = 'build-integration'
+      project = helper.Project(project_src_path,
+                               is_external=True,
+                               build_integration_path=build_integration_path)
+      self.assertTrue(helper.build_image_impl(project))
+      mock_docker_build.assert_called_with([
+          '-t', 'gcr.io/oss-fuzz/example', '--file',
+          os.path.join(project_src_path, build_integration_path, 'Dockerfile'),
+          project_src_path
+      ])
+
+
+class GenerateImplTest(fake_filesystem_unittest.TestCase):
+  """Tests for _generate_impl."""
+  PROJECT_NAME = 'newfakeproject'
+  PROJECT_LANGUAGE = 'python'
+
+  def setUp(self):
+    self.maxDiff = None  # pylint: disable=invalid-name
+    self.setUpPyfakefs()
+    self.fs.add_real_directory(helper.OSS_FUZZ_DIR)
+
+  def _verify_templated_files(self, template_dict, directory, language):
+    template_args = {
+        'project_name': self.PROJECT_NAME,
+        'year': 2021,
+        'base_builder': helper._base_builder_from_language(language),
+        'language': language,
+    }
+    for filename, template in template_dict.items():
+      file_path = os.path.join(directory, filename)
+      with open(file_path, 'r') as file_handle:
+        contents = file_handle.read()
+      self.assertEqual(contents, template % template_args)
+
+  @mock.patch('helper._get_current_datetime',
+              return_value=datetime.datetime(year=2021, month=1, day=1))
+  def test_generate_oss_fuzz_project(self, _):
+    """Tests that the correct files are generated for an OSS-Fuzz project."""
+    helper._generate_impl(helper.Project(self.PROJECT_NAME),
+                          self.PROJECT_LANGUAGE)
+    self._verify_templated_files(
+        templates.TEMPLATES,
+        os.path.join(helper.OSS_FUZZ_DIR, 'projects', self.PROJECT_NAME),
+        self.PROJECT_LANGUAGE)
+
+  def test_generate_external_project(self):
+    """Tests that the correct files are generated for a non-OSS-Fuzz project."""
+    build_integration_path = '/newfakeproject/build-integration'
+    helper._generate_impl(
+        helper.Project('/newfakeproject/',
+                       is_external=True,
+                       build_integration_path=build_integration_path),
+        self.PROJECT_LANGUAGE)
+    self._verify_templated_files(templates.EXTERNAL_TEMPLATES,
+                                 build_integration_path, self.PROJECT_LANGUAGE)
+
+  @mock.patch('helper._get_current_datetime',
+              return_value=datetime.datetime(year=2021, month=1, day=1))
+  def test_generate_swift_project(self, _):
+    """Tests that the swift project uses the correct base image."""
+    helper._generate_impl(helper.Project(self.PROJECT_NAME), 'swift')
+    self._verify_templated_files(
+        templates.TEMPLATES,
+        os.path.join(helper.OSS_FUZZ_DIR, 'projects', self.PROJECT_NAME),
+        'swift')
+
+
+class ProjectTest(fake_filesystem_unittest.TestCase):
+  """Tests for Project class."""
+
+  def setUp(self):
+    self.project_name = 'project'
+    self.internal_project = helper.Project(self.project_name)
+    self.external_project_path = os.path.join('/path', 'to', self.project_name)
+    self.external_project = helper.Project(self.external_project_path,
+                                           is_external=True)
+    self.setUpPyfakefs()
+
+  def test_init_external_project(self):
+    """Tests __init__ method for external projects."""
+    self.assertEqual(self.external_project.name, self.project_name)
+    self.assertEqual(self.external_project.path, self.external_project_path)
+    self.assertEqual(
+        self.external_project.build_integration_path,
+        os.path.join(self.external_project_path,
+                     constants.DEFAULT_EXTERNAL_BUILD_INTEGRATION_PATH))
+
+  def test_init_internal_project(self):
+    """Tests __init__ method for internal projects."""
+    self.assertEqual(self.internal_project.name, self.project_name)
+    path = os.path.join(helper.OSS_FUZZ_DIR, 'projects', self.project_name)
+    self.assertEqual(self.internal_project.path, path)
+    self.assertEqual(self.internal_project.build_integration_path, path)
+
+  def test_dockerfile_path_internal_project(self):
+    """Tests that dockerfile_path works as intended."""
+    self.assertEqual(
+        self.internal_project.dockerfile_path,
+        os.path.join(helper.OSS_FUZZ_DIR, 'projects', self.project_name,
+                     'Dockerfile'))
+
+  def test_dockerfile_path_external_project(self):
+    """Tests that dockerfile_path works as intended."""
+    self.assertEqual(
+        self.external_project.dockerfile_path,
+        os.path.join(self.external_project_path,
+                     constants.DEFAULT_EXTERNAL_BUILD_INTEGRATION_PATH,
+                     'Dockerfile'))
+
+  def test_out(self):
+    """Tests that out works as intended."""
+    out_dir = self.internal_project.out
+    self.assertEqual(
+        out_dir,
+        os.path.join(helper.OSS_FUZZ_DIR, 'build', 'out', self.project_name))
+    self.assertTrue(os.path.exists(out_dir))
+
+  def test_work(self):
+    """Tests that work works as intended."""
+    work_dir = self.internal_project.work
+    self.assertEqual(
+        work_dir,
+        os.path.join(helper.OSS_FUZZ_DIR, 'build', 'work', self.project_name))
+    self.assertTrue(os.path.exists(work_dir))
+
+  def test_corpus(self):
+    """Tests that corpus works as intended."""
+    corpus_dir = self.internal_project.corpus
+    self.assertEqual(
+        corpus_dir,
+        os.path.join(helper.OSS_FUZZ_DIR, 'build', 'corpus', self.project_name))
+    self.assertTrue(os.path.exists(corpus_dir))
+
+  def test_language_internal_project(self):
+    """Tests that language works as intended for an internal project."""
+    project_yaml_path = os.path.join(self.internal_project.path, 'project.yaml')
+    self.fs.create_file(project_yaml_path, contents='language: python')
+    self.assertEqual(self.internal_project.language, 'python')
+
+  def test_language_external_project(self):
+    """Tests that language works as intended for an external project."""
+    self.assertEqual(self.external_project.language, 'c++')

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/presubmit.py

@@ -0,0 +1,549 @@
+#!/usr/bin/env python3
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#        http://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.
+#
+################################################################################
+"""Checks code for common issues before submitting."""
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+import unittest
+import yaml
+
+import constants
+
+_SRC_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+VALID_PROJECT_REGEX_STR = '^[a-z0-9_-]+$'
+VALID_PROJECT_REGEX = re.compile(VALID_PROJECT_REGEX_STR)
+
+
+def _is_project_file(actual_path, expected_filename):
+  """Returns True if actual_path's name is |expected_filename| and is a file
+  that exists and is in in projects/."""
+  if os.path.basename(actual_path) != expected_filename:
+    return False
+
+  if os.path.basename(os.path.dirname(
+      os.path.dirname(actual_path))) != 'projects':
+    return False
+
+  return os.path.exists(actual_path)
+
+
+# TODO: Check for -fsanitize=fuzzer in files as well.
+
+
+def _check_one_lib_fuzzing_engine(build_sh_file):
+  """Returns False if |build_sh_file| contains -lFuzzingEngine.
+  This is deprecated behavior. $LIB_FUZZING_ENGINE should be used instead
+  so that -fsanitize=fuzzer is used."""
+  if not _is_project_file(build_sh_file, 'build.sh'):
+    return True
+
+  with open(build_sh_file) as build_sh:
+    build_sh_lines = build_sh.readlines()
+  for line_num, line in enumerate(build_sh_lines):
+    uncommented_code = line.split('#')[0]
+    if '-lFuzzingEngine' in uncommented_code:
+      print('Error: build.sh contains deprecated "-lFuzzingEngine" on line: '
+            f'{line_num}. Please use "$LIB_FUZZING_ENGINE" instead.')
+      return False
+  return True
+
+
+def check_lib_fuzzing_engine(paths):
+  """Calls _check_one_lib_fuzzing_engine on each path in |paths|. Returns True
+  if the result of every call is True."""
+  return all(_check_one_lib_fuzzing_engine(path) for path in paths)
+
+
+class ProjectYamlChecker:
+  """Checks for a project.yaml file."""
+
+  # Sections in a project.yaml and the constant values that they are allowed
+  # to have.
+  SECTIONS_AND_CONSTANTS = {
+      'sanitizers': constants.SANITIZERS,
+      'architectures': constants.ARCHITECTURES,
+      'fuzzing_engines': constants.ENGINES,
+  }
+
+  # Note: this list must be updated when we allow new sections.
+  VALID_SECTION_NAMES = [
+      'architectures',
+      'auto_ccs',
+      'blackbox',
+      'builds_per_day',
+      'coverage_extra_args',
+      'disabled',
+      'fuzzing_engines',
+      'help_url',
+      'homepage',
+      'language',
+      'labels',  # For internal use only, hard to lint as it uses fuzzer names.
+      'main_repo',
+      'primary_contact',
+      'run_tests',
+      'sanitizers',
+      'selective_unpack',
+      'vendor_ccs',
+      'view_restrictions',
+      'file_github_issue',
+  ]
+
+  REQUIRED_SECTIONS = ['main_repo']
+
+  def __init__(self, filename):
+    self.filename = filename
+    with open(filename) as file_handle:
+      self.data = yaml.safe_load(file_handle)
+
+    self.success = True
+
+  def do_checks(self):
+    """Does all project.yaml checks. Returns True if they pass."""
+    if self.is_disabled():
+      return True
+
+    checks = [
+        self.check_project_yaml_constants,
+        self.check_required_sections,
+        self.check_valid_section_names,
+        self.check_valid_emails,
+        self.check_valid_language,
+        self.check_valid_project_name,
+    ]
+    for check_function in checks:
+      check_function()
+    return self.success
+
+  def is_disabled(self):
+    """Returns True if this project is disabled."""
+    return self.data.get('disabled', False)
+
+  def error(self, message):
+    """Prints an error message and sets self.success to False."""
+    self.success = False
+    print(f'Error in {self.filename}: {message}')
+
+  def check_valid_project_name(self):
+    """Checks that the project has a valid name."""
+    banned_names = ['google', 'g00gle']
+    project_name = os.path.basename(os.path.dirname(self.filename))
+    for banned_name in banned_names:
+      if banned_name in project_name:
+        self.error('Projects can\'t have \'google\' in the name.')
+    if not VALID_PROJECT_REGEX.match(project_name):
+      self.error(f'Projects must conform to regex {VALID_PROJECT_REGEX_STR}')
+
+  def check_project_yaml_constants(self):
+    """Returns True if certain sections only have certain constant values."""
+    for section, allowed_constants in self.SECTIONS_AND_CONSTANTS.items():
+      if section not in self.data:
+        continue
+      actual_constants = self.data[section]
+      allowed_constants_str = ', '.join(allowed_constants)
+      for constant in actual_constants:
+        if isinstance(constant, str):
+          if constant not in allowed_constants:
+            self.error(f'{constant} (in {section} section) is not a valid '
+                       f'constant ({allowed_constants_str}).')
+        elif isinstance(constant, dict):
+          # The only alternative value allowed is the experimental flag, i.e.
+          # `constant == {'memory': {'experimental': True}}`. Do not check the
+          # experimental flag, but assert that the sanitizer is a valid one.
+          if (len(constant.keys()) > 1 or
+              list(constant.keys())[0] not in allowed_constants):
+            self.error(f'Not allowed value in the project.yaml: {constant}')
+        else:
+          self.error(f'Not allowed value in the project.yaml: {constant}')
+
+  def check_valid_section_names(self):
+    """Returns True if all section names are valid."""
+    for name in self.data:
+      if name not in self.VALID_SECTION_NAMES:
+        self.error(
+            f'{name} is not a valid section name ({self.VALID_SECTION_NAMES})')
+
+  def check_required_sections(self):
+    """Returns True if all required sections are in |self.data|."""
+    for section in self.REQUIRED_SECTIONS:
+      if section not in self.data:
+        self.error(f'{section} section is missing.')
+
+  def check_valid_emails(self):
+    """Returns True if emails are valid looking.."""
+    # Get email addresses.
+    email_addresses = []
+    primary_contact = self.data.get('primary_contact')
+    if primary_contact:
+      email_addresses.append(primary_contact)
+    auto_ccs = self.data.get('auto_ccs')
+    if auto_ccs:
+      email_addresses.extend(auto_ccs)
+
+    # Check that email addresses seem normal.
+    for email_address in email_addresses:
+      if '@' not in email_address or '.' not in email_address:
+        self.error(f'{email_address} is an invalid email address.')
+
+  def check_valid_language(self):
+    """Returns True if the language is specified and valid."""
+    language = self.data.get('language')
+    if not language:
+      self.error('Missing "language" attribute in project.yaml.')
+    elif language not in constants.LANGUAGES:
+      self.error(
+          f'"language: {language}" is not supported ({constants.LANGUAGES}).')
+
+
+def _check_one_project_yaml(project_yaml_filename):
+  """Does checks on the project.yaml file. Returns True on success."""
+  if _is_project_file(project_yaml_filename, 'project.yml'):
+    print(project_yaml_filename, 'must be named project.yaml.')
+    return False
+
+  if not _is_project_file(project_yaml_filename, 'project.yaml'):
+    return True
+
+  checker = ProjectYamlChecker(project_yaml_filename)
+  return checker.do_checks()
+
+
+def check_project_yaml(paths):
+  """Calls _check_one_project_yaml on each path in |paths|. Returns True if the
+  result of every call is True."""
+  return all([_check_one_project_yaml(path) for path in paths])
+
+
+def _check_one_seed_corpus(path):
+  """Returns False and prints error if |path| is a seed corpus."""
+  if os.path.basename(os.path.dirname(os.path.dirname(path))) != 'projects':
+    return True
+
+  if os.path.splitext(path)[1] == '.zip':
+    print('Don\'t commit seed corpora into the ClusterFuzz repo,'
+          'they bloat it forever.')
+    return False
+
+  return True
+
+
+def check_seed_corpus(paths):
+  """Calls _check_one_seed_corpus on each path in |paths|. Returns True if the
+  result of every call is True."""
+  return all([_check_one_seed_corpus(path) for path in paths])
+
+
+def _check_one_apt_update(path):
+  """Checks that a Dockerfile uses apt-update before apt-install"""
+  if os.path.basename(os.path.dirname(os.path.dirname(path))) != 'projects':
+    return True
+
+  if os.path.basename(path) != 'Dockerfile':
+    return True
+
+  with open(path, 'r') as file:
+    dockerfile = file.read()
+    if 'RUN apt install' in dockerfile or 'RUN apt-get install' in dockerfile:
+      print('Please add an "apt-get update" before "apt-get install". '
+            'Otherwise, a cached and outdated RUN layer may lead to install '
+            'failures in file %s.' % str(path))
+      return False
+
+  return True
+
+
+def check_apt_update(paths):
+  """Checks that all Dockerfile use apt-update before apt-install"""
+  return all([_check_one_apt_update(path) for path in paths])
+
+
+def do_checks(changed_files):
+  """Runs all presubmit checks. Returns False if any fails."""
+  checks = [
+      check_license,
+      yapf,
+      check_project_yaml,
+      check_lib_fuzzing_engine,
+      check_seed_corpus,
+      check_apt_update,
+  ]
+  # Use a list comprehension here and in other cases where we use all() so that
+  # we don't quit early on failure. This is more user-friendly since the more
+  # errors we spit out at once, the less frequently the less check-fix-check
+  # cycles they need to do.
+  return all([check(changed_files) for check in checks])
+
+
+_CHECK_LICENSE_FILENAMES = ['Dockerfile']
+_CHECK_LICENSE_EXTENSIONS = [
+    '.bash',
+    '.c',
+    '.cc',
+    '.cpp',
+    '.css',
+    '.Dockerfile',
+    '.go',
+    '.h',
+    '.htm',
+    '.html',
+    '.java',
+    '.js',
+    '.proto',
+    '.py',
+    '.rs',
+    '.sh',
+    '.ts',
+]
+THIRD_PARTY_DIR_NAME = 'third_party'
+
+_LICENSE_STRING = 'http://www.apache.org/licenses/LICENSE-2.0'
+
+
+def check_license(paths):
+  """Validates license header."""
+  if not paths:
+    return True
+
+  success = True
+  for path in paths:
+    path_parts = str(path).split(os.sep)
+    if any(path_part == THIRD_PARTY_DIR_NAME for path_part in path_parts):
+      continue
+    filename = os.path.basename(path)
+    extension = os.path.splitext(path)[1]
+    if (filename not in _CHECK_LICENSE_FILENAMES and
+        extension not in _CHECK_LICENSE_EXTENSIONS):
+      continue
+
+    with open(path) as file_handle:
+      if _LICENSE_STRING not in file_handle.read():
+        print('Missing license header in file %s.' % str(path))
+        success = False
+
+  return success
+
+
+def bool_to_returncode(success):
+  """Returns 0 if |success|. Otherwise returns 1."""
+  if success:
+    print('Success.')
+    return 0
+
+  print('Failed.')
+  return 1
+
+
+def is_nonfuzzer_python(path):
+  """Returns True if |path| ends in .py."""
+  return os.path.splitext(path)[1] == '.py' and '/projects/' not in path
+
+
+def lint(_=None):
+  """Runs python's linter on infra. Returns False if it fails linting."""
+
+  # Use --score no to make linting quieter.
+  command = ['python3', '-m', 'pylint', '--score', 'no', '-j', '0', 'infra']
+  returncode = subprocess.run(command, check=False).returncode
+  return returncode == 0
+
+
+def yapf(paths, validate=True):
+  """Does yapf on |path| if it is Python file. Only validates format if
+  |validate|. Otherwise, formats the file. Returns False if validation or
+  formatting fails."""
+  paths = [path for path in paths if is_nonfuzzer_python(path)]
+  if not paths:
+    return True
+
+  validate_argument = '-d' if validate else '-i'
+  command = ['yapf', validate_argument, '-p']
+  command.extend(paths)
+
+  returncode = subprocess.run(command, check=False).returncode
+  return returncode == 0
+
+
+def get_changed_files():
+  """Returns a list of absolute paths of files changed in this git branch."""
+  branch_commit_hash = subprocess.check_output(
+      ['git', 'merge-base', 'HEAD', 'origin/HEAD']).strip().decode()
+
+  diff_commands = [
+      # Return list of modified files in the commits on this branch.
+      ['git', 'diff', '--name-only', branch_commit_hash + '..'],
+      # Return list of modified files from uncommitted changes.
+      ['git', 'diff', '--name-only']
+  ]
+
+  changed_files = set()
+  for command in diff_commands:
+    file_paths = subprocess.check_output(command).decode().splitlines()
+    for file_path in file_paths:
+      if not os.path.isfile(file_path):
+        continue
+      changed_files.add(file_path)
+  print(f'Changed files: {" ".join(changed_files)}')
+  return [os.path.abspath(f) for f in changed_files]
+
+
+def run_build_tests():
+  """Runs build tests because they can't be run in parallel."""
+  suite_list = [
+      unittest.TestLoader().discover(os.path.join(_SRC_ROOT, 'infra', 'build'),
+                                     pattern='*_test.py'),
+  ]
+  suite = unittest.TestSuite(suite_list)
+  print('Running build tests.')
+  result = unittest.TextTestRunner().run(suite)
+  return not result.failures and not result.errors
+
+
+def run_nonbuild_tests(parallel):
+  """Runs all tests but build tests. Does them in parallel if |parallel|. The
+  reason why we exclude build tests is because they use an emulator that
+  prevents them from being used in parallel."""
+  # We look for all project directories because otherwise pytest won't run tests
+  # that are not in valid modules (e.g. "base-images").
+  relevant_dirs = set()
+  all_files = get_all_files()
+  for file_path in all_files:
+    directory = os.path.dirname(file_path)
+    relevant_dirs.add(directory)
+
+  # Use ignore-glob because ignore doesn't seem to work properly with the way we
+  # pass directories to pytest.
+  command = [
+      'pytest',
+      '--ignore-glob=infra/build/*',
+      '--ignore-glob=projects/*',
+  ]
+  if parallel:
+    command.extend(['-n', 'auto'])
+  command += list(relevant_dirs)
+  print('Running non-build tests.')
+
+  # TODO(metzman): Get rid of this once config_utils stops using it.
+  env = os.environ.copy()
+  env['CIFUZZ_TEST'] = '1'
+
+  return subprocess.run(command, check=False, env=env).returncode == 0
+
+
+def run_tests(_=None, parallel=False, build_tests=True, nonbuild_tests=True):
+  """Runs all unit tests."""
+  build_success = True
+  nonbuild_success = True
+  if nonbuild_tests:
+    nonbuild_success = run_nonbuild_tests(parallel)
+  else:
+    print('Skipping nonbuild tests as specified.')
+
+  if build_tests:
+    build_success = run_build_tests()
+  else:
+    print('Skipping build tests as specified.')
+
+  return nonbuild_success and build_success
+
+
+def run_systemsan_tests(_=None):
+  """Runs SystemSan unit tests."""
+  command = ['make', 'test']
+  return subprocess.run(command,
+                        cwd='infra/experimental/SystemSan',
+                        check=False).returncode == 0
+
+
+def get_all_files():
+  """Returns a list of absolute paths of files in this repo."""
+  get_all_files_command = ['git', 'ls-files']
+  output = subprocess.check_output(get_all_files_command).decode().splitlines()
+  return [os.path.abspath(path) for path in output if os.path.isfile(path)]
+
+
+def main():
+  """Check changes on a branch for common issues before submitting."""
+  # Get program arguments.
+  parser = argparse.ArgumentParser(description='Presubmit script for oss-fuzz.')
+  parser.add_argument(
+      'command',
+      choices=['format', 'lint', 'license', 'infra-tests', 'systemsan-tests'],
+      nargs='?')
+  parser.add_argument('-a',
+                      '--all-files',
+                      action='store_true',
+                      help='Run presubmit check(s) on all files',
+                      default=False)
+  parser.add_argument('-p',
+                      '--parallel',
+                      action='store_true',
+                      help='Run tests in parallel.',
+                      default=False)
+  parser.add_argument('-s',
+                      '--skip-build-tests',
+                      action='store_true',
+                      help='Skip build tests which are slow and must run '
+                      'sequentially.',
+                      default=False)
+  parser.add_argument('-n',
+                      '--skip-nonbuild-tests',
+                      action='store_true',
+                      help='Only do build tests.',
+                      default=False)
+  args = parser.parse_args()
+
+  if args.all_files:
+    relevant_files = get_all_files()
+  else:
+    relevant_files = get_changed_files()
+
+  os.chdir(_SRC_ROOT)
+
+  # Do one specific check if the user asked for it.
+  if args.command == 'format':
+    success = yapf(relevant_files, False)
+    return bool_to_returncode(success)
+
+  if args.command == 'lint':
+    success = lint()
+    return bool_to_returncode(success)
+
+  if args.command == 'license':
+    success = check_license(relevant_files)
+    return bool_to_returncode(success)
+
+  if args.command == 'infra-tests':
+    success = run_tests(relevant_files,
+                        parallel=args.parallel,
+                        build_tests=(not args.skip_build_tests),
+                        nonbuild_tests=(not args.skip_nonbuild_tests))
+    return bool_to_returncode(success)
+
+  if args.command == 'systemsan-tests':
+    success = run_systemsan_tests(relevant_files)
+    return bool_to_returncode(success)
+
+  # Do all the checks (but no tests).
+  success = do_checks(relevant_files)
+
+  return bool_to_returncode(success)
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+python_files = *_test.py
+log_cli = true

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/repo_manager_test.py

@@ -0,0 +1,201 @@
+# Copyright 2019 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Test the functionality of the RepoManager class."""
+
+import contextlib
+import os
+import tempfile
+import unittest
+from unittest import mock
+
+import repo_manager
+import utils
+
+# pylint: disable=protected-access
+
+OSS_FUZZ_REPO_URL = 'https://github.com/google/oss-fuzz'
+
+
+@contextlib.contextmanager
+def get_oss_fuzz_repo():
+  """Clones a temporary copy of the OSS-Fuzz repo. Returns the path to the
+  repo."""
+  repo_name = 'oss-fuzz'
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    repo_manager._clone(OSS_FUZZ_REPO_URL, tmp_dir, repo_name)
+    yield os.path.join(tmp_dir, repo_name)
+
+
+class CloneTest(unittest.TestCase):
+  """Tests the _clone function."""
+
+  @unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                   'INTEGRATION_TESTS=1 not set')
+  def test_clone_valid_repo_integration(self):
+    """Integration test that tests the correct location of the git repo."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      git_path = os.path.join(oss_fuzz_repo, '.git')
+      self.assertTrue(os.path.isdir(git_path))
+
+  def test_clone_invalid_repo(self):
+    """Tests that cloning an invalid repo will fail."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      with self.assertRaises(RuntimeError):
+        repo_manager._clone('https://github.com/oss-fuzz-not-real.git', tmp_dir,
+                            'oss-fuzz')
+
+  @mock.patch('utils.execute')
+  def test_clone_with_username(self, mock_execute):  # pylint: disable=no-self-use
+    """Test clone with username."""
+    repo_manager._clone('https://github.com/fake/repo.git',
+                        '/',
+                        'name',
+                        username='user',
+                        password='password')
+    mock_execute.assert_called_once_with([
+        'git', 'clone', 'https://user:password@github.com/fake/repo.git', 'name'
+    ],
+                                         location='/',
+                                         check_result=True,
+                                         log_command=False)
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class RepoManagerCheckoutTest(unittest.TestCase):
+  """Tests the checkout functionality of RepoManager."""
+
+  def test_checkout_valid_commit(self):
+    """Tests that the git checkout command works."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      commit_to_test = '04ea24ee15bbe46a19e5da6c5f022a2ffdfbdb3b'
+      repo_man.checkout_commit(commit_to_test)
+      self.assertEqual(commit_to_test, repo_man.get_current_commit())
+
+  def test_checkout_invalid_commit(self):
+    """Tests that the git checkout invalid commit fails."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      with self.assertRaises(ValueError):
+        repo_man.checkout_commit(' ')
+      with self.assertRaises(ValueError):
+        repo_man.checkout_commit('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+      with self.assertRaises(ValueError):
+        repo_man.checkout_commit('not-a-valid-commit')
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class RepoManagerGetCommitListTest(unittest.TestCase):
+  """Tests the get_commit_list method of RepoManager."""
+
+  def test_get_valid_commit_list(self):
+    """Tests an accurate commit list can be retrieved from the repo manager."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      old_commit = '04ea24ee15bbe46a19e5da6c5f022a2ffdfbdb3b'
+      new_commit = 'fa662173bfeb3ba08d2e84cefc363be11e6c8463'
+      commit_list = [
+          'fa662173bfeb3ba08d2e84cefc363be11e6c8463',
+          '17035317a44fa89d22fe6846d868d4bf57def78b',
+          '97dee00a3c4ce95071c3e061592f5fd577dea886',
+          '04ea24ee15bbe46a19e5da6c5f022a2ffdfbdb3b'
+      ]
+      result_list = repo_man.get_commit_list(new_commit, old_commit)
+      self.assertListEqual(commit_list, result_list)
+
+  def test_get_invalid_commit_list(self):
+    """Tests that the proper errors are thrown when invalid commits are
+    passed to get_commit_list."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      old_commit = '04ea24ee15bbe46a19e5da6c5f022a2ffdfbdb3b'
+      new_commit = 'fa662173bfeb3ba08d2e84cefc363be11e6c8463'
+      with self.assertRaises(ValueError):
+        repo_man.get_commit_list('fakecommit', new_commit)
+      with self.assertRaises(ValueError):
+        repo_man.get_commit_list(new_commit, 'fakecommit')
+      with self.assertRaises(RuntimeError):
+        repo_man.get_commit_list(old_commit, new_commit)  # pylint: disable=arguments-out-of-order
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class GitDiffTest(unittest.TestCase):
+  """Tests get_git_diff."""
+
+  def test_diff_exists(self):
+    """Tests that a real diff is returned when a valid repo manager exists."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      with mock.patch.object(utils,
+                             'execute',
+                             return_value=('test.py\ndiff.py', None, 0)):
+        diff = repo_man.get_git_diff()
+        self.assertCountEqual(diff, ['test.py', 'diff.py'])
+
+  def test_diff_empty(self):
+    """Tests that None is returned when there is no difference between repos."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      with mock.patch.object(utils, 'execute', return_value=('', None, 0)):
+        diff = repo_man.get_git_diff()
+        self.assertIsNone(diff)
+
+  def test_error_on_command(self):
+    """Tests that None is returned when the command errors out."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      with mock.patch.object(utils,
+                             'execute',
+                             return_value=('', 'Test error.', 1)):
+        diff = repo_man.get_git_diff()
+        self.assertIsNone(diff)
+
+  def test_diff_no_change(self):
+    """Tests that None is returned when there is no difference between repos."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      diff = repo_man.get_git_diff()
+      self.assertIsNone(diff)
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class CheckoutPrIntegrationTest(unittest.TestCase):
+  """Does Integration tests on the checkout_pr method of RepoManager."""
+
+  def test_pull_request_exists(self):
+    """Tests that a diff is returned when a valid PR is checked out."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      repo_man.checkout_pr('refs/pull/3415/merge')
+      diff = repo_man.get_git_diff()
+      self.assertCountEqual(diff, ['README.md'])
+
+  def test_checkout_invalid_pull_request(self):
+    """Tests that the git checkout invalid pull request fails."""
+    with get_oss_fuzz_repo() as oss_fuzz_repo:
+      repo_man = repo_manager.RepoManager(oss_fuzz_repo)
+      with self.assertRaises(RuntimeError):
+        repo_man.checkout_pr(' ')
+      with self.assertRaises(RuntimeError):
+        repo_man.checkout_pr('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+      with self.assertRaises(RuntimeError):
+        repo_man.checkout_pr('not/a/valid/pr')
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-commons-compress-full-01-vuln_5/fuzz-tooling/infra/utils_test.py

@@ -0,0 +1,151 @@
+# Copyright 2020 Google LLC
+#
+# 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
+#
+#      http://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.
+"""Tests the functionality of the utils module's functions"""
+
+import os
+import tempfile
+import unittest
+from unittest import mock
+
+import utils
+import helper
+
+EXAMPLE_PROJECT = 'example'
+
+TEST_OUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                            'cifuzz', 'test_data', 'build-out')
+
+
+class IsFuzzTargetLocalTest(unittest.TestCase):
+  """Tests the is_fuzz_target_local function."""
+
+  def test_invalid_filepath(self):
+    """Tests the function with an invalid file path."""
+    is_local = utils.is_fuzz_target_local('not/a/real/file')
+    self.assertFalse(is_local)
+    is_local = utils.is_fuzz_target_local('')
+    self.assertFalse(is_local)
+    is_local = utils.is_fuzz_target_local(' ')
+    self.assertFalse(is_local)
+
+  def test_valid_filepath(self):
+    """Checks is_fuzz_target_local function with a valid filepath."""
+
+    is_local = utils.is_fuzz_target_local(
+        os.path.join(TEST_OUT_DIR, 'example_crash_fuzzer'))
+    self.assertTrue(is_local)
+    is_local = utils.is_fuzz_target_local(TEST_OUT_DIR)
+    self.assertFalse(is_local)
+
+
+class GetFuzzTargetsTest(unittest.TestCase):
+  """Tests the get_fuzz_targets function."""
+
+  def test_valid_filepath(self):
+    """Tests that fuzz targets can be retrieved once the fuzzers are built."""
+    fuzz_targets = utils.get_fuzz_targets(TEST_OUT_DIR)
+    crash_fuzzer_path = os.path.join(TEST_OUT_DIR, 'example_crash_fuzzer')
+    nocrash_fuzzer_path = os.path.join(TEST_OUT_DIR, 'example_nocrash_fuzzer')
+    self.assertCountEqual(fuzz_targets,
+                          [crash_fuzzer_path, nocrash_fuzzer_path])
+
+    # Testing on a arbitrary directory with no fuzz targets in it.
+    fuzz_targets = utils.get_fuzz_targets(
+        os.path.join(helper.OSS_FUZZ_DIR, 'infra', 'travis'))
+    self.assertFalse(fuzz_targets)
+
+  def test_invalid_filepath(self):
+    """Tests what get_fuzz_targets return when invalid filepath is used."""
+    fuzz_targets = utils.get_fuzz_targets('not/a/valid/file/path')
+    self.assertFalse(fuzz_targets)
+
+
+class ExecuteTest(unittest.TestCase):
+  """Tests the execute function."""
+
+  def test_valid_command(self):
+    """Tests that execute can produce valid output."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out, err, err_code = utils.execute(['ls', '.'],
+                                         location=tmp_dir,
+                                         check_result=False)
+      self.assertEqual(err_code, 0)
+      self.assertEqual(err, '')
+      self.assertEqual(out, '')
+      out, err, err_code = utils.execute(['mkdir', 'tmp'],
+                                         location=tmp_dir,
+                                         check_result=False)
+      self.assertEqual(err_code, 0)
+      self.assertEqual(err, '')
+      self.assertEqual(out, '')
+      out, err, err_code = utils.execute(['ls', '.'],
+                                         location=tmp_dir,
+                                         check_result=False)
+      self.assertEqual(err_code, 0)
+      self.assertEqual(err, '')
+      self.assertEqual(out, 'tmp\n')
+
+  def test_error_command(self):
+    """Tests that execute can correctly surface errors."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      out, err, err_code = utils.execute(['ls', 'notarealdir'],
+                                         location=tmp_dir,
+                                         check_result=False)
+      self.assertEqual(err_code, 2)
+      self.assertIsNotNone(err)
+      self.assertEqual(out, '')
+      with self.assertRaises(RuntimeError):
+        out, err, err_code = utils.execute(['ls', 'notarealdir'],
+                                           location=tmp_dir,
+                                           check_result=True)
+
+
+class BinaryPrintTest(unittest.TestCase):
+  """Tests for utils.binary_print."""
+
+  @unittest.skip('Causes spurious failures because of side-effects.')
+  def test_string(self):  # pylint: disable=no-self-use
+    """Tests that utils.binary_print can print a regular string."""
+    # Should execute without raising any exceptions.
+    with mock.patch('sys.stdout.buffer.write') as mock_write:
+      utils.binary_print('hello')
+      mock_write.assert_called_with('hello\n')
+
+  @unittest.skip('Causes spurious failures because of side-effects.')
+  def test_binary_string(self):  # pylint: disable=no-self-use
+    """Tests that utils.binary_print can print a bianry string."""
+    # Should execute without raising any exceptions.
+    with mock.patch('sys.stdout.buffer.write') as mock_write:
+      utils.binary_print(b'hello')
+      mock_write.assert_called_with(b'hello\n')
+
+
+class CommandToStringTest(unittest.TestCase):
+  """Tests for command_to_string."""
+
+  def test_string(self):
+    """Tests that command_to_string returns the argument passed to it when it is
+    passed a string."""
+    command = 'command'
+    self.assertEqual(utils.command_to_string(command), command)
+
+  def test_list(self):
+    """Tests that command_to_string returns the correct stringwhen it is passed
+    a list."""
+    command = ['command', 'arg1', 'arg2']
+    self.assertEqual(utils.command_to_string(command), 'command arg1 arg2')
+
+
+if __name__ == '__main__':
+  unittest.main()