use std::sync::Arc;
use dig_constants::{DEK_SALT, IDENTITY_IKM_VERSION, SYMMETRIC_KEY_LEN};
use dig_keystore::scheme::KeyScheme;
use dig_keystore::SignerHandle;
use hkdf::Hkdf;
use sha2::Sha256;
use zeroize::Zeroizing;
pub type SigningFn<K> = Arc<dyn Fn(&[u8]) -> <K as KeyScheme>::Signature + Send + Sync>;
pub struct UnlockedIdentity<K: KeyScheme> {
signer: SignerHandle<K>,
public_key: K::PublicKey,
}
impl<K: KeyScheme> UnlockedIdentity<K> {
pub(crate) fn new(signer: SignerHandle<K>) -> Self {
let public_key = signer.public_key().clone();
Self { signer, public_key }
}
pub fn public_key(&self) -> &K::PublicKey {
&self.public_key
}
pub fn sign(&self, msg: &[u8]) -> K::Signature {
self.signer.sign(msg)
}
pub fn signing_fn(&self) -> SigningFn<K> {
let signer = self.signer.clone();
Arc::new(move |msg: &[u8]| signer.sign(msg))
}
pub fn derive_symmetric_key(&self, label: &[u8]) -> Zeroizing<[u8; SYMMETRIC_KEY_LEN]> {
let scalar = self.signer.expose_secret();
let mut ikm = Zeroizing::new(Vec::with_capacity(1 + scalar.len()));
ikm.push(IDENTITY_IKM_VERSION);
ikm.extend_from_slice(scalar);
let hkdf = Hkdf::<Sha256>::new(Some(DEK_SALT), &ikm);
let mut dek = Zeroizing::new([0u8; SYMMETRIC_KEY_LEN]);
hkdf.expand(label, &mut *dek)
.expect("32 bytes is a valid HKDF-SHA256 output length");
dek
}
pub fn inject_into<T>(&self, consumer: impl FnOnce(SigningFn<K>) -> T) -> T {
consumer(self.signing_fn())
}
}
impl<K: KeyScheme> core::fmt::Debug for UnlockedIdentity<K> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("UnlockedIdentity")
.field("scheme", &K::NAME)
.field("secret", &"<redacted>")
.finish()
}
}