# Vulnerability: JSON Injection in tokenURI Functions

**Overview of the Vulnerability**

The core issue with JSON injection in the `tokenURI` function arises when user input is not properly sanitized or encoded before it is incorporated into the token's metadata. This can allow an attacker to manipulate the JSON structure by injecting characters (like `"` or `\`) that alter the intended structure of the JSON.

In a typical NFT metadata setup, the `tokenURI` function may return something like:

```json
{
  "name": "Bio #1",
  "description": "Test",
  "image": "data:image/svg+xml;base64,..."
}
```

If the user input for a field like "description" or "name" contains special characters and is not properly handled, the attacker can inject malicious JSON elements. For example:

Input:

```bash
Test", "name": "Bio #999999999
```

Resulting manipulated JSON:

```json
{
  "name": "Bio #1",
  "description": "Test",
  "name": "Bio #999999999",
  "image": "data:image/svg+xml;base64,..."
}
```

This results in a JSON structure that contains an additional, unintended `name` field, which can be used for various types of attacks, including data manipulation, impersonation, and XSS if the data is rendered in a web application without proper escaping.

**Potential Attack Vectors**

The impact of JSON injection in the `tokenURI` function depends on how the protocol and external applications use the metadata. Some possible attack vectors include:

1. **Impersonation of Other NFTs**: An attacker could craft an NFT that appears identical to another by injecting a duplicate `name` field with a different value, effectively mimicking the properties of a legitimate NFT.
2. **Image Manipulation**: By injecting or altering the image field, the attacker could point the image to an external URL, or change the visual representation of the token entirely.
3. **Cross-Site Scripting (XSS) Attacks**: If the manipulated JSON is passed into a frontend application that does not sanitize or escape user input, it could lead to a cross-site scripting attack. This could allow an attacker to execute arbitrary JavaScript in the context of the user's browser, compromising sensitive data or the application itself.
4. **Altered Metadata**: The attacker could manipulate other metadata fields, such as adding fake attributes or altering the token’s description, to mislead users or third-party services that rely on the token metadata.

**Proof of Concept**

In practice, this vulnerability might look like:

* A user submits the bio data:

  ```bash
  Test", "name": "Bio #999999999
  ```
* The `tokenURI` function generates the following JSON:

  ```json
  {
    "name": "Bio #1",
    "description": "Test",
    "name": "Bio #999999999",
    "image": "data:image/svg+xml;base64,..."
  }
  ```
* The attacker has now successfully injected a new name field, mimicking another NFT or altering the expected structure.

**Consequences**

* **Confusion in Ownership**: Users may be tricked into believing they own an NFT they do not, leading to possible scams or fraud.
* **External Image Manipulation**: The attacker could point the image URL to malicious content or an external resource, undermining the integrity of the NFT.
* **Cross-Site Scripting**: Malicious code injected through XSS could compromise the security of web applications displaying the NFT metadata.

#### Mitigation Strategies

To prevent JSON injection vulnerabilities, developers should adopt the following best practices:

1. **Sanitize User Input**: Always sanitize input provided by users before incorporating it into JSON metadata. This includes escaping special characters that could alter the structure of the JSON data, such as quotes (`"`) or backslashes (`\`).
2. **Properly Encode Data**: Encode user data when embedding it in the `tokenURI` response to ensure that it does not introduce malformed JSON. Libraries or encoding utilities can be used to automatically escape special characters and prevent injection attacks.
3. **Strict JSON Schema Validation**: Implement validation to ensure that the resulting JSON conforms to a strict schema. By verifying that the output matches expected fields and data types, you can prevent unexpected values from being injected into the JSON.
4. **Front-End Security Practices**: Ensure that any frontend applications interacting with the NFT metadata properly escape and sanitize user-generated content. This can help prevent XSS attacks from occurring when the data is rendered in a browser.
5. **Audits and Testing**: Regularly audit the smart contracts and associated infrastructure to identify any potential injection points. Automated testing tools can also be used to simulate attack scenarios and verify that the system is resilient against such vulnerabilities.

#### Conclusion

JSON injection in `tokenURI` functions is a serious vulnerability that can undermine the integrity of NFTs and related metadata. By manipulating the JSON structure, attackers can impersonate other tokens, alter critical data, or trigger security vulnerabilities in external applications. Developers must take care to properly sanitize and encode all user-generated input to protect against these attacks and maintain the security and trustworthiness of their protocol.<br>
