"""Make a delivered file out of an upstream file: take a member out of a zip or tar archive, decompress, turn a hex dump or a uuencoded file back into bytes, recompress. Standard library only, so it can sit next to fetch.py and to_pool.py and be imported by both. A transform is a list of steps, applied in order: unzip: the member with exactly this name inside a zip archive (a directory entry is refused) bunzip2 decompress bzip2 (several concatenated streams are read as one) gunzip decompress gzip (several concatenated members are read as one) unxz decompress xz (several concatenated streams are read as one) untar: the member with exactly this name inside an uncompressed tar archive (put unxz, gunzip or bunzip2 before it for a compressed one); it must be a regular file, read at its full size when it is stored sparse; a member that is a link, a directory or a device is refused, and so is a name that is absolute, has a .. part, or is found more than once in the archive unxxd turn a hex dump written by xxd (or xxd -a) back into bytes, without running xxd; see below uudecode turn a uuencoded file back into bytes, without running uudecode; see below uncompress decompress a .Z file written by Unix compress (LZW), without running uncompress; see below gzip compress with gzip at level 9, modification time 0 and no file name in the header; allowed once, as the last step validate(steps) checks a list of steps and raises ValueError for anything else. apply(src_path, steps, out_path) writes the result to out_path (atomically: a temporary file in the same directory, renamed at the end) and returns {"sha256", "bytes", "content_sha256"}: the sha256 and size of the written file, and the sha256 of the bytes before a final gzip step (equal to sha256 when the last step is not gzip). The gzip bytes depend on the zlib build, so compare content_sha256 to check a transform made elsewhere. Only the named member is read out of an archive, and the result is written only to out_path: no name found inside an archive is ever used as a path. The output of unxz, untar, unxxd, uudecode and uncompress may be at most max_bytes (a keyword of apply; default MAX_BYTES, 256,000,000 bytes; None for no limit): apply stops as soon as it passes and raises TooLarge, a ValueError. A tar member whose size, counted at its expanded size when it is stored sparse, is more than the limit is refused before it is read. The other steps have no limit. unxxd reads only the default layout of xxd: each line is an offset of 8 lowercase hex digits, a colon and a space, 16 bytes in groups of two bytes (4 lowercase hex digits) parted by one space, two spaces and the text column. The text column is not compared with the bytes; it must hold one character per byte. The first line has offset 0 and each line starts where the one before it ended. Only the last line may hold fewer than 16 bytes; its hex part is padded with spaces to the full width. A line holding only * (written by xxd -a) means that the bytes from the end of the line before it up to the offset of the line after it are all zero: the line before it must hold 16 zero bytes, the line after it must be a line of bytes, and the zero bytes it stands for must be a whole number of 16-byte lines, at least one. Every line ends with a newline (a carriage return is refused), and an empty file gives an empty output. Anything else is refused: nothing is guessed. The whole dump is read and checked, and the length of the output counted, before anything is written, so a dump that is bad anywhere or whose output would pass max_bytes writes nothing. uudecode decodes the lines between the first line of the form "begin " (mode in octal digits) and the first line "end" after it, each with binascii.a2b_uu; lines before the begin line and after the end line are skipped. The name on the begin line is never used: the output goes only to out_path. A file with no begin line, with a second begin line, with no end line after the begin line, or with a line between them that does not decode is refused. A line may end with a carriage return before its newline. uncompress reads the .Z format of Unix compress: the magic bytes 1f 9d, a flags byte whose low five bits are the maximum code width (9 to 16 bits) and whose high bit is block mode (code 256 then clears the table), and then LZW codes of 9 bits up to that width, packed from the low bit up. Codes are read in groups of eight, as the original compress writes them: when the width grows, or after a clear code, the remaining codes of the current group are skipped and the next group starts at the new width. As in the original compress (and in gzip -d), with a maximum width of 9 the codes still grow to 10 bits once the table is full, so a file written by ncompress -b 9 does not decode here, as it does not with ncompress or gzip either. Bits at the end too few for one more code are ignored. A wrong magic, a maximum width outside 9 to 16, a first code that is not a byte, and a code that is not yet in the table (other than the next one to be added, the KwKwK case) are refused. The output is written as it is decoded. Bad archives, a missing member and corrupt compressed data raise ValueError; reading or writing errors (a missing source file, a full disk) raise OSError. Deletes: the step outputs .transform-*.part that apply made with tempfile.mkstemp next to the output (listed one by one in its temps list), once the last one is renamed to the output or a step fails: temporary files. """ from __future__ import annotations import binascii import bz2 import gzip import hashlib import lzma import os import re import tarfile import tempfile import unicodedata import zipfile import zlib UNZIP = "unzip:" UNTAR = "untar:" SIMPLE = ("bunzip2", "gunzip", "unxz", "unxxd", "uudecode", "uncompress", "gzip") MAX_BYTES = 256_000_000 GZIP_LEVEL = 9 CHUNK = 1 << 20 XXD_WIDTH = 16 _XXD_LINE = re.compile(r"([0-9a-f]{8}): ([0-9a-f ]{39}) ([ -~]*)") _XXD_HEX = re.compile(r"(?:[0-9a-f]{4} ){0,7}(?:[0-9a-f]{4}|[0-9a-f]{2})") _XXD_LINE_MAX = 128 _UU_BEGIN = re.compile(rb"begin [0-7]{1,6} +\S.*") _UU_LINE_MAX = 1024 _Z_MAGIC = b"\x1f\x9d" _Z_BLOCK_MODE = 0x80 _Z_BITS_MASK = 0x1f _Z_INIT_BITS = 9 _Z_MAX_BITS = 16 _Z_CLEAR = 256 _Z_KEEP = 256 _ZEROS = bytes(CHUNK) _DATA_ERRORS = (OSError, EOFError, zlib.error, zipfile.BadZipFile, RuntimeError, NotImplementedError, lzma.LZMAError, tarfile.TarError) class TooLarge(ValueError): """The output of a step passed max_bytes.""" def _tar_name_problem(member: str): if re.match(r"[/\\]|[A-Za-z]:", member): return "is an absolute path" if ".." in re.split(r"[/\\]", member): return "has a .. part" return None def validate(steps) -> list: """-> the steps as a new list; ValueError unless steps is a non-empty list of known steps with gzip only last.""" if not isinstance(steps, (list, tuple)) or not steps: raise ValueError(f"transform must be a non-empty list of steps, got {steps!r}") out = [] for i, s in enumerate(steps): if not isinstance(s, str): raise ValueError(f"step {i + 1} must be a string, got {s!r}") if s.startswith(UNZIP): member = s[len(UNZIP):] if not member or member.endswith("/"): raise ValueError(f"step {i + 1}: unzip needs a file member name: {s!r}") if any(unicodedata.category(c) == "Cc" for c in member): raise ValueError(f"step {i + 1}: member name has a control character: {s!r}") elif s.startswith(UNTAR): member = s[len(UNTAR):] if not member or member.endswith("/"): raise ValueError(f"step {i + 1}: untar needs a file member name: {s!r}") if any(unicodedata.category(c) == "Cc" for c in member): raise ValueError(f"step {i + 1}: member name has a control character: {s!r}") why = _tar_name_problem(member) if why: raise ValueError(f"step {i + 1}: member name {why}: {s!r}") elif s not in SIMPLE: raise ValueError(f"step {i + 1}: unknown step {s!r} " "(use unzip:, untar:, bunzip2, gunzip, unxz, unxxd, uudecode, uncompress " "or gzip)") if s == "gzip" and i != len(steps) - 1: raise ValueError(f"step {i + 1}: gzip is allowed only as the last step") out.append(s) return out def _copy(fin, fout, h=None, limit=None) -> None: n = 0 while True: b = fin.read(CHUNK) if not b: return n += len(b) if limit is not None and n > limit: raise TooLarge(f"output passes the limit of {limit} bytes") if h is not None: h.update(b) fout.write(b) def _unzip(src: str, member: str, fout) -> None: with zipfile.ZipFile(src) as zf: try: info = zf.getinfo(member) except KeyError: raise ValueError(f"no member {member!r} in the zip archive") from None if info.is_dir(): raise ValueError(f"member {member!r} is a directory") with zf.open(info) as fin: _copy(fin, fout) def _untar(src: str, member: str, fout, limit) -> None: with tarfile.open(src, "r:") as tf: found = [m for m in tf.getmembers() if m.name == member] if not found: raise ValueError(f"no member {member!r} in the tar archive") if len(found) > 1: raise ValueError(f"member {member!r} is in the tar archive {len(found)} times") info = found[0] if info.issym() or info.islnk(): raise ValueError(f"member {member!r} is a link") if not info.isfile(): raise ValueError(f"member {member!r} is not a regular file") if limit is not None and info.size > limit: raise TooLarge(f"member {member!r} is {info.size} bytes" f"{' when expanded' if info.sparse else ''}, more than the limit of {limit} bytes") fin = tf.extractfile(info) _copy(fin, fout, limit=limit) def _xxd_parts(fin): """Yield the bytes a hex dump stands for, in order: a bytes object per line, an int (that many zero bytes) per * line. Raises ValueError at the first thing that does not fit the layout.""" pos = 0 last = None n = 0 while True: raw = fin.readline(_XXD_LINE_MAX) if not raw: break n += 1 if not raw.endswith(b"\n"): raise ValueError(f"line {n}: " + ("too long" if len(raw) >= _XXD_LINE_MAX else "no newline at the end")) try: line = raw[:-1].decode("ascii") except UnicodeDecodeError: raise ValueError(f"line {n}: not ASCII") from None if line == "*": if last is None: raise ValueError(f"line {n}: a * line cannot come first") if last == "*": raise ValueError(f"line {n}: two * lines in a row") if len(last) != XXD_WIDTH or any(last): raise ValueError(f"line {n}: the line before a * line must hold {XXD_WIDTH} zero bytes") last = "*" continue m = _XXD_LINE.fullmatch(line) hexpart = m.group(2).rstrip(" ") if m else "" if not m or not _XXD_HEX.fullmatch(hexpart): raise ValueError(f"line {n}: not a line of xxd output: {line[:80]!r}") data = bytes.fromhex(hexpart) if len(m.group(3)) != len(data): raise ValueError(f"line {n}: the text column has {len(m.group(3))} characters for {len(data)} bytes") if isinstance(last, bytes) and len(last) < XXD_WIDTH: raise ValueError(f"line {n - 1}: only the last line may hold fewer than {XXD_WIDTH} bytes") off = int(m.group(1), 16) if last == "*": gap = off - pos if gap <= 0: raise ValueError(f"line {n}: offset {off:08x} after a * line does not pass {pos:08x}") if gap % XXD_WIDTH: raise ValueError(f"line {n}: the * line before it stands for {gap} bytes, " f"not a whole number of {XXD_WIDTH}-byte lines") yield gap pos = off elif off != pos: raise ValueError(f"line {n}: offset {off:08x}, expected {pos:08x}") yield data pos += len(data) last = data if last == "*": raise ValueError("the dump ends with a * line") def _unxxd(src: str, fout, limit) -> None: with open(src, "rb") as fin: total = 0 for part in _xxd_parts(fin): total += part if isinstance(part, int) else len(part) if limit is not None and total > limit: raise TooLarge(f"output would pass the limit of {limit} bytes") fin.seek(0) for part in _xxd_parts(fin): if isinstance(part, int): while part: k = min(part, CHUNK) fout.write(_ZEROS[:k] if k < CHUNK else _ZEROS) part -= k else: fout.write(part) def _uu_lines(fin): """Yield (line number, line without its line end) for each line of fin; a line of _UU_LINE_MAX bytes or more is read to its end and yielded as None, so it never matches a begin or end line and never decodes.""" n = 0 while True: raw = fin.readline(_UU_LINE_MAX) if not raw: return n += 1 if len(raw) >= _UU_LINE_MAX and not raw.endswith(b"\n"): while raw and not raw.endswith(b"\n"): raw = fin.readline(CHUNK) yield n, None continue line = raw[:-1] if raw.endswith(b"\n") else raw if line.endswith(b"\r"): line = line[:-1] yield n, line def _uudecode(src: str, fout, limit) -> None: with open(src, "rb") as fin: state = "before" total = 0 for n, line in _uu_lines(fin): is_begin = line is not None and _UU_BEGIN.fullmatch(line) is not None if state == "before": if is_begin: state = "body" continue if is_begin: raise ValueError(f"line {n}: a second begin line") if state == "after": continue if line == b"end": state = "after" continue if line is None: raise ValueError(f"line {n}: too long for a uuencoded line") try: data = binascii.a2b_uu(line) except binascii.Error as e: raise ValueError(f"line {n}: does not decode: {e}") from None total += len(data) if limit is not None and total > limit: raise TooLarge(f"output passes the limit of {limit} bytes") fout.write(data) if state == "before": raise ValueError("no begin line") if state == "body": raise ValueError("no end line after the begin line") def _uncompress(src: str, fout, limit) -> None: with open(src, "rb") as fin: head = fin.read(3) if len(head) < 3 or head[:2] != _Z_MAGIC: raise ValueError("not a .Z file (no 1f 9d magic)") maxbits = head[2] & _Z_BITS_MASK block = bool(head[2] & _Z_BLOCK_MODE) if not _Z_INIT_BITS <= maxbits <= _Z_MAX_BITS: raise ValueError(f"maximum code width {maxbits} is outside {_Z_INIT_BITS} to {_Z_MAX_BITS}") maxmaxcode = 1 << maxbits # an entry is kept as bytes when it is at most _Z_KEEP bytes long, else as its prefix code and last byte strs = [bytes([i]) for i in range(256)] + [None] * (maxmaxcode - 256) pre = [0] * maxmaxcode suf = [0] * maxmaxcode n_bits = _Z_INIT_BITS maxcode = (1 << n_bits) - 1 free_ent = 257 if block else 256 oldcode = -1 prev = b"" total = 0 buf = bytearray() while True: group = fin.read(n_bits) if not group: break v = int.from_bytes(group, "little") mask = (1 << n_bits) - 1 for k in range(len(group) * 8 // n_bits): code = (v >> (k * n_bits)) & mask if oldcode == -1: if code >= 256: raise ValueError(f"first code {code} is not a byte") oldcode = code prev = strs[code] out = prev elif code == _Z_CLEAR and block: free_ent = 256 n_bits = _Z_INIT_BITS maxcode = (1 << n_bits) - 1 break else: if code > free_ent: raise ValueError(f"code {code} is not in the table (next entry is {free_ent})") if code == free_ent: out = prev + prev[:1] else: out = strs[code] if out is None: tail = [] c = code while out is None: tail.append(suf[c]) c = pre[c] out = strs[c] tail.reverse() out = out + bytes(tail) if free_ent < maxmaxcode: if len(prev) < _Z_KEEP: strs[free_ent] = prev + out[:1] else: strs[free_ent] = None pre[free_ent] = oldcode suf[free_ent] = out[0] free_ent += 1 oldcode = code prev = out total += len(out) if limit is not None and total > limit: raise TooLarge(f"output passes the limit of {limit} bytes") buf += out if len(buf) >= CHUNK: fout.write(buf) buf.clear() if free_ent > maxcode: n_bits += 1 maxcode = maxmaxcode if n_bits == maxbits else (1 << n_bits) - 1 break fout.write(buf) def _step(src: str, step: str, fout, content, limit=None) -> None: if step.startswith(UNZIP): _unzip(src, step[len(UNZIP):], fout) elif step.startswith(UNTAR): _untar(src, step[len(UNTAR):], fout, limit) elif step == "unxz": with lzma.open(src, "rb", format=lzma.FORMAT_XZ) as fin: _copy(fin, fout, limit=limit) elif step == "unxxd": _unxxd(src, fout, limit) elif step == "uudecode": _uudecode(src, fout, limit) elif step == "uncompress": _uncompress(src, fout, limit) elif step == "bunzip2": with bz2.open(src, "rb") as fin: _copy(fin, fout) elif step == "gunzip": with gzip.open(src, "rb") as fin: _copy(fin, fout) else: with open(src, "rb") as fin, gzip.GzipFile(filename="", mode="wb", fileobj=fout, compresslevel=GZIP_LEVEL, mtime=0) as gz: _copy(fin, gz, content) def _sha256_file(path: str) -> tuple: h = hashlib.sha256() n = 0 with open(path, "rb") as f: while True: b = f.read(CHUNK) if not b: return h.hexdigest(), n h.update(b) n += len(b) def apply(src_path, steps, out_path, *, max_bytes: int | None = MAX_BYTES) -> dict: """Apply steps to src_path, write out_path -> {"sha256", "bytes", "content_sha256"}. max_bytes limits the output of unxz, untar, unxxd, uudecode and uncompress (TooLarge when it passes).""" steps = validate(steps) src = os.fspath(src_path) out = os.path.abspath(os.fspath(out_path)) if not os.path.isfile(src): raise FileNotFoundError(src) d = os.path.dirname(out) os.makedirs(d, exist_ok=True) temps = [] cur = src content = None try: for i, step in enumerate(steps): fd, tmp = tempfile.mkstemp(dir=d, prefix=".transform-", suffix=".part") temps.append(tmp) if step == "gzip": content = hashlib.sha256() with os.fdopen(fd, "wb") as fout: limited = step in ("unxz", "unxxd", "uudecode", "uncompress") or step.startswith(UNTAR) try: _step(cur, step, fout, content, max_bytes if limited else None) except ValueError as e: kind = TooLarge if isinstance(e, TooLarge) else ValueError raise kind(f"step {i + 1} ({step}): {e}") from None except _DATA_ERRORS as e: if isinstance(e, OSError) and e.errno is not None: raise raise ValueError(f"step {i + 1} ({step}): {type(e).__name__}: {e}") from e cur = tmp sha, n = _sha256_file(cur) os.chmod(cur, 0o644) os.replace(cur, out) temps.remove(cur) finally: for t in temps: try: os.unlink(t) except OSError: pass return {"sha256": sha, "bytes": n, "content_sha256": content.hexdigest() if content is not None else sha}