Skip to content

Latest commit

 

History

History
42 lines (35 loc) · 4.5 KB

attack-surface.md

File metadata and controls

42 lines (35 loc) · 4.5 KB

Attack Surface Analysis for facebook/react-native

Attack Surface: Bridge Communication Exploitation

  • Description: Attacks targeting the communication channel (the "bridge") between the JavaScript and native layers. This is the core mechanism for React Native operation.
  • How React Native Contributes: React Native's fundamental architecture depends on this bridge for all JavaScript-to-native communication, making it a central and unavoidable attack vector.
  • Example: An attacker intercepts and modifies a message containing a serialized authentication token sent across the bridge, gaining unauthorized access.
  • Impact: Data breaches, unauthorized access, application manipulation, denial of service.
  • Risk Severity: Critical to High (depending on the data and exposed native functionality).
  • Mitigation Strategies:
    • Strict Input Validation (Both Sides): Rigorous validation and sanitization of all data crossing the bridge, implemented on both the JavaScript and native sides. Use schema validation.
    • Message Integrity: Employ cryptographic techniques (e.g., HMAC) to ensure message integrity, preventing tampering, especially for sensitive operations.
    • Minimize Bridge Traffic: Reduce the volume and frequency of bridge communication.
    • Avoid Sensitive Data on Bridge: Never transmit sensitive data (passwords, API keys) directly. Use secure storage and pass identifiers instead.
    • Rate Limiting: Implement rate limiting to prevent denial-of-service attacks targeting the bridge.

Attack Surface: Native Module Vulnerabilities

  • Description: Exploitation of vulnerabilities within native code modules (Objective-C/Swift/Java/Kotlin) accessed via the React Native bridge.
  • How React Native Contributes: React Native enables the creation and integration of custom native modules, directly exposing the application to potential native code vulnerabilities through the bridge.
  • Example: A native module handling cryptographic operations has a memory corruption bug. An attacker sends crafted data through the bridge to trigger the bug and gain code execution.
  • Impact: Code execution, privilege escalation, data breaches, application crashes.
  • Risk Severity: Critical to High (depending on the native module's privileges and functionality).
  • Mitigation Strategies:
    • Secure Native Code Practices: Rigorously apply secure coding practices in the native code. Prioritize memory-safe languages (Swift, Kotlin) when possible.
    • Native-Side Input Validation: Validate all input received from JavaScript within the native module, even if JavaScript-side validation exists (defense in depth).
    • Principle of Least Privilege: Ensure native modules have only the absolute minimum necessary permissions.
    • Auditing and Penetration Testing: Conduct regular security audits and penetration testing specifically targeting native modules.
    • Vetted Third-Party Modules: Thoroughly vet and review the source code of any third-party native modules before integration.

Attack Surface: Debug Mode Enabled in Production

  • Description: Releasing the application with React Native's debugging features enabled, leading to information disclosure or facilitating reverse engineering.
  • How React Native Contributes: React Native provides built-in debugging tools (remote debugging, performance monitoring, etc.) that, if not explicitly disabled, can expose sensitive internal details.
  • Example: An application is released with remote debugging enabled. An attacker connects to the running application and inspects its memory, potentially extracting API keys or other sensitive data.
  • Impact: Information disclosure, easier reverse engineering, potential for remote code execution (if remote debugging is fully enabled and exploitable).
  • Risk Severity: High to Critical.
  • Mitigation Strategies:
    • Explicitly Disable Debug Mode: Ensure debug mode is explicitly disabled in release builds. This is a crucial step.
    • Automated Build Processes: Configure build processes to automatically disable debug mode for production releases.
    • Build Configuration Review: Thoroughly review and double-check all build settings before releasing the application to ensure debug mode is off.