test(utils): cover hardlink overwrite and in-root hardlinks

The existing hardlink test names a link target two levels above the
extraction root, so its final assertion checked a path the link never
resolved to and could not fail. Point the target one level up instead,
at the path that assertion already names.

Add two cases. The first uses a .tar.gz, where ExtractArchive binds a
Tar config with OverwriteExisting set, and follows the link entry with a
regular entry of the same name. Before the fix that pair linked to a
file outside the root and then truncated it through the link, which the
plain .tar case does not reach. The second extracts a hardlink whose
target is an earlier member of the same archive, covering the claim that
ordinary archives are unaffected.

Assisted-by: Claude:claude-opus-5
Signed-off-by: Zelys-DFKH <zelys@dfkhelper.com>

Author: Zelys-DFKH

pkg/utils/untar_test.go

@@ -3,6 +3,7 @@ package utils_test
 import (
 	"archive/tar"
 	"archive/zip"
+	"compress/gzip"
 	"os"
 	"path/filepath"
 
@@ -60,12 +61,45 @@ var _ = Describe("utils/archive tests", func() {
 		Expect(filepath.Join(tmpDir, "escaped.txt")).ToNot(BeAnExistingFile())
 	})
 
+	It("rejects tar hardlinks that overwrite a file outside the destination", func() {
+		tmpDir := GinkgoT().TempDir()
+		archivePath := filepath.Join(tmpDir, "model.tar.gz")
+		extractPath := filepath.Join(tmpDir, "models")
+		outsidePath := filepath.Join(tmpDir, "outside.txt")
+
+		Expect(os.WriteFile(outsidePath, []byte("original"), 0o600)).To(Succeed())
+		Expect(writeTarGzArchiveWithHardlinkedFile(archivePath, "payload.bin", "../outside.txt", "overwritten")).To(Succeed())
+
+		err := ExtractArchive(archivePath, extractPath)
+
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(ContainSubstring("unsafe path"))
+
+		contents, readErr := os.ReadFile(outsidePath)
+		Expect(readErr).ToNot(HaveOccurred())
+		Expect(string(contents)).To(Equal("original"))
+	})
+
+	It("extracts tar hardlinks that stay inside the destination", func() {
+		tmpDir := GinkgoT().TempDir()
+		archivePath := filepath.Join(tmpDir, "model.tar.gz")
+		extractPath := filepath.Join(tmpDir, "models")
+
+		Expect(writeTarGzArchiveWithInternalHardlink(archivePath, "model.bin", "alias.bin", "weights")).To(Succeed())
+
+		Expect(ExtractArchive(archivePath, extractPath)).To(Succeed())
+
+		extracted, err := os.ReadFile(filepath.Join(extractPath, "alias.bin"))
+		Expect(err).ToNot(HaveOccurred())
+		Expect(string(extracted)).To(Equal("weights"))
+	})
+
 	It("rejects tar hardlinks that point outside the destination", func() {
 		tmpDir := GinkgoT().TempDir()
 		archivePath := filepath.Join(tmpDir, "model.tar")
 		extractPath := filepath.Join(tmpDir, "models")
 
-		Expect(writeTarArchiveWithHardlink(archivePath, "payload.bin", "../../escaped.txt")).To(Succeed())
+		Expect(writeTarArchiveWithHardlink(archivePath, "payload.bin", "../escaped.txt")).To(Succeed())
 
 		err := ExtractArchive(archivePath, extractPath)
 
@@ -166,3 +200,95 @@ func writeTarArchiveWithHardlink(path, name, linkname string) (err error) {
 		Mode:     0o600,
 	})
 }
+
+func writeTarGzArchiveWithHardlinkedFile(path, name, linkname, contents string) (err error) {
+	out, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if closeErr := out.Close(); err == nil {
+			err = closeErr
+		}
+	}()
+
+	compressor := gzip.NewWriter(out)
+	defer func() {
+		if closeErr := compressor.Close(); err == nil {
+			err = closeErr
+		}
+	}()
+
+	writer := tar.NewWriter(compressor)
+	defer func() {
+		if closeErr := writer.Close(); err == nil {
+			err = closeErr
+		}
+	}()
+
+	if err := writer.WriteHeader(&tar.Header{
+		Name:     name,
+		Linkname: linkname,
+		Typeflag: tar.TypeLink,
+		Mode:     0o600,
+	}); err != nil {
+		return err
+	}
+
+	data := []byte(contents)
+	if err := writer.WriteHeader(&tar.Header{
+		Name: name,
+		Mode: 0o600,
+		Size: int64(len(data)),
+	}); err != nil {
+		return err
+	}
+	_, err = writer.Write(data)
+
+	return err
+}
+
+func writeTarGzArchiveWithInternalHardlink(path, targetName, linkName, contents string) (err error) {
+	out, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if closeErr := out.Close(); err == nil {
+			err = closeErr
+		}
+	}()
+
+	compressor := gzip.NewWriter(out)
+	defer func() {
+		if closeErr := compressor.Close(); err == nil {
+			err = closeErr
+		}
+	}()
+
+	writer := tar.NewWriter(compressor)
+	defer func() {
+		if closeErr := writer.Close(); err == nil {
+			err = closeErr
+		}
+	}()
+
+	data := []byte(contents)
+	if err := writer.WriteHeader(&tar.Header{
+		Name: targetName,
+		Mode: 0o600,
+		Size: int64(len(data)),
+	}); err != nil {
+		return err
+	}
+	if _, err := writer.Write(data); err != nil {
+		return err
+	}
+
+	return writer.WriteHeader(&tar.Header{
+		Name:     linkName,
+		Linkname: targetName,
+		Typeflag: tar.TypeLink,
+		Mode:     0o600,
+	})
+}