feat: support for 6 version and 5 metadata

Author: danila-schelkov

gradle.properties

@@ -1,2 +1,2 @@
-version=1.0.2
-zstd_version=1.5.7-3
+version=1.0.3
+zstd_version=1.5.7-4

src/main/java/dev/donutquine/swf/file/Hasher.java

@@ -19,10 +19,10 @@ private Hasher() {
     }
 
     public static boolean verifyHash(byte[] data, byte[] hash) {
-        return Arrays.equals(createHash(data), hash);
+        return Arrays.equals(calculateHash(data), hash);
     }
 
-    public static byte[] createHash(byte[] data) {
+    public static byte[] calculateHash(byte[] data) {
         return MD5.digest(data);
     }
 }

src/main/java/dev/donutquine/swf/file/ScFileInfo.java

@@ -1,4 +1,4 @@
 package dev.donutquine.swf.file;
 
-public record ScFileInfo(int version, byte[] data) {
+public record ScFileInfo(int version, int flagsMaybe, byte[] data) {
 }

src/main/java/dev/donutquine/swf/file/ScFilePacker.java

@@ -9,8 +9,6 @@
 import java.io.IOException;
 
 public final class ScFilePacker {
-    private static final byte[] LZMA_PROPERTIES = new byte[]{0x5d, 0x00, 0x00, 0x04, 0x00};
-
     private static final int SC_MAGIC = 0x5343;
 
     private ScFilePacker() {
@@ -22,32 +20,35 @@ public static byte[] pack(byte[] data, byte[] metadata, int version) throws IOEx
 
         dos.writeShort(SC_MAGIC);
 
-        dos.writeInt(version);
-        if (version == 4) {
-            version = 1;
+        if (version < 5) {
             dos.writeInt(version);
+            if (version == 4) {
+                version = 1;
+                dos.writeInt(version);
+            }
+        } else {
+            dos.writeInt(Integer.reverseBytes(version));
         }
 
         if (version < 5) {
-            byte[] hash = Hasher.createHash(data);
+            byte[] hash = Hasher.calculateHash(data);
 
             dos.writeInt(hash.length);
             dos.write(hash);
         } else {
+            if (version == 6) {
+                dos.writeShort(0);
+            }
+
             dos.writeInt(metadata.length);
             dos.write(metadata);
         }
 
         switch (version) {
             case 1 -> {
-                dos.write(LZMA_PROPERTIES);
-                for (int i = 0; i < 4; i++) {
-                    dos.writeByte((data.length >> (8 * i)) & 0xFF);
-                }
-
                 dos.write(Lzma.compress(data));
             }
-            case 2, 3, 5 -> dos.write(Zstandard.compress(data));
+            case 2, 3, 5, 6 -> dos.write(Zstandard.compress(data));
             default ->
                 throw new UnknownFileVersionException("Unknown file version: " + version);
         }

src/main/java/dev/donutquine/swf/file/ScFileUnpacker.java

@@ -10,19 +10,18 @@
 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
 import java.io.IOException;
+import java.util.Arrays;
 
 public final class ScFileUnpacker {
     private static final int SC_MAGIC = 0x5343;
-    private static final int FIVE_LITTLE_ENDIAN = swapEndian32(5);
-    private static final byte[] START_SECTION_BYTES = {'S', 'T', 'A', 'R', 'T'};
 
     private ScFileUnpacker() {
     }
 
     public static ScFileInfo unpack(byte[] compressedData) throws UnknownFileVersionException, IOException, FileVerificationException {
         DataInputStream stream = createDataInputStreamFromBytes(compressedData);
 
-        checkMagic(stream);
+        verifyMagic(stream);
 
         byte[] hash = null;
 
@@ -32,9 +31,18 @@ public static ScFileInfo unpack(byte[] compressedData) throws UnknownFileVersion
                 int hashLength = stream.readInt();
                 hash = readBytes(hashLength, stream);
             }
-            case 5 -> {
-                int metadataRootTableOffset = swapEndian32(stream.readInt());
-                skipBytes(stream, metadataRootTableOffset);
+            // Note: returns compressed data to allow user parse metadata and other compressed chunks
+            case 5, 6 -> {
+                int flagsMaybe;
+                if (version == 6) {
+                    flagsMaybe = Short.reverseBytes(stream.readShort()) & 0xFFFF;
+                } else {
+                    flagsMaybe = 0;  // TODO: ?
+                }
+
+                byte[] data = Arrays.copyOfRange(compressedData, compressedData.length - stream.available(), compressedData.length);
+
+                return new ScFileInfo(version, flagsMaybe, data);
             }
         }
 
@@ -44,25 +52,20 @@ public static ScFileInfo unpack(byte[] compressedData) throws UnknownFileVersion
             throw new HashVerificationException("Decompressed data hash doesn't equal to hash from file");
         }
 
-        return new ScFileInfo(version, decompressed);
+        return new ScFileInfo(version, 0, decompressed);
     }
 
     private static byte[] decompress(byte[] compressedData, int version, DataInputStream stream) throws IOException, UnknownFileVersionException {
         byte[] decompressed;
 
         switch (version) {
             case 1 -> decompressed = Lzma.decompress(stream);
-            case 2, 3, 5 -> {
+            case 2, 3 -> {
                 int offset = compressedData.length - stream.available();
-                int startSectionOffset = indexOf(compressedData, START_SECTION_BYTES);
-                if (startSectionOffset != -1) {
-                    decompressed = Zstandard.decompress(compressedData, offset, startSectionOffset - offset);
-                } else {
-                    decompressed = Zstandard.decompress(compressedData, offset);
-                }
+                decompressed = Zstandard.decompress(compressedData, offset);
             }
             default ->
-                throw new UnknownFileVersionException("Unknown file version: " + version);
+                throw new UnknownFileVersionException("Unsupported file version: " + version);
         }
 
         return decompressed;
@@ -78,7 +81,7 @@ private static byte[] readBytes(int hashLength, DataInputStream stream) throws I
         return data;
     }
 
-    private static void checkMagic(DataInputStream stream) throws IOException, WrongFileMagicException {
+    private static void verifyMagic(DataInputStream stream) throws IOException, WrongFileMagicException {
         int magic = stream.readShort();
         if (magic != SC_MAGIC) {
             throw new WrongFileMagicException("Unknown file magic: " + magic);
@@ -90,42 +93,15 @@ private static int parseVersion(DataInputStream stream) throws IOException {
         if (version == 4) {
             version = stream.readInt();
         }
-        if (version == FIVE_LITTLE_ENDIAN) {
-            version = 5;
-        }
-        return version;
-    }
 
-    private static DataInputStream createDataInputStreamFromBytes(byte[] compressedData) {
-        return new DataInputStream(new ByteArrayInputStream(compressedData));
-    }
-
-    private static void skipBytes(DataInputStream stream, int bytesToBeSkipped) throws IOException {
-        long actualSkipped = stream.skip(bytesToBeSkipped);
-        if (actualSkipped != bytesToBeSkipped) {
-            throw new IllegalStateException("The number of bytes skipped is not equal to the requested number of bytes: " + actualSkipped + " vs " + bytesToBeSkipped);
+        if (version <= 4) {
+            return version;
         }
-    }
 
-    private static int swapEndian32(int metadataRootTableOffset) {
-        return (metadataRootTableOffset >> 24) & 0xFF | (((metadataRootTableOffset >> 16) & 0xFF) << 8) | (((metadataRootTableOffset >> 8) & 0xFF) << 16) | ((metadataRootTableOffset & 0xFF) << 24);
+        return Integer.reverseBytes(version);
     }
 
-    private static int indexOf(byte[] array, byte[] bytesToFind) {
-        for (int i = 0; i < array.length; i++) {
-            boolean found = true;
-            for (int j = 0; j < bytesToFind.length; j++) {
-                if (array[i+j] != bytesToFind[j]) {
-                    found = false;
-                    break;
-                }
-            }
-
-            if (found) {
-                return i;
-            }
-        }
-
-        return -1;
+    private static DataInputStream createDataInputStreamFromBytes(byte[] compressedData) {
+        return new DataInputStream(new ByteArrayInputStream(compressedData));
     }
 }

src/main/java/dev/donutquine/swf/file/compression/Lzma.java

@@ -9,6 +9,8 @@
 import java.io.IOException;
 
 public final class Lzma {
+    private static final int UNCOMPRESSED_SIZE_LENGTH = 4;
+
     private Lzma() {
     }
 
@@ -19,7 +21,7 @@ public static byte[] decompress(DataInputStream stream) throws IOException {
         decoder.setDecoderProperties(decoderProperties);
 
         int outSize = 0;
-        for (int i = 0; i < 4; i++) {
+        for (int i = 0; i < UNCOMPRESSED_SIZE_LENGTH; i++) {
             outSize |= (stream.read() & 0xFF) << (i * 8);
         }
 
@@ -34,6 +36,10 @@ public static byte[] compress(byte[] data) throws IOException {
         ByteArrayOutputStream outputArray = new ByteArrayOutputStream();
 
         Encoder encoder = new Encoder();
+        encoder.writeCoderProperties(outputArray);
+        for (int i = 0; i < UNCOMPRESSED_SIZE_LENGTH; i++) {
+            outputArray.write((data.length >> (8 * i)) & 0xFF);
+        }
         encoder.code(byteArrayInputStream, outputArray, null);
 
         return outputArray.toByteArray();

src/main/java/dev/donutquine/swf/file/compression/Zstandard.java

@@ -7,23 +7,9 @@ private Zstandard() {
     }
 
     public static byte[] decompress(byte[] compressedData, int offset) {
-        return decompress(compressedData, offset, compressedData.length - offset);
-    }
-
-    public static byte[] decompress(byte[] compressedData, int offset, int length) {
-        int decompressedSize = (int) Zstd.getFrameContentSize(compressedData, offset, length);
-
-        byte[] zstdContent;
-        if (offset > 0 || length != compressedData.length - offset) {
-            zstdContent = new byte[length];
-            System.arraycopy(compressedData, offset, zstdContent, 0, zstdContent.length);
-        } else {
-            zstdContent = compressedData;
-        }
-
-        return Zstd.decompress(
-            zstdContent,
-            decompressedSize
+        return Zstd.decompressFrame(
+            compressedData,
+            offset
         );
     }