JavaScript中的等效方法：使用hmac.new函数创建哈希实例，参数为哈希函数h和密钥key

差点在go lang hmac.new的js实现中卡住好几天了。然而，没有成功。我使用 crypto、crypto-js 和 stablelib 模块进行实现。问题是，在go lang版本中，hmac实例可以通过hmac实例创建。例如（代码块正确且经过测试）：

hmacf := hmac.New(func() hash.Hash {
    return hmac.New(func() hash.Hash {
        return hmac.New(func() hash.Hash {
            return hmac.New(sha256.New, []byte(SALT))
        }, []byte(path[0]))
    }, []byte(path[1]))
}, []byte(path[2]))

其实我也不知道它是怎么工作的！因为在所有与 javascript 相关的模块中，您无法从 hmac 创建 hmac，并且它们接受确定哈希算法的 string 值。

也许最好问一下如何在javascript中从hmac创建hmac。

解决方案是什么？

当 go 版本的输出与你的实现的输出相同时；您的解决方案是正确的。

正确答案

根据规范 (rfc 2104)，hmac 使用摘要函数内部，例如sha256。

但是，您的实现应用了（实际上不兼容）内部使用另一个 hmac 而不是摘要的 hmac，其中只有最低级别的 hmac 在内部使用常规摘要。这样就创建了一个嵌套结构。

基于常规 hmac（带有摘要）的规范，这可以扩展到 go 代码中使用的带有 hmac（而不是摘要）的 hmac：

hmac(k xor opad, hmac(k xor ipad, text)) s。 rfc2104，第 2 节。hmac 的定义

由于与规范的差异，找到一个开箱即用的支持此类功能的 javascript 库可能不会那么容易。
虽然大多数库当然支持 hmac，但只允许指定摘要（而不是 hmac），例如nodejs的crypto模块的crypto.createhmac()，参见还有其他答案。我认为这种方法不能用于实现 go 代码中的逻辑。

如果其他答案的方法不起作用，并且您找不到另一个具有所需功能的 javascript 库，您可以自己在 javascript 中实现逻辑，因为 hmac 的规范相对简单（见上文） ）。

以下代码是 nodejs 的 crypto 模块的示例实现：

var crypto = require('crypto')

const digest = 'sha256'
const blocksize = 64 // block size of the digest

// define input parameter
var salt = buffer.from('salt')
var path = [ buffer.from('alfa'), buffer.from('beta'), buffer.from('gamma') ]
var data = buffer.from('data')

// calculate hmac
var hmac = hmac(data, salt, path)
console.log(hmac.tostring('hex'))

function hmac(data, salt, path) {
    
    // create keylist
    var keylist = []
    keylist.push(salt)
    keylist = keylist.concat(path)

    // determine hmac recursively
    var result = hmac_rec(data, keylist)
    return result
}

function hmac_rec(data, keylist) {

    // adjust key (according to hmac specification)
    var key = keylist.pop()
    if (key.length > blocksize) {        
        k = buffer.allocunsafe(blocksize).fill('x00');
        if (keylist.length > 0) {
            hmac_rec(key, [...keylist]).copy(k)
        } else {
            gethash(key).copy(k)
        }
    } else if (key.length < blocksize) {
        k = buffer.allocunsafe(blocksize).fill('x00');
        key.copy(k)
    } else {
        k = key
    }

    // create 'key xor ipad' and 'key xor opad' (according to hmac specification)  
    var ik = buffer.allocunsafe(blocksize)
    var ok = buffer.allocunsafe(blocksize)
    k.copy(ik)
    k.copy(ok)
    for (var i = 0; i < ik.length; i++) {
        ik[i] = 0x36 ^ ik[i] 
        ok[i] = 0x5c ^ ok[i]
    }

    // calculate hmac
    if (keylist.length > 0) {
        var innerhmac = hmac_rec(buffer.concat([ ik, data ]), [...keylist]) 
        var outerhmac = hmac_rec(buffer.concat([ ok, innerhmac ]), [...keylist])
    } else {
        var innerhmac = gethash(buffer.concat([ik, data]))
        var outerhmac = gethash(buffer.concat([ok, innerhmac]))
    }
  
    return outerhmac 
}

// calculate sha256 hash
function gethash(data){
    var hash = crypto.createhash(digest);
    hash.update(data)
    return hash.digest()
}

结果：

2e631dcb4289f8256861a833ed985fa945cd714ebe7c3bd4ed4b4072b107b073

测试：

以下 go 代码产生相同的结果：

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "hash"
)

func main() {
    salt := "salt"
    path := []string{"alfa", "beta", "gamma"}
    hmacf := hmac.new(func() hash.hash {
        return hmac.new(func() hash.hash {
            return hmac.new(func() hash.hash {
                return hmac.new(sha256.new, []byte(salt))
            }, []byte(path[0]))
        }, []byte(path[1]))
    }, []byte(path[2]))
    hmacf.write([]byte("data"))
    result := hmacf.sum(nil)
    fmt.println(hex.encodetostring(result)) // 2e631dcb4289f8256861a833ed985fa945cd714ebe7c3bd4ed4b4072b107b073
}

编辑：

受这篇文章的启发，以下是 hmac_rec() 的更紧凑/高效的实现，它使用常规最后一个迭代步骤的 hmac（这也使得 gethash() 过时）：

function hmac_rec(data, keyList) {
    var key = keyList.pop()
    if (keyList.length > 0) {
        
        // adjust key (according to HMAC specification)
        if (key.length > blockSize) {        
            k = Buffer.allocUnsafe(blockSize).fill('x00');
            hmac_rec(key, [...keyList]).copy(k)
        } else if (key.length < blockSize) {
            k = Buffer.allocUnsafe(blockSize).fill('x00');
            key.copy(k)
        } else {
            k = key
        }
    
        // create 'key xor ipad' and 'key xor opad' (according to HMAC specification)  
        var ik = Buffer.allocUnsafe(blockSize)
        var ok = Buffer.allocUnsafe(blockSize)
        k.copy(ik)
        k.copy(ok)
        for (var i = 0; i < ik.length; i++) {
            ik[i] = 0x36 ^ ik[i] 
            ok[i] = 0x5c ^ ok[i]
        }

        // calculate HMAC
        var innerHMac = hmac_rec(Buffer.concat([ ik, data ]), [...keyList]) 
        var outerHMac = hmac_rec(Buffer.concat([ ok, innerHMac ]), [...keyList])
    } else {
        var outerHMac = crypto.createHmac(digest, key).update(data).digest();
    }  
    return outerHMac 
}