Manop55555

The `saveAction` functionality allows an authenticated attacker to change the administrator password without re-authentication. This occurs due to a missing re-verification check during the password change process, enabling attackers to bypass authentication controls and maintain or escalate unauthorized access to the administrative account.

The `serveStatic` function decodes the request path a second time after the application has already decoded it for routing. A malformed percent-encoded sequence can cause the route middleware to evaluate an encoded path while the static file resolution uses a different directory. This allows an unauthenticated attacker to bypass middleware mounted on a protected static prefix and read files within the configured static root. This issue does not permit directory traversal outside the configured root and only affects applications that mount middleware on parts of the directory served by `serveStatic`.

A middleware bypass exists in the `serveStatic` function. Unauthenticated attackers can bypass prefix middleware by using double path decoding, sending malformed percent-encoded paths that the router matches in encoded form. This allows unauthorized access to static files by skipping authentication checks.

A crafted PDF containing specific form field values can trigger a performance issue during appearance-stream generation within the `pypdf/generic/ appearance stream.py` file. This occurs when an application updates fields with flattening enabled, causing the system to repeat invariant selection-data work inside a loop. This inefficiency leads to excessive runtimes and can result in application unavailability.

A crafted PDF file can contain unusually large alphabetical page-label values. When an application retrieves document page labels, the `pypdf/ page labels.py` module generates strings that exceed a reasonable length, leading to excessive memory consumption and potentially causing the application to become unavailable.

Stored Cross-Site Scripting occurs due to insufficient input sanitization and output escaping. This allows unauthenticated attackers to inject arbitrary web scripts into pages, which execute when a user accesses the affected page.

An unauthenticated Cross Site Scripting (XSS) issue exists, which allows an attacker to execute malicious scripts in the browser of a user without requiring prior authentication.

An unauthenticated SQL Injection exists in the software. SQL Injection is a type of vulnerability that allows an attacker to interfere with the queries that an application makes to its database, potentially allowing them to view data they are not normally able to retrieve.

An attacker can craft a PDF file that results in long runtimes. This occurs when accessing a stream that utilizes the `/FlateDecode` filter with a PNG predictor.

A flaw in the pure-python PDF library allows an attacker to craft a PDF that causes excessive memory consumption. This occurs when extracting text from a page containing a form XObject (a reusable PDF object) that includes self-references.

The `<NuxtLink>` component fails to validate the URL scheme of values bound to its `to` or `href` props before rendering them into the `href` attribute of the underlying `<a>` element. If an application binds attacker-controlled input to these props, an attacker can provide a `javascript:` or `vbscript:` URL. When clicked, this executes the script in the origin of the application, leading to reflected DOM-based cross-site scripting (XSS), which is a vulnerability where a script is executed in the user's browser due to the application's failure to sanitize input. Additionally, a `data:text/html,...` payload can be used to create a same-tab phishing surface. This issue also affects applications that re-bind the `href` and `route.href` props from the component's custom slot to their own anchors.

An attacker can craft a PDF file that causes excessive memory consumption during the parsing of large XMP metadata, which may contain numerous unnecessary elements.