feat:ELA (Error Level Analysis) signal (23rd signal)

ELA detects JPEG compression inconsistencies across image regions.
Authentic photos have consistent compression history.
AI-generated images show uniform low error (synthesized uniformly).
Manipulated images show regional inconsistencies.

- ela_detector.py: JPEG re-compression difference analysis
* Global error level analysis
* Regional block variance (coefficient of variation)
* High-error concentration analysis
- ensemble: ELA wired in, weights updated, v1.2
- 23 total signals (was 22)
- Tests updated to 23

backend/services/advanced_ensemble_detector.py

@@ -8,6 +8,7 @@ from backend.services.statistical_detector import StatisticalDetector
 from backend.services.dire_detector import DIREDetector
 from backend.services.clip_detector import CLIPDetector
 from backend.services.prnu_detector import detect_prnu
+from backend.services.ela_detector import detect_ela
 
 logger = setup_logger(__name__)
 
@@ -37,7 +38,7 @@ class AdvancedEnsembleDetector(StatisticalDetector):
         Run complete advanced detection with all methods.
         
         Returns:
-            Complete report with 22 detection signals
+            Complete report with 23 detection signals
         """
         logger.info(f"Starting advanced ensemble detection for {self.filename}")
         
@@ -53,8 +54,11 @@ class AdvancedEnsembleDetector(StatisticalDetector):
         # Add PRNU signal
         prnu_result = detect_prnu(self.image_bytes, self.filename)
 
-        # Combine all signals (now 22 total)
-        all_signals = base_report["all_signals"] + [dire_result, clip_result, prnu_result]
+        # Add ELA signal
+        ela_result = detect_ela(self.image_bytes, self.filename)
+
+        # Combine all signals (now 23 total)
+        all_signals = base_report["all_signals"] + [dire_result, clip_result, prnu_result, ela_result]
         
         # Recalculate final score with weighted ensemble
         # Weights based on validation performance
@@ -62,33 +66,26 @@ class AdvancedEnsembleDetector(StatisticalDetector):
 
         prnu_confidence = prnu_result.get("confidence", 0.0)
 
-        if dire_confidence > 0.0 and prnu_confidence > 0.0:
+        ela_confidence = ela_result.get("confidence", 0.0)
+        prnu_confidence = prnu_result.get("confidence", 0.0)
+
+        if dire_confidence > 0.0:
             weighted_score = (
-                0.38 * base_report["ai_probability"] +
-                0.30 * dire_result["score"] +
-                0.22 * clip_result["score"] +
-                0.10 * prnu_result["score"]
+                0.35 * base_report["ai_probability"] +
+                0.28 * dire_result["score"] +
+                0.20 * clip_result["score"] +
+                0.10 * prnu_result["score"] +
+                0.07 * ela_result["score"]
             )
-        elif dire_confidence > 0.0:
+        else:
+            # DIRE unavailable
+            logger.info("DIRE unavailable — using statistical+CLIP+PRNU+ELA")
             weighted_score = (
-                0.40 * base_report["ai_probability"] +
-                0.35 * dire_result["score"] +
-                0.25 * clip_result["score"]
+                0.55 * base_report["ai_probability"] +
+                0.25 * clip_result["score"] +
+                0.12 * prnu_result["score"] +
+                0.08 * ela_result["score"]
             )
-        else:
-            # DIRE unavailable — use statistical+CLIP+PRNU
-            logger.info("DIRE unavailable — using statistical+CLIP+PRNU")
-            if prnu_confidence > 0.0:
-                weighted_score = (
-                    0.58 * base_report["ai_probability"] +
-                    0.30 * clip_result["score"] +
-                    0.12 * prnu_result["score"]
-                )
-            else:
-                weighted_score = (
-                    0.65 * base_report["ai_probability"] +
-                    0.35 * clip_result["score"]
-                )
 
         suspicious_count = sum(1 for s in all_signals if s["score"] > 0.5)
         
@@ -130,8 +127,8 @@ class AdvancedEnsembleDetector(StatisticalDetector):
             "summary": f"Analyzed using {len(all_signals)} independent signals including "
                       f"statistical analysis, diffusion reconstruction, and semantic embeddings. "
                       f"{suspicious_count} signals indicate AI generation.",
-            "detection_version": "advanced-ensemble-v1.1",
-            "methods_used": ["statistical", "dire", "clip", "prnu"]
+            "detection_version": "advanced-ensemble-v1.2",
+            "methods_used": ["statistical", "dire", "clip", "prnu", "ela"]
         }
         
         logger.info(

backend/services/ela_detector.py

@@ -0,0 +1,164 @@
+"""
+ELA (Error Level Analysis) Detection.
+
+ELA detects inconsistencies in JPEG compression across image regions.
+When an image is authentic, all regions have similar compression error levels.
+When an image is AI-generated or manipulated, regions show inconsistent
+error levels because they have different compression histories.
+
+Widely used in digital forensics, journalism verification, and court cases.
+"""
+import numpy as np
+from typing import Dict, Any
+from PIL import Image, ImageChops, ImageEnhance
+from io import BytesIO
+from backend.core.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+
+def detect_ela(image_bytes: bytes, filename: str = "unknown") -> Dict[str, Any]:
+    """
+    Perform Error Level Analysis on image.
+
+    Process:
+    1. Re-save image at known JPEG quality (95)
+    2. Compute pixel difference between original and re-saved
+    3. Analyze the distribution of error levels across regions
+    4. Inconsistent errors = manipulation or AI generation indicators
+    """
+    try:
+        # Open original image
+        original = Image.open(BytesIO(image_bytes)).convert("RGB")
+        width, height = original.size
+
+        # Skip tiny images
+        if width < 32 or height < 32:
+            return {
+                "signal_name": "ELA Compression Analysis",
+                "score": 0.5,
+                "confidence": 0.0,
+                "explanation": "Image too small for ELA analysis",
+                "method": "ela"
+            }
+
+        # Re-save at known quality
+        buffer = BytesIO()
+        original.save(buffer, format="JPEG", quality=95)
+        buffer.seek(0)
+        recompressed = Image.open(buffer).convert("RGB")
+
+        # Compute difference
+        diff = ImageChops.difference(original, recompressed)
+        diff_array = np.array(diff, dtype=np.float64)
+
+        # === Signal 1: Global error level ===
+        # AI images: very uniform low error (synthesized at consistent quality)
+        # Real photos: moderate variation in error levels
+        mean_error = float(np.mean(diff_array))
+        std_error = float(np.std(diff_array))
+
+        # === Signal 2: Regional inconsistency ===
+        # Divide image into blocks and measure error variance between blocks
+        block_size = max(16, min(width, height) // 8)
+        block_means = []
+
+        for y in range(0, height - block_size, block_size):
+            for x in range(0, width - block_size, block_size):
+                block = diff_array[y:y+block_size, x:x+block_size]
+                block_means.append(float(np.mean(block)))
+
+        if len(block_means) > 4:
+            block_variance = float(np.var(block_means))
+            block_mean = float(np.mean(block_means))
+            # Coefficient of variation: how inconsistent are regions?
+            cv = float(np.std(block_means) / (block_mean + 1e-10))
+        else:
+            block_variance = 0.0
+            cv = 0.0
+
+        # === Signal 3: High error region concentration ===
+        # AI images: error concentrated in specific patterns (e.g. edges)
+        # Real photos: error distributed across image
+        flat = diff_array.flatten()
+        high_error_pct = float(np.sum(flat > np.percentile(flat, 90)) / len(flat))
+        error_concentration = abs(high_error_pct - 0.10)  # Expected ~10% above 90th pct
+
+        # === Combine into AI score ===
+        # Very low mean error + low variance = likely AI (uniform synthesis)
+        # Very high variance = likely manipulation
+
+        # Normalize mean error (real photos: typically 3-15, AI: 0.5-5)
+        if mean_error < 1.5:
+            mean_score = 0.8  # Very low error = AI signature
+        elif mean_error < 4.0:
+            mean_score = 0.5
+        elif mean_error < 10.0:
+            mean_score = 0.3  # Normal photo range
+        else:
+            mean_score = 0.4  # High error = possibly edited
+
+        # High coefficient of variation = inconsistent regions = manipulation
+        if cv > 2.0:
+            cv_score = 0.75  # Very inconsistent = manipulation
+        elif cv > 1.0:
+            cv_score = 0.55
+        else:
+            cv_score = 0.25  # Consistent = real or clean AI
+
+        # Error concentration anomaly
+        concentration_score = min(1.0, error_concentration * 5)
+
+        # Weighted combination
+        ai_score = (
+            0.50 * mean_score +
+            0.30 * cv_score +
+            0.20 * concentration_score
+        )
+        ai_score = float(np.clip(ai_score, 0.0, 1.0))
+
+        # Confidence based on image size
+        pixel_count = width * height
+        confidence = min(0.80, 0.4 + (pixel_count / (512 * 512)) * 0.40)
+
+        if mean_error < 2.0:
+            explanation = (
+                f"Very low ELA error ({mean_error:.2f}) — "
+                "uniform compression consistent with AI synthesis"
+            )
+        elif cv > 1.5:
+            explanation = (
+                f"High regional ELA inconsistency (CV={cv:.2f}) — "
+                "compression anomalies detected across image regions"
+            )
+        else:
+            explanation = (
+                f"Normal ELA pattern (mean={mean_error:.2f}, CV={cv:.2f}) — "
+                "compression levels consistent with authentic photo"
+            )
+
+        logger.info(
+            f"ELA detection: score={ai_score:.3f}, "
+            f"mean_err={mean_error:.2f}, cv={cv:.2f}, file={filename}"
+        )
+
+        return {
+            "signal_name": "ELA Compression Analysis",
+            "score": ai_score,
+            "confidence": confidence,
+            "explanation": explanation,
+            "raw_value": mean_error,
+            "expected_range": "< 2.0 mean error for AI images",
+            "method": "ela_jpeg"
+        }
+
+    except Exception as e:
+        logger.warning(f"ELA detection failed: {e}")
+        return {
+            "signal_name": "ELA Compression Analysis",
+            "score": 0.5,
+            "confidence": 0.0,
+            "explanation": f"ELA analysis unavailable: {str(e)}",
+            "raw_value": 0.0,
+            "method": "ela_jpeg"
+        }

backend/tests/test_advanced_ai_detector.py

@@ -67,4 +67,4 @@ def test_forensics_integration(sample_image_bytes):
     assert "ai_detection" in report
     assert "all_signals" in report["ai_detection"]
     # System has 21 signals: 19 statistical + 1 DIRE + 1 CLIP
-    assert report["summary"]["total_detection_signals"] == 22
+    assert report["summary"]["total_detection_signals"] == 23

backend/tests/test_advanced_ensemble.py

@@ -26,8 +26,8 @@ def test_advanced_ensemble_complete_detection(sample_image_bytes):
     assert "methods_used" in report
     
     # Should have 21 signals (19 statistical + DIRE + CLIP)
-    assert report["total_signals"] == 22
-    assert len(report["all_signals"]) == 22
+    assert report["total_signals"] == 23
+    assert len(report["all_signals"]) == 23
     
     # Check methods used
     assert "statistical" in report["methods_used"]
@@ -36,7 +36,7 @@ def test_advanced_ensemble_complete_detection(sample_image_bytes):
     assert "prnu" in report["methods_used"]
     
     # Check version
-    assert report["detection_version"] == "advanced-ensemble-v1.1"
+    assert report["detection_version"] == "advanced-ensemble-v1.2"
     
     # Cleanup
     detector.cleanup()
@@ -50,7 +50,7 @@ def test_advanced_ensemble_forensics_integration(sample_image_bytes):
     report = forensics.generate_forensic_report()
     
     # Check advanced detection was used
-    assert report["ai_detection"]["total_signals"] == 22
+    assert report["ai_detection"]["total_signals"] == 23
     assert report["metadata"]["analyzer_version"] == "6.0.0"
     assert "methods_used" in report["ai_detection"]
-    assert len(report["ai_detection"]["methods_used"]) == 4
+    assert len(report["ai_detection"]["methods_used"]) == 5

backend/tests/test_covariance_detector.py

@@ -62,7 +62,7 @@ def test_covariance_forensics_integration(sample_image_bytes):
     
     assert "ai_detection" in report
     # System has 21 signals: 19 statistical + 1 DIRE + 1 CLIP
-    assert report["ai_detection"]["total_signals"] == 22
+    assert report["ai_detection"]["total_signals"] == 23
     assert report["metadata"]["analyzer_version"] == "6.0.0"
     assert "detection_version" in report["ai_detection"]
 

backend/tests/test_determinism.py

@@ -20,8 +20,8 @@ def test_detection_is_deterministic(sample_image_bytes):
     assert report1["summary"]["ai_classification"] == report2["summary"]["ai_classification"]
     
     # Signal counts should be identical
-    assert report1["summary"]["total_detection_signals"] == 22
-    assert report2["summary"]["total_detection_signals"] == 22
+    assert report1["summary"]["total_detection_signals"] == 23
+    assert report2["summary"]["total_detection_signals"] == 23
 
 
 def test_hash_generation_is_consistent(sample_image_bytes):
@@ -61,8 +61,8 @@ def test_forensic_report_stability(sample_image_bytes):
     assert report1["hashes"]["sha256"] == report2["hashes"]["sha256"]
     
     # Signal counts should be identical
-    assert report1["summary"]["total_detection_signals"] == 22
-    assert report2["summary"]["total_detection_signals"] == 22
+    assert report1["summary"]["total_detection_signals"] == 23
+    assert report2["summary"]["total_detection_signals"] == 23
     assert report1["summary"]["total_detection_signals"] == report2["summary"]["total_detection_signals"]
     
     # AI probability: allow 20% variance for CLIP randomness
@@ -114,8 +114,8 @@ def test_signal_ordering_is_stable(sample_image_bytes):
     assert "ai_detection" in report2
     
     # Both should have 21 signals total
-    assert report1["ai_detection"]["total_signals"] == 22
-    assert report2["ai_detection"]["total_signals"] == 22
+    assert report1["ai_detection"]["total_signals"] == 23
+    assert report2["ai_detection"]["total_signals"] == 23
     
     # Classification keys should be consistent
     assert report1["ai_detection"]["classification"] == report2["ai_detection"]["classification"]

backend/tests/test_statistical_detector.py

@@ -61,7 +61,7 @@ def test_statistical_forensics_integration(sample_image_bytes):
     
     assert "ai_detection" in report
     # System has 21 signals: 19 statistical + 1 DIRE + 1 CLIP
-    assert report["ai_detection"]["total_signals"] == 22
+    assert report["ai_detection"]["total_signals"] == 23
     assert report["metadata"]["analyzer_version"] == "6.0.0"
     assert "detection_version" in report["ai_detection"]
 

backend/tests/test_ultra_advanced_detector.py

@@ -60,6 +60,6 @@ def test_ultra_forensics_integration(sample_image_bytes):
     
     assert "ai_detection" in report
     # System has 21 signals: 19 statistical + 1 DIRE + 1 CLIP
-    assert report["ai_detection"]["total_signals"] == 22
+    assert report["ai_detection"]["total_signals"] == 23
     assert report["metadata"]["analyzer_version"] == "6.0.0"
     assert "detection_version" in report["ai_detection"]

frontend/index.html

@@ -122,7 +122,7 @@
     <nav class="navbar">
         <div class="nav-container">
             <div class="logo">VeriFile-X</div>
-            <div class="nav-badge">22 Detection Signals • 96-98% Accuracy</div>
+            <div class="nav-badge">23 Detection Signals • 96-98% Accuracy</div>
         </div>
     </nav>