Watermark Invisibile in JPEG con PHP 8

{
    "name": "renornad/php-dct-invisible-watermark",
    "description": "Pure-PHP DCT watermarking library for JPEG images.",
    "type": "project",
    "license": "MIT",
    "require": {
      "php": ">=8.3"
    },
    "autoload": {
      "psr-4": {
        "Renor\Watermark\": "src/"
      }
    }
  }

<?php

declare(strict_types=1);

namespace RenorWatermark;

/**
 * 2-D Discrete Cosine Transform (DCT) and its inverse (IDCT) for 8x8 blocks.
 */
final class Dct
{
    private const N = 8;
    private const SQRT_2_INV = 0.7071067811865476; // 1 / sqrt(2)

    /**
     * Performs the forward DCT on an 8x8 block of pixel intensities (0-255).
     */
    public static function forward(array $block): array
    {
        self::assertBlock($block);
        $C = [];

        for ($u = 0; $u < self::N; ++$u) {
            $alphaU = ($u === 0) ? self::SQRT_2_INV : 1.0;
            for ($v = 0; $v < self::N; ++$v) {
                $alphaV = ($v === 0) ? self::SQRT_2_INV : 1.0;
                $sum = 0.0;
                for ($x = 0; $x < self::N; ++$x) {
                    for ($y = 0; $y < self::N; ++$y) {
                        $cosX = cos((2 * $x + 1) * $u * M_PI / (2 * self::N));
                        $cosY = cos((2 * $y + 1) * $v * M_PI / (2 * self::N));
                        $sum += $block[$x][$y] * $cosX * $cosY;
                    }
                }
                // The DCT formula includes a factor of 1/4
                $C[$u][$v] = 0.25 * $alphaU * $alphaV * $sum;
            }
        }
        return $C;
    }

    /**
     * Performs the inverse DCT on an 8x8 block of coefficients, 
     * returning pixel values in the range [0..255].
     */
    public static function inverse(array $coeff): array
    {
        self::assertBlock($coeff);
        $f = [];

        for ($x = 0; $x < self::N; ++$x) {
            for ($y = 0; $y < self::N; ++$y) {
                $sum = 0.0;
                for ($u = 0; $u < self::N; ++$u) {
                    $alphaU = ($u === 0) ? self::SQRT_2_INV : 1.0;
                    for ($v = 0; $v < self::N; ++$v) {
                        $alphaV = ($v === 0) ? self::SQRT_2_INV : 1.0;
                        $cosX = cos((2 * $x + 1) * $u * M_PI / (2 * self::N));
                        $cosY = cos((2 * $y + 1) * $v * M_PI / (2 * self::N));
                        $sum += $alphaU * $alphaV * $coeff[$u][$v] * $cosX * $cosY;
                    }
                }
                $pixel = (int) round(0.25 * $sum);
                $f[$x][$y] = max(0, min(255, $pixel));
            }
        }
        return $f;
    }

    /**
     * Checks that the array is exactly 8x8.
     */
    private static function assertBlock(array $block): void
    {
        if (count($block) !== self::N) {
            throw new InvalidArgumentException('Block must have 8 rows.');
        }
        foreach ($block as $row) {
            if (count($row) !== self::N) {
                throw new InvalidArgumentException('Each row must have 8 columns.');
            }
        }
    }

    /**
     * Disallow instantiation.
     */
    private function __construct()
    {
    }
}

<?php

declare(strict_types=1);

namespace RenorWatermark;

/**
 * Watermarker class
 *
 * Embeds/extracts a short ASCII message (max 10 characters + terminator)
 * into low-frequency DCT coefficients. Instead of relying on the single
 * parity bit – too fragile after rounding and quantization – here
 * we encode the information into the **sign** of the coefficient:
 *
 *   bit 0  → positive coefficient
 *   bit 1  → negative coefficient
 *
 * The sign is never affected during:
 *   1. IDCT → integer rounding,
 *   2. division by JPEG quantization tables,
 *   3. further rounding or transformations.
 */
final class Watermarker
{
    /** Low-frequency coordinates (survive even at q≈90–100). */
    private const EMBED_COORDS = [
        [0, 1], [1, 0], [1, 1], [0, 2],
        [2, 0], [1, 2], [2, 1], [2, 2]
    ];

    /** Redundancy: each bit is repeated 25 times. */
    private const REDUNDANCY = 25;

    private const TERMINATOR = "";

    /* ------------------------------------------------------------------
       Public API
    -------------------------------------------------------------------*/

    public static function embed(array &$blocks, string $msg): void
    {
        if (strlen($msg) > 10) {
            throw new RuntimeException('Message too long (max 10).');
        }

        $bits   = self::stringToBitStream($msg . self::TERMINATOR);
        $cursor = 0;

        foreach ($blocks as &$block) {
            foreach (self::EMBED_COORDS as [$u, $v]) {
                if ($cursor >= count($bits)) {
                    return;
                }
                $bit           = $bits[$cursor++];
                $block[$u][$v] = self::forceSign($block[$u][$v], $bit);
            }
        }
        if ($cursor < count($bits)) {
            throw new RuntimeException('Image too small for the message.');
        }
    }

    public static function extract(array $blocks): string
    {
        $bits = [];
        foreach ($blocks as $block) {
            foreach (self::EMBED_COORDS as [$u, $v]) {
                $bits[] = ( (int) round($block[$u][$v]) < 0 ) ? 1 : 0;
            }
        }

        $filtered   = self::majority($bits, self::REDUNDANCY);
        $byteChunks = array_chunk($filtered, 8);

        $out = '';
        foreach ($byteChunks as $chunk) {
            if (count($chunk) < 8) break;
            $ch = chr(self::bitsToInt($chunk));
            if ($ch === self::TERMINATOR) break;
            $out .= $ch;
        }
        return $out;
    }

    /* ------------------------------------------------------------------
       Private helpers
    -------------------------------------------------------------------*/

    private static function stringToBitStream(string $s): array
    {
        $bits = [];
        foreach (str_split($s) as $c) {
            $byte = ord($c);
            for ($i = 7; $i >= 0; --$i) {
                $bit = ($byte >> $i) & 1;
                $bits = array_merge($bits, array_fill(0, self::REDUNDANCY, $bit));
            }
        }
        return $bits;
    }

    private static function majority(array $bits, int $group): array
    {
        $out = [];
        foreach (array_chunk($bits, $group) as $chunk) {
            $out[] = (array_sum($chunk) > $group / 2) ? 1 : 0;
        }
        return $out;
    }

    private static function bitsToInt(array $bits): int
    {
        return array_reduce($bits, fn($v, $b) => ($v << 1) | $b, 0);
    }

    /**
     * Forces the sign of the coefficient:
     *   bit 0 → positive   (>= +minAmp)
     *   bit 1 → negative   (<= -minAmp)
     * so the quantizer cannot flip it.
     */
    private static function forceSign(
        float $coeff,
        int   $bit,
        int   $minAmp = 80,   // safe amplitude > luminance quantization divisors
        int   $boost  = 64    // further offset to move away from zero
    ): float {
        $rounded = (int) round($coeff);

        // Enforce minimum amplitude
        if (abs($rounded) < $minAmp) {
            $rounded = ($rounded >= 0) ? $minAmp : -$minAmp;
        }

        // Set the sign according to the bit
        if ($bit === 0 && $rounded < 0) $rounded = abs($rounded);
        if ($bit === 1 && $rounded > 0) $rounded = -$rounded;

        // Push further from zero: +/-boost (preserving the sign)
        $rounded += ($rounded > 0) ? $boost : -$boost;

        return (float) $rounded;
    }

    private function __construct() {}
}

<?php

declare(strict_types=1);

namespace RenorWatermark;

use GdImage;

/**
 * Class ImageIO
 *
 * - Loads a JPEG image.
 * - Converts RGB to the Y (luminance) channel.
 * - Splits it into 8x8 blocks and applies DCT/IDCT.
 * - Overwrites the Y channel with the embedded watermark, merging with the original CbCr.
 * - Saves the final image as JPEG with a specified quality.
 */
final class ImageIO
{
    private const BLOCK_SIZE = 8;
    private const MIN_WIDTH = 200;
    private const MIN_HEIGHT = 200;

    /**
     * Embed a watermark in a JPEG image and save the result.
     *
     * @param string $src      Path to the original JPEG
     * @param string $dest     Output path for the watermarked image
     * @param string $message  ASCII watermark (up to 10 chars)
     * @param int    $quality  JPEG quality in [0..100], default 90
     */
    public static function embed(
        string $src,
        string $dest,
        string $message,
        int $quality = 90
    ): void {
        $im = self::loadJpeg($src);
        $w = imagesx($im);
        $h = imagesy($im);

        // Ensure a minimum image size
        if ($w < self::MIN_WIDTH || $h < self::MIN_HEIGHT) {
            imagedestroy($im);
            throw new RuntimeException("Image must be at least 200x200 for robust embedding.");
        }

        // Convert RGB → Y
        $Y = self::rgbToY($im);

        // Split into 8x8 blocks, apply forward DCT
        $blocks = self::forwardBlocks($Y, $w, $h);

        // Embed the message into the DCT coefficients
        Watermarker::embed($blocks, $message);

        // Reconstruct the Y channel from the inverse DCT
        $Ywm = self::inverseBlocks($blocks, $w, $h);

        // Merge the modified Y channel and save as JPEG
        self::mergeAndSave($im, $Ywm, $dest, $quality);

        imagedestroy($im);
    }

    /**
     * Extract the watermark from a JPEG image.
     *
     * @param string $src Path to the watermarked JPEG
     * @return string     The recovered ASCII message
     */
    public static function extract(string $src): string
    {
        $im = self::loadJpeg($src);
        $w = imagesx($im);
        $h = imagesy($im);

        if ($w < self::MIN_WIDTH || $h < self::MIN_HEIGHT) {
            imagedestroy($im);
            throw new RuntimeException("Image is too small (<200x200). It may not contain a robust watermark.");
        }

        // Convert to Y
        $Y = self::rgbToY($im);

        // Apply DCT on 8x8 blocks
        $blocks = self::forwardBlocks($Y, $w, $h);

        // Extract the message from the DCT blocks
        $msg = Watermarker::extract($blocks);

        imagedestroy($im);
        return $msg;
    }

    /* -------------------------------------------------------------------------
       INTERNAL METHODS
    -------------------------------------------------------------------------- */

    /**
     * Loads a JPEG image from disk or throws an exception if invalid.
     */
    public static function loadJpeg(string $path): GdImage
    {
        if (!is_file($path)) {
            throw new RuntimeException("File not found: $path");
        }
        $im = @imagecreatefromjpeg($path);
        if (!$im) {
            throw new RuntimeException("Invalid JPEG: $path");
        }

        return $im;
    }

    /**
     * Converts an RGB image to a 2D Y (luminance) matrix.
     */
    public static function rgbToY(GdImage $im): array
    {
        $w = imagesx($im);
        $h = imagesy($im);
        $Y = array_fill(0, $h, array_fill(0, $w, 0));

        for ($y = 0; $y < $h; $y++) {
            for ($x = 0; $x < $w; $x++) {
                $rgb = imagecolorat($im, $x, $y);
                $r = ($rgb >> 16) & 0xFF;
                $g = ($rgb >> 8) & 0xFF;
                $b = $rgb & 0xFF;
                // ITU-R BT.601 luma formula
                $luma = (int) round(0.299 * $r + 0.587 * $g + 0.114 * $b);
                $Y[$y][$x] = max(0, min(255, $luma));
            }
        }

        return $Y;
    }

    /**
     * Splits the Y matrix into 8x8 blocks and applies forward DCT.
     */
    public static function forwardBlocks(array $Y, int $w, int $h): array
    {
        $blocks = [];
        for ($by = 0; $by < $h; $by += self::BLOCK_SIZE) {
            for ($bx = 0; $bx < $w; $bx += self::BLOCK_SIZE) {
                $block = [];
                for ($i = 0; $i < self::BLOCK_SIZE; $i++) {
                    $row = [];
                    $srcY = min($by + $i, $h - 1);
                    for ($j = 0; $j < self::BLOCK_SIZE; $j++) {
                        $srcX = min($bx + $j, $w - 1);
                        $row[] = $Y[$srcY][$srcX];
                    }
                    $block[] = $row;
                }
                $blocks[] = Dct::forward($block);
            }
        }
        return $blocks;
    }

    /**
     * Applies inverse DCT to each 8x8 block and rebuilds the Y matrix.
     */
    private static function inverseBlocks(array $blocks, int $w, int $h): array
    {
        $Y = array_fill(0, $h, array_fill(0, $w, 0));
        $idx = 0;

        for ($by = 0; $by < $h; $by += self::BLOCK_SIZE) {
            for ($bx = 0; $bx < $w; $bx += self::BLOCK_SIZE) {
                $coeffBlock = $blocks[$idx++];
                $pixBlock = Dct::inverse($coeffBlock);

                for ($i = 0; $i < self::BLOCK_SIZE; $i++) {
                    $dstY = $by + $i;
                    if ($dstY >= $h) break;
                    for ($j = 0; $j < self::BLOCK_SIZE; $j++) {
                        $dstX = $bx + $j;
                        if ($dstX >= $w) break;
                        $Y[$dstY][$dstX] = $pixBlock[$i][$j];
                    }
                }
            }
        }

        return $Y;
    }

    /**
     * Merges the watermarked Y channel with the original CbCr, then saves the final JPEG.
     */
    private static function mergeAndSave(GdImage $orig, array $Ywm, string $dest, int $quality): void
    {
        $w = imagesx($orig);
        $h = imagesy($orig);

        // 1) Overwrite the RGB pixels of the GDImage using the new Y
        for ($y = 0; $y < $h; $y++) {
            for ($x = 0; $x < $w; $x++) {
                $rgb = imagecolorat($orig, $x, $y);
                $r = ($rgb >> 16) & 0xFF;
                $g = ($rgb >> 8) & 0xFF;
                $b = $rgb & 0xFF;

                $cb = -0.169 * $r - 0.331 * $g + 0.5 * $b + 128;
                $cr = 0.5 * $r - 0.419 * $g - 0.081 * $b + 128;

                $Yval = $Ywm[$y][$x];

                $R = $Yval + 1.402 * ($cr - 128);
                $G = $Yval - 0.344136 * ($cb - 128) - 0.714136 * ($cr - 128);
                $B = $Yval + 1.772 * ($cb - 128);

                $R = max(0, min(255, (int) round($R)));
                $G = max(0, min(255, (int) round($G)));
                $B = max(0, min(255, (int) round($B)));

                $color = imagecolorallocate($orig, $R, $G, $B);
                imagesetpixel($orig, $x, $y, $color);
            }
        }

        // 2) Convert GDImage to a PNG blob in memory (lossless)
        ob_start();
        imagepng($orig);
        $pngData = ob_get_clean();

        // 3) Create an Imagick object from the PNG blob
        $imagick = new Imagick();
        $imagick->readImageBlob($pngData);

        // 4) Set desired JPEG parameters
        $imagick->setOption('jpeg:sampling-factor', '1x1'); // disable chroma subsampling
        $imagick->setImageCompressionQuality($quality);
        $imagick->setImageCompression(Imagick::COMPRESSION_JPEG);
        $imagick->setImageFormat('jpeg');

        // 5) Save the file
        $imagick->writeImage($dest);

        // 6) Cleanup
        $imagick->destroy();
    }

    /**
     * Prevents instantiation.
     */
    private function __construct()
    {
    }
}

#!/usr/bin/env php
<?php

// Set memory limit to 1GB
ini_set('memory_limit', '1024M');
require __DIR__ . '/vendor/autoload.php';

use RenorWatermarkImageIO;

/**
 * This command-line script embeds a watermark (up to 10 characters)
 * into a JPEG and saves the result. By default, it uses quality=90.
 *
 * Example usage:
 *   php embed.php --src=original.jpg --out=watermarked.jpg --msg="HELLO" --q=95
 *
 * Or simply:
 *   php embed.php --src=original.jpg --out=watermarked.jpg
 *   (defaults to msg="DEFAULT" and quality=90)
 */

$options = getopt('', ['src:', 'out:', 'msg::', 'q::']);
$src = $options['src'] ?? null;
$out = $options['out'] ?? null;
$msg = $options['msg'] ?? 'DEFAULT';
$q   = isset($options['q']) ? (int) $options['q'] : 90;

if (!$src || !$out) {
    fwrite(STDERR, "Usage: embed --src=INPUT.jpg --out=OUTPUT.jpg [--msg=STRING] [--q=90]n");
    exit(1);
}

try {
    ImageIO::embed($src, $out, $msg, $q);
    echo "Watermark "$msg" embedded successfully into $out at quality $qn";
} catch (Exception $e) {
    fwrite(STDERR, "Error: " . $e->getMessage() . "n");
    exit(1);
}

#!/usr/bin/env php
<?php

// Set memory limit to 1GB
ini_set('memory_limit', '1024M');
require __DIR__ . '/vendor/autoload.php';

use RenorWatermarkImageIO;

/**
 * This command-line script extracts a watermark from a JPEG.
 *
 * Usage:
 *   php extract.php --src=watermarked.jpg
 */

$options = getopt('', ['src:']);
$src = $options['src'] ?? null;

if (!$src) {
    fwrite(STDERR, "Usage: extract --src=IMAGE.jpgn");
    exit(1);
}

try {
    $msg = ImageIO::extract($src);
    echo "Recovered message: "$msg"n";
} catch (Exception $e) {
    fwrite(STDERR, "Error: " . $e->getMessage() . "n");
    exit(1);
}