FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(FX_LPCBYTE password, FX_DWORD pass_size,
FX_BOOL bIgnoreEncryptMeta, FX_LPBYTE key, FX_INT32 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;
}
FX_BYTE ukeybuf[32];
if (m_Revision == 2) {
FXSYS_memcpy32(ukeybuf, defpasscode, 32);
CRYPT_ArcFourCryptBlock(ukeybuf, 32, key, key_len);
} else {
FX_BYTE test[32], tmpkey[32];
FX_DWORD copy_len = sizeof(test);
if (copy_len > (FX_DWORD)ukey.GetLength()) {
copy_len = ukey.GetLength();
}
FXSYS_memset32(test, 0, sizeof(test));
FXSYS_memset32(tmpkey, 0, sizeof(tmpkey));
FXSYS_memcpy32(test, (FX_LPCSTR)ukey, copy_len);
for (int i = 19; i >= 0; i --) {
for (int j = 0; j < key_len; j ++) {
tmpkey[j] = key[j] ^ i;
}
CRYPT_ArcFourCryptBlock(test, 32, tmpkey, key_len);
}
FX_BYTE md5[100];
CRYPT_MD5Start(md5);
CRYPT_MD5Update(md5, defpasscode, 32);
CPDF_Array* pIdArray = m_pParser->GetIDArray();
if (pIdArray) {
CFX_ByteString id = pIdArray->GetString(0);
CRYPT_MD5Update(md5, (FX_LPBYTE)(FX_LPCSTR)id, id.GetLength());
}
CRYPT_MD5Finish(md5, ukeybuf);
return FXSYS_memcmp32(test, ukeybuf, 16) == 0;
}
if (FXSYS_memcmp32((FX_LPVOID)(FX_LPCSTR)ukey, ukeybuf, 16) == 0) {
return TRUE;
}
return FALSE;
}
CPDF_IccProfile::CPDF_IccProfile(FX_LPCBYTE pData, FX_DWORD dwSize):
m_bsRGB(FALSE),
m_pTransform(NULL),
m_nSrcComponents(0)
{
if (dwSize == 3144 && FXSYS_memcmp32(pData + 0x190, "sRGB IEC61966-2.1", 17) == 0) {
m_bsRGB = TRUE;
m_nSrcComponents = 3;
}
else if (CPDF_ModuleMgr::Get()->GetIccModule()) {
m_pTransform = CPDF_ModuleMgr::Get()->GetIccModule()->CreateTransform_sRGB(pData, dwSize, m_nSrcComponents);
}
}
FX_BOOL CCodec_JpegDecoder::Create(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,
int nComps, FX_BOOL ColorTransform, IFX_JpegProvider* pJP)
{
if (pJP) {
m_pExtProvider = pJP;
m_pExtContext = m_pExtProvider->CreateDecoder(src_buf, src_size, width, height, nComps, ColorTransform);
return m_pExtContext != NULL;
}
_JpegScanSOI(src_buf, src_size);
m_SrcBuf = src_buf;
m_SrcSize = src_size;
jerr.error_exit = _error_fatal;
jerr.emit_message = _error_do_nothing1;
jerr.output_message = _error_do_nothing;
jerr.format_message = _error_do_nothing2;
jerr.reset_error_mgr = _error_do_nothing;
src.init_source = _src_do_nothing;
src.term_source = _src_do_nothing;
src.skip_input_data = _src_skip_data;
src.fill_input_buffer = _src_fill_buffer;
src.resync_to_restart = _src_resync;
m_bJpegTransform = ColorTransform;
if(src_size > 1 && FXSYS_memcmp32(src_buf + src_size - 2, "\xFF\xD9", 2) != 0) {
((FX_LPBYTE)src_buf)[src_size - 2] = 0xFF;
((FX_LPBYTE)src_buf)[src_size - 1] = 0xD9;
}
m_OutputWidth = m_OrigWidth = width;
m_OutputHeight = m_OrigHeight = height;
if (!InitDecode()) {
return FALSE;
}
if (cinfo.num_components < nComps) {
return FALSE;
}
if ((int)cinfo.image_width < width) {
return FALSE;
}
m_Pitch = (cinfo.image_width * cinfo.num_components + 3) / 4 * 4;
m_pScanlineBuf = FX_Alloc(FX_BYTE, m_Pitch);
if (m_pScanlineBuf == NULL) {
return FALSE;
}
m_nComps = cinfo.num_components;
m_bpc = 8;
m_bColorTransformed = FALSE;
m_bStarted = FALSE;
return TRUE;
}
FX_BOOL CPDF_FXMP::LoadFile(FX_LPVOID pPackage, FX_LPCSTR fileid)
{
if (m_pHeader) {
FX_Free(m_pHeader);
m_pHeader = NULL;
}
m_pTable = NULL;
FX_DWORD size;
if (!FXFC_LoadFile(pPackage, fileid, (FX_LPBYTE&)m_pHeader, size)) {
return FALSE;
}
if (FXSYS_memcmp32(m_pHeader, "FXMP", 4)) {
return FALSE;
}
m_pTable = (FX_LPBYTE)m_pHeader + m_pHeader->dwDataOffset;
return TRUE;
}
FX_BOOL CPDF_StandardSecurityHandler::AES256_CheckPassword(FX_LPCBYTE password, FX_DWORD size,
FX_BOOL bOwner, FX_LPBYTE key)
{
CFX_ByteString okey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("O")) : CFX_ByteString();
if (okey.GetLength() < 48) {
return FALSE;
}
CFX_ByteString ukey = m_pEncryptDict ? m_pEncryptDict->GetString(FX_BSTRC("U")) : CFX_ByteString();
if (ukey.GetLength() < 48) {
return FALSE;
}
FX_LPCBYTE pkey = bOwner ? (FX_LPCBYTE)okey : (FX_LPCBYTE)ukey;
FX_BYTE sha[128];
FX_BYTE digest[32];
if (m_Revision >= 6) {
Revision6_Hash(password, size, (FX_LPCBYTE)pkey + 32, (bOwner ? (FX_LPCBYTE)ukey : NULL), digest);
} else {
CRYPT_SHA256Start(sha);
CRYPT_SHA256Update(sha, password, size);
CRYPT_SHA256Update(sha, pkey + 32, 8);
if (bOwner) {
CRYPT_SHA256Update(sha, ukey, 48);
}
CRYPT_SHA256Finish(sha, digest);
}
if (FXSYS_memcmp32(digest, pkey, 32) != 0) {
return FALSE;
}
if (key == NULL) {
return TRUE;
}
if (m_Revision >= 6) {
Revision6_Hash(password, size, (FX_LPCBYTE)pkey + 40, (bOwner ? (FX_LPCBYTE)ukey : NULL), digest);
} else {
CRYPT_SHA256Start(sha);
CRYPT_SHA256Update(sha, password, size);
CRYPT_SHA256Update(sha, pkey + 40, 8);
if (bOwner) {
CRYPT_SHA256Update(sha, ukey, 48);
}
CRYPT_SHA256Finish(sha, digest);
}
CFX_ByteString ekey = m_pEncryptDict ? m_pEncryptDict->GetString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE")) : CFX_ByteString();
if (ekey.GetLength() < 32) {
return FALSE;
}
FX_BYTE* aes = FX_Alloc(FX_BYTE, 2048);
CRYPT_AESSetKey(aes, 16, digest, 32, FALSE);
FX_BYTE iv[16];
FXSYS_memset32(iv, 0, 16);
CRYPT_AESSetIV(aes, iv);
CRYPT_AESDecrypt(aes, key, ekey, 32);
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;
}
FX_BYTE perms_buf[16];
FXSYS_memset32(perms_buf, 0, sizeof(perms_buf));
FX_DWORD copy_len = sizeof(perms_buf);
if (copy_len > (FX_DWORD)perms.GetLength()) {
copy_len = perms.GetLength();
}
FXSYS_memcpy32(perms_buf, (FX_LPCBYTE)perms, copy_len);
FX_BYTE buf[16];
CRYPT_AESDecrypt(aes, buf, perms_buf, 16);
FX_Free(aes);
if (buf[9] != 'a' || buf[10] != 'd' || buf[11] != 'b') {
return FALSE;
}
if (FXDWORD_GET_LSBFIRST(buf) != m_Permissions) {
return FALSE;
}
if ((buf[8] == 'T' && !IsMetadataEncrypted()) || (buf[8] == 'F' && IsMetadataEncrypted())) {
return FALSE;
}
return TRUE;
}
FX_BOOL CPDF_Stream::Identical(CPDF_Stream* pOther) const
{
if (!m_pDict)
return pOther->m_pDict ? FALSE : TRUE;
if (!m_pDict->Identical(pOther->m_pDict)) {
return FALSE;
}
if (m_dwSize != pOther->m_dwSize) {
return FALSE;
}
if (m_GenNum != (FX_DWORD) - 1 && pOther->m_GenNum != (FX_DWORD) - 1) {
if (m_pFile == pOther->m_pFile && m_pFile == NULL) {
return TRUE;
}
if (!m_pFile || !pOther->m_pFile) {
return FALSE;
}
FX_BYTE srcBuf[1024];
FX_BYTE destBuf[1024];
FX_DWORD size = m_dwSize;
FX_DWORD srcOffset = m_FileOffset;
FX_DWORD destOffset = pOther->m_FileOffset;
if (m_pFile == pOther->m_pFile && srcOffset == destOffset) {
return TRUE;
}
while (size > 0) {
FX_DWORD actualSize = size > 1024 ? 1024 : size;
m_pFile->ReadBlock(srcBuf, srcOffset, actualSize);
pOther->m_pFile->ReadBlock(destBuf, destOffset, actualSize);
if (FXSYS_memcmp32(srcBuf, destBuf, actualSize) != 0) {
return FALSE;
}
size -= actualSize;
srcOffset += actualSize;
destOffset += actualSize;
}
return TRUE;
}
if (m_GenNum != (FX_DWORD) - 1 || pOther->m_GenNum != (FX_DWORD) - 1) {
IFX_FileRead* pFile = NULL;
FX_LPBYTE pBuf = NULL;
FX_DWORD offset = 0;
if (m_GenNum != (FX_DWORD) - 1) {
pFile = m_pFile;
pBuf = pOther->m_pDataBuf;
offset = m_FileOffset;
}
if (pOther->m_GenNum != (FX_DWORD) - 1) {
pFile = pOther->m_pFile;
pBuf = m_pDataBuf;
offset = pOther->m_FileOffset;
}
if (NULL == pBuf) {
return FALSE;
}
FX_BYTE srcBuf[1024];
FX_DWORD size = m_dwSize;
while (size > 0) {
FX_DWORD actualSize = size > 1024 ? 1024 : size;
m_pFile->ReadBlock(srcBuf, offset, actualSize);
if (FXSYS_memcmp32(srcBuf, pBuf, actualSize) != 0) {
return FALSE;
}
pBuf += actualSize;
size -= actualSize;
offset += actualSize;
}
return TRUE;
}
return FXSYS_memcmp32(m_pDataBuf, pOther->m_pDataBuf, m_dwSize) == 0;
}
void CPDF_StreamContentParser::EndImageDict()
{
if (m_StringBuf.GetSize() != m_LastImageDict.GetSize() ||
FXSYS_memcmp32(m_StringBuf.GetBuffer(), m_LastImageDict.GetBuffer(), m_StringBuf.GetSize())) {
m_WordState = 0;
StartDict();
InputData(m_StringBuf.GetBuffer(), m_StringBuf.GetSize());
Finish();
m_bSameLastDict = FALSE;
if (m_pLastImageDict && m_bReleaseLastDict) {
m_pLastImageDict->Release();
m_pLastImageDict = NULL;
}
if (!m_ObjectSize) {
m_InlineImageState = 0;
return;
}
m_pLastImageDict = (CPDF_Dictionary*)m_pObjectStack[--m_ObjectSize];
m_bReleaseLastDict = !m_pObjectState[m_ObjectSize];
m_pObjectState[m_ObjectSize] = FALSE;
_PDF_ReplaceAbbr(m_pLastImageDict);
m_LastImageDict.TakeOver(m_StringBuf);
if (m_pLastImageDict->KeyExist(FX_BSTRC("ColorSpace"))) {
CPDF_Object* pCSObj = m_pLastImageDict->GetElementValue(FX_BSTRC("ColorSpace"));
if (pCSObj->GetType() == PDFOBJ_NAME) {
CFX_ByteString name = pCSObj->GetString();
if (name != FX_BSTRC("DeviceRGB") && name != FX_BSTRC("DeviceGray") && name != FX_BSTRC("DeviceCMYK")) {
pCSObj = FindResourceObj(FX_BSTRC("ColorSpace"), name);
if (pCSObj) {
if (!pCSObj->GetObjNum()) {
pCSObj = pCSObj->Clone();
}
m_pLastImageDict->SetAt(FX_BSTRC("ColorSpace"), pCSObj, m_pDocument);
}
}
}
}
} else {
m_bSameLastDict = TRUE;
}
m_ImageSrcBuf.Clear();
if (m_pLastCloneImageDict) {
m_pLastCloneImageDict->Release();
}
m_pLastCloneImageDict = (CPDF_Dictionary*)m_pLastImageDict->Clone();
if (m_pLastCloneImageDict->KeyExist(FX_BSTRC("Filter"))) {
m_WordState = 10;
m_InlineImageState = 0;
} else {
int width = m_pLastCloneImageDict->GetInteger(FX_BSTRC("Width"));
int height = m_pLastCloneImageDict->GetInteger(FX_BSTRC("Height"));
int OrigSize = 0;
CPDF_Object* pCSObj = m_pLastCloneImageDict->GetElementValue(FX_BSTRC("ColorSpace"));
if (pCSObj != NULL) {
int bpc = m_pLastCloneImageDict->GetInteger(FX_BSTRC("BitsPerComponent"));
int nComponents = 1;
CPDF_ColorSpace* pCS = m_pDocument->LoadColorSpace(pCSObj);
if (pCS == NULL) {
nComponents = 3;
} else {
nComponents = pCS->CountComponents();
m_pDocument->GetPageData()->ReleaseColorSpace(pCSObj);
}
int pitch = (width * bpc * nComponents + 7) / 8;
OrigSize = pitch * height;
} else {
OrigSize = ((width + 7) / 8) * height;
}
m_ImageSrcBuf.AppendBlock(NULL, OrigSize);
m_WordState = 11;
m_InlineImageState = 0;
}
}