Add files using upload-large-folder tool

local-test-commons-compress-full-01-vuln_1/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_1/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_1/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_1/fuzz-tooling/docs/404.html

@@ -0,0 +1,23 @@
+---
+layout: default
+---
+
+<style type="text/css" media="screen">
+  .container {
+    margin: 10px auto;
+    max-width: 600px;
+    text-align: center;
+  }
+  h1 {
+    margin: 30px 0;
+    font-size: 4em;
+    line-height: 1;
+    letter-spacing: -1px;
+  }
+</style>
+
+<div class="container">
+  <h1>404</h1>
+
+  <p><strong>Page not found :(</strong></p>
+</div>

local-test-commons-compress-full-01-vuln_1/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_1/fuzz-tooling/infra/MAINTAINERS.csv

@@ -0,0 +1,7 @@
+Name,Email,Github Username
+Adam Korcz,adam@adalogics.com,AdamKorcz
+David Korczynski,david@adalogics.com,DavidKorczynski
+Dongge Liu,donggeliu@google.com,Alan32Liu
+Holly Gong,gongh@google.com,hogo6002
+Jonathan Metzman,metzman@google.com,jonathanmetzman
+Oliver Chang,ochang@google.com,oliverchang

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/README.md

@@ -0,0 +1,23 @@
+# infra
+> OSS-Fuzz project infrastructure
+
+Core infrastructure:
+* [`base-images`](base-images/) - docker images for building fuzz targets & corresponding jenkins
+  pipeline.
+
+Continuous Integration infrastructure:
+
+* [`ci`](ci/) - script to build projects in CI.
+
+## helper.py
+> script to automate common docker operations
+
+| Command | Description |
+|---------|-------------
+| `generate`      | Generates skeleton files for a new project |
+| `build_image`   | Builds a docker image for a given project |
+| `build_fuzzers` | Builds fuzz targets for a given project |
+| `run_fuzzer`    | Runs a fuzz target in a docker container |
+| `coverage`      | Runs fuzz target(s) in a docker container and generates a code coverage report. See [Code Coverage doc](https://google.github.io/oss-fuzz/advanced-topics/code-coverage/) |
+| `reproduce`     | Runs a testcase to reproduce a crash |
+| `shell`         | Starts a shell inside the docker image for a project |

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/bisector.py

@@ -0,0 +1,318 @@
+# 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.
+"""Uses bisection to determine which commit a bug was introduced and fixed.
+This module takes a high and a low commit SHA, a repo name, and a bug.
+The module bisects the high and low commit SHA searching for the location
+where the bug was introduced. It also looks for where the bug was fixed.
+This is done with the following steps:
+
+
+  NOTE: Needs to be run from root of the OSS-Fuzz source checkout.
+
+  Typical usage example:
+        python3 infra/bisector.py
+          --old_commit 1e403e9259a1abedf108ab86f711ba52c907226d
+          --new_commit f79be4f2330f4b89ea2f42e1c44ca998c59a0c0f
+          --fuzz_target rules_fuzzer
+          --project_name yara
+          --testcase infra/yara_testcase
+          --sanitizer address
+"""
+
+import argparse
+import collections
+import logging
+import os
+import sys
+import tempfile
+
+import build_specified_commit
+import helper
+import repo_manager
+import utils
+
+Result = collections.namedtuple('Result', ['repo_url', 'commit'])
+
+START_MARKERS = [
+    '==ERROR',
+    '==WARNING',
+]
+
+END_MARKERS = [
+    'SUMMARY:',
+]
+
+DEDUP_TOKEN_MARKER = 'DEDUP_TOKEN:'
+
+
+class BisectError(Exception):
+  """Bisection error."""
+
+  def __init__(self, message, repo_url):
+    super().__init__(message)
+    self.repo_url = repo_url
+
+
+def main():
+  """Finds the commit SHA where an error was initally introduced."""
+  logging.getLogger().setLevel(logging.INFO)
+  utils.chdir_to_root()
+  parser = argparse.ArgumentParser(
+      description='git bisection for finding introduction of bugs')
+
+  parser.add_argument('--project_name',
+                      help='The name of the project where the bug occurred.',
+                      required=True)
+  parser.add_argument('--new_commit',
+                      help='The newest commit SHA to be bisected.',
+                      required=True)
+  parser.add_argument('--old_commit',
+                      help='The oldest commit SHA to be bisected.',
+                      required=True)
+  parser.add_argument('--fuzz_target',
+                      help='The name of the fuzzer to be built.',
+                      required=True)
+  parser.add_argument('--test_case_path',
+                      help='The path to test case.',
+                      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('--type',
+                      choices=['regressed', 'fixed'],
+                      help='The bisection type.',
+                      required=True)
+  parser.add_argument('--architecture', default='x86_64')
+  args = parser.parse_args()
+
+  build_data = build_specified_commit.BuildData(project_name=args.project_name,
+                                                engine=args.engine,
+                                                sanitizer=args.sanitizer,
+                                                architecture=args.architecture)
+
+  result = bisect(args.type, args.old_commit, args.new_commit,
+                  args.test_case_path, args.fuzz_target, build_data)
+  if not result.commit:
+    logging.error('No error was found in commit range %s:%s', args.old_commit,
+                  args.new_commit)
+    return 1
+  if result.commit == args.old_commit:
+    logging.error(
+        'Bisection Error: Both the first and the last commits in'
+        'the given range have the same behavior, bisection is not possible. ')
+    return 1
+  if args.type == 'regressed':
+    print('Error was introduced at commit %s' % result.commit)
+  elif args.type == 'fixed':
+    print('Error was fixed at commit %s' % result.commit)
+  return 0
+
+
+def _get_dedup_token(output):
+  """Get dedup token."""
+  for line in output.splitlines():
+    token_location = line.find(DEDUP_TOKEN_MARKER)
+    if token_location == -1:
+      continue
+
+    return line[token_location + len(DEDUP_TOKEN_MARKER):].strip()
+
+  return None
+
+
+def _check_for_crash(project_name, fuzz_target, testcase_path):
+  """Check for crash."""
+
+  def docker_run(args, **kwargs):
+    del kwargs
+    command = ['docker', 'run', '--rm', '--privileged']
+    if sys.stdin.isatty():
+      command.append('-i')
+
+    return utils.execute(command + args)
+
+  logging.info('Checking for crash')
+  out, err, return_code = helper.reproduce_impl(
+      project=helper.Project(project_name),
+      fuzzer_name=fuzz_target,
+      valgrind=False,
+      env_to_add=[],
+      fuzzer_args=[],
+      testcase_path=testcase_path,
+      run_function=docker_run,
+      err_result=(None, None, None))
+  if return_code is None:
+    return None
+
+  logging.info('stdout =\n%s', out)
+  logging.info('stderr =\n%s', err)
+
+  # pylint: disable=unsupported-membership-test
+  has_start_marker = any(
+      marker in out or marker in err for marker in START_MARKERS)
+  has_end_marker = any(marker in out or marker in err for marker in END_MARKERS)
+  if not has_start_marker or not has_end_marker:
+    return None
+
+  return _get_dedup_token(out + err)
+
+
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-arguments
+# pylint: disable=too-many-statements
+def _bisect(bisect_type, old_commit, new_commit, testcase_path, fuzz_target,
+            build_data):
+  """Perform the bisect."""
+  # pylint: disable=too-many-branches
+  base_builder_repo = build_specified_commit.load_base_builder_repo()
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    repo_url, repo_path = build_specified_commit.detect_main_repo(
+        build_data.project_name, commit=new_commit)
+    if not repo_url or not repo_path:
+      raise ValueError('Main git repo can not be determined.')
+
+    if old_commit == new_commit:
+      raise BisectError('old_commit is the same as new_commit', repo_url)
+
+    # Copy /src from the built Docker container to ensure all dependencies
+    # exist. This will be mounted when running them.
+    host_src_dir = build_specified_commit.copy_src_from_docker(
+        build_data.project_name, tmp_dir)
+
+    bisect_repo_manager = repo_manager.RepoManager(
+        os.path.join(host_src_dir, os.path.basename(repo_path)))
+    bisect_repo_manager.fetch_all_remotes()
+
+    commit_list = bisect_repo_manager.get_commit_list(new_commit, old_commit)
+
+    old_idx = len(commit_list) - 1
+    new_idx = 0
+    logging.info('Testing against new_commit (%s)', commit_list[new_idx])
+    if not build_specified_commit.build_fuzzers_from_commit(
+        commit_list[new_idx],
+        bisect_repo_manager,
+        host_src_dir,
+        build_data,
+        base_builder_repo=base_builder_repo):
+      raise BisectError('Failed to build new_commit', repo_url)
+
+    if bisect_type == 'fixed':
+      should_crash = False
+    elif bisect_type == 'regressed':
+      should_crash = True
+    else:
+      raise BisectError('Invalid bisect type ' + bisect_type, repo_url)
+
+    expected_error = _check_for_crash(build_data.project_name, fuzz_target,
+                                      testcase_path)
+    logging.info('new_commit result = %s', expected_error)
+
+    if not should_crash and expected_error:
+      logging.warning('new_commit crashed but not shouldn\'t. '
+                      'Continuing to see if stack changes.')
+
+    range_valid = False
+    for _ in range(2):
+      logging.info('Testing against old_commit (%s)', commit_list[old_idx])
+      if not build_specified_commit.build_fuzzers_from_commit(
+          commit_list[old_idx],
+          bisect_repo_manager,
+          host_src_dir,
+          build_data,
+          base_builder_repo=base_builder_repo):
+        raise BisectError('Failed to build old_commit', repo_url)
+
+      if _check_for_crash(build_data.project_name, fuzz_target,
+                          testcase_path) == expected_error:
+        logging.warning('old_commit %s had same result as new_commit %s',
+                        old_commit, new_commit)
+        # Try again on an slightly older commit.
+        old_commit = bisect_repo_manager.get_parent(old_commit, 64)
+        if not old_commit:
+          break
+
+        commit_list = bisect_repo_manager.get_commit_list(
+            new_commit, old_commit)
+        old_idx = len(commit_list) - 1
+        continue
+
+      range_valid = True
+      break
+
+    if not range_valid:
+      raise BisectError('old_commit had same result as new_commit', repo_url)
+
+    while old_idx - new_idx > 1:
+      curr_idx = (old_idx + new_idx) // 2
+      logging.info('Testing against %s (idx=%d)', commit_list[curr_idx],
+                   curr_idx)
+      if not build_specified_commit.build_fuzzers_from_commit(
+          commit_list[curr_idx],
+          bisect_repo_manager,
+          host_src_dir,
+          build_data,
+          base_builder_repo=base_builder_repo):
+        # Treat build failures as if we couldn't repo.
+        # TODO(ochang): retry nearby commits?
+        old_idx = curr_idx
+        continue
+
+      current_error = _check_for_crash(build_data.project_name, fuzz_target,
+                                       testcase_path)
+      logging.info('Current result = %s', current_error)
+      if expected_error == current_error:
+        new_idx = curr_idx
+      else:
+        old_idx = curr_idx
+    return Result(repo_url, commit_list[new_idx])
+
+
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-arguments
+def bisect(bisect_type, old_commit, new_commit, testcase_path, fuzz_target,
+           build_data):
+  """From a commit range, this function caluclates which introduced a
+  specific error from a fuzz testcase_path.
+
+  Args:
+    bisect_type: The type of the bisect ('regressed' or 'fixed').
+    old_commit: The oldest commit in the error regression range.
+    new_commit: The newest commit in the error regression range.
+    testcase_path: The file path of the test case that triggers the error
+    fuzz_target: The name of the fuzzer to be tested.
+    build_data: a class holding all of the input parameters for bisection.
+
+  Returns:
+    The commit SHA that introduced the error or None.
+
+  Raises:
+    ValueError: when a repo url can't be determine from the project.
+  """
+  try:
+    return _bisect(bisect_type, old_commit, new_commit, testcase_path,
+                   fuzz_target, build_data)
+  finally:
+    # Clean up projects/ as _bisect may have modified it.
+    oss_fuzz_repo_manager = repo_manager.RepoManager(helper.OSS_FUZZ_DIR)
+    oss_fuzz_repo_manager.git(['reset', 'projects'])
+    oss_fuzz_repo_manager.git(['checkout', 'projects'])
+    oss_fuzz_repo_manager.git(['clean', '-fxd', 'projects'])
+
+
+if __name__ == '__main__':
+  main()

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/bisector_test.py

@@ -0,0 +1,70 @@
+# 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 perepo_managerissions and
+# limitations under the License.
+"""Test the functionality of bisection module:
+1) Test a known case where an error appears in a regression range.
+2) Bisect can handle incorrect inputs.
+
+IMPORTANT: This test needs to be run with root privileges.
+"""
+
+import os
+import unittest
+
+import bisector
+import build_specified_commit
+import test_repos
+
+# Necessary because __file__ changes with os.chdir
+TEST_DIR_PATH = os.path.dirname(os.path.realpath(__file__))
+
+
+@unittest.skip('Test is too long to be run with presubmit.')
+class BisectIntegrationTests(unittest.TestCase):
+  """Class to test the functionality of bisection method."""
+
+  BISECT_TYPE = 'regressed'
+
+  def test_bisect_invalid_repo(self):
+    """Test the bisection method on a project that does not exist."""
+    test_repo = test_repos.INVALID_REPO
+    build_data = build_specified_commit.BuildData(
+        project_name=test_repo.project_name,
+        engine='libfuzzer',
+        sanitizer='address',
+        architecture='x86_64')
+    with self.assertRaises(ValueError):
+      bisector.bisect(self.BISECT_TYPE, test_repo.old_commit,
+                      test_repo.new_commit, test_repo.testcase_path,
+                      test_repo.fuzz_target, build_data)
+
+  def test_bisect(self):
+    """Test the bisect method on example projects."""
+    for test_repo in test_repos.TEST_REPOS:
+      if test_repo.new_commit:
+        build_data = build_specified_commit.BuildData(
+            project_name=test_repo.project_name,
+            engine='libfuzzer',
+            sanitizer='address',
+            architecture='x86_64')
+        result = bisector.bisect(self.BISECT_TYPE, test_repo.old_commit,
+                                 test_repo.new_commit, test_repo.testcase_path,
+                                 test_repo.fuzz_target, build_data)
+        self.assertEqual(result.commit, test_repo.intro_commit)
+
+
+if __name__ == '__main__':
+  # Change to oss-fuzz main directory so helper.py runs correctly.
+  if os.getcwd() != os.path.dirname(TEST_DIR_PATH):
+    os.chdir(os.path.dirname(TEST_DIR_PATH))
+  unittest.main()

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/build_fuzzers.Dockerfile

@@ -0,0 +1,31 @@
+# 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.
+#
+################################################################################
+# Docker image to run fuzzers for CIFuzz (the run_fuzzers action on GitHub
+# actions).
+
+FROM ghcr.io/aixcc-finals/cifuzz-base
+
+# Python file to execute when the docker container starts up
+# We can't use the env var $OSS_FUZZ_ROOT here. Since it's a constant env var,
+# just expand to '/opt/oss-fuzz'.
+ENTRYPOINT ["python3", "/opt/oss-fuzz/infra/cifuzz/build_fuzzers_entrypoint.py"]
+
+WORKDIR ${OSS_FUZZ_ROOT}/infra
+
+# Update infra source code.
+ADD . ${OSS_FUZZ_ROOT}/infra
+
+RUN python3 -m pip install -r ${OSS_FUZZ_ROOT}/infra/cifuzz/requirements.txt

local-test-commons-compress-full-01-vuln_1/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_1/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_1/fuzz-tooling/infra/helper.py

@@ -0,0 +1,1810 @@
+#!/usr/bin/env python
+# Copyright 2016 Google Inc.
+#
+# 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.
+#
+################################################################################
+"""Helper script for OSS-Fuzz users. Can do common tasks like building
+projects/fuzzers, running them etc."""
+
+from __future__ import print_function
+from multiprocessing.dummy import Pool as ThreadPool
+import argparse
+import datetime
+import errno
+import logging
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+
+import constants
+import templates
+
+OSS_FUZZ_DIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+BUILD_DIR = os.path.join(OSS_FUZZ_DIR, 'build')
+
+BASE_IMAGE_TAG = ':v1.2.1' # no tag for latest
+
+BASE_RUNNER_IMAGE = f'ghcr.io/aixcc-finals/base-runner{BASE_IMAGE_TAG}'
+
+BASE_IMAGES = {
+    'generic': [
+        f'ghcr.io/aixcc-finals/base-image{BASE_IMAGE_TAG}',
+        f'ghcr.io/aixcc-finals/base-clang{BASE_IMAGE_TAG}',
+        f'ghcr.io/aixcc-finals/base-builder{BASE_IMAGE_TAG}',
+        BASE_RUNNER_IMAGE,
+        f'ghcr.io/aixcc-finals/base-runner-debug{BASE_IMAGE_TAG}',
+    ],
+    'go': [f'ghcr.io/aixcc-finals/base-builder-go{BASE_IMAGE_TAG}'],
+    'javascript': [f'ghcr.io/aixcc-finals/base-builder-javascript{BASE_IMAGE_TAG}'],
+    'jvm': [f'ghcr.io/aixcc-finals/base-builder-jvm{BASE_IMAGE_TAG}'],
+    'python': [f'ghcr.io/aixcc-finals/base-builder-python{BASE_IMAGE_TAG}'],
+    'rust': [f'ghcr.io/aixcc-finals/base-builder-rust{BASE_IMAGE_TAG}'],
+    'ruby': [f'ghcr.io/aixcc-finals/base-builder-ruby{BASE_IMAGE_TAG}'],
+    'swift': [f'ghcr.io/aixcc-finals/base-builder-swift{BASE_IMAGE_TAG}'],
+}
+
+VALID_PROJECT_NAME_REGEX = re.compile(r'^[a-zA-Z0-9_-]+$')
+MAX_PROJECT_NAME_LENGTH = 26
+
+CORPUS_URL_FORMAT = (
+    'gs://{project_name}-corpus.clusterfuzz-external.appspot.com/libFuzzer/'
+    '{fuzz_target}/')
+CORPUS_BACKUP_URL_FORMAT = (
+    'gs://{project_name}-backup.clusterfuzz-external.appspot.com/corpus/'
+    'libFuzzer/{fuzz_target}/')
+
+HTTPS_CORPUS_BACKUP_URL_FORMAT = (
+    'https://storage.googleapis.com/{project_name}-backup.clusterfuzz-external'
+    '.appspot.com/corpus/libFuzzer/{fuzz_target}/public.zip')
+
+LANGUAGE_REGEX = re.compile(r'[^\s]+')
+PROJECT_LANGUAGE_REGEX = re.compile(r'\s*language\s*:\s*([^\s]+)')
+
+WORKDIR_REGEX = re.compile(r'\s*WORKDIR\s*([^\s]+)')
+
+# Regex to match special chars in project name.
+SPECIAL_CHARS_REGEX = re.compile('[^a-zA-Z0-9_-]')
+
+LANGUAGE_TO_BASE_BUILDER_IMAGE = {
+    'c': 'base-builder',
+    'c++': 'base-builder',
+    'go': 'base-builder-go',
+    'javascript': 'base-builder-javascript',
+    'jvm': 'base-builder-jvm',
+    'python': 'base-builder-python',
+    'ruby': 'base-builder-ruby',
+    'rust': 'base-builder-rust',
+    'swift': 'base-builder-swift'
+}
+ARM_BUILDER_NAME = 'oss-fuzz-buildx-builder'
+
+CLUSTERFUZZLITE_ENGINE = 'libfuzzer'
+CLUSTERFUZZLITE_ARCHITECTURE = 'x86_64'
+CLUSTERFUZZLITE_FILESTORE_DIR = 'filestore'
+CLUSTERFUZZLITE_DOCKER_IMAGE = 'ghcr.io/aixcc-finals/cifuzz-run-fuzzers'
+
+logger = logging.getLogger(__name__)
+
+if sys.version_info[0] >= 3:
+  raw_input = input  # pylint: disable=invalid-name
+
+# pylint: disable=too-many-lines
+
+
+class Project:
+  """Class representing a project that is in OSS-Fuzz or an external project
+  (ClusterFuzzLite user)."""
+
+  def __init__(
+      self,
+      project_name_or_path,
+      is_external=False,
+      build_integration_path=constants.DEFAULT_EXTERNAL_BUILD_INTEGRATION_PATH):
+    self.is_external = is_external
+    if self.is_external:
+      self.path = os.path.abspath(project_name_or_path)
+      self.name = os.path.basename(self.path)
+      self.build_integration_path = os.path.join(self.path,
+                                                 build_integration_path)
+    else:
+      self.name = project_name_or_path
+      self.path = os.path.join(OSS_FUZZ_DIR, 'projects', self.name)
+      self.build_integration_path = self.path
+
+  @property
+  def dockerfile_path(self):
+    """Returns path to the project Dockerfile."""
+    return os.path.join(self.build_integration_path, 'Dockerfile')
+
+  @property
+  def language(self):
+    """Returns project language."""
+    project_yaml_path = os.path.join(self.build_integration_path,
+                                     'project.yaml')
+    if not os.path.exists(project_yaml_path):
+      logger.warning('No project.yaml. Assuming c++.')
+      return constants.DEFAULT_LANGUAGE
+
+    with open(project_yaml_path) as file_handle:
+      content = file_handle.read()
+      for line in content.splitlines():
+        match = PROJECT_LANGUAGE_REGEX.match(line)
+        if match:
+          return match.group(1)
+
+    logger.warning('Language not specified in project.yaml. Assuming c++.')
+    return constants.DEFAULT_LANGUAGE
+
+  @property
+  def coverage_extra_args(self):
+    """Returns project coverage extra args."""
+    project_yaml_path = os.path.join(self.build_integration_path,
+                                     'project.yaml')
+    if not os.path.exists(project_yaml_path):
+      logger.warning('project.yaml not found: %s.', project_yaml_path)
+      return ''
+
+    with open(project_yaml_path) as file_handle:
+      content = file_handle.read()
+
+    coverage_flags = ''
+    read_coverage_extra_args = False
+    # Pass the yaml file and extract the value of the coverage_extra_args key.
+    # This is naive yaml parsing and we do not handle comments at this point.
+    for line in content.splitlines():
+      if read_coverage_extra_args:
+        # Break reading coverage args if a new yaml key is defined.
+        if len(line) > 0 and line[0] != ' ':
+          break
+        coverage_flags += line
+      if 'coverage_extra_args' in line:
+        read_coverage_extra_args = True
+        # Include the first line only if it's not a multi-line value.
+        if 'coverage_extra_args: >' not in line:
+          coverage_flags += line.replace('coverage_extra_args: ', '')
+    return coverage_flags
+
+  @property
+  def out(self):
+    """Returns the out dir for the project. Creates it if needed."""
+    return _get_out_dir(self.name)
+
+  @property
+  def work(self):
+    """Returns the out dir for the project. Creates it if needed."""
+    return _get_project_build_subdir(self.name, 'work')
+
+  @property
+  def corpus(self):
+    """Returns the out dir for the project. Creates it if needed."""
+    return _get_project_build_subdir(self.name, 'corpus')
+
+
+def main():  # pylint: disable=too-many-branches,too-many-return-statements
+  """Gets subcommand from program arguments and does it. Returns 0 on success 1
+  on error."""
+  logging.basicConfig(level=logging.INFO)
+  parser = get_parser()
+  args = parse_args(parser)
+
+  # Need to do this before chdir.
+  # TODO(https://github.com/google/oss-fuzz/issues/6758): Get rid of chdir.
+  if hasattr(args, 'testcase_path'):
+    args.testcase_path = _get_absolute_path(args.testcase_path)
+  # Note: this has to happen after parse_args above as parse_args needs to know
+  # the original CWD for external projects.
+  os.chdir(OSS_FUZZ_DIR)
+  if not os.path.exists(BUILD_DIR):
+    os.mkdir(BUILD_DIR)
+
+  # We have different default values for `sanitizer` depending on the `engine`.
+  # Some commands do not have `sanitizer` argument, so `hasattr` is necessary.
+  if hasattr(args, 'sanitizer') and not args.sanitizer:
+    if args.project.language == 'javascript':
+      args.sanitizer = 'none'
+    else:
+      args.sanitizer = constants.DEFAULT_SANITIZER
+
+  if args.command == 'generate':
+    result = generate(args)
+  elif args.command == 'build_image':
+    result = build_image(args)
+  elif args.command == 'build_fuzzers':
+    result = build_fuzzers(args)
+  elif args.command == 'fuzzbench_build_fuzzers':
+    result = fuzzbench_build_fuzzers(args)
+  elif args.command == 'fuzzbench_run_fuzzer':
+    result = fuzzbench_run_fuzzer(args)
+  elif args.command == 'fuzzbench_measure':
+    result = fuzzbench_measure(args)
+  elif args.command == 'check_build':
+    result = check_build(args)
+  elif args.command == 'download_corpora':
+    result = download_corpora(args)
+  elif args.command == 'run_fuzzer':
+    result = run_fuzzer(args)
+  elif args.command == 'coverage':
+    result = coverage(args)
+  elif args.command == 'introspector':
+    result = introspector(args)
+  elif args.command == 'reproduce':
+    result = reproduce(args)
+    if args.propagate_exit_codes:
+      return result
+  elif args.command == 'shell':
+    result = shell(args)
+  elif args.command == 'pull_images':
+    result = pull_images()
+  elif args.command == 'run_clusterfuzzlite':
+    result = run_clusterfuzzlite(args)
+  else:
+    # Print help string if no arguments provided.
+    parser.print_help()
+    result = False
+  return bool_to_retcode(result)
+
+
+def bool_to_retcode(boolean):
+  """Returns 0 if |boolean| is Truthy, 0 is the standard return code for a
+  successful process execution. Returns 1 otherwise, indicating the process
+  failed."""
+  return 0 if boolean else 1
+
+
+def parse_args(parser, args=None):
+  """Parses |args| using |parser| and returns parsed args. Also changes
+  |args.build_integration_path| to have correct default behavior."""
+  # Use default argument None for args so that in production, argparse does its
+  # normal behavior, but unittesting is easier.
+  parsed_args = parser.parse_args(args)
+  project = getattr(parsed_args, 'project', None)
+  if not project:
+    return parsed_args
+
+  # Use hacky method for extracting attributes so that ShellTest works.
+  # TODO(metzman): Fix this.
+  is_external = getattr(parsed_args, 'external', False)
+  parsed_args.project = Project(parsed_args.project, is_external)
+  return parsed_args
+
+
+def _add_external_project_args(parser):
+  parser.add_argument(
+      '--external',
+      help='Is project external?',
+      default=False,
+      action='store_true',
+  )
+
+
+def get_parser():  # pylint: disable=too-many-statements,too-many-locals
+  """Returns an argparse parser."""
+  parser = argparse.ArgumentParser('helper.py', description='oss-fuzz helpers')
+  subparsers = parser.add_subparsers(dest='command')
+
+  generate_parser = subparsers.add_parser(
+      'generate', help='Generate files for new project.')
+  generate_parser.add_argument('project')
+  generate_parser.add_argument('--language',
+                               default=constants.DEFAULT_LANGUAGE,
+                               choices=LANGUAGE_TO_BASE_BUILDER_IMAGE.keys(),
+                               help='Project language.')
+  _add_external_project_args(generate_parser)
+
+  build_image_parser = subparsers.add_parser('build_image',
+                                             help='Build an image.')
+  build_image_parser.add_argument('project')
+  build_image_parser.add_argument('--pull',
+                                  action='store_true',
+                                  help='Pull latest base image.')
+  _add_architecture_args(build_image_parser)
+  build_image_parser.add_argument('--cache',
+                                  action='store_true',
+                                  default=False,
+                                  help='Use docker cache when building image.')
+  build_image_parser.add_argument('--no-pull',
+                                  action='store_true',
+                                  help='Do not pull latest base image.')
+  build_image_parser.add_argument('--docker_image_tag',
+                                    dest='docker_image_tag',
+                                    default='latest',
+                                    help='docker image build tag'
+                                    'default: latest')
+  _add_external_project_args(build_image_parser)
+
+  build_fuzzers_parser = subparsers.add_parser(
+      'build_fuzzers', help='Build fuzzers for a project.')
+  _add_architecture_args(build_fuzzers_parser)
+  _add_engine_args(build_fuzzers_parser)
+  _add_sanitizer_args(build_fuzzers_parser)
+  _add_environment_args(build_fuzzers_parser)
+  _add_external_project_args(build_fuzzers_parser)
+  build_fuzzers_parser.add_argument('project')
+  build_fuzzers_parser.add_argument('source_path',
+                                    help='path of local source',
+                                    nargs='?')
+  build_fuzzers_parser.add_argument('--mount_path',
+                                    dest='mount_path',
+                                    help='path to mount local source in '
+                                    '(defaults to WORKDIR)')
+  build_fuzzers_parser.add_argument('--clean',
+                                    dest='clean',
+                                    action='store_true',
+                                    help='clean existing artifacts.')
+  build_fuzzers_parser.add_argument('--no-clean',
+                                    dest='clean',
+                                    action='store_false',
+                                    help='do not clean existing artifacts '
+                                    '(default).')
+  build_fuzzers_parser.add_argument('--docker_image_tag',
+                                    dest='docker_image_tag',
+                                    default='latest',
+                                    help='docker image build tag'
+                                    'default: latest')
+  build_fuzzers_parser.set_defaults(clean=False)
+
+  fuzzbench_build_fuzzers_parser = subparsers.add_parser(
+      'fuzzbench_build_fuzzers')
+  _add_architecture_args(fuzzbench_build_fuzzers_parser)
+  fuzzbench_build_fuzzers_parser.add_argument('--engine')
+  _add_sanitizer_args(fuzzbench_build_fuzzers_parser)
+  _add_environment_args(fuzzbench_build_fuzzers_parser)
+  _add_external_project_args(fuzzbench_build_fuzzers_parser)
+  fuzzbench_build_fuzzers_parser.add_argument('project')
+  check_build_parser = subparsers.add_parser(
+      'check_build', help='Checks that fuzzers execute without errors.')
+  _add_architecture_args(check_build_parser)
+  _add_engine_args(check_build_parser, choices=constants.ENGINES)
+  _add_sanitizer_args(check_build_parser, choices=constants.SANITIZERS)
+  _add_environment_args(check_build_parser)
+  check_build_parser.add_argument('project',
+                                  help='name of the project or path (external)')
+  check_build_parser.add_argument('fuzzer_name',
+                                  help='name of the fuzzer',
+                                  nargs='?')
+  _add_external_project_args(check_build_parser)
+
+  run_fuzzer_parser = subparsers.add_parser(
+      'run_fuzzer', help='Run a fuzzer in the emulated fuzzing environment.')
+  _add_architecture_args(run_fuzzer_parser)
+  _add_engine_args(run_fuzzer_parser)
+  _add_sanitizer_args(run_fuzzer_parser)
+  _add_environment_args(run_fuzzer_parser)
+  _add_external_project_args(run_fuzzer_parser)
+  run_fuzzer_parser.add_argument(
+      '--corpus-dir', help='directory to store corpus for the fuzz target')
+  run_fuzzer_parser.add_argument('project',
+                                 help='name of the project or path (external)')
+  run_fuzzer_parser.add_argument('fuzzer_name', help='name of the fuzzer')
+  run_fuzzer_parser.add_argument('fuzzer_args',
+                                 help='arguments to pass to the fuzzer',
+                                 nargs='*')
+
+  fuzzbench_run_fuzzer_parser = subparsers.add_parser('fuzzbench_run_fuzzer')
+  _add_architecture_args(fuzzbench_run_fuzzer_parser)
+  fuzzbench_run_fuzzer_parser.add_argument('--engine')
+  _add_sanitizer_args(fuzzbench_run_fuzzer_parser)
+  _add_environment_args(fuzzbench_run_fuzzer_parser)
+  _add_external_project_args(fuzzbench_run_fuzzer_parser)
+  fuzzbench_run_fuzzer_parser.add_argument(
+      '--corpus-dir', help='directory to store corpus for the fuzz target')
+  fuzzbench_run_fuzzer_parser.add_argument(
+      'project', help='name of the project or path (external)')
+  fuzzbench_run_fuzzer_parser.add_argument('fuzzer_name',
+                                           help='name of the fuzzer')
+  fuzzbench_run_fuzzer_parser.add_argument(
+      'fuzzer_args', help='arguments to pass to the fuzzer', nargs='*')
+
+  fuzzbench_measure_parser = subparsers.add_parser('fuzzbench_measure')
+  fuzzbench_measure_parser.add_argument(
+      'project', help='name of the project or path (external)')
+  fuzzbench_measure_parser.add_argument('engine_name',
+                                        help='name of the fuzzer')
+  fuzzbench_measure_parser.add_argument('fuzz_target_name',
+                                        help='name of the fuzzer')
+
+  coverage_parser = subparsers.add_parser(
+      'coverage', help='Generate code coverage report for the project.')
+  coverage_parser.add_argument('--no-corpus-download',
+                               action='store_true',
+                               help='do not download corpus backup from '
+                               'OSS-Fuzz; use corpus located in '
+                               'build/corpus/<project>/<fuzz_target>/')
+  coverage_parser.add_argument('--no-serve',
+                               action='store_true',
+                               help='do not serve a local HTTP server.')
+  coverage_parser.add_argument('--port',
+                               default='8008',
+                               help='specify port for'
+                               ' a local HTTP server rendering coverage report')
+  coverage_parser.add_argument('--fuzz-target',
+                               help='specify name of a fuzz '
+                               'target to be run for generating coverage '
+                               'report')
+  coverage_parser.add_argument('--corpus-dir',
+                               help='specify location of corpus'
+                               ' to be used (requires --fuzz-target argument)')
+  coverage_parser.add_argument('--public',
+                               action='store_true',
+                               help='if set, will download public '
+                               'corpus using wget')
+  coverage_parser.add_argument('project',
+                               help='name of the project or path (external)')
+  coverage_parser.add_argument('extra_args',
+                               help='additional arguments to '
+                               'pass to llvm-cov utility.',
+                               nargs='*')
+  _add_external_project_args(coverage_parser)
+  _add_architecture_args(coverage_parser)
+
+  introspector_parser = subparsers.add_parser(
+      'introspector',
+      help='Run a complete end-to-end run of '
+      'fuzz introspector. This involves (1) '
+      'building the fuzzers with ASAN; (2) '
+      'running all fuzzers; (3) building '
+      'fuzzers with coverge; (4) extracting '
+      'coverage; (5) building fuzzers using '
+      'introspector')
+  introspector_parser.add_argument('project', help='name of the project')
+  introspector_parser.add_argument('--seconds',
+                                   help='number of seconds to run fuzzers',
+                                   default=10)
+  introspector_parser.add_argument('source_path',
+                                   help='path of local source',
+                                   nargs='?')
+  introspector_parser.add_argument(
+      '--public-corpora',
+      help='if specified, will use public corpora for code coverage',
+      default=False,
+      action='store_true')
+  introspector_parser.add_argument(
+      '--private-corpora',
+      help='if specified, will use private corpora',
+      default=False,
+      action='store_true')
+
+  download_corpora_parser = subparsers.add_parser(
+      'download_corpora', help='Download all corpora for a project.')
+  download_corpora_parser.add_argument('--fuzz-target',
+                                       nargs='+',
+                                       help='specify name of a fuzz target')
+  download_corpora_parser.add_argument('--public',
+                                       action='store_true',
+                                       help='if set, will download public '
+                                       'corpus using wget')
+  download_corpora_parser.add_argument(
+      'project', help='name of the project or path (external)')
+
+  reproduce_parser = subparsers.add_parser('reproduce',
+                                           help='Reproduce a crash.')
+  reproduce_parser.add_argument('--valgrind',
+                                action='store_true',
+                                help='run with valgrind')
+  reproduce_parser.add_argument('--propagate_exit_codes',
+                                action='store_true',
+                                default=False,
+                                help='return underlying exit codes instead of True/False.')
+  reproduce_parser.add_argument('--not_privileged',
+                                dest='privileged',
+                                action='store_false',
+                                default=True,
+                                help='reproduce without running docker in privileged mode.')
+  reproduce_parser.add_argument('--err_result', 
+                                help='exit code override for missing harness / fuzz targets '
+                                '(default err_result = 1).',
+                                type=int)
+  reproduce_parser.add_argument('--timeout', 
+                                help='timeout for reproduce subprocess '
+                                '(default: None).',
+                                default=None,
+                                type=int)
+  reproduce_parser.add_argument('project',
+                                help='name of the project or path (external)')
+  reproduce_parser.add_argument('fuzzer_name', help='name of the fuzzer')
+  reproduce_parser.add_argument('testcase_path', help='path of local testcase')
+  reproduce_parser.add_argument('fuzzer_args',
+                                help='arguments to pass to the fuzzer',
+                                nargs='*')
+  _add_environment_args(reproduce_parser)
+  _add_external_project_args(reproduce_parser)
+  _add_architecture_args(reproduce_parser)
+
+  shell_parser = subparsers.add_parser(
+      'shell', help='Run /bin/bash within the builder container.')
+  shell_parser.add_argument('project',
+                            help='name of the project or path (external)')
+  shell_parser.add_argument('source_path',
+                            help='path of local source',
+                            nargs='?')
+  shell_parser.add_argument('--docker_image_tag',
+                            dest='docker_image_tag',
+                            default='latest',
+                            help='docker image build tag'
+                            'default: latest')
+  _add_architecture_args(shell_parser)
+  _add_engine_args(shell_parser)
+  _add_sanitizer_args(shell_parser)
+  _add_environment_args(shell_parser)
+  _add_external_project_args(shell_parser)
+
+  run_clusterfuzzlite_parser = subparsers.add_parser(
+      'run_clusterfuzzlite', help='Run ClusterFuzzLite on a project.')
+  _add_sanitizer_args(run_clusterfuzzlite_parser)
+  _add_environment_args(run_clusterfuzzlite_parser)
+  run_clusterfuzzlite_parser.add_argument('project')
+  run_clusterfuzzlite_parser.add_argument('--clean',
+                                          dest='clean',
+                                          action='store_true',
+                                          help='clean existing artifacts.')
+  run_clusterfuzzlite_parser.add_argument(
+      '--no-clean',
+      dest='clean',
+      action='store_false',
+      help='do not clean existing artifacts '
+      '(default).')
+  run_clusterfuzzlite_parser.add_argument('--branch',
+                                          default='master',
+                                          required=True)
+  _add_external_project_args(run_clusterfuzzlite_parser)
+  run_clusterfuzzlite_parser.set_defaults(clean=False)
+
+  subparsers.add_parser('pull_images', help='Pull base images.')
+  return parser
+
+
+def is_base_image(image_name):
+  """Checks if the image name is a base image."""
+  return os.path.exists(os.path.join('infra', 'base-images', image_name))
+
+
+def check_project_exists(project):
+  """Checks if a project exists."""
+  if os.path.exists(project.path):
+    return True
+
+  if project.is_external:
+    descriptive_project_name = project.path
+  else:
+    descriptive_project_name = project.name
+
+  logger.error('"%s" does not exist.', descriptive_project_name)
+  return False
+
+
+def _check_fuzzer_exists(project, fuzzer_name, architecture='x86_64'):
+  """Checks if a fuzzer exists."""
+  platform = 'linux/arm64' if architecture == 'aarch64' else 'linux/amd64'
+  command = ['docker', 'run', '--rm', '--platform', platform]
+  command.extend(['-v', '%s:/out' % project.out])
+  command.append(BASE_RUNNER_IMAGE)
+
+  command.extend(['/bin/bash', '-c', 'test -f /out/%s' % fuzzer_name])
+
+  try:
+    subprocess.check_call(command)
+  except subprocess.CalledProcessError:
+    logger.error('%s does not seem to exist. Please run build_fuzzers first.',
+                 fuzzer_name)
+    return False
+
+  return True
+
+
+def _normalized_name(name):
+  """Return normalized name with special chars like slash, colon, etc normalized
+  to hyphen(-). This is important as otherwise these chars break local and cloud
+  storage paths."""
+  return SPECIAL_CHARS_REGEX.sub('-', name).strip('-')
+
+
+def _get_absolute_path(path):
+  """Returns absolute path with user expansion."""
+  return os.path.abspath(os.path.expanduser(path))
+
+
+def _get_command_string(command):
+  """Returns a shell escaped command string."""
+  return ' '.join(shlex.quote(part) for part in command)
+
+
+def _get_project_build_subdir(project, subdir_name):
+  """Creates the |subdir_name| subdirectory of the |project| subdirectory in
+  |BUILD_DIR| and returns its path."""
+  directory = os.path.join(BUILD_DIR, subdir_name, project)
+  os.makedirs(directory, exist_ok=True)
+
+  return directory
+
+
+def _get_out_dir(project=''):
+  """Creates and returns path to /out directory for the given project (if
+  specified)."""
+  return _get_project_build_subdir(project, 'out')
+
+
+def _add_architecture_args(parser, choices=None):
+  """Adds common architecture args."""
+  if choices is None:
+    choices = constants.ARCHITECTURES
+  parser.add_argument('--architecture',
+                      default=constants.DEFAULT_ARCHITECTURE,
+                      choices=choices)
+
+
+def _add_engine_args(parser, choices=None):
+  """Adds common engine args."""
+  if choices is None:
+    choices = constants.ENGINES
+  parser.add_argument('--engine',
+                      default=constants.DEFAULT_ENGINE,
+                      choices=choices)
+
+
+def _add_sanitizer_args(parser, choices=None):
+  """Adds common sanitizer args."""
+  if choices is None:
+    choices = constants.SANITIZERS
+  parser.add_argument('--sanitizer',
+                      default=None,
+                      choices=choices,
+                      help='the default is "address"')
+
+
+def _add_environment_args(parser):
+  """Adds common environment args."""
+  parser.add_argument('-e',
+                      action='append',
+                      help="set environment variable e.g. VAR=value")
+
+
+def build_image_impl(project, cache=True, pull=False, 
+                     architecture='x86_64', 
+                     docker_image_tag='latest'):
+  """Builds image."""
+  image_name = project.name
+
+  if is_base_image(image_name):
+    image_project = 'aixcc-finals'
+    docker_build_dir = os.path.join(OSS_FUZZ_DIR, 'infra', 'base-images',
+                                    image_name)
+    dockerfile_path = os.path.join(docker_build_dir, 'Dockerfile')
+    image_name = 'ghcr.io/%s/%s%s' % (image_project, image_name, BASE_IMAGE_TAG)
+  else:
+    if not check_project_exists(project):
+      return False
+    dockerfile_path = project.dockerfile_path
+    docker_build_dir = project.path
+    image_project = 'aixcc-afc'
+    image_name = '%s/%s:%s' % (image_project, image_name, docker_image_tag)
+
+  if pull and not pull_images(project.language):
+    return False
+
+  build_args = []
+  if architecture == 'aarch64':
+    build_args += [
+        'buildx',
+        'build',
+        '--platform',
+        'linux/arm64',
+        '--progress',
+        'plain',
+        '--load',
+    ]
+  if not cache:
+    build_args.append('--no-cache')
+
+  build_args += ['-t', image_name, '--file', dockerfile_path]
+  build_args.append(docker_build_dir)
+
+  if architecture == 'aarch64':
+    command = ['docker'] + build_args
+    subprocess.check_call(command)
+    return True
+  return docker_build(build_args)
+
+
+def _env_to_docker_args(env_list):
+  """Turns envirnoment variable list into docker arguments."""
+  return sum([['-e', v] for v in env_list], [])
+
+
+def workdir_from_lines(lines, default='/src'):
+  """Gets the WORKDIR from the given lines."""
+  for line in reversed(lines):  # reversed to get last WORKDIR.
+    match = re.match(WORKDIR_REGEX, line)
+    if match:
+      workdir = match.group(1)
+      workdir = workdir.replace('$SRC', '/src')
+
+      if not os.path.isabs(workdir):
+        workdir = os.path.join('/src', workdir)
+
+      return os.path.normpath(workdir)
+
+  return default
+
+
+def _workdir_from_dockerfile(project):
+  """Parses WORKDIR from the Dockerfile for the given project."""
+  with open(project.dockerfile_path) as file_handle:
+    lines = file_handle.readlines()
+
+  return workdir_from_lines(lines, default=os.path.join('/src', project.name))
+
+
+def prepare_aarch64_emulation():
+  """Run some necessary commands to use buildx to build AArch64 targets using
+  QEMU emulation on an x86_64 host."""
+  subprocess.check_call(
+      ['docker', 'buildx', 'create', '--name', ARM_BUILDER_NAME])
+  subprocess.check_call(['docker', 'buildx', 'use', ARM_BUILDER_NAME])
+
+
+def docker_run(run_args, print_output=True, architecture='x86_64', propagate_exit_codes=False, privileged=True, timeout=None):
+  """Calls `docker run`."""
+  platform = 'linux/arm64' if architecture == 'aarch64' else 'linux/amd64'
+
+  if privileged:
+      command = [
+          'docker', 'run', '--privileged', '--shm-size=2g', '--platform', platform
+      ]
+  else:
+      command = [
+          'docker', 'run', '--shm-size=2g', '--platform', platform
+      ]
+
+  if os.getenv('OSS_FUZZ_SAVE_CONTAINERS_NAME'):
+    command.append('--name')
+    command.append(os.getenv('OSS_FUZZ_SAVE_CONTAINERS_NAME'))
+  else:
+    command.append('--rm')
+
+  # Support environments with a TTY.
+  if sys.stdin.isatty():
+    command.append('-i')
+
+  command.extend(run_args)
+
+  logger.info('Running: %s.', _get_command_string(command))
+  stdout = None
+  if not print_output:
+    stdout = open(os.devnull, 'w')
+
+  exit_code = 0
+
+  try:
+    subprocess.check_call(command, stdout=stdout, stderr=subprocess.STDOUT,
+                          timeout=timeout)
+  except subprocess.CalledProcessError as e:
+    print(f'subprocess command returned a non-zero exit status: {e.returncode}')
+    exit_code = e.returncode
+  except subprocess.TimeoutExpired:
+    print(f'subprocess command timed out: {timeout=}')
+    exit_code = 124
+
+  return exit_code if propagate_exit_codes else exit_code == 0
+
+
+def docker_build(build_args):
+  """Calls `docker build`."""
+  command = ['docker', 'build']
+  command.extend(build_args)
+  logger.info('Running: %s.', _get_command_string(command))
+
+  try:
+    subprocess.check_call(command)
+  except subprocess.CalledProcessError:
+    logger.error('Docker build failed.')
+    return False
+
+  return True
+
+
+def docker_pull(image):
+  """Call `docker pull`."""
+  command = ['docker', 'pull', image]
+  logger.info('Running: %s', _get_command_string(command))
+
+  try:
+    subprocess.check_call(command)
+  except subprocess.CalledProcessError:
+    logger.error('Docker pull failed.')
+    return False
+
+  return True
+
+
+def build_image(args):
+  """Builds docker image."""
+  if args.pull and args.no_pull:
+    logger.error('Incompatible arguments --pull and --no-pull.')
+    return False
+
+  if args.pull:
+    pull = True
+  elif args.no_pull:
+    pull = False
+  else:
+    y_or_n = raw_input('Pull latest base images (compiler/runtime)? (y/N): ')
+    pull = y_or_n.lower() == 'y'
+
+  if pull:
+    logger.info('Pulling latest base images...')
+  else:
+    logger.info('Using cached base images...')
+
+  # If build_image is called explicitly, don't use cache.
+  if build_image_impl(args.project,
+                      cache=args.cache,
+                      pull=pull,
+                      architecture=args.architecture,
+                      docker_image_tag=args.docker_image_tag):
+    return True
+
+  return False
+
+
+def build_fuzzers_impl(  # pylint: disable=too-many-arguments,too-many-locals,too-many-branches
+    project,
+    clean,
+    engine,
+    sanitizer,
+    architecture,
+    env_to_add,
+    source_path,
+    mount_path=None,
+    child_dir='',
+    build_project_image=True,
+    docker_image_tag='latest'):
+  """Builds fuzzers."""
+  if build_project_image and not build_image_impl(project,
+                                                  architecture=architecture,
+                                                  docker_image_tag=docker_image_tag):
+    return False
+
+  docker_image = f'aixcc-afc/{project.name}:{docker_image_tag}'
+
+  project_out = os.path.join(project.out, child_dir)
+  if clean:
+    logger.info('Cleaning existing build artifacts.')
+
+    # Clean old and possibly conflicting artifacts in project's out directory.
+    docker_run([
+        '-v', f'{project_out}:/out', '-t', f'{docker_image}',
+        '/bin/bash', '-c', 'rm -rf /out/*'
+    ],
+               architecture=architecture)
+
+    docker_run([
+        '-v',
+        '%s:/work' % project.work, '-t',
+        f'{docker_image}', '/bin/bash', '-c', 'rm -rf /work/*'
+    ],
+               architecture=architecture)
+
+  else:
+    logger.info('Keeping existing build artifacts as-is (if any).')
+  env = [
+      'FUZZING_ENGINE=' + engine,
+      'SANITIZER=' + sanitizer,
+      'ARCHITECTURE=' + architecture,
+      'PROJECT_NAME=' + project.name,
+      'HELPER=True',
+  ]
+
+  _add_oss_fuzz_ci_if_needed(env)
+
+  if project.language:
+    env.append('FUZZING_LANGUAGE=' + project.language)
+
+  if env_to_add:
+    env += env_to_add
+
+  command = _env_to_docker_args(env)
+  if source_path:
+    workdir = _workdir_from_dockerfile(project)
+    stateless_path = mount_path if mount_path else workdir
+
+    if stateless_path == '/src':
+      logger.error('Cannot mount local source targeting "/src".')
+      return False
+
+    command += [
+        '-v',
+        '%s:%s:ro' % (_get_absolute_path(source_path), '/local-source-mount'),
+    ]
+
+  command += [
+      '-v', f'{project_out}:/out', '-v', f'{project.work}:/work',
+      f'{docker_image}'
+  ]
+
+  if sys.stdin.isatty():
+    command.insert(-1, '-t')
+
+  if source_path:
+    default_cmd = 'compile'
+    command += [
+      '/bin/bash', 
+      '-c', 
+      f'pushd $SRC && rm -rf {stateless_path} && cp -r /local-source-mount {stateless_path} && popd && {default_cmd}'
+    ]
+
+  result = docker_run(command, architecture=architecture)
+  if not result:
+    logger.error('Building fuzzers failed.')
+    return False
+
+  return True
+
+
+def run_clusterfuzzlite(args):
+  """Runs ClusterFuzzLite on a local repo."""
+  if not os.path.exists(CLUSTERFUZZLITE_FILESTORE_DIR):
+    os.mkdir(CLUSTERFUZZLITE_FILESTORE_DIR)
+
+  try:
+    with tempfile.TemporaryDirectory() as workspace:
+
+      if args.external:
+        project_src_path = os.path.join(workspace, args.project.name)
+        shutil.copytree(args.project.path, project_src_path)
+
+      build_command = [
+          '--tag', 'ghcr.io/aixcc-finals/cifuzz-run-fuzzers', '--file',
+          'infra/run_fuzzers.Dockerfile', 'infra'
+      ]
+      if not docker_build(build_command):
+        return False
+      filestore_path = os.path.abspath(CLUSTERFUZZLITE_FILESTORE_DIR)
+      docker_run_command = []
+      if args.external:
+        docker_run_command += [
+            '-e',
+            f'PROJECT_SRC_PATH={project_src_path}',
+        ]
+      else:
+        docker_run_command += [
+            '-e',
+            f'OSS_FUZZ_PROJECT_NAME={args.project.name}',
+        ]
+      docker_run_command += [
+          '-v',
+          f'{filestore_path}:{filestore_path}',
+          '-v',
+          f'{workspace}:{workspace}',
+          '-e',
+          f'FILESTORE_ROOT_DIR={filestore_path}',
+          '-e',
+          f'WORKSPACE={workspace}',
+          '-e',
+          f'REPOSITORY={args.project.name}',
+          '-e',
+          'CFL_PLATFORM=standalone',
+          '--entrypoint',
+          '',
+          '-v',
+          '/var/run/docker.sock:/var/run/docker.sock',
+          CLUSTERFUZZLITE_DOCKER_IMAGE,
+          'python3',
+          '/opt/oss-fuzz/infra/cifuzz/cifuzz_combined_entrypoint.py',
+      ]
+      return docker_run(docker_run_command)
+
+  except PermissionError as error:
+    logger.error('PermissionError: %s.', error)
+    # Tempfile can't delete the workspace because of a permissions issue. This
+    # is because docker creates files in the workspace that are owned by root
+    # but this process is probably being run as another user. Use a docker image
+    # to delete the temp directory (workspace) so that we have permission.
+    docker_run([
+        '-v', f'{workspace}:{workspace}', '--entrypoint', '',
+        CLUSTERFUZZLITE_DOCKER_IMAGE, 'rm', '-rf',
+        os.path.join(workspace, '*')
+    ])
+    return False
+
+
+def build_fuzzers(args):
+  """Builds fuzzers."""
+  if args.engine == 'centipede' and args.sanitizer != 'none':
+    # Centipede always requires separate binaries for sanitizers:
+    # An unsanitized binary, which Centipede requires for fuzzing.
+    # A sanitized binary, placed in the child directory.
+    sanitized_binary_directories = (
+        ('none', ''),
+        (args.sanitizer, f'__centipede_{args.sanitizer}'),
+    )
+  else:
+    # Generally, a fuzzer only needs one sanitized binary in the default dir.
+    sanitized_binary_directories = ((args.sanitizer, ''),)
+  return all(
+      build_fuzzers_impl(args.project,
+                         args.clean,
+                         args.engine,
+                         sanitizer,
+                         args.architecture,
+                         args.e,
+                         args.source_path,
+                         mount_path=args.mount_path,
+                         child_dir=child_dir,
+                         docker_image_tag=args.docker_image_tag)
+      for sanitizer, child_dir in sanitized_binary_directories)
+
+
+def fuzzbench_build_fuzzers(args):
+  """Builds fuzz targets with an arbitrary fuzzer from FuzzBench."""
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    tmp_dir = os.path.abspath(tmp_dir)
+    fuzzbench_path = os.path.join(tmp_dir, 'fuzzbench')
+    subprocess.run([
+        'git', 'clone', 'https://github.com/google/fuzzbench', '--depth', '1',
+        fuzzbench_path
+    ],
+                   check=True)
+    env = [
+        f'FUZZBENCH_PATH={fuzzbench_path}', 'OSS_FUZZ_ON_DEMAND=1',
+        f'PROJECT={args.project.name}'
+    ]
+    tag = f'aixcc-afc/{args.project.name}'
+    subprocess.run([
+        'docker', 'tag', 'ghcr.io/aixcc-finals/base-builder-fuzzbench',
+        f'ghcr.io/aixcc-finals/base-builder{BASE_IMAGE_TAG}'
+    ],
+                   check=True)
+    build_image_impl(args.project)
+    assert docker_build([
+        '--tag', tag, '--build-arg', f'parent_image={tag}', '--file',
+        os.path.join(fuzzbench_path, 'fuzzers', args.engine,
+                     'builder.Dockerfile'),
+        os.path.join(fuzzbench_path, 'fuzzers', args.engine)
+    ])
+
+    return build_fuzzers_impl(args.project,
+                              False,
+                              args.engine,
+                              args.sanitizer,
+                              args.architecture,
+                              env,
+                              source_path=fuzzbench_path,
+                              mount_path=fuzzbench_path,
+                              build_project_image=False)
+
+
+def _add_oss_fuzz_ci_if_needed(env):
+  """Adds value of |OSS_FUZZ_CI| environment variable to |env| if it is set."""
+  oss_fuzz_ci = os.getenv('OSS_FUZZ_CI')
+  if oss_fuzz_ci:
+    env.append('OSS_FUZZ_CI=' + oss_fuzz_ci)
+
+
+def check_build(args):
+  """Checks that fuzzers in the container execute without errors."""
+  if not check_project_exists(args.project):
+    return False
+
+  if (args.fuzzer_name and not _check_fuzzer_exists(
+      args.project, args.fuzzer_name, args.architecture)):
+    return False
+
+  env = [
+      'FUZZING_ENGINE=' + args.engine,
+      'SANITIZER=' + args.sanitizer,
+      'ARCHITECTURE=' + args.architecture,
+      'FUZZING_LANGUAGE=' + args.project.language,
+      'HELPER=True',
+  ]
+  _add_oss_fuzz_ci_if_needed(env)
+  if args.e:
+    env += args.e
+
+  run_args = _env_to_docker_args(env) + [
+      '-v', f'{args.project.out}:/out', '-t', BASE_RUNNER_IMAGE
+  ]
+
+  if args.fuzzer_name:
+    run_args += ['test_one.py', args.fuzzer_name]
+  else:
+    run_args.append('test_all.py')
+
+  result = docker_run(run_args, architecture=args.architecture)
+  if result:
+    logger.info('Check build passed.')
+  else:
+    logger.error('Check build failed.')
+
+  return result
+
+
+def _get_fuzz_targets(project):
+  """Returns names of fuzz targest build in the project's /out directory."""
+  fuzz_targets = []
+  for name in os.listdir(project.out):
+    if name.startswith('afl-'):
+      continue
+    if name == 'centipede':
+      continue
+    if name.startswith('jazzer_'):
+      continue
+    if name == 'llvm-symbolizer':
+      continue
+
+    path = os.path.join(project.out, name)
+    # Python and JVM fuzz targets are only executable for the root user, so
+    # we can't use os.access.
+    if os.path.isfile(path) and (os.stat(path).st_mode & 0o111):
+      fuzz_targets.append(name)
+
+  return fuzz_targets
+
+
+def _get_latest_corpus(project, fuzz_target, base_corpus_dir):
+  """Downloads the latest corpus for the given fuzz target."""
+  corpus_dir = os.path.join(base_corpus_dir, fuzz_target)
+  os.makedirs(corpus_dir, exist_ok=True)
+
+  if not fuzz_target.startswith(project.name + '_'):
+    fuzz_target = '%s_%s' % (project.name, fuzz_target)
+
+  # Normalise fuzz target name.
+  fuzz_target = _normalized_name(fuzz_target)
+
+  corpus_backup_url = CORPUS_BACKUP_URL_FORMAT.format(project_name=project.name,
+                                                      fuzz_target=fuzz_target)
+  command = ['gsutil', 'ls', corpus_backup_url]
+
+  # Don't capture stderr. We want it to print in real time, in case gsutil is
+  # asking for two-factor authentication.
+  corpus_listing = subprocess.Popen(command, stdout=subprocess.PIPE)
+  output, _ = corpus_listing.communicate()
+
+  # Some fuzz targets (e.g. new ones) may not have corpus yet, just skip those.
+  if corpus_listing.returncode:
+    logger.warning('Corpus for %s not found:\n', fuzz_target)
+    return
+
+  if output:
+    latest_backup_url = output.splitlines()[-1]
+    archive_path = corpus_dir + '.zip'
+    command = ['gsutil', '-q', 'cp', latest_backup_url, archive_path]
+    subprocess.check_call(command)
+
+    command = ['unzip', '-q', '-o', archive_path, '-d', corpus_dir]
+    subprocess.check_call(command)
+    os.remove(archive_path)
+  else:
+    # Sync the working corpus copy if a minimized backup is not available.
+    corpus_url = CORPUS_URL_FORMAT.format(project_name=project.name,
+                                          fuzz_target=fuzz_target)
+    command = ['gsutil', '-m', '-q', 'rsync', '-R', corpus_url, corpus_dir]
+    subprocess.check_call(command)
+
+
+def _get_latest_public_corpus(args, fuzzer):
+  """Downloads the public corpus"""
+  target_corpus_dir = "build/corpus/%s" % args.project.name
+  if not os.path.isdir(target_corpus_dir):
+    os.makedirs(target_corpus_dir)
+
+  target_zip = os.path.join(target_corpus_dir, fuzzer + ".zip")
+
+  project_qualified_fuzz_target_name = fuzzer
+  qualified_name_prefix = args.project.name + '_'
+  if not fuzzer.startswith(qualified_name_prefix):
+    project_qualified_fuzz_target_name = qualified_name_prefix + fuzzer
+
+  download_url = HTTPS_CORPUS_BACKUP_URL_FORMAT.format(
+      project_name=args.project.name,
+      fuzz_target=project_qualified_fuzz_target_name)
+
+  cmd = ['wget', download_url, '-O', target_zip]
+  try:
+    with open(os.devnull, 'w') as stdout:
+      subprocess.check_call(cmd, stdout=stdout)
+  except OSError:
+    logger.error('Failed to download corpus')
+
+  target_fuzzer_dir = os.path.join(target_corpus_dir, fuzzer)
+  if not os.path.isdir(target_fuzzer_dir):
+    os.mkdir(target_fuzzer_dir)
+
+  target_corpus_dir = os.path.join(target_corpus_dir, fuzzer)
+  try:
+    with open(os.devnull, 'w') as stdout:
+      subprocess.check_call(
+          ['unzip', '-q', '-o', target_zip, '-d', target_fuzzer_dir],
+          stdout=stdout)
+  except OSError:
+    logger.error('Failed to unzip corpus')
+
+  # Remove the downloaded zip
+  os.remove(target_zip)
+  return True
+
+
+def download_corpora(args):
+  """Downloads most recent corpora from GCS for the given project."""
+  if not check_project_exists(args.project):
+    return False
+
+  if args.public:
+    logger.info("Downloading public corpus")
+    try:
+      with open(os.devnull, 'w') as stdout:
+        subprocess.check_call(['wget', '--version'], stdout=stdout)
+    except OSError:
+      logger.error('wget not found')
+      return False
+  else:
+    try:
+      with open(os.devnull, 'w') as stdout:
+        subprocess.check_call(['gsutil', '--version'], stdout=stdout)
+    except OSError:
+      logger.error('gsutil not found. Please install it from '
+                   'https://cloud.google.com/storage/docs/gsutil_install')
+      return False
+
+  if args.fuzz_target:
+    fuzz_targets = args.fuzz_target
+  else:
+    fuzz_targets = _get_fuzz_targets(args.project)
+
+  if not fuzz_targets:
+    logger.error(
+        'Fuzz targets not found. Please build project first '
+        '(python3 infra/helper.py build_fuzzers %s) so that download_corpora '
+        'can automatically identify targets.', args.project.name)
+    return False
+
+  corpus_dir = args.project.corpus
+
+  def _download_for_single_target(fuzz_target):
+    try:
+      if args.public:
+        _get_latest_public_corpus(args, fuzz_target)
+      else:
+        _get_latest_corpus(args.project, fuzz_target, corpus_dir)
+      return True
+    except Exception as error:  # pylint:disable=broad-except
+      logger.error('Corpus download for %s failed: %s.', fuzz_target,
+                   str(error))
+      return False
+
+  logger.info('Downloading corpora for %s project to %s.', args.project.name,
+              corpus_dir)
+  thread_pool = ThreadPool()
+  return all(thread_pool.map(_download_for_single_target, fuzz_targets))
+
+
+def coverage(args):  # pylint: disable=too-many-branches
+  """Generates code coverage using clang source based code coverage."""
+  if args.corpus_dir and not args.fuzz_target:
+    logger.error(
+        '--corpus-dir requires specifying a particular fuzz target using '
+        '--fuzz-target')
+    return False
+
+  if not check_project_exists(args.project):
+    return False
+
+  if args.project.language not in constants.LANGUAGES_WITH_COVERAGE_SUPPORT:
+    logger.error(
+        'Project is written in %s, coverage for it is not supported yet.',
+        args.project.language)
+    return False
+
+  if (not args.no_corpus_download and not args.corpus_dir and
+      not args.project.is_external):
+    if not download_corpora(args):
+      return False
+
+  extra_cov_args = (
+      f'{args.project.coverage_extra_args.strip()} {" ".join(args.extra_args)}')
+  env = [
+      'FUZZING_ENGINE=libfuzzer',
+      'HELPER=True',
+      'FUZZING_LANGUAGE=%s' % args.project.language,
+      'PROJECT=%s' % args.project.name,
+      'SANITIZER=coverage',
+      'COVERAGE_EXTRA_ARGS=%s' % extra_cov_args,
+      'ARCHITECTURE=' + args.architecture,
+  ]
+
+  if not args.no_serve:
+    env.append(f'HTTP_PORT={args.port}')
+
+  run_args = _env_to_docker_args(env)
+
+  if args.port:
+    run_args.extend([
+        '-p',
+        '%s:%s' % (args.port, args.port),
+    ])
+
+  if args.corpus_dir:
+    if not os.path.exists(args.corpus_dir):
+      logger.error('The path provided in --corpus-dir argument does not '
+                   'exist.')
+      return False
+    corpus_dir = os.path.realpath(args.corpus_dir)
+    run_args.extend(['-v', '%s:/corpus/%s' % (corpus_dir, args.fuzz_target)])
+  else:
+    run_args.extend(['-v', '%s:/corpus' % args.project.corpus])
+
+  run_args.extend([
+      '-v',
+      '%s:/out' % args.project.out,
+      '-t',
+      BASE_RUNNER_IMAGE,
+  ])
+
+  run_args.append('coverage')
+  if args.fuzz_target:
+    run_args.append(args.fuzz_target)
+
+  result = docker_run(run_args, architecture=args.architecture)
+  if result:
+    logger.info('Successfully generated clang code coverage report.')
+  else:
+    logger.error('Failed to generate clang code coverage report.')
+
+  return result
+
+
+def _introspector_prepare_corpus(args):
+  """Helper function for introspector runs to generate corpora."""
+  parser = get_parser()
+  # Generate corpus, either by downloading or running fuzzers.
+  if args.private_corpora or args.public_corpora:
+    corpora_command = ['download_corpora']
+    if args.public_corpora:
+      corpora_command.append('--public')
+    corpora_command.append(args.project.name)
+    if not download_corpora(parse_args(parser, corpora_command)):
+      logger.error('Failed to download corpora')
+      return False
+  else:
+    fuzzer_targets = _get_fuzz_targets(args.project)
+    for fuzzer_name in fuzzer_targets:
+      # Make a corpus directory.
+      fuzzer_corpus_dir = args.project.corpus + f'/{fuzzer_name}'
+      if not os.path.isdir(fuzzer_corpus_dir):
+        os.makedirs(fuzzer_corpus_dir)
+      run_fuzzer_command = [
+          'run_fuzzer', '--sanitizer', 'address', '--corpus-dir',
+          fuzzer_corpus_dir, args.project.name, fuzzer_name
+      ]
+
+      parsed_args = parse_args(parser, run_fuzzer_command)
+      parsed_args.fuzzer_args = [
+          f'-max_total_time={args.seconds}', '-detect_leaks=0'
+      ]
+      # Continue even if run command fails, because we do not have 100%
+      # accuracy in fuzz target detection, i.e. we might try to run something
+      # that is not a target.
+      run_fuzzer(parsed_args)
+  return True
+
+
+def introspector(args):
+  """Runs a complete end-to-end run of introspector."""
+  parser = get_parser()
+
+  args_to_append = []
+  if args.source_path:
+    args_to_append.append(_get_absolute_path(args.source_path))
+
+  # Build fuzzers with ASAN.
+  build_fuzzers_command = [
+      'build_fuzzers', '--sanitizer=address', args.project.name
+  ] + args_to_append
+  if not build_fuzzers(parse_args(parser, build_fuzzers_command)):
+    logger.error('Failed to build project with ASAN')
+    return False
+
+  if not _introspector_prepare_corpus(args):
+    return False
+
+  # Build code coverage.
+  build_fuzzers_command = [
+      'build_fuzzers', '--sanitizer=coverage', args.project.name
+  ] + args_to_append
+  if not build_fuzzers(parse_args(parser, build_fuzzers_command)):
+    logger.error('Failed to build project with coverage instrumentation')
+    return False
+
+  # Collect coverage.
+  coverage_command = [
+      'coverage', '--no-corpus-download', '--port', '', args.project.name
+  ]
+  if not coverage(parse_args(parser, coverage_command)):
+    logger.error('Failed to extract coverage')
+    return False
+
+  # Build introspector.
+  build_fuzzers_command = [
+      'build_fuzzers', '--sanitizer=introspector', args.project.name
+  ] + args_to_append
+  if not build_fuzzers(parse_args(parser, build_fuzzers_command)):
+    logger.error('Failed to build project with introspector')
+    return False
+
+  introspector_dst = os.path.join(args.project.out,
+                                  "introspector-report/inspector")
+  shutil.rmtree(introspector_dst, ignore_errors=True)
+  shutil.copytree(os.path.join(args.project.out, "inspector"), introspector_dst)
+
+  # Copy the coverage reports into the introspector report.
+  dst_cov_report = os.path.join(introspector_dst, "covreport")
+  shutil.copytree(os.path.join(args.project.out, "report"), dst_cov_report)
+
+  # Copy per-target coverage reports
+  src_target_cov_report = os.path.join(args.project.out, "report_target")
+  for target_cov_dir in os.listdir(src_target_cov_report):
+    dst_target_cov_report = os.path.join(dst_cov_report, target_cov_dir)
+    shutil.copytree(os.path.join(src_target_cov_report, target_cov_dir),
+                    dst_target_cov_report)
+
+  logger.info('Introspector run complete. Report in %s', introspector_dst)
+  logger.info(
+      'To browse the report, run: `python3 -m http.server 8008 --directory %s`'
+      'and navigate to localhost:8008/fuzz_report.html in your browser',
+      introspector_dst)
+  return True
+
+
+def run_fuzzer(args):
+  """Runs a fuzzer in the container."""
+  if not check_project_exists(args.project):
+    return False
+
+  if not _check_fuzzer_exists(args.project, args.fuzzer_name,
+                              args.architecture):
+    return False
+
+  env = [
+      'FUZZING_ENGINE=' + args.engine,
+      'SANITIZER=' + args.sanitizer,
+      'RUN_FUZZER_MODE=interactive',
+      'HELPER=True',
+  ]
+
+  if args.e:
+    env += args.e
+
+  run_args = _env_to_docker_args(env)
+
+  if args.corpus_dir:
+    if not os.path.exists(args.corpus_dir):
+      logger.error('The path provided in --corpus-dir argument does not exist')
+      return False
+    corpus_dir = os.path.realpath(args.corpus_dir)
+    run_args.extend([
+        '-v',
+        '{corpus_dir}:/tmp/{fuzzer}_corpus'.format(corpus_dir=corpus_dir,
+                                                   fuzzer=args.fuzzer_name)
+    ])
+
+  run_args.extend([
+      '-v',
+      '%s:/out' % args.project.out,
+      '-t',
+      BASE_RUNNER_IMAGE,
+      'run_fuzzer',
+      args.fuzzer_name,
+  ] + args.fuzzer_args)
+
+  return docker_run(run_args, architecture=args.architecture)
+
+
+def fuzzbench_run_fuzzer(args):
+  """Runs a fuzz target built by fuzzbench in the container."""
+  if not check_project_exists(args.project):
+    return False
+
+  env = [
+      'FUZZING_ENGINE=' + args.engine,
+      'SANITIZER=' + args.sanitizer,
+      'RUN_FUZZER_MODE=interactive',
+      'HELPER=True',
+      f'FUZZ_TARGET={args.fuzzer_name}',
+      f'BENCHMARK={args.project.name}',
+      'TRIAL_ID=1',
+      'EXPERIMENT_TYPE=bug',
+  ]
+
+  if args.e:
+    env += args.e
+
+  run_args = _env_to_docker_args(env)
+
+  if args.corpus_dir:
+    if not os.path.exists(args.corpus_dir):
+      logger.error('The path provided in --corpus-dir argument does not exist')
+      return False
+    corpus_dir = os.path.realpath(args.corpus_dir)
+    run_args.extend([
+        '-v',
+        '{corpus_dir}:/tmp/{fuzzer}_corpus'.format(corpus_dir=corpus_dir,
+                                                   fuzzer=args.fuzzer_name)
+    ])
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    tmp_dir = os.path.abspath(tmp_dir)
+    fuzzbench_path = os.path.join(tmp_dir, 'fuzzbench')
+    subprocess.run([
+        'git', 'clone', 'https://github.com/google/fuzzbench', '--depth', '1',
+        fuzzbench_path
+    ],
+                   check=True)
+    run_args.extend([
+        '-v',
+        f'{args.project.out}:/out',
+        '-v',
+        f'{fuzzbench_path}:{fuzzbench_path}',
+        '-e',
+        f'FUZZBENCH_PATH={fuzzbench_path}',
+        f'aixcc-afc/{args.project.name}',
+        'fuzzbench_run_fuzzer',
+        args.fuzzer_name,
+    ] + args.fuzzer_args)
+
+    return docker_run(run_args, architecture=args.architecture)
+
+
+def fuzzbench_measure(args):
+  """Measure results from fuzzing with fuzzbench."""
+  if not check_project_exists(args.project):
+    return False
+
+  with tempfile.TemporaryDirectory() as tmp_dir:
+    tmp_dir = os.path.abspath(tmp_dir)
+    fuzzbench_path = os.path.join(tmp_dir, 'fuzzbench')
+    subprocess.run([
+        'git', 'clone', 'https://github.com/google/fuzzbench', '--depth', '1',
+        fuzzbench_path
+    ],
+                   check=True)
+    run_args = [
+        '-v', f'{args.project.out}:/out', '-v',
+        f'{fuzzbench_path}:{fuzzbench_path}', '-e',
+        f'FUZZBENCH_PATH={fuzzbench_path}', '-e', 'EXPERIMENT_TYPE=bug', '-e',
+        f'FUZZ_TARGET={args.fuzz_target_name}', '-e',
+        f'FUZZER={args.engine_name}', '-e', f'BENCHMARK={args.project.name}',
+        f'aixcc-afc/{args.project.name}', 'fuzzbench_measure'
+    ]
+
+    return docker_run(run_args, 'x86_64')
+
+
+def reproduce(args):
+  """Reproduces a specific test case from a specific project."""
+  return reproduce_impl(args.project, args.fuzzer_name, args.valgrind, args.e,
+                        args.fuzzer_args, args.testcase_path, args.architecture, 
+                        args.propagate_exit_codes, args.err_result, 
+                        privileged=args.privileged, timeout=args.timeout)
+
+
+def reproduce_impl(  # pylint: disable=too-many-arguments
+    project,
+    fuzzer_name,
+    valgrind,
+    env_to_add,
+    fuzzer_args,
+    testcase_path,
+    architecture='x86_64',
+    propagate_exit_codes=False,
+    err_result=1,
+    run_function=docker_run,
+    privileged=True,
+    timeout=None):
+  """Reproduces a testcase in the container."""
+
+  if not check_project_exists(project):
+    return err_result if propagate_exit_codes else False
+
+  if not _check_fuzzer_exists(project, fuzzer_name, architecture):
+    return err_result if propagate_exit_codes else False
+
+  debugger = ''
+  env = ['HELPER=True', 'ARCHITECTURE=' + architecture]
+  image_name = 'base-runner'
+
+  if valgrind:
+    debugger = 'valgrind --tool=memcheck --track-origins=yes --leak-check=full'
+
+  if debugger:
+    image_name = 'base-runner-debug'
+    env += ['DEBUGGER=' + debugger]
+
+  if env_to_add:
+    env += env_to_add
+
+  run_args = _env_to_docker_args(env) + [
+      '-v',
+      '%s:/out' % project.out,
+      '-v',
+      '%s:/testcase' % _get_absolute_path(testcase_path),
+      '-t',
+      'ghcr.io/aixcc-finals/%s%s' % (image_name, BASE_IMAGE_TAG),
+      'reproduce',
+      fuzzer_name,
+      '-runs=100',
+  ] + fuzzer_args
+
+  return run_function(run_args, architecture=architecture, propagate_exit_codes=propagate_exit_codes, privileged=privileged, timeout=timeout)
+
+
+def _validate_project_name(project_name):
+  """Validates |project_name| is a valid OSS-Fuzz project name."""
+  if len(project_name) > MAX_PROJECT_NAME_LENGTH:
+    logger.error(
+        'Project name needs to be less than or equal to %d characters.',
+        MAX_PROJECT_NAME_LENGTH)
+    return False
+
+  if not VALID_PROJECT_NAME_REGEX.match(project_name):
+    logger.info('Invalid project name: %s.', project_name)
+    return False
+
+  return True
+
+
+def _validate_language(language):
+  if not LANGUAGE_REGEX.match(language):
+    logger.error('Invalid project language %s.', language)
+    return False
+
+  return True
+
+
+def _create_build_integration_directory(directory):
+  """Returns True on successful creation of a build integration directory.
+  Suitable for OSS-Fuzz and external projects."""
+  try:
+    os.makedirs(directory)
+  except OSError as error:
+    if error.errno != errno.EEXIST:
+      raise
+    logger.error('%s already exists.', directory)
+    return False
+  return True
+
+
+def _template_project_file(filename, template, template_args, directory):
+  """Templates |template| using |template_args| and writes the result to
+  |directory|/|filename|. Sets the file to executable if |filename| is
+  build.sh."""
+  file_path = os.path.join(directory, filename)
+  with open(file_path, 'w') as file_handle:
+    file_handle.write(template % template_args)
+
+  if filename == 'build.sh':
+    os.chmod(file_path, 0o755)
+
+
+def generate(args):
+  """Generates empty project files."""
+  return _generate_impl(args.project, args.language)
+
+
+def _get_current_datetime():
+  """Returns this year. Needed for mocking."""
+  return datetime.datetime.now()
+
+
+def _base_builder_from_language(language):
+  """Returns the base builder for the specified language."""
+  return LANGUAGE_TO_BASE_BUILDER_IMAGE[language]
+
+
+def _generate_impl(project, language):
+  """Implementation of generate(). Useful for testing."""
+  if project.is_external:
+    # External project.
+    project_templates = templates.EXTERNAL_TEMPLATES
+  else:
+    # Internal project.
+    if not _validate_project_name(project.name):
+      return False
+    project_templates = templates.TEMPLATES
+
+  if not _validate_language(language):
+    return False
+
+  directory = project.build_integration_path
+  if not _create_build_integration_directory(directory):
+    return False
+
+  logger.info('Writing new files to: %s.', directory)
+
+  template_args = {
+      'project_name': project.name,
+      'base_builder': _base_builder_from_language(language),
+      'language': language,
+      'year': _get_current_datetime().year
+  }
+  for filename, template in project_templates.items():
+    _template_project_file(filename, template, template_args, directory)
+  return True
+
+
+def shell(args):
+  """Runs a shell within a docker image."""
+  if not build_image_impl(args.project):
+    return False
+
+  env = [
+      'FUZZING_ENGINE=' + args.engine,
+      'SANITIZER=' + args.sanitizer,
+      'ARCHITECTURE=' + args.architecture,
+      'HELPER=True',
+  ]
+
+  if args.project.name != 'base-runner-debug':
+    env.append('FUZZING_LANGUAGE=' + args.project.language)
+
+  if args.e:
+    env += args.e
+
+  if is_base_image(args.project.name):
+    image_project = 'aixcc-finals'
+    project_full = 'ghcr.io/%s/%s%s' % (image_project, args.project.name, BASE_IMAGE_TAG)
+    out_dir = _get_out_dir()
+  else:
+    image_project = 'aixcc-afc'
+    project_full = '%s/%s:%s' % (image_project, args.project.name, args.docker_image_tag)
+    out_dir = args.project.out
+
+  run_args = _env_to_docker_args(env)
+  if args.source_path:
+    workdir = _workdir_from_dockerfile(args.project)
+    run_args.extend([
+        '-v',
+        '%s:%s' % (_get_absolute_path(args.source_path), workdir),
+    ])
+
+
+  run_args.extend([
+      '-v',
+      '%s:/out' % out_dir, '-v',
+      '%s:/work' % args.project.work, '-t',
+      '%s' % (project_full), '/bin/bash'
+  ])
+
+  docker_run(run_args, architecture=args.architecture)
+  return True
+
+
+def pull_images(language=None):
+  """Pulls base images used to build projects in language lang (or all if lang
+  is None)."""
+  for base_image_lang, base_images in BASE_IMAGES.items():
+    if (language is None or base_image_lang == 'generic' or
+        base_image_lang == language):
+      for base_image in base_images:
+        if not docker_pull(base_image):
+          return False
+
+  return True
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-commons-compress-full-01-vuln_1/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_1/fuzz-tooling/infra/pytest.ini

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

local-test-commons-compress-full-01-vuln_1/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_1/fuzz-tooling/infra/run_fuzzers.Dockerfile

@@ -0,0 +1,31 @@
+# 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.
+#
+################################################################################
+# Docker image for running fuzzers on CIFuzz (the run_fuzzers action on GitHub
+# actions).
+
+FROM ghcr.io/aixcc-finals/cifuzz-base
+
+# Python file to execute when the docker container starts up.
+# We can't use the env var $OSS_FUZZ_ROOT here. Since it's a constant env var,
+# just expand to '/opt/oss-fuzz'.
+ENTRYPOINT ["python3", "/opt/oss-fuzz/infra/cifuzz/run_fuzzers_entrypoint.py"]
+
+WORKDIR ${OSS_FUZZ_ROOT}/infra
+
+# Copy infra source code.
+ADD . ${OSS_FUZZ_ROOT}/infra
+
+RUN python3 -m pip install -r ${OSS_FUZZ_ROOT}/infra/cifuzz/requirements.txt

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/templates.py

@@ -0,0 +1,119 @@
+# Copyright 2016 Google Inc.
+#
+# 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.
+#
+################################################################################
+"""Templates for OSS-Fuzz project files."""
+
+PROJECT_YAML_TEMPLATE = """\
+homepage: "<your_project_homepage>"
+language: %(language)s
+primary_contact: "<primary_contact_email>"
+main_repo: "https://path/to/main/repo.git"
+file_github_issue: true
+"""
+
+DOCKER_TEMPLATE = """\
+# Copyright %(year)d 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.
+#
+################################################################################
+
+FROM ghcr.io/aixcc-finals/%(base_builder)s
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+RUN git clone --depth 1 <git_url> %(project_name)s     # or use other version control
+WORKDIR %(project_name)s
+COPY build.sh $SRC/
+"""
+
+EXTERNAL_DOCKER_TEMPLATE = """\
+FROM ghcr.io/aixcc-finals/%(base_builder)s:v1
+RUN apt-get update && apt-get install -y make autoconf automake libtool
+COPY . $SRC/%(project_name)s
+WORKDIR %(project_name)s
+COPY .clusterfuzzlite/build.sh $SRC/
+"""
+
+BUILD_TEMPLATE = """\
+#!/bin/bash -eu
+# Copyright %(year)d 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 project
+# e.g.
+# ./autogen.sh
+# ./configure
+# make -j$(nproc) all
+
+# build fuzzers
+# e.g.
+# $CXX $CXXFLAGS -std=c++11 -Iinclude \\
+#     /path/to/name_of_fuzzer.cc -o $OUT/name_of_fuzzer \\
+#     $LIB_FUZZING_ENGINE /path/to/library.a
+"""
+
+EXTERNAL_BUILD_TEMPLATE = """\
+#!/bin/bash -eu
+
+# build project
+# e.g.
+# ./autogen.sh
+# ./configure
+# make -j$(nproc) all
+
+# build fuzzers
+# e.g.
+# $CXX $CXXFLAGS -std=c++11 -Iinclude \\
+#     /path/to/name_of_fuzzer.cc -o $OUT/name_of_fuzzer \\
+#     $LIB_FUZZING_ENGINE /path/to/library.a
+"""
+
+EXTERNAL_PROJECT_YAML_TEMPLATE = """\
+language: %(language)s
+"""
+
+TEMPLATES = {
+    'build.sh': BUILD_TEMPLATE,
+    'Dockerfile': DOCKER_TEMPLATE,
+    'project.yaml': PROJECT_YAML_TEMPLATE
+}
+
+EXTERNAL_TEMPLATES = {
+    'build.sh': EXTERNAL_BUILD_TEMPLATE,
+    'Dockerfile': EXTERNAL_DOCKER_TEMPLATE,
+    'project.yaml': EXTERNAL_PROJECT_YAML_TEMPLATE
+}

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/test

@@ -0,0 +1 @@
+

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/infra/test_repos.py

@@ -0,0 +1,84 @@
+# 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.
+"""This module contains a list of test repository's used in unit/integration
+tests.
+
+Note: If you notice tests failing for unexpected reasons, make sure the data
+in the test repos are correct. This is because the test repos are dynamic and
+may change.
+
+Note: This should be removed when a better method of testing is established.
+"""
+
+import collections
+import os
+
+ExampleRepo = collections.namedtuple('ExampleRepo', [
+    'project_name', 'oss_repo_name', 'git_repo_name', 'image_location',
+    'git_url', 'new_commit', 'old_commit', 'intro_commit', 'fuzz_target',
+    'testcase_path'
+])
+
+TEST_DIR_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+                             'testcases')
+
+# WARNING: Tests are dependent upon the following repos existing and the
+# specified commits existing.
+# TODO(metzman): Fix this problem.
+# TODO(metzman): The testcases got deleted here because the test that used them
+# was skipped. Probably worth deleting the test.
+TEST_REPOS = [
+    ExampleRepo(project_name='curl',
+                oss_repo_name='curl',
+                git_repo_name='curl',
+                image_location='/src',
+                git_url='https://github.com/curl/curl.git',
+                old_commit='df26f5f9c36e19cd503c0e462e9f72ad37b84c82',
+                new_commit='dda418266c99ceab368d723facb52069cbb9c8d5',
+                intro_commit='df26f5f9c36e19cd503c0e462e9f72ad37b84c82',
+                fuzz_target='curl_fuzzer_ftp',
+                testcase_path=os.path.join(TEST_DIR_PATH, 'curl_test_data')),
+    ExampleRepo(project_name='libarchive',
+                oss_repo_name='libarchive',
+                git_repo_name='libarchive',
+                image_location='/src',
+                git_url='https://github.com/libarchive/libarchive.git',
+                old_commit='5bd2a9b6658a3a6efa20bb9ad75bd39a44d71da6',
+                new_commit='458e49358f17ec58d65ab1c45cf299baaf3c98d1',
+                intro_commit='840266712006de5e737f8052db920dfea2be4260',
+                fuzz_target='libarchive_fuzzer',
+                testcase_path=os.path.join(TEST_DIR_PATH,
+                                           'libarchive_test_data')),
+    ExampleRepo(project_name='gonids',
+                oss_repo_name='gonids',
+                git_repo_name='gonids',
+                image_location='/root/go/src/github.com/google/',
+                git_url='https://github.com/google/gonids',
+                old_commit='',
+                new_commit='',
+                intro_commit='',
+                fuzz_target='',
+                testcase_path='')
+]
+
+INVALID_REPO = ExampleRepo(project_name='notaproj',
+                           oss_repo_name='notarepo',
+                           git_repo_name='notarepo',
+                           git_url='invalid.git',
+                           image_location='/src',
+                           old_commit='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                           new_commit='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                           intro_commit='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+                           fuzz_target='NONEFUZZER',
+                           testcase_path='not/a/path')