/

CVE-2025-70995

Severity:

HIGH RISK

(8.8)

Code Injection in Aranda Service Desk Web Edition ASDK API

CVE-2025-70995

Deferred

Vulnerability type

Category:

Code Injection

CWE:

CWE-94

Impact:

Remote Code Execution by Authenticated Users

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Aranda Service Desk Web Edition (ASDK API 8.6) improperly validates uploaded files, allowing authenticated users to upload a crafted web.config configuration file into a web-exposed directory.

When processed by the ASP.NET runtime, this configuration changes the execution context of the upload directory, enabling compilation and execution of attacker-controlled code (such as an .aspx webshell), which can lead to remote command execution on the server.

Affected context

The vulnerability exists in Aranda Service Desk Web Edition deployments using ASDK API 8.6 where users can upload files via the /ASDKAPI/api/v8.6/item/addfile endpoint.

It is relevant when:

  • File upload paths are served by IIS/ASP.NET and interpreted as part of the web application
  • The upload directory is within or under a configuration scope that allows web.config overrides
  • Uploaded files are not strictly validated to prevent configuration or executable content (e.g., web.config, .aspx) from being stored and served

Both On-Premise and SaaS instances may be impacted when these conditions hold and authenticated users can reach the upload API.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoint at /ASDKAPI/api/v8.6/item/addfile in the Aranda Service Desk Web Edition installation.
  • Required access: Valid authenticated user account with permission to invoke the file upload API (no additional elevated role is described).
  • Trigger point: Upload of a crafted web.config (or similar configuration file) via a POST request to the file upload endpoint.
  • Why exploitation is possible:
  • The server accepts and stores uploaded files in a web-accessible directory without sufficiently constraining file type or content.
  • IIS/ASP.NET interprets the uploaded web.config, allowing it to redefine the execution behavior of that directory.
  • Once the directory is treated as executable, attacker-controlled code (e.g., .aspx webshell) can be compiled and executed by the ASP.NET runtime.

Why this happens

The underlying issue is a form of code injection that stems from insecure handling of user-supplied content within a web-executed context, mapped to CWE-94: Improper Control of Generation of Code.

The application permits arbitrary file uploads, including configuration files, into a directory processed by IIS/ASP.NET.

By allowing an attacker to upload a web.config that modifies the directory configuration, the system effectively lets untrusted users control how and what code is generated and executed by the runtime.

Instead of treating uploaded files as passive data and isolating them from the execution pipeline, the application pipeline conflates user-controlled input with configuration and executable content, enabling dynamic compilation of attacker-provided code.

Potential impact

  • Execution of arbitrary server-side code in the context of the application pool identity
  • Full compromise of the affected web application and its data
  • Use of a deployed webshell for persistent remote access and command execution
  • Lateral movement to other systems reachable from the compromised server
  • Tampering with application behavior, logs, or configuration to evade detection
  • Exfiltration or destruction of sensitive information handled by the service desk platform

General mitigation guidance

Defensive measures should reduce the ability of uploaded content to influence runtime configuration or executable code paths:

  • Treat all uploaded files as untrusted data and ensure they are stored outside of web-executable paths or separate from application roots.
  • Enforce strict allowlists on file types and extensions, rejecting configuration files (e.g., web.config) and dynamic content (e.g., .aspx, .ashx, .asmx, .cshtml) at the application layer and, where possible, via web server configuration.
  • Strip or normalize metadata and reject uploads that contain patterns associated with configuration or code, even if renamed.
  • Configure IIS/ASP.NET so that upload directories are explicitly marked as non-executable and ignore nested web.config files in those locations.
  • Apply the principle of least privilege to the application pool identity and file system ACLs so that the process cannot modify application configuration locations beyond what is operationally necessary.
  • Introduce defense-in-depth measures such as web application firewalls (WAF) with rules to detect and block suspicious configuration or script uploads.

How teams detect issues like this

Detection ideally combines code-level analysis with runtime monitoring:

  • Static analysis and code review:
  • Identify endpoints that perform file uploads and verify that they enforce strong validation, storage outside the web root, and non-executable contexts.
  • Flag any logic that allows arbitrary filenames, extensions, or unrestricted content types for uploads.
  • Review deployment and IIS configuration to ensure upload directories cannot override configuration with web.config or similar files.
  • Configuration and policy enforcement:
  • Use infrastructure-as-code or server configuration scanning to verify that application upload paths are non-executable and that nested configuration overrides are disabled or constrained.
  • Enforce security policies requiring allowlisted content types and safe storage patterns for file uploads.
  • Runtime and log monitoring:
  • Monitor HTTP access logs for requests accessing uploaded content as .aspx or other dynamic script types.
  • Alert on web.config appearing in upload directories or on unexpected changes to configuration files.
  • Track anomalous process creation, command execution, or unusual outbound connections originating from the application pool identity.
  • Automated SAST/DAST tools or ASP.NET security analyzers can help highlight insecure file upload and configuration handling patterns before deployment.

Sources

SourceLink
docs.arandasoft.comdocs.arandasoft.com/asdk-api/pages/V1.9/descripcion/adjuntar_archivos.html
docs.arandasoft.comdocs.arandasoft.com/asdk-v8-release-notes/assets/asdk-v8-release-notes.pdf
github.comgithub.com/0xcronos/CVE/blob/main/CVE-2025-70995/README.md

Frequently asked

questions

Yes, if the Aranda Service Desk Web Edition instance is exposed over the network and authentication is accessible remotely.

An attacker with valid credentials and reachability to the /ASDKAPI/api/v8.6/item/addfile endpoint can exploit the issue without physical access.

Not necessarily. The description indicates that an "authenticated user" can exploit the vulnerability, implying that any account with access to the file upload endpoint may be sufficient, even without administrative rights.

The most robust pattern is to segregate uploaded files from the application's executable and configuration paths, enforce strict allowlists on file types, and configure IIS/ASP.NET so that upload directories cannot execute code or honor nested web.config files.

Design file upload features with the assumption that all uploaded content is hostile: always store files outside of web-executable paths, validate both file type and content, lock down web server execution permissions, and include checks in secure code review and CI pipelines to catch any new upload handlers that do not follow these patterns.

Find out what's already
exploitable in your codebase.