synta-python 0.3.0

//! Python wrappers for ASN.1 string types: UTF8String, PrintableString, IA5String,
//! NumericString, TeletexString, VisibleString, GeneralString, UniversalString, BMPString.

use pyo3::exceptions::PyValueError;
use pyo3::prelude::*;
use pyo3::types::PyBytes;

use synta::{
    BmpString, FromDer, GeneralString, IA5String, NumericString, PrintableString, TeletexString,
    ToDer, UniversalString, Utf8String, VisibleString,
};

use crate::error::SyntaErr;

/// Python wrapper for ASN.1 UTF8String
#[pyclass(name = "Utf8String")]
#[derive(Debug, Clone)]
pub struct PyUtf8String {
    pub(crate) inner: Utf8String,
}

#[pymethods]
impl PyUtf8String {
    /// Create a new UTF8String from a Python str
    #[new]
    fn new(value: &str) -> Self {
        Self {
            inner: Utf8String::new(value.to_string()),
        }
    }

    /// Get the string value
    fn as_str(&self) -> &str {
        self.inner.as_str()
    }

    fn __str__(&self) -> &str {
        self.inner.as_str()
    }

    fn __repr__(&self) -> String {
        format!("Utf8String('{}')", self.inner.as_str())
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    fn __len__(&self) -> usize {
        self.inner.as_str().chars().count()
    }

    /// Return the DER encoding of this ``Utf8String``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``Utf8String``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = Utf8String::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 PrintableString
///
/// PrintableString is a subset of ASCII containing A-Z, a-z, 0-9,
/// and the characters: ' ( ) + , - . / : = ?
#[pyclass(name = "PrintableString")]
#[derive(Debug, Clone)]
pub struct PyPrintableString {
    pub(crate) inner: PrintableString,
}

#[pymethods]
impl PyPrintableString {
    /// Create a new PrintableString
    ///
    /// Raises ValueError if the string contains characters outside the PrintableString charset.
    #[new]
    fn new(value: &str) -> PyResult<Self> {
        let inner = PrintableString::new(value.to_string())
            .map_err(|e| PyValueError::new_err(format!("Invalid PrintableString: {:?}", e)))?;
        Ok(Self { inner })
    }

    /// Get the string value
    fn as_str(&self) -> &str {
        self.inner.as_str()
    }

    fn __str__(&self) -> &str {
        self.inner.as_str()
    }

    fn __repr__(&self) -> String {
        format!("PrintableString('{}')", self.inner.as_str())
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    fn __len__(&self) -> usize {
        self.inner.as_str().chars().count()
    }

    /// Return the DER encoding of this ``PrintableString``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``PrintableString``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = PrintableString::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 IA5String (International Alphabet 5 = ASCII)
#[pyclass(name = "IA5String")]
#[derive(Debug, Clone)]
pub struct PyIA5String {
    pub(crate) inner: IA5String,
}

#[pymethods]
impl PyIA5String {
    /// Create a new IA5String
    ///
    /// Raises ValueError if the string contains non-ASCII characters.
    #[new]
    fn new(value: &str) -> PyResult<Self> {
        let inner = IA5String::new(value.to_string())
            .map_err(|e| PyValueError::new_err(format!("Invalid IA5String: {:?}", e)))?;
        Ok(Self { inner })
    }

    /// Get the string value
    fn as_str(&self) -> &str {
        self.inner.as_str()
    }

    fn __str__(&self) -> &str {
        self.inner.as_str()
    }

    fn __repr__(&self) -> String {
        format!("IA5String('{}')", self.inner.as_str())
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    fn __len__(&self) -> usize {
        self.inner.as_str().chars().count()
    }

    /// Return the DER encoding of this ``IA5String``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``IA5String``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = IA5String::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 NumericString (tag 18) — digits and space
#[pyclass(name = "NumericString")]
#[derive(Debug, Clone)]
pub struct PyNumericString {
    pub(crate) inner: NumericString,
}

#[pymethods]
impl PyNumericString {
    /// Create a ``NumericString`` from *value*.
    ///
    /// :raises ValueError: if *value* contains characters other than digits (0–9) and space.
    #[new]
    fn new(value: &str) -> PyResult<Self> {
        let inner = NumericString::new(value.to_string())
            .map_err(|e| PyValueError::new_err(format!("Invalid NumericString: {:?}", e)))?;
        Ok(Self { inner })
    }

    fn as_str(&self) -> &str {
        self.inner.as_str()
    }

    fn __str__(&self) -> &str {
        self.inner.as_str()
    }

    fn __repr__(&self) -> String {
        format!("NumericString('{}')", self.inner.as_str())
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    fn __len__(&self) -> usize {
        self.inner.as_str().chars().count()
    }

    /// Return the DER encoding of this ``NumericString``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``NumericString``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = NumericString::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 TeletexString / T61String (tag 20) — arbitrary 8-bit bytes
#[pyclass(name = "TeletexString")]
#[derive(Debug, Clone)]
pub struct PyTeletexString {
    pub(crate) inner: TeletexString,
}

#[pymethods]
impl PyTeletexString {
    /// Create from raw bytes.
    #[new]
    fn new(data: Vec<u8>) -> Self {
        Self {
            inner: TeletexString::new(data),
        }
    }

    /// Create from a Python str, encoding as Latin-1.
    ///
    /// Raises ValueError if any character is outside the Latin-1 range (U+0000..=U+00FF).
    #[staticmethod]
    fn from_latin1(value: &str) -> PyResult<Self> {
        TeletexString::from_latin1(value)
            .map(|inner| Self { inner })
            .map_err(|e| PyValueError::new_err(format!("{:?}", e)))
    }

    /// Create from a Python str, encoding as Latin-1.
    ///
    /// Raises ValueError if any character is outside the Latin-1 range (U+0000..=U+00FF).
    #[staticmethod]
    fn from_str(value: &str) -> PyResult<Self> {
        TeletexString::from_latin1(value)
            .map(|inner| Self { inner })
            .map_err(|e| PyValueError::new_err(format!("{:?}", e)))
    }

    /// Return the raw bytes.
    fn to_bytes<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {
        PyBytes::new(py, self.inner.as_bytes())
    }

    /// Decode as a Latin-1 string.
    fn as_str(&self) -> String {
        self.inner.as_latin1_string()
    }

    fn __str__(&self) -> String {
        self.inner.as_latin1_string()
    }

    fn __repr__(&self) -> String {
        format!("TeletexString(<{} bytes>)", self.inner.as_bytes().len())
    }

    fn __len__(&self) -> usize {
        self.inner.as_bytes().len()
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    /// Return the DER encoding of this ``TeletexString``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``TeletexString``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = TeletexString::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 VisibleString (tag 26) — printable ASCII
#[pyclass(name = "VisibleString")]
#[derive(Debug, Clone)]
pub struct PyVisibleString {
    pub(crate) inner: VisibleString,
}

#[pymethods]
impl PyVisibleString {
    /// Create a ``VisibleString`` from *value*.
    ///
    /// :raises ValueError: if *value* contains characters outside the printable ASCII range
    ///     (U+0020–U+007E).
    #[new]
    fn new(value: &str) -> PyResult<Self> {
        let inner = VisibleString::new(value.to_string())
            .map_err(|e| PyValueError::new_err(format!("Invalid VisibleString: {:?}", e)))?;
        Ok(Self { inner })
    }

    fn as_str(&self) -> &str {
        self.inner.as_str()
    }

    fn __str__(&self) -> &str {
        self.inner.as_str()
    }

    fn __repr__(&self) -> String {
        format!("VisibleString('{}')", self.inner.as_str())
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    fn __len__(&self) -> usize {
        self.inner.as_str().len()
    }

    /// Return the DER encoding of this ``VisibleString``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``VisibleString``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = VisibleString::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 GeneralString (tag 27) — 8-bit bytes, treated as Latin-1
#[pyclass(name = "GeneralString")]
#[derive(Debug, Clone)]
pub struct PyGeneralString {
    pub(crate) inner: GeneralString,
}

#[pymethods]
impl PyGeneralString {
    /// Create from raw bytes.
    #[new]
    fn new(data: Vec<u8>) -> Self {
        Self {
            inner: GeneralString::new(data),
        }
    }

    /// Create from a Python str, encoding as ASCII.
    ///
    /// Raises ValueError if any character is outside the ASCII range (U+0000..=U+007F).
    #[staticmethod]
    fn from_ascii(value: &str) -> PyResult<Self> {
        GeneralString::from_ascii(value)
            .map(|inner| Self { inner })
            .map_err(|e| PyValueError::new_err(format!("{:?}", e)))
    }

    /// Create from a Python str, encoding as ASCII.
    ///
    /// Raises ValueError if any character is outside the ASCII range (U+0000..=U+007F).
    #[staticmethod]
    fn from_str(value: &str) -> PyResult<Self> {
        GeneralString::from_ascii(value)
            .map(|inner| Self { inner })
            .map_err(|e| PyValueError::new_err(format!("{:?}", e)))
    }

    /// Return the raw bytes.
    fn to_bytes<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {
        PyBytes::new(py, self.inner.as_bytes())
    }

    /// Decode as a Latin-1 string.
    fn as_str(&self) -> String {
        self.inner.as_latin1_string()
    }

    fn __str__(&self) -> String {
        self.inner.as_latin1_string()
    }

    fn __repr__(&self) -> String {
        format!("GeneralString(<{} bytes>)", self.inner.as_bytes().len())
    }

    fn __len__(&self) -> usize {
        self.inner.as_bytes().len()
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    /// Return the DER encoding of this ``GeneralString``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``GeneralString``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = GeneralString::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 UniversalString (tag 28) — UCS-4 big-endian
#[pyclass(name = "UniversalString")]
#[derive(Debug, Clone)]
pub struct PyUniversalString {
    pub(crate) inner: UniversalString,
}

#[pymethods]
impl PyUniversalString {
    /// Create from a Python str.
    #[new]
    fn new(value: &str) -> Self {
        Self {
            inner: UniversalString::new(value.to_string()),
        }
    }

    /// Create from raw UCS-4 big-endian bytes.
    #[staticmethod]
    fn from_bytes(data: &[u8]) -> PyResult<Self> {
        let inner = UniversalString::from_ucs4_be(data)
            .map_err(|e| PyValueError::new_err(format!("Invalid UniversalString: {:?}", e)))?;
        Ok(Self { inner })
    }

    fn as_str(&self) -> &str {
        self.inner.as_str()
    }

    fn __str__(&self) -> &str {
        self.inner.as_str()
    }

    fn __repr__(&self) -> String {
        format!("UniversalString('{}')", self.inner.as_str())
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    fn __len__(&self) -> usize {
        self.inner.as_str().chars().count()
    }

    /// Return the DER encoding of this ``UniversalString``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``UniversalString``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = UniversalString::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}

/// Python wrapper for ASN.1 BMPString (tag 30) — UCS-2 big-endian (BMP only)
#[pyclass(name = "BmpString")]
#[derive(Debug, Clone)]
pub struct PyBmpString {
    pub(crate) inner: BmpString,
}

#[pymethods]
impl PyBmpString {
    /// Create from a Python str (must be BMP-only, i.e. no code points > U+FFFF).
    #[new]
    fn new(value: &str) -> PyResult<Self> {
        let inner = BmpString::new(value.to_string())
            .map_err(|e| PyValueError::new_err(format!("Invalid BMPString: {:?}", e)))?;
        Ok(Self { inner })
    }

    /// Create from raw UCS-2 big-endian bytes.
    #[staticmethod]
    fn from_bytes(data: &[u8]) -> PyResult<Self> {
        let inner = BmpString::from_ucs2_be(data)
            .map_err(|e| PyValueError::new_err(format!("Invalid BMPString: {:?}", e)))?;
        Ok(Self { inner })
    }

    fn as_str(&self) -> &str {
        self.inner.as_str()
    }

    fn __str__(&self) -> &str {
        self.inner.as_str()
    }

    fn __repr__(&self) -> String {
        format!("BmpString('{}')", self.inner.as_str())
    }

    fn __eq__(&self, other: &Self) -> bool {
        self.inner == other.inner
    }

    fn __len__(&self) -> usize {
        self.inner.as_str().chars().count()
    }

    /// Return the DER encoding of this ``BmpString``.
    fn to_der<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
        Ok(PyBytes::new(py, &self.inner.to_der().map_err(SyntaErr)?))
    }

    /// Parse a DER-encoded ``BmpString``.
    ///
    /// :raises ValueError: if the bytes cannot be decoded.
    #[staticmethod]
    fn from_der(data: &[u8]) -> PyResult<Self> {
        let inner = BmpString::from_der(data).map_err(SyntaErr)?;
        Ok(Self { inner })
    }
}