Needham–Schroeder-protokollet

Symmetriskt Needham–Schroeder-protokollschema

Needham –Schroeder-protokollet är ett av de två nyckeltransportprotokollen som är avsedda för användning över ett osäkert nätverk, båda föreslagna av Roger Needham och Michael Schroeder . Dessa är:

• Needham –Schroeder Symmetric Key Protocol , baserat på en symmetrisk krypteringsalgoritm . Det utgör grunden för Kerberos -protokollet. Detta protokoll syftar till att upprätta en sessionsnyckel mellan två parter i ett nätverk, vanligtvis för att skydda ytterligare kommunikation.
• Needham –Schroeder Public-Key Protocol , baserat på public-key kryptografi . Detta protokoll är avsett att tillhandahålla ömsesidig autentisering mellan två parter som kommunicerar på ett nätverk, men i sin föreslagna form är det osäkert.

Det symmetriska protokollet

Här initierar Alice $(A)$ kommunikationen till Bob $B$ . $S$ är en server som båda parter litar på. I kommunikationen:

• $A$ och $B$ är identiteter för Alice respektive Bob
• ${K_{AS}}$ är en symmetrisk nyckel som endast är känd för $A$ och $S$
• ${K_{BS}}$ är en symmetrisk nyckel som endast är känd för $B$ och $S$
• $N_{A}$ och N $\displaystyle N_{B}}$ är nonser genererade av $A$ respektive $B$
• ${K_{AB}}$ är en symmetrisk, genererad nyckel, som kommer att vara sessionsnyckeln för sessionen mellan $A$ och $B$

Protokollet kan specificeras enligt följande i säkerhetsprotokollnotation :

$A\rightarrow S:\left.A,B,N_{A}\right.$

Alice skickar ett meddelande till servern som identifierar sig själv och Bob och berättar för servern att hon vill kommunicera med Bob.

$S\rightarrow A:\{N_{A},K_{AB},B, \{K_{AB},A\}_{K_{BS}}\}_{K_{AS}}$

Servern genererar ${K_{AB}}$ och skickar tillbaka till Alice en kopia krypterad under ${K_{BS}}$ för Alice att vidarebefordra till Bob och även en kopia för Alice . Eftersom Alice kan begära nycklar för flera olika personer, försäkrar nonce Alice att meddelandet är färskt och att servern svarar på just det meddelandet och inkluderingen av Bobs namn talar om för Alice vem hon är att dela denna nyckel med.

$A\rightarrow B:\{K_{AB},A\}_{K_{BS}}$

Alice vidarebefordrar nyckeln till Bob som kan dekryptera den med nyckeln han delar med servern och på så sätt autentisera data.

$B\rightarrow A:\{N_{B}\}_{K_{AB}}$

Bob skickar Alice en nonce krypterad under ${K_{AB}}$ för att visa att han har nyckeln.

$A\rightarrow B:\{N_{B}-1\}_{K_{AB}}$

Alice utför en enkel operation på nonce, omkrypterar den och skickar tillbaka den för att verifiera att hon fortfarande lever och att hon har nyckeln.

Attacker mot protokollet

Protokollet är sårbart för en replay-attack (som identifierats av Denning och Sacco). Om en angripare använder ett äldre, komprometterat värde för $K_{AB}$ kan han sedan spela upp meddelandet $\{K_{AB},A\ }_{K_{BS}}$ till Bob, som kommer att acceptera det, eftersom han inte kan säga att nyckeln inte är färsk.

Att fixa attacken

Denna brist åtgärdas i Kerberos-protokollet genom att en tidsstämpel ingår . Det kan också fixas med hjälp av nonces som beskrivs nedan. I början av protokollet:

$A\rightarrow B:A$

Alice skickar en förfrågan till Bob.

${\displaystyle B\rightarrow A:\{A,\mathbf {N_{B}'} \}_{K_{BS}}} Bob$

svarar med ett nonce krypterad under sin nyckel med servern.

$A\rightarrow S:\left.A,B,N_{A},\{A,\mathbf {N_{ B}'} \}_{K_{BS}}\right.$

Alice skickar ett meddelande till servern som identifierar sig själv och Bob och talar om för servern att hon vill kommunicera med Bob.

${\displaystyle S\rightarrow A:\{N_{A},K_{AB },B,\{K_{AB},A,\mathbf {N_{B}'} \}_{K_{BS}}\}_{K_{AS}}} Notera inkluderingen av nonce$

.

Protokollet fortsätter sedan som beskrivits genom de tre sista stegen som beskrivs i det ursprungliga protokollet ovan . Observera att $N_{B}'$ är en annan nonce än $N_{B}$ . Inkluderingen av denna nya nonce förhindrar uppspelning av en komprometterad version av $\{K_{AB},A\}_{K_{BS}}$ eftersom ett sådant meddelande skulle måste ha formen $\{K_{AB},A,\mathbf {N_{B}'} \}_{K_{BS}}$ som angriparen inte kan förfalska eftersom hon inte har $K_{BS}$ .

Protokollet med offentlig nyckel

Detta förutsätter användningen av en krypteringsalgoritm med offentlig nyckel .

Här använder Alice $(A)$ och Bob $(B)$ en betrodd server $(S)$ för att distribuera publika nycklar på begäran. Dessa nycklar är:

• $K_{PA}$ och $K_{SA}$ , offentliga respektive privata halvor av ett krypteringsnyckelpar som tillhör $A$ ( $S$ står för "hemlig nyckel" här)
• $K_{PB}$ och $K_{SB}$ , liknande tillhörande $B$
• $K_{PS}$ och $K_{SS}$ , liknande tillhörande $S$ . (Observera att detta nyckelpar kommer att användas för digitala signaturer , dvs. $K_{SS}$ används för att signera ett meddelande och $K_{PS}$ används för verifiering. $K_{PS}$ måste vara känd för $A$ och $B$ innan protokollet startar.)

Protokollet fungerar som följer:

$A\rightarrow S:\left.A,B\right.$

$A$ begär $B$ s publika nycklar från $S$

$S\rightarrow A:\{K_{PB},B\}_{K_{SS}}$

$S$ svarar med den offentliga nyckeln $K_{PB}$ bredvid $B$ s identitet, signerad av servern för autentiseringsändamål.

$A\rightarrow B:\{N_{A},A\}_{K_{PB}}$

$A$ väljer en slumpmässig $N_{A}$ och skickar den till $B$ .

$B\rightarrow S:\left.B,A\right.$

$B$ vet nu att A vill kommunicera, så $B$ begär $A$ s publika nycklar.

$S\rightarrow B:\{K_{PA},A\}_{K_{SS}}$

Servern svarar.

$B\rightarrow A:\{N_{A},N_{B}\}_{K_{PA}}$

$B$ väljer en slumpmässig $N_{B}$ och skickar den till $A$ tillsammans med $N_{A}$ för att bevisa förmågan att dekryptera med $K_{SB}$ .

$A\rightarrow B:\{N_{B}\}_{K_{PB}}$

$A$ bekräftar $N_{B}$ till $B$ , för att bevisa förmågan att dekryptera med $K_{SA}$

I slutet av protokollet känner $A$ och $B$ varandras identiteter och känner till både $N_{A}$ och $N_{B}$ . Dessa nonces är inte kända för avlyssnare.

En attack mot protokollet

Detta protokoll är sårbart för en man-i-mitten-attack . Om en bedragare $I$ kan övertala $A$ att initiera en session med dem, kan de vidarebefordra meddelandena till $B$ och övertyga $B$ att han kommunicerar med $A$ .

Om du ignorerar trafiken till och från ${\displaystyle S} ,$ som är oförändrad, går attacken enligt följande:

$A\rightarrow I:\{N_{A},A\}_{K_{PI}}$

$A$ skickar $N_{A}$ till $I$ , som dekrypterar meddelandet med $K_{SI}$

$I\rightarrow B:\{N_{A},A\}_{K_{PB}}$

$I$ vidarebefordrar meddelandet till $B$ och låtsas att $A$ kommunicerar

$B\rightarrow I:\{N_{A},N_{B}\}_{K_{PA}}$

$B$ skickar $N_{B}$

$I\rightarrow A:\{N_{A},N_{B}\}_{K_{PA}}$

$I$ vidarebefordrar den till $A$

$A\rightarrow I:\{N_{B}\}_{K_{PI}}$

$A$ dekrypterar $NB$ och bekräftar det till $I$ , som lär sig det

$I\rightarrow B:\{N_{B}\}_{K_{PB}}$

$I$ omkrypterar $N_{B}$ och övertygar $B$ att hon har dekrypterat det

I slutet av attacken tror ${\displaystyle B} felaktigt att$$A$ kommunicerar med honom och att $N_{A}$ och $N_{B}$ är bara kända för $A$ och $B$ .

Följande exempel illustrerar attacken. Alice (A) skulle vilja kontakta sin bank (B). Vi antar att en bedragare (I) framgångsrikt övertygar A om att de är banken. Som en följd av detta använder A den publika nyckeln för I istället för att använda den offentliga nyckeln för B för att kryptera de meddelanden hon avser att skicka till sin bank. Därför skickar A I sin nonce krypterad med den offentliga nyckeln av I. Jag dekrypterar meddelandet med deras privata nyckel och kontakter B skickar det nonce av A krypterad med den offentliga nyckeln för B. B har inget sätt att veta att detta meddelande var faktiskt skickat av I. B svarar med sitt eget nonce och krypterar meddelandet med den offentliga nyckeln för A. Eftersom I inte är i besittning av den privata nyckeln till A måste de vidarebefordra meddelandet till A utan att känna till innehållet. A dekrypterar meddelandet med sin privata nyckel och svarar med nonce av B krypterad med den offentliga nyckeln av I. Jag dekrypterar meddelandet med deras privata nyckel och är nu i besittning av nonce A och B. Därför kan de nu utge sig för att vara banken respektive klienten.

Åtgärda man-i-mitten-attacken

Attacken beskrevs först i en tidning 1995 av Gavin Lowe . Tidningen beskriver också en fast version av schemat, kallat Needham-Schroeder-Lowe-protokollet . Korrigeringen innebär ändring av meddelande sex för att inkludera svarandens identitet, det vill säga vi ersätter:

$B\rightarrow A:\{N_{A},N_{B}\}_{K_{PA}}$

med den fasta versionen:

$B\rightarrow A:\{N_{A},N_{B},B\}_{K_{PA}}$

och inkräktaren kan inte spela upp meddelandet igen eftersom A förväntar sig ett meddelande som innehåller identiteten för I medan meddelandet kommer att ha identiteten B.

Se även

• Kerberos
• Otway–Rees protokoll
• Yahalom
• Wide Mouth Frog-protokoll
• Neuman–Stubblebine-protokollet
• Diffie-Hellman nyckelbyte

externa länkar

• Roger Needham och Michael Schroeder (1978). "Needham-Schroeder Public Key" . Laboratoire Spécification et Verification. {{ citera webben }} : CS1 underhåll: använder författarens parameter ( länk )

• Roger Needham och Michael Schroeder (1978). "Needham Schroeder symmetrisk nyckel" . Laboratoire Spécification et Verification. {{ citera webben }} : CS1 underhåll: använder författarens parameter ( länk )

• Gavin Lowe (1995). "Lowes fasta version av Needham-Schroder Public Key" . Laboratoire Spécification et Verification. {{ citera webben }} : CS1 underhåll: använder författarens parameter ( länk )
• Förklaring av man-in-the-middle-attack av Computerphile .