码迷,mamicode.com
首页 > 编程语言 > 详细

对称加解密算法解析

时间:2016-12-19 08:46:31      阅读:308      评论:0      收藏:0      [点我收藏+]

标签:size   ctr   indexof   keygen   substr   this   his   home   tty   

一、概述

cryptosystem密码学系统分为私钥系统及公钥系统。

私钥系统:指加解密双方事先做了私有信息约定,采用对称密钥算法; 
公钥系统:指发送方用公开凭证对数据进行加密后传输,接收方使用私有凭证进行解密,采用非对称密钥算法;

对称加密分类

流加密(stream cipher),加密和解密双方使用相同伪随机加密数据流,一般都是逐位异或或者随机置换数据内容,常见的流加密算法如RC4。 
分组加密加密(block cipher),也叫块加密,将明文分成多个等长的模块(block),使用确定的算法和对称密钥对每组分别加密解密。 
高级的分组加密建立以迭代的方式产生密文,每轮产生的密文都使用不同的子密钥,而子密钥生成自原始密钥。 
数据加密中分组方式成为分组模式,如ECB;当加密中数据长度不足以满足分组时需要进行填充,此时采用的方式对应填充算法,如PKCS5Padding。

二、对称密钥算法

DES

Data Encryption Standard,数据加密标准,由IBM研究设计。 
密钥长度8字节,有效位56bit;其中,分组为64bit=8字节。

3DES

DES像 AES过渡的加密标准。 
由3个64bit的DES密钥对数据进行三次加密。 
密钥长度为24字节,有效位168bit。

AES

Advanced Encryption Standard,高级加密标准。 
包括AES-128;AES-192;AES-256算法,分组大小为128bit=16字节。

三、密码分组模式

1 ECB

Electronic Code Book,电码本模式 
相同分组输出相同的密钥,简单且利于并行运算,但无法隐藏模式,也容易招致攻击

技术分享

2 CBC

Cipher Block Chaining,密文分组链模式 
需要初始化向量IV(长度与分组大小相同),第一组的密文与第二组数据XOR计算后再进行加密产生第二组密文 
安全性较好,TLS、IPSec等标准的推荐模式,但不利于并行运算

技术分享

3 CFB

Cipher Feedback,密文反馈模式 
技术分享

4 OFB

Output Feedback (OFB),输出反馈模式 
技术分享

三、填充算法

1 NoPadding,无填充算法,通常要求数据满足分组长度要求; 
2 ZerosPadding,全部填充为0; 
3 PKCS5Padding,填充字节数; 
4 others…

DES像 AES过渡的加密标准 
由3个64bit的DES密钥对数据进行三次加密 
密钥长度为24字节,有效位168bit

 

四、代码示例

/**
 * 加密工具类
 * 
 * <pre>
 * AES支持128/192/256,取决于密钥长度(与位数对应)
 * DES密钥长度8字节
 * 3DES密钥长度24字节
 * 
 * 采用CBC 需指定初始向量IV,长度与分组大小相同
 * DES为8字节;AES为16字节
 * 
 * </pre>
 */
public class Crypto {
    static {
        // add bouncycastle support for md4 etc..
        Security.addProvider(new BouncyCastleProvider());
    }
    public static enum CryptType {
        DES_ECB_PKCS5("DES/ECB/PKCS5Padding"),
        DES_CBC_PKCS5("DES/CBC/PKCS5Padding", 8),
        DESede_ECB_PKCS5("DESede/ECB/PKCS5Padding"),
        DESede_CBC_PKCS5("DESede/CBC/PKCS5Padding", 8),
        AES_ECB_PKCS5("AES/CBC/PKCS5Padding", 16),
        AES_CBC_PKCS5("AES/CBC/PKCS5Padding", 16),
        AES_CBC_PKCS7("AES/CBC/PKCS7Padding", 16);
        public final String algorithm;
        public final String keyAlg;
        public final int ivlen;
        private CryptType(String algorithm, int ivlen) {
            this.algorithm = algorithm;
            this.keyAlg = this.algorithm.substring(0, this.algorithm.indexOf(‘/‘));
            this.ivlen = ivlen;
        }
        private CryptType(String algorithm) {
            this(algorithm, 0);
        }
        @Override
        public String toString() {
            return this.algorithm;
        }
    }
    /**
     * Initialize the key
     * 
     * @param type
     * @return
     */
    public static String initKey(CryptType type) {
        try {
            KeyGenerator generator = KeyGenerator.getInstance(type.keyAlg);
            SecretKey secretKey = generator.generateKey();
            byte[] key = secretKey.getEncoded();
            return Codec.byteToHexString(key);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * generate default ivparam for type
     * 
     * @return
     */
    public static byte[] generateDefaultIv(CryptType type) {
        byte[] iv = new byte[type.ivlen];
        for (int i = 0; i < iv.length; i++) {
            iv[i] = 0x01;
        }
        return iv;
    }
    /**
     * Encrypt the value with the encryption standard.
     * 
     * @param value
     *            raw string
     * @param key
     *            in hex format
     * @param iv
     *            in hex format if exist
     * @param type
     * @return result in hex format
     */
    public static String encrypt(String value, String key, String iv, CryptType type) {
        byte[] dvalue;
        try {
            dvalue = value.getBytes("utf-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
        byte[] dkey = Codec.hexStringToByte(key);
        byte[] div = null;
        if (iv != null && iv.length() > 0) {
            div = Codec.hexStringToByte(iv);
        }
        byte[] result = encrypt(dvalue, dkey, div, type);
        return Codec.byteToHexString(result);
    }
    /**
     * Encrypt the value with the encryption standard.
     * 
     * <pre>
     * key must have the corresponding length.
     * 
     * if use cbc mode which need iv param, the iv must not be null,
     * and iv data length is 16 for aes, 8 for des
     * 
     * </pre>
     * 
     * @param value
     * @param key
     * @param iv
     * @return
     */
    public static byte[] encrypt(byte[] value, byte[] key, byte[] iv, CryptType type) {
        try {
            SecretKeySpec skeySpec = new SecretKeySpec(key, type.keyAlg);
            Cipher cipher = Cipher.getInstance(type.algorithm);
            IvParameterSpec ivparamSpec = null;
            if (iv != null) {
                ivparamSpec = new IvParameterSpec(iv);
            }
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec, ivparamSpec);
            return cipher.doFinal(value);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
    /**
     * Encrypt the value with the encryption standard.
     * 
     * @param value
     *            encoded data in hex format
     * @param key
     *            in hex format
     * @param iv
     *            in hex format if exist
     * @param type
     * @return result raw string
     */
    public static String decrypt(String value, String key, String iv, CryptType type) {
        byte[] dvalue = Codec.hexStringToByte(value);
        byte[] dkey = Codec.hexStringToByte(key);
        byte[] div = null;
        if (iv != null && iv.length() > 0) {
            div = Codec.hexStringToByte(iv);
        }
        byte[] result = decrypt(dvalue, dkey, div, type);
        try {
            return new String(result, "utf-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * Decrypt the value with the encryption standard.
     * 
     * <pre>
     * key must have the corresponding length.
     * 
     * if use cbc mode which need iv param, the iv must not be null,
     * and iv data length is 16 for aes, 8 for des
     * 
     * </pre>
     * 
     * @param value
     * @param key
     * @param iv
     * @param type
     * @return
     */
    public static byte[] decrypt(byte[] value, byte[] key, byte[] iv, CryptType type) {
        try {
            SecretKeySpec skeySpec = new SecretKeySpec(key, type.keyAlg);
            Cipher cipher = Cipher.getInstance(type.algorithm);
            IvParameterSpec ivparamSpec = null;
            if (iv != null) {
                ivparamSpec = new IvParameterSpec(iv);
            }
            cipher.init(Cipher.DECRYPT_MODE, skeySpec, ivparamSpec);
            return cipher.doFinal(value);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }
}

 

key 长度受限问题

Exception in thread "main" java.security.InvalidKeyException: Illegal key size or default parameters

问题原因:因软件出版政策原因,默认 jdk 环境做了限制,当AES加密密钥大于128位时,会出现以上异常; 
解决办法:下载JCE扩展,替换至 ${java_home}/jre/lib/security 
http://www.oracle.com/technetwork/java/javase/downloads/index.html

五、参考文档:

http://m.blog.csdn.net/article/details?id=51066799 
http://www.blogjava.net/amigoxie/archive/2014/07/06/415503.html

对称加解密算法解析

标签:size   ctr   indexof   keygen   substr   this   his   home   tty   

原文地址:http://www.cnblogs.com/littleatp/p/6196092.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!