Arpitjain099

On JRuby, the `NONET` parse option fails to block external DTDs or entities when the system identifier uses a short-form IPv4 host (e.g., `http://127.1/`) or an absolute path (e.g., `/x.dtd`) resolved against a network URL. When an application parses untrusted XML using `DTDLOAD`, `DTDVALID`, or `NOENT`, the resolver may treat these identifiers as local and initiate a network request, potentially enabling server-side request forgery (SSRF), which is a technique used to induce a server to make requests to an unintended location.

An authorization flaw exists in the FHIR implementation where certain read routes skip Access Control List (ACL) checks. This allows users with non-patient API tokens that lack OpenEMR ACLs to request resources using a `uuid`, bypassing compartment filtering. Consequently, an attacker can read documents and questionnaire responses belonging to any patient via the '/FHIR Media/:uuid' and '/QuestionnaireResponse' endpoints.

An insecure direct object reference occurs in multiple encounter-form view and save endpoints due to a lack of patient or encounter ownership verification. Authenticated clinical users can enumerate sequential form ID values in requests to the 'soap/view.php' and 'save.php' endpoints to read and overwrite clinical records belonging to other patients.

An SQL injection issue exists in the Fee Sheet drug-inventory lookup within the `sellDrug()` function of the `DrugSalesService` class. The flaw occurs when the `prod[N][warehouse]` POST field is interpolated into an ORDER BY clause. Low-privileged authenticated users can exploit this by submitting Fee Sheet product lines containing constant subqueries to perform a time-based blind oracle attack, allowing the extraction of patient data and `users secure` bcrypt hashes.

The HTTP-Redirect binding decoder decompresses SAML messages provided by an attacker without limiting the output size before signature validation. This allows an unauthenticated remote attacker to exhaust server memory, leading to a denial of service.

The `Untar` function in `pkg/archive/archive.go` validates absolute tar symlink targets after rebasing them beneath a destination, but creates the symlink using the raw absolute `Linkname`. This allows a crafted archive to plant a host-absolute symlink and use a subsequent regular-file entry to write files outside the extraction directory. This issue is reachable via remote add-on retrieval and database or file imports. Overwriting shell startup files, Git hooks, or cron entries can result in code execution within the context of the DDEV user.

The `DataSourcePolicy` fails to resolve symbolic links when checking filename containment. This allows a compromised or semi-trusted xDS control plane to force the xDS client to read files located outside the configured allowed root directories if a symbolic link within an allowed directory points to an external location. In environments utilizing a credential injector, this could lead to the exposure of header-compatible text secrets to an attacker-observable upstream.

The `dagu read` operation with target `dag spec` invokes the DAG specification API directly, bypassing the HTTP middleware. Because the underlying resolver does not restrict resolved paths to configured DAG directories, an authenticated attacker with a viewer-role API key can use absolute or traversing paths to read `.yaml` or `.yml` files outside the intended directories that are accessible to the Dagu process. This issue allows for unauthorized file reading but does not provide write or execution capabilities.

An authentication bypass exists in the `matchCertificateData` function. This issue occurs when a signing certificate lacks a Subject Alternative Name (SAN), causing the system to skip `verifyImages` subject and `subjectRegExp` checks. An attacker possessing a leaf certificate from a configured private trust root can omit the SAN and set the expected Fulcio issuer OID to sign malicious images, which are then admitted despite signer pinning.

The TLS client in this native JavaScript implementation of Transport Layer Security incorrectly checks the property used to determine if a server certificate is missing. When using `forge.tls.createConnection()`, `c.session.serverCertificate`, and RSA key exchange, a malicious TLS server or on-path peer can omit the Certificate message. This leads to the dereferencing of the absent certificate, resulting in an uncaught exception that terminates the connection or the process.

The `RegistryClient.signIn()` method in `packages/oci/src/registry.ts` stores registry Authorization and Docker configuration headers as defaults on a shared HTTP client. Simultaneously, the `RegistryClient.uploadBlob()` function sends a PUT request to an absolute blob-upload Location provided by the registry without verifying if the origin or scheme matches the registry. Consequently, a compromised registry can redirect a user pushing an artifact via `attachArtifactToImage()` to an attacker-controlled host, leading to the leak of registry bearer tokens, Basic credentials, or custom authentication headers. This occurs because the cross-host PUT is treated as a new explicit request, bypassing redirect-time header stripping.

Forge (also known as node-forge) is a native JavaScript implementation of Transport Layer Security. The `asn1.fromDer()` function fails to consistently apply the `maxDepth` limit when decoding ASN.1 data stored within BIT STRING values, recursively retaining copies at each nesting level. An attacker can provide a specially crafted DER (Distinguished Encoding Rules) containing nested BIT STRINGs to trigger excessive recursion, high CPU utilization, and quadratic memory consumption.

pyLoad fails to invalidate active Flask sessions when an administrator modifies a user's password or permissions. This occurs because the system uses role and permission values copied into the session during login via the `set session()` function in `webui/app/helpers.py`, rather than verifying them against the database for every request. Consequently, a user may retain revoked privileges or maintain access using a session established with an old password for the duration of the session lifetime, which defaults to 44640 minutes. This issue is triggered when using the following API endpoints: - '/api/set user permission' - '/api/change password' Authentication via API keys is not affected as it retrieves user data directly from the database for each request.

An information disclosure issue exists where GraphQL validation error messages reveal hidden class names even when public introspection is disabled. Unauthenticated attackers with the public Application Id can send crafted operations to trigger unknown-argument or invalid enum value errors, allowing them to discover pointer and relation target classes.

An issue exists where the `get-page` RPC (Remote Procedure Call) accepts a share-link permission object providing broad read access but fails to verify if the requested `page-id` is among the pages authorized by the link. An authenticated attacker possessing a valid share link can retrieve the full shape and design data of other pages within the same file if the page identifier is known. Additionally, the `get-file-fragment` RPC allows share-link access without properly mapping fragments to authorized pages.

The OAuth2 Provider PKCE enforcement is only applied to authorization requests where the `response type` is exactly code. Consequently, codes issued via OpenID Connect hybrid flows (such as `code token`, `code id token`, or `code token id token`) are not bound to a challenge. This allows an attacker who intercepts such a code to redeem it for tokens of a public client using any non-empty `code verifier`. PKCE (Proof Key for Code Exchange) is a security extension used to prevent authorization code injection attacks.

A server-side request forgery (SSRF) issue exists where attackers with permissions to register or modify OAuth 2.0 clients can force the server to fetch internal resources. This occurs through the use of an unvalidated `jwks uri` variable. By leveraging client-authentication and ID-token validation, unauthenticated fetches can be triggered to probe internal hosts, metadata endpoints, or local files, or to cause a denial of service by exhausting request threads.

An improper authorization issue exists where delegated administrators can destroy sessions outside their assigned realms. This occurs because realm checks are performed using the requester's realm rather than the target session's realm. Authenticated accounts possessing the `iplanet-am-session-destroy-sessions` attribute can provide a target session identifier or handle to forcibly log out users across any realm.

A cross-site request forgery (CSRF) issue exists in the filemanager page handler. The system deletes page attachments via GET requests without validating a CSRF token—a unique token used to verify that a request was intentionally sent by the user. An attacker can trick an authenticated page owner or administrator into performing a top-level GET navigation using the `do` parameter with values such as `del`, `erase`, or `emptytrash`, resulting in the deletion or permanent purging of page attachments.

An authentication bypass exists in the ActivityPub inbox due to a failure to bind the verified HTTP signature signer to the activity actor. This allows unauthenticated attackers possessing any ActivityPub keypair to send signed Delete or Update activities. By referencing a mirrored entry's `sourceUrl`, an attacker can delete or overwrite federated entries belonging to other actors.