pub mod x25519;
use crate::NoiseError;
use libp2p_core::identity;
use rand::SeedableRng;
use zeroize::Zeroize;
#[derive(Clone)]
pub struct ProtocolParams(snow::params::NoiseParams);
impl ProtocolParams {
pub(crate) fn into_builder(self) -> snow::Builder<'static> {
snow::Builder::with_resolver(self.0, Box::new(Resolver))
}
}
#[derive(Debug, Clone)]
pub enum IK {}
#[derive(Debug, Clone)]
pub enum IX {}
#[derive(Debug, Clone)]
pub enum XX {}
pub trait Protocol<C> {
fn params_ik() -> ProtocolParams;
fn params_ix() -> ProtocolParams;
fn params_xx() -> ProtocolParams;
fn public_from_bytes(s: &[u8]) -> Result<PublicKey<C>, NoiseError>;
#[allow(unused_variables)]
fn linked(id_pk: &identity::PublicKey, dh_pk: &PublicKey<C>) -> bool {
false
}
fn verify(id_pk: &identity::PublicKey, dh_pk: &PublicKey<C>, sig: &Option<Vec<u8>>) -> bool
where
C: AsRef<[u8]>
{
Self::linked(id_pk, dh_pk)
||
sig.as_ref().map_or(false, |s| id_pk.verify(dh_pk.as_ref(), s))
}
}
#[derive(Clone)]
pub struct Keypair<T: Zeroize> {
secret: SecretKey<T>,
public: PublicKey<T>,
}
#[derive(Clone)]
pub struct AuthenticKeypair<T: Zeroize> {
keypair: Keypair<T>,
identity: KeypairIdentity
}
impl<T: Zeroize> AuthenticKeypair<T> {
pub fn into_identity(self) -> KeypairIdentity {
self.identity
}
}
impl<T: Zeroize> std::ops::Deref for AuthenticKeypair<T> {
type Target = Keypair<T>;
fn deref(&self) -> &Self::Target {
&self.keypair
}
}
#[derive(Clone)]
pub struct KeypairIdentity {
pub public: identity::PublicKey,
pub signature: Option<Vec<u8>>
}
impl<T: Zeroize> Keypair<T> {
pub fn public(&self) -> &PublicKey<T> {
&self.public
}
pub fn secret(&self) -> &SecretKey<T> {
&self.secret
}
pub fn into_authentic(self, id_keys: &identity::Keypair) -> Result<AuthenticKeypair<T>, NoiseError>
where
T: AsRef<[u8]>
{
let sig = id_keys.sign(self.public.as_ref())?;
let identity = KeypairIdentity {
public: id_keys.public(),
signature: Some(sig)
};
Ok(AuthenticKeypair { keypair: self, identity })
}
}
#[derive(Clone)]
pub struct SecretKey<T: Zeroize>(T);
impl<T: Zeroize> Drop for SecretKey<T> {
fn drop(&mut self) {
self.0.zeroize()
}
}
impl<T: AsRef<[u8]> + Zeroize> AsRef<[u8]> for SecretKey<T> {
fn as_ref(&self) -> &[u8] {
self.0.as_ref()
}
}
#[derive(Clone)]
pub struct PublicKey<T>(T);
impl<T: AsRef<[u8]>> PartialEq for PublicKey<T> {
fn eq(&self, other: &PublicKey<T>) -> bool {
self.as_ref() == other.as_ref()
}
}
impl<T: AsRef<[u8]>> Eq for PublicKey<T> {}
impl<T: AsRef<[u8]>> AsRef<[u8]> for PublicKey<T> {
fn as_ref(&self) -> &[u8] {
self.0.as_ref()
}
}
struct Resolver;
impl snow::resolvers::CryptoResolver for Resolver {
fn resolve_rng(&self) -> Option<Box<dyn snow::types::Random>> {
Some(Box::new(Rng(rand::rngs::StdRng::from_entropy())))
}
fn resolve_dh(&self, choice: &snow::params::DHChoice) -> Option<Box<dyn snow::types::Dh>> {
if let snow::params::DHChoice::Curve25519 = choice {
Some(Box::new(Keypair::<x25519::X25519>::default()))
} else {
None
}
}
fn resolve_hash(&self, choice: &snow::params::HashChoice) -> Option<Box<dyn snow::types::Hash>> {
#[cfg(target_os = "unknown")]
{
snow::resolvers::DefaultResolver.resolve_hash(choice)
}
#[cfg(not(target_os = "unknown"))]
{
snow::resolvers::RingResolver.resolve_hash(choice)
}
}
fn resolve_cipher(&self, choice: &snow::params::CipherChoice) -> Option<Box<dyn snow::types::Cipher>> {
#[cfg(target_os = "unknown")]
{
snow::resolvers::DefaultResolver.resolve_cipher(choice)
}
#[cfg(not(target_os = "unknown"))]
{
snow::resolvers::RingResolver.resolve_cipher(choice)
}
}
}
struct Rng(rand::rngs::StdRng);
impl rand::RngCore for Rng {
fn next_u32(&mut self) -> u32 {
self.0.next_u32()
}
fn next_u64(&mut self) -> u64 {
self.0.next_u64()
}
fn fill_bytes(&mut self, dest: &mut [u8]) {
self.0.fill_bytes(dest)
}
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
self.0.try_fill_bytes(dest)
}
}
impl rand::CryptoRng for Rng {}
impl snow::types::Random for Rng {}