多种对称加密算法实现及应用 | 数据加密学堂

1.对称加密算法概述

对称加密算法是应用较早的加密算法,技术成熟。在对称加密算法中,数据发信方将明文和加密密钥一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去。收信方收到密文后,若想解读原文,则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密,才能使其恢复成可读明文。

在对称加密算法中,使用的密钥只有一个,发收信双方都使用这个密钥对数据进行加密和解密,这就要求解密方事先必须知道加密密钥。

对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。

不足之处是,交易双方都使用同样钥匙,安全性得不到保证。

在计算机系统中广泛使用的对称加密算法有DES和IDEA等。因为DES近年来屡屡被破解,所以,美国国家标准局倡导的AES即将作为新标准取代DES。

2.对称加密算法-DES

DES算法为密码体制中的对称密码体制,又被称为美国数据加密标准,是1972年美国IBM公司研制的对称密码体制加密算法。

明文按64位进行分组,密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位, 使得每个密钥都有奇数个1)分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

引入Bouncy Castle依赖:


  1. <dependency> 
  2.    <groupId>org.bouncycastle</groupId> 
  3.    <artifactId>bcprov-jdk15</artifactId> 
  4.    <version>1.46</version> 
  5. </dependency> 

引入Commons Codec依赖:


  1. <dependency> 
  2.    <groupId>commons-codec</groupId> 
  3.    <artifactId>commons-codec</artifactId> 
  4.    <version>1.10</version> 
  5. </dependency> 

Java代码实现:


  1. import java.security.Key
  2. import java.security.Security; 
  3. import javax.crypto.Cipher; 
  4. import javax.crypto.KeyGenerator; 
  5. import javax.crypto.SecretKey; 
  6. import javax.crypto.SecretKeyFactory; 
  7. import javax.crypto.spec.DESKeySpec; 
  8. import org.apache.commons.codec.binary.Hex; 
  9. import org.bouncycastle.jce.provider.BouncyCastleProvider; 
  10.  
  11. public class DES { 
  12.  
  13.   public static final String src = "des test"
  14.  
  15.   public static void main(String[] args) { 
  16.     jdkDES(); 
  17.     bcDES(); 
  18.   } 
  19.  
  20.   // 用jdk实现: 
  21.   public static void jdkDES() { 
  22.     try { 
  23.       // 生成KEY 
  24.       KeyGenerator keyGenerator = KeyGenerator.getInstance("DES"); 
  25.       keyGenerator.init(56); 
  26.       // 产生密钥 
  27.       SecretKey secretKey = keyGenerator.generateKey(); 
  28.       // 获取密钥 
  29.       byte[] bytesKey = secretKey.getEncoded(); 
  30.  
  31.       // KEY转换 
  32.       DESKeySpec desKeySpec = new DESKeySpec(bytesKey); 
  33.       SecretKeyFactory factory = SecretKeyFactory.getInstance("DES"); 
  34.       Key convertSecretKey = factory.generateSecret(desKeySpec); 
  35.  
  36.       // 加密 
  37.       Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); 
  38.       cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey); 
  39.       byte[] result = cipher.doFinal(src.getBytes()); 
  40.       System.out.println("jdk des encrypt:" + Hex.encodeHexString(result)); 
  41.  
  42.       // 解密 
  43.       cipher.init(Cipher.DECRYPT_MODE, convertSecretKey); 
  44.       result = cipher.doFinal(result); 
  45.       System.out.println("jdk des decrypt:" + new String(result)); 
  46.     } catch (Exception e) { 
  47.       e.printStackTrace(); 
  48.     } 
  49.   } 
  50.  
  51.   // 用bouncy castle实现: 
  52.   public static void bcDES() { 
  53.     try { 
  54.       Security.addProvider(new BouncyCastleProvider()); 
  55.  
  56.       // 生成KEY 
  57.       KeyGenerator keyGenerator = KeyGenerator.getInstance("DES""BC"); 
  58.       keyGenerator.getProvider(); 
  59.       keyGenerator.init(56); 
  60.       // 产生密钥 
  61.       SecretKey secretKey = keyGenerator.generateKey(); 
  62.       // 获取密钥 
  63.       byte[] bytesKey = secretKey.getEncoded(); 
  64.  
  65.       // KEY转换 
  66.       DESKeySpec desKeySpec = new DESKeySpec(bytesKey); 
  67.       SecretKeyFactory factory = SecretKeyFactory.getInstance("DES"); 
  68.       Key convertSecretKey = factory.generateSecret(desKeySpec); 
  69.  
  70.       // 加密 
  71.       Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding"); 
  72.       cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey); 
  73.       byte[] result = cipher.doFinal(src.getBytes()); 
  74.       System.out.println("bc des encrypt:" + Hex.encodeHexString(result)); 
  75.  
  76.       // 解密 
  77.       cipher.init(Cipher.DECRYPT_MODE, convertSecretKey); 
  78.       result = cipher.doFinal(result); 
  79.       System.out.println("bc des decrypt:" + new String(result)); 
  80.     } catch (Exception e) { 
  81.       e.printStackTrace(); 
  82.     } 
  83.   } 

应用例子:

3.对称加密算法-3DES

密码学中,三重数据加密算法(英语:Triple Data Encryption Algorithm,缩写为TDEA,Triple DEA),或称3DES(Triple DES),是一种对称密钥加密块密码,相当于是对每个数据块应用三次数据加密标准(DES)算法。由于计算机运算能力的增强,原版DES密码的密钥长度变得容易被暴力破解;3DES即是设计用来提供一种相对简单的方法,即通过增加DES的密钥长度来避免类似的攻击,而不是设计一种全新的块密码算法。

Java代码实现:


  1. import java.security.Key
  2. import java.security.SecureRandom; 
  3. import java.security.Security; 
  4. import javax.crypto.Cipher; 
  5. import javax.crypto.KeyGenerator; 
  6. import javax.crypto.SecretKey; 
  7. import javax.crypto.SecretKeyFactory; 
  8. import javax.crypto.spec.DESedeKeySpec; 
  9. import org.apache.commons.codec.binary.Hex; 
  10. import org.bouncycastle.jce.provider.BouncyCastleProvider; 
  11.  
  12. public class DES3 { 
  13.  
  14.   public static final String src = "3des test"
  15.  
  16.   public static void main(String[] args) { 
  17.     jdk3DES(); 
  18.     bc3DES(); 
  19.   } 
  20.  
  21.   // 用jdk实现: 
  22.   public static void jdk3DES() { 
  23.     try { 
  24.       // 生成KEY 
  25.       KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede"); 
  26.       // 必须长度是:112或168 
  27. //            keyGenerator.init(168); 
  28.       keyGenerator.init(new SecureRandom()); 
  29.       // 产生密钥 
  30.       SecretKey secretKey = keyGenerator.generateKey(); 
  31.       // 获取密钥 
  32.       byte[] bytesKey = secretKey.getEncoded(); 
  33.  
  34.       // KEY转换 
  35.       DESedeKeySpec desKeySpec = new DESedeKeySpec(bytesKey); 
  36.       SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede"); 
  37.       Key convertSecretKey = factory.generateSecret(desKeySpec); 
  38.  
  39.       // 加密 
  40.       Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding"); 
  41.       cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey); 
  42.       byte[] result = cipher.doFinal(src.getBytes()); 
  43.       System.out.println("jdk 3des encrypt:" + Hex.encodeHexString(result)); 
  44.  
  45.       // 解密 
  46.       cipher.init(Cipher.DECRYPT_MODE, convertSecretKey); 
  47.       result = cipher.doFinal(result); 
  48.       System.out.println("jdk 3des decrypt:" + new String(result)); 
  49.  
  50.     } catch (Exception e) { 
  51.       e.printStackTrace(); 
  52.     } 
  53.   } 
  54.  
  55.   // 用bouncy castle实现: 
  56.   public static void bc3DES() { 
  57.     try { 
  58.       Security.addProvider(new BouncyCastleProvider()); 
  59.  
  60.       // 生成KEY 
  61.       KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede""BC"); 
  62.       keyGenerator.getProvider(); 
  63.       keyGenerator.init(168); 
  64.       // 产生密钥 
  65.       SecretKey secretKey = keyGenerator.generateKey(); 
  66.       // 获取密钥 
  67.       byte[] bytesKey = secretKey.getEncoded(); 
  68.  
  69.       // KEY转换 
  70.       DESedeKeySpec desKeySpec = new DESedeKeySpec(bytesKey); 
  71.       SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede"); 
  72.       Key convertSecretKey = factory.generateSecret(desKeySpec); 
  73.  
  74.       // 加密 
  75.       Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding"); 
  76.       cipher.init(Cipher.ENCRYPT_MODE, convertSecretKey); 
  77.       byte[] result = cipher.doFinal(src.getBytes()); 
  78.       System.out.println("bc 3des encrypt:" + Hex.encodeHexString(result)); 
  79.  
  80.       // 解密 
  81.       cipher.init(Cipher.DECRYPT_MODE, convertSecretKey); 
  82.       result = cipher.doFinal(result); 
  83.       System.out.println("bc 3des decrypt:" + new String(result)); 
  84.  
  85.     } catch (Exception e) { 
  86.       e.printStackTrace(); 
  87.     } 
  88.   } 

4.对称加密算法-AES

高级加密标准(英语:Advanced Encryption Standard,缩写:AES),在密码学中又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。经过五年的甄选流程,高级加密标准由美国国家标准与技术研究院(NIST)于2001年11月26日发布于FIPS PUB 197,并在2002年5月26日成为有效的标准。2006年,高级加密标准已然成为对称密钥加密中最流行的算法之一。

该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计,结合两位作者的名字,以Rijndael为名投稿高级加密标准的甄选流程。(Rijndael的发音近于"Rhine doll")

Java代码实现:


  1. import java.security.Key
  2. import java.security.Security; 
  3. import javax.crypto.Cipher; 
  4. import javax.crypto.KeyGenerator; 
  5. import javax.crypto.SecretKey; 
  6. import javax.crypto.spec.SecretKeySpec; 
  7. import org.apache.commons.codec.binary.Hex; 
  8. import org.bouncycastle.jce.provider.BouncyCastleProvider; 
  9.  
  10. public class AES { 
  11.  
  12.   public static final String src = "aes test"
  13.  
  14.   public static void main(String[] args) { 
  15.     jdkAES(); 
  16.     bcAES(); 
  17.   } 
  18.  
  19.   // 用jdk实现: 
  20.   public static void jdkAES() { 
  21.     try { 
  22.       // 生成KEY 
  23.       KeyGenerator keyGenerator = KeyGenerator.getInstance("AES"); 
  24.       keyGenerator.init(128); 
  25.       // 产生密钥 
  26.       SecretKey secretKey = keyGenerator.generateKey(); 
  27.       // 获取密钥 
  28.       byte[] keyBytes = secretKey.getEncoded(); 
  29.  
  30.       // KEY转换 
  31.       Key key = new SecretKeySpec(keyBytes, "AES"); 
  32.  
  33.       // 加密 
  34.       Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); 
  35.       cipher.init(Cipher.ENCRYPT_MODE, key); 
  36.       byte[] result = cipher.doFinal(src.getBytes()); 
  37.       System.out.println("jdk aes encrypt:" + Hex.encodeHexString(result)); 
  38.  
  39.       // 解密 
  40.       cipher.init(Cipher.DECRYPT_MODE, key); 
  41.       result = cipher.doFinal(result); 
  42.       System.out.println("jdk aes decrypt:" + new String(result)); 
  43.     } catch (Exception e) { 
  44.       e.printStackTrace(); 
  45.     } 
  46.   } 
  47.  
  48.   // 用bouncy castle实现: 
  49.   public static void bcAES() { 
  50.     try { 
  51.       Security.addProvider(new BouncyCastleProvider()); 
  52.  
  53.       // 生成KEY 
  54.       KeyGenerator keyGenerator = KeyGenerator.getInstance("AES""BC"); 
  55.       keyGenerator.getProvider(); 
  56.       keyGenerator.init(128); 
  57.       // 产生密钥 
  58.       SecretKey secretKey = keyGenerator.generateKey(); 
  59.       // 获取密钥 
  60.       byte[] keyBytes = secretKey.getEncoded(); 
  61.  
  62.       // KEY转换 
  63.       Key key = new SecretKeySpec(keyBytes, "AES"); 
  64.  
  65.       // 加密 
  66.       Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); 
  67.       cipher.init(Cipher.ENCRYPT_MODE, key); 
  68.       byte[] result = cipher.doFinal(src.getBytes()); 
  69.       System.out.println("bc aes encrypt:" + Hex.encodeHexString(result)); 
  70.  
  71.       // 解密 
  72.       cipher.init(Cipher.DECRYPT_MODE, key); 
  73.       result = cipher.doFinal(result); 
  74.       System.out.println("bc aes decrypt:" + new String(result)); 
  75.     } catch (Exception e) { 
  76.       e.printStackTrace(); 
  77.     } 
  78.   } 

5.对称加密算法-PBE

PBE算法(Password Based Encryption,基于口令加密)是一种基于口令的加密算法,其特点是使用口令代替了密钥,而口令由用户自己掌管,采用随机数杂凑多重加密等方法保证数据的安全性。

PBE算法在加密过程中并不是直接使用口令来加密,而是加密的密钥由口令生成,这个功能由PBE算法中的KDF函数完成。KDF函数的实现过程为:将用户输入的口令首先通过“盐”(salt)的扰乱产生准密钥,再将准密钥经过散列函数多次迭代后生成最终加密密钥,密钥生成后,PBE算法再选用对称加密算法对数据进行加密,可以选择DES、3DES、RC5等对称加密算法。

具体实现如下:

Java代码实现:


  1. import java.security.Key
  2. import java.security.SecureRandom; 
  3. import javax.crypto.Cipher; 
  4. import javax.crypto.SecretKeyFactory; 
  5. import javax.crypto.spec.PBEKeySpec; 
  6. import javax.crypto.spec.PBEParameterSpec; 
  7. import org.apache.commons.codec.binary.Hex; 
  8.  
  9. public class PBE { 
  10.  
  11.   public static final String src = "pbe test"
  12.  
  13.   public static void main(String[] args) { 
  14.     jdkPBE(); 
  15.   } 
  16.  
  17.   // 用jdk实现: 
  18.   public static void jdkPBE() { 
  19.     try { 
  20.       // 初始化盐 
  21.       SecureRandom random = new SecureRandom(); 
  22.       byte[] salt = random.generateSeed(8); 
  23.  
  24.       // 口令与密钥 
  25.       String password = "timliu"
  26.       PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray()); 
  27.       SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWITHMD5andDES"); 
  28.       Key key = factory.generateSecret(pbeKeySpec); 
  29.  
  30.       // 加密 
  31.       PBEParameterSpec pbeParameterSpac = new PBEParameterSpec(salt, 100); 
  32.       Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES"); 
  33.       cipher.init(Cipher.ENCRYPT_MODE, key, pbeParameterSpac); 
  34.       byte[] result = cipher.doFinal(src.getBytes()); 
  35.       System.out.println("jdk pbe encrypt:" + Hex.encodeHexString(result)); 
  36.  
  37.       // 解密 
  38.       cipher.init(Cipher.DECRYPT_MODE, key, pbeParameterSpac); 
  39.       result = cipher.doFinal(result); 
  40.       System.out.println("jdk pbe decrypt:" + new String(result)); 
  41.     } catch (Exception e) { 
  42.       e.printStackTrace(); 
  43.     } 
  44.   } 

应用举例:

【编辑推荐】
 易控王数据防泄密软件--企业文件防泄密专家!轻松实现单位内部文件自动加密保护,加密后的文件在单位内部正常流转使用。未经许可,任何私自拷贝加密文件外发出去,都将打开为乱码,无法使用!对于发送给客户等第三方的文件,可实现控制打开时间和打开次数等防泄密参数!同时可设置对员工电脑文件自动备份,防止恶意删除造成核心数据的遗失!从源头防止企业核心文件被外泄!
相关页面:加密软件文件加密文档加密图纸加密软件,防泄密软件,CAD加密软件,文件外发加密
【免责声明】本站内容转载自互联网,其相关言论仅代表作者个人观点绝非权威,不代表本站立场。如您发现内容存在版权问题,请提交相关链接至邮箱:[email protected],我们将及时予以处理。

软件相关证书
  • 5

    热情服务
  • 7
    *24
    小时售后支持
  • 7

    免费试用
  • 0

    免费体验
  • 平台支持

    平台支持

    windows系统: windowsXP,windows7,windows2003,windows2008,windows8
    linux系统: redhat,redflag,ubuntu,昆仑
    苹果系统: mac os
    语言支持

    语言支持

    简体中文,繁体中文,英文,韩文,日文 ( 可定制加入其它语言 )


    售前咨询
      咨询热线  
      在线咨询    
    全方位的购买咨询 | 精准的配置推荐 | 灵活的价格方案 | 1对1贴心服务
    如果您有任何电脑监控软件、文件加密软件的疑问,请联系我们,竭诚为您服务

      友情链接:文件加密软件 局域网监控软件 免费监控软件 远程监控软件下载 电脑加密软件 免费加密软件 文档加密软件 QQ聊天监控软件 上网行为监控软件

    【易控王官网:www.ekongsoft.com】易控王是一款集局域网电脑监控软件图纸文件加密软件文档备份软件等多功能于一体的超强电脑监控防泄密系统。功能强大,安全稳定!

    © 2003-2017 Shanghai Junchong Agel Ecommerce Ltd. All rights reserved.
    上海均崇电子商务有限公司 | 沪ICP备09024707号