Node.js异步函数能否实现操作并行？SHA1暴力破解多核优化疑问

• Node.js 的普通 Promise/async 异步语法仅运行在主线程的事件循环中，不会创建新线程，完全无法利用多核CPU。你代码里的6层for循环是CPU密集型同步任务，调用guessPromise时会立刻同步执行，直到这段任务跑完才会返回Promise，所以你推第一个Promise的时候就已经把主线程堵死了，根本不会并发执行，甚至比单循环版本更慢。
• 你对Promise的执行逻辑理解有误：Promise构造函数里的代码是同步立即执行的，不是等到await的时候才运行，所以你以为是推入pending状态的Promise，实际上代码已经开始同步跑计算任务了，自然耗时极长。

Node.js 提供了worker_threads核心模块，专门用于创建独立的工作线程，才能真正利用多核CPU性能。你需要把计算任务拆分到不同的工作线程中运行，主线程负责调度和接收结果。

优化实现示例 #

第一步：编写工作线程文件 hash-crack-worker.js #

const { parentPort } = require('worker_threads');
const crypto = require('crypto');

parentPort.on('message', (task) => {
  const { flag, password, startChar, endChar } = task;
  const prefix = `${password}_`;
  for (let char1 = startChar; char1 <= endChar; char1++) {
    for (let char2 = 65; char2 <= 90; char2++) {
      for (let char3 = 65; char3 <= 90; char3++) {
        for (let char4 = 65; char4 <= 90; char4++) {
          for (let char5 = 65; char5 <= 90; char5++) {
            for (let char6 = 65; char6 <= 90; char6++) {
              const keyGuess = String.fromCharCode(char1, char2, char3, char4, char5, char6);
              const hash = crypto.createHash('sha1').update(prefix + keyGuess).digest('hex');
              if (hash === flag) {
                parentPort.postMessage(keyGuess);
                return;
              }
            }
          }
        }
      }
    }
  }
  parentPort.postMessage(null);
});

第二步：编写主线程调度代码 #

const { Worker } = require('worker_threads');
const CPU_CORES = 6;
// 替换为你实际的flag和已获取的密码
const TARGET_FLAG = '你的sha1格式flag';
const KNOWN_PASSWORD = '你拿到的密码';

async function guessKey() {
  return new Promise((resolve) => {
    const workers = [];
    let startChar = 65;
    // 沿用你之前的拆分逻辑，2个线程各处理5个首字母，剩余4个各处理4个
    const taskSplits = [5,5,4,4,4,4];

    for (let i = 0; i < CPU_CORES; i++) {
      const endChar = startChar + taskSplits[i] - 1;
      const worker = new Worker('./hash-crack-worker.js');
      workers.push(worker);

      worker.postMessage({
        flag: TARGET_FLAG,
        password: KNOWN_PASSWORD,
        startChar,
        endChar
      });

      worker.on('message', (result) => {
        if (result) {
          // 找到结果直接终止所有线程，无需等待剩余任务
          workers.forEach(w => w.terminate());
          resolve(result);
        }
      });

      startChar = endChar + 1;
    }
  });
}

(async () => {
  console.time('crack time');
  const key = await guessKey();
  console.log('找到密钥：', key);
  console.timeEnd('crack time');
})();

• 可以进一步优化哈希计算逻辑：提前计算password_的哈希上下文，复用上下文计算后缀，减少重复计算量，速度可再提升10%~20%。
• 可以根据你的CPU核心数调整任务拆分粒度，尽量让每个线程的任务量均匀，避免出现木桶效应。

内容的提问来源于stack exchange，提问作者CXY