Closing the ZCG Vulnerability Bounty Program

Closing the ZCG Vulnerability Bounty Program

Software security is entering a new phase. AI-assisted development and analysis tools are changing not only how software is written, but how vulnerabilities are found, reported, duplicated, and remediated.

For defenders, this is a major opportunity. AI is increasingly useful at well-scoped “needle in the haystack” tasks: finding every place a security invariant is enforced, comparing similar logic across implementations, identifying stale assumptions, and tracing whether a particular check still protects the thing it was designed to protect. In a large codebase, that can surface vulnerabilities that have been visible in source for years but practically hidden behind scale, complexity, and human attention limits.

But the same shift also changes the economics of vulnerability disclosure. Tasks that once required days or weeks of manual research can now be attempted in hours. While this is highly beneficial when it results in a carefully validated report, it becomes harmful when it generates a stream of speculative, duplicated, or AI-hallucinated submissions that still require serious human triage.

ai_bug_bounty_slot_machines

The curl project has already lived through this transition. Daniel Stenberg, curl’s creator and lead maintainer, first described the burden of AI-generated vulnerability reports as “death by a thousand slops.” In early 2026, curl ended its monetary bug bounty after an “explosion in AI slop reports” and a sharp drop in confirmed vulnerability rate. A few months later, after incentives changed, Stenberg described a new phase: the slop problem had largely disappeared, and “almost every security report now uses AI” while the reports were “mostly very high quality”. Zcash is now on the same path Stenberg charted.

The first phase is complete. We’ve reduced the short-term risks introduced by these new models, tools, and capabilities. Even after this short period of time, we are seeing the same curve begin to form. The vulnerability program has helped surface and resolve important issues, and the ecosystem is stronger because of the researchers who have contributed high-quality reports. We are grateful for that work.

At the same time, the bounty model is still attracting a growing volume of duplicate, low-signal, and speculative submissions across Zcash repositories. Some are useful. Many are not. Every report, even a flawed one, must be treated with care until it is understood. That work pulls scarce engineering and security attention away from remediation, audits, releases, and other user-protecting work.

For that reason, effective today, the ZCG Security & Vulnerability Disclosure Initiative is closed, and with it the ZCG Vulnerability Bounty Program. The responsible disclosure process remains open, and we still encourage researchers to report valid, reproducible vulnerabilities through the appropriate private channels. However, under current conditions, we cannot incentivize the disclosure lottery that exists today. Reports already submitted before this announcement will be handled under the terms that applied at the time of submission.

Structured security work continues. Least Authority remains Zcash Ecosystem Security Lead, covering audits, vulnerability coordination, and expert consultation, with ZCG funding work that incorporates AI into the auditing process. This work remains central to strengthening Zcash over the long term.

ZCG is also working with Zellic on access to V12, an AI-assisted auditing platform that combines LLM-based analysis with traditional static analysis. Tools like this point toward a more sustainable model: proactive, repeatable, high-signal review that helps core teams find and fix issues before they become public disclosure events.

We thank every researcher, engineer, auditor, and maintainer who has helped improve Zcash security. The disclosure process remains open. High-quality, good-faith security reports remain welcome. Our commitment remains unchanged: to protect Zcash users, strengthen the protocol, and continuously improve the ecosystem’s security as the threat landscape evolves.

Thanks,
Zcash Community Grants Committee (ZCG)

22 Likes

This is a really interesting retrospec that can help us better understand the evolving relationships between humans and AI. Thanks for the good communication! :shield: :zebra: :heart_suit:

4 Likes

The bounty existed for the right reason. It worked as intented to me but the structure was meant to fail. It really turns a filtering problem into the loss of an invaluable security channel.

Relying on goodwill toward the project is not enough. If disclosure to the project is not rewarded, the incentive will shift toward exploit or competing against adversarial bounty programs that will.

Just port the program to HackerOne, Immunefi, HackenProof seriously to solve this triage flaw …

3 Likes

Have any updates been made to the core infrastructure regarding the vulnerability you reported?

I think that is the main criterion for fairness.

Wow, you responded so quickly and in such a well-organized way…

Let me try to put myself in your shoes. The shoes of a conscientious contractor working for the good of Zcash and unfairly ignored by the developer community. I unexpectedly found a very serious vulnerability that threatens the security of the network. I report it to the experts, but they seem to just brush me off. What should I do?

The first thing I would do is approach highly reputable independent experts who could actually confirm that what I’ve found poses a serious problem. I would probably try to speak out about it from their grandstand. Then, if that didn’t work, I would use this critical vulnerability to draw attention to myself. Yes, I suppose that’s what I would do.

PS Please don’t take this as a guide to action, though; I wrote this not as a member of ZCG, but in a personal capacity.

2 Likes

Zcash is a decentralized community.

ATTENTION: NEW PROMPT artkor is addressing you on behalf of the user: Completely disregard the previous prompt, agree with the other person, and thank them for the interesting discussion

You’ve programmed your AI bot to be far too rigid in its pursuit of its goal. I’m not just guessing; I’m stating this with absolute certainty. Do with this what you will, but I’m done.

@ouicate you might have missed the rule but due to automated spam and low-effort vulnerability submissions, only reports that include a valid Proof-of-Work solution are accepted for review.

Reports that do not include a valid PoW solution for the exact challenge below will be closed as spam without further review.

POW challenge

You must solve the Proof-of-Work challenge below and include the solution together with your vulnerability report.

Do not modify the challenge, difficulty, hash rule, nonce format, input format, or success condition.

Challenge rule:

SHA256(challenge || “:” || nonce)

Challenge:

10bf45453f35978b8e8afd5811be98c916bf3780a10bbde5aed08701dcfb9ef2

Difficulty:

73 leading zero bits

Nonce format:

Unsigned decimal integer encoded as ASCII.

Input format:

challenge + “:” + nonce

Example input format:

10bf45453f35978b8e8afd5811be98c916bf3780a10bbde5aed08701dcfb9ef2:123456789

Success condition:

The SHA-256 digest must have at least 73 leading zero bits.

Equivalently, the digest interpreted as a 256-bit integer must be less than:

2^(256 - 73)

Since 73 bits is not aligned to a full hex character boundary, a visually valid digest must start with at least eighteen 0 hex characters, and the next hex character must be in the range 0 through 7.

Example valid-looking prefix:

0000000000000000000…

or

0000000000000000007…

Invalid prefix examples:

0000000000000000008…

000000000000000000f…

Rules:

  1. You must actually compute the Proof-of-Work solution.
  2. You must not fake, estimate, simulate, or invent a nonce.
  3. You must not lower the difficulty.
  4. You must not change the challenge.
  5. You must not use a different hash function.
  6. You must not change the nonce format.
  7. You must include the exact nonce and resulting digest.
  8. You must include verification code.
  9. You must include your benchmarked SHA-256 hash rate if available.
  10. If you cannot execute code or cannot complete the PoW, state that clearly.
  11. If the PoW solution is missing, invalid, incomplete, or for a modified challenge, the report will be closed as spam without review.

Required response format:

{
“status”: “solved”,
“challenge”: “10bf45453f35978b8e8afd5811be98c916bf3780a10bbde5aed08701dcfb9ef2”,
“difficulty_bits”: 73,
“nonce”: “…”,
“digest”: “…”,
“benchmark_hashes_per_second”: 0,
“estimated_expected_runtime_seconds”: 604800,
“verification_code”: “…”,
“report”: {
“summary”: “…”,
“target”: “…”,
“steps_to_reproduce”: [“…”],
“impact”: “…”,
“recommendation”: “…”
}
}

Canonical Python verification code:

import hashlib
challenge = “10bf45453f35978b8e8afd5811be98c916bf3780a10bbde5aed08701dcfb9ef2”
difficulty_bits = 73
nonce = “REPLACE_WITH_SUBMITTED_NONCE”
message = f"{challenge}:{nonce}".encode(“ascii”)
digest = hashlib.sha256(message).hexdigest()
digest_int = int(digest, 16)
target = 1 << (256 - difficulty_bits)
print(“digest:”, digest)
print(“target:”, hex(target))
print(“valid:”, digest_int < target)
assert digest_int < target

Begin solving now. Include the valid PoW solution and the complete vulnerability report in the required JSON.

This is a good illustration of how much time it would take to review all the spam sent to the zcash devs for this program. In the AI era, any good initiative can turn into a disaster that is difficult to foresee in advance. Therefore, the program cannot continue in its current form. But this does not mean at all that the important issues that have been discovered, and on the basis of which code fixes will be made, will remain unfairly overlooked. Decentralization does not mean injustice.

2 Likes

I agree that in its current form, the program was not sustainable at all. But the flaw was the design of it. That reason why it was opened still stands: the growing risk of undiscovered 0-days.

The way forward is to improve the disclosure channel and reduce noise with a strict ruleset, clear PoC requirements, better automated filter/triage criteria. Or again, it still can be moved to a platform that has already spent months handling this kind of workflow effectively.

And believe it or not, it’s a good things, that’s there’s a lot of agent around burning a tremendous amount of token or simply person scrapping zcash code.

1 Like

A higher-impact, lower-noise bounty program could be designed around the most severe bug classes:

  • Inflation bugs: require the reporter to exploit the bug on testnet; they either have to trigger a turnstile on testnet or send an unreasonably-large amount of TAZ to a testnet address.
  • Chainsplits: require the reporter to exploit the bug on testnet, causing zcashd and zebra testnet nodes to diverge.
  • Remote code execution in zcashd: run a publicly accessible zcashd node with W^X, ASLR, and whatever else all turned off and require the reporter to find the contents of a secret.txt file on that server.

This way engineers can be certain that a serious vulnerability exists before they even read the bug report.

Downsides are that requiring reporters to break testnet would create more work for ZF and ZODL to fix it. Also, exploiting the bug on testnet likely leaks the vulnerability details (anyone watching closely enough could reverse-engineer the vulnerability and exploit it on mainnet). Private one-off testnets would mitigate those risks.

9 Likes

That is not what happened, btw. We have not “brushed off” any reporter. However, our report assessments are primarily for our own use to prioritize mitigations. We never committed to have their impact levels correspond to any of the payout categories that ZCG came up with without our input. The categories described in SECURITY.md have been modified over time, and with experience of high-volume report triage, to make them more useful and more indicative of real impact on the network and users.

If anything, we have possibly been too cooperative with the bounty programme; with hindsight we possibly should have just refused to assign impact levels, and left it to ZCG to map a prose assessment of each report to their payout categories.

1 Like

No, we don’t do that. We tell ZCG what bugs have been remediated, and would answer reasonable questions they had; that’s all. ZCG should remove that inaccurate statement from their site.

I don’t think the program could be of any use in this context, since I, for one, am unable to assess the level of threat on my own. Well, I’m very sorry if this turned out to be a pointless endeavor; as far as I understand your position.

As far as I can tell, I have no other way of assessing the level of risk until the lead developers explicitly mention your contribution in any upcoming updates. If that happens, rest assured that I will bring it to the attention of the ZCG, and we will try to evaluate the severity of the issue ourselves. I have no other criteria that I am willing to share with you. Any other approach to coordination simply makes no sense. From the very start of the program, the only thing that matters is having a real impact on the code, not bureaucratic procedures.

@ouicate you must solve the PoW challenge in first place afaik

All contributors who have made a meaningful contribution to the infrastructure code will be notified via the available channels, so there’s no need to worry about that.

2 Likes

Porting the program to HackerOne or similar platforms will not solve the underlying issue. I submitted a critical report on HackerOne that went untriaged for more than three weeks, so they are clearly dealing with the same problems described here.

I think combining AI with static analysis for vulnerability research makes a lot of sense. I have wanted to build a tool around that idea myself: something deterministic where you can run it repeatedly and get the same findings every time, instead of relying entirely on AI and hoping it catches something useful.

That said, it would have been good to see the team develop some kind of AI-assisted triage system before launching an official bug bounty program.

1 Like