Skip to content
KitploitKITPLOIT
उपकरणएक्सप्लॉइटब्लॉग
Log in
जमा करें
उपकरणएक्सप्लॉइटब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

फ़ीडसंपर्कगोपनीयता© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
dlr-ne-ics-security — उन्नत स्थायी खतरों और मूविंग टारगेट डिफेंस के बीच स्टोकेस्टिक ICS सुरक्षा खेलों के लिए डायनामिकल लो-रैंक नैश इक्विलिब्रियम गणना को लागू करने वाला शोध कोड। | Kitploit
उपकरण/GitHubGitHub/tz98lab/dlr-ne-ics-security
रक्षात्मक उपकरणभेद्यता विश्लेषणSCADA/ICS सुरक्षाउपयोगिताएँ और फ्रेमवर्कमशीन लर्निंगपेपर और शोध
GitHubtz98lab/dlr-ne-ics-security

dlr-ne-ics-security

उन्नत स्थायी खतरों और मूविंग टारगेट डिफेंस के बीच स्टोकेस्टिक ICS सुरक्षा खेलों के लिए डायनामिकल लो-रैंक नैश इक्विलिब्रियम गणना को लागू करने वाला शोध कोड।

रिपॉजिटरी देखें
184 दिन पहलेअभी तक समीक्षित नहीं

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें

ICS सुरक्षा खेलों के लिए DLR-NE

Python 3.10+ License: MIT

उन्नत स्थायी खतरों और गतिशील लक्ष्य रक्षा के बीच स्टोकेस्टिक खेलों के लिए गतिक निम्न-रैंक संतुलन गणना

नियमित पेपर, Automatica में समीक्षा के अधीन (अक्टूबर 2026 में पुनः सबमिट किया गया)

अवलोकन

यह रिपॉजिटरी उच्च-आयामी औद्योगिक नियंत्रण प्रणाली (ICS) सुरक्षा खेलों में नैश संतुलन की गणना के लिए गतिक निम्न-रैंक नैश संतुलन (DLR-NE) एल्गोरिदम का कार्यान्वयन और प्रायोगिक सत्यापन प्रस्तुत करती है।

उन्नत स्थायी खतरों (APTs) और गतिशील लक्ष्य रक्षा (MTDs) के बीच रणनीतिक अंतःक्रिया को आयाम $n \sim 10^3$–$10^4$ के सतत अवस्था स्थान पर एक दो-खिलाड़ी शून्य-योग स्टोकेस्टिक खेल के रूप में मॉडल किया गया है। मुख्य अंतर्दृष्टि यह है कि हमले और रक्षा चैनलों का भौतिक निम्न-रैंक युग्मन (ICS नेटवर्क टोपोलॉजी में अंतर्निहित एक संरचनात्मक गुण) संतुलन मूल्य फलन का सुगम निम्न-रैंक न्यूरल-नेटवर्क सन्निकटन सक्षम बनाता है, जिससे प्रति-पुनरावृत्ति जटिलता $\mathcal{O}(n^2)$ से घटकर $\mathcal{O}(nr^2)$ हो जाती है, जो $\Theta(n/r^2)$ की गति वृद्धि है।

मुख्य सैद्धांतिक योगदान

प्रमेयकथनप्रयोग
प्रमेय 1इष्टतम मूल्य फलन $V^*$ के लिए वैश्विक निम्न-रैंक सन्निकटन त्रुटि बाध्यप्रयोग 1
प्रमेय 2स्पष्ट स्थिर-अवस्था त्रुटि अपघटन के साथ DLR-NE का ज्यामितीय अभिसरणप्रयोग 2
प्रमेय 3प्रति-पुनरावृत्ति जटिलता $\mathcal{O}(nr^2)$ और पूर्ण-रैंक आधारों पर गति वृद्धि $\Theta(n/r^2)$प्रयोग 3
उपप्रमेय 1खेल-सैद्धांतिक मजबूती: संतुलन संवेदनशीलता शर्त संख्या $\kappa(S)$ द्वारा नियंत्रित होती हैप्रयोग 4

रिपॉजिटरी संरचना

dlr-ne-ics-security/
├── src/                          # Core algorithmic modules
│   ├── environment.py            # Synthetic nonlinear power-system dynamics
│   ├── networks.py               # Low-rank and full-rank neural networks
│   ├── bellman.py                # Bellman operator and greedy Nash policy extractor
│   ├── dlra_vi.py                # Algorithm 1: DLR-NE
│   └── utils.py                  # FLOPs accounting, EYM error, metrics
│
├── experiments/                  # Experimental scripts (one per theorem)
│   ├── exp01_truncation_error.py     # Theorem 1: Low-rank truncation error
│   ├── exp02_convergence.py          # Theorem 2: Convergence of DLR-NE
│   ├── exp03_complexity.py           # Theorem 3: Computational complexity
│   ├── exp04_robustness.py           # Corollary 1: Game-theoretic robustness
│   ├── exp05_tradeoff.py             # Compression-accuracy Pareto frontier
│   └── exp06_ablation.py             # Ablation: necessity of basis augmentation
│
├── data/                         # Generated datasets (excluded from git)
├── results/                      # Figures and logs (excluded from git)
├── notebooks/                    # Prototyping and visualization
├── requirements.txt              # Python dependencies
└── README.md                     # This file

स्थापना

पूर्वापेक्षाएँ

  • Python >= 3.10
  • NumPy, SciPy, Matplotlib, PyTorch (CPU या CUDA)

त्वरित सेटअप

# Clone the repository
git clone https://github.com/tz98lab/dlr-ne-ics-security.git
cd dlr-ne-ics-security

# Create a virtual environment (recommended)
python -m venv venv
source venv/bin/activate        # Linux/Mac
# venv\Scripts\activate         # Windows

# Install dependencies
pip install -r requirements.txt

आवश्यकताएँ

numpy>=1.24.0
scipy>=1.10.0
matplotlib>=3.7.0
torch>=2.0.0

प्रयोग

सभी प्रयोग स्व-निहित हैं और स्वतंत्र रूप से चलाए जा सकते हैं। प्रत्येक स्क्रिप्ट results/figures/ निर्देशिका में आंकड़े उत्पन्न करती है।

पैमाने पर नोट: डिफ़ॉल्ट कॉन्फ़िगरेशन त्वरित प्रदर्शन के लिए $n=200$ का उपयोग करते हैं। पेपर में रिपोर्ट किए गए पूर्ण-पैमाने के परिणामों ($n \sim 10^3$) को पुनः उत्पन्न करने के लिए, प्रत्येक स्क्रिप्ट के शीर्ष पर PowerSystemConfig को संशोधित करें (इनलाइन टिप्पणियाँ देखें)।

प्रयोग 1: निम्न-रैंक ट्रंकेशन त्रुटि (प्रमेय 1)

सत्यापित करता है कि ट्रंकेशन त्रुटि $|V_{\mathrm{full}} - \widehat{V}r|\infty$ रैंक $r$ के साथ घटती है और Eckart-Young-Mirsky सैद्धांतिक भविष्यवाणी के अनुरूप है।

python experiments/exp01_truncation_error.py

आउटपुट: results/figures/exp1_truncation_error.png
अपेक्षित: मापी गई त्रुटि (नीले वृत्त) सैद्धांतिक बाध्य $L_\phi |w_{\mathrm{out}}^*|2 R{\mathcal{X}} \epsilon_{\mathrm{EYM}}(r)$ (बैंगनी धराशायी रेखा) का अनुसरण करती है; एकवचन-मान स्पेक्ट्रम तीव्र क्षय दर्शाता है।

प्रयोग 2: DLR-NE का अभिसरण (प्रमेय 2)

दर $\gamma$ के साथ ज्यामितीय अभिसरण और स्पष्ट स्थिर-अवस्था त्रुटि पड़ोस $\varepsilon_{\mathrm{total}}/(1-\gamma)$ को सत्यापित करता है।

python experiments/exp02_convergence.py

आउटपुट: results/figures/exp2_convergence.png
अपेक्षित: त्रुटि वक्र पहले $\gamma^k$ लिफाफे के साथ घटते हैं, फिर आंतरिक-लूप बजट $s^$ द्वारा प्रभुत्व वाले पठार में मुड़ जाते हैं ($s^$ को आधा करने पर सटीकता में $\approx 20$ के कारक की लागत आती है); बैच आकार $N_b$ का तुलनात्मक रूप से नगण्य प्रभाव पड़ता है।

प्रयोग 3: कम्प्यूटेशनल जटिलता (प्रमेय 3)

$\mathcal{O}(nr^2)$ प्रति-पुनरावृत्ति जटिलता और पूर्ण-रैंक FC-NN आधारों पर $\Theta(n/r^2)$ गति वृद्धि को सत्यापित करता है।

python experiments/exp03_complexity.py

आउटपुट: results/figures/exp3_complexity.png
अपेक्षित: DLR-NE $n$ में रैखिक रूप से स्केल करता है (log-log में ढलान 1), FC-NN द्विघात रूप से स्केल करता है (ढलान 2); $n=2000, r=10$ पर मापी गई FLOPs गति वृद्धि $\approx 12\times$ (वॉल-क्लॉक $\approx 4\times$)।

प्रयोग 4: खेल-सैद्धांतिक मजबूती (उपप्रमेय 1)

रैखिक संबंध $|V(\cdot;\pi_D,\pi_A) - V(\cdot;\tilde{\pi}D,\pi_A)|\infty \le L_\kappa |\Delta S|F$ को एक परिमित, $\beta$-समायोज्य संवेदनशीलता स्थिरांक $L\kappa$ के साथ सत्यापित करता है जो शर्त संख्या $\kappa(S)$ द्वारा प्रमाणित है (एक प्राथमिक सर्वाधिक-खराब-स्थिति प्रमाणपत्र)।

python experiments/exp04_robustness.py

आउटपुट: results/figures/exp4_robustness.png
अपेक्षित: मूल्य विचलन $|\Delta S|_F$ में रैखिक है और ढलान स्पेक्ट्रल नियमितीकरण भार $\beta$ में घटती है; $\kappa(S)$ को $\beta$ बढ़ाकर संपीड़ित किया जाता है।

प्रयोग 5: संपीड़न–सटीकता व्यापार-बंद

संपीड़न अनुपात और संतुलन नीति उपयोगिता के बीच Pareto सीमा का अन्वेषण करता है।

python experiments/exp05_tradeoff.py

आउटपुट: results/figures/exp5_tradeoff.png
अपेक्षित: $r = 5$ पर सर्वोत्तम बिंदु: $\approx 2.3%$ उपयोगिता हानि पर $\approx 94%$ पैरामीटर संपीड़न।

प्रयोग 6: एब्लेशन—आधार संवर्धन की आवश्यकता

तीन प्रकारों की तुलना करता है: (i) पूर्ण एल्गोरिदम 1, (ii) निश्चित आधार, (iii) कोई रिट्रैक्शन नहीं।

python experiments/exp06_ablation.py

आउटपुट: results/figures/exp6_ablation.png
अपेक्षित: निश्चित-आधार प्रकार स्थिर हो जाता है; बिना-रिट्रैक्शन प्रकार अस्थिर है; पूर्ण एल्गोरिदम 1 नियंत्रित लागत पर स्थिर क्षय प्राप्त करता है।

पुनरुत्पादनशीलता कथन

सभी यादृच्छिक बीज निश्चित और रिपोर्ट किए गए हैं। प्रत्येक प्रयोग स्क्रिप्ट स्व-निहित है और डिफ़ॉल्ट $n=200$ कॉन्फ़िगरेशन के लिए एक मानक लैपटॉप (केवल CPU) पर निष्पादित की जा सकती है। पूर्ण-पैमाने के प्रयोग ($n \sim 10^3$) Intel Xeon Gold 6248R पर NVIDIA A100 40GB GPU के साथ आयोजित किए गए थे (केवल पूर्ण-रैंक आधारों को त्वरित करने के लिए उपयोग किया गया)।

मुख्य हाइपरपैरामीटर:

  • छूट कारक: $\gamma = 0.95$
  • सक्रियण: $\tanh$ ($L_\phi = 1$)
  • बैच आकार: $N_b = 512$ (LHS)
  • आंतरिक-लूप चरण: $s^* = 10$
  • स्पेक्ट्रल नियमितीकरण: $\beta = 0.1$ (डिफ़ॉल्ट)

पूर्ण पैरामीटर सूचियों के लिए src/utils.py और व्यक्तिगत प्रयोग स्क्रिप्ट देखें।

उद्धरण

यदि आप इस कोड का उपयोग करते हैं, तो कृपया उद्धृत करें:

टूल डाउनलोड करें