ZAP Messaging Application ⚙️🖧🔐📡🛠️

Peer-to-peer link-layer messaging system implemented in Python 🐍. ZAP constructs and parses custom Ethernet frames (EtherType 0x88B5) to deliver text messages and files directly between MAC addresses on the same LAN — no IP/TCP/UDP required. 🧩🔗

Two user entry points are provided: a desktop GUI (index.py) implemented with Tkinter (🖥️🎨) and a terminal CLI (main.py) for headless/scripted operation (⌨️📟). Both use the same low-level transmission engine. ⚙️🔁

Project Overview 🧭🔬

ZAP is designed for local networks where raw Ethernet access is available. Key capabilities include:

• 📡 Device discovery via link-layer broadcasts and neighbor detection
• 📦 Reliable, fragmented file transfer with batch ACKs and windowed flow control
• 💬 Peer-to-peer text messaging addressed by destination MAC
• 🖥️ GUI and CLI frontends sharing a common link-layer protocol

Project Structure 🗂️📂

Messaging-application/
├── main.py        # CLI entry point (⌨️)
├── index.py       # GUI entry point (Tkinter, 🖥️)
├── Enviar.py      # Transmitter: frame building, fragmentation, send logic (📤🛠️)
├── Recibir.py     # Receiver: raw socket listener, parsing, reassembly (📥🔎)
├── Detector.py    # Network interface detection & MAC utilities (🔍🧭)
├── Values.py      # Protocol constants and global configuration (⚙️📐)
├── assets/        # UI assets and test resources (🖼️)
└── __pycache__/    # Compiled Python files

Technical Summary 🧠💻

• 🐍 Language: Python 3.8+
• 🖧 Networking: Linux raw Ethernet sockets (AF_PACKET) — constructs/parses Ethernet frames directly using EtherType 0x88B5. Requires elevated privileges or CAP_NET_RAW.
• 🖥️ GUI: Tkinter (standard library) used by index.py.
• 🔁 Concurrency: threading + non-blocking sockets for parallel send/receive pipelines.
• 🧩 Protocol design: fragmentation for payloads larger than ~1450 bytes (MTU-aware), per-fragment IDs, sequence numbers, transfer IDs, and batch ACKs for file transfers.

⚠️ Note: Raw Ethernet access from user-space is limited on Windows/macOS. Use Linux (native or a privileged container) for full capabilities. 🐧📦

Protocol (high-level) 🔬📡

• EtherType: 0x88B5 — application frames identifier on the wire (🛠️).
• Frame types: Discovery (broadcast), Message (unicast), File Chunk (fragment), ACK/Control (reliability control).
• Fragmentation: payloads exceeding the threshold are split into numbered chunks; receiver reassembles chunks by transfer_id + sequence.
• Flow control: windowing and batched ACKs prevent receiver overload and manage retransmissions.

Component Details 🧩🔧

• main.py — CLI client: interactive commands (/list, /msg, /file, /broadcast) and logging (⌨️📝).
• index.py — Desktop UI: message timeline, device list, file chooser, and transfer progress indicators (🖥️🎛️).
• Enviar.py — Transmission engine: frame construction, fragmentation, send queue, retransmit logic, and rate/window control (📤🔁).
• Recibir.py — Reception engine: raw socket listener, EtherType filtering, header parsing, fragment reassembly, and delivery to UI/CLI (📥🔎).
• Detector.py — Interface utilities: enumerate interfaces, read MAC addresses, convert formats, detect container/host environments (🔍🧭).
• Values.py — Protocol constants: EtherType, frame type codes, default MTU/fragment sizes, timeout and retry settings (⚙️📐).

Running (quick) ▶️🛠️

The application requires raw Ethernet socket access. Typical usage on Linux (root or with CAP_NET_RAW):

GUI (desktop):

sudo -E python3 index.py

CLI (terminal):

sudo -E python3 main.py

Recommendations:

• Install Tkinter for GUI: sudo apt-get install -y python3-tk (Debian/Ubuntu) 🧩.
• To avoid running Python as root, grant CAP_NET_RAW to the interpreter: sudo setcap cap_net_raw+ep $(readlink -f $(which python3)) (advanced) 🔐.

Requirements & Environment ⚙️🧪

• Python 3.8+
• Linux kernel with AF_PACKET raw socket support (Debian/Ubuntu recommended) 🐧
• Root privileges or CAP_NET_RAW for raw Ethernet access 🔒
• Display server (X11/Wayland) for the GUI 🖥️ (optional for CLI)

Limitations & Troubleshooting 🛠️🔎

• Windows/macOS: user-space raw Ethernet is generally unsupported — limited functionality 🪟🍏.
• WSL: direct interface/raw Ethernet may be unavailable depending on WSL version 🐧🚧.
• Containers: use --network host and add capabilities (--cap-add=NET_RAW) to enable raw socket access (Docker: --cap-add=NET_RAW) 🐳⚙️.
• GUI issues: ensure python3-tk installed and a graphical session is running 🔧🖼️.

Security Considerations 🔐🛡️

Running at the link layer requires administrative privileges. ZAP frames are not encrypted by default — avoid use on untrusted networks without additional encryption or VPN tunneling. Consider application-layer encryption (e.g., symmetric keys) if confidentiality is required. 🔒🧰

Development & Testing 🔬🧪

• Uses Python standard library (socket, threading) — no external dependencies required for core features.
• Test in an isolated LAN or VM to avoid unintended frame injection on production networks. Use packet capture tools (tcpdump, wireshark) for debugging (monitor EtherType 0x88B5) 🕵️‍♂️📡.