Onion routing
यह क्यों मायने रखता है जब आप Tor इस्तेमाल करते हैं, तो आपके संदेश तीन अजनबियों के कंप्यूटरों से गुज़रते हैं। ठीक-ठीक जानना कि उनमें से हर कंप्यूटर क्या देख सकता है आपको बताता है कि Tor किसकी रक्षा करता है, और क्या खुला छोड़ता है। इस lab में आप परतें ख़ुद बनाते हैं, ताकि विचार जादू न रहे।
तीन लिफ़ाफ़ों के अंदर एक चिट्ठी की कल्पना करें, एक के अंदर दूसरा। आप बंडल एक पहले courier को देते हैं। वे बाहरी लिफ़ाफ़ा खोलते हैं, उसमें सिर्फ़ एक दूसरे courier का नाम पाते हैं, और बाक़ी आगे दे देते हैं। दूसरा courier अगला लिफ़ाफ़ा खोलता है और एक तीसरे का नाम पाता है। सिर्फ़ तीसरा courier आख़िरी लिफ़ाफ़ा खोलता है और देखता है कि चिट्ठी असल में कहाँ जा रही है।
कोई अकेला courier यह दोनों नहीं जानता कि चिट्ठी किसने भेजी और वह कहाँ पहुँचती है। यही पूरी तरकीब है, और इसका एक नाम है।
Onion routing: encryption की कई परतों में लिपटा एक संदेश कंप्यूटरों की एक श्रृंखला से भेजना, जहाँ हर एक ठीक एक परत हटाता है। प्याज़ छीलने की तरह, इसलिए यह नाम।
Relay: एक onion-routing network का एक कंप्यूटर जो traffic आगे भेजता है। Tor के relays दुनिया भर के volunteers चलाते हैं।
Circuit: relays की वह श्रृंखला जो आपका traffic लेता है, आपके अपने device की चुनी। Tor में एक circuit में सामान्यतः तीन relays होते हैं: एक guard, एक middle और एक exit।
कौन क्या जानता है
| Relay | जानता है कि आप कौन हैं (आपका IP address)? | जानता है कि आप कहाँ जा रहे हैं? |
|---|---|---|
| Guard (पहला) | हाँ | नहीं, सिर्फ़ middle relay |
| Middle | नहीं, सिर्फ़ guard | नहीं, सिर्फ़ exit |
| Exit (आख़िरी) | नहीं, सिर्फ़ middle relay | हाँ, और वह traffic पढ़ सकता है जब तक साइट HTTPS इस्तेमाल न करे |
कुछ भी निकलने से पहले आपका device सारा लपेटना करता है। यह हर relay के साथ एक अलग गुप्त key साझा करता है (असली Tor में ये keys बारी-बारी हर relay के साथ एक key exchange से आती हैं)। क्योंकि guard को पहले छीलना है, उसकी परत को सबसे बाहरी होना होगा, इसलिए आप परतें अंदर से बाहर बंद करते हैं: पहले exit की परत, फिर middle की, फिर guard की।
अभ्यास दुनिया के relays
module watched.leg7b_onion आपको पेड़ों के नाम पर बारह काल्पनिक relays देता है। हर एक के पास एक name, एक key (एक पूर्ण संख्या) और flags हैं। is_guard सेट वाला relay पहला hop होने के लिए भरोसेमंद है; is_exit सेट वाला वेबसाइटों से बाहर जुड़ने को राज़ी है। कुछ relays के पास दोनों flags हैं, कुछ के पास कोई नहीं।
import random
from watched.leg7b_onion import relays, lock, unlock
rs = relays(seed=1)
print([r.name for r in rs if r.is_exit]) # the relays allowed to be exits
secret = lock(42, "hello") # one layer, locked with key 42
print(secret) # unreadable hex text
print(unlock(42, secret)) # hello
rng = random.Random(7) # a seeded random generator
print(rng.choice(["a", "b", "c"])) # picks one item at random, the same one every runlock एक सिखाने का खिलौना है जो सुरक्षित नहीं है। यह सिर्फ़ इसलिए है ताकि आप परतों को जुड़ते और हटते देख सकें। असली Tor जाँचे-परखे ciphers इस्तेमाल करता है।
हर परत के टेक्स्ट का रूप next hop|the rest है: अगले relay का नाम, एक bar अक्षर, फिर अब भी बंद अंदरूनी परतें। exit की परत में relay के नाम की जगह गंतव्य host होता है, और फिर संदेश ख़ुद। helper relay_views(onion, circuit, your_ip) आपका onion circuit से भेजता है और हर relay के लिए बताता है कि traffic कहाँ से came_from, कहाँ passed_to, और वह क्या read कर सका।
एक आम ग़लतफ़हमी: "Tor मेरा traffic वेबसाइट तक पूरे रास्ते encrypt करता है।" नहीं करता। आख़िरी परत exit पर उतरती है, इसलिए exit आपका भेजा जो भी है देखता है जब तक साइट ख़ुद HTTPS इस्तेमाल न करे। Tor छिपाता है कि कौन बात कर रहा है; HTTPS छिपाता है कि क्या कहा गया। आपको दोनों चाहिए।
दूसरी भाषाओं में
लपेटने का loop किसी भी भाषा में एक जैसा दिखता है: circuit पर उल्टा चलें, हर बार एक परत जोड़ते हुए।
// JavaScript
function wrap(message, destination, circuit, lock) {
const hops = circuit.slice(1).map(r => r.name).concat([destination]);
let data = message;
for (let i = circuit.length - 1; i >= 0; i--) {
data = lock(circuit[i].key, hops[i] + "|" + data);
}
return data;
}// Go
func wrap(message, destination string, circuit []Relay) string {
hops := []string{}
for _, r := range circuit[1:] { hops = append(hops, r.Name) }
hops = append(hops, destination)
data := message
for i := len(circuit) - 1; i >= 0; i-- {
data = lock(circuit[i].Key, hops[i]+"|"+data)
}
return data
}// Rust
fn wrap(message: &str, destination: &str, circuit: &[Relay]) -> String {
let mut hops: Vec<String> = circuit[1..].iter().map(|r| r.name.clone()).collect();
hops.push(destination.to_string());
let mut data = message.to_string();
for i in (0..circuit.len()).rev() {
data = lock(circuit[i].key, &format!("{}|{}", hops[i], data));
}
data
}सार
- Onion routing एक संदेश को हर relay के लिए एक परत में लपेटता है; हर relay ठीक एक छीलता है।
- guard आपको जानता है पर आपका गंतव्य नहीं; exit गंतव्य जानता है पर आपको नहीं; middle दोनों में से कुछ नहीं जानता।
- परतें अंदर से बाहर बंद करें: पहले exit की, आख़िर में guard की।
- Tor छिपाता है कि कौन बात कर रहा है। सिर्फ़ HTTPS exit से छिपाता है कि क्या कहा गया।
watched.leg7b_onion के काल्पनिक relays इस्तेमाल करें। दो functions लिखें:
build_circuit(relays, rng): एक सूची[guard, middle, exit]लौटाएँ। guard कोrng.choiceसे उन relays में से चुनें जिनकाis_guardसही है; exit को उन relays में से जिनकाis_exitसही है और जो guard नहीं हैं; middle को उन relays में से जो न guard हैं न exit (उनके flags जो भी हों)। कुछ relays के पास दोनों flags हैं, इसलिए जाँचें कि तीनों अलग हैं।wrap(message, destination, circuit): हर relay के लिए एक परत बंद करें। guard की परत का टेक्स्टmiddle name|...है, middle काexit name|...है, और exit काdestination|messageहै।lock(relay.key, text)इस्तेमाल करते हुए पहले exit की परत बंद करें और आख़िर में guard की, और सबसे बाहरी बंद टेक्स्ट लौटाएँ।
इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें
यह अभ्यास जल्द खुलेगा
इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।
यह ब्राउज़र learn.floati.life के लिए कुकी रोक रहा है, इसलिए यहाँ पूरे किए गए पाठ क्रम से नहीं खुल सकते। इस साइट के लिए कुकी की अनुमति दें और फिर से लोड करें।