CODEWITHSUNDEEP
rubybinaryhex
user1985427
user1985427

Reputation: 363

How do I convert hex to binary (and vice versa) in Ruby, WHILE maintaining leading zeroes?

I have a data structure that I'd like to convert back and forth from hex to binary in Ruby. The simplest approach for a binary to hex is '0010'.to_i(2).to_s(16) - unfortunately this does not preserve leading zeroes (due to the to_i call), as one may need with data structures like cryptographic keys (which also vary with the number of leading zeroes).

Is there an easy built in way to do this?

Upvotes: 2

Views: 931

Answers (3)

D-side
D-side

Reputation: 9485

The truth is, leading zeros are not part of the integer value. I mean, it's a little detail related to representation of this value, not the value itself. So if you want to preserve properties of representation, it may be best not to get to underlying values at all.

Luckily, hex<->binary conversion has one neat property: each hexadecimal digit exactly corresponds to 4 binary digits. So assuming you only get binary numbers that have number of digits divisible by 4 you can just construct two dictionaries for constructing back and forth:

# Hexadecimal part is easy
hex = [*'0'..'9', *'A'..'F']
# Binary... not much longer, but a bit trickier
bin = (0..15).map { |i| '%04b' % i }

Note the use of String#% operator, that formats the given value interpreting the string as printf-style format string.

Okay, so these are lists of "digits", 16 each. Now for the dictionaries:

hex2bin = hex.zip(bin).to_h
bin2hex = bin.zip(hex).to_h

Converting hex to bin with these is straightforward:

"DEADBEEF".each_char.map { |d| hex2bin[d] }.join

Converting back is not that trivial. I assume we have a "good number" that can be split into groups of 4 binary digits each. I haven't found a cleaner way than using String#scan with a "match every 4 characters" regex:

"10111110".scan(/.{4}/).map { |d| bin2hex[d] }.join

The procedure is mostly similar.

Bonus task: implement the same conversion disregarding my assumption of having only "good binary numbers", i. e. "110101".

"I-should-have-read-the-docs" remark: there is Hash#invert that returns a hash with all key-value pairs inverted.

Upvotes: 2

Pere Joan Martorell
Pere Joan Martorell

Reputation: 3112

This is the most straightforward solution I found that preserves leading zeros. To convert from hexadecimal to binary:

['DEADBEEF'].pack('H*').unpack('B*').first # => "11011110101011011011111011101111"

And from binary to hexadecimal:

['11011110101011011011111011101111'].pack('B*').unpack1('H*') # => "deadbeef"

Here you can find more information:

Upvotes: 1

David Grayson
David Grayson

Reputation: 87406

I think you should have a firm idea of how many bits are in your cryptographic key. That should be stored in some constant or variable in your program, not inside individual strings representing the key:

KEY_BITS = 16

The most natural way to represent a key is as an integer, so if you receive a key in a hex format you can convert it like this (leading zeros in the string do not matter):

key = 'a0a0'.to_i(16)

If you receive a key in a (ASCII) binary format, you can convert it like this (leading zeros in the string do not matter):

key = '101011'.to_i(2)

If you need to output a key in hex with the right number of leading zeros:

key.to_s(16).rjust((KEY_BITS+3)/4, '0')

If you need to output a key in binary with the right number of leading zeros:

key.to_s(2).rjust(KEY_BITS, '0')

If you really do want to figure out how many bits might be in a key based on a (ASCII) binary or hex string, you can do:

key_bits = binary_str.length
key_bits = hex_str.length * 4

Upvotes: 3

Related Questions