pull down to refresh

The Stash #04: What Does a Remote Node Operator See? I Ran a Node and LookedThe Stash #04: What Does a Remote Node Operator See? I Ran a Node and Looked

Level: Intermediate · Reading time: ~15-20 min · Last checked: Nov 20, 2026 · Versions covered: Monero v0.18.5.4 "Fluorine Fermi" (stagenet), Feather Wallet 2.9.1

ContentsContents

Before we start: Special thanks to @samourai. I originally planned to write this post very differently, but their comment shaped it into what it is now, built around the trade-offs between a local node and Feather over Tor. This post is also my attempt to make up for the "what should you do" section that I forgot to include in the first one.

In shortIn short

A Monero wallet needs access to a copy of the blockchain to show your balance and send transactions. That copy is big: even a pruned node takes up about 100 GB. So mobile wallets in particular, and anyone who doesn't want to deal with the download, connect to someone else's node that holds the blockchain copy, in other words a remote node.

So what can the person running that node learn about us? Does Tor change that? Does running your own node really make a difference?

In this post I set up my own stagenet node, repeat the same experiment with three different connection methods, and look at the node's logs from an operator's point of view. The short version:

  • On a plain connection, the node ties the transaction we send directly to our IP address. (And an IP address can also reveal our internet service provider and approximate location.)
  • With Feather + Tor, the node doesn't see our IP address, only a Tor exit address.
  • With our own node, the wallet's requests never leave the computer. The only trace left is the IP address the transaction uses when it goes out to the P2P network.
  • In none of them could the node link a transaction we received to our wallet, and it couldn't see our balance, the amounts or the recipient either. The whole issue is in the transactions we send, not the ones we receive.

Experiment designExperiment design

The question is simple: what can the person running the node we connect to learn about us? We test it with three connection methods, using the same scenario:

MethodHow do we connect?
1. Plain connectionNo proxy in Feather. The wallet connects to the node directly over the internet, unencrypted (HTTP).
2. Feather + TorFeather's Tor mode, with all traffic including sync going over Tor ("always over Tor").
3. Our own nodeNode and wallet on the same computer. The node is closed to the outside, and the wallet connects only to 127.0.0.1.

For every method we ask the same questions:

  1. Does the node see our IP address?
  2. Can it link the transaction we send to that IP address, in other words to us?
  3. Can it learn about the transaction we receive, our balance or the amounts?
  4. Can it link the different requests made by the same wallet to each other?
  5. What do third parties along the way (the internet service provider, the Tor exit node) see?

In this scenario we are an honest node operator: all we do is look at what a normal remote node can learn about its users and what it can conclude from that. We do nothing else.

Setup and toolsSetup and tools

Why stagenet? To experiment on mainnet you'd need to download and verify about 100 GB, even pruned. Stagenet is a test network that uses the same protocol rules as mainnet, with worthless coins. It suits this experiment because the RPC communication between wallet and node runs on the same software and the same code. The chain is also much smaller (about 14 GB on my machine, and it sets up in a day). So for the purposes of this experiment, stagenet gives us a good way to observe the same wallet-to-node RPC behavior without having to deal with the much larger mainnet blockchain.

Tools we use:

  • monerod logs: We set the log level to 1 and additionally record RPC and HTTP communication at DEBUG level. Everything we could use for correlation in this experiment is already in this setting; logging at level 4 gives no extra information.
  • tcpdump: Records network traffic in raw form into a .pcap file.
  • Wireshark / tshark: We open the .pcap files to inspect connections and packet contents.
  • Feather Wallet 2.9.1: The wallet software. We use it without Tor in one scenario and with Tor in another.

The commands are written for the fish shell. If you use Bash, the only difference is that you write EXT_IF=$(...) instead of set EXT_IF (...) when assigning a variable. There's nothing else significant, so I haven't added another command just to stretch things out.

The post includes some console commands for listening and analysis, and I briefly explain what each one does. But you don't need to follow them closely: you can read along just by looking at what the commands output, and nothing is lost. The commands and the fixed test flow are there so that you can try it with your own hands if you want. You can repeat the whole experiment on stagenet, step by step. If, beyond the log extractions I used, you find other useful data, please share it in the comments. These are the extractions I made using the most basic methods I could, and it'd be great for others to see what you find.

Security note: In the experiment I exposed the node to the internet over 0.0.0.0, with a simple password like user:123 and unencrypted HTTP. On top of that I had to open a small port on my modem, so technically one of my modem's ports was open for the duration of the experiment. That's acceptable only for a temporary stagenet node in an experiment like this. Never copy such a setup on mainnet. If you ever need to open a port on your modem, be careful, and don't forget to close it when you're done, just in case.

Common test flowCommon test flow

To make the comparison fair, we create a new wallet in all three methods, and once the wallet is open we apply these steps in the same order:

  1. Synchronization: Connect to the node and wait for the wallet to fully sync to the latest block.
  2. Getting funds (faucet): Send test XMR to the wallet from a stagenet faucet.
  3. Wait until spendable: Wait for 10 block confirmations so the incoming balance becomes spendable.
  4. Transfer: Send half of the balance out (straight back to the faucet's return address, so we don't waste test coins).
  5. Transaction confirmation: Wait for 2 more block confirmations to give the transaction we sent a bit more confirmation depth.
  6. Close the records and analyze: Stop the node and the network capture tools; open the monerod logs and .pcap files and see what information we're left with.

About timestamps and IP addresses. For both anonymity and readability, I shifted all the times in the post and took the moment the node was started as 12:00:00. So the clock times aren't real, but the durations between events are exactly real (which is what matters). I've hidden the wallet's real IP address as [WALLET_IP], the Tor exit address as [TOR_IP], and the other nodes' addresses as PEER_IP.

Method 1: Plain connectionMethod 1: Plain connection

In the first scenario there's no privacy layer: the wallet connects to the node directly over the internet. Our goal is to see what the simplest connection leaks.

Opening the node to the outside and starting to listenOpening the node to the outside and starting to listen

On the computer we'll use as the node, we run this command:

monerod --stagenet \
  --data-dir ~/node/monero-stagenet \
  --rpc-bind-ip 0.0.0.0 --rpc-bind-port 38081 --confirm-external-bind \
  --rpc-login user:123 \
  --log-file ~/monerod-stagenet.log \
  --log-level 1,daemon.rpc:DEBUG,net.http:DEBUG

This command starts a stagenet node using the blockchain database in the directory we point to with --data-dir, listens for incoming connections on port 38081, and writes a detailed record of RPC/HTTP traffic to the monerod-stagenet.log file.

user:123 is just a simple authentication we set so that only our own wallet connects; it provides no network encryption. Because the connection is unencrypted (HTTP), third parties along the way, such as the internet service provider, can also see this traffic in plain text.

ParameterWhat it does
--stagenetUses the stagenet test network, which has no real monetary value.
--data-dir ...Points to the directory containing the blockchain database.
--rpc-bind-ip 0.0.0.0Opens the RPC interface to all incoming connections, not just the local computer.
--rpc-bind-port 38081Sets the port used for stagenet RPC connections.
--confirm-external-bindMandatory parameter confirming that we accept the risk of exposing the node to the outside network.
--rpc-login user:123Adds a username and password to RPC access. It's access control, not encryption.
--log-fileWrites the records to the specified file.
--log-level 1,daemon.rpc:DEBUG,net.http:DEBUGKeeps general logging at level 1 while recording RPC and HTTP communication in the finest detail.

Recording the network traffic rawRecording the network traffic raw

On top of the monerod logs, we run tcpdump to capture the packets passing through the network without any filter getting in the way:

sudo tcpdump -i any port 38081 -w ~/monero-network-capture.pcap
ParameterWhat it does
sudoGrants the administrator privileges needed to listen on network interfaces.
-i anyListens on all network interfaces on the computer at once.
port 38081Captures only the RPC port the wallet connects to. Node-to-node P2P traffic (38080) isn't in this capture.
-w fileWrites the captured packets to disk in .pcap format.

That's all for the node side. To repeat: a malicious operator could collect somewhat more data with far more technical methods, but we'll leave that out of scope and behave like a completely standard, honest operator. We'll only record the normal communication wallets have with us and look at what we can extract from it.

The wallet side: connecting from a different networkThe wallet side: connecting from a different network

We download Feather Wallet (the current version at the time of writing is 2.9.1) to the second computer. Since we'll be connecting to stagenet, we start the app not by double-clicking but from the terminal with the --stagenet flag:

./feather-2.9.1 --stagenet

To make the experiment match real conditions, we don't connect this computer to the same local network as the node; we go online through the phone's mobile data (hotspot). That gives us a real connection between node and wallet, made over the outside internet.

In the setup wizard we make two settings (you can change both later under the Node and Proxy tabs in Settings > Network):

  1. Custom node: We connect to our own node in the user:password@ip:port format:
user:123@[NODE_IP_ADDRESS]:38081
  1. Proxy: We change the Tor option, which comes selected by default, to None. In the first scenario we want to see what a plain connection leaks, with no privacy layer at all.

When we save the settings and create the new wallet, Feather connects to the node we're logging and starts scanning the blockchain. Once the wallet is fully synced, we apply the common test flow above.

Inspecting the recordsInspecting the records

The experiment is over; we've stopped both the node and tcpdump. We have two records: monerod-stagenet.log and monero-network-capture.pcap. Now we act like a node operator and look for the answer to a single question: what do we learn from these records about the owner of the transaction we sent? We start from the transaction itself, open the surrounding records one by one, and at the end tie what we found together.

1. Finding the transaction we sent1. Finding the transaction we sent

First we look for the request that relayed the transaction to the network. A wallet hands the transaction it prepared to the node with a sendrawtransaction request, so we search the logs for that word:

grep -n "sendrawtransaction" ~/monerod-stagenet.log
4398:2026-01-01 12:25:41.548 [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:98    HTTP [WALLET_IP] POST /sendrawtransaction
4399:2026-01-01 12:25:41.548 [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:116   [WALLET_IP:43514 INC] calling /sendrawtransaction
4409:2026-01-01 12:25:41.565 [RPC1]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:116   /sendrawtransaction processed with 0/17/0ms

The heart of it showed up with the very first command: the wallet handed the transaction to the node at 12:25:41.548, from [WALLET_IP], and the node recorded it down to the millisecond. The node already knows which IP address connected to it; it doesn't need to do anything extra. Now let's look around these lines, because a lot more records land in between as the node validates the transaction and adds it to the pool:

sed -n '4398,4410p' ~/monerod-stagenet.log | cut -c1-200
ParameterWhat it does
sed -n '4398,4410p'Prints only lines 4398 to 4410 of the file (the area around the line we just found).
cut -c1-200Shows the first 200 characters of each line so the output fits on screen.
2026-01-01 12:25:41.548 [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:98    HTTP [WALLET_IP] POST /sendrawtransaction
2026-01-01 12:25:41.548 [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:116   [WALLET_IP:43514 INC] calling /sendrawtransaction
2026-01-01 12:25:41.548 [RPC1]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:120   PERF             ----------
2026-01-01 12:25:41.556 [RPC1]  INFO    perf.ringct     src/common/perf_timer.cpp:156   PERF     5800        verRctSemanticsSimple
2026-01-01 12:25:41.556 [RPC1]  INFO    perf.blockchain src/common/perf_timer.cpp:156   PERF        1          expand_transaction_2
2026-01-01 12:25:41.564 [RPC1]  INFO    perf.ringct     src/common/perf_timer.cpp:156   PERF     7551            verRctCLSAGSimple
2026-01-01 12:25:41.564 [RPC1]  INFO    perf.ringct     src/common/perf_timer.cpp:156   PERF     7581          verRctNonSemanticsSimple
2026-01-01 12:25:41.564 [RPC1]  INFO    perf.blockchain src/common/perf_timer.cpp:156   PERF     8022        check_tx_inputs
2026-01-01 12:25:41.565 [RPC1]  INFO    txpool  src/cryptonote_core/tx_pool.cpp:351     Transaction added to pool: txid <f5xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx> weight: 1521 fee/byte:
2026-01-01 12:25:41.565 [RPC1]  INFO    perf.txpool     src/common/perf_timer.cpp:156   PERF    14840      add_tx
2026-01-01 12:25:41.565 [RPC1]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:156   PERF    16726    send_raw_tx
2026-01-01 12:25:41.565 [RPC1]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:116   /sendrawtransaction processed with 0/17/0ms
2026-01-01 12:25:41.566 [P2P1]  INFO    net.p2p.traffic contrib/epee/include/net/levin_protocol_handler_async.h:56      [PEER_IP:38080 OUT] 1563 bytes sent for category command-2002 initiated by us

The most important line in the output is this one:

12:25:41.565 [RPC1] Transaction added to pool: txid <f5.....> weight: 1521 fee/byte: 20000

(Note: in the output above, because of cut -c1-200, the end of this line is cut off at fee/byte:. Here I'm showing the uncut version of the line. The same cut-off happens in the other two methods, so you can read them the same way.)

So a wallet sent us a /sendrawtransaction request from [WALLET_IP], and just 17 milliseconds later a transaction was added to the pool. The transaction's txid is sitting plainly in the log; this is very valuable information, because now we have which address sent which transaction written down. On top of that, the transaction's size (weight: 1521) and its per-byte fee are in the record too. The PERF lines in between show the node validating the transaction and adding it to the pool. The [PEER_IP:38080 OUT] line at the bottom shows the node starting to forward the transaction to a peer on the network; we'll come back to that in Method 3.

So what else did the wallet ask the node while preparing this transaction? Let's list all the preparation requests:

grep -nE "get_fee_estimate|get_txpool_backlog|getblockheadersrange|get_output_distribution|get_outs|sendrawtransaction" ~/monerod-stagenet.log | cut -c1-160
830:2026-01-01 12:01:02.857     [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:98    HTTP [WALLET_IP] POST /get_output_distribution.bin
831:2026-01-01 12:01:02.857     [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:141   [WALLET_IP:43514 INC] calling /get_output_distribution.bin
833:2026-01-01 12:01:05.510     [RPC1]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:156   PERF  2655296    get_output_distribution_bin
834:2026-01-01 12:01:05.518     [RPC1]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:141   /get_output_distribution.bin() processed with 0/2653/6ms
4357:2026-01-01 12:25:38.736    [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:176   [WALLET_IP:43514 INC] Calling RPC method get_fee_estimate
4360:2026-01-01 12:25:38.736    [RPC1]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:176   /json_rpc[get_fee_estimate] processed with 0/0/0ms
4362:2026-01-01 12:25:38.802    [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:180   [WALLET_IP:43514 INC] Calling RPC method get_txpool_backlog
4364:2026-01-01 12:25:38.803    [RPC1]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:156   PERF       40    get_txpool_backlog
4365:2026-01-01 12:25:38.803    [RPC1]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:180   /json_rpc[get_txpool_backlog] processed with 0/0/0ms
4367:2026-01-01 12:25:38.859    [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:163   [WALLET_IP:43514 INC] Calling RPC method getblockheadersrange
4380:2026-01-01 12:25:38.861    [RPC1]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:163   /json_rpc[getblockheadersrange] processed with 0/1/0ms
4381:2026-01-01 12:25:39.008    [RPC0]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:98    HTTP [WALLET_IP] POST /get_output_distribution.bin
4382:2026-01-01 12:25:39.008    [RPC0]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:141   [WALLET_IP:43514 INC] calling /get_output_distribution.bin
4384:2026-01-01 12:25:39.008    [RPC0]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:156   PERF      238    get_output_distribution_bin
4385:2026-01-01 12:25:39.008    [RPC0]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:141   /get_output_distribution.bin() processed with 0/0/1ms
4386:2026-01-01 12:25:39.314    [RPC0]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:98    HTTP [WALLET_IP] POST /get_outs.bin
4387:2026-01-01 12:25:39.314    [RPC0]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:110   [WALLET_IP:43514 INC] calling /get_outs.bin
4389:2026-01-01 12:25:39.320    [RPC0]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:156   PERF     5637    get_outs_bin
4390:2026-01-01 12:25:39.320    [RPC0]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:110   /get_outs.bin() processed with 0/6/0ms
4398:2026-01-01 12:25:41.548    [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:98    HTTP [WALLET_IP] POST /sendrawtransaction
4399:2026-01-01 12:25:41.548    [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:116   [WALLET_IP:43514 INC] calling /sendrawtransaction
4409:2026-01-01 12:25:41.565    [RPC1]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:116   /sendrawtransaction processed with 0/17/0ms

(The lines at the very top, around 12:01, are the same kind of request made when the wallet was first opened; they have nothing to do with sending.) After hitting Send, the requests the wallet made, in order, are:

OrderRequestWhat for?
1get_fee_estimateFee estimate
2get_txpool_backlogHow busy the pool is
3getblockheadersrangeLatest block headers
4get_output_distribution.binOutput distribution, for picking decoys
5get_outs.binFetching the ring members
6sendrawtransactionHanding the transaction to the node

To be honest, nothing new for correlation comes out of these requests. They all come from the same address; in other words they just tell us once more what we already know: which IP address is making the requests. The node can already see the ring members from the transaction itself. It can't tell which one is the real input; of course, this ring is now matched with an IP address. But that's no more important than the txid match, and we had already tied the txid to the IP; these requests just repeat the same IP once more.

2. What else has this address done?2. What else has this address done?

Now we check whether the IP address we found was involved only in this transaction throughout the record, or did other things too. First we count who connected to the node's RPC port and how many requests they sent:

grep -oE "HTTP \[[^]]*\]" ~/monerod-stagenet.log | sort | uniq -c
  • grep -oE ... extracts only the connecting address from each request line.
  • sort and uniq -c group identical addresses and count how many requests each sent.
328 HTTP [WALLET_IP]

All 328 requests that came to the node came from a single address. We check the same thing from the network capture too:

tshark -r ~/monero-network-capture.pcap -q -z conv,tcp
Connection                            <- from node       -> to node           Total               Start       Duration (s)
WALLET_IP:43514 <-> 192.168.1.125:38081   20368 / 28 MB    8858 / 1130 kB      29226 / 29 MB       0.0         1922.4667
192.168.1.125:57224 <-> PEER_IP:38081         0 / 0 B         5 / 400 B           5 / 400 B           53.04       4.1000

The first line is our wallet's connection; the second line is a small connection the node itself made to another node on the outside, and it's unrelated to the experiment. So the only one connecting to our node on port 38081 is our wallet. That means that, as far as the node is concerned, the person who set up the wallet, synced it, downloaded blocks to scan for the funds from the faucet, and sent the transaction is the same person. There's no need to investigate that separately; it's all under the same address.

Since the traffic is entirely HTTP, let's not forget that requests and responses can be read in plain text. In other words the connection is unencrypted; not only the node operator but anyone along the way can see this traffic.

You might wonder: we only see a single address because only we connected to our node; what if others had connected too? We'd see the same thing, just with more lines. Every line in the log carries the address the request came from; even in a crowd, which request belongs to whom is written in the line itself. For a crowd to help, multiple people would need to appear behind the same address; that's exactly what we look at in the next method.

3. Looking for the transaction we received3. Looking for the transaction we received

Now we come to what we really wanted to know: can the node link the transaction we received to the wallet too? From the transaction details in Feather we copy the ID of the transaction the faucet sent and search for it in the records:

grep -n "f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" ~/monerod-stagenet.log | cut -c1-200
1201:2026-01-01 12:04:22.247    [P2P7]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
1210:2026-01-01 12:04:22.272    [P2P7]  INFO    txpool  src/cryptonote_core/tx_pool.cpp:351     Transaction added to pool: txid <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx> weight: 2200 fee/
1220:2026-01-01 12:04:23.934    [P2P0]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
1230:2026-01-01 12:04:24.190    [P2P0]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
1235:2026-01-01 12:04:24.741    [P2P3]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
1242:2026-01-01 12:04:25.275    [P2P0]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
1245:2026-01-01 12:04:25.312    [P2P8]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
1248:2026-01-01 12:04:25.353    [P2P2]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
1252:2026-01-01 12:04:26.563    [P2P6]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
1255:2026-01-01 12:04:27.219    [P2P0]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <f4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

This transaction is in the record, because the node sees all the transactions on the network. But nothing in those lines has anything to do with our wallet: the transaction reached us from the network through another node; it isn't a request our wallet made to the node. The wallet never tells the node "this transaction is mine"; it downloads the blocks and does the scanning on its own computer.

"But doesn't the moment the transaction entered a block match the moment the wallet downloaded the new block?" you might ask. It does match, but that's not a clue: every wallet downloads every new block, and a block can contain dozens of transactions. So the timing doesn't set us apart from other users. And because the recipient address is one-time (a stealth address), it can't be read from inside the transaction.

By the same logic, the wallet's balance and address never go to the node either (the scanning is done in the wallet, so the node doesn't see the result); the amount we send is encrypted inside the transaction, and the recipient is behind a one-time address. That's why everything we looked for in the records and couldn't find isn't there.

4. Putting everything we found together4. Putting everything we found together

Let's stack up the pieces. We have an IP address, a transaction ID (txid), the transaction's size and fee. What matters most is that the send request and the txid landing in the pool are back to back, only 17 milliseconds apart. Putting these together, we can comfortably say this:

The person at [WALLET_IP] submitted transaction f5..... to the network around 12:25:41.

We needed nothing but our own records to form this sentence, and the match is certain. On top of that, the IP address can reveal the internet service provider and an approximate location. Depending on the network, it may also give clues about the type of connection.

With the transaction we received, the situation is the opposite: the node sees the transaction but can't link it to the wallet. And it can't see the amount, the recipient or the balance in either case.

In short, a remote node used over a plain connection can link the transactions the user sends directly to them, but it can't learn about the transactions they receive or how much money they have. Now we repeat the same experiment with Tor and see whether the answer to "which IP sent this transaction?" changes.

Method 2: Feather + TorMethod 2: Feather + Tor

Now we repeat the same experiment with Feather's Tor setting and look for the answer to a single question: does Tor really reduce the information in the node operator's hands?

The setup is the same as in the first experiment: a new wallet, the same node, the same commands, the same log level. The only things that change are the names of the record files and the proxy setting in Feather. To avoid mix-ups, we save the log as monerod-stagenet-tor.log and the network capture as monero-tor-network-capture.pcap:

sudo tcpdump -i any port 38081 -w ~/monero-tor-network-capture.pcap
monerod --stagenet \
  --data-dir ~/node/monero-stagenet \
  --rpc-bind-ip 0.0.0.0 --rpc-bind-port 38081 --confirm-external-bind \
  --rpc-login user:123 \
  --log-file ~/monerod-stagenet-tor.log \
  --log-level 1,daemon.rpc:DEBUG,net.http:DEBUG

On the Feather side we change the proxy setting from None to Tor; the node address is still user:123@[NODE_IP_ADDRESS]:38081.

Important distinction: Even though the Tor option comes selected by default in Feather, with the default settings synchronization does not go over Tor (see the Feather documentation). In this experiment I deliberately chose the "always over Tor" option; that is, all the traffic the wallet sends to the node, sync included, went through Tor. We did not test the default setting in this post. That's because this way we imitate a user who is really using Tor.

The test flow is the same as before: sync, funds from the faucet, 10 confirmations, send half back, 2 confirmations. I again shifted the times so that the moment the node started counts as 12:00:00.

Inspecting the recordsInspecting the records

1. Who did the transaction come from this time?1. Who did the transaction come from this time?

Just like in the first experiment, we first look for the transaction we sent; this time, to avoid fiddling with line numbers, we have grep bring the surrounding lines too:

grep -n -A12 "POST /sendrawtransaction" ~/monerod-stagenet-tor.log | cut -c1-200
  • -A12 also brings the 12 lines below the matching line (a shortcut for picking a range with sed).
5460:2026-01-01 12:31:38.548    [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:98    HTTP [TOR_IP] POST /sendrawtransaction
5461-2026-01-01 12:31:38.549    [RPC1]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:116   [TOR_IP:39736 INC] calling /sendrawtransaction
5462-2026-01-01 12:31:38.549    [RPC1]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:120   PERF             ----------
5463-2026-01-01 12:31:38.560    [RPC1]  INFO    perf.ringct     src/common/perf_timer.cpp:156   PERF     9077        verRctSemanticsSimple
5464-2026-01-01 12:31:38.561    [RPC1]  INFO    perf.blockchain src/common/perf_timer.cpp:156   PERF        1          expand_transaction_2
5465-2026-01-01 12:31:38.569    [RPC1]  INFO    perf.ringct     src/common/perf_timer.cpp:156   PERF     7778            verRctCLSAGSimple
5466-2026-01-01 12:31:38.569    [RPC1]  INFO    perf.ringct     src/common/perf_timer.cpp:156   PERF     7821          verRctNonSemanticsSimple
5467-2026-01-01 12:31:38.569    [RPC1]  INFO    perf.blockchain src/common/perf_timer.cpp:156   PERF     8525        check_tx_inputs
5468-2026-01-01 12:31:38.570    [RPC1]  INFO    txpool  src/cryptonote_core/tx_pool.cpp:351     Transaction added to pool: txid <f7xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx> weight: 1531 fee/
5469-2026-01-01 12:31:38.570    [RPC1]  INFO    perf.txpool     src/common/perf_timer.cpp:156   PERF    18695      add_tx
5470-2026-01-01 12:31:38.570    [RPC1]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:156   PERF    21293    send_raw_tx
5471-2026-01-01 12:31:38.570    [RPC1]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:116   /sendrawtransaction processed with 0/22/0ms
5472-2026-01-01 12:31:38.571    [P2P4]  INFO    net.p2p.traffic contrib/epee/include/net/levin_protocol_handler_async.h:56      [PEER_IP:38080 OUT] 1573 bytes sent for category command-2002 initiated by us

The same lines as in the first experiment, but with one difference: the address sending the request is no longer the laptop's IP, it's [TOR_IP]. That's the address of a Tor exit node; in other words, the node sees not the wallet but traffic coming out of the Tor network. The rest is very familiar: the transaction reached the node at 12:31:38.548, was validated and added to the pool in 22 milliseconds, and its txid (f7.....) sits plainly in the log. It's just that this time it's tied to the IP of a Tor node.

I pulled out the wallet's preparation requests with the same filter too (for readability I kept only the lines where the request arrived):

5419:2026-01-01 12:31:32.716  [TOR_IP:39736 INC] Calling RPC method get_fee_estimate
5424:2026-01-01 12:31:32.980  [TOR_IP:39736 INC] Calling RPC method get_txpool_backlog
5431:2026-01-01 12:31:33.509  [TOR_IP:39736 INC] Calling RPC method getblockheadersrange
5445:2026-01-01 12:31:34.066  HTTP [TOR_IP] POST /get_output_distribution.bin
5450:2026-01-01 12:31:34.956  HTTP [TOR_IP] POST /get_outs.bin
5460:2026-01-01 12:31:38.548  HTTP [TOR_IP] POST /sendrawtransaction

The request order is exactly the same as in the first experiment: fee, pool congestion, block headers, output distribution, ring members and sending. The result is the same too: nothing new for correlation comes out of these requests. They're just matched, again, this time with the [TOR_IP] address.

2. Who connected to the node?2. Who connected to the node?

Now we look at the addresses and connections that connected to the node:

grep -oE "HTTP \[[^]]*\]" ~/monerod-stagenet-tor.log | sort | uniq -c
grep -oE "\[[0-9.]+:[0-9]+ INC\]" ~/monerod-stagenet-tor.log | sort | uniq -c
  • The second command extracts the connecting address from each line together with its source port; that way we see how many separate connections came from the same address.
410 HTTP [TOR_IP]

    350 [TOR_IP:39736 INC]
      1 [TOR_IP:58238 INC]
     59 [TOR_IP:61361 INC]

All 410 requests that came to the node came from [TOR_IP] again. Once more, no additional valuable information.

tshark -r ~/monero-tor-network-capture.pcap -q -z conv,tcp
Connection                           <- from node       -> to node           Total               Start       Duration (s)
TOR_IP:39736 <-> 192.168.1.125:38081    28849 / 40 MB    26725 / 2339 kB     55574 / 42 MB       102.27      2036.4348
TOR_IP:61361 <-> 192.168.1.125:38081    13480 / 19 MB    12729 / 969 kB      26209 / 20 MB       0.0         97.1357
TOR_IP:58238 <-> 192.168.1.125:38081      257 / 342 kB     241 / 20 kB         498 / 363 kB      97.59       3.4306
192.168.1.125:46042 <-> PEER_IP:38081       0 / 0 B          5 / 400 B           5 / 400 B       1000.88     4.1229

The first three lines are the wallet's three connections: the one on port 61361 carried the first 97 seconds (the start of the sync), the one on port 58238 a small 3-second window, and the one on port 39736 the remaining roughly 34 minutes. The fourth line is the node's own outbound connection, unrelated to the experiment. The thing to notice: the real IP address of the computer we ran the wallet on doesn't appear anywhere in the records. Every address that connected to the node on port 38081 is a Tor exit address.

3. Looking for the transaction we received3. Looking for the transaction we received

grep -n "07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" ~/monerod-stagenet-tor.log | cut -c1-200
2290:2026-01-01 12:06:15.597    [P2P6]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2300:2026-01-01 12:06:15.624    [P2P6]  INFO    txpool  src/cryptonote_core/tx_pool.cpp:351     Transaction added to pool: txid <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx> weight: 2201 fee/
2304:2026-01-01 12:06:15.734    [P2P6]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2309:2026-01-01 12:06:15.916    [P2P8]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2316:2026-01-01 12:06:16.352    [P2P7]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2320:2026-01-01 12:06:16.493    [P2P7]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2328:2026-01-01 12:06:16.704    [P2P7]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2333:2026-01-01 12:06:16.932    [P2P5]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2338:2026-01-01 12:06:17.778    [P2P7]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2347:2026-01-01 12:06:18.876    [P2P0]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2353:2026-01-01 12:06:20.083    [P2P3]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2356:2026-01-01 12:06:20.531    [P2P4]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
2361:2026-01-01 12:06:21.062    [P2P3]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <07xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

The result is the same as in the first experiment: the transaction is in the record but isn't linked to any wallet request. Tor didn't change anything here, because there was no leak in the first place.

4. Putting everything we found together4. Putting everything we found together

In the first experiment we could form this sentence: "The person at [WALLET_IP] submitted transaction f5..... to the network." The sentence we can form with Tor is this:

The exit address [TOR_IP] submitted transaction f7..... to the network around 12:31:38.

The difference is huge. The IP address in the first sentence gives information at a level that directly reveals who the user is: an IP address gives an approximate location, and since both a home internet connection and a mobile line are always registered under some identity, for someone looking in the right place that IP can extend all the way to a name. None of that is in the second sentence; from a Tor exit address we can't work out where the device is or who it belongs to. This is exactly where Tor earns its keep, and it's nothing to sneeze at.

But the node hasn't lost everything. The same exit address sent all 410 requests. So the node can link the requests from the wallet setup and sync, ring preparation and transaction submission to the same Tor exit address. It has no name, but it has a consistent "pseudonym": [TOR_IP]. The transaction's size, the time it was sent and how long the wallet stayed online are all still tied to that same pseudonym. But let's be honest, this isn't information that really damages privacy. The most important link in the chain was the IP address, and Tor hides it successfully. What's left in our hands as meaningful data is timestamps, and that's not information you can use in a way that actually helps you under normal circumstances. Besides, we'll see shortly that with a local node we don't give even that to anyone.

In short, Tor leaves the node's question of "who is this?" unanswered, and that's actually good protection. Now on to the last scenario: the case where we connect to no outside node at all, use a fully local node and never expose it to the outside.

Method 3: Our own nodeMethod 3: Our own node

In the last scenario both the node and the wallet run on the same computer, and we don't expose the node to the outside at all. Since the RPC port listens only on 127.0.0.1 by itself, we don't use the --rpc-bind-ip and --rpc-login parameters either. The proxy setting in Feather is None, and the node address is 127.0.0.1:38081. The test flow is again the same; I shifted the times in this experiment too.

This time, since the traffic between wallet and node won't leave the computer, there are two places to listen: the traffic inside the computer (between wallet and node) and the traffic leaving through the computer's outward-facing network interface. The second will give the answer to the real question: do the wallet's requests leak out of the machine?

set EXT_IF (ip route show default | awk '{print $5}' | head -1)
sudo tcpdump -i $EXT_IF "port 38081 or port 38080" -w ~/monero-external-interface.pcap
sudo tcpdump -i lo port 38081 -w ~/monero-loopback.pcap
monerod --stagenet \
  --data-dir ~/node/monero-stagenet \
  --log-file ~/monerod-stagenet-local.log \
  --log-level 1,daemon.rpc:DEBUG,net.http:DEBUG
ParameterWhat it does
ip route show default and awk '{print $5}'Finds the name of the network interface the computer uses to reach the internet and assigns it to the EXT_IF variable. (Just for convenience; not an important detail.)
port 38081 or port 38080Listens on both the RPC port used for the wallet connection (38081) and the P2P port the nodes use to talk to each other (38080).
-i loListens to the traffic inside the computer itself (loopback); this is where the wallet and node talk.

Inspecting the recordsInspecting the records

1. Who did the transaction come from this time?1. Who did the transaction come from this time?

Just like in the previous two experiments, we first look for the transaction we sent:

grep -n -A12 "POST /sendrawtransaction" ~/monerod-stagenet-local.log | cut -c1-200
258214:2026-01-01 12:34:41.949  [RPC0]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:98    HTTP [127.0.0.1] POST /sendrawtransaction
258215-2026-01-01 12:34:41.949  [RPC0]  INFO    daemon.rpc      src/rpc/core_rpc_server.h:116   [127.0.0.1:38502 INC] calling /sendrawtransaction
258216-2026-01-01 12:34:41.949  [RPC0]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:120   PERF             ----------
258217-2026-01-01 12:34:41.959  [RPC0]  INFO    perf.ringct     src/common/perf_timer.cpp:156   PERF     5786        verRctSemanticsSimple
258218-2026-01-01 12:34:41.960  [RPC0]  INFO    perf.blockchain src/common/perf_timer.cpp:156   PERF        1          expand_transaction_2
258219-2026-01-01 12:34:41.964  [RPC0]  INFO    perf.ringct     src/common/perf_timer.cpp:156   PERF     4204            verRctCLSAGSimple
258220-2026-01-01 12:34:41.964  [RPC0]  INFO    perf.ringct     src/common/perf_timer.cpp:156   PERF     4231          verRctNonSemanticsSimple
258221-2026-01-01 12:34:41.964  [RPC0]  INFO    perf.blockchain src/common/perf_timer.cpp:156   PERF     4966        check_tx_inputs
258222-2026-01-01 12:34:41.965  [RPC0]  INFO    txpool  src/cryptonote_core/tx_pool.cpp:351     Transaction added to pool: txid <50xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx> weight: 1519 fe
258223-2026-01-01 12:34:41.965  [RPC0]  INFO    perf.txpool     src/common/perf_timer.cpp:156   PERF    11686      add_tx
258224-2026-01-01 12:34:41.965  [RPC0]  INFO    perf.daemon.rpc src/common/perf_timer.cpp:156   PERF    15900    send_raw_tx
258225-2026-01-01 12:34:41.965  [RPC0]  DEBUG   daemon.rpc      src/rpc/core_rpc_server.h:116   /sendrawtransaction processed with 0/16/0ms
258226-2026-01-01 12:34:41.966  [P2P0]  INFO    net.p2p.traffic contrib/epee/include/net/levin_protocol_handler_async.h:56      [PEER_IP:38080 OUT] 1561 bytes sent for category command-2002 initiated by u

The lines are familiar again, but this time the address sending the request is 127.0.0.1. In other words, the client the node sees is the computer itself. The transaction was validated and added to the pool in 16 milliseconds; its txid (50.....) is again in the log. On a plain connection this is where the laptop's IP was, and with Tor it was an exit address. Here there's no internet service provider, no location and no line type, because the place the request came from is our own computer.

The order of the preparation requests is again exactly the same (again I kept only the lines where the request arrived):

258173:2026-01-01 12:34:38.472  [127.0.0.1:38502 INC] Calling RPC method get_fee_estimate
258178:2026-01-01 12:34:38.482  [127.0.0.1:38502 INC] Calling RPC method get_txpool_backlog
258183:2026-01-01 12:34:38.483  [127.0.0.1:38502 INC] Calling RPC method getblockheadersrange
258197:2026-01-01 12:34:38.489  HTTP [127.0.0.1] POST /get_output_distribution.bin
258202:2026-01-01 12:34:38.549  HTTP [127.0.0.1] POST /get_outs.bin
258214:2026-01-01 12:34:41.949  HTTP [127.0.0.1] POST /sendrawtransaction

The conclusion from the earlier experiments holds here too: nothing new comes out of these requests.

2. What goes out?2. What goes out?

Now we look at the real difference. First we count who connected to the node:

grep -oE "HTTP \[[^]]*\]" ~/monerod-stagenet-local.log | sort | uniq -c
481 HTTP [127.0.0.1]

All 481 requests that came to the node came from 127.0.0.1; there's no other address. Now we look at the traffic inside the computer, then the traffic going out:

tshark -r ~/monero-loopback.pcap -q -z conv,tcp
tshark -r ~/monero-external-interface.pcap -q -z conv,tcp

Output of the first command (from inside, loopback):

Connection                         <- from node      -> to node           Total               Start       Duration (s)
127.0.0.1:38502 <-> 127.0.0.1:38081   4287 / 57 MB    2776 / 625 kB       7063 / 58 MB        44.71       2245.2927
127.0.0.1:45170 <-> 127.0.0.1:38081      5 / 919 B       7 / 3872 B         12 / 4791 B      2073.33     120.3011
127.0.0.1:38844 <-> 127.0.0.1:38081      3 / 206 B       4 / 272 B           7 / 478 B       0.0         0.0008

Output of the second command (the outward-facing interface; I shortened it because there are over a hundred lines):

Connection                            <- from node       -> to node           Total               Start       Duration (s)
192.168.1.125:58420 <-> PEER_IP:38080   3433 / 4834 kB    2053 / 168 kB       5486 / 5003 kB      0.0         1718.1023
192.168.1.125:49036 <-> PEER_IP:38080   3317 / 4751 kB    2033 / 150 kB       5350 / 4901 kB      3.55        71.9451
192.168.1.125:54530 <-> PEER_IP:38080   3384 / 4824 kB    1936 / 150 kB       5320 / 4975 kB      2.15        1210.8816
[... over a hundred more lines, all :38080 ...]

The first table is where the wallet talks to the node: three connections, all between 127.0.0.1 and 127.0.0.1. One of them is the main connection (it lasted about 37 minutes and carried about 58 MB), and the other two are small connections of a few kilobytes.

The second table is the traffic going out of the computer, and what to notice here is that there isn't a single line belonging to port 38081. All of the hundred-plus connections are 38080, the P2P port the node uses to talk to other nodes. In other words, what the wallet asked the node, which blocks it downloaded and how it picked the ring members never left the computer. There's no internet service provider, no Tor exit node and no node operator on the network who could see it.

3. Looking for the transaction we received3. Looking for the transaction we received

grep -n "4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" ~/monerod-stagenet-local.log | cut -c1-200
254687:2026-01-01 12:16:57.154  [P2P0]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254696:2026-01-01 12:16:57.181  [P2P0]  INFO    txpool  src/cryptonote_core/tx_pool.cpp:351     Transaction added to pool: txid <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx> weight: 2202 fe
254702:2026-01-01 12:16:57.434  [P2P2]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254705:2026-01-01 12:16:57.967  [P2P7]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254708:2026-01-01 12:16:58.154  [P2P4]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254711:2026-01-01 12:16:58.243  [P2P0]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254718:2026-01-01 12:16:59.195  [P2P7]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254771:2026-01-01 12:17:00.213  [P2P6]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254775:2026-01-01 12:17:00.766  [P2P7]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254779:2026-01-01 12:17:01.183  [P2P3]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254782:2026-01-01 12:17:01.393  [P2P6]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254785:2026-01-01 12:17:01.504  [P2P3]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
254814:2026-01-01 12:17:15.160  [P2P5]  INFO    net.p2p.msg     src/cryptonote_protocol/cryptonote_protocol_handler.inl:898     Including transaction <4cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

The result is the same here too; but now there isn't even a third party holding this information.

4. Putting everything we found together4. Putting everything we found together

In this scenario, the sentence the node can form is this:

127.0.0.1 submitted transaction 50..... to the network around 12:34:41.

127.0.0.1 is our own computer, so this sentence tells no one anything. In the previous two experiments this line said, respectively, the laptop's real IP and a Tor exit address. Here there is no third person holding this information: the one running the node and the one using the wallet are both us.

But there is one thing that does go out: the transaction itself. In the last line of the log output above, there's the line where, once the transaction enters the pool, the node sends it to a node on the network (PEER_IP). This transaction leaves our node with our home IP address, and it's unavoidable that the first node to receive the transaction sees this address. That doesn't reveal who the wallet is, it reveals the node's address, but it's still a piece of information. Think of it like this: we're broadcasting the transaction to the network, and while doing so the other nodes on the P2P network know our IP address. Under normal circumstances, those nodes could use the information of who they first heard this transaction from to match it with our IP address again.

But here an important feature of Monero comes into play: Dandelion++.

Instead of announcing your transaction to the network directly, Dandelion++ breaks this match by quietly whispering it to a single randomly chosen neighbor (which then passes it on to another one). Because the nodes on the network are constantly relaying other people's transactions to each other anyway, a malicious node listening on its own can't tell whether the transaction originated with you or just passed through you. So unless there's a huge surveillance setup watching a large part of the network, matching the transaction's true source to your IP address isn't easy.

In our experiment there's a single listening node, so this question doesn't even come up. But in a broader surveillance scenario even Dandelion++ may not be enough on its own. It's possible to use the local node with a Tor proxy too, and against that kind of wide-scale listening scenario it's better than a local node by itself. That's worth noting as well.

In short, someone using their own node leaks the wallet's requests to no third party. The only trace left is the IP address used when the transaction goes out to the P2P network. And thanks to Dandelion++, tying the transaction to that IP isn't straightforward, even in our scenario.

Comparison and rankingComparison and ranking

I ranked the three methods from the one that protects privacy the most to the least, based on what the node operator (and those along the way) learn:

RankMethodWhat do the node and those along the way learn?ProsCons
1Our own nodeWallet requests never leave the computer. Peers broadcasting the transaction on the P2P network see only our home IP.No need to trust a third party. We verify the chain ourselves. Dandelion++ makes it difficult to link the transaction to our IP.Requires ~100 GB disk space (even pruned), a long initial sync, and an always-on computer. (Home IP can be masked with --tx-proxy).
2Feather + Tor (remote node)Real IP isn't visible, only a Tor exit address.Easy setup, no disk space needed. IP, location, and ISP stay hidden.Requires trusting the remote node. On unencrypted HTTP, the exit node can read the content. Must ensure all traffic goes through Tor.
3Plain connection (remote node)Real IP, ISP, approximate location, and connection type. Every transaction sent is tied directly to the IP. Those along the way can read unencrypted content.Easiest and fastest way. No extra setup.Maximum leakage is here. Requires full trust in the node. Your IP address is linked to your transaction.

Putting the sentence the node can form in each method side by side makes the difference clearer:

  • Plain connection: "The person at [WALLET_IP] submitted transaction f5..... to the network."
  • Feather + Tor: "The exit address [TOR_IP] submitted transaction f7..... to the network."
  • Our own node: "127.0.0.1 submitted transaction 50..... to the network."

Two things didn't change across all three methods. First: the transaction we sent itself (its existence, size, fee, time) is always in the node's hands, because handing the transaction to the network requires that anyway. Second: in none of them could we find the transaction we received, our balance, the amount or the recipient in the records. The leak, as in #01, is again outside Monero: at the layer of who sent which transaction from which address, in other words through the IP address. So the things Monero hides (recipient, amount, balance) stayed hidden in this experiment too; the difference showed up in the trail the wallet user leaves on the network.

Our own node or Tor?

What we saw at the end of the experiment is this: there isn't as big a difference between these two methods as you'd first assume. When it comes to privacy, Tor does a job quite close to a local node.

There's even an ironic twist: while in our single-listener-node scenario Dandelion++ gives enough protection against tying the IP to the txid, in a large-scale, general surveillance situation we need to use even our own node through Tor. So it's very clear that the Tor network generally provides a good additional layer of privacy.

But to give a straight answer to the question: using our own node leaks almost no linkable information to the outside, so if we have enough space and time, it's the best in every respect. If possible, using the local node with a Tor proxy as well is the best of all the scenarios. But if we don't have enough space or time, connecting to a well-known remote node through a Tor proxy really does help with privacy too, and it's worth admitting that. In the end, connecting to a remote node with Tor did a really good job.

What should you do?What should you do?

  • If you can, run your own node, and even send the transaction broadcast through a Tor proxy (monerod has a --tx-proxy option for this). This is the best.
  • If you can't, connecting to a well-known remote node through a Tor proxy also does a really good job. It's better to route everything, sync included, through Tor ("always over Tor") in the settings. To keep the first sync from being very slow, Feather doesn't use Tor for it in the default settings; still, depending on your situation, choosing "always over Tor" is the best.
  • Prefer HTTPS nodes over HTTP where possible. This isn't about the node itself, but it stops third parties along the way, or your internet service provider, from seeing all your communication in plain text, wide open.
  • Choose remote nodes carefully. "We don't keep logs" is not a guarantee that they don't.
  • If privacy is really important to you and you want to leave no room for doubt, it's always best to assume the worst case: set up your own node and connect to it through a proxy over Tor or the I2P network. Going by the results of this experiment, that's the maximum you can do.

Limits of the experimentLimits of the experiment

This is a single-wallet, single-run observation rather than a broad statistical study. It shows what a standard, honest node operator can see with detailed logging turned on, not what a global adversary or a malicious operator could do. Additionally, the tests ran on stagenet; while the RPC behavior matches mainnet, mainnet’s heavier traffic and concurrent users make timing analysis significantly noisier, though the core IP correlation still holds.

Finally, the Tor test only covered the "always over Tor" mode (using Monero v0.18.5.4 and Feather 2.9.1 for Linux); behavior may vary in other versions or platforms.

Thanks for reading. I'd be glad to hear your thoughts or criticism about the post.

Absolutely fantastic—the more I learn about Monero, the more indispensable it becomes; it’s truly remarkable.

reply

Thanks, @fujimoto. You always demonstrate the deepest understanding of XMR; I’ve learned more about XMR from you than from all other sources combined.

reply

Great write up, especially appreciate that you tested the same flow and separated what the node can actually observe from what it can’t infer. Thanks for turning the discussion into a reproducible experiment.

reply