rsa 矩阵置换 及Vernam加密算法 C#实现

最新推荐文章于 2022-11-04 13:56:28 发布
最新推荐文章于 2022-11-04 13:56:28 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： .net 文章标签： 加密 算法 c# textbox 解密 object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidang201/article/details/7523021
版权

刚刚搞完密码安全的课程结束论文，des算法搞了好久没搞成，就搞了rsa 矩阵置换 及Vernam加密，上代码


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Security.Cryptography;
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private void button1_Click(object sender, EventArgs e)
        {
            string mingwen = "", miyao = "", miwen = "";
            
            mingwen = TextBox_mingwen.Text;
            miyao = textBox_miyao.Text;


            if (mingwen.Equals(""))
            {
                MessageBox.Show("明文为空");
               
                return;
            }


            #region 矩阵换位加密
            if (radio_juzhen.Checked) //矩阵换位
            {
                if (miyao.Equals(""))
                {
                    MessageBox.Show("密钥为空");
                    
                    return;
                }


                for (int i = 0; i < miyao.Length; i++)
                {
                    for (int j = i + 1; j < miyao.Length; j++)
                    {
                        if (miyao[i].Equals(miyao[j]))
                        {
                            MessageBox.Show("密钥中不允许有重复字母");
                            return;


                        }
                    }




                    if (!char.IsLetter(miyao[i]))
                    {
                        MessageBox.Show("密钥必须全为字母");
                        return;
                    }
                }




                char[] charr = new char[100];
                int[] intarr = new int[100];
                int[] xulieintarr=new int[100];
                int zushu;
                miyao = miyao.ToLower();//把所有字母转成小写


                for (int i = 0; i < miyao.Length; i++)
                {
                    charr[i] = miyao[i];
                }


                
                for (int i = 0; i < miyao.Length; i++)//密钥的字母排序
                {
                    for (int j = i + 1; j < miyao.Length; j++)
                    {
                        if (charr[i] > charr[j])
                        {
                            char t = charr[i];
                            charr[i] = charr[j];
                            charr[j] = t;
                        }
                    }
                }








                for (int i = 0; i < miyao.Length; i++)//算字母序列  intarr[i] = j;表示miyao字符串的第i位 在字母表排在第j位
                {
                    for (int j = 0; j < miyao.Length; j++)
                    {
                        if (miyao[j].Equals(charr[i]))
                        {
                            intarr[i] = j;
                            break;
                        }
                    }
                    //label9.Text += charr[i];
                }




                for (int i = 0; i < miyao.Length; i++)//逆序列 用于
                {
                    for (int j = 0; j < miyao.Length; j++)
                    {
                        if (i == intarr[j])
                        {
                            xulieintarr[i] = j;
                            break;
                        }
                    }
                }




                zushu = mingwen.Length / miyao.Length;
                if ((mingwen.Length) % (miyao.Length) != 0)
                {
                    while ((mingwen.Length) % (miyao.Length) != 0)
                    {
                        mingwen += '$';
                    }
                    zushu += 1;


                }






                for (int i = 0; i < miyao.Length; i++)
                {
                    for (int j = 0; j < zushu; j++)
                    {
                        //miwen += mingwen[j * miyao.Length + xulieintarr[i]];
                        miwen += mingwen[j * miyao.Length + intarr[i]];
                        //label9.Text += xulieintarr[i];
                    }
                    
                }
                //attackbeginsatfive
                TextBox_miwen.Text = miwen;
             }
#endregion


            #region Vernam加密
            if (radio_Vernam.Checked)//Vernam加密
            {
                if (miyao.Equals(""))
                {
                    MessageBox.Show("密钥为空");
                    //flag = false;
                    return;
                }


                if (miyao.Length != 8)
                {
                    MessageBox.Show("密钥长度必须为8");
                    return;
                }


                for (int i = 0; i < miyao.Length; i++)
                {
                    if (!miyao[i].Equals('1') && !miyao[i].Equals('0'))
                    {
                        MessageBox.Show("密钥必须由1和0构成");
                        return;
                    }
                }


                int intmiyao;
                intmiyao = Convert.ToInt16(miyao, 2);


                //label9.Text =Convert.ToString(intmiyao);


                for (int i = 0; i < mingwen.Length; i++)
                {
                    int intming = Convert.ToInt16(mingwen[i]);
                    intming ^= intmiyao;
                    miwen += Convert.ToChar(intming);
                }


                TextBox_miwen.Text = miwen;
            }


            #endregion


            #region rsa加密
            if (radio_rsa.Checked)//rsa加密    c=(m^e)%n
            {
                if (miyao.Equals(""))
                {
                    MessageBox.Show("密钥为空");


                    return;
                }


                long gongyue_e = Convert.ToInt32(miyao);
                long n =Convert.ToInt32( textBox_n.Text);
                for (int i=0; i < mingwen.Length; i++)
                {
                    long[] carr=new long[4];
                    //long c=rsaqiumo(Convert.ToInt32(mingwen[i]),gongyue_e,n);
                    long c = Algmod(Convert.ToInt32(mingwen[i]), gongyue_e, n);
                    for (int j = 0; j < 4; j++)
                    {
                        carr[j] = c & 0xff;
                        c >>= 8;
                    }


                    for (int j = 3; j >=0; j--)
                    {
                        if (carr[j] >> 4 == 0)
                        {
                            miwen+='0';
                        }
                        miwen += Convert.ToString(carr[j],16);
                    }
                                        
                }


                TextBox_miwen.Text = miwen;
  
            }
        }


         #endregion


        private void button_jiemi_Click(object sender, EventArgs e)
        {
            string mingwen = "", miwen = "", miyao = "";
            miwen = TextBox_miwen.Text;
            miyao = textBox_miyao.Text;


            if (miwen.Equals(""))
            {
                MessageBox.Show("密文为空");
                return;
            }


            #region rsa解密
            if (radio_rsa.Checked)//rsa解密
            {
                if (miyao.Equals(""))
                {
                    MessageBox.Show("密钥为空");
                    //flag = false;
                    return;
                }


                long n = Convert.ToInt32( textBox_n.Text);
                long d = Convert.ToInt32(textBox_miyao.Text);




                //if()


                for (int i = 0; i < miwen.Length/8; i++)
                {
                    string strt = "";
                    //for (int j = 0; j < 8; j++)
                    //{
                    //    strt+=miwen[i*8 + j];
                    //}
                    strt = miwen.Substring(i * 8, 8);


                    long ltemp=Convert.ToInt32(strt,16);
                    //ltemp = rsaqiumo(ltemp, d, n);
                    ltemp = Algmod(ltemp,d,n);


                    
                    mingwen+=(char)ltemp;
                }


                 TextBox_mingwen.Text = mingwen;
            }
            #endregion


            #region  矩阵换位解密
            if (radio_juzhen.Checked)//矩阵换位解密
            {
                


                if (miyao.Equals(""))
                {
                    MessageBox.Show("密钥为空");
                    //flag = false;
                    return;
                }


                if (!(miwen.Length % miyao.Length == 0))
                {
                    MessageBox.Show("密文长度必须为密钥长度的整数倍");
                    return;
                }




                for (int i = 0; i < miyao.Length; i++)
                {
                    for (int j = i + 1; j < miyao.Length; j++)
                    {
                        if (miyao[i].Equals(miyao[j]))
                        {
                            MessageBox.Show("密钥中不允许有重复字母");
                            return;


                        }
                    }




                    if (!char.IsLetter(miyao[i]))
                    {
                        MessageBox.Show("密钥必须全为字母");
                        return;
                    }
                 }




                char[] charr = new char[100];
                int[] intarr = new int[100];
                int[] xulieintarr = new int[100];
                int zushu,fenzuchangdu;
                miyao = miyao.ToLower();//把所有字母转成小写


                for (int i = 0; i < miyao.Length; i++)
                {
                    charr[i] = miyao[i];
                }




                for (int i = 0; i < miyao.Length; i++)//密钥的字母排序
                {
                    for (int j = i + 1; j < miyao.Length; j++)
                    {
                        if (charr[i] > charr[j])
                        {
                            char t = charr[i];
                            charr[i] = charr[j];
                            charr[j] = t;
                        }
                    }
                }








                for (int i = 0; i < miyao.Length; i++)//算字母序列  intarr[i] = j;表示miyao字符串的第i位 在字母表排在第j位
                {
                    for (int j = 0; j < miyao.Length; j++)
                    {
                        if (miyao[j].Equals(charr[i]))
                        {
                            intarr[i] = j;
                            break;
                        }
                    }
                    //label9.Text += intarr[i];
                }
                //label9.Text += ' ';


                for (int i = 0; i < miyao.Length; i++)//逆序列 用于解密
                {
                    for (int j = 0; j < miyao.Length; j++)
                    {
                        if (i == intarr[j])
                        {
                            xulieintarr[i] = j;
                            break;
                        }
                    }
                    //label9.Text += xulieintarr[i];
                }


                
                zushu = miwen.Length / miyao.Length;
                //fenzuchangdu=miwen.Length/zushu;
                for (int j = 0; j < zushu; j++)//j循环读取分组密文长度
                {
                    for (int i = 0; i < miyao.Length; i++)//i循环读取排序
                    {


                        if (!miwen[xulieintarr[i] * zushu + j].Equals('$'))
                            mingwen += miwen[xulieintarr[i] * zushu + j];
                        //miwen += mingwen[j * miyao.Length + intarr[i]];
                        //label9.Text += xulieintarr[i];
                    }


                }
                //attackbeginsatfive
                TextBox_mingwen.Text = mingwen;
            }
            #endregion


            #region  Vernam解密
            if (radio_Vernam.Checked)//Vernam解密
            {
                if (miyao.Equals(""))
                {
                    MessageBox.Show("密钥为空");
                    //flag = false;
                    return;
                }


                if (miyao.Length != 8)
                {
                    MessageBox.Show("密钥长度必须为8");
                    return;
                }


                for (int i = 0; i < miyao.Length; i++)
                {
                    if (!miyao[i].Equals('1') && !miyao[i].Equals('0'))
                    {
                        MessageBox.Show("密钥必须由1和0构成");
                        return;
                    }
                }


                int intmiyao = Convert.ToInt16(miyao, 2);


                for (int i = 0; i < miwen.Length; i++)
                {
                    int intmi = miwen[i];
                    intmi ^= intmiyao;
                    mingwen += Convert.ToChar(intmi);
                }
                TextBox_mingwen.Text = mingwen;
            }
            #endregion
        }








        long rsaqiumo(long dishu, long zhishu, long n)//求(dishu^zhishu)%n
        {
            long r = 1;
            zhishu += 1;
            while (zhishu != 1)
            {
                r = r * dishu;
                r = r % n;
                zhishu--;
            }
            //printf("%d\n", r);
            return r;
        }




        //  C#改写的，在vs.net 2005下调试通过：
        /// <summary>
        /// 指数取模:x=(a^b)%c （a的b次方mod）
        /// 条件1：在rsa中a<c,其它不用a<c
        /// 条件2:ac互素
        /// </summary>
        /// /*
        /// 
        /// */
        private static long Algmod(long a, long b, long c)
        {
            long[] l = new long[500];
            long z = -1, y;
            for (; b != 1; b >>= 1)//分解b为2进制数．记录下分解成的位数z，构造栈l
            {
                z++;
                if (b % 2 == 0)
                    l[z] = 0;
                else
                    l[z] = 1;
            }
            //a%=c;//如果一开始数就很大，先模一次,防止过大, 求逆
            y = a * a % c;//第一次模
            for (; z > 0; z--)
            {
                if (l[z] > 0) y = (y * a % c) * (y * a % c) % c;
                else y = y * y % c;
            }
            if (l[0] > 0) y = (y * a % c);//最后次模
            return y;
        }


        private void button2_Click(object sender, EventArgs e)
        {
            //long gongyue_e = 65537;
            //long p = 9973;
            //long q = 5009;
            //long t = (p - 1) * (q - 1);
            //long n = p * q;


            //long d = 1;
            //while (((gongyue_e * d) % t) != 1) d++;


            //zidai_ras_gongyao.Text = Convert.ToString(gongyue_e);
            //zidai_rsa_n.Text = Convert.ToString(n);
            //zidai_rsa_siyao.Text = Convert.ToString(d);




            zidai_ras_gongyao.Text = "65537";
            zidai_rsa_n.Text = "49954757";
            zidai_rsa_siyao.Text = "44705537";
        }


        private void radio_rsa_CheckedChanged(object sender, EventArgs e)
        {
            if (radio_rsa.Checked)
            {
                textBox_n.ReadOnly = false;
            }
            else
            {
                textBox_n.ReadOnly = true;
            }
        }


        private void radio_juzhen_CheckedChanged(object sender, EventArgs e)
        {
            if (radio_rsa.Checked)
            {
                textBox_n.ReadOnly = false;
            }
            else
            {
                textBox_n.ReadOnly = true;
            }
        }


        private void radio_Vernam_CheckedChanged(object sender, EventArgs e)
        {
            if (radio_rsa.Checked)
            {
                textBox_n.ReadOnly = false;
            }
            else
            {
                textBox_n.ReadOnly = true;
            }
        }
    }
}

剑有偏锋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
信息安全_置换加密算法_矩阵换位加…
CHINAonlyQiu的专栏
08-23 8500
【题意描述】 置换密码算法的原理是不改变明文字符，而是按照某一规则重新排列消息中的比特或字符顺序，才而实现明文信息的加密。置换密码有时又称为换位密码。 矩阵换位法是实现置换密码的一种常用方法。它将明文中的字母按照给定的顺序安排在一个矩阵中，然后用根据密钥提供的顺序重新组合矩阵中的字母，从而形成密文。例如，明文为attack begins at five，密钥为cipher，将明文按照每行6个字
C#实现简单的RSA非对称加密算法示例
08-29
C#实现简单的RSA非对称加密算法示例 本文主要介绍了C#实现简单的RSA非对称加密算法，结合实例形式分析了C#实现RSA加密的具体步骤与相关操作技巧。 RSA非对称加密算法是公钥密码体制中的一种，使用了一对密钥，一个...
扩展欧几里得求解逆元、RSA中公私钥（利用矩阵快速无脑求解）
weixin_43736501的博客
06-23 1341
情景引入： 先来看这样一道例题：在使用RSA密码体制中，如果截获了发送给其他用户的密文c=10，若此用户的公钥为e=7，n=77，请问明文的内容是什么？ 通过学习RSA，我们可以得到以下信息： 两个素数：p=7,q=11； n=p*q=7*11=77； φ（n）=(p-1)*(q-1)=60; 公钥e=7, ...
简单密码矩阵置换
焱敦的博客
04-15 1万+
一、传统简单加密技术--深度加密： 明文：i love you 要求加密深度为2 i o e o l v y u 加密后密文为：ioeolvyu 如果没看懂再举一例，延伸上面的例子加密深度为3 i v o l e u o y 加密后密文为：ivoleuoy 二、传统简单加密技术--置换加密（key为数字） 明文：i love you 要求以秘钥：key=...
详解密码学中几种常见密码加密与解密
肥学的博客
04-05 1万+
已知明文:MEET ME AFITER THE TOGO PARTY，分别用以下方法加密，写出加密后的密文。然后完成解密。 (1)Caesar加密，分别用k=3，k= 5加密; (2) Vigenere密码，k = word: (3)栅栏式密码; (4)矩阵置换密码，矩阵3×8，分别用k= 12345678和k= 34127856。
C++ 矩阵置换密码的具体实现
wikl的博客
04-03 3751
置换密码 置换密码算法的原理是不改变明文字符，只将字符在明文中的排列顺序改变，从而实现明文信息的加密。置换密码也叫换位密码。它的加密方法是将明文中的字母按照给定的顺序安排在一个矩阵中，然后用根据密钥提供的顺序重新组合矩阵中的字母，形成密文。例如，明文为 attack begins at five，密钥为 cipher，将明文按照每行 6 个字母的形式排在矩阵中，如下形式： a t t a c k b e g i n s a t f i v e 根据密钥 cipher 中各字母在字母表中出现的先后顺序，.
RSA文件加密算法C#实现.rar_RSA文件加密算法C#实现_RSA算法_grayvwe_rsa加密_rsa文件加密
09-22
在给定的压缩包文件“RSA文件加密算法C#实现”中，可能包含了实现RSA加密的C#代码示例，这些代码可以帮助理解如何在C#环境中集成RSA加密功能，用于保护敏感文件的安全。 总之，RSA文件加密算法在C#中的实现涉及到...
基于私钥加密公钥解密的RSA算法C#实现方法
09-04
总的来说，实现基于私钥加密公钥解密的RSA算法需要对RSA的数学原理有深入理解，并能够自定义加密和解密过程，以适应C#中`RSACryptoServiceProvider`类的限制。这种方法在某些特定应用场景，如软件注册码的加密，是...
RSA加密算法c++实现
04-07
RSA加密算法的实现，使用c++语言编程，使用dev c++平台编码，文件为cpp格式。经过反复测试代码正确，可搭配RSA讲解教程一起使用，讲解教程点击我的个人主页即可查看，希望能够对你有帮助，谢谢。
RSA的解法
weixin_48224845的博客
11-04 391
http://www.so-cools.com/?p=818
C++实现置换算法通过矩阵变换加密解密
10-28
C++实现置换算法通过矩阵变换加密解密，内容简单实用！
置换密钥矩阵加密算法的改进 (2008年)
05-20
提出了对分组加密算法（RKM）的改进，主要包括密钥进化算法、特征因子子矩阵和密钥的分发与更新算法。密钥进化算法是特征因子子矩阵生成算法和密钥分发与更新算法的基本组件，由一个16字节的单字节数组（称为进化指针）和一个密钥矩阵计算一个新的密钥矩阵。特征因子子矩阵是把128BIT矩阵特征因子作为进化指针代入密钥进化算法计算而得。在引入特征因子子矩阵的基础上对算法流程进行了改进，使算法的加、解密完全对称。在不降低算法安全性的基础上减少了4轮异或运算，从而降低了运算量。在密钥进化算法的基础上设计了密钥的分发与更新算
一种全新的基于置换密钥矩阵加密算法 (2005年)
05-13
介绍一种全新的基于置换密钥矩阵（RKM）的非线性多米诺查表加密算法。RKM算法以一个16×16阶置换矩阵为密钥，将分组明文以-5-节的方式通过置换矩阵查表得到密文；同N-RKM加密算法还引入置换密钥矩阵横向和纵向特征因子以及多米诺查表，使其安全性得到进一步提高。
网络安全-古典加密算法之置换密码加解密算法
快乐的小小程序猿
02-22 1万+
置换密码 置换密码算法的原理是不改变明文字符，只将字符在明文中的排列顺序改变，从而实现明文信息的加密。置换密码有时又称为换位密码。 矩阵换位法是实现置换密码的一种常用方法。它将明文中的字母按照给的顺序安排在一个矩阵中，然后用根据密钥提供的顺序重新组合矩阵中字母，从而形成密文。例如，明文为attack begins atfive，密钥为cipher，将明文按照每行6列的形式排在矩阵中，形成如下形式...
RSA原理
Hydra的博客
11-26 1702
前言          最近碰到好多RSA，不得不。。。 介绍 RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA是1977年由 罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman） 一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。 ...
RSA算法原理详解
weixin_30735745的博客
06-29 565
一些相关的数学概念 在理解RSA算法之前，我们必须理解一些相关的数学概念。 质数及互质 质数(Prime number)又称素数,指在大于1的自然数中，除了1和该数自身外，无法被其他自然数整除的数。大于1的自然数若不是素数，则称之为合数。 如果两个或两个以上的整数的最大公约数是 1，则称它们为互质(也叫互素)。两个整数 a 与 b 互质，记为 a ⊥ b。 互质的两个数，有如下性质 整数a和b互...
Vernam加密解密C++实现
06-29 1538
 #include #include #include using namespace std;int main(){ string plain,ciper,key; int len; //长度三者一致 void change(string &, vector&);//字符变数字 vector encrypt_compute(vec
置换密码代码简单实现（C语言）
热门推荐
烟敛寒林的博客
09-06 2万+
置换只不过是一个简单的换位，每个置换都可以用一个置换矩阵Ek来表示。每个置换都有一个与之对应的逆置换Dk。置换密码的特点是仅有一个发送方和接受方知道的加密置换（用于加密）及对应的逆置换（用于解密）。它是对明文L长字母组中的字母位置进行重新排列，而每个字母本身并不改变。 代码实现： #include&lt;stdio.h&gt; #include&lt;string.h&gt; int...
基于python的RSA加密算法软件设计与实现.docx
最新发布
08-17
基于python的RSA加密算法软件设计与实现

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值