use crate::error::NetError;
use libp2p::PeerId;
use libp2p::identity::{Keypair, PublicKey};
use sha2::Digest;
use zeroize::Zeroizing;
pub type Stored = (Zeroizing<Vec<u8>>, String);
pub trait IdentityStore {
type Error: From<NetError>;
fn node_identity(&self) -> Result<Option<Stored>, Self::Error>;
fn init_node_identity(&self, keypair: &[u8], peer: &str) -> Result<(), Self::Error>;
}
fn decode(bytes: &[u8]) -> Result<Keypair, NetError> {
Keypair::from_protobuf_encoding(bytes).map_err(|e| NetError::Crypto(format!("node identity: {e}")))
}
pub fn load_or_create<S: IdentityStore>(store: &S) -> Result<Keypair, S::Error> {
if let Some((bytes, _)) = store.node_identity()? {
return Ok(decode(&bytes)?);
}
let kp = Keypair::generate_ed25519();
let bytes = Zeroizing::new(kp.to_protobuf_encoding().map_err(|e| NetError::Crypto(format!("node identity: {e}")))?);
store.init_node_identity(&bytes, &kp.public().to_peer_id().to_string())?;
let (bytes, _) = store.node_identity()?.ok_or_else(|| NetError::Crypto("node identity: not stored".into()))?;
Ok(decode(&bytes)?)
}
pub fn peer_id<S: IdentityStore>(store: &S) -> Result<Option<PeerId>, S::Error> {
Ok(match store.node_identity()? {
Some((_, p)) => Some(p.parse().map_err(|_| NetError::Crypto("node identity: bad peer id".into()))?),
None => None,
})
}
pub fn fingerprint_of<S: IdentityStore>(store: &S) -> Result<Option<String>, S::Error> {
let Some((bytes, _)) = store.node_identity()? else {
return Ok(None);
};
Ok(Some(fingerprint(&decode(&bytes)?.public())))
}
pub fn fingerprint(key: &PublicKey) -> String {
let h = sha2::Sha256::digest(key.encode_protobuf());
group(&hex::encode(&h[..10]))
}
pub fn group(hex: &str) -> String {
hex.as_bytes().chunks(4).map(|c| String::from_utf8_lossy(c).to_string()).collect::<Vec<_>>().join(" ")
}
pub fn short_peer(p: &str) -> &str {
&p[p.len().saturating_sub(8)..]
}