DSS

DSS 2026 / Day 1 / Pearl Hall

Why Blockchain Security Has Failed: Single Points of Failure

Kirk Baird

18:15 · Recording

Watch on YouTube ↗Open recording viewerOriginal programme entry
Download plain textDownload timestamped JSON

Source: YouTube automatic caption track · Exported 2026-11-16. Timestamps link to the source video. Cue end times were not supplied.

Transcript

0:00Okay. So, why has blockchain security

0:04failed? If those of you were in Peter

0:06Tschirhart's ski's talk this morning,

0:08we can all agree blockchain security is

0:10currently failing. We're not doing

0:11enough. There are way too many hacks.

0:13There are billion dollar hacks. There

0:14are 100 million dollar hacks every week.

0:17And it's it's becoming a serious problem

0:19for our industry that we need to fix.

0:21And so the point of this talk is to

0:25explain to you why this problem is

0:28occurring and how they are fixing it.

0:30And some of the inspiration for my talks

0:33has come from what banks actually do in

0:35practice, which is a lot of risk

0:37management. I know we all kind of hate

0:39that word and it sounds gross, but it

0:40has a lot of practical effects and we

0:43can definitely learn from it.

0:44So, the problem is arising because

0:47defenders only need to break one

0:49component of your system. They get to

0:51see every single component. They can map

0:53it all out. They find the weakest point,

0:55which is often a single point of

0:56failure, and then they break that one

0:58single point and they have your

0:59protocol. So, the job is a lot harder

1:03for the defenders than it is for the

1:04attackers because we have to secure

1:06every single component, whereas

1:08attackers get it easy and bug bounty

1:09hunters, if you're a bug bounty hunter,

1:11get it easy. You just need to find one

1:13hole and you can get your way in.

1:16So, what are these holes?

1:18The most obvious hole and the biggest

1:20hole that pops up is a single point of

1:22failure. So, a single point of failure

1:24is anywhere in this whole system. Uh,

1:27I'm I'm talking abstract here. This

1:29doesn't need to be a literal piece of

1:30code. This could be one trusted signer.

1:33This could be um your smart contracts.

1:36This could be your choice of blockchain

1:38if you pick a centralized or one with

1:40weak security. It could be any part of

1:43your smart contract. It could be the

1:44oracles. Like, are you getting your

1:46price feeds? So, you don't need to think

1:48of this as like, oh, this code function

1:50is a single point of failure. You need

1:52to think abstractly. You need to work

1:54out what is your system doing and then

1:58what can one of these things do.

2:00This what I want you all doing. I want

2:02you all mapping out the whole system. I

2:03want you all there like, this connects

2:05this, connects to this. This is the

2:07entire abstract system, and once we map

2:10it through, threat model, risk analysis,

2:13work out what the problems are.

2:14And when we find a single point of

2:17failure or a high risk component,

2:19there's three things we can do. The

2:22absolute best we can do is diversify,

2:24redundancies. Think of this as like a

2:26multi-sig. You don't just have one

2:28person signing. You got three. You got

2:29multiple people signing, and you got to

2:31hit two or more of them to break the

2:34system.

2:35Then we can do bound. So bound is

2:38limiting it with something like a rate

2:40limit or something along those lines

2:42that you can slow the flow. You can you

2:44can lower the impact. Maybe rather than

2:47having all your funds in one wallet, you

2:49split it into a couple, so okay, if they

2:51break this one, they now only get $1

2:54billion rather than $6 billion.

2:57Um, and then the last one is harden,

2:58which is add everything else you can

3:00just to make it as hard as you can for

3:02them. Like cause the attacker as much

3:04pain as you can do.

3:06Okay.

3:07So we're going to run through a few

3:09different parts of the stack.

3:11This one, when I wrote this was

3:13absolutely the hot topic because

3:14everyone was talking about how AI is

3:16breaking cryptography, how AI is the

3:19most powerful thing in mathematics.

3:21Um, and one of my fondest topics that

3:23I've spent some time on is ECDSA is can

3:26we use

3:28AI to actually break the algebra

3:30underlying elliptic curves? Right now

3:32the answer is no, but if we could, this

3:35is a single point of failure. This is

3:37something that would give you access to

3:39pretty much every single wallet on

3:40Ethereum. It would also break most of

3:43the internet. It would break TLS. It

3:44would break a lot of other things.

3:46Um, but it is a single point of failure.

3:49Uh, and there's different ways to break

3:50it. And you don't actually just have to

3:52break

3:53the cryptography itself. You can do dumb

3:56things like using a very weak private

3:58key generation. And if you only make a

4:0132-bit rather than a 250 bit

4:04private key, then a hacker can brute

4:07force it. 32 bits is about 4 billion and

4:09a computer can do that in a couple of

4:11minutes.

4:13So,

4:15what you really need to do is diversify.

4:19Don't have one single protocol you're

4:22relying on. Don't rely just on the

4:24elliptic curve discrete logarithm

4:25problem. Don't rely just on ECDSA. If

4:28you can change them up and have two

4:30protocols in parallel,

4:32and notice there's an and there, not an

4:34or, you have to make sure both of them

4:36are secure.

4:37There's a few protocols out there like

4:39near that support SECP curves, they

4:42support ED Ed curves, and they support a

4:45few other hashing mechanisms, but

4:47they're put together in ors. You can

4:49have private keys on each of them, which

4:51actually increases the single points of

4:53failures because if you break Ed, it

4:56happens to have a flaw in it, that's one

4:58path in. If you break SECP, that's a

5:00different path in. And either of these

5:02paths can actually

5:04act as a full break. So, we need the

5:06and, not the or.

5:09But I do understand that no one actually

5:12is implementing this right now, although

5:14I want them all to, but if you're doing

5:16these on chain, it's pretty gas

5:17expensive. Cryptography is one of the

5:19more gas expensive parts. And so, if you

5:22can't diversify, if you really can't,

5:25and I mean you like you think about it

5:26and you cannot, then the option is to

5:29harden, which is do as much as you can

5:31to make sure you're securing the single

5:33point of failure. Put everything you can

5:34in there.

5:36Okay, consensus clients.

5:39Consensus clients is one that I think

5:41Ethereum actually kind of does well.

5:43I've put this as as a pro to see what

5:46can happen when we're doing things

5:47right.

5:49If you have under 1/3 of validators, if

5:52one of the consensus clients is buggy,

5:55it has bad

5:57fork choice rules, it doesn't do balance

5:59checks on user transactions, or whatever

6:01it happens, the other 2/3 plus of the

6:04network will reject it.

6:06They're going to say, no, you're wrong,

6:08ignore it.

6:09Uh if you have one of your consensus

6:11client that gets into that one-third to

6:13two-thirds,

6:15the network still continues on, uh but

6:18what happens is you just lose finality.

6:20And then really bad case is is what

6:23happens if one client is over two-thirds

6:26of the network, then if we have a bug uh

6:28and that bug is exploited on chain by

6:30some malicious users, we end up

6:32finalizing and we're in a world that

6:34hurt all the exchanges around the world

6:35are like finalized. Yeah, that's good

6:37block. We'll start paying out the money.

6:39And then it it's very hard to unroll it

6:42when you get to that point. We we can't

6:43just do the DAO hack where we just go uh

6:45send the money back to us. We want it

6:47all. No.

6:49And this this did happen. Someone was

6:51attacking Nethermind, which only had 8%

6:54of the network at the time. And okay,

6:56the Nethermind nodes went down and that

6:58was a bit annoying for some people, but

7:00the rest of the Ethereum consensus

7:02managed con uh the Ethereum execution

7:04and consensus managed to keep ticking

7:06on. We still have finality and the

7:07network was safe.

7:09Now, look look I I I am

7:13kind of drumming up how good this is

7:15because if those of you who do know the

7:17stats uh know that Geth had at the

7:20similar time almost 80% of the network.

7:23So if we did have a bug in the Geth

7:25execution client, this would cause fine

7:28um finality bugs and this would have

7:30been bad for everyone.

7:33But yeah, that this is this is what the

7:34defense is. We we just need to tidy it

7:36up a little bit more. Make sure that

7:37each of the declines gets down below

7:39that one-third threshold and then we

7:41have this perfect situation where none

7:43of the clients are acting as a single

7:45point of failure.

7:46Um that being said, they they all rely

7:49on the same hash functions. They all

7:50rely on the same elliptic curve

7:52algorithms. So there's plenty of other

7:53single points of failures in there if

7:55you want to get into them, but the core

7:57node and the software itself uh is not.

8:00It it it'd be a spec problem at this

8:02stage rather than an implementation

8:03problem.

8:06Cool. It also allows us to do other fun

8:09things as well. So, there's benefits of

8:10having multiple clients and multiple

8:12protocols, and that's things like

8:14differential fuzzings. So, you get other

8:16security benefits that are auxiliary.

8:19Um and you can also do adversarial spec

8:21tests

8:22where um

8:25if every every past bug from any of

8:28these clients can be fed into all of the

8:30clients, and that way you you get their

8:33compounding security benefits.

8:36Okay, next up.

8:38This is a pretty interesting one. So, on

8:42uh Ethereum or Solidity specifically,

8:45any of the EVM chains, we will see that

8:47there is essentially two compilers. Um

8:51but as a smart

8:53uh smart contract protocol, if you're

8:55writing a Viper, you only get a choice

8:56of one compile. This becomes a very

8:59interesting single point of failure

9:01because if there are any bugs in your

9:02compiler, then there's absolutely

9:04nothing you can do uh and your protocol

9:07is going to be vulnerable to those bugs.

9:10Now, uh

9:12this did happen, and this caused a $70

9:15million hack. It happened because of the

9:18non-reentrant check was being optimized

9:22out by the Viper compiler, and so that

9:24meant anyone who is relying on this

9:27non-reentrant check is therefore

9:28vulnerable to the bug. Uh there were a

9:30bunch of other protocols, not just

9:32Curve, who are vulnerable to it, but

9:33Curve is by far and away the biggest uh

9:36protocol using Viper as a language, and

9:38that's why Curve got hacked by this.

9:41Um so, how do we fix it?

9:43Again, uh this is a tough one because

9:46people don't normally have multiple

9:48compilers. So, it makes a diversifier

9:50problem a lot challenging uh because

9:53Viper doesn't necessarily run through

9:55the Solidity compiler. It's got its own

9:56compiler. So, this is where we need to

9:58get into the harden and the bounds as

10:00much as we can. So, pin and track your

10:03compiler versions. Make sure you have

10:05pinned uh your version control. Uh then

10:08testing the actual deployed bytecode is

10:11way to check up on your compilers. So if

10:13what they had done is compiled the

10:15code uh put it into testnet and then run

10:18their tests on the testnet they would

10:19have found this bug. Um

10:21but they didn't because everyone just

10:23assumed that the compiler was valid and

10:25they hadn't done uh thorough enough risk

10:27management.

10:29Uh

10:30yeah bound. Don't put everything under

10:32one version. Uh some potential ways to

10:35get around this diversified problem

10:37would be to have multiple versions of

10:39your code uh run it under multiple

10:41different versions of the compiler and

10:43see if the behavior is different across

10:45these.

10:46And so it's it's not quite as powerful

10:48as diversify but it is testing different

10:50things.

10:53Okay admins admin keys and upgrading oh

10:57a little bit of a touchy topic at the

10:58moment I think.

11:00I don't know if you guys been following

11:01the news. No you'll you'll have So we

11:03know where this is leading but

11:06what happens uh

11:07as an upgrade key? So smart contracts we

11:12often claim that these are decentralized

11:15they're neutral but if all of these come

11:18under one proxy key

11:20uh that is if you have any proxy in your

11:24smart contract and there is a key that

11:25can update the proxy that is a single

11:27point of failure. They can take complete

11:29control over the smart contract all of

11:31the funds in it and everything.

11:33And it is one of the biggest single

11:35points of failure that happens in pretty

11:37much all of the protocols that we review

11:39because everyone wants to have this

11:42upgradeability function.

11:43Uh Ethereum deliberately didn't add

11:47upgradeability because they wanted it to

11:49be immutable. They wanted the code out

11:51there to not be able to change. Uh but

11:53that's not really that practical for a

11:56long-term commercial engagement where

11:58you build your product over the time you

12:00want to add more features.

12:02And so how do we actually deal with

12:04these admin keys?

12:07Well we could uh

12:11just just be hacked.

12:14That's one way to do it. But no, it is

12:16it's a single point of failure.

12:18And you guys may not know this one, but

12:21they

12:26Yeah. Now they they didn't when they

12:28upgraded, they didn't upgrade properly

12:31securing the initialization function. So

12:32someone hit the initialization function

12:34with a new trusted route which was their

12:37own and therefore they had control over

12:39the entire protocol.

12:40Single point of failure.

12:43This one again is a bound. If you want

12:46to have the capability to upgrade, it's

12:48it's really doesn't make sense to have

12:50diversifiers redundant. So

12:54these are all things that we recommend

12:55in every review and I think every

12:57security engineer in the in this room is

12:59going to nod along and they're not going

13:00to be surprised, but things like

13:02timeouts,

13:03staged rollouts. Make sure when you do

13:06the upgrade process as well that you are

13:08actually doing like a mainnet fork and

13:10you are testing the code on the forked

13:12code.

13:13It's amazing how many people will come

13:14to us with migration scripts and we're

13:16like

13:17yeah, but but do you have actual tests

13:19to run this on the mainnet fork or are

13:21you just kind of hoping it works after

13:22you've written it? And they're like oh

13:24no no no it'll work. And then of course

13:27it it doesn't work.

13:30But that's what we can do.

13:31So keys, signing, and bridges.

13:35So a five of nine threshold is great.

13:38This is exactly what I've been talking

13:39about. Diversify. Don't have a single

13:41point of failure. Hey, if if you want to

13:43get the keys to our bridge, you need to

13:45have five keys out of nine.

13:48And you have to have many signers.

13:51But the threshold only actually exists

13:54if every key is separate, is a separate

13:58single point.

13:59It does not count if you put five of the

14:02nine keys on a single device that is

14:05held by one company because then it

14:07becomes a single point of failure again.

14:09And so this is what I really want to get

14:11across to you that you have to think

14:13abstractly. You can't just look at the

14:14protocol code and be great, this is a

14:16multi-sig. It's got five of nine. You

14:18actually have to analyze the

14:19architecture, see what they're doing,

14:21not just in the code, but the broader

14:23system, run some risk analysis and be

14:25like, hey,

14:26no, you've you've actually got five of

14:28your keys on the same device. You've

14:29made a single point of failure again.

14:30That's not great.

14:33Bybit is also another very interesting

14:35example of this. They had a single point

14:38of failure that is a little bit

14:40different, too. They had a multi-sig.

14:41They were doing everything right. They

14:43were like, okay, we have this multi-sig.

14:45We all have to sit down. We have to

14:47review the code and we have to make sure

14:48it's good before we transfer anything

14:50from our cold wallet. But what they

14:52didn't consider as a single point of

14:53failure was the front end of the safe

14:56software itself. So it showed all of

14:59their signers when all of them sat

15:00there, they all looked at the same

15:02front-end UI and it said, this is a

15:04valid transaction doing exactly what you

15:06want it to do. But what the front end

15:08was doing is switching the back-end

15:10transaction so it was different to the

15:12one that was being displayed. All of the

15:14signers didn't check their device that

15:16that matches the front end. And so when

15:18they hit sign, the 1.6 1.4 billion

15:21dollars went went over to the hackers.

15:25And even more recently, what happened

15:27again? So diving a little bit into this

15:30Binance one, it was a single point of

15:32failure. They didn't have just a single

15:34private key sitting on machine. No, they

15:37had some MCP set up in the background

15:40where they had a bunch of different

15:41servers.

15:42And what the single point of failure

15:45here was that it was one path to approve

15:49this MCP to sign everything.

15:51So one of the DevOps had their laptops

15:54breached and then they went in

15:57the attacker is using that proposed a

15:59malicious transaction to the MCP and the

16:02MCP went, great,

16:03this is good. This is a genuine real

16:05transaction.

16:07And so that interface there was the

16:09single point of failure because it is

16:11one point that allows the attacker to do

16:13whatever they want. And unfortunately,

16:15the pains of EIP 7702 mean that you can

16:18exploit bugs like this extremely

16:20quickly.

16:22Uh so one transaction allowed them to

16:24drain the entire contract.

16:26So what do we do? In in some of these

16:29cases they'd they'd already diversified.

16:30They did have independent signers, but

16:32have independent stacks, have

16:34independent ways of reviewing this code.

16:36Uh add second paths as well. Uh what you

16:39need to do is add limits, delays,

16:42monitorings. So once the transaction is

16:45proposed, have someone else come in

16:46there and prove it as well. And harden

16:49your wallets, harden your

16:50infrastructure.

16:51Everything on those lines.

16:53Okay. Lastly, we are running out of time

16:55here. So I'm going to breeze through

16:57this one.

16:58But oracles are absolutely another

17:00single point of failure. Even if you are

17:03using an oracle like Chainlink, that

17:05doesn't mean which has a distributed set

17:07of nodes, that doesn't mean that it is

17:09not a single point of failure. If

17:11someone can adjust the config, an admin

17:13can come in and switch out your oracle

17:15to something malicious.

17:17These things have happened. Uh oracles

17:19been manipulated, configs have been

17:21changed, hacks have occurred. Um

17:24oracles all need to use a median, not a

17:26mean. And infrastructure needs to make

17:28sure that we have multiple front ends so

17:31we don't end up like Bybit. And bound

17:34and harden them too.

17:36So what I want to leave you with uh is

17:39what is a single point of failure? Do

17:42not get too caught up in the specifics

17:44of the code. Keep it abstract, think at

17:46a high level, brainstorm, understand

17:48your system. And when you understand the

17:49system, you can tell where the risks

17:52are. And then you can build a threat

17:54model and then you can understand how to

17:56solve these problems.

18:00Beautiful.

18:02And considering the state of our

18:04industry, look, just make yourself as

18:06hard to hack as possible and they're

18:07going to go somewhere else because

18:09they're easier targets.

Source and accuracy details

Source export SHA256: 6a4f3cfa609c79a9277f0aa137f170b9f2e3b1ab94d1011b71ec0fedbb87ea79