Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

9.3 KB
Raw Blame
use std::collections::HashMap;

use aes_gcm::{
    Aes256Gcm, Nonce,
    aead::{Aead, AeadCore, KeyInit, OsRng, Payload},
};
use aws_sdk_kms::{Client, primitives::Blob, types::DataKeySpec};
use zeroize::Zeroizing;

const ENCRYPTION_VERSION: i16 = 1;
const AES_256_KEY_LENGTH: usize = 32;
const AES_GCM_NONCE_LENGTH: usize = 12;
const AES_GCM_TAG_LENGTH: usize = 16;
const ENCRYPTION_PURPOSE: &str = "microsoft-refresh-token";

pub use crate::domain::microsoft::token::*;

/// AES-256-GCM envelope cipher backed by an external data-key provider.
pub struct EnvelopeMicrosoftTokenCipher<P> {
    data_key_provider: P,
}

impl<P> EnvelopeMicrosoftTokenCipher<P> {
    pub fn new(data_key_provider: P) -> Self {
        Self { data_key_provider }
    }
}

#[async_trait::async_trait]
impl<P> MicrosoftTokenCipher for EnvelopeMicrosoftTokenCipher<P>
where
    P: DataKeyProvider,
{
    async fn encrypt(
        &self,
        fusionauth_user_id: &str,
        email_address: &str,
        refresh_token: MicrosoftRefreshToken,
    ) -> Result<EncryptedMicrosoftToken, MicrosoftTokenCipherError> {
        let identity = EncryptionIdentity::new(fusionauth_user_id, email_address)?;
        let data_key = self
            .data_key_provider
            .generate_data_key(identity.kms_encryption_context())
            .await?;
        validate_plaintext_data_key(&data_key.plaintext)?;

        let cipher = Aes256Gcm::new_from_slice(&data_key.plaintext)
            .map_err(|_| MicrosoftTokenCipherError::InvalidDataKey)?;
        let nonce = Aes256Gcm::generate_nonce(&mut OsRng);
        let ciphertext = cipher
            .encrypt(
                &nonce,
                Payload {
                    msg: refresh_token.as_str().as_bytes(),
                    aad: &identity.aad(),
                },
            )
            .map_err(|_| MicrosoftTokenCipherError::EncryptionFailed)?;

        Ok(EncryptedMicrosoftToken {
            refresh_token_ciphertext: ciphertext,
            encrypted_data_key: data_key.encrypted,
            nonce: nonce.to_vec(),
            encryption_version: ENCRYPTION_VERSION,
            kms_key_id: data_key.key_id,
        })
    }

    async fn decrypt(
        &self,
        fusionauth_user_id: &str,
        email_address: &str,
        envelope: &EncryptedMicrosoftToken,
    ) -> Result<MicrosoftRefreshToken, MicrosoftTokenCipherError> {
        validate_envelope(envelope)?;
        let identity = EncryptionIdentity::new(fusionauth_user_id, email_address)?;
        let plaintext_data_key = self
            .data_key_provider
            .decrypt_data_key(
                &envelope.kms_key_id,
                &envelope.encrypted_data_key,
                identity.kms_encryption_context(),
            )
            .await?;
        validate_plaintext_data_key(&plaintext_data_key)?;

        let cipher = Aes256Gcm::new_from_slice(&plaintext_data_key)
            .map_err(|_| MicrosoftTokenCipherError::InvalidDataKey)?;
        let nonce_bytes: [u8; AES_GCM_NONCE_LENGTH] = envelope
            .nonce
            .as_slice()
            .try_into()
            .map_err(|_| MicrosoftTokenCipherError::MalformedEnvelope)?;
        let nonce = Nonce::from(nonce_bytes);
        let plaintext = cipher
            .decrypt(
                &nonce,
                Payload {
                    msg: &envelope.refresh_token_ciphertext,
                    aad: &identity.aad(),
                },
            )
            .map_err(|_| MicrosoftTokenCipherError::DecryptionFailed)?;
        let mut plaintext = Zeroizing::new(plaintext);
        if std::str::from_utf8(&plaintext).is_err() {
            return Err(MicrosoftTokenCipherError::MalformedPlaintext);
        }

        // UTF-8 was validated above. Moving the allocation into String avoids another plaintext
        // copy, and the returned wrapper zeroizes that allocation on drop.
        let plaintext = String::from_utf8(std::mem::take(&mut *plaintext))
            .map_err(|_| MicrosoftTokenCipherError::MalformedPlaintext)?;
        Ok(MicrosoftRefreshToken::new(plaintext))
    }
}

struct GeneratedDataKey {
    plaintext: Zeroizing<Vec<u8>>,
    encrypted: Vec<u8>,
    key_id: String,
}

#[async_trait::async_trait]
trait DataKeyProvider: Send + Sync {
    async fn generate_data_key(
        &self,
        encryption_context: HashMap<String, String>,
    ) -> Result<GeneratedDataKey, DataKeyProviderError>;

    async fn decrypt_data_key(
        &self,
        key_id: &str,
        encrypted_data_key: &[u8],
        encryption_context: HashMap<String, String>,
    ) -> Result<Zeroizing<Vec<u8>>, DataKeyProviderError>;
}

/// KMS implementation of the envelope data-key provider.
pub struct KmsDataKeyProvider {
    client: Client,
    key_id: String,
}

impl KmsDataKeyProvider {
    pub fn new(client: Client, key_id: String) -> Self {
        Self { client, key_id }
    }
}

#[async_trait::async_trait]
impl DataKeyProvider for KmsDataKeyProvider {
    async fn generate_data_key(
        &self,
        encryption_context: HashMap<String, String>,
    ) -> Result<GeneratedDataKey, DataKeyProviderError> {
        let output = self
            .client
            .generate_data_key()
            .key_id(&self.key_id)
            .key_spec(DataKeySpec::Aes256)
            .set_encryption_context(Some(encryption_context))
            .send()
            .await
            .map_err(|_| DataKeyProviderError::GenerateFailed)?;

        let plaintext = output
            .plaintext()
            .map(|value| Zeroizing::new(value.as_ref().to_vec()))
            .ok_or(DataKeyProviderError::MalformedResponse)?;
        let encrypted = output
            .ciphertext_blob()
            .map(|value| value.as_ref().to_vec())
            .ok_or(DataKeyProviderError::MalformedResponse)?;
        let key_id = output
            .key_id()
            .filter(|value| !value.trim().is_empty())
            .map(str::to_owned)
            .ok_or(DataKeyProviderError::MalformedResponse)?;

        Ok(GeneratedDataKey {
            plaintext,
            encrypted,
            key_id,
        })
    }

    async fn decrypt_data_key(
        &self,
        key_id: &str,
        encrypted_data_key: &[u8],
        encryption_context: HashMap<String, String>,
    ) -> Result<Zeroizing<Vec<u8>>, DataKeyProviderError> {
        let output = self
            .client
            .decrypt()
            .key_id(key_id)
            .ciphertext_blob(Blob::new(encrypted_data_key))
            .set_encryption_context(Some(encryption_context))
            .send()
            .await
            .map_err(|_| DataKeyProviderError::DecryptFailed)?;

        output
            .plaintext()
            .map(|value| Zeroizing::new(value.as_ref().to_vec()))
            .ok_or(DataKeyProviderError::MalformedResponse)
    }
}

struct EncryptionIdentity {
    fusionauth_user_id: String,
    email_address: String,
}

impl EncryptionIdentity {
    fn new(
        fusionauth_user_id: &str,
        email_address: &str,
    ) -> Result<Self, MicrosoftTokenCipherError> {
        let fusionauth_user_id = fusionauth_user_id.trim().to_ascii_lowercase();
        let email_address = email_validator::normalize_email(email_address)
            .map(|email| email.into_owned())
            .ok_or(MicrosoftTokenCipherError::MalformedIdentity)?;
        if fusionauth_user_id.is_empty() || fusionauth_user_id.contains('\0') {
            return Err(MicrosoftTokenCipherError::MalformedIdentity);
        }

        Ok(Self {
            fusionauth_user_id,
            email_address,
        })
    }

    fn aad(&self) -> Vec<u8> {
        let mut aad = ENCRYPTION_PURPOSE.as_bytes().to_vec();
        append_length_prefixed(&mut aad, &ENCRYPTION_VERSION.to_be_bytes());
        append_length_prefixed(&mut aad, self.fusionauth_user_id.as_bytes());
        append_length_prefixed(&mut aad, self.email_address.as_bytes());
        aad
    }

    fn kms_encryption_context(&self) -> HashMap<String, String> {
        HashMap::from([
            ("macro:purpose".to_owned(), ENCRYPTION_PURPOSE.to_owned()),
            (
                "macro:encryption-version".to_owned(),
                ENCRYPTION_VERSION.to_string(),
            ),
            (
                "macro:fusionauth-user-id".to_owned(),
                self.fusionauth_user_id.clone(),
            ),
            (
                "macro:microsoft-mailbox".to_owned(),
                self.email_address.clone(),
            ),
        ])
    }
}

fn append_length_prefixed(output: &mut Vec<u8>, value: &[u8]) {
    output.extend_from_slice(&(value.len() as u64).to_be_bytes());
    output.extend_from_slice(value);
}

fn validate_plaintext_data_key(data_key: &[u8]) -> Result<(), MicrosoftTokenCipherError> {
    if data_key.len() != AES_256_KEY_LENGTH {
        return Err(MicrosoftTokenCipherError::InvalidDataKey);
    }
    Ok(())
}

fn validate_envelope(envelope: &EncryptedMicrosoftToken) -> Result<(), MicrosoftTokenCipherError> {
    if envelope.encryption_version != ENCRYPTION_VERSION {
        return Err(MicrosoftTokenCipherError::UnsupportedVersion(
            envelope.encryption_version,
        ));
    }
    if envelope.nonce.len() != AES_GCM_NONCE_LENGTH
        || envelope.refresh_token_ciphertext.len() < AES_GCM_TAG_LENGTH
        || envelope.encrypted_data_key.is_empty()
        || envelope.kms_key_id.trim().is_empty()
    {
        return Err(MicrosoftTokenCipherError::MalformedEnvelope);
    }
    Ok(())
}

#[cfg(test)]
mod test;