CalvinBackup/reverse-SynthID
1
0
Fork 0
mirror of https://github.com/aloshdenny/reverse-SynthID.git synced 2026-08-30 17:40:40 +02:00
Code Issues Packages Projects Releases Wiki Activity

v3

Browse Source
This commit is contained in:
Alosh Denny
2026-02-15 18:04:20 +05:30
parent ad79ba532f
commit 25483c159a
22 changed files with 3341 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+305 -286
View File
@@ -2,213 +2,156 @@
<img src="assets/synthid-watermark.jpeg" alt="SynthID Watermark Analysis" width="100%">
</p>
<h1 align="center">🔍 AI Watermark Reverse Engineering</h1>
<h1 align="center">🔍 Reverse-Engineering SynthID</h1>
<p align="center">
<b>Discovering hidden AI watermark patterns through signal analysis</b>
<b>Discovering, detecting, and surgically removing Google's AI watermark through spectral analysis</b>
</p>
<p align="center">
<img src="https://img.shields.io/badge/Python-3.10+-blue?style=flat-square&logo=python" alt="Python">
<img src="https://img.shields.io/badge/License-Research-green?style=flat-square" alt="License">
<img src="https://img.shields.io/badge/Status-Complete-success?style=flat-square" alt="Status">
<img src="https://img.shields.io/badge/Images_Analyzed-123,268-brightgreen?style=flat-square" alt="Images">
<img src="https://img.shields.io/badge/Detection_Rate-99.9%25-success?style=flat-square" alt="Detection">
<img src="https://img.shields.io/badge/Detection_Rate-90%25-success?style=flat-square" alt="Detection">
<img src="https://img.shields.io/badge/Bypass_V3-PSNR_40dB+-blueviolet?style=flat-square" alt="Bypass V3">
</p>
---
## 🎯 Overview
This project reverse-engineers **AI watermarking technologies** by analyzing AI-generated and AI-edited images. We use signal processing techniques to discover watermark structures without access to proprietary neural network encoders/decoders.
This project reverse-engineers **Google's SynthID** watermarking system - the invisible watermark embedded into every image generated by Google Gemini. Using only signal processing and spectral analysis (no access to the proprietary encoder/decoder), we:
### Projects
1. **Discovered** the watermark's exact frequency-domain structure
2. **Built a detector** that identifies SynthID watermarks with 90% accuracy
3. **Developed a spectral bypass** (V3) that surgically removes watermark components while preserving image quality at **40+ dB PSNR**
| Analysis | Images | Detection Rate | Key Finding |
|:---------|:------:|:--------------:|:------------|
| **[Nano-150k Investigation](#-nano-150k-watermark-investigation)** | 123,268 | 99.9% | Multi-layer frequency + spatial watermarking |
| **[SynthID Analysis](#-synthid-google-gemini-analysis)** | 250 | 84% | Spread-spectrum phase encoding |
### What Makes This Different
Unlike brute-force approaches (JPEG compression, noise injection), our V3 bypass uses a **SpectralCodebook** - a fingerprint of the watermark's exact frequency signature - extracted from reference images. This allows surgical, frequency-bin-level removal rather than blind signal destruction.
---
## 🔬 Nano-150k Watermark Investigation
## 🔬 Key Findings
Analysis of **123,268 AI-edited image pairs** from the Nano-150k dataset to detect and characterize embedded watermarks.
### The Watermark is a Fixed Spectral Pattern
### Key Discovery
By generating pure black and white images through Google Gemini, we isolated the watermark signal from content. The results are striking:
AI-edited images contain **multi-layer watermarks** using both frequency domain (DCT/DFT) and spatial domain (color shifts) embedding techniques. The watermarks are invisible to humans but detectable via statistical analysis.
<p align="center">
<img src="assets/synthid_black.jpg" alt="Watermark on black background" width="45%">
<img src="assets/synthid_white.jpg" alt="Watermark on white background" width="45%">
</p>
### Detection Results
<p align="center">
<i>Left: SynthID watermark extracted from a pure-black Gemini image (enhanced 100×). Right: Same watermark on a white background. The diagonal stripe pattern and carrier frequencies are clearly visible.</i>
</p>
| Metric | Rate | Description |
|:-------|:----:|:------------|
| **Frequency Domain Modifications** | 100.0% | All images show spectral changes |
| **Significant Color Shifts** | 95.3% | Mean shift > 1.0 in RGB channels |
| **Perceptual Hash Changes** | 66.0% | Invisible modifications detected |
| **LSB Anomalies** | 10.2% | Least significant bit patterns |
| **2+ Watermark Indicators** | 99.9% | Multi-layer evidence |
| **3+ Watermark Indicators** | 69.2% | Strong multi-layer evidence |
### Carrier Frequency Discovery
### Watermark Confidence Distribution
The watermark embeds energy at specific carrier frequencies with **>99.9% phase coherence** across all images:
```
0 indicators: 0 ( 0.0%)
1 indicator: 122 ( 0.1%)
2 indicators: 37,832 (30.7%) ███████████████
3 indicators: 74,525 (60.5%) ██████████████████████████████
4 indicators: 10,789 ( 8.8%) ████
```
| Carrier Frequency (fy, fx) | Phase Coherence | Magnitude | Phase (rad) |
|:--------------------------:|:---------------:|:---------:|:-----------:|
| **(±14, ±14)** | 99.96% | 16,807 | ±1.44 |
| **(±126, ±14)** | 99.96% | 8,046 | ±2.37 |
| **(±98, ∓14)** | 99.94% | 6,283 | ±0.61 |
| **(±128, ±128)** | 99.25% | 6,908 | ±2.29 |
| **(±210, ∓14)** | 99.96% | 6,032 | ±1.13 |
| **(±238, ±14)** | 99.90% | 4,190 | ±1.61 |
### Extracted Watermark Visualizations
> **Key insight:** Most carriers cluster along the `y = ±14` line in frequency space, suggesting a structured frequency selection algorithm. The diagonal stripe pattern visible in the enhanced images corresponds to these carrier frequencies.
<table>
<tr>
<td width="50%">
### Phase Consistency - A Fixed Model-Level Key
**Extracted Watermark Pattern**
<img src="watermark_investigation/WATERMARK_EXTRACTED.png" width="100%">
The watermark's phase template is **identical across all images** from the same Gemini model:
</td>
<td width="50%">
- **Green channel phase std**: < 0.007 radians across 50 reference images
- **Cross-image correlation**: 21.8% mean pairwise noise correlation
- **Noise structure ratio**: 1.32 ± 0.02 (byproduct of the neural encoder)
**Comprehensive Analysis**
<img src="watermark_investigation/WATERMARK_FINAL_ANALYSIS.png" width="100%">
This means SynthID does not embed per-image messages - it uses a **fixed spectral fingerprint** that can be profiled and subtracted.
</td>
</tr>
<tr>
<td width="50%">
### Frequency Spectrum Analysis
**Frequency Spectrum**
<img src="watermark_investigation/WATERMARK_frequency_spectrum.png" width="100%">
<p align="center">
<img src="artifacts/visualizations/synthid_watermark_spectrum.png" alt="FFT Magnitude Spectrum" width="35%">
<img src="artifacts/visualizations/synthid_watermark_carriers.png" alt="Carrier Frequencies" width="35%">
</p>
<p align="center">
<i>Left: FFT magnitude spectrum showing bright carrier frequency peaks. Right: Reconstructed carrier pattern showing the diagonal structure.</i>
</p>
</td>
<td width="50%">
**Enhanced Difference Pattern**
<img src="watermark_investigation/WATERMARK_enhanced_difference.png" width="100%">
</td>
</tr>
</table>
### Analysis by Edit Category
| Category | Image Pairs | Avg Freq Diff | Watermark Strength |
|:---------|:-----------:|:-------------:|:------------------:|
| hairstyle | 16,012 | 1.786 | High |
| sweet_headshot | 16,008 | 1.759 | High |
| black_headshot | 17,700 | 1.735 | High |
| background | 32,765 | 1.037 | Medium |
| time-change | 18,178 | 1.028 | Medium |
| action | 22,605 | 1.013 | Medium |
### Processing Statistics
- **Total Processing Time**: 170.2 minutes
- **Processing Rate**: 12.1 pairs/second
- **Success Rate**: 100% (0 failed loads)
<p align="center">
<img src="artifacts/visualizations/deep_analysis/frequency_analysis.png" alt="Frequency Analysis" width="80%">
</p>
<p align="center">
<i>Detailed frequency analysis: Average magnitude spectrum (left) and phase coherence map (right). The carrier positions are marked with crosshairs.</i>
</p>
---
## 🔬 SynthID (Google Gemini) Analysis
## 🏗️ Architecture
Analysis of **250 AI-generated images** from Google Gemini to reverse-engineer SynthID watermarking.
### Three Generations of Bypass
### Key Discovery
| Version | Approach | PSNR | Detection Impact | Status |
|:-------:|:---------|:----:|:----------------:|:------:|
| **V1** | JPEG compression (Q50) | 37 dB | ~11% phase drop | ✅ Baseline |
| **V2** | Multi-stage transforms (noise, color, frequency) | 27-37 dB | ~0% confidence drop | ✅ Quality trade-off |
| **V3** | Spectral codebook subtraction | **33-43 dB** | **1-7% confidence drop** | ✅ Best quality |
SynthID uses **spread-spectrum phase encoding** in the frequency domain—not LSB replacement or simple noise addition. The watermark embeds information through precise phase relationships at specific carrier frequencies.
## 🔬 Discovered Patterns
| Carrier Frequency | Phase Coherence | Description |
|:----------------:|:---------------:|:------------|
| **(±14, ±14)** | 99.99% | Primary diagonal carrier |
| **(±126, ±14)** | 99.97% | Secondary horizontal |
| **(±98, ±14)** | 99.94% | Tertiary carrier |
| **(±128, ±128)** | 99.92% | Center frequency |
| **(±210, ±14)** | 99.77% | Extended carrier |
| **(±238, ±14)** | 99.71% | Edge carrier |
### Detection Metrics
- **Noise Correlation**: ~0.218 between watermarked images
- **Structure Ratio**: ~1.32
- **Detection Threshold**: correlation > 0.179
## 🖼️ Extracted Watermark Visualizations
<table>
<tr>
<td width="50%">
**Enhanced Visualization (500x Amplification)**
<img src="artifacts/visualizations/synthid_watermark_amp500x.png" width="100%">
</td>
<td width="50%">
**Frequency Domain Carriers**
<img src="artifacts/visualizations/synthid_watermark_frequency.png" width="100%">
</td>
</tr>
<tr>
<td width="50%">
**False Color (HSV Encoding)**
<img src="artifacts/visualizations/synthid_watermark_falsecolor.png" width="100%">
</td>
<td width="50%">
**Phase Encoding Pattern**
<img src="artifacts/visualizations/synthid_watermark_phase.png" width="100%">
</td>
</tr>
</table>
## 📁 Project Structure
### V3 Pipeline (Spectral Bypass)
```
reverse-SynthID/
├── 📄 README.md # This file
├── 📋 requirements.txt # Python dependencies
│
├── 🔍 watermark_investigation/ # Nano-150k Analysis (NEW)
│ ├── WATERMARK_EXTRACTED.png # Final extracted watermark
│ ├── WATERMARK_FINAL_ANALYSIS.png # Comprehensive visualization
│ ├── WATERMARK_enhanced_difference.png # Enhanced pattern
│ ├── WATERMARK_frequency_spectrum.png # Frequency domain
│ ├── WATERMARK_signed_pattern.png # Signed watermark
│ ├── watermark_FULL_123k_results.json # Complete results
│ ├── watermark_evidence/ # Visual evidence
│ └── *.py # Analysis scripts
│
├── 💻 src/
│ ├── analysis/
│ │ ├── synthid_codebook_finder.py # Pattern discovery
│ │ └── deep_synthid_analysis.py # Frequency analysis
│ └── extraction/
│ └── synthid_codebook_extractor.py # Codebook extraction & detection
│
├── 🎯 artifacts/
│ ├── codebook/
│ │ ├── synthid_codebook.pkl # Extracted codebook (9 MB)
│ │ └── synthid_codebook_meta.json # Carrier frequencies
│ └── visualizations/ # Watermark images
│
├── 📂 data/
│ └── pure_white/ # 250 Gemini AI images
│
├── 📚 docs/
│ └── SYNTHID_CODEBOOK_ANALYSIS.md # Technical documentation
│
└── 🖼️ assets/
└── synthid-watermark.jpeg # Cover image
Input Image → FFT per channel → Estimate Watermark → Subtract → IFFT → Clip → Output
↑
SpectralCodebook
(25 black + 25 white refs)
```
1. **SpectralCodebook** profiles the watermark from reference images (pure black/white Gemini outputs)
2. **Selective notch filter** targets only high-magnitude (P97+), high-consistency (≥95%) frequency bins
3. **Safe magnitude cap** limits subtraction to 30% of image energy per bin - preserving content
4. **Content-adaptive scaling** adjusts subtraction based on image luminance
---
## 📊 Results
### V3 Bypass Quality (PSNR in dB - higher is better)
| Image | Gentle | Moderate | Aggressive | Maximum |
|:-----:|:------:|:--------:|:----------:|:-------:|
| 121407 | **42.9** | 41.4 | 40.0 | 39.3 |
| 110802 | 33.4 | 33.3 | 33.1 | 33.0 |
| 131614 | **38.4** | 38.0 | 37.5 | 37.2 |
| 119198 | **38.4** | 37.7 | 37.0 | 36.6 |
| 12085 | **42.5** | 41.6 | 40.7 | 40.3 |
> All images maintain **>33 dB PSNR** - visually indistinguishable from the original.
### Watermark Detection Confidence
| Image | Before | After (Aggressive) | Drop |
|:-----:|:------:|:------------------:|:----:|
| 121407 | 0.394 | 0.387 | 1.7% |
| 131614 | 0.437 | 0.422 | 3.4% |
| 12085 | 0.394 | 0.366 | **7.2%** |
| 119198 | 0.389 | 0.386 | 0.9% |
### Sample Output
<p align="center">
<img src="assets/sample_watermarked.png" alt="Original watermarked image" width="45%">
<img src="assets/sample_cleaned.png" alt="V3 bypass output" width="45%">
</p>
<p align="center">
<i>Left: Original SynthID-watermarked Gemini image. Right: After V3 spectral bypass - visually identical, watermark energy reduced.</i>
</p>
---
## 🚀 Quick Start
### Installation
@@ -217,159 +160,235 @@ reverse-SynthID/
git clone https://github.com/yourusername/reverse-SynthID.git
cd reverse-SynthID
# Create virtual environment
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
# Install dependencies
pip install -r requirements.txt
```
### Run Nano-150k Watermark Analysis
### 1. Build Detection Codebook
```bash
# Full analysis on all 123k pairs (takes ~3 hours)
python watermark_investigation/watermark_full_123k_analysis.py
# Extract final watermark visualization
python watermark_investigation/extract_final_watermark.py
# Quick sample analysis (1000 pairs)
python watermark_investigation/watermark_full_analysis.py
python src/extraction/robust_extractor.py extract /path/to/watermarked/images \
--output artifacts/codebook/robust_codebook.pkl
```
### Detect SynthID Watermark
### 2. Detect Watermark
```bash
python src/extraction/synthid_codebook_extractor.py detect "path/to/image.png" \
--codebook "artifacts/codebook/synthid_codebook.pkl"
python src/extraction/robust_extractor.py detect image.png \
--codebook artifacts/codebook/robust_codebook.pkl
```
**Output:**
```
Detection Results:
Watermarked: True
Confidence: 1.0000
Correlation: 0.5355
Phase Match: 0.9571
Structure Ratio: 1.2753
Confidence: 0.95
Phase Match: 0.6683
```
### Extract New Codebook
### 3. Build Spectral Codebook (V3)
```bash
python src/extraction/synthid_codebook_extractor.py extract "data/pure_white/" \
--output "./my_codebook.pkl"
```
### Run Analysis
```bash
# Comprehensive pattern discovery
python src/analysis/synthid_codebook_finder.py
# Deep frequency analysis
python src/analysis/deep_synthid_analysis.py
```
## 🧠 How It Works
### Nano-150k Watermark Detection
1. **Frequency Domain Analysis**: Compute FFT differences between original and edited images
2. **LSB Pattern Detection**: Analyze least significant bit distributions for anomalies
3. **Color Shift Measurement**: Detect systematic RGB channel modifications
4. **Perceptual Hashing**: Compare perceptual hashes to find invisible changes
5. **Multi-Indicator Scoring**: Combine multiple detection methods for confidence
### SynthID Detection
1. **Pattern Discovery**: Analyze noise patterns across multiple images to find consistent structures
2. **Frequency Analysis**: Use FFT to identify carrier frequencies with phase modulation
3. **Phase Coherence**: Measure phase consistency at carrier frequencies
4. **Codebook Extraction**: Build reference patterns from averaged signals
5. **Detection**: Compare test image against codebook using correlation metrics
## 📊 Technical Details
### Nano-150k Watermark Characteristics
- **Embedding Domains**: Frequency (DCT/DFT) + Spatial (color shifts)
- **Detection Methods**: FFT analysis, LSB statistics, perceptual hashing
- **Signal Strength**: Mean freq diff ~1.32, color shifts 32-35 pixel values
- **Robustness**: Survives JPEG compression, consistent across edit types
- **Categories Analyzed**: background, action, time-change, headshot, hairstyle
### SynthID Watermark Characteristics
- **Embedding Domain**: Frequency (FFT phase)
- **Signal Strength**: ~0.1-0.15 pixel values
- **Carrier Count**: 100+ frequency locations
- **Robustness**: Survives moderate compression
### Detection Algorithms
**Nano-150k Multi-Indicator Detection:**
```python
def detect_watermark(original, edited):
indicators = 0
# 1. Frequency domain analysis
freq_diff = compute_fft_difference(original, edited)
if freq_diff > 0.5:
indicators += 1
# 2. Color shift detection
color_shift = compute_color_shift(original, edited)
if any(abs(shift) > 1.0 for shift in color_shift):
indicators += 1
# 3. LSB anomaly detection
lsb_deviation = compute_lsb_deviation(edited)
if any(dev > 0.02 for dev in lsb_deviation):
indicators += 1
# 4. Perceptual hash comparison
phash_dist = compute_phash_distance(original, edited)
if 5 < phash_dist <= 30:
indicators += 1
return indicators >= 2, indicators
from synthid_bypass import SpectralCodebook
codebook = SpectralCodebook()
codebook.extract_from_references(
black_dir='assets/black/', # Pure-black Gemini images
white_dir='assets/white/' # Pure-white Gemini images
)
codebook.save('artifacts/spectral_codebook.npz')
```
**SynthID Detection:**
### 4. Run V3 Bypass
```python
def detect_synthid(image, codebook):
# 1. Extract noise pattern
noise = image - denoise(image)
# 2. Check carrier phase coherence
fft = fft2(noise)
phase_match = check_phases(fft, codebook.carriers)
# 3. Correlate with reference
correlation = correlate(noise, codebook.reference)
# 4. Apply decision thresholds
is_watermarked = (
correlation > 0.179 and
phase_match > 0.5 and
0.8 < structure_ratio < 1.8
)
return is_watermarked, confidence
from synthid_bypass import SynthIDBypass, SpectralCodebook
codebook = SpectralCodebook()
codebook.load('artifacts/spectral_codebook.npz')
bypass = SynthIDBypass()
result = bypass.bypass_v3(image_rgb, codebook, strength='aggressive')
print(f"PSNR: {result.psnr:.1f} dB") # ~40 dB
```
**Strength levels:** `gentle` (minimal change, ~43 dB) → `moderate` → `aggressive` → `maximum` (strongest removal, ~33 dB)
---
## 📁 Project Structure
```
reverse-SynthID/
├── src/
│ ├── extraction/
│ │ ├── synthid_bypass.py # V1/V2/V3 bypass implementations + SpectralCodebook
│ │ ├── robust_extractor.py # Multi-scale watermark detection (90% accuracy)
│ │ ├── watermark_remover.py # Frequency-domain watermark removal
│ │ ├── benchmark_extraction.py # Performance benchmarking suite
│ │ └── synthid_codebook_extractor.py # Original codebook extractor (legacy)
│ └── analysis/
│ ├── deep_synthid_analysis.py # FFT/phase analysis scripts
│ └── synthid_codebook_finder.py # Carrier frequency discovery
│
├── assets/
│ ├── synthid_black.jpg # Watermark on black (enhanced)
│ ├── synthid_white.jpg # Watermark on white (enhanced)
│ ├── black/ # Reference black images from Gemini
│ └── white/ # Reference white images from Gemini
│
├── artifacts/
│ ├── codebook/ # Detection codebooks (.pkl)
│ ├── spectral_codebook.npz # V3 spectral fingerprint (119 MB)
│ ├── v3_output/ # V3 bypass output samples
│ └── visualizations/ # FFT, phase, carrier visualizations
│
├── watermark_investigation/ # Early-stage Nano-150k analysis (archived)
├── SYNTHID_CODEBOOK_ANALYSIS.md # Detailed codebook reverse-engineering report
├── synthid.pdf # SynthID paper reference
└── requirements.txt
```
---
## 🔬 Technical Deep Dive
### How SynthID Works (Reverse-Engineered)
```
┌──────────────────────────────────────────────────────────────┐
│ SynthID Encoder (in Gemini) │
├──────────────────────────────────────────────────────────────┤
│ 1. Generate carrier frequencies: {(14,14), (126,14), ...} │
│ 2. Assign fixed phase values to each carrier │
│ 3. Neural encoder adds learned noise pattern to image │
│ 4. Watermark is imperceptible - spread across spectrum │
├──────────────────────────────────────────────────────────────┤
│ SynthID Decoder (in Google) │
├──────────────────────────────────────────────────────────────┤
│ 1. Extract noise residual (wavelet denoising) │
│ 2. FFT → check phase at known carrier frequencies │
│ 3. If phases match expected values → Watermarked │
└──────────────────────────────────────────────────────────────┘
```
### SpectralCodebook Extraction
The codebook captures the watermark's full frequency fingerprint:
- **50 reference images** (25 pure black + 25 pure white, all from Gemini)
- Extracts **magnitude envelope** and **phase template** per channel
- Computes **phase consistency score** per frequency bin
- Content-adaptive profiles for dark vs. light image regions
### Selective Notch Filter
The V3 bypass doesn't subtract blindly - it targets only bins where:
1. **Magnitude** exceeds the 97th percentile (strong watermark energy)
2. **Phase consistency** ≥ 0.95 across reference images (confirmed watermark, not noise)
3. **Subtraction** is capped at 30% of the image's energy at each bin
This surgical precision is why V3 achieves 40+ dB PSNR while still reducing watermark energy.
### Noise Correlation Signature
| Metric | Value | Significance |
|:-------|:-----:|:-------------|
| Mean pairwise noise correlation | **0.218** | Identical watermark in all images |
| Noise structure ratio | **1.32** | Neural encoder byproduct |
| Phase coherence (top carriers) | **>99.9%** | Fixed model-level key |
| Green channel phase std | **<0.007 rad** | Strongest consistency channel |
### Bit Plane Analysis
| Bit Plane | Consistency | Role |
|:---------:|:-----------:|:-----|
| Bit 0 (LSB) | 0.049 | Watermark signal |
| Bit 1 | 0.074 | Watermark signal |
| Bit 2 | 0.125 | Partially watermarked |
| Bit 3 | 0.513 | Mixed |
| Bits 4-7 | 0.635–1.000 | Image structure |
---
## 🛠️ Core Modules
### `robust_extractor.py` - Detection
Multi-scale, multi-denoiser watermark detector achieving 90% detection rate.
```python
from robust_extractor import RobustSynthIDExtractor
extractor = RobustSynthIDExtractor()
extractor.load_codebook('artifacts/codebook/robust_codebook.pkl')
result = extractor.detect_array(image)
print(f"Watermarked: {result.is_watermarked}")
print(f"Confidence: {result.confidence:.4f}")
print(f"Phase Match: {result.phase_match:.4f}")
```
**Features:**
- Multi-scale analysis (256, 512, 1024px)
- Wavelet + bilateral + NLM denoising fusion
- ICA-based watermark/content separation
- Ensemble carrier detection across scales
### `synthid_bypass.py` - Bypass (V1/V2/V3)
Three generations of watermark bypass:
```python
from synthid_bypass import SynthIDBypass, SpectralCodebook
bypass = SynthIDBypass()
# V1: Simple JPEG compression
result = bypass.bypass_simple(image, jpeg_quality=50)
# V2: Multi-stage transform pipeline
result = bypass.bypass_v2(image, strength='moderate')
# V3: Spectral codebook subtraction (best)
codebook = SpectralCodebook()
codebook.load('artifacts/spectral_codebook.npz')
result = bypass.bypass_v3(image, codebook, strength='aggressive')
```
### `watermark_remover.py` - Removal
Quality-preserving frequency-domain removal:
```python
from watermark_remover import WatermarkRemover
remover = WatermarkRemover(extractor)
result = remover.remove(image, mode='balanced')
```
---
## 📚 References
- [SynthID: Identifying AI-generated images](https://deepmind.google/technologies/synthid/)
- [Arxiv Paper - SynthID-Image: Image watermarking at internet scale]([https://doi.org/10.1038/s41586-024-07754-z](https://arxiv.org/abs/2510.09263))
- [SynthID Paper (arXiv:2510.09263)](https://arxiv.org/abs/2510.09263)
- [Synthid-Bypass ComfyUI Workflow](https://github.com/aloshdenny/Synthid-Bypass) - img2img re-generation approach
---
## ⚠️ Disclaimer
This project is for **research and educational purposes only**. SynthID is proprietary technology owned by Google DeepMind. The extracted patterns and detection methods are intended for:
This project is for **research and educational purposes only**. SynthID is proprietary technology owned by Google DeepMind. These tools are intended for:
- Academic research on watermarking techniques
- Security analysis of AI-generated content identification
- Understanding spread-spectrum encoding methods
- 🎓 Academic research on watermarking robustness
- 🔒 Security analysis of AI-generated content identification
- 📡 Understanding spread-spectrum encoding methods
**Do not use these tools to misrepresent AI-generated content as human-created.**
---
## 📄 License
@@ -378,5 +397,5 @@ Research and educational use only. See [LICENSE](LICENSE) for details.
---
<p align="center">
Made with 🔬 by reverse engineering enthusiasts
Made with 🔬 by watermark reverse engineering researchers
</p>