Crypto Security Audits: What Investors Need to Know12 min read2,498 words

Crypto Security Audits: What Investors Need to Know

Crypto security audits can miss keys, suppliers and unpatched systems. Learn what Hacken’s $1.18B Q3 loss report means and how to assess risk before investing.

crypto security auditscrypto hacksblockchain securitysmart contract auditscrypto custody risk
Crypto Security Audits: What Investors Need to Know

A Crypto Audit Badge Is Not a Security Guarantee

An audit badge can look reassuring - like someone reviewed a project, found the problems, and confirmed everything is safe. But in practice, an audit is a review of a specific scope at a specific time. It often says little about what attackers can reach later: wallets, signing keys, key holders, suppliers, and software updates that happen after the review.

That gap matters. Blockchain security firm Hacken reported that crypto projects lost $1.18 billion across 107 incidents in the third quarter, up 55% from the previous quarter. Hacken attributed about $906.8 million - roughly 77% of the losses - to compromised suppliers or developer tools, security fixes that had not been installed, or components excluded from the latest review.

None of this is proof that audits are useless. It's a reminder that "audited" doesn't mean "everything is secure," and that the difference is usually hidden in the scope. Here's what Hacken's findings do - and don't - tell investors, where audits miss operational risk, and what to verify before trusting a project's security claims.

What Hacken's Q3 report found

Hacken's report covers a quarter where losses jumped - though the headline total is only part of the story. Hacken's key point is that many losses weren't tied to the kind of issues a "smart contract audit" typically covers. Instead, they often involved development tools, external suppliers, key-management setups, and fixes that were available but never deployed.

According to Hacken, $1.18 billion was stolen in 107 incidents during the third quarter. That was 55% more than in the previous quarter. Hacken attributed $906.8 million to compromised suppliers or developer tools, uninstalled security fixes, or components not included in the most recent security review. Those categories point to a broader problem than a vulnerable contract. A project can have code that passed review and still rely on insecure processes or infrastructure.

A large loss does not explain the cause by itself

The $1.18 billion figure combines incidents with different causes and outcomes. Some involved software vulnerabilities; others involved compromised keys, suppliers, or systems around the core product. For investors, that distinction matters. A smart contract review can't, by itself, confirm every employee workflow, signing device, third-party service, or production setup used to run a platform.

Hacken also highlighted the September attack on crypto exchange Bitget as the largest incident in the period, reporting losses of at least $352 million. Hacken said attackers exploited a vulnerability in a third-party security product to reach the exchange's withdrawal infrastructure. This is a supply-chain risk: the exchange may rely on software it didn't build, but that software can still become a route to customer funds.

The report also mentioned several other incidents. It said three bridges and cross-chain protocols lost more than $35 million during a six-hour exploit in July, and that AFX Trade lost $24 million after attackers gained control of validator keys. Hacken listed losses involving Liquid Network, Tectonic, and Coldcard wallet software. Those cases aren't interchangeable, and their inclusion doesn't prove one shared root cause. Taken together, they do show why security reviews need to look beyond contract code.

The 77% figure needs context

The $906.8 million number is a big slice of Q3 losses, but it's best read as Hacken's categorization - not a universal measure of all crypto security failures. Those categories cover different issues, and the report's summary doesn't mean every loss came from a missing audit or an ignored warning.

The practical takeaway is narrower: an audit badge doesn't tell you whether the systems that control funds were included, whether a known fix was installed, or whether the project's suppliers were assessed. Those are separate questions. If you want to know what the badge really represents, you need answers.

Why an audit can miss the system attackers target

An audit isn't a general stamp of approval for a company or protocol. It's an assessment done against a defined scope, using specific methods, at a specific point in time. That scope may include certain smart contracts and exclude the infrastructure that deploys them, administers them, or authorizes withdrawals.

Hacken co-founder and board director Andrii Matiukhin told CoinDesk that scope is the central issue. Reviewing everything that interacts with funds - or affects a protocol's economics - can be expensive, so teams may limit reviews to what they consider critical. This is a real trade-off. Limited resources are common, and not every project can commission a comprehensive review of every dependency. The catch is that the limits should be visible to users, not hidden behind a broad claim that the project is "audited."

A point-in-time review has a time limit

An audit reflects the system as it existed when reviewers received it. Code changes, configuration updates, new integrations, and software upgrades can change the risk after the review ends. The longer the gap between the audit and today's deployment, the less useful the report is as evidence about the system you're actually using now.

That doesn't automatically make an older audit worthless. It can still show how a specific version was assessed and whether reported issues were fixed at that time. The bigger problem is treating it as an ongoing guarantee. If a project changes contracts or adds a new custody provider, the old review may not cover the new setup. A sensible security page should make the version, date, scope, and remediation status easy to find.

Smart contracts are only one part of the product

In many crypto systems, the contract is just one component inside a bigger operating environment. Teams use administrative keys to upgrade contracts, signing infrastructure to authorize transactions, cloud services to run apps, external tools to build software, and third-party providers to monitor or secure the environment.

An audit that focuses on contract logic may not cover those surrounding components. But attackers often look for the simplest path to an outcome, not the part that's most "technically impressive." If a compromised supplier or an exposed key can authorize a withdrawal, then a well-reviewed contract doesn't fix the operational weakness.

So "the contracts were audited" and "the platform is secure" are not the same claim. The first is specific and checkable. The second needs evidence across a much larger system - and even then, it still can't promise attackers will never succeed.

The risks behind keys, suppliers and delayed fixes

Hacken's report highlights several practical risk categories. Each needs a different kind of control, and none can be handled by putting an audit logo on a website.

Signing keys and administrative access

A signing key can authorize actions that affect customer assets or protocol behavior. The key questions are how keys are generated and stored, who can use them, what approvals are required, and how access is monitored. Multi-signature arrangements can reduce reliance on a single person or device, but the number of signers doesn't tell you whether the setup is truly robust. You also need to know how signers are separated, how keys are protected, and what happens if one is compromised.

Hacken said it examined 12 derivatives exchanges and prediction markets. It found that more than $700 million in assets at two major venues depended on a four-key arrangement requiring three signatures, or on administrative keys whose holders were not publicly identified. Matiukhin said the firm wasn't aware of an active vulnerability at those venues, but thought some arrangements were inadequate given the scale. That distinction is important: a configuration can create governance or resilience concerns without proving there was an active exploit.

For users, undisclosed key holders make it harder to evaluate who can act, how decisions are controlled, and whether duties are actually separated. Projects may have legitimate reasons to avoid publishing sensitive operational details. They can still provide independent evidence about the controls and the process for changing them.

Third-party and software supply-chain exposure

Teams rely on external software, services, and suppliers. Those dependencies can introduce vulnerabilities into systems that otherwise look well managed. The Bitget incident, as Hacken described it, shows how a flaw in a third-party security product can affect an exchange's withdrawal infrastructure.

This doesn't mean every supplier is equally risky. A project should identify which external components can affect funds, production access, or transaction approval - and then apply stronger scrutiny to those dependencies. That may include supplier reviews, restricting privileges, monitoring, incident-response plans, and the ability to disable or replace a compromised service.

The investor-facing question is simple: what critical services live outside the project's own codebase, and how does the team limit access? Saying "we use reputable vendors" isn't enough to show what happens if something goes wrong.

Known vulnerabilities and slow remediation

A security review can find problems, but it doesn't install fixes. Hacken said delays in addressing known vulnerabilities were another issue, including cases where software was used across multiple blockchains but updates were applied at different times. Matiukhin also said some critical vulnerabilities were treated as low priority by teams, with fixes delayed or declined.

This creates a gap between identifying a risk and actually removing the exposure. The longer a vulnerable component remains in production, the more time an attacker has. But applying an update too quickly - or without testing - can also cause outages or introduce new bugs. Teams need a controlled process: set severity, assign ownership, test fixes, and track deployments across every affected environment.

For investors, a useful signal isn't a claim that a project has never had a vulnerability. It's whether the team can explain how issues are triaged, how quickly fixes get deployed, and how users learn about changes when risk levels shift.

How investors and teams should assess security claims

Security information often shows up as a badge or a set of audit logos. Those are easy to scan, but they don't provide enough detail to judge risk. A better way to approach it is to think of security as evidence you can verify: scope, current deployment, operational controls, remediation, and accountability.

A practical checklist for investors

Before trusting an audit claim, look for answers to these questions:

  • What was reviewed? Does the report cover smart contracts only, or also relevant infrastructure, administrative functions, and integrations.
  • Which version was assessed? Confirm what contract addresses, code version, or release date were reviewed, and whether the live deployment matches.
  • What issues were found? Look for severity ratings, remediation notes, and any unresolved findings. If the summary doesn't include scope or findings, it's hard to evaluate.
  • Who controls privileged access? Check whether the project explains its key-management model, approval process, and emergency controls at a level you can actually assess.
  • How are dependencies managed? Look for evidence that critical suppliers and software components are identified, monitored, and restricted in what they can access.
  • How are fixes deployed? A vulnerability policy should explain how findings are triaged and how updates reach every relevant chain or production environment.
  • What happens during an incident? See whether the project has a documented response process, communication channels, and a way to pause or limit damage when needed.

No single answer proves a platform is safe. What you're trying to learn is whether the project understands its own trust boundaries and can explain how it manages them. If basic information is missing, that's uncertainty - not proof that a vulnerability exists, and not reassurance either.

What responsible teams should publish

Teams should make audit scope and limitations clear without exposing sensitive implementation details. A solid security page can list reviewed components, report dates, relevant deployment versions, outstanding findings, and the status of fixes. It should also explain the controls around keys and suppliers in a way that lets users judge governance - without giving attackers a playbook.

Security work can't stop after publication. Teams should keep an inventory of systems that can affect funds, track vendor and software updates, run incident processes, and reassess risk after material changes. An audit is one input into that work, not a replacement for it.

There's also a cost trade-off. Broad reviews and continuous monitoring take time and money, and smaller teams may not implement every control right away. The practical response is to prioritize by impact: focus first on components that move funds, change contract behavior, or grant production access. Then spell out the remaining limitations and share a plan to reduce them. A transparent, imperfect control system is usually more useful than an impressive badge that nobody can explain.

Conclusion

Hacken's Q3 report is a useful reminder that an audit badge isn't the same thing as a security verdict. The reported losses show how funds can be exposed through keys, suppliers, delayed fixes, and infrastructure that a review may not cover. That doesn't mean audits are irrelevant - it means scope and ongoing operational security are part of the same conversation.

For investors, the next step is practical: read the audit report, see what it excludes, and look for evidence that the live system and its controls haven't drifted since the review. For crypto teams, publish clear boundaries and keep fixing the risks audits can't resolve on their own. Before committing funds, assess the system behind the badge - not just the badge itself. Read Hacken's report coverage at CoinDesk and use it as a prompt to ask better questions about any platform you rely on.

Frequently Asked Questions

No. An audit evaluates a defined scope at a particular time. It can identify issues in the reviewed components, but it does not guarantee that the whole platform is secure or that future changes and operational failures are covered.
Hacken attributed about $906.8 million of the $1.18 billion in reported losses to compromised suppliers or developer tools, uninstalled security fixes, or components excluded from the latest review. The figure reflects Hacken’s categorization of the incidents.
It can, if those areas are explicitly included in the engagement, but many contract audits focus on code. Check the report’s scope rather than assuming that keys, infrastructure or third-party services were reviewed.
Check the audit date and scope, whether the live deployment matches the reviewed version, how privileged keys are controlled, how suppliers are managed, and how quickly security fixes are deployed. Missing information should be treated as uncertainty.

Related articles