use crate::baseline::{has_auth_errors, has_meaningful_field_data, EndpointBaseline};
use anyhow::Result;
use scanclient::reqwest::header::{AUTHORIZATION, CONTENT_TYPE};
use scanclient::ScanClient;
use secfinding::{Evidence, Finding, FindingKind, Severity};
use serde_json::{json, Value};
#[derive(Debug)]
pub enum AuthTestResult {
Accessible(String),
Protected,
Error(String),
}
pub async fn test_unauthenticated_query(
client: &ScanClient,
url: &str,
query_name: &str,
_baseline: &EndpointBaseline,
) -> Result<AuthTestResult> {
let query = format!("query {{ {query_name} {{ __typename }} }}");
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_string();
let parsed = serde_json::from_str::<Value>(&body_text).ok();
if let Some(ref json) = parsed {
if resp.status().is_success()
&& has_meaningful_field_data(json, query_name)
&& !has_auth_errors(json)
{
return Ok(AuthTestResult::Accessible(body_text.to_lowercase()));
}
}
Ok(AuthTestResult::Protected)
}
Err(e) => Ok(AuthTestResult::Error(e.to_string())),
}
}
pub async fn test_unauthenticated_mutation_safe(
client: &ScanClient,
url: &str,
mutation_name: &str,
_baseline: &EndpointBaseline,
) -> Result<AuthTestResult> {
let query =
format!(r#"mutation {{ {mutation_name}(id: "__gqlprobe_test__") {{ __typename }} }}"#);
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_string();
let parsed = serde_json::from_str::<Value>(&body_text).ok();
if let Some(ref json) = parsed {
if resp.status().is_success()
&& has_meaningful_field_data(json, mutation_name)
&& !has_auth_errors(json)
{
return Ok(AuthTestResult::Accessible(body_text.to_lowercase()));
}
}
Ok(AuthTestResult::Protected)
}
Err(e) => Ok(AuthTestResult::Error(e.to_string())),
}
}
pub(super) async fn test_baseline_public(client: &ScanClient, url: &str) -> Result<AuthTestResult> {
let body = json!({ "query": "{ __typename }" });
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 resp.status().is_success()
&& body_text.contains("data")
&& !body_text.contains("errors")
{
return Ok(AuthTestResult::Accessible(body_text));
}
Ok(AuthTestResult::Protected)
}
Err(e) => Ok(AuthTestResult::Error(e.to_string())),
}
}
pub async fn test_token_bypass(
client: &ScanClient,
url: &str,
token: &str,
) -> Result<AuthTestResult> {
let body = json!({ "query": "{ __typename }" });
let request = client
.request(scanclient::reqwest::Method::POST, url)
.header(CONTENT_TYPE, "application/json")
.header(AUTHORIZATION, token)
.body(body.to_string());
match client.execute(request).await {
Ok(resp) => {
let body_text = resp.body_text().unwrap_or("").to_lowercase();
if resp.status().is_success()
&& body_text.contains("data")
&& !body_text.contains("errors")
{
return Ok(AuthTestResult::Accessible(body_text));
}
Ok(AuthTestResult::Protected)
}
Err(e) => Ok(AuthTestResult::Error(e.to_string())),
}
}
pub async fn test_introspection_auth_leak(
client: &ScanClient,
url: &str,
) -> Result<AuthTestResult> {
let query = r#"
{
__type(name: "Query") {
fields {
name
description
}
}
}
"#;
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();
let parsed = serde_json::from_str::<serde_json::Value>(&body_text);
if let Ok(json) = parsed {
if let Some(fields) = json.pointer("/data/__type/fields") {
let fields_str = fields.to_string().to_lowercase();
if fields_str.contains("auth")
|| fields_str.contains("login")
|| fields_str.contains("token")
|| fields_str.contains("password")
{
return Ok(AuthTestResult::Accessible(body_text));
}
}
}
Ok(AuthTestResult::Protected)
}
Err(e) => Ok(AuthTestResult::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("authentication")
.tag("auth-bypass")
.cwe("CWE-287") .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()?)
}