core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp - Issue 1252613002: FX_BOOL considered harmful.

Unified Diff: core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp

Issue 1252613002: FX_BOOL considered harmful. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master

Patch Set: Manual edits. Created 5 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp

diff --git a/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp b/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp

index 9f356a47483d2fb658433dadaa15e15547ad0102..ff6f0e12bdf65c9d4eb4faa0ded44ab4056fba80 100644

--- a/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp

+++ b/core/src/fpdfapi/fpdf_parser/fpdf_parser_encrypt.cpp

@@ -14,7 +14,7 @@ const uint8_t defpasscode[32] = {

0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a

};

void CalcEncryptKey(CPDF_Dictionary* pEncrypt, const uint8_t* password, FX_DWORD pass_size,

- uint8_t* key, int keylen, FX_BOOL bIgnoreMeta, CPDF_Array* pIdArray)

+ uint8_t* key, int keylen, bool bIgnoreMeta, CPDF_Array* pIdArray)

{

int revision = pEncrypt->GetInteger(FX_BSTRC("R"));

uint8_t passcode[32];

@@ -57,7 +57,7 @@ CPDF_CryptoHandler* CPDF_StandardSecurityHandler::CreateCryptoHandler()

typedef struct _PDF_CRYPTOITEM {

int32_t m_Cipher;

int32_t m_KeyLen;

- FX_BOOL m_bChecked;

+ bool m_bChecked;

CPDF_StandardCryptoHandler* m_pCryptoHandler;

} PDF_CRYPTOITEM;

CPDF_StandardSecurityHandler::CPDF_StandardSecurityHandler()

@@ -66,7 +66,7 @@ CPDF_StandardSecurityHandler::CPDF_StandardSecurityHandler()

m_Revision = 0;

m_pParser = NULL;

m_pEncryptDict = NULL;

- m_bOwner = FALSE;

+ m_bOwner = false;

m_Permissions = 0;

m_Cipher = FXCIPHER_NONE;

m_KeyLen = 0;

@@ -74,36 +74,36 @@ CPDF_StandardSecurityHandler::CPDF_StandardSecurityHandler()

CPDF_StandardSecurityHandler::~CPDF_StandardSecurityHandler()

{

}

-FX_BOOL CPDF_StandardSecurityHandler::OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict)

+bool CPDF_StandardSecurityHandler::OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict)

{

m_pParser = pParser;

if (!LoadDict(pEncryptDict)) {

- return FALSE;

+ return false;

}

if (m_Cipher == FXCIPHER_NONE) {

- return TRUE;

+ return true;

}

return CheckSecurity(m_KeyLen);

}

-FX_BOOL CPDF_StandardSecurityHandler::CheckSecurity(int32_t key_len)

+bool CPDF_StandardSecurityHandler::CheckSecurity(int32_t key_len)

{

CFX_ByteString password = m_pParser->GetPassword();

- if (CheckPassword(password, password.GetLength(), TRUE, m_EncryptKey, key_len)) {

+ if (CheckPassword(password, password.GetLength(), true, m_EncryptKey, key_len)) {

if (password.IsEmpty()) {

- if (!CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey, key_len)) {

- return FALSE;

+ if (!CheckPassword(password, password.GetLength(), false, m_EncryptKey, key_len)) {

+ return false;

}

- m_bOwner = TRUE;

- return TRUE;

+ m_bOwner = true;

+ return true;

}

- return CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey, key_len);

+ return CheckPassword(password, password.GetLength(), false, m_EncryptKey, key_len);

}

FX_DWORD CPDF_StandardSecurityHandler::GetPermissions()

{

return m_Permissions;

}

-static FX_BOOL _LoadCryptInfo(CPDF_Dictionary* pEncryptDict, const CFX_ByteStringC& name, int& cipher, int& keylen)

+static bool _LoadCryptInfo(CPDF_Dictionary* pEncryptDict, const CFX_ByteStringC& name, int& cipher, int& keylen)

{

int Version = pEncryptDict->GetInteger(FX_BSTRC("V"));

cipher = FXCIPHER_RC4;

@@ -111,14 +111,14 @@ static FX_BOOL _LoadCryptInfo(CPDF_Dictionary* pEncryptDict, const CFX_ByteStrin

if (Version >= 4) {

CPDF_Dictionary* pCryptFilters = pEncryptDict->GetDict(FX_BSTRC("CF"));

if (pCryptFilters == NULL) {

- return FALSE;

+ return false;

}

if (name == FX_BSTRC("Identity")) {

cipher = FXCIPHER_NONE;

} else {

CPDF_Dictionary* pDefFilter = pCryptFilters->GetDict(name);

if (pDefFilter == NULL) {

- return FALSE;

+ return false;

}

int nKeyBits = 0;

if (Version == 4) {

@@ -142,14 +142,14 @@ static FX_BOOL _LoadCryptInfo(CPDF_Dictionary* pEncryptDict, const CFX_ByteStrin

keylen = Version > 1 ? pEncryptDict->GetInteger(FX_BSTRC("Length"), 40) / 8 : 5;

}

if (keylen > 32 || keylen < 0) {

- return FALSE;

+ return false;

}

- return TRUE;

+ return true;

}

-FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict)

+bool CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict)

{

m_pEncryptDict = pEncryptDict;

- m_bOwner = FALSE;

+ m_bOwner = false;

m_Version = pEncryptDict->GetInteger(FX_BSTRC("V"));

m_Revision = pEncryptDict->GetInteger(FX_BSTRC("R"));

m_Permissions = pEncryptDict->GetInteger(FX_BSTRC("P"), -1);

@@ -159,17 +159,17 @@ FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict)

CFX_ByteString stmf_name = pEncryptDict->GetString(FX_BSTRC("StmF"));

CFX_ByteString strf_name = pEncryptDict->GetString(FX_BSTRC("StrF"));

if (stmf_name != strf_name) {

- return FALSE;

+ return false;

}

if (!_LoadCryptInfo(pEncryptDict, strf_name, m_Cipher, m_KeyLen)) {

- return FALSE;

+ return false;

}

- return TRUE;

+ return true;

}

-FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict, FX_DWORD type, int& cipher, int& key_len)

+bool CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict, FX_DWORD type, int& cipher, int& key_len)

{

m_pEncryptDict = pEncryptDict;

- m_bOwner = FALSE;

+ m_bOwner = false;

m_Version = pEncryptDict->GetInteger(FX_BSTRC("V"));

m_Revision = pEncryptDict->GetInteger(FX_BSTRC("R"));

m_Permissions = pEncryptDict->GetInteger(FX_BSTRC("P"), -1);

@@ -178,23 +178,23 @@ FX_BOOL CPDF_StandardSecurityHandler::LoadDict(CPDF_Dictionary* pEncryptDict, FX

stmf_name = pEncryptDict->GetString(FX_BSTRC("StmF"));

strf_name = pEncryptDict->GetString(FX_BSTRC("StrF"));

if (stmf_name != strf_name) {

- return FALSE;

+ return false;

}

if (!_LoadCryptInfo(pEncryptDict, strf_name, cipher, key_len)) {

- return FALSE;

+ return false;

}

m_Cipher = cipher;

m_KeyLen = key_len;

- return TRUE;

+ return true;

}

-FX_BOOL CPDF_StandardSecurityHandler::GetCryptInfo(int& cipher, const uint8_t*& buffer, int& keylen)

+bool CPDF_StandardSecurityHandler::GetCryptInfo(int& cipher, const uint8_t*& buffer, int& keylen)

{

cipher = m_Cipher;

buffer = m_EncryptKey;

keylen = m_KeyLen;

- return TRUE;

+ return true;

}

#define FX_GET_32WORD(n,b,i) \

{ \

@@ -252,7 +252,7 @@ void Revision6_Hash(const uint8_t* password, FX_DWORD size, const uint8_t* salt,

content.AppendBlock(vector, 48);

}

- CRYPT_AESSetKey(aes, 16, key, 16, TRUE);

+ CRYPT_AESSetKey(aes, 16, key, 16, true);

CRYPT_AESSetIV(aes, iv);

CRYPT_AESEncrypt(aes, E, content.GetBuffer(), iBufLen);

int iHash = 0;

@@ -288,16 +288,16 @@ void Revision6_Hash(const uint8_t* password, FX_DWORD size, const uint8_t* salt,

FXSYS_memcpy(hash, input, 32);

}

-FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* password, FX_DWORD size,

- FX_BOOL bOwner, uint8_t* key)

+bool CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* password, FX_DWORD size,

+ bool bOwner, uint8_t* key)

{

CFX_ByteString okey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("O")) : CFX_ByteString();

if (okey.GetLength() < 48) {

- return FALSE;

+ return false;

}

CFX_ByteString ukey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("U")) : CFX_ByteString();

if (ukey.GetLength() < 48) {

- return FALSE;

+ return false;

}

const uint8_t* pkey = bOwner ? (const uint8_t*)okey : (const uint8_t*)ukey;

uint8_t sha[128];

@@ -314,10 +314,10 @@ FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* passwo

CRYPT_SHA256Finish(sha, digest);

}

if (FXSYS_memcmp(digest, pkey, 32) != 0) {

- return FALSE;

+ return false;

}

if (key == NULL) {

- return TRUE;

+ return true;

}

if (m_Revision >= 6) {

Revision6_Hash(password, size, (const uint8_t*)pkey + 40, (bOwner ? (const uint8_t*)ukey : NULL), digest);

@@ -332,19 +332,19 @@ FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* passwo

}

CFX_ByteString ekey = m_pEncryptDict ? m_pEncryptDict->GetString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE")) : CFX_ByteString();

if (ekey.GetLength() < 32) {

- return FALSE;

+ return false;

}

uint8_t* aes = FX_Alloc(uint8_t, 2048);

- CRYPT_AESSetKey(aes, 16, digest, 32, FALSE);

+ CRYPT_AESSetKey(aes, 16, digest, 32, false);

uint8_t iv[16];

FXSYS_memset(iv, 0, 16);

CRYPT_AESSetIV(aes, iv);

CRYPT_AESDecrypt(aes, key, ekey, 32);

- CRYPT_AESSetKey(aes, 16, key, 32, FALSE);

+ CRYPT_AESSetKey(aes, 16, key, 32, false);

CRYPT_AESSetIV(aes, iv);

CFX_ByteString perms = m_pEncryptDict->GetString(FX_BSTRC("Perms"));

if (perms.IsEmpty()) {

- return FALSE;

+ return false;

}

uint8_t perms_buf[16];

FXSYS_memset(perms_buf, 0, sizeof(perms_buf));

@@ -357,21 +357,21 @@ FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(const uint8_t* passwo

CRYPT_AESDecrypt(aes, buf, perms_buf, 16);

FX_Free(aes);

if (buf[9] != 'a' || buf[10] != 'd' || buf[11] != 'b') {

- return FALSE;

+ return false;

}

if (FXDWORD_GET_LSBFIRST(buf) != m_Permissions) {

- return FALSE;

+ return false;

}

if ((buf[8] == 'T' && !IsMetadataEncrypted()) || (buf[8] == 'F' && IsMetadataEncrypted())) {

- return FALSE;

+ return false;

}

- return TRUE;

+ return true;

}

-int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWORD pass_size, FX_BOOL bOwner, uint8_t* key)

+int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWORD pass_size, bool bOwner, uint8_t* key)

{

return CheckPassword(password, pass_size, bOwner, key, m_KeyLen);

}

-int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWORD size, FX_BOOL bOwner, uint8_t* key, int32_t key_len)

+int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWORD size, bool bOwner, uint8_t* key, int32_t key_len)

{

if (m_Revision >= 5) {

return AES256_CheckPassword(password, size, bOwner, key);

@@ -383,16 +383,16 @@ int CPDF_StandardSecurityHandler::CheckPassword(const uint8_t* password, FX_DWOR

if (bOwner) {

return CheckOwnerPassword(password, size, key, key_len);

}

- return CheckUserPassword(password, size, FALSE, key, key_len) || CheckUserPassword(password, size, TRUE, key, key_len);

+ return CheckUserPassword(password, size, false, key, key_len) || CheckUserPassword(password, size, true, key, key_len);

}

-FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(const uint8_t* password, FX_DWORD pass_size,

- FX_BOOL bIgnoreEncryptMeta, uint8_t* key, int32_t key_len)

+bool CPDF_StandardSecurityHandler::CheckUserPassword(const uint8_t* password, FX_DWORD pass_size,

+ bool bIgnoreEncryptMeta, uint8_t* key, int32_t key_len)

{

CalcEncryptKey(m_pEncryptDict, password, pass_size, key, key_len, bIgnoreEncryptMeta,

m_pParser->GetIDArray());

CFX_ByteString ukey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("U")) : CFX_ByteString();

if (ukey.GetLength() < 16) {

- return FALSE;

+ return false;

}

uint8_t ukeybuf[32];

if (m_Revision == 2) {

@@ -425,9 +425,9 @@ FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(const uint8_t* password,

return FXSYS_memcmp(test, ukeybuf, 16) == 0;

}

if (FXSYS_memcmp((void*)ukey.c_str(), ukeybuf, 16) == 0) {

- return TRUE;

+ return true;

}

- return FALSE;

+ return false;

}

CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(const uint8_t* owner_pass, FX_DWORD pass_size)

{

@@ -480,18 +480,18 @@ CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(const uint8_t* owne

}

return CFX_ByteString(okeybuf, len);

}

-FX_BOOL CPDF_StandardSecurityHandler::CheckOwnerPassword(const uint8_t* password, FX_DWORD pass_size,

+bool CPDF_StandardSecurityHandler::CheckOwnerPassword(const uint8_t* password, FX_DWORD pass_size,

uint8_t* key, int32_t key_len)

{

CFX_ByteString user_pass = GetUserPassword(password, pass_size, key_len);

- if (CheckUserPassword(user_pass, user_pass.GetLength(), FALSE, key, key_len)) {

- return TRUE;

+ if (CheckUserPassword(user_pass, user_pass.GetLength(), false, key, key_len)) {

+ return true;

}

- return CheckUserPassword(user_pass, user_pass.GetLength(), TRUE, key, key_len);

+ return CheckUserPassword(user_pass, user_pass.GetLength(), true, key, key_len);

}

-FX_BOOL CPDF_StandardSecurityHandler::IsMetadataEncrypted()

+bool CPDF_StandardSecurityHandler::IsMetadataEncrypted()

{

- return m_pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), TRUE);

+ return m_pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), true);

}

CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler()

{

@@ -499,7 +499,7 @@ CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler()

}

void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,

const uint8_t* user_pass, FX_DWORD user_size,

- const uint8_t* owner_pass, FX_DWORD owner_size, FX_BOOL bDefault, FX_DWORD type)

+ const uint8_t* owner_pass, FX_DWORD owner_size, bool bDefault, FX_DWORD type)

{

int cipher = 0, key_len = 0;

if (!LoadDict(pEncryptDict, type, cipher, key_len)) {

@@ -517,10 +517,10 @@ void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_

CRYPT_SHA256Update(sha, m_EncryptKey, 32);

CRYPT_SHA256Update(sha, (uint8_t*)"there", 5);

CRYPT_SHA256Finish(sha, m_EncryptKey);

- AES256_SetPassword(pEncryptDict, user_pass, user_size, FALSE, m_EncryptKey);

+ AES256_SetPassword(pEncryptDict, user_pass, user_size, false, m_EncryptKey);

if (bDefault) {

- AES256_SetPassword(pEncryptDict, owner_pass, owner_size, TRUE, m_EncryptKey);

- AES256_SetPerms(pEncryptDict, m_Permissions, pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), TRUE), m_EncryptKey);

+ AES256_SetPassword(pEncryptDict, owner_pass, owner_size, true, m_EncryptKey);

+ AES256_SetPerms(pEncryptDict, m_Permissions, pEncryptDict->GetBoolean(FX_BSTRC("EncryptMetadata"), true), m_EncryptKey);

}

return;

}

@@ -554,7 +554,7 @@ void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_

}

pEncryptDict->SetAtString(FX_BSTRC("O"), CFX_ByteString(passcode, 32));

}

- CalcEncryptKey(m_pEncryptDict, (uint8_t*)user_pass, user_size, m_EncryptKey, key_len, FALSE, pIdArray);

+ CalcEncryptKey(m_pEncryptDict, (uint8_t*)user_pass, user_size, m_EncryptKey, key_len, false, pIdArray);

if (m_Revision < 3) {

uint8_t tempbuf[32];

FXSYS_memcpy(tempbuf, defpasscode, 32);

@@ -586,13 +586,13 @@ void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_

const uint8_t* user_pass, FX_DWORD user_size,

const uint8_t* owner_pass, FX_DWORD owner_size, FX_DWORD type)

{

- OnCreate(pEncryptDict, pIdArray, user_pass, user_size, owner_pass, owner_size, TRUE, type);

+ OnCreate(pEncryptDict, pIdArray, user_pass, user_size, owner_pass, owner_size, true, type);

}

void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray, const uint8_t* user_pass, FX_DWORD user_size, FX_DWORD type)

{

- OnCreate(pEncryptDict, pIdArray, user_pass, user_size, NULL, 0, FALSE, type);

+ OnCreate(pEncryptDict, pIdArray, user_pass, user_size, NULL, 0, false, type);

}

-void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, const uint8_t* password, FX_DWORD size, FX_BOOL bOwner, const uint8_t* key)

+void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, const uint8_t* password, FX_DWORD size, bool bOwner, const uint8_t* key)

{

uint8_t sha[128];

CRYPT_SHA1Start(sha);

@@ -627,7 +627,7 @@ void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptD

CRYPT_SHA256Finish(sha, digest1);

}

uint8_t* aes = FX_Alloc(uint8_t, 2048);

- CRYPT_AESSetKey(aes, 16, digest1, 32, TRUE);

+ CRYPT_AESSetKey(aes, 16, digest1, 32, true);

uint8_t iv[16];

FXSYS_memset(iv, 0, 16);

CRYPT_AESSetIV(aes, iv);

@@ -636,7 +636,7 @@ void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptD

pEncryptDict->SetAtString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE"), CFX_ByteString(digest1, 32));

}

void CPDF_StandardSecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict, FX_DWORD permissions,

- FX_BOOL bEncryptMetadata, const uint8_t* key)

+ bool bEncryptMetadata, const uint8_t* key)

{

uint8_t buf[16];

buf[0] = (uint8_t)permissions;

@@ -652,7 +652,7 @@ void CPDF_StandardSecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict

buf[10] = 'd';

buf[11] = 'b';

uint8_t* aes = FX_Alloc(uint8_t, 2048);

- CRYPT_AESSetKey(aes, 16, key, 32, TRUE);

+ CRYPT_AESSetKey(aes, 16, key, 32, true);

uint8_t iv[16], buf1[16];

FXSYS_memset(iv, 0, 16);

CRYPT_AESSetIV(aes, iv);

@@ -660,7 +660,7 @@ void CPDF_StandardSecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict

FX_Free(aes);

pEncryptDict->SetAtString(FX_BSTRC("Perms"), CFX_ByteString(buf1, 16));

}

-void CPDF_StandardCryptoHandler::CryptBlock(FX_BOOL bEncrypt, FX_DWORD objnum, FX_DWORD gennum, const uint8_t* src_buf, FX_DWORD src_size,

+void CPDF_StandardCryptoHandler::CryptBlock(bool bEncrypt, FX_DWORD objnum, FX_DWORD gennum, const uint8_t* src_buf, FX_DWORD src_size,

uint8_t* dest_buf, FX_DWORD& dest_size)

{

if (m_Cipher == FXCIPHER_NONE) {

@@ -720,18 +720,18 @@ void CPDF_StandardCryptoHandler::CryptBlock(FX_BOOL bEncrypt, FX_DWORD objnum, F

}

typedef struct _AESCryptContext {

uint8_t m_Context[2048];

- FX_BOOL m_bIV;

+ bool m_bIV;

uint8_t m_Block[16];

FX_DWORD m_BlockOffset;

} AESCryptContext;

-void* CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum, FX_DWORD gennum, FX_BOOL bEncrypt)

+void* CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum, FX_DWORD gennum, bool bEncrypt)

{

if (m_Cipher == FXCIPHER_NONE) {

return this;

}

if (m_Cipher == FXCIPHER_AES && m_KeyLen == 32) {

AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);

- pContext->m_bIV = TRUE;

+ pContext->m_bIV = true;

pContext->m_BlockOffset = 0;

CRYPT_AESSetKey(pContext->m_Context, 16, m_EncryptKey, 32, bEncrypt);

if (bEncrypt) {

@@ -757,7 +757,7 @@ void* CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum, FX_DWORD gennum, F

}

if (m_Cipher == FXCIPHER_AES) {

AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);

- pContext->m_bIV = TRUE;

+ pContext->m_bIV = true;

pContext->m_BlockOffset = 0;

CRYPT_AESSetKey(pContext->m_Context, 16, realkey, 16, bEncrypt);

if (bEncrypt) {

@@ -772,25 +772,25 @@ void* CPDF_StandardCryptoHandler::CryptStart(FX_DWORD objnum, FX_DWORD gennum, F

CRYPT_ArcFourSetup(pContext, realkey, realkeylen);

return pContext;

}

-FX_BOOL CPDF_StandardCryptoHandler::CryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt)

+bool CPDF_StandardCryptoHandler::CryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf, bool bEncrypt)

{

if (!context) {

- return FALSE;

+ return false;

}

if (m_Cipher == FXCIPHER_NONE) {

dest_buf.AppendBlock(src_buf, src_size);

- return TRUE;

+ return true;

}

if (m_Cipher == FXCIPHER_RC4) {

int old_size = dest_buf.GetSize();

dest_buf.AppendBlock(src_buf, src_size);

CRYPT_ArcFourCrypt(context, dest_buf.GetBuffer() + old_size, src_size);

- return TRUE;

+ return true;

}

AESCryptContext* pContext = (AESCryptContext*)context;

if (pContext->m_bIV && bEncrypt) {

dest_buf.AppendBlock(pContext->m_Block, 16);

- pContext->m_bIV = FALSE;

+ pContext->m_bIV = false;

}

FX_DWORD src_off = 0;

FX_DWORD src_left = src_size;

@@ -806,7 +806,7 @@ FX_BOOL CPDF_StandardCryptoHandler::CryptStream(void* context, const uint8_t* sr

if (pContext->m_BlockOffset == 16) {

if (!bEncrypt && pContext->m_bIV) {

CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);

- pContext->m_bIV = FALSE;

+ pContext->m_bIV = false;

pContext->m_BlockOffset = 0;

} else if (src_off < src_size) {

uint8_t block_buf[16];

@@ -823,19 +823,19 @@ FX_BOOL CPDF_StandardCryptoHandler::CryptStream(void* context, const uint8_t* sr

break;

}

- return TRUE;

+ return true;

}

-FX_BOOL CPDF_StandardCryptoHandler::CryptFinish(void* context, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt)

+bool CPDF_StandardCryptoHandler::CryptFinish(void* context, CFX_BinaryBuf& dest_buf, bool bEncrypt)

{

if (!context) {

- return FALSE;

+ return false;

}

if (m_Cipher == FXCIPHER_NONE) {

- return TRUE;

+ return true;

}

if (m_Cipher == FXCIPHER_RC4) {

FX_Free(context);

- return TRUE;

+ return true;

}

AESCryptContext* pContext = (AESCryptContext*)context;

if (bEncrypt) {

@@ -856,24 +856,24 @@ FX_BOOL CPDF_StandardCryptoHandler::CryptFinish(void* context, CFX_BinaryBuf& de

}

FX_Free(pContext);

- return TRUE;

+ return true;

}

void* CPDF_StandardCryptoHandler::DecryptStart(FX_DWORD objnum, FX_DWORD gennum)

{

- return CryptStart(objnum, gennum, FALSE);

+ return CryptStart(objnum, gennum, false);

}

FX_DWORD CPDF_StandardCryptoHandler::DecryptGetSize(FX_DWORD src_size)

{

return m_Cipher == FXCIPHER_AES ? src_size - 16 : src_size;

}

-FX_BOOL CPDF_StandardCryptoHandler::Init(CPDF_Dictionary* pEncryptDict, CPDF_SecurityHandler* pSecurityHandler)

+bool CPDF_StandardCryptoHandler::Init(CPDF_Dictionary* pEncryptDict, CPDF_SecurityHandler* pSecurityHandler)

{

const uint8_t* key;

if (!pSecurityHandler->GetCryptInfo(m_Cipher, key, m_KeyLen)) {

- return FALSE;

+ return false;

}

if (m_KeyLen > 32 || m_KeyLen < 0) {

- return FALSE;

+ return false;

}

if (m_Cipher != FXCIPHER_NONE) {

FXSYS_memcpy(m_EncryptKey, key, m_KeyLen);

@@ -881,9 +881,9 @@ FX_BOOL CPDF_StandardCryptoHandler::Init(CPDF_Dictionary* pEncryptDict, CPDF_Sec

if (m_Cipher == FXCIPHER_AES) {

m_pAESContext = FX_Alloc(uint8_t, 2048);

}

- return TRUE;

+ return true;

}

-FX_BOOL CPDF_StandardCryptoHandler::Init(int cipher, const uint8_t* key, int keylen)

+bool CPDF_StandardCryptoHandler::Init(int cipher, const uint8_t* key, int keylen)

{

if (cipher == FXCIPHER_AES) {

switch(keylen) {

@@ -892,15 +892,15 @@ FX_BOOL CPDF_StandardCryptoHandler::Init(int cipher, const uint8_t* key, int key

case 32:

break;

default:

- return FALSE;

+ return false;

}

} else if (cipher == FXCIPHER_AES2) {

if (keylen != 32) {

- return FALSE;

+ return false;

}

} else if (cipher == FXCIPHER_RC4) {

if (keylen < 5 || keylen > 16) {

- return FALSE;

+ return false;

}

} else {

if (keylen > 32) {

@@ -913,16 +913,16 @@ FX_BOOL CPDF_StandardCryptoHandler::Init(int cipher, const uint8_t* key, int key

if (m_Cipher == FXCIPHER_AES) {

m_pAESContext = FX_Alloc(uint8_t, 2048);

}

- return TRUE;

+ return true;

}

-FX_BOOL CPDF_StandardCryptoHandler::DecryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size,

+bool CPDF_StandardCryptoHandler::DecryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size,

CFX_BinaryBuf& dest_buf)

{

- return CryptStream(context, src_buf, src_size, dest_buf, FALSE);

+ return CryptStream(context, src_buf, src_size, dest_buf, false);

}

-FX_BOOL CPDF_StandardCryptoHandler::DecryptFinish(void* context, CFX_BinaryBuf& dest_buf)

+bool CPDF_StandardCryptoHandler::DecryptFinish(void* context, CFX_BinaryBuf& dest_buf)

{

- return CryptFinish(context, dest_buf, FALSE);

+ return CryptFinish(context, dest_buf, false);

}

FX_DWORD CPDF_StandardCryptoHandler::EncryptGetSize(FX_DWORD objnum, FX_DWORD version, const uint8_t* src_buf, FX_DWORD src_size)

{

@@ -931,11 +931,11 @@ FX_DWORD CPDF_StandardCryptoHandler::EncryptGetSize(FX_DWORD objnum, FX_DWORD ve

}

return src_size;

}

-FX_BOOL CPDF_StandardCryptoHandler::EncryptContent(FX_DWORD objnum, FX_DWORD gennum, const uint8_t* src_buf, FX_DWORD src_size,

+bool CPDF_StandardCryptoHandler::EncryptContent(FX_DWORD objnum, FX_DWORD gennum, const uint8_t* src_buf, FX_DWORD src_size,

uint8_t* dest_buf, FX_DWORD& dest_size)

{

- CryptBlock(TRUE, objnum, gennum, src_buf, src_size, dest_buf, dest_size);

- return TRUE;

+ CryptBlock(true, objnum, gennum, src_buf, src_size, dest_buf, dest_size);

+ return true;

}

void CPDF_CryptoHandler::Decrypt(FX_DWORD objnum, FX_DWORD gennum, CFX_ByteString& str)

{

« no previous file with comments | « core/src/fpdfapi/fpdf_parser/fpdf_parser_document.cpp ('k') | core/src/fpdfapi/fpdf_parser/fpdf_parser_fdf.cpp » ('j') | no next file with comments »