franklee26/bluefin

Experimental, secure, p2p-oriented, transport-layer protocol

Bluefin

Bluefin is an experimental, P2P, transport-layer protocol.

Example

Pack-leader

use bluefin::hosts::pack_leader::BluefinPackLeaderBuilder;

#[tokio::main]
async fn main() {
    // Bind and construct a pack-leader over an TUN device
    let mut pack_leader = BluefinPackLeader::builder()
        .name("utun3".to_string())
        .bind_address("192.168.55.2".to_string())
        .netmask("255.255.255.0".to_string())
        .build();

    loop {
        let connection_res = pack_leader.accept().await;

        tokio::spawn(async move {
            match connection_res {
                Ok(conn) => println!("Conn ready! {conn})"),
                Err(err) => eprintln!("\nConnection attempt failed: {:?}", err),
            }
        });

        sleep(Duration::from_secs(1)).await;
    }
}

Client

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let mut client = BluefinClient::builder()
        .name("test_client".to_string())
        .build();

    let port = rand::thread_rng().gen_range(10000..50000);
    client
        .bind("0.0.0.0", port)
        .expect("Failed to bind client socket");
    let mut conn = client
        .connect("192.168.55.2", 31416)
        .await
        .expect("Failed to connect to host");

    eprintln!("Conn ready! {conn}");
    Ok(())
}

bluefin's Issues

Handle close connection event

Goal:

A connection is closed when the logical Bluefin connection is in ERROR or CLOSED state OR when the socket is closed. The host with the closed connection should broadcast the closed-state to any connected parties. Currently, hosts do not know if the connected party is still connected and will continuously send bytes even if the connection is closed.

Multiplex over network socket/device

Bluefin is a connection-based protocol BUT it is built on top of UDP, which is connection less. We need an implementation that is able to multiplex over the single network interface and supports both read and write operations.

Establish mvp client <--> pack leader handshake

NOTE: this does not yet include tls support (addressed in #3)

Incorperate TLS1.3 into Bluefin handshake

General performance improvements

Of course as part of MVP, we want to focus on core functionality eg. handshake, tls support, streaming and flow control. However, if the mvp implementation is under-performant then we need to make some investments to ensure this doesn't become a larger issue in the future.

The primary concern as of now is how the read workers operate. We will need to analyse some benchmarks and generate some flamegraphs to determine where our bottlenecks lie.

Introduce Streams