uint8_t* BlockPoolBase::resizeLastBlock( size_t newSize )
{
const auto alignedNewSize = getAlignedSize( newSize, alignment_ );
const auto currentBlockSize = lastBlockSize();
LOG(logDEBUG2) << "Resizing block "
<< " from " << currentBlockSize
<< " to " << newSize
<< " aligned " << alignedNewSize
<< " alloc " << allocationSize_;
if ( alignedNewSize <= currentBlockSize ) {
allocationSize_ -= ( currentBlockSize - alignedNewSize );
}
else {
const auto delta = alignedNewSize - currentBlockSize;
LOG(logDEBUG2) << "Increasing last block size by " << delta;
if ( allocationSize_ + delta >= pool_.size() ) {
increasePool( pool_ );
}
allocationSize_ += delta;
}
LOG(logDEBUG2) << "Resized block, alloc " << allocationSize_;
return pool_.data() + blockIndex_.back();
}
QString encodeText(const QString &rawText, const QString &key) {
QCryptographicHash hash(QCryptographicHash::Md5);
hash.addData(key.toUtf8());
QByteArray keyData = hash.result();
const ushort *rawData = rawText.utf16();
void *rawDataVoid = (void*)rawData;
const char *rawDataChar = static_cast<char*>(rawDataVoid);
QByteArray inputData;
// ushort is 2*uint8_t + 1 byte for '\0'
inputData.append(rawDataChar, rawText.size() * 2 + 1);
const int length = inputData.size();
int encryptionLength = getAlignedSize(length, 16);
QByteArray encodingBuffer(encryptionLength, 0);
inputData.resize(encryptionLength);
AES128_CBC_encrypt_buffer((uint8_t*)encodingBuffer.data(), (uint8_t*)inputData.data(),
encryptionLength, (const uint8_t*)keyData.data(), iv);
QByteArray data(encodingBuffer.data(), encryptionLength);
QString hex = QString::fromLatin1(data.toHex());
return hex;
}
BOOL loadPE(char *exePtr, MZHeader *inMZ, PE_Header *inPE, PE_ExtHeader *inpeXH,
SectionHeader *inSecHdr, LPVOID ptrLoc)
{
char *outPtr = (char *)ptrLoc;
memcpy(outPtr, exePtr, inpeXH->sizeOfHeaders);
outPtr += getAlignedSize(inpeXH->sizeOfHeaders, inpeXH->sectionAlignment);
for(int i = 0; i < inPE->numSections; i++)
{
if(inSecHdr[i].sizeOfRawData > 0)
{
unsigned long toRead = inSecHdr[i].sizeOfRawData;
if(toRead > inSecHdr[i].virtualSize)
toRead = inSecHdr[i].virtualSize;
memcpy(outPtr, exePtr + inSecHdr[i].pointerToRawData, toRead);
outPtr += getAlignedSize(inSecHdr[i].virtualSize, inpeXH->sectionAlignment);
}
}
return true;
}
uint8_t* BlockPoolBase::getBlock( size_t elementsCount )
{
const auto requiredSize = getBlockStorageSize( elementsCount, elementSize_, alignment_ );
const auto alignedAllocationSize = getAlignedSize(allocationSize_, alignment_);
LOG(logDEBUG2) << "Get block " << elementSize_
<< " pool " << pool_.size()
<< " alloc " << allocationSize_
<< " blocks " << blockIndex_.size();
if ( alignedAllocationSize + requiredSize >= pool_.size() ) {
increasePool( pool_ );
}
blockIndex_.push_back( alignedAllocationSize );
allocationSize_ = alignedAllocationSize + requiredSize;
return pool_.data() + blockIndex_.back();
}
QString decodeText(const QString &hexEncodedText, const QString &key)
{
QCryptographicHash hash(QCryptographicHash::Md5);
hash.addData(key.toUtf8());
QByteArray keyData = hash.result();
const int length = hexEncodedText.size();
int encryptionLength = getAlignedSize(length, 16);
QByteArray encodingBuffer(encryptionLength, 0);
QByteArray encodedText = QByteArray::fromHex(hexEncodedText.toLatin1());
encodedText.resize(encryptionLength);
AES128_CBC_decrypt_buffer((uint8_t*)encodingBuffer.data(), (uint8_t*)encodedText.data(),
encryptionLength, (const uint8_t*)keyData.data(), iv);
void *data = encodingBuffer.data();
const ushort *decodedData = static_cast<ushort*>(data);
QString result = QString::fromUtf16(decodedData);
return result;
}