whellvalue/src/tpMain/cryptokey/lpCryptokey.cpp

#include "lpCryptokey.h"
#include <QCryptographicHash>
#include "lpHardwareInfo.h"
#include <QSettings>

namespace lpCryptokey
{
	const QString ComponyKey = "hzleaper";
	QString genSerialNumber(const QString& mac)
	{
		unsigned long long ulMacTmp = 0;
		QString newMac = mac + ComponyKey;
		std::string mStrMac = newMac.toStdString();
		mStrMac.erase(std::remove(mStrMac.begin(), mStrMac.end(), ':'), mStrMac.end());
		mStrMac.erase(std::remove(mStrMac.begin(), mStrMac.end(), '-'), mStrMac.end());

		for (int i = 0; i < mStrMac.size(); i++)
		{
			ulMacTmp = ulMacTmp << 4;
			char cStr = mStrMac.at(i);
			if (cStr >= '0'&&cStr <= '9')
				ulMacTmp += (int)(mStrMac.at(i) - '0');
			else if (cStr >= 'a'&&cStr <= 'f')
				ulMacTmp += (int)(mStrMac.at(i) - 'a' + 10);
			else if (cStr >= 'A'&&cStr <= 'F')
				ulMacTmp += (int)(mStrMac.at(i) - 'A' + 10);
			else
				ulMacTmp += 0;
		}
		QString serial = QString("%1").arg(ulMacTmp);
		QString key = QString("%1").arg(serial.mid(serial.size()-9,-1).toInt(),9,10, QLatin1Char('0'));
		return key;
	}

	QString genEncryption(const QString& serial)
	{
		QByteArray byte;
		byte.append(serial + ComponyKey);
		QByteArray MD5byte = QCryptographicHash::hash(byte, QCryptographicHash::Md4);
		QString str = MD5byte.toHex().toUpper();
		int size = 20;
		int kNum = 4;
		QString strKey;
		for (int n = 0; n < size / kNum; n++) {
			strKey += str.mid(n * kNum, kNum);
			if (n < (size / kNum) - 1)
				strKey += "-";
		}
		return strKey;
	}

	bool compareCrypto(const QString& serial, const QString& key)
	{
		QString tmpKey = genEncryption(serial);
		if (tmpKey == key)
			return true;
		return false;
	}

}

lpCheckKey::lpCheckKey()
{
	lpHardwareInfo::instance()->init();
	rsa_op.set_params();
	rsa_op.open_prikey_pubkey();
	rsa_op.open_pubkey();
}

lpCheckKey::~lpCheckKey()
{

}
//检查linese是否匹配
bool lpCheckKey::checkLinese()
{
	std::string hardDriveID = lpHardwareInfo::instance()->getHardDrive();
	std::string cpuID = lpHardwareInfo::instance()->getCpuID();
	std::string BoardID = lpHardwareInfo::instance()->getMotherBoardID();
	std::string macID = lpHardwareInfo::instance()->getMacAddress();
// 	if (hardDriveID.size() > 0)
// 	{
// 		m_SerialNo = lpCryptokey::genSerialNumber(QString(hardDriveID.c_str()) + QString(cpuID.c_str()));
// 	}
// 	else {
		m_SerialNo = lpCryptokey::genSerialNumber(/*QString(BoardID.c_str()) +*/ QString(macID.c_str()));
//	}
	QSettings settingKey("Leaper_Register");
	QString strKey = settingKey.value("key").toString();
	bool bRegister = settingKey.value("register", false).toBool();
	QString serialNo = settingKey.value("serialNo").toString();
	if (m_SerialNo != serialNo)
	{
		if (bRegister == true)
		{
			return true;
		}
	}

	QByteArray lineseData = genLinese(m_SerialNo.toLatin1());
	if (lineseData == strKey)
		return true;
	else
		return false;
}

bool lpCheckKey::checkLinese(QString serialNo, QString linese)
{
	QByteArray lineseData = genLinese(serialNo.toLatin1());
	if (QString(lineseData) == linese)
	{
		QSettings settingKey("Leaper_Register");
		settingKey.setValue("key", linese);
		settingKey.setValue("register", true);
		settingKey.setValue("serialNo", serialNo);
		return true;
	}
	else
		return false;
}

QString lpCheckKey::getSerialNo() const
{
	return m_SerialNo;
}

QByteArray lpCheckKey::genLinese(QByteArray serialNo)
{
	QByteArray character = serialNo;
	if (character.length() >= 116)
	{
		character = character.mid(0, 116);
	}

	int enc_len = 0;
	unsigned char *enc_data = NULL;
	unsigned char *enc_data2 = NULL;
	rsa_op.prikey_encrypt((BYTE*)character.data(), character.length() + 1, (unsigned char **)&enc_data, enc_len);
	QByteArray licenseKey((char*)enc_data, enc_len);
	QByteArray licenseKeyForHex = licenseKey.toHex();
	return licenseKeyForHex;
}