DSS

DSS 2026 / Day 1 / Pearl Hall

Every Safe Is Blind to Its Own Backdoor: Scanning 2M+ Multisigs for Shadows

Elliot Friedman

14:50 · 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:00Hello everyone. I am Elliot Friedman,

0:03the founder of Solidity Labs.

0:05We're an on-chain engineering team where

0:07we embed with protocol teams to build

0:10and secure smart contracts.

0:13I'm also a seal member and help with the

0:15framework around custody. And today,

0:19we're going to be talking about scanning

0:2312 million multisigs for shadow owners

0:26and modules because Gnosis Safes are the

0:30uh

0:31largest and most widely adopted uh

0:34wallet with the the largest uh AUM.

0:38And so let's dive in.

0:41We're going to start here asking a

0:42question.

0:43What's the difference between these two

0:47Gnosis Safes?

0:49So on the left we can see one has no

0:51pending transactions. On the right we

0:53can see there's some pending

0:54transactions that have been

0:56removed.

0:58Does anyone notice a difference?

1:03So if you said there is no difference,

1:05um you got the question right, but one

1:08of those Safes has a shadow module

1:11that can steal all of its funds at a

1:13moment's notice and the other was

1:15completely fine.

1:18So we have a paradox here.

1:20How can an owner both be and not be at

1:23the same time?

1:25And we have the same question for a

1:27module.

1:28If we made

1:30two calls to a Safe, we could get

1:33contradicting answers

1:35because

1:37every major interface relies on linked

1:39list enumeration

1:42and

1:44if an item is not in the linked list, it

1:46means it's not um

1:49it's not an owner or module.

1:51But as we can see here with this fun

1:53little diagram,

1:55all uh owners or modules in Safe must be

1:59in a

2:00linked list

2:01where we start off at the sentinel. The

2:03sentinel points to the first address,

2:05the first address points to the second

2:07address and so on. And then the last

2:09address will point back to the sentinel

2:12address.

2:13So it's a linked list, it goes in a

2:14circle.

2:16But as we can see here, if someone is

2:19able to write to this mapping outside of

2:22this circularly linked list,

2:24now this shadow.eth will be a

2:28owner.

2:30And it will not be returned in the get

2:33owners function and so no interfaces

2:35will be able to see it.

2:36We have the same issue with modules

2:38which are

2:39arguably more powerful than owners

2:42because they do not require quorum

2:45in order to

2:46actually have a transaction go through.

2:48And so this brings us to the core

2:50problem with shadow owners and shadow

2:52modules, which is that they are

2:55invisible almost everywhere across the

2:58ecosystem

3:00because

3:02no one bothered with the tooling to

3:04detect them.

3:05Um

3:07and there are some websites about this,

3:08but

3:09yes, basically what happens here is we

3:11have a second owner that exists on

3:14chain. It's invisible to the safe UI

3:17and

3:18there is no uh infrastructure checks for

3:23for shadows.

3:26Um

3:27but we're going to get into uh a site

3:29that we've built out that helps solve

3:31this problem.

3:33So here we have a

3:36gnosis safe that has a shadow owner.

3:38We can see here in the owners array it

3:40has the owner, the sentinel that points

3:42to the owner that points to the

3:43sentinel. So it's a nice circularly

3:45linked list. We go down to check

3:47addresses, we paste the address in here

3:50and then it says, you know, this is a

3:52shadow owner.

3:54This address is a shadow owner of this

3:56safe.

3:59And

4:02how does it get planted? And why are we

4:04investigating this today?

4:06Because this is a known issue that Safe

4:08can have these shadow owners and shadow

4:10modules.

4:12We were building a Safe-based wallet

4:15and noticed that during the setup

4:17delegate call window, an attacker could

4:19inject arbitrary

4:21uh actions because

4:23the module setup function

4:26calls does a delegate call out to the

4:28target address that's passed.

4:32And so

4:34we said, well, wait a second. If you can

4:36do an arbitrary delegate call during

4:38initialization, then an attacker could

4:41quite easily

4:43get people to set up Safes using some

4:45malicious way

4:47and then install a shadow module

4:50or a series of shadow modules

4:52in that Safe.

4:55[snorts]

4:56And right, you just don't don't write

4:57into the

4:59into the circularly linked list, but

5:00just add into the mapping. This is now

5:03an owner.

5:04And we wanted to know, is this

5:06theoretical or has this attack already

5:08been planted in the wild?

5:11Um because if it's theoretical, then

5:14hey, you know,

5:16it doesn't really matter. But we haven't

5:18really seen anyone do a large-scale scan

5:21of all

5:23all the Safes that contain most of the

5:25funds that Safes hold across multiple

5:27chains and ecosystems. And so we wanted

5:29to do that.

5:31Before we get there though, let's talk

5:32about the CPIMP uh

5:34attack pattern. CPIMP stands for

5:37clandestine proxy in the middle of

5:39proxy.

5:40And this was a hidden proxy inserted

5:43uh during proxy initialization

5:46and it made the proxy be owned by an

5:49attacker.

5:51And

5:52the same thing is kind of true with

5:55shadow owners and shadow modules because

5:57you get created by this hidden entry in

5:59the owner's mapping.

6:00And both of these attacks, they leave

6:03surface logic and getters untouched, so

6:06the smart contracts work exactly as

6:08intended.

6:09But both of these things are invisible

6:12to auditors, Etherscan, Tenderly,

6:16and basically, you know, the in

6:18infrastructure that people rely on

6:20um

6:21on a on a regular basis to ensure their

6:25their safes are are secure.

6:28And

6:28as a as a category, as a

6:31crypto really we we under

6:34underweight um

6:37under index

6:39threat models that are persistent

6:42where an attacker gains access and then

6:44doesn't use it immediately because we're

6:46so used to

6:48instant smash and grab exploits and same

6:50block chains

6:52uh in DeFi, but

6:54I think that this category is

6:57very very concerning and we should be

6:59spending more time on on finding

7:03um and hunting for threat actors that

7:05are,

7:06you know, exploiting these kind of

7:08methods.

7:10So can we even prove that a shadow

7:13exists?

7:14If we have the address of a shadow,

7:17shadow owner, shadow module,

7:19we can prove that

7:22um

7:24we can prove if it's a shadow or not. We

7:25can falsify that question. But if we are

7:28instead

7:30given um

7:34if we are instead given a

7:37arbitrary storage right inside of a safe

7:40that doesn't do anything that we think

7:42it should be doing or we don't know what

7:44it should be doing,

7:45uh it's actually impossible for us. Even

7:47if we used and we had all the computing

7:49power on Earth,

7:51we wouldn't be able to guess whether or

7:53not this

7:55safe was a shadow owner or just some

7:57arbitrary storage right.

8:00And that's because you'd have to brute

8:02force all the Ethereum addresses in

8:03existence and then check them

8:05to to if they're either a

8:07or

8:08an owner in the safe.

8:14So how do we detect how did we go about

8:16detecting shadows? So

8:19we started off by reading all the public

8:21state that we could from the safe

8:24and

8:25with that state we reconstructed the

8:27expected storage try.

8:29We fetched the current storage hash with

8:33eth get proof

8:34and then we checked to see if the

8:38current storage hash from the RBC

8:41matched the expected

8:44um that we computed ourselves.

8:46And a mismatch is going to be imply that

8:49there's storage that that we don't

8:52uh that we can't account for which means

8:54yeah we're probably dealing with a

8:56shadow.

8:57So we started off with a script that

8:59didn't have much state and we quickly

9:02realized that

9:03oh actually um

9:06we're going to need quite a bit more of

9:07a complex system for this.

9:10So we started off with

9:12um we had a lot of false positives

9:14because of approve hashes and signed

9:16messages

9:17because the safe could write these

9:20into storage and everything would

9:25check out um in terms of this being a

9:27legitimate storage right but we had no

9:29way to account for this. So we had to

9:32build indexing into our service and

9:34crawl through the logs

9:35to find all of the approve hashes and

9:38and sign messages.

9:40And then we also found another after we

9:43we fixed that um set of false positives

9:45we found another set of uh false

9:47positive which were pass keys

9:50which basically we had these account

9:52extraction wallets on base

9:54where we configured um

9:59web off um

10:01pass keys basically or the owners of the

10:04safe configure these web off pass keys

10:07and uh it just made these three

10:10deterministic storage rights to these

10:12different addresses and then there was

10:13different modules and different versions

10:15of the pass keys that would

10:17write to different addresses and so we

10:18had our different slots and so we had to

10:20go and update our um

10:24our eliminator service

10:26and reviewer service to understand this

10:29behavior so it could um

10:32clear all of these these false

10:33positives.

10:35So this is our funnel on Base. We had

10:3860,000

10:39um storage root mismatches flagged once

10:43we had the logic to you know get rid of

10:47the approve hash

10:49and pass keys

10:51um

10:53that that ended up eliminating uh

10:55you know most of

10:57of the of the safes that we found and

10:59flagged and then we were we ended up

11:02with

11:0312 unexpected uh

11:06safes

11:08with with potential shadow

11:11uh owners or modules

11:13but these were on you know addresses

11:16that didn't have enough funds

11:18um

11:19to to warrant concern and most of them

11:23were were unused anyway.

11:25So these are our results.

11:27We ended up scanning 12.1

11:30million safes across Base, Ethereum,

11:34Optimism, and Arbitrum

11:36and

11:38you know the majority of them ended up

11:40reconciling against the expected clean

11:43root which is great

11:45great news. We don't need to have a seal

11:46war room.

11:48Yeah it we we didn't really find

11:51um evidence of a large-scale shadow

11:54owner or shadow module

11:56um

11:57you know campaign.

12:00And here we have just a UI, a couple

12:04screen grabs here. You can see the

12:06different networks.

12:08In the future we might add more.

12:10It'll show you how many safes we've gone

12:12through,

12:13what what block we've indexed to, the

12:16different versions of the safe that we

12:17covered.

12:19[snorts]

12:20Here we have an unexplained storage

12:21mismatch. We have this route that we

12:23expected. This is the actual route.

12:26And there's a little drop down

12:27explaining, you know, what this could

12:29be.

12:31Here we have uh

12:33a safe that cleared. So hey, we can see,

12:36you know, we have our linked list here.

12:38The sentinel goes to, you know, these

12:40two modules and then it closes and

12:43there's one owner.

12:44And so everything kind of

12:46matched up there.

12:48Here's another one that's clean.

12:51Um

12:52again, that's great news, you know, this

12:54is how the majority of them came back.

12:57Here we have a

12:59shadow safe where we have an owner.

13:02Goes to the, you know, sentinel to owner

13:04to sentinel

13:06uh modules. It says there's no modules,

13:08but we checked this address and it said,

13:10hey, this is a shadow.

13:14So here we can see the

13:17shadow scan URL.

13:19And you're able to

13:22um look through all of the safes of

13:25version 1.

13:2641 and 1.50

13:29uh on this site. You can get a real-time

13:31view of scan progress and flag safe.

13:35And you can also see, you know, a

13:37recomputed

13:39uh storage route locally that gets

13:40checked against RPC. So you don't need

13:43to just trust the back end. You you

13:45actually get that uh in browser.

13:48So we're going to end with uh

13:50a little bit of a tip here. If you see a

13:54safe that has been created

13:56that you're using and it has an

13:58unverified delegate call,

14:01uh if you see that, you should treat

14:03that as a potential uh full compromise

14:06[snorts] and immediately contact Seal

14:09911 and if funds are in that safe that

14:13has a potential compromise or a

14:14potential shadow owner or module, um

14:17immediately migrate those funds to a new

14:20safe.

14:23So yes, stay safe, uh stay in touch. Um

14:27yeah, this was this was a uh multi-month

14:30effort to get all of this

14:32together and so I want to just thank the

14:35other engineer on the project, Pratik,

14:36who really

14:37uh

14:38stepped in and helped out a lot. So and

14:41you can follow us more um on Twitter at

14:43Solidity Labs

14:45and you can check the site out here.

14:48Thanks so much.

Source and accuracy details

Source export SHA256: 046e44d927488eab302f4213a7d279778d4de10b48e920467653bfe1d9b877bb