462 lines
10 KiB
C++
462 lines
10 KiB
C++
#include "Inc/toolkit/Authority.h"
|
|
#include <filesystem>
|
|
namespace fs = std::filesystem;
|
|
|
|
#ifdef WIN32
|
|
#include <time.h>
|
|
|
|
RegMgr* RegMgr::m_instance = nullptr;
|
|
|
|
RegMgr* RegMgr::GetInstance()
|
|
{
|
|
if (m_instance == nullptr)
|
|
{
|
|
m_instance = new RegMgr;
|
|
}
|
|
return m_instance;
|
|
}
|
|
|
|
bool RegMgr::IsKeyExists(HKEY hRootKey, char* strKey)
|
|
{
|
|
HKEY hKey;
|
|
LONG nError = RegOpenKeyExA(hRootKey, strKey, NULL, KEY_ALL_ACCESS, &hKey);
|
|
|
|
if (nError == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
return false;
|
|
}
|
|
RegCloseKey(hKey);
|
|
return true;
|
|
}
|
|
|
|
HKEY RegMgr::OpenKey(HKEY hRootKey, char* strKey)
|
|
{
|
|
HKEY hKey;
|
|
LONG nError = RegOpenKeyExA(hRootKey, strKey, NULL, KEY_ALL_ACCESS, &hKey);
|
|
|
|
if (nError == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
//cout << "Creating registry key: " << strKey << endl;
|
|
nError = RegCreateKeyExA(hRootKey, strKey, NULL, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL);
|
|
}
|
|
|
|
if (nError)
|
|
{
|
|
//cout << "Error: " << nError << " Could not find and create " << strKey << endl;
|
|
return NULL;
|
|
}
|
|
|
|
return hKey;
|
|
}
|
|
|
|
long RegMgr::SetDwordVal(HKEY hKey, char* lpValueName, DWORD dwValue)
|
|
{
|
|
LONG nError = RegSetValueExA(hKey, lpValueName, NULL, REG_DWORD, (LPBYTE)&dwValue, sizeof(DWORD));
|
|
|
|
if (nError)
|
|
{
|
|
//cout << "Error: " << nError << " Could not set registry value: " << (char*)lpValueName << endl;
|
|
return nError;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
long RegMgr::GetDwordVal(HKEY hKey, char* lpValueName, DWORD& dwVale)
|
|
{
|
|
DWORD type = REG_DWORD, size = sizeof(dwVale);
|
|
LONG nError = RegQueryValueExA(hKey, lpValueName, NULL, &type, (LPBYTE)&dwVale, &size);
|
|
|
|
if (nError == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
dwVale = 0; // The value will be created and set to data next time SetVal() is called.
|
|
return nError;
|
|
}
|
|
else if (nError)
|
|
{
|
|
//cout << "Error: " << nError << " Could not get registry value " << (char*)lpValueName << endl;
|
|
return nError;
|
|
}
|
|
else if (type != REG_DWORD)
|
|
{
|
|
//cout << "Error: " << nError << " Could not get registry value " << (char*)lpValueName << endl;
|
|
return ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
long RegMgr::SetStrVal(HKEY hKey, char* lpValueName, char * strValue)
|
|
{
|
|
LONG nError = RegSetValueExA(hKey, lpValueName, NULL, REG_BINARY, (LPBYTE)strValue, 32);
|
|
|
|
if (nError)
|
|
{
|
|
//cout << "Error: " << nError << " Could not set registry value: " << (char*)lpValueName << endl;
|
|
return nError;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
long RegMgr::GetStrVal(HKEY hKey, char* lpValueName, char * strValue, DWORD strLen)
|
|
{
|
|
if (strValue == NULL || strlen <= 0)
|
|
{
|
|
return -1;
|
|
}
|
|
DWORD type = REG_BINARY;
|
|
LONG nError = RegQueryValueExA(hKey, lpValueName, NULL, &type, (LPBYTE)strValue, &strLen);
|
|
|
|
if (nError == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
strValue[0] = '\0'; // The value will be created and set to data next time SetVal() is called.
|
|
return nError;
|
|
}
|
|
else if (nError)
|
|
{
|
|
strValue[0] = '\0';
|
|
//cout << "Error: " << nError << " Could not get registry value " << (char*)lpValueName << endl;
|
|
return nError;
|
|
}
|
|
else if (type != REG_BINARY)
|
|
{
|
|
strValue[0] = '\0';
|
|
//cout << "Error: " << nError << " Could not get registry value " << (char*)lpValueName << endl;
|
|
return ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
long RegMgr::SetLastUsedTime()
|
|
{
|
|
time_t curTime;
|
|
time(&curTime);
|
|
char srcBuf[64] = { 0 };
|
|
char encryptBuf[64] = { 0 };
|
|
|
|
tm _tm;
|
|
localtime_s(&_tm, &curTime);
|
|
strftime(srcBuf, sizeof(srcBuf), "%Y-%m-%d %H:%M:%S", &_tm);
|
|
|
|
if (0 == Authority::GetInstance()->EncryptString(srcBuf, encryptBuf))
|
|
{
|
|
HKEY hKey = OpenKey(DC_ROOT_KEY, DC_XD_FRDLL_LASTUSED_TIME);
|
|
if (hKey == NULL)
|
|
{
|
|
return -2;
|
|
}
|
|
long lRsult = SetStrVal(hKey, DC_LAST_TIME_VALUE_NAME, encryptBuf);
|
|
RegCloseKey(hKey);
|
|
return lRsult;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
long RegMgr::GetLastUsedTime(time_t & usedTime)
|
|
{
|
|
char srcBuf[64] = { 0 };
|
|
char decryptBuf[64] = { 0 };
|
|
|
|
HKEY hKey = OpenKey(DC_ROOT_KEY, DC_XD_FRDLL_LASTUSED_TIME);
|
|
if (hKey == NULL)
|
|
{
|
|
return -2;
|
|
}
|
|
long lRsult = GetStrVal(hKey, DC_LAST_TIME_VALUE_NAME, srcBuf, 32);
|
|
RegCloseKey(hKey);
|
|
|
|
if (lRsult != ERROR_SUCCESS)
|
|
{
|
|
return -4;
|
|
}
|
|
if (0 == Authority::GetInstance()->DecryptString(srcBuf, decryptBuf))
|
|
{
|
|
usedTime = StringToDatetime(decryptBuf);
|
|
if (usedTime > 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
long RegMgr::DeleteAllUsedKeys()
|
|
{
|
|
HKEY hKey;
|
|
LONG nError = RegOpenKeyExA(DC_ROOT_KEY, "SOFTWARE", NULL, KEY_ALL_ACCESS, &hKey);
|
|
|
|
if (nError == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
return nError;
|
|
}
|
|
|
|
::RegDeleteKeyA(hKey, "HighDeepCamSTc");
|
|
::RegDeleteKeyA(hKey, "XdFrInfoTc");
|
|
::RegDeleteKeyA(hKey, "SweepXdTc");
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
if (!IsKeyExists(DC_ROOT_KEY, DC_HIGH_DEEPCAM_AUTHORITY) &&
|
|
!IsKeyExists(DC_ROOT_KEY, DC_XD_FRDLL_AUTHORITY_TIME) &&
|
|
!IsKeyExists(DC_ROOT_KEY, DC_XD_FRDLL_LASTUSED_TIME))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
long RegMgr::SetAuthorityKey(char * strAuthKey)
|
|
{
|
|
if (strAuthKey == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
char encryptBuf[64] = { 0 };
|
|
if (0 == Authority::GetInstance()->EncryptString(strAuthKey, encryptBuf))
|
|
{
|
|
HKEY hKey = OpenKey(DC_ROOT_KEY, DC_HIGH_DEEPCAM_AUTHORITY);
|
|
if (hKey == NULL)
|
|
{
|
|
return -2;
|
|
}
|
|
long lRsult = SetStrVal(hKey, DC_KEY_VALUE_NAME, encryptBuf);
|
|
RegCloseKey(hKey);
|
|
return lRsult;
|
|
}
|
|
return -3;
|
|
}
|
|
|
|
long RegMgr::GetAuthorityKey(char * strAuthKey, DWORD strLen)
|
|
{
|
|
if (strAuthKey == NULL || strLen != 64)
|
|
{
|
|
return -1;
|
|
}
|
|
char dncryptBuf[64] = { 0 };
|
|
HKEY hKey = OpenKey(DC_ROOT_KEY, DC_HIGH_DEEPCAM_AUTHORITY);
|
|
|
|
if (hKey == NULL)
|
|
{
|
|
return -2;
|
|
}
|
|
|
|
long lRsult = GetStrVal(hKey, DC_KEY_VALUE_NAME, dncryptBuf, 32);
|
|
RegCloseKey(hKey);
|
|
|
|
if (lRsult != ERROR_SUCCESS)
|
|
{
|
|
return -4;
|
|
}
|
|
|
|
if (0 == Authority::GetInstance()->DecryptString(dncryptBuf, strAuthKey))
|
|
{
|
|
return 0;
|
|
}
|
|
return -3;
|
|
}
|
|
|
|
long RegMgr::SetAuthorityByTimeStr(char * strAuthTime)
|
|
{
|
|
if (strAuthTime == NULL)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
//OfficialVersion
|
|
char tmpTimeStr[64] = { 0 };
|
|
strncpy_s(tmpTimeStr, 64, DC_OfficialVersion_FLAG, strnlen_s(DC_OfficialVersion_FLAG, 16));
|
|
char strUuid[64] = { 0 };
|
|
GetUUID(strUuid);
|
|
strUuid[12] = '\0';
|
|
strncat_s(tmpTimeStr, 64, strUuid, strnlen_s(strUuid, 12));
|
|
if (0 != strcmp(strAuthTime, tmpTimeStr))
|
|
{
|
|
time_t authTime = StringToDatetime(strAuthTime);
|
|
time_t tCurTime;
|
|
time(&tCurTime);
|
|
if (tCurTime > authTime)
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
char encryptBuf[64] = { 0 };
|
|
if (0 == EncryptString(strAuthTime, encryptBuf))
|
|
{
|
|
HKEY hKey = OpenKey(DC_ROOT_KEY, DC_XD_FRDLL_AUTHORITY_TIME);
|
|
if (hKey == NULL)
|
|
{
|
|
return -2;
|
|
}
|
|
long lRsult = SetStrVal(hKey, DC_AUTH_TIME_VALUE_NAME, encryptBuf);
|
|
RegCloseKey(hKey);
|
|
return lRsult;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
long RegMgr::SetAuthorityTime()
|
|
{
|
|
time_t curTime;
|
|
time(&curTime);
|
|
char srcBuf[64] = { 0 };
|
|
char encryptBuf[64] = { 0 };
|
|
|
|
tm _tm;
|
|
localtime_s(&_tm, &curTime);
|
|
strftime(srcBuf, sizeof(srcBuf), "%Y-%m-%d %H:%M:%S", &_tm);
|
|
|
|
return SetAuthorityByTimeStr(srcBuf);
|
|
}
|
|
long RegMgr::GetAuthorityTime(time_t & authTime)
|
|
{
|
|
char srcBuf[64] = { 0 };
|
|
char decryptBuf[64] = { 0 };
|
|
|
|
HKEY hKey = OpenKey(DC_ROOT_KEY, DC_XD_FRDLL_AUTHORITY_TIME);
|
|
if (hKey == NULL)
|
|
{
|
|
return -2;
|
|
}
|
|
long lRsult = GetStrVal(hKey, DC_AUTH_TIME_VALUE_NAME, srcBuf, 32);
|
|
RegCloseKey(hKey);
|
|
|
|
if (lRsult != ERROR_SUCCESS)
|
|
{
|
|
return -4;
|
|
}
|
|
if (0 == DecryptString(srcBuf, decryptBuf))
|
|
{
|
|
//OfficialVersion
|
|
char tmpTimeStr[64] = { 0 };
|
|
strncpy_s(tmpTimeStr, 64, DC_OfficialVersion_FLAG, strnlen_s(DC_OfficialVersion_FLAG, 16));
|
|
char strUuid[64] = { 0 };
|
|
GetUUID(strUuid);
|
|
strUuid[12] = '\0';
|
|
strncat_s(tmpTimeStr, 64, strUuid, strnlen_s(strUuid, 12));
|
|
if (0 == strcmp(decryptBuf, tmpTimeStr))
|
|
{
|
|
return DC_OfficialVersion_YEAR;
|
|
}
|
|
int year, month, day, hour, minute, second;
|
|
sscanf_s(decryptBuf, "%d-%d-%d %d:%d:%d", &year, &month, &day, &hour, &minute, &second);
|
|
if (year >= DC_OfficialVersion_YEAR)
|
|
{
|
|
return DC_OfficialVersion_YEAR;
|
|
}
|
|
|
|
authTime = StringToDatetime(decryptBuf);
|
|
if (authTime > 0)
|
|
{
|
|
return 0;
|
|
}
|
|
//if (1 == sscanf_s(decryptBuf, "%lu-T", &authTime))
|
|
//{
|
|
// return 0;
|
|
//}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
#endif //WIN32
|
|
|
|
Authority* Authority::m_instance = nullptr;
|
|
|
|
Authority* Authority::GetInstance()
|
|
{
|
|
if (m_instance == nullptr)
|
|
{
|
|
m_instance = new Authority;
|
|
}
|
|
return m_instance;
|
|
}
|
|
|
|
bool Authority::EnumFilesForConfigs(AuthorizeConfigs & configs)
|
|
{
|
|
std::string configPath = GetCurrDir() + std::string("/config");
|
|
std::vector<std::string> suffixFilters;
|
|
std::string filterJson(".json"), filterKey(".Key");
|
|
suffixFilters.push_back(filterJson);
|
|
suffixFilters.push_back(filterKey);
|
|
|
|
std::vector<std::string> fileList;
|
|
}
|
|
|
|
bool Authority::CheckAuthority()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
long Authority::EncryptString(char * strSrc, char * strEncrypted)//Parameters max lenth is 64 bytes
|
|
{
|
|
if (strSrc == NULL || strEncrypted == NULL)
|
|
{
|
|
return -2;
|
|
}
|
|
|
|
int ires = -1;//Default error
|
|
AES_KEY aes_key;
|
|
|
|
if (AES_set_encrypt_key((const unsigned char *)DC_AES_CRYPTCODE, DC_AES_LEN_IN_BITS, &aes_key) == 0)//set encrpt key (32 bytes)
|
|
{
|
|
//int len = strnlen_s(strSrc, 64);
|
|
//int count = len / 16 + (len % 16 == 0 ? 0 : 1);
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
AES_encrypt((const unsigned char *)(strSrc + i * 16), (unsigned char *)(strEncrypted + i * 16), &aes_key);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
return ires;
|
|
}
|
|
|
|
long Authority::DecryptString(char * strSrc, char * strDecrypted)//Parameters max lenth is 64 bytes
|
|
{
|
|
if (strSrc == NULL || strDecrypted == NULL)
|
|
{
|
|
return -2;
|
|
}
|
|
|
|
int ires = -1;//Default error
|
|
AES_KEY aes_key;
|
|
|
|
if (AES_set_decrypt_key((const unsigned char *)DC_AES_CRYPTCODE, DC_AES_LEN_IN_BITS, &aes_key) == 0)//set encrpt key (32 bytes)
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
AES_decrypt((const unsigned char *)(strSrc + i * 16), (unsigned char *)(strDecrypted + i * 16), &aes_key);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
return ires;
|
|
}
|
|
|
|
std::string Authority::GetCurrDir()
|
|
{
|
|
return fs::current_path().generic_u8string();
|
|
}
|
|
|
|
bool Authority::FindAllFilesInPath(std::string strPath, std::vector<std::string> & fileList, std::vector<std::string> & suffixFilters)
|
|
{
|
|
fs::path str(strPath);
|
|
if (!exists(str)) //必须先检测目录是否存在才能使用文件入口.
|
|
return false;
|
|
fs::directory_entry entry(str); //文件入口
|
|
if (entry.status().type() == fs::file_type::directory)
|
|
{
|
|
fs::directory_iterator list(str); //文件入口容器
|
|
for (auto& it : list)
|
|
{
|
|
//std::cout << it.path().filename() << " <==> " << it.path().stem() << std::endl;
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
} |