常见加密算法简析

Posted linybo

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了常见加密算法简析相关的知识,希望对你有一定的参考价值。

1、对称加密算法(AES、DES、3DES)

对称加密算法是指加密和解密采用相同的密钥,是可逆的(即可解密),也叫单钥加密。

AES加密算法是密码学中的高级加密标准,采用的是对称分组密码体制,密钥长度的最少支持为128。AES加密算法是美国联邦政府采用的区块加密标准,这个标准用来替代原先的DES,已经被多方分析且广为全世界使用。

AES数学原理详解:https://www.cnblogs.com/block2016/p/5596676.html

优点:加密速度快

缺点:密钥的传递和保存是一个问题,参与加密和解密的双方使用的密钥是一样的,这样密钥就很容易泄露。

2、非对称加密算法(RSA、DSA、ECC)

非对称加密算法是指加密和解密采用不同的密钥(公钥和私钥),因此非对称加密也叫公钥加密,是可逆的(即可解密),也叫双钥加密。公钥密码体制根据其所依据的难题一般分为三类:大素数分解问题类、离散对数问题类、椭圆曲线类。

RSA加密算法是基于一个十分简单的数论事实:将两个大素数相乘十分容易,但是想要对其乘积进行因式分解极其困难,因此可以将乘积公开作为加密密钥。虽然RSA的安全性一直未能得到理论上的证明,但它经历了各种攻击至今未被完全攻破。 

优点:加密和解密的密钥不一致,公钥是可以公开的,只需保证私钥不被泄露即可,这样就密钥的传递变的简单很多,从而降低了被破解的几率。

缺点:加密速度慢

RSA加密算法既可以用来做数据加密,也可以用来数字签名。

--数据加密过程:发送者用公钥加密,接收者用私钥解密(只有拥有私钥的接收者才能解读加密的内容)

--数字签名过程:甲方用私钥加密,乙方用公钥解密(乙方解密成功说明就是甲方加的密,甲方就不可以抵赖)

简单理解就是:

--既然是加密,那肯定是不希望别人知道我的消息,所以只有我才能解密,所以可得出公钥负责加密,私钥负责解密

--同理,既然是签名,那肯定是不希望有人冒充我发消息,只有我才能发布这个签名,所以可得出私钥负责签名,公钥负责验证

详细数学原理见 【来龙去脉系列】RSA算法原理

ECC加密算法是基于椭圆曲线上离散对数计算问题(ECDLP)的ECC算法。ECC算法的数学理论非常深奥和复杂,在工程应用中比较难于实现,但它的单位安全强度相对较高。

用国际上公认的对于ECC算法最有效的攻击方法--Pollard rho方法去破译和攻击ECC算法,它的破译或求解难度基本上是指数级的。正是由于RSA算法ECC算法这一明显不同,使得ECC算法的单位安全强度高于RSA算法,也就是说,要达到同样的安全强度,ECC算法所需的密钥长度远比RSA算法低。有研究表示160位的椭圆密钥与1024位的RSA密钥安全性相同。在私钥的加密解密速度上,ECC算法比RSA、DSA速度更快。存储空间占用更小。

扩展阅读:

ECDH and ECDSA   

How to encrypt data using Elliptic Curve Algorithm in C#

ECC Examples for C#

3、线性散列算法算法(MD5、SHA1、HMAC)

MD5全称是Message-Digest Algorithm 5(信息摘要算法5),单向的算法不可逆(被MD5加密的数据不能被解密)。MD5加密后的数据长度要比加密数据小的多,且长度固定,且加密后的串是唯一的。

适用场景:常用在不可还原的密码存储、信息完整性校验等。

信息完整性校验:典型的应用是对一段信息产生信息摘要,以防止被篡改。如果再有一个第三方的认证机构,用MD5还可以防止文件作者的“抵赖”,这就是所谓的数字签名应用。

SHA-1 与 MD5 的比较

SHA-1摘要比MD5摘要长32 位,所以SHA-1对强行攻击有更大的强度,比MD5更安全。使用强行技术,产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2^128数量级的操作,而对SHA-1则是2^160数量级的操作。

在相同的硬件上,SHA-1 的运行速度比 MD5 慢。

4、混合加密

由于以上加密算法都有各自的缺点(RSA加密速度慢、AES密钥存储问题、MD5加密不可逆),因此实际应用时常将几种加密算法混合使用。

例如:RSA+AES:

采用RSA加密AES的密钥,采用AES对数据进行加密,这样集成了两种加密算法的优点,既保证了数据加密的速度,又实现了安全方便的密钥管理。

那么,采用多少位的密钥合适呢?一般来讲密钥长度越长,安全性越高,但是加密速度越慢。所以密钥长度也要合理的选择,一般RSA建议采用1024位的数字,AES建议采用128位即可。

5、Base64

严格意义讲,Base64并不能算是一种加密算法,而是一种编码格式,是网络上最常见的用于传输8bid字节代码的编码方式之一。

Base64编码可用于在HTTP环境下传递较长的标识信息,Base编码不仅不仅比较简单,同时也据有不可读性(编码的数据不会被肉眼直接看到)。

6、各种加密算法对比

a)对称算法

密钥管理:比较难,不适合互联网,一般用于内部系统

安全性:中

加密速度:快好 几个数量级 (软件加解密速度至少快 100 倍,每秒可以加解密数 M 比特 数据),适合大数据量的加解密处理

b)非对称算法

密钥管理:密钥容易管理,适合互联网数据传输

安全性:高

加密速度:比较慢,适合 小数据量 加解密或数据签名

—————————————————————————————————————————————————————————

C#实现:

技术图片
using System;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace EnDeCode1
{
    /// <summary>
    /// 加密解密工具类
    /// 作者博客:https://www.cnblogs.com/tuyile006/
    /// </summary>
    public class EncodeHelper
    {
        #region MD5
        /// <summary>
        /// MD5哈希加密
        /// </summary>
        /// <param name="scr">原始string数据</param>
        /// <returns>加密后的数据</returns>
        public static string MD5(string scr)
        {
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] palindata = Encoding.Default.GetBytes(scr);//将要加密的字符串转换为字节数组
            byte[] encryptdata = md5.ComputeHash(palindata);//将字符串加密后也转换为字符数组
            return Convert.ToBase64String(encryptdata);//将加密后的字节数组转换为加密字符串
        }
        #endregion

        #region SHA1
        /// <summary>
        /// SHA1哈希加密
        /// </summary>
        /// <param name="scr">原始string数据</param>
        /// <returns>加密后的数据</returns>
        public static string SHA1(string scr)
        {
            SHA1 sha1 = new SHA1CryptoServiceProvider();
            byte[] palindata = Encoding.Default.GetBytes(scr);//将要加密的字符串转换为字节数组
            byte[] encryptdata = sha1.ComputeHash(palindata);//将字符串加密后也转换为字符数组
            return Convert.ToBase64String(encryptdata);//将加密后的字节数组转换为加密字符串
        }
        #endregion

        #region RSA
        /// <summary>
        /// RSA加密
        /// </summary>
        /// <param name="scr">原始string数据</param>
        /// <returns></returns>
        public static string RSA(string scr)
        {
            CspParameters csp = new CspParameters(); //密钥容器知识参见https://docs.microsoft.com/zh-cn/dotnet/standard/security/how-to-store-asymmetric-keys-in-a-key-container
                                                     //在Web中配置参见https://docs.microsoft.com/zh-cn/previous-versions/aspnet/yxw286t2%28v%3dvs.100%29
            csp.KeyContainerName = "tuyile006.cnblogs.com";//密匙容器的名称,保持加密解密一致才能解密成功
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(csp))
            {
                byte[] plaindata = Encoding.Default.GetBytes(scr);//将要加密的字符串转换为字节数组
                byte[] encryptdata = rsa.Encrypt(plaindata, false);//将加密后的字节数据转换为新的加密字节数组
                return Convert.ToBase64String(encryptdata);//将加密后的字节数组转换为字符串
            }
        }
        /// <summary>
        /// RSA解密
        /// </summary>
        /// <param name="scr">密文</param>
        /// <returns></returns>
        public static string RSADecrypt(string scr)
        {
            try
            {
                CspParameters csp = new CspParameters();
                csp.KeyContainerName = "tuyile006.cnblogs.com";//密匙容器的名称,保持加密解密一致才能解密成功
                using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(csp))
                {
                    byte[] bytes = Convert.FromBase64String(scr); //加密时用了Base64,则解密时对应的也要用Base64解码
                    byte[] DecryptBytes =  rsa.Decrypt(bytes, false);
                    return Encoding.Default.GetString(DecryptBytes);
                }
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// 返回RSA公匙
        /// </summary>
        /// <returns></returns>
        public static string GetRSAPublicKey()
        {
            CspParameters csp = new CspParameters();
            csp.KeyContainerName = "tuyile006.cnblogs.com";//密匙容器的名称,保持加密解密一致才能解密成功
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(csp))
            {
                return rsa.ToXmlString(false);
            }
        }

        #endregion

        #region DES
        const string DesIV_64 = "xiaoy><@";//定义默认加密密钥 8个字节 
        /// <summary>
        /// 按指定键值进行DES加密
        /// </summary>
        /// <param name="strContent">要加密字符</param>
        /// <param name="strKey">自定义键值 ASCII编码  必须大于或等于8个字符</param>
        /// <returns></returns>
        public static string DES(string strContent, string strKey)
        {
            if (string.IsNullOrEmpty(strContent)) return string.Empty;
            if (strKey.Length > 8) strKey = strKey.Substring(0, 8);
            
            DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
            byte[] byKey = Encoding.ASCII.GetBytes(strKey);
            byte[] byIV = Encoding.ASCII.GetBytes(DesIV_64);
            
            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateEncryptor(byKey, byIV), CryptoStreamMode.Write))
                {
                    using (StreamWriter sw = new StreamWriter(cst))
                    {
                        sw.Write(strContent);
                        sw.Flush();
                        cst.FlushFinalBlock();
                        sw.Flush();
                        return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
                    }
                }
            }
        }

        /// <summary>
        /// 按指定键值进行DES解密
        /// </summary>
        /// <param name="strContent">要解密字符</param>
        /// <param name="strKey">加密时使用的键值 ASCII编码 必须大于或等于8个字符</param>
        /// <returns></returns>
        public static string DESDecrypt(string strContent, string strKey)
        {
            if (string.IsNullOrEmpty(strContent)) return string.Empty;
            if (strKey.Length > 8) strKey = strKey.Substring(0, 8); 
            byte[] byKey = Encoding.ASCII.GetBytes(strKey);
            byte[] byIV = Encoding.ASCII.GetBytes(DesIV_64);

            byte[] byEnc;
            try
            {
                byEnc = Convert.FromBase64String(strContent);
                using (DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider())
                {
                    using (MemoryStream ms = new MemoryStream(byEnc))
                    {
                        using (CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateDecryptor(byKey, byIV), CryptoStreamMode.Read))
                        {
                            StreamReader sr = new StreamReader(cst);
                            return sr.ReadToEnd();
                        }
                    }
                }
            }
            catch
            {
                return string.Empty;
            }
            
        }
        #endregion

        #region AES
        const string AesIV_128 = "xiaoy设计.";//定义默认加密密钥 16个字节 Unicode编码为8个英文或汉字
        /// <summary>
        /// 按指定键值进行AES加密
        /// </summary>
        /// <param name="plainText">要解密字符</param>
        /// <param name="strKey">加密时使用的键值 Unicode编码 必须大于或等于8个英文或汉字</param>
        /// <returns></returns>
        public static string AES(string strContent, string strKey)
        {
            if (string.IsNullOrEmpty(strContent)) return string.Empty;
            if (strKey.Length > 8) strKey = strKey.Substring(0, 8);

            using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider())
            {
                aesAlg.Key = Encoding.Unicode.GetBytes(strKey);
                aesAlg.IV = Encoding.Unicode.GetBytes(AesIV_128);
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(strContent);
                        }
                        return Convert.ToBase64String(msEncrypt.ToArray()); //返回Base64密文方便传输
                    }
                }
            }
        }
        /// <summary>
        /// 按指定键值进行AES解密
        /// </summary>
        /// <param name="strContent">要解密字符</param>
        /// <param name="strKey">加密时使用的键值 Unicode编码 必须大于或等于8个英文或汉字</param>
        /// <returns></returns>
        public static string AESDecrypt(string strContent, string strKey)
        {
            if (string.IsNullOrEmpty(strContent)) return string.Empty;
            if (strKey.Length > 8) strKey = strKey.Substring(0, 8);
            //与加密时Base64对应
            byte[] byEnc;
            try
            {
                byEnc = Convert.FromBase64String(strContent);
                //解密
                using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider())
                {
                    aesAlg.Key = Encoding.Unicode.GetBytes(strKey);
                    aesAlg.IV = Encoding.Unicode.GetBytes(AesIV_128);

                    // Create a decryptor to perform the stream transform.
                    ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

                    // Create the streams used for decryption.
                    using (MemoryStream msDecrypt = new MemoryStream(byEnc))
                    {
                        using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                        {
                            using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                            {
                                return srDecrypt.ReadToEnd();
                            }
                        }
                    }
                }
            }
            catch
            {
                return string.Empty;
            }
        }
        #endregion

        #region ECC

        /// <summary>
        /// 利用ecc生成key
        /// 假设从A-->B进行信息发送
        /// </summary>
        /// <param name="AKeyName">A的公钥名称 自身</param>
        /// <param name="BKey">B的公钥</param>
        /// <returns> 生成A端用于交互信息的密钥,可以用于AES加密的密钥</returns>
        public static string ECC_EncodeKey(string AKeyName,string BKey)
        {
            byte[] BKeybyte = Convert.FromBase64String(BKey);
            using (ECDiffieHellmanCng AClient = new ECDiffieHellmanCng(CngKey.Open(AKeyName)))
            //using (ECDiffieHellmanCng AClient = new ECDiffieHellmanCng())
            {
                AClient.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
                AClient.HashAlgorithm = CngAlgorithm.Sha256;
                
                byte[] MsgKey = AClient.DeriveKeyMaterial(CngKey.Import(BKeybyte, CngKeyBlobFormat.EccPublicBlob));
                return Convert.ToBase64String(MsgKey);
            }
        }

        /// <summary>
        /// 获取自身的公钥
        /// </summary>
        /// <returns>Base64编码的字符串,接收端需要Base64解码再使用</returns>
        public static string ECC_GetMyPublicKey(string keyName)
        {
            if (!CngKey.Exists(keyName))
            {
                using (ECDiffieHellmanCng MyECC = new ECDiffieHellmanCng(CngKey.Create(CngAlgorithm.ECDiffieHellmanP256, keyName)))
                {
                    MyECC.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
                    MyECC.HashAlgorithm = CngAlgorithm.Sha256;
                    byte[] Keybyte = MyECC.PublicKey.ToByteArray();
                    return Convert.ToBase64String(Keybyte);

                }
            }
            else
            {
                using (ECDiffieHellmanCng MyECC = new ECDiffieHellmanCng(CngKey.Open(keyName)))
                {
                    byte[] Keybyte = MyECC.PublicKey.ToByteArray();
                    return Convert.ToBase64String(Keybyte);
                }
            }
        }
        #endregion
    }
}
技术图片

这些算法已经在.net框架里面封装好了,只需要引用System.Security.Cryptography库,使用起来还是非常方便的。

使用示例:(下载Demo)

技术图片

算法调用很简单:

 txtEncode.Text = EncodeHelper.MD5(txtMsg.Text);
 txtEncode.Text = EncodeHelper.RSA(txtMsg.Text);
txtMsg.Text = "解密后的文本:" + EncodeHelper.RSADecrypt(txtEncode.Text);
txtEncode.Text = EncodeHelper.AES(txtMsg.Text, "密钥可以是汉字哦");
txtMsg.Text = "解密后的文本:" + EncodeHelper.AESDecrypt(txtEncode.Text, "密钥可以是汉字哦");

稍微复杂一点的是ECC+AES混合加密,用ECC加密AES的密钥,而用AES加密要传送的信息,接收端用ECC公钥解密得到AES密钥,然后解密信息。

该过程可以参考MSDN上的例子https://docs.microsoft.com/ru-ru/dotnet/api/system.security.cryptography.ecdiffiehellmancng

技术图片
string bkey, akey,akeyname="akey",bkeyname="bkey";

        private void btn_Ecc_Click(object sender, EventArgs e)
        {
            akey = EncodeHelper.ECC_GetMyPublicKey(akeyname); //A先获取自身的publickey
            bkey = EncodeHelper.ECC_GetMyPublicKey(bkeyname); //B先获取自身的publickey
            string  AClientAESKey = EncodeHelper.ECC_EncodeKey(akeyname, bkey);  //用bkey生成用于AES算法的key
            txtEncode.Text = EncodeHelper.AES(txtMsg.Text, AClientAESKey);
        }

        private void btn_eccrec_Click(object sender, EventArgs e)
        {
            string BClientAESKey = EncodeHelper.ECC_EncodeKey(bkeyname, akey);  //用akey生成用于AES算法的key
            txtMsg.Text ="解密后的文本:"+ EncodeHelper.AESDecrypt(txtEncode.Text, BClientAESKey);
        }
技术图片

 

参考地址:https://blog.csdn.net/baidu_22254181/article/details/82594072

 ******************转摘:https://www.cnblogs.com/tuyile006/p/10873975.html

以上是关于常见加密算法简析的主要内容,如果未能解决你的问题,请参考以下文章

Https 协议简析及中间人攻击原理

数据加密(MD5,DES,RSA)简析

聚类算法简析:朴素贝叶斯算法的场景案例

逆向常见加密算法值BlowFish算法

可以解密加密数据的片段吗?

SSL常见加密算法