NFTables -Pakete werden nach der Manipulation von Benutzerspace nicht empfangen ⇐ Linux

[Anonymous]

Ich versuche ein Programm zu erstellen, das das Ziel für einige eingehende Pakete ändert. Mein Programm empfängt diese Pakete gemäß einigen Druckanweisungen (jetzt für die Kürze entfernt) Änderungen, aber sie werden nie von ihrem neuen Ziel empfangen. :
xxx.xxx.xxx.xxx ist die IP des Geräts, auf dem ich dies ausführe. Nach meinem Verständnis sollte dies den gesamten Datenverkehr herausfiltern, der von einem externen Gerät stammt und für Port 5000 mit uDP oder TCP für Port 5000 bestimmt ist. Diese Pakete sollten an eine Warteschlange mit Index 0 gesendet werden.

Code: Select all

nft add table ip filter
nft add chain ip filter PREROUTING { type filter hook prerouting priority 0 \; }
nft add rule ip filter prerouting ip daddr xxx.xxx.xxx.xxx tcp dport 5000 queue num 0 bypass
nft add rule ip filter prerouting ip daddr xxx.xxx.xxx.xxx udp dport 5000 queue num 0 bypass
< /code>
Mit diesem Rost -Programm höre ich auf Pakete in der Warteschlange mit Index 0. Bis hier alles funktioniert (Pakete werden empfangen). Wenn ich die Pakete modifiziere und „sie auf“ senden “(ich kann sehen, dass Änderungen stattfinden), werden sie nicht in Port 8080 

empfangen (siehe unten).

Code: Select all

fn main() -> std::io::Result {
let mut queue = Queue::open()?;
queue.bind(0)?;
queue.set_recv_conntrack(0, true)?;
queue.set_recv_security_context(0, true)?;
queue.set_recv_uid_gid(0, true)?;

loop {
let mut msg = queue.recv()?;
let mut payload = msg.get_payload_mut().to_vec();

if let Some(ip_packet) = Ipv4Packet::new(&payload) {

if ip_packet.get_next_level_protocol() == IpNextHeaderProtocols::Udp {
let udp_start = ip_packet.get_header_length() as usize;

if let Some(mut udp_packet) = MutableUdpPacket::new(&mut payload[udp_start..]) {
udp_packet.set_destination(8080);

// Recalculate checksum
let checksum = util::checksum(udp_packet.packet(), 1);
udp_packet.set_checksum(checksum);

println!("{:?}", msg);
}
}
}
println!("Done");
msg.set_verdict(Verdict::Accept);
queue.verdict(msg)?
}
}

Bei Port 8080 Ich habe ein Programm gestartet, um zu überprüfen, ob Pakete ankommen. Dieses Programm erhält keine Pakete.

Code: Select all

from scapy.all import sniff, get_if_list
import socket
import netifaces
import threading
import sys
sys.stdout.reconfigure(line_buffering=True)

PORT = 8080  # Set the port to listen on
HOST = "0.0.0.0"  # Listen on all available network interfaces

def get_available_addresses():
addresses = {}
interfaces = netifaces.interfaces()
for iface in interfaces:
addrs = netifaces.ifaddresses(iface)
if netifaces.AF_INET in addrs:
for addr in addrs[netifaces.AF_INET]:
ip = addr['addr']
addresses[iface] = ip  # Store interface and its IP
return addresses

def get_active_interfaces():
interfaces = get_if_list()
return [iface for iface in interfaces]  # Include all interfaces, including loopback

def packet_callback(packet):
if packet.haslayer("IP"):
src_ip = packet["IP"].src
dst_ip = packet["IP"].dst
iface = packet.sniffed_on if hasattr(packet, 'sniffed_on') else "Unknown"
iface_ip = netifaces.ifaddresses(iface)[netifaces.AF_INET][0]['addr'] if iface in netifaces.interfaces() else "Unknown"

if packet.haslayer("TCP"):
src_port = packet["TCP"].sport
dst_port = packet["TCP"].dport
protocol = "TCP"
elif packet.haslayer("UDP"):
src_port = packet["UDP"].sport
dst_port = packet["UDP"].dport
protocol = "UDP"
else:
return
direction = "ingress" if dst_ip == iface_ip else "egress "

print(f"{direction} on[{iface}] {iface_ip}: {src_ip}:{src_port} -> {dst_ip}:{dst_port} ({protocol})")

def start_sniffing(ifaces):
sniff(filter=f"tcp port {PORT} or udp port {PORT}", prn=packet_callback, store=False, iface=ifaces)

if __name__ == "__main__":
addresses = get_available_addresses()
interfaces = get_active_interfaces()
print(f"Listening as {HOST}:{PORT}...")
print("Available addresses:")
< /code>
Dieser Python-Teil wird in einem Docker-Container mit einem benutzerdefinierten Netzwerk ausgeführt: < /p>
FROM python:3.12.9-bullseye

WORKDIR /app
RUN apt-get update && apt-get install -y tcpdump iproute2 net-tools && pip3 install --no-cache-dir scapy netifaces

COPY . .

CMD ["python3", "server.py"]
< /code>
docker build -t packet-listener .
docker network create --subnet=192.168.100.0/24 custom-net
docker run --net custom-net -p 8080:8080/tcp -p 8080:8080/udp --ip 192.168.100.50 packet-listener
< /code>
Wenn der Port des Python -Programms auf 5000 geändert wird, werden im Rostprogramm keine Pakete mehr eingegangen, aber sie kommen zum Python -Programm ein. Um mein Setup zu testen, sende ich Anfragen von einem anderen Gerät: Echo "Hallo" | nc -v -u xxx.xxx.xxx.xxx 5000