Simple textbasierte Verschlüsselung



  • 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!


Log in to reply