C# 可逆加解密演算法

阿新 • • 發佈：2019-02-03

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EmptyProject
{
    /// <summary>
    /// 自定義可逆加解密演算法，資料、密碼，可以為任意字串；
    /// 1、加密 Locker.Encrypt()
    /// 2、解密 Locker.Decrypt()
    /// </summary>
    public class Locker
    {
        public static void example()
        {
            string data = Locker.Encrypt("待加密的資料資訊", "自定義密碼");
            string result = Locker.Decrypt("9olrx3xiueqa9iegopfqskl2updirdfp922o0zi1tqxsltks", "自定義密碼");

            //MessageBox.Show(data.Equals("9olrx3xiueqa9iegopfqskl2updirdfp922o0zi1tqxsltks") + "");  // true
            //MessageBox.Show(result.Equals("待加密的資料資訊") + "");                                // true
        }

        /// <summary>
        /// 使用SecretKey對資料data進行加密
        /// </summary>
        /// <param name="data">待加密的資料</param>
        /// <param name="SecretKey">自定義密碼串</param>
        /// <returns></returns>
        public static string Encrypt(string data, string SecretKey)
        {
            string key = MD5.Encrypt(SecretKey);
            data = Encoder.EncodeAlphabet(data);

            StringBuilder builder = new StringBuilder();

            int i = 0;
            foreach (char A in data)
            {
                if (i >= key.Length)
                {
                    i = i % key.Length;
                    key = MD5.Encrypt(key);
                }
                char B = key[i++];

                char n = ToChar(ToInt(A) + ToInt(B) * 3);
                builder.Append(n);
            }

            return builder.ToString();
        }

        /// <summary>
        /// 使用SecretKey對資料data進行解密
        /// </summary>
        /// <param name="data">待解密的資料</param>
        /// <param name="SecretKey">解密密碼串</param>
        /// <returns></returns>
        public static string Decrypt(string data, string SecretKey)
        {
            string key = MD5.Encrypt(SecretKey);

            StringBuilder builder = new StringBuilder();

            int i = 0;
            foreach (char A in data)
            {
                if (i >= key.Length)
                {
                    i = i % key.Length;
                    key = MD5.Encrypt(key);
                }
                char B = key[i++];

                char n = ToChar(ToInt(A) - ToInt(B) * 3);
                builder.Append(n);
            }
            data = builder.ToString();
            data = Encoder.DecodeAlphabet(data);

            return data;
        }

        /// <summary>
        /// "0-9 a-z"對映為 0到35
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        private static int ToInt(char c)
        {
            if ('0' <= c && c <= '9') return c - '0';
            else if ('a' <= c && c <= 'z') return 10 + c - 'a';
            else return 0;
        }

        /// <summary>
        /// 0到35依次對映為"0-9 a-z"，
        /// 超出35取餘數對映
        /// </summary>
        /// <param name="n"></param>
        /// <returns></returns>
        private static char ToChar(int n)
        {
            if (n >= 36) n = n % 36;
            else if (n < 0) n = n % 36 + 36;

            if (n > 9) return (char)(n - 10 + 'a');
            else return (char)(n + '0');
        }


        ///// <summary>
        ///// "0-9 a-z A-Z"對映為 0到9 10到35 36到61
        ///// </summary>
        ///// <param name="c"></param>
        ///// <returns></returns>
        //public static int ToInt(char c)
        //{
        //    if ('0' <= c && c <= '9') return c - '0';
        //    else if ('a' <= c && c <= 'z') return 10 + c - 'a';
        //    else if ('A' <= c && c <= 'Z') return 36 + c - 'A';
        //    else return 0;
        //}

        ///// <summary>
        ///// 0到61依次對映為"0-9 a-z A-Z"，
        ///// 超出61取餘數對映
        ///// </summary>
        ///// <param name="n"></param>
        ///// <returns></returns>
        //public static char ToChar(int n)
        //{
        //    if (n >= 62) n = n % 62;
        //    else if (n < 0) n = n % 62 + 62;

        //    if (n > 35) return (char)(n - 36 + 'A');
        //    else if (n > 9) return (char)(n - 10 + 'a');
        //    else return (char)(n + '0');
        //}
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EmptyProject
{
    public class Encoder
    {
        public static void example()
        {
            String data = "test encode";
            string encode = Encode(data);
            string decode = Decode(encode);
            bool b = data.Equals(decode);
            bool b2 = b;
        }

        /// <summary>  
        /// 轉碼data為全字母串，並新增字首  
        /// </summary>
        public static string Encode(string data)
        {
            string str = data;
            if (!data.StartsWith(" 
[email protected]"))
            {
                str = "[email protected]" + EncodeAlphabet(data);
            }
            return str;
        }


        /// <summary>  
        /// 解析字母串為原有串  
        /// </summary>  
        public static string Decode(string data)
        {
            string str = data;
            if (data.StartsWith(" 
[email protected]"))
            {
                str = DecodeAlphabet(data.Substring("[email protected]".Length));
            }
            return str;
        }

        /// <summary>
        /// 獲取檔案對應的編碼字串
        /// </summary>
        public static string getFileData(string file)
        {
            byte[] bytes = File2Bytes(file);
            string data = ToStr(bytes);

            return data;
        }

        /// <summary>  
        /// 將檔案轉換為byte陣列  
        /// </summary>  
        /// <param name="path">檔案地址</param>  
        /// <returns>轉換後的byte陣列</returns>  
        public static byte[] File2Bytes(string path)
        {
            if (!File.Exists(path))
            {
                return new byte[0];
            }

            FileInfo fi = new FileInfo(path);
            byte[] buff = new byte[fi.Length];

            FileStream fs = fi.OpenRead();
            fs.Read(buff, 0, Convert.ToInt32(fs.Length));
            fs.Close();

            return buff;
        }

        /// <summary>  
        /// 獲取檔案中的資料,自動判定編碼格式
        /// </summary>  
        private static string fileToString(String filePath)
        {
            byte[] bytes = File2Bytes(filePath);
            string str = Encoding.UTF8.GetString(bytes);

            return str;
        }

        # region 字串字母編碼邏輯

        /// <summary>  
        /// 轉化為字母字串  
        /// </summary>  
        public static string EncodeAlphabet(string data)
        {
            byte[] B = Encoding.UTF8.GetBytes(data);
            return ToStr(B);
        }

        /// <summary>  
        /// 每個位元組轉化為兩個字母  
        /// </summary>  
        private static string ToStr(byte[] B)
        {
            StringBuilder Str = new StringBuilder();
            foreach (byte b in B)
            {
                Str.Append(ToStr(b));
            }
            return Str.ToString();
        }

        private static string ToStr(byte b)
        {
            return "" + ToChar(b / 16) + ToChar(b % 16);
        }

        private static char ToChar(int n)
        {
            return (char)('a' + n);
        }

        /// <summary>  
        /// 解析字母字串  
        /// </summary>  
        public static string DecodeAlphabet(string data)
        {
            byte[] B = ToBytes(data);
            return Encoding.UTF8.GetString(B);
        }

        /// <summary>  
        /// 解析字串為Bytes陣列
        /// </summary>  
        public static byte[] ToBytes(string data)
        {
            byte[] B = new byte[data.Length / 2];
            char[] C = data.ToCharArray();

            for (int i = 0; i < C.Length; i += 2)
            {
                byte b = ToByte(C[i], C[i + 1]);
                B[i / 2] = b;
            }

            return B;
        }

        /// <summary>  
        /// 每兩個字母還原為一個位元組  
        /// </summary>  
        private static byte ToByte(char a1, char a2)
        {
            return (byte)((a1 - 'a') * 16 + (a2 - 'a'));
        }

        # endregion

    }

}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EmptyProject
{

    //示例： 
    // MD5.Encrypt("a");                        // 計算字串MD5值
    // MD5.Encrypt(new FileInfo("D:\\1.rar"));  // 計算檔案MD5值
    // MD5.Encrypt(byte[] Bytes);               // 計算Byte陣列MD5值

    //MD5 ("") = d41d8cd98f00b204e9800998ecf8427e   
    //MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661   
    //MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72   
    //MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0   
    //MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b  
    class MD5
    {

        #region MD5呼叫介面

        /// <summary>
        /// 計算data的MD5值
        /// </summary>
        public static string Encrypt(string data)
        {
            uint[] X = To16Array(data);
            string Str = ToNativeStr(X);

            return calculate(X);
        }

        /// <summary>
        /// 計算byte陣列的MD5值
        /// </summary>
        public static string Encrypt(byte[] Bytes)
        {
            uint[] X = To16Array(Bytes);
            return calculate(X);
        }

        /// <summary>
        /// 計算檔案的MD5值
        /// </summary>
        public static string Encrypt(FileInfo file)
        {
            uint[] X = To16Array(file);
            return calculate(X);
        }

        #endregion


        #region MD5計算邏輯

        /// <summary>
        /// 轉化byte陣列為uint陣列，陣列長度為16的倍數
        /// 
        /// 1、字串轉化為位元組陣列，每4個位元組轉化為一個uint，依次儲存到uint陣列
        /// 2、附加0x80作為最後一個位元組
        /// 3、在uint陣列最後位置記錄檔案位元組長度資訊
        /// </summary>
        public static uint[] To16Array(byte[] Bytes)
        {
            uint DataLen = (uint)Bytes.Length;

            // 計算FileLen對應的uint長度（要求為16的倍數、預留2個uint、最小為16）
            uint ArrayLen = (((DataLen + 8) / 64) + 1) * 16;
            uint[] Array = new uint[ArrayLen];

            uint ArrayPos = 0;
            int pos = 0;
            uint ByteCount = 0;
            for (ByteCount = 0; ByteCount < DataLen; ByteCount++)
            {
                // 每4個Byte轉化為1個uint
                ArrayPos = ByteCount / 4;
                pos = (int)(ByteCount % 4) * 8;
                Array[ArrayPos] = Array[ArrayPos] | ((uint)Bytes[ByteCount] << pos);
            }

            // 附加0x80作為最後一個位元組，新增到uint陣列對應位置
            ArrayPos = ByteCount / 4;
            pos = (int)(ByteCount % 4) * 8;
            Array[ArrayPos] = Array[ArrayPos] | ((uint)0x80 << pos);

            // 記錄總長度資訊
            Array[ArrayLen - 2] = (DataLen << 3);
            Array[ArrayLen - 1] = (DataLen >> 29);

            return Array;
        }

        /// <summary>
        /// 轉化字串為uint陣列，陣列長度為16的倍數
        /// 
        /// 1、字串轉化為位元組陣列，每4個位元組轉化為一個uint，依次儲存到uint陣列
        /// 2、附加0x80作為最後一個位元組
        /// 3、在uint陣列最後位置記錄檔案位元組長度資訊
        /// </summary>
        public static uint[] To16Array(string data)
        {
            byte[] datas = System.Text.Encoding.Default.GetBytes(data);
            return To16Array(datas);
        }

        /// <summary>
        /// 轉化檔案為uint陣列，陣列長度為16的倍數
        /// 
        /// 1、讀取檔案位元組資訊，每4個位元組轉化為一個uint，依次儲存到uint陣列
        /// 2、附加0x80作為最後一個位元組
        /// 3、在uint陣列最後位置記錄檔案位元組長度資訊
        /// </summary>
        public static uint[] To16Array(FileInfo info)
        {
            FileStream fs = new FileStream(info.FullName, FileMode.Open);// 讀取方式開啟，得到流
            int SIZE = 1024 * 1024 * 10;        // 10M快取
            byte[] datas = new byte[SIZE];      // 要讀取的內容會放到這個數組裡
            int countI = 0;
            long offset = 0;

            // 計算FileLen對應的uint長度（要求為16的倍數、預留2個uint、最小為16）
            uint FileLen = (uint)info.Length;
            uint ArrayLen = (((FileLen + 8) / 64) + 1) * 16;
            uint[] Array = new uint[ArrayLen];

            int pos = 0;
            uint ByteCount = 0;
            uint ArrayPos = 0;
            while (ByteCount < FileLen)
            {
                if (countI == 0)
                {
                    fs.Seek(offset, SeekOrigin.Begin);// 定位到指定位元組
                    fs.Read(datas, 0, datas.Length);

                    offset += SIZE;
                }

                // 每4個Byte轉化為1個uint
                ArrayPos = ByteCount / 4;
                pos = (int)(ByteCount % 4) * 8;
                Array[ArrayPos] = Array[ArrayPos] | ((uint)datas[countI] << pos);

                ByteCount = ByteCount + 1;

                countI++;
                if (countI == SIZE) countI = 0;
            }

            // 附加0x80作為最後一個位元組，新增到uint陣列對應位置
            ArrayPos = ByteCount / 4;
            pos = (int)(ByteCount % 4) * 8;
            Array[ArrayPos] = Array[ArrayPos] | ((uint)0x80 << pos);

            // 記錄總長度資訊
            Array[ArrayLen - 2] = (FileLen << 3);
            Array[ArrayLen - 1] = (FileLen >> 29);

            fs.Close();
            return Array;
        }

        /// <summary>
        /// 將X陣列還原為原有字串
        /// </summary>
        private static String ToNativeStr(uint[] X)
        {
            List<byte> list = new List<byte>();

            for (int i = 0; i < 8; i++)
            {
                uint n = X[i];
                for (int j = 0; j < 4; j++)
                {
                    byte b = (byte)(n & 0xFF);
                    list.Add(b);
                    n = n >> 8;
                }
            }
            byte[] Bytes = list.ToArray();
            String Str = System.Text.Encoding.Default.GetString(Bytes);
            return Str;
        }

        private static uint F(uint x, uint y, uint z)
        {
            return (x & y) | ((~x) & z);
        }
        private static uint G(uint x, uint y, uint z)
        {
            return (x & z) | (y & (~z));
        }

        // 0^0^0 = 0
        // 0^0^1 = 1
        // 0^1^0 = 1
        // 0^1^1 = 0
        // 1^0^0 = 1
        // 1^0^1 = 0
        // 1^1^0 = 0
        // 1^1^1 = 1
        private static uint H(uint x, uint y, uint z)
        {
            return (x ^ y ^ z);
        }
        private static uint I(uint x, uint y, uint z)
        {
            return (y ^ (x | (~z)));
        }

        // 迴圈左移
        private static uint RL(uint x, int y)
        {
            y = y % 32;
            return (x << y) | (x >> (32 - y));
        }

        private static void md5_FF(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
        {
            //uint a1 = a;    // 1732584193   4023233417

            uint f = F(b, c, d);    // 2562383102
            a = x + ac + a + f;     // 3614090487

            a = RL(a, s);           // 3042081771
            a = a + b;

            //md5_FF2(ref a1, b, c, d, x, s, ac);

            //if (a != a1)    // 2770347892 2770347893
            //    MessageBox.Show("");

        }

        private static void md5_FF2(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
        {
            uint f = F(b, c, d);    // 2562383102
            a = x + ac + a + f;     // 3614090487

            uint b2 = RL(b, 32 - s);    // 333421399
            a = a + b2;

            a = RL(a, s);
        }

        private static void md5_GG(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
        {
            uint g = G(b, c, d);
            a = x + ac + a + g;

            a = RL(a, s);
            a = a + b;
        }
        private static void md5_HH(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
        {
            uint h = H(b, c, d);
            a = x + ac + a + h;

            a = RL(a, s);
            a = a + b;
        }
        //uint a = 350508294;
        //uint b = 4283343851;
        //uint c = 1846584438;
        //uint d = 1917254355;
        private static void md5_II(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
        {
            //uint xa = x + a;    // 806551938

            uint i = I(b, c, d);// 2448360345
            a = x + ac + a + i; // 2911426732

            a = RL(a, s);       // 362131739
            a = a + b;
        }

        private static string RHex(uint n)
        {
            string S = Convert.ToString(n, 16);
            return ReOrder(S);
        }

        // 16進位制串重排序 67452301 -> 01234567
        private static string ReOrder(String S)
        {
            string T = "";
            for (int i = S.Length - 2; i >= 0; i = i - 2)
            {
                if (i == -1) T = T + "0" + S[i + 1];
                else T = T + "" + S[i] + S[i + 1];
            }
            return T;
        }


        /// <summary>
        /// 對長度為16倍數的uint陣列，執行md5資料摘要，輸出md5資訊
        /// </summary>
        public static string calculate(uint[] x)
        {
            //uint time1 = DateTime.Now.Ticks;

            // 7   12  17   22
            // 5   9   14   20
            // 4   11  16   23
            // 6   10  15   21
            const int S11 = 7;
            const int S12 = 12;
            const int S13 = 17;
            const int S14 = 22;
            const int S21 = 5;
            const int S22 = 9;
            const int S23 = 14;
            const int S24 = 20;
            const int S31 = 4;
            const int S32 = 11;
            const int S33 = 16;
            const int S34 = 23;
            const int S41 = 6;
            const int S42 = 10;
            const int S43 = 15;
            const int S44 = 21;

            uint a = 0x67452301;
            uint b = 0xEFCDAB89;
            uint c = 0x98BADCFE;
            uint d = 0x10325476;

            for (int k = 0; k < x.Length; k += 16)
            {
                uint AA = a;
                uint BB = b;
                uint CC = c;
                uint DD = d;

                md5_FF(ref a, b, c, d, x[k + 0], S11, 0xD76AA478);  // 3604027302
                md5_FF(ref d, a, b, c, x[k + 1], S12, 0xE8C7B756);  // 877880356
                md5_FF(ref c, d, a, b, x[k + 2], S13, 0x242070DB);  // 2562383102
                md5_FF(ref b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
                md5_FF(ref a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
                md5_FF(ref d, a, b, c, x[k + 5], S12, 0x4787C62A);
                md5_FF(ref c, d, a, b, x[k + 6], S13, 0xA8304613);
                md5_FF(ref b, c, d, a, x[k + 7], S14, 0xFD469501);
                md5_FF(ref a, b, c, d, x[k + 8], S11, 0x698098D8);
                md5_FF(ref d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
                md5_FF(ref c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
                md5_FF(ref b, c, d, a, x[k + 11], S14, 0x895CD7BE);
                md5_FF(ref a, b, c, d, x[k + 12], S11, 0x6B901122);
                md5_FF(ref d, a, b, c, x[k + 13], S12, 0xFD987193);
                md5_FF(ref c, d, a, b, x[k + 14], S13, 0xA679438E);
                md5_FF(ref b, c, d, a, x[k + 15], S14, 0x49B40821); //3526238649
                md5_GG(ref a, b, c, d, x[k + 1], S21, 0xF61E2562);
                md5_GG(ref d, a, b, c, x[k + 6], S22, 0xC040B340);  //1572812400
                md5_GG(ref c, d, a, b, x[k + 11], S23, 0x265E5A51);
                md5_GG(ref b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
                md5_GG(ref a, b, c, d, x[k + 5], S21, 0xD62F105D);
                md5_GG(ref d, a, b, c, x[k + 10], S22, 0x2441453);
                md5_GG(ref c, d, a, b, x[k + 15], S23, 0xD8A1E681);
                md5_GG(ref b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
                md5_GG(ref a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
                md5_GG(ref d, a, b, c, x[k + 14], S22, 0xC33707D6);
                md5_GG(ref c, d, a, b, x[k + 3], S23, 0xF4D50D87);
                md5_GG(ref b, c, d, a, x[k + 8], S24, 0x455A14ED);
                md5_GG(ref a, b, c, d, x[k + 13], S21, 0xA9E3E905);
                md5_GG(ref d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
                md5_GG(ref c, d, a, b, x[k + 7], S23, 0x676F02D9);
                md5_GG(ref b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
                md5_HH(ref a, b, c, d, x[k + 5], S31, 0xFFFA3942);  // 3750198684 2314002400 1089690627 990001115 0 4 -> 2749600077
                md5_HH(ref d, a, b, c, x[k + 8], S32, 0x8771F681);  // 990001115
                md5_HH(ref c, d, a, b, x[k + 11], S33, 0x6D9D6122); // 1089690627
                md5_HH(ref b, c, d, a, x[k + 14], S34, 0xFDE5380C); // 2314002400
                md5_HH(ref a, b, c, d, x[k + 1], S31, 0xA4BEEA44);  // 555633090
                md5_HH(ref d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
                md5_HH(ref c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
                md5_HH(ref b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
                md5_HH(ref a, b, c, d, x[k + 13], S31, 0x289B7EC6);
                md5_HH(ref d, a, b, c, x[k + 0], S32, 0xEAA127FA);
                md5_HH(ref c, d, a, b, x[k + 3], S33, 0xD4EF3085);
                md5_HH(ref b, c, d, a, x[k + 6], S34, 0x4881D05);
                md5_HH(ref a, b, c, d, x[k + 9], S31, 0xD9D4D039);
                md5_HH(ref d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
                md5_HH(ref c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
                md5_HH(ref b, c, d, a, x[k + 2], S34, 0xC4AC5665);  // 1444303940


                md5_II(ref a, b, c, d, x[k + 0], S41, 0xF4292244);  // 808311156
                md5_II(ref d, a, b, c, x[k + 7], S42, 0x432AFF97);

                md5_II(ref c, d, a, b, x[k + 14], S43, 0xAB9423A7);
                md5_II(ref b, c, d, a, x[k + 5], S44, 0xFC93A039);

                md5_II(ref a, b, c, d, x[k + 12], S41, 0x655B59C3);
                md5_II(ref d, a, b, c, x[k + 3], S42, 0x8F0CCC92);

                md5_II(ref c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
                md5_II(ref b, c, d, a, x[k + 1], S44, 0x85845DD1);

                md5_II(ref a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
                md5_II(ref d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);

                md5_II(ref c, d, a, b, x[k + 6], S43, 0xA3014314);
                md5_II(ref b, c, d, a, x[k + 13], S44, 0x4E0811A1);

                md5_II(ref a, b, c, d, x[k + 4], S41, 0xF7537E82);
                md5_II(ref d, a, b, c, x[k + 11], S42, 0xBD3AF235);
                md5_II(ref c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
                md5_II(ref b, c, d, a, x[k + 9], S44, 0xEB86D391);  // 4120542881
                // 350508294 4283343851 1846584438 1917254355
                a = a + AA; //3844921825
                b = b + BB;
                c = c + CC;
                d = d + DD;
            }

            string MD5 = RHex(a) + RHex(b) + RHex(c) + RHex(d);

            //uint time2 = DateTime.Now.Ticks;
            //MessageBox.Show("MD5計算耗時：" + ((time2 - time1) / 10000000f) + "秒");

            return MD5;
        }

        #endregion

    }
}

C# 可逆加解密演算法

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace EmptyProjec

C#/JAVA/PHP 互通DES加解密演算法(ECB模式支援8位)

import java.io.BufferedReader; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.UnsupportedEncodingE

3DES加解密演算法

在日常設計及開發中，為確保資料傳輸和資料儲存的安全，可通過特定的演算法，將資料明文加密成複雜的密文。目前主流加密手段大致可分為單向加密和雙向加密。單向加密：通過對資料進行摘要計算生成密文，密文不可逆推還原。演算法代表：Base64，MD5，SHA; 雙向加密：與單向加密相

一個php可逆加解密

<?php //加密解密函式 function authcode($string, $operation = 'DECODE', $key = 'dhyuerwbcytwbzghn', $expiry = 0) { // 動態密匙長度，相同的明文會生成不同密文就是依靠動態密匙

C# DES加解密

Key為八位字串 /// <summary> /// DES加密字串 /// </summary> /// <param name="pToEncrypt">待加密的字串</param> /// <param name="sKey"&

使用python實現RSA加解密演算法(包含讀取檔案操作),檔案內容為16進位制字串,同時實現對學號姓名的加密——(SCU應用密碼學實驗)

#-*- coding：UTF-8 -*- ''' time: 2018-5-30 content:RSA python 3.6 mac os ''' from random import randint import random im

java-socket簡單程式設計（socket C/S加解密）

好久沒更新部落格了，最近在幫老師整理專案，本來對socket接觸的不多。本次不多說廢話，直接說專案專案要求：1.實現服務端和客戶端的傳輸檔案加解密，我這邊實現的是服務端傳輸加密後的檔案，客戶端收到檔案後解密，為了展示方便，我此次採用了AES加密方式，填充方式採用AES/C

CryptoJS與C#AES加解密互轉

頁面js引用： <script type="text/javascript" src="/content/plugin/CryptoJSv3.1.2/components/core-min.js"></script> <scrip

Java C#相互加解密

因業務需求，需要使用AES加密演算法對傳輸資料進行加密解密操作。一端使用C#，一端使用Java，由於第一次接觸C#，在搜尋C#的AES演算法中是在痛苦從網頁到github。。。昨晚找到一點終於找到一個可以使用的。 Java import org.apache.

安全體系（零）—— 加解密演算法、訊息摘要、訊息認證技術、數字簽名與公鑰證書

鋒影 email:[email protected] 如果你認為本系列文章對你有所幫助，請大家有錢的捧個錢場，點選此處贊助，贊助額0.1元起步，多少隨意本文講解對稱加密、非對稱加密、訊息摘要、MAC、數字簽名、公鑰證書的用途、不足和解決的問題。 0.概

【JAVA】常用加解密演算法總結及JAVA實現【BASE64,MD5,SHA,DES,3DES,AES,RSA】

BASE64 這其實是一種編解碼方法，但是隻要我們能夠將原文變成肉眼不可識別的內容，其實就是一種加密的方法。 BASE64 的編碼都是按字串長度，以每 3 個 8 bit 的字元為一組，然後針對每組，首先獲取每個字元的 ASCII 編碼，然後將 ASCII 編碼轉換成 8

C# RSA加解密和MD5加密

ntc new .get sas byte style i++ locks mba 1.RSA加密 /// <summary> /// 加密處理 /// </summary> /// <pa

RSA非對稱加解密演算法的使用

加密金鑰和解密金鑰相同時則稱為對稱加密。由於加密金鑰和解密金鑰相同，它們也被稱為Shared Key。如AES等。加密金鑰（公鑰）和解密金鑰（私鑰）不相同時則稱為非對稱加密，別稱公鑰密碼。如RSA等。非對稱加密例子：假設張三擁有的公鑰Pu和私鑰Pr，其公鑰是公開的，誰

Java☞DES加解密演算法簡介及實現

Java加密解密之對稱加密演算法DES 　　資料加密演算法（Data Encryption Algorithm，DEA）是一種對稱加密演算法，很可能是使用最廣泛的金鑰系統，特別是在保護金融資料的安全中，最初開發的DEA是嵌入硬體中的。通常，自動取款機（Aut

Crypto++ 加/解密演算法庫

編譯 Crypto++ cryptlib 適合VC6 VC7 VC8 VC9 VC10 Crypto++ Library is a free C++ class library of cryptographic schemes. 可以到下面的網址下載最新原始碼： Cry

常見加解密演算法及opensll的使用

上篇寫了關於jni的使用blog，本文主要在於使用c++實現一些加解密演算法，然後供android開發使用；首先補充加解密的知識及基本概念對稱加密VS非對稱加密、公鑰VS私鑰、簽名/驗證、資訊摘要公鑰加密資料,然後私鑰解密的情況被稱為加密解密,私鑰加密資料,公鑰

PHP可逆加密解密演算法

對於大部分密碼加密，我們可以採用md5、sha1等方法。可以有效防止資料洩露，但是這些方法僅適用於無需還原的資料加密。對於需要還原的資訊，則需要採用可逆的加密解密演算法。下面一組PHP函式是實現此加密解密的方法：加密演算法如下： Php程式碼

C語言加密解密演算法

本文介紹了英文字串的加密、解密過程。是根據網上一篇部落格的題目重寫的程式。原文地址：http://blog.csdn.net/meditator_hkx/article/details/49445773 #include <stdio.h> #include&

密碼學之各種加解密演算法比較

對稱加密演算法對稱加密演算法用來對敏感資料等資訊進行加密，常用的演算法包括： DES（Data Encryption Standard）：資料加密標準，速度較快，適用於加密大量資料的場合。 3DES（Triple DES）：是基於DES，對一塊資料用三個不同的金鑰進行三次加密，強度更高。 AES（Adva

C# 3DES加密解密演算法

using System; using System.Collections.Generic; using System.Text; using System.Security.Cryptography; using System.IO; namespace C

C# 可逆加解密演算法

相關推薦