# Vibe-Coded Applications Riddled With Exploitable Security Flaws — Theori Xint.io Study Finds 434 Issues Across AI-Generated Codebases

> Theori's autonomous pentest platform Xint.io found 434 exploitable security issues across three AI-generated ("vibe-coded") application test scenarios — two greenfield builds and one hardened legacy migration. Resource-exhaustion/DoS, authorization/IDOR, and access-boundary/SSRF/traversal flaws dominated, while traditional injection (SQLi/XSS) was comparatively rare; IDOR's share of findings nearly tripled (11% to 28%) as the codebase grew from greenfield to a large migrated brownfield app.

- **Published:** 2026-07-22T00:00:00Z
- **Last reviewed:** 2026-07-22T00:00:00Z
- **Canonical:** https://intel.threadlinqs.com/threat/TL-2026-1622
- **Card image:** https://intel.threadlinqs.com/og/threat/threat-intel-xint-code-vibe-coded-flaw-study-tl-2026-1622.webp?v=19fdc390 (Threadlinqs threat intel: Xint Code 434 Vibe-Coded Flaws: Analysis & Hunting (TL-2026-1622) — Medium severity, 22 IOCs, 9 detection rules.)
- **ID:** TL-2026-1622
- **Severity:** MEDIUM
- **Category:** THREAT_INTEL
- **Status:** ACTIVE
- **Detections:** 9 (1 shown free below) · **IOCs:** 22

## Description

Theori, a security firm known for large-scale AI-driven code auditing (its Xint Code / Xint.io platform swept the database category at the 2025 ZeroDay Cloud competition by discovering critical RCEs in Redis, PostgreSQL, and MariaDB), ran its autonomous pentest platform against three representative 'vibe-coded' application scenarios to quantify the real-world security debt of AI-assisted development: (1) a new application built from a well-written specification with experienced developer oversight, (2) a new application built from a casual, unstructured directive with minimal oversight, and (3) Gnuboard7, a legacy PHP CMS hardened and migrated to a modern Laravel + React stack — representing the increasingly common 'AI-assisted legacy modernization' pattern. Each app received a 30-minute autonomous runtime-plus-source-code scan.

Across the three apps, Xint.io surfaced 434 exploitable issues: 196 in the two greenfield apps and 238 in the migrated brownfield Gnuboard7 app. The dominant category (93 findings) was resource exhaustion / denial-of-service stemming from missing rate-limiting controls — AI code generators reliably implement the functional request-handling path but omit throttling, backoff, and abuse controls unless explicitly prompted. The second-largest category (88 findings) was authorization and IDOR (Insecure Direct Object Reference / Broken Object-Level Authorization) — generated database queries filter strictly on the requested identifier (e.g. `SELECT * FROM orders WHERE id = :id`) without validating that the requesting principal actually owns the referenced object, letting any authenticated user enumerate or modify records belonging to others. Access-boundary issues — path traversal, SSRF, and related boundary-crossing flaws — made up 54 findings, frequently surfacing in URL-preview / file-fetch / import features where the generated code passes user-supplied URLs or paths directly into filesystem or HTTP-client calls without allowlisting internal address ranges or normalizing paths. Eleven critical-severity findings were hardcoded or default secrets (API keys, DB passwords, JWT signing secrets baked into source or config as string literals, then propagated across files via stateless code generation and persisted in git history even after later removal), and six were debug-mode remote code execution — frameworks (e.g. Django/Flask-style debug consoles, Laravel debug pages) left enabled in production-reachable configurations, exposing interactive code-execution consoles or verbose stack traces with secrets.

A structurally significant finding is that the IDOR flaw share nearly tripled — from 11% of findings in the smaller greenfield apps to 28% in the larger, more complex Gnuboard7 migration — indicating that authorization-boundary defects compound disproportionately as AI-generated/AI-assisted codebases grow in scope and object-relationship complexity, a pattern consistent with prior industry findings (e.g. a 15-app, 5-agent study reporting 100% of AI coding agents introduced SSRF via URL-preview features and 0% implemented CSRF protection; the May 2025 Lovable mass-exposure incident, CVE-2025-48757, in which 170+ vibe-coded applications had their backing databases fully exposed due to missing/misconfigured access controls; and Cloud Security Alliance research describing a broader 'AI-generated code vulnerability surge' with Fortune 50 empirical data showing AI-assisted developers commit 3-4x faster than peers while introducing security findings at 10x the rate).

Notably, traditional injection classes — SQL injection and XSS — appeared far less frequently than anticipated, which the researchers attribute to genuine improvement in foundation-model training/tooling around those specific, well-studied vulnerability classes (extensive public training data, linting, and framework-level ORM/templating defaults). The residual risk in AI-generated code has instead concentrated in *business-logic and authorization-boundary* defects — categories that require understanding of who should be allowed to do what, not just how to satisfy a functional prompt — which current-generation code-generation models do not reliably reason about unless the developer explicitly specifies access-control requirements.

This is a systemic, cross-cutting risk pattern rather than a single-product vulnerability: with an estimated ~90% of developers now using AI coding assistants in some capacity, organizations adopting 'vibe coding' — for both greenfield development and, increasingly, legacy-system modernization — inherit a predictable, quantifiable defect profile (DoS-by-missing-rate-limits, IDOR-by-default, SSRF-via-fetch-features, hardcoded secrets, and debug-mode exposure) that traditional injection-focused SAST/SCA tooling and code-review checklists are not tuned to catch. Detection and hardening guidance for AI-assisted development pipelines is therefore treated here as a trackable, ongoing threat class.

## MITRE ATT&CK

- T1595.002 Vulnerability Scanning
- T1588.006 Vulnerabilities
- T1190 Exploit Public-Facing Application
- T1133 External Remote Services
- T1059 Command and Scripting Interpreter
- T1203 Exploitation for Client Execution
- T1078 Valid Accounts
- T1068 Exploitation for Privilege Escalation
- T1548 Abuse Elevation Control Mechanism
- T1211 Exploitation for Stealth
- T1552.001 Credentials In Files
- T1606 Forge Web Credentials
- T1083 File and Directory Discovery
- T1046 Network Service Discovery
- T1210 Exploitation of Remote Services
- T1213 Data from Information Repositories
- T1005 Data from Local System
- T1567 Exfiltration Over Web Service
- T1499 Endpoint Denial of Service

## Free detection (Splunk SPL, Microsoft KQL, Sigma)

**IDOR/BOLA Sequential Object-ID Enumeration Against AI-Generated Lookup Endpoint** (`TL-2026-1622-SPL-001`)

Detects a single authenticated session issuing rapid sequential/incrementing object_id (order_id, user_id, etc.) lookups against a web endpoint and receiving HTTP 200 for a high count of distinct IDs in a short window — the exact signature of an ID-only object-lookup query (SELECT * FROM orders WHERE id = :id) with no ownership check, the study's largest authorization defect class (88 findings, CWE-862/CWE-639).

- **Languages:** Splunk SPL, Microsoft KQL, Sigma
- **ATT&CK:** T1190, T1595.002, T1213
- **Data sources:** web_access_logs, application_gateway_logs, waf_logs
- **Severity:** high
- **Confidence:** high

### Splunk SPL

```spl
index=web sourcetype=access_combined
| rex field=uri_query "(?i)(?:id|order_id|user_id)=(?<obj_id>\d+)"
| where isnotnull(obj_id) AND status=200
| bin _time span=1m
| stats dc(obj_id) as distinct_ids values(obj_id) as ids_seen count as request_count by _time, c_ip, cs_username, uri_path
| where distinct_ids > 20
| sort - distinct_ids
```

### Microsoft KQL

```kql
let lookback = 1h;
AppRequests
| where TimeGenerated > ago(lookback)
| where ResultCode == 200
| extend obj_id = extract(@"(?i)(?:id|order_id|user_id)=(\d+)", 1, Url)
| where isnotempty(obj_id)
| summarize distinct_ids = dcount(obj_id), ids_seen = make_set(obj_id, 50), request_count = count() by bin(TimeGenerated, 1m), ClientIP, UserId, tostring(split(Url, "?")[0])
| where distinct_ids > 20
| project TimeGenerated, ClientIP, UserId, distinct_ids, request_count, ids_seen
```

### Sigma

```yaml
title: Sequential Object-ID Enumeration Consistent with IDOR/BOLA Probing
id: 7e2a1c3e-4f5b-4a6c-9d1e-2b3c4d5e6f70
status: experimental
description: Detects a single client enumerating a high count of distinct sequential object IDs (order_id/user_id/id) against a lookup endpoint within one minute, receiving 200 OK for records it does not own — the signature of an AI-generated ID-only authorization query.
references:
  - https://www.securityweek.com/vibe-coded-apps-riddled-with-exploitable-security-flaws/
  - https://theori.io/blog/announcing-xint-code
author: AII-Detector — ThreadLinqs Intelligence
date: 2026/07/22
tags:
  - attack.initial-access
  - attack.t1190
  - attack.discovery
  - attack.t1213
  - cwe.862
  - cwe.639
logsource:
  category: webserver
  product: generic
detection:
  selection:
    cs-uri-query|re: '(?i)(id|order_id|user_id)=\d+'
    sc-status: 200
  timeframe: 1m
  condition: selection | count(cs-uri-query) by c-ip > 20
falsepositives:
  - Legitimate bulk-export or admin reporting tools that enumerate IDs under an authorized service account
  - Load-testing or QA automation hitting sequential fixture IDs in a staging environment
level: high
```

**Known false positives:**

- Authorized bulk-export/admin reporting service accounts enumerating records sequentially
- Automated QA/load-testing against staging fixture IDs

**Tuning notes:** Tune the distinct-ID threshold (20) to the endpoint's normal per-session lookup rate; exclude known service-account/admin identities via an allowlist lookup; correlate with a 403/ownership-check field if the app later adds one to reduce noise.

### 8 more detection rules (Splunk SPL, Microsoft KQL, Sigma), unlock with TL Creds

- SSRF Outbound Fetch to Internal/Cloud-Metadata Address Range from URL-Preview Feature (locked: unlock with TL Creds)
- Path-Traversal Sequence in File-Import/File-Fetch Request Parameter (locked: unlock with TL Creds)
- Debug-Mode Console / Verbose Stack Trace Reachable Outside Development Range (locked: unlock with TL Creds)
- Hardcoded Secret Literal Committed to Source (gitleaks/trufflehog-style) (locked: unlock with TL Creds)
- Weak JWT Validation — alg:none Acceptance or verify=False Pattern (locked: unlock with TL Creds)
- Missing Rate-Limit Burst Combined With Cross-Tenant Data Exfiltration Over Web Service (locked: unlock with TL Creds)
- Missing Ownership Validation — Cross-Tenant Record Access on Object-Lookup Endpoint (locked: unlock with TL Creds)
- Missing Rate-Limit High-Frequency Identical-Endpoint Burst (Resource Exhaustion / DoS) (locked: unlock with TL Creds)

Sign up free to unlock the detection rules: https://threadlinqs.com/?modal=signup

## Sources

- [Vibe-Coded Apps Riddled With Exploitable Security Flaws](https://www.securityweek.com/vibe-coded-apps-riddled-with-exploitable-security-flaws/)
- [Announcing Xint Code](https://theori.io/blog/announcing-xint-code)
- [5 Vulnerabilities in Every Vibe-Coded App](https://securityboulevard.com/2026/05/5-vulnerabilities-in-every-vibe-coded-app/)
- [Vibe coded applications full of security blunders](https://www.devclass.com/ai-ml/2026/01/15/vibe-coded-applications-full-of-security-blunders/4079588)
- [Theori brings Xint Code to market for large-scale AI code security analysis](https://www.helpnetsecurity.com/2026/03/18/theori-xint-code/)
- [Theori launches Xint Code AI platform to uncover hidden vulnerabilities in massive codebases](https://siliconangle.com/2026/03/17/theori-launches-xint-code-ai-platform-uncover-hidden-vulnerabilities-massive-codebases/)
- [Xint Code Demonstrates Human-like Discovery and Prioritization of Business Logic Vulnerabilities](https://www.businesswire.com/news/home/20260317129537/en/Xint-Code-Demonstrates-Human-like-Discovery-and-Prioritization-of-Business-Logic-Vulnerabilities-Analyzing-Millions-of-Code-Lines-in-Just-Hours)
- [Vibe Coding Security: 69 Vulnerabilities Found in AI-Generated Apps](https://dev.to/hari_prakash_b0a882ec9225/vibe-coding-security-69-vulnerabilities-found-in-ai-generated-apps-is-yours-safe-5hcn)
- [Vibe Coding's Security Debt: The AI-Generated CVE Surge](https://labs.cloudsecurityalliance.org/research/csa-research-note-ai-generated-code-vulnerability-surge-2026/)
- [Vibe Coding Security: Why 62% Of AI-Generated Code Ships With Vulnerabilities](https://www.ox.security/blog/vibe-coding-security/)
- [Vibe Coding Security: The Complete Research Record Unbiased Research, 2026](https://museumofvibecoding.org/vibe-coding-security-the-complete-research-record-unbiased-research-2026/)

## Full data

The other 8 detection rules (Splunk SPL / Microsoft KQL / Sigma) unlock with TL Creds; a free account includes daily creds: https://threadlinqs.com/?modal=signup
Indicator values unlock with TL Creds, at a lower price on Red and Purple; AI agents can query rules and IOCs through the Threadlinqs MCP server (Purple): https://intel.threadlinqs.com/mcp

Canonical: https://intel.threadlinqs.com/threat/TL-2026-1622