Strategy & Governance

Managed Security

Cyber Defense

Governance, Risk & Compliance

Operations & People

Talk to us

Cyber Defense

Source code security review that finds the class, not the instance.

Source code security review services earn their cost in one specific way: a penetration test finds the injection on the search page, and a code review finds the twelve other places the same helper is called. One is an instance. The other is the class of bug, and only the code shows it.

We combine tuned static analysis with manual review by people who read the code. Automated tools give breadth and catch known-bad patterns; they also generate the false positives that make developers stop reading. Everything we report has been traced from the entry point to the sink by hand, with file and line, so the fix is obvious and the argument is over.

Review works best against the design questions tools cannot ask: is authorisation enforced centrally or re-implemented per handler, is the cryptography correct as well as strong, does untrusted data ever reach a template unescaped. Pair it with web application penetration testing: code review says what is wrong, the test says what is reachable.

Why you need it

01 / 06

Why review the code as well as the running system.

01

You find every instance, not the one that was exposed.

A test reaches the code paths it can reach. A review sees the handler behind the feature flag, the admin endpoint that is not linked, and the second call site of the unsafe function that nobody remembered.

02

It is cheapest before the release.

A design flaw found in review is a refactor. The same flaw found after launch is an incident, a patch, a customer notification and a re-test. Reviewing at merge or before a major release is where the economics sit.

03

Some bugs have no external symptom.

A hard-coded key, a weak random source used to generate tokens, a cryptographic mode without integrity, an authorisation check that runs after the side effect. None of these look wrong from outside until the day they do.

04

Auditors and enterprise buyers ask for it specifically.

Secure development lifecycle expectations under ISO 27001:2022 and SOC 2, and most enterprise security questionnaires, ask whether code is reviewed for security. A dated review with findings and closure answers it directly.

Instrument

02 / 06

What the scanner says, and what the reviewer traced.

The same codebase seen twice: automated output, then the findings that survive a human following the data from input to sink.

What we deliver

03 / 06

How the review is structured.

01

Tuned static analysis

Semgrep with rules written for your stack and your frameworks, CodeQL where the language is supported, and language-specific analysers, run against the whole repository to establish breadth, then triaged so that what reaches you is signal.

02

Manual review of the security-critical paths

Authentication, session handling, authorisation checks, password and token storage, cryptographic use, file handling and upload, deserialisation, and every place user-controlled data crosses a trust boundary. This is the part that finds design flaws.

03

Data-flow and taint tracing

Following untrusted input from each entry point (request parameters, headers, message queues, uploaded files, third-party callbacks) to every sink that executes, queries, renders or writes it, and reporting where sanitisation is missing rather than where a pattern matched.

04

Secrets and configuration

Credentials, API keys and private keys in code, configuration and version-control history; debug settings enabled in production paths; and the difference between what the deployment configuration claims and what the code reads.

05

Dependency and supply-chain review

Third-party libraries with known vulnerabilities, filtered to those that are actually reachable from your code, plus licence and provenance issues, unpinned versions, and build scripts that fetch from places nobody has audited.

06

Developer walkthrough and secure-coding guidance

A working session on the findings with the team that owns the code, and a short set of patterns to standardise: the central authorisation helper, the parameterised query wrapper, the one place output encoding happens.

How we run it

04 / 06

Six steps, from repository access to closure.

  1. 01

    Initial consultation

    The architecture, the languages and frameworks, what the application protects, and where the team already has doubts. Reviews are far more valuable when the engineers say where the bodies are buried.

    Week 0
  2. 02

    Scope definition

    Repositories, branches and commit hash under review, the modules that matter most, and what is explicitly excluded: generated code, vendored dependencies, legacy services being retired. Access is read-only and time-bound.

    Week 0
  3. 03

    Automated analysis

    Static analysis across the codebase, dependency and secret scanning, and a first pass at complexity and hot-spot identification to direct the manual effort at the code that matters.

    Days 1-2
  4. 04

    Manual code review

    Security-critical paths read line by line, tool output triaged and either traced to a real finding or discarded with a reason, and data flow followed from entry point to sink.

    Days 3-8
  5. 05

    Reporting and recommendations

    Findings with file, line, the vulnerable snippet, the traced path and a concrete fix: a patch or pull request where the change is small enough to write. Ranked by exploitability and by how many call sites share the root cause.

    Days 9-10
  6. 06

    Re-review

    The corrected commits are re-read, including a check that the fix was applied at every call site rather than at the one we named, and a closure note is issued for your audit file.

    After your fixes

Key benefits

05 / 06

What changes after.

Root causes get fixed, not symptoms

Findings are grouped by the pattern that produced them, so one change to a shared helper closes eleven issues instead of eleven separate patches.

Your developers keep the knowledge

The walkthrough and the rule set stay with the team. Custom static-analysis rules from the engagement can run in your pipeline afterwards and stop the same bug being written again.

Secure development is evidenced

A dated review against a named commit, with findings and verified closure, is exactly what an ISO 27001:2022 or SOC 2 assessor means by secure development lifecycle evidence.

Tools we use

06 / 06

Named, and used on your engagement.

No “latest tech tools”. These are the ones your report will cite, alongside the manual work that a tool cannot do for you.

Static analysis

  • Semgrep
  • CodeQL
  • SonarQube
  • Bandit
  • Brakeman
  • gosec

Dependencies and supply chain

  • OWASP Dependency-Check
  • Trivy
  • Grype
  • Syft

Secrets

  • Gitleaks
  • TruffleHog

Verification

  • Burp Suite Professional
  • Local build and debugger
  • Unit-level proof of concept

Methodology

  • OWASP ASVS
  • OWASP Code Review Guide
  • CWE Top 25

Why Aphelion

Shared

Four things you can check.

01

The work is done by people with names.

Darshap Nayak, formerly of KPMG, holds a master’s degree in cybersecurity and more than seven years in security operations. Jaimin Somani brings fifteen-plus years of academic and hands-on VAPT. Hemang Desai is an ICT network specialist from Australia. You will meet them, not a logo.

Meet the team
02

Evidence, not adjectives.

Every finding arrives with the reproduction steps, the affected asset and the fix, ranked by what it actually reaches in your environment, not by a CVSS number copied from a scanner. You get the report and the raw output, not a summary of a summary.

See how we test
03

Two offices, one practice.

Ahmedabad and Sharjah, working the same methodology on the same tooling. Indian data-residency requirements and UAE delivery are both ordinary here, and the AphelioNYX AD Pen-Test module runs entirely inside your perimeter when regulation says it must.

The platform
04

What we will not do.

Invent a statistic to make a slide land. Publish your name as a client without written permission. Print an award badge nobody awarded. Founded in 2024. We say so, and we attribute experience to the people who have it.

Ask us anything

100+ organizations secured

Across the globe, and across eight industries. We name a client only with their written permission.

  • Finance & Banking
  • Healthcare
  • Retail & E-commerce
  • Technology
  • SaaS
  • Hospitality
  • Manufacturing
  • Pharmaceuticals

AphelioNYX is SOC 2, ISO and GDPR compliant; attestations are available on request under NDA. We would rather hand you the report than print a badge.

Questions

FAQ

What clients ask before a code review.

Do we have to give you our repository?
We need read access to the code for the duration of the review, and there are several ways to arrange it: a time-limited read-only account on your platform, a snapshot of a named commit, or review conducted on your infrastructure where policy requires it. Access is scoped to the branches in the agreed scope and revoked at the end; the terms are set out in the engagement agreement before anything is cloned.
Which languages do you review?
Java, C#, Python, JavaScript and TypeScript, PHP, Go, Ruby, Kotlin and Swift cover the majority of what we see, along with the frameworks built on them. If your stack is outside that list, say so during scoping. We will tell you honestly whether we can review it properly rather than run a scanner over it and call it a review.
How is this different from the SAST tool in our pipeline?
Your pipeline tool runs on every commit and catches known-bad patterns, which is exactly what it should do. It cannot tell that your authorisation helper is called in nineteen handlers and omitted in the twentieth, or that the token generator uses a predictable seed. Reviews find design and logic flaws; keep the tool for regression, and we will tune its rules while we are there.
How much code can you review, and what does it cost?
Effort scales with the security-critical surface, not with total line count: a large codebase with a small trusted core reviews faster than a small one where every handler does its own authorisation. We scope by module after a short walkthrough of the architecture, and we tell you where a partial review would be misleading rather than accept a budget that cannot cover it.
Should we do this instead of a penetration test?
Alongside, not instead. A review tells you what is wrong in the code, including what is unreachable today and will be reachable after the next release. A test tells you what an attacker actually reaches now, including flaws in configuration and deployment that no source file contains. Where budget forces a choice, test first if you are already live and review first if you are about to ship.

Forty-five minutes. Your environment, not a slide deck.

A personalised walkthrough and a free readiness assessment against the frameworks you are actually being asked for. Pick a time that suits you, or write to us. We reply within one business day.