📜  柱状换位密码

📅  最后修改于: 2021-04-23 17:03:22             🧑  作者: Mango

给定纯文本消息和数字键,请使用“列式换位密码”对给定文本进行加密/解密

柱状换位密码是换位密码的一种形式,就像Rail Fence Cipher一样。列式转置包括将明文按行写出,然后逐列逐列读取密文。

例子:

Encryption
Input : Geeks for Geeks
Key = HACK
Output : e  kefGsGsrekoe_
Decryption
Input : e  kefGsGsrekoe_
Key = HACK
Output : Geeks for Geeks 

Encryption
Input :  Geeks on work
Key = HACK
Output : e w_eoo_Gs kknr_
Decryption
Input : e w_eoo_Gs kknr_
Key = HACK
Output : Geeks on work

加密

在换位密码中,重新排列字母的顺序以获得密文。

  1. 消息以固定长度的行写出,然后逐列再次读出,并以某种加扰的顺序选择列。
  2. 行的宽度和列的排列通常由关键字定义。
  3. 例如,单词HACK的长度为4(因此行的长度为4),并且排列由关键字中字母的字母顺序定义。在这种情况下,顺序将为“ 3 1 2 4”。
  4. 任何备用空间都将填充为null或保留为空白,或由字符放置(例如:_)。
  5. 最后,按关键字指定的顺序在列中读取消息。

柱状转置密码

解密方式

  1. 要解密它,接收者必须通过将消息长度除以密钥长度来算出列长度。
  2. 然后,将消息再次写到各列中,然后通过重新设置关键字来重新排列各列的顺序。
    C++
    // CPP program for illustrating
    // Columnar Transposition Cipher
    #include
    using namespace std;
      
    // Key for Columnar Transposition
    string const key = "HACK"; 
    map keyMap;
      
    void setPermutationOrder()
    {             
        // Add the permutation order into map 
        for(int i=0; i < key.length(); i++)
        {
            keyMap[key[i]] = i;
        }
    }
      
    // Encryption 
    string encryptMessage(string msg)
    {
        int row,col,j;
        string cipher = "";
          
        /* calculate column of the matrix*/
        col = key.length(); 
          
        /* calculate Maximum row of the matrix*/
        row = msg.length()/col; 
          
        if (msg.length() % col)
            row += 1;
      
        char matrix[row][col];
      
        for (int i=0,k=0; i < row; i++)
        {
            for (int j=0; j::iterator ii = keyMap.begin(); ii!=keyMap.end(); ++ii)
        {
            j=ii->second;
              
            // getting cipher text from matrix column wise using permuted key
            for (int i=0; i::iterator ii=keyMap.begin(); ii!=keyMap.end(); ++ii)
            ii->second = index++;
      
        /* Arrange the matrix column wise according 
        to permutation order by adding into new matrix */
        char decCipher[row][col];
        map::iterator ii=keyMap.begin();
        int k = 0;
        for (int l=0,j; key[l]!='\0'; k++)
        {
            j = keyMap[key[l++]];
            for (int i=0; i


    Python3
    # Python3 implementation of 
    # Columnar Transposition
    import math
      
    key = "HACK"
      
    # Encryption
    def encryptMessage(msg):
        cipher = ""
      
        # track key indices
        k_indx = 0
      
        msg_len = float(len(msg))
        msg_lst = list(msg)
        key_lst = sorted(list(key))
      
        # calculate column of the matrix
        col = len(key)
          
        # calculate maximum row of the matrix
        row = int(math.ceil(msg_len / col))
      
        # add the padding character '_' in empty
        # the empty cell of the matix 
        fill_null = int((row * col) - msg_len)
        msg_lst.extend('_' * fill_null)
      
        # create Matrix and insert message and 
        # padding characters row-wise 
        matrix = [msg_lst[i: i + col] 
                  for i in range(0, len(msg_lst), col)]
      
        # read matrix column-wise using key
        for _ in range(col):
            curr_idx = key.index(key_lst[k_indx])
            cipher += ''.join([row[curr_idx] 
                              for row in matrix])
            k_indx += 1
      
        return cipher
      
    # Decryption
    def decryptMessage(cipher):
        msg = ""
      
        # track key indices
        k_indx = 0
      
        # track msg indices
        msg_indx = 0
        msg_len = float(len(cipher))
        msg_lst = list(cipher)
      
        # calculate column of the matrix
        col = len(key)
          
        # calculate maximum row of the matrix
        row = int(math.ceil(msg_len / col))
      
        # convert key into list and sort 
        # alphabetically so we can access 
        # each character by its alphabetical position.
        key_lst = sorted(list(key))
      
        # create an empty matrix to 
        # store deciphered message
        dec_cipher = []
        for _ in range(row):
            dec_cipher += [[None] * col]
      
        # Arrange the matrix column wise according 
        # to permutation order by adding into new matrix
        for _ in range(col):
            curr_idx = key.index(key_lst[k_indx])
      
            for j in range(row):
                dec_cipher[j][curr_idx] = msg_lst[msg_indx]
                msg_indx += 1
            k_indx += 1
      
        # convert decrypted msg matrix into a string
        try:
            msg = ''.join(sum(dec_cipher, []))
        except TypeError:
            raise TypeError("This program cannot",
                            "handle repeating words.")
      
        null_count = msg.count('_')
      
        if null_count > 0:
            return msg[: -null_count]
      
        return msg
      
    # Driver Code
    msg = "Geeks for Geeks"
      
    cipher = encryptMessage(msg)
    print("Encrypted Message: {}".
                   format(cipher))
      
    print("Decryped Message: {}".
           format(decryptMessage(cipher)))
      
    # This code is contributed by Aditya K


    输出:

    Encrypted Message: e  kefGsGsrekoe_
    Decrypted Message: Geeks for Geeks
    

    自己尝试:双列换位(第一次世界大战中,美国陆军使用了它,它只是一个列换位,然后是另一个列换位)。