加密解密五种算法的实现

1、  实验目的

通过五种加密解密算法的分析与设计，用高级语言实现加密解密过程。通过实验过程理解系统中加密解密的基本思想和实现方法。

2、  实验基本原理与方法

①单字母替换加密方法——恺撒密码

加密方法是把英文字母按字母表的顺序编号作为明文，将密钥定为m，加密算法为将明文加上密钥m，得到密码表，通过相反的过程由密文得到明文。

②单字母替换加密方法——字母倒排序

在加密、解密的过程中明文和密文按照字母表的顺序倒排对应，即A对应Z，B对应Y。  

③单字母替换加密方法——单表置换密码      

由密钥Key构造字符置换表，完成加密和解密过程。

④多字母替换加密方法——维吉利亚密码

假设明文m=m1 m2 m3 … mn；密钥k=k1k2 k3 … kn，对应密文c=c1 c2 c3 … cn，密文为：ci=（mi+ki ）mod 26 ，26个字母的序号依次为0~25，ci , mi ,,ki是分别是密文明文密钥中第i个字母的序号。

⑤转换加密方法

 通过将明文每m个字符一组按顺序分为若干个字符串，再按照先列后行形成密文，并分析给出解密的方法。或者通过给出一个密钥字符串，将明文按密钥字符串长度按顺序分为若干组字符串，再按照密钥字符串各个字符的顺序形成密文，并分析给出解密的方法。

3 具体实现方法：

①      实验方案简述：

本次实验选择用高级语言C#完成，使用面向对象的思想编程，一来对算法实现了较好的封装，使程序安全性提高，同时通过采用C#Web窗体编程框架，设计了较为直观方面的交互页面，并且对程序输入进行输入合法性验证，提高了程序的用户体验，也保证了程序的稳定运行。本实验根据上述实验的基本原理与方法设计程序算法并予以实现，分别实现了凯撒算法、字母倒排序、单表置换、维吉利亚密码和转化加密方法的加密解密。

②      实验技术路线：

1 凯撒算法

凯撒算法较为简单只是按照字母表按照密钥移动形成密文或解密显现原文，但是得注意 ,.:?等符号的出现，所以List长度为32同时注意边界的判断别入?的加密和a的解密，以及密文中字母大小写部分，所以在进行加密或解密前可以将所有字母转换成与List对应的大学，并统一以大写字母输出。

 

 

2 字母倒排序法

字母倒排序法也是较为简单的一种加密解密算法，建立字母表List并将输入按照字母表对应顺讯输出即可。

 

 

3 单表置换法

单表置换法与前两种算法的主要区别在于，单表置换法的对应表是先将密钥填入进去再将剩余的字母表字母按照字母表顺序填入，之后以之与字母表对应生成密文或对密文进行解密。该方法注意密钥中可能会出现相同的字母所以要去除密钥中相同字母再生成对应的密文表。

 

 

4 维吉利亚算法

维吉利亚算法是由两个表生成密文，第一个是密文中字母对应字母表中的顺序，第二个是按照密钥顺序构建长度等于密文的参照表，然后由m+n%26得出对应的密文对应List顺讯，解密过程先判断每个字母对应两个表的位置上面的字母在List中的位次大小，作出是否给密文对应表字母对应List顺序+26再减去密钥对应表中对应List位次，即为原文该位置上的字母对应List上的位次。解密过程较加密过程复杂，起初是比较懵的，然后百度了一下该类问题得解决原理，写出了算法并进行测试，没有问题，所以通过。

5 转换加密方法

转换加密方法有两种，第一种是根据int类型密钥，将输入信息分割成密钥长度的片段并将其进行倒叙排序，然后连接片段并输出，解密过程可以是和加密过程一样的操作进行解密，该过程比较简单，但是得注意不能讲输入信息全部截断成等于密钥长度的片段的情况，这里我使用了栈结构，同时加判断如果栈的长度等于密钥长度将其输出到新的片段字符串，并对不能刚好截成等于密钥长度的片段进行判断标记单独处理。

第二种方法可以设置成第一种方法的重载，我理解的第二种方法是根据密钥长度将输入信息拆分成等于密钥长度的片段，然后将每个片段按照密钥的对应List序号进行排序，之后将各个片段连接并输出。该方法由于涉及将拆分的片段密钥对用List顺序排列，所以我将不能全部拆分成等于密钥长度的片段给其后面补不常见的字符‘!’，进行排序后再将‘!’删除。同时注意密钥中不可以有相同的字符出现，而且解密过程与加密算法是不一样的。其中该过程调试修改了多次，虽然实现了正确的加密解密，但是感觉算法过程比较复杂，在加密过程，先将List字母顺序对应shunxu数组位置，List顺序字母在key出现的位置对应shunxu数组的值，然后将shunxu转换成按照List字母出现顺序的nshunxu，如key=”adbc”，shunxu=0231，nshunxu=0312，再令shuxun=nshunxu。然后按照位置递进，在每个片段截取对应shunxu数组的值。解密时，不需要令shuxun=nshunxu，但是要将不能全部拆分成等于密钥长度的片段还原成带有“！”的加密状态，否则会出现错误。

 

 

 

//凯撒算法
        public string Caesar(int xuanze, string psd, int key)
        {
            string List = "ABCDEFGHIJKLMNOPQRSTUVWXYZ ,.\:?";
            psd = psd.ToUpper();
            char[] miwen1 = new char[psd.Length];
            string miwen;
            int i = 0;
            if (xuanze == 1)
            {
                foreach (char e in psd)
                {
                    int m = List.IndexOf(e);

                    if (m + key < List.Length)
                    {
                        string mm = List.Substring(m + key, 1);
                        miwen1[i] = Char.Parse(mm);
                        i++;
                    }
                    else
                    {
                        string mm = List.Substring((m + key) - List.Length, 1);
                        miwen1[i] = Char.Parse(mm);
                        i++;
                    }

                }
                miwen = string.Join("", miwen1);
                Console.WriteLine(psd);
                return miwen;
            }
            else
            {
                foreach (char e in psd)
                {
                    int m = List.IndexOf(e);
                    if (m - key < 0)
                    {
                        string mm = List.Substring(m + 32 - key, 1);
                        miwen1[i] = Char.Parse(mm);
                        i++;
                    }
                    else
                    {
                        string mm = List.Substring((m - key), 1);
                        miwen1[i] = Char.Parse(mm);
                        i++;
                    }
                }
                miwen = string.Join("", miwen1);
                return miwen;
            }
        }
        //字母倒排序
        public string Ainversion(int xuanze, string psd)
        {
            string List = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            psd = psd.ToUpper();
            char[] miwen1 = new char[psd.Length];
            string miwen;
            int i = 0;
            if (xuanze == 1)
            {
                foreach (char e in psd)
                {
                    int m = List.IndexOf(e);
                    string mm = List.Substring(List.Length - m - 1, 1);
                    miwen1[i] = Char.Parse(mm);
                    i++;
                }
                miwen = string.Join("", miwen1);
                return miwen;
            }
            else
            {
                foreach (char e in psd)
                {
                    int m = List.IndexOf(e);
                    string mm = List.Substring(List.Length - m - 1, 1);
                    miwen1[i] = Char.Parse(mm);
                    i++;
                }
                miwen = string.Join("", miwen1);
                return miwen;
            }
        }
        //单表置换密码
        public string STReplace(int xuanze, string psd, string key)
        {
            string List = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            //先构建一个对应的表吧
            string NList;
            char[] nList = new char[List.Length];
            key = key.ToUpper();
            int j = 0;
            foreach (char e in List)
            {
                if (key.IndexOf(e) == -1)
                {
                    nList[j] = e;
                    j++;
                }
            }
            string sList = string.Join("", nList);
            string LList = sList.Substring(0, j);
            //Console.WriteLine(LList);
            //LList没有问题了，但是key中还存在重复的值
            string nkey = "";
            foreach (char e in key)
            {
                if (nkey.IndexOf(e) == -1)
                {
                    nkey += e;
                }
            }
            NList = nkey + LList;
            //Console.Write(NList);

            psd = psd.ToUpper();
            char[] miwen1 = new char[psd.Length];
            string miwen;
            int i = 0;
            if (xuanze == 1)
            {
                foreach (char e in psd)
                {
                    int m = List.IndexOf(e);
                    string mm = NList.Substring(m, 1);
                    miwen1[i] = Char.Parse(mm);
                    i++;
                }
                miwen = string.Join("", miwen1);
                return miwen;
            }
            else
            {
                foreach (char e in psd)
                {
                    int m = NList.IndexOf(e);
                    string mm = List.Substring(m, 1);
                    miwen1[i] = Char.Parse(mm);
                    i++;
                }
                miwen = string.Join("", miwen1);
                return miwen;
            }
        }
        //维吉利亚
        public string Virginia(int xuanze, string psd, string key)
        {
            string List = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            //先构建对应的秘钥
            key = key.ToUpper();
            char[] key1 = new char[key.Length];
            int j = 0;
            foreach (char e in key)
            {
                key1[j] = e;
                j++;
            }
            j = 0;
            ; string keywords = "";
            for (int i = 0; i < psd.Length; i++)
            {
                keywords += key1[j];
                j++;
                if (j == key.Length)
                {
                    j = 0;
                }
            }
            psd = psd.ToUpper();
            string miwen = "";
            if (xuanze == 1)
            {
                int m = 0, n = 0, k = 0, s = 0;
                foreach (char e in psd)
                {
                    m = List.IndexOf(e);
                    n = List.IndexOf(keywords.Substring(k, 1));
                    s = (m + n) % 26;
                    Console.Write(s);
                    miwen += List.Substring(s, 1);
                    k++;
                }
                return miwen;
            }
            else
            {
                int i = 0;
                while (i < psd.Length)
                {
                    int jj = i % key.Length;
                    int x1 = List.IndexOf(key.Substring(jj, 1));
                    int x2 = List.IndexOf(psd.Substring(i, 1));
                    if (x2 < x1)
                    {
                        x2 += 26;
                        miwen += List.Substring(x2 - x1, 1);
                    }
                    else
                    {
                        miwen += List.Substring(x2 - x1, 1);
                    }
                    i++;
                }
                return miwen;
            }
        }
        //转换加密方法——密钥类型为int
        public string ConvertingEncrypted(int xuanze, string psd, int key)
        {
            string npsd = "";
            foreach (char e in psd)
            {
                if (e != ' ')
                {
                    npsd += e;
                }
            }
            int total;
            if (npsd.Length % key == 0)
            {
                total = npsd.Length / key;
            }
            else
            {
                total = npsd.Length / key + 1;
            }
            //实现解密或加密过程
            string[] password1 = new string[total];
            Stack<char> stacks = new Stack<char>();
            int x = 0, y = 0;
            foreach (char e in npsd)
            {
                stacks.Push(e);
                y++;
                if (y == key)
                {
                    while (0 != stacks.Count)
                    {
                        password1[x] += stacks.Pop();
                    }
                    y = 0;
                    x++;
                }
            }
            while (0 != stacks.Count)
            {
                password1[x] += stacks.Pop();
            }
            //形成密文或原文
            string miwen = "";
            for (int i = 0; i < total; i++)
            {
                miwen += password1[i];
            }
            return miwen;
        }
         //来一个重载的方法
        public string ConvertingEncrypted(int xuanze, string psd, string key)
        {
264　　　　　　　　//去除原文/密文中的空格
265             string npsd = "";
266             foreach (char e in psd)

267             {
268                 if (e != ' ')
269                 {
270                     npsd += e;
271                 }
272             }
273             int total;
274             //做一个是否拆完的标记，之后会用到，否则会报超出索引
275             bool chujin = false;
276             if (npsd.Length % key.Length == 0)
277             {
278                 total = npsd.Length / key.Length;
279                 chujin = true;
280             }
281             else
282             {
283                 total = npsd.Length / key.Length + 1;
284                 chujin = false;
285             }
286             //按照密钥长度拆分原文
287             string[] password1 = new string[total];
288             int x = 0, y = 0;
289             foreach (char e in npsd)
290             {
291                 password1[x] += e;
292                 y++;
293                 if (y == key.Length)
294                 {
295                     y = 0;
296                     x++;
297                 }
298             }
299             //按照密钥字符串各个字符的顺序形成密文，有点晕，我觉得应该是这样的——这样要求密钥中不存在处重复的字符
300             string List = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
301             int[] shunxu = new int[key.Length];//记录密钥字母顺序数组（4321）
302             key = key.ToUpper();//将密钥全部转换成大写以便于一List进行比较
303             int i = 0;//声明一个标志值下面确定int数组的前进
304             foreach (char e in List)
305             {
306                 if (key.IndexOf(e) >= 0)
307                 {
308                     shunxu[i] = key.IndexOf(e);
309                     i++;
310                 }
311             }
312             int[] nshunxu = new int[key.Length];//加密时，处理顺序使adbc的0231变成0312
313             for (int ni = 0; ni < key.Length; ni++)
314             {
315                 for (int si = 0; si < key.Length; si++)
316                 {
317                     if (shunxu[si] == ni)
318                     {
319                         nshunxu[ni] = si;
320                         break;
321                     }
322                 }
323             }
324             if (xuanze==1) //加密时，处理顺序使adbc的0231变成0312
325             {
326                 shunxu = nshunxu;
327             }
328             if (!chujin)//如果没有除尽让最后一个数组剩余的字符为！
329             {
330                 int length = key.Length - password1[total - 1].Length;
331                 for (int xs = 0; xs < length; xs++)
332                 {
333                     password1[total - 1] += '!';
334                 }
335                 if(xuanze==2)//如果是解密最后一个没有整数拆分的要还原成加密状态
336                 {
337                     int iiis = 0;
338                     string mm = "";
339                     while (iiis < key.Length)
340                     {
341                         mm += password1[total-1].Substring(shunxu[iiis], 1);
342                         iiis++;
343                     }
344                     password1[total - 1] = mm;
345                 }
346             }
347             //加密解密操作核心，加密解密可以使用同一个算法
348             //将所有切分字符串按照密钥顺序排序
349             string[] password2 = new string[total];
350             int ii = 0;
351             while (ii < key.Length)
352             {
353                 for (int j = 0; j < total; j++)
354                 {
355                     password2[j] += password1[j].Substring(shunxu[ii], 1);
356                 }
357                 ii++;
358             }        
359             //将最后一个未除尽数组中的！删除
360             if (!chujin)
361             {
362                 string midpad = "";
363                 foreach (char e in password2[total - 1])
364                 {
365                     if (e != '!')
366                     {
367                         midpad += e;
368                     }
369                 }
370                 password2[total - 1] = midpad;
371             }
372             //将所=切分的字符串连接
373             string miwen = "";
374             for (int s = 0; s < total; s++)
375             {
376                 miwen += password2[s];
377             }
378             return miwen;
 　　} 
}