API接口入门（二）：API接口的签名验签和加解密原理

Posted 2023-04-29

参考技术A 本文目录：

API接口为什么要签名加密？

API接口如何加密？

一、API接口为什么要签名加密？

想象一个场景：一位许久不见的好兄弟，突然在微信里面跟你说“兄弟，借我1万应急呗”，你会怎么反应？

我想大部分人马上的反应就是：是不是被盗号了？他是本人吗？

实际上这是我们日常生活中常见的通讯行为，系统间调用API和传输数据的过程无异于你和朋友间的微信沟通，所有处于开放环境的数据传输都是可以被截取，甚至被篡改的。因而数据传输存在着极大的危险，所以必须加密。

加密核心解决两个问题：

你是本人吗？（签名验签）

你传过来的信息是对的吗？（加密解密）

二、API接口如何签名验签和加密解密？

古代人写信通过邮差传信，路途遥远，他们为了避免重要的内容被发现，决定用密文来写信，比如我想表达“八百标兵上北坡”，我写成800north，并且收件人也知道怎么阅读这份信息，即使路上的人截取偷看了，也看不懂你们在说的什么意思。同时我在文末签上我的字迹，在盒子里放上我的信物（比如一片羽毛等等），这样收件人也就知道这份信是我寄出的了。

这被称为“对称性密码”，也就是加密的人用A方式加密，解密的人用A方式解密，有什么缺点呢？

如果你经常传输，这就很容易被发现了密码规律，比如我很快就知道你寄信都会带上一片羽毛，那我以后也可以搞一片羽毛来冒充你了。加上，如果我要给很多人寄信，我就要跟每个人告诉我的加密方式，说不准有一个卧底就把你的加密方式出卖了。

因为互联网传输的对接方数量和频率非常高，显然搞个对称性密码是不安全的。于是，基于对称性密码延伸出“非对称密码”的概念。

1. 公私钥——签名验签及加解密原理

通俗的解释：A要给B发信息，B先把一个箱子给A，A收到之后把信放进箱子，然后上锁，上锁了之后A自己也打不开，取不出来了，因为钥匙在B的手里，这样即使路上被截取了，别人也打不开箱子看里面的信息，最后B就能安全地收到A发的信了，并且信息没有泄露。

现在我们以一个单向的A发信息给B的场景进行深入了解公私钥工作原理。

发送者和接收者都有2套加解密的方法，而且他们把其中一套加密方法a和解密方法b都公开（虚线标黑）；

这里提到的加解密，因为密码学过于深奥，无法解释。大家需默认加密方法是不能反推出解密方法的，解密方法是不能反推出加密方法的。a加密就必须a解密，b加密就必须b解密；

现在A需要向B发送一条信息，因为信息的内容很重要，他就用接收者B的加密方法c进行加密，这样只有B自己的解密方法c才能解开，任何人获取了都解开不了，包括A自己也解不开；

在A向B发送信息的同时，需要带上自己的签名，这个时候A用自己才知道的加密方法b进行加密，因为任何人都知道解密方法b，所以任何人都可以看到A的签字，也就是任何人都知道这条是A发出来的信息，但因为签名不是不能公开的信息，所以被解密了也没有关系。

总结：

（1）签名会被任何人获取，但因为签名内容不涉及核心内容，被获取破解是OK的。

（2）重要内容只能接收方解密，任何人获取了都无法解密。

（3）接收者B只有验证签名者是A的信息，才会执行接下来的程序。阿猫阿狗发来的信息不予执行。

捣局者C可能的情况：

（1）他获取到这条信息是A发出的，但看不明白加密的内容。

（2）他可以也用接受者B的加密方法c向接收者B发信息，但他无法冒充发送者A的签名，所以B不会接受C的请求。

（2）公私钥的非对称加密+session key对称加密

2. 公私钥的非对称加密+session key对称加密

上一小节解释的公私钥加密是标准和安全的，但因为这类非对称加密对系统运算的需求比较大，在保证安全的前提下，还是尽量希望提升程序响应的时效。所以目前主流应用的另一种加密方式是公私钥的非对称加密+session key对称加密。

当A向B发送信息的时候，不需要用到B的公私钥。

A用自己的加密方法b加密签名和一条空信息，因为信息无关重要，被破解了也没关系，B利用解密方法b验证了是A发来的信息。

这个时候，接收者B用发送者A的加密方法a，加密一个有时效的加密方法给A（相当于告诉A，这2个小时，我们用这个暗号进行沟通），因为只有A有解密方法，所以别人获取了也不能知道session key是什么。

A接收到session key了以后，A用这种有时效的加密函数发送重要信息，签名仍用加密方法b加密，B用同样一个加密函数解密（实际上变成了对称加密，大家都用同样的方式加解密）

2小时后，再重复第2步，更新加密方法。

3. 总结

（1）当B向A发出临时有效的加密方法之后，通讯的过程变为了对称加密；

（2）这类加密方式的核心是时效性，必须在短时间内更新，否则固定的规律容易被获取破解。

捣局者C可能的情况：

（1）他获取到B发出的session key的加密文件，无法破解session key是什么。因为解密方法在A手上；

（2）通过各种手段，C破解出session key的加解密方法，但因为时效已到，session key更新，C徒劳无功；

（3）C在时效内破解出session key，但无法冒充A的签名。

以上是2种常见的加解密方式，每个开放平台会在概述中最开始介绍API调用的安全加解密方法，这是每个对接过程中必须的准备流程，如微信企业平台在概述中就已介绍利用第2种方法（企业微信命名为access_token）进行加解密传输。

三、最后

以上就是API签名验签和加解密的基本原理，接下来我会继续更新API的请求方式等问题，同时以企业微信，微信开放平台等大型开放平台的业务解释各平台支持的现有功能。

综上，水平有限，如有纰漏，敬请指出。

RSACryptoServiceProvider加密解密签名验签和DESCryptoServiceProvider加解密

原文:RSACryptoServiceProvider加密解密签名验签和DESCryptoServiceProvider加解密

C#在using System.Security.Cryptography下有 DESCryptoServiceProvider RSACryptoServiceProvider 
DESCryptoServiceProvider 是用于对称加密 RSACryptoServiceProvider是用于非对称加密 
对称加密的意思：有一个密钥 相当于加密算法，加密用它来加密，解密也需要用到它。因为加密解密都是用同一个密钥所以叫对称加密。 对称加密有一个坏处只要拥有密钥的人都可以解密。 
非对称加密：就是有2个密钥，一个是公钥，一个是私钥，私钥是自己的，不能随便给人，公钥随便给，无所谓。一般是别人用你的公钥加密，然后把密文给你，你用你的私钥解密，这样一样加密和解密不是同一个密钥，所以叫非对称。 非对称的好处是假如没有私钥别人是无法解密的，就算加密的那个人他把数据加密了他也无法解密，加密者把密文和公钥随便给那个人都无法解密。 
数字签名：数字签名的意义就是这些数据与原文数据比对是否修改过，这个解释有点麻烦，当初我也搞了好久才理解！一般是用自己的私钥对数据进行签名，然后用公钥去验证这个数据是否修改过 
-
现在该说说DESCryptoServiceProvider 和RSACryptoServiceProvider 在C#中的具体怎么用: 
-
1、用RSACryptoServiceProvider 加密解密 
 

//加密解密用到的公钥与私钥 
RSACryptoServiceProvider oRSA = new RSACryptoServiceProvider(); 
string privatekey=oRSA.ToXmlString(true);//私钥 
string publickey=oRSA.ToXmlString(false);//公钥 
//这两个密钥需要保存下来 
byte[] messagebytes = Encoding.UTF8.GetBytes("luo罗"); //需要加密的数据 
-
//公钥加密 
RSACryptoServiceProvider oRSA1 = new RSACryptoServiceProvider(); 
oRSA1.FromXmlString(publickey); //加密要用到公钥所以导入公钥 
byte[] AOutput = oRSA1.Encrypt(messagebytes ,false); //AOutput 加密以后的数据 
-
//私钥解密 
RSACryptoServiceProvider oRSA2 = new RSACryptoServiceProvider(); 
oRSA2.FromXmlString(privatekey);           
byte[] AInput = oRSA2.Decrypt(AOutput, false); 
string reslut=Encoding.ASCII.GetString(AInput) 

 

 
2、用RSACryptoServiceProvider签名验签 
   

byte[] messagebytes = Encoding.UTF8.GetBytes("luo罗"); 
           RSACryptoServiceProvider oRSA = new RSACryptoServiceProvider(); 
           string privatekey = oRSA.ToXmlString(true); 
           string publickey = oRSA.ToXmlString(false); 
           
            //私钥签名 
            RSACryptoServiceProvider oRSA3 = new RSACryptoServiceProvider(); 
            oRSA3.FromXmlString(privatekey); 
            byte[] AOutput = oRSA3.SignData(messagebytes, "SHA1"); 
            //公钥验证 
            RSACryptoServiceProvider oRSA4 = new RSACryptoServiceProvider(); 
            oRSA4.FromXmlString(publickey); 
            bool bVerify = oRSA4.VerifyData(messagebytes, "SHA1", AOutput); 

 

3、用证书进行签名 
   

   // 因为一般证书的私钥是不可以导出的所以所以用第2种方法导入私钥的来进行签名行不通 
byte[] messagebytes = Encoding.UTF8.GetBytes("luo罗"); 
           string Path = @"D:\Certificate\1.P12"; 
           X509Certificate2 x509 = new X509Certificate2(Path, "12345678"); 
           SHA1 sha1 = new SHA1CryptoServiceProvider(); 
           byte[] hashbytes = sha1.ComputeHash(messagebytes); //对要签名的数据进行哈希 
           RSAPKCS1SignatureFormatter signe = new RSAPKCS1SignatureFormatter(); 
           signe.SetKey(x509.PrivateKey); //设置签名用到的私钥 
           signe.SetHashAlgorithm("SHA1"); //设置签名算法 
           byte[] reslut = signe.CreateSignature(hashbytes); 
//验签：与第2方法相同 
           RSACryptoServiceProvider oRSA4 = new RSACryptoServiceProvider(); 
           oRSA4.FromXmlString(x509.PublicKey.Key.ToXmlString(false)); 
           bool bVerify = oRSA4.VerifyData(messagebytes, "SHA1", reslut); 

 

4、用证书加密解密 
    

 string Path = @"D:\Certificate\1.P12"; 
            X509Certificate2 x509 = new X509Certificate2(Path, "12345678"); 
            byte[] data = System.Text.Encoding.UTF8.GetBytes("cheshi罗"); 
-
            //证书公钥加密 
            RSACryptoServiceProvider oRSA1 = new RSACryptoServiceProvider(); 
     
            oRSA1.FromXmlString(x509.PublicKey.Key.ToXmlString(false)); 
-
            byte[] AOutput = oRSA1.Encrypt(data, false); 
-
            //证书私钥解密 
            RSACryptoServiceProvider rsa2 = (RSACryptoServiceProvider)x509.PrivateKey; 
            byte[] plainbytes = rsa2.Decrypt(AOutput, false); 
            string reslut = Encoding.UTF8.GetString(plainbytes); 

 

5用证书对文件加密解密，因为文件可能特别大 所以需要用流和buffer的方式来，鄙视把文件全部读到byte[]里进行加密的人，假如文件5G，那全部读到byte[]里崩溃掉 
   

private void Form1_Load(object sender, EventArgs e) 
        { 
            x509=new X509Certificate2(Path, "12345678"); 
            RSACryptoServiceProvider oRSA1 = new RSACryptoServiceProvider(); 
            Encrypt(); 
            Decrypt();           
        } 
        private void Decrypt() 
        { 
            string FilePath = "2.txt"; 
            string OutFile = "3.txt"; 
            System.IO.FileStream picfs = new System.IO.FileStream(FilePath, System.IO.FileMode.Open); 
            System.IO.FileStream fs = new System.IO.FileStream(OutFile, System.IO.FileMode.OpenOrCreate); 
            oRSA1 = (RSACryptoServiceProvider)x509.PrivateKey; 
            int blocksize = oRSA1.KeySize/8; 
-
            byte[] buffer, buffer1, encryblock; 
            bool Closed = true; 
            while (Closed) 
            { 
                buffer = null; 
                buffer = new byte[blocksize]; 
                int k = picfs.Read(buffer, 0, buffer.Length); 
                if (k > 0) 
                { 
                    if (blocksize == k) 
                    { 
                        encryblock = oRSA1.Decrypt(buffer, false); 
                        fs.Write(encryblock, 0, encryblock.Length); 
                    } 
                    else 
                    { 
                        buffer1 = new byte[k]; 
                        for (int i = 0; i < k; i++) 
                        { 
                            buffer1[i] = buffer[i]; 
                        } 
                        encryblock = oRSA1.Decrypt(buffer1, false); 
                        fs.Write(encryblock, 0, encryblock.Length); 
                    } 
                } 
                else 
                { 
                    picfs.Close(); 
                    fs.Close(); 
                    Closed = false; 
                } 
            } 
-
        } 
        private void Encrypt() 
        { 
            string FilePath = "1.txt"; 
            string OutFile = "2.txt"; 
            //证书公钥加密 
-
            oRSA1.FromXmlString(x509.PublicKey.Key.ToXmlString(false)); 
            System.IO.FileStream picfs = new System.IO.FileStream(FilePath, System.IO.FileMode.Open); 
            System.IO.FileStream fs = new System.IO.FileStream(OutFile, System.IO.FileMode.OpenOrCreate); 
            int blocksize = 0; 
            if (oRSA1.KeySize == 1024) 
            { 
                blocksize = 16; 
            } 
            else 
            { 
                blocksize = 8; 
            } 
            byte[] buffer, buffer1, encryblock; 
            bool Closed = true; 
            while (Closed) 
            { 
                buffer = null; 
                buffer = new byte[blocksize]; 
                int k = picfs.Read(buffer, 0, buffer.Length); 
                if (k > 0) 
                { 
                    if (blocksize == k) 
                    { 
                        encryblock = oRSA1.Encrypt(buffer, false); 
                        fs.Write(encryblock, 0, encryblock.Length); 
                    } 
                    else 
                    { 
                        buffer1 = new byte[k]; 
                        for (int i = 0; i < k; i++) 
                        { 
                            buffer1[i] = buffer[i]; 
                        } 
                        encryblock = oRSA1.Encrypt(buffer1, false); 
                        fs.Write(encryblock, 0, encryblock.Length); 
                    } 
                } 
                else 
                { 
                    picfs.Close(); 
                    fs.Close(); 
                    Closed = false; 
                } 
            } 
        } 

 

6用证书对文件进行签名验签，因为文件可能特别大 所以需要用流和buffer的方式来  

private void Form1_Load(object sender, EventArgs e)
        {
            x509 = new X509Certificate2(Path, "12345678");
             SignFile("1.txt", "11.txt");

             VerifyFile("1.txt", "11.txt");
        }
        private bool VerifyFile(string FileName, string SignedFileName)
        {

            bool reslut = true;

            System.IO.StreamReader objread = new System.IO.StreamReader(FileName);
            System.IO.StreamReader objreadSigned = new System.IO.StreamReader(SignedFileName);

            RSACryptoServiceProvider VeryRsa = new RSACryptoServiceProvider();
            VeryRsa.FromXmlString(x509.PublicKey.Key.ToXmlString(false));

            int Inblocksize = 0;
            int Signedblocksize = 0;
            if (VeryRsa.KeySize == 1024)
            {
                Inblocksize = 16;
            }
            else
            {
                Inblocksize = 8;
            }
            Signedblocksize = VeryRsa.KeySize / 8;

            bool Closed = true;
            byte[] Buffer; //原文缓存区
            byte[] InBuffer;//原文缓存区
            byte[] Buffer1;//签名文件缓存区
            while (Closed)
            {
                Buffer = null;
                Buffer = new byte[Inblocksize];
                int k = objread.BaseStream.Read(Buffer, 0, Buffer.Length);
                if (k > 0)
                {
                    if (Inblocksize == k) //读出来的长度和缓存区一样大
                    {
                        Buffer1 = new byte[Signedblocksize];
                        objreadSigned.BaseStream.Read(Buffer1, 0, Buffer1.Length);
                        reslut = VeryRsa.VerifyData(Buffer,"SHA1",Buffer1);
                        if (!reslut)
                        {
                            Closed = false;
                        }
                    }
                    else
                    { //意思是Buffer没满，只有k个字节，k字节后面全是空所以不需要验签
                        InBuffer = new byte[k];
                        for (int i = 0; i < k; i++)
                        {
                            InBuffer[i] = Buffer[i];
                        }
                        Buffer1 = new byte[Signedblocksize];
                        objreadSigned.BaseStream.Read(Buffer1, 0, Buffer1.Length);
                        reslut = VeryRsa.VerifyData(InBuffer, "SHA1", Buffer1);
                        if (!reslut)
                        {
                            Closed = false;
                        }
                    }
                }
                else
                {
                    //这里的意思是原文已经读完毕了，并且已经和签名文件对应验签成功，那么
                    //签名文件也必须读完毕了。
                    if (objreadSigned.BaseStream.Position!= objreadSigned.BaseStream.Length)
                    {
                        reslut = false;
                    }
                    objreadSigned.Close();
                    objread.Close();
                    Closed = false;
                }
            }
            return reslut;


        }
        private void SignFile(string InFileName,string OutFileName)
        {
            RSACryptoServiceProvider SignRsa = (RSACryptoServiceProvider)x509.PrivateKey;

            System.IO.StreamReader objread = new System.IO.StreamReader(InFileName);
            System.IO.StreamWriter objwrite = new System.IO.StreamWriter(OutFileName, false);

            int blocksize = 0;
            if (SignRsa.KeySize == 1024)
            {
                blocksize = 16;
            }
            else
            {
                blocksize = 8;
            }

            bool Closed = true;
            byte[] Buffer = new byte[blocksize];
            byte[] buffer1, SignBytes;
            while (Closed)
            {
                int k = objread.BaseStream.Read(Buffer, 0, Buffer.Length);
                if (k > 0)
                {
                    if (k == blocksize)
                    {
                        SignBytes = SignRsa.SignData(Buffer, "SHA1");
                        objwrite.BaseStream.Write(SignBytes, 0, SignBytes.Length);
                    }
                    else
                    {
                        buffer1 = new byte[k];
                        for (int i = 0; i < k; i++)
                        {
                            buffer1[i] = Buffer[i];
                        }
                        SignBytes = SignRsa.SignData(buffer1, "SHA1");
                        objwrite.BaseStream.Write(SignBytes, 0, SignBytes.Length);
                    }
                }
                else
                {
                    Closed = false;
                    objread.Close();
                    objwrite.Close();
                }
            }


        }

 

7、用DESCryptoServiceProvider 进行对称加密 
 

byte[] messagebytes = Encoding.UTF8.GetBytes("LUO罗"); 
            //需要用的对称密钥 
            DESCryptoServiceProvider Des = new DESCryptoServiceProvider(); 
            byte[] key = Des.Key; 
            //加密 
            DESCryptoServiceProvider tdesProvider = new DESCryptoServiceProvider(); 
            tdesProvider.Key = key; 
            tdesProvider.Mode = CipherMode.ECB; 
            byte[] encrypted = tdesProvider.CreateEncryptor().TransformFinalBlock(messagebytes, 0, messagebytes.Length); 
            //解密 
            DESCryptoServiceProvider tdesProvider2 = new DESCryptoServiceProvider(); 
            tdesProvider.Key = key1; 
            tdesProvider.Mode = CipherMode.ECB; 
            byte[] outputdata = tdesProvider.CreateDecryptor().TransformFinalBlock(encrypted, 0, encrypted.Length); 
            string reslut = Encoding.UTF8.GetString(outputdata);
//7用DESCryptoServiceProvider 加解密 流
CryptoStream csDecrypt = new CryptoStream(Stream, Des.CreateEncryptor(), CryptoStreamMode.Write);
          CryptoStream csDecrypt = new CryptoStream(Stream, Des.CreateDecryptor(), CryptoStreamMode.Write);