亚洲激情专区-91九色丨porny丨老师-久久久久久久女国产乱让韩-国产精品午夜小视频观看

溫馨提示×

溫馨提示×

您好，登錄后才能下訂單哦！

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

Tea加密算法和XxTea加密算法

發布時間：2020-06-21 16:47:55 來源：網絡 閱讀：4027 作者：linzheng 欄目：開發技術

TEA（Tiny Encryption Algorithm）是一種小型的對稱加密解密算法，支持128位密碼，與BlowFish一樣TEA每次只能加密/解密8字節數據。TEA特點是速度快、效率高，實現也非常簡單。由于針對TEA的***不斷出現，所以TEA也發展出幾個版本，分別是XTEA、Block TEA和XXTEA。

TEA加密和解密時都使用一個常量值，這個常量值為0x9e3779b，這個值是近似黃金分割率，注意，有些編程人員為了避免在程序中直接出現"mov 變量，0x9e3779b"，以免被破解者直接搜索0x9e3779b這個常數得知使用TEA算法，所以有時會使用"sub 變量，0x61C88647"代替"mov 變量，0x9e3779b"，0x61C88647=－(0x9e3779b)。

TEA算法每一次可以操作64bit(8byte)，采用128bit(16byte)作為key，算法采用迭代的形式，推薦的迭代輪數是64輪，最少32輪。

標準的16輪運算TEA，如果要改成標準的32輪運算TEA，只需修改code和decode中的n為32，并將decode中的delta左移4位改成左移5位即可。

C#的實現代碼：

 

  1. public static class Tea  
  2.     {  
  3.  
  4.         public static byte[] Encrypt(byte[] data, byte[] key)  
  5.         {  
  6.  
  7.             byte[] dataBytes;  
  8.             if (data.Length % 2 == 0)  
  9.             {  
  10.                 datadataBytes = data;  
  11.  
  12.             }  
  13.             else  
  14.             {  
  15.                 dataBytes = new byte[data.Length + 1];  
  16.                 Array.Copy(data, 0, dataBytes, 0, data.Length);  
  17.                 dataBytes[data.Length] = 0x0;  
  18.  
  19.             }  
  20.             byte[] result = new byte[dataBytes.Length * 4];  
  21.             uint[] formattedKey = FormatKey(key);  
  22.             uint[] tempData = new uint[2];  
  23.             for (int i = 0; i < dataBytes.Length; i += 2)  
  24.             {  
  25.                 tempData[0] = dataBytes[i];  
  26.                 tempData[1] = dataBytes[i + 1];  
  27.                 code(tempData, formattedKey);  
  28.                 Array.Copy(ConvertUIntToByteArray(tempData[0]), 0, result, i * 4, 4);  
  29.                 Array.Copy(ConvertUIntToByteArray(tempData[1]), 0, result, i * 4 + 4, 4);  
  30.             }  
  31.             return result;  
  32.         }  
  33.  
  34.         public static byte[] Decrypt(byte[] data, byte[] key)  
  35.         {  
  36.             uint[] formattedKey = FormatKey(key);  
  37.             int x = 0;  
  38.             uint[] tempData = new uint[2];  
  39.             byte[] dataBytes = new byte[data.Length / 8 * 2];  
  40.             for (int i = 0; i < data.Length; i += 8)  
  41.             {  
  42.                 tempData[0] = ConvertByteArrayToUInt(data, i);  
  43.                 tempData[1] = ConvertByteArrayToUInt(data, i + 4);  
  44.                 decode(tempData, formattedKey);  
  45.                 dataBytes[x++] = (byte)tempData[0];  
  46.                 dataBytes[x++] = (byte)tempData[1];  
  47.             }  
  48.             //修剪添加的空字符  
  49.             if (dataBytes[dataBytes.Length - 1] == 0x0)  
  50.             {  
  51.                 byte[] result = new byte[dataBytes.Length - 1];  
  52.                 Array.Copy(dataBytes, 0, result, 0, dataBytes.Length - 1);  
  53.             }  
  54.             return dataBytes;  
  55.  
  56.         }  
  57.  
  58.         static uint[] FormatKey(byte[] key)  
  59.         {  
  60.             if (key.Length == 0)  
  61.                 throw new ArgumentException("Key must be between 1 and 16 characters in length");  
  62.             byte[] refineKey = new byte[16];  
  63.             if (key.Length < 16)  
  64.             {  
  65.                 Array.Copy(key, 0, refineKey, 0, key.Length);  
  66.                 for (int k = key.Length; k < 16; k++)  
  67.                 {  
  68.                     refineKey[k] = 0x20;  
  69.                 }  
  70.             }  
  71.             else  
  72.             {  
  73.                 Array.Copy(key, 0, refineKey, 0, 16);  
  74.             }  
  75.             uint[] formattedKey = new uint[4];  
  76.             int j = 0;  
  77.             for (int i = 0; i < refineKey.Length; i += 4)  
  78.                 formattedKey[j++] = ConvertByteArrayToUInt(refineKey, i);  
  79.             return formattedKey;  
  80.         }  
  81.         #region Tea Algorithm  
  82.         static void code(uint[] v, uint[] k)  
  83.         {  
  84.             uint y = v[0];  
  85.             uint z = v[1];  
  86.             uint sum = 0;  
  87.             uint delta = 0x9e3779b9;  
  88.             uint n = 16;  
  89.             while (n-- > 0)  
  90.             {  
  91.                 sum += delta;  
  92.                 y += (z << 4) + k[0] ^ z + sum ^ (z >> 5) + k[1];  
  93.                 z += (y << 4) + k[2] ^ y + sum ^ (y >> 5) + k[3];  
  94.             }  
  95.             v[0] = y;  
  96.             v[1] = z;  
  97.         }  
  98.  
  99.         static void decode(uint[] v, uint[] k)  
  100.         {  
  101.             uint n = 16;  
  102.             uint sum;  
  103.             uint y = v[0];  
  104.             uint z = v[1];  
  105.             uint delta = 0x9e3779b9;  
  106.             /*  
  107.             * 由于進行16輪運算，所以將delta左移4位，減16次后剛好為0.  
  108.             */  
  109.             sum = delta << 4;  
  110.             while (n-- > 0)  
  111.             {  
  112.                 z -= (y << 4) + k[2] ^ y + sum ^ (y >> 5) + k[3];  
  113.                 y -= (z << 4) + k[0] ^ z + sum ^ (z >> 5) + k[1];  
  114.                 sum -= delta;  
  115.             }  
  116.             v[0] = y;  
  117.             v[1] = z;  
  118.         }  
  119.         #endregion  
  120.  
  121.         private static byte[] ConvertUIntToByteArray(uint v)  
  122.         {  
  123.             byte[] result = new byte[4];  
  124.             result[0] = (byte)(v & 0xFF);  
  125.             result[1] = (byte)((v >> 8) & 0xFF);  
  126.             result[2] = (byte)((v >> 16) & 0xFF);  
  127.             result[3] = (byte)((v >> 24) & 0xFF);  
  128.             return result;  
  129.         }  
  130.  
  131.         private static uint ConvertByteArrayToUInt(byte[] v, int offset)  
  132.         {  
  133.             if (offset + 4 > v.Length) return 0;  
  134.             uint output;  
  135.             output = (uint)v[offset];  
  136.             output |= (uint)(v[offset + 1] << 8);  
  137.             output |= (uint)(v[offset + 2] << 16);  
  138.             output |= (uint)(v[offset + 3] << 24);  
  139.             return output;  
  140.         }  
  141.     } 

 XTEA 跟 TEA 使用了相同的簡單運算，但它采用了截然不同的順序，為了阻止密鑰表***，四個子密鑰（在加密過程中，原 128 位的密鑰被拆分為 4 個 32 位的子密鑰）采用了一種不太正規的方式進行混合，但速度更慢了。在跟描述 XTEA 算法的同一份報告中，還介紹了另外一種被稱為 Block TEA 算法的變種，它可以對 32 位大小任意倍數的變量塊進行操作。該算法將 XTEA 輪循函數依次應用于塊中的每個字，并且將它附加于它的鄰字。該操作重復多少輪依賴于塊的大小，但至少需要 6 輪。該方法的優勢在于它無需操作模式（CBC，OFB，CFB 等），密鑰可直接用于信息。對于長的信息它可能比 XTEA 更有效率。在 1998 年，Markku-Juhani Saarinen 給出了一個可有效*** Block TEA 算法的代碼，但之后很快 David J. Wheeler 和 Roger M. Needham 就給出了 Block TEA 算法的修訂版，這個算法被稱為 XXTEA。XXTEA 使用跟 Block TEA 相似的結構，但在處理塊中每個字時利用了相鄰字。它利用一個更復雜的 MX 函數代替了 XTEA 輪循函數，MX 使用 2 個輸入量。

 如果加密字符串長度不是 4 的整數倍，則這些實現的在加密后無法真正還原，還原以后的字符串實際上與原字符串不相等，而是后面多了一些 \0 的字符，或者少了一些 \0 的字符。原因在于 XXTEA 算法只定義了如何對 32 位的信息塊數組（實際上是 32 位無符號整數數組）進行加密，而并沒有定義如何來將字符串編碼為這種數組。而現有的實現中在將字符串編碼為整數數組時，都丟失了字符串長度信息，因此還原出現了問題。
C#的實現代碼
  1. using System;  
  2.  
  3. class XXTEA  
  4. {  
  5.     public static Byte[] Encrypt(Byte[] Data, Byte[] Key)  
  6.     {  
  7.         if (Data.Length == 0)  
  8.         {  
  9.             return Data;  
  10.         }  
  11.         return ToByteArray(Encrypt(ToUInt32Array(Data, true), ToUInt32Array(Key, false)), false);  
  12.     }  
  13.     public static Byte[] Decrypt(Byte[] Data, Byte[] Key)  
  14.     {  
  15.         if (Data.Length == 0)  
  16.         {  
  17.             return Data;  
  18.         }  
  19.         return ToByteArray(Decrypt(ToUInt32Array(Data, false), ToUInt32Array(Key, false)), true);  
  20.     }  
  21.  
  22.     public static UInt32[] Encrypt(UInt32[] v, UInt32[] k)  
  23.     {  
  24.         Int32 n = v.Length - 1;  
  25.         if (n < 1)  
  26.         {  
  27.             return v;  
  28.         }  
  29.         if (k.Length < 4)  
  30.         {  
  31.             UInt32[] Key = new UInt32[4];  
  32.             k.CopyTo(Key, 0);  
  33.             k = Key;  
  34.         }  
  35.         UInt32 z = v[n], y = v[0], delta = 0x9E3779B9, sum = 0, e;  
  36.         Int32 p, q = 6 + 52 / (n + 1);  
  37.         while (q-- > 0)  
  38.         {  
  39.             sum = unchecked(sum + delta);  
  40.             e = sum >> 2 & 3;  
  41.             for (p = 0; p < n; p++)  
  42.             {  
  43.                 y = v[p + 1];  
  44.                 z = unchecked(v[p] += (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z));  
  45.             }  
  46.             y = v[0];  
  47.             z = unchecked(v[n] += (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z));  
  48.         }  
  49.         return v;  
  50.     }  
  51.     public static UInt32[] Decrypt(UInt32[] v, UInt32[] k)  
  52.     {  
  53.         Int32 n = v.Length - 1;  
  54.         if (n < 1)  
  55.         {  
  56.             return v;  
  57.         }  
  58.         if (k.Length < 4)  
  59.         {  
  60.             UInt32[] Key = new UInt32[4];  
  61.             k.CopyTo(Key, 0);  
  62.             k = Key;  
  63.         }  
  64.         UInt32 z = v[n], y = v[0], delta = 0x9E3779B9, sum, e;  
  65.         Int32 p, q = 6 + 52 / (n + 1);  
  66.         sum = unchecked((UInt32)(q * delta));  
  67.         while (sum != 0)  
  68.         {  
  69.             e = sum >> 2 & 3;  
  70.             for (p = n; p > 0; p--)  
  71.             {  
  72.                 z = v[p - 1];  
  73.                 y = unchecked(v[p] -= (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z));  
  74.             }  
  75.             z = v[n];  
  76.             y = unchecked(v[0] -= (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z));  
  77.             sum = unchecked(sum - delta);  
  78.         }  
  79.         return v;  
  80.     }  
  81.     private static UInt32[] ToUInt32Array(Byte[] Data, Boolean IncludeLength)  
  82.     {  
  83.         Int32 n = (((Data.Length & 3) == 0) ? (Data.Length >> 2) : ((Data.Length >> 2) + 1));  
  84.         UInt32[] Result;  
  85.         if (IncludeLength)  
  86.         {  
  87.             Result = new UInt32[n + 1];  
  88.             Result[n] = (UInt32)Data.Length;  
  89.         }  
  90.         else  
  91.         {  
  92.             Result = new UInt32[n];  
  93.         }  
  94.         n = Data.Length;  
  95.         for (Int32 i = 0; i < n; i++)  
  96.         {  
  97.             Result[i >> 2] |= (UInt32)Data[i] << ((i & 3) << 3);  
  98.         }  
  99.         return Result;  
  100.     }  
  101.     private static Byte[] ToByteArray(UInt32[] Data, Boolean IncludeLength)  
  102.     {  
  103.         Int32 n;  
  104.         if (IncludeLength)  
  105.         {  
  106.             n = (Int32)Data[Data.Length - 1];  
  107.         }  
  108.         else  
  109.         {  
  110.             n = Data.Length << 2;  
  111.         }  
  112.         Byte[] Result = new Byte[n];  
  113.         for (Int32 i = 0; i < n; i++)  
  114.         {  
  115.             Result[i] = (Byte)(Data[i >> 2] >> ((i & 3) << 3));  
  116.         }  
  117.         return Result;  
  118.     }  
  119. } 

 

向AI問一下細節

免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。

AI
助
手
昂仁县| 册亨县| 珠海市| 连城县| 鹤岗市| 长寿区| 龙山县| 延寿县| 定结县| 塔河县| 沙坪坝区| 阿尔山市| 威宁| 明光市| 玉树县| 金坛市| 平阴县| 青龙| 安国市| 苍南县| 辽中县| 泰安市| 开封县| 黄冈市| 安阳市| 伊春市| 荃湾区| 马尔康县| 陇川县| 淮阳县| 庆安县| 漳平市| 陵水| 苍溪县| 绍兴县| 固原市| 年辖：市辖区| 黑龙江省| 红河县| 辉南县| 垫江县|