• 转:system.Security.Cryptography C# 加密和解密


    以下文转自:

    http://www.360doc.com/content/13/0122/05/19147_261678471.shtml

    总结:注册的时候经过MD5加密存进数据库,在登录的时候需要先加密输入的密码,再进行和数据库里的比对,因为同一字符串加密后是一样的,并不是无规则的:实例:

    string name = this.TextBox1.Text;
            string pwd = System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(this.TextBox2.Text, "MD5");

            Response.Write(name+"<br>"+pwd);

    ------------------------------------------------分界线--------------------------------------------------

     

    .NET将原来独立的API和SDK合并到一个框架中,这对于程序开发人员非常有利。它将CryptoAPI改编进.NET的System.Security.Cryptography名字空间,使密码服务摆脱了SDK平台

    的神秘性,变成了简单的.NET名字空间的使用。

      加密和解密的算法

      System.Security.Cryptography名字空间包含了实现安全方案的类,例如加密和解密数据、管理密钥、验证数据的完整性并确保数据没有被篡改等等

      加密和解密的算法分为对称(symmetric)算法和不对称(asymmetric)算法。对称算法在加密和解密数据时使用相同的密钥和初始化矢量,通过私钥对数据块进行加密,只有

    与之对应发布的公钥才能解密。从而确保了发布消息的正确身份。典型的有DES、 TripleDES和Rijndael算法,它适用于不需要传递密钥的情况,主要用于本地文档或数据的加密。
        不对称算法有两个不同的密钥,分别是公共密钥和私有密钥,公共密钥在网络中传递,用于加密数据,而私有密钥用于解密数据。不对称算法主要有RSA、DSA等,主要用于网

    络数据的加密。

    --------------------------------------------------------------------------
    部分名词
    密钥 Secret key
    对称加密算法 symmetric cryptography
    非对称加密算法 asymmetric cryptography
    数字签名 digital signature
    证书 certificate
    认证授权 certificate
    摘要 digest

    ---------------------------------------------------------------------------
    .NET的提供的加密功能类
       对称加密类
       System.Security.Cryptography.SymmetricAlgorithm
          System.Security.Cryptography.DES
          System.Security.Cryptography.RC2
          System.Security.Cryptography.Rijndael
          System.Security.Cryptography.TripleDES
       非对称加密类 
       System.Security.Cryptography.AsymmetricAlgorithm
          System.Security.Cryptography.DSA
          System.Security.Cryptography.RSA
    ---------------------------------------------------------------------------
    具体使用方法

    加密和解密本地文档 使用的是Rijndael对称算法

        对称算法在数据流通过时对它进行加密。因此首先需要建立一个正常的流(例如I/O流)。文章使用FileStream类将文本文件读入字节数组,也使用该类作为输出机制。

      接下来定义相应的对象变量。在定义SymmetricAlgorithm抽象类的对象变量时我们可以指定任何一种对称加密算法提供程序。代码使用的是Rijndael算法,但是很容易改为DES

        
        或者TripleDES算法。.NET使用强大的随机密钥设置了提供程序的实例,选择自己的密钥是比较危险的,接受计算机产生的密钥是一个更好的选择,文中的代码使用的是计算机

        
        产生的密钥。算法实例提供了一个对象来执行实际数据传输。每种算法都有CreateEncryptor和CreateDecryptor两个方法,它们返回实现ICryptoTransform接口的对象。

      最后,现在使用BinaryReader的ReadBytes方法读取源文件,它会返回一个字节数组。BinaryReader读取源文件的输入流,在作为CryptoStream.Write方法的参数时调用    
        
        ReadBytes方法。指定的CryptoStream实例被告知它应该操作的下层流,该对象将执行数据传递,无论流的目的是读或者写
            string file = args[0];
    string tempfile = Path.GetTempFileName();
    //打开指定的文件
    FileStream fsIn = File.Open(file,FileMode.Open,FileAccess.Read);
    FileStream fsOut = File.Open(tempfile, FileMode.Open,FileAccess.Write);
       
    //定义对称算法对象实例和接口 SymmetricAlgorithm所有的对称算法类都是从这个基类继承而来的
           SymmetricAlgorithm symm = new RijndaelManaged();
           ICryptoTransform transform = symm.CreateEncryptor();
           System.Security.Cryptography.CryptoStream cstream = new CryptoStrea(fsOut,transform,System.Security.Cryptography.CryptoStreamMode.Write);

            BinaryReader br = new BinaryReader(fsIn);
    // 读取源文件到cryptostream 
    cstream.Write(br.ReadBytes((int)fsIn.Length),0,(int)fsIn.Length);
    cstream.FlushFinalBlock();
    cstream.Close();
    fsIn.Close();
    fsOut.Close();

    Console.WriteLine("created encrypted file {0}", tempfile);
    Console.WriteLine("will now decrypt and show contents");

    // 反向操作--解密刚才加密的临时文件
    afsIn = File.Open(tempfile,FileMode.Open,FileAccess.Read);
    transform = symm.CreateDecryptor();
    cstream = new CryptoStream(fsIn,transform,CryptoStreamMode.Read);

    StreamReader sr = new StreamReader(cstream);
    Console.WriteLine("decrypted file text: " + sr.ReadToEnd());
    fsIn.Close();

    加密网络数据

      如果我有一个只想自己看到的文档,我不会简单的通过e-mail发送给你。我将使用对称算法加密它;如果有人截取了它,他们也不能阅读该文档,因为他们没有用于加密的唯

    一密钥。但是你也没有密钥。我需要使用某种方式将密钥给你,这样你才能解密文档,但是不能冒密钥和文档被截取的风险。

      非对称算法就是一种解决方案。这类算法使用的两个密钥有如下关系:使用公共密钥加密的信息只能被相应的私有密钥解密。因此,我首要求你给我发送你的公共密钥。在发

    送给我的途中可能有人会截取它,但是没有关系,因为他们只能使用该密钥给你的信息加密。我使用你的公共密钥加密文档并发送给你。你使用私有密钥解密该文档,这是唯一可

    以解密的密钥,并且没有通过网络传递。

      不对称算法比对称算法计算的花费多、速度慢。因此我们不希望在线对话中使用不对称算法加密所有信息。相反,我们使用对称算法。下面的例子中我们使用不对称加密来加

    密对称密钥。接着就使用对称算法加密了。实际上安全接口层(SSL)建立服务器和浏览器之间的安全对话使用的就是这种工作方式。
    示例是一个TCP程序,分为服务器端和客户端。
        
         服务器端的工作流程是:

       从客户端接收公共密钥。

       使用公共密钥加密未来使用的对称密钥。

       将加密了的对称密钥发送给客户端。

       给客户端发送使用该对称密钥加密的信息。

      代码如下:


    namespace com.billdawson.crypto
    {
    public class CryptoServer
    {
    private const int RSA_KEY_SIZE_BITS = 1024;
    private const int RSA_KEY_SIZE_BYTES = 252;
    private const int TDES_KEY_SIZE_BITS = 192;

    public static void Main(string[] args)
    {
    int port;
    string msg;
    TcpListener listener;
    TcpClient client;
    SymmetricAlgorithm symm;
    RSACryptoServiceProvider rsa;
    //获取端口
    try
    {
    port = Int32.Parse(args[0]);
    msg = args[1];
    }
    catch
    {
    Console.WriteLine(USAGE);
    return;
    }
    //建立监听
    try
    {
    listener = new TcpListener(port);
    listener.Start();
    Console.WriteLine("Listening on port {0}...",port);

    client = listener.AcceptTcpClient();
    Console.WriteLine("connection....");
    }
    catch (Exception e)
    {
    Console.WriteLine(e.Message);
    Console.WriteLine(e.StackTrace);
    return;
    }

    try

    rsa = new RSACryptoServiceProvider();
    rsa.KeySize = RSA_KEY_SIZE_BITS;

    // 获取客户端公共密钥
    rsa.ImportParameters(getClientPublicKey(client));

    symm = new TripleDESCryptoServiceProvider();
    symm.KeySize = TDES_KEY_SIZE_BITS;

    //使用客户端的公共密钥加密对称密钥并发送给客。
    encryptAndSendSymmetricKey(client, rsa, symm);

    //使用对称密钥加密信息并发送
    encryptAndSendSecretMessage(client, symm, msg);
    }
    catch (Exception e)
    {
    Console.WriteLine(e.Message);
    Console.WriteLine(e.StackTrace);
    }
    finally
    {
    try
    {
    client.Close();
    listener.Stop();
    }
    catch
    {
    //错误
    }
    Console.WriteLine("Server exiting...");
    }
    }

    private static RSAParameters getClientPublicKey(TcpClient client)
    {
    // 从字节流获取串行化的公共密钥,通过串并转换写入类的实例
    byte[] buffer = new byte[RSA_KEY_SIZE_BYTES];
    NetworkStream ns = client.GetStream();
    MemoryStream ms = new MemoryStream();
    BinaryFormatter bf = new BinaryFormatter();
    RSAParameters result;

    int len = 0;
    int totalLen = 0;

    while(totalLen (len = ns.Read(buffer,0,buffer.Length))>0)
    {
    totalLen+=len;
    ms.Write(buffer, 0, len);
    }

    ms.Position=0;

    result = (RSAParameters)bf.Deserialize(ms);
    ms.Close();

    return result;

    }

    private static void encryptAndSendSymmetricKey(
    TcpClient client,
    RSACryptoServiceProvider rsa,
    SymmetricAlgorithm symm)
    {
    // 使用客户端的公共密钥加密对称密钥
    byte[] symKeyEncrypted;
    byte[] symIVEncrypted;

    NetworkStream ns = client.GetStream();

    symKeyEncrypted = rsa.Encrypt(symm.Key, false);
    symIVEncrypted = rsa.Encrypt(symm.IV, false);

    ns.Write(symKeyEncrypted, 0, symKeyEncrypted.Length);
    ns.Write(symIVEncrypted, 0, symIVEncrypted.Length);

    }

    private static void encryptAndSendSecretMessage(TcpClient client,
    SymmetricAlgorithm symm,
    string secretMsg)
    {
    // 使用对称密钥和初始化矢量加密信息并发送给客户端
    byte[] msgAsBytes;
    NetworkStream ns = client.GetStream();
    ICryptoTransform transform =
    symm.CreateEncryptor(symm.Key,symm.IV);
    CryptoStream cstream =new CryptoStream(ns, transform, CryptoStreamMode.Write);

    msgAsBytes = Encoding.ASCII.GetBytes(secretMsg);

    cstream.Write(msgAsBytes, 0, msgAsBytes.Length);
    cstream.FlushFinalBlock(); 

    }

    客户端的工作流程是:

       建立和发送公共密钥给服务器。

       从服务器接收被加密的对称密钥。

       解密该对称密钥并将它作为私有的不对称密钥。

       接收并使用不对称密钥解密信息。

      代码如下:


    namespace com.billdawson.crypto
    {
    public class CryptoClient 
    {
    private const int RSA_KEY_SIZE_BITS = 1024;
    private const int RSA_KEY_SIZE_BYTES = 252;
    private const int TDES_KEY_SIZE_BITS = 192;
    private const int TDES_KEY_SIZE_BYTES = 128;
    private const int TDES_IV_SIZE_BYTES = 128;
    public static void Main(string[] args)
    {
    int port;
    string host;
    TcpClient client;
    SymmetricAlgorithm symm;
    RSACryptoServiceProvider rsa;

    if (args.Length!=2)
    {
    Console.WriteLine(USAGE);
    return;
    }

    try
    {
    host = args[0];
    port = Int32.Parse(args[1]); 
    }
    catch
    {
    Console.WriteLine(USAGE);
    return;
    }

    try //连接
    {
    client = new TcpClient();
    client.Connect(host,port);
    }
    catch(Exception e)
    {
    Console.WriteLine(e.Message);
    Console.Write(e.StackTrace);
    return;
    }

    try
    {
    Console.WriteLine("Connected. Sending public key.");
    rsa = new RSACryptoServiceProvider();
    rsa.KeySize = RSA_KEY_SIZE_BITS;
    sendPublicKey(rsa.ExportParameters(false),client);
    symm = new TripleDESCryptoServiceProvider();
    symm.KeySize = TDES_KEY_SIZE_BITS;

    MemoryStream ms = getRestOfMessage(client);
    extractSymmetricKeyInfo(rsa, symm, ms);
    showSecretMessage(symm, ms);
    }
    catch(Exception e)
    {
    Console.WriteLine(e.Message);
    Console.Write(e.StackTrace);
    }
    finally
    {
    try
    {
    client.Close();
    }
    catch { //错误
    }
    }
    }

    private static void sendPublicKey(
    RSAParameters key,
    TcpClient client)
    {
    NetworkStream ns = client.GetStream();
    BinaryFormatter bf = new BinaryFormatter();
    bf.Serialize(ns,key);
    }

    private static MemoryStream getRestOfMessage(TcpClient client)
    {
    //获取加密的对称密钥、初始化矢量、秘密信息。对称密钥用公共RSA密钥
    //加密,秘密信息用对称密钥加密
    MemoryStream ms = new MemoryStream(); 
    NetworkStream ns = client.GetStream();
    byte[] buffer = new byte[1024];

    int len=0;

    // 将NetStream 的数据写入内存流
    while((len = ns.Read(buffer, 0, buffer.Length))>0)
    {
    ms.Write(buffer, 0, len);
    }
    ms.Position = 0;
    return ms;
    }

    private static void extractSymmetricKeyInfo(
    RSACryptoServiceProvider rsa,
    SymmetricAlgorithm symm,
    MemoryStream msOrig) 
    {
    MemoryStream ms = new MemoryStream();

    // 获取TDES密钥--它被公共RSA密钥加密,使用私有密钥解密
    byte[] buffer = new byte[TDES_KEY_SIZE_BYTES];
    msOrig.Read(buffer,0,buffer.Length);
    symm.Key = rsa.Decrypt(buffer,false);

    // 获取TDES初始化矢量
    buffer = new byte[TDES_IV_SIZE_BYTES];
    msOrig.Read(buffer, 0, buffer.Length);
    symm.IV = rsa.Decrypt(buffer,false);
    }

    private static void showSecretMessage(
    SymmetricAlgorithm symm,
    MemoryStream msOrig)
    {
    //内存流中的所有数据都被加密了
    byte[] buffer = new byte[1024];
    int len = msOrig.Read(buffer,0,buffer.Length);

    MemoryStream ms = new MemoryStream();
    ICryptoTransform transform =symm.CreateDecryptor(symm.Key,symm.IV);
    CryptoStream cstream =new CryptoStream(ms, transform, 
    CryptoStreamMode.Write);
    cstream.Write(buffer, 0, len);
    cstream.FlushFinalBlock();

    // 内存流现在是解密信息,是字节的形式,将它转换为字符串
    ms.Position = 0;
    len = ms.Read(buffer,0,(int) ms.Length);
    ms.Close();

    string msg = Encoding.ASCII.GetString(buffer,0,len);
    Console.WriteLine("The host sent me this secret message:");
    Console.WriteLine(msg); 


    }

      结论

      使用对称算法加密本地数据时比较适合。在保持代码通用时我们可以选择多种算法,当数据通过特定的CryptoStream时算法使用转换对象加密该数据。需要将数据通过网络发

    送时,首先使用接收的公共不对称密钥加密对称密钥。

      本文只涉及到System.Security.Cryptography名字空间的一部分服务。尽管文章保证只有某个私有密钥可以解密相应公共密钥加密的信息,但是它没有保证是谁发送的公共密

    钥,发送者也可能是假的。需要使用处理数字证书的类来对付该风险。

    ------------------------------------------------------------------------
    DES对称加密算法
    //名称空间 
    using System; 
    using System.Security.Cryptography; 
    using System.IO; 
    using System.Text;

    //方法 
    //加密方法 
    public    string Encrypt(string pToEncrypt, string sKey) 

               DESCryptoServiceProvider des = new DESCryptoServiceProvider(); 
               //把字符串放到byte数组中 
                     //原来使用的UTF8编码,我改成Unicode编码了,不行 
               byte[] inputByteArray = Encoding.Default.GetBytes(pToEncrypt); 
               //byte[] inputByteArray=Encoding.Unicode.GetBytes(pToEncrypt);

               //建立加密对象的密钥和偏移量 
               //原文使用ASCIIEncoding.ASCII方法的GetBytes方法 
               //使得输入密码必须输入英文文本 
               des.Key = ASCIIEncoding.ASCII.GetBytes(sKey); 
               des.IV = ASCIIEncoding.ASCII.GetBytes(sKey); 
               MemoryStream ms = new MemoryStream(); 
               CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(),CryptoStreamMode.Write); 
               //Write the byte array into the crypto stream 
               //(It will end up in the memory stream) 
               cs.Write(inputByteArray, 0, inputByteArray.Length); 
               cs.FlushFinalBlock(); 
               //Get the data back from the memory stream, and into a string 
               StringBuilder ret = new StringBuilder(); 
               foreach(byte b in ms.ToArray()) 
                           { 
                           //Format as hex 
                           ret.AppendFormat("{0:X2}", b); 
                           } 
               ret.ToString(); 
               return ret.ToString(); 
    }

    //解密方法 
    public    string Decrypt(string pToDecrypt, string sKey) 

               DESCryptoServiceProvider des = new DESCryptoServiceProvider();

               //Put the input string into the byte array 
               byte[] inputByteArray = new byte[pToDecrypt.Length / 2]; 
               for(int x = 0; x < pToDecrypt.Length / 2; x++) 
               { 
                         int i = (Convert.ToInt32(pToDecrypt.Substring(x * 2, 2), 16)); 
                   inputByteArray[x] = (byte)i; 
               }

               //建立加密对象的密钥和偏移量,此值重要,不能修改 
               des.Key = ASCIIEncoding.ASCII.GetBytes(sKey); 
               des.IV = ASCIIEncoding.ASCII.GetBytes(sKey); 
               MemoryStream ms = new MemoryStream(); 
               CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(),CryptoStreamMode.Write); 
               //Flush the data through the crypto stream into the memory stream 
               cs.Write(inputByteArray, 0, inputByteArray.Length); 
               cs.FlushFinalBlock();

               //Get the decrypted data back from the memory stream 
               //建立StringBuild对象,CreateDecrypt使用的是流对象,必须把解密后的文本变成流对象 
               StringBuilder ret = new StringBuilder(); 
                 
               return System.Text.Encoding.Default.GetString(ms.ToArray()); 
    }

     

    2.2 范例
    使用非对称算法加密消息的四个主要步骤
    1. 获取发送者的私钥和接收者的公钥。
    2. 借助随机密钥(random key)和初始化向量,用对称算法加密消息。
    3. 用接收者的公钥为2步骤中的密钥和初始化向量加密。
    4. 用发送者的私钥对消息进行数字签名处理。

    对应的解密的四个步骤
    1. 获取发送者的公钥和接收者的私钥。
    2. 验证数字签名。
    3. 解密密钥和初始化向量。
    4. 使用解密后的密钥和初始化向量解密消息。

    代码分析:

    1. 获取密钥
    ...{
    X509CertificateStore x509Store = null;
    if (location == "CurrentUser")
    ...{
    x509Store = X509CertificateStore.CurrentUserStore(X509CertificateStore.MyStore);
    }
    else
    ...{
    x509Store = X509CertificateStore.LocalMachineStore(X509CertificateStore.MyStore);
    }
    bool open = x509Store.OpenRead();
    X509Certificate sender_cert = null;
    X509Certificate receiver_cert = null;

    if (!open)
    ...{
    throw new Exception("unable to open the certificate store");
    }


    sender_cert = x509Store.FindCertificateBySubjectName("CN=XinChen, E=none@none.com")[0 ];
    receiver_cert = x509Store.FindCertificateBySubjectName("CN=Sherry, E=none@none.com")[0 ];

    RSAParameters sender_privateKey = sender_cert.Key.ExportParameters(true);
    RSAParameters receiver_publicKey = receiver_cert.PublicKey.ExportParameters(false);
    }

    2. 对称算法加密 (不指定初始密钥和初始向量,则由系统自动生成)
    ...{
    SymmetricAlgorithm symmProvider = SymmetricAlgorithm.Create("TripleDES");

    encryptor = symmProvider.CreateEncryptor();

    CryptoStream encStream = new CryptoStream(data, encryptor, CryptoStreamMode.Read);
    MemoryStream encrypted = new MemoryStream();
    byte[] buffer = new byte[1024];
    int count = 0;
    while ((count = encStream.Read(buffer,0,1024)) > 0)
    ...{
    encrypted.Write(buffer,0,count);
    }
    }
    3. 用接收者的公钥为2步骤中的密钥和初始化向量加密
    ...{
    byte[] key;
    byte[] iv;
    RSACryptoServiceProvider asymmetricProvider = new RSACryptoServiceProvider();
    asymmetricProvider.ImportParameters(receiver_publicKey);
       
    key = asymmetricProvider.Encrypt(symmProvider.Key,false);
    iv = asymmetricProvider.Encrypt(symmProvider.IV,false);
    }
    4. 创建数字签名
    使用密钥为消息散列进行加密
    ...{
    byte[] signature;
    asymmetricProvider.ImportParameters(sender_privateKey);
    signature = asymmetricProvider.SignData(encrypted.ToArray(), new SHA1CryptoServiceProvider());
    }

    上面四个步骤的最后输出为encrypted、key、iv和signature

    解密的代码演示:
    1. 获取密钥
    ...
    2. 验证数字签名
    ...{
    asymmetricProvider.ImportParameters(sender_publicKey);
    bool verify = asymmetricProvider.VerifyData(encrypted, new SHA1CryptoServiceProvider(), signature)
    }
    3. 解密密钥和初始化向量
    ...{
    asymmetricProvider.ImportParameters(receiver_privateKey);
    byte[] decryptedKey = asymmetricProvider.Decrypt(key, false);
    byte[] decryptediv = asymmetricProvider.Decrypt(iv, false);

    4. 使用解密后的密钥和初始化向量解密消息。
    ...{
    SymmetricAlgorithm symmProvider = SymmetricAlgorithm.Create("TripleDES");
    ICryptoTransform decryptor = symmProvider.CreateDecryptor(decryptedKey, decryptediv);
    CryptoStream decStream = new CryptoStream(encrypted, decryptor, CryptoStreamMode.Read);
    }

    3.Hash散列举例
    ...{
       System.Security.Cryptography.HashAlgorithm
          System.Security.Cryptography.KeyedHashAlgorithm
          System.Security.Cryptography.MD5
          System.Security.Cryptography.SHA1
          System.Security.Cryptography.SHA256
          System.Security.Cryptography.SHA384
          System.Security.Cryptography.SHA512
    }
    public static string Encrypt(string password) 
    ...{
    password = password.ToLower();

    Byte[] clearBytes = new UnicodeEncoding().GetBytes(password);
    Byte[] hashedBytes = ((HashAlgorithm) CryptoConfig.CreateFromName("MD5")).ComputeHash(clearBytes);

    return BitConverter.ToString(hashedBytes);
    }

  • 相关阅读:
    第二阶段冲刺——个人总结05
    购书最低价
    第二阶段冲刺——个人总结04
    第二阶段冲刺——个人总结03
    第二阶段冲刺——个人总结02
    学习进度条——十三周
    第二阶段冲刺——个人总结01
    android模拟器
    unigui导出TMS.Flexcel【5】
    unigui+fastreport 打印【4】
  • 原文地址:https://www.cnblogs.com/KevinMO/p/5766700.html
Copyright © 2020-2023  润新知