how do we encode each byte as two hexadecimal characters in ruby?

Question

I have a hexadecimal number as

hexMidAppId = '0001000000000002'

In node.js, we have a library new Buffer(hexMidAppId, 'hex') which gives me the output as

<Buffer 00 01 00 00 00 00 00 02>

now the same output i want to get it in ruby but i couldn't find any equivalent method in ruby for the Buffer method. Can anyone help me this?

Answer 1

I have a logic in node.js which i am trying in ruby but couldnt find a relevant method(Buffer()) in ruby.Below is my code in the node.js which uses a crypto library method createHmac

I testsed with ID =2 and APPID=1

function generatesomevalue(ID, APPID) {

    // add zero padding for at the beginning of the number pick lowest 6 bytes
    var hexMemberId = ('0000000000000000' + ID.toString(16)).substr(-12);
    console.log(hexMemberId); //000000000002
    // put APPID into two highest bytes of member id
    var hexAppId = APPID.toString(16);
    console.log(hexAppId);//1
    var hexMidAppId = ('0000' + hexAppId + hexMemberId).substr(-16);//<Buffer 00 01 00 00 00 00 00 02>
    console.log(hexMidAppId);//0001000000000002
    var midBuffer = new Buffer(hexMidAppId, 'hex');
    console.log(midBuffer);//<Buffer 00 01 00 00 00 00 00 02>

    var key = 'PLACEHOLDER';
    var hmacBuffer = createHMACDigest(key, midBuffer);
    console.log(hmacBuffer); //01c690ac02eb572fde4a096a076aaa8501ea3671bf
    var outputBuffer = Buffer.concat([midBuffer, new Buffer(hmacBuffer, 'hex')]);
    console.log(outputBuffer); //<Buffer 00 01 00 00 00 00 00 02 01 c6 90 ac 02 eb 57 2f de 4a 09 6a 07 6a aa 85 01 ea 36 71 bf>
    console.log(outputBuffer.toString('base64')); //AAEAAAAAAAIBxpCsAutXL95KCWoHaqqFAeo2cb8=
    return outputBuffer.toString('base64');
}

function createHMACDigest(key, paddedMemberId) { return '01' + Crypto.createHmac('sha1', key).update(paddedMemberId).digest('hex'); }

Answer 2

In ruby you can use the String#unpack and Array#pack for these - and many other - transformations.

To change the hex string into the actual bytes, you can put it inside an Array and use Array#pack like so:

 ['0001000000000002'].pack 'H*'
 # => this will give:  "\x00\x01\x00\x00\x00\x00\x00\x02" 

What you get is a string with the actual bytes. You can convert this into a byte array using:

 data = ['0001000000000002'].pack 'H*'
 # => this will give:  "\x00\x01\x00\x00\x00\x00\x00\x02" 
 data.bytes # => [0, 1, 0, 0, 0, 0, 0, 2]

P.S.

The Buffer class in Javascript is used since pure Javascript isn't binary friendly.

Pure JavaScript is Unicode friendly but not nice to binary data. When dealing with TCP streams or the file system, it's necessary to handle octet streams. Node has several strategies for manipulating, creating, and consuming octet streams.

Raw data is stored in instances of the Buffer class. A Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap. A Buffer cannot be resized.

In Ruby, it's possible to use either the String class or an Array to store binary data, so you will not find a designated "Buffer" class.

In Example:

"\x00\x01\x02" # => A string with 3 bytes, using Hex notation (00, 01, 02)
"\x00\x01\x02".bytes # => [1,2,3] An array with 3 bytes.
[1,2,3].pack('C*') # => "\x00\x01\x02" Back to the string

you can also use pack for integers (16bit), longs (32bit) doubles (64bit) and other data types:

[1024, 2].pack('i*') # => "\x00\x04\x00\x00\x02\x00\x00\x00"

Answer 3

You actually have String and you want to output it with spaces between each two sequential characters. So, you can do scan & join

hexMidAppId.scan(/.{2}/).join(' ')