Perché lo scambio delle chiavi della libellula richiede caccia e beccaggio?
Lo schema di scambio della chiave della libellula (utilizzato da WPA3) ha ricevuto critiche perché il modo in cui sceglie un generatore del gruppo di curve ellittiche ("caccia e beccaggio") è un algoritmo a tempo non costante che lo rende vulnerabile agli attacchi del canale laterale.
La mia domanda è: perché si caccia e si becca?
Supponiamo che ci sia un generatore noto $G$ per un gruppo di prime dimensioni, quindi $G^P$ sarebbe anche un generatore dello stesso gruppo (se $P$non è un multiplo della dimensione del gruppo). Con$P$ essendo un numero derivato da password (come con lo schema della libellula così com'è), in questo modo si otterrebbe un generatore altrettanto casuale e imprevedibile come con la caccia e la beccata, no?
Dov'è l'errore in quel ragionamento?
Risposte
Dov'è l'errore in quel ragionamento?
Il problema è che consentirebbe a un utente malintenzionato di testare più password con lo stesso scambio, perdendo così le proprietà PAKE che stavamo cercando di ottenere.
Con la libellula, il lato onesto seleziona valori segreti $p, m$e restituisce i valori $s = p+m$ e $P = -m \cdot SKE$, dove $SKE$ è l '"elemento chiave segreto", cioè quello che suggerisci di derivare $SKE = [password]G$ (Lo sto scrivendo in notazione additiva perché caccia e becca entra in gioco in Dragonfly solo se stai usando curve ellittiche).
Quindi, la parte onesta riceve valori $s'$ e $P'$ dall'altro lato (l'avversario), quindi calcola la chiave segreta:
$$H( p( P' + s' \cdot SKE ))$$
e quindi invia un messaggio crittografato basato su quella chiave (ovvero, se l'avversario in qualche modo ottiene un'ipotesi sulla stessa chiave, può decrittografare il messaggio e quindi convalidare la chiave).
Con la tua proposta, l'attaccante conoscerà il log discreto di qualsiasi SKE, ovvero il valore $x$ st $xG = SKE$. Quindi, cosa può fare l'attaccante (dopo aver ricevuto i messaggi di errore dei colleghi onesti$s, P$ valori) è selezionare arbitrario $s', P'$ valori (per i quali conosce il logaritmo discreto di $P' = p'G$) e inviarli, quindi ricevere la password crittografata in base al valore calcolato dalla parte onesta.
Quindi, per ogni password nel suo dizionario, calcola il corrispondente $SKE$ e $xG = SKE$ e quindi calcola:
$$H( (p'+s'x)(sG + x^{-1}P))$$
Se l'ipotesi per SKE fosse corretta, questa è la stessa chiave segreta calcolata dalla parte onesta e che può essere convalidata.
Questo può essere considerato lo stesso perché, se lo SKE è il valore utilizzato dalla parte onesta, allora $pG = sG + x^{-1}P$ e $p' + s'x$ è il logaritmo discreto di $P' + s' \cdot SKE$
L'aggressore può eseguire tutti questi calcoli per ogni password nel suo dizionario, quindi può testare ogni password come risultato di un singolo scambio.
Ora, DragonFly non deve usare caccia e becca; ci sono altre trasformazioni note da hash a curva che convertono una password in un punto EC in un modo che non è possibile calcolare il log discreto. Tuttavia, DragonFly deve utilizzare un metodo simile ...