Skip to content
BCTI

01 → 06

Web3 security

Smart contracts, the protocols built on them and the Web 2.5 layer of apps, keys and infrastructure around them.

01

Smart contract audit

We review your contracts at a fixed commit, model how value moves through the protocol and who can move it, and try to break every assumption. Every serious finding is backed by an exploit test.

What you get

Audit report with severity ratings, Foundry proof-of-concept tests for critical and high findings, a fix review and a version ready to publish.

What we test

  • Access control, roles and upgradeability (proxies, initialisers, storage layout)
  • Reentrancy, including cross-function and read-only
  • Arithmetic, rounding and precision loss
  • Signatures: EIP-712, permit and replay protection
  • Token integration quirks: fee-on-transfer, rebasing, callbacks
02

Fuzzing & invariant testing

We work with your developers to write down the properties that must always hold, such as solvency, conservation of value and access rules, and build handler-based fuzzing suites that try to break them.

What you get

The fuzzing suite as code in your repository, a coverage report and a minimised counterexample for every broken property.

What we test

  • Invariant and property specification with your team
  • Stateful, handler-based fuzzing with Foundry, Echidna and Medusa
  • Differential fuzzing against reference implementations
  • Long-running campaigns with coverage tracking
  • Integration into your CI pipeline
03

Formal verification

For code where a failure would be catastrophic, testing is not enough. We specify critical properties formally and prove them with symbolic execution and automated provers, stating every assumption explicitly.

What you get

Machine-checkable specifications and proofs in your repository, plus a report on what is proven, under which assumptions and what is out of scope.

What we test

  • Formal specification of critical properties
  • Symbolic execution of Foundry tests with Halmos and hevm
  • Rule-based verification with the Certora Prover
  • Equivalence checking of optimised or upgraded code
  • Math libraries: fixed-point arithmetic, AMM curves, interest models
04

DeFi & cross-chain protocol security

Many exploits use the code exactly as written: they abuse prices, incentives and trust assumptions. We model how an attacker with flash-loan capital would make your protocol pay.

What you get

Attack scenarios simulated on a mainnet fork, with their profitability and concrete design or parameter changes.

What we test

  • Oracle manipulation and price dependencies
  • Flash-loan and MEV scenarios: sandwiching, front-running, back-running
  • Liquidation, interest-rate and incentive logic
  • Governance takeovers and timelock bypasses
  • Bridges and cross-chain messaging: verification, replay, finality
05

Web 2.5 application security

Users never touch your contracts directly: they go through a website, an API and a wallet. We attack that Web 2.5 layer, where a single malicious script can turn every signature into a transfer to an attacker.

What you get

Penetration test report with attack chains from the browser to user funds, mapped to OWASP, and prioritised fixes.

What we test

  • dApp front ends: script injection, supply chain, DNS and CDN hijacking
  • Integrity of transaction and signature requests: what users are actually asked to sign
  • Wallet authentication: Sign-In with Ethereum (SIWE) and sessions
  • Off-chain backends: indexers, relayers, order books and gasless APIs
  • Exchange, custody and admin platforms
06

Wallets, keys & node infrastructure

Some of the largest Web3 losses started with a compromised signer or key, not a contract bug. We test how your keys are generated, stored and used, and how an attacker could reach them.

What you get

Attack paths to keys and funds, with a hardening plan for signing operations and infrastructure.

What we test

  • Multisig signing procedures and blind-signing risks
  • MPC and HSM custody, key ceremonies and backups
  • Deployer and admin keys in CI/CD and the cloud
  • Node, validator and RPC infrastructure
  • Oracle, keeper and relayer bots

07 → 12

Offensive security

Penetration testing, red teaming and social engineering for traditional applications and infrastructure.

07

Web application penetration testing

We test your applications as an authenticated and unauthenticated attacker, combining tooling with manual analysis to find the flaws scanners miss.

What you get

Technical report mapped to OWASP WSTG/ASVS, with reproducible evidence and specific fixes for each finding.

What we test

  • Authentication and session management
  • Access control: IDOR and privilege escalation
  • Injection: SQLi, XSS, SSTI, command injection
  • Business logic flaws
  • Misconfigurations and exposed secrets
08

API & mobile application testing

APIs and mobile apps expose your business logic directly. We review how they authenticate, authorise and protect data, both on the server and on the device.

What you get

Report mapped to OWASP API Security Top 10 and MASVS, with proof-of-concept requests.

What we test

  • Object- and function-level authorisation
  • Tokens, JWT and OAuth/OIDC flows
  • Rate limiting and mass assignment
  • Insecure data storage on the device
  • Reverse engineering and certificate pinning bypass
09

Network & Active Directory

We start from the internet or from an unprivileged foothold inside your network and show how far an attacker can get.

What you get

Attack paths with evidence, affected assets and a prioritised hardening plan.

What we test

  • External attack surface and exposed services
  • Internal network segmentation
  • Active Directory: Kerberoasting, ACL abuse, AD CS
  • Lateral movement and privilege escalation
  • Wi-Fi security
10

Cloud security assessment

In the cloud, one excessive permission can be enough. We review your configuration and attack it the way an intruder with stolen credentials would.

What you get

Findings per account and service, with exploitation paths and remediation steps.

What we test

  • IAM and privilege escalation paths
  • Storage and secrets exposure
  • Network exposure and security groups
  • Kubernetes and container security
  • Logging and detection gaps
11

Red teaming & adversary simulation

A red team exercise answers one question: could a determined attacker reach your most critical assets without being stopped? We test people, processes and technology together.

What you get

Attack narrative mapped to MITRE ATT&CK, detection gap analysis and a joint debrief with your defenders.

What we test

  • Threat-intelligence-led scenarios
  • Initial access: phishing, external exploitation, physical
  • Evasion of EDR and monitoring
  • Objective-based actions against your crown jewels
  • Purple team debrief to improve detection
12

Social engineering & phishing

Most breaches start with a person. We run controlled, ethical campaigns that show where awareness needs reinforcing, without blaming individuals.

What you get

Campaign metrics, anonymised by default, plus concrete awareness recommendations.

What we test

  • Phishing campaigns: credential capture and payloads
  • Vishing (voice) and pretexting
  • Physical access testing
  • Metrics by department
  • Awareness and training recommendations

FAQ

Frequently asked questions

What is the difference between fuzzing and formal verification?

Fuzzing runs millions of random transaction sequences and checks that your invariants still hold. It is fast, cheap to run continuously and finds real counterexamples, but it can only show that bugs exist, not that they don’t. Formal verification reasons about every possible input and state, so a proven property holds universally, under the stated assumptions. We fuzz broadly and apply formal verification to the code where a failure would be catastrophic.

Which chains and languages do you cover?

Our focus is the EVM: Solidity, Vyper and Yul on Ethereum, layer 2s and other EVM-compatible chains. For other ecosystems, ask us: we will tell you honestly whether we are the right fit.

Does an audit guarantee that our code is secure?

No honest auditor can promise that. An audit significantly reduces risk within a defined scope and time. That is why we combine manual review with fuzzing and formal verification, and recommend monitoring and a bug bounty after launch.

Will testing disrupt our production systems?

Every test is planned to minimise risk: agreed time windows, no destructive techniques without explicit approval, and a direct line to our team throughout the engagement. Smart contract testing runs on local forks, never against live funds, and systems can be tested in staging environments.

How long does an engagement take?

It depends on the scope. An audit is sized by the amount and complexity of the code, a single web application usually takes one to two weeks, and a red team exercise can run for several weeks. You get a precise estimate after the scoping call.

What do we receive at the end?

An executive summary for management, a detailed technical report with evidence and remediation guidance, and a results presentation. Fuzzing and verification suites are delivered as code in your repository. Once you have fixed the issues, we review the fixes.

Do you sign a non-disclosure agreement?

Always. Every engagement starts with a signed authorisation and an NDA, and all code and information is handled confidentially.

How exposed are you, really?

Tell us about your protocol or your environment and we will propose an engagement tailored to it.

Talk to us