How to decrypt AES with an unknown KEY and IV in Java?

Question

so I'm creating a game for my A level project and I'm now at the stage where I need to be able to encrypt and decrypt text files.

I have figured out encryption using AES-256 in GCM mode however I am using a randomly generated key and IV in order to encrypt the data in the first place. So I was wondering, is there any way in which I can decrypt the text file without knowing the key and iv. Alternatively, from the encryption method shown below, is there anything I could change so that I will know the key and iv when decrypting the text later on.

NOTE: I'm using the libGDX library to create the game which is why I'm not using the standard method to write to the text file.

Encryption method:

public void encrypt ()
{
    byte[] input = w.getSprites().toString().getBytes(); // Data to be encrypted
    byte[] encrypted = null; // Encrypted output
    Cipher cipher; // Cipher algorithm to be used

    try {

        // Setup the cipher algorithm to use and select the wanted mode
        // AES is the cipher algorithm GCM is the mode
        cipher = Cipher.getInstance("AES/GCM/NoPadding");

        // Generate a random key for the encryption
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        keyGenerator.init(256);
        SecretKey key = keyGenerator.generateKey();

        // Generate a random iv for the encryption
        SecureRandom randomSecureRandom = new SecureRandom();
        byte[] iv = new byte[cipher.getBlockSize()];
        randomSecureRandom.nextBytes(iv);

        // Encrypt the data
        cipher.init(Cipher.ENCRYPT_MODE, key, randomSecureRandom);
        encrypted = new byte[cipher.getOutputSize(input.length)];
        int enc_len = cipher.update(input, 0, input.length, encrypted, 0);
        enc_len += cipher.doFinal(encrypted, enc_len);
    }
    catch (NoSuchAlgorithmException | 
           NoSuchPaddingException | 
           InvalidKeyException | 
           ShortBufferException | 
           IllegalBlockSizeException | 
           BadPaddingException e) { e.printStackTrace(); }

    FileHandle f = Gdx.files.local("bin/default/saves/default/test.txt");
    f.writeString(encrypted.toString(), false);
}

Thank you in advance for any answers, they are very much appreciated.

Answer 1

No, you cannot decrypt without knowing the key. What would the point of encryption be if anyone could decrypt the message without even having the key?

If this is intended to hide data from a local user, then pretty much the best you can is obfuscate the data. The machine needs to know the key in order to encrypt and decrypt it and anyone with access to that machine can eventually find that key and use it to decrypt the data for themselves. Even if you don't write anything to disk, local users could look at memory and find the key. Also remember that code can be decompiled.

Basically just keep in mind that anyone with physical access is king and you can't really stop them, just slow them down.

So the best you can do is make it as painful as possible to get the key. String literals in classfiles or property files are easy to read and not at all painful so avoid using those.

See this question for related ways to handle local security.

Also consider using a tool like Proguard to obfuscate (and optimize) your code in general as well.

Answer 2

You could try a brute force attack.

Breaking a symmetric 256-bit key by brute force requires 2128 times more computational power than a 128-bit key. Fifty supercomputers that could check a billion billion (1018) AES keys per second (if such a device could ever be made) would, in theory, require about 3×1051 years to exhaust the 256-bit key space.

Per wikipedia

In reality the 256-bit AES is considered computationally infeasible. The only 'feasible' way to decrypt would be using the same key used to encrypt. Some background on AES.

There is a faster method (still computationally infeasible for 256 bit) called Biclique attack. but I think this is a bit outside the scope of what your asking.

If you decide you need to pass your AES key from the encryption person to the decrytion person you can use RSA encryption which uses asymetric keys. Take a look at my github for a basic RSA implementation.