本文目录一览：
- 1、C#(加密)Des很容易被破解吗?
- 2、请问各位电脑高手，DES密文在没有密钥的情况下能不能被电脑高手或者数学家破解出来？
- 3、des和aes 加解密算法具体步骤？有例子最好
- 4、DES加密算法的破解是怎么回事？
- 5、怎么解密ＤＥＳ文件？
- 6、如何使用JAVA实现对字符串的DES加密和解密
C#(加密)Des很容易被破解吗?
用C#做加密相对其他语言而言，是比较容易被破解的
C#是一种中间语言，做加密有一个致命的问题，它可以被完全逆向成源代码
因此无论做什么加密，加密代码都可以呈现在破解者面前
算法本身并没有问题（当然AES安全性确实高于DES，不论是密钥长度、抗分析能力都远超后者），可是代码变成白盒，算法再厉害，解密的密钥直接可以从代码中分析出来，算法也就没有意义了。
因此算法部分最好是用C/C++这些可以直接运行的，目标文件为机器码级别的语言开发相对比较安全。
同样作为中间语言的java、python也有这种缺点。
请问各位电脑高手，DES密文在没有密钥的情况下能不能被电脑高手或者数学家破解出来？
DES密文现在是可以被破解的，在wiki上就给出了3中暴力破解方法：
引用于wiki百科DES条目
=======================================================================
快于暴力攻击的攻击方法
有三种已知方法可以以小于暴力破解的复杂性破解DES的全部16回次：微分密码分析（DC），线性密码分析（LC），以及戴维斯攻击。然而，这些攻击都是理论性的，难以用于实践；它们有时被归结于认证的弱点。
微分密码分析在1980年代晚期由艾力·毕汉姆和阿迪·萨莫尔重新发现[36][37]；1970年代IBM和NSA便发现了这种方法，但没有公开。为了破解全部16回次，微分密码分析需要247组选择明文。DES被设计为对DC具有抵抗性。
线性密码分析由松井充（Mitsuru Matsui）发现，需要243组已知明文[38]；该方法已被实现[22]，是第一种公开的实验性的针对DES的密码分析。没有证据显示DES的设计可以抵抗这种攻击方法。一般概念上的LC—“多线性密码分析”—在1994年由Kaliski和Robshaw所建议[39]，并由比留科夫等人于2004年所改进[40]。线性密码分析的选择明文变种是一种类似的减少数据复杂性的方法[2]。帕斯卡尔·朱诺德（Pascal Junod）在2001年进行了一些确定线性密码分析的实际时间复杂性的实验，结果显示它比预期的要快，需要约239–241次操作[1]。
改进的戴维斯攻击：线性和微分密码分析是针对很多算法的通用技术，而戴维斯攻击是一种针对DES的特别技术，在1980年代由唐纳德·戴维斯（Donald Davies）首先提出，并于1997年为毕汉姆和亚历克斯·比留科夫（Alex Biryukov）所改进[41][42]。其最有效的攻击形式需要250已知明文，计算复杂性亦为250，成功率为51%。
也有一些其它的针对削减了回次的密码版本，即少于16回次的DES版本。这些攻击显示了多少回次是安全所需的，以及完整版本拥有多少“安全余量”。微分线性密码分析于1994年为兰福德（Langford）和海尔曼所提出，是一种组合了微分和线性密码分析的方法[43]。一种增强的微分线性密码分析版本可以利用215.8 组已知明文可以以229.2的时间复杂性破解9回次的DES[44]。
=========================================================================
DES二进制和十六进制区分，所有处理都会在bit单位，就算是16进制也会转成二进制处理，最多由于位数增多，划分的64bit加密快增多，但没有在算法复杂度上增加破解难度。如果破解二进制所需时间为N，破解十六进制所需时间为8N
=========================================================================
补充回答：
这是不可能的。如果你不知道密文，就算你有秘钥也没办法还原。AES的加密过程是把明文和秘钥混淆。
des和aes 加解密算法具体步骤？有例子最好
随着计算机网络和计算机通讯技术的发展，计算机密码学得到前所未有的重视并迅速普及和发展起来。由于密码系统的各种性能主要由密码算法所决定，不同的算法决定了不同的密码体制，而不同的密码体制又有着不同的优缺点：有的密码算法高速简便，但加解密密钥相同，密钥管理困难；有的密码算法密钥管理方便安全，但计算开销大、处理速度慢。基于此，本文针对两种典型的密码算法DES和RSA的特点进行讨论分析，并提出一种以这两种密码体制为基础的混合密码系统，来实现优势互补。
1 密码系统简介
1.1 密码系统分类
密码系统从原理上可分为两大类，即单密钥系统和双密钥系统。单密钥系统又称为对称密码系统，其加密密钥和解密密钥或者相同，或者实质上相同，即易于从一个密钥得出另一个，如图1所示。双密钥系统又称为公开密钥密码系统，它有两个密钥，一个是公开的，用K1表示，谁都可以使用；另一个是私人密钥，用K2表示，只由采用此系统的人掌握。从公开的密钥推不出私人密钥，如图2所示。
1.2 两种密码系统分析
1.2.1 对称密码系统（单钥密码系统）
对称密码系统中加密和解密均采用同一把密钥，而且通信双方必须都要获得这把密钥。这就带来了一系列问题。首先，密钥本身的发送就存在着风险，如果在发送中丢失，接受方就不可能重新得到密文的内容；其次，多人通信时密钥的组合的数量会出现爆炸性的膨胀，N个人两两通信，需要N*(N-1)/2把密钥，增加了分发密钥的代价和难度；最后，由于通信双方必须事先统一密钥，才能发送保密的信息，这样，陌生人之间就无法发送密文了。
1.2.2 公开密钥密码系统（双钥密码系统）
公开密钥密码系统中，收信人生成两把数学上关联但又不同的公钥和私钥，私钥自己保存，把公钥公布出去，发信人使用收信人的公钥对通信文件进行加密，收信人收到密文后用私钥解密。公开密钥密码系统的优势在于，首先，用户可以把用于加密的钥匙公开地发给任何人，并且除了持有私有密钥的收信人之外，无人能解开密文；其次，用户可以把公开钥匙发表或刊登出来，使得陌生人之间可以互发保密的通信；最后，公开密钥密码系统提供了数字签字的公开鉴定系统，而这是对称密码系统不具备的。
1.3 典型算法
对称密码系统的算法有DES，AES，RC系列，DEA等，公开密钥密码系统的算法有RSA，Diffie-Hellman， Merkle-Hellman等。
2 DES算法
DES (Data Encryption Standard，数据加密标准)是一个分组加密算法，它以64 bit位(8 byte)为分组对数据加密，其中有8 bit奇偶校验，有效密钥长度为56 bit。64 位一组的明文从算法的一端输入，64 位的密文从另一端输出。DES算法的加密和解密用的是同一算法，它的安全性依赖于所用的密钥。DES 对64位的明文分组进行操作，通过一个初始置换，将明文分组成左半部分和右半部分，各32位长。然后进行16轮完全相同的运算，这些运算被称为函数f，在运算过程中数据与密钥结合。经过16轮后，左、右半部分合在一起经过一个末置换(初始置换的逆置换)，完成算法。在每一轮中，密钥位移位，然后再从密钥的56位中选出48位。通过一个扩展置换将数据的右半部分扩展成48位，并通过一个异或操作与48位密钥结合，通过8个s盒将这48位替代成新的32位数据，再将其置换一次。这些运算构成了函数f。然后，通过另一个异或运算，函数f输出与左半部分结合，其结果即成为新的右半部分， 原来的右半部分成为新的左半部分。将该操作重复16次，实现DES的16轮运算。
3 RSA算法
RSA算法使用两个密钥，一个公共密钥，一个私有密钥。如用其中一个加密，则可用另一个解密。密钥长度从40到2048 bit可变。加密时把明文分成块，块的大小可变，但不能超过密钥的长度，RSA算法把每一块明文转化为与密钥长度相同的密文块。密钥越长，加密效果越好，但加密解密的开销也大，所以要在安全与性能之间折衷考虑，一般64位是较合适的。RSA算法利用了陷门单向函数的一种可逆模指数运算，描述如下：(1)选择两个大素数p和q；(2)计算乘积n=pq和φ(n)=(p-1)(q-1)；(3)选择大于1小于φ(n)的随机整数e，使得
gcd(e，φ(n))=1；(4)计算d使得de=1modφ(n)；(5)对每一个密钥k=(n，p，q，d，e)，定义加密变换为Ek(x)=xemodn，解密变换为Dk(y)=ydmodn，这里x，y∈Zn；(6)以{e，n}为公开密钥，{p，q，d}为私有密钥。
4 基于DES和RSA的混合密码系统
4.1 概述
混合密码系统充分利用了公钥密码和对称密码算法的优点，克服其缺点，解决了每次传送更新密钥的问题。发送者自动生成对称密钥，用对称密钥按照DES算法加密发送的信息，将生成的密文连同用接受方的公钥按照RSA算法加密后的对称密钥一起传送出去。收信者用其密钥按照RSA算法解密被加密的密钥来得到对称密钥，并用它来按照DES算法解密密文。
4.2 具体实现步骤
（1）发信方选择对称密钥K（一般为64位，目前可以达到192位）
（2）发信方加密消息：对明文按64位分组进行操作，通过一个初始置换，将明文分组成左半部分和右半部分。然后进行16轮完全相同的运算，最后，左、右半部分合在一起经过一个末置换(初始置换的逆置换)，完成算法。在每一轮中，密钥位移位，然后再从密钥的56位中选出48位。通过一个扩展置换将数据的右半部分扩展成48位，并通过一个异或操作与48位密钥结合，通过8个S盒将这48位替代成新的32位数据，再将其置换一次。然后通过另一个异或运算，输出结果与左半部分结合，其结果即成为新的右半部分，原来的右半部分成为新的左半部分。如图3所示。
（3）收信方产生两个足够大的强质数p、q，计算n=p×q和z=(p-1)×(q-1)，然后再选取一个与z互素的奇数e，从这个e值找出另一个值d，使之满足e×d=1 mod (z)条件。以两组数(n，e) 和 (n，d)分别作为公钥和私钥。收信方将公钥对外公开，从而收信方可以利用收信方的公钥对 （1）中产生的对称密钥的每一位x进行加密变换Ek(x)=xemodn；
（4）发信方将步骤（2）和（3）中得到的消息的密文和对称密钥的密文一起发送给收信方；
（5）收信方用（3）中得到的私钥来对对称密钥的每一位y进行解密变换Dk(y)=ydmodn，从而得到（1）中的K；
（6）收信方用对称密钥K和DES算法的逆步骤来对消息进行解密，具体步骤和（2）中恰好相反，也是有16轮迭代。
（7）既可以由收信方保留对称密钥K来进行下一次数据通信，也可以由收信方产生新的对称密钥，从而使K作废。
4.3 两点说明
4.3.1 用公钥算法加密密钥
在混合密码系统中，公开密钥算法不用来加密消息，而用来加密密钥，这样做有两个理由：第一，公钥算法比对称算法慢，对称算法一般比公钥算法快一千倍。计算机在大约15年后运行公开密钥密码算法的速度才能比得上现在计算机运行对称密码的速度。并且，随着带宽需求的增加，比公开密钥密码处理更快的加密数据要求越来越多。第二，公开密钥密码系统对选择明文攻击是脆弱的。密码分析者只需要加密所有可能的明文，将得到的所有密文与要破解的密文比较，这样，虽然它不可能恢复解密密钥，但它能够确定当前密文所对应的明文。
4.3.2 安全性分析
如果攻击者无论得到多少密文，都没有足够的信息去恢复明文，那么该密码系统就是无条件安全的。在理论上，只有一次一密的系统才能真正实现这一点。而在本文所讨论的混合密码系统中，发信方每次可以自由选择对称密钥来加密消息，然后用公钥算法来加密对称密钥，即用户可以采用一次一密的方式来进行数据通信，达到上述的无条件安全。
5 小结
基于DES和RSA的混合密码系统结合了公钥密码体制易于密钥分配的特点和对称密码体制易于计算、速度快的特点，为信息的安全传输提供了良好的、快捷的途径，使数据传输的密文被破解的几率大大降低，从而对数据传输的安全性形成更有力的保障，并且发信方和收信方对密钥的操作自由度得到了很大的发挥。
DES加密算法的破解是怎么回事？
密码算法的破解根据破译者掌握的信息不同，可分为唯密文攻击，已知明文攻击，选择明文攻击和选择密文攻击。
破解一个分组密码算法，是指根据掌握的信息，求出密钥。
这里，破译者也许只有密文，也许有了一定数量的明文-密文对，或者有了加密机，输入任意的明文，都可以得到密文，总之，破译的目标是“找到密钥”。
穷举法就是对56比特的所有可能密钥进行穷举，一个一个试，直到找出正确密钥。
怎么解密ＤＥＳ文件？
数据加密算法（Data Encryption Algorithm，DEA）的数据加密标准（Data Encryption Standard，DES）是规范的描述，它出自 IBM 的研究工作，并在 1997 年被美国政府正式采纳。它很可能是使用最广泛的秘钥系统，特别是在保护金融数据的安全中，最初开发的 DES 是嵌入硬 件中的。通常，自动取款机（Automated Teller Machine，ATM）都使用 DES。
DES的解密一般都很麻烦，也很难，建议你去下载一个破解密码的工具试试看行不行。
如何使用JAVA实现对字符串的DES加密和解密
java加密字符串可以使用des加密算法，实例如下：
package test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
/**
* 加密解密
*
* @author shy.qiu
* @since
*/
public class CryptTest {
/**
* 进行MD5加密
*
* @param info
* 要加密的信息
* @return String 加密后的字符串
*/
public String encryptToMD5(String info) {
byte[] digesta = null;
try {
// 得到一个md5的消息摘要
MessageDigest alga = MessageDigest.getInstance("MD5");
// 添加要进行计算摘要的信息
alga.update(info.getBytes());
// 得到该摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 将摘要转为字符串
String rs = byte2hex(digesta);
return rs;
}
/**
* 进行SHA加密
*
* @param info
* 要加密的信息
* @return String 加密后的字符串
*/
public String encryptToSHA(String info) {
byte[] digesta = null;
try {
// 得到一个SHA-1的消息摘要
MessageDigest alga = MessageDigest.getInstance("SHA-1");
// 添加要进行计算摘要的信息
alga.update(info.getBytes());
// 得到该摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 将摘要转为字符串
String rs = byte2hex(digesta);
return rs;
}
// //////////////////////////////////////////////////////////////////////////
/**
* 创建密匙
*
* @param algorithm
* 加密算法,可用 DES,DESede,Blowfish
* @return SecretKey 秘密（对称）密钥
*/
public SecretKey createSecretKey(String algorithm) {
// 声明KeyGenerator对象
KeyGenerator keygen;
// 声明 密钥对象
SecretKey deskey = null;
try {
// 返回生成指定算法的秘密密钥的 KeyGenerator 对象
keygen = KeyGenerator.getInstance(algorithm);
// 生成一个密钥
deskey = keygen.generateKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 返回密匙
return deskey;
}
/**
* 根据密匙进行DES加密
*
* @param key
* 密匙
* @param info
* 要加密的信息
* @return String 加密后的信息
*/
public String encryptToDES(SecretKey key, String info) {
// 定义 加密算法,可用 DES,DESede,Blowfish
String Algorithm = "DES";
// 加密随机数生成器 (RNG),(可以不写)
SecureRandom sr = new SecureRandom();
// 定义要生成的密文
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
// 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1.init(Cipher.ENCRYPT_MODE, key, sr);
// 对要加密的内容进行编码处理,
cipherByte = c1.doFinal(info.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
// 返回密文的十六进制形式
return byte2hex(cipherByte);
}
/**
* 根据密匙进行DES解密
*
* @param key
* 密匙
* @param sInfo
* 要解密的密文
* @return String 返回解密后信息
*/
public String decryptByDES(SecretKey key, String sInfo) {
// 定义 加密算法,
String Algorithm = "DES";
// 加密随机数生成器 (RNG)
SecureRandom sr = new SecureRandom();
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
c1.init(Cipher.DECRYPT_MODE, key, sr);
// 对要解密的内容进行编码处理
cipherByte = c1.doFinal(hex2byte(sInfo));
} catch (Exception e) {
e.printStackTrace();
}
// return byte2hex(cipherByte);
return new String(cipherByte);
}
// /////////////////////////////////////////////////////////////////////////////
/**
* 创建密匙组，并将公匙，私匙放入到指定文件中
*
* 默认放入mykeys.bat文件中
*/
public void createPairKey() {
try {
// 根据特定的算法一个密钥对生成器
KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");
// 加密随机数生成器 (RNG)
SecureRandom random = new SecureRandom();
// 重新设置此随机对象的种子
random.setSeed(1000);
// 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器
keygen.initialize(512, random);// keygen.initialize(512);
// 生成密钥组
KeyPair keys = keygen.generateKeyPair();
// 得到公匙
PublicKey pubkey = keys.getPublic();
// 得到私匙
PrivateKey prikey = keys.getPrivate();
// 将公匙私匙写入到文件当中
doObjToFile("mykeys.bat", new Object[] { prikey, pubkey });
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
/**
* 利用私匙对信息进行签名 把签名后的信息放入到指定的文件中
*
* @param info
* 要签名的信息
* @param signfile
* 存入的文件
*/
public void signToInfo(String info, String signfile) {
// 从文件当中读取私匙
PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);
// 从文件中读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);
try {
// Signature 对象可用来生成和验证数字签名
Signature signet = Signature.getInstance("DSA");
// 初始化签署签名的私钥
signet.initSign(myprikey);
// 更新要由字节签名或验证的数据
signet.update(info.getBytes());
// 签署或验证所有更新字节的签名，返回签名
byte[] signed = signet.sign();
// 将数字签名,公匙,信息放入文件中
doObjToFile(signfile, new Object[] { signed, mypubkey, info });
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 读取数字签名文件 根据公匙，签名，信息验证信息的合法性
*
* @return true 验证成功 false 验证失败
*/
public boolean validateSign(String signfile) {
// 读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);
// 读取签名
byte[] signed = (byte[]) getObjFromFile(signfile, 1);
// 读取信息
String info = (String) getObjFromFile(signfile, 3);
try {
// 初始一个Signature对象,并用公钥和签名进行验证
Signature signetcheck = Signature.getInstance("DSA");
// 初始化验证签名的公钥
signetcheck.initVerify(mypubkey);
// 使用指定的 byte 数组更新要签名或验证的数据
signetcheck.update(info.getBytes());
System.out.println(info);
// 验证传入的签名
return signetcheck.verify(signed);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将二进制转化为16进制字符串
*
* @param b
* 二进制字节数组
* @return String
*/
public String byte2hex(byte[] b) {
String hs = "";
String stmp = "";
for (int n = 0; n b.length; n++) {
stmp = (java.lang.Integer.toHexString(b[n] 0XFF));
if (stmp.length() == 1) {
hs = hs + "0" + stmp;
} else {
hs = hs + stmp;
}
}
return hs.toUpperCase();
}
/**
* 十六进制字符串转化为2进制
*
* @param hex
* @return
*/
public byte[] hex2byte(String hex) {
byte[] ret = new byte[8];
byte[] tmp = hex.getBytes();
for (int i = 0; i 8; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
/**
* 将两个ASCII字符合成一个字节； 如："EF"-- 0xEF
*
* @param src0
* byte
* @param src1
* byte
* @return byte
*/
public static byte uniteBytes(byte src0, byte src1) {
byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 }))
.byteValue();
_b0 = (byte) (_b0 4);
byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 }))
.byteValue();
byte ret = (byte) (_b0 ^ _b1);
return ret;
}
/**
* 将指定的对象写入指定的文件
*
* @param file
* 指定写入的文件
* @param objs
* 要写入的对象
*/
public void doObjToFile(String file, Object[] objs) {
ObjectOutputStream oos = null;
try {
FileOutputStream fos = new FileOutputStream(file);
oos = new ObjectOutputStream(fos);
for (int i = 0; i objs.length; i++) {
oos.writeObject(objs[i]);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 返回在文件中指定位置的对象
*
* @param file
* 指定的文件
* @param i
* 从1开始
* @return
*/
public Object getObjFromFile(String file, int i) {
ObjectInputStream ois = null;
Object obj = null;
try {
FileInputStream fis = new FileInputStream(file);
ois = new ObjectInputStream(fis);
for (int j = 0; j i; j++) {
obj = ois.readObject();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}
/**
* 测试
*
* @param args
*/
public static void main(String[] args) {
CryptTest jiami = new CryptTest();
// 执行MD5加密"Hello world!"
System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));
// 生成一个DES算法的密匙
SecretKey key = jiami.createSecretKey("DES");
// 用密匙加密信息"Hello world!"
String str1 = jiami.encryptToDES(key, "Hello");
System.out.println("使用des加密信息Hello为:" + str1);
// 使用这个密匙解密
String str2 = jiami.decryptByDES(key, str1);
System.out.println("解密后为：" + str2);
// 创建公匙和私匙
jiami.createPairKey();
// 对Hello world!使用私匙进行签名
jiami.signToInfo("Hello", "mysign.bat");
// 利用公匙对签名进行验证。
if (jiami.validateSign("mysign.bat")) {
System.out.println("Success!");
} else {
System.out.println("Fail!");
}
}
}