org.springframework.security.crypto.encrypt.Encryptors Java Examples

public static void main(String[] args) {

        TextEncryptor encryptor =
            Encryptors.delux("pass", new String(Hex.encode("salt".getBytes(Charset.forName("utf-8")))));
        System.out.println(encryptor.encrypt("sadfsadfasfsadf"));
        System.out.println(encryptor.encrypt("sadfsadfasfsadf"));
        System.out.println(encryptor.decrypt(encryptor.encrypt("这是密码")));
    }
 

@Test
public void testDecryptCompositePropertySource() {
	ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
	EnvironmentDecryptApplicationInitializer initializer = new EnvironmentDecryptApplicationInitializer(
			Encryptors.noOpText());

	MapPropertySource devProfile = new MapPropertySource("dev-profile",
			Collections.singletonMap("key", "{cipher}value1"));

	MapPropertySource defaultProfile = new MapPropertySource("default-profile",
			Collections.singletonMap("key", "{cipher}value2"));

	CompositePropertySource cps = mock(CompositePropertySource.class);
	when(cps.getPropertyNames()).thenReturn(devProfile.getPropertyNames());
	when(cps.getPropertySources())
			.thenReturn(Arrays.asList(devProfile, defaultProfile));
	ctx.getEnvironment().getPropertySources().addLast(cps);

	initializer.initialize(ctx);
	then(ctx.getEnvironment().getProperty("key")).isEqualTo("value1");
}
 

@Test
public void testDecryptNonStandardParent() {
	ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
	EnvironmentDecryptApplicationInitializer initializer = new EnvironmentDecryptApplicationInitializer(
			Encryptors.noOpText());

	TestPropertyValues.of("key:{cipher}value").applyTo(ctx);

	ApplicationContext ctxParent = mock(ApplicationContext.class);
	when(ctxParent.getEnvironment()).thenReturn(mock(Environment.class));

	ctx.setParent(ctxParent);

	initializer.initialize(ctx);

	then(ctx.getEnvironment().getProperty("key")).isEqualTo("value");
}
 

@Test
public void errorOnDecrypt() {
	this.listener = new EnvironmentDecryptApplicationInitializer(
			Encryptors.text("deadbeef", "AFFE37"));
	ConfigurableApplicationContext context = new AnnotationConfigApplicationContext();
	TestPropertyValues.of("foo: {cipher}bar").applyTo(context);
	// catch IllegalStateException and verify
	try {
		this.listener.initialize(context);
	}
	catch (Exception e) {
		then(e).isInstanceOf(IllegalStateException.class);
	}
	// Assert logs contain warning even when exception thrown
	String sysOutput = this.outputCapture.toString();
	then(sysOutput).contains("Cannot decrypt: key=foo");
}
 

@Override
public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {
	JpaUsersConnectRepository repository = new JpaUsersConnectRepository(userConnectionRepository,
			connectionFactoryLocator, Encryptors.noOpText());
	if (connectionSignUp != null) {
		repository.setConnectionSignUp(connectionSignUp);
	}
	return repository;
}
 

@Override
public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {
    MongoUsersConnectionRepositoryImpl repository = new MongoUsersConnectionRepositoryImpl(
            userSocialConnectionRepository, (SocialAuthenticationServiceLocator)connectionFactoryLocator, Encryptors.noOpText());
    repository.setConnectionSignUp(autoConnectionSignUp());
    return repository;
}
 

@Test
public void shouldEncryptUsingApplicationAndProfiles() {

	this.controller = new EncryptionController(
			new SingleTextEncryptorLocator(Encryptors.text("application", "11")));

	// when
	String encrypted = this.controller.encrypt(this.application, this.profiles,
			this.data, TEXT_PLAIN);

	// then
	assertThat(this.controller.decrypt(this.application, this.profiles, encrypted,
			TEXT_PLAIN)).isEqualTo(this.data);
}
 

@Bean
public TextEncryptor defaultTextEncryptor() {
	if (this.locator != null) {
		return new LocatorTextEncryptor(this.locator);
	}
	if (StringUtils.hasText(this.key.getKey())) {
		return new EncryptorFactory(this.key.getSalt()).create(this.key.getKey());
	}
	return Encryptors.noOpText();
}
 

@Test
public void errorOnDecryptWithEmpty() {
	this.listener = new EnvironmentDecryptApplicationInitializer(
			Encryptors.text("deadbeef", "AFFE37"));
	this.listener.setFailOnError(false);
	ConfigurableApplicationContext context = new AnnotationConfigApplicationContext();
	TestPropertyValues.of("foo: {cipher}bar").applyTo(context);
	this.listener.initialize(context);
	// Assert logs contain warning
	String sysOutput = this.outputCapture.toString();
	then(sysOutput).contains("Cannot decrypt: key=foo");
	// Empty is safest fallback for undecryptable cipher
	then(context.getEnvironment().getProperty("foo")).isEqualTo("");
}
 

/**
 * Returns decrypted text from a Base64 string composed by the salt followed
 * by the encrypted data.
 */
@Override
public String decrypt(String base64Data) {

    byte[] bytes = Base64.getDecoder().decode(base64Data);
    byte[] saltBytes = ArrayUtils.subarray(bytes, 0, 8);
    byte[] encryptedBytes = ArrayUtils.subarray(bytes, 8, bytes.length);

    String salt = new String(Hex.encode(saltBytes));
    BytesEncryptor encryptor = Encryptors.standard(key, salt);

    return new String(encryptor.decrypt(encryptedBytes));
}
 

/**
 * Returns a Base64 string composed by the salt followed by the encrypted
 * data.
 */
@Override
public String encrypt(String plainText) {

    // default StringKeyGenerator returns a 8 bytes hex-encoded string
    String salt = KeyGenerators.string().generateKey();

    BytesEncryptor encryptor = Encryptors.standard(key, salt);
    byte[] encrypted = encryptor.encrypt(plainText.getBytes());

    byte[] saltAndSecret = ArrayUtils.addAll(Hex.decode(salt), encrypted);
    return Base64.getEncoder().encodeToString(saltAndSecret);
}
 

/**
 * Method to decrypt fields based on {@link Encrypt} annotation.
 *
 * @param obj entity object
 */
public static void decrypt(Object obj) throws IllegalAccessException {
    CharSequence salt = getSalt(obj);

    TextEncryptor encryptor = Encryptors.text(secretKey, salt);
    for (Field field : obj.getClass().getDeclaredFields()) {
        if (field.isAnnotationPresent(Encrypt.class)) {
            field.setAccessible(true);
            field.set(obj, encryptor.decrypt((String) field.get(obj)));
            field.setAccessible(false);
        }
    }
}
 

/**
 * Method to encrypt fields based on {@link Encrypt} annotation.
 *
 * @param obj entity object
 */
public static void encrypt(Object obj) throws IllegalAccessException {
    CharSequence salt = getSalt(obj);

    TextEncryptor encryptor = Encryptors.text(secretKey, salt);
    for (Field field : obj.getClass().getDeclaredFields()) {
        if (field.isAnnotationPresent(Encrypt.class)) {
            field.setAccessible(true);
            field.set(obj, encryptor.encrypt((String) field.get(obj)));
            field.setAccessible(false);
        }
    }
}
 

public String decrypt(String encryptedValue) {
    try {
        String password = getPassword();
        String salt = getEncodedSalt();
        if (StringUtils.isNotBlank(encryptedValue) && StringUtils.isNotBlank(password) && StringUtils.isNotBlank(salt)) {
            TextEncryptor decryptor = Encryptors.delux(password, salt);
            return decryptor.decrypt(encryptedValue);
        }
    } catch (IllegalArgumentException | IllegalStateException | NullPointerException ex) {
        logger.error("Error decrypting value", ex);
    }
    return StringUtils.EMPTY;
}
 

public String encrypt(String value) {
    String password = getPassword();
    String salt = getEncodedSalt();
    if (StringUtils.isNotBlank(value) && StringUtils.isNotBlank(password) && StringUtils.isNotBlank(salt)) {
        TextEncryptor encryptor = Encryptors.delux(password, salt);
        return encryptor.encrypt(value);
    }
    return StringUtils.EMPTY;
}
 

@Override
public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {
    PreJdbcUsersConnectionRepository repository = new PreJdbcUsersConnectionRepository(dataSource,
            connectionFactoryLocator, Encryptors.noOpText());
    repository.setTablePrefix("social_");
    return repository;
}
 

public EncryptionComponent(String encryptKey) {
    if (encryptKey != null) {
        this.textEncryptor = Encryptors.text(encryptKey, "deadbeef"); //$NON-NLS-1$
    } else {
        this.textEncryptor = null;
    }
}
 

/**
 * Gets users connection repository.
 *
 * @param connectionFactoryLocator the connection factory locator
 *
 * @return the users connection repository
 */
@Override
public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {
	JdbcUsersConnectionRepository repository = new JdbcUsersConnectionRepository(dataSource, connectionFactoryLocator, Encryptors.noOpText());
	repository.setTablePrefix("pc_uac_");
	if (connectionSignUp != null) {
		repository.setConnectionSignUp(connectionSignUp);
	}
	return repository;
}
 

@Bean
public TextEncryptor getTextEncryptor() {
    return Encryptors.noOpText();
}
 

public AesGcmPasswordEncoder(String password, String salt) {
    this.encryptor = Encryptors.delux(password, salt);
}
 

@Bean
public TextEncryptor textEncryptor() {
    return Encryptors.noOpText();
}
 

@Override
public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {
    return new JpaUsersConnectionRepository(jpaTemplate, connectionFactoryLocator, Encryptors.noOpText());
}
 

@Override
public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {
    JdbcUsersConnectionRepository repository = new JdbcUsersConnectionRepository(dataSource,connectionFactoryLocator, Encryptors.noOpText());
    repository.setConnectionSignUp(new AccountConnectionSignUpService(usersDao));
    return repository;
}
 

public StandardStringEncryptor(String password, String salt) {
    super(password, salt);
    encryptor = Encryptors.text(super.getPassword(), super.getSalt());
}
 

public SingleTextEncryptorLocator(TextEncryptor encryptor) {
	this.encryptor = encryptor == null ? Encryptors.noOpText() : encryptor;
}
 

@Bean
public TextEncryptor textEncryptor() {
	return Encryptors.noOpText();
}
 

public StrongStringEncryptor(String password, String salt) {
    super(password, salt);
    encryptor = Encryptors.delux(super.getPassword(), super.getSalt());
}
 

@Override
public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {
    JdbcUsersConnectionRepository jdbcUsersConnectionRepository = new JdbcUsersConnectionRepository(dataSource, connectionFactoryLocator, Encryptors.noOpText());
    jdbcUsersConnectionRepository.setTablePrefix("t_");
    return jdbcUsersConnectionRepository;
}
 

@Bean
public TextEncryptor getTextEncryptor() {
    return Encryptors.text(encryptKey, "deadbeef");
}
 

@Bean
TextEncryptor textEncryptor() {
    return Encryptors.noOpText();
}