Skip to content

Latest commit

 

History

History
35 lines (30 loc) · 4.01 KB

threat-modeling.md

File metadata and controls

35 lines (30 loc) · 4.01 KB

Threat Model Analysis for yewstack/yew

Threat: Wasm Module Tampering (Post-Deployment)

  • Description: An attacker gains access to the web server hosting the Yew application and modifies the compiled .wasm file. They could inject malicious code to steal user data, redirect users to phishing sites, bypass client-side validation, or perform other harmful actions. The attacker leverages the fact that the browser executes the Wasm code, and this is directly related to Yew because Yew compiles to Wasm.
    • Impact:
      • Data breaches (user credentials, personal information).
      • Compromised user accounts.
      • Malware distribution.
      • Reputational damage.
      • Loss of user trust.
    • Affected Yew Component: The entire compiled .wasm module. This is the core of the Yew application.
    • Risk Severity: Critical
    • Mitigation Strategies:
      • Subresource Integrity (SRI): Use SRI tags in the HTML <script> tag that loads the Wasm. Generate a cryptographic hash of the .wasm file and include it in the integrity attribute. The browser will verify the hash before executing the code. This is the primary defense.
      • Content Security Policy (CSP): Use a strict CSP to restrict the sources from which Wasm can be loaded (e.g., script-src 'self' https://cdn.example.com;). Also, restrict the actions the Wasm can perform (e.g., connect-src 'self' https://api.example.com;). This provides defense-in-depth.
      • Server-Side File Integrity Monitoring: Implement server-side monitoring to detect unauthorized changes to the .wasm file. This can trigger alerts and automated responses.
      • Secure Deployment Practices: Use secure deployment pipelines (e.g., CI/CD) with strong access controls and auditing to prevent unauthorized modifications during the deployment process.

Threat: Component State Manipulation (via External JS)

  • Description: An attacker manages to inject malicious JavaScript code into the page (e.g., through a separate XSS vulnerability or a compromised third-party library). This injected code then attempts to interact with and modify the internal state of Yew components directly, bypassing Yew's intended state management mechanisms. While the entry point is a general web vulnerability (XSS), the target and the potential impact are specific to how Yew manages state. This is less likely than direct DOM manipulation in a non-framework application, but the attacker could potentially disrupt Yew's virtual DOM diffing or alter component behavior in unexpected ways.
    • Impact:
      • Unpredictable application behavior.
      • Data corruption.
      • Bypass of security checks.
      • Potential for further exploitation.
    • Affected Yew Component: Any Component implementation, specifically its internal state. The attacker would likely target the Scope or the underlying data structures used to manage the component's state. This is Yew-specific because it targets Yew's component model.
    • Risk Severity: High
    • Mitigation Strategies:
      • Prevent JavaScript Injection: The primary mitigation is to prevent JavaScript injection vulnerabilities (XSS) in the first place. This is a general web security best practice, but it's crucial here.
      • Content Security Policy (CSP): Use a strict CSP to limit the execution of inline scripts and restrict the sources from which scripts can be loaded.
      • Robust State Management: Use a robust state management solution (e.g., Redux, Yew's context API, or a custom solution) that provides additional layers of protection against unauthorized state changes. Consider using immutable data structures.
      • Input Validation: Thoroughly validate and sanitize all user inputs to prevent malicious data from being stored in the component state.