Generieren der gleichen SHA1 UUID in Golang und Javascript

Question

Ich habe, was ich dachte, war eine ziemlich einfache Frage. Ich verwende diesen Code ein SHA1 UUID in Golang zu generieren:

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

Jetzt möchte ich die gleiche UUID in JavaScript generieren, und ich dachte, es so etwas wie das so einfach wäre:

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

Allerdings stoße ich auf ernsthafte Probleme. Es scheint, dass die uuid.Parse-Funktion in Golang this parsing function läuft, die den Namespace in ein 16-Byte-Array konvertiert, also obwohl ich den gleichen SHA1-Algorithmus in Javascript verwende, bekomme ich nicht die gleiche Ausgabe.

Ich habe mich damit beschäftigt, das gleiche in JS zu tun, aber ich bin ratlos.

Irgendwelche intelligenten Krypto Leute hier, die mir helfen können?

Answer 1

Nun, das dauerte nur einen Monat.

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