下面列出了org.junit.jupiter.params.provider.EnumSource#java.security.MessageDigest 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public static String parseStrToMd5L32(String str) {
String reStr = null;
try {
MessageDigest md5 = MessageDigest.getInstance("MD5");
byte[] bytes = md5.digest(str.getBytes());
StringBuffer stringBuffer = new StringBuffer();
for (byte b : bytes) {
int bt = b & 0xff;
if (bt < 16) {
stringBuffer.append(0);
}
stringBuffer.append(Integer.toHexString(bt));
}
reStr = stringBuffer.toString();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return reStr;
}
/**
* 将签名字符串转换成需要的32位签名
*/
private static String hexdigest(byte[] paramArrayOfByte) {
final char[] hexDigits = { 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
98, 99, 100, 101, 102 };
try {
MessageDigest localMessageDigest = MessageDigest.getInstance("MD5");
localMessageDigest.update(paramArrayOfByte);
byte[] arrayOfByte = localMessageDigest.digest();
char[] arrayOfChar = new char[32];
for (int i = 0, j = 0;; i++, j++) {
if (i >= 16) {
return new String(arrayOfChar);
}
int k = arrayOfByte[i];
arrayOfChar[j] = hexDigits[(0xF & k >>> 4)];
arrayOfChar[++j] = hexDigits[(k & 0xF)];
}
} catch (Exception e) {
}
return "";
}
@Override
public Long apply(String key) {
byte[] bytes = key.getBytes(StandardCharsets.UTF_8);
MessageDigest hasher = hashers.get();
if (hasher == null) {
try {
hasher = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException notFound) {
throw new RuntimeException(notFound);
}
hashers.set(hasher);
}
hasher.update(bytes);
byte[] md5Bytes = hasher.digest();
char[] hexChars = new char[md5Bytes.length * 2];
for (int j = 0; j < md5Bytes.length; j++) {
int v = md5Bytes[j] & 0xFF;
hexChars[j * 2] = HEX[v >>> 4];
hexChars[j * 2 + 1] = HEX[v & 0x0F];
}
String hexString = new String(hexChars);
if (hexString.length() > 8) {
hexString = hexString.substring(0, 8);
}
return Long.parseLong(hexString, 16);
}
private static String encode(final String s, final String alg)
{
try {
final MessageDigest md = MessageDigest.getInstance(alg);
md.reset();
md.update(s.getBytes());
final byte[] d = md.digest();
String ret = "";
for (int val : d) {
final char[] hex = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
if (val < 0) {
val = 256 + val;
}
final char hi = hex[val / 16];
final char lo = hex[val % 16];
ret = hi + "" + lo + ret;
}
return md.getAlgorithm() + '{' + ret + '}';
} catch (final NoSuchAlgorithmException ex) {
log.fatal(ex);
return "NONE{" + s + "}";
}
}
public static String MD5(RandomAccessFile randomAccessFile) {
try {
MessageDigest crypt = md5.get();
crypt.reset();
byte[] block = new byte[8 * 1024];
for (int i = 0; i < randomAccessFile.length(); i += 8 * 1024) {
int len = (int) Math.min(block.length, randomAccessFile.length() - i);
randomAccessFile.readFully(block, 0, len);
crypt.update(block, 0, len);
}
return ToHex(crypt.digest());
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
private CompletableFuture<byte[]> computeInternal(@Nonnull FDBRecordContext context,
@Nullable byte[] continuation,
@Nonnull MessageDigest messageDigest) {
return resolver.getMappingSubspaceAsync().thenCompose(mappingSubspace -> {
final RecordCursor<KeyValue> cursor = KeyValueCursor.Builder.withSubspace(mappingSubspace)
.setScanProperties(new ScanProperties(ExecuteProperties.newBuilder().setReturnedRowLimit(transactionRowLimit).setIsolationLevel(IsolationLevel.SNAPSHOT).build()))
.setContext(context)
.setContinuation(continuation)
.build();
return cursor.forEachResult(result -> {
KeyValue kv = result.get();
String key = mappingSubspace.unpack(kv.getKey()).getString(0);
ResolverResult value = resolver.deserializeValue(kv.getValue());
messageDigest.update(Tuple.from(key, value.getValue(), value.getMetadata()).pack());
}).thenApply(result -> result.getContinuation().toBytes());
});
}
/**
* Get a unique ID by fetching the phone ID and hashing it
*
* @return
*/
private String getID() {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
String actual_id = Secure.getString(getApplicationContext()
.getContentResolver(), Secure.ANDROID_ID);
byte[] bytes = actual_id.getBytes();
byte[] digest = md.digest(bytes);
StringBuffer hexString = new StringBuffer();
for (int i = 0; i < digest.length; i++) {
hexString.append(Integer.toHexString(0xFF & digest[i]));
}
return hexString.toString();
} catch (Exception e) {
return "--";
}
}
public static String MD5(String s) {
char hexDigits[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
try {
byte[] btInput = s.getBytes();
MessageDigest mdInst = MessageDigest.getInstance("MD5");
mdInst.update(btInput);
byte[] md = mdInst.digest();
int j = md.length;
char str[] = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* MD5 and Hexify an array of bytes. Take the input array, MD5 encodes it
* and then turns it into Hex.
* @param secretBytes you want md5hexed
* @return md5hexed String.
*/
public static String md5Hex(byte[] secretBytes) {
String retval = null;
// add secret
MessageDigest md;
try {
md = MessageDigest.getInstance("MD5");
//byte[] secretBytes = inputString.getBytes("UTF-8");
md.update(secretBytes);
// generate the digest
byte[] digest = md.digest();
// hexify this puppy
retval = new String(Hex.encodeHex(digest));
}
catch (NoSuchAlgorithmException e) {
throw new RuntimeException("NoSuchAlgorithm: MD5. Something" +
" weird with your JVM, you should be able to do this.", e);
}
return retval;
}
private String encode(String src, char[] passwd, MessageDigest md) {
try {
md.update(src.getBytes("ISO-8859-1"));
} catch (java.io.UnsupportedEncodingException uee) {
assert false;
}
if (passwd != null) {
byte[] passwdBytes = new byte[passwd.length];
for (int i=0; i<passwd.length; i++)
passwdBytes[i] = (byte)passwd[i];
md.update(passwdBytes);
Arrays.fill(passwdBytes, (byte)0x00);
}
byte[] digest = md.digest();
StringBuffer res = new StringBuffer(digest.length * 2);
for (int i = 0; i < digest.length; i++) {
int hashchar = ((digest[i] >>> 4) & 0xf);
res.append(charArray[hashchar]);
hashchar = (digest[i] & 0xf);
res.append(charArray[hashchar]);
}
return res.toString();
}
public static String SHA1(InputStream is) {
try {
MessageDigest messageDigest = MessageDigest.getInstance("SHA1");
final byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
for (int read; (read = is.read(buffer)) != -1; ) {
messageDigest.update(buffer, 0, read);
}
Formatter formatter = new Formatter();
// Convert the byte to hex format
for (final byte b : messageDigest.digest()) {
formatter.format("%02x", b);
}
return formatter.toString();
} catch (NoSuchAlgorithmException | IOException e) {
android.util.Log.e(TAG,e.getMessage());
} finally {
YTutils.close(is);
}
return null;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!(obj instanceof SecretKey))
return false;
String thatAlg = ((SecretKey)obj).getAlgorithm();
if (!(thatAlg.equalsIgnoreCase("DES")))
return false;
byte[] thatKey = ((SecretKey)obj).getEncoded();
boolean ret = MessageDigest.isEqual(this.key, thatKey);
java.util.Arrays.fill(thatKey, (byte)0x00);
return ret;
}
public static String encrypt(String string) {
if (TextUtils.isEmpty(string)) {
return "";
}
MessageDigest md5;
try {
md5 = MessageDigest.getInstance("MD5");
byte[] bytes = md5.digest(string.getBytes());
StringBuilder result = new StringBuilder();
for (byte b : bytes) {
String temp = Integer.toHexString(b & 0xff);
if (temp.length() == 1) {
temp = "0" + temp;
}
result.append(temp);
}
return result.toString();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return "";
}
private MessageDigest getKeyedMessageDigest(char[] aKeyPassword)
throws NoSuchAlgorithmException, UnsupportedEncodingException {
int i, j;
MessageDigest md = MessageDigest.getInstance("SHA");
byte[] keyPasswordBytes = new byte[aKeyPassword.length * 2];
for (i = 0, j = 0; i < aKeyPassword.length; i++) {
keyPasswordBytes[j++] = (byte) (aKeyPassword[i] >> 8);
keyPasswordBytes[j++] = (byte) aKeyPassword[i];
}
md.update(keyPasswordBytes);
for (i = 0; i < keyPasswordBytes.length; i++)
keyPasswordBytes[i] = 0;
md.update(SECRET_KEY_HASH_WORD.getBytes("UTF8"));
return md;
}
public static String getMD5(String str) {
MessageDigest md5 = null;
try {
md5 = MessageDigest.getInstance("MD5");
} catch (Exception e) {
e.printStackTrace();
return "";
}
char[] charArray = str.toCharArray();
byte[] byteArray = new byte[charArray.length];
for (int i = 0; i < charArray.length; i++) {
byteArray[i] = (byte) charArray[i];
}
byte[] md5Bytes = md5.digest(byteArray);
StringBuffer hexValue = new StringBuffer();
for (int i = 0; i < md5Bytes.length; i++) {
int val = ((int) md5Bytes[i]) & 0xff;
if (val < 16) {
hexValue.append("0");
}
hexValue.append(Integer.toHexString(val));
}
return hexValue.toString();
}
protected String md5sign(final String txId, final String amount) {
final StringBuilder sign = new StringBuilder();
sign.append(getParameterValue(AN_MD5_HASH_KEY));
sign.append(getParameterValue(AN_API_LOGIN_ID));
sign.append(txId);
sign.append(amount);
sign.append("EUR");
try {
final Charset charset = StandardCharsets.UTF_8;
final MessageDigest digest = MessageDigest.getInstance("MD5");
return new String(Hex.encodeHex(digest.digest(sign.toString().getBytes(charset)))).toUpperCase();
} catch (NoSuchAlgorithmException e) {
LOG.error("MD5 not available", e);
return "MD5 not available";
}
}
public static byte[] encrypt(byte[] data, String key)
throws NoSuchAlgorithmException, NoSuchPaddingException, UnsupportedEncodingException,
InvalidKeyException, IllegalBlockSizeException, BadPaddingException,
InvalidAlgorithmParameterException {
Cipher cipher = Cipher.getInstance(TRANSFORMATION);
MessageDigest digest = MessageDigest.getInstance(MESSAGE_DIGEST_ALGORITHM);
digest.update(key.getBytes("UTF-8"));
// default JVM impl. may only support key strength up to 128 bit;
byte[] keyData = new byte[16];
System.arraycopy(digest.digest(), 0, keyData, 0, keyData.length);
SecretKeySpec keySpec = new SecretKeySpec(keyData, SECRET_KEY_ALGORITHM);
IvParameterSpec ivSpec = new IvParameterSpec(IV);
data = deflate(data);
cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
return xor(cipher.doFinal(data));
}
/** get digest from cache */
private MessageDigest getDigest(String algorithm) throws SignatureException {
// check that algorithm is not restricted
if (!JAR_DISABLED_CHECK.permits(DIGEST_PRIMITIVE_SET, algorithm, null)) {
SignatureException e =
new SignatureException("SignatureFile check failed. " +
"Disabled algorithm used: " + algorithm);
throw e;
}
if (createdDigests == null)
createdDigests = new HashMap<String, MessageDigest>();
MessageDigest digest = createdDigests.get(algorithm);
if (digest == null) {
try {
digest = MessageDigest.getInstance(algorithm);
createdDigests.put(algorithm, digest);
} catch (NoSuchAlgorithmException nsae) {
// ignore
}
}
return digest;
}
/**
URL(服务器地址) http://www.programself.com/JavaWeb/app/weichat/core/accessWeiChat
Token(令牌) pirtzxLSjoAjacYXemOSflqtyns0wpQK
EncodingAESKey(消息加解密密钥) xcd4N4i53IB9rrtLOra7Tvt8ybLLhAzjacKhGBaUb7h
消息加解密方式 安全模式
*/
//校验签名
public static boolean checkSignature(String signature, String timestamp, String nonce) throws Exception {
//将token、timestamp、nonce三个参数进行字典序排序
String[] paramArr = new String[] { Token, timestamp, nonce };
Arrays.sort(paramArr);
//将三个参数字符串拼接成一个字符串进行sha1加密
String content = paramArr[0].concat(paramArr[1]).concat(paramArr[2]);
MessageDigest md = MessageDigest.getInstance("SHA-1");
// 对接后的字符串进行sha1加密
byte[] digest = md.digest(content.toString().getBytes());
String ciphertext = byteToStr(digest);
//开发者获得加密后的字符串可与signature对比,标识该请求来源于微信
return ciphertext != null ? ciphertext.equals(signature.toUpperCase()) : false;
}
/**
* Verifies the validity of checksum field
*
* @param data the application data
* @param offset the offset where the data begins
* @param len the length of the application data
*
* @throws GSSException if an error occurs in the checksum calculation
*/
public final boolean verifySign(byte[] data, int offset, int len)
throws GSSException {
// debug("\t====In verifySign:====\n");
// debug("\t\t checksum: [" + getHexBytes(checksum) + "]\n");
// debug("\t\t data = [" + getHexBytes(data) + "]\n");
byte[] myChecksum = getChecksum(data, offset, len);
// debug("\t\t mychecksum: [" + getHexBytes(myChecksum) +"]\n");
if (MessageDigest.isEqual(checksum, myChecksum)) {
// debug("\t\t====Checksum PASS:====\n");
return true;
}
return false;
}
private MessageDigest uploadParts(BoxFile uploadedFile, BoxFileUploadSession.Info session,
long fileSize, String fileName) throws Exception {
URL fileURL = this.getClass().getResource("/sample-files/" + fileName);
String filePath = URLDecoder.decode(fileURL.getFile(), "utf-8");
File file = new File(filePath);
FileInputStream stream = new FileInputStream(file);
MessageDigest fileDigest = MessageDigest.getInstance("SHA1");
DigestInputStream dis = new DigestInputStream(stream, fileDigest);
long offset = 0;
byte[] bytes = null;
long processed = 0;
boolean canBreak = false;
while (true) {
long min = session.getPartSize();
long diff = fileSize - processed;
if (diff < min) {
min = diff;
canBreak = true;
}
BoxFileUploadSessionPart part = session.getResource().uploadPart(dis, offset, (int) min, fileSize);
Assert.assertNotNull(part.getSha1());
Assert.assertNotNull(part.getPartId());
Assert.assertEquals(part.getOffset(), offset);
Assert.assertTrue(part.getSize() <= session.getPartSize());
offset = offset + session.getPartSize();
processed += min;
if (canBreak) {
break;
}
}
return fileDigest;
}
public String calculateSignature() {
MessageDigest md = null;
try {
md = MessageDigest.getInstance("MD5");
StringBuilder sigString = new StringBuilder();
sigString.append(this.name).append("|").append(this.getFactTable()).append("|").append(JsonUtil.writeValueAsString(this.model.getPartitionDesc())).append("|").append(JsonUtil.writeValueAsString(this.dimensions)).append("|").append(JsonUtil.writeValueAsString(this.measures)).append("|").append(JsonUtil.writeValueAsString(this.rowkey)).append("|").append(JsonUtil.writeValueAsString(this.hbaseMapping));
byte[] signature = md.digest(sigString.toString().getBytes());
return new String(Base64.encodeBase64(signature));
} catch (NoSuchAlgorithmException | JsonProcessingException e) {
throw new RuntimeException("Failed to calculate signature");
}
}
private boolean digestInputEqual(Reference ref) throws Exception {
MessageDigest md = MessageDigest.getInstance("SHA1");
InputStream is = ref.getDigestInputStream();
int nbytes;
byte[] buf = new byte[256];
while ((nbytes = is.read(buf, 0, buf.length)) != -1) {
md.update(buf, 0, nbytes);
}
return Arrays.equals(md.digest(), ref.getDigestValue());
}
private void validateFile(long counter) throws Exception {
Path file = new Path(rootPath + "/" + generateObjectName(counter));
byte[] content = timer.time(() -> {
try (FSDataInputStream input = fileSystem.open(file)) {
return IOUtils.toByteArray(input);
}
});
if (!MessageDigest.isEqual(referenceDigest, getDigest(content))) {
throw new IllegalStateException(
"Reference (=first) message digest doesn't match with digest of "
+ file.toString());
}
}
/**
* create a SHA1 hash of the path
*
* @param nodePath
* @param encode
* @return some SHA1 hash value possibly
* @throws NoSuchAlgorithmException
*/
public static String hash(String nodePath)
{
MessageDigest mdigest = (MessageDigest) digest.get();
if ( mdigest == null )
{
try
{
mdigest = MessageDigest.getInstance("SHA1");
digest.set(mdigest);
}
catch (NoSuchAlgorithmException e)
{
throw new RuntimeException("Failed to find SHA1 message digest: " + e, e);
}
}
byte[] b = mdigest.digest(nodePath.getBytes());
char[] c = new char[b.length * 2];
for (int i = 0; i < b.length; i++)
{
c[i * 2] = encode[b[i]&0x0f];
c[i * 2 + 1] = encode[(b[i]>>4)&0x0f];
}
String encoded = new String(c);
log.debug("Encoded "+nodePath+" as "+encoded);
return encoded;
}
private static String encode(String algorithm, String value) {
if (value == null) {
return null;
}
try {
MessageDigest messageDigest
= MessageDigest.getInstance(algorithm);
messageDigest.update(value.getBytes());
return getFormattedText(messageDigest.digest());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static String hashBytes(MessageDigest hash, byte[] bytes) {
hash.update(bytes);
byte[] digest = hash.digest();
StringBuilder builder = new StringBuilder();
for (int b : digest) {
builder.append(Integer.toHexString((b >> 4) & 0xf));
builder.append(Integer.toHexString((b >> 0) & 0xf));
}
return builder.toString();
}
public String getMd5(String str) {
MessageDigest md = null;
try {
md = MessageDigest.getInstance("MD5");
} catch (Exception e) {
e.printStackTrace();
}
md.update(str.getBytes());
byte b[] = md.digest();
str = byte2hex(b);
return str;
}
public static String encrypt(String password,String algorithm){
try {
MessageDigest md = MessageDigest.getInstance(algorithm);
byte[] b = md.digest(password.getBytes());
return ByteUtils.byte2HexString(b);
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/** Netscape doesn't include the new line. Intel and JavaSoft do */
public byte[] digestWorkaround(MessageDigest md)
{
md.reset();
for (Section sec : sections) {
md.update(sec.rawBytes, sec.offset, sec.length);
}
return md.digest();
}