freerasp-react-native 4.5.2 → 5.1.0

package/plugin/build/iosSpm.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const FREERASP_SPM_ACTIVATION_TAG = '# @generated freerasp-react-native (SPM activation)';
+const FREERASP_SPM_DISABLED_TAG = '# @generated freerasp-react-native (SPM disabled)';
+const FREERASP_SPM_EMBED_TAG = '# @generated freerasp-react-native (SPM embed)';
+const PREPARE_REACT_NATIVE_ANCHOR = 'prepare_react_native_project!';
+const REACT_NATIVE_POST_INSTALL_ANCHOR = 'react_native_post_install(';
+const indentationAt = (contents, index) => {
+    const lineStart = contents.lastIndexOf('\n', index - 1) + 1;
+    return contents.slice(lineStart, index).match(/^\s*/)?.[0] ?? '';
+};
+const removeManagedBlock = (contents, tag, bodyLineCount) => {
+    const newline = contents.includes('\r\n') ? '\r\n' : '\n';
+    const lines = contents.split(/\r?\n/);
+    const tagIndex = lines.findIndex((line) => line.trim() === tag);
+    if (tagIndex === -1) {
+        return contents;
+    }
+    let startIndex = tagIndex;
+    while (startIndex > 0 && lines[startIndex - 1]?.trim() === '') {
+        startIndex -= 1;
+    }
+    lines.splice(startIndex, tagIndex - startIndex + bodyLineCount + 1);
+    return lines.join(newline);
+};
+const findClosingParenthesis = (contents, openingIndex) => {
+    let depth = 0;
+    let quote;
+    let escaped = false;
+    let inComment = false;
+    for (let index = openingIndex; index < contents.length; index += 1) {
+        const character = contents[index];
+        if (inComment) {
+            if (character === '\n') {
+                inComment = false;
+            }
+            continue;
+        }
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === '\\') {
+                escaped = true;
+            }
+            else if (character === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (character === '#') {
+            inComment = true;
+        }
+        else if (character === "'" || character === '"') {
+            quote = character;
+        }
+        else if (character === '(') {
+            depth += 1;
+        }
+        else if (character === ')') {
+            depth -= 1;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return -1;
+};
+const mutatePodfileForFreeraspSpm = (contents, enabled = true) => {
+    let updatedContents = removeManagedBlock(contents, FREERASP_SPM_ACTIVATION_TAG, 1);
+    updatedContents = removeManagedBlock(updatedContents, FREERASP_SPM_DISABLED_TAG, 1);
+    updatedContents = removeManagedBlock(updatedContents, FREERASP_SPM_EMBED_TAG, 4);
+    const missingAnchors = [];
+    const prepareIndex = updatedContents.indexOf(PREPARE_REACT_NATIVE_ANCHOR);
+    const postInstallIndex = enabled
+        ? updatedContents.indexOf(REACT_NATIVE_POST_INSTALL_ANCHOR)
+        : -1;
+    const postInstallOpeningIndex = postInstallIndex === -1
+        ? -1
+        : postInstallIndex + REACT_NATIVE_POST_INSTALL_ANCHOR.length - 1;
+    const postInstallClosingIndex = postInstallOpeningIndex === -1
+        ? -1
+        : findClosingParenthesis(updatedContents, postInstallOpeningIndex);
+    if (prepareIndex === -1) {
+        missingAnchors.push(PREPARE_REACT_NATIVE_ANCHOR);
+    }
+    if (enabled && postInstallClosingIndex === -1) {
+        missingAnchors.push(REACT_NATIVE_POST_INSTALL_ANCHOR);
+    }
+    if (missingAnchors.length > 0) {
+        return { contents, changed: false, missingAnchors };
+    }
+    const newline = updatedContents.includes('\r\n') ? '\r\n' : '\n';
+    if (enabled) {
+        // Preserve the post-install index by inserting its snippet first.
+        const indent = indentationAt(updatedContents, postInstallIndex);
+        const snippet = [
+            '',
+            '',
+            `${indent}${FREERASP_SPM_EMBED_TAG}`,
+            `${indent}require Pod::Executable.execute_command('node', ['-p',`,
+            `${indent}  'require.resolve("freerasp-react-native/freerasp_spm.rb", {paths: [process.argv[1]]})',`,
+            `${indent}  __dir__]).strip`,
+            `${indent}freerasp_embed_talsec_spm!(installer)`,
+        ].join(newline);
+        updatedContents =
+            updatedContents.slice(0, postInstallClosingIndex + 1) +
+                snippet +
+                updatedContents.slice(postInstallClosingIndex + 1);
+    }
+    const insertAt = prepareIndex + PREPARE_REACT_NATIVE_ANCHOR.length;
+    const indent = indentationAt(updatedContents, prepareIndex);
+    const configurationSnippet = enabled
+        ? [
+            '',
+            '',
+            `${indent}${FREERASP_SPM_ACTIVATION_TAG}`,
+            `${indent}ENV['FREERASP_USE_SPM'] = '1' unless ENV['FREERASP_USE_SPM'] == '0'`,
+        ]
+        : [
+            '',
+            '',
+            `${indent}${FREERASP_SPM_DISABLED_TAG}`,
+            `${indent}ENV['FREERASP_USE_SPM'] = '0'`,
+        ];
+    updatedContents =
+        updatedContents.slice(0, insertAt) +
+            configurationSnippet.join(newline) +
+            updatedContents.slice(insertAt);
+    return {
+        contents: updatedContents,
+        changed: updatedContents !== contents,
+        missingAnchors: [],
+    };
+};
+exports.default = mutatePodfileForFreeraspSpm;

package/plugin/build/iosSpmProperties.d.ts

@@ -0,0 +1,2 @@
+declare const configureIosSpmProperties: (properties: Record<string, string>, spmEnabled: boolean) => Record<string, string>;
+export default configureIosSpmProperties;

package/plugin/build/iosSpmProperties.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const FRAMEWORKS_PROPERTY = 'ios.useFrameworks';
+const MANAGED_PROPERTY = 'freerasp.iosUseFrameworks';
+const PREVIOUS_VALUE_PROPERTY = 'freerasp.previousIosUseFrameworks';
+const UNSET_VALUE = '__freerasp_unset__';
+const configureIosSpmProperties = (properties, spmEnabled) => {
+    if (spmEnabled) {
+        if (properties[MANAGED_PROPERTY] !== 'true') {
+            properties[PREVIOUS_VALUE_PROPERTY] =
+                properties[FRAMEWORKS_PROPERTY] ?? UNSET_VALUE;
+        }
+        properties[FRAMEWORKS_PROPERTY] = 'dynamic';
+        properties[MANAGED_PROPERTY] = 'true';
+    }
+    else if (properties[MANAGED_PROPERTY] === 'true') {
+        const previousValue = properties[PREVIOUS_VALUE_PROPERTY];
+        if (previousValue && previousValue !== UNSET_VALUE) {
+            properties[FRAMEWORKS_PROPERTY] = previousValue;
+        }
+        else {
+            delete properties[FRAMEWORKS_PROPERTY];
+        }
+        delete properties[MANAGED_PROPERTY];
+        delete properties[PREVIOUS_VALUE_PROPERTY];
+    }
+    return properties;
+};
+exports.default = configureIosSpmProperties;

package/plugin/build/pluginConfig.d.ts

@@ -2,12 +2,20 @@
  * Interface representing base build properties configuration.
  */
 export interface PluginConfigType {
+    ios?: PluginConfigTypeIos;
     /**
      * Interface representing available configuration for Android native build properties.
      * @platform android
      */
     android?: PluginConfigTypeAndroid;
 }
+/** @platform ios */
+export interface PluginConfigTypeIos {
+    /**
+     * Use Swift Package Manager to deliver TalsecRuntime. Defaults to `true`.
+     */
+    useSpm?: boolean;
+}
 /**
  * Interface representing available configuration for Android native build properties.
  * @platform android

package/plugin/tests/iosSpm.test.js

@@ -0,0 +1,126 @@
+/* eslint-env node */
+
+const assert = require('assert').strict;
+const mutatePodfileForFreeraspSpm = require('../build/iosSpm').default;
+const configureIosSpmProperties = require('../build/iosSpmProperties').default;
+
+const FREERASP_SPM_ACTIVATION_TAG =
+  '# @generated freerasp-react-native (SPM activation)';
+const FREERASP_SPM_DISABLED_TAG =
+  '# @generated freerasp-react-native (SPM disabled)';
+const FREERASP_SPM_EMBED_TAG = '# @generated freerasp-react-native (SPM embed)';
+
+const podfile = `prepare_react_native_project!
+
+target 'Example' do
+  post_install do |installer|
+    react_native_post_install(
+      installer,
+      config[:reactNativePath],
+      :mac_catalyst_enabled => nested_option(enabled: false),
+      :quoted_value => "parentheses do not count: ())"
+    )
+  end
+end
+`;
+
+const mutation = mutatePodfileForFreeraspSpm(podfile);
+assert.equal(mutation.changed, true);
+assert.deepEqual(mutation.missingAnchors, []);
+
+const activationIndex = mutation.contents.indexOf(FREERASP_SPM_ACTIVATION_TAG);
+const targetIndex = mutation.contents.indexOf("target 'Example'");
+assert(
+  activationIndex > mutation.contents.indexOf('prepare_react_native_project!')
+);
+assert(activationIndex < targetIndex);
+assert(
+  mutation.contents.includes(
+    "ENV['FREERASP_USE_SPM'] = '1' unless ENV['FREERASP_USE_SPM'] == '0'"
+  )
+);
+
+const postInstallCloseIndex = mutation.contents.indexOf('\n    )');
+const embedIndex = mutation.contents.indexOf(FREERASP_SPM_EMBED_TAG);
+const postInstallEndIndex = mutation.contents.indexOf('\n  end', embedIndex);
+assert(embedIndex > postInstallCloseIndex);
+assert(embedIndex < postInstallEndIndex);
+
+const secondMutation = mutatePodfileForFreeraspSpm(mutation.contents);
+assert.equal(secondMutation.changed, false);
+assert.equal(secondMutation.contents, mutation.contents);
+
+const disabledMutation = mutatePodfileForFreeraspSpm(mutation.contents, false);
+assert.equal(disabledMutation.changed, true);
+assert(disabledMutation.contents.includes(FREERASP_SPM_DISABLED_TAG));
+assert(disabledMutation.contents.includes("ENV['FREERASP_USE_SPM'] = '0'"));
+assert.equal(
+  disabledMutation.contents.includes(FREERASP_SPM_ACTIVATION_TAG),
+  false
+);
+assert.equal(disabledMutation.contents.includes(FREERASP_SPM_EMBED_TAG), false);
+
+const secondDisabledMutation = mutatePodfileForFreeraspSpm(
+  disabledMutation.contents,
+  false
+);
+assert.equal(secondDisabledMutation.changed, false);
+assert.equal(secondDisabledMutation.contents, disabledMutation.contents);
+
+const reenabledMutation = mutatePodfileForFreeraspSpm(
+  disabledMutation.contents,
+  true
+);
+assert.equal(reenabledMutation.changed, true);
+assert(reenabledMutation.contents.includes(FREERASP_SPM_ACTIVATION_TAG));
+assert(reenabledMutation.contents.includes(FREERASP_SPM_EMBED_TAG));
+assert.equal(
+  reenabledMutation.contents.includes(FREERASP_SPM_DISABLED_TAG),
+  false
+);
+
+const missingAnchors = mutatePodfileForFreeraspSpm(
+  'target "Example" do\nend\n'
+);
+assert.equal(missingAnchors.changed, false);
+assert.equal(missingAnchors.contents, 'target "Example" do\nend\n');
+assert.deepEqual(missingAnchors.missingAnchors, [
+  'prepare_react_native_project!',
+  'react_native_post_install(',
+]);
+
+const windowsMutation = mutatePodfileForFreeraspSpm(
+  podfile.replace(/\n/g, '\r\n')
+);
+assert.equal(windowsMutation.changed, true);
+assert.equal(
+  windowsMutation.contents.replace(/\r\n/g, '').includes('\n'),
+  false
+);
+
+const propertiesWithoutFrameworks = {};
+configureIosSpmProperties(propertiesWithoutFrameworks, true);
+assert.equal(propertiesWithoutFrameworks['ios.useFrameworks'], 'dynamic');
+configureIosSpmProperties(propertiesWithoutFrameworks, false);
+assert.deepEqual(propertiesWithoutFrameworks, {});
+
+const propertiesWithStaticFrameworks = {
+  'ios.useFrameworks': 'static',
+};
+configureIosSpmProperties(propertiesWithStaticFrameworks, true);
+configureIosSpmProperties(propertiesWithStaticFrameworks, true);
+assert.equal(propertiesWithStaticFrameworks['ios.useFrameworks'], 'dynamic');
+configureIosSpmProperties(propertiesWithStaticFrameworks, false);
+assert.deepEqual(propertiesWithStaticFrameworks, {
+  'ios.useFrameworks': 'static',
+});
+
+const unownedProperties = {
+  'ios.useFrameworks': 'dynamic',
+};
+configureIosSpmProperties(unownedProperties, false);
+assert.deepEqual(unownedProperties, {
+  'ios.useFrameworks': 'dynamic',
+});
+
+console.log('Expo iOS SPM tests passed.');

package/src/api/methods/native.ts

@@ -1,9 +1,10 @@
 import { Platform } from 'react-native';
 import { FreeraspReactNative } from '../nativeModules';
 import type { TalsecConfig } from '../../types/types';
+import { withDefaults } from '../../utils/config';
 
 export const talsecStart = async (options: TalsecConfig): Promise<string> => {
-  return FreeraspReactNative.talsecStart(options);
+  return FreeraspReactNative.talsecStart(withDefaults(options));
 };
 
 export const addToWhitelist = async (packageName: string): Promise<boolean> => {

package/src/types/types.ts

@@ -6,11 +6,34 @@ export type TalsecConfig = {
   killOnBypass?: boolean;
 };
 
+export type ScopeType =
+  | 'SIDELOADED_ONLY'
+  | 'SIDELOADED_AND_SYSTEM_EXCLUDE_OEM'
+  | 'SIDELOADED_AND_OEM'
+  | 'SIDELOADED_AND_SYSTEM_AND_OEM'
+  | 'ALL';
+
+export type ReasonMode = 'ALL' | 'HIGHEST_CONFIDENCE';
+
+export type ScanScope = {
+  scopeType: ScopeType;
+  trustedInstallSources?: string[];
+};
+
+export type SuspiciousAppDetectionConfig = {
+  packageNames?: string[];
+  hashes?: string[];
+  requestedPermissions?: string[][];
+  grantedPermissions?: string[][];
+  scanScope: ScanScope;
+  reasonMode: ReasonMode;
+};
+
 export type TalsecAndroidConfig = {
   packageName: string;
   certificateHashes: string[];
   supportedAlternativeStores?: string[];
-  malwareConfig?: TalsecMalwareConfig;
+  suspiciousAppDetectionConfig?: SuspiciousAppDetectionConfig;
 };
 
 export type TalsecIosConfig = {
@@ -18,16 +41,9 @@ export type TalsecIosConfig = {
   appTeamId: string;
 };
 
-export type TalsecMalwareConfig = {
-  blacklistedHashes?: string[];
-  blacklistedPackageNames?: string[];
-  suspiciousPermissions?: string[][];
-  whitelistedInstallationSources?: string[];
-};
-
 export type SuspiciousAppInfo = {
   packageInfo: PackageInfo;
-  reason: string;
+  reasons: string[];
   permissions?: string[];
 };
 

package/src/utils/config.ts

@@ -0,0 +1,42 @@
+import type {
+  ReasonMode,
+  ScanScope,
+  SuspiciousAppDetectionConfig,
+  TalsecAndroidConfig,
+  TalsecConfig,
+} from '../types/types';
+
+const DEFAULT_SCAN_SCOPE: ScanScope = {
+  scopeType: 'SIDELOADED_ONLY',
+};
+
+const DEFAULT_REASON_MODE: ReasonMode = 'HIGHEST_CONFIDENCE';
+
+const withDetectionDefaults = (
+  config: SuspiciousAppDetectionConfig
+): SuspiciousAppDetectionConfig => ({
+  ...config,
+  scanScope: config.scanScope ?? DEFAULT_SCAN_SCOPE,
+  reasonMode: config.reasonMode ?? DEFAULT_REASON_MODE,
+});
+
+export const normalizeAndroidConfig = (
+  androidConfig: TalsecAndroidConfig
+): TalsecAndroidConfig => {
+  if (!androidConfig.suspiciousAppDetectionConfig) {
+    return androidConfig;
+  }
+  return {
+    ...androidConfig,
+    suspiciousAppDetectionConfig: withDetectionDefaults(
+      androidConfig.suspiciousAppDetectionConfig
+    ),
+  };
+};
+
+export const withDefaults = (options: TalsecConfig): TalsecConfig => ({
+  ...options,
+  androidConfig: options.androidConfig
+    ? normalizeAndroidConfig(options.androidConfig)
+    : undefined,
+});

package/src/utils/malware.ts

@@ -18,7 +18,7 @@ export const toSuspiciousAppInfo = (base64Value: string): SuspiciousAppInfo => {
   const packageInfo = data.packageInfo as PackageInfo;
   return {
     packageInfo,
-    reason: data.reason,
+    reasons: data.reasons,
     permissions: data.permissions,
   } as SuspiciousAppInfo;
 };