Generazione dello stesso UUID SHA1 in golang e Javascript

Question

Ho quello che pensavo fosse una semplice domanda. Sto usando questo codice per generare un UUID SHA1 in Golang:

namespace := uuid.Parse("b9cfdb9d-f741-4e1f-89ae-fac6b2a5d740") 
sha := uuid.NewSHA1(namespace, []byte("something")) 
fmt.Println(sha.String()) 

Ora voglio generare lo stesso UUID in javascript, e ho pensato che sarebbe stato facile come qualcosa di simile a questo:

var hash = CryptoJS.SHA1("b9cfdb9d-f741-4e1f-89ae-fac6b2a5d740" + "something") 
// chomp the hash into a UUID string 

Tuttavia, sto riscontrando seri problemi. Sembra che la funzione uuid.Parse in Golang sia in esecuzione this parsing function che converte lo spazio dei nomi in una matrice a 16 byte, quindi anche se utilizzo lo stesso algoritmo SHA1 in Javascript, non ottengo lo stesso risultato.

Mi sono scontrato con fare lo stesso in JS, ma sono perplesso.

Qualsiasi persona cripto intelligente qui che può aiutarmi?

Answer 1

Beh, mi ci è voluto solo un mese.

var SHA1Generator = { 

    hex_chr: "abcdef", 

    hex: function (num) { 
     var str = ""; 
     for (var j = 7; j >= 0; j--) 
      str += this.hex_chr.charAt((num >> (j * 4)) & 0x0F); 
     return str; 
    }, 


    str2blks_SHA1: function (str) { 
     var nblk = ((str.length + 8) >> 6) + 1; 
     var blks = new Array(nblk * 16); 
     for (var i = 0; i < nblk * 16; i++) blks[i] = 0; 
     for (i = 0; i < str.length; i++) 
      blks[i >> 2] |= str.charCodeAt(i) << (24 - (i % 4) * 8); 
     blks[i >> 2] |= 0x80 << (24 - (i % 4) * 8); 
     blks[nblk * 16 - 1] = str.length * 8; 
     return blks; 
    }, 


    add: function (x, y) { 
     var lsw = (x & 0xFFFF) + (y & 0xFFFF); 
     var msw = (x >> 16) + (y >> 16) + (lsw >> 16); 
     return (msw << 16) | (lsw & 0xFFFF); 
    }, 


    rol: function (num, cnt) { 
     return (num << cnt) | (num >>> (32 - cnt)); 
    }, 


    ft: function (t, b, c, d) { 
     if (t < 20) return (b & c) | ((~b) & d); 
     if (t < 40) return b^c^d; 
     if (t < 60) return (b & c) | (b & d) | (c & d); 
     return b^c^d; 
    }, 


    kt: function (t) { 
     return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : 
     (t < 60) ? -1894007588 : -899497514; 
    }, 

    calcSHA1FromByte: function(byteArr) { 
     var str = ''; 
     for(var i=0; i<byteArr.length; i++) 
      str += String.fromCharCode(byteArr[i]); 
     return this.calcSHA1(str); 
    }, 

    calcSHA1: function (str) { 
     if (str != '') { 
      var x = this.str2blks_SHA1(str); 
      var w = new Array(80); 

      var a = 1732584193; 
      var b = -271733879; 
      var c = -1732584194; 
      var d = 271733878; 
      var e = -1009589776; 

      for (var i = 0; i < x.length; i += 16) { 
       var olda = a; 
       var oldb = b; 
       var oldc = c; 
       var oldd = d; 
       var olde = e; 

       for (var j = 0; j < 80; j++) { 
        if (j < 16) w[j] = x[i + j]; 
        else w[j] = this.rol(w[j - 3]^w[j - 8]^w[j - 14]^w[j - 16], 1); 
        t = this.add(this.add(this.rol(a, 5), this.ft(j, b, c, d)), this.add(this.add(e, w[j]), this.kt(j))); 
        e = d; 
        d = c; 
        c = this.rol(b, 30); 
        b = a; 
        a = t; 
       } 

       a = this.add(a, olda); 
       b = this.add(b, oldb); 
       c = this.add(c, oldc); 
       d = this.add(d, oldd); 
       e = this.add(e, olde); 
      } 
      return this.hex(a) + this.hex(b) + this.hex(c) + this.hex(d) + this.hex(e); 
     } 
     else { 
      return ''; 
     } 
    } 
}; 

function stringToByteArray(str) { 
    var bytes = []; 
    for (var i = 0; i < str.length; ++i) { 
     bytes.push(str.charCodeAt(i)); 
    } 
    return bytes; 
} 

function uuidToByteArray(hex) { 

    // If this is a uuid, remove the dashes 
    hex = hex.replace(/-/g, ""); 

    // convert each hex number into a string representation 
    // of the byte integer. 
    var bytes = []; 
    for(var i = 0; i < hex.length; i += 2) { 
    bytes.push(parseInt(hex.substring(i, i+2),16)); 
    } 

    return bytes; 
} 

function sha1ToUUID5(hash) { 
    var uuid = hash.substring(0, 8) + 
    '-' + hash.substring(8, 12) + 
    // four most significant bits holds version number 5 
    '-' + ((parseInt(hash.substring(12, 16), 16) & 0x0fff) | 0x5000).toString(16) + 
    // two most significant bits holds zero and one for variant DCE1.1 
    '-' + ((parseInt(hash.substring(16, 20), 16) & 0x3fff) | 0x8000).toString(16) + 
    '-' + hash.substring(20, 32); //12 digits 
    return uuid; 
} 

var namespace = "e75a36a9-3323-40dd-a7d1-1c57ad2aa3cd" 
var id = "event154" 

var namespaceBytes = uuidToByteArray(namespace); 
var idBytes = stringToByteArray(id); 
var allBytes = namespaceBytes.concat(idBytes); 

console.log("ORG 4505612c-c323-5d6f-b5cc-b7f362b9ba55") 
console.log("NEW " + sha1ToUUID5(SHA1Generator.calcSHA1FromByte(allBytes)))