There is no installer and no service. Deployment is copying a folder onto the machine you work from and running an exe. What follows is the part that is not obvious: the things Windows does to a downloaded binary, what to expect on a shared jump box, and the limits that no amount of configuration will move.
- Windows 10 (1809 or later) or Windows 11.
- Nothing else. RSPaster uses the .NET Framework 4.x that ships with Windows, and builds with the C# compiler that ships with it. There is no runtime to install, no NuGet restore, and no network access at any point.
The two undocumented dark-mode calls it makes are looked up by ordinal and the failure is swallowed, so on a build that lacks them you get light scrollbars rather than a crash.
From the release zip. Unzip anywhere the user can write. %LOCALAPPDATA%
or a tools folder both work; it does not need Program Files, and putting it
there only means it needs elevation to update itself.
From source. Copy the repo folder and run Build-RSPaster.cmd once. This
matters on a locked-down machine: nothing was downloaded, so nothing carries a
web mark, and the person running it can read every line first.
A zip downloaded through a browser is tagged with a zone identifier, and that tag survives extraction onto every file inside it. The symptom is not always an obvious block - sometimes SmartScreen shows "Windows protected your PC", and sometimes the exe simply does nothing on double-click.
Verify the hash first, then clear the tag. Unblocking strips the only record Windows kept of where the file came from, so it is worth spending one command first to confirm you have the file the release published:
Get-FileHash .\RSPaster.zip -Algorithm SHA256Compare that against the RSPaster.zip.sha256 published with the release. Then
clear the tag on the zip before extracting, so it is not copied onto each
extracted file:
Unblock-File .\RSPaster.zipIf it is already extracted, clear the folder:
Get-ChildItem .\RSPaster -Recurse | Unblock-FileThe binary is unsigned. Code signing needs a certificate this project does not
have, so SmartScreen will warn on a fresh download until enough people run it.
If that is unacceptable in your environment, use the source path instead:
double-click Run-From-Source.cmd and no binary is involved at all.
| Path | What | Notes |
|---|---|---|
%APPDATA%\RSPaster\settings.ini |
Delays, checkbox states, theme, window size | Plain key=value, safe to edit or delete |
| nowhere else |
The contents of the text box are never written to disk, in any form: no settings entry, no recent-items list, no crash backup. It routinely holds passwords, so it stays in memory only. That is worth knowing before you approve the tool for a team.
Be precise about what that guarantees, because the difference matters to a reviewer. RSPaster writes no secret to disk, and that is a real property you can check. It is not the same as "cannot end up on disk". Secrets are held in ordinary process memory as .NET strings, which cannot be wiped on demand, so a process dump taken by anything running as the same user, or a pagefile or hiberfile write, can still contain them. RSPaster does what it can about the most likely path: it exits without invoking Windows Error Reporting rather than letting a crash write a heap dump. Beyond that, treat a machine where the tool has typed a password the way you would treat one where the password was typed by hand.
Uninstalling is deleting the folder and, if you care, that one settings file. Nothing is written to the registry, no service is registered, and nothing is added to startup.
On a machine with roaming profiles, %APPDATA% roams, so settings follow the
user between machines. Window size is stored in physical pixels, so a size
saved at 100% scaling is rejected as too small at 150% and the defaults apply.
That is deliberate, and it means the only symptom of moving between differently
scaled machines is a window that reverts to its default size.
Windows blocks a normal-privilege process from sending input to a window that belongs to a higher-privilege one. If your target is an elevated app, RSPaster must be elevated too, or the keystrokes are silently discarded.
"Silently" is exact: the send API reports success and sets no error when the block happens, so nothing after the fact can detect it. RSPaster instead compares integrity levels before it types and refuses the run, naming the target window's process. It refuses the same way when the workstation is locked or a UAC prompt holds the secure desktop.
Use the Restart as Admin link at the bottom of the window rather than launching elevated by habit. An elevated RSPaster can send to elevated targets and normal ones equally, but it also means a global hotkey registered by an elevated process, which some environments audit.
The link is hidden when running from source, deliberately. Elevating that
path would run Run-From-Source.ps1 with the execution policy bypassed, and
that script compiles and runs every .cs file next to it, unsigned and
unchecked. Anything able to write to that folder would gain administrator
rights the moment someone clicked the link, and the UAC prompt would say
"Windows PowerShell" rather than RSPaster. Build the exe first if you need to
elevate.
If anyone will ever elevate RSPaster, put it somewhere only administrators can write. That advice applies to the exe too: elevating any unsigned binary out of a user-writable directory hands its contents whatever rights you approve.
- Per-user, not per-machine. Two users on the same box each get their own settings and their own hotkey registration. There is nothing machine-wide to configure.
- The hotkey is first-come.
Ctrl+Alt+Vis registered at startup. If another app already owns it, RSPaster says so in the status bar and the top bar, and the button keeps working. It does not fight for the key. - AppLocker and similar. The exe is unsigned and lives in a user-writable
directory, which is exactly what a default AppLocker policy blocks. The
source path runs through
powershell.exewith-ExecutionPolicy Bypass, which many managed environments also block. If both are blocked, that is the policy working as intended; get the exe allowlisted by hash rather than working around it.Make-Dist.ps1prints the exe's SHA256 for exactly this, and each release publishes it.
The UAC secure desktop cannot be reached. It is isolated from all user-mode input injection, so nothing running in your session can type into it. RSPaster works with UAC prompts only where they are configured to appear on the normal desktop. Running elevated covers ordinary elevated windows, not the secure desktop.
Keystrokes go wherever focus is. There is no targeting. The countdown is the mechanism for putting focus in the right place, and the global hotkey exists so you can focus the target first and never take it away.
Consoles drop keys that arrive too fast. BMC and IPMI KVM sessions are the usual offenders. Missing characters almost always mean the key delay is too low; 30 to 50 ms is a reasonable starting point over a slow link.
Grab uses the OCR engine Windows ships (Windows.Media.Ocr). Consumer and
enterprise Windows 10/11 have it with at least the profile language. Some LTSC
and Server images ship no OCR language pack: RSPaster detects that at startup,
disables the OCR button with an explanation in its tooltip, and everything
else works as normal. Nothing needs installing either way, and recognition
never leaves the machine.
Where the result goes is a separate question from where recognition happens.
Grabbed text is put on the clipboard, and the clipboard is a shared surface that
any process in the session can read. RSPaster marks its clipboard writes with
the documented opt-out formats, so the text is kept out of Clipboard History
(Win+V) and out of cloud clipboard sync, the same way a password manager does.
It does not clear the clipboard afterwards, because pasting the text somewhere
is the entire point of the feature.
Building from source on such an image still works: the WinRT metadata the
compile references lives in %WINDIR%\System32\WinMetadata on every stock
install, language packs or not.
If you are being asked to approve this tool, the honest summary is that its capability list reads like an infostealer's, and every capability on it is load-bearing for a feature you can see in the UI:
| Capability | Why it is there |
|---|---|
| Registers a global hotkey | Triggering a run without taking focus off the target, which is the whole point of the hotkey |
Reads global key state (GetAsyncKeyState) |
At the start of a run only, for at most three seconds, checking whether the operator's own Ctrl+Alt+V fingers are still down; injecting while they are turns the first characters into shortcuts |
Injects synthetic keystrokes (SendInput) |
The product |
| Captures the whole screen | The OCR region selector freezes the desktop first so a scrolling console cannot move the text between aiming and capturing |
| Runs OCR over the capture | Reading console output back out |
| Writes to the clipboard | Delivering the OCR result |
The key-state poll is usually the line that stops a reviewer, because it reads
one non-modifier key, V. It is the hotkey's own letter, it is only read, and
nothing is recorded anywhere.
The strongest thing the project has to say for itself takes seconds to check:
there is no network code in the process at all. No System.Net, no sockets,
no HTTP client, nothing that resolves a name. Search the source for it. The only
I/O the program performs is the one settings file described above, and that file
never contains a secret.
On a display scaled above 100%, use RSPaster.exe. Run-From-Source.cmd
cannot declare DPI awareness, because that has to happen before a process opens
its first window and the PowerShell host has already opened one; that path lays
out at 1x and lets Windows stretch the result, which is correct in proportion
but soft.
To confirm the layout on your own display rather than trusting a screenshot:
tools\Dpi-Report.cmd
It compiles a probe against the app's own sources, measures the real geometry at whatever scaling is in force, and prints a pass or fail per control gap. It also reports whether DPI awareness was actually achieved, so a run that only describes an unscaled layout says so instead of looking like a pass.