DSS 2026 — Don’t Trust the First Model: A Methodology for Adversarial AI Audits Christian Vari Source video: https://www.youtube.com/watch?v=7otm-JgMGbk Automatic captions — not human-reviewed. Complete spoken-audio coverage is unverified. Source language tag: en (English). Source export SHA256: 4c75d3f91c3ba7c842bc174543489f1688987480c08f1d0e4bfda9a7bbed6666 [0:01] How many security researchers do we have [0:03] in the room? Raise your hand, guys. Oh, [0:06] great. I see a lot of you. So, from a [0:08] security researcher to security [0:10] researcher, [0:12] please don't trust the first model. So, [0:16] you know, [0:17] LLM models always try to convince us [0:19] that they went through all the code [0:20] base, they checked everything, and that [0:23] those this is the list of all the [0:25] vulnerabilities that are in the code [0:27] base. [0:28] But the biggest issue that we have here [0:31] is that they are overconfident. And at [0:34] Ox Security, we developed a methodology [0:37] for doing this adversarially. So, how to [0:39] have models challenge each other in [0:42] order to reach an agreement. [0:46] My name is Christian Vari. I'm the the [0:48] head of audit operation at Ox Security. [0:50] Ox Security is [0:52] spotting vulnerabilities since 2017. We [0:56] have worked on more than 600 [0:58] engagements, and we have a pool of more [1:01] than 50 senior security researchers. [1:06] So, [1:08] we usually ask a lot of things to LLMs, [1:10] and we got usually good replies. So, we [1:13] get a lot of info from them. [1:15] But there is one thing that we usually [1:18] don't know. We don't have the real [1:20] coverage of what they've done, the real [1:22] part that they checked. So, [1:25] is true that probably they checked [1:28] mostly of the things, but we don't have [1:30] the observability for being sure about [1:32] that. So, what if some files has not [1:35] been read, if some parts were not been [1:39] examined? What if they just keep it an [1:41] entire file? [1:43] We're not just thinking about, you know, [1:45] smart contracts, but maybe we are [1:47] auditing a full node or, you know, [1:51] off-chain components that then move [1:53] nodes. So, we have big parts, large [1:56] amount of code. How can we [1:59] be sure about coverage that they have [2:01] have checked? And also another thing, [2:05] not just, you know, the the file and the [2:07] code base, but also the claims. So have [2:08] they challenged really all the potential [2:11] things that are in the code base? [2:13] Have they challenged the assumptions? [2:16] We usually just by, you know, running [2:19] LLM or a model or something like that, [2:22] we're usually not really aware of that. [2:25] So we came up with, you know, [2:28] an harness, a workflow. We have [2:30] implemented it and its name is Hive, but [2:33] in this talk I will just [2:35] tell you the methodology. I mean, you [2:37] can apply the same methodology. [2:39] We [2:41] define it this in five steps actually. [2:44] So the first one is the scope. So [2:46] as a security researcher is what we [2:48] usually do. We prepare a scope, okay? So [2:51] we have the commit hash of the code base [2:54] that we will review. We have, you know, [2:56] the architecture, we have the [2:58] boundaries, you know, the the the [3:01] preconditions and all the [3:03] issues or, you know, [3:05] things that are already known to the [3:07] client. Then we have for each of this [3:10] block a gate. So for the scope we have [3:12] the gate that we know the scope. Then we [3:15] have discover and this part actually is [3:18] where we use a multiple amount of [3:20] models. Usually we [3:23] try to run all of them, so from [3:25] different providers and different type [3:27] of models in order to check the code [3:29] base and spot all the possible [3:31] vulnerabilities. The important thing for [3:33] this is that at the end of this part of [3:35] the process we have some very specified [3:40] candidate of vulnerabilities. Then we [3:43] next to the the gate open and we move to [3:46] the next step that is actually the the [3:48] duplication. And we [3:51] actually perform some some execution of [3:54] the models in order to get a single [3:58] a single candidate. Then we do the [4:00] validation. I'll explain you why that is [4:02] one of the most important thing and we [4:04] then move to the the human part because [4:07] we believe that at the end of the [4:08] process we still need [4:10] human reviewer and this is just, you [4:12] know, a suggestion, an a testable [4:14] hypothesis of what the vulnerability [4:16] will be. [4:18] So that's what I was saying before. We [4:20] are creating the scope but our tool [4:23] should be able to ensure that we check [4:25] all the all the files, all the paths and [4:28] check all the potential precondition and [4:31] and and also [4:34] the external dependencies where [4:37] something is built on. [4:39] So for example here in the [4:41] in in this in this matrix we are just [4:44] checking, you know, that all the models [4:46] checked all the file and this is [4:47] important because sometimes we have a [4:50] global coverage on all the models that [4:52] are working on that but we are not [4:54] ensuring that the each model have 100% [4:58] of the coverage. [5:01] Oh. [5:03] Another important thing is that models [5:05] should not be biased and this is really [5:08] line with what we usually do with our [5:10] human auditors. So at Ox Security we [5:13] have our blinded approach where each [5:15] auditor actually go through the code [5:16] base [5:18] independently, so without sharing [5:19] insight with the other auditors. And we [5:22] are trying to do the same thing applied [5:23] to models. So the models have a shared [5:25] input where they have, you know, the [5:27] code base, the revision, the [5:29] architecture, all this kind of stuff. [5:31] And then also we keep separate all their [5:34] work. So the candidate findings, the the [5:37] path that the models went through in [5:39] order to find the the vulnerabilities. [5:43] Then we start with the discovery that is [5:45] executed by multiple models and is [5:47] actually performing two step. So we have [5:49] a blind pass where actually the models [5:53] go through the [5:54] most known, you know, vulnerabilities [5:56] glasses like I don't know, overflow, [5:59] arithmetic, all this kind of stuff. And [6:01] then we have an informed pass. So in all [6:03] the the past engagement, we got a lot of [6:06] knowledge about [6:08] vulnerabilities and potential issues. [6:11] So, we created a a dataset for that and [6:15] we used that in the informed pass. And [6:17] we actually execute both. The informed [6:19] pass is also very specific depending on [6:21] the on the technology that we are [6:24] auditing. [6:26] Another important thing is that at the [6:28] end of the discovery phase, we have the [6:31] claim that is testable and that is well [6:34] defined. So, we have to know who is the [6:36] attacker, so their role and his [6:38] capabilities. What are the [6:39] preconditions? So, probably [6:42] you know [6:44] that type of attacker have a [6:45] precondition and depending on the [6:46] precondition depends also the severity. [6:49] The boundary, the invariance, if there [6:52] are scoped invariance, actually it [6:54] should be checked. The location [6:56] obviously, so the code and the related [6:58] code and the provenance, so which model [7:01] found it and which phase. So, the [7:02] important thing for us is keeping [7:05] an audit log actually of what happened, [7:07] who found something and the path that [7:09] has been executed. This is very [7:11] important especially on very very large [7:12] code bases where we have, I don't know, [7:14] a node that is depending on a big SDK [7:18] and actually we have to scope the the [7:21] whole path in order to pass it correctly [7:24] to the model and also, you know, [7:26] have [7:27] a feasible type of cost because, you [7:30] know, tokens are not free. [7:34] Another part that is important, so after [7:37] the the the discovery part, we have this [7:39] list of of findings, potential findings. [7:43] We have to duplicate them. And, you [7:45] know, [7:46] as a security researcher, everyone has a [7:48] way for doing the duplication, okay? [7:52] It's a very opinionated thing. And in [7:54] our opinion, the best way is with the [7:56] root cause, okay? So, here for example, [7:58] we have two claims but they have the the [8:00] same root cause and the same fix fix the [8:02] same thing. And the model should be able [8:05] also to separate the things that that [8:08] makes each claim [8:10] unique. So, for example, here it should [8:12] be able to [8:14] separate the part that are in common and [8:16] merge them into just one and then also [8:19] create another findings with the [8:20] remaining part. [8:24] It's not working. [8:27] Okay. Well, [8:32] just trying. [8:33] By the way, even if it's not moving. [8:36] Okay. Yeah, after that we have the [8:38] validation. This is the most important [8:40] part because [8:42] actually we use this as hypothesis for [8:45] the security researcher and we don't [8:47] want to waste the time of security [8:49] researcher. So, it's true that we have a [8:50] lot of harnesses for generating [8:53] findings, [8:54] but there are a lot of false positive [8:56] and bringing a lot of false positive to [8:59] security researcher is actually a waste [9:00] of time. You know, you have 200 [9:02] potential findings and the security [9:04] researcher have to spend their time on [9:06] double checking all these AI crap [9:09] instead of checking anti-code. And this [9:11] is, you know, is something that we [9:14] cannot deal with. So, the idea here is [9:15] to rerun all the the claims that have [9:19] been found adversarially through other [9:21] models. So, [9:23] we create a fresh context with this with [9:25] all the data that is required, all the [9:27] dependencies and all the the the the [9:30] architecture part that is needed and we [9:32] actually let those new models try to [9:35] execute them and validate it. [9:39] Also, it's very important especially in [9:41] large code base like I don't know [9:43] blockchain node or this kind of stuff to [9:45] give all the the the path to them, so [9:48] the the the dependencies. So, imagine a [9:50] big SDK or this kind of stuff. So, we [9:53] have to give all the context needed [9:55] trying to scope it to make, you know, [9:57] the less amount to spend the less amount [9:59] of tokens and this will be able actually [10:03] our models to [10:06] identify where a path is actually [10:08] something that is reachable or not, for [10:10] example, because it's very common, you [10:12] know, with models when use them, that [10:13] say, okay, we have this kind of [10:15] vulnerabilities, [10:16] just go through it and you can execute [10:18] it. But then it's not really true [10:20] because it may be in a dependency of, [10:22] you know, depending on the on the [10:25] execution, [10:27] there is a difference because maybe it's [10:29] gated, so like in this example. [10:32] And one another thing that is important [10:35] in our process is confidence. So I mean, [10:39] we [10:40] have traced all the the [10:43] all the path that our model our [10:46] methodology has going through, so we [10:48] know which model found something and at [10:50] which stage. And we have all the audit [10:52] log of this. Having this, we have this [10:55] part of the model that actually create a [10:57] summary of that [10:59] and also depending on a threshold, put [11:02] the findings in a different way. And the [11:05] important thing is that we are able then [11:07] to pass all this information to the [11:08] auditors. So if we have some models that [11:12] are supporting it, some model that are [11:14] refusing it, and you know, they're not [11:16] really sure about that, actually we gave [11:19] all their thinking to the security [11:22] researcher, the human one, the the real [11:23] one, in order to be able then to to [11:26] judge this. [11:29] At the end of the process, we have this [11:31] last part that is [11:33] you know, a sort of health health check. [11:36] So sometimes, you know, our models, you [11:39] know, we use all of them, can [11:43] you know, give no verdict or giving no [11:45] candidates or just not read the scope. [11:48] So it's very important that your harness [11:51] is able to identify that, to be aware of [11:53] that because we are tracking it and then [11:56] be able to rerun it. So if, I don't [11:58] know, a part of the code base has not [12:00] been checked or if a part of the [12:02] architecture is still not checked or [12:06] we are unsure about it, we have to [12:08] iterate about that or at least we have [12:10] to let the auditors, the human the human [12:12] auditors be aware of it in order then [12:16] that they can then just go through it [12:18] manually and check it. [12:21] So this is our model. Actually we [12:23] implemented it through our tool that is [12:25] called Hive and you can actually get [12:28] more information on our website that is [12:30] oxsecurity.io. [12:32] Um [12:34] um our tool is something that you can [12:38] use if you reach us to us, but the [12:40] methodology is something that you can [12:42] they can use as you want because is [12:44] something that is not really dependent [12:46] on models or technology. And that's all. [12:49] If you want to reach out for for trying [12:52] it or just have any question, I'll be [12:54] here. Thank you.