简单的不用系统函数的加密解密函数，支持中文

来源：互联网发布：pl sql developer教程编辑：程序博客网时间：2024/06/02 06:37

using System;
using System.Collections.Generic;
using System.Text;

namespace TestSilverlight
{
    /********************************************************************************************************
         * 公共类（加解密）
         * Copyright (C) 2008-2009 By 石家庄云天信息技术有限公司
         * songjh20080616(创建标识)

* 修改标识
* 修改描述

         * 修改标识
         * 修改描述
        *********************************************************************************************************/

    public class PassWord
    {
        private PassWord()
        {

        }

        public static byte[] DecryptByte(byte[] dd, string key)
        {
            return ASCIIEncoding.Default.GetBytes(Decrypt(ASCIIEncoding.Default.GetString(dd), key));
        }

        public static byte[] EncryptByte(byte[] dd, string key)
        {
            return ASCIIEncoding.Default.GetBytes(Encrypt(ASCIIEncoding.Default.GetString(dd), key));
        }

        /// <summary>
        /// 解密程序
        /// </summary>
        /// <param name="dd">加密的密码</param>
        /// <returns>解密后的密码</returns>
        public static string Decrypt(string dd,string key)
        {
            byte[] encbuff = System.Text.Encoding.UTF8.GetBytes(source);
            string dd = Convert.ToBase64String(encbuff);

            string vkey = key;   //
            int vkeylen = vkey.Length;
            int vKeyPos = 0;
            int vSrcPos = 0;
            int vSrcAsc = 0;
            int vTmpSrcAsc = 0;
            string vDest = "";
            string ff = dd.Substring(0, 2);
            int ddddd = Convert.ToInt32(ff, 16);
            string fff = Convert.ToString(ddddd, 10);
            int vOffset = Convert.ToInt32(fff);

            vSrcPos = 2;
            while (vSrcPos < dd.Length)
            {
                int eee = Convert.ToInt32(dd.Substring(vSrcPos, 2), 16);

                vSrcAsc = Convert.ToInt32(Convert.ToString(eee, 10));
                if (vKeyPos < vkeylen)
                {
                    vKeyPos = vKeyPos + 1;
                }
                else
                {
                    vKeyPos = 1;
                }
                char ddddff = (vkey[vKeyPos - 1]);
                //vKeyPos = vKeyPos - 1;
                vTmpSrcAsc = vSrcAsc ^ (int)(vkey[vKeyPos - 1]);
                if (vTmpSrcAsc <= vOffset)
                {
                    vTmpSrcAsc = 255 + vTmpSrcAsc - vOffset;
                }
                else
                {
                    vTmpSrcAsc = vTmpSrcAsc - vOffset;
                }

                vDest = vDest + (char)(vTmpSrcAsc);
                vOffset = vSrcAsc;
                vSrcPos = vSrcPos + 2;
            }
            byte[] decbuff = Convert.FromBase64String(vDest);
            return System.Text.Encoding.UTF8.GetString(decbuff);
        }

        /// <summary>
        /// 加密程序
        /// </summary>
        /// <param name="dd">要加密的字符串</param>
        /// <returns>加密后的字符串</returns>
        public static string Encrypt(string source, string key)
        {
            byte[] encbuff = System.Text.Encoding.UTF8.GetBytes(source);
            string dd = Convert.ToBase64String(encbuff);

            string vkey = key;       //"zhangzengbao"
            int vkeylen = vkey.Length;
            int vKeyPos = 0;
            int vSrcAsc = 0;
            int vRange = 256;
            int voffset = 0;
            string vDest = "";
            Random ro = new Random();
            voffset = ro.Next(vRange);
            //voffset = ro.Next(17, 256);

            vDest = Convert.ToString(voffset, 16);
            if (vDest.Length < 2)
            {
                vDest = "0" + vDest;
            }
            for (int i = 0; i < dd.Length; i++)
            {
                //byte[] B = Encoding.ASCII.GetBytes(a);
                // byte[] b = Encoding.ASCII.GetBytes(dd[i].ToString());
                // int bb =(int) b[0];
                vSrcAsc = ((int)dd[i] + voffset) % 255;//求模
                // vSrcAsc = (bb + voffset) % 255;
                if (vKeyPos < vkeylen)
                {
                    vKeyPos = vKeyPos + 1;
                }
                else
                {
                    vKeyPos = 1;
                }

                vRange = (int)(vkey[vKeyPos - 1]);
                //byte[] c = Encoding.ASCII.GetBytes(vkey[vKeyPos - 1].ToString());
                // int cc = (int)c[0];
                //vRange = cc;
                vSrcAsc = vSrcAsc ^ vRange;
                string v1 = Convert.ToString(vSrcAsc, 16);
                if (v1.Length < 2)
                {
                    v1 = "0" + v1;
                }
                vDest = vDest + v1;

voffset = vSrcAsc;

}
vDest = vDest.ToUpper();

            return vDest;
        }
    }
}

////
//简单的使用系统加密解密函数实现的加密解密函数
//

//using System;
//using System.Text;
//using System.Globalization;
//using System.Security.Cryptography;
//using System.Windows.Forms;

//namespace TestSilverlight
//{
//    public class TestEncrypt
//    {
//        /// <summary>
//        /// 构造方法
//        /// </summary>
//        public TestEncrypt()
//        {
//        }

//        /// <summary>
//        /// 使用缺省密钥字符串加密
//        /// </summary>
//        /// <param name="original">明文</param>
//        /// <returns>密文</returns>
//        public static string Encrypt(string original)
//        {
//            return Encrypt(original,"JASONHEUNG");
//        }

//        /// <summary>
//        /// 使用缺省密钥解密
//        /// </summary>
//        /// <param name="original">密文</param>
//        /// <returns>明文</returns>
//        public static string Decrypt(string original)
//        {
//            return Decrypt(original,"JASONHEUNG",System.Text.Encoding.Default);
//        }

//        /// <summary>
//        /// 使用给定密钥解密
//        /// </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>
//        /// 使用缺省密钥解密,返回指定编码方式明文
//        /// </summary>
//        /// <param name="original">密文</param>
//        /// <param name="encoding">编码方式</param>
//        /// <returns>明文</returns>
//        public static string Decrypt(string original,Encoding encoding)
//        {
//            return Decrypt(original,"JASONHEUNG",encoding);
//        }

//        /// <summary>
//        /// 使用给定密钥加密
//        /// </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>
//        /// 使用给定密钥解密
//        /// </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));
//        }

//        /// <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);
//        }

//        /// <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("JASONHEUNG");
//            return Encrypt(original,key);
//        }

//        /// <summary>
//        /// 使用缺省密钥解密数据
//        /// </summary>
//        /// <param name="encrypted">密文</param>
//        /// <param name="key">密钥</param>
//        /// <returns>明文</returns>
//        public static byte[] Decrypt(byte[] encrypted)
//        {
//            byte[] key = System.Text.Encoding.Default.GetBytes("JASONHEUNG");
//            return Decrypt(encrypted,key);
//        }
//    }
//}