简单的密码安全实现使用 MD5 算法
MD5消息摘要算法(MD5 Message-Digest Algorithm)是一种广泛使用的加密 Hash 函数，主要用于生成一个128bit(16byte) Hash 值。它的实现思路非常简单且易懂，其最基本的思路是将可变长度的数据集映射为固定长度的数据集。为了做到这一点，它将输入消息分割成 512-bit 的数据块。通过填补消息到末尾以确保其长度能除以512。现在这些块将通过 MD5 算法处理，其结果将是一个128位的散列值。使用MD5后，生成的散列值通常是32位16进制的数字。
在该文中，对于被加密的密码明文被称为“消息(message)”，其加密后所生成的 Hash 值称为 “消息摘要(message digest)” 或简称 "摘要(digest)"。以下是 MD5 产生 Hash 值的代码示例：
public class SimpleMD5Example
{
public static void main(String[] args)
{
String passwordToHash = "password";
String generatedPassword = null;
try {
// Create MessageDigest instance for MD5
MessageDigest md = MessageDigest.getInstance("MD5");
//Add password bytes to digest
md.update(passwordToHash.getBytes());
//Get the hash's bytes
byte[] bytes = md.digest();
//This bytes[] has bytes in decimal format;
//Convert it to hexadecimal format
StringBuilder sb = new StringBuilder();
for(int i=0; i< bytes.length ;i++)
{
sb.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
}
//Get complete hashed password in hex format
generatedPassword = sb.toString();
}
catch (NoSuchAlgorithmException e)
{
e.printStackTrace();
}
System.out.println(generatedPassword);
}
}
Console output:
5f4dcc3b5aa765d61d8327deb882cf99
虽然 MD5 是一个广为流传的 Hash 算法, 但它并不安全且所生成的 Hash 值也是相当的薄弱。它主要的优点在于生成速度快且易于实现。但是，这也意味着它是容易被暴力攻击和字典攻击。例如使用明文和 Hash 生成的彩虹表可以快速地搜索已知 Hash 对应的原数据。
此外，MD5 并没有避免 Hash 碰撞：这意味不同的密码会导致生成相同的 Hash 值。
不过，如果你仍然需要使用 MD5，可以考虑为其加 salt 来进一步保证它的安全性。
使用 salt 让生成的 MD5 更加安全
这里需要注意的是，加 salt 並不是 MD5 所特有的, 你同样可以把它应用在其它算法中。所以，在这里你只需关注它是如何应用而不是它与 MD5 的联系。
在 Wikipedia 上对 salt 的定义是通过一个单向函数获取随机数据来为密码或口令添加一些额外的数据。更简单的说法则是通过生成一些随机的文本将其附加到密码上来生成 Hash。
为 Hash 加 salt 的主要目的是用来防止预先被计算好的彩虹表攻击。现在加 slat 好处是将原本一次比较变为多次比较从而减慢对密码 Hash 值的猜测，否则对 Hash 密码库的破解效率将是非常之高。
重要的是：在 Java 中，我们总是需要使用 SecureRandom 来生成一个好的 salt 值，因此可以利用 SecureRandom 类所提供 “SHA1PRNG” 算法来生成伪随机数。代码如下所示：
private static String getSalt() throws NoSuchAlgorithmException
{
//Always use a SecureRandom generator
SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
//Create array for salt
byte[] salt = new byte[16];
//Get a random salt
sr.nextBytes(salt);
//return salt
return salt.toString();
}
SHA1PRNG 算法是基于 SHA-1 算法实现且保密性较强的伪随机数生成器。要注意的是，如果不为它提供随机数种子，它将会通过真随机数来生成一个种子（TRNG）。 译注：关于 TRGN 和 PRGN。
接下来，看看为 MD5 Hash 加 slat 的代码示例：
public class SaltedMD5Example
{
public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchProviderException
{
String passwordToHash = "password";
String salt = getSalt();
String securePassword = getSecurePassword(passwordToHash, salt);
System.out.println(securePassword); //Prints 83ee5baeea20b6c21635e4ea67847f66
String regeneratedPassowrdToVerify = getSecurePassword(passwordToHash, salt);
System.out.println(regeneratedPassowrdToVerify); //Prints 83ee5baeea20b6c21635e4ea67847f66
}
private static String getSecurePassword(String passwordToHash, String salt)
{
String generatedPassword = null;
try {
// Create MessageDigest instance for MD5
MessageDigest md = MessageDigest.getInstance("MD5");
//Add password bytes to digest
md.update(salt.getBytes());
//Get the hash's bytes
byte[] bytes = md.digest(passwordToHash.getBytes());
//This bytes[] has bytes in decimal format;
//Convert it to hexadecimal format
StringBuilder sb = new StringBuilder();
for(int i=0; i< bytes.length ;i++)
{
sb.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
}
//Get complete hashed password in hex format
generatedPassword = sb.toString();
}
catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return generatedPassword;
}
//Add salt
private static String getSalt() throws NoSuchAlgorithmException, NoSuchProviderException
{
//Always use a SecureRandom generator
SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "SUN");
//Create array for salt
byte[] salt = new byte[16];
//Get a random salt
sr.nextBytes(salt);
//return salt
return salt.toString();
}
}
重要提示：请注意，现在你必须每一个密码 Hash 存储它 slat 值。因为当用户登录系统，你必须使用最初生成的 slat 来再次生成 Hash 与存储的 Hash 进行匹配。如果使用不同的 slat（生成随机 slat）那么生成的 Hash 将不同。
此外，你可能听说过多次 Hash 和加 salt。通常就是指创建自定义的组合，如：
salt+password+salt => hash
实际上你没必要这样去做，因为这并不能帮助你进一步巩固 Hash 的安全性。如果你需要更高的安全性，正确的做法应该去选择一个更好的算法。
中等的密码安全实现使用SHA算法
SHA（安全散列算法）同样是作为加密 Hash 函数家族中的一员。除了它生成的 Hash 安全性比 MD5 更强之外其它都与 MD5 非常类似。然而，它们生成的 Hash 并不总是唯一的，这意味着输入两个不同的值所获的 Hash 却是相同的。通常这种情况的发生我们称之为“碰撞”。 不过，SHA 碰撞的几率小于 MD5。你甚至无需担心碰撞的发生，因为这种情况非常罕见。
在 Java 中有提供有4种 SHA 算法的实现，相对 MD5(128 bit hash) 它提供了以下长度的 Hash：
SHA-1 (简单实现 – 160 bits Hash)
SHA-256 (强于 SHA-1 – 256 bits Hash)
SHA-384 (强于 SHA-256 – 384 bits Hash)
SHA-512 (强于 SHA-384 – 512 bits Hash)
通常越长的 Hash 越难破解，这是核心思想。
要获取相应算法实现，可通过参数的方式传给 MessageDigest 来获得实例。如下所示：
MessageDigest md = MessageDigest.getInstance("SHA-1");
//OR
MessageDigest md = MessageDigest.getInstance("SHA-256");
下面通过测试程序来看 SHA 的应用：
package com.howtodoinjava.hashing.password.demo.sha;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
public class SHAExample {
public static void main(String[] args) throws NoSuchAlgorithmException {
String passwordToHash = "password";
String salt = getSalt();
String securePassword = get_SHA_1_SecurePassword(passwordToHash, salt);
System.out.println(securePassword);
securePassword = get_SHA_256_SecurePassword(passwordToHash, salt);
System.out.println(securePassword);
securePassword = get_SHA_384_SecurePassword(passwordToHash, salt);
System.out.println(securePassword);
securePassword = get_SHA_512_SecurePassword(passwordToHash, salt);
System.out.println(securePassword);
}
private static String get_SHA_1_SecurePassword(String passwordToHash, String salt)
{
String generatedPassword = null;
try {
MessageDigest md = MessageDigest.getInstance("SHA-1");
md.update(salt.getBytes());
byte[] bytes = md.digest(passwordToHash.getBytes());
StringBuilder sb = new StringBuilder();
for(int i=0; i< bytes.length ;i++)
{
sb.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
}
generatedPassword = sb.toString();
}
catch (NoSuchAlgorithmException e)
{
e.printStackTrace();
}
return generatedPassword;
}
private static String get_SHA_256_SecurePassword(String passwordToHash, String salt)
{
//Use MessageDigest md = MessageDigest.getInstance("SHA-256");
}
private static String get_SHA_384_SecurePassword(String passwordToHash, String salt)
{
//Use MessageDigest md = MessageDigest.getInstance("SHA-384");
}
private static String get_SHA_512_SecurePassword(String passwordToHash, String salt)
{
//Use MessageDigest md = MessageDigest.getInstance("SHA-512");
}
//Add salt
private static String getSalt() throws NoSuchAlgorithmException
{
SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
byte[] salt = new byte[16];
sr.nextBytes(salt);
return salt.toString();
}
}
Output:
// SHA-1
e4c53afeaa7a08b1f27022abd443688c37981bc4
// SHA-256
87adfd14a7a89b201bf6d99105b417287db6581d8aee989076bb7f86154e8f32
// SHA-384
bc5914fe3896ae8a2c43a4513f2a0d716974cc305733847e3d49e1ea52d1ca50e2a9d0ac192acd43facfb422bb5ace88
// SAH-512
529211542985b8f7af61994670d03d25d55cc9cd1cff8d57bb799c4b586891e112b197530c76744bcd7ef135b58d47d65a0bec221eb5d77793956cf2709dd012
如上代码所示，在使用 SHA 的同时同样可以为其加 salt 来加强它的安全性。
较高密码安全实现使用 PBKDF2WithHmacSHA1 算法
到目前为止，我们已经了解如何为密码生成安全的 Hash 值以及通过利用 salt 来加强它的安全性。但今天的问题是，硬件的速度已经远远超过任何使用字典或彩虹表进行的暴力攻击，并且任何密码都能被破解，只是使用时间多少的问题。
为了解决这个问题，主要想法是尽可能降低暴力攻击速度来保证最小化的损失。我们下一个算法同样是基于这个概念。目标是使 Hash 函数足够慢以妨碍攻击，并对用户来说仍然非常快且不会感到有明显的延时。
要达到这个目的通常是使用某些 CPU 密集型算法来实现，比如 PBKDF2, Bcrypt 或 Scrypt 。这些算法采用 work factor(也称之为 security factor)或迭代次数作为参数来确定 Hash 函数将变的有多慢，并且随着日后计算能力的提高，可以逐步增大 work factor 来使之与计算能力达到平衡。
Java 中可通过 "PBKDF2WithHmacSHA1" 来实现"PBKDF2"算法，下面代码是使用示例：
public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeySpecException
{
String originalPassword = "password";
String generatedSecuredPasswordHash = generateStorngPasswordHash(originalPassword);
System.out.println(generatedSecuredPasswordHash);
}
private static String generateStorngPasswordHash(String password) throws NoSuchAlgorithmException, InvalidKeySpecException
{
int iterations = 1000;
char[] chars = password.toCharArray();
byte[] salt = getSalt().getBytes();
PBEKeySpec spec = new PBEKeySpec(chars, salt, iterations, 64 * 8);
SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
byte[] hash = skf.generateSecret(spec).getEncoded();
return iterations + ":" + toHex(salt) + ":" + toHex(hash);
}
private static String getSalt() throws NoSuchAlgorithmException
{
SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
byte[] salt = new byte[16];
sr.nextBytes(salt);
return salt.toString();
}
private static String toHex(byte[] array) throws NoSuchAlgorithmException
{
BigInteger bi = new BigInteger(1, array);
String hex = bi.toString(16);
int paddingLength = (array.length * 2) - hex.length();
if(paddingLength > 0)
{
return String.format("%0" +paddingLength + "d", 0) + hex;
}else{
return hex;
}
}
Output:
1000:5b4240333032306164:f38d165fce8ce42f59d366139ef5d9e1ca1247f0e06e503ee1a611dd9ec40876bb5edb8409f5abe5504aab6628e70cfb3d3a18e99d70357d295002c3d0a308a0
接下来的是当重新回来时，需要提供登录密码验证的方法实现：
public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeySpecException
{
String originalPassword = "password";
String generatedSecuredPasswordHash = generateStorngPasswordHash(originalPassword);
System.out.println(generatedSecuredPasswordHash);
boolean matched = validatePassword("password", generatedSecuredPasswordHash);
System.out.println(matched);
matched = validatePassword("password1", generatedSecuredPasswordHash);
System.out.println(matched);
}
private static boolean validatePassword(String originalPassword, String storedPassword) throws NoSuchAlgorithmException, InvalidKeySpecException
{
String[] parts = storedPassword.split(":");
int iterations = Integer.parseInt(parts[0]);
byte[] salt = fromHex(parts[1]);
byte[] hash = fromHex(parts[2]);
PBEKeySpec spec = new PBEKeySpec(originalPassword.toCharArray(), salt, iterations, hash.length * 8);
SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
byte[] testHash = skf.generateSecret(spec).getEncoded();
int diff = hash.length ^ testHash.length;
for(int i = 0; i < hash.length && i < testHash.length; i++)
{
diff |= hash[i] ^ testHash[i];
}
return diff == 0;
}
private static byte[] fromHex(String hex) throws NoSuchAlgorithmException
{
byte[] bytes = new byte[hex.length() / 2];
for(int i = 0; i<bytes.length ;i++)
{
bytes[i] = (byte)Integer.parseInt(hex.substring(2 * i, 2 * i + 2), 16);
}
return bytes;
}
参考以上代码时需注意，如果发现任何问题请下载本文章结尾处附件中的代码。
更加安全的密码实现使用 bcrypt 和 scrypt 算法
bcrypt 的背后的思想与 PBKDF2 类似。只是 Java 中并没有内置支持使攻击者变慢的 bcrypt 算法实现，但你仍然可以找到并下载它的源码。
下以是 bcrypt 的使用代码示例（其中 Bcrypt.java 已提供在源码中）：
public class BcryptHashingExample
{
public static void main(String[] args) throws NoSuchAlgorithmException
{
String originalPassword = "password";
String generatedSecuredPasswordHash = BCrypt.hashpw(originalPassword, BCrypt.gensalt(12));
System.out.println(generatedSecuredPasswordHash);
boolean matched = BCrypt.checkpw(originalPassword, generatedSecuredPasswordHash);
System.out.println(matched);
}
}
Output:
$2a$12$WXItscQ/FDbLKU4mO58jxu3Tx/mueaS8En3M6QOVZIZLaGdWrS.pK
true
与 bcrypt 算法类似，我已经从 github 下载了 scrypt 算法的源代码并添加到在最后一节中的源码下载中。看看它是如何使用：
public class ScryptPasswordHashingDemo
{
public static void main(String[] args) {
String originalPassword = "password";
String generatedSecuredPasswordHash = SCryptUtil.scrypt(originalPassword, 16, 16, 16);
System.out.println(generatedSecuredPasswordHash);
boolean matched = SCryptUtil.check("password", generatedSecuredPasswordHash);
System.out.println(matched);
matched = SCryptUtil.check("passwordno", generatedSecuredPasswordHash);
System.out.println(matched);
}
}
Output:
$s0$41010$Gxbn9LQ4I+fZ/kt0glnZgQ==$X+dRy9oLJz1JaNm1xscUl7EmUFHIILT1ktYB5DQ3fZs=
true
false
最后说明
在应用程序中存储密码明文是极其危险的事情。
MD5 提供了最基本的安全 Hash 生成，使用时应为其添加 slat 来进一步加强它的安全性。
MD5 生成128位的 Hash。为了使它更安全，应该使用 SHA 算法生成 160-bit 或 512-bit 的长 Hash，其中 512-bit 是最强的。
虽然使用 SHA Hash 密码也能被当今快速的硬件破解，如要避免这一点，你需要的算法是能让暴力攻击尽可能的变慢且使影响减至最低。这时候你可以使用 PBKDF2, BCrypt 或 SCrypt 算法。
请在深思熟虑后来选择适当的安全算法。
点击这里下载完整源码
参考资料:
https://en.wikipedia.org/wiki/MD5
https://en.wikipedia.org/wiki/Secure_Hash_Algorithm
http://en.wikipedia.org/wiki/Bcrypt
http://en.wikipedia.org/wiki/Scrypt
http://en.wikipedia.org/wiki/PBKDF2
https://github.com/wg/scrypt
http://www.mindrot.org/projects/jBCrypt/
Original: How to generate secure password hash : MD5, SHA, PBKDF2, BCrypt examples
本文出自：http://denger.me/, 原文地址：http://denger.me/2013/07/how-to-generate-secure-password-hash-md5-sha-pbkdf2-bcrypt-examples, 感谢原作者分享。
相关推荐
md5和sha-1算法代码及验证文件 在vc6.0调试运行无误，
PKCS＃5中定义的PBKDF2（基于密码的密钥派生功能＃2）是一种从密码派生随机值的算法。 该算法将伪随机函数（在这种情况下为SHA256 HMAC）与盐字符串一起应用于密码，并重复多次此过程以创建派生密钥（即哈希）。 ...
MD5 SHA1校验工具Hash,校验软件
用于获取文件md5 sha1值 进行完整性校验
MD5生成hash序列MD5生成hMD5生成hash序列MD5生成hash序列ash序列MD5生成hash序列MD5生成hash序列
简单快速的文件 Hash 计算器（也就是文件MD5计算器） 校验 MD5, SHA1, CRC32 还可以检测文件大小和程序版本 支持拖放 集成系统右键菜单 支持 Windows 7
MD5，SHA1，SHA256，HMAC，PBKDF2，SCrypt使用OpenCL（GPU，yay！）和Python的暴力破解工具 （c）B.Kerler和CB 2017-2019 为什么 因为仅使用CPU即可暴力破解PBKDF2 / HMAC / SCrypt并哈希MD5 / SHA1 / SHA256 / SHA...
实现多种Hash算法，包括MD2, MD5, SHA-1, SHA-256, SHA-384, SHA-512
用于验证MD5,SHA1,SHA256的绿色小工具。
HASH算法MD5的代码实验，编译可以直接使用的MD5源代码
//此函数用于生成hash字符串 std::string hash = BCrypt::generateHash(password); //用于判断密码和数据库password加密后的字符串是否匹配 std::cout << BCrypt::validatePassword(password,hash) << std::...
Java程序。可以生成文件的MD5哈希值。生成的Hash值可保存到txt文件中。程序完全可运行。
计算字符串的 pbkdf2 散列，和/或根据 pbkdf2 散列字符串检查密码。 这最初是为了将密码哈希从 django 应用程序导入到 rails/devise 应用程序 安装 在您的 Gemfile 中： gem pbkdf2_password_hasher , git : '...
md5介绍：md5deep工具就是监控linux系统下的文件，给文件生成md5值，这个包是他的源码
计算文件或者一段字符串的HASH,SHA1,SHA256,CRC32,MD5的值。里面有readMe文件，可在控制台中运行计算。在界面中，readme中有详细的介绍。可显示当前计算的进度和时间信息
Django的哈希在由django admin创建的auth_user表中哈希并验证密码。安装npm i django-hash如何散列...// Hashed: pbkdf2_sha256$100000$hxtU/X2nCSo=$WREDUhqfScrEya9kjkHtK/T4hhRG1Y22roZS2EkJSWU=如何验证const djan
哈希计算工具，支持：文件，文本字符串，十六进制字符串的数据格式。支持：MD5，MD4，SHA1，SHA256，SHA384，SHA512，RIPEMD160，PANAMA，TIGER，MD2，ADLER32，CRC32等算法。 备注：只是工具，不带源码。
如果您需要共享敏感数据（例如客户电子邮件地址）以供第三方广告客户执行广告（例如自定义/量身定制的受众群体定位广告系列，第三方电子邮件新闻通讯，电子邮件广告交换等），电子邮件和文本Hash加密生成器小工具...
1、HASH类函数：MD5、SHA1、SHA256、SHA512 2、HMAC类函数：MD5、SHA1、SHA256、SHA512 3、AES encrypt和decrypt: CBC-128 4、RSA publicKey Encrypt 和 RSA privateKey Decrypt 5、RSA sign 和 RSA verify: MD...
Hash校验工具 ，可以校验文件的MD5 、SHA1 、CRC32值。