Dql-Injection — CraftedSignal Threat Feed

Dgraph Pre-Auth DQL Injection Vulnerability

hello@craftedsignal.io — Sat, 26 Oct 2024 12:00:00 +0000

A critical vulnerability exists in Dgraph, a graph database, allowing unauthenticated attackers to perform full database exfiltration. This flaw resides within the /mutate endpoint, specifically when Access Control Lists (ACL) are disabled, which is the default configuration. By injecting malicious DQL queries via a crafted cond field in an upsert mutation, attackers can bypass authorization checks and extract sensitive data, including user credentials and secrets. The vulnerability stems from the lack of proper sanitization of the cond field, leading to direct concatenation into the DQL query string. This vulnerability was found in v25.3.0, but may exist in other versions as well.

Attack Chain

The attacker sends an HTTP POST request to the /mutate?commitNow=true endpoint without any authentication headers (e.g., X-Dgraph-AccessToken, X-Dgraph-AuthToken).
The mutationHandler in http.go extracts the request body and processes the mutations array, including the cond field, using strconv.Unquote.
The request proceeds to edgraph.Server.QueryNoGrpc, where the Cond value is copied verbatim to dql.Mutation.Cond in server.go.
The buildUpsertQuery function in server.go performs a simple string replacement (@if to @filter) but otherwise concatenates the unsanitized Cond value into the DQL query.
The dql.ParseWithNeedVars parser processes the constructed DQL string, accepting the injected query blocks as valid DQL.
The authorizeQuery function in access.go returns nil immediately because ACL is disabled (AclSecretKey == nil), bypassing authorization checks.
The injected query block executes, traversing and extracting data from the database.
The response, containing the exfiltrated data, is returned to the attacker via http.go, effectively granting unauthorized access to sensitive information.

Impact

Successful exploitation of this vulnerability results in complete database exfiltration. Attackers can retrieve all nodes, predicates, and values within the Dgraph database, including sensitive data such as user credentials, API keys, and Personally Identifiable Information (PII). Given the default configuration of Dgraph lacking ACL enabled, this poses a significant risk to organizations relying on Dgraph for data storage. The injection can also manipulate upsert conditions, bypassing uniqueness constraints and conditional mutation logic.

Recommendation

Enable ACL on all Dgraph instances and configure appropriate access controls to mitigate unauthorized data access.
Implement the Sigma rule Detect Dgraph DQL Injection in Mutation Endpoint to identify potentially malicious requests to the /mutate endpoint.
Sanitize and validate user-supplied input, especially the cond field in mutation requests, to prevent DQL injection attacks.
Monitor network traffic to detect suspicious POST requests to the /mutate endpoint with unusual or unexpected cond values.
Review and restrict network access to the Dgraph instance, limiting access only to authorized clients and networks.

Dgraph Pre-Auth Full Database Exfiltration via DQL Injection

hello@craftedsignal.io — Wed, 03 Jan 2024 12:00:00 +0000

A critical vulnerability in Dgraph, specifically within the addQueryIfUnique function, enables unauthenticated attackers to perform full database exfiltration. This affects default configurations where Access Control Lists (ACLs) are disabled. The attack involves sending crafted HTTP POST requests to the /alter and /mutate endpoints on port 8080. The vulnerability stems from the lack of sanitization of the Lang field in JSON mutations, which allows for DQL injection. By exploiting the x.PredicateLang() function, which splits predicate names on @, attackers can inject malicious code into the language tag. This injected code allows attackers to execute arbitrary DQL queries, bypassing authentication mechanisms and extracting sensitive data from the database. This vulnerability was tested on Dgraph version v25.3.0, posing a significant risk to organizations using Dgraph with default settings.

Attack Chain

The attacker sends an HTTP POST request to the /alter endpoint to create a schema predicate with @unique @index(exact) @lang. No authentication is required in the default Dgraph configuration.
The attacker crafts a JSON mutation containing a malicious payload. The key in the JSON mutation includes the predicate name followed by @ and the DQL injection payload in the language tag position, such as name@en,"x")) leak(func: has(dgraph.type)) { uid dgraph.type name email secret aws_access_key_id aws_secret_access_key } } #.
The attacker sends the crafted JSON mutation via an HTTP POST request to the /mutate?commitNow=true endpoint.
The mutationHandler parses the JSON body and identifies the malicious predicate and language tag.
The x.PredicateLang function splits the key on the last @, separating the predicate and the injection payload.
The addQueryIfUnique function constructs a DQL query string by interpolating the raw language tag from the mutation into the query via fmt.Sprintf without any sanitization.
The constructed DQL is parsed, and the injected query is executed, bypassing authentication checks due to AclSecretKey == nil.
The results of the injected query, containing the entire database content, are returned to the attacker in the HTTP response.

Impact

Successful exploitation of this vulnerability allows an unauthenticated attacker to exfiltrate the entire Dgraph database, including all nodes, predicates, and values. This could lead to severe data breaches, exposure of sensitive information, and potential compromise of user credentials, API keys, or other confidential data stored within the database. The vulnerability affects Dgraph instances using the default configuration without ACL enabled, which poses a high risk to a wide range of deployments across various sectors.

Recommendation

Deploy the following Sigma rule to detect DQL injection attempts by monitoring for unusual characters and patterns in the predicateName field (within application logs or network traffic capturing HTTP POST requests) to the /mutate endpoint.
Enable ACL in Dgraph to require authentication for /alter and /mutate endpoints, mitigating the pre-authentication aspect of the vulnerability.
Implement input validation and sanitization for the Lang field in JSON mutations to prevent DQL injection, focusing on the x.PredicateLang function and addQueryIfUnique function within edgraph/server.go.