我将如何实现使用Java攻击TripleDES的暴力?
我一直在做我的科学项目,当时我想做一个实验,通过暴力强迫来测试TripleDES的安全性。TripleDES由三个密钥组成,每个密钥56位(加上8个奇偶校验位),其中每个密钥可以是两种模式,解密或加密。因此,有八种可能的组合(如下所列): 利用这一原理,我将如何设计一个Java程序,对三元组强制执行所有可能的键,并可能找到原始的纯文本 以下是我为单曲DES所做的尝试:我将如何实现使用Java攻击TripleDES的暴力?,java,encryption,brute-force,des,tripledes,Java,Encryption,Brute Force,Des,Tripledes,我一直在做我的科学项目,当时我想做一个实验,通过暴力强迫来测试TripleDES的安全性。TripleDES由三个密钥组成,每个密钥56位(加上8个奇偶校验位),其中每个密钥可以是两种模式,解密或加密。因此,有八种可能的组合(如下所列): 利用这一原理,我将如何设计一个Java程序,对三元组强制执行所有可能的键,并可能找到原始的纯文本 以下是我为单曲DES所做的尝试: import java.security.spec.AlgorithmParameterSpec; import javax
import java.security.spec.AlgorithmParameterSpec;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.BitSet;
public class DES64 {
public static byte[] generateKey(byte [] encoded_key2, int N_BYTE) {
byte[] encoded_key = new byte[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
for (int i = 0; i < N_BYTE; i++) {
encoded_key[8 - N_BYTE + i] = encoded_key2[i];
}
return encoded_key;
}
public static byte[] des_attack(String plaintext, byte[] encoded_key2, int N_BYTE) throws Exception {
byte[] encoded_key = generateKey(encoded_key2, N_BYTE);
SecretKey key = new SecretKeySpec(encoded_key, "DES");
byte[] initVector = new byte[] { 0x10, 0x10, 0x01, 0x04, 0x01, 0x01, 0x01, 0x02 };
AlgorithmParameterSpec algParamSpec = new IvParameterSpec(initVector);
Cipher m_encrypter = Cipher.getInstance("DES/CBC/PKCS5Padding");
m_encrypter.init(Cipher.ENCRYPT_MODE, key, algParamSpec);
Cipher m_decrypter = Cipher.getInstance("DES/CBC/PKCS5Padding");
byte[] clearText = plaintext.getBytes();
byte[] encryptedText = m_encrypter.doFinal(clearText);
int guess = 0;
int N_COMB = (int) Math.pow(2.0, (N_BYTE) * 7);
System.out.println("All possible combiantions : " + N_COMB);
BitSet encoding_attack_key = new BitSet(8 * N_BYTE);
encoding_attack_key.clear();
byte[] mykey = new byte[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
for (int i = 0; i < N_COMB; i++) {
String tmp = Integer.toBinaryString(i);
int z = 0;
int j = tmp.length() - 1;
while (j >= 0) {
if (z != 63 && z != 55 && z != 47 && z != 39 && z != 31 && z != 23 && z != 15 && z != 7) {
if (tmp.charAt(j) == '1') {
encoding_attack_key.set(z);
}
j--;
z++;
} else {
z++;
}
}
for (int k = 0; k < N_BYTE; k++) {
if (encoding_attack_key.get(k * 8, (k * 8) + 7).cardinality() % 2 != 0) {
encoding_attack_key.set((k * 8) + 7);
}
}
if (guess % 1000000 == 0) {
System.out.println("Guess : " + guess + " out of : " + N_COMB + " ------- "
+ 100 * (guess + 0.0) / N_COMB + "% completed");
}
guess++;
int len = encoding_attack_key.toByteArray().length;
mykey[0] = len >= 8 ? encoding_attack_key.toByteArray()[7] : 0x0;
mykey[1] = len >= 7 ? encoding_attack_key.toByteArray()[6] : 0x0;
mykey[2] = len >= 6 ? encoding_attack_key.toByteArray()[5] : 0x0;
mykey[3] = len >= 5 ? encoding_attack_key.toByteArray()[4] : 0x0;
mykey[4] = len >= 4 ? encoding_attack_key.toByteArray()[3] : 0x0;
mykey[5] = len >= 3 ? encoding_attack_key.toByteArray()[2] : 0x0;
mykey[6] = len >= 2 ? encoding_attack_key.toByteArray()[1] : 0x0;
mykey[7] = len >= 1 ? encoding_attack_key.toByteArray()[0] : 0x0;
SecretKey key_g = new SecretKeySpec(mykey, "DES");
m_decrypter.init(Cipher.DECRYPT_MODE, key_g, algParamSpec);
try {
byte[] text_g = m_decrypter.doFinal(encryptedText);
String plain_text = new String(text_g);
if (plain_text.equals(new String(clearText))) {
return mykey;
}
} catch (BadPaddingException ee) {
}
encoding_attack_key.clear();
}
return null;
}
public static void main(String args[]) throws Exception {
String plaintext = "example";
int nbyte = 4;
byte[] b = new byte[] { 0x6, 0x7, 0x35, 0x09 };
long startTime = System.nanoTime();
byte[] ris = des_attack(plaintext, b, b.length);
long estimatedTime = (System.nanoTime() - startTime);
String kris = "";
for (int i = 0; i < ris.length; i++)
kris += " " + ris[i] + " ";
System.out.println("PLAINTEXT : " + plaintext + " ESTIMATED TIME: " + estimatedTime
+ " NFREE_BYTE_KEY: " + nbyte + " KEY: " + kris + "\n");
}
}
导入java.security.spec.AlgorithmParameterSpec;
导入javax.crypto.BadPaddingException;
导入javax.crypto.Cipher;
导入javax.crypto.SecretKey;
导入javax.crypto.spec.IvParameterSpec;
导入javax.crypto.spec.SecretKeySpec;
导入java.util.BitSet;
公共类DES64{
公共静态字节[]generateKey(字节[]编码的密钥2,整数N字节){
byte[]encoded_key=新字节[]{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
for(int i=0;i=0){
如果(z!=63&&z!=55&&z!=47&&z!=39&&z!=31&&z!=23&&z!=15&&z!=7){
如果(tmp.字符(j)='1'){
编码攻击密钥集(z);
}
j--;
z++;
}否则{
z++;
}
}
for(int k=0;k=8?编码\u攻击\u key.toByteArray()[7]:0x0;
mykey[1]=len>=7?编码\u攻击\u key.toByteArray()[6]:0x0;
mykey[2]=len>=6?编码\u攻击\u key.toByteArray()[5]:0x0;
mykey[3]=len>=5?编码\u攻击\u key.toByteArray()[4]:0x0;
mykey[4]=len>=4?编码\u攻击\u key.toByteArray()[3]:0x0;
mykey[5]=len>=3?编码\u攻击\u key.toByteArray()[2]:0x0;
mykey[6]=len>=2?编码\u攻击\u key.toByteArray()[1]:0x0;
mykey[7]=len>=1?编码\u攻击\u key.toByteArray()[0]:0x0;
SecretKey_g=新的SecretKey规范(mykey,“DES”);
m_decrypter.init(Cipher.DECRYPT_模式,key_g,algParamSpec);
试一试{
字节[]text\u g=m\u decrypter.doFinal(encryptedText);
字符串纯文本=新字符串(文本);
if(纯文本等于(新字符串(明文))){
返回mykey;
}
}捕获(BadPaddingEE异常){
}
编码_攻击_键。清除();
}
返回null;
}
公共静态void main(字符串args[])引发异常{
String plaintext=“示例”;
int-nbyte=4;
字节[]b=新字节[]{0x6,0x7,0x35,0x09};
long startTime=System.nanoTime();
字节[]ris=des_攻击(明文,b,b.长度);
长估计时间=(System.nanoTime()-startTime);
字符串kris=“”;
对于(int i=0;i
。顺便说一句,这只是DES-EDE,其他的都没有。当然,解密是使用DED顺序执行的。Triple-DES有两键和三键模式(不考虑为了向后兼容而简单地恢复为DES的模式)
双密钥三重DES模式(使用所谓的DES ABA密钥作为最终DES密码的a密钥)在最坏情况下的强度约为80位。这有点接近暴力,暴力程度仅是使用谷歌基础设施实施的破坏性攻击的2^16倍。这不是Java和PC本身所能做到的
三键三重DES和DES-ABC键的强度大约为2^112,没有办法用暴力迫使你摆脱这个困境。因此,简单的答案是:不管有没有Java,“你都不会”