stegmark 1.0.0__py3-none-any.whl

stegmark/__init__.py

@@ -0,0 +1,27 @@
+"""
+Stegmark — Universal Steganographic Analysis
+=============================================
+pip install stegmark
+
+Usage:
+    from stegmark import analyze, robustness_test
+
+    # Analyze a single image
+    result = analyze("image.jpg")
+    print(result.verdict)
+    print(result.confidence)
+    result.save_report("audit.pdf")
+
+    # Test watermark robustness
+    report = robustness_test("cover.jpg", secret="my_watermark")
+    print(f"Survived {report.survival_rate:.0%} of attacks")
+    report.save_report("robustness_audit.pdf")
+"""
+
+from stegmark.core import analyze, AnalysisResult
+from stegmark.robustness import robustness_test, RobustnessResult
+from stegmark.report import generate_report
+
+__version__ = "1.0.0"
+__all__ = ["analyze", "robustness_test", "generate_report",
+           "AnalysisResult", "RobustnessResult"]

stegmark/_detectors.py

@@ -0,0 +1,44 @@
+"""
+stegmark._detectors — internal detector wrappers
+Bridges the package API to the underlying detector modules.
+"""
+
+import os, sys, dataclasses
+_PKG_DIR = os.path.dirname(__file__)
+sys.path.insert(0, _PKG_DIR)
+
+
+def run_statistical(image_path: str, cover_path=None) -> dict:
+    from steganalysis import run_report
+    report = run_report(image_path, cover_path)
+    return dataclasses.asdict(report)
+
+
+def run_neural(image_path: str) -> dict:
+    try:
+        from neural_watermark import run_neural_detection
+        nd = run_neural_detection(image_path)
+        return {
+            "attempted": True,
+            "any_detected": nd.any_detected,
+            "detected_schemes": nd.detected_schemes,
+            "detail": nd.detail,
+            "schemes": [dataclasses.asdict(s) for s in nd.schemes],
+        }
+    except ImportError:
+        return {
+            "attempted": False,
+            "error": "pip install trustmark torch torchvision",
+            "schemes": [],
+        }
+    except Exception as e:
+        return {"attempted": True, "error": str(e), "schemes": []}
+
+
+def run_srnet_detection(image_path: str) -> dict:
+    try:
+        from srnet_detector import detect_srnet
+        sr = detect_srnet(image_path)
+        return dataclasses.asdict(sr)
+    except Exception as e:
+        return {"attempted": False, "error": str(e)}

stegmark/cli.py

@@ -0,0 +1,13 @@
+"""
+stegmark CLI — installed as `stegmark` command after pip install
+"""
+import sys, os
+sys.path.insert(0, os.path.dirname(__file__))
+
+def main():
+    # Delegate to run.py's main
+    from run import main as run_main
+    run_main()
+
+if __name__ == "__main__":
+    main()

stegmark/core.py

@@ -0,0 +1,187 @@
+"""
+stegmark.core — main analyze() function
+"""
+
+import os
+import sys
+import dataclasses
+from typing import Optional
+from dataclasses import dataclass, field
+
+# Add package internals to path
+_PKG_DIR = os.path.dirname(__file__)
+sys.path.insert(0, _PKG_DIR)
+
+
+@dataclass
+class AnalysisResult:
+    """
+    Full steganalysis result for a single image.
+
+    Attributes:
+        verdict         Plain-language verdict string
+        confidence      0.0–1.0 aggregate confidence stego is present
+        detected_by     List of detector names that fired
+        image_path      Path to analyzed image
+        cover_path      Path to cover image (if provided)
+
+        # Detector results
+        chi_square      JPEG DCT equalization score result
+        rs_analysis     RS analysis result
+        spa             Sample pair analysis result
+        eof             EOF hidden data result
+        exif            EXIF anomaly result
+        lsb_histogram   LSB uniformity result
+        multi_channel   Per-channel R/G/B result
+        neural          Neural watermark detection result
+        srnet           SRNet adaptive steg result
+        quality         PSNR/SSIM (if cover provided)
+
+    Methods:
+        save_report(path)   Generate and save PDF report
+        to_dict()           Return as JSON-serializable dict
+        is_clean            True if no stego detected
+        is_watermarked      True if neural watermark detected
+    """
+    verdict: str
+    confidence: float
+    detected_by: list
+    image_path: str
+    cover_path: Optional[str]
+
+    # Raw detector results
+    chi_square: dict = field(default_factory=dict)
+    rs_analysis: dict = field(default_factory=dict)
+    spa: dict = field(default_factory=dict)
+    eof: dict = field(default_factory=dict)
+    exif: dict = field(default_factory=dict)
+    lsb_histogram: dict = field(default_factory=dict)
+    multi_channel: dict = field(default_factory=dict)
+    neural: dict = field(default_factory=dict)
+    srnet: dict = field(default_factory=dict)
+    quality: Optional[dict] = None
+
+    @property
+    def is_clean(self) -> bool:
+        return self.confidence < 0.05 and not self.detected_by
+
+    @property
+    def is_watermarked(self) -> bool:
+        return any("neural" in d for d in self.detected_by)
+
+    @property
+    def psnr(self) -> Optional[float]:
+        return self.quality.get("psnr_db") if self.quality else None
+
+    @property
+    def ssim(self) -> Optional[float]:
+        return self.quality.get("ssim") if self.quality else None
+
+    def save_report(self, output_path: str = None) -> str:
+        """Generate PDF report and save to output_path."""
+        from stegmark.report import generate_report
+        if output_path is None:
+            base = os.path.splitext(self.image_path)[0]
+            output_path = f"{base}_stegmark_report.pdf"
+        generate_report(self.to_dict(), output_path,
+                       self.image_path, self.cover_path or "")
+        return output_path
+
+    def to_dict(self) -> dict:
+        return dataclasses.asdict(self)
+
+    def __repr__(self):
+        return (f"AnalysisResult(verdict={self.verdict!r}, "
+                f"confidence={self.confidence:.1%}, "
+                f"detected_by={self.detected_by})")
+
+
+def analyze(
+    image_path: str,
+    cover_path: Optional[str] = None,
+    neural: bool = True,
+    srnet: bool = True,
+    verbose: bool = False,
+) -> AnalysisResult:
+    """
+    Run complete steganalysis on an image. Runs entirely locally.
+
+    Args:
+        image_path  Path to the image to analyze (JPEG or PNG)
+        cover_path  Path to the original cover image (optional).
+                    Enables PSNR/SSIM quality metrics.
+        neural      Run neural watermark detectors (TrustMark, Stable Signature).
+                    Requires: pip install trustmark torch torchvision
+        srnet       Run SRNet adaptive steg detector if checkpoint available.
+                    Train with: stegmark train  (runs overnight on Modal)
+        verbose     Print progress to stdout
+
+    Returns:
+        AnalysisResult with .verdict, .confidence, .detected_by,
+        and per-detector results. Call .save_report() to get a PDF.
+
+    Example:
+        from stegmark import analyze
+
+        result = analyze("watermarked_image.jpg")
+        print(result.verdict)
+        # "WATERMARK DETECTED — neural (trustmark)"
+
+        result.save_report("audit_report.pdf")
+
+        # With cover for quality metrics:
+        result = analyze("stego.jpg", cover_path="original.jpg")
+        print(f"PSNR: {result.psnr:.1f} dB")
+    """
+    from stegmark._detectors import (
+        run_statistical, run_neural, run_srnet_detection
+    )
+
+    if verbose:
+        print(f"[stegmark] Analyzing {image_path}...")
+
+    # Phase 0: statistical + forensic
+    if verbose: print("[stegmark] Running statistical detectors...")
+    stat = run_statistical(image_path, cover_path)
+
+    # Phase 1: neural watermark detection
+    neural_result = {"attempted": False, "schemes": []}
+    if neural:
+        if verbose: print("[stegmark] Running neural detectors...")
+        neural_result = run_neural(image_path)
+        if neural_result.get("any_detected"):
+            for s in neural_result.get("schemes", []):
+                if s.get("detected"):
+                    label = f"{s['scheme']}-neural"
+                    if label not in stat["detected_by"]:
+                        stat["detected_by"].append(label)
+            if stat["confidence"] < 0.5:
+                stat["confidence"] = 1.0
+                schemes = ", ".join(neural_result.get("detected_schemes", []))
+                stat["overall_verdict"] = f"WATERMARK DETECTED — neural ({schemes})"
+
+    # Phase 2: SRNet
+    srnet_result = {"attempted": False}
+    if srnet:
+        srnet_result = run_srnet_detection(image_path)
+        if srnet_result.get("detected"):
+            if "srnet-adaptive" not in stat["detected_by"]:
+                stat["detected_by"].append("srnet-adaptive")
+
+    return AnalysisResult(
+        verdict=stat["overall_verdict"],
+        confidence=stat["confidence"],
+        detected_by=stat["detected_by"],
+        image_path=image_path,
+        cover_path=cover_path,
+        chi_square=stat.get("chi_square", {}),
+        rs_analysis=stat.get("rs_analysis", {}),
+        spa=stat.get("spa", {}),
+        eof=stat.get("eof", {}),
+        exif=stat.get("exif", {}),
+        lsb_histogram=stat.get("lsb_histogram", {}),
+        multi_channel=stat.get("multi_channel", {}),
+        neural=neural_result,
+        srnet=srnet_result,
+        quality=stat.get("quality"),
+    )

stegmark/report.py

@@ -0,0 +1,70 @@
+"""
+stegmark.report — generate_report() function
+Thin wrapper around generate_report.py
+"""
+
+import os, sys
+_PKG_DIR = os.path.dirname(__file__)
+sys.path.insert(0, _PKG_DIR)
+
+
+def generate_report(result: dict, output_path: str,
+                    image_filename: str = "",
+                    cover_filename: str = "") -> str:
+    """Generate a PDF report from an analysis result dict."""
+    from generate_report import generate_pdf
+    generate_pdf(result, output_path, image_filename, cover_filename)
+    return output_path
+
+
+def generate_robustness_report(result, output_path: str) -> str:
+    """Generate a PDF robustness report from a RobustnessResult."""
+    import dataclasses
+    from generate_report import generate_pdf
+
+    # Build a result dict that generate_pdf can consume
+    attacks = result.attacks
+    survived = sum(1 for a in attacks if a.survived)
+
+    # Minimal stat result for the report
+    fake_result = {
+        "chi_square": {"equalization_score": 0, "estimated_payload_rate": 0,
+                       "detected": False, "threshold": 0.65, "n_pairs": 0,
+                       "detail": "Robustness test — not applicable"},
+        "rs_analysis": {"payload_rate": 0, "detected": False, "threshold": 0.05,
+                        "detail": "Robustness test — not applicable"},
+        "spa": {"payload_rate": 0, "detected": False, "threshold": 0.07,
+                "detail": "Robustness test — not applicable"},
+        "eof": {"has_hidden_data": False, "hidden_bytes": 0, "detail": "N/A"},
+        "exif": {"has_exif": False, "anomalies": [], "software": None,
+                 "suspicious": False, "detail": "N/A"},
+        "lsb_histogram": {"lsb_uniformity": 0, "noise_floor": 0,
+                          "detected": False, "detail": "N/A"},
+        "multi_channel": {"channels": [], "most_suspicious": None, "detail": "N/A"},
+        "quality": {"psnr_db": result.baseline_psnr, "ssim": 0.99,
+                    "imperceptible": result.baseline_psnr > 40,
+                    "detail": f"Baseline PSNR={result.baseline_psnr:.2f}dB"},
+        "overall_verdict": (
+            f"ROBUSTNESS TEST — {result.secret!r} — "
+            f"Survived {survived}/{len(attacks)} attacks ({result.survival_rate:.0%})"
+        ),
+        "confidence": result.survival_rate,
+        "detected_by": ["trustmark-neural"],
+        "neural": {
+            "attempted": True, "any_detected": True,
+            "detected_schemes": ["trustmark"],
+            "detail": f"TrustMark watermark — survival rate {result.survival_rate:.0%}",
+            "schemes": [{
+                "scheme": "trustmark", "detected": True,
+                "confidence": 1.0, "payload": result.secret,
+                "bit_accuracy": 1.0, "error": None,
+                "description": "Adobe TrustMark — C2PA content provenance",
+            }]
+        },
+        "srnet": {"attempted": False},
+    }
+
+    generate_pdf(fake_result, output_path,
+                 image_filename=result.image_path,
+                 cover_filename="")
+    return output_path

stegmark/robustness.py

@@ -0,0 +1,162 @@
+"""
+stegmark.robustness — robustness_test() function
+"""
+
+import os, sys, json
+from dataclasses import dataclass, field
+from typing import Optional, List
+
+_PKG_DIR = os.path.dirname(__file__)
+sys.path.insert(0, _PKG_DIR)
+
+
+@dataclass
+class AttackResult:
+    attack: str
+    psnr: float
+    bit_accuracy: float
+    survived: bool
+
+
+@dataclass
+class RobustnessResult:
+    """
+    Robustness test result for a watermarked image.
+
+    Attributes:
+        image_path      Original cover image
+        secret          Embedded secret string
+        baseline_psnr   PSNR of watermarked vs cover
+        survival_rate   Fraction of attacks watermark survived (0.0–1.0)
+        attacks         Per-attack results
+        stego_path      Path to saved watermarked image
+
+    Methods:
+        save_report(path)   Generate and save PDF report
+        to_dict()           Return as JSON-serializable dict
+    """
+    image_path: str
+    secret: str
+    baseline_psnr: float
+    survival_rate: float
+    attacks: List[AttackResult] = field(default_factory=list)
+    stego_path: str = ""
+
+    @property
+    def survived_attacks(self) -> List[str]:
+        return [a.attack for a in self.attacks if a.survived]
+
+    @property
+    def failed_attacks(self) -> List[str]:
+        return [a.attack for a in self.attacks if not a.survived]
+
+    def save_report(self, output_path: str = None) -> str:
+        from stegmark.report import generate_robustness_report
+        if output_path is None:
+            base = os.path.splitext(self.image_path)[0]
+            output_path = f"{base}_robustness_report.pdf"
+        generate_robustness_report(self, output_path)
+        return output_path
+
+    def to_dict(self) -> dict:
+        import dataclasses
+        return dataclasses.asdict(self)
+
+    def __repr__(self):
+        return (f"RobustnessResult(survival_rate={self.survival_rate:.0%}, "
+                f"survived={len(self.survived_attacks)}/{len(self.attacks)}, "
+                f"baseline_psnr={self.baseline_psnr:.1f}dB)")
+
+
+def robustness_test(
+    image_path: str,
+    secret: str = "stegmark",
+    tier2: bool = False,
+    verbose: bool = True,
+) -> RobustnessResult:
+    """
+    Embed a TrustMark watermark and test survival across attack suite.
+
+    Args:
+        image_path  Cover image path (JPEG or PNG)
+        secret      String payload to embed (default: "stegmark")
+        tier2       Also run tier-2 attacks (brightness, contrast, noise)
+        verbose     Print progress table
+
+    Returns:
+        RobustnessResult with .survival_rate, .survived_attacks,
+        .failed_attacks, .baseline_psnr. Call .save_report() for PDF.
+
+    Example:
+        from stegmark import robustness_test
+
+        report = robustness_test("cover.jpg", secret="my_company_id")
+        print(f"Survival rate: {report.survival_rate:.0%}")
+        print(f"Failed: {report.failed_attacks}")
+        report.save_report("robustness_audit.pdf")
+    """
+    import io
+    import numpy as np
+    from PIL import Image
+
+    try:
+        from trustmark import TrustMark
+    except ImportError:
+        raise ImportError("pip install trustmark torch torchvision")
+
+    from robust_watermark_test import (
+        TIER1_ATTACKS, TIER2_ATTACKS, psnr, bit_accuracy
+    )
+
+    if verbose:
+        print(f"[stegmark] Loading TrustMark model...")
+    tm = TrustMark(verbose=False, model_type="Q")
+
+    cover = Image.open(image_path).convert("RGB")
+    stego = tm.encode(cover, secret)
+
+    stego_path = os.path.splitext(image_path)[0] + "_stegmark_stego.png"
+    stego.save(stego_path)
+
+    baseline = psnr(cover, stego)
+    decoded_wm, detected, _ = tm.decode(stego)
+
+    if verbose:
+        print(f"[stegmark] Baseline: PSNR={baseline:.1f}dB  detected={detected}")
+        print(f"\n  {'Attack':<25} {'PSNR':>7}  {'bit_acc':>8}  {'survive':>8}")
+        print(f"  {'-'*54}")
+
+    attacks = TIER1_ATTACKS + (TIER2_ATTACKS if tier2 else [])
+    results = []
+
+    for name, fn in attacks:
+        try:
+            attacked = fn(stego)
+            p = psnr(cover, attacked)
+            try:
+                dec, det, _ = tm.decode(attacked)
+                acc = bit_accuracy(dec, decoded_wm) if dec and decoded_wm else 0.0
+                survived = det and acc > 0.8
+            except Exception:
+                acc = 0.0; survived = False
+
+            if verbose:
+                print(f"  {name:<25} {p:>6.1f}   {acc:>7.1%}   {'✓' if survived else '✗'}")
+            results.append(AttackResult(name, round(p,2), round(acc,3), survived))
+        except Exception as e:
+            results.append(AttackResult(name, 0.0, 0.0, False))
+
+    survived_count = sum(1 for r in results if r.survived)
+    rate = survived_count / len(results) if results else 0.0
+
+    if verbose:
+        print(f"\n  Survived {survived_count}/{len(results)} ({rate:.0%})")
+
+    return RobustnessResult(
+        image_path=image_path,
+        secret=secret,
+        baseline_psnr=round(baseline, 2),
+        survival_rate=round(rate, 3),
+        attacks=results,
+        stego_path=stego_path,
+    )

stegmark-1.0.0.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: stegmark
+Version: 1.0.0
+Summary: Universal steganographic analysis — statistical, forensic, and neural watermark detection
+Requires-Python: >=3.9
+Requires-Dist: numpy<2.0,>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: scikit-image>=0.21
+Requires-Dist: Pillow>=10.0
+Requires-Dist: reportlab>=4.0
+Requires-Dist: jpegio>=0.2.8
+Requires-Dist: fastapi>=0.100
+Requires-Dist: uvicorn>=0.23
+Requires-Dist: python-multipart>=0.0.6
+Provides-Extra: neural
+Requires-Dist: trustmark>=0.1; extra == "neural"
+Requires-Dist: torch>=2.0; extra == "neural"
+Requires-Dist: torchvision>=0.15; extra == "neural"
+Provides-Extra: all
+Requires-Dist: trustmark>=0.1; extra == "all"
+Requires-Dist: torch>=2.0; extra == "all"
+Requires-Dist: torchvision>=0.15; extra == "all"

stegmark-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+stegmark/__init__.py,sha256=H216oaX10Y_Bug_DI6fMuMe7zv7SuG_MMs4O5Xm4bhc,833
+stegmark/_detectors.py,sha256=mL7cNW0gpNaSN6mBg3ui9tiqDzVCIucgJl_aUOOVhBA,1351
+stegmark/cli.py,sha256=yS_jcQIs3Ydwr-Y4zGoWoaQED9XLjQIUQzGRGsMsUEk,272
+stegmark/core.py,sha256=5UyK6viBePrQzM4w-cZhwPI2Gf4n18BRsyG7v4wvKAw,6595
+stegmark/report.py,sha256=8zh4wWv8Btd34BosExrTegDwZwMl8FiFfvs6ybE_RV4,3062
+stegmark/robustness.py,sha256=2g-IE7bqehcGaXl1obWMvOBbO4Lhxy0wz-Tuo4-SIKM,5049
+stegmark-1.0.0.dist-info/METADATA,sha256=IoFvcfnMYuYm4tL6qRDzwRJyyTYZU915LBC2pp7STWg,780
+stegmark-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+stegmark-1.0.0.dist-info/entry_points.txt,sha256=rTsDDAbnrdXDYrT0eZeDqMa1adHD1tOk5Of-zGwOc5g,47
+stegmark-1.0.0.dist-info/top_level.txt,sha256=LSUI8MIJoPOw_Eu380gTUMdjHL7P-9tTRldD5PcXx8c,9
+stegmark-1.0.0.dist-info/RECORD,,

stegmark-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stegmark-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stegmark = stegmark.cli:main

stegmark-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+stegmark