Crate aggligator

Aggregates multiple links into one connection.

Aggligator takes multiple network links (for example TCP connections) between two endpoints and combines them into one connection that has the combined bandwidth of all links. Additionally it provides resiliency against failure of individual links and allows adding and removing of links on-the-fly.

It serves the same purpose as Multipath TCP and SCTP but works over existing, widely adopted protocols such as TCP, HTTPS, TLS and WebSockets and is completely implemented in user space without the need for any support from the operating system.

Aggligator is written in 100% safe Rust and builds upon the Tokio asynchronous runtime.

Link requirements

A link can either be stream-based (implementing the AsyncRead and AsyncWrite traits) or packet-based (implementing the Sink and Stream traits). In both cases the implementation of the link must ensure data integrity and deliver data in the same order as it was sent. If data has been lost or corrupted underway, the link must handle retransmission and, if that is unsuccessful, fail by disconnecting itself.

In the case of TCP this is handled by the operating system and thus a TcpStream or protocols building on top of that (such as TLS or WebSockets) can be directly used as links.

Other then the requirements stated above, Aggligator makes no assumption about the type of links and can work over any networking methodology such as TCP/IP, Bluetooth, and serial links. It never interfaces directly with the operating system and only uses links provided by the user.

Connection security

Aggligator does not perform cryptographic authentication of the remote endpoint or encryption of data. If you are sending sensitive data over an untrusted connection you should encrypt it and authenticate the remote endpoint, for example using TLS. The implementation provided in the tokio-rustls crate works nicely with Aggligator.

However, the unique identifier of each connection is encrypted using a shared secret that is exchanged via Diffie-Hellman key exchange. Thus, an eavesdropper cannot inject fake links to an existing connection by using the spoofed connection identifier. This provides the same security level against insertion of malicious data and connection termination by an adversary as you would have when using a single unencrypted TCP connection.

Basic usage and utility functions

See the connect module on how to accept incoming connections and establish outgoing connections. This is agnostic of the underlying protocol.

Useful functions for working with TCP-based links, encryption and authentication using TLS, a visualizing link monitor and a completely worked out example are provided in the aggligator-util crate.

Re-exports

• pub use cfg::Cfg;
• pub use connect::connect;
• pub use connect::Incoming;
• pub use connect::Listener;
• pub use connect::Outgoing;
• pub use connect::Server;
• pub use control::Control;
• pub use control::Link;
• pub use io::IoRxBox;
• pub use io::IoTxBox;

Modules

• alc
  Aggregated link connection.
• cfg
  Connection configuration.
• connect
  Establishing new incoming and outgoing connections.
• control
  Connection and link control.
• dumpdump
  Dump data for performance analysis.
• id
  Unique identifiers.
• io
  Wrapper types for stream-based links.

Structs

• Task
  Task managing a connection of aggregated links.

Enums

• TaskError
  Error indicating why a connection of aggregated links failed.