react-native-ssl-manager 1.0.0 → 1.0.2

package/react-native-ssl-manager.podspec

@@ -1,43 +1,92 @@
-require "json"
-
-package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-
 Pod::Spec.new do |s|
-  s.name         = "react-native-ssl-manager"
-  s.version      = package["version"]
-  s.summary      = package["description"]
-  s.homepage     = package["homepage"]
-  s.license      = package["license"]
-  s.authors      = package["author"]
-
-  s.platforms    = { :ios => min_ios_version_supported }
-  s.source       = { :git => "https://github.com/huytdps13400/react-native-ssl-manager.git", :tag => "#{s.version}" }
+  s.name = 'react-native-ssl-manager'
+  s.version = '1.0.1'
+  s.summary = 'SSL Pinning Module for React Native and Expo'
+  s.author = 'Huy Tran'
+  s.homepage = 'https://github.com/huytdps13400/react-native-ssl-manager'
+  s.platforms = { :ios => '13.0' }
+  s.source = { :git => 'https://github.com/huytdps13400/react-native-ssl-manager', :tag => s.version.to_s }
+  
 
+  
+  # RNBootSplash pattern - single implementation for all architectures  
   s.source_files = "ios/**/*.{h,m,mm,swift}"
-
-  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
-  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
-  if respond_to?(:install_modules_dependencies, true)
-    install_modules_dependencies(s)
-  else
-  s.dependency "React-Core"
-
-  # Don't install the dependencies when we run `pod install` in the old architecture.
+  
+  s.pod_target_xcconfig = { "DEFINES_MODULE" => "YES" }
+  
   if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
-    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
-    s.pod_target_xcconfig    = {
-        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
-        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
-        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    # New Architecture dependencies would go here if needed
+    s.dependency "React-Core"
+  else
+    s.dependency "React-Core"
+  end
+  
+  # Use script phase to copy ssl_config.json during app build
+  s.script_phases = [
+    {
+      :name => 'Copy SSL Config to App Bundle',
+      :script => '
+        echo "🔧 SSL Manager: Copying ssl_config.json to app bundle..."
+        
+        # Look for ssl_config.json in parent directories of SRCROOT
+        SSL_CONFIG_SOURCE=""
+        
+        # Check common locations and verify content is not empty
+        if [ -f "${SRCROOT}/../ssl_config.json" ]; then
+          CONTENT=$(cat "${SRCROOT}/../ssl_config.json" | tr -d " \\n\\r")
+          if [ "$CONTENT" != "{}" ]; then
+            SSL_CONFIG_SOURCE="${SRCROOT}/../ssl_config.json"
+            echo "📄 Found ssl_config.json at: $SSL_CONFIG_SOURCE"
+          fi
+        fi
+        
+        if [ -z "$SSL_CONFIG_SOURCE" ] && [ -f "${SRCROOT}/../../ssl_config.json" ]; then
+          CONTENT=$(cat "${SRCROOT}/../../ssl_config.json" | tr -d " \\n\\r")
+          if [ "$CONTENT" != "{}" ]; then
+            SSL_CONFIG_SOURCE="${SRCROOT}/../../ssl_config.json"
+            echo "📄 Found ssl_config.json at: $SSL_CONFIG_SOURCE"
+          fi
+        fi
+        
+        if [ -z "$SSL_CONFIG_SOURCE" ] && [ -f "${SRCROOT}/../../../ssl_config.json" ]; then
+          CONTENT=$(cat "${SRCROOT}/../../../ssl_config.json" | tr -d " \\n\\r")
+          if [ "$CONTENT" != "{}" ]; then
+            SSL_CONFIG_SOURCE="${SRCROOT}/../../../ssl_config.json"
+            echo "📄 Found ssl_config.json at: $SSL_CONFIG_SOURCE"
+          fi
+        fi
+        
+        if [ -n "$SSL_CONFIG_SOURCE" ]; then
+          # Copy to app bundle resources
+          cp "$SSL_CONFIG_SOURCE" "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.app/"
+          echo "✅ SSL config copied to app bundle"
+        else
+          echo "⚠️ ssl_config.json not found in common locations"
+          echo "🔍 Searching for ssl_config.json with content..."
+          
+          # Search for any ssl_config.json with content
+          for path in $(find "${SRCROOT}/../.." -name "ssl_config.json" -type f 2>/dev/null); do
+            CONTENT=$(cat "$path" | tr -d " \\n\\r")
+            if [ "$CONTENT" != "{}" ]; then
+              SSL_CONFIG_SOURCE="$path"
+              echo "📄 Found ssl_config.json with content at: $SSL_CONFIG_SOURCE"
+              cp "$SSL_CONFIG_SOURCE" "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.app/"
+              echo "✅ SSL config copied to app bundle"
+              break
+            fi
+          done
+          
+          if [ -z "$SSL_CONFIG_SOURCE" ]; then
+            echo "💡 SRCROOT: $SRCROOT"
+            echo "💡 Create ssl_config.json at project root for SSL pinning to work"
+            exit 0
+          fi
+        fi
+      ',
+      :execution_position => :before_compile
     }
-    s.dependency "React-Codegen"
-    s.dependency "RCT-Folly"
-    s.dependency "RCTRequired"
-    s.dependency "RCTTypeSafety"
-    s.dependency "ReactCommon/turbomodule/core"
-   end
-  end    
-
-  s.dependency "TrustKit"
-end
+  ]
+  
+  s.dependency 'TrustKit'
+  s.dependency 'React-Core'
+end 

package/react-native.config.js

@@ -0,0 +1,34 @@
+// React Native SSL Manager Auto-linking Configuration
+
+module.exports = {
+  dependencies: {
+    'react-native-ssl-manager': {
+      platforms: {
+        android: {
+          sourceDir: '../android',
+          packageImportPath: 'import com.usesslpinning.UseSslPinningPackage;',
+          packageInstance: 'new UseSslPinningPackage()',
+          // Auto-setup SSL config copy script
+          buildTypes: [],
+          componentDescriptors: [],
+          cmakeListsPath: null,
+        },
+        ios: {
+          podspecPath: '../react-native-ssl-manager.podspec',
+        },
+      },
+      hooks: {
+        postlink: () => {
+          console.log('🔗 React Native SSL Manager linked successfully');
+          console.log('📋 SSL config auto-copy script is now available');
+          console.log(
+            '💡 Android: Run "cd android && ./gradlew checkSslConfig" to verify setup'
+          );
+          console.log(
+            '💡 iOS: ssl_config.json will be auto-copied during build'
+          );
+        },
+      },
+    },
+  },
+};

package/scripts/build.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# Build script for react-native-ssl-manager
+# This script helps build and test the library
+
+set -e
+
+echo "🚀 Building react-native-ssl-manager..."
+
+# Clean previous builds
+echo "🧹 Cleaning previous builds..."
+rm -rf lib/
+rm -rf build/
+
+# Install dependencies
+echo "📦 Installing dependencies..."
+yarn install
+
+# Type check
+echo "🔍 Running type check..."
+yarn typecheck
+
+# Build TypeScript
+echo "🔨 Building TypeScript..."
+yarn build
+
+# Run tests
+echo "🧪 Running tests..."
+yarn test
+
+echo "✅ Build completed successfully!"
+
+# Optional: Build examples
+if [ "$1" = "--with-examples" ]; then
+    echo "📱 Building examples..."
+    
+    # Build React Native CLI example
+    echo "Building React Native CLI example..."
+    cd example
+    yarn install
+    cd ..
+    
+    # Build Expo example
+    echo "Building Expo example..."
+    cd example-expo
+    yarn install
+    cd ..
+    
+    echo "✅ Examples built successfully!"
+fi
+
+echo "🎉 All done! The library is ready for use." 

package/src/NativeUseSslPinning.ts

@@ -0,0 +1,9 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  readonly setUseSSLPinning: (usePinning: boolean) => Promise<void>;
+  readonly getUseSSLPinning: () => Promise<boolean>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('UseSslPinning');

package/src/UseSslPinning.types.ts

@@ -0,0 +1,17 @@
+/**
+ * SSL Pinning Configuration Interface
+ * Defines the structure for SSL pinning configuration
+ */
+export interface SslPinningConfig {
+  sha256Keys: {
+    [domain: string]: string[];
+  };
+}
+
+/**
+ * SSL Pinning Error Interface
+ */
+export interface SslPinningError extends Error {
+  code?: string;
+  message: string;
+}

package/src/index.tsx

@@ -1,43 +1,63 @@
-import { NativeModules, Platform } from 'react-native';
-
-const LINKING_ERROR =
-  `The package 'react-native-ssl-manager' doesn't seem to be linked. Make sure: \n\n` +
-  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
-  '- You rebuilt the app after installing the package\n' +
-  '- You are not using Expo Go\n';
-
-const UseSslPinning = NativeModules.UseSslPinning
-  ? NativeModules.UseSslPinning
-  : new Proxy(
-      {},
-      {
-        get() {
-          throw new Error(LINKING_ERROR);
-        },
-      }
-    );
-
-export const setUseSSLPinning = (usePinning: boolean): void => {
-  UseSslPinning.setUseSSLPinning(usePinning);
-};
+// Remove unused Platform import since we no longer check OS
+
+// Export types from the library
+export type { SslPinningConfig, SslPinningError } from './UseSslPinning.types';
+
+// New Architecture and Legacy Architecture support
+let UseSslPinning: any;
+
+try {
+  // Try Legacy NativeModules first (more reliable)
+  const { NativeModules } = require('react-native');
+
+  // Look for our universal module (works in both CLI and Expo)
+  UseSslPinning = NativeModules.UseSslPinning;
+
+  if (UseSslPinning) {
+  } else {
+    // Fallback to TurboModule if available
+    try {
+      UseSslPinning = require('./NativeUseSslPinning').default;
+    } catch (turboModuleError) {
+      console.log(
+        '❌ TurboModule failed:',
+        (turboModuleError as Error).message
+      );
+      UseSslPinning = null;
+    }
+  }
+} catch (error) {
+  console.log('❌ Overall module loading failed:', (error as Error).message);
+  UseSslPinning = null;
+}
+
+// Fallback implementation if native module is not available
+if (!UseSslPinning) {
+  UseSslPinning = {
+    setUseSSLPinning: (_usePinning: boolean) => {
+      return Promise.resolve();
+    },
+    getUseSSLPinning: () => {
+      return Promise.resolve(true);
+    },
+  };
+}
 
 /**
- * Retrieves the current state of SSL pinning usage.
+ * Sets whether SSL pinning should be used.
  *
- * @returns A promise that resolves to a boolean indicating whether SSL pinning is being used.
+ * @param {boolean} usePinning - Whether to enable SSL pinning
+ * @returns {Promise<void>} A promise that resolves when the setting is saved
  */
-export const getUseSSLPinning = async (): Promise<boolean> => {
-  return await UseSslPinning.getUseSSLPinning();
+export const setUseSSLPinning = (usePinning: boolean): Promise<void> => {
+  return UseSslPinning.setUseSSLPinning(usePinning);
 };
 
 /**
- * Initializes SSL pinning with the provided configuration.
+ * Retrieves the current state of SSL pinning usage.
  *
- * @param {string} configJsonString - The JSON string containing the SSL pinning configuration.
- * @returns {Promise<any>} A promise that resolves when the SSL pinning is initialized.
+ * @returns A promise that resolves to a boolean indicating whether SSL pinning is being used.
  */
-export const initializeSslPinning = async (
-  configJsonString: string
-): Promise<any> => {
-  return await UseSslPinning.initializeSslPinning(configJsonString);
+export const getUseSSLPinning = async (): Promise<boolean> => {
+  return await UseSslPinning.getUseSSLPinning();
 };

package/android/src/main/java/com/usesslpinning/UseSslPinningFactory.kt

@@ -1,50 +0,0 @@
-package com.usesslpinning
-
-import android.content.Context
-import android.util.Log
-import com.facebook.react.modules.network.OkHttpClientFactory
-import com.facebook.react.modules.network.ReactCookieJarContainer
-import okhttp3.CertificatePinner
-import okhttp3.OkHttpClient
-import org.json.JSONObject
-
-class UseSslPinningFactory(
-  private val context: Context,
-  private val configJsonString: String
-) : OkHttpClientFactory {
-
-  override fun createNewNetworkModuleClient(): OkHttpClient {
-    val sharedPreferences = context.getSharedPreferences("AppSettings", Context.MODE_PRIVATE)
-    val useSSLPinning = sharedPreferences.getBoolean("useSSLPinning", true)
-
-    val clientBuilder = OkHttpClient.Builder().cookieJar(ReactCookieJarContainer()).apply {
-      if (useSSLPinning) {
-        val certificatePinnerBuilder = CertificatePinner.Builder()
-
-        try {
-          val configJson = JSONObject(configJsonString)
-          addCertificatesToPinner(certificatePinnerBuilder, configJson)
-          val certificatePinner = certificatePinnerBuilder.build()
-          certificatePinner(certificatePinner)
-        } catch (e: Exception) {
-          e.printStackTrace()
-        }
-      }
-    }.cache(null).build()
-
-    return clientBuilder
-  }
-  private fun addCertificatesToPinner(certificatePinnerBuilder: CertificatePinner.Builder, configJson: JSONObject) {
-    val sha256Keys = configJson.getJSONObject("sha256Keys")
-    val hostnames = sha256Keys.keys()
-    while (hostnames.hasNext()) {
-      val hostname = hostnames.next()
-      val keysArray = sha256Keys.getJSONArray(hostname)
-      for (i in 0 until keysArray.length()) {
-        val sha256Key = keysArray.getString(i)
-        certificatePinnerBuilder.add(hostname, sha256Key)
-      }
-    }
-  }
-}
-

package/android/src/main/java/com/usesslpinning/UseSslPinningModule.kt

@@ -1,45 +0,0 @@
-package com.usesslpinning
-
-import android.content.Context // Thêm dòng này
-import android.util.Log
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
-import com.facebook.react.modules.network.OkHttpClientProvider
-
-class UseSslPinningModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
-
-    override fun getName(): String {
-        return NAME
-    }
-
-    @ReactMethod
-    fun setUseSSLPinning(usePinning: Boolean) {
-        val sharedPreferences = reactApplicationContext.getSharedPreferences("AppSettings", Context.MODE_PRIVATE)
-        sharedPreferences.edit().putBoolean("useSSLPinning", usePinning).apply()
-    }
-
-    @ReactMethod
-    fun getUseSSLPinning(promise: Promise) {
-        val sharedPreferences = reactApplicationContext.getSharedPreferences("AppSettings", Context.MODE_PRIVATE)
-        val usePinning = sharedPreferences.getBoolean("useSSLPinning", true)
-        promise.resolve(usePinning)
-    }
-
-  @ReactMethod
-  fun initializeSslPinning(configJsonString: String, promise: Promise) {
-    try {
-      OkHttpClientProvider.setOkHttpClientFactory(UseSslPinningFactory(reactApplicationContext, configJsonString))
-      Log.d("MyLibrary", "SSL Pinning initialized successfully")
-      promise.resolve("SSL Pinning initialized successfully")
-    } catch (e: Exception) {
-      promise.reject("SSL_PINNING_ERROR", "Failed to initialize SSL Pinning", e)
-    }
-  }
-
-    companion object {
-        const val NAME = "UseSslPinning"
-    }
-}

package/ios/UseSslPinning-Bridging-Header.h

@@ -1,2 +0,0 @@
-#import <React/RCTBridgeModule.h>
-#import <React/RCTViewManager.h>

package/ios/UseSslPinning.swift

@@ -1,169 +0,0 @@
-import Foundation
-import TrustKit
-import TrustKit.TSKPinningValidator
-import TrustKit.TSKPinningValidatorCallback
-
-// Add SSLPinningError enum definition
-enum SSLPinningError: Error {
-    case invalidConfiguration
-    case invalidPinConfiguration(domain: String)
-    
-    var message: String {
-        switch self {
-        case .invalidConfiguration:
-            return "Invalid SSL pinning configuration format"
-        case .invalidPinConfiguration(let domain):
-            return "Invalid pin configuration for domain: \(domain)"
-        }
-    }
-}
-
-@objc(UseSslPinning)
-class UseSslPinning: NSObject {
-    private static var sharedTrustKit: TrustKit?
-    private let userDefaults = UserDefaults.standard
-    private let useSSLPinningKey = "useSSLPinning"
-    
-    private func cleanJsonString(_ jsonString: String) -> String {
-        var cleaned = jsonString
-            .replacingOccurrences(of: "\n", with: "")
-            .replacingOccurrences(of: "| ", with: "")
-            .replacingOccurrences(of: "\\ ", with: "")
-            .replacingOccurrences(of: "\\\"", with: "\"")
-        
-        // Remove any remaining backslashes before quotes
-        cleaned = cleaned.replacingOccurrences(of: "\\(?!\")", with: "")
-        
-        // Clean up any double spaces
-        cleaned = cleaned.replacingOccurrences(of: "  ", with: " ")
-        
-        NSLog("Original JSON: %@", jsonString)
-        NSLog("Cleaned JSON: %@", cleaned)
-        
-        return cleaned
-    }
-    
-    private func validateAndCleanPins(_ pins: [String], for domain: String) throws -> [String] {
-        return try pins.map { pin -> String in
-            var cleanPin = pin.trimmingCharacters(in: .whitespacesAndNewlines)
-            
-            // Verify pin format
-            guard cleanPin.starts(with: "sha256/") else {
-                NSLog("Invalid pin format (missing sha256/): %@", cleanPin)
-                throw SSLPinningError.invalidPinConfiguration(domain: domain)
-            }
-            
-            // Remove sha256/ prefix for TrustKit
-            cleanPin = cleanPin.replacingOccurrences(of: "sha256/", with: "")
-            
-            // Verify base64 format
-            guard cleanPin.range(of: "^[A-Za-z0-9+/=]+$", options: .regularExpression) != nil else {
-                NSLog("Invalid pin format (not base64): %@", cleanPin)
-                throw SSLPinningError.invalidPinConfiguration(domain: domain)
-            }
-            
-            return cleanPin
-        }
-    }
-    
-    @objc
-    func initializeSslPinning(_ configJsonString: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // Check if SSL pinning is enabled
-        let isSSLPinningEnabled = userDefaults.bool(forKey: useSSLPinningKey)
-        
-        if isSSLPinningEnabled {
-            do {
-                // Parse JSON configuration
-                guard let jsonData = configJsonString.data(using: .utf8),
-                      let config = try JSONSerialization.jsonObject(with: jsonData, options: []) as? [String: Any],
-                      let sha256Keys = config["sha256Keys"] as? [String: [String]] else {
-                    throw SSLPinningError.invalidConfiguration
-                }
-                
-                // Build pinned domains configuration
-                var pinnedDomains: [String: Any] = [:]
-                
-                // Process each domain and its pins from JSON
-                for (domain, pins) in sha256Keys {
-                    let cleanedPins = try pins.map { pin -> String in
-                        // Validate and clean the pin
-                        var cleanPin = pin.trimmingCharacters(in: .whitespacesAndNewlines)
-                        
-                        // Verify pin format
-                        guard cleanPin.starts(with: "sha256/") else {
-                            NSLog("Invalid pin format for domain %@: %@", domain, cleanPin)
-                            throw SSLPinningError.invalidPinConfiguration(domain: domain)
-                        }
-                        
-                        // Remove sha256/ prefix for TrustKit
-                        cleanPin = cleanPin.replacingOccurrences(of: "sha256/", with: "")
-                        
-                        return cleanPin
-                    }
-                    
-                    pinnedDomains[domain] = [
-                        kTSKIncludeSubdomains: true,
-                        kTSKEnforcePinning: true,
-                        kTSKDisableDefaultReportUri: true,
-                        kTSKPublicKeyHashes: cleanedPins
-                    ]
-                }
-                
-                let trustKitConfig: [String: Any] = [
-                    kTSKSwizzleNetworkDelegates: true,
-                    kTSKPinnedDomains: pinnedDomains
-                ]
-                
-                DispatchQueue.main.async {
-                    // Initialize TrustKit with the configuration
-                    TrustKit.initSharedInstance(withConfiguration: trustKitConfig)
-                    
-                    // Set up validation callback
-                    TrustKit.sharedInstance().pinningValidatorCallback = { result, notedHostname, policy in
-                        switch result.finalTrustDecision {
-                        case .shouldBlockConnection:
-                            NSLog("⛔️ SSL Pinning failed for domain: %@", notedHostname)
-                            NSLog("Policy details: %@", policy)
-                        case .shouldAllowConnection:
-                            NSLog("✅ SSL Pinning succeeded for domain: %@", notedHostname)
-                        default:
-                            NSLog("⚠️ Unexpected SSL Pinning result for domain: %@", notedHostname)
-                        }
-                    }
-                    
-                    NSLog("✅ TrustKit initialized with config: %@", trustKitConfig)
-                    resolve([
-                        "message": "SSL Pinning initialized successfully",
-                        "domains": Array(pinnedDomains.keys)
-                    ])
-                }
-                
-            } catch let error as SSLPinningError {
-                NSLog("❌ SSL Pinning Error: %@", error.message)
-                reject("SSL_PINNING_ERROR", error.message, error)
-            } catch {
-                NSLog("❌ Unexpected Error: %@", error.localizedDescription)
-                reject("SSL_PINNING_ERROR", "Unexpected error during SSL pinning initialization", error)
-            }
-        } else {
-            NSLog("⚠️ SSL Pinning is disabled",isSSLPinningEnabled)
-            resolve([
-                "message": "SSL Pinning is disabled",
-                "domains": [],
-                "isSSLPinningEnabled": isSSLPinningEnabled
-            ])
-        }
-    }
-    
-    @objc
-    func setUseSSLPinning(_ usePinning: Bool) {
-        userDefaults.set(usePinning, forKey: useSSLPinningKey)
-        userDefaults.synchronize()
-    }
-    
-    @objc
-    func getUseSSLPinning(_ resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) {
-        let usePinning = userDefaults.bool(forKey: useSSLPinningKey)
-        resolve(usePinning)
-    }
-}