Skip to content

Commit

Permalink
Refactor crypto callback to have separate input/output pointers. Add …
Browse files Browse the repository at this point in the history 
…initial writing support.
  • Loading branch information
@michaelrsweet
michaelrsweet committed Oct 12, 2021
1 parent 0caea44 commit c24243a
Show file tree
Hide file tree
Showing 7 changed files with 151 additions and 28 deletions.
50 changes: 36 additions & 14 deletions pdfio-aes.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -170,23 +170,34 @@ _pdfioCryptoAESInit(
//
// '_pdfioCryptoAESDecrypt()' - Decrypt a block of bytes with AES.
//
// "inbuffer" and "outbuffer" can point to the same memory.
//

void
_pdfioCryptoAESDecrypt(
_pdfio_aes_t *ctx, // I - AES context
uint8_t *buffer, // I - Buffer
uint8_t *outbuffer, // I - Output buffer
const uint8_t *inbuffer, // I - Input buffer
size_t len) // I - Number of bytes to decrypt
{
uint8_t next_iv[16]; // Next IV value


if (inbuffer != outbuffer)
{
// Not the most efficient, but we can optimize later - the sample AES code
// manipulates the data directly in memory and doesn't support separate
// input and output buffers...
memcpy(outbuffer, inbuffer, len);
}

while (len > 15)
{
memcpy(next_iv, buffer, 16);
InvCipher((state_t *)buffer, ctx);
XorWithIv(buffer, ctx->iv);
memcpy(next_iv, outbuffer, 16);
InvCipher((state_t *)outbuffer, ctx);
XorWithIv(outbuffer, ctx->iv);
memcpy(ctx->iv, next_iv, 16);
buffer += 16;
outbuffer += 16;
len -= 16;
}

Expand All @@ -196,52 +207,63 @@ _pdfioCryptoAESDecrypt(
uint8_t temp[16]; // Temporary buffer

memset(temp, 16 - len, sizeof(temp));
memcpy(temp, buffer, len);
memcpy(temp, outbuffer, len);

memcpy(next_iv, temp, 16);
InvCipher((state_t *)temp, ctx);
XorWithIv(temp, ctx->iv);
memcpy(ctx->iv, next_iv, 16);

memcpy(buffer, temp, len);
memcpy(outbuffer, temp, len);
}
}


//
// '_pdfioCryptoAESEncrypt()' - Encrypt a block of bytes with AES.
//
// "inbuffer" and "outbuffer" can point to the same memory.
//

void
_pdfioCryptoAESEncrypt(
_pdfio_aes_t *ctx, // I - AES context
uint8_t *buffer, // I - Buffer
uint8_t *outbuffer, // I - Output buffer
const uint8_t *inbuffer, // I - Input buffer
size_t len) // I - Number of bytes to decrypt
{
uint8_t *iv = ctx->iv; // Current IV for CBC
uint8_t temp[16]; // Temporary buffer


if (inbuffer != outbuffer)
{
// Not the most efficient, but we can optimize later - the sample AES code
// manipulates the data directly in memory and doesn't support separate
// input and output buffers...
memcpy(outbuffer, inbuffer, len);
}

while (len > 15)
{
XorWithIv(buffer, iv);
Cipher((state_t*)buffer, ctx);
iv = buffer;
buffer += 16;
XorWithIv(outbuffer, iv);
Cipher((state_t*)outbuffer, ctx);
iv = outbuffer;
outbuffer += 16;
len -= 16;
}

if (len > 0)
{
// Pad the final buffer with (16 - len)...
memset(temp, 16 - len, sizeof(temp));
memcpy(temp, buffer, len);
memcpy(temp, outbuffer, len);

XorWithIv(temp, iv);
Cipher((state_t*)temp, ctx);
iv = temp;

memcpy(buffer, temp, len);
memcpy(outbuffer, temp, len);
}

/* store Iv in ctx for next call */
Expand Down
4 changes: 2 additions & 2 deletions pdfio-file.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1159,7 +1159,7 @@ pdfioFileSetPermissions(
encrypt_key[j] = (uint8_t)(digest[j] ^ i);

_pdfioCryptoRC4Init(&rc4, encrypt_key, sizeof(encrypt_key));
_pdfioCryptoRC4Crypt(&rc4, pdf->owner_key, sizeof(pdf->owner_key));
_pdfioCryptoRC4Crypt(&rc4, pdf->owner_key, pdf->owner_key, sizeof(pdf->owner_key));
}

// Generate the encryption key
Expand Down Expand Up @@ -1204,7 +1204,7 @@ pdfioFileSetPermissions(
digest[j] = (uint8_t)(pdf->encryption_key[j] ^ i);

_pdfioCryptoRC4Init(&rc4, digest, 16);
_pdfioCryptoRC4Crypt(&rc4, pdf->user_key, sizeof(pdf->user_key));
_pdfioCryptoRC4Crypt(&rc4, pdf->user_key, pdf->user_key, sizeof(pdf->user_key));
}

// Save everything in the dictionary...
Expand Down
9 changes: 4 additions & 5 deletions pdfio-private.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -175,7 +175,6 @@ typedef struct _pdfio_value_s // Value structure
} value; // Value union
} _pdfio_value_t;


typedef struct _pdfio_aes_s // AES encryption state
{
size_t round_size; // Size of round key
Expand Down Expand Up @@ -212,7 +211,7 @@ typedef union _pdfio_crypto_ctx_u // Cryptographic contexts
_pdfio_aes_t aes; // AES-128/256 context
_pdfio_rc4_t rc4; // RC4-40/128 context
} _pdfio_crypto_ctx_t;
typedef void (*_pdfio_crypto_cb_t)(_pdfio_crypto_ctx_t *ctx, uint8_t *buffer, size_t len);
typedef void (*_pdfio_crypto_cb_t)(_pdfio_crypto_ctx_t *ctx, uint8_t *outbuffer, const uint8_t *inbuffer, size_t len);

struct _pdfio_array_s
{
Expand Down Expand Up @@ -343,16 +342,16 @@ extern pdfio_array_t *_pdfioArrayRead(pdfio_file_t *pdf, _pdfio_token_t *ts) _PD
extern bool _pdfioArrayWrite(pdfio_array_t *a) _PDFIO_INTERNAL;

extern void _pdfioCryptoAESInit(_pdfio_aes_t *ctx, const uint8_t *key, size_t keylen, const uint8_t *iv) _PDFIO_INTERNAL;
extern void _pdfioCryptoAESDecrypt(_pdfio_aes_t *ctx, uint8_t *buffer, size_t len) _PDFIO_INTERNAL;
extern void _pdfioCryptoAESEncrypt(_pdfio_aes_t *ctx, uint8_t *buffer, size_t len) _PDFIO_INTERNAL;
extern void _pdfioCryptoAESDecrypt(_pdfio_aes_t *ctx, uint8_t *outbuffer, const uint8_t *inbuffer, size_t len) _PDFIO_INTERNAL;
extern void _pdfioCryptoAESEncrypt(_pdfio_aes_t *ctx, uint8_t *outbuffer, const uint8_t *inbuffer, size_t len) _PDFIO_INTERNAL;
extern void _pdfioCryptoMakeRandom(uint8_t *buffer, size_t bytes) _PDFIO_INTERNAL;
extern _pdfio_crypto_cb_t _pdfioCryptoMakeReader(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_crypto_ctx_t *ctx, uint8_t *iv, size_t *ivlen) _PDFIO_INTERNAL;
extern _pdfio_crypto_cb_t _pdfioCryptoMakeWriter(pdfio_file_t *pdf, pdfio_obj_t *obj, _pdfio_crypto_ctx_t *ctx, uint8_t *iv, size_t *ivlen) _PDFIO_INTERNAL;
extern void _pdfioCryptoMD5Append(_pdfio_md5_t *pms, const uint8_t *data, size_t nbytes) _PDFIO_INTERNAL;
extern void _pdfioCryptoMD5Finish(_pdfio_md5_t *pms, uint8_t digest[16]) _PDFIO_INTERNAL;
extern void _pdfioCryptoMD5Init(_pdfio_md5_t *pms) _PDFIO_INTERNAL;
extern void _pdfioCryptoRC4Init(_pdfio_rc4_t *ctx, const uint8_t *key, size_t keylen) _PDFIO_INTERNAL;
extern void _pdfioCryptoRC4Crypt(_pdfio_rc4_t *ctx, uint8_t *buffer, size_t len) _PDFIO_INTERNAL;
extern void _pdfioCryptoRC4Crypt(_pdfio_rc4_t *ctx, uint8_t *outbuffer, const uint8_t *inbuffer, size_t len) _PDFIO_INTERNAL;
extern void _pdfioCryptoSHA256Append(_pdfio_sha256_t *, const uint8_t *bytes, size_t bytecount) _PDFIO_INTERNAL;
extern void _pdfioCryptoSHA256Init(_pdfio_sha256_t *ctx) _PDFIO_INTERNAL;
extern void _pdfioCryptoSHA256Finish(_pdfio_sha256_t *ctx, uint8_t *Message_Digest) _PDFIO_INTERNAL;
Expand Down
7 changes: 5 additions & 2 deletions pdfio-rc4.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -66,11 +66,14 @@ _pdfioCryptoRC4Init(
//
// '_pdfioCryptoRC4Crypt()' - De/encrypt the given buffer.
//
// "inbuffer" and "outbuffer" can point to the same memory.
//

void
_pdfioCryptoRC4Crypt(
_pdfio_rc4_t *ctx, // I - Context
uint8_t *buffer, // I - Buffer
uint8_t *outbuffer, // I - Output buffer
const uint8_t *inbuffer, // I - Input buffer
size_t len) // I - Size of buffers
{
uint8_t tmp, // Swap variable
Expand All @@ -97,7 +100,7 @@ _pdfioCryptoRC4Crypt(
t = ctx->sbox[i] + ctx->sbox[j];

// Encrypt using the S box...
*buffer++ ^= ctx->sbox[t];
*outbuffer++ = *inbuffer++ ^ ctx->sbox[t];
len --;
}

Expand Down
67 changes: 64 additions & 3 deletions pdfio-stream.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -61,6 +61,12 @@ pdfioStreamClose(pdfio_stream_t *st) // I - Stream
goto done;
}

if (st->crypto_cb)
{
// Encrypt it first...
(st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, sizeof(st->cbuffer) - st->flate.avail_out);
}

if (!_pdfioFileWrite(st->pdf, st->cbuffer, sizeof(st->cbuffer) - st->flate.avail_out))
{
ret = false;
Expand All @@ -74,6 +80,12 @@ pdfioStreamClose(pdfio_stream_t *st) // I - Stream
if (st->flate.avail_out < (uInt)sizeof(st->cbuffer))
{
// Write any residuals...
if (st->crypto_cb)
{
// Encrypt it first...
(st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, sizeof(st->cbuffer) - st->flate.avail_out);
}

if (!_pdfioFileWrite(st->pdf, st->cbuffer, sizeof(st->cbuffer) - st->flate.avail_out))
{
ret = false;
Expand Down Expand Up @@ -160,6 +172,22 @@ _pdfioStreamCreate(
st->length_obj = length_obj;
st->filter = compression;

if (obj->pdf->encryption)
{
uint8_t iv[64]; // Initialization vector
size_t ivlen = sizeof(iv); // Length of initialization vector, if any

if ((st->crypto_cb = _pdfioCryptoMakeWriter(st->pdf, obj, &st->crypto_ctx, iv, &ivlen)) == NULL)
{
// TODO: Add error message?
free(st);
return (NULL);
}

if (ivlen > 0)
_pdfioFileWrite(st->pdf, iv, ivlen);
}

if (compression == PDFIO_FILTER_FLATE)
{
// Flate compression
Expand Down Expand Up @@ -592,7 +620,7 @@ pdfioStreamPrintf(


//
// '()' - Write a single character to a stream.
// 'pdfioStreamPutChar()' - Write a single character to a stream.
//

bool // O - `true` on success, `false` on failure
Expand Down Expand Up @@ -722,8 +750,35 @@ pdfioStreamWrite(
// Write it...
if (st->filter == PDFIO_FILTER_NONE)
{
// No filtering so just write it...
return (_pdfioFileWrite(st->pdf, buffer, bytes));
// No filtering...
if (st->crypto_cb)
{
// Encrypt data before writing...
unsigned char temp[8192]; // Temporary buffer
size_t cbytes; // Current bytes

bufptr = (const unsigned char *)buffer;

while (bytes > 0)
{
if ((cbytes = bytes) > sizeof(temp))
cbytes = sizeof(temp);

(st->crypto_cb)(&st->crypto_ctx, temp, bufptr, cbytes);
if (!_pdfioFileWrite(st->pdf, temp, cbytes))
return (false);

bytes -= cbytes;
bufptr += cbytes;
}

return (true);
}
else
{
// Write unencrypted...
return (_pdfioFileWrite(st->pdf, buffer, bytes));
}
}

pbline = st->pbsize - 1;
Expand Down Expand Up @@ -1098,6 +1153,12 @@ stream_write(pdfio_stream_t *st, // I - Stream
if (st->flate.avail_out < (sizeof(st->cbuffer) / 8))
{
// Flush the compression buffer...
if (st->crypto_cb)
{
// Encrypt it first...
(st->crypto_cb)(&st->crypto_ctx, st->cbuffer, st->cbuffer, sizeof(st->cbuffer) - st->flate.avail_out);
}

if (!_pdfioFileWrite(st->pdf, st->cbuffer, sizeof(st->cbuffer) - st->flate.avail_out))
return (false);

Expand Down
2 changes: 1 addition & 1 deletion pdfio.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -99,7 +99,7 @@ enum pdfio_permission_e // PDF permission bits
PDFIO_PERMISSION_PRINT_HIGH = 0x0800, // PDF allows high quality printing
PDFIO_PERMISSION_ALL = ~0 // All permissions
};
typedef unsigned pdfio_permission_t; // PDF permission bitfield
typedef int pdfio_permission_t; // PDF permission bitfield
typedef struct pdfio_rect_s // PDF rectangle
{
double x1; // Lower-left X coordinate
Expand Down
40 changes: 39 additions & 1 deletion testpdfio.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -763,7 +763,7 @@ do_unit_tests(void)
if (read_unit_file("testpdfio-out.pdf", num_pages, first_image, false))
return (1);

// Create a new PDF file...
// Stream a new PDF file...
if ((outfd = open("testpdfio-out2.pdf", O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0666)) < 0)
{
perror("Unable to open \"testpdfio-out2.pdf\"");
Expand All @@ -784,6 +784,44 @@ do_unit_tests(void)
if (read_unit_file("testpdfio-out2.pdf", num_pages, first_image, true))
return (1);

// Create new encrypted PDF files...
fputs("pdfioFileCreate(\"testpdfio-rc4.pdf\", ...): ", stdout);
if ((outpdf = pdfioFileCreate("testpdfio-rc4.pdf", NULL, NULL, NULL, (pdfio_error_cb_t)error_cb, &error)) != NULL)
puts("PASS");
else
return (1);

fputs("pdfioFileSetPermissions(all, RC4-128, no passwords): ", stdout);
if (pdfioFileSetPermissions(outpdf, PDFIO_PERMISSION_ALL, PDFIO_ENCRYPTION_RC4_128, NULL, NULL))
puts("PASS");
else
return (1);

if (write_unit_file(inpdf, outpdf, &num_pages, &first_image))
return (1);

// if (read_unit_file("testpdfio-rc4.pdf", num_pages, first_image, false))
// return (1);

fputs("pdfioFileCreate(\"testpdfio-aes.pdf\", ...): ", stdout);
if ((outpdf = pdfioFileCreate("testpdfio-aes.pdf", NULL, NULL, NULL, (pdfio_error_cb_t)error_cb, &error)) != NULL)
puts("PASS");
else
return (1);

fputs("pdfioFileSetPermissions(no-print, AES-128, passwords='owner' and 'user'): ", stdout);
if (pdfioFileSetPermissions(outpdf, PDFIO_PERMISSION_ALL ^ PDFIO_PERMISSION_PRINT, PDFIO_ENCRYPTION_AES_128, "owner", "user"))
puts("PASS");
else
return (1);

if (write_unit_file(inpdf, outpdf, &num_pages, &first_image))
return (1);

// if (read_unit_file("testpdfio-aes.pdf", num_pages, first_image, false))
// return (1);


return (0);
}

Expand Down

0 comments on commit c24243a

Please sign in to comment.