Remove duplicate test.

The exact same thing is tested 20 lines earlier.

Fix encryption end writing for external fileobjs.

The fix in commit 867f75f78 for fixing offset calculations did not
take into account that file objects could be given from external code.

Correct that case.

minor improvements

avoid another warning

tried to add test_deltatar.DeltaTarBz2[Stream]Test to run_long_tests but failed

created script for running long tests similar to runtests.py

renamed test method

make fast_fail and print_everything function params; return n_errs from run_forever

need to check whether _Stream has an _extfileobj, otherwise 2nd close will raise OSError

need to be more carful in determining whether is multi-volume or not

created Unittest for test_volume_split

improve output

done testing --> disable test output

exclude another incomatible read-write-mode-combination

fix test: check for RECORDSIZE of first volume only if new compressing/encrypting

continue testing of volume split with compressed archives; may have found another TarFile bug

volume split test working enough to find first bugs...

created new test for volume splitting with compressed (and some day encrypted) files

remove close that is not needed any more

skip another multi-volume unittest that gives warning/raises error if compressing

close a few files that are given as external fileobj to TarFile in unittests

remove closing_new_volume_handler since tarfile does the closing now on its own

do not run compression level suite if args are given to runtest

fail unittest if expected exception does not happen; close tar in any case

rename volume_size_accuracy to test_volume_size_accuracy to fit pattern of unittests

add unittest to volume_size_accuracy

preparations for adding unittests to volume_size_accuracy

- rename main to run_all_tests
- rename test to do_test
- make fast_fail and print_everything params

also extract temp files and check size and contents

some fine-tuning: clarify documentation, add variables for easier debugging

test of precise handling of volume+file sizes finally working for uncompressed+unencrypted data

moved specification of expectations out of test() function; deal with RECORDSIZE; nearly done

implemented volume size accuracy test before realizing RECORDSIZE

added stub with plan for new volume_size_accuracy test

check for multi-volume compatibility of tar modes also if reading

for reading, there is no max_volume_size but a new_volume_handler given

when changing volume, then also close external file object in _Stream

Ensure files are closed when starting new volume.

Move closing of old volume from handler to own code (handlers might
try to close again, should not be a problem).

Also ensure files are closed if volume handler fails.

update comment: the "-2 * BLOCKSIZE" in size_left has 2 reasons, not just 1

improve debug output in TarFile

- clarify in debug output from TarFile._dbg where it comes from via prefix
- mention name of new volume in output

added a print_func arg to TarFile.list to allow output to log or other

force max_volume_size >= RECORDSIZE since last volume is filled with 0s until RECORDSIZE

bpo-32713: Fix tarfile.itn for large/negative float values. (GH-5434)

Import the tarfile changes from commit:

    commit 72d9b2be36f091793ae7ffc5ad751f040c6e6ad3
    Author: Joffrey F <f.joffrey@gmail.com>
    Date:   Mon Feb 26 16:02:21 2018 -0800

        bpo-32713: Fix tarfile.itn for large/negative float values. (GH-5434)

which add a safeguard against the type level volatility of
os.stat_result which will return a float instead of an int if e.
g. st_mtime becomes negative due to the timezone.

Increase version to 2.2

Merge branch 'crypto-review'

Crypto auditor is happy with our changes.

add support for PDT encryption to run_benchmark.py

The script was still expecting the encryption to be handled in
the pre-crypto.py fashion.

Paths need some preparing as well so we can inject a deltatar
from arbitrary locations; the $DELTATAR environment variable
is used for this.

fix usage info in run_benchmark

add utility for profiling memory usage of encryption

document future transition to AES-GCM-SIV as possibility

Address Deltatar audit item 2.6/1: miscellaneous suggestions

It would be great if we could add support for SIV but there are
no immediate plans for doing so.

state the consequences of disabling integrity checks in rescue and recovery mode

Address Deltatar audit item 2.4: exploitability of disaster
recovery

Clarify that recovery mode can enable an attacker to recover
plaintext of encrypted backups under certain conditions and
should only be used as a last resort.

allow checking PDTCRYPT archives for IV integrity with crypto.py

This allows checking the IVs of objects in the given file for
uniqueness and consecutiveness without decrypting them.

Example:

    $ crypto.py ivcheck -i - <bfull-2020-04-20-1133-001.tar.gz.pdtcrypt
    PDT: Successfully traversed 411 encrypted objects in input.
    PDT:
    PDT: All IVs consecutive and unique.

enable strict IV checking by default during decryption

Address Deltatar audit item 2.3: Ciphertexts can be re-ordered or
dropped when decryption is non-linear

Set *decryption* contexts to validate IVs unless the user opts out.
This requires sprinkling options for non-strict behavior wherever
a decryption context might be created, and disabling the strict
checking for APIs intended for use with possibly corrupted inputs.

During a normal *encryption* when only a single Encrypt handle is
used, the IVs are guaranteed unique. Strict tracking of IVs is
only necessary in testing and when working with multiple Encrypt
handles so used IVs are to be compared across handlers
afterwards. Thus we need not enable the ``strict_ivs'' option for
Encrypt handles.

clarify possible IV reuse with multiple Encrypt handles

Address Deltatar audit item 2.2: Unsafe to create more than 2^32
instances of Encrypt using the same key and salt

Extend the documentation section on handling of IVs with a
paragraph concerning multiple Encrypt handles. Also add a method
to obtain the list of IVs for checks performed by the caller.

deny insecure parameters by default

Address Deltatar audit item 2.1: Violating data integrity using
passthrough mode.

The ciphertext is assumed attacker controlled. This allows a
downgrade to plaintext by setting the parameter version to
plaintext passthrough on an encrypted object, bypassing integrity
protection. Reduce the susceptibility to this attack by refusing
to continue if such a header is encountered in the input.
Passthrough mode is still available if the *insecure* flag is
passed to the constructors of the encryption / decryption
handles.

skip exclusive branch

Of the two conditions only one can ever apply, so skip evaluating
the second one if the first branch was taken.

Increase version to 2.1

python 3.7 support: Track cpython removal of re._pattern_type

Another sneaky backward incompatibility introduced by Python 3.7.
https://github.com/python/cpython/pull/1646

Merge branch 'tarfile-unlink'

unit test unlink protection for tarfile

Add a separate test series that uses Tarfile directly, bypassing
DeltaTar because the latter does not allow fine-grained control
over what mitigations are active.

fix check for symlink path in unittest

os.path.exists() will return false in the event that it is passed
a broken symlink which defeats the point of testing whether the
link itself exists. use path.lexist() instead which properly
checks with O_NOFOLLOW.

add unlink-before-extract behavior for tarfile

Implement optional removal of existing files analogous to the -U
option of GNU tar and bsdtar. This is an effective measure
against symlink attacks which tarfile.py is not capable of
mitigating.

Signed-off-by: Philipp Gesang <philipp.gesang@intra2net.com>

Increase version to 2.0

Major feature: New AES-GCM based crypto layer.

Merge branch 'bug-6440_open-race'

fix incorrect error handling in deltatar

Account for the fact that the os library converts return values
to exceptions ... It is not documented whether os.open() can ever
return negative values at all.

extend fs access test to compress and crypto variant

guard call to stat() against ENOENT

Move the implicit call to stat(2) into the ENOENT-safe block we
just introduced.

Found by unit testing.

add unit test for mishandling access(3)

Replace os.access() with a dummy to check deltatar behavior
against racey file system checks.

drop os.exists() before makedirs()

os.makedirs() has proper EEXIST handling builtin. Checking with
``os.exists()`` is both redundant and inherently racy.

fix access race when traversing the filesystem

Related to issue #6440.

Yet another race caused by mishandling of access(3); fix by
acquiring an fd to the directory and use that for iteration.
Handle ENOENT around open(2) and throw out the call to
os.path.exists().

fix crash on unaccessible input files

Fix i2n bug #6440: race condition between access(3) and open(2).

This flaw exists in both the full and diff backup code. Deltatar
must not assume that the verdict returned by access() will hold
true later. Emit a warning if we receive ENOENT on later calls to
open(), but continue regardless.

Merge branch 'crypto'. Yes!

treat binary data as binary data

The script ``file_crypt.py'' was opening both the source and the
sink in ``text mode'' which already messes with the input, then
encoding the result as UTF-8 encoded strings before writing
it back. Needless to say this was corrupting data all over the
place as soon as the payload contained non-ASCII bytes.

remove unused argument

Different encryption modes vanished with the revised crypto that
only implements AES-GCM.

unit test detection of non-consecutive ivs

The detection works as expected except for a bug in the exception
formatting.

guard invocations of tar from interactive mode

On failure, tests may cause GNU tar to prompt for user input like
for example volume names etc. which may interrupt the test run.
Prevent that by passing /dev/null wherever we shell out to tar.

fix resource leaks building recovery index

Python 3.7 now emits warnings about possible resource leaks
of which deltatar provokes plenty. The main culprit here is
manual resource management of file handles in face of early
returns by exception.

validate data lengths against value in header

When decrypting we need to ensure that the decryptor will not
blindly accept data past the size that was specified by the
current object's header. Note that processing trailing data would
fail eventually when the GCM tag is checked; this check just
catches that case earlier.

fix incorrect unit test description

The process() method signals the caller that the maximum data length
has been reached by returning a ciphertext that is shorter than
the plaintext. The caller must then continue by finalizing the
current object and starting a new one.

The behavior in this case was changed in cb7a3911f8 to not
propagate the exception from Cryptography, but the unit test
retained the erroneous description.

improve unit test SNR

turn API-mandated no-op into assertion

Make it explicit that there cannot actually be a rest data when
finalizing an encrypted object. The Cryptography API mandates
that the caller handle the remainder of the data on finalization.
By virtue of being a stream cipher, the AES-GCM encoder always
returns the exact number of bytes that it was given so
technically the rest is meaningless.

account for one-tuple return

For some reason, feeding ``(0,)'' into os.read() as the length
argument fails with newer versions of python. Fix this by
unpacking the single element ``tuple'' before using it.

Document source of the AES GCM size limit

Also verified our bit left shift operations match the numbers.

Mention sibling UT for the test_crypto_aes_gcm_enc_length_cap() test

Fix up docstring of test_create_backup_index_max_file_length()

Extend unit test for larger than GCM encrytion size

Add a few corner cases in addition to the existing test:

* MAX_SIZE-1
* MAX_SIZE
* 2*MAX_SIZE + 1

Fix indentation of 'else' block

Right now this affects the debug output only.

Fix up check_consecutive_iv()

It was using the wrong variable to store the previously used IV.

Clarify two functions are meant to be used by desaster recovery

Remove upstream GCM issue that was resolved

Remove outdated author information

Change unit tests to check for expected exception

It would be an error if the expected exception is not thrown
f.e. for re-use of IVs.

Fix position of [-c] handler in usage

It won't work the other way around.

Fix wrong script name in usage help

Increase version to 1.6

Fix use of wrong 'i' variable name

pylint complained:
tarfile.py:3797:38: E0602: Undefined variable 'i' (undefined-variable)

Code was introduced like this in

commit 27ee4dd4df48340541317123f5df348056c235ca
Author:     Philipp Gesang <philipp.gesang@intra2net.com>
AuthorDate: Tue Aug 29 12:00:54 2017 +0200

    implement volume handling for rescue mode

    When reconstructing the index, traverse backup volumes and set
    the “volume” member on the objects appropriately.

-> I guess 'i' was renamed to nvol for better readability.

Fix errno.ESPIPE error handler

pylint complained:
crypto.py:1632:28: E1101: Module 'os' has no 'errno' member (no-member)

Add missing iv fixed part in error output

pylint complained:
crypto.py:1357:36: E1306: Not enough arguments for format string (too-few-format-args)

Fix 'pw' variable name in error handling

pylint complained:
crypto.py:840:40: E0602: Undefined variable 'password' (undefined-variable)

Documentation improvements

remove development tweak for test runner

This essentially reverts

    commit 406e0fa86d97f912b50689d6b080c2aee69eef86
    Author: Philipp Gesang <philipp.gesang@intra2net.com>
    Date:   Tue Apr 18 11:59:02 2017 +0200

        allow selecting individual tests with runtests.py

Tests and files for all imported test classes may still take some
moments but we don’t need to skip them any longer.

handle problems with incomplete gzip headers

Throw the appropriate exn to signal EOF or malformed data
conditions when tentatively parsing GZip headers.

add tests for truncated files