@onekeyfe/react-native-sni-connect 6.7.0-alpha.362 → 6.7.0-alpha.364

package/README.md

@@ -40,6 +40,8 @@ import {
   clearDNSCache,
   getDebugSnapshot,
   isProxyActiveForUrl,
+  uploadFile,
+  isUploadFileSupported,
 } from '@onekeyfe/react-native-sni-connect';
 
 const proxyActive = await isProxyActiveForUrl('https://example.com/api/v1/ping');
@@ -82,6 +84,9 @@ collapsed by the transport before this adapter can observe them. Full duplicate
 header preservation on iOS requires an EMASCurl version that exposes the raw
 response header list.
 
+Check `isUploadFileSupported()` before uploading when JS can run with older native
+binaries. `uploadFile()` rejects with `code: SNI_UNSUPPORTED` when unavailable.
+
 ## Specification
 
 The behavior of the SNI connect module is governed by a normative,
@@ -90,6 +95,9 @@ shared JS adapters, and any future platform) must conform to:
 
 **-> [OneKey SNI Connect Standard (OSCS)](https://github.com/OneKeyHQ/app-modules/blob/main/native-modules/react-native-sni-connect/SPEC.md)**
 
+The [native upload contract](docs/SPEC.md) defines capability detection and
+consumption-time file bounds.
+
 Any change to request validation, destination pinning, TLS validation, redirect
 handling, cancellation, response shape, or cache behavior must be checked
 against OSCS.

package/android/src/main/java/com/sniconnect/SniConnectModule.kt

@@ -21,6 +21,7 @@ import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
 import okhttp3.ResponseBody
 import okio.Buffer
+import java.io.File
 import java.io.IOException
 import java.io.InterruptedIOException
 import java.net.Proxy
@@ -191,6 +192,24 @@ class SniConnectModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun uploadFile(config: ReadableMap, promise: Promise) {
+    try {
+      val requestConfig = config.toUploadFileConfig()
+      performRequest(requestConfig, promise)
+    } catch (error: Exception) {
+      SniConnectLogger.error(
+        SniConnectLogger.event(
+          "sni_request_result",
+          "result" to "error",
+          "code" to "SNI_INVALID_CONFIG",
+          "nativeErrorClass" to error.javaClass.simpleName,
+          "stage" to "parse_upload_config",
+        ),
+      )
+      promise.reject("SNI_INVALID_CONFIG", error.message, error)
+    }
+  }
+
   @ReactMethod
   override fun cancelRequest(requestId: String, promise: Promise) {
     val request = synchronized(activeCallsLock) {
@@ -301,7 +320,8 @@ class SniConnectModule(reactContext: ReactApplicationContext) :
           "method" to config.method,
           "timeoutMs" to config.timeoutMillis,
           "headerCount" to config.headers.size,
-          "bodyBytes" to (config.body?.toByteArray(StandardCharsets.UTF_8)?.size ?: 0),
+          "bodyBytes" to config.bodyBytes(),
+          "bodySource" to if (config.bodyFile != null) "file" else "string",
         ),
       )
 
@@ -349,6 +369,7 @@ class SniConnectModule(reactContext: ReactApplicationContext) :
                 "ipFamily" to SniConnectLogger.ipFamily(config.ip),
                 "method" to config.method,
                 "timeoutMs" to config.timeoutMillis,
+                "bodyBytes" to config.bodyBytes(),
                 "responseBytes" to bodyString.toByteArray(StandardCharsets.UTF_8).size,
                 "elapsedMs" to SniConnectLogger.elapsedMs(startedAtMs),
               )
@@ -581,13 +602,13 @@ class SniConnectModule(reactContext: ReactApplicationContext) :
     builder.header("Accept-Encoding", "identity")
 
     val method = config.method
-    val requestBody = config.body?.let { bodyContent ->
-      val mediaType = config.headers.entries
-        .firstOrNull { it.key.equals("Content-Type", ignoreCase = true) }
-        ?.value
-        ?.toMediaTypeOrNull()
-      bodyContent.toRequestBody(mediaType)
-    }
+    val mediaType = config.headers.entries
+      .firstOrNull { it.key.equals("Content-Type", ignoreCase = true) }
+      ?.value
+      ?.toMediaTypeOrNull()
+    // Enforce the body bound when OkHttp consumes the file, after admission.
+    val requestBody = config.bodyFile?.let { SniUploadFileRequestBody(it, mediaType) }
+      ?: config.body?.toRequestBody(mediaType)
 
     when (method) {
       "GET" -> builder.get()
@@ -713,6 +734,67 @@ class SniConnectModule(reactContext: ReactApplicationContext) :
     )
   }
 
+  /** Uploads may only read files from this app's own storage. */
+  private fun uploadFileAllowedRoots(): List<File> {
+    val context = reactApplicationContext
+    return listOfNotNull(
+      File(context.applicationInfo.dataDir),
+      context.filesDir,
+      context.cacheDir,
+      context.externalCacheDir,
+      context.getExternalFilesDir(null),
+    )
+  }
+
+  private fun ReadableMap.toUploadFileConfig(): RequestConfig {
+    if (hasKey("body") && !isNull("body")) {
+      throw IllegalArgumentException("uploadFile does not accept body")
+    }
+    val filePath = if (hasKey("filePath") && !isNull("filePath")) getString("filePath") else null
+    if (filePath.isNullOrEmpty()) {
+      throw IllegalArgumentException("filePath is required")
+    }
+    val rawHeadersMap = if (hasKey("headers") && !isNull("headers")) {
+      getMap("headers")?.toHashMap()
+        ?.mapValues { (_, value) -> value?.toString() ?: "" }
+        ?: emptyMap()
+    } else {
+      emptyMap()
+    }
+    val timeoutMillis = if (hasKey("timeout") && !isNull("timeout")) {
+      SniConnectValidation.parseTimeoutMillis(getDouble("timeout"))
+    } else {
+      30_000L
+    }
+    val requestId = if (hasKey("requestId") && !isNull("requestId")) getString("requestId") else null
+    val rawIp = getString("ip") ?: throw IllegalArgumentException("ip is required")
+    val hostname = getString("hostname") ?: throw IllegalArgumentException("hostname is required")
+    val method = getString("method") ?: "POST"
+    val path = getString("path") ?: "/"
+
+    SniConnectValidation.validateRequestId(requestId)
+    val ip = SniConnectValidation.canonicalizePublicIp(rawIp)
+    SniConnectValidation.validateHostname(hostname)
+    val headersMap = SniConnectValidation.normalizeHeaders(rawHeadersMap)
+    val normalizedMethod = SniConnectValidation.normalizeMethod(method)
+    SniConnectValidation.validateUploadMethod(normalizedMethod)
+    val normalizedPath = SniConnectValidation.normalizePath(path)
+    SniConnectValidation.validateTimeout(timeoutMillis)
+    val bodyFile = SniConnectValidation.resolveUploadFile(filePath, uploadFileAllowedRoots())
+
+    return RequestConfig(
+      requestId = requestId,
+      ip = ip,
+      hostname = hostname,
+      method = normalizedMethod,
+      path = normalizedPath,
+      headers = headersMap,
+      body = null,
+      timeoutMillis = timeoutMillis,
+      bodyFile = bodyFile,
+    )
+  }
+
   private data class RequestConfig(
     val requestId: String?,
     val ip: String,
@@ -722,7 +804,12 @@ class SniConnectModule(reactContext: ReactApplicationContext) :
     val headers: Map<String, String>,
     val body: String?,
     val timeoutMillis: Long,
-  )
+    // Set only by uploadFile(); already resolved inside the app sandbox.
+    val bodyFile: File? = null,
+  ) {
+    fun bodyBytes(): Long =
+      bodyFile?.length() ?: (body?.toByteArray(StandardCharsets.UTF_8)?.size?.toLong() ?: 0L)
+  }
 
   private data class HeaderMaps(
     val singleValueHeaders: Map<String, String>,

package/android/src/main/java/com/sniconnect/SniConnectValidation.kt

@@ -1,6 +1,9 @@
 package com.sniconnect
 
+import java.io.File
+import java.io.IOException
 import java.net.Inet6Address
+import java.net.URI
 import java.net.InetAddress
 import java.nio.charset.StandardCharsets
 import java.util.Locale
@@ -22,6 +25,7 @@ internal object SniConnectValidation {
   const val MAX_PATH_BYTES = 8 * 1024
   const val MAX_REQUEST_BODY_BYTES = 1024 * 1024
   const val MAX_RESPONSE_BODY_BYTES = 10 * 1024 * 1024L
+  const val MAX_UPLOAD_FILE_BYTES = 20 * 1024 * 1024L
   const val MAX_HEADER_COUNT = 64
   const val MAX_HEADER_NAME_BYTES = 128
   const val MAX_HEADER_VALUE_BYTES = 8 * 1024
@@ -94,6 +98,70 @@ internal object SniConnectValidation {
     }
   }
 
+  /** File uploads always carry a body, so only body-bearing write methods apply. */
+  fun validateUploadMethod(method: String) {
+    if (method != "POST" && method != "PUT") {
+      throw ValidationException("Invalid upload method: $method")
+    }
+  }
+
+  /**
+   * Resolve a caller-supplied upload path to a regular file inside one of
+   * [allowedRoots] (the app's own storage). Canonicalization resolves symlinks
+   * before the containment check so a link cannot point the upload elsewhere.
+   */
+  fun resolveUploadFile(rawPath: String, allowedRoots: List<File>): File {
+    if (rawPath.isEmpty() || containsControlChars(rawPath)) {
+      throw ValidationException("Invalid file path")
+    }
+    val file = when {
+      rawPath.startsWith("file:") -> {
+        val uri = try {
+          URI(rawPath)
+        } catch (error: Exception) {
+          throw ValidationException("Invalid file URL")
+        }
+        val path = uri.path
+        if (uri.scheme != "file" || path.isNullOrEmpty()) {
+          throw ValidationException("Invalid file URL")
+        }
+        File(path)
+      }
+      rawPath.startsWith("/") -> File(rawPath)
+      else -> throw ValidationException("File path must be absolute")
+    }
+
+    val canonicalFile = try {
+      file.canonicalFile
+    } catch (error: IOException) {
+      throw ValidationException("File path cannot be resolved")
+    }
+    val canonicalPath = canonicalFile.path
+    val isInsideAllowedRoot = allowedRoots.any { root ->
+      val rootPath = try {
+        root.canonicalPath
+      } catch (error: IOException) {
+        return@any false
+      }
+      val prefix = if (rootPath.endsWith(File.separator)) rootPath else rootPath + File.separator
+      canonicalPath.startsWith(prefix)
+    }
+    if (!isInsideAllowedRoot) {
+      throw ValidationException("File is outside the app sandbox")
+    }
+    if (!canonicalFile.isFile || !canonicalFile.canRead()) {
+      throw ValidationException("Not a readable regular file")
+    }
+    val sizeBytes = canonicalFile.length()
+    if (sizeBytes <= 0L) {
+      throw ValidationException("File is empty")
+    }
+    if (sizeBytes > MAX_UPLOAD_FILE_BYTES) {
+      throw ValidationException("File is too large")
+    }
+    return canonicalFile
+  }
+
   fun normalizeMethod(method: String): String {
     if (containsControlChars(method)) {
       throw ValidationException("Invalid method: $method")

package/android/src/main/java/com/sniconnect/SniPinnedTransport.kt

@@ -1,5 +1,7 @@
 package com.sniconnect
 
+import java.io.File
+import java.io.IOException
 import java.net.InetAddress
 import java.net.Proxy
 import java.net.UnknownHostException
@@ -8,8 +10,13 @@ import java.util.concurrent.TimeUnit
 import okhttp3.ConnectionPool
 import okhttp3.Dispatcher
 import okhttp3.Dns
+import okhttp3.MediaType
 import okhttp3.OkHttpClient
 import okhttp3.Protocol
+import okhttp3.RequestBody
+import okio.Buffer
+import okio.BufferedSink
+import okio.source
 import javax.net.ssl.HttpsURLConnection
 
 object SniPinnedTransport {
@@ -56,3 +63,39 @@ object SniPinnedTransport {
       }
     }
 }
+
+/** Reads from disk only during transmission, with a fixed, bounded body length. */
+internal class SniUploadFileRequestBody(
+  private val file: File,
+  private val mediaType: MediaType?,
+) : RequestBody() {
+  private val length = file.length().also {
+    if (it <= 0 || it > SniConnectValidation.MAX_UPLOAD_FILE_BYTES) {
+      throw IOException("Upload file size is out of range")
+    }
+  }
+
+  override fun contentType(): MediaType? = mediaType
+
+  override fun contentLength(): Long = length
+
+  override fun writeTo(sink: BufferedSink) {
+    file.source().use { source ->
+      val buffer = Buffer()
+      var totalBytes = 0L
+      while (true) {
+        // One extra byte detects growth without ever writing beyond the bound.
+        val read = source.read(buffer, minOf(8 * 1024L, length - totalBytes + 1))
+        if (read == -1L) break
+        if (totalBytes + read > length) {
+          throw IOException("Upload file grew during transmission")
+        }
+        sink.write(buffer, read)
+        totalBytes += read
+      }
+      if (totalBytes != length) {
+        throw IOException("Upload file was truncated during transmission")
+      }
+    }
+  }
+}

package/android/src/test/java/com/sniconnect/SniConnectValidationTest.kt

@@ -3,8 +3,17 @@ package com.sniconnect
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
+import org.junit.Assert.assertThrows
+import okio.Buffer
+import okio.ForwardingSink
+import okio.buffer
+import org.junit.Rule
 import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.File
 import java.io.IOException
+import java.io.RandomAccessFile
+import java.nio.file.Files
 import java.io.InterruptedIOException
 import java.net.SocketTimeoutException
 import java.net.UnknownHostException
@@ -14,6 +23,121 @@ import javax.net.ssl.SSLPeerUnverifiedException
 
 class SniConnectValidationTest {
 
+  @get:Rule
+  val tempFolder = TemporaryFolder()
+
+  @Test
+  fun uploadMethodAllowsOnlyPostAndPut() {
+    SniConnectValidation.validateUploadMethod("POST")
+    SniConnectValidation.validateUploadMethod("PUT")
+    listOf("GET", "HEAD", "PATCH", "DELETE", "OPTIONS").forEach { method ->
+      assertValidationFails { SniConnectValidation.validateUploadMethod(method) }
+    }
+  }
+
+  @Test
+  fun resolveUploadFileAcceptsSandboxFileByPathAndFileUrl() {
+    val root = tempFolder.newFolder("sandbox")
+    val file = File(root, "logs.zip").apply { writeBytes(byteArrayOf(0x50, 0x4B, 3, 4, -1)) }
+
+    val byPath = SniConnectValidation.resolveUploadFile(file.path, listOf(root))
+    assertEquals(file.canonicalPath, byPath.path)
+    val byUrl = SniConnectValidation.resolveUploadFile(file.toURI().toString(), listOf(root))
+    assertEquals(file.canonicalPath, byUrl.path)
+    val byTripleSlashUrl = SniConnectValidation.resolveUploadFile("file://${file.path}", listOf(root))
+    assertEquals(file.canonicalPath, byTripleSlashUrl.path)
+  }
+
+  @Test
+  fun resolveUploadFileRejectsInvalidOrOutOfSandboxFiles() {
+    val root = tempFolder.newFolder("sandbox")
+    val outside = tempFolder.newFolder("outside")
+    val outsideFile = File(outside, "secret.bin").apply { writeBytes(byteArrayOf(1, 2, 3)) }
+    val emptyFile = File(root, "empty.zip").apply { writeBytes(ByteArray(0)) }
+    val link = File(root, "link.zip")
+    Files.createSymbolicLink(link.toPath(), outsideFile.toPath())
+
+    listOf(
+      "",
+      "relative/logs.zip",
+      "https://example.com/logs.zip",
+      outsideFile.path,
+      "${root.path}/../outside/secret.bin",
+      link.path,
+      emptyFile.path,
+      root.path,
+      File(root, "missing.zip").path,
+      "${root.path}/logs\n.zip",
+    ).forEach { path ->
+      assertValidationFails { SniConnectValidation.resolveUploadFile(path, listOf(root)) }
+    }
+  }
+
+  @Test
+  fun resolveUploadFileRejectsFilesOverTheSizeLimit() {
+    val root = tempFolder.newFolder("sandbox")
+    val file = File(root, "big.zip")
+    RandomAccessFile(file, "rw").use { it.setLength(SniConnectValidation.MAX_UPLOAD_FILE_BYTES + 1) }
+
+    assertValidationFails { SniConnectValidation.resolveUploadFile(file.path, listOf(root)) }
+  }
+
+  @Test
+  fun uploadBodyStreamsExactLimitBinaryData() {
+    val file = tempFolder.newFile("exact.zip")
+    val expected = ByteArray(SniConnectValidation.MAX_UPLOAD_FILE_BYTES.toInt()) { 0xFF.toByte() }
+    file.writeBytes(expected)
+    val body = SniUploadFileRequestBody(file, null)
+    val sink = Buffer()
+    body.writeTo(sink)
+    assertEquals(expected.size.toLong(), body.contentLength())
+    assertTrue(expected.contentEquals(sink.readByteArray()))
+  }
+
+  @Test
+  fun uploadBodyRejectsGrowthAfterValidation() {
+    val root = tempFolder.newFolder("sandbox")
+    val file = File(root, "growing.zip").apply { writeBytes(byteArrayOf(1)) }
+    val validated = SniConnectValidation.resolveUploadFile(file.path, listOf(root))
+    val body = SniUploadFileRequestBody(validated, null)
+    RandomAccessFile(file, "rw").use { it.setLength(SniConnectValidation.MAX_UPLOAD_FILE_BYTES + 1) }
+    val sink = Buffer()
+    assertThrows(IOException::class.java) { body.writeTo(sink) }
+    assertTrue(sink.size <= body.contentLength())
+    assertThrows(IOException::class.java) { SniUploadFileRequestBody(validated, null) }
+  }
+
+  @Test
+  fun uploadBodyRejectsGrowthDuringTransmission() {
+    val file = tempFolder.newFile("growing-during-write.zip")
+    file.writeBytes(ByteArray(16 * 1024) { 1 })
+    val body = SniUploadFileRequestBody(file, null)
+    val output = Buffer()
+    var appended = false
+    val sink = object : ForwardingSink(output) {
+      override fun write(source: Buffer, byteCount: Long) {
+        super.write(source, byteCount)
+        if (!appended) {
+          file.appendBytes(byteArrayOf(2))
+          appended = true
+        }
+      }
+    }.buffer()
+    assertThrows(IOException::class.java) { body.writeTo(sink) }
+    assertTrue(appended)
+    assertTrue(output.size <= body.contentLength())
+  }
+
+  @Test
+  fun uploadBodyRejectsTruncationAfterValidation() {
+    val file = tempFolder.newFile("truncated.zip").apply { writeBytes(byteArrayOf(1, 2)) }
+    val body = SniUploadFileRequestBody(file, null)
+    file.writeBytes(byteArrayOf(1))
+    assertThrows(IOException::class.java) { body.writeTo(Buffer()) }
+    file.writeBytes(byteArrayOf())
+    assertThrows(IOException::class.java) { body.writeTo(Buffer()) }
+  }
+
   @Test
   fun acceptsValidRequestBoundaryValues() {
     SniConnectValidation.validateRequestId("req-1")

package/ios/SniConnect.mm

@@ -13,6 +13,9 @@
 - (void)request:(NSDictionary *)config
         resolve:(RCTPromiseResolveBlock)resolve
          reject:(RCTPromiseRejectBlock)reject;
+- (void)uploadFile:(NSDictionary *)config
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject;
 - (void)cancelRequest:(NSString *)requestId
               resolve:(RCTPromiseResolveBlock)resolve
                reject:(RCTPromiseRejectBlock)reject;
@@ -82,6 +85,24 @@ RCT_EXPORT_MODULE(SniConnect)
   [_implementation request:configDict resolve:resolve reject:reject];
 }
 
+- (void)uploadFile:(JS::NativeSniConnect::NativeSniConnectUploadFileRequest &)config
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+  NSMutableDictionary *configDict = [NSMutableDictionary dictionary];
+  configDict[@"ip"] = config.ip() ?: @"";
+  configDict[@"hostname"] = config.hostname() ?: @"";
+  configDict[@"method"] = config.method() ?: @"POST";
+  configDict[@"path"] = config.path() ?: @"/";
+  configDict[@"headers"] = config.headers() ?: @{};
+  configDict[@"timeout"] = @(config.timeout());
+  configDict[@"filePath"] = config.filePath() ?: @"";
+  if (config.requestId()) {
+    configDict[@"requestId"] = config.requestId();
+  }
+
+  [_implementation uploadFile:configDict resolve:resolve reject:reject];
+}
+
 - (void)cancelRequest:(NSString *)requestId
               resolve:(RCTPromiseResolveBlock)resolve
                reject:(RCTPromiseRejectBlock)reject {
@@ -127,6 +148,12 @@ RCT_EXPORT_METHOD(request:(NSDictionary *)config
   [_implementation request:config resolve:resolve reject:reject];
 }
 
+RCT_EXPORT_METHOD(uploadFile:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+  [_implementation uploadFile:config resolve:resolve reject:reject];
+}
+
 RCT_EXPORT_METHOD(cancelRequest:(NSString *)requestId
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {

package/ios/SniConnect.swift

@@ -41,6 +41,26 @@ final class SniConnectImpl: NSObject {
     }
   }
 
+  @objc
+  public func uploadFile(
+    _ config: NSDictionary,
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    do {
+      let parsed = try Self.parseUploadFileDictionary(config)
+      handleRequest(config: parsed, resolve: resolve, reject: reject)
+    } catch {
+      SniConnectLog.error(SniConnectLog.event("sni_request_result", [
+        ("result", "error"),
+        ("code", "SNI_INVALID_CONFIG"),
+        ("nativeErrorClass", String(describing: type(of: error))),
+        ("stage", "parse_upload_config"),
+      ]))
+      reject("SNI_INVALID_CONFIG", "\(error)", error)
+    }
+  }
+
   private func handleRequest(
     config: SniConnectClient.RequestConfig,
     resolve: @escaping RCTPromiseResolveBlock,
@@ -213,6 +233,45 @@ final class SniConnectImpl: NSObject {
     )
   }
 
+  /// Uploads may only read files from this app's own container.
+  private static var uploadFileAllowedRoots: [URL] {
+    [
+      URL(fileURLWithPath: NSHomeDirectory(), isDirectory: true),
+      URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true),
+    ]
+  }
+
+  private static func parseUploadFileDictionary(
+    _ dictionary: NSDictionary
+  ) throws -> SniConnectClient.RequestConfig {
+    guard dictionary["body"] == nil || dictionary["body"] is NSNull else {
+      throw SniConnectError.invalidConfig("uploadFile does not accept body")
+    }
+    guard let filePath = dictionary["filePath"] as? String, !filePath.isEmpty else {
+      throw SniConnectError.invalidConfig("Missing filePath")
+    }
+    let base = try parseDictionary(dictionary)
+    let method = try SniConnectValidation.normalizeMethod(base.method)
+    try SniConnectValidation.validateUploadMethod(method)
+    let resolvedFile = try SniConnectValidation.resolveUploadFile(
+      filePath,
+      allowedRoots: uploadFileAllowedRoots
+    )
+    return SniConnectClient.RequestConfig(
+      requestId: base.requestId,
+      ip: base.ip,
+      hostname: base.hostname,
+      method: method,
+      path: base.path,
+      headers: base.headers,
+      body: nil,
+      timeout: base.timeout,
+      bodyFileURL: resolvedFile.url,
+      connectTimeout: base.connectTimeout,
+      totalTimeout: base.totalTimeout
+    )
+  }
+
   private static func validate(_ config: SniConnectClient.RequestConfig) throws {
     try SniConnectValidation.validatePublicIP(config.ip)
     try SniConnectValidation.validateHostname(config.hostname)
@@ -221,6 +280,10 @@ final class SniConnectImpl: NSObject {
     _ = try SniConnectValidation.normalizePath(config.path)
     try SniConnectValidation.validateRequestId(config.requestId)
     try SniConnectValidation.validateTimeout(config.effectiveTotalTimeout)
+    if config.bodyFileURL != nil {
+      try SniConnectValidation.validateUploadMethod(method)
+      return
+    }
     try SniConnectValidation.validateBody(config.body)
     try SniConnectValidation.validateMethodBody(method: method, body: config.body)
   }

package/ios/SniConnectClient.swift

@@ -259,6 +259,8 @@ final class SniConnectClient {
     let headers: [String: String]
     let body: String?
     let timeout: TimeInterval
+    // Set only by uploadFile(); already resolved inside the app sandbox.
+    var bodyFileURL: URL? = nil
 
     // Advanced timeout configurations
     let connectTimeout: TimeInterval? // Connection establishment timeout
@@ -678,8 +680,15 @@ final class SniConnectClient {
       method = try SniConnectValidation.normalizeMethod(config.method)
       normalizedPath = try SniConnectValidation.normalizePath(config.path)
       try SniConnectValidation.validateTimeout(config.effectiveTotalTimeout)
-      try SniConnectValidation.validateBody(config.body)
-      try SniConnectValidation.validateMethodBody(method: method, body: config.body)
+      if config.bodyFileURL != nil {
+        try SniConnectValidation.validateUploadMethod(method)
+        if config.body != nil {
+          throw SniConnectValidation.ValidationError.invalidBody
+        }
+      } else {
+        try SniConnectValidation.validateBody(config.body)
+        try SniConnectValidation.validateMethodBody(method: method, body: config.body)
+      }
     } catch {
       let sniError = SniConnectError.invalidConfig("\(error)")
       SniConnectLog.error(SniConnectLog.event("sni_request_result", [
@@ -763,8 +772,20 @@ final class SniConnectClient {
     mutableRequest.setValue(config.hostname, forHTTPHeaderField: "Host")
     mutableRequest.setValue("identity", forHTTPHeaderField: "Accept-Encoding")
 
-    if let bodyString = config.body, let bodyData = bodyString.data(using: .utf8) {
+    var bodyBytes = 0
+    if let bodyFileURL = config.bodyFileURL {
+      let fileData: Data
+      do {
+        // Bound consumption even if the file grew while waiting for admission.
+        fileData = try SniConnectValidation.readUploadFile(bodyFileURL)
+      } catch {
+        throw SniConnectError.invalidConfig("Upload file is not readable")
+      }
+      mutableRequest.httpBody = fileData
+      bodyBytes = fileData.count
+    } else if let bodyString = config.body, let bodyData = bodyString.data(using: .utf8) {
       mutableRequest.httpBody = bodyData
+      bodyBytes = bodyData.count
     }
 
     // Per-request connect timeout (avoids the process-global setter race).
@@ -781,7 +802,8 @@ final class SniConnectClient {
       ("connectTimeoutMs", Int(config.effectiveConnectTimeout)),
       ("queueWaitMs", queueWaitMilliseconds),
       ("headerCount", normalizedHeaders.count),
-      ("bodyBytes", config.body?.data(using: .utf8)?.count ?? 0),
+      ("bodyBytes", bodyBytes),
+      ("bodySource", config.bodyFileURL != nil ? "file" : "string"),
     ]))
 
     do {
@@ -817,6 +839,7 @@ final class SniConnectClient {
           ("ipFamily", SniConnectLog.ipFamily(config.ip)),
           ("method", method),
           ("timeoutMs", Int(config.effectiveTotalTimeout)),
+          ("bodyBytes", bodyBytes),
           ("responseBytes", data.count),
           ("elapsedMs", SniConnectLog.elapsedMs(since: startedAt)),
         ])

package/ios/SniConnectValidation.swift

@@ -18,6 +18,7 @@ enum SniConnectValidation {
     case invalidRequestId(String)
     case invalidTimeout(Double)
     case invalidBody
+    case invalidUploadFile(String)
     case resourceLimit(String)
   }
 
@@ -26,6 +27,7 @@ enum SniConnectValidation {
   static let maxPathBytes = 8 * 1024
   static let maxRequestBodyBytes = 1024 * 1024
   static let maxResponseBodyBytes = 10 * 1024 * 1024
+  static let maxUploadFileBytes = 20 * 1024 * 1024
   static let maxHeaderCount = 64
   static let maxHeaderNameBytes = 128
   static let maxHeaderValueBytes = 8 * 1024
@@ -88,6 +90,75 @@ enum SniConnectValidation {
     }
   }
 
+  /// File uploads always carry a body, so only body-bearing write methods apply.
+  static func validateUploadMethod(_ method: String) throws {
+    if method != "POST" && method != "PUT" {
+      throw ValidationError.invalidMethod(method)
+    }
+  }
+
+  /// Resolve a caller-supplied upload path to a regular file inside one of
+  /// `allowedRoots` (the app's own sandbox). Symlinks are resolved before the
+  /// containment check so a link cannot point the upload at another file.
+  static func resolveUploadFile(
+    _ rawPath: String,
+    allowedRoots: [URL]
+  ) throws -> (url: URL, sizeBytes: Int) {
+    if rawPath.isEmpty || containsControlCharacters(rawPath) {
+      throw ValidationError.invalidUploadFile("Invalid file path")
+    }
+    let fileURL: URL
+    if rawPath.hasPrefix("file:") {
+      guard let parsed = URL(string: rawPath), parsed.isFileURL else {
+        throw ValidationError.invalidUploadFile("Invalid file URL")
+      }
+      fileURL = parsed
+    } else if rawPath.hasPrefix("/") {
+      fileURL = URL(fileURLWithPath: rawPath)
+    } else {
+      throw ValidationError.invalidUploadFile("File path must be absolute")
+    }
+
+    let resolvedPath = fileURL.standardizedFileURL.resolvingSymlinksInPath().path
+    let isInsideAllowedRoot = allowedRoots.contains { root in
+      let rootPath = root.standardizedFileURL.resolvingSymlinksInPath().path
+      let prefix = rootPath.hasSuffix("/") ? rootPath : rootPath + "/"
+      return resolvedPath.hasPrefix(prefix)
+    }
+    if !isInsideAllowedRoot {
+      throw ValidationError.invalidUploadFile("File is outside the app sandbox")
+    }
+
+    let attributes: [FileAttributeKey: Any]
+    do {
+      attributes = try FileManager.default.attributesOfItem(atPath: resolvedPath)
+    } catch {
+      throw ValidationError.invalidUploadFile("File is not readable")
+    }
+    guard (attributes[.type] as? FileAttributeType) == .typeRegular else {
+      throw ValidationError.invalidUploadFile("Not a regular file")
+    }
+    let sizeBytes = (attributes[.size] as? NSNumber)?.intValue ?? 0
+    if sizeBytes <= 0 {
+      throw ValidationError.invalidUploadFile("File is empty")
+    }
+    if sizeBytes > maxUploadFileBytes {
+      throw ValidationError.invalidUploadFile("File is too large")
+    }
+    return (URL(fileURLWithPath: resolvedPath), sizeBytes)
+  }
+
+  /// Bound the actual read as well as the earlier path/metadata validation.
+  static func readUploadFile(_ url: URL) throws -> Data {
+    let handle = try FileHandle(forReadingFrom: url)
+    defer { try? handle.close() }
+    let data = try handle.read(upToCount: maxUploadFileBytes + 1) ?? Data()
+    guard !data.isEmpty, data.count <= maxUploadFileBytes else {
+      throw ValidationError.invalidUploadFile("File size is out of range")
+    }
+    return data
+  }
+
   /// Validate and uppercase the HTTP method.
   static func normalizeMethod(_ method: String) throws -> String {
     if containsControlCharacters(method) {

package/ios/Tests/SniConnectValidationTests/SniConnectValidationTests.swift

@@ -550,6 +550,119 @@ final class SniConnectValidationTests: XCTestCase {
     ])
   }
 
+  func testUploadMethodAllowsOnlyPostAndPut() {
+    XCTAssertNoThrow(try SniConnectValidation.validateUploadMethod("POST"))
+    XCTAssertNoThrow(try SniConnectValidation.validateUploadMethod("PUT"))
+    ["GET", "HEAD", "PATCH", "DELETE", "OPTIONS"].forEach { method in
+      assertValidationFails {
+        try SniConnectValidation.validateUploadMethod(method)
+      }
+    }
+  }
+
+  func testResolveUploadFileAcceptsSandboxFileByPathAndFileURL() throws {
+    let root = try makeUploadRoot()
+    defer { try? FileManager.default.removeItem(at: root) }
+    let file = root.appendingPathComponent("logs.zip")
+    try Data([0x50, 0x4B, 0x03, 0x04, 0xFF]).write(to: file)
+
+    let byPath = try SniConnectValidation.resolveUploadFile(file.path, allowedRoots: [root])
+    XCTAssertEqual(byPath.sizeBytes, 5)
+    XCTAssertEqual(
+      byPath.url.path,
+      file.standardizedFileURL.resolvingSymlinksInPath().path
+    )
+
+    let byURL = try SniConnectValidation.resolveUploadFile(
+      file.absoluteString,
+      allowedRoots: [root]
+    )
+    XCTAssertEqual(byURL.url.path, byPath.url.path)
+
+    let bySingleSlashURL = try SniConnectValidation.resolveUploadFile(
+      "file:" + file.path,
+      allowedRoots: [root]
+    )
+    XCTAssertEqual(bySingleSlashURL.url.path, byPath.url.path)
+  }
+
+  func testResolveUploadFileRejectsInvalidOrOutOfSandboxFiles() throws {
+    let root = try makeUploadRoot()
+    let outside = try makeUploadRoot()
+    defer {
+      try? FileManager.default.removeItem(at: root)
+      try? FileManager.default.removeItem(at: outside)
+    }
+    let outsideFile = outside.appendingPathComponent("secret.bin")
+    try Data([1, 2, 3]).write(to: outsideFile)
+    let emptyFile = root.appendingPathComponent("empty.zip")
+    try Data().write(to: emptyFile)
+    let link = root.appendingPathComponent("link.zip")
+    try FileManager.default.createSymbolicLink(at: link, withDestinationURL: outsideFile)
+
+    [
+      "",
+      "relative/logs.zip",
+      "https://example.com/logs.zip",
+      outsideFile.path,
+      root.appendingPathComponent("../\(outside.lastPathComponent)/secret.bin").path,
+      link.path,
+      emptyFile.path,
+      root.path,
+      root.appendingPathComponent("missing.zip").path,
+      root.path + "/logs\n.zip",
+    ].forEach { path in
+      assertValidationFails {
+        _ = try SniConnectValidation.resolveUploadFile(path, allowedRoots: [root])
+      }
+    }
+  }
+
+  func testResolveUploadFileRejectsFilesOverTheSizeLimit() throws {
+    let root = try makeUploadRoot()
+    defer { try? FileManager.default.removeItem(at: root) }
+    let file = root.appendingPathComponent("big.zip")
+    FileManager.default.createFile(atPath: file.path, contents: nil)
+    let handle = try FileHandle(forWritingTo: file)
+    try handle.truncate(atOffset: UInt64(SniConnectValidation.maxUploadFileBytes + 1))
+    try handle.close()
+
+    assertValidationFails {
+      _ = try SniConnectValidation.resolveUploadFile(file.path, allowedRoots: [root])
+    }
+  }
+
+  func testReadUploadFileAcceptsExactLimitBinaryData() throws {
+    let root = try makeUploadRoot()
+    defer { try? FileManager.default.removeItem(at: root) }
+    let file = root.appendingPathComponent("exact.zip")
+    let expected = Data(repeating: 0xFF, count: SniConnectValidation.maxUploadFileBytes)
+    try expected.write(to: file)
+    XCTAssertEqual(try SniConnectValidation.readUploadFile(file), expected)
+  }
+
+  func testReadUploadFileRejectsGrowthAndTruncationAfterValidation() throws {
+    let root = try makeUploadRoot()
+    defer { try? FileManager.default.removeItem(at: root) }
+    let file = root.appendingPathComponent("changing.zip")
+    try Data([1]).write(to: file)
+    let validated = try SniConnectValidation.resolveUploadFile(file.path, allowedRoots: [root])
+    let handle = try FileHandle(forWritingTo: file)
+    defer { try? handle.close() }
+    // A sparse file exercises the consumption bound without a large fixture.
+    try handle.truncate(atOffset: UInt64(SniConnectValidation.maxUploadFileBytes * 4))
+    XCTAssertThrowsError(try SniConnectValidation.readUploadFile(validated.url))
+    try handle.truncate(atOffset: 0)
+    XCTAssertThrowsError(try SniConnectValidation.readUploadFile(validated.url))
+  }
+
+  private func makeUploadRoot() throws -> URL {
+    let root = FileManager.default.temporaryDirectory
+      .appendingPathComponent("sni-upload-\(UUID().uuidString)", isDirectory: true)
+    try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
+    return root
+  }
+
   private func assertValidationFails(_ block: () throws -> Void, file: StaticString = #filePath, line: UInt = #line) {
     XCTAssertThrowsError(try block(), file: file, line: line)
   }

package/lib/module/NativeSniConnect.js

@@ -1,6 +1,12 @@
 "use strict";
 
 import { NativeModules, Platform, TurboModuleRegistry } from 'react-native';
+
+/**
+ * Sends the raw bytes of an app-sandbox file as the request body over the same
+ * pinned-IP/SNI transport as `request()`. Set `content-type` in `headers`.
+ */
+
 const LINKING_ERROR = `The package '@onekeyfe/react-native-sni-connect' doesn't seem to be linked. Make sure:\n\n` + Platform.select({
   ios: "- You have run 'pod install'\n",
   default: ''

package/lib/module/index.js

@@ -4,6 +4,17 @@ import NativeSniConnect from "./NativeSniConnect.js";
 export function request(config) {
   return NativeSniConnect.request(config);
 }
+export function isUploadFileSupported() {
+  return typeof NativeSniConnect.uploadFile === 'function';
+}
+export async function uploadFile(config) {
+  if (!isUploadFileSupported()) {
+    throw Object.assign(new Error('Native SNI file upload is not supported'), {
+      code: 'SNI_UNSUPPORTED'
+    });
+  }
+  return NativeSniConnect.uploadFile(config);
+}
 export function cancelRequest(requestId) {
   return NativeSniConnect.cancelRequest(requestId);
 }

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

@@ -18,6 +18,20 @@ type NativeSniConnectRequest = SniConnectRequestBase & {
     method: string;
     body?: string | null;
 };
+type NativeSniConnectUploadFileRequest = SniConnectRequestBase & {
+    method: string;
+    filePath: string;
+};
+export type SniConnectUploadFileMethod = 'POST' | 'PUT';
+/**
+ * Sends the raw bytes of an app-sandbox file as the request body over the same
+ * pinned-IP/SNI transport as `request()`. Set `content-type` in `headers`.
+ */
+export type SniConnectUploadFileRequest = SniConnectRequestBase & {
+    method: SniConnectUploadFileMethod;
+    /** Absolute path or `file://` URL inside the app sandbox, at most 20 MiB. */
+    filePath: string;
+};
 export type SniConnectBodylessMethod = 'GET' | 'HEAD';
 export type SniConnectRequiredBodyMethod = 'POST' | 'PUT' | 'PATCH';
 export type SniConnectOptionalBodyMethod = 'DELETE' | 'OPTIONS';
@@ -53,6 +67,7 @@ export type SniConnectDebugSnapshot = {
 };
 export interface Spec extends TurboModule {
     request(config: NativeSniConnectRequest): Promise<SniConnectResponse>;
+    uploadFile(config: NativeSniConnectUploadFileRequest): Promise<SniConnectResponse>;
     cancelRequest(requestId: string): Promise<{
         success: boolean;
     }>;

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

@@ -1,5 +1,7 @@
-import { type SniConnectDebugSnapshot, type SniConnectDebugTarget, type SniConnectRequest, type SniConnectResponse } from './NativeSniConnect';
+import { type SniConnectDebugSnapshot, type SniConnectDebugTarget, type SniConnectRequest, type SniConnectResponse, type SniConnectUploadFileRequest } from './NativeSniConnect';
 export declare function request(config: SniConnectRequest): Promise<SniConnectResponse>;
+export declare function isUploadFileSupported(): boolean;
+export declare function uploadFile(config: SniConnectUploadFileRequest): Promise<SniConnectResponse>;
 export declare function cancelRequest(requestId: string): Promise<{
     success: boolean;
 }>;
@@ -11,5 +13,5 @@ export declare function clearDNSCache(): Promise<{
 }>;
 export declare function getDebugSnapshot(target: SniConnectDebugTarget): Promise<SniConnectDebugSnapshot>;
 export declare function isProxyActiveForUrl(url: string): Promise<boolean>;
-export type { SniConnectBodylessMethod, SniConnectDebugSnapshot, SniConnectDebugTarget, SniConnectMethod, SniConnectOptionalBodyMethod, SniConnectRequest, SniConnectRequiredBodyMethod, SniConnectResponse, } from './NativeSniConnect';
+export type { SniConnectBodylessMethod, SniConnectDebugSnapshot, SniConnectDebugTarget, SniConnectMethod, SniConnectOptionalBodyMethod, SniConnectRequest, SniConnectRequiredBodyMethod, SniConnectResponse, SniConnectUploadFileMethod, SniConnectUploadFileRequest, } from './NativeSniConnect';
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-sni-connect",
-  "version": "6.7.0-alpha.362",
+  "version": "6.7.0-alpha.364",
   "description": "A React Native library for SNI-based HTTP requests with DNS caching and request management",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/NativeSniConnect.ts

@@ -28,6 +28,23 @@ type NativeSniConnectRequest = SniConnectRequestBase & {
   body?: string | null;
 };
 
+type NativeSniConnectUploadFileRequest = SniConnectRequestBase & {
+  method: string;
+  filePath: string;
+};
+
+export type SniConnectUploadFileMethod = 'POST' | 'PUT';
+
+/**
+ * Sends the raw bytes of an app-sandbox file as the request body over the same
+ * pinned-IP/SNI transport as `request()`. Set `content-type` in `headers`.
+ */
+export type SniConnectUploadFileRequest = SniConnectRequestBase & {
+  method: SniConnectUploadFileMethod;
+  /** Absolute path or `file://` URL inside the app sandbox, at most 20 MiB. */
+  filePath: string;
+};
+
 export type SniConnectBodylessMethod = 'GET' | 'HEAD';
 export type SniConnectRequiredBodyMethod = 'POST' | 'PUT' | 'PATCH';
 export type SniConnectOptionalBodyMethod = 'DELETE' | 'OPTIONS';
@@ -74,6 +91,9 @@ export type SniConnectDebugSnapshot = {
 
 export interface Spec extends TurboModule {
   request(config: NativeSniConnectRequest): Promise<SniConnectResponse>;
+  uploadFile(
+    config: NativeSniConnectUploadFileRequest
+  ): Promise<SniConnectResponse>;
   cancelRequest(requestId: string): Promise<{ success: boolean }>;
   cancelAllRequests(): Promise<{ success: boolean }>;
   clearDNSCache(): Promise<{ success: boolean }>;

package/src/index.tsx

@@ -3,6 +3,7 @@ import NativeSniConnect, {
   type SniConnectDebugTarget,
   type SniConnectRequest,
   type SniConnectResponse,
+  type SniConnectUploadFileRequest,
 } from './NativeSniConnect';
 
 export function request(
@@ -11,6 +12,21 @@ export function request(
   return NativeSniConnect.request(config);
 }
 
+export function isUploadFileSupported(): boolean {
+  return typeof NativeSniConnect.uploadFile === 'function';
+}
+
+export async function uploadFile(
+  config: SniConnectUploadFileRequest
+): Promise<SniConnectResponse> {
+  if (!isUploadFileSupported()) {
+    throw Object.assign(new Error('Native SNI file upload is not supported'), {
+      code: 'SNI_UNSUPPORTED',
+    });
+  }
+  return NativeSniConnect.uploadFile(config);
+}
+
 export function cancelRequest(
   requestId: string
 ): Promise<{ success: boolean }> {
@@ -44,4 +60,6 @@ export type {
   SniConnectRequest,
   SniConnectRequiredBodyMethod,
   SniConnectResponse,
+  SniConnectUploadFileMethod,
+  SniConnectUploadFileRequest,
 } from './NativeSniConnect';