asn1: Add support for IA5String

Signed-off-by: Facundo Tuesca <[email protected]>

Author: facutuesca

src/cryptography/hazmat/asn1/__init__.py

@@ -7,6 +7,7 @@
     Default,
     Explicit,
     GeneralizedTime,
+    IA5String,
     Implicit,
     PrintableString,
     Size,
@@ -21,6 +22,7 @@
     "Default",
     "Explicit",
     "GeneralizedTime",
+    "IA5String",
     "Implicit",
     "PrintableString",
     "Size",

src/cryptography/hazmat/asn1/asn1.py

@@ -238,6 +238,7 @@ class Default(typing.Generic[U]):
 Size = declarative_asn1.Size
 
 PrintableString = declarative_asn1.PrintableString
+IA5String = declarative_asn1.IA5String
 UtcTime = declarative_asn1.UtcTime
 GeneralizedTime = declarative_asn1.GeneralizedTime
 BitString = declarative_asn1.BitString

src/cryptography/hazmat/bindings/_rust/declarative_asn1.pyi

@@ -66,6 +66,12 @@ class PrintableString:
     def __eq__(self, other: object) -> bool: ...
     def as_str(self) -> str: ...
 
+class IA5String:
+    def __new__(cls, inner: str) -> IA5String: ...
+    def __repr__(self) -> str: ...
+    def __eq__(self, other: object) -> bool: ...
+    def as_str(self) -> str: ...
+
 class UtcTime:
     def __new__(cls, inner: datetime.datetime) -> UtcTime: ...
     def __repr__(self) -> str: ...

src/rust/src/declarative_asn1/decode.rs

@@ -8,8 +8,8 @@ use pyo3::types::PyListMethods;
 
 use crate::asn1::big_byte_slice_to_py_int;
 use crate::declarative_asn1::types::{
-    type_to_tag, AnnotatedType, BitString, Encoding, GeneralizedTime, PrintableString, Type,
-    UtcTime,
+    type_to_tag, AnnotatedType, BitString, Encoding, GeneralizedTime, IA5String, PrintableString,
+    Type, UtcTime,
 };
 use crate::error::CryptographyError;
 
@@ -77,6 +77,16 @@ fn decode_printable_string<'a>(
     Ok(pyo3::Bound::new(py, PrintableString { inner })?)
 }
 
+fn decode_ia5_string<'a>(
+    py: pyo3::Python<'a>,
+    parser: &mut Parser<'a>,
+    encoding: &Option<pyo3::Py<Encoding>>,
+) -> ParseResult<pyo3::Bound<'a, IA5String>> {
+    let value = read_value::<asn1::IA5String<'a>>(parser, encoding)?.as_str();
+    let inner = pyo3::types::PyString::new(py, value).unbind();
+    Ok(pyo3::Bound::new(py, IA5String { inner })?)
+}
+
 fn decode_utc_time<'a>(
     py: pyo3::Python<'a>,
     parser: &mut Parser<'a>,
@@ -216,6 +226,7 @@ pub(crate) fn decode_annotated_type<'a>(
         Type::PyBytes() => decode_pybytes(py, parser, encoding)?.into_any(),
         Type::PyStr() => decode_pystr(py, parser, encoding)?.into_any(),
         Type::PrintableString() => decode_printable_string(py, parser, encoding)?.into_any(),
+        Type::IA5String() => decode_ia5_string(py, parser, encoding)?.into_any(),
         Type::UtcTime() => decode_utc_time(py, parser, encoding)?.into_any(),
         Type::GeneralizedTime() => decode_generalized_time(py, parser, encoding)?.into_any(),
         Type::BitString() => decode_bitstring(py, parser, encoding)?.into_any(),

src/rust/src/declarative_asn1/encode.rs

@@ -7,8 +7,8 @@ use pyo3::types::PyAnyMethods;
 use pyo3::types::PyListMethods;
 
 use crate::declarative_asn1::types::{
-    AnnotatedType, AnnotatedTypeObject, BitString, Encoding, GeneralizedTime, PrintableString,
-    Type, UtcTime,
+    AnnotatedType, AnnotatedTypeObject, BitString, Encoding, GeneralizedTime, IA5String,
+    PrintableString, Type, UtcTime,
 };
 
 fn write_value<T: SimpleAsn1Writable>(
@@ -148,6 +148,19 @@ impl asn1::Asn1Writable for AnnotatedTypeObject<'_> {
                         .ok_or(asn1::WriteError::AllocationError)?;
                 write_value(writer, &printable_string, encoding)
             }
+            Type::IA5String() => {
+                let val: &pyo3::Bound<'_, IA5String> = value
+                    .cast()
+                    .map_err(|_| asn1::WriteError::AllocationError)?;
+                let inner_str = val
+                    .get()
+                    .inner
+                    .to_cow(py)
+                    .map_err(|_| asn1::WriteError::AllocationError)?;
+                let ia5_string: asn1::IA5String<'_> =
+                    asn1::IA5String::new(&inner_str).ok_or(asn1::WriteError::AllocationError)?;
+                write_value(writer, &ia5_string, encoding)
+            }
             Type::UtcTime() => {
                 let val: &pyo3::Bound<'_, UtcTime> = value
                     .cast()

src/rust/src/declarative_asn1/types.rs

@@ -2,6 +2,7 @@
 // 2.0, and the BSD License. See the LICENSE file in the root of this repository
 // for complete details.
 
+use asn1::IA5String as Asn1IA5String;
 use asn1::PrintableString as Asn1PrintableString;
 use asn1::SimpleAsn1Readable;
 use asn1::UtcTime as Asn1UtcTime;
@@ -36,6 +37,8 @@ pub enum Type {
     PyStr(),
     /// PrintableString (`str`)
     PrintableString(),
+    /// IA5String (`str`)
+    IA5String(),
     /// UtcTime (`datetime`)
     UtcTime(),
     /// GeneralizedTime (`datetime`)
@@ -162,6 +165,39 @@ impl PrintableString {
     }
 }
 
+#[derive(pyo3::FromPyObject)]
+#[pyo3::pyclass(frozen, module = "cryptography.hazmat.bindings._rust.asn1")]
+pub struct IA5String {
+    pub(crate) inner: pyo3::Py<pyo3::types::PyString>,
+}
+
+#[pyo3::pymethods]
+impl IA5String {
+    #[new]
+    #[pyo3(signature = (inner,))]
+    fn new(py: pyo3::Python<'_>, inner: pyo3::Py<pyo3::types::PyString>) -> pyo3::PyResult<Self> {
+        if Asn1IA5String::new(&inner.to_cow(py)?).is_none() {
+            return Err(pyo3::exceptions::PyValueError::new_err(format!(
+                "invalid IA5String: {inner}"
+            )));
+        }
+
+        Ok(IA5String { inner })
+    }
+
+    pub fn as_str(&self, py: pyo3::Python<'_>) -> pyo3::PyResult<pyo3::Py<pyo3::types::PyString>> {
+        Ok(self.inner.clone_ref(py))
+    }
+
+    fn __eq__(&self, py: pyo3::Python<'_>, other: pyo3::PyRef<'_, Self>) -> pyo3::PyResult<bool> {
+        (**self.inner.bind(py)).eq(other.inner.bind(py))
+    }
+
+    pub fn __repr__(&self, py: pyo3::Python<'_>) -> pyo3::PyResult<String> {
+        Ok(format!("IA5String({})", self.inner.bind(py).repr()?))
+    }
+}
+
 #[derive(pyo3::FromPyObject)]
 #[pyo3::pyclass(frozen, module = "cryptography.hazmat.bindings._rust.asn1")]
 pub struct UtcTime {
@@ -310,6 +346,8 @@ pub fn non_root_python_to_rust<'p>(
         Type::PyBytes().into_pyobject(py)
     } else if class.is(PrintableString::type_object(py)) {
         Type::PrintableString().into_pyobject(py)
+    } else if class.is(IA5String::type_object(py)) {
+        Type::IA5String().into_pyobject(py)
     } else if class.is(UtcTime::type_object(py)) {
         Type::UtcTime().into_pyobject(py)
     } else if class.is(GeneralizedTime::type_object(py)) {
@@ -370,6 +408,7 @@ pub(crate) fn type_to_tag(t: &Type, encoding: &Option<pyo3::Py<Encoding>>) -> as
         Type::PyBytes() => <&[u8] as SimpleAsn1Readable>::TAG,
         Type::PyStr() => asn1::Utf8String::TAG,
         Type::PrintableString() => asn1::PrintableString::TAG,
+        Type::IA5String() => asn1::IA5String::TAG,
         Type::UtcTime() => asn1::UtcTime::TAG,
         Type::GeneralizedTime() => asn1::GeneralizedTime::TAG,
         Type::BitString() => asn1::BitString::TAG,

src/rust/src/lib.rs

@@ -152,7 +152,7 @@ mod _rust {
         #[pymodule_export]
         use crate::declarative_asn1::types::{
             non_root_python_to_rust, AnnotatedType, Annotation, BitString, Encoding,
-            GeneralizedTime, PrintableString, Size, Type, UtcTime,
+            GeneralizedTime, IA5String, PrintableString, Size, Type, UtcTime,
         };
     }
 

tests/hazmat/asn1/test_api.py

@@ -33,6 +33,18 @@ def test_invalid_printable_string(self) -> None:
         with pytest.raises(ValueError, match="invalid PrintableString: café"):
             asn1.PrintableString("café")
 
+    def test_repr_ia5_string(self) -> None:
+        my_string = "MyString"
+        assert repr(asn1.IA5String(my_string)) == f"IA5String({my_string!r})"
+
+    def test_ia5_string_as_str(self) -> None:
+        my_string = "MyString"
+        assert asn1.IA5String(my_string).as_str() == my_string
+
+    def test_invalid_ia5_string(self) -> None:
+        with pytest.raises(ValueError, match="invalid IA5String: café"):
+            asn1.IA5String("café")
+
     def test_utc_time_as_datetime(self) -> None:
         dt = datetime.datetime(
             2000, 1, 1, 10, 10, 10, tzinfo=datetime.timezone.utc

tests/hazmat/asn1/test_serialization.py

@@ -127,6 +127,17 @@ def test_ok_printable_string(self) -> None:
         )
 
 
+class TestIA5String:
+    def test_ok_ia5_string(self) -> None:
+        assert_roundtrips(
+            [
+                (asn1.IA5String(""), b"\x16\x00"),
+                (asn1.IA5String("hello"), b"\x16\x05hello"),
+                (asn1.IA5String("Test User 1"), b"\x16\x0bTest User 1"),
+            ]
+        )
+
+
 class TestUtcTime:
     def test_utc_time(self) -> None:
         assert_roundtrips(
@@ -538,6 +549,7 @@ class Example:
             f: typing.Union[asn1.GeneralizedTime, None]
             g: typing.Union[typing.List[int], None]
             h: typing.Union[asn1.BitString, None]
+            i: typing.Union[asn1.IA5String, None]
 
         assert_roundtrips(
             [
@@ -551,6 +563,7 @@ class Example:
                         f=None,
                         g=None,
                         h=None,
+                        i=None,
                     ),
                     b"\x30\x00",
                 )