package utils;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.KeySpec;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
/**
* DES的密钥(key)长度是为8个字节,加密解密的速度是最快的<br>
* DESede的密钥(key)长度是24个字节<br>
* AES的密钥(key)长度是16个字节<br>
* BlowFish的密钥(key)长度是可变的(1<=key<=16),加密最快,强度最高<br>
*/
public class AppCrypt {
public final static String DES = "DES";
public final static String DESEDE = "DESede";
public final static String AES = "AES";
public final static String BLOWFISH = "BlowFish";
public final static String MD5 = "MD5";
/**
* md5加密
*
* @param data
* @return
*/
public static String getMD5(String data) {
return null == data ? data : getMD5(string2byte(data));
}
private static String getMD5(byte str[]) {
try {
MessageDigest md = MessageDigest.getInstance(MD5);
md.update(str);
byte b[] = md.digest();
return byte2hex(b);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 字符串加密
*
* @param data
* 字符串数据
* @param key
* 密钥
* @param name
* 算法名称
* @throws Exception
*/
public static String encrypt(String data, String key, String name) {
try {
return byte2hex(encrypt(string2byte(data), string2byte(key), name));
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 字符串解密
*
* @param data
* 字符串加密数据
* @param key
* 密钥
* @param name
* 算法名称
* @return
* @throws Exception
*/
public static String decrypt(String data, String key, String name) {
try {
return byte2string(decrypt(hex2byte(string2byte(data)),
string2byte(key), name));
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 对数据源进行加密
*
* @param src
* 数据源
* @param key
* 密钥
* @param name
* 算法的名称
* @return 返回加密后的数据
* @throws Exception
*/
private static byte[] encrypt(byte[] src, byte[] key, String name)
throws Exception {
SecretKey securekey = new SecretKeySpec(key, name);
Cipher cipher = Cipher.getInstance(name);
cipher.init(Cipher.ENCRYPT_MODE, securekey);
return cipher.doFinal(src);
}
/**
* 对加密的数据源进行解密
*
* @param src
* 数据源
* @param key
* 密钥
* @param name
* 算法的名称
* @return 返回解密后的原始数据
* @throws Exception
*/
private static byte[] decrypt(byte[] src, byte[] key, String name)
throws Exception {
SecretKey securekey = new SecretKeySpec(key, name);
Cipher cipher = Cipher.getInstance(name);
cipher.init(Cipher.DECRYPT_MODE, securekey);
return cipher.doFinal(src);
}
/**
* 二进制转十六进制
*
* @param bytes
* @return
*/
private static String byte2hex(byte[] bytes) {
String hex = "";
if (bytes != null) {
final int size = bytes.length;
if (size > 0) {
String tmp;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < size; i++) {
tmp = (java.lang.Integer.toHexString(bytes[i] & 0XFF));
if (tmp.length() == 1) {
sb.append("0" + tmp);
} else {
sb.append(tmp);
}
}
hex = sb.toString().toUpperCase();
}
}
return hex;
}
/**
* 十六进制转二进制
*
* @param bytes
* @return
*/
private static byte[] hex2byte(byte[] bytes) {
if ((bytes.length % 2) != 0) {
return null;
}
String item;
byte[] result = new byte[bytes.length / 2];
for (int i = 0; i < bytes.length; i += 2) {
item = new String(bytes, i, 2);
result[i / 2] = (byte) Integer.parseInt(item, 16);
}
return result;
}
/**
* 把字符串转换成 Unicode Bytes.
*
* @param s
* String
* @return byte[]
*/
private static byte[] string2byte(String s) {
byte[] bytes = null;
if (s != null) {
try {
bytes = s.getBytes("utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
return bytes;
}
/**
* 根据 Unicode Bytes 构造字符串.
*
* @param bytes
* byte[]
* @return String
*/
private static String byte2string(byte[] bytes) {
String s = null;
if (bytes != null) {
try {
s = new String(bytes, "utf-8");
} catch (Exception e) {
e.printStackTrace();
}
}
return s;
}
public static void main(String[] args) throws Exception {
/** DES算法 **/
String src = "你好！";
String key = "k>k2>&1&";
String enc = "", dec = "";
enc = encrypt(src, key, DES);
System.out.println("11加密后的数据为:" + enc);
dec = decrypt(enc, key, DES);
System.out.println("11解密后的数据:" + dec);
/* 若key的字节数大于8，则只取前8个字节 */
KeySpec keySpec = new DESKeySpec(string2byte(key));
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey secretKey = keyFactory.generateSecret(keySpec);
/*
* 在JAVA中DES默认使用DES/ECB/PKCS5Padding，下面的写法Cipher.getInstance(
* "DES/ECB/PKCS5Padding")与 Cipher.getInstance("DES")等价
*/
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("12加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("12解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
/* CBC模式下，需要传入IV向量 ，IV向量的字节长度必须等于8 */
AlgorithmParameterSpec paramSpec = new IvParameterSpec(string2byte(key));
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("13加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("13解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
/* NoPadding模式下，加密源数据的字节数必须是8的倍数 */
src = "12345678";
cipher = Cipher.getInstance("DES/ECB/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("14加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("14解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("DES/CBC/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("15加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("15解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
/** DESede算法 **/
src = "你好！";
key = "nohup command > f 2>&1 &";
enc = encrypt(src, key, DESEDE);
System.out.println("21加密后的数据为:" + enc);
dec = decrypt(enc, key, DESEDE);
System.out.println("21解密后的数据:" + dec);
/* 若key的字节数大于24，则只取前24个字节 */
keySpec = new DESedeKeySpec(string2byte(key));
keyFactory = SecretKeyFactory.getInstance(DESEDE);
secretKey = keyFactory.generateSecret(keySpec);
/*
* 在JAVA中DESede默认使用DESede/ECB/PKCS5Padding，下面的写法Cipher.getInstance(
* "DESede/ECB/PKCS5Padding")与 Cipher.getInstance("DESede")等价
*/
cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("22加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("22解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");
/* CBC模式下，需要传入IV向量 ，IV向量的字节长度必须等于8 */
paramSpec = new IvParameterSpec(string2byte("k>k2>&1&"));
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("23加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("23解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
/* NoPadding模式下，加密源数据的字节数必须是8的倍数 */
src = "12345678";
cipher = Cipher.getInstance("DESede/ECB/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("24加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("24解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("DESede/CBC/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("25加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("25解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
/** AES算法 **/
src = "你好！";
key = "nohup cmd>f2>&1&";
enc = encrypt(src, key, AES);
System.out.println("31加密后的数据为:" + enc);
dec = decrypt(enc, key, AES);
System.out.println("31解密后的数据:" + dec);
/* key的字节数必须等于16 */
secretKey = new SecretKeySpec(string2byte(key), AES);
/*
* 在JAVA中AES默认使用AES/ECB/PKCS5Padding，下面的写法Cipher.getInstance(
* "AES/ECB/PKCS5Padding")与 Cipher.getInstance("AES")等价
*/
cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("32加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("32解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
/* CBC模式下，需要传入IV向量 ，IV向量的字节长度必须等于16 */
paramSpec = new IvParameterSpec(string2byte(key));
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("33加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("33解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
/* NoPadding模式下，加密源数据的字节数必须是16的倍数 */
src = "1234567812345678";
cipher = Cipher.getInstance("AES/ECB/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("34加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("34解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("AES/CBC/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("35加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("35解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
src = "你好！";
key = "nohup cmd>f2>&1&";
KeyGenerator kgen = KeyGenerator.getInstance(AES);
// ------------------------------
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
random.setSeed(string2byte(key));
kgen.init(128, random);
// ------------------------------
// 以上三行等价于kgen.init(128, new SecureRandom(string2byte(key)));
secretKey = kgen.generateKey();
secretKey = new SecretKeySpec(secretKey.getEncoded(), AES);// 这一行可以省略
cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("36加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("36解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("37加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("37解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
/* NoPadding模式下，加密源数据的字节数必须是16的倍数 */
src = "1234567812345678";
cipher = Cipher.getInstance("AES/ECB/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("38加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("38解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("AES/CBC/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("39加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("39解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
/** BlowFish算法 **/
src = "你好！";
key = "nohup cmd>f2>&1&";
enc = encrypt(src, key, BLOWFISH);
System.out.println("41加密后的数据为:" + enc);
dec = decrypt(enc, key, BLOWFISH);
System.out.println("41解密后的数据:" + dec);
/* key的字节数必须大于等于1小于等于16 */
secretKey = new SecretKeySpec(string2byte(key), BLOWFISH);
/*
* 在JAVA中BlowFish默认使用BlowFish/ECB/PKCS5Padding，下面的写法Cipher.getInstance(
* "BlowFish/ECB/PKCS5Padding")与 Cipher.getInstance("BlowFish")等价
*/
cipher = Cipher.getInstance("BlowFish/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("42加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("42解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("BlowFish/CBC/PKCS5Padding");
/* CBC模式下，需要传入IV向量 ，IV向量的字节长度必须等于8 */
paramSpec = new IvParameterSpec(string2byte("k>k2>&1&"));
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("43加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("43解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
/* NoPadding模式下，加密源数据的字节数必须是8的倍数 */
src = "12345678";
cipher = Cipher.getInstance("BlowFish/ECB/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
System.out.println("44加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey);
System.out.println("44解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
cipher = Cipher.getInstance("BlowFish/CBC/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey, paramSpec);
System.out.println("45加密后的数据为:"
+ (enc = byte2hex(cipher.doFinal(string2byte(src)))));
cipher.init(Cipher.DECRYPT_MODE, secretKey, paramSpec);
System.out.println("45解密后的数据:"
+ byte2string(cipher.doFinal(hex2byte(string2byte(enc)))));
}
}
相关推荐
java关于加密的算法demo代码（Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法） JAVA安全实现三种方式： 1.JDK 2.Commons Codec 3.Bouncy Castle 一。非对称加密算法： 1.DH 2.RSA 3.ELGamal 二。...
通过阅读《非对称加密算法 数字签名算法——RSA - 信息安全 - ITeye知识库频道.htm》这篇文章，可以深入理解这些概念，并了解在实际应用中如何使用Java实现这些功能。同时，文件中的`非对称加密算法 数字签名算法...
"Java实现的对称加密算法AES定义与用法详解" 对称加密算法AES是当前使用最多的加密算法之一，其主要特点是高级的、安全的、快速的和灵活的。下面我们将详细介绍Java实现的对称加密算法AES的定义、特点、用法及使用...
这是本人总结的Java 非对称 加密 算法，有疑问可以找我1038546502@qq.com
本人总结了一些对称的加密算法，希望可以给一些朋友带来帮助！！
本资料包“对称加密算法分析及用Java实现.zip”包含了关于这一主题的详细内容，特别是如何使用Java编程语言来实现对称加密算法。 对称加密算法的核心特点是加密和解密使用相同的密钥，这简化了密钥管理，但也带来了...
RSA算法是一种非对称加密算法，它在信息安全领域有着广泛的应用，特别是在数据传输中的安全保护。这个RAR压缩包包含了一个名为“Rsa.java”的源代码文件，可能是用于演示如何在Java环境中实现RSA算法。另一个文件...
在分布式网络系统中，由于密钥数量呈几何级数增长，对称加密算法使用较为困难。 1. 对称加密算法主要包含以下几种： - DES（Data Encryption Standard）：是一种使用56位密钥的对称密钥加密算法，因其密钥长度较短...
1. **AES（Advanced Encryption Standard）**：高级加密标准，是一种对称加密算法，因其高效性和安全性被广泛应用。AESUtil.java可能是实现AES加密解密功能的工具类，通常包括AES的ECB、CBC、CFB、OFB和CTR模式，...
而非对称加密算法则采用了一对密钥，包括一个公钥和一个私钥。公钥可以公开给任何人，用于加密数据；而私钥必须保密，用于解密数据。这种设计使得即使公钥被他人获取，也无法解密由私钥加密的信息，极大地增强了通信...
《对称加密算法Blowfish在Java环境中的应用》 对称加密算法是信息安全领域中的一种基础技术，它以其高效性和简洁性广泛应用于数据保护。Blowfish算法作为其中的一员，由 Bruce Schneier 在1993年设计，以其优秀的...
一个来自Java非对称加密算法演示源码，通过网络或磁盘等方式,把公钥编码传送给李四，李四接收到张三编码后的公钥,将其解码，将公钥的KeySpec对象转换为公钥，张三用自己的私钥解密从李四处收到的信息，里面对原理的...
对称加密算法使用相同的密钥进行加密和解密，效率高，适合大量数据的处理。Java中常见的对称加密算法包括： - DES（Data Encryption Standard）：一种古老的64位块加密算法，已被AES取代。 - 3DES（Triple DES）：...
对称加密算法使用同一个密钥进行加密和解密操作，而非对称加密算法则需要一对密钥——公钥用于加密，而私钥用于解密。 ##### 2.1 对称加密算法 对称加密算法因其高效性和易于实现的特点，在日常应用中非常普遍。...
DES算法为密码体制中的对称密码体制，是一个分组加密算法，典型的DES以64位为分组对数据加密，加密和解密用的是同一个算法。 这里以Java代码实现DES算法。
对称加密算法使用相同的密钥进行加密和解密，速度快，效率高，适合大量数据的处理。Java中内置了DES（Data Encryption Standard）、3DES（Triple DES）以及AES（Advanced Encryption Standard）等对称加密算法。 -...
Java对称加密算法是使用对称密钥进行加密和解密的加密算法，其加密和解密使用相同的密钥。Java中对称加密算法有多种，而DES（Data Encryption Standard）是其中一种古老的对称加密算法。 一、DES算法概述 DES是一...
一个用java做得关于des的对称加密算法。