Expose openpgp_sequoia::armor::Writer

Add an armor(bytes, ArmorKind) function

Signed-off-by: Daniel Alley <dalley@redhat.com>

Author: dralley

NEXT.md

@@ -8,6 +8,7 @@ New:
   - Added `PacketPile` and `Packet` for low-level reading of individual packet fields [#61]
   - Added `Sig.signature_type`, `Sig.hash_algorithm`, `Sig.key_algorithm`, and `Sig.key_validity_period` [#61]
   - Added `SignatureType`, `PublicKeyAlgorithm`, `HashAlgorithm`, `DataFormat`, `Tag` and `KeyFlags` as returned types [#61]
+  - Added Sequoia's `armor::Writer` for applying Ascii Armor to data, via the `armor()` function and `ArmorKind` type [#61]
 
 Changed:
   - `Sig.issuer_fpr` is now considered deprecated, use `Sig.issuer_fingerprint` instead [#60]

README.md

@@ -692,6 +692,30 @@ assert packet.tag == Tag.PublicKey
 assert len(packet.body) > 0
 ```
 
+## ASCII armor
+
+The `armor` function wraps raw binary OpenPGP data in ASCII armor,
+adding the appropriate header, base64 encoding, and CRC24 checksum:
+
+```python
+from pysequoia import armor, ArmorKind
+
+cert = Cert.generate("Test <test@example.com>")
+armored = armor(bytes(cert), ArmorKind.PublicKey)
+assert "-----BEGIN PGP PUBLIC KEY BLOCK-----" in armored
+assert "-----END PGP PUBLIC KEY BLOCK-----" in armored
+```
+
+Other armor kinds are available for different data types:
+
+```python
+armored_msg = armor(b"dummy data", ArmorKind.Message)
+assert "BEGIN PGP MESSAGE" in armored_msg
+
+armored_sig = armor(b"dummy data", ArmorKind.Signature)
+assert "BEGIN PGP SIGNATURE" in armored_sig
+```
+
 ## License
 
 This project is licensed under [Apache License, Version 2.0][APL].

src/lib.rs

@@ -19,6 +19,8 @@ use sequoia_openpgp::parse::stream::GoodChecksum;
 use sequoia_openpgp::serialize::stream::Armorer;
 use sequoia_openpgp::serialize::{Marshal, stream::Message};
 
+use crate::types::ArmorKind;
+
 pub(crate) fn serialize<T>(p: Packet, armor_kind: T) -> sequoia_openpgp::Result<Vec<u8>>
 where
     T: Into<Option<Kind>>,
@@ -92,11 +94,32 @@ impl Decrypted {
     }
 }
 
+/// Wrap raw OpenPGP data in ASCII armor.
+///
+/// Takes raw binary OpenPGP data and an `ArmorKind` specifying the armor
+/// header type, and returns the ASCII-armored string.
+#[pyfunction]
+pub fn armor(data: &[u8], kind: ArmorKind) -> PyResult<String> {
+    let mut output = vec![];
+    {
+        let mut writer = sequoia_openpgp::armor::Writer::new(&mut output, kind.into())
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
+        std::io::Write::write_all(&mut writer, data)
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
+        writer
+            .finalize()
+            .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?;
+    }
+    String::from_utf8(output).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))
+}
+
 #[pymodule]
 pub mod pysequoia {
     #[pymodule_export]
     pub use super::Decrypted;
     #[pymodule_export]
+    pub use super::armor;
+    #[pymodule_export]
     pub use super::cert::Cert;
     #[pymodule_export]
     pub use super::cert::Profile;
@@ -127,6 +150,8 @@ pub mod pysequoia {
     #[pymodule_export]
     pub use super::signer::PySigner;
     #[pymodule_export]
+    pub use super::types::ArmorKind;
+    #[pymodule_export]
     pub use super::types::DataFormat;
     #[pymodule_export]
     pub use super::types::HashAlgorithm;

src/types.rs

@@ -283,6 +283,31 @@ impl TryFrom<SqTag> for Tag {
     }
 }
 
+/// The type of ASCII armor to use when wrapping OpenPGP data.
+#[pyclass(eq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum ArmorKind {
+    /// "PGP PUBLIC KEY BLOCK"
+    PublicKey,
+    /// "PGP PRIVATE KEY BLOCK"
+    SecretKey,
+    /// "PGP MESSAGE"
+    Message,
+    /// "PGP SIGNATURE"
+    Signature,
+}
+
+impl From<ArmorKind> for sequoia_openpgp::armor::Kind {
+    fn from(kind: ArmorKind) -> Self {
+        match kind {
+            ArmorKind::PublicKey => Self::PublicKey,
+            ArmorKind::SecretKey => Self::SecretKey,
+            ArmorKind::Message => Self::Message,
+            ArmorKind::Signature => Self::Signature,
+        }
+    }
+}
+
 /// The key usage flags from an OpenPGP signature.
 ///
 /// Indicates what operations a key is authorized to perform.