int DrawScreenBitmap1(HDC hdc_screen_save, HDC hdc_screen, HDC hdc_screen_memory, int *arr, int arr_count, int split_width, int width, int height, double accelerate, HBRUSH hbr_background)
{
static RECT rect;
int i, count = 0;
for (i = 0; i < arr_count; i++)
{
if (arr[i] > 0)
{
int old_offset = RoundToInt(CalcOffset(arr[i] - 1, accelerate));
int new_offset = RoundToInt(CalcOffset(arr[i], accelerate));
if (new_offset > height)
{
new_offset = height;
count++;
}
if (new_offset > old_offset)
{
rect.left = i * split_width;
rect.top = old_offset;
rect.right = rect.left + split_width;
rect.bottom = new_offset;
FillRect(hdc_screen_memory, &rect, hbr_background);
BitBlt(hdc_screen_memory, rect.left, new_offset, split_width, height - new_offset, hdc_screen_save, rect.left, 0, SRCCOPY);
}
}
}
BitBlt(hdc_screen, 0, 0, width, height, hdc_screen_memory, 0, 0, SRCCOPY);
return count;
}
int DrawScreenBitmap2(HDC hdc_screen_save, HDC hdc_screen, HDC hdc_screen_memory, int *arr, int arr_count, int split_width, int width, int height, double accelerate, HBRUSH hbr_background)
{
int i, count = 0;
UNREFERENCED_PARAMETER(hbr_background);
for (i = 0; i < arr_count; i++)
{
if (arr[i] > 0)
{
int old_offset = RoundToInt(CalcOffset(arr[i] - 1, accelerate));
int new_offset = RoundToInt(CalcOffset(arr[i], accelerate));
if (new_offset > height)
{
new_offset = height;
count++;
}
if (new_offset > old_offset)
{
BitBlt(hdc_screen_memory, i * split_width, 0, split_width, new_offset, hdc_screen_save, i * split_width, height - new_offset, SRCCOPY);
}
}
}
BitBlt(hdc_screen, 0, 0, width, height, hdc_screen_memory, 0, 0, SRCCOPY);
return count;
}
void BlockManager::WritePartialBlockData( offset_type blockid, const void* buffer, offset_type offset, offset_type length )
{
FileAutoLock lock(m_pLock);
m_pFile->Seek(CalcOffset(blockid) + offset, IFile::S_Begin);
offset_type result = m_pFile->Write(buffer, length);
assert(result == length);
}
void BlockManager::ReadEmptyBlockHeader( offset_type blockid, offset_type &header )
{
//FileAutoLock lock(m_pLock);
assert(blockid < m_Header.Blocks && "out of range");
m_pFile->Seek(CalcOffset(blockid), IFile::S_Begin);
m_pFile->Read(&header, offset_type(sizeof(header)));
}
void BlockManager::WriteEmptyBlockHeader( offset_type blockid, offset_type header )
{
assert(header<blockid&&"Wrong Empty Block header");
assert(blockid < m_Header.Blocks && "out of range");
m_pFile->Seek(CalcOffset(blockid), IFile::S_Begin);
m_pFile->Write(&header, offset_type(sizeof(header)));
}
bool CUserCryptoManager::CheckPassword(const wchar_t *pszPassword)
{
CommonLib::CString sPWD = pszPassword;
std::vector<byte> vecUtf8PWD;
uint32 nUtf8Len = sPWD.calcUTF8Length();
vecUtf8PWD.resize(nUtf8Len + 1);
sPWD.exportToUTF8((char*)&vecUtf8PWD[0], nUtf8Len);
IDBStoragePtr pDBStorage = m_pDB->getDBStorage();
m_pCheckPageChiper->SetKey(&vecUtf8PWD[0], nUtf8Len, m_szSalt, m_szSaltIV, ___nSALT_SIZE);
byte buf[MIN_PAGE_SIZE];
bool bRet = pDBStorage->ReadRowData(buf, MIN_PAGE_SIZE, m_nPWDPage * MIN_PAGE_SIZE);
if(!bRet)
return false;
CFilePage pwdPage(buf, MIN_PAGE_SIZE, m_nPWDPage);
m_pCheckPageChiper->decrypt(&pwdPage);
CommonLib::FxMemoryReadStream stream;
stream.attachBuffer(pwdPage.getRowData(), pwdPage.getPageSize());
sFilePageHeader header(stream, pwdPage.getPageSize(), true, false);
if(!header.isValid())
return false;
uint32 nOffset = CalcOffset(&vecUtf8PWD[0], nUtf8Len, m_szSalt, ___nSALT_SIZE);
if(m_bPWDCheck)
{
if(nOffset != m_nOffset)
return false;
return true;
}
else
{
if(nOffset > pDBStorage->getFileSize())
return false;
m_nOffset = nOffset;
m_PageChiper->SetKey(&vecUtf8PWD[0], nUtf8Len, m_szSalt, m_szSaltIV, ___nSALT_SIZE);
((CStorage*)pDBStorage.get())->setPageChiper(m_PageChiper.get());
pDBStorage->SetOffset(m_nOffset);
m_bPWDCheck = true;
}
return true;
}
offset_type BlockManager::AllocNewBlock()
{
CheckHeader();
assert(m_Header.Unused.offset < 0);
offset_type blockid = m_Header.Blocks;
++m_Header.Blocks.offset;
m_pFile->ReserveSpace(CalcOffset(m_Header.Blocks));
FlushHeader();
return blockid;
}
void LoaderCurrent::ParseTypes()
{
Classificator & c = classif();
ArrayByteSource source(DataPtr() + m_TypesOffset);
size_t const count = m_pF->GetTypesCount();
for (size_t i = 0; i < count; ++i)
m_pF->m_types[i] = c.GetTypeForIndex(ReadVarUint<uint32_t>(source));
m_CommonOffset = CalcOffset(source);
}
void LoaderCurrent::ParseCommon()
{
ArrayByteSource source(DataPtr() + m_CommonOffset);
uint8_t const h = Header();
m_pF->m_params.Read(source, h);
if (m_pF->GetFeatureType() == GEOM_POINT)
{
m_pF->m_center = serial::LoadPoint(source, GetDefCodingParams());
m_pF->m_limitRect.Add(m_pF->m_center);
}
m_Header2Offset = CalcOffset(source);
}
bool CUserCryptoManager::InitPasswordMode(CFilePage *pPage, const wchar_t *pszPassword)
{
IDBStoragePtr pDBStorage = m_pDB->getDBStorage();
CRandomGenerator::GetRandomValues(m_szSalt, ___nSALT_SIZE);
CRandomGenerator::GetRandomValues(m_szSaltIV, ___nSALT_SIZE);
CommonLib::CString sPWD = pszPassword;
std::vector<byte> vecUtf8PWD;
uint32 nUtf8Len = sPWD.calcUTF8Length();
vecUtf8PWD.resize(nUtf8Len + 1);
sPWD.exportToUTF8((char*)&vecUtf8PWD[0], nUtf8Len);
m_nOffset = CalcOffset(&vecUtf8PWD[0], nUtf8Len, m_szSalt, ___nSALT_SIZE);
m_PageChiper.reset( new CPageCipher( m_qryptoAlg));
m_pCheckPageChiper.reset(new CPageCipher(m_qryptoAlg));
m_PageChiper->SetKey(&vecUtf8PWD[0], nUtf8Len, m_szSalt, m_szSaltIV, ___nSALT_SIZE);
((CStorage*)pDBStorage.get())->setPageChiper(m_PageChiper.get());
m_nPWDPage = CreateCheckPWDPage();
CreateNoise(m_nOffset);
CommonLib::FxMemoryWriteStream stream;
stream.attachBuffer(pPage->getRowData(), pPage->getPageSize());
sFilePageHeader header(stream, DATABASE_PAGE, DB_ROOT_USER_PAGE, pPage->getPageSize(),true);
stream.write((uint16)m_UserMode);
stream.write((uint16)m_qryptoAlg);
stream.write(m_szSalt, ___nSALT_SIZE);
stream.write(m_szSaltIV, ___nSALT_SIZE);
stream.write(m_nPWDPage);
header.writeCRC32(stream);
pPage->setNeedEncrypt(false);
pDBStorage->saveFilePage(pPage);
pDBStorage->SetOffset(m_nOffset);
m_bPWDCheck = true;
return true;
}
void BlockManager::RecycleBlock( offset_type blockid )
{
FileAutoLock lock(m_pLock);
assert(blockid.offset >=0 && blockid < m_Header.Blocks && "Recycle out of range");
assert(blockid != m_Header.Unused && "Recycle again?");
if(blockid.offset == m_Header.Blocks.offset -1)//shrink file size
{
--m_Header.Blocks.offset;
while (m_Header.Unused.offset == m_Header.Blocks.offset -1 && m_Header.Unused.offset >= 0)
{
offset_type header(-1);
ReadEmptyBlockHeader(m_Header.Unused, header);
m_Header.Unused = header;
--m_Header.Blocks.offset;
assert(m_Header.Blocks.offset >=0);
assert(m_Header.Unused < m_Header.Blocks);
}
m_pFile->ReserveSpace(CalcOffset(m_Header.Blocks));
FlushHeader();
}
else
{
if(blockid > m_Header.Unused)
{
offset_type header = m_Header.Unused;
WriteEmptyBlockHeader(blockid, header);
m_Header.Unused = blockid;
FlushHeader();
}
else
{
offset_type unused = m_Header.Unused;
offset_type found(0);
offset_type header(-1);
while (blockid < unused)
{
ReadEmptyBlockHeader(unused, header);
found = unused;
unused = header;
}
WriteEmptyBlockHeader(found, blockid);
WriteEmptyBlockHeader(blockid, unused);
}
}
}
int64 CDatabase::InitCrypto(byte* pPWD, uint32 nLen)
{
CRandomGenerator::GetRandomValues(m_dbHeader.szSalt, sDBHeader::SALT_SIZE);
CRandomGenerator::GetRandomValues(m_dbHeader.szSaltIV, sDBHeader::SALT_SIZE);
int64 nOffset = CalcOffset(pPWD, nLen, m_dbHeader.szSalt, sDBHeader::SALT_SIZE);
m_PageChiper.reset( new CPageCipher(m_DBParams.qryptoAlg));
m_PageChiper->SetKey(pPWD, nLen, m_dbHeader.szSalt, m_dbHeader.szSaltIV, sDBHeader::SALT_SIZE);
((CStorage*)m_pStorage.get())->setPageChiper(m_PageChiper.get());
CreateCheckPWDPage();
CreateNoise(nOffset);
return nOffset;
}
bool get_image_feature(
const wchar_t * file_path,
char *rs_md5)
{
unsigned short Num = 0;
CPeFile pe;
auto st_size = get_file_data(file_path, nullptr);
if (!st_size) {
return false;
}
auto file_data = new char[st_size];
if (!get_file_data(file_path, file_data)) {
return false;
}
auto if_openfile_success = pe.Attach(file_path);
if (if_openfile_success == 0UL ||
if_openfile_success == 1UL ||
if_openfile_success == 2UL) {
return false;
}
auto p_nt_header = const_cast<PIMAGE_NT_HEADERS32>(pe.GetNtHeader());
auto p_data_directory = &pe.GetDataDirectory()[IMAGE_DIRECTORY_ENTRY_RESOURCE];
if (p_data_directory->Size == 0 || p_data_directory->VirtualAddress == 0) {
return false;
}
auto p_reg_directory = reinterpret_cast<PIMAGE_RESOURCE_DIRECTORY>(const_cast<char*>(file_data) + CalcOffset(p_data_directory->VirtualAddress, p_nt_header));
auto re_size = p_reg_directory->NumberOfIdEntries + p_reg_directory->NumberOfNamedEntries;
auto p_reg_directory_entry = reinterpret_cast<PIMAGE_RESOURCE_DIRECTORY_ENTRY>((long)p_reg_directory + sizeof(IMAGE_RESOURCE_DIRECTORY));
for (DWORD FirstOrder = 0; FirstOrder < re_size; FirstOrder++) {
if (p_reg_directory_entry->Name != 0x03) {
p_reg_directory_entry++;
continue;
}
auto p_reg_directory2 = (PIMAGE_RESOURCE_DIRECTORY)((long)p_reg_directory + p_reg_directory_entry->OffsetToDirectory);
auto re_size2 = p_reg_directory2->NumberOfIdEntries + p_reg_directory2->NumberOfNamedEntries;
auto p_reg_directory_entry2 = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((long)p_reg_directory2 + sizeof(IMAGE_RESOURCE_DIRECTORY));
for (unsigned int second_order = 0; second_order < re_size2; second_order++) {
if (p_reg_directory_entry2->DataIsDirectory != 1) {
break;
}
//解析第三层
auto p_reg_directory3 = (PIMAGE_RESOURCE_DIRECTORY)((long)p_reg_directory + p_reg_directory_entry2->OffsetToDirectory);
auto p_reg_directory_entry3 = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((long)p_reg_directory3 + sizeof(IMAGE_RESOURCE_DIRECTORY));
auto reg_data = (PIMAGE_RESOURCE_DATA_ENTRY)((long)p_reg_directory + p_reg_directory_entry3->OffsetToData);
auto image_data = reinterpret_cast<const char*>(reinterpret_cast<unsigned long>(file_data) + CalcOffset(reg_data->OffsetToData, p_nt_header));
if (reg_data->Size > 0x50000) {
break;
}
string str_md5 = "";
MD5 md5; //定义MD5的类
if (!IsBadReadPtr(image_data, reg_data->Size)) {
md5.update(image_data, reg_data->Size);
str_md5 = md5.toString();
}
if (str_md5 != "" && rs_md5) {
strcpy(rs_md5, str_md5.c_str());
return true;
}
p_reg_directory_entry2++;
}
p_reg_directory_entry++;
}
return false;
}
bool search_image_md5(
const PHARDCODE hard_code,
const int hard_number,
CPeFile * lp_pe,
const char * file_data)
{
bool if_success = false;
auto p_nt_header = const_cast<PIMAGE_NT_HEADERS32>(lp_pe->GetNtHeader());
auto p_data_directory = &lp_pe->GetDataDirectory()[IMAGE_DIRECTORY_ENTRY_RESOURCE];
if (p_data_directory->Size == 0 || p_data_directory->VirtualAddress == 0){
return false;
}
auto p_reg_directory = reinterpret_cast<PIMAGE_RESOURCE_DIRECTORY>(const_cast<char*>(file_data) + CalcOffset(p_data_directory->VirtualAddress, p_nt_header));
auto re_size = p_reg_directory->NumberOfIdEntries + p_reg_directory->NumberOfNamedEntries;
auto p_reg_directory_entry = reinterpret_cast<PIMAGE_RESOURCE_DIRECTORY_ENTRY>((long)p_reg_directory + sizeof(IMAGE_RESOURCE_DIRECTORY));
char ResourceName[15][16] = { "鼠标指针","位图","图标","菜单","对话框",
"字符串列表","字体目录","字体","快捷键","非格式化资源",
"消息列表","鼠标指针组","图标组","版本信息" };
for (DWORD FirstOrder = 0; FirstOrder < re_size; FirstOrder++){
if (p_reg_directory_entry->Name != 0x03) {
p_reg_directory_entry++;
continue;
}
auto p_reg_directory2 = (PIMAGE_RESOURCE_DIRECTORY)((long)p_reg_directory + p_reg_directory_entry->OffsetToDirectory);
auto re_size2 = p_reg_directory2->NumberOfIdEntries + p_reg_directory2->NumberOfNamedEntries;
auto p_reg_directory_entry2 = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((long)p_reg_directory2 + sizeof(IMAGE_RESOURCE_DIRECTORY));
for (unsigned int second_order = 0; second_order < re_size2; second_order++) {
if (p_reg_directory_entry2->DataIsDirectory != 1) {
break;
}
auto p_reg_directory3 = (PIMAGE_RESOURCE_DIRECTORY)((long)p_reg_directory + p_reg_directory_entry2->OffsetToDirectory);
auto p_reg_directory_entry3 = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((long)p_reg_directory3 + sizeof(IMAGE_RESOURCE_DIRECTORY));
auto reg_data = (PIMAGE_RESOURCE_DATA_ENTRY)((long)p_reg_directory + p_reg_directory_entry3->OffsetToData);
auto image_data = reinterpret_cast<const char*>(reinterpret_cast<unsigned long>(file_data) + CalcOffset(reg_data->OffsetToData, p_nt_header));
if (reg_data->Size > 0x50000){
break;
}
string str_md5 = "";
MD5 md5; //定义MD5的类
if (!IsBadReadPtr(image_data, reg_data->Size)) {
md5.update(image_data, reg_data->Size);
str_md5 = md5.toString();
}
for (size_t i = 0; i < hard_number; i++) {
auto image_md5 = hard_code[i].image_md5;
if (image_md5 == nullptr || image_md5 == str_md5) {
hard_code[i].if_image_success = true;
}
}
//return true;
p_reg_directory_entry2++;
}
p_reg_directory_entry++;
}
return if_success;
}
void BlockManager::ZeroBlock( offset_type blockid )
{
m_pFile->Seek(CalcOffset(blockid), IFile::S_Begin);
std::vector<char>buffer((size_t)m_Header.BlockSize.offset);//performance penalties
m_pFile->Write(&buffer[0], m_Header.BlockSize);
}
