Unity程序做一个授权认证的功能

首先要导入3个类型转换的扩展类文件

代码如下：

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using Newtonsoft.Json;

namespace EH.Extend
{
    /// <summary>
    /// byte[] 扩展
    /// </summary>
    public static class EBytes
    {
        /// <summary>
        /// 二进制数组转为16进制字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static string ToHex(this byte[] bytes)
        {
            if (bytes == null)
            {
                return "";
            }

            var sb = new StringBuilder();
            foreach (var b in bytes)
            {
                sb.Append(b.ToString("X2"));
            }

            return sb.ToString();
        }

        /// <summary>
        /// 字节数组数组转布尔数组
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static bool[] ToBits(this byte[] bytes)
        {
            var bits = new bool[bytes.Length * 8];
            for (var i = 0; i < bytes.Length; i++)
            {
                var bools = bytes[i].ToBits();
                Array.Copy(bools, 0, bits, i * 8, 8);
            }

            return bits;
        }

        /// <summary>
        /// 字节数组转UTF8字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static string ToUTF8(this byte[] bytes)
        {
            return Encoding.UTF8.GetString(bytes);
        }
        /// <summary>
        /// 字节数组转UTF8字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="offset"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string ToUTF8(this byte[] bytes, int offset, int length)
        {
            return Encoding.UTF8.GetString(bytes, offset, length);
        }

        /// <summary>
        /// 字节数组转UTF8字符串,再通过JsonConvert转泛型对象实例
        /// </summary>
        /// <param name="bytes"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static T To<T>(this byte[] bytes)
        {
            var str = bytes.ToUTF8();
            try
            {
                return JsonConvert.DeserializeObject<T>(str);
            }
            catch (Exception e)
            {
               
                return default(T);
            }
        }
        /// <summary>
        /// 字节数组转UTF8字符串,再通过JsonConvert转泛型对象实例
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="offset"></param>
        /// <param name="length"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static T To<T>(this byte[] bytes, int offset, int length)
        {
            var str = bytes.ToUTF8(offset, length);
            try
            {
                return JsonConvert.DeserializeObject<T>(str);
            }
            catch (Exception e)
            {
                
                return default;
            }
        }

        /// <summary>
        /// 字节数组转UTF8字符串,再通过JsonConvert转类型实例
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="offset"></param>
        /// <param name="length"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static object To(this byte[] bytes, int offset, int length, Type type)
        {
            var str = bytes.ToUTF8(offset, length);
            try
            {
                return JsonConvert.DeserializeObject(str, type);
            }
            catch (Exception e)
            {
                
                return null;
            }
        }

        /// <summary>
        /// 字节数组小尾读取指定长度的整型
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static int ReadIntLE(this byte[] bytes, int length)
        {
            var count = 0;
            var val = 0;
            for (var i = length - 1; i > -1; i--)
            {
                val |= bytes[i] << (8 * count++);
            }

            return val;
        }

        /// <summary>
        /// 字节数组小尾写入指定长度的整型
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="val"></param>
        /// <param name="length"></param>
        public static void WriteIntLE(this byte[] bytes, int val, int length)
        {
            var count = 0;
            for (var i = length - 1; i > -1; i--)
            {
                bytes[i] = (byte) (val >> (8 * count++));
            }
        }

        /// <summary>
        /// 字节数组Aes加密
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="Key"></param>
        /// <param name="iv"></param>
        /// <returns></returns>
        public static byte[] AesEncrypt(this byte[] bytes, byte[] Key, byte[] iv)
        {
            byte[] encrypted;
            var len = Key.Length;
            if (len < 32)
            {
                var k = new byte[32];
                Array.Copy(Key, k, len);
                Key = k;
            }

            len = iv.Length;
            if (len < 16)
            {
                var i = new byte[16];
                Array.Copy(iv, i, len);
                iv = i;
            }

            using (var aesAlg = Aes.Create())
            {
                aesAlg.Key = Key;
                aesAlg.IV = iv;

                var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

    &n