ab-image-ob 1.0.1 → 1.0.3

package/dist/crypto/ImageEncryptor.d.ts

@@ -0,0 +1,83 @@
+export declare enum EncryptionAlgorithm {
+    /** AES-128-GCM - 快速，安全性高，推荐 */
+    AES_128_GCM = "aes-128-gcm",
+    /** AES-192-GCM - 中等强度 */
+    AES_192_GCM = "aes-192-gcm",
+    /** AES-256-GCM - 最高强度，推荐敏感数据 */
+    AES_256_GCM = "aes-256-gcm",
+    /** AES-128-CBC - 传统模式，无完整性验证 */
+    AES_128_CBC = "aes-128-cbc",
+    /** AES-256-CBC - 传统模式，无完整性验证 */
+    AES_256_CBC = "aes-256-cbc",
+    /** ChaCha20-Poly1305 - 现代算法，移动端友好 */
+    CHACHA20_POLY1305 = "chacha20-poly1305",
+    /** XOR 简单混淆 - 快速但不安全，仅用于预览混淆 */
+    XOR_SIMPLE = "xor-simple",
+    /** 像素位置打乱 - 不改变颜色值，仅重排像素 */
+    PIXEL_SHUFFLE = "pixel-shuffle",
+    /** 颜色通道置换 - 交换 RGB 通道顺序 */
+    CHANNEL_SWAP = "channel-swap"
+}
+export declare enum EncryptionMode {
+    /** 仅加密像素数据（输出可显示的图片） */
+    PIXEL_ONLY = "pixel-only",
+    /** 加密完整文件（输出不可显示的加密文件） */
+    FULL_FILE = "full-file",
+    /** 混合模式：像素加密 + 元数据保护 */
+    HYBRID = "hybrid"
+}
+interface EncryptionMetadata {
+    algorithm: EncryptionAlgorithm;
+    mode: EncryptionMode;
+    iv: string;
+    authTag?: string;
+    width: number;
+    height: number;
+    channels: number;
+    density?: number;
+    channelMapping?: number[];
+    shuffleSeed?: number;
+    originalFormat?: string;
+    timestamp: number;
+}
+export declare class ImageEncryptor {
+    private algorithm;
+    private mode;
+    private key;
+    constructor(algorithm?: EncryptionAlgorithm, mode?: EncryptionMode);
+    /**
+     * 从密码生成密钥（使用 PBKDF2）
+     */
+    generateKeyFromPassword(password: string, salt?: Buffer): Promise<Buffer>;
+    /**
+     * 生成随机密钥
+     */
+    generateRandomKey(): Buffer;
+    /**
+     * 设置已有密钥
+     */
+    setKey(key: Buffer): void;
+    /**
+     * 加密图片
+     */
+    encrypt(inputPath: string, outputPath: string): Promise<EncryptionMetadata>;
+    /**
+     * 解密图片
+     */
+    decrypt(encryptedPath: string, outputPath: string, fullMetadata?: EncryptionMetadata, metaPath?: string): Promise<void>;
+    private extractMetadata;
+    private standardEncrypt;
+    private standardDecrypt;
+    private xorEncrypt;
+    private xorDecrypt;
+    private pixelShuffleEncrypt;
+    private pixelShuffleDecrypt;
+    private generateShuffleIndices;
+    private channelSwapEncrypt;
+    private channelSwapDecrypt;
+    private generateChannelMapping;
+    private saveAsImage;
+}
+export declare function quickEncrypt(inputPath: string, outputPath: string, algorithm?: EncryptionAlgorithm, mode?: EncryptionMode, password?: string): Promise<Buffer>;
+export {};
+//# sourceMappingURL=ImageEncryptor.d.ts.map

package/dist/crypto/ImageEncryptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageEncryptor.d.ts","sourceRoot":"","sources":["../../src/crypto/ImageEncryptor.ts"],"names":[],"mappings":"AAOA,oBAAY,mBAAmB;IAC3B,+BAA+B;IAC/B,WAAW,gBAAgB;IAC3B,yBAAyB;IACzB,WAAW,gBAAgB;IAC3B,gCAAgC;IAChC,WAAW,gBAAgB;IAC3B,gCAAgC;IAChC,WAAW,gBAAgB;IAC3B,gCAAgC;IAChC,WAAW,gBAAgB;IAC3B,qCAAqC;IACrC,iBAAiB,sBAAsB;IACvC,gCAAgC;IAChC,UAAU,eAAe;IACzB,4BAA4B;IAC5B,aAAa,kBAAkB;IAC/B,2BAA2B;IAC3B,YAAY,iBAAiB;CAChC;AAGD,oBAAY,cAAc;IACtB,wBAAwB;IACxB,UAAU,eAAe;IACzB,0BAA0B;IAC1B,SAAS,cAAc;IACvB,wBAAwB;IACxB,MAAM,WAAW;CACpB;AAqED,UAAU,kBAAkB;IACxB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACrB;AAGD,qBAAa,cAAc;IACvB,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,GAAG,CAAS;gBAER,SAAS,GAAE,mBAAqD,EAAE,IAAI,GAAE,cAA0C;IAM9H;;OAEG;IACG,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO/E;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAM3B;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAQzB;;OAEG;IACG,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAyDjF;;OAEG;IACG,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,kBAAkB,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YA0D/G,eAAe;YAYf,eAAe;YAmBf,eAAe;YAYf,UAAU;YAYV,UAAU;YAUV,mBAAmB;YAwBnB,mBAAmB;IAmBjC,OAAO,CAAC,sBAAsB;YAehB,kBAAkB;YAiClB,kBAAkB;IA2BhC,OAAO,CAAC,sBAAsB;YAchB,WAAW;CAsB5B;AAGD,wBAAsB,YAAY,CAC9B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,SAAS,GAAE,mBAAqD,EAChE,IAAI,GAAE,cAA0C,EAChD,QAAQ,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,CAWjB"}

package/dist/crypto/ImageEncryptor.js

@@ -0,0 +1,441 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageEncryptor = exports.EncryptionMode = exports.EncryptionAlgorithm = void 0;
+exports.quickEncrypt = quickEncrypt;
+// imageCrypto.ts
+const sharp_1 = __importDefault(require("sharp"));
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+// ============ 加密算法枚举 ============
+var EncryptionAlgorithm;
+(function (EncryptionAlgorithm) {
+    /** AES-128-GCM - 快速，安全性高，推荐 */
+    EncryptionAlgorithm["AES_128_GCM"] = "aes-128-gcm";
+    /** AES-192-GCM - 中等强度 */
+    EncryptionAlgorithm["AES_192_GCM"] = "aes-192-gcm";
+    /** AES-256-GCM - 最高强度，推荐敏感数据 */
+    EncryptionAlgorithm["AES_256_GCM"] = "aes-256-gcm";
+    /** AES-128-CBC - 传统模式，无完整性验证 */
+    EncryptionAlgorithm["AES_128_CBC"] = "aes-128-cbc";
+    /** AES-256-CBC - 传统模式，无完整性验证 */
+    EncryptionAlgorithm["AES_256_CBC"] = "aes-256-cbc";
+    /** ChaCha20-Poly1305 - 现代算法，移动端友好 */
+    EncryptionAlgorithm["CHACHA20_POLY1305"] = "chacha20-poly1305";
+    /** XOR 简单混淆 - 快速但不安全，仅用于预览混淆 */
+    EncryptionAlgorithm["XOR_SIMPLE"] = "xor-simple";
+    /** 像素位置打乱 - 不改变颜色值，仅重排像素 */
+    EncryptionAlgorithm["PIXEL_SHUFFLE"] = "pixel-shuffle";
+    /** 颜色通道置换 - 交换 RGB 通道顺序 */
+    EncryptionAlgorithm["CHANNEL_SWAP"] = "channel-swap";
+})(EncryptionAlgorithm || (exports.EncryptionAlgorithm = EncryptionAlgorithm = {}));
+// ============ 加密模式枚举 ============
+var EncryptionMode;
+(function (EncryptionMode) {
+    /** 仅加密像素数据（输出可显示的图片） */
+    EncryptionMode["PIXEL_ONLY"] = "pixel-only";
+    /** 加密完整文件（输出不可显示的加密文件） */
+    EncryptionMode["FULL_FILE"] = "full-file";
+    /** 混合模式：像素加密 + 元数据保护 */
+    EncryptionMode["HYBRID"] = "hybrid";
+})(EncryptionMode || (exports.EncryptionMode = EncryptionMode = {}));
+// ============ 算法配置映射 ============
+const ALGORITHM_CONFIG = {
+    [EncryptionAlgorithm.AES_128_GCM]: {
+        keyLength: 16,
+        ivLength: 12,
+        authTagLength: 16,
+        isAuthenticated: true
+    },
+    [EncryptionAlgorithm.AES_192_GCM]: {
+        keyLength: 24,
+        ivLength: 12,
+        authTagLength: 16,
+        isAuthenticated: true
+    },
+    [EncryptionAlgorithm.AES_256_GCM]: {
+        keyLength: 32,
+        ivLength: 12,
+        authTagLength: 16,
+        isAuthenticated: true
+    },
+    [EncryptionAlgorithm.AES_128_CBC]: {
+        keyLength: 16,
+        ivLength: 16,
+        authTagLength: 0,
+        isAuthenticated: false
+    },
+    [EncryptionAlgorithm.AES_256_CBC]: {
+        keyLength: 32,
+        ivLength: 16,
+        authTagLength: 0,
+        isAuthenticated: false
+    },
+    [EncryptionAlgorithm.CHACHA20_POLY1305]: {
+        keyLength: 32,
+        ivLength: 12,
+        authTagLength: 16,
+        isAuthenticated: true
+    },
+    [EncryptionAlgorithm.XOR_SIMPLE]: {
+        keyLength: 1, // XOR 只需要 1 字节密钥
+        ivLength: 0,
+        authTagLength: 0,
+        isAuthenticated: false
+    },
+    [EncryptionAlgorithm.PIXEL_SHUFFLE]: {
+        keyLength: 32, // 用作随机种子
+        ivLength: 0,
+        authTagLength: 0,
+        isAuthenticated: false
+    },
+    [EncryptionAlgorithm.CHANNEL_SWAP]: {
+        keyLength: 0, // 不需要密钥，只是通道置换
+        ivLength: 0,
+        authTagLength: 0,
+        isAuthenticated: false
+    }
+};
+// ============ 主加密类 ============
+class ImageEncryptor {
+    constructor(algorithm = EncryptionAlgorithm.AES_256_GCM, mode = EncryptionMode.PIXEL_ONLY) {
+        this.algorithm = algorithm;
+        this.mode = mode;
+        this.key = Buffer.alloc(ALGORITHM_CONFIG[algorithm].keyLength);
+    }
+    /**
+     * 从密码生成密钥（使用 PBKDF2）
+     */
+    async generateKeyFromPassword(password, salt) {
+        const config = ALGORITHM_CONFIG[this.algorithm];
+        const usedSalt = salt || (0, crypto_1.randomBytes)(16);
+        this.key = (0, crypto_1.scryptSync)(password, usedSalt, config.keyLength);
+        return this.key;
+    }
+    /**
+     * 生成随机密钥
+     */
+    generateRandomKey() {
+        const config = ALGORITHM_CONFIG[this.algorithm];
+        this.key = (0, crypto_1.randomBytes)(config.keyLength);
+        return this.key;
+    }
+    /**
+     * 设置已有密钥
+     */
+    setKey(key) {
+        const config = ALGORITHM_CONFIG[this.algorithm];
+        if (key.length !== config.keyLength) {
+            throw new Error(`密钥长度必须为 ${config.keyLength} 字节，当前为 ${key.length} 字节`);
+        }
+        this.key = key;
+    }
+    /**
+     * 加密图片
+     */
+    async encrypt(inputPath, outputPath) {
+        const metadata = await this.extractMetadata(inputPath);
+        // 根据算法执行加密
+        let encryptedBuffer;
+        let extraMetadata = {};
+        switch (this.algorithm) {
+            case EncryptionAlgorithm.AES_128_GCM:
+            case EncryptionAlgorithm.AES_192_GCM:
+            case EncryptionAlgorithm.AES_256_GCM:
+            case EncryptionAlgorithm.AES_128_CBC:
+            case EncryptionAlgorithm.AES_256_CBC:
+            case EncryptionAlgorithm.CHACHA20_POLY1305:
+                encryptedBuffer = await this.standardEncrypt(inputPath, metadata, extraMetadata);
+                break;
+            case EncryptionAlgorithm.XOR_SIMPLE:
+                encryptedBuffer = await this.xorEncrypt(inputPath);
+                break;
+            case EncryptionAlgorithm.PIXEL_SHUFFLE:
+                encryptedBuffer = await this.pixelShuffleEncrypt(inputPath, extraMetadata);
+                break;
+            case EncryptionAlgorithm.CHANNEL_SWAP:
+                encryptedBuffer = await this.channelSwapEncrypt(inputPath, extraMetadata);
+                break;
+            default:
+                throw new Error(`不支持的算法: ${this.algorithm}`);
+        }
+        // 保存加密后的图片
+        if (this.mode === EncryptionMode.PIXEL_ONLY) {
+            await this.saveAsImage(encryptedBuffer, outputPath, metadata);
+        }
+        else {
+            await fs_1.promises.writeFile(outputPath, encryptedBuffer);
+        }
+        // 保存元数据
+        const metaPath = outputPath + '.meta.json';
+        const fullMetadata = {
+            algorithm: this.algorithm,
+            mode: this.mode,
+            iv: extraMetadata.iv || '',
+            authTag: extraMetadata.authTag,
+            width: metadata.width,
+            height: metadata.height,
+            channels: metadata.channels,
+            density: metadata.density,
+            channelMapping: extraMetadata.channelMapping,
+            shuffleSeed: extraMetadata.shuffleSeed,
+            originalFormat: metadata.format,
+            timestamp: Date.now()
+        };
+        await fs_1.promises.writeFile(metaPath, JSON.stringify(fullMetadata, null, 2));
+        return fullMetadata;
+    }
+    /**
+     * 解密图片
+     */
+    async decrypt(encryptedPath, outputPath, fullMetadata, metaPath) {
+        // 读取元数据
+        let metadata;
+        if (fullMetadata) {
+            metadata = fullMetadata;
+        }
+        else if (!metaPath) {
+            throw new Error("需要 metaData 或 metaPath");
+        }
+        else {
+            const metaContent = await fs_1.promises.readFile(metaPath, 'utf-8');
+            metadata = JSON.parse(metaContent);
+        }
+        // 验证算法匹配
+        if (metadata.algorithm !== this.algorithm) {
+            throw new Error(`算法不匹配：文件使用 ${metadata.algorithm}，当前使用 ${this.algorithm}`);
+        }
+        // 读取加密数据
+        let encryptedBuffer;
+        if (this.mode === EncryptionMode.PIXEL_ONLY) {
+            const image = (0, sharp_1.default)(encryptedPath);
+            encryptedBuffer = await image.raw().toBuffer();
+        }
+        else {
+            encryptedBuffer = await fs_1.promises.readFile(encryptedPath);
+        }
+        // 根据算法执行解密
+        let decryptedBuffer;
+        switch (this.algorithm) {
+            case EncryptionAlgorithm.AES_128_GCM:
+            case EncryptionAlgorithm.AES_192_GCM:
+            case EncryptionAlgorithm.AES_256_GCM:
+            case EncryptionAlgorithm.AES_128_CBC:
+            case EncryptionAlgorithm.AES_256_CBC:
+            case EncryptionAlgorithm.CHACHA20_POLY1305:
+                decryptedBuffer = await this.standardDecrypt(encryptedBuffer, metadata);
+                break;
+            case EncryptionAlgorithm.XOR_SIMPLE:
+                decryptedBuffer = await this.xorDecrypt(encryptedBuffer);
+                break;
+            case EncryptionAlgorithm.PIXEL_SHUFFLE:
+                decryptedBuffer = await this.pixelShuffleDecrypt(encryptedBuffer, metadata);
+                break;
+            case EncryptionAlgorithm.CHANNEL_SWAP:
+                decryptedBuffer = await this.channelSwapDecrypt(encryptedBuffer, metadata);
+                break;
+            default:
+                throw new Error(`不支持的算法: ${this.algorithm}`);
+        }
+        // 保存解密后的图片
+        await this.saveAsImage(decryptedBuffer, outputPath, metadata);
+        console.log(`解密完成：${outputPath}`);
+    }
+    // ============ 私有方法 ============
+    async extractMetadata(inputPath) {
+        const image = (0, sharp_1.default)(inputPath);
+        const metadata = await image.metadata();
+        if (!metadata.width || !metadata.height || !metadata.channels) {
+            throw new Error('无法读取图片尺寸信息');
+        }
+        console.log('原始元数据:', metadata);
+        return metadata;
+    }
+    async standardEncrypt(inputPath, metadata, extraMetadata) {
+        const image = (0, sharp_1.default)(inputPath);
+        const pixelBuffer = await image.raw().toBuffer();
+        const config = ALGORITHM_CONFIG[this.algorithm];
+        const iv = (0, crypto_1.randomBytes)(config.ivLength);
+        const cipher = (0, crypto_1.createCipheriv)(this.algorithm, this.key, iv);
+        const encryptedBuffer = Buffer.concat([cipher.update(pixelBuffer), cipher.final()]);
+        extraMetadata.iv = iv.toString('hex');
+        if (config.isAuthenticated && 'getAuthTag' in cipher) {
+            extraMetadata.authTag = cipher.getAuthTag().toString('hex');
+        }
+        return encryptedBuffer;
+    }
+    async standardDecrypt(encryptedBuffer, metadata) {
+        const config = ALGORITHM_CONFIG[this.algorithm];
+        const iv = Buffer.from(metadata.iv, 'hex');
+        const decipher = (0, crypto_1.createDecipheriv)(this.algorithm, this.key, iv);
+        if (config.isAuthenticated && metadata.authTag) {
+            decipher.setAuthTag(Buffer.from(metadata.authTag, 'hex'));
+        }
+        return Buffer.concat([decipher.update(encryptedBuffer), decipher.final()]);
+    }
+    async xorEncrypt(inputPath) {
+        const image = (0, sharp_1.default)(inputPath);
+        const pixelBuffer = await image.raw().toBuffer();
+        const xorKey = this.key[0]; // 使用第一个字节作为 XOR 密钥
+        const result = Buffer.alloc(pixelBuffer.length);
+        for (let i = 0; i < pixelBuffer.length; i++) {
+            result[i] = pixelBuffer[i] ^ xorKey;
+        }
+        return result;
+    }
+    async xorDecrypt(encryptedBuffer) {
+        // XOR 是对称的，相同操作即可解密
+        const xorKey = this.key[0];
+        const result = Buffer.alloc(encryptedBuffer.length);
+        for (let i = 0; i < encryptedBuffer.length; i++) {
+            result[i] = encryptedBuffer[i] ^ xorKey;
+        }
+        return result;
+    }
+    async pixelShuffleEncrypt(inputPath, extraMetadata) {
+        const image = (0, sharp_1.default)(inputPath);
+        const metadata = await image.metadata();
+        const pixelBuffer = await image.raw().toBuffer();
+        const pixelCount = metadata.width * metadata.height;
+        const pixelSize = metadata.channels;
+        const seed = this.key.readUInt32BE(0);
+        extraMetadata.shuffleSeed = seed;
+        // 生成随机索引映射
+        const indices = this.generateShuffleIndices(pixelCount, seed);
+        const shuffledBuffer = Buffer.alloc(pixelBuffer.length);
+        for (let i = 0; i < pixelCount; i++) {
+            const srcOffset = indices[i] * pixelSize;
+            const dstOffset = i * pixelSize;
+            pixelBuffer.copy(shuffledBuffer, dstOffset, srcOffset, srcOffset + pixelSize);
+        }
+        return shuffledBuffer;
+    }
+    async pixelShuffleDecrypt(encryptedBuffer, metadata) {
+        const pixelCount = metadata.width * metadata.height;
+        const pixelSize = metadata.channels;
+        const seed = metadata.shuffleSeed || 0;
+        // 生成相同的随机索引映射
+        const indices = this.generateShuffleIndices(pixelCount, seed);
+        const restoredBuffer = Buffer.alloc(encryptedBuffer.length);
+        // 反向映射
+        for (let i = 0; i < pixelCount; i++) {
+            const srcOffset = i * pixelSize;
+            const dstOffset = indices[i] * pixelSize;
+            encryptedBuffer.copy(restoredBuffer, dstOffset, srcOffset, srcOffset + pixelSize);
+        }
+        return restoredBuffer;
+    }
+    generateShuffleIndices(count, seed) {
+        const indices = Array.from({ length: count }, (_, i) => i);
+        let rng = (s) => {
+            s = (s * 9301 + 49297) % 233280;
+            return s / 233280;
+        };
+        for (let i = count - 1; i > 0; i--) {
+            const j = Math.floor(rng(seed) * (i + 1));
+            [indices[i], indices[j]] = [indices[j], indices[i]];
+            seed = (seed * 9301 + 49297) % 233280;
+        }
+        return indices;
+    }
+    async channelSwapEncrypt(inputPath, extraMetadata) {
+        const image = (0, sharp_1.default)(inputPath);
+        const metadata = await image.metadata();
+        const pixelBuffer = await image.raw().toBuffer();
+        const channels = metadata.channels;
+        if (channels < 3) {
+            throw new Error('通道置换需要至少 3 个通道（RGB）');
+        }
+        // 使用密钥决定置换映射
+        const mapping = this.generateChannelMapping(this.key);
+        extraMetadata.channelMapping = mapping;
+        const result = Buffer.alloc(pixelBuffer.length);
+        const pixelCount = metadata.width * metadata.height;
+        for (let i = 0; i < pixelCount; i++) {
+            const offset = i * channels;
+            for (let c = 0; c < channels; c++) {
+                if (c < 3) {
+                    // 交换 RGB 通道
+                    result[offset + mapping[c]] = pixelBuffer[offset + c];
+                }
+                else {
+                    // Alpha 通道保持不变
+                    result[offset + c] = pixelBuffer[offset + c];
+                }
+            }
+        }
+        return result;
+    }
+    async channelSwapDecrypt(encryptedBuffer, metadata) {
+        const channels = metadata.channels;
+        const mapping = metadata.channelMapping || [0, 1, 2];
+        // 创建反向映射
+        const inverseMapping = new Array(3);
+        for (let i = 0; i < 3; i++) {
+            inverseMapping[mapping[i]] = i;
+        }
+        const result = Buffer.alloc(encryptedBuffer.length);
+        const pixelCount = metadata.width * metadata.height;
+        for (let i = 0; i < pixelCount; i++) {
+            const offset = i * channels;
+            for (let c = 0; c < 3; c++) {
+                result[offset + inverseMapping[c]] = encryptedBuffer[offset + c];
+            }
+            // 保留 Alpha 通道
+            if (channels === 4) {
+                result[offset + 3] = encryptedBuffer[offset + 3];
+            }
+        }
+        return result;
+    }
+    generateChannelMapping(key) {
+        // 使用密钥的哈希值决定 RGB 通道的置换方式
+        const hash = key.reduce((a, b) => a + b, 0) % 6;
+        const mappings = [
+            [0, 1, 2], // 原始 RGB
+            [0, 2, 1], // R B G
+            [1, 0, 2], // G R B
+            [1, 2, 0], // G B R
+            [2, 0, 1], // B R G
+            [2, 1, 0] // B G R
+        ];
+        return mappings[hash];
+    }
+    async saveAsImage(buffer, outputPath, metadata) {
+        let sharpInstance = (0, sharp_1.default)(buffer, {
+            raw: {
+                width: metadata.width,
+                height: metadata.height,
+                channels: metadata.channels
+            }
+        });
+        // 恢复 density 信息
+        if (metadata.density) {
+            sharpInstance = sharpInstance.withMetadata({ density: metadata.density });
+        }
+        // 根据原格式保存
+        const ext = path_1.default.extname(outputPath).toLowerCase();
+        if (ext === '.jpg' || ext === '.jpeg') {
+            await sharpInstance.jpeg({ quality: 100 }).toFile(outputPath);
+        }
+        else {
+            await sharpInstance.png({ compressionLevel: 9 }).toFile(outputPath);
+        }
+    }
+}
+exports.ImageEncryptor = ImageEncryptor;
+// ============ 便捷函数 ============
+async function quickEncrypt(inputPath, outputPath, algorithm = EncryptionAlgorithm.AES_256_GCM, mode = EncryptionMode.PIXEL_ONLY, password) {
+    const encryptor = new ImageEncryptor(algorithm, mode);
+    if (password) {
+        await encryptor.generateKeyFromPassword(password);
+    }
+    else {
+        encryptor.generateRandomKey();
+        console.log(`随机密钥（请保存）: ${encryptor['key'].toString('hex')}`);
+    }
+    return await encryptor.encrypt(inputPath, outputPath);
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export declare function greet(name: string): string;
+export { ImageEncryptor, quickEncrypt } from "./crypto/ImageEncryptor";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.greet = greet;
-// src/index.ts
-function greet(name) {
-    return `Hello, ${name}!`;
-}
+exports.quickEncrypt = exports.ImageEncryptor = void 0;
+var ImageEncryptor_1 = require("./crypto/ImageEncryptor");
+Object.defineProperty(exports, "ImageEncryptor", { enumerable: true, get: function () { return ImageEncryptor_1.ImageEncryptor; } });
+Object.defineProperty(exports, "quickEncrypt", { enumerable: true, get: function () { return ImageEncryptor_1.quickEncrypt; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ab-image-ob",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,5 +17,8 @@
   },
   "files": [
     "dist"
-  ]
+  ],
+  "dependencies": {
+    "sharp": "^0.34.5"
+  }
 }