Added support for hashing using different algorithms.

git-svn-id: http://svn.igniterealtime.org/svn/repos/wildfire/trunk@3864 b35dd754-fafc-0310-a699-88a17e54d16e

src/java/org/jivesoftware/util/StringUtils.java

@@ -15,6 +15,7 @@ import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.text.BreakIterator;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Utility class to peform common String manipulation algorithms.
@@ -277,7 +278,8 @@ public class StringUtils {
     /**
      * Used by the hash method.
      */
-    private static MessageDigest digest = null;
+    private static Map<String, MessageDigest> digests =
+            new ConcurrentHashMap<String, MessageDigest>();
 
     /**
      * Hashes a String using the Md5 algorithm and returns the result as a
@@ -303,24 +305,58 @@ public class StringUtils {
      * @param data the String to compute the hash of.
      * @return a hashed version of the passed-in String
      */
-    public synchronized static String hash(String data) {
-        if (digest == null) {
+    public static String hash(String data) {
+        return hash(data, "MD5");
+    }
+
+    /**
+     * Hashes a String using the specified algorithm and returns the result as a
+     * String of hexadecimal numbers. This method is synchronized to avoid
+     * excessive MessageDigest object creation. If calling this method becomes
+     * a bottleneck in your code, you may wish to maintain a pool of
+     * MessageDigest objects instead of using this method.
+     * <p/>
+     * A hash is a one-way function -- that is, given an
+     * input, an output is easily computed. However, given the output, the
+     * input is almost impossible to compute. This is useful for passwords
+     * since we can store the hash and a hacker will then have a very hard time
+     * determining the original password.
+     * <p/>
+     * In Jive, every time a user logs in, we simply
+     * take their plain text password, compute the hash, and compare the
+     * generated hash to the stored hash. Since it is almost impossible that
+     * two passwords will generate the same hash, we know if the user gave us
+     * the correct password or not. The only negative to this system is that
+     * password recovery is basically impossible. Therefore, a reset password
+     * method is used instead.
+     *
+     * @param data the String to compute the hash of.
+     * @param algorithm the name of the algorithm requested.
+     * @return a hashed version of the passed-in String
+     */
+    public static String hash(String data, String algorithm) {
+        synchronized (algorithm.intern()) {
+            MessageDigest digest = digests.get(algorithm);
+            if (digest == null) {
+                try {
+                    digest = MessageDigest.getInstance(algorithm);
+                    digests.put(algorithm, digest);
+                }
+                catch (NoSuchAlgorithmException nsae) {
+                    Log.error("Failed to load the MD5 MessageDigest. " +
+                            "Jive will be unable to function normally.", nsae);
+                    return null;
+                }
+            }
+            // Now, compute hash.
             try {
-                digest = MessageDigest.getInstance("MD5");
+                digest.update(data.getBytes("utf-8"));
             }
-            catch (NoSuchAlgorithmException nsae) {
-                Log.error("Failed to load the MD5 MessageDigest. " +
-                        "Jive will be unable to function normally.", nsae);
+            catch (UnsupportedEncodingException e) {
+                Log.error(e);
             }
+            return encodeHex(digest.digest());
         }
-        // Now, compute hash.
-        try {
-            digest.update(data.getBytes("utf-8"));
-        }
-        catch (UnsupportedEncodingException e) {
-            Log.error(e);
-        }
-        return encodeHex(digest.digest());
     }
 
     /**