grassrootseconomics/openethereum
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use parity-crypto updated to use upstream rust-secp256k1 (#11406)

Browse Source 
* Use parity-crypto updated to use upstream rust-secp256k1

* Fetch dependency from git

* Missed a session ID

* Add free-standing inversion function that uses `libsecp256k1`

* fixed tests

* Update deps

* Use parity-crypto 0.5.0
Use libsecp256k1 0.3.5

* Review grumble

Co-authored-by: Svyatoslav Nikolsky <svyatonik@gmail.com>
This commit is contained in:
David
2020-02-10 18:29:21 +01:00
committed by GitHub
parent 2c4b51c3ea
commit 99271db9d3
82 changed files with 642 additions and 503 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
util/network-devp2p/src/discovery.rs
View File

@@ -926,7 +926,7 @@ mod tests {
#[test]
fn ping_queue() {
let key = Random.generate().unwrap();
let key = Random.generate();
let ep = NodeEndpoint { address: SocketAddr::from_str("127.0.0.1:40445").unwrap(), udp_port: 40445 };
let mut discovery = Discovery::new(&key, ep.clone(), IpFilter::default());
@@ -947,7 +947,7 @@ mod tests {
#[test]
fn discovery() {
let mut discovery_handlers = (0..5).map(|i| {
let key = Random.generate().unwrap();
let key = Random.generate();
let ep = NodeEndpoint {
address: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 41000 + i),
udp_port: 41000 + i,
@@ -997,7 +997,7 @@ mod tests {
#[test]
fn removes_expired() {
let key = Random.generate().unwrap();
let key = Random.generate();
let ep = NodeEndpoint { address: SocketAddr::from_str("127.0.0.1:40446").unwrap(), udp_port: 40447 };
let discovery = Discovery::new(&key, ep.clone(), IpFilter::default());
@@ -1042,7 +1042,7 @@ mod tests {
let from = SocketAddr::from_str("99.99.99.99:40445").unwrap();
// FIND_NODE times out because it doesn't receive k results.
let key = Random.generate().unwrap();
let key = Random.generate();
discovery.send_find_node(&node_entries[100], key.public()).unwrap();
for payload in Discovery::prepare_neighbours_packets(&node_entries[101..116]) {
let packet = assemble_packet(PACKET_NEIGHBOURS, &payload, &key.secret()).unwrap();
@@ -1089,7 +1089,7 @@ mod tests {
fn find_nearest_saturated() {
use super::*;
let key = Random.generate().unwrap();
let key = Random.generate();
let ep = NodeEndpoint { address: SocketAddr::from_str("127.0.0.1:40447").unwrap(), udp_port: 40447 };
let mut discovery = Discovery::new(&key, ep.clone(), IpFilter::default());
@@ -1191,7 +1191,7 @@ mod tests {
#[test]
fn packets() {
let key = Random.generate().unwrap();
let key = Random.generate();
let ep = NodeEndpoint { address: SocketAddr::from_str("127.0.0.1:40449").unwrap(), udp_port: 40449 };
let mut discovery = Discovery::new(&key, ep.clone(), IpFilter::default());
discovery.check_timestamps = false;
@@ -1256,9 +1256,9 @@ mod tests {
#[test]
fn test_ping() {
let key1 = Random.generate().unwrap();
let key2 = Random.generate().unwrap();
let key3 = Random.generate().unwrap();
let key1 = Random.generate();
let key2 = Random.generate();
let key3 = Random.generate();
let ep1 = NodeEndpoint { address: SocketAddr::from_str("127.0.0.1:40344").unwrap(), udp_port: 40344 };
let ep2 = NodeEndpoint { address: SocketAddr::from_str("127.0.0.1:40345").unwrap(), udp_port: 40345 };
let ep3 = NodeEndpoint { address: SocketAddr::from_str("127.0.0.1:40346").unwrap(), udp_port: 40345 };

10
util/network-devp2p/src/handshake.rs
View File

@@ -83,20 +83,20 @@ const ECIES_OVERHEAD: usize = 113;
impl Handshake {
/// Create a new handshake object
pub fn new(token: StreamToken, id: Option<&NodeId>, socket: TcpStream, nonce: &H256) -> Result<Handshake, Error> {
Ok(Handshake {
pub fn new(token: StreamToken, id: Option<&NodeId>, socket: TcpStream, nonce: &H256) -> Handshake {
Handshake {
id: if let Some(id) = id { *id } else { NodeId::default() },
connection: Connection::new(token, socket),
originated: false,
state: HandshakeState::New,
ecdhe: Random.generate()?,
ecdhe: Random.generate(),
nonce: *nonce,
remote_ephemeral: Public::default(),
remote_nonce: H256::zero(),
remote_version: PROTOCOL_VERSION,
auth_cipher: Bytes::new(),
ack_cipher: Bytes::new(),
})
}
}
/// Start a handshake
@@ -358,7 +358,7 @@ mod test {
let addr = "127.0.0.1:50556".parse().unwrap();
let socket = TcpStream::connect(&addr).unwrap();
let nonce = H256::zero();
Handshake::new(0, to, socket, &nonce).unwrap()
Handshake::new(0, to, socket, &nonce)
}
fn test_io() -> IoContext<i32> {

2
util/network-devp2p/src/host.rs
View File

@@ -290,7 +290,7 @@ impl Host {
} else {
config.config_path.clone().and_then(|ref p| load_key(Path::new(&p)))
.map_or_else(|| {
let key = Random.generate().expect("Error generating random key pair");
let key = Random.generate();
if let Some(path) = config.config_path.clone() {
save_key(Path::new(&path), key.secret());
}

2
util/network-devp2p/src/session.rs
View File

@@ -110,7 +110,7 @@ impl Session {
nonce: &H256, host: &HostInfo) -> Result<Session, Error>
where Message: Send + Clone + Sync + 'static {
let originated = id.is_some();
let mut handshake = Handshake::new(token, id, socket, nonce).expect("Can't create handshake");
let mut handshake = Handshake::new(token, id, socket, nonce);
let local_addr = handshake.connection.local_addr_str();
handshake.start(io, host, originated)?;
Ok(Session {