古典密碼算法的實現

1、古典密碼可以分為代替密碼和置換密碼兩種，這里實現了代替密碼中的仿射變換和置換密碼中的換位變換。

 

2、仿射變換：

加密過程：e(x) = ax + b (mod m)

解密過程：d(e(x)) = a^(-1)*(e(x) - b) mod m

參數要求：a,m互質；a,b互質；m是集合中元素的個數。（例如當前取1~9和a~z中的所有元素作為集合，m為36）

加密實現：

import java.util.Scanner;

public class Main {
    public static void main(String []args) {
        int m = 36, thisNum, index = 0; // m是集合中元素的個數（例如當前取1~9和a~z中的所有元素作為集合，m為36）
        Scanner s = new Scanner(System.in);
        // 將輸入的字符串轉化為字符數組
        char[] buff = s.nextLine().toCharArray();
        // 參數a、b手動輸入
        int a = s.nextInt();
        int b = s.nextInt();
        // 參數要求:a,m互質;a,b互質
        while (fun1(m, a) != 1 || fun1(Math.max(a, b), Math.min(a, b)) != 1) {
            System.out.println("參數不符合要求，請重新輸入");
            a = s.nextInt();
            b = s.nextInt();
        }
        for (char i : buff) {
            // 由字符轉換為數字
            if (i > '9') thisNum = (int)i - 87;
            else thisNum = (int)i - 48;
            // 對該數字加密
            thisNum = (thisNum*a+b)%m;
            // 加密后再將數字轉換為字符
            if (thisNum < 10) buff[index++] = (char)(thisNum+48);
            else buff[index++] = (char)(thisNum+87);
        }
        System.out.println(buff);
        s.close();
    }

    // 歐幾里得算法求兩個數的最大公因數
    public static int fun1(int a, int b) {
        return b == 0 ? a : fun1(b, a%b);
    }
}

解密實現：

import java.util.Scanner;

public class Main {
    public static void main(String []args) {
        int m = 36, thisNum, index = 0, k;
        Scanner s = new Scanner(System.in);
        char[] buff = s.nextLine().toCharArray();
        int a = s.nextInt();
        int b = s.nextInt();
        while (fun1(m, a) != 1 || fun1(Math.max(a, b), Math.min(a, b)) != 1) {
            System.out.println("參數不符合要求，請重新輸入");
            a = s.nextInt();
            b = s.nextInt();
        }
        // k為a模m的逆元
        k = fun2(a, m);
        for (char i : buff) {
            // 將加密后的字符轉換為數字
            if (i > '9') thisNum = (int)i - 87;
            else thisNum = (int)i - 48;
            // 解密過程 D(E(x)) = a^(-1)*(E(x)-b) mod m
            thisNum = ((thisNum-b)*k)%m;
            // 如果結果是負數，則轉換為正數，原理為 a % b = (a % b + b) % b
            if(thisNum < 0) thisNum += m;
            // 最后將解密后的數字轉換為字符
            if (thisNum < 10) buff[index++] = (char)(thisNum+48);
            else buff[index++] = (char)(thisNum+87);
        }
        System.out.println(buff);
    }

    public static int fun1(int a, int b) {
        return b == 0 ? a : fun1(b, a%b);
    }

    // 循環求a模m的逆元
    public static int fun2(int a, int m) {
        for (int i = 0; i < m; i++) {
            if (a*i%m == 1) {
                a = i;
                break;
            }
        }
        return a;
    }
}

 

3、換位密碼

加密過程：保持明文的所有字符不變，根據一定的規則重新排列明文。

解密過程：加密過程的逆過程。

注解：加密過程和解密過程都是創建索引的過程，即用數組存儲哪個位置放哪個字符，最后再通過索引重新組合成密文或明文。

示例：

明文矩陣：
a s d f g
h j k l m
n b v c

密文矩陣：
d a g s f
k h m j l
v n b c

(計算結果中n和b之間有一個空格，但輸出時將空格去掉了)

明文：asdfghjklmnbvc
密鑰：31524

加密實現：

import java.util.Scanner;

public class Main {
    public static void main(String []args) {
        Scanner s = new Scanner(System.in);
        char[] mingwen = s.nextLine().toCharArray();
        char[] miyao = s.nextLine().toCharArray();
        StringBuffer miwen = new StringBuffer();
        int[] poi = new int[miyao.length];
        int index = 0, thisRow = 0, realPoi;

        // 計算出明文矩陣的列數和行數
        int col = miyao.length;
        int row = (mingwen.length / col) + (mingwen.length % col == 0? 0 : 1);  // 處理明文矩陣最后一行可能不滿的情況
        
        // 密鑰位置格式化（密鑰中的所有字符都大於等於'1'所以最后減1方便后續計算）
        for (int i = 0; i < poi.length; i++) poi[i] = miyao[i] - 48 - 1;


        for (int i = 0; i < row * col; i++) {
            // 計算出當前位置i的真正字符（例如加密后第0位為2，即字符d），如果該字符在明文中存在，則將其添加到密文中
            if ((realPoi = poi[index++] + thisRow * col) < mingwen.length) miwen.append(mingwen[realPoi]);
            // 如果當前位置無字符則用空格代替
            else miwen.append(' ');
            
            if (index >= col) {
                index = index % col;
                thisRow++;
            }
        }

        // 密文去空格(解密時密文中的空格需要保留)
        for (int i = 0; i < miwen.length(); i++) {
            if (miwen.charAt(i) == ' ') miwen.deleteCharAt(i);
        }

        // 輸出加密后的密文
        System.out.println(miwen);
    }
}

解密實現：

import java.util.Scanner;

public class Main {
    public static void main(String []args) {
        Scanner s = new Scanner(System.in);
        char[] miwen = s.nextLine().toCharArray();
        char[] miyao = s.nextLine().toCharArray();
        StringBuffer mingwen = new StringBuffer();
        int []poi = new int[miyao.length];
        int index = 0, thisRow = 0, realPoi;

        // 獲取解密密鑰並將密鑰的位置格式化（最后減一），即加密的逆過程
        for (char c : miyao) {
            poi[(int)c - 48 - 1] = index++;
        }
        index = 0;

        // 密文矩陣的列數和行數
        int col = miyao.length;
        int row = (miwen.length / col) + (miwen.length % col == 0? 0 : 1);

        for (int i = 0; i < row * col; i++) {
            // 計算出當前位置i的真正字符並將該字符添加到明文字符串中
            if ((realPoi = poi[index++] + thisRow * col) < miwen.length) mingwen.append(miwen[realPoi]);
            
            if (index >= col) {
                index = index % col;
                thisRow++;
            }
        }

        // 輸出解密后的明文
        System.out.println(mingwen);
    }
}

 

4、希爾密碼（Hill密碼）- 屬於古典密碼中的多表代換密碼，運用了基本的矩陣論原理

注解：

1）每個字母當作 26 進制數字：a=0, b=1, c=2... 一串字母當成n維向量，跟一個n×n的矩陣相乘，再將得出的結果模 26。用作加密的矩陣(即密匙)必須是可逆的，否則就不可能譯碼。只有矩陣的行列式和 26 互質，才是可逆的。

2）明文和密文的長度必須是給定的矩陣的列數的整數倍。（矩陣相乘的前提）

加密過程：將明文轉化為n維向量（字符轉數字）與n×n的矩陣相乘，再將得出的結果模 26 后轉化為字符。

解密過程：將明文轉化為n維向量（字符轉數字）與n×n的矩陣相乘，再將得出的結果模 26 后轉化為字符。

加密實現：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 三階可逆矩陣A
        int[][] A = { { 1, 2, 3 }, { 1, 1, 2 }, { 0, 1, 2 } };

        Scanner s = new Scanner(System.in);
        char[] mingwen = s.nextLine().toCharArray();
        char[] miwen = new char[mingwen.length];
        int row = 3, col = mingwen.length / 3, index = 0;

        while (index < col) {
            int sum;
            for (int i = 0; i < row; i++) {
                sum = 0;
                for (int j = 0; j < row; j++) {
                    sum += A[i][j] * (int) (mingwen[j+index*row] - 97);
                }
                sum %= 26;
                if (sum < 0) sum += 26;
                miwen[i + index*row] = (char) (sum + 97);
            }
            index++;
        }

        for (char c : miwen) {
            System.out.print(c);
        }
    }
}

解密實現：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // A的逆矩陣
        int[][] A_1 = {{0, 1, -1}, {2, -2, -1}, {-1, 1, 1}};

        Scanner s = new Scanner(System.in);
        char[] miwen = s.nextLine().toCharArray();
        char[] mingwen = new char[miwen.length];
        int row = 3, col = mingwen.length / 3, index = 0;

        while (index < col) {
            int sum;
            for (int i = 0; i < 3; i++) {
                sum = 0;
                for (int j = 0; j < 3; j++) {
                    sum += A_1[i][j] * (int)(miwen[j+index*row] - 97);
                }
                sum %= 26;
                if (sum < 0) sum += 26;
                mingwen[i+index*row] = (char)(sum+97);
            }
            index++;
        }

        for(char c : mingwen) {
            System.out.print(c);
        }
    }
}