HashHelper.java

package org.objectweb.jonas.security.realm.lib;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class HashHelper {

    private static final int HEX_CONSTANT = 0xFF;

    private static final String[] ALGORITHM = {"MD5", "MD2", "SHA-1", "SHA"};

    private static final String[] SEPARATOR_ALGORITHM = {"MD5:", "MD2:", "SHA-1:", "SHA:"};

    private static final String[] SEPARATOR_ALGORITHM_BIS = {"{MD5}", "{MD2}", "{SHA-1}", "{SHA}"};

    public static final String DEFAULT_ALGO = "MD5";

    private HashHelper() {
    }

    private static boolean isAValidAlgorithm(String algo) {
        for (int i = 0; i < ALGORITHM.length; i++) {
            if (algo.equalsIgnoreCase(ALGORITHM[i])) {
                return true;
            }
        }
        return false;
    }

    public static HashPassword getHashPassword(String password) {
        String pass = null;
        String algo = null;
        //Check with the format ALGO:
        for (int i = 0; i < ALGORITHM.length; i++) {
            if (password.toUpperCase().startsWith(SEPARATOR_ALGORITHM[i])) {
                pass = password.substring(SEPARATOR_ALGORITHM[i].length());
                algo = password.substring(0, SEPARATOR_ALGORITHM[i].length() - 1);
                return new HashPassword(pass, algo);
            }
            if (password.toUpperCase().startsWith(SEPARATOR_ALGORITHM_BIS[i])) {
                pass = password.substring(SEPARATOR_ALGORITHM_BIS[i].length());
                algo = password.substring(1, SEPARATOR_ALGORITHM_BIS[i].length() - 1);
                return new HashPassword(pass, algo);
            }
        }

        //Return a haspassword without algorithm (clear password)
        return new HashPassword(password, null);
    }

    public static char[] hexDump(byte[] src) {
        char[] buf = new char[src.length * 2];

        for (int b = 0; b < src.length; b++) {
            String byt = Integer.toHexString(src[b] & HEX_CONSTANT);

            if (byt.length() < 2) {
                buf[b * 2 + 0] = '0';
                buf[b * 2 + 1] = byt.charAt(0);
            } else {
                buf[b * 2 + 0] = byt.charAt(0);
                buf[b * 2 + 1] = byt.charAt(1);
            }
        }
        return buf;
    }

    public static void smudge(char[] pwd) {
        if (pwd != null) {
            for (int b = 0; b < pwd.length; b++) {
                pwd[b] = 0;
            }
        }
    }

    public static void smudge(byte[] pwd) {
        if (pwd != null) {
            for (int b = 0; b < pwd.length; b++) {
                pwd[b] = 0;
            }
        }
    }

    public static String hashPassword(char[] pwd) throws NoSuchAlgorithmException {
        return hashPassword(pwd, DEFAULT_ALGO);
    }

    public static String hashPassword(char[] pwd, String algo) throws NoSuchAlgorithmException {

        if (!isAValidAlgorithm(algo)) {
            throw new NoSuchAlgorithmException("Your algorithm isn't valid or not yet supported.");
        }
        MessageDigest md = MessageDigest.getInstance(algo);
        md.reset();

        byte[] pwdb = new byte[pwd.length];
        byte[] crypt = null;
        for (int b = 0; b < pwd.length; b++) {
            pwdb[b] = (byte) pwd[b];
        }
        crypt = md.digest(pwdb);
        smudge(pwdb);
        return new String(Base64.encode(crypt));
    }

    public static String hashPassword(String string, String algo) throws NoSuchAlgorithmException {
        return hashPassword(string.toCharArray(), algo);
    }
}

---