safehtml 0.2.0

A high-performance, no_std Rust library for Type-Driven Security (XSS and injection prevention).
Documentation
//! Optional `serde` support: `Serialize`/`Deserialize` impls for the safe
//! types. `Deserialize` trusts the input except for `SafeUrl`, which
//! re-validates — see the "Security Model" section in the crate docs.

use super::*;
use serde::{Deserialize, Deserializer, Serialize, Serializer};

impl Serialize for SafeHtml {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for SafeHtml {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = alloc::string::String::deserialize(deserializer)?;
        // SECURITY: The already-safe-HTML contract cannot be re-verified,
        // so the input is trusted, like FromProto. Only deserialize
        // SafeHtml from trusted sources (database, internal services) —
        // never directly from user-controlled request bodies.
        Ok(unsafe { SafeHtml::from_string_unchecked(s) })
    }
}

impl Serialize for SafeUrl {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for SafeUrl {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = alloc::string::String::deserialize(deserializer)?;
        // For safety, we sanitize the URL on deserialization.
        // If it is not safe, we fail deserialization (safer for API
        // endpoints than silently substituting INNOCUOUS_URL).
        if is_safe_url_restrictive(&s) {
            Ok(unsafe { SafeUrl::from_string_unchecked(s) })
        } else {
            use serde::de::Error;
            Err(D::Error::custom("untrusted or invalid scheme in SafeUrl"))
        }
    }
}

impl Serialize for SafeScript {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for SafeScript {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = alloc::string::String::deserialize(deserializer)?;
        // SECURITY: input is trusted; see the note on SafeHtml above.
        Ok(unsafe { SafeScript::from_string_unchecked(s) })
    }
}

impl Serialize for TrustedResourceUrl {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for TrustedResourceUrl {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = alloc::string::String::deserialize(deserializer)?;
        // SECURITY: input is trusted; see the note on SafeHtml above.
        Ok(unsafe { TrustedResourceUrl::from_string_unchecked(s) })
    }
}

impl Serialize for SafeStyle {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for SafeStyle {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = alloc::string::String::deserialize(deserializer)?;
        // SECURITY: input is trusted; see the note on SafeHtml above.
        Ok(unsafe { SafeStyle::from_string_unchecked(s) })
    }
}

impl Serialize for SafeStyleSheet {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for SafeStyleSheet {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = alloc::string::String::deserialize(deserializer)?;
        // SECURITY: input is trusted; see the note on SafeHtml above.
        Ok(unsafe { SafeStyleSheet::from_string_unchecked(s) })
    }
}

impl Serialize for Identifier {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de> Deserialize<'de> for Identifier {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = alloc::string::String::deserialize(deserializer)?;
        // Identifiers are fully re-validatable, so reject invalid input
        // instead of trusting it.
        if is_safe_identifier(&s) {
            // SAFETY: just validated.
            Ok(unsafe { Identifier::from_string_unchecked(s) })
        } else {
            Err(serde::de::Error::custom(
                "invalid identifier: expected [A-Za-z][A-Za-z0-9_-]*",
            ))
        }
    }
}