pyrus_crypto/message/

parser.rs

use std::sync::Arc;

use zeroize::Zeroizing;

use crate::cert::Cert;
use crate::crypto;
use crate::error::{CryptoError, Result};

use super::{header::*, Message, MessageDesc};

/// Parses a message.
///
/// This struct implements something akin to the state pattern by using 
/// enums and internal variables.
///
/// # Examples
///
/// Typical call chain used to decrypt a message.
/// ```rust
/// # use std::error::Error;
/// use pyrus_crypto::prelude::*;
/// # use std::sync::Arc;
///
/// # fn main() -> Result<(), Box<dyn Error>> {
/// # let larry = Arc::new(Cert::new("Larry <larry@gentoo.org>"));
/// # let agentcow = Arc::new(Cert::new("agentcow"));
/// # let agenthorse = Arc::new(Cert::new("agenthorse"));
/// # let friends = vec![agentcow.clone(), agenthorse.clone()];
///
/// let secret_text = b"Hello there.";
/// # let message = Message::new(&larry)?
/// #     .write(&secret_text[..])?
/// #     .sign()
/// #     .encrypt_for(&friends)?
/// #     .finalize()?;
/// let (message, content, signature) = message
///     .parse(&agentcow)? // recieve the message as agentcow
///     .decrypt(larry.clone())? // asymmetrically decrypt from larry
///     .verify_signature(larry.clone())? // verify the signature from larry
///     .finalize(); // finish parsing, return the results as a tuple
///                  // (<original message>, <decrypted content>, Option<signature>)
///
/// assert_eq!(&secret_text[..], &content[..]);
/// assert!(signature.is_some()); // signature is Some
/// assert!(signature.unwrap()); // signature is good
/// # Ok(())
/// # }
/// ```
///
/// Decrypting a symmetric message.
/// ```rust
/// # use std::error::Error;
/// use pyrus_crypto::prelude::*;
///
/// # fn main() -> Result<(), Box<dyn Error>> {
/// # let larry: Cert = Cert::new("Larry <larry@gentoo.org>");
/// let secret_text = b"This is a very secret message";
/// # let message = Message::new(&larry)?
/// #     .write(&secret_text[..])?
/// #     .encrypt_with(b"password123")? // don't use such passwords
/// #     .finalize()?;
/// // another of the aforementioned shortcomings
/// # let dummy = Cert::new("dummy cert");
/// // assume we already have a message
/// let (_, content, sig) = message
///     .parse(&dummy)? // a dummy certificate is needed
///     .decrypt_with(&b"password123"[..])?
///     .finalize();
///
/// assert_eq!(&secret_text[..], &content[..]);
/// assert!(sig.is_none()); // the message is not signed
/// # Ok(())
/// # }
pub struct MessageParser<'a> {
    pub(super) recipient: &'a Cert,
    pub(super) desc: MessageDesc,
    pub(super) message: Message,
    pub(super) payload: Vec<u8>,
    pub(super) verified: Option<bool>,
}

impl<'a> MessageParser<'a> {
    /// Decrypts an asymmetrically encrypted message using `issuer`'s public 
    /// key and a private certificate supplied to [`Message::parse`].
    ///
    /// # Errors
    /// * [`CryptoError::NotARecipient`] if the private certificate holder is 
    /// not a recipient,
    /// * [`CryptoError::NotType`] if the message cannot be asymmetrically 
    /// decrypted,
    /// * [`CryptoError::UnauthenticCipher`] if the message's AAD cannot be 
    /// verified,
    /// * [`CryptoError::InsufficientMemory`],
    /// * [`CryptoError::SerializationError`].
    pub fn decrypt(mut self, issuer: Arc<Cert>) -> Result<Self> {
        let (key, nonce) = match self.message.header.msg_type {
            MessageType::EncryptedAsm {
                ref keys,
                ref nonce,
            }
            | MessageType::SignedEncryptedAsm {
                ref keys,
                ref nonce,
                ..
            } => {
                let nonce = nonce.into();
                let fpr = self.recipient.fingerprint();
                let key = if let Some(k) = keys.get(fpr) {
                    let shared_secret = self
                        .recipient
                        .encryption_secret()
                        .unwrap()
                        .diffie_hellman(issuer.encryption_public());
                    let k = crypto::decrypt_key(&k, nonce, &shared_secret)?;
                    vec_to_key(k.to_vec())?
                } else {
                    return Err(CryptoError::NotARecipient(*self.recipient.fingerprint()));
                };
                (key, nonce)
            }
            _ => return Err(CryptoError::NotType(MessageDesc::EncryptedAsm)),
        };
        let aad = self.message.header.as_bytes()?;
        self.payload = crypto::decrypt_symmetric(&key, nonce, &self.message.payload, &aad)?;
        self.desc = match self.desc {
            MessageDesc::EncryptedAsm => MessageDesc::Plaintext,
            MessageDesc::SignedEncryptedAsm => MessageDesc::Signed,
            _ => unreachable!(),
        };
        Ok(self)
    }

    /// Decrypts a symmetrically encrypted message using a `passphrase`.
    ///
    /// # Errors
    /// * [`CryptoError::NotType`] if the message cannot be symmetrically 
    /// decrypted,
    /// * [`CryptoError::UnauthenticCipher`] if the message's AAD cannot be 
    /// verified,
    /// * [`CryptoError::InsufficientMemory`],
    /// * [`CryptoError::SerializationError`].
    pub fn decrypt_with(mut self, passphrase: impl AsRef<[u8]>) -> Result<Self> {
        let (salt, nonce) = match self.message.header.msg_type {
            MessageType::EncryptedSym {
                ref salt,
                ref nonce,
            }
            | MessageType::SignedEncryptedSym {
                ref salt,
                ref nonce,
                ..
            } => (salt, nonce),
            _ => return Err(CryptoError::NotType(MessageDesc::EncryptedSym)),
        };
        let key = crypto::derive_key(passphrase.as_ref(), &salt[..])?;
        let aad = self.message.header.as_bytes()?;
        self.payload = crypto::decrypt_symmetric(&key, nonce.into(), &self.message.payload, &aad)?;
        self.desc = match self.desc {
            MessageDesc::EncryptedSym => MessageDesc::Plaintext,
            MessageDesc::SignedEncryptedSym => MessageDesc::Signed,
            _ => unreachable!(),
        };

        Ok(self)
    }

    /// Verifies the signed message using `issuer`'s public key.
    ///
    /// # Errors
    /// * [`CryptoError::NotType`] if the message was not signed,
    /// * [`CryptoError::NotDecrypted`] if the message is signed, but is not 
    /// decrypted.
    pub fn verify_signature(mut self, issuer: Arc<Cert>) -> Result<Self> {
        let signature = match self.message.header.msg_type {
            MessageType::Signed { ref signature } => {
                self.payload = self.message.payload.clone();
                signature
            }
            MessageType::SignedEncryptedSym { ref signature, .. }
            | MessageType::SignedEncryptedAsm { ref signature, .. } => signature,
            _ => return Err(CryptoError::NotType(MessageDesc::Signed)),
        };
        match self.desc {
            MessageDesc::Signed => {
                self.verified = Some(crypto::verify_signature(
                    issuer.signing_public(),
                    &self.payload,
                    signature,
                ));
                Ok(self)
            }
            MessageDesc::Plaintext => Err(CryptoError::NotType(MessageDesc::Signed)),
            _ => Err(CryptoError::NotDecrypted),
        }
    }

    /// Finishes the process of parsing the message. Returns a tuple of the 
    /// form: `(<original message>, <decrypted content>, Option<signature>)`.
    /// * `original message` is the message which was moved into the parser, 
    /// its ownership is now moved back,
    /// * `decrypted content` the plaintext content of the message. If the 
    /// message was not encrypted, it will be the plaintext content which was 
    /// signed.
    /// * `Option<signature>`:
    ///     - `Some(signature)` - `signature` is true if the signature is ok, 
    ///     false otherwise,
    ///     - `None` - the message was not signed or signature verification 
    ///     was not attempted.
    pub fn finalize(self) -> (Message, Vec<u8>, Option<bool>) {
        (self.message, self.payload, self.verified)
    }
}

fn vec_to_key(v: Vec<u8>) -> Result<Zeroizing<[u8; 32]>> {
    if v.len() != 32 {
        return Err(CryptoError::Unknown);
    }

    let k: [u8; 32] = v.try_into().map_err(|_| CryptoError::Unknown)?;
    Ok(Zeroizing::new(k))
}