各种Java加密算法二

最新推荐文章于 2023-03-23 09:17:25 发布
最新推荐文章于 2023-03-23 09:17:25 发布
阅读量524 收藏
点赞数
分类专栏： 基础知识 文章标签： 算法 加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjq008/article/details/49071033
版权

DES 
DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中 Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密 或解密。 
        DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位。 


通过java代码实现如下：Coder类见

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
import  java.security.Key;
import  java.security.SecureRandom;
 
import  javax.crypto.Cipher;
import  javax.crypto.KeyGenerator;
import  javax.crypto.SecretKey;
import  javax.crypto.SecretKeyFactory;
import  javax.crypto.spec.DESKeySpec;
 
 
/**
  * DES安全编码组件
  * 
  * <pre>
  * 支持 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR)
  * DES                  key size must be equal to 56
  * DESede(TripleDES)     key size must be equal to 112 or 168
  * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
  * Blowfish          key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
  * RC2                  key size must be between 40 and 1024 bits
  * RC4(ARCFOUR)      key size must be between 40 and 1024 bits
  * 具体内容 需要关注 JDK Document http://.../docs/technotes/guides/security/SunProviders.html
  * </pre>
  * 
  * @author 梁栋
  * @version 1.0
  * @since 1.0
  */
public  abstract  class  DESCoder  extends  Coder {
     /**
      * ALGORITHM 算法 <br>
      * 可替换为以下任意一种算法，同时key值的size相应改变。
      * 
      * <pre>
      * DES                  key size must be equal to 56
      * DESede(TripleDES)     key size must be equal to 112 or 168
      * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
      * Blowfish          key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
      * RC2                  key size must be between 40 and 1024 bits
      * RC4(ARCFOUR)      key size must be between 40 and 1024 bits
      * </pre>
      * 
      * 在Key toKey(byte[] key)方法中使用下述代码
      * <code>SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);</code> 替换
      * <code>
      * DESKeySpec dks = new DESKeySpec(key);
      * SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
      * SecretKey secretKey = keyFactory.generateSecret(dks);
      * </code>
      */
     public  static  final  String ALGORITHM =  "DES" ;
 
     /**
      * 转换密钥<br>
      * 
      * @param key
      * @return
      * @throws Exception
      */
     private  static  Key toKey( byte [] key)  throws  Exception {
         DESKeySpec dks =  new  DESKeySpec(key);
         SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
         SecretKey secretKey = keyFactory.generateSecret(dks);
 
         // 当使用其他对称加密算法时，如AES、Blowfish等算法时，用下述代码替换上述三行代码
         // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);
 
         return  secretKey;
     }
 
     /**
      * 解密
      * 
      * @param data
      * @param key
      * @return
      * @throws Exception
      */
     public  static  byte [] decrypt( byte [] data, String key)  throws  Exception {
         Key k = toKey(decryptBASE64(key));
 
         Cipher cipher = Cipher.getInstance(ALGORITHM);
         cipher.init(Cipher.DECRYPT_MODE, k);
 
         return  cipher.doFinal(data);
     }
 
     /**
      * 加密
      * 
      * @param data
      * @param key
      * @return
      * @throws Exception
      */
     public  static  byte [] encrypt( byte [] data, String key)  throws  Exception {
         Key k = toKey(decryptBASE64(key));
         Cipher cipher = Cipher.getInstance(ALGORITHM);
         cipher.init(Cipher.ENCRYPT_MODE, k);
 
         return  cipher.doFinal(data);
     }
 
     /**
      * 生成密钥
      * 
      * @return
      * @throws Exception
      */
     public  static  String initKey()  throws  Exception {
         return  initKey( null );
     }
 
     /**
      * 生成密钥
      * 
      * @param seed
      * @return
      * @throws Exception
      */
     public  static  String initKey(String seed)  throws  Exception {
         SecureRandom secureRandom =  null ;
 
         if  (seed !=  null ) {
             secureRandom =  new  SecureRandom(decryptBASE64(seed));
         }  else  {
             secureRandom =  new  SecureRandom();
         }
 
         KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);
         kg.init(secureRandom);
 
         SecretKey secretKey = kg.generateKey();
 
         return  encryptBASE64(secretKey.getEncoded());
     }
}


延续上一个类的实现，我们通过MD5以及SHA对字符串加密生成密钥，这是比较常见的密钥生成方式。 
再给出一个测试类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import  static  org.junit.Assert.*;
 
 
import  org.junit.Test;
 
/**
  * 
  * @author 梁栋
  * @version 1.0
  * @since 1.0
  */
public  class  DESCoderTest {
 
     @Test
     public  void  test()  throws  Exception {
         String inputStr =  "DES" ;
         String key = DESCoder.initKey();
         System.err.println( "原文:\t"  + inputStr);
 
         System.err.println( "密钥:\t"  + key);
 
         byte [] inputData = inputStr.getBytes();
         inputData = DESCoder.encrypt(inputData, key);
 
         System.err.println( "加密后:\t"  + DESCoder.encryptBASE64(inputData));
 
         byte [] outputData = DESCoder.decrypt(inputData, key);
         String outputStr =  new  String(outputData);
 
         System.err.println( "解密后:\t"  + outputStr);
 
         assertEquals(inputStr, outputStr);
     }
}


得到的输出内容如下：

原文:	DES
密钥:	f3wEtRrV6q0=

加密后:	C6qe9oNIzRY=

解密后:	DES


    由控制台得到的输出，我们能够比对加密、解密后结果一致。这是一种简单的加密解密方式，只有一个密钥。 
    其实DES有很多同胞兄弟，如DESede(TripleDES)、AES、Blowfish、RC2、RC4(ARCFOUR)。这里就不过多阐述了，大同小异，只要换掉ALGORITHM换成对应的值，同时做一个代码替换SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);就可以了，此外就是密钥长度不同了。 

?
1
2
3
4
5
6
7
8
/**
  * DES          key size must be equal to 56
  * DESede(TripleDES) key size must be equal to 112 or 168
  * AES          key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
  * Blowfish     key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
  * RC2          key size must be between 40 and 1024 bits
  * RC4(ARCFOUR) key size must be between 40 and 1024 bits
  **/

    除了DES，我们还知道有DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR)等多种对称加密方式，其实现方式大同小异，这里介绍对称加密的另一个算法——PBE 
PBE 
    PBE——Password-based encryption（基于密码加密）。其特点在于口令由用户自己掌管，不借助任何物理媒体；采用随机数（这里我们叫做盐）杂凑多重加密等方法保证数据的安全性。是一种简便的加密方式。 
通过java代码实现如下：Coder类见 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import  java.security.Key;
import  java.util.Random;
  
import  javax.crypto.Cipher;
import  javax.crypto.SecretKey;
import  javax.crypto.SecretKeyFactory;
import  javax.crypto.spec.PBEKeySpec;
import  javax.crypto.spec.PBEParameterSpec;
  
/**
  * PBE安全编码组件
  * 
  * @author 梁栋
  * @version 1.0
  * @since 1.0
  */
public  abstract  class  PBECoder  extends  Coder {
     /**
      * 支持以下任意一种算法
      * 
      * <pre>
      * PBEWithMD5AndDES 
      * PBEWithMD5AndTripleDES 
      * PBEWithSHA1AndDESede
      * PBEWithSHA1AndRC2_40
      * </pre>
      */
     public  static  final  String ALGORITHM =  "PBEWITHMD5andDES" ;
  
     /**
      * 盐初始化
      * 
      * @return
      * @throws Exception
      */
     public  static  byte [] initSalt()  throws  Exception {
         byte [] salt =  new  byte [ 8 ];
         Random random =  new  Random();
         random.nextBytes(salt);
         return  salt;
     }
  
     /**
      * 转换密钥<br>
      * 
      * @param password
      * @return
      * @throws Exception
      */
     private  static  Key toKey(String password)  throws  Exception {
         PBEKeySpec keySpec =  new  PBEKeySpec(password.toCharArray());
         SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
         SecretKey secretKey = keyFactory.generateSecret(keySpec);
  
         return  secretKey;
     }
  
     /**
      * 加密
      * 
      * @param data 数据
      * @param password 密码
      * @param salt  盐
      * @return
      * @throws Exception
      */
     public  static  byte [] encrypt( byte [] data, String password,  byte [] salt)
             throws  Exception {
  
         Key key = toKey(password);
  
         PBEParameterSpec paramSpec =  new  PBEParameterSpec(salt,  100 );
         Cipher cipher = Cipher.getInstance(ALGORITHM);
         cipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
  
         return  cipher.doFinal(data);
  
     }
  
     /**
      * 解密
      * 
      * @param data  数据
      * @param password 密码
      * @param salt  盐
      * @return
      * @throws Exception
      */
     public  static  byte [] decrypt( byte [] data, String password,  byte [] salt)
             throws  Exception {
  
         Key key = toKey(password);
  
         PBEParameterSpec paramSpec =  new  PBEParameterSpec(salt,  100 );
         Cipher cipher = Cipher.getInstance(ALGORITHM);
         cipher.init(Cipher.DECRYPT_MODE, key, paramSpec);
  
         return  cipher.doFinal(data);
  
     }
}



再给出一个测试类： 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import  static  org.junit.Assert.*;
  
import  org.junit.Test;
  
/**
  * 
  * @author 梁栋
  * @version 1.0
  * @since 1.0
  */
public  class  PBECoderTest {
  
     @Test
     public  void  test()  throws  Exception {
         String inputStr =  "abc" ;
         System.err.println( "原文: "  + inputStr);
         byte [] input = inputStr.getBytes();
  
         String pwd =  "efg" ;
         System.err.println( "密码: "  + pwd);
  
         byte [] salt = PBECoder.initSalt();
  
         byte [] data = PBECoder.encrypt(input, pwd, salt);
  
         System.err.println( "加密后: "  + PBECoder.encryptBASE64(data));
  
         byte [] output = PBECoder.decrypt(data, pwd, salt);
         String outputStr =  new  String(output);
  
         System.err.println( "解密后: "  + outputStr);
         assertEquals(inputStr, outputStr);
     }
  
}



控制台输出： 

原文: abc
密码: efg
加密后: iCZ0uRtaAhE=
 
解密后: abc
wjq008
关注
专栏目录
java DES加解密及Wrong key size错误
weixin_30642561的博客
07-11 7318
如下的DES加密方法会报错：Wrong key size public static String encryptDES(String source) throws Exception{ SecretKeySpec skeySpec = new SecretKeySpec(ckplayerkey.getBytes(), "DES"); Cip...
前后端DES加解密及Wrong key size错误处理
weixin_39876990的博客
04-02 5385
前后端DES加解密及Wrong key size错误处理 前端使用 CryptoJS 进行DES加密，后端Java进行解密。 前端 function encryptByDES(message, key) { var keyHex = CryptoJS.enc.Utf8.parse(key); var encrypted = CryptoJS.DES.encrypt(message, keyHex, { mode: CryptoJS.mode.ECB,
JAVA—DES的加密解密
TofuCai的博客
02-15 1401
 JAVA采用DES进行的加密和解密操作 简单介绍： DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究， 后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力， 24小时内即可被破解。 理论： DES是一个分组加密算法，它以64位为分组对数据加密。同时DES也是一个对称算法：加密...
漫谈Java加密技术（二）
anlovejing的专栏
03-06 463
接下来我们介绍对称加密算法，最常用的莫过于DES数据加密算法。     DES     DES-Data Encryption Standard，即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个：Key、Data、Mode.其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作
报错java.security.InvalidKeyException: Wrong key size
qq_40178497的博客
03-28 2204
DESKeySpec desKeySpec = new DESKeySpec(key.getBytes());获取的key.getBytes()长度要>=24，在小于24时会报错，添加如下判断： public static String encrypt(String encryptText, String key) { if (encryptText == null || key == null) { throw new IllegalArgumentExce
基于Java实现的同态加密算法的实现
最新发布
04-27
在"research_encrypt-code"这个压缩包中，很可能包含了Java实现同态加密算法的源代码，包括密钥管理、加密、解密和操作加密数据的函数。通过研究这些代码，我们可以深入了解如何在实际应用中利用Java来构建安全的...
Java加密算法RSA代码实例
08-25
Java加密算法RSA代码实例 Java加密算法RSA代码实例是Java中的一种常用加密算法，主要用于数据加密和解密。 RSA算法是基于大数分解的公钥加密算法，使用一对密钥对（公钥和私钥）来实现加密和解密。 在Java中，RSA...
基于java实现的ECC加密算法示例
08-29
基于Java实现的ECC加密算法示例 本文主要介绍了基于Java实现的ECC加密算法，简单说明了ECC算法的概念、原理，并结合实例形式分析了Java实现ECC加密算法的定义与使用技巧。 ECC算法概念 ECC（Elliptic Curves ...
java 加密算法
yushan125的博客
03-23 478
java 加密算法
DES加密算法DES加密算法
03-15
// Java crypt example SJ import javax.crypto.*; import javax.crypto.spec.*; import java.io.*; import java.lang.*; import java.util.*; import java.security.*; public class EncryptionExample { protected String calg = "Blowfish"; // AES. DES, Blowfish protected int keyLen = 128; // 128 for AES, Blowfish, 64 for DES public static void main(String[] args) { EncryptionExample s = new EncryptionExample(); // to call nonstatic methods SecretKeySpec key = s.readkey(); String mess = new String("Hello, world!"); byte[] messb = mess.getBytes(); System.out.println("Plain|" + mess +"|=|" + s.bintohex(messb)); byte[] ct = s.encrypt(messb, key); System.out.println("Encry:" + s.bintohex(ct)); byte[] pt = s.decrypt(ct, key); String dmess = new String(pt); System.out.println("Decry|" + dmess +"|=|" + s.bintohex(pt)); } // main() // encrypt message t with key k public byte[] encrypt(byte[] t, SecretKeySpec k) { try { Cipher c = Cipher.getInstance(calg); c.init(Cipher.ENCRYPT_MODE, k); return c.doFinal(t); } catch (Exception e) { System.err.println("Encryption failed: " + e); } return null; } // decrypt message t with key k public byte[] decrypt(byte[] t, SecretKeySpec k) { try { Cipher c = Cipher.getInstance(calg); c.init(Cipher.DECRYPT_MODE, k); return c.doFinal(t); } catch (Exception e) { System.err.println("Decryption failed: " + e); } return null; } // reads key string from user, returns SecretKeySpec public SecretKeySpec readkey() { SecretKeySpec kp = null; String line; byte [] bin = null; try { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Give the key or passphrase (" + keyLen/4 + " hex digits or long ascii string) \n : "); line = in.readLine(); // check if input is all hex or not boolean ishex = true; for (int i = 0; i < line.length(); i++) if (Character.digit(line.charAt(i), 16) < 0) { ishex = false; break; } // check hex key length if (ishex && line.length() != keyLen/4) System.err.println("Wrong hex ley lenght (" + line.length() + "/" + keyLen/4 + ")"); // make binary key if (ishex) bin = hextobin(line); else bin = asciitobin(line); // make key for crypto algorithm kp = new SecretKeySpec(bin, calg); System.out.println("Key = |" + bintohex(kp.getEncoded()) + "|"); } catch (Exception e) { System.err.println("Key generation failed" + e); } return kp; } // readkey() // make binary out of hex string public byte[] hextobin(String s) { int len = (s.length()+1)/2; byte[] A = new byte[len]; for (int i = 0; i < len; i++) A[i] = Integer.valueOf(s.substring(i*2, i*2+2), 16).byteValue(); return A; } // returns new 128 bit key using MD5 of the string s public byte[] asciitobin(String s) { byte[] A = null; try { MessageDigest md = MessageDigest.getInstance("MD5"); A = md.digest(s.getBytes()); } catch (Exception e) { System.err.println("Digest failed" + e); } return A; } // returns new hex string representation of A public String bintohex(byte[] A) { int len = A.length; StringBuffer sb = new StringBuffer(len*2); for (int i = 0; i < len; i++) { if ((A[i] & 0xFF) < 0x10) sb.append("0"); sb.append(Integer.toHexString(A[i] & 0xFF)); } return sb.toString(); } } // class
Java加密技术（二）
中源
05-08 210
 接下来我们介绍对称加密算法，最常用的莫过于DES数据加密算法。 DES DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或...
Java 加解密技术系列之 DES
热门推荐
紫羽风的博客
03-19 2万+
序 前几篇文章讲的都是单向加密算法，其中涉及到了 BASE64、MD5、SHA、HMAC 等几个比较常见的加解密算法。这篇文章，以及后面几篇，打算介绍几个对称加密算法，比如：DES、3DES（TripleDES）、AES 等。那么，这篇文章主要是对 DES 大概讲一下。 背景 在讨论 DES 之前，首先了解一下什么是对称加密算法吧。对于对称加密算法，他应用的时
java.security.InvalidKeyException: Wrong key size 错误
sunzbking的博客
11-30 1万+
3Des实际上只是3个单独的DES操作，每个操作都需要一个8字节的密钥。这需要24字节的密钥..但是一些实现支持16字节密钥，其中前8个字节在场景后“自动重复”。有的实现可能不支持这一点。你怎么能通过重复前8个字节来自己做 - 这样的事情： public static byte[] encrypt3DESECB(byte[] keyBytes, byte[] dataBytes) { ...
记录异常InvalidKeyOrParametersException: Key length not 128/192/256 bits
dctCheng的博客
11-26 1万+
Key length not 128/192/256 bits      一般是使用对称算法加密的时候出现的异常，它的意思是指 key的长度不是 128,192或者256 位，注意！！！ 并不是不足，而是不是，这个意思指的是key的长度必须要是128，192或者256 位，知道了这个的话就很好去解决这个问题了       以AES 加密为例：       aes.getSecretKey().getEncoded().length 能获取到aes 的 字节长度 （注意是字节） 128 位 对应的是 16
DESCoderUtil加密解密工具类
x790222549的博客
07-26 1849
1、代码 package com.ra.util; import java.security.Key; import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax....
JAVA加密算法实用实现案例详解
资源摘要信息:"JAVA加密算法实现用例集合" 在当今信息化高速发展的时代，数据的安全性变得越来越重要，尤其是在使用Java进行软件开发时，加密算法的合理运用对于保障数据安全具有关键意义。本资源集合包含了多个在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值