Java EncryptionException类代码示例

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
private ExtensionOAuthConfiguration createFromProperties(final Properties properties) throws IllegalArgumentException, EncryptionException {
    final String clientId = getPropertyValue(properties.getProperty(OAUTH_PROPERTY_CLIENT_ID));
    final String userRefreshToken = getPropertyValue(properties.getProperty(OAUTH_PROPERTY_USER_REFRESH_TOKEN));
    final String callbackUrl = getPropertyValue(properties.getProperty(OAUTH_PROPERTY_CALLBACK_URL));
    final String hubUri = getPropertyValue(properties.getProperty(OAUTH_PROPERTY_HUB_URI));
    final String extensionUri = getPropertyValue(properties.getProperty(OAUTH_PROPERTY_EXTENSION_URI));
    final String authorizeUri = getPropertyValue(properties.getProperty(OAUTH_PROPERTY_AUTHORIZE_URI));
    final String tokenUri = getPropertyValue(properties.getProperty(OAUTH_PROPERTY_TOKEN_URI));
    final ExtensionOAuthConfiguration config = new ExtensionOAuthConfiguration();
    config.clientId = clientId;
    config.callbackUrl = callbackUrl;
    config.refreshToken = userRefreshToken;
    config.setAddresses(hubUri, extensionUri, authorizeUri, tokenUri);

    return config;
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
public void checkInput(final HttpServletRequest request, final ActionErrors errors) throws IllegalArgumentException, EncryptionException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
    final HubServerConfigBuilder builder = getHubServerConfigBuilderFromRequest(request);

    final AbstractValidator validator = builder.createValidator();

    final ValidationResults results = validator.assertValid();
    if (results.isSuccess()) {
        final HubServerConfig config = builder.buildObject();
        configPersistenceManager.setHubServerConfig(config);
        configPersistenceManager.setHubWorkspaceCheck(Boolean.valueOf(request.getParameter("hubWorkspaceCheck")));
    } else {
        checkForErrors(HubServerConfigFieldEnum.HUBURL, "errorUrl", results, errors);
        checkForErrors(HubServerConfigFieldEnum.HUBTIMEOUT, "errorTimeout", results, errors);

        checkForErrors(HubCredentialsFieldEnum.USERNAME, "errorUserName", results, errors);
        checkForErrors(HubCredentialsFieldEnum.PASSWORD, "errorPassword", results, errors);

        checkForErrors(HubProxyInfoFieldEnum.PROXYHOST, "errorHubProxyServer", results, errors);
        checkForErrors(HubProxyInfoFieldEnum.PROXYPORT, "errorHubProxyPort", results, errors);
        checkForErrors(HubProxyInfoFieldEnum.NOPROXYHOSTS, "errorHubNoProxyHost", results, errors);
        checkForErrors(HubProxyInfoFieldEnum.PROXYUSERNAME, "errorHubProxyUser", results, errors);
        checkForErrors(HubProxyInfoFieldEnum.PROXYPASSWORD, "errorHubProxyPass", results, errors);
    }
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
private HubServerConfigBuilder getHubServerConfigBuilderFromRequest(final HttpServletRequest request) throws IllegalArgumentException, EncryptionException {
    final HubServerConfigBuilder serverConfigBuilder = new HubServerConfigBuilder();

    serverConfigBuilder.setHubUrl(request.getParameter("hubUrl"));
    serverConfigBuilder.setTimeout(request.getParameter("hubTimeout"));
    serverConfigBuilder.setUsername(request.getParameter("hubUser"));
    String hubPass = getDecryptedWebPassword(request.getParameter("encryptedHubPass"));
    if (isPasswordAstericks(hubPass) && configPersistenceManager.getHubServerConfig() != null && configPersistenceManager.getHubServerConfig().getGlobalCredentials() != null) {
        hubPass = configPersistenceManager.getHubServerConfig().getGlobalCredentials().getDecryptedPassword();
    }
    serverConfigBuilder.setPassword(hubPass);
    serverConfigBuilder.setAutoImportHttpsCertificates(Boolean.valueOf(request.getParameter("autoImportHttpsCertificates")));
    serverConfigBuilder.setProxyHost(request.getParameter("hubProxyServer"));
    serverConfigBuilder.setProxyPort(request.getParameter("hubProxyPort"));
    serverConfigBuilder.setIgnoredProxyHosts(request.getParameter("hubNoProxyHost"));
    serverConfigBuilder.setProxyUsername(request.getParameter("hubProxyUser"));
    String proxyPass = getDecryptedWebPassword(request.getParameter("encryptedHubProxyPass"));
    if (isPasswordAstericks(proxyPass) && configPersistenceManager.getHubServerConfig() != null && configPersistenceManager.getHubServerConfig().getProxyInfo() != null) {
        proxyPass = configPersistenceManager.getHubServerConfig().getProxyInfo().getDecryptedPassword();
    }
    serverConfigBuilder.setProxyPassword(proxyPass);

    return serverConfigBuilder;
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
public HubCredentials getCredentialsFromRequest(final HttpServletRequest request, final String usernameKey) throws IllegalArgumentException, EncryptionException {
    final String username = request.getParameter(usernameKey);
    String password = "";
    password = request.getParameter("encryptedHubPass");

    HubCredentials hubCredentials = null;
    final String decryptedPassword = getDecryptedWebPassword(password);
    if (isPasswordAstericks(decryptedPassword) && configPersistenceManager.getHubServerConfig() != null && configPersistenceManager.getHubServerConfig().getGlobalCredentials() != null) {
        final String savedPassword = configPersistenceManager.getHubServerConfig().getGlobalCredentials().getDecryptedPassword();
        hubCredentials = new HubCredentials(username, savedPassword);
    } else {
        if (StringUtils.isNotBlank(decryptedPassword)) {
            // Do not change the saved password unless the User has provided a new one
            final String decryptedWebPassword = getDecryptedWebPassword(password);
            if (StringUtils.isNotBlank(decryptedWebPassword)) {
                hubCredentials = new HubCredentials(username, decryptedWebPassword);
            }
        }
    }

    return hubCredentials;
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
@Test
public void testIsHubCredentialConfiguredValidCredentials() throws EncryptionException {
    final HubParameterValidator validator = new HubParameterValidator(buildLogger);
    final HubCredentials credential = new HubCredentials("user", "password");
    assertTrue(validator.isHubCredentialConfigured(credential));
    assertTrue(testLogger.getErrorMessages().size() == 0);
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
private String getDecryptedWebPassword(final String webEncryptedPass) throws IllegalArgumentException, EncryptionException {
    if (StringUtils.isNotBlank(webEncryptedPass)) {
        final String webDecryptedPass = RSACipher.decryptWebRequestData(webEncryptedPass);

        if (StringUtils.isNotBlank(webDecryptedPass)) {
            return webDecryptedPass;
        }
    }
    return "";
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
private HubServicesFactory createHubServicesFactory(final HubServerConfig hubServerConfig) throws EncryptionException {
	final RestConnection restConnection = new CredentialsRestConnection(logger, hubServerConfig.getHubUrl(),
			hubServerConfig.getGlobalCredentials().getUsername(), hubServerConfig.getGlobalCredentials().getDecryptedPassword(),
			hubServerConfig.getTimeout());
	final HubServicesFactory hubServicesFactory = new HubServicesFactory(restConnection);
	return hubServicesFactory;
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
private String getPropertyValue(final String propertyValue) throws IllegalArgumentException, EncryptionException {
    final Decoder decoder = Base64.getUrlDecoder();
    final String value = new String(decoder.decode(propertyValue));
    return value;
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
private String encodePropertyValue(final String value) throws IllegalArgumentException, EncryptionException {
    // simply obfuscate the values from clear text.
    final Encoder encoder = Base64.getUrlEncoder();
    final String encoded = encoder.encodeToString(value.getBytes());
    return encoded;
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
public RestConnection getRestConnection(final IntLogger logger, final HubServerConfig hubServerConfig) throws EncryptionException {
    return hubServerConfig.createCredentialsRestConnection(logger);
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
private RestConnection getRestConnection(final HubServerConfig hubServerConfig) throws EncryptionException {
    final Slf4jIntLogger intLogger = new Slf4jIntLogger(logger);
    return hubServerConfig.createCredentialsRestConnection(intLogger);
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
public HubServicesFactory createHubServicesFactory(final HubServerConfig config) throws EncryptionException {
    final RestConnection restConnection = new CredentialsRestConnection(logger, config.getHubUrl(), config.getGlobalCredentials().getUsername(), config.getGlobalCredentials().getDecryptedPassword(), config.getTimeout());
    return new HubServicesFactory(restConnection);
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
@Override
public HubServicesFactory createHubServicesFactory(final HubServerConfig config) throws EncryptionException {
    return hubServicesFactory;
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
/**
 * Get the Hub Vulnerability BOM component Url
 *
 * @param projectVersionItem
 * @return
 * @throws HubIntegrationException
 * @throws IllegalArgumentException
 * @throws EncryptionException
 */
private String getVulnerabililtyBomComponentUrl(final ProjectVersionView projectVersionItem)
        throws HubIntegrationException, IllegalArgumentException, EncryptionException {
    final MetaService metaService = hubServicesFactory.createMetaService();
    return metaService.getFirstLink(projectVersionItem, MetaService.VULNERABLE_COMPONENTS_LINK);
}
 

import com.blackducksoftware.integration.exception.EncryptionException; //导入依赖的package包/类
/**
 * Get the Hub Project version risk-profile url
 *
 * @param projectVersionItem
 * @return
 * @throws HubIntegrationException
 * @throws IllegalArgumentException
 * @throws EncryptionException
 */
private String getProjectVersionRiskProfileUrl(final ProjectVersionView projectVersionItem)
        throws HubIntegrationException, IllegalArgumentException, EncryptionException {
    final MetaService metaService = hubServicesFactory.createMetaService();
    return metaService.getFirstLink(projectVersionItem, MetaService.RISK_PROFILE_LINK);
}