From 332ef5423df9aa7a28166907f4a6ac8ac095163d Mon Sep 17 00:00:00 2001 From: Tom Sepez Date: Fri, 5 May 2017 17:08:07 -0700 Subject: Remove type-unsafe void* / uint8_t* usage in fx_crypt.h Consolidate all of the sha2 contexts while we're at it, the one with the largest buf is suitable for use by all the others. Change-Id: Iace6cd8ca4405f75f78842a1559c3a2478910218 Reviewed-on: https://pdfium-review.googlesource.com/4994 Commit-Queue: Tom Sepez Reviewed-by: Lei Zhang --- core/fdrm/crypto/fx_crypt.h | 49 +++++++++------- core/fdrm/crypto/fx_crypt_aes.cpp | 65 ++++++++++----------- core/fdrm/crypto/fx_crypt_sha.cpp | 39 +++++++------ core/fpdfapi/parser/cpdf_crypto_handler.cpp | 81 ++++++++++++++------------- core/fpdfapi/parser/cpdf_crypto_handler.h | 6 +- core/fpdfapi/parser/cpdf_security_handler.cpp | 59 ++++++++++--------- 6 files changed, 158 insertions(+), 141 deletions(-) diff --git a/core/fdrm/crypto/fx_crypt.h b/core/fdrm/crypto/fx_crypt.h index 2b127948f0..5416080af7 100644 --- a/core/fdrm/crypto/fx_crypt.h +++ b/core/fdrm/crypto/fx_crypt.h @@ -16,6 +16,19 @@ struct CRYPT_rc4_context { int32_t m[kRC4ContextPermutationLength]; }; +#define MAX_NR 14 +#define MAX_NK 8 +#define MAX_NB 8 +struct CRYPT_aes_context { + void (*encrypt)(CRYPT_aes_context* ctx, unsigned int* block); + void (*decrypt)(CRYPT_aes_context* ctx, unsigned int* block); + int Nb; + int Nr; + unsigned int keysched[(MAX_NR + 1) * MAX_NB]; + unsigned int invkeysched[(MAX_NR + 1) * MAX_NB]; + unsigned int iv[MAX_NB]; +}; + struct CRYPT_md5_context { uint32_t total[2]; uint32_t state[4]; @@ -30,13 +43,7 @@ struct CRYPT_sha1_context { unsigned int lenlo; }; -struct CRYPT_sha256_context { - uint32_t total[2]; - uint32_t state[8]; - uint8_t buffer[64]; -}; - -struct CRYPT_sha384_context { +struct CRYPT_sha2_context { uint64_t total[2]; uint64_t state[8]; uint8_t buffer[128]; @@ -53,17 +60,17 @@ void CRYPT_ArcFourCrypt(CRYPT_rc4_context* context, uint8_t* data, uint32_t size); -void CRYPT_AESSetKey(void* context, +void CRYPT_AESSetKey(CRYPT_aes_context* context, uint32_t blocklen, const uint8_t* key, uint32_t keylen, bool bEncrypt); -void CRYPT_AESSetIV(void* context, const uint8_t* iv); -void CRYPT_AESDecrypt(void* context, +void CRYPT_AESSetIV(CRYPT_aes_context* context, const uint8_t* iv); +void CRYPT_AESDecrypt(CRYPT_aes_context* context, uint8_t* dest, const uint8_t* src, uint32_t size); -void CRYPT_AESEncrypt(void* context, +void CRYPT_AESEncrypt(CRYPT_aes_context* context, uint8_t* dest, const uint8_t* src, uint32_t size); @@ -82,27 +89,29 @@ void CRYPT_SHA1Update(CRYPT_sha1_context* context, void CRYPT_SHA1Finish(CRYPT_sha1_context* context, uint8_t digest[20]); void CRYPT_SHA1Generate(const uint8_t* data, uint32_t size, uint8_t digest[20]); -void CRYPT_SHA256Start(CRYPT_sha256_context* context); -void CRYPT_SHA256Update(CRYPT_sha256_context* context, +void CRYPT_SHA256Start(CRYPT_sha2_context* context); +void CRYPT_SHA256Update(CRYPT_sha2_context* context, const uint8_t* data, uint32_t size); -void CRYPT_SHA256Finish(CRYPT_sha256_context* context, uint8_t digest[32]); +void CRYPT_SHA256Finish(CRYPT_sha2_context* context, uint8_t digest[32]); void CRYPT_SHA256Generate(const uint8_t* data, uint32_t size, uint8_t digest[32]); -void CRYPT_SHA384Start(CRYPT_sha384_context* context); -void CRYPT_SHA384Update(CRYPT_sha384_context* context, +void CRYPT_SHA384Start(CRYPT_sha2_context* context); +void CRYPT_SHA384Update(CRYPT_sha2_context* context, const uint8_t* data, uint32_t size); -void CRYPT_SHA384Finish(CRYPT_sha384_context* context, uint8_t digest[48]); +void CRYPT_SHA384Finish(CRYPT_sha2_context* context, uint8_t digest[48]); void CRYPT_SHA384Generate(const uint8_t* data, uint32_t size, uint8_t digest[48]); -void CRYPT_SHA512Start(void* context); -void CRYPT_SHA512Update(void* context, const uint8_t* data, uint32_t size); -void CRYPT_SHA512Finish(void* context, uint8_t digest[64]); +void CRYPT_SHA512Start(CRYPT_sha2_context* context); +void CRYPT_SHA512Update(CRYPT_sha2_context* context, + const uint8_t* data, + uint32_t size); +void CRYPT_SHA512Finish(CRYPT_sha2_context* context, uint8_t digest[64]); void CRYPT_SHA512Generate(const uint8_t* data, uint32_t size, uint8_t digest[64]); diff --git a/core/fdrm/crypto/fx_crypt_aes.cpp b/core/fdrm/crypto/fx_crypt_aes.cpp index 671dc65f31..94d66d0956 100644 --- a/core/fdrm/crypto/fx_crypt_aes.cpp +++ b/core/fdrm/crypto/fx_crypt_aes.cpp @@ -6,9 +6,6 @@ #include "core/fdrm/crypto/fx_crypt.h" -#define MAX_NR 14 -#define MAX_NK 8 -#define MAX_NB 8 #define mulby2(x) (((x & 0x7F) << 1) ^ (x & 0x80 ? 0x1B : 0)) #define GET_32BIT_MSB_FIRST(cp) \ (((unsigned long)(unsigned char)(cp)[3]) | \ @@ -23,15 +20,6 @@ (cp)[0] = (value) >> 24; \ } while (0) -struct AESContext { - unsigned int keysched[(MAX_NR + 1) * MAX_NB]; - unsigned int invkeysched[(MAX_NR + 1) * MAX_NB]; - void (*encrypt)(AESContext* ctx, unsigned int* block); - void (*decrypt)(AESContext* ctx, unsigned int* block); - unsigned int iv[MAX_NB]; - int Nb, Nr; -}; - namespace { const unsigned char Sbox[256] = { @@ -462,7 +450,8 @@ const unsigned int D3[256] = { (Sbox[(block[(i + C1) % Nb] >> 16) & 0xFF] << 16) | \ (Sbox[(block[(i + C2) % Nb] >> 8) & 0xFF] << 8) | \ (Sbox[(block[(i + C3) % Nb]) & 0xFF])) -void aes_encrypt_nb_4(AESContext* ctx, unsigned int* block) { + +void aes_encrypt_nb_4(CRYPT_aes_context* ctx, unsigned int* block) { int i; const int C1 = 1, C2 = 2, C3 = 3, Nb = 4; unsigned int* keysched = ctx->keysched; @@ -489,7 +478,8 @@ void aes_encrypt_nb_4(AESContext* ctx, unsigned int* block) { MOVEWORD(3); ADD_ROUND_KEY_4; } -void aes_encrypt_nb_6(AESContext* ctx, unsigned int* block) { + +void aes_encrypt_nb_6(CRYPT_aes_context* ctx, unsigned int* block) { int i; const int C1 = 1, C2 = 2, C3 = 3, Nb = 6; unsigned int* keysched = ctx->keysched; @@ -524,7 +514,8 @@ void aes_encrypt_nb_6(AESContext* ctx, unsigned int* block) { MOVEWORD(5); ADD_ROUND_KEY_6; } -void aes_encrypt_nb_8(AESContext* ctx, unsigned int* block) { + +void aes_encrypt_nb_8(CRYPT_aes_context* ctx, unsigned int* block) { int i; const int C1 = 1, C2 = 3, C3 = 4, Nb = 8; unsigned int* keysched = ctx->keysched; @@ -579,7 +570,8 @@ void aes_encrypt_nb_8(AESContext* ctx, unsigned int* block) { (Sboxinv[(block[(i + C1) % Nb] >> 16) & 0xFF] << 16) | \ (Sboxinv[(block[(i + C2) % Nb] >> 8) & 0xFF] << 8) | \ (Sboxinv[(block[(i + C3) % Nb]) & 0xFF])) -void aes_decrypt_nb_4(AESContext* ctx, unsigned int* block) { + +void aes_decrypt_nb_4(CRYPT_aes_context* ctx, unsigned int* block) { int i; const int C1 = 4 - 1, C2 = 4 - 2, C3 = 4 - 3, Nb = 4; unsigned int* keysched = ctx->invkeysched; @@ -606,7 +598,8 @@ void aes_decrypt_nb_4(AESContext* ctx, unsigned int* block) { MOVEWORD(3); ADD_ROUND_KEY_4; } -void aes_decrypt_nb_6(AESContext* ctx, unsigned int* block) { + +void aes_decrypt_nb_6(CRYPT_aes_context* ctx, unsigned int* block) { int i; const int C1 = 6 - 1, C2 = 6 - 2, C3 = 6 - 3, Nb = 6; unsigned int* keysched = ctx->invkeysched; @@ -641,7 +634,8 @@ void aes_decrypt_nb_6(AESContext* ctx, unsigned int* block) { MOVEWORD(5); ADD_ROUND_KEY_6; } -void aes_decrypt_nb_8(AESContext* ctx, unsigned int* block) { + +void aes_decrypt_nb_8(CRYPT_aes_context* ctx, unsigned int* block) { int i; const int C1 = 8 - 1, C2 = 8 - 3, C3 = 8 - 4, Nb = 8; unsigned int* keysched = ctx->invkeysched; @@ -686,7 +680,7 @@ void aes_decrypt_nb_8(AESContext* ctx, unsigned int* block) { } #undef MAKEWORD #undef LASTWORD -void aes_setup(AESContext* ctx, +void aes_setup(CRYPT_aes_context* ctx, int blocklen, const unsigned char* key, int keylen) { @@ -753,13 +747,13 @@ void aes_setup(AESContext* ctx, } } } -void aes_decrypt(AESContext* ctx, unsigned int* block) { +void aes_decrypt(CRYPT_aes_context* ctx, unsigned int* block) { ctx->decrypt(ctx, block); } void aes_decrypt_cbc(unsigned char* dest, const unsigned char* src, int len, - AESContext* ctx) { + CRYPT_aes_context* ctx) { unsigned int iv[4], x[4], ct[4]; int i; ASSERT((len & 15) == 0); @@ -779,13 +773,15 @@ void aes_decrypt_cbc(unsigned char* dest, } memcpy(ctx->iv, iv, sizeof(iv)); } -void aes_encrypt(AESContext* ctx, unsigned int* block) { + +void aes_encrypt(CRYPT_aes_context* ctx, unsigned int* block) { ctx->encrypt(ctx, block); } + void aes_encrypt_cbc(unsigned char* dest, const unsigned char* src, int len, - AESContext* ctx) { + CRYPT_aes_context* ctx) { unsigned int iv[4]; int i; ASSERT((len & 15) == 0); @@ -807,28 +803,29 @@ void aes_encrypt_cbc(unsigned char* dest, } // namespace -void CRYPT_AESSetKey(void* context, +void CRYPT_AESSetKey(CRYPT_aes_context* context, uint32_t blocklen, const uint8_t* key, uint32_t keylen, bool bEncrypt) { - aes_setup((AESContext*)context, blocklen, key, keylen); + aes_setup(context, blocklen, key, keylen); } -void CRYPT_AESSetIV(void* context, const uint8_t* iv) { - int i; - for (i = 0; i < ((AESContext*)context)->Nb; i++) { - ((AESContext*)context)->iv[i] = GET_32BIT_MSB_FIRST(iv + 4 * i); - } + +void CRYPT_AESSetIV(CRYPT_aes_context* context, const uint8_t* iv) { + for (int i = 0; i < context->Nb; i++) + context->iv[i] = GET_32BIT_MSB_FIRST(iv + 4 * i); } -void CRYPT_AESDecrypt(void* context, + +void CRYPT_AESDecrypt(CRYPT_aes_context* context, uint8_t* dest, const uint8_t* src, uint32_t len) { - aes_decrypt_cbc(dest, src, len, (AESContext*)context); + aes_decrypt_cbc(dest, src, len, context); } -void CRYPT_AESEncrypt(void* context, + +void CRYPT_AESEncrypt(CRYPT_aes_context* context, uint8_t* dest, const uint8_t* src, uint32_t len) { - aes_encrypt_cbc(dest, src, len, (AESContext*)context); + aes_encrypt_cbc(dest, src, len, context); } diff --git a/core/fdrm/crypto/fx_crypt_sha.cpp b/core/fdrm/crypto/fx_crypt_sha.cpp index 49f77558f0..7420a32d48 100644 --- a/core/fdrm/crypto/fx_crypt_sha.cpp +++ b/core/fdrm/crypto/fx_crypt_sha.cpp @@ -144,7 +144,7 @@ void SHATransform(unsigned int* digest, unsigned int* block) { digest[4] += e; } -void sha256_process(CRYPT_sha256_context* ctx, const uint8_t data[64]) { +void sha256_process(CRYPT_sha2_context* ctx, const uint8_t data[64]) { uint32_t temp1, temp2, W[64]; uint32_t A, B, C, D, E, F, G, H; GET_UINT32(W[0], data, 0); @@ -289,7 +289,7 @@ uint64_t const constants[] = { 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL, }; -void sha384_process(CRYPT_sha384_context* ctx, const uint8_t data[128]) { +void sha384_process(CRYPT_sha2_context* ctx, const uint8_t data[128]) { uint64_t temp1, temp2; uint64_t A, B, C, D, E, F, G, H; uint64_t W[80]; @@ -436,7 +436,7 @@ void CRYPT_SHA1Generate(const uint8_t* data, CRYPT_SHA1Update(&s, data, size); CRYPT_SHA1Finish(&s, digest); } -void CRYPT_SHA256Start(CRYPT_sha256_context* ctx) { +void CRYPT_SHA256Start(CRYPT_sha2_context* ctx) { ctx->total[0] = 0; ctx->total[1] = 0; ctx->state[0] = 0x6A09E667; @@ -449,7 +449,7 @@ void CRYPT_SHA256Start(CRYPT_sha256_context* ctx) { ctx->state[7] = 0x5BE0CD19; } -void CRYPT_SHA256Update(CRYPT_sha256_context* ctx, +void CRYPT_SHA256Update(CRYPT_sha2_context* ctx, const uint8_t* input, uint32_t length) { if (!length) @@ -478,7 +478,7 @@ void CRYPT_SHA256Update(CRYPT_sha256_context* ctx, memcpy(ctx->buffer + left, input, length); } -void CRYPT_SHA256Finish(CRYPT_sha256_context* ctx, uint8_t digest[32]) { +void CRYPT_SHA256Finish(CRYPT_sha2_context* ctx, uint8_t digest[32]) { uint32_t last, padn; uint32_t high, low; uint8_t msglen[8]; @@ -503,17 +503,17 @@ void CRYPT_SHA256Finish(CRYPT_sha256_context* ctx, uint8_t digest[32]) { void CRYPT_SHA256Generate(const uint8_t* data, uint32_t size, uint8_t digest[32]) { - CRYPT_sha256_context ctx; + CRYPT_sha2_context ctx; CRYPT_SHA256Start(&ctx); CRYPT_SHA256Update(&ctx, data, size); CRYPT_SHA256Finish(&ctx, digest); } -void CRYPT_SHA384Start(CRYPT_sha384_context* ctx) { +void CRYPT_SHA384Start(CRYPT_sha2_context* ctx) { if (!ctx) return; - memset(ctx, 0, sizeof(CRYPT_sha384_context)); + memset(ctx, 0, sizeof(CRYPT_sha2_context)); ctx->state[0] = 0xcbbb9d5dc1059ed8ULL; ctx->state[1] = 0x629a292a367cd507ULL; ctx->state[2] = 0x9159015a3070dd17ULL; @@ -524,7 +524,7 @@ void CRYPT_SHA384Start(CRYPT_sha384_context* ctx) { ctx->state[7] = 0x47b5481dbefa4fa4ULL; } -void CRYPT_SHA384Update(CRYPT_sha384_context* ctx, +void CRYPT_SHA384Update(CRYPT_sha2_context* ctx, const uint8_t* input, uint32_t length) { if (!length) @@ -552,7 +552,7 @@ void CRYPT_SHA384Update(CRYPT_sha384_context* ctx, memcpy(ctx->buffer + left, input, length); } -void CRYPT_SHA384Finish(CRYPT_sha384_context* ctx, uint8_t digest[48]) { +void CRYPT_SHA384Finish(CRYPT_sha2_context* ctx, uint8_t digest[48]) { uint32_t last, padn; uint8_t msglen[16]; memset(msglen, 0, 16); @@ -576,18 +576,17 @@ void CRYPT_SHA384Finish(CRYPT_sha384_context* ctx, uint8_t digest[48]) { void CRYPT_SHA384Generate(const uint8_t* data, uint32_t size, uint8_t digest[64]) { - CRYPT_sha384_context context; + CRYPT_sha2_context context; CRYPT_SHA384Start(&context); CRYPT_SHA384Update(&context, data, size); CRYPT_SHA384Finish(&context, digest); } -void CRYPT_SHA512Start(void* context) { - if (!context) +void CRYPT_SHA512Start(CRYPT_sha2_context* ctx) { + if (!ctx) return; - CRYPT_sha384_context* ctx = (CRYPT_sha384_context*)context; - memset(ctx, 0, sizeof(CRYPT_sha384_context)); + memset(ctx, 0, sizeof(CRYPT_sha2_context)); ctx->state[0] = 0xa09e667f3bcc908ULL; ctx->state[1] = 0xb67ae8584caa73bULL; ctx->state[2] = 0xc6ef372fe94f82bULL; @@ -598,13 +597,13 @@ void CRYPT_SHA512Start(void* context) { ctx->state[7] = 0xbe0cd19137e2179ULL; } -void CRYPT_SHA512Update(void* context, const uint8_t* data, uint32_t size) { - CRYPT_sha384_context* ctx = (CRYPT_sha384_context*)context; +void CRYPT_SHA512Update(CRYPT_sha2_context* ctx, + const uint8_t* data, + uint32_t size) { CRYPT_SHA384Update(ctx, data, size); } -void CRYPT_SHA512Finish(void* context, uint8_t digest[64]) { - CRYPT_sha384_context* ctx = (CRYPT_sha384_context*)context; +void CRYPT_SHA512Finish(CRYPT_sha2_context* ctx, uint8_t digest[64]) { uint32_t last, padn; uint8_t msglen[16]; memset(msglen, 0, 16); @@ -630,7 +629,7 @@ void CRYPT_SHA512Finish(void* context, uint8_t digest[64]) { void CRYPT_SHA512Generate(const uint8_t* data, uint32_t size, uint8_t digest[64]) { - CRYPT_sha384_context context; + CRYPT_sha2_context context; CRYPT_SHA512Start(&context); CRYPT_SHA512Update(&context, data, size); CRYPT_SHA512Finish(&context, digest); diff --git a/core/fpdfapi/parser/cpdf_crypto_handler.cpp b/core/fpdfapi/parser/cpdf_crypto_handler.cpp index ea09601b30..ef84480c23 100644 --- a/core/fpdfapi/parser/cpdf_crypto_handler.cpp +++ b/core/fpdfapi/parser/cpdf_crypto_handler.cpp @@ -41,26 +41,29 @@ void CPDF_CryptoHandler::CryptBlock(bool bEncrypt, } } if (m_Cipher == FXCIPHER_AES) { - CRYPT_AESSetKey(m_pAESContext, 16, m_KeyLen == 32 ? m_EncryptKey : realkey, - m_KeyLen, bEncrypt); + CRYPT_AESSetKey(m_pAESContext.get(), 16, + m_KeyLen == 32 ? m_EncryptKey : realkey, m_KeyLen, + bEncrypt); if (bEncrypt) { uint8_t iv[16]; for (int i = 0; i < 16; i++) { iv[i] = (uint8_t)rand(); } - CRYPT_AESSetIV(m_pAESContext, iv); + CRYPT_AESSetIV(m_pAESContext.get(), iv); memcpy(dest_buf, iv, 16); int nblocks = src_size / 16; - CRYPT_AESEncrypt(m_pAESContext, dest_buf + 16, src_buf, nblocks * 16); + CRYPT_AESEncrypt(m_pAESContext.get(), dest_buf + 16, src_buf, + nblocks * 16); uint8_t padding[16]; memcpy(padding, src_buf + nblocks * 16, src_size % 16); memset(padding + src_size % 16, 16 - src_size % 16, 16 - src_size % 16); - CRYPT_AESEncrypt(m_pAESContext, dest_buf + nblocks * 16 + 16, padding, - 16); + CRYPT_AESEncrypt(m_pAESContext.get(), dest_buf + nblocks * 16 + 16, + padding, 16); dest_size = 32 + nblocks * 16; } else { - CRYPT_AESSetIV(m_pAESContext, src_buf); - CRYPT_AESDecrypt(m_pAESContext, dest_buf, src_buf + 16, src_size - 16); + CRYPT_AESSetIV(m_pAESContext.get(), src_buf); + CRYPT_AESDecrypt(m_pAESContext.get(), dest_buf, src_buf + 16, + src_size - 16); dest_size = src_size - 16; dest_size -= dest_buf[dest_size - 1]; } @@ -74,10 +77,10 @@ void CPDF_CryptoHandler::CryptBlock(bool bEncrypt, } struct AESCryptContext { - uint8_t m_Context[2048]; bool m_bIV; uint8_t m_Block[16]; uint32_t m_BlockOffset; + CRYPT_aes_context m_Context; }; void* CPDF_CryptoHandler::CryptStart(uint32_t objnum, @@ -90,12 +93,12 @@ void* CPDF_CryptoHandler::CryptStart(uint32_t objnum, AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1); pContext->m_bIV = true; pContext->m_BlockOffset = 0; - CRYPT_AESSetKey(pContext->m_Context, 16, m_EncryptKey, 32, bEncrypt); + CRYPT_AESSetKey(&pContext->m_Context, 16, m_EncryptKey, 32, bEncrypt); if (bEncrypt) { for (int i = 0; i < 16; i++) { pContext->m_Block[i] = (uint8_t)rand(); } - CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block); + CRYPT_AESSetIV(&pContext->m_Context, pContext->m_Block); } return pContext; } @@ -116,12 +119,12 @@ void* CPDF_CryptoHandler::CryptStart(uint32_t objnum, AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1); pContext->m_bIV = true; pContext->m_BlockOffset = 0; - CRYPT_AESSetKey(pContext->m_Context, 16, realkey, 16, bEncrypt); + CRYPT_AESSetKey(&pContext->m_Context, 16, realkey, 16, bEncrypt); if (bEncrypt) { for (int i = 0; i < 16; i++) { pContext->m_Block[i] = (uint8_t)rand(); } - CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block); + CRYPT_AESSetIV(&pContext->m_Context, pContext->m_Block); } return pContext; } @@ -168,16 +171,16 @@ bool CPDF_CryptoHandler::CryptStream(void* context, pContext->m_BlockOffset += copy_size; if (pContext->m_BlockOffset == 16) { if (!bEncrypt && pContext->m_bIV) { - CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block); + CRYPT_AESSetIV(&pContext->m_Context, pContext->m_Block); pContext->m_bIV = false; pContext->m_BlockOffset = 0; } else if (src_off < src_size) { uint8_t block_buf[16]; if (bEncrypt) { - CRYPT_AESEncrypt(pContext->m_Context, block_buf, pContext->m_Block, + CRYPT_AESEncrypt(&pContext->m_Context, block_buf, pContext->m_Block, 16); } else { - CRYPT_AESDecrypt(pContext->m_Context, block_buf, pContext->m_Block, + CRYPT_AESDecrypt(&pContext->m_Context, block_buf, pContext->m_Block, 16); } dest_buf.AppendBlock(block_buf, 16); @@ -207,18 +210,18 @@ bool CPDF_CryptoHandler::CryptFinish(void* context, if (bEncrypt) { uint8_t block_buf[16]; if (pContext->m_BlockOffset == 16) { - CRYPT_AESEncrypt(pContext->m_Context, block_buf, pContext->m_Block, 16); + CRYPT_AESEncrypt(&pContext->m_Context, block_buf, pContext->m_Block, 16); dest_buf.AppendBlock(block_buf, 16); pContext->m_BlockOffset = 0; } memset(pContext->m_Block + pContext->m_BlockOffset, (uint8_t)(16 - pContext->m_BlockOffset), 16 - pContext->m_BlockOffset); - CRYPT_AESEncrypt(pContext->m_Context, block_buf, pContext->m_Block, 16); + CRYPT_AESEncrypt(&pContext->m_Context, block_buf, pContext->m_Block, 16); dest_buf.AppendBlock(block_buf, 16); } else if (pContext->m_BlockOffset == 16) { uint8_t block_buf[16]; - CRYPT_AESDecrypt(pContext->m_Context, block_buf, pContext->m_Block, 16); + CRYPT_AESDecrypt(&pContext->m_Context, block_buf, pContext->m_Block, 16); if (block_buf[15] <= 16) { dest_buf.AppendBlock(block_buf, 16 - block_buf[15]); } @@ -247,18 +250,18 @@ uint32_t CPDF_CryptoHandler::DecryptGetSize(uint32_t src_size) { bool CPDF_CryptoHandler::Init(CPDF_Dictionary* pEncryptDict, CPDF_SecurityHandler* pSecurityHandler) { const uint8_t* key; - if (!pSecurityHandler->GetCryptInfo(m_Cipher, key, m_KeyLen)) { + if (!pSecurityHandler->GetCryptInfo(m_Cipher, key, m_KeyLen)) return false; - } - if (m_KeyLen > 32 || m_KeyLen < 0) { + + if (m_KeyLen > 32 || m_KeyLen < 0) return false; - } - if (m_Cipher != FXCIPHER_NONE) { + + if (m_Cipher != FXCIPHER_NONE) memcpy(m_EncryptKey, key, m_KeyLen); - } - if (m_Cipher == FXCIPHER_AES) { - m_pAESContext = FX_Alloc(uint8_t, 2048); - } + + if (m_Cipher == FXCIPHER_AES) + m_pAESContext.reset(FX_Alloc(CRYPT_aes_context, 1)); + return true; } @@ -288,17 +291,19 @@ bool CPDF_CryptoHandler::Init(int cipher, const uint8_t* key, int keylen) { m_Cipher = cipher; m_KeyLen = keylen; memcpy(m_EncryptKey, key, keylen); - if (m_Cipher == FXCIPHER_AES) { - m_pAESContext = FX_Alloc(uint8_t, 2048); - } + if (m_Cipher == FXCIPHER_AES) + m_pAESContext.reset(FX_Alloc(CRYPT_aes_context, 1)); + return true; } + bool CPDF_CryptoHandler::DecryptStream(void* context, const uint8_t* src_buf, uint32_t src_size, CFX_BinaryBuf& dest_buf) { return CryptStream(context, src_buf, src_size, dest_buf, false); } + bool CPDF_CryptoHandler::DecryptFinish(void* context, CFX_BinaryBuf& dest_buf) { return CryptFinish(context, dest_buf, false); } @@ -311,6 +316,7 @@ uint32_t CPDF_CryptoHandler::EncryptGetSize(uint32_t objnum, } return src_size; } + bool CPDF_CryptoHandler::EncryptContent(uint32_t objnum, uint32_t gennum, const uint8_t* src_buf, @@ -320,14 +326,11 @@ bool CPDF_CryptoHandler::EncryptContent(uint32_t objnum, CryptBlock(true, objnum, gennum, src_buf, src_size, dest_buf, dest_size); return true; } -CPDF_CryptoHandler::CPDF_CryptoHandler() { - m_pAESContext = nullptr; - m_Cipher = FXCIPHER_NONE; - m_KeyLen = 0; -} -CPDF_CryptoHandler::~CPDF_CryptoHandler() { - FX_Free(m_pAESContext); -} + +CPDF_CryptoHandler::CPDF_CryptoHandler() + : m_KeyLen(0), m_Cipher(FXCIPHER_NONE) {} + +CPDF_CryptoHandler::~CPDF_CryptoHandler() {} void CPDF_CryptoHandler::PopulateKey(uint32_t objnum, uint32_t gennum, diff --git a/core/fpdfapi/parser/cpdf_crypto_handler.h b/core/fpdfapi/parser/cpdf_crypto_handler.h index 24caff7081..9d76e67d96 100644 --- a/core/fpdfapi/parser/cpdf_crypto_handler.h +++ b/core/fpdfapi/parser/cpdf_crypto_handler.h @@ -7,8 +7,12 @@ #ifndef CORE_FPDFAPI_PARSER_CPDF_CRYPTO_HANDLER_H_ #define CORE_FPDFAPI_PARSER_CPDF_CRYPTO_HANDLER_H_ +#include + +#include "core/fdrm/crypto/fx_crypt.h" #include "core/fxcrt/cfx_retain_ptr.h" #include "core/fxcrt/fx_basic.h" +#include "core/fxcrt/fx_memory.h" #include "core/fxcrt/fx_string.h" #include "core/fxcrt/fx_system.h" @@ -68,7 +72,7 @@ class CPDF_CryptoHandler : public CFX_Retainable { uint8_t m_EncryptKey[32]; int m_KeyLen; int m_Cipher; - uint8_t* m_pAESContext; + std::unique_ptr m_pAESContext; }; #endif // CORE_FPDFAPI_PARSER_CPDF_CRYPTO_HANDLER_H_ diff --git a/core/fpdfapi/parser/cpdf_security_handler.cpp b/core/fpdfapi/parser/cpdf_security_handler.cpp index 4ea5da3497..85a3805eea 100644 --- a/core/fpdfapi/parser/cpdf_security_handler.cpp +++ b/core/fpdfapi/parser/cpdf_security_handler.cpp @@ -230,7 +230,7 @@ void Revision6_Hash(const uint8_t* password, const uint8_t* salt, const uint8_t* vector, uint8_t* hash) { - CRYPT_sha256_context sha; + CRYPT_sha2_context sha; CRYPT_SHA256Start(&sha); CRYPT_SHA256Update(&sha, password, size); CRYPT_SHA256Update(&sha, salt, 8); @@ -249,7 +249,8 @@ void Revision6_Hash(const uint8_t* password, CFX_ByteTextBuf interDigest; int i = 0; int iBlockSize = 32; - uint8_t* aes = FX_Alloc(uint8_t, 2048); + CRYPT_aes_context aes; + memset(&aes, 0, sizeof(aes)); while (i < 64 || i < E[iBufLen - 1] + 32) { int iRoundSize = size + iBlockSize; if (vector) { @@ -266,9 +267,9 @@ void Revision6_Hash(const uint8_t* password, content.AppendBlock(vector, 48); } } - CRYPT_AESSetKey(aes, 16, key, 16, true); - CRYPT_AESSetIV(aes, iv); - CRYPT_AESEncrypt(aes, E, content.GetBuffer(), iBufLen); + CRYPT_AESSetKey(&aes, 16, key, 16, true); + CRYPT_AESSetIV(&aes, iv); + CRYPT_AESEncrypt(&aes, E, content.GetBuffer(), iBufLen); int iHash = 0; switch (BigOrder64BitsMod3(E)) { case 0: @@ -297,7 +298,6 @@ void Revision6_Hash(const uint8_t* password, iv = input + 16; ++i; } - FX_Free(aes); if (hash) { memcpy(hash, input, 32); } @@ -319,7 +319,7 @@ bool CPDF_SecurityHandler::AES256_CheckPassword(const uint8_t* password, return false; const uint8_t* pkey = bOwner ? okey.raw_str() : ukey.raw_str(); - CRYPT_sha256_context sha; + CRYPT_sha2_context sha; uint8_t digest[32]; if (m_Revision >= 6) { Revision6_Hash(password, size, (const uint8_t*)pkey + 32, @@ -357,14 +357,15 @@ bool CPDF_SecurityHandler::AES256_CheckPassword(const uint8_t* password, if (ekey.GetLength() < 32) return false; - std::vector aes(2048); - CRYPT_AESSetKey(aes.data(), 16, digest, 32, false); + CRYPT_aes_context aes; + memset(&aes, 0, sizeof(aes)); + CRYPT_AESSetKey(&aes, 16, digest, 32, false); uint8_t iv[16]; memset(iv, 0, 16); - CRYPT_AESSetIV(aes.data(), iv); - CRYPT_AESDecrypt(aes.data(), key, ekey.raw_str(), 32); - CRYPT_AESSetKey(aes.data(), 16, key, 32, false); - CRYPT_AESSetIV(aes.data(), iv); + CRYPT_AESSetIV(&aes, iv); + CRYPT_AESDecrypt(&aes, key, ekey.raw_str(), 32); + CRYPT_AESSetKey(&aes, 16, key, 32, false); + CRYPT_AESSetIV(&aes, iv); CFX_ByteString perms = m_pEncryptDict->GetStringFor("Perms"); if (perms.IsEmpty()) return false; @@ -375,7 +376,7 @@ bool CPDF_SecurityHandler::AES256_CheckPassword(const uint8_t* password, std::min(sizeof(perms_buf), static_cast(perms.GetLength())); memcpy(perms_buf, perms.raw_str(), copy_len); uint8_t buf[16]; - CRYPT_AESDecrypt(aes.data(), buf, perms_buf, 16); + CRYPT_AESDecrypt(&aes, buf, perms_buf, 16); if (buf[9] != 'a' || buf[10] != 'd' || buf[11] != 'b') return false; @@ -532,7 +533,7 @@ void CPDF_SecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, } if (m_Revision >= 5) { int t = (int)time(nullptr); - CRYPT_sha256_context sha; + CRYPT_sha2_context sha; CRYPT_SHA256Start(&sha); CRYPT_SHA256Update(&sha, (uint8_t*)&t, sizeof t); CRYPT_SHA256Update(&sha, m_EncryptKey, 32); @@ -640,7 +641,7 @@ void CPDF_SecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, CRYPT_SHA1Finish(&sha, digest); CFX_ByteString ukey = pEncryptDict->GetStringFor("U"); - CRYPT_sha256_context sha2; + CRYPT_sha2_context sha2; uint8_t digest1[48]; if (m_Revision >= 6) { Revision6_Hash(password, size, digest, bOwner ? ukey.raw_str() : nullptr, @@ -669,13 +670,13 @@ void CPDF_SecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, } CRYPT_SHA256Finish(&sha2, digest1); } - uint8_t* aes = FX_Alloc(uint8_t, 2048); - CRYPT_AESSetKey(aes, 16, digest1, 32, true); + CRYPT_aes_context aes; + memset(&aes, 0, sizeof(aes)); + CRYPT_AESSetKey(&aes, 16, digest1, 32, true); uint8_t iv[16]; memset(iv, 0, 16); - CRYPT_AESSetIV(aes, iv); - CRYPT_AESEncrypt(aes, digest1, key, 32); - FX_Free(aes); + CRYPT_AESSetIV(&aes, iv); + CRYPT_AESEncrypt(&aes, digest1, key, 32); pEncryptDict->SetNewFor(bOwner ? "OE" : "UE", CFX_ByteString(digest1, 32), false); } @@ -697,13 +698,17 @@ void CPDF_SecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict, buf[9] = 'a'; buf[10] = 'd'; buf[11] = 'b'; - uint8_t* aes = FX_Alloc(uint8_t, 2048); - CRYPT_AESSetKey(aes, 16, key, 32, true); - uint8_t iv[16], buf1[16]; + + CRYPT_aes_context aes; + memset(&aes, 0, sizeof(aes)); + CRYPT_AESSetKey(&aes, 16, key, 32, true); + + uint8_t iv[16]; memset(iv, 0, 16); - CRYPT_AESSetIV(aes, iv); - CRYPT_AESEncrypt(aes, buf1, buf, 16); - FX_Free(aes); + CRYPT_AESSetIV(&aes, iv); + + uint8_t buf1[16]; + CRYPT_AESEncrypt(&aes, buf1, buf, 16); pEncryptDict->SetNewFor("Perms", CFX_ByteString(buf1, 16), false); } -- cgit v1.2.3