node.js - 非同期関数はNodeJSで操作を並列化しますか?

Question

私の学校の課題では、キーを見つけるために SHA1 ハッシュをブルートフォースする任務を負っています。
フラグ (SHA1) とパスワード (SHA1) が提供され、キーは [AAAAAA-ZZZZZZ] であることがわかりました。フラグは SHA1(PASSWORD_KEY) の形式でした。
レインボー テーブル メソッドでパスワードを取得できたので、今度は AAAAAA-ZZZZZZ からキーをブルートフォースする必要があります。以下は私が思いついたコードです

function guess(flag, password) {
    for (let char1 = 65; char1 <= 90; 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 key_guess = String.fromCharCode(char1, char2, char3, char4, char5, char6);
                            const guess = `${password}_${key_guess}`;

                            const shasum = crypto.createHash('sha1');
                            shasum.update(guess);
                            const hashed_guess = shasum.digest('hex');

                            if (hashed_guess === flag) {
                                return key_guess;
                            }
                        }
                    }
                }
            }
        }
    }
}

これは機能しますが、キーをクラックするのに私のPCから23秒かかりました. これをnodejsで書いているので、プロミスラッピングを利用してブルートフォースを複数のコアにオフロードすることを考えました（AMD 5600xを使用しているため、6つの物理コアがあります）ので、このコードを思いつきました

async function guessKey(flag, password) {
    return new Promise(async (resolve) => {
        async function guessPromise(startCharAscii, endCharAscii) {
            return new Promise((resolve) => {
                for (let char1 = startCharAscii; char1 <= endCharAscii; 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 key_guess = String.fromCharCode(char1, char2, char3, char4, char5, char6);
                                        const guess = `${password}_${key_guess}`;

                                        const shasum = crypto.createHash('sha1');
                                        shasum.update(guess);
                                        const hashed_guess = shasum.digest('hex');

                                        if (hashed_guess === flag) {
                                            resolve(key_guess);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            });
        }

        const NUMBER_OF_CORES = 6;
        const promiseList = [];
        let startCharAscii = 65;

        // 6 cores
        for (let i = 0; i < NUMBER_OF_CORES; i++) {
            // split into 5, 5, 4, 4, 4, 4
            // btwn cores 0, 1, 2, 3, 4, 5

            // core 0: [65, 69]
            // core 1: [70, 74]
            // core 2: [75, 78]
            // core 3: [79, 82]
            // core 4: [83, 86]
            // core 5: [87, 90]

            if (i === 0 || i === 1) {
                // 5 letters
                promiseList.push(guessPromise(startCharAscii, startCharAscii + 4));
                startCharAscii += 5;
            } else {
                promiseList.push(guessPromise(startCharAscii, startCharAscii + 3));
                startCharAscii += 4;
            }
        }

        await Promise.all(promiseList);
        resolve(promiseList.find((x) => x !== undefined));
    });
}

(async () => {
    console.time(`time`);
    console.log(await guessKey(flag, password));
    console.timeEnd(`time`);
})();

しかし、保留中のプロミスをリストにプッシュするには、永遠に時間がかかるようです。何か足りないのでしょうか、それとも nodeJS の非同期操作はマルチコアを利用していませんか?