mkorman90/regipyRegipy एक os स्वतंत्र पायथन लाइब्रेरी है जो ऑफलाइन रजिस्ट्री हाइव्स को पार्स करने के लिए है।
# regipy
[](https://securityscorecards.dev/viewer/?uri=github.com/mkorman90/regipy)
> **⚠️ v6.0.0 में ब्रेकिंग बदलाव**
>
> संस्करण 6.0.0 में महत्वपूर्ण आधुनिकीकरण परिवर्तन शामिल हैं:
>
> - **Python 3.9+ आवश्यक** - Python 3.6, 3.7, और 3.8 के लिए समर्थन हटा दिया गया
> - **`attrs` लाइब्रेरी हटा दी गई** - डेटा क्लासेस अब Python के अंतर्निहित `dataclasses` मॉड्यूल का उपयोग करते हैं
> - यदि आपका कोड आंतरिक क्लासेस (`Cell`, `VKRecord`, `Value`, `Subkey`) आयात करता है और `attr.asdict()` जैसे `attrs` फ़ंक्शन का उपयोग करता है, तो `dataclasses.asdict()` पर स्विच करें
>
> पूर्ण विवरण के लिए [CHANGELOG](https://github.com/mkorman90/regipy/blob/master/CHANGELOG.md) देखें।
Regipy ऑफ़लाइन रजिस्ट्री हाइव्स (REGF हेडर वाली Hive फ़ाइलें) को पार्स करने के लिए एक Python लाइब्रेरी है। regipy में बहुत सारी क्षमताएँ हैं:
- लाइब्रेरी के रूप में उपयोग करें:
- रजिस्ट्री हाइव पर पुनरावृत्ति करें, रूट या किसी दिए गए पथ से, और सभी सबकीज़ और मान प्राप्त करें
- विशिष्ट सबकीज़ और मान पढ़ें
- रजिस्ट्री हाइव पर ट्रांज़ैक्शन लॉग लागू करें
- कमांड लाइन टूल्स
- पूरी रजिस्ट्री हाइव को json में डंप करें
- रजिस्ट्री हाइव पर ट्रांज़ैक्शन लॉग लागू करें
- रजिस्ट्री हाइव्स की तुलना करें
- एक मजबूत प्लगइन सिस्टम से प्लगइन्स निष्पादित करें (जैसे: amcache, shimcache, कंप्यूटर नाम निकालें...)
**Python 3.9 या उच्चतर आवश्यक है।**
## इंस्टॉलेशन
Regipy का नवीनतम संस्करण pypi से इंस्टॉल किया जा सकता है:
```bash
pip install regipy[full]
```
नोट: ``regipy[full]`` उन निर्भरताओं को इंस्टॉल करता है जिनके लिए कंपाइलेशन टूल्स की आवश्यकता होती है और इसमें कुछ समय लग सकता है।
``[full]`` को छोड़कर, शिथिल निर्भरताओं वाला संस्करण इंस्टॉल करना भी संभव है।
साथ ही, रिपॉजिटरी को क्लोन करके और निम्नलिखित निष्पादित करके स्रोत से इंस्टॉल करना संभव है:
```bash
pip install --editable .[full]
```
### Rust-accelerated बैकएंड (alpha)
कोर REGF पार्सर का एक वैकल्पिक Rust कार्यान्वयन एक opt-in बैकएंड के रूप में उपलब्ध है, जो PyPI पर अलग से
[`regipy-rs`](https://pypi.org/project/regipy-rs/) के रूप में प्रकाशित है:
```bash
pip install regipy[rust]
```
```python
from regipy.registry_rs import RegistryHive # instead of regipy.registry
reg = RegistryHive("/tmp/NTUSER.dat")
# Same API: get_key, iter_values, recurse_subkeys, plugins — everything
# works unchanged, including all regipy plugins.
```
यह एक drop-in प्रतिस्थापन है जिसे पूरे test-hive कॉर्पस पर शुद्ध-Python पार्सर के विरुद्ध 1:1 सत्यापित किया गया है — प्रत्येक key path, timestamp, value और plugin output, मेल खाते SHA-256 traversal digests द्वारा प्रमाणित (देखें
`regipy_tests/comparison_test.py` और [regipy-rs/BENCHMARKS.md](https://github.com/mkorman90/regipy/blob/master/regipy-rs/BENCHMARKS.md) का *Forensic parity evidence* अनुभाग)।
मानों के साथ पूर्ण traversal (`recurse_subkeys`), 3 रनों में से सर्वश्रेष्ठ:
| Hive | Keys | Python | Rust | Speedup |
| ------ | -----: | -------: | -----: | --------: |
| NTUSER.DAT | 1,812 | 173 ms | 5 ms | **38x** |
| UsrClass.dat | 6,205 | 948 ms | 17 ms | **55x** |
| amcache.hve | 2,105 | 837 ms | 12 ms | **67x** |
| SYSTEM | 30,756 | 23.1 s | 91 ms | **253x** |
| SYSTEM (Win10 1709) | 43,211 | 118.7 s | 111 ms | **1,068x** |
| SOFTWARE | 117,488 | 745.6 s | 292 ms | **2,550x** |
`cProfile` दिखाता है क्यों: Python बैकएंड में, traversal समय प्रति-रिकॉर्ड `construct` struct पार्सिंग और value डिकोडिंग द्वारा प्रभुत्व रखता है; Rust बैकएंड के साथ, पार्सर प्रोफ़ाइल से पूरी तरह गायब हो जाता है और एकमात्र शेष Python लागत लौटाए गए `Subkey` dataclasses का निर्माण है।
पूर्ण प्रोफ़ाइल, प्रति-hive digests और कुछ जानबूझकर किए गए विचलनों (दूषित hives पर exception प्रकार, cycle-guard व्यवहार) का दस्तावेज़ीकरण करने वाला एक अस्वीकरण [regipy-rs/BENCHMARKS.md](https://github.com/mkorman90/regipy/blob/master/regipy-rs/BENCHMARKS.md) में है;
`python regipy-rs/benchmark.py` पूरी रिपोर्ट को पुनः उत्पन्न करता है।
शुद्ध-Python पार्सर डिफ़ॉल्ट बना हुआ है और जब Rust बैकएंड इंस्टॉल नहीं है तो अप्रभावित रहता है।
## CLI
#### हेडर पार्स करें
```bash
regipy-parse-header ~/Documents/TestEvidence/Registry/SYSTEM
```
उदाहरण आउटपुट:
```
╒════════════════════════╤══════════╕
│ signature │ b'regf' │
├────────────────────────┼──────────┤
│ primary_sequence_num │ 11639 │
├────────────────────────┼──────────┤
│ secondary_sequence_num │ 11638 │
├────────────────────────┼──────────┤
│ last_modification_time │ 0 │
├────────────────────────┼──────────┤
│ major_version │ 1 │
├────────────────────────┼──────────┤
│ minor_version │ 5 │
├────────────────────────┼──────────┤
│ file_type │ 0 │
├────────────────────────┼──────────┤
│ file_format │ 1 │
├────────────────────────┼──────────┤
│ root_key_offset │ 32 │
├────────────────────────┼──────────┤
│ hive_bins_data_size │ 10534912 │
├────────────────────────┼──────────┤
│ clustering_factor │ 1 │
├────────────────────────┼──────────┤
│ file_name │ SYSTEM │
├────────────────────────┼──────────┤
│ checksum │ 0 │
╘════════════════════════╧══════════╛
[2019-02-09 13:46:12.111654] WARNING: regipy.cli: Hive is not clean! You should apply transaction logs
```
- किसी hive के हेडर को पार्स करते समय, checksum सत्यापन और transaction सत्यापन भी किए जाते हैं
#### पूरी hive को डिस्क पर डंप करें (इसमें कुछ समय लग सकता है)
```bash
regipy-dump ~/Documents/TestEvidence/Registry/NTUSER-CCLEANER.DAT -o /tmp/output.json
```
regipy-dump उपयोगिता JSON के बजाय timeline भी आउटपुट कर सकती है, `-t` फ़्लैग जोड़कर
#### Hive पर प्रासंगिक प्लगइन्स चलाएँ
```bash
regipy-plugins-run ~/Documents/TestEvidence/Registry/SYSTEM -o /tmp/plugins_output.json
```
hive प्रकार स्वचालित रूप से पहचाना जाएगा और प्रासंगिक प्लगइन्स निष्पादित किए जाएंगे।
[**अधिक जानकारी के लिए प्लगइन्स अनुभाग देखें**](https://github.com/mkorman90/regipy/blob/master/docs/PLUGINS.md)
#### रजिस्ट्री हाइव्स की तुलना करें
एक ही प्रकार की रजिस्ट्री हाइव्स की तुलना करें और CSV में आउटपुट करें (यदि `-o` निर्दिष्ट नहीं है तो आउटपुट स्क्रीन पर प्रिंट होगा)
```bash
regipy-diff NTUSER.dat NTUSER_modified.dat -o /tmp/diff.csv
```
उदाहरण आउटपुट:
```
[2019-02-11 19:49:18.824245] INFO: regipy.cli: Comparing NTUSER.DAT vs NTUSER_modified.DAT
╒══════════════╤══════════════╤════════════════════════════════════════════════════════════════════════════════╤════════════════════════════════════════════════╕
│ difference │ first_hive │ second_hive │ description │
╞══════════════╪══════════════╪════════════════════════════════════════════════════════════════════════════════╪════════════════════════════════════════════════╡
│ new_subkey │ │ 2019-02-11T19:46:31.832134+00:00 │ \Software\Microsoft\legitimate_subkey │
├──────────────┼──────────────┼────────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────┤
│ new_value │ │ not_a_malware: c:\temp\legitimate_binary.exe @ 2019-02-11 19:45:25.516346+00:00 │ \Software\Microsoft\Windows\CurrentVersion\Run │
╘══════════════╧══════════════╧════════════════════════════════════════════════════════════════════════════════╧════════════════════════════════════════════════╛
[2019-02-11 19:49:18.825328] INFO: regipy.cli: Detected 2 differences
```
## ट्रांज़ैक्शन लॉग का उपयोग करके रजिस्ट्री हाइव रिकवर करें
```bash
regipy-process-transaction-logs NTUSER.DAT -p ntuser.dat.log1 -s ntuser.dat.log2 -o recovered_NTUSER.dat
```
रिकवर करने के बाद, क्या बदला यह देखने के लिए registry-diff के साथ hives की तुलना करें
## लाइब्रेरी के रूप में उपयोग करना
#### रजिस्ट्री hive ऑब्जेक्ट आरंभ करें
```python
from regipy.registry import RegistryHive
reg = RegistryHive("/Users/martinkorman/Documents/TestEvidence/Registry/Vibranium-NTUSER.DAT")
```
#### रूट key से, पूरी hive पर पुनरावृत्ति करें
```python
for entry in reg.recurse_subkeys(as_json=True):
print(entry)
```
#### एक key पर पुनरावृत्ति करें और सभी subkeys और उनके संशोधन समय प्राप्त करें
```python
for sk in reg.get_key('Software').iter_subkeys():
print(sk.name, convert_wintime(sk.header.last_modified).isoformat())
Adobe 2019-02-03T22:05:32.525965
AppDataLow 2019-02-03T22:05:32.526047
McAfee 2019-02-03T22:05:32.526140
Microsoft 2019-02-03T22:05:32.526282
Netscape 2019-02-03T22:05:32.526352
ODBC 2019-02-03T22:05:32.526521
Policies 2019-02-03T22:05:32.526592
```
#### एक key के मान प्राप्त करें
```python
reg.get_key("Software\Microsoft\Internet Explorer\BrowserEmulation").get_values(as_json=True)
[
{"name": "CVListTTL", "value": 0, "value_type": "REG_DWORD", "is_corrupted": False},
{"name": "UnattendLoaded", "value": 0, "value_type": "REG_DWORD", "is_corrupted": False},
{"name": "TLDUpdates", "value": 0, "value_type": "REG_DWORD", "is_corrupted": False},
{"name": "CVListXMLVersionLow", "value": 2097211, "value_type": "REG_DWORD", "is_corrupted": False},
{"name": "CVListXMLVersionHigh", "value": None, "value_type": "REG_DWORD", "is_corrupted": False},
{"name": "CVListLastUpdateTime", "value": None, "value_type": "REG_DWORD", "is_corrupted": False},
{"name": "IECompatVersionHigh", "value": None, "value_type": "REG_DWORD", "is_corrupted": False},
{"name": "IECompatVersionLow", "value": 2097211, "value_type": "REG_DWORD", "is_corrupted": False},
{"name": "StaleCompatCache", "value": 0, "value_type": "REG_DWORD", "is_corrupted": False},
]
```
#### प्लगइन के रूप में उपयोग करें
```python
from regipy.plugins.ntuser.ntuser_persistence import NTUserPersistencePlugin
NTUserPersistencePlugin(reg, as_json=True).run()
{
"Software\\Microsoft\\Windows\\CurrentVersion\\Run": {
"timestamp": "2019-02-03T22:10:52.655462",
"values": [
{
"name": "Sidebar",
"value": "%ProgramFiles%\\Windows Sidebar\\Sidebar.exe /autoRun",
"value_type": "REG_EXPAND_SZ",
"is_corrupted": False,
}
],
}
}
```
#### किसी विशिष्ट hive के लिए सभी प्रासंगिक प्लगइन्स चलाएँ
```python
from regipy.plugins.utils import run_relevant_plugins
reg = RegistryHive("/Users/martinkorman/Documents/TestEvidence/Registry/SYSTEM")
run_relevant_plugins(reg, as_json=True)
{
"routes": {},
"computer_name": [
{
"control_set": "ControlSet001\\Control\\ComputerName\\ComputerName",
"computer_name": "DESKTOP-5EG84UG",
"timestamp": "2019-02-03T22:19:28.853219",
}
],
}
```
## सत्यापन मामले
[सत्यापन मामले रिपोर्ट](https://github.com/mkorman90/regipy/blob/master/regipy_tests/validation/plugin_validation.md)
सभी नए प्लगइन्स में एक या अधिक बुनियादी सत्यापन मामले होने चाहिए (जिन्हें भविष्य में विस्तारित किया जा सकता है), उदाहरण के लिए:
```python
from regipy.plugins.system.bam import BAMPlugin
from regipy_tests.validation.validation import ValidationCase
class NTUserUserAssistValidationCase(ValidationCase):
# define your plugin class
plugin = BAMPlugin
# define the test file name, which should be present in `regipy_tests/data`
test_hive_file_name = "SYSTEM_WIN_10_1709.xz"
# Use `expected_entries` to test for presence of a few samples from the plugin results
expected_entries = [
{
"sequence_number": 9,
"version": 1,
"sid": "S-1-5-90-0-1",
"executable": "\\Device\\HarddiskVolume2\\Windows\\System32\\dwm.exe",
"timestamp": "2020-04-19T09:09:35.731816+00:00",
"key_path": "\\ControlSet001\\Services\\bam\\state\\UserSettings\\S-1-5-90-0-1",
}
]
# OR use `exact_expected_result` to test for an exact result:
exact_expected_result = [
{
"sequence_number": 9,
"version": 1,
"sid": "S-1-5-90-0-1",
"executable": "\\Device\\HarddiskVolume2\\Windows\\System32\\dwm.exe",
"timestamp": "2020-04-19T09:09:35.731816+00:00",
"key_path": "\\ControlSet001\\Services\\bam\\state\\UserSettings\\S-1-5-90-0-1",
},
{
"sequence_number": 8,
"version": 1,
"sid": "S-1-5-90-0-1",
"executable": "\\Device\\HarddiskVolume2\\Windows\\System32\\cmd.exe",
"timestamp": "2020-04-19T09:09:34.544224+00:00",
"key_path": "\\ControlSet001\\Services\\bam\\state\\UserSettings\\S-1-5-90-0-1",
},
]
expected_entries_count = 2
```
## विकास
### विकास के लिए सेटअप
```bash
# Clone the repository
git clone https://github.com/mkorman90/regipy.git
cd regipy
# Install in development mode with all dependencies
pip install -e ".[full,dev]"
# Install pre-commit hooks
pre-commit install
```
### परीक्षण चलाना
```bash
# Run all tests
pytest
# Run specific test files
pytest regipy_tests/tests.py
pytest regipy_tests/cli_tests.py
# Run plugin validation
PYTHONPATH=. python regipy_tests/validation/plugin_validation.py
```
### कोड गुणवत्ता
```bash
# Run linter
ruff check .
# Run formatter
ruff format .
# Run type checker
mypy regipy/
```
### GitHub Actions को स्थानीय रूप से परीक्षण करना
पुश करने से पहले CI वर्कफ़्लो परिवर्तनों का स्थानीय रूप से परीक्षण करने के लिए, [act](https://github.com/nektos/act) का उपयोग करें:
```bash
# Install act (Fedora)
sudo dnf install act-cli
# Install act (macOS)
brew install act
# Install act (other)
# See https://nektosact.com/installation/index.html
```
सुनिश्चित करें कि Docker चल रहा है, फिर:
```bash
# List available jobs
act -l
# Run the lint job
act -j lint
# Run all jobs for a push event
act push
# Run the test job with a specific Python version
act -j test
# Test the build job from publish workflow (simulates a release)
act release -j build --eventpath /dev/stdin <<< '{"action": "published"}'
```
नोट: कुछ jobs के लिए secrets की आवश्यकता हो सकती है। आप उन्हें इस प्रकार प्रदान कर सकते हैं:
```bash
act -j publish --secret PYPI_API_TOKEN=your_token
```
## लाइसेंस
MIT