Printing result of a bitwise XOR in C

Question

When I am trying to do a bitwise XOR of two strings, I get x��K or similar output. The code I am using:

char test[] = "teststring";
char test2[] = "testtwostring";
char *bytearray = NULL;
bytearray = malloc(sizeof(char) * (strlen(test2)+1));

for(int j=0; (j< strlen(test) && j< strlen(test2)); j++){
    bytearray[j] += test[j] ^ test2[j];
}

printf(bytearray)

Should it not save the XOR result of both string, in each of the bytearray elements, and then print out a new result string? Is there something I am missing?

Answer 1

You haven't initialized bytearray, so it contains whatever garbage happened to be in that section of memory when it was allocated. You want to do:

memset(bytearray, 0, sizeof(char) * (strlen(test2) + 1));

after you allocate the array with malloc(). As @John Bollinger noted, you can combine the malloc and memset by calling calloc:

bytearray = calloc(strlen(test2) + 1, sizeof(char));

As another alternative, you could just assign instead of adding:

bytearray[j] = test[j] ^ test2[j];

instead of:

bytearray[j] += test[j] ^ test2[j];

Also, you shouldn't call strlen repeatedly, since the value will never change. You should just call it once each for test and test2, store those values in variables, and use the variables. Right now strlen is getting unnecessarily called twice each time your for loop iterates.

Answer 2

There are many problems in your code:

• bytearray[j] += test[j] ^ test2[j]; modifies bytearray, but it is uninitialized, so its values should not even be read at all and whatever they are is unpredictable. This completely explains your observations.

• you do not null terminate the string in bytearray, so printing it invokes undefined behavior as it is uninitialized.

• you pass printf the byte array directly. If by coincidence it contains a % character, that would invoke undefined behavior as you do not pass any extra arguments to printf. You should at least write printf("%s\n", bytearray);

• The values in bytearray are not necessarily printable characters.

• calling strlen(test) and strlen(test2) in the test expression is very inefficient as this operation is expensive and gets repeated for each iteration of the loop. Use this test instead:

  for (j = 0; test[j] != '\0' && test2[j] != '\0'; j++) {
      ...
  

Since your goal is to save the XOR result of both strings, you should modify the code this way:

char test[] = "teststring";
char test2[] = "testtwostring";
size_t len = strlen(test);
size_t len2 = strlen(test2);
unsigned char *bytearray = malloc(len2 + 1);
size_t j;

for (j = 0; j < len && j < len2; j++) {
    bytearray[j] = test[j] ^ test2[j];
}
for (; j < len2; j++) {
    bytearray[j] = test2[j];
}

printf("XOR byte values: \n");
for (j = 0; j < len2; j++) {
    printf("%02X ", bytearray[j]);
}
printf("\n");