Javascript 验证nodeJS中的Identity Server 3/4哈希
我试图编写一个库,模仿Javascript 验证nodeJS中的Identity Server 3/4哈希,javascript,c#,node.js,buffer,identityserver4,Javascript,C#,Node.js,Buffer,Identityserver4,我试图编写一个库,模仿nodeJS中identity server 3的验证功能,但我正在努力验证生成的缓冲区 我不知道为什么,但是我得到了一个完全不同的长度缓冲区,尽管我相信它是等效的 作为异步任务运行的pbkdf2函数在迭代过程中可能具有不同的行为 pbkdf2函数可能正在实现不同版本的sha256,或者根本不是hmac 我搞砸了缓冲区管理,在salt/subkey之间吐出了数据 从这个意义上讲,复制可能不像identity server 3 尽管注意到我试图验证的散列是直接从Identit
nodeJS
中identity server 3
的验证功能,但我正在努力验证生成的缓冲区
pbkdf2
函数在迭代过程中可能具有不同的行为pbkdf2
函数可能正在实现不同版本的sha256,或者根本不是hmacidentity server 3
Identity Server 3
中获取的,该应用程序是从ABP样板文件启动的,但根据我自己的研究,我不相信他们实现了自定义散列算法或更改了设置。我用来转换的c#
代码参考可以在这里找到:
随着对identity server 2等价物的进一步研究,它使用了一种更普通的算法进行检查,我注意到有人报告说他们必须更改编码,但在测试中,这仍然不起作用
使用类中包含的hashpassword函数进行的进一步测试表明,返回的缓冲区长度为61,而验证解码的缓冲区大小为84时,听起来像某种形式的编码不匹配或丢失字节
下面是我的哈希和验证类
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;
}
}
您的实现在逻辑上是正确的,但存在一些小问题,所有这些问题都与算法实现无关:
首先
应该是
// 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, 13 + saltLength + expectedSubkey.length);
第三
与第一个相同的故事应该是:
let subkeyLength = decodedBuffer.length - 13 - saltLength;
decodedBuffer.copy(expectedSubkey, 0, 13 + saltLength, 13 + saltLength + expectedSubkey.length);
有了这些更改,它将按预期工作。我想对缓冲区来说可能是这么简单的事情,要解决字节比较问题,如果可行的话,我将接受。按预期工作,非常感谢您的回答。
decodedBuffer.copy(expectedSubkey, 0, 13 + saltLength, 13 + saltLength + expectedSubkey.length);