Missing authorization in JeecgBoot through 3.9.5 allows any authenticated user to read arbitrary accounts' role codes by supplying a userId to the queryUserRolesById handler of SystemApiController, enabling enumeration of role assignments and identification of administrator accounts. Exploitation requires only a valid low-privilege session (CVSS 4.0 vector shows PR:L, no user interaction) and publicly available exploit code exists, while there is no evidence of confirmed active exploitation (no CISA KEV listing in the provided data). Because the flaw is limited to confidentiality with no modification or availability impact, it is a genuine but low-to-moderate priority disclosure issue rather than a critical emergency.
Authenticated insecure direct object reference in JeecgBoot through 3.9.5 allows any logged-in user to read other users' in-application announcement messages by passing an attacker-chosen sendId to the getOne handler of SysAnnouncementSendController. Valid delivery-record identifiers are trivially harvested from the unguarded /sys/sysAnnouncementSend/list endpoint, after which getOne returns message titles, bodies, senders and recipients without any ownership check, producing a confidentiality-only impact with no write or availability effect (CVSS 4.0 base 5.3; assessed CVSS 3.1 5.3, AV:N/AC:L/PR:L/UI:N). Exploitation requires a valid low-privileged account but no special configuration or user interaction; publicly available exploit code exists in the form of a published GitHub proof-of-concept script, and there is no KEV confirmation of active exploitation, so this should be treated as a moderate-priority, exploitation-ready information-disclosure issue rather than a system-compromise flaw.
Missing authorization in the JeecgBoot SysDepartRole queryById handler (all versions through 3.9.5) lets any authenticated user - regardless of department scope - read department-role metadata such as role names, codes, descriptions, and audit fields by issuing GET /sys/sysDepartRole/queryById with an arbitrary id value. Exploitation requires only a valid low-privileged session on a reachable JeecgBoot system API, so it is not exploitable by fully unauthenticated outsiders, and publicly available exploit code exists, making the flaw trivially reproducible for anyone holding basic account credentials. The impact is limited to read-only disclosure of role metadata with no write or availability effect, consistent with the assessed CVSS 4.0 score of 5.3 (Medium) and CWE-862 (Missing Authorization).
Missing authorization in JeecgBoot through 3.9.5 lets any authenticated user - regardless of privilege level (CVSS vector PR:L) - enumerate department personnel via the GET /sys/sysDepart/getDepartmentHead endpoint of SysDepartController, disclosing staff names, avatars, posts, and mobile and telephone numbers, including records explicitly marked hidden, simply by iterating the departId parameter. Publicly available exploit code exists in the form of a proof-of-concept script targeting the endpoint, but the impact is confined to confidentiality of directory/contact data at CVSS 5.3 with no write, code-execution, or availability effect, and no non-default configuration is needed to reach the vulnerable code path. This is a moderate-severity information-disclosure issue rather than an urgent, actively exploited one.
Low-privileged authenticated users of JeecgBoot through 3.9.5 can read department permission records they should not be authorized to see by issuing GET requests to /sys/sysDepartPermission/queryById with an arbitrary department id, exposing depart_id, permission_id and data_rule_ids values. The flaw is a missing authorization check in the SysDepartPermissionController queryById handler (CWE-862), rated 5.3 with an assessed vector of CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N, so exploitation is limited to confidentiality impact and requires only a valid account with no administrative role. Publicly available exploit code exists (a Python PoC published by VulnCheck-referenced researchers), and the issue is not listed in CISA KEV as actively exploited; EPSS data was not provided, so no exploitation-likelihood estimate can be cited.
Missing authorization in JeecgBoot through 3.9.5 lets any authenticated user read role data-rule metadata - rule names, columns, conditions, values and bound rule IDs - for arbitrary roles via GET /sys/role/datarule/{permissionId}/{roleId}. The loadDatarule handler in SysRoleController omits the authorization check that its sibling endpoints enforce, so a low-privileged account (PR:L, unauthenticated access does not work) can enumerate permissionId/roleId pairs and exfiltrate the row-level access-control policy of the whole tenant. Impact is information disclosure only (CWE-862, no write, no code execution); publicly available exploit code exists, and the CVE is not in CISA KEV.
Missing authorization in JeecgBoot's SysMessageController queryById handler (all versions through 3.9.5) lets any authenticated user, at any privilege level, read the message push records of other accounts by supplying arbitrary record IDs to GET /sys/message/sysMessage/queryById, exposing message content and receiver addresses. The impact is read-only information disclosure - no integrity or availability effect - and exploitation requires a valid low-privileged session plus knowledge or enumeration of valid message record IDs, making this a moderate-risk IDOR rather than a pre-authentication compromise path (CVSS 4.0 base 5.3; independently assessed CVSS 3.1 5.3, PR:L, C:L). Publicly available exploit code exists (a Python PoC linked from the VulnCheck advisory), but there is no confirmation of active exploitation (CISA KEV).
Missing authorization in the AiragExtDataController exportXls handler of JeecgBoot (through 3.9.5) allows any authenticated account, regardless of role, to download every user's airag_ext_data records - AI evaluator definitions and test-tracking data - as an Excel workbook via a request to /airag/extData/exportXls. Exploitation requires a valid account of any privilege level (CVSS 3.1 AV:N/AC:L/PR:L/UI:N, scored 5.3) and only affects instances that actually deploy the airag module; publicly available exploit code exists, but there is no confirmed active exploitation (CISA KEV). Because the impact is read-only information disclosure (C:L, no integrity or availability effect), this is a moderate-priority exposure tied to the sensitivity of the exported AI evaluator and prompt data rather than a critical one.
Authenticated users of JeecgBoot through 3.9.5 can read other users' AI voice-generation history by supplying an arbitrary victim identifier in the userId parameter of GET /airag/voice/listByUser, an insecure direct object reference (CWE-639) in the airag voice controller where the endpoint trusts the client-supplied id instead of the session identity. Requirement to exploit is a valid low-privilege account (CVSS vector PR:L) plus knowledge or enumeration of another user's id, after which an attacker can retrieve submitted text-to-speech input, voice settings, timestamps, and generated audio file names and paths stored in Redis; no user interaction or elevated privilege is needed and the AI voice module must be present and in use. Impact is confidentiality-only with no write or availability effect, and publicly available exploit code exists (no confirmation of active exploitation and no KEV listing).
JeecgBoot through 3.9.5 permits any authenticated low-privileged user to alter another user's avatar, including an administrator's, by sending a PUT request with an arbitrary target user ID and avatar value to the SystemApiController updateAvatar endpoint. The independent assessment rates this as a low-to-moderate priority authenticated integrity-check failure: network reachable, low privileges required, no user interaction, and only low impact to avatar data with no confidentiality or availability loss. Publicly available exploit code exists, but no CISA KEV active exploitation is indicated.
Missing authorization in the SysCategoryController importExcel handler of JeecgBoot through 3.9.5 allows any authenticated user - of any privilege level - to bulk-insert arbitrary nodes into the system-wide sys_category dictionary by uploading a crafted Excel workbook. Because the endpoint lacks a role or permission check, a low-privileged account can add entries, including under existing parent nodes, tampering with a shared configuration dictionary; the impact is limited to integrity (no confidentiality or availability loss per the CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N assessment), and the primary limiter is that a valid login is required, so unauthenticated outsiders cannot exploit it. Publicly available exploit code exists and the issue is referenced by VulnCheck, but there is no indication of confirmed active exploitation (CISA KEV), and no vendor-released patch was identified at time of analysis.
Missing authorization in JeecgBoot's SysCategoryController (through version 3.9.5) lets any authenticated user, including a low-privileged one, rename, recode, or move system-wide sys_category dictionary nodes by sending POST or PUT requests with a node id to /sys/category/edit, corrupting classification values that are consumed across forms and other application features. Publicly available exploit code exists and the issue is tracked by VulnCheck, but no evidence of confirmed active exploitation (CISA KEV) was provided. With PR:L in both the vendor CVSS 4.0 vector (5.3) and the independent CVSS 3.1 assessment, impact is confined to integrity of shared reference data - no confidentiality or availability effect - and the need for a valid session plus a known or enumerable node id keeps this a moderate-priority issue rather than a high-impact one.
JeecgBoot versions through 3.9.5 expose an authorization gap in SysAnnouncementSendController that lets any authenticated user tamper with other users' announcement delivery records, overwriting read flags, recipient identifiers, or the linked announcement so that messages are hidden from the intended recipients. Exploitation requires a valid low-privileged account and reachability to the standard GET /sys/sysAnnouncementSend/list and PUT /sys/sysAnnouncementSend/edit endpoints, which ship enabled in default deployments; no user interaction or special configuration is needed. Publicly available exploit code exists (a PoC script published in a public GitHub repository), and VulnCheck is credited with reporting it, but there is no evidence of confirmed active exploitation (not in CISA KEV). Impact is integrity-only against message-delivery data, with no confidentiality or availability effect, giving moderate severity (CVSS 4.0 base 5.3; independently assessed as CVSS 3.1 5.3, PR:L).
Missing authorization in JeecgBoot through 3.9.5 allows any authenticated low-privileged user to remove arbitrary users from administrator-maintained groups by sending DELETE requests with manipulated groupId and userId parameters to the SysUserController's deleteGroupUser handler. This broken-access-control flaw (CWE-862) has modest impact-only group membership integrity is affected, not code execution or data theft-and publicly available exploit code exists. Exploitation requires a valid account of any privilege level and network access to the API; no special configuration is needed, making multi-tenant deployments particularly at risk.
Missing authorization in JeecgBoot through 3.9.5 lets any low-privileged authenticated user silently remove members from administrator-maintained user groups by calling DELETE /sys/user/deleteUserGroupBatch with an arbitrary groupId and a comma-separated list of userIds. The endpoint performs no permission or tenant-isolation check before deleting rows from sys_ugroup_user, so the impact is limited to integrity tampering with group membership rather than data disclosure or denial of service; publicly available exploit code exists (a PoC script is published), and no confirmed vendor patch was identified at time of analysis. Successful exploitation requires a valid authenticated session at any privilege level (PR:L in both the reported CVSS 4.0 vector and our assessed CVSS 3.1 vector), meaning fully unauthenticated attackers cannot exploit it, and no CISA KEV listing or confirmed active exploitation is associated with this issue.
Missing authorization in JeecgBoot through 3.9.5 allows any authenticated user, regardless of role, to upload a crafted Excel workbook to POST /sys/sysDepart/appImportExcel and create arbitrary sys_depart records in the administrator-maintained department tree. Exploitation requires only a valid low-privilege session with network reachability to the endpoint, and publicly available exploit code exists; however, the impact is confined to integrity (CVSS 3.1 base 5.3, PR:L, I:L, C:N, A:N), with no code execution, data disclosure, or service disruption possible from this flaw alone. This is a medium-severity, lower-priority issue in practice that matters mainly where low-privilege accounts are freely provisioned.
JeecgBoot through 3.9.5 exposes the POST /sys/sysDepartPermission/add endpoint without any authorization check, so any low-privileged authenticated user can create department-permission bindings and attach menu, button, and data-rule grants to arbitrary departments by supplying their own departId, permissionId, and dataRuleIds values. Because the flaw is a missing-authorization issue (CWE-862) rated 5.3 with an assessed CVSS:3.1 vector of AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N, impact is limited to integrity and exploitation requires a pre-existing account plus a department context whose roles will actually delegate the injected grants. Publicly available proof-of-concept exploit code exists, making the issue practically reproducible, but there is no confirmed active exploitation (CISA KEV) at time of analysis.
Missing authorization in JeecgBoot through 3.9.5 allows any authenticated user, including low-privileged accounts, to overwrite department permission records through the unprotected edit (PUT) endpoint of SysDepartPermissionController, changing depart_id, permission_id and data_rule_ids values that control which menus and data rules departments may delegate. A companion list endpoint is likewise unguarded, so attackers can enumerate valid record ids before issuing the modification requests. Publicly available exploit code exists (no confirmed active exploitation), and the flaw is rated moderate - CVSS 4.0 base 5.3 with integrity-only impact - requiring only a valid authenticated account of any privilege level per the CVSS vector (PR:L).
Any authenticated JeecgBoot user - regardless of privilege level - can add, modify or clear department data-rule bindings by POSTing departId, permissionId and dataRuleIds to /sys/sysDepartPermission/datarule, because the saveDatarule handler in SysDepartPermissionController performs no authorization check, in versions through 3.9.5. Publicly available exploit code exists, but no active exploitation is confirmed (not in CISA KEV). With a CVSS 5.3 rating reflecting network reachability, low privileges required and only low integrity impact, realistic risk concentrates in multi-department or multi-tenant deployments where untrusted low-privilege accounts exist.
Missing authorization in JeecgBoot through 3.9.5 allows any authenticated user holding a low-privileged account to overwrite arbitrary message-push records by sending a PUT request to /sys/message/sysMessage/edit with any sys_sms record id in the body, changing the record's title, content, receiver address and send status without any ownership check. The flaw is confined to integrity tampering of message records - there is no confidentiality or availability impact - and exploitation requires a valid account plus network reachability to the application's REST API, so unauthenticated attacks are not possible. Publicly available exploit code exists, making the issue straightforward to reproduce, but active exploitation has not been confirmed and no vendor-released patch was identified at time of analysis.
Missing authorization in the JeecgBoot SysPositionController edit handler (/sys/position/edit) lets any authenticated low-privileged account rewrite organizational position names, codes, and ranks via crafted PUT or POST requests, affecting JeecgBoot through 3.9.5. Because the position list endpoint is also unguarded, an attacker can first enumerate valid position IDs and then target them directly, so no guesswork or elevated role is required. Impact is confined to the integrity of position reference data - there is no confidentiality or availability loss and no escalation to system compromise - and the issue is correctly rated medium (CVSS 5.3); publicly available exploit code exists, while no CISA KEV active-exploitation entry is indicated.
Low-privileged authenticated users of JeecgBoot through 3.9.5 can overwrite system notification templates via the PUT /sys/message/sysMessageTemplate/edit endpoint, which lacks an authorization check, allowing attacker-controlled text or links to be injected into messages delivered to other users. Publicly available exploit code exists, but exploitation requires a valid low-privileged account and enumeration of template IDs from an unguarded list endpoint; there is no confirmed active exploitation (not in CISA KEV). The impact is confined to integrity tampering of notification content, with no confidentiality or availability impact per the assessed CVSS:3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N).
Missing function-level authorization in JeecgBoot through 3.9.5 (CWE-862) allows any authenticated user holding only a low-privileged role to create arbitrary notification templates by calling POST /sys/message/sysMessageTemplate/add. Because the SysMessageTemplateController handler performs no permission check, an attacker with minimal credentials can insert templates with attacker-chosen codes and content into the shared sys_sms_template library used for system, email, SMS and IM notifications, giving an integrity-only impact on the template store rather than host or data compromise. Publicly available exploit code exists (no CISA KEV confirmation of active exploitation), and our independent assessment scores this as a medium-severity authorization flaw (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N) that is not an urgent priority.
Any low-privileged authenticated user of JeecgBoot through 3.9.5 can overwrite shared Word document templates by sending PUT or POST requests to the /airag/word/edit endpoint, because the AigcWordTemplateController edit handler performs no authorization or ownership check. The impact is limited to integrity of shared templates used by other users for document generation - no data disclosure or service disruption - with an assessed severity of CVSS 3.1 5.3 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N). Publicly available exploit code exists (a proof-of-concept Python script published on GitHub), though there is no indication of confirmed active exploitation (no CISA KEV listing), and exploitation requires valid credentials plus a deployment where the AIRAG word-template feature is enabled and in use.
Authenticated JeecgBoot users running version 3.9.5 or earlier can delete other users' stored AI voice (text-to-speech) history by passing an arbitrary userId to the DELETE /airag/voice/deleteVoiceRecord endpoint, which trusts the client-supplied identifier instead of the caller's session identity. Victims' record IDs are easily enumerated from the ownership-unchecked GET /airag/voice/listByUser endpoint, and deletion proceeds one record per request against history held in Redis; a publicly available exploit script is referenced in the VulnCheck advisory. Impact is limited to unauthorized modification (loss) of voice records with no confidentiality or host availability impact, there is no CISA KEV listing, and any valid authenticated account, regardless of privilege level, is sufficient to exploit the flaw.
Authenticated users can delete other users' AI video generation records in JeecgBoot through 3.9.5 by exploiting an insecure direct object reference (IDOR) in the DELETE /airag/video/deleteVideoRecord endpoint, which accepts arbitrary userId values without ownership checks. Attackers can first retrieve record IDs from the unchecked GET /airag/video/listByUser endpoint, then delete victims' Redis-stored video history entries one record per request. Publicly available exploit code exists (no CISA KEV confirmation), and exploitation requires a valid authenticated account; impact is limited to integrity of video history records with no confidentiality or availability impact.
Missing authorization in JeecgBoot through 3.9.5 allows any authenticated low-privileged user to overwrite the global OCR/LLM prompt templates used by the AiRAG module by sending a PUT request to /airag/ocr/edit, writing attacker-controlled content into the shared airag:ocr Redis key and corrupting OCR output for every user of the instance. Exploitation requires only a valid low-privilege account (PR:L in the CVSS vector) and no user interaction, and publicly available exploit code exists; the issue is not listed as confirmed actively exploited (CISA KEV). The impact is confined to integrity tampering with shared prompt configuration - no data disclosure and no denial of service - which is consistent with the assessed CVSS:3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N and makes this a genuine but low-to-moderate priority issue.
Permanent deletion of other users' recycled AI prompt templates is possible in JeecgBoot through 3.9.5 because the AiragPromptsController deleteRecycleBin handler performs no authorization check. Any authenticated user - including the lowest-privileged account, since the assessed vector is PR:L - can issue a DELETE request carrying arbitrary prompt-template IDs and purge recycle-bin entries that belong to administrators or other tenants; no admin role, user interaction, or special configuration is needed beyond the AIRAG module being present. Publicly available exploit code exists (a PoC script targeting this endpoint), though there is no confirmed active exploitation (not in CISA KEV). Our independent assessment rates this as medium severity (CVSS:3.1 5.3, AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:L) and a low-real-world-priority issue: integrity-only impact confined to deletion of soft-deleted template records, with no confidentiality exposure, no code execution, and fully unauthenticated outsiders unable to exploit it.
Missing authorization in JeecgBoot through 3.9.5 allows any authenticated user, regardless of role, to delete administrator-created AI prompt templates through the deleteBatch handler of AiragPromptsController. The unguarded list endpoint lets a low-privileged attacker enumerate prompt IDs and feed them to deleteBatch, destroying templates belonging to admins or other tenants; exploitation requires only a valid account (CVSS vector PR:L) and no user interaction or elevated role. Publicly available exploit code exists (a PoC script targeting the deleteBatch endpoint has been published), but there is no confirmation of active exploitation in the wild, and the practical risk is concentrated in multi-tenant or self-registering deployments where low-privileged accounts coexist with administrator content.
Missing authorization in JeecgBoot 3.9.5 and earlier allows any authenticated low-privileged user to remove arbitrary users from any tenant's product pack by sending attacker-controlled userId and packId values to PUT /sys/tenant/deleteTenantPackUser, silently revoking assigned permissions such as tenant administrator access. Exploitation requires only a valid low-privileged account (PR:L per the assessed CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:L) on an instance running in multi-tenant mode with tenant product packs configured, and publicly available exploit code exists, though there is no confirmed active exploitation (CISA KEV). The impact is confined to integrity and availability of permission assignments - no confidentiality exposure and no code execution - making this a genuine but moderate-priority issue rather than a top-tier emergency.
JeecgBoot through 3.9.5 contains an authorization bypass (CWE-639) in the AIRAG video-generation module, where an authenticated low-privileged user can read other users' AI video-generation history by supplying an arbitrary userId to the getVideoRecords handler in VideoGenerationController. Publicly available exploit code exists, and the disclosed records include prompts, task IDs, video URLs, and cover URLs; however, there is no write access or broader compromise, and exploitation requires the AIRAG video feature to be deployed and the attacker to already hold a valid account. The issue is a moderate-severity information-disclosure bug (CVSS 4.0 5.3; independent CVSS 3.1 assessment 5.3) rather than a top-tier priority.
Improper authorization in Strapi 5.47.0 through 5.57.0 allows authenticated holders of pre-existing admin API tokens to retain all-field Content Manager read access after an administrator field-restricts the token owner's role, because the reconciliation routine skips token permissions whose field entries are omitted or null. Publicly available exploit code exists, but exploitation requires a valid admin API token and only exposes read access to content fields, with no write, integrity or availability impact. CISA KEV does not list this issue and the assessed severity is moderate (CVSS 3.1 5.3, AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N).
Authenticated partners in Immich through 3.3.1 can read metadata from assets stored in another user's Locked Folder - including GPS coordinates, capture times, descriptions and camera details - via the partner synchronization stream, because sync queries fail to exclude assets marked with Locked visibility. The attacker must already hold an active, victim-accepted partner relationship and be authenticated, and publicly available exploit code exists demonstrating the technique (no CISA KEV confirmation of active exploitation). Impact is confined to metadata disclosure of Locked Folder assets; image/video binaries, credentials, and data belonging to non-partnered users are not exposed, making this a moderate-severity information-disclosure issue rather than an emergency.
Missing authorization in JeecgBoot through 3.9.5 lets any authenticated low-privileged user read arbitrary users' role codes by sending GET requests to /sys/api/queryUserRoles with an arbitrary username parameter, allowing role-assignment discovery and identification of administrator accounts. The issue is tracked as CWE-862 (missing authorization) with an assessed CVSS of 5.3 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:N/C:L/I:N/A:N), requiring only a valid JeecgBoot account of any privilege level; impact is confined to information disclosure rather than write or execution capability. Publicly available exploit code exists for this endpoint, but there is no indication of confirmed active exploitation (CISA KEV); the endpoint is exploitable in default deployments with no special configuration, making the authentication requirement the primary limiting factor.
Missing authorization in the JeecgBoot SysAnnouncementController downLoadFiles handler lets any authenticated low-privileged user retrieve a ZIP of announcement attachments by supplying a valid announcement id, exposing files from unpublished announcements or announcements addressed only to other users. The flaw affects JeecgBoot through version 3.9.5 (CPE cpe:2.3:a:jeecgboot:jeecgboot:*), requires a valid non-admin account and knowledge or enumeration of an announcement id, and yields only confidentiality impact with no write, execution, or availability effect. Publicly available exploit code exists (a Python PoC script published on GitHub) but there is no confirmed active exploitation (not listed in CISA KEV), so this is a medium-severity information-disclosure issue rather than a critical priority.
Missing authorization in JeecgBoot through 3.9.5 allows any authenticated low-privileged user to read OpenAPI gateway definitions they are not entitled to see, exposing internal origin URLs, virtual paths, IP whitelists, and header and parameter templates. The flaw (CWE-862) lives in the OpenApiController queryById handler, which fails to enforce the openapi permission, so a simple GET /openapi/queryById with a valid entry id returns configuration metadata. It is a moderate-severity issue (CVSS 5.3, PR:L, confidentiality-only impact) for which publicly available exploit code exists, but there is no indication of confirmed active exploitation and the CVE is not in CISA KEV.
Missing authorization in JeecgBoot through 3.9.5 lets any authenticated user - including low-privileged accounts - download every user's stored AI prompts by calling the /airag/prompts/exportXls endpoint. The response is an Excel workbook exposing prompt content, model IDs, and parameters belonging to all users, a moderate-severity information disclosure rather than a critical code-execution issue. Publicly available exploit code exists (a PoC script targets this handler), though there is no confirmed evidence of active exploitation (no CISA KEV listing), and exploitation is gated solely on possession of any valid low-privilege session.
Missing authorization in JeecgBoot's AiRAG knowledge module lets low-privileged authenticated users read document text chunks from knowledge bases they do not own. The embeddingSearch handler in AiragKnowledgeController (GET /airag/knowledge/embedding/search) lacks Shiro permission annotations, so any valid account can pass arbitrary knowledge base IDs and retrieve indexed content belonging to other users or tenants. Exploitation is remote and requires authentication (CVSS:4.0 PR:L, assessed CVSS:3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N), impact is limited to confidentiality, and publicly available exploit code exists (a Python PoC targeting the data plane); no confirmed active exploitation has been reported. This is a genuine but moderate-severity issue, not a top-tier emergency.
JeecgBoot versions through 3.9.5 contain a missing authorization flaw in the AiragPromptsController that lets any authenticated user read AI prompt templates belonging to other users, including administrators. Attackers can enumerate prompt IDs through the unguarded /airag/prompts/list endpoint and then retrieve each template's text, model parameters, and creator details via queryById, resulting in unauthorized information disclosure. Publicly available exploit code exists, but the issue requires a valid account and the AIRAG module to be deployed, making it a modest-severity confidentiality risk rather than a critical one.
An authenticated low-privileged user on JeecgBoot through 3.9.5 can query any tenant's product-pack configuration by calling the SysTenantController listPackByTenantUserId handler with attacker-chosen tenantId and userId parameters, because that handler performs no authorization check on the caller's ownership of the requested tenant. The result is read-only disclosure - tenant pack settings plus the identities of users who are tenant administrators - which is useful for reconnaissance and privilege-mapping but causes no data modification or service disruption (CVSS 5.3 / CVSS:3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N). Publicly available exploit code exists in a GitHub proof-of-concept repository, and exploitation is meaningful only in multi-tenant deployments where other tenants exist to enumerate; there is no confirmation of active exploitation (CISA KEV) at time of analysis.
Missing authorization in JeecgBoot's SysTenantController queryTenantAuthInfo handler (all versions through 3.9.5) allows any authenticated, low-privileged user to enumerate small integer tenant IDs and read other tenants' full sys_tenant records, including house numbers used as tenant join codes and company profile fields. Exploitation requires a valid authenticated account (CVSS vector PR:L) on a multi-tenant deployment where other tenants' records exist; publicly available exploit code exists, but there is no confirmation of active exploitation. The impact is limited to read-only information disclosure (CVSS 5.3, assessed as C:L/I:N/A:N), making this a moderate access-control issue rather than a high-urgency flaw.
Information disclosure in JeecgBoot through 3.9.5 allows any authenticated low-privileged user to read tenant administrator applications for any tenant by iterating the tenantId parameter on the /sys/tenant/getTenantPackApplyUsers endpoint. Public exploit code exists, but exploitation requires a valid account and a multi-tenant deployment with pending applicants; the impact is limited to read-only disclosure of applicant PII (usernames, real names, phone numbers, departments) with no write or availability effect. This medium-severity issue is confirmed by an independent assessment as an information-disclosure flaw, not a critical priority.
Missing authorization in JeecgBoot through 3.9.5 lets any authenticated, low-privileged user send spoofed template announcements by POSTing to /sys/api/sendTemplateAnnouncement with attacker-chosen sender, recipient, title, and template parameters, so the resulting messages appear to come from admin or system accounts. Rated 5.3 (medium), the issue carries only low integrity impact with no confidentiality or availability effect and no path to code execution, and it requires the attacker to already hold a valid JeecgBoot session. Publicly available exploit code exists (VulnCheck-reported POC plus a GitHub PoC script), though there is no indication of confirmed active exploitation.
JeecgBoot through 3.9.5 allows any authenticated low-privileged user to send spoofed system announcements via the /sys/api/sendBusAnnouncement endpoint because SystemApiController does not enforce the required permission check. An attacker can forge the sender, recipients, title, and content to impersonate administrators or the system, enabling phishing against other users. No code execution, data disclosure, or service disruption is possible, and publicly available exploit code exists; this is a low-severity authorization flaw rather than a remotely exploitable unauthenticated compromise.
Missing authorization in the SysAnnouncementController editIzTop handler of JeecgBoot through 3.9.5 allows any authenticated user at a low privilege level to pin or unpin system-wide announcements by sending a POST or PUT request carrying an arbitrary announcement id. The root cause is a pure access-control failure (CWE-862), not a memory or injection flaw, so the practical impact is limited to tampering with the pinned-notice banner displayed to all users, with no data disclosure, code execution, or service disruption. Publicly available exploit code exists and the issue was reported by VulnCheck, but the assessed severity is modest (CVSS 3.1 score 5.3, PR:L) because an attacker must already hold valid credentials and the resulting integrity change is low.
Missing authorization in JeecgBoot's AIRAG prompts module (through version 3.9.5) lets any authenticated, low-privileged user invoke the promptExperiment handler in AiragPromptsController and launch AI prompt evaluation runs against prompt templates and datasets that belong to other users. Because the handler performs no ownership or permission check on the supplied prompt-template and dataset IDs, an attacker who can enumerate or guess those identifiers can write result rows into the airag_ext_data table and alter dataset status, an integrity-only impact with no confidentiality or availability loss. Exploitation requires a valid low-privileged account plus an instance where the AIRAG module is deployed with a working LLM backend; publicly available exploit code exists, but there is no confirmed active exploitation (no CISA KEV listing) and the issue is rated moderate rather than critical.
Missing authorization in JeecgBoot through 3.9.5 allows a low-privileged authenticated user to undo administrator deletions of AI prompt templates by sending crafted PUT requests to the /airag/prompts/revertRecycleBin endpoint with chosen template IDs, clearing the deleted flag and returning them to active use. Because the endpoint performs no permission check, any account with a valid session - not just an administrator - can restore recycled content; publicly available exploit code exists, though exploitation still requires credentials (CVSS PR:L) and knowledge of valid deleted-template IDs, and the impact is limited to an integrity change on prompt template records with no confidentiality or availability effect. Per our independent assessment this is a genuinely low-severity, low-priority issue: it is not exploitable by unauthenticated attackers, requires no user interaction, and cannot be used to read data, escalate privileges, or disrupt the platform.
Tampering with AI prompt templates in JeecgBoot through 3.9.5 is possible for any authenticated user due to missing authorization in the AiragPromptsController edit handler. A low-privileged attacker can send PUT or POST requests to /airag/prompts/edit with a target template id to overwrite prompt text and model parameters created by administrators or other users, resulting in integrity-only impact. Publicly available exploit code exists, though no active exploitation has been confirmed; CVSS 5.3 (medium).
Missing authorization in JeecgBoot through 3.9.5 lets any authenticated, low-privileged user delete pending tenant-administrator applications belonging to other tenants via the SysTenantController deleteApply handler, which also sends rejection notifications to the affected applicants. Publicly available exploit code exists, though exploitation requires a valid low-privileged account plus valid or enumerable tenantId, packId and userId values for a pending application. Impact is limited to integrity of the tenant-onboarding workflow with no data disclosure or service outage, making this a genuine but moderate issue rather than a top-priority one.
Missing authorization in JeecgBoot (all versions through 3.9.5) lets any authenticated, low-privileged user alter tenant administrator application status for arbitrary tenants by sending a PUT request to /sys/tenant/updateApplyStatus with a tenant id they do not own. The endpoint performs no ownership or role check on the supplied identifier, so an ordinary account - including one obtained through self-registration - can toggle the applyStatus field and thereby enable or disable tenant-admin applications across the entire instance. Publicly available exploit code exists (a Python PoC is published in a public GitHub repository), though this is not confirmed as actively exploited in the wild; EPSS and KEV data were not provided, and the independent assessment rates this as a moderate-severity broken access control issue with limited blast radius, since impact is confined to status toggling rather than full tenant takeover.