Stored cross-site scripting in the Bold Page Builder WordPress plugin (all versions before 5.9.9) permits any user holding the Contributor role or higher to embed arbitrary JavaScript inside an HTML attribute via an unsanitized shortcode parameter. A publicly available exploit exists per WPScan (EUVD-2026-72064). When a higher-privileged user such as an administrator views a page containing the injected payload, the script executes in their browser, enabling session hijacking, nonce theft, or full administrative takeover of the WordPress installation.
Shortcode injection in JetFormBuilder WordPress plugin before 3.6.5.2 allows unauthenticated remote attackers to execute any shortcode registered on the target WordPress site. The flaw stems from a misordered sanitization pipeline: user-supplied input in a request parameter is HTML-escaped before it is passed to WordPress's shortcode expansion function rather than after, meaning shortcode syntax survives the escape pass intact and is then evaluated server-side. A publicly available proof-of-concept exploit exists via WPScan, making this immediately actionable for attackers against unpatched installs.
Unauthenticated account registration bypass in SureCart WordPress plugin before 4.7.0 allows remote attackers to create WordPress user accounts and obtain authenticated sessions even when the site administrator has explicitly disabled user registration. The plugin fails to consult WordPress's native `users_can_register` site option before processing account creation through its own checkout/registration flow. A publicly available proof-of-concept exists per WPScan, and a vendor patch is available in version 4.7.0. No confirmed active exploitation (CISA KEV) at time of analysis.
SQL injection in SourceCodester Class and Exam Timetabling System 1.0 exposes the `/delete_user_account.php` endpoint to unauthenticated remote exploitation via an unsanitized `id` parameter. The flaw allows attackers to read, modify, or delete underlying database records without any authentication credential. A public proof-of-concept exploit is available via GitHub, materially elevating practical risk beyond what the moderate CVSS 4.0 score of 6.9 might suggest at face value.
Unauthenticated SQL injection in SourceCodester Class and Exam Timetabling System 1.0 allows remote attackers to manipulate the database through the ID parameter in /delete_user.php. The vulnerability requires no privileges or user interaction, and a public proof-of-concept exploit has been published on GitHub. Impact is limited by the CVSS 4.0 assessment (VC:L/VI:L/VA:L), suggesting partial data read/write rather than full database compromise, though chained exploitation could escalate impact.
SQL injection in the Login component of code-projects Task Management System In PHP 1.0 exposes the application's database to unauthenticated remote attackers via the `email` parameter in `/index.php`. The root cause is unsanitized user input passed directly into a SQL query (CWE-89), enabling authentication bypass and arbitrary data extraction. A public proof-of-concept writeup has been published on GitHub, significantly lowering the exploitation barrier; no vendor patch has been identified.
SQL injection in code-projects Content Management System 1.0 allows unauthenticated remote attackers to manipulate database queries via the user_name parameter in /login.php. Because the vulnerable endpoint is the authentication form itself, successful exploitation can achieve authentication bypass - granting admin-level access without credentials - as well as full database enumeration. A public proof-of-concept exploit has been published to GitHub, materially lowering the bar for exploitation.
Insecure direct object reference (IDOR) in the dmWidget component of diem-project/diem (versions through 5.1.3) allows unauthenticated remote attackers to bypass authorization controls by manipulating the `widget_id` parameter in `BasedmWidgetActions.class.php`, exposing widget data belonging to other users or contexts. A public proof-of-concept exists via GitHub issue #450, and the upstream project has not responded to the coordinated disclosure despite early notification. The CVSS 4.0 score of 5.5 reflects the limited blast radius - confidentiality impact only, with no integrity or availability consequences confirmed.
SQL injection in SourceCodester Class and Exam Timetabling System 1.0 exposes the /delete_teacher.php endpoint to unauthenticated remote database manipulation via an unsanitized ID parameter (CWE-89). A proof-of-concept exploit has been publicly released on GitHub, making opportunistic exploitation straightforward for low-skilled attackers. Attackers with network access to the application can extract, modify, or delete records from the underlying database without supplying credentials.
Unauthenticated remote access to an exposed SQL database backup file in code-projects Daily Expense Manager 1.0 allows any network attacker to retrieve sensitive application data. The file `/Daily-Expense-Manager/exp_ak.sql` - a raw database dump - is served directly from the web root without access control, disclosing potentially credentials, user records, and expense data. No public exploitation via CISA KEV, but a public exploit writeup is available on GitHub confirming the exposure path.
Unauthenticated remote download of a raw SQL database backup in code-projects Hotel and Tourism Reservation in PHP 1.0 exposes the full application database to any internet-connected attacker. The file /ht/hotel_db%20(1).sql is placed inside the web root without access restrictions, making it directly retrievable over HTTP with no credentials. A publicly available proof-of-concept exploit exists; the database dump likely contains guest PII, booking records, and potentially hashed or plaintext admin credentials.
Unauthenticated SQL injection in SourceCodester Class and Exam Timetabling System 1.0 exposes the application to full database read and write via the `fname` parameter in `/admin/modal_add_product.php`. The underlying `mysqli_query` call accepts unsanitized user input, allowing remote attackers to craft malicious SQL payloads without any authentication. A public exploit has been disclosed on GitHub, materially increasing the likelihood of opportunistic exploitation.
SQL injection in SourceCodester Class and Exam Timetabling System 1.0 allows remote unauthenticated attackers to manipulate backend database queries via the unsanitized `course` parameter passed directly to mysqli_query in /admin/modal_add_coursea.php. The vulnerability carries limited but confirmed data exposure and integrity risk (VC:L/VI:L/VA:L per CVSS 4.0). A public proof-of-concept exploit was published to GitHub, lowering the bar for exploitation significantly. No vendor patch has been identified.
SQL injection in SourceCodester Class and Exam Timetabling System 1.0 exposes the `course` parameter in `/admin/modal_add_course2.php` to unauthenticated remote attackers who can manipulate the underlying MySQL database. The vulnerability is rooted in direct, unsanitized input concatenation into a `mysqli_query()` call, yielding bounded but real read, write, and partial availability impact. A proof-of-concept exploit has been publicly disclosed on GitHub, materially lowering the exploitation barrier.
SQL injection in Mstfakts College-Management-System exposes the Search Handler endpoint (Front-end/university.php) to unauthenticated remote exploitation via unsanitized book_name and book_author parameters passed directly to mysqli_query(). A working proof-of-concept has been publicly disclosed via GitHub Issue #5, and the project maintainer has not responded to the disclosure, leaving the codebase unpatched. No public exploit identified as actively exploited in the wild at time of analysis, but the low attack complexity and no-authentication requirement combined with public PoC materially elevate practical risk.
SQL injection in SourceCodester Class and Exam Timetabling System 1.0 allows remote attackers to manipulate database queries via the room_name parameter passed to the mysqli_query() call in /admin/modal_add_room.php. Exploitation yields limited data disclosure and modification (VC:L/VI:L per CVSS 4.0), consistent with a classic unsanitized input flaw in a PHP/MySQL stack. A public proof-of-concept is available on GitHub, no vendor patch has been identified, and no active exploitation (CISA KEV) has been confirmed.
SQL injection in SourceCodester Class and Exam Timetabling System 1.0 exposes the database to unauthenticated remote attackers via the `course` parameter passed to `mysqli_query()` in `/admin/modal_add_course1.php`. An attacker can craft a malicious HTTP request to read, modify, or delete database contents without prior authentication, as confirmed by a publicly available proof-of-concept exploit. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N) reflects straightforward remote exploitation with no special conditions, though limited CIA impact scores (VC:L/VI:L/VA:L) suggest partial rather than full database compromise.
SQL injection in SourceCodester Class and Exam Timetabling System 1.0 allows unauthenticated remote attackers to execute arbitrary SQL against the application database through the unvalidated `course` parameter in `/admin/modal_add_course.php`. The `mysqli_query` function receives attacker-controlled input without parameterization or sanitization, enabling full database extraction, credential theft, and record manipulation. A public proof-of-concept exploit is available on GitHub; no vendor patch has been identified at time of analysis.
Unauthenticated SQL injection in SourceCodester Online Voting System 1.0 exposes the login endpoint `/ajax.php?action=login` to database manipulation via an unsanitized Username parameter. A remote attacker with no credentials can craft malicious SQL input to bypass authentication, extract database contents, or alter voting records. A public proof-of-concept exploit has been disclosed on GitHub (CVE exploit issue #1), elevating practical risk above the moderate CVSS 4.0 score of 6.9.
Unauthenticated SQL injection in SourceCodester Online Voting System 1.0 allows remote attackers to manipulate database queries via the unsanitized `id` parameter in `/ajax.php?action=delete_category`. Because the endpoint accepts user-supplied input without parameterization or sanitization, an attacker can craft malicious SQL payloads to read, modify, or delete database contents - including voter credentials, vote tallies, and administrative account data. A public proof-of-concept exploit exists per VulDB submission; no vendor patch has been identified at time of analysis. No public exploit identified at time of analysis is contradicted by the POC flag - POC is confirmed publicly available.
Unauthenticated SQL injection in SourceCodester Online Voting System 1.0 exposes the `/ajax.php?action=delete_voting` endpoint to arbitrary database manipulation via an unsanitized `ID` parameter. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms remote exploitation with no authentication or preconditions, and a public proof-of-concept has been disclosed on GitHub. An attacker can read, modify, or delete voting records depending on the database user's privileges, with potential to undermine the integrity of any election or poll managed by the application.
SQL injection in SourceCodester Online Voting System 1.0 exposes the /ajax.php?action=save_user endpoint to unauthenticated remote exploitation via the unsanitized ID parameter. A public proof-of-concept exploit is available on GitHub, enabling database extraction or manipulation without authentication. The CVSS 4.0 vector confirms network-reachable, zero-prerequisite exploitation, though impact is bounded at the database layer rather than full system compromise.
Unauthenticated SQL injection in rabindralamsal's inventory-management-system 1.0.0 exposes the login endpoint (index.php) to direct database manipulation via unsanitized username and password parameters. An attacker with network access can craft malicious SQL payloads to bypass authentication, enumerate database contents, or alter stored records without any prior credential or privilege. A public proof-of-concept exploit exists (GitHub issue), making this immediately actionable by low-skill attackers; no patch has been identified.
Unauthorized role self-assignment in the B2BKing WooCommerce plugin before version 5.2.40 allows unauthenticated registrants to claim restricted B2B customer group memberships without admin approval by supplying arbitrary role parameters not bounded by server-side validation. The plugin fails to verify that a role submitted during account registration is actually one offered on the public registration form, enabling any user to bypass the manual account-approval workflow and gain access to wholesale pricing tiers or restricted catalogs. A publicly available proof-of-concept exists via WPScan, though no confirmed active exploitation has been identified in CISA KEV at time of analysis.
Shortcode injection in the Ninja Forms WordPress plugin (versions 3.14.10 through 3.15.1) allows unauthenticated network attackers to execute any shortcode registered on the target site by embedding shortcode syntax into form request fields the plugin later processes. The plugin fails to strip or escape shortcode markers before passing user-controlled values through WordPress's shortcode execution pipeline, meaning the server interprets and runs injected tags. A publicly available exploit exists per WPScan's advisory; real-world impact scales with the shortcodes registered on the site - ranging from benign output to sensitive data exposure or unintended privileged actions.
Shortcode injection in the Redirection for Contact Form 7 WordPress plugin (versions 2.2.7 through 3.2.10) enables unauthenticated remote attackers to execute arbitrary registered WordPress shortcodes server-side and capture their output. The plugin substitutes raw form submission values into its action settings and then evaluates those settings through WordPress's do_shortcode() pipeline without sanitizing or stripping user-supplied shortcode syntax first. A public proof-of-concept is available via WPScan; vendor-released patch version 3.2.11 addresses the issue.
Email header injection in JetFormBuilder WordPress plugin before 3.6.5.2 allows unauthenticated attackers to manipulate outgoing email headers by submitting CRLF sequences in form address fields. Exploitation enables adding hidden recipients via BCC, spoofing the sender address, and abusing the victim site's trusted email reputation as a phishing or spam relay. A publicly available exploit entry is documented by WPScan, though exploitation requires a non-default configuration in which the plugin is explicitly set to source message address headers from user-submitted form fields.
Real Estate Papi WordPress theme (≤1.0.5) exposes an AJAX endpoint that lacks both capability checks and CSRF validation, enabling any authenticated subscriber to silently force-install a fixed set of companion plugins from the WordPress.org repository. Because CSRF protection is also absent, an attacker can craft a cross-site request that fires in an active administrator session, causing those plugins to be activated as well - an escalation beyond what subscriber-level access alone would permit. WPScan published a proof-of-concept; SSVC rates exploitation as none with partial technical impact, indicating no confirmed in-the-wild abuse at time of analysis.
SSE event injection in the h3 JavaScript HTTP framework (npm package h3js/h3, versions before 1.15.9 stable and before 2.0.1-rc.17 beta) allows remote attackers to inject arbitrary Server-Sent Events by embedding carriage return (`\r`) characters in `data` or `comment` fields that are reflected into the EventStream. Because the HTML SSE specification treats `\r` as a valid line terminator, browsers parse injected `\r` sequences as field boundaries - enabling attackers to spoof event types, split a single push call into multiple distinct browser-parsed events, or escape comment fields to deliver fake data. This is a confirmed incomplete-fix bypass: the prior commit `7791538` sanitized `\n` and `\r` only for `id` and `event` fields while leaving `data` and `comment` unprotected. No public exploit has been confirmed in CISA KEV; however, the GHSA advisory (GHSA-4hxc-9384-m385) includes a proof-of-concept server setup demonstrating the bypass.
Privilege escalation in PostgreSQL Anonymizer (Dalibo) prior to 3.2.0 allows a table owner to execute arbitrary code with full superuser privileges via the `anon.anonymize_database_parallel()` function. The vulnerability (CWE-250, Execution with Unnecessary Privileges) enables a low-to-high privilege escalation within the database server, granting complete C:H/I:H/A:H impact. No public exploit has been identified and the issue is not listed in CISA KEV; a vendor-released patch is available in version 3.2.0.
SQL injection in PostgreSQL Anonymizer's anon.import_database_rules() and anon.import_roles_rules() functions enables privilege escalation to superuser-level code execution within PostgreSQL. A low-privileged database user plants a malicious JSON rules document containing crafted object names (such as schema, table, or column identifiers); when a superuser subsequently invokes either import function, the injected SQL executes with superuser privileges, yielding full database compromise. The vendor has released a fix in version 3.1.4; no public exploit has been identified at time of analysis.
Incomplete authorization fix in wger through master exposes three user-management views in wger/core/views/user.py to the same None != None gym-scope bypass previously identified in CVE-2026-43948 (GHSA-mhc8-p3jx-84mm). A gym staff member holding gym.manage_gym permission whose account has gym=None - the default unlinked state for any newly provisioned staff account - can permanently delete, deactivate, or re-activate any other user also carrying gym=None, exploiting a raw integer comparison that evaluates None != None as False instead of blocking the operation. No vendor-released patch has been identified at time of analysis; all wger versions through the master Docker image build of 2026-05-08 are confirmed affected.
Authentication bypass in Mstfakts College-Management-System exposes the login endpoint at Front-end/login.php to manipulation of the email argument, enabling remote unauthenticated attackers to circumvent access controls entirely. A public proof-of-concept exploit has been disclosed (CVSS 4.0 E:P), and the project maintainer has not responded to the responsible disclosure report filed via GitHub. No patched release exists due to the rolling-release delivery model, leaving all current deployments without a vendor-supported fix.
Open redirect in h3 (h3js) before 2.0.1-rc.18 allows unauthenticated remote attackers to redirect victims to arbitrary external domains by crafting a Referer header containing a same-origin URL with a double-slash path segment (e.g., http://target.com//evil.com/phish). The redirectBack() utility passes the WHATWG origin check - because the parsed origin is correctly identified as the target domain - but emits the raw pathname //evil.com/phish as the Location header, which browsers interpret as a protocol-relative redirect to an attacker-controlled site. A proof-of-concept is included in the GHSA advisory; no active exploitation (CISA KEV) has been identified at time of analysis.
Open redirect in wger's trainer_login view allows an attacker to redirect an authenticated trainer's browser to an arbitrary external domain immediately after impersonation mode is established. The root cause is in `wger/core/views/user.py` (~line 203), where `HttpResponseRedirect(request.GET['next'])` is called without invoking Django's `url_has_allowed_host_and_scheme()` guard, allowing any URL - including off-host ones - to be supplied via the `?next=` GET parameter. Beyond phishing, the redirect leaks the wger instance URL structure and the impersonated user's `user_pk` through the browser's Referer header; a working PoC is confirmed in the GHSA advisory, though no active exploitation has been reported.
CSV/TSV formula injection in wger's gym member export endpoint allows any authenticated gym member to pre-load spreadsheet formulas into their own first_name or last_name profile fields, which are then reproduced verbatim in the TSV export file. When a gym administrator opens the exported file in Excel, LibreOffice Calc, or Google Sheets, the formula executes in the admin's local spreadsheet context, enabling data exfiltration via =HYPERLINK callbacks and, on legacy Excel deployments with DDE enabled, arbitrary local code execution. No public exploit code has been independently verified beyond the researcher's proof-of-concept described in the GHSA advisory; this vulnerability is not listed in the CISA KEV catalog.