BLS-signaturer og aggregerede signaturskemaer

BLS-signaturer bygger på bilineære parringer – en matematisk operation på elliptiske kurver. En parring e: G1 x G2 -> GT afbilder par af punkter fra to grupper (G1, G2) til en målgruppe GT. Den afgørende egenskab er bilinearitet: e(aP, bQ) = e(P, Q)^(ab) for skalarerne a, b og punkterne P, Q. Det gør det muligt at kontrollere relationer mellem gruppeelementer uden at kende de diskrete logaritmer. Den mest anvendte paringskurve til kryptografi er BLS12-381, som er valgt på grund af dens sikkerhedsniveau på 128 bit, små gruppeelementer (48 byte i G1, 96 byte i G2) og effektive paringsberegninger.

En BLS-signatur (Boneh-Lynn-Shacham) fungerer således. Nøglegenerering: Den private nøgle x er en tilfældig skalar; den offentlige nøgle PK = x * G, hvor G er G2-generatoren. Signering: Givet meddelelsen m beregnes H = hash-to-curve(m) i G1, hvorefter sigma = x * H. Signaturen sigma er et enkelt G1-punkt (48 byte på BLS12-381). Verificering: kontrollér e(sigma, G) == e(H, PK). På grund af bilineariteten gælder e(x*H, G) = e(H, G)^x = e(H, x*G) = e(H, PK). Sikkerheden bygger på co-CDH-antagelsen: Det er vanskeligt at beregne x*H ud fra H og x*G uden at kende x.

BLS-signaturer understøtter ikke-interaktiv aggregering: Givet signaturer sigma_1, ..., sigma_n på meddelelserne m_1, ..., m_n fra de offentlige nøgler PK_1, ..., PK_n beregner en aggregator sigma_agg = sigma_1 + sigma_2 + ... + sigma_n (addition af punkter på en elliptisk kurve). Den aggregerede signatur er én værdi på 48 byte uanset n. Verificering kræver n+1 paringsoperationer: kontrollér e(sigma_agg, G) == product(e(H_i, PK_i)). I det almindelige tilfælde, hvor alle underskrivere signerer den samme meddelelse, reduceres verificeringen til 2 parringer: e(sigma_agg, G) == e(H, sum(PK_i)).

Naiv BLS-aggregering er sårbar over for angreb med en falsk nøgle. En modstander registrerer PK_adv = x_adv*G - PK_honest. Den aggregerede nøgle PK_agg = PK_honest + PK_adv = x_adv*G, som modstanderen har fuld kontrol over. Forsvarsmuligheder: (1) Besiddelsesbevis (PoP): Hver underskriver beviser under registreringen, at vedkommende kender sin private nøgle, ved at signere sin egen offentlige nøgle. (2) Meddelelsesudvidelse: inkludér hver underskrivers offentlige nøgle i dennes meddelelse. (3) Delinearisering (BGLS): gang hver offentlig nøgle med hash(PK_i, all_PKs) før aggregering, så den linearitet, der muliggør angrebet, brydes. Ethereum bruger PoP ved registrering af validatorer.

Ethereums konsensuslag (Beacon Chain) gør omfattende brug af aggregering med BLS12-381. I hvert slot afgiver cirka 400.000+ aktive validatorer attesteringer om kædetoppen. Uden aggregering ville lagring af alle signaturer kræve cirka 400.000 * 96 byte = 38 MB pr. slot. Med BLS-aggregering pr. komité (typisk 512 validatorer) producerer hver komité én aggregeret signatur på 96 byte, hvilket reducerer de samlede signaturdata til kilobyte pr. slot. Beacon Chain-blokkens legeme indeholder aggregerede attesteringer: et bitfelt, der angiver, hvilke validatorer der deltog, samt én aggregeret BLS-signatur for hver komité.

BLS-signaturoperationer har andre ydeevneegenskaber end ECDSA. BLS-signering kræver én hash-to-curve-beregning og én skalarmultiplikation (~1 ms på moderne hardware). BLS-verificering kræver to paringsoperationer (~3-5 ms hver = ~6-10 ms i alt). ECDSA-signering kræver én punktmultiplikation (~0.2 ms), mens verificering kræver to punktmultiplikationer (~0.4 ms). BLS-verificering er langsommere pr. signatur, men langt hurtigere samlet set: verificering af 1000 aggregerede BLS-signaturer kræver ~10 ms i alt mod ~400 ms for 1000 individuelle ECDSA-verificeringer. Skæringspunktet ligger omkring 2-3 signaturer.

Tærskelbaseret BLS udvider aggregering til hemmelighedsdeling. I en (t, n)-tærskelordning deles den private nøgle i n andele ved hjælp af Shamirs hemmelighedsdeling over BLS-skalarfeltet. Hver andelshaver i producerer en delvis signatur sigma_i = sk_i * H(m). Alle t delvise signaturer kan kombineres ved hjælp af Lagrange-interpolationskoefficienter: sigma = sum(lambda_i * sigma_i). Resultatet er identisk med den signatur, som den oprindelige nøgle ville have produceret, men ingen enkelt part har nogensinde den fuldstændige nøgle. Tærskelbaseret BLS bruges i distribueret validator-teknologi (DVT), MPC-tegnebøger og tærskelbaserede signeringstjenester som Fireblocks og Web3Auth.

Filecoin bruger BLS-signaturer til sit system med lagringsbeviser og til transaktionssignering. Lagringsminere aggregerer flere beviser ved hjælp af BLS-aggregering, hvilket reducerer omkostningerne ved verificering på kæden. Filecoins meddelelsespulje aggregerer også flere transaktionssignaturer til én samlet signatur, hvilket reducerer blokstørrelserne. Filecoin-implementeringen bruger IETF's udkast til BLS-standarden (hash-to-curve i henhold til RFC 9380, BLS12-381-kurven) med varianten med minimumsstørrelse for offentlige nøgler, hvor offentlige nøgler er i G1 (48 byte), og signaturer er i G2 (96 byte) – modsat Ethereums konvention.

Selv om Zcash primært bruger Groth16 zk-SNARK-beviser, danner BLS-parringer grundlag for mange nulvidenskabskonstruktioner baseret på parringer. Groth16-verificeringsligningen er en paringskontrol: e(A, B) = e(alpha, beta) * e(vk, C), hvor A, B og C er beviselementer. KZG-polynomiale forpligtelser (som bruges i Ethereums EIP-4844-blobtransaktioner og forskellige ZK-rollupsystemer) bygger også på BLS12-381-parringer: En forpligtelse til polynomiet f(x) er C = f(tau)*G, og evalueringsbeviser verificeres via parring. BLS12-381 blev specifikt valgt på grund af sine effektive paringsoperationer og sikkerhedsniveauet på 128 bit.

BLS er ikke den eneste ordning for aggregerbare signaturer. Schnorr-signaturer understøtter nøgleaggregering (MuSig2, som bruges i Bitcoin Taproot), hvor flere underskrivere frembringer én Schnorr-signatur, der ikke kan skelnes fra en signatur fra én underskriver. FROST (Flexible Round-Optimized Schnorr Threshold) leverer tærskelbaserede Schnorr-signaturer i to runder. Schnorr-aggregering kræver dog interaktion mellem underskriverne (i modsætning til BLS' ikke-interaktive aggregering), hvilket gør den mindre egnet til store validatorsæt. BLS foretrækkes fortsat til blockchain-konsensus på grund af sin ikke-interaktive aggregering og effektive batchverificering.

BLS-signaturer er baseret på elliptiske kurveparringer, som er sårbare over for kvantecomputere, der kører Shors algoritme. En tilstrækkeligt kraftig kvantecomputer kunne beregne diskrete logaritmer i BLS12-381, bryde alle eksisterende BLS-signaturer og sætte sikkerheden i Ethereums konsensus ud af kraft. Tidsrammen er usikker, men NIST anslår, at kvantecomputere, der er relevante for kryptografi, kan være en realitet om 15-20 år. Ethereum og andre kæder, der er afhængige af BLS, bliver nødt til at migrere til postkvantesikre signatursystemer (CRYSTALS-Dilithium/ML-DSA eller SPHINCS+/SLH-DSA), inden denne trussel bliver til virkelighed. Migreringen kræver ændringer på protokolniveau i validatorregistrering, attestationsformater og verifikation af aggregerede signaturer.

BLS-signaturer bruger bilineære parringer på BLS12-381-kurver. Signaturer er 48-byte G1-punkter, og offentlige nøgler er 96-byte G2-punkter efter Ethereums konvention. Ikke-interaktiv aggregering kombinerer n signaturer til én værdi på 48 byte, som verificeres med n+1 parringer. Angreb med falske nøgler afværges ved hjælp af Proof of Possession under validatorregistreringen. Ethereum bruger BLS til at komprimere over 400.000 validatorattestationer pr. slot til kilobyte. Tærskelbaseret BLS gør det muligt at have distribuerede validatorer uden én enkelt indehaver af nøglen. BLS er paringsbaseret og ikke postkvantesikker, så det kræver en fremtidig migrering.