Simple textbasierte Verschlüsselung

Mirek

Mit einem Key (Hashwert eines Strings) wird ein Zufallszahlengenerator initialisiert, der eine Folge von Pseudo-Zufallszahlen liefert, die dazu dienen, einen Text durcheinanderzuwirbeln. Der Algorithmus ist einfach, reversibel und verstößt nicht gegen das Kerckhoff’sche Prinzip.

/**
 * Shuffles a String reversibly
 */
public class StringShuffler
{
    private long _seed;

    /**
     * Constructor
     * @param key Password for encryption/decryption
     * @throws NoSuchAlgorithmException when getMD fails
     */
    public StringShuffler(String key) throws NoSuchAlgorithmException
    {
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        byte[] dig = md5.digest(key.getBytes());
        BigInteger big = new BigInteger(dig);
        _seed = big.longValue();
    }

    /**
     * Shuffles a string
     * @param in Input string
     * @return Shuffled string
     */
    public String shuffle (String in)
    {
        int len = in.length();
        int len2 = 2*len;
        Random r = new Random(_seed);

        StringBuilder sb = new StringBuilder(in);
        for (int s=0; s<len2; s++)
        {
            int r1 = r.nextInt(len);
            int r2 = r.nextInt(len);
            char c1 = sb.charAt(r1);
            char c2 = sb.charAt(r2);
            sb.setCharAt(r1, c2);
            sb.setCharAt(r2, c1);
        }
        return sb.toString();
    }

    /**
     * De-shuffles a string
     * @param in input string
     * @return output string
     */
    public String deshuffle (String in)
    {
        int len = in.length();
        int len2 = 2*len;
        Random r = new Random(_seed);

        StringBuilder sb = new StringBuilder(in);
        ArrayList<Integer> al = new ArrayList<>();
        for (int s=0; s<len2; s++)
        {
            al.add(r.nextInt(len));
            al.add(r.nextInt(len));
        }
        Collections.reverse(al);

        for (int s=0; s<al.size(); s+=2)
        {
            int r1 = al.get(s);
            int r2 = al.get(s+1);
            char c1 = sb.charAt(r1);
            char c2 = sb.charAt(r2);
            sb.setCharAt(r1, c2);
            sb.setCharAt(r2, c1);
        }
        return sb.toString();
    }
}

Benutzt wird die Klasse so:

String password = "hello123";
        StringShuffler sf = new StringShuffler(password);
        String plain = "hello world, this is my wonderful text encryption algorithm :)";
        String encrypted = sf.shuffle (plain);
        String decrypted = sf.deshuffle(encrypted);
        System.out.println(encrypted);
        System.out.println("----------------------");
        System.out.println(decrypted);

Verbesserungsvorschläge? Kritik?
Nur zu!