base64加密解密详解（及参考代码）

　　一、base64加密解密

　　1. Base64使用A--Z，a--z，0--9，+，/ 这64个字符。

　　2. 编码原理：将3个字节转换成4个字节（ （3 X 8） = 24 = （4 X 6） ）先读入3个字节，每读一个字节，左移8位，再右移四次，每次6位，这样就有4个字节了。

　　3. 解码原理：将4个字节转换成3个字节。先读入4个6位（用或运算），每次左移6位，再右移3次，每次8位。这样就还原了。

　　Base64是一种很常见的编码规范，其作用是将二进制序列转换为人类可读的ASCII字符序列，常用在需用通过文本协议（比如HTTP和SMTP）来传输二进制数据的情况下。Base64并不是一种用于安全领域的加密解密算法（这类算法有DES等），尽管我们有时也听到使用Base64来加密解密的说法，但这里所说的加密与解密实际是指编码（encode）和解码（decode）的过程，其变换是非常简单的，仅仅能够避免信息被直接识别。

　　Base64采用了一种很简单的编码转换：对于待编码数据，以3个字节为单位，依次取6位数据并在前面补上两个0形成新的8位编码，由于3*8=4*6，这样3个字节的输入会变成4个字节的输出，长度上增加了1/3。

　　上面的处理还不能保证得到的字符都是可见字符，为了达到此目的，Base64制定了一个编码表，进行统一的转换。码表的大小为2^6=64，这也是Base64名称的由来。

　　Base64编码表

　　

　　二、编程实现

　　本文给大家汇总介绍了几种C#编写的Base64加密和解密类的代码，从简单到复杂，都能够实现功能，有需要的小伙伴根据自己的项目需求参考下吧。

　　这个C#类是一个基于Base64的加密和解密类，用户可以可以使用默认的秘钥进行加密、解密，也可以自己设定秘钥进行加密和解密，非常实用

　　代码一：非常精简的代码

　　/// 《summary》

　　/// Base64加密，解密方法

　　/// 《/summary》

　　/// 《paramname=“s”》输入字符串《/param》

　　/// 《paramname=“c”》true-加密，false-解密《/param》

　　static public string base64（string s， bool c）

　　{

　　if （c）

　　{

　　returnSystem.Convert.ToBase64String（System.Text.Encoding.Default.GetBytes（s））;

　　}

　　else

　　{

　　try

　　{

　　returnSystem.Text.Encoding.Default.GetString（System.Convert.FromBase64String（pwdString））;

　　}

　　catch（Exception exp）

　　{

　　returnexp.Message;

　　}

　　}

　　}

　　代码二：

　　using System;

　　using System.Security.Cryptography;

　　using System.Text;

　　namespace DotNet.Utilities

　　{

　　/// 《summary》

　　/// Encrypt 的摘要说明。

　　/// 《/summary》

　　public class DEncrypt

　　{

　　/// 《summary》

　　/// 构造方法

　　/// 《/summary》

　　public DEncrypt（）

　　{

　　}

　　#region 使用 缺省密钥字符串 加密/解密string

　　/// 《summary》

　　/// 使用缺省密钥字符串加密string

　　/// 《/summary》

　　/// 《param name=“original”》明文《/param》

　　/// 《returns》密文《/returns》

　　public static string Encrypt（string original）

　　{

　　return Encrypt（original，“sharejs.com”）;

　　}

　　/// 《summary》

　　/// 使用缺省密钥字符串解密string

　　/// 《/summary》

　　/// 《param name=“original”》密文《/param》

　　/// 《returns》明文《/returns》

　　public static string Decrypt（string original）

　　{

　　return Decrypt（original，“sharejs.com”，System.Text.Encoding.Default）;

　　}

　　#endregion

　　#region 使用 给定密钥字符串 加密/解密string

　　/// 《summary》

　　/// 使用给定密钥字符串加密string

　　/// 《/summary》

　　/// 《param name=“original”》原始文字《/param》

　　/// 《param name=“key”》密钥《/param》

　　/// 《param name=“encoding”》字符编码方案《/param》

　　/// 《returns》密文《/returns》

　　public static string Encrypt（string original， string key）

　　{

　　byte［］ buff = System.Text.Encoding.Default.GetBytes（original）;

　　byte［］ kb = System.Text.Encoding.Default.GetBytes（key）;

　　return Convert.ToBase64String（Encrypt（buff，kb））;

　　}

　　/// 《summary》

　　/// 使用给定密钥字符串解密string

　　/// 《/summary》

　　/// 《param name=“original”》密文《/param》

　　/// 《param name=“key”》密钥《/param》

　　/// 《returns》明文《/returns》

　　public static string Decrypt（string original， string key）

　　{

　　return Decrypt（original，key，System.Text.Encoding.Default）;

　　}

　　/// 《summary》

　　/// 使用给定密钥字符串解密string，返回指定编码方式明文

　　/// 《/summary》

　　/// 《param name=“encrypted”》密文《/param》

　　/// 《param name=“key”》密钥《/param》

　　/// 《param name=“encoding”》字符编码方案《/param》

　　/// 《returns》明文《/returns》

　　public static string Decrypt（string encrypted， string key，Encoding encoding）

　　{

　　byte［］ buff = Convert.FromBase64String（encrypted）;

　　byte［］ kb = System.Text.Encoding.Default.GetBytes（key）;

　　return encoding.GetString（Decrypt（buff，kb））;

　　}

　　#endregion

　　#region 使用 缺省密钥字符串 加密/解密/byte［］

　　/// 《summary》

　　/// 使用缺省密钥字符串解密byte［］

　　/// 《/summary》

　　/// 《param name=“encrypted”》密文《/param》

　　/// 《param name=“key”》密钥《/param》

　　/// 《returns》明文《/returns》

　　public static byte［］ Decrypt（byte［］ encrypted）

　　{

　　byte［］ key = System.Text.Encoding.Default.GetBytes（“sharejs.com”）;

　　return Decrypt（encrypted，key）;

　　}

　　/// 《summary》

　　/// 使用缺省密钥字符串加密

　　/// 《/summary》

　　/// 《param name=“original”》原始数据《/param》

　　/// 《param name=“key”》密钥《/param》

　　/// 《returns》密文《/returns》

　　public static byte［］ Encrypt（byte［］ original）

　　{

　　byte［］ key = System.Text.Encoding.Default.GetBytes（“sharejs.com”）;

　　return Encrypt（original，key）;

　　}

　　#endregion

　　#region 使用 给定密钥 加密/解密/byte［］

　　/// 《summary》

　　/// 生成MD5摘要

　　/// 《/summary》

　　/// 《param name=“original”》数据源《/param》

　　/// 《returns》摘要《/returns》

　　public static byte［］ MakeMD5（byte［］ original）

　　{

　　MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider（）;

　　byte［］ keyhash = hashmd5.ComputeHash（original）;

　　hashmd5 = null;

　　return keyhash;

　　}

　　/// 《summary》

　　/// 使用给定密钥加密

　　/// 《/summary》

　　/// 《param name=“original”》明文《/param》

　　/// 《param name=“key”》密钥《/param》

　　/// 《returns》密文《/returns》

　　public static byte［］ Encrypt（byte［］ original， byte［］ key）

　　{

　　TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider（）;

　　des.Key = MakeMD5（key）;

　　des.Mode = CipherMode.ECB;

　　return des.CreateEncryptor（）.TransformFinalBlock（original， 0， original.Length）;

　　}

　　/// 《summary》

　　/// 使用给定密钥解密数据

　　/// 《/summary》

　　/// 《param name=“encrypted”》密文《/param》

　　/// 《param name=“key”》密钥《/param》

　　/// 《returns》明文《/returns》

　　public static byte［］ Decrypt（byte［］ encrypted， byte［］ key）

　　{

　　TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider（）;

　　des.Key = MakeMD5（key）;

　　des.Mode = CipherMode.ECB;

　　return des.CreateDecryptor（）.TransformFinalBlock（encrypted， 0， encrypted.Length）;

　　}

　　#endregion

　　}

　　}

　　代码三：

　　using System;

　　using System.Collections.Generic;

　　using System.Text;

　　namespace MyLibs.encrypt

　　{

　　public class Base64

　　{

　　private static string base64EncodeChars = “ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/”;//编码后的字符集

　　private static int［］ base64DecodeChars = new int［］ { -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， -1， 62， -1， -1， -1， 63， 52， 53， 54， 55， 56， 57， 58， 59， 60， 61， -1， -1， -1， -1， -1， -1， -1， 0， 1， 2， 3， 4， 5， 6， 7， 8， 9， 10， 11， 12， 13， 14， 15， 16， 17， 18， 19， 20， 21， 22， 23， 24， 25， -1， -1， -1， -1， -1， -1， 26， 27， 28， 29， 30， 31， 32， 33， 34， 35， 36， 37， 38， 39， 40， 41， 42， 43， 44， 45， 46， 47， 48， 49， 50， 51， -1， -1， -1， -1， -1 };//对应ASICC字符的位置

　　public static string base64encode（string str）

　　{ //加密

　　string Out = “”;

　　int i = 0， len = str.Length;

　　char c1， c2， c3;

　　while （i 《 len）

　　{

　　c1 = Convert.ToChar（str［i++］ & 0xff）;

　　if （i == len）

　　{

　　Out += base64EncodeChars［c1 》》 2］;

　　Out += base64EncodeChars［（c1 & 0x3） 《《 4］;

　　Out += “==”;

　　break;

　　}

　　c2 = str［i++］;

　　if （i == len）

　　{

　　Out += base64EncodeChars［c1 》》 2］;

　　Out += base64EncodeChars［（（c1 & 0x3） 《《 4） | （（c2 & 0xF0） 》》 4）］;

　　Out += base64EncodeChars［（c2 & 0xF） 《《 2］;

　　Out += “=”;

　　break;

　　}

　　c3 = str［i++］;

　　Out += base64EncodeChars［c1 》》 2］;

　　Out += base64EncodeChars［（（c1 & 0x3） 《《 4） | （（c2 & 0xF0） 》》 4）］;

　　Out += base64EncodeChars［（（c2 & 0xF） 《《 2） | （（c3 & 0xC0） 》》 6）］;

　　Out += base64EncodeChars［c3 & 0x3F］;

　　}

　　return Out;

　　}

　　public string utf16to8（string str）

　　{

　　string Out = “”;

　　int i， len;

　　char c;//char为16位Unicode字符，范围0~0xffff，感谢vczh提醒

　　len = str.Length;

　　for （i = 0; i 《 len; i++）

　　{//根据字符的不同范围分别转化

　　c = str［i］;

　　if （（c 》= 0x0001） && （c 《= 0x007F））

　　{

　　Out += str［i］;

　　}

　　else if （c 》 0x07FF）

　　{

　　Out += （char）（0xE0 | （（c 》》 12） & 0x0F））;

　　Out += （char）（0x80 | （（c 》》 6） & 0x3F））;

　　Out += （char）（0x80 | （（c 》》 0） & 0x3F））;

　　}

　　else

　　{

　　Out += （char）（0xC0 | （（c 》》 6） & 0x1F））;

　　Out += （char）（0x80 | （（c 》》 0） & 0x3F））;

　　}

　　}

　　return Out;

　　}

　　public static string base64decode（string str）

　　{//解密

　　int c1， c2， c3， c4;

　　int i， len;

　　string Out;

　　len = str.Length;

　　i = 0; Out = “”;

　　while （i 《 len）

　　{

　　do

　　{

　　c1 = base64DecodeChars［str［i++］ & 0xff］;

　　} while （i 《 len && c1 == -1）;

　　if （c1 == -1） break;

　　do

　　{

　　c2 = base64DecodeChars［str［i++］ & 0xff］;

　　} while （i 《 len && c2 == -1）;

　　if （c2 == -1） break;

　　Out += （char）（（c1 《《 2） | （（c2 & 0x30） 》》 4））;

　　do

　　{

　　c3 = str［i++］ & 0xff;

　　if （c3 == 61） return Out;

　　c3 = base64DecodeChars［c3］;

　　} while （i 《 len && c3 == -1）;

　　if （c3 == -1） break;

　　Out += （char）（（（c2 & 0XF） 《《 4） | （（c3 & 0x3C） 》》 2））;

　　do

　　{

　　c4 = str［i++］ & 0xff;

　　if （c4 == 61） return Out;

　　c4 = base64DecodeChars［c4］;

　　} while （i 《 len && c4 == -1）;

　　if （c4 == -1） break;

　　Out += （char）（（（c3 & 0x03） 《《 6） | c4）;

　　}

　　return Out;

　　}

　　public string utf8to16（string str）

　　{

　　string Out = “”;

　　int i， len;

　　char c， char2， char3;

　　len = str.Length;

　　i = 0; while （i 《 len）

　　{

　　c = str［i++］;

　　switch （c 》》 4）

　　{

　　case 0：

　　case 1：

　　case 2：

　　case 3：

　　case 4：

　　case 5：

　　case 6：

　　case 7： Out += str［i - 1］; break;

　　case 12：

　　case 13： char2 = str［i++］;

　　Out += （char）（（（c & 0x1F） 《《 6） | （char2 & 0x3F））; break;

　　case 14： char2 = str［i++］;

　　char3 = str［i++］;

　　Out += （char）（（（c & 0x0F） 《《 12） | （（char2 & 0x3F） 《《 6） | （（char3 & 0x3F） 《《 0））; break;

　　}

　　}

　　return Out;

　　}

　　}

　　}