C-Language-Series-#158: File Encryption and Decryption in C

In our ongoing C Language Series, we've explored a wide array of topics, from basic syntax to complex data structures and file handling. Today, we're diving into a crucial aspect of computing: data security. Specifically, we'll learn how to implement a basic file encryption and decryption mechanism using the C programming language.

While the techniques we'll demonstrate are simple and primarily for educational purposes, understanding these fundamentals is a vital step toward appreciating more sophisticated cryptographic algorithms. We'll use a straightforward XOR cipher to illustrate the core concepts of transforming data to protect its confidentiality and then reversing that transformation to retrieve the original content.

Why File Security Matters

In an increasingly digital world, the privacy and integrity of our data are paramount. From personal documents and financial records to confidential business information, many files contain sensitive data that should not be accessible to unauthorized individuals. Encryption provides a fundamental layer of defense, scrambling data in such a way that it becomes unreadable without the correct "key."

• Confidentiality: Ensures that only authorized users can read the information.
• Data Integrity: While not a primary function of simple encryption, stronger algorithms can also detect if data has been tampered with.
• Privacy: Protects personal and sensitive information from prying eyes.

Basic Encryption Concepts

Before jumping into code, let's briefly touch upon some foundational terms:

• Plaintext: The original, readable data.
• Ciphertext: The encrypted, unreadable data.
• Encryption: The process of converting plaintext into ciphertext.
• Decryption: The process of converting ciphertext back into plaintext.
• Key: A secret piece of information (like a password) used in conjunction with an algorithm to encrypt and decrypt data.
• Algorithm: A set of rules or steps used for encryption and decryption.

For this tutorial, we will focus on symmetric-key encryption, where the same key is used for both encryption and decryption. Our chosen algorithm will be the simple XOR cipher.

Understanding the XOR Cipher

The Exclusive OR (XOR) operation is a bitwise logical operation that is remarkably simple yet forms the basis for many cryptographic concepts. Its key properties make it suitable for a basic cipher:

• A XOR 0 = A
• A XOR A = 0
• A XOR B = C implies C XOR B = A

The third property is what makes XOR useful for encryption. If you XOR a byte of plaintext with a key byte to get ciphertext, you can XOR the ciphertext with the *same* key byte to get back the original plaintext. It's its own inverse operation.

For example, let's say we have a plaintext byte P = 01010101 and a key byte K = 11001100:

Encryption:

  01010101 (P)
XOR 11001100 (K)
-----------
= 10011001 (C - Ciphertext)

Decryption:

  10011001 (C)
XOR 11001100 (K)
-----------
= 01010101 (P - Original Plaintext)

This reversible property is what we'll leverage to encrypt and decrypt files byte by byte.

Implementing File Encryption/Decryption in C

Our approach will involve reading the input file byte by byte, applying the XOR operation with our secret key, and then writing the result to an output file. The same function can be used for both encryption and decryption, provided you use the same key.

The Core Encryption/Decryption Function

Let's define a function that takes the input file path, output file path, and the encryption key (a character for simplicity) as arguments.

#include <stdio.h>
#include <stdlib.h> // For exit()

/**
 * @brief Encrypts or decrypts a file using a simple XOR cipher.
 *        The same function is used for both encryption and decryption
 *        because XORing with the same key twice restores the original data.
 * 
 * @param inputFile Path to the file to be processed (encrypted/decrypted).
 * @param outputFile Path where the processed file will be saved.
 * @param key The single-character key used for the XOR operation.
 */
void xorEncryptDecrypt(const char *inputFile, const char *outputFile, char key) {
    FILE *fpIn, *fpOut;
    int ch; // Use int to read EOF correctly

    // Open input file in binary read mode
    fpIn = fopen(inputFile, "rb");
    if (fpIn == NULL) {
        perror("Error opening input file");
        exit(EXIT_FAILURE);
    }

    // Open output file in binary write mode
    fpOut = fopen(outputFile, "wb");
    if (fpOut == NULL) {
        perror("Error opening output file");
        fclose(fpIn); // Close the input file before exiting
        exit(EXIT_FAILURE);
    }

    // Read byte by byte, XOR and write
    while ((ch = fgetc(fpIn)) != EOF) {
        fputc(ch ^ key, fpOut); // XOR operation
    }

    printf("File '%s' processed to '%s' with key '%c'.\n", inputFile, outputFile, key);

    fclose(fpIn);
    fclose(fpOut);
}

Explanation of the Function:

• We include stdio.h for file operations and stdlib.h for exit().
• The function xorEncryptDecrypt takes three arguments:
  • const char *inputFile: Path to the file to be processed.
  • const char *outputFile: Path where the processed file will be saved.
  • char key: The single-character key used for XORing.
• fopen(filename, "rb") opens the input file in read binary mode. This is crucial for handling all types of files (text, images, executables) correctly, preventing character translation issues that can occur in text mode.
• fopen(filename, "wb") opens the output file in write binary mode. If the file doesn't exist, it's created. If it does, its content is truncated (emptied).
• Error checking is performed for fopen calls. If a file cannot be opened, an error message is printed, and the program exits.
• The core loop reads characters (bytes) using fgetc() until the End-Of-File (EOF) marker is reached.
  • ch = fgetc(fpIn) reads one character. Note that ch is an int, as fgetc returns EOF (which is an int, typically -1) or the character code (0-255).
  • fputc(ch ^ key, fpOut) performs the XOR operation between the read character and the key, then writes the result to the output file.
• Finally, both input and output files are closed using fclose(), which is vital to ensure all buffered data is written and resources are released.

Putting It All Together: A Complete Program

Now, let's create a main function that demonstrates how to use our xorEncryptDecrypt function to encrypt a file and then decrypt it back to its original form.

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

// Function to encrypt/decrypt a file using XOR cipher (re-declared for clarity in combined code)
void xorEncryptDecrypt(const char *inputFile, const char *outputFile, char key) {
    FILE *fpIn, *fpOut;
    int ch;

    fpIn = fopen(inputFile, "rb");
    if (fpIn == NULL) {
        perror("Error opening input file");
        exit(EXIT_FAILURE);
    }

    fpOut = fopen(outputFile, "wb");
    if (fpOut == NULL) {
        perror("Error opening output file");
        fclose(fpIn);
        exit(EXIT_FAILURE);
    }

    while ((ch = fgetc(fpIn)) != EOF) {
        fputc(ch ^ key, fpOut);
    }

    printf("File '%s' processed to '%s' with key '%c'.\n", inputFile, outputFile, key);

    fclose(fpIn);
    fclose(fpOut);
}

int main() {
    // Define file names and our secret key
    const char *originalFile = "my_secret_doc.txt";
    const char *encryptedFile = "my_secret_doc.encrypted";
    const char *decryptedFile = "my_secret_doc.decrypted";
    char encryptionKey = 'K'; // Our chosen single-character key

    // --- STEP 1: Create a dummy original file for demonstration ---
    FILE *fpOriginal = fopen(originalFile, "w");
    if (fpOriginal == NULL) {
        perror("Error creating original file");
        return EXIT_FAILURE;
    }
    fprintf(fpOriginal, "This is a very secret message.\n");
    fprintf(fpOriginal, "It contains sensitive information that needs protection.\n");
    fprintf(fpOriginal, "Data security is important, even with simple examples.");
    fclose(fpOriginal);
    printf("Original file '%s' created.\n\n", originalFile);

    // --- STEP 2: ENCRYPTION ---
    printf("--- Initiating ENCRYPTION ---\n");
    xorEncryptDecrypt(originalFile, encryptedFile, encryptionKey);
    printf("Encryption complete. An encrypted version of '%s' is now in '%s'.\n\n", originalFile, encryptedFile);

    // --- STEP 3: DECRYPTION ---
    printf("--- Initiating DECRYPTION ---\n");
    xorEncryptDecrypt(encryptedFile, decryptedFile, encryptionKey);
    printf("Decryption complete. The original content is restored in '%s'.\n\n", decryptedFile);

    printf("Verification: Open '%s' and '%s' to confirm they are identical.\n", originalFile, decryptedFile);
    printf("You can also open '%s' to see the scrambled content.\n", encryptedFile);

    return 0;
}

How to Compile and Run:

1. Save the code above as a .c file (e.g., file_cipher.c).
2. Compile using a C compiler (like GCC) from your terminal:

   gcc file_cipher.c -o file_cipher

3. Run the executable:

   ./file_cipher

The program will first create a my_secret_doc.txt file with some sample text. Then, it will encrypt this file into my_secret_doc.encrypted. Finally, it will decrypt my_secret_doc.encrypted back into my_secret_doc.decrypted. You can open these files with a text editor to see the plaintext in the original and decrypted files, and the scrambled (unreadable) ciphertext in the encrypted file.

Limitations and Security Considerations

It's important to reiterate that the simple XOR cipher demonstrated here is not suitable for securing sensitive data in real-world applications. It's a foundational concept, not a robust cryptographic solution. Here's why:

• Weak Key: Using a single character (byte) as a key is extremely weak. A dedicated attacker could easily brute-force all 256 possible single-byte keys in a fraction of a second.
• Repetitive Key: If the key is shorter than the plaintext (as our single-character key is for any substantial file), it repeats. This makes the cipher highly susceptible to frequency analysis (similar to how historical substitution ciphers were broken). For example, if a common character like 'e' in English is XORed with the same key character repeatedly, its encrypted form will also repeat, revealing patterns.
• Known-Plaintext Attacks: If an attacker knows even a small portion of the original plaintext and its corresponding ciphertext, they can easily deduce the key or parts of it, compromising the entire encrypted message.
• No Integrity/Authentication: This cipher provides no way to tell if the encrypted data has been tampered with or if it truly originates from an authentic source.

For genuine security, you would need to use:

• Stronger Algorithms: Like AES (Advanced Encryption Standard) for symmetric encryption or RSA for asymmetric encryption. These algorithms employ complex mathematical operations and much longer, non-repeating keys.
• Longer, Random Keys: Keys should be sufficiently long and truly random, generated by cryptographically secure random number generators.
• Proper Key Management: Securely generating, storing, distributing, and revoking keys is a complex and critical part of any secure cryptographic system.
• Initialization Vectors (IVs) and Modes of Operation: To prevent identical plaintext blocks from encrypting to identical ciphertext blocks, enhancing security.

Conclusion

Congratulations! You've successfully implemented a basic file encryption and decryption program in C using the XOR cipher. This exercise provides a valuable insight into how cryptographic operations work at a fundamental level, involving file I/O and simple bitwise logic.

While this method is rudimentary for practical security, it lays the groundwork for understanding the principles of confidentiality and data transformation. As you continue your journey in C programming and cybersecurity, remember that building truly secure systems requires a deeper dive into established cryptographic libraries and best practices. The goal here was to demystify the basic mechanics, not to provide a production-ready solution.

Keep experimenting, keep learning, and always be mindful of the security implications of your code!