des解密工具安卓下载（dgs解密工具）
des解密工具安卓下载（dgs解密工具）
#region 跨平台加解密（c# 安卓 IOS）
// public static string sKey = "12345678";
// /// summary
// /// 解密
// /// /summary
// /// param name="pToDecrypt"要解密的以Base64/param
// /// param name="sKey"密钥，且必须为8位/param
// /// returns已解密的字符串/returns
// public static string DesDecrypt(string pToDecrypt)
// {
// //转义特殊字符
// pToDecrypt = pToDecrypt.Replace("-", "+");
// pToDecrypt = pToDecrypt.Replace("_", "/");
// pToDecrypt = pToDecrypt.Replace("~", "=");
// byte[] inputByteArray = Convert.FromBase64String(pToDecrypt);
// using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
// {
// des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
// des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
// System.IO.MemoryStream ms = new System.IO.MemoryStream();
// using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
// {
// cs.Write(inputByteArray, 0, inputByteArray.Length);
// cs.FlushFinalBlock();
// cs.Close();
// }
// string str = Encoding.UTF8.GetString(ms.ToArray());
// ms.Close();
// return str;
// }
// }
// /// summary
// /// 对字符串进行DES加密
// /// /summary
// /// param name="sourceString"待加密的字符串/param
// /// returns加密后的BASE64编码的字符串/returns
// public string Encrypt(string sourceString)
//{
// byte[] btKey = Encoding.UTF8.GetBytes(sKey);
// byte[] btIV = Encoding.UTF8.GetBytes(sKey);
// DESCryptoServiceProvider des = new DESCryptoServiceProvider();
// using (MemoryStream ms = new MemoryStream())
// {
// byte[] inData = Encoding.UTF8.GetBytes(sourceString);
// try
// {
// using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(btKey, btIV), CryptoStreamMode.Write))
// {
// cs.Write(inData, 0, inData.Length);
// cs.FlushFinalBlock();
// }
// return Convert.ToBase64String(ms.ToArray());
// }
// catch
// {
// throw;
// }
// }
//}
#endregion
安卓---------------------------------------------------------------------------
// // 加密
//public static String DecryptDoNet(String message, String key)
// throws Exception {
// byte[] bytesrc = Base64.decode(message.getBytes(), Base64.DEFAULT);
// Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
// DESKeySpec desKeySpec = new DESKeySpec(key.getBytes("UTF-8"));
// SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
// SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
// IvParameterSpec iv = new IvParameterSpec(key.getBytes("UTF-8"));
// cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
// byte[] retByte = cipher.doFinal(bytesrc);
// return new String(retByte);
//}
//// 解密
//public static String EncryptAsDoNet(String message, String key)
// throws Exception {
// Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
// DESKeySpec desKeySpec = new DESKeySpec(key.getBytes("UTF-8"));
// SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
// SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
// IvParameterSpec iv = new IvParameterSpec(key.getBytes("UTF-8"));
// cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
// byte[] encryptbyte = cipher.doFinal(message.getBytes());
// return new String(Base64.encode(encryptbyte, Base64.DEFAULT));
//}
Ios --------------------------------------------------------------------------------------------------------------------\
static const char* encryptWithKeyAndType(const char *text,CCOperation encryptOperation,char *key)
{
NSString *textString=[[NSString alloc]initWithCString:text encoding:NSUTF8StringEncoding];
// NSLog(@"[[item.url description] UTF8String=%@",textString);
const void *dataIn;
size_t dataInLength;
if (encryptOperation == kCCDecrypt)//传递过来的是decrypt 解码
{
//解码 base64
NSData *decryptData = [GTMBase64 decodeData:[textString dataUsingEncoding:NSUTF8StringEncoding]];//转成utf-8并decode
dataInLength = [decryptData length];
dataIn = [decryptData bytes];
}
else //encrypt
{
NSData* encryptData = [textString dataUsingEncoding:NSUTF8StringEncoding];
dataInLength = [encryptData length];
dataIn = (const void *)[encryptData bytes];
}
CCCryptorStatus ccStatus;
uint8_t *dataOut = NULL; //可以理解位type/typedef 的缩写（有效的维护了代码，比如：一个人用int，一个人用long。最好用typedef来定义）
size_t dataOutAvailable = 0; //size_t 是操作符sizeof返回的结果类型
size_t dataOutMoved = 0;
dataOutAvailable = (dataInLength + kCCBlockSizeDES) ~(kCCBlockSizeDES - 1);
dataOut = malloc( dataOutAvailable * sizeof(uint8_t));
memset((void *)dataOut, 00, dataOutAvailable);//将已开辟内存空间buffer的首 1 个字节的值设为值 0
//NSString *initIv = @"12345678";
const void *vkey = key;
const void *iv = (const void *) key; //[initIv UTF8String];
//CCCrypt函数 加密/解密
ccStatus = CCCrypt(encryptOperation,// 加密/解密
kCCAlgorithmDES,// 加密根据哪个标准（des，3des，aes。。。。）
kCCOptionPKCS7Padding,// 选项分组密码算法(des:对每块分组加一次密 3DES：对每块分组加三个不同的密)
vkey, //密钥 加密和解密的密钥必须一致
kCCKeySizeDES,// DES 密钥的大小（kCCKeySizeDES=8）
iv, // 可选的初始矢量
dataIn, // 数据的存储单元
dataInLength,// 数据的大小
(void *)dataOut,// 用于返回数据
dataOutAvailable,
dataOutMoved);
NSString *result = nil;
if (encryptOperation == kCCDecrypt)//encryptOperation==1 解码
{
//得到解密出来的data数据，改变为utf-8的字符串
result = [[NSString alloc] initWithData:[NSData dataWithBytes:(const void *)dataOut length:(NSUInteger)dataOutMoved] encoding:NSUTF8StringEncoding];
}
else //encryptOperation==0 （加密过程中，把加好密的数据转成base64的）
{
//编码 base64
NSData *data = [NSData dataWithBytes:(const void *)dataOut length:(NSUInteger)dataOutMoved];
result = [GTMBase64 stringByEncodingData:data];
}
return [result UTF8String];
}
+(NSString*)encryptWithContent:(NSString*)content type:(CCOperation)type key:(NSString*)aKey
{
const char * contentChar =[content UTF8String];
char * keyChar =(char*)[aKey UTF8String];
const char *miChar;
miChar = encryptWithKeyAndType(contentChar, type, keyChar);
return [NSString stringWithCString:miChar encoding:NSUTF8StringEncoding];
}
des对称加密，是一种比较传统的加密方式，其加密运算、解密运算使用的是同样的密钥，信息的发送者和信息的接收者在进行信息的传输与处理时，必须共同持有该密码（称为对称密码），是一种对称加密算法。
DES全称Data Encryption Standard，是一种使用密匙加密的块算法。现在认为是一种不安全的加密算法，因为现在已经有用穷举法攻破DES密码的报道了。尽管如此，该加密算法还是运用非常普遍，是一种标准的加密算法。3DES是DES的加强版本。
DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位，产生最大 64 位的分组大小。这是一个迭代的分组密码，使用称为 Feistel 的技术，其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行“异或”运算；接着交换这两半，这一过程会继续下去，但最后一个循环不交换。DES 使用 16 个循环，使用异或，置换，代换，移位操作四种基本运算。
DES( Data Encryption Standard)算法，于1977年得到美国政府的正式许可，是一种用56位密钥来加密64位数据的方法。虽然56位密钥的DES算法已经风光不在,而且常有用Des加密的明文被破译的报道,但是了解一下昔日美国的标准加密算法总是有益的,而且目前DES算法得到了广泛的应用,在某些场合,她仍然发挥着余热^_^.
1.1 密钥生成
1.1.1 取得密钥
从用户处取得一个64位(本文如未特指，均指二进制位))长的密码key ,
去除64位密码中作为奇偶校验位的第8、16、24、32、40、48、56、64位,剩下的56位作为有效输入密钥.
1.1.2 等分密钥
表1. 57 49 41 33 25 17 9
1 58 50 42 34 26 18
10 2 59 51 43 35 27
19 11 3 60 50 44 36
表2.
65 55 47 39 31 23 15
7 62 54 46 38 30 22
14 6 61 53 45 37 29
21 13 5 28 20 12 4
把在1.1.1步中生成的56位输入密钥分成均等的A,B两部分,每部分为28位,参照表1和表2把输入密钥的位值填入相应的位置. 按照表1所示A的第一位为输入的64位密钥的第57位，A的第2位为64位密钥的第49位，...，依此类推，A的最后一位最后一位是64位密钥的第36位。
1.1.3 密钥移位
表3. i 1 2 3 4 5 6 7 8
ǿ 1 1 2 2 2 2 2 2
i 9 10 11 12 13 14 15 16
ǿ 1 2 2 2 2 2 2 1
DES算法的密钥是经过16次迭代得到一组密钥的,把在1.1.2步中生成的A,B视为迭代的起始密钥,表3显示在第i次迭代时密钥循环左移的位数. 比如在第1次迭代时密钥循环左移1位,第3次迭代时密钥循环左移2位.
第9次迭代时密钥循环左移1位,第14次迭代时密钥循环左移2位.
第一次迭代:
A(1) = ǿ(1) A
B(1) = ǿ(1) B
第i次迭代:
A(i) = ǿ(i) A(i-1)
B(i) = ǿ(i) B(i-1)
1.1.4 密钥的选取
表4.
14 17 11 24 1 5 3 28
15 6 21 10 23 19 12 4
26 8 16 7 27 20 13 2
41 52 31 37 47 55 30 40
51 45 33 48 44 49 39 56
34 53 46 42 50 36 29 32
在1.1.3步中第i次迭代生成的两个28位长的密钥为
把合并
按照表4所示k的第一位为56位密钥的第14位，k的第2位为56位密钥的第17位，...，依此类推，k的最后一位最后一位是56位密钥的第32位。 生成与进行第i次迭代加密的数据进行按位异或的48位使用密钥:
1.1.5迭代
DES算法密钥生成需要进行16次迭代,在完成16次迭代前,循环执行1.1.3-1.1.4步.
最终形成16套加密密钥:key[0] , key[1] , key[2] ,…. key[14] , key[15] .
1. 2 数据的加密操作
1.2.1 取得数据
把明文数据分成64位的数据块，不够64位的数据块以适当的方式补足。
1.2.2 初始换位
表5. 58 50 42 34 26 18 10 2
60 52 44 36 28 20 12 4
62 54 46 38 30 22 14 6
64 56 48 40 32 24 16 8
57 49 41 33 25 17 9 1
59 51 43 35 27 19 11 3
61 53 45 37 29 21 13 5
63 55 47 39 31 23 15 7
按照表5所示把输入的64位数据的原第58位换到第一位,原第50位换到第二位，...，依此类推,最后的得到新的64位数据.
OldData newData
1.2.3 数据扩展
表6.
32 1 2 3 4 5 4 5
6 7 8 9 8 9 10 11
12 13 12 13 14 15 16 17
16 17 18 19 20 21 20 21
22 23 24 25 24 25 26 27
28 29 28 29 30 31 32 1
第一次迭代以1.2.2步中生成的newData作为输入数据,第i (i 1)次迭代以第i-1次的64位输出数据为输入数据,把64位数据按位置等分成左右两部分:
保持left不变,根据表6把right由32位扩展成48位
把扩展后的48位right与第i次迭代生成的48位加密密钥进行按位异或操作 形成一个新的48位的right.
1.2.4 数据压缩
表7.1 1 2 3 4 5 6 7 8
1-8 0xe 0x0 0x4 0xf 0xd 0x7 0x1 0x4
9-16 0x2 0xe 0xf 0x2 0xb 0xd 0xb 0xe
17-24 0x3 0xa 0xa 0x6 0x6 0xc 0xc 0xb
25-32 0x5 0x9 0x9 0x5 0x0 0x3 0x7 0x8
33-40 0x4 0xf 0x1 0xc 0xe 0x8 0x8 0x2
41-48 0xd 0x4 0x6 0x9 0x2 0x1 0xb 0x7
49-56 0xf 0x5 0xc 0xb 0x9 0x3 0x7 0xe
57-64 0x3 0xa 0xa 0x0 0x5 0x6 0x0 0xd
表7.2 1 2 3 4 5 6 7 8
1-8 0xf 0x3 0x1 0xd 0x8 0x4 0xe 0x7
9-16 0x6 0xf 0xb 0x2 0x3 0x8 0x4 0xf
17-24 0x9 0xc 0x7 0x0 0x2 0x1 0xd 0xa
25-32 0xc 0x6 0x0 0x9 0x5 0xb 0xa 0x5
33-40 0x0 0xd 0xe 0x8 0x7 0xa 0xb 0x1
41-48 0xa 0x3 0x4 0xf 0xd 0x4 0x1 0x2
49-56 0x5 0xb 0x8 0x6 0xc 0x7 0x6 0xc
57-64 0x9 0x0 0x3 0x5 0x2 0xe 0xf 0x9
表7.3 1 2 3 4 5 6 7 8
1-8 0xa 0xd 0x0 0x7 0x9 0x0 0xe 0x9
9-16 0x6 0x3 0x3 0x4 0xf 0x6 0x5 0xa
17-24 0x1 0x2 0xd 0x8 0xc 0x5 0x7 0xe
25-32 0xb 0xc 0x4 0xb 0x2 0xf 0x8 0x1
33-40 0xd 0x1 0x6 0xa 0x4 0xd 0x9 0x0
41-48 0x8 0x6 0xf 0x9 0x3 0x8 0x0 0x7
49-56 0xb 0x4 0x1 0xf 0x2 0xe 0xc 0x3
57-64 0x5 0xb 0xa 0x5 0xe 0x2 0x7 0xc
表7.4 1 2 3 4 5 6 7 8
1-8 0x7 0xd 0xd 0x8 0xe 0xb 0x3 0x5
9-16 0x0 0x6 0x6 0xf 0x9 0x0 0xa 0x3
17-24 0x1 0x4 0x2 0x7 0x8 0x2 0x5 0xc
25-32 0xb 0x1 0xc 0xa 0x4 0xe 0xf 0x9
33-40 0xa 0x3 0x6 0xf 0x9 0x0 0x0 0x6
41-48 0xc 0xa 0xb 0xa 0x7 0xd 0xd 0x8
49-56 0xf 0x9 0x1 0x4 0x3 0x5 0xe 0xb
57-64 0x5 0xc 0x2 0x7 0x8 0x2 0x4 0xe
表7.5 1 2 3 4 5 6 7 8
1-8 0x2 0xe 0xc 0xb 0x4 0x2 0x1 0xc
9-16 0x7 0x4 0xa 0x7 0xb 0xd 0x6 0x1
17-24 0x8 0x5 0x5 0x0 0x3 0xf 0xf 0xa
25-32 0xd 0x3 0x0 0x9 0xe 0x8 0x9 0x6
33-40 0x4 0xb 0x2 0x8 0x1 0xc 0xb 0x7
41-48 0xa 0x1 0xd 0xe 0x7 0x2 0x8 0xd
49-56 0xf 0x6 0x9 0xf 0xc 0x0 0x5 0x9
57-64 0x6 0xa 0x3 0x4 0x0 0x5 0xe 0x3
表7.6 1 2 3 4 5 6 7 8
1-8 0xc 0xa 0x1 0xf 0xa 0x4 0xf 0x2
9-16 0x9 0x7 0x2 0xc 0x6 0x9 0x8 0x5
17-24 0x0 0x6 0xd 0x1 0x3 0xd 0x4 0xe
25-32 0xe 0x0 0x7 0xb 0x5 0x3 0xb 0x8
33-40 0x9 0x4 0xe 0x3 0xf 0x2 0x5 0xc
41-48 0x2 0x9 0x8 0x5 0xc 0xf 0x3 0xa
49-56 0x7 0xb 0x0 0xe 0x4 0x1 0xa 0x7
57-64 0x1 0x6 0xd 0x0 0xb 0x8 0x6 0xd
表7.7 1 2 3 4 5 6 7 8
1-8 0x4 0xd 0xb 0x0 0x2 0xb 0xe 0x7
9-16 0xf 0x4 0x0 0x9 0x8 0x1 0xd 0xa
17-24 0x3 0xe 0xc 0x3 0x9 0x5 0x7 0xc
25-32 0x5 0x2 0xa 0xf 0x6 0x8 0x1 0x6
33-40 0x1 0x6 0x4 0xb 0xb 0xd 0xd 0x8
41-48 0xc 0x1 0x3 0x4 0x7 0xa 0xe 0x7
49-56 0xa 0x9 0xf 0x5 0x6 0x0 0x8 0xf
57-64 0x0 0xe 0x5 0x2 0x9 0x3 0x2 0xc
表7.8 1 2 3 4 5 6 7 8
1-8 0xd 0x1 0x2 0xf 0x8 0xd 0x4 0x8
9-16 0x6 0xa 0xf 0x3 0xb 0x7 0x1 0x4
17-24 0xa 0xc 0x9 0x5 0x3 0x6 0xe 0xb
25-32 0x5 0x0 0x0 0xe 0xc 0x9 0x7 0x2
33-40 0x7 0x2 0xb 0x1 0x4 0xe 0x1 0x7
41-48 0x9 0x4 0xc 0xa 0xe 0x8 0x2 0xd
49-56 0x0 0xf 0x6 0xc 0xa 0x9 0xd 0x0
57-64 0xf 0x3 0x3 0x5 0x5 0x6 0x8 0xb
在1.2.3步中形成了48位的right值,
需要把48位的right值转换成32位的right值.把right视为由8个6位二进制块组成,
a,b….h都是6位,强制转换成10进制整数的值都不大于64 ,a,b…h转成10进制整数后,在对应的表中根据转换后整数值取得对应位置的替代值,
a对应表7.1
b对应表7.2
c对应表7.3
d对应表7.4
e对应表7.5
f对应表7.6
g对应表7.7
h对应表7.8
比如:
a = 32 ,那么到表7.1中找到32的位置,把对应的替代值0x8赋给a;
d = 53 ,那么到表7.4中找到的位置,把对应的替代值 0x3赋给d ;
g = 16, 那么到表7.7中找到16的位置,把对应的替代值0xa赋给g;
每6位用一个4位替换这样就完成了从48位向32位数据的转换.
有些资料中介绍6位转4位的实现方法与本文所采用的不同,但殊途同归,最终的结果是相同的.
1.2.5 数据换位
表8
16 7 20 21 29 12 28 17
1 15 23 26 5 18 31 10
2 8 24 14 32 27 3 9
19 13 30 6 22 11 4 25
把1.2.4步形成的32位right
根据表8进行转换:
数据的原第16位换到第一位,原第7位换到第二位，...，依此类推,最后得到新的32位数据.
1.2.6 交换数据
把right 和left按位异或后的值赋给right,然后将本轮输入的原始right值赋给left.
1.2.7 迭代
DES算法需要进行16次迭代,在完成16次迭代前,把第i-1次得到的的left和right的值作为第i次的输入数据,重复1.2.3~1.2.6的步骤,但是有一点要记住:在步骤1.2.3中第i次迭代要选择第i次迭代生成的密钥与数据进行按位异或.
1.2.8 数据整理
表9
40 8 48 16 56 24 64 32
39 7 47 15 55 23 63 31
38 6 46 14 54 22 62 30
37 5 45 13 53 21 61 29
36 4 44 12 52 20 60 28
35 3 43 11 51 19 59 27
34 2 42 10 50 18 58 26
33 1 41 9 49 17 57 25
为保证加密和解密的对称性,DES算法的前15次迭代每完成一次迭代都要交换left和right的值,第16次迭代不交换两者的数值. 到此把32位的left和right合并成64位的Data
根据表9重新调整Data的位值
数据的原第40位换到第一位,原第8位换到第二位，...，依此类推,最后的得到新的64位.
Data即为密文.
1.3 数据的解密
数据解密的算法与加密算法相同,区别在于1.2.3步中和数据进行按位异或的密钥的使用顺序不同,在加密中是按照第i次迭代就采用第i次迭代生成的密钥进行异或,而解密时第i次迭代就采用第17-i次迭代生成的密钥和数据进行异或.
二.算法实现
笔者用c语言编写了的基于DES算法的核心加密解密程序并针对不同的加密解密需求封装了6个接口函数.
2. 1 算法实现接口函数的介绍
2.1.1 int des(char *data, char *key,int readlen)
参数:
1.存放待加密明文的内存指针(长度为readlen,可能经过填充;
2.存放用户输入的密钥内存的指针
3.待加密明文的长度(8字节的倍数)
功能:
生成加密密钥,把待加密的明文数据分割成64位的块,逐块完成16次迭代加密,密文存放在data所指向的内存中.
2.1.2 int Ddes(char *data, char *key,int readlen)
参数:
1.存放待解密文的内存指针(长度为readlen,可能经过填充;
2.存放用户输入的密钥内存的指针
3.待解密文的长度( 8字节的倍数)
功能:
生成解密密钥,把待解密文分割成64位的块,逐块完成16次迭代解密,解密后的明文存放在data所指向的内存中.
2.1.3 int des3(char *data, char *key, int n ,int readlen)
参数:
1.存放待加密明文的内存指针(长度为readlen,可能经过填充;
2.存放用户输入的密钥内存的指针
3.用户指定进行多少层加密
4.待加密明文的长度(8字节的倍数)
功能:
生成加密密钥,把待加密的明文分割成64位的块,把第i-1层加密后的密文作为第i层加密的明文输入,根据用户指定的加密层数进行n层加密,最终生成的密文存放在data所指向的内存中.
说明:
用户仅仅输入一条密钥,所有的加密密钥都是由这条密钥生成.
2.1.4 int Ddes3(char *data, char*key, int n ,int readlen)
参数:
1.存放待解密文的内存指针(长度为readlen,可能经过填充;
2.存放用户输入的密钥内存的指针
3.用户指定进行多少层解密
4.待解密文的长度(8字节的倍数)
功能:
生成解密密钥,把待解密文分割成64位的块,把第i-1层解密后的"明文"作为第i层解密的密文输入,根据用户指定的解密层数进行n层解密,最终生成的明文存放在data所指向的内存中.
说明:
用户仅仅输入一条密钥,所有的解密密钥都是由这条密钥生成.
2.1.5 int desN(char*data,char**key,int n_key,int readlen)
参数:
1.存放待加密明文的内存指针(长度为readlen,可能经过填充;
2.存放用户输入的密钥内存的指针
3.用户指定了多少条密钥
4.待加密明文的长度(8字节的倍数)
功能:
生成加密密钥,把待加密的明文分割成64位的块,把第i-1层加密后的密文作为第i层加密的明文输入,根据用户指定的加密层数进行n层加密,最终生成的密文存放在data所指向的内存中.
说明:
这里用户通过输入的密钥条数决定加密的层数,每轮16次迭代加密所使用的加密密钥是由用户自定的对应密钥生成.
2.1.6 int DdesN(char*data,char**key,intn_key,int readlen)
参数:
1.存放待解密文的内存指针(长度为readlen,可能经过填充;
2.存放用户输入的密钥内存的指针
3.用户指定了多少条密钥
4.待解密文的长度(8字节的倍数)
功能:
生成解密密钥,把待解密文分割成64位的块,把第i-1层解密后的”明文”作为第i层解密的密文输入,根据用户指定的解密层数进行n层解密,最终生成的明文存放在data所指向的内存中.
说明:
这里用户通过输入的密钥条数决定解密的层数,每轮16次迭代加密所使用的解密密钥是由用户自定的对应密钥生成.
源代码说明:
这是一个有关DES算法实现文件加密工具的代码,我把算法实现的代码封装在了一个DLL中.工程中已经把环境设置好了,无论选择Debug版本还是Release版本只需直接编译就行了.使用时把.exe文件和.dll文件拷贝到同一个目录中即可
java DES 加密 解密 生成随机密钥
举例说明：
//保存生成的key
public static void saveDesKey() {
try {
SecureRandom sr = new SecureRandom();
// 选择的DES算法生成一个KeyGenerator对象
KeyGenerator kg = KeyGenerator.getInstance("DES");
kg.init(sr);
// 相对路径 需要新建 conf 文件夹
// String fileName = "conf/DesKey.xml";
// 绝对路径
String fileName = "d:/DesKey.xml";
FileOutputStream fos = new FileOutputStream(fileName);
ObjectOutputStream oos = new ObjectOutputStream(fos);
// 生成密钥
Key key = kg.generateKey();
oos.writeObject(key);
oos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
//获取生成的key
public static Key getKey() {
Key kp = null;
try {
// 相对路径 需要新建 conf 文件夹
// String fileName = "conf/DesKey.xml";
// InputStream is = Encrypt.class.getClassLoader().getResourceAsStream(fileName);
// 绝对路径
String fileName = "d:/DesKey.xml";
FileInputStream is = new FileInputStream(fileName);
ObjectInputStream oos = new ObjectInputStream(is);
kp = (Key) oos.readObject();
oos.close();
} catch (Exception e) {
e.printStackTrace();
}
return kp;
}
//加密开始
public static void encrypt(String file, String dest) throws Exception {
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, getKey());
InputStream is = new FileInputStream(file);
OutputStream out = new FileOutputStream(dest);
CipherInputStream cis = new CipherInputStream(is, cipher);
byte[] buffer = new byte[1024];
int r;
while ((r = cis.read(buffer)) 0) {
out.write(buffer, 0, r);
}
cis.close();
is.close();
out.close();
}
//解密开始
public static void decrypt(String file, String dest) throws Exception {
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.DECRYPT_MODE, getKey());
InputStream is = new FileInputStream(file);
OutputStream out = new FileOutputStream(dest);
CipherOutputStream cos = new CipherOutputStream(out, cipher);
byte[] buffer = new byte[1024];
int r;
while ((r = is.read(buffer)) = 0) {
cos.write(buffer, 0, r);
}
cos.close();
out.close();
is.close();
}
}
//des加密主方法
public class DES {
public static void main(String[] args) throws Exception {
Encrypt.saveDesKey();
System.out.println("生成key");
Encrypt.getKey();
System.out.println("获取key");
Encrypt.encrypt("d:\\hello.txt", "d:\\encrypt.txt");
System.out.println("加密");
Encrypt.decrypt("d:\\encrypt.txt", "d:\\decrypt.txt");
System.out.println("解密");
}
以上方法亲测可用。
DES是一种对称加密算法，所谓对称加密算法即：加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究，
后来被美国政府正式采用，之后开始广泛流传，但是近些年使用越来越少，因为DES使用56位密钥，以现代计算能力，
24小时内即可被破解
调用过程
最近做微信小程序获取用户绑定的手机号信息解密，试了很多方法。最终虽然没有完全解决，但是也达到我的极限了。有时会报错：javax.crypto.BadPaddingException: pad block corrupted。
出现错误的详细描述
每次刚进入小程序登陆获取手机号时，会出现第一次解密失败，再试一次就成功的问题。如果连续登出，登入，就不会再出现揭秘失败的问题。但是如果停止操作过一会，登出后登入，又会出现第一次揭秘失败，再试一次就成功的问题。
网上说的，官方文档上注意点我都排除了。获取的加密密文是在前端调取wx.login（）方法后，调用我后端的微信授权接口，获取用户的sessionkey，openId.然后才是前端调用的获取sessionkey加密的用户手机号接口，所以我可以保证每次sessionkey是最新的。不会过期。
并且我通过日志发现在sessionkey不变的情况下，第一次失败，第二次解密成功。
加密算法，RSA是绕不开的话题，因为RSA算法是目前最流行的公开密钥算法，既能用于加密，也能用户数字签名。不仅在加密货币领域使用，在传统互联网领域的应用也很广泛。从被提出到现在20多年，经历了各种考验，被普遍认为是目前最优秀的公钥方案之一
非对称加密算法的特点就是加密秘钥和解密秘钥不同，秘钥分为公钥和私钥，用私钥加密的明文，只能用公钥解密；用公钥加密的明文，只能用私钥解密。
一、 什么是“素数”？
素数是这样的整数，它除了能表示为它自己和1的乘积以外，不能表示为任何其它两个整数的乘积
二、什么是“互质数”（或“互素数”）？
小学数学教材对互质数是这样定义的：“公约数只有1的两个数，叫做互质数
（1）两个质数一定是互质数。例如，2与7、13与19。
（2）一个质数如果不能整除另一个合数，这两个数为互质数。例如，3与10、5与 26。
（3）1不是质数也不是合数，它和任何一个自然数在一起都是互质数。如1和9908。
（4）相邻的两个自然数是互质数。如 15与 16。
（5）相邻的两个奇数是互质数。如 49与 51。
（6）大数是质数的两个数是互质数。如97与88。
（7）小数是质数，大数不是小数的倍数的两个数是互质数。如 7和 16。
（8）两个数都是合数（二数差又较大），小数所有的质因数，都不是大数的约数，这两个数是互质数。如357与715，357=3×7×17，而3、7和17都不是715的约数，这两个数为互质数。等等。
三、什么是模指数运算？
指数运算谁都懂，不必说了，先说说模运算。模运算是整数运算，有一个整数m，以n为模做模运算，即m mod n。怎样做呢？让m去被n整除，只取所得的余数作为结果，就叫做模运算。例如，10 mod 3=1；26 mod 6=2；28 mod 2 =0等等。
模指数运算就是先做指数运算，取其结果再做模运算。如(5^3) mod 7 = (125 mod 7) = 6。
其中，符号^表示数学上的指数运算；mod表示模运算，即相除取余数。具体算法步骤如下：
（1）选择一对不同的、足够大的素数p，q。
（2）计算n=p q。
（3）计算f(n)=(p-1) (q-1)，同时对p, q严加保密，不让任何人知道。
（4）找一个与f(n)互质的数e作为公钥指数，且1ef(n)。
（5）计算私钥指数d，使得d满足(d*e) mod f(n) = 1
（6）公钥KU=(e,n)，私钥KR=(d,n)。
（7）加密时，先将明文变换成0至n-1的一个整数M。若明文较长，可先分割成适当的组，然后再进行交换。设密文为C，则加密过程为：C=M^e mod n。
（8）解密过程为：M=C^d mod n。
在RSA密码应用中，公钥KU是被公开的，即e和n的数值可以被第三方窃听者得到。破解RSA密码的问题就是从已知的e和n的数值（n等于pq），想法求出d的数值，这样就可以得到私钥来破解密文。从上文中的公式：(d e) mod ((p-1) (q-1)) = 1，我们可以看出，密码破解的实质问题是：从p q的数值，去求出(p-1)和(q-1)。换句话说，只要求出p和q的值，我们就能求出d的值而得到私钥。
当p和q是一个大素数的时候，从它们的积p q去分解因子p和q，这是一个公认的数学难题。比如当p*q大到1024位时，迄今为止还没有人能够利用任何计算工具去完成分解因子的任务。因此，RSA从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。
缺点1：虽然RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。即RSA的重大缺陷是无法从理论上把握它的保密性能如何。
在android 开发的很多时候。为了保证用户的账户的安全性，再保存用户的密码时，通常会采用MD5加密算法，这种算法是不可逆的，具有一定的安全性
MD5不是加密算法， 因为如果目的是加密，必须满足的一个条件是加密过后可以解密。但是MD5是无法从结果还原出原始数据的。
MD5只是一种哈希算法
/// summary
/// 加密原函数
/// /summary
/// param name="str_in_data"加密原串/param
/// param name="str_DES_KEY"密钥/param
/// returns加密串/returns
public static string Encrypt_DES16(string str_in_data, string str_DES_KEY)
{
try
{
byte[] shuju = new byte[8];
byte[] keys = new byte[8];
for (int i = 0; i 8; i++)
{
shuju[i] = Convert.ToByte(str_in_data.Substring(i * 2, 2), 16);
keys[i] = Convert.ToByte(str_DES_KEY.Substring(i * 2, 2), 16);
}
DES desEncrypt = new DESCryptoServiceProvider();
desEncrypt.Mode = CipherMode.ECB;
//desEncrypt.Key = ASCIIEncoding.ASCII.GetBytes(str_DES_KEY);
desEncrypt.Key = keys;
byte[] Buffer;
Buffer = shuju;//ASCIIEncoding.ASCII.GetBytes(str_in_data);
ICryptoTransform transForm = desEncrypt.CreateEncryptor();
byte[] R;
R = transForm.TransformFinalBlock(Buffer, 0, Buffer.Length);
string return_str = "";
foreach (byte b in R)
{
return_str += b.ToString("X2");
}
return_str = return_str.Substring(0, 16);
return return_str;
}
catch (Exception e)
{
throw e;
}
}
