How to untar safely, without polluting the current directory in case of a tarbomb?

Question

Respectable projects release tar archives that contain a single directory, for instance zyrgus-3.18.tar.gz contains a zyrgus-3.18 folder which in turn contains src, build, dist, etc.

But some punk projects put everything at the root :'-( This results in a total mess when unarchiving. Creating a folder manually every time is a pain, and unnecessary most of the time.

• Is there a super-fast way to tell whether a .tar or .tar.gz file contains more than a single directory at its root? Even for a big archive.
• Or even better, is there a tool that in such cases would create a directory (name of the archive without the extension) and put everything inside?

Answer 1

patool handles different kinds of archives and creates a subdirectory in case the archive contains multiple files to prevent cluttering the working directory with the extracted files.

Extract archive

patool extract archive.tar

To obtain a list of the supported formats, use patool formats.

Answer 2

You could do something like

tar tf thefile.tar | cut -d/ -f1 | sort -u

to see what top-level entries a tar has; pipe to wc -l to check if there's more than one. Note that there are a few cases where this would fail, e.g. if the tar contains file paths of the form somedir/whatever and also ./somedir/whatever (or something crazier); this should be uncommon, though.

This will read the whole tar file before outputting anything, because of the sort, though it should be faster than actually extracting because it's just one sequential read and it can skip large files.

If you're doing this interactively and the file might be large, you can change sort -u to uniq and Control+C if it prints out more than one thing.

Answer 3

you can do:

pax <some.tar

...to list the contents of a tar file.

if you want to know how many levels deep it goes, you can do:

pax <some.tar | tr -dc /\\n | sort -r | head -n1

you can explicitly forbid an explosion on extraction with:

mkdir some.tar
pax -'rs|^|some.tar/|' <some.tar

Answer 4

This should do what you want. I'm sure someone can improve it. In these examples I assume a gzip compressed tar archive since this is the most common.

You want an archive where there are no sibling nodes in the root level directory tree.

Every entry in the tar content list must begin with the same pattern. This pattern is the base directory path that all entries in the archive must share. If any two entries do not begin with the same pattern then they are siblings.

The first line in the tar content list will give you the minimal pattern you need to check for. This is the BASEPATH.

BASEPATH=$(tar ztf example.tar.gz | (read line; echo $line))

Then to test for explosive tarballs you need to check if any line of the tar content list does not begin with the BASEPATH.

tar ztf example.tar.gz | grep -qv "^${BASEPATH}"

Turn this into a shell function:

is_explosive() {
    TARBALL_NAME=$1
    tar ztf "${TARBALL_NAME}" | grep -qv "^$(tar ztf "${TARBALL_NAME}" | (read line; echo ${line}))"
    return $?
}

From here you can write a safe tar archive extraction function.

is_explosive() {
    TARBALL_NAME=$1
    tar ztf "${TARBALL_NAME}" | grep -qv "^$(tar ztf "${TARBALL_NAME}" | (read line; echo ${line}))"
    return $?
}

safe_tar_x() {
    TARBALL_NAME=$1
    if is_explosive ${TARBALL_NAME}; then
        SUBDIR=${TARBALL_NAME%.tar.gz}
        SUBDIR=${SUBDIR##*/}
        mkdir "${SUBDIR}"
        echo "WARNING: This tarball is explosive. Opening in subdirectory, ${SUBDIR}, for safety." >&2
    else
        SUBDIR="."
    fi
    # Tar quirks: "--directory" must be last, and using more than
    #     one option group requires that all groups start with a dash.
    tar -zxf "${TARBALL_NAME}" --directory "${SUBDIR}"
    return $?
}

Answer 5

aunpack archive.tar is what I use.

Part of the good old atool package. Manpage: https://linux.die.net/man/1/atool