it-swarm.dev

Perché un nodo di uscita Tor può decrittografare i dati, ma non il nodo di entrata?

Me -> Node A -> Node B -> Node C -> destination

La documentazione su Tor afferma sempre che solo il nodo di uscita C può vedere dati di testo semplice. Come è possibile senza che io parli con Node C direttamente?

Se ho alcuni dati in chiaro e desidero inviarli crittografati a Node A, di solito farei uno scambio di chiavi Diffie-Hellman e li invierò. Ma con quello schema, Node A potrebbe decrittografare i dati.

Se Node C condivideva in qualche modo la sua chiave pubblica con me, non poteva Node B o Node A MITM la chiave ?

In che modo Tor gestisce esattamente la sua PKI? Quali chiavi vengono utilizzate per crittografare i dati dove?

33
Petey B

Tor utilizza un metodo di routing chiamato Onion routing . Proprio come una cipolla, ogni messaggio (il nucleo della cipolla) è coperto da strati di crittografia. attrib:wikipediaattribuzione dell'immagine

Il tuo messaggio viene crittografato più volte prima di lasciare il dispositivo. Node A può solo decodificare (sbucciare) il livello A, sotto il quale vedrebbe l'indirizzo del nodo successivo. Dopo che il pacchetto ha raggiunto il nodo successivo, può solo decodificare (sbucciare) il livello B e così via. Per ogni livello, si utilizza la chiave pubblica del rispettivo nodo, quindi solo quel nodo esatto può decodificare il livello con la propria chiave privata.

Quando il messaggio raggiunge il nodo di uscita, tutti i livelli sono stati decrittografati e il messaggio è ora in testo normale (potrebbe anche essere crittografato se si sta comunicando con il server in SSL).

58
Adi

TOR utilizza il principio del routing delle cipolle. Supponiamo che siano coinvolti 3 nodi TOR A, B e C (selezionati casualmente dal cliente) e il messaggio è m. Partiamo dal presupposto che le corrispondenti chiavi pubbliche di questi nodi siano Pa, Pb e Pc.

Il messaggio viene ripetutamente crittografato dal client a partire dalla chiave pubblica del nodo di uscita (Pc) seguito da Pb e alla fine Pa (Onion Routing).

Data received by node A: Pa(Pb(Pc(m))) 
Data received by node B: Pb(Pc(m)) 
Data received by node C: Pc(m)  

I dati vengono decrittografati su ciascun nodo utilizzando la chiave privata corrispondente. Dopo la decrittografia, ciascun nodo ottiene alcune informazioni di testo in chiaro su dove inoltrare i dati rimanenti. Questo assicura che nessun singolo nodo conosce l'intero percorso. Ogni nodo conosce solo il nodo precedente e quello successivo.

post scriptum C'è un ottimo articolo su TOR nel nostro blog della comunità, ma in qualche modo non riesco a trovarlo. Se qualcuno trova il link, aggiungilo alla risposta.

17
Shurmajee

Ci sono due domande diverse qui:
1- come vengono inviati i dati e in che modo i nodi decrittografano ogni livello di crittografia?
2- come otteniamo i dati dal nodo di uscita?
A proposito della prima domanda, posso dire che non esiste una crittografia a chiave pubblica per l'invio di dati a destinazione, ma i segreti condivisi. Prima di questo dovresti sapere abbastanza su D-H .
Passaggi D-H:

  1. Alice e Bob concordano su un gruppo ciclico finito G e su un elemento generatore g in G. (Questo di solito viene fatto molto prima del resto del protocollo; si presume che g sia noto a tutti gli attaccanti.) Scriveremo il gruppo G in modo moltiplicativo.
  2. Alice sceglie un numero naturale casuale a e invia g ^ a a Bob.
  3. Bob sceglie un numero naturale casuale b e invia g ^ b ad Alice.
  4. Alice calcola (g ^ b) ^ a.
  5. Bob calcola (g ^ a) ^ b.

Dopo questi passaggi Alice e Bob hanno un Segreto condiviso e nessuno conosce questo Segreto condiviso.

Tor Steps:

  1. OP (proxy cipolla o sorgente) invia g ^ a a Nodo1 (router cipolla). (Ma crittografato dalla chiave pubblica di Nodo1)
  2. Il nodo 1 decodifica i dati con la chiave privata e quindi invia g ^ b a OP. (In chiaro. Perché se la chiave pubblica di OP è nota a OR allora dov'è la privacy !!).
  3. Ora OP e Nodo1 hanno un segreto condiviso [ad esempio: SS1 = OP e Nodo1 = 2].
  4. OP invia g ^ a al Nodo1 quale Nodo1 dovrebbe inviare al Nodo2 ('a' è un nuovo numero casuale)
    OP crittografa g ^ a con la chiave pubblica Node2 e crittografa i dati (en (g ^ a) e l'indirizzo Node2) con SS1.
  5. Nodo1 decodifica i dati con SS1 e ottiene l'indirizzo Nodo2 e invia g ^ a rimanenti crittografati a Nodo2.
  6. Node2 decodifica i dati con la sua chiave privata, quindi invia di nuovo g ^ b a Node1. (Cancella il testo)
  7. Nodo1 crittografa g ^ b con SS1 e invia a OP.
  8. OP decodifica i dati con SS1.
  9. Ora OP e Nodo2 hanno un Segreto condiviso che Nodo 1 non conosce [ad esempio: SS2 = OP e Nodo2 = 5].

Ciò continuerà fino al completamento del circuito. Ora OP può inviare la richiesta di destinazione tramite nodi con (SS1, SS2, ...). l'ultima richiesta di invio dovrebbe essere così:

OP al Nodo1 => encryptSS1 (invia a Nodo2, encryptSS2 (invia a destinazione, "ciao server"))

E sulla seconda domanda che riceve la risposta dovrebbe essere così:

  1. Dest to Node2 => "ciao client"
  2. Da Nodo2 a Nodo1 => encryptSS2 ("ciao client")
  3. Da Nodo1 a OP => encryptSS1 (encryptSS2 ("ciao client"))
  4. OP decryptSS1 (decryptSS2 (dati)).

Dai un'occhiata a un'immagine in questa pagina:
Instradamento delle cipolle - pikneek

1
M Rostami