워터마킹 기술

// LSB 워터마킹 구현
import sharp from 'sharp';

async function embedLSBWatermark(
    imagePath: string,
    watermarkText: string,
    outputPath: string
): Promise {
    // 1. 이미지를 원시 픽셀 데이터로 로드
    const { data, info } = await sharp(imagePath)
        .raw()
        .toBuffer({ resolveWithObject: true });

    // 2. 워터마크 텍스트를 이진수로 변환
    const watermarkBits = textToBinary(watermarkText);

    // 3. 길이 정보 추가 (처음 32비트)
    const lengthBits = watermarkBits.length.toString(2).padStart(32, '0');
    const fullWatermark = lengthBits + watermarkBits;

    // 4. 픽셀 데이터 수정
    const pixels = new Uint8Array(data);
    for (let i = 0; i < fullWatermark.length; i++) {
        // RGB 중 파란색 채널의 LSB 수정 (덜 눈에 띔)
        const pixelIndex = i * info.channels + 2;
        const bit = parseInt(fullWatermark[i]);

        // LSB를 워터마크 비트로 교체
        pixels[pixelIndex] = (pixels[pixelIndex] & 0xFE) | bit;
    }

    // 5. 워터마크된 이미지 저장
    await sharp(Buffer.from(pixels), {
        raw: {
            width: info.width,
            height: info.height,
            channels: info.channels
        }
    })
    .png()  // 무손실 형식 사용 필수
    .toFile(outputPath);

    console.log(`✅ 워터마크 삽입 완료: ${watermarkText}`);
}

// 텍스트를 이진수로 변환
function textToBinary(text: string): string {
    return text.split('')
        .map(char => char.charCodeAt(0).toString(2).padStart(8, '0'))
        .join('');
}

// 워터마크 추출
async function extractLSBWatermark(imagePath: string): Promise {
    const { data, info } = await sharp(imagePath)
        .raw()
        .toBuffer({ resolveWithObject: true });

    const pixels = new Uint8Array(data);

    // 1. 길이 정보 읽기 (처음 32비트)
    let lengthBits = '';
    for (let i = 0; i < 32; i++) {
        const pixelIndex = i * info.channels + 2;
        lengthBits += (pixels[pixelIndex] & 1).toString();
    }
    const length = parseInt(lengthBits, 2);

    // 2. 워터마크 데이터 읽기
    let watermarkBits = '';
    for (let i = 32; i < 32 + length; i++) {
        const pixelIndex = i * info.channels + 2;
        watermarkBits += (pixels[pixelIndex] & 1).toString();
    }

    // 3. 이진수를 텍스트로 변환
    const text = binaryToText(watermarkBits);

    return text;
}

// 이진수를 텍스트로 변환
function binaryToText(binary: string): string {
    const chars: string[] = [];
    for (let i = 0; i < binary.length; i += 8) {
        const byte = binary.slice(i, i + 8);
        chars.push(String.fromCharCode(parseInt(byte, 2)));
    }
    return chars.join('');
}

// 사용 예제
await embedLSBWatermark(
    'original.png',
    'WIA-AI-017 © 2025 SmileStory',
    'watermarked.png'
);

const extracted = await extractLSBWatermark('watermarked.png');
console.log('추출된 워터마크:', extracted);

// DCT 기반 워터마킹
import sharp from 'sharp';

class DCTWatermarker {
    // 2D DCT 적용
    private dct2d(block: number[][]): number[][] {
        const N = block.length;
        const result: number[][] = Array(N).fill(0).map(() => Array(N).fill(0));

        for (let u = 0; u < N; u++) {
            for (let v = 0; v < N; v++) {
                let sum = 0;
                for (let i = 0; i < N; i++) {
                    for (let j = 0; j < N; j++) {
                        sum += block[i][j] *
                               Math.cos(((2*i+1) * u * Math.PI) / (2*N)) *
                               Math.cos(((2*j+1) * v * Math.PI) / (2*N));
                    }
                }
                const cu = u === 0 ? 1/Math.sqrt(2) : 1;
                const cv = v === 0 ? 1/Math.sqrt(2) : 1;
                result[u][v] = (2/N) * cu * cv * sum;
            }
        }
        return result;
    }

    // 역 DCT
    private idct2d(block: number[][]): number[][] {
        const N = block.length;
        const result: number[][] = Array(N).fill(0).map(() => Array(N).fill(0));

        for (let i = 0; i < N; i++) {
            for (let j = 0; j < N; j++) {
                let sum = 0;
                for (let u = 0; u < N; u++) {
                    for (let v = 0; v < N; v++) {
                        const cu = u === 0 ? 1/Math.sqrt(2) : 1;
                        const cv = v === 0 ? 1/Math.sqrt(2) : 1;
                        sum += cu * cv * block[u][v] *
                               Math.cos(((2*i+1) * u * Math.PI) / (2*N)) *
                               Math.cos(((2*j+1) * v * Math.PI) / (2*N));
                    }
                }
                result[i][j] = (2/N) * sum;
            }
        }
        return result;
    }

    async embedDCTWatermark(
        imagePath: string,
        watermarkBits: string,
        strength: number = 10
    ): Promise {
        // 1. 이미지를 회색조로 변환
        const { data, info } = await sharp(imagePath)
            .grayscale()
            .raw()
            .toBuffer({ resolveWithObject: true });

        const pixels = new Uint8Array(data);
        const width = info.width;
        const height = info.height;

        // 2. 이미지를 8x8 블록으로 분할하고 DCT 적용
        let bitIndex = 0;
        for (let y = 0; y < height - 8; y += 8) {
            for (let x = 0; x < width - 8; x += 8) {
                if (bitIndex >= watermarkBits.length) break;

                // 8x8 블록 추출
                const block: number[][] = [];
                for (let i = 0; i < 8; i++) {
                    block[i] = [];
                    for (let j = 0; j < 8; j++) {
                        const idx = ((y + i) * width + (x + j));
                        block[i][j] = pixels[idx];
                    }
                }

                // DCT 적용
                const dctBlock = this.dct2d(block);

                // 3. 중간 주파수 계수에 워터마크 삽입
                const bit = parseInt(watermarkBits[bitIndex]);
                dctBlock[4][4] += bit === 1 ? strength : -strength;

                // 역 DCT
                const idctBlock = this.idct2d(dctBlock);

                // 블록을 이미지에 다시 쓰기
                for (let i = 0; i < 8; i++) {
                    for (let j = 0; j < 8; j++) {
                        const idx = ((y + i) * width + (x + j));
                        pixels[idx] = Math.max(0, Math.min(255, Math.round(idctBlock[i][j])));
                    }
                }

                bitIndex++;
            }
            if (bitIndex >= watermarkBits.length) break;
        }

        // 4. 결과 이미지 생성
        return sharp(Buffer.from(pixels), {
            raw: { width, height, channels: 1 }
        }).jpeg({ quality: 90 }).toBuffer();
    }
}

// 사용 예제
const watermarker = new DCTWatermarker();
const watermarkData = '101010110011';  // 워터마크 비트

const watermarkedImage = await watermarker.embedDCTWatermark(
    'photo.jpg',
    watermarkData,
    15  // 강도
);

// DWT 기반 워터마킹
class DWTWatermarker {
    // 1D Haar 웨이블릿 변환
    private haar1D(signal: number[]): { low: number[], high: number[] } {
        const n = signal.length;
        const low: number[] = [];
        const high: number[] = [];

        for (let i = 0; i < n; i += 2) {
            // 저주파 성분 (평균)
            low.push((signal[i] + signal[i + 1]) / Math.sqrt(2));
            // 고주파 성분 (차이)
            high.push((signal[i] - signal[i + 1]) / Math.sqrt(2));
        }

        return { low, high };
    }

    // 역 Haar 웨이블릿 변환
    private ihaar1D(low: number[], high: number[]): number[] {
        const signal: number[] = [];

        for (let i = 0; i < low.length; i++) {
            // 원본 신호 재구성
            signal.push((low[i] + high[i]) / Math.sqrt(2));
            signal.push((low[i] - high[i]) / Math.sqrt(2));
        }

        return signal;
    }

    // 2D DWT (이미지)
    private dwt2D(image: number[][]): {
        LL: number[][],  // 저주파-저주파
        LH: number[][],  // 저주파-고주파
        HL: number[][],  // 고주파-저주파
        HH: number[][]   // 고주파-고주파
    } {
        const rows = image.length;
        const cols = image[0].length;

        // 1. 행 방향 DWT
        const rowDWT: Array<{ low: number[], high: number[] }> = [];
        for (let i = 0; i < rows; i++) {
            rowDWT.push(this.haar1D(image[i]));
        }

        // 2. 열 방향 DWT
        const LL: number[][] = [];
        const LH: number[][] = [];
        const HL: number[][] = [];
        const HH: number[][] = [];

        for (let j = 0; j < cols / 2; j++) {
            const lowCol = rowDWT.map(r => r.low[j]);
            const highCol = rowDWT.map(r => r.high[j]);

            const lowDWT = this.haar1D(lowCol);
            const highDWT = this.haar1D(highCol);

            LL.push(lowDWT.low);
            LH.push(lowDWT.high);
            HL.push(highDWT.low);
            HH.push(highDWT.high);
        }

        return { LL, LH, HL, HH };
    }

    // 워터마크 삽입 (LL 밴드에)
    async embedDWTWatermark(
        imagePath: string,
        watermarkBits: string,
        strength: number = 20
    ): Promise {
        const { data, info } = await sharp(imagePath)
            .grayscale()
            .raw()
            .toBuffer({ resolveWithObject: true });

        // 픽셀을 2D 배열로 변환
        const pixels: number[][] = [];
        for (let i = 0; i < info.height; i++) {
            pixels[i] = [];
            for (let j = 0; j < info.width; j++) {
                const idx = i * info.width + j;
                pixels[i][j] = data[idx];
            }
        }

        // DWT 적용
        const dwt = this.dwt2D(pixels);

        // LL 밴드에 워터마크 삽입
        for (let i = 0; i < watermarkBits.length && i < dwt.LL.length; i++) {
            const bit = parseInt(watermarkBits[i]);
            dwt.LL[0][i] += bit === 1 ? strength : -strength;
        }

        // 역 DWT 및 이미지 재구성
        // (실제 구현에서는 완전한 역변환 필요)

        console.log('✅ DWT 워터마크 삽입 완료');
        return Buffer.from([]);  // 간소화
    }
}

// FFmpeg를 사용한 비디오 워터마킹
import { spawn } from 'child_process';

async function watermarkVideo(
    inputPath: string,
    watermarkImagePath: string,
    outputPath: string,
    position: 'topleft' | 'topright' | 'bottomleft' | 'bottomright' = 'bottomright'
): Promise {
    // 위치별 오버레이 좌표 설정
    const positions = {
        topleft: '10:10',
        topright: 'main_w-overlay_w-10:10',
        bottomleft: '10:main_h-overlay_h-10',
        bottomright: 'main_w-overlay_w-10:main_h-overlay_h-10'
    };

    return new Promise((resolve, reject) => {
        const ffmpeg = spawn('ffmpeg', [
            '-i', inputPath,                    // 입력 비디오
            '-i', watermarkImagePath,           // 워터마크 이미지
            '-filter_complex',                  // 복합 필터
            `[1:v]format=rgba,colorchannelmixer=aa=0.3[wm];` +  // 투명도 30%
            `[0:v][wm]overlay=${positions[position]}`,          // 위치 지정
            '-codec:a', 'copy',                 // 오디오 복사
            '-y',                               // 덮어쓰기
            outputPath
        ]);

        ffmpeg.on('close', (code) => {
            if (code === 0) {
                console.log('✅ 비디오 워터마킹 완료');
                resolve();
            } else {
                reject(new Error(`FFmpeg 종료 코드: ${code}`));
            }
        });
    });
}

// AI 생성 콘텐츠 워터마킹 (개념적 구현)
interface AIWatermarkMetadata {
    modelName: string;          // AI 모델명
    modelVersion: string;       // 버전
    generatedAt: string;        // 생성 시각
    prompt?: string;            // 프롬프트 해시
    signature: string;          // 디지털 서명
}

class AIContentWatermarker {
    async embedAIWatermark(
        generatedImagePath: string,
        metadata: AIWatermarkMetadata,
        privateKey: string
    ): Promise {
        // 1. 메타데이터를 JSON으로 직렬화
        const jsonData = JSON.stringify(metadata);

        // 2. 메타데이터에 서명
        const crypto = await import('crypto');
        const sign = crypto.createSign('SHA256');
        sign.update(jsonData);
        sign.end();
        const signature = sign.sign(privateKey, 'hex');

        // 3. 서명된 데이터를 DCT 워터마크로 삽입
        const signedMetadata = { ...metadata, signature };

        console.log('✅ AI 워터마크 삽입:', metadata.modelName);
        return Buffer.from([]);
    }
}

// WIA-AI-017 워터마크 매니페스트
interface WatermarkManifest {
    watermarkId: string;              // 고유 ID
    version: string;                  // 표준 버전
    type: 'invisible' | 'visible' | 'dual';

    embeddingInfo: {
        algorithm: string;            // LSB, DCT, DWT, SynthID 등
        strength: number;             // 워터마크 강도
        location: string;             // 공간/주파수 영역
        embeddedAt: string;           // 삽입 시각
    };

    payload: {
        type: 'text' | 'binary' | 'json';
        data: string;                 // Base64 인코딩
        encoding: string;             // UTF-8, binary 등
    };

    security: {
        encrypted: boolean;           // 암호화 여부
        signed: boolean;              // 서명 여부
        signatureAlgorithm?: string;  // RSA, ECDSA 등
    };
}