// 查询本机是否安装加密狗
public bool FindDog(out string msg)
{
msg = string.Empty;
byte[] bytPID = new byte[8];
int count = 0;
bytPID = System.Text.Encoding.ASCII.GetBytes(Properties.Resources.PID_Default);
uint result = ET99_API.et_FindToken(bytPID, out count);
if (result == ET99_API.ET_SUCCESS)
{
msg = "检测到加密狗--新狗";
dogFlag = Dog_Flag.新狗;
DoThreadSafe(() => { toolStripProgressBar1.Maximum = 16; });//新狗分为16个步骤
return(true);
}
else
{
bytPID = System.Text.Encoding.ASCII.GetBytes(Properties.Resources.PID);
result = ET99_API.et_FindToken(bytPID, out count);
if (result == ET99_API.ET_SUCCESS)
{
msg = "检测到加密狗--旧狗";
dogFlag = Dog_Flag.旧狗;
DoThreadSafe(() => { toolStripProgressBar1.Maximum = 14; });//旧狗分为14个步骤
return(true);
}
msg = string.Format("系统未检测到加密狗，请检查！错误：{0}",
ET99_API.ShowResultText(result));
return(false);
}
}
//设置设备参数
public bool SetConfig(out string msg)
{
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
byte bytUserReadOnly = ET99_API.ET_USER_READ_ONLY;//设置为只读模式
byte bytSoPinRetries = byte.Parse(Properties.Resources.SOPIN重试次数);
byte bytUserPinRetries = byte.Parse(Properties.Resources.UserPIN重试次数);
byte bytBack = 0;
uint result = ET99_API.et_SetupToken(ET99_API.dogHandle, bytSoPinRetries, bytUserPinRetries, bytUserReadOnly, bytBack);
if (result == ET99_API.ET_SUCCESS)
{
msg = "设备参数设置成功！";
return(true);
}
else
{
msg = "设备参数设置失败！ 错误：" + ET99_API.ShowResultText(result);
return(false);
}
}
/// <summary>
/// 闪烁LED灯n次
/// </summary>
/// <param name="times">闪烁次数</param>
/// <param name="interval">间隔毫秒数，300貌似不错</param>
public void FlashLED(int times, int interval)
{
int count = 0;
System.Timers.Timer turnOffTimer = new System.Timers.Timer(interval);
turnOffTimer.AutoReset = false;
System.Timers.Timer turnOnTimer = new System.Timers.Timer(interval);
turnOnTimer.AutoReset = false;
turnOffTimer.Elapsed += new System.Timers.ElapsedEventHandler((m, n) =>
{
ET99_API.et_TurnOffLED(ET99_API.dogHandle);
turnOnTimer.Start();
});
turnOnTimer.Elapsed += new System.Timers.ElapsedEventHandler((m, n) =>
{
count++;
ET99_API.et_TurnOnLED(ET99_API.dogHandle);
if (count < times)
{
turnOffTimer.Start();
}
});
turnOffTimer.Start();
}
// 打开加密狗
public bool OpenDog(out string msg)
{
msg = string.Empty;
int index = 1;//默认仅打开第一个加密狗
byte[] bytPID = new byte[8];
if (dogFlag == Dog_Flag.新狗)
{
bytPID = System.Text.Encoding.ASCII.GetBytes(Properties.Resources.PID_Default);
}
else
{
bytPID = System.Text.Encoding.ASCII.GetBytes(Properties.Resources.PID);
}
uint result = ET99_API.et_OpenToken(ref ET99_API.dogHandle, bytPID, index);
if (result == ET99_API.ET_SUCCESS)//打开成功
{
msg = "打开加密狗成功。";
return(true);
}
else
{
msg = string.Format("打开加密狗失败，请检查！错误：{0}",
ET99_API.ShowResultText(result));
return(false);
}
}
//修改普通用户的PIN
public bool ModifyUserPin(out string msg)
{
string strOldUserPin = Properties.Resources.UserPIN_Default;
byte[] bytOldUserPin = new byte[16];
string strNewUserPin = Properties.Resources.UserPIN;
byte[] bytNewUserPin = new byte[16];
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
bytOldUserPin = System.Text.Encoding.ASCII.GetBytes(strOldUserPin);
bytNewUserPin = System.Text.Encoding.ASCII.GetBytes(strNewUserPin);
uint result = ET99_API.et_ChangeUserPIN(ET99_API.dogHandle, bytOldUserPin, bytNewUserPin);
if (result == ET99_API.ET_SUCCESS)
{
msg = "普通用户PIN修改成功！进入普通用户状态。";
return(true);
}
else
{
msg = "普通用户PIN修改失败！ 错误：" + ET99_API.ShowResultText(result);
return(false);
}
}
//产生新的超级用户PIN（针对新狗）
public bool GenSoPin(out string msg)
{
string strSeed = Properties.Resources.SOPIN种子;
byte[] bytSeed;
int iSeedLen = strSeed.Length;
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
StringBuilder strNewPIN = new StringBuilder();
bytSeed = System.Text.Encoding.ASCII.GetBytes(strSeed);
uint result = ET99_API.et_GenSOPIN(ET99_API.dogHandle, iSeedLen, bytSeed, strNewPIN);
if (result == ET99_API.ET_SUCCESS)
{
msg = "成功产生新的超级用户PIN！请牢记 -- " + strNewPIN.ToString().Trim().Substring(0, 16);
return(true);
}
else
{
msg = "产生新的超级用户PIN失败！ 错误：" + ET99_API.ShowResultText(result);
return(false);
}
}
//重置普通用户PIN为 ffffffffffffffff
public bool ResetUserPin(out string msg)
{
string strSoPIN = Properties.Resources.SOPIN;
byte[] bytPIN = new byte[16];
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
bytPIN = System.Text.Encoding.ASCII.GetBytes(strSoPIN);
uint result = ET99_API.et_ResetPIN(ET99_API.dogHandle, bytPIN);
if (result == ET99_API.ET_SUCCESS)
{
msg = "重置普通用户PIN为 FFFFFFFFFFFFFFFF 成功！";
return(true);
}
else
{
msg = "重置普通用户PIN失败！ 错误：" + ET99_API.ShowResultText(result);
return(false);
}
}
//产生新的PID（针对新狗）
public bool GenPID(out string msg)
{
string strSeed = Properties.Resources.PID种子;
byte[] bytSeed;
int iSeedLen = strSeed.Length;
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
StringBuilder strNewPID = new StringBuilder();
bytSeed = System.Text.Encoding.ASCII.GetBytes(strSeed);
uint result = ET99_API.et_GenPID(ET99_API.dogHandle, iSeedLen, bytSeed, strNewPID);
if (result == ET99_API.ET_SUCCESS)
{
msg = "成功写入新的PID到当前设备中！ -- " + strNewPID.ToString().Trim().Substring(0, 8);
return(true);
}
else
{
msg = "写入新的PID到当前设备失败！ 错误：" + ET99_API.ShowResultText(result);
return(false);
}
}
//获取硬件SN
public bool GetSN(out string msg)
{
byte[] bytSN = new byte[8];
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
uint result = ET99_API.et_GetSN(ET99_API.dogHandle, bytSN);
if (result == ET99_API.ET_SUCCESS)
{
string strSN = "";
for (int i = 0; i < 8; ++i)
{
strSN += string.Format("{0:X2}", bytSN[i]);
}
msg = "获取硬件SN成功！-- " + strSN;
dogSN = strSN;
return(true);
}
else
{
msg = "获取硬件SN失败！错误：" + ET99_API.ShowResultText(result);
return(false);
}
}
// 校验加密狗，进入超级用户状态
public bool VerifyDog(out string msg)
{
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
byte[] bytPIN = new byte[16];
if (dogFlag == Dog_Flag.新狗)
{
bytPIN = System.Text.Encoding.ASCII.GetBytes(Properties.Resources.SOPIN_Default);
}
else
{
bytPIN = System.Text.Encoding.ASCII.GetBytes(Properties.Resources.SOPIN);
}
uint result = ET99_API.et_Verify(ET99_API.dogHandle, ET99_API.ET_VERIFY_SOPIN, bytPIN);
if (result == ET99_API.ET_SUCCESS)
{
msg = "加密狗认证成功，进入超级用户状态。";
return(true);
}
else
{
msg = string.Format("加密狗认证失败，请检查！错误：{0}",
ET99_API.ShowResultText(result));
return(false);
}
}
/// <summary>
/// 硬件加密狗计算HMAC_MD5
/// </summary>
/// <param name="MD5KeyIndexInDog">密钥index[范围1~8，对应加密狗中密钥存储范围1~8]</param>
/// <param name="origin">原始字串</param>
/// <returns>加密后字串</returns>
public string HMAC_MD5_dog(int MD5KeyIndexInDog, string origin)
{
byte[] bytRandomCode = new byte[origin.Length]; //第四个参数为随机数
bytRandomCode = System.Text.Encoding.ASCII.GetBytes(origin);
byte[] bytDigest = new byte[16]; //第五个参数为硬件中计算结果
//硬件中计算
//第一个参数为设备的handle句柄
//第二个参数为硬件中密钥索引
//第三个参数为随机数长度
//第四个参数为随机数
//第五个参数为硬件中计算结果
uint result = ET99_API.et_HMAC_MD5(ET99_API.dogHandle, MD5KeyIndexInDog, origin.Length, bytRandomCode, bytDigest);
if (result == ET99_API.ET_SUCCESS)
{
//string strSoftDigest = string.Empty;
//for (int i = 0; i < 16; i++)
// strSoftDigest += string.Format("{0:X2}", bytDigest[i]);
//return strSoftDigest;
return(System.Text.Encoding.Default.GetString(bytDigest));
}
else//失败
{
return("硬件中计算失败");
}
}
//完全清空数据区
public bool ClearData(out string msg)
{
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
//就是将锁内的数据区全部写成0x00
byte[] zerodata = new byte[50]; //1000字节每次写50个字节，循环20次
uint resultmess = 0;
int i = 0;
for (i = 0; i < 50; ++i)
{
zerodata[i] = 0x00;
}
for (i = 0; i < 20; ++i)
{
resultmess = ET99_API.et_Write(ET99_API.dogHandle, (ushort)(i * 50), 50, zerodata);
if (resultmess != ET99_API.ET_SUCCESS)
{
msg = "清空数据区失败！";
return(false);
}
}
msg = "成功清空数据区！";
return(true);
}
/// <summary>
/// 读取指定地址数据区的字符串
/// </summary>
/// <param name="str">指定地址数据区的字符串</param>
/// <param name="offset">偏移地址，范围0~999，字节为单位（整个数据区1000字节，每次读写限制长度60字节）</param>
/// <param name="length">欲读取的字节长度</param>
/// <param name="msg">成功与否详细信息</param>
/// <returns>是否成功</returns>
public bool ReadDataFromDog(out string str, int offset, int length, out string msg)
{
str = string.Empty;
msg = "读取数据成功";
byte[] zyn = new byte[length];
//校验从偏移地址开始，欲写入的字节长度是否超过999
if (offset + length > 1000)
{
msg = "从偏移地址开始，欲读取的字节长度超出数据区范围（整个数据区1000字节）！";
return(false);
}
uint resultmess;
while (length > 60)
{
byte[] temp = new byte[60];
resultmess = ET99_API.et_Read(ET99_API.dogHandle, (ushort)offset, 60, temp);//读取60字节
if (resultmess != ET99_API.ET_SUCCESS)
{
msg = "其他错误";
if (resultmess == ET99_API.ET_HARD_ERROR)
{
msg = "硬件错误！";
}
if (resultmess == ET99_API.ET_ACCESS_DENY)
{
msg = "权限不够！";
}
return(false);
}
Array.Copy(temp, 0, zyn, zyn.Length - length, 60);
offset += 60;
length -= 60;
}
//剩余数据，不需分割
byte[] others = new byte[length];
resultmess = ET99_API.et_Read(ET99_API.dogHandle, (ushort)offset, length, others);//读取
if (resultmess != ET99_API.ET_SUCCESS)
{
msg = "其他错误";
if (resultmess == ET99_API.ET_HARD_ERROR)
{
msg = "硬件错误！";
}
if (resultmess == ET99_API.ET_ACCESS_DENY)
{
msg = "权限不够！";
}
return(false);
}
Array.Copy(others, 0, zyn, zyn.Length - length, length);
//转化成字符串
str = System.Text.Encoding.Default.GetString(zyn);
return(true);
}
/// <summary>
/// 将字符串写入指定地址的数据区
/// </summary>
/// <param name="origin">欲写入的字符串</param>
/// <param name="offset">偏移地址，范围0~999，字节为单位（整个数据区1000字节，每次读写限制长度60字节）</param>
/// <param name="msg">成功与否详细信息</param>
/// <returns>是否成功</returns>
public bool WriteDataToDog(string origin, int offset, out string msg)
{
msg = "写入数据成功";
byte[] zyn = System.Text.Encoding.Default.GetBytes(origin);
//校验从偏移地址开始，欲写入的字节长度是否超过999
if (offset + zyn.Length > 1000)
{
msg = "从偏移地址开始，欲写入的字节长度超出数据区范围（整个数据区1000字节）！";
return(false);
}
uint resultmess;
while (zyn.Length > 60)
{
byte[] temp = new byte[60];
Array.Copy(zyn, 0, temp, 0, 60); //拷贝60字节数据
byte[] others = new byte[zyn.Length - 60];
Array.Copy(zyn, 60, others, 0, zyn.Length - 60); //拷贝剩余数据
zyn = others; //zyn赋值为剩余数据
resultmess = ET99_API.et_Write(ET99_API.dogHandle, (ushort)offset, 60, temp); // 传入值
if (resultmess != ET99_API.ET_SUCCESS)
{
msg = "其他错误";
if (resultmess == ET99_API.ET_HARD_ERROR)
{
msg = "硬件错误！";
}
if (resultmess == ET99_API.ET_ACCESS_DENY)
{
msg = "权限不够！";
}
return(false);
}
offset += 60;//更新偏移值
}
//剩余数据，不需分割
resultmess = ET99_API.et_Write(ET99_API.dogHandle, (ushort)offset, zyn.Length, zyn);// 传入值
if (resultmess != ET99_API.ET_SUCCESS)
{
msg = "其他错误";
if (resultmess == ET99_API.ET_HARD_ERROR)
{
msg = "硬件错误！";
}
if (resultmess == ET99_API.ET_ACCESS_DENY)
{
msg = "权限不够！";
}
return(false);
}
return(true);
}
/// <summary>
/// 读取指定地址数据区的字符串，并解密。
/// </summary>
/// <param name="offset">偏移地址，范围0~999，字节为单位（整个数据区1000字节，每次读写限制长度60字节）</param>
/// <param name="length">欲读取的字节长度</param>
/// <returns></returns>
public string ReadOffsetDataAndDecrypt(int offset, int length)
{
string str = string.Empty;
byte[] zyn = new byte[length];
uint resultmess;
while (length > 60)
{
byte[] temp = new byte[60];
resultmess = ET99_API.et_Read(ET99_API.dogHandle, (ushort)offset, 60, temp);//读取60字节
if (resultmess != ET99_API.ET_SUCCESS)
{
//ComponentFactory.Krypton.Toolkit.KryptonMessageBox.Show("加密狗数据错误！", "错误",
// System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
//System.Windows.Forms.Application.Exit();
return(string.Format("加密狗读取失败。偏移：{0}，长度：{1}", offset, length));
}
Array.Copy(temp, 0, zyn, zyn.Length - length, 60);
offset += 60;
length -= 60;
}
//剩余数据，不需分割
byte[] others = new byte[length];
resultmess = ET99_API.et_Read(ET99_API.dogHandle, (ushort)offset, length, others);//读取
if (resultmess != ET99_API.ET_SUCCESS)
{
//ComponentFactory.Krypton.Toolkit.KryptonMessageBox.Show("加密狗数据错误！", "错误",
// System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
//System.Windows.Forms.Application.Exit();
return(string.Format("加密狗读取失败。偏移：{0}，长度：{1}", offset, length));
}
Array.Copy(others, 0, zyn, zyn.Length - length, length);
//转化成字符串
str = System.Text.Encoding.Default.GetString(zyn);
if (string.IsNullOrWhiteSpace(str.Replace('\0', ' ')))
{
return(string.Empty);//类似加密狗初期没有的数据‘起始时间’等，直接返回空。
}
//======解密
int intRandom = new Random().Next(1, 9);//随即取1~8
string key16 = HMAC_MD5_dog(intRandom, "武汉创方科技");
return(系统使用的加解密算法.RC2Decrypt(str, key16));
}
// 关闭加密狗
public bool CloseDog(out string msg)
{
msg = string.Empty;
uint result = ET99_API.et_CloseToken(ET99_API.dogHandle);
if (result == ET99_API.ET_SUCCESS)
{
ET99_API.dogHandle = System.IntPtr.Zero;
msg = "成功关闭加密狗";
return(true);
}
else
{
msg = string.Format("关闭加密狗失败，请检查！错误：{0}",
ET99_API.ShowResultText(result));
return(false);
}
}
private void button1_Click(object sender, EventArgs e)
{
int index = 1;//默认仅打开第一个加密狗
byte[] bytPID = System.Text.Encoding.ASCII.GetBytes(Properties.Resources.PID);
uint result = ET99_API.et_OpenToken(ref ET99_API.dogHandle, bytPID, index);
//------------
byte[] bytPIN = System.Text.Encoding.ASCII.GetBytes(Properties.Resources.SOPIN);
result = ET99_API.et_Verify(ET99_API.dogHandle, ET99_API.ET_VERIFY_SOPIN, bytPIN);
if (result == ET99_API.ET_SUCCESS)
{
MessageBox.Show("加密狗认证成功，进入超级用户状态。");
}
else
{
MessageBox.Show("加密狗认证失败，请检查！错误：{0}",
ET99_API.ShowResultText(result));
}
}
//设置8个MD5校验密匙
public bool SetMd5Key(out string msg)
{
msg = string.Empty;
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
string strMd5Key = Properties.Resources.HMAC_MD5;//需要写入的KEY
byte[] bytShortKey = System.Text.Encoding.ASCII.GetBytes(strMd5Key);
for (int keyid = 1; keyid <= 8; keyid++)//循环写入Md5Key
{
byte[] randombuffer = new byte[51];
byte keylen = byte.Parse(strMd5Key.Length.ToString());
byte randomlen = 51;
byte[] sbMd5Key = new byte[32];
byte[] sbdigest = new byte[16];
//第一个参数是随机数，在设置密钥时没有作用
//第二个参数是随机数长度，在设置密钥时没有作用
//第三个参数是分配给客户的密钥
//第四个参数是分配给客户的密钥的长度
//第五个参数是返回的32字节的密钥，用于存到锁内
//第六个参数在设置密钥时没有作用
uint result = ET99_API.MD5_HMAC(randombuffer, randomlen, bytShortKey, keylen, sbMd5Key, sbdigest);
result = ET99_API.et_SetKey(ET99_API.dogHandle, keyid, sbMd5Key);
if (result == ET99_API.ET_SUCCESS)
{
msg = "设置8个MD5校验密匙成功！";
}
else
{
msg = string.Format("设置第{0}个MD5校验密匙失败！错误：{1}", keyid, ET99_API.ShowResultText(result));
return(false);
}
}
return(true);
}
//关闭LED
public bool CloseLED(out string msg)
{
if (ET99_API.dogHandle == System.IntPtr.Zero)
{
msg = "请先打开设备！";
return(false);
}
uint result = ET99_API.et_TurnOffLED(ET99_API.dogHandle);
if (result == ET99_API.ET_SUCCESS)
{
msg = "关闭LED成功！";
return(true);
}
else
{
msg = "关闭LED失败！ 错误：" + ET99_API.ShowResultText(result);
return(false);
}
}
/// <summary>
/// 软件计算HMAC_MD5
/// 加密狗中可存储8个32字节HMAC_MD5密钥（每一个密钥都是由1个16字节密钥种子重复一次而成，这里存储的是8个16字节‘密钥种子’）
/// </summary>
/// <param name="MD5KeyIndexInDog">密钥index[范围1~8，对应加密狗中密钥存储范围1~8]</param>
/// <param name="origin">原始字串</param>
/// <returns>加密后字串</returns>
public string HMAC_MD5_soft(int MD5KeyIndexInDog, string origin)
{
string strMD5Key = Properties.Resources.HMAC_MD5;
byte[] bytRandomCode = new byte[origin.Length]; //第一个参数是随机数
bytRandomCode = System.Text.Encoding.ASCII.GetBytes(origin);
byte randomlen = byte.Parse(origin.Length.ToString()); //第二个参数是随机数长度
byte[] bytShortKey = new byte[strMD5Key.Length]; //第三个参数是分配给客户的密钥
bytShortKey = System.Text.Encoding.ASCII.GetBytes(strMD5Key);
byte keylen = byte.Parse(strMD5Key.Length.ToString()); //第四个参数是分配给客户的密钥的长度
byte[] sbMd5Key = new byte[32]; //第五个参数没有作用
byte[] sbdigest = new byte[16]; //第六个参数为软件计算的结果
//第一个参数是随机数
//第二个参数是随机数长度
//第三个参数是分配给客户的密钥
//第四个参数是分配给客户的密钥的长度
//第五个参数没有作用
//第六个参数为软件计算的结果
uint result = ET99_API.MD5_HMAC(bytRandomCode, randomlen, bytShortKey, keylen, sbMd5Key, sbdigest);
if (result == ET99_API.ET_SUCCESS)
{
//string strSoftDigest = string.Empty;
//for (int i = 0; i < 16; i++)
// strSoftDigest += string.Format("{0:X2}", sbdigest[i]);
//return strSoftDigest;
return(System.Text.Encoding.Default.GetString(sbdigest));
}
else//失败
{
return("软件计算失败");
}
}
