DSS

DSS 2026 / Day 1 / Pearl Hall

Web3 Security Monitoring System Internals

Raj Kumar · Sabanaku77

17:56 · 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:00I'm Rajkumar and I'm a security

0:02researcher at Celer. The topic of the

0:04talk today is monitoring system

0:06internals from on-chain data to incident

0:09response and I will be giving this talk

0:12with my co-speaker Prajwal Singh.

0:14>> Hey myself Prajwal. I work as a senior

0:17threat researcher for Zscaler and my

0:19area of interest in Web3 cryptography

0:21and mainly the monitoring systems. What

0:23do you Raj? So now Raj is going to

0:25explain you what are all the topics we

0:29are going to cover in this talk.

0:32>> So what we have done is we have divided

0:34this talk into multiple parts. First we

0:36will explain why we need monitoring.

0:38Second one is system architecture behind

0:40the monitoring system and third one and

0:43fourth one is about the detection rules

0:45and the incident response and then we

0:47will take the case study of Wasabi and

0:49then of course references and the Q&A.

0:53So why we need monitoring? So basically

0:56if we are doing let's say testing, we

0:58are doing formal verification and we are

1:00doing manual audits.

1:02So why we need monitoring system? So

1:05there is always a possibility that in

1:07the production our first can

1:10you know assumption can break and audits

1:12manual audits are also time bound. So

1:15there there is a possibility that there

1:17might be a critical in a protocol that

1:20can cause basically huge loss to the

1:22protocol. And basically we would what we

1:25would like is we would like to detect

1:26that

1:28risk and take action against

1:32against that risk.

1:33So yeah you can take it from here.

1:35>> Okay so now I'm going to explain what's

1:38the monitoring system architecture looks

1:40like. So we'll start from the left side.

1:43So first we take input data. You can say

1:46input logs from two sources. First is

1:48block data that is the transaction which

1:51have already been happened. Second is

1:54the pending transactions most of the

1:56times from the mem pools.

1:58Then after getting that data we to

2:01decode and enrich it because the data is

2:03in the hex format and making a detection

2:06rule on a hex hex format is not so much

2:08useful. After decoding and enriching

2:11data, we then pass it into Elk stack. So

2:13basically Elk stack

2:15is a

2:17Elk stack is a system where we can store

2:20the data in decoded form

2:23and then store store the data in decoded

2:26form, index it, search it and write the

2:29detection rules. So on basis of the data

2:32which we

2:33stored in Elk stack, we can make

2:35detection rule on top of that and on the

2:37basis of the detection rules or the

2:38cluster of the detection rules, we can

2:42take response or actionable items based

2:45on the based on that.

2:47So let's talk about block data and

2:49mempool data and how they are different

2:52and why we need to treat them

2:54differently when you're talking about

2:55the monitoring.

2:56The first thing is confirmed

2:59transactions, that is block data. So

3:01when we are retrieving block data, that

3:03means confirmed transactions from a

3:05node, it will give us a receipt logs

3:08because the transaction is already been

3:10completed. That means we will get all

3:11the events that has been emitted, the

3:14state change which occurred due to the

3:16that transaction. On the other hand, we

3:18have pending transaction, mostly

3:21mempool transaction. So basically

3:22mempool transactions are not executed

3:25yet. So we won't get the receipt logs,

3:27that is we won't get the emitted events,

3:29what what will be the state change, what

3:31will be the new state.

3:33So in order to get the same, we need to

3:36simulate the

3:39pending transaction which we have it

3:41from the mempool. So

3:43while the mempool is important because

3:46mempool

3:47gives us time. For example, if we see

3:50any

3:51possible exploit or possible things

3:55which is gonna exploit

3:58protocol. So in that case, we might be

4:00able to if we detect it very early, we

4:02might be able to front run the

4:04transaction and may be save a protocol.

4:07Next is basically after getting the logs

4:10after getting the those logs from

4:12block data or mempool, what is the next

4:14step? So basically as I said that data

4:17is in hex format and we will not be it's

4:19not much meaningful to make detection

4:21rule on top of that. So after getting

4:24the block data or after getting all the

4:27like data we have we get after

4:30simulating the

4:31mempool transactions, we basically refer

4:34to four data sources. First is receipt

4:37and logs that are basically the events.

4:39Second is call traces. They are internal

4:43contract calls. They don't emit logs.

4:45Third is basically state change and then

4:48moving further to ABI and policy

4:50content. So you can look at the right

4:53side that the data has been decoded and

4:56enriched. So we get this in a beautiful

4:59JSON format. Here we can see okay the

5:01chain ID is one. This is the block hash.

5:03This is the transaction hash. Log index

5:05is seven. Role event is role granted and

5:09similarly the mode is observed and

5:11policy version is version 12.

5:13So after getting so till now we got the

5:17data. We gripped the data. We enriched

5:19and decoded, changed it into the JSON

5:20format. So what next? The next is

5:23basically

5:25injecting that data

5:28indexing it

5:29and making it prepare

5:32so that we can write detection rule on

5:33the same

5:34and take different actions. So for that

5:37we have used ELK stack.

5:40There are other

5:42other sources too which can be used for

5:44example Splunk, Microsoft Sentinel or

5:46Google SecOps. That depends on the

5:48depends on

5:49protocol to protocol. So after getting

5:52the logs in JSON format, what we do?

5:54We

5:55we use logstash. So basically logstash

5:58what it do? It take the JSON format and

6:02then

6:03rectify

6:04the

6:06rectify the data on the basis of what is

6:10required. For example, we are getting a

6:12data in JSON format and we don't want

6:14certain type of fields or maybe certain

6:16types of fields are sensitive. We can

6:18directly remove it. So basically what

6:20Logstash does to it take the data,

6:22rectify it, change it in into a unified

6:25schema and then forward it to the

6:27Elastic stack. So in Elastic stack what

6:29happened the same data get stored and

6:32index.

6:34Index because

6:36yeah index so for the fast search. So

6:38once the data gets stored and indexed in

6:40Elastic search

6:42then we will move forward to the Kibana.

6:44So Kibana is basically a graphical user

6:47interface which help us in order to get

6:50logs from the Elastic search that will

6:52be a lifetime live live data, historical

6:56data,

6:57yeah anything. So Kibana gives us a good

7:01control to any security analyst who is

7:03sitting there and wants to

7:05maybe monitor the events or write the

7:07detection rule based on same.

7:11So now next we have certain now we have

7:14got the data

7:16encoded it, enriched it and then feed it

7:19into the ELK stack. So now Raj will

7:22explain what are detection rules and how

7:24to make it.

7:25>> So yeah what are detection rules and

7:29basically to detect everything like

7:31every type of risk internal or the

7:33external we need some rules based on the

7:36threat

7:38that we were thinking about and based on

7:41the detection rules we can also write

7:44the

7:46incident response for that.

7:48and the approach for

7:51writing the detection rule is like

7:53pretty simple. We can think about

7:56detection rules in three questions. The

7:58first one is what can go wrong? Let's

8:00say if there is a trust assumption that

8:02we were making it can break in the

8:03production and if there is a security

8:06property or intended behavior but that

8:08can fail in the you know other end time.

8:11And the second question it is like what

8:13we will observe basically the detection

8:14rule and when we will

8:17basically use that. And third one is

8:20what action can it still help if we have

8:22the detection rule, but if we don't have

8:24the action that we can take then there

8:25is no

8:27no worth to write the detection rule,

8:29right?

8:31Now for writing the detection rule we

8:34can use the systematic approach which is

8:36we can take help from the threat model.

8:38And for writing the threat model we can

8:42use a 4A model which is

8:44we have to map everything in the

8:46protocol like assets and the invariants,

8:49assets

8:51like everything that can

8:53every like assets that we have and the

8:55invariants that can break in the let's

8:57say production.

8:58And second one is actors and the roles

9:01let's say we have a role abuse etc.

9:04So we have to detect that as well. And

9:07third one is the internal assumptions or

9:09external assumptions that can

9:12break in the future let's say

9:13liquidations or the keepers etc.

9:16And fourth one is the attack vectors.

9:19And we we have to take about think about

9:22every attack vectors and according to

9:24that we have to write the detection

9:26rules and for every detection rules we

9:28have to write the incident response. And

9:31we can divide risk into internal and the

9:34externals for internals like accounting

9:37bugs, role abuse etc. And externals are

9:40mostly the assumptions that we are

9:41making let's say DPE Oracle failure or

9:44compromised signers.

9:47Yeah, here is a example of the vault

9:50theft let's say we have a vault user can

9:52deposit the asset and means that here.

9:54And

9:56what we can do to detect that there is a

9:59theft of the funds.

10:00Basically we can use the invariant which

10:03is the if if there is a drop in the

10:06share

10:07price it means that something is wrong

10:09with the

10:10and if we detect this, it means we have

10:13to take the action as well, which is the

10:15incident response.

10:18Yeah, next part is about the incident

10:20response. So if we have the detection

10:22rules, but we don't have a book for the

10:24actions, you know, like what we will do

10:27when something goes wrong, then there is

10:29no mean to write the you know, detection

10:31rule. So we can take

10:33action according to the

10:35So basically we can take action

10:36according to the protocols and

10:40the rule that we have written, right?

10:42And it can be like alerting the team,

10:44pausing the protocol or disabling a

10:46strategy and basically

10:50including the you know, circuit breaker

10:52etc.

10:53So yeah. And next there is an example of

10:57Wasabi hack which will Press will

10:58explain.

11:00>> So let's talk about the Wasabi. It's a

11:02real life

11:04example that why we need monitoring and

11:06threat detection. So what happened with

11:08Wasabi that they got exploited for 5

11:11millions over three chains,

11:13Ethereum base and Blast. So the attack

11:15vector was pretty simple. It was a

11:17developer key leak. So this key had

11:22authority of granting admin rights to

11:24anyone,

11:25changing, moving the funds of vaults to

11:28any other strategies and third is

11:31basically updating the pool contract. So

11:34basically what happened the once the

11:37malicious actor got the private key,

11:39first he

11:41granted the admin access to one of his

11:44contracts. After that he changed he

11:48moved the fund of vaults by changing the

11:52strategy. And next what he has done, he

11:55upgraded the pool contract in order to

11:57move funds from the same.

11:59So

12:01the next question is how and at what

12:04point we could have detected it. So the

12:07first point is basically admin grant.

12:10If an admin access has been

12:14to a contract or to a address which is

12:16not in the white list, that's a first

12:18red flag.

12:19Next is basically

12:21strategies. I guess in most of the firms

12:24the strategy which will be deployed for

12:28any vault will go through governance and

12:30have certain kind of approvals. So if a

12:33vault is redirected to any strategy

12:35which is not

12:37white listed or which is not approved,

12:39that's still a red flag.

12:41The next next is basically the third

12:44step that is the pool contract has been

12:47updated upgraded. So when we have to

12:50upgrade a contract in any protocol, we

12:52go through multiple security audits

12:54other things and certain kind of

12:55approval. So if a pool contract is been

12:59upgraded to a unknown contract that

13:01itself a malicious.

13:03So in terms of Wasabi, the first

13:06reported signal was at 7:46.

13:09Admin was granted at 7:48 and the first

13:11fall drain was 7:49. So as we can see

13:13there is a one minute difference between

13:16admin grant and first wall drain. That's

13:18enough in order to have a successful

13:22or we can say a good incidence response.

13:25Also incidence response in this case

13:26depends on many factor depends on what

13:29kind of if they have multiple role

13:31separation that is role is been granted

13:34for pausing the contract and etc.

13:37So I guess

13:41Okay, so thank you. That's was the talk

13:44by me and Raj. These are the references

13:46which I have used for the talk.

13:48And yeah, we are open to any questions.

13:50Thank you.

13:53>> Thank you so much everyone for listening

13:54the talk.

13:56>> Thank you.

13:58>> Okay, okay.

13:59>> Yeah, yeah, yeah, please.

14:07>> Okay, that depends on the blast radius.

14:09For example, that depends on protocol to

14:11protocol and blast radius. For example,

14:13in this case, if a vault if you get to

14:15know the admin right have been

14:16transferred and there will be effect on

14:18the vault. So, in that case, it will be

14:20good to just pause the vault and keep

14:22the protocol as you know, working.

14:26It's automated exactly because we don't

14:29have much time to response when we

14:32detect something, right? Because

14:33everything moves so fast. So there is I

14:35don't think there will be a good option

14:37to you know, human intervention and

14:39taking some kind of

14:40like authorities and all. So everything

14:42should be necessary.

14:46Yeah, right.

14:48Exactly. These are pre-vetted rules

14:50which we made and we tested out in dev

14:52in moment. So everything is automated.

14:55Yeah.

14:55>> Basically for every detection rule, we

14:57will have a incident response guideline

14:59so that we can take action.

15:02>> Yeah, sure.

15:08Okay. So yeah, good question. So

15:10basically

15:11most of the hacks goes through private

15:13block builders. So it's but if any go

15:16with the public mem pool, what we can

15:18do? We can have the transaction from the

15:21mem pool. We can simulate it and on the

15:23basis of the results, if it's harming

15:25the protocol, if it's causing some

15:27damage, we can front end that

15:28transaction.

15:39Okay.

15:40All right. So this is not for the whole

15:42Ethereum chain. That depends on protocol

15:44to protocol. So if any protocol wants to

15:47opt in for the monitoring thing, so we

15:49can have data of there and we have a log

15:51retention policy. We can apply for 30

15:53days, 60 days, 90 days based on the

15:54requirement.

16:04You no, that's I can we can use S3

16:07bucket out AWS. It's pretty cheap,

16:08right? We'll be able to so what we can

16:10do through remediate it, we can only

16:12store 7 days of data in elk and after

16:14that if the data is 7 days old, we can

16:17directly store that in S3. S3 is

16:18basically pretty cheap. So in order to

16:20query the historical data, we can

16:21directly go to the S3 and in order to

16:23get the live data or anything, we can

16:25just directly get it from there.

16:27All right? Thank you.

16:29Yeah.

16:33Yeah.

16:35It's Elk.

17:02So basically Elk don't work. There is an

17:05option in Elk. We can Basically, how Elk

17:07store the data? They store data in

17:09shards. So basically, when we store

17:11data, there will be multiple shards of

17:13the tables which we call index and that

17:15gets stored at certain values. So in

17:18Elk, we can also have multiple instance

17:20of for example, Elk and multiple

17:23database what we can say basically

17:26multiple backup databases.

17:28So what happened? For example, there are

17:30four databases, one, two, three, four

17:31and there are four Elk stances with

17:33people are accessing, right? If one

17:34database goes down, the other will be

17:37able to give them the

17:39data.

17:40So basically we that depends on us. It's

17:42very flexible. We can make multiple like

17:45we can make it centralized, we can make

17:47it decentralized.

17:52Okay, I guess. Thank you.

17:54>> Thanks so much.

Source and accuracy details

Source export SHA256: 921ed2430d5da17b1f2a6107a9d431556de7dbbbf68087f525c2c0b5143f1cf9