Why application control is the highest-impact Essential Eight control
Application control (formerly "application whitelisting") is designated Control 1 in the ACSC Essential Eight for good reason: it prevents unauthorised code execution at the source. By enforcing an allow-list of trusted applications, organisations block the vast majority of commodity malware, ransomware droppers, and fileless attack techniques before they can execute. For Australian organisations seeking Essential Eight compliance, application control is non-negotiable—and technically challenging to implement well.
1) Understanding application control under Essential Eight
- What qualifies: ACSC accepts Microsoft AppLocker (Windows 7+), Windows Defender Application Control (WDAC, Windows 10+), or equivalent third-party solutions that enforce application execution policies.
- Maturity levels: Level 1 requires application control on some endpoints; Level 2 demands coverage across workstations and servers with centralised management; Level 3 adds tamper resistance and strict block-by-default enforcement.
- Scope: Controls must cover executables, scripts (PowerShell, VBScript, batch), DLLs, and installers.
- Common gap: Many organisations deploy application control to workstations but neglect servers, where attackers often establish persistence post-compromise.
2) AppLocker vs WDAC: Choosing your enforcement engine
AppLocker (Windows 7–11, Server 2008 R2+)
- Strengths: User-friendly Group Policy management, well-documented, supports rule types (publisher, path, hash), audit mode for testing.
- Limitations: Can be bypassed via DLL injection or unsigned scripts if not comprehensively configured; requires Enterprise edition for full feature set.
- Best for: Small-to-medium enterprises with existing Group Policy infrastructure seeking Essential Eight Level 1-2 compliance.
Windows Defender Application Control (WDAC, Windows 10+)
- Strengths: Kernel-mode enforcement (tamper-resistant), integrated with code integrity and Secure Boot, supports managed installer rules and Intelligent Security Graph intelligence.
- Limitations: More complex to configure (XML policies), requires Windows 10 1903+ for best features, limited GUI tooling.
- Best for: Organisations targeting Essential Eight Level 3, high-security environments, Windows 10/11-only fleets.
Recommendation for Australian SMBs
Start with AppLocker in audit mode to baseline application usage. For high-security environments or Level 3 maturity targets, migrate to WDAC after proving enforcement feasibility. Hybrid deployments (AppLocker on legacy, WDAC on modern endpoints) are common during transition phases.
3) Step-by-step AppLocker implementation (Level 2 target)
Phase 1: Baseline and pilot (Weeks 1-4)
- Enable audit mode GPO: Create a Group Policy Object targeting a pilot OU (e.g., IT department, 20-50 devices).
Computer Configuration > Policies > Windows Settings > Security Settings > Application Control Policies > AppLocker - Generate default rules: Right-click each rule collection (Executable, Windows Installer, Script, Packaged app) and select "Create Default Rules". These allow Windows system files and Program Files to execute.
- Set to audit mode: Configure enforcement to "Audit only" for all rule collections. This logs blocks without preventing execution.
Configure rule enforcement > Set all to "Audit only" - Deploy and monitor: Link the GPO to the pilot OU. Monitor Event Viewer logs for 2-4 weeks:
Event Viewer > Applications and Services Logs > Microsoft > Windows > AppLocker > EXE and DLL (Event IDs 8003, 8004 for blocks) - Analyse blocked events: Export logs to CSV, identify legitimate applications being blocked (especially line-of-business apps installed outside Program Files), and create allow rules using publisher certificates or file hashes.
Phase 2: Enforcement rollout (Weeks 5-12)
- Create application allow rules: For each legitimate blocked application:
- Publisher rules (preferred): Right-click rule collection > Create New Rule > Publisher > Select signed executable > Scope to product name and version range.
- Hash rules (fallback): For unsigned apps, create hash-based rules. Note: Hash rules break on application updates.
- Path rules (use sparingly): Allow execution from specific directories. Risk: Attackers can place malware in allowed paths.
- Test enforcement in rings:
- Ring 1 (Week 5-6): IT department and security team. Set enforcement to "Enforce rules" for Executable and Script collections. Monitor help desk tickets and Event Viewer.
- Ring 2 (Week 7-9): Finance, HR, and other high-value departments. Expand enforcement to Windows Installer and Packaged app rules.
- Ring 3 (Week 10-12): Remaining workstations and servers. Enable DLL rules if targeting Level 3 maturity (note: DLL rules significantly increase complexity and performance impact).
- Exception handling: Establish a formal exception process:
- Temporary exception (7-14 days): Path-based allow rule for testing.
- Permanent exception: Publisher or hash rule with documented business justification and compensating controls (e.g., EDR monitoring).
- Track exceptions in a register reviewed quarterly.
Phase 3: Coverage expansion and hardening (Months 4-6)
- Servers: Deploy AppLocker to Windows servers with enforcement focus on script execution (PowerShell, VBScript). Use managed installer rules to allow software deployment tools.
- DLL rules: If targeting Level 3, enable DLL enforcement on high-security workstations (e.g., privileged access workstations). Test extensively in audit mode first—DLL rules frequently break applications.
- Script hardening: Enable PowerShell Constrained Language Mode via AppLocker script rules to prevent unsigned script execution and inline code injection.
4) Windows Defender Application Control (WDAC) for Level 3 maturity
Key differences from AppLocker
- Policy format: XML-based policies deployed via Intune, SCCM, or local policy. No Group Policy UI.
- Kernel enforcement: Runs in kernel mode, making bypass significantly harder. Integrates with Secure Boot and UEFI.
- Managed installer: WDAC can trust applications deployed by Configuration Manager or Intune, simplifying allow-list management for software deployed via approved channels.
- Intelligent Security Graph: Cloud-powered reputation checks for unknown binaries (requires Windows 10 1903+).
WDAC deployment workflow (condensed)
- Create base policy: Use PowerShell to generate a base policy from a reference device:
New-CIPolicy -Level Publisher -FilePath BasePolicy.xml -UserPEs -MultiplePolicyFormat -Fallback Hash - Merge policies: Combine base policy with Microsoft recommended block rules:
Merge-CIPolicy -PolicyPaths BasePolicy.xml,MSBlockRules.xml -OutputFilePath MergedPolicy.xml - Set to audit mode: Audit mode is the
Enabled:Audit Moderule option (option 3), whichNew-CIPolicysets by default on creation. Ensure it is present before testing:Set-RuleOption -FilePath MergedPolicy.xml -Option 3 - Convert and deploy: Convert XML to binary format and deploy via Intune or local policy. For the multiple-policy format used above, the binary is a
{PolicyGUID}.cipfile deployed to the active-policies folder:ConvertFrom-CIPolicy MergedPolicy.xml MergedPolicy.cip # Deploy via Intune, or copy the .cip to # C:\Windows\System32\CodeIntegrity\CiPolicies\Active\ and refresh # (single-policy-format systems use the legacy SIPolicy.p7b path instead) - Monitor and refine: Review audit events, create supplemental policies for legitimate blocked apps, then switch to enforcement mode.
5) Common pitfalls and how to avoid them
- Breaking business-critical apps: Audit for 4+ weeks minimum before enforcement. Engage application owners early to identify dependencies.
- Path rule abuse: Attackers can write malware to allowed paths (e.g., C:\Program Files if write permissions are misconfigured). Use publisher rules wherever possible.
- DLL hell: DLL rules break applications frequently due to dependencies. Deploy DLL enforcement only to high-security devices (PAWs, servers) and test exhaustively.
- Scripting bypass: If script rules aren't configured, PowerShell and VBScript remain attack vectors. Enable script enforcement and consider PowerShell logging + Constrained Language Mode.
- Update breakage: Hash-based rules break when applications update. Prefer publisher rules with version wildcards.
- Performance impact: DLL enforcement can cause measurable performance degradation through additional CPU overhead. Benchmark and tune on representative hardware.
6) Integration with ACSC Essential Eight controls
- Control 2 (Patch applications): Application control complements patching by preventing exploitation even when patches are delayed. Use publisher rules with version ranges to allow patched versions automatically.
- Control 3 (Configure Office macros): AppLocker/WDAC can block unsigned macros system-wide, reinforcing Office macro hardening.
- Control 5 (Restrict admin privileges): Deploy stricter application control policies (including DLL rules) to privileged access workstations (PAWs) to protect admin workflows.
- Control 7 (Multi-factor authentication): Application control prevents malware from stealing cached credentials or deploying keyloggers post-authentication.
7) Measuring success and demonstrating compliance
Key metrics
- Coverage: % of endpoints with application control policies enforced (target: 95%+ for Level 2, 98%+ for Level 3).
- Block rate: Unauthorised execution attempts blocked per month. Baseline and trend downward as users adapt.
- Exception count: Track temporary and permanent exceptions. Aim to reduce exceptions over time through publisher rule refinement.
- Incident reduction: Compare malware incidents pre- and post-deployment. Application control typically achieves a substantial reduction in malware execution.
Evidence for ACSC assessments
- Policy exports: Export AppLocker GPOs or WDAC XML policies showing allow-list rules and enforcement status.
- Coverage reports: Demonstrate policy deployment across endpoints via Group Policy Results or Intune compliance reports.
- Event logs: Provide samples of audit and block events showing active enforcement.
- Exception register: Document all exceptions with business justification, approval, and review dates.
- Test results: Evidence of testing (pilot phases, ringed rollouts, incident response drills where application control blocks simulated malware).
8) Illustrative scenario: Australian manufacturing firm
The following is an illustrative scenario - a composite drawn from typical mid-market deployments rather than a specific client engagement - included to show how the phases fit together in practice. The figures are indicative, not measured results.
Organisation: 350-employee manufacturer, Essential Eight Level 1 baseline, targeting Level 2 within 12 months.
Challenge: Ransomware incident via phishing email deploying unsigned executable. No application control in place.
Solution:
- Deployed AppLocker in audit mode across 280 Windows 10 workstations and 15 Windows Server 2019 instances.
- Identified 42 legitimate unsigned applications (mostly internal tools and vendor utilities).
- Created publisher rules for 38 signed apps; hash rules for 4 unsigned critical apps with documented exceptions.
- Enforced executable and script rules in three 4-week rings: IT (20 users) → Finance/HR (60 users) → Production (200 users).
- Enabled DLL rules on 12 privileged access workstations for IT administrators.
Outcome:
- 98% endpoint coverage within 6 months.
- Zero successful malware executions post-deployment (4 attempted infections blocked and logged).
- Essential Eight Level 2 maturity achieved for Control 1 during subsequent ACSC assessment.
- ROI: the implementation cost (internal labour plus consulting) was modest relative to the breach costs a successful ransomware event would have incurred.
9) Practical PowerShell examples
Example 1: Generate AppLocker policy from reference device
# Scan Program Files for executables and build publisher rules, saving to an XML policy
Get-AppLockerFileInformation -Directory "C:\\Program Files" -Recurse -FileType Exe |
New-AppLockerPolicy -RuleType Publisher -User Everyone -Xml |
Out-File ".\\ReferencePolicy.xml"
# Merge the generated policy into the effective local policy
Set-AppLockerPolicy -XmlPolicy ".\\ReferencePolicy.xml" -Merge
# Export the effective policy to XML for review
Get-AppLockerPolicy -Effective -Xml | Out-File ".\\EffectivePolicy.xml"
Example 2: Create hash rule for unsigned application
# Collect file information for the unsigned app
$FileInfo = Get-AppLockerFileInformation -Path "C:\\Tools\\LegacyApp.exe"
# Create a hash-based allow rule and save it to an XML policy
$FileInfo | New-AppLockerPolicy -RuleType Hash -User Everyone -RuleNamePrefix "LegacyApp" -Xml |
Out-File ".\\LegacyAppPolicy.xml"
# Merge the hash rule into the effective local policy
Set-AppLockerPolicy -XmlPolicy ".\\LegacyAppPolicy.xml" -Merge
Example 3: Enable WDAC audit mode
# Generate a base policy from a reference device
# (the Enabled:Audit Mode rule option is set by default on creation)
New-CIPolicy -Level Publisher -FilePath AuditPolicy.xml -UserPEs -MultiplePolicyFormat
# Explicitly ensure audit mode (rule option 3) is present before deployment
Set-RuleOption -FilePath AuditPolicy.xml -Option 3
# Convert to binary (multiple-policy format produces a .cip file)
ConvertFrom-CIPolicy AuditPolicy.xml AuditPolicy.cip
# Deploy via Intune, or copy the .cip to the active-policies folder
Copy-Item AuditPolicy.cip "C:\\Windows\\System32\\CodeIntegrity\\CiPolicies\\Active\\" -Force
# Apply the policy. On Windows 11 / Server 2022+ refresh without a reboot:
# CiTool --refresh
# Otherwise schedule a restart during a maintenance window:
# Restart-Computer -Confirm
10) Before/After comparison
Before application control:
- Any user can execute any downloaded file, including malware.
- PowerShell scripts run unrestricted, enabling fileless attacks.
- Ransomware executes immediately upon phishing email interaction.
- No visibility into unauthorised application usage.
After Essential Eight Level 2 application control:
- Only trusted, signed applications execute; unsigned malware is blocked.
- PowerShell runs in Constrained Language Mode; unsigned scripts are denied.
- Ransomware droppers are logged and blocked before encryption starts.
- Centralised logging provides visibility into application execution patterns.
- Exception register ensures deliberate, auditable allow-list management.
11) Compliance with Australian Privacy Act and ACSC guidance
Application control directly supports Privacy Act obligations for "reasonable steps" to protect personal information by preventing unauthorised code execution that could lead to data breaches. ACSC's Strategies to Mitigate Targeted Cyber Intrusions identifies application control as the most effective single mitigation against ransomware and advanced persistent threats.
Key alignment:
- Australian Privacy Principle 11 (APP 11, Schedule 1): Application control supports the obligation to take reasonable steps to protect personal information by blocking malware that could access or exfiltrate data.
- Notifiable Data Breaches scheme: Demonstrable application control implementation reduces breach likelihood and supports "reasonable steps" defence (OAIC — Notifiable Data Breaches scheme, accessed 16 June 2026).
- ACSC ISM: Application control is a mandatory control for PROTECTED-level systems and strongly recommended for all Australian organisations handling sensitive data (ASD — Information Security Manual, accessed 16 June 2026).
Sources referenced in this article: ACSC Information Security Manual (ISM), OAIC Notifiable Data Breaches scheme, ACSC Strategies to Mitigate Targeted Cyber Intrusions, Privacy Act 1988 (APP 11, Schedule 1).
Call to action
Application control is complex but achievable with phased rollout, stakeholder engagement, and disciplined exception management. Start with AppLocker in audit mode, build your allow-list over 4-8 weeks, and enforce in rings. For Level 3 maturity or high-security environments, progress to WDAC with kernel-mode enforcement and tamper resistance.
Next steps: Pilot application control in your IT department this month. Document blocklists, refine allow rules, and plan your enforcement timeline.


