Support for EncryptableProperties about owner HOT 8 OPEN

import org.aeonbits.owner.Config;
import org.aeonbits.owner.ConfigFactory;
import org.aeonbits.owner.Converter;
import sun.misc.BASE64Decoder;

import java.io.IOException;
import java.lang.reflect.Method;

/**
 * To encrypt the password:
 *   System.out.println(new BASE64Encoder().encode(xor("tiger".getBytes(), "secret".getBytes())));
 */

public class EncryptedPropertiesExample {

    interface EncryptedConfiguration extends Config {
        @ConverterClass(DecryptConverter.class)
        @DefaultValue("BwwEFxc=")
        String scottPassword();
    }

    public static class DecryptConverter implements Converter {
        public Object convert(Method method, String input) {
            try {
                String key = System.getProperty("example.encryption.key");
                return new String(xor(new BASE64Decoder().decodeBuffer(input), key.getBytes()));
            } catch (IOException e) {
                throw new UnsupportedOperationException(e);
            }
        }
    }

    public static void main(String[] args) {
        System.setProperty("example.encryption.key", "secret");
        EncryptedConfiguration example = ConfigFactory.create(EncryptedConfiguration.class);
        System.out.println(example.scottPassword());
    }

    private static byte[] xor(final byte[] input, final byte[] secret) {
        final byte[] output = new byte[input.length];
        if (secret.length == 0) {
            throw new IllegalArgumentException("empty encryption key");
        }
        int spos = 0;
        for (int pos = 0; pos < input.length; ++pos) {
            output[pos] = (byte) (input[pos] ^ secret[spos]);
            ++spos;
            if (spos >= secret.length) {
                spos = 0;
            }
        }
        return output;
    }
}

public static class EncryptedValueConverter implements Converter<String> {
        @Override
        public String convert(Method method, String input) {
            return (PropertyValueEncryptionUtils.isEncryptedValue(input) ? PropertyValueEncryptionUtils.decrypt(input, getEncryptor()) : input);
        }

    private StringEncryptor getEncryptor() {
        EnvironmentStringPBEConfig config = new EnvironmentStringPBEConfig();
        config.setAlgorithm("PBEWITHMD5ANDDES");
        config.setPasswordEnvName("PASSWORD");

        StandardPBEStringEncryptor standardPBEStringEncryptor = new StandardPBEStringEncryptor();
        standardPBEStringEncryptor.setConfig(config);
        return standardPBEStringEncryptor;
    }
}

    @DecrypterManagerClass(SampleDecrypter.class)
    public interface SampleConfig extends Config {
        @Key("password")
        @EncryptedKey
        @DefaultValue("LEXKJVu5XG/0fSgAROlfSG+a5TfXz4HeJ/tbjUuM8cg=")
        String password();

        @Key("myapp.username")
        String username;

import java.io.UnsupportedEncodingException;
import java.security.Key;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

import javax.xml.bind.DatatypeConverter;

public class AESEncryption {
    public static final String ALGORITHM = "AES";

    private final String encoding;
    private final byte[] keyValue;

    public String getAlgorithm() {
        return AESEncryption.ALGORITHM;
    }

    public AESEncryption( String keyValue )
    throws UnsupportedEncodingException {
        this ( keyValue, "UTF-8" );
    }

    public AESEncryption( String keyValue, String encoding )
    throws UnsupportedEncodingException {
        this.encoding = encoding;
        this.keyValue = keyValue.getBytes( encoding );
    }

    public String encrypt(String plainData) throws Exception {
        Key key = generateKey();
        Cipher c = Cipher.getInstance(ALGORITHM);
        c.init(Cipher.ENCRYPT_MODE, key);
        byte[] encVal = c.doFinal( plainData.getBytes( this.encoding ) );
        String encryptedValue = DatatypeConverter.printBase64Binary( encVal );
        return encryptedValue;
    }

    public String decrypt(String encryptedData) throws Exception {
        Key key = generateKey();
        Cipher c = Cipher.getInstance( ALGORITHM );
        c.init(Cipher.DECRYPT_MODE, key);
        byte[] decordedValue = DatatypeConverter.parseBase64Binary( encryptedData );
        byte[] decValue = c.doFinal(decordedValue);
        String decryptedValue = new String(decValue, this.encoding );
        return decryptedValue;
    }

    private Key generateKey() throws Exception {
        return new SecretKeySpec( this.keyValue, this.getAlgorithm() );
    }
}

import java.io.UnsupportedEncodingException;
import org.junit.Assert;
import org.junit.Test;

public class AESEncryptionTestCase {
    @Test
    public void encriptionDecriptionTest()
    throws UnsupportedEncodingException, Exception {
        String cipherKey = "ABCDEFGH12345678";
        String expectedValue = "This is a decoded value";
        AESEncryption aes = new AESEncryption( cipherKey );
        String encriptedValue = aes.encrypt( expectedValue );
        System.out.println( "Encripted=" + encriptedValue );
        String decriptedValue = aes.decrypt( encriptedValue );
        System.out.println( "Decripted=" + decriptedValue);
        Assert.assertEquals("The decripted value is not the same as original value", expectedValue, decriptedValue);
    }
}