@onekeyfe/react-native-bundle-crypto 3.0.53 → 3.0.55

package/README.md

@@ -5,20 +5,28 @@ react-native-bundle-crypto
 ## Installation
 
 ```sh
-npm install react-native-bundle-crypto react-native-nitro-modules
+npm install @onekeyfe/react-native-bundle-crypto react-native-nitro-modules
 
 > `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
 ```
 
 ## Usage
 
-```js
-import { ReactNativeBundleCrypto } from 'react-native-bundle-crypto';
+```ts
+import { ReactNativeBundleCrypto } from '@onekeyfe/react-native-bundle-crypto';
 
 // ...
 
-const result = await ReactNativeBundleCrypto.hello({ message: 'World' });
-console.log(result); // { success: true, data: 'Hello, World!' }
+const hash = await ReactNativeBundleCrypto.sha256OfFile('/absolute/path/bundle.zip');
+if (hash.sha256) {
+  console.log('sha256:', hash.sha256);
+}
+
+const isSame = ReactNativeBundleCrypto.secureEqualHex(
+  '0123456789abcdef',
+  '0123456789abcdef'
+);
+console.log(isSame);
 ```
 
 ## Contributing

package/ReactNativeBundleCrypto.podspec

@@ -20,8 +20,8 @@ Pod::Spec.new do |s|
   ]
 
   # Vendored Gopenpgp framework: GPG cleartext/detached signature verification.
-  # This is the single in-tree copy used by the bundle-crypto security module
-  # (copied from react-native-bundle-update during P1; that module keeps its own).
+  # This is the single in-tree copy used by bundle-crypto and by modules that
+  # delegate to BundleCryptoCore instead of vendoring their own framework.
   s.vendored_frameworks = 'ios/Frameworks/Gopenpgp.xcframework'
 
   s.dependency 'React-jsi'

package/android/src/main/java/com/margelo/nitro/reactnativebundlecrypto/BundleCryptoCore.kt

@@ -152,23 +152,13 @@ object BundleCryptoCore {
       // Extract cleartext and signature from the PGP signed message manually
       // (BouncyCastle's cleartext handling requires manual parsing).
       val lines = signedMessage.lines()
-      val hashHeaderIdx = lines.indexOfFirst { it.startsWith("Hash:") }
-      val sigStartIdx = lines.indexOfFirst { it == "-----BEGIN PGP SIGNATURE-----" }
-      val sigEndIdx = lines.indexOfFirst { it == "-----END PGP SIGNATURE-----" }
-
-      if (hashHeaderIdx < 0 || sigStartIdx < 0 || sigEndIdx < 0) {
-        OneKeyLog.error("BundleCrypto", "Invalid PGP cleartext signed message format")
-        return VerifyResult(false, null, "INVALID_FORMAT")
-      }
-
-      // The cleartext body is between the Hash header blank line and the PGP SIGNATURE block.
-      val bodyStartIdx = hashHeaderIdx + 2 // skip Hash: line and the blank line after it
-      val bodyLines = lines.subList(bodyStartIdx, sigStartIdx)
-      // Remove trailing empty line that PGP adds.
-      val cleartextBody = bodyLines.joinToString("\r\n").trimEnd()
-
-      // The signature block.
-      val sigBlock = lines.subList(sigStartIdx, sigEndIdx + 1).joinToString("\n")
+      val framed = frameCleartext(lines)
+        ?: run {
+          OneKeyLog.error("BundleCrypto", "Invalid PGP cleartext signed message format")
+          return VerifyResult(false, null, "INVALID_FORMAT")
+        }
+      val cleartextBody = framed.body
+      val sigBlock = framed.signatureBlock
 
       // Decode the signature.
       val sigInputStream = PGPUtil.getDecoderStream(sigBlock.byteInputStream())
@@ -193,11 +183,9 @@ object BundleCryptoCore {
       // Verify the signature.
       pgpSignature.init(JcaPGPContentVerifierBuilderProvider().setProvider(bcProvider), publicKey)
 
-      // Dash-unescape the cleartext per RFC 4880 Section 7.1.
-      val unescapedLines = cleartextBody.lines().map { line ->
-        if (line.startsWith("- ")) line.substring(2) else line
-      }
-      val dataToVerify = unescapedLines.joinToString("\r\n").toByteArray(Charsets.UTF_8)
+      // Canonicalize the cleartext per RFC 4880 Section 7.1 (dash-unescape +
+      // per-line trailing-whitespace strip), matching iOS Gopenpgp.
+      val dataToVerify = canonicalizeCleartext(cleartextBody).toByteArray(Charsets.UTF_8)
       pgpSignature.update(dataToVerify)
 
       if (!pgpSignature.verify()) {
@@ -234,17 +222,10 @@ object BundleCryptoCore {
 
     return try {
       val lines = ascContent.lines()
-      val hashHeaderIdx = lines.indexOfFirst { it.startsWith("Hash:") }
-      val sigStartIdx = lines.indexOfFirst { it == "-----BEGIN PGP SIGNATURE-----" }
-      val sigEndIdx = lines.indexOfFirst { it == "-----END PGP SIGNATURE-----" }
-      if (hashHeaderIdx < 0 || sigStartIdx < 0 || sigEndIdx < 0) {
-        return VerifyResult(false, null, "INVALID_FORMAT")
-      }
-
-      val bodyStartIdx = hashHeaderIdx + 2
-      val bodyLines = lines.subList(bodyStartIdx, sigStartIdx)
-      val cleartextBody = bodyLines.joinToString("\r\n").trimEnd()
-      val sigBlock = lines.subList(sigStartIdx, sigEndIdx + 1).joinToString("\n")
+      val framed = frameCleartext(lines)
+        ?: return VerifyResult(false, null, "INVALID_FORMAT")
+      val cleartextBody = framed.body
+      val sigBlock = framed.signatureBlock
 
       // Verify GPG signature.
       val sigInputStream = PGPUtil.getDecoderStream(sigBlock.byteInputStream())
@@ -261,10 +242,9 @@ object BundleCryptoCore {
         ?: return VerifyResult(false, null, "PUBKEY_NOT_FOUND")
 
       pgpSignature.init(JcaPGPContentVerifierBuilderProvider().setProvider(bcProvider), publicKey)
-      val unescapedLines = cleartextBody.lines().map { line ->
-        if (line.startsWith("- ")) line.substring(2) else line
-      }
-      val dataToVerify = unescapedLines.joinToString("\r\n").toByteArray(Charsets.UTF_8)
+      // Canonicalize per RFC 4880 Section 7.1 (dash-unescape + per-line
+      // trailing-whitespace strip), matching iOS Gopenpgp.
+      val dataToVerify = canonicalizeCleartext(cleartextBody).toByteArray(Charsets.UTF_8)
       pgpSignature.update(dataToVerify)
       if (!pgpSignature.verify()) {
         return VerifyResult(false, null, "SIGNATURE_INVALID")
@@ -284,6 +264,55 @@ object BundleCryptoCore {
     }
   }
 
+  // MARK: - PGP cleartext framing + canonicalization (RFC 4880 §7.1)
+  // Shared by verifyGpgCleartext and verifyDetachedAsc so both forms parse and
+  // canonicalize identically.
+
+  private data class FramedCleartext(val body: String, val signatureBlock: String)
+
+  // Frame a PGP CLEARTEXT SIGNED MESSAGE per RFC 4880 §7: a header section
+  // (one-or-more "Key: value" lines such as Hash:) terminated by the FIRST blank
+  // line, then the cleartext body, then the ASCII-armored signature block. This
+  // is robust to zero, one, or multiple armor headers rather than assuming a
+  // single "Hash:" line. Returns null if the message is not well-formed.
+  private fun frameCleartext(lines: List<String>): FramedCleartext? {
+    val msgStartIdx = lines.indexOfFirst { it == "-----BEGIN PGP SIGNED MESSAGE-----" }
+    val sigStartIdx = lines.indexOfFirst { it == "-----BEGIN PGP SIGNATURE-----" }
+    val sigEndIdx = lines.indexOfFirst { it == "-----END PGP SIGNATURE-----" }
+    if (msgStartIdx < 0 || sigStartIdx < 0 || sigEndIdx < 0) return null
+    if (sigStartIdx <= msgStartIdx || sigEndIdx < sigStartIdx) return null
+
+    // Header lines run from just after the BEGIN line until the first blank line;
+    // the body starts immediately after that blank line. If there is no blank
+    // line before the signature, the format is invalid.
+    var blankIdx = -1
+    for (i in (msgStartIdx + 1) until sigStartIdx) {
+      if (lines[i].isEmpty()) { blankIdx = i; break }
+    }
+    if (blankIdx < 0) return null
+
+    val bodyStartIdx = blankIdx + 1
+    val bodyLines = lines.subList(bodyStartIdx, sigStartIdx)
+    // Remove the trailing empty line that PGP adds before the signature block.
+    val body = bodyLines.joinToString("\r\n").trimEnd()
+    val signatureBlock = lines.subList(sigStartIdx, sigEndIdx + 1).joinToString("\n")
+    return FramedCleartext(body, signatureBlock)
+  }
+
+  // Canonicalize cleartext for signature verification per RFC 4880 §7.1, matching
+  // iOS Gopenpgp:
+  //   - dash-unescape: a line beginning with "- " has that prefix removed;
+  //   - trailing whitespace is stripped from each line;
+  //   - lines are rejoined with CRLF.
+  // Fail-safe: a stricter canonicalization can only reject otherwise-valid
+  // signatures, never accept an invalid one.
+  private fun canonicalizeCleartext(body: String): String {
+    return body.lines().joinToString("\r\n") { line ->
+      val unescaped = if (line.startsWith("- ")) line.substring(2) else line
+      unescaped.trimEnd(' ', '\t')
+    }
+  }
+
   // MARK: - sha256 (java MessageDigest streaming) — ported from calculateSHA256.
   // failureReason taxonomy preserved verbatim (FILE_NOT_FOUND / FILE_DISAPPEARED
   // / FILE_TRUNCATED / PERMISSION_DENIED / OOM / IO_<class> / UNEXPECTED_<class>).
@@ -384,8 +413,12 @@ object BundleCryptoCore {
       if (file.isDirectory) {
         if (!validateFilesRecursive(file, expected, jsBundleDir)) return false
       } else {
-        if (file.name.contains("metadata.json") || file.name.contains(".DS_Store")) continue
-        val relativePath = file.absolutePath.replace(jsBundleDir, "")
+        // Skip only by EXACT basename (defense-in-depth: substring match could
+        // let an unverified file like "evil-metadata.json" bypass hashing).
+        if (file.name == "metadata.json" || file.name == ".DS_Store") continue
+        // Strip only the leading base dir; a global replace would corrupt paths
+        // where the base dir name recurs deeper in the tree.
+        val relativePath = file.absolutePath.removePrefix(jsBundleDir)
         val expectedSHA256 = expected[relativePath]
         if (expectedSHA256 == null) {
           OneKeyLog.error("BundleCrypto", "[bundle-verify] File on disk not found in metadata: $relativePath")
@@ -426,8 +459,10 @@ object BundleCryptoCore {
       if (file.isDirectory) {
         hashFilesRecursive(file, jsBundleDir, out)
       } else {
-        if (file.name.contains("metadata.json") || file.name.contains(".DS_Store")) continue
-        val relativePath = file.absolutePath.replace(jsBundleDir, "")
+        // Skip only by EXACT basename (mirror verify loop / sibling check).
+        if (file.name == "metadata.json" || file.name == ".DS_Store") continue
+        // Strip only the leading base dir (see validateFilesRecursive).
+        val relativePath = file.absolutePath.removePrefix(jsBundleDir)
         val sha256 = calculateSHA256(file.absolutePath).sha256
           ?: throw Exception("HASH_FAILED:$relativePath")
         out.add(DirHash(relativePath, sha256))

package/ios/BundleCryptoCore.swift

@@ -356,6 +356,18 @@ public enum BundleCryptoCore {
     return result == 0
   }
 
+  /// Strip only the leading base directory from an absolute path, returning the
+  /// relative path with any leading "/" trimmed. Unlike replacingOccurrences,
+  /// this removes only the leading prefix so a base dir name that recurs deeper
+  /// in the tree cannot corrupt the relative path / metadata key.
+  private static func stripLeadingDir(_ fullPath: String, prefix: String) -> String {
+    if fullPath.hasPrefix(prefix) {
+      return String(fullPath.dropFirst(prefix.count))
+    }
+    // Fall back to trimming a leading separator so keys stay consistent.
+    return fullPath.hasPrefix("/") ? String(fullPath.dropFirst()) : fullPath
+  }
+
   /// Synchronous sha256 used internally by dir hashing — returns nil on any
   /// failure (used where only the hex/nil distinction matters).
   private static func calculateSHA256Sync(_ filePath: String) -> String? {
@@ -405,12 +417,18 @@ public enum BundleCryptoCore {
 
     guard let enumerator = fm.enumerator(atPath: dirPath) else { return false }
     while let file = enumerator.nextObject() as? String {
-      if file.contains("metadata.json") || file.contains(".DS_Store") { continue }
+      // Skip only by EXACT basename (defense-in-depth: `file` is the relative
+      // path, so a substring match was even looser and could let an unverified
+      // file like "evil-metadata.json" or "sub/metadata.json.bak" bypass).
+      let basename = (file as NSString).lastPathComponent
+      if basename == "metadata.json" || basename == ".DS_Store" { continue }
       let fullPath = (dirPath as NSString).appendingPathComponent(file)
       var entryIsDir: ObjCBool = false
       if fm.fileExists(atPath: fullPath, isDirectory: &entryIsDir), entryIsDir.boolValue { continue }
 
-      let relativePath = fullPath.replacingOccurrences(of: normalizedDir, with: "")
+      // Strip only the leading base dir; a global replace would corrupt paths
+      // where the base dir name recurs deeper in the tree.
+      let relativePath = Self.stripLeadingDir(fullPath, prefix: normalizedDir)
       guard let expectedSHA256 = expected[relativePath] else {
         OneKeyLog.error("BundleCrypto", "[bundle-verify] File on disk not found in metadata: \(relativePath)")
         return false
@@ -446,7 +464,9 @@ public enum BundleCryptoCore {
     var results: [DirHash] = []
     guard let enumerator = fm.enumerator(atPath: dirPath) else { return [] }
     while let file = enumerator.nextObject() as? String {
-      if file.contains("metadata.json") || file.contains(".DS_Store") { continue }
+      // Skip only by EXACT basename (mirror verifyDirAgainstHashes / sibling check).
+      let basename = (file as NSString).lastPathComponent
+      if basename == "metadata.json" || basename == ".DS_Store" { continue }
       let fullPath = (dirPath as NSString).appendingPathComponent(file)
       var entryIsDir: ObjCBool = false
       if fm.fileExists(atPath: fullPath, isDirectory: &entryIsDir), entryIsDir.boolValue { continue }
@@ -454,7 +474,8 @@ public enum BundleCryptoCore {
         OneKeyLog.error("BundleCrypto", "hashDir: failed to hash \(file)")
         throw NSError(domain: "BundleCrypto", code: -1, userInfo: [NSLocalizedDescriptionKey: "HASH_FAILED"])
       }
-      let relativePath = fullPath.replacingOccurrences(of: normalizedDir, with: "")
+      // Strip only the leading base dir (see verifyDirAgainstHashes).
+      let relativePath = Self.stripLeadingDir(fullPath, prefix: normalizedDir)
       results.append(DirHash(relativePath: relativePath, sha256: sha256))
     }
     return results
@@ -476,7 +497,10 @@ public enum BundleCryptoCore {
         return false
       }
       let resolvedPath = (fullPath as NSString).resolvingSymlinksInPath
-      if !resolvedPath.hasPrefix(resolvedDestination) {
+      // Require a path-separator boundary (or exact match) so a sibling dir like
+      // "/Bundles/v1-evil" cannot pass the "/Bundles/v1" prefix check. Mirrors
+      // the tight Android canonicalPath check.
+      if resolvedPath != resolvedDestination && !resolvedPath.hasPrefix(resolvedDestination + "/") {
         OneKeyLog.error("BundleCrypto", "Path traversal detected in extracted bundle: \(file)")
         return false
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-bundle-crypto",
-  "version": "3.0.53",
+  "version": "3.0.55",
   "description": "react-native-bundle-crypto",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",