@x47base/pocketbase-addon 0.1.0

package/internal/archive/extract.go

@@ -0,0 +1,99 @@
+package archive
+
+import (
+	"archive/zip"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Extract extracts the zip archive at "src" to "dest".
+//
+// Note that only dirs and regular files will be extracted.
+// Symbolic links, named pipes, sockets, or any other irregular files
+// are skipped because they come with too many edge cases and ambiguities.
+func Extract(src, dest string) error { return ExtractContext(context.Background(), src, dest) }
+
+func ExtractContext(ctx context.Context, src, dest string) error {
+	zr, err := zip.OpenReader(src)
+	if err != nil {
+		return err
+	}
+	defer zr.Close()
+
+	// normalize dest path to check later for Zip Slip
+	dest = filepath.Clean(dest) + string(os.PathSeparator)
+
+	for _, f := range zr.File {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		err := extractFileContext(ctx, f, dest)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// extractFile extracts the provided zipFile into "basePath/zipFileName" path,
+// creating all the necessary path directories.
+func extractFile(zipFile *zip.File, basePath string) error {
+	return extractFileContext(context.Background(), zipFile, basePath)
+}
+
+func extractFileContext(ctx context.Context, zipFile *zip.File, basePath string) error {
+	path := filepath.Join(basePath, zipFile.Name)
+
+	// check for Zip Slip
+	if !strings.HasPrefix(path, basePath) {
+		return fmt.Errorf("invalid file path: %s", path)
+	}
+
+	r, err := zipFile.Open()
+	if err != nil {
+		return err
+	}
+	defer r.Close()
+
+	// allow only dirs or regular files
+	if zipFile.FileInfo().IsDir() {
+		if err := os.MkdirAll(path, os.ModePerm); err != nil {
+			return err
+		}
+	} else if zipFile.FileInfo().Mode().IsRegular() {
+		// ensure that the file path directories are created
+		if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
+			return err
+		}
+
+		f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, zipFile.Mode())
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+
+		_, err = io.Copy(f, contextReader{ctx, r})
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+type contextReader struct {
+	ctx    context.Context
+	reader io.Reader
+}
+
+func (r contextReader) Read(p []byte) (int, error) {
+	if err := r.ctx.Err(); err != nil {
+		return 0, err
+	}
+	return r.reader.Read(p)
+}

package/internal/archive/extract_test.go

@@ -0,0 +1,88 @@
+package archive_test
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/spink-dev/pocketbase-extension/internal/archive"
+)
+
+func TestExtractFailure(t *testing.T) {
+	testDir := createTestDir(t)
+	defer os.RemoveAll(testDir)
+
+	missingZipPath := filepath.Join(os.TempDir(), "pb_missing_test.zip")
+	extractedPath := filepath.Join(os.TempDir(), "pb_zip_extract")
+	defer os.RemoveAll(extractedPath)
+
+	if err := archive.Extract(missingZipPath, extractedPath); err == nil {
+		t.Fatal("Expected Extract to fail due to missing zipPath")
+	}
+
+	if _, err := os.Stat(extractedPath); err == nil {
+		t.Fatalf("Expected %q to not be created", extractedPath)
+	}
+}
+
+func TestExtractSuccess(t *testing.T) {
+	testDir := createTestDir(t)
+	defer os.RemoveAll(testDir)
+
+	zipPath := filepath.Join(os.TempDir(), "pb_test.zip")
+	defer os.RemoveAll(zipPath)
+
+	extractedPath := filepath.Join(os.TempDir(), "pb_zip_extract")
+	defer os.RemoveAll(extractedPath)
+
+	// zip testDir content (with exclude)
+	if err := archive.Create(testDir, zipPath, "a/b/c", "test2", "sub2"); err != nil {
+		t.Fatalf("Failed to create archive: %v", err)
+	}
+
+	if err := archive.Extract(zipPath, extractedPath); err != nil {
+		t.Fatalf("Failed to extract %q in %q", zipPath, extractedPath)
+	}
+
+	availableFiles := []string{}
+
+	walkErr := filepath.WalkDir(extractedPath, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if d.IsDir() {
+			return nil
+		}
+
+		availableFiles = append(availableFiles, path)
+
+		return nil
+	})
+	if walkErr != nil {
+		t.Fatalf("Failed to read the extracted dir: %v", walkErr)
+	}
+
+	// (note: symbolic links and other regular files should be missing)
+	expectedFiles := []string{
+		filepath.Join(extractedPath, "test"),
+		filepath.Join(extractedPath, "a/test"),
+		filepath.Join(extractedPath, "a/b/sub1"),
+	}
+
+	if len(availableFiles) != len(expectedFiles) {
+		t.Fatalf("Expected \n%v, \ngot \n%v", expectedFiles, availableFiles)
+	}
+
+ExpectedLoop:
+	for _, expected := range expectedFiles {
+		for _, available := range availableFiles {
+			if available == expected {
+				continue ExpectedLoop
+			}
+		}
+
+		t.Fatalf("Missing file %q in \n%v", expected, availableFiles)
+	}
+}