diff --git a/Infrastructure/Infrastructure.csproj b/Infrastructure/Infrastructure.csproj
index e8327bd..1e771a5 100644
--- a/Infrastructure/Infrastructure.csproj
+++ b/Infrastructure/Infrastructure.csproj
@@ -15,6 +15,7 @@
+
diff --git a/OpenAuth.Repository/Domain/LasaDronePort.cs b/OpenAuth.Repository/Domain/LasaDronePort.cs
index 7f7c7f2..0bc649f 100644
--- a/OpenAuth.Repository/Domain/LasaDronePort.cs
+++ b/OpenAuth.Repository/Domain/LasaDronePort.cs
@@ -1,4 +1,5 @@
-using SqlSugar;
+using NetTopologySuite.Geometries;
+using SqlSugar;
namespace OpenAuth.Repository.Domain
{
@@ -29,7 +30,7 @@ namespace OpenAuth.Repository.Domain
public string WorkSpaceId { get; set; }
public string GateWay { get; set; }
//
- public string WorkArea { get; set; }
+ public Geometry WorkArea { get; set; }
public int? Status { get; set; }
[Navigate(NavigateType.OneToMany, nameof(LasaUav.PId))]
diff --git a/OpenAuth.WebApi/Program.cs b/OpenAuth.WebApi/Program.cs
index 0071ec6..39ed263 100644
--- a/OpenAuth.WebApi/Program.cs
+++ b/OpenAuth.WebApi/Program.cs
@@ -1,9 +1,53 @@
-using Autofac.Extensions.DependencyInjection;
-using Autofac;
+using Autofac;
+using Autofac.Extensions.DependencyInjection;
+using HidSharp;
using OpenAuth.WebApi;
+using SoftKey;
var builder = WebApplication.CreateBuilder(args);
+/*
+var list = DeviceList.Local;
+var ytsoftkey = new F2K();
+list.Changed += (sender, args) =>
+{
+ if (ytsoftkey.CheckKeyByFindort_2() != 0)
+ {
+ Console.WriteLine(" 加密锁被拨出。");
+ throw new Exception("加密锁被拨出。");
+ }
+};
+
+
+String DevicePath = null;
+short verex = 0;
+short ver = 0;
+//这个用于判断系统中是否存在着加密锁。不需要是指定的加密锁,
+
+int ret = ytsoftkey.FindPort(0, ref DevicePath);
+if (ret != 0)
+{
+ throw new Exception("未找到加密锁,请插入加密锁后，再进行操作。");
+}
+
+// 从加密狗中读取密钥
+String str = "";
+byte[] length = new byte[1];
+ret = ytsoftkey.YRead(length, 0, 1, "E1930089", "C7326137", DevicePath);
+if (ret != 0)
+{
+ throw new Exception("读取加密狗数据失败1！");
+}
+
+ret = ytsoftkey.YReadString(ref str, 1, length[0], "E1930089", "C7326137", DevicePath);
+if (ret != 0)
+{
+ throw new Exception("读取加密狗数据失败2！");
+}
+
+Console.WriteLine("读取数据：" + str);
+*/
+
var startup = new Startup(builder.Configuration);
startup.ConfigureServices(builder.Services);
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
@@ -14,4 +58,4 @@ startup.Configure(app, app.Environment);
//var url = app.Configuration.GetValue("AppSetting:HttpHost");
//app.Urls.Add(url);
-app.Run();
+app.Run();
\ No newline at end of file
diff --git a/OpenAuth.WebApi/SoftKey.cs b/OpenAuth.WebApi/SoftKey.cs
new file mode 100644
index 0000000..250d4fb
--- /dev/null
+++ b/OpenAuth.WebApi/SoftKey.cs
@@ -0,0 +1,2640 @@
+using System;
+using System.Text;
+using System.IO;
+using HidSharp;
+using System.Linq;
+using System.Threading;
+using System.Runtime.InteropServices;
+
+//公共函数说明
+
+//***查找加密锁
+//int FindPort(int start, ref string OutKeyPath);
+
+//查找指定的加密锁(使用普通算法一)
+//int FindPort_2(int start, int in_data, int verf_data, ref string OutKeyPath);
+
+//***获到锁的版本
+//int NT_GetIDVersion(ref short version, string KeyPath);
+
+//获到锁的扩展版本
+//int NT_GetIDVersionEx(ref short version, string KeyPath);
+
+//***获到锁的ID
+//int GetID(ref int id_1, ref int id_2, string KeyPath);
+
+//***从加密锁中读取一批字节
+//int YReadEx(Byte[] OutData, short Address, short mylen, string HKey, string LKey, string KeyPath);
+
+//***从加密锁中读取一个字节数据，一般不使用
+//int YRead(ref Byte OutData, short Address,string HKey, string LKey, string KeyPath);
+
+//***写一批字节到加密锁中
+//int YWriteEx(Byte[] InData, short Address, short mylen, string HKey, string LKey, string KeyPath);
+
+//***写一个字节的数据到加密锁中，一般不使用
+//int YWrite(Byte InData, short Address, string HKey, string LKey, string KeyPath);
+
+//***从加密锁中读字符串
+//int YReadString(ref string outstring, short Address, short mylen, string HKey, string LKey, string KeyPath);
+
+//***写字符串到加密锁中
+//int YWriteString(string InString, short Address, string HKey, string LKey, string KeyPath);
+
+//***算法函数
+//int sWriteEx(int in_data , ref int out_data , string KeyPath);
+//int sWrite_2Ex(int in_data , ref int out_data ,string KeyPath);
+//int sRead(ref int in_data, string KeyPath);
+//int sWrite(int out_data, string KeyPath);
+//int sWrite_2(int out_data, string KeyPath);
+
+//***设置写密码
+//int SetWritePassword(string W_HKey, string W_LKey, string new_HKey, string new_LKey, string KeyPath);
+
+//***设置读密码
+//int SetReadPassword(string W_HKey, string W_LKey, string new_HKey, string new_LKey, string KeyPath);
+
+//'设置增强算法密钥一
+//int SetCal_2(string Key , string KeyPath);
+
+//使用增强算法一对字符串进行加密
+//int EncString(string InString , ref string outstring , string KeyPath);
+
+//使用增强算法一对二进制数据进行加密
+// int Cal(Byte[] InBuf, Byte[] OutBuf, string KeyPath);
+
+//'设置增强算法密钥二
+//int SetCal_New(string Key , string KeyPath);
+
+//使用增强算法二对字符串进行加密
+//int EncString_New(string InString , ref string outstring , string KeyPath);
+
+//使用增强算法二对二进制数据进行加密
+// int Cal_New(Byte[] InBuf, Byte[] OutBuf, string KeyPath);
+
+//***初始化加密锁函数
+//int ReSet( string Path);
+
+//***获取字符串长度
+//int lstrlenA(string InString );
+namespace SoftKey
+{
+ public class F2K
+ {
+ #region Fields
+
+ private const ushort VID = 0x3689;
+ private const ushort PID = 0x3689;
+ private const ushort PID_NEW = 0X4040;
+ private const ushort VID_NEW = 0X3689;
+ private const ushort PID_NEW_2 = 0X4040;
+ private const ushort VID_NEW_2 = 0X2020;
+ private const short DIGCF_PRESENT = 0x2;
+ private const short DIGCF_DEVICEINTERFACE = 0x10;
+ private const short INVALID_HANDLE_VALUE = (-1);
+ private const short ERROR_NO_MORE_ITEMS = 259;
+
+ private const uint GENERIC_READ = 0x80000000;
+ private const int GENERIC_WRITE = 0x40000000;
+ private const uint FILE_SHARE_READ = 0x1;
+ private const uint FILE_SHARE_WRITE = 0x2;
+ private const uint OPEN_EXISTING = 3;
+ private const uint FILE_ATTRIBUTE_NORMAL = 0x80;
+ private const uint INFINITE = 0xFFFF;
+
+ private const short MAX_LEN = 2031;
+
+ public const int FAILEDGENKEYPAIR = -21;
+ public const int FAILENC = -22;
+ public const int FAILDEC = -23;
+ public const int FAILPINPWD = -24;
+ public const int USBStatusFail = -50; //USB操作失败，可能是没有找到相关的指令
+ private const int FUNCTION_LENGTH_NAME_MORE_THEN_25 = -79;
+ private const int NOUSBKEY = -92;
+ private const int CANNOT_OPEN_BIN_FILE = -8017;
+ private const int CAN_NOT_READ_FILE = -8026;
+ private const int OVER_KEY_LEN = 8025;
+ private const int OVER_BIND_SIZE = -8035; //绑定电脑的数据超过最大绑定值
+
+
+ public const int SM2_ADDBYTE = 97; //加密后的数据会增加的长度
+ public const int MAX_ENCLEN = 128; //最大的加密长度分组
+ public const int MAX_DECLEN = (MAX_ENCLEN + SM2_ADDBYTE); //最大的解密长度分组
+ public const int SM2_USENAME_LEN = 80; // '最大的用户名长度
+
+
+ public const int ECC_MAXLEN = 32;
+ public const int PIN_LEN = 16;
+
+ private const Byte GETVERSION = 0x01;
+ private const Byte GETID = 0x02;
+ private const Byte GETVEREX = 0x05;
+ private const Byte CAL_TEA = 0x08;
+ private const Byte SET_TEAKEY = 0x09;
+ private const Byte READBYTE = 0x10;
+ private const Byte WRITEBYTE = 0x11;
+ private const Byte YTREADBUF = 0x12;
+ private const Byte YTWRITEBUF = 0x13;
+ private const Byte MYRESET = 0x20;
+ private const Byte YTREBOOT = 0x24;
+ private const Byte SET_ECC_PARA = 0x30;
+ private const Byte GET_ECC_PARA = 0x31;
+ private const Byte SET_ECC_KEY = 0x32;
+ private const Byte GET_ECC_KEY = 0x33;
+ private const Byte MYENC = 0x34;
+ private const Byte MYDEC = 0X35;
+ private const Byte SET_PIN = 0X36;
+ private const Byte GEN_KEYPAIR = 0x37;
+ private const Byte YTSIGN = 0x51;
+ private const Byte YTVERIFY = 0x52;
+ private const Byte GET_CHIPID = 0x53;
+
+ private const Byte YTSIGN_2 = 0x53;
+
+ //D8定义
+ private const Byte MAX_KEY_LEN = 16;
+ private const Byte MAX_FUNNAME = 25;
+ private const Byte MAX_BUF_SIZE = 255;
+ private const Byte DOWNLOAD_SIZE = (MAX_BUF_SIZE - 1 - 1 - 1); //一个字节长度，一个字节命令，一个字节报告
+ private const Byte TRANSFER_VAR_SIZE = (MAX_BUF_SIZE - 1 - 1 - 4); //一个字节长度，一个字节命令，一个字节报告,4个字节内存起始地址
+ private const Byte GETDATA_BUF_SIZE = (MAX_BUF_SIZE - 2 - 1 - 1); //2个字节错误码，1个字节长度是否完成，一个字节为多出来的
+ private const Byte VERF_CODE_SIZE = 8;
+ private const byte NEW_PWD_LEN = 9;
+
+ private const byte
+ NEW_EPROM_TRANSFER_SIZE =
+ (MAX_BUF_SIZE - (1 + 1 + sizeof(short) + 1 + 2 * NEW_PWD_LEN)); //一个字节报告,一个字节命令，二个字节地址，一个字节长度，2*9个字节密码，
+
+ private const Byte MAX_BIND_MAC_SIZE = 200;
+
+ private const Byte GET_LIMIT_DATE = 0x71;
+ private const Byte SET_LIMIT_DATE = 0x72;
+ private const Byte GET_USER_ID = 0x73;
+ private const Byte GET_LEAVE_NUMBER = 0x74;
+ private const Byte CHECK_NUMBER = 0x75;
+ private const Byte SET_NUMBER_AUTH = 0x76;
+ private const Byte SET_BIND_AUTH = 0x77;
+ private const Byte SET_DATE_AUTH = 0x78;
+ private const Byte CHECK_DATE = 0x79;
+ private const Byte CHECK_BIND = 0x7A;
+ private const Byte GET_LEAVE_DAYS = 0x7B;
+ private const Byte GET_BIND_INFO = 0x7C;
+ private const Byte YTDOWNLOAD = 0x80;
+ private const Byte START_DOWNLOAD = 0x81;
+ private const Byte RUN_FUNCTION = 0x82;
+ private const Byte SET_VAR = 0x84;
+ private const Byte GET_VAR = 0x85;
+ private const Byte SET_DOWNLOAD_KEY = 0x86;
+ private const Byte OPEN_KEY = 0x87;
+ private const Byte CLOSE_KEY = 0x88;
+ private const Byte COUNTINU_RUNCTION = 0x89;
+ private const Byte GET_API_PARAM = 0x8A;
+ private const Byte SET_API_PARAM = 0x8B;
+ private const Byte GETFUNCVER = 0x8C;
+ private const Byte WRITE_NEW_EPROM = 0x8D;
+ private const Byte READ_NEW_EPROM = 0x8E;
+ private const Byte SET_PWD = 0x8F;
+
+
+ private UInt16 UInt16 = sizeof(UInt16);
+
+ public int MAX_TIMEOUT = 5;
+
+ #endregion
+
+ //以下函数用于将字节数组转化为宽字符串
+ public static string ByteConvertString(Byte[] buffer)
+ {
+ char[] null_string = { '\0', '\0' };
+ System.Text.Encoding encoding = System.Text.Encoding.Default;
+ return encoding.GetString(buffer).TrimEnd(null_string);
+ }
+
+ //以下用于将16进制字符串转化为无符号长整型
+ private uint HexToInt(string s)
+ {
+ string[] hexch =
+ {
+ "0", "1", "2", "3", "4", "5", "6", "7",
+ "8", "9", "A", "B", "C", "D", "E", "F"
+ };
+ s = s.ToUpper();
+ int i, j;
+ int r, n, k;
+ string ch;
+
+ k = 1;
+ r = 0;
+ for (i = s.Length; i > 0; i--)
+ {
+ ch = s.Substring(i - 1, 1);
+ n = 0;
+ for (j = 0; j < 16; j++)
+ if (ch == hexch[j])
+ n = j;
+ r += (n * k);
+ k *= 16;
+ }
+
+ return unchecked((uint)r);
+ }
+
+ private int HexStringToByteArray(string InString, ref Byte[] b)
+ {
+ return HexStringToByteArrayEx(InString, ref b, 0);
+ }
+
+ private int HexStringToByteArrayEx(string InString, ref Byte[] b, int pos)
+ {
+ int nlen;
+ int retutn_len;
+ int n, i;
+ string temp;
+ nlen = InString.Length;
+ if (nlen < 16) retutn_len = 16;
+ retutn_len = nlen / 2;
+ i = 0;
+ for (n = 0; n < nlen; n = n + 2)
+ {
+ temp = InString.Substring(n, 2);
+ b[i + pos] = (Byte)HexToInt(temp);
+ i = i + 1;
+ }
+
+ return retutn_len;
+ }
+
+ public void EnCode(Byte[] inb, Byte[] outb, string Key)
+ {
+ UInt32 cnDelta, y, z, a, b, c, d, temp_2;
+ UInt32[] buf = new UInt32[16];
+ int n, i, nlen;
+ UInt32 sum;
+ //UInt32 temp, temp_1;
+ string temp_string;
+
+
+ cnDelta = 2654435769;
+ sum = 0;
+
+ nlen = Key.Length;
+ i = 0;
+ for (n = 1; n <= nlen; n = n + 2)
+ {
+ temp_string = Key.Substring(n - 1, 2);
+ buf[i] = HexToInt(temp_string);
+ i = i + 1;
+ }
+
+ a = 0;
+ b = 0;
+ c = 0;
+ d = 0;
+ for (n = 0; n <= 3; n++)
+ {
+ a = (buf[n] << (n * 8)) | a;
+ b = (buf[n + 4] << (n * 8)) | b;
+ c = (buf[n + 4 + 4] << (n * 8)) | c;
+ d = (buf[n + 4 + 4 + 4] << (n * 8)) | d;
+ }
+
+
+ y = 0;
+ z = 0;
+ for (n = 0; n <= 3; n++)
+ {
+ temp_2 = inb[n];
+ y = (temp_2 << (n * 8)) | y;
+ temp_2 = inb[n + 4];
+ z = (temp_2 << (n * 8)) | z;
+ }
+
+
+ n = 32;
+
+ while (n > 0)
+ {
+ sum = cnDelta + sum;
+
+ /*temp = (z << 4) & 0xFFFFFFFF;
+ temp = (temp + a) & 0xFFFFFFFF;
+ temp_1 = (z + sum) & 0xFFFFFFFF;
+ temp = (temp ^ temp_1) & 0xFFFFFFFF;
+ temp_1 = (z >> 5) & 0xFFFFFFFF;
+ temp_1 = (temp_1 + b) & 0xFFFFFFFF;
+ temp = (temp ^ temp_1) & 0xFFFFFFFF;
+ temp = (temp + y) & 0xFFFFFFFF;
+ y = temp & 0xFFFFFFFF;*/
+ y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
+
+ /*temp = (y << 4) & 0xFFFFFFFF;
+ temp = (temp + c) & 0xFFFFFFFF;
+ temp_1 = (y + sum) & 0xFFFFFFFF;
+ temp = (temp ^ temp_1) & 0xFFFFFFFF;
+ temp_1 = (y >> 5) & 0xFFFFFFFF;
+ temp_1 = (temp_1 + d) & 0xFFFFFFFF;
+ temp = (temp ^ temp_1) & 0xFFFFFFFF;
+ temp = (z + temp) & 0xFFFFFFFF;
+ z = temp & 0xFFFFFFFF;*/
+ z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
+ n = n - 1;
+ }
+
+ for (n = 0; n <= 3; n++)
+ {
+ outb[n] = System.Convert.ToByte((y >> (n * 8)) & 255);
+ outb[n + 4] = System.Convert.ToByte((z >> (n * 8)) & 255);
+ }
+ }
+
+ public void DeCode(Byte[] inb, Byte[] outb, string Key)
+ {
+ UInt32 cnDelta, y, z, a, b, c, d, temp_2;
+ UInt32[] buf = new UInt32[16];
+ int n, i, nlen;
+ UInt32 sum;
+ //UInt32 temp, temp_1;
+ string temp_string;
+
+
+ cnDelta = 2654435769;
+ sum = 0xC6EF3720;
+
+ nlen = Key.Length;
+ i = 0;
+ for (n = 1; n <= nlen; n = n + 2)
+ {
+ temp_string = Key.Substring(n - 1, 2);
+ buf[i] = HexToInt(temp_string);
+ i = i + 1;
+ }
+
+ a = 0;
+ b = 0;
+ c = 0;
+ d = 0;
+ for (n = 0; n <= 3; n++)
+ {
+ a = (buf[n] << (n * 8)) | a;
+ b = (buf[n + 4] << (n * 8)) | b;
+ c = (buf[n + 4 + 4] << (n * 8)) | c;
+ d = (buf[n + 4 + 4 + 4] << (n * 8)) | d;
+ }
+
+
+ y = 0;
+ z = 0;
+ for (n = 0; n <= 3; n++)
+ {
+ temp_2 = inb[n];
+ y = (temp_2 << (n * 8)) | y;
+ temp_2 = inb[n + 4];
+ z = (temp_2 << (n * 8)) | z;
+ }
+
+
+ n = 32;
+
+ while (n-- > 0)
+ {
+ z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
+ y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
+ sum -= cnDelta;
+ }
+
+ for (n = 0; n <= 3; n++)
+ {
+ outb[n] = System.Convert.ToByte((y >> (n * 8)) & 255);
+ outb[n + 4] = System.Convert.ToByte((z >> (n * 8)) & 255);
+ }
+ }
+
+
+ public string StrEnc(string InString, string Key) //使用增强算法，加密字符串
+ {
+ Byte[] b, outb;
+ Byte[] temp = new Byte[8], outtemp = new Byte[8];
+ int n, i, nlen, outlen;
+ string outstring;
+ byte[] SrcbyteArray = System.Text.Encoding.Default.GetBytes(InString);
+
+ nlen = SrcbyteArray.Length + 1;
+ if (nlen < 8)
+ outlen = 8;
+ else
+ outlen = nlen;
+ b = new byte[outlen];
+ outb = new byte[outlen];
+
+ Array.Copy(SrcbyteArray, b, SrcbyteArray.Length);
+
+ b.CopyTo(outb, 0);
+
+ for (n = 0; n <= outlen - 8; n = n + 8)
+ {
+ for (i = 0; i < 8; i++) temp[i] = b[i + n];
+ EnCode(temp, outtemp, Key);
+ for (i = 0; i < 8; i++) outb[i + n] = outtemp[i];
+ }
+
+ outstring = "";
+ for (n = 0; n <= outlen - 1; n++)
+ {
+ outstring = outstring + outb[n].ToString("X2");
+ }
+
+ return outstring;
+ }
+
+ public string StrDec(string InString, string Key) //使用增强算法，加密字符串
+ {
+ Byte[] b, outb;
+ Byte[] temp = new Byte[8], outtemp = new Byte[8];
+ int n, i, nlen, outlen;
+ string temp_string;
+ String c_str;
+
+
+ nlen = InString.Length;
+ if (nlen < 16) outlen = 16;
+ outlen = nlen / 2;
+ b = new Byte[outlen];
+ outb = new Byte[outlen];
+
+ i = 0;
+ for (n = 1; n <= nlen; n = n + 2)
+ {
+ temp_string = InString.Substring(n - 1, 2);
+ b[i] = System.Convert.ToByte(HexToInt(temp_string));
+ i = i + 1;
+ }
+
+ b.CopyTo(outb, 0);
+
+ for (n = 0; n <= outlen - 8; n = n + 8)
+ {
+ for (i = 0; i < 8; i++) temp[i] = b[i + n];
+ DeCode(temp, outtemp, Key);
+ for (i = 0; i < 8; i++) outb[i + n] = outtemp[i];
+ }
+
+ c_str = ByteConvertString(outb);
+ return c_str;
+ }
+
+ private bool isfindmydevice(int pos, ref string OutPath)
+ {
+ var list = HidSharp.DeviceList.Local;
+ var hidDeviceList = list.GetHidDevices(VID, PID).ToArray();
+ if (hidDeviceList.Length > pos)
+ {
+ OutPath = hidDeviceList[pos].DevicePath;
+ return true;
+ }
+
+ pos = pos - hidDeviceList.Length;
+ hidDeviceList = list.GetHidDevices(VID_NEW, PID_NEW).ToArray();
+ if (hidDeviceList.Length > pos)
+ {
+ OutPath = hidDeviceList[pos].DevicePath;
+ return true;
+ }
+
+ pos = pos - hidDeviceList.Length;
+ hidDeviceList = list.GetHidDevices(VID_NEW_2, PID_NEW_2).ToArray();
+ if (hidDeviceList.Length > pos)
+ {
+ OutPath = hidDeviceList[pos].DevicePath;
+ return true;
+ }
+
+ return false;
+ }
+
+ private int NT_FindPort(int start, ref string OutPath)
+ {
+ if (!isfindmydevice(start, ref OutPath))
+ {
+ return -92;
+ }
+
+ return 0;
+ }
+
+ private int NT_FindPort_2(int start, int in_data, int verf_data, ref string OutPath)
+ {
+ int pos;
+ int out_data = 0;
+ int ret;
+ for (pos = start; pos < 256; pos++)
+ {
+ if (!isfindmydevice(pos, ref OutPath)) return -92;
+ ret = WriteDword(in_data, OutPath);
+ if (ret != 0) continue;
+ ret = ReadDword(ref out_data, OutPath);
+ if (ret != 0) continue;
+ if (out_data == verf_data)
+ {
+ return 0;
+ }
+ }
+
+ return (-92);
+ }
+
+ private int OpenMydivece(out HidStream hidStream, string Path)
+ {
+ var list = HidSharp.DeviceList.Local;
+ var hidDeviceList = list.GetHidDevices(VID, PID).ToArray();
+ foreach (HidDevice dev in hidDeviceList)
+ {
+ if (Path.CompareTo(dev.DevicePath) == 0)
+ {
+ if (dev.TryOpen(out hidStream)) return 0;
+ else return -92;
+ }
+ }
+
+ hidDeviceList = list.GetHidDevices(VID_NEW, PID_NEW).ToArray();
+ foreach (HidDevice dev in hidDeviceList)
+ {
+ if (Path.CompareTo(dev.DevicePath) == 0)
+ {
+ if (dev.TryOpen(out hidStream)) return 0;
+ else return -92;
+ }
+ }
+
+ hidDeviceList = list.GetHidDevices(VID_NEW_2, PID_NEW_2).ToArray();
+ foreach (HidDevice dev in hidDeviceList)
+ {
+ if (Path.CompareTo(dev.DevicePath) == 0)
+ {
+ if (dev.TryOpen(out hidStream)) return 0;
+ else return -92;
+ }
+ }
+
+ hidStream = null;
+ return -92;
+ }
+
+ private bool GetFeature(HidStream hidStream, ref Byte[] array_out, int out_len)
+ {
+ int count = 0;
+ out_len = hidStream.Device.GetMaxFeatureReportLength();
+ retry:
+ array_out[0] = 1;
+ try
+ {
+ if (out_len != 0)
+ {
+ hidStream.GetFeature(array_out, 0, hidStream.Device.GetMaxFeatureReportLength());
+ }
+ else
+ {
+ hidStream.GetFeature(array_out);
+ }
+ }
+ catch
+ {
+ count++;
+ if (count == MAX_TIMEOUT) return false;
+ goto retry;
+ }
+
+ return true;
+ }
+
+ private bool SetFeature(HidStream hidStream, Byte[] array_in, int in_len)
+ {
+ array_in[0] = 2;
+ try
+ {
+ hidStream.SetFeature(array_in);
+ }
+ catch
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ private int TransferData(Byte[] array_in, int in_len, ref Byte[] array_out, int out_len, string Path)
+ {
+ HidStream hUsbDevice;
+ Byte[] array_In_257 = new Byte[257];
+ Byte[] array_In_21 = new Byte[0x15];
+ Byte[] array_out_257 = new Byte[257];
+ if (OpenMydivece(out hUsbDevice, Path) != 0) return -92;
+ Semaphore sem;
+ sem = new Semaphore(1, 1);
+ sem.WaitOne();
+ try
+ {
+ if (in_len > 0)
+ {
+ Array.Copy(array_in, array_In_257,
+ array_in.Length < array_In_257.Length ? array_in.Length : array_In_257.Length);
+ if (!SetFeature(hUsbDevice, array_In_257, in_len))
+ {
+ Array.Copy(array_in, 0, array_In_21, 0, 0x15);
+ if (!SetFeature(hUsbDevice, array_In_21, in_len))
+ {
+ return -93;
+ }
+ }
+ }
+
+ if (out_len > 0)
+ {
+ if (!GetFeature(hUsbDevice, ref array_out_257, out_len))
+ {
+ return -94;
+ }
+ }
+ }
+ finally
+ {
+ sem.Release(1);
+ }
+
+ if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+ {
+ Array.Copy(array_out_257, 1, array_out, 0, out_len);
+ }
+ else
+ {
+ Array.Copy(array_out_257, 0, array_out, 0, out_len);
+ }
+
+ return 0;
+ }
+
+ private int NT_Read(ref Byte ele1, ref Byte ele2, ref Byte ele3, ref Byte ele4, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int ret = TransferData(array_in, 0, ref array_out, 5, Path);
+ ele1 = array_out[0];
+ ele2 = array_out[1];
+ ele3 = array_out[2];
+ ele4 = array_out[3];
+ return ret;
+ }
+
+ private int NT_Write(Byte ele1, Byte ele2, Byte ele3, Byte ele4, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ array_in[1] = 3;
+ array_in[2] = ele1;
+ array_in[3] = ele2;
+ array_in[4] = ele3;
+ array_in[5] = ele4;
+ int ret = TransferData(array_in, 5, ref array_out, 0, Path);
+ return ret;
+ }
+
+ private int NT_Write_2(Byte ele1, Byte ele2, Byte ele3, Byte ele4, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ array_in[1] = 4;
+ array_in[2] = ele1;
+ array_in[3] = ele2;
+ array_in[4] = ele3;
+ array_in[5] = ele4;
+ int ret = TransferData(array_in, 5, ref array_out, 0, Path);
+ return ret;
+ }
+
+ private int GetIDVersion(ref short Version, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ array_in[1] = 1;
+ int ret = TransferData(array_in, 1, ref array_out, 1, Path);
+ Version = array_out[0];
+ return ret;
+ }
+
+ private int NT_GetID(ref int ID_1, ref int ID_2, string Path)
+ {
+ int[] t = new int[8];
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+ array_in[1] = 2;
+ int ret = TransferData(array_in, 1, ref array_out, 8, Path);
+ t[0] = array_out[0];
+ t[1] = array_out[1];
+ t[2] = array_out[2];
+ t[3] = array_out[3];
+ t[4] = array_out[4];
+ t[5] = array_out[5];
+ t[6] = array_out[6];
+ t[7] = array_out[7];
+ ID_1 = t[3] | (t[2] << 8) | (t[1] << 16) | (t[0] << 24);
+ ID_2 = t[7] | (t[6] << 8) | (t[5] << 16) | (t[4] << 24);
+ return ret;
+ }
+
+
+ private int Y_Read(Byte[] OutData, int address, int nlen, Byte[] password, string Path, int pos)
+ {
+ int addr_l;
+ int addr_h;
+ int n;
+ Byte[] array_in = new Byte[512];
+ Byte[] array_out = new Byte[512];
+ if ((address > MAX_LEN) || (address < 0)) return -81;
+ if ((nlen > 255)) return -87;
+ if ((nlen + address) > MAX_LEN) return -88;
+ addr_h = (address >> 8) * 2;
+ addr_l = address & 255;
+
+
+ array_in[1] = 0x10;
+ array_in[2] = (Byte)addr_h;
+ array_in[3] = (Byte)addr_l;
+ array_in[4] = (Byte)nlen;
+ for (n = 0; n <= 7; n++)
+ {
+ array_in[5 + n] = password[n];
+ }
+
+ int ret = TransferData(array_in, 13, ref array_out, nlen + 1, Path);
+ if (array_out[0] != 0)
+ {
+ return -83;
+ }
+
+ for (n = 0; n < nlen; n++)
+ {
+ OutData[n + pos] = array_out[n + 1];
+ }
+
+ return ret;
+ }
+
+ private int Y_Write(Byte[] indata, int address, int nlen, Byte[] password, string Path, int pos)
+ {
+ int addr_l;
+ int addr_h;
+ int n;
+ Byte[] array_in = new Byte[512];
+ Byte[] array_out = new Byte[512];
+ if ((nlen > 255)) return -87;
+ if ((address + nlen - 1) > (MAX_LEN + 17) || (address < 0)) return -81;
+ addr_h = (address >> 8) * 2;
+ addr_l = address & 255;
+
+
+ array_in[1] = 0x11;
+ array_in[2] = (Byte)addr_h;
+ array_in[3] = (Byte)addr_l;
+ array_in[4] = (Byte)nlen;
+ for (n = 0; n <= 7; n++)
+ {
+ array_in[5 + n] = password[n];
+ }
+
+ for (n = 0; n < nlen; n++)
+ {
+ array_in[13 + n] = indata[n + pos];
+ }
+
+ int ret = TransferData(array_in, 13, ref array_out, 2, Path);
+ if (array_out[0] != 0)
+ {
+ return -82;
+ }
+
+ return ret;
+ }
+
+ private int NT_Cal(Byte[] InBuf, Byte[] outbuf, string Path, int pos)
+ {
+ int n;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 8;
+ for (n = 2; n <= 9; n++)
+ {
+ array_in[n] = InBuf[n - 2 + pos];
+ }
+
+ int ret = TransferData(array_in, 9, ref array_out, 9, Path);
+ for (n = 0; n < 8; n++)
+ {
+ outbuf[n + pos] = array_out[n];
+ }
+
+ if (array_out[8] != 0x55)
+ {
+ return -20;
+ }
+
+ return ret;
+ }
+
+ private int NT_SetCal_2(Byte[] indata, Byte IsHi, string Path, short pos)
+ {
+ int n;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 9;
+ array_in[2] = IsHi;
+ for (n = 0; n < 8; n++)
+ {
+ array_in[3 + n] = indata[n + pos];
+ }
+
+ int ret = TransferData(array_in, 11, ref array_out, 2, Path);
+ if (array_out[0] != 0)
+ {
+ return -82;
+ }
+
+ return ret;
+ }
+
+ private int ReadDword(ref int out_data, string Path)
+ {
+ Byte b1 = 0;
+ Byte b2 = 0;
+ Byte b3 = 0;
+ Byte b4 = 0;
+ int t1;
+ int t2;
+ int t3;
+ int t4;
+ int ret;
+ ret = NT_Read(ref b1, ref b2, ref b3, ref b4, Path);
+ t1 = b1;
+ t2 = b2;
+ t3 = b3;
+ t4 = b4;
+ out_data = t1 | (t2 << 8) | (t3 << 16) | (t4 << 24);
+ return ret;
+ }
+
+ private int WriteDword(int in_data, string Path)
+ {
+ Byte b1;
+ Byte b2;
+ Byte b3;
+ Byte b4;
+ b1 = (Byte)(in_data & 255);
+ b2 = (Byte)((in_data >> 8) & 255);
+ b3 = (Byte)((in_data >> 16) & 255);
+ b4 = (Byte)((in_data >> 24) & 255);
+ return NT_Write(b1, b2, b3, b4, Path);
+ }
+
+ private int WriteDword_2(int in_data, string Path)
+ {
+ Byte b1;
+ Byte b2;
+ Byte b3;
+ Byte b4;
+ b1 = (Byte)(in_data & 255);
+ b2 = (Byte)((in_data >> 8) & 255);
+ b3 = (Byte)((in_data >> 16) & 255);
+ b4 = (Byte)((in_data >> 24) & 255);
+ return NT_Write_2(b1, b2, b3, b4, Path);
+ }
+
+ public int NT_GetIDVersion(ref short Version, string Path)
+ {
+ int ret;
+
+ ret = GetIDVersion(ref Version, Path);
+
+ return ret;
+ }
+
+ public int GetID(ref int ID_1, ref int ID_2, string Path)
+ {
+ int ret;
+
+ ret = NT_GetID(ref ID_1, ref ID_2, Path);
+
+ return ret;
+ }
+
+ public int sRead(ref int in_data, string Path)
+ {
+ int ret;
+
+ ret = ReadDword(ref in_data, Path);
+
+ return ret;
+ }
+
+ public int sWrite(int out_data, string Path)
+ {
+ int ret;
+
+ ret = WriteDword(out_data, Path);
+
+ return ret;
+ }
+
+ public int YWrite(Byte[] indata, int address, int nlen, string HKey, string LKey, string Path)
+ {
+ int ret = 0;
+
+ Byte[] password = new Byte[8];
+ int n, trashLen = 0;
+ int leave;
+ int temp_leave;
+ if ((address + nlen - 1 > MAX_LEN) || (address < 0)) return -81;
+
+ ret = GetTrashBufLen(Path, ref trashLen);
+ if (trashLen < 100) trashLen = 16;
+ trashLen = trashLen - 8;
+ if (ret != 0) return ret;
+
+ myconvert(HKey, LKey, password);
+
+ temp_leave = address % trashLen;
+ leave = trashLen - temp_leave;
+ if (leave > nlen) leave = nlen;
+ if (leave > 0)
+ {
+ for (n = 0; n < leave / trashLen; n++)
+ {
+ ret = Y_Write(indata, address + n * trashLen, trashLen, password, Path, trashLen * n);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+
+ if (leave - trashLen * n > 0)
+ {
+ ret = Y_Write(indata, address + n * trashLen, leave - n * trashLen, password, Path, trashLen * n);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+ }
+
+ nlen = nlen - leave;
+ address = address + leave;
+ if (nlen > 0)
+ {
+ for (n = 0; n < nlen / trashLen; n++)
+ {
+ ret = Y_Write(indata, address + n * trashLen, trashLen, password, Path, leave + trashLen * n);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+
+ if (nlen - trashLen * n > 0)
+ {
+ ret = Y_Write(indata, address + n * trashLen, nlen - n * trashLen, password, Path,
+ leave + trashLen * n);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+ }
+
+ return ret;
+ }
+
+ public int YRead(Byte[] OutData, short address, short nlen, string HKey, string LKey, string Path)
+ {
+ int ret = 0;
+
+ Byte[] password = new Byte[8];
+ int n, trashLen = 0;
+
+ if ((address + nlen - 1 > MAX_LEN) || (address < 0)) return (-81);
+
+ ret = GetTrashBufLen(Path, ref trashLen);
+ if (trashLen < 100) trashLen = 16;
+ if (ret != 0) return ret;
+
+
+ myconvert(HKey, LKey, password);
+
+ for (n = 0; n < nlen / trashLen; n++)
+ {
+ ret = Y_Read(OutData, address + n * trashLen, trashLen, password, Path, n * trashLen);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+
+ if (nlen - trashLen * n > 0)
+ {
+ ret = Y_Read(OutData, address + n * trashLen, nlen - trashLen * n, password, Path, trashLen * n);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+
+ return ret;
+ }
+
+ public int FindPort_2(int start, int in_data, int verf_data, ref string OutPath)
+ {
+ int ret;
+
+ ret = NT_FindPort_2(start, in_data, verf_data, ref OutPath);
+
+ return ret;
+ }
+
+ public int FindPort(int start, ref string OutPath)
+ {
+ int ret;
+
+ ret = NT_FindPort(start, ref OutPath);
+
+ return ret;
+ }
+
+
+ public int sWrite_2(int out_data, string Path)
+ {
+ int ret;
+
+ ret = WriteDword_2(out_data, Path);
+
+ return ret;
+ }
+
+ private string AddZero(string InKey)
+ {
+ int nlen;
+ int n;
+ nlen = InKey.Length;
+ for (n = nlen; n <= 7; n++)
+ {
+ InKey = "0" + InKey;
+ }
+
+ return InKey;
+ }
+
+ private void myconvert(string HKey, string LKey, Byte[] out_data)
+ {
+ HKey = AddZero(HKey);
+ LKey = AddZero(LKey);
+ int n;
+ for (n = 0; n <= 3; n++)
+ {
+ out_data[n] = (Byte)HexToInt(HKey.Substring(n * 2, 2));
+ }
+
+ for (n = 0; n <= 3; n++)
+ {
+ out_data[n + 4] = (Byte)HexToInt(LKey.Substring(n * 2, 2));
+ }
+ }
+
+ public int SetReadPassword(string W_HKey, string W_LKey, string new_HKey, string new_LKey, string Path)
+ {
+ int ret;
+
+ Byte[] ary1 = new Byte[8];
+ Byte[] ary2 = new Byte[8];
+ short address;
+ myconvert(W_HKey, W_LKey, ary1);
+ myconvert(new_HKey, new_LKey, ary2);
+ address = 2032;
+
+
+ ret = Y_Write(ary2, address, 8, ary1, Path, 0);
+
+
+ return ret;
+ }
+
+
+ public int SetWritePassword(string W_HKey, string W_LKey, string new_HKey, string new_LKey, string Path)
+ {
+ int ret;
+
+ Byte[] ary1 = new Byte[8];
+ Byte[] ary2 = new Byte[8];
+ short address;
+ myconvert(W_HKey, W_LKey, ary1);
+ myconvert(new_HKey, new_LKey, ary2);
+ address = 2040;
+
+
+ ret = Y_Write(ary2, address, 8, ary1, Path, 0);
+
+
+ return ret;
+ }
+
+ public int YWriteString(string InString, int address, string HKey, string LKey, string Path)
+ {
+ int ret = 0;
+ Byte[] ary1 = new Byte[8];
+
+ int n, trashLen = 0;
+ int outlen;
+ int total_len;
+ int temp_leave;
+ int leave;
+ Byte[] b;
+ if ((address < 0)) return -81;
+
+ ret = GetTrashBufLen(Path, ref trashLen);
+ if (trashLen < 100) trashLen = 16;
+ trashLen = trashLen - 8;
+ if (ret != 0) return ret;
+
+ myconvert(HKey, LKey, ary1);
+
+ byte[] SrcbyteArray = System.Text.Encoding.Default.GetBytes(InString);
+ outlen = SrcbyteArray.Length;
+ b = new Byte[outlen];
+ Array.Copy(SrcbyteArray, b, SrcbyteArray.Length);
+
+ total_len = address + outlen;
+ if (total_len > MAX_LEN) return -47;
+
+
+ temp_leave = address % trashLen;
+ leave = trashLen - temp_leave;
+ if (leave > outlen) leave = outlen;
+
+ if (leave > 0)
+ {
+ for (n = 0; n < (leave / trashLen); n++)
+ {
+ ret = Y_Write(b, address + n * trashLen, trashLen, ary1, Path, n * trashLen);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+
+ if (leave - trashLen * n > 0)
+ {
+ ret = Y_Write(b, address + n * trashLen, leave - n * trashLen, ary1, Path, trashLen * n);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+ }
+
+ outlen = outlen - leave;
+ address = address + leave;
+ if (outlen > 0)
+ {
+ for (n = 0; n < (outlen / trashLen); n++)
+ {
+ ret = Y_Write(b, address + n * trashLen, trashLen, ary1, Path, leave + n * trashLen);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+
+ if (outlen - trashLen * n > 0)
+ {
+ ret = Y_Write(b, address + n * trashLen, outlen - n * trashLen, ary1, Path, leave + trashLen * n);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+ }
+
+
+ return SrcbyteArray.Length;
+ }
+
+ public int YReadString(ref string OutString, int address, int nlen, string HKey, string LKey, string Path)
+ {
+ int ret = 0;
+ Byte[] ary1 = new Byte[8];
+
+ int n, trashLen = 0;
+ int total_len;
+ Byte[] outb;
+ outb = new Byte[nlen];
+ myconvert(HKey, LKey, ary1);
+ if (address < 0) return -81;
+
+ ret = GetTrashBufLen(Path, ref trashLen);
+ if (trashLen < 100) trashLen = 16;
+ if (ret != 0) return ret;
+
+ total_len = address + nlen;
+ if (total_len > MAX_LEN) return -47;
+
+
+ for (n = 0; n < (nlen / trashLen); n++)
+ {
+ ret = Y_Read(outb, address + n * trashLen, trashLen, ary1, Path, n * trashLen);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+
+ if (nlen - trashLen * n > 0)
+ {
+ ret = Y_Read(outb, address + n * trashLen, nlen - trashLen * n, ary1, Path, trashLen * n);
+ if (ret != 0)
+ {
+ return ret;
+ }
+ }
+
+ OutString = ByteConvertString(outb);
+ return ret;
+ }
+
+ public int SetCal_2(string Key, string Path)
+ {
+ int ret;
+
+ Byte[] KeyBuf = new Byte[16];
+ Byte[] inb = new Byte[8];
+ HexStringToByteArray(Key, ref KeyBuf);
+
+
+ ret = NT_SetCal_2(KeyBuf, 0, Path, 8);
+ if (ret != 0) goto error1;
+ ret = NT_SetCal_2(KeyBuf, 1, Path, 0);
+ error1:
+
+
+ return ret;
+ }
+
+ public int Cal(Byte[] InBuf, Byte[] outbuf, string Path)
+ {
+ int ret;
+
+
+ ret = NT_Cal(InBuf, outbuf, Path, 0);
+
+
+ return ret;
+ }
+
+ public int EncString(string InString, ref string OutString, string Path)
+ {
+ Byte[] b;
+ Byte[] outb;
+ int n;
+ int nlen, temp_len;
+ int ret = 0;
+ byte[] SrcbyteArray = System.Text.Encoding.Default.GetBytes(InString);
+
+ nlen = SrcbyteArray.Length + 1;
+ temp_len = nlen;
+ if (nlen < 8)
+ {
+ nlen = 8;
+ }
+
+
+ b = new Byte[nlen];
+ outb = new Byte[nlen];
+
+ Array.Copy(SrcbyteArray, b, SrcbyteArray.Length);
+
+ b.CopyTo(outb, 0);
+
+
+ for (n = 0; n <= (nlen - 8); n = n + 8)
+ {
+ ret = NT_Cal(b, outb, Path, n);
+ if (ret != 0) break;
+ }
+
+
+ OutString = "";
+ for (n = 0; n < nlen; n++)
+ {
+ OutString = OutString + outb[n].ToString("X2");
+ }
+
+ return ret;
+ }
+
+ public int sWriteEx(int in_data, ref int out_data, string Path)
+ {
+ int ret;
+
+
+ ret = WriteDword(in_data, Path);
+ if (ret != 0) goto error1;
+ ret = ReadDword(ref out_data, Path);
+ error1:
+
+
+ return ret;
+ }
+
+ public int sWrite_2Ex(int in_data, ref int out_data, string Path)
+ {
+ int ret;
+
+
+ ret = WriteDword_2(in_data, Path);
+ if (ret != 0) goto error1;
+ ret = ReadDword(ref out_data, Path);
+ error1:
+
+
+ return ret;
+ }
+
+ public int ReSet(string Path)
+ {
+ int ret;
+
+
+ ret = NT_ReSet(Path);
+
+
+ return ret;
+ }
+
+ private int NT_ReSet(string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 32;
+ int ret = TransferData(array_in, 2, ref array_out, 2, Path);
+ if (array_out[0] != 0)
+ {
+ return -82;
+ }
+
+ return ret;
+ }
+
+ public int SetCal_New(string Key, string Path)
+ {
+ int ret;
+
+ Byte[] KeyBuf = new Byte[16];
+ Byte[] inb = new Byte[8];
+ HexStringToByteArray(Key, ref KeyBuf);
+
+
+ ret = NT_SetCal_New(KeyBuf, 0, Path, 8);
+ if (ret != 0) goto error1;
+ ret = NT_SetCal_New(KeyBuf, 1, Path, 0);
+ error1:
+
+
+ return ret;
+ }
+
+ public int Cal_New(Byte[] InBuf, Byte[] outbuf, string Path)
+ {
+ int ret;
+
+
+ ret = NT_Cal_New(InBuf, outbuf, Path, 0);
+
+
+ return ret;
+ }
+
+ public int EncString_New(string InString, ref string OutString, string Path)
+ {
+ Byte[] b;
+ Byte[] outb;
+ int n;
+ int nlen, temp_len;
+ int ret = 0;
+ byte[] SrcbyteArray = System.Text.Encoding.Default.GetBytes(InString);
+
+ nlen = SrcbyteArray.Length + 1;
+
+ temp_len = nlen;
+ if (nlen < 8)
+ {
+ nlen = 8;
+ }
+
+
+ b = new Byte[nlen];
+ outb = new Byte[nlen];
+
+ Array.Copy(SrcbyteArray, b, SrcbyteArray.Length);
+
+ b.CopyTo(outb, 0);
+
+
+ for (n = 0; n <= (nlen - 8); n = n + 8)
+ {
+ ret = NT_Cal_New(b, outb, Path, n);
+ if (ret != 0) break;
+ }
+
+
+ OutString = "";
+ for (n = 0; n < nlen; n++)
+ {
+ OutString = OutString + outb[n].ToString("X2");
+ }
+
+ return ret;
+ }
+
+ public int NT_GetVersionEx(ref short Version, string Path)
+ {
+ int ret;
+
+
+ ret = F_GetVersionEx(ref Version, Path);
+
+
+ return ret;
+ }
+
+ private int NT_Cal_New(Byte[] InBuf, Byte[] outbuf, string Path, int pos)
+ {
+ int n;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 12;
+ for (n = 2; n <= 9; n++)
+ {
+ array_in[n] = InBuf[n - 2 + pos];
+ }
+
+ int ret = TransferData(array_in, 9, ref array_out, 9, Path);
+ for (n = 0; n < 8; n++)
+ {
+ outbuf[n + pos] = array_out[n];
+ }
+
+ if (array_out[8] != 0x55)
+ {
+ return -20;
+ }
+
+ return ret;
+ }
+
+ private int NT_SetCal_New(Byte[] indata, Byte IsHi, string Path, short pos)
+ {
+ int n;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 13;
+ array_in[2] = IsHi;
+ for (n = 0; n < 8; n++)
+ {
+ array_in[3 + n] = indata[n + pos];
+ }
+
+ int ret = TransferData(array_in, 11, ref array_out, 2, Path);
+ if (array_out[0] != 0)
+ {
+ return -82;
+ }
+
+ return ret;
+ }
+
+ private int F_GetVersionEx(ref short Version, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 5;
+ int ret = TransferData(array_in, 1, ref array_out, 1, Path);
+ Version = array_out[0];
+ return ret;
+ }
+
+
+ public int SetHidOnly(bool IsHidOnly, string Path)
+ {
+ int ret;
+
+
+ ret = NT_SetHidOnly(IsHidOnly, Path);
+
+
+ return ret;
+ }
+
+ private int NT_SetHidOnly(bool IsHidOnly, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 0x55;
+ if (IsHidOnly) array_in[2] = 0;
+ else array_in[2] = 0xff;
+ int ret = TransferData(array_in, 3, ref array_out, 1, Path);
+ if (array_out[0] != 0)
+ {
+ return -82;
+ }
+
+ return ret;
+ }
+
+ public int SetUReadOnly(string Path)
+ {
+ int ret;
+
+
+ ret = NT_SetUReadOnly(Path);
+
+
+ return ret;
+ }
+
+ private int NT_SetUReadOnly(string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 0x56;
+ int ret = TransferData(array_in, 3, ref array_out, 1, Path);
+ if (array_out[0] != 0)
+ {
+ return -82;
+ }
+
+ return ret;
+ }
+
+ private int sub_GetTrashBufLen(IntPtr hDevice, ref int out_len)
+ {
+ /* IntPtr Ppd = System.IntPtr.Zero;
+ HIDP_CAPS Caps = new HIDP_CAPS();
+
+ if (!HidD_GetPreparsedData(hDevice, ref Ppd)) return -93;
+
+ if (HidP_GetCaps(Ppd, ref Caps) <= 0)
+ {
+ HidD_FreePreparsedData(Ppd);
+ return -93;
+ }
+ HidD_FreePreparsedData(Ppd);
+ out_len = Caps.FeatureReportByteLength - 5;*/
+ return 0;
+ }
+
+ private int GetTrashBufLen(string Path, ref int out_len)
+ {
+ out_len = 16;
+ return 0;
+ }
+
+ private int NT_Set_SM2_KeyPair(Byte[] PriKey, Byte[] PubKeyX, Byte[] PubKeyY, Byte[] sm2_UerName, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int n = 0;
+
+
+ array_in[1] = 0x32;
+ for (n = 0; n < ECC_MAXLEN; n++)
+ {
+ array_in[2 + n + ECC_MAXLEN * 0] = PriKey[n];
+ array_in[2 + n + ECC_MAXLEN * 1] = PubKeyX[n];
+ array_in[2 + n + ECC_MAXLEN * 2] = PubKeyY[n];
+ }
+
+ for (n = 0; n < SM2_USENAME_LEN; n++)
+ {
+ array_in[2 + n + ECC_MAXLEN * 3] = sm2_UerName[n];
+ }
+
+ int ret = TransferData(array_in, ECC_MAXLEN * 3 + SM2_USENAME_LEN + 2, ref array_out, 2, Path);
+ if (array_out[0] != 0x20) return USBStatusFail;
+
+ return ret;
+ }
+
+ private int NT_GenKeyPair(Byte[] PriKey, Byte[] PubKey, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int n = 0;
+ array_out[0] = 0xfb;
+
+ array_in[1] = GEN_KEYPAIR;
+
+ int ret = TransferData(array_in, 2, ref array_out, ECC_MAXLEN * 3 + 2, Path);
+
+ if (array_out[0] != 0x20)
+ {
+ return FAILEDGENKEYPAIR; //表示读取失败；
+ }
+
+ for (n = 0; n < ECC_MAXLEN; n++)
+ {
+ PriKey[n] = array_out[1 + ECC_MAXLEN * 0 + n];
+ }
+
+ for (n = 0; n < (ECC_MAXLEN * 2 + 1); n++)
+ {
+ PubKey[n] = array_out[1 + ECC_MAXLEN * 1 + n];
+ }
+
+ return ret;
+ }
+
+ private int NT_GetChipID(Byte[] OutChipID, string Path)
+ {
+ int[] t = new int[8];
+ int n;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = GET_CHIPID;
+ int ret = TransferData(array_in, 1, ref array_out, 17, Path);
+ if (array_out[0] != 0x20) return USBStatusFail;
+ for (n = 0; n < 16; n++)
+ {
+ OutChipID[n] = array_out[1 + n];
+ }
+
+ return ret;
+ }
+
+
+ private int NT_Get_SM2_PubKey(Byte[] KGx, Byte[] KGy, Byte[] sm2_UerName, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int n = 0;
+
+
+ array_in[1] = 0x33;
+ int ret = TransferData(array_in, 2, ref array_out, ECC_MAXLEN * 2 + SM2_USENAME_LEN + 2, Path);
+ if (array_out[0] != 0x20) return USBStatusFail;
+
+ for (n = 0; n < ECC_MAXLEN; n++)
+ {
+ KGx[n] = array_out[1 + ECC_MAXLEN * 0 + n];
+ KGy[n] = array_out[1 + ECC_MAXLEN * 1 + n];
+ }
+
+ for (n = 0; n < SM2_USENAME_LEN; n++)
+ {
+ sm2_UerName[n] = array_out[1 + ECC_MAXLEN * 2 + n];
+ }
+
+ return ret;
+ }
+
+ private int NT_Set_Pin(string old_pin, string new_pin, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int n = 0;
+
+
+ array_in[1] = SET_PIN;
+ Byte[] b_oldpin = System.Text.Encoding.Default.GetBytes(old_pin);
+
+ Byte[] b_newpin = System.Text.Encoding.Default.GetBytes(new_pin);
+
+ for (n = 0; n < PIN_LEN; n++)
+ {
+ array_in[2 + PIN_LEN * 0 + n] = b_oldpin[n];
+ array_in[2 + PIN_LEN * 1 + n] = b_newpin[n];
+ }
+
+ int ret = TransferData(array_in, PIN_LEN * 2 + 2, ref array_out, 2, Path);
+ if (array_out[0] != 0x20) return USBStatusFail;
+ if (array_out[1] != 0x20) return FAILPINPWD;
+ return ret;
+ }
+
+
+ private int NT_SM2_Enc(Byte[] inbuf, Byte[] outbuf, Byte inlen, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int n = 0;
+
+
+ array_in[1] = MYENC;
+ array_in[2] = inlen;
+ for (n = 0; n < inlen; n++)
+ {
+ array_in[3 + n] = inbuf[n];
+ }
+
+ int ret = TransferData(array_in, inlen + 1 + 2, ref array_out, inlen + SM2_ADDBYTE + 3, Path);
+ if (array_out[0] != 0x20) return USBStatusFail;
+ if (array_out[1] == 0) return FAILENC;
+
+ for (n = 0; n < (inlen + SM2_ADDBYTE); n++)
+ {
+ outbuf[n] = array_out[2 + n];
+ }
+
+ return ret;
+ }
+
+ private int NT_SM2_Dec(Byte[] inbuf, Byte[] outbuf, Byte inlen, string pin, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int n = 0;
+
+
+ array_in[1] = MYDEC;
+ Byte[] b_pin = System.Text.Encoding.Default.GetBytes(pin);
+
+ for (n = 0; n < PIN_LEN; n++)
+ {
+ array_in[2 + PIN_LEN * 0 + n] = b_pin[n];
+ }
+
+ array_in[2 + PIN_LEN] = inlen;
+ for (n = 0; n < inlen; n++)
+ {
+ array_in[2 + PIN_LEN + 1 + n] = inbuf[n];
+ }
+
+ int ret = TransferData(array_in, inlen + 1 + 2 + PIN_LEN, ref array_out, inlen - SM2_ADDBYTE + 4, Path);
+ if (array_out[2] != 0x20) return FAILPINPWD;
+ if (array_out[1] == 0) return FAILENC;
+ if (array_out[0] != 0x20) return USBStatusFail;
+ for (n = 0; n < (inlen - SM2_ADDBYTE); n++)
+ {
+ outbuf[n] = array_out[3 + n];
+ }
+
+ return ret;
+ }
+
+ private int NT_Sign(Byte[] inbuf, Byte[] outbuf, string pin, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int n = 0;
+
+
+ array_in[1] = YTSIGN;
+ Byte[] b_pin = System.Text.Encoding.Default.GetBytes(pin);
+
+ for (n = 0; n < PIN_LEN; n++)
+ {
+ array_in[2 + PIN_LEN * 0 + n] = b_pin[n];
+ }
+
+ for (n = 0; n < 32; n++)
+ {
+ array_in[2 + PIN_LEN + n] = inbuf[n];
+ }
+
+ int ret = TransferData(array_in, 32 + 2 + PIN_LEN, ref array_out, 64 + 3, Path);
+ if (array_out[1] != 0x20) return FAILPINPWD;
+ if (array_out[0] != 0x20) return USBStatusFail;
+ for (n = 0; n < 64; n++)
+ {
+ outbuf[n] = array_out[2 + n];
+ }
+
+ return ret;
+ }
+
+ private int NT_Sign_2(Byte[] inbuf, Byte[] outbuf, string pin, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int n = 0;
+
+
+ array_in[1] = YTSIGN_2;
+ Byte[] b_pin = System.Text.Encoding.Default.GetBytes(pin);
+
+ for (n = 0; n < PIN_LEN; n++)
+ {
+ array_in[2 + PIN_LEN * 0 + n] = b_pin[n];
+ }
+
+ for (n = 0; n < 32; n++)
+ {
+ array_in[2 + PIN_LEN + n] = inbuf[n];
+ }
+
+ int ret = TransferData(array_in, 32 + 2 + PIN_LEN, ref array_out, 64 + 3, Path);
+ if (array_out[1] != 0x20) return FAILPINPWD;
+ if (array_out[0] != 0x20) return USBStatusFail;
+ for (n = 0; n < 64; n++)
+ {
+ outbuf[n] = array_out[2 + n];
+ }
+
+ return ret;
+ }
+
+
+ private int NT_Verfiy(Byte[] inbuf, Byte[] InSignBuf, ref bool outbiao, string Path)
+ {
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+ int n = 0;
+
+
+ array_in[1] = YTVERIFY;
+ for (n = 0; n < 32; n++)
+ {
+ array_in[2 + n] = inbuf[n];
+ }
+
+ for (n = 0; n < 64; n++)
+ {
+ array_in[2 + 32 + n] = InSignBuf[n];
+ }
+
+ int ret = TransferData(array_in, 32 + 2 + 64, ref array_out, 3, Path);
+ outbiao = (array_out[1] != 0);
+ if (array_out[0] != 0x20) return USBStatusFail;
+
+ return ret;
+ }
+
+ private string ByteArrayToHexString(Byte[] in_data, int nlen)
+ {
+ return ByteArrayToHexStringEx(in_data, nlen, 0);
+ }
+
+ private string ByteArrayToHexStringEx(Byte[] in_data, int nlen, int pos)
+ {
+ string OutString = "";
+ int n;
+ for (n = 0; n < nlen; n++)
+ {
+ OutString = OutString + in_data[n + pos].ToString("X2");
+ }
+
+ return OutString;
+ }
+
+ public int YT_GenKeyPair(ref string PriKey, ref string PubKeyX, ref string PubKeyY, string InPath)
+ {
+ int ret, n;
+ Byte[] b_PriKey = new Byte[ECC_MAXLEN], b_PubKey = new Byte[ECC_MAXLEN * 2 + 1]; //其中第一个字节是标志位，忽略
+
+
+ ret = NT_GenKeyPair(b_PriKey, b_PubKey, InPath);
+
+
+ PriKey = ByteArrayToHexString(b_PriKey, ECC_MAXLEN);
+ PubKeyX = "";
+ PubKeyY = "";
+ for (n = 0; n < ECC_MAXLEN; n++)
+ {
+ PubKeyX = PubKeyX + b_PubKey[n + 1].ToString("X2");
+ PubKeyY = PubKeyY + b_PubKey[n + 1 + ECC_MAXLEN].ToString("X2");
+ }
+
+ return ret;
+ }
+
+ public int Set_SM2_KeyPair(string PriKey, string PubKeyX, string PubKeyY, string SM2_UserName, string InPath)
+ {
+ int ret;
+ Byte[] b_PriKey = new Byte[ECC_MAXLEN], b_PubKeyX = new Byte[ECC_MAXLEN], b_PubKeyY = new Byte[ECC_MAXLEN];
+ HexStringToByteArray(PriKey, ref b_PriKey);
+ HexStringToByteArray(PubKeyX, ref b_PubKeyX);
+ HexStringToByteArray(PubKeyY, ref b_PubKeyY);
+
+ Byte[] b_SM2UserName = System.Text.Encoding.Default.GetBytes(SM2_UserName);
+
+ ret = NT_Set_SM2_KeyPair(b_PriKey, b_PubKeyX, b_PubKeyY, b_SM2UserName, InPath);
+
+
+ return ret;
+ }
+
+ public int Get_SM2_PubKey(ref string PubKeyX, ref string PubKeyY, ref string sm2UserName, string InPath)
+ {
+ int ret;
+ Byte[] b_PubKeyX = new Byte[ECC_MAXLEN],
+ b_PubKeyY = new Byte[ECC_MAXLEN],
+ b_sm2UserName = new Byte[SM2_USENAME_LEN];
+
+
+ ret = NT_Get_SM2_PubKey(b_PubKeyX, b_PubKeyY, b_sm2UserName, InPath);
+
+
+ PubKeyX = ByteArrayToHexString(b_PubKeyX, ECC_MAXLEN);
+ PubKeyY = ByteArrayToHexString(b_PubKeyY, ECC_MAXLEN);
+
+
+ sm2UserName = ByteConvertString(b_sm2UserName);
+ return ret;
+ }
+
+ public int GetChipID(ref string OutChipID, string InPath)
+ {
+ int ret;
+ Byte[] b_OutChipID = new Byte[16];
+
+ ret = NT_GetChipID(b_OutChipID, InPath);
+
+
+ OutChipID = ByteArrayToHexString(b_OutChipID, 16);
+ return ret;
+ }
+
+ public int SM2_EncBuf(Byte[] InBuf, Byte[] OutBuf, int inlen, string InPath)
+ {
+ int ret = 0, n, temp_inlen, incount = 0, outcount = 0;
+ Byte[] temp_InBuf = new Byte[MAX_ENCLEN + SM2_ADDBYTE], temp_OutBuf = new Byte[MAX_ENCLEN + SM2_ADDBYTE];
+ while (inlen > 0)
+ {
+ if (inlen > MAX_ENCLEN)
+ temp_inlen = MAX_ENCLEN;
+ else
+ temp_inlen = inlen;
+ for (n = 0; n < temp_inlen; n++)
+ {
+ temp_InBuf[n] = InBuf[incount + n];
+ }
+
+ ret = NT_SM2_Enc(temp_InBuf, temp_OutBuf, (Byte)temp_inlen, InPath);
+ for (n = 0; n < (temp_inlen + SM2_ADDBYTE); n++)
+ {
+ OutBuf[outcount + n] = temp_OutBuf[n];
+ }
+
+ if (ret != 0) goto err;
+ inlen = inlen - MAX_ENCLEN;
+ incount = incount + MAX_ENCLEN;
+ outcount = outcount + MAX_DECLEN;
+ }
+
+ err:
+
+
+ return ret;
+ }
+
+ public int SM2_DecBuf(Byte[] InBuf, Byte[] OutBuf, int inlen, string pin, string InPath)
+ {
+ int ret = 0, temp_inlen, n, incount = 0, outcount = 0;
+ Byte[] temp_InBuf = new Byte[MAX_ENCLEN + SM2_ADDBYTE], temp_OutBuf = new Byte[MAX_ENCLEN + SM2_ADDBYTE];
+
+ while (inlen > 0)
+ {
+ if (inlen > MAX_DECLEN)
+ temp_inlen = MAX_DECLEN;
+ else
+ temp_inlen = inlen;
+ for (n = 0; n < temp_inlen; n++)
+ {
+ temp_InBuf[n] = InBuf[incount + n];
+ }
+
+ ret = NT_SM2_Dec(InBuf, OutBuf, (Byte)temp_inlen, pin, InPath);
+ for (n = 0; n < (temp_inlen - SM2_ADDBYTE); n++)
+ {
+ OutBuf[outcount + n] = temp_OutBuf[n];
+ }
+
+ if (ret != 0) goto err;
+ inlen = inlen - MAX_DECLEN;
+ incount = incount + MAX_DECLEN;
+ outcount = outcount + MAX_ENCLEN;
+ }
+
+ err:
+
+
+ return ret;
+ }
+
+ public int SM2_EncString(string InString, ref string OutString, string InPath)
+ {
+ int n, incount = 0, outcount = 0;
+ Byte[] temp_InBuf = new Byte[MAX_ENCLEN + SM2_ADDBYTE], temp_OutBuf = new Byte[MAX_ENCLEN + SM2_ADDBYTE];
+ byte[] SrcbyteArray = System.Text.Encoding.Default.GetBytes(InString);
+
+ int inlen = SrcbyteArray.Length + 1;
+ int outlen = (int)Math.Ceiling((double)inlen / (MAX_ENCLEN)) * SM2_ADDBYTE + inlen;
+ Byte[] OutBuf = new Byte[outlen];
+ Byte[] InBuf = new Byte[inlen];
+ Array.Copy(SrcbyteArray, InBuf, SrcbyteArray.Length);
+ int ret = 0, temp_inlen;
+
+ while (inlen > 0)
+ {
+ if (inlen > MAX_ENCLEN)
+ temp_inlen = MAX_ENCLEN;
+ else
+ temp_inlen = inlen;
+ for (n = 0; n < temp_inlen; n++)
+ {
+ temp_InBuf[n] = InBuf[incount + n];
+ }
+
+ ret = NT_SM2_Enc(temp_InBuf, temp_OutBuf, (Byte)temp_inlen, InPath);
+ for (n = 0; n < (temp_inlen + SM2_ADDBYTE); n++)
+ {
+ OutBuf[outcount + n] = temp_OutBuf[n];
+ }
+
+ if (ret != 0) goto err;
+ inlen = inlen - MAX_ENCLEN;
+ incount = incount + MAX_ENCLEN;
+ outcount = outcount + MAX_DECLEN;
+ }
+
+ err:
+ OutString = ByteArrayToHexString(OutBuf, outlen);
+
+
+ return ret;
+ }
+
+ public int SM2_DecString(string InString, ref string OutString, string pin, string InPath)
+ {
+ int n, incount = 0, outcount = 0;
+ Byte[] temp_InBuf = new Byte[MAX_ENCLEN + SM2_ADDBYTE], temp_OutBuf = new Byte[MAX_ENCLEN + SM2_ADDBYTE];
+ byte[] SrcbyteArray = System.Text.Encoding.Default.GetBytes(InString);
+
+ int inlen = SrcbyteArray.Length / 2;
+ int outlen = inlen - (int)Math.Ceiling((double)inlen / (MAX_DECLEN)) * SM2_ADDBYTE + 1;
+ Byte[] InBuf = new Byte[inlen];
+ Byte[] OutBuf = new Byte[outlen];
+ int ret = 0, temp_inlen;
+ HexStringToByteArray(InString, ref InBuf);
+
+ while (inlen > 0)
+ {
+ if (inlen > MAX_DECLEN)
+ temp_inlen = MAX_DECLEN;
+ else
+ temp_inlen = inlen;
+ for (n = 0; n < temp_inlen; n++)
+ {
+ temp_InBuf[n] = InBuf[incount + n];
+ }
+
+ ret = NT_SM2_Dec(temp_InBuf, temp_OutBuf, (Byte)temp_inlen, pin, InPath);
+ for (n = 0; n < (temp_inlen - SM2_ADDBYTE); n++)
+ {
+ OutBuf[outcount + n] = temp_OutBuf[n];
+ }
+
+ if (ret != 0) goto err;
+ inlen = inlen - MAX_DECLEN;
+ incount = incount + MAX_DECLEN;
+ outcount = outcount + MAX_ENCLEN;
+ }
+
+ err:
+
+
+ OutString = ByteConvertString(OutBuf);
+ return ret;
+ }
+
+
+ public int YtSetPin(string old_pin, string new_pin, string InPath)
+ {
+ int ret;
+
+
+ ret = NT_Set_Pin(old_pin, new_pin, InPath);
+
+
+ return ret;
+ }
+
+ private int NT_SetID(Byte[] InBuf, string Path)
+ {
+ int n;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 7;
+ for (n = 2; n <= 9; n++)
+ {
+ array_in[n] = InBuf[n - 2];
+ }
+
+ int ret = TransferData(array_in, 9, ref array_out, 9, Path);
+ if (array_out[0] != 0x0)
+ {
+ return -82;
+ }
+
+ return ret;
+ }
+
+ public int SetID(string Seed, string Path)
+ {
+ int ret;
+
+ int n;
+ Byte[] KeyBuf = new Byte[8];
+ for (n = 0; n < 8; n++)
+ {
+ KeyBuf[n] = 0;
+ }
+
+ HexStringToByteArray(Seed, ref KeyBuf);
+
+
+ ret = NT_SetID(KeyBuf, Path);
+
+
+ return ret;
+ }
+
+ private int NT_GetProduceDate(ref string OutDate, string Path)
+ {
+ int n;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 15;
+
+ int ret = TransferData(array_in, 1, ref array_out, 8, Path);
+ OutDate = "";
+ for (n = 0; n < 8; n++)
+ {
+ OutDate = OutDate + array_out[n].ToString("X2");
+ }
+
+ return ret;
+ }
+
+ //返回锁的出厂编码
+ public int GetProduceDate(ref string PDate, string Path)
+ {
+ int ret;
+
+
+ ret = NT_GetProduceDate(ref PDate, Path);
+
+
+ return ret;
+ }
+
+ public string SnToProduceDate(string InSn)
+ {
+ string OutString;
+ OutString = (2000 + HexToInt(InSn.Substring(0, 2))).ToString() + "年";
+ OutString = OutString + (HexToInt(InSn.Substring(2, 2))).ToString() + "月";
+ OutString = OutString + (HexToInt(InSn.Substring(4, 2))).ToString() + "日";
+ OutString = OutString + (HexToInt(InSn.Substring(6, 2))).ToString() + "时";
+ OutString = OutString + (HexToInt(InSn.Substring(8, 2))).ToString() + "分";
+ OutString = OutString + (HexToInt(InSn.Substring(10, 2))).ToString() + "秒--";
+ OutString = OutString + "序号：" + HexToInt(InSn.Substring(12, 4)).ToString();
+ return OutString;
+ }
+
+ private int y_setcal(Byte[] indata, int address, int nlen, Byte[] password, string Path)
+ {
+ int n;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+ if (nlen > 8) return -87;
+
+
+ array_in[1] = 6;
+ array_in[2] = 0;
+ array_in[3] = 0;
+ array_in[4] = (Byte)nlen;
+ for (n = 0; n <= 7; n++)
+ {
+ array_in[5 + n] = password[n];
+ }
+
+ for (n = 0; n < nlen; n++)
+ {
+ array_in[13 + n] = indata[n];
+ }
+
+ int ret = TransferData(array_in, 13 + nlen, ref array_out, 2, Path);
+ if (array_out[0] != 0)
+ {
+ return -82;
+ }
+
+ return ret;
+ }
+
+ public int SetCal(string W_HKey, string W_LKey, string new_HKey, string new_LKey, string Path)
+ {
+ int ret;
+
+ Byte[] ary1 = new Byte[8];
+ Byte[] ary2 = new Byte[8];
+ short address;
+ myconvert(W_HKey, W_LKey, ary1);
+ myconvert(new_HKey, new_LKey, ary2);
+ address = 0;
+
+
+ ret = y_setcal(ary2, address, 8, ary1, Path);
+
+
+ return ret;
+ }
+
+ private int NT_SetDisableFlag(Byte Flag, Byte[] password, string Path)
+ {
+ int n;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 0x40;
+ array_in[2] = 0;
+ array_in[3] = 0;
+ array_in[4] = 1;
+ for (n = 0; n <= 7; n++)
+ {
+ array_in[5 + n] = password[n];
+ }
+
+ array_in[13] = Flag;
+ int ret = TransferData(array_in, 13 + 1, ref array_out, 2, Path);
+ if (array_out[0] != 0)
+ {
+ return -82;
+ }
+
+ return ret;
+ }
+
+ private int NT_GetDisableFlag(ref bool isDisableFlag, string Path)
+ {
+ isDisableFlag = false;
+ Byte[] array_in = new Byte[257];
+ Byte[] array_out = new Byte[257];
+
+
+ array_in[1] = 0x41;
+ int ret = TransferData(array_in, 1, ref array_out, 2, Path);
+ if (array_out[0] != 0)
+ {
+ return -82;
+ }
+
+ if (array_out[1] == 0xe5) isDisableFlag = true;
+ return ret;
+ }
+
+ public int SetDisableFlag(bool isDisableFlag, string HKey, string LKey, string Path)
+ {
+ int ret;
+ Byte Flag = 0;
+ Byte[] ary = new Byte[8];
+ myconvert(HKey, LKey, ary);
+ if (isDisableFlag) Flag = 0xE5;
+
+
+ ret = NT_SetDisableFlag(Flag, ary, Path);
+
+
+ return ret;
+ }
+
+ public int GetDisableFlag(ref bool isDisableFlag, string Path)
+ {
+ int ret;
+
+
+ ret = NT_GetDisableFlag(ref isDisableFlag, Path);
+
+
+ return ret;
+ }
+
+
+ public void memset(Byte[] buf, int pos, Byte val, int size)
+ {
+ int n;
+ for (n = pos; n < size; n++)
+ {
+ buf[n] = val;
+ }
+ }
+
+ private int HanldetransferEx(Byte[] InBuf, int InBufLen, Byte[] OutBuf, int OutBufLen, string Path)
+ {
+ Byte[] t_InBuf = new byte[MAX_BUF_SIZE + 2];
+ Byte[] t_OutBuf = new byte[MAX_BUF_SIZE + 2];
+ Array.Copy(InBuf, 0, t_InBuf, 0, InBufLen + 1);
+ int ret = TransferData(t_InBuf, InBufLen, ref t_OutBuf, OutBufLen, Path);
+ if (ret != 0) return ret;
+ Array.Copy(t_OutBuf, 0, OutBuf, 0, OutBufLen);
+ ret = BitConverter.ToInt16(OutBuf, 0);
+ return ret;
+ }
+
+ public int CheckKeyByFindort_2()
+ {
+ //使用普通算法一查找指定的加密锁
+ string DevicePath = ""; //用于储存加密锁所在的路径
+ return FindPort_2(0, 1, 16711934, ref DevicePath);
+ }
+
+ public int CheckKeyByFindort_3()
+ {
+ //使用普通算法二查找指定的加密锁
+ string DevicePath = ""; //用于储存加密锁所在的路径
+ //@NoUseCode_FindPort_3 return 2;//如果这个锁不支持这个功能，直接返回2
+ return 2;
+ //return FindPort_3(0, 1, 16711934, ref DevicePath);
+ }
+
+ //使用带长度的方法从指定的地址读取字符串
+ public int ReadStringEx(int addr, ref string outstring, string DevicePath)
+ {
+ int nlen, ret;
+ byte[] buf = new byte[1];
+ //先从地址0读到以前写入的字符串的长度
+ ret = YRead(buf, (short)addr, (short)1, "E1930089", "C7326137", DevicePath);
+ if (ret != 0) return ret;
+ nlen = buf[0];
+ //再读取相应长度的字符串
+ return YReadString(ref outstring, addr + 1, nlen, "E1930089", "C7326137", DevicePath);
+ }
+
+ //使用从储存器读取相应数据的方式检查是否存在指定的加密锁
+ public int CheckKeyByReadEprom()
+ {
+ int n, ret;
+ string DevicePath = ""; //用于储存加密锁所在的路径
+ string outstring = "";
+ return 1; //如果没有使用这个功能，直接返回1
+ for (n = 0; n < 255; n++)
+ {
+ ret = FindPort(n, ref DevicePath);
+ if (ret != 0) return ret;
+ ret = ReadStringEx(0, ref outstring, DevicePath);
+ if ((ret == 0) && (outstring.CompareTo("") == 0)) return 0;
+ }
+
+ return -92;
+ }
+
+ //使用增强算法一检查加密锁，这个方法可以有效地防止仿真
+ public int CheckKeyByEncstring()
+ {
+ //推荐加密方案：生成随机数，让锁做加密运算，同时在程序中端使用代码做同样的加密运算，然后进行比较判断。
+
+ int n, ret;
+ string DevicePath = ""; //用于储存加密锁所在的路径
+ string InString;
+
+ //@NoUseKeyEx return 1;//如果没有使用这个功能，直接返回1
+ System.Random rnd = new System.Random();
+
+ InString = rnd.Next(0, 32767).ToString("X") + rnd.Next(0, 32767).ToString("X");
+
+ for (n = 0; n < 255; n++)
+ {
+ ret = FindPort(n, ref DevicePath);
+ if (ret != 0) return ret;
+ if (Sub_CheckKeyByEncstring(InString, DevicePath) == 0) return 0;
+ }
+
+ return -92;
+ }
+
+ private int Sub_CheckKeyByEncstring(string InString, string DevicePath)
+ {
+ //使用增强算法一对字符串进行加密
+ int ret;
+ string outstring = "";
+ string outstring_2;
+ ret = EncString(InString, ref outstring, DevicePath);
+ if (ret != 0) return ret;
+ outstring_2 = StrEnc(InString, "389217D0F16CB88A512E734C70DB4F8E");
+ if (outstring_2.CompareTo(outstring) == 0) //比较结果是否相符
+ {
+ ret = 0;
+ }
+ else
+ {
+ ret = -92;
+ }
+
+ return ret;
+ }
+
+ //使用增强算法二检查是否存在对应的加密锁
+ public int CheckKeyByEncstring_New()
+ {
+ int n, ret;
+ string DevicePath = ""; //用于储存加密锁所在的路径
+ string outstring = "";
+ System.Random rnd = new System.Random();
+ int myrnd = rnd.Next(0, 500);
+ String[] EncInString =
+ {
+ "10553", "19783", "19946", "15766", "29138", "17249", "7140", "25299", "29856", "864", "8881", "6675",
+ "3053", "9827", "7918", "5508", "26913", "16430", "23892", "22265", "20167", "12580", "17597", "4582",
+ "27273", "6212", "36", "11611", "20274", "25906",
+ "18593", "26122", "3756", "2608", "20335", "4168", "29694", "19999", "18409", "31234", "23893", "16003",
+ "4488", "27853", "13818", "16763", "486", "20444", "4184", "18379", "20157", "27135", "24566", "7894",
+ "6119", "17320", "21378", "25243", "4447", "10475",
+ "20164", "4031", "19773", "19319", "1190", "13697", "9660", "1185", "12593", "18373", "18231", "14169",
+ "29585", "4366", "23078", "21041", "18447", "17531", "19749", "29020", "8726", "12241", "16110", "8365",
+ "9774", "3440", "2137", "15763", "1027", "30298",
+ "26209", "31010", "28765", "29746", "17440", "31243", "16168", "13114", "9425", "7843", "7533", "21587",
+ "11725", "24279", "27477", "24320", "20621", "20029", "13869", "21347", "5294", "15877", "21084",
+ "23613", "487", "32514", "5486", "8434", "10771", "17318",
+ "12299", "14209", "21292", "8706", "10239", "13966", "16716", "13769", "29234", "26459", "8366",
+ "25164", "11440", "6090", "4011", "13438", "30881", "3164", "18620", "25840", "29778", "4660", "27773",
+ "31189", "21802", "12563", "27559", "2304", "8629", "32091",
+ "4373", "6624", "2971", "2577", "11199", "10121", "27047", "31442", "22720", "17069", "20932", "13796",
+ "27986", "21405", "21243", "13864", "209", "31820", "20342", "32030", "5811", "6732", "30335", "9452",
+ "26773", "26830", "24192", "4688", "20528", "17061",
+ "16132", "18094", "20830", "1091", "19123", "20999", "17433", "3513", "10585", "25854", "7804", "25785",
+ "4575", "726", "24255", "30359", "1103", "21358", "5438", "31298", "9171", "5450", "3698", "29263",
+ "12469", "12172", "7413", "20207", "8799", "25589",
+ "897", "12275", "24923", "8424", "32496", "18125", "8532", "29542", "28732", "22672", "23314", "6419",
+ "9856", "24558", "26241", "12846", "18676", "20280", "13482", "5020", "24820", "29281", "10679",
+ "14557", "1017", "28923", "5874", "22035", "7581", "28727",
+ "21701", "2562", "22937", "21736", "31930", "12298", "11722", "9600", "17276", "21037", "1064", "3088",
+ "29395", "15119", "1228", "30794", "940", "10224", "32753", "24962", "22541", "6834", "30705", "10408",
+ "5411", "19416", "19271", "6735", "7480", "15492",
+ "32396", "4264", "10676", "26743", "9851", "13702", "1314", "6164", "29163", "25690", "25900", "21084",
+ "21466", "11320", "25757", "28402", "19807", "29135", "7518", "18456", "22454", "12660", "25208",
+ "3248", "28215", "24854", "6680", "12859", "14430", "29258",
+ "14213", "1756", "21444", "29760", "21802", "25428", "15907", "21963", "28305", "32005", "24405",
+ "18269", "14949", "22515", "13141", "15623", "9326", "22719", "5180", "4220", "26520", "30377", "9283",
+ "17165", "18412", "3478", "22469", "24493", "27795", "20486",
+ "7997", "31981", "23002", "22812", "12612", "24321", "2857", "24217", "29844", "14777", "11529", "737",
+ "2568", "4744", "30500", "18163", "30359", "17023", "9800", "7283", "27999", "6225", "5723", "6051",
+ "14744", "6735", "31847", "16740", "18587", "26731",
+ "16536", "2362", "21476", "15929", "30775", "22340", "11020", "5354", "32686", "15942", "7629", "25934",
+ "13448", "19874", "1538", "2522", "20333", "858", "29090", "16542", "24105", "24079", "27850", "19789",
+ "23972", "3844", "27572", "15160", "29674", "19482",
+ "21689", "16210", "18980", "16852", "10835", "14893", "1693", "9556", "21788", "23034", "26300",
+ "26203", "3534", "23692", "30991", "333", "26435", "29012", "30525", "28968", "30837", "15206", "16402",
+ "16787", "9855", "29553", "29046", "16589", "3738", "10698",
+ "8822", "20920", "4127", "10337", "15673", "24023", "30345", "29896", "30985", "26444", "17268",
+ "29234", "29779", "15064", "6295", "9074", "28318", "16862", "16845", "3320", "8854", "29791", "24336",
+ "14037", "16387", "27391", "11899", "20158", "1490", "4350",
+ "30278", "27139", "31753", "30270", "3789", "26519", "19925", "16706", "3209", "29196", "17279",
+ "16684", "2580", "8596", "23665", "8126", "4648", "15871", "2358", "13144", "10655", "8386", "1399",
+ "28926", "31090", "14061", "20989", "32339", "6335", "9011",
+ "20147", "25495", "30394", "32741", "29860", "23980", "25794", "16630", "12281", "20501", "16463",
+ "13816", "23036", "22260", "15611", "11292", "21272", "30986", "20096", "12341"
+ };
+ String[] EncOutString =
+ {
+ "C1E62AA68D77F26C", "382473C34EAFCB90", "9046D801EBC6F987", "FA693CD753862224", "28E488C974B183F5",
+ "A236C8056BC74311", "12DE5A5D0A37E0BB", "7D4B973873D32A7E", "0712AFC4E796F724", "D7773040D01D0B52",
+ "776ADB90595F0407", "FC5E71B4F5D911E1", "6F035CA0D25DE983", "66A85CFE63FD3BBE", "66E583FBEFBC92B6",
+ "D5574F80CF6E9410", "E22699779F27BE0C", "6187E40A7EB277F6", "BC93CBC18B89D9BB", "F5F054BBEC12575E",
+ "C3794A7771F66A40", "17023D941AD4866A", "B03FC0DA94DFD1AC", "8785CF1D1667F073", "B95DF7A5821286D4",
+ "AE8E7B0E9045BACF", "5DB74AB530197B8A", "7668E2D871451EA2", "B6E17097428202A5", "959599240234F50C",
+ "06E5577C18519D22", "D81CFCA41339C658", "95E3C76D2AA0B89A", "223775F6400C09E4", "170FEC2DF4A53B21",
+ "CB6F2FB44E5CC3A5", "188D7C3E77E1E8F0", "6565E19FA93DC971", "898476103159C69F", "BE2E067CFF145CA9",
+ "9C08447205F853B6", "4DEFED252CF6C824", "2695F0B4DA7E83A5", "2350B70EFA87390F", "603DD571FB0D9549",
+ "B08D94399039920F", "4B3F27F00D5598F8", "F75C4EC69BAAE07B", "AB4A41272F043447", "051B199E1F61F0E7",
+ "638F42AE37FB04D1", "9DB172A9138C7FA6", "EF325430E9CD17EF", "34C8A3B8463B0C99", "E475B479998265E7",
+ "664005AE2C7E2536", "8B1A5F87434C712F", "AD6DD3ECAD35ED6D", "1FB00CF2E1D02AF5", "9AA185A2299C5DD0",
+ "3776A6A5134B7F14", "BA55E5BF66E5B14E", "E65824033AE1E6DF", "FA7176107DC7924C", "D348B34E2BB64CDE",
+ "DE7B1049DFFEC1C0", "0CE41D0233218EA8", "1D69487327859BD1", "83E4279C9D4E1388", "CA51085554E8FE2D",
+ "AB87E5F7633985C2", "FCD8B2EDAEE6E8AA", "A5318D85DCABF24C", "658644BBBAEE42D0", "0573EC6BD7F019E3",
+ "5C8B106A7769A6BB", "EA2A24F53CD57BF7", "7B019D9C62E6DF45", "DCCCE86016BC412C", "78B7AC961D4A35F3",
+ "655207DC6D85CB03", "71446A24B87896BF", "C865B9ABF4E3D4E7", "52BA4883758F0B17", "F2B8DD8547C74872",
+ "82C05F46DFD80CA8", "AA14A081C3CE1A37", "51C7D0922697C864", "36C2EAAE3539CBD6", "4C40005B44F82538",
+ "BF546F66114AFA1A", "2F823EC453F4C717", "9565F8F155EFBCDA", "2007A053C5013AF6", "A8624A400C05D5BA",
+ "BC1CC0A1BFA1F0DA", "6A9E8DFF9EE95967", "34E2AFD6AD845052", "F30206A8F05651FF", "D7249CCA67FDA77C",
+ "EAA7AACF0906355F", "1948FB636AD0B240", "F5B77831170E279C", "BF9D5EA9FFC56895", "3116EEC8A0FB0B46",
+ "31D677ECA624375C", "E26CC8EBAB5F2D34", "7532C7424FA1B6D2", "8179159D7AA6EECB", "70DF923D88618F1A",
+ "29EEEEAF541CE27D", "5BE2A73E011E6C7A", "D7AE78369D0EF293", "89B641BB3E44A2C4", "3B166ECFFF78E313",
+ "E757430C97ABED2D", "DBFC50731B1A350C", "91AF88D11AC39C09", "FC564F75D2B30B3D", "1D0DAF06B919FC31",
+ "937F583EAD80D3D4", "C6840C5D73A81C4C", "B2FB75B17BA7BB8D", "E852018DCC07F8FA", "CDEEB7BE769F818A",
+ "7AC0779CCD5B52AD", "D901C86680973AD6", "466FE65AA996EAAF", "32761ECFE13FCBE6", "B5D4D1D066AC420C",
+ "D8B87FEA2FDD97B4", "72BA756CA6E7FD76", "F8793140D31FEB92", "5C78364299061112", "7AAABBFE4960B3F0",
+ "75D095F945A7DBB8", "9C0B76404D58273F", "B0F9AB228C1EF410", "AE6C4F91FE02B1DE", "1C99CE616A229159",
+ "F6C9B7ECFF2F6ECD", "C220AFD378F2E80F", "42367BACDBB66DC0", "DA04974888B8C018", "F39404A5A3070C56",
+ "13887E2AC1FEFB70", "DBFC5EFB1447B93A", "AB246AEF5D7EF830", "5C96A44BC82EB00C", "178A2A70720ADC88",
+ "90FC4555575D3706", "1F28FAF438B06052", "29B226B43F66E5F0", "AC79F224028C6FBE", "81CD83469F8E60E5",
+ "F97B052844950578", "653AA775345A0D41", "7495AF5627B17B2A", "7BAEDE2CA9BCA778", "AC49B94AF2F7D8D5",
+ "8D30814C7229159B", "72FCB739499A32B8", "1CAF5A42931A42F3", "35E822ACCD0775B2", "30AE680F4EDBCC73",
+ "3AB6BCCA4198E19F", "101B8C787CD8DE3D", "FE9C0B22B0DA9168", "D6B2FE5BF1FF178F", "1D17717ED7FB67C9",
+ "E173455B6D362F9D", "CF30BF25A91455BF", "E1A9AE779D5895CF", "D4728D158CD9EE96", "225A201374C7E1B8",
+ "BC52635AF11CAA04", "0C90748256DAB8DA", "EEA7E043E4412880", "24C39C47F02AAFC2", "47D42B5130CC982B",
+ "134ABB1C2C95BF9B", "6EB2396DE7910EEF", "184E1D16BE28BFFB", "C520226B5395B227", "FED1D880638834D6",
+ "5F0537B6AE0D89F8", "81E3742EF183BA69", "2033BB7455913DC1", "2CB46A398182424E", "53803FE9AA33513F",
+ "420D0DA81D3A8504", "0CE95996CD34A382", "7A93D08FD5048C0B", "57387F22E11AA2FC", "9BC169C3A32C1AFA",
+ "6AB950B4E71D434A", "FADDD7A201D9BEBA", "F6D87D6DC316F223", "76E35BC267BF1337", "1C7CFAE2198D1A07",
+ "22BD5502D17A0237", "519AED517AFBCAE0", "34AAACCAE82C9A13", "A2757FAD5626AC5F", "83E926B46AC0C2B5",
+ "8B6B9F38747AB541", "AA1C5EED41130D9B", "DE8FF32A57157F11", "804F7144E792FD11", "E227F2072C0B3155",
+ "5F05958C2A9FDBA2", "B1DA7D580F53E48A", "55910179EFD9E0B0", "811D5F3DD3CBC65D", "AE5CA8292B50BB53",
+ "57A2241F414FBCAD", "2888E24602379D83", "F584BF1B9077F85F", "EE181E416EBBC002", "ED1347DC7429CFB4",
+ "5D97CF65CE4D9EC0", "890D53425BF94CED", "0BA292D19CE5148A", "84D2D04602A834BD", "A73B33BE5068864F",
+ "83B360BE49849BA7", "663576163C51F342", "46D2F349DF191ECD", "A0B46B0C18920C55", "D9A4290F4B9F217A",
+ "1C5FC778190ACB4E", "B95B1364B7E7EECD", "ED40DC41F5BFC3AB", "5B157E859FD59169", "C20BA26FD8276496",
+ "D34932A94F9CE8BE", "851DC76D0E03802F", "05510909416351D3", "30BD565075997975", "CFCF79ACD1718353",
+ "90395E844546B8B0", "95A04192C4A99D52", "AB0F8AEA1FBEED05", "B7AE633E5E5B0B9D", "35223BD9EF30AFA2",
+ "8FCD116A4085E1F2", "841F30FF22B171AA", "9C8D7D3C8F2A62AB", "BA05E5F44937CA77", "311CFACDD6F06F9D",
+ "C171FE410BE63E31", "03814B11FFB87D3E", "BC68642D76C89F09", "8756CC7ED9D75FF6", "6757414D8C78E34B",
+ "6F938EE4BFEFCF39", "2D3A13C3F233037E", "938570777EC3A30D", "9728AE4D851E81A1", "C2555FD6E19C3F38",
+ "D51F5C01CBB65D31", "A5C7117E6CBD972E", "00B0242C804B8154", "0EC21FD2D9043834", "5D71C1F8B2792BF8",
+ "2F8DC1EDA72C1652", "1338A3790D2424BB", "CD626189FF05FF86", "C51FEDF73205DF8E", "AB27F7448A83A9CE",
+ "0D46289E4D15E0FB", "B99FCF3F39E65B81", "E6F0A1169CBD1441", "8997DDCE1478D784", "5B581D25972CEF76",
+ "2F7E2C8EA3AE100B", "A5CA820BEC458A34", "BA04897779586515", "CFC2D99BBFA57BC3", "3289C26E0D2A8DCE",
+ "3DAF4091DEDD9D52", "D7AE78369D0EF293", "D3A3CA54DEE75273", "BC49B70EC956A03F", "597ED794EAB95D5F",
+ "5546CC4FEB26D549", "7D2A20B6CDA86BB5", "CF5D90FF1AF85083", "D60759480D68671D", "449DCFABD01FA9A8",
+ "2C300F3C0D32C8B1", "A8C29C56B46E5A97", "5E562AABD22414AC", "EAA77EBE4AFA7198", "4D36EE5BF46B2FC8",
+ "2A13AE8CEE6AA8FF", "5C624ABA4135BA8F", "491D6550F48D1126", "A117FA84167472D5", "153364AA485FF4FD",
+ "CC901986B08E6F4D", "3225378A5AF745BB", "01A8746A2B7E7182", "10FD8BCC6839F641", "F39404A5A3070C56",
+ "CC4281C870E98FAC", "C32DD966C0911ECD", "75D53D58DA0A70C5", "D84144D87358F716", "4420E1E870AC1AC7",
+ "EEC04DAFE6659C67", "1EE6ED19E6D1F548", "10088800D9EA8484", "BA0E440265568FC3", "6A79A4027DC9D4C7",
+ "7D564FAD598FD71E", "F7775FAE079EB4C9", "E3013B5B058573BB", "2D5FF3FB6874560C", "66909ED4393E998E",
+ "3FDD7F237A882F4E", "82463C64AC7D665E", "C79F95A4A56C81C8", "329526DD264F8A07", "3E277CE73B1DD6B6",
+ "AA76F8BB4839C72D", "88806A6CF45F5439", "0254BDF538B70B99", "97B37E0DD8EEA2BD", "49E03A838A5C4FFE",
+ "F83A31773938C4ED", "0F9314BAED157FE3", "59C738EB7CE00FBC", "9CFC7E5908186F73", "A36065CCDE877BB4",
+ "1EAAA733468A6019", "360FC0E131E4CC1C", "25607B762A1912F6", "151FA7D6B6C38BFB", "1DCF229C02EE920C",
+ "E44F1A0FAECCA2E4", "BA77D98DE2255D16", "E8E1FFEF014D8191", "6757AB22B326D8D7", "CAFB058DB98410BE",
+ "CDF2CB6724C8A377", "6AB950B4E71D434A", "DEBD85FCF06FE7FC", "F8D4DED46C08C557", "F336CE213892CDF0",
+ "B8286C2A9BC957A4", "2066C93EDF7A3C10", "B86B77DBFF5E837F", "87CBCC5F55CF43FD", "BC4A994D13CA2CD9",
+ "CD626189FF05FF86", "B74A74ADB51394D8", "B9822A1A2109D936", "E5868A2E179903C1", "388903BA3E36418D",
+ "95EB34D874063AD6", "8C8C66A7CE733BB0", "7BBF7CC10AFEBDE9", "43F108D358DBF0D4", "4395B49A18044F2A",
+ "CF5109A9A6983D7F", "C61E7854F2169888", "BE6EB2FB54D6ECA8", "14728C58CD3E799E", "A375923C1A54C8A5",
+ "7AB48632CE35A523", "FCE6BBCE9CCC676E", "8BB67E5E0AFA1592", "285B1FF5FF6784FE", "277A4FAD4B6DB505",
+ "76BAE9F2EA376065", "B29823DC293436F9", "D2FA7FA7483B3A92", "D66E7F06AE8FD2B2", "BF9AE5AFDC703102",
+ "3F0FFD22EDEE952C", "E628DAF8829B1997", "0E32DA43088F068E", "2D1927F21BBBB9DA", "49F7AA07DAF523BA",
+ "C8F8FDCDD0CED748", "BFEDFBF17219D73C", "17FAD1D1923D5FB9", "9FEF66E3274DDB91", "1001FA3B5AE5AD0C",
+ "79E86333D9152ED6", "2EB1C753BAB7DA0D", "94CD99C3D1295F28", "F4AD081B7327C65B", "AFF84D2307E0004A",
+ "8C4D945B235DF70D", "9430D196ED501BF0", "885D1E52A651F72B", "86762B897D2D7DC8", "BA49CEEB36979C54",
+ "3346D32437F20BA7", "D8D72F656297CF6E", "109C0C7EFBBAFF8A", "B16E1D9A13EC8ED0", "0FA523D673D40F8D",
+ "44C4A24338491722", "BB9BD15CB1D218AA", "D05C80DCC2FABD6F", "E4E1E9670EEB8EF1", "21262FFB226D913B",
+ "736D33A1261A6665", "FD35A67BA0EAFD5B", "AFE2C45CCE183477", "D809EB8109C693FA", "D2F1DDFE9B55FCB0",
+ "6C2344567DBED2B5", "4422B3FCE37C6A74", "245FE0EE6155E84B", "F0216CBD4B5FACEA", "7B74C39A819F9565",
+ "8DB23551362C3CA0", "E6422F1BA2AF21B9", "EFA99BF359C6EFDC", "A295DD974B576A0E", "8BC3564BEE4C6301",
+ "50E38A69412D0CDD", "157D4D5E98CBBB34", "9C926329C9F6A489", "B1D222A23E86CD08", "C411C62E8DF23668",
+ "DD19D9775EB46262", "32761ECFE13FCBE6", "084417836778EB4D", "F15829D37A7314E5", "4F7B06B15FEE2707",
+ "10DB3275004C79AD", "BEAA74A8913D0445", "E008EA199670C28E", "676C34B32958D680", "76E4A9FE97A497A1",
+ "6CB7F4D7E13CC00B", "A12251D86CC4F5DF", "586393DAE93A348A", "A15E06F138A6D461", "AA580F9FD8DD4901",
+ "50C5BCD7D0614F0C", "116EA518B037B48A", "A1705FE72C12390B", "953C047DF74D0341", "ABD21234CF9D29E4",
+ "855791A5CC995465", "A012A1A8362E3F2D", "9167CAB444658E1C", "3B623E11D26E55E4", "100A976A19BE9230",
+ "56637BD09EC70A1E", "DF46663A3EE76DE0", "45408E72328A2F53", "A12012445EB86F26", "CC5CF9D0685A8CAD",
+ "5778ECFF8C1C085F", "7094B21B545BBF9E", "6EDADC7C54073FD3", "0CDC5A12BF2EA459", "F05D4B3E557BDAD1",
+ "BB2A498F1666A01E", "0D75D870486661B9", "9362E7108C3D98C1", "06087161793B3368", "2224A28409722E98",
+ "C3387717CFC1AAD6", "CD86078F76A17B9C", "60538B976EA9965C", "D2E25D5D00C9CC01", "4DB3017CA1BE6B53",
+ "B0368AE0514F1247", "4321BE32BB189DF1", "4F83770DE9C5BA09", "F4905FDDB68B6CBF", "8A68A38F955CDA6A",
+ "9BC6971147743E8E", "290222CBED992731", "15638B59E525F5A0", "419FD9CAE4EF021F", "F95A4B6A78DBA7ED",
+ "6146A0CC3DBDB82A", "C6113F6D40D21E50", "90CA7BD1A145331E", "A1E2270416BD555F", "B43D6A9230EAEA2F",
+ "EC57F08BF05A0EEC", "1F59C2EA1721D03D", "7F56DB73A960CD06", "79CBDFDADA190B10", "7DD10E9EFB3C0351",
+ "C1CCB89780B9C8C9", "A97D417450C5AE3C", "B5767CE314B55F4C", "576E5F13051AD639", "F277D3FA64CBC89B"
+ };
+ //@NoUseNewKeyEx return 1;//如果没有使用这个功能，直接返回1
+ //@NoSupNewKeyEx return 2;//如果该锁不支持这个功能，直接返回2
+ for (n = 0; n < 255; n++)
+ {
+ ret = FindPort(n, ref DevicePath);
+ if (ret != 0) return ret;
+ ret = EncString_New(EncInString[myrnd], ref outstring, DevicePath);
+ if ((ret == 0) && (outstring.CompareTo(EncOutString[myrnd]) == 0)) return 0;
+ }
+
+ return -92;
+ }
+ }
+}
\ No newline at end of file