com.siashan.toolkit.crypt.digest.Md5Crypt Maven / Gradle / Ivy
package com.siashan.toolkit.crypt.digest;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* MD5加密工具类
*
* 基于libc crypt（）“$1$”和Apache“$apr1$”MD5的哈希算法
*
*
* @author siashan
* @since 1.0.7
*/
public class Md5Crypt {
/** Apache变体的标识符. */
static final String APR1_PREFIX = "$apr1$";
/** 最终哈希的字节数. */
private static final int BLOCKSIZE = 16;
/** crypt（）变量的标识符. */
static final String MD5_PREFIX = "$1$";
/** 散列次数. */
private static final int ROUNDS = 1000;
/**
* 生成与Apache htpasswd兼容的基于“$apr1$”MD5的哈希值.
*
* @param keyBytes 要哈希的纯文本字符串
* @return 哈希值
*/
public static String apr1Crypt(final byte[] keyBytes) {
return apr1Crypt(keyBytes, APR1_PREFIX + B64.getRandomSalt(8));
}
/**
* 生成与Apache htpasswd兼容的基于“$apr1$”MD5的哈希值.
*
* @param keyBytes 要哈希的纯文本字符串.
* @param random 用于生成salt的{@link Random}实例。考虑使用{@link SecureRandom } 或 {@link-ThreadLocalRandom}。
* @return 哈希值
* @since 1.0.7
*/
public static String apr1Crypt(final byte[] keyBytes, final Random random) {
return apr1Crypt(keyBytes, APR1_PREFIX + B64.getRandomSalt(8, random));
}
/**
* 生成与Apache htpasswd兼容的基于“$apr1$”MD5的哈希值.
*
* @param keyBytes
* 要哈希的纯文本字符串.
* @param salt
* 一种APR1的盐。salt可能为null，在这种情况下，将使用为您生成salt {@link-ThreadLocalRandom}；
* 对于更安全的盐，请考虑使用{@Link SecureRandom}来生成自己的盐。
* @return 哈希值
*/
public static String apr1Crypt(final byte[] keyBytes, String salt) {
// to make the md5Crypt regex happy
if (salt != null && !salt.startsWith(APR1_PREFIX)) {
salt = APR1_PREFIX + salt;
}
return md5Crypt(keyBytes, salt, APR1_PREFIX);
}
/**
* 生成与Apache htpasswd兼容的基于“$apr1$”MD5的哈希值.
*
*
* 使用{@link-ThreadLocalRandom}为您生成一个salt；
* 为了更安全的盐考虑使用{@link SecureRandom}生成您自己的salt并调用{@link#apr1Crypt（字节[]，字符串）}
*
*
* @param keyBytes
* 要哈希的纯文本字符串.
* @return 哈希值
*/
public static String apr1Crypt(final String keyBytes) {
return apr1Crypt(keyBytes.getBytes(StandardCharsets.UTF_8));
}
/**
* 生成与Apache htpasswd兼容的基于“$apr1$”MD5的哈希值.
*
* 该算法与crypt（3）“$1$”相同，但由于salt前缀的不同，会产生不同的输出。
*
*
* @param keyBytes
* 要散列的纯文本字符串.
* @param salt
* salt字符串，包括前缀和结尾的可选垃圾。
* 盐可能为空，其中使用{@link-ThreadLocalRandom}为您生成salt的情况；
* 为了更安全的盐考虑使用{@link SecureRandom}生成您自己的盐。
* @return hash值
* @since v1.0.7
*/
public static String apr1Crypt(final String keyBytes, final String salt) {
return apr1Crypt(keyBytes.getBytes(StandardCharsets.UTF_8), salt);
}
/**
* 生成与libc6 crypt（）兼容的“$1$”哈希值。
*
*
*使用{@link-ThreadLocalRandom}为您生成一个salt；为了更安全的盐考虑使用
*
* {@link SecureRandom}生成您自己的salt并调用{@link#md5Crypt（字节[]，字符串）}。
*
* @param keyBytes
* 要散列的纯文本字符串.
* @return hash值
*/
public static String md5Crypt(final byte[] keyBytes) {
return md5Crypt(keyBytes, MD5_PREFIX + B64.getRandomSalt(8));
}
/**
* 生成与libc6 crypt（）兼容的“$1$”哈希值。
*
* salt是使用您提供的{@link Random}实例为您生成的.
*
* @param keyBytes
* 要散列的纯文本字符串.
* @param random
* 用于生成salt的{@link Random}实例。考虑使用{@link SecureRandom}或{@link ThreadLocalRandom}.
* @return hash值
*/
public static String md5Crypt(final byte[] keyBytes, final Random random) {
return md5Crypt(keyBytes, MD5_PREFIX + B64.getRandomSalt(8, random));
}
/**
* 生成与libc crypt（）兼容的基于“$1$”MD5的哈希值.
*
* @param keyBytes
* 要散列的纯文本字符串.
* @param salt
* salt字符串，包括前缀和结尾的可选垃圾。
* salt可能为null，在这种情况下，使用{@link-ThreadLocalRandom}为您生成salt；
* 对于更安全的盐，请考虑使用{@link SecureRandom }来生成您自己的盐。
* @return hash值
*/
public static String md5Crypt(final byte[] keyBytes, final String salt) {
return md5Crypt(keyBytes, salt, MD5_PREFIX);
}
/**
* 生成libc6 crypt（）“$1$”或Apache htpasswd“$apr1$”散列值.
*
* @param keyBytes
* 要散列的纯文本字符串.
* @param salt
* 不带前缀或“rounds=”的实际盐值。
* salt可能为null，在这种情况下，使用{@link-ThreadLocalRandom}为您生成salt；
* 对于更安全的盐，请考虑使用{@link SecureRandom}来生成您自己的盐。
* @param prefix
* 加密盐前缀
* @return 哈希值
*/
public static String md5Crypt(final byte[] keyBytes, final String salt, final String prefix) {
return md5Crypt(keyBytes, salt, prefix, new SecureRandom());
}
/**
* 生成libc6 crypt（）“$1$”或Apache htpasswd“$apr1$”哈希值。
*
* @param keyBytes
* 要散列的纯文本字符串.
* @param salt
* 不带前缀或“rounds=”的实际盐值。
* salt可能为null，在这种情况下，使用{@link-ThreadLocalRandom}为您生成salt；
* 对于更安全的盐，请考虑使用{@link SecureRandom}来生成您自己的盐。
* @param prefix
* 加密盐前缀
* @param random
* 用于生成salt的{@link Random}实例。考虑使用{@link SecureRandom} 或{@link-ThreadLocalRandom}。
* @return 哈希值
*/
public static String md5Crypt(final byte[] keyBytes, final String salt, final String prefix, final Random random) {
final int keyLen = keyBytes.length;
// Extract the real salt from the given string which can be a complete hash string.
String saltString;
if (salt == null) {
saltString = B64.getRandomSalt(8, random);
} else {
final Pattern p = Pattern.compile("^" + prefix.replace("$", "\\$") + "([\\.\\/a-zA-Z0-9]{1,8}).*");
final Matcher m = p.matcher(salt);
if (!m.find()) {
throw new IllegalArgumentException("Invalid salt value: " + salt);
}
saltString = m.group(1);
}
final byte[] saltBytes = saltString.getBytes(StandardCharsets.UTF_8);
final MessageDigest ctx = DigestUtil.getMd5Digest();
/*
* The password first, since that is what is most unknown
*/
ctx.update(keyBytes);
/*
* Then our magic string
*/
ctx.update(prefix.getBytes(StandardCharsets.UTF_8));
/*
* Then the raw salt
*/
ctx.update(saltBytes);
/*
* Then just as many characters of the MD5(pw,salt,pw)
*/
MessageDigest ctx1 = DigestUtil.getMd5Digest();
ctx1.update(keyBytes);
ctx1.update(saltBytes);
ctx1.update(keyBytes);
byte[] finalb = ctx1.digest();
int ii = keyLen;
while (ii > 0) {
ctx.update(finalb, 0, ii > 16 ? 16 : ii);
ii -= 16;
}
/*
* Don't leave anything around in vm they could use.
*/
Arrays.fill(finalb, (byte) 0);
/*
* Then something really weird...
*/
ii = keyLen;
final int j = 0;
while (ii > 0) {
if ((ii & 1) == 1) {
ctx.update(finalb[j]);
} else {
ctx.update(keyBytes[j]);
}
ii >>= 1;
}
/*
* Now make the output string
*/
final StringBuilder passwd = new StringBuilder(prefix + saltString + "$");
finalb = ctx.digest();
/*
* and now, just to make sure things don't run too fast On a 60 Mhz Pentium this takes 34 msec, so you would
* need 30 seconds to build a 1000 entry dictionary...
*/
for (int i = 0; i < ROUNDS; i++) {
ctx1 = DigestUtil.getMd5Digest();
if ((i & 1) != 0) {
ctx1.update(keyBytes);
} else {
ctx1.update(finalb, 0, BLOCKSIZE);
}
if (i % 3 != 0) {
ctx1.update(saltBytes);
}
if (i % 7 != 0) {
ctx1.update(keyBytes);
}
if ((i & 1) != 0) {
ctx1.update(finalb, 0, BLOCKSIZE);
} else {
ctx1.update(keyBytes);
}
finalb = ctx1.digest();
}
// The following was nearly identical to the Sha2Crypt code.
// Again, the buflen is not really needed.
// int buflen = MD5_PREFIX.length() - 1 + salt_string.length() + 1 + BLOCKSIZE + 1;
B64.b64from24bit(finalb[0], finalb[6], finalb[12], 4, passwd);
B64.b64from24bit(finalb[1], finalb[7], finalb[13], 4, passwd);
B64.b64from24bit(finalb[2], finalb[8], finalb[14], 4, passwd);
B64.b64from24bit(finalb[3], finalb[9], finalb[15], 4, passwd);
B64.b64from24bit(finalb[4], finalb[10], finalb[5], 4, passwd);
B64.b64from24bit((byte) 0, (byte) 0, finalb[11], 2, passwd);
/*
* Don't leave anything around in vm they could use.
*/
// Is there a better way to do this with the JVM?
ctx.reset();
ctx1.reset();
Arrays.fill(keyBytes, (byte) 0);
Arrays.fill(saltBytes, (byte) 0);
Arrays.fill(finalb, (byte) 0);
return passwd.toString();
}
}