forked from ryzokuken/cosmoline
Compare commits
8 Commits
ec43ca01c6
...
893e75cbf5
Author | SHA1 | Date |
---|---|---|
mirsal | 893e75cbf5 | |
mirsal | 9074a16eb6 | |
mirsal | 8be534c086 | |
mirsal | 5d351ebc00 | |
Ujjwal Sharma | 77387edd0d | |
Ujjwal Sharma | 53bd1c9e6c | |
Ujjwal Sharma | 4b2a20c581 | |
Ujjwal Sharma | d46faad53e |
|
@ -1,10 +1,25 @@
|
|||
use async_std::fs;
|
||||
use async_std::path::PathBuf;
|
||||
use async_trait::async_trait;
|
||||
use ed25519_dalek::{Keypair, PublicKey, SecretKey};
|
||||
use json::{object, JsonValue};
|
||||
use rand::rngs::OsRng;
|
||||
use regex::Regex;
|
||||
use async_std::fs;
|
||||
use async_std::path::PathBuf;
|
||||
use async_trait::async_trait;
|
||||
|
||||
pub trait SSBPublicKey {
|
||||
fn to_base64(&self) -> String;
|
||||
fn from_base64(string: &str) -> Self;
|
||||
}
|
||||
|
||||
impl SSBPublicKey for PublicKey {
|
||||
fn to_base64(&self) -> String {
|
||||
base64::encode(self.to_bytes())
|
||||
}
|
||||
|
||||
fn from_base64(string: &str) -> Self {
|
||||
Self::from_bytes(&base64::decode(string).unwrap()).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
pub trait SSBKeypair {
|
||||
|
@ -16,7 +31,7 @@ pub trait SSBKeypair {
|
|||
#[async_trait]
|
||||
impl SSBKeypair for Keypair {
|
||||
fn to_json(&self) -> JsonValue {
|
||||
let pubstring = base64::encode(self.public.to_bytes());
|
||||
let pubstring = self.public.to_base64();
|
||||
let privstring = base64::encode([self.secret.to_bytes(), self.public.to_bytes()].concat());
|
||||
object! {
|
||||
curve: "ed25519",
|
||||
|
@ -36,8 +51,7 @@ impl SSBKeypair for Keypair {
|
|||
.unwrap()
|
||||
.strip_suffix(".ed25519")
|
||||
.unwrap();
|
||||
let pubkey = base64::decode(pubkey).unwrap();
|
||||
let pubkey = PublicKey::from_bytes(pubkey.as_slice()).unwrap();
|
||||
let pubkey = SSBPublicKey::from_base64(pubkey);
|
||||
|
||||
let privkey = obj["private"]
|
||||
.as_str()
|
||||
|
@ -70,7 +84,8 @@ impl SSBKeypair for Keypair {
|
|||
keys = keypair_json.pretty(2),
|
||||
id = keypair_json["id"]
|
||||
),
|
||||
).await
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
keypair
|
||||
}
|
||||
|
|
75
src/main.rs
75
src/main.rs
|
@ -1,34 +1,49 @@
|
|||
use async_std::{fs, task};
|
||||
use async_std::net::{UdpSocket, Ipv6Addr};
|
||||
use async_std::path::PathBuf;
|
||||
use async_std::sync::Arc;
|
||||
use clap::{load_yaml, App};
|
||||
use ed25519_dalek::Keypair;
|
||||
use async_std::fs;
|
||||
use async_std::net::UdpSocket;
|
||||
use async_std::path::PathBuf;
|
||||
|
||||
mod keypair;
|
||||
use keypair::{SSBKeypair, SSBPublicKey};
|
||||
|
||||
use keypair::SSBKeypair;
|
||||
mod network;
|
||||
use network::Peer;
|
||||
|
||||
type Config = toml::map::Map<String, toml::Value>;
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Host {
|
||||
protocol: String,
|
||||
host: String,
|
||||
port: String,
|
||||
pubkey: String,
|
||||
async fn peer_discovery_recv() {
|
||||
let socket = UdpSocket::bind(":::8008").await.unwrap();
|
||||
let all_nodes_addr = Ipv6Addr::new(0xFF02, 0, 0, 0, 0, 0, 0, 0x02);
|
||||
let mut buf = [0u8; 1024];
|
||||
|
||||
socket.join_multicast_v6(&all_nodes_addr, 0).unwrap();
|
||||
|
||||
loop {
|
||||
let (amt, peer) = socket.recv_from(&mut buf).await.unwrap();
|
||||
let buf = &mut buf[..amt];
|
||||
let packet = String::from_utf8(buf.to_vec()).unwrap();
|
||||
println!(
|
||||
"{} {}",
|
||||
peer,
|
||||
Peer::from_discovery_packet(&packet).to_discovery_packet()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_packet(packet: String) -> Host {
|
||||
let mut packet = packet.splitn(4, ':');
|
||||
let protocol = packet.next().unwrap();
|
||||
let host = packet.next().unwrap();
|
||||
let port = packet.next().unwrap().splitn(2, '~').next().unwrap();
|
||||
let pubkey = packet.next().unwrap();
|
||||
Host {
|
||||
protocol: protocol.to_string(),
|
||||
host: host.to_string(),
|
||||
port: port.to_string(),
|
||||
pubkey: pubkey.to_string(),
|
||||
async fn peer_discovery_send(pubkey: Arc<String>) {
|
||||
let socket = UdpSocket::bind(":::0").await.unwrap();
|
||||
let msg = format!("net:1.2.3.4:8023~shs:{}", &pubkey);
|
||||
let buf = msg.as_bytes();
|
||||
|
||||
socket.set_broadcast(true).unwrap();
|
||||
|
||||
loop {
|
||||
println!("Sending packet: {:?}", &msg);
|
||||
socket.send_to(&buf, "255.255.255.255:8008").await.unwrap();
|
||||
socket.send_to(&buf, "[FF02::2]:8008").await.unwrap();
|
||||
task::sleep(std::time::Duration::from_secs(1)).await;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -39,10 +54,12 @@ async fn main() {
|
|||
|
||||
let config_file = match options.value_of("config") {
|
||||
Some(path) => PathBuf::from(path),
|
||||
None => PathBuf::from(dirs::config_dir()
|
||||
None => PathBuf::from(
|
||||
dirs::config_dir()
|
||||
.unwrap()
|
||||
.join("cosmoline")
|
||||
.join("config.toml")),
|
||||
.join("config.toml"),
|
||||
),
|
||||
};
|
||||
let config = fs::read_to_string(config_file).await.unwrap();
|
||||
let config: Config = toml::from_str(config.as_str()).unwrap();
|
||||
|
@ -57,14 +74,8 @@ async fn main() {
|
|||
let keypair = Keypair::read_or_generate(path.join("secret")).await;
|
||||
println!("{}", keypair.to_json().pretty(2));
|
||||
|
||||
let socket = UdpSocket::bind("0.0.0.0:8008").await.unwrap();
|
||||
let mut buf = [0u8; 1024];
|
||||
|
||||
loop {
|
||||
let (amt, peer) = socket.recv_from(&mut buf).await.unwrap();
|
||||
let buf = &mut buf[..amt];
|
||||
let packet = String::from_utf8(buf.to_vec()).unwrap();
|
||||
println!("{:?}", (peer, parse_packet(packet)));
|
||||
};
|
||||
let pubkey = keypair.public.to_base64();
|
||||
|
||||
task::spawn(peer_discovery_recv());
|
||||
task::spawn(peer_discovery_send(Arc::new(pubkey))).await;
|
||||
}
|
||||
|
|
|
@ -0,0 +1,60 @@
|
|||
use async_std::net::IpAddr;
|
||||
use ed25519_dalek::PublicKey;
|
||||
|
||||
use crate::keypair::SSBPublicKey;
|
||||
|
||||
enum Protocol {
|
||||
Net,
|
||||
Ws,
|
||||
Wss,
|
||||
}
|
||||
|
||||
pub struct Peer {
|
||||
protocol: Protocol,
|
||||
host: IpAddr,
|
||||
port: u16,
|
||||
pubkey: PublicKey,
|
||||
}
|
||||
|
||||
impl Peer {
|
||||
pub fn to_discovery_packet(&self) -> String {
|
||||
let proto = match self.protocol {
|
||||
Protocol::Net => "net",
|
||||
Protocol::Ws => "ws",
|
||||
Protocol::Wss => "wss",
|
||||
};
|
||||
format!(
|
||||
"{}:{}:{}~shs:{}",
|
||||
proto,
|
||||
self.host,
|
||||
self.port,
|
||||
self.pubkey.to_base64()
|
||||
)
|
||||
}
|
||||
|
||||
pub fn from_discovery_packet(packet: &str) -> Self {
|
||||
let mut packet = packet.splitn(4, ':');
|
||||
let protocol = match packet.next().unwrap() {
|
||||
"net" => Protocol::Net,
|
||||
"ws" => Protocol::Ws,
|
||||
"wss" => Protocol::Wss,
|
||||
_ => panic!("unknown protocol"),
|
||||
};
|
||||
let host = IpAddr::V4(packet.next().unwrap().parse().unwrap());
|
||||
let port = packet
|
||||
.next()
|
||||
.unwrap()
|
||||
.splitn(2, '~')
|
||||
.next()
|
||||
.unwrap()
|
||||
.parse()
|
||||
.unwrap();
|
||||
let pubkey = SSBPublicKey::from_base64(packet.next().unwrap());
|
||||
Peer {
|
||||
protocol,
|
||||
host,
|
||||
port,
|
||||
pubkey,
|
||||
}
|
||||
}
|
||||
}
|
Loading…
Reference in New Issue