Generowanie tego samego identyfikatora UUID SHA1 w golang i Javascriptu

Question

Mam to, co uważałem za całkiem proste pytanie. Używam tego kodu do generowania UUID SHA1 w Golang:

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

teraz chcę, aby wygenerować ten sam UUID w JavaScript, a ja pomyślałem, że byłoby tak proste, jak coś takiego:

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

Jednak mam poważne problemy. Wygląda na to, że funkcja uuid.Parse w Golang działa pod kontrolą this parsing function, która przekształca przestrzeń nazw w 16-bajtową tablicę, więc nawet jeśli używam tego samego algorytmu SHA1 w JavaScript, nie otrzymuję tego samego wyniku.

Robiłem to samo w JS, ale jestem zdumiony.

Wszyscy inteligentni ludzie kryptografiści tutaj, którzy mogą mi pomóc?

Answer 1

Cóż, zajęło mi to tylko miesiąc.

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