Dgraph — 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 Unauthenticated Admin Token Disclosure via /debug/vars

hello@craftedsignal.io — Thu, 02 May 2024 12:00:00 +0000

Dgraph, a graph database, exposes sensitive information through an unauthenticated endpoint, /debug/vars, in versions prior to 25.3.3. The vulnerability arises because the admin token is often passed as a command-line argument using the --security "token=..." flag. This argument is exposed through the /debug/vars endpoint, which is enabled by default via Go’s expvar package. An attacker can retrieve this token without authentication and then use it to gain administrative privileges by including it in the X-Dgraph-AuthToken header of subsequent requests. This is a bypass of previous attempts to mitigate similar issues via /debug/pprof/cmdline, which were addressed incompletely. This issue impacts deployments where the Alpha HTTP port is reachable by untrusted parties, allowing for a full authentication bypass.

Attack Chain

An attacker sends an unauthenticated GET request to the /debug/vars endpoint on the Dgraph Alpha server (e.g., GET /debug/vars HTTP/1.1).
The server responds with a JSON payload containing the cmdline field.
The attacker parses the JSON response and extracts the value of the cmdline field.
The attacker searches the cmdline output for the --security token=... argument.
The attacker extracts the admin token from the --security argument string.
The attacker sends a request to an admin-only endpoint (e.g., GET /admin/config/cache_mb HTTP/1.1).
The attacker includes the extracted admin token in the X-Dgraph-AuthToken header of the request.
The Dgraph Alpha server validates the token, granting the attacker administrative access.

Impact

Successful exploitation allows an unauthenticated attacker to gain complete administrative control over the Dgraph database. This includes the ability to read and modify admin configurations, and perform operational control actions. In deployments where the Alpha HTTP port is publicly accessible, this vulnerability poses a significant risk, leading to potential data breaches, service disruption, and unauthorized manipulation of the database. While the number of affected deployments is not explicitly stated, any Dgraph instance running a vulnerable version with an exposed Alpha HTTP port is at risk.

Recommendation

Upgrade Dgraph to version 25.3.3 or later to address the vulnerability.
As a temporary workaround, restrict access to the Alpha HTTP port to trusted networks only.
Deploy the Sigma rule below to detect unauthorized access attempts to the /admin/config/cache_mb endpoint using the X-Dgraph-AuthToken header.
Deploy the Sigma rule below to detect access to /debug/vars endpoint.

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.