@onekeyfe/react-native-range-downloader 3.0.80 → 3.0.81-alpha.1

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/ReactNativeRangeDownloader.kt

@@ -2,6 +2,7 @@ package com.margelo.nitro.reactnativerangedownloader
 
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.nativelogger.OneKeyLog
 import java.io.File
@@ -265,6 +266,153 @@ class ReactNativeRangeDownloader : HybridReactNativeRangeDownloaderSpec() {
     return ctx.cacheDir.absolutePath
   }
 
+  override fun getFirmwareArtifactCapabilities(): FirmwareArtifactCapabilities {
+    return FirmwareArtifactCapabilities(
+      firmwareArtifactProtocolVersion = 1.0,
+      supportedRouteTypes = arrayOf("domain", "pinnedIp"),
+      supportsArchiveMaterialization = true,
+      maxReadBytes = FirmwareArtifactStore.MAX_READ_BYTES.toDouble(),
+    )
+  }
+
+  override fun downloadFirmwareArtifact(
+    params: FirmwareArtifactDownloadParams,
+  ): Promise<FirmwareArtifactReceipt> {
+    return Promise.async {
+      val artifact = FirmwareArtifactStore.download(params)
+      FirmwareArtifactReceipt(
+        artifactRef = artifact.artifactRef,
+        size = artifact.size.toDouble(),
+        sha256 = artifact.sha256,
+      )
+    }
+  }
+
+  override fun cancelFirmwareArtifactDownloads(
+    params: FirmwareArtifactCancelParams,
+  ): Promise<Unit> {
+    return Promise.async {
+      FirmwareArtifactStore.cancelDownloads(params.transactionId)
+    }
+  }
+
+  override fun discardFirmwareArtifact(
+    params: FirmwareArtifactRefParams,
+  ): Promise<Unit> {
+    return Promise.async {
+      FirmwareArtifactStore.discard(params.artifactRef)
+    }
+  }
+
+  override fun openFirmwareArtifact(
+    params: FirmwareArtifactRefParams,
+  ): Promise<FirmwareArtifactReaderInfo> {
+    return Promise.async {
+      val (readerId, size) = FirmwareArtifactStore.open(params.artifactRef)
+      FirmwareArtifactReaderInfo(readerId = readerId, size = size.toDouble())
+    }
+  }
+
+  override fun readFirmwareArtifact(
+    params: FirmwareArtifactReaderReadParams,
+  ): Promise<ArrayBuffer> {
+    return Promise.async {
+      require(
+        params.offset.isFinite() &&
+          params.offset >= 0 &&
+          params.offset.toLong().toDouble() == params.offset &&
+          params.length.isFinite() &&
+          params.length > 0 &&
+          params.length.toInt().toDouble() == params.length
+      ) {
+        "Invalid firmware artifact read"
+      }
+      ArrayBuffer.copy(
+        FirmwareArtifactStore.read(
+          readerId = params.readerId,
+          offset = params.offset.toLong(),
+          length = params.length.toInt(),
+        ),
+      )
+    }
+  }
+
+  override fun closeFirmwareArtifact(
+    params: FirmwareArtifactReaderCloseParams,
+  ): Promise<Unit> {
+    return Promise.async {
+      FirmwareArtifactStore.close(params.readerId)
+    }
+  }
+
+  override fun materializeFirmwareArchive(
+    params: FirmwareArchiveMaterializeParams,
+  ): Promise<FirmwareArchiveMaterializeResult> {
+    return Promise.async {
+      val artifacts = FirmwareArtifactStore.materializeArchive(
+        params.leaseRef,
+        params.archiveArtifactRef,
+        params.expectedEntries,
+      )
+      FirmwareArchiveMaterializeResult(
+        artifacts = artifacts.map { entry ->
+          FirmwareArchiveMaterializedArtifact(
+            entryName = entry.entryName,
+            receipt = FirmwareArtifactReceipt(
+              artifactRef = entry.artifact.artifactRef,
+              size = entry.artifact.size.toDouble(),
+              sha256 = entry.artifact.sha256,
+            ),
+          )
+        }.toTypedArray(),
+      )
+    }
+  }
+
+  override fun createFirmwareArtifactLease(
+    params: FirmwareArtifactLeaseCreateParams,
+  ): Promise<FirmwareArtifactLease> {
+    return Promise.async {
+      FirmwareArtifactLease(
+        leaseRef = FirmwareArtifactStore.createLease(params.transactionId),
+      )
+    }
+  }
+
+  override fun retainFirmwareArtifact(
+    params: FirmwareArtifactLeaseRetainParams,
+  ): Promise<Unit> {
+    return Promise.async {
+      FirmwareArtifactStore.retain(params.leaseRef, params.artifactRef)
+    }
+  }
+
+  override fun releaseFirmwareArtifactLease(
+    params: FirmwareArtifactLeaseReleaseParams,
+  ): Promise<Unit> {
+    return Promise.async {
+      FirmwareArtifactStore.releaseLease(params.leaseRef, params.disposition)
+    }
+  }
+
+  override fun reconcileFirmwareArtifactLeases(
+    params: FirmwareArtifactLeaseReconcileParams,
+  ): Promise<Unit> {
+    return Promise.async {
+      FirmwareArtifactStore.reconcileLeases(params.activeLeaseRefs)
+    }
+  }
+
+  override fun sweepFirmwareArtifactOrphans(): Promise<FirmwareArtifactSweepResult> {
+    return Promise.async {
+      val (deletedFiles, deletedBytes) = FirmwareArtifactStore.sweepOrphans()
+      FirmwareArtifactSweepResult(
+        deletedFiles = deletedFiles.toDouble(),
+        deletedBytes = deletedBytes.toDouble(),
+      )
+    }
+  }
+
   // Broadcast one event to every registered listener. Listeners filter by
   // channel/taskId on their side (shared registry, per the design).
   private fun sendEvent(

package/android/src/test/java/com/margelo/nitro/reactnativerangedownloader/FirmwareArchiveRulesTest.kt

@@ -0,0 +1,75 @@
+package com.margelo.nitro.reactnativerangedownloader
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class FirmwareArchiveRulesTest {
+  private fun entry(
+    artifactId: String = "resource-entry",
+    entryName: String = "assets/icon.png",
+    expectedSize: Double = 128.0,
+    expectedSha256: String = "a".repeat(64),
+  ) = FirmwareArchiveExpectedEntry(
+    artifactId = artifactId,
+    entryName = entryName,
+    expectedSize = expectedSize,
+    expectedSha256 = expectedSha256,
+  )
+
+  @Test
+  fun acceptsAnExactPortableAllowlist() {
+    val requirements = FirmwareArchiveRules.validateRequirements(
+      arrayOf(
+        entry(),
+        entry(
+          artifactId = "resource-entry-2",
+          entryName = "assets/sub/icon-2.png",
+          expectedSha256 = "b".repeat(64),
+        ),
+      ),
+    )
+
+    assertEquals(2, requirements.size)
+  }
+
+  @Test
+  fun rejectsTraversalAndNestedArchives() {
+    for (entryName in listOf("../icon.png", "assets/../icon.png", "assets.zip")) {
+      assertThrows(IllegalArgumentException::class.java) {
+        FirmwareArchiveRules.validateRequirements(
+          arrayOf(entry(entryName = entryName)),
+        )
+      }
+    }
+  }
+
+  @Test
+  fun rejectsCaseFoldedDuplicateNames() {
+    assertThrows(IllegalArgumentException::class.java) {
+      FirmwareArchiveRules.validateRequirements(
+        arrayOf(
+          entry(entryName = "assets/Icon.png"),
+          entry(
+            artifactId = "resource-entry-2",
+            entryName = "assets/icon.png",
+          ),
+        ),
+      )
+    }
+  }
+
+  @Test
+  fun rejectsNonIntegralSizesAndInvalidDigests() {
+    assertThrows(IllegalArgumentException::class.java) {
+      FirmwareArchiveRules.validateRequirements(
+        arrayOf(entry(expectedSize = 1.5)),
+      )
+    }
+    assertThrows(IllegalArgumentException::class.java) {
+      FirmwareArchiveRules.validateRequirements(
+        arrayOf(entry(expectedSha256 = "not-a-digest")),
+      )
+    }
+  }
+}

package/ios/FirmwareArchiveMinizipBridge.h

@@ -0,0 +1,33 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FirmwareArchiveEntryInfo : NSObject
+
+@property(nonatomic, readonly) NSString *name;
+@property(nonatomic, readonly) int64_t compressedSize;
+@property(nonatomic, readonly) int64_t uncompressedSize;
+@property(nonatomic, readonly) uint32_t crc32;
+@property(nonatomic, readonly) uint16_t flags;
+@property(nonatomic, readonly) uint16_t compressionMethod;
+@property(nonatomic, readonly) uint16_t versionMadeBy;
+@property(nonatomic, readonly) uint32_t externalAttributes;
+@property(nonatomic, readonly) uint32_t diskNumber;
+@property(nonatomic, readonly, nullable) NSString *linkName;
+
+@end
+
+@interface FirmwareArchiveMinizipBridge : NSObject
+
++ (nullable NSArray<FirmwareArchiveEntryInfo *> *)scanArchiveAtPath:
+    (NSString *)path
+    error:(NSError * _Nullable * _Nullable)error;
+
++ (BOOL)extractEntryNamed:(NSString *)entryName
+            archivePath:(NSString *)archivePath
+               consumer:(BOOL (^)(NSData *chunk))consumer
+                  error:(NSError * _Nullable * _Nullable)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/FirmwareArchiveMinizipBridge.mm

@@ -0,0 +1,213 @@
+#import "FirmwareArchiveMinizipBridge.h"
+
+#import "mz.h"
+#import "mz_strm.h"
+#import "mz_zip.h"
+#import "mz_zip_rw.h"
+
+#include <cstring>
+
+static NSString *const FirmwareArchiveBridgeErrorDomain =
+    @"so.onekey.firmware.archive.minizip";
+
+static NSError *FirmwareArchiveBridgeError(NSString *message, int32_t code) {
+  return [NSError errorWithDomain:FirmwareArchiveBridgeErrorDomain
+                             code:code
+                         userInfo:@{NSLocalizedDescriptionKey : message}];
+}
+
+@interface FirmwareArchiveEntryInfo ()
+
+@property(nonatomic, readwrite) NSString *name;
+@property(nonatomic, readwrite) int64_t compressedSize;
+@property(nonatomic, readwrite) int64_t uncompressedSize;
+@property(nonatomic, readwrite) uint32_t crc32;
+@property(nonatomic, readwrite) uint16_t flags;
+@property(nonatomic, readwrite) uint16_t compressionMethod;
+@property(nonatomic, readwrite) uint16_t versionMadeBy;
+@property(nonatomic, readwrite) uint32_t externalAttributes;
+@property(nonatomic, readwrite) uint32_t diskNumber;
+@property(nonatomic, readwrite, nullable) NSString *linkName;
+
+@end
+
+@implementation FirmwareArchiveEntryInfo
+@end
+
+@implementation FirmwareArchiveMinizipBridge
+
++ (nullable NSArray<FirmwareArchiveEntryInfo *> *)scanArchiveAtPath:
+    (NSString *)path
+    error:(NSError * _Nullable * _Nullable)error {
+  void *reader = nullptr;
+  mz_zip_reader_create(&reader);
+  if (reader == nullptr) {
+    if (error != nullptr) {
+      *error = FirmwareArchiveBridgeError(@"Archive reader allocation failed",
+                                          MZ_MEM_ERROR);
+    }
+    return nil;
+  }
+
+  int32_t result = mz_zip_reader_open_file(reader, path.fileSystemRepresentation);
+  if (result != MZ_OK) {
+    mz_zip_reader_delete(&reader);
+    if (error != nullptr) {
+      *error = FirmwareArchiveBridgeError(@"Archive open failed", result);
+    }
+    return nil;
+  }
+
+  NSMutableArray<FirmwareArchiveEntryInfo *> *entries =
+      [NSMutableArray array];
+  result = mz_zip_reader_goto_first_entry(reader);
+  while (result == MZ_OK) {
+    mz_zip_file *fileInfo = nullptr;
+    result = mz_zip_reader_entry_get_info(reader, &fileInfo);
+    if (result != MZ_OK || fileInfo == nullptr ||
+        fileInfo->filename == nullptr) {
+      result = result == MZ_OK ? MZ_FORMAT_ERROR : result;
+      break;
+    }
+    const size_t filenameLength = std::strlen(fileInfo->filename);
+    if (filenameLength == 0 || filenameLength > 4096) {
+      result = MZ_FORMAT_ERROR;
+      break;
+    }
+    if ((fileInfo->flag & (1 << 11)) == 0) {
+      const unsigned char *filenameBytes =
+          reinterpret_cast<const unsigned char *>(fileInfo->filename);
+      bool isAscii = true;
+      for (size_t index = 0; index < filenameLength; index += 1) {
+        if (filenameBytes[index] >= 0x80) {
+          isAscii = false;
+          break;
+        }
+      }
+      if (!isAscii) {
+        result = MZ_FORMAT_ERROR;
+        break;
+      }
+    }
+    NSString *name = [NSString stringWithUTF8String:fileInfo->filename];
+    if (name == nil) {
+      result = MZ_FORMAT_ERROR;
+      break;
+    }
+    NSString *linkName = nil;
+    if (fileInfo->linkname != nullptr) {
+      linkName = [NSString stringWithUTF8String:fileInfo->linkname];
+      if (linkName == nil) {
+        result = MZ_FORMAT_ERROR;
+        break;
+      }
+    }
+
+    FirmwareArchiveEntryInfo *entry =
+        [[FirmwareArchiveEntryInfo alloc] init];
+    entry.name = name;
+    entry.compressedSize = fileInfo->compressed_size;
+    entry.uncompressedSize = fileInfo->uncompressed_size;
+    entry.crc32 = fileInfo->crc;
+    entry.flags = fileInfo->flag;
+    entry.compressionMethod = fileInfo->compression_method;
+    entry.versionMadeBy = fileInfo->version_madeby;
+    entry.externalAttributes = fileInfo->external_fa;
+    entry.diskNumber = fileInfo->disk_number;
+    entry.linkName = linkName;
+    [entries addObject:entry];
+    if (entries.count > 4096) {
+      result = MZ_FORMAT_ERROR;
+      break;
+    }
+    result = mz_zip_reader_goto_next_entry(reader);
+  }
+
+  if (result == MZ_END_OF_LIST) {
+    result = MZ_OK;
+  }
+  int32_t closeResult = mz_zip_reader_close(reader);
+  mz_zip_reader_delete(&reader);
+  if (result != MZ_OK || closeResult != MZ_OK) {
+    if (error != nullptr) {
+      *error = FirmwareArchiveBridgeError(@"Archive scan failed",
+                                          result != MZ_OK ? result
+                                                          : closeResult);
+    }
+    return nil;
+  }
+  return entries;
+}
+
++ (BOOL)extractEntryNamed:(NSString *)entryName
+            archivePath:(NSString *)archivePath
+               consumer:(BOOL (^)(NSData *chunk))consumer
+                  error:(NSError * _Nullable * _Nullable)error {
+  void *reader = nullptr;
+  bool archiveOpened = false;
+  bool entryOpened = false;
+  mz_zip_reader_create(&reader);
+  if (reader == nullptr) {
+    if (error != nullptr) {
+      *error = FirmwareArchiveBridgeError(@"Archive reader allocation failed",
+                                          MZ_MEM_ERROR);
+    }
+    return NO;
+  }
+
+  int32_t result =
+      mz_zip_reader_open_file(reader, archivePath.fileSystemRepresentation);
+  if (result == MZ_OK) {
+    archiveOpened = true;
+  }
+  if (result == MZ_OK) {
+    result = mz_zip_reader_locate_entry(
+        reader, entryName.UTF8String, 0);
+  }
+  if (result == MZ_OK) {
+    result = mz_zip_reader_entry_open(reader);
+    if (result == MZ_OK) {
+      entryOpened = true;
+    }
+  }
+
+  uint8_t buffer[64 * 1024];
+  while (result == MZ_OK) {
+    int32_t count =
+        mz_zip_reader_entry_read(reader, buffer, (int32_t)sizeof(buffer));
+    if (count < 0) {
+      result = count;
+      break;
+    }
+    if (count == 0) {
+      break;
+    }
+    NSData *chunk = [NSData dataWithBytes:buffer length:(NSUInteger)count];
+    if (!consumer(chunk)) {
+      result = MZ_WRITE_ERROR;
+      break;
+    }
+  }
+
+  int32_t entryCloseResult =
+      entryOpened ? mz_zip_reader_entry_close(reader) : MZ_OK;
+  int32_t archiveCloseResult =
+      archiveOpened ? mz_zip_reader_close(reader) : MZ_OK;
+  mz_zip_reader_delete(&reader);
+  if (result != MZ_OK || entryCloseResult != MZ_OK ||
+      archiveCloseResult != MZ_OK) {
+    if (error != nullptr) {
+      int32_t failure = result != MZ_OK
+                            ? result
+                            : (entryCloseResult != MZ_OK
+                                   ? entryCloseResult
+                                   : archiveCloseResult);
+      *error = FirmwareArchiveBridgeError(
+          @"Archive entry extraction or CRC validation failed", failure);
+    }
+    return NO;
+  }
+  return YES;
+}
+
+@end