पाठ्यक्रम 156 में से पाठ 96 · Threat modelling
Threat modelling

चरण 4 प्रोजेक्ट: एक threat model

यह क्यों मायने रखता है यह प्रोजेक्ट चरण 4 को साथ लाता है। आप एक ऐसे product का असली threat model लिखेंगे जो आप सचमुच इस्तेमाल करते हैं, Python डेटा के रूप में, और वह code जो उसे एक rubric के मुक़ाबले जाँचता है। आप एक ऐसे औज़ार के साथ ख़त्म करते हैं जिसे आप किसी भी product के लिए दोबारा इस्तेमाल कर सकते हैं, और उन तीन चीज़ों की एक साफ़ सूची के साथ जो आपको पहले ठीक करनी चाहिए।

काम

आपका इस्तेमाल किया एक product चुनें: एक messaging ऐप, एक fitness tracker, एक shopping साइट, एक smart speaker। उसका threat model एक उपयोगकर्ता के रूप में आपके नज़रिए से MODEL नाम की एक dictionary में लिखें, फिर तीन functions लिखें जो उसे जाँचें और rank करें।

निजी रखा: आपके code को आपके अपने ब्राउज़र में अंक मिलते हैं। अगर आप devices के पार सहेजना चालू करते हैं, तो आपके drafts Floati के server पर भी रखे जाते हैं, जो इसे सामान्य रखने का एक और कारण है। फिर भी, model सामान्य रखें: "मेरे संदेश" या "मेरा घर का पता" लिखें, कभी असली passwords, usernames, पते या खाता नंबर नहीं। एक threat model risk के आकार के बारे में है, राज़ों के बारे में नहीं।

MODEL का आकार

MODEL = {
    "product": "a fitness tracker app (fitly.example)",
    "assets": ["my running routes", "my heart-rate history", "my contacts"],
    "adversaries": [
        {"who": "advertisers", "wants": "my habits", "capability": "buy data from the app"},
        {"who": "a stranger", "wants": "where I live", "capability": "see public route maps"},
    ],
    "threats": [
        {"id": "T1", "asset": "my running routes", "adversary": "a stranger",
         "what": "public maps show where my runs start, near my home",
         "likelihood": 2, "impact": 3},
        # ... at least 4 threats
    ],
    "mitigations": [
        {"threat": "T1", "action": "hide the first and last 500 m of every route", "owner": "me"},
        # ... at least one for every threat
    ],
}

हर threat का asset आपके assets में से एक होना चाहिए, और हर threat का adversary एक adversary के "who" से मेल खाना चाहिए। यह model को जोड़ता है: हर threat ठीक बताता है कि वह किस पर चोट करता है और कौन करता है। owner बताता है कि mitigation कौन करता है: "me" या "product" (चीज़ें जो आप कंपनी से बदलने को कहेंगे)।

Rubric

जाँचविफल होने पर problem code
एक non-empty product नामno-product
कम से कम 3 assetsfew-assets
कम से कम 2 adversariesfew-adversaries
कम से कम 4 threatsfew-threats
हर threat का asset asset सूची में हैunknown-asset:T1 (उस threat की id के साथ)
हर threat का adversary एक "who" से मेल खाता हैunknown-adversary:T1
संभावना और असर हर एक 1, 2 या 3 हैंbad-score:T1
हर threat का कम से कम एक mitigation हैunmitigated:T1

आत्म-मूल्यांकन और tutor feedback

Tests जाँचते हैं कि आपका model पूरा है और जुड़ता है, और कि आपके functions सही हैं। वे यह नहीं परख सकते कि आपके threats सही threats हैं या नहीं। उसके लिए अपने शीर्ष तीन threats ज़ोर से पढ़ें और ख़ुद से पूछें: क्या इस product को जानने वाला कोई सहमत होगा कि ये सबसे बड़े risks हैं? आप अपने काम पर टिप्पणियों के लिए on-device tutor का code review button भी दबा सकते हैं। यह आपके ब्राउज़र में चलता है, इसलिए model आपके पास रहता है। यह एक छोटा model है, इसलिए इसके नोट्स को सोचने के संकेत मानें, फ़ैसला नहीं। स्वचालित जाँचें साबित करती हैं कि आपका model पूरा है; यह सही है या नहीं वह हिस्सा आप ख़ुद परखते हैं।

एक अच्छे model के लिए सुझाव

  • जो सीखा उसका इस्तेमाल करें: cookies, fingerprints, pixels और सहमति (चरण 1), code में trackers कैसे काम करते हैं (चरण 2), साइटों पर third parties और लीक (चरण 3), HTTPS और end-to-end encryption क्या छिपाते हैं और क्या नहीं, और AI features आपका टेक्स्ट कहाँ भेजते हैं।
  • कम से कम एक साधारण threat (एक दोहराया password, एक खोया फ़ोन) और एक product के बारे में (यह क्या इकट्ठा करता है, किससे साझा करता है) शामिल करें।
  • उन उपायों को तरजीह दें जो आप इस हफ़्ते सचमुच करेंगे, उन परफ़ेक्ट वालों पर जो आप नहीं करेंगे।
दूसरी भाषाओं में

JavaScript: एक दो-हिस्सा sort के साथ risk ranking।

const risk = t => t.likelihood * t.impact;
function topThreats(model, n = 3) {
  return [...model.threats]
    .sort((a, b) => risk(b) - risk(a) || a.id.localeCompare(b.id))
    .slice(0, n)
    .map(t => t.id);
}

Rust: sort_by के साथ वही क्रम।

threats.sort_by(|a, b| risk(b).cmp(&risk(a)).then(a.id.cmp(&b.id)));

सार

  • डेटा के रूप में एक threat model code से जाँचा जा सकता है: पूरा, जुड़ा हुआ और ranked।
  • Risk संभावना गुणा असर है; बराबरी threat id से तोड़ी जाती है ताकि क्रम हमेशा एक जैसा रहे।
  • Tests संरचना जाँचते हैं; आप और tutor परखते हैं कि threats सही हैं या नहीं।
  • अपना model सामान्य और निजी रखें: risks का वर्णन करें, राज़ कभी न लिखें।
आपकी बारी

आपके इस्तेमाल के एक product के लिए MODEL भरें (ऊपर का आकार देखें): एक "product" string, कम से कम 3 "assets", कम से कम 2 "adversaries" (हर एक non-empty "who", "wants" और "capability" के साथ), कम से कम 4 "threats" और हर threat के लिए एक mitigation (non-empty "action" और "me" या "product" के "owner" के साथ)। फिर लिखें:

  1. risk(threat): likelihood * impact लौटाता है।
  2. top_threats(model, n=3): n सबसे ऊँचे-risk threats की ids लौटाता है, सबसे ऊँचा पहले; जब दो threats का risk एक जैसा हो, तो छोटी id (सामान्य string क्रम में) पहले आती है।
  3. rubric(model): rubric table से problem codes की एक सूची लौटाता है, या model पास होने पर []। पहले चार model-भर के नियम जाँचें, फिर हर threat सूची क्रम में, asset, adversary, score, mitigation उस क्रम में जाँचते हुए। defaults के साथ .get इस्तेमाल करें ताकि ग़ायब keys वाला model crash न करे।
आख़िर में rubric(MODEL) और top_threats(MODEL) print करें।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।