KRemote

An open-source, cross-platform remote connection manager inspired by mRemoteNG but built from the ground up to work on Windows, Linux, macOS, iOS, and Android.

Screenshots

Manage all your remote connections in one place

More screenshots

Vault Creation

Empty Home Screen

Add Connection

Home with Connections

Connection Details

After Logout (Vault Locked)

Download

Pre-built binaries are available on the Releases page.

Latest: v0.11.1 (Windows x64 + Linux x64)

• Windows: Download KRemote-v0.11.1-windows.zip, extract, and run kremote.exe
• Linux: Download KRemote-v0.11.1-linux-x64.tar.gz, extract, and run ./kremote
• No installation required (portable)
• New in v0.11.1: RDP xrdp compatibility fix — disable NLA (CredSSP) for xrdp servers, TLS-only connection support
• v0.11.0: RDP protocol foundation — IronRDP integration complete, protocol connection testing, domain field support, framebuffer API ready (UI coming next)
• v0.10.0: Dynamic window title (shows active connection name), delete confirmation dialogs for connections/folders
• v0.9.0: Connection timeout configuration — set custom timeout (1-300s) per connection, defaults to 30s
• v0.8.x: OS keyring integration for master password caching (auto-unlock on startup), Lock Vault bugfixes
• v0.7.0: SSH key passphrase prompt for encrypted private keys
• v0.6.0: Session tabs & reconnect — multiple terminals, per-tab reconnect banners
• v0.5.0: Jump host tunneling — route SSH through bastion hosts
• This is an early alpha — expect rough edges and breaking changes between releases

Project Vision

A unified connection manager supporting multiple protocols:

• SSH - Secure Shell terminal connections
• RDP - Remote Desktop Protocol
• VNC - Virtual Network Computing
• HTTP/HTTPS - Web protocols
• VPN - Virtual Private Networks (WireGuard integration planned)
• AnyDesk-style remote control (future milestone)

Current Status: Early MVP

This is an active work-in-progress. What's working today:

✅ Implemented

• Encrypted credential vault with master password protection (Argon2id + AES-256-GCM)
• OS keyring integration for master password caching (Windows Credential Manager / Linux Secret Service) — opt-in auto-unlock
• Connection timeout configuration - set custom timeout (1-300s) per connection, defaults to 30s
• Cross-platform architecture using Flutter (UI) + Rust (crypto/network/protocol logic)
• Connection management: add, edit, delete, organize connections with folders and tags
• SSH interactive terminal with full PTY support (xterm emulation, hardware keyboard input)
• SSH session tabs - multiple terminals in one window with independent sessions and tab controls
• SSH session reconnect - per-tab reconnect banner recovers from connection loss without closing the window
• SSH jump host tunneling - route connections through bastion hosts with automatic TCP proxy
• SSH key passphrase prompt - connect with encrypted private keys via an on-demand passphrase dialog
• SSH connection testing via libssh2 (password and SSH key authentication)
• Multi-protocol support foundation (SSH, RDP, VNC, HTTP/HTTPS, VPN)
• Import/export functionality for connection backup and migration
• Vault operations: create, unlock, lock, auto-save on changes
• Modern UI with dark slate theme (#0F172A), protocol-specific icons/colors
• VNC client stub ready for libvncclient integration

🚧 In Progress / Planned

• RDP client integration (via FreeRDP)
• VNC client integration (via LibVNCServer) - stub implemented
• HTTP/HTTPS launcher (URL launcher ready)
• VPN profile management (WireGuard)
• Session recording and audit logs
• Mobile apps (Android/iOS) - architecture is ready, UI needs mobile adaptation
• Team vaults with shared credentials (zero-knowledge sync)
• Plugin system for extending protocol support

Architecture

┌─────────────────────────────────────┐
│         Flutter (Dart)              │  <- Cross-platform UI
│  Windows / Linux / iOS / Android    │
└──────────────┬──────────────────────┘
               │ flutter_rust_bridge (FFI)
┌──────────────▼──────────────────────┐
│           Rust Core                 │  <- Business logic, crypto, protocols
│  • Vault (Argon2, AES-GCM)          │
│  • SSH (libssh2)                    │
│  • RDP (FreeRDP - TODO)             │
│  • VNC (libvncclient - TODO)        │
└─────────────────────────────────────┘

• Flutter handles the UI layer and platform-specific packaging
• Rust handles encryption, credential storage, SSH/RDP/VNC protocol implementations
• flutter_rust_bridge generates type-safe FFI bindings automatically

Why Flutter + Rust?

1. Flutter: Write UI once, deploy to Windows/Linux/iOS/Android
2. Rust: Memory-safe, fast, excellent crypto/networking libraries (no need to reinvent RDP/SSH/VNC stacks)
3. FRB: Seamless Dart↔Rust interop with async/await support

Technology Stack

Layer	Technology
UI Framework	Flutter 3.x
Core Logic	Rust (stable)
FFI Bridge	flutter_rust_bridge 2.x
Encryption	Argon2id (password hashing), AES-256-GCM (vault encryption)
SSH	libssh2
RDP	FreeRDP (planned)
VNC	LibVNCServer/libvncclient (planned)
VPN	WireGuard (wireguard-go / wireguard-rs, planned)

Building from Source

Prerequisites

1. Flutter SDK (3.13+): https://flutter.dev/docs/get-started/install
2. Rust toolchain (stable): https://rustup.rs
3. Platform-specific build tools:
   • Windows: Visual Studio 2022 Build Tools (C++ desktop workload)
   • Linux: build-essential, libssh2-1-dev, pkg-config
   • macOS: Xcode command-line tools
4. flutter_rust_bridge codegen:

   cargo install flutter_rust_bridge_codegen

Build Steps

# Clone the repository
git clone https://github.com/z41hk/KRemote.git
cd KRemote

# Get Flutter dependencies
flutter pub get

# Generate Rust↔Dart bindings
flutter_rust_bridge_codegen generate

# Run on your platform
flutter run -d windows   # Windows
flutter run -d linux     # Linux
flutter run -d macos     # macOS

# Build release binary
flutter build windows --release
flutter build linux --release
flutter build apk --release   # Android
flutter build ios --release   # iOS (requires macOS + Xcode)

Project Structure

kremote/
├── lib/                      # Flutter/Dart code
│   ├── main.dart             # App entry point
│   ├── screens/              # UI screens
│   │   ├── home_screen.dart
│   │   ├── vault_screen.dart
│   │   └── connection_detail_screen.dart
│   └── src/rust/             # Auto-generated Rust bindings
│       ├── api/              # API surface (generated by FRB)
│       └── frb_generated.dart
├── rust/                     # Rust core
│   ├── src/
│   │   ├── api/              # Public API exposed to Flutter
│   │   │   ├── app.rs        # High-level app functions
│   │   │   ├── vault.rs      # Vault operations
│   │   │   ├── models.rs     # Data models (Connection, etc.)
│   │   │   ├── ssh.rs        # SSH protocol (libssh2 wrapper)
│   │   │   ├── vnc.rs        # VNC protocol stub
│   │   │   └── import.rs     # Import/export functions
│   │   └── lib.rs
│   └── Cargo.toml
├── windows/                  # Windows runner (C++)
├── linux/                    # Linux runner (C++)
├── android/                  # Android project
├── ios/                      # iOS project
└── pubspec.yaml              # Flutter dependencies

Security Model

Vault Encryption

1. Master password → Argon2id (time=3, memory=64MB, parallelism=4) → 32-byte key
2. Data encryption: AES-256-GCM (authenticated encryption)
3. Vault file format (JSON):

   {
     "version": 1,
     "salt": "<hex>",           // 32-byte random salt for Argon2
     "password_hash": "<hex>",  // Argon2(password + salt) for verification
     "nonce": "<hex>",          // 12-byte random nonce for AES-GCM
     "ciphertext": "<hex>",     // Encrypted connections JSON
     "tag": "<hex>"             // 16-byte GCM authentication tag
   }

4. No plaintext storage: Passwords are never written to disk unencrypted
5. Memory protection: Sensitive data cleared on vault lock (Rust's Drop trait)

Threat Model

• Protected against: offline vault file theft (strong encryption), casual inspection, memory dumps after lock
• Not protected against: keylogger capturing master password, memory dump while unlocked, malicious Rust/Flutter code in dependencies
• Keyring security: Cached master password (when "Remember master password" is enabled) is stored in OS-native credential stores (Windows Credential Manager uses DPAPI encryption, Linux Secret Service is encrypted per-session). This is equivalent in risk to any browser/app "remember me" feature — if an attacker has full access to your logged-in OS user account, they can retrieve stored credentials.
• Future: Hardware key support (FIDO2/YubiKey)

Usage

First Run

1. Launch the app
2. Create a new vault with a strong master password (min 8 characters)
3. The vault file is saved to:
   • Windows: %APPDATA%\kremote\vault.enc
   • Linux: ~/.config/kremote/vault.enc
   • macOS: ~/Library/Application Support/kremote/vault.enc

Adding Connections

1. Click + Add Connection
2. Fill in:
   • Name: Display name (e.g., "Production Server")
   • Protocol: SSH, RDP, VNC, HTTP, HTTPS, VPN
   • Host: IP or hostname
   • Port: Default is auto-filled per protocol
   • Credentials: Username, password, or SSH private key path
   • Timeout: Connection timeout in seconds (1-300s, defaults to 30s)
   • Folder: Optional folder ID for organization
   • Tags: Comma-separated tags (e.g., "production,linux,web")
   • Jump Host: Optional bastion/jump host ID for tunneling
   • Notes: Free-text notes for documentation
3. Click Save to store the connection

Testing Connections

• Click the ▶ (play) button on any connection card
• For SSH: attempts to connect and run echo "Connection test successful"
• Result shown in a snackbar (green = success, red = failure)

Locking the Vault

• Click the 🔒 lock icon in the app bar
• All decrypted data is cleared from memory
• You'll need to re-enter your master password to unlock (unless "Remember master password" is enabled, in which case it auto-unlocks again on the next launch — uncheck that box to require manual entry)

Roadmap

Phase 1: MVP

• Vault with AES-256-GCM encryption
• Connection CRUD (create, read, update, delete)
• SSH connection testing
• Windows build working
• Full SSH terminal emulation (interactive PTY with streaming I/O)
• Linux build verification

Phase 2: Protocol Expansion

• RDP client integration (FreeRDP)
• VNC module scaffolded (stub - needs libvncclient FFI bindings)
• HTTP/HTTPS launcher (opens system browser)
• Jump host SSH tunneling (full TCP proxy via channel_direct_tcpip - production ready)
• Session tabs (multiple SSH terminals in tabbed interface)

Phase 3: Mobile

• Android app (UI adaptation for touch)
• iOS app
• Mobile-specific features (biometric unlock)

Phase 4: Advanced Features

• Connection folders (hierarchical, with rename/delete)
• Connection tags
• Import from mRemoteNG XML
• Export vault to plaintext JSON (manual backup)
• Session recording/playback
• Team vaults with cloud sync (E2E encrypted)
• WireGuard VPN profile management
• Plugin/extension system

Phase 5: Enterprise

• LDAP/AD integration
• Audit logs and compliance reports
• Role-based access control (RBAC)
• Self-hosted sync server

See STATUS.md for a detailed, up-to-date breakdown of what's implemented vs. stubbed vs. planned.

Contributing

This project is fully open source! Contributions welcome:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Development Guidelines

• Rust code: Run cargo fmt and cargo clippy before committing
• Flutter code: Run flutter analyze and dart format .
• Bindings: Regenerate with flutter_rust_bridge_codegen generate after changing Rust API
• Testing: Add tests for new Rust modules (cargo test)

License

MIT License - see LICENSE for details.

Acknowledgments

Inspired by:

• mRemoteNG - The original Windows-only connection manager
• Apache Guacamole - Clientless remote desktop gateway
• RustDesk - Open-source remote desktop solution
• Remmina - Linux GTK+ remote desktop client

Built with:

• Flutter
• Rust
• flutter_rust_bridge
• libssh2

Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions

---

Status: 🚧 Active Development | License: MIT | Platforms: Windows, Linux, macOS, iOS, Android (cross-platform)