c# aes，des，md5加密等解密算法

一：可逆加密，即是能加密也能解密

1. 对称可逆加密：加密后能解密回原文，加密key和解密key是一个
2. 加密算法都是公开的，密钥是保密的， 即使拿到密文 你是推算不了密钥 也推算不了原文
3. 加密解密的速度快，问题是密钥的安全

1：DES加密解密

/// <summary>
/// DES AES Blowfish
///  对称加密算法的优点是速度快，
///  缺点是密钥管理不方便，要求共享密钥。
/// 可逆对称加密  密钥长度8
/// </summary>
public class DesEncrypt
    {
        private static byte[] _rgbKey = ASCIIEncoding.ASCII.GetBytes("12345678");
        private static byte[] _rgbIV = ASCIIEncoding.ASCII.GetBytes("AES00000");
        /// <summary>
        /// DES 加密
        /// </summary>
        /// <param name="text">需要加密的值</param>
        /// <returns>加密后的结果</returns>
        public static string Encrypt(string text)
        {
            DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
            using (MemoryStream memStream = new MemoryStream())
            {
                CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateEncryptor(_rgbKey, _rgbIV), CryptoStreamMode.Write);
                StreamWriter sWriter = new StreamWriter(crypStream);
                sWriter.Write(text);
                sWriter.Flush();
                crypStream.FlushFinalBlock();
                memStream.Flush();
                return Convert.ToBase64String(memStream.GetBuffer(), 0, (int)memStream.Length);
            }
        }

        /// <summary>
        /// DES解密
        /// </summary>
        /// <param name="encryptText"></param>
        /// <returns>解密后的结果</returns>
        public static string Decrypt(string encryptText)
        {
            DESCryptoServiceProvider dsp = new DESCryptoServiceProvider();
            byte[] buffer = Convert.FromBase64String(encryptText);

            using (MemoryStream memStream = new MemoryStream())
            {
                CryptoStream crypStream = new CryptoStream(memStream, dsp.CreateDecryptor(_rgbKey, _rgbIV), CryptoStreamMode.Write);
                crypStream.Write(buffer, 0, buffer.Length);
                crypStream.FlushFinalBlock();
                return ASCIIEncoding.UTF8.GetString(memStream.ToArray());
            }
        }
    }

 2：AES加密解密

c#代码：

public class AesEncrypts
    {
        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="str"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string AesEncrypt(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);
            byte[] ivs = new byte[16];
            RijndaelManaged rm = new RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode = CipherMode.CBC, //位置偏移，如果是ECB则不需要ivs
                Padding = PaddingMode.PKCS7,
                IV=ivs
            };

            ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }

        /// <summary>
        ///  AES 解密
        /// </summary>
        /// <param name="str"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string AesDecrypt(string str, string key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Convert.FromBase64String(str);
            byte[] ivs = new byte[16];
            RijndaelManaged rm = new RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                Mode =CipherMode.CBC,
                Padding =PaddingMode.PKCS7,
                IV=ivs
            };

            ICryptoTransform cTransform = rm.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Encoding.UTF8.GetString(resultArray);
        }
    }

java代码：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.lvmama.intlflight.api.common.util;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class AESUtil {
    public AESUtil() {
    }

    public static String encrypt(String sSrc, String sKey) throws Exception {
        if(sKey == null) {
            System.out.print("Key为空null");
            return null;
        } else if(sKey.length() != 16) {
            System.out.print("Key长度不是16位");
            return null;
        } else {
            byte[] raw = sKey.getBytes();
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            byte[] ivs = new byte[16];
            IvParameterSpec iv = new IvParameterSpec(ivs);
            cipher.init(1, skeySpec, iv);
            byte[] encrypted = cipher.doFinal(sSrc.getBytes());
            return (new BASE64Encoder()).encode(encrypted);
        }
    }

    public static String decrypt(String sSrc, String sKey) throws Exception {
        try {
            if(sKey == null) {
                System.out.print("Key为空null");
                return null;
            } else if(sKey.length() != 16) {
                System.out.print("Key长度不是16位");
                return null;
            } else {
                byte[] raw = sKey.getBytes("ASCII");
                SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
                Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
                byte[] ivs = new byte[16];
                IvParameterSpec iv = new IvParameterSpec(ivs);
                cipher.init(2, skeySpec, iv);
                byte[] encrypted1 = (new BASE64Decoder()).decodeBuffer(sSrc);

                try {
                    byte[] original = cipher.doFinal(encrypted1);
                    String originalString = new String(original);
                    return originalString;
                } catch (Exception var10) {
                    System.out.println(var10.toString());
                    return null;
                }
            }
        } catch (Exception var11) {
            System.out.println(var11.toString());
            return null;
        }
    }

    public static void main(String[] args) throws Exception {
        String cKey = "1234567890123456";
        String cSrc = "abcdefghigklmnopqrstuvwxyz0123456789";
        System.out.println(cSrc);
        long lStart = System.currentTimeMillis();
        String enString = encrypt(cSrc, cKey);
        System.out.println("加密后的字串是：" + enString);
        long lUseTime = System.currentTimeMillis() - lStart;
        System.out.println("加密耗时：" + lUseTime + "毫秒");
        lStart = System.currentTimeMillis();
        String DeString = decrypt(enString, cKey);
        System.out.println("解密后的字串是：" + DeString);
        lUseTime = System.currentTimeMillis() - lStart;
        System.out.println("解密耗时：" + lUseTime + "毫秒");
    }
}

二：不可逆加密，即是没有办法解密，其特点为如下几个：

•  相同原文加密的结果是一样的
•  不同长度的内容加密后加过都是32位
•  原文差别很小，结果差别很大
• 不管文件多大，都能产生32位长度摘要

1：MD5加密代码：

 #region MD5
 /// <summary>
 /// MD5加密,和动网上的16/32位MD5加密结果相同,
 /// 使用的UTF8编码
 /// </summary>
 /// <param name="source">待加密字串</param>
 /// <param name="length">16或32值之一,其它则采用.net默认MD5加密算法</param>
 /// <returns>加密后的字串</returns>
 public static string Encrypt(string source, int length = 32)//默认参数
        {
            if (string.IsNullOrEmpty(source)) return string.Empty;
            HashAlgorithm provider = CryptoConfig.CreateFromName("MD5") as HashAlgorithm;
            byte[] bytes = Encoding.UTF8.GetBytes(source);//这里需要区别编码的
            byte[] hashValue = provider.ComputeHash(bytes);
            StringBuilder sb = new StringBuilder();
            switch (length)
            {
                case 16://16位密文是32位密文的9到24位字符
                    for (int i = 4; i < 12; i++)
                    {
                        sb.Append(hashValue[i].ToString("x2"));
                    }
                    break;
                case 32:
                    for (int i = 0; i < 16; i++)
                    {
                        sb.Append(hashValue[i].ToString("x2"));
                    }
                    break;
                default:
                    for (int i = 0; i < hashValue.Length; i++)
                    {
                        sb.Append(hashValue[i].ToString("x2"));
                    }
                    break;
            }
            return sb.ToString();
        }
 #endregion MD5

2：MD5的用途

A：防篡改：
//发个文档，事先给别人一个MD5，是文档的摘要，
//源代码管理器svn--即使电脑断网了，文件有任何改动都能被发现--本地存了一个文件的MD5--文件有更新，就再对比下MD5
//急速秒传--扫描文件的MD5--跟已有的文件MD5比对--吻合表示文件已存在不用再上传

B： 密码保存，防止看到明文
//密码应该只有用户知道----数据库不能存明文---但是又需要验证
//MD5加密下原始密码---数据库存密文---下次登录把密码MD5后再比对
//密文是可见的，所以要求密码不能太简单，加盐(123456+wss)

C 防止抵赖，数字签名
//把一些内容摘要一下，由权威的第三方去保障，将来这个文件就是你做的，不能抵赖

 #region MD5摘要
 /// <summary>
 /// 获取文件的MD5摘要
 /// </summary>
 /// <param name="fileName"></param>
 /// <returns></returns>
 public static string AbstractFile(string fileName)
        {
            using (FileStream file = new FileStream(fileName, FileMode.Open))
            {
                return AbstractFile(file);
            }
        }
 /// <summary>
 /// 根据stream获取文件摘要
 /// </summary>
 /// <param name="stream"></param>
 /// <returns></returns>
 public static string AbstractFile(Stream stream)
        {
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] retVal = md5.ComputeHash(stream);

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < retVal.Length; i++)
            {
                sb.Append(retVal[i].ToString("x2"));
            }
            return sb.ToString();
        }
 #endregion