use ed25519_dalek::{Signer, SigningKey, Verifier, VerifyingKey};
use shamir_algorithm::ShamirSS;
use std::collections::BTreeMap;
use zeroize::Zeroize;
use zeroize::Zeroizing;
#[derive(Debug, Clone, PartialEq)]
pub struct Share {
pub index: u8,
pub m: u8,
pub data: Vec<u8>,
}
#[derive(Debug, Clone)]
pub struct ThresholdConfig {
pub m: u8,
pub n: u8,
pub guardian_dids: Vec<String>,
}
impl ThresholdConfig {
pub fn validate(&self) -> Result<(), String> {
if self.m == 0 {
return Err("threshold M cannot be zero".to_string());
}
if self.n == 0 {
return Err("share count N cannot be zero".to_string());
}
if self.m > self.n {
return Err(format!(
"threshold M ({}) cannot exceed share count N ({})",
self.m, self.n
));
}
if self.guardian_dids.len() != self.n as usize {
return Err(format!(
"expected {} guardian DIDs, got {}",
self.n,
self.guardian_dids.len()
));
}
Ok(())
}
}
pub fn split_key(secret: &[u8], m: u8, n: u8) -> Result<Vec<Share>, String> {
if m == 0 {
return Err("threshold M cannot be zero".to_string());
}
if n == 0 || m > n {
return Err("invalid M-of-N configuration".to_string());
}
if secret.len() != 32 {
return Err(format!(
"Ed25519 seed must be 32 bytes, got {}",
secret.len()
));
}
let shares = ShamirSS::split(n as i32, m as i32, secret.to_vec())
.map_err(|e| format!("shamir split failed: {}", e))?;
Ok(shares
.into_iter()
.map(|(index, data)| Share {
index: index as u8,
m,
data,
})
.collect())
}
pub fn reconstruct_secret(shares: &[Share]) -> Result<Vec<u8>, String> {
if shares.len() < 2 {
return Err("need at least 2 shares to reconstruct".to_string());
}
let mut parts: BTreeMap<i32, Vec<u8>> = BTreeMap::new();
for share in shares {
parts.insert(share.index as i32, share.data.clone());
}
ShamirSS::join(parts).map_err(|e| format!("shamir join failed: {}", e))
}
pub fn threshold_sign(shares: &[Share], message: &[u8]) -> Result<ed25519_dalek::Signature, String> {
if shares.is_empty() {
return Err("no shares provided".to_string());
}
let m = shares[0].m;
if (shares.len() as u8) < m {
return Err(format!(
"insufficient shares: need {}, got {}",
m,
shares.len()
));
}
let secret = reconstruct_secret(shares)?;
let seed: [u8; 32] = secret
.try_into()
.map_err(|_| "reconstructed secret is not 32 bytes".to_string())?;
let signing_key = SigningKey::from_bytes(&seed);
Ok(signing_key.sign(message))
}
pub fn threshold_verify(
public_key: &VerifyingKey,
signature: &ed25519_dalek::Signature,
message: &[u8],
) -> bool {
public_key.verify(message, signature).is_ok()
}
pub fn generate_threshold_keypair(
m: u8,
n: u8,
) -> Result<(VerifyingKey, Vec<Share>), String> {
use rand::rngs::OsRng;
let signing_key = SigningKey::generate(&mut OsRng);
let verifying_key = signing_key.verifying_key();
let shares = split_key(signing_key.as_bytes(), m, n)?;
Ok((verifying_key, shares))
}
pub struct EphemeralCA {
pub did: String,
seed: Zeroizing<[u8; 32]>,
pub verifying_key: VerifyingKey,
pub capabilities: Vec<String>,
pub delegation_vcard: Option<String>,
shredded: bool,
}
impl EphemeralCA {
pub fn new(capabilities: Vec<String>) -> Self {
use rand::rngs::OsRng;
let signing_key = SigningKey::generate(&mut OsRng);
let verifying_key = signing_key.verifying_key();
let did = format!(
"did:key:{}",
base64_url_encode(&verifying_key.to_bytes())
);
EphemeralCA {
did,
seed: Zeroizing::new(signing_key.to_bytes()),
verifying_key,
capabilities,
delegation_vcard: None,
shredded: false,
}
}
fn signing_key(&self) -> Result<SigningKey, String> {
if self.shredded {
return Err("EphemeralCA has been shredded".to_string());
}
Ok(SigningKey::from_bytes(&self.seed))
}
pub fn issue_delegation(&mut self) -> Result<String, String> {
if self.shredded {
return Err("EphemeralCA has been shredded".to_string());
}
let signing_key = self.signing_key()?;
let timestamp = chrono::Utc::now().to_rfc3339();
let vcard_without_sig = format!(
"vcard_token:\n agent_did: {}\n capabilities: {:?}\n timestamp: {}\n verifying_key: {}",
self.did,
self.capabilities,
timestamp,
hex::encode(self.verifying_key.to_bytes())
);
let signature = signing_key.sign(vcard_without_sig.as_bytes());
let vcard = format!(
"{}\n signature: {}",
vcard_without_sig,
hex::encode(signature.to_bytes())
);
self.delegation_vcard = Some(vcard.clone());
Ok(vcard)
}
pub fn sign(&self, message: &[u8]) -> Result<ed25519_dalek::Signature, String> {
let signing_key = self.signing_key()?;
Ok(signing_key.sign(message))
}
pub fn verify(
&self,
signature: &ed25519_dalek::Signature,
message: &[u8],
) -> bool {
self.verifying_key.verify(message, signature).is_ok()
}
pub fn shred(&mut self) {
if self.shredded {
return;
}
self.seed.zeroize();
self.capabilities.clear();
self.delegation_vcard = None;
self.shredded = true;
}
pub fn is_shredded(&self) -> bool {
self.shredded
}
}
impl Drop for EphemeralCA {
fn drop(&mut self) {
self.shred();
}
}
pub fn verify_delegation(
vcard_yaml: &str,
ca_verifying_key: &VerifyingKey,
) -> bool {
let mut payload_lines = Vec::new();
let mut signature_hex = String::new();
for line in vcard_yaml.lines() {
let trimmed = line.trim();
if let Some(rest) = trimmed.strip_prefix("signature:") {
signature_hex = rest.trim().to_string();
} else {
payload_lines.push(line);
}
}
if signature_hex.is_empty() {
return false;
}
let sig_bytes = match hex::decode(&signature_hex) {
Ok(b) => b,
Err(_) => return false,
};
let sig = match ed25519_dalek::Signature::from_slice(&sig_bytes) {
Ok(s) => s,
Err(_) => return false,
};
let payload = payload_lines.join("\n");
ca_verifying_key.verify(payload.as_bytes(), &sig).is_ok()
}
fn base64_url_encode(bytes: &[u8]) -> String {
const ALPHABET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
let mut result = String::new();
let mut i = 0;
while i + 3 <= bytes.len() {
let n = ((bytes[i] as u32) << 16) | ((bytes[i + 1] as u32) << 8) | (bytes[i + 2] as u32);
result.push(ALPHABET[((n >> 18) & 63) as usize] as char);
result.push(ALPHABET[((n >> 12) & 63) as usize] as char);
result.push(ALPHABET[((n >> 6) & 63) as usize] as char);
result.push(ALPHABET[(n & 63) as usize] as char);
i += 3;
}
let rem = bytes.len() - i;
if rem == 1 {
let n = (bytes[i] as u32) << 16;
result.push(ALPHABET[((n >> 18) & 63) as usize] as char);
result.push(ALPHABET[((n >> 12) & 63) as usize] as char);
} else if rem == 2 {
let n = ((bytes[i] as u32) << 16) | ((bytes[i + 1] as u32) << 8);
result.push(ALPHABET[((n >> 18) & 63) as usize] as char);
result.push(ALPHABET[((n >> 12) & 63) as usize] as char);
result.push(ALPHABET[((n >> 6) & 63) as usize] as char);
}
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_3_of_5_threshold_signing_and_verification() {
let (vk, shares) = generate_threshold_keypair(3, 5).unwrap();
let message = b"threshold test message";
let sig = threshold_sign(&shares[..3], message).unwrap();
assert!(threshold_verify(&vk, &sig, message));
}
#[test]
fn test_below_threshold_fails() {
let (_vk, shares) = generate_threshold_keypair(3, 5).unwrap();
let message = b"threshold test message";
assert!(threshold_sign(&shares[..2], message).is_err());
}
#[test]
fn test_corrupted_share_produces_invalid_signature() {
let (vk, mut shares) = generate_threshold_keypair(3, 5).unwrap();
shares[0].data[0] ^= 0xFF;
let message = b"threshold test message";
let sig = threshold_sign(&shares[..3], message).unwrap();
assert!(!threshold_verify(&vk, &sig, message));
}
#[test]
fn test_threshold_config_validation() {
assert!(ThresholdConfig {
m: 3,
n: 5,
guardian_dids: vec!["a".to_string(), "b".to_string(), "c".to_string(), "d".to_string(), "e".to_string()],
}
.validate()
.is_ok());
assert!(ThresholdConfig {
m: 0,
n: 5,
guardian_dids: vec!["a".to_string(); 5],
}
.validate()
.is_err());
assert!(ThresholdConfig {
m: 6,
n: 5,
guardian_dids: vec!["a".to_string(); 5],
}
.validate()
.is_err());
}
#[test]
fn test_ephemeral_ca_sign_and_verify() {
let ca = EphemeralCA::new(vec!["execute".to_string()]);
let message = b"test message from CA";
let sig = ca.sign(message).unwrap();
assert!(ca.verify(&sig, message));
assert!(!ca.is_shredded());
}
#[test]
fn test_ephemeral_ca_delegation() {
let mut ca = EphemeralCA::new(vec!["execute".to_string(), "delegate".to_string()]);
let vcard = ca.issue_delegation().unwrap();
assert!(vcard.contains("vcard_token:"));
assert!(vcard.contains(&ca.did));
assert!(vcard.contains("signature:"));
assert!(verify_delegation(&vcard, &ca.verifying_key));
}
#[test]
fn test_ephemeral_ca_shred_blocks_signing() {
let mut ca = EphemeralCA::new(vec!["execute".to_string()]);
ca.shred();
assert!(ca.is_shredded());
assert!(ca.sign(b"msg").is_err());
assert!(ca.issue_delegation().is_err());
}
#[test]
fn test_ephemeral_ca_drop_calls_shred() {
let mut ca = EphemeralCA::new(vec!["execute".to_string()]);
let did = ca.did.clone();
{
let _ca2 = EphemeralCA::new(vec!["temp".to_string()]);
}
assert!(!ca.is_shredded());
ca.shred();
assert!(ca.is_shredded());
assert!(!did.is_empty());
}
#[test]
fn test_ephemeral_ca_did_format() {
let ca = EphemeralCA::new(vec!["execute".to_string()]);
assert!(ca.did.starts_with("did:key:"));
assert!(ca.did.len() > "did:key:".len() + 10);
}
#[test]
fn test_verify_delegation_rejects_tampered() {
let mut ca = EphemeralCA::new(vec!["execute".to_string()]);
let mut vcard = ca.issue_delegation().unwrap();
vcard = vcard.replace(&ca.did, "did:key:fake");
assert!(!verify_delegation(&vcard, &ca.verifying_key));
}
}