Node.js 在单独线程上生成电子运行加密Diffie-Hellman密钥

在我的electron应用程序中，我通过以下方法创建Diffie-Hellman键：

const crypto = require('crypto');

/**
 * Generate the keys and the diffie hellman key agreement object.
 * @param {Integer} p The prime for Diffie Hellman Key Generation
 * @param {Integer} g The generator for Diffie Hellman Key Exchange
 */
async function createSelfKey(p, g, callback) {
  let returnVal = null;
  if (p && g) {
    returnVal = { dh: await crypto.createDiffieHellman(p, g) };
  } else {
    returnVal = { dh: await crypto.createDiffieHellman(2048) };
  }
  returnVal.keys = await returnVal.dh.generateKeys();
  return callback(returnVal);
};

但是密钥生成是一个计算量稍大的过程，因此它使我的应用程序冻结。用法的一个示例是，我尝试从以下函数实现此方法

generateCreatWorkeys

：

function ChatRoomStatus() {
  /**
   * @var {Object}
   */
  const chatrooms = {};

  // Some other logic
    /**
   * This Method fetched the creator of the Chatroom and executes a callback on it.
   * @param {String} chatroom The chatroom to fetch the creator
   * @param {Function} callback The callback of the chatroom.
   */
  this.processCreator = (chatroom, callback) => {
    const index = _.findIndex(chatrooms[chatroom].friends, (friend) => friend.creator);
    return callback(chatrooms[chatroom].friends[index], index , chatrooms[chatroom] );
  };


  /**
   * Generate keys for the Chatroom Creator:
   * @param {String} chatroom The chatroom to fetch the creator
   * @param {Function} callback The callback of the chatroom.
   */
  this.generateCreatorKeys =  (chatroom, callback) => {
    return this.processCreator(chatroom, (friend, index, chatroom) => {
       return createSelfKey(null, null, (cryptoValues) => {
        friend.encryption = cryptoValues;
        return callback(friend, index, chatroom);
       });
    });
  };
};

调用此方法的示例如下：

const { xml, jid } = require('@xmpp/client');

/**
 * Handling the message Exchange for group Key agreement 
 * @param {Function} sendMessageCallback 
 * @param {ChatRoomStatus} ChatroomWithParticipants 
 */
function GroupKeyAgreement(sendMessageCallback, ChatroomWithParticipants) {
  const self = this;
  /**
   * Send the Owner participant Keys into the Chatroom
   */
  self.sendSelfKeys = (chatroomJid, chatroomName) => {
    ChatroomWithParticipants.generateCreatorKeys(chatroomName, (creator) => {
      const message = xml('message', { to: jid(chatroomJid).bare().toString()+"/"+creator.nick });
      const extention = xml('x', { xmlns: 'http://pcmagas.tk/gkePlusp#intiator_key' });
      extention.append(xml('p', {}, creator.encryption.dh.getPrime().toString('hex')));
      extention.append(xml('g', {}, creator.encryption.dh.getGenerator().toString('hex')));
      extention.append(xml('pubKey', {}, creator.encryption.keys.toString('hex')));
      message.append(extention);
      sendMessageCallback(message);
    });
  };
};

module.exports = GroupKeyAgreement;

您知道如何以并行/独立线程“运行”函数

createSelfKey

，并通过回调提供其内容吗？此外，上面的代码在Electron的主进程上运行，因此冻结它会导致整个应用程序暂停一段时间

Electron基本上拥有从DOM和node.js到更多的内容，因此您有一些选择。一般来说，它们是：

Web工作者（仅渲染器进程）。如果在渲染器进程中执行此操作，则可以使用普通DOM web workers。这些都在一个单独的进程或线程中运行（不确定是哪个，这是chromium实现的细节，但它肯定不会阻塞您的UI）

看起来node.js worker_线程（仅渲染器进程？）现在也可以在Electron中使用。这可能也行，但从未亲自使用过

您始终可以创建另一个渲染器进程，并将其用作单独的“线程”，并通过IPC与之通信。工作完成后，你只需关闭它。您可以通过创建一个新的隐藏Browser窗口来实现这一点

使用node.js的cluster/child_进程模块启动一个新的节点进程，并使用它的内置IPC（而不是Electron）与之通信

---

因为您在主进程中运行此代码，并且假设无法将其移出，所以（据我所知）您唯一的选择是#3。如果您可以添加库，electron remote（）有一些很酷的功能，让您在后台启动一个（或多个）渲染器进程，获得结果作为承诺，然后为您关闭它们

我试图解决您的问题的最佳解决方案是基于以下代码：

---

正如您所见，使用npm中的库将为您提供所需的内容。这种方法唯一的缺点是不能将线程内生成的对象传递到线程范围之外。此外，执行线程的函数内部的代码是某种独立的代码，因此您可能需要重新包含您所需的任何库，如上文所示。

好的，代码不是在渲染器进程中运行的，而是在我的应用程序的后端上运行的。啊，所以它在主进程中。很遗憾，阻止主进程将阻止所有渲染器。我会更新我的答案。我还发现了一些方法，如，或

const crypto = require('crypto');
const spawn = require('threads').spawn;

/**
 * Generate the keys and the diffie hellman key agreement object.
 * @param {Integer} p The prime for Diffie Hellman Key Generation
 * @param {Integer} g The generator for Diffie Hellman Key Exchange
 * @param {Function} callback The callback in order to provide the keys and the diffie-hellman Object.
 */
const createSelfKey = (p, g, callback) => {

  const thread = spawn(function(input, done) {
    const cryptot = require('crypto');
    console.log(input);
    const pVal = input.p;
    const gVal = input.g;
    let dh = null;

    if (pVal && gVal) {
      dh = cryptot.createDiffieHellman(pVal, gVal);
    } else {
      dh = cryptot.createDiffieHellman(2048);
    }

    const pubKey = dh.generateKeys();
    const signaturePubKey = dh.generateKeys();
    done({ prime: dh.getPrime().toString('hex'), generator: dh.getGenerator().toString('hex'), pubKey, signaturePubKey});
  });

  return thread.send({p,g}).on('message', (response) => {
    callback( crypto.createDiffieHellman(response.prime, response.generator), response.pubKey, response.signaturePubKey);
    thread.kill();
  }).on('error', (err)=>{
    console.error(err);
  }).on('exit', function() {
    console.log('Worker has been terminated.');
  });
};