using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;
namespace Team.Utility
{
//公共函数说明
//***查找加密锁
//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 );
public struct GUID
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] Data1;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] Data2;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public byte[] Data3;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public byte[] Data4;
}
public struct SP_INTERFACE_DEVICE_DATA
{
public int cbSize;
public GUID InterfaceClassGuid;
public int Flags;
public IntPtr Reserved;
}
public struct SP_DEVINFO_DATA
{
public int cbSize;
public GUID ClassGuid;
public int DevInst;
public IntPtr Reserved;
}
public struct SP_DEVICE_INTERFACE_DETAIL_DATA
{
public int cbSize;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 255)]
public byte[] DevicePath;
}
public struct HIDD_ATTRIBUTES
{
public int Size;
public ushort VendorID;
public ushort ProductID;
public ushort VersionNumber;
}
public struct HIDP_CAPS
{
public short Usage;
public short UsagePage;
public short InputReportByteLength;
public short OutputReportByteLength;
public short FeatureReportByteLength;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public short[] Reserved;
public short NumberLinkCollectionNodes;
public short NumberInputButtonCaps;
public short NumberInputValueCaps;
public short NumberInputDataIndices;
public short NumberOutputButtonCaps;
public short NumberOutputValueCaps;
public short NumberOutputDataIndices;
public short NumberFeatureButtonCaps;
public short NumberFeatureValueCaps;
public short NumberFeatureDataIndices;
}
public class SoftKey
{
private const ushort VID = 0x3689;
private const ushort PID = 0x8762;
private const ushort PID_NEW = 0X2020;
private const ushort VID_NEW = 0X3689;
private const ushort PID_NEW_2 = 0X2020;
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 = 495;
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操作失败，可能是没有找到相关的指令
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;
[DllImport("kernel32.dll")]
public static extern int lstrlenA(string InString);
[DllImport("kernel32.dll", EntryPoint = "RtlMoveMemory")]
public static extern void CopyStringToByte(byte[] pDest, string pSourceg, int ByteLenr);
[DllImport("kernel32.dll", EntryPoint = "RtlMoveMemory")]
public static extern void CopyByteToString(StringBuilder pDest, byte[] pSource, int ByteLenr);
[DllImport("HID.dll")]
private static extern bool HidD_GetAttributes(IntPtr HidDeviceObject, ref HIDD_ATTRIBUTES Attributes);
[DllImport("HID.dll")]
private static extern int HidD_GetHidGuid(ref GUID HidGuid);
[DllImport("HID.dll")]
private static extern bool HidD_GetPreparsedData(IntPtr HidDeviceObject, ref IntPtr PreparsedData);
[DllImport("HID.dll")]
private static extern int HidP_GetCaps(IntPtr PreparsedData, ref HIDP_CAPS Capabilities);
[DllImport("HID.dll")]
private static extern bool HidD_FreePreparsedData(IntPtr PreparsedData);
[DllImport("HID.dll")]
private static extern bool HidD_SetFeature(IntPtr HidDeviceObject, byte[] ReportBuffer, int ReportBufferLength);
[DllImport("HID.dll")]
private static extern bool HidD_GetFeature(IntPtr HidDeviceObject, byte[] ReportBuffer, int ReportBufferLength);
[DllImport("SetupApi.dll")]
private static extern IntPtr
SetupDiGetClassDevsA(ref GUID ClassGuid, int Enumerator, int hwndParent, int Flags);
[DllImport("SetupApi.dll")]
private static extern bool SetupDiDestroyDeviceInfoList(IntPtr DeviceInfoSet);
[DllImport("SetupApi.dll")]
private static extern bool SetupDiGetDeviceInterfaceDetailA(IntPtr DeviceInfoSet,
ref SP_INTERFACE_DEVICE_DATA DeviceInterfaceData,
ref SP_DEVICE_INTERFACE_DETAIL_DATA DeviceInterfaceDetailData, int DeviceInterfaceDetailDataSize,
ref int RequiredSize, int DeviceInfoData);
[DllImport("SetupApi.dll")]
private static extern bool SetupDiEnumDeviceInterfaces(IntPtr DeviceInfoSet, int DeviceInfoData,
ref GUID InterfaceClassGuid, int MemberIndex, ref SP_INTERFACE_DEVICE_DATA DeviceInterfaceData);
[DllImport("kernel32.dll", EntryPoint = "CreateFileA")]
private static extern IntPtr CreateFile(string lpFileName, uint dwDesiredAccess, uint dwShareMode,
uint lpSecurityAttributes, uint dwCreationDisposition, uint dwFlagsAndAttributes, uint hTemplateFile);
[DllImport("kernel32.dll")]
private static extern int CloseHandle(IntPtr hObject);
[DllImport("kernel32.dll")]
private static extern int GetLastError();
[DllImport("kernel32.dll", EntryPoint = "CreateSemaphoreA")]
private static extern IntPtr CreateSemaphore(int lpSemaphoreAttributes, int lInitialCount, int lMaximumCount,
string lpName);
[DllImport("kernel32.dll")]
private static extern int WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds);
[DllImport("kernel32.dll")]
private static extern int ReleaseSemaphore(IntPtr hSemaphore, int lReleaseCount, int lpPreviousCount);
//以下函数用于将字节数组转化为宽字符串
private 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)
{
int nlen;
int retutn_len;
int n, i;
string temp;
nlen = InString.Length;
if (nlen < 16) retutn_len = 16;
retutn_len = nlen / 2;
b = new byte[retutn_len];
i = 0;
for (n = 0; n < nlen; n = n + 2)
{
temp = InString.Substring(n, 2);
b[i] = (byte) HexToInt(temp);
i = i + 1;
}
return retutn_len;
}
public void EnCode(byte[] inb, byte[] outb, string Key)
{
uint cnDelta, y, z, a, b, c, d, temp_2;
uint[] buf = new uint[16];
int n, i, nlen;
uint 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)
{
uint cnDelta, y, z, a, b, c, d, temp_2;
uint[] buf = new uint[16];
int n, i, nlen;
uint 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;
nlen = lstrlenA(inString) + 1;
if (nlen < 8)
outlen = 8;
else
outlen = nlen;
b = new byte[outlen];
outb = new byte[outlen];
CopyStringToByte(b, inString, nlen);
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;
StringBuilder 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 = new StringBuilder("", outlen);
CopyByteToString(c_str, outb, outlen);
return c_str.ToString();
}
private bool isfindmydevice(int pos, ref int count, ref string OutPath)
{
return Subisfindmydevice(pos, ref count, ref OutPath);
}
private bool Subisfindmydevice(int pos, ref int count, ref string OutPath)
{
IntPtr hardwareDeviceInfo;
SP_INTERFACE_DEVICE_DATA DeviceInfoData = new SP_INTERFACE_DEVICE_DATA();
int i;
GUID HidGuid = new GUID();
SP_DEVICE_INTERFACE_DETAIL_DATA functionClassDeviceData = new SP_DEVICE_INTERFACE_DETAIL_DATA();
int requiredLength;
IntPtr d_handle;
HIDD_ATTRIBUTES Attributes = new HIDD_ATTRIBUTES();
i = 0;
count = 0;
HidD_GetHidGuid(ref HidGuid);
hardwareDeviceInfo = SetupDiGetClassDevsA(ref HidGuid, 0, 0, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
if (hardwareDeviceInfo == (IntPtr) INVALID_HANDLE_VALUE) return false;
DeviceInfoData.cbSize = Marshal.SizeOf(DeviceInfoData);
while (SetupDiEnumDeviceInterfaces(hardwareDeviceInfo, 0, ref HidGuid, i, ref DeviceInfoData))
{
if (GetLastError() == ERROR_NO_MORE_ITEMS) break;
if (System.IntPtr.Size == 4)
functionClassDeviceData.cbSize = Marshal.SizeOf(functionClassDeviceData) - 255; // 5;
else
functionClassDeviceData.cbSize = 8;
requiredLength = 0;
if (!SetupDiGetDeviceInterfaceDetailA(hardwareDeviceInfo, ref DeviceInfoData,
ref functionClassDeviceData, 300, ref requiredLength, 0))
{
SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);
return false;
}
OutPath = ByteConvertString(functionClassDeviceData.DevicePath);
d_handle = CreateFile(OutPath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
OPEN_EXISTING, 0, 0);
if ((IntPtr) INVALID_HANDLE_VALUE != d_handle)
{
if (HidD_GetAttributes(d_handle, ref Attributes))
{
if ((Attributes.ProductID == PID) && (Attributes.VendorID == VID) ||
(Attributes.ProductID == PID_NEW) && (Attributes.VendorID == VID_NEW) ||
(Attributes.ProductID == PID_NEW_2) && (Attributes.VendorID == VID_NEW_2))
{
if (pos == count)
{
SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);
CloseHandle(d_handle);
return true;
}
count = count + 1;
}
}
CloseHandle(d_handle);
}
i = i + 1;
}
SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);
return false;
}
private bool GetFeature(IntPtr hDevice, byte[] array_out, int out_len)
{
bool FeatureStatus;
bool Status;
int i;
byte[] FeatureReportBuffer = new byte[512];
IntPtr Ppd = System.IntPtr.Zero;
HIDP_CAPS Caps = new HIDP_CAPS();
if (!HidD_GetPreparsedData(hDevice, ref Ppd)) return false;
if (HidP_GetCaps(Ppd, ref Caps) <= 0)
{
HidD_FreePreparsedData(Ppd);
return false;
}
Status = true;
FeatureReportBuffer[0] = 1;
FeatureStatus = HidD_GetFeature(hDevice, FeatureReportBuffer, Caps.FeatureReportByteLength);
if (FeatureStatus)
{
for (i = 0; i < out_len; i++)
{
array_out[i] = FeatureReportBuffer[i];
}
}
Status = Status && FeatureStatus;
HidD_FreePreparsedData(Ppd);
return Status;
}
private bool SetFeature(IntPtr hDevice, byte[] array_in, int in_len)
{
bool FeatureStatus;
bool Status;
int i;
byte[] FeatureReportBuffer = new byte[512];
IntPtr Ppd = System.IntPtr.Zero;
HIDP_CAPS Caps = new HIDP_CAPS();
if (!HidD_GetPreparsedData(hDevice, ref Ppd)) return false;
if (HidP_GetCaps(Ppd, ref Caps) <= 0)
{
HidD_FreePreparsedData(Ppd);
return false;
}
Status = true;
FeatureReportBuffer[0] = 2;
for (i = 0; i < in_len; i++)
{
FeatureReportBuffer[i + 1] = array_in[i + 1];
}
FeatureStatus = HidD_SetFeature(hDevice, FeatureReportBuffer, Caps.FeatureReportByteLength);
Status = Status && FeatureStatus;
HidD_FreePreparsedData(Ppd);
return Status;
}
private int NT_FindPort(int start, ref string OutPath)
{
int count = 0;
if (!isfindmydevice(start, ref count, ref OutPath))
{
return -92;
}
return 0;
}
private int NT_FindPort_2(int start, int in_data, int verf_data, ref string OutPath)
{
int count = 0;
int pos;
int out_data = 0;
int ret;
for (pos = start; pos < 256; pos++)
{
if (!isfindmydevice(pos, ref count, 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(ref IntPtr hUsbDevice, string Path)
{
string OutPath;
bool biao;
int count = 0;
if (Path.Length < 1)
{
OutPath = "";
biao = isfindmydevice(0, ref count, ref OutPath);
if (!biao) return -92;
hUsbDevice = CreateFile(OutPath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hUsbDevice == (IntPtr) INVALID_HANDLE_VALUE) return -92;
}
else
{
hUsbDevice = CreateFile(Path, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hUsbDevice == (IntPtr) INVALID_HANDLE_VALUE) return -92;
}
return 0;
}
private int NT_Read(ref byte ele1, ref byte ele2, ref byte ele3, ref byte ele4, string Path)
{
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
if (!GetFeature(hUsbDevice, array_out, 5))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
ele1 = array_out[0];
ele2 = array_out[1];
ele3 = array_out[2];
ele4 = array_out[3];
return 0;
}
private int NT_Write(byte ele1, byte ele2, byte ele3, byte ele4, string Path)
{
byte[] array_in = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0)
{
return -92;
}
array_in[1] = 3;
array_in[2] = ele1;
array_in[3] = ele2;
array_in[4] = ele3;
array_in[5] = ele4;
if (!SetFeature(hUsbDevice, array_in, 5))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
return 0;
}
private int NT_Write_2(byte ele1, byte ele2, byte ele3, byte ele4, string Path)
{
byte[] array_in = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 4;
array_in[2] = ele1;
array_in[3] = ele2;
array_in[4] = ele3;
array_in[5] = ele4;
if (!SetFeature(hUsbDevice, array_in, 5))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
return 0;
}
private int GetIDVersion(ref short Version, string Path)
{
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 1;
if (!SetFeature(hUsbDevice, array_in, 1))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 1))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
Version = array_out[0];
return 0;
}
private int NT_GetID(ref int ID_1, ref int ID_2, string Path)
{
int[] t = new int[8];
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 2;
if (!SetFeature(hUsbDevice, array_in, 1))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 8))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
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 0;
}
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;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 0x12;
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];
}
if (!SetFeature(hUsbDevice, array_in, 13))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, nlen + 1))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0)
{
return -83;
}
for (n = 0; n < nlen; n++)
{
OutData[n + pos] = array_out[n + 1];
}
return 0;
}
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;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 0x13;
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];
}
if (!SetFeature(hUsbDevice, array_in, 13 + nlen))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 2))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0)
{
return -82;
}
return 0;
}
private int NT_Cal(byte[] InBuf, byte[] outbuf, string Path, int pos)
{
int n;
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 8;
for (n = 2; n <= 9; n++)
{
array_in[n] = InBuf[n - 2 + pos];
}
if (!SetFeature(hUsbDevice, array_in, 9))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 9))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
for (n = 0; n < 8; n++)
{
outbuf[n + pos] = array_out[n];
}
if (array_out[8] != 0x55)
{
return -20;
}
return 0;
}
private int NT_SetCal_2(byte[] indata, byte IsHi, string Path, short pos)
{
int n;
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 9;
array_in[2] = IsHi;
for (n = 0; n < 8; n++)
{
array_in[3 + n] = indata[n + pos];
}
if (!SetFeature(hUsbDevice, array_in, 11))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 2))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0)
{
return -82;
}
return 0;
}
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;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = GetIDVersion(ref Version, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int GetID(ref int ID_1, ref int ID_2, string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_GetID(ref ID_1, ref ID_2, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int sRead(ref int in_data, string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = ReadDword(ref in_data, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int sWrite(int out_data, string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = WriteDword(out_data, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int YWriteEx(byte[] indata, int address, int nlen, string HKey, string LKey, string Path)
{
int ret = 0;
IntPtr hsignal;
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);
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
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)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YWriteEx(indata, address, nlen, HKey, LKey, Path);
}
}
if (leave - trashLen * n > 0)
{
ret = Y_Write(indata, address + n * trashLen, leave - n * trashLen, password, Path, trashLen * n);
if (ret != 0)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YWriteEx(indata, address, nlen, HKey, LKey, Path);
}
}
}
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)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YWriteEx(indata, address, nlen, HKey, LKey, Path);
}
}
if (nlen - trashLen * n > 0)
{
ret = Y_Write(indata, address + n * trashLen, nlen - n * trashLen, password, Path,
leave + trashLen * n);
if (ret != 0)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YWriteEx(indata, address, nlen, HKey, LKey, Path);
}
}
}
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int YReadEx(byte[] OutData, short address, short nlen, string HKey, string LKey, string Path)
{
int ret = 0;
IntPtr hsignal;
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);
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
for (n = 0; n < nlen / trashLen; n++)
{
ret = Y_Read(OutData, address + n * trashLen, trashLen, password, Path, n * trashLen);
if (ret != 0)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YReadEx(OutData, address, nlen, HKey, LKey, Path);
}
}
if (nlen - trashLen * n > 0)
{
ret = Y_Read(OutData, address + n * trashLen, nlen - trashLen * n, password, Path, trashLen * n);
if (ret != 0)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YReadEx(OutData, address, nlen, HKey, LKey, Path);
}
}
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int FindPort_2(int start, int in_data, int verf_data, ref string OutPath)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_FindPort_2(start, in_data, verf_data, ref OutPath);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int FindPort(int start, ref string OutPath)
{
Stopwatch stopwatch = Stopwatch.StartNew();
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_FindPort(start, ref OutPath);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
Debug.WriteLine(stopwatch.ElapsedMilliseconds);
return ret;
}
public int sWrite_2(int out_data, string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = WriteDword_2(out_data, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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 YRead(ref byte indata, int address, string HKey, string LKey, string Path)
{
int ret;
IntPtr hsignal;
byte[] ary1 = new byte[8];
if ((address > 495) || (address < 0)) return -81;
myconvert(HKey, LKey, ary1);
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = sub_YRead(ref indata, address, ary1, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
private int sub_YRead(ref byte OutData, int address, byte[] password, string Path)
{
int n;
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
byte opcode;
if ((address > 495) || (address < 0)) return -81;
opcode = 128;
if (address > 255)
{
opcode = 160;
address = address - 256;
}
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 16;
array_in[2] = opcode;
array_in[3] = (byte) address;
array_in[4] = (byte) address;
for (n = 0; n < 8; n++)
{
array_in[5 + n] = password[n];
}
if (!SetFeature(hUsbDevice, array_in, 13))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 2))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 83)
{
return -83;
}
OutData = array_out[1];
return 0;
}
public int YWrite(byte indata, int address, string HKey, string LKey, string Path)
{
int ret;
IntPtr hsignal;
byte[] ary1 = new byte[8];
if ((address > 495) || (address < 0)) return -81;
myconvert(HKey, LKey, ary1);
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = sub_YWrite(indata, address, ary1, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
private int sub_YWrite(byte indata, int address, byte[] password, string Path)
{
int n;
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
byte opcode;
if ((address > 511) || (address < 0)) return -81;
opcode = 64;
if (address > 255)
{
opcode = 96;
address = address - 256;
}
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 17;
array_in[2] = opcode;
array_in[3] = (byte) address;
array_in[4] = indata;
for (n = 0; n < 8; n++)
{
array_in[5 + n] = password[n];
}
if (!SetFeature(hUsbDevice, array_in, 13))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 2))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
if (array_out[1] != 1)
{
return -82;
}
return 0;
}
public int SetReadPassword(string W_HKey, string W_LKey, string new_HKey, string new_LKey, string Path)
{
int ret;
IntPtr hsignal;
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 = 496;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = Y_Write(ary2, address, 8, ary1, Path, 0);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int SetWritePassword(string W_HKey, string W_LKey, string new_HKey, string new_LKey, string Path)
{
int ret;
IntPtr hsignal;
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 = 504;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = Y_Write(ary2, address, 8, ary1, Path, 0);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int YWriteString(string InString, int address, string HKey, string LKey, string Path)
{
int ret = 0;
byte[] ary1 = new byte[8];
IntPtr hsignal;
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);
outlen = lstrlenA(InString); //注意，这里不写入结束字符串，与原来的兼容，也可以写入结束字符串，与原来的不兼容，写入长度会增加1
b = new byte[outlen];
CopyStringToByte(b, InString, outlen);
total_len = address + outlen;
if (total_len > MAX_LEN) return -47;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
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)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YWrite_new((InString), address, HKey, LKey, Path);
}
}
if (leave - trashLen * n > 0)
{
ret = Y_Write(b, address + n * trashLen, leave - n * trashLen, ary1, Path, trashLen * n);
if (ret != 0)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YWrite_new((InString), address, HKey, LKey, Path);
}
}
}
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)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
}
}
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int YReadString(ref string OutString, int address, int nlen, string HKey, string LKey, string Path)
{
int ret = 0;
byte[] ary1 = new byte[8];
IntPtr hsignal;
int n, trashLen = 0;
int total_len;
byte[] outb;
StringBuilder temp_OutString;
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;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
for (n = 0; n < (nlen / trashLen); n++)
{
ret = Y_Read(outb, address + n * trashLen, trashLen, ary1, Path, n * trashLen);
if (ret != 0)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YRead_new(ref OutString, address, nlen, HKey, LKey, Path);
}
}
if (nlen - trashLen * n > 0)
{
ret = Y_Read(outb, address + n * trashLen, nlen - trashLen * n, ary1, Path, trashLen * n);
if (ret != 0)
{
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return sub_YRead_new(ref OutString, address, nlen, HKey, LKey, Path);
}
}
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
temp_OutString = new StringBuilder("", nlen);
//初始化数据为0，注意，这步一定是需要的
for (n = 0; n < nlen; n++)
{
temp_OutString.Append(0);
}
CopyByteToString(temp_OutString, outb, nlen);
OutString = temp_OutString.ToString();
return ret;
}
public int SetCal_2(string Key, string Path)
{
int ret;
IntPtr hsignal;
byte[] KeyBuf = new byte[16];
byte[] inb = new byte[8];
HexStringToByteArray(Key, ref KeyBuf);
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_SetCal_2(KeyBuf, 0, Path, 8);
if (ret != 0) goto error1;
ret = NT_SetCal_2(KeyBuf, 1, Path, 0);
error1:
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int Cal(byte[] InBuf, byte[] outbuf, string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_Cal(InBuf, outbuf, Path, 0);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int EncString(string InString, ref string OutString, string Path)
{
IntPtr hsignal;
byte[] b;
byte[] outb;
int n;
int nlen, temp_len;
int ret = 0;
nlen = lstrlenA(InString) + 1;
temp_len = nlen;
if (nlen < 8)
{
nlen = 8;
}
b = new byte[nlen];
outb = new byte[nlen];
CopyStringToByte(b, InString, temp_len);
b.CopyTo(outb, 0);
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
for (n = 0; n <= (nlen - 8); n = n + 8)
{
ret = NT_Cal(b, outb, Path, n);
if (ret != 0) break;
}
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = WriteDword(in_data, Path);
if (ret != 0) goto error1;
ret = ReadDword(ref out_data, Path);
error1:
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int sWrite_2Ex(int in_data, ref int out_data, string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = WriteDword_2(in_data, Path);
if (ret != 0) goto error1;
ret = ReadDword(ref out_data, Path);
error1:
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int ReSet(string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_ReSet(Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
private int NT_ReSet(string Path)
{
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 32;
if (!SetFeature(hUsbDevice, array_in, 2))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 2))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0)
{
return -82;
}
return 0;
}
public int SetCal_New(string Key, string Path)
{
int ret;
IntPtr hsignal;
byte[] KeyBuf = new byte[16];
byte[] inb = new byte[8];
HexStringToByteArray(Key, ref KeyBuf);
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_SetCal_New(KeyBuf, 0, Path, 8);
if (ret != 0) goto error1;
ret = NT_SetCal_New(KeyBuf, 1, Path, 0);
error1:
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int Cal_New(byte[] InBuf, byte[] outbuf, string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_Cal_New(InBuf, outbuf, Path, 0);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int EncString_New(string InString, ref string OutString, string Path)
{
IntPtr hsignal;
byte[] b;
byte[] outb;
int n;
int nlen, temp_len;
int ret = 0;
nlen = lstrlenA(InString) + 1;
temp_len = nlen;
if (nlen < 8)
{
nlen = 8;
}
b = new byte[nlen];
outb = new byte[nlen];
CopyStringToByte(b, InString, temp_len);
b.CopyTo(outb, 0);
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
for (n = 0; n <= (nlen - 8); n = n + 8)
{
ret = NT_Cal_New(b, outb, Path, n);
if (ret != 0) break;
}
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = F_GetVersionEx(ref Version, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
private int NT_Cal_New(byte[] InBuf, byte[] outbuf, string Path, int pos)
{
int n;
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 12;
for (n = 2; n <= 9; n++)
{
array_in[n] = InBuf[n - 2 + pos];
}
if (!SetFeature(hUsbDevice, array_in, 9))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 9))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
for (n = 0; n < 8; n++)
{
outbuf[n + pos] = array_out[n];
}
if (array_out[8] != 0x55)
{
return -20;
}
return 0;
}
private int NT_SetCal_New(byte[] indata, byte IsHi, string Path, short pos)
{
int n;
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 13;
array_in[2] = IsHi;
for (n = 0; n < 8; n++)
{
array_in[3 + n] = indata[n + pos];
}
if (!SetFeature(hUsbDevice, array_in, 11))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 2))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0)
{
return -82;
}
return 0;
}
private int F_GetVersionEx(ref short Version, string Path)
{
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 5;
if (!SetFeature(hUsbDevice, array_in, 1))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 1))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
Version = array_out[0];
return 0;
}
int sub_YRead_new(ref string OutString, int Address, int nlen, string HKey, string LKey, string Path)
{
int n, ret = 0;
byte[] outb;
StringBuilder temp_OutString;
outb = new byte[nlen];
for (n = 0; n < nlen; n++)
{
ret = YRead(ref outb[n], Address + n, HKey, LKey, Path);
if (ret != 0) return ret;
}
temp_OutString = new StringBuilder("", nlen);
//初始化数据为0，注意，这步一定是需要的
for (n = 0; n < nlen; n++)
{
temp_OutString.Append(0);
}
CopyByteToString(temp_OutString, outb, nlen);
OutString = temp_OutString.ToString();
return ret;
}
int sub_YWrite_new(string InString, int Address, string HKey, string LKey, string Path)
{
int n, ret = 0;
byte[] b;
int outlen = lstrlenA(InString); //注意，这里不写入结束字符串，与原来的兼容，也可以写入结束字符串，与原来的不兼容，写入长度会增加1
b = new byte[outlen];
CopyStringToByte(b, InString, outlen);
for (n = 0; n < outlen; n++)
{
ret = YWrite(b[n], Address + n, HKey, LKey, Path);
if (ret != 0) return ret;
}
return ret;
}
int sub_YReadEx(byte[] OutData, int Address, int nlen, string HKey, string LKey, string Path)
{
int n, ret = 0;
for (n = 0; n < nlen; n++)
{
ret = YRead(ref OutData[n], Address + n, HKey, LKey, Path);
if (ret != 0) return ret;
}
return ret;
}
int sub_YWriteEx(byte[] indata, int Address, int len, string HKey, string LKey, string Path)
{
int n, ret = 0;
for (n = 0; n < len; n++)
{
ret = YWrite(indata[n], Address + n, HKey, LKey, Path);
if (ret != 0) return ret;
}
return ret;
}
public int SetHidOnly(bool IsHidOnly, string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_SetHidOnly(IsHidOnly, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
private int NT_SetHidOnly(bool IsHidOnly, string Path)
{
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 0x55;
if (IsHidOnly) array_in[2] = 0;
else array_in[2] = 0xff;
if (!SetFeature(hUsbDevice, array_in, 3))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 1))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0)
{
return -82;
}
return 0;
}
public int SetUReadOnly(string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_SetUReadOnly(Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
private int NT_SetUReadOnly(string Path)
{
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 0x56;
if (!SetFeature(hUsbDevice, array_in, 3))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 1))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0)
{
return -82;
}
return 0;
}
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)
{
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
int ret = sub_GetTrashBufLen(hUsbDevice, ref out_len);
CloseHandle(hUsbDevice);
return ret;
}
private int NT_Set_SM2_KeyPair(byte[] PriKey, byte[] PubKeyX, byte[] PubKeyY, byte[] sm2_UerName, string Path)
{
byte[] array_in = new byte[256];
byte[] array_out = new byte[25];
int n = 0;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
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];
}
if (!SetFeature(hUsbDevice, array_in, ECC_MAXLEN * 3 + SM2_USENAME_LEN + 2))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 2))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0x20) return USBStatusFail;
return 0;
}
private int NT_GenKeyPair(byte[] PriKey, byte[] PubKey, string Path)
{
byte[] array_in = new byte[256];
byte[] array_out = new byte[256];
int n = 0;
IntPtr hUsbDevice = IntPtr.Zero;
array_out[0] = 0xfb;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = GEN_KEYPAIR;
if (!SetFeature(hUsbDevice, array_in, 2))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, ECC_MAXLEN * 3 + 2))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
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 0;
}
private int NT_GetChipID(byte[] OutChipID, string Path)
{
int[] t = new int[8];
int n;
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = GET_CHIPID;
if (!SetFeature(hUsbDevice, array_in, 1))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 17))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0x20) return USBStatusFail;
for (n = 0; n < 16; n++)
{
OutChipID[n] = array_out[1 + n];
}
return 0;
}
private int NT_Get_SM2_PubKey(byte[] KGx, byte[] KGy, byte[] sm2_UerName, string Path)
{
byte[] array_in = new byte[256];
byte[] array_out = new byte[256];
int n = 0;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 0x33;
if (!SetFeature(hUsbDevice, array_in, 2))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, ECC_MAXLEN * 2 + SM2_USENAME_LEN + 2))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
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 0;
}
private int NT_Set_Pin(string old_pin, string new_pin, string Path)
{
byte[] array_in = new byte[256];
byte[] array_out = new byte[256];
int n = 0;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = SET_PIN;
byte[] b_oldpin = new byte[PIN_LEN];
CopyStringToByte(b_oldpin, old_pin, PIN_LEN);
byte[] b_newpin = new byte[PIN_LEN];
CopyStringToByte(b_newpin, new_pin, PIN_LEN);
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];
}
if (!SetFeature(hUsbDevice, array_in, PIN_LEN * 2 + 2))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 2))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0x20) return USBStatusFail;
if (array_out[1] != 0x20) return FAILPINPWD;
return 0;
}
private int NT_SM2_Enc(byte[] inbuf, byte[] outbuf, byte inlen, string Path)
{
byte[] array_in = new byte[256];
byte[] array_out = new byte[256];
int n = 0;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = MYENC;
array_in[2] = inlen;
for (n = 0; n < inlen; n++)
{
array_in[3 + n] = inbuf[n];
}
if (!SetFeature(hUsbDevice, array_in, inlen + 1 + 2))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, inlen + SM2_ADDBYTE + 3))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
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 0;
}
private int NT_SM2_Dec(byte[] inbuf, byte[] outbuf, byte inlen, string pin, string Path)
{
byte[] array_in = new byte[256];
byte[] array_out = new byte[256];
int n = 0;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = MYDEC;
byte[] b_pin = new byte[PIN_LEN];
CopyStringToByte(b_pin, pin, PIN_LEN);
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];
}
if (!SetFeature(hUsbDevice, array_in, inlen + 1 + 2 + PIN_LEN))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, inlen - SM2_ADDBYTE + 4))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
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 0;
}
private int NT_Sign(byte[] inbuf, byte[] outbuf, string pin, string Path)
{
byte[] array_in = new byte[256];
byte[] array_out = new byte[256];
int n = 0;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = YTSIGN;
byte[] b_pin = new byte[PIN_LEN];
CopyStringToByte(b_pin, pin, PIN_LEN);
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];
}
if (!SetFeature(hUsbDevice, array_in, 32 + 2 + PIN_LEN))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 64 + 3))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
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 0;
}
private int NT_Sign_2(byte[] inbuf, byte[] outbuf, string pin, string Path)
{
byte[] array_in = new byte[256];
byte[] array_out = new byte[256];
int n = 0;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = YTSIGN_2;
byte[] b_pin = new byte[PIN_LEN];
CopyStringToByte(b_pin, pin, PIN_LEN);
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];
}
if (!SetFeature(hUsbDevice, array_in, 32 + 2 + PIN_LEN))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 64 + 3))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
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 0;
}
private int NT_Verfiy(byte[] inbuf, byte[] InSignBuf, ref bool outbiao, string Path)
{
byte[] array_in = new byte[256];
byte[] array_out = new byte[256];
int n = 0;
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
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];
}
if (!SetFeature(hUsbDevice, array_in, 32 + 2 + 64))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 3))
{
CloseHandle(hUsbDevice);
return -94;
}
CloseHandle(hUsbDevice);
outbiao = (array_out[1] != 0);
if (array_out[0] != 0x20) return USBStatusFail;
return 0;
}
private string ByteArrayToHexString(byte[] in_data, int nlen)
{
string OutString = "";
int n;
for (n = 0; n < nlen; n++)
{
OutString = OutString + in_data[n].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]; //其中第一个字节是标志位，忽略
IntPtr hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_GenKeyPair(b_PriKey, b_PubKey, InPath);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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],
b_SM2UserName = new byte[SM2_USENAME_LEN];
HexStringToByteArray(PriKey, ref b_PriKey);
HexStringToByteArray(PubKeyX, ref b_PubKeyX);
HexStringToByteArray(PubKeyY, ref b_PubKeyY);
CopyStringToByte(b_SM2UserName, SM2_UserName, SM2_USENAME_LEN);
IntPtr hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_Set_SM2_KeyPair(b_PriKey, b_PubKeyX, b_PubKeyY, b_SM2UserName, InPath);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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];
IntPtr hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_Get_SM2_PubKey(b_PubKeyX, b_PubKeyY, b_sm2UserName, InPath);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
PubKeyX = ByteArrayToHexString(b_PubKeyX, ECC_MAXLEN);
PubKeyY = ByteArrayToHexString(b_PubKeyY, ECC_MAXLEN);
StringBuilder c_str = new StringBuilder("", SM2_USENAME_LEN);
CopyByteToString(c_str, b_sm2UserName, SM2_USENAME_LEN);
sm2UserName = c_str.ToString();
return ret;
}
public int GetChipID(ref string OutChipID, string InPath)
{
int ret;
byte[] b_OutChipID = new byte[16];
IntPtr hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_GetChipID(b_OutChipID, InPath);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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];
IntPtr hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
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:
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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];
IntPtr hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
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, 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:
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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];
int inlen = lstrlenA(InString) + 1;
int outlen = (inlen / (MAX_ENCLEN) + 1) * SM2_ADDBYTE + inlen;
byte[] OutBuf = new byte[outlen];
byte[] InBuf = new byte[inlen];
CopyStringToByte(InBuf, InString, inlen);
int ret = 0, temp_inlen;
IntPtr hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
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);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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];
int inlen = lstrlenA(InString) / 2;
int outlen = inlen - (inlen / (MAX_DECLEN) + 1) * SM2_ADDBYTE;
byte[] InBuf = new byte[inlen];
byte[] OutBuf = new byte[outlen];
int ret = 0, temp_inlen;
HexStringToByteArray(InString, ref InBuf);
IntPtr hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
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:
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
StringBuilder c_str = new StringBuilder("", outlen);
CopyByteToString(c_str, OutBuf, outlen);
OutString = c_str.ToString();
return ret;
}
public int YtSetPin(string old_pin, string new_pin, string InPath)
{
int ret;
IntPtr hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_Set_Pin(old_pin, new_pin, InPath);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
private int NT_SetID(byte[] InBuf, string Path)
{
int n;
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 7;
for (n = 2; n <= 9; n++)
{
array_in[n] = InBuf[n - 2];
}
if (!SetFeature(hUsbDevice, array_in, 9))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 9))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0x0)
{
return -82;
}
return 0;
}
public int SetID(string Seed, string Path)
{
int ret;
IntPtr hsignal;
int n;
byte[] KeyBuf = new byte[8];
for (n = 0; n < 8; n++)
{
KeyBuf[n] = 0;
}
HexStringToByteArray(Seed, ref KeyBuf);
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_SetID(KeyBuf, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
private int NT_GetProduceDate(ref string OutDate, string Path)
{
int n;
byte[] array_in = new byte[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
array_in[1] = 15;
if (!SetFeature(hUsbDevice, array_in, 1))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 8))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
OutDate = "";
for (n = 0; n < 8; n++)
{
OutDate = OutDate + array_out[n].ToString("X2");
}
return 0;
}
//返回锁的出厂编码
public int GetProduceDate(ref string PDate, string Path)
{
int ret;
IntPtr hsignal;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = NT_GetProduceDate(ref PDate, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
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[25];
byte[] array_out = new byte[25];
IntPtr hUsbDevice = IntPtr.Zero;
if (nlen > 8) return -87;
if (OpenMydivece(ref hUsbDevice, Path) != 0) return -92;
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];
}
if (!SetFeature(hUsbDevice, array_in, 13 + nlen))
{
CloseHandle(hUsbDevice);
return -93;
}
if (!GetFeature(hUsbDevice, array_out, 2))
{
CloseHandle(hUsbDevice);
return -93;
}
CloseHandle(hUsbDevice);
if (array_out[0] != 0)
{
return -82;
}
return 0;
}
public int SetCal(string W_HKey, string W_LKey, string new_HKey, string new_LKey, string Path)
{
int ret;
IntPtr hsignal;
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;
hsignal = CreateSemaphore(0, 1, 1, "ex_sim");
WaitForSingleObject(hsignal, INFINITE);
ret = y_setcal(ary2, address, 8, ary1, Path);
ReleaseSemaphore(hsignal, 1, 0);
CloseHandle(hsignal);
return ret;
}
public int CheckKeyByFindort_2()
{
//使用普通算法一查找指定的加密锁
string DevicePath = ""; //用于储存加密锁所在的路径
return FindPort_2(0, 1, -517431188, ref DevicePath);
}
//使用带长度的方法从指定的地址读取字符串
private int ReadStringEx(int addr, ref string outstring, string DevicePath)
{
int nlen, ret;
byte[] buf = new byte[1];
//先从地址0读到以前写入的字符串的长度
ret = YReadEx(buf, (short) addr, (short) 1, "54618348", "4776A17F", DevicePath);
if (ret != 0) return ret;
nlen = buf[0];
//再读取相应长度的字符串
return YReadString(ref outstring, addr + 1, nlen, "54618348", "4776A17F", DevicePath);
}
//使用从储存器读取相应数据的方式检查是否存在指定的加密锁
public int CheckKeyByReadEprom()
{
int n, ret;
string DevicePath = ""; //用于储存加密锁所在的路径
string outstring = "";
//@NoUseCode_data 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 && (string.Compare(outstring, "TEAM123", StringComparison.Ordinal) == 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, "21B6D3E062EB66C48B800EEB08D0F37F");
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 =
{
"14325", "15004", "22868", "16672", "5595", "27472", "2047", "4810", "10216", "16402", "2305", "12781",
"1029", "7972", "12691", "1758", "14651", "872", "6417", "13196", "10678", "28254", "17139", "5516",
"1216", "31275", "26837", "26638", "24768", "2960",
"25712", "1510", "30019", "9198", "14750", "19331", "29939", "21319", "16474", "6393", "1945", "19006",
"28348", "29689", "25630", "3094", "17151", "18903", "2703", "16558", "19838", "20867", "7699", "9866",
"23218", "3472", "24308", "9420", "15669", "28206",
"17567", "32052", "14273", "4915", "14235", "7720", "1840", "11789", "27539", "5287", "3197", "977",
"22866", "7763", "5824", "3887", "22721", "23406", "19764", "17016", "23274", "8412", "14644", "27041",
"17399", "27165", "28728", "11323", "25906", "27475",
"24028", "12152", "5893", "17218", "11738", "22568", "29434", "19786", "22026", "11456", "11708",
"4974", "16487", "22352", "4372", "24654", "5388", "18315", "5612", "28975", "9265", "29890", "7757",
"18418", "28721", "16360", "20323", "7448", "22407", "30094",
"2936", "29123", "24268", "28648", "3060", "16823", "6843", "22726", "7010", "21844", "14892", "2971",
"28524", "13213", "12314", "6008", "8925", "13363", "32159", "24847", "20382", "12633", "7158", "25779",
"18616", "23024", "1656", "6231", "29783", "9083",
"25758", "28042", "17861", "23579", "21508", "29568", "22378", "23700", "21091", "6412", "9425",
"23110", "18325", "3741", "25764", "22835", "12181", "18503", "687", "15871", "25723", "8124", "14808",
"32745", "2179", "5710", "20012", "31446", "4102", "14061",
"26323", "24902", "27517", "6190", "2074", "20060", "20868", "32321", "11624", "30681", "10452", "7417",
"841", "33", "4680", "31175", "16741", "26674", "4824", "28094", "9352", "8627", "23967", "18320",
"2203", "16611", "15832", "3471", "8871", "20132",
"8411", "24492", "23256", "14969", "16420", "31097", "18039", "27779", "27468", "21545", "16878",
"30598", "29197", "26766", "10952", "27362", "11841", "4378", "14765", "17562", "11747", "3039",
"31848", "847", "32010", "7309", "28644", "22595", "4085", "20088",
"14890", "31066", "19705", "22162", "1125", "4885", "13971", "5485", "29916", "23188", "13660", "14650",
"18685", "16283", "526", "32716", "3919", "16012", "12163", "6293", "382", "21097", "21685", "9894",
"32338", "1747", "22206", "25265", "9143", "10765",
"21209", "23818", "2230", "7928", "10335", "24481", "6009", "20247", "8906", "28680", "1866", "15500",
"17332", "29042", "30355", "13336", "11479", "26289", "9439", "7966", "10765", "21559", "19670",
"30111", "23376", "16917", "7748", "20543", "32442", "24062",
"22545", "6718", "23174", "15683", "586", "25470", "18189", "16087", "18453", "21122", "22728", "3404",
"29119", "13932", "10836", "16595", "32433", "14589", "18023", "8511", "24437", "12440", "12767",
"2050", "20406", "4671", "5555", "25133", "20541", "916",
"2303", "21106", "16627", "3287", "31482", "29477", "6885", "27372", "15618", "14390", "19001", "342",
"11407", "28983", "10301", "27700", "32059", "27484", "5464", "12875", "8896", "13173", "13077", "5883",
"23288", "30708", "15903", "3142", "22493", "2797",
"2111", "17615", "2442", "1040", "4702", "26072", "2104", "687", "18056", "22850", "7745", "4029",
"20966", "16272", "29214", "8139", "7874", "485", "20587", "13581", "28294", "1024", "5601", "8531",
"5053", "30276", "14682", "26639", "19471", "18357",
"30160", "16468", "14919", "14323", "5214", "14036", "81", "2369", "22076", "28640", "31027", "21120",
"32454", "2412", "4890", "28979", "32116", "7431", "18767", "7036", "14307", "25061", "15932", "4637",
"29641", "28376", "30059", "29302", "24836", "7250",
"11655", "10380", "17291", "1636", "23129", "256", "15738", "11968", "16074", "23314", "14601", "16058",
"9958", "31398", "29331", "26945", "16854", "31294", "8852", "27882", "7141", "23804", "18339", "13798",
"14459", "16546", "4219", "8198", "19491", "12177",
"26102", "22716", "5768", "4811", "5390", "24859", "23666", "17395", "6366", "12245", "461", "16203",
"1183", "29499", "17314", "30132", "3498", "29504", "4635", "16050", "13691", "4982", "2690", "27236",
"5035", "29966", "4417", "29582", "16371", "14555",
"3043", "20882", "23599", "24910", "15120", "27250", "15961", "21627", "13459", "9424", "14985",
"32273", "32087", "6636", "3323", "4453", "17253", "26538", "25607", "27494"
};
string[] EncOutString =
{
"81523BE49203CDDC", "3CB641EA3FF0577E", "2CEBDEA42762FBE1", "F22C6159C1723636", "B8CB9B743D317040",
"91EBB14366AE02AD", "D34478DF40793EDE", "B57EF295ABB39189", "4D46D7F69BA5D960", "082C74E4F107AF87",
"DADCF2B97B7AAF25", "7EC98C12C6C24046", "0B7B0A7DF447C3F5", "B3ED50FFA07C6B2E", "0A1CC2400645CA94",
"A5DC58E618279445", "034C114F0BBC6F78", "D144F87C87FB3FBB", "28E51DFB73C1AA20", "85DA1BD923805040",
"54F6E08B4B4F20B9", "4071869F278BDA07", "42978249F571F331", "A4B8CFBE3ED86BE3", "F55B0E35451A518D",
"669A63A14F49C085", "576D002A50BAE78E", "C73406AD9A409E74", "EF1A53B0B23B335A", "34954C54FCB0D03E",
"85CB7C78CE31F385", "1AD2298DF6C7E67E", "A0A1A5AC679806F8", "9FBF059AA66C2AD7", "E2B6AE62C8C97C56",
"C260427BC8B642FF", "B34AA659B16287BF", "32F2B71F11C0FEEE", "2227D78F36634562", "172FB9000B2EF10C",
"5EB0A7ED6BB29432", "6848371CF208EAEE", "4A6FAF220A7A410A", "7C16575BDC3EC20B", "D2946E1D06E2805B",
"FEE8F83A157AC090", "A3D9C078725181E1", "35C59D4BB42B0532", "D721FC412ED8E16A", "3A959C6CB8C1066A",
"ECBD5AD3AA734B45", "C343663C4DE1DFE6", "14605989AEAD3C71", "02F1A14972276BA4", "EE8A4F6457399922",
"408E2646AFBC49F4", "AEC653D3A83D4E82", "575AA99EE0F2CB0B", "C76AB4442781647F", "8FC7D9CE1781EF9D",
"8FA389063F09452D", "8E8E3B22A4B90D2D", "88061AC1565B782F", "11BF8F9CB819C846", "FD9DE94A18FCD675",
"876F2E426A0A7342", "D412E08087726A88", "4513F1ACCC5F9705", "AF6C239605E452B5", "41A0B58F92B5E3DB",
"CFA153542F50C1ED", "8D8E9427FED908FA", "383C8D0CCA05B4A6", "9B71186709B3D6ED", "8B1A2F96D73510CB",
"F43F462EE7A6A9FF", "9A8A1FB491FD78EE", "CA299EF4FEC8D485", "71943747049CF25E", "505BBB4940D7CB58",
"63A1BCF252674C4E", "C7511DAFD982D451", "0E49A5117C26070D", "A3E21D54AC60F232", "62449CDB9E65643B",
"40CB7C0445C1ED09", "36C7CF3615BC5512", "194616AEBECFCDB7", "E6B13C9B2B439CFE", "D75B396ABB65FD32",
"AFA77639C986097D", "2D1A0DBBDBF7BC5B", "91BBFA9FFC0100FA", "9E80B94D7C9487BD", "E2078F27CC5457D2",
"1C5321A0920C6D30", "C9136A83E0701149", "7908C991EB75B308", "3B7445996DA2BA56", "933DCDB471DFDFC0",
"EFC9DE4CC1EDA2AA", "FBB24DD1D5529290", "DA14A0E9F12F1A59", "5DD9F7E3F5E55F72", "D8486DEBBE7EF308",
"CF604E95E7CFF6AB", "56461C4E59EF83AE", "B8A10DCF7AFA759C", "0798FA796380EF5B", "548A51A1345BB41E",
"AA54664216843AED", "9D4EE9D0B73F7D41", "ADA379FDC851756D", "7093D58C7A7A16BD", "A22083C0A08AFAA6",
"F42299BE9E745D80", "36AB3963476B70AA", "C58141E6B5E21CF2", "5C21B78B23377A52", "36BCB65B7DBE1EB0",
"C463F294CBFD68E7", "651E29F879CAB5A9", "AA8E5E88340BBDE5", "759CE8DF881B903A", "E2300C547456BB19",
"9C5E13634DE58147", "A105D097C4BEC526", "549D1CC247C82DDB", "1B3E95E395213AEB", "A70AEBFD30CA3202",
"E6077D73F94670E0", "BBE048ED46B67C5C", "35E8BFD51078B385", "03502D98908C8CEE", "8949A102527CCD28",
"6042D0DEC2E4EB82", "6CC7980794D5ECA7", "95F5F421F6B1868E", "6F19E9DF75509BA8", "D398EF72E4001004",
"9421E892DCD4DC36", "763967F59F7EB711", "3483F5EB4B0714D4", "81B85F5573585C35", "B3E42D14238DBC12",
"AC7343EBEB4716AB", "D66C4A925870193B", "81370808197FAF85", "6C401DFF90A1E174", "947FE8F9B9D0FBD4",
"0B7FB3385FE6238C", "04C393E30AED5793", "FC84FB08E54335C8", "75A59C5800BF2F66", "378451E5E7FE1EFB",
"08CF1ECE5B1D2988", "7E81F790FB62116B", "E5A5E6CEC239E2B0", "6F72AC38B48E9BE5", "B265D058D6B5B192",
"537C2C4693979235", "BAA8A19281814678", "653C94B5847DEDFF", "E931A2ABF3D5FF7C", "5A9BADA9AE3D9F98",
"22D2B5B23519D581", "777EC40EBC7BFF56", "E8745945283C71E0", "1EEDE0D74FAB92A8", "D4A79CF838427DF9",
"556433D0F69AAD55", "FBE7E0FE026A1D15", "855F8000CDADF904", "36EE8EE935FAAAC1", "17DFAAA3B6560020",
"1503DE845ABFECF9", "BB7EE225E1827FEE", "993CD4DBCED9BB0C", "0DAA74F5F5E6C53F", "B6743DA1C6278772",
"75FB8979B98C0B65", "E3C3CC647E52EF2C", "3DABD4FDC8DB5CA1", "199A8F46DA4CF7E0", "04B18765000678B2",
"11BF5E172D66F748", "C0F2D99C7B5F8A9E", "C2482B0B9D275F84", "E934FFB6AC45C2A7", "DAAE613BEF6EC022",
"C19B9C388DA7878C", "ECAD65BF3D59C1DF", "93BF7A19CF2B4EFA", "42A900C673406E6F", "3750D3666BD81174",
"E5180B2F3B2D0C9B", "F7D83B2CAB92E8FD", "CF16927992131D05", "120DD671A29F5F1D", "FD5A8F3306AA10C5",
"62D2EA4FF45C15E3", "1ADA3FB680DA495C", "CE7BD6090CB3DE75", "F724AC0F0BD0BCFD", "C2F1449556DDDB12",
"43C3B7E17AE6B311", "5F6576733B5B5F3D", "1DF28CAE0D1BEEDD", "C5C55009F3E1E55F", "93F1CA6296C33DE1",
"91D6B5F1BE8EC5FC", "B5C6DFBD98C0158A", "B5584604C2C97223", "12B20C5CF67EE003", "0E01D8E4884EAC03",
"624D1016458E7228", "24D4813DFE12629A", "4546A408D8C22951", "80A9339C195561CB", "AD364AE98F16D8B3",
"3BE9F7F954FA729A", "3328C6A173277E21", "AAC8663BD47EDCA3", "A5EA76DCEF97423B", "EF11BC18E72809EE",
"6172889BB20C9269", "0DDC9BCDD25D8DF3", "BFE17CC8E9E62DB5", "98D8880316C3ECC6", "F2979DC363CECCC3",
"C9EE9BC534946FB3", "AA3FBD1BC77F7A0F", "5A1C5A3A717208D4", "770E6704C0C53197", "0B0DFBF4516603D2",
"9FC95C6256DB13D9", "58597AEE41BF56AE", "075AFB63468B3CEF", "F16978E8D1F94EA9", "517BCC68365507EF",
"9BAA18EF01322E1E", "84A6A24E82A3D8C8", "30AC991A8CC469EB", "09069EC5BFB12087", "EAC41D54B3D3EC89",
"1890E753A07DF165", "A66E16C21C8274DC", "9D4A3C237EC0B505", "4261F5918251F958", "54AC82F1F1AA475F",
"CD24D3092D4B2C42", "D2AA408273C5ABD3", "EED1A93584899E51", "4D80BBC0F2E882E6", "73E6B8DEEA6ACEBE",
"1FCAA9CFFE27E98C", "0A937994088B09B0", "9A772D4014F90109", "39AC44EB20195032", "AE370A95A4965E16",
"336862ECE271C4A1", "0F93D090DAB342FB", "1D82AD6FF449B0A2", "5CE6CECE7A0416B0", "89879B0BCEF327BB",
"2FE76976889698E3", "75D7389D0C309C41", "DC0336890E1352A7", "F980DE1E3BDB632C", "C3AE6F36629B639F",
"37F10A87CB8605DF", "F66D90B1774A5FAD", "605751521989C0BF", "EDA72FF8C1401994", "0910BF65DD64E2C3",
"41A507FB81165144", "88056785AA082EE3", "3B69AF7076B368FF", "F9DB9773EABCF394", "ABE9143444CFCB4E",
"834A5F8B20E1082F", "B4075A3F9761653F", "89F39A29CC487D45", "66A48EB6D8B43A34", "F7D41E5F276CACB1",
"90028E59071C1674", "B63E2C406E1F72F4", "FB2915F817C94EB3", "D96ED4102BC5254D", "7C744CFB7580B3AA",
"C3AE6F36629B639F", "80BCA18A4442A447", "6680052DEF50B720", "485D7BA34F53FC4D", "2C4AD1D35EE7C4C3",
"8157DC1EDA128271", "0019CC663A28C57C", "20B34A42316BE69C", "6489B2964CD074E8", "03922631C35FDAC0",
"03CCDD2196BFF31C", "F91345DC6D48079C", "6D8D588F1727A04B", "7C4506F74DDD6D5A", "38FBC9A9EDA47752",
"AC5EBEDEA2879D4E", "8F3152319ACD6CFC", "5E07009796B3F1D3", "42E7A16A43454FF2", "A126E29F49BE22FD",
"B3B09EFF420C32C2", "B19464A630414BAE", "E871B1A478009612", "4F74739DDDC5F494", "A81EC3F160B03C67",
"A657F28088CEDE79", "30C925FC13D57EE1", "06B90DC484A6AF3C", "5D876D6E347CA177", "961252177EED989C",
"4944CBD101F680BA", "0B8B8C4FC7E1B149", "71A6308FB43B00BB", "88056E9E5FE61A74", "F6BE5693DBCC69D1",
"FD2B6E9BED16F951", "DAC2EE09D17ECED4", "B6DE3CDFB0137582", "8092CA85C27343BA", "6EBE40C41E517E8F",
"624B66116FBED5FA", "A714D3A76859C779", "BD8B8D82C839FE80", "FF691F3DB8D09887", "F4B0613D0898D12D",
"3AA3C459F35D4CE4", "99B14BB7801F2E58", "43CCD3A5D9FF4A46", "6BCFBE87E050E8B4", "83BF725BD4C3E4D3",
"D421F68FDE727B81", "CF2411BE18C68F82", "AF674A858EC10D8E", "27E7DC60D5D983F2", "5E41B1C9D6ADC64C",
"D90B17A4AFD48E40", "E9F186EAF1F10B0D", "51E6C9C9E3F89561", "E0F8FD6364AFC4ED", "0B38833206E14A64",
"DDB4651CC4CA598C", "74D003DD7CB19B41", "339A157CCB801C1E", "B46ACBA4F76A8DD7", "61B72F57AF0C7911",
"C6B06725F45E304F", "2E091E74B2C6D54E", "C85A98CD6DFC92C3", "0B7470FBCD0B5CA8", "C4465B2500AF3954",
"7380D05E1BBDD294", "B7E16B2B3C09E4A1", "8CABC3DD7FF68F83", "57205F99E167C1DD", "598F245229B51FE7",
"9561FC7ABD756E91", "D772453FFB5E748D", "1EEDE0D74FAB92A8", "07D2C1C1209A7659", "F864DA7FEDFB556C",
"3D3E11E7C560AAEF", "1900C5FC60B5523B", "29CE902C699D49C8", "FDC66F8D24B9E436", "81819D7A5219A808",
"1A8D50273B2B98B7", "10512231DAF9CEC7", "6234B44558537B48", "3B7B815D72989E62", "3FD715B420CC9E76",
"BF6A3AF58D01C71E", "6D8AD54BFC388C1C", "C9D37C9411FD13CE", "39E0BF675E6E4E2C", "212A11B63AA287DA",
"42CF60C613ADB485", "850895D1DAB78C09", "260F10ADEB254F37", "E75DC0ED75D4D898", "C07251AF19B91319",
"B49A484CF5600B18", "116C587B04A07CCA", "0BCA8C36AA105779", "F4245674E7DA95D8", "921EE34B1CD8BF7E",
"C230DEBF480ACB5F", "B3BE00C8224258D4", "D1BBE471ACB13B61", "140C67E566F56F45", "55F187171BE507CC",
"02F06DB5F74F2959", "D3B4CC00BE953C29", "2E8F814967FF0CE9", "762C26FFDAA34B5D", "3502FB15FB52C57B",
"056DAFA5E05DCF5A", "B9737E6124ACCD8D", "9A8501FC3E3E2CF9", "8D9EBF2B1A9BCB84", "D869A9D6914A6B7A",
"7895ED9C52872ED5", "0151A0F1DB298114", "F4E6FD2DE3011785", "6EF9308D4EFCFEE2", "113706A076CBC65F",
"74DBA2899E54CE4B", "0146180294169F47", "8F047C3EAB91AB06", "4207B4C92AF7C0F2", "C1C01D6E2ED962F6",
"4930F7E4788BC118", "C3995549A933D069", "CCA9DD8336D9F871", "F5C0DCF135F329EA", "46A5042266F8B5BB",
"96052C9A937640E6", "44FD8EB770E13A5B", "978277F4FFEC4AFB", "9DC933AFE95710F4", "0B627B13DB8D7D98",
"250346033B4049A4", "128B05472E455458", "40EE138760A9B7E3", "0744D0C7165C8497", "6C13D761ADD9C1DE",
"15522950F078A703", "FF4C6F7D3FC84265", "985F04EE678F2D45", "81F170E31AA377C9", "C916204B0BE099D7",
"8F2FC51B0CAEF611", "2FB07D21C52B1020", "E3E1A2F227CC20DD", "00C5EAFA0305E874", "E61764B98FBACEBB",
"15D4B14CB43F22A2", "D737A3ECA6EAB2C0", "901B6294BF8FF883", "1BFD7C7A5BF6E554", "531FC4360B4F492B",
"A8AC6FF7C7EF5B22", "24E7670F56BF5C99", "8E4E9DF917646EAC", "3246F226416FF1D3", "C92CA77D518DD39C",
"BD5273D303E9B5A9", "A93E963FCC1207C8", "DAEF059AF82D5149", "13C0BD26C4EC09CC", "A18BCC64C189FE49",
"65EC6600B328ABBC", "4A71841B76A4A95B", "DC9532F6D551BA99", "BB2A097FC166A1DC", "BAE03296F65F9471",
"3B61B691FCAEAE9F", "AFF505046E63E6D3", "211D1BAA18BCF7B3", "097DDBE93EA61C17", "05E1176E694DC1C0",
"F6799A243C8EA050", "42D8F4BA026B0344", "1DBC44F85A188E99", "32F671A2E8BABE21", "77C6D82DC131DE35",
"56A6A3C51BC4960A", "5317665483C82CAB", "3923EBEAD41C10B3", "CC69577EB87DCF53", "749DD598BA5B9532",
"A759F194DEBC4814", "82C0982B62D9BCE8", "564993B58B3CF419", "97B6182A0843590D", "F6977B98F0E783CD",
"486E21D382A8806F", "4188A1754C842233", "671013F6E2D489E1", "146B6C03F13E172E", "C3DC60541C9D34F4",
"426026A17087AB51", "848FCEFEC72F2664", "4794CD385896D78D", "0EE5F1AC44874EA3", "2DC3B113C0487E80",
"183F2EE9C4291855", "6F3A7CF759BE98B3", "C7FBDEDCA6B69121", "E3864F275A73BC64", "8873D70CFFCAF40C"
};
//@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;
}
}
}