hmac.New(h func() hash.Hash, key byte) hash.Hash équivalent en JavaScript

En PHP, nous devons souvent utiliser des algorithmes de cryptage pour protéger la sécurité des données. HMAC (Hash-based Message Authentication Code) est un algorithme de cryptage couramment utilisé pour vérifier l'intégrité des données et l'authentification de l'identité. En PHP, nous pouvons créer une instance HMAC en utilisant la fonction hmac.New(), qui nécessite de spécifier une fonction de hachage et une clé. De même, en JavaScript, nous pouvons utiliser des méthodes équivalentes pour obtenir la même fonctionnalité. Dans cet article, je vais vous montrer comment créer une instance HMAC en utilisant des méthodes équivalentes en JavaScript, ainsi que comment chiffrer et déchiffrer des données entre PHP et JavaScript.

Contenu de la question

J'étais presque coincé dans l'implémentation js de go lang hmac.new pendant plusieurs jours. Cependant, cela n’a pas abouti. J'utilise crypto、crypto-js 和 stablelib 模块进行实现。问题是，在go lang版本中，hmac实例可以通过hmac la création d'instance. Par exemple (le bloc de code est correct et testé) :

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]))

En fait, je ne sais pas non plus comment ça marche ! Parce que dans tous les modules liés au javascript, vous ne pouvez pas obtenir de valeur de hmac 创建 hmac，并且它们接受确定哈希算法的 string .

Il serait peut-être préférable de demander comment obtenir de hmac创建hmac en javascript.

Quelle est la solution ?

Lorsque le résultat de la version go est le même que celui de votre implémentation, votre solution est correcte.

Solution de contournement

Selon la spécification (rfc 2104), hmac utilise des fonctions de digestion en interne, telles que sha256.

Cependant, votre implémentation applique (en fait est incompatible avec) un hmac qui utilise un autre hmac en interne au lieu de digest, où seul le hmac de niveau le plus bas utilise un digest régulier en interne. Cela crée une structure imbriquée.

Basé sur la spécification du hmac régulier (avec digest), cela peut être étendu à hmac avec hmac (au lieu de digest) utilisé dans le code go :

hmac(k xor opad, hmac(k xor ipad, text))s. rfc2104, Section 2. Définition de hmac

En raison des différences par rapport aux spécifications, il n'est peut-être pas si facile de trouver une bibliothèque javascript prenant en charge une telle fonctionnalité prête à l'emploi.
Bien que la plupart des bibliothèques prennent certainement en charge hmac, autorisez uniquement la spécification de résumés (pas de hmac), comme celui du module crypto de nodejs crypto.createhmac(), voir aussi autres réponses. Je ne pense pas que cette approche puisse être utilisée pour implémenter la logique dans le code Go.

Si les approches des autres réponses ne fonctionnent pas et que vous ne trouvez pas une autre bibliothèque javascript avec les fonctionnalités dont vous avez besoin, vous pouvez implémenter vous-même la logique en javascript, car la spécification de hmac est relativement simple (voir ci-dessus).

Le code suivant est un exemple d'implémentation du module crypto de nodejs :

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()
}

Résultat :

2e631dcb4289f8256861a833ed985fa945cd714ebe7c3bd4ed4b4072b107b073

Test :

Le code go suivant produit le même résultat :

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
}

Éditeur :

Inspiré de cet article, le suivant est hmac_rec() 的更紧凑/高效的实现，它使用常规最后一个迭代步骤的 hmac（这也使得 gethash() obsolète) :

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 
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!