use anyhow::Result;
use scanclient::reqwest::header::CONTENT_TYPE;
use scanclient::ScanClient;
use crate::context::ScanContext;
use crate::schema::SchemaGraph;
use secfinding::{Evidence, Finding, FindingKind, Severity};
use serde_json::json;
use tracing::{debug, trace};
pub const SQL_PAYLOADS: &[&str] = &[
"' OR '1'='1",
"' AND 1=1--",
"' AND 1=2--",
"1' OR '1'='1' --",
"admin'--",
"' UNION SELECT null,null--",
];
const NOSQL_PAYLOADS: &[&str] = &[
r#"{"$gt": ""}"#,
r#"{"$ne": null}"#,
r#"{"$exists": true}"#,
r#"{"$regex": ".*"}"#,
];
pub const CMD_PAYLOADS: &[&str] = &["; id", "| id", "$(id)", "`id`"];
pub const SQL_INDICATORS: &[&str] = &[
"sql syntax",
"mysql",
"postgresql",
"sqlite",
"ora-",
"sql server",
"near \"\"",
"you have an error in your sql",
];
pub const GRAPHQL_PARSE_INDICATORS: &[&str] = &["expected", "unexpected", "parse error"];
pub const NOSQL_INDICATORS: &[&str] = &[
"mongoerror",
"e_query",
"bson",
"invalid bson",
"cannot parse",
];
pub const CMD_INDICATORS: &[&str] = &[
"sh: ",
"command not found",
"syntax error near unexpected token",
"bin/bash",
"bin/sh",
"permission denied",
];
pub fn generate_injection_query(length: usize) -> String {
let chunk = "' OR '1'='1";
let mut payload = String::with_capacity(length);
while payload.len() + chunk.len() <= length {
payload.push_str(chunk);
}
let remaining = length.saturating_sub(payload.len());
payload.push_str(&chunk[..remaining.min(chunk.len())]);
payload.truncate(length);
payload
}
const INJECTION_TEMPLATES: &[&str] = &[
r#"query InjectionTest {{ user(id: "{}") {{ name }} }}"#,
r#"query InjectionTest {{ search(query: "{}") {{ results }} }}"#,
r#"query InjectionTest {{ users(filter: "{}") {{ name }} }}"#,
r#"query InjectionTest {{ items(query: "{}") {{ id }} }}"#,
r#"query InjectionTest {{ user(email: "{}") {{ name }} }}"#,
];
pub async fn test_with_context(client: &ScanClient, ctx: &ScanContext) -> Result<Vec<Finding>> {
test_inner(client, ctx.url(), ctx.schema.as_ref()).await
}
pub async fn test(client: &ScanClient, url: &str) -> Result<Vec<Finding>> {
test_inner(client, url, None).await
}
async fn test_inner(
client: &ScanClient,
url: &str,
schema: Option<&SchemaGraph>,
) -> Result<Vec<Finding>> {
let mut findings = Vec::new();
debug!("Testing GraphQL injection on {}", url);
let templates: Vec<String> = if let Some(s) = schema {
if s.injectable_args.is_empty() {
INJECTION_TEMPLATES
.iter()
.map(|t| (*t).to_string())
.collect()
} else {
s.injectable_args
.iter()
.map(|a| {
if a.is_mutation {
format!(
r#"mutation InjectionTest {{ {}({}: "{{}}") {{ __typename }} }}"#,
a.field, a.arg
)
} else {
format!(
r#"query InjectionTest {{ {}({}: "{{}}") {{ __typename }} }}"#,
a.field, a.arg
)
}
})
.collect()
}
} else {
INJECTION_TEMPLATES
.iter()
.map(|t| (*t).to_string())
.collect()
};
let template_refs: Vec<&str> = templates.iter().map(String::as_str).collect();
'sql_loop: for template in &template_refs {
for payload in SQL_PAYLOADS {
match send_injection_test(client, url, payload, template).await? {
InjectionResult::Vulnerable(category, evidence) => {
trace!("SQL injection indicator found with payload: {}", payload);
findings.push(create_finding(
url,
&format!("GraphQL {category} Injection Detected"),
&format!(
"The GraphQL endpoint appears vulnerable to {category} injection. \
A test payload in a query argument triggered a backend error response."
),
Severity::Critical,
&format!(
"Use parameterized queries for all {category} operations. \
Validate and sanitize GraphQL inputs before passing them to backend systems."
),
Some(&evidence),
)?);
break 'sql_loop; }
InjectionResult::Safe => {}
InjectionResult::Error(e) => {
debug!("Injection test error for payload '{}': {}", payload, e);
}
}
}
}
'nosql_loop: for template in &template_refs {
for payload in NOSQL_PAYLOADS {
match send_injection_test(client, url, payload, template).await? {
InjectionResult::Vulnerable(category, evidence) => {
trace!("NoSQL injection indicator found with payload: {}", payload);
findings.push(create_finding(
url,
&format!("GraphQL {category} Injection Detected"),
&format!(
"The GraphQL endpoint appears vulnerable to {category} injection. \
A NoSQL payload in a query argument triggered a backend error response."
),
Severity::High,
"Use parameterized queries for `NoSQL` operations. Validate JSON inputs strictly.",
Some(&evidence),
)?);
break 'nosql_loop;
}
InjectionResult::Safe => {}
InjectionResult::Error(e) => {
debug!("NoSQL test error for payload '{}': {}", payload, e);
}
}
}
}
'cmd_loop: for template in &template_refs {
for payload in CMD_PAYLOADS {
match send_injection_test(client, url, payload, template).await? {
InjectionResult::Vulnerable(category, evidence) => {
trace!(
"Command injection indicator found with payload: {}",
payload
);
findings.push(create_finding(
url,
&format!("GraphQL {category} Injection Detected"),
&format!(
"The GraphQL endpoint appears vulnerable to {category} injection. \
A shell metacharacter payload triggered a backend error response."
),
Severity::High,
"Never pass GraphQL arguments to shell commands. Use allow-lists and strict input validation.",
Some(&evidence),
)?);
break 'cmd_loop;
}
InjectionResult::Safe => {}
InjectionResult::Error(e) => {
debug!("Command test error for payload '{}': {}", payload, e);
}
}
}
}
debug!(
"GraphQL injection test complete: {} findings",
findings.len()
);
Ok(findings)
}
#[derive(Debug)]
pub enum InjectionResult {
Vulnerable(String, String),
Safe,
Error(String),
}
pub fn is_likely_graphql_parse_error(body: &str) -> bool {
let b = body.to_lowercase();
let has_parse_indicator = GRAPHQL_PARSE_INDICATORS.iter().any(|&ind| b.contains(ind));
let has_db_indicator = SQL_INDICATORS.iter().any(|&ind| b.contains(ind))
|| NOSQL_INDICATORS.iter().any(|&ind| b.contains(ind))
|| CMD_INDICATORS.iter().any(|&ind| b.contains(ind));
has_parse_indicator && !has_db_indicator
}
pub async fn send_injection_test(
client: &ScanClient,
url: &str,
payload: &str,
template: &str,
) -> Result<InjectionResult> {
let escaped = serde_json::to_string(payload)
.unwrap_or_else(|_| format!("\"{}\"", payload.replace('"', "\\\"")));
let query = template.replace("{}", &escaped);
let body = json!({ "query": query });
let request = client
.request(scanclient::reqwest::Method::POST, url)
.header(CONTENT_TYPE, "application/json")
.body(body.to_string());
match client.execute(request).await {
Ok(resp) => {
let body_text = resp.body_text().unwrap_or("").to_lowercase();
if is_likely_graphql_parse_error(&body_text) {
return Ok(InjectionResult::Safe);
}
for indicator in SQL_INDICATORS {
if body_text.contains(indicator) {
return Ok(InjectionResult::Vulnerable("SQL".to_string(), body_text));
}
}
for indicator in NOSQL_INDICATORS {
if body_text.contains(indicator) {
return Ok(InjectionResult::Vulnerable("NoSQL".to_string(), body_text));
}
}
for indicator in CMD_INDICATORS {
if body_text.contains(indicator) {
return Ok(InjectionResult::Vulnerable(
"Command".to_string(),
body_text,
));
}
}
Ok(InjectionResult::Safe)
}
Err(e) => Ok(InjectionResult::Error(e.to_string())),
}
}
pub fn create_finding(
url: &str,
title: &str,
detail: &str,
severity: Severity,
remediation: &str,
evidence_body: Option<&str>,
) -> Result<Finding> {
let mut builder = Finding::builder("gqlprobe", url, severity)
.title(title)
.detail(detail)
.kind(FindingKind::Vulnerability)
.tag("graphql")
.tag("injection")
.cwe("CWE-943") .remediation(remediation);
if let Some(body) = evidence_body {
let excerpt = if body.chars().count() > 1000 {
format!(
"{}...[truncated]",
body.chars().take(1000).collect::<String>()
)
} else {
body.to_string()
};
builder = builder.evidence(Evidence::raw(excerpt));
}
Ok(builder.build()?)
}