import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
public static String encrypt(final String plain) {
    if (!EncryptionSecretKeyChecker.useEncryption() || (plain == null) || plain.isEmpty()) {
        return plain;
    }
    if (s_encryptor == null) {
        initialize();
    }
    String encryptedString = null;
    try {
        encryptedString = s_encryptor.encrypt(plain);
    } catch (final EncryptionOperationNotPossibleException e) {
        s_logger.debug("Error while encrypting: " + plain);
        throw e;
    }
    return encryptedString;
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
public static String decrypt(final String encrypted) {
    if (!EncryptionSecretKeyChecker.useEncryption() || (encrypted == null) || encrypted.isEmpty()) {
        return encrypted;
    }
    if (s_encryptor == null) {
        initialize();
    }

    String plain = null;
    try {
        plain = s_encryptor.decrypt(encrypted);
    } catch (final EncryptionOperationNotPossibleException e) {
        s_logger.debug("Error while decrypting: " + encrypted);
        throw e;
    }
    return plain;
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
@Test
public void testStrongEncryptionAndDecryption() throws IOException {
  String password = UUID.randomUUID().toString();
  String masterPassword = UUID.randomUUID().toString();
  File masterPwdFile = getMasterPwdFile(masterPassword);
  State state = new State();
  state.setProp(ConfigurationKeys.ENCRYPT_KEY_LOC, masterPwdFile.toString());
  state.setProp(ConfigurationKeys.ENCRYPT_USE_STRONG_ENCRYPTOR, true);
  try{
    StrongTextEncryptor encryptor = new StrongTextEncryptor();
    encryptor.setPassword(masterPassword);
    String encrypted = encryptor.encrypt(password);
    encrypted = "ENC(" + encrypted + ")";
    String decrypted = PasswordManager.getInstance(state).readPassword(encrypted);
    Assert.assertEquals(decrypted, password);
  }
  catch (EncryptionOperationNotPossibleException e) {
    //no strong encryption is supported
  }
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
public static byte[] fromHexadecimal(final String message) {
    if (message == null) {
        return null;
    }
    if ((message.length() % 2) != 0) {
        throw new EncryptionOperationNotPossibleException();
    }
    try {
        final byte[] result = new byte[message.length() / 2];
        for (int i = 0; i < message.length(); i = i + 2) {
            final int first = Integer.parseInt("" + message.charAt(i), 16);
            final int second = Integer.parseInt("" + message.charAt(i + 1), 16);
            result[i/2] = (byte) (0x0 + ((first & 0xff) << 4) + (second & 0xff));
        }
        return result;
    } catch (Exception e) {
        throw new EncryptionOperationNotPossibleException();
    }
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
@Test
public void shouldWrapExceptionOnEncryptionError() {
    // given
    StandardEnvironment environment = new StandardEnvironment();
    Properties props = new Properties();
    props.put("propertyDecryption.password", "NOT-A-PASSWORD");
    props.put("someProperty", "{encrypted}NOT-ENCRYPTED");
    environment.getPropertySources().addFirst(new PropertiesPropertySource("test-env", props));

    exception.expect(RuntimeException.class);
    exception.expectMessage("Unable to decrypt property value '{encrypted}NOT-ENCRYPTED'");
    exception.expectCause(isA(EncryptionOperationNotPossibleException.class));

    ApplicationEnvironmentPreparedEvent event = new ApplicationEnvironmentPreparedEvent(new SpringApplication(), new String[0], environment);

    // when
    listener.onApplicationEvent(event);

    // then -> exception
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
public AuthToken(String key,String token) throws AuthenticationException {
    try {
        logger.info("En: " + token);
        token = decrypt(token, key);
        logger.info("De: " + token);
        String[] parts = token.split("(\\|)");
        for (String s : parts){
            logger.info("Part: " + s);
        }
        userId = parts[1];
        expirationDate = Long.parseLong(parts[2]);
    } catch (EncryptionOperationNotPossibleException e){
        e.printStackTrace();
        throw new AuthenticationException("Failed to create AuthToken",e);
    }
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
private Map<String, Object> processValues(Map<String, Object> properties, List<Value> values, boolean revert, boolean remove) {
    Map<String, Object> processed = new HashMap<>();
    for (Value value : values) {
        String key = value.getName();
        String property = getProperty(properties, key, isOptional(value));
        if (property != null && !property.isEmpty() && isEncrypted(value)) {
            if (revert) {
                try {
                    property = encryptor.decrypt(property);
                } catch (EncryptionOperationNotPossibleException ignored) {
                    property = legacyEncryptor.decrypt(property);
                }
            } else {
                property = encryptor.encrypt(property);
            }
        }
        if (isSensitve(value)) {
            if (!remove) {
                processed.put(key, property);
            }
        } else {
            processed.put(key, property);
        }
    }
    return processed;
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
private void encryptIpSecPresharedKeysOfRemoteAccessVpn(Connection conn) {
    try (
            PreparedStatement selectStatement = conn.prepareStatement("SELECT id, ipsec_psk FROM `cloud`.`remote_access_vpn`");
            ResultSet resultSet = selectStatement.executeQuery();
        ) {
        while (resultSet.next()) {
            Long rowId = resultSet.getLong(1);
            String preSharedKey = resultSet.getString(2);
            try {
                preSharedKey = DBEncryptionUtil.decrypt(preSharedKey);
            } catch (EncryptionOperationNotPossibleException ignored) {
                s_logger.debug("The ipsec_psk preshared key id=" + rowId + "in remote_access_vpn is not encrypted, encrypting it.");
            }
            try (PreparedStatement updateStatement = conn.prepareStatement("UPDATE `cloud`.`remote_access_vpn` SET ipsec_psk=? WHERE id=?");) {
                updateStatement.setString(1, DBEncryptionUtil.encrypt(preSharedKey));
                updateStatement.setLong(2, rowId);
                updateStatement.executeUpdate();
            }
        }
    } catch (SQLException e) {
        throw new CloudRuntimeException("Unable to update the remote_access_vpn's preshared key ipsec_psk column", e);
    }
    s_logger.debug("Done encrypting remote_access_vpn's ipsec_psk column");
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
public static String encrypt(String plain) {
    if (!EncryptionSecretKeyChecker.useEncryption() || (plain == null) || plain.isEmpty()) {
        return plain;
    }
    if (s_encryptor == null) {
        initialize();
    }
    String encryptedString = null;
    try {
        encryptedString = s_encryptor.encrypt(plain);
    } catch (EncryptionOperationNotPossibleException e) {
        s_logger.debug("Error while encrypting: " + plain);
        throw e;
    }
    return encryptedString;
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
public static String decrypt(String encrypted) {
    if (!EncryptionSecretKeyChecker.useEncryption() || (encrypted == null) || encrypted.isEmpty()) {
        return encrypted;
    }
    if (s_encryptor == null) {
        initialize();
    }

    String plain = null;
    try {
        plain = s_encryptor.decrypt(encrypted);
    } catch (EncryptionOperationNotPossibleException e) {
        s_logger.debug("Error while decrypting: " + encrypted);
        throw e;
    }
    return plain;
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
public String decryptOne(String encPassword, String key) {
	String result = null;
	if(JmsHelper.isStringNullOrEmpty(encPassword) || key == null || key.equals("")) {
		throw new IllegalArgumentException("EncryptedText or password cannot be null or empty");
	}
	
	decryptor = new StandardPBEStringEncryptor();
	
	try {
		decryptor.setPassword(key);
		result = decryptor.decrypt(encPassword);
	} catch (EncryptionOperationNotPossibleException ex) {
		//Absorb this exception 
	}
	return result;
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
public String decrypt(String encryptedText) {
	String result = null;
	if(encryptedText == null) 
		throw new IllegalArgumentException("Encrypted text cannot be null");

	if(passwords.size() == 0) 
		throw new IllegalArgumentException("No password list provided");
	
	for(String pass : passwords) {
		//New object is required for each decryption attempt
		decryptor = new StandardPBEStringEncryptor();
		try {
			decryptor.setPassword(pass);
			result = decryptor.decrypt(encryptedText);
		} catch (EncryptionOperationNotPossibleException ex) {
			//Absorb this exception to be able to run through a large number of passwords 
		}
	}			
	// A null value for the result indicates that encrypted 
	// text could not be decrypted with the provided passwords
	return result;
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
/** Logging in the user */
 private void loginUser(){
     Executors.newSingleThreadExecutor().execute(() ->
     {
         String usrnm = gui.getLogin().getTxtUsername().getText();
         String pwd = String.valueOf(gui.getLogin().getTxtPass1().getPassword());

         if(usrnm.length() != 0 && pwd.length() != 0){
             PasswordManagerGUI.setSessionUsername(usrnm);
             PasswordManagerGUI.setSessionPassword(pwd);
             String uppercase_username = ((usrnm + "   ").toUpperCase());
             PasswordManagerGUI.getLblUser().setText(uppercase_username);
             BasicTextEncryptor encryptor = new BasicTextEncryptor();
             encryptor.setPassword(pwd);

             try{
                 if(encryptor.decrypt(dao.getPassword(usrnm)).equals(PasswordManagerGUI.getSessionPassword())){
                     System.out.println("Successfully logged in!");
                     gui.switchToPass();
                     JOptionPane.showMessageDialog(gui.getPanel(),
                             "Successfully logged in as " + usrnm + "!",
                             "Login", JOptionPane.PLAIN_MESSAGE);
                     gui.switchToLoggedIn();
                 }

             } catch(EncryptionOperationNotPossibleException xx){
                 JOptionPane.showMessageDialog(gui.getPanel(),
                         "Wrong password!",
                         "Password", JOptionPane.ERROR_MESSAGE);
             }catch(NullPointerException x) {
                 JOptionPane.showMessageDialog(gui.getPanel(),
                         "This username not exist!",
                         "Username", JOptionPane.ERROR_MESSAGE);
             }
         }
     });
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
/**
 * Decrypt a potentially encrypted value.
 * 
 * @param value
 *            The encrypted value to decrypt if not <code>null</code>.
 * @return the decrypted value.
 */
public String decryptAsNeeded(final String value) {
	try {
		// Try a decryption
		return decrypt(value);
	} catch (final EncryptionOperationNotPossibleException e) { // NOSONAR - Ignore raw value
		// Value could be encrypted, but was not
		return value;
	}
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
/**
 * Encrypt a clear value. Try to decrypt the value, and if succeed, return the formal parameter without encrypting
 * again the value.
 * 
 * @param value
 *            A potentially raw value to encrypt.
 * @return The encrypted value, or formal parameter if was already encrypted.
 */
public String encryptAsNeeded(final String value) {
	try {
		// Try a decryption
		decrypt(value);

		// Value is already encrypted
		return value;
	} catch (final EncryptionOperationNotPossibleException e) { // NOSONAR - Ignore raw value
		// Value could be encrypted, but was not
		return encrypt(value);
	}
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
/**
 * Test encrypt.
 */
@Test
public void encryptAsNeeded() {
	final StringEncryptor stringEncryptor = Mockito.mock(StringEncryptor.class);
	Mockito.when(stringEncryptor.decrypt("value")).thenThrow(new EncryptionOperationNotPossibleException());
	Mockito.when(stringEncryptor.encrypt("value")).thenReturn("encrypted");
	final CryptoHelper securityHelper = new CryptoHelper();
	securityHelper.setEncryptor(stringEncryptor);
	Assert.assertEquals("encrypted", securityHelper.encryptAsNeeded("value"));
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
/**
 * Test decrypt a raw value.
 */
@Test
public void decryptAsNeededAlreadyDecrypted() {
	final StringEncryptor stringEncryptor = Mockito.mock(StringEncryptor.class);
	Mockito.when(stringEncryptor.decrypt("value")).thenThrow(new EncryptionOperationNotPossibleException());
	final CryptoHelper securityHelper = new CryptoHelper();
	securityHelper.setEncryptor(stringEncryptor);
	Assert.assertEquals("value", securityHelper.decryptAsNeeded("value"));
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
/**
 * Get system setting optional. The database call is executed in a
 * programmatic transaction.
 *
 * @param name the system setting name.
 * @param defaultValue the default value for the system setting.
 * @return an optional system setting value.
 */
private Optional<Serializable> getSystemSettingOptional( String name, Serializable defaultValue )
{
    SystemSetting setting = transactionTemplate.execute( new TransactionCallback<SystemSetting>()
    {
        public SystemSetting doInTransaction( TransactionStatus status )
        {
            return systemSettingStore.getByName( name );
        }
    } );

    if ( setting != null && setting.hasValue() )
    {
        if ( isConfidential( name ) )
        {
            try
            {
                return Optional.of( pbeStringEncryptor.decrypt( (String) setting.getValue() ) );
            }
            catch ( EncryptionOperationNotPossibleException e ) // Most likely this means the value is not encrypted, or not existing
            {
                log.warn( "Could not decrypt system setting '" + name + "'" );
                return Optional.empty();
            }
        }
        else
        {
            return Optional.of( setting.getValue() );
        }
    }
    else
    {
        return Optional.ofNullable( defaultValue );
    }
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
@Override
public String resolvePropertyValue(String value) {
    String actualValue = value;
    if (detector.isEncrypted(value)) {
        try {
            actualValue = encryptor.decrypt(detector.unwrapEncryptedValue(value.trim()));
        } catch (EncryptionOperationNotPossibleException e) {
            throw new DecryptionException("Decryption of Properties failed,  make sure encryption/decryption " +
                    "passwords match", e);
        }
    }
    return actualValue;
}
 

import org.jasypt.exceptions.EncryptionOperationNotPossibleException; //导入依赖的package包/类
@Override
protected void runTask(List<String> tokens) throws Exception {
    if (password == null || input == null) {
        context.printException(new IllegalArgumentException("input and password parameters are mandatory"));
        return;
    }
    encryptor.setPassword(password);
    try {
        context.print("Decrypted text: " + encryptor.decrypt(input));
    } catch (EncryptionOperationNotPossibleException e) {
        context.print("ERROR: Text cannot be decrypted, check your input and password and try again!");
    }
}