Java Program to Encrypt and Decrypt Files Using Caesar Cipher

Introduction

The caesar cipher file encryption java tutorial shows how to apply the world's oldest documented cipher to files on disk. The Caesar cipher itself is hopelessly insecure for real data, but the engineering of file based encryption is the same regardless of the underlying cipher. This caesar cipher file encryption java tutorial walks through reading a file byte by byte, applying the Caesar shift to each byte, and writing the result to a new file. The same pattern extends naturally to AES, ChaCha20, and any other modern cipher.

File based encryption is the foundation of disk encryption products like BitLocker and LUKS, of file encryption tools like GPG, and of cloud storage systems that protect customer data at rest. Studying the simplest possible file cipher in Java is the fastest way to understand the engineering challenges of real encryption products.

What is Caesar Cipher File Encryption?

Caesar cipher file encryption is the application of the Caesar shift to a file. The file is read as a sequence of bytes, each byte is shifted by a fixed amount (typically modulo 256 for byte oriented encryption), and the shifted bytes are written to a new file. Decryption reverses the shift.

Compared to a Caesar cipher on letters, the file version operates on bytes, which means the shift is modulo 256 instead of modulo 26. This preserves the binary structure of the file and is compatible with any file format, including images, audio, and compressed data.

Compared to a modern file cipher like AES-CTR, the Caesar file cipher is hopelessly insecure. The shift is constant across the entire file, which means the same plaintext byte always produces the same ciphertext byte. This leaks the file structure through frequency analysis.

How Caesar Cipher File Encryption Works Step by Step

Step 1: Choose a shift value. We use 7 as the shift, which is small enough to remember and large enough to scramble printable text. The shift is the key of the cipher.

Step 2: Read the input file. We use java.nio.file.Files.readAllBytes to read the entire file into a byte array. For large files, a streaming approach with a buffer would be more memory efficient.

Step 3: Encrypt each byte. For each byte b in the input array, the encrypted byte is (b + shift) mod 256. The modulo operation handles the wrap around for byte values that exceed 255 after the shift.

Step 4: Write the encrypted bytes to the output file. We use java.nio.file.Files.write to write the entire byte array to a new file.

Step 5: Decrypt by reversing the shift. For each byte b in the encrypted array, the decrypted byte is (b - shift + 256) mod 256. The +256 handles the negative results that Java's % operator would otherwise produce.

Java Program to Encrypt and Decrypt Files Using Caesar Cipher

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class CaesarFileCipher {

    private final int shift;

    public CaesarFileCipher(int shift) {
        this.shift = ((shift % 256) + 256) % 256;
    }

    public void encryptFile(Path input, Path output) throws IOException {
        byte[] data = Files.readAllBytes(input);
        for (int i = 0; i < data.length; i++) {
            data[i] = (byte) ((data[i] & 0xff) + shift);
        }
        Files.write(output, data);
    }

    public void decryptFile(Path input, Path output) throws IOException {
        byte[] data = Files.readAllBytes(input);
        for (int i = 0; i < data.length; i++) {
            int v = (data[i] & 0xff) - shift;
            data[i] = (byte) ((v + 256) & 0xff);
        }
        Files.write(output, data);
    }

    public static void main(String[] args) throws IOException {
        Path plain  = Paths.get("plain.txt");
        Path cipher = Paths.get("cipher.bin");
        Path back   = Paths.get("back.txt");

        // Write a sample plaintext file
        Files.write(plain, "Hello, Caesar! This is a test file.".getBytes());

        CaesarFileCipher cfc = new CaesarFileCipher(7);
        cfc.encryptFile(plain, cipher);
        cfc.decryptFile(cipher, back);

        byte[] original = Files.readAllBytes(plain);
        byte[] recovered = Files.readAllBytes(back);
        System.out.println("Original file size : " + original.length);
        System.out.println("Cipher file size   : "
            + Files.readAllBytes(cipher).length);
        System.out.println("Recovered file size: " + recovered.length);
        System.out.println("Round trip success : "
            + java.util.Arrays.equals(original, recovered));
        System.out.println("Recovered content  : " + new String(recovered));
    }
}

Code Explanation Line by Line

The constructor takes a shift and normalizes it to the range 0 to 255 using the ((shift % 256) + 256) % 256 idiom. This idiom handles negative shifts correctly, which would otherwise produce wrong ciphertext.

The encryptFile method reads the entire input file into a byte array using Files.readAllBytes. For each byte, it adds the shift and casts back to a byte. The & 0xff mask is important: bytes in Java are signed, so a byte value of 200 is interpreted as -56 when read as a byte. The mask converts it to the unsigned value 200 before adding the shift.

The decryptFile method reverses the process. For each byte, it subtracts the shift and adds 256 to handle negative results, then masks with 0xff to ensure the result fits in a byte. Without the +256, a negative numerator would produce a negative result when cast to a byte.

The main method demonstrates a round trip. It writes a sample plaintext to a file, encrypts the file to a ciphertext file, decrypts the ciphertext file to a recovered file, and compares the recovered file with the original. The comparison uses Arrays.equals, which is the standard way to compare byte arrays for equality.

The output shows that the original file size, the cipher file size, and the recovered file size are all the same, and that the round trip succeeded. The recovered content matches the original content exactly.

Sample Input and Output

Input file: plain.txt
  Content: "Hello, Caesar! This is a test file."
  Size: 35 bytes
Shift: 7
Output file: cipher.bin (encrypted)
  Size: 35 bytes
  Content: (binary, not human-readable)
Output file: back.txt (decrypted)
  Size: 35 bytes
  Content: "Hello, Caesar! This is a test file."
Round trip success: true

The plaintext file is encrypted byte by byte with shift 7, producing a binary ciphertext file of the same size. The ciphertext file is then decrypted byte by byte with shift -7, producing a recovered file that matches the original byte for byte. The round trip succeeds, confirming the implementation is correct.

Common Mistakes to Avoid

First, forgetting the & 0xff mask when reading bytes. Java bytes are signed, so a byte value of 200 is interpreted as -56 when read as a byte. The mask converts it to the unsigned value 200 before any arithmetic.

Second, not handling negative shifts in decryption. The expression (b - shift) can produce a negative result when b is small, and Java's % operator returns a negative value for negative numerators. Always add 256 (or 2 * 256) before the modulo.

Third, reading the entire file into memory for very large files. Files.readAllBytes loads the entire file into a heap array, which can cause OutOfMemoryError for files larger than a few hundred megabytes. Use a streaming approach with a buffer for large files.

Fourth, using a predictable shift. The Caesar shift is a single integer, which makes it trivially brute forceable. Use a random key with a modern cipher like AES-GCM for any real data.

Real-World Applications

The Caesar file cipher is not used in production. Its security is nonexistent: the shift is a single byte, which means there are only 256 possible keys, and an attacker can try all of them in milliseconds.

However, the engineering pattern of file based encryption is the same regardless of the underlying cipher. Real encryption products like BitLocker, LUKS, and GPG use the same pattern of reading a file, applying a transformation, and writing the result. The only difference is that the transformation is a strong cipher like AES-CTR instead of the trivial Caesar shift.

In modern systems, file based encryption is used by cloud storage products like Dropbox and Google Drive to protect customer data at rest. The encryption is typically AES-256-GCM with a random key per file, and the key is itself encrypted with a master key that is stored in a key management service.

The streaming pattern shown in this tutorial is the foundation of disk encryption products like BitLocker and LUKS. These products encrypt disk sectors one at a time using a block cipher in XTS mode, which is a variant of CTR mode designed specifically for disk encryption.

In capture the flag events, file based Caesar ciphers are sometimes used as a warm-up puzzle. The hint is usually a binary file that, when viewed in a hex editor, shows the ASCII printable range shifted by a constant amount. The solver tries each of the 256 possible shifts and finds the one that produces readable text.

The file encryption pattern is also a useful demonstration of the principle of separation of concerns. The encryption logic is independent of the file I/O logic, which means the same encrypt method can be used with different I/O strategies (in memory, streaming, memory mapped) without modification. This is the same principle used by the Java NIO Files API, which separates the file operations from the buffer operations.

Conclusion

Caesar cipher file encryption applies the Caesar shift to each byte of a file. We read the file with Files.readAllBytes, applied the shift with the & 0xff mask, and wrote the result with Files.write. Next you should study AES file encryption (which uses a strong cipher in place of Caesar), AES-GCM (which adds authentication), and disk encryption (which applies the cipher to disk sectors instead of files).