[][src]Crate susyp2p_secio

The secio protocol is a middleware that will encrypt and decrypt communications going through a socket (or anything that implements AsyncRead + AsyncWrite).

Connection upgrade

The SecioConfig struct implements the ConnectionUpgrade trait. You can apply it over a Transport by using the with_upgrade method. The returned object will also implement Transport and will automatically apply the secio protocol over any connection that is opened through it.

use futures::Future;
use susyp2p_secio::{SecioConfig, SecioOutput};
use susyp2p_core::{Multiaddr, identity, upgrade::apply_inbound};
use susyp2p_core::transport::Transport;
use susyp2p_tcp::TcpConfig;
use tokio_io::io::write_all;
use tokio::runtime::current_thread::Runtime;

let dialer = TcpConfig::new()
        // See the documentation of `identity::Keypair`.
        let keypair = identity::Keypair::rsa_from_pkcs8(private_key).unwrap();
    .map(|out: SecioOutput<_>, _| out.stream);

let future = dialer.dial("/ip4/".parse::<Multiaddr>().unwrap())
    .map_err(|e| panic!("error: {:?}", e))
    .and_then(|connection| {
        // Sends "hello world" on the connection, will be encrypted.
        write_all(connection, "hello world")
    .map_err(|e| panic!("error: {:?}", e));

let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();

Manual usage

Note: You are encouraged to use SecioConfig as described above.

You can add the secio layer over a socket by calling SecioMiddleware::handshake(). This method will perform a handshake with the host, and return a future that corresponds to the moment when the handshake succeeds or errored. On success, the future produces a SecioMiddleware that implements Sink and Stream and can be used to send packets of data.



Implementation of the ConnectionUpgrade trait of susyp2p_core. Automatically applies secio on any connection.


Wraps around an object that implements AsyncRead and AsyncWrite.


Output of the secio protocol.



Possible encryption ciphers.


Possible digest algorithms.


Possible key agreement algorithms.


Error at the SECIO layer communication.