DSS 2026 / Day 1 / Pearl Hall
Web3 Security Monitoring System Internals
Raj Kumar · Sabanaku77
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
- Names, organizations, technical terms, code and numbers may be misrecognized.
- Source wording and disfluencies are preserved; no editorial corrections were applied.
- Export contains whole-second cue starts only; cue ends and subsecond timing are unavailable.
- A full caption-track export does not establish that every spoken word is represented.
- Automatic YouTube captions; not human-verified against the audio.
Source export SHA256: 921ed2430d5da17b1f2a6107a9d431556de7dbbbf68087f525c2c0b5143f1cf9