一、加密算法分类
加密算法通常分为三类：
对称加密
指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密效率高且易于实现。
不可逆加密
不可逆加密算法的特征是加密过程不需要密钥，并且经过加密的数据无法被解密，只有同样输入的输入数据经过同样的不可逆算法才能得到同样的加密数据。
非对称加密
指加密和解密使用不同密钥的加密算法，也称为公私钥加密。
二、加密算法的应用
1.数字签名：进行身份认证和数据完整性验证，主要用到了非对称密钥加密技术与数字摘要技术。
2.数字证书：主要用来确保数字签名才是安全有效的，数字证书由独立的证书发行机构发布。数字证书各不相同，每种证书可提供不同级别的可信度，该证书内包含用户的个人信息和他的公钥信息，同时还附有认证中心的签名信息。
3.md5：对用户密码进行加密并进行保存。
4.网络数据加密：保障传输的数据安全，即使被截获报文，在没有密匙的情况下也无法得知报文真实内容。
5.ssl协议：在握手阶段使用的是非对称加密，在传输阶段使用的是对称加密，也就是说在ssl上传送的数据是使用对称密钥加密的。同时https也是由ssl+http协议构建的可进行加密传输、身份认证（确认客户端连接的目标主机是否是真实正确的主机）的网络协议。
三、对称加密算法实现
- 优点：算法对消息双方公开、计算量小、加密速度快、加密效率高。
- 缺点：在数据传送前，发送方和接收方必须商定好秘钥，然后双方保存好秘钥。如果一方的秘钥被泄露，那么加密信息就会被破解。
3.1 des介绍
des全称为data encryption standard，即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（fips），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。不过现在已经有点过时了。
java代码实现：
import java.io.unsupportedencodingexception;
import java.security.securerandom;
import javax.crypto.spec.deskeyspec;
import javax.crypto.secretkeyfactory;
import javax.crypto.secretkey;
import javax.crypto.cipher;
/**
* des加密介绍 des是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。des加密算法出自ibm的研究，
* 后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为des使用56位密钥，以现代计算能力，
* 24小时内即可被破解。虽然如此，在某些简单应用中，我们还是可以使用des加密算法，本文简单讲解des的java实现 。
* 注意：des加密和解密过程中，密钥长度都必须是8的倍数
*/
public class desdemo {
public desdemo() {
}
// 测试
public static void main(string args[]) {
// 待加密内容
string str = "cryptology";
// 密码，长度要是8的倍数
string password = "95880288";
byte[] result;
try {
result = desdemo.encrypt(str.getbytes(), password);
system.out.println("加密后：" + result);
byte[] decryresult = desdemo.decrypt(result, password);
system.out.println("解密后：" + new string(decryresult));
} catch (unsupportedencodingexception e2) {
// todo auto-generated catch block
e2.printstacktrace();
} catch (exception e1) {
e1.printstacktrace();
}
}
// 直接将如上内容解密
/**
* 加密
*
* @param datasource
* byte[]
* @param password
* string
* @return byte[]
*/
public static byte[] encrypt(byte[] datasource, string password) {
try {
securerandom random = new securerandom();
deskeyspec deskey = new deskeyspec(password.getbytes());
// 创建一个密匙工厂，然后用它把deskeyspec转换成
secretkeyfactory keyfactory = secretkeyfactory.getinstance("des");
secretkey securekey = keyfactory.generatesecret(deskey);
// cipher对象实际完成加密操作
cipher cipher = cipher.getinstance("des");
// 用密匙初始化cipher对象,encrypt_mode用于将 cipher 初始化为加密模式的常量
cipher.init(cipher.encrypt_mode, securekey, random);
// 现在，获取数据并加密
// 正式执行加密操作
return cipher.dofinal(datasource); // 按单部分操作加密或解密数据，或者结束一个多部分操作
} catch (throwable e) {
e.printstacktrace();
}
return null;
}
/**
* 解密
*
* @param src
* byte[]
* @param password
* string
* @return byte[]
* @throws exception
*/
public static byte[] decrypt(byte[] src, string password) throws exception {
// des算法要求有一个可信任的随机数源
securerandom random = new securerandom();
// 创建一个deskeyspec对象
deskeyspec deskey = new deskeyspec(password.getbytes());
// 创建一个密匙工厂
secretkeyfactory keyfactory = secretkeyfactory.getinstance("des");// 返回实现指定转换的
// cipher
// 对象
// 将deskeyspec对象转换成secretkey对象
secretkey securekey = keyfactory.generatesecret(deskey);
// cipher对象实际完成解密操作
cipher cipher = cipher.getinstance("des");
// 用密匙初始化cipher对象
cipher.init(cipher.decrypt_mode, securekey, random);
// 真正开始解密操作
return cipher.dofinal(src);
}
}
3.2 idea介绍
- 这种算法是在des算法的基础上发展出来的，类似于三重des。
- 发展idea也是因为感到des具有密钥太短等缺点。
- dea的密钥为128位，这么长的密钥在今后若干年内应该是安全的。
- 在实际项目中用到的很少了解即可。
java代码实现
import java.security.key;
import java.security.security;
import javax.crypto.cipher;
import javax.crypto.keygenerator;
import javax.crypto.secretkey;
import javax.crypto.spec.secretkeyspec;
import org.apache.commons.codec.binary.base64;
import org.bouncycastle.jce.provider.bouncycastleprovider;
public class ideademo {
public static void main(string args[]) {
bcidea();
}
public static void bcidea() {
string src = "www.xttblog.com security idea";
try {
security.addprovider(new bouncycastleprovider());
//生成key
keygenerator keygenerator = keygenerator.getinstance("idea");
keygenerator.init(128);
secretkey secretkey = keygenerator.generatekey();
byte[] keybytes = secretkey.getencoded();
//转换密钥
key key = new secretkeyspec(keybytes, "idea");
//加密
cipher cipher = cipher.getinstance("idea/ecb/iso10126padding");
cipher.init(cipher.encrypt_mode, key);
byte[] result = cipher.dofinal(src.getbytes());
system.out.println("bc idea encrypt : " + base64.encodebase64string(result));
//解密
cipher.init(cipher.decrypt_mode, key);
result = cipher.dofinal(result);
system.out.println("bc idea decrypt : " + new string(result));
} catch (exception e) {
e.printstacktrace();
}
}
}
四、不可逆加密算法
- 优点：不可逆、易计算、特征化
- 缺点：可能存在散列冲突
4.1 md5介绍
md5的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式
（也就是把一个任意长度的字节串变换成一定长的十六进制数字串）。
主要有以下特点：
- 1.压缩性： 任意长度的数据，算出的md5值长度都是固定的。
- 2.容易计算： 从原数据计算出md5值很容易。
- 3.抗修改性： 对原数据进行任何改动，哪怕只修改1个字节，所得到的md5值都有很大区别。
- 4.强抗碰撞： 已知原数据和其md5值，想找到一个具有相同md5值的数据（即伪造数据）是非常困难的。
java代码实现
import java.security.messagedigest;
//利用jdk提供java.security.messagedigest类实现md5算法
public class md5demo {
public static void main(string[] args) {
system.out.println(getmd5code("不可逆加密算法"));
}
private md5demo() {
}
// md5加密
public static string getmd5code(string message) {
string md5str = "";
try {
//创建md5算法消息摘要
messagedigest md = messagedigest.getinstance("md5");
//生成的哈希值的字节数组
byte[] md5bytes = md.digest(message.getbytes());
md5str = bytes2hex(md5bytes);
}catch(exception e) {
e.printstacktrace();
}
return md5str;
}
// 2进制转16进制
public static string bytes2hex(byte[] bytes) {
stringbuffer result = new stringbuffer();
int temp;
try {
for (int i = 0; i < bytes.length; i++) {
temp = bytes[i];
if(temp < 0) {
temp += 256;
}
if (temp < 16) {
result.append("0");
}
result.append(integer.tohexstring(temp));
}
} catch (exception e) {
e.printstacktrace();
}
return result.tostring();
}
}
4.2 sha1介绍
对于长度小于2^64位的消息，sha1会产生一个160位(40个字符)的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。
sha1有如下特性：
- 不可以从消息摘要中复原信息；
- 两个不同的消息不会产生同样的消息摘要,(但会有1×10 ^ 48分之一的机率出现相同的消息摘要,一般使用时忽略)。
java代码实现
import java.io.unsupportedencodingexception;
import java.security.messagedigest;
import java.security.nosuchalgorithmexception;
public class sha1demo {
public static void main(string[] args) {
// todo auto-generated method stub
system.out.println(getsha1("不可逆加密算法"));
}
public static string getsha1(string str) {
if (null == str || 0 == str.length()) {
return null;
}
char[] hexdigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
try {
//创建sha1算法消息摘要对象
messagedigest mdtemp = messagedigest.getinstance("sha1");
//使用指定的字节数组更新摘要。
mdtemp.update(str.getbytes("utf-8"));
//生成的哈希值的字节数组
byte[] md = mdtemp.digest();
//sha1算法生成信息摘要关键过程
int j = md.length;
char[] buf = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++) {
byte byte0 = md[i];
buf[k++] = hexdigits[byte0 >>> 4 & 0xf];
buf[k++] = hexdigits[byte0 & 0xf];
}
return new string(buf);
} catch (nosuchalgorithmexception e) {
e.printstacktrace();
} catch (unsupportedencodingexception e) {
e.printstacktrace();
}
return "0";
}
}
4.3 hmac 介绍
hmac 是密钥相关的 哈希运算消息认证码（hash-based message authentication code），hmac 运算利用 哈希算法 (md5、sha1 等)，以 一个密钥 和 一个消息 为输入，生成一个 消息摘要 作为 输出。
hmac 发送方 和 接收方 都有的 key 进行计算，而没有这把 key 的第三方，则是 无法计算 出正确的 散列值的，这样就可以 防止数据被篡改。
java代码实现
import net.pocrd.annotation.notthreadsafe;
import net.pocrd.define.constfield;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import javax.crypto.mac;
import javax.crypto.secretkey;
import javax.crypto.spec.secretkeyspec;
import java.util.arrays;
@notthreadsafe
public class hmachelper {
private static final logger logger = loggerfactory.getlogger(hmachelper.class);
private mac mac;
/**
* mac算法可选以下多种算法
* hmacmd5/hmacsha1/hmacsha256/hmacsha384/hmacsha512
*/
private static final string key_mac = "hmacmd5";
public hmachelper(string key) {
try {
secretkey secretkey = new secretkeyspec(key.getbytes(constfield.utf8), key_mac);
mac = mac.getinstance(secretkey.getalgorithm());
mac.init(secretkey);
} catch (exception e) {
logger.error("create hmac helper failed.", e);
}
}
public byte[] sign(byte[] content) {
return mac.dofinal(content);
}
public boolean verify(byte[] signature, byte[] content) {
try {
byte[] result = mac.dofinal(content);
return arrays.equals(signature, result);
} catch (exception e) {
logger.error("verify sig failed.", e);
}
return false;
}
}
五、非对称加密
- 优点：非对称加密与对称加密相比其安全性更好，只要私钥不泄露，很难被破解。
- 缺点：加密和解密花费时间长、速度慢，只适合对少量数据进行加密。
5.1 rsa介绍
rsa是目前最有影响力和最常用的公钥加密算法。它能够抵抗到目前为止已知的绝大多数密码攻击，已被iso推荐为公钥数据加密标准。rsa公开密钥密码体制的原理是：根据数论，寻求两个大素数比较简单，而将它们的乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥
java代码实现
import org.apache.commons.codec.binary.base64;
import java.security.*;
import java.security.spec.pkcs8encodedkeyspec;
import java.security.spec.x509encodedkeyspec;
import java.util.hashmap;
import java.util.map;
import javax.crypto.cipher;
/**
* created by humf.需要依赖 commons-codec 包
*/
public class rsademo {
public static void main(string[] args) throws exception {
map<string, key> keymap = initkey();
string publickey = getpublickey(keymap);
string privatekey = getprivatekey(keymap);
system.out.println(keymap);
system.out.println("-----------------------------------");
system.out.println(publickey);
system.out.println("-----------------------------------");
system.out.println(privatekey);
system.out.println("-----------------------------------");
byte[] encryptbyprivatekey = encryptbyprivatekey("123456".getbytes(), privatekey);
byte[] encryptbypublickey = encryptbypublickey("123456", publickey);
system.out.println(encryptbyprivatekey);
system.out.println("-----------------------------------");
system.out.println(encryptbypublickey);
system.out.println("-----------------------------------");
string sign = sign(encryptbyprivatekey, privatekey);
system.out.println(sign);
system.out.println("-----------------------------------");
boolean verify = verify(encryptbyprivatekey, publickey, sign);
system.out.println(verify);
system.out.println("-----------------------------------");
byte[] decryptbypublickey = decryptbypublickey(encryptbyprivatekey, publickey);
byte[] decryptbyprivatekey = decryptbyprivatekey(encryptbypublickey, privatekey);
system.out.println(decryptbypublickey);
system.out.println("-----------------------------------");
system.out.println(decryptbyprivatekey);
}
public static final string key_algorithm = "rsa";
public static final string signature_algorithm = "md5withrsa";
private static final string public_key = "rsapublickey";
private static final string private_key = "rsaprivatekey";
public static byte[] decryptbase64(string key) {
return base64.decodebase64(key);
}
public static string encryptbase64(byte[] bytes) {
return base64.encodebase64string(bytes);
}
/**
* 用私钥对信息生成数字签名
*
* @param data
* 加密数据
* @param privatekey
* 私钥
* @return
* @throws exception
*/
public static string sign(byte[] data, string privatekey) throws exception {
// 解密由base64编码的私钥
byte[] keybytes = decryptbase64(privatekey);
// 构造pkcs8encodedkeyspec对象
pkcs8encodedkeyspec pkcs8keyspec = new pkcs8encodedkeyspec(keybytes);
// key_algorithm 指定的加密算法
keyfactory keyfactory = keyfactory.getinstance(key_algorithm);
// 取私钥匙对象
privatekey prikey = keyfactory.generateprivate(pkcs8keyspec);
// 用私钥对信息生成数字签名
signature signature = signature.getinstance(signature_algorithm);
signature.initsign(prikey);
signature.update(data);
return encryptbase64(signature.sign());
}
/**
* 校验数字签名
*
* @param data
* 加密数据
* @param publickey
* 公钥
* @param sign
* 数字签名
* @return 校验成功返回true 失败返回false
* @throws exception
*/
public static boolean verify(byte[] data, string publickey, string sign) throws exception {
// 解密由base64编码的公钥
byte[] keybytes = decryptbase64(publickey);
// 构造x509encodedkeyspec对象
x509encodedkeyspec keyspec = new x509encodedkeyspec(keybytes);
// key_algorithm 指定的加密算法
keyfactory keyfactory = keyfactory.getinstance(key_algorithm);
// 取公钥匙对象
publickey pubkey = keyfactory.generatepublic(keyspec);
signature signature = signature.getinstance(signature_algorithm);
signature.initverify(pubkey);
signature.update(data);
// 验证签名是否正常
return signature.verify(decryptbase64(sign));
}
public static byte[] decryptbyprivatekey(byte[] data, string key) throws exception {
// 对密钥解密
byte[] keybytes = decryptbase64(key);
// 取得私钥
pkcs8encodedkeyspec pkcs8keyspec = new pkcs8encodedkeyspec(keybytes);
keyfactory keyfactory = keyfactory.getinstance(key_algorithm);
key privatekey = keyfactory.generateprivate(pkcs8keyspec);
// 对数据解密
cipher cipher = cipher.getinstance(keyfactory.getalgorithm());
cipher.init(cipher.decrypt_mode, privatekey);
return cipher.dofinal(data);
}
/**
* 解密<br>
* 用私钥解密
*
* @param data
* @param key
* @return
* @throws exception
*/
public static byte[] decryptbyprivatekey(string data, string key) throws exception {
return decryptbyprivatekey(decryptbase64(data), key);
}
/**
* 解密<br>
* 用公钥解密
*
* @param data
* @param key
* @return
* @throws exception
*/
public static byte[] decryptbypublickey(byte[] data, string key) throws exception {
// 对密钥解密
byte[] keybytes = decryptbase64(key);
// 取得公钥
x509encodedkeyspec x509keyspec = new x509encodedkeyspec(keybytes);
keyfactory keyfactory = keyfactory.getinstance(key_algorithm);
key publickey = keyfactory.generatepublic(x509keyspec);
// 对数据解密
cipher cipher = cipher.getinstance(keyfactory.getalgorithm());
cipher.init(cipher.decrypt_mode, publickey);
return cipher.dofinal(data);
}
/**
* 加密<br>
* 用公钥加密
*
* @param data
* @param key
* @return
* @throws exception
*/
public static byte[] encryptbypublickey(string data, string key) throws exception {
// 对公钥解密
byte[] keybytes = decryptbase64(key);
// 取得公钥
x509encodedkeyspec x509keyspec = new x509encodedkeyspec(keybytes);
keyfactory keyfactory = keyfactory.getinstance(key_algorithm);
key publickey = keyfactory.generatepublic(x509keyspec);
// 对数据加密
cipher cipher = cipher.getinstance(keyfactory.getalgorithm());
cipher.init(cipher.encrypt_mode, publickey);
return cipher.dofinal(data.getbytes());
}
/**
* 加密<br>
* 用私钥加密
*
* @param data
* @param key
* @return
* @throws exception
*/
public static byte[] encryptbyprivatekey(byte[] data, string key) throws exception {
// 对密钥解密
byte[] keybytes = decryptbase64(key);
// 取得私钥
pkcs8encodedkeyspec pkcs8keyspec = new pkcs8encodedkeyspec(keybytes);
keyfactory keyfactory = keyfactory.getinstance(key_algorithm);
key privatekey = keyfactory.generateprivate(pkcs8keyspec);
// 对数据加密
cipher cipher = cipher.getinstance(keyfactory.getalgorithm());
cipher.init(cipher.encrypt_mode, privatekey);
return cipher.dofinal(data);
}
/**
* 取得私钥
*
* @param keymap
* @return
* @throws exception
*/
public static string getprivatekey(map<string, key> keymap) throws exception {
key key = (key) keymap.get(private_key);
return encryptbase64(key.getencoded());
}
/**
* 取得公钥
*
* @param keymap
* @return
* @throws exception
*/
public static string getpublickey(map<string, key> keymap) throws exception {
key key = keymap.get(public_key);
return encryptbase64(key.getencoded());
}
/**
* 初始化密钥
*
* @return
* @throws exception
*/
public static map<string, key> initkey() throws exception {
keypairgenerator keypairgen = keypairgenerator.getinstance(key_algorithm);
keypairgen.initialize(1024);
keypair keypair = keypairgen.generatekeypair();
map<string, key> keymap = new hashmap(2);
keymap.put(public_key, keypair.getpublic());// 公钥
keymap.put(private_key, keypair.getprivate());// 私钥
return keymap;
}
}
5.2 ecc 介绍
ecc 也是一种 非对称加密算法，主要优势是在某些情况下，它比其他的方法使用 更小的密钥，比如 rsa 加密算法，提供 相当的或更高等级 的安全级别。不过一个缺点是 加密和解密操作 的实现比其他机制 时间长 (相比 rsa 算法，该算法对 cpu 消耗严重)。
java代码实现
import net.pocrd.annotation.notthreadsafe;
import org.bouncycastle.jcajce.provider.asymmetric.ec.bcecprivatekey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.bcecpublickey;
import org.bouncycastle.jce.provider.bouncycastleprovider;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import javax.crypto.cipher;
import java.io.bytearrayoutputstream;
import java.security.keyfactory;
import java.security.security;
import java.security.signature;
import java.security.spec.pkcs8encodedkeyspec;
import java.security.spec.x509encodedkeyspec;
@notthreadsafe
public class ecchelper {
private static final logger logger = loggerfactory.getlogger(ecchelper.class);
private static final int size = 4096;
private bcecpublickey publickey;
private bcecprivatekey privatekey;
static {
security.addprovider(new bouncycastleprovider());
}
public ecchelper(string publickey, string privatekey) {
this(base64util.decode(publickey), base64util.decode(privatekey));
}
public ecchelper(byte[] publickey, byte[] privatekey) {
try {
keyfactory keyfactory = keyfactory.getinstance("ec", "bc");
if (publickey != null && publickey.length > 0) {
this.publickey = (bcecpublickey)keyfactory.generatepublic(new x509encodedkeyspec(publickey));
}
if (privatekey != null && privatekey.length > 0) {
this.privatekey = (bcecprivatekey)keyfactory.generateprivate(new pkcs8encodedkeyspec(privatekey));
}
} catch (classcastexception e) {
throw new runtimeexception("", e);
} catch (exception e) {
throw new runtimeexception(e);
}
}
public ecchelper(string publickey) {
this(base64util.decode(publickey));
}
public ecchelper(byte[] publickey) {
try {
keyfactory keyfactory = keyfactory.getinstance("ec", "bc");
if (publickey != null && publickey.length > 0) {
this.publickey = (bcecpublickey)keyfactory.generatepublic(new x509encodedkeyspec(publickey));
}
} catch (exception e) {
throw new runtimeexception(e);
}
}
public byte[] encrypt(byte[] content) {
if (publickey == null) {
throw new runtimeexception("public key is null.");
}
try {
cipher cipher = cipher.getinstance("ecies", "bc");
cipher.init(cipher.encrypt_mode, publickey);
int size = size;
bytearrayoutputstream baos = new bytearrayoutputstream((content.length + size - 1) / size * (size + 45));
int left = 0;
for (int i = 0; i < content.length; ) {
left = content.length - i;
if (left > size) {
cipher.update(content, i, size);
i += size;
} else {
cipher.update(content, i, left);
i += left;
}
baos.write(cipher.dofinal());
}
return baos.tobytearray();
} catch (exception e) {
throw new runtimeexception(e);
}
}
public byte[] decrypt(byte[] secret) {
if (privatekey == null) {
throw new runtimeexception("private key is null.");
}
try {
cipher cipher = cipher.getinstance("ecies", "bc");
cipher.init(cipher.decrypt_mode, privatekey);
int size = size + 45;
bytearrayoutputstream baos = new bytearrayoutputstream((secret.length + size + 44) / (size + 45) * size);
int left = 0;
for (int i = 0; i < secret.length; ) {
left = secret.length - i;
if (left > size) {
cipher.update(secret, i, size);
i += size;
} else {
cipher.update(secret, i, left);
i += left;
}
baos.write(cipher.dofinal());
}
return baos.tobytearray();
} catch (exception e) {
logger.error("ecc decrypt failed.", e);
}
return null;
}
public byte[] sign(byte[] content) {
if (privatekey == null) {
throw new runtimeexception("private key is null.");
}
try {
signature signature = signature.getinstance("sha1withecdsa", "bc");
signature.initsign(privatekey);
signature.update(content);
return signature.sign();
} catch (exception e) {
throw new runtimeexception(e);
}
}
public boolean verify(byte[] sign, byte[] content) {
if (publickey == null) {
throw new runtimeexception("public key is null.");
}
try {
signature signature = signature.getinstance("sha1withecdsa", "bc");
signature.initverify(publickey);
signature.update(content);
return signature.verify(sign);
} catch (exception e) {
logger.error("ecc verify failed.", e);
}
return false;
}
}
到此这篇关于总结一些java常用的加密算法的文章就介绍到这了,更多相关java加密算法内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
黄山市民网：https://www.huangshanshimin.com/
