Data Protection

/// <summary>
/// Extracts tenant_id from JWT claims and sets it in IDataScopeService.
/// All subsequent DB queries are automatically scoped to this tenant.
/// </summary>
public class TenantContextMiddleware
{
    public async Task InvokeAsync(HttpContext context, IDataScopeService dataScopeService)
    {
        if (context.User.Identity?.IsAuthenticated == true)
        {
            var tenantClaim = context.User.FindFirst("tenant_id");
            if (tenantClaim != null && Guid.TryParse(tenantClaim.Value, out var tenantId))
            {
                dataScopeService.SetCurrentTenant(tenantId);
            }
        }

        await _next(context);
    }
}

public class DataScopeService : IDataScopeService
{
    private Guid? _currentTenantId;

    public Guid? CurrentTenantId => _currentTenantId;

    public void SetCurrentTenant(Guid tenantId)
        => _currentTenantId = tenantId;

    // Used by EF Core global query filter
    public Expression<Func<T, bool>> GetTenantFilter<T>()
        where T : ITenantAwareEntity
    {
        var tenantId = _currentTenantId
            ?? throw new UnauthorizedAccessException("No tenant context");
        return entity => entity.TenantId == tenantId;
    }
}

/// <summary>
/// AES-GCM authenticated encryption service for IDs.
/// Encrypts Guid and int IDs to URL-safe base64 strings.
///
/// Uses AES-GCM (Galois/Counter Mode) which provides both confidentiality
/// and integrity — immune to padding oracle attacks unlike AES-CBC.
///
/// Wire format: [Nonce 12B][Tag 16B][Ciphertext]
/// </summary>
public sealed class IdEncryptionService : IIdEncryptionService
{
    private const int NonceSize = 12; // AES-GCM standard nonce size
    private const int TagSize = 16;   // AES-GCM standard tag size
    private readonly byte[] _key;     // 32-byte key derived from config

    public IdEncryptionService(IOptions<IdEncryptionOptions> options, IHostEnvironment? environment = null)
    {
        var keyString = options.Value.Key;
        var minLength = options.Value.MinimumKeyLength; // Min 32 chars
        
        // Startup safety checks - fail-closed model
        if (string.IsNullOrWhiteSpace(keyString) || keyString.Length < minLength)
            throw new InvalidOperationException("Key is missing or too weak.");

        // Rejects placeholder keys ("change-this") in Production environments
        if (options.Value.RejectPlaceholderKeysInProduction && environment?.IsProduction() == true && IsPlaceholder(keyString))
            throw new InvalidOperationException("Do not use placeholders in production!");

        _key = Encoding.UTF8.GetBytes(keyString[..32]);
    }

    public string Encrypt(Guid id)
    {
        var plainBytes = id.ToByteArray();
        var nonce = new byte[NonceSize];
        RandomNumberGenerator.Fill(nonce);

        var ciphertext = new byte[plainBytes.Length];
        var tag = new byte[TagSize];

        using var aesGcm = new AesGcm(_key, TagSize);
        aesGcm.Encrypt(nonce, plainBytes, ciphertext, tag);

        // Combined wire format: [nonce][tag][ciphertext]
        var combined = new byte[NonceSize + TagSize + ciphertext.Length];
        Buffer.BlockCopy(nonce, 0, combined, 0, NonceSize);
        Buffer.BlockCopy(tag, 0, combined, NonceSize, TagSize);
        Buffer.BlockCopy(ciphertext, 0, combined, NonceSize + TagSize, ciphertext.Length);

        return Convert.ToBase64String(combined).Replace('+', '-').Replace('/', '_').TrimEnd('=');
    }

    public Guid Decrypt(string encryptedId)
    {
        var combined = Convert.FromBase64String(encryptedId.Replace('-', '+').Replace('_', '/') + GetPadding(encryptedId));
        if (combined.Length < NonceSize + TagSize)
            throw new CryptographicException("Ciphertext is too short.");

        var nonce = new byte[NonceSize];
        var tag = new byte[TagSize];
        var ciphertext = new byte[combined.Length - NonceSize - TagSize];

        Buffer.BlockCopy(combined, 0, nonce, 0, NonceSize);
        Buffer.BlockCopy(combined, NonceSize, tag, 0, TagSize);
        Buffer.BlockCopy(combined, NonceSize + TagSize, ciphertext, 0, ciphertext.Length);

        var plaintext = new byte[ciphertext.Length];
        using var aesGcm = new AesGcm(_key, TagSize);
        aesGcm.Decrypt(nonce, ciphertext, tag, plaintext);

        return new Guid(plaintext);
    }
}

/// <summary>
/// ASP.NET Core authorization filter that checks if the current user's role
/// has permission to view specific fields in the response.
/// Fields are configured per-role in the RolePermission entity.
/// </summary>
public class RestrictedFieldsAuthorizationFilter : IAsyncAuthorizationFilter
{
    public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
    {
        var roleId = context.HttpContext.User.FindFirst("role_id")?.Value;
        if (roleId is null) return;

        var restrictedFields = await _rolePermRepo
            .GetRestrictedFieldsAsync(Guid.Parse(roleId));

        if (restrictedFields.Any())
        {
            // Store in HttpContext.Items for response serializer
            context.HttpContext.Items["RestrictedFields"] = restrictedFields;
        }
    }
}

// In response serialization:
// Fields listed in RestrictedFields are replaced with "***" or omitted

public class TenantGuardianService : ITenantGuardianService
{
    /// <summary>
    /// Validates that a tenant operation doesn't violate hierarchy rules:
    /// - Cannot create circular parent references
    /// - Cannot delete a tenant with active children
    /// - Cannot move a tenant under its own descendant
    /// </summary>
    public async Task<Result> ValidateHierarchy(
        Guid tenantId, Guid? newParentId, CancellationToken ct)
    {
        if (newParentId is null) return Result.Success();

        // Check for circular reference
        var ancestors = await GetAllAncestorsAsync(newParentId.Value, ct);
        if (ancestors.Contains(tenantId))
            return Result.Failure(new AppError(
                "Tenant.CircularReference",
                "Cannot set a descendant as parent — circular reference"
            ));

        return Result.Success();
    }
}