
Funding: This article contains no direct affiliate purchase links. CypherpunkGuide may earn commissions through linked buying guides.
A node is running, synchronization works, and the firewall reports that it is active. Those observations answer useful questions. They do not answer who can reach the node’s management interface.
RPC, or remote procedure call, is the interface software uses to ask Bitcoin Core for information or instruct it to act. It is different from peer-to-peer communication with other Bitcoin nodes. An intended peer connection does not justify exposing management access. Depending on enabled wallets and permissions, RPC access can affect funds and reveal private information. Bitcoin Core’s security documentation warns against exposing RPC to the public internet.
The task is to establish what each observation proves. That is also the distinction behind our custody verification guide: a reassuring display is useful only within its limits.
What the source analysis establishes#
This analysis traces Bitcoin Core v31.1 source code and Docker documentation. It does not measure a running node, an open port, or a firewall’s behavior on any machine.
The Core source is fixed at commit 9be056a8a72b624dae9623b2f7bded92c2a21c91, retrieved on October 10, 2026. The downloadable evidence package contains seven public source files, their acquisition manifest and SHA-256 hashes, and the eight-case analysis. A hash lets readers check the saved file; it is not a binary signature verification. Docker documentation was checked on October 10 and rechecked on October 11, 2026; it is a changing document, not a pinned Engine test.
No service was started and no wallet, authentication secret, or real funds were used. All eight cases retain not_tested as their observed result. The contribution is a traceable comparison between configuration claims and the evidence still needed to establish reachability.
Separate the listener, client permission, and authentication#
Bitcoin Core’s listening address, allowed client addresses, authentication, and permitted operations are separate controls. Passing or failing one control does not establish the state of the others.
A listener is the address and port where a program accepts connections. Loopback addresses, such as 127.0.0.1 and ::1, refer back to the same network environment. Docker runs applications in containers, separated environments on a host machine. The host and a normally isolated container have different loopback environments.
| Control | Question it answers | What it does not establish |
|---|---|---|
| RPC server enabled | Should the management server start? | Whether startup and binding succeeded |
rpcbind | Which addresses and optional ports should Core listen on? | Which remote clients or operations are authorized |
rpcallowip | Which client addresses should pass the source-address check? | Authentication or encrypted transport |
| Authentication | Does this request present acceptable credentials? | That the connection is private or every operation is allowed |
| Operation permissions | May this authenticated user invoke this method? | That other methods or other routes are inaccessible |
In the pinned HTTP server code, if either rpcbind or rpcallowip has no values, the listening candidates fall back to loopback. This does not mean the separate source-address permission list is discarded. When both have values, binding and client permission checks still occur separately.
Do not copy these setting names into a configuration just to make a test succeed. First establish what the running process actually uses. The daemon, bitcoind, enables server mode by default; the graphical application does not, according to the pinned RPC interface documentation. A working graphical debug console does not establish that an HTTP listener exists.
Checking only port 8332 is insufficient. That is the pinned version’s mainnet RPC default; another Bitcoin network or a custom setting can use another port. rpcport overrides the network default, and a port explicitly supplied in rpcbind takes precedence for that binding. In a container setup, distinguish the host port from the container port.
Docker adds routes that a UFW status cannot settle#
For Linux Docker bridge networking, an active UFW firewall is not proof that a published container port is blocked. UFW is a Linux firewall management tool; bridge networking connects containers through a virtual network on the host. Docker’s official firewall documentation explains that published traffic is redirected before the INPUT and OUTPUT chains UFW normally uses.
The port-publishing documentation adds conditions: omitted host addresses normally mean all host addresses, unless a default binding override applies. A mapping still does not prove Core is listening inside the container.
Loopback publication is not a universal all-route guarantee. Docker documents a same-L2 exception before version 28.0.0, meaning machines on the same local network segment could reach such ports. Direct access to container addresses also depends on routing, gateway mode, and settings such as trusted_host_interfaces. Inspect host and container destinations separately.
These statements do not provide a universal repair command for Docker Desktop, Swarm, every network driver, or every firewall backend. The worksheet asks for the actual environment. The broader costs of maintaining it belong in the self-hosting decision.
Use eight cases to identify missing evidence#
The eight cases below are checks to document, not eight successful security tests. Download the blank exposure worksheet and the source-backed case record. Keep credentials, real addresses, and identifying infrastructure details out of a shared copy.
| Case | What to establish | What remains unknown without observation |
|---|---|---|
| R01: native defaults | Core version, daemon or GUI, effective server mode | Whether a listener actually opened |
| R02: remote allowlist | Effective binding and source-address restrictions | The peer address Core sees and the reachable route |
| R03: custom port | Network, effective RPC port, explicit bind ports | Which destination and port the client actually reaches |
| R04: Docker publication | Engine version, network mode, host binding, inner listener | Whether the mapping produces a reachable service |
| R05: loopback publication | Host route and direct container route separately | Effects of old Engine versions and direct routing |
| R06: UFW active | OS, firewall backend, actual packet path | Whether that path is filtered |
| R07: IPv4 and IPv6 | Listener, mapping, and route for each address family | Whether one family’s result applies to the other |
| R08: private transport | Endpoint ownership, protected path, remaining listeners | Whether traffic or management access remains exposed elsewhere |
When it falls back to loopback, the pinned binding function tries both address families, but reports success if at least one binding succeeds. An apparently successful start is therefore not evidence that both listeners opened. Docker gateway modes can also differ between IPv4 and IPv6.
Use the worksheet in this order:
- Identify the intended management client and the destination it should reach. Use role labels in shared notes.
- Record effective non-secret settings and observed listeners. A sample configuration file is not proof of what the running process loaded. Do not export complete configuration or process output that may contain credentials.
- Document host and container paths for each address family. Where relevant, include the router’s role; our home router audit addresses that separate boundary.
- If you perform reachability testing, use only systems you own or are authorized to test. Record the client location, destination role, address family, time, and exact class of result. Never open RPC to the public internet to simplify the test.
- Mark missing evidence
unknown. Resolve it before relying on a claim that management access is restricted to the intended clients.
Read an HTTP refusal as a response, not a closed port#
An HTTP error means an HTTP service responded along the tested path. It does not prove the network port was unreachable, and it does not identify Bitcoin Core as the responder when a proxy is present.
The pinned RPC handler returns 401 for missing or failed authentication in the relevant request path. A 403 can arise from source-address refusal or, later, restrictions on an authenticated user’s permitted methods. The status alone cannot tell you which control rejected the request.
| Result | Narrow interpretation |
|---|---|
| Connection refused | That connection attempt was rejected; this does not describe all routes |
| Timeout | No usable response arrived in the test interval; the cause is unresolved |
| HTTP 401 or 403 | An HTTP service was reachable and refused the request at some stage |
| Valid RPC response | That request worked on that path under those conditions |
Authentication also does not encrypt RPC traffic. A VPN, SSH tunnel, or Tor onion endpoint does not by its name prove that host trust, endpoint access, and leftover listeners are safe. The Core documentation explicitly warns against public RPC exposure, including publicly exposing an onion service. A transport choice must be assessed together with who controls its endpoints and who can access them.
Sources and verification limits#
Core claims use the fixed v31.1 source below. Docker claims use the dated documentation review. Both Docker documentation archives have been verified. The five Core archives preserve the raw source files; their contents exactly match the fixed source used for this analysis.
| Source | Original URL | Archive |
|---|---|---|
| Core RPC interface and security | Fixed source | Verified archive |
| Core HTTP server | Fixed source | Verified archive |
| Core authentication and method checks | Fixed source | Verified archive |
| Core startup | Fixed source | Verified archive |
| Core network port defaults | Fixed source | Verified archive |
| Docker port publishing | Documentation | Verified archive |
| Docker and UFW | Documentation | Verified archive |


