Rust网络隐私保护库libp2p-pnet的使用，实现安全点对点通信和私有网络构建

Rust网络隐私保护库libp2p-pnet的使用，实现安全点对点通信和私有网络构建

安装

在项目目录中运行以下Cargo命令：

cargo add libp2p-pnet

或者在Cargo.toml中添加以下行：

libp2p-pnet = "0.26.0"

示例代码

以下是一个使用libp2p-pnet实现安全点对点通信和私有网络构建的完整示例：

use libp2p::{
    identity,
    pnet::{PnetConfig, PreSharedKey},
    swarm::{Swarm, SwarmEvent},
    Multiaddr, PeerId, Transport,
};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // 生成密钥对
    let key_pair = identity::Keypair::generate_ed25519();
    let peer_id = PeerId::from(key_pair.public());
    println!("本地节点ID: {}", peer_id);

    // 设置预共享密钥 - 这是私有网络的关键
    let psk = PreSharedKey::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
                                17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]);
    
    // 创建传输层
    let transport = libp2p::development_transport(key_pair).await?;
    
    // 添加私有网络支持
    let transport = transport.and_then(move |socket, _| {
        PnetConfig::new(psk).handshake(socket)
    });

    // 创建Swarm
    let mut swarm = {
        let behaviour = libp2p::ping::Behaviour::new(libp2p::ping::Config::new());
        Swarm::new(transport, behaviour, peer_id)
    };

    // 监听所有接口的随机端口
    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;

    // 如果指定了要连接的地址
    if let Some(addr) = std::env::args().nth(1) {
        let remote: Multiaddr = addr.parse()?;
        swarm.dial(remote)?;
        println!("正在连接到远程节点: {}", addr);
    }

    loop {
        match swarm.select_next_some().await {
            SwarmEvent::NewListenAddr { address, .. } => {
                println!("监听到地址: {}", address);
            }
            SwarmEvent::Behaviour(event) => {
                println!("{:?}", event);
            }
            _ => {}
        }
    }
}

代码说明

  1. 密钥生成:

    • 使用identity::Keypair::generate_ed25519()生成ED25519密钥对
    • 从公钥派生PeerId用于网络标识

  2. 私有网络配置:

    • 创建32字节的预共享密钥(PSK) - 这是私有网络的关键
    • 只有拥有相同PSK的节点才能相互通信

  3. 网络传输层:

    • 使用development_transport创建基础传输层
    • 通过PnetConfig添加私有网络支持

  4. 节点行为:

    • 使用简单的ping行为进行测试
    • 可以通过替换为更复杂的行为来实现特定功能

  5. 网络连接:

    • 监听本地所有接口的随机端口
    • 支持通过命令行参数连接其他节点

使用方法

  1. 编译运行第一个节点:
cargo run

  1. 获取第一个节点的监听地址(如/ip4/127.0.0.1/tcp/58923)

  2. 运行第二个节点并连接到第一个节点:

cargo run /ip4/127.0.0.1/tcp/58923

注意事项

  • 所有通信节点必须使用相同的预共享密钥
  • 预共享密钥应保密处理，不应硬编码在生产环境中
  • 此示例仅展示基本功能，实际应用中需要添加更多安全措施

通过这个示例，您可以构建一个基于libp2p-pnet的私有网络，实现安全的点对点通信。


1 回复

Rust网络隐私保护库libp2p-pnet的使用指南

下面是基于提供内容的完整示例demo，展示了如何使用libp2p-pnet构建一个安全的点对点网络：

use libp2p::{
    identity, 
    Multiaddr, 
    noise, 
    tcp::TokioTcpConfig, 
    yamux,
    ping::{Ping, PingConfig, PingEvent},
    swarm::{Swarm, SwarmEvent, NetworkBehaviour},
};
use libp2p_pnet::{PnetConfig, PreSharedKey};
use std::error::Error;

// 定义网络行为
#[derive(NetworkBehaviour, Default)]
struct MyBehaviour {
    ping: Ping,  // 包含ping协议用于测试连接
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // 1. 生成密钥对
    let local_key = identity::Keypair::generate_ed25519();
    let local_peer_id = local_key.public().to_peer_id();
    println!("本地节点ID: {:?}", local_peer_id);

    // 2. 设置预共享密钥 (32字节十六进制字符串)
    let psk = PreSharedKey::from_str("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")?;

    // 3. 创建传输层
    let transport = TokioTcpConfig::new()
        .upgrade(libp2p::core::upgrade::Version::V1)
        .authenticate(PnetConfig::new(psk))  // 添加pnet认证
        .multiplex(yamux::Config::default())
        .boxed();

    // 4. 创建网络行为
    let behaviour = MyBehaviour {
        ping: Ping::new(
            PingConfig::new()
                .with_keep_alive(true)  // 保持连接活跃
                .with_interval(std::time::Duration::from_secs(10))  // 每10秒ping一次
        )
    };

    // 5. 创建Swarm
    let mut swarm = Swarm::new(transport, behaviour, local_peer_id);

    // 6. 监听本地地址
    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;

    // 7. 如果有命令行参数，尝试连接其他节点
    if let Some(remote_addr) = std::env::args().nth(1) {
        let remote_addr: Multiaddr = remote_addr.parse()?;
        swarm.dial(remote_addr)?;
        println!("尝试连接: {}", remote_addr);
    }

    // 8. 事件处理循环
    loop {
        match swarm.select_next_some().await {
            SwarmEvent::NewListenAddr { address, .. } => {
                println!("监听地址: {}", address);
            }
            SwarmEvent::ConnectionEstablished { peer_id, .. } => {
                println!("已连接到: {}", peer_id);
            }
            SwarmEvent::ConnectionClosed { peer_id, .. } => {
                println!("断开连接: {}", peer_id);
            }
            SwarmEvent::Behaviour(PingEvent { peer, result }) => {
                println!("从 {} 收到Ping结果: {:?}", peer, result);
            }
            _ => {}
        }
    }
}

使用说明

  1. 将此代码保存为main.rs
  2. 确保Cargo.toml中包含所需的依赖项
  3. 运行第一个节点（监听模式）：
    cargo run
  4. 运行第二个节点并连接到第一个节点（使用第一个节点打印的监听地址）：
    cargo run /ip4/127.0.0.1/tcp/xxxxx

完整功能说明

  1. 安全认证：使用预共享密钥确保只有授权节点可以连接
  2. Ping协议：用于测试节点间的基本连接
  3. 事件处理：处理各种网络事件（连接建立/断开、ping响应等）
  4. 多地址支持：支持多种网络地址格式
  5. 异步运行时：使用tokio作为异步运行时

这个示例展示了libp2p-pnet的核心功能，包括安全网络建立、节点间通信和事件处理。您可以根据需要扩展MyBehaviour结构体来添加更多协议支持。

回到顶部