sshportal is a transparent SSH bastion/jump host implemented in Go. It allows users to connect to remote hosts through a single point of entry, managing users, hosts, keys, and ACLs. The system features session logging, an interactive administrative shell, support for multi-hop connections, and various SSH features (port forwarding, X11, etc.). It uses a database (SQLite3 by default, MySQL/PostgreSQL supported) for persistence and provides a health check endpoint. The architecture is monolithic with clear separation of concerns: core bastion logic in pkg/bastion/, database models in pkg/dbmodels/, cryptographic utilities in pkg/crypto/, and utilities in pkg/utils/. The code demonstrates good use of interfaces and modular design, though some internal coupling exists between components.
PassWall is a LuCI application for OpenWrt routers that provides a unified management interface and runtime orchestration for proxy/VPN clients. In production it runs as a daemon-managed transparent proxy: it generates per-core JSON configurations for xray, sing-box, shadowsocks-rust, SSR, hysteria2, naiveproxy, and other engines; builds iptables/nftables transparent-proxy rules; integrates DNS-level routing through dnsmasq, smartdns, chinadns-ng, or dns2socks; and exposes a full web UI for node management, subscriptions, ACLs, shunt rules, health checks, load balancing via HAProxy, and server-side inbound configuration. The service is configured through UCI (`/etc/config/passwall`), with shell scripts as the main runtime dispatchers and Lua modules as the configuration-generation and LuCI-controller layer.
This is an Android application that serves as a GUI client for XTLS/Xray-core, a proxy/VPN tool. The app provides a comprehensive interface for managing proxy profiles, subscription links, and VPN configurations. It supports both standard VPN mode (using tun2socks) and transparent proxy mode (requiring root). The architecture follows MVVM with Room database for persistence, coroutines for async operations, and a native Go library (XrayCore) for core proxy functionality. The codebase is well-structured, using modern Android development practices (Kotlin, Jetpack libraries, Material Design 3). It includes features like QR code scanning, clipboard import, link management with auto-refresh, per-app routing, and a quick settings tile. The app is actively maintained with frequent updates and a CI/CD pipeline for release builds.
This repository provides a transparent proxy package for OpenWrt using Mihomo (a clash-compatible rule-based proxy core) as the backend. It is a full LuCI application that allows users to configure proxy modes (redirect, TPROXY, TUN), manage subscriptions, define access control rules, and monitor logs through a web interface. The system is designed for OpenWrt ≥24.10 with firewall4 (nftables) and kernel ≥5.13. The architecture consists of three OpenWrt packages: `nikki` (main service and scripts), `mihomo-meta` (stable core), and `mihomo-alpha` (alpha variant). The service is managed via procd init script (`nikki.init`), which handles starting/stopping Mihomo, setting up routing rules and nftables tables, and scheduling tasks. Configuration is stored in UCI (OpenWrt's standard configuration system) and processed through a pipeline: UCI options → `mixin.uc` (ucode script) generates a JSON overlay → `yq` merges it with a base profile → final Mihomo config. Traffic interception rules are generated dynamically from a utpl template (`hijack.ut`) that produces nftables rulesets. Key entry points include the LuCI views (`app.js`, `profile.js`, `mixin.js`, `proxy.js`, `editor.js`, `log.js`) for web-based management, the init script for service lifecycle, and shell scripts for installation/upgrade. External dependencies are Mihomo core, `yq` for YAML processing, and standard OpenWrt tools (procd, nftables, ucode). The repository also includes a large hardcoded nftables set of Chinese IP prefixes (`geoip_cn.nft`) for bypassing mainland China traffic.
This is a LuCI application package for OpenWrt routers that provides a full web-based management interface for Clash/Mihomo proxy services. It handles the complete proxy lifecycle: service management via procd, transparent proxy setup (TPROXY/TUN/MIXED modes), DNS manipulation, firewall rule generation via nftables/iptables, subscription management, and a real-time log viewer. The package installs to /opt/clash/ and integrates deeply with OpenWrt's hotplug, UCI, and LuCI systems. A separate Vue-based SPA dashboard (zashboard) is bundled for advanced features like Tailscale management, network diagnostics (bandwidth tests, STUN NAT detection), and an embedded SSH terminal. The architecture is a classic OpenWrt package: shell scripts for service and firewall management (/etc/init.d/clash, /opt/clash/bin/clash-rules), LuCI JavaScript views for the admin UI (config, settings, rulesets, log), hotplug scripts for network events, and a vendored Ace editor for YAML editing. The firewall engine is the most substantial component — roughly 1400 lines of modular shell that generates nftables/iptables rules, manages subscription IP caches with locking, and auto-generates fake-IP whitelists from rule providers. The init script includes rollback logic that restores DNS/firewall state on failure, preventing bricked router connectivity. The repository is explicitly legacy: the README states active development has moved to SSClash-Go (a single static binary with built-in web UI). This repo receives bugfix maintenance only. Technical drift is medium — the vendored Ace editor is an old version (1.5.0), the shell scripts use fragile heuristics for YAML transformation, GitHub API calls for kernel downloads lack caching, and the dual configuration (config.yaml plus /opt/clash/settings) can confuse users. However, the CI pipeline is maintained and the package builds for current OpenWrt versions (both ipk and apk formats). For reuse, the most valuable components are the modular firewall engine pattern (nft/iptables abstraction with idempotent rule generation), the procd init script with rollback logic, and the LuCI view utilities (chunked file writing, service polling). These could be extracted for other OpenWrt proxy/VPN services with minimal modification. The repo serves as a solid reference for OpenWrt package structure, LuCI app development, and transparent proxy integration, though new projects should target the successor SSClash-Go instead.
A Debian-packaged Bash toolset that ports ParrotSec's anonsurf and pandora tools to Kali Linux. The anonsurf component makes the whole system use a Tor transparent proxy: it saves existing iptables rules, flushes them, redirects DNS to a local Tor DNSPort, forwards TCP/UDP/ICMP through Tor's TransPort on port 9040, excludes private and local networks, disables IPv6 through sysctl, and supports changing Tor identity. The pandora component is a shutdown service that drops kernel caches and scrubs RAM with sdmem from secure-delete. The repository is not a library or service; it is an installer plus a .deb source tree, with GitHub Actions that build the package and verify it installs in Kali rolling containers. The code is functional and has some good operational detail, including UID-based iptables owner rules, resolvconf vs. plain resolv.conf handling, and package maintainer scripts that swap torrc files. It is also rough around the edges: it is largely monolithic shell, has no unit tests for the iptables logic, relies on outdated actions/checkout@v2 CI actions, and the IPv6 re-enable function has a filename typo that checks /etc/sysctl.d/98-kali-anonsurf but removes /etc/sysctl.d/98-kali-anonsurf.conf, which can prevent IPv6 from being re-enabled after stop.