Java tutorial
/* * This work is Open Source and licensed by the European Commission under the * conditions of the European Public License v1.1 * * (http://www.osor.eu/eupl/european-union-public-licence-eupl-v.1.1); * * any use of this file implies acceptance of the conditions of this license. * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. */ package eu.stork.peps.auth.commons; import java.io.ByteArrayInputStream; import java.io.InputStream; import java.io.UnsupportedEncodingException; import java.util.Properties; import org.apache.commons.lang.StringUtils; import org.apache.log4j.Logger; import org.bouncycastle.crypto.Digest; import org.bouncycastle.util.encoders.Base64; import org.bouncycastle.util.encoders.UrlBase64; import eu.stork.peps.auth.commons.exceptions.InternalErrorPEPSException; import eu.stork.peps.auth.commons.exceptions.InvalidParameterPEPSException; /** * This class holds static helper methods. * * @author ricardo.ferreira@multicert.com, renato.portela@multicert.com, * luis.felix@multicert.com, hugo.magalhaes@multicert.com, * paulo.ribeiro@multicert.com * @version $Revision: 1.75 $, $Date: 2010-11-23 00:05:35 $ */ public final class PEPSUtil { /** * Logger object. */ private static final Logger LOG = Logger.getLogger(PEPSUtil.class.getName()); /** * Configurations object. */ private static Properties configs; /** * Max prefix. */ private static final String MAX_PARAM_PREFIX = "max."; /** * Code prefix to get error code. */ private static final String CODE_PARAM_SUFFIX = ".code"; /** * param's size prefix to get max param size. */ private static final String MAX_PARAM_SUFFIX = ".size"; /** * Message prefix to get error message. */ private static final String MSG_PARAM_SUFFIX = ".message"; /** * Private constructor. Prevents the class from being instantiated. */ private PEPSUtil() { // empty constructor } /** * Creates a single instance of this class and sets the properties. * * @param nConfigs The set of available configurations. * * @return The created PEPSUtil's class. */ public static PEPSUtil createInstance(final Properties nConfigs) { if (nConfigs != null) { PEPSUtil.configs = nConfigs; } return new PEPSUtil(); } /** * Getter for the Properties. * * @return configs The properties value. */ public Properties getConfigs() { return configs; } /** * Setter for the Properties. * * @param nConfigs The new properties value. */ public static void setConfigs(final Properties nConfigs) { if (nConfigs != null) { PEPSUtil.configs = nConfigs; } } /** * Returns the identifier of some configuration given a set of configurations * and the corresponding configuration key. * * @param configKey The key that IDs some configuration. * * @return The configuration String value. */ public static String getConfig(final String configKey) { return configs.getProperty(configKey); } /** * Validates the input paramValue identified by the paramName. * * @param paramName The name of the parameter to validate. * @param paramValue The value of the parameter to validate. * * @return true if the parameter is valid. */ public static boolean isValidParameter(final String paramName, final String paramValue) { final String validationParam = PEPSUtil.getConfig(PEPSParameters.VALIDATION_ACTIVE.toString()); boolean retVal = true; final String paramConf = MAX_PARAM_PREFIX + paramName + MAX_PARAM_SUFFIX; if (PEPSValues.TRUE.toString().equals(validationParam)) { final String paramSizeStr = PEPSUtil.getConfig(paramConf); // Checking if the parameter size exists and if it's numeric if (StringUtils.isNumeric(paramSizeStr)) { final int maxParamSize = Integer.valueOf(paramSizeStr); if (StringUtils.isEmpty(paramValue) || paramValue.length() > maxParamSize) { retVal = false; LOG.warn("Invalid parameter [" + paramName + "] value " + paramValue); } } else { retVal = false; LOG.error("Missing " + paramConf + " configuration in the pepsUtils.properties configuration file"); } } return retVal; } /** * Validates the Parameter and throws an exception if an error occurs. Throws * an InvalidParameterPEPSException runtime exception if the parameter is * invalid. * * @param className The Class Name that invoked the method. * @param paramName The name of the parameter to validate. * @param paramValue The value of the parameter to validate. */ public static void validateParameter(final String className, final String paramName, final Object paramValue) { if (paramValue == null) { PEPSUtil.validateParameter(className, paramName, ""); } else { PEPSUtil.validateParameter(className, paramName, paramValue.toString()); } } /** * Validates the Parameters and throws an exception if an error occurs. * * @param className The Class Name that invoked the method. * @param paramName The name of the parameter to validate. * @param paramValue The value of the parameter to validate. */ public static void validateParameter(final String className, final String paramName, final String paramValue) { PEPSUtil.validateParameter(className, paramName, paramValue, PEPSUtil.getErrorCode(paramName), PEPSUtil.getErrorMessage(paramName)); } /** * Validates the Parameters and throws an exception if an error occurs. * * @param className The Class Name that invoked the method. * @param paramName The name of the parameter to validate. * @param paramValue The value of the parameter to validate. * @param error The PEPSError to get error code and messages from configs. */ public static void validateParameter(final String className, final String paramName, final String paramValue, final PEPSErrors error) { PEPSUtil.validateParameter(className, paramName, paramValue, PEPSUtil.getConfig(error.errorCode()), PEPSUtil.getConfig(error.errorMessage())); } /** * Validates the HTTP Parameter and throws an exception if an error occurs. * Throws an InvalidParameterPEPSException runtime exception if the parameter * is invalid. * * @param className The Class Name that invoked the method. * @param paramName The name of the parameter to validate. * @param paramValue The value of the parameter to validate. * @param errorCode The error code to include on the exception. * @param errorMessage The error message to include on the exception. */ public static void validateParameter(final String className, final String paramName, final String paramValue, final String errorCode, final String errorMessage) { if (!isValidParameter(paramName, paramValue)) { LOG.warn("Invalid parameter [" + paramName + "] value found at " + className); throw new InvalidParameterPEPSException(errorCode, errorMessage); } } /** * Getter for the error code of some given error related to the input param. * * @param paramName The name of the parameter associated with the error. * * @return The code of the error. */ private static String getErrorCode(final String paramName) { return getConfig(paramName + CODE_PARAM_SUFFIX); } /** * Getter for the error message of some given error related to the input * parameter. * * @param paramName The name of the parameter associated with the message. * * @return The message for the error. */ private static String getErrorMessage(final String paramName) { return getConfig(paramName + MSG_PARAM_SUFFIX); } /** * {@link Base64} encodes the input samlToken parameter. * * @param samlToken the SAML Token to be encoded. * * @return The Base64 String representing the samlToken. * * @see Base64#encode */ public static String encodeSAMLToken(final byte[] samlToken) { try { return new String(Base64.encode(samlToken), "UTF8"); } catch (final UnsupportedEncodingException e) { LOG.error(PEPSErrors.INTERNAL_ERROR.errorMessage(), e); return null; } } /** * Encode samltoken url safe * @param samlToken the saml token to encode * @return the bas64 encoded string */ public static String encodeSAMLTokenUrlSafe(final byte[] samlToken) { try { return new String(UrlBase64.encode(samlToken), "UTF8"); } catch (final UnsupportedEncodingException e) { LOG.error(PEPSErrors.INTERNAL_ERROR.errorMessage(), e); return null; } } /** * Decodes the {@link Base64} String input parameter representing a samlToken. * * @param samlToken the SAML Token to be decoded. * * @return The samlToken decoded bytes. * * @see Base64#decode */ public static byte[] decodeSAMLToken(final String samlToken) { return Base64.decode(samlToken); } /** * Decode URL save base64 saml token * @param samlToken the SAML toke to decode * @return The decoded bytes */ public static byte[] decodeSAMLTokenUrlSafe(final String samlToken) { return UrlBase64.decode(samlToken); } /** * Hashes a SAML token. Throws an InternalErrorPEPSException runtime exception * if the Cryptographic Engine fails. * * @param samlToken the SAML Token to be hashed. * * @return byte[] with the hashed SAML Token. */ public static byte[] hashPersonalToken(final byte[] samlToken) { try { final String className = PEPSUtil.getConfig(PEPSValues.HASH_DIGEST_CLASS.toString()); final Digest digest = (Digest) Class.forName(className).getConstructor().newInstance((Object[]) null); digest.update(samlToken, 0, samlToken.length); final int retLength = digest.getDigestSize(); final byte[] ret = new byte[retLength]; digest.doFinal(ret, 0); return ret; } catch (final Exception e) { // For all those exceptions that could be thrown, we always log it and // thrown an InternalErrorPEPSException. LOG.error(PEPSErrors.HASH_ERROR.errorMessage(), e); throw new InternalErrorPEPSException(PEPSUtil.getConfig(PEPSErrors.HASH_ERROR.errorCode()), PEPSUtil.getConfig(PEPSErrors.HASH_ERROR.errorMessage()), e); } } /** * Gets the Stork error code in the error message if exists! * * @param errorMessage The message to get the error code if exists; * * @return the error code if exists. Returns null otherwise. */ public static String getStorkErrorCode(final String errorMessage) { if (StringUtils.isNotBlank(errorMessage) && errorMessage.indexOf(PEPSValues.ERROR_MESSAGE_SEP.toString()) >= 0) { final String[] msgSplitted = errorMessage.split(PEPSValues.ERROR_MESSAGE_SEP.toString()); if (msgSplitted.length == 2 && StringUtils.isNumeric(msgSplitted[0])) { return msgSplitted[0]; } } return null; } /** * Gets the Stork error message in the saml message if exists! * * @param errorMessage The message to get in the saml message if exists; * * @return the error message if exists. Returns the original message * otherwise. */ public static String getStorkErrorMessage(final String errorMessage) { if (StringUtils.isNotBlank(errorMessage) && errorMessage.indexOf(PEPSValues.ERROR_MESSAGE_SEP.toString()) >= 0) { final String[] msgSplitted = errorMessage.split(PEPSValues.ERROR_MESSAGE_SEP.toString()); if (msgSplitted.length == 2 && StringUtils.isNumeric(msgSplitted[0])) { return msgSplitted[1]; } } return errorMessage; } /** * Get inputstream from string * @param string the string to convert * @param codePage the codepage of string * @return an inputstream * @throws UnsupportedEncodingException */ public static InputStream getStream(final String string, final String codePage) throws UnsupportedEncodingException { return new ByteArrayInputStream(string.getBytes(codePage)); } }