static void crypt_all(int count)
{
int index = 0;
#ifdef _OPENMP
#pragma omp parallel for
for (index = 0; index < count; index++)
#endif
{
unsigned char master[32];
unsigned char output[1024];
unsigned char *iv_in;
unsigned char iv_out[16];
int size;
int page_sz = 1008; /* 1024 - strlen(SQLITE_FILE_HEADER) */
int reserve_sz = 16; /* for HMAC off case */
AES_KEY akey;
pbkdf2((unsigned char *)saved_key[index], strlen(saved_key[index]), cur_salt->salt, 16, ITERATIONS, (uint32_t *)master);
memcpy(output, SQLITE_FILE_HEADER, FILE_HEADER_SZ);
size = page_sz - reserve_sz;
iv_in = cur_salt->data + size + 16;
memcpy(iv_out, iv_in, 16);
if (AES_set_decrypt_key(master, 256, &akey) < 0) {
fprintf(stderr, "AES_set_derypt_key failed!\n");
}
/* decrypting 24 bytes is enough */
AES_cbc_encrypt(cur_salt->data + 16, output + 16, 24, &akey, iv_out, AES_DECRYPT);
if (verify_page(output) == 0) {
cracked[index] = 1;
}
else
cracked[index] = 0;
}
}
int pdfsign_main(int argc, char **argv)
{
fz_context *ctx;
pdf_document *doc;
char *password = "";
int i, n, c;
pdf_page *page = NULL;
while ((c = fz_getopt(argc, argv, "p:")) != -1)
{
switch (c)
{
case 'p': password = fz_optarg; break;
default: usage(); break;
}
}
if (argc - fz_optind < 1)
usage();
filename = argv[fz_optind++];
ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (!ctx)
{
fprintf(stderr, "cannot initialize context\n");
exit(1);
}
fz_var(page);
doc = pdf_open_document(ctx, filename);
fz_try(ctx)
{
if (pdf_needs_password(ctx, doc))
if (!pdf_authenticate_password(ctx, doc, password))
fz_warn(ctx, "cannot authenticate password: %s", filename);
n = pdf_count_pages(ctx, doc);
for (i = 0; i < n; ++i)
{
page = pdf_load_page(ctx, doc, i);
verify_page(ctx, doc, i, page);
fz_drop_page(ctx, (fz_page*)page);
page = NULL;
}
}
fz_always(ctx)
pdf_drop_document(ctx, doc);
fz_catch(ctx)
{
fz_drop_page(ctx, (fz_page*)page);
fprintf(stderr, "error verify signatures: %s\n", fz_caught_message(ctx));
}
fz_flush_warnings(ctx);
fz_drop_context(ctx);
return 0;
}
static int crypt_all(int *pcount, struct db_salt *salt)
{
const int count = *pcount;
int index = 0;
#ifdef _OPENMP
#pragma omp parallel for
for (index = 0; index < count; index += MAX_KEYS_PER_CRYPT)
#endif
{
unsigned char master[MAX_KEYS_PER_CRYPT][32];
unsigned char output[1024];
unsigned char *iv_in;
unsigned char iv_out[16];
int size,i;
int page_sz = 1008; /* 1024 - strlen(SQLITE_FILE_HEADER) */
int reserve_sz = 16; /* for HMAC off case */
AES_KEY akey;
#ifdef SIMD_COEF_32
int len[MAX_KEYS_PER_CRYPT];
unsigned char *pin[MAX_KEYS_PER_CRYPT], *pout[MAX_KEYS_PER_CRYPT];
for (i = 0; i < MAX_KEYS_PER_CRYPT; ++i) {
len[i] = strlen(saved_key[i+index]);
pin[i] = (unsigned char*)saved_key[i+index];
pout[i] = master[i];
}
pbkdf2_sha1_sse((const unsigned char **)pin, len, cur_salt->salt, 16, ITERATIONS, pout, 32, 0);
#else
pbkdf2_sha1((unsigned char *)saved_key[index],
strlen(saved_key[index]), cur_salt->salt,
16, ITERATIONS, master[0], 32, 0);
#if !ARCH_LITTLE_ENDIAN
for (i = 0; i < 32/sizeof(ARCH_WORD_32); ++i) {
((ARCH_WORD_32*)master[0])[i] = JOHNSWAP(((ARCH_WORD_32*)master[0])[i]);
}
#endif
#endif
for (i = 0; i < MAX_KEYS_PER_CRYPT; ++i) {
memcpy(output, SQLITE_FILE_HEADER, FILE_HEADER_SZ);
size = page_sz - reserve_sz;
iv_in = cur_salt->data + size + 16;
memcpy(iv_out, iv_in, 16);
if (AES_set_decrypt_key(master[i], 256, &akey) < 0) {
fprintf(stderr, "AES_set_decrypt_key failed!\n");
}
/* decrypting 24 bytes is enough */
AES_cbc_encrypt(cur_salt->data + 16, output + 16, 24, &akey, iv_out, AES_DECRYPT);
if (verify_page(output) == 0) {
cracked[index+i] = 1;
}
else
cracked[index+i] = 0;
}
}
return count;
}
int
verify_segmentfile(const char *filepath)
{
int fd;
char page[BLCKSZ];
BlockNumber blkno = 0;
BlockNumber corrupted = 0;
fd = open(filepath, O_RDONLY);
if (fd <= 0)
{
fprintf(stderr, "%s: %s\n", strerror(errno), filepath);
exit(2);
}
while (read(fd, page, BLCKSZ) == BLCKSZ)
{
if (!verify_page(page, blkno, filepath))
{
corrupted++;
}
blkno++;
}
close(fd);
if (corrupted > 0)
{
printf("%d blocks corrupted in %s.\n", corrupted, filepath);
return FALSE;
}
if (verbose)
printf("Verified %d blocks in %s.\n", blkno, filepath);
return TRUE;
}
BOOL flash_module(WORD page, WORD numpages, char *fn, char *name, BYTE flags)
{
int i;
static WORD bytes_read;
static WORD b, last_b = 0;
static long addr;
static WORD pages;
pages = numpages;
if(flags & 0x01) {
prog_fres = f_open(&prog_file, fn, FA_READ);
if(prog_fres == FR_OK) {
printf("Flashing %s...", name);
i = page;
do {
MAPPER_MAP1 = 0;
FillPage(0xff, 0);
prog_fres = f_read(&prog_file, (void *)0x4000, 8192, &bytes_read);
addr = (((long)(i & 0x7FF)) << 13);
b = flash_addr2block(addr);
if(b != last_b) {
if(!(flags & 0x04)) {
flash_erase_block(b);
}
last_b = b;
}
flash_page(0, i);
i++;
pages--;
} while((bytes_read == 8192)&&(pages));
f_close(&prog_file);
printf(" OK!\n");
} else {
printf("\nCouldn't open %s:\n-> Not flashed!\n", fn);
return FALSE;
}
}
pages = numpages;
if(flags & 0x02) {
prog_fres = f_open(&prog_file, fn, FA_READ);
if(prog_fres == FR_OK) {
printf("Verifying %s...", name);
i = page;
do {
MAPPER_MAP1 = 0;
FillPage(0xff, 0);
prog_fres = f_read(&prog_file, (void *)0x4000, 8192, &bytes_read);
// if(bytes_read != 0x2000) {
// printf("Can't read 8192 bytes from file, but %d (error %d)\n", bytes_read, prog_fres);
// }
if(b=verify_page(0, i)) { // return 0 on good, address when wrong
printf(" ERROR!\n",b);
dump_hex((void*)(b&0xFFF0), 16);
b ^= 0x2000;
dump_hex((void*)(b&0xFFF0), 16);
return FALSE;
}
i++;
pages--;
} while((bytes_read == 8192)&&(pages));
f_close(&prog_file);
printf(" OK!\n");
} else {
printf("\nCouldn't open %s:\n-> Not verified!\n", fn);
return FALSE;
}
}
return TRUE;
}
static int crypt_all(int *pcount, struct db_salt *salt)
{
const int count = *pcount;
int index;
size_t *lws = local_work_size ? &local_work_size : NULL;
global_work_size = local_work_size ? (count + local_work_size - 1) / local_work_size * local_work_size : count;
if (any_cracked) {
memset(cracked, 0, cracked_size);
any_cracked = 0;
}
/// Copy data to gpu
HANDLE_CLERROR(clEnqueueWriteBuffer(queue[gpu_id], mem_in, CL_FALSE, 0,
insize, inbuffer, 0, NULL, multi_profilingEvent[0]),
"Copy data to gpu");
/// Run kernel
HANDLE_CLERROR(clEnqueueNDRangeKernel(queue[gpu_id], crypt_kernel, 1,
NULL, &global_work_size, lws, 0, NULL,
multi_profilingEvent[1]), "Run kernel");
/// Read the result back
HANDLE_CLERROR(clEnqueueReadBuffer(queue[gpu_id], mem_out, CL_TRUE, 0,
outsize, outbuffer, 0, NULL, multi_profilingEvent[2]), "Copy result back");
#ifdef _OPENMP
#pragma omp parallel for
#endif
for (index = 0; index < count; index++)
{
unsigned char master[32];
unsigned char output[1024];
unsigned char *iv_in;
unsigned char iv_out[16];
int size;
int page_sz = 1008; /* 1024 - strlen(SQLITE_FILE_HEADER) */
int reserve_sz = 16; /* for HMAC off case */
AES_KEY akey;
memcpy(master, outbuffer[index].v, 32);
memcpy(output, SQLITE_FILE_HEADER, FILE_HEADER_SZ);
size = page_sz - reserve_sz;
iv_in = cur_salt->data + size + 16;
memcpy(iv_out, iv_in, 16);
if (AES_set_decrypt_key(master, 256, &akey) < 0) {
fprintf(stderr, "AES_set_decrypt_key failed!\n");
}
/* decrypting 24 bytes is enough */
AES_cbc_encrypt(cur_salt->data + 16, output + 16, 24, &akey, iv_out, AES_DECRYPT);
if (verify_page(output) == 0)
{
cracked[index] = 1;
#ifdef _OPENMP
#pragma omp atomic
#endif
any_cracked |= 1;
}
}
return count;
}
