I have this easy en-/decryption algorithm.
Disclaimer
However, I have absolutely no prior experience in information security, encryption, and so on, so bare with me.
Encryption
Encryption works this way: first we read in four first bytes from the data being encrypted; then, we treat the four bytes as a single 32-bit integer and we add the value of the cipher to that value; then, we store the sum into the same location (four first bytes). Next we "shift the window" one byte to the right and read once again a 32-bit value that, however, starts at the byte 1 (indexing starts from 0); add cipher, store, and so on.
Decryption
The decryption algorithm undoes what encryption method does: it begins from the four last bytes; reads them, subtracts the cipher key, and stores back, moves the window one byte towards beginning of the data array.
The code follows:
CipherTools.java:
package net.coderodde.encryption;
import java.util.Arrays;
import java.util.Random;
/**
* This class provides static methods for encrypting and decrypting binary data
* represented by arrays of bytes.
*
* @author Rodion "rodde" Efremov
* @version 1.6 (Feb 29, 2016)
*/
public class CipherTools {
private static final int BYTES_PER_INT = 4;
/**
* Encrypts the input data {@code input} using the cipher key
* {@code cipherKey}.
*
* @param input the data to encrypt.
* @param cipherKey the cipher key.
* @return the encrypted data.
*/
public static byte[] encrypt(byte[] input, int cipherKey) {
checkCipherNotZero(cipherKey);
byte[] output = input.clone();
for (int i = 0; i <= output.length - BYTES_PER_INT; ++i) {
writeInt(output, i, readInt(output, i) + cipherKey);
}
return output;
}
/**
* Decrypts the input data {@code input} using the cipher key
* {@code cipherKey}.
*
* @param input the input data to decrypt.
* @param cipherKey the cipher key.
* @return the decrypted data.
*/
public static byte[] decrypt(byte[] input, int cipherKey) {
checkCipherNotZero(cipherKey);
byte[] output = input.clone();
for (int i = output.length - BYTES_PER_INT; i >= 0; --i) {
writeInt(output, i, readInt(output, i) - cipherKey);
}
return output;
}
private static void checkCipherNotZero(int cipherKey) {
if (cipherKey == 0) {
throw new IllegalArgumentException(
"The input cipher key is zero. For this reason, the data " +
"would not be encrypted.");
}
}
/**
* Returns the integer represented by bytes {@code data[offset],
* data[offset + 1], data[offset + 2], data[offset + 3]}, where the bytes
* are listed from least significant to most significant.
*
* @param data the data array holding the bytes.
* @param offset the offset of the integer to read.
* @return a four byte integer value.
*/
private static int readInt(byte[] data, int offset) {
int b0 = Byte.toUnsignedInt(data[offset]);
int b1 = Byte.toUnsignedInt(data[offset + 1]);
int b2 = Byte.toUnsignedInt(data[offset + 2]);
int b3 = Byte.toUnsignedInt(data[offset + 3]);
return (b3 << 24) | (b2 << 16) | (b1 << 8) | b0;
}
/**
* Writes the value {@code value} to the byte array {@code data} starting
* from index {@code offset}, or namely, to the bytes {@code data[offset],
* data[offset + 1], data[offset + 2], data[offset + 3]}, where the least
* significant byte of the value is stored in the byte {@code data[offset]},
* i.e., we assume a <b>little-endian</b> machine.
*
* @param data the array holding the data to write to.
* @param offset the index of the least significant byte of the target
* data integer.
* @param value the value to write.
*/
private static void writeInt(byte[] data, int offset, int value) {
data[offset] = (byte)(value & 0xff);
data[offset + 1] = (byte)((value >>> 8) & 0xff);
data[offset + 2] = (byte)((value >>> 16) & 0xff);
data[offset + 3] = (byte)((value >>> 24) & 0xff);
}
public static void main(final String... args) {
Random random = new Random();
byte[] before = new byte[10];
random.nextBytes(before);
int cipherKey = random.nextInt();
byte[] encrypted = encrypt(before, cipherKey);
byte[] after = decrypt(encrypted, cipherKey);
System.out.println("Before: " + Arrays.toString(before));
System.out.println("Encrypted: " + Arrays.toString(encrypted));
System.out.println("After: " + Arrays.toString(after));
System.out.println("Match: " + Arrays.equals(before, after));
}
}
CipherToolsTest.java:
package net.coderodde.encryption;
import java.util.Arrays;
import java.util.Random;
import org.junit.Test;
import static org.junit.Assert.*;
public class CipherToolsTest {
private static final int ITERATIONS = 100;
private static final int MAXIMUM_LENGTH = 1000;
@Test
public void testEncryptionDecryption() {
long seed = System.nanoTime();
Random random = new Random(seed);
System.out.println("Seed = " + seed);
for (int iteration = 0; iteration < ITERATIONS; iteration++) {
int cipherKey = random.nextInt();
if (cipherKey == 0) {
cipherKey = 1;
}
byte[] before = new byte[random.nextInt(MAXIMUM_LENGTH + 1)];
random.nextBytes(before);
byte[] encrypted = CipherTools.encrypt(before, cipherKey);
byte[] after = CipherTools.decrypt(encrypted, cipherKey);
assertTrue(Arrays.equals(before, after));
assertFalse(Arrays.equals(before, encrypted));
}
}
@Test(expected = IllegalArgumentException.class)
public void testEncryptionThrowsOnZeroCipher() {
CipherTools.encrypt(new byte[2], 0);
}
@Test(expected = IllegalArgumentException.class)
public void testDecryptionThrowsOnZeroCipher() {
CipherTools.decrypt(new byte[2], 0);
}
}
Please, tell me anything that comes to mind. Also, is it easy to crack that cipher if the hacker, say, knows that the file encrypted is a source code file in some particular language?
