## Introduction

A very common task when working with binary data in C is, converting it to and from Hex. It’s unfortunate that C doesn’t provide a standard function that can take care of this for us. However, it’s pretty easy to implement a set of functions to handle it.

Hex encoding is always twice the size of binary. Since hex is base 16 we can take any `unsigned char` value 0-255 and represent it in two hex digits, 0x00-0xFF.

When dealing with Hex encoding, always use two characters even if the numeric value fits within one hex digit (0-F). It’s very important to have consistent sizing because 0FAB could be 0F AB or 00 0F 0A 0B. I can’t stress enough that always using the width of the largest value (FF) means you always know the number of characters that represent each value. In this situation one ```unsigned char``` is two hex characters. Going back to binary two hex characters will always convert back to one binary value.

## Binary to hex

``````char *bin2hex(const unsigned char *bin, size_t len)
{
char   *out;
size_t  i;

if (bin == NULL || len == 0)
return NULL;

out = malloc(len*2+1);
for (i=0; i<len; i++) {
out[i*2]   = "0123456789ABCDEF"[bin[i] >> 4];
out[i*2+1] = "0123456789ABCDEF"[bin[i] & 0x0F];
}
out[len*2] = '\0';

return out;
}
``````

“0..F” is a `const` string here and we can index this as an array because it is an array. Assignment to a `const char *` variable means the variable points to the memory address of the constant. Since it’s just a memory address we an access it as an array.

There are a total of 16 hex characters. An unsigned char is 8 bits which is split into two 4 bit parts. 4 bits can have a value 0 to 15 which is the same number of characters for hex encoding. The right shift masks off the high part which is the first hex character and the 0x0F mask masks off the low part to get the second hex digit.

## Hex to binary

``````int hexchr2bin(const char hex, char *out)
{
if (out == NULL)
return 0;

if (hex >= '0' && hex <= '9') {
*out = hex - '0';
} else if (hex >= 'A' && hex <= 'F') {
*out = hex - 'A' + 10;
} else if (hex >= 'a' && hex <= 'f') {
*out = hex - 'a' + 10;
} else {
return 0;
}

return 1;
}
``````

Every hex digit needs to be turned back into a 4 bit binary value. Meaning 0 = 0, 1 = 1, … A = 10 … E = 14, F = 15. The character is subtracted from the base character in it’s range and for the alpha values 10 is added since they represent 10+. This calculation is based on the numeric values of each character in the ASCII text encoding table.

``````size_t hexs2bin(const char *hex, unsigned char **out)
{
size_t len;
char   b1;
char   b2;
size_t i;

if (hex == NULL || *hex == '\0' || out == NULL)
return 0;

len = strlen(hex);
if (len % 2 != 0)
return 0;
len /= 2;

*out = malloc(len);
memset(*out, 'A', len);
for (i=0; i<len; i++) {
if (!hexchr2bin(hex[i*2], &b1) || !hexchr2bin(hex[i*2+1], &b2)) {
return 0;
}
(*out)[i] = (b1 << 4) | b2;
}
return len;
}
``````

The first thing we do is determine the size of the buffer and allocate it. Then we can move onto the main part where we combine the two 4 bit values into one 8 bit unsigned character.

## Testing

Finally, here is a simple test app to demonstrate the use of each function.

``````int main(int argc, char **argv)
{
const char    *a = "Test 123! - jklmn";
char          *hex;
unsigned char *bin;
size_t         binlen;

hex = bin2hex((unsigned char *)a, strlen(a));
printf("%sn", hex);

binlen = hexs2bin(hex, &bin);
printf("%.*sn", (int)binlen, (char *)bin);

free(bin);
free(hex);
return 0;
}
``````

You might notice that the input variable `a` is a string. We’ll, it’s still data and we can treat it as binary. Using a string makes it easier to verify the decode since we can print it out and see the result.