using system;
　　using system.io;
　　using system.security.cryptography;
　　
　　namespace common
　　{
　　/// <summary>
　　///copyright (c), 2004, kwklover(邝伟科)
　　///file name:hasher.cs
　　///author:邝伟科 version:1.0 date:2004年4月22日
　　///description:哈希（不可逆）加密通用类库函数
　　/// </summary>
　　public class hasher
　　{
　　private byte[] _hashkey; //哈希密钥存储变量
　　private string _hashtext; //待加密的字符串
　　public hasher()
　　{
　　//
　　// todo: 在此处添加构造函数逻辑
　　//
　　}
　　
　　/// <summary>
　　/// 哈希密钥
　　/// </summary>
　　public byte[] hashkey
　　{
　　set
　　{
　　_hashkey=value;
　　}
　　get
　　{
　　return _hashkey;
　　}
　　}
　　
　　/// <summary>
　　/// 需要产生加密哈希的字符串
　　/// </summary>
　　public string hashtext
　　{
　　set
　　{
　　_hashtext=value;
　　}
　　get
　　{
　　return _hashtext;
　　}
　　}
　　
　　/// <summary>
　　/// 使用hmacsha1类产生长度为 20 字节的哈希序列。需提供相应的密钥，接受任何大小的密钥。
　　/// </summary>
　　/// <returns></returns>
　　public string hmacsha1hasher()
　　{
　　byte[] hmackey=hashkey;
　　byte[] hmacdata=system.text.encoding.utf8.getbytes(hashtext);
　　
　　hmacsha1 hmac = new hmacsha1(hmackey);
　　
　　cryptostream cs = new cryptostream(stream.null, hmac, cryptostreammode.write);
　　cs.write(hmacdata, 0, hmacdata.length);
　　cs.close();
　　
　　byte[] result=hmac.hash;
　　
　　return convert.tobase64string(result); //返回长度为28字节字符串
　　}
　　
　　/// <summary>
　　/// 使用mactripledes类产生长度为 8 字节的哈希序列。需提供相应的密钥，密钥长度可为 8、16 或 24 字节的密钥。
　　/// </summary>
　　/// <returns></returns>
　　public string mactripledeshasher()
　　{
　　byte[] mackey=hashkey;
　　byte[] macdata=system.text.encoding.utf8.getbytes(hashtext);
　　
　　mactripledes mac=new mactripledes(mackey);
　　
　　byte[] result=mac.computehash(macdata);
　　
　　return convert.tobase64string(result); //返回长度为12字节字符串
　　}
　　
　　/// <summary>
　　/// 使用md5cryptoserviceprovider类产生哈希值。不需要提供密钥。
　　/// </summary>
　　/// <returns></returns>
　　public string md5hasher()
　　{
　　byte[] md5data=system.text.encoding.utf8.getbytes(hashtext);
　　
　　md5 md5=new md5cryptoserviceprovider();
　　
　　byte[] result=md5.computehash(md5data);
　　
　　return convert.tobase64string(result); //返回长度为25字节字符串
　　}
　　
　　/// <summary>
　　/// 使用sha1managed类产生长度为160位哈希值。不需要提供密钥。
　　/// </summary>
　　/// <returns></returns>
　　public string sha1managedhasher()
　　{
　　byte[] sha1data=system.text.encoding.utf8.getbytes(hashtext);
　　
　　sha1managed sha1=new sha1managed();
　　
　　byte[] result=sha1.computehash(sha1data);
　　
　　return convert.tobase64string(result); //返回长度为28字节的字符串
　　}
　　
　　/// <summary>
　　/// 使用sha256managed类产生长度为256位哈希值。不需要提供密钥。
　　/// </summary>
　　/// <returns></returns>
　　public string sha256managedhasher()
　　{
　　byte[] sha256data=system.text.encoding.utf8.getbytes(hashtext);
　　
　　sha256managed sha256=new sha256managed();
　　
　　byte[] result=sha256.computehash(sha256data);
　　
　　return convert.tobase64string(result); //返回长度为44字节的字符串
　　}
　　
　　/// <summary>
　　/// 使用sha384managed类产生长度为384位哈希值。不需要提供密钥。
　　/// </summary>
　　/// <returns></returns>
　　public string sha384managedhasher()
　　{
　　byte[] sha384data=system.text.encoding.utf8.getbytes(hashtext);
　　
　　sha384managed sha384=new sha384managed();
　　
　　byte[] result=sha384.computehash(sha384data);
　　
　　return convert.tobase64string(result); //返回长度为64字节的字符串
　　}
　　
　　/// <summary>
　　/// 使用sha512managed类产生长度为512位哈希值。不需要提供密钥。
　　/// </summary>
　　/// <returns></returns>
　　public string sha512managedhasher()
　　{
　　byte[] sha512data=system.text.encoding.utf8.getbytes(hashtext);
　　
　　sha512managed sha512=new sha512managed();
　　
　　byte[] result=sha512.computehash(sha512data);
　　
　　return convert.tobase64string(result); //返回长度为88字节的字符串
　　}
　　}
　　}