private void doExecuteScript(final Resource scriptResource) {
if (scriptResource == null || !scriptResource.exists()) return;
final JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String[] scripts;
try {
String[] list =
StringUtils.delimitedListToStringArray(
stripComments(IOUtils.readLines(scriptResource.getInputStream())), ";");
scripts = list;
} catch (IOException e) {
throw new BeanInitializationException("Cannot load script from [" + scriptResource + "]", e);
}
for (int i = 0; i < scripts.length; i++) {
final String script = scripts[i].trim();
TransactionTemplate transactionTemplate =
new TransactionTemplate(new DataSourceTransactionManager(dataSource));
transactionTemplate.execute(
new TransactionCallback<Void>() {
@Override
public Void doInTransaction(TransactionStatus status) {
if (StringUtils.hasText(script)) {
try {
jdbcTemplate.execute(script);
} catch (DataAccessException e) {
if (!script.toUpperCase().startsWith("DROP")) {
throw e;
}
}
}
return null;
}
});
}
}
public Script getScript(Dialect dialect, SimpleJdbcTemplate template) throws Exception {
Script script = new Script();
String[] statements = StringUtils.delimitedListToStringArray(sql, ";");
for (String s : statements) {
script.append(s.trim());
script.newStatement();
}
return script;
}
private static List<String> convertDelimitedStringToList(String delimitedString) {
List<String> result = new ArrayList<>();
if ("No orders".equals(delimitedString) || "No cooked dishes".equals(delimitedString)) {
delimitedString = "";
}
if (!StringUtils.isEmpty(delimitedString)) {
result = Arrays.asList(StringUtils.delimitedListToStringArray(delimitedString, ", "));
}
return result;
}
/**
* Generate list of Business Associates from To address
*
* @param to
*/
private List<BusinessAssociate> populateBAFromRecipients(String to) {
String[] tos = StringUtils.delimitedListToStringArray(to, ";");
List<BusinessAssociate> businessAssociates = new ArrayList<BusinessAssociate>();
for (String recipient : tos) {
BusinessAssociate ba = businessAssociateDao.findByEmail(recipient);
if (ba != null) {
businessAssociates.add(ba);
}
}
return businessAssociates;
}
@Override
public ObjectName getObjectName(Object managedBean, String beanKey)
throws MalformedObjectNameException {
ObjectName objectName = this.namingStrategy.getObjectName(managedBean, beanKey);
String domain = objectName.getDomain();
Hashtable<String, String> table =
new Hashtable<String, String>(objectName.getKeyPropertyList());
String name = objectName.getKeyProperty("name");
if (name != null) {
table.remove("name");
String[] parts = StringUtils.delimitedListToStringArray(name, ".");
table.put("type", parts[0]);
if (parts.length > 1) {
table.put(parts.length > 2 ? "name" : "value", parts[1]);
}
if (parts.length > 2) {
table.put("value", name.substring(parts[0].length() + parts[1].length() + 2));
}
}
return new ObjectName(domain, table);
}
/** Creates a Set of {@link URL}s from the OSGi bundle class path manifest entry. */
public static Set<URL> getBundleClassPath(String bundleId) {
Set<URL> paths = new HashSet<URL>();
try {
Bundle bundle = Platform.getBundle(bundleId);
if (bundle != null) {
String bundleClassPath =
(String) bundle.getHeaders().get(org.osgi.framework.Constants.BUNDLE_CLASSPATH);
if (bundleClassPath != null) {
String[] classPathEntries = StringUtils.delimitedListToStringArray(bundleClassPath, ",");
for (String classPathEntry : classPathEntries) {
if (".".equals(classPathEntry.trim())) {
paths.add(FileLocator.toFileURL(bundle.getEntry("/")));
} else {
try {
paths.add(
FileLocator.toFileURL(
new URL(bundle.getEntry("/"), "/" + classPathEntry.trim())));
} catch (FileNotFoundException e) {
SpringCore.log(
"bundle classpath entry \""
+ classPathEntry.trim()
+ "\" of bundle "
+ bundle.getSymbolicName()
+ " not found and therefore ignored",
e);
}
}
}
} else {
paths.add(FileLocator.toFileURL(bundle.getEntry("/")));
}
}
} catch (MalformedURLException e) {
SpringCore.log(e);
} catch (IOException e) {
SpringCore.log(e);
}
return paths;
}
/*
* (non-Javadoc)
* @see org.springframework.data.repository.config.RepositoryConfigurationSource#getBasePackages()
*/
public Iterable<String> getBasePackages() {
String attribute = element.getAttribute(BASE_PACKAGE);
return Arrays.asList(StringUtils.delimitedListToStringArray(attribute, ",", " "));
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
if (!(request instanceof HttpServletRequest)) {
throw new ServletException("Can only process HttpServletRequest");
}
if (!(response instanceof HttpServletResponse)) {
throw new ServletException("Can only process HttpServletResponse");
}
HttpServletRequest httpRequest = (HttpServletRequest) request;
String header = httpRequest.getHeader("Authorization");
if (logger.isDebugEnabled()) {
logger.debug("Authorization header received from user agent: " + header);
}
if ((header != null) && header.startsWith("Digest ")) {
String section212response = header.substring(7);
String[] headerEntries = StringSplitUtils.splitIgnoringQuotes(section212response, ',');
Map headerMap = StringSplitUtils.splitEachArrayElementAndCreateMap(headerEntries, "=", "\"");
String username = (String) headerMap.get("username");
String realm = (String) headerMap.get("realm");
String nonce = (String) headerMap.get("nonce");
String uri = (String) headerMap.get("uri");
String responseDigest = (String) headerMap.get("response");
String qop = (String) headerMap.get("qop"); // RFC 2617 extension
String nc = (String) headerMap.get("nc"); // RFC 2617 extension
String cnonce = (String) headerMap.get("cnonce"); // RFC 2617 extension
// Check all required parameters were supplied (ie RFC 2069)
if ((username == null)
|| (realm == null)
|| (nonce == null)
|| (uri == null)
|| (response == null)) {
if (logger.isDebugEnabled()) {
logger.debug(
"extracted username: '******'; realm: '"
+ username
+ "'; nonce: '"
+ username
+ "'; uri: '"
+ username
+ "'; response: '"
+ username
+ "'");
}
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.missingMandatory",
new Object[] {section212response},
"Missing mandatory digest value; received header {0}")));
return;
}
// Check all required parameters for an "auth" qop were supplied (ie RFC 2617)
if ("auth".equals(qop)) {
if ((nc == null) || (cnonce == null)) {
if (logger.isDebugEnabled()) {
logger.debug("extracted nc: '" + nc + "'; cnonce: '" + cnonce + "'");
}
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.missingAuth",
new Object[] {section212response},
"Missing mandatory digest value; received header {0}")));
return;
}
}
// Check realm name equals what we expected
if (!this.getAuthenticationEntryPoint().getRealmName().equals(realm)) {
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.incorrectRealm",
new Object[] {realm, this.getAuthenticationEntryPoint().getRealmName()},
"Response realm name '{0}' does not match system realm name of '{1}'")));
return;
}
// Check nonce was a Base64 encoded (as sent by DigestProcessingFilterEntryPoint)
if (!Base64.isArrayByteBase64(nonce.getBytes())) {
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.nonceEncoding",
new Object[] {nonce},
"Nonce is not encoded in Base64; received nonce {0}")));
return;
}
// Decode nonce from Base64
// format of nonce is:
// base64(expirationTime + ":" + md5Hex(expirationTime + ":" + key))
String nonceAsPlainText = new String(Base64.decodeBase64(nonce.getBytes()));
String[] nonceTokens = StringUtils.delimitedListToStringArray(nonceAsPlainText, ":");
if (nonceTokens.length != 2) {
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.nonceNotTwoTokens",
new Object[] {nonceAsPlainText},
"Nonce should have yielded two tokens but was {0}")));
return;
}
// Extract expiry time from nonce
long nonceExpiryTime;
try {
nonceExpiryTime = new Long(nonceTokens[0]).longValue();
} catch (NumberFormatException nfe) {
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.nonceNotNumeric",
new Object[] {nonceAsPlainText},
"Nonce token should have yielded a numeric first token, but was {0}")));
return;
}
// Check signature of nonce matches this expiry time
String expectedNonceSignature =
DigestUtils.md5Hex(nonceExpiryTime + ":" + this.getAuthenticationEntryPoint().getKey());
if (!expectedNonceSignature.equals(nonceTokens[1])) {
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.nonceCompromised",
new Object[] {nonceAsPlainText},
"Nonce token compromised {0}")));
return;
}
// Lookup password for presented username
// NB: DAO-provided password MUST be clear text - not encoded/salted
// (unless this instance's passwordAlreadyEncoded property is 'false')
boolean loadedFromDao = false;
UserDetails user = userCache.getUserFromCache(username);
if (user == null) {
loadedFromDao = true;
try {
user = userDetailsService.loadUserByUsername(username);
} catch (UsernameNotFoundException notFound) {
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.usernameNotFound",
new Object[] {username},
"Username {0} not found")));
return;
}
if (user == null) {
throw new AuthenticationServiceException(
"AuthenticationDao returned null, which is an interface contract violation");
}
userCache.putUserInCache(user);
}
// Compute the expected response-digest (will be in hex form)
String serverDigestMd5;
// Don't catch IllegalArgumentException (already checked validity)
serverDigestMd5 =
generateDigest(
passwordAlreadyEncoded,
username,
realm,
user.getPassword(),
((HttpServletRequest) request).getMethod(),
uri,
qop,
nonce,
nc,
cnonce);
// If digest is incorrect, try refreshing from backend and recomputing
if (!serverDigestMd5.equals(responseDigest) && !loadedFromDao) {
if (logger.isDebugEnabled()) {
logger.debug(
"Digest comparison failure; trying to refresh user from DAO in case password had changed");
}
try {
user = userDetailsService.loadUserByUsername(username);
} catch (UsernameNotFoundException notFound) {
// Would very rarely happen, as user existed earlier
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.usernameNotFound",
new Object[] {username},
"Username {0} not found")));
}
userCache.putUserInCache(user);
// Don't catch IllegalArgumentException (already checked validity)
serverDigestMd5 =
generateDigest(
passwordAlreadyEncoded,
username,
realm,
user.getPassword(),
((HttpServletRequest) request).getMethod(),
uri,
qop,
nonce,
nc,
cnonce);
}
// If digest is still incorrect, definitely reject authentication attempt
if (!serverDigestMd5.equals(responseDigest)) {
if (logger.isDebugEnabled()) {
logger.debug(
"Expected response: '"
+ serverDigestMd5
+ "' but received: '"
+ responseDigest
+ "'; is AuthenticationDao returning clear text passwords?");
}
fail(
request,
response,
new BadCredentialsException(
messages.getMessage(
"DigestProcessingFilter.incorrectResponse", "Incorrect response")));
return;
}
// To get this far, the digest must have been valid
// Check the nonce has not expired
// We do this last so we can direct the user agent its nonce is stale
// but the request was otherwise appearing to be valid
if (nonceExpiryTime < System.currentTimeMillis()) {
fail(
request,
response,
new NonceExpiredException(
messages.getMessage(
"DigestProcessingFilter.nonceExpired", "Nonce has expired/timed out")));
return;
}
if (logger.isDebugEnabled()) {
logger.debug(
"Authentication success for user: '******' with response: '"
+ responseDigest
+ "'");
}
// START SIPXECS CUSTOM CODE: XX-8253
// commented original code
// UsernamePasswordAuthenticationToken authRequest = new
// UsernamePasswordAuthenticationToken(user,
// user.getPassword());
// creates digest token to be handled by
// org.sipfoundry.sipxconfig.security.DaoAuthenticationProvider
UsernamePasswordAuthenticationToken authRequest =
new DigestUsernamePasswordAuthenticationToken(user, user.getPassword());
// END SIPXECS CUSTOM CODE: XX-8253
authRequest.setDetails(
authenticationDetailsSource.buildDetails((HttpServletRequest) request));
SecurityContextHolder.getContext().setAuthentication(authRequest);
}
chain.doFilter(request, response);
}