kapitan 0.36.4.dev6__tar.gz → 0.36.4.dev7__tar.gz

{kapitan-0.36.4.dev6 → kapitan-0.36.4.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kapitan
-Version: 0.36.4.dev6
+Version: 0.36.4.dev7
 Summary: Generic templated configuration management for Kubernetes, Terraform and other things
 Project-URL: Homepage, https://kapitan.dev
 Project-URL: Repository, https://github.com/kapicorp/kapitan

{kapitan-0.36.4.dev6 → kapitan-0.36.4.dev7}/kapitan/dependency_manager/base.py

@@ -6,7 +6,6 @@ import hashlib
 import logging
 import multiprocessing
 import os
-import sys
 import tarfile
 from collections import defaultdict, namedtuple
 from functools import partial
@@ -36,6 +35,7 @@ from kapitan.utils import (
     normalise_join_path,
     safe_copy_file,
     safe_copy_tree,
+    safe_tar_extractall,
     unpack_downloaded_file,
 )
 
@@ -436,10 +436,7 @@ def _extract_tar_blobs(target_dir: str) -> None:
         logger.debug("Extracting OCI tar blob %s into %s", blob_path, target_dir)
         with tarfile.open(blob_path, "r:*") as tar:
             os.unlink(blob_path)
-            if sys.version_info >= (3, 12):
-                tar.extractall(target_dir, filter="data")
-            else:
-                tar.extractall(target_dir)
+            safe_tar_extractall(tar, target_dir)
 
 
 def fetch_oci_dependency(dep_mapping, save_dir, force=False, item_type="Dependency"):

{kapitan-0.36.4.dev6 → kapitan-0.36.4.dev7}/kapitan/errors.py

@@ -84,3 +84,7 @@ class CuelangTemplateError(KapitanError):
 
 class OCIFetchingError(KapitanError):
     """Raised when fetching an OCI artifact fails."""
+
+
+class UnsafeArchiveError(KapitanError):
+    """Raised when an archive member would be extracted outside its target directory."""

{kapitan-0.36.4.dev6 → kapitan-0.36.4.dev7}/kapitan/utils.py

@@ -28,7 +28,7 @@ import requests
 import yaml
 
 from kapitan import cached, defaults
-from kapitan.errors import CompileError
+from kapitan.errors import CompileError, UnsafeArchiveError
 from kapitan.jinja2_filters import (
     _jinja_error_info,
     load_jinja2_filters,
@@ -534,6 +534,57 @@ def make_request(source):
     return None, None
 
 
+def _validated_tar_members(tar, output_path):
+    """Return tar members, rejecting any that would write outside output_path.
+
+    Fallback for Python < 3.12, which has no ``data`` extraction filter.
+    """
+    dest = os.path.realpath(output_path)
+
+    def contained(path):
+        return path == dest or path.startswith(dest + os.sep)
+
+    members = tar.getmembers()
+    for member in members:
+        if member.isdev():
+            raise UnsafeArchiveError(f"{member.name}: archive contains a special file")
+        # Mirror the stdlib ``data`` filter: absolute names are stripped of
+        # their leading separator rather than rejected, so behaviour matches
+        # Python >= 3.12 exactly.
+        member.name = member.name.lstrip("/")
+        target = os.path.realpath(os.path.join(dest, member.name))
+        if not contained(target):
+            raise UnsafeArchiveError(
+                f"{member.name}: archive member escapes {output_path}"
+            )
+        if member.issym() or member.islnk():
+            anchor = os.path.dirname(target) if member.issym() else dest
+            link = os.path.realpath(os.path.join(anchor, member.linkname))
+            if not contained(link):
+                raise UnsafeArchiveError(
+                    f"{member.name}: link target escapes {output_path}"
+                )
+    return members
+
+
+def safe_tar_extractall(tar, output_path):
+    """Extract tar into output_path, refusing members that escape it.
+
+    Wraps ``TarFile.extractall`` so a malicious or compromised archive cannot
+    write outside its destination via ``..`` components, absolute paths or
+    escaping links.
+    """
+    if sys.version_info >= (3, 12):
+        try:
+            tar.extractall(path=output_path, filter="data")
+        except tarfile.FilterError as e:
+            raise UnsafeArchiveError(f"unsafe archive member: {e}") from e
+    else:
+        tar.extractall(
+            path=output_path, members=_validated_tar_members(tar, output_path)
+        )
+
+
 def unpack_downloaded_file(file_path, output_path, content_type):
     """unpacks files of various MIME type and stores it to the output_path"""
     is_unpacked = False
@@ -545,7 +596,7 @@ def unpack_downloaded_file(file_path, output_path, content_type):
 
     if content_type == "application/x-tar":
         with tarfile.open(file_path) as tar:
-            tar.extractall(path=output_path)
+            safe_tar_extractall(tar, output_path)
         is_unpacked = True
     elif content_type == "application/zip":
         with ZipFile(file_path) as zfile:
@@ -560,7 +611,7 @@ def unpack_downloaded_file(file_path, output_path, content_type):
     ]:
         if re.search(r"(\.tar\.gz|\.tgz)$", file_path):
             with tarfile.open(file_path) as tar:
-                tar.extractall(path=output_path)
+                safe_tar_extractall(tar, output_path)
             is_unpacked = True
         else:
             extension = re.findall(r"\..*$", file_path)[0]

{kapitan-0.36.4.dev6 → kapitan-0.36.4.dev7}/tests/test_utils.py

@@ -11,12 +11,15 @@ import glob
 import os
 import shutil
 import stat
+import sys
+import tarfile
 import tempfile
 import unittest
 from unittest.mock import patch
 
 import yaml
 
+from kapitan.errors import UnsafeArchiveError
 from kapitan.utils import (
     SafeCopyError,
     YamlLoader,
@@ -30,7 +33,9 @@ from kapitan.utils import (
     force_copy_file,
     get_entropy,
     prune_empty,
+    safe_tar_extractall,
     sha256_string,
+    unpack_downloaded_file,
 )
 
 
@@ -488,3 +493,139 @@ class CompareVersionsTest(unittest.TestCase):
 
     def test_compare_versions_major_diff(self):
         self.assertEqual(compare_versions("2.0.0", "1.9.9"), "greater")
+
+
+class UnpackDownloadedFileSafetyTest(unittest.TestCase):
+    """Test unpack_downloaded_file refuses archive members that escape output_path."""
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.output_path = os.path.join(self.temp_dir, "output")
+        os.makedirs(self.output_path)
+        self.addCleanup(shutil.rmtree, self.temp_dir, ignore_errors=True)
+
+    def _payload(self):
+        payload = os.path.join(self.temp_dir, "payload.txt")
+        with open(payload, "w") as fp:
+            fp.write("owned")
+        return payload
+
+    def _make_tar(self, arcname, mode="w", name="archive.tar", linkname=None):
+        archive = os.path.join(self.temp_dir, name)
+        with tarfile.open(archive, mode) as tar:
+            if linkname is None:
+                tar.add(self._payload(), arcname=arcname)
+            else:
+                info = tarfile.TarInfo(arcname)
+                info.type = tarfile.SYMTYPE
+                info.linkname = linkname
+                tar.addfile(info)
+        return archive
+
+    def test_tar_member_escaping_output_path_is_rejected(self):
+        archive = self._make_tar("../escaped.txt")
+        with self.assertRaises(UnsafeArchiveError):
+            unpack_downloaded_file(archive, self.output_path, "application/x-tar")
+        self.assertFalse(os.path.exists(os.path.join(self.temp_dir, "escaped.txt")))
+
+    def test_tar_absolute_member_stays_inside_output_path(self):
+        # tarfile.add() strips a leading "/", so build the member explicitly to
+        # reproduce what an attacker-crafted archive carries. Absolute names are
+        # neutralised (leading separator stripped) rather than rejected, which is
+        # what the stdlib "data" filter does.
+        absolute_name = os.path.join(self.temp_dir, "absolute.txt")
+        archive = os.path.join(self.temp_dir, "absolute.tar")
+        with tarfile.open(archive, "w") as tar:
+            info = tarfile.TarInfo(absolute_name)
+            info.size = 0
+            tar.addfile(info)
+
+        unpack_downloaded_file(archive, self.output_path, "application/x-tar")
+
+        self.assertFalse(os.path.exists(absolute_name))
+        extracted = os.path.join(self.output_path, absolute_name.lstrip("/"))
+        self.assertTrue(os.path.exists(extracted))
+
+    def test_targz_member_escaping_output_path_is_rejected(self):
+        archive = self._make_tar(
+            "../escaped_gz.txt", mode="w:gz", name="archive.tar.gz"
+        )
+        with self.assertRaises(UnsafeArchiveError):
+            unpack_downloaded_file(archive, self.output_path, "application/gzip")
+        self.assertFalse(os.path.exists(os.path.join(self.temp_dir, "escaped_gz.txt")))
+
+    def test_tar_symlink_escaping_output_path_is_rejected(self):
+        archive = self._make_tar("link", linkname="/etc/passwd")
+        with self.assertRaises(UnsafeArchiveError):
+            unpack_downloaded_file(archive, self.output_path, "application/x-tar")
+        self.assertFalse(
+            os.path.lexists(os.path.join(self.output_path, "link")),
+        )
+
+    def test_tar_with_safe_members_is_extracted(self):
+        archive = self._make_tar("nested/safe.txt")
+        self.assertTrue(
+            unpack_downloaded_file(archive, self.output_path, "application/x-tar")
+        )
+        extracted = os.path.join(self.output_path, "nested", "safe.txt")
+        with open(extracted) as fp:
+            self.assertEqual(fp.read(), "owned")
+
+
+class SafeTarExtractallFallbackTest(unittest.TestCase):
+    """Test the pre-3.12 member validator, which has no stdlib 'data' filter."""
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.output_path = os.path.join(self.temp_dir, "output")
+        os.makedirs(self.output_path)
+        self.addCleanup(shutil.rmtree, self.temp_dir, ignore_errors=True)
+
+    def _extract_via_fallback(self, archive):
+        with patch.object(sys, "version_info", (3, 11, 0)):
+            with tarfile.open(archive) as tar:
+                safe_tar_extractall(tar, self.output_path)
+
+    def _tar_with(self, info, name="fallback.tar"):
+        archive = os.path.join(self.temp_dir, name)
+        with tarfile.open(archive, "w") as tar:
+            tar.addfile(info)
+        return archive
+
+    def test_fallback_rejects_traversing_member(self):
+        info = tarfile.TarInfo("../escaped.txt")
+        info.size = 0
+        with self.assertRaises(UnsafeArchiveError):
+            self._extract_via_fallback(self._tar_with(info))
+        self.assertFalse(os.path.exists(os.path.join(self.temp_dir, "escaped.txt")))
+
+    def test_fallback_rejects_escaping_symlink(self):
+        info = tarfile.TarInfo("link")
+        info.type = tarfile.SYMTYPE
+        info.linkname = "/etc/passwd"
+        with self.assertRaises(UnsafeArchiveError):
+            self._extract_via_fallback(self._tar_with(info))
+
+    def test_fallback_rejects_special_file(self):
+        info = tarfile.TarInfo("fifo")
+        info.type = tarfile.FIFOTYPE
+        with self.assertRaises(UnsafeArchiveError):
+            self._extract_via_fallback(self._tar_with(info))
+
+    def test_fallback_neutralises_absolute_member(self):
+        absolute_name = os.path.join(self.temp_dir, "absolute.txt")
+        info = tarfile.TarInfo(absolute_name)
+        info.size = 0
+        self._extract_via_fallback(self._tar_with(info))
+        self.assertFalse(os.path.exists(absolute_name))
+        self.assertTrue(
+            os.path.exists(os.path.join(self.output_path, absolute_name.lstrip("/")))
+        )
+
+    def test_fallback_extracts_safe_member(self):
+        info = tarfile.TarInfo("nested/safe.txt")
+        info.size = 0
+        self._extract_via_fallback(self._tar_with(info))
+        self.assertTrue(
+            os.path.exists(os.path.join(self.output_path, "nested", "safe.txt"))
+        )