C#加密算法

本贴代码是借鉴别人的非本人所写（本人技术现在还无法写出MD5的算法）

在程序中经常都要用到数据加密, 不过.NET中的加密方式稍微有那么一点复

杂了, 有时候我们希望以更简单的方式处理加密, 那么下面的代码是一个简

单的不错的例子:

using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using QyBBS.BBSConfiguration;
using QyBBS.DataAccess;

namespace OOHacker.Example
...{
public class MyEncrypter
...{
//===========================================
// 返回长为40位的SHA-1加密字符串
//============================================
public static string HexSHA(string text)
...{
return EncryptTemplate(SHA1.Create(), text);
}

//==============================================
// 返回长为32位的MD5加密字符串
//==============================================
public static string HexMD5(string text)
...{
return EncryptTemplate(MD5.Create(), text);
}

//===========================================
// 加密模板
//===========================================
private static string EncryptTemplate(HashAlgorithm algo,

string text)
...{
byte[] data = algo.ComputeHash

(ASCIIEncoding.ASCII.GetBytes(text));
StringBuilder codes = new StringBuilder();
for (int i = 0; i < data.Length; ++i)
...{
codes.Append(data[i].ToString("x2"));
}
return codes.ToString();
}
}
}

使用方法很简单,如下所示:

string strmd5 = MyEncrypter.HexMD5("oohacker");
string strsha = MyEncrypter.HexSHA("oohacker");
Console.WriteLine("Hex MD5 Encryption: {0}", strmd5);
Console.WriteLine("Hex SHA-1 Encryption: {0}", strsha);
输出结果如下:
Hex MD5 Encryption: eccca05fb779dcece81656890773b7bf
Hex SHA-1 Encryption:

67576ffe5410fb70651ef8fd550ecdb7a9901603


根据MD5算法的特点，我们可以把MD5加密过程看作是一个函数调用过程，建

议必须做如下方式修改,这样可以保证一定程度上你的网站用户和数据安全

：
1、修改MD5算法重的4个常数，这是最捷径的作法，其特点是加密后的数据

和加密前非常类似，但是不会被破解
2、多次加密，对MD5加密过的数据进行二次或三次加密，或者在每次加密后

从重抽取部分值进行在加密，比如“我爱你”，加密

后“1E6986ACEC7BAE541AB7B37B99260DAF”，我们可以取任意一部分进行再

加密，比如取前18位“1E6986ACEC7BAE541”进行再加密得

到“E3E0A1F51038849583263FE1F1B8B3E9”，这种做法修改很简单，比如

asp中调用是md5("password")那么你可以改成md5(left(md5

("password"),16))，这样以来就很安全了，就是你的数据被下载，破解的

话也是不可能的

3、仿MD5加密，顾名思义，我们不采用MD5加密，而采用其他算法，然后取

其中的部分散列，可以保证不被破解

方法有很多，我这里只是抛砖引玉，希望你在做网站的时候自己修改，可以

确保万无一失，不管你用的是什么软件，希望大家谨慎一下，我们把这种改

法称为MD5的私有算法或私有MD5算法。

不要使用常规MD5算法，有人说不用常规就不是MD5了，加密方式是灵活的，

希望在做程序的时候选用适合的算法，可以适当对MD5进行修改，比如在配

置文件里给用户增加改变MD5的影响函数，当用户正常安装程序时给出选择

，自动修改MD5算法函数关键部分，从而产生不同网站用户密码加密结果差

异，在初始管理员密码的时候就能保存较高加密程度密码，提高自身程序的

安全性，2、制作程序时，应该多吸收新的加密解密知识，即使用常规方法

，应该多考虑程序以外的安全系数，很多情况下，我们都是开源的，所以，

让用户密码动态改变等新技术也应该吸取

网络加密方式
链路加密方式

　　节点对节点加密方式

　　端对端加密方式

信息加密。支持128bitSSL、DES、3DES、AES等多种加密方式。

密码分为很多种，但一般来说只有四种基本加密类型：
1移位密码（又叫错位密码）。如：12345是密码原码，所得密码为13254，

同理，abcde是原码，移位后为cdbac,密码安全性大大提高。

2为替代码。如原码33215替换后ccbae。

3为科学记数码。这一类密码一般通过复杂的公式运算如：y=kx+b算出新的

密码

4为化学码。这一类往往通过化学手段隐藏需加密内容，这里不做讨论。

（其实即使是最隐蔽的特工组织，所使用的密码也不过是以上几种方法的叠

加或者是手段上的新花样，万变不离其宗，掌握了上面的一般通用规律后，

加密和解密都是一样的）

一般情况下，你自己设定的密码，通过以上加密手段处理后,密码安全性大

大提高，很多自诩为黑客的也要败下阵来。以上内容仅供大家参考，不足之

处请大家批评指正

Base64 编码加密机制原代码

用Base64编码数据,好处是压缩了大小(相对bin2str而言),缺点是增加处理

时间和脚本复杂度。 由于效率瓶颈是在bat生成vbs这一步,所以总的来说还

是合算了。


md5的加密机制原代码
<script>
var hexcase = 0; /* hex output format. 0 - lowercase; 1 -

uppercase */
var b64pad = ""; /* base-64 pad character. "=" for strict RFC

compliance */
var chrsz = 8; /* bits per input character. 8 - ASCII; 16 -

Unicode */
/*
* These are the functions you'll usually want to call
* They take string arguments and return either hex or base-64

encoded strings
*/
function hex_md5(s)&leftsign; return binl2hex(core_md5(str2binl

(s), s.length * chrsz));&rightsign;
function b64_md5(s)&leftsign; return binl2b64(core_md5(str2binl

(s), s.length * chrsz));&rightsign;
function hex_hmac_md5(key, data) &leftsign; return binl2hex

(core_hmac_md5(key, data)); &rightsign;
function b64_hmac_md5(key, data) &leftsign; return binl2b64

(core_hmac_md5(key, data)); &rightsign;
/* Backwards compatibility - same as hex_md5() */
function calcMD5(s)&leftsign; return binl2hex(core_md5(str2binl

(s), s.length * chrsz));&rightsign;
/*
* Perform a simple self-test to see if the VM is working
*/
function md5_vm_test()
&leftsign;
return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
&rightsign;
/*
* Calculate the MD5 of an array of little-endian words, and a bit

length
*/
function core_md5(x, len)
&leftsign;
/* append padding */
x[len >> 5] &line;= 0x80 << ((len) % 32);
x[(((len + 64) >>> 9) << 4) + 14] = len;

var a = 1732584193;
var b = -271733879;
var c = -1732584194;
var d = 271733878;
for(var i = 0; i < x.length; i += 16)
&leftsign;
var olda = a;
var oldb = b;
var oldc = c;
var oldd = d;
a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
a = safe_add(a, olda);
b = safe_add(b, oldb);
c = safe_add(c, oldc);
d = safe_add(d, oldd);
&rightsign;
return Array(a, b, c, d);

&rightsign;
/*
* These functions implement the four basic operations the

algorithm uses.
*/
function md5_cmn(q, a, b, x, s, t)
&leftsign;
return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)),

s),b);
&rightsign;
function md5_ff(a, b, c, d, x, s, t)
&leftsign;
return md5_cmn((b & c) &line; ((~b) & d), a, b, x, s, t);
&rightsign;
function md5_gg(a, b, c, d, x, s, t)
&leftsign;
return md5_cmn((b & d) &line; (c & (~d)), a, b, x, s, t);
&rightsign;
function md5_hh(a, b, c, d, x, s, t)
&leftsign;
return md5_cmn(b ^ c ^ d, a, b, x, s, t);
&rightsign;
function md5_ii(a, b, c, d, x, s, t)
&leftsign;
return md5_cmn(c ^ (b &line; (~d)), a, b, x, s, t);
&rightsign;
/*
* Calculate the HMAC-MD5, of a key and some data
*/
function core_hmac_md5(key, data)
&leftsign;
var bkey = str2binl(key);
if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);
var ipad = Array(16), opad = Array(16);
for(var i = 0; i < 16; i++)
&leftsign;
ipad = bkey ^ 0x36363636;
opad = bkey ^ 0x5C5C5C5C;
&rightsign;
var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length

* chrsz);
return core_md5(opad.concat(hash), 512 + 128);
&rightsign;
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations

internally
* to work around bugs in some JS interpreters.
*/
function safe_add(x, y)
&leftsign;
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return (msw << 16) &line; (lsw & 0xFFFF);
&rightsign;
/*
* Bitwise rotate a 32-bit number to the left.
*/
function bit_rol(num, cnt)
&leftsign;
return (num << cnt) &line; (num >>> (32 - cnt));
&rightsign;
/*
* Convert a string to an array of little-endian words
* If chrsz is ASCII, characters >255 have their hi-byte silently

ignored.
*/
function str2binl(str)
&leftsign;
var bin = Array();
var mask = (1 << chrsz) - 1;
for(var i = 0; i < str.length * chrsz; i += chrsz)
bin[i>>5] &line;= (str.charCodeAt(i / chrsz) & mask) << (i

%32);
return bin;
&rightsign;
/*
* Convert an array of little-endian words to a hex string.
*/
function binl2hex(binarray)
&leftsign;
var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
var str = "";
for(var i = 0; i < binarray.length * 4; i++)
&leftsign;
str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 )) & 0xF);
&rightsign;
return str;
&rightsign;
/*
* Convert an array of little-endian words to a base-64 string
*/
function binl2b64(binarray)
&leftsign;
var tab =

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

;
var str = "";
for(var i = 0; i < binarray.length * 4; i += 3)
&leftsign;
var triplet = (((binarray[i >> 2] >> 8 * ( i %4)) & 0xFF)

<< 16)
&line; (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) &

0xFF) << 8 )
&line; ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) &

0xFF);
for(var j = 0; j < 4; j++)
&leftsign;
if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
&rightsign;
&rightsign;
return str;
&rightsign;
</script>