税理士・社労士・司法書士・弁護士事務所向け：
顧問先のマイナンバー・財務・労務データを守るSCS★3水準のセキュリティ設計

#![forbid(unsafe_code)]

use std::collections::BTreeSet;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StaffSessionContext {
    pub staff_id: u32,
    pub fido2_verified: bool,
    pub mynumber_handler_authorized: bool,
    pub assigned_client_ids: BTreeSet<u64>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SealedClientRecord {
    pub client_id: u64,
    pub record_id: u64,
    pub aad_context_tag: [u8; 32],
    pub ciphertext_payload: Vec<u8>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProfVaultError {
    Fido2MfaRequired,
    MyNumberClearanceMissing,
    ClientTenantNotAssigned { client_id: u64 },
    AadContextMismatchTransplantDetected,
    InvalidMyNumberLength,
    InvalidMyNumberCheckDigit,
}

/// Computes a deterministic 32-byte Additional Authenticated Data (AAD) binding tag
/// over (firm_domain_sep, client_id, record_id) to prevent cross-client ciphertext transplanting.
pub fn compute_tenant_aad_binding(client_id: u64, record_id: u64) -> [u8; 32] {
    let mut out = [0u8; 32];
    let domain = b"OK-SCS★3-PROF-TENANT-AAD-V1::";
    out[..16].copy_from_slice(&domain[..16]);
    out[16..24].copy_from_slice(&client_id.to_be_bytes());
    out[24..32].copy_from_slice(&record_id.to_be_bytes());
    out
}

/// Verifies the official 12-digit Japanese Individual Number (MyNumber) Modulo-11 check digit
/// defined by Ministry of Internal Affairs and Communications Order No. 85.
pub fn verify_mynumber_check_digit(digits_ascii: &[u8]) -> Result<(), ProfVaultError> {
    if digits_ascii.len() != 12 || !digits_ascii.iter().all(|b| b.is_ascii_digit()) {
        return Err(ProfVaultError::InvalidMyNumberLength);
    }

    let mut sum: u32 = 0;
    // Let n = 1..=11 from least significant payload digit (index 10 down to 0)
    for n in 1..=11usize {
        let p_n = u32::from(digits_ascii[11 - n] - b'0');
        let q_n = if n <= 6 { (n + 1) as u32 } else { (n - 5) as u32 };
        sum += p_n * q_n;
    }

    let remainder = sum % 11;
    let expected_check = if remainder <= 1 { 0 } else { 11 - remainder };
    let actual_check = u32::from(digits_ascii[11] - b'0');

    if actual_check != expected_check {
        return Err(ProfVaultError::InvalidMyNumberCheckDigit);
    }
    Ok(())
}

/// Enforces FIDO2 MFA, MyNumber handler clearance, per-client RLS assignment,
/// and constant-time AAD context binding before unsealing a client's sensitive record.
pub fn authorize_and_verify_client_record_access(
    ctx: &StaffSessionContext,
    record: &SealedClientRecord,
    target_client_id: u64,
    target_record_id: u64,
) -> Result<(), ProfVaultError> {
    if !ctx.fido2_verified {
        return Err(ProfVaultError::Fido2MfaRequired);
    }
    if !ctx.mynumber_handler_authorized {
        return Err(ProfVaultError::MyNumberClearanceMissing);
    }
    if !ctx.assigned_client_ids.contains(&target_client_id) {
        return Err(ProfVaultError::ClientTenantNotAssigned {
            client_id: target_client_id,
        });
    }

    let expected_aad = compute_tenant_aad_binding(target_client_id, target_record_id);
    let mut diff: u8 = 0;
    for (a, b) in record.aad_context_tag.iter().zip(expected_aad.iter()) {
        diff |= a ^ b;
    }
    if diff != 0 || record.client_id != target_client_id || record.record_id != target_record_id {
        return Err(ProfVaultError::AadContextMismatchTransplantDetected);
    }

    Ok(())
}