dave
71 lines
2.2 KiB
Rust
71 lines
2.2 KiB
Rust
//! Ed25519 keypair utilities and type aliases for node identity and signing.
|
|
//!
|
|
//! Provides the [`AuthorId`] and [`SignedDigest`] type aliases, a SHA-256 helper,
|
|
//! and convenience wrappers around the `ed25519-dalek` Ed25519 primitives used
|
|
//! throughout the CRDT codebase.
|
|
|
|
use ed25519_dalek::Signer as _;
|
|
use ed25519_dalek::Verifier as _;
|
|
use sha2::{Digest, Sha256};
|
|
|
|
/// Ed25519 signing key (private + public pair).
|
|
pub type Ed25519KeyPair = ed25519_dalek::SigningKey;
|
|
/// Ed25519 verifying (public) key.
|
|
pub type Ed25519PublicKey = ed25519_dalek::VerifyingKey;
|
|
/// Ed25519 signature.
|
|
pub type Ed25519Signature = ed25519_dalek::Signature;
|
|
|
|
/// Length of an Ed25519 public key in bytes.
|
|
pub const ED25519_PUBLIC_KEY_LENGTH: usize = 32;
|
|
/// Length of an Ed25519 signature in bytes.
|
|
pub const ED25519_SIGNATURE_LENGTH: usize = 64;
|
|
|
|
/// Represents the ID of a unique node. An Ed25519 public key
|
|
pub type AuthorId = [u8; ED25519_PUBLIC_KEY_LENGTH];
|
|
|
|
/// A signed message
|
|
pub type SignedDigest = [u8; ED25519_SIGNATURE_LENGTH];
|
|
|
|
/// Create a fake public key from a u8
|
|
pub fn make_author(n: u8) -> AuthorId {
|
|
let mut id = [0u8; ED25519_PUBLIC_KEY_LENGTH];
|
|
id[0] = n;
|
|
id
|
|
}
|
|
|
|
/// Get the least significant 32 bits of a public key
|
|
pub fn lsb_32(pubkey: AuthorId) -> u32 {
|
|
((pubkey[0] as u32) << 24)
|
|
+ ((pubkey[1] as u32) << 16)
|
|
+ ((pubkey[2] as u32) << 8)
|
|
+ (pubkey[3] as u32)
|
|
}
|
|
|
|
/// SHA256 hash of a string
|
|
pub fn sha256(input: String) -> [u8; 32] {
|
|
let mut hasher = Sha256::new();
|
|
hasher.update(input.as_bytes());
|
|
let result = hasher.finalize();
|
|
let mut bytes = [0u8; 32];
|
|
bytes.copy_from_slice(&result[..]);
|
|
bytes
|
|
}
|
|
|
|
/// Generate a random Ed25519 keypair from OS rng
|
|
pub fn make_keypair() -> Ed25519KeyPair {
|
|
use rand::RngCore as _;
|
|
let mut seed = [0u8; 32];
|
|
rand::rng().fill_bytes(&mut seed);
|
|
Ed25519KeyPair::from_bytes(&seed)
|
|
}
|
|
|
|
/// Sign a byte array
|
|
pub fn sign(keypair: &Ed25519KeyPair, message: &[u8]) -> Ed25519Signature {
|
|
keypair.sign(message)
|
|
}
|
|
|
|
/// Verify a byte array was signed by the given pubkey
|
|
pub fn verify(pubkey: Ed25519PublicKey, message: &[u8], signature: Ed25519Signature) -> bool {
|
|
pubkey.verify(message, &signature).is_ok()
|
|
}
|