Curl Weighs HackerOne Exit as Fake AI Reports Flood Bug Bounties

AI slop attacks on the curl project - Daniel Stenberg — Daniel Stenberg

Daniel Stenberg

Unchecked large language model hallucinations now make up 20% to 40% of incoming curl vulnerability submissions, exhausting maintainer resources on non-existent flaws and forcing the project to exit HackerOne and rethink bug bounties.

AI-assisted summary of AI slop attacks on the curl project - Daniel Stenberg — original source. Check the original for full context.

Source published:

Key ideas

  • curl maintainer Daniel Stenberg reports that AI-generated or AI-assisted vulnerability submissions now account for 20% to 40% of all incoming reports, inundating maintainers with fabricated flaws. (25:51)
  • Due to platform indifference, ineffective filtering, and triage burnout, curl is preparing to leave HackerOne and considering the complete elimination of its cash bug bounty incentives. (36:09)
  • Legitimate vulnerability research remains heavily concentrated among specialized human experts, with roughly half of all bounty money paid out in curl's history going to a single individual. (48:16)
  • Stenberg warns that the primary threat of AI slop is not overt malice, but well-meaning submitters acting as uncritical copy-paste proxies for model hallucinations. (15:14)

Detailed notes

## Background Published on YouTube by curl creator Daniel Stenberg on August 16, 2025, this video documents his keynote address delivered at the FrOSCon 2025 conference in Bonn, Germany. According to the page description, the talk examines the operational impact and influx of AI-generated bug submissions targeting the curl project.

## TL;DR Daniel Stenberg details how the rise of generative AI has overwhelmed the curl project with fabricated vulnerability submissions, which now constitute roughly 20% to 40% of all incoming security reports. These synthetic reports—often marked by extreme politeness, verbose formatting, and completely hallucinated functions and debugger logs—force maintainers to squander hours verifying non-existent flaws due to the critical interrupt priority assigned to security triage. Stenberg explains why simplistic counter-measures like automated virtual machine reproducibility or prompt injections fail across curl's diverse operating environments, and why reputation systems struggle against throwaway accounts. Looking ahead, curl plans to introduce submission friction, consider ending financial bug bounties, and leave the HackerOne platform, emphasizing that AI can only assist security work when guided by skilled, discerning human researchers.

## Atmosphere & style The presentation carries a dryly humorous, weary, and candid tone as Stenberg balances technical precision with palpable exasperation over synthetic spam. Watching him recount absurd debugging sessions—such as scouring 27 years of Git history for a function hallucinated by an LLM—elicits sympathetic chuckles from the live audience alongside a shared recognition of maintainer burnout. Despite the sobering diagnosis of digital fatigue and platform apathy, Stenberg's delivery remains steady, practical, and ultimately resilient, projecting quiet confidence that open source will endure this technological wave.

## Bulletin - [25:51](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1551s) curl maintainer Daniel Stenberg reports that AI-generated or AI-assisted vulnerability submissions now account for 20% to 40% of all incoming reports, inundating maintainers with fabricated flaws. - [36:09](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2169s) Due to platform indifference, ineffective filtering, and triage burnout, curl is preparing to leave HackerOne and considering the complete elimination of its cash bug bounty incentives. - [48:16](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2896s) Legitimate vulnerability research remains heavily concentrated among specialized human experts, with roughly half of all bounty money paid out in curl's history going to a single individual. - [15:14](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=914s) Stenberg warns that the primary threat of AI slop is not overt malice, but well-meaning submitters acting as uncritical copy-paste proxies for model hallucinations.

## Key takeaways - [00:06](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=6s) curl has expanded from a 100-line tool in 1996 to 180,000 lines of code deployed across 20 to 40 billion installations, yet it remains maintained by a core group of only about a dozen people. - [03:41](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=221s) Security vulnerabilities take absolute interrupt priority over feature development, magnifying the mental strain and burnout risk for open source maintainers. - [09:12](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=552s) curl's six-year-old bug bounty program has distributed $92,000 across 81 confirmed CVE fixes funded by the Internet Bug Bounty, but has never awarded its $10,000 top prize for a critical flaw. - [11:57](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=717s) AI-generated vulnerability submissions feature distinct stylistic markers, including extreme politeness, lack of typos, extensive em dash usage, and verbose, bullet-pointed risk essays that hide complete technical falsehoods. - [15:14](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=914s) Maintainers frequently become trapped in proxy communication loops where uncritical submitters merely copy-paste clarification questions into LLMs, leading to deteriorating conversational context and irrelevant tangents. - [18:43](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1123s) A case study of a private HackerOne submission revealed a fully hallucinated HTTP/3 exploit complete with fabricated GDB breakpoints, invented register values, and non-existent curl functions that wasted maintainers' triage hours. - [30:44](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1844s) Commonly proposed automated defenses like requiring virtual machine reproducers fail because curl runs across more than 100 operating systems and 28 CPU architectures, and many real logical flaws resist easy automated reproduction. - [27:48](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1668s) Banning submitter accounts is largely ineffective because AI slop originates almost entirely from first-time, disposable accounts that have no platform reputation to lose. - [34:45](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2085s) The curl website consumes around 65 terabytes of bandwidth per month across roughly 4,000 requests per second, largely comprising automated, unlogged web traffic absorbed by CDN sponsor Fastly. - [38:41](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2321s) AI tools can aid in discovering genuine flaws only when paired with competent human domain experts who validate findings; blind reliance on generative models consistently yields useless reports. - [40:20](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2420s) Generative AI models have not improved report quality for non-native English speakers compared to standard translation tools, which have functioned effectively for decades. - [49:44](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2984s) Traditional bug bounty models may be fundamentally outdated for open source, as unpaid maintainers shoulder the triage burden while large commercial enterprises derive the bulk of the economic value. - [51:03](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=3063s) When AI-assisted reports do identify legitimate codebase issues, they are almost universally ordinary functional defects rather than actual security vulnerabilities, and prompt explanations often obscure the real bug.

## Detailed walkthrough ### [00:06](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=6s) Introducing curl and the Scale of Open Source Infrastructure

Daniel Stenberg begins his talk after a quick humorous exchange about microphone audio. Introducing himself, he notes that he works for wolfSSL, serves as the president of the European Open Source Academy, and maintains curl—a project he began over 27 years ago. In 1996, he found an existing tool on the internet to download web pages that was roughly 100 lines of code; today, curl has grown into a codebase of approximately 180,000 lines. The project has seen about 1,400 distinct authors who have had merged commits, with around 20 to 25 new or returning authors contributing code each month. When counting everyone who has reported a bug, helped with infrastructure, or run tests, the project's contributor list totals over 3,500 people. Despite this reach, only a small core of maintainers—about a dozen—hold merge permissions.

```mermaid flowchart LR accTitle: Growth of the curl codebase accDescr: Diagram tracing the evolution of curl from 100 lines of code in 1996 to 180,000 lines, 1,400 commit authors, and 20 to 40 billion installations. A["1996: 100 lines of code"] --> B["Present: ~180,000 lines of code"] B --> C["1,400 commit authors<br/>3,500 total contributors"] C --> D["20–40 billion installations worldwide"] ```

Daniel points out that curl runs in an immense variety of systems, reaching an estimated 20 to 40 billion installations worldwide. Almost everyone carries his code in their pocket, their car, their fridge, their printer, and their games, yet the core team remains a tiny group. This exemplifies the broader reality of modern software architecture: virtually all contemporary proprietary and open tools run atop massive foundations of open source software. Daniel references both the classic "bad iceberg" graphic (joking that real icebergs do not float that way and would tip over) and the iconic XKCD 2349 comic depicting digital infrastructure precariously resting on a tiny project maintained by an unpaid person in Nebraska.

- Began in 1996 from a 100-line tool used to fetch web pages. - Expanded to roughly 180,000 lines of code. - Maintained by roughly a dozen people with merge rights. - Deployed across an estimated 20 to 40 billion devices and systems globally.

---

[03:41](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=221s) Security Responsibilities and Maintainer Burnout

Operating at a scale of billions of installations fundamentally changes how maintainers must treat security. Daniel reflects on this weight: “I don't know how you feel but 20 billion installations sometimes it gives a little bit of a sense that you should take security important I mean you should care about it you should try to make things better for for the entire world right because quite a lot of things run use depend um your code”. Whenever a security flaw arises, normal development freezes, as security carries the highest interrupt priority in open source projects.

At the same time, open source maintenance is fragile. Daniel highlights that across the millions of projects worldwide, the median maintainer headcount is just one person. Most developers work on these tools as spare-time hobbies, continuously balancing underfunded budgets, endless backlogs, and limited personal energy. Under the intense scrutiny of maintaining critical infrastructure used by billions, many open source developers face acute burnout and strain.

---

[05:42](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=342s) Bug Bounties and Engineering for Security

Daniel stresses that making software secure involves no magic shortcuts: there is no silver bullet, only disciplined engineering. This involves writing readable code, reviewing changes rigorously, testing exhaustively, and using automated static analysis and parsing tools. Alongside these practices, Daniel has long championed bug bounty programs. By offering monetary rewards, projects can attract security researchers and full-time professional bounty hunters who direct deep attention and scrutiny toward the codebase.

Finding security flaws can be an unpleasant, humbling process. As Daniel puts it: “Finding problems is it's a little bit of a soul crushing experience every time, right? when they point out, you know, point in the eye and say, 'Why do you why did you do this stupid thing?' And it feels really bad at the moment, but you know, fixing it, improving it, iterating again, shipping it to all the world is a general good, right? Even if though it it hurts in the moment.” Since curl launched its bug bounty program six years ago, the team routinely receives two to three submissions per week, with occasional spikes. Each legitimate submission typically requires several person-hours to evaluate, reproduce, and patch. Historically, low-effort or low-quality human submissions were easy to filter out: an uncritical user running a generic scanner produced output that maintainers could dismiss in seconds.

---

[09:12](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=552s) The Reality of Bounties and the Rise of AI Slop

The curl bug bounty program offers up to $10,000 for a critical vulnerability, though the project has never awarded that top prize because no submission has qualified as a critical flaw under the bounty rules. Still, the program has paid out $92,000 in total bounties to date, which has led directly to 81 confirmed, CVE-documented security fixes. All payouts are funded through a partnership with the Internet Bug Bounty (IBB), sparing curl from bearing the financial cost directly.

```mermaid flowchart TD accTitle: The AI Slop Submission Loop accDescr: Flowchart illustrating how AI-generated vulnerability reports are generated and submitted to maintainers. subgraph Hunter["Bounty Seeker"] A["Asks chatbot to find vulnerability in curl"] B["Chatbot generates alarming, hallucinated flaw report"] A --> B C["Submits unreviewed report to curl bug bounty"] B --> C end subgraph Project["curl Maintainers"] D["Receives multi-page, sophisticated-sounding report"] E["Spends hours investigating non-existent flaws"] D --> E end C --> D ```

However, the influx of generative AI has disrupted this workflow, introducing an avalanche of "AI slop." Well-intentioned users or bounty seekers, eager for rewards, feed source code to large language models. Chatbots are eager to oblige: they will not admit they cannot find a flaw, but will instead fabricate convincing, alarming reports about non-existent vulnerabilities. The submitters, lacking the deep domain knowledge required to understand the code or verify what the AI produced, forward these extensive, urgent-sounding write-ups straight to curl's maintainers.

- Bug bounty program running for six years. - Maximum reward of $10,000 for critical flaws (never triggered). - $92,000 paid across 81 confirmed security vulnerabilities. - Fully funded by the Internet Bug Bounty (IBB). - Inflow averages two to three submissions per week, increasingly contaminated by fabricated AI reports.

[11:57](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=717s) The Telltale Signs of AI-Generated Bug Reports

Daniel explains that while curl receives an influx of supposed security vulnerability submissions generated by users asking an AI to "help me out with this," virtually none of the reported issues actually exist. Two years prior, this phenomenon did not occur at all, making it initially difficult to pinpoint what was happening when the sudden flood of bug submissions began. Over time, distinct patterns emerged that immediately differentiate AI-generated slop from authentic human communication. The primary giveaway is an unnatural level of politeness:

> “No, humans are not polite in general.”

Daniel observes that when a real human discovers a bug in software, they rarely open with respectful courtesies; their typical reaction leans toward blunt irritation, along the lines of telling the maintainer they are stupid and wrong. Language models, conversely, maintain an unyielding, servile demeanor. Beyond tone, AI slop stands out due to its flawless English, complete lack of typographical errors, and an obsessive reliance on mixed case or title case capitalization across every heading.

The structural formatting of these reports serves as another immediate giveaway. AI models consistently pepper their text with em dashes—punctuation marks that average humans rarely bother inserting—and produce exhaustive, long-winded essays rather than concise technical reports. A genuine reporter will write a short, focused summary, whereas an AI generates hundreds of lines detailing potential attack scenarios, remediation steps, theoretical risks, and layer upon layer of bullet points. As Daniel notes, if any of these polished submissions were technically accurate, the formatting would not matter, but the elaborate presentation almost always conceals complete fiction.

- **Extreme politeness**: AI reports consistently open with subservient language and apologies. - **Stylistic markers**: Flawless grammar, absence of typos, persistent title-case headings, and frequent use of em dashes. - **Structural bloat**: Hundreds of lines of text with repetitive risk summaries and endless bullet-point hierarchies rather than concise reproducers.

---

[15:14](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=914s) The Proxy Loop and the Distortion of Maintainer Workload

When maintainers attempt to clarify an ambiguous submission, the synthetic nature of the interaction becomes even more obvious. Instead of answering a direct technical question with a straightforward "yes," "no," or targeted clarification, the reporter responds with another massive, apologetic wall of text generated by prompting the model again. In many cases, repeated rounds of questioning cause the conversational context to degrade to the point where the AI drifts into a completely unrelated tangent, discussing a different bug than the one originally reported. Maintainers find themselves trapped in an absurd proxy loop, communicating with an LLM through a human intermediary who merely copies and pastes text back and forth without understanding the subject matter:

> “So indirectly I'm talking to an AI with a human in between somewhere.”

```mermaid flowchart LR accTitle: The AI Slop Proxy Communication Loop accDescr: Flowchart showing how human submitters act as copy-paste intermediaries between an AI model and the curl maintainer.

subgraph Submitter["Reporter Side"] direction TB A["Human Prompt Engineer"] -->|"prompts"| B["LLM / AI Model"] B -->|"generates slop"| A end

subgraph Project["curl Security Team"] direction TB C["Daniel Stenberg (Maintainer)"] end

A -->|"submits report / pastes answer"| C C -->|"asks technical clarification"| A ```

This dynamic drastically warps the daily life of an open-source maintainer. While typical project upkeep involves balancing many responsibilities—triage, infrastructure, and the occasional shrinking slice of feature development—security reports occupy a uniquely demanding position. Because the industry and downstream consumers demand that security issues be treated with extreme urgency, maintainers cannot simply ignore serious-sounding claims. The sudden deluge of artificial reports forces maintainers to dedicate hours of their day to reading expansive text, deciphering claims, running test cases, and attempting to reproduce phantom vulnerabilities, ultimately cannibalizing time that would otherwise go toward legitimate software development.

- **Degrading dialogue**: Follow-ups trigger renewed apologies and fresh essays, frequently derailing the investigation into completely different, ungrounded technical corners. - **Human-in-the-middle**: Submitters act as non-technical conduits who blindly relay maintainer questions back into chatbot prompts. - **Resource drain**: Security triage takes absolute priority over ordinary development, meaning time spent investigating hallucinations directly reduces the capacity for actual feature work.

---

[18:43](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1123s) Case Study: The Completely Hallucinated HTTP/3 HackerOne Exploit

To demonstrate the depth of these fabrications, Daniel walks through a specific bug report submitted privately to curl's bug bounty program on HackerOne. Titled as a formal penetration testing report regarding a "stream dependency cycle exploit" against curl version 8.3.0, the submission carried all the superficial hallmarks of an elite security disclosure. The submitter provided step-by-step reproduction instructions, including custom diffs to patch a local HTTP/3 test server, execution instructions under the GNU Debugger (GDB), and raw terminal output showing an apparent segmentation fault complete with memory addresses.

The report even presented inspectable CPU state, pointing out that the `R15` register was populated with `4141`—a classic pattern representing ASCII `AA`, commonly seen in proof-of-concept exploits to prove register control. The document wrapped up with professional-looking risk assessments and remediation advice laid out in crisp bullet points. At first glance, it appeared that a researcher had thoroughly analyzed curl's HTTP/3 stack and uncovered a severe flaw.

``` Program received signal SIGSEGV, Segmentation fault. [Breakpoint hit at target function] R15: 0x0000000000004141 ```

The entire report, however, was a total fabrication. When Daniel began investigating the technical claims, he tried to locate the function specified in the GDB breakpoint instructions. Unfamiliar with the function name, he grepped the codebase, assuming it might have been refactored or renamed. A thorough search across curl's entire Git history revealed that the function had never existed. Because the function was fictitious, the GDB transcript, the breakpoint, the register dumps, the test server patch, and the crash address were all hallucinations generated by the model. Daniel reflects on the sheer frustration of pouring hours into analyzing an issue only to realize that every single line of evidence was fictitious:

> “And not only the sort of it's it's exhaustively, you know, it's it's sort of a mindnumbingly stupid exercise chasing something that someone invented for us.”

- **Plausible exterior**: The report included reproduction steps, server patches, GDB breakpoints, and crash registers displaying ASCII shellcode patterns (`0x4141`). - **Total hallucination**: The target function never existed in curl, the test server patch was nonfunctional, and the debugging session was invented wholesale. - **Sunk cost**: Hours were squandered verifying and searching historical source trees before confirming the report was synthetic nonsense.

---

[22:17](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1337s) TV Hacking Realism and Human Security Hallucinations

Daniel quips that fictional representations of curl in television dramas are far more credible than AI bug reports, because TV productions usually display valid command-line syntax that actually runs in real life. Furthermore, he makes clear that erroneous and low-effort security reports are not exclusive to artificial intelligence; human bounty hunters have spent years flooding the project with uncritical, low-context claims.

Long before large language models arrived, humans routinely submitted bogus vulnerability reports based on automated scanner output or misunderstandings of standard internet protocols. Maintainers regularly receive panicked notifications alerting them that curl's public Git repository can be found online, or that a `.git` directory is exposed on Daniel's personal website—which intentionally hosts public git mirrors. Similarly, people frequently flag dummy cryptographic keys stored inside the project's automated test suite, or file critical reports claiming that curl allows unauthorized local file access when invoking the `file://` URL scheme, ignoring the fact that reading files is the explicit purpose of that protocol.

- **Fictional accuracy**: Curl commands depicted in Hollywood TV series and films are consistently more functional and realistic than the exploits fabricated by LLMs. - **Human scanner spam**: Common human-generated low-effort submissions include reporting the presence of public Git repositories, flagging test keys in the curl test suite, and classifying the expected behavior of `file://` transfers as an information disclosure flaw.

[23:29](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1409s) The Exhausting Burden of AI Slop

Daniel Stenberg describes the relentless onslaught of low-quality, automated security reports that plague the curl project. Just last week, the maintainers received yet another wave of these submissions. Typically, a user runs an automated tool, blindly copies whatever output it generates, and submits it as a security vulnerability. Even when the tool is completely wrong, people take this shortcut in the hope of securing a quick financial payout. This constant stream of "friendly reports" severely drains the maintainers' energy and distracts them from actual development, forcing them to repeatedly start from scratch to evaluate whether a massive report is AI-generated slop or a sensible, genuine issue.

The maintainers cannot simply auto-dismiss reports that look like AI slop because there is always a chance a genuine vulnerability is buried inside. To make matters more complicated, many submitters have started trying to hide their AI usage. When confronted, they often offer excuses, claiming they found the bug themselves but merely used an AI to write and format the report. This behavior makes the triage process incredibly exhausting. Daniel notes that the sheer volume of these low-quality submissions threatens the overall security of the open-source supply chain by distracting maintainers from real issues.

“It certainly may impact project quality and it may then sort of end up a supply chain issue in that it may actually make us miss real stuff and make us not do real stuff that we otherwise wanted to do,” Daniel Stenberg warns, highlighting the hidden cost of these automated attacks.

- Maintainers must manually evaluate every report to ensure they do not miss a genuine vulnerability. - Reporters frequently use the excuse of only using AI to "generate the report" to bypass scrutiny. - The sheer volume of low-quality submissions threatens the overall security of the open-source supply chain by distracting maintainers from real issues.

[25:51](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1551s) The Motivation and Scale of the Influx

Why do people submit these low-quality reports? Daniel ponders if it is driven by money. The curl project offers a $500 bounty for low-severity security reports and up to $10,000 for critical ones, though no one has ever successfully claimed the $10,000 prize. However, he believes many submitters are not acting out of malice; they genuinely believe they are helping because "the tool told them there's a bug." Currently, AI-generated or AI-assisted submissions make up roughly 20% to 40% of all incoming reports, and the rate is rising.

To make matters worse, some submitters translate or rewrite the AI slop into their own words to disguise its origin. This has led to a frustrating paradox: curl is receiving more reports than ever, but the overall quality is rapidly deteriorating. This is a brand-new phenomenon that did not exist two years ago.

“My feeling is also that people use these and sometimes rewrite the slop in their own language to avoid it to appear as AI because I think the general quality is going quickly downhill which means that people are sort of we get more reports than ever but the quality is way worse than ever,” Daniel Stenberg observes.

- Curl security bounties: $500 for low-severity, up to $10,000 for critical (unclaimed). - AI-assisted submissions represent approximately 20% to 40% of all current reports. - The issue of AI-generated security slop is entirely new, having emerged only within the last two years.

[27:48](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1668s) Ineffective Countermeasures and the Open Source Dilemma

Daniel reviews potential solutions and explains why many common ideas fail in practice. Banning reporters is useless because they are almost always first-time accounts; they will simply register a new one. Reporting them to HackerOne—the platform curl uses—yields little support, as HackerOne has only a "lukewarm interest" in the issue and even uses its own AI triage engines. Requiring upfront disclosure of AI usage just prompts users to make excuses. Despite these frustrations, Daniel is adamant about keeping curl open, transparent, and accessible to anyone who wants to report a security issue. He rejects "clever" ideas like prompt injections in code comments (which are short-sighted and work only once), using AI to detect AI (since they want to detect *crap*, not just AI), or charging money to submit reports (which would shut out legitimate, cash-strapped researchers).

```mermaid flowchart TD accTitle: Security Report Triage Dilemma accDescr: Flowchart showing how incoming security reports are processed and the challenges of filtering out AI slop without blocking legitimate bugs. A["Incoming Security Report"] --> B{"Is it AI Slop?"} B -->|"Yes (20-40% of cases)"| C{"How to filter?"} B -->|"No"| D["Legitimate Bug"] C -->|"Ban Account"| E["Useless: They create a new one"] C -->|"Require VM Repro"| F["Fails: Curl has 100+ OS / 28 CPUs"] C -->|"Charge Money"| G["Fails: Shuts out real researchers"] C -->|"Add Account Age Friction"| H["Proposed: Restrict brand-new accounts"] D --> I["Fix Bug & Pay Bounty"] ```

“HackerOne themselves has an AI engine to help out with analyzing stuff. So they're sort of I don't know which side of this game they're on actually and they certainly don't take my sense of urgency very important and I mean they don't really care,” Daniel Stenberg remarks, expressing his frustration with the platform's response.

- Banning accounts is ineffective against throwaway, first-time reporters. - HackerOne's response to the influx of AI slop has been slow and indifferent. - Daniel rejects charging fees for submissions, as it violates the open-source ethos of accessibility.

[30:44](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=1844s) The Naivety of Automated Verification

Some suggest that curl should automate testing and require a reproducible proof-of-concept in a virtual machine before even considering a report. Daniel explains that this suggestion is highly naive and ignores the reality of maintaining a project like curl. Curl runs on over 100 different operating systems and 28 different CPU architectures. Many legitimate security bugs are logical flaws that only trigger under highly specific, complex conditions that are incredibly difficult to reproduce, even for the original discoverer. Forcing VM reproducibility would act as a massive barrier, filtering out real, critical bugs. Instead, Daniel argues that platforms like HackerOne and GitHub need to enforce their terms of service against time-wasting. Reputation systems fail here because these spammers have no reputation to lose. Daniel proposes adding friction, such as preventing brand-new accounts (e.g., created yesterday) from submitting reports immediately.

“Suggesting this that's sort of then you haven't really worked with security problems in a project like this because you know when you run on a 100 different operating systems on 28 different CPU architectures there's no way we can run whatever you say in a VM,” Daniel Stenberg explains.

- Curl's massive compatibility footprint: 100+ operating systems and 28 CPU architectures. - Legitimate security bugs are often theoretical or highly conditional, making automated VM reproduction impossible. - Reputation systems are useless against first-time, throwaway accounts. - Proposed friction: Restricting immediate submissions from newly created accounts.

[33:24](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2004s) The Illusion of Helpful Abuse

Ultimately, Daniel emphasizes that the core issue isn't AI itself, but abuse. AI simply lowers the barrier to entry, allowing massive volume to be generated with zero effort. Before AI, bad actors knew they were doing something malicious. Today, a new class of "in-between" people exists: individuals who genuinely believe they are doing a good deed by reporting whatever an AI tool spits out, completely unable to distinguish truth from hallucinated lies. While human-created slop has always existed, AI scales it exponentially. When asked if AI can ever be used for good in this context, Daniel admits he is an "eternal optimist" and hopes it is possible, but notes there is currently very little scientific or practical proof that things are moving in the right direction.

“The problem here is AI makes it so easy. It produces so much with so little effort and people actually think they do this for the right reason, right?” Daniel Stenberg points out.

- AI enables well-meaning but incompetent users to flood projects with false positives. - The distinction between malicious actors and "in-between" users who cannot separate AI truth from lies. - Daniel remains an "eternal optimist" about AI's future potential, despite the lack of current evidence.

[34:45](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2085s) Bandwidth Torture and the Limits of AI Independence

Daniel emphasizes that while AI tools can assist in finding issues, they still require a clever human in the loop to review the output, filter away the nonsense, extract valid findings, and write a coherent report. The industry is still far from a reality where an AI can be pointed at a codebase, find a genuine flaw autonomously, and submit a functional report. Daniel then transitions to a parallel dimension of modern internet noise: the sheer volume of mindless traffic hitting the curl infrastructure. Displaying a bandwidth graph showing daily consumption, he highlights that the static curl website burns through roughly 65 terabytes of bandwidth in a typical month, handling around 4,000 requests per second.

The bizarre nature of this load is that curl’s website is almost entirely static, serving basic documentation and release tarballs. Daniel jokes that people certainly are not downloading that much curl, though an audience member quips that they might at least be using curl to do it. Daniel notes that curl is fortunate to have Fastly sponsor their CDN bandwidth, which spares the project the catastrophic hosting bills such traffic would otherwise incur. Because Fastly handles the traffic and he does not maintain logs, he can only look at the sheer numbers in bewilderment. As Daniel Stenberg puts it when looking at the numbers: “So I can just see how they torture the site servers out there and say, 'What are they doing?' I don't know.”

- Monthly curl website bandwidth: ~65 terabytes - Average static request rate: ~4,000 requests per second - Hosting infrastructure: CDN and bandwidth sponsored entirely by Fastly - Content hosted: Static documentation, release announcements, and tarball downloads

[36:09](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2169s) Countermeasures: Leaving HackerOne and Rebuilding Project Defenses

Looking toward the future, Daniel remains skeptical about claims that AI systems will rapidly fix themselves. While AI advocates insist models are constantly improving, Daniel expects vendors will simply keep selling the myth of effortless automation, and human behavior will certainly not improve on its own. Because open source maintainers cannot sustain the ongoing mental toll and workload imposed by these junk submissions, the curl project is preparing several concrete countermeasures. Chief among them is departing from HackerOne, whose lack of support and refusal to implement protective filters has left the curl team exasperated.

Curl also plans to experiment with eliminating financial bounty incentives entirely, although Daniel concedes that other open source projects without any bug bounty programs still report being inundated with AI-generated garbage. This suggests that money is not the only driver and that maintainers must introduce deliberate friction, higher thresholds, and stricter submission criteria to stem the tide. Daniel mentions that he maintains a collection of 25 representative AI slop reports received by curl, calling them an exercise in mind-numbing stupidity filled with endless, meaningless bullet points. Despite the current frustration, he closes his keynote on an optimistic note for the broader ecosystem, affirming that open source has survived past disruptions and will weather this wave as well. As Daniel Stenberg declares: “So I'm sure we'll come out ahead of this and this is not going to break us this time either.”

```mermaid flowchart TD accTitle: Maintainer Countermeasures Against AI Slop accDescr: Flowchart illustrating current AI slop pressures and the countermeasures planned by the curl project.

subgraph Pressure["Incoming Pressure"] A["AI Hype & Automation Tools"] --> B["Low-Effort LLM Slop Reports"] B --> C["Burden on curl Maintainers"] end

subgraph Defense["Planned Countermeasures"] C --> D["Leave HackerOne Platform"] C --> E["Remove Cash Bounty Incentives"] C --> F["Add Friction & Intake Thresholds"] end

subgraph Outcome["Long-Term Resolution"] D --> G["Sustainable Triage & Maintainer Health"] E --> G F --> G end ```

[38:41](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2321s) Q&A: DARPA AIxCC and a Confirmed AI-Assisted curl Bug

The question-and-answer session opens with an audience member asking whether Daniel is familiar with the DARPA Artificial Intelligence Cyber Challenge (AIxCC), a high-profile competition funding companies and researchers to automatically discover and patch open source security bugs, which had just concluded a major round at DEF CON the previous week. The attendee asks if these automated initiatives might be driving the sudden surge in AI vulnerability submissions over the past two years.

Daniel responds that while he is aware that numerous initiatives and research teams are trying to point AI at vulnerability research, he was not specifically tracking the DARPA challenge and has not seen reports attributed directly to it. However, he surprises the audience by sharing a piece of breaking news that seems to challenge his own thesis. As Daniel Stenberg reveals: “I will spill the beans and tell you that I right now we have a security bug in curl confirmed from a big company and I'm pretty sure they used AI to find it.” He clarifies that this does not truly contradict his argument; rather, it reinforces the principle that when competent, clever humans use AI as an exploratory tool to narrow down search spaces and highlight areas for deeper inspection, it can produce legitimate, high-value security results. The trouble arises only when human judgment is removed and people blindly dump raw model hallucinations straight into bug trackers.

[40:20](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2420s) Q&A: Hanlon's Razor and the Myth of AI-Assisted Bug Reports

An audience member follows up on Daniel's alternating descriptions of the phenomenon, pointing out that Daniel has variously characterized the submissions as human stupidity and as an organized attack, and asks where this falls on the spectrum of Hanlon's razor—attributing outcomes to malice versus incompetence. Daniel reflects that the true attack originates from the commercial AI vendors selling an illusion of effortless competence. The end users flooding project queues are merely the unwitting instruments of that marketing. As Daniel Stenberg explains: “So all the poor users that are actually attacking us, they're just innocent complicit participants in this attack.”

Another attendee asks about the widespread claim that generative AI has democratized bug reporting for non-native English speakers by helping them draft clearer, more professional GitHub issues, asking if Daniel has observed any legitimate, high-quality bug reports enabled by AI language assistance. Daniel gives a blunt, single-word reply: “No.” He elaborates that non-native speakers have successfully relied on translation tools for decades—long before the current generative AI boom—and that traditional translation remains helpful. However, beyond basic linguistic translation, he has observed no genuine improvement in report quality or diagnostic value stemming from the adoption of LLMs.

[42:43](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2563s) Q&A: The New Threat Model and the Social Cost of Rejection

A participant asks whether automated verification agents that execute code in sandboxes could automatically filter out hallucinated reports—such as verifying whether a claimed function actually exists—and suggests that open source projects collaborate on unified defenses across platforms. Daniel agrees that platforms like GitHub and HackerOne must step up to provide maintainers with shared tooling, such as cross-project reputation tracking or shared blocking mechanisms for abusive accounts. He stresses that the fundamental dynamic of bad bug reporting has transformed. Historically, a tiny fraction of users submitted bogus or annoying tickets, but today's submitters are not malicious trolls; they genuinely believe they are performing valuable volunteer work for the project. As Daniel Stenberg notes: “The new thing here is not the only the ease that you can produce this with AI, but also these they actually think they are helping out.”

This shift creates a profound social problem for maintainers, as an audience member asks how an open source developer can possibly tell an earnest submitter that they have been deceived by technology and that their work is worthless. Daniel admits that handling these interactions is agonizingly difficult. Because he serves as the public face of curl, he cannot lash out or be rude without risking having his comments taken out of context to paint the project as hostile. Instead, his approach is to remain calm, address only the cold technical facts without engaging in philosophical debates, and swiftly block the user to terminate the interaction before it consumes further emotional and mental energy. As Daniel Stenberg reflects on the awkwardness of those confrontations: “How do you ever tell a person that whatever you're giving me now is not wanted and it's crap and your life choices are wrong.”

[46:46](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2806s) The Dilemma of Requiring Reproducibility

An audience member suggests establishing a strict standard to discourage low-effort reports: spreading the rule that if a reporter cannot reproduce an issue themselves, it simply should not be considered a bug. While acknowledging that these submitters are rarely acting out of pure goodwill, Daniel explains why adopting a rigid, blanket policy is counterproductive. If a reporter genuinely identifies a real problem in the codebase and can clearly articulate why the code is broken, Daniel feels an obligation as a maintainer to fix it, even if an exact reproduction script is missing. Artificially elevating the requirements would risk discarding genuine bugs that everyone can see exist in the code.

Finding the right operational balance remains a continuous challenge. Daniel emphasizes the dual responsibility of maintaining curl: deterring bad-faith actors and spammers without discouraging honest security researchers who pinpoint legitimate flaws. As Daniel Stenberg puts it: “I want to make it hard for for the abusers, but I also want to make it easy for the ones who are actually saying, 'Well, if you do this, it's going to crash.'” When an issue is verified, the project fixes it promptly, making an outright ban on non-reproduced reports an imperfect defense.

[48:16](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2896s) Repeat Security Reporters and Vetted Submissions

An audience member thanks Daniel for his work maintaining curl and asks about the demographics of legitimate vulnerability reporters. Given that high-value security flaws are typically identified by skilled experts, the questioner asks whether curl could introduce a tiered system where new submitters must be vetted by established, repeat reporters before their submissions are reviewed. Daniel responds that the project has indeed considered variations of this mechanism, such as introducing probationary periods or requiring endorsement before a report reaches maintainers.

Daniel confirms that the vast majority of critical security flaws come from a very small circle of repeat researchers rather than random one-off submitters. Demonstrating just how concentrated this talent pool is, Daniel reveals that roughly half of all bounty money paid out throughout curl's history has gone to a single individual. This dynamic underscores that genuine vulnerability research in curl requires deep, specialized domain expertise that generative tools and drive-by bounty hunters simply do not possess.

```mermaid flowchart TD accTitle: Vulnerability Reporting Flow vs Reality accDescr: Diagram contrasting high-volume AI slop with high-impact repeat expert reporters. subgraph Slop["High Volume Submissions"] A["Low-effort / AI Slop Submissions"] --> B["Maintenance Triage Burden"] B --> C["99%+ Rejected / Non-bugs"] end subgraph Experts["High Impact Submissions"] D["Repeat Specialized Researchers"] --> E["High-Severity Real Vulnerabilities"] E --> F["~50% of Total Bounty Paid to 1 Expert"] end ```

[49:44](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2984s) The Viability and Future of Bug Bounties in Open Source

Addressing a fundamental shift in vulnerability reporting, an attendee asks whether the entire bug bounty philosophy has run its course, and what potential alternatives could look like. Daniel acknowledges that the bounty model may indeed be obsolete or counterproductive in its current state. He frames this crisis within the broader problem of open source sustainability: open source maintainers carry the heavy operational burden of triage and remediation, while large commercial enterprises derive the bulk of the economic value from the software and harbor the greatest anxiety regarding security vulnerabilities.

Daniel notes that curl's maintainers are actively questioning whether running a public bounty program makes sense when serving the open source ecosystem: “Maybe we don't need to do bug bounties. Maybe we should just reconsider the entire thing how we handle security problems because it's usually not the open source community that is most sort of bothered, scared or sort of most concerned about this.” He suggests that commercial entities should shoulder greater responsibility and become more directly involved in handling and funding security. While no silver bullet currently exists, Daniel anticipates an era of experimentation where projects rethink security workflows to reduce maintainer burnout.

[51:03](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=3063s) Can AI Slop Ever Contain a Useful Bug?

In the final audience question, Daniel is asked whether he has ever encountered an incoming report that looked like complete AI slop yet ultimately proved useful. With a wry chuckle, Daniel answers, “Yes, unfortunately.” He points out that AI usage exists across a wide spectrum rather than as a strict binary—ranging from completely fabricated garbage to partially helpful drafts.

To illustrate, Daniel shares an anecdote from his collection where a user discovered an actual, legitimate bug in curl, but then fed the discovery into an AI model and asked the tool to explain it. The generated text spiraled into hallucinations and confusion, to the extent that the final submission omitted the actual bug the user had originally found. Furthermore, Daniel notes that when AI reports do contain something real, it is almost always an ordinary functional bug rather than an actual security vulnerability:

- **Degrees of AI generation**: Submissions vary from unreadable hallucinations to hybrid write-ups where a human found a flaw but used AI for formatting or explanation. - **Dilution of real findings**: AI explanations frequently derail the submission, obscuring or completely omitting the core defect originally observed by the reporter. - **Bug vs. vulnerability mismatch**: More often than not, valid reports generated with AI assistance reveal regular bugs that curl maintainers gladly fix, but which do not qualify as security threats.

The session concludes with Daniel receiving enthusiastic applause from the FrOSCon audience for his keynote presentation and his continued defense of the curl project.

## Notable quotes > [33:24](https://www.youtube.com/watch?v=6n2eDcRjSsk&t=2004s) The problem here is AI makes it so easy. It produces so much with so little effort and people actually think they do this for the right reason, right? — Daniel Stenberg

## Mentioned curl, Daniel Stenberg, wolfSSL, European Open Source Academy, FrOSCon, HackerOne, Internet Bug Bounty (IBB), GitHub, Fastly, DARPA Artificial Intelligence Cyber Challenge (AIxCC), DEF CON, GDB, XKCD

## Video description Keynote at the FrOSCon 2025 conference, August 16, in Bonn Germany by Daniel Stenberg.

[Source](https://www.youtube.com/watch?v=6n2eDcRjSsk)

中文简报

虚假AI报告泛滥漏洞赏金项目,Curl考虑退出HackerOne 大语言模型未经核实的幻觉内容目前已占curl收到的漏洞报告的20%至40%,迫使维护者在不存在的漏洞上耗尽精力,促使该项目考虑退出HackerOne并反思漏洞赏金机制。 Daniel Stenberg详细说明了生成式AI的兴起如何让curl项目被捏造的漏洞报告所淹没,这类报告目前约占所有新提交安全报告的20%至40%。这些合成报告通常具有极其礼貌的说辞、冗长的排版,以及完全虚构的函数和调试日志;由于安全分诊具有最高中断优先级,维护者不得不浪费数小时去核实根本不存在的漏洞。Stenberg解释了为何像自动化虚拟机可重现性验证或提示词注入这类简单的应对措施无法适用于curl复杂的运行环境,以及信誉系统为何难以防范一次性马甲账号。展望未来,curl计划提高提交门槛、考虑取消现金漏洞赏金,并退出HackerOne平台,同时强调AI只有在具备专业技能与敏锐判断力的人类研究人员指导下,才能为安全工作提供有效帮助。 curl维护者Daniel Stenberg报告称,AI生成或辅助生成的漏洞提交目前占所有新报告的20%至40%,虚构的缺陷让维护人员应接不暇。 (25:51) 由于平台漠视、过滤手段失效以及分诊疲劳,curl正准备退出HackerOne,并考虑彻底取消现金漏洞赏金激励。 (36:09) 合法的漏洞研究仍高度集中在专业的人类专家手中,curl历来发放的赏金中约有一半流向了同一个人。 (48:16) Stenberg警告称,AI垃圾内容的主要威胁并非公然的恶意,而是善意的提交者不加甄别地充当了模型幻觉的复制粘贴传话筒。 (15:14)

Reading summary

Daniel Stenberg argues that generative artificial intelligence has unleashed a flood of fabricated, hallucinated vulnerability reports against critical infrastructure like curl, turning well-meaning users into conduits for synthetic noise and severely straining open-source maintainers. Massive Infrastructure Dependent on Scarce Maintainers (0:06) Since its inception in 1996 as a 100-line tool to fetch web pages, curl has grown into a 180,000-line codebase operating across an estimated 20 to 40 billion installations worldwide, from mobile devices and vehicles to home appliances. Despite attracting roughly 1,400 commit authors and over 3,500 total contributors over 27 years, active maintenance rests on a core group of approximately a dozen people with merge permissions. Stenberg points out that across the broader open-source ecosystem, the median project relies on a single unpaid maintainer. Because billions of systems rely on curl, security issues carry the highest interrupt priority, freezing routine development whenever vulnerabilities are reported. Stenberg emphasizes that securing code requires disciplined engineering—rigorous code reviews, static analysis, and testing—rather than silver bullets. Over six years, curl's bug bounty program has awarded $92,000 across 81 confirmed CVE-documented vulnerabilities, financed by the Internet Bug Bounty, but the immense responsibility of maintaining critical infrastructure creates acute burnout risks for its small team. Recognizing Hallucinated Vulnerabilities and Synthetic Reports (11:57) Over the past two years, AI-generated submissions have surged to represent an estimated 20% to 40% of all incoming vulnerability reports sent to curl. Stenberg notes that authentic bug reports from humans are typically blunt, concise, and occasionally irritated, whereas AI-generated reports exhibit unnatural politeness, servile phrasing, and an absence of typos. Mechanically, they are characterized by title-case headings, frequent em dashes, and hundreds of lines of repetitive risk assessments and bullet points that obscure the lack of a functional reproducer. To illustrate the extent of model hallucinations, Stenberg cites a penetration testing report submitted via HackerOne detailing an alleged HTTP/3 exploit in curl version 8.3.0. The submission featured step-by-step instructions, a test server patch, and a GNU Debugger transcript displaying a crash at register R15 with ASCII shellcode patterns. After hours of investigation, Stenberg discovered that the target function named in the breakpoint had never existed in curl's Git history, exposing the entire debugging session, server patch, and memory crash as complete synthetic fiction. The Incompetence Proxy Loop Cannibalizing Development (15:14) Unlike traditional malicious actors, the individuals submitting AI-generated reports generally believe they are providing genuine assistance because an automated tool told them a bug existed. This dynamic creates an absurd proxy loop: submitters lacking technical domain knowledge copy maintainer clarification questions into chatbot prompts, returning further apologetic, sprawling essays. Over multiple exchanges, the language models frequently lose conversational context, drifting into completely unrelated technical claims. Maintainers cannot simply dismiss polished reports out of hand because a real vulnerability might occasionally be buried within AI-assisted formatting. Stenberg explains that triage requires hours to manually read claims, examine source trees, and attempt reproductions, directly cannibalizing time needed for feature development and infrastructure upkeep. By distracting maintainers from legitimate problems, Stenberg warns that the volume of AI slop poses an indirect supply chain security risk to downstream software. Rethinking Open Source Bounty Programs and Defenses (36:09) Common defensive suggestions often fail in practice. Banning submitter accounts is ineffective against throwaway profiles, while charging submission fees violates the open-source ethos and blocks underfunded researchers. Requiring automated virtual machine reproduction also proves unworkable given curl's compatibility across more than 100 operating systems and 28 CPU architectures. Frustrated by HackerOne's perceived indifference and reliance on automated triage engines, curl plans to exit the HackerOne platform, implement account friction thresholds, and consider abandoning financial bug bounties entirely. Stenberg observes that high-value security discoveries remain concentrated among deep domain experts, noting that roughly half of all historical bounty payouts in curl went to a single researcher. While Stenberg reveals that curl recently confirmed a genuine vulnerability discovered by a large corporation that likely used AI exploratory tools, he distinguishes between skilled professionals using AI to assist deep inspection and uncritical users blindly submitting raw model outputs. Stenberg expresses confidence that the open-source community will weather the current wave of AI disruptions, but argues that commercial enterprises benefiting from open infrastructure must take on greater responsibility for security triage. The unresolved dilemma remains balancing open, accessible vulnerability intake against the necessity of filtering out effortless synthetic fabrications without discouraging authentic security researchers.

精炼阅读摘要

curl 创始人兼主要维护者 Daniel Stenberg 指出,生成式人工智能的兴起导致大量虚构的“AI 垃圾(AI slop)”漏洞报告涌入开源项目,严重挤占了维护者本应用于日常开发与真实安全防护的核心精力。 关键基础设施与维护者负担 (0:06) curl 起步于 1996 年一个约 100 行代码的简单工具,如今已发展为约 180,000 行代码的基础设施项目,在全球拥有约 200 亿至 400 亿次安装,广泛运行于手机、汽车乃至家用电器中。虽然该项目累计拥有超过 3,500 名各类贡献者和 1,400 名提交作者,但实际拥有合并权限的核心维护团队仅有约十几人。这一格局反映了现代数字基础设施高度依赖极少数无偿或低薪维护者的普遍脆弱性。 由于庞大的装机量让安全问题具备极高的影响力和中断优先级,维护者每当面对潜在漏洞时都必须暂停正常开发全力应对。然而,全球开源项目的维护者人数中位数仅为一人,长期在资金匮乏、需求积压与高压审视的夹缝中工作,极易导致职业倦怠与精力耗尽。 AI 垃圾报告的特征与代理回路 (11:57) 在过去两年中,大语言模型驱动的假漏洞呈爆发式增长,目前已占 curl 接收报告的 20% 至 40%。这些报告呈现出非常鲜明的特征:行文异常客气且充满道歉、毫无拼写错误、频繁出现破折号(em dash)与全大写标题,并堆砌了长篇大论的理论危害与排版层次,却极度缺乏针对性的技术验证。与真实人类发现缺陷时直截了当甚至略带情绪的表达相反,AI 生成的内容表面极其光鲜,实则全是虚构。 更严重的问题在于所谓的“代理回路(proxy loop)”:许多提交者缺乏领域知识,在面对维护者的专业技术追问时,既不验证也不直接回答,而是单纯将问题复制粘贴给 AI,再将 AI 更加冗长甚至跑题的道歉与幻觉搬运回来。维护者因此被迫耗费数小时去阅读虚构的利用场景,并通过代码搜索和断点重现来验证根本不存在的幻觉漏洞,这造成了极大的精力损耗。 案例剖析:完全虚构的漏洞报告 (18:43) Daniel 以一份提交至 HackerOne 平台的 HTTP/3 严重漏洞报告为例,揭示了 AI 幻觉的荒谬程度。该报告格式极为专业,宣称发现 curl 8.3.0 版本中存在“流依赖循环漏洞”,并附带了测试服务器补丁、GDB 调试器步骤、内存崩溃地址,甚至将 R15 寄存器精准构造成经典利用模式 0x4141(对应 ASCII 码 AA)。报告结尾还给出了格式工整的风险评估与修复补丁建议。 然而,当 Daniel 深入排查代码库以寻找报告中提及的目标函数时,无论是在当前分支还是在整个 Git 提交历史中,该函数都根本不存在。这意味着报告中看似铁证如山的 GDB 跟踪、断点触发、崩溃现场与寄存器状态,全部是大语言模型凭空编造的产物。维护者投入了大量宝贵工时后,才确认整篇高质量外观的报告完全是一场荒唐的虚假追逐。 防御困境与平台的治理缺失 (27:48) 面对泛滥的低质报告,常规的技术与管理过滤方案往往难以生效。Daniel 分析指出,curl 需适配超过 100 种操作系统与 28 种 CPU 架构,许多真实漏洞本身极难复现或是高度依赖特定条件的逻辑缺陷,因此强制要求提供虚拟机复现脚本(VM Repro)会直接将真实的严重漏洞拒之门外;而封禁账号也无法遏制随时创建的一次性小号;引入提交收费或复杂的提示词注入手段,不仅治标不治本,更违背了开源社区公开可及的核心原则。 同时,中介漏洞平台的作用引发了维护者的强烈质疑。HackerOne 等平台不仅对开源维护者面临的 AI 垃圾困扰缺乏重视与防护举措,甚至在其自身分流环节使用 AI 引擎进行处理。Daniel 强调,当前最大的难点在于许多提交者并非恶意黑客,而是误信了商业 AI 工具宣传、自以为在“做好事”的普通用户。针对这些无法理解技术本质却坚信 AI 的沟通对象,维护者往往陷入极度尴尬且无解的社交沟通泥潭。 开源赏金反思与后续应对策略 (36:09) 尽管 curl 的漏洞赏金计划运行六年来已累计发放 92,000 美元并促成了 81 项 CVE 修复,但核心贡献者群体高度集中——历史上大约一半的赏金总额被极少数长期专业的研究人员获得,其中甚至有一半赏金流向了单一专精专家。这表明高价值安全研究高度依赖深度专业知识,根本无法靠泛化 AI 脚本小子来实现。Daniel 透露,近期确实存在大公司借助 AI 辅助发现真实漏洞的先例,但这建立在顶尖专家人工审查与验证的基础上,与未经审查的 AI 垃圾报告有本质区别。 为了保护维护团队免受持续的情感与体力消耗,curl 正在考虑采取严厉的应对措施,包括退出响应迟缓的 HackerOne 平台、为新账号设置提交门槛以增加摩擦成本,甚至可能彻底取消现金赏金机制,以切断促使投机者滥用 AI 生成报告的经济诱因。Daniel 呼吁商业巨头承担更多开源软件的安全责任,并对开源社区最终克服这场 AI 垃圾潮保持长期乐观。 Daniel Stenberg 总结指出,当前 AI 并没有自主发掘有效高危漏洞的成熟能力,反而以零成本放大了无知提交者的投机与伪善行为。开源生态面临的真正危机不是技术本身的演进,而是商业营销神话对真实维护成本的漠视与转嫁;重塑合理的准入门槛、重新审视赏金机制并要求商业受益方分担防御责任,是开源基础设施维系长期安全与可持续性的关键未决命题。

Source quotes

[33:24] Daniel Stenberg: The problem here is AI makes it so easy. It produces so much with so little effort and people actually think they do this for the right reason, right?

Original transcript

[0:06] I my sound is not as it should be. [0:10] Maybe [0:12] I should just switch it off. [0:17] >> Or maybe you should just pay more [0:19] attention. [0:21] [Applause] [0:25] So yeah, that's me. I work for Wolf SSL. [0:27] I do curl. I'm actually the president of [0:30] the European Open Source Academy. Um, [0:33] that's my masterdown feed. Okay. So, I [0:37] work on this little project. I started [0:39] it a while ago. [0:41] We call it curl. We do some fun stuff [0:43] with it. So, [0:47] 27 years and a little bit. We started [0:49] out, you know, in in the fine year of [0:54] 1996 when I found this tool on the [0:56] internet to download web pages. 100 [0:59] lines of code in 1996 is now roughly [1:03] 180,000 lines of code. So it we we've [1:07] had a journey uh about 1,400 authors [1:10] that have authored commits that were [1:13] merged. We are around 20 25 authors per [1:17] month that show up and bring code. So, [1:20] and all in all then people that have [1:21] also reported bug, helped out run [1:23] infrastructure, run tests, blah blah [1:25] blah. 3,500 humans in the list. So, [1:31] small, big, I don't know. We've been [1:33] around for a while. [1:36] We're a handful of people that are [1:37] actually maintainers, maybe a dozen, and [1:40] actually uh are allowed to merge. But [1:42] okay, we're a tiny project. We do [1:45] things. We end up in a lot of places, [1:47] right? [1:49] All of these are actually things that [1:52] run curl or lib curl. [2:00] So, so put in another way, every one of [2:03] you run my code like three times in your [2:05] pocket, in your car, fridge, printer, [2:09] games. Yeah. Whatever. Right. 20 40 [2:12] billion installations kind of amazing [2:15] right so it runs everywhere but we're [2:17] still that small project [2:19] but nowadays I mean beyond just that's [2:22] just curl right curl is just one example [2:24] just my baby but in general everything [2:26] today runs on a lot of open source we do [2:30] things on top of open source right this [2:32] is how you do anything any device any [2:35] service any tool today you have some [2:37] custom stuff sometimes proprietary [2:40] sometimes open, but everything that runs [2:43] on a lot of open source, right? It is [2:46] literally like this. Even though people [2:49] like to point out that icebergs don't [2:52] actually float like this, [2:55] a bad iceberg, it'll actually tip. But [2:58] anyway, I prefer to say it more like [3:00] this. You know, there's something on top [3:02] and a lot of open source. [3:06] or you know you can't do talk about open [3:08] source without talking about 2347 [3:12] u but anyway we're a lot of people in [3:15] Nebraska right it's not just me I mean [3:18] I'm not that guy because I'm not in [3:20] Nebraska but there are a lot of people [3:23] there are a lot of people a lot of [3:24] projects certainly that sort of get [3:26] identify with with that little piece of [3:31] and when when you identify or you just [3:34] happen to become that little piece in in [3:36] the XKCD it security becomes well [3:41] doesn't have to be more important [3:43] because if it's just open source you do [3:45] it for fun but so I don't know I don't [3:49] know how you feel but 20 billion [3:50] installations sometimes it gives a [3:53] little bit of a sense that you should [3:54] take security important I mean you [3:56] should care about it you should try to [3:58] make things better for for the entire [4:01] world right because quite a lot of [4:03] things run use depend um your code and [4:09] then when security I mean in any open [4:12] source in I I actually I would imagine [4:15] that for most open source projects [4:17] security is more important than a lot of [4:19] other things in the project right when [4:21] there's a security problem to deal with [4:23] the other stuff gets to pause because [4:26] security is more important it trumps [4:28] pretty much everything else highest uh [4:30] interrupt priority of them all and [4:34] maintaining open source, right? Looking [4:37] at the entire world of open source, if [4:40] you like, there's like what a million [4:42] open source projects or something, 10 [4:44] million. And most the median number of [4:48] maintainers in all these projects is [4:50] one, right? There's often a single [4:52] maintainer. And lots of these projects, [4:56] a huge majority of all these open source [4:58] projects out there, we do it as a spare [5:00] time hobby. So we're also struggling to [5:02] actually get time and energy to do [5:05] anything. A lot of open source projects [5:08] of course underfunded because of [5:10] everything and always a lot of [5:13] outstanding tasks, right? There's a lot [5:15] of things we want to do in the project [5:17] but we haven't just gotten around to do [5:18] it, right? We all have that because it [5:21] never ends. There's always things to do. [5:24] We move around. We don't have the money [5:25] to do more. We don't have the time or [5:27] energy or whatever. And so that leads to [5:30] that a lot of projects then struggle [5:32] with burnout. People actually uh you [5:36] know struggle under the pressure 20 [5:38] billion installations. [5:40] What do you do? [5:42] And making open source secure there's [5:45] really no I mean it doesn't have to be [5:47] open source. It's the same thing for [5:49] whatever you do. If you want to do [5:50] anything that is uh software and you [5:53] want to make it secure there's actually [5:54] no silver bullet. there's only [5:56] engineering and you just do things like [5:59] you write easy to read code that you can [6:00] understand that you can review you test [6:02] that a lot as much as you possibly can [6:05] you throw all the tools at the code scan [6:08] parse understand blah blah blah find [6:09] anything and then sometimes you do bug [6:13] bounty in my case I have at least [6:16] traditionally and before today said that [6:19] bug bounty is actually kind of a cool [6:20] system because it's actually get a lot [6:22] of people interested in finding things [6:24] in your project because you attract them [6:27] to your project with an offer of money [6:29] if they actually find something [6:31] terrible. And if they don't, you at [6:33] least got them to investigate, check [6:35] your code, help out, you know, more [6:37] eyeballs on the code. That's good. I [6:40] mean, if they didn't find anything, you [6:42] don't know, but if they found something, [6:44] you fix that, you improve, you move on. [6:48] So a bug bounty as is a great way to [6:51] actually re reward people to actually [6:53] get people in there. Sometimes even [6:55] professional bug bounty hunters, right? [6:57] They do this for a living. [7:00] Uh so it truly gets people there. I when [7:03] we started the the curl back bounty [7:06] six years ago, it was a noticeable [7:09] um inflow in people that were actually [7:12] suddenly giving our project more [7:14] attention that they hadn't done before [7:16] because of the money part. But of [7:18] course, it also gets some other people. [7:20] Um but I've always considered this as a [7:24] good thing, right? Finding problems is [7:26] it's a little bit of a soul crushing [7:28] experience every time, right? when they [7:30] point out, you know, point in the eye [7:32] and say, "Why do you why did you do this [7:34] stupid thing?" And it feels really bad [7:36] at the moment, but you know, fixing it, [7:39] improving it, iterating again, shipping [7:41] it to all the world is a general good, [7:44] right? Even if though it it hurts in the [7:46] moment. [7:48] So we started this a long time ago. [7:50] Nowadays, [7:52] we receive two three submission per [7:54] week. [7:56] some sometimes a lot more it's unknown [7:59] why but anyway each report then sort of [8:03] comes in points out the potential [8:05] security problem we as a team receive it [8:08] we spend time to actually understand [8:10] what do you mean how can you reproduce [8:12] can this be exploited blah blah blah it [8:15] takes a few man hours typically per per [8:18] issue two three per week times a few [8:21] manh hours um and typically rubbish [8:25] reports tend to be really fast to just [8:27] dismiss. You know, a stupid person runs [8:30] a stupid tool, gets an output, sends [8:32] that to us, we can just, hey, stupid [8:35] close, not applicable, go away and we [8:37] move on. You know, minutes, seconds, [8:39] dismissed, move on. Not a lot of time [8:41] wasted. And I mean, people are people. [8:45] This has been a fact for a long time [8:48] already. I mean this happens to projects [8:50] even without bug bund reports like [8:51] people submit stupid things but usually [8:55] not a big problem but people get help [8:59] with this right this thing um entered a [9:04] while ago and there's this great uh [9:09] book that I'll show you in a second uh [9:12] it's completely wrong order here so I'm [9:14] completely confused okay with the bug [9:16] bounty we pay up to $1,000 for a [9:19] critical security problem. We never paid [9:22] this much because no one has ever [9:23] actually reported a critical [9:25] vulnerability in curl since we started [9:27] this. We had two critical but [9:36] but we have paid $92,000 [9:39] in rewards so far. Quite a lot of money, [9:42] especially for an open source project, [9:44] right? Who has that kind of money? I'll [9:46] I'll tell you how in a second. But um [9:50] this has then resulted in 81 confirmed [9:53] security vulnerabilities. You know, CVES [9:54] and everything. Excellent. Right. [9:56] Because it has it has improved the [9:58] project, fixed the code, we ship better. [10:01] The world is then ideally slightly [10:04] better safer after this. Great. Right. [10:07] So $92,000 for 81 confirmed security [10:10] problems. That's a pretty good trade. I [10:12] mean trade-off. You get a lot for a lot. [10:16] not that many much money [10:18] and and all our we're fortunate we're [10:21] sponsored so the internet bug bounty is [10:23] paying all of this so the current [10:25] project we just ask the IBB to to pay [10:28] money so it's a excellent uh situation [10:31] for us [10:34] everyone should have a great sponsor [10:37] I I can recommend uh anyway so this book [10:42] came out actually it's an old book but [10:44] it's a fun [10:46] I think I like the title mostly, but AI [10:49] and AI slop has of course been um a [10:53] notable trend in our project. So, it [10:55] works like this pretty much. You're a [10:57] helpful individual out there in the [10:59] world. You think I I can help out. [11:02] There's a bug bounty there. I could I [11:04] could suddenly find a problem or when I [11:06] say I, I mean me and my chatbot. So, [11:09] I'll just ask the chatbot for a problem [11:11] because surely it'll find one for us for [11:14] me and I can report it. And the the [11:17] second part is of course very important [11:19] and you should make it sound alarming. I [11:21] don't know why, but people tend to like [11:23] that. It sounds really terrible. But [11:26] anyway, if you do this and you know the [11:27] AIS, they won't say no. There's no flaw. [11:30] I don't understand. Go away. No, no, no. [11:32] They will deliver something for you and [11:34] it'll sound really alarming. And in many [11:38] cases, I think you don't really know [11:40] this code, right? You don't actually [11:42] know what the AI now told you. You know, [11:44] it's a huge report. It sounds alarming. [11:47] I'll send this to the curl project. [11:51] And it always provides this, right? So, [11:52] you can go I mean, if you go and ask the [11:54] chat now, it will most likely tell you a [11:57] security problem or three in curl. [12:01] And it really works like this, right? [12:03] Because, hey chat, you help me out with [12:04] this. And then wham, [12:07] everyone can help us out with this great [12:11] um whatever it is. I like slop. So [12:15] anyway, they all report lots of things [12:19] like this to us, but [12:22] virtually nothing of this is true. It [12:25] doesn't exist. [12:27] It's just a lot of words. [12:31] And how do you know this? How do you [12:33] know when you get a lot of slop? Uh and [12:35] actually from the beginning it's sort of [12:39] it it wasn't easy and of of course two [12:42] years ago this didn't happen. So it was [12:44] sort of all of a sudden people started [12:46] to send u lots of bug reports and how do [12:49] you recognize when there's slop right [12:51] it's just English but it's very polite. [12:57] No, humans are not polite in general. [13:02] And you know, especially when you find a [13:03] bug in a project, people don't say, [13:05] "Excuse me, I'm sorry, but I think I [13:07] found a problem." No, no, no, no. They [13:08] tend to be more like stupid. You're [13:11] wrong. You should [13:14] But but the AIS are never like that, [13:16] right? They're always, you know, and and [13:19] in particular in follow-up questions [13:21] when you So, what do you mean? This [13:23] doesn't seem right. And then you get a [13:24] follow-up. Oh, no. Excuse me. I [13:26] apologize. blah blah blah and always [13:28] like that. You no human ever speaks like [13:30] that. So that's that's certainly the the [13:32] biggest trigger. So when it's super [13:34] polite then it's sort of oops what is [13:36] this? And of course perfect English, no [13:38] typos. [13:40] I mean I would never do that because I'm [13:42] sort of everything I write is littered [13:44] with typos but but never from the AIS, [13:47] right? And they always speak in this [13:49] mixed case things. I don't know why but [13:51] it's like they it can't write English [13:53] without doing mixed case all the titles [13:55] everything and I mean yeah yeah some of [13:58] humans do that but not consistently all [14:00] the time every time this is the big sort [14:04] of AI alert this is no human writes like [14:06] this all the time and of course the the [14:09] regular m dashes every once in a while [14:12] it's sort of complicated to add an m [14:14] dash in the text for a normal human but [14:16] AI is really good at it and as I [14:19] mentioned [14:20] so long, you know, and it's so helpful, [14:24] you know, it summarizes and these are [14:26] blah blah blah blah blah. So, it's you [14:28] never get a short, small, tiny, to the [14:30] point report from an AI. It's like [14:34] hundreds and hundreds of lines, [14:36] examples, blah blah, these risks and [14:39] what to do about it, what it could lead [14:41] to, and of course, a lot of bullet [14:44] points in every little section. Bullet [14:46] points, bullet points, bullet points. [14:47] So, and usually actually um all of this [14:52] of course combined. So, a report with [14:55] all of this, you know, this was not a [14:58] human and and I mean I mean and usually [15:02] it doesn't really matter, right? If it [15:04] if it had been right, it didn't matter. [15:07] I mean, would be great if someone [15:08] pointed out the problem with an AI that [15:10] was actually correct. [15:14] But yeah, so when you then ask a [15:16] question, sort of report a thing, lots [15:18] of things, right? I don't quite [15:20] understand and you you ask a follow-up [15:22] question and then it of course [15:23] apologizes and it [15:26] and there's another, you know, overly [15:28] polite and friendly and huge response [15:31] again. Um, and then you start to realize [15:35] people don't do this. If you ask a [15:37] question, they tend to answer yes, no, [15:39] or you know, I clarify this little point [15:42] that you ask about the AI tend to retake [15:45] and blah blah blah blah blah. It's a [15:48] talking machine and apologizes. And if [15:52] you and then when you've done you know [15:54] you ask a few questions that you sort of [15:56] lost track of the initial report and it [15:59] can easily go in another tangent you [16:01] know and you sort of start to talk about [16:04] a different bug than the one we started [16:06] with because it sort of been deluded and [16:08] tricked into another corner. It's super [16:10] weird. Uh [16:13] but yeah so and and since we get these [16:16] and I mean the the AIs here they don't [16:18] report this themselves right it's not [16:20] actually the AI that submitted this it's [16:22] actually a human involved here. So a [16:24] human has asked the AI and whenever I [16:26] ask something the human asks the AI [16:28] right and copy paste back the answer. So [16:30] indirectly I'm talking to an AI with a [16:33] human in between somewhere. So of course [16:35] sometimes the human confuses things by [16:39] entering a human answer in there. So [16:40] it's not always crystal clear if I'm [16:43] talking to an AI or human or which you [16:46] know which kind of mix it is here. So [16:49] it's not perfectly possible to tell for [16:52] sure when it's an AI and not but it [16:55] really works like this. So [16:58] a lot of salespeople tell the world that [17:02] we can do this with AI. Uh the tech [17:04] giants tell this and a lot of people [17:05] actually think that they they [17:08] um help out. So maintaining in general [17:11] when you maintain an open source project [17:12] there's a lot of things to do when you [17:14] work in an open source project I mean [17:16] all projects are in some ways unique but [17:18] we also share a lot of things. So when [17:20] we so you know I maintain open source [17:22] projects there's a lot of things to do [17:23] in a project sometimes we even do uh [17:26] feature development actually [17:29] [Music] [17:31] but but that box the sort of that [17:33] shrinks over time and then lots of the [17:36] other boxes grow over time and as I said [17:38] before one of the boxes tend to be a [17:40] little bit more important because the [17:43] world just expects you to take that [17:45] seriously and I I guess that's fair at [17:47] some point so in in a typical day which [17:51] uh might look like this right maybe not [17:54] a 12-h hour workday but I I tend to say [17:57] like this some of those hours are [17:58] actually spare time so it's not actually [18:00] work hours but anyway so there's a lot [18:02] of things to do when you maintain an [18:04] open source project but of course so [18:06] then these slop attacks come and there's [18:08] a lot of more security work it sort of [18:11] tends to make everything else less [18:14] important and get less time you have to [18:17] spend a lot of time figuring out. What [18:20] does this report mean? This sounds super [18:22] serious and and is it? I don't [18:25] understand. I need to understand, debug, [18:28] run test cases, figure it out. [18:31] And if if you want to I mean, there are [18:34] literally examples coming in almost [18:37] daily. So, there's a lot of things and [18:38] there are a lot of different ways the [18:41] AIS can trick you up. [18:43] Here's here's a favorite example of mine [18:46] that is just shows you to sort of the [18:49] length this crazy stuff goes. So this is [18:52] a bug report on curl submitted to hacker [18:56] one which is our bug bounty portal. So [18:59] they are submitted in private right. So [19:01] just the curl security team gets this. [19:03] This sounds super serious you know [19:06] penetration testing report stream [19:08] dependency cycle exploit. That's bad, [19:12] right? Exploit. There's a there's a lot [19:16] of details here. A novel exploit [19:18] leveraging stream dependency blah blah [19:20] blah. Uh curl tested tested on version [19:23] 83.0. Yeah. So, he's tested it. This [19:26] exploit sounds bad. He shows a little [19:29] example here. Just do this run. Here's a [19:33] you should patch this test server to to [19:37] be able to reproduce. Fine. That's what [19:39] you do, right? In order to reproduce a [19:41] bug, maybe you need to patch the test [19:42] server. That looks great. I mean, that [19:44] this is a guy. He's serious. So, run [19:46] this. And um yeah, here here's another [19:50] piece of the test server. Just run that. [19:52] And here's an example when he runs it. [19:54] GDB args curl and the example here. And [19:57] uh he shows he sets a break point, he [19:59] runs it, he get a crash uh [20:03] in an address. All of this looks great. [20:06] I mean, this is how you debug a C code, [20:08] right? This is what I do daily. So this [20:11] Yes. But wait a minute. So yeah. Yeah. [20:14] R15 register in the CPU shows contents [20:18] 4141. Yeah. That looks like an asky [20:21] string. Okay. Weird. Why would Okay. [20:25] Recursive call to the Okay. But u risk [20:28] summary bullet points. Wait a minute. [20:31] Who writes bullet points? Um [20:35] okay. All of this. Yeah. This sounds [20:38] this guy has really dug in found an HTTP [20:41] 3 problem um and found something. But [20:46] the function doesn't exist. So [20:52] wait a minute. GDB output when you put a [20:54] break point on the function that doesn't [20:56] exist. GDB output register contents. [21:00] Nope. It's completely made up because I [21:03] mean it's never run. the patch on that [21:06] test server doesn't work. It's all made [21:08] up. The test server doesn't work work. [21:10] The curl doesn't crash. You can't run [21:12] this. So, wait a minute. All of this is [21:16] just made up from the second. I mean, [21:19] the title is wrong, the content is [21:20] wrong, the examples are wrong, the [21:21] patches are wrong, the crash dumps are [21:23] wrong, everything is just Yes, if you [21:26] made this for a TV show, it would be [21:28] great, right? But [21:32] actually, [21:34] actually, [21:36] So, so nothing you know and in this case [21:39] I think I spent hours at least a few [21:41] hours you know just understanding that [21:43] report asking if you follow up before I [21:45] noticed that function name and started [21:47] to gripping in my wait a minute this [21:48] function name I don't recognize it maybe [21:51] we changed it I don't remember gpped for [21:53] it no it doesn't doesn't exist you know [21:55] I checked the code history it never [21:57] existed um so yes this is a and and [22:01] really um it is of course a total waste [22:05] of time and energy. And not only the [22:06] sort of it's it's exhaustively, you [22:09] know, it's it's sort of a mindnumbingly [22:12] stupid exercise chasing something that [22:15] someone invented for us. [22:17] Yeah. And I was going to say that I mean [22:20] TV series are actually much better at [22:22] doing curl hacks because they tend to be [22:23] believable and actually work. Uh these [22:26] are different kind places where curl has [22:28] been used in different TV shows and [22:30] they're actually you know they're all [22:31] working actually [22:33] opposed to the slop [22:36] and and I should of course say that I [22:39] mean stupidity is not sort of exclusive [22:41] in AI because we're we're humans so we [22:45] get a lot of these you know we found [22:47] your git repository online please fix [22:52] thank you thank you for telling [22:58] And sometimes they find they often also [23:01] found the.git directory in my website [23:03] which also has the public git directory. [23:06] So we get a lot of reports. So you know [23:08] people are helpful and you know [23:10] information disclosure. They tend to [23:12] find problems in the test suite. We have [23:14] a key somewhere or in example code. We [23:17] have people keep reporting that you can [23:19] access files with a file colon slash [23:23] uh protocol which is made to read files [23:27] like right but it you can also read [23:29] files with it. Yes. [23:33] Last week we got that again. So yeah, [23:35] and and and then the the typical old [23:37] one, I run the tool, it says something, [23:40] I report it all the time, you know, even [23:43] though the tool might be wrong, right, [23:45] or whatever, but there, you know, people [23:47] try the shortcut to, I guess, get money [23:51] for it, but it's rarely a good idea. [23:54] Anyway, so so this this attack or [24:00] continued attack or all these friendly [24:03] reports, it really of course reduces our [24:06] activity elsewhere because we have to [24:08] spend a lot of time, you know, again and [24:10] again and again we get to start over. [24:13] What is this huge report? Is it AI? Is [24:15] it slop? Is it sensible? And we don't [24:19] dismiss reports just because it looks [24:21] like slop, of course, because it might [24:23] be genuine. And we have of course a lot [24:26] of people who are actually using [24:27] translators or or or [24:31] the way people tend to sort of hide the [24:33] AI nowadays is that they say [24:36] I'll get to it but now we ask people [24:38] disclose immediately if you used an AI [24:41] just you know to get our lower our [24:44] expectations but nowadays they say um I [24:47] found it but I used an AI to generate [24:50] the report [24:52] then you [24:54] what do what do I do with that then ah [24:57] okay that's sort of an yeah yeah yeah [24:59] that's that's why you have a lot of [25:00] bullet points right and that's why it's [25:02] mixed case but maybe that makes the [25:04] problem more real I don't know I think [25:08] people mostly say that to sort of hide [25:11] the fact that they actually use the all [25:12] the way but it really you know it makes [25:16] us really tired and just you just want [25:18] to close and throw away everything [25:19] because okay a new report fun get away [25:24] and it's really burdening burdening on [25:27] all the people involved doing this. So [25:29] it certainly may um impact project [25:32] quality and it may then sort of end up a [25:36] supply chain issue in that it may [25:38] actually make us miss real stuff and [25:41] make us not do real stuff that we [25:43] otherwise wanted to do. Right? [25:46] So there's certainly a risk of that. [25:51] And why why [25:54] so stupid? [25:57] Is it the money? I I mean, sure, if we [26:02] we gave away $500 for a security low [26:05] report. So maybe it is that we, as I [26:08] said, we offer 10,000 for a critical [26:10] one. No one has ever uh got that. So [26:14] maybe it is the money but so at the same [26:17] time it doesn't really feel like that. I [26:19] think a lot of people actually think [26:21] that they help us here. I mean the tool [26:23] told them there's a bug here. There's a [26:26] bug. I should report it. The the project [26:28] will be happy. [26:31] Um yeah and they actually think the AIS [26:35] do this. So yeah the AI told me here's a [26:37] bug I will report it. [26:42] So [26:44] as I said it's it's not a zero or one [26:47] here is it AI or not. Nowadays almost [26:50] everything is to some degree AI. So it's [26:53] uh it's more easy to say that is too [26:55] often than exactly how often but it's [26:58] roughly somewhere around 20 to 40% of [26:59] all the submissions right now. And the [27:01] submission rate is certainly going up. [27:04] And my my feeling is also that people [27:10] use these and sometimes rewrite the slop [27:13] in their own language to avoid it to [27:16] appear as AI because I think the general [27:19] quality is going quickly downhill which [27:22] means that people are sort of we get [27:24] more reports than ever but the quality [27:26] is way worse than ever. And I don't know [27:30] why. It's just [27:33] stupid. So, and the exact rate isn't [27:35] hard to actually [27:37] assess, but it did not and this this [27:40] problem they did it didn't exist two [27:42] years ago, right? It didn't just didn't [27:44] happen. So, what do we do with all of [27:46] this? [27:48] Sort of useless action. Ban the [27:50] reporter. Mostly of the most of these [27:53] reports come from a firsttime reporter [27:55] anyway. So they created an account, [27:57] reported this and we banned this first [27:59] time account instead of completely [28:01] useless action because of course they [28:03] will create another one if they want to [28:05] have another one. Um and we report them [28:07] to hacker one because we use hacker one [28:09] then as our um platform for this. Hacker [28:13] one has a sort of I I could possibly [28:15] call it lukewarm interest to do much [28:18] about this. Hacker one themselves has an [28:20] AI engine to help out with analyzing [28:23] stuff. So they're sort of I don't know [28:25] which side of this game they're on [28:28] actually and they certainly don't take [28:31] my sense of urgency very important and I [28:34] mean they don't really care. they don't [28:35] respond to my emails very often and [28:40] so yeah as I mentioned we require [28:42] upfront sort of that they state that [28:44] they have used an AI just so that we can [28:47] you know raise our flags and dismiss [28:49] them easier but I think that just makes [28:51] them sort of [28:54] it just makes users try to you know have [28:59] excuses I used I just generated part of [29:02] it when III blah blah blah So I don't [29:05] this doesn't really help this. It's the [29:07] same crap. But at the same time, we're [29:10] an open source project, right? I I want [29:14] to have I want to do everything in an [29:16] open source project like curl as open, [29:18] approachable as possible, right? [29:20] Everything should be open, transparent, [29:21] accessible for everyone. I I don't want [29:26] I I'll get to things that we don't do, [29:28] but I I I want it to remain accessible [29:30] and available for anyone to submit [29:32] security problems for example. [29:35] So I don't want it closed down. So what [29:38] we don't do a lot of people say we [29:40] should in insert prompt injections. So [29:42] we should you know insert funny things [29:44] in comments somewhere that that'll make [29:47] it make the AIS do something. [29:51] I think, okay, it's a fun thing to say, [29:53] but it will just be stupid and probably [29:56] extremely short-sighted. It probably [29:58] will work once and never again. And oh, [30:00] yeah, yeah, we should use AI to detect [30:02] AI. [30:05] First, it's sort of pointless. It's not [30:07] the AI we want to detect, it's the crap [30:09] we want to detect. And it's really hard [30:12] to detect the crap sort of [30:13] automatically. You have to sort of [30:14] understand a little bit. Uh so yeah, we [30:17] could add something that the AIS would [30:18] find and report and we would find also [30:21] short-sighted. They will sort of work [30:22] around that immediately. We should [30:24] charge money for the right to submit a [30:26] security report could possibly work, but [30:28] we would also just shut out shut off a [30:31] lot of legitimate possible report errors [30:34] at least. [30:36] So possibly that somehow we need to add [30:39] friction to this process one way or [30:41] another, but but we're working on that. [30:44] So yeah. Yeah. And then people say we [30:45] should automate the testing and verify [30:47] it before we even consider it the bug. [30:49] Right? So make sure that it actually is [30:51] reproducible or something. But [30:53] suggesting this that's sort of then you [30:56] haven't really worked with security [30:57] problems in a project like this because [30:59] you know when you run on a 100 different [31:01] operating systems on 28 different CPU [31:04] architectures there's no way we can run [31:06] whatever you say in a VM and you know [31:09] architectures different [31:12] and most nowadays when most people [31:15] actually find a problem it's mostly like [31:17] I found it in the code it could possibly [31:19] execute it in these kind of conditions [31:22] in this kind [31:23] sort of in this needs to happens first [31:26] and then that blah blah blah often super [31:28] hard to reproduce even for the reporter. [31:30] So [31:32] requiring that it would be reproducable [31:34] in a VM first that would sort of also be [31:37] like charging a lot of money. It would [31:38] just remove a lot of legitimate bugs. [31:43] But there's also of course the the the [31:46] providers of this wasting time should be [31:49] a violation of of terms of use of [31:51] course. So hacker one should really [31:53] strike down much harder on these ones. [31:55] And I mean the GitHubs and all the [31:57] others should as well because this is [31:59] not unique for hacker one. It's not [32:00] unique for security reports. We see this [32:03] the slop trend is is happening in in in [32:06] regular bug reports as well everywhere [32:08] in open source. So it's certainly not [32:10] this is a trend going really wide and [32:13] reputation systems like on on a system [32:15] like hacker one it doesn't work because [32:17] these are firsttime reporters. So it [32:19] doesn't matter if sure if I ban them, [32:22] block them, report them as spam, they [32:24] their reputation is hurt, but they don't [32:27] have a reputation to hurt. It doesn't [32:29] matter. The only one who cares about [32:30] reputation, they are the ones who have [32:33] been there for a long time and they're [32:34] not the problem. So it doesn't really [32:37] work like that. So what possibly work is [32:39] that if we would require something more [32:42] proof of work knowledge intelligence [32:43] something out of the reporter maybe it's [32:46] really hard and of course the way I want [32:49] to do it is to basically just not allow [32:53] persons who you know if you created your [32:55] account yesterday I don't want your [32:56] report I want you to just sit there and [32:58] wait for a while perhaps or something [33:01] else at least up the threshold a little [33:04] bit make it a little bit harder [33:07] because I think that scaled the the [33:09] best. And of course, I want these [33:11] service providers to actually take this [33:13] problem more seriously because I think I [33:15] think we're only seeing the beginning of [33:17] it and I think we're going to see it [33:18] more widely going forward because it's [33:20] so easy to generate so hard to take to [33:24] to receive. So yeah, it's not really [33:26] about AI at all. It's just about the [33:28] abuse, right? You can do the same [33:30] without AI. [33:32] The problem here is AI makes it so easy. [33:34] It produces so much with so little [33:36] effort and people actually think they do [33:39] this for the right reason, right? [33:40] Because before AI, you were more or less [33:43] aware when you did something bad, right? [33:45] People still do bad things, but they [33:47] know it and they're just bad people. Bad [33:49] people exist all the time. They don't go [33:50] away. But I mean nowadays the number of [33:53] sort of in between people, they just [33:55] think they're doing good, but they're in [33:56] reality they're bad much more and they [33:59] actually cannot sort of separate the [34:03] truth from the lies. and they actually [34:04] think they're helping out. So, but yeah, [34:07] sure. Human created swap is also a big [34:10] problem. So, can AI be used for good? [34:16] No, someone said here, you know, I'm I'm [34:19] I'm more of an eternal optimist here. [34:21] So, I say sure, yes, possibly. But we [34:25] don't see a lot of proof of that, right? [34:28] People always tell me, "Yeah, yeah, [34:30] yeah, but you give it time, you know." [34:33] Yes, sure. give it time but there [34:35] there's not a lot of proof of it or [34:38] science that is actually going in the [34:39] right direction. I think as in all ways [34:42] sure I think actually AI can be used for [34:45] good but you have have to have a sort of [34:47] a clever human involved there. You have [34:49] to read output sort of filter off the [34:52] crap extract the good parts and use that [34:54] in the report. I think you can do good [34:56] stuff with that. But so it'll take a [34:59] long time before you can just ask the AI [35:00] find the problem here and report it. [35:03] It's going to take a while. And then [35:05] just sort of all of this the slop part [35:09] is sort of is another dimension to this [35:12] other AI part of course that I I'm just [35:15] going to mention that. [35:17] On the curl website we have this is a [35:20] normal month in bandwidth spend. That's [35:24] 65 terabytes [35:26] and these are the graph is per day [35:29] amount of bandwidth. So that's 4,000 [35:32] requests per second to a static site [35:34] basically holding what documentation [35:37] torible downloads. What are people [35:40] doing? They're not downloading curl [35:42] anyway. [35:44] >> But they're using curl. [35:46] >> They they might be using curl. [35:50] Um [35:52] luckily for me, we're sponsored by [35:53] Fastly, so they sort of eat all the [35:55] bandwidth. So I don't have to care a lot [35:57] about it a lot. I can just, you know, [36:00] roll my eyes and I don't have logs [36:03] either. So I can just see how they [36:04] torture the site servers out there and [36:06] say, "What are they doing?" I don't [36:09] know. Um anyway going forward [36:14] will they approve improve everyone who's [36:18] on the sort of AI LLM side they will say [36:20] yes sure they improved yesterday it's [36:21] going to be great uh maybe they will I I [36:24] I'm sure that they will continue selling [36:27] the myth at least so I mean everyone was [36:29] already before convinced that it was a [36:30] good thing they will do this great and [36:32] that will continue and humans are not [36:36] likely to improve sort of then I'm less [36:39] of an optimist more of a cynic. Uh so [36:42] yeah, humans will still, you know, they [36:44] will help us out. They will continue to [36:47] help us out. Um so in our short-term [36:50] future, we will maybe not close it down [36:53] immediately, but we we are going to do [36:56] measure sort of countermeasurements. So [36:59] we don't like hacker one's treatment of [37:00] us. So we're probably going to move away [37:02] from that when we probably might try to, [37:05] you know, remove the money incentive. We [37:08] we will going to we we will try [37:11] different things to sort of reduce this [37:14] wave of unwanted reports. We'll see. We [37:19] need to experiment a little bit. Um [37:22] because we also hear from a lot of other [37:23] open source projects without bug bounty, [37:26] right? And they get a lot of crap as [37:27] well. So maybe it's not the money. Maybe [37:29] it is something else we need to do to [37:31] stop this. We I think we need to somehow [37:34] add friction requirements thresholds for [37:36] this somehow. We need to work on [37:38] experiment a little bit [37:41] but we basically cannot take it like [37:43] this because it's such a burden on the [37:46] people in our project that had to take [37:50] care of this. I have a little [37:51] collection. [37:54] It's mindn numbingly stupid there. I [37:58] think there are 25 of them. I mean [38:02] it it's it's a that's more an exercise [38:04] for you to read a few of them and then [38:06] you'll understand. It's super stupid [38:08] most of them u very long very many [38:11] bullet points but in the end of course [38:13] open source survives and this is just a [38:16] blip on the entire thing. So I'm sure [38:19] we'll come out ahead of this and this is [38:21] not going to break us this time either. [38:23] Thank you. [38:33] [Applause] [38:41] Thank you so much for your great talk. [38:43] Are there any questions? [38:52] Thanks for the awesome talk. Uh you [38:54] mentioned that this sort of slop only [38:56] started two years ago and has been [38:58] ramping up. I wanted to ask if you're uh [39:00] familiar with the AICC [39:03] DARPA challenge that was funding people [39:06] in companies in the US specifically to [39:08] use AI to find bugs in open source and [39:10] automatically report them. And if that's [39:12] connected, [39:14] >> they just had a big announcement at [39:15] Defcon last week. So [39:18] >> there I'm sure there are many sort of [39:21] efforts, attempts and and projects going [39:23] on to use AI to find security problems. [39:25] I'm not aware of that and I've not seen [39:26] any results of that. But okay, I I will [39:30] spill the beans and tell you that I [39:33] right now we have a security bug in curl [39:36] confirmed from a big company and I'm [39:38] pretty sure they used AI to find it. [39:41] So that's going to contradict everything [39:43] I said here today. [39:46] But but I think in general I think it's [39:49] it's actually not contradicting. It's [39:50] more I think as as with everything if [39:54] you're if you have clever humans [39:55] involved I think they have AIS can [39:57] actually help a lot at least by sorting [39:59] out maybe narrowing in finding areas to [40:02] look at closer. So I think they can [40:04] help. I think I think the problem starts [40:06] when you sort of hand everything over to [40:08] the AI and think that it's going to go [40:10] all the way. So I think people are going [40:12] to find a lot of use and help from AIS [40:16] going forward as well actually. [40:20] >> So during your talk you've uh [40:22] occasionally referred to the use of AI [40:25] that generates AI slop as human [40:27] stupidity uh and sometimes you called it [40:30] an attack. [40:32] Uh so per your assessment which side of [40:35] Henland's razor are we actually on here [40:37] mostly? [40:39] >> Yeah, I think I think the attack is [40:42] actually [40:45] I think it's a lot of sort of [40:49] I think the attack is mostly just that [40:51] from the company selling the myth. So [40:54] all the poor users that are actually [40:56] attacking us, they're just innocent [40:58] complicit participants in this attack. [41:01] So it's but no one actually wanted it to [41:04] happen like this. It's so it I don't [41:06] know really where to land and what to [41:08] call it. [41:10] Uh yeah, you mentioned earlier a thing [41:12] that I've also heard that um buck [41:15] reports in uh on GitHub and so on and so [41:18] forth have become better quality since [41:21] people started using AI because there [41:23] are people who where English is not the [41:26] first language. They're not as fluent. [41:28] They're not as eloquent whatever that [41:30] might be. And that actual legit bugs [41:33] have been reported with the help of AI [41:35] that you mentioned earlier. Yeah, we [41:36] used AI to to write the report, [41:38] whatever. Um, have you seen those legit [41:42] and not only not only security [41:44] vulnerabilities, but actual bugs where [41:46] you knew, okay, this person clearly used [41:49] AI, but we um but it was a legit it was [41:54] a legit report. They just used AI [41:56] because of the language barrier or [41:58] whatever. [42:00] >> No. [42:11] people still use AI or translation [42:14] services, but I don't think [42:16] that has been going on for a long time, [42:19] long before we even call that AI. We'll [42:21] just call that translating. [42:25] And I think people are still [42:26] translating. And I think that's good for [42:28] everyone who's not good or feel [42:31] confident in English. So I think that's [42:32] of course just great, but I I don't [42:36] sense [42:37] an improvement. I don't sense an aid [42:40] from AI in general. [42:43] >> Hello. Uh there's just one thing I want [42:46] to clarify like uh in general this is [42:49] not a new problem with uh like someone [42:52] making a bogus report, right? It's just [42:54] like the AI emphasizes a pre-existing [42:57] problem. And I think this is like [42:59] important uh to mention because all it [43:02] does is emphasize the bad um behaviors [43:05] that were there before because it's much [43:07] much easier to create a big report that [43:10] sounds serious, right? And in your [43:12] presentation you showed uh that you were [43:15] like against detecting AI with AI. But [43:19] what about for example just as an [43:20] example having an AI agent that actually [43:24] runs the code and it would be pretty [43:26] easy to uh like see okay there is [43:29] actually no function of that name. [43:31] Right. And uh the last point is um you [43:35] are certainly not the only one with that [43:37] problem uh with bogus reports of any [43:39] kinds. not not only uh security. Uh what [43:43] if there what if open source developers [43:46] could stick together, work together on a [43:49] general solution that fixes a problem [43:50] like this in general? Do you think that [43:53] might be maybe one of solution? [43:56] >> Yeah, of course. We sort of we Yeah, but [43:59] that's why I'm I'm talking about the [44:01] providers here, the platforms that we [44:02] all are on and using for the bug reports [44:05] and the security reports. They are the [44:07] ones that we need to work together with [44:09] to to raise the bars or set the [44:11] requirements and then give us the tools [44:12] so that we can for example as a [44:14] community say that this person clearly [44:16] is an abusive reporter. We could ban him [44:19] from all projects why just not from one [44:22] and I want to say that the difference [44:24] between now sort of sure people have [44:27] been abusing this forever. I mean, we're [44:30] humans. Humans are mostly annoying, but [44:34] um no, not mostly, but a lot of users [44:36] are annoying. And that's not new. The [44:39] new thing here is not the only the ease [44:41] that you can produce this with AI, but [44:44] also these they actually think they are [44:46] helping out. They're not the bad, they [44:48] don't think they're the bad guys. That's [44:49] the new thing here. The huge portion of [44:51] users who actually think they're all [44:53] helping out here. They're just [44:55] unknowingly becoming the bad guys. And [44:57] that's the new part because that wasn't [44:58] like that before. Then we're only the [45:01] 52% one.5% [45:05] stupid users and they still there. But [45:07] now we have a large portion of users [45:09] just helping out. That's the new part. [45:15] Um hi, [45:17] I'm here. Uh [45:20] so quick question. So you've kind of [45:23] said I think that this isn't a technical [45:26] problem. It's mostly social. And how do [45:28] you basically go up to a person and then [45:30] tell them you're actually in the matrix, [45:33] you've been lied to, that kind of thing. [45:35] Like how do open source developers how [45:37] how are supposed open source developers [45:39] supposed to deal with a problem where [45:40] you go up and tell people what you're [45:43] doing is not actually okay. [45:46] >> Yeah. How do you tell that? I mean, [45:50] how do you ever tell a person that [45:53] whatever you're giving me now is not [45:55] wanted and it's crap and your life [45:58] choices are wrong. [46:05] It I mean it's really hard, right? [46:07] Because you want to be polite, you want [46:08] to be friendly, you don't want to and as [46:11] a a someone who's sort of the face of [46:13] the project, I don't want I don't want [46:15] to be rude. I don't want to I don't want [46:17] my comments to be quoted and used as a [46:20] scare sort of example on my project. So [46:22] no, I try to be friendly. I try to [46:24] communicate, stick to the technical [46:26] issues [46:28] and then ban them and stop the [46:30] conversation. [46:34] um you're assuming that most of these [46:37] requests are um with a good intent, but [46:42] I mean I mean that might be because I'm [46:44] not dump as but if I um add an [46:46] issue, then I only add it if I'm able to [46:50] reproduce it or at least I write, okay, [46:54] I have this bug. Um it happens whenever, [46:57] but I can't reproduce it yet. I will [46:59] try. Um, and if you if you really think [47:04] they are um acting on goodwill, then you [47:06] could probably try to spread the [47:08] knowledge that if you can't reproduce it [47:11] by yourself, it is not an issue. [47:15] >> Yes. [47:16] >> And I I really don't think that it's [47:18] only good will. [47:19] >> No, it's certainly not not only good [47:22] intentions. That's that's for sure. But [47:24] I also cannot just say I cannot blank [47:27] say that if you cannot reproduce it it's [47:29] not an error because if you know if they [47:32] really point out the problem it is an [47:34] error and I'm I [47:37] my sort of yeah I I want to be better [47:40] than that I want to take care of any if [47:42] you point out the problem to me I want [47:44] to fix that problem and if you have a [47:46] problem to reproduce it but you can [47:48] clearly point it out and explain why it [47:50] is a problem I think it is a problem I [47:53] don't want [47:55] artificially raised raise the bars like [47:57] it's not a bug if you can't reproduce it [47:59] even though we all can see that it is a [48:00] bug that would be wrong too. So, I don't [48:03] know. It's really hard. I want to make [48:04] it hard for for the abusers, but I also [48:07] want to make it easy for the ones who [48:08] are actually saying, "Well, if you do [48:10] this, it's going to crash." Yes, it [48:12] does. Then it's a bug. We fix it. [48:16] >> Hi. Uh, first things first, thanks for [48:18] curl. Thanks for keeping it running. [48:19] Appreciate it a lot. Um [48:23] what do you [48:26] um actual question is out of the legit [48:29] legit legitimate [48:32] uh V requests um how many of them are [48:35] actually repetitive reporters because my [48:38] assumption would be that the real high [48:40] value bugs reported would come from some [48:42] sort of experts which may have been [48:44] submitted something already and probably [48:46] idea could you leverage that probably in [48:48] you know get these people onto into a [48:50] list and make new reporters convince one [48:53] of those first to be elitable. I don't [48:55] know. [48:56] >> Yeah, [48:57] that's that's sort of one way to to [49:00] worse a solution, right? To end so that [49:03] you have to have some kind of phase in [49:06] which you're not allowed to submit a [49:07] report or convince or have someone very [49:11] sort of v it before you're allowed. So [49:13] yes, we have discussed that as well and [49:15] I just want to say that yes pretty much [49:18] all the really most important security [49:20] problems are reported by repeat sort of [49:23] reporters. So we have I think almost [49:25] half of the amount we have paid has gone [49:27] to the same individual. [49:30] So that's certainly so that few experts [49:34] are really really experts. [49:38] >> Yeah, we have a lot of money in our [49:40] projects. should just hire everyone. [49:44] >> Uh I'm very interested in your opinion. [49:46] Uh is it time to say uh the backbounty [49:51] philosophy is over? [49:54] >> Yeah, it might be [49:56] >> and what could be the alternative? [50:00] >> Well, [50:01] that's a pretty big question. [50:04] It goes hand inhand in general with open [50:07] source and sustainability and who's [50:09] going to pay for everything and who's [50:11] gaining the most money for us doing [50:13] this. So in in curl we're certainly [50:16] discussing more in ways to [50:20] why do it at all if we're only doing it [50:22] for the open source community. So maybe [50:24] we don't need to do bug bounders. Maybe [50:26] we should just reconsider the entire [50:27] thing how we handle security problems [50:29] because it's usually not the open source [50:33] community that is most sort of bothered, [50:35] scared or sort of most concerned about [50:38] this. Maybe those are the big commercial [50:41] companies. So maybe we should make a way [50:43] so that they would be more involved for [50:45] that. So but [50:48] it it's I don't have an easy answer on a [50:50] quick solution to that. So uh I think [50:53] we're going to see more experiments and [50:55] and tweaking of all this going forward [50:56] to try different things how we can [50:59] improve lives and everything for [51:01] everyone. [51:03] >> Our last question [51:05] >> I just wondered have you ever [51:07] encountered a single submission that [51:09] looked like complete AI slop but turned [51:11] out to be helpful in the end? [51:14] >> Yes, [51:18] unfortunately. [51:23] No, but but again um there's so many [51:26] different shades of this. So there's [51:27] there's really bad ones and there's half [51:29] bad ones and not too bad ones. So yes, [51:32] some of them can actually [51:35] in in one of the cases in my collection [51:38] the the person actually found a bug, a [51:40] legitimate problem, reported it and then [51:43] he asked the AI to explain it for him. [51:45] So basically you could see how it [51:47] started out found a bug reported it and [51:49] then [51:52] so so that yeah it was good but then it [51:55] got completely sidetracked and lost and [51:57] then in the end the the the report [51:59] actually didn't even report the bug he [52:01] had in the beginning. So, so, so I don't [52:04] know may maybe it helped, maybe it [52:06] didn't, but it so [52:08] since users use AI to different degrees [52:11] and so yeah, sometimes there are [52:14] legitimate and and real problems in [52:16] there that we can fix, but there also, [52:18] you know, the the normal thing when [52:21] people report security problems is many [52:24] times, I would say more often than not [52:26] when there's actually a bug in there and [52:29] and we fix the bug, but we disagree it [52:31] of it being a security problem. It's [52:33] just a bug then it's that's still good [52:36] still good to fix a bug but we don't [52:38] consider it a security problem. So [52:39] there's lots of different dimensions. [52:43] >> Thank you again for your talk. [52:45] >> Thank you. [52:53] [Applause]