एक उदाहरण `Makefile` भी है जो इन सभी को लक्ष्यों में लपेटता है जिन्हें कई मॉडलों के लिए आसानी से साझा किया जा सकता है। यदि आपके पास [GNU make](https://www.gnu.org/software/make/) स्थापित है (लिनक्स वितरणों पर डिफ़ॉल्ट रूप से उपलब्ध, पर OSX पर नहीं), तो बस चलाएँ:

```bash
make help

आपके पास या तो अपने मॉडल के समान निर्देशिका में plantuml.jar होना चाहिए, या PLANTUML_PATH सेट करना चाहिए। सभी निर्भरताओं, जैसे `pandoc` या `Java` को स्थापित करने से बचने के लिए, स्क्रिप्ट को एक कंटेनर के अंदर चलाया जा सकता है:```
# do this only once
export USE_DOCKER=true
make image

# call this after every change in your model
make

The *stale_days* तर्क यह निर्धारित करने का प्रयास करता है कि मॉडल स्क्रिप्ट (जिसे आप लिख रहे हैं) और उस कोड के बीच दिनों में कितना अंतर है, जो मॉडल किए जा रहे सिस्टम को लागू करता है। आदर्श रूप से, सक्रिय रूप से विकसित सिस्टम के अधिकांश मामलों में वे काफी करीब होने चाहिए। आप अपने प्रोजेक्ट की धड़कन और अपने थ्रेट मॉडल की 'ताजगी' को मापने के लिए इसे समय-समय पर चला सकते हैं।

वर्तमान में उपलब्ध तत्व हैं: TM, Element, Server, ExternalEntity, Datastore, Actor, Process, SetOfProcesses, Dataflow, Boundary, Lambda, LLM और Agent।

एक तत्व के उपलब्ध गुणों को तत्व के नाम के बाद `--describe` का उपयोग करके सूचीबद्ध किया जा सकता है:```text

(pytm) ➜  pytm git:(master) ✗ ./tm.py --describe Element
Element class attributes:
  OS
  definesConnectionTimeout        default: False
  description
  handlesResources                default: False
  implementsAuthenticationScheme  default: False
  implementsNonce                 default: False
  inBoundary
  inScope                         Is the element in scope of the threat model, default: True
  isAdmin                         default: False
  isHardened                      default: False
  name                            required
  onAWS                           default: False

आपके पास [pytmGPT](https://chat.openai.com/g/g-soISG24ix-pytmgpt) का उपयोग करके गद्य से अपने मॉडल बनाने का विकल्प भी है!

### आरेख उत्पन्न करना

आरेख [Dot](https://graphviz.gitlab.io/) और [PlantUML](https://plantuml.com/) के रूप में आउटपुट होते हैं।

जब `--dfd` तर्क उपरोक्त `tm.py` फ़ाइल को दिया जाता है तो यह stdout पर आउटपुट उत्पन्न करता है, जिसे Data Flow Diagram उत्पन्न करने के लिए Graphviz के dot में भेजा जाता है:```bash

tm.py --dfd | dot -Tpng -o sample.png

यह आरेख उत्पन्न करता है:

seq.png

### रिपोर्ट बनाना

आरेखों और निष्कर्षों को टेम्पलेट में शामिल करके एक अंतिम रिपोर्ट तैयार की जा सकती है:```bash

tm.py --report docs/basic_template.md | pandoc -f markdown -t html > report.html

तत्वों के अनुसार परिणामों को समूहबद्ध करने के लिए, एक अधिक उन्नत, नेस्टेड लूप का उपयोग करें:```text
## Findings

{elements:repeat:{{item.findings:if:
### {{item.name}}

{{item.findings:repeat:
**Threat**: {{{{item.id}}}} - {{{{item.description}}}}

**Severity**: {{{{item.severity}}}}

**Mitigations**: {{{{item.mitigations}}}}

**References**: {{{{item.references}}}}

}}}}}

यदि आप एक Finding जोड़ रहे हैं, तो सुनिश्चित करें कि आप एक गंभीरता जोड़ें: "Very High", "High", "Medium", "Low", "Very Low".

## खतरे का डेटाबेस

सुरक्षा व्यवसायी के लिए, आप `TM.threatsFile` सेट करके अपनी स्वयं की खतरों की फ़ाइल प्रदान कर सकते हैं। इसमें इस प्रकार की प्रविष्टियाँ होनी चाहिए:```json
{
   "SID":"INP01",
   "target": ["Lambda","Process"],
   "description": "Buffer Overflow via Environment Variables",
   "details": "This attack pattern involves causing a buffer overflow through manipulation of environment variables. Once the attacker finds that they can modify an environment variable, they may try to overflow associated buffers. This attack leverages implicit trust often placed in environment variables.",
   "Likelihood Of Attack": "High",
   "severity": "High",
   "condition": "target.usesEnvironmentVariables is True and target.controls.sanitizesInput is False and target.controls.checksInputBounds is False",
   "prerequisites": "The application uses environment variables.An environment variable exposed to the user is vulnerable to a buffer overflow.The vulnerable environment variable uses untrusted data.Tainted data used in the environment variables is not properly validated. For instance boundary checking is not done before copying the input data to a buffer.",
   "mitigations": "Do not expose environment variable to the user.Do not use untrusted data in your environment variables. Use a language or compiler that performs automatic bounds checking. There are tools such as Sharefuzz [R.10.3] which is an environment variable fuzzer for Unix that support loading a shared library. You can use Sharefuzz to determine if you are exposing an environment variable vulnerable to buffer overflow.",
   "example": "Attack Example: Buffer Overflow in $HOME A buffer overflow in sccw allows local users to gain root access via the $HOME environmental variable. Attack Example: Buffer Overflow in TERM A buffer overflow in the rlogin program involves its consumption of the TERM environmental variable.",
   "references": "https://capec.mitre.org/data/definitions/10.html, CVE-1999-0906, CVE-1999-0046, http://cwe.mitre.org/data/definitions/120.html, http://cwe.mitre.org/data/definitions/119.html, http://cwe.mitre.org/data/definitions/680.html"
 }

#!/usr/bin/env python3
# Example tm2.py contents
# Run: python tm2.py --dfd | dot -Tpng -o sample_json.png

from pytm import (
    TM,
    Actor,
    Boundary,
    Classification,
    Data,
    Dataflow,
    Datastore,
    Lambda,
    Server,
    DatastoreType,
    Assumption,
    load,
)

json_file_string = './tests/input.json'
with open(json_file_string) as input_json:
    TM.reset()
    tm = load(input_json)
    tm.process()

```
हम `tm2.py` को उसी तरह कॉल कर सकते हैं जैसे हमने पहले किया था, यहाँ `--dfd` के साथ और फिर आउटपुट को Graphviz (`dot`) पर रीडायरेक्ट करें:```bash

python tm2.py --dfd | dot -Tpng -o sample_json.png

```
## स्लाइड्स बनाना!

एक बार जब खतरा मॉडल पूरा और तैयार हो जाता है, तो भयावह प्रस्तुति चरण आता है - और अब pytm आपकी मदद भी कर सकता है, एक टेम्पलेट के साथ जो आपके खतरा मॉडल को स्लाइड्स में व्यक्त करता है, (RevealMD)[https://github.com/webpro/reveal-md] की शक्ति का उपयोग करके! बस docs/revealjs.md टेम्पलेट का उपयोग करें और आपको कुछ सुंदर स्लाइड्स मिलेंगी, पूरी तरह से अनुकूलन योग्य, जिन्हें आप अपने ब्राउज़र से प्रस्तुत और साझा कर सकते हैं।



https://github.com/izar/pytm/assets/368769/30218241-c7cc-4085-91e9-bbec2843f838



## वर्तमान में समर्थित खतरे```text
INP01 - Buffer Overflow via Environment Variables
INP02 - Overflow Buffers
INP03 - Server Side Include (SSI) Injection
CR01 - Session Sidejacking
INP04 - HTTP Request Splitting
CR02 - Cross Site Tracing
INP05 - Command Line Execution through SQL Injection
INP06 - SQL Injection through SOAP Parameter Tampering
SC01 - JSON Hijacking (aka JavaScript Hijacking)
LB01 - API Manipulation
AA01 - Authentication Abuse/ByPass
DS01 - Excavation
DE01 - Interception
DE02 - Double Encoding
API01 - Exploit Test APIs
AC01 - Privilege Abuse
INP07 - Buffer Manipulation
AC02 - Shared Data Manipulation
DO01 - Flooding
HA01 - Path Traversal
AC03 - Subverting Environment Variable Values
DO02 - Excessive Allocation
DS02 - Try All Common Switches
INP08 - Format String Injection
INP09 - LDAP Injection
INP10 - Parameter Injection
INP11 - Relative Path Traversal
INP12 - Client-side Injection-induced Buffer Overflow
AC04 - XML Schema Poisoning
DO03 - XML Ping of the Death
AC05 - Content Spoofing
INP13 - Command Delimiters
INP14 - Input Data Manipulation
DE03 - Sniffing Attacks
CR03 - Dictionary-based Password Attack
API02 - Exploit Script-Based APIs
HA02 - White Box Reverse Engineering
DS03 - Footprinting
AC06 - Using Malicious Files
HA03 - Web Application Fingerprinting
SC02 - XSS Targeting Non-Script Elements
AC07 - Exploiting Incorrectly Configured Access Control Security Levels
INP15 - IMAP/SMTP Command Injection
HA04 - Reverse Engineering
SC03 - Embedding Scripts within Scripts
INP16 - PHP Remote File Inclusion
AA02 - Principal Spoof
CR04 - Session Credential Falsification through Forging
DO04 - XML Entity Expansion
DS04 - XSS Targeting Error Pages
SC04 - XSS Using Alternate Syntax
CR05 - Encryption Brute Forcing
AC08 - Manipulate Registry Information
DS05 - Lifting Sensitive Data Embedded in Cache
SC05 - Removing Important Client Functionality
INP17 - XSS Using MIME Type Mismatch
AA03 - Exploitation of Trusted Credentials
AC09 - Functionality Misuse
INP18 - Fuzzing and observing application log data/errors for application mapping
CR06 - Communication Channel Manipulation
AC10 - Exploiting Incorrectly Configured SSL
CR07 - XML Routing Detour Attacks
AA04 - Exploiting Trust in Client
CR08 - Client-Server Protocol Manipulation
INP19 - XML External Entities Blowup
INP20 - iFrame Overlay
AC11 - Session Credential Falsification through Manipulation
INP21 - DTD Injection
INP22 - XML Attribute Blowup
INP23 - File Content Injection
DO05 - XML Nested Payloads
AC12 - Privilege Escalation
AC13 - Hijacking a privileged process
AC14 - Catching exception throw/signal from privileged block
INP24 - Filter Failure through Buffer Overflow
INP25 - Resource Injection
INP26 - Code Injection
INP27 - XSS Targeting HTML Attributes
INP28 - XSS Targeting URI Placeholders
INP29 - XSS Using Doubled Characters
INP30 - XSS Using Invalid Characters
INP31 - Command Injection
INP32 - XML Injection
INP33 - Remote Code Inclusion
INP34 - SOAP Array Overflow
INP35 - Leverage Alternate Encoding
DE04 - Audit Log Manipulation
AC15 - Schema Poisoning
INP36 - HTTP Response Smuggling
INP37 - HTTP Request Smuggling
INP38 - DOM-Based XSS
AC16 - Session Credential Falsification through Prediction
INP39 - Reflected XSS
INP40 - Stored XSS
AC17 - Session Hijacking - ServerSide
AC18 - Session Hijacking - ClientSide
INP41 - Argument Injection
AC19 - Reusing Session IDs (aka Session Replay) - ServerSide
AC20 - Reusing Session IDs (aka Session Replay) - ClientSide
AC21 - Cross Site Request Forgery
DS06 - Data Leak
DR01 - Unprotected Sensitive Data
AC22 - Credentials Aging (deprecated)
AC23 - Credentials Disclosure
AC24 - Use of hardcoded credentials
LLM01 - Direct Prompt Injection
LLM02 - Indirect Prompt Injection via Retrieved Content
LLM03 - Sensitive Data Leakage to Third-Party Provider
LLM04 - Training Data Poisoning
LLM05 - Excessive Agency via Unauthorized Tool Use
LLM06 - Arbitrary Code Execution via LLM Agent
LLM07 - Jailbreaking and Safety Bypass
LLM08 - Sensitive Information Disclosure Through Output
LLM09 - Untrusted Tool Launch Configuration


```