package sun.netsecurity.matrixtran;

 

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.math.BigInteger;

 

public class MatrixTransposition {

       

        private static BufferedReader br;

       

        static {

                InputStreamReader reader = new InputStreamReader(System.in);

                br = new BufferedReader(reader);

        }

 

        /**

        public static void main(String[] args) throws IOException {

 

                char[] plaintext = inputPlaintext();

                Integer key = inputKey();

               

                br.close();

 

                String ciphertext = encrypt(plaintext, key);

                System.out.println("明文加密后为: " + ciphertext);

 

                String plaintextStr = decrypt(ciphertext.toCharArray(), plaintext, key);

                System.out.println("密文解密后为: " + plaintextStr);

        }

 

        /**

        static char[][] groupPlaintext(char[] plaintext, Integer key) {

                char[][] plaintextGroup = null;

                Integer length = plaintext.length;

 

                if (length % key != 0) {// 当字符数组的长度不是密钥的整数倍时，用字符'$'填补

                        String plaintextStr = new String(plaintext);

 

                        BigInteger lengthBI = new BigInteger(length.toString());

                        BigInteger keyBI = new BigInteger(key.toString());

                        BigInteger mod = lengthBI.mod(keyBI);

 

                        int fillNumber = keyBI.intValue() - mod.intValue();

                        for (int i = 0; i < fillNumber; i++) {

                                plaintextStr = plaintextStr + "$";

                        }

                        plaintext = plaintextStr.toCharArray();

                        length = plaintext.length;

                }

 

                int groupAmount = length / key;

                plaintextGroup = new char[groupAmount][key];

                for (int i = 0; i < groupAmount; i++) {

                        for (int j = 0; j < key; j++) {

                                // 将明文字符数组分割为二维数组

                                plaintextGroup[i][j] = plaintext[i * key + j];

                        }

                }

 

                return plaintextGroup;

        }

 

        /**

        static char[][] groupCiphertext(char[] ciphertext, Integer key) {

                char[][] ciphertextGroup = null;

                int length = ciphertext.length;

 

                int groupAmount = length / key;

                ciphertextGroup = new char[groupAmount][key];

                for (int i = 0; i < groupAmount; i++) {

                        for (int j = 0; j < key; j++) {

                                ciphertextGroup[i][j] = ciphertext[i * key + j];

                        }

                }

 

                return ciphertextGroup;

        }

 

        /**

        static char[] changePlaintext(char[] group) {

                char[] newGroup = new char[group.length];

                for (int i = 0; i < group.length; i++) {

                        if (i == 0) {

                                newGroup[0] = group[group.length - 1];

                                continue;

                        }

 

                        newGroup[i] = group[i - 1];

                }

                return newGroup;

        }

 

        /**

        static char[] changeCiphertext(char[] group) {

                char[] newGroup = new char[group.length];

                for (int i = 0; i < group.length; i++) {

                        if (i == group.length - 1) {

                                newGroup[group.length - 1] = group[0];

                                break;

                        }

 

                        newGroup[i] = group[i + 1];

                }

                return newGroup;

        }

 

        static String getCipherFromGroup(char[][] plaintextGroup) {

                String ciphertext = "";

 

                int rowAccount = plaintextGroup.length;

                int lowAccount = plaintextGroup[0].length;

 

                for (int i = 0; i < rowAccount; i++) {

                        char[] rowChar = new char[lowAccount];

                        for (int j = 0; j < lowAccount; j++) {

                                rowChar[j] = plaintextGroup[i][j];

                        }

                        ciphertext = ciphertext + new String(rowChar);

                }

 

                return ciphertext;

        }

 

        static String getPlaintextFromGroup(char[][] ciphertextGroup) {

                String plaintext = "";

 

                int rowAccount = ciphertextGroup.length;

                int lowAccount = ciphertextGroup[0].length;

 

                for (int i = 0; i < rowAccount; i++) {

                        char[] rowChar = new char[lowAccount];

                        for (int j = 0; j < lowAccount; j++) {

                                rowChar[j] = ciphertextGroup[i][j];

                        }

                        plaintext = plaintext + new String(rowChar);

                }

 

                return plaintext;

        }

 

        // 从键盘输入明文

        static char[] inputPlaintext() {

 

                System.out.println("请输入明文:");

 

                char[] plaintextChar = null;

 

                try {

                        String plaintext = null;

                        plaintext = br.readLine();

                        plaintextChar = plaintext.toCharArray();

                } catch (Exception e) {

                        e.printStackTrace();

                }

 

                return plaintextChar;

        }

 

        // 从键盘获得密钥

        static Integer inputKey() {

 

                System.out.println("请输入密钥:");

 

                Integer key = null;

 

                try {

                        String keyString = null;

                        keyString = br.readLine();

                        key = new Integer(keyString);

                } catch (Exception e) {

                        e.printStackTrace();

                }

 

                return key;

        }

 

        /**

        static String encrypt(char[] plaintext, Integer key) {

                String ciphertext;

                char[][] plaintextGroup;

 

                // 调用groupPlaintext(plaintext, key)方法对明文分组

                plaintextGroup = groupPlaintext(plaintext, key);

                for (int i = 0; i < plaintextGroup.length; i++) {

                        // 调用changePlaintext(char[])进行位变换

                        char[] rowText = changePlaintext(plaintextGroup[i]);

                        plaintextGroup[i] = rowText;

                }

 

                //

                ciphertext = getCipherFromGroup(plaintextGroup);

 

                return ciphertext;

        }

       

        /**

        static String decrypt(char[] ciphertext, char[] plaintext, Integer key) {

                String plaintextStr;

                char[][] ciphertextGroup;

 

                ciphertextGroup = groupCiphertext(ciphertext, key);

                for (int i = 0; i < ciphertextGroup.length; i++) {

                        char[] rowText = changeCiphertext(ciphertextGroup[i]);

                        ciphertextGroup[i] = rowText;

                }

               

                plaintextStr = getPlaintextFromGroup(ciphertextGroup);

 

                Integer plaintextLength = plaintext.length;

                BigInteger pLenghBI = new BigInteger(plaintextLength.toString());

                BigInteger keyBI = new BigInteger(key.toString());

                BigInteger mod = pLenghBI.mod(keyBI);

                if (mod.intValue() != 0) {

                        plaintextStr = plaintextStr.substring(0, plaintextStr.length()

                                        - (key - mod.intValue()));

                }

 

                return plaintextStr;

        }