nks-usbshare
Share USB devices between computers over a TLS link on a LAN, VPN or the internet, with apps for Windows, Linux and macOS, a CLI and an MCP server. C#/.NET 9, no NuGet packages.
Install / Use
claude mcp add nks-hub -- npx -y github:nks-hub/nks-usbshareIf the server publishes to npm under a different name, use that package instead — check the repo README.
MCP Server
Model Context Protocol server
Quality Score
Category
Development & EngineeringSupported Platforms
Tags
Our assessment of nks-usbshare
nks-usbshare scores 83/100 on our quality scale, 2989th of 4,705 Development & Engineering skills we index.
Its MCP Server is 21 KB long, well organised into 20 sections with 8 code examples: a thorough specification that gives an agent plenty to work with.
It has 3 GitHub stars, so there is little community track record yet; judge it on its content.
Maintenance, license and trust
- The repository was last updated 37 days ago, so nks-usbshare is actively maintained.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 80/100, with 2 cautions from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-11-16. Automated pattern scan on 2026-11-16. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
nks-usbshare compared with similar skills
All 4 of these similar skills score higher than nks-usbshare; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| nks-usbshare (this skill)by nks-hub | 83 | 3 | 37d ago | MCP Server |
| taste-skillby Leonxlnx | 100 | 117.0k | 8d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.4k | 9d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.9k | today | CLAUDE.md |
Frequently asked questions
- How do I install nks-usbshare?
- Run
claude mcp add nks-hub -- npx -y github:nks-hub/nks-usbshare. The install tabs above show the steps for each supported agent. - Which AI agents does nks-usbshare work with?
- It is written for Claude Code and Claude Desktop, as a MCP Server file. Other agents that read the same format can often use it too.
- Is nks-usbshare safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 80/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is nks-usbshare still maintained?
- The repository was last updated 37 days ago, so nks-usbshare is actively maintained.
Skill content
View source on GitHubNKS UsbShare
Share USB devices between computers over an encrypted TCP link on a LAN, across a VPN or over the internet. A flash drive, a phone, a dongle: plug it into one machine, use it from another as though it were plugged in there.
Written in C# on .NET 9 with no NuGet packages, on top of WinUSB and SetupAPI on Windows, usbfs on Linux, IOKit on macOS and the .NET TLS stack.
One thing cannot be written in user mode: the virtual USB controller that makes a remote device visible to every application on Windows. That is a kernel driver, and it has to be signed by someone Windows already trusts. The application fetches and installs it on its own the first time it is needed; see Dependencies.
The computer a device is plugged into: everything attached, and what is shared:

The computer using it: a phone attached across the network, listed as a local device:

| Settings | Linux |
|---|---|
|
|
|
Every window shows the same thing in the same shape: identity and pairing details pinned at the top, then a table of devices with a button per row, then the computers allowed in.
Features
- 🔌 USB over the network - Plug a device into one computer and use it from another, on a LAN, across a VPN or over the internet
- 🔒 Encrypted and pinned - TLS 1.3 (1.2 floor), self-signed P-384 identities pinned on first use, 125-bit pairing tokens, optional mutual TLS
- 🛂 Per-device access control - Allow lists of client fingerprints per device, named clients and instant blocking
- 🖥️ Native apps on three platforms - WPF on Windows, GTK 3 on Linux, AppKit on macOS, plus the cross-platform
nksusbCLI - 🤖 MCP server - Manage sharing, pairing and imports from AI agents over the Model Context Protocol
- 🧲 Driver claim on Windows - Moves a device from its class driver onto
winusb.sysand gives it back, with Secure Boot left on - 🧩 Whole-OS attach - Presents a remote device to the local USB stack through
vhci_hcdon Linux or the usbip-win2 controller on Windows, installed automatically - 💾 Driverless storage access - Reads a remote disk directly over SCSI Bulk-Only Transport with a built-in FAT32 reader
- 📦 Zero NuGet packages - Protocol, MCP JSON-RPC, descriptor parser, SCSI/FAT32 readers, UI bindings and test runner are all in-repo
Requirements
- Windows x64, Linux x64 or macOS arm64 (release builds are self-contained)
- .NET 9 SDK to build from source
- Windows: administrator consent once to claim a device or install the virtual USB controller
- Linux: the in-kernel
vhci_hcdcontroller for whole-OS attach; GTK 3 and a display for the desktop app - macOS: whole-OS attach is not possible today; remote devices are reachable through
RemoteUsbDeviceandnksusb storage
Installation
Download a self-contained build for your platform from GitHub Releases:
| Package | Platforms |
|---------|-----------|
| NksUsbShare.Desktop | win-x64 |
| NksUsbShare.Gtk | linux-x64 |
| NksUsbShare.Mac | osx-arm64 |
| NksUsbShare.Cli | win-x64, linux-x64, osx-arm64 |
| NksUsbShare.Mcp | win-x64, linux-x64, osx-arm64 |
Or build the desktop application from source:
Windows: dotnet build src/NksUsbShare.Desktop, then run NksUsbShare.exe.
macOS: dotnet publish src/NksUsbShare.Mac -r osx-arm64 --self-contained. Put the binary in
a .app bundle so LaunchServices treats it as a normal application.
Linux: dotnet publish src/NksUsbShare.Gtk -r linux-x64 --self-contained, then run
nksusb-gtk. On a machine with no display it prints that and exits.
Usage
Desktop application
The Windows, macOS and Linux applications all accept --home <dir> like the terminal application, so a second node can be run beside
the real one without disturbing its settings.
Command line (all platforms)
dotnet build src/NksUsbShare.Cli
nksusb list # local devices and what is shared
nksusb share 3 # share the third device, claiming it from Windows if needed
nksusb giveback # return every claimed device to its original driver
nksusb serve # run the node until interrupted
nksusb pair 192.0.2.10 ABCDE-FGHIJ-KLMNO-PQRST-UVWXY
nksusb remote 192.0.2.10 # what that host offers
nksusb import 192.0.2.10 <device-id> # hold a device until interrupted
nksusb attach 192.0.2.10 <device-id> # hand it to this machine's USB stack
nksusb storage 192.0.2.10 <device-id># read a remote disk directly, without a driver
nksusb clients # computers that have connected here
nksusb access 3 anyone # offer the third device to any paired computer
nksusb access 3 laptop workshop # or only to those two
nksusb block laptop # refuse a computer even with the right token
A computer can be named by its name or by any unambiguous part of its key fingerprint. These commands write the settings file, so a node that is already running picks them up when it restarts; the windowed applications change their own running node straight away.
Settings live in %APPDATA%\nks-usbshare or ~/.config/nks-usbshare, overridable with
NKS_USBSHARE_HOME or --home.
MCP server
{
"mcpServers": {
"nks-usbshare": {
"type": "stdio",
"command": "<path-to>/nksusb-mcp"
}
}
}
| Tool | Description |
|------|-------------|
| node_info | Identity, platform, pairing token and listening address |
| list_local_devices | Local USB devices and whether each one is shared |
| share_device / unshare_device | Offer a device, optionally claiming it first |
| release_claimed_devices | Give every claimed device back to its original driver |
| list_clients | Computers that have connected to this node |
| set_client_blocked | Refuse or re-admit a computer |
| set_device_access | Choose which computers may use a shared device |
| list_hosts / pair_host / forget_host | Manage paired computers |
| list_remote_devices | What another computer offers |
| import_device / release_device / list_imports | Hold and release remote devices |
| recent_activity | The node's activity log |
What works today
| | Windows | Linux | macOS | |---|---|---|---| | Enumerate local USB devices | verified | verified | verified | | Share a device (export) | verified | verified | implemented | | Claim a device from its class driver | verified | n/a | n/a | | Use a remote device from an application | verified | verified | verified | | Present a remote device to the whole OS | verified | verified | not possible today | | Native application window | WPF, verified | GTK, verified | AppKit, verified | | Command line | verified | verified | verified | | Per-device access lists and blocking | verified | verified | implemented |
"Verified" means it was exercised against real hardware; "implemented" means the code is complete but has not yet been run on that platform.
The Windows export path was checked end to end: a USB flash drive plugged into one machine was claimed from its class driver, shared, and then read from a Windows 11 virtual machine on another host across a VPN. The virtual machine pulled the device and configuration descriptors straight off the hardware (mass storage, class 08/06/50, two 512 byte bulk endpoints), so real transfers crossed the encrypted link, not cached metadata.
nksusb probe 192.0.2.10 'USB\VID_FFFF&PID_5678\0123456789ABC'
Disk 2.0 (ffff:5678)
device descriptor (18 bytes)
1201000200000040FFFF7856000201020301
usb 2.00 vendor ffff product 5678 class 00 max packet 64
configuration descriptor, 32 bytes total
interface 0 alt 0 class 08/06/50
endpoint 0x01 Bulk 512 bytes
endpoint 0x82 Bulk 512 bytes
The import path was then checked the same way. With a virtual controller installed, nksusb attach
handed the same flash drive to the virtual machine's own USB stack: Windows enumerated it, bound
its ordinary mass storage driver, and mounted the filesystem as a removable drive. Files written
from the virtual machine landed on the physical device, and a two megabyte round trip came back
byte for byte identical.
Architecture
machine A (host) machine B (client)
+-----------------------+ +-----------------------+
| USB device | | application |
| | WinUSB / usbfs | | ^ RemoteUsbDevice |
| v | TLS 1.3, port | | |
| NodeService | | NodeService |
| HostServer --------+------ 57340 ------+-> UsbShareClient |
+-----------------------+ +-----------------------+
Transfers cross the link as URBs: the client submits a request describing an endpoint, a transfer type and a payload; the host issues it through the operating system and sends back the result. Control, bulk and interrupt transfers are carried; isochronous is carried by the protocol and implemented on the Linux backend.
Components
| Component | Runtime | Description |
|-----------|---------|-------------|
| NksUsbShare.Core | .NET 9 | Wire protocol, TLS, USB backends, host and client engines |
| NksUsbShare.Cli | .NET 9 | nksusb command line with every feature, all platforms |
| NksUsbShare.Desktop | .NET 9 (WPF) | Windows application |
| NksUsbShare.Gtk | .NET 9 (GTK 3) | Linux application, plain P/Invoke |
| NksUsbShare.Mac | .NET 9 (AppKit) | macOS application, on the Objective-C runtime |
| NksUsbShare.Mcp | .NET 9 | Management server speaking the Model Context Protocol |
Security
| Layer | Technology | Scope | |-------|-----------|-------| | Transport | TLS 1.3 (TLS 1.2 floor) | Every connection, before a single protocol byte | | Host identity | Self-signed P-384, pinned on first use | Client refuses a host whose key changed | | Client identity | Self-signed P-384, always presented | Host names, blocks and restricts by key | | Admission | 125-bit pairing token, constant-time compare | Every connection | | Per device | Allow list of client fingerprints | Listing and opening |
- Public-key pinning. Each node generates its certificate on first run. A client pins the host's fingerprint the first time it connects and refuses to continue if it ever changes. There is no certificate authority, because there is no third party in the link.
- Pairing tokens. 125 bits of entropy, shown in groups of five characters with the ambiguous ones removed so they can be read aloud.
- Every client is named. A client always presents its own key, so the host records which computers have used it and can tell them apart. Nothing has to be turned on for this.
- Blocking. A computer can be refused outright. It is disconnected at once and anything it was holding is released, so blocking does not wait for it to come ba
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
117.0kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
112.4kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.9kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
