use codec_multibase::multibase_to_bytes;
use codec_multicodec::{
lookup_codec_prefix, validate_public_key_payload, KeyLength, KeyMaterialKind,
};
use crate::error::MultikeyError;
use crate::map_public_key_error::map_public_key_error;
use zeroize::Zeroizing;
pub struct ParsedMultikey {
codec_name: &'static str,
alg: &'static str,
public_key: Vec<u8>,
key_length: KeyLength,
}
impl ParsedMultikey {
#[must_use]
pub const fn codec_name(&self) -> &'static str {
self.codec_name
}
#[must_use]
pub const fn algorithm_name(&self) -> &'static str {
self.alg
}
#[must_use]
pub fn public_key(&self) -> &[u8] {
&self.public_key
}
#[must_use]
pub const fn key_length(&self) -> KeyLength {
self.key_length
}
#[must_use]
pub fn into_public_key(self) -> Vec<u8> {
self.public_key
}
}
pub fn parse_multikey(multibase_key: &str) -> Result<ParsedMultikey, MultikeyError> {
if multibase_key.len() < 2 {
return Err(MultikeyError::InvalidMultibase);
}
if !multibase_key.starts_with('z') {
return Err(MultikeyError::InvalidMultibase);
}
let raw = Zeroizing::new(
multibase_to_bytes(multibase_key).map_err(|_| MultikeyError::InvalidMultibase)?,
);
if raw.len() < 2 {
return Err(MultikeyError::DecodedTooShort(raw.len()));
}
let found = lookup_codec_prefix(&raw).ok_or(MultikeyError::UnknownCodecPrefix)?;
if found.key_material != KeyMaterialKind::PublicKey {
return Err(MultikeyError::NonPublicKeyMaterial);
}
let public_key = raw
.get(found.codec.len()..)
.ok_or(MultikeyError::UnknownCodecPrefix)?;
validate_public_key_payload(found.name, public_key).map_err(|error| {
map_public_key_error(found.name, found.key_length, public_key.len(), error)
})?;
Ok(ParsedMultikey {
codec_name: found.name,
alg: found.alg,
public_key: public_key.to_vec(),
key_length: found.key_length,
})
}