在 nodeJS 中验证 Identity Server 3/4 哈希

Question

我正在尝试编写一个库来模仿 nodeJS 中 identity server 3 的验证功能，但我正在努力验证生成的缓冲区。

我不确定为什么，但我得到了一个完全不同的长度缓冲区，尽管遵循了我认为是等效的。
pbkdf2 函数作为异步任务运行在迭代过程中可能会有不同的行为。
pbkdf2 函数可能正在实施不同版本的 sha256，或者根本不是 hmac。
我搞砸了缓冲区管理并在 salt / subkey 之间吐了口水。
这种意义上的复制可能不像 blockcopy 在上述 identity server 3

虽然请注意，我要验证的哈希值是直接从 Identity Server 3 中的一个单独的应用程序中获取的，该应用程序是从 ABP boilerplate 启动的，但根据我自己的研究，我不相信它们实施自定义哈希算法或更改设置。我用来转换的 c# 代码参考可以在这里找到：

https://github.com/aspnet/Identity/blob/rel/2.0.0/src/Microsoft.Extensions.Identity.Core/PasswordHasher.cs#L248

通过对使用更普通算法进行检查的身份服务器 2 等效项的进一步研究，我注意到人们报告说他们必须更改编码，但在测试中这仍然无法正常工作。

使用此处 class 中包含的 hashpassword 函数进行的进一步测试表明，返回的缓冲区长度为 61，而在验证解码缓冲区的大小为 84 时，听起来像是某种形式的不匹配编码或其他内容丢失字节的地方。

下面是我的 class 散列和验证。

import crypto from 'crypto';
import util from 'util';

const pbkdf2Async = util.promisify(crypto.pbkdf2);

export default class HashPasswordv3 {   

    async verifyPassword(password, hashedPassword) {

        let decodedBuffer = null;

        if (hashedPassword) {
            decodedBuffer = Buffer.from(hashedPassword, 'base64');
        }

        let iteration = 10000;
        let key = decodedBuffer[0];
        let saltLength = this.readNetworkByteOrder(decodedBuffer, 9);

        if (saltLength < 128 / 8) {
            return false;
        }

        let salt = new Buffer(saltLength);

        // take the salt from the stored hash in the database.
        // we effectively overwrite the bytes here from our random buffer.
        decodedBuffer.copy(salt, 13, 0, saltLength);

        console.log(salt);

        let subkeyLength = hashedPassword.length - 13 - saltLength;

        if (subkeyLength < 128 / 8) {
            return false;
        }

        let expectedSubkey = new Buffer(subkeyLength);

        decodedBuffer.copy(expectedSubkey, 0, 13 + saltLength, expectedSubkey.length);

        console.log(expectedSubkey);

        let acutalSubkey = await pbkdf2Async(password, salt, 10000, 32, 'sha256');

        console.log(acutalSubkey);

        console.log(this.areBuffersEqual(acutalSubkey, expectedSubkey));

    }

    async hashPassword(password) {

        try {
            // Create a salt with cryptographically secure method.
            let salt = await crypto.randomBytes(16);

            let subkey = await pbkdf2Async(password, salt, 10000, 32, 'sha256');

            let outputBytes = new Buffer(13 + salt.length + subkey.length);

            // Write in the format marker
            outputBytes[0] = 0x01;

            // Write out the byte order
            this.writeNetworkByteOrder(outputBytes, 1, 1);
            this.writeNetworkByteOrder(outputBytes, 5, 10000);
            this.writeNetworkByteOrder(outputBytes, 9, salt.length);

            salt.copy(outputBytes, 13, 0, 16);
            subkey.copy(outputBytes, 13 + salt.length, 0, subkey.length);

            console.log(outputBytes.toString('base64'));


        } catch (e) {
            console.log(e);
        }

    }

    /**
     * Writes the appropriate bytes into available slots
     * @param buffer
     * @param offset
     * @param value
     */
    writeNetworkByteOrder(buffer, offset, value) {
        buffer[offset + 0] = value >> 0;
        buffer[offset + 1] = value >> 8;
        buffer[offset + 2] = value >> 16;
        buffer[offset + 3] = value >> 24;
    }

    /**
     * Reads the bytes back out using an offset.
     * @param buffer
     * @param offset
     * @returns {number}
     */
    readNetworkByteOrder(buffer, offset) {
        return ((buffer[offset + 0]) << 24)
            | ((buffer[offset + 1]) << 16)
            | ((buffer[offset + 2]) << 8)
            | ((buffer[offset + 3]));
    }

    /**
     * Confirms if two byte arrays are equal.
     * @param a
     * @param b
     * @returns {boolean}
     */
    byteArraysEqual(a, b) {
        if (Buffer.compare(a, b)) {
            return true;
        }

        if (a == null || b == null || a.Length !== b.Length) {
            return false;
        }

        let areSame = true;
        for (let i = 0; i < a.Length; i++) {
            areSame &= (a[i] === b[i]);
        }

        return areSame;
    }

    /**
    * Checks to see if the buffers are equal when read out from uint.
    * @param a
    * @param b
    */
    areBuffersEqual(bufA, bufB) {
        let len = bufA.length;
        if (len !== bufB.length) {
            return false;
        }
        for (let i = 0; i < len; i++) {
            if (bufA.readUInt8(i) !== bufB.readUInt8(i)) {
                return false;
            }
        }
        return true;
    }

}

实现如下，可用于测试：

import identityHasher from '../IdentityServer3/HashPasswordv3';

const hasher = new identityHasher();

let result = await hasher.verifyPassword('test', 'AQAAAAEAACcQAAAAEGKKbVuUwa4Y6qIclGpTE95X6wSw0mdwhMjXMBpAnHrjrQlHngJCgeuTf52w91UruA==');

Answer 1

你的实现在逻辑上是正确的，但有一些小问题，都与算法实现无关：

第一个

decodedBuffer.copy(salt, 13, 0, saltLength);

应该是

// copy data from "decodedBuffer" buffer to "salt" buffer,    
// from position 13, up to position 13 + saltLength of "decodedBuffer"
// to position 0 of "salt" buffer
decodedBuffer.copy(salt, 0, 13, 13 + saltLength);

只是因为它做了你想要的事情（从源数组中的位置 13 提取盐），而你当前的版本做的事情完全不同。我想你搞砸了这个函数的签名。

第二

let subkeyLength = hashedPassword.length - 13 - saltLength;

您已经在使用缓冲区，但使用 hashedPassword 的长度，这是 base-64 字符串。这是不正确的（因为它表示的 base-64 字符串的长度和字节数组的长度不同）应该是：

let subkeyLength = decodedBuffer.length - 13 - saltLength;

第三

decodedBuffer.copy(expectedSubkey, 0, 13 + saltLength, expectedSubkey.length);

同第一个故事，应该是：

decodedBuffer.copy(expectedSubkey, 0, 13 + saltLength, 13 + saltLength + expectedSubkey.length);

通过此更改，它将按预期工作。

在 nodeJS 中验证 Identity Server 3/4 哈希

Verifying Identity Server 3/4 hash in nodeJS

javascript

c#

buffer

node.js

identityserver4