信息加密之Transposition Cipher(变位密码)

变位密码是一种简单的对称加密方法，
加密原理：

   （1）确定密钥（加密、解密使用同一密钥）。
   （2）对密钥中的字符进行排序。
   （3）将明文放到一个行宽为strlen(密钥)的矩阵中，补足则用a、b、c、d...补足生成明文矩阵。
   （4）根据密钥中字符的次序（Ascii码）依次以列的形式将明文矩阵的内容读到一数组中，生成密文。

解密原理：

   （1）确定密钥（加密、解密使用同一密钥）。
   （2）对密钥中的字符进行排序。
   （3）将密文存放到一个列长为strlen(密钥)的矩阵中，生成密文矩阵。
   （4）根据密钥中字符的次序（Ascii码）依次以行的形式将密文矩阵的内容读到一个数组中，生成解密后的明文。

 

运行结果：

代码：

// TranspositionCipher.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdio.h>
#include <string.h>

//密钥长度
int keyLength;
//密钥
char* key = "Hello World";
//明文用'|'来代表结束符
char* Plaintext = "Hello, my name is lauvenman|";
//在矩阵不能排满时用temptext补足
char* temptext = "abcdefghijklmn";

int main()
{
     //初始化密钥长度
     keyLength = strlen(key);
     //定义密钥中字母的排列顺序的数组rank
     int* rank = new int[keyLength];
     //flag用于在对密钥的字母进行排序时判断该字母是否已经被确定位置
     int* flag = new int[keyLength];

     for(int i = 0 ; i < keyLength; i++)
         flag[i] = 0;
         
    //将key中的字母进行排序
     for(int i = 0 ; i < keyLength; i++)
        {
            int temp_rank_flag1;
            int rank_flag;
            char min_char;
            
            for(int k = 0 ; k < keyLength ; k++)
                {
                    //找一个还没被确定位置的字母
                    if(flag[k] == 0)
                        {
                            min_char = key[k];
                            rank_flag = k;
                            temp_rank_flag1 = k;
                            break;
                        }
                }
                
            for(int j = 0 ; j < keyLength; j++)
                {
                     //如果找到一个比现在的min_char小,并且它还没被选中过的密钥中的字母时
                     if(min_char > key[j] && flag[j] == 0)
                        {
                              //重新赋值min_char更小的字母
                              min_char = key[j];
                              //记录此时最小字母的下标
                              rank_flag = j;
                              temp_rank_flag1 = j;
                        }
                }
           
           //得到其在密钥中字母排序后的位置
           rank[rank_flag] = i+1;
           //将其flag设成1
           flag[temp_rank_flag1] = 1;
        }
      
        //声明矩阵的空间
        int col = keyLength;
        int row = strlen(Plaintext) / keyLength;
        if(strlen(Plaintext) % keyLength != 0)
            row++;
        
        //定义用于存放明文的矩阵temp_string（动态生成）,长=row, 宽=col
        char** temp_string = new char*[row];
        for(int i=0;i<row;i++)
            temp_string[i] = new char[col];
        
        //定义密文
        char* Ciphertext = new char[row*col];

        //将明文信息转换到矩阵当中
        int temptext_flag = 0;
        for(int i = 0; i < row; i++)
            {
                for(int j = 0; j < col; j++)
                    {
                        if( i*keyLength+j < (strlen(Plaintext)) )
                            temp_string[i][j] = Plaintext[i*(keyLength)+j];
                        else
                            {
                                 temp_string[i][j] = temptext[temptext_flag];
                                 temptext_flag++;
                            }
                    }
            }


       printf(" 明文是长度: %d",strlen(Plaintext)-1);
       printf(" 明文是: ");
       for(int i = 0 ; i < strlen(Plaintext) ; i++)
            {
                 printf("%c",Plaintext[i]);
            }

       printf(" 密钥是: ");
       for(int i = 0; i < keyLength; i++)
           {
               printf("%c",key[i]);
           }
           
       printf(" 密钥排序 ");
       for(int i = 0 ; i < keyLength ; i++)
            printf("%c ",key[i]);
            printf(" ");
       for(int i = 0 ; i < keyLength ; i++)
            printf("%d ",rank[i]);
       printf(" ");

       printf(" 明文矩阵(row = %d , col = %d) ",row,col);
       for(int i = 0; i < row; i++)
           {
                for(int j = 0; j < col; j++)
                     {
                         printf("%c ",temp_string[i][j]);
                     }
                 printf(" ");
           }

       /*加密*/
       printf(" 密文是:  ");
       int full = 0;
       for(int i = 0 ; i < keyLength ; i++)
            {
                 for(int j = 0 ; j < keyLength ; j ++)
                    {    
                        //按密钥字母排序的顺序将明文矩阵转换成密文
                        if(rank[j] == i+1)
                            {
                                for(int k = 0 ; k < row; k++)
                                    {
                                        Ciphertext[full] = temp_string[k][j];
                                        printf("%c",Ciphertext[full]);
                                        full++;
                                    }
                            }
                    }
            }
        printf(" ");

        printf(" 密文矩阵(row = %d , col = %d) ",col,row);
        for(int j = 0; j < row*col; j++)
            {
                printf("%c ",Ciphertext[j]);
                if(j%row == row-1  )
                    printf(" ");
            }

        
        //定义解密后的明文（动态生成），长度是row*col
        char** dec = new char*[row];
        for(int i = 0 ; i < row ; i ++)
            dec[i] = new char[col];
        
        /*解密*/
        //此处由于只是用于演示所以就没有重新对密钥进行排序
        //直接使用上面的排序结果
        for(int i = 0 ; i < keyLength ; i++)
            {
                //将密文以行的形式放到解密后明文的行中
                for(int j = 0 ; j < row ; j++)
                    {
                        dec[j][i] = Ciphertext[(rank[i]-1) * row + j];
                    }
            }
        

        printf(" 解密后的明文 ");
        for(int i = 0 ; i < row ; i++)
            {
                for(int j = 0 ; j < col ; j++)
                    {
                       if(dec[i][j] == '|')
                           goto endPrint;
                       printf("%c",dec[i][j]) ;

                    }
            }
        endPrint:
            printf(" ");

    getchar();
   return 0;
}