7 Followers
28 Following
31 Posts

ZAST.AI verified CVE-2026-3352 in Easy PHP Settings <= 1.0.4 (https://wordpress.org/plugins/easy-php-settings/), a WordPress plugin with 1,000+ active installations.

Root cause is simple: sanitize_text_field() on admin input, then direct concatenation into wp-config.php via update_wp_memory_constants().

The value is sanitized for HTML context, but that sanitization provides no protection in a PHP code-generation path.

The key result is the executable PoC showing persistent PHP code injection after the config write.

Full report: https://blog.zast.ai/vulnerability%20research/wordpress%20security/Persistent-PHP-Code-Injection-in-Easy-PHP-Settings/

ZAST.AI identified and verified CVE-2026-2711 in worldquant-miner (<=1.0.9).

The path is clean: attacker-controlled input reaches /console/api/remote-files, gets decoded, and is sent into ssrf_proxy.head() / ssrf_proxy.get(). Once a product starts fetching arbitrary URLs for users, it is already operating on a security boundary whether it treats it that way or not.

Project: https://github.com/zhutoutoutousan/worldquant-miner
Report: https://github.com/zhutoutoutousan/worldquant-miner/issues/100

User-driven fetch logic deserves direct validation, not assumptions. ZAST.AI is built for that kind of check.

Most teams do not need more findings. They need less noise.

We are rolling out Fast Verification in ZAST.AI so candidate vulnerabilities from other tools can be pushed into the same verification flow instead of sitting in manual triage queues.

The point is simple: confirm which findings actually hold in the target, cut review cost, and move faster on the issues that are real.

Full blog: https://blog.zast.ai/product/application%20security/Why-Fast-Verification-Matters/

ZAST.AI verified an insecure deserialization issue in pycel <= 1.0b30, now assigned CVE-2026-30108.

Project: https://github.com/dgorissen/pycel/ (600+ GitHub stars). The bug is in ExcelCompiler.from_file(), where pickle-backed files go straight into pickle.load(). The interesting part is not just the sink.

The PoC showed code execution during deserialization, followed by an application error only afterward.

That moved the finding from a risky pattern to a verified arbitrary-code-execution path.

Report: https://blog.zast.ai/vulnerability%20research/ai%20security/Insecure-Deserialization-in-Pycel/

Many teams already understand the common security risks in AI agent deployments. The harder question is whether those issues already exist in the environment they are running.

OpenClaw Security Audit is aimed at the next layer: deterministic audit of OpenClaw-like agent environments. Current scope: 12 attack surfaces, 80 checks, 27 threat mappings, no LLM dependency, reproducible results. It checks local instances, Docker deployments, and remote port exposure, and outputs terminal, Markdown, and JSON reports.

If the question is what issues already exist in the environment you are running, it is now available here: https://github.com/zast-ai/openclaw-security-audit

Discovery is becoming abundant. Actionability is still scarce.

I recently joined Cyber Defense TV to talk about one of the biggest problems in application security today: the industry is getting better and faster at generating findings, but proving which ones are real is still the harder part.

That changes how security teams work. When a finding cannot be verified, teams end up debating reachability, severity, and priority. A working PoC usually settles that discussion much faster than a long argument ever will.

At ZAST.AI, our approach is built around that reality:
Analyze — combine static analysis, code property graph analysis, and LLM reasoning to understand flows, assets, trust boundaries, and business logic
Generate — produce PoC candidates from the relevant execution context
Verify — run those PoCs against test targets to determine whether the path is actually exploitable

So far, that workflow has helped us turn candidate findings into verified results, contribute 150+ CVEs across projects including Microsoft Azure SDK, Apache Struts, and WordPress, and uncover hundreds of “forever days” in legacy IoT firmware.

One of the main points from the interview was simple: as AI-generated reports continue to multiply, verification becomes more important for everyone in the process — researchers, vendors, CNAs, and defenders trying to prioritize what actually matters.

If you want the full conversation, the episode is here:
🎥 Full episode: https://lnkd.in/gDHy4wTN

ZAST.AI verified a previously undisclosed ACE path in verl <= 0.7.0. verl is a ByteDance-initiated project: https://github.com/verl-project/verl/ (20.5k GitHub stars as of April 6, 2026).

Prompt-controlled model output flowed through match_answer() and ended up in eval(prediction) inside matrix grading.

This is the part that matters: it is not just unsafe eval(), it is an execution-boundary failure inside a training pipeline.

A poisoned dataset or other controllable training input lives upstream, the model emits the payload, and the reward path executes it.

Full report: https://blog.zast.ai/vulnerability%20research/ai%20security/When-Prompt-Injection-Reaches-Code-Execution/

https://www.youtube.com/watch?v=X3FwfYS-Xq0

ZAST.AI verified CVE-2026-33419 in MinIO (https://github.com/minio/minio), currently at 60.5k+ GitHub stars.

The LDAP-backed AssumeRoleWithLDAPIdentity path exposed a username oracle, had no effective brute-force control, and returned temporary AWS-style credentials on success.

The interesting part is not one missing check.

It is the full chain from enumeration to credential issuance, validated with an executable PoC.

Full report: https://blog.zast.ai/security%20research/CVE-2026-33419-Analysis/

Security Advisory: OpenClaw @steipete deployments are a high-value target if misconfigured.

OpenClaw combines untrusted input, sensitive data access, and command execution — making exposed instances especially dangerous.

Our new handbook covers:
- critical threat paths
- isolation and hardening
- auth and network exposure risks
- channel / bot abuse scenarios
- safer deployment practices

Read: https://github.com/zast-ai/openclaw-security?tab=readme-ov-file