Calculation/app/lib/crypt.js

'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */

const crypto = require('crypto-js');
const fs = require('fs');
const path = require('path');
const encryptSpr = '|----|';
const baseKey = crypto.enc.Utf8.parse('Sc3850?Calc888Zh'); // 十六位十六进制数作为密钥
const baseIv = crypto.enc.Utf8.parse('Zh888!Sc3850Calc'); // 十六位十六进制数作为密钥偏移量

const baseUtils = {
    aesDecrypt: function(str, key, iv) {
        const encryptedHexStr = crypto.enc.Hex.parse(str);
        const src = crypto.enc.Base64.stringify(encryptedHexStr);
        const decrypt = crypto.AES.decrypt(src, key, {
            iv,
            mode: crypto.mode.CBC,
            padding: crypto.pad.Pkcs7,
        });
        const decryptedStr = decrypt.toString(crypto.enc.Utf8);
        return decryptedStr.toString();
    },
    aesEncrypt: function(str, key, iv) {
        const src = crypto.enc.Utf8.parse(str);
        const encrypted = crypto.AES.encrypt(src, key, {
            iv,
            mode: crypto.mode.CBC,
            padding: crypto.pad.Pkcs7,
        });
        return encrypted.ciphertext.toString().toUpperCase();
    },
    md5: function(str) {
        return crypto.MD5(str).toString();
    },
    decryptBuffer: function(buffer) {
        try {
            const result = [];
            const arr = buffer.split(encryptSpr);
            const header = JSON.parse(this.aesDecrypt(arr[0], baseKey, baseIv));
            header.key = crypto.enc.Hex.parse(header.key);
            header.iv = crypto.enc.Hex.parse(header.iv);
            arr.shift();
            const check = this.md5(arr.join(encryptSpr));
            if (check !== header.check) throw '文件被篡改';
            for (const a of arr) {
                result.push(JSON.parse(this.aesDecrypt(a, header.key, header.iv)));
            }
            return header.data === 'array' ? result : result[0];
        } catch(err) {
            throw err;
        }
    },
    getRamdonHeader: function () {
        return {
            key: crypto.lib.WordArray.random(16),
            iv: crypto.lib.WordArray.random(16),
        };
    },
    encryptBuffer: function(data) {
        const datas = data instanceof Array ? data : [data];
        const header = this.getRamdonHeader();
        const arr = [];
        for (const d of datas) {
            arr.push(this.aesEncrypt(JSON.stringify(d), header.key, header.iv ));
        }
        header.key = header.key.toString();
        header.iv = header.iv.toString();
        header.check = this.md5(arr.join(encryptSpr));
        header.data = data instanceof Array ? 'array' : 'object';
        return this.aesEncrypt(JSON.stringify(header), baseKey, baseIv) + encryptSpr + arr.join(encryptSpr);
    },
};

class baseFile {
    doDecrypt(str) {

    }
    async decrypt(file) {
        const str = await fs.readFileSync(file, 'utf-8');
        return this.doDecrypt(str);
    }
    async recursiveMkdirSync(pathName) {
        if (!fs.existsSync(pathName)) {
            const upperPath = path.dirname(pathName);
            if (!fs.existsSync(upperPath)) {
                await this.recursiveMkdirSync(upperPath);
            }
            await fs.mkdirSync(pathName);
        }
    }
    doEncrypt(data) {

    }
    async encrypt(data, file) {
        const buffer = this.doEncrypt(data);
        // 检查文件夹是否存在，不存在则直接创建文件夹
        const pathName = path.dirname(file);
        if (!fs.existsSync(pathName)) await this.recursiveMkdirSync(pathName);
        await fs.writeFileSync(file, buffer);
    }
}

class cpd extends baseFile {
    doEncrypt(data) {
        return baseUtils.encryptBuffer(data);
    }
    doDecrypt(str) {
        return baseUtils.decryptBuffer(str);
    }
}

module.exports = {
    cpd
};