DSS

DSS 2026 / Day 1 / Amber Hall

Ill Bloom

Joaquin Pereyra

32:20 · 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:00security there. Um,

0:01hello.

0:03While I'll wait for the slides. Okay,

0:06quick. I was going to introduce myself,

0:08but I have slides for that. I'm Joaquin

0:09Pereira. I've been a researcher for more

0:11than 10 years and I work at Coinispect,

0:14which is a security firm that's been

0:16providing services

0:18in the blockchain space since 2014. So

0:21that's basically forever in blockchain

0:24times.

0:25Um,

0:27this talk

0:28we are

0:31we're going to talk about Earbloom.

0:33Does someone know what Earbloom was?

0:36Yes, you, because you read my yeah.

0:39That's that's actually surprising, but

0:44it speaks about the state of security

0:46today.

0:49The talk will have two objectives. One,

0:51it's going to be a very technical

0:53talk. I'm going to try to present

0:55a lot of details about what a

0:57pseudo-random number generator flow

0:59looks like in the real world.

1:01And

1:02it's also going to be a story about how

1:04to deal with an incident of that

1:06of that style. It's not a common

1:09incident response kind of

1:11kind of thing because it's very

1:13distributed. So I want you to imagine

1:15you're

1:16contacted to respond to an incident.

1:20You it's a normal project for you. I

1:22guess most people here work in security,

1:24so you've done something like that.

1:26And you realize the flow that you're

1:28looking at

1:29does not affect the single protocol that

1:31contacted you.

1:33It affects

1:34you don't know how many accounts, you

1:36don't know how many blockchains, you are

1:38not sure how many millions of dollars

1:40could be at stake here.

1:43Also, you see evidence that it's being

1:45exploited. It's

1:46continuously being exploited while

1:48you're researching

1:50after the the first incident was

1:51reported.

1:53And

1:54there's no easy way to actually know

1:56who's affected and who isn't

1:58because the

1:59the vulnerability in a library.

2:02It's actually,

2:04as we'll come to find out, it's in a

2:05library of libraries. So it's deep,

2:08deep, deeply nested in many, many, many

2:11applications.

2:13So that's basically the talk and we're

2:15going to try to

2:17um

2:19discuss how how we dealt with it so

2:21hopefully you can learn about it.

2:23And if you're you're faced with a

2:25similar problem ever in an incident

2:27response, you learn from our ideas and

2:31our mistakes and what we tried and what

2:33we

2:34uh did.

2:35So

2:37El Bloom, for those that don't know, was

2:40a problem in a pseudo random number

2:42generator in crypto JS, which is

2:46probably a library you are not aware.

2:48You don't know,

2:49but it's been uh live since 2014

2:53and it was really, really heavily used

2:56like from 2022 14

2:59maybe till 2020 2021.

3:03And uh it was really, really used before

3:07native

3:08um crypto was available in JavaScript

3:11because remember there was a time when

3:12the crypto module wasn't as available as

3:15it is now.

3:17And uh

3:18the peak exposure was $12 million.

3:21At least

3:23almost $6 million were stolen, which

3:26unfortunately in our industry that

3:28sounds like

3:30not a lot.

3:32Um

3:33but that's

3:35that speaks about other things in the

3:36industry.

3:37Um we ended up fearing that almost at

3:40least almost 3,000 accounts were

3:42vulnerable

3:44and uh

3:45we analyzed 14 chains for signs of

3:47exploitations and we found at least

3:51five chains that were affected. So as I

3:53said, this is all

3:55we figured all this out afterwards. At

3:57the beginning we didn't know if it was

3:58$5 million,

4:00$100k,

4:02$1 billion,

4:03you have

4:04no way to know.

4:06And um just so we understand the

4:08vulnerability and we

4:11can understand what we did to figure out

4:13who was affected, let's do a quick intro

4:16into BIP 39. Who is familiar with BIP

4:1939?

4:21Wow, almost. Okay, so the quick intro is

4:23worth it.

4:25BIP 39 is a way that um

4:28basically

4:30you can have the same seed

4:33to

4:34control all your accounts in uh in

4:37blockchains, right? It's a way that you

4:38have when you initiate your wallet, it

4:41tells you, hey, write down these 12 or

4:4314

4:4424 words

4:46and you can have accounts in Ethereum

4:48and blockchain and and Bitcoin and third

4:51chain and whatever you want and have

4:53multiple addresses with the same kind of

4:5612 or 24 words or 18 words, but no one

4:59ever used 18 words for some reason.

5:02The way that works is uh first your

5:04wallet will gather some entropy from

5:06somewhere that uh it will gather

5:09a random number.

5:11I will do the examples with 128 bits

5:13because it's easier, but there are

5:15several lengths available.

5:18And uh once your wallet has that

5:20entropy, it will use that random number

5:23to index into some words. So basically,

5:26let's do the worst version possible.

5:28Let's say the random number is 67

5:32and uh the the dictionary is food and

5:34potato.

5:36So your

5:37index number six is food, index number

5:39seven is potato, your words will be food

5:42potato.

5:43Something that not many people know

5:46and it's a weird quirk of BIP 39

5:50is that it supports many languages.

5:53Uh you can have your words in English

5:56or Chinese or Spanish or French and

6:00probably more. I don't know how many

6:02languages exactly are supported.

6:05And the weird part,

6:07if you see the whole process,

6:10is that

6:12the language you have

6:14will determine the master seed.

6:17So the same entropy, if you have the

6:20same random number

6:21but a different language,

6:24the words will be different and the

6:26words it's

6:29what the input for

6:31PBKDF2 is.

6:34So PBKDF2

6:36will have a different output if you have

6:37different languages,

6:39which is kind of surprising. Languages

6:41seems like a UX thing, not a

6:45master generating thing,

6:48detail kind of thing. But that's how it

6:50works.

6:51I will try not to say PBKDF2 never and

6:54again in my life if I can avoid it. It's

6:56a mouthful, so I will just say hash.

6:58It's not a hash really, but

7:00similar enough.

7:02And well, from there you have your

7:04master key and there's some process to

7:07derive infinite accounts from that

7:09master key.

7:10And the important part here is that the

7:12hash function is designed to be

7:14extremely slow and that's a feature.

7:16That's to avoid

7:18brute forcing even if you have a bad

7:20random number generator and that will

7:22also be very relevant.

7:24So that's B 39. Let's get situated in

7:28time here and there's something very

7:30interesting with the timeline.

7:32It's a very reduced timeline.

7:35The crypto JS

7:37issue was introduced in 2014, so very

7:39old.

7:40And it was

7:42fixed in 2020.

7:45And I realized

7:46just an hour ago when I was reviewing

7:48the slides that I kind of lied to you

7:52because the title of this talk is

7:54discovering Illum, but it was fixed in

7:572020, so we really didn't discover it.

7:59We rediscovered it. Or we were the first

8:02good guys to rediscover it after the

8:05hackers started draining funds.

8:07The

8:09weird part here

8:11is that the first people to realize the

8:13the flaw

8:15didn't realize the potential of the flaw

8:18or didn't realize how easy it was to

8:21actually

8:24crack the seeds

8:26from the seed or from the bad seed or

8:28random number generator. So

8:30the maintainers of the library kind of

8:32knew

8:33that their pseudo random number

8:35generator was bad.

8:37They just thought it wasn't

8:39as bad

8:40as it turned out to be.

8:42And that's

8:43a very interesting point. Sometimes you

8:46see this kind of phenomenon

8:48where people know there's a

8:49vulnerability and they will basically

8:53trust that it's not as bad as it looks.

8:56It ends up ends up being extremely bad.

8:59And uh on May 2026 we were made aware of

9:02a hack that was happening. We were

9:04contacted to find the root cause. We

9:07found it

9:08and uh

9:10all through the following months

9:12until we were able to

9:14basically warn as many people as as we

9:16could

9:17uh that hacker kept draining funds

9:19unfortunately.

9:20And uh the CVE was published in August

9:232026. CVE publishing was

9:26quite challenging but very important

9:28because once you get the CVE

9:30and many applications get automatically

9:33warn that there's something wrong with

9:35their dependencies. So that was

9:37important for us.

9:39Why did people kept using a library that

9:41was

9:43known to be vulnerable? I mean there was

9:44a fix available and everything. This was

9:47a time uh where mobile wallets were

9:50being really popular and there were lots

9:52of mobile wallets.

9:53The market wasn't as concentrated as it

9:56is now.

9:57And it's very interesting because you

10:00can go and see the GitHub issues.

10:02You can go and read the discussions.

10:05And the discussions are basically hey I

10:07updated

10:08and it it stopped working. My app is not

10:10working anymore.

10:11And the fix that was popular was hey,

10:14just downgrade and it will work again.

10:16Uh so many applications

10:18just downgraded and uh were like okay,

10:21works again. I can build my app.

10:23Uh so everything's fine.

10:27Um the maintainer even

10:29kind of supported like uh

10:32kept the zero random generator

10:35in a new major version

10:37saying hey, yeah, well, I can't update

10:39the zero random number generator because

10:41it breaks people up.

10:43So here's a new version with other fixes

10:46and that still works with React Native.

10:49Uh so again,

10:51kind of interesting to see how

10:55if you don't put security first or if

10:56you don't

10:58try to prioritize security,

11:00the fixes can be available, the

11:01vulnerability can be known,

11:03everything can be basically spelled out

11:05for you.

11:06You will make mistakes still.

11:09So this this part was very surprising to

11:11find.

11:12And

11:13also another surprising part of the

11:14timeline,

11:192020 was the year the fix was posted.

11:222026 was the year

11:24the first identified drain happened.

11:27And um

11:29that's a long time.

11:31And that's actually actually a long time

11:33even after

11:34AI uh wasn't the scene. So it took

11:38quite long for someone to to actually

11:40start hacking

11:41with the problem.

11:43Now

11:44let's go

11:46to the problem at hand.

11:48In the first beta version of this talk,

11:50I was going to go by by line by line and

11:52read the code.

11:54Then I remembered that when a speaker

11:55does that, I usually sleep. I don't like

11:59it. I think it's very boring, very

12:00confusing. There's always someone that

12:02cannot read the lines because they're

12:04too far away.

12:05So what I encourage you to do,

12:08go to the GitHub and go with your agent

12:11through the code base. And in this talk,

12:14instead of doing that, let's go through

12:16a simplified conceptual

12:18um version of the flow instead of going

12:20line by line

12:22like nerds.

12:23Okay.

12:24So the problem is

12:26you want some randomness, as we said, to

12:28generate a seed, right? You're a wallet,

12:30you need to generate a seed, and your

12:31user comes to you, hey, I want to use

12:34blockchain.

12:35Uh okay, here are your 12 words. What

12:37you had to do was generate some

12:41random number.

12:42And this library promised you to give

12:44you a random number.

12:46What the library did was

12:48take some input

12:51and um

12:53take the input was simply the amount of

12:55randomness you wanted.

12:57I don't know if you know, but randomness

12:59is measured in

13:01bits. So we say one bit of randomness,

13:0418 bits, whatever.

13:06To be cryptographically safe, you need

13:07128 at the very least, at the very

13:10least. That's why during the 2010s

13:13um 12 words were very popular. Nowadays

13:16we use 24 words. 24 words are 256 bits.

13:2012 words was uh 128. Well, basically you

13:24told the library, hey, I want 28 uh 20

13:27128 bits of

13:29randomness, give them to me.

13:32And the library did some

13:35weird

13:36math.

13:37But basically, if you

13:39reduce it,

13:41you'll see that the library ended up

13:43doing one call to math.random,

13:45which is 32 bits of randomness,

13:48and then a coin flip basically

13:50every

13:52four-byte chunk. So for 128 bits, that's

13:56four bytes, four chunks. Yeah?

13:59So we end up and the last for reasons

14:02that are

14:03not really relevant,

14:05the last uh the last chunk had would

14:06only one one coin flip, not two.

14:09So we end up with only two to the 39

14:13space.

14:14We wanted a space of two to a 128. We

14:17end up with two to the

14:2039. That's way smaller, way way smaller.

14:24Do the math.

14:26It's it's actually worse than that

14:27because for some reason there's a

14:29multiplication in the in the code that

14:31multiplies the high bits and the low

14:34bits of a number.

14:36If you do that, you'll get collisions

14:38because imagine you have the number

14:40bytes

14:41two and four

14:42that has the same output that if you

14:44multiply the high and low bits of four

14:46and two, which is kind of obvious when I

14:49say it like that, but it was missed for

14:51some reason. So after some math, you can

14:54see this leaves you with 37 bits of

14:57randomness. 37 bits of randomness is

15:00awful.

15:01By the way, I I do want to mention

15:03something about the codebase.

15:06I already have the slide, so why not?

15:09If you go through this, you will see

15:11math.random

15:13and if someone

15:16read the slide and saw that

15:18maybe they thought, oh, this talk is

15:20going to be math.random is bad.

15:22Don't use math.random. Talk is over.

15:25Great. Congrats.

15:26Well,

15:27the interesting part here is that

15:30math.random wasn't the bad the the the

15:32bad part.

15:33I I think it would have been even best

15:36to use

15:38just use math.random instead of doing

15:40all that they do because they introduced

15:42like collisions and they introduced

15:46one call to math.random no matter how

15:49many bytes you wanted. So in the end it

15:53was even worse

15:55than just calling math.random. So yeah,

15:57math.random is bad. Don't use it for

15:59cryptography, but it can be even worse.

16:02That's the good news. You're not the

16:04worst if you use math.random.

16:08So yeah, that's basically how you end up

16:10with only

16:1237 bits of randomness when you wanted

16:15128.

16:17For 256 bits, the math is the same. You

16:21end up with 49 bits of randomness.

16:24Um,

16:2547 if you end up

16:27taking into account the collisions.

16:30So,

16:33remember we were doing an incident

16:35response during this time. We found

16:37this. Uh, we wanted to confirm if this

16:39was actually what was causing the hacks.

16:43People were being drained while we

16:44researched this topic.

16:46And if you ever participated in an

16:48incident response,

16:49you know it's quite stressful. You're

16:52trying to tell it like logically, and

16:54yeah, we found this, and then we found

16:55that, and then we did that.

16:57But the reality is much more chaotic.

17:00So, we found this,

17:03and we wanted to make sure um

17:05that um

17:07that this was actually the issue that

17:08was

17:10um being leveraged by the attacker. And

17:12as I said,

17:14um

17:15sorry, yeah.

17:17And we

17:20kind of got lucky here

17:22because we were able to confirm the the

17:25issue because a user, a victim

17:27actually shared their seed with us.

17:30What's what was so important about this?

17:33If you remember the BIP 39 slides,

17:36the expensive part of the process

17:39is the

17:40PBKDF2 part. I said it again. Damn. Um,

17:47if you can skip that part,

17:50iterating over 2 to the 37 space is

17:54quite cheap. You can do it quite easily.

17:58So, once a user and

18:00again, if you remember the slides of BIP

18:0339,

18:05the hashing comes

18:07after the seed. So, if you have a seed

18:09like a raw seed, like the words, you can

18:12iterate over that without doing the

18:14hashing, the expensive hashing part, and

18:16you can do it much more quicker.

18:19So, once the user shared their seed with

18:21us,

18:23um the user was had already been

18:25drained, so they had nothing to lose.

18:28We found it matched

18:29our

18:31reproduction of the weak seed of random

18:32number generator,

18:34and we were quite happy because we found

18:36the the actual root cause. We were

18:37convinced at that point.

18:40So what to do now?

18:43Well, you have to find who is affected,

18:45and not all the users will share their

18:47seed, obviously.

18:49Uh you have to find

18:51what wallets were producing the

18:53vulnerable seeds,

18:55and you need to figure out if you can

18:57save the funds.

19:00How to find who is affected? Well,

19:02basically we downloaded the whole

19:04active blockchain address space of every

19:08blockchain we could think of that was

19:11more or less relevant.

19:13And

19:14uh you can see there are some stats, but

19:16all your usual suspects are on there.

19:18And the first idea is basically, well,

19:21we iterate.

19:22We go I equals 0 1 2

19:26and we generate every possible

19:28candidate, and we try to see if that's

19:32on the set of active blockchain spaces,

19:34and if it is, well, we have a victim, a

19:36potential victim, but they may not have

19:38been drained yet.

19:40There's an issue with that, which is uh

19:43it's too slow.

19:44Um

19:46a search space of 37 bits or

19:49even worse for to 256 bits of of

19:54um

19:55B 39 size.

19:57It's bad for cryptography, but it's

19:59still

20:00quite big for

20:02for

20:05easy and response times. We didn't want

20:07to take

20:08three years on brute forcing

20:12uh all the possible seeds.

20:14Our interest was being as quick as

20:15possible so we could be faster than the

20:18attacker.

20:19And I'll share some slides on how we

20:21were faster than the attacker, which I

20:23think it's very interesting at the end.

20:25But

20:26the important part for now is that uh

20:29we thought of an optimization to this

20:32process.

20:33And the optimization is

20:35quite obvious, which is use GPUs. The

20:37important part is how do we did that.

20:41GPUs are very good at computing PBKDF2

20:44again.

20:46And

20:47the problem was was how do we actually

20:50match against the active

20:54the active addresses on a blockchain,

20:55right? There are two alternatives.

20:58Either we compute everything on the GPU,

21:00we store it somewhere,

21:02and then we kind of see what the

21:06middle of the two circles is.

21:08And that's uh

21:11that's the the the space is too big.

21:13It's at least almost 20 terabytes.

21:17It was too big to do that.

21:20So we we what we ended up using was uh

21:23Bloom filters.

21:25Do you know who knows what Bloom filters

21:26are?

21:27Very few people. They are cool data

21:29structures, so you should know more many

21:31more people should know about Bloom

21:32filters. Um Bloom filters are basically

21:35a set.

21:36And

21:37the important part of this uh data

21:39structure

21:40is that it's able to tell you

21:43it's a Boolean data structure, let's

21:44say.

21:45It can tell you two things.

21:48You ask, hey, is this item on the set?

21:50And it tells you, no, it's not on the

21:52set.

21:53Or it can tell you, meh, it's probably

21:57on the set. Uh so you're not sure.

22:00But you get a probably. And probably is

22:03good enough for optimizations.

22:06So

22:07what do you gain because you lost like

22:10the certainty that the item is in the

22:11set

22:12compared to an actual set data

22:13structure?

22:14What do you gain? You gain uh that is a

22:16very compressed data structure. It uses

22:19much much less space. So by using a

22:21Bloom filter, we were able to put the

22:24whole

22:25the whole um

22:28number of active blockchain addresses on

22:31the GPU directly.

22:33And the final

22:36the final pipeline looked like this. For

22:38every blockchain we were interested in,

22:40we downloaded the set of active

22:42addresses, which

22:44by the way,

22:45defining active is an whole another

22:48ordeal, especially in chains like

22:50Bitcoin, but that's

22:53I could I could talk for that like for

22:54another hour, so let's not do that.

22:57Let's just say active.

22:59Um we Bloom filtered it. We put

23:02everything on the GPU

23:04only if the Bloom filter tells us that

23:06it's likely on the set of active

23:09blockchain

23:10addresses, then we leave the GPU

23:13and confirm on the actual set. So that

23:16allowed us to be quite quick

23:19and allowed us to find

23:21many many many many many vulnerable

23:23addresses

23:25quite quickly.

23:27So that was the key optimization.

23:30And it's also fun because of the name.

23:32The name includes Bloom

23:34uh and I'll share more about the name

23:35later.

23:37So once you get who is affected, you

23:40need to understand which wallets were

23:42the ones producing the vulnerable seeds.

23:46Very hard.

23:47Very hard.

23:48We tried three things.

23:50Again, I'm telling this like it's

23:53chronologically. It wasn't

23:57chronologically.

23:58While we were attempting the the Bloom

24:00filter thing and researching that,

24:02other people were trying to find the

24:04vulnerable wallets and so on and so

24:05forth. So so keep that in mind.

24:08The first

24:11strategy maybe was we knew React Native

24:14was relevant.

24:16Uh React Native is very useful mobile

24:17applications.

24:18So let's try to reverse engineer APKs.

24:23Absolutely a waste of time. It's very

24:27hard not to reverse the IP case, but to

24:30find

24:31all the historical post all the history

24:35of APKs of every wallet forever

24:38was such a challenge.

24:40Uh then you have to decompile them like

24:43try to understand the code base

24:45too hard.

24:47Again, this is all with AI and and all

24:49the whistles and everything. Uh it's

24:51just

24:52uh it didn't produce any results and it

24:54took us a long time. So we quickly

24:56discarded that.

24:58In case it's not clear,

25:00we did have to find every historical

25:02release of every like

25:05suspicious wallet

25:07ever

25:08because once you produce a vulnerable

25:09seed, it doesn't matter if you produce

25:11it in 2015

25:14or yesterday. The seed is still

25:16vulnerable. So if you were vulnerable

25:18for like a week and then you fixed it,

25:21you still like had to warn your users.

25:24So that was why um historical research

25:27was very important.

25:28Then uh something that's maybe the most

25:31obvious idea,

25:33many wallets are open source. Go to

25:34GitHub, try to find if they're

25:35vulnerable. Again, quite hard, quite

25:38harder than it sounds. Even though this

25:40produced a couple of results, uh you

25:42again have to find all the historical

25:43data.

25:45And of course, only depending on the

25:46vulnerable library doesn't mean you

25:48actually used the vulnerable like code

25:51path, right? So it was hard to analyze.

25:54And maybe the most surprising strategy

25:57worked the best

25:59um which was

26:01well, we have the accounts that were

26:03vulnerable. Let's try to find what those

26:05accounts have in common, like what

26:07tokens do they trade, what country they

26:10are in,

26:11whatever, what NFTs do they have.

26:14And then you could figure out the

26:15community

26:17and by proxy many times you can find out

26:20like popular wallets among that

26:22community. And that actually worked the

26:24best, which

26:26wasn't my initial suspicion. I I didn't

26:28think that would work, but ended up

26:30working.

26:31Um,

26:33I already said this, but uh you cannot

26:35patch the seed. So,

26:38again, if you I hope that's clear. If

26:40you ever produce If a wallet ever

26:42produced

26:43um a vulnerable seed,

26:46the seed is going to be crackable.

26:48It It doesn't matter if the wallet fixed

26:50the vulnerability afterwards

26:52until the user creates a new seed on a

26:56safe like pseudo random number

26:58generator, that seed is going to live on

27:01the searchable space

27:03and basically be doomed forever. So,

27:06there's something also very interesting

27:07here.

27:09This was a problem since 2014, right?

27:122014 were different times for

27:15information security, for blockchain,

27:17for everything.

27:18Many people were were

27:20migrated after 2014. So, say you created

27:23your first seed on 2015 and then you

27:25migrated to

27:27top tier wallet in 2018 because you

27:30learned more about security and you

27:32said, no, I don't trust this wallet. I

27:34trust this other one. You bought maybe a

27:36hardware wallet, but you kept your seed.

27:40Um, you're doomed anyway. It doesn't

27:42matter. Your seed is already like

27:45vulnerable.

27:46So, it was a hard problem for for for

27:49wallets.

27:50Meanwhile, while we are doing all this

27:52research, the attacker is still

27:56draining accounts.

27:57The attacker first drained as I said

28:00$3 million.

28:01While we were we were doing the

28:02research, a second wave hit.

28:04That's almost $2 million. Well, more

28:06more $2.5 million. And there was a small

28:09very small drain, 40k

28:12at the end of July.

28:14So, this this whole research is being

28:16done

28:17kind of on a race with the attacker. We

28:19were

28:20trying to figure out what was happening

28:23and contacting wallets and contacting

28:25everyone

28:26as the attacker

28:28was exploiting stuff.

28:31I will need to be quick because I only

28:32have two left. So, let's go.

28:35One important user had $2 million

28:37on their account. And the important part

28:39here is that

28:41this was the first time we actually

28:42considered rescuing the funds ourselves.

28:46Um, $2 million is not pocket money.

28:49And we wanted to be able to save the

28:52user's money if possible.

28:54Unfortunately unfortunately

28:57it was impossible. Basically, we

28:59consulted So, this is this is something

29:01important also to know if you ever are

29:03faced with a decision like this.

29:05We consulted several firms, like legal

29:07firms,

29:08and none of them

29:10had a clear path to move forward.

29:13Like none. Absolutely none of them.

29:17And we also contacted Seal 911 at the

29:19beginning of this investigation.

29:21And kind of

29:23the idea was to we focus on the research

29:26as much as possible.

29:28And Seal 911 tried to

29:30reach out to to they have lots of

29:32contacts and were very useful in that

29:33respect.

29:35Um, so basically we tried to keep

29:38kept things to to the research. But it

29:40was

29:42it was a hard night to sleep, so to say,

29:44knowing that there were $2 million

29:46for

29:47someone and they were probably about to

29:49be drained. And they ended up being

29:51drained and we we suspect they were

29:53drained. We can't know, of course. We we

29:56just saw a transaction on the

29:57blockchain. We we have no idea who they

29:58are.

29:59Um,

30:01how to warn the users very quickly.

30:04Again, the best way was through the

30:06community.

30:07And I

30:10yeah, this was so

30:13so hard for us, so frustrating to us

30:15that we couldn't warn users about this

30:18that we created Unlock Key.

30:20Unlock Key is basically have have I been

30:22puned for for keys.

30:24So, in a privacy preserving manner, you

30:26can go paste your address there and see

30:28if your address is in a known vulnerable

30:31set

30:32of

30:33addresses that are well in a set of

30:36vulnerable

30:37Uh and Unlucky is not only for E-Bloom,

30:39it also contains a cold card addresses.

30:42And we are sure that more pseudo random

30:45number generator problems will happen.

30:47So

30:50basically we we think efforts like

30:53Unlucky are very important.

30:55Red thing times up.

30:58Um

30:59these slides I think are very cool.

31:02There's a break now if you want to know

31:04why we think we were able to actually

31:06know about the addresses before the

31:08attacker because that's also very

31:09important. Like not to adopt a defeatist

31:12attitude when you find something like

31:14this.

31:15Don't do not think okay attacker already

31:16knows all is doomed.

31:18Let's you know do the post mortem and go

31:20to sleep.

31:22You can do stuff yet. You can be smarter

31:24than the attacker at least for a while.

31:26And uh

31:27times up.

31:29But again there's a break now. I'll be

31:31around if you want to discuss this. Uh

31:33I'll be happy to do so.

31:34Uh there's one part that's very

31:37interesting and very technical about

31:39pseudo random number generators that we

31:42figured out before the attacker that

31:44allowed us to crack even the 256 bits.

31:47Yes I'm finishing. Um

31:50but there's a success story for two

31:52wallets that were able to like warn

31:53their users and we

31:55hopefully save people's uh savings. So

32:00again we think Unlucky efforts like

32:02Unlucky are very important.

32:04Let's discuss if you have other idea

32:06besides Unlucky which by the way is not

32:07a product. We are not charging for

32:09Unlucky is an idea. Go and check out the

32:11site.

32:12And uh

32:14fun facts for the break.

32:16Thank you.

Source and accuracy details

Source export SHA256: e5aab74893af58b3cf2b10e2cb5b156c121f9e95cd19de36213b70c3a34abe24