asn1: Add support for bytes, str and bool (#13482)

* asn1: Add support for bytes, str and bool

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

* Use `PyBackedStr`

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

---------

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

Author: facutuesca

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

@@ -11,7 +11,10 @@ def non_root_python_to_rust(cls: type) -> Type: ...
 # annotations like this:
 class Type:
     Sequence: typing.ClassVar[type]
+    PyBool: typing.ClassVar[type]
     PyInt: typing.ClassVar[type]
+    PyBytes: typing.ClassVar[type]
+    PyStr: typing.ClassVar[type]
 
 class Annotation:
     def __new__(

src/rust/src/declarative_asn1/decode.rs

@@ -11,6 +11,14 @@ use crate::error::CryptographyError;
 
 type ParseResult<T> = Result<T, CryptographyError>;
 
+fn decode_pybool<'a>(
+    py: pyo3::Python<'a>,
+    parser: &mut Parser<'a>,
+) -> ParseResult<pyo3::Bound<'a, pyo3::types::PyBool>> {
+    let value = parser.read_element::<bool>()?;
+    Ok(pyo3::types::PyBool::new(py, value).to_owned())
+}
+
 fn decode_pyint<'a>(
     py: pyo3::Python<'a>,
     parser: &mut Parser<'a>,
@@ -24,6 +32,22 @@ fn decode_pyint<'a>(
     Ok(pyint)
 }
 
+fn decode_pybytes<'a>(
+    py: pyo3::Python<'a>,
+    parser: &mut Parser<'a>,
+) -> ParseResult<pyo3::Bound<'a, pyo3::types::PyBytes>> {
+    let value = parser.read_element::<&[u8]>()?;
+    Ok(pyo3::types::PyBytes::new(py, value))
+}
+
+fn decode_pystr<'a>(
+    py: pyo3::Python<'a>,
+    parser: &mut Parser<'a>,
+) -> ParseResult<pyo3::Bound<'a, pyo3::types::PyString>> {
+    let value = parser.read_element::<asn1::Utf8String<'a>>()?;
+    Ok(pyo3::types::PyString::new(py, value.as_str()))
+}
+
 pub(crate) fn decode_annotated_type<'a>(
     py: pyo3::Python<'a>,
     parser: &mut Parser<'a>,
@@ -50,6 +74,9 @@ pub(crate) fn decode_annotated_type<'a>(
                 Ok(val)
             })
         }
+        Type::PyBool() => Ok(decode_pybool(py, parser)?.into_any()),
         Type::PyInt() => Ok(decode_pyint(py, parser)?.into_any()),
+        Type::PyBytes() => Ok(decode_pybytes(py, parser)?.into_any()),
+        Type::PyStr() => Ok(decode_pystr(py, parser)?.into_any()),
     }
 }

src/rust/src/declarative_asn1/encode.rs

@@ -48,12 +48,31 @@ impl asn1::Asn1Writable for AnnotatedTypeObject<'_> {
                     Ok(())
                 }),
             ),
+            Type::PyBool() => {
+                let val: bool = value
+                    .extract()
+                    .map_err(|_| asn1::WriteError::AllocationError)?;
+                write_value(writer, &val)
+            }
             Type::PyInt() => {
                 let val: i64 = value
                     .extract()
                     .map_err(|_| asn1::WriteError::AllocationError)?;
                 write_value(writer, &val)
             }
+            Type::PyBytes() => {
+                let val: &[u8] = value
+                    .extract()
+                    .map_err(|_| asn1::WriteError::AllocationError)?;
+                write_value(writer, &val)
+            }
+            Type::PyStr() => {
+                let val: pyo3::pybacked::PyBackedStr = value
+                    .extract()
+                    .map_err(|_| asn1::WriteError::AllocationError)?;
+                let asn1_string: asn1::Utf8String<'_> = asn1::Utf8String::new(&val);
+                write_value(writer, &asn1_string)
+            }
         }
     }
 }

src/rust/src/declarative_asn1/types.rs

@@ -20,9 +20,18 @@ pub enum Type {
 
     // Python types that we map to canonical ASN.1 types
     //
+    /// `bool` -> `Boolean`
+    #[pyo3(constructor = ())]
+    PyBool(),
     /// `int` -> `Integer`
     #[pyo3(constructor = ())]
     PyInt(),
+    /// `bytes` -> `Octet String`
+    #[pyo3(constructor = ())]
+    PyBytes(),
+    /// `str` -> `UTF8String`
+    #[pyo3(constructor = ())]
+    PyStr(),
 }
 
 /// A type that we know how to encode/decode, along with any
@@ -70,6 +79,12 @@ pub fn non_root_python_to_rust<'p>(
 ) -> pyo3::PyResult<pyo3::Bound<'p, Type>> {
     if class.is(pyo3::types::PyInt::type_object(py)) {
         Type::PyInt().into_pyobject(py)
+    } else if class.is(pyo3::types::PyBool::type_object(py)) {
+        Type::PyBool().into_pyobject(py)
+    } else if class.is(pyo3::types::PyString::type_object(py)) {
+        Type::PyStr().into_pyobject(py)
+    } else if class.is(pyo3::types::PyBytes::type_object(py)) {
+        Type::PyBytes().into_pyobject(py)
     } else {
         Err(pyo3::exceptions::PyTypeError::new_err(format!(
             "cannot handle type: {class:?}"

tests/hazmat/asn1/test_serialization.py

@@ -46,6 +46,16 @@ def assert_roundtrips(
         assert decoded == obj
 
 
+class TestBool:
+    def test_bool(self) -> None:
+        assert_roundtrips(
+            [
+                (True, b"\x01\x01\xff"),
+                (False, b"\x01\x01\x00"),
+            ],
+        )
+
+
 class TestInteger:
     def test_int(self) -> None:
         assert_roundtrips(
@@ -64,6 +74,37 @@ def test_int(self) -> None:
         )
 
 
+class TestBytes:
+    def test_bytes(self) -> None:
+        assert_roundtrips(
+            [
+                (b"", b"\x04\x00"),
+                (b"hello", b"\x04\x05hello"),
+                (b"\x01\x02\x03", b"\x04\x03\x01\x02\x03"),
+                (
+                    b"\x00\xff\x80\x7f",
+                    b"\x04\x04\x00\xff\x80\x7f",
+                ),
+            ]
+        )
+
+
+class TestString:
+    def test_string(self) -> None:
+        assert_roundtrips(
+            [
+                ("", b"\x0c\x00"),
+                ("hello", b"\x0c\x05hello"),
+                ("Test User 1", b"\x0c\x0bTest User 1"),
+                (
+                    "café",
+                    b"\x0c\x05caf\xc3\xa9",
+                ),  # UTF-8 string with non-ASCII
+                ("🚀", b"\x0c\x04\xf0\x9f\x9a\x80"),  # UTF-8 emoji
+            ]
+        )
+
+
 class TestSequence:
     def test_ok_sequence_single_field(self) -> None:
         @asn1.sequence
@@ -73,7 +114,7 @@ class Example:
 
         assert_roundtrips([(Example(foo=9), b"\x30\x03\x02\x01\x09")])
 
-    def test_encode_ok_sequence_multiple_fields(self) -> None:
+    def test_ok_sequence_multiple_fields(self) -> None:
         @asn1.sequence
         @_comparable_dataclass
         class Example:
@@ -84,7 +125,7 @@ class Example:
             [(Example(foo=9, bar=6), b"\x30\x06\x02\x01\x09\x02\x01\x06")]
         )
 
-    def test_encode_ok_nested_sequence(self) -> None:
+    def test_ok_nested_sequence(self) -> None:
         @asn1.sequence
         @_comparable_dataclass
         class Child:
@@ -98,3 +139,21 @@ class Parent:
         assert_roundtrips(
             [(Parent(foo=Child(foo=9)), b"\x30\x05\x30\x03\x02\x01\x09")]
         )
+
+    def test_ok_sequence_multiple_types(self) -> None:
+        @asn1.sequence
+        @_comparable_dataclass
+        class Example:
+            a: bool
+            b: int
+            c: bytes
+            d: str
+
+        assert_roundtrips(
+            [
+                (
+                    Example(a=True, b=9, c=b"c", d="d"),
+                    b"\x30\x0c\x01\x01\xff\x02\x01\x09\x04\x01c\x0c\x01d",
+                )
+            ]
+        )