A fresh node install is not a finished node, it is a server with default settings, open ports, and a key that controls real stake, sitting on the public internet. Setup guides get the node running; hardening is what keeps it running safely. This post is the checklist to run after setup and after every major change: lock down SSH, close the firewall to only what the node needs, protect the keys, patch the operating system, lock down the RPC interface, and set up monitoring that catches intrusions, not just downtime.
Work through the sections in order, and do not skip the ones that feel boring, because the boring ones are the ones attackers count on. Our key security guide covers key handling in more depth, our SSH and firewall guide covers the first two sections in detail, and our backup guide covers what to do when hardening fails and you need to rebuild.
Lock down SSH first
SSH is the front door, and it is also the first thing automated scanners try. Switch to key-only authentication and disable password login entirely, because passwords can be guessed and keys cannot be brute-forced in any practical sense. Disable direct root login and use a named user with sudo instead, so a compromised key does not immediately hand over full control. Keep your private key off the server, protected with a passphrase, and never copy it to the node itself.
Two more steps are worth doing. First, install a tool like fail2ban, which temporarily blocks addresses that fail logins repeatedly, because it turns a noisy brute-force attempt into a short-lived nuisance. Second, review who has access on a schedule: remove old keys, remove accounts for people who no longer operate the node, and check the authorised keys file whenever the team changes. Access that nobody reviews only grows, and every extra key is an extra way in.
Firewall: allow only what the node needs
A firewall with a default-deny policy is the simplest high-value step in this whole post: block everything, then open only the ports the node actually needs. For most validators that means the peer-to-peer port, so the node can find and serve peers, and SSH, so you can administer it. Everything else stays closed, including the RPC port, the metrics port, and any admin interface, unless you have a specific reason to open it, and then only to specific addresses.
# Allow SSH and the chain peer port, block everything else
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow 30303/tcp
sudo ufw enable
sudo ufw status verbose
The port number above is an example: use the peer port your chain actually uses, and check the client docs for it. If your hosting provider has its own firewall or security group, configure that too, because the cloud firewall sits in front of the server firewall, and a port open in one but closed in the other is still a gap. After every change, test from outside the server: a firewall rule you believe is working is not the same as one you have verified.
Keep the operating system patched
Most node compromises start with an unpatched operating system, not with the blockchain client. Enable automatic security updates for the OS, so critical patches apply without waiting for a human to remember, and schedule a regular window for the rest. Kernel updates need a reboot, so plan reboots into your maintenance routine rather than letting them pile up for months. A node that has not rebooted in a year is a node running a year of known vulnerabilities.
Patching the OS and patching the client are different jobs, and both need a process. Our upgrade guide covers the client side, with snapshot and rollback steps that apply to OS updates too. The rule for both is the same: know what version you are running, know what the update changes, test where you can, and keep a way back.
Protect the keys
Keys are the one asset on the server that cannot be re-downloaded, so they deserve the strongest rules. Keep signing keys and withdrawal credentials separate, with different storage and different access, so a compromise of one does not hand over the other. Set strict file permissions, readable only by the user that runs the node, and never store keys in a git repository, a chat message, a screenshot, or a shared drive. If a key has ever been pasted somewhere it should not have been, treat it as compromised and rotate it.
Backups of keys must be encrypted, stored off the server, and tested, as covered in our backup guide. And remember that hardening the server does not harden the operator: phishing, a compromised laptop, or a careless copy-paste can leak a key without touching the node at all. Keep keys off personal machines, use a password manager for passphrases, and treat any request for a key or seed phrase as hostile until proven otherwise.
Lock down RPC and APIs
The RPC interface is how apps talk to the node, and it is dangerous when exposed. Bind RPC to localhost by default, so only processes on the same server can reach it, and use a reverse proxy or a private network if a remote app needs access. Never expose an RPC endpoint to the public internet without authentication, and never expose admin or personal APIs at all. An open RPC endpoint can leak information about your node, and an open admin API can be used to control it.
If your setup needs a public RPC, put it behind its own service with rate limits, authentication, and monitoring, and keep it separate from the validator. Our private RPC guide and our RPC failover guide cover that architecture, including health checks and a fallback endpoint. The principle is simple: the validator signs blocks, the RPC serves queries, and the two jobs should not share an interface.
Monitor for intrusions, not just uptime
Most node monitoring watches uptime: is the node synced, are attestations landing, is the disk full. That is necessary and not enough. Add checks that catch intrusions: failed SSH login spikes, unexpected processes, unexpected outbound connections, files changed in directories that should not change, and disk use that jumps without a chain growth reason. A node that is synced and attesting can still be compromised, and uptime monitoring will not tell you.
Review logs on a schedule, not only when something breaks. A weekly look at authentication logs, firewall blocks, and client warnings is cheap, and it builds the familiarity that makes an anomaly visible. Our Grafana monitoring guide covers the metrics side, and our post on reading validator logs covers what to look for in the logs themselves. Alerts should page a human for security events, not just for downtime, because an intrusion noticed a week late is much harder to clean up than one noticed in an hour.
Re-check hardening after every change
Hardening decays. Upgrades reset configuration files, new tools open new ports, a debugging session leaves an API exposed, and a teammate adds a key and forgets to remove it. After every upgrade, every new service, and every incident, re-run this checklist: SSH settings, firewall rules, open ports, key permissions, RPC binding, and update status. Put the re-check in the same runbook as the upgrade, so it happens as part of the change, not as a separate task that gets skipped.
A simple way to keep the check honest is to scan the server from outside once a quarter, using a port scanner against your own public address, and compare the open ports against the list you expect. Anything open that you did not expect is a finding, not a curiosity. Write the expected list down, and the scan becomes a test with a pass condition instead of a glance at output.
Hardening is not a one-time task, it is a habit that runs after every setup and every change. Lock down SSH, close the firewall, patch the OS, protect the keys, bind RPC to localhost, and monitor for intrusions, and re-check it all whenever anything changes. If your team runs validators and wants hardening, monitoring, and upgrades handled as a service, see our node operations and node setup pages, or start with a free infra audit and we will review your node security along with the rest of the stack.
Disclaimer: This post is educational only, not financial advice. Figures are listing or project data as of 2026-11-07 and may change - always confirm version numbers, requirements, and dates in the official docs before acting on them.
