Java中使用MD5进行加密

合集下载

java中常用的md5方法

java中常用的md5方法Java是一种广泛使用的编程语言，特别适合用于开发各种类型的应用程序。

在Java中，MD5（Message-Digest Algorithm 5）是一种常用的哈希算法，用于产生唯一的消息摘要。

本文将详细介绍在Java中常用的MD5方法。

第一步：导入相关的包使用MD5算法需要导入Java的Security包。

在代码的开头加上以下导入语句:import java.security.MessageDigest;第二步：创建一个方法在Java中，我们可以创建一个方法用于计算MD5消息摘要。

下面是一个示例：public static String getMD5(String input) {try {MessageDigest md =MessageDigest.getInstance("MD5"); 创建MD5加密对象byte[] messageDigest = md.digest(input.getBytes()); 获取二进制摘要值转化为十六进制字符串形式StringBuilder hexString = new StringBuilder();for (byte b : messageDigest) {String hex = Integer.toHexString(0xFF & b);if (hex.length() == 1) {hexString.append('0');}hexString.append(hex);}return hexString.toString();} catch (Exception ex) {ex.printStackTrace();return null;}}第三步：调用方法要使用这个方法，只需在代码中调用getMD5()方法，并传递要进行MD5加密的消息作为参数。

以下是一个使用示例：String input = "Hello World";String md5Hash = getMD5(input);System.out.println("MD5加密后的结果：" + md5Hash);以上代码将输出：MD5加密后的结果：0a4d55a8d778e5022fab701977c5d840第四步：解释代码让我们来解释一下上面的代码。

Java实现MD5加密及解密的代码实例分享

Java实现MD5加密及解密的代码实例分享基础：MessageDigest类的使⽤其实要在Java中完成MD5加密，MessageDigest类⼤部分都帮你实现好了，⼏⾏代码⾜矣：/*** 对字符串md5加密** @param str* @return*/import java.security.MessageDigest;public static String getMD5(String str) {try {// ⽣成⼀个MD5加密计算摘要MessageDigest md = MessageDigest.getInstance("MD5");// 计算md5函数md.update(str.getBytes());// digest()最后确定返回md5 hash值，返回值为8为字符串。

因为md5 hash值是16位的hex值，实际上就是8位的字符// BigInteger函数则将8位的字符串转换成16位hex值，⽤字符串来表⽰；得到字符串形式的hash值return new BigInteger(1, md.digest()).toString(16);} catch (Exception e) {throw new SpeedException("MD5加密出现错误");}}进阶：加密及解密类Java实现MD5加密以及解密类，附带测试类，具体见代码。

MD5加密解密类——MyMD5Util,代码如下package com.zyg.security.md5;import java.io.UnsupportedEncodingException;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import java.security.SecureRandom;import java.util.Arrays;public class MyMD5Util {private static final String HEX_NUMS_STR="0123456789ABCDEF";private static final Integer SALT_LENGTH = 12;/*** 将16进制字符串转换成字节数组* @param hex* @return*/public static byte[] hexStringToByte(String hex) {int len = (hex.length() / 2);byte[] result = new byte[len];char[] hexChars = hex.toCharArray();for (int i = 0; i < len; i++) {int pos = i * 2;result[i] = (byte) (HEX_NUMS_STR.indexOf(hexChars[pos]) << 4| HEX_NUMS_STR.indexOf(hexChars[pos + 1]));}return result;}/*** 将指定byte数组转换成16进制字符串* @param b* @return*/public static String byteToHexString(byte[] b) {StringBuffer hexString = new StringBuffer();for (int i = 0; i < b.length; i++) {String hex = Integer.toHexString(b[i] & 0xFF);if (hex.length() == 1) {hex = '0' + hex;}hexString.append(hex.toUpperCase());}return hexString.toString();}/*** 验证⼝令是否合法* @param password* @param passwordInDb* @return* @throws NoSuchAlgorithmException* @throws UnsupportedEncodingException*/public static boolean validPassword(String password, String passwordInDb)throws NoSuchAlgorithmException, UnsupportedEncodingException {//将16进制字符串格式⼝令转换成字节数组byte[] pwdInDb = hexStringToByte(passwordInDb);//声明盐变量byte[] salt = new byte[SALT_LENGTH];//将盐从数据库中保存的⼝令字节数组中提取出来System.arraycopy(pwdInDb, 0, salt, 0, SALT_LENGTH);//创建消息摘要对象MessageDigest md = MessageDigest.getInstance("MD5");//将盐数据传⼊消息摘要对象md.update(salt);//将⼝令的数据传给消息摘要对象md.update(password.getBytes("UTF-8"));//⽣成输⼊⼝令的消息摘要byte[] digest = md.digest();//声明⼀个保存数据库中⼝令消息摘要的变量byte[] digestInDb = new byte[pwdInDb.length - SALT_LENGTH];//取得数据库中⼝令的消息摘要System.arraycopy(pwdInDb, SALT_LENGTH, digestInDb, 0, digestInDb.length); //⽐较根据输⼊⼝令⽣成的消息摘要和数据库中消息摘要是否相同if (Arrays.equals(digest, digestInDb)) {//⼝令正确返回⼝令匹配消息return true;} else {//⼝令不正确返回⼝令不匹配消息return false;}}/*** 获得加密后的16进制形式⼝令* @param password* @return* @throws NoSuchAlgorithmException* @throws UnsupportedEncodingException*/public static String getEncryptedPwd(String password)throws NoSuchAlgorithmException, UnsupportedEncodingException {//声明加密后的⼝令数组变量byte[] pwd = null;//随机数⽣成器SecureRandom random = new SecureRandom();//声明盐数组变量byte[] salt = new byte[SALT_LENGTH];//将随机数放⼊盐变量中random.nextBytes(salt);//声明消息摘要对象MessageDigest md = null;//创建消息摘要md = MessageDigest.getInstance("MD5");//将盐数据传⼊消息摘要对象md.update(salt);//将⼝令的数据传给消息摘要对象md.update(password.getBytes("UTF-8"));//获得消息摘要的字节数组byte[] digest = md.digest();//因为要在⼝令的字节数组中存放盐，所以加上盐的字节长度pwd = new byte[digest.length + SALT_LENGTH];//将盐的字节拷贝到⽣成的加密⼝令字节数组的前12个字节，以便在验证⼝令时取出盐 System.arraycopy(salt, 0, pwd, 0, SALT_LENGTH);//将消息摘要拷贝到加密⼝令字节数组从第13个字节开始的字节System.arraycopy(digest, 0, pwd, SALT_LENGTH, digest.length);//将字节数组格式加密后的⼝令转化为16进制字符串格式的⼝令return byteToHexString(pwd);}}测试类——Client,代码如下：package com.zyg.security.md5;import java.io.UnsupportedEncodingException;import java.security.NoSuchAlgorithmException;import java.util.HashMap;import java.util.Map;public class Client {private static Map users = new HashMap();public static void main(String[] args){String userName = "zyg";String password = "123";registerUser(userName,password);userName = "changong";password = "456";registerUser(userName,password);String loginUserId = "zyg";String pwd = "1232";try {if(loginValid(loginUserId,pwd)){System.out.println("欢迎登陆");}else{System.out.println("⼝令错误，请重新输⼊");}} catch (NoSuchAlgorithmException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (UnsupportedEncodingException e) {// TODO Auto-generated catch blocke.printStackTrace();}}/*** 注册⽤户** @param userName* @param password*/public static void registerUser(String userName,String password){String encryptedPwd = null;try {encryptedPwd = MyMD5Util.getEncryptedPwd(password);users.put(userName, encryptedPwd);} catch (NoSuchAlgorithmException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (UnsupportedEncodingException e) {// TODO Auto-generated catch blocke.printStackTrace();}}/*** 验证登陆** @param userName* @param password* @return* @throws UnsupportedEncodingException* @throws NoSuchAlgorithmException*/public static boolean loginValid(String userName,String password)throws NoSuchAlgorithmException, UnsupportedEncodingException{String pwdInDb = (String)users.get(userName);if(null!=pwdInDb){ // 该⽤户存在return MyMD5Util.validPassword(password, pwdInDb);}else{System.out.println("不存在该⽤户");return false;}}}PS：这⾥再为⼤家提供2款MD5加密⼯具，感兴趣的朋友可以参考⼀下：MD5在线加密⼯具：在线MD5/hash/SHA-1/SHA-2/SHA-256/SHA-512/SHA-3/RIPEMD-160加密⼯具：。

java中的md5用法

java中的md5用法Java中的MD5用法什么是MD5MD5是一种常见的哈希算法，用于对任意长度的数据进行加密。

它可以将任意长度的数据转化为定长的128位(16字节)哈希值。

使用场景MD5主要用于密码存储、数据完整性校验、数字签名等场景。

使用步骤1.导入类:import ;2.创建MD5对象:MessageDigest md = ("MD5");此处也可以使用其他哈希算法，如”SHA-1”等。

3.将要加密的数据转换为字节数组:String data = "Hello, World!";byte[] dataBytes = ();4.将字节数组更新到MD5对象中:(dataBytes);5.计算MD5的哈希值:byte[] md5Bytes = ();6.将MD5的哈希值转化为字符串表示:StringBuilder sb = new StringBuilder();for (byte b : md5Bytes) {(("%02x", b & 0xff));}String md5 = ();通过上述步骤，我们即可得到原始数据的MD5加密结果。

实际应用密码存储在用户注册或登录时，常常需要对用户输入的密码进行加密后才能进行存储或验证。

以下是一个示例代码：public static String getMD5(String data) {String md5 = null;try {MessageDigest md = ("MD5");byte[] dataBytes = ();(dataBytes);byte[] md5Bytes = ();StringBuilder sb = new StringBuilder();for (byte b : md5Bytes) {(("%02x", b & 0xff));}md5 = ();} catch (Exception e) {();}return md5;}在注册时，可以将用户输入的密码使用上述方法加密后存储到数据库中。

对中文进行MD5加密的注意事项（Java版，编码问题）

对中⽂进⾏MD5加密的注意事项（Java版，编码问题）在⼯作中需要和第三⽅进⾏Http通信，在通信内容中有⼏个参数涉及到了中⽂。

⾃⼰在进⾏MD5加密验证过程中，遇到了⼀些很奇怪（本⼈认为MD5是⼀个通⽤简单的加密，应该很稳定很完美了吧！）的问题：问题1：接收到的问题乱码了解决：这个问题很常见，⽹上有很多说明。

由于http协议在传输过程中使⽤的都是iso_8859_1编码，所以在接收到参数之后，⽤value = new String(value.getBytes("ISO-8859-1"),"UTF-8"); ⽅法转成utf-8就可以了。

问题2：按照问题1的解决办法，⽣成MD5加密之前的字符串（⽇志中显⽰中⽂没有乱码），但是MD5加密之后字符串和本地的⽣成的不⼀样。

解决：这个问题就⽐较奇怪了。

我⼜详细的查看了查看了第三⽅的开发问题，发现其中有"台通知参数都⽤URLEncoder.encode("xxx","UTF-8")做了编码处理"这句话，是不是这个原因引起的呢？⾃⼰做了尝试将参数⼜通过value=URLDecoder.decode(value, "UTF-8")进⾏了解码。

出来，加密的字符串⼀致了。

问题3：这个问题就更奇怪了，在测试环境MD5之后是⼀样的，在正式环境就不⼀样了，并且正式环境的tomcat重新启动之后就正常了，但是⼀段时间之后⼜出现问题了。

解决：这个问题是由于MD5中⽤的String.getBytes()没有显⽰的指定编码格式导致的。

如果⽅法String.getBytes()不显⽰指定编码格式，本⽅法将返回该默认的编码格式的字节数组。

（这个问题还有个疑问就是为什么重启tomcat之后⼜正常了）总结：这个Http通信时，对⽅进⾏了怎么样的正向操作，你就要逆向把它解析出来。

java 标准的md5

java 标准的md5Java标准的MD5。

在Java编程中，MD5（Message Digest Algorithm 5）是一种广泛使用的加密算法，用于对数据进行加密和摘要处理。

MD5算法产生的摘要长度为128位，通常以32位十六进制数表示，它是一种不可逆的加密算法，即无法通过MD5摘要逆向推导出原始数据。

在本文中，我们将详细介绍Java标准的MD5算法的使用方法和相关注意事项。

首先，我们需要了解如何在Java中使用MD5算法对数据进行加密。

Java标准库中提供了java.security.MessageDigest类来实现MD5算法。

下面是一个简单的示例代码：```java。

import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;public class MD5Example {。

public static void main(String[] args) {。

String input = "Hello, MD5!";try {。

MessageDigest md = MessageDigest.getInstance("MD5");md.update(input.getBytes());byte[] digest = md.digest();StringBuffer sb = new StringBuffer();for (byte b : digest) {。

sb.append(String.format("%02x", b & 0xff));}。

System.out.println("MD5 hash: " + sb.toString());} catch (NoSuchAlgorithmException e) {。

加密系列MD5加密和解密算法详解代码示例

加密系列MD5加密和解密算法详解代码示例MD5加密算法是一种广泛应用的密码加密算法，它将任意长度的数据映射为固定长度的128位哈希值。

MD5加密算法是不可逆的，即通过密文无法还原得到原始数据。

MD5加密算法的实现可以通过编写代码来完成。

下面是一个示例的MD5加密算法的代码：```import hashlibdef md5_encrypt(data):md5 = hashlib.md5md5.update(data.encode('utf-8'))return md5.hexdigestif __name__ == '__main__':data = input("请输入需要加密的数据：")encrypted_data = md5_encrypt(data)print("加密结果为：", encrypted_data)```以上代码实现了一个简单的MD5加密算法。

首先导入了`hashlib`模块，该模块提供了一系列用于数据加密的算法，包括MD5算法。

`md5_encrypt`函数接收一个字符串作为输入数据，并将其转换为字节流形式，然后使用`hashlib.md5`方法创建了一个MD5对象。

接着，通过调用MD5对象的`update`方法将输入数据添加到加密流程中。

最后，通过调用MD5对象的`hexdigest`方法获得加密后的结果，并将其返回。

在`if __name__ == '__main__'`下方的代码段中，首先获取用户输入的数据，然后调用`md5_encrypt`函数对其进行加密，并将结果打印到控制台。

下面是MD5解密算法的示例代码：```import hashlibdef md5_decrypt(encrypted_data):md5 = hashlib.md5md5.update(encrypted_data.encode('utf-8'))return md5.hexdigestif __name__ == '__main__':encrypted_data = input("请输入需要解密的数据：")decrypted_data = md5_decrypt(encrypted_data)print("解密结果为：", decrypted_data)```以上代码实现了一个简单的MD5解密算法。

Java详解单向加密--MD5、SHA和HMAC及简单实现实例

Java详解单向加密--MD5、SHA和HMAC及简单实现实例Java 详解单向加密--MD5、SHA和HMAC及简单实现实例概要：MD5、SHA、HMAC这三种加密算法，可谓是⾮可逆加密，就是不可解密的加密⽅法。

MD5MD5即Message-Digest Algorithm 5（信息-摘要算法5），⽤于确保信息传输完整⼀致。

MD5是输⼊不定长度信息，输出固定长度128-bits的算法。

MD5算法具有以下特点：1、压缩性：任意长度的数据，算出的MD5值长度都是固定的。

2、容易计算：从原数据计算出MD5值很容易。

3、抗修改性：对原数据进⾏任何改动，哪怕只修改1个字节，所得到的MD5值都有很⼤区别。

4、强抗碰撞：已知原数据和其MD5值，想找到⼀个具有相同MD5值的数据（即伪造数据）是⾮常困难的。

MD5还⼴泛⽤于操作系统的登陆认证上，如Unix、各类BSD系统登录密码、数字签名等诸多⽅⾯。

如在Unix系统中⽤户的密码是以MD5（或其它类似的算法）经Hash运算后存储在⽂件系统中。

当⽤户登录的时候，系统把⽤户输⼊的密码进⾏MD5 Hash运算，然后再去和保存在⽂件系统中的MD5值进⾏⽐较，进⽽确定输⼊的密码是否正确。

通过这样的步骤，系统在并不知道⽤户密码的明码的情况下就可以确定⽤户登录系统的合法性。

这可以避免⽤户的密码被具有系统管理员权限的⽤户知道。

MD5将任意长度的“字节串”映射为⼀个128bit的⼤整数，并且通过该128bit反推原始字符串是⾮常困难的。

SHASHA(Secure Hash Algorithm，安全散列算法），数字签名等密码学应⽤中重要的⼯具，被⼴泛地应⽤于电⼦商务等信息安全领域。

虽然SHA与MD5通过碰撞法都被破解了，但是SHA仍然是公认的安全加密算法，较之MD5更为安全。

SHA所定义的长度下表中的中继散列值（internal state）表⽰对每个数据区块压缩散列过后的中继值（internal hash sum）。

java密码规则

java密码规则
Java密码规则是指在Java编程中关于密码设置的标准。

密码设置是保证系统安全的重要措施，因此在Java中有许多规则需要遵守。

首先，密码应该是强密码。

强密码通常包括大写字母、小写字母、数字和特殊字符，长度至少为8个字符。

这样可以减少密码被猜测的概率，提高系统安全性。

其次，密码应该经过加密处理。

在Java中，可以使用MD5、SHA-1等算法对密码进行加密，使得密码在传输和存储过程中无法被轻易获取。

另外，密码应该避免使用简单的字典单词、拼音和生日等容易被猜测的信息。

还应该定期更改密码，避免长期使用相同的密码。

总之，Java密码规则是为了保障系统安全而设置的严格标准，开发人员应该在编程时认真遵守，确保系统的安全性。

- 1 -。

MD5的使用方法

MD5的使⽤⽅法MD5加密的Java实现在各种应⽤系统中，如果需要设置账户，那么就会涉及到存储⽤户账户信息的问题，为了保证所存储账户信息的安全，通常会采⽤MD5加密的⽅式来，进⾏存储。

⾸先，简单得介绍⼀下，什么是MD5加密。

MD5的全称是Message-Digest Algorithm 5 （信息-摘要算法），在90年代初，由MIT Laboratory for Computer Scientce 和RSA Data Security Inc 的 Ronald L.Rivest开发出来，经MD2、MD3和MD4发展⽽来。

是让⼤容量信息在⽤数字签名软件签署私⼈密匙前被"压缩"成⼀种保密的格式（就是把⼀个任意长度的字节串变换成⼀定长的⼤整数）。

不管是MD2、MD4还是MD5，它们都需要获得⼀个随机长度的信息并产⽣⼀个128位的信息摘要。

虽然这些算法的结构或多或少有些相似，但MD2的设计与MD4和MD5完全不同，那是因为MD2是为8位机器做过设计优化的，⽽MD4和MD5却是⾯向32位的电脑。

这三个算法的描述和C语⾔源代码在Internet RFCs 1321中有详细的描述，这是⼀份最权威的⽂档，由Ronald L.Rivest在1992年8⽉向IETF提交。

（⼀）消息摘要简介⼀个消息摘要就是⼀个数据块的数字指纹。

即对⼀个任意长度的⼀个数据块进⾏计算，产⽣⼀个唯⼀指印（对于SHA1是产⽣⼀个20字节的⼆进制数组）。

消息摘要是⼀种与消息认证码结合使⽤以确保消息完整性的技术。

主要使⽤单向散列函数算法，可⽤于检验消息的完整性，和通过散列密码直接以⽂本形式保存等，⽬前⼴泛使⽤的算法由MD4、MD5、SHA-1.消息摘要有两个基本属性：1.两个不同的报⽂难以⽣成相同的摘要2.难以对指定的摘要⽣成⼀个报⽂，⽽可以由改报⽂反推算出该指定的摘要代表：美国国家标准技术研究所的SHA1和⿇省理⼯学院Ronald Rivest提出的MD5（⼆）对字符串进⾏加密package test;import java.io.UnsupportedEncodingException;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import sun.misc.BASE64Encoder;/*** 对字符串进⾏加密* @param str 待加密的字符串* @return 加密后的字符串* @throws NoSuchAlgorithmException 没有这种产⽣消息摘要的算法* @throws UnsupportedEncodingException*/public class Demo01 {public static String EncoderByMd5(String str) throws NoSuchAlgorithmException, UnsupportedEncodingException{//确定算法MessageDigest md5 = MessageDigest.getInstance("MD5");BASE64Encoder base64en = new BASE64Encoder();//加密后的字符串String newstr = base64en.encode(md5.digest(str.getBytes("utf-8")));return newstr;}public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {String str = "0123456789";System.out.println(EncoderByMd5(str));}}（三）验证密码是否正确package test;import java.io.UnsupportedEncodingException;import java.security.NoSuchAlgorithmException;/*** 判断⽤户密码是否正确* @param newpasswd ⽤户输⼊的密码* @param oldpasswd 数据库中存储的密码－－⽤户密码的摘要* @return* @throws NoSuchAlgorithmException* @throws UnsupportedEncodingException**/public class Demo02 {public static boolean checkpassword(String newpasswd, String oldpasswd) throws NoSuchAlgorithmException, UnsupportedEncodingException{if (Demo01.EncoderByMd5(newpasswd).equals(oldpasswd)) {return true;} else {return false;}}public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {System.out.println("old:"+Demo01.EncoderByMd5("123"));System.out.println("new:"+Demo01.EncoderByMd5("123"));System.out.println(checkpassword("123",Demo01.EncoderByMd5("123")));}}因为MD5是基于消息摘要原理的，消息摘要的基本特征就是很难根据摘要推算出消息报⽂，因此要验证密码是否正确，就必须对输⼊密码（消息报⽂）重新计算其摘要，和数据库中存储的摘要进⾏对⽐（即数据库中存储的其实为⽤户密码的摘要），若两个摘要相同，则说明密码正确，不同，则说明密码错误。

java的md5util.encodemd5string方法

java的md5util.encodemd5string方法Java的MD5Util.encodeMD5String方法是一种常见的加密方法，用于将任意长度的字符串转化成固定长度的MD5值。

在本文中，我们将一步一步地回答有关这个方法的问题，从而全面地了解它的使用和原理。

1. 什么是MD5？MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，常用于对密码或其他敏感信息进行加密。

它产生一个唯一的128位（32个字符）MD5值，不同的输入会产生不同的输出，且无法从MD5值反推出原始数据。

2. 什么是加密方法？加密是一种将数据转化为不可读的密文的过程，以保护数据的安全性。

而加密方法则指用于执行加密操作的算法或函数。

3. MD5Util.encodeMD5String方法的作用是什么？MD5Util.encodeMD5String方法用于将字符串转化为MD5值。

通过将用户输入的字符串进行哈希处理，可以将其变为不可逆的MD5值。

这样一来，即使有人获取了MD5值，也无法从中获取原始数据。

4. 这个方法的使用步骤是什么？使用MD5Util.encodeMD5String方法有以下几个步骤：- 导入MD5Util类。

- 创建一个字符串变量，用来存储需要加密的字符串。

- 调用MD5Util.encodeMD5String方法并传入需要加密的字符串作为参数。

- 获取返回的MD5值并进行后续操作，如存储、比较等。

5. encodeMD5String方法的参数和返回值是什么？encodeMD5String方法的参数是一个字符串类型的明文数据。

它返回一个字符串类型的MD5值，即将明文数据转化后的加密结果。

6. 如何导入MD5Util类？要使用MD5Util类，首先需要确保该类已存在于项目中。

如果该类来自于外部库或框架，则需要先在项目的构建路径中导入相关的依赖。

然后，在Java代码的开头导入MD5Util类。

java中常用的md5方法 -回复

java中常用的md5方法-回复Java中常用的MD5方法是一种常见的数据加密方式，它能够将任意长度的数据转换为固定长度的字符串。

在本文中，我们将详细介绍MD5的基本概念、原理，以及在Java中如何使用MD5方法实现数据加密。

第一部分：MD5的基本概念与原理（300-500字）MD5（Message Digest Algorithm 5）是一种广泛使用的哈希算法，由Ron Rivest于1991年设计。

MD5算法将任意长度的输入数据通过一系列步骤转换为128位长度的输出字符串。

其具体的转换过程由四轮循环操作组成，其中每轮包括四个步骤：填充、划分、压缩和输出。

通过这些操作，MD5算法能够保证输出的唯一性和不可逆性，即无法从MD5值还原出原始数据。

第二部分：Java中的MD5方法（600-1000字）Java提供了多种方法来实现MD5加密，下面我们一步一步详细介绍如何在Java中使用MD5方法。

步骤一：导入相关的类库在使用MD5方法之前，需要导入Java提供的相关类库。

在Java中，可以使用java.security.MessageDigest类来进行MD5加密操作。

因此，需要在代码的开头导入该类。

javaimport java.security.MessageDigest;步骤二：创建MD5加密方法在Java中，可以通过调用java.security.MessageDigest类的getInstance方法来获取MD5加密实例。

javaMessageDigest md = MessageDigest.getInstance("MD5");步骤三：传入待加密的数据调用md实例的update方法，将待加密的数据传入。

在md实例中，可以通过调用digest方法获取加密后的数据。

需要注意的是，MD5加密后的数据是以字节数组的形式存储的。

javamd.update(data.getBytes());byte[] encryptedData = md.digest();步骤四：转换为字符串形式将字节数组形式的加密数据转换为字符串形式，可以使用Java提供的辅助类进行转换。

java md5 加密原理

Java MD5 加密原理一、MD5 简介在计算机领域，MD5（Message Digest Algorithm 5）是一种广泛应用的哈希算法。

它将任意长度的消息作为输入，通过一系列的运算，生成一个128位（16字节）的哈希值。

MD5 由 Ronald Rivest 设计于 1991 年，至今仍被广泛使用。

本文将详细讨论 MD5 加密的原理及其在 Java 中的实现。

二、MD5 加密原理MD5 加密算法的核心思想是将输入的消息分成若干个大小相等的块，并通过一系列的变换，逐步产生最终的哈希值。

具体步骤如下：1. 填充数据首先，需要将输入的消息填充到一个 512 位的块中。

填充规则如下： - 如果消息的长度（以字节为单位）对 512 取余的结果小于 448，需要填充的位数为 448 减去余数； - 如果消息的长度对 512 取余的结果大于 448，则填充的位数为 512减去余数加上 448。

填充后，消息的长度必然是 512 的整数倍。

2. 填充长度在填充数据的末尾，需要附加消息的原始长度（以位为单位），表示消息的实际长度。

原始长度需要用 64 位表示，因此填充长度的过程是将原始长度转换为 64 位的二进制形式，并附加在填充数据之后。

3. 初始化参数MD5 算法还需要定义一些初始参数，包括四个 32 位的寄存器（A、B、C、D），初始时分别对应如下的十六进制值： - A: 0x67452301 - B: 0xEFCDAB89 - C:0x98BADCFE - D: 0x103254764. 循环运算将填充后的消息划分为 N 个 512 位的块，每个块又被划分为 16 个 32 位的子块。

通过循环运算，分别对每个块进行如下的处理： - 将寄存器 A、B、C、D 的当前值分别赋给 a、b、c、d； - 使用子块的数据和一系列的位运算，更新寄存器中的值； - 将更新后的寄存器值赋给 A、B、C、D。

循环运算的次数等于子块的个数。

java中使用MD5进行计算摘要

java中使⽤MD5进⾏计算摘要java中使⽤MD5进⾏加密在各种应⽤系统的开发中，经常需要存储⽤户信息，很多地⽅都要存储⽤户密码，⽽将⽤户密码直接存储在服务器上显然是不安全的，本⽂简要介绍⼯作中常⽤的 MD5加密算法，希望能抛砖引⽟。

（⼀）消息摘要简介⼀个消息摘要就是⼀个数据块的数字指纹。

即对⼀个任意长度的⼀个数据块进⾏计算，产⽣⼀个唯⼀指印（对于SHA1是产⽣⼀个20字节的⼆进制数组）。

消息摘要是⼀种与消息认证码结合使⽤以确保消息完整性的技术。

主要使⽤单向散列函数算法，可⽤于检验消息的完整性，和通过散列密码直接以⽂本形式保存等，⽬前⼴泛使⽤的算法有MD4、MD5、SHA-1。

消息摘要有两个基本属性：1. 两个不同的报⽂难以⽣成相同的摘要2. 难以对指定的摘要⽣成⼀个报⽂，⽽可以由该报⽂反推算出该指定的摘要代表：美国国家标准技术研究所的SHA1和⿇省理⼯学院Ronald Rivest提出的MD5（⼆）对字符串进⾏加密/**利⽤MD5进⾏加密* @param str 待加密的字符串* @return加密后的字符串* @throws NoSuchAlgorithmException 没有这种产⽣消息摘要的算法* @throws UnsupportedEncodingException*/public String EncoderByMd5(String str) throws NoSuchAlgorithmException, UnsupportedEncodingException{//确定计算⽅法MessageDigest md5=MessageDigest.getInstance("MD5");BASE64Encoder base64en = new BASE64Encoder();//加密后的字符串String newstr=base64en.encode(md5.digest(str.getBytes("utf-8")));return newstr;}调⽤函数：String str="0123456789"System.out.println(EncoderByMd5(str));输出：eB5eJF1ptWaXm4bijSPyxw==（三）验证密码是否正确因为MD5是基于消息摘要原理的，消息摘要的基本特征就是很难根据摘要推算出消息报⽂，因此要验证密码是否正确，就必须对输⼊密码（消息报⽂）重新计算其摘要，和数据库中存储的摘要进⾏对⽐（即数据库中存储的其实为⽤户密码的摘要），若两个摘要相同，则说明密码正确，不同，则说明密码错误。

java传输json数据用md5加密过程

String md5Encrypted = HashEncoder.encode(HashAlgorithm.MD5, _sb.toString());
("encrypted: " + md5Encrypted); if(!md5Encrypted.equalsIgnoreCase(param.getSign())){
try { MessageDigest md = MessageDigest.getInstance("MD5"); md.update( content.getBytes() ); return getHashString( md ); } catch (NoSuchAlgorithmException e) { // TODO Auto-generated catch block e.printStackTrace(); } return null; }
JSONObject inputJson=JSONObject.parseObject(lines); reader.close();
System.out.println(md5Encrypt(encrapted)); return inputJson; } public String md5Encrypt(String content) {
//input BufferedReader reader = new BufferedReader(new InputStreamReader(httpURLConnection.getInputStream())); String lines =reader.readLine();//��ȡ��
}else{ this.response(response, JSONObject.toJSONString(new ResultObject(ResultCode.NULL_PARAM)));

JAVA中简单的MD5加密类（MD5Utils）

JAVA中简单的MD5加密类（MD5Utils）MD5加密分析：JDK API：获取对象的API：加密的API：1package cn.utils;23import java.security.MessageDigest;4import java.security.NoSuchAlgorithmException;56/**7 * @author CQY13 MD5加密⼯具类8*/9public class MD5Utils {1011/**12 * 获取MD5加密13 *14 * @param pwd15 * 需要加密的字符串16 * @return String字符串加密后的字符串17*/18public static String getPwd(String pwd) {19try {20// 创建加密对象21 MessageDigest digest = MessageDigest.getInstance("md5");2223// 调⽤加密对象的⽅法，加密的动作已经完成24byte[] bs = digest.digest(pwd.getBytes());25// 接下来，我们要对加密后的结果，进⾏优化，按照mysql的优化思路⾛26// mysql的优化思路：27// 第⼀步，将数据全部转换成正数：28 String hexString = "";29for (byte b : bs) {30// 第⼀步，将数据全部转换成正数：31// 解释：为什么采⽤b&25532/*33 * b:它本来是⼀个byte类型的数据(1个字节) 255：是⼀个int类型的数据(4个字节)34 * byte类型的数据与int类型的数据进⾏运算，会⾃动类型提升为int类型 eg: b: 1001 1100(原始数据)35 * 运算时： b: 0000 0000 0000 0000 0000 0000 1001 1100 255: 000036 * 0000 0000 0000 0000 0000 1111 1111 结果：0000 0000 0000 000037 * 0000 0000 1001 1100 此时的temp是⼀个int类型的整数38*/39int temp = b & 255;40// 第⼆步，将所有的数据转换成16进制的形式41// 注意：转换的时候注意if正数>=0&&<16，那么如果使⽤Integer.toHexString()，可能会造成缺少位数42// 因此，需要对temp进⾏判断43if (temp < 16 && temp >= 0) {44// ⼿动补上⼀个“0”45 hexString = hexString + "0" + Integer.toHexString(temp);46 } else {47 hexString = hexString + Integer.toHexString(temp);48 }49 }50return hexString;51 } catch (NoSuchAlgorithmException e) {52// TODO Auto-generated catch block53 e.printStackTrace();54 }55return "";56 }5758/**59 * @param args60*/61public static void main(String[] args) {62 String pwd = MD5Utils.getPwd("abc");63 System.out.println(pwd);64 }6566 }。

Java常见摘要算法——md5、sha1、sha256

Java常见摘要算法——md5、sha1、sha256⽬录实现sha256的代码和sha1的代码相似摘要算法简介摘要算法，也是加密算法的⼀种，还有另外⼀种叫法：指纹。

摘要算法就是对指定的数据进⾏⼀系列的计算，然后得出⼀个串内容，该内容就是该数据的摘要。

不同的数据产⽣的摘要是不同的，所以，可以⽤它来进⾏⼀些数据加密的⼯作：通过对⽐两个数据加密后的摘要是否相同，来判断这两个数据是否相同。

还可以⽤来保证数据的完整性，常见的软件在发布之后，会同时发布软件的md5和sha值，这个md5和sha值就是软件的摘要。

当⽤户将软件下载之后，然后去计算软件的摘要，如果计算所得的摘要和软件发布⽅提供的摘要相同，则证明下载的软件和发布的软件⼀模⼀样，否则，就是下载过程中数据（软件）被篡改了。

常见的摘要算法包括：md、sha这两类。

md包括md2、md4、md5；sha包括sha1、sha224、sha256、sha384、sha512。

md5 md摘要算法包括多种算法：分别是md2、md4、md5。

现在⼀般都是使⽤md5进⾏加密。

Java中实现md5加密，有三种⽅式：使⽤jdk内置的⽅法实现实现md5加密package cn.ganlixin.security;import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;import mons.codec.binary.Hex;public class JdkMD5 {public static void main(String[] args) throws NoSuchAlgorithmException {String plainText = "this is plain text";// 通过调⽤MessageDigest（数据摘要类）的getInstance()静态⽅法，传⼊加密算法的名称，获取数据摘要对象。

java MD5加密工具类

package com.person.util;import ng.reflect.Array;public class MD5 {/* 下面这些S11-S44实际上是\uFFFD \uFFFD4*4的矩阵，在原始的C实现中是\uFFFD#define 现的，这里把它们实现成为static final是表示了只读，切能在同一个进程空间内的多\uFFFD Instance 共\uFFFD*/static final int S11 = 7;static final int S12 = 12;static final int S13 = 17;static final int S14 = 22;static final int S21 = 5;static final int S22 = 9;static final int S23 = 14;static final int S24 = 20;static final int S31 = 4;static final int S32 = 11;static final int S33 = 16;static final int S34 = 23;static final int S41 = 6;static final int S42 = 10;static final int S43 = 15;static final int S44 = 21;static final byte[] PADDING = {-128, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};/* 面的三个成员是MD5计算过程中用到的3个核心数据，在原始的C实现\uFFFD 定义到MD5_CTX结构\uFFFD*/private long[] state = new long[4]; // state (ABCD)private long[] count = new long[2]; // number of bits, modulo 2^64 (lsb first)private byte[] buffer = new byte[64]; // input buffer/* digestHexStr MD5的唯\uFFFD \uFFFD个公共成员，是最新一次计算结果的\uFFFD 16 制ASCII表示.*/public String digestHexStr;/* digest,是最新一次计算结果的2进制内部表示，表\uFFFD128bit MD5\uFFFD.*/private byte[] digest = new byte[16];/*getMD5ofStr 类MD5\uFFFD 要的公共方法，入口参数是你想要进行MD5变换的字符串返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的．*/public String getMD5ofStr(String inbuf) {md5Init();md5Update(inbuf.getBytes(), inbuf.length());md5Final();digestHexStr = "";for (int i = 0; i < 16; i++) {digestHexStr += byteHEX(digest[i]);}return digestHexStr;}// 这是MD5这个类的标准构\uFFFD 数，JavaBean要求有一个public的并且没有参数的构\uFFFD \uFFFDpublic MD5() {md5Init();return;}/* md5Init 一个初始化函数，初始化核心变量，装入标准的幻数*/private void md5Init() {count[0] = 0L;count[1] = 0L;///* Load magic initialization constants.state[0] = 0x67452301L;state[1] = 0xefcdab89L;state[2] = 0x98badcfeL;state[3] = 0x10325476L;return;/* F, G, H ,I \uFFFD4 基本的MD5函数，在原始的MD5的C实现中，由于它们\uFFFD \uFFFD单的位运算，可能出于效率的\uFFFD 把它们实现成了宏，在java中，我们把它\uFFFD\uFFFD\uFFFD 现成了private方法，名字保持了原来C中的\uFFFD */private long F(long x, long y, long z) {return (x & y) | ((~x) & z);}private long G(long x, long y, long z) {return (x & z) | (y & (~z));}private long H(long x, long y, long z) {return x ^ y ^ z;}private long I(long x, long y, long z) {return y ^ (x | (~z));}/*FF,GG,HH II将调用F,G,H,I进行近一步变\uFFFDFF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.Rotation is separate from addition to prevent recomputation.*/private long FF(long a, long b, long c, long d, long x, long s,long ac) {a += F(b, c, d) + x + ac;a = ((int) a << s) | ((int) a >>> (32 - s));a += b;return a;}private long GG(long a, long b, long c, long d, long x, long s,long ac) {a += G(b, c, d) + x + ac;a = ((int) a << s) | ((int) a >>> (32 - s));a += b;return a;private long HH(long a, long b, long c, long d, long x, long s,long ac) {a += H(b, c, d) + x + ac;a = ((int) a << s) | ((int) a >>> (32 - s));a += b;return a;}private long II(long a, long b, long c, long d, long x, long s,long ac) {a += I(b, c, d) + x + ac;a = ((int) a << s) | ((int) a >>> (32 - s));a += b;return a;}/*md5Update MD5的主计算过程，inbuf是要变换的字节串，inputlen是长度，这个函数由getMD5ofStr调用，调用之前需要调用md5init，因此把它设计成private\uFFFD */private void md5Update(byte[] inbuf, int inputLen) {int i, index, partLen;byte[] block = new byte[64];index = (int) (count[0] >>> 3) & 0x3F;// /* Update number of bits */if ((count[0] += (inputLen << 3)) < (inputLen << 3))count[1]++;count[1] += (inputLen >>> 29);partLen = 64 - index;// Transform as many times as possible.if (inputLen >= partLen) {md5Memcpy(buffer, inbuf, index, 0, partLen);md5Transform(buffer);for (i = partLen; i + 63 < inputLen; i += 64) {md5Memcpy(block, inbuf, 0, i, 64);md5Transform(block);}index = 0;} elsei = 0;///* Buffer remaining input */md5Memcpy(buffer, inbuf, index, i, inputLen - i);}/*md5Final 理和填写输出结\uFFFD*/private void md5Final() {byte[] bits = new byte[8];int index, padLen;///* Save number of bits */Encode(bits, count, 8);///* Pad out to 56 mod 64.index = (int) (count[0] >>> 3) & 0x3f;padLen = (index < 56) ? (56 - index) : (120 - index);md5Update(PADDING, padLen);///* Append length (before padding) */md5Update(bits, 8);///* Store state in digest */Encode(digest, state, 16);}/* md5Memcpy 一个内部使用的byte数组的块拷贝函数，从input的inpos\uFFFD 把len 长度\uFFFD\uFFFD\uFFFD \uFFFD\uFFFD \uFFFD 字节拷贝到output的outpos位置\uFFFD \uFFFD */private void md5Memcpy(byte[] output, byte[] input,int outpos, int inpos, int len) {int i;for (i = 0; i < len; i++)output[outpos + i] = input[inpos + i];}/*md5Transform是MD5核心变换程序，有md5Update调用，block是分块的原始字节*/private void md5Transform(byte block[]) {long a = state[0], b = state[1], c = state[2], d = state[3];long[] x = new long[16];Decode(x, block, 64);/* Round 1 */a = FF(a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */d = FF(d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */c = FF(c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */b = FF(b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */a = FF(a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */d = FF(d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */c = FF(c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */b = FF(b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */a = FF(a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */d = FF(d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */c = FF(c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */b = FF(b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */a = FF(a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */d = FF(d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */c = FF(c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */b = FF(b, c, d, a, x[15], S14, 0x49b40821L); /* 16 *//* Round 2 */a = GG(a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */d = GG(d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */c = GG(c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */a = GG(a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */d = GG(d, a, b, c, x[10], S22, 0x2441453L); /* 22 */c = GG(c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */a = GG(a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */d = GG(d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */c = GG(c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */b = GG(b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */a = GG(a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */ c = GG(c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */ b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 *//* Round 3 */a = HH(a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */ d = HH(d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */ c = HH(c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */b = HH(b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */ a = HH(a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */ d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */ b = HH(b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */ a = HH(a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */d = HH(d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */ c = HH(c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */ b = HH(b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */ a = HH(a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */ d = HH(d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */ c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */ b = HH(b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 *//* Round 4 */a = II(a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */d = II(d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */c = II(c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */ b = II(b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */a = II(a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */ d = II(d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */c = II(c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */b = II(b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */a = II(a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */ c = II(c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */b = II(b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */ a = II(a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */d = II(d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */ c = II(c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */b = II(b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */state[0] += a;state[1] += b;state[2] += c;state[3] += d;}/*Encode把long数组按顺序拆成byte数组，因为java的long类型\uFFFD64bit ，只拆\uFFFD32bit 以适应原始C实现的用\uFFFD*/private void Encode(byte[] output, long[] input, int len) {int i, j;for (i = 0, j = 0; j < len; i++, j += 4) {output[j] = (byte) (input[i] & 0xffL);output[j + 1] = (byte) ((input[i] >>> 8) & 0xffL);output[j + 2] = (byte) ((input[i] >>> 16) & 0xffL);output[j + 3] = (byte) ((input[i] >>> 24) & 0xffL);}}/*Decode byte数组按顺序合成成long数组，因为java的long类型\uFFFD64bit ，只合成低32bit，高32bit清零，以适应原始C实现的用\uFFFD*/private void Decode(long[] output, byte[] input, int len) {int i, j;for (i = 0, j = 0; j < len; i++, j += 4)output[i] = b2iu(input[j]) |(b2iu(input[j + 1]) << 8) |(b2iu(input[j + 2]) << 16) |(b2iu(input[j + 3]) << 24);return;}/*b2iu 我写的\uFFFD 把byte按照不\uFFFD 正负号的原则的＂升位＂程序，因为java 没有unsigned运算*/public static long b2iu(byte b) {return b < 0 ? b & 0x7F + 128 : b;}/*byteHEX()，用来把\uFFFD byte类型的数转换成十六进制的ASCII表示\uFFFD\uFFFD因为java中的byte的toString无法实现这一点，我们又没有C语言中的sprintf(outbuf,"%02X",ib)*/public static String byteHEX(byte ib) {char[] Digit = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9','A', 'B', 'C', 'D', 'E', 'F'};char [] ob = new char[2];ob[0] = Digit[(ib >>> 4) & 0X0F];ob[1] = Digit[ib & 0X0F];String s = new String(ob);return s;}public static void main(String args[]) {MD5 m = new MD5();if (Array.getLength(args) == 0) { //如果没有参数，执行标准的Test SuiteSystem.out.println("MD5 Test suite:");System.out.println("MD5(\"\"):" + m.getMD5ofStr(""));System.out.println("MD5(\"a\"):" + m.getMD5ofStr("a"));System.out.println("MD5(\"abc\"):" + m.getMD5ofStr("abc"));System.out.println("MD5(\"message digest\"):" + m.getMD5ofStr("message digest"));System.out.println("MD5(\"abcdefghijklmnopqrstuvwxyz\"):" +m.getMD5ofStr("abcdefghijklmnopqrstuvwxyz"));System.out.println("MD5(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvw xyz0123456789\"):" +m.getMD5ofStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345 6789"));} elseSystem.out.println("MD5(" + args[0] + ")=" + m.getMD5ofStr(args[0]));}}。

Java的MD5盐值加密，Des加密解密和base64加密解密使用方法

Java的MD5盐值加密，Des加密解密和base64加密解密使⽤⽅法java⽀持md5盐值加密和des加密。

做项⽬时，某些模块添加加密功能可以提⾼⽤户个⼈信息安全性，防⽌信息泄露，其中des⽀持加密解密，MD5⽬前只⽀持加密（多⽤于⽤户登录密码验证，所以⽆需解密展⽰）。

⼀、MD5盐值加密1.在pom⽂件中导⼊相关jar包<dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-core</artifactId><version>1.3.2</version></dependency>2.编写MD5类import org.apache.shiro.crypto.hash.SimpleHash;/*** 加密⼯具类* @author john**/public class MD5 {//加密类型private static String hashName="MD5";//加密次数private static int hashNum=1024;//pwd是需要加密的字符，salt是盐值（⾃定义），hashNum是加密次数，次数越多越安全public static Object getMD5(String pwd,String salt){Object obj=new SimpleHash(hashName, pwd, salt, hashNum);return obj;}}加密⽅法是静态⽅法，使⽤时直接MD5.getMD5（pwd,salt）.toString();即可。

暂⽆解密⽅法。

⼆、Base64加密1.同样第⼀步也是导⼊base相关jar包<dependency><groupId>commons-codec</groupId><artifactId>commons-codec</artifactId><version>1.14</version></dependency>2.编写base64类import mons.codec.binary.Base64;public class Base64Utils {/*** 加密** @param plainText* @return*/public static String encodeStr(String plainText) {byte[] b = plainText.getBytes();Base64 base64 = new Base64();b = base64.encode(b);return new String(b);}/*** 解密** @param encodeStr* @return*/public static String decodeStr(String encodeStr) {byte[] b = encodeStr.getBytes();Base64 base64 = new Base64();b = base64.decode(b);return new String(b);}}加密解密的⽅法同样是静态⽅法，直接类名.⽅法名调⽤即可。

Java和JSMD5加密-附盐值加密demo

Java和JSMD5加密-附盐值加密demo JAVA和JS的MD5加密经过测试：字母和数据好使，中⽂不好使。

源码如下：*** 类MD5Util.java的实现描述：**/public class MD5Util {// 获得MD5摘要算法的 MessageDigest 对象private static MessageDigest _mdInst = null;private static char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};private static MessageDigest getMdInst() {if (_mdInst == null) {try {_mdInst = MessageDigest.getInstance("MD5");} catch (NoSuchAlgorithmException e) {e.printStackTrace();}}return _mdInst;}private MD5Util() {}/*** Returns a MessageDigest for the given <code>algorithm</code>.** @return An MD5 digest instance.* @throws RuntimeException when a {@link NoSuchAlgorithmException} is caught*/static MessageDigest getDigest() {try {return MessageDigest.getInstance("MD5");} catch (NoSuchAlgorithmException e) {throw new RuntimeException(e);}}/*** Calculates the MD5 digest and returns the value as a 16 element <code>byte[]</code>.** @param data Data to digest* @return MD5 digest*/public static byte[] md5(byte[] data) {return getDigest().digest(data);}/*** Calculates the MD5 digest and returns the value as a 16 element <code>byte[]</code>.** @param data Data to digest* @return MD5 digest*/public static byte[] md5(String data) {return md5(data.getBytes());}/*** Calculates the MD5 digest and returns the value as a 32 character hex string.** @param data Data to digest* @return MD5 digest as a hex string*//*public static String md5Hex(byte[] data) {return HexUtil.toHexString(md5(data));}*//*** Calculates the MD5 digest and returns the value as a 32 character hex string. ** @param data Data to digest* @return MD5 digest as a hex string*//*public static String md5Hex(String data) {return HexUtil.toHexString(md5(data));}*//*** 对密码字符串进⾏MD5加密** @param pass* @return*/public static String encoding(String pass) {if (pass == null) {return "";} else {StringBuffer buf = null;MessageDigest md5 = null;try {// 获取md5摘要md5 = MessageDigest.getInstance("MD5");// 指定utf-8编码md5.update(pass.getBytes("utf-8"));byte[] b = md5.digest();int i;buf = new StringBuffer("");for (int offset = 0; offset < b.length; offset++) {i = b[offset];if (i < 0) {i += 256;}if (i < 16) {buf.append("0");}// 产⽣16进制保存buf.append(Integer.toHexString(i));}} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (UnsupportedEncodingException e) {e.printStackTrace();}return buf.toString();}}public final static String encode(String s) {try {byte[] btInput = s.getBytes();// 使⽤指定的字节更新摘要getMdInst().update(btInput);// 获得密⽂byte[] md = getMdInst().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.js/** A JavaScript implementation of the RSA Data Security, Inc. MD5 Message* Digest Algorithm, as defined in RFC 1321.* Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet* Distributed under the BSD License* See /crypt/md5 for more info.*//** Configurable variables. You may need to tweak these to be compatible with* the server-side, but the defaults work in most cases.*/var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */var b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance */var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode *//** These are the functions you'll usually want to call* They take string arguments and return either hex or base-64 encoded strings*/function hex_md5(s){ return binl2hex(core_md5(str2binl(s), s.length * chrsz));} function b64_md5(s){ return binl2b64(core_md5(str2binl(s), s.length * chrsz));} function str_md5(s){ return binl2str(core_md5(str2binl(s), s.length * chrsz));} function hex_hmac_md5(key, data) { return binl2hex(core_hmac_md5(key, data)); } function b64_hmac_md5(key, data) { return binl2b64(core_hmac_md5(key, data)); } function str_hmac_md5(key, data) { return binl2str(core_hmac_md5(key, data)); } /** Perform a simple self-test to see if the VM is working*/function md5_vm_test(){return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";}/** Calculate the MD5 of an array of little-endian words, and a bit length*/function core_md5(x, len){/* append padding */x[len >> 5] |= 0x80 << ((len) % 32);x[(((len + 64) >>> 9) << 4) + 14] = len;var a = 1732584193;var b = -271733879;var c = -1732584194;var d = 271733878;for(var i = 0; i < x.length; i += 16){var olda = a;var oldb = b;var oldc = c;var oldd = d;a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);c = md5_ff(c, d, a, b, x[i+10], 17, -42063);b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);a = safe_add(a, olda);b = safe_add(b, oldb);c = safe_add(c, oldc);d = safe_add(d, oldd);}return Array(a, b, c, d);}/** These functions implement the four basic operations the algorithm uses. */function md5_cmn(q, a, b, x, s, t){return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);}function md5_ff(a, b, c, d, x, s, t){return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);}function md5_gg(a, b, c, d, x, s, t){return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);}function md5_hh(a, b, c, d, x, s, t){return md5_cmn(b ^ c ^ d, a, b, x, s, t);}function md5_ii(a, b, c, d, x, s, t){return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);}/** Calculate the HMAC-MD5, of a key and some data*/function core_hmac_md5(key, data){var bkey = str2binl(key);if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);var ipad = Array(16), opad = Array(16);for(var i = 0; i < 16; i++){ipad[i] = bkey[i] ^ 0x36363636;opad[i] = bkey[i] ^ 0x5C5C5C5C;}var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);return core_md5(opad.concat(hash), 512 + 128);}/** Add integers, wrapping at 2^32. This uses 16-bit operations internally* to work around bugs in some JS interpreters.*/function safe_add(x, y){var lsw = (x & 0xFFFF) + (y & 0xFFFF);var msw = (x >> 16) + (y >> 16) + (lsw >> 16);return (msw << 16) | (lsw & 0xFFFF);}/** Bitwise rotate a 32-bit number to the left.*/function bit_rol(num, cnt){return (num << cnt) | (num >>> (32 - cnt));}/** Convert a string to an array of little-endian words* If chrsz is ASCII, characters >255 have their hi-byte silently ignored.*/function str2binl(str){var bin = Array();var mask = (1 << chrsz) - 1;for(var i = 0; i < str.length * chrsz; i += chrsz)bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);return bin;}/** Convert an array of little-endian words to a string*/function binl2str(bin){var str = "";var mask = (1 << chrsz) - 1;for(var i = 0; i < bin.length * 32; i += chrsz)str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);return str;}/** Convert an array of little-endian words to a hex string.*/function binl2hex(binarray){var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";var str = "";for(var i = 0; i < binarray.length * 4; i++){str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 )) & 0xF);}return str;}/** Convert an array of little-endian words to a base-64 string*/function binl2b64(binarray){var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; var str = "";for(var i = 0; i < binarray.length * 4; i += 3){var triplet = (((binarray[i >> 2] >> 8 * ( i %4)) & 0xFF) << 16)| (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )| ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);for(var j = 0; j < 4; j++){if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);}}return str;}测试DEMO类(⼯具类加密后转成⼩写)：public class Test {public static void main(String[] args) throws Exception {String source = "123AB";String salt = "asdklsakjfdlsadjfl";System.out.printf("source is %s,result is %s",salt+source,MD5Util.encode(salt+source).toLowerCase()); }}运⾏结果：source is asdklsakjfdlsadjfl123AB,result is d5976dad58ad32000e3867f0601e236c。