गोलांग और जावास्क्रिप्ट

Question

में एक ही SHA1 UUID उत्पन्न करना मेरे पास एक बहुत ही सरल सवाल था। मैं Golang में एक SHA1 UUID उत्पन्न करने के लिए इस कोड का उपयोग कर रहा हूँ:

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

अब मैं जावास्क्रिप्ट में एक ही UUID उत्पन्न करने के लिए चाहते हैं, और मैंने सोचा था कि यह कुछ इस तरह के रूप में के रूप में आसान होगा:

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

हालांकि, मैं गंभीर मुद्दों में भाग रहा हूं। ऐसा लगता है कि गोलांग में uuid.Parse फ़ंक्शन this parsing function चला रहा है जो नामस्थान को 16-बाइट सरणी में परिवर्तित करता है, भले ही मैं जावास्क्रिप्ट में एक ही SHA1 एल्गोरिदम का उपयोग करता हूं, मुझे एक ही आउटपुट नहीं मिल रहा है।

मैं जेएस में ऐसा करने के साथ गड़बड़ कर रहा हूं, लेकिन मैं स्टंप हो गया हूं।

यहां कोई स्मार्ट क्रिप्टो लोग जो मेरी मदद कर सकते हैं?

Answer 1

ठीक है, यह केवल मुझे एक महीने ले गया।

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