Add file validation utility (#4)

- Implement MIME type validation using python-magic
- Add file size limit enforcement (50MB max)
- Create FileValidationError for validation failures
- Add comprehensive unit tests with fixtures
- Use centralized logger for validation events

Security features:
- Validates actual file content, not just extension
- Prevents renamed malicious files (.exe -> .jpg)
- Enforces memory-safe size limits

Closes #4

backend/core/logger.py

@@ -1,36 +1,24 @@
 """
 Centralized logging configuration.
-Why: Consistent log format, easy to change output (file vs console).
 """
 import logging
 import sys
 from backend.core.config import settings
 
+
 def setup_logger(name: str) -> logging.Logger:
-    """
-    Create a logger with consistent formatting.
-    
-    Args:
-        name: Logger name (usually __name__ of the module)
-    
-    Returns:
-        Configured logger instance
-    """
+    """Create logger with consistent formatting."""
     logger = logging.getLogger(name)
     
-    # Set level based on DEBUG mode
     level = logging.DEBUG if settings.DEBUG else logging.INFO
     logger.setLevel(level)
     
-    # Prevent duplicate handlers if already configured
     if logger.handlers:
         return logger
     
-    # Console handler
     handler = logging.StreamHandler(sys.stdout)
     handler.setLevel(level)
     
-    # Format: timestamp - logger_name - level - message
     formatter = logging.Formatter(
         '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
         datefmt='%Y-%m-%d %H:%M:%S'

backend/tests/test_validators.py

@@ -0,0 +1,47 @@
+"""
+Tests for file validation utilities.
+"""
+import pytest
+from backend.utils.validators import (
+    validate_file_type,
+    validate_file_size,
+    validate_file,
+    FileValidationError
+)
+
+
+def test_validate_file_type_valid_png(sample_image_bytes):
+    mime_type, extension = validate_file_type(sample_image_bytes, "test.png")
+    assert mime_type == "image/png"
+    assert extension == "png"
+
+
+def test_validate_file_type_invalid():
+    fake_image = b"This is not an image"
+
+    with pytest.raises(FileValidationError):
+        validate_file_type(fake_image, "fake.jpg")
+
+
+def test_validate_file_size_within_limit(sample_image_bytes):
+    size = validate_file_size(sample_image_bytes, "small.png")
+    assert size == len(sample_image_bytes)
+
+
+def test_validate_file_size_exceeds_limit():
+    large_file = b"x" * (60 * 1024 * 1024)
+
+    with pytest.raises(FileValidationError):
+        validate_file_size(large_file, "huge.bin")
+
+
+def test_validate_file_complete(sample_image_bytes):
+    result = validate_file(sample_image_bytes, "test.png")
+
+    assert result["valid"] is True
+    assert result["mime_type"] == "image/png"
+    assert result["extension"] == "png"
+    assert result["size_bytes"] > 0
+    assert result["size_mb"] < 0.01
+    assert result["filename"] == "test.png"
+

backend/utils/validators.py

@@ -0,0 +1,128 @@
+"""
+File validation utilities for secure file processing.
+Why: Prevent malicious files, enforce size limits, validate MIME types.
+"""
+import magic
+from typing import Tuple, Optional
+from backend.core.config import settings
+from backend.core.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class FileValidationError(Exception):
+    """Custom exception for file validation failures."""
+    pass
+
+
+def validate_file_type(file_bytes: bytes, filename: str) -> Tuple[str, str]:
+    """
+    Validate file MIME type using python-magic (reads file signature).
+    
+    Why python-magic? 
+    - Reads actual file headers, not just extension
+    - Prevents .exe renamed to .jpg attacks
+    
+    Args:
+        file_bytes: Raw file content
+        filename: Original filename (for extension check)
+        
+    Returns:
+        Tuple of (mime_type, file_extension)
+        
+    Raises:
+        FileValidationError: If file type not allowed
+    """
+    # Get MIME type from file content (not extension)
+    mime = magic.Magic(mime=True)
+    detected_mime = mime.from_buffer(file_bytes)
+    
+    logger.info(f"File '{filename}' detected as {detected_mime}")
+    
+    # Combine all allowed types
+    allowed_types = (
+        settings.ALLOWED_IMAGE_TYPES +
+        settings.ALLOWED_VIDEO_TYPES +
+        settings.ALLOWED_DOC_TYPES
+    )
+    
+    if detected_mime not in allowed_types:
+        raise FileValidationError(
+            f"File type '{detected_mime}' not allowed. "
+            f"Allowed: {', '.join(allowed_types)}"
+        )
+    
+    # Extract extension
+    extension = filename.rsplit('.', 1)[-1].lower() if '.' in filename else ''
+    
+    return detected_mime, extension
+
+
+def validate_file_size(file_bytes: bytes, filename: str) -> int:
+    """
+    Validate file size against limit.
+    
+    Why size limits?
+    - Prevent DoS attacks (100GB upload)
+    - Memory constraints (in-memory processing)
+    - Reasonable for forensic analysis
+    
+    Args:
+        file_bytes: Raw file content
+        filename: Original filename (for logging)
+        
+    Returns:
+        File size in bytes
+        
+    Raises:
+        FileValidationError: If file exceeds limit
+    """
+    size_bytes = len(file_bytes)
+    size_mb = size_bytes / (1024 * 1024)
+    max_size_mb = settings.MAX_FILE_SIZE_MB
+    
+    logger.info(f"File '{filename}' size: {size_mb:.2f} MB")
+    
+    if size_mb > max_size_mb:
+        raise FileValidationError(
+            f"File size ({size_mb:.2f} MB) exceeds limit ({max_size_mb} MB)"
+        )
+    
+    return size_bytes
+
+
+def validate_file(file_bytes: bytes, filename: str) -> dict:
+    """
+    Complete file validation (type + size).
+    
+    Args:
+        file_bytes: Raw file content
+        filename: Original filename
+        
+    Returns:
+        dict with validation results:
+            {
+                "valid": True,
+                "mime_type": "image/jpeg",
+                "extension": "jpg",
+                "size_bytes": 1024000,
+                "size_mb": 0.98
+            }
+            
+    Raises:
+        FileValidationError: If validation fails
+    """
+    # Validate type
+    mime_type, extension = validate_file_type(file_bytes, filename)
+    
+    # Validate size
+    size_bytes = validate_file_size(file_bytes, filename)
+    
+    return {
+        "valid": True,
+        "mime_type": mime_type,
+        "extension": extension,
+        "size_bytes": size_bytes,
+        "size_mb": round(size_bytes / (1024 * 1024), 2),
+        "filename": filename
+    }