The svg-sanitizer library versions from 0.11.0 up to but not including 1.1.0 contain a vulnerability where submitting well-formed XML documents without a top-level svg root element causes an uncaught exception. Specifically, supplying documents with a non-svg root or nested svg element triggers a LogicException in the Sanitizer::sanitize() function, leading to crashes or bypassing upload rejection.
A denial of service vulnerability exists in svg-sanitizer versions from 0.5.3 up to but not including 1.1.0. The flaw occurs in the Sanitizer::sanitize() function, which repeatedly rescans the entire input while stripping PHP tags. This behavior allows unauthenticated attackers to craft SVG files containing many overlapping PHP tag openers and closers, causing excessive CPU usage and service disruption.
REDAXO versions prior to 5.21.0 have a reflected cross-site scripting (XSS) vulnerability in the backend packages API. The flaw arises because a function parameter is concatenated into an error message without proper HTML escaping. An attacker can exploit this by tricking an authenticated backend user into clicking a crafted link containing a valid CSRF token, leading to execution of malicious JavaScript that can perform same-origin actions or read DOM data.
REDAXO versions prior to 5.21.3 have a reflected cross-site scripting (XSS) vulnerability in the backend media pool detail page. The vulnerability arises because the opener_link parameter is rendered without proper HTML escaping. An unauthenticated attacker can trick logged-in backend users with media permissions into clicking a crafted link, allowing script injection. This script can read the victim's CSRF token and perform actions with their permissions, including potentially executing code via template or module edits if the victim has administrator privileges.
REDAXO versions before 5.21.0 have a reflected cross-site scripting (XSS) vulnerability in the metainfo_default_fields_create API. Authenticated attackers can inject malicious scripts via the type parameter, which are rendered unescaped in the backend session. This allows script execution in the victim's backend context.
REDAXO versions before 5.21.3 have a cross-site request forgery (CSRF) vulnerability in the backend user administration page. The CSRF token check is only enforced when the save parameter is set, but the update path triggered by FUNC_UPDATE bypasses this check. This allows attackers to trick logged-in backend users with the users[] permission into performing unauthorized actions such as granting administrator rights, deactivating accounts, or locking out the sole administrator via crafted GET requests.
REDAXO versions before 5.21.3 have a cross-site request forgery (CSRF) vulnerability in the structure/history plugin. This flaw allows attackers to trick logged-in backend users into sending unvalidated GET requests that can delete all article snapshots or revert articles to previous states. The vulnerability can cause loss of content history or unintended content rollback.
A vulnerability in certain versions of Octopus Server allows users with the System Manager role to escalate their privileges to full system Administrator. This elevation of privilege could enable unauthorized administrative control over the system.
REDAXO core versions from 5.3.0 up to but not including 5.21.4 contain an authentication bypass vulnerability in the structure/history plugin. This flaw allows unauthenticated attackers to forge temporary login tokens by forcing the session-tied secret into a predictable state. Exploitation can lead to unauthorized backend access, including admin-level privileges, and code execution outside of live mode.
REDAXO versions before 5.21.4 have a broken access control vulnerability that allows authenticated editors to modify slices in categories they are not authorized to access. By pairing a permitted article with a foreign slice ID, attackers can abuse content editing, deletion, and slice status or movement APIs to delete, toggle, move, or overwrite slices belonging to other editors.
REDAXO versions before 5.21.4 have a missing authorization vulnerability in the media pool bulk move feature. The vulnerability arises because the system only checks permissions on the target category and ignores the source category. Authenticated backend users with permission on one media category can move files from restricted categories into their permitted category and replace their contents silently across the site.
In certain versions of Octopus Server, creating a user invitation causes the invitation code to be logged in the audit event log. If the invitation is linked to a space, users with appropriate permissions in that space could read the invitation code from the audit log. An attacker who redeems the unclaimed invitation might escalate privileges depending on the permissions assigned to the invited user. This vulnerability has a high severity rating with a CVSS score of 7.7.
REDAXO versions from 5.18.0 up to but not including 5.21.4 contain a stored cross-site scripting (XSS) vulnerability. This occurs because the rex_media_service component moves uploaded SVG files into the public media folder before sanitizing them. Authenticated users with mediapool upload rights can exploit a race condition or exhaust memory limits to leave malicious script-laden SVG files accessible, leading to script execution in victims' backend sessions.
JetBrains Junie CLI versions prior to 26.8.17 contain a vulnerability that allows command execution due to incomplete validation of allowlisted commands. This flaw could enable an attacker with limited privileges to execute arbitrary commands. The issue has been assigned CVE-2026-117530 and carries a CVSS score of 6.7, indicating a medium severity level.
REDAXO versions before 5.21.4 have a stored cross-site scripting (XSS) vulnerability. This flaw allows content editors to inject malicious HTML by submitting crafted input values that are stored and later rendered without proper escaping in media-related widgets. Exploitation can lead to script execution in administrators' backend sessions, potentially hijacking their accounts.
REDAXO versions before 5.21.5 have a cross-site request forgery (CSRF) vulnerability in the backend. The vulnerability arises because the safemode GET parameter in index.php is processed without validating a CSRF token. An attacker can exploit this by tricking a logged-in administrator into clicking a crafted link, which can disable global safe mode or enable session safe mode, potentially impacting backend addon functionality.
REDAXO core versions before 5.21.4 have a missing authorization vulnerability in the structure/version and structure/history frontend preview modes. These modes fail to verify category or clang permissions for the previewed article, allowing any backend user or users with the history[article_rollback] permission to access unpublished, historic, or deleted content by manipulating preview parameters.
REDAXO versions before 5.21.5 have a missing authorization vulnerability in the backup addon export feature. This flaw allows non-admin users with the backup[export] permission to export any database table, including sensitive tables such as rex_user and rex_user_session. Exploitation can lead to attackers obtaining plaintext session IDs and stay-logged-in keys to hijack admin accounts or password hashes for offline cracking.
SemanticMediaWiki versions from 3.1.0 up to but not including 7.3.1 contain a reflected cross-site scripting (XSS) vulnerability. This flaw allows unauthenticated attackers to inject malicious markup via the search parameter in the extended Special:Search profile. The vulnerability arises because the ProfileForm::profile_sheet function inserts unescaped user input into a pre element, enabling script execution in the context of the wiki origin when crafted URLs with SVG event handlers are used.
SemanticMediaWiki versions from 2.5.0 up to but not including 7.3.1 contain a stored cross-site scripting (XSS) vulnerability. This flaw allows users with page-edit rights to inject malicious script via Code-typed property values. The vulnerability arises because attackers can embed HTML markup inside a valid JSON value, which is then rendered unescaped on the Special:Browse page, leading to JavaScript execution in the browsers of users viewing the page.