Initial commit: Veritas Forensic Image Analysis Toolkit with 11 analysis techniques

Author: CodeRafay

.gitignore

@@ -0,0 +1,37 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Temporary files
+temp/
+*.tmp
+
+# Logs
+*.log

.streamlit/config.toml

@@ -0,0 +1,17 @@
+[theme]
+base="dark"
+primaryColor="#00ff41"
+backgroundColor="#0e1117"
+secondaryBackgroundColor="#262730"
+textColor="#fafafa"
+font="sans serif"
+
+[server]
+headless = true
+port = 8501
+
+[client]
+showErrorDetails = true
+
+[logger]
+level = "info"

analysis/__init__.py

@@ -0,0 +1,29 @@
+from . import (
+    ela,
+    metadata_analysis,
+    histogram_analysis,
+    noise_map,
+    jpeg_ghost,
+    quant_table,
+    cmfd,
+    prnu,
+    frequency_analysis,
+    deepfake_detector,
+    resampling_detector,
+    util
+)
+
+__all__ = [
+    "ela",
+    "metadata_analysis",
+    "histogram_analysis",
+    "noise_map",
+    "jpeg_ghost",
+    "quant_table",
+    "cmfd",
+    "prnu",
+    "frequency_analysis",
+    "deepfake_detector",
+    "resampling_detector",
+    "util",
+]

analysis/cmfd.py

@@ -0,0 +1,40 @@
+import cv2
+import numpy as np
+from pathlib import Path
+
+
+def detect_copy_move(image_path, block_size=32, threshold=100):
+    """
+    Detects copy-move forgery using block matching.
+
+    Args:
+        image_path (str): Path to the image file
+        block_size (int): Size of blocks for matching (default 32)
+        threshold (int): Similarity threshold (default 100)
+
+    Returns:
+        dict: Results dictionary or None on error
+    """
+    try:
+        # Read image
+        img = cv2.imread(image_path)
+        if img is None:
+            return {"error": "Could not read image", "result": "Failed to load image"}
+
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+        # For now, return a placeholder indicating the analysis would happen here
+        # Full CMFD implementation is complex and requires sophisticated block matching
+        result = {
+            "status": "analysis_pending",
+            "method": "Block Matching (SIFT)",
+            "block_size": block_size,
+            "image_shape": gray.shape,
+            "result": "CMFD analysis is computationally intensive. Implementation pending."
+        }
+
+        return result
+
+    except Exception as e:
+        print(f"Error in CMFD detection: {e}")
+        return {"error": str(e), "result": f"CMFD error: {str(e)}"}

analysis/deepfake_detector.py

@@ -0,0 +1,129 @@
+import numpy as np
+from PIL import Image
+
+
+def detect_deepfake_artifacts(image_path):
+    """
+    Detects common deepfake/GAN artifacts:
+    - Blurry boundaries between face and background
+    - Unnatural skin texture
+    - Inconsistent lighting
+    - Face warping artifacts
+
+    Args:
+        image_path (str): Path to image file
+
+    Returns:
+        dict: Deepfake artifact detection results
+    """
+    try:
+        img = Image.open(image_path).convert('RGB')
+        img_array = np.array(img, dtype=np.float32)
+
+        # Check for common GAN artifacts
+        # 1. Frequency anomalies (GANs produce artifacts in specific frequency bands)
+        from scipy.fft import fft2, fftshift
+
+        gray = np.mean(img_array, axis=2)
+        fft_result = fft2(gray)
+        magnitude = np.abs(fftshift(fft_result))
+
+        # Analyze specific frequency bands used by GANs
+        h, w = magnitude.shape
+        center_h, center_w = h // 2, w // 2
+
+        # High frequency analysis (often shows GAN artifacts)
+        high_freq_ring = magnitude[center_h -
+                                   20:center_h+20, center_w-20:center_w+20]
+        high_freq_variance = np.var(high_freq_ring)
+
+        # 2. Texture consistency check
+        # GANs often produce subtle texture inconsistencies
+        r, g, b = img_array[:, :, 0], img_array[:, :, 1], img_array[:, :, 2]
+
+        # Channel correlation
+        rg_correlation = np.corrcoef(r.flatten(), g.flatten())[0, 1]
+        rb_correlation = np.corrcoef(r.flatten(), b.flatten())[0, 1]
+        gb_correlation = np.corrcoef(g.flatten(), b.flatten())[0, 1]
+
+        avg_channel_correlation = np.mean(
+            [rg_correlation, rb_correlation, gb_correlation])
+
+        # 3. Boundary blur detection
+        # Calculate gradient magnitude
+        from scipy.ndimage import sobel
+        gradient_x = sobel(gray, axis=1)
+        gradient_y = sobel(gray, axis=0)
+        gradient_magnitude = np.sqrt(gradient_x**2 + gradient_y**2)
+
+        # High gradient at edges is natural; too uniform suggests blurring
+        edge_sharpness = np.std(gradient_magnitude)
+
+        result = {
+            "status": "analysis_complete",
+            "method": "GAN/Deepfake Artifact Detection",
+            "image_size": img_array.shape,
+            "artifacts": {
+                "frequency_anomaly_score": float(high_freq_variance),
+                "channel_correlation_score": float(avg_channel_correlation),
+                "edge_sharpness_score": float(edge_sharpness)
+            },
+            "interpretation": "Scores help identify GAN-generated or deepfake artifacts",
+            "note": "This is a simplified heuristic detector; professional deepfake detection requires deep learning models"
+        }
+
+        return result
+
+    except Exception as e:
+        return {"error": str(e), "status": "analysis_failed"}
+
+
+def detect_gan_fingerprint(image_path):
+    """
+    Detects specific fingerprints left by popular GAN architectures (StyleGAN, ProGAN, etc).
+
+    Args:
+        image_path (str): Path to image file
+
+    Returns:
+        dict: GAN fingerprint detection results
+    """
+    try:
+        img = Image.open(image_path).convert('RGB')
+        img_array = np.array(img, dtype=np.float32)
+
+        # Analyze spectral properties unique to GANs
+        from scipy.fft import fft2, fftshift
+
+        gray = np.mean(img_array, axis=2)
+        fft_result = fft2(gray)
+        magnitude = np.abs(fftshift(fft_result))
+
+        # Look for characteristic "blob" patterns in frequency domain
+        h, w = magnitude.shape
+        center_h, center_w = h // 2, w // 2
+
+        # Radial frequency analysis
+        y, x = np.ogrid[:h, :w]
+        distance = np.sqrt((y - center_h)**2 + (x - center_w)**2)
+
+        radial_profile = []
+        for r in range(1, min(center_h, center_w), 10):
+            mask = (distance >= r) & (distance < r + 10)
+            radial_profile.append(np.mean(magnitude[mask]))
+
+        # GANs produce characteristic radial patterns
+        radial_variance = np.var(radial_profile)
+
+        result = {
+            "status": "analysis_complete",
+            "method": "GAN Fingerprint Detection (Spectral Analysis)",
+            "radial_frequency_variance": float(radial_variance),
+            "potential_gan_likelihood": "Medium" if radial_variance > 1000 else "Low",
+            "note": "Requires deep learning model for accurate detection; this is pattern-based heuristic"
+        }
+
+        return result
+
+    except Exception as e:
+        return {"error": str(e), "status": "analysis_failed"}