DSS 2026 — Stateful Minefields: Post-Quantum Signatures for Ethereum Accounts Magnus Woodgate Source video: https://www.youtube.com/watch?v=1IASdrXy3i8 Automatic captions — not human-reviewed. Complete spoken-audio coverage is unverified. Source language tag: en (English). Source export SHA256: f373ed37dd8ac06cc178433022429b68e898349191bd349256e378e95f47c358 [0:00] Cool. Uh, some of you maybe saw my talk [0:02] before. This is going to be a super [0:04] quick run through uh with some maybe uh [0:07] original thoughts, but to get everyone [0:08] in too. So uh today we're going to be [0:10] talking about post quantum signatures um [0:12] specifically the concept of stateful [0:14] mind fields. Um this is you know we [0:17] introduce state uh into the post quantum [0:19] signing process and this adds a ton of [0:21] complexity to think about security [0:22] practitioners. Uh so this talks for [0:24] people building L1s, L2s, wallet devs, [0:27] anyone who's going to work with [0:28] signatures or think about how they're [0:29] integrated or audit them. [0:31] So asymmetric research for those of you [0:33] who don't know uh we work with a ton of [0:35] different protocol teams who are [0:36] embedded for continuous security [0:38] throughout software development life [0:39] cycle and all of that. We also do a ton [0:41] of other security instant response and [0:43] that sort of thing. Um yeah. [0:45] Cool. So to jump right in the idea of [0:48] post quantum Ethereum accounts is you [0:50] know we're going to migrate from this [0:51] ECDSA signing process to hash based [0:54] signatures. At least that's the current [0:56] proposal. The Ethereum approach is [0:58] actually to create account abstraction [1:00] so that we can do programmable signature [1:01] validation. [1:02] That means that we're not locked into [1:04] hash based signatures, but that's the [1:06] current approach we're going with [1:07] because it's you know it's very [1:08] conservative uh compared to lattice [1:10] based cryptography which we're not going [1:11] to talk about today. So today we're [1:13] specifically going to be looking at [1:14] Sphinx minus or or Jardin uh for those [1:17] of you who are familiar with it. [1:19] So this is a very quick run through of [1:22] SLHDSA uh [1:24] which comes from the Sphinx plus [1:25] proposal and is now standardized. The [1:28] way it works is you have this hyper [1:29] tree. You can just think of it as a [1:30] really really complicated tree where the [1:32] top layer you have a public root. You [1:34] have these uh extended Merkel signature [1:36] scheme layers as well. So they're just [1:38] Merkel trees where the leaves are bound [1:40] to WOTS signatures um in this case WOTS [1:43] plus or WOTS plus C, a compressed [1:44] version of that. And effectively you [1:46] have these trees that bind to trees and [1:48] you can do this composable layering [1:50] depending on the security uh strength [1:52] you want. And right at the bottom you [1:53] have this false layer of uh forest of of [1:56] random subsets uh where this is the [1:59] thing you're going to to actually sign [2:00] the transaction. The point to be aware [2:02] of here is you have all these layers and [2:04] you know you can already see that we've [2:05] got XMSS and Falls as the two key [2:09] defense [2:10] you know membership that we have here. [2:13] So you're going to have to verify all [2:14] the way from the bottom up to the top to [2:17] verify that an account is you know [2:19] signature is valid for that account. [2:22] Jardin on the other hand which is [2:23] proposed has two approaches to basically [2:26] overcome some of the limitations of [2:28] SLHDSA or based on Sphinx minus. We have [2:31] compact transactions and the and the [2:32] fallback case. So the hyper tree that I [2:35] just showed you guys was actually based [2:37] on the fallback stateless signing and [2:40] the idea there is that the [2:42] basically whenever you you resign a new [2:44] transaction you have the same problems [2:46] as other hashing where you could have [2:48] collisions. [2:49] Ideally they're cryptographically secure [2:51] so the collision risk is low but [2:52] something you want to think about when [2:53] you're auditing this code. [2:55] Otherwise the compact transaction format [2:58] actually requires using a stateful [3:00] signing process. So you use the SPX or [3:04] registration fallback to do the [3:05] signature to register a new Falls [3:08] instance or a subset of Falls [3:10] and then basically you're going to use [3:12] that instance [3:14] X amount of time so you might have 128 [3:16] signatures registered. The way it works [3:18] is you have a pool registered and then [3:20] you can consume them and and use them. [3:22] The difference here is that these [3:24] compact transactions are significantly [3:25] faster and smaller. [3:27] Yeah one of the measurements here was [3:28] about 43 seconds on a ledger Nano S to [3:31] do the fallback just to sign the [3:32] transaction. [3:35] So the way this works is basically you [3:37] have this stateless SPX authorization [3:39] SPX being that big hyper tree that we [3:41] saw before with Sphinx minus or SLHDSA. [3:44] You register a commitment to [3:47] Falls random Forest of random subset and [3:50] basically you then sign compactly so [3:53] each time you use one of these forests [3:56] you you consume Q. So Q is this is the [3:59] index of the forest that you're using [4:01] Um and then basically you do that until [4:04] the capacity is exhausted and then you [4:05] create a fresh pool and you try again. [4:07] So the idea here is that now we're going [4:09] to have to do this registration process [4:11] semi-frequently depending on your [4:12] transaction frequency. Um but the [4:14] signing compactly uh is is going to add [4:16] a ton of benefits so that you can [4:17] actually sign things in meaningful time. [4:20] The distinction here you want to make is [4:21] that Q should never be rewound or [4:23] resigned uh and we'll get into that. [4:26] So [4:27] this is like a hypothetical scenario [4:29] where you have you know signature A um [4:31] with some pseudo code where Q equals [4:32] seven. You know the wallet might die uh [4:35] there's a power outage, there's a race [4:36] condition or something and something [4:37] crashes uh and the wallet's gone. So [4:40] then what you do is you restore the [4:41] backup as you see in yellow and then you [4:43] sign again which generates a new [4:45] signature B. Now the signature you've [4:48] used the in in this case you've used the [4:50] same Q so you've used the same forest uh [4:52] and you've revealed more information [4:54] about that forest. So what ends up [4:56] happening is you end up losing bit [4:58] strength on that specific forest and [5:00] then what an attacker can do is sit [5:02] there, listen and then uh try to [5:05] essentially forge a proof for that [5:07] forest. Now the bit strength is only [5:09] going to reduce a bit each time because [5:10] force has its property of few time [5:12] signatures. So if you do sign with the [5:14] same forest twice it's not game over but [5:17] it it's it's massively worse than you [5:18] know you don't want to be doing it and [5:21] when you think about these things we [5:22] want to be thinking in the post-quantum [5:23] era. So there may be new post-quantum [5:25] algorithms that make the impact worse. [5:28] Uh yeah and more openings always reduce [5:30] the security margin. [5:32] So you want to be thinking when you're [5:34] reviewing this code um it's it you know [5:36] it's a lot of it's in draft and [5:37] experimental now but you'll be seeing [5:38] stuff come out. The you want to be [5:40] consuming these Q values uh durably. So [5:43] this is kind of the ideal uh [5:46] ideal signing policy. So basically even [5:48] if the signature doesn't succeed you [5:51] don't broadcast it to the network. You [5:53] do want to actually consume Q um and the [5:56] chance that it did you know it might not [5:58] even be on the network but maybe it's on [5:59] uh you know it was recorded uh being [6:03] propagated but not finalized for an [6:04] example. You you always want to [6:05] increment Q and don't sign with it [6:07] twice. [6:09] Cool. So that's actually talking about, [6:11] you know, um SLHDSA and Jarden, but the [6:14] other part is account abstraction, which [6:16] I mentioned. Account abstraction enables [6:18] us to do programmable validation. The [6:20] other thing that you really need to be [6:21] thinking about, even though after a full [6:23] migration to post-quantum, is what [6:25] authorizes like what action. [6:27] So post-quantum doesn't actually retire [6:29] ECDSA. So even though you have all this [6:31] new fancy tree-based signing signatures, [6:35] verification, it doesn't actually retire [6:36] what you've got authorized by ECDSA. So [6:38] if you have something delegated to a [6:40] 7702 account that you you know, you can [6:42] overwrite the code, then the ECDSA key [6:44] is still going to be in play. And when [6:46] you're reviewing this code as an [6:47] auditor, you really want to check this [6:48] out. [6:50] So if there's one takeaway that you [6:52] should think about from this is that [6:53] just because the signature is valid [6:55] doesn't mean the account's secure. And [6:56] if you're signing with multiple [6:57] instances of the same Q, then that [7:00] you're going to start leaking [7:00] information about the key, and that's [7:02] something that, you know, if you're [7:03] managing billions in TVL, you don't want [7:05] to be doing. [7:06] Cool. So thanks for listening. Um yeah, [7:09] you can check us out asymmetric.com [7:10] there. [7:12] Any questions? [7:18] Thanks guys.