XOR Encrypted Message length is showing wrongly in C

Question

Im Encrypting the Original Messages using XOR algorithm by following code in C program. And Finally it gives another different value that message has encrypted. It should return same length even after the message has encrypted.

But, Using strlen(encrypted) it gives less value than original message length. I couldn't recognize why the length of XOR encrypted message is showing less than the original message length. Please find the following the code to solve my problem.

Thanks in Advance!

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char* XORCipher(char* data, char* key, int dataLen, int keyLen) {
    char* output = (char*)malloc(sizeof(char)*dataLen);

    for(int i = 0; i < dataLen; ++i) {
      output[i] = data[i] ^ key[i % keyLen];
    }

    return output;
}

int main(){

char *msg = "This is a Message from Boss";
char *key = "nandha";

int dataLen = strlen(msg);
int keyLen = strlen(key);

char *encrypt = XORCipher(msg,key,dataLen,keyLen);
printf("\nEncrypted msg is :\n %s",(char*)encrypt);

//The Length of encrypted char size is showing wrongly.
printf("size of Encrypted msg is: %d\n",strlen(encrypt));

encrypt = XORCipher(encrypt,key,strlen(encrypt),keyLen);
printf("\nOriginal msg converted is : %s\n",encrypt);

return 0;

}

Answer 1

When you perform these XOR operations on your string, the resulting values could fall outside the range of printable characters. In particular, if a plaintext character happens to match the key character used to encode it the result will be 0.

In C, a string is actually a sequence of characters terminated by a null byte, i.e. a byte with value 0. Any function that operates on strings looks for this byte to denote the end of the string.

Because your encoding can generate null bytes, your encrypted message is not a string but an array of bytes. Attempting to use a string function on the encrypted message can cause it to stop processing in the middle of the message if it contains a null byte. If the message does not contain a null byte, these string functions will continue to read past the end of the character array until it finds one. Reading past the end of an array or dynamically allocated block of memory invoked undefined behavior.

You need some other way to know how long the encrypted message is. In the case of the XOR encoding you're doing this is easy: the length of the ciphertext is the same as the length of the plaintext. So when decoding, pass in dataLen for the ciphertext length. To print the ciphertext, you need to loop through the bytes and print each one individually rather that trying to print it as a string (which it is not).

Also, after you've decoded, you still don't have a string because there was no null terminating byte added to the end of the decrypted message. You can do this manually after calling decrypting:

// pass in plaintext length as ciphertext length since they are the same
encrypt = XORCipher(encrypt,key,dataLen,keyLen);
// null terminate decrypted string
encrypt[dataLen] = '\0';

The buffer allocated inside of XORCipher doesn't currently allocate enough space for the null terminator, so you need to increase this by 1 to allow for this:

// no need to cast the return value of malloc
// sizeof(char) is guaranteed to be 1, so no need to multiply by it
char* output = malloc(dataLen + 1);

Answer 2

C strings are character arrays that are null terminated. When you allocate your encrypted array with the length of the string, you don't leave room for null termination, so strlen is unable to tell when the string ends, thinking the string ends outside of the actual memory that you allocated. This modification to your xor function will make it work.

char* XORCipher(char* data, char* key, int dataLen, int keyLen) {
    char* output = (char*)malloc(sizeof(char)*dataLen+1);
    output[dateLen] = 0;
    for(int i = 0; i < dataLen; ++i) {
        output[i] = data[i] ^ key[i % keyLen];
    }
    return output;
}

Additionally, if you're xor function gives 0 as an output, strlen will see that as the end of the string, which would give you a string length shorter than the expected output.

Update: I have tested the code and it works.

char* XORCipher(char* data, char* key, unsigned long dataLen, unsigned long keyLen) {
    char* output = (char*)malloc(sizeof(char)*dataLen+1);
    output[dataLen] = 0;
    for(int i = 0; i < dataLen; ++i) {
        output[i] = data[i] ^ key[i % keyLen];
    }
    return output;
}

void printLn(char* toPrint, unsigned long len){
    for (unsigned long i = 0; i < len; i++) {
        printf("%c", toPrint[i]);
    }
    printf("\n");
}

int main(){

    char *msg = "This is a Message from Boss";
    char *key = "nandha";

    unsigned long dataLen = strlen(msg);
    unsigned long keyLen = strlen(key);

    printLn(msg, dataLen);
    char* xorMessage = XORCipher(msg, key, dataLen, keyLen);
    printLn(xorMessage, dataLen);
    xorMessage = XORCipher(xorMessage, key, dataLen, keyLen);
    printLn(xorMessage, dataLen);


    return 0;
}

Be reminded that xoring can result in null characters in the array that you've allocated, resulting in a terminating character which you might have not intended. To compensate for this, I have added a function to print out based on length since you know this information based on your msg. After xoring twice you should have your original string back, which I my code verified.