澳门新葡亰平台游戏网站DES/3DES/AES 三种对称加密算法在 Java 中的实现

澳门新葡亰平台游戏网站 4

有两句话是这么说的:

介绍

对称加密算法是应用较早的加密算法,才具成熟。在对称加密算法中,数据发信方将公开(原始数据)和加密密钥一同经过极其加密算法管理后,使其变为复杂的加密密文发送出去。收信方收到密文后,若想解读原来的文章,则须求动用加密用过的密钥及相同算法的逆算法对密文实行解密,技能使其回复成可读明文。在对称加密算法中,使用的密钥唯有二个,发收信双方都应用那些密钥对数据举办加密和解密,那就要求解密方事情发生前必需精晓加密密钥。最近常用的加解密算法有:DES、3DES、AES、Blowfish、IDEA、RC5、RC6。

Java 常用加密算法(二State of Qatar—对称加密(DES/3DES(TripleDESState of Qatar/AES卡塔尔(قطر‎

基于“对称密钥”的加密算法重要有DES、3DES(TripleDES)、AES、RC2、RC4、RC5和Blowfish等。

代码中用到的Base64与BouncyCastleProvider的jar包可在本文末尾下载源码,从源码获取jar包。

  1. DES
    DES算法全称为Data Encryption
    Standard,即数据加密算法,它是IBM公司于1972年斟酌成功并当面登载的。DES算法的入口参数有三个:Key、Data、Mode。个中Key为8个字节共六二十个人,是DES算法的工作密钥;Data也为8个字节六16人,是要被加密或被解密的多寡;Mode为DES的行事措施,有三种:加密或解密。
    多种分组方式:EBC方式、CBC形式、CFB情势、OFB方式、CTENCORE形式。
    此中CT哈弗 形式被大规模用于 ATM 网络安全和
    IPSec应用中,相对于其余情势来说,CRT方式抱好似下特点:
    ■硬件作用:允许同时处理多块明文 / 密文。
    ■ 软件效用:允许并行计算,能够很好地使用 CPU 流水等互相本事。

    预管理:算法和加密盒的出口不相信赖明文和密文的输入,因而只要有足够的保障安全的存款和储蓄器,加密算法将单纯是一种类异或运算,那将十分大地提升吞吐量。
    ■ 随机访谈:第 i 块密文的解密不重视于第 i-1
    块密文,提供非常高的任意拜谒工夫
    ■ 可验证的安全性:能够证实 CT奔驰G级 起码和别的格局同样安全(CBC, CFB,
    OFB, …)

    轻松性:与其余方式差别,CT奇骏格局仅须要落到实处加密算法,但不须要完毕解密算法。对于
    AES 等加/解密本质上分化的算法来讲,这种简化是高大的。
    ■ 无填充,能够便捷地看成流式加密应用。
    在Java进行DES、3DES和AES三种对称加密算法时,常使用的是NoPadding(不填充)、Zeros填充(0填充)、PKCS5Padding填充。
    示例:

/**
 * DES加密工具类
 * @author mazaiting
 */
public class DESUtil {
    /**
     * 算法名称
     */
    public static final String KEY_ALGORITHM = "DES";
    /**
     * 算法名称/加密模式/填充方式
     * DES的四种工作模式:ECB(电子密码本)、CBC(加密分组链接)、
     * CFB(加密反馈模式)、OFB(输出反馈)
     * 当前无填充的情况:
     *      加密数据必须为8的倍数,密钥输入必须为16的倍数
     *  使用
        String source = "abcdefgh";// 为8位的倍数
        String key = "A1B2C3D4E5F60708";// 为16位的倍数

        String encryptData = DESUtil.encrypt(source, key);
        System.out.println("加密后: " + encryptData);

        String decryptData = DESUtil.decrypt(encryptData, key);
        System.out.println("解密后: " + decryptData);
     */
    public static final String CIPHER_ALGORITHM_DES_ECB_NOPADDING = "DES/ECB/NoPadding";
    /**
     * DES/CBC/PKCS5Padding
     * PKCS5Padding填充时:
     *      加密数据无位数控制,密钥输入必须为16的倍数
     *  使用
        String source = "abcdefgh";// 无需控制位数
        String key = "A1B2C3D4E5F60708";// 为16位的倍数

        String encryptData = DESUtil.encrypt(source, key);
        System.out.println("加密后: " + encryptData);

        String decryptData = DESUtil.decrypt(encryptData, key);
        System.out.println("解密后: " + decryptData);

     */
    public static final String CIPHER_ALGORITHM_DES_ECB_PKCS5_PADDING = "DES/ECB/PKCS5Padding";

    /**
     * 加密数据
     * @param data 待加密的数据--8位
     * @param key 密钥--16位
     * @return 加密后的数据
     */
    public static String encrypt(String data, String key) {
        try {
            // 获得一个密钥
            Key deskey = keyGenerator(key);
            // 实例化一个Cipher(密码)对象,用于完成加密操作
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM_DES_ECB_PKCS5_PADDING);
            SecureRandom random = new SecureRandom();
            // 初始化Cipher对象,设置为加密模式
            cipher.init(Cipher.ENCRYPT_MODE, deskey, random);
            byte[] bytes = data.getBytes();
            // 执行加密操作
            byte[] results = cipher.doFinal(bytes);
            return Base64.encodeBase64String(results);
        } catch (InvalidKeyException e) {
            return "无效KEY"; // 无效KEY
        } catch (NoSuchAlgorithmException e) {
            return "无效算法名称"; // 无效算法名称
        } catch (InvalidKeySpecException e) {
            return "无效KeySpec"; // 无效KeySpec
        } catch (NoSuchPaddingException e) {
            return "无效算法名称"; // 无效算法名称
        } catch (IllegalBlockSizeException e) {
            return "无效字节"; // 无效字节
        } catch (BadPaddingException e) {
            return "解析异常"; // 解析异常
        }
    }

    /**
     * 解密数据
     * @param data 待解密数据
     * @param key 密钥
     * @return 解密后的数据
     */
    public static String decrypt(String data, String key) {
        try {
            Key desKey = keyGenerator(key);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM_DES_ECB_PKCS5_PADDING);
            // 初始化Cipher对象,设置为解密模式
            cipher.init(Cipher.DECRYPT_MODE, desKey);
            // 执行解密操作
            byte[] decBytes = cipher.doFinal(Base64.decodeBase64(data));
            return new String(decBytes,"UTF-8");
        } catch (InvalidKeyException e) {
            return "无效KEY"; // 无效KEY
        } catch (NoSuchAlgorithmException e) {
            return "无效算法名称"; // 无效算法名称
        } catch (InvalidKeySpecException e) {
            return "无效KeySpec"; // 无效KeySpec
        } catch (NoSuchPaddingException e) {
            return "无效算法名称"; // 无效算法名称
        } catch (IllegalBlockSizeException e) {
            return "无效字节"; // 无效字节
        } catch (BadPaddingException e) {
            return "解析异常"; // 解析异常
        } catch (UnsupportedEncodingException e) {
            return "编码异常"; // 编码异常
        }
    }

    /**
     * 生成密钥key对象
     * @param key 密钥字符串
     * @return 密钥对象
     * @throws InvalidKeyException 无效的key
     * @throws NoSuchAlgorithmException 算法名称未发现
     * @throws InvalidKeySpecException 无效的KeySpec
     */
    private static Key keyGenerator(String key) throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] input = hexString2Bytes(key);
        DESKeySpec desKey = new DESKeySpec(input);
        // 创建一个密钥工厂,然后用它把DESKeySpec转化
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
        // 获得一个密钥
        SecretKey secretKey = keyFactory.generateSecret(desKey);
        return secretKey;
    }

    /**
     * 从十六进制字符串到字节数组转化
     * @param key 密钥
     */
    private static byte[] hexString2Bytes(String key) {
        byte[] b = new byte[key.length()/2];
        int j = 0;
        for (int i = 0; i < b.length; i++) {
            char c0 = key.charAt(j++);
            char c1 = key.charAt(j++);
            // c0做b[i]的高字节,c1做低字节
            b[i] = (byte) ((parse(c0)<<4)|parse(c1));
        }
        return b;
    }

    /**
     * 将字符转换为int值
     * @param c 要转化的字符
     * @return ASCII码值
     */
    private static int parse(char c) {
        if (c >= 'a') {
            return (c - 'a' + 10) & 0x0f;
        }
        if (c >= 'A') {
            return (c - 'A' + 10) & 0x0f;
        }
        return (c - '0') & 0x0f;
    }   
}
  1. 3-DES
    3DES(或称为Triple
    DES)是三重数码加密算法(TDEA,Triple
    Data Encryption
    Algorithm)块密码的通称。它也等于是对各样数据块利用三遍DES加密算法。由于Computer运算技艺的加强,原版DES密码的密钥长度变得轻易被暴力破解;3DES就是设计用来提供一种相对轻易的措施,即经过增加DES的密钥长度来幸免形似的大张讨伐,并非安排一种全新的块密码算法。
    示例:

/**
 * 3-DES加密工具类
 * @author mazaiting
 */
public class ThreeDESUtil {
    /**
     * 算法名称
     */
    public static final String KEY_ALGORITHM = "desede";
    /**
     * 算法名称/加密模式/填充方式
     * 
        String source = "abcdefgh"; // 无填充情况下,长度必须为8的倍数
        String key = "6C4E60E55552386C759569836DC0F83869836DC0F838C0F7";// 长度必须大于等于48
        System.out.println(key.length());
        String encryptData = ThreeDESUtil.tDesEncryptCBC(source, key);
        System.out.println("加密后: " + encryptData);

        String decryptData = ThreeDESUtil.tDesDecryptCBC(encryptData, key);
        System.out.println("解密后: " + decryptData);  
     */
    public static final String CIPHER_ALGORITHM = "desede/CBC/NoPadding";
    /**
     * IvParameterSpec参数
     */
    public static final byte[] keyiv = { 1, 2, 3, 4, 5, 6, 7, 8 };

    /**
     * CBC加密
     * @param data 明文
     * @param key 密钥
     * @return Base64编码的密文
     */
    public static String tDesEncryptCBC(String data, String key){
        try {
            // 添加一个安全提供者
            Security.addProvider(new BouncyCastleProvider());
            // 获得密钥
            Key desKey = keyGenerator(key);
            // 获取密码实例
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            IvParameterSpec ips = new IvParameterSpec(keyiv);
            // 初始化密码
            cipher.init(Cipher.ENCRYPT_MODE, desKey, ips);
            // 执行加密
            byte[] bytes = cipher.doFinal(data.getBytes("UTF-8"));
            return Base64.encodeBase64String(bytes);
        } catch (InvalidKeyException e) {
            return "无效KEY"; // 无效KEY
        } catch (NoSuchAlgorithmException e) {
            return "无效算法名称"; // 无效算法名称
        } catch (InvalidKeySpecException e) {
            return "无效KeySpec"; // 无效KeySpec
        } catch (NoSuchPaddingException e) {
            return "无效算法名称"; // 无效算法名称
        } catch (IllegalBlockSizeException e) {
            return "无效字节"; // 无效字节
        } catch (BadPaddingException e) {
            return "解析异常"; // 解析异常
        } catch (UnsupportedEncodingException e) {
            return "编码异常"; // 编码异常
        } catch (InvalidAlgorithmParameterException e) {
            return "摘要参数异常"; // 摘要参数异常
        }
    }

    /**
     * CBC解密
     * @param data Base64编码的密文
     * @param key 密钥
     * @return
     */
    public static String tDesDecryptCBC(String data, String key) {
        try {
            Key desKey = keyGenerator(key);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            IvParameterSpec ips = new IvParameterSpec(keyiv);
            cipher.init(Cipher.DECRYPT_MODE, desKey, ips);
            byte[] bytes = cipher.doFinal(Base64.decodeBase64(data));
            return new String(bytes, "UTF-8");
        } catch (InvalidKeyException e) {
            return "无效KEY"; // 无效KEY
        } catch (NoSuchAlgorithmException e) {
            return "无效算法名称"; // 无效算法名称
        } catch (InvalidKeySpecException e) {
            return "无效KeySpec"; // 无效KeySpec
        } catch (NoSuchPaddingException e) {
            return "无效算法名称"; // 无效算法名称
        } catch (IllegalBlockSizeException e) {
            return "无效字节"; // 无效字节
        } catch (BadPaddingException e) {
            return "解析异常"; // 解析异常
        } catch (UnsupportedEncodingException e) {
            return "编码异常"; // 编码异常
        } catch (InvalidAlgorithmParameterException e) {
            return "摘要参数异常"; // 摘要参数异常
        }
    }


    /**
     * 生成密钥key对象
     * @param key 密钥字符串
     * @return 密钥对象
     * @throws InvalidKeyException 无效的key
     * @throws NoSuchAlgorithmException 算法名称未发现
     * @throws InvalidKeySpecException 无效的KeySpec
     */
    private static Key keyGenerator(String key) throws InvalidKeyException, NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] input = hexString2Bytes(key);
        DESedeKeySpec desKey = new DESedeKeySpec(input);
        // 创建一个密钥工厂,然后用它把DESKeySpec转化
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
        // 获得一个密钥
        SecretKey secretKey = keyFactory.generateSecret(desKey);
        return secretKey;
    }

    /**
     * 从十六进制字符串到字节数组转化
     * @param key 密钥
     */
    private static byte[] hexString2Bytes(String key) {
        byte[] b = new byte[key.length()/2];
        int j = 0;
        for (int i = 0; i < b.length; i++) {
            char c0 = key.charAt(j++);
            char c1 = key.charAt(j++);
            // c0做b[i]的高字节,c1做低字节
            b[i] = (byte) ((parse(c0)<<4)|parse(c1));
        }
        return b;
    }

    /**
     * 将字符转换为int值
     * @param c 要转化的字符
     * @return ASCII码值
     */
    private static int parse(char c) {
        if (c >= 'a') {
            return (c - 'a' + 10) & 0x0f;
        }
        if (c >= 'A') {
            return (c - 'A' + 10) & 0x0f;
        }
        return (c - '0') & 0x0f;
    }   

}
  1. AES加密
    AES是分组密钥,算法输入1二十六位数据,密钥长度也是1贰十八位。

/**
 * AES加密工具类
 * @author mazaiting
 */
public class AESUtil {
    /**
     * 算法名称
     */
    public static final String KEY_ALGORITHM = "AES";
    /**
     * 算法
     * 使用:
        String source = "mazaiting";
        String key = "123456";

        String encryptString = AESUtil.encrypt(source, key);
        System.out.println("加密后: " + encryptString);

        String decryptString = AESUtil.decrypt(encryptString, key);
        System.out.println("解密后: " + decryptString);
     */
    public static final String CIPHER_ALGORITHM = "AES";


    /**
     * 加密数据
     * @param data 待加密内容
     * @param key 加密的密钥
     * @return 加密后的数据
     */
    public static String encrypt(String data, String key) {
        try {
            // 获得密钥
            Key deskey = keyGenerator(key);
            // 实例化一个密码对象
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            // 密码初始化
            cipher.init(Cipher.ENCRYPT_MODE, deskey);
            // 执行加密
            byte[] bytes = cipher.doFinal(data.getBytes("UTF-8"));
            return Base64.encodeBase64String(bytes);
        } catch (NoSuchAlgorithmException e) {
            return "加密名称异常"; // 获取加密名称异常
        } catch (UnsupportedEncodingException e) {
            return "未知编码格式"; // 未知编码格式 
        } catch (InvalidKeyException e) {
            return "无效Key"; // 无效Key
        } catch (NoSuchPaddingException e) {
            return "无效密码算法"; // 无效密码算法
        } catch (IllegalBlockSizeException e) {
            return "无效字节"; // 无效字节
        } catch (BadPaddingException e) {
            return "解析异常"; // 解析异常
        }
    }

    /**
     * 解密数据
     * @param data 待解密的内容
     * @param key 解密的密钥
     * @return
     */
    public static String decrypt(String data, String key){
        try {
            // 生成密钥
            Key kGen = keyGenerator(key);
            // 实例化密码对象
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            // 初始化密码对象
            cipher.init(Cipher.DECRYPT_MODE, kGen);
            // 执行解密
            byte[] bytes = cipher.doFinal(Base64.decodeBase64(data));
            return new String(bytes, "UTF-8");
        } catch (NoSuchAlgorithmException e) {
            return "加密名称异常"; // 获取加密名称异常
        } catch (UnsupportedEncodingException e) {
            return "未知编码格式"; // 未知编码格式 
        } catch (InvalidKeyException e) {
            return "无效Key"; // 无效Key
        } catch (NoSuchPaddingException e) {
            return "无效密码算法"; // 无效密码算法
        } catch (IllegalBlockSizeException e) {
            return "无效字节"; // 无效字节
        } catch (BadPaddingException e) {
            return "解析异常"; // 解析异常
        }
    }

    /**
     * 获取密钥
     * @param key 密钥字符串
     * @return 返回一个密钥
     * @throws NoSuchAlgorithmException
     * @throws UnsupportedEncodingException
     */
    private static Key keyGenerator(String key) throws NoSuchAlgorithmException, UnsupportedEncodingException {
        KeyGenerator kGen = KeyGenerator.getInstance(KEY_ALGORITHM);
        kGen.init(128, new SecureRandom(hexString2Bytes(key)));
        SecretKey secretKey = kGen.generateKey();
        byte[] encoded = secretKey.getEncoded();
        SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, KEY_ALGORITHM);
        return secretKeySpec;
    }


    /**
     * 从十六进制字符串到字节数组转化
     * @param key 密钥
     */
    private static byte[] hexString2Bytes(String key) {
        byte[] b = new byte[key.length()/2];
        int j = 0;
        for (int i = 0; i < b.length; i++) {
            char c0 = key.charAt(j++);
            char c1 = key.charAt(j++);
            // c0做b[i]的高字节,c1做低字节
            b[i] = (byte) ((parse(c0)<<4)|parse(c1));
        }
        return b;
    }

    /**
     * 将字符转换为int值
     * @param c 要转化的字符
     * @return ASCII码值
     */
    private static int parse(char c) {
        if (c >= 'a') {
            return (c - 'a' + 10) & 0x0f;
        }
        if (c >= 'A') {
            return (c - 'A' + 10) & 0x0f;
        }
        return (c - '0') & 0x0f;
    }   
}

代码下载

1)算法和数据布局就是编制程序的三个最首要片段,你若失掉了算法和数据布局,你就把全体都失去了。
2)编制程序便是算法和数据构造,算法和数据布局是编制程序的魂魄。

二种常用算法介绍

对称加密算法用来对敏感数据等音信实行加密,常用的算法包含:

DES(Data Encryption
Standard):数据加密标准,速度很快,适用于加密大批量数据的场面。
3DES(Triple
DES):是基于DES,对一块数据用多少个不相同的密钥进行一回加密,强度更加高。
AES(Advanced Encryption
Standard):高档加密规范,是下一代的加密算法标准,速度快,安全等级高;

瞩目,那可不是作者说的,是比超级多程序员计算的,话说的很实际也很深邃,若想持久可持续发展,多钻探算法依旧很有供给的,昨天自家给我们说说加密算法中的对称加密算法,何况这里将教会大家对称加密算法的编制程序使用。包罗DES、3DES和AES三种对称加密算法的编制程序使用,干货满满。

1、DES算法

数码加密标准DES(Data Encryption
斯坦dard卡塔尔(قطر‎是一种分组加密算法,以陆十五个人为分组,基于伍十七位密钥来对数据开展加密。

澳门新葡亰平台游戏网站 1

算法描述:

DES是一种规范的块密码—一种将牢固长度的平文通过一多种复杂的操作产生相同长度的密文的算法。对DES来讲,块长度为陆15个人。同一时间,DES使用密钥来自定义转变进度,因而算法以为独有全数加密所用的密钥的客商才具解密密文。密钥表面上是陆拾一人的,然则独有此中的伍十几人被实际用来算法,别的8位能够被用于奇偶校验,并在算法中被撇下。由此,DES的低价密钥长度为55人,平时称DES的密钥长度为伍20个人。来源:数据加密规范

1.对称密码算法

对称密码算法是前天利用范围最广,使用作用最高的加密算法。它不只使用于软件行当,在硬件行当同样流行。各样根底设备凡是涉及到安全需求,都会先行思忖对称加密算法。

对称密码算法的加密密钥和平解决密密钥相通,对于大多数对称密码算法,加解密进程互逆。

(1)加解密通讯模型

澳门新葡亰平台游戏网站 2

(2)特点:算法公开、总结量小、加密速度快、加密效用高

(3)劣势:双方都选取相似密钥,安全性得不到保证

对称密码有流密码和分组密码二种,但是今后大面积运用的是分组密码:

(4)分组密码专门的学问情势

  • 1)ECB:电子密码本(最常用的,每一趟加密均产生独立的密文分组,并且对别的的密文分组不会时有发生耳濡目染,也正是同样的公然加密后发出雷同的密文)
  • 2)CBC:密文链接(常用的,明文加密前需求先和前面包车型地铁密文举行异或运算,也正是大同小异的公开加密后发出不一致的密文)
  • 3)CFB:密文反馈
  • 4)OFB:输出反馈
  • 5)CTR:计数器

那多样工作格局重若是密码学中算法在拓展推制片人算的时候所使用到的。

6.分组密码填充方式

  • 1)NoPadding:无填充
  • 2)PKCS5Padding:
  • 3)ISO10126Padding:

7.常用对称密码:

  • 1)DES(Data Encryption Standard,数据加密规范)
  • 2)3DES(Triple DES、DESede,实行了三重DES加密的算法)
  • 3)AES(Advanced Encryption
    Standard,高档数据加密标准,AES算法能够有效对抗针对DES的笔伐口诛算法)

先来看一下这两种算法的简易比较:

算法 密钥长度 默认密钥长度 工作模式 填充方式
DES 56 56 ECB、CBC、PCBC、CTR、CTS、CFB、CFB8-CFB128、OFB、OFB8-OFB128 NoPadding、PKCS5Padding、ISO10126Padding
3DES 112、168 168 ECB、CBC、PCBC、CTR、CTS、CFB、CFB8-CFB128、OFB、OFB8-OFB128 NoPadding、PKCS5Padding、ISO10126Padding
AES 128、192、256 128 ECB、CBC、PCBC、CTR、CTS、CFB、CFB8-CFB128、OFB、OFB8-OFB128 NoPadding、PKCS5Padding、ISO10126Padding

下边大家看怎么样利用 DES / 3DES / AES 三种算法完结 对称加密:

算法原理:

DES算法把61位的公开输入块变为69人的密文输出块,它所运用的密钥也是63个人,其算法主要分为两步:

  1. 先导置换
    其职能是把输入的61个人数据块按位重新整合,并把出口分为L0、Highlander0两片段,每部分各长三十一个人,其置换准则为将输入的第58人换到第壹个人,第54个人换成第1位……依此类推,最终一个人是原先的第7位。L0、Rubicon0则是交换一下地方输出后的两局地,L0是出口的左叁拾叁个人,Highlander0是右叁拾一个人,例:设置换前的输入值为D1D2D3……D64,则透过起始置换后的结果为:L0=D58D50……D8;帕杰罗0=D57D49……D7。
  2. 逆置换
    经过17次迭代运算后,得到L16、Escort16,将此看作输入,实行逆置换,逆置换适逢其会是从头置换的逆运算,因而即获取密文输出。

澳门新葡亰平台游戏网站 3

DES算法流程图

如上为DES算法流程图,详细的DES加密进程参考:des算法和DES加密解密算法详细明白。

2.DES算法

1.DES:数据加密规范,是对称加密算法领域中的规范算法

2.特征:密钥偏短(五十几人)、生命周期短(制止被破解)

3.Java实现

1)生成密钥

KeyGenerator keyGen = KeyGenerator.getInstance("DES");//密钥生成器
keyGen.init(56);//初始化密钥生成器
SecretKey secretKey = keyGen.generateKey();//生成密钥
byte[] key = secretKey.getEncoded();//密钥字节数组

2)加密

SecretKey secretKey = new SecretKeySpec(key, "DES");//恢复密钥
Cipher cipher = Cipher.getInstance("DES");//Cipher完成加密或解密工作类
cipher.init(Cipher.ENCRYPT_MODE, secretKey);//对Cipher初始化,加密模式
byte[] cipherByte = cipher.doFinal(data);//加密data

3)解密

SecretKey secretKey = new SecretKeySpec(key, "DES");//恢复密钥
Cipher cipher = Cipher.getInstance("DES");//Cipher完成加密或解密工作类
cipher.init(Cipher.DECRYPT_MODE, secretKey);//对Cipher初始化,解密模式
byte[] cipherByte = cipher.doFinal(data);//解密data

我们能够开采,加密解密大家只是设置了不一致的方式而已。

2、3DES算法

3DES(或称为Triple DES)是三重数据加密算法(TDEA,Triple Data Encryption
Algorithm)块密码的通称。它一定于是对每一种数据块应用一回DES加密算法。由于计算机械运输算本事的升高,原版DES密码的密钥长度变得轻巧被暴力破解;3DES正是设计用来提供一种绝对简便易行的格局,即因而增添DES的密钥长度来制止近似的口诛笔伐,并不是兼备一种全新的块密码算法。来源三重数据加密算法

3.3DES算法

1.3DES:将密钥长度增加到1十一个人或1陆拾伍位,通过扩展迭代次数进步安全性

2.劣点:管理速度比较慢、密钥总计时间较长、加密成效不高

3.Java实现

1)生成密钥

KeyGenerator keyGen = KeyGenerator.getInstance("DESede");//密钥生成器
keyGen.init(168);  //可指定密钥长度为112或168,默认为168   
SecretKey secretKey = keyGen.generateKey();//生成密钥
byte[] key = secretKey.getEncoded();//密钥字节数组

2)3DES加密

SecretKey secretKey = new SecretKeySpec(key, "DESede");//恢复密钥
Cipher cipher = Cipher.getInstance("DESede");//Cipher完成加密或解密工作类
cipher.init(Cipher.ENCRYPT_MODE, secretKey);//对Cipher初始化,解密模式
byte[] cipherByte = cipher.doFinal(data);//加密data

3)3DES解密

SecretKey secretKey = new SecretKeySpec(key, "DESede");//恢复密钥
Cipher cipher = Cipher.getInstance("DESede");//Cipher完成加密或解密工作类
cipher.init(Cipher.DECRYPT_MODE, secretKey);//对Cipher初始化,解密模式
byte[] cipherByte = cipher.doFinal(data);//解密data
算法原理

使用3条55个人的密钥对 数据开展贰遍加密。3DES(即Triple
DES)是DES向AES过渡的加密算法(壹玖玖柒年,NIST将3-DES钦命为过渡的加密规范卡塔尔国。
其具体贯彻如下:设Ek(卡塔尔(قطر‎和Dk(State of Qatar代表DES算法的加密和平解决密进程,K代表DES算法使用的密钥,P代申明文,C代表密文,那样:
3DES加密进度为:C=Ek3(Dk2(Ek1(P)))
3DES解密进度为:P=Dk1(EK2(Dk3(C)))

4.AES算法(推荐使用)

1.AES:高等数据加密标准,能够行得通对抗已知的针对DES算法的具备攻击

2.特色:密钥创建刻间短、灵敏性好、内部存款和储蓄器须要低、安全性高

3.Java实现

1)生成密钥

KeyGenerator keyGen = KeyGenerator.getInstance("AES");//密钥生成器
keygen.init(128);  //默认128,获得无政策权限后可为192或256
SecretKey secretKey = keyGen.generateKey();//生成密钥
byte[] key = secretKey.getEncoded();//密钥字节数组

2)AES加密

SecretKey secretKey = new SecretKeySpec(key, "AES");//恢复密钥
Cipher cipher = Cipher.getInstance("AES");//Cipher完成加密或解密工作类
cipher.init(Cipher.ENCRYPT_MODE, secretKey);//对Cipher初始化,解密模式
byte[] cipherByte = cipher.doFinal(data);//加密data

3)AES解密

SecretKey secretKey = new SecretKeySpec(key, "AES");//恢复密钥
Cipher cipher = Cipher.getInstance("AES");//Cipher完成加密或解密工作类
cipher.init(Cipher.DECRYPT_MODE, secretKey);//对Cipher初始化,解密模式
byte[] cipherByte = cipher.doFinal(data);//解密data

为了方便使用,笔者对DES / 3DES / AES
二种算法进行了工具类编写,地址: (新增DES/3DES/AES工具类)。

3、AES算法

二〇〇三年一月,NIST(美利哥国标和本事术家组织会)发布通过从15种侯选算法中选出的一项新的密匙加密规范。Rijndael被入选成为今后的AES。
Rijndael是在 1998 年下3个月,由商量员 Joan Daemen 和 Vincent Rijmen
创造的。AES 正日益成为加密各类款式的电子数据的实在标准。
U.S.A.正规与工夫研商院 (NIST卡塔尔 于 2000 年 5 月 26 日制定了新的尖端加密规范(AESState of Qatar 规范。

算法原理

澳门新葡亰平台游戏网站 4

AES加解密的流程图

AES
算法基于排列和交流运算。AES加密进程涉及到4种操作:字节替代(SubBytes)、行活动(ShiftRows)、列混淆(MixColumns)和轮密钥加(AddRoundKey)。从上海体育场面能够看看:

1)解密进程的每一步分别对应操作的逆操作
2)加解密全体操作的依次适逢其时是相反的。便是出于这两点有限支撑精晓密能够科学地光复明文。加解密中每轮的密钥分别由初叶密钥扩张赢得。算法中16字节的当众、密文和轮密钥都是三个4×4的矩阵表示。

AES 是八个迭代的、对称密钥分组的密码,它可以使用128、192 和 2伍十几个人密钥,並且用 1二十四人(16字节)分组加密和平解决密数据。与公私密钥密码使用密钥对两样,对称密钥密码使用相通的密钥加密和平解决密数据。通过分组密码重临的加密数据的位数与输入数据一致。迭代加密应用八个循环构造,在该循环中重复置换和替换输入数据。算法详细经过参考:密码算法详整——AES及高档加密标准

AES与3DES的比较

**算法名称****** **算法类型****** **密钥长度****** **速度****** **解密时间(建设机器每秒尝试****255****个密钥)****** **资源消耗******
AES 对称block密码 128、192、256位 1490000亿年
3DES 对称feistel密码 112位或168位 46亿年

参照他事他说加以考查作品:
常用加密算法的Java完结计算(二State of Qatar
SSL常见加密算法

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图