react-native-ssl-manager 1.0.0 → 1.0.2

package/android/src/oldarch/com/usesslpinning/UseSslPinningModule.kt

@@ -0,0 +1,32 @@
+package com.usesslpinning
+
+import android.content.Context 
+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
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = UseSslPinningModuleImpl.NAME)
+class UseSslPinningModule(reactContext: ReactApplicationContext) : 
+    ReactContextBaseJavaModule(reactContext) {
+
+    init {
+        UseSslPinningModuleImpl.initialize(reactContext)
+    }
+
+    override fun getName(): String {
+        return UseSslPinningModuleImpl.NAME
+    }
+
+    @ReactMethod
+    fun setUseSSLPinning(usePinning: Boolean, promise: Promise) {
+        UseSslPinningModuleImpl.setUseSSLPinning(reactApplicationContext, usePinning, promise)
+    }
+
+    @ReactMethod
+    fun getUseSSLPinning(promise: Promise) {
+        UseSslPinningModuleImpl.getUseSSLPinning(reactApplicationContext, promise)
+    }
+}

package/android/src/{main/java → oldarch}/com/usesslpinning/UseSslPinningPackage.kt

@@ -5,7 +5,6 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
-
 class UseSslPinningPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
     return listOf(UseSslPinningModule(reactContext))

package/android/ssl-pinning-setup.gradle

@@ -0,0 +1,148 @@
+def findSslConfigFile() {
+    def candidates = [
+        file("${project.rootDir}/../ssl_config.json"), // repo root (android/ là thư mục con)
+        file("${project.rootDir}/ssl_config.json"),    // android root
+        file("${projectDir}/../../ssl_config.json"),   // monorepo fallback
+        file("${projectDir}/../ssl_config.json")
+    ]
+    for (f in candidates) {
+        if (f.exists()) return f
+    }
+    return null
+}
+
+def ensureAssetsDir() {
+    def d = file("${projectDir}/src/main/assets")
+    if (!d.exists()) d.mkdirs()
+    return d
+}
+
+def assetsDir = file("${projectDir}/src/main/assets")
+def destFile  = file("${projectDir}/src/main/assets/ssl_config.json")
+
+plugins.withId('com.android.application') {
+
+    // ===== AGP 7/8: androidComponents DSL =====
+    if (project.extensions.findByName("androidComponents") != null) {
+        androidComponents {
+            onVariants(selector().all()) { variant ->   // <-- Sửa chỗ này
+                def vName = variant.name
+                def vNameCap = vName.substring(0,1).toUpperCase() + vName.substring(1)
+                def taskName = "copySslConfig${vNameCap}"
+
+                tasks.register(taskName, Copy) {
+                    group = "SSL Pinning"
+                    description = "Copy ssl_config.json to assets for ${vName}"
+
+                    def sourceFile = findSslConfigFile()
+
+                    onlyIf {
+                        if (sourceFile) {
+                            println "📋 SSL Config found: ${sourceFile.absolutePath}"
+                            true
+                        } else {
+                            println "⚠️ SSL Config not found in expected locations"
+                            false
+                        }
+                    }
+
+                    doFirst {
+                        ensureAssetsDir()
+                        println "🔄 Copying SSL config for variant: ${vName}"
+                        println "📂 To: ${assetsDir}"
+                    }
+
+                    from { sourceFile }
+                    into assetsDir
+
+                    doLast {
+                        if (destFile.exists()) {
+                            println "✅ SSL config copied: ${destFile} (${destFile.length()} bytes)"
+                        } else {
+                            println "❌ SSL config copy failed"
+                        }
+                    }
+                }
+
+                // Hook chắc chắn cho assemble/install/mergeAssets
+                tasks.matching { it.name == "merge${vNameCap}Assets" }.configureEach { dependsOn taskName }
+                tasks.matching { it.name == "install${vNameCap}" }.configureEach   { dependsOn taskName }
+                tasks.matching { it.name == "assemble${vNameCap}" }.configureEach  { dependsOn taskName }
+            }
+        }
+
+    } else {
+        // ===== Fallback: API cũ applicationVariants =====
+        afterEvaluate {
+            android.applicationVariants.all { variant ->
+                def bt = variant.buildType.name
+                def fl = variant.flavorName ?: ""
+                def vNameCap = (fl ? "${fl.capitalize()}${bt.capitalize()}" : bt.capitalize())
+                def taskName = "copySslConfig${vNameCap}"
+
+                def copyTask = tasks.create(taskName, Copy) {
+                    group = "SSL Pinning"
+                    description = "Copy ssl_config.json to assets for ${vNameCap}"
+
+                    def sourceFile = findSslConfigFile()
+
+                    onlyIf {
+                        if (sourceFile) {
+                            println "📋 SSL Config found: ${sourceFile.absolutePath}"
+                            true
+                        } else {
+                            println "⚠️ SSL Config not found in expected locations"
+                            false
+                        }
+                    }
+
+                    doFirst {
+                        ensureAssetsDir()
+                        println "🔄 Copying SSL config for variant: ${vNameCap}"
+                        println "📂 To: ${assetsDir}"
+                    }
+
+                    from { sourceFile }
+                    into assetsDir
+
+                    doLast {
+                        if (destFile.exists()) {
+                            println "✅ SSL config copied: ${destFile} (${destFile.length()} bytes)"
+                        } else {
+                            println "❌ SSL config copy failed"
+                        }
+                    }
+                }
+
+                try {
+                    if (variant.hasProperty("mergeAssetsProvider")) {
+                        variant.mergeAssetsProvider.configure { dependsOn copyTask }
+                    } else {
+                        tasks.named("merge${vNameCap}Assets").configure { dependsOn copyTask }
+                    }
+                } catch (ignored) { }
+                try { tasks.named("install${vNameCap}").configure { dependsOn copyTask } } catch (ignored) { }
+                try { tasks.named("assemble${vNameCap}").configure { dependsOn copyTask } } catch (ignored) { }
+            }
+        }
+    }
+
+    // ===== Utility =====
+    tasks.register("checkSslConfig") {
+        group = "SSL Pinning"
+        description = "Check SSL config file status"
+        doLast {
+            def source = findSslConfigFile()
+            println "\n📋 SSL Pinning Configuration Status:"
+            println "   Source config: " + (source ? "✅ Found at ${source.absolutePath}" : "❌ Not found")
+            println "   Assets config: " + (destFile.exists() ? "✅ Found at ${destFile.absolutePath}" : "❌ Not found")
+            if (!source) {
+                println "💡 Create ssl_config.json tại repo root (ngang 'android/') hoặc trong 'android/'."
+            } else if (!destFile.exists()) {
+                println "💡 Run: ./gradlew copySslConfigDebug (hoặc biến thể tương ứng)"
+            } else {
+                println "✅ SSL config is properly setup"
+            }
+        }
+    }
+}

package/app.plugin.js

@@ -0,0 +1,293 @@
+const {
+  withInfoPlist,
+  withDangerousMod,
+  withXcodeProject,
+  withAndroidManifest,
+  withMainApplication,
+} = require('@expo/config-plugins');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Expo Config Plugin for react-native-ssl-manager
+ * Automatically configures SSL pinning for Expo projects
+ */
+function withSslManager(config, options = {}) {
+  const {
+    enableAndroid = true,
+    enableIOS = true,
+    sslConfigPath = 'ssl_config.json',
+  } = options;
+
+  // Add Android configuration
+  if (enableAndroid) {
+    config = withAndroidSslPinning(config);
+    config = withAndroidMainApplication(config);
+    config = withAndroidAssets(config, { sslConfigPath });
+  }
+
+  // Add iOS configuration
+  if (enableIOS) {
+    config = withIOSSslPinning(config);
+    config = withIosAssets(config, { sslConfigPath });
+  }
+
+  return config;
+}
+
+/**
+ * Configure Android SSL pinning
+ */
+function withAndroidSslPinning(config) {
+  return withAndroidManifest(config, (config) => {
+    const manifest = config.modResults;
+
+    // Add required permissions
+    if (!manifest.manifest['uses-permission']) {
+      manifest.manifest['uses-permission'] = [];
+    }
+
+    const permissions = Array.isArray(manifest.manifest['uses-permission'])
+      ? manifest.manifest['uses-permission']
+      : [manifest.manifest['uses-permission']];
+
+    // Add INTERNET permission if not exists
+    if (
+      !permissions.find(
+        (p) => p.$['android:name'] === 'android.permission.INTERNET'
+      )
+    ) {
+      permissions.push({
+        $: {
+          'android:name': 'android.permission.INTERNET',
+        },
+      });
+    }
+
+    manifest.manifest['uses-permission'] = permissions;
+    return config;
+  });
+}
+
+/**
+ * Configure Android MainApplication - No longer needed as autolinking handles package registration
+ * Keeping function for backward compatibility but removing auto-registration to avoid duplicates
+ */
+function withAndroidMainApplication(config) {
+  // No longer auto-register package - let autolinking handle it
+  // This prevents duplicate module registration errors
+  return config;
+}
+
+/**
+ * Auto-copy SSL config to Android assets
+ */
+function withAndroidAssets(config, options) {
+  return withDangerousMod(config, [
+    'android',
+    async (config) => {
+      const { sslConfigPath = 'ssl_config.json' } = options;
+
+      try {
+        const projectRoot = config.modRequest.projectRoot;
+        const sourceConfigPath = path.resolve(projectRoot, sslConfigPath);
+
+        if (fs.existsSync(sourceConfigPath)) {
+          const assetsDir = path.join(
+            config.modRequest.platformProjectRoot,
+            'app/src/main/assets'
+          );
+
+          // Create assets directory if it doesn't exist
+          if (!fs.existsSync(assetsDir)) {
+            fs.mkdirSync(assetsDir, { recursive: true });
+          }
+
+          // Copy SSL config to assets
+          const targetPath = path.join(assetsDir, 'ssl_config.json');
+          fs.copyFileSync(sourceConfigPath, targetPath);
+        } else {
+          console.warn(`⚠️  SSL config file not found at: ${sourceConfigPath}`);
+          console.warn(
+            '💡 Place ssl_config.json in your project root for auto-setup'
+          );
+        }
+      } catch (error) {
+        console.warn('⚠️  Failed to auto-copy SSL config to assets:', error);
+      }
+
+      return config;
+    },
+  ]);
+}
+
+/**
+ * Configure iOS SSL pinning - No Info.plist modification needed
+ * SSL pinning is handled by SharedLogic.swift at runtime
+ */
+function withIOSSslPinning(config) {
+  // No Info.plist modifications needed
+  // SSL pinning is initialized at runtime by SharedLogic.swift
+
+  return config;
+}
+
+/**
+ * Auto-copy SSL config to iOS bundle resources and add to Xcode project
+ */
+function withIosAssets(config, options) {
+  // First copy the file
+  config = withDangerousMod(config, [
+    'ios',
+    async (config) => {
+      const { sslConfigPath = 'ssl_config.json' } = options;
+
+      try {
+        const projectRoot = config.modRequest.projectRoot;
+        const sourceConfigPath = path.resolve(projectRoot, sslConfigPath);
+
+        if (fs.existsSync(sourceConfigPath)) {
+          // Create ios directory if it doesn't exist
+          const iosDir = path.join(projectRoot, 'ios');
+          if (!fs.existsSync(iosDir)) {
+            fs.mkdirSync(iosDir, { recursive: true });
+          }
+
+          // Copy ssl_config.json to ios directory
+          const targetConfigPath = path.join(iosDir, 'ssl_config.json');
+          fs.copyFileSync(sourceConfigPath, targetConfigPath);
+
+          // Also copy to app bundle directory for Xcode project
+          const appBundleDir = path.join(iosDir, config.modRequest.projectName);
+          const appBundleConfigPath = path.join(
+            appBundleDir,
+            'ssl_config.json'
+          );
+          if (fs.existsSync(appBundleDir)) {
+            fs.copyFileSync(sourceConfigPath, appBundleConfigPath);
+          }
+        } else {
+          console.warn(`⚠️  SSL config file not found at: ${sourceConfigPath}`);
+          console.warn(
+            '💡 Place ssl_config.json in your project root for auto-setup'
+          );
+        }
+      } catch (error) {
+        console.warn('⚠️  Failed to copy SSL config:', error);
+      }
+
+      return config;
+    },
+  ]);
+
+  // Add to Xcode project programmatically - run in same withDangerousMod as file copy
+  config = withDangerousMod(config, [
+    'ios',
+    async (config) => {
+      // First ensure file is copied to app bundle directory
+      const projectName = config.modRequest.projectName || 'exampleexpo';
+      const projectRoot = config.modRequest.projectRoot;
+      const sourceConfigPath = path.resolve(projectRoot, 'ssl_config.json');
+      const appBundleDir = path.join(
+        config.modRequest.platformProjectRoot,
+        projectName
+      );
+      const appBundleConfigPath = path.join(appBundleDir, 'ssl_config.json');
+
+      // Ensure SSL config is copied to app bundle directory
+      if (fs.existsSync(sourceConfigPath) && fs.existsSync(appBundleDir)) {
+        fs.copyFileSync(sourceConfigPath, appBundleConfigPath);
+      }
+
+      try {
+        const projectPath = path.join(
+          config.modRequest.platformProjectRoot,
+          `${projectName}.xcodeproj/project.pbxproj`
+        );
+        const sslConfigPath = appBundleConfigPath;
+
+        if (!fs.existsSync(projectPath) || !fs.existsSync(sslConfigPath)) {
+          console.warn(
+            '⚠️  Xcode project or SSL config not found, skipping automatic addition'
+          );
+          return config;
+        }
+
+        let projectContent = fs.readFileSync(projectPath, 'utf8');
+
+        // Check if already added
+        if (projectContent.includes('ssl_config.json')) {
+          return config;
+        }
+
+        // Generate unique IDs for the file
+        const fileRefId =
+          'SSL' + Math.random().toString(36).substr(2, 24).toUpperCase();
+        const buildFileId =
+          'SSL' + Math.random().toString(36).substr(2, 24).toUpperCase();
+
+        // Add file reference
+        const fileRefEntry = `\t\t${fileRefId} /* ssl_config.json */ = {isa = PBXFileReference; lastKnownFileType = text.json; path = ssl_config.json; sourceTree = "<group>"; };`;
+        projectContent = projectContent.replace(
+          '/* End PBXFileReference section */',
+          fileRefEntry + '\n\t\t/* End PBXFileReference section */'
+        );
+
+        // Add build file
+        const buildFileEntry = `\t\t${buildFileId} /* ssl_config.json in Resources */ = {isa = PBXBuildFile; fileRef = ${fileRefId} /* ssl_config.json */; };`;
+        projectContent = projectContent.replace(
+          '/* End PBXBuildFile section */',
+          buildFileEntry + '\n\t\t/* End PBXBuildFile section */'
+        );
+
+        // Add to resources build phase
+        const resourcesPhaseMatch = projectContent.match(
+          /(\w+) \/\* Resources \*\/ = \{[^}]*files = \(([^)]*)\)/
+        );
+        if (resourcesPhaseMatch) {
+          const filesSection = resourcesPhaseMatch[2];
+          const newFilesSection =
+            filesSection +
+            `\t\t\t\t${buildFileId} /* ssl_config.json in Resources */,\n`;
+          projectContent = projectContent.replace(
+            `files = (${filesSection})`,
+            `files = (\n${newFilesSection}\t\t\t)`
+          );
+        }
+
+        // Add to main group
+        const mainGroupMatch = projectContent.match(
+          new RegExp(
+            `(\\w+) /\\* ${projectName} \\*/ = \\{[^}]*children = \\(([^)]*)\\)`
+          )
+        );
+        if (mainGroupMatch) {
+          const childrenSection = mainGroupMatch[2];
+          const newChildrenSection =
+            childrenSection + `\t\t\t\t${fileRefId} /* ssl_config.json */,\n`;
+          projectContent = projectContent.replace(
+            `children = (${childrenSection})`,
+            `children = (\n${newChildrenSection}\t\t\t)`
+          );
+        }
+
+        // Write back to file
+        fs.writeFileSync(projectPath, projectContent);
+      } catch (error) {
+        console.warn(
+          '⚠️  Failed to add SSL config to Xcode project:',
+          error.message
+        );
+        console.warn(
+          '💡 File copied to ios/ directory, manual Xcode setup may be needed'
+        );
+      }
+
+      return config;
+    },
+  ]);
+
+  return config;
+}
+
+module.exports = withSslManager;

package/expo-module.config.json

@@ -0,0 +1,10 @@
+{
+  "name": "react-native-ssl-manager",
+  "platforms": ["apple"],
+  "android": {
+    "modules": []
+  },
+  "apple": {
+    "modules": ["UseSslPinningExpoModule"]
+  }
+}