212 lines
6.9 KiB
Rust
212 lines
6.9 KiB
Rust
use mio::*;
|
|
use mio::tcp::*;
|
|
use hash::*;
|
|
use sha3::Hashable;
|
|
use bytes::Bytes;
|
|
use crypto::*;
|
|
use crypto;
|
|
use network::connection::{Connection};
|
|
use network::host::{HostInfo};
|
|
use network::node::NodeId;
|
|
use error::*;
|
|
use network::error::NetworkError;
|
|
|
|
#[derive(PartialEq, Eq, Debug)]
|
|
enum HandshakeState {
|
|
/// Just created
|
|
New,
|
|
/// Waiting for auth packet
|
|
ReadingAuth,
|
|
/// Waiting for ack packet
|
|
ReadingAck,
|
|
/// Ready to start a session
|
|
StartSession,
|
|
}
|
|
|
|
/// RLPx protocol handhake. See https://github.com/ethereum/devp2p/blob/master/rlpx.md#encrypted-handshake
|
|
pub struct Handshake {
|
|
/// Remote node public key
|
|
pub id: NodeId,
|
|
/// Underlying connection
|
|
pub connection: Connection,
|
|
/// Handshake state
|
|
state: HandshakeState,
|
|
/// Outgoing or incoming connection
|
|
pub originated: bool,
|
|
/// Disconnect timeout
|
|
idle_timeout: Option<Timeout>,
|
|
/// ECDH ephemeral
|
|
pub ecdhe: KeyPair,
|
|
/// Connection nonce
|
|
pub nonce: H256,
|
|
/// Handshake public key
|
|
pub remote_public: Public,
|
|
/// Remote connection nonce.
|
|
pub remote_nonce: H256,
|
|
/// A copy of received encryped auth packet
|
|
pub auth_cipher: Bytes,
|
|
/// A copy of received encryped ack packet
|
|
pub ack_cipher: Bytes
|
|
}
|
|
|
|
const AUTH_PACKET_SIZE: usize = 307;
|
|
const ACK_PACKET_SIZE: usize = 210;
|
|
|
|
impl Handshake {
|
|
/// Create a new handshake object
|
|
pub fn new(token: Token, id: &NodeId, socket: TcpStream, nonce: &H256) -> Result<Handshake, UtilError> {
|
|
Ok(Handshake {
|
|
id: id.clone(),
|
|
connection: Connection::new(token, socket),
|
|
originated: false,
|
|
state: HandshakeState::New,
|
|
idle_timeout: None,
|
|
ecdhe: try!(KeyPair::create()),
|
|
nonce: nonce.clone(),
|
|
remote_public: Public::new(),
|
|
remote_nonce: H256::new(),
|
|
auth_cipher: Bytes::new(),
|
|
ack_cipher: Bytes::new(),
|
|
})
|
|
}
|
|
|
|
/// Start a handhsake
|
|
pub fn start(&mut self, host: &HostInfo, originated: bool) -> Result<(), UtilError> {
|
|
self.originated = originated;
|
|
if originated {
|
|
try!(self.write_auth(host));
|
|
}
|
|
else {
|
|
self.state = HandshakeState::ReadingAuth;
|
|
self.connection.expect(AUTH_PACKET_SIZE);
|
|
};
|
|
Ok(())
|
|
}
|
|
|
|
/// Check if handshake is complete
|
|
pub fn done(&self) -> bool {
|
|
self.state == HandshakeState::StartSession
|
|
}
|
|
|
|
/// Readable IO handler. Drives the state change.
|
|
pub fn readable<Host:Handler>(&mut self, event_loop: &mut EventLoop<Host>, host: &HostInfo) -> Result<(), UtilError> {
|
|
self.idle_timeout.map(|t| event_loop.clear_timeout(t));
|
|
match self.state {
|
|
HandshakeState::ReadingAuth => {
|
|
if let Some(data) = try!(self.connection.readable()) {
|
|
try!(self.read_auth(host, &data));
|
|
try!(self.write_ack());
|
|
};
|
|
},
|
|
HandshakeState::ReadingAck => {
|
|
if let Some(data) = try!(self.connection.readable()) {
|
|
try!(self.read_ack(host, &data));
|
|
self.state = HandshakeState::StartSession;
|
|
};
|
|
},
|
|
_ => { panic!("Unexpected state"); }
|
|
}
|
|
if self.state != HandshakeState::StartSession {
|
|
try!(self.connection.reregister(event_loop));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Writabe IO handler.
|
|
pub fn writable<Host:Handler>(&mut self, event_loop: &mut EventLoop<Host>, _host: &HostInfo) -> Result<(), UtilError> {
|
|
self.idle_timeout.map(|t| event_loop.clear_timeout(t));
|
|
try!(self.connection.writable());
|
|
if self.state != HandshakeState::StartSession {
|
|
try!(self.connection.reregister(event_loop));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Register the IO handler with the event loop
|
|
pub fn register<Host:Handler<Timeout=Token>>(&mut self, event_loop: &mut EventLoop<Host>) -> Result<(), UtilError> {
|
|
self.idle_timeout.map(|t| event_loop.clear_timeout(t));
|
|
self.idle_timeout = event_loop.timeout_ms(self.connection.token, 1800).ok();
|
|
try!(self.connection.register(event_loop));
|
|
Ok(())
|
|
}
|
|
|
|
/// Parse, validate and confirm auth message
|
|
fn read_auth(&mut self, host: &HostInfo, data: &[u8]) -> Result<(), UtilError> {
|
|
trace!(target:"net", "Received handshake auth to {:?}", self.connection.socket.peer_addr());
|
|
assert!(data.len() == AUTH_PACKET_SIZE);
|
|
self.auth_cipher = data.to_vec();
|
|
let auth = try!(ecies::decrypt(host.secret(), data));
|
|
let (sig, rest) = auth.split_at(65);
|
|
let (hepubk, rest) = rest.split_at(32);
|
|
let (pubk, rest) = rest.split_at(64);
|
|
let (nonce, _) = rest.split_at(32);
|
|
self.remote_public.clone_from_slice(pubk);
|
|
self.remote_nonce.clone_from_slice(nonce);
|
|
let shared = try!(ecdh::agree(host.secret(), &self.remote_public));
|
|
let signature = Signature::from_slice(sig);
|
|
let spub = try!(ec::recover(&signature, &(&shared ^ &self.remote_nonce)));
|
|
if &spub.sha3()[..] != hepubk {
|
|
trace!(target:"net", "Handshake hash mismath with {:?}", self.connection.socket.peer_addr());
|
|
return Err(From::from(NetworkError::Auth));
|
|
};
|
|
self.write_ack()
|
|
}
|
|
|
|
/// Parse and validate ack message
|
|
fn read_ack(&mut self, host: &HostInfo, data: &[u8]) -> Result<(), UtilError> {
|
|
trace!(target:"net", "Received handshake auth to {:?}", self.connection.socket.peer_addr());
|
|
assert!(data.len() == ACK_PACKET_SIZE);
|
|
self.ack_cipher = data.to_vec();
|
|
let ack = try!(ecies::decrypt(host.secret(), data));
|
|
self.remote_public.clone_from_slice(&ack[0..64]);
|
|
self.remote_nonce.clone_from_slice(&ack[64..(64+32)]);
|
|
Ok(())
|
|
}
|
|
|
|
/// Sends auth message
|
|
fn write_auth(&mut self, host: &HostInfo) -> Result<(), UtilError> {
|
|
trace!(target:"net", "Sending handshake auth to {:?}", self.connection.socket.peer_addr());
|
|
let mut data = [0u8; /*Signature::SIZE*/ 65 + /*H256::SIZE*/ 32 + /*Public::SIZE*/ 64 + /*H256::SIZE*/ 32 + 1]; //TODO: use associated constants
|
|
let len = data.len();
|
|
{
|
|
data[len - 1] = 0x0;
|
|
let (sig, rest) = data.split_at_mut(65);
|
|
let (hepubk, rest) = rest.split_at_mut(32);
|
|
let (pubk, rest) = rest.split_at_mut(64);
|
|
let (nonce, _) = rest.split_at_mut(32);
|
|
|
|
// E(remote-pubk, S(ecdhe-random, ecdh-shared-secret^nonce) || H(ecdhe-random-pubk) || pubk || nonce || 0x0)
|
|
let shared = try!(crypto::ecdh::agree(host.secret(), &self.id));
|
|
try!(crypto::ec::sign(self.ecdhe.secret(), &(&shared ^ &self.nonce))).copy_to(sig);
|
|
self.ecdhe.public().sha3_into(hepubk);
|
|
host.id().copy_to(pubk);
|
|
self.nonce.copy_to(nonce);
|
|
}
|
|
let message = try!(crypto::ecies::encrypt(&self.id, &data));
|
|
self.auth_cipher = message.clone();
|
|
self.connection.send(message);
|
|
self.connection.expect(ACK_PACKET_SIZE);
|
|
self.state = HandshakeState::ReadingAck;
|
|
Ok(())
|
|
}
|
|
|
|
/// Sends ack message
|
|
fn write_ack(&mut self) -> Result<(), UtilError> {
|
|
trace!(target:"net", "Sending handshake ack to {:?}", self.connection.socket.peer_addr());
|
|
let mut data = [0u8; 1 + /*Public::SIZE*/ 64 + /*H256::SIZE*/ 32]; //TODO: use associated constants
|
|
let len = data.len();
|
|
{
|
|
data[len - 1] = 0x0;
|
|
let (epubk, rest) = data.split_at_mut(64);
|
|
let (nonce, _) = rest.split_at_mut(32);
|
|
self.ecdhe.public().copy_to(epubk);
|
|
self.nonce.copy_to(nonce);
|
|
}
|
|
let message = try!(crypto::ecies::encrypt(&self.id, &data));
|
|
self.ack_cipher = message.clone();
|
|
self.connection.send(message);
|
|
self.state = HandshakeState::StartSession;
|
|
Ok(())
|
|
}
|
|
}
|