react-native-security-suite 0.6.5 → 0.6.6

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Mohammad Navabi
+Copyright (c) 2024 Mohammad Navabi
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights

package/README.md

@@ -14,11 +14,11 @@ You can use any of the following:
 ## Installation
 
 ```sh
-yarn add react-native-security-suite
+yarn add react-native-security-suite @react-native-async-storage/async-storage
 ```
 
 ```sh
-npm install react-native-security-suite
+npm install react-native-security-suite @react-native-async-storage/async-storage
 ```
 
 ## Usage

package/android/build.gradle

@@ -1,8 +1,6 @@
-apply plugin: "com.android.library"
-apply plugin: "kotlin-android"
-
 buildscript {
-  def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['SecuritySuite_kotlinVersion']
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["SecuritySuite_kotlinVersion"]
 
   repositories {
     google()
@@ -11,18 +9,27 @@ buildscript {
 
   dependencies {
     classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   }
 }
 
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
 def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
-apply plugin: "com.android.library"
 
 
-def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+plugins {
+  id "com.android.library"
+  id "kotlin-android"
+  id "com.google.devtools.ksp" version "1.9.21-1.0.15"
+}
 
 if (isNewArchitectureEnabled()) {
   apply plugin: "com.facebook.react"
@@ -42,20 +49,16 @@ def supportsNamespace() {
   def minor = parsed[1].toInteger()
 
   // Namespace support was added in 7.3.0
-  if (major == 7 && minor >= 3) {
-    return true
-  }
-
-  return major >= 8
+  return (major == 7 && minor >= 3) || major >= 8
 }
 
 android {
   if (supportsNamespace()) {
     namespace "com.securitysuite"
-  } else {
+
     sourceSets {
       main {
-        manifest.srcFile "src/main/AndroidManifestDeprecated.xml"
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
       }
     }
   }
@@ -65,8 +68,9 @@ android {
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
   }
+
   buildTypes {
     release {
       minifyEnabled false
@@ -78,35 +82,48 @@ android {
   }
 
   compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
   }
 
+  kotlin {
+    jvmToolchain(17)
+  }
+
+  buildFeatures {
+    dataBinding true
+  }
 }
 
 repositories {
   mavenCentral()
   google()
-  jcenter()
 }
 
-def kotlin_version = getExtOrDefault('kotlinVersion')
+def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
   // For < 0.71, this will be from the local maven repo
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
-  implementation "com.squareup.okhttp3:okhttp:3.0.1"
-  implementation "com.scottyab:rootbeer-lib:0.1.0"
-  implementation "com.github.mrmike:ok2curl:0.8.0"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-}
 
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "SecuritySuite"
-    codegenJavaPackageName = "com.securitysuite"
-  }
+  implementation "com.squareup.okhttp3:okhttp:4.12.0"
+  implementation "com.scottyab:rootbeer-lib:0.1.0"
+
+  implementation "com.google.android.material:material:1.12.0"
+  implementation "com.google.code.gson:gson:2.11.0"
+  implementation "org.brotli:dec:0.1.2"
+  implementation "androidx.databinding:viewbinding:8.7.3"
+  implementation "androidx.constraintlayout:constraintlayout:2.2.0"
+  implementation "androidx.palette:palette-ktx:1.0.0"
+  implementation "androidx.activity:activity-ktx:1.9.3"
+  implementation "androidx.fragment:fragment-ktx:1.8.5"
+  implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7"
+  implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.8.7"
+  implementation "androidx.room:room-ktx:2.6.1"
+  implementation "androidx.room:room-runtime:2.6.1"
+  ksp "androidx.room:room-compiler:2.6.1"
 }
+

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <queries>
+    <intent>
+      <action android:name="android.intent.action.CREATE_DOCUMENT" />
+      <data android:mimeType="*/*" />
+    </intent>
+  </queries>
+
+  <uses-permission
+    android:name="android.permission.WAKE_LOCK"
+    android:maxSdkVersion="25" />
+
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+  <application>
+    <activity
+      android:name="com.securitysuite.internal.ui.MainActivity"
+      android:label="@string/chucker_name"
+      android:launchMode="singleTask"
+      android:taskAffinity="com.securitysuite.task"
+      android:theme="@style/Chucker.Theme" />
+
+    <activity
+      android:name="com.securitysuite.internal.ui.transaction.TransactionActivity"
+      android:parentActivityName="com.securitysuite.internal.ui.MainActivity"
+      android:theme="@style/Chucker.Theme" />
+
+    <service
+      android:name="com.securitysuite.internal.support.ClearDatabaseService"
+      android:exported="false"
+      android:permission="android.permission.BIND_JOB_SERVICE" />
+
+    <receiver
+      android:name="com.securitysuite.internal.support.ClearDatabaseJobIntentServiceReceiver"
+      android:exported="false" />
+
+    <provider
+      android:name="com.securitysuite.internal.support.ChuckerFileProvider"
+      android:authorities="${applicationId}.com.securitysuite.provider"
+      android:exported="false"
+      android:grantUriPermissions="true">
+      <meta-data
+        android:name="android.support.FILE_PROVIDER_PATHS"
+        android:resource="@xml/chucker_provider_paths" />
+    </provider>
+  </application>
 </manifest>

package/android/src/main/{AndroidManifestDeprecated.xml → AndroidManifestNew.xml}

@@ -1,3 +1,2 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.securitysuite">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 </manifest>

package/android/src/main/java/com/securitysuite/NetworkLogger.java

@@ -0,0 +1,25 @@
+package com.securitysuite;
+
+import android.content.Context;
+
+import com.facebook.react.modules.network.OkHttpClientFactory;
+import com.facebook.react.modules.network.ReactCookieJarContainer;
+import com.securitysuite.api.ChuckerInterceptor;
+
+import okhttp3.OkHttpClient;
+public class NetworkLogger implements OkHttpClientFactory {
+  private Context context;
+
+  public NetworkLogger(Context context) {
+    this.context = context;
+  }
+
+  public OkHttpClient createNewNetworkModuleClient() {
+    OkHttpClient client = new OkHttpClient.Builder()
+      .addInterceptor(new ChuckerInterceptor.Builder(context).build())
+      .cookieJar(new ReactCookieJarContainer())
+      .build();
+
+    return client;
+  }
+}

package/android/src/main/java/com/securitysuite/Sslpinning.java

@@ -1,11 +1,9 @@
 package com.securitysuite;
 
-import com.securitysuite.modifier.Base64Decoder;
-import com.securitysuite.modifier.BasicAuthorizationHeaderModifier;
-
 import android.content.Context;
 import android.net.Uri;
 
+import com.facebook.react.modules.network.OkHttpClientProvider;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -15,10 +13,6 @@ import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.bridge.WritableMap;
 
-import com.moczul.ok2curl.modifier.HeaderModifier;
-import com.moczul.ok2curl.Configuration;
-import com.moczul.ok2curl.CurlInterceptor;
-
 import org.json.JSONException;
 
 import java.io.BufferedOutputStream;
@@ -32,9 +26,8 @@ import java.net.SocketTimeoutException;
 import java.net.URI;
 import java.net.URISyntaxException;
 
-import java.util.ArrayList;
+import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
@@ -53,46 +46,41 @@ import okio.Buffer;
 
 public class Sslpinning {
   private ReactApplicationContext context;
+  private static String hostname = "";
   private static String content_type = "application/json; charset=utf-8";
   public static MediaType mediaType = MediaType.parse(content_type);
   String responseBodyString = "{}";
-  private static AndroidLogger curl = null;
+  Callback callback;
 
   public Sslpinning(ReactApplicationContext context) {
     this.context = context;
   }
 
   public void fetch(String url, final ReadableMap options, SecretKey sharedKey, Callback callback) {
+    this.callback = callback;
+
     if (!isValidUrl(url)) {
       callback.invoke(null, "url is invalid!");
       return;
     }
 
-    String hostname;
     try {
-      hostname = getHostname(url);
+      this.hostname = getHostname(url);
     } catch (URISyntaxException e) {
-      hostname = url;
-    }
-
-    if (!options.hasKey("certificates")) {
-      callback.invoke(null, "certificates is required!");
-      return;
-    }
-
-    ReadableArray hashes = options.getArray("certificates");
-    if (hashes == null || hashes.size() == 0) {
-      callback.invoke(null, "certificates is empty!");
-      return;
+      this.hostname = url;
     }
 
     try {
-      CertificatePinner certificatePinner = getCertificatePinner(hostname, options);
-      OkHttpClient client = getClient(options, certificatePinner);
+      OkHttpClient client = getClient(options);
 
       Headers header = setHeader(options);
-      RequestBody requestBody = setBody(context, options);
       String method = getMethod(options);
+      RequestBody requestBody = setBody(options);
+
+      if (!method.equals("GET") && requestBody == null) {
+        this.callback.invoke(null, "For " + method + " method body option is Required!");
+        return;
+      }
 
       // JWS handler
       String jwsHeader = "";
@@ -129,11 +117,10 @@ public class Sslpinning {
         int responseCode = response.code();
 
         byte[] bytes = response.body().bytes();
-        responseBodyString = new String(bytes, "UTF-8");
+        responseBodyString = new String(bytes, StandardCharsets.UTF_8);
 
         output.putInt("status", responseCode);
         output.putString("url", request.url().toString());
-        output.putString("curl", curl.getCurl());
 
         // response time
         long tx = response.sentRequestAtMillis();
@@ -162,44 +149,37 @@ public class Sslpinning {
     }
   }
 
-  private CertificatePinner getCertificatePinner(String hostname, ReadableMap options) {
+  private CertificatePinner getCertificatePinner(ReadableMap options) {
     CertificatePinner.Builder certificatePinner = new CertificatePinner.Builder();
 
     ReadableArray hashes = options.getArray("certificates");
     for (int i = 0; i < hashes.size(); i++) {
-      certificatePinner.add(hostname, "sha256/" + hashes.getString(i).replaceAll("sha256/", ""));
+      certificatePinner.add(this.hostname, "sha256/" + hashes.getString(i).replaceAll("sha256/", ""));
     }
 
     return certificatePinner.build();
   }
 
-  private OkHttpClient getClient(ReadableMap options, CertificatePinner certificatePinner) throws JSONException {
-    CurlInterceptor curlInterceptor = handleCurl();
+  private OkHttpClient getClient(ReadableMap options) throws JSONException {
+    OkHttpClient.Builder builder = new OkHttpClient.Builder();
+
+    if (options.hasKey("certificates")) {
+      CertificatePinner certificatePinner = getCertificatePinner(options);
+      builder.certificatePinner(certificatePinner);
+    }
 
     if (options.hasKey("timeout")) {
       int timeout = options.getInt("timeout");
-      return new OkHttpClient.Builder()
-          .connectTimeout(timeout, TimeUnit.MILLISECONDS)
+      builder.connectTimeout(timeout, TimeUnit.MILLISECONDS)
           .readTimeout(timeout, TimeUnit.MILLISECONDS)
-          .writeTimeout(timeout, TimeUnit.MILLISECONDS)
-          .certificatePinner(certificatePinner)
-          .addInterceptor(curlInterceptor)
-          .build();
-    } else {
-      return new OkHttpClient.Builder()
-          .certificatePinner(certificatePinner)
-          .build();
+          .writeTimeout(timeout, TimeUnit.MILLISECONDS);
     }
-  }
 
-  private CurlInterceptor handleCurl() {
-    BasicAuthorizationHeaderModifier modifier = new BasicAuthorizationHeaderModifier(new Base64Decoder());
-    List<HeaderModifier> headerModifiers = new ArrayList<>();
-    headerModifiers.add(modifier);
-    Configuration config = new Configuration(headerModifiers);
-    CurlInterceptor curlInterceptor = new CurlInterceptor(curl = new AndroidLogger(), config);
+    if (options.hasKey("loggerIsEnabled") && options.getBoolean("loggerIsEnabled")) {
+      OkHttpClientProvider.setOkHttpClientFactory(new NetworkLogger(context));
+    }
 
-    return curlInterceptor;
+    return builder.build();
   }
 
   private static String getHostname(String url) throws URISyntaxException {
@@ -267,12 +247,13 @@ public class Sslpinning {
     return value.hasKey("type") && (value.hasKey("uri") || value.hasKey("path"));
   }
 
-  private RequestBody setBody(ReactApplicationContext context, ReadableMap options) {
+  private RequestBody setBody(ReadableMap options) {
+    RequestBody body = null;
+
     if (!options.hasKey("body")) {
-      return null;
+      return body;
     }
 
-    RequestBody body = null;
     ReadableType bodyType = options.getType("body");
     switch (bodyType) {
       case String:
@@ -285,9 +266,12 @@ public class Sslpinning {
           body = getBody(formData);
         } else if (bodyMap.hasKey("_parts")) {
           body = getBody(bodyMap);
+        } else {
+          body = RequestBody.create(mediaType, bodyMap.toString());
         }
         break;
     }
+
     return body;
   }
 

package/android/src/main/java/com/securitysuite/api/BodyDecoder.kt

@@ -0,0 +1,35 @@
+package com.securitysuite.api
+
+import okhttp3.Request
+import okhttp3.Response
+import okio.ByteString
+import okio.IOException
+
+/**
+ * Decodes HTTP request and response bodies to human–readable texts.
+ */
+public interface BodyDecoder {
+    /**
+     * Returns a text representation of [body] that will be displayed in Chucker UI transaction,
+     * or `null` if [request] cannot be handled by this decoder. [Body][body] is no longer than
+     * [max content length][ChuckerInterceptor.Builder.maxContentLength] and is guaranteed to be
+     * uncompressed even if [request] has gzip or br header.
+     */
+    @Throws(IOException::class)
+    public fun decodeRequest(
+        request: Request,
+        body: ByteString,
+    ): String?
+
+    /**
+     * Returns a text representation of [body] that will be displayed in Chucker UI transaction,
+     * or `null` if [response] cannot be handled by this decoder. [Body][body] is no longer than
+     * [max content length][ChuckerInterceptor.Builder.maxContentLength] and is guaranteed to be
+     * uncompressed even if [response] has gzip or br header.
+     */
+    @Throws(IOException::class)
+    public fun decodeResponse(
+        response: Response,
+        body: ByteString,
+    ): String?
+}

package/android/src/main/java/com/securitysuite/api/Chucker.kt

@@ -0,0 +1,108 @@
+package com.securitysuite.api
+
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ShortcutInfo
+import android.content.pm.ShortcutManager
+import android.graphics.drawable.Icon
+import android.os.Build
+import android.util.Log
+import androidx.core.content.getSystemService
+import com.securitysuite.R
+import com.securitysuite.internal.support.Logger
+import com.securitysuite.internal.support.NotificationHelper
+import com.securitysuite.internal.ui.MainActivity
+
+/**
+ * Chucker methods and utilities to interact with the library.
+ */
+public object Chucker {
+    private const val SHORTCUT_ID = "chuckerShortcutId"
+
+    /**
+     * Keep track of latest show notifications value from ChuckerCollector.
+     */
+    internal var showNotifications: Boolean = true
+
+    /**
+     * Check if this instance is the operation one or no-op.
+     * @return `true` if this is the operation instance.
+     */
+    @Suppress("MayBeConst ") // https://github.com/ChuckerTeam/chucker/pull/169#discussion_r362341353
+    public val isOp: Boolean = true
+
+    /**
+     * Get an Intent to launch the Chucker UI directly.
+     * @param context An Android [Context].
+     * @return An Intent for the main Chucker Activity that can be started with [Context.startActivity].
+     */
+    @JvmStatic
+    public fun getLaunchIntent(context: Context): Intent {
+        return Intent(context, MainActivity::class.java)
+            .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+
+    /**
+     * Create a shortcut to launch Chucker UI.
+     * @param context An Android [Context].
+     */
+    internal fun createShortcut(context: Context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N_MR1) {
+            return
+        }
+
+        val shortcutManager = context.getSystemService<ShortcutManager>() ?: return
+        if (shortcutManager.dynamicShortcuts.any { it.id == SHORTCUT_ID }) {
+            return
+        }
+
+        val shortcut =
+            ShortcutInfo.Builder(context, SHORTCUT_ID)
+                .setShortLabel(context.getString(R.string.chucker_shortcut_label))
+                .setLongLabel(context.getString(R.string.chucker_shortcut_label))
+                .setIcon(Icon.createWithResource(context, R.mipmap.chucker_ic_launcher))
+                .setIntent(getLaunchIntent(context).setAction(Intent.ACTION_VIEW))
+                .build()
+        try {
+            shortcutManager.addDynamicShortcuts(listOf(shortcut))
+        } catch (e: IllegalArgumentException) {
+            Logger.warn("ShortcutManager addDynamicShortcuts failed ", e)
+        } catch (e: IllegalStateException) {
+            Logger.warn("ShortcutManager addDynamicShortcuts failed ", e)
+        }
+    }
+
+    /**
+     * Dismisses all previous Chucker notifications.
+     */
+    @JvmStatic
+    public fun dismissNotifications(context: Context) {
+        NotificationHelper(context).dismissNotifications()
+    }
+
+    internal var logger: Logger =
+        object : Logger {
+            val TAG = "Chucker"
+
+            override fun info(
+                message: String,
+                throwable: Throwable?,
+            ) {
+                Log.i(TAG, message, throwable)
+            }
+
+            override fun warn(
+                message: String,
+                throwable: Throwable?,
+            ) {
+                Log.w(TAG, message, throwable)
+            }
+
+            override fun error(
+                message: String,
+                throwable: Throwable?,
+            ) {
+                Log.e(TAG, message, throwable)
+            }
+        }
+}