Fix CTR decryption.

Off by one error in respect to the y blocks.

src/main/java/ch/fhnw/kry/CTR.java

@@ -3,6 +3,11 @@ package ch.fhnw.kry;
 import java.util.Random;
 import java.util.concurrent.ThreadLocalRandom;
 
+import static ch.fhnw.kry.Main.BLOCK_LENGTH;
+
+/**
+ * Implementation of CTR mode for decryption.
+ */
 public class CTR {
     private final SPN spn = new SPN();
     private final int iv;
@@ -13,10 +18,11 @@ public class CTR {
         this.key = key;
     }
 
-    public int getIV() {
+    /**
-        return iv;
+     * Generate a 16 bit long initialisation vector.
-    }
+     *
-
+     * @return Generated initialisation vector.
+     */
     public static int generateIV() {
         Random random = ThreadLocalRandom.current();
         byte[] r = new byte[2];
@@ -25,10 +31,22 @@ public class CTR {
         return r[0] << 8 & r[1];
     }
 
-    public int decrypt(int block, int idx) {
+    public int getIV() {
-        int e = (iv + idx) % (1 << 16);
+        return iv;
-        e = spn.decryptBlock(key, e);
+    }
 
-        return block ^ e;
+    /**
+     * Decrypt a block in CTR mode.
+     *
+     * @param block Encrypted block (only lower 16 bits get looked at).
+     * @param idx   Block index.
+     * @param y     Y at index idx.
+     * @return Decrypted block (in the lower 16 bits of the int).
+     */
+    public int decrypt(int block, int idx, int y) {
+        int e = (iv + idx) % (1 << BLOCK_LENGTH); // iv + i mod 2^16
+        e = spn.encryptBlock(key, e); // yes, we need the encryption function, as this is CTR
+
+        return y ^ e;
     }
 }

src/main/java/ch/fhnw/kry/Decrypt.java

@@ -4,31 +4,68 @@ import java.nio.charset.StandardCharsets;
 
 import static ch.fhnw.kry.Main.BLOCK_LENGTH;
 
+/**
+ * Decrypt cipher text with CTR and SPN.
+ * <p>
+ * Some implemented functions are not as flexible as could be,
+ * as everything basically assumes a block length of 16 bits.
+ * For this learning exercise, this is satisfactory though.
+ */
 public class Decrypt {
-    public String decrypt(String keyString, String chiffre) {
+    /**
-        int key = Integer.parseInt(keyString, 2);
+     * Decrypt a cipher text with a key, using CTR and an SPN.
+     * <p>
+     * The decrypted data is interpreted as ASCII code.
+     *
+     * @param keyString Key as a bit string.
+     * @param cipher    Cipher text as a bit string.
+     * @return Decrypted data, interpreted as an ASCII string.
+     */
+    public String decrypt(String keyString, String cipher) {
+        int key = Integer.parseInt(keyString, 2); // get the key
 
-        int[] data = strToArray(chiffre);
+        int[] data = strToArray(cipher);
-        byte[] decryptedData = new byte[data.length * 2];
+        byte[] decryptedData =
-        int iv = data[0];
+            new byte[data.length * 2]; // as the block size is 16 bits, the byte array needs double the capacity
+        int iv = data[0]; // first block is the iv
         var ctr = new CTR(iv, key);
 
-        for (int i = 1; i < data.length; i++) {
+        for (int i = 0; i < data.length - 1; i++) {
             int block = data[i];
-            int decryptedBlock = ctr.decrypt(block, i);
+            int decryptedBlock = ctr.decrypt(block, i, data[i + 1]);  // y is i + 1 because i = 0 is the iv
 
-            decryptedData[i * 2] = (byte)(decryptedBlock >>> 8);
+            decryptedData[i * 2] = (byte) (decryptedBlock >>> 8); // get the upper half of the decrypted block
-            decryptedData[i * 2 + 1] = (byte)(decryptedBlock & 0x0000_00FF);
+            decryptedData[i * 2 + 1] = (byte) (decryptedBlock & 0xFF); // and the lower half
         }
 
-        String decryptedString = new String(decryptedData, StandardCharsets.US_ASCII);
+        decryptedData = removePadding(decryptedData);
 
-        return decryptedString;
+        return new String(decryptedData, StandardCharsets.US_ASCII);
+    }
+
+    /**
+     * Remove the padding of data by traversing it
+     * backwards until a byte != 0 s found and lop it off behind
+     * the found position.
+     *
+     * @param data Data with padding.
+     * @return Input data without the padding.
+     */
+    public byte[] removePadding(byte[] data) {
+        int idx = data.length - 1;
+
+        while (idx > 0 && data[idx] == 0) {
+            idx--;
+        }
+
+        byte[] unpaddedData = new byte[idx];
+        System.arraycopy(data, 0, unpaddedData, 0, idx);
+        return unpaddedData;
     }
 
     /**
      * Convert a bit string into an integer array.
-     *
+     * <p>
      * Because later we only ever look at the lower 16 bits,
      * we stuff every block of 16 bits into the lower half of an int
      * (meaning the igh 16 bits of the ints in the array are always 0).

src/main/java/ch/fhnw/kry/Main.java

@@ -6,12 +6,20 @@ package ch.fhnw.kry;
 public class Main {
 
     static final String KEY = "00111010100101001101011000111111";
-    static final String CHIFFRE =
+    static final String CIPHER =
         "00000100110100100000101110111000000000101000111110001110011111110110000001010001010000111010000000010011011001110010101110110000";
 
     static final int BLOCK_LENGTH = 16;
 
+    /**
+     * Decrypt {@link Main#CIPHER} with {@link Main#KEY}.
+     * <p>
+     * In a real program we would read those from files or command line arguments.
+     *
+     * @param args Command line arguments.
+     */
     public static void main(String[] args) {
-
+        var decrypt = new Decrypt();
+        System.out.printf("decrypted message: %s%n", decrypt.decrypt(KEY, CIPHER));
     }
 }

src/main/java/ch/fhnw/kry/SPN.java

@@ -44,6 +44,7 @@ public class SPN {
         entry(7, 0xF)
     );
     private final static int ROUND_KEY_LENGTH = 16;
+    private static final int ROUNDS = 4;
     private final Map<Integer, Integer> PERMUTATION = Map.ofEntries(
         entry(0, 0),
         entry(1, 4),
@@ -63,14 +64,11 @@ public class SPN {
         entry(15, 15)
     );
 
-
-    private static final int ROUNDS = 4;
-
     /**
      * Encrypt a block with the defined SPN.
      *
      * @param key Key for encryption (round keys get derived from this).
-     * @param x Input block (high 16 bits get ignored).
+     * @param x   Input block (high 16 bits get ignored).
      * @return Encrypted block.
      */
     public int encryptBlock(int key, int x) {
@@ -92,7 +90,7 @@ public class SPN {
      * Decrypt a block with the defined SPN.
      *
      * @param key Key for decryption (round keys get derived from this).
-     * @param x Encrypted block (high 16 bits get ignored).
+     * @param x   Encrypted block (high 16 bits get ignored).
      * @return Decrypted block.
      */
     public int decryptBlock(int key, int x) {
@@ -116,7 +114,7 @@ public class SPN {
      * bits from that position in the key.
      *
      * @param key Key as input.
-     * @param i Round number (starts at 0).
+     * @param i   Round number (starts at 0).
      * @return Derived key.
      */
     public int k(int key, int i) {
@@ -128,12 +126,12 @@ public class SPN {
 
     /**
      * Initialer Weisschritt.
-     *
+     * <p>
      * XOR an input with the key of a specific round.
      *
      * @param key Key to derive the round key.
-     * @param x Input.
+     * @param x   Input.
-     * @param r Round number (starts at 0).
+     * @param r   Round number (starts at 0).
      * @return Input xored with the derived round key.
      */
     public int init(int key, int x, int r) {
@@ -163,7 +161,7 @@ public class SPN {
     /**
      * Substitute every four bits of an input by running them through an S-Box.
      *
-     * @param x Initial state (the high 16 bits of the integer are ignored).
+     * @param x    Initial state (the high 16 bits of the integer are ignored).
      * @param sbox A mapping consisting of hex keys and values.
      * @return End state, after running all substitutions.
      */
@@ -183,7 +181,7 @@ public class SPN {
 
     /**
      * Swap two bits.
-     *
+     * <p>
      * Because we work with blocks of 16 bits, the high bits of the int input x are ignored.
      *
      * @param x Value where the bits get swapped (high 16 bits get ignored).

src/test/java/ch/fhnw/kry/CTRTest.java

@@ -2,14 +2,12 @@ package ch.fhnw.kry;
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.*;
-
 class CTRTest {
 
     @Test
     void generateIV() {
         int count = 0;
-        while(count < Integer.MAX_VALUE) {
+        while (count < Integer.MAX_VALUE) {
             int iv = CTR.generateIV();
             assert (iv < 1 << 16);
             count++;

src/test/java/ch/fhnw/kry/DecryptTest.java

@@ -2,9 +2,9 @@ package ch.fhnw.kry;
 
 import org.junit.jupiter.api.Test;
 
-import static ch.fhnw.kry.Main.CHIFFRE;
+import static ch.fhnw.kry.Main.CIPHER;
 import static ch.fhnw.kry.Main.KEY;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class DecryptTest {
 
@@ -12,7 +12,8 @@ class DecryptTest {
     void strToArray() {
         var decrypt = new Decrypt();
 
-        String input = "00000100110100100000101110111000000000101000111110001110011111110110000001010001010000111010000000010011011001110010101110110000";
+        String input =
+            "00000100110100100000101110111000000000101000111110001110011111110110000001010001010000111010000000010011011001110010101110110000";
         int[] data = decrypt.strToArray(input);
 
         assertEquals(8, data.length);
@@ -23,6 +24,6 @@ class DecryptTest {
     @Test
     void decrypt() {
         var decrypt = new Decrypt();
-        String decrypted = decrypt.decrypt(KEY, CHIFFRE);
+        assertEquals("Gut gemacht!", decrypt.decrypt(KEY, CIPHER));
     }
 }

src/test/java/ch/fhnw/kry/SPNTest.java

@@ -2,7 +2,7 @@ package ch.fhnw.kry;
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class SPNTest {
 
@@ -11,9 +11,9 @@ class SPNTest {
         var spn = new SPN();
 
         final int key = 0xFFFFFFFF;
-        assertEquals(0xFFFF,  spn.k(key, 0));
+        assertEquals(0xFFFF, spn.k(key, 0));
-        assertEquals(0xFFFF,  spn.k(key, 1));
+        assertEquals(0xFFFF, spn.k(key, 1));
-        assertEquals(0xFFFF,  spn.k(key, 2));
+        assertEquals(0xFFFF, spn.k(key, 2));
     }
 
     @Test
@@ -66,7 +66,7 @@ class SPNTest {
     void blockEncryptionDecryption() {
         var spn = new SPN();
 
-        int x = 0x128F ;
+        int x = 0x128F;
         int key = 0x11288C00;
         int y = 0xAEB4;