There other day I needed to encrypt certain properties in our XML configuration files. But there were few challanges that needed to be addressed

• Use existing Java installation
• !!! How will Master Encryption Key be derives and stored !!!

First restriction is very important as it limits us to what algorithmic and key sizes can be used, adding Java Cryptography Extension was not a option.

This limited us to using AES with key size 128, using 256 would give us an exception.

java.security.InvalidKeyException:Illegal key size or default parameters

Second important question raised was “How will the master password be derived and possibly stored ?”, there are a number of approaches to this and each have its advantages, but the constraint here is that there should be no user interaction involved.

Few of the approaches considered

Passing password as a environment variable

This requires users to modify the startup parameters and the password is plain text

Prompting user to provider password when they start the application

This is good method(KeePass use it) but it requires user interaction, which was not acceptable in my case

Generating unique machine key

This method is not the best but it does work well, as long as the attacker don’t know how the key was generated.

Approach chosen by me was to use the machine generated key/id, I have chooses the MAC address as the machine key, I know it can be easily spoofed but if the attacker is that dedicated then I am screwed anyway.

Machine key generation algorithm is is straight forward. First we will try to obtain the MAC Address from the network interface, if that fails we we try to use the machine name obtained from the RuntimeMXBean, this is very depended on what JVM we are using as there is no guarantee what getName() method will return, if this fails we will fall back to using
System.getenv("COMPUTERNAME"), if all this fails we simply throw an exception.

Encrypted Message Format

CRYPT:Ss3iHK6kHLswAh7AyoHdo1dbbTJt0UpLxVNRZ9W+bks=

Encrypted messages can be broken down into three parts

Identifier : CRYPT used to indicate that this property have been encrypted
Initial Vector + Data : Ss3iHK6kHLswAh7AyoHdo1dbbTJt0UpLxVNRZ9W+bks=

Because we know the IV size(128 bits) we can prepend that to the begging of our encrypted message, so when we are decrypting the message we know that first 128bits will be the IV.

Example Usage

  AESEncryptDecryptUtil util = new AESEncryptDecryptUtil();
        String encrypedMessage = util
            .encrypt("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin scelerisque sodales augue, ac tristique nibh euismod nec. ");
        boolean status = util.isEncrypted(encrypedMessage);

        System.out.println("Encrypted : " + encrypedMessage);
        System.out.println("Message encrypted : " + status);
        System.out.println("Decrypted : " + util.decrypt(encrypedMessage));

Encrypting Properties

   public String getUserName()
    {
        try
        {
            AESEncryptDecryptUtil util = new AESEncryptDecryptUtil();
            if (util.isEncrypted(userName))
            {
                return util.decrypt(userName);
            }
        }
        catch (EncryptDecryptException e)
        {
            e.printStackTrace();
        }
        return userName;
    }

Output

Encrypted : CRYPT:keGhiojDBpgsUkdepcT6aFvzR0Jpsmi4no3TwP3OzFbAmjvvBxkSQHMyQ8uM81PTCTEWebe3HrE5
o/+jLgdmQB+CDxBMUvUrFRvFFAGsrCcS+cWgYTi+T5/LTUFonXBOc5r++GQbV2htxy9YislL2JPT
vMQAGrgMjOFTDBZvuJdeUIC6uKWjtndJidxigxHB
Message encrypted : true
Decrypted : Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin scelerisque sodales augue, ac tristique nibh euismod nec.

Code Listing

import java.io.UnsupportedEncodingException;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.security.AlgorithmParameters;
import java.security.InvalidKeyException;
import java.security.spec.InvalidParameterSpecException;
import java.security.spec.KeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * AES Encryption/Decryption Utility that uses MAC address as the Master
 * Encryption Key Initial Vector need to be stored together with the encrypted
 * string so that we can use it to decrypt the message. This is the format that
 * will be produced from the encryption, both encrypted message and initial
 * vector are base 64 encoded, in UTF-8 char set
 * CRYPT:initialVector+encryptedMessage
 * 
 * @author gbugaj
 */
public class AESEncryptDecryptUtil
{

    private static final int ITERATIONS = 65536;

    private static final String STRING_ENCODING = "UTF-8";

    private static final String CRYPT_PREFIX = "CRYPT";

    /**
     * If we user Key size of 256 we will get java.security.InvalidKeyException:
     * Illegal key size or default parameters , Unless we configure Java
     * Cryptography Extension 128
     */
    private static final int KEY_SIZE = 128;

    private static final byte[] SALT = { (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0 };

    private SecretKeySpec secret;

    private Cipher cipher;

    private BASE64Encoder base64Encoder;

    private BASE64Decoder base64Decoder;

    private AESEncryptDecryptUtil() throws EncryptDecryptException
    {
        try
        {
            /* Derive the key, given password and salt. */
            SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
            KeySpec spec;

            spec = new PBEKeySpec(getHardwareKey(), SALT, ITERATIONS, KEY_SIZE);
            SecretKey tmp = factory.generateSecret(spec);
            secret = new SecretKeySpec(tmp.getEncoded(), "AES");

            // CBC = Cipher Block chaining
            // PKCS5Padding Indicates that the keys are padded
            cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");

            // For production use commons base64 encoder
            base64Decoder = new BASE64Decoder();
            base64Encoder = new BASE64Encoder();
        }
        catch (Exception e)
        {
            throw new EncryptDecryptException("Unable to initialize", e);
        }

    }

    /**
     * Get hardware key to be used for encryption, we rely on MAC address as the
     * key, with fallback to JVM name then windows machine name
     * 
     * @return key as char[]
     * @throws EncryptDecryptException
     */
    private char[] getHardwareKey() throws EncryptDecryptException
    {

        // Exceptions from this are ignored as we move to next available method
        try
        {
            InetAddress address = InetAddress.getLocalHost();
            NetworkInterface nic = NetworkInterface.getByInetAddress(address);
            if (nic != null)
            {
                byte[] mac = nic.getHardwareAddress();
                if (mac != null && mac.length > 0)
                {
                    return new String(mac, STRING_ENCODING).toCharArray();
                }
            }
        }
        catch (UnknownHostException e)
        {
            e.printStackTrace();
        }
        catch (SocketException e)
        {
            e.printStackTrace();
        }
        catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
        }

        // Could not obtain MAC Address so we are falling back on the computer
        // name then on the JVM Name
        RuntimeMXBean rmx = ManagementFactory.getRuntimeMXBean();
        String jvmName = rmx.getName();
        String[] parts = jvmName.split("@");
        if (parts.length > 0)
        {
            String name = parts[1];
            if (name != null && !name.isEmpty())
            {
                return name.toCharArray();
            }
        }

        String name = System.getenv("COMPUTERNAME");
        if (name != null && !name.isEmpty())
        {
            return name.toCharArray();
        }
        throw new EncryptDecryptException("Unable to obtain Secure Key");
    }

    /**
     * Encrypt given input string
     * 
     * @param input
     * @return
     * @throws EncryptDecryptException
     */
    public String encrypt(String input) throws EncryptDecryptException
    {
        try
        {
            byte[] inputBytes = input.getBytes(STRING_ENCODING);
            cipher.init(Cipher.ENCRYPT_MODE, secret);
            AlgorithmParameters params = cipher.getParameters();
            byte[] iv = params.getParameterSpec(IvParameterSpec.class).getIV();
            byte[] ciphertext = cipher.doFinal(inputBytes);
            byte[] out = new byte[iv.length + ciphertext.length];
            System.arraycopy(iv, 0, out, 0, iv.length);
            System.arraycopy(ciphertext, 0, out, iv.length, ciphertext.length);
            return CRYPT_PREFIX + ":" + base64Encoder.encode(out);
        }

        catch (IllegalBlockSizeException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
        catch (BadPaddingException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
        catch (InvalidKeyException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
        catch (InvalidParameterSpecException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
        catch (UnsupportedEncodingException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
    }

    /**
     * Decrypt input string
     * 
     * @param input
     * @return decrypted string
     * @throws EncryptDecryptException
     */
    @SuppressWarnings("restriction")
    public String decrypt(String input) throws EncryptDecryptException

    {
        if (!input.startsWith(CRYPT_PREFIX))
        {
            throw new EncryptDecryptException("Unable to decrypt, input string does not start with 'CRYPT'");
        }

        try
        {
            byte[] data = base64Decoder.decodeBuffer(input.substring(6, input.length()));
            int keylen = KEY_SIZE / 8;
            byte[] iv = new byte[keylen];
            System.arraycopy(data, 0, iv, 0, keylen);
            cipher.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(iv));
            return new String(cipher.doFinal(data, keylen, data.length - keylen), STRING_ENCODING);
        }
        catch (Exception e)
        {
            throw new EncryptDecryptException("Unable to decrypt ", e);
        }
    }

    /**
     * Helper Exception to wrap arround Encryption/Decryption exceptions
     */
    @SuppressWarnings("serial")
    private static class EncryptDecryptException extends Exception
    {
        public EncryptDecryptException()
        {
            super();
        }

        public EncryptDecryptException(String msg)
        {
            super(msg);
        }

        public EncryptDecryptException(String msg, Throwable t)
        {
            super(msg, t);
        }

        public EncryptDecryptException(Throwable t)
        {
            super(t);
        }
    }

    /**
     * Check if given string is already encrypted
     * 
     * @param input
     * @return
     */
    private boolean isEncrypted(String input)
    {
        if (input == null || input.isEmpty())
        {
            return false;
        }
        return input.startsWith(CRYPT_PREFIX);
    }

    public static void main(String[] args) throws EncryptDecryptException
    {
        AESEncryptDecryptUtil util = new AESEncryptDecryptUtil();
        String encrypedMessage = util
            .encrypt("TEST");
        boolean status = util.isEncrypted(encrypedMessage);

        System.out.println("Encrypted : " + encrypedMessage);
        System.out.println("Message encrypted : " + status);
        System.out.println("Decrypted : " + util.decrypt(encrypedMessage));
    }

}