deardaniel/secdata-raw huggingface dataset:
GitHub Security Advisory: GHSA-p27m-hp98-6637
Package: Magick.NET-Q16-HDRI-x86 (NUGET)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-674: Uncontrolled Recursion
Vulnerable versions: < 14.10.1
Patched in: 14.10.1

Summary: ImageMagick's failure to limit the depth of SVG file reads caused a DoS attack

Details:
### Summary

Using Magick to read a malicious SVG file resulted in a DoS attack.

### Details

bt obtained using gdb:

```
#4 0x[PII_REDACTED]794c9c in ResizeMagickMemory (memory=0x7fffee203800, size=391344) at MagickCore/memory.c:1443
#5 0x[PII_REDACTED]794e5a in ResizeQuantumMemory (memory=0x7fffee203800, count=48918, quantum=8) 
at MagickCore/memory.c:1508
#6 0x[PII_REDACTED]acc8ed in SVGStartElement (context=0x[PII_REDACTED]80, name=0x[PII_REDACTED]e3 "g", attributes=0x0) 
at coders/svg.c:1254
#7 0x00007ffff6799b1c in xmlParseStartTag () at /lib/x86_64-linux-gnu/libxml2.so.2
#8 0x00007ffff68c7bb8 in () at /lib/x86_64-linux-gnu/libxml2.so.2
#9 0x00007ffff67a03f1 in xmlParseChunk () at /lib/x86_64-linux-gnu/libxml2.so.2
```

This is related to the SVGStartElement and ResizeQuantumMemory functions.

### PoC

1. Generate an SVG file

2. Read this file using Magick:

```
./magick /data/ylwang/Tools/LargeScan/targets/ImageMagick/test++/1.svg null
```

3. Causes a DoS Attack

My server has a large amount of memory, causing a stack overflow to take a long time. I'll use the Windows release version as an example:

``` 
PS C:\Program Files\ImageMagick-7.1.2-Q8> .\magick.exe -ping 1.svg null:
PS C:\Program Files\ImageMagick-7.1.2-Q8> echo $LASTEXITCODE
[PII_REDACTED]
```

The error code [PII_REDACTED] indicates a crash due to a stack overflow.

### Impact

This is a DoS vulnerability and all applications using Magick to parse SVG files are affected.
GitHub Security Advisory: GHSA-p27m-hp98-6637
Package: Magick.NET-Q16-HDRI-AnyCPU (NUGET)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-674: Uncontrolled Recursion
Vulnerable versions: < 14.10.1
Patched in: 14.10.1

Summary: ImageMagick's failure to limit the depth of SVG file reads caused a DoS attack

Details:
### Summary

Using Magick to read a malicious SVG file resulted in a DoS attack.

### Details

bt obtained using gdb:

```
#4 0x[PII_REDACTED]794c9c in ResizeMagickMemory (memory=0x7fffee203800, size=391344) at MagickCore/memory.c:1443
#5 0x[PII_REDACTED]794e5a in ResizeQuantumMemory (memory=0x7fffee203800, count=48918, quantum=8) 
at MagickCore/memory.c:1508
#6 0x[PII_REDACTED]acc8ed in SVGStartElement (context=0x[PII_REDACTED]80, name=0x[PII_REDACTED]e3 "g", attributes=0x0) 
at coders/svg.c:1254
#7 0x00007ffff6799b1c in xmlParseStartTag () at /lib/x86_64-linux-gnu/libxml2.so.2
#8 0x00007ffff68c7bb8 in () at /lib/x86_64-linux-gnu/libxml2.so.2
#9 0x00007ffff67a03f1 in xmlParseChunk () at /lib/x86_64-linux-gnu/libxml2.so.2
```

This is related to the SVGStartElement and ResizeQuantumMemory functions.

### PoC

1. Generate an SVG file

2. Read this file using Magick:

```
./magick /data/ylwang/Tools/LargeScan/targets/ImageMagick/test++/1.svg null
```

3. Causes a DoS Attack

My server has a large amount of memory, causing a stack overflow to take a long time. I'll use the Windows release version as an example:

``` 
PS C:\Program Files\ImageMagick-7.1.2-Q8> .\magick.exe -ping 1.svg null:
PS C:\Program Files\ImageMagick-7.1.2-Q8> echo $LASTEXITCODE
[PII_REDACTED]
```

The error code [PII_REDACTED] indicates a crash due to a stack overflow.

### Impact

This is a DoS vulnerability and all applications using Magick to parse SVG files are affected.
GitHub Security Advisory: GHSA-p27m-hp98-6637
Package: Magick.NET-Q16-AnyCPU (NUGET)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-674: Uncontrolled Recursion
Vulnerable versions: < 14.10.1
Patched in: 14.10.1

Summary: ImageMagick's failure to limit the depth of SVG file reads caused a DoS attack

Details:
### Summary

Using Magick to read a malicious SVG file resulted in a DoS attack.

### Details

bt obtained using gdb:

```
#4 0x[PII_REDACTED]794c9c in ResizeMagickMemory (memory=0x7fffee203800, size=391344) at MagickCore/memory.c:1443
#5 0x[PII_REDACTED]794e5a in ResizeQuantumMemory (memory=0x7fffee203800, count=48918, quantum=8) 
at MagickCore/memory.c:1508
#6 0x[PII_REDACTED]acc8ed in SVGStartElement (context=0x[PII_REDACTED]80, name=0x[PII_REDACTED]e3 "g", attributes=0x0) 
at coders/svg.c:1254
#7 0x00007ffff6799b1c in xmlParseStartTag () at /lib/x86_64-linux-gnu/libxml2.so.2
#8 0x00007ffff68c7bb8 in () at /lib/x86_64-linux-gnu/libxml2.so.2
#9 0x00007ffff67a03f1 in xmlParseChunk () at /lib/x86_64-linux-gnu/libxml2.so.2
```

This is related to the SVGStartElement and ResizeQuantumMemory functions.

### PoC

1. Generate an SVG file

2. Read this file using Magick:

```
./magick /data/ylwang/Tools/LargeScan/targets/ImageMagick/test++/1.svg null
```

3. Causes a DoS Attack

My server has a large amount of memory, causing a stack overflow to take a long time. I'll use the Windows release version as an example:

``` 
PS C:\Program Files\ImageMagick-7.1.2-Q8> .\magick.exe -ping 1.svg null:
PS C:\Program Files\ImageMagick-7.1.2-Q8> echo $LASTEXITCODE
[PII_REDACTED]
```

The error code [PII_REDACTED] indicates a crash due to a stack overflow.

### Impact

This is a DoS vulnerability and all applications using Magick to parse SVG files are affected.
GitHub Security Advisory: GHSA-83fp-hh9m-c2jq
Package: Piranha (NUGET)
Severity: LOW (CVSS 0.0)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: <= 12.0.0
Patched in: unpatched

Summary: Piranha has stored cross-site scripting (XSS) vulnerability

Details:
A stored cross-site scripting (XSS) vulnerability in the Media module of Piranha CMS v12.1 allows attackers to execute arbitrary web scripts or HTML via injecting a crafted payload into the Name field.
GitHub Security Advisory: GHSA-fw48-7qf9-455m
Package: Piranha (NUGET)
Severity: LOW (CVSS 0.0)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: <= 12.0.0
Patched in: unpatched

Summary: Piranha has stored cross-site scripting (XSS) vulnerability

Details:
A stored cross-site scripting (XSS) vulnerability in the Page Settings module of Piranha CMS v12.1 allows attackers to execute arbitrary web scripts or HTML via injecting a crafted payload into the Excerpt field.
GitHub Security Advisory: GHSA-54mj-vcvj-q3v5
Package: Umbraco.Cms (NUGET)
Severity: MODERATE (CVSS 10.0)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting'), CWE-434: Unrestricted Upload of File with Dangerous Type
Vulnerable versions: <= 16.3.3
Patched in: unpatched

Summary: Umbraco CMS has an arbitrary file upload vulnerability

Details:
An arbitrary file upload vulnerability in Umbraco CMS v16.3.3 allows attackers to execute arbitrary code via uploading a crafted PDF file. While Umbraco provides [hooks to perform file validation](https://docs.umbraco.com/umbraco-cms/reference/security/serverside-file-validation), it does not do implement filtering by default. Users are expected to implement their own validation.

Note: This vulnerability is [disputed by Ubraco](https://github.com/github/advisory-database/pull/6633).
GitHub Security Advisory: GHSA-4v42-65r3-3gjx
Package: Amazon.Extensions.S3.Encryption (NUGET)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-327: Use of a Broken or Risky Cryptographic Algorithm
Vulnerable versions: < 3.2.0
Patched in: 3.2.0

Summary: Amazon S3 Encryption Client for .NET has a Key Commitment Issue

Details:
## Summary

S3 Encryption Client for .NET (S3EC) is an open-source client-side encryption library used to facilitate writing and reading encrypted records to S3.  

When the encrypted data key (EDK) is stored in an "Instruction File" instead of S3's metadata record, the EDK is exposed to an "Invisible Salamanders" attack  (https://eprint.iacr.org/2019/016), which could allow the EDK to be replaced with a new key. 



## Impact

### Background - Key Commitment

There is a cryptographic property whereby under certain conditions, a single ciphertext can be decrypted into 2 different plaintexts by using different encryption keys.  To address this issue, strong encryption schemes use what is known as "key commitment", a process by which an encrypted message can only be decrypted by one key; the key used to originally encrypt the message. 

In older versions of S3EC, when customers are also using a feature called "Instruction File" to store EDKs, key commitment is not implemented because multiple EDKs could be associated to an underlying encrypted message object.  For such customers an attack that leverages the lack of key commitment is possible.  A bad actor would need two things to leverage this issue: (i) the ability to create a separate, rogue, EDK that will also decrypt the underlying object to produce desired plaintext, and (ii) permission to upload a new instruction file to the S3 bucket to replace the existing instruction file placed there by the user using the S3C.  Any future attempt to decrypt the underlying encrypted message with the S3EC will unwittingly use the rogue EDK to produce a valid plaintext message.

Impacted versions: <= 3.1.0



## Patches

Amazon S3 Encryption Client is introducing the concept of "key commitment" to S3EC where the EDK is cryptographically bound to the ciphertext in order to address this issue.  In order to maintain compatibility for in-flight messages, the fix will be released in two versions.  A code-compatible minor version that can read messages with key-commitment but not write them, and a new major version that can both read and write messages with key-commitment.  For maximum safety customers are asked to upgrade to the latest major version: 4.0.0 or later.



## Workarounds

There are no workarounds, please upgrade to the suggested version of S3EC.

## References

If users have any questions or comments about this advisory, Amazon S3 Encryption Client asks that they contact AWS Security via the issue reporting page or directly via email to [aws-security@amazon.com](mailto:aws-security@amazon.com). Please do not create a public GitHub issue.
GitHub Security Advisory: GHSA-vfm5-cr22-jg3m
Package: Volo.Abp.Account.Web (NUGET)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-20: Improper Input Validation, CWE-601: URL Redirection to Untrusted Site ('Open Redirect')
Vulnerable versions: >= 5.1.0, < 10.0.0-rc.2
Patched in: 10.0.0-rc.2

Summary: ABP Account Module has an Open Redirect through Improper validation in its register function

Details:
An open redirect vulnerability exists in the Account module in Volosoft ABP Framework >= 5.1.0 and < 10.0.0-rc.2. Improper validation of the returnUrl parameter in the register function allows an attacker to redirect users to arbitrary external domains.
GitHub Security Advisory: GHSA-6hjr-v6g4-3fm8
Package: Magick.NET-Q8-x86 (NUGET)
Severity: HIGH (CVSS 7.5)
CWE: CWE-125: Out-of-bounds Read
Vulnerable versions: < 14.10.0
Patched in: 14.10.0

Summary: ImageMagick is vulnerable to an integer Overflow in TIM decoder leading to out of bounds read (32-bit only)

Details:
### Summary
The TIM (PSX TIM) image parser in ImageMagick contains a critical integer overflow vulnerability in the `ReadTIMImage` function (`coders/tim.c`). The code reads `width` and `height` (16-bit values) from the file header and calculates `image_size = 2 * width * height` without checking for overflow.
On 32-bit systems (or where `size_t` is 32-bit), this calculation can overflow if `width` and `height` are large (e.g., 65535), wrapping around to a small value. This results in a small heap allocation via `AcquireQuantumMemory` and later operations relying on the dimensions can trigger an out of bounds read.
### Vulnerable Code
File: `coders/tim.c`
```c
width=ReadBlobLSBShort(image);
height=ReadBlobLSBShort(image);
image_size=2*width*height;       // Line 234 - NO OVERFLOW CHECK!
```

### Impact
This vulnerability can lead to Arbitrary Memory Disclosure due to an out of bounds read on 32-bit systems.
GitHub Security Advisory: GHSA-6hjr-v6g4-3fm8
Package: Magick.NET-Q8-AnyCPU (NUGET)
Severity: HIGH (CVSS 7.5)
CWE: CWE-125: Out-of-bounds Read
Vulnerable versions: < 14.10.0
Patched in: 14.10.0

Summary: ImageMagick is vulnerable to an integer Overflow in TIM decoder leading to out of bounds read (32-bit only)

Details:
### Summary
The TIM (PSX TIM) image parser in ImageMagick contains a critical integer overflow vulnerability in the `ReadTIMImage` function (`coders/tim.c`). The code reads `width` and `height` (16-bit values) from the file header and calculates `image_size = 2 * width * height` without checking for overflow.
On 32-bit systems (or where `size_t` is 32-bit), this calculation can overflow if `width` and `height` are large (e.g., 65535), wrapping around to a small value. This results in a small heap allocation via `AcquireQuantumMemory` and later operations relying on the dimensions can trigger an out of bounds read.
### Vulnerable Code
File: `coders/tim.c`
```c
width=ReadBlobLSBShort(image);
height=ReadBlobLSBShort(image);
image_size=2*width*height;       // Line 234 - NO OVERFLOW CHECK!
```

### Impact
This vulnerability can lead to Arbitrary Memory Disclosure due to an out of bounds read on 32-bit systems.
GitHub Security Advisory: GHSA-6hjr-v6g4-3fm8
Package: Magick.NET-Q16-x86 (NUGET)
Severity: HIGH (CVSS 7.5)
CWE: CWE-125: Out-of-bounds Read
Vulnerable versions: < 14.10.0
Patched in: 14.10.0

Summary: ImageMagick is vulnerable to an integer Overflow in TIM decoder leading to out of bounds read (32-bit only)

Details:
### Summary
The TIM (PSX TIM) image parser in ImageMagick contains a critical integer overflow vulnerability in the `ReadTIMImage` function (`coders/tim.c`). The code reads `width` and `height` (16-bit values) from the file header and calculates `image_size = 2 * width * height` without checking for overflow.
On 32-bit systems (or where `size_t` is 32-bit), this calculation can overflow if `width` and `height` are large (e.g., 65535), wrapping around to a small value. This results in a small heap allocation via `AcquireQuantumMemory` and later operations relying on the dimensions can trigger an out of bounds read.
### Vulnerable Code
File: `coders/tim.c`
```c
width=ReadBlobLSBShort(image);
height=ReadBlobLSBShort(image);
image_size=2*width*height;       // Line 234 - NO OVERFLOW CHECK!
```

### Impact
This vulnerability can lead to Arbitrary Memory Disclosure due to an out of bounds read on 32-bit systems.
GitHub Security Advisory: GHSA-6hjr-v6g4-3fm8
Package: Magick.NET-Q16-HDRI-x86 (NUGET)
Severity: HIGH (CVSS 7.5)
CWE: CWE-125: Out-of-bounds Read
Vulnerable versions: < 14.10.0
Patched in: 14.10.0

Summary: ImageMagick is vulnerable to an integer Overflow in TIM decoder leading to out of bounds read (32-bit only)

Details:
### Summary
The TIM (PSX TIM) image parser in ImageMagick contains a critical integer overflow vulnerability in the `ReadTIMImage` function (`coders/tim.c`). The code reads `width` and `height` (16-bit values) from the file header and calculates `image_size = 2 * width * height` without checking for overflow.
On 32-bit systems (or where `size_t` is 32-bit), this calculation can overflow if `width` and `height` are large (e.g., 65535), wrapping around to a small value. This results in a small heap allocation via `AcquireQuantumMemory` and later operations relying on the dimensions can trigger an out of bounds read.
### Vulnerable Code
File: `coders/tim.c`
```c
width=ReadBlobLSBShort(image);
height=ReadBlobLSBShort(image);
image_size=2*width*height;       // Line 234 - NO OVERFLOW CHECK!
```

### Impact
This vulnerability can lead to Arbitrary Memory Disclosure due to an out of bounds read on 32-bit systems.
GitHub Security Advisory: GHSA-6hjr-v6g4-3fm8
Package: Magick.NET-Q16-HDRI-AnyCPU (NUGET)
Severity: HIGH (CVSS 7.5)
CWE: CWE-125: Out-of-bounds Read
Vulnerable versions: < 14.10.0
Patched in: 14.10.0

Summary: ImageMagick is vulnerable to an integer Overflow in TIM decoder leading to out of bounds read (32-bit only)

Details:
### Summary
The TIM (PSX TIM) image parser in ImageMagick contains a critical integer overflow vulnerability in the `ReadTIMImage` function (`coders/tim.c`). The code reads `width` and `height` (16-bit values) from the file header and calculates `image_size = 2 * width * height` without checking for overflow.
On 32-bit systems (or where `size_t` is 32-bit), this calculation can overflow if `width` and `height` are large (e.g., 65535), wrapping around to a small value. This results in a small heap allocation via `AcquireQuantumMemory` and later operations relying on the dimensions can trigger an out of bounds read.
### Vulnerable Code
File: `coders/tim.c`
```c
width=ReadBlobLSBShort(image);
height=ReadBlobLSBShort(image);
image_size=2*width*height;       // Line 234 - NO OVERFLOW CHECK!
```

### Impact
This vulnerability can lead to Arbitrary Memory Disclosure due to an out of bounds read on 32-bit systems.
GitHub Security Advisory: GHSA-6hjr-v6g4-3fm8
Package: Magick.NET-Q16-AnyCPU (NUGET)
Severity: HIGH (CVSS 7.5)
CWE: CWE-125: Out-of-bounds Read
Vulnerable versions: < 14.10.0
Patched in: 14.10.0

Summary: ImageMagick is vulnerable to an integer Overflow in TIM decoder leading to out of bounds read (32-bit only)

Details:
### Summary
The TIM (PSX TIM) image parser in ImageMagick contains a critical integer overflow vulnerability in the `ReadTIMImage` function (`coders/tim.c`). The code reads `width` and `height` (16-bit values) from the file header and calculates `image_size = 2 * width * height` without checking for overflow.
On 32-bit systems (or where `size_t` is 32-bit), this calculation can overflow if `width` and `height` are large (e.g., 65535), wrapping around to a small value. This results in a small heap allocation via `AcquireQuantumMemory` and later operations relying on the dimensions can trigger an out of bounds read.
### Vulnerable Code
File: `coders/tim.c`
```c
width=ReadBlobLSBShort(image);
height=ReadBlobLSBShort(image);
image_size=2*width*height;       // Line 234 - NO OVERFLOW CHECK!
```

### Impact
This vulnerability can lead to Arbitrary Memory Disclosure due to an out of bounds read on 32-bit systems.
GitHub Security Advisory: GHSA-hfv2-pf68-m33x
Package: Umbraco.Cms (NUGET)
Severity: MODERATE (CVSS 4.9)
CWE: CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, CWE-377: Insecure Temporary File, CWE-552: Files or Directories Accessible to External Parties
Vulnerable versions: >= 10.0.0, <= 13.12.0
Patched in: 13.12.1

Summary: Umbraco Vulnerable to Improper File Access and Credential Exposure in Dictionary Import Functionality

Details:
### Impact
Due to unsafe handling and deletion of temporary files during the dictionary upload process, an attacker with access to the backoffice can trigger predictable requests to temporary file paths. The application’s error responses (HTTP 500 when a file exists, 404 when it does not) allow the attacker to enumerate the existence of arbitrary files on the server’s filesystem. This vulnerability does not allow reading or writing file contents.

In certain configurations, incomplete clean-up of temporary upload files may additionally expose the NTLM hash of the Windows account running the Umbraco application. The direct impact of this vulnerability is therefore limited to confidentiality, which is reflected in its CVSS base score of 4.9

While the CVSS Base Score captures only the immediate effect, the practical risk varies significantly based on hosting environment and identity configuration. Umbraco Cloud sites run under low-privilege, isolated Azure App Service worker identities, which mitigates the impact of any credential exposure. In contrast, self-hosted deployments could run Umbraco using privileged local or domain accounts. If such an account’s NTLM hash is disclosed, an attacker may be able to:
- Perform NTLM relay attacks
- Crack the hash offline to recover the underlying password
- Authenticate as the compromised identity
- Access internal systems trusted by that identity
- Move laterally within the network
- Potentially escalate to full domain compromise in weakly segmented environments

These outcomes are not part of the CVSS base score, which only rates the immediate confidentiality impact, but represent realistic downstream consequences for installations using elevated or widely-trusted service accounts. Self-hosted environments running Umbraco under privileged identities are therefore at significantly higher risk.

Vulnerability found and reported by Tomasz Holeksa at Pentest Limited

### Patches
The issue has been patched in 13.12.1.

### Workarounds
The issue can only be exploited by authorized backoffice accounts with access to the "Translations" section.
GitHub Security Advisory: GHSA-wq34-7f4g-953v
Package: Csla (NUGET)
Severity: HIGH (CVSS 0.0)
CWE: CWE-502: Deserialization of Untrusted Data
Vulnerable versions: < 6.0.0
Patched in: 6.0.0

Summary: Csla affected by Remote Code Execution via WcfProxy (NetDataContractSerializer)

Details:
### Impact
Versions of CSLA .NET prior to version 6 allow the use of WcfProxy. WcfProxy uses the NetDataContractSerializer (NDCS) which has known vulnerabilities that can allow remote execution of code during deserialization. NDCS itself is considered obsolete, and you should avoid using WcfProxy or upgrade to CSLA 6 or higher where this issue does not exist.

### Patches
CSLA .NET version 6 and higher do not use WCF or NetDataContractSerializer.

### Workarounds
If you are using a version CSLA .NET older than version 6, you should stop using WcfProxy in your data portal configuration. Doing this avoids the use of WCF and the NetDataContractSerializer, avoiding the vulnerability.
GitHub Security Advisory: GHSA-95fv-5gfj-2r84
Package: MediaBrowser.Server.Core (NUGET)
Severity: CRITICAL (CVSS 0.0)
CWE: CWE-640: Weak Password Recovery Mechanism for Forgotten Password
Vulnerable versions: <= 4.9.1.80
Patched in: 4.9.1.81

Summary: Withdrawn Advisory: Emby Server API Vulnerability allowing to gain administrative access without precondition

Details:
### Withdrawn Advisory
This advisory has been withdrawn because it incorrectly listed [MediaBrowser.Server.Core](https://www.nuget.org/packages/MediaBrowser.Server.Core) as vulnerable. CVE-2025-64113 affects Emby Server versions 4.9.1.80 and prior, and Emby Server Beta versions 4.9.2.6 and prior.

### Original Description
### Impact

This vulnerability affects all Emby Server versions - beta and stable up to the specified versions.
It allows an attacker to gain full administrative access to an Emby Server (for Emby Server administration, **not at the OS level**,).
Other than network access, no specific preconditions need to be fulfilled for a server to be vulnerable.

### Patches

#### Quick Fix

A quick fix will be rolled out via an update to one of the default-included Emby Server plugins.
This way is chosen because many users are updating their servers manually while plugin updates are typically configured to be applied automatically. This allows to get a patch deployed to a large amount of servers within a single day.

#### Server Patches

Patched versions for both, Emby Server stable and Emby Server beta are available now.

**All Emby Server owners are strongly encouraged to apply those updates as soon as possible.**


### Workarounds

> [!NOTE]
> These workarounds are OBSOLETE now. Please update Emby Server instead!

As and immediate remedy, it is possible to set restricted file system permissions on the `passwordreset.txt` file in the configuration folder of Emby Server. If it doesn't exist, users can create the file themselves or just call the ForgotPassword API once, which will create the file.

On Windows, users can set DENY permissions for "Authenticated users" and on Linux, permissions can be set via `sudo chmod 444 passwordreset.txt`.
This will make the API request fail, which completely eliminates the vulnerability.