@onekeyfe/react-native-sni-connect 1.0.0 → 3.0.69

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

@@ -0,0 +1,144 @@
+package com.sniconnect
+
+import java.net.Inet6Address
+import java.net.InetAddress
+import java.util.Locale
+
+/**
+ * Boundary validation/normalization for SNI request inputs.
+ *
+ * The module connects to a caller-supplied IP while preserving the TLS SNI/Host of
+ * `hostname`. Because the connect target is caller-controlled, every field that
+ * reaches the network layer is validated here to prevent SSRF, scheme/host/port
+ * override, cleartext downgrade and CR/LF header injection.
+ */
+internal object SniConnectValidation {
+
+  class ValidationException(message: String) : IllegalArgumentException(message)
+
+  private val ALLOWED_METHODS =
+    setOf("GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS")
+
+  private val HOSTNAME_REGEX = Regex(
+    "^(?=.{1,253}\$)([A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)(\\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*\$"
+  )
+  private val IPV4_REGEX = Regex("^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\$")
+  private val SCHEME_REGEX = Regex("^[A-Za-z][A-Za-z0-9+.-]*:")
+
+  fun normalizeMethod(method: String): String {
+    val upper = method.trim().uppercase(Locale.US)
+    if (upper !in ALLOWED_METHODS) {
+      throw ValidationException("Invalid method: $method")
+    }
+    return upper
+  }
+
+  fun validateHostname(hostname: String) {
+    if (hostname.isEmpty() || hostname.length > 253 || !HOSTNAME_REGEX.matches(hostname)) {
+      throw ValidationException("Invalid hostname: $hostname")
+    }
+  }
+
+  /** Must be a relative path/query only — reject absolute/protocol-relative URLs and control chars. */
+  fun normalizePath(path: String): String {
+    val trimmed = path.trim()
+    if (containsControlChars(trimmed)) {
+      throw ValidationException("Invalid path")
+    }
+    if (trimmed.contains("://") || trimmed.startsWith("//") || SCHEME_REGEX.containsMatchIn(trimmed.take(64).substringBefore('/'))) {
+      throw ValidationException("Invalid path: absolute URLs are not allowed")
+    }
+    if (trimmed.isEmpty()) return "/"
+    return if (trimmed.startsWith("/")) trimmed else "/$trimmed"
+  }
+
+  fun validateHeaders(headers: Map<String, String>) {
+    for ((key, value) in headers) {
+      if (key.isEmpty() || containsControlChars(key) || containsControlChars(value)) {
+        throw ValidationException("Invalid header: $key")
+      }
+    }
+  }
+
+  private fun containsControlChars(s: String): Boolean =
+    s.any { it.code < 0x20 || it.code == 0x7F }
+
+  /**
+   * Validate `ip` is a literal IPv4/IPv6 address (never a hostname) routing to a
+   * public/global-unicast destination. Rejects loopback, private, link-local
+   * (incl. 169.254.169.254 metadata), CGNAT, multicast and reserved ranges.
+   */
+  fun validatePublicIp(ip: String) {
+    val octets = IPV4_REGEX.matchEntire(ip)?.groupValues?.drop(1)?.map { it.toInt() }
+    if (octets != null) {
+      if (octets.any { it > 255 }) throw ValidationException("Invalid IP: $ip")
+      if (isForbiddenIpv4(octets)) throw ValidationException("Forbidden IP: $ip")
+      return
+    }
+    // IPv6: only treat as literal if it contains ':' (avoids any DNS lookup).
+    if (ip.contains(':')) {
+      val addr: InetAddress = try {
+        InetAddress.getByName(ip)
+      } catch (e: Exception) {
+        throw ValidationException("Invalid IP: $ip")
+      }
+      if (addr !is Inet6Address) throw ValidationException("Invalid IP: $ip")
+      if (isForbiddenIpv6(addr)) throw ValidationException("Forbidden IP: $ip")
+      return
+    }
+    throw ValidationException("Invalid IP: $ip")
+  }
+
+  private fun isForbiddenIpv4(o: List<Int>): Boolean {
+    val a = o[0]; val b = o[1]; val c = o[2]; val d = o[3]
+    return when {
+      a == 0 -> true                              // 0.0.0.0/8
+      a == 10 -> true                             // 10/8 private
+      a == 127 -> true                            // 127/8 loopback
+      a == 100 && (b and 0xC0) == 0x40 -> true     // 100.64/10 CGNAT
+      a == 169 && b == 254 -> true                // 169.254/16 link-local + metadata
+      a == 172 && b in 16..31 -> true             // 172.16/12 private
+      a == 192 && b == 168 -> true                // 192.168/16 private
+      a == 192 && b == 0 && c == 0 -> true         // 192.0.0/24
+      a == 192 && b == 0 && c == 2 -> true         // 192.0.2/24 TEST-NET-1
+      a == 198 && (b == 18 || b == 19) -> true     // 198.18/15 benchmarking
+      a == 198 && b == 51 && c == 100 -> true      // 198.51.100/24 TEST-NET-2
+      a == 203 && b == 0 && c == 113 -> true       // 203.0.113/24 TEST-NET-3
+      a >= 224 -> true                            // 224/4 multicast + 240/4 reserved + broadcast
+      else -> false
+    }
+  }
+
+  private fun isForbiddenIpv6(addr: Inet6Address): Boolean {
+    if (addr.isAnyLocalAddress || addr.isLoopbackAddress || addr.isLinkLocalAddress ||
+      addr.isSiteLocalAddress || addr.isMulticastAddress
+    ) {
+      return true
+    }
+    val bytes = addr.address
+    // Unique local fc00::/7
+    if ((bytes[0].toInt() and 0xFE) == 0xFC) return true
+    // IPv4-mapped ::ffff:a.b.c.d — validate the embedded IPv4
+    val mappedPrefixZero = (0..9).all { bytes[it].toInt() == 0 }
+    if (mappedPrefixZero && (bytes[10].toInt() and 0xFF) == 0xFF && (bytes[11].toInt() and 0xFF) == 0xFF) {
+      return isForbiddenIpv4(
+        listOf(
+          bytes[12].toInt() and 0xFF,
+          bytes[13].toInt() and 0xFF,
+          bytes[14].toInt() and 0xFF,
+          bytes[15].toInt() and 0xFF,
+        )
+      )
+    }
+    return false
+  }
+
+  /** Parse a validated IPv4/IPv6 literal into an InetAddress without DNS resolution. */
+  fun literalToInetAddress(ip: String): InetAddress {
+    val octets = IPV4_REGEX.matchEntire(ip)?.groupValues?.drop(1)?.map { it.toInt().toByte() }
+    if (octets != null) {
+      return InetAddress.getByAddress(byteArrayOf(octets[0], octets[1], octets[2], octets[3]))
+    }
+    return InetAddress.getByName(ip) // safe: already validated as an IPv6 literal
+  }
+}

package/ios/SniConnect-Bridging-Header.h

@@ -6,7 +6,6 @@
 //
 
 #import <React/RCTBridgeModule.h>
-#import <React/RCTEventEmitter.h>
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <SniConnectSpec/SniConnectSpec.h>

package/ios/SniConnect.mm

@@ -1,5 +1,4 @@
 #import <React/RCTBridgeModule.h>
-#import <React/RCTEventEmitter.h>
 #import <React/RCTUtils.h>
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -8,7 +7,7 @@
 
 // Forward declaration of the Swift implementation
 @interface SniConnectImpl : NSObject
-- (instancetype)initWithEventSender:(id)eventSender;
+- (instancetype)init;
 - (void)request:(NSDictionary *)config
         resolve:(RCTPromiseResolveBlock)resolve
          reject:(RCTPromiseRejectBlock)reject;
@@ -21,7 +20,7 @@
                reject:(RCTPromiseRejectBlock)reject;
 @end
 
-@interface SniConnect : RCTEventEmitter
+@interface SniConnect : NSObject
 #ifdef RCT_NEW_ARCH_ENABLED
 <NativeSniConnectSpec>
 #else
@@ -31,63 +30,42 @@
 
 @implementation SniConnect {
   SniConnectImpl *_implementation;
-  BOOL _hasListeners;
 }
 
 RCT_EXPORT_MODULE(SniConnect)
 
-// Expose hasListeners as a property for Swift access
-- (BOOL)hasListeners {
-  return _hasListeners;
-}
-
 + (BOOL)requiresMainQueueSetup {
   return NO;
 }
 
 - (instancetype)init {
   if (self = [super init]) {
-    _implementation = [[SniConnectImpl alloc] initWithEventSender:self];
-    _hasListeners = NO;
+    _implementation = [[SniConnectImpl alloc] init];
   }
   return self;
 }
 
-// Event emitter methods
-- (NSArray<NSString *> *)supportedEvents {
-  return @[@"SniConnectLog"];
-}
-
-- (void)startObserving {
-  _hasListeners = YES;
-}
-
-- (void)stopObserving {
-  _hasListeners = NO;
-}
-
-// Method to send log event to JS
-- (void)sendLogEvent:(NSDictionary *)logData {
-  if (_hasListeners) {
-    [self sendEventWithName:@"SniConnectLog" body:logData];
-  }
-}
-
 #ifdef RCT_NEW_ARCH_ENABLED
 // TurboModule interface implementation
 - (void)request:(JS::NativeSniConnect::SniConnectRequest &)config
         resolve:(RCTPromiseResolveBlock)resolve
          reject:(RCTPromiseRejectBlock)reject {
-  // Convert Codegen struct to NSDictionary for Swift implementation
-  NSDictionary *configDict = @{
-    @"ip": config.ip(),
-    @"hostname": config.hostname(),
-    @"method": config.method(),
-    @"path": config.path(),
-    @"headers": config.headers(),
-    @"body": config.body() ?: [NSNull null],
-    @"timeout": @(config.timeout())
-  };
+  // Convert Codegen struct to NSDictionary for the Swift implementation.
+  // Null-guard every field so a nil value never crashes the dictionary literal,
+  // and forward requestId so cancellation works under the new architecture.
+  NSMutableDictionary *configDict = [NSMutableDictionary dictionary];
+  configDict[@"ip"] = config.ip() ?: @"";
+  configDict[@"hostname"] = config.hostname() ?: @"";
+  configDict[@"method"] = config.method() ?: @"GET";
+  configDict[@"path"] = config.path() ?: @"/";
+  configDict[@"headers"] = config.headers() ?: @{};
+  configDict[@"timeout"] = @(config.timeout());
+  if (config.requestId()) {
+    configDict[@"requestId"] = config.requestId();
+  }
+  if (config.body()) {
+    configDict[@"body"] = config.body();
+  }
 
   [_implementation request:configDict resolve:resolve reject:reject];
 }

package/ios/SniConnect.swift

@@ -8,52 +8,25 @@ private enum SniConnectError: Error {
 @objc(SniConnectImpl)
 final class SniConnectImpl: NSObject {
   private let client: SniConnectClient
-  private weak var eventSender: AnyObject?
 
   @objc
-  init(eventSender: AnyObject) {
-    self.eventSender = eventSender
+  override init() {
     self.client = SniConnectClient()
     super.init()
-
-    // Set up logging closure for the client
-    self.client.onLog = { [weak self] level, message in
-      self?.sendLogEvent(level: level, message: message)
-    }
-  }
-
-  private func sendLogEvent(level: String, message: String) {
-    // Send log event to the Objective-C bridge
-    guard let eventSender = eventSender else {
-      return
-    }
-
-    let logData: [String: Any] = [
-      "level": level,
-      "message": message,
-      "timestamp": Int(Date().timeIntervalSince1970 * 1000)
-    ]
-
-    // Call the sendLogEvent method on the bridge
-    let selector = NSSelectorFromString("sendLogEvent:")
-    if eventSender.responds(to: selector) {
-      eventSender.perform(selector, with: logData)
-    }
   }
 
   @objc
   public func request(
     _ config: NSDictionary,
-    resolve resolve: @escaping RCTPromiseResolveBlock,
-    reject reject: @escaping RCTPromiseRejectBlock
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
   ) {
     do {
       let parsed = try Self.parseDictionary(config)
       handleRequest(config: parsed, resolve: resolve, reject: reject)
     } catch {
-      NSLog("[SniConnect] ❌ Config parsing failed: \(error)")
-      sendLogEvent(level: "error", message: "Config parsing failed: \(error)")
-      reject("SNI_REQUEST_FAILED", error.localizedDescription, error)
+      SniConnectLog.error("Config parsing failed: \(error)")
+      reject("SNI_INVALID_CONFIG", "\(error)", error)
     }
   }
 
@@ -62,12 +35,20 @@ final class SniConnectImpl: NSObject {
     resolve: @escaping RCTPromiseResolveBlock,
     reject: @escaping RCTPromiseRejectBlock
   ) {
-    // Create task and register it synchronously before it starts executing
+    do {
+      try Self.validate(config)
+    } catch {
+      SniConnectLog.error("Config validation failed: \(error)")
+      reject("SNI_INVALID_CONFIG", "\(error)", error)
+      return
+    }
+
+    // Create the task and register it synchronously before JS can cancel it.
     let task = Task { () -> SniConnectClient.Response in
       return try await client.performRequest(config: config)
     }
 
-    // Register task synchronously if requestId is provided
+    // Register task if requestId is provided
     if let requestId = config.requestId {
       client.registerTask(task, for: requestId)
     }
@@ -86,16 +67,11 @@ final class SniConnectImpl: NSObject {
           "multiValueHeaders": result.multiValueHeaders,
         ])
       } catch let error as SniConnectClient.SniConnectError {
-        NSLog("[SniConnect] ❌ [\(error.code)] \(error.message)")
-        sendLogEvent(level: "error", message: "[\(error.code)] \(error.message)")
         reject(error.code, error.message, error)
       } catch is CancellationError {
-        NSLog("[SniConnect] ❌ Request cancelled")
-        sendLogEvent(level: "info", message: "Request cancelled")
         reject("SNI_CANCELLED", "Request cancelled", nil)
       } catch {
-        NSLog("[SniConnect] ❌ Request failed: \(error.localizedDescription)")
-        sendLogEvent(level: "error", message: "Request failed: \(error.localizedDescription)")
+        SniConnectLog.error("Request failed: \(error.localizedDescription)")
         reject("SNI_UNKNOWN_ERROR", error.localizedDescription, error)
       }
     }
@@ -104,8 +80,8 @@ final class SniConnectImpl: NSObject {
   @objc
   public func cancelRequest(
     _ requestId: String,
-    resolve resolve: @escaping RCTPromiseResolveBlock,
-    reject reject: @escaping RCTPromiseRejectBlock
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
   ) {
     client.cancelRequest(requestId: requestId)
     resolve(["success": true])
@@ -114,7 +90,7 @@ final class SniConnectImpl: NSObject {
   @objc
   public func cancelAllRequests(
     _ resolve: @escaping RCTPromiseResolveBlock,
-    reject reject: @escaping RCTPromiseRejectBlock
+    reject: @escaping RCTPromiseRejectBlock
   ) {
     client.cancelAllRequests()
     resolve(["success": true])
@@ -123,7 +99,7 @@ final class SniConnectImpl: NSObject {
   @objc
   public func clearDNSCache(
     _ resolve: @escaping RCTPromiseResolveBlock,
-    reject reject: @escaping RCTPromiseRejectBlock
+    reject: @escaping RCTPromiseRejectBlock
   ) {
     client.clearDNSCache()
     resolve(["success": true])
@@ -162,24 +138,25 @@ final class SniConnectImpl: NSObject {
     )
   }
 
+  private static func validate(_ config: SniConnectClient.RequestConfig) throws {
+    try SniConnectValidation.validatePublicIP(config.ip)
+    try SniConnectValidation.validateHostname(config.hostname)
+    try SniConnectValidation.validateHeaders(config.headers)
+    _ = try SniConnectValidation.normalizeMethod(config.method)
+    _ = try SniConnectValidation.normalizePath(config.path)
+  }
+
   private static func serializeResponseData(_ data: Any) -> String {
-    if let dict = data as? [String: Any],
-       let jsonData = try? JSONSerialization.data(withJSONObject: dict, options: []),
-       let jsonString = String(data: jsonData, encoding: .utf8) {
-      return jsonString
+    if let stringValue = data as? String {
+      return stringValue
     }
 
-    if let array = data as? [[String: Any]],
-       let jsonData = try? JSONSerialization.data(withJSONObject: array, options: []),
+    if JSONSerialization.isValidJSONObject(data),
+       let jsonData = try? JSONSerialization.data(withJSONObject: data, options: []),
        let jsonString = String(data: jsonData, encoding: .utf8) {
       return jsonString
     }
 
-    if let stringValue = data as? String {
-      return stringValue
-    }
-
     return String(describing: data)
   }
 }
-