Thick Client VAPT · Desktop & Electron

Thick client penetration testing from Sumrite for software that lives on the desktop.

Desktop apps hold session data locally and trust the network. We test installed clients the way attackers with laptop access would — memory, storage, updates, and traffic.

What this helps you achieve

Protect data on shared PCs

Find credentials in memory, logs, or config files.

Harden updates and installers

Reduce tampering and local privilege escalation.

Meet enterprise deployment reviews

Satisfy security for finance, healthcare, and government desktops.

Validate client-server trust

Ensure the app cannot be tricked into leaking data.

Test Your Desktop Application. Installer or build · NDA first

CERT-In empanelled · India

Get a CERT-In empanelled VAPT report.

Sumrite’s testers run your thick client VAPT by hand, and the report is issued through a CERT-In empanelled auditor. One team from scoping to sign-off, built for Indian regulators, enterprise buyers and government work.

  • Accepted where it is requiredRegulators, auditors and procurement teams that ask for a CERT-In empanelled auditor’s report, including SEBI-regulated entities and government and PSU contracts.
  • One team, one contractSumrite handles scoping, testing, the report and the retest. You do not manage a second vendor.
  • Real testing, not a scanManual exploitation with evidence for every finding, and a retest after your fixes.

Can Sumrite also arrange the formal step for me?

Yes. We run the full engagement for you and route the formal attestation through our network of CERT-In empanelled partner auditors, so you deal with one team from scoping to report.

What is thick client VAPT?

Thick client VAPT is a security test of software installed on a desktop or laptop, such as a trading terminal, a hospital records client, an internal finance tool or an Electron app. Unlike a web app, a thick client does much of its work on the user's machine, so it often stores session data locally, keeps secrets in memory or configuration files, and trusts the network more than it should. A tester examines the installed application the way an attacker with access to the laptop would: reading local storage and memory, decompiling .NET, Java or Electron code, intercepting traffic between the client and its server, and checking whether the installer or auto-update can be abused to run code or gain higher privileges. The server the client talks to is tested too, because a client-side check is no protection if the server trusts whatever it receives.

Thick client testing methodology

  • Information gathering: architecture, technology (.NET, Java, Electron, native), installer and update mechanism
  • Static analysis: decompiling binaries, hard-coded secrets, connection strings and licence checks
  • Local storage: files, registry, configuration and credentials left on disk
  • Traffic analysis: intercepting HTTP and non-HTTP protocols between client and server
  • Dynamic analysis: memory inspection, DLL hijacking, process injection and privilege escalation
  • Server-side trust: business rules enforced only in the client, and direct calls to the backend
  • Retest of every fix, with before-and-after evidence

Tools used in thick client penetration testing

AreaTypical tools
Decompiling and reversingdnSpy, ILSpy, JD-GUI, Ghidra
Traffic interceptionBurp Suite, Echo Mirage, Wireshark
Runtime and memoryx64dbg, Process Hacker, Frida
File, registry and process activityProcess Monitor, Sysinternals Suite

Tools speed up routine work; findings are confirmed by hand.

What Thick Client VAPT covers

AreaWhat we checkExample finding
Local dataCredentials, tokens and personal data in files, registry or logsA database password in a readable config file
MemorySecrets and session data held in process memoryA user's session token recoverable from a memory dump
Binary protectionsDecompilation, tampering, debug and signing checksA licence or role check removed by patching the binary
Client-server trustTraffic interception and server-side validationThe server accepts a price changed in the client's request
Installer and updatesUpdate integrity, file permissions, privilege escalationAn unsigned update path that runs attacker code as admin

How an engagement runs

  1. Scope and NDA. Tell us what needs testing and why. You get a fixed-price quote and an NDA is signed before any technical detail changes hands.
  2. Rules of engagement. Targets, test windows, accounts, safety contacts and anything off-limits are agreed in writing before testing starts.
  3. Expert-led testing. A researcher tests by hand, using tools to speed up the routine parts. Every finding is reproduced and confirmed before it is reported.
  4. Report. An executive summary for leadership, then each finding with a CVSS severity, the evidence, steps to reproduce and a fix your team can apply.
  5. Re-test. Once fixes are in, we test them again and record the result, so the final report shows what was found and what is now closed.

Thick Client VAPT: common questions

Which desktop technologies do you test?

.NET (WinForms and WPF), Java, Electron and native Windows and macOS applications, together with the backend services they connect to.

Read this in the FAQ →

What do you need to start?

The installer or build, test accounts, and access to a test backend. A short walkthrough of the main workflows helps the tester focus on what matters.

Read this in the FAQ →

Why test a thick client if the server is already tested?

The client often holds secrets, cached data and logic of its own. Attackers with access to one laptop can extract those, or use the client to send requests the server was never designed to receive.

Read this in the FAQ →

See all Thick Client VAPT questions in the FAQ →

We run the full engagement for these frameworks, and where a formal audit or attestation is needed we route it through our local partner firms, so you deal with one team.

Related services

Further reading

The problem & our approach

Users treat desktop software as trusted — attackers do too.

Thick clients bypass browser sandboxes. Weak local encryption and debug builds in production still cause major incidents.

Sumrite's Thick Client VAPT combines binary review, runtime inspection, and protocol testing before wide rollout.

  • Findings for IT and development
  • Proof for each high-risk issue
  • Report for vendor packets
For engineering & security teams

Technical overview

Methodology, scope, and deliverables in plain terms.

How we test

OWASP client-side and PTES: local storage, updates, binary protections, and API traffic.

  • .NET, Java, Electron, native Windows/macOS
  • Installers and auto-update
  • Backend sync and authentication

What you receive

Risk-rated report with reproduction and fixes. Re-test included on standard engagements.

OWASP Testing GuidePTESCWE Top 25
Simple process

Your Thick Client VAPT journey

Every step from scope and NDA to a retested, final report, shown for Thick Client VAPT. No jargon, no surprises.

Step 1 of 6

Request your thick client test

Submit your scope so our team can plan the engagement and get started.

  • Installer or build and the supported operating systems
  • The servers and APIs the client talks to
  • Test accounts and licence keys
  • NDA and testing authorisation signed first
Step 2 of 6

Expert assessment: Thick Client VAPT

Every phase is run by a security expert, with tools used only to speed up the routine parts. Findings are reproduced and confirmed before they reach your report.

Static and binary

  • Decompile .NET, Java and native binaries
  • Hard-coded credentials, keys and connection strings
  • DLL hijacking, side-loading and installer permissions

Local and runtime

  • Local storage, registry, configuration files and memory
  • Process hooking and tampering
  • Licence and client-side control bypass

Network and server

  • Interception of proxy-unaware and non-HTTP traffic
  • Server-side authorisation the client simply assumes
Expert-only work: beyond scanners and AI
  • Reverse-engineering custom protocols
  • Hooking the client to test how far the server trusts it
  • Recovering credentials from memory
  • Chaining a local weakness into server compromise
Step 3 of 6

Draft report in 48 hours

Findings are written for two readers at once: developers who need the exact fix and auditors or buyers who need confidence.

  • Executive summary for leadership and auditors
  • CVSS-rated findings with proof of exploitation
  • Step-by-step reproduction for your engineers
  • Mapped to the framework you named in scope
Step 4 of 6

Fix the vulnerabilities

Your team fixes the issues with guidance written for your stack, and the tester who found each issue answers questions directly.

  • Fix guidance per finding, in plain language
  • Prioritised order so critical issues go first
  • Direct line to the tester, no account-manager relay
Step 5 of 6

Re-validation, included

Every fix is tested again. Nothing is marked closed on trust.

  • Each fix re-tested, with before and after evidence
  • Regression checks on related functionality
  • Status per finding: fixed, partly fixed or open
  • Retest included at no extra cost
Step 6 of 6

Final report issued

You receive a verified report in your company name, ready for clients, auditors and procurement.

  • Issued in your company name
  • Updated with retest results
  • Dated and scoped to the assets tested
  • Re-issued after major product changes

Rolling out to enterprise desktops?

Share platform and distribution. We scope it fast.

Test Your Desktop Application. Or run a free scan