use std::fmt;
use std::ops::Deref;
use serde::{Deserialize, Serialize};
use subtle::ConstantTimeEq;
use zeroize::{Zeroize, ZeroizeOnDrop};
use crate::error::{ClmError, StorageErrorCode, AuthErrorCode};
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct ContentHash(String);
impl ContentHash {
pub fn parse(s: impl AsRef<str>) -> Result<Self, ClmError> {
let s = s.as_ref().trim();
if s.len() != 64 {
return Err(ClmError::storage(
StorageErrorCode::CorruptedContent,
format!("Invalid ContentHash length: expected 64 hex characters, found {}", s.len()),
));
}
if !s.chars().all(|c| c.is_ascii_hexdigit()) {
return Err(ClmError::storage(
StorageErrorCode::CorruptedContent,
format!("Invalid ContentHash characters: must be valid hex digits, found '{}'", s),
));
}
Ok(Self(s.to_ascii_lowercase()))
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn compute(bytes: &[u8]) -> Self {
Self(crate::hash::raw_hash_bytes(bytes))
}
}
impl Deref for ContentHash {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl AsRef<str> for ContentHash {
fn as_ref(&self) -> &str {
&self.0
}
}
impl fmt::Display for ContentHash {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl fmt::Debug for ContentHash {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "ContentHash({})", self.0)
}
}
impl TryFrom<String> for ContentHash {
type Error = ClmError;
fn try_from(value: String) -> Result<Self, Self::Error> {
Self::parse(value)
}
}
impl TryFrom<&str> for ContentHash {
type Error = ClmError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
Self::parse(value)
}
}
impl ConstantTimeEq for ContentHash {
fn ct_eq(&self, other: &Self) -> subtle::Choice {
self.0.as_bytes().ct_eq(other.0.as_bytes())
}
}
impl Serialize for ContentHash {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(&self.0)
}
}
impl<'de> Deserialize<'de> for ContentHash {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
Self::parse(&s).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct AgentDid(String);
impl AgentDid {
pub fn parse(s: impl AsRef<str>) -> Result<Self, ClmError> {
let s = s.as_ref().trim();
if !s.starts_with("did:") {
return Err(ClmError::auth(
AuthErrorCode::InvalidDid,
format!("Invalid AgentDid: must start with 'did:', found '{}'", s),
));
}
let parts: Vec<&str> = s.split(':').collect();
if parts.len() < 3 || parts[1].is_empty() || parts[2].is_empty() {
return Err(ClmError::auth(
AuthErrorCode::InvalidDid,
format!("Invalid AgentDid format: must contain method and identifier, found '{}'", s),
));
}
Ok(Self(s.to_string()))
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn method(&self) -> &str {
self.0.split(':').nth(1).unwrap_or("")
}
pub fn new(did: impl AsRef<str>) -> Result<Self, ClmError> {
Self::parse(did)
}
pub fn new_unchecked(s: impl Into<String>) -> Self {
Self(s.into())
}
}
impl Deref for AgentDid {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl AsRef<str> for AgentDid {
fn as_ref(&self) -> &str {
&self.0
}
}
impl fmt::Display for AgentDid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl fmt::Debug for AgentDid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "AgentDid({})", self.0)
}
}
impl TryFrom<String> for AgentDid {
type Error = ClmError;
fn try_from(value: String) -> Result<Self, Self::Error> {
Self::parse(value)
}
}
impl TryFrom<&str> for AgentDid {
type Error = ClmError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
Self::parse(value)
}
}
impl Serialize for AgentDid {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(&self.0)
}
}
impl<'de> Deserialize<'de> for AgentDid {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
Self::parse(&s).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Handle(String);
impl Handle {
pub fn parse(s: impl AsRef<str>) -> Result<Self, ClmError> {
let s = s.as_ref().trim();
if s.is_empty() {
return Err(ClmError::storage(
StorageErrorCode::CardNotFound,
"Handle cannot be empty",
));
}
if s.contains(' ') || s.contains('\t') || s.contains('\n') {
return Err(ClmError::storage(
StorageErrorCode::CorruptedContent,
format!("Handle cannot contain whitespace: '{}'", s),
));
}
Ok(Self(s.to_string()))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl Deref for Handle {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl AsRef<str> for Handle {
fn as_ref(&self) -> &str {
&self.0
}
}
impl fmt::Display for Handle {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl fmt::Debug for Handle {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Handle({})", self.0)
}
}
impl TryFrom<String> for Handle {
type Error = ClmError;
fn try_from(value: String) -> Result<Self, Self::Error> {
Self::parse(value)
}
}
impl TryFrom<&str> for Handle {
type Error = ClmError;
fn try_from(value: &str) -> Result<Self, Self::Error> {
Self::parse(value)
}
}
impl Serialize for Handle {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(&self.0)
}
}
impl<'de> Deserialize<'de> for Handle {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
Self::parse(&s).map_err(serde::de::Error::custom)
}
}
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub struct PlaceId(pub String);
impl fmt::Display for PlaceId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl fmt::Debug for PlaceId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "PlaceId({})", self.0)
}
}
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub struct TransitionId(pub String);
impl fmt::Display for TransitionId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl fmt::Debug for TransitionId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "TransitionId({})", self.0)
}
}
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
pub struct MarkingHash(pub String);
impl fmt::Display for MarkingHash {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl fmt::Debug for MarkingHash {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "MarkingHash({})", self.0)
}
}
#[derive(Clone, Zeroize, ZeroizeOnDrop)]
pub struct SecretKeyBytes(pub Vec<u8>);
impl SecretKeyBytes {
pub fn new(bytes: impl Into<Vec<u8>>) -> Self {
Self(bytes.into())
}
pub fn as_bytes(&self) -> &[u8] {
&self.0
}
}
impl fmt::Debug for SecretKeyBytes {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "[REDACTED SECRET KEY]")
}
}
impl fmt::Display for SecretKeyBytes {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "[REDACTED SECRET KEY]")
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct SavepointToken(String);
impl SavepointToken {
pub fn generate(prefix: &str) -> Self {
let clean_prefix: String = prefix
.chars()
.filter(|c| c.is_ascii_alphanumeric() || *c == '_')
.collect();
let id = uuid::Uuid::new_v4().simple().to_string();
let short_id = if id.len() >= 12 { &id[..12] } else { &id };
Self(format!("clm_sp_{}_{}", clean_prefix, short_id))
}
pub fn parse(s: &str) -> Result<Self, ClmError> {
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') && s.starts_with("clm_sp_") {
Ok(Self(s.to_string()))
} else {
Err(ClmError::storage(
StorageErrorCode::SavepointFailed,
format!("Invalid savepoint token identifier: {}", s),
))
}
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Display for SavepointToken {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
impl Deref for SavepointToken {
type Target = str;
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_content_hash_validation() {
let valid = "2f9acb02faa121bb2a3621951f57b4c690655337edee2e5ac350be2b3be88ea8";
let hash = ContentHash::parse(valid).expect("Valid hash should parse");
assert_eq!(hash.as_str(), valid);
assert!(ContentHash::parse("short_hash").is_err());
assert!(ContentHash::parse("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz").is_err());
}
#[test]
fn test_content_hash_constant_time_equality() {
let a = ContentHash::parse("2f9acb02faa121bb2a3621951f57b4c690655337edee2e5ac350be2b3be88ea8").unwrap();
let b = ContentHash::parse("2f9acb02faa121bb2a3621951f57b4c690655337edee2e5ac350be2b3be88ea8").unwrap();
let c = ContentHash::parse("0000000000000000000000000000000000000000000000000000000000000000").unwrap();
assert_eq!(a.ct_eq(&b).unwrap_u8(), 1);
assert_eq!(a.ct_eq(&c).unwrap_u8(), 0);
}
#[test]
fn test_agent_did_validation() {
let valid = "did:pkc:ca:darwin:root-agent";
let did = AgentDid::parse(valid).expect("Valid DID should parse");
assert_eq!(did.as_str(), valid);
assert_eq!(did.method(), "pkc");
assert!(AgentDid::parse("not_a_did").is_err());
assert!(AgentDid::parse("did:").is_err());
}
#[test]
fn test_handle_validation() {
let valid = "mcard:token/dca/1234";
let handle = Handle::parse(valid).expect("Valid handle should parse");
assert_eq!(handle.as_str(), valid);
assert!(Handle::parse("").is_err());
assert!(Handle::parse("invalid handle with spaces").is_err());
}
#[test]
fn test_secret_key_bytes_redaction() {
let secret = SecretKeyBytes::new(vec![1, 2, 3, 4, 5]);
let debug_str = format!("{:?}", secret);
assert_eq!(debug_str, "[REDACTED SECRET KEY]");
assert_eq!(secret.as_bytes(), &[1, 2, 3, 4, 5]);
}
#[test]
fn test_savepoint_token_generation_and_validation() {
let token = SavepointToken::generate("eval_fiber");
assert!(token.as_str().starts_with("clm_sp_eval_fiber_"));
assert!(SavepointToken::parse(token.as_str()).is_ok());
assert!(SavepointToken::parse("clm_sp_test; DROP TABLE card;--").is_err());
assert!(SavepointToken::parse("malicious_no_prefix").is_err());
}
}