439 lines
14 KiB
C++
439 lines
14 KiB
C++
#include "LicenseManger.h"
|
|
#include "dlginputaddr.h"
|
|
#include <QFile>
|
|
#include <QMessageBox>
|
|
#include <QDate>
|
|
#include <QDateEdit>
|
|
#include <time.h>
|
|
#include <QDebug>
|
|
#include <QTime>
|
|
#include <QDate>
|
|
|
|
#include "qnamespace.h"
|
|
#include <QtCore/QCoreApplication>
|
|
#include <QCryptographicHash>
|
|
|
|
|
|
|
|
MACHINE_INFO_t machine_info;
|
|
LICENSE_DATA_t license_data;
|
|
QMutex machine_info_mutex;
|
|
QMutex license_data_mutex;
|
|
|
|
|
|
|
|
void adjustDateAndTime(int year, int mon, int mday, int hour, int min, int sec);
|
|
LicenseManger::LicenseManger()
|
|
{
|
|
#if 1
|
|
UCHAR e_key[1024] = "dangerous IOP 0908 ";
|
|
pAes = new TAesClass;
|
|
pAes->InitializePrivateKey(16, e_key); //进行初始化
|
|
//setMachineInfo(16);
|
|
#endif
|
|
}
|
|
//set machine info
|
|
qint32 LicenseManger::setMachineInfo(quint32 serial_num)
|
|
{
|
|
//check serial number size
|
|
if(serial_num>999999)
|
|
{
|
|
return -1;
|
|
}
|
|
machine_info_mutex.lock();
|
|
QString serial;
|
|
serial.sprintf("VB%06d", serial_num);
|
|
|
|
QByteArray hash_data;
|
|
hash_data = QCryptographicHash::hash(serial.toAscii(),QCryptographicHash::Md5 );
|
|
//MACHINE_INFO_t machine_info;
|
|
machine_info.serial_number=serial_num;
|
|
memcpy(&machine_info.md5[0],hash_data.data(),MD5_LENGTH);
|
|
//qDebug()<<"org sn info"<<machine_info.serial_number;
|
|
//qDebug()<<"org machine md5 size"<<sizeof(machine_info.md5);
|
|
#if 0
|
|
QString md5;
|
|
md5.append(hash_data);
|
|
qDebug()<<"org machine md5 "<<md5;
|
|
for(int i=0;i<16;i++)
|
|
{
|
|
qDebug()<<tr("org md5[%1]").arg(i)<<machine_info.md5[i];
|
|
}
|
|
#endif
|
|
#if 1
|
|
char encrypt_buff[1024];
|
|
QFile file(MACH_INFO_FILE);
|
|
//encrypt the data then write to file
|
|
file.open(QIODevice::WriteOnly | QIODevice::Truncate);
|
|
file.seek(0);
|
|
pAes->OnAesEncrypt((LPVOID)&machine_info, sizeof(machine_info), (LPVOID)encrypt_buff); //进行加密
|
|
//qDebug()<<"sn jiami:"<<encrypt_buff;
|
|
file.write((char *)encrypt_buff,(qint64)sizeof(encrypt_buff));
|
|
file.close();
|
|
#else
|
|
QFile file(MACH_INFO_FILE);
|
|
//encrypt the data then write to file
|
|
file.open(QIODevice::WriteOnly | QIODevice::Truncate);
|
|
file.seek(0);
|
|
file.write((char *)&machine_info,(qint64)sizeof(machine_info));
|
|
file.close();
|
|
#endif
|
|
machine_info_mutex.unlock();
|
|
return 0;
|
|
}
|
|
|
|
// check machine info from flash is available
|
|
qint32 LicenseManger::checkMachineInfoAvailable()
|
|
{
|
|
static bool bmachine_info_availble;
|
|
QFile file(MACH_INFO_FILE);
|
|
if(!file.exists())
|
|
{
|
|
bmachine_info_availble=false;
|
|
return 0;
|
|
}
|
|
if(bmachine_info_availble)
|
|
{
|
|
return 1;
|
|
}
|
|
#if 1
|
|
machine_info_mutex.lock();
|
|
char encrypt_buff[1024];
|
|
char decrypt_buff[1024];
|
|
MACHINE_INFO_t machine_info_from_flash;
|
|
file.open(QIODevice::ReadOnly | QIODevice::Truncate);
|
|
file.read((char *)encrypt_buff,(qint64)sizeof(encrypt_buff));
|
|
pAes->OnAesUncrypt((LPVOID)encrypt_buff, (DWORD)sizeof(encrypt_buff),(LPVOID)decrypt_buff); //进行解密
|
|
//qDebug()<<"jiemi:"<<decrypt_buff;
|
|
memcpy(&machine_info_from_flash,decrypt_buff,sizeof(machine_info_from_flash));
|
|
file.close();
|
|
#else
|
|
MACHINE_INFO_t machine_info_from_flash;
|
|
file.open(QIODevice::ReadOnly | QIODevice::Truncate);
|
|
file.seek(0);
|
|
file.read((char *)&machine_info_from_flash,(qint64)sizeof(machine_info_from_flash));
|
|
file.close();
|
|
qDebug()<<"duchu:sn"<<machine_info_from_flash.serial_number;
|
|
#endif
|
|
qDebug()<<"jiemi:sn"<<machine_info_from_flash.serial_number;
|
|
QString serial_from_flash;
|
|
serial_from_flash.sprintf("VB%06d", machine_info_from_flash.serial_number);
|
|
QString md5_from_calc;
|
|
QByteArray hash_data;
|
|
hash_data = QCryptographicHash::hash(serial_from_flash.toAscii(),QCryptographicHash::Md5 );
|
|
md5_from_calc.append(hash_data);
|
|
if(!memcmp(hash_data.data(),&machine_info_from_flash.md5[0],16))
|
|
{
|
|
bmachine_info_availble=true;
|
|
memcpy(&machine_info,&machine_info_from_flash,sizeof(machine_info));
|
|
qDebug()<<"machine info is available"<<machine_info.serial_number;
|
|
machine_info_mutex.unlock();
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
bmachine_info_availble=false;
|
|
qDebug()<<"machine info is not available";
|
|
machine_info_mutex.unlock();
|
|
return 0;
|
|
}
|
|
}
|
|
qint8 LicenseManger::getLicState()
|
|
{
|
|
qint8 lic_state = LICENSE_STATE_OK;
|
|
if(!checkMachineInfoAvailable())
|
|
{
|
|
lic_state = -LICENSE_STATE_MACH_INFO_DAMAGED;
|
|
}
|
|
else
|
|
{
|
|
|
|
if(!CheckLicDataValid())
|
|
{
|
|
lic_state = -LICENSE_STATE_LIC_DATA_DAMAGED;
|
|
}
|
|
}
|
|
return lic_state;
|
|
}
|
|
void LicenseManger::SaveLicData2File()
|
|
{
|
|
#if 0
|
|
QFile file("/lib/syst");
|
|
#else
|
|
QFile file(LIC_FILE);
|
|
qint32 encryp_len;
|
|
#endif
|
|
|
|
if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate)){
|
|
QMessageBox::warning(0,"警告",QString(QObject::tr("无法打开license文件")) );
|
|
}
|
|
else {
|
|
qDebug()<<"save license file start";
|
|
license_data_mutex.lock();
|
|
QByteArray ba_licdata((char *)&license_data,(sizeof(license_data) - sizeof(license_data.md5)));
|
|
//memcpy(ba_licdata.data(),(char *)&license_data,(sizeof(license_data) - sizeof(license_data.md5)));
|
|
QByteArray hash_data;
|
|
hash_data = QCryptographicHash::hash(ba_licdata,QCryptographicHash::Md5 );
|
|
memcpy(&license_data.md5[0],hash_data.data(),LIC_DATA_MD5_LEN);
|
|
#if 0
|
|
file.seek(0);
|
|
file.write((char *)&license_data.serial_number,(long long int)sizeof(license_data));
|
|
file.close();
|
|
#else
|
|
char encrypt_buff[1024];
|
|
file.seek(0);
|
|
encryp_len = pAes->OnAesEncrypt((LPVOID)&license_data, sizeof(license_data), (LPVOID)encrypt_buff); //进行加密
|
|
//qDebug()<<"jiami:"<<encrypt_buff;
|
|
file.write((char *)encrypt_buff,(qint64)sizeof(encrypt_buff));
|
|
file.close();
|
|
#endif
|
|
license_data_mutex.unlock();
|
|
qDebug()<<"save license file end";
|
|
}
|
|
}
|
|
void LicenseManger::ReadLicDataFromFile()
|
|
{
|
|
#if 0
|
|
QFile file("/lib/syst");
|
|
#else
|
|
QFile file(LIC_FILE);
|
|
#endif
|
|
if(!file.exists())
|
|
{
|
|
if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate)){
|
|
QMessageBox::warning(0,QObject::tr("警告"),QString(QObject::tr("无法打开license文件") ));
|
|
}
|
|
else {
|
|
//file.seek(0);
|
|
file.close();
|
|
ResetLicDataFile();
|
|
//show();
|
|
}
|
|
}
|
|
else {
|
|
if(!file.open(QIODevice::ReadOnly | QIODevice::Truncate)){
|
|
QMessageBox::warning(0,"警告",QString("无法打开license文件") );
|
|
}
|
|
else
|
|
{
|
|
license_data_mutex.lock();
|
|
qDebug()<<"read license file start";
|
|
#if 0
|
|
file.read((char *)&license_data.serial_number,(long long int)sizeof(license_data));
|
|
file.close();
|
|
#else
|
|
char encrypt_buff[1024];
|
|
char decrypt_buff[1024];
|
|
file.read((char *)encrypt_buff,(qint64)sizeof(encrypt_buff));
|
|
pAes->OnAesUncrypt((LPVOID)encrypt_buff, (DWORD)sizeof(encrypt_buff),(LPVOID)decrypt_buff); //进行解密
|
|
//qDebug()<<"jiemi:"<<decrypt_buff;
|
|
memcpy((char *)&license_data,decrypt_buff,sizeof(license_data));
|
|
file.close();
|
|
#endif
|
|
license_data_mutex.unlock();
|
|
qDebug()<<"read license file end";
|
|
}
|
|
}
|
|
}
|
|
void LicenseManger::ResetLicDataFile()
|
|
{
|
|
memset((char *)&license_data.serial_number,0,sizeof(license_data));
|
|
license_data.serial_number = 100001;
|
|
license_data.powerEn=1;
|
|
license_data.printEn =1;
|
|
license_data.enable =1;
|
|
license_data.powerMinuteCnt=0;
|
|
license_data.printCnt=0;
|
|
license_data.powerMinuteMax=1*31*18*60;// minute cnt
|
|
license_data.printMax = 0xfffff000;
|
|
curDate =QDate::currentDate();
|
|
QDate curDate1;
|
|
QDate buildDate = QLocale(QLocale::English).toDate(QString( __DATE__ ).replace(" ", " 0"), "MMM dd yyyy");
|
|
QTime buildTime = QTime::fromString( __TIME__, "hh:mm:ss" );
|
|
if(curDate<buildDate) {
|
|
curDate=buildDate;
|
|
int year = buildDate.year();
|
|
int month = buildDate.month();
|
|
int day = buildDate.day();
|
|
int hour = buildTime.hour();
|
|
int minute = buildTime.minute();
|
|
int sec = buildTime.second();
|
|
adjustDateAndTime(year, month, day, hour, minute, sec);//set system date and time
|
|
}
|
|
|
|
license_data.start =curDate.toString("yyyyMMdd").toInt(0);
|
|
license_data.nDate = license_data.start; //
|
|
//curDate1.toString("yyyyMMdd").toInt(0);
|
|
curDate1 = curDate.addMonths(1);
|
|
//curDate1.setYMD(curDate.year()+license_data.validity/12, (curDate.month()+license_data.validity)%12,curDate.day());
|
|
license_data.end = curDate1.toString("yyyyMMdd").toInt(0);
|
|
license_data.workout = 0x1;
|
|
license_data.remainingTime = 6*60*18*180; //half year,one day work 18 hours
|
|
license_data.printer_auth_flag = ~0x00;
|
|
license_data.printer_bworkout = 1;
|
|
//qDebug()<<license_data.start<<license_data.end ;
|
|
SaveLicData2File();
|
|
}
|
|
#include <time.h>
|
|
void adjustDateAndTime(int year, int mon, int mday, int hour, int min, int sec) {
|
|
time_t t;
|
|
struct tm nowtime;
|
|
nowtime.tm_sec = sec; // Seconds.[0-60] (1 leap second)
|
|
nowtime.tm_min = min; // Minutes.[0-59]
|
|
nowtime.tm_hour = hour; // Hours. [0-23]
|
|
nowtime.tm_mday = mday; // Day.[1-31]
|
|
nowtime.tm_mon = mon - 1; // Month. [0-11]
|
|
nowtime.tm_year = year - 1900; // Year- 1900.
|
|
nowtime.tm_isdst = -1; // DST.[-1/0/1]
|
|
t = mktime(&nowtime);
|
|
// qDebug()<<t<<year<<mon<<mday<<hour<<min<<sec;
|
|
#ifdef ARMUART
|
|
stime(&t);
|
|
#endif
|
|
|
|
}
|
|
|
|
int LicenseManger::CheckLicDataValid()
|
|
{
|
|
/* read data from file */
|
|
ReadLicDataFromFile();
|
|
|
|
/* check remaining time */
|
|
if(license_data.remainingTime >= 6*60*18*367)
|
|
{
|
|
qDebug()<<"license file was invalid";
|
|
return 0;
|
|
}
|
|
if(license_data.vernon_bach_version != VERNONBACH_VERSION_CODE)
|
|
{
|
|
qDebug()<<"license file was invalid";
|
|
return 0;
|
|
}
|
|
qDebug()<<"license serial number"<<license_data.serial_number;
|
|
/* check md5 value */
|
|
QByteArray ba_licdata((char *)&license_data,(sizeof(license_data) - sizeof(license_data.md5)));
|
|
//memcpy(ba_licdata.data(),(char *)&license_data,(sizeof(license_data) - sizeof(license_data.md5)));
|
|
QByteArray hash_data;
|
|
hash_data = QCryptographicHash::hash(ba_licdata, QCryptographicHash::Md5);
|
|
if(memcmp(&license_data.md5[0],hash_data.data(),LIC_DATA_MD5_LEN))
|
|
{
|
|
qDebug()<<"license file was damaged";
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
|
|
quint32 LicenseManger::CheckRemainingTime()
|
|
{
|
|
/* read data from file */
|
|
ReadLicDataFromFile();
|
|
|
|
/* check remaining time */
|
|
if(license_data.remainingTime >= 6*60*18*367)
|
|
{
|
|
qDebug()<<"license file was invalid";
|
|
return 0;
|
|
}
|
|
if(license_data.remainingTime)
|
|
license_data.remainingTime--;
|
|
if(license_data.remainingTime<=0)
|
|
{
|
|
license_data.workout = 1;
|
|
}
|
|
SaveLicData2File();
|
|
//license_data.remainingTime=0;
|
|
return license_data.remainingTime;
|
|
|
|
}
|
|
|
|
quint32 LicenseManger::CheckUpdateFileState()
|
|
{
|
|
QFile file(UPDATE_LIC_FILE);
|
|
LICENSE_DATA_t update_license_data;
|
|
quint32 state = UPDATE_LICENSE_FILE_OK;
|
|
if(!file.exists())
|
|
{
|
|
state = -UPDATE_LICENSE_FILE_NOT_EXIT;
|
|
}
|
|
else
|
|
{
|
|
if(!file.open(QIODevice::ReadOnly | QIODevice::Truncate)){
|
|
QMessageBox::warning(0,"警告",QString("无法打开license文件") );
|
|
state = -UPDATE_LICENSE_FILE_OPEN_FAILED;
|
|
}
|
|
else
|
|
{
|
|
//license_data_mutex.lock();
|
|
char encrypt_buff[1024];
|
|
char decrypt_buff[1024];
|
|
file.read((char *)encrypt_buff,(qint64)sizeof(encrypt_buff));
|
|
pAes->OnAesUncrypt((LPVOID)encrypt_buff, (DWORD)sizeof(encrypt_buff),(LPVOID)decrypt_buff); //进行解密
|
|
//qDebug()<<"jiemi:"<<decrypt_buff;
|
|
memcpy(&update_license_data,decrypt_buff,sizeof(update_license_data));
|
|
file.close();
|
|
//license_data_mutex.unlock();
|
|
|
|
/* check md5 value */
|
|
QByteArray ba_update_licdata;
|
|
memcpy(ba_update_licdata.data(),(char *)&update_license_data,(sizeof(update_license_data) - sizeof(update_license_data.md5)));
|
|
QByteArray hash_data;
|
|
hash_data = QCryptographicHash::hash(ba_update_licdata,QCryptographicHash::Md5 );
|
|
if(memcmp(&update_license_data.md5[0],hash_data.data(),LIC_DATA_MD5_LEN)) //file is invalid
|
|
{
|
|
state = -UPDATE_LICENSE_FILE_MD5_VALUE_ERR;
|
|
}
|
|
|
|
if( update_license_data.serial_number != machine_info.serial_number)
|
|
{
|
|
state = -UPDATE_LICENSE_FILE_SERIAL_NUMBER_ERR;
|
|
}
|
|
else if( update_license_data.printer_active_count <= license_data.printer_active_count ||
|
|
update_license_data.printer_active_count >= (license_data.printer_active_count+3) )
|
|
{
|
|
state = -UPDATE_LICENSE_FILE_ACTIVE_NUMBER_ERR;
|
|
}
|
|
else if(update_license_data.vernon_bach_version != VERNONBACH_VERSION_CODE)
|
|
{
|
|
state = -UPDATE_LICENSE_FILE_SW_VERSION_ERR;
|
|
}
|
|
}
|
|
}
|
|
return state;
|
|
}
|
|
quint32 LicenseManger::UpdateLicenseFileData()
|
|
{
|
|
QFile file(UPDATE_LIC_FILE);
|
|
LICENSE_DATA_t update_license_data;
|
|
quint32 state = UPDATE_LICENSE_FILE_OK;
|
|
if(!file.exists())
|
|
{
|
|
state = -UPDATE_LICENSE_FILE_NOT_EXIT;
|
|
}
|
|
else
|
|
{
|
|
if(!file.open(QIODevice::ReadOnly | QIODevice::Truncate)){
|
|
QMessageBox::warning(0,"警告",QString("无法打开更新license文件") );
|
|
state = -UPDATE_LICENSE_FILE_OPEN_FAILED;
|
|
}
|
|
else
|
|
{
|
|
//license_data_mutex.lock();
|
|
char encrypt_buff[1024];
|
|
char decrypt_buff[1024];
|
|
file.read((char *)encrypt_buff,(qint64)sizeof(encrypt_buff));
|
|
pAes->OnAesUncrypt((LPVOID)encrypt_buff, (DWORD)sizeof(encrypt_buff),(LPVOID)decrypt_buff); //进行解密
|
|
//qDebug()<<"jiemi:"<<decrypt_buff;
|
|
memcpy(&update_license_data,decrypt_buff,sizeof(update_license_data));
|
|
file.close();
|
|
//license_data_mutex.unlock();
|
|
memcpy(&license_data, &update_license_data, sizeof(update_license_data));
|
|
SaveLicData2File();
|
|
}
|
|
}
|
|
return state;
|
|
}
|