A critical deserialization of untrusted data vulnerability (CVE-2026-93941) exists in ThemeREX Group Edema, allowing object injection. This affects versions up to 1.2.2.2. The vulnerability has a CVSS score of 9.8, indicating high severity with network attack vector, no privileges or user interaction required, and impacts confidentiality, integrity, and availability.
CVE-2026-93938 is a critical vulnerability in ThemeREX Group's Hogwords product that allows deserialization of untrusted data leading to object injection. This flaw affects versions from 0 up to and including 1.2.7. The vulnerability has a high CVSS score of 9.8, indicating it can be exploited remotely without privileges or user interaction, resulting in complete confidentiality, integrity, and availability compromise.
A critical deserialization of untrusted data vulnerability (CWE-502) exists in ThemeREX Group's Let's Play playhockey plugin, allowing object injection. This affects versions up to and including 1.1.15. The vulnerability has a high CVSS score of 9.8, indicating it can be exploited remotely without privileges or user interaction, resulting in complete confidentiality, integrity, and availability compromise.
CVE-2026-93934 is a critical deserialization of untrusted data vulnerability in ThemeREX Group's Partiso product. It allows object injection and affects versions from 0 up to and including 1.1.13. The vulnerability has a high CVSS score of 9.8, indicating it can be exploited remotely without privileges or user interaction, leading to full confidentiality, integrity, and availability compromise.
CVE-2026-93933 is a critical deserialization of untrusted data vulnerability in ThemeREX Group's Rosalinda product, affecting versions up to 1.2.4. This flaw allows object injection, potentially leading to full compromise of confidentiality, integrity, and availability without requiring user interaction or privileges.
CVE-2026-93932 is a critical vulnerability in ThemeREX Group's Smart Casa product that allows deserialization of untrusted data, leading to object injection. This vulnerability affects versions from 0 up to and including 1.0.12. It has a high CVSS score of 9.8, indicating severe impact on confidentiality, integrity, and availability without requiring user interaction or privileges.
CVE-2026-93931 is a critical deserialization of untrusted data vulnerability in ThemeREX Group's Smash product. It allows object injection, potentially leading to full compromise of confidentiality, integrity, and availability. The issue affects Smash versions from initial releases up to and including 1.12.0. The vulnerability has a CVSS score of 9.8, indicating a high severity with network attack vector and no required privileges or user interaction.
A critical deserialization of untrusted data vulnerability (CVE-2026-93929) exists in ThemeREX Group Travesia travesia versions up to 1.1.16. This vulnerability allows object injection, which can lead to complete compromise of confidentiality, integrity, and availability. The vulnerability has a CVSS score of 9.8, indicating a high severity with network attack vector, no privileges or user interaction required. No patch or remediation information is currently provided.
The FBI arrested Edward Dubrovsky, co-founder of a Canadian cybersecurity firm specializing in ransomware negotiation, on charges related to assisting the ShinyHunters hacking group. ShinyHunters is known for using phishing and stolen credentials to steal data from software-as-a-service companies and extorting victims by threatening to publish stolen data. Dubrovsky faces charges including conspiracy to threaten confidentiality with intent to extort and interference with commerce by threats. The investigation has centralized in the FBI's Eastern District of Texas, the hub for ShinyHunters-related cases. Dubrovsky authored a book on ransomware negotiation strategies. The case is ongoing with several documents sealed, and further charges against other ransomware negotiation firms may follow.
Ransomware threat actors are shifting tactics away from encrypting data to extorting victims through data theft and demonstrating access by hijacking Active Directory environments. The PAYLOAD campaign exemplifies this trend by using malicious Group Policy Objects to display ransom notes and lock screens without encrypting files. This shift is driven by the increasing difficulty attackers face in collecting ransom payments due to widespread backup practices and the complexity of decrypting large-scale infections. Instead, attackers steal confidential data and threaten publication, which can cause reputational damage and regulatory penalties. Data exfiltration is also harder to detect than encryption-based attacks, making it a more attractive method for extortion. Businesses are advised to maintain strong cyber hygiene, including regular backups, patch management, endpoint protection, and access control to mitigate these evolving extortion threats.
## Summary
Incomplete fix of GHSA-5v7c-xpfp-p65m: the secure-session (OTP step-up) requirement added to the nginx, cert, dns, backup, site, and stream mutation routers was not applied to the parallel api/cluster router, so cluster node management and cluster-wide nginx reload/restart run with only a JWT and no step-up. An authenticated user whose JWT is stolen or persisted, but who does not hold a fresh secure-session, can perform cluster node CRUD (including reading and rewriting a node token secret) and trigger cluster-wide nginx reload/restart. Confirmed at HEAD 2cb7ee9102c9d87274de2fa104db804841d140a0.
## The defect
GHSA-5v7c-xpfp-p65m required a fresh secure session (an OTP step-up beyond the JWT) for sensitive mutation routes. The fix wrapped the nginx, cert, dns, backup, site, and stream mutation handlers in middleware.RequireSecureSession() and added reload/restart to the MCP sensitive-tool list. It did not touch the physically separate api/cluster package, whose router registers the same class of sensitive operations on the bare authenticated group.
The fixed sibling, api/nginx/router.go:
```go
o := r.Group("", middleware.RequireSecureSession()) // line 28
{
o.POST("nginx/reload", Reload) // line 30
o.POST("nginx/restart", Restart) // line 31
}
```
The missed router, api/cluster/router.go, registers every sensitive operation directly on r with no RequireSecureSession wrapper:
```go
nodeGroup := r.Group("nodes") // line 9, no step-up
{
nodeGroup.POST("", AddNode) // line 12
nodeGroup.POST("/:id", EditNode) // line 13
nodeGroup.DELETE("/:id", DeleteNode) // line 14
}
r.POST("nodes/reload_nginx", ReloadNginx) // line 17
r.POST("nodes/restart_nginx", RestartNginx) // line 18
r.POST("namespaces", AddNamespace) // line 22
r.POST("namespaces/:id", ModifyNamespace) // line 23
r.DELETE("namespaces/:id", DeleteNamespace) // line 24
```
Both routers mount on the same group in router/routers.go: `g := root.Group("/", middleware.AuthRequired(), middleware.Proxy())` (line 87); nginx.InitRouter(g) creates its own RequireSecureSession subgroup, cluster.InitRouter(g) does not. So the cluster routes inherit only AuthRequired and Proxy, exactly the pre-fix posture the advisory closed for the nginx routes. AuthRequired has no role gate, so any authenticated user reaches them.
## Attacker model and impact
An authenticated, OTP-enabled user who does not present a fresh X-Secure-Session-ID (the parent advisory's model: a stolen or persisted JWT used without the step-up). Such a user can: add/edit/delete cluster nodes (AddNode/EditNode store an AES-serialized node token, the secret used to control a remote node, so this reads back and rewrites a cross-node credential); trigger nodes/reload_nginx and nodes/restart_nginx across the cluster (the exact reload/restart action class the fix protected on the single-node path); and add/modify/delete/reorder namespaces.
Proof of concept: with a valid JWT but no fresh secure session, call POST /api/nodes (AddNode) or POST /api/nodes/reload_nginx. The nginx equivalent POST /api/nginx/reload returns the secure-session challenge; the cluster route succeeds.
## Verification
Source-verified at HEAD: the nginx router wraps reload/restart in RequireSecureSession, the cluster router registers node/namespace/reload/restart directly on the group with no such wrapper, and both mount on the AuthRequired+Proxy-only group. I did not stand up a live nginx-ui.
## Suggested fix
Wrap the cluster router's mutation handlers (node CRUD, nodes/reload_nginx, nodes/restart_nginx, namespace CRUD) in middleware.RequireSecureSession(), mirroring api/nginx/router.go. Secondary lower-confidence items worth checking in the same pass: the system/restart handler, the core-upgrade websocket, and the upstream socket PUT also appear to run without the step-up (I did not fully trace these).
## Summary
Nginx-UI v2.4.3 stores the API JWT in a browser cookie named `token` and the `AuthRequired` middleware accepts that cookie as an authentication source. Because management endpoints are protected by `AuthRequired` and do not enforce a universal CSRF token or Origin/Referer check, a remote attacker can induce a logged-in administrator to submit cross-site state-changing requests. The attacker does not need to read the cross-origin response; the browser-sent cookie is enough to authenticate the request.
## Details
The root cause is a trust-boundary failure between browser-managed cookies and API bearer-token authentication. In `app/src/pinia/moudule/user.ts:25-35`, the front end writes the JWT to a `token` cookie when the token changes. In `internal/middleware/middleware.go:16-36`, `getToken` first checks the `Authorization` header and `token` query parameter, then falls back to `c.Cookie("token")`. That fallback causes browser-initiated cross-site requests to carry a valid API credential automatically. The route group in `router/routers.go:87-110` applies `middleware.AuthRequired()` to many management modules, including `config.InitRouter`, `nginx.InitRouter`, `settings.InitRouter`, and backup-related handlers. For accounts without OTP/Passkey, `RequireSecureSession` does not provide a universal second factor for all state-changing operations. A representative sink is `api/config/add.go:68-78`, where an authenticated request writes Nginx configuration with `os.WriteFile` and then calls `nginx.Control(nginx.Reload)`. CORS does not mitigate this issue because preventing cross-origin response reads does not prevent cross-site form or no-cors requests from being sent with cookies.
Core vulnerable code path:
```typescript
// app/src/pinia/moudule/user.ts:25-35
watch(token, v => {
if (v) {
cookies.set('token', v, getCookieOptions(86400))
if (!shortToken.value) {
void fetchShortToken()
}
}
else {
cookies.remove('token', { path: '/' })
shortToken.value = ''
}
})
```
The front end stores the authentication token in a `token` cookie. The cookie is created client-side and is not shown here as HttpOnly; it becomes the credential that the back end later accepts through cookie fallback.
```go
// internal/middleware/middleware.go:16-36
// getToken from header, cookie or query
func getToken(c *gin.Context) (token string) {
if token = c.GetHeader("Authorization"); token != "" {
return
}
if token = c.Query("token"); token != "" {
if len(token) > 16 {
// Long token (base64 encoded JWT)
tokenBytes, _ := base64.StdEncoding.DecodeString(token)
return string(tokenBytes)
}
// Short token (16 characters)
return token
}
if token, _ = c.Cookie("token"); token != "" {
return token
}
return ""
}
```
`getToken` accepts the `token` cookie as an authentication credential after checking the header and query parameter. That behavior lets a browser-sent cookie authenticate state-changing API requests triggered from another origin.
```go
// router/routers.go:87-110
// Authorization required and not websocket request
g := root.Group("/", middleware.AuthRequired(), middleware.Proxy())
{
debug.InitRouter(g)
user.InitUserRouter(g)
analytic.InitRouter(g)
user.InitManageUserRouter(g)
nginx.InitRouter(g)
sites.InitRouter(g)
streams.InitRouter(g)
config.InitRouter(g)
template.InitRouter(g)
certificate.InitCertificateRouter(g)
certificate.InitDNSCredentialRouter(g)
certificate.InitAcmeUserRouter(g)
dnsapi.InitRouter(g)
system.InitPrivateRouter(g)
settings.InitRouter(g)
llm.InitRouter(g)
cluster.InitRouter(g)
notification.InitRouter(g)
external_notify.InitRouter(g)
backup.InitAutoBackupRouter(g)
nginxLog.InitRouter(g)
upstream.InitHTTPRouter(g)
```
Many management modules, including Nginx, configuration, settings, backup, and user management, are placed behind `AuthRequired`. The cookie fallback therefore protects high-impact state-changing routes, not only read-only endpoints.
```go
// api/config/add.go:68-78
err = os.WriteFile(path, []byte(content), 0644)
if err != nil {
cosy.ErrHandler(c, err)
return
}
res := nginx.Control(nginx.Reload)
if res.IsError() {
res.RespError(c)
return
}
```
This representative sink shows why the CSRF is high impact: once authenticated through the cookie fallback, a request can write Nginx configuration content and trigger a reload.
## POC
Prerequisites: an administrator is logged in to Nginx-UI and has a browser `token` cookie; the administrator account has not enabled OTP/Passkey, or the chosen target endpoint does not require secure-session proof; the attacker knows the Nginx-UI management URL and can induce the administrator to visit an attacker-controlled page. Reproduction: (1) Host an attacker page at `GET /csrf.html` that automatically submits a cross-site request to the victim instance. (2) The page submits `POST /api/configs`
The United States disrupted two Chinese state-sponsored hacking tools, MicroScan and FishHub, used by the APT group Flax Typhoon and others to target critical infrastructure in the US and abroad. MicroScan is a Python-based vulnerability scanning tool with over 1,300 penetration testing scripts, used since at least 2017 against various software and services. FishHub facilitated network intrusions and data exfiltration via spear phishing, targeting universities and critical infrastructure entities. The US seized domains used by these tools and previously sanctioned the developer, Integrity Technology Group. The tools enabled reconnaissance, credential theft, and exfiltration of sensitive data from government, law enforcement, healthcare, and religious organizations, primarily in Southeast Asia. The disruption was part of a coordinated international effort involving multiple countries.
OpenPrinting CUPS before 2.4.20 contains a NULL pointer dereference caused by repeated IPP group tags in job-creation requests. IPP parsing creates unnamed separator attributes with IPP_TAG_ZERO, but add_job() converts these separators to IPP_TAG_JOB. During job startup, get_options()/ipp_length() subsequently calls strlen() on a NULL attribute name, terminating cupsd and disrupting all queues. A single crafted Print-Job request can trigger the crash when the client can reach the scheduler and submit jobs to an accepting, enabled queue supporting the submitted document format. Anonymous submission is possible when permitted by listener and access-control configuration.
In July 2026, a sophisticated malware campaign attributed to the TraderTraitor group was uncovered, leveraging a trojanized Terraform provider to target cryptocurrency and Web3 developers. The attack uses a malicious Terraform provider that downloads a Bash loader from a HashiCorp-themed lookalike domain, which then deploys platform-specific payloads for macOS, Linux, and Windows. Encrypted executables are hidden in fake font files and decrypted with AES-256-CBC. The campaign delivers FLATROOF, a Rust-based backdoor with multiple command and control (C2) channels, and Python-based information stealers targeting browser credentials and cryptocurrency wallet data. The attack concludes with deployment of the ROOFDECK backdoor, which uses resilient C2 discovery methods including cryptographically signed Pastebin dead drops and Nostr metadata.
Incorrect default permissions in the Windows installer of Progressive Robot hMailServer 6.0.0 through 6.3.5 allow a local authenticated user to read the mail server's data. The installer created the data, log, temp, database and event folders and the hMailServer.INI configuration file with the permissions inherited from the installation folder, by default under Program Files, which give the local Users group read access. Any user who can sign in to the computer could read every stored message, the logs, the built-in database with the accounts' password hashes whenever the service is stopped, and the configuration file, including the database password, which is sealed only with the machine's DPAPI key and can be unsealed by any local account; with an external database that password gives full control of it. The Linux AppImage of 6.3.0 through 6.3.5 likewise created its per-user data folders readable by other local users.
A buffer overflow vulnerability exists in the TIFF CCITT Group 4 (T6) encoder of the SixLabors.ImageSharp library versions 2.1.0 through 4.1.1. When encoding a 1-bit image, the encoder writes beyond the allocated output buffer, causing an unhandled exception and process termination. This occurs because the encoder appends two 12-bit end-of-facsimile-block codes without checking buffer capacity. The issue affects applications that decode a Group 4 TIFF and then re-encode it using inherited TIFF metadata. No active exploitation is known. Fixed versions are 3.2.0 and 4.1.2.
ImageSharp's TIFF CCITT Group 3 (T4) encoder in versions 2.0.0 through 4.1.1 can write beyond its allocated compressed-data buffer when encoding narrow 1-bit images. This unchecked buffer overflow can corrupt process memory and cause application crashes. The issue occurs when encoding 1-bit TIFF images with CcittGroup3Fax compression, either explicitly configured or when re-encoding TIFFs preserving metadata. No active exploitation is known. Fixed in versions 3.2.0 and 4.1.2.
A vulnerability in the endpoint group (EPG) contract functionality of Cisco Nexus 9000 Series Fabric Switches in ACI Mode could allow an unauthenticated, remote attacker to bypass configured EPG contracts.
This vulnerability is due to an improper control with EPG contracts. An attacker could exploit this vulnerability by sending IPv4 or IPv6 packets using UDP source and destination ports that are assigned to DHCP traffic through an affected device. A successful exploit could allow the attacker to bypass EPG contracts on the affected device.