FX_BOOL CFX_BasicArray::SetSize(int nNewSize, int nGrowBy)
{
if (nNewSize < 0 || nNewSize > (1 << 28) / m_nUnitSize) {
if (m_pData != NULL) {
FX_Allocator_Free(m_pAllocator, m_pData);
m_pData = NULL;
}
m_nSize = m_nMaxSize = 0;
return FALSE;
}
if (nGrowBy >= 0) {
m_nGrowBy = nGrowBy;
}
if (nNewSize == 0) {
if (m_pData != NULL) {
FX_Allocator_Free(m_pAllocator, m_pData);
m_pData = NULL;
}
m_nSize = m_nMaxSize = 0;
} else if (m_pData == NULL) {
m_pData = FX_Allocator_Alloc(m_pAllocator, FX_BYTE, nNewSize * m_nUnitSize);
if (!m_pData) {
m_nSize = m_nMaxSize = 0;
return FALSE;
}
FXSYS_memset32(m_pData, 0, nNewSize * m_nUnitSize);
m_nSize = m_nMaxSize = nNewSize;
} else if (nNewSize <= m_nMaxSize) {
if (nNewSize > m_nSize) {
FXSYS_memset32(m_pData + m_nSize * m_nUnitSize, 0, (nNewSize - m_nSize) * m_nUnitSize);
}
m_nSize = nNewSize;
} else {
int nGrowBy = m_nGrowBy;
if (nGrowBy == 0) {
nGrowBy = m_nSize / 8;
nGrowBy = (nGrowBy < 4) ? 4 : ((nGrowBy > 1024) ? 1024 : nGrowBy);
}
int nNewMax;
if (nNewSize < m_nMaxSize + nGrowBy) {
nNewMax = m_nMaxSize + nGrowBy;
} else {
nNewMax = nNewSize;
}
FX_LPBYTE pNewData = FX_Allocator_Realloc(m_pAllocator, FX_BYTE, m_pData, nNewMax * m_nUnitSize);
if (pNewData == NULL) {
return FALSE;
}
FXSYS_memset32(pNewData + m_nSize * m_nUnitSize, 0, (nNewMax - m_nSize) * m_nUnitSize);
m_pData = pNewData;
m_nSize = nNewSize;
m_nMaxSize = nNewMax;
}
return TRUE;
}
CCodec_JpegDecoder::CCodec_JpegDecoder()
{
m_pScanlineBuf = NULL;
m_DownScale = 1;
m_bStarted = FALSE;
m_bInited = FALSE;
m_pExtProvider = NULL;
m_pExtContext = NULL;
FXSYS_memset32(&cinfo, 0, sizeof(cinfo));
FXSYS_memset32(&jerr, 0, sizeof(jerr));
FXSYS_memset32(&src, 0, sizeof(src));
m_nDefaultScaleDenom = 1;
}
void CPDF_StandardSecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict, FX_DWORD permissions,
FX_BOOL bEncryptMetadata, FX_LPCBYTE key)
{
FX_BYTE buf[16];
buf[0] = (FX_BYTE)permissions;
buf[1] = (FX_BYTE)(permissions >> 8);
buf[2] = (FX_BYTE)(permissions >> 16);
buf[3] = (FX_BYTE)(permissions >> 24);
buf[4] = 0xff;
buf[5] = 0xff;
buf[6] = 0xff;
buf[7] = 0xff;
buf[8] = bEncryptMetadata ? 'T' : 'F';
buf[9] = 'a';
buf[10] = 'd';
buf[11] = 'b';
FX_BYTE* aes = FX_Alloc(FX_BYTE, 2048);
CRYPT_AESSetKey(aes, 16, key, 32, TRUE);
FX_BYTE iv[16], buf1[16];
FXSYS_memset32(iv, 0, 16);
CRYPT_AESSetIV(aes, iv);
CRYPT_AESEncrypt(aes, buf1, buf, 16);
FX_Free(aes);
pEncryptDict->SetAtString(FX_BSTRC("Perms"), CFX_ByteString(buf1, 16));
}
FXFT_Face CFPF_SkiaFontMgr::GetFontFace(IFX_FileRead *pFileRead, FX_INT32 iFaceIndex)
{
if (!pFileRead) {
return NULL;
}
if (pFileRead->GetSize() == 0) {
return NULL;
}
if (iFaceIndex < 0) {
return NULL;
}
FXFT_StreamRec streamRec;
FXSYS_memset32(&streamRec, 0, sizeof(FXFT_StreamRec));
streamRec.size = pFileRead->GetSize();
streamRec.descriptor.pointer = pFileRead;
streamRec.read = FPF_SkiaStream_Read;
streamRec.close = FPF_SkiaStream_Close;
FXFT_Open_Args args;
args.flags = FT_OPEN_STREAM;
args.stream = &streamRec;
FXFT_Face face;
if (FXFT_Open_Face(m_FTLibrary, &args, iFaceIndex, &face)) {
return NULL;
}
FXFT_Set_Pixel_Sizes(face, 0, 64);
return face;
}
void CPDF_ContentParser::Start(CPDF_Page* pPage, CPDF_ParseOptions* pOptions)
{
if (m_Status != Ready || pPage == NULL || pPage->m_pDocument == NULL || pPage->m_pFormDict == NULL) {
m_Status = Done;
return;
}
m_pObjects = pPage;
m_bForm = FALSE;
if (pOptions) {
m_Options = *pOptions;
}
m_Status = ToBeContinued;
m_InternalStage = PAGEPARSE_STAGE_GETCONTENT;
m_CurrentOffset = 0;
CPDF_Object* pContent = pPage->m_pFormDict->GetElementValue(FX_BSTRC("Contents"));
if (pContent == NULL) {
m_Status = Done;
return;
}
if (pContent->GetType() == PDFOBJ_STREAM) {
m_nStreams = 0;
m_pSingleStream = FX_NEW CPDF_StreamAcc;
m_pSingleStream->LoadAllData((CPDF_Stream*)pContent, FALSE);
} else if (pContent->GetType() == PDFOBJ_ARRAY) {
CPDF_Array* pArray = (CPDF_Array*)pContent;
m_nStreams = pArray->GetCount();
if (m_nStreams == 0) {
m_Status = Done;
return;
}
m_pStreamArray = FX_Alloc(CPDF_StreamAcc*, m_nStreams);
FXSYS_memset32(m_pStreamArray, 0, sizeof(CPDF_StreamAcc*) * m_nStreams);
} else {
void* CFX_BaseSegmentedArray::Add()
{
if (m_DataSize % m_SegmentSize) {
return GetAt(m_DataSize ++);
}
void* pSegment = FX_Allocator_Alloc(m_pAllocator, FX_BYTE, m_UnitSize * m_SegmentSize);
if (!pSegment) {
return NULL;
}
if (m_pIndex == NULL) {
m_pIndex = pSegment;
m_DataSize ++;
return pSegment;
}
if (m_IndexDepth == 0) {
void** pIndex = (void**)FX_Allocator_Alloc(m_pAllocator, void*, m_IndexSize);
if (pIndex == NULL) {
FX_Allocator_Free(m_pAllocator, pSegment);
return NULL;
}
FXSYS_memset32(pIndex, 0, sizeof(void*) * m_IndexSize);
pIndex[0] = m_pIndex;
pIndex[1] = pSegment;
m_pIndex = pIndex;
m_DataSize ++;
m_IndexDepth ++;
return pSegment;
}
int CPDF_Object::GetInteger() const
{
CFX_AutoRestorer<int> restorer(&s_nCurRefDepth);
if (++s_nCurRefDepth > OBJECT_REF_MAX_DEPTH) {
return 0;
}
switch (m_Type) {
case PDFOBJ_BOOLEAN:
return ((CPDF_Boolean*)this)->m_bValue;
case PDFOBJ_NUMBER:
return ((CPDF_Number*)this)->GetInteger();
case PDFOBJ_REFERENCE: {
CPDF_Reference* pRef = (CPDF_Reference*)(FX_LPVOID)this;
PARSE_CONTEXT context;
FXSYS_memset32(&context, 0, sizeof(PARSE_CONTEXT));
if (pRef->m_pObjList == NULL) {
return 0;
}
CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum, &context);
if (pObj == NULL) {
return 0;
}
return pObj->GetInteger();
}
}
return 0;
}
CFX_ByteString CPDF_StandardSecurityHandler::GetUserPassword(FX_LPCBYTE owner_pass, FX_DWORD pass_size, FX_INT32 key_len)
{
CFX_ByteString okey = m_pEncryptDict->GetString(FX_BSTRC("O"));
FX_BYTE passcode[32];
FX_DWORD i;
for (i = 0; i < 32; i ++) {
passcode[i] = i < pass_size ? owner_pass[i] : defpasscode[i - pass_size];
}
FX_BYTE digest[16];
CRYPT_MD5Generate(passcode, 32, digest);
if (m_Revision >= 3) {
for (int i = 0; i < 50; i ++) {
CRYPT_MD5Generate(digest, 16, digest);
}
}
FX_BYTE enckey[32];
FXSYS_memset32(enckey, 0, sizeof(enckey));
FX_DWORD copy_len = key_len;
if (copy_len > sizeof(digest)) {
copy_len = sizeof(digest);
}
FXSYS_memcpy32(enckey, digest, copy_len);
int okeylen = okey.GetLength();
if (okeylen > 32) {
okeylen = 32;
}
FX_BYTE okeybuf[64];
FXSYS_memset32(okeybuf, 0, sizeof(okeybuf));
FXSYS_memcpy32(okeybuf, (FX_LPCSTR)okey, okeylen);
if (m_Revision == 2) {
CRYPT_ArcFourCryptBlock(okeybuf, okeylen, enckey, key_len);
} else {
for (int i = 19; i >= 0; i --) {
FX_BYTE tempkey[32];
FXSYS_memset32(tempkey, 0, sizeof(tempkey));
for (int j = 0; j < m_KeyLen; j ++) {
tempkey[j] = enckey[j] ^ i;
}
CRYPT_ArcFourCryptBlock(okeybuf, okeylen, tempkey, key_len);
}
}
int len = 32;
while (len && defpasscode[len - 1] == okeybuf[len - 1]) {
len --;
}
return CFX_ByteString(okeybuf, len);
}
CFX_FontMapper::CFX_FontMapper()
{
FXSYS_memset32(m_FoxitFaces, 0, sizeof m_FoxitFaces);
m_MMFaces[0] = m_MMFaces[1] = NULL;
m_pFontInfo = NULL;
m_bListLoaded = FALSE;
m_pFontEnumerator = NULL;
}
FX_BOOL CCodec_RLScanlineDecoder::v_Rewind()
{
FXSYS_memset32(m_pScanline, 0, m_Pitch);
m_SrcOffset = 0;
m_bEOD = FALSE;
m_Operator = 0;
return TRUE;
}
FX_BOOL CFX_BasicArray::SetSize(int nNewSize)
{
if (nNewSize <= 0) {
FX_Free(m_pData);
m_pData = NULL;
m_nSize = m_nMaxSize = 0;
return 0 == nNewSize;
}
if (m_pData == NULL) {
pdfium::base::CheckedNumeric<int> totalSize = nNewSize;
totalSize *= m_nUnitSize;
if (!totalSize.IsValid()) {
m_nSize = m_nMaxSize = 0;
return FALSE;
}
m_pData = FX_Alloc(FX_BYTE, totalSize.ValueOrDie());
if (!m_pData) {
m_nSize = m_nMaxSize = 0;
return FALSE;
}
m_nSize = m_nMaxSize = nNewSize;
} else if (nNewSize <= m_nMaxSize) {
if (nNewSize > m_nSize) {
FXSYS_memset32(m_pData + m_nSize * m_nUnitSize, 0, (nNewSize - m_nSize) * m_nUnitSize);
}
m_nSize = nNewSize;
} else {
int nNewMax = nNewSize < m_nMaxSize ? m_nMaxSize : nNewSize;
pdfium::base::CheckedNumeric<int> totalSize = nNewMax;
totalSize *= m_nUnitSize;
if (!totalSize.IsValid() || nNewMax < m_nSize) {
return FALSE;
}
FX_LPBYTE pNewData = FX_Realloc(FX_BYTE, m_pData, totalSize.ValueOrDie());
if (pNewData == NULL) {
return FALSE;
}
FXSYS_memset32(pNewData + m_nSize * m_nUnitSize, 0, (nNewMax - m_nSize) * m_nUnitSize);
m_pData = pNewData;
m_nSize = nNewSize;
m_nMaxSize = nNewMax;
}
return TRUE;
}
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;
}
FX_FILESIZE CFXCRT_FileAccess_Posix::GetSize() const
{
if (m_nFD < 0) {
return 0;
}
struct stat s;
FXSYS_memset32(&s, 0, sizeof(s));
fstat(m_nFD, &s);
return s.st_size;
}
CFX_FontMgr::CFX_FontMgr()
{
m_pBuiltinMapper = FX_NEW CFX_FontMapper;
if (!m_pBuiltinMapper) {
return;
}
m_pBuiltinMapper->m_pFontMgr = this;
m_pExtMapper = NULL;
m_FTLibrary = NULL;
FXSYS_memset32(m_ExternalFonts, 0, sizeof m_ExternalFonts);
}
void CPDF_CharPosList::Load(int nChars, FX_DWORD* pCharCodes, FX_FLOAT* pCharPos, CPDF_Font* pFont,
FX_FLOAT FontSize)
{
m_pCharPos = FX_Alloc(FXTEXT_CHARPOS, nChars);
FXSYS_memset32(m_pCharPos, 0, sizeof(FXTEXT_CHARPOS) * nChars);
m_nChars = 0;
CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
FX_BOOL bVertWriting = pCIDFont && pCIDFont->IsVertWriting();
for (int iChar = 0; iChar < nChars; iChar ++) {
FX_DWORD CharCode = nChars == 1 ? (FX_DWORD)(FX_UINTPTR)pCharCodes : pCharCodes[iChar];
if (CharCode == (FX_DWORD) - 1) {
continue;
}
FX_BOOL bVert = FALSE;
FXTEXT_CHARPOS& charpos = m_pCharPos[m_nChars++];
if (pCIDFont) {
charpos.m_bFontStyle = pCIDFont->IsFontStyleFromCharCode(CharCode);
}
charpos.m_GlyphIndex = pFont->GlyphFromCharCode(CharCode, &bVert);
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
charpos.m_ExtGID = pFont->GlyphFromCharCodeExt(CharCode);
#endif
if (!pFont->IsEmbedded() && pFont->GetFontType() != PDFFONT_CIDFONT) {
charpos.m_FontCharWidth = pFont->GetCharWidthF(CharCode);
} else {
charpos.m_FontCharWidth = 0;
}
charpos.m_OriginX = iChar ? pCharPos[iChar - 1] : 0;
charpos.m_OriginY = 0;
charpos.m_bGlyphAdjust = FALSE;
if (pCIDFont == NULL) {
continue;
}
FX_WORD CID = pCIDFont->CIDFromCharCode(CharCode);
if (bVertWriting) {
charpos.m_OriginY = charpos.m_OriginX;
charpos.m_OriginX = 0;
short vx, vy;
pCIDFont->GetVertOrigin(CID, vx, vy);
charpos.m_OriginX -= FontSize * vx / 1000;
charpos.m_OriginY -= FontSize * vy / 1000;
}
FX_LPCBYTE pTransform = pCIDFont->GetCIDTransform(CID);
if (pTransform && !bVert) {
charpos.m_AdjustMatrix[0] = _CIDTransformToFloat(pTransform[0]);
charpos.m_AdjustMatrix[2] = _CIDTransformToFloat(pTransform[2]);
charpos.m_AdjustMatrix[1] = _CIDTransformToFloat(pTransform[1]);
charpos.m_AdjustMatrix[3] = _CIDTransformToFloat(pTransform[3]);
charpos.m_OriginX += _CIDTransformToFloat(pTransform[4]) * FontSize;
charpos.m_OriginY += _CIDTransformToFloat(pTransform[5]) * FontSize;
charpos.m_bGlyphAdjust = TRUE;
}
}
}
void* FPDFAPI_FlateInit(void* (*alloc_func)(void*, unsigned int, unsigned int),
void (*free_func)(void*, void*))
{
z_stream* p = (z_stream*)alloc_func(0, 1, sizeof(z_stream));
if (p == NULL) {
return NULL;
}
FXSYS_memset32(p, 0, sizeof(z_stream));
p->zalloc = alloc_func;
p->zfree = free_func;
inflateInit(p);
return p;
}
int CPDF_IndirectObjects::GetIndirectType(FX_DWORD objnum)
{
FX_LPVOID value;
if (m_IndirectObjs.Lookup((FX_LPVOID)(FX_UINTPTR)objnum, value)) {
return ((CPDF_Object*)value)->GetType();
}
if (m_pParser) {
PARSE_CONTEXT context;
FXSYS_memset32(&context, 0, sizeof(PARSE_CONTEXT));
context.m_Flags = PDFPARSE_TYPEONLY;
return (int)(FX_UINTPTR)m_pParser->ParseIndirectObject(this, objnum, &context);
}
return 0;
}
CPDF_Metadata::CPDF_Metadata()
{
m_pData = FX_Alloc(PDFDOC_METADATA, 1);
FXSYS_memset32(m_pData, 0, sizeof(PDFDOC_METADATA));
CFX_CMapByteStringToPtr *&pStringMap = ((PDFDOC_LPMETADATA)m_pData)->m_pStringMap;
pStringMap = FX_NEW(CFX_CMapByteStringToPtr);
if (pStringMap != NULL) {
CFX_ByteString bstr;
for (int i = 0; i < 18; i += 2) {
bstr = gs_FPDFDOC_Metadata_Titles[i];
pStringMap->AddValue(bstr, (void*)gs_FPDFDOC_Metadata_Titles[i + 1]);
}
}
}
CFX_WindowsDIB::CFX_WindowsDIB(HDC hDC, int width, int height)
{
Create(width, height, FXDIB_Rgb, (FX_LPBYTE)1);
BITMAPINFOHEADER bmih;
FXSYS_memset32(&bmih, 0, sizeof bmih);
bmih.biSize = sizeof bmih;
bmih.biBitCount = 24;
bmih.biHeight = -height;
bmih.biPlanes = 1;
bmih.biWidth = width;
m_hBitmap = CreateDIBSection(hDC, (BITMAPINFO*)&bmih, DIB_RGB_COLORS, (LPVOID*)&m_pBuffer, NULL, 0);
m_hMemDC = CreateCompatibleDC(hDC);
m_hOldBitmap = (HBITMAP)SelectObject(m_hMemDC, m_hBitmap);
}
void CFX_CTTGSUBTable::ParseLangSys(FT_Bytes raw, struct TLangSys *rec)
{
FT_Bytes sp = raw;
rec->LookupOrder = GetUInt16(sp);
rec->ReqFeatureIndex = GetUInt16(sp);
rec->FeatureCount = GetUInt16(sp);
if(rec->FeatureCount <= 0) {
return;
}
rec->FeatureIndex = new TT_uint16_t[rec->FeatureCount];
FXSYS_memset32(rec->FeatureIndex, 0, sizeof(TT_uint16_t) * rec->FeatureCount);
for (int i = 0; i < rec->FeatureCount; ++i) {
rec->FeatureIndex[i] = GetUInt16(sp);
}
}
FX_LPBYTE CCodec_RLScanlineDecoder::v_GetNextLine()
{
if (m_SrcOffset == 0) {
GetNextOperator();
} else {
if (m_bEOD) {
return NULL;
}
}
FXSYS_memset32(m_pScanline, 0, m_Pitch);
FX_DWORD col_pos = 0;
FX_BOOL eol = FALSE;
while (m_SrcOffset < m_SrcSize && !eol) {
if (m_Operator < 128) {
FX_DWORD copy_len = m_Operator + 1;
if (col_pos + copy_len >= m_dwLineBytes) {
copy_len = m_dwLineBytes - col_pos;
eol = TRUE;
}
if (copy_len >= m_SrcSize - m_SrcOffset) {
copy_len = m_SrcSize - m_SrcOffset;
m_bEOD = TRUE;
}
FXSYS_memcpy32(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len);
col_pos += copy_len;
UpdateOperator((FX_BYTE)copy_len);
} else if (m_Operator > 128) {
int fill = 0;
if (m_SrcOffset - 1 < m_SrcSize - 1) {
fill = m_pSrcBuf[m_SrcOffset];
}
FX_DWORD duplicate_len = 257 - m_Operator;
if (col_pos + duplicate_len >= m_dwLineBytes) {
duplicate_len = m_dwLineBytes - col_pos;
eol = TRUE;
}
FXSYS_memset8(m_pScanline + col_pos, fill, duplicate_len);
col_pos += duplicate_len;
UpdateOperator((FX_BYTE)duplicate_len);
} else {
m_bEOD = TRUE;
break;
}
}
return m_pScanline;
}
void CPDF_StandardSecurityHandler::AES256_SetPassword(CPDF_Dictionary* pEncryptDict, FX_LPCBYTE password, FX_DWORD size, FX_BOOL bOwner, FX_LPCBYTE key)
{
FX_BYTE sha[128];
CRYPT_SHA1Start(sha);
CRYPT_SHA1Update(sha, key, 32);
CRYPT_SHA1Update(sha, (FX_BYTE*)"hello", 5);
FX_BYTE digest[20];
CRYPT_SHA1Finish(sha, digest);
CFX_ByteString ukey = pEncryptDict->GetString(FX_BSTRC("U"));
FX_BYTE digest1[48];
if (m_Revision >= 6) {
Revision6_Hash(password, size, digest, (bOwner ? (FX_LPCBYTE)ukey : NULL), digest1);
} else {
CRYPT_SHA256Start(sha);
CRYPT_SHA256Update(sha, password, size);
CRYPT_SHA256Update(sha, digest, 8);
if (bOwner) {
CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
}
CRYPT_SHA256Finish(sha, digest1);
}
FXSYS_memcpy32(digest1 + 32, digest, 16);
pEncryptDict->SetAtString(bOwner ? FX_BSTRC("O") : FX_BSTRC("U"), CFX_ByteString(digest1, 48));
if (m_Revision >= 6) {
Revision6_Hash(password, size, digest + 8, (bOwner ? (FX_LPCBYTE)ukey : NULL), digest1);
} else {
CRYPT_SHA256Start(sha);
CRYPT_SHA256Update(sha, password, size);
CRYPT_SHA256Update(sha, digest + 8, 8);
if (bOwner) {
CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
}
CRYPT_SHA256Finish(sha, digest1);
}
FX_BYTE* aes = FX_Alloc(FX_BYTE, 2048);
CRYPT_AESSetKey(aes, 16, digest1, 32, TRUE);
FX_BYTE iv[16];
FXSYS_memset32(iv, 0, 16);
CRYPT_AESSetIV(aes, iv);
CRYPT_AESEncrypt(aes, digest1, key, 32);
FX_Free(aes);
pEncryptDict->SetAtString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE"), CFX_ByteString(digest1, 32));
}
FX_LPBYTE CFX_BasicArray::InsertSpaceAt(int nIndex, int nCount)
{
if (nIndex < 0 || nCount <= 0) {
return NULL;
}
if (nIndex >= m_nSize) {
if (!SetSize(nIndex + nCount, -1)) {
return NULL;
}
} else {
int nOldSize = m_nSize;
if (!SetSize(m_nSize + nCount, -1)) {
return NULL;
}
FXSYS_memmove32(m_pData + (nIndex + nCount)*m_nUnitSize, m_pData + nIndex * m_nUnitSize,
(nOldSize - nIndex) * m_nUnitSize);
FXSYS_memset32(m_pData + nIndex * m_nUnitSize, 0, nCount * m_nUnitSize);
}
return m_pData + nIndex * m_nUnitSize;
}
FX_BOOL CCodec_Jbig2Module::Decode(FX_DWORD width, FX_DWORD height, FX_LPCBYTE src_buf, FX_DWORD src_size,
FX_LPCBYTE global_data, FX_DWORD global_size, FX_LPBYTE dest_buf, FX_DWORD dest_pitch)
{
FXSYS_memset32(dest_buf, 0, height * dest_pitch);
CJBig2_Context* pContext = CJBig2_Context::CreateContext(&m_Module,
(FX_LPBYTE)global_data, global_size, (FX_LPBYTE)src_buf, src_size, JBIG2_EMBED_STREAM, &m_SymbolDictCache);
if (pContext == NULL) {
return FALSE;
}
int ret = pContext->getFirstPage(dest_buf, width, height, dest_pitch, NULL);
CJBig2_Context::DestroyContext(pContext);
if (ret != JBIG2_SUCCESS) {
return FALSE;
}
int dword_size = height * dest_pitch / 4;
FX_DWORD* dword_buf = (FX_DWORD*)dest_buf;
for (int i = 0; i < dword_size; i ++) {
dword_buf[i] = ~dword_buf[i];
}
return TRUE;
}
CFX_ByteString CFX_WindowsDIB::GetBitmapInfo(const CFX_DIBitmap* pBitmap)
{
CFX_ByteString result;
int len = sizeof (BITMAPINFOHEADER);
if (pBitmap->GetBPP() == 1 || pBitmap->GetBPP() == 8) {
len += sizeof (DWORD) * (int)(1 << pBitmap->GetBPP());
}
BITMAPINFOHEADER* pbmih = (BITMAPINFOHEADER*)result.GetBuffer(len);
FXSYS_memset32(pbmih, 0, sizeof (BITMAPINFOHEADER));
pbmih->biSize = sizeof(BITMAPINFOHEADER);
pbmih->biBitCount = pBitmap->GetBPP();
pbmih->biCompression = BI_RGB;
pbmih->biHeight = -(int)pBitmap->GetHeight();
pbmih->biPlanes = 1;
pbmih->biWidth = pBitmap->GetWidth();
if (pBitmap->GetBPP() == 8) {
FX_DWORD* pPalette = (FX_DWORD*)(pbmih + 1);
if (pBitmap->GetPalette() == NULL) {
for (int i = 0; i < 256; i ++) {
pPalette[i] = i * 0x010101;
}
} else {
for (int i = 0; i < 256; i ++) {
pPalette[i] = pBitmap->GetPalette()[i];
}
}
}
if (pBitmap->GetBPP() == 1) {
FX_DWORD* pPalette = (FX_DWORD*)(pbmih + 1);
if (pBitmap->GetPalette() == NULL) {
pPalette[0] = 0;
pPalette[1] = 0xffffff;
} else {
pPalette[0] = pBitmap->GetPalette()[0];
pPalette[1] = pBitmap->GetPalette()[1];
}
}
result.ReleaseBuffer(len);
return result;
}
FX_BOOL CPDF_Function::Init(CPDF_Object* pObj)
{
CPDF_Dictionary* pDict;
if (pObj->GetType() == PDFOBJ_STREAM) {
pDict = ((CPDF_Stream*)pObj)->GetDict();
} else {
pDict = (CPDF_Dictionary*)pObj;
}
CPDF_Array* pDomains = pDict->GetArray(FX_BSTRC("Domain"));
if (pDomains == NULL) {
return FALSE;
}
m_nInputs = pDomains->GetCount() / 2;
if (m_nInputs == 0) {
return FALSE;
}
m_pDomains = FX_Alloc(FX_FLOAT, m_nInputs * 2);
for (int i = 0; i < m_nInputs * 2; i ++) {
m_pDomains[i] = pDomains->GetFloat(i);
}
CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC("Range"));
m_nOutputs = 0;
if (pRanges) {
m_nOutputs = pRanges->GetCount() / 2;
m_pRanges = FX_Alloc(FX_FLOAT, m_nOutputs * 2);
for (int i = 0; i < m_nOutputs * 2; i ++) {
m_pRanges[i] = pRanges->GetFloat(i);
}
}
FX_DWORD old_outputs = m_nOutputs;
FX_BOOL ret = v_Init(pObj);
if (m_pRanges && m_nOutputs > (int)old_outputs) {
m_pRanges = FX_Realloc(FX_FLOAT, m_pRanges, m_nOutputs * 2);
if (m_pRanges) {
FXSYS_memset32(m_pRanges + (old_outputs * 2), 0, sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);
}
}
return ret;
}
void CPDF_MeshStream::GetColor(FX_FLOAT& r, FX_FLOAT& g, FX_FLOAT& b)
{
FX_DWORD i;
FX_FLOAT color_value[8];
for (i = 0; i < m_nComps; i ++) {
color_value[i] = m_ColorMin[i] + m_BitStream.GetBits(m_nCompBits) * (m_ColorMax[i] - m_ColorMin[i]) / m_CompMax;
}
if (m_nFuncs) {
static const int kMaxResults = 8;
FX_FLOAT result[kMaxResults];
int nResults;
FXSYS_memset32(result, 0, sizeof(result));
for (FX_DWORD i = 0; i < m_nFuncs; i ++) {
if (m_pFuncs[i] && m_pFuncs[i]->CountOutputs() <= kMaxResults) {
m_pFuncs[i]->Call(color_value, 1, result, nResults);
}
}
m_pCS->GetRGB(result, r, g, b);
} else {
m_pCS->GetRGB(color_value, r, g, b);
}
}
FXCODEC_STATUS CCodec_Jbig2Module::StartDecode(void* pJbig2Context, FX_DWORD width, FX_DWORD height, FX_LPCBYTE src_buf, FX_DWORD src_size,
FX_LPCBYTE global_data, FX_DWORD global_size, FX_LPBYTE dest_buf, FX_DWORD dest_pitch, IFX_Pause* pPause)
{
if(!pJbig2Context) {
return FXCODEC_STATUS_ERR_PARAMS;
}
CCodec_Jbig2Context* m_pJbig2Context = (CCodec_Jbig2Context*)pJbig2Context;
m_pJbig2Context->m_width = width;
m_pJbig2Context->m_height = height;
m_pJbig2Context->m_src_buf = (unsigned char *)src_buf;
m_pJbig2Context->m_src_size = src_size;
m_pJbig2Context->m_global_data = global_data;
m_pJbig2Context->m_global_size = global_size;
m_pJbig2Context->m_dest_buf = dest_buf;
m_pJbig2Context->m_dest_pitch = dest_pitch;
m_pJbig2Context->m_pPause = pPause;
m_pJbig2Context->m_bFileReader = FALSE;
FXSYS_memset32(dest_buf, 0, height * dest_pitch);
m_pJbig2Context->m_pContext = CJBig2_Context::CreateContext(&m_Module,
(FX_LPBYTE)global_data, global_size, (FX_LPBYTE)src_buf, src_size, JBIG2_EMBED_STREAM, &m_SymbolDictCache, pPause);
if(!m_pJbig2Context->m_pContext) {
return FXCODEC_STATUS_ERROR;
}
int ret = m_pJbig2Context->m_pContext->getFirstPage(dest_buf, width, height, dest_pitch, pPause);
if(m_pJbig2Context->m_pContext->GetProcessiveStatus() == FXCODEC_STATUS_DECODE_FINISH) {
CJBig2_Context::DestroyContext(m_pJbig2Context->m_pContext);
m_pJbig2Context->m_pContext = NULL;
if (ret != JBIG2_SUCCESS) {
return FXCODEC_STATUS_ERROR;
}
int dword_size = height * dest_pitch / 4;
FX_DWORD* dword_buf = (FX_DWORD*)dest_buf;
for (int i = 0; i < dword_size; i ++) {
dword_buf[i] = ~dword_buf[i];
}
return FXCODEC_STATUS_DECODE_FINISH;
}
return m_pJbig2Context->m_pContext->GetProcessiveStatus();
}
void CalcEncryptKey(CPDF_Dictionary* pEncrypt, FX_LPCBYTE password, FX_DWORD pass_size,
FX_LPBYTE key, int keylen, FX_BOOL bIgnoreMeta, CPDF_Array* pIdArray)
{
int revision = pEncrypt->GetInteger(FX_BSTRC("R"));
FX_BYTE passcode[32];
for (FX_DWORD i = 0; i < 32; i ++) {
passcode[i] = i < pass_size ? password[i] : defpasscode[i - pass_size];
}
FX_BYTE md5[100];
CRYPT_MD5Start(md5);
CRYPT_MD5Update(md5, passcode, 32);
CFX_ByteString okey = pEncrypt->GetString(FX_BSTRC("O"));
CRYPT_MD5Update(md5, (FX_LPBYTE)(FX_LPCSTR)okey, okey.GetLength());
FX_DWORD perm = pEncrypt->GetInteger(FX_BSTRC("P"));
CRYPT_MD5Update(md5, (FX_LPBYTE)&perm, 4);
if (pIdArray) {
CFX_ByteString id = pIdArray->GetString(0);
CRYPT_MD5Update(md5, (FX_LPBYTE)(FX_LPCSTR)id, id.GetLength());
}
if (!bIgnoreMeta && revision >= 3 && !pEncrypt->GetInteger(FX_BSTRC("EncryptMetadata"), 1)) {
FX_DWORD tag = (FX_DWORD) - 1;
CRYPT_MD5Update(md5, (FX_LPBYTE)&tag, 4);
}
FX_BYTE digest[16];
CRYPT_MD5Finish(md5, digest);
FX_DWORD copy_len = keylen;
if (copy_len > sizeof(digest)) {
copy_len = sizeof(digest);
}
if (revision >= 3) {
for (int i = 0; i < 50; i ++) {
CRYPT_MD5Generate(digest, copy_len, digest);
}
}
FXSYS_memset32(key, 0, keylen);
FXSYS_memcpy32(key, digest, copy_len);
}
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;
}
