2 unstable releases
0.7.0 | May 4, 2019 |
---|---|
0.6.0 | May 4, 2019 |
#8 in #susyp2p
Used in 4 crates
670KB
12K
SLoC
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()
.with_upgrade({
# let private_key = &mut [];
// See the documentation of `identity::Keypair`.
let keypair = identity::Keypair::rsa_from_pkcs8(private_key).unwrap();
SecioConfig::new(keypair)
})
.map(|out: SecioOutput<_>, _| out.stream);
let future = dialer.dial("/ip4/127.0.0.1/tcp/12345".parse::<Multiaddr>().unwrap())
.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.
Dependencies
~8–13MB
~246K SLoC