Overview
Judge is an Active Directory machine, and the path to Domain Admin is a chain of small permission misconfigurations that each hand us the keys to the next account. We begin with an assumed-breach foothold as d.taylor , a low-privilege domain user with nothing interesting on the shares, but a telling right hidden in the directory: ForceChangePassword over s.wilson. That lets us reset Wilson’s password without ever knowing the old one, so the account becomes ours.
Wearing s.wilson’s identity opens a door that was shut to Taylor READ access to the script share. Inside sits a single logon script that carelessly stores cleartext credentials for e.brown, and with those we trade our borrowed account for genuine user-level access over WinRM.
From there, Brown turns out to be the real prize. The account holds WriteOwner over the Default Domain Policy GPO, which we abuse to take ownership, grant ourselves edit rights, and inject a scheduled task that quietly adds e.brown to Domain Admins. Now sitting in the most privileged group in the domain, we invoke our replication rights to run DCSync, pull the Administrator’s NTLM hash straight from the DC, and log back in via Pass-the-Hash — full control of the domain, built one misconfiguration at a time.
Enumeration
Nmap
We started with an Nmap scan to identify the open ports and running services on the target.
Judge ➜ nmap -Pn -sV -sC 10.0.4.146

Nmap scan results
| Port | Service | Description |
|---|---|---|
| 53/tcp | domain | Simple DNS Plus (DNS) |
| 88/tcp | kerberos-sec | Microsoft Windows Kerberos |
| 135/tcp | msrpc | Microsoft Windows RPC |
| 139/tcp | netbios-ssn | NetBIOS Session Service |
| 389/tcp | ldap | AD LDAP — Domain: judge.local |
| 445/tcp | microsoft-ds | SMB |
| 464/tcp | kpasswd5 | Kerberos password change |
| 593/tcp | ncacn_http | RPC over HTTP 1.0 |
| 636/tcp | ldaps | LDAP over SSL (tcpwrapped) |
| 3268/tcp | ldap | AD Global Catalog |
| 3269/tcp | ldaps | Global Catalog over SSL (tcpwrapped) |
| 3389/tcp | ms-wbt-server | RDP — Terminal Services |
| 5985/tcp | http | WinRM (Microsoft-HTTPAPI/2.0) |
Open ports and services found by the Nmap scan
The combination of Kerberos (88), LDAP (389/3268) and the judge.local domain name confirms this is an Active Directory Domain Controller.
Credentials Enumeration
We were provided with assumed-breach credentials by the box creator, so we begin as an authenticated low-privilege domain user.
== Assumed Breach ==
Username: d.taylor
Password: [email protected]
Enumerating Domain Users
Using the credentials, we enumerate the other domain accounts so we know who we might be able to pivot to.
Judge ➜ nxc smb judge.local -u d.taylor -p '[email protected]' --users

Domain Users Enumerated
This returns the following user accounts:
j.smithe.brownm.clarks.wilsond.taylor
Enumerating Shares
Next we check whether d.taylor has any access to SMB shares on the target.
Judge ➜ nxc smb judge.local -u d.taylor -p '[email protected]' --shares

Discovered Shares
d.taylor has no meaningful permissions over any of the shares, so SMB is a dead end for this account. We need to look at the account’s Active Directory rights instead.
BloodHound Enumeration
To map out d.taylor’s privileges across the domain, we collect the data with BloodHound.
(.venv) BloodHound.py (bloodhound-ce) ➜ python3 bloodhound.py -u 'd.taylor' -p '[email protected]' -c All --zip -ns 10.0.4.146 -d judge.local

Conducted BloodHound Enumeration
Identifying the DACL Privilege
Inspecting the collected data, we find that d.taylor holds the ForceChangePassword right over s.wilson.

Identified Privilege
ForceChangePassword allows a principal to set a new password for the target account without knowing the current one. In practice this means we can fully take over s.wilson.
Exploitation
Because we can reset s.wilson’s password, we effectively control that account. We’ll set a new password and then use it to re-enumerate SMB from s.wilson’s perspective.
Resetting the Password
We abuse the ForceChangePassword right with bloodyAD to set a password we control.
Judge ➜ bloodyAD -u d.taylor -p '[email protected]' -H DC01.judge.local -d judge.local set password s.wilson 'Hacker123!'
Also we verify right a way if we successfully can authenticate with the new password.

Successfully Updated Password
The password is updated successfully, giving us control of s.wilson.
Reviewing s.wilson’s Share Access
Now that we own a second account, we repeat the share enumeration as s.wilson.

Read Access Discovered
Unlike d.taylor, s.wilson has READ access to the script share.
Looting the script Share
The share contains a single file, mount.bat. We download it and find a new set of cleartext credentials inside, this time for e.brown.
Judge ➜ smbclient //judge.local/script -U s.wilson
smb: \> get mount.bat

Discovered Credentials
set USERNAME=e.brown
set Password=El3vator876#
Storing credentials in logon scripts on a readable share is a common misconfiguration and here it hands us user-level access.
Logging in as e.brown
With valid credentials and WinRM open, we drop into an interactive shell as e.brown.
Judge ➜ evil-winrm-py -i 10.0.4.146 -u e.brown -p 'El3vator876#'

Successfully Gained User Level Access
We now have user-level access to the target.
Post-Enumeration
With a shell as e.brown, we return to BloodHound to see what this account can do in the domain.
Identifying e.brown’s Domain Privileges

WriteOwner Permission
e.brown holds WriteOwner over the Default Domain Policy GPO. This is the escalation path:
- WriteOwner lets us set ourselves as the owner of the GPO.
- As owner, we can grant ourselves full control (edit rights) over it.
- With edit rights, we can inject a malicious setting in this case: a scheduled task, that executes on every machine the GPO applies to, including the Domain Controller.
Because the Default Domain Policy is linked at the domain root, any command we push runs in a highly privileged context. We’ll use it to add e.brown to Domain Admins
Post-Exploitation
Abusing the GPO
We use pyGPOAbuse to modify the GPO and schedule a command that adds e.brown to the Domain Admins group.
(.venv) pyGPOAbuse (master) ➜ python3 pygpoabuse.py judge.local/e.brown:"El3vator876#" -gpo-id 31B2F340-016D-11D2-945F-00C04FB984F9 -dc-ip 10.0.4.146 -command 'net group "Domain Admins" e.brown /add' -filter-enabled -target-dns-name DC01.judge.local

Modified GPO
pyGPOAbuse injects an immediate scheduled task into the GPO that runs our net group command.
Forcing a GPO Update
Rather than wait for the background refresh cycle, we force the policy to apply immediately from our Evil-WinRM session.
evil-winrm-py PS C:\Users\e.brown\Documents> gpupdate /force

Once the policy applies, the scheduled task runs and e.brown is added to Domain Admins.
Dumping the Administrator Hash (DCSync)
Now that e.brown is a member of Domain Admins, the account has replication rights on the domain. We abuse this with DCSync to pull the Administrator’s NTLM hash directly from the DC.
Judge ➜ secretsdump.py e.brown:'El3vator876#'@10.0.4.146 -just-dc-user administrator

Perform DCSync
Logging in as Administrator
Finally, we authenticate with the recovered NTLM hash using Pass-the-Hash — no cleartext password required.
Judge ➜ evil-winrm-py -i 10.0.4.146 -u administrator -H 70daab295e23be7672976607b78d381d

Successfully Logged In
We now have full Domain Administrator access, completing the box.

