A deserialization of untrusted data vulnerability (CWE-502) exists in OpenAM's WebAuthn authentication module, affecting versions prior to 16.1.1. Exploitation requires that an attacker can write attacker-controlled data to a storage attribute read by the WebAuthn module, which is not the default configuration but possible in some deployments. Successful exploitation allows arbitrary code execution as the application server user. The issue is patched in OpenAM Community Edition version 16.1.1.
ACE vulnerability in conditional configuration file processing by QOS.CH logback-core up to and including version 1.5.36 in Java applications, allows an attacker to execute arbitrary code circumventing existing protections against CVE-2025-11226 by compromising an existing logback configuration file or by injecting an environment variable before program execution.
A successful attack requires the presence of Janino library to be present on the user's class path. In addition, the attacker must have write access to a
configuration file. Alternatively, the attacker could inject a malicious
environment variable pointing to a malicious configuration file. In both
cases, the attack requires existing privilege.
Please note that in logack version 1.5.37 conditional processing using Janino was removed.
Multiple security vulnerabilities have been identified in the FasterXML Jackson library, a widely used open-source JSON processing library for Java. These include security bypasses that allow arbitrary code execution, information disclosure, and data manipulation via various bypasses and improper handling of properties. The vulnerabilities are addressed in version 5.36.00.16. Red Hat has issued security advisories for related products including Red Hat Build of Apache Camel and Red Hat build of Quarkus, which include fixes for these Jackson vulnerabilities along with other related issues. The overall security impact is rated as Important by Red Hat.
## Vulnerability
`ZooKeeperReplicationConfig.secret()` silently substitutes the hard-coded constant `"ch4n63m3"` (leetspeak for "change me") whenever the operator omits `replication.secret`. The same secret is wired into both the **client-facing SASL context** and the **quorum/learner SASL contexts** of the embedded ZooKeeper. The constant is in OSS source on GitHub and is discoverable via code search in seconds.
### Three Reinforcing Defects
1. **OSS-public credential** — `DEFAULT_SECRET` is in `line/centraldogma` source.
2. **Silent fallback** — `firstNonNull(convertValue(...), DEFAULT_SECRET)` substitutes the default with no log, no warning, no startup banner. The only sanity check `checkArgument(!secret().isEmpty(), ...)` passes because the getter substitutes the literal before the emptiness check runs.
3. **Dual-purpose secret** — used for both ZK client-port super auth and inter-peer quorum SASL. A single leaked password authenticates against both surfaces.
### Architecture Context (Important)
Central Dogma does **NOT** connect to an external ZooKeeper ensemble. Each replica embeds a `QuorumPeer` (`EmbeddedZooKeeper extends QuorumPeer`) inside its own JVM. The Central Dogma cluster **IS** the ZK ensemble. So the "ZK network" is the inter-replica network of the Central Dogma cluster itself.
### Applicability
| `replication.method` | ZK Started? | Applicable? |
|---|---|---|
| `NONE` (standalone, dev default) | No | **NOT applicable** |
| `ZOOKEEPER` (HA production) | Yes, embedded on every replica | **Fully applicable** — canonical production configuration |
---
## Evidence
**File:** `server/src/main/java/com/linecorp/centraldogma/server/ZooKeeperReplicationConfig.java`
**Branch:** `main` @ commit `d64a5151`
**Line 53** — the constant:
```java
private static final String DEFAULT_SECRET = "ch4n63m3";
```
**Lines 210–215** — the silent fallback:
```java
/**
* Returns the secret string used for authenticating the ZooKeeper peers.
*/
public String secret() {
return firstNonNull(convertValue(secret, "replication.secret"), DEFAULT_SECRET);
}
```
---
**File:** `server/src/main/java/com/linecorp/centraldogma/server/internal/replication/ZooKeeperCommandExecutor.java`
**Lines 586–607** — JAAS wiring (same secret on both surfaces):
```java
final String escapedSecret = jaasValueEscaper.escape(cfg.secret());
ImmutableList.of("Server", EmbeddedZooKeeper.SASL_SERVER_LOGIN_CONTEXT).forEach(name -> {
buf.append(name).append(" {").append(newline);
buf.append(DigestLoginModule.class.getName()).append(" required").append(newline);
buf.append("user_super=\"").append(escapedSecret).append("\";").append(newline);
buf.append("};").append(newline);
});
ImmutableList.of("Client", EmbeddedZooKeeper.SASL_LEARNER_LOGIN_CONTEXT).forEach(name -> {
buf.append(name).append(" {").append(newline);
buf.append(DigestLoginModule.class.getName()).append(" required").append(newline);
buf.append("username=\"super\"").append(newline);
buf.append("password=\"").append(escapedSecret).append("\";").append(newline);
buf.append("};").append(newline);
});
```
---
**File:** `server/src/main/java/com/linecorp/centraldogma/server/internal/replication/EmbeddedZooKeeper.java`
**Line 44** — proves CD embeds the ZK server:
```java
final class EmbeddedZooKeeper extends QuorumPeer {
```
**Lines 213–220** — client port binding (loopback only):
```java
private static ServerCnxnFactory createCnxnFactory(QuorumPeerConfig zkCfg) throws IOException {
final InetSocketAddress bindAddr = zkCfg.getClientPortAddress();
final ServerCnxnFactory cnxnFactory = ServerCnxnFactory.createFactory();
// Listen only on 127.0.0.1 because we do not want to expose ZooKeeper to others.
cnxnFactory.configure(new InetSocketAddress("127.0.0.1", bindAddr != null ? bindAddr.getPort() : 0),
zkCfg.getMaxClientCnxns());
return cnxnFactory;
}
```
> Quorum/election ports are **NOT** loopback-bound — they bind to `replication.servers[].host` as configured, exposed on the inter-replica network.
---
## PoC
Two attack surfaces, two scenarios. **Surface A** (client port, same-host) is implemented as a working read-only PoC. **Surface B** (quorum-port peer impersonation) is documented but intentionally not weaponized.
### Surface A — Same-Host Client Port (Loopback) PoC
Python + kazoo + pure-sasl. Authenticates as `super` over SASL DIGEST-MD5 with the leaked secret and reads the full Central Dogma replication log. Hardcoded to `127.0.0.1`, read-only, prints first 5 entries.
```python
#!/usr/bin/env python3
"""
C3 PoC -- ZooKeeper default-secret takeover (read-only, loopback only).
Demonstrates that a Central Dogma instance launched with a
ZooKeeper-replicated configuration but without `replication.secret` set
exposes its embedded ZooKeeper to anyone with local-host access, using
the well-known credential `super / ch4n63m3`.
SAFETY:
* Hardcoded to 127.0.0.1. Refuses any other targ
In setAllowedCarriers of PhoneInterfaceManager.java, there is a possible way to disable carrier restrictions due to a logic error in the code. This could lead to local escalation of privilege with no additional execution privileges needed. User interaction is not needed for exploitation.
In MmsSmsProvider of MmsSmsProvider.java, there is a possible way to retrieve sensitive information due to a missing permission check. This could lead to local information disclosure with no additional execution privileges needed. User interaction is not needed for exploitation.
In tryStartActivity of NfcDispatcher.java, there is a possible automatic special app access permission assignment due to an insecure default value. This could lead to local escalation of privilege with no additional execution privileges needed. User interaction is not needed for exploitation.
In createSessionInternal of PackageInstallerService.java, there is a possible method to remove a DPC app from a managed device without DO consent due to desync from persistence. This could lead to local escalation of privilege if a user can install a malicious app with no additional execution privileges needed. User interaction is needed for exploitation.
In overrideConfig of CarrierConfigLoader.java, there is a possible way to bypass UID check due to a permissions bypass. This could lead to local escalation of privilege with no additional execution privileges needed. User interaction is not needed for exploitation.
Microsoft has patched an actively exploited Exchange Server vulnerability that allows threat actors to execute arbitrary JavaScript code in cross-site scripting (XSS) attacks targeting Outlook Web Access users. [...]
OpenClinic GA 5.351.19 contains a reflected cross-site scripting vulnerability in the DICOM image upload handler that allows attackers to execute arbitrary JavaScript in a victim's browser by embedding malicious payloads in DICOM file metadata fields. Attackers can craft a DICOM file with JavaScript payloads in metadata fields such as Study Description, which are reflected without sanitization in popup.jsp and archiving/uploadfiles_jsp.java when processed through the Upload DICOM images feature.
CVE-2026-44746 is a reflected cross-site scripting (XSS) vulnerability in the SAP NetWeaver AS Java JDBC Test Servlet. An unauthenticated attacker can craft a malicious URL that, when visited by a victim, causes execution of injected script code in the victim's browser. This impacts the confidentiality and integrity of the web client data but does not affect availability. The vulnerability requires user interaction (clicking the crafted link) and has a medium severity rating with a CVSS score of 6.1.
The AsyncHttpClient (AHC) library allows Java applications to easily execute HTTP requests and asynchronously process HTTP responses. Versions on the 2.x branch prior to 2.15.0 and the 3.x branch prior to 3.0.10 leak `Cookie` headers to cross-origin redirect targets. When following a redirect to a different origin, the `propagatedHeaders()` method in `Redirect30xInterceptor.java` strips `Authorization` and `Proxy-Authorization` headers but does not strip the `Cookie` header, causing session cookies and other sensitive cookie values to be sent to attacker-controlled servers. Versions 2.15.0 and 3.0.10 patch the issue.
A vulnerability was found in crmeb crmeb_java 1.4. Affected is the function RestTemplate.getForEntity of the file crmeb-common/src/main/java/com/zbkj/common/utils/RestTemplateUtil.java of the component base64 Qrcode Endpoint. The manipulation of the argument url results in server-side request forgery. The attack can be executed remotely. The exploit has been made public and could be used. The project was informed of the problem early through an issue report but has not responded yet.
alf.io is an open source ticket reservation system for conferences, trade shows, workshops, and meetups. Prior to version 2.0-M5-2606, a sandbox escape vulnerability in the alf.io extension script engine allows an authenticated administrator to execute arbitrary operating system commands on the server. The extension system is intended to execute restricted JavaScript in a sandboxed Rhino environment; however, a combination of an unguarded injected Java object (`returnClass`) and an incomplete AST blocklist allows the sandbox to be fully escaped using Java reflection without triggering any validation errors. Version 2.0-M5-2606 patches the issue.
CVE-2026-10567 is a cross-site scripting (XSS) vulnerability in 1Panel-dev CordysCRM affecting versions up to 1.4.1. The issue occurs in the Save function of the ModuleFormService.java file, where manipulation of the Description argument allows remote attackers to execute XSS attacks. The vulnerability has a medium severity score of 5.1. Upgrading to version 1.7.0 resolves the issue.
CVE-2026-10550 is a command injection vulnerability in elunez eladmin affecting versions 2.0 through 2.7. The issue arises from unsafe manipulation of the uploadPath argument in the Application Deployment Module's App.java file. This flaw allows remote attackers to execute arbitrary commands. The vulnerability has a medium severity rating with a CVSS 4.0 score of 5.3. No official patch or remediation has been announced by the vendor as of the publication date.
CVE-2026-28586 is a vulnerability in multiple functions of AppOpsService.java where a missing permission check allows a permissions bypass. This flaw can lead to local information disclosure without requiring additional execution privileges or user interaction. The vulnerability has a low CVSS score of 3.3, indicating limited impact primarily on confidentiality.
A logic error in multiple functions of ComputerEngine.java allows access to URIs across users, leading to local privilege escalation without requiring additional execution privileges or user interaction. The vulnerability has a medium severity rating with a CVSS score of 5.9.
CVE-2026-10529 is a medium severity cross-site scripting (XSS) vulnerability in westboy CicadasCMS, specifically in an unknown function within the Task Scheduling Management Module (ScheduleJobController.java). The vulnerability allows remote attackers to execute XSS attacks by manipulating input. The product uses a rolling release model, so exact affected or fixed versions are not clearly defined. No official patch or remediation has been provided by the vendor as of the publication date. Exploit code is publicly available, but no known widespread exploitation has been reported.