信息摘要算法-RipeMD以及HmacRipeMD算法

2016-05-14 17:17:02

除了MD、SHA和MAC三大主流信息摘要算法之外，还有一些不常见的消息摘要算法。包括RipeMD系列、Tiger、Whirlpool和Gost3411算法。同时，RipeMD算法和MAC算法系列相结合，有产生了HmacRipeMD128和HmacRipeMD160两种...


                    
一、简述
  除了MD、SHA和MAC三大主流信息摘要算法之外，还有一些不常见的消息摘要算法。包括RipeMD系列、Tiger、Whirlpool和Gost3411算法。同时，RipeMD算法和MAC算法系列相结合，有产生了HmacRipeMD128和HmacRipeMD160两种算法。
  针对这些算法进行简单介绍
  1、RipeMD算法：针对MD4和MD5算法缺陷分析提出的算法。这些算法主要是针对摘要值得长度进行了区分
  2、Tiger算法：号称最快的Hash算法，专门针对64为机器做优化了。其消息长度为192位
  3、Whirlpool：被列入iso标准。与AES加密标准使用了相同的转化技术，极大提高了安全性，被称为最安全的摘要算法，长度为512位
  4、Gost3411：信息摘要长度为256位
  这些算法的实现java6都没提供。这里BouncyCastle进行了支持。其实这些算法的调用都一个样，就是换一个调用的名字而已。
 
二、RipeMD算法和HmacRipeMD算法系列
 
算法 摘要长度 备注
RipeMD128 128 BouncyCastle实现
RipeMD160 160 BouncyCastle实现
RipeMD256 256 BouncyCastle实现
RipeMD320 320 BouncyCastle实现
HmacRipeMD128 128 BouncyCastle实现
HmacRipeMD160 160 BouncyCastle实现
　 　 　
三、RipeMD系列算法举例（注意他们生成的摘要信息的长度）
package com.ca.test;
import java.security.MessageDigest;
import java.security.Security;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;
/**
 * RipeMD系列消息摘要组件
 * 这个算法暂时只有BouncyCastle支持
 * @author kongqz
 * */
public class RipeMDCoder {
RipeMD128消息摘要处理///
	/**
	 * RipeMD128消息摘要
	 * @param data 待处理的消息摘要数据
	 * @return byte[] 消息摘要
	 * */
	public static byte[] encodeRipeMD128(byte[] data) throws Exception{
		//加入BouncyCastleProvider的支持
		Security.addProvider(new BouncyCastleProvider());
		//初始化MessageDigest
		MessageDigest md=MessageDigest.getInstance("RipeMD128");
		//执行消息摘要
		return md.digest(data);
		
	}
	/**
	 * RipeMD128Hex消息摘要
	 * @param data 待处理的消息摘要数据
	 * @return String 消息摘要
	 * **/
	public static String encodeRipeMD128Hex(byte[] data) throws Exception{
		//执行消息摘要
		byte[] b=encodeRipeMD128(data);
		//做十六进制的编码处理
		return new String(Hex.encode(b));
	}
	
RipeMD160消息摘要处理///
	/**
	 * RipeMD160消息摘要
	 * @param data 待处理的消息摘要数据
	 * @return byte[] 消息摘要
	 * */
	public static byte[] encodeRipeMD160(byte[] data) throws Exception{
		//加入BouncyCastleProvider的支持
		Security.addProvider(new BouncyCastleProvider());
		//初始化MessageDigest
		MessageDigest md=MessageDigest.getInstance("RipeMD160");
		//执行消息摘要
		return md.digest(data);
		
	}
	/**
	 * RipeMD160Hex消息摘要
	 * @param data 待处理的消息摘要数据
	 * @return String 消息摘要
	 * **/
	public static String encodeRipeMD160Hex(byte[] data) throws Exception{
		//执行消息摘要
		byte[] b=encodeRipeMD160(data);
		//做十六进制的编码处理
		return new String(Hex.encode(b));
	}
RipeMD256消息摘要处理///
	/**
	 * RipeMD256消息摘要
	 * @param data 待处理的消息摘要数据
	 * @return byte[] 消息摘要
	 * */
	public static byte[] encodeRipeMD256(byte[] data) throws Exception{
		//加入BouncyCastleProvider的支持
		Security.addProvider(new BouncyCastleProvider());
		//初始化MessageDigest
		MessageDigest md=MessageDigest.getInstance("RipeMD256");
		//执行消息摘要
		return md.digest(data);
		
	}
	/**
	 * RipeMD256Hex消息摘要
	 * @param data 待处理的消息摘要数据
	 * @return String 消息摘要
	 * **/
	public static String encodeRipeMD256Hex(byte[] data) throws Exception{
		//执行消息摘要
		byte[] b=encodeRipeMD256(data);
		//做十六进制的编码处理
		return new String(Hex.encode(b));
	}
	
RipeMD320消息摘要处理///
	/**
	 * RipeMD320消息摘要
	 * @param data 待处理的消息摘要数据
	 * @return byte[] 消息摘要
	 * */
	public static byte[] encodeRipeMD320(byte[] data) throws Exception{
		//加入BouncyCastleProvider的支持
		Security.addProvider(new BouncyCastleProvider());
		//初始化MessageDigest
		MessageDigest md=MessageDigest.getInstance("RipeMD320");
		//执行消息摘要
		return md.digest(data);
		
	}
	/**
	 * RipeMD320Hex消息摘要
	 * @param data 待处理的消息摘要数据
	 * @return String 消息摘要
	 * **/
	public static String encodeRipeMD320Hex(byte[] data) throws Exception{
		//执行消息摘要
		byte[] b=encodeRipeMD320(data);
		//做十六进制的编码处理
		return new String(Hex.encode(b));
	}
///HmacRipeMD-BouncyCastle支持的实现//
	/**
	 * 初始化HmacRipeMD128的密钥
	 * @return byte[] 密钥
	 * */
	public static byte[] initHmacRipeMD128Key() throws Exception{
		
		//加入BouncyCastleProvider的支持
		Security.addProvider(new BouncyCastleProvider());
		//初始化KeyGenerator
		KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacRipeMD128");
		//产生密钥
		SecretKey secretKey=keyGenerator.generateKey();
		//获取密钥
		return secretKey.getEncoded();
	}
	/**
	 * HmacRipeMD128消息摘要
	 * @param data 待做摘要处理的数据
	 * @param key 密钥
	 * @return  byte[] 消息摘要
	 * */
	public static byte[] encodeHmacRipeMD128(byte[] data,byte[] key) throws Exception{
		//加入BouncyCastleProvider的支持
		Security.addProvider(new BouncyCastleProvider());
		//还原密钥，因为密钥是以byte形式为消息传递算法所拥有
		SecretKey secretKey=new SecretKeySpec(key,"HmacRipeMD128");
		//实例化Mac
		Mac mac=Mac.getInstance(secretKey.getAlgorithm());
		//初始化Mac
		mac.init(secretKey);
		//执行消息摘要处理
		return mac.doFinal(data);
	}
	/**
	 * HmacRipeMD128Hex消息摘要
	 * @param data 待做消息摘要处理的数据
	 * @param String 密钥
	 * @return byte[] 消息摘要
	 * */
	public static String encodeHmacRipeMD128Hex(byte[] data,byte[] key) throws Exception{
		//执行消息摘要处理
		byte[] b=encodeHmacRipeMD128(data,key);
		//做十六进制转换
		return new String(Hex.encode(b));
	}
	
///HmacRipeMD-BouncyCastle支持的实现//
	/**
	 * 初始化HmacRipeMD160的密钥
	 * @return byte[] 密钥
	 * */
	public static byte[] initHmacRipeMD160Key() throws Exception{
		
		//加入BouncyCastleProvider的支持
		Security.addProvider(new BouncyCastleProvider());
		//初始化KeyGenerator
		KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacRipeMD160");
		//产生密钥
		SecretKey secretKey=keyGenerator.generateKey();
		//获取密钥
		return secretKey.getEncoded();
	}
	/**
	 * HmacRipeMD160消息摘要
	 * @param data 待做摘要处理的数据
	 * @param key 密钥
	 * @return  byte[] 消息摘要
	 * */
	public static byte[] encodeHmacRipeMD160(byte[] data,byte[] key) throws Exception{
		//加入BouncyCastleProvider的支持
		Security.addProvider(new BouncyCastleProvider());
		//还原密钥，因为密钥是以byte形式为消息传递算法所拥有
		SecretKey secretKey=new SecretKeySpec(key,"HmacRipeMD160");
		//实例化Mac
		Mac mac=Mac.getInstance(secretKey.getAlgorithm());
		//初始化Mac
		mac.init(secretKey);
		//执行消息摘要处理
		return mac.doFinal(data);
	}
	/**
	 * HmacRipeMD160Hex消息摘要
	 * @param data 待做消息摘要处理的数据
	 * @param String 密钥
	 * @return byte[] 消息摘要
	 * */
	public static String encodeHmacRipeMD160Hex(byte[] data,byte[] key) throws Exception{
		//执行消息摘要处理
		byte[] b=encodeHmacRipeMD160(data,key);
		//做十六进制转换
		return new String(Hex.encode(b));
	}
	/***
	 * 
	 * 进行消息摘要长度的处理
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		
		String str="RIPEMD消息摘要";
		System.out.println("原文："+str);
		byte[] data1=RipeMDCoder.encodeRipeMD128(str.getBytes());
		String data1hex=RipeMDCoder.encodeRipeMD128Hex(str.getBytes());
		System.out.println("RipeMD128的消息摘要算法值："+data1.toString());
		System.out.println("RipeMD128的十六进制消息摘要算法值："+data1hex);
		System.out.println();
		
		byte[] data2=RipeMDCoder.encodeRipeMD160(str.getBytes());
		String data2hex=RipeMDCoder.encodeRipeMD160Hex(str.getBytes());
		System.out.println("RipeMD160的消息摘要算法值："+data2.toString());
		System.out.println("RipeMD160的十六进制消息摘要算法值："+data2hex);
		System.out.println();
		
		byte[] data3=RipeMDCoder.encodeRipeMD256(str.getBytes());
		String data3hex=RipeMDCoder.encodeRipeMD256Hex(str.getBytes());
		System.out.println("RipeMD256的消息摘要算法值："+data3.toString());
		System.out.println("RipeMD256的十六进制消息摘要算法值："+data3hex);
		System.out.println();	
		
		byte[] data4=RipeMDCoder.encodeRipeMD320(str.getBytes());
		String data4hex=RipeMDCoder.encodeRipeMD320Hex(str.getBytes());
		System.out.println("RipeMD320的消息摘要算法值："+data4.toString());
		System.out.println("RipeMD320的十六进制消息摘要算法值："+data4hex);
		System.out.println();	
		
		System.out.println("================以下的算法支持是HmacRipeMD系列，现阶段只有BouncyCastle支持=======================");
		//初始化密钥
		byte[] key5=RipeMDCoder.initHmacRipeMD128Key();
		//获取摘要信息
		byte[] data5=RipeMDCoder.encodeHmacRipeMD128(str.getBytes(), key5);
		String datahex5=RipeMDCoder.encodeHmacRipeMD128Hex(str.getBytes(), key5);
		System.out.println("Bouncycastle HmacRipeMD128的密钥:"+key5.toString());
		System.out.println("Bouncycastle HmacRipeMD128算法摘要："+data5.toString());
		System.out.println("Bouncycastle HmacRipeMD128Hex算法摘要："+datahex5.toString());
		System.out.println();
		
		//初始化密钥
		byte[] key6=RipeMDCoder.initHmacRipeMD160Key();
		//获取摘要信息
		byte[] data6=RipeMDCoder.encodeHmacRipeMD160(str.getBytes(), key6);
		String datahex6=RipeMDCoder.encodeHmacRipeMD160Hex(str.getBytes(), key6);
		System.out.println("Bouncycastle HmacRipeMD160的密钥:"+key6.toString());
		System.out.println("Bouncycastle HmacRipeMD160算法摘要："+data6.toString());
		System.out.println("Bouncycastle HmacRipeMD160Hex算法摘要："+datahex6.toString());
		System.out.println();
	}
}
控制台输出结果：
原文：RIPEMD消息摘要
RipeMD128的消息摘要算法值：[B@253498
RipeMD128的十六进制消息摘要算法值：33fe1de4407218a6e530a91271fb775a
RipeMD160的消息摘要算法值：[B@17172ea
RipeMD160的十六进制消息摘要算法值：e35a41f8872f35d4e32da2d9189bb85a29111ccc
RipeMD256的消息摘要算法值：[B@b169f8
RipeMD256的十六进制消息摘要算法值：8ce5cfd043d5f591c5a8f5c1bbe61940995c6c49abe18045bafb77a14e12abbd
RipeMD320的消息摘要算法值：[B@b0f13d
RipeMD320的十六进制消息摘要算法值：086a2de72a828297a37dd5467d5ad2ad506cd259b9015f2aac216664489c408f8b98b80a71f4c3f9
================以下的算法支持是HmacRipeMD系列，现阶段只有BouncyCastle支持=======================
Bouncycastle HmacRipeMD128的密钥:[B@ab95e6
Bouncycastle HmacRipeMD128算法摘要：[B@fe64b9
Bouncycastle HmacRipeMD128Hex算法摘要：ff5fa29b67e366558957200f2355b35a
Bouncycastle HmacRipeMD160的密钥:[B@13582d
Bouncycastle HmacRipeMD160算法摘要：[B@21b6d
Bouncycastle HmacRipeMD160Hex算法摘要：74285f4e6e365d1f2661b93382f32e1d55c92cb9
四、总结
1、HmacRipeMD消息摘要的长度与相应的摘要算法的摘要长度相同：HmacRipeMD128与RipeMD128相对应，消息摘要长度都是32个字符的16进制串。HmacRipeMD160与RipeMD160相对应，消息摘要长度都是40个字符的16进制串。
2、BouncyCastle不仅仅提供了HmacRipeMD算法的实现，还提供了HmacTiger算法的实现。实现方式与上边的代码清单相似

收起

展开全文

java ripemd160,JAVA加解密9-信息摘要算法-RipeMD以及HmacRipeMD算法

2021-03-25 09:44:46

一、简述除了MD、SHA和MAC三大主流信息摘要算法之外，还有一些不常见的消息摘要算法。包括RipeMD系列、Tiger、Whirlpool和Gost3411算法。同时，RipeMD算法和MAC算法系列相结合，有产生了HmacRipeMD128和HmacRipeMD...

一、简述
除了MD、SHA和MAC三大主流信息摘要算法之外，还有一些不常见的消息摘要算法。包括RipeMD系列、Tiger、Whirlpool和Gost3411算法。同时，RipeMD算法和MAC算法系列相结合，有产生了HmacRipeMD128和HmacRipeMD160两种算法。
针对这些算法进行简单介绍
1.RipeMD算法：针对MD4和MD5算法缺陷分析提出的算法。这些算法主要是针对摘要值得长度进行了区分
2.Tiger算法：号称最快的Hash算法，专门针对64为机器做优化了。其消息长度为192位
3.Whirlpool：被列入iso标准。与AES加密标准使用了相同的转化技术，极大提高了安全性，被称为最安全的摘要算法，长度为512位
4.Gost3411：信息摘要长度为256位
这些算法的实现java6都没提供。这里BouncyCastle进行了支持。其实这些算法的调用都一个样，就是换一个调用的名字而已。
二、RipeMD算法和HmacRipeMD算法系列
算法
摘要长度
备注
RipeMD128
128
BouncyCastle实现
RipeMD160
160
BouncyCastle实现
RipeMD256
256
BouncyCastle实现
RipeMD320
320
BouncyCastle实现
HmacRipeMD128
128
BouncyCastle实现
HmacRipeMD160
160
BouncyCastle实现
三、RipeMD系列算法举例(注意他们生成的摘要信息的长度)
package com.ca.test;
import java.security.MessageDigest;
import java.security.Security;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;
/**
* RipeMD系列消息摘要组件
* 这个算法暂时只有BouncyCastle支持
* @author kongqz
* */
public class RipeMDCoder {
RipeMD128消息摘要处理///
/**
* RipeMD128消息摘要
* @param data 待处理的消息摘要数据
* @return byte[] 消息摘要
* */
public static byte[] encodeRipeMD128(byte[] data) throws Exception{
//加入BouncyCastleProvider的支持
Security.addProvider(new BouncyCastleProvider());
//初始化MessageDigest
MessageDigest md=MessageDigest.getInstance("RipeMD128");
//执行消息摘要
return md.digest(data);
}
/**
* RipeMD128Hex消息摘要
* @param data 待处理的消息摘要数据
* @return String 消息摘要
* **/
public static String encodeRipeMD128Hex(byte[] data) throws Exception{
//执行消息摘要
byte[] b=encodeRipeMD128(data);
//做十六进制的编码处理
return new String(Hex.encode(b));
}
RipeMD160消息摘要处理///
/**
* RipeMD160消息摘要
* @param data 待处理的消息摘要数据
* @return byte[] 消息摘要
* */
public static byte[] encodeRipeMD160(byte[] data) throws Exception{
//加入BouncyCastleProvider的支持
Security.addProvider(new BouncyCastleProvider());
//初始化MessageDigest
MessageDigest md=MessageDigest.getInstance("RipeMD160");
//执行消息摘要
return md.digest(data);
}
/**
* RipeMD160Hex消息摘要
* @param data 待处理的消息摘要数据
* @return String 消息摘要
* **/
public static String encodeRipeMD160Hex(byte[] data) throws Exception{
//执行消息摘要
byte[] b=encodeRipeMD160(data);
//做十六进制的编码处理
return new String(Hex.encode(b));
}
RipeMD256消息摘要处理///
/**
* RipeMD256消息摘要
* @param data 待处理的消息摘要数据
* @return byte[] 消息摘要
* */
public static byte[] encodeRipeMD256(byte[] data) throws Exception{
//加入BouncyCastleProvider的支持
Security.addProvider(new BouncyCastleProvider());
//初始化MessageDigest
MessageDigest md=MessageDigest.getInstance("RipeMD256");
//执行消息摘要
return md.digest(data);
}
/**
* RipeMD256Hex消息摘要
* @param data 待处理的消息摘要数据
* @return String 消息摘要
* **/
public static String encodeRipeMD256Hex(byte[] data) throws Exception{
//执行消息摘要
byte[] b=encodeRipeMD256(data);
//做十六进制的编码处理
return new String(Hex.encode(b));
}
RipeMD320消息摘要处理///
/**
* RipeMD320消息摘要
* @param data 待处理的消息摘要数据
* @return byte[] 消息摘要
* */
public static byte[] encodeRipeMD320(byte[] data) throws Exception{
//加入BouncyCastleProvider的支持
Security.addProvider(new BouncyCastleProvider());
//初始化MessageDigest
MessageDigest md=MessageDigest.getInstance("RipeMD320");
//执行消息摘要
return md.digest(data);
}
/**
* RipeMD320Hex消息摘要
* @param data 待处理的消息摘要数据
* @return String 消息摘要
* **/
public static String encodeRipeMD320Hex(byte[] data) throws Exception{
//执行消息摘要
byte[] b=encodeRipeMD320(data);
//做十六进制的编码处理
return new String(Hex.encode(b));
}
///HmacRipeMD-BouncyCastle支持的实现//
/**
* 初始化HmacRipeMD128的密钥
* @return byte[] 密钥
* */
public static byte[] initHmacRipeMD128Key() throws Exception{
//加入BouncyCastleProvider的支持
Security.addProvider(new BouncyCastleProvider());
//初始化KeyGenerator
KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacRipeMD128");
//产生密钥
SecretKey secretKey=keyGenerator.generateKey();
//获取密钥
return secretKey.getEncoded();
}
/**
* HmacRipeMD128消息摘要
* @param data 待做摘要处理的数据
* @param key 密钥
* @return  byte[] 消息摘要
* */
public static byte[] encodeHmacRipeMD128(byte[] data,byte[] key) throws Exception{
//加入BouncyCastleProvider的支持
Security.addProvider(new BouncyCastleProvider());
//还原密钥，因为密钥是以byte形式为消息传递算法所拥有
SecretKey secretKey=new SecretKeySpec(key,"HmacRipeMD128");
//实例化Mac
Mac mac=Mac.getInstance(secretKey.getAlgorithm());
//初始化Mac
mac.init(secretKey);
//执行消息摘要处理
return mac.doFinal(data);
}
/**
* HmacRipeMD128Hex消息摘要
* @param data 待做消息摘要处理的数据
* @param String 密钥
* @return byte[] 消息摘要
* */
public static String encodeHmacRipeMD128Hex(byte[] data,byte[] key) throws Exception{
//执行消息摘要处理
byte[] b=encodeHmacRipeMD128(data,key);
//做十六进制转换
return new String(Hex.encode(b));
}
///HmacRipeMD-BouncyCastle支持的实现//
/**
* 初始化HmacRipeMD160的密钥
* @return byte[] 密钥
* */
public static byte[] initHmacRipeMD160Key() throws Exception{
//加入BouncyCastleProvider的支持
Security.addProvider(new BouncyCastleProvider());
//初始化KeyGenerator
KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacRipeMD160");
//产生密钥
SecretKey secretKey=keyGenerator.generateKey();
//获取密钥
return secretKey.getEncoded();
}
/**
* HmacRipeMD160消息摘要
* @param data 待做摘要处理的数据
* @param key 密钥
* @return  byte[] 消息摘要
* */
public static byte[] encodeHmacRipeMD160(byte[] data,byte[] key) throws Exception{
//加入BouncyCastleProvider的支持
Security.addProvider(new BouncyCastleProvider());
//还原密钥，因为密钥是以byte形式为消息传递算法所拥有
SecretKey secretKey=new SecretKeySpec(key,"HmacRipeMD160");
//实例化Mac
Mac mac=Mac.getInstance(secretKey.getAlgorithm());
//初始化Mac
mac.init(secretKey);
//执行消息摘要处理
return mac.doFinal(data);
}
/**
* HmacRipeMD160Hex消息摘要
* @param data 待做消息摘要处理的数据
* @param String 密钥
* @return byte[] 消息摘要
* */
public static String encodeHmacRipeMD160Hex(byte[] data,byte[] key) throws Exception{
//执行消息摘要处理
byte[] b=encodeHmacRipeMD160(data,key);
//做十六进制转换
return new String(Hex.encode(b));
}
/***
*
* 进行消息摘要长度的处理
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
String str="RIPEMD消息摘要";
System.out.println("原文："+str);
byte[] data1=RipeMDCoder.encodeRipeMD128(str.getBytes());
String data1hex=RipeMDCoder.encodeRipeMD128Hex(str.getBytes());
System.out.println("RipeMD128的消息摘要算法值："+data1.toString());
System.out.println("RipeMD128的十六进制消息摘要算法值："+data1hex);
System.out.println();
byte[] data2=RipeMDCoder.encodeRipeMD160(str.getBytes());
String data2hex=RipeMDCoder.encodeRipeMD160Hex(str.getBytes());
System.out.println("RipeMD160的消息摘要算法值："+data2.toString());
System.out.println("RipeMD160的十六进制消息摘要算法值："+data2hex);
System.out.println();
byte[] data3=RipeMDCoder.encodeRipeMD256(str.getBytes());
String data3hex=RipeMDCoder.encodeRipeMD256Hex(str.getBytes());
System.out.println("RipeMD256的消息摘要算法值："+data3.toString());
System.out.println("RipeMD256的十六进制消息摘要算法值："+data3hex);
System.out.println();
byte[] data4=RipeMDCoder.encodeRipeMD320(str.getBytes());
String data4hex=RipeMDCoder.encodeRipeMD320Hex(str.getBytes());
System.out.println("RipeMD320的消息摘要算法值："+data4.toString());
System.out.println("RipeMD320的十六进制消息摘要算法值："+data4hex);
System.out.println();
System.out.println("================以下的算法支持是HmacRipeMD系列，现阶段只有BouncyCastle支持=======================");
//初始化密钥
byte[] key5=RipeMDCoder.initHmacRipeMD128Key();
//获取摘要信息
byte[] data5=RipeMDCoder.encodeHmacRipeMD128(str.getBytes(), key5);
String datahex5=RipeMDCoder.encodeHmacRipeMD128Hex(str.getBytes(), key5);
System.out.println("Bouncycastle HmacRipeMD128的密钥:"+key5.toString());
System.out.println("Bouncycastle HmacRipeMD128算法摘要："+data5.toString());
System.out.println("Bouncycastle HmacRipeMD128Hex算法摘要："+datahex5.toString());
System.out.println();
//初始化密钥
byte[] key6=RipeMDCoder.initHmacRipeMD160Key();
//获取摘要信息
byte[] data6=RipeMDCoder.encodeHmacRipeMD160(str.getBytes(), key6);
String datahex6=RipeMDCoder.encodeHmacRipeMD160Hex(str.getBytes(), key6);
System.out.println("Bouncycastle HmacRipeMD160的密钥:"+key6.toString());
System.out.println("Bouncycastle HmacRipeMD160算法摘要："+data6.toString());
System.out.println("Bouncycastle HmacRipeMD160Hex算法摘要："+datahex6.toString());
System.out.println();
}
}
控制台输出结果：
原文：RIPEMD消息摘要
RipeMD128的消息摘要算法值：[B@253498
RipeMD128的十六进制消息摘要算法值：33fe1de4407218a6e530a91271fb775a
RipeMD160的消息摘要算法值：[B@17172ea
RipeMD160的十六进制消息摘要算法值：e35a41f8872f35d4e32da2d9189bb85a29111ccc
RipeMD256的消息摘要算法值：[B@b169f8
RipeMD256的十六进制消息摘要算法值：8ce5cfd043d5f591c5a8f5c1bbe61940995c6c49abe18045bafb77a14e12abbd
RipeMD320的消息摘要算法值：[B@b0f13d
RipeMD320的十六进制消息摘要算法值：086a2de72a828297a37dd5467d5ad2ad506cd259b9015f2aac216664489c408f8b98b80a71f4c3f9
================以下的算法支持是HmacRipeMD系列，现阶段只有BouncyCastle支持=======================
Bouncycastle HmacRipeMD128的密钥:[B@ab95e6
Bouncycastle HmacRipeMD128算法摘要：[B@fe64b9
Bouncycastle HmacRipeMD128Hex算法摘要：ff5fa29b67e366558957200f2355b35a
Bouncycastle HmacRipeMD160的密钥:[B@13582d
Bouncycastle HmacRipeMD160算法摘要：[B@21b6d
Bouncycastle HmacRipeMD160Hex算法摘要：74285f4e6e365d1f2661b93382f32e1d55c92cb9
四、总结
1、HmacRipeMD消息摘要的长度与相应的摘要算法的摘要长度相同：HmacRipeMD128与RipeMD128相对应，消息摘要长度都是32个字符的16进制串。HmacRipeMD160与RipeMD160相对应，消息摘要长度都是40个字符的16进制串。
2、BouncyCastle不仅仅提供了HmacRipeMD算法的实现，还提供了HmacTiger算法的实现。实现方式与上边的代码清单相似

收起

展开全文

[软考考点解析]软件设计师--常用加密与摘要算法

2020-10-07 22:31:23

加密与摘要算法常见的分3类：对称加密算法、非对称加密算法、消息摘要算法。 2.1 对称加密算法只有一个密钥，加解密使用同一个密钥，加密速度快。 常见的有：DES/IDEA/TDEA/AES/RC2/RC4。 2.2 非对称加密算法有2个...

1. 题目

以下加密算法中，适合对大量的明文消息进行加密传输的是____。
A RSA
B SHA-1
C MD5
D RC5

2. 理论

加密与摘要算法常见的分3类：对称加密算法、非对称加密算法、消息摘要算法。

2.1 对称加密算法

只有一个密钥，加解密使用同一个密钥，加密速度快。

常见的有：DES/IDEA/TDEA/AES/RC2/RC4。

2.2 非对称加密算法

有2个密钥，一个公钥，一个私钥，一个用来加密，一个用来解密。加密速度较慢。

常见的有RSA。

2.3 消息摘要算法

其实就是对加密内容生成一个摘要，注意摘要不是加密，无法解密，仅能用来标识原内容。

常见的有：MD5/SHA。

3. 解析

A是非对称，速度慢，B/C是摘要不是加密，选D。

收起

展开全文

加密

插装动态勾选一些常见自吐算法

2020-12-22 19:23:20

消息摘要算法 md算法家族 md2，md4，md5 sha算法家族 SHA-1，SHA-256，SHA- Mac算法家族 HmacMd5，HmacSHA256 热插拔动态调试的原理在app的加密中，绝大多数的加密方式都会采用上述的常用加密算法，有时候有的小型...

常用的加密算法
对称加密算法
AES，DES，3DES
非对称加密算法
RSA
消息摘要算法
md算法家族 md2，md4，md5
sha算法家族 SHA-1，SHA-256，SHA-
Mac算法家族 HmacMd5，HmacSHA256
热插拔动态调试的原理
在app的加密中，绝大多数的加密方式都会采用上述的常用加密算法，有时候有的小型APP通过一些加固处理，很难反编译出来，那么对他上面的加密算法进行hook，可以很好的解决这个问题。
在某个app运行的过程中，hook到某个加密算法后，将调用这个加密方法的入参打印出来，然后再将返回结果打印处理；又知道是采用哪个加密算法。这样很容易就能分析出加密逻辑。
Java层的算法的代码实现步骤：1.初始化一个key，2.ciper确定一个加密模式(getInstace， init)，3. 执行加密 dofinal
热插拔动态调试的js代码
如下的js代码来源 https://blog.csdn.net/weixin_34365417/article/details/93088342 ，原来的代码时python的，我将python代码提取出来，改为纯的js代码。
function showStacks() {
    Java.perform(function () {
        console.log(Java.use("android.util.Log").getStackTraceString(Java.use("java.lang.Exception").$new()));
    });
}

(function () {
    var base64EncodeChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
        base64DecodeChars = new Array((-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), (-1), 62, (-1), (-1), (-1), 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, (-1), (-1), (-1), (-1), (-1), (-1), (-1), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, (-1), (-1), (-1), (-1), (-1), (-1), 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, (-1), (-1), (-1), (-1), (-1));
    this.stringToBase64 = function (e) {
        var r, a, c, h, o, t;
        for (c = e.length, a = 0, r = ''; a < c;) {
            if (h = 255 & e.charCodeAt(a++), a == c) {
                r += base64EncodeChars.charAt(h >> 2),
                    r += base64EncodeChars.charAt((3 & h) << 4),
                    r += '==';
                break
            }
            if (o = e.charCodeAt(a++), a == c) {
                r += base64EncodeChars.charAt(h >> 2),
                    r += base64EncodeChars.charAt((3 & h) << 4 | (240 & o) >> 4),
                    r += base64EncodeChars.charAt((15 & o) << 2),
                    r += '=';
                break
            }
            t = e.charCodeAt(a++),
                r += base64EncodeChars.charAt(h >> 2),
                r += base64EncodeChars.charAt((3 & h) << 4 | (240 & o) >> 4),
                r += base64EncodeChars.charAt((15 & o) << 2 | (192 & t) >> 6),
                r += base64EncodeChars.charAt(63 & t)
        }
        return r
    }
    this.base64ToString = function (e) {
        var r, a, c, h, o, t, d;
        for (t = e.length, o = 0, d = ''; o < t;) {
            do
                r = base64DecodeChars[255 & e.charCodeAt(o++)];
            while (o < t && r == -1);
            if (r == -1)
                break;
            do
                a = base64DecodeChars[255 & e.charCodeAt(o++)];
            while (o < t && a == -1);
            if (a == -1)
                break;
            d += String.fromCharCode(r << 2 | (48 & a) >> 4);
            do {
                if (c = 255 & e.charCodeAt(o++), 61 == c)
                    return d;
                c = base64DecodeChars[c]
            } while (o < t && c == -1);
            if (c == -1)
                break;
            d += String.fromCharCode((15 & a) << 4 | (60 & c) >> 2);
            do {
                if (h = 255 & e.charCodeAt(o++), 61 == h)
                    return d;
                h = base64DecodeChars[h]
            } while (o < t && h == -1);
            if (h == -1)
                break;
            d += String.fromCharCode((3 & c) << 6 | h)
        }
        return d
    }
    this.hexToBase64 = function (str) {
        return base64Encode(String.fromCharCode.apply(null, str.replace(/\r|\n/g, "").replace(/([\da-fA-F]{2}) ?/g, "0x$1 ").replace(/ +$/, "").split(" ")));
    }
    this.base64ToHex = function (str) {
        for (var i = 0, bin = base64Decode(str.replace(/[ \r\n]+$/, "")), hex = []; i < bin.length; ++i) {
            var tmp = bin.charCodeAt(i).toString(16);
            if (tmp.length === 1)
                tmp = "0" + tmp;
            hex[hex.length] = tmp;
        }
        return hex.join("");
    }
    this.hexToBytes = function (str) {
        var pos = 0;
        var len = str.length;
        if (len % 2 != 0) {
            return null;
        }
        len /= 2;
        var hexA = new Array();
        for (var i = 0; i < len; i++) {
            var s = str.substr(pos, 2);
            var v = parseInt(s, 16);
            hexA.push(v);
            pos += 2;
        }
        return hexA;
    }
    this.bytesToHex = function (arr) {
        var str = '';
        var k, j;
        for (var i = 0; i < arr.length; i++) {
            k = arr[i];
            j = k;
            if (k < 0) {
                j = k + 256;
            }
            if (j < 16) {
                str += "0";
            }
            str += j.toString(16);
        }
        return str;
    }
    this.stringToHex = function (str) {
        var val = "";
        for (var i = 0; i < str.length; i++) {
            if (val == "")
                val = str.charCodeAt(i).toString(16);
            else
                val += str.charCodeAt(i).toString(16);
        }
        return val
    }
    this.stringToBytes = function (str) {
        var ch, st, re = [];
        for (var i = 0; i < str.length; i++) {
            ch = str.charCodeAt(i);
            st = [];
            do {
                st.push(ch & 0xFF);
                ch = ch >> 8;
            }
            while (ch);
            re = re.concat(st.reverse());
        }
        return re;
    }
    //将byte[]转成String的方法
    this.bytesToString = function (arr) {
        var str = '';
        arr = new Uint8Array(arr);
        for (i in arr) {
            str += String.fromCharCode(arr[i]);
        }
        return str;
    }
    this.bytesToBase64 = function (e) {
        var r, a, c, h, o, t;
        for (c = e.length, a = 0, r = ''; a < c;) {
            if (h = 255 & e[a++], a == c) {
                r += base64EncodeChars.charAt(h >> 2),
                    r += base64EncodeChars.charAt((3 & h) << 4),
                    r += '==';
                break
            }
            if (o = e[a++], a == c) {
                r += base64EncodeChars.charAt(h >> 2),
                    r += base64EncodeChars.charAt((3 & h) << 4 | (240 & o) >> 4),
                    r += base64EncodeChars.charAt((15 & o) << 2),
                    r += '=';
                break
            }
            t = e[a++],
                r += base64EncodeChars.charAt(h >> 2),
                r += base64EncodeChars.charAt((3 & h) << 4 | (240 & o) >> 4),
                r += base64EncodeChars.charAt((15 & o) << 2 | (192 & t) >> 6),
                r += base64EncodeChars.charAt(63 & t)
        }
        return r
    }
    this.base64ToBytes = function (e) {
        var r, a, c, h, o, t, d;
        for (t = e.length, o = 0, d = []; o < t;) {
            do
                r = base64DecodeChars[255 & e.charCodeAt(o++)];
            while (o < t && r == -1);
            if (r == -1)
                break;
            do
                a = base64DecodeChars[255 & e.charCodeAt(o++)];
            while (o < t && a == -1);
            if (a == -1)
                break;
            d.push(r << 2 | (48 & a) >> 4);
            do {
                if (c = 255 & e.charCodeAt(o++), 61 == c)
                    return d;
                c = base64DecodeChars[c]
            } while (o < t && c == -1);
            if (c == -1)
                break;
            d.push((15 & a) << 4 | (60 & c) >> 2);
            do {
                if (h = 255 & e.charCodeAt(o++), 61 == h)
                    return d;
                h = base64DecodeChars[h]
            } while (o < t && h == -1);
            if (h == -1)
                break;
            d.push((3 & c) << 6 | h)
        }
        return d
    }
})();
//stringToBase64 stringToHex stringToBytes
//base64ToString base64ToHex base64ToBytes
//               hexToBase64  hexToBytes
// bytesToBase64 bytesToHex bytesToString
Java.perform(function () {
    var secretKeySpec = Java.use('javax.crypto.spec.SecretKeySpec');
    secretKeySpec.$init.overload('[B', 'java.lang.String').implementation = function (a, b) {
        showStacks();
        var result = this.$init(a, b);
        console.log("======================================");
        console.log("算法名：" + b + "|Dec密钥:" + bytesToString(a));
        console.log("算法名：" + b + "|Hex密钥:" + bytesToHex(a));
        return result;
    }
    var mac = Java.use('javax.crypto.Mac');
    mac.getInstance.overload('java.lang.String').implementation = function (a) {
        showStacks();
        var result = this.getInstance(a);
        console.log("======================================");
        console.log("算法名：" + a);
        return result;
    }
    mac.update.overload('[B').implementation = function (a) {
        showStacks();
        this.update(a);
        console.log("======================================");
        console.log("update:" + bytesToString(a))
    }
    mac.update.overload('[B', 'int', 'int').implementation = function (a, b, c) {
        showStacks();
        this.update(a, b, c)
        console.log("======================================");
        console.log("update:" + bytesToString(a) + "|" + b + "|" + c);
    }
    mac.doFinal.overload().implementation = function () {
        showStacks();
        var result = this.doFinal();
        console.log("======================================");
        console.log("doFinal结果:" + bytesToHex(result));
        console.log("doFinal结果:" + bytesToBase64(result));
        return result;
    }
    mac.doFinal.overload('[B').implementation = function (a) {
        showStacks();
        var result = this.doFinal(a);
        console.log("======================================");
        console.log("doFinal参数:" + bytesToString(a));
        console.log("doFinal结果:" + bytesToHex(result));
        console.log("doFinal结果:" + bytesToBase64(result));
        return result;
    }
    var md = Java.use('java.security.MessageDigest');
    md.getInstance.overload('java.lang.String', 'java.lang.String').implementation = function (a, b) {
        showStacks();
        console.log("======================================");
        console.log("算法名：" + a);
        return this.getInstance(a, b);
    }
    md.getInstance.overload('java.lang.String').implementation = function (a) {
        showStacks();
        console.log("======================================");
        console.log("算法名：" + a);
        return this.getInstance(a);
    }
    md.update.overload('[B').implementation = function (a) {
        showStacks();
        console.log("======================================");
        console.log("update:" + bytesToString(a))
        return this.update(a);
    }
    md.update.overload('[B', 'int', 'int').implementation = function (a, b, c) {
        showStacks();
        console.log("======================================");
        console.log("update:" + bytesToString(a) + "|" + b + "|" + c);
        return this.update(a, b, c);
    }
    md.digest.overload().implementation = function () {
        showStacks();
        console.log("======================================");
        var result = this.digest();
        console.log("digest结果:" + bytesToHex(result));
        console.log("digest结果:" + bytesToBase64(result));
        return result;
    }
    md.digest.overload('[B').implementation = function (a) {
        showStacks();
        console.log("======================================");
        console.log("digest参数:" + bytesToString(a));
        var result = this.digest(a);
        console.log("digest结果:" + bytesToHex(result));
        console.log("digest结果:" + bytesToBase64(result));
        return result;
    }
    var ivParameterSpec = Java.use('javax.crypto.spec.IvParameterSpec');
    ivParameterSpec.$init.overload('[B').implementation = function (a) {
        showStacks();
        var result = this.$init(a);
        console.log("======================================");
        console.log("iv向量:" + bytesToString(a));
        console.log("iv向量:" + bytesToHex(a));
        return result;
    }
    var cipher = Java.use('javax.crypto.Cipher');
    cipher.getInstance.overload('java.lang.String').implementation = function (a) {
        showStacks();
        var result = this.getInstance(a);
        console.log("======================================");
        console.log("模式填充:" + a);
        return result;
    }
    cipher.update.overload('[B').implementation = function (a) {
        showStacks();
        var result = this.update(a);
        console.log("======================================");
        console.log("update:" + bytesToString(a));
        return result;
    }
    cipher.update.overload('[B', 'int', 'int').implementation = function (a, b, c) {
        showStacks();
        var result = this.update(a, b, c);
        console.log("======================================");
        console.log("update:" + bytesToString(a) + "|" + b + "|" + c);
        return result;
    }
    cipher.doFinal.overload().implementation = function () {
        showStacks();
        var result = this.doFinal();
        console.log("======================================");
        console.log("doFinal结果:" + bytesToHex(result));
        console.log("doFinal结果:" + bytesToBase64(result));
        return result;
    }
    cipher.doFinal.overload('[B').implementation = function (a) {
        showStacks();
        var result = this.doFinal(a);
        console.log("======================================");
        console.log("doFinal参数:" + bytesToString(a));
        console.log("doFinal结果:" + bytesToHex(result));
        console.log("doFinal结果:" + bytesToBase64(result));
        return result;
    }
    var x509EncodedKeySpec = Java.use('java.security.spec.X509EncodedKeySpec');
    x509EncodedKeySpec.$init.overload('[B').implementation = function (a) {
        showStacks();
        var result = this.$init(a);
        console.log("======================================");
        console.log("RSA密钥:" + bytesToBase64(a));
        return result;
    }
    var rSAPublicKeySpec = Java.use('java.security.spec.RSAPublicKeySpec');
    rSAPublicKeySpec.$init.overload('java.math.BigInteger', 'java.math.BigInteger').implementation = function (a, b) {
        showStacks();
        var result = this.$init(a, b);
        console.log("======================================");
        //console.log("RSA密钥:" + bytesToBase64(a));
        console.log("RSA密钥N:" + a.toString(16));
        console.log("RSA密钥E:" + b.toString(16));
        return result;
    }
});

收起

展开全文

Java中4大基本加密算法解析
2016-10-19 19:23:28
Java中4大基本加密算法解析简单的java加密算法有：BASE64 严格地说，属于编码格式，而非加密算法 MD5(Message Digest algorithm 5，信息摘要算法) SHA(Secure Hash Algorithm，安全散列算法) HMAC(Hash Message ...
收起
java 加密编码
长度较短的rsa 2048证书_摘要、签名与数字证书都是什么？
2020-12-03 13:03:16
看完这篇文章，你将会知道：1. 摘要、签名、证书是什么； 2. 摘要、签名、证书的用途和关系； 3.... 4.... 5.... 6....1. 消息摘要（Digest）什么是消息摘要？对一份数据，进行一个单向的 ...摘要算法常见的摘要算法有 MD5、SHA...
收起
java报文hash算法_Java中4大基本加密算法解析
2021-03-08 05:34:55
严格地说，属于编码格式，而非加密算法2.MD5(Message Digest algorithm 5，信息摘要算法)3.SHA(Secure Hash Algorithm，安全散列算法)4.HMAC(Hash Message Authentication Code，散列消息鉴别码) 1.是网络上最常见...
收起
Java中4大加密算法
2015-11-18 19:10:43
BASE64 严格地说，属于编码格式，而非加密算法MD5(Message Digest algorithm 5，信息摘要算法)SHA(Secure Hash Algorithm，安全散列算法)HMAC(Hash Message Authentication Code，散列消息鉴别码 1. BASE64 ...
收起
java 加密
Java 4大基本加密算法解析
2019-04-16 19:13:52
简单的java加密算法有： BASE64 严格地说，属于编码格式，而非加密算法 MD5(Message Digest algorithm 5，信息摘要算法) SHA(Secure Hash Algorithm，安全散列算法) HMAC(Hash Message Authentication Code，...
收起
java4大基本算法加密解析
2015-07-14 18:04:07
BASE64 严格地说，属于编码格式，而非加密算法MD5(Message Digest algorithm 5，信息摘要算法)SHA(Secure Hash Algorithm，安全散列算法)HMAC(Hash Message Authentication Code，散列消息鉴别码) 1. BASE64 ...
收起
java
数字签名算法RSA
2019-09-16 10:54:23
1、数字签名算法可以看做是一个带有密钥的消息摘要算法，并且这个密钥包括了公钥和私钥。他是非对称加密算法和消息摘要算法的结合体 2、数字签名算法是公钥基础设施（PKI），以及许多网络安全机制的基础 3、数字...
收起
C#常见加密方式
千次阅读 2019-04-29 18:07:19
MD5消息摘要算法：一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致. 简单的说就是单向的加密，即是说无法根据密文推导出明文 MD5主要用途： 1、对一...
收起
关于文件加密所要学习的东西
2018-09-20 09:17:00
看一下这两个类CipherOutputStream和CipherInputStream掌握这两个类之前，需要了解...常见的流加密算法有：RC4常见的块加密算法有：DES、3DES、AES、Blowfish等等MD5肯定是不能加密文件的，MD5是消息摘要，只能...
收起
java源码包4
千次下载 热门讨论 2013-04-20 11:31:44
2个目标文件，FTP的目标是：（1）提高文件的共享性（计算机程序和/或数据），（2）鼓励间接地（通过程序）使用远程计算机，（3）保护用户因主机之间的文件存储系统导致的变化，（4）为了可靠和高效地传输，虽然用户...
收起
成百上千个Java 源码DEMO 4(1-4是独立压缩包)
2017-03-29 17:40:59
Java生成密钥的实例 1个目标文件摘要:Java源码,算法相关,密钥 Java生成密钥、保存密钥的实例源码，通过本源码可以了解到Java如何产生单钥加密的密钥(myKey)、产生双钥的密钥对(keyPair)、如何保存公钥的字节数组、...
收起

信息摘要算法-RipeMD以及HmacRipeMD算法

java ripemd160,JAVA加解密9-信息摘要算法-RipeMD以及HmacRipeMD算法

[软考考点解析]软件设计师--常用加密与摘要算法

1. 题目

2. 理论

2.1 对称加密算法

2.2 非对称加密算法

2.3 消息摘要算法

3. 解析

插装动态勾选一些常见自吐算法

常用的加密算法

对称加密算法

非对称加密算法

消息摘要算法

热插拔动态调试的原理

热插拔动态调试的js代码

Java中4大基本加密算法解析

长度较短的rsa 2048证书_摘要、签名与数字证书都是什么？

java报文hash算法_Java中4大基本加密算法解析

Java中4大加密算法

Java 4大基本加密算法解析

java4大基本算法加密解析

数字签名算法RSA

C#常见加密方式

关于文件加密所要学习的东西

java源码包4

成百上千个Java 源码DEMO 4(1-4是独立压缩包)

常见的摘要算法有消息摘要4