分布式服务器框架之Server.Core库中实现 XXTEA分组加密算法

简介: 在密码学中,微型加密算法(Tiny Encryption Algorithm,TEA)是一种易于描述和执行的块密码,通常只需要很少的代码就可实现。其设计者是剑桥大学计算机实验室的大卫·惠勒与罗杰·尼达姆。这项技术最初于1994年提交给鲁汶的快速软件加密的研讨会上,并在该研讨会上演讲中首次发表。

1 XXTEA分组加密算法介绍


在密码学中,微型加密算法(Tiny Encryption Algorithm,TEA)是一种易于描述和执行的块密码,通常只需要很少的代码就可实现。其设计者是剑桥大学计算机实验室的大卫·惠勒与罗杰·尼达姆。这项技术最初于1994年提交给鲁汶的快速软件加密的研讨会上,并在该研讨会上演讲中首次发表。


在给出的代码中:加密使用的数据为2个32位无符号整数,密钥为4个32位无符号整数即密钥长度为128位


XTEA是TEA的升级版,增加了更多的密钥表,移位和异或操作等等。


XXTEA,又称Corrected Block TEA,又是XTEA的升级版 。目前XXTEA还暂未被破解。


XXTEA加密算法比较复杂,如果要彻底理解得把引用链接里给出的公式吃透差不多才能理解,这里面又涉及密码学和数学的很多知识,读者实在看不懂也没关系,直接拿去用就行,知道怎么用就可以了。


2 代码实现


XXTEAUtil.cs代码实现


using System;
using System.Collections.Generic;
using System.Text;
namespace Servers.Core.Utils
{
    public static class XXTEAUtil
    {
        public static readonly byte[] SoketKey = { 102, 120, 22, 24, 88, 6, 119, 88 };
        private static int RightMove(this int value, int pos)
        {
            if (pos != 0)
            {
                // int.MaxValue = 0x7FFFFFFF 整数最大值
                int mask = int.MaxValue;
                //无符号整数最高位不表示正负但操作数还是有符号的,有符号数右移1位,正数时高位补0,负数时高位补1
                value = value >> 1;
                //和整数最大值进行逻辑与运算,运算后的结果为忽略表示正负值的最高位
                value = value & mask;
                //逻辑运算后的值无符号,对无符号的值直接做右移运算,计算剩下的位
                value = value >> pos - 1;
            }
            return value;
        }
        private static int[] ToIntArray(byte[] data, bool includeLenth)
        {
            int n = (data.Length & 3) == 0 ? (data.Length.RightMove(2)) : (data.Length.RightMove(3)) + 1;
            int[] result;
            if (includeLenth)
            {
                result = new int[n + 1];
                result[n] = data.Length;
            }
            else
            {
                result = new int[n];
            }
            n = data.Length;
            for (int i = 0; i < n; ++i)
            {
                result[i.RightMove(2)] |= (0x000000ff & data[i]) << ((i & 3) << 3);
            }
            return result;
        }
        public static byte[] ToByteArray(int[] data, bool includeLength)
        {
            int n = data.Length << 2;
            if (includeLength)
            {
                int m = data[^1];
                if (m > n)
                {
                    return null;
                }
                else
                {
                    n = m;
                }
            }
            byte[] result = new byte[n];
            for (int i = 0; i < n; ++i)
            {
                result[i] = (byte)((data[i.RightMove(2)].RightMove((i & 3) << 3)) & 0xff);
            }
            return result;
        }
        //加密
        private static int[] Encrypt(int[] v, int[] k)
        {
            int n = v.Length - 1;
            if (n < 1)
                return v;
            if (k.Length < 4)
            {
                int[] key = new int[4];
                System.Array.Copy(k, 0, key, 0, k.Length);
                k = key;
            }
            int z = v[n], y = v[0];
            int delta = -1640531527;
            int sum = 0, e;
            int p, q = 6 + 52 / (n + 1); ;
            while (q-- > 0)
            {
                sum = (int)(sum + delta);
                e = sum.RightMove(2) & 3;
                for (p = 0; p < n; p++)
                {
                    y = v[p + 1];
                    z = v[p] += (z.RightMove(5) ^ y << 2) + (y.RightMove(3) ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
                }
                y = v[0];
                z = v[n] += (z.RightMove(5) ^ y << 2) + (y.RightMove(3) ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
            }
            return v;
        }
        //解密
        private static int[] Decrypt(int[] v, int[] k)
        {
            int n = v.Length - 1;
            if (n < 1)
            {
                return v;
            }
            if (k.Length < 4)
            {
                int[] key = new int[4];
                System.Array.Copy(k, 0, key, 0, k.Length);
                k = key;
            }
            int z = v[n], y = v[0], delta = -1640531527, sum, e;
            int p, q = 6 + 52 / (n + 1);
            sum = q * delta;
            while (sum != 0)
            {
                e = sum.RightMove(2) & 3;
                for (p = n; p > 0; p--)
                {
                    z = v[p - 1];
                    y = v[p] -= (z.RightMove(5) ^ y << 2) + (y.RightMove(3) ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
                }
                z = v[n];
                y = v[0] -= (z.RightMove(5) ^ y << 2) + (y.RightMove(3) ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
                sum = sum - delta;
            }
            return v;
        }
        public static string Base64Encode(string data)
        {
            try
            {
                byte[] encodeDataByte = System.Text.Encoding.UTF8.GetBytes(data);
                string encodeData = Convert.ToBase64String(encodeDataByte);
                return encodeData;
            }
            catch (Exception e)
            {
                throw new Exception("Error in base64Encode" + e.Message);
            }
        }
        public static string Base64Decode(string data)
        {
            try
            {
                byte[] toDecodeDataByte = Convert.FromBase64String(data);
                return System.Text.Encoding.UTF8.GetString(toDecodeDataByte);
            }
            catch (Exception e)
            {
                throw new Exception("Error in base64Decode" + e.Message);
            }
        }
        //byte数组 加密
        public static byte[] Encrypt(byte[] data)
        {
            if (null == data || data.Length == 0)
                return data;
            return ToByteArray(Encrypt(ToIntArray(data, true), ToIntArray(SoketKey, false)), false);
        }
        //bute数组 解密
        public static byte[] Decrypt(byte[] data)
        {
            if (null == data || data.Length == 0)
                return data;
            return ToByteArray(Decrypt(ToIntArray(data, false), ToIntArray(SoketKey, false)), true);
        }
        //字符串加密
        public static string Encrypt(string source,string key)
        {
            System.Text.Encoding encoder = System.Text.Encoding.UTF8;
            byte[] bytData = encoder.GetBytes(source);
            byte[] bytKey = encoder.GetBytes(key);
            if (bytData.Length == 0)
                return "";
            return Convert.ToBase64String(
                ToByteArray(Encrypt(ToIntArray(bytData, true), ToIntArray(bytKey, false)), false)
                ) ;
        }
        //字符串解密
        public static string Decrypt(string source, string key)
        {
            if (source.Length == 0)
                return "";
            System.Text.Encoding encoder = System.Text.Encoding.UTF8;
            byte[] bytData = Convert.FromBase64String(source);
            byte[] bytKey = encoder.GetBytes(key);
            return encoder.GetString(
                ToByteArray(Decrypt(ToIntArray(bytData, false), ToIntArray(bytKey, false)), true)
                );
        }
    }
}


3 参考资料


参考链接:https://blog.csdn.net/gsls200808/article/details/48243019

相关文章
|
10天前
|
负载均衡 算法 调度
基于遗传算法的新的异构分布式系统任务调度算法研究(Matlab代码实现)
基于遗传算法的新的异构分布式系统任务调度算法研究(Matlab代码实现)
82 11
|
23天前
|
算法 安全 Python
【顶级EI复现】分布式电源选址定容的多目标优化算法(Matlab代码实现)
【顶级EI复现】分布式电源选址定容的多目标优化算法(Matlab代码实现)
|
29天前
|
传感器 机器学习/深度学习 算法
【无人机编队】基于麻雀算法分布式无人机群自适应航迹规划和碰撞检测研究(Matlab代码实现)
【无人机编队】基于麻雀算法分布式无人机群自适应航迹规划和碰撞检测研究(Matlab代码实现)
|
11天前
|
并行计算 算法 调度
基于串行并行ADMM算法的主从配电网分布式优化控制研究(Matlab代码实现)
基于串行并行ADMM算法的主从配电网分布式优化控制研究(Matlab代码实现)
|
13天前
|
并行计算 算法 安全
【ADMM、碳排放】基于分布式ADMM算法的考虑碳排放交易的电力系统优化调度研究【IEEE6节点、IEEE30节点、IEEE118节点】(Matlab代码实现)
【ADMM、碳排放】基于分布式ADMM算法的考虑碳排放交易的电力系统优化调度研究【IEEE6节点、IEEE30节点、IEEE118节点】(Matlab代码实现)
|
2月前
|
运维 算法 5G
【优化管理】基于事件触发的弹性分布式能源管理算法研究(Matlab代码实现)
【优化管理】基于事件触发的弹性分布式能源管理算法研究(Matlab代码实现)
|
5月前
|
NoSQL 算法 安全
分布式锁—1.原理算法和使用建议
本文主要探讨了Redis分布式锁的八大问题,包括非原子操作、忘记释放锁、释放其他线程的锁、加锁失败处理、锁重入问题、锁竞争问题、锁超时失效及主从复制问题,并提供了相应的优化措施。接着分析了Redis的RedLock算法,讨论其优缺点以及分布式专家Martin对其的质疑。此外,文章对比了基于Redis和Zookeeper(zk)的分布式锁实现原理,包括获取与释放锁的具体流程。最后总结了两种分布式锁的适用场景及使用建议,指出Redis分布式锁虽有性能优势但模型不够健壮,而zk分布式锁更稳定但部署成本较高。实际应用中需根据业务需求权衡选择。
|
8月前
|
运维 NoSQL 算法
【📕分布式锁通关指南 04】redis分布式锁的细节问题以及RedLock算法原理
本文深入探讨了基于Redis实现分布式锁时遇到的细节问题及解决方案。首先,针对锁续期问题,提出了通过独立服务、获取锁进程自己续期和异步线程三种方式,并详细介绍了如何利用Lua脚本和守护线程实现自动续期。接着,解决了锁阻塞问题,引入了带超时时间的`tryLock`机制,确保在高并发场景下不会无限等待锁。最后,作为知识扩展,讲解了RedLock算法原理及其在实际业务中的局限性。文章强调,在并发量不高的场景中手写分布式锁可行,但推荐使用更成熟的Redisson框架来实现分布式锁,以保证系统的稳定性和可靠性。
352 0
【📕分布式锁通关指南 04】redis分布式锁的细节问题以及RedLock算法原理
|
9月前
|
存储 人工智能 算法
解锁分布式文件分享的 Java 一致性哈希算法密码
在数字化时代,文件分享成为信息传播与协同办公的关键环节。本文深入探讨基于Java的一致性哈希算法,该算法通过引入虚拟节点和环形哈希空间,解决了传统哈希算法在分布式存储中的“哈希雪崩”问题,确保文件分配稳定高效。文章还展示了Java实现代码,并展望了其在未来文件分享技术中的应用前景,如结合AI优化节点布局和区块链增强数据安全。
|
10月前
|
运维 数据挖掘 索引
服务器数据恢复—Lustre分布式文件系统服务器数据恢复案例
5台节点服务器,每台节点服务器上有一组RAID5阵列。每组RAID5阵列上有6块硬盘(其中1块硬盘设置为热备盘,其他5块硬盘为数据盘)。上层系统环境为Lustre分布式文件系统。 机房天花板漏水导致这5台节点服务器进水,每台服务器都有至少2块硬盘出现故障。每台服务器中的RAID5阵列短时间内同时掉线2块或以上数量的硬盘,导致RAID崩溃,服务器中数据无法正常读取。

热门文章

最新文章