Desktop Apps, Taken Apart
Thick Client Penetration Testing
Thick client apps hide a lot in the binary and the traffic between client and server. We reverse the application, watch how it talks to its backend, and test the trust it places in the machine it runs on.
See the engagement path, 6 phasesSee the full VAPT service index
Overview
A thick client VAPT covers desktop applications, whether .NET, Java, C++ or Electron. We look at how the app stores data and secrets locally, how it communicates with its servers, and how much it trusts input from the client side. Because the user controls the machine, we test what happens when an attacker tampers with the binary, the memory and the traffic that the app assumes it can rely on.
Methodology
How the Engagement Runs
Every phase has a named output, so you always know what is being worked on and what lands on your side of the table.
6 Phases, 6 Named Handovers
Flow
Flow chart of the Thick Client Application engagement, 6 phases in order, each one selectable. Phase 1, Scoping and Rules of Engagement. We agree the application, installers, test accounts and backend services in scope, and set up a controlled test machine. Activities: Confirm the app, installers and backends in scope; Provision test accounts and licences; Set up a controlled test machine; Agree testing windows and contacts. Hands over Signed Rules of Engagement. Phase 2, Reconnaissance and Binary Analysis. We inspect the installed files, configuration and binaries, decompile managed code and look for secrets, weak crypto and unsafe local storage. Activities: Inspect installed files and configuration; Decompile managed .NET and Java code; Hunt for hardcoded secrets and weak crypto; Review local data storage. Hands over Binary Analysis Findings. Phase 3, Traffic and Protocol Analysis. We intercept and decode the client-to-server traffic, including proprietary and non-HTTP protocols, to find weak transport and trust in client input. Activities: Intercept client-to-server traffic; Decode proprietary and non-HTTP protocols; Assess transport security; Probe server trust in client input. Hands over Protocol Analysis Findings. Phase 4, Manual Exploitation. We tamper with the binary, patch runtime behaviour and manipulate memory to bypass client-side controls and licensing checks. Activities: Patch the binary to alter behaviour; Manipulate memory at runtime; Bypass client-side security controls; Defeat licensing and integrity checks. Hands over Proven Client-Side Findings. Phase 5, Backend and Impact. We test the server the client trusts and show how client-side tampering translates into real impact on data and other users. Activities: Test the backend services the client trusts; Turn client tampering into server-side impact; Map exposed data and affected users; Assess combined business impact. Hands over Impact and Risk Assessment. Phase 6, Reporting and Verified Retest. You get a report with proof of concept and clear fixes, and we retest once you remediate to confirm each issue is closed. Activities: Document findings with proof of concept; Produce an executive summary; Walk your team through the results; Retest fixes and confirm closure. Hands over Final Report and Verified Retest. Each phase begins from the artefact the phase before it produced.
Phase 01 Scoping and Rules of Engagement
We agree the application, installers, test accounts and backend services in scope, and set up a controlled test machine.
What Happens In This Phase
- Confirm the app, installers and backends in scope
- Provision test accounts and licences
- Set up a controlled test machine
- Agree testing windows and contacts
The Handover
Signed Rules of Engagement
The next phase starts from this.
Phase 01 Scoping and Rules of Engagement
We agree the application, installers, test accounts and backend services in scope, and set up a controlled test machine.
What Happens In This Phase
- Confirm the app, installers and backends in scope
- Provision test accounts and licences
- Set up a controlled test machine
- Agree testing windows and contacts
The Handover
Signed Rules of Engagement
The next phase starts from this.
- 01
Scoping and Rules of Engagement
We agree the application, installers, test accounts and backend services in scope, and set up a controlled test machine.
OutputSigned Rules of EngagementActivities
- Confirm the app, installers and backends in scope
- Provision test accounts and licences
- Set up a controlled test machine
- Agree testing windows and contacts
- 02
Reconnaissance and Binary Analysis
We inspect the installed files, configuration and binaries, decompile managed code and look for secrets, weak crypto and unsafe local storage.
OutputBinary Analysis FindingsActivities
- Inspect installed files and configuration
- Decompile managed .NET and Java code
- Hunt for hardcoded secrets and weak crypto
- Review local data storage
- 03
Traffic and Protocol Analysis
We intercept and decode the client-to-server traffic, including proprietary and non-HTTP protocols, to find weak transport and trust in client input.
OutputProtocol Analysis FindingsActivities
- Intercept client-to-server traffic
- Decode proprietary and non-HTTP protocols
- Assess transport security
- Probe server trust in client input
- 04
Manual Exploitation
We tamper with the binary, patch runtime behaviour and manipulate memory to bypass client-side controls and licensing checks.
OutputProven Client-Side FindingsActivities
- Patch the binary to alter behaviour
- Manipulate memory at runtime
- Bypass client-side security controls
- Defeat licensing and integrity checks
- 05
Backend and Impact
We test the server the client trusts and show how client-side tampering translates into real impact on data and other users.
OutputImpact and Risk AssessmentActivities
- Test the backend services the client trusts
- Turn client tampering into server-side impact
- Map exposed data and affected users
- Assess combined business impact
- 06
Reporting and Verified Retest
You get a report with proof of concept and clear fixes, and we retest once you remediate to confirm each issue is closed.
OutputFinal Report and Verified RetestActivities
- Document findings with proof of concept
- Produce an executive summary
- Walk your team through the results
- Retest fixes and confirm closure
Specification
What We Run, and What We Measure You Against
The tooling our engineers use on this work, and the published standards the findings and evidence are mapped to.
What Is Examined, and What it Is Measured Against
Map
Map of the Thick Client Application scope, running left to right in three stages. Stage one, what we run, 8 tools and techniques: Ghidra, x64dbg, Wireshark, Frida, dnSpy, Echo Mirage, Process Monitor, Burp Suite Professional. Stage two, findings from all of it are proven by hand and written up once. Stage three, measured against 5 published standards: OWASP ASVS, PTES, NIST SP 800-115, OSSTMM, CVSS v4.0.
What We Run
8 tools
- dnSpy
- Echo Mirage
- Process Monitor
Converges On
One Set of Proven Findings
Every issue is reproduced by hand before it is written down, and it is written down once.
Measured Against
5 standards
- OWASP
- PTES
- OSSTMMISECOM
Deliverables
What You Receive
- Findings report with proof of concept
- Executive summary
- Remediation guidance
- Verified retest report
- Attestation letter
Scope This Engagement
Tell us about your environment, your timelines and any audit dates you are working to. We come back with scope, effort and a start date.
What kinds of desktop apps can you test?
We test .NET, Java, C and C++, and Electron applications on Windows, and other desktop stacks on request. The approach adapts to how the app is built and how it talks to its backend.
Do you test the server side too?
Yes. A thick client is only half the picture. We test the services it depends on, because most real impact comes from a server that trusts a client an attacker fully controls.
Can you handle custom or non-HTTP protocols?
Yes. We decode proprietary and binary protocols with tools like Wireshark and Echo Mirage so we can test communication that ordinary web proxies never see.
Keep Moving Through VAPT
Service 4 of 7 in this practice area
Practice Area
More in VAPT
- Web ApplicationManual testing of your web apps against the OWASP WSTG
- Mobile ApplicationAndroid and iOS app testing against the OWASP MASVS
- APIREST, GraphQL and SOAP testing against the OWASP API Top 10
- Network InfrastructureExternal and internal network testing with lateral movement
- IoT and EmbeddedDevice testing across firmware, hardware and radio
- CloudConfiguration and IAM testing across AWS, Azure and GCP