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 series message summary component
-
This algorithm is currently only supported by BouncyCastle
-
@author kongqz
-
/
public class RipeMDCoder {
RipeMD128 message digest processing ///
/*- RipeMD128 message digest
- @param data pending message digest data
- @return byte[] message digest
- */
public static byte[] encodeRipeMD128(byte[] data) throws Exception{
// Add support for BouncyCastleProvider
Security. addProvider(new BouncyCastleProvider());
//Initialize MessageDigest
MessageDigest md=MessageDigest.getInstance(“RipeMD128”);
//execute message digest
return md. digest(data);
}
/**- RipeMD128Hex message digest
- @param data pending message digest data
- @return String message digest
- **/
public static String encodeRipeMD128Hex(byte[] data) throws Exception{
//execute message digest
byte[] b=encodeRipeMD128(data);
// Do hexadecimal encoding processing
return new String(Hex. encode(b));
}
RipeMD160 message digest processing ///
/**
* RipeMD160 message digest
* @param data pending message summary data
* @return byte[] message digest
* */
public static byte[] encodeRipeMD160(byte[] data) throws Exception{
// Add support for BouncyCastleProvider
Security. addProvider(new BouncyCastleProvider());
//Initialize MessageDigest
MessageDigest md=MessageDigest.getInstance(“RipeMD160”);
//execute message digest
return md. digest(data);
}
/**
* RipeMD160Hex message digest
* @param data pending message summary data
* @return String message digest
* **/
public static String encodeRipeMD160Hex(byte[] data) throws Exception{
//execute message digest
byte[] b=encodeRipeMD160(data);
// Do hexadecimal encoding processing
return new String(Hex. encode(b));
}
RipeMD256 message digest processing ///
/**
* RipeMD256 message digest
* @param data pending message summary data
* @return byte[] message digest
* */
public static byte[] encodeRipeMD256(byte[] data) throws Exception{
// Add support for BouncyCastleProvider
Security. addProvider(new BouncyCastleProvider());
//Initialize MessageDigest
MessageDigest md=MessageDigest.getInstance(“RipeMD256”);
//execute message digest
return md. digest(data);
}
/**
* RipeMD256Hex message digest
* @param data pending message summary data
* @return String message digest
* **/
public static String encodeRipeMD256Hex(byte[] data) throws Exception{
//execute message digest
byte[] b=encodeRipeMD256(data);
// Do hexadecimal encoding processing
return new String(Hex. encode(b));
}
RipeMD320 message digest processing ///
/**
* RipeMD320 message digest
* @param data pending message summary data
* @return byte[] message digest
* */
public static byte[] encodeRipeMD320(byte[] data) throws Exception{
// Add support for BouncyCastleProvider
Security. addProvider(new BouncyCastleProvider());
//Initialize MessageDigest
MessageDigest md=MessageDigest.getInstance(“RipeMD320”);
//execute message digest
return md. digest(data);
}
/**
* RipeMD320Hex message digest
* @param data pending message summary data
* @return String message digest
* **/
public static String encodeRipeMD320Hex(byte[] data) throws Exception{
//execute message digest
byte[] b=encodeRipeMD320(data);
// Do hexadecimal encoding processing
return new String(Hex. encode(b));
}
///HmacRipeMD-BouncyCastle supported implementation//
/**
* Initialize the key of HmacRipeMD128
* @return byte[] key
* */
public static byte[] initHmacRipeMD128Key() throws Exception{
//Add support for BouncyCastleProvider
Security. addProvider(new BouncyCastleProvider());
//Initialize KeyGenerator
KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacRipeMD128");
//Generate key
SecretKey secretKey=keyGenerator. generateKey();
//Get the key
return secretKey. getEncoded();
}
/**
* HmacRipeMD128 message digest
* @param data data to be digested
* @param key key
* @return byte[] message digest
* */
public static byte[] encodeHmacRipeMD128(byte[] data,byte[] key) throws Exception{
// Add support for BouncyCastleProvider
Security. addProvider(new BouncyCastleProvider());
//Restore the key, because the key is owned by the messaging algorithm in byte form
SecretKey secretKey=new SecretKeySpec(key,"HmacRipeMD128");
//Instantiate the Mac
Mac mac=Mac.getInstance(secretKey.getAlgorithm());
//Initialize the Mac
mac.init(secretKey);
//Execute message digest processing
return mac.doFinal(data);
}
/**
* HmacRipeMD128Hex message digest
* @param data data to be digested
* @param String key
* @return byte[] message digest
* */
public static String encodeHmacRipeMD128Hex(byte[] data,byte[] key) throws Exception{
//Execute message digest processing
byte[] b=encodeHmacRipeMD128(data,key);
// do hex conversion
return new String(Hex. encode(b));
}
///HmacRipeMD-BouncyCastle supported implementation//
/**
* Initialize the key of HmacRipeMD160
* @return byte[] key
* */
public static byte[] initHmacRipeMD160Key() throws Exception{
//Add support for BouncyCastleProvider
Security. addProvider(new BouncyCastleProvider());
//Initialize KeyGenerator
KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacRipeMD160");
//Generate key
SecretKey secretKey=keyGenerator. generateKey();
//Get the key
return secretKey. getEncoded();
}
/**
* HmacRipeMD160 message digest
* @param data data to be digested
* @param key key
* @return byte[] message digest
* */
public static byte[] encodeHmacRipeMD160(byte[] data,byte[] key) throws Exception{
// Add support for BouncyCastleProvider
Security. addProvider(new BouncyCastleProvider());
//Restore the key, because the key is owned by the messaging algorithm in byte form
SecretKey secretKey=new SecretKeySpec(key,"HmacRipeMD160");
//Instantiate the Mac
Mac mac=Mac.getInstance(secretKey.getAlgorithm());
//Initialize the Mac
mac.init(secretKey);
//Execute message digest processing
return mac.doFinal(data);
}
/**
* HmacRipeMD160Hex message digest
* @param data data to be digested
* @param String key
* @return byte[] message digest
* */
public static String encodeHmacRipeMD160Hex(byte[] data,byte[] key) throws Exception{
//Execute message digest processing
byte[] b=encodeHmacRipeMD160(data,key);
// do hex conversion
return new String(Hex. encode(b));
}
/***
*
* Process the message digest length
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
String str="RIPEMD message summary";
System.out.println("Original:" + str);
byte[] data1=RipeMDCoder.encodeRipeMD128(str.getBytes());
String data1hex=RipeMDCoder.encodeRipeMD128Hex(str.getBytes());
System.out.println("RipeMD128 message digest algorithm value:" + data1.toString());
System.out.println("RipeMD128 hex message digest algorithm value: " + data1hex);
System.out.println();
byte[] data2=RipeMDCoder.encodeRipeMD160(str.getBytes());
String data2hex=RipeMDCoder.encodeRipeMD160Hex(str.getBytes());
System.out.println("RipeMD160 message digest algorithm value:" + data2.toString());
System.out.println("RipeMD160 hex message digest algorithm value: " + data2hex);
System.out.println();
byte[] data3=RipeMDCoder.encodeRipeMD256(str.getBytes());
String data3hex=RipeMDCoder.encodeRipeMD256Hex(str.getBytes());
System.out.println("RipeMD256 message digest algorithm value:" + data3.toString());
System.out.println("RipeMD256 hex message digest algorithm value: " + data3hex);
System.out.println();
byte[] data4=RipeMDCoder.encodeRipeMD320(str.getBytes());
String data4hex=RipeMDCoder.encodeRipeMD320Hex(str.getBytes());
System.out.println("RipeMD320 message digest algorithm value:" + data4.toString());
System.out.println("RipeMD320 hex message digest algorithm value: " + data4hex);
System.out.println();
System.out.println("================= The following algorithms support HmacRipeMD series, only BouncyCastle supports at this stage ============== ============");
//Initialize the key
byte[] key5=RipeMDCoder.initHmacRipeMD128Key();
// Get summary information
byte[] data5=RipeMDCoder.encodeHmacRipeMD128(str.getBytes(), key5);
String datahex5=RipeMDCoder.encodeHmacRipeMD128Hex(str.getBytes(), key5);
System.out.println("Key of Bouncycastle HmacRipeMD128:" + key5.toString());
System.out.println("Bouncycastle HmacRipeMD128 algorithm summary:" + data5.toString());
System.out.println("Bouncycastle HmacRipeMD128Hex algorithm summary:" + datahex5.toString());
System.out.println();
//Initialize the key
byte[] key6=RipeMDCoder.initHmacRipeMD160Key();
// Get summary information
byte[] data6=RipeMDCoder.encodeHmacRipeMD160(str.getBytes(), key6);
String datahex6=RipeMDCoder.encodeHmacRipeMD160Hex(str.getBytes(), key6);
System.out.println("Key of Bouncycastle HmacRipeMD160:" + key6.toString());
System.out.println("Bouncycastle HmacRipeMD160 algorithm summary:" + data6.toString());
System.out.println("Bouncycastle HmacRipeMD160Hex algorithm summary:" + datahex6.toString());
System.out.println();
}
}
Console output:
Original: RIPEMD message digest
RipeMD128 message digest algorithm value: [B@253498
RipeMD128 hex message digest algorithm value: 33fe1de4407218a6e530a91271fb775a
RipeMD160 message digest algorithm value: [B@17172ea
RipeMD160 hex message digest algorithm value: e35a41f8872f35d4e32da2d9189bb85a29111ccc
RipeMD256 message digest algorithm value: [B@b169f8
RipeMD256 hex message digest algorithm value: 8ce5cfd043d5f591c5a8f5c1bbe61940995c6c49abe18045bafb77a14e12abbd
RipeMD320 message digest algorithm value: [B@b0f13d
RipeMD320 hex message digest algorithm value: 086a2de72a828297a37dd5467d5ad2ad506cd259b9015f2aac216664489c408f8b98b80a71f4c3f9
The following algorithms support HmacRipeMD series, currently only BouncyCastle supports< /mark>=======
Key for Bouncycastle HmacRipeMD128: [B@ab95e6
Bouncycastle HmacRipeMD128 algorithm summary: [B@fe64b9
Bouncycastle HmacRipeMD128Hex algorithm summary: ff5fa29b67e366558957200f2355b35a
Key for Bouncycastle HmacRipeMD160: [B@13582d
Bouncycastle HmacRipeMD160 algorithm summary: [B@21b6d
Bouncycastle HmacRipeMD160Hex algorithm summary: 74285f4e6e365d1f2661b93382f32e1d55c92cb9