croc is a secure, peer-to-peer file transfer tool that operates via a relay server for NAT traversal. It uses Password Authenticated Key Exchange (PAKE) for authentication and end-to-end encryption (AES-GCM or ChaCha20-Poly1305) to protect data in transit. The application consists of a Go CLI client, a standalone web server (croc-web), and a React/Vite web frontend that uses WebAssembly to perform crypto operations in the browser. Files are split into chunks, optionally compressed, and transferred over multiple TCP connections with resume support. The tool also supports an asynchronous 'stored transfer' mode where encrypted files are temporarily stored on the relay server and can be downloaded by recipients using access tokens. The codebase is well-structured with a custom CLI framework, modular crypto and compression packages, and a comprehensive test suite covering core transfer logic, security properties, and end-to-end browser tests. The web client includes a blog with deep technical articles about the protocol design.
The AdvancedSharpAdbClient is a .NET library that provides a managed implementation of the Android Debug Bridge (ADB) protocol, enabling developers to interact with Android devices without relying on the external `adb.exe` executable. It offers a comprehensive suite of features including device connection management, shell command execution, application installation and uninstallation, file transfer via ADB sync service, screen capture, and device state monitoring. The library is designed with a strong emphasis on testability and loose coupling, utilizing interfaces and a factory pattern for dependency injection. Architecturally, the library is structured as a set of cohesive, loosely coupled components. Core communication is handled by `AdbSocket` (low-level TCP) and higher-level operations are exposed through `AdbClient`, `DeviceClient`, `PackageManager`, and `SyncService`. The library makes extensive use of interfaces to allow for easy mocking in unit tests and provides asynchronous counterparts for most operations to support non-blocking programming models. It targets a wide range of .NET frameworks (from .NET Framework 3.5 to .NET 10+) using conditional compilation and polyfills to maintain compatibility. The library demonstrates solid engineering practices through its use of the factory pattern for object creation, extension methods to enhance interface usability, and careful handling of binary data structures for statistics and framebuffer headers. Its comprehensive test suite, which includes mock implementations for various components, ensures reliability and facilitates safe evolution. While the broad target range introduces some complexity via conditional compilation symbols, the code remains well-organized and maintainable, reflecting a commitment to serving a diverse set of .NET applications requiring Android device interaction.
DashBeam is a peer-to-peer encrypted file transfer application that operates without a central server. Built on the Iroh networking stack (QUIC, BLAKE3, relays), it enables direct device-to-device transfers with end-to-end encryption, NAT traversal via relays, and local LAN discovery via mDNS. The application is cross-platform, targeting desktop (Windows, macOS, Linux via Tauri), Android, and web (via a Rust WASM bridge). Its architecture cleanly separates a core protocol crate (P2P wire format, pairing, identity) from platform-specific I/O crates (native disk I/O for desktop/mobile, in-memory for web), all wrapped by a unified engine facade. The frontend is a modern React/TypeScript SPA with Zustand state management, a comprehensive UI component library built on Base UI, and 20+ locale translations. The system supports one-time share tickets, permanent device pairing, broadcast mode, transfer progress with resume, and self-hosted infrastructure. No telemetry or accounts are required, and the AGPL-3.0 license ensures openness.
Cyberduck is a mature, multi-protocol file transfer client for macOS, Windows, and Linux (CLI). It supports over 30 storage protocols including S3, SFTP, FTP, WebDAV, Azure, Google Drive, Dropbox, Backblaze B2, and many more. The architecture is a Java core library with platform-specific UI bindings: Cocoa for macOS (via Rococoa/JNA), WinForms/WPF for Windows, and a command-line interface (duck). The core defines a clean set of feature interfaces (Read, Write, Find, Delete, etc.) that each protocol module implements, enabling a uniform file operation model. The system also integrates client-side encryption via Cryptomator vaults, which wrap protocol features transparently using decorator patterns. Key external dependencies include Apache HttpClient, JSch (SSH), and various cloud SDKs.
QRServ is an Android application that turns a device into a local file-sharing server. Users select files (or use Direct Access Mode for single files without copying), and the app starts an embedded Ktor HTTP server on an unused port. The server URL is displayed as a QR code for other devices on the same network to scan and download files. Optionally, on Android 13+, QRServ can create a private Wi-Fi hotspot (with band selection on Android 16+) so that only devices joining the hotspot can access the files. The app runs a foreground service with a persistent notification, handles HTTP range requests for large files, and includes an idle timeout that automatically stops the server when no downloads occur for a configurable period. The architecture follows a standard Android MVVM pattern with Jetpack Compose UI, using StateFlow for reactive state management and a centralized ViewModel (QRServViewModel) that orchestrates server lifecycle, network callbacks, and hotspot control. The codebase demonstrates strong engineering practices including comprehensive unit tests, separation of concerns into repositories and controllers, and careful handling of Android-specific edge cases such as permission revocations, network changes, and file removal during sharing. The app is available on Google Play and IzzyOnDroid with multi-language support.
Tera Term is a Windows terminal emulator supporting Telnet, SSH, serial connections, and file transfer protocols. It features a plugin system (TTXSamples) for extensibility, a macro language for automation, and extensive configuration options. The architecture is modular with core terminal emulation, SSH implementation (ttssh2), macro interpreter (ttpmacro), and plugin loader. Key external dependencies include Windows API, OpenSSL/LibreSSL, zlib, Oniguruma, and Argon2. The project is actively maintained with recent commits and supports both legacy and modern Windows versions.
This repository implements an end-to-end encrypted file transfer system called e2ecp. It consists of a Go-based relay server, a CLI client, and a React web frontend. The system allows users to transfer files or text between peers with zero-knowledge encryption: the relay server never sees plaintext data or metadata. It also supports user accounts with encrypted cloud storage, file sharing via links, device authentication, and email verification. The architecture is a monolith with a WebSocket relay, HTTP API, PostgreSQL database, and separate client implementations. Key entry points are the CLI (main.go), the relay server (src/relay/relay.go), and the React app (web/src/App.jsx). The codebase is well-structured with comprehensive testing, CI/CD, and Docker support. However, there are some maintenance risks such as duplicated protobuf schemas between Go and JavaScript, and the use of a future Go version (1.25) in go.mod, which may indicate dependency drift.
Aspia is a comprehensive, cross-platform remote desktop and system administration suite. The codebase is decomposed into four primary components: a **host** (the machine being controlled), a **client** (the controlling machine), a **router** (session brokering and NAT traversal), and a **relay** (traffic forwarding). It supports Windows, Linux, macOS, and Android, with platform-specific implementations for screen capture (DXGI, X11, Wayland/PipeWire, KMS/DRM, Android MediaProjection), audio (WASAPI, PulseAudio, Oboe), input injection, and clipboard integration. The system uses encrypted communication with SRP authentication, X25519 key exchange, and AEAD ciphers (AES-256-GCM, ChaCha20-Poly1305) with key ratcheting. Beyond desktop sharing, it provides file transfer, text chat, remote terminal, task manager, system information collection, and video recording. The client features both a Qt-based desktop GUI and a custom Android UI built with native widgets. The router manages host discovery, two-factor authentication (TOTP), and relay session keys, while the relay handles peer-to-peer forwarding. The codebase is built with CMake, uses protobuf for messaging, and relies on libraries like asio, OpenSSL, libvpx, libyuv, and zstd.
The Global Socket Toolkit (gsocket) is a secure networking utility suite that enables TCP connections across NATs and firewalls without requiring any inbound ports. It achieves this by relaying traffic through a free cloud-based relay network (GSRN) and encrypting the session end-to-end using SRP (RFC 5054) with AES-256 and a 4096-bit prime. The project provides a core library (`libgsocket`) that abstracts the relay protocol, and several command-line tools: `gs-netcat` (a netcat-like tool for data transfer, reverse shells, port forwarding, and SOCKS proxies), `gs-sftp` (SFTP through the relay), `gs-mount` (sshfs mounting), and `blitz` (bulk file transfer). It also includes a `LD_PRELOAD`-based interposition library (`gsocket_dso`) that can transparently redirect existing network applications through the relay. The architecture is client-server with a relay network; the client establishes a connection to the relay using a shared secret token, and the server connects to the same token, allowing the relay to bridge the two. The codebase is written in C and Bash, with autotools build system, extensive cross-platform support (Linux, macOS, FreeBSD, OpenBSD, Solaris, Cygwin, OpenWRT), and CI/CD pipelines for publishing static binaries. It is a dual-use tool: it can be used for legitimate remote administration, secure file transfer, and privacy, but also includes documented patterns for hidden reverse shells and persistence, which introduces security and maintenance risks.