java - Java 传递字符串错误的暴力算法

Question

我认为这可能是一个非常简单的解决方案，但我不太确定。

我正在尝试创建一个字符数组，通过递增数组的特定索引并将它们放入末尾的字符串中对它们进行排序。

我已经完成了这个，(通过将结果打印到控制台进行验证。“aaaaaaaa”到“aaaaaaab”等等。但是，我的新版本代码对 ASCII 值 33 - 126 进行排序。“!”到'~'

现在，我想做的一件事是在主方法中调用该字符串，以便分配给我们的加密/解密程序可以一遍又一遍地使用该字符串。

我们最初分配的程序可以在这里找到: http://www.avajava.com/tutorials/lessons/how-do-i-encrypt-and-decrypt-files-using-des.html

    import java.lang.Class.*;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import javax.crypto.Cipher;
    import javax.crypto.CipherInputStream;
    import javax.crypto.CipherOutputStream;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec;

public class Example1 {

public String keyGen() {
//create an array used for storing each character    
char array[] = new char[8];

    //for loop checks for each character between '!' and '~'
    for (char c0 = '!'; c0 <= '~'; c0++) {
    array[0] = c0;

    for (char c1 = '!'; c1 <= '~'; c1++) {
    array[1] = c1;

    for (char c2 = '!'; c2 <= '~'; c2++) {
    array[2] = c2;

    for (char c3 = '!'; c3 <= '~'; c3++) {
    array[3] = c3;

    for (char c4 = '!'; c4 <= '~'; c4++) {
    array[4] = c4;

    for (char c5 = '!'; c5 <= '~'; c5++) {
    array[5] = c5;

    for (char c6 = '!'; c6 <= '~'; c6++) {
    array[6] = c6;

    for (char c7 = '!'; c7 <= '~'; c7++) {
    array[7] = c7;

    //create new string that stores the array
    String pKey = new String(array);

    //trying to return the new string 
    return pKey;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    } 
                }
            }

public static void main(String []args) {
try {

// I am getting an error here; I know it has something to do with static references

    String key = new String(keyGen(pKey); 

                    // needs to be at least 8 characters for DES

        FileInputStream fis = new FileInputStream("original.txt");
        FileOutputStream fos = new FileOutputStream("encrypted.txt");
        encrypt(key, fis, fos);

        FileInputStream fis2 = new FileInputStream("encrypted.txt");
        FileOutputStream fos2 = new FileOutputStream("decrypted.txt");
        decrypt(key, fis2, fos2);
    } catch (Throwable e) {
        e.printStackTrace();
    }
}

public static void encrypt(String key, InputStream is, OutputStream os) throws Throwable {
    encryptOrDecrypt(key, Cipher.ENCRYPT_MODE, is, os);
}

public static void decrypt(String key, InputStream is, OutputStream os) throws Throwable {
    encryptOrDecrypt(key, Cipher.DECRYPT_MODE, is, os);
}

public static void encryptOrDecrypt(String key, int mode, InputStream is, OutputStream os) throws Throwable {

    DESKeySpec dks = new DESKeySpec(key.getBytes());
    SecretKeyFactory skf = SecretKeyFactory.getInstance("DES");
    SecretKey desKey = skf.generateSecret(dks);
    Cipher cipher = Cipher.getInstance("DES"); // DES/ECB/PKCS5Padding for SunJCE

    if (mode == Cipher.ENCRYPT_MODE) {
        cipher.init(Cipher.ENCRYPT_MODE, desKey);
        CipherInputStream cis = new CipherInputStream(is, cipher);
        doCopy(cis, os);
    } else if (mode == Cipher.DECRYPT_MODE) {
        cipher.init(Cipher.DECRYPT_MODE, desKey);
        CipherOutputStream cos = new CipherOutputStream(os, cipher);
        doCopy(is, cos);
    }
}

public static void doCopy(InputStream is, OutputStream os) throws IOException {
    byte[] bytes = new byte[64];
    int numBytes;
    while ((numBytes = is.read(bytes)) != -1) {
        os.write(bytes, 0, numBytes);
    }
    os.flush();
    os.close();
    is.close();
}

}

蒂

Answer 1

希望能帮助您解决问题。至于现在，你的keyGen()相当于下面的代码:

public String keyGen() {
    return "!!!!!!!!";
}

因为一进入最里面就返回值for环形。也许您想更改方法以返回 List<String>并将您的字符串添加到最里面的 for循环到该列表，并在所有 for 之后返回该列表循环？这样您就可以迭代 main 中的列表。方法。

<小时/>

如果我数得正确的话，有 93^8 = 5.595.818.096.650.401 个不同的字符串。将所有这些存储在列表中是一个糟糕的建议。 Dukeling 在评论中指出，最好使用自定义 Iterator<String>为此。

<小时/>

编辑

这是此类迭代器的实现:

import java.util.Arrays;
import java.util.Iterator;

public class BruteForceIterator implements Iterator<String> {

    private char min, max;

    private char[] current;

    private char[] last;

    private int reachedLast = 0;

    public BruteForceIterator(char min, char max, int length) {
        this.min = min;
        this.max = max;
        current = new char[length];
        Arrays.fill(current, min);
        last = new char[length];
        Arrays.fill(last, max);
    }

    @Override
    public boolean hasNext() {
        return reachedLast < 2;
    }

    @Override
    public String next() {
        String str = new String(current);
        for(int i = current.length - 1; i >= 0; i--) {
            char next = following(current[i]);
            current[i] = next;
            if (next != min) {
                break;
            }
        }
        if (Arrays.equals(current, last) || reachedLast > 0) {
            reachedLast++;
        }
        return str;
    }

    private char following(char in) {
        if (in < max) {
            return (char) (in + 1);
        } else {
            return min;
        }
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("No with me, sir!");
    }

    public static void main(String[] args) {
        BruteForceIterator bit = new BruteForceIterator('a', 'c', 3);
        while (bit.hasNext()) {
            System.out.println(bit.next());
        }
    }
}