@onekeyfe/react-native-zip-archive 3.0.38 → 3.0.40

package/{ZipArchive.podspec → ReactNativeZipArchive.podspec}

@@ -3,7 +3,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
 Pod::Spec.new do |s|
-  s.name         = "ZipArchive"
+  s.name         = "ReactNativeZipArchive"
   s.version      = package["version"]
   s.summary      = package["description"]
   s.homepage     = package["homepage"]
@@ -13,9 +13,18 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/react-native-zip-archive.git", :tag => "#{s.version}" }
 
-  s.source_files = "ios/**/*.{h,m,mm}"
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
 
-  s.dependency 'SSZipArchive'
+  # >= 2.5.4 pulls the fix for the zip-slip / symlink path-traversal CVEs
+  # (CVE-2023-39139 etc.) — important since OTA unzips downloaded archives.
+  s.dependency 'SSZipArchive', '>= 2.5.4'
+
+  load 'nitrogen/generated/ios/ReactNativeZipArchive+autolinking.rb'
+  add_nitrogen_files(s)
 
   install_modules_dependencies(s)
 end

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(reactnativeziparchive)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME reactnativeziparchive)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/reactnativeziparchive+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -1,6 +1,6 @@
 buildscript {
   ext.getExtOrDefault = {name ->
-    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['RNZipArchive_' + name]
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeZipArchive_' + name]
   }
 
   repositories {
@@ -15,28 +15,78 @@ buildscript {
   }
 }
 
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/reactnativeziparchive+autolinking.gradle'
 
 apply plugin: "com.facebook.react"
 
 def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RNZipArchive_" + name]).toInteger()
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeZipArchive_" + name]).toInteger()
 }
 
 android {
-  namespace "com.rnziparchive"
+  namespace "com.margelo.nitro.reactnativeziparchive"
 
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
   }
 
   buildFeatures {
     buildConfig true
+    prefab true
   }
 
   buildTypes {
@@ -74,4 +124,5 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
 }

package/android/gradle.properties

@@ -0,0 +1,4 @@
+ReactNativeZipArchive_kotlinVersion=1.9.25
+ReactNativeZipArchive_compileSdkVersion=35
+ReactNativeZipArchive_targetSdkVersion=35
+ReactNativeZipArchive_minSdkVersion=24

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "reactnativeziparchiveOnLoad.hpp"
+
+extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::reactnativeziparchive::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/reactnativeziparchive/ReactNativeZipArchive.kt

@@ -0,0 +1,139 @@
+package com.margelo.nitro.reactnativeziparchive
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import java.io.BufferedInputStream
+import java.io.BufferedOutputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+import java.util.zip.ZipInputStream
+import java.util.zip.ZipOutputStream
+
+/**
+ * Nitro HybridObject implementation of the OneKey zip-archive module.
+ *
+ * This is a 1:1 port of the previous TurboModule `RNZipArchiveModule.kt`. The
+ * underlying archive engine is unchanged: it still uses `java.util.zip`
+ * (`ZipInputStream` / `ZipOutputStream` / `ZipFile`) so the on-disk
+ * extraction/compression behaviour stays byte-for-byte identical.
+ */
+@DoNotStrip
+class ReactNativeZipArchive : HybridReactNativeZipArchiveSpec() {
+
+  companion object {
+    private const val BUFFER_SIZE = 8192
+  }
+
+  override fun isPasswordProtected(file: String): Promise<Boolean> {
+    return Promise.async {
+      // java.util.zip does not support password-protected zips natively.
+      // Return false as a safe default (matches the previous implementation).
+      false
+    }
+  }
+
+  override fun unzip(from: String, to: String): Promise<String> {
+    return Promise.async {
+      val destDir = File(to)
+      if (!destDir.exists()) destDir.mkdirs()
+
+      ZipInputStream(BufferedInputStream(FileInputStream(from))).use { zis ->
+        var entry: ZipEntry? = zis.nextEntry
+        while (entry != null) {
+          val outFile = File(destDir, entry.name)
+          if (entry.isDirectory) {
+            outFile.mkdirs()
+          } else {
+            outFile.parentFile?.mkdirs()
+            FileOutputStream(outFile).use { fos ->
+              val buffer = ByteArray(BUFFER_SIZE)
+              var len: Int
+              while (zis.read(buffer).also { len = it } > 0) {
+                fos.write(buffer, 0, len)
+              }
+            }
+          }
+          zis.closeEntry()
+          entry = zis.nextEntry
+        }
+      }
+      to
+    }
+  }
+
+  override fun unzipWithPassword(from: String, to: String, password: String): Promise<String> {
+    return Promise.async {
+      // java.util.zip does not support password-protected zip extraction.
+      throw Exception("Password-protected zip extraction is not supported on Android")
+    }
+  }
+
+  override fun zipFolder(from: String, to: String): Promise<String> {
+    return Promise.async {
+      val sourceDir = File(from)
+      FileOutputStream(to).use { fos ->
+        ZipOutputStream(BufferedOutputStream(fos)).use { zos ->
+          zipDirectory(sourceDir, sourceDir.name, zos)
+        }
+      }
+      to
+    }
+  }
+
+  override fun zipFiles(files: Array<String>, to: String): Promise<String> {
+    return Promise.async {
+      FileOutputStream(to).use { fos ->
+        ZipOutputStream(BufferedOutputStream(fos)).use { zos ->
+          for (filePath in files) {
+            val file = File(filePath)
+            if (file.exists()) {
+              addFileToZip(file, file.name, zos)
+            }
+          }
+        }
+      }
+      to
+    }
+  }
+
+  override fun getUncompressedSize(path: String): Promise<Double> {
+    return Promise.async {
+      var totalSize = 0L
+      ZipFile(path).use { zipFile ->
+        val entries = zipFile.entries()
+        while (entries.hasMoreElements()) {
+          totalSize += entries.nextElement().size
+        }
+      }
+      totalSize.toDouble()
+    }
+  }
+
+  private fun zipDirectory(dir: File, baseName: String, zos: ZipOutputStream) {
+    val files = dir.listFiles() ?: return
+    for (file in files) {
+      val entryName = "$baseName/${file.name}"
+      if (file.isDirectory) {
+        zipDirectory(file, entryName, zos)
+      } else {
+        addFileToZip(file, entryName, zos)
+      }
+    }
+  }
+
+  private fun addFileToZip(file: File, entryName: String, zos: ZipOutputStream) {
+    val entry = ZipEntry(entryName)
+    zos.putNextEntry(entry)
+    FileInputStream(file).use { fis ->
+      val buffer = ByteArray(BUFFER_SIZE)
+      var len: Int
+      while (fis.read(buffer).also { len = it } > 0) {
+        zos.write(buffer, 0, len)
+      }
+    }
+    zos.closeEntry()
+  }
+}

package/android/src/main/java/com/margelo/nitro/reactnativeziparchive/ReactNativeZipArchivePackage.kt

@@ -0,0 +1,22 @@
+package com.margelo.nitro.reactnativeziparchive
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class ReactNativeZipArchivePackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("reactnativeziparchive")
+        }
+    }
+}

package/ios/ReactNativeZipArchive.swift

@@ -0,0 +1,130 @@
+import Foundation
+import NitroModules
+import SSZipArchive
+
+/// Nitro HybridObject implementation of the OneKey zip-archive module.
+///
+/// This is a 1:1 port of the previous Objective-C `ZipArchive.mm` TurboModule.
+/// The underlying archive engine is unchanged: it still wraps `SSZipArchive`
+/// (`unzipFileAtPath:` / `createZipFileAtPath:` / `payloadSizeForArchiveAtPath:`)
+/// so the on-disk extraction/compression behaviour stays byte-for-byte identical.
+final class ReactNativeZipArchive: HybridReactNativeZipArchiveSpec {
+
+  // MARK: - isPasswordProtected
+
+  func isPasswordProtected(file: String) throws -> Promise<Bool> {
+    return Promise.async {
+      return SSZipArchive.isFilePasswordProtected(atPath: file)
+    }
+  }
+
+  // MARK: - unzip
+
+  func unzip(from: String, to: String) throws -> Promise<String> {
+    return Promise.async {
+      var error: NSError?
+      let success = SSZipArchive.unzipFile(
+        atPath: from,
+        toDestination: to,
+        preserveAttributes: false,
+        overwrite: true,
+        password: nil,
+        error: &error,
+        delegate: nil
+      )
+
+      if success {
+        return to
+      }
+      throw NSError(
+        domain: "ZipArchive",
+        code: -1,
+        userInfo: [
+          NSLocalizedDescriptionKey: error?.localizedDescription ?? "unable to unzip"
+        ]
+      )
+    }
+  }
+
+  // MARK: - unzipWithPassword
+
+  func unzipWithPassword(from: String, to: String, password: String) throws -> Promise<String> {
+    return Promise.async {
+      var error: NSError?
+      let success = SSZipArchive.unzipFile(
+        atPath: from,
+        toDestination: to,
+        preserveAttributes: false,
+        overwrite: true,
+        password: password,
+        error: &error,
+        delegate: nil
+      )
+
+      if success {
+        return to
+      }
+      throw NSError(
+        domain: "ZipArchive",
+        code: -1,
+        userInfo: [NSLocalizedDescriptionKey: "unable to unzip"]
+      )
+    }
+  }
+
+  // MARK: - zipFolder
+
+  func zipFolder(from: String, to: String) throws -> Promise<String> {
+    return Promise.async {
+      let success = SSZipArchive.createZipFile(
+        atPath: to,
+        withContentsOfDirectory: from,
+        keepParentDirectory: false,
+        withPassword: nil,
+        andProgressHandler: nil
+      )
+
+      if success {
+        return to
+      }
+      throw NSError(
+        domain: "ZipArchive",
+        code: -1,
+        userInfo: [NSLocalizedDescriptionKey: "unable to zip"]
+      )
+    }
+  }
+
+  // MARK: - zipFiles
+
+  func zipFiles(files: [String], to: String) throws -> Promise<String> {
+    return Promise.async {
+      let success = SSZipArchive.createZipFile(atPath: to, withFilesAtPaths: files)
+
+      if success {
+        return to
+      }
+      throw NSError(
+        domain: "ZipArchive",
+        code: -1,
+        userInfo: [NSLocalizedDescriptionKey: "unable to zip"]
+      )
+    }
+  }
+
+  // MARK: - getUncompressedSize
+
+  func getUncompressedSize(path: String) throws -> Promise<Double> {
+    return Promise.async {
+      // Swift imports `+payloadSizeForArchiveAtPath:error:` as
+      // payloadSizeForArchive(atPath:error:) -> NSNumber (non-throwing, keeps the
+      // NSErrorPointer because the return is unannotated/non-nullable).
+      var error: NSError?
+      let wantedFileSize = SSZipArchive.payloadSizeForArchive(atPath: path, error: &error)
+      if error == nil {
+        return wantedFileSize.doubleValue
+      }
+      return -1
+    }
+  }
+}

package/lib/module/ReactNativeZipArchive.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ReactNativeZipArchive.nitro.js.map

package/lib/module/index.js

@@ -1,6 +1,27 @@
 "use strict";
 
-import NativeZipArchive from "./NativeZipArchive.js";
-export const ZipArchive = NativeZipArchive;
-export const zip = (source, target) => NativeZipArchive.zipFolder(source, target);
+import { NitroModules } from 'react-native-nitro-modules';
+const ReactNativeZipArchiveHybridObject = NitroModules.createHybridObject('ReactNativeZipArchive');
+
+// Raw HybridObject. Kept exported for compatibility with the previous
+// `export const ZipArchive = NativeZipArchive` shape.
+export const ZipArchive = ReactNativeZipArchiveHybridObject;
+
+// Backwards-compatible named function wrappers. These preserve the exact
+// public API (names + signatures) of the previous TurboModule-based release so
+// consumers (e.g. monorepo logger using `import { zip }`) require zero changes.
+
+export const isPasswordProtected = file => ReactNativeZipArchiveHybridObject.isPasswordProtected(file);
+export const unzip = (from, to) => ReactNativeZipArchiveHybridObject.unzip(from, to);
+export const unzipWithPassword = (from, to, password) => ReactNativeZipArchiveHybridObject.unzipWithPassword(from, to, password);
+export const zipFolder = (from, to) => ReactNativeZipArchiveHybridObject.zipFolder(from, to);
+export const zipFiles = (files, to) => ReactNativeZipArchiveHybridObject.zipFiles(files, to);
+export const getUncompressedSize = path => ReactNativeZipArchiveHybridObject.getUncompressedSize(path);
+
+// `zip` is an alias for `zipFolder` and matches the previous public signature
+// `(source, target) => Promise<string>`. This is the only API the monorepo
+// logger consumes.
+export const zip = (source, target) => ReactNativeZipArchiveHybridObject.zipFolder(source, target);
+
+// Backwards-compatible alias for the previously exported `ZipArchiveSpec` type.
 //# sourceMappingURL=index.js.map

package/lib/typescript/src/{NativeZipArchive.d.ts → ReactNativeZipArchive.nitro.d.ts}

@@ -1,5 +1,8 @@
-import type { TurboModule } from 'react-native';
-export interface Spec extends TurboModule {
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface ReactNativeZipArchive extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
     isPasswordProtected(file: string): Promise<boolean>;
     unzip(from: string, to: string): Promise<string>;
     unzipWithPassword(from: string, to: string, password: string): Promise<string>;
@@ -7,6 +10,4 @@ export interface Spec extends TurboModule {
     zipFiles(files: string[], to: string): Promise<string>;
     getUncompressedSize(path: string): Promise<number>;
 }
-declare const _default: Spec;
-export default _default;
-//# sourceMappingURL=NativeZipArchive.d.ts.map
+//# sourceMappingURL=ReactNativeZipArchive.nitro.d.ts.map

package/lib/typescript/src/index.d.ts

@@ -1,4 +1,12 @@
-export declare const ZipArchive: import("./NativeZipArchive").Spec;
+import type { ReactNativeZipArchive as ReactNativeZipArchiveType } from './ReactNativeZipArchive.nitro';
+export declare const ZipArchive: ReactNativeZipArchiveType;
+export declare const isPasswordProtected: (file: string) => Promise<boolean>;
+export declare const unzip: (from: string, to: string) => Promise<string>;
+export declare const unzipWithPassword: (from: string, to: string, password: string) => Promise<string>;
+export declare const zipFolder: (from: string, to: string) => Promise<string>;
+export declare const zipFiles: (files: string[], to: string) => Promise<string>;
+export declare const getUncompressedSize: (path: string) => Promise<number>;
 export declare const zip: (source: string, target: string) => Promise<string>;
-export type { Spec as ZipArchiveSpec } from './NativeZipArchive';
+export type * from './ReactNativeZipArchive.nitro';
+export type { ReactNativeZipArchive as ZipArchiveSpec } from './ReactNativeZipArchive.nitro';
 //# sourceMappingURL=index.d.ts.map

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["reactnativeziparchive"],
+  "ios": {
+    "iosModuleName": "ReactNativeZipArchive"
+  },
+  "android": {
+    "androidNamespace": ["reactnativeziparchive"],
+    "androidCxxLibName": "reactnativeziparchive"
+  },
+  "autolinking": {
+    "ReactNativeZipArchive": {
+      "swift": "ReactNativeZipArchive",
+      "kotlin": "ReactNativeZipArchive"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}