SHA384 online Hash Generator

How do I generate hash for my wowza application using SHA-256 algo for my default "live" application?My stream name is "gocoder.stream" and the secret key is "palmleaf".Please help or tell the procedure to calculate the same.

I'm attempting to port some NodeJS code to Python 3, but am having trouble getting a SHA1 hash to behave identically.

This code in each language shows the problem:

NodeJS

var crypto = require('crypto');crypto.createHash('sha1');var h = crypto.createHash('sha1');h.update(new Buffer('pXHepU2vIdYJuIAN', 'base64').toString('binary'));console.log(h.digest('hex')); // ea70f5b1ec762290cefd37bc0f9a7421dcc93466

Python 3

import hashlibimport base64h = hashlib.sha1()h.update(base64.b64decode(b'pXHepU2vIdYJuIAN'))print(h.hexdigest()) # 74161d2d37d9fff312dd396d5f779133c4bfd88d

I think I'm passing the Python input in the wrong format as if I remove the .toString('binary') from the NodeJS code it matches.

Could anyone explain to me what the Python code should be, and why they behave differently?

I tried searching in vain but can't seem to find a solution. I am coding SHA512 and the addition of unsigned long long integers is truncating the most significant bits on an overflow instead of wrapping around. The truncation happens whenever the overflow occurs, even though the output below shows a small sample size. I though unsigned long long integers automatically wrap around. An example output for the first 3 rounds out of 80 for the string "abc" is below. The first truncation happens during round 3 of the output. This error obviously propagates throughout. The code is below the output.

Error below was result of adding:A13DCE53256BD0066A09E667F3BCC908 +---------------- B47B4BB1928990E <-result**Output**Initial hash buffer:Hash value in hexadecimal:6A09E667F3BCC908BB67AE8584CAA73B3C6EF372FE94F82BA54FF53A5F1D36F1510E527FADE682D19B05688C2B3E6C1F1F83D9ABFB41BD6B5BE0CD19137E2179Round: 0Temp Hash value in hexadecimal:F6AFCEB8BCFCDDF56A09E667F3BCC908BB67AE8584CAA73B3C6EF372FE94F82B58CB02347AB51F91510E527FADE682D19B05688C2B3E6C1F1F83D9ABFB41BD6BRound: 1Temp Hash value in hexadecimal:1320F8C9FB872CC0F6AFCEB8BCFCDDF56A09E667F3BCC908BB67AE8584CAA73BC3D4EBFD48650FFA58CB02347AB51F91510E527FADE682D19B05688C2B3E6C1FRound: 2Temp Hash value in hexadecimal:EBCFFC07203D91F31320F8C9FB872CC0F6AFCEB8BCFCDDF56A09E667F3BCC908DFA9B239F2697812C3D4EBFD48650FFA58CB02347AB51F91510E527FADE682D1Round: 3Temp Hash value in hexadecimal:5A83CB3E80050E82EBCFFC07203D91F31320F8C9FB872CC0F6AFCEB8BCFCDDF5B47B4BB1928990E <- truncated value hereDFA9B239F2697812C3D4EBFD48650FFA58CB02347AB51F91**Code**void SHA2::roundFunction(){    std::cout << std::endl << "Initial hash buffer:" << std::endl;    printHashBuffer();    // loop through each 1024 bit msg block from the original file    for(int i = 0; i < messageChunks.size(); i++){        int strIndex = 0;        unsigned long long word;        std::array<unsigned long long,80> words;        // initialize working variables w0 to w16        for(int t = 0; t < 16; t++){            std::string tempStr = messageChunks[i].substr(strIndex, 64);            std::bitset<64> wordBitset(tempStr);            words[t] = wordBitset.to_ullong();            strIndex += 64;        }        // initialize working variables w16 to w79        for(int t = 16; t < 80; t++){            word = sigma1(words[t - 2]) + words[t - 7] + sigma0(words[t - 15]) + words[t - 16];            words[t] = word;        }        tempHashBuffer = hashBuffer;                    // loop through all 64 bit message chunks for each 1024 bit block        for(int t = 0; t < 80; t++){            std::cout << std::dec << "Round: " << t << std::endl;            unsigned long long ch = Ch(tempHashBuffer[4], tempHashBuffer[5], tempHashBuffer[6]);            unsigned long long maj = Maj(tempHashBuffer[0], tempHashBuffer[1], tempHashBuffer[2]);            unsigned long long sumA = SumA(tempHashBuffer[0]);            unsigned long long sumE = SumE(tempHashBuffer[4]);            unsigned long long t1 = tempHashBuffer[7] + ch + sumE + words[t] + constants[t];            unsigned long long t2 = sumA + maj;            tempHashBuffer[7] = tempHashBuffer[6]; // h = g            tempHashBuffer[6] = tempHashBuffer[5]; // g = f            tempHashBuffer[5] = tempHashBuffer[4]; // f = e            tempHashBuffer[4] = tempHashBuffer[3] + t1; // e = d + t1            tempHashBuffer[3] = tempHashBuffer[2]; // d = c            tempHashBuffer[2] = tempHashBuffer[1]; // c = b            tempHashBuffer[1] = tempHashBuffer[0]; // b = a            tempHashBuffer[0] = t1 + t2; // a = t1 + t2            //std::cout << std::hex << tempHashBuffer[4] <<" :e after d + t1" <<  std::endl;            printTempHashBuffer();        }        // compute intermediate hash value        for(int j = 0; j < hashBuffer.size(); j++){            hashBuffer[j] += tempHashBuffer[j];        }    }}unsigned long long SHA2::ROTR(unsigned long long word, unsigned shift){    shift %= 64;    return (word << (64 - shift)) | (word >> shift);}unsigned long long SHA2::sigma0(unsigned long long word){    return ROTR(word,1) ^ ROTR(word,8) ^ (word << 7);}unsigned long long SHA2::sigma1(unsigned long long word){    return ROTR(word,19) ^ ROTR(word,61) ^ (word << 6);}unsigned long long SHA2::SumA(unsigned long long a){    return ROTR(a,28) ^ ROTR(a,34) ^ ROTR(a,39);}unsigned long long SHA2::SumE(unsigned long long e){    return ROTR(e,14) ^ ROTR(e,18) ^ ROTR(e,41);}unsigned long long SHA2::Ch(unsigned long long e, unsigned long long f,                            unsigned long long g){    return (e & f) ^ (~e & g);}unsigned long long SHA2::Maj(unsigned long long a, unsigned long long b,                             unsigned long long c){    return (a & b) ^ (a & c) ^ (b & c);}

...I'd like to ask how is it, and hopefully not asking an alrady asked question (I searched for it on the internet for a week, didn't find it... I know it's hidden somewhere in those long books... so if it's here please direct me to the thread, ty)...

...I'd like to know what character base... or how exactly is it with character base which is used in hash functions like MD5, SHA... for example... what do they use base64, ascii, extended ascii... cose if I try to encode for example char alt 444 (╝) it encodes it... but there has to be a limit right, to how many indifferent chars can be used... cose otherwise the hash could not be unique, right? And many sites using these algorithms only let you use base64 character pool... I guess... please help... thank you

I would like to sign a xml document to send it to a soap web service. To begin, I am trying to sign a simple node like this:

<test xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" wsu:Id="id-F4821D01E882FF4507149477187940483"> truc</test>

The digest value of the test element is “pdB9Sx1CJ6Cj2z/FoqamVKkjxZ8= ».

Here is a simple python code to compute the digest value:

from xml.dom import minidomfrom xml.dom.ext import c14nimport base64import hashlibdoc = minidom.parse('file2.xml')canonical_xml = c14n.Canonicalize(doc)print (canonical_xml)print base64.b64encode(hashlib.sha1(canonical_xml).digest())print (" ".join("{:02x}".format(ord(c)) for c in canonical_xml))

The node «test«  is in the file named ‘file2.xml’.

To test the soap request, I create it with SoapUI but the digest value of this node is different.I don’t understand why the digest value from SOAPUI is different. I have «ONNdniHbKnsMddcMR8rUuPWxbgw= ».

Here is a part from the document xml generated by SoapUI:

<ds:Reference URI="#id-F4821D01E882FF4507149477187940483"><ds:Transforms><ds:Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"><ec:InclusiveNamespaces PrefixList="soapenv urn" xmlns:ec="http://www.w3.org/2001/10/xml-exc-c14n#"/></ds:Transform></ds:Transforms><ds:DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/><ds:DigestValue>ONNdniHbKnsMddcMR8rUuPWxbgw=</ds:DigestValue></ds:Reference>

Can someone explain to me why those digest values are different?