.NET中DES加密代码转成ASP代码

[ltjy]

using System;
using System.Security.Cryptography;
using System.Text;
using System.IO;
namespace DesSecurity
{
    /// <summary>
    /// 使用DES对称加密法进行加密解密,密钥只能为8位以内的字符串，多余部分会舍去
    /// 可以处理中文
    /// </summary>
    public class DesCrypt
    {

        string key;
        DESCryptoServiceProvider des;
        bool initaled; //是否初始化了des对象和3个流对象，修改KeyString属性以后需要重新建立对象
        MemoryStream ms;
        CryptoStream cs;
        StreamWriter sw;
        StreamReader sr;
        //======================================私有成员定义完成===============================
        private bool inital()
        {
            try
            {
                string tkey;
                if (key.Length > 8) { tkey = key.Substring(0, 8); key = tkey; }//密钥太长，舍去多余部分
                if (key.Length < 8) { tkey = key + "KLFDOADA"; key = tkey.Substring(0, 8); }//密钥太短，自动添上一部分
                des = new DESCryptoServiceProvider();
                des.Key = ASCIIEncoding.ASCII.GetBytes(key);
                des.IV = ASCIIEncoding.ASCII.GetBytes(key);

                initaled = true;
                return (true);
            }
            catch
            {
                initaled = false;
                return (false);
            }
        }
        //======================================私有方法定义完成===============================
        /// <summary>
        /// 使用此方法建立对象后需要提供密钥才能工作（KeyString属性）
        /// </summary>
        public DesCrypt()
        {
            key = "12345678";
        }
        /// <summary>
        /// 参数为密钥
        /// </summary>
        /// <param name="KeyString"></param>
        public DesCrypt(string KeyString)
        {
            key = KeyString;
            inital();
        }
        //======================================构造函数定义完成===============================

        /// <summary>
        /// 提供一个未加密的字符串，返回一个加密过的字符串
        /// </summary>
        /// <param name="SourceString"></param>
        /// <returns></returns>
        public string Encrypt(string SourceString)
        {
            try
            {
                if (!initaled && !inital()) return (null);
                ms = new MemoryStream();
                cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
                sw = new StreamWriter(cs);
                sw.Write(SourceString);
                sw.Flush();
                cs.FlushFinalBlock();
                ms.Flush();
                return (Convert.ToBase64String(ms.GetBuffer(), 0, (Int32)ms.Length));

            }
            catch
            {
                return (null);
            }
        }
        /// <summary>
        /// 提供一个加密过的字符串，返回一个解密了的字符串
        /// </summary>
        /// <param name="SourceString"></param>
        /// <returns></returns>
        public string Decrypt(string SourceString)
        {
            try
            {
                if (!initaled && !inital()) return (null);
                byte[] buffer = Convert.FromBase64String(SourceString);
                ms = new MemoryStream(buffer);
                cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read);
                sr = new StreamReader(cs);
                return (sr.ReadToEnd());
            }
            catch
            {
                return (null);
            }
        }
        //======================================共有方法定义完成===============================
        /// <summary>
        /// 获取或修改密钥
        /// </summary>
        public string KeyString
        {
            get { return (key); }
            set { key = value; inital(); }
        }
        /// <summary>
        /// 是否已经准备就绪，可以开始加密、解密工作
        /// </summary>
        public bool Ready
        {
            get { return (initaled); }
        }


        //======================================共有属性定义完成===============================

    }

    /// <summary>
    /// DesCrypt的升级版，时间复杂度较高，但是可以使用任意长度的密钥
    /// 实际上是将密钥分成长度8的子串，为每个子串建立一个DesCrypt对象
    /// 加密的时候分级加密，解密的时候分级解密
    /// </summary>
    public class AdvanceDesCrypt
    {
        private DesCrypt[] des;
        private string key;
        private int level;

        //=====================================私有成员定义完成=================================
        private int inital()
        {
            try
            {
                string sub;
                int i, j;
                j = key.Length / 8; if (key.Length % 8 > 0) j++;//将密钥8个字符一组进行划分
                des = new DesCrypt[j];
                for (i = 0; i < j; i++)
                {
                    if (key.Length >= i * 8 + 7) sub = key.Substring(i * 8, 8);
                    else sub = key.Substring(i * 8);//最后的子串可能不到8个字符
                    des[i] = new DesCrypt(sub);
                }
                return (j);
            }
            catch
            {
                return (0);
            }
        }
        //=====================================私有函数定义完成=================================
        public AdvanceDesCrypt()
        {
            key = "12345678";
            level = inital();
        }
        public AdvanceDesCrypt(string Key)
        {
            if (Key.Length > 0 && Key.Length <= 256) key = Key;
            else key = "KLFDOADA";
            level = inital();
        }
        //=====================================构造函数定义完成=================================
        /// <summary>
        /// 加密一个字符串
        /// </summary>
        /// <param name="SourceString"></param>
        /// <returns></returns>
        public string Encrypt(string SourceString)
        {
            try
            {
                int i;
                string temp;
                temp = SourceString;
                for (i = level - 1; i >= 0; i--) temp = des[i].Encrypt(temp);//从后向前分级加密
                return (temp);
            }
            catch
            {
                return (null);
            }
        }
        /// <summary>
        /// 解密一个已经加密过的字符串
        /// </summary>
        /// <param name="SourceString"></param>
        /// <returns></returns>
        public string Decrypt(string SourceString)
        {
            try
            {
                int i;
                string temp;
                temp = SourceString;
                for (i = 0; i < level; i++) temp = des[i].Decrypt(temp);//从前向后分级解密
                return (temp);
            }
            catch
            {
                return (null);
            }
        }
        /// <summary>
        /// 随机生成指定长度的密钥
        /// </summary>
        /// <param name="Length"></param>
        /// <returns></returns>
        public string GenerateKey(int Length)
        {
            try
            {
                string k;
                if (Length <= 0 || Length > 256) return (null);
                byte[] bit = new byte[256];
                int i;
                Random ran = new Random();
                for (i = 0; i < Length; i++) bit[i] = (byte)ran.Next(65, 255);
                k = Convert.ToBase64String(bit, 0, Length);
                return (k.Substring(0, Length));
            }
            catch
            {
                return (null);
            }
        }
        //=====================================公有函数定义完成=================================
        /// <summary>
        /// 获取或设置密钥，长度应在256个字符以内
        /// </summary>
        public string Key
        {
            get { return (key); }
            set
            {
                if (value.Length > 0 || value.Length <= 256)
                {
                    key = value;
                    level = inital();
                }

            }
        }
        //=====================================公有属性定义完成=================================
    }

}

[海边的狼]

could you tell me what's your mean

[kbryant]

帮你顶

[mengxj85]

不用转化吧，VS里已经集成有DES算法了，只要调用就OK了，网上有源码，

[ltjy]

[Quote=引用 4 楼 mengxj85 的回复:]
不用转化吧，VS里已经集成有DES算法了，只要调用就OK了，网上有源码，
[/Quote]
我怎么没做到，能帮我找下吗？

[s208ping]

public class Encryption 
{ 
public Encryption() 
{ 
} 

/// <summary> 
/// 对字符串进行加密。 
/// </summary> 
/// <param name="src">要加密的字符串。 </param> 
/// <returns>返回加密后的字符串。 </returns> 
public static string Encrypt(string src) 
{ 
if (src == "") return src; 

Encoding enc = Encoding.Unicode; 
byte [] input = enc.GetBytes(src); 
byte [] output = Encryption.Encrypt(input); 

string result = System.Convert.ToBase64String(output); 
return result; 
} 

/// <summary> 
/// 对字节数组进行加密。 
/// </summary> 
/// <param name="input">要加密的字节数组。 </param> 
/// <returns>返回加密后的字节数组。 </returns> 
public static byte [] Encrypt(byte[] input) 
{ 
byte[] key = {0x13, 0x90, 0x11, 0x99, 0x93, 0x13, 0x80, 0x12}; 
byte[] iv = {0x08, 0x01, 0x41, 0x39, 0x01, 0x19, 0x99, 0x31}; 

DESCryptoServiceProvider desp = new DESCryptoServiceProvider(); 
ICryptoTransform enf = desp.CreateEncryptor(key, iv); 

byte [] output = enf.TransformFinalBlock(input, 0, input.Length); 

return output; 
} 

/// <summary> 
/// 对字节数组进行解密。 
/// </summary> 
/// <param name="input">要解密的字节数组。 </param> 
/// <returns>返回解密后的字节数组。 </returns> 
public static byte [] Decrypt(byte[] input) 
{ 
byte[] key = {0x13, 0x90, 0x11, 0x99, 0x93, 0x13, 0x80, 0x12}; 
byte[] iv = {0x08, 0x01, 0x41, 0x39, 0x01, 0x19, 0x99, 0x31}; 

DESCryptoServiceProvider desp = new DESCryptoServiceProvider(); 
ICryptoTransform enf = desp.CreateDecryptor(key, iv); 

byte [] output = enf.TransformFinalBlock(input, 0, input.Length); 

return output; 
} 

/// <summary> 
/// 对字符串进行解密。 
/// </summary> 
/// <param name="src">要解密的字符串。 </param> 
/// <returns>返回解密后的字符串。 </returns> 
public static string Decrypt(string src) 
{ 
if (src == "") return src; 

Encoding enc = Encoding.Unicode; 

byte [] input = System.Convert.FromBase64String(src); 
byte [] output = Encryption.Decrypt(input); 

string result = enc.GetString(output); 
return result; 
} 
} 
} 

[大自然D使者]

帮楼主顶一下，自己也学习一下。

[ltjy]

不是ASP的呀？

[CrazyHosptial]

你可以自己定义一组标记。
用于转换。
如果靠纯算法来进行转换的话，可靠性是高了，但是效率却低了。

[ltjy]

不会哦

[变成熊猫你就老实了是不]

建议你将这个代码打包成dll，然后在服务器注册这个dll，最后用asp的Server.CreateObject调用。

[littlelam]

DES算法及其在VC++6.0下的实现源代码

http://download.csdn.net/source/334900

这个应该可以编译成dll给asp调用