古典密码算法的实现

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);
        }
    }
}