Exploring Cross-Site Scripting with React and Tauri
Tags: tauri, react, security, xss
Published: 2023-07-13 08:50:34

## What is Cross-Site Scripting?

Cross-Site Scripting, or in short XSS, occurs when an attacker can control and execute JavaScript in the context of a website. Facilitating JavaScript on websites is very common and there are multiple methods for attackers to execute their own code instead of the intended legitimate JavaScript code of the website. There are several types of XSS attacks: stored, reflected, and self. Let’s dig into these deeper.

One type is a stored XSS. For instance, a website may load content from various sources, such as files, remote sources, or database entries, and construct the website’s [DOM](https://en.wikipedia.org/wiki/Document_Object_Model), or just parts of it, and execute it in the visitor’s context. An attacker has the ability to modify these sources to trick the website into loading their own JavaScript from this stored content.

Another common type of XSS is reflected, where an attacker controls an URL parameter like a search query in a search engine. By visiting this link containing the malicious parameter values the code is executed in the context of the website.

A third type of XSS is one that does not rely on URL parameters or remote sources; instead, attackers trick users into copy-pasting encoded input into a website’s input forms, causing the script to execute. This is called self XSS, because only you are able to insert and execute the malicious content. Understanding these three common types of XSS helps developers protect their applications against potential attacks.

## How Does React Prevent This?

React’s approach to fix XSS vulnerabilities is to prevent it by design. This is similar to how Rust addresses memory safety issues and prevents a complete class of bugs by default.

In React, data passed is not immediately rendered in the website context. Instead, it is first prepared in a Virtual Document Object Model (DOM), and only the dynamic content is attached to elements like text nodes. This makes it nearly impossible to execute JavaScript that is not already present when building the Virtual DOM. With this design the only way script execution could occur is if a malicious JavaScript file is loaded during the application build, which is not a typical XSS attack method. React’s default safety features, prevent XSS attacks. However, developers may still need to directly access or manipulate the DOM, which can introduce vulnerabilities if not handled carefully.

## How Can You Still Get XSS in React?

In React, developers typically control nodes and their content within the Virtual DOM tree using the framework, but occasionally they may need to manipulate it directly. There are several methods for doing this, but some can introduce vulnerabilities. One such method is [dangerouslySetInnerHTML](https://react.dev/reference/react-dom/components/common#dangerously-setting-the-inner-html), which, as the name implies, is dangerous if not used carefully. Developers should only pass any input into this function when they can ensure it is trusted HTML content, as it’s directly rendered and bypassing the Virtual DOM.

Similarly, using innerHTML can also lead to XSS vulnerabilities. Additionally, if a src attribute is set to a user-controlled input, it can result in script execution. For example, if an attacker’s URL containing JavaScript is set as the source, it can lead to an XSS attack. Another less common way is if the application exposes the ability to manipulate or create a React template, which is then executed.

To mitigate these risks, developers must exercise caution when manipulating the DOM directly in React applications. If these features are not used, it’s highly likely that an application is not vulnerable to XSS, which is a significant advantage in comparison to websites not facilitating a framework like React.

## XSS Vulnerabilities Impact in the Browser vs Tauri Applications

XSS attacks in websites rendered in a web browser allow attackers to execute JavaScript code in the website context, which permits them to emulate or modify the website’s actions. For example, if an attacker compromises Google, they could steal a user’s Google cookie, monitor their search queries, and track their browsing activity. However, further actions are limited by browser [sandboxes](https://chromium.googlesource.com/chromium/src/+/refs/heads/main/docs/design/sandbox.md), which act as a security measure. Browser vendors invest heavily in sandboxing technology and maintain large security teams to ensure the safety of their users. As a result, the potential damage caused by XSS attacks in browsers is restricted by these sandboxes, which helps to protect users from more harmful consequences.

[Tauri](https://tauri.app/) applications provide similar built-in [sandboxing](https://tauri.app/v1/references/architecture/inter-process-communication/) capabilities. These are mostly secure by default and can be fine-grained [configured](https://tauri.app/v1/api/config/#allowlistconfig) by the developer of the application. However, Tauri developers may not have the same level of security expertise as large, well-funded teams that develop in browsers using sandboxes. As a result, Tauri apps are more likely to expose features which can be abused in XSS based attacks, which can lead to more significant consequences than in-browser attacks. In the worst-case scenario, an attacker could gain remote code execution privileges on a user’s computer, which is a highly undesirable outcome.

Therefore, understanding and preventing XSS vulnerabilities in Tauri applications is crucial for developers to ensure the security of their users. As prevention is only one layer, it is necessary to configure the [Content-Security-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) to limit the impact of such an attack. Another layer of defense is the [Tauri configuration](https://tauri.app/v1/api/config/), which allows to limit system access by using scopes for the enabled endpoints. If all of these layers are implemented correctly the impact of XSS in a Tauri application is greatly reduced and should contain the attack to the access level of the application.

## Summary

Insights on Cross-Site Scripting (XSS) in React.js provides a valuable understanding of how the popular front-end framework addresses potential vulnerabilities. React’s approach to XSS defense makes it more difficult for attackers to execute malicious JavaScript in a website’s context. It’s crucial to recognize the risks of directly manipulating the DOM in React applications, as methods like dangerouslySetInnerHTML and innerHTML can introduce vulnerabilities if not used carefully. Additionally, it’s worth noting that XSS attacks on Tauri applications can be more impactful due to their possibly increased system access, making it essential for developers to thoroughly understand XSS prevention and impact reduction techniques. If you have any further questions, comments, or remarks, feel free to reach out to us at [CrabNebula Consulting](https://crabnebula.dev/consulting).

---

_Author: Tillmann Weidinger, Director of Security_