void ImageOverlayRegionFinder::findRegions(bool optimizeForPowersOf2)
{
m_regions.clear();
if (!m_overlay.isValid())
{
return;
}
int rows = m_overlay.getRows();
int columns = m_overlay.getColumns();
unsigned char *data = m_overlay.getData();
// Màscara que indica els píxels visitats
QBitArray mask(rows * columns);
for (int row = 0, i = 0; row < rows; row++)
{
for (int column = 0; column < columns; column++, i++)
{
// Si trobem un objecte no tractat
if (data[i] > 0 && !mask.testBit(i))
{
QRect region = growRegion(row, column, mask);
addPadding(region);
addRegion(region, optimizeForPowersOf2);
removePadding(region);
fillMaskForRegion(mask, region);
}
}
}
}
/**
* Decrypt Decrypts data based on cipher text, cipher key and IV
* @param b_input Cipher text
* @param p_key Cipher key
* @param p_iv Initialization vector
* @return Decrypted data
*/
QByteArray AES::decrypt(QByteArray b_input, QByteArray p_key, QByteArray p_iv)
{
if (b_input.isEmpty()) {
qDebug() << "Error while decryption: Cannot decrypt empty input";
return QByteArray();
}
QByteArray result;
int keySize = p_key.size();
int ivSize = p_iv.size();
if (keySize != 16 && keySize != 24 && keySize != 32) {
qDebug() << "Error while decryption: Invalid keysize";
return QByteArray();
}
if (ivSize != 16) {
qDebug() << "Error while decryption: Invalid keysize";
return QByteArray();
}
// 500KB blocks
qint64 chunksCount = (b_input.size()/500000) + 1;
for (int part = 0; part < chunksCount; part++) {
// Out of range checks
if (part*500000 > b_input.size()) {
qDebug() << "Error while decryption: Skipped: Buffer overflow";
continue;
}
QByteArray p_chunk = b_input.mid(part*500000, 500000);
int inputSize = p_chunk.size();
unsigned char key[keySize];
qByteArrayToUCharArray(p_key, key);
unsigned char iv[ivSize];
qByteArrayToUCharArray(p_iv, iv);
unsigned char encrypted[inputSize];
qByteArrayToUCharArray(p_chunk, encrypted);
unsigned char decrypted[inputSize]; // Decrypted text
aes_context context;
aes_set_key(key, keySize * 8, &context);
aes_cbc_decrypt(encrypted, decrypted, inputSize, iv, &context);
QByteArray temp_result = uCharArrayToQByteArray(decrypted, inputSize);
result.append( temp_result);
}
removePadding(&result);
return result;
}
QString WPUtils::decrypt(QString d) {
QByteArray in;
if (!fromHex(d, in)) {
//toast
qDebug() << "Cipher text is not valid hex";
return false;
}
QByteArray out(in.length(), 0);
if (crypt(false, in, out)) {
if (removePadding(out)) {
QString toUse(QString::fromUtf8(out.constData(), out.length()));
return toUse;
//return true;
}
}
return "";//false;
}
/* TODO: handle multiple blocks
* test-read END record; if present, store offset, else unbounded (current active block)
* when decrypting, check if bound is reached. If yes, split into two blocks, get new IV for
* second one.
*/
rsRetVal
rsgcryDecrypt(gcryfile pF, uchar *buf, size_t *len)
{
gcry_error_t gcryError;
DEFiRet;
if(pF->bytesToBlkEnd != -1)
pF->bytesToBlkEnd -= *len;
gcryError = gcry_cipher_decrypt(pF->chd, buf, *len, NULL, 0);
if(gcryError) {
DBGPRINTF("gcry_cipher_decrypt failed: %s/%s\n",
gcry_strsource(gcryError),
gcry_strerror(gcryError));
ABORT_FINALIZE(RS_RET_ERR);
}
removePadding(buf, len);
// TODO: remove dbgprintf once things are sufficently stable -- rgerhards, 2013-05-16
dbgprintf("libgcry: decrypted, bytesToBlkEnd %lld, buffer is now '%50.50s'\n", (long long) pF->bytesToBlkEnd, buf);
finalize_it:
RETiRet;
}
static void
decryptBlock(FILE *fpin, FILE *fpout, off64_t blkEnd, off64_t *pCurrOffs)
{
gcry_error_t gcryError;
size_t nRead, nWritten;
size_t toRead;
size_t leftTillBlkEnd;
char buf[64*1024];
leftTillBlkEnd = blkEnd - *pCurrOffs;
while(1) {
toRead = sizeof(buf) <= leftTillBlkEnd ? sizeof(buf) : leftTillBlkEnd;
toRead = toRead - toRead % blkLength;
nRead = fread(buf, 1, toRead, fpin);
if(nRead == 0)
break;
leftTillBlkEnd -= nRead, *pCurrOffs += nRead;
gcryError = gcry_cipher_decrypt(
gcry_chd, // gcry_cipher_hd_t
buf, // void *
nRead, // size_t
NULL, // const void *
0); // size_t
if (gcryError) {
fprintf(stderr, "gcry_cipher_decrypt failed: %s/%s\n",
gcry_strsource(gcryError),
gcry_strerror(gcryError));
return;
}
removePadding(buf, &nRead);
nWritten = fwrite(buf, 1, nRead, fpout);
if(nWritten != nRead) {
perror("fpout");
return;
}
}
}
void AtlasPresentationBridge::mapEnd()
{
removePadding();
}
void AtlasPresentationBridge::streamEnd()
{
removePadding();
}
void AtlasPresentationBridge::listEnd()
{
mMapsInList.pop();
removePadding();
}
int main(int argc, char* argv[])
{
if(argc!=4)
{
printf("Invalid number of arguments.\n");
return 1;
}
if(strlen(argv[1])!=32)
{
printf("Invalid key length.\n");
return 1;
}
char key0str[17], key1str[17];
strncpy(key0str, argv[1], 16);
strncpy(key1str, argv[1]+16, 16);
key0str[16]='\0'; key1str[16]='\0';
uint64_t key0 = toLL(key0str);
if(errno!=0){
printf("Invalid key format.\n");
return 5;
}
uint64_t key1 = toLL(key1str);
if(errno!=0){
printf("Invalid key format.\n");
return 5;
}
//printf("Encrypting %016llx, Key %016llx%016llx\n", plaintext, key0, key1);
FILE *inp, *outp;
inp = fopen(argv[2], "rb");
if(inp==NULL){
printf("Cannot open file for reading.\n");
return 1;
}
outp = fopen(argv[3], "wb");
//open files
uint64_t input;
int count =0, removed=0;
uint64_t output;
int flag =1;
uint8_t inputbytes[8], pastBytes[8];
while(!feof(inp))
{
count += fread(&inputbytes,1,8,inp);
if(count==0)
{
removed=removePadding(pastBytes);
fwrite(pastBytes, 1, 8-removed, outp);
break;
}
if(count<8)
{
printf("File size is not a multiple of 8: %d", count);
fclose(inp);
fclose(outp);
return 7;
}
input = join(inputbytes);
output = decrypt(input, key0, key1);
split(inputbytes, output);
if(!flag) //write the previous 8 bytes if not the first
fwrite(pastBytes, 1, 8, outp);
memcpy(pastBytes, inputbytes, 8);
flag=0;
count=0;
}
fclose(inp);
fclose(outp);
return 0;
}
