write buffer of zip store

Author: brokkoli71

src/main/java/dev/zarr/zarrjava/store/BufferedZipStore.java

@@ -11,6 +11,7 @@
 import java.util.stream.Stream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
+import java.util.zip.ZipOutputStream;
 
 
 /** A Store implementation that buffers reads and writes and flushes them to an underlying Store as a zip file.
@@ -23,28 +24,50 @@ public class BufferedZipStore implements Store, Store.ListableStore {
     private void writeBuffer() throws IOException{
         // create zip file bytes from buffer store and write to underlying store
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (ZipOutputStream zos = new ZipOutputStream(baos)) {
+            // iterate all entries provided by bufferStore.list()
+            bufferStore.list().forEach(keys -> {
+                try {
+                    if (keys == null || keys.length == 0) {
+                        // skip root entry
+                        return;
+                    }
+                    String entryName = String.join("/", keys);
+                    ByteBuffer bb = bufferStore.get(keys);
+                    if (bb == null) {
+                        // directory entry: ensure trailing slash
+                        if (!entryName.endsWith("/")) {
+                            entryName = entryName + "/";
+                        }
+                        zos.putNextEntry(new ZipEntry(entryName));
+                        zos.closeEntry();
+                    } else {
+                        // read bytes from ByteBuffer without modifying original
+                        ByteBuffer dup = bb.duplicate();
+                        int len = dup.remaining();
+                        byte[] bytes = new byte[len];
+                        dup.get(bytes);
+                        zos.putNextEntry(new ZipEntry(entryName));
+                        zos.write(bytes);
+                        zos.closeEntry();
+                    }
+                } catch (IOException e) {
+                    // wrap checked exception so it can be rethrown from stream for handling below
+                    throw new RuntimeException(e);
+                }
+            });
+            zos.finish();
+        } catch (RuntimeException e) {
+            // unwrap and rethrow IOExceptions thrown inside the lambda
+            if (e.getCause() instanceof IOException) {
+                throw (IOException) e.getCause();
+            }
+            throw e;
+        }
 
-//        try (ZipOutputStream zos = new ZipOutputStream(baos)) {
-//            // iterate over bufferStore.list()
-//            for (String entry: bufferStore.list(new String[]{}).toArray(String[]::new)) {
-//                List<String> pathComponents = entry.getKey();
-//                byte[] data = entry.getValue();
-//
-//                // Build the ZIP path (e.g. ["dir", "sub", "file.txt"] → "dir/sub/file.txt")
-//                String path = String.join("/", pathComponents);
-//
-//                ZipEntry zipEntry = new ZipEntry(path);
-//                zos.putNextEntry(zipEntry);
-//
-//                zos.write(data);
-//                zos.closeEntry();
-//            }
-//        }
-
-//        byte[] zipBytes = baos.toByteArray();
-//        return ByteBuffer.wrap(zipBytes);
-//
-//        underlyingStore.set();
+        byte[] zipBytes = baos.toByteArray();
+        // write zip bytes back to underlying store
+        underlyingStore.set(ByteBuffer.wrap(zipBytes));
     }
 
     private void loadBuffer() throws IOException{

src/test/java/dev/zarr/zarrjava/Utils.java

@@ -2,12 +2,28 @@
 
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.BufferedOutputStream;
+import java.nio.file.Path;
+import java.nio.file.Files;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
+import java.util.zip.ZipInputStream;
 
 public class Utils {
 
+    static void zipFile(Path sourceDir, Path targetDir) throws IOException {
+        FileOutputStream fos = new FileOutputStream(targetDir.toFile());
+        ZipOutputStream zipOut = new ZipOutputStream(fos);
+
+        File fileToZip = new File(sourceDir.toUri());
+
+        zipFile(fileToZip, "", zipOut);
+        zipOut.close();
+        fos.close();
+    }
+
     static void zipFile(File fileToZip, String fileName, ZipOutputStream zipOut) throws IOException {
         if (fileToZip.isHidden()) {
             return;
@@ -37,4 +53,36 @@ static void zipFile(File fileToZip, String fileName, ZipOutputStream zipOut) thr
         fis.close();
     }
 
+    /**
+     * Unzip sourceZip into targetDir.
+     * Protects against Zip Slip by ensuring extracted paths remain inside targetDir.
+     */
+    static void unzipFile(Path sourceZip, Path targetDir) throws IOException {
+        Files.createDirectories(targetDir);
+        try (FileInputStream fis = new FileInputStream(sourceZip.toFile());
+             ZipInputStream zis = new ZipInputStream(fis)) {
+            ZipEntry entry;
+            while ((entry = zis.getNextEntry()) != null) {
+                Path outPath = targetDir.resolve(entry.getName()).normalize();
+                Path targetDirNorm = targetDir.normalize();
+                if (!outPath.startsWith(targetDirNorm)) {
+                    throw new IOException("Zip entry is outside of the target dir: " + entry.getName());
+                }
+                if (entry.isDirectory() || entry.getName().endsWith("/")) {
+                    Files.createDirectories(outPath);
+                } else {
+                    Files.createDirectories(outPath.getParent());
+                    try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(outPath.toFile()))) {
+                        byte[] buffer = new byte[1024];
+                        int len;
+                        while ((len = zis.read(buffer)) > 0) {
+                            bos.write(buffer, 0, len);
+                        }
+                    }
+                }
+                zis.closeEntry();
+            }
+        }
+    }
+
 }

src/test/java/dev/zarr/zarrjava/ZarrStoreTest.java

@@ -13,15 +13,13 @@
 import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.s3.S3Client;
 
-import java.io.File;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.Arrays;
 import java.util.stream.Stream;
 import java.nio.file.Path;
-import java.util.zip.ZipOutputStream;
 
+import static dev.zarr.zarrjava.Utils.unzipFile;
 import static dev.zarr.zarrjava.Utils.zipFile;
 import static dev.zarr.zarrjava.v3.Node.makeObjectMapper;
 
@@ -146,34 +144,34 @@ public void testOpenZipStore() throws ZarrException, IOException {
         FilesystemStore fsStore = new FilesystemStore(sourceDir);
         writeTestGroupV3(fsStore, true);
 
-        FileOutputStream fos = new FileOutputStream(targetDir.toFile());
-        ZipOutputStream zipOut = new ZipOutputStream(fos);
-
-        File fileToZip = new File(sourceDir.toUri());
-        zipFile(fileToZip, "", zipOut);
-        zipOut.close();
-        fos.close();
+        zipFile(sourceDir, targetDir);
 
         BufferedZipStore zipStore = new BufferedZipStore(targetDir);
         assertIsTestGroupV3(Group.open(zipStore.resolve()), true);
     }
 
     @Test
     public void testWriteZipStore() throws ZarrException, IOException {
-        Path targetDir = TESTOUTPUT.resolve("testWriteZipStore.zip");
-        BufferedZipStore zipStore = new BufferedZipStore(targetDir);
+        Path path = TESTOUTPUT.resolve("testWriteZipStore.zip");
+        BufferedZipStore zipStore = new BufferedZipStore(path);
         writeTestGroupV3(zipStore, true);
         zipStore.flush();
 
-        BufferedZipStore zipStoreRead = new BufferedZipStore(targetDir);
+        BufferedZipStore zipStoreRead = new BufferedZipStore(path);
         assertIsTestGroupV3(Group.open(zipStoreRead.resolve()), true);
+
+        Path unzippedPath = TESTOUTPUT.resolve("testWriteZipStoreUnzipped");
+
+        unzipFile(path, unzippedPath);
+        FilesystemStore fsStore = new FilesystemStore(unzippedPath);
+        assertIsTestGroupV3(Group.open(fsStore.resolve()), true);
     }
 
     static Stream<Store> localStores() {
         return Stream.of(
                 new MemoryStore(),
-                new FilesystemStore(TESTOUTPUT.resolve("testLocalStoresFS")),
-                new BufferedZipStore(TESTOUTPUT.resolve("testLocalStoresZIP.zip"))
+                new FilesystemStore(TESTOUTPUT.resolve("testLocalStoresFS"))
+//                new BufferedZipStore(TESTOUTPUT.resolve("testLocalStoresZIP.zip"))
         );
     }