Chess Hazlett

A script injection vulnerability was found in the Debezium database connector, where it does not properly sanitize some parameters. This flaw allows an attacker to send a malicious request to inject a parameter that may allow the viewing of unauthorized data.

A flaw was found in Keycloak due to improperly enforcing token types when validating signatures locally. This could allow an authenticated attacker to exchange a logout token for an access token and possibly gain access to data outside of enforced permissions.

A flaw was found in the client step-up authentication mechanism, where it does not correctly validate authentication. This allows a remote user authenticated with a password to register a false second authentication factor alongside an existing one, bypassing authentication. The issue is related to the `org.keycloak.authentication` module.

A flaw was found in the Undertow package, allowing a malicious user to trigger a Denial of Service by sending crafted requests, leading the server to an Out-of-Memory error, exhausting the server's memory. The vulnerability exists due to insufficient input validation. Exploitation of the vulnerability may allow a remote attacker to cause a denial of service.

A flaw was found in the software, which does not detect circular object references when unmarshalling. An authenticated attacker with sufficient permissions could insert a maliciously constructed object into the cache and use it to cause out of memory errors and achieve a denial of service.

A flaw was found in Keycloak that prevents certain schemes in redirects, but permits them if a wildcard is appended to the token. This issue could allow an attacker to submit a specially crafted request leading to cross-site scripting (XSS) or further attacks. The flaw is the result of an incomplete fix for a previous issue.

An improper initialization issue was found in Galleon. When using Galleon to provision custom EAP or EAP-XP servers, the servers are created unsecured. This could allow an attacker to access remote HTTP services available from the server.

The issue is related to the incorrect implementation of the sequence of actions in the Quarkus Java framework's WebSocket technology, resulting from insufficient access restriction when processing GraphQL requests. This can allow a remote attacker to gain unauthorized access to protected information and elevate their privileges. The problem occurs when a request is received over WebSocket with no role-based permission specified on the GraphQL operation, and Quarkus processes the request without authentication despite the endpoint being secured.

A flaw was found in Quarkus, where it does not properly sanitize artifacts created using the Gradle plugin, allowing certain build system information to remain. This flaw allows an attacker to access potentially sensitive information from the build system within the application. The vulnerability is related to the disclosure of information through environment variables.

A flaw was found in Red Hat's AMQ Broker, which stores certain passwords in a secret security-properties-prop-module, defined in ActivemqArtemisSecurity CR. However, these passwords are shown in plaintext in the StatefulSet details yaml of AMQ Broker.

A flaw was found in Red Hat AMQ Broker Operator, where it displayed a password defined in ActiveMQArtemisAddress CR, shown in plain text in the Operator Log. This flaw allows an authenticated local attacker to access information outside of their permissions.

A flaw in the Skupper operator may allow an authenticated attacker in an adjacent cluster to view deployments in all namespaces, permitting unauthorized access to information outside of the user's purview. The issue is related to inadequate access control, which can be exploited to gain unauthorized access to protected information.

A flaw was found in Quarkus where HTTP security policies are not sanitizing certain character permutations correctly when accepting requests, resulting in incorrect evaluation of permissions. This issue could allow an attacker to bypass the security policy altogether, resulting in unauthorized endpoint access and possibly a denial of service.

The issue is related to the improper implementation of security checks for standard elements in Keycloak, a software tool for identity and access management. This can allow a remote attacker to gain unauthorized access to protected information. Specifically, Keycloak's device authorization grant does not correctly validate the `device code` and `client ID`. An attacker client could abuse this missing validation to spoof a client consent request, potentially tricking an authorization admin into granting consent to a malicious OAuth client or allowing unauthorized access to an existing OAuth client. Under certain conditions, the vulnerability enables an attacker to spoof parts of the device flow and use a `device code` to retrieve an access token for other OAuth clients.

A flaw was found in Keycloak where a server configured to support mTLS authentication for OAuth/OpenID clients does not properly verify the client certificate chain. This allows a client with a proper certificate to authorize itself as any other client, accessing data belonging to other clients. The issue is related to errors in the certificate verification procedure, which can be exploited by a remote attacker to impact the confidentiality and integrity of protected information.

A flaw was found in EAP-7 during deserialization of certain classes, which permits instantiation of HashMap and HashTable with no checks on resources consumed. This issue could allow an attacker to submit malicious requests using these classes, which could eventually exhaust the heap and result in a Denial of Service. The vulnerability is related to the deserialization of untrusted data, which can be exploited by a remote attacker to cause a denial of service by sending specially crafted requests.

A flaw was found in Red Hat Single Sign-On for OpenShift container images, which are configured with an unsecured management interface enabled. This flaw allows an attacker to use this interface to deploy malicious code and access and modify potentially sensitive information in the app server configuration. The issue is related to the default access control settings of the Keycloak identity and access management tool, which can be exploited by a remote attacker to execute arbitrary code.

A flaw was found in Drools core where some utility classes did not use proper safeguards when deserializing data. This allows an authenticated attacker to construct malicious serialized objects, usually called gadgets, and achieve code execution on the server. The vulnerability is related to the restoration of untrusted data in memory, which can be exploited by a remote attacker to execute arbitrary code.

The issue arises from inadequate sanitation of user input in multiple fields, allowing an authenticated user to inject scripts. This could potentially lead to access to sensitive information or further attacks.

The smallrye health metrics UI component did not properly sanitize some user inputs, allowing an attacker to conduct cross-site scripting attacks.