HashMap with integers as key and value takes too long to finish work

Question

I am working with meet-in-the-middle attack on 2DES. I have implemented the DES encryption/decryption and it is working. The way I am trying to achieve this is by storing, within a for loop, the intermediate ciphers as the key of a HashMap and the possible keys as the values of the HashMap. Both as integers - Started with byte[], but figured out that a key cannot be an array. However, within this for loop I also want to make sure that the possible keys are unique i.e. I have a while loop, which makes sure that the size of the HashMap is 2^20 (only 20 bits of the DES key are effective). Aftwards, I try to find the keys, which have matching intermediate cipher text by iterating through the HashMap with a foreach and compare each intermediate cipher text from the encryptions with the intermediate cipher text from the decryptions.

However, I am unable to find the match as it takes too long to finish. I have been waiting for like 20 mins without any result.

while (intermediateCipher.size() < Math.pow(2, 20)) {
            byte[] key = generateDesKey();

            intermediateCipher.put(ByteBuffer.wrap(encrypt(key, plainText)).getInt() , ByteBuffer.wrap(key).getInt());
        } 

        int count = 0;
        for (Entry<Integer, Integer> arr : intermediateCipher.entrySet()) {
            byte[] k2 = ByteBuffer.allocate(8).putInt(arr.getValue()).array();
            int temp = ByteBuffer.wrap(decrypt(k2, cipherText2)).getInt();
            if (intermediateCipher.containsKey(temp)) {
                count++;
                byte[] k1 = ByteBuffer.allocate(8).putInt(intermediateCipher.get(temp)).array();

                if (encrypt(k2, encrypt(k1, plainText)) == cipherText2) {
                    System.out.println("Key is " + k1 + " " + k2);
                }
            }
        }

intermediateCipher is my HashMap .

PlainText is a byte[] of 8 bytes, cipherText2 is the encryption result of 2DES on the plainText and generateDesKey is the method which generates 64 bits, where the parity bits are skipped in order to make sure that the 20 bits are effective, and convert the bits to a byte[] as DES requires that

Answer 1

After reading your code, I have several suggestions to optimize it:

1. Most important: Do not waste effort accessing the map twice if you can access just once: Instead of:

    if (intermediateCipher.containsKey(temp)) {
        byte[] k1 = intermediateCipher.get(temp);
        ...
    }

... reduce it to:

    byte[] k1 = intermediateCipher.get(temp);
    if (k1!=null) {
        ...
    }

2. There is too much memory allocating within the loops, because it is useless to create a new ByteBuffer only for temporary operations and then discard it (too much GC overworking). If you are certain that the byte buffers used will have length 8 (or less), you can use a single buffer in the first loop:

   ByteBuffer tempBuffer=ByteBuffer.allocate(8);
   while (intermediateCipher.size() < Math.pow(2, 20)) {
       // Note: A call to rewind() must be done before each put/get operation on the buffer:
       byte[] key = generateDesKey();
       tempBuffer.rewind();
       tempBuffer.put(encrypt(key, plainText));
       tempBuffer.rewind();
       int mapKey=tempBuffer.getInt();
       tempBuffer.rewind();
       tempBuffer.put(key);
       tempBuffer.rewind();
       int mapValue=tempBuffer.getInt();
       intermediateCipher.put(mapKey, mapValue);
   }
   

In the second loop, a similar transformation could be done.

3. As @Thilo suggested in a comment, it is always a good practice to pre-size your map in function of the expected maximum size. It shall go like this: Map<...> intermediateCipher=new HashMap<...>((int)(1.7d * expectedSize));

4. Loop while (intermediateCipher.size() < Math.pow(2, 20)) shall be simplified to int len=Math.pow(2, 20); for (int i=0;i<len;i++)

Update

5. If the call generateDesKey() returns the same on every iteration, you can set it before the loop.

Answer 2

Here are some things you can try to shorten running time.

First, switch from HashMap to TreeMap. When a HashMap becomes too large, like 2^20, searching in the worst case is expected to go from O(1) to O(n), because all slots in the hash table are full with a large number of entries. However, TreeMap searching always runs in O(lg n).

Secondly, switch from Map<Integer, Integer> to Map<Integer, byte[]>. You only need to convert the Map keys to integers; you can leave the values as byte arrays, resulting in significantly fewer byte[] -> ByteBuffer -> int conversions.

Map<Integer, byte[]> intermediateCipher = new TreeMap<>();

and

while (intermediateCipher.size() < Math.pow(2, 20)) {
    byte[] key = generateDesKey();
    int encrypted = ByteBuffer.wrap(encrypt(key, plainText)).getInt();
    intermediateCipher.put(encrypted, key);
} 

int count = 0;
for (Entry<Integer, byte[]> arr : intermediateCipher.entrySet()) {
    byte[] k2 = arr.getValue();
    int temp = ByteBuffer.wrap(decrypt(k2, cipherText2)).getInt();

    if (intermediateCipher.containsKey(temp)) {
        count++;
        byte[] k1 = intermediateCipher.get(temp);
        if (encrypt(k2, encrypt(k1, plainText)) == cipherText2) {
            System.out.println("Key is " + k1 + " " + k2);
        }
    }
}