DES,RC2,Rijndael, TripleDes,RSA, MD5, SHA1通用的安全密码类

using System;
using System.IO;
using System.Text;
using System.Security.Cryptography;
using System.Web.Security;

//工程需要引用system.web.dll

/**//*
 * 通用的安全密码类
 *
 * 本类库支持DES,RC2,Rijndael, TripleDes,RSA, MD5, SHA1等六种加密格式
 *
 * 注意：MD5, SHA1加密是不可逆的，所以不支持他们的解密；
 *
 * 支持生成Key/公钥,Iv/私钥及简单的随机字符；
 *
 * SmartJavaer
 *
 * SmartJavaer@163.com
 *
 * 2006/10/26
 *
 */

namespace ManagePassword
{
 //枚举加密格式
 #region 枚举加密格式
   
 /**//// <summary>
 /// 枚举加密的格式
 ///
 /// 对称加密：DES，RC2，RIJNDAEL，TripleDes
 /// 非对称加密：DSA,RSA
 /// 哈西加密：MD5,SHA1
 ///
 /// </summary>
 public enum CryptogramFormat { Des = 1, Rc2, Rijndael, TripleDes,RSA,MD5, SHA1 }
   
 #endregion

 //通用密码类
 #region 通用密码类
   
 /**//// <summary>
 /// 一个通用的加密类
 /// 支持DES,RC2,Rijndael, TripleDes,RSA, MD5, SHA1等六种加密格式
 /// 注意：MD5, SHA1加密是不可逆的，所以不支持他们的解密；
 /// 支持生成Key/公钥,Iv/私钥及简单的随机字符；
 /// </summary>
 public class Cryptogram
 {
  private Cryptogram() { }

  //加密，解密内部处理
      #region 加密，解密内部处理
      /**//// <summary>
      /// 生成Des,Rc2,Rijndael,TripleDes的处理对象
      /// </summary>
      /// <param name="encryptionFormat">加密格式</param>
      /// <param name="key">Key</param>
      /// <param name="iv">IV</param>
      /// <returns>返回处理对象，若返回null，则表示生成失败；</returns>
      private static SymmetricAlgorithm GetCSP(CryptogramFormat encryptionFormat,string key,string iv)
      {
       SymmetricAlgorithm mCSP;
           
       switch (encryptionFormat)
       {
        case CryptogramFormat.Des:
        {
         mCSP = new DESCryptoServiceProvider();
         break;
        }
        case CryptogramFormat.TripleDes:
        {
         mCSP = new TripleDESCryptoServiceProvider();
         break;
        }
        case CryptogramFormat.Rc2:
        {
         mCSP = new RC2CryptoServiceProvider();
         break;
        }
        case CryptogramFormat.Rijndael:
        {
         mCSP = new RijndaelManaged();
         break;
        }
        default:
         mCSP = null;
         break;
       }

       if (mCSP == null)
        return null;

       if(key.Length==0)
        // if(String.IsNullOrEmpty(key))
       {
        //mCSP.GenerateKey();
        return null;
       }
       else
       {
        try
        {
         mCSP.Key = Convert.FromBase64String(key);
        }
        catch
        {
         //mCSP.GenerateKey();
         return null;
        }
       }

       if (iv.Length==0)
        //if (String.IsNullOrEmpty(iv))
       {
        //mCSP.GenerateIV();
        return null;
       }
       else
       {
        try
        {
         mCSP.IV = Convert.FromBase64String(iv);
        }
        catch
        {
         //mCSP.GenerateIV();
         return null;
        }
       }
       return mCSP;
      }

  /**//// <summary>
  /// Des,Rc2,Rijndael,TripleDes加密
  /// </summary>
  /// <param name="encryptionFormat">加密格式</param>
  /// <param name="srcString">欲加密的字符串</param>
  /// <param name="key">Key</param>
  /// <param name="iv">IV</param>
  /// <returns>返回加密后的字符串，若返回null，则表示加密失败；</returns>
  private static string CSPEncode(CryptogramFormat encryptionFormat, string srcString, string key, string iv)
  {
   SymmetricAlgorithm mCSP;
   ICryptoTransform ct;
   MemoryStream ms;
   CryptoStream cs;
   byte[] byt;

   mCSP = GetCSP(encryptionFormat, key, iv);
   if (mCSP == null)
    return null;
   try
   {
    ct = mCSP.CreateEncryptor(mCSP.Key, mCSP.IV);

    byt = Convert.FromBase64String(srcString);
    ms = new MemoryStream();
    cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
    cs.Write(byt, 0, byt.Length);
    cs.FlushFinalBlock();

    cs.Close();
    return Convert.ToBase64String(ms.ToArray());
   }
   catch
   {
    return null;
   }
  }

  /**//// <summary>
  /// Des,Rc2,Rijndael,TripleDes解密
  /// </summary>
  /// <param name="encryptionFormat"></param>
  /// <param name="srcString"></param>
  /// <param name="key"></param>
  /// <param name="iv"></param>
  /// <returns></returns>
  private static string CSPDecode(CryptogramFormat encryptionFormat, string srcString, string key, string iv)
  {
   SymmetricAlgorithm mCSP;
   ICryptoTransform ct;
   MemoryStream ms;
   CryptoStream cs;
   byte[] byt;
   mCSP = GetCSP(encryptionFormat, key, iv);
   if (mCSP == null)
    return null;
   try
   {
    ct = mCSP.CreateDecryptor(mCSP.Key, mCSP.IV);
    byt = Convert.FromBase64String(srcString);

    ms = new MemoryStream();
    cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
    cs.Write(byt, 0, byt.Length);
    cs.FlushFinalBlock();
    cs.Close();

    return Convert.ToBase64String(ms.ToArray());
   }
   catch
   {
    return null;
   }
  }
 
  /**//// <summary>
  /// RSA加密
  /// </summary>
  /// <param name="encryptionFormat"></param>
  /// <param name="srcString"></param>
  /// <param name="key"></param>
  /// <param name="iv"></param>
  /// <returns></returns>
  private static string RSAEncode(CryptogramFormat encryptionFormat, string srcString, string key, string iv)
  {
   RSACryptoServiceProvider rsa1 = new RSACryptoServiceProvider();
   byte[] toEncryptData = null;
   byte[] encryptedData = null;

   try
   {
    rsa1.FromXmlString(key);
   }
   catch
   {
    return null;
   }

   try
   {
    rsa1.FromXmlString(iv);
   }
   catch
   {
    return null;
   }

   toEncryptData = Convert.FromBase64String(srcString);
   encryptedData = rsa1.Encrypt(toEncryptData, false);//加密后的数据
   return Convert.ToBase64String(encryptedData);
  }

  /**//// <summary>
  /// RSA解密
  /// </summary>
  /// <param name="encryptionFormat"></param>
  /// <param name="srcString"></param>
  /// <param name="key"></param>
  /// <param name="iv"></param>
  /// <returns></returns>
  private static string RSADecode(CryptogramFormat encryptionFormat, string srcString, string key, string iv)
  {
   RSACryptoServiceProvider rsaD = new RSACryptoServiceProvider();
   byte[] encryptedData = null ;
   byte[] decryptedData = null ;

   try
   {
    rsaD.FromXmlString(key);
   }
   catch
   {
    return null;
   }

   try
   {
    rsaD.FromXmlString(iv);
   }
   catch
   {
    return null;
   }

   encryptedData = Convert.FromBase64String(srcString);
   decryptedData = rsaD.Decrypt(encryptedData, false);//解密后的数据
   return Convert.ToBase64String(decryptedData);
  }

  /**//// <summary>
  /// 生成对称加密格式的Key和IV
  /// </summary>
  /// <param name="encryptionFormat">加密格式</param>
  /// <param name="key"></param>
  /// <param name="iv"></param>
  private static void KeyAndIV(CryptogramFormat encryptionFormat, ref string key, ref string iv)
  {
   SymmetricAlgorithm mCSP;

   switch (encryptionFormat)
   {
    case CryptogramFormat.Des:
    {
     mCSP = new DESCryptoServiceProvider();
     break;
    }
    case CryptogramFormat.TripleDes:
    {
     mCSP = new TripleDESCryptoServiceProvider();
     break;
    }
    case CryptogramFormat.Rc2:
    {
     mCSP = new RC2CryptoServiceProvider();
     break;
    }
    case CryptogramFormat.Rijndael:
    {
     mCSP = new RijndaelManaged();
     break;
    }
    default:
     mCSP = null;
     break;
   }

   mCSP.GenerateKey();
   mCSP.GenerateIV();
   key = Convert.ToBase64String(mCSP.Key);
   iv = Convert.ToBase64String(mCSP.IV);
  }

  #endregion

  //公共加密解密方法

   #region 公共加密解密方法

   /**//// <summary>
   /// 加密方法
   /// </summary>
   /// <param name="encryptionFormat">加密格式</param>
   /// <param name="srcString">欲加密字符串</param>
   /// <returns>返回加密后的字符串；若返回null，表示失败</returns>
   public static string Encrypt(CryptogramFormat encryptionFormat, string srcString)
   {
    try
    {
     switch (encryptionFormat)
     {
      case CryptogramFormat.MD5:
       return FormsAuthentication.HashPasswordForStoringInConfigFile(srcString, "MD5");

      case CryptogramFormat.SHA1:
       return FormsAuthentication.HashPasswordForStoringInConfigFile(srcString, "SHA1");

      case CryptogramFormat.Des:
      case CryptogramFormat.Rc2:
      case CryptogramFormat.Rijndael:
      case CryptogramFormat.TripleDes:
      case CryptogramFormat.RSA:
       return "缺少参数";
      default:
      {
       return "不支持该格式的加密";
      }
     }
    }
    catch (Exception e)
    {
     return "加密异常：" + e.Message;
    }
   }

  /**//// <summary>
  /// 加密方法
  /// </summary>
  /// <param name="encryptionFormat">加密格式</param>
  /// <param name="srcString">欲加密字符串</param>
  /// <param name="key">指定加密的Key</param>
  /// <param name="iv">指定加密的IV</param>
  /// <returns>返回加密后的字符串；若返回null，表示失败</returns>
  public static string Encrypt(CryptogramFormat encryptionFormat, string srcString,string key,string iv)
  {
   try
   {
    switch (encryptionFormat)
    {
     case CryptogramFormat.MD5:
      return FormsAuthentication.HashPasswordForStoringInConfigFile(srcString, "MD5");

     case CryptogramFormat.SHA1:
      return FormsAuthentication.HashPasswordForStoringInConfigFile(srcString, "SHA1");

     case CryptogramFormat.Des:
     case CryptogramFormat.Rc2:
     case CryptogramFormat.Rijndael:
     case CryptogramFormat.TripleDes:
      return CSPEncode(encryptionFormat, srcString, key, iv);

      //case CryptogramFormat.DSA:
      //    return DSAEncode(encryptionFormat, srcString, key, iv);

     case CryptogramFormat.RSA:
      return RSAEncode(encryptionFormat, srcString, key, iv);
     default:
     {
      return null;
     }
    }
   }
   catch (Exception e)
   {
    return "加密异常：" + e.Message;
   }
  }

  /**//// <summary>
  /// 解密方法
  /// </summary>
  /// <param name="encryptionFormat">加密格式</param>
  /// <param name="srcString">欲解密字符串</param>
  /// <param name="key">指定解密的Key</param>
  /// <param name="iv">指定解密的IV</param>
  /// <returns>返回解密后的字符串；若返回null，表示失败</returns>
  public static string Decrypt(CryptogramFormat encryptionFormat, string srcString, string key, string iv)
  {
   try
   {
    switch (encryptionFormat)
    {
     case CryptogramFormat.Des:
     case CryptogramFormat.Rc2:
     case CryptogramFormat.Rijndael:
     case CryptogramFormat.TripleDes:
      return CSPDecode(encryptionFormat, srcString, key, iv);
     case CryptogramFormat.RSA:
      return RSADecode(encryptionFormat, srcString, key, iv);
     default:
     {
      return "不支持该种解密";
     }
    }
   }
   catch(Exception e)
   {
    return "解密异常："+e.Message;
   }
  }

  /**//// <summary>
  /// 生成Key和IV
  /// </summary>
  /// <param name="encryptionFormat">加密格式</param>
  /// <param name="key">Key</param>
  /// <param name="iv">Iv</param>
  /// <returns>返回是否成功生成Key和IV</returns>
  public static bool GenerateKeyAndIV(CryptogramFormat encryptionFormat, ref string key, ref string iv)
  {
   try
   {
    switch (encryptionFormat)
    {
     case CryptogramFormat.MD5:
     case CryptogramFormat.SHA1:
      key = "不支持";
      iv = "不支持";
      break;
     case CryptogramFormat.Des:
     case CryptogramFormat.Rc2:
     case CryptogramFormat.Rijndael:
     case CryptogramFormat.TripleDes:
      KeyAndIV(encryptionFormat,ref key,ref iv);
      break;
     case CryptogramFormat.RSA:
      RSACryptoServiceProvider rsaD = new RSACryptoServiceProvider();
      key = rsaD.ToXmlString(false);
      iv = rsaD.ToXmlString(true);
      break;
     default:
     {
      return false;
     }
    }
   }
   catch
   {
    return false;
   }
   return true;
  }
       
  #endregion

  //生成随机密码
   #region 生成随机密码
   /**//// <summary>
   /// 生成随机密码
   /// </summary>
   /// <returns></returns>
   public static string GenerateString()
   {
    return GenerateString(8);
   }

  /**//// <summary>
  /// 生成随机密码
  /// </summary>
  /// <param name="keylength"></param>
  /// <returns></returns>
  public static string GenerateString(int keylength)
  {
   try
   {
    if (keylength <= 1)
     return "SmartJavaer";

    byte[] buff = new Byte[keylength/2];
    RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
    rng.GetBytes(buff);
    //return Convert.ToBase64String(buff);
    StringBuilder sb = new StringBuilder(keylength);
    int i;
    for (i = 0; i < buff.Length; i++)
    {
     sb.Append(String.Format("{0:X2}", buff[i]));
    }
    return sb.ToString();
   }
   catch
   {
    return "SmartJavaer";
   }
  }
  #endregion

 }
  
 #endregion

}