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.7 KB
Raw Blame
use super::*;

const SECRET: &str = "a distinct account-link state test secret";
const NOW: i64 = 1_730_000_000;

fn key() -> AccountLinkStateKey {
    AccountLinkStateKey::new(SECRET).unwrap()
}

fn link_id() -> Uuid {
    Uuid::parse_str("0192b8a0-6a2e-7c3e-9b1f-4d5e6f708192").unwrap()
}

fn fusion_user_id() -> Uuid {
    Uuid::parse_str("8c06ab3e-693c-45a7-8f92-1b5a5bf876ac").unwrap()
}

fn state(original_url: Option<&str>, exp: i64) -> AccountLinkState {
    AccountLinkState {
        provider: LinkProvider::Google,
        identity_provider_id: "google-gmail-idp".into(),
        link_id: link_id(),
        fusion_user_id: fusion_user_id(),
        original_url: original_url.map(str::to_owned),
        exp,
    }
}

fn sign_raw_payload(payload: &[u8]) -> String {
    let encoded_payload = URL_SAFE_NO_PAD.encode(payload);
    let signature = signature_for(encoded_payload.as_bytes(), &key());
    format!("{encoded_payload}.{}", URL_SAFE_NO_PAD.encode(signature))
}

fn payload_json(token: &str) -> String {
    let encoded_payload = token.split_once('.').unwrap().0;
    String::from_utf8(URL_SAFE_NO_PAD.decode(encoded_payload).unwrap()).unwrap()
}

#[test]
fn payload_round_trips_deterministically() {
    let payload = state(
        Some("https://macro.com/app/inbox-link-callback"),
        NOW + 3_600,
    );

    let first_token = sign_account_link_state(&payload, &key()).unwrap();
    let second_token = sign_account_link_state(&payload, &key()).unwrap();

    assert_eq!(first_token, second_token);
    assert!(!first_token.contains('='));
    assert_eq!(
        verify_signed_state(&first_token, &key(), NOW),
        Ok(SignedState::AccountLink(payload))
    );
}

#[test]
fn payload_without_original_url_omits_the_field() {
    let payload = state(None, NOW + 3_600);
    let token = sign_account_link_state(&payload, &key()).unwrap();

    assert!(!payload_json(&token).contains("original_url"));
    assert_eq!(
        verify_signed_state(&token, &key(), NOW),
        Ok(SignedState::AccountLink(payload))
    );
}

#[test]
fn provider_serializes_as_the_callback_path_segment() {
    for (provider, segment) in [
        (LinkProvider::Google, "google"),
        (LinkProvider::Github, "github"),
        (LinkProvider::Microsoft, "microsoft"),
    ] {
        assert_eq!(provider.as_str(), segment);
        assert_eq!(provider.to_string(), segment);
        assert_eq!(
            serde_json::to_string(&provider).unwrap(),
            format!("\"{segment}\"")
        );
    }
}

#[test]
fn new_state_expires_one_ttl_from_now() {
    let before = chrono::Utc::now().timestamp();
    let state = AccountLinkState::new(
        LinkProvider::Github,
        "github-idp".into(),
        link_id(),
        fusion_user_id(),
        None,
    );
    let after = chrono::Utc::now().timestamp();
    let ttl = ACCOUNT_LINK_STATE_TTL.num_seconds();

    assert!(state.exp >= before + ttl);
    assert!(state.exp <= after + ttl);
    assert!(
        verify_signed_state(
            &sign_account_link_state(&state, &key()).unwrap(),
            &key(),
            after
        )
        .is_ok()
    );
}

#[test]
fn expiration_boundary_is_enforced_and_names_the_pending_link() {
    let token = sign_account_link_state(&state(None, NOW), &key()).unwrap();

    assert_eq!(
        verify_signed_state(&token, &key(), NOW - 1),
        Ok(SignedState::AccountLink(state(None, NOW)))
    );
    for current_timestamp in [NOW, NOW + 1] {
        assert_eq!(
            verify_signed_state(&token, &key(), current_timestamp),
            Err(AccountLinkStateError::Expired { link_id: link_id() })
        );
    }
}

#[test]
fn malformed_tokens_are_rejected() {
    for token in [
        "",
        "payload",
        ".signature",
        "payload.",
        "payload.signature.extra",
        "%%%.signature",
        "payload.%%%",
        r#"{"identity_provider_id":"idp","link_id":"0192b8a0-6a2e-7c3e-9b1f-4d5e6f708192"}"#,
    ] {
        assert!(
            verify_signed_state(token, &key(), NOW).is_err(),
            "token should be rejected: {token}"
        );
    }

    let malformed_json = sign_raw_payload(b"not json");
    assert_eq!(
        verify_signed_state(&malformed_json, &key(), NOW),
        Err(AccountLinkStateError::Malformed)
    );
}

#[test]
fn authentic_payloads_with_bad_fields_are_rejected() {
    let base = serde_json::json!({
        "provider": "google",
        "identity_provider_id": "google-gmail-idp",
        "link_id": link_id(),
        "fusion_user_id": fusion_user_id(),
        "exp": NOW + 3_600,
    });

    for (field, value) in [
        ("provider", serde_json::json!("apple")),
        ("link_id", serde_json::json!("not-a-uuid")),
        ("fusion_user_id", serde_json::json!("not-a-uuid")),
        ("exp", serde_json::json!("soon")),
    ] {
        let mut payload = base.clone();
        payload[field] = value;
        let token = sign_raw_payload(&serde_json::to_vec(&payload).unwrap());
        assert_eq!(
            verify_signed_state(&token, &key(), NOW),
            Err(AccountLinkStateError::Malformed),
            "{field} should be validated"
        );
    }

    for field in ["provider", "link_id", "fusion_user_id", "exp"] {
        let mut payload = base.clone();
        payload.as_object_mut().unwrap().remove(field);
        let token = sign_raw_payload(&serde_json::to_vec(&payload).unwrap());
        assert_eq!(
            verify_signed_state(&token, &key(), NOW),
            Err(AccountLinkStateError::Malformed),
            "{field} should be required"
        );
    }
}

#[test]
fn payload_tampering_is_rejected() {
    let token = sign_account_link_state(&state(None, NOW + 3_600), &key()).unwrap();
    let (encoded_payload, encoded_signature) = token.split_once('.').unwrap();
    let mut json: serde_json::Value =
        serde_json::from_slice(&URL_SAFE_NO_PAD.decode(encoded_payload).unwrap()).unwrap();

    for (field, value) in [
        ("link_id", serde_json::json!(Uuid::now_v7())),
        ("fusion_user_id", serde_json::json!(Uuid::now_v7())),
        (
            "original_url",
            serde_json::json!("https://evil.example.com/"),
        ),
        ("provider", serde_json::json!("github")),
        ("exp", serde_json::json!(NOW + 7_200)),
    ] {
        json[field] = value;
        let tampered_payload = URL_SAFE_NO_PAD.encode(serde_json::to_vec(&json).unwrap());
        let tampered_token = format!("{tampered_payload}.{encoded_signature}");

        assert_eq!(
            verify_signed_state(&tampered_token, &key(), NOW),
            Err(AccountLinkStateError::InvalidSignature),
            "changing {field} should invalidate the signature"
        );
    }
}

#[test]
fn signature_tampering_and_wrong_keys_are_rejected() {
    let token = sign_account_link_state(&state(None, NOW + 3_600), &key()).unwrap();
    let (encoded_payload, encoded_signature) = token.split_once('.').unwrap();
    let mut signature = URL_SAFE_NO_PAD.decode(encoded_signature).unwrap();
    signature[0] ^= 1;
    let tampered_token = format!("{encoded_payload}.{}", URL_SAFE_NO_PAD.encode(signature));
    let other_key = AccountLinkStateKey::new("another secret that is also long enough").unwrap();

    assert_eq!(
        verify_signed_state(&tampered_token, &key(), NOW),
        Err(AccountLinkStateError::InvalidSignature)
    );
    assert_eq!(
        verify_signed_state(&token, &other_key, NOW),
        Err(AccountLinkStateError::InvalidSignature)
    );
}

fn admin_consent_state() -> AdminConsentState {
    AdminConsentState {
        kind: AdminConsentKind::AdminConsent,
        provider: LinkProvider::Microsoft,
        original_url: "https://macro.com/app/inbox-link-callback".into(),
    }
}

#[test]
fn admin_consent_state_round_trips_and_never_expires() {
    let token = sign_admin_consent_state(&admin_consent_state(), &key()).unwrap();

    let json: serde_json::Value = serde_json::from_str(&payload_json(&token)).unwrap();
    assert_eq!(json["kind"], "admin_consent");
    assert_eq!(json["provider"], "microsoft");
    assert!(json.get("exp").is_none());
    for current_timestamp in [NOW, NOW + 365 * 24 * 3_600] {
        assert_eq!(
            verify_signed_state(&token, &key(), current_timestamp),
            Ok(SignedState::AdminConsent(admin_consent_state()))
        );
    }
}

#[test]
fn signed_kinds_cannot_be_confused() {
    // An admin-consent payload without its tag is neither kind.
    let untagged = serde_json::json!({
        "provider": "microsoft",
        "original_url": "https://macro.com/app/inbox-link-callback",
    });
    let token = sign_raw_payload(&serde_json::to_vec(&untagged).unwrap());
    assert_eq!(
        verify_signed_state(&token, &key(), NOW),
        Err(AccountLinkStateError::Malformed)
    );

    let mut mistagged = serde_json::to_value(admin_consent_state()).unwrap();
    mistagged["kind"] = serde_json::json!("link");
    let token = sign_raw_payload(&serde_json::to_vec(&mistagged).unwrap());
    assert_eq!(
        verify_signed_state(&token, &key(), NOW),
        Err(AccountLinkStateError::Malformed)
    );
}

#[test]
fn keys_must_be_at_least_32_bytes() {
    for secret in ["", "   ", "short", &"x".repeat(MIN_SECRET_LENGTH - 1)] {
        let error = AccountLinkStateKey::new(secret).expect_err("short keys are rejected");
        assert!(error.to_string().contains("ACCOUNT_LINK_STATE_SECRET"));
        assert!(!error.to_string().contains(secret.trim()) || secret.trim().is_empty());
    }

    assert!(AccountLinkStateKey::new(&"x".repeat(MIN_SECRET_LENGTH)).is_ok());
    assert!(AccountLinkStateKey::new(&format!("  {}  ", "x".repeat(MIN_SECRET_LENGTH))).is_ok());
}

#[test]
fn key_debug_output_redacts_the_secret() {
    let debug = format!("{:?}", key());

    assert!(!debug.contains(SECRET));
    assert!(debug.contains("redacted"));
}