P2P Network

A P2P network operates without a central server, forming a mesh or unstructured topology where each node (peer) connects directly to several others. This eliminates single points of failure and control, making the network resilient to attacks or shutdowns. Key characteristics include:

• Flat Hierarchy: All nodes are equal participants.
• Ad-Hoc Connections: Nodes dynamically discover and connect to peers.
• Redundancy: Data and transaction history are replicated across thousands of nodes.

Blockchains use gossip protocols (or epidemic protocols) to efficiently broadcast new transactions and blocks. When a node receives new data, it forwards it to a random subset of its connected peers, who then do the same. This creates a rapid, viral spread across the network. This method ensures:

• Eventual Consistency: All honest nodes eventually receive all valid data.
• Robustness: The network tolerates node churn (peers joining/leaving).
• Efficiency: Minimizes redundant messages compared to naive broadcasting.

Not all nodes in a P2P network perform the same function. Different node types assume specific roles based on their resources and configuration:

• Full Nodes: Store the complete blockchain history and validate all rules (e.g., Bitcoin Core, Geth).
• Archival Nodes: A subset of full nodes that also serve historical data to the network.
• Light Nodes (SPV Clients): Download only block headers, relying on full nodes for specific transaction data.
• Mining/Validator Nodes: Participate in consensus by creating new blocks (requires a full node).

To join a P2P network, a new node must discover its initial set of peers. This bootstrapping process typically uses:

• Hardcoded Seed Nodes: A list of stable, well-known nodes provided in the client software (e.g., Bitcoin's DNS seeds).
• Peer Exchange (PEX): Once connected, nodes share lists of their other peers.
• Discovery Protocols: Dedicated protocols like Kademlia (used by Ethereum's Discv4/Discv5) or Bitcoin's addr message system to find peers in a decentralized manner.

A core challenge in P2P networks is Sybil attacks, where an adversary creates many fake identities to subvert the network. Blockchains mitigate this not at the network layer, but through the consensus layer:

• Costly Identity: In Proof of Work, identity is tied to computational power (hashrate). In Proof of Stake, it's tied to staked capital.
• Network-Level Mitigations: Limiting connections per IP, using peer reputation scoring, and requiring proof of work for connection requests (e.g., Bitcoin's PoW for peers).

A Sybil attack occurs when a single adversary creates many fake identities (Sybil nodes) to gain disproportionate influence over the network. This can undermine consensus, disrupt routing, or enable eclipse attacks where a victim node is isolated and fed a false view of the network.

• Mitigation: Proof-of-Work (costly identity creation), Proof-of-Stake (economic stake), or reputation systems.

An eclipse attack is a network-layer attack where an adversary controls all connections to and from a specific victim node. By isolating the node, the attacker can:

• Feed it invalid blocks or transactions.
• Censor its view of the network.
• Enable double-spend attempts.

Mitigations include increasing the number of outgoing connections and using hardcoded bootnodes.

The gossip protocol used for propagating data is vulnerable to manipulation. Key issues include:

• Transaction Malleability: Altering a transaction's signature without changing its semantic meaning, potentially breaking downstream logic.
• Block Withholding: A miner discovers a block but delays broadcasting it to gain an advantage.
• Network Partitioning: Natural or malicious splits in the network can lead to temporary chain reorganizations.

P2P networks must withstand resource exhaustion attacks. Common vectors include:

• Connection Spam: Flooding nodes with new connection requests.
• Message Flooding: Sending malformed or resource-intensive messages (e.g., large blocks).
• CPU Exhaustion: Sending transactions with complex scripts.

Defenses involve rate limiting, peer scoring (e.g., Ethereum's eth/65), and sanity checks on incoming data.

While transactions may be pseudonymous, the P2P layer leaks metadata. Network observers can analyze:

• IP Addresses: Linking transactions to physical locations.
• Timing Analysis: Correlating transaction propagation to identify its origin node.
• Network Topology: Mapping the connections between nodes.

Solutions include Dandelion++ propagation, VPN/Tor usage, and light client protocols.

The initial connection to the network (bootstrapping) requires some trust. Nodes typically connect to a list of hardcoded bootnodes or use a DNS-based discovery mechanism. This creates a centralization vector:

• If bootnodes are compromised, they could provide false peer lists.
• DNS seeds could be censored or hijacked.

Decentralized alternatives like peer exchange (PEX) and random node discovery are used to reduce this reliance.

A node is any computer or device that participates in a P2P network by running the network's software. Nodes are responsible for maintaining the network's integrity by performing key functions:

• Full Nodes: Validate all transactions and blocks, storing a complete copy of the blockchain.
• Light Nodes: Download only block headers, relying on full nodes for transaction details.
• Mining/Validator Nodes: Specialized nodes that create new blocks through Proof-of-Work or Proof-of-Stake consensus.

A consensus mechanism is the protocol that enables all nodes in a decentralized P2P network to agree on a single, canonical state of the ledger. It is the core rule-set that prevents double-spending and ensures security without a central authority.

• Proof-of-Work (PoW): Used by Bitcoin, where nodes (miners) compete to solve cryptographic puzzles.
• Proof-of-Stake (PoS): Used by Ethereum, where nodes (validators) are chosen to create blocks based on the amount of cryptocurrency they "stake" as collateral.

A gossip protocol is the communication method used by nodes in a P2P network to efficiently propagate data. When a node receives new information (e.g., a transaction), it "gossips" it to a few randomly selected peers, who then do the same, creating an epidemic-style spread.

• This ensures robustness and fault tolerance; the network can withstand nodes joining, leaving, or failing.
• It provides eventual consistency, as all honest nodes will eventually receive all valid data, though not necessarily at the same time.

The client-server model is the centralized architectural antithesis of a P2P network. In this model, clients (e.g., web browsers) make requests to centralized servers (e.g., web hosts), which provide resources or services.

• Contrast with P2P: All communication flows through a central point, creating a single point of failure and control.
• Most traditional internet services (websites, email, cloud storage) are built on this model, which is efficient for managed services but lacks the censorship-resistance and resilience of P2P architectures.

A Sybil attack is a security threat where a single adversary creates a large number of fake identities (Sybil nodes) to gain disproportionate influence over a P2P network.

• The attack aims to subvert the network's reputation system or consensus mechanism.
• Blockchains mitigate this through costly consensus mechanisms (PoW, PoS) that make creating fake identities economically prohibitive. A network's resistance to Sybil attacks is a key measure of its decentralization.