node.js - 这是使用 openpgp.js 加密二进制文件的可能方法以及如何保存文件以便它也可以在 Filebrowser 中处理 'manual' ？

Question

我正在尝试读取二进制文件，加密/解密并保存/写入它。将原始文件与解密结果文件进行比较会得到相同的文件哈希值。所以我认为这是一个正确/可能的方法。

如果我尝试在 Windows 中使用 GnuPG 手动解密文件，则表明该文件已验证，但未保存任何可用文件。所以我的问题是:我如何存储也可以“手动”使用的文件。

使用的来源

我的代码基于以下帖子: https://commscentral.net/tech/?post=64

-> example code of post on GitHub

但我读到了处理二进制文件/有效负载的内容:

openpgp.message.fromBinary()

应使用

。-> https://github.com/openpgpjs/openpgpjs/issues/204#issuecomment-43065260

我的代码

导入

const fs = require('fs');
const util = require('util');
const readFile = util.promisify(fs.readFile);
const writeFile = util.promisify(fs.writeFile);
const openpgp = require('openpgp') // use as CommonJS, AMD, ES6 module or via window.openpgp

加密

const encryptFuntion = async() => {
    openpgp.initWorker({ path:'openpgp.worker.js' }) // set the relative web worker path
    const pubkey = await readFile('pub.asc','utf8');
    const passphrase = `password`;
    const privkey = await readFile('priv.asc','utf8');
    const privKeyObj = (await openpgp.key.readArmored(privkey)).keys[0];
    await privKeyObj.decrypt(passphrase);
    const file = await readFile('test.txt');
    const fileArray = new Uint8Array(file);

    const options = {
        message: openpgp.message.fromBinary(fileArray),
        publicKeys: (await openpgp.key.readArmored(pubkey)).keys,
        privateKeys: [privKeyObj],
        armor:false
    };
    const encryptionResponse = await openpgp.encrypt(options);
    const encryptedFile = encryptionResponse.message.packets.write();
    await writeFile('test.txt.gpg',encryptedFile);
};

解密

const decryptFuntion = async () => {
    openpgp.initWorker({path: 'openpgp.worker.js'}) // set the relative web worker path
    const passphrase = `password`;
    const privkey = await readFile('priv.asc', 'utf8');
    const pubkey = await readFile('pub.asc', 'utf8');
    const privKeyObj = (await openpgp.key.readArmored(privkey)).keys[0];
    await privKeyObj.decrypt(passphrase);
    const file = await readFile('test.txt.gpg');
    const fileArray = new Uint8Array(file);
    options = {
        message: await openpgp.message.read(file), // parse encrypted bytes
        privateKeys: [privKeyObj],              // decrypt with password
        publicKeys: (await openpgp.key.readArmored(pubkey)).keys,
        format: 'binary'                          // output as Uint8Array
    };
    const decryptionResponse = await openpgp.decrypt(options);
    const decryptedFile = decryptionResponse.data;
    await writeFile('test-decrypted.txt', decryptedFile);
};

Answer 1

希望这有帮助，根据我对 NodeJS 的了解对代码做了一些更改。

const fs = require('fs');
const openpgp = require('openpgp');
const async = require('async');

const encryptFuntion = () => {
    async.waterfall([
        (a_cb) => {
            fs.readFile('pub.asc', 'utf8', (err, pubkey) => {
                if (!err) {
                    a_cb(null, pubkey);
                } else {
                    a_cb(err);
                }
            });
        },
        (pubkey, a_cb) => {
            fs.readFile('priv.asc', 'utf8', (err, privkey) => {
                if (!err) {
                    const passphrase = `yourPassphrase`;
                    let privKeyObj = (await openpgp.key.readArmored(privkey)).keys[0];
                    await privKeyObj.decrypt(passphrase);
                    a_cb(null, pubkey, privKeyObj);
                } else {
                    a_cb(err);
                }
            });
        },
        (pubkey, privKeyObj, a_cb) => {
            fs.readFile('test.txt', 'utf8', (err, rawMessage) => {
                if (!err) {
                    a_cb(null, pubkey, privKeyObj, rawMessage);
                } else {
                    a_cb(err);
                }
            });
        },
        (pubkey, privKeyObj, message, a_cb) => {
            let options = {
                message: openpgp.message.fromText(message),
                publicKeys: (await openpgp.key.readArmored(pubkey)).keys,
                privateKeys: [privKeyObj],
                armor: false
            };
            openpgp.encrypt(options)
                .then((ciphertext) => {
                    a_cb(null, ciphertext);
                });
        }
    ], (err, ciphertext) => {
        if (!err) {
            fs.writeFile('test.txt.gpg', ciphertext.data, (err) => {
                if (!err) {
                    console.log('Created GPG file!');
                } else {
                    console.log(err);
                }
            });
        } else {
            console.log(err);
        }
    });
};

const decryptFuntion = () => {
    async.waterfall([
        (a_cb) => {
            fs.readFile('test.txt.gpg', (err, encrypted) => {
                if (!err) {
                    a_cb(null, encrypted);
                } else {
                    a_cb(err);
                }
            });
        },
        (encrypted, a_cb) => {
            fs.readFile('pub.asc', 'utf8', (err, pubkey) => {
                if (!err) {
                    a_cb(null, encrypted, pubkey);
                } else {
                    a_cb(err);
                }
            });
        },
        (encrypted, pubkey, a_cb) => {
            fs.readFile('priv.asc', 'utf8', (err, privkey) => {
                if (!err) {
                    const passphrase = `yourPassphrase`;
                    let privKeyObj = (await openpgp.key.readArmored(privkey)).keys[0];
                    await privKeyObj.decrypt(passphrase);
                    a_cb(null, encrypted, pubkey, privKeyObj);
                } else {
                    a_cb(err);
                }
            });
        },
        (encrypted, pubkey, privKeyObj, a_cb) => {
            let options = {
                message: await openpgp.message.readArmored(encrypted),
                publicKeys: (await openpgp.key.readArmored(pubkey)).keys,
                privateKeys: [privKeyObj]
            };
            openpgp.decrypt(options)
                .then((plaintext) => {
                    a_cb(null, plaintext);
                });
        }
    ], (err, plaintext) => {
        if (!err) {
            fs.writeFile('test-decrypted.txt', plaintext, 'utf8', (err) => {
                if (!err) {
                    console.log('Created txt file!');
                } else {
                    console.log(err);
                }
            });
        } else {
            console.log(err);
        }
    });
};

module.exports = {
    encryptFuntion, decryptFuntion
};

我可能在文件内容类型上出错，将使用 fs.readFile

引用链接:1.Async waterfall2.Openpgp3.Node FS Module

PS:这是我每周学习新东西的方式，通过在 stackoverflow 重写代码。