1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sdext.hxx"
26 
27 #include <pdfparse.hxx>
28 
29 #include <rtl/strbuf.hxx>
30 #include <rtl/ustring.hxx>
31 #include <rtl/ustrbuf.hxx>
32 #include <rtl/alloc.h>
33 #include <rtl/digest.h>
34 #include <rtl/cipher.h>
35 #include <rtl/memory.h>
36 #ifdef SYSTEM_ZLIB
37 #include "zlib.h"
38 #else
39 #include <zlib/zlib.h>
40 #endif
41 
42 #include <math.h>
43 #include <map>
44 
45 #include <stdio.h>
46 
47 using namespace rtl;
48 
49 namespace pdfparse
50 {
51 
52 struct EmitImplData
53 {
54     // xref table: maps object number to a pair of (generation, buffer offset)
55     typedef std::map< unsigned int, std::pair< unsigned int, unsigned int > > XRefTable;
56     XRefTable m_aXRefTable;
57     // container of all indirect objects (usually a PDFFile*)
58     const PDFContainer* m_pObjectContainer;
59     unsigned int m_nDecryptObject;
60     unsigned int m_nDecryptGeneration;
61 
62     // returns true if the xref table was updated
insertXrefpdfparse::EmitImplData63     bool insertXref( unsigned int nObject, unsigned int nGeneration, unsigned int nOffset )
64     {
65         XRefTable::iterator it = m_aXRefTable.find( nObject );
66         if( it == m_aXRefTable.end() )
67         {
68             // new entry
69             m_aXRefTable[ nObject ] = std::pair<unsigned int, unsigned int>(nGeneration,nOffset);
70             return true;
71         }
72         // update old entry, if generation number is higher
73         if( it->second.first < nGeneration )
74         {
75             it->second = std::pair<unsigned int, unsigned int>(nGeneration,nOffset);
76             return true;
77         }
78         return false;
79     }
80 
EmitImplDatapdfparse::EmitImplData81     EmitImplData( const PDFContainer* pTopContainer ) :
82         m_pObjectContainer( pTopContainer ),
83         m_nDecryptObject( 0 ),
84         m_nDecryptGeneration( 0 )
85     {}
~EmitImplDatapdfparse::EmitImplData86     ~EmitImplData() {}
decryptpdfparse::EmitImplData87     bool decrypt( const sal_uInt8* pInBuffer, sal_uInt32 nLen, sal_uInt8* pOutBuffer,
88                   unsigned int nObject, unsigned int nGeneration ) const
89     {
90         const PDFFile* pFile = dynamic_cast<const PDFFile*>(m_pObjectContainer);
91         return pFile ? pFile->decrypt( pInBuffer, nLen, pOutBuffer, nObject, nGeneration ) : false;
92     }
93 
setDecryptObjectpdfparse::EmitImplData94     void setDecryptObject( unsigned int nObject, unsigned int nGeneration )
95     {
96         m_nDecryptObject = nObject;
97         m_nDecryptGeneration = nGeneration;
98     }
99 };
100 
101 }
102 
103 using namespace pdfparse;
104 
EmitContext(const PDFContainer * pTop)105 EmitContext::EmitContext( const PDFContainer* pTop ) :
106     m_bDeflate( false ),
107     m_bDecrypt( false ),
108     m_pImplData( NULL )
109 {
110     if( pTop )
111         m_pImplData = new EmitImplData( pTop );
112 }
113 
~EmitContext()114 EmitContext::~EmitContext()
115 {
116     delete m_pImplData;
117 }
118 
~PDFEntry()119 PDFEntry::~PDFEntry()
120 {
121 }
122 
getEmitData(EmitContext & rContext) const123 EmitImplData* PDFEntry::getEmitData( EmitContext& rContext ) const
124 {
125     return rContext.m_pImplData;
126 }
127 
setEmitData(EmitContext & rContext,EmitImplData * pNewEmitData) const128 void PDFEntry::setEmitData( EmitContext& rContext, EmitImplData* pNewEmitData ) const
129 {
130     if( rContext.m_pImplData && rContext.m_pImplData != pNewEmitData )
131         delete rContext.m_pImplData;
132     rContext.m_pImplData = pNewEmitData;
133 }
134 
~PDFValue()135 PDFValue::~PDFValue()
136 {
137 }
138 
~PDFComment()139 PDFComment::~PDFComment()
140 {
141 }
142 
emit(EmitContext & rWriteContext) const143 bool PDFComment::emit( EmitContext& rWriteContext ) const
144 {
145     return rWriteContext.write( m_aComment.getStr(), m_aComment.getLength() );
146 }
147 
clone() const148 PDFEntry* PDFComment::clone() const
149 {
150     return new PDFComment( m_aComment );
151 }
152 
~PDFName()153 PDFName::~PDFName()
154 {
155 }
156 
emit(EmitContext & rWriteContext) const157 bool PDFName::emit( EmitContext& rWriteContext ) const
158 {
159     if( ! rWriteContext.write( " /", 2 ) )
160         return false;
161     return rWriteContext.write( m_aName.getStr(), m_aName.getLength() );
162 }
163 
clone() const164 PDFEntry* PDFName::clone() const
165 {
166     return new PDFName( m_aName );
167 }
168 
getFilteredName() const169 OUString PDFName::getFilteredName() const
170 {
171     OStringBuffer aFilter( m_aName.getLength() );
172     const sal_Char* pStr = m_aName.getStr();
173     unsigned int nLen = m_aName.getLength();
174     for( unsigned int i = 0; i < nLen; i++ )
175     {
176         if( pStr[i] == '#' && i < nLen - 3 )
177         {
178             sal_Char rResult = 0;
179             i++;
180             if( pStr[i] >= '0' && pStr[i] <= '9' )
181                 rResult = sal_Char( pStr[i]-'0' ) << 4;
182             else if( pStr[i] >= 'a' && pStr[i] <= 'f' )
183                 rResult = sal_Char( pStr[i]-'a' + 10 ) << 4;
184             else if( pStr[i] >= 'A' && pStr[i] <= 'F' )
185                 rResult = sal_Char( pStr[i]-'A' + 10 ) << 4;
186             i++;
187             if( pStr[i] >= '0' && pStr[i] <= '9' )
188                 rResult |= sal_Char( pStr[i]-'0' );
189             else if( pStr[i] >= 'a' && pStr[i] <= 'f' )
190                 rResult |= sal_Char( pStr[i]-'a' + 10 );
191             else if( pStr[i] >= 'A' && pStr[i] <= 'F' )
192                 rResult |= sal_Char( pStr[i]-'A' + 10 );
193             aFilter.append( rResult );
194         }
195         else
196             aFilter.append( pStr[i] );
197     }
198     return OStringToOUString( aFilter.makeStringAndClear(), RTL_TEXTENCODING_UTF8 );
199 }
200 
~PDFString()201 PDFString::~PDFString()
202 {
203 }
204 
emit(EmitContext & rWriteContext) const205 bool PDFString::emit( EmitContext& rWriteContext ) const
206 {
207     if( ! rWriteContext.write( " ", 1 ) )
208         return false;
209     EmitImplData* pEData = getEmitData( rWriteContext );
210     if( rWriteContext.m_bDecrypt && pEData && pEData->m_nDecryptObject )
211     {
212         OString aFiltered( getFilteredString() );
213         // decrypt inplace (evil since OString is supposed to be const
214         // however in this case we know that getFilteredString returned a singular string instance
215         pEData->decrypt( (sal_uInt8*)aFiltered.getStr(), aFiltered.getLength(),
216                          (sal_uInt8*)aFiltered.getStr(),
217                          pEData->m_nDecryptObject, pEData->m_nDecryptGeneration );
218         // check for string or hex string
219         const sal_Char* pStr = aFiltered.getStr();
220         if( aFiltered.getLength() > 1 &&
221            ( (pStr[0] == sal_Char(0xff) && pStr[1] == sal_Char(0xfe)) ||
222              (pStr[0] == sal_Char(0xfe) && pStr[1] == sal_Char(0xff)) ) )
223         {
224             static const char pHexTab[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
225                                               '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
226             if( ! rWriteContext.write( "<", 1 ) )
227                 return false;
228             for( sal_Int32 i = 0; i < aFiltered.getLength(); i++ )
229             {
230                 if( ! rWriteContext.write( pHexTab + ((sal_uInt32(pStr[i]) >> 4) & 0x0f), 1 ) )
231                     return false;
232                 if( ! rWriteContext.write( pHexTab + (sal_uInt32(pStr[i]) & 0x0f), 1 ) )
233                     return false;
234             }
235             if( ! rWriteContext.write( ">", 1 ) )
236                 return false;
237         }
238         else
239         {
240             if( ! rWriteContext.write( "(", 1 ) )
241                 return false;
242             if( ! rWriteContext.write( aFiltered.getStr(), aFiltered.getLength() ) )
243                 return false;
244             if( ! rWriteContext.write( ")", 1 ) )
245                 return false;
246         }
247         return true;
248     }
249     return rWriteContext.write( m_aString.getStr(), m_aString.getLength() );
250 }
251 
clone() const252 PDFEntry* PDFString::clone() const
253 {
254     return new PDFString( m_aString );
255 }
256 
getFilteredString() const257 OString PDFString::getFilteredString() const
258 {
259     int nLen = m_aString.getLength();
260     OStringBuffer aBuf( nLen );
261 
262     const sal_Char* pStr = m_aString.getStr();
263     if( *pStr == '(' )
264     {
265         const sal_Char* pRun = pStr+1;
266         while( pRun - pStr < nLen-1 )
267         {
268             if( *pRun == '\\' )
269             {
270                 pRun++;
271                 if( pRun - pStr < nLen )
272                 {
273                     sal_Char aEsc = 0;
274                     if( *pRun == 'n' )
275                         aEsc = '\n';
276                     else if( *pRun == 'r' )
277                         aEsc = '\r';
278                     else if( *pRun == 't' )
279                         aEsc = '\t';
280                     else if( *pRun == 'b' )
281                         aEsc = '\b';
282                     else if( *pRun == 'f' )
283                         aEsc = '\f';
284                     else if( *pRun == '(' )
285                         aEsc = '(';
286                     else if( *pRun == ')' )
287                         aEsc = ')';
288                     else if( *pRun == '\\' )
289                         aEsc = '\\';
290                     else if( *pRun == '\n' )
291                     {
292                         pRun++;
293                         continue;
294                     }
295                     else if( *pRun == '\r' )
296                     {
297                         pRun++;
298                         if( *pRun == '\n' )
299                             pRun++;
300                         continue;
301                     }
302                     else
303                     {
304                         int i = 0;
305                         while( i++ < 3 && *pRun >= '0' && *pRun <= '7' )
306                             aEsc = 8*aEsc + (*pRun++ - '0');
307                         // move pointer back to last character of octal sequence
308                         pRun--;
309                     }
310                     aBuf.append( aEsc );
311                 }
312             }
313             else
314                 aBuf.append( *pRun );
315             // move pointer to next character
316             pRun++;
317         }
318     }
319     else if( *pStr == '<' )
320     {
321         const sal_Char* pRun = pStr+1;
322         while( *pRun != '>' && pRun - pStr < nLen )
323         {
324             sal_Char rResult = 0;
325             if( *pRun >= '0' && *pRun <= '9' )
326                 rResult = sal_Char( *pRun-'0' ) << 4;
327             else if( *pRun >= 'a' && *pRun <= 'f' )
328                 rResult = sal_Char( *pRun-'a' + 10 ) << 4;
329             else if( *pRun >= 'A' && *pRun <= 'F' )
330                 rResult = sal_Char( *pRun-'A' + 10 ) << 4;
331             pRun++;
332             if( *pRun != '>' && pRun - pStr < nLen )
333             {
334                 if( *pRun >= '0' && *pRun <= '9' )
335                     rResult |= sal_Char( *pRun-'0' );
336                 else if( *pRun >= 'a' && *pRun <= 'f' )
337                     rResult |= sal_Char( *pRun-'a' + 10 );
338                 else if( *pRun >= 'A' && *pRun <= 'F' )
339                     rResult |= sal_Char( *pRun-'A' + 10 );
340             }
341             pRun++;
342             aBuf.append( rResult );
343         }
344     }
345 
346     return aBuf.makeStringAndClear();
347 }
348 
~PDFNumber()349 PDFNumber::~PDFNumber()
350 {
351 }
352 
emit(EmitContext & rWriteContext) const353 bool PDFNumber::emit( EmitContext& rWriteContext ) const
354 {
355     rtl::OStringBuffer aBuf( 32 );
356     aBuf.append( ' ' );
357 
358     double fValue = m_fValue;
359     bool bNeg = false;
360     int nPrecision = 5;
361     if( fValue < 0.0 )
362     {
363         bNeg = true;
364         fValue=-fValue;
365     }
366 
367     sal_Int64 nInt = (sal_Int64)fValue;
368     fValue -= (double)nInt;
369     // optimizing hardware may lead to a value of 1.0 after the subtraction
370     if( fValue == 1.0 || log10( 1.0-fValue ) <= -nPrecision )
371     {
372         nInt++;
373         fValue = 0.0;
374     }
375     sal_Int64 nFrac = 0;
376     if( fValue )
377     {
378         fValue *= pow( 10.0, (double)nPrecision );
379         nFrac = (sal_Int64)fValue;
380     }
381     if( bNeg && ( nInt || nFrac ) )
382         aBuf.append( '-' );
383     aBuf.append( nInt );
384     if( nFrac )
385     {
386 		int i;
387         aBuf.append( '.' );
388 		sal_Int64 nBound = (sal_Int64)(pow( 10.0, nPrecision - 1.0 )+0.5);
389 		for ( i = 0; ( i < nPrecision ) && nFrac; i++ )
390 		{
391 			sal_Int64 nNumb = nFrac / nBound;
392 			nFrac -= nNumb * nBound;
393 			aBuf.append( nNumb );
394 			nBound /= 10;
395 		}
396     }
397 
398     return rWriteContext.write( aBuf.getStr(), aBuf.getLength() );
399 }
400 
clone() const401 PDFEntry* PDFNumber::clone() const
402 {
403     return new PDFNumber( m_fValue );
404 }
405 
406 
~PDFBool()407 PDFBool::~PDFBool()
408 {
409 }
410 
emit(EmitContext & rWriteContext) const411 bool PDFBool::emit( EmitContext& rWriteContext ) const
412 {
413     return m_bValue ? rWriteContext.write( " true", 5 ) : rWriteContext.write( " false", 6 );
414 }
415 
clone() const416 PDFEntry* PDFBool::clone() const
417 {
418     return new PDFBool( m_bValue );
419 }
420 
~PDFNull()421 PDFNull::~PDFNull()
422 {
423 }
424 
emit(EmitContext & rWriteContext) const425 bool PDFNull::emit( EmitContext& rWriteContext ) const
426 {
427     return rWriteContext.write( " null", 5 );
428 }
429 
clone() const430 PDFEntry* PDFNull::clone() const
431 {
432     return new PDFNull();
433 }
434 
435 
~PDFObjectRef()436 PDFObjectRef::~PDFObjectRef()
437 {
438 }
439 
emit(EmitContext & rWriteContext) const440 bool PDFObjectRef::emit( EmitContext& rWriteContext ) const
441 {
442     OStringBuffer aBuf( 16 );
443     aBuf.append( ' ' );
444     aBuf.append( sal_Int32( m_nNumber ) );
445     aBuf.append( ' ' );
446     aBuf.append( sal_Int32( m_nGeneration ) );
447     aBuf.append( " R", 2 );
448     return rWriteContext.write( aBuf.getStr(), aBuf.getLength() );
449 }
450 
clone() const451 PDFEntry* PDFObjectRef::clone() const
452 {
453     return new PDFObjectRef( m_nNumber, m_nGeneration );
454 }
455 
~PDFContainer()456 PDFContainer::~PDFContainer()
457 {
458     int nEle = m_aSubElements.size();
459     for( int i = 0; i < nEle; i++ )
460         delete m_aSubElements[i];
461 }
462 
emitSubElements(EmitContext & rWriteContext) const463 bool PDFContainer::emitSubElements( EmitContext& rWriteContext ) const
464 {
465     int nEle = m_aSubElements.size();
466     for( int i = 0; i < nEle; i++ )
467     {
468         if( rWriteContext.m_bDecrypt )
469         {
470             const PDFName* pName = dynamic_cast<PDFName*>(m_aSubElements[i]);
471             if( pName && pName->m_aName.equals( rtl::OString("Encrypt") ) )
472             {
473                 i++;
474                 continue;
475             }
476         }
477         if( ! m_aSubElements[i]->emit( rWriteContext ) )
478             return false;
479     }
480     return true;
481 }
482 
cloneSubElements(std::vector<PDFEntry * > & rNewSubElements) const483 void PDFContainer::cloneSubElements( std::vector<PDFEntry*>& rNewSubElements ) const
484 {
485     int nEle = m_aSubElements.size();
486     for( int i = 0; i < nEle; i++ )
487         rNewSubElements.push_back( m_aSubElements[i]->clone() );
488 }
489 
findObject(unsigned int nNumber,unsigned int nGeneration) const490 PDFObject* PDFContainer::findObject( unsigned int nNumber, unsigned int nGeneration ) const
491 {
492     unsigned int nEle = m_aSubElements.size();
493     for( unsigned int i = 0; i < nEle; i++ )
494     {
495         PDFObject* pObject = dynamic_cast<PDFObject*>(m_aSubElements[i]);
496         if( pObject &&
497             pObject->m_nNumber == nNumber &&
498             pObject->m_nGeneration == nGeneration )
499         {
500             return pObject;
501         }
502     }
503     return NULL;
504 }
505 
~PDFArray()506 PDFArray::~PDFArray()
507 {
508 }
509 
emit(EmitContext & rWriteContext) const510 bool PDFArray::emit( EmitContext& rWriteContext ) const
511 {
512     if( ! rWriteContext.write( "[", 1 ) )
513         return false;
514     if( ! emitSubElements( rWriteContext ) )
515         return false;
516     return rWriteContext.write( "]", 1 );
517 }
518 
clone() const519 PDFEntry* PDFArray::clone() const
520 {
521     PDFArray* pNewAr = new PDFArray();
522     cloneSubElements( pNewAr->m_aSubElements );
523     return pNewAr;
524 }
525 
~PDFDict()526 PDFDict::~PDFDict()
527 {
528 }
529 
emit(EmitContext & rWriteContext) const530 bool PDFDict::emit( EmitContext& rWriteContext ) const
531 {
532     if( ! rWriteContext.write( "<<\n", 3 ) )
533         return false;
534     if( ! emitSubElements( rWriteContext ) )
535         return false;
536     return rWriteContext.write( "\n>>\n", 4 );
537 }
538 
insertValue(const OString & rName,PDFEntry * pValue)539 void PDFDict::insertValue( const OString& rName, PDFEntry* pValue )
540 {
541     if( ! pValue )
542         eraseValue( rName );
543 
544     std::hash_map<OString,PDFEntry*,OStringHash>::iterator it = m_aMap.find( rName );
545     if( it == m_aMap.end() )
546     {
547         // new name/value, pair, append it
548         m_aSubElements.push_back( new PDFName( rName ) );
549         m_aSubElements.push_back( pValue );
550     }
551     else
552     {
553         unsigned int nSub = m_aSubElements.size();
554         for( unsigned int i = 0; i < nSub; i++ )
555             if( m_aSubElements[i] == it->second )
556                 m_aSubElements[i] = pValue;
557         delete it->second;
558     }
559     m_aMap[ rName ] = pValue;
560 }
561 
eraseValue(const OString & rName)562 void PDFDict::eraseValue( const OString& rName )
563 {
564     unsigned int nEle = m_aSubElements.size();
565     for( unsigned int i = 0; i < nEle; i++ )
566     {
567         PDFName* pName = dynamic_cast<PDFName*>(m_aSubElements[i]);
568         if( pName && pName->m_aName.equals( rName ) )
569         {
570             for( unsigned int j = i+1; j < nEle; j++ )
571             {
572                 if( dynamic_cast<PDFComment*>(m_aSubElements[j]) == NULL )
573                 {
574                     // free name and value
575                     delete m_aSubElements[j];
576                     delete m_aSubElements[i];
577                     // remove subelements from vector
578                     m_aSubElements.erase( m_aSubElements.begin()+j );
579                     m_aSubElements.erase( m_aSubElements.begin()+i );
580                     buildMap();
581                     return;
582                 }
583             }
584         }
585     }
586 }
587 
buildMap()588 PDFEntry* PDFDict::buildMap()
589 {
590     // clear map
591     m_aMap.clear();
592     // build map
593     unsigned int nEle = m_aSubElements.size();
594     PDFName* pName = NULL;
595     for( unsigned int i = 0; i < nEle; i++ )
596     {
597         if( dynamic_cast<PDFComment*>(m_aSubElements[i]) == NULL )
598         {
599             if( pName )
600             {
601                 m_aMap[ pName->m_aName ] = m_aSubElements[i];
602                 pName = NULL;
603             }
604             else if( (pName = dynamic_cast<PDFName*>(m_aSubElements[i])) == NULL )
605                 return m_aSubElements[i];
606         }
607     }
608     return pName;
609 }
610 
clone() const611 PDFEntry* PDFDict::clone() const
612 {
613     PDFDict* pNewDict = new PDFDict();
614     cloneSubElements( pNewDict->m_aSubElements );
615     pNewDict->buildMap();
616     return pNewDict;
617 }
618 
~PDFStream()619 PDFStream::~PDFStream()
620 {
621 }
622 
emit(EmitContext & rWriteContext) const623 bool PDFStream::emit( EmitContext& rWriteContext ) const
624 {
625     return rWriteContext.copyOrigBytes( m_nBeginOffset, m_nEndOffset-m_nBeginOffset );
626 }
627 
clone() const628 PDFEntry* PDFStream::clone() const
629 {
630     return new PDFStream( m_nBeginOffset, m_nEndOffset, NULL );
631 }
632 
getDictLength(const PDFContainer * pContainer) const633 unsigned int PDFStream::getDictLength( const PDFContainer* pContainer ) const
634 {
635     if( ! m_pDict )
636         return 0;
637     // find /Length entry, can either be a direct or indirect number object
638     std::hash_map<OString,PDFEntry*,OStringHash>::const_iterator it =
639         m_pDict->m_aMap.find( "Length" );
640     if( it == m_pDict->m_aMap.end() )
641         return 0;
642     PDFNumber* pNum = dynamic_cast<PDFNumber*>(it->second);
643     if( ! pNum && pContainer )
644     {
645         PDFObjectRef* pRef = dynamic_cast<PDFObjectRef*>(it->second);
646         if( pRef )
647         {
648             int nEle = pContainer->m_aSubElements.size();
649             for( int i = 0; i < nEle && ! pNum; i++ )
650             {
651                 PDFObject* pObj = dynamic_cast<PDFObject*>(pContainer->m_aSubElements[i]);
652                 if( pObj &&
653                     pObj->m_nNumber == pRef->m_nNumber &&
654                     pObj->m_nGeneration == pRef->m_nGeneration )
655                 {
656                     if( pObj->m_pObject )
657                         pNum = dynamic_cast<PDFNumber*>(pObj->m_pObject);
658                     break;
659                 }
660             }
661         }
662     }
663     return pNum ? static_cast<unsigned int>(pNum->m_fValue) : 0;
664 }
665 
~PDFObject()666 PDFObject::~PDFObject()
667 {
668 }
669 
getDeflatedStream(char ** ppStream,unsigned int * pBytes,const PDFContainer * pObjectContainer,EmitContext & rContext) const670 bool PDFObject::getDeflatedStream( char** ppStream, unsigned int* pBytes, const PDFContainer* pObjectContainer, EmitContext& rContext ) const
671 {
672     bool bIsDeflated = false;
673     if( m_pStream && m_pStream->m_pDict &&
674         m_pStream->m_nEndOffset > m_pStream->m_nBeginOffset+15
675         )
676     {
677         unsigned int nOuterStreamLen = m_pStream->m_nEndOffset - m_pStream->m_nBeginOffset;
678         *ppStream = static_cast<char*>(rtl_allocateMemory( nOuterStreamLen ));
679         if( ! ppStream )
680         {
681             *pBytes = 0;
682             return false;
683         }
684         unsigned int nRead = rContext.readOrigBytes( m_pStream->m_nBeginOffset, nOuterStreamLen, *ppStream );
685         if( nRead != nOuterStreamLen )
686         {
687             rtl_freeMemory( *ppStream );
688             *ppStream = NULL;
689             *pBytes = 0;
690             return false;
691         }
692         // is there a filter entry ?
693         std::hash_map<OString,PDFEntry*,OStringHash>::const_iterator it =
694             m_pStream->m_pDict->m_aMap.find( "Filter" );
695         if( it != m_pStream->m_pDict->m_aMap.end() )
696         {
697             PDFName* pFilter = dynamic_cast<PDFName*>(it->second);
698             if( ! pFilter )
699             {
700                 PDFArray* pArray = dynamic_cast<PDFArray*>(it->second);
701                 if( pArray && ! pArray->m_aSubElements.empty() )
702                 {
703                     pFilter = dynamic_cast<PDFName*>(pArray->m_aSubElements.front());
704                 }
705             }
706 
707             // is the (first) filter FlateDecode ?
708             if( pFilter && pFilter->m_aName.equals( "FlateDecode" ) )
709             {
710                 bIsDeflated = true;
711             }
712         }
713         // prepare compressed data section
714         char* pStream = *ppStream;
715         if( pStream[0] == 's' )
716             pStream += 6; // skip "stream"
717         // skip line end after "stream"
718         while( *pStream == '\r' || *pStream == '\n' )
719             pStream++;
720         // get the compressed length
721         *pBytes = m_pStream->getDictLength( pObjectContainer );
722         if( pStream != *ppStream )
723             rtl_moveMemory( *ppStream, pStream, *pBytes );
724         if( rContext.m_bDecrypt )
725         {
726             EmitImplData* pEData = getEmitData( rContext );
727             pEData->decrypt( reinterpret_cast<const sal_uInt8*>(*ppStream),
728                              *pBytes,
729                              reinterpret_cast<sal_uInt8*>(*ppStream),
730                              m_nNumber,
731                              m_nGeneration
732                              ); // decrypt inplace
733         }
734     }
735     else
736         *ppStream = NULL, *pBytes = 0;
737     return bIsDeflated;
738 }
739 
unzipToBuffer(const char * pBegin,unsigned int nLen,sal_uInt8 ** pOutBuf,sal_uInt32 * pOutLen)740 static void unzipToBuffer( const char* pBegin, unsigned int nLen,
741                            sal_uInt8** pOutBuf, sal_uInt32* pOutLen )
742 {
743     z_stream aZStr;
744     aZStr.next_in       = (Bytef*)pBegin;
745     aZStr.avail_in      = nLen;
746 	aZStr.zalloc        = ( alloc_func )0;
747     aZStr.zfree         = ( free_func )0;
748     aZStr.opaque        = ( voidpf )0;
749     inflateInit(&aZStr);
750 
751     const unsigned int buf_increment_size = 16384;
752 
753     *pOutBuf = (sal_uInt8*)rtl_reallocateMemory( *pOutBuf, buf_increment_size );
754     aZStr.next_out      = (Bytef*)*pOutBuf;
755     aZStr.avail_out     = buf_increment_size;
756     int err = Z_OK;
757     *pOutLen = buf_increment_size;
758     while( err != Z_STREAM_END && err >= Z_OK && aZStr.avail_in )
759     {
760         err = inflate( &aZStr, Z_NO_FLUSH );
761         if( aZStr.avail_out == 0 )
762         {
763             if( err != Z_STREAM_END )
764             {
765                 const int nNewAlloc = *pOutLen + buf_increment_size;
766                 *pOutBuf = (sal_uInt8*)rtl_reallocateMemory( *pOutBuf, nNewAlloc );
767                 aZStr.next_out = (Bytef*)(*pOutBuf + *pOutLen);
768                 aZStr.avail_out = buf_increment_size;
769                 *pOutLen = nNewAlloc;
770             }
771         }
772     }
773     if( err == Z_STREAM_END )
774     {
775         if( aZStr.avail_out > 0 )
776             *pOutLen -= aZStr.avail_out;;
777     }
778     inflateEnd(&aZStr);
779     if( err < Z_OK )
780     {
781         rtl_freeMemory( *pOutBuf );
782         *pOutBuf = NULL;
783         *pOutLen = 0;
784     }
785 }
786 
writeStream(EmitContext & rWriteContext,const PDFFile * pParsedFile) const787 bool PDFObject::writeStream( EmitContext& rWriteContext, const PDFFile* pParsedFile ) const
788 {
789     bool bSuccess = false;
790     if( m_pStream )
791     {
792         char* pStream = NULL;
793         unsigned int nBytes = 0;
794         if( getDeflatedStream( &pStream, &nBytes, pParsedFile, rWriteContext ) && nBytes && rWriteContext.m_bDeflate )
795         {
796             sal_uInt8* pOutBytes = NULL;
797             sal_uInt32 nOutBytes = 0;
798             unzipToBuffer( pStream, nBytes, &pOutBytes, &nOutBytes );
799             rWriteContext.write( pOutBytes, nOutBytes );
800             rtl_freeMemory( pOutBytes );
801         }
802         else if( pStream && nBytes )
803             rWriteContext.write( pStream, nBytes );
804         rtl_freeMemory( pStream );
805     }
806     return bSuccess;
807 }
808 
emit(EmitContext & rWriteContext) const809 bool PDFObject::emit( EmitContext& rWriteContext ) const
810 {
811     if( ! rWriteContext.write( "\n", 1 ) )
812         return false;
813 
814     EmitImplData* pEData = getEmitData( rWriteContext );
815     if( pEData )
816         pEData->insertXref( m_nNumber, m_nGeneration, rWriteContext.getCurPos() );
817 
818     OStringBuffer aBuf( 32 );
819     aBuf.append( sal_Int32( m_nNumber ) );
820     aBuf.append( ' ' );
821     aBuf.append( sal_Int32( m_nGeneration ) );
822     aBuf.append( " obj\n" );
823     if( ! rWriteContext.write( aBuf.getStr(), aBuf.getLength() ) )
824         return false;
825 
826     if( pEData )
827         pEData->setDecryptObject( m_nNumber, m_nGeneration );
828     if( (rWriteContext.m_bDeflate || rWriteContext.m_bDecrypt) && pEData )
829     {
830         char* pStream = NULL;
831         unsigned int nBytes = 0;
832         bool bDeflate = getDeflatedStream( &pStream, &nBytes, pEData->m_pObjectContainer, rWriteContext );
833         if( pStream && nBytes )
834         {
835             // unzip the stream
836             sal_uInt8* pOutBytes = NULL;
837             sal_uInt32 nOutBytes = 0;
838             if( bDeflate && rWriteContext.m_bDeflate )
839                 unzipToBuffer( pStream, nBytes, &pOutBytes, &nOutBytes );
840             else
841             {
842                 // nothing to deflate, but decryption has happened
843                 pOutBytes = (sal_uInt8*)pStream;
844                 nOutBytes = (sal_uInt32)nBytes;
845             }
846 
847             if( nOutBytes )
848             {
849                 // clone this object
850                 PDFObject* pClone = static_cast<PDFObject*>(clone());
851                 // set length in the dictionary to new stream length
852                 PDFNumber* pNewLen = new PDFNumber( double(nOutBytes) );
853                 pClone->m_pStream->m_pDict->insertValue( "Length", pNewLen );
854 
855                 if( bDeflate && rWriteContext.m_bDeflate )
856                 {
857                     // delete flatedecode filter
858                     std::hash_map<OString,PDFEntry*,OStringHash>::const_iterator it =
859                     pClone->m_pStream->m_pDict->m_aMap.find( "Filter" );
860                     if( it != pClone->m_pStream->m_pDict->m_aMap.end() )
861                     {
862                         PDFName* pFilter = dynamic_cast<PDFName*>(it->second);
863                         if( pFilter && pFilter->m_aName.equals( "FlateDecode" ) )
864                             pClone->m_pStream->m_pDict->eraseValue( "Filter" );
865                         else
866                         {
867                             PDFArray* pArray = dynamic_cast<PDFArray*>(it->second);
868                             if( pArray && ! pArray->m_aSubElements.empty() )
869                             {
870                                 pFilter = dynamic_cast<PDFName*>(pArray->m_aSubElements.front());
871                                 if( pFilter && pFilter->m_aName.equals( "FlateDecode" ) )
872                                 {
873                                     delete pFilter;
874                                     pArray->m_aSubElements.erase( pArray->m_aSubElements.begin() );
875                                 }
876                             }
877                         }
878                     }
879                 }
880 
881                 // write sub elements except stream
882                 bool bRet = true;
883                 unsigned int nEle = pClone->m_aSubElements.size();
884                 for( unsigned int i = 0; i < nEle && bRet; i++ )
885                 {
886                     if( pClone->m_aSubElements[i] != pClone->m_pStream )
887                         bRet = pClone->m_aSubElements[i]->emit( rWriteContext );
888                 }
889                 delete pClone;
890                 // write stream
891                 if( bRet )
892                     rWriteContext.write( "stream\n", 7 );
893                 if( bRet )
894                     bRet = rWriteContext.write( pOutBytes, nOutBytes );
895                 if( bRet )
896                     bRet = rWriteContext.write( "\nendstream\nendobj\n", 18 );
897                 rtl_freeMemory( pStream );
898                 if( pOutBytes != (sal_uInt8*)pStream )
899                     rtl_freeMemory( pOutBytes );
900                 if( pEData )
901                     pEData->setDecryptObject( 0, 0 );
902                 return bRet;
903             }
904             if( pOutBytes != (sal_uInt8*)pStream )
905                 rtl_freeMemory( pOutBytes );
906         }
907         rtl_freeMemory( pStream );
908     }
909 
910     bool bRet = emitSubElements( rWriteContext ) &&
911                 rWriteContext.write( "\nendobj\n", 8 );
912     if( pEData )
913         pEData->setDecryptObject( 0, 0 );
914     return bRet;
915 }
916 
clone() const917 PDFEntry* PDFObject::clone() const
918 {
919     PDFObject* pNewOb = new PDFObject( m_nNumber, m_nGeneration );
920     cloneSubElements( pNewOb->m_aSubElements );
921     unsigned int nEle = m_aSubElements.size();
922     for( unsigned int i = 0; i < nEle; i++ )
923     {
924         if( m_aSubElements[i] == m_pObject )
925             pNewOb->m_pObject = pNewOb->m_aSubElements[i];
926         else if( m_aSubElements[i] == m_pStream && pNewOb->m_pObject )
927         {
928             pNewOb->m_pStream = dynamic_cast<PDFStream*>(pNewOb->m_aSubElements[i]);
929             PDFDict* pNewDict = dynamic_cast<PDFDict*>(pNewOb->m_pObject);
930             if( pNewDict )
931                 pNewOb->m_pStream->m_pDict = pNewDict;
932         }
933     }
934     return pNewOb;
935 }
936 
~PDFTrailer()937 PDFTrailer::~PDFTrailer()
938 {
939 }
940 
emit(EmitContext & rWriteContext) const941 bool PDFTrailer::emit( EmitContext& rWriteContext ) const
942 {
943     // get xref offset
944     unsigned int nXRefPos = rWriteContext.getCurPos();
945     // begin xref section, object 0 is always free
946     if( ! rWriteContext.write( "xref\r\n"
947                                "0 1\r\n"
948                                "0000000000 65535 f\r\n", 31 ) )
949         return false;
950     // check if we are emitting a complete PDF file
951     EmitImplData* pEData = getEmitData( rWriteContext );
952     if( pEData )
953     {
954         // emit object xrefs
955         const EmitImplData::XRefTable& rXRefs = pEData->m_aXRefTable;
956         EmitImplData::XRefTable::const_iterator section_begin, section_end;
957         section_begin = rXRefs.begin();
958         while( section_begin != rXRefs.end() )
959         {
960             // find end of continuous object numbers
961             section_end = section_begin;
962             unsigned int nLast = section_begin->first;
963             while( (++section_end) != rXRefs.end() &&
964                    section_end->first == nLast+1 )
965                 nLast = section_end->first;
966             // write first object number and number of following entries
967             OStringBuffer aBuf( 21 );
968             aBuf.append( sal_Int32( section_begin->first ) );
969             aBuf.append( ' ' );
970             aBuf.append( sal_Int32(nLast - section_begin->first + 1) );
971             aBuf.append( "\r\n" );
972             if( ! rWriteContext.write( aBuf.getStr(), aBuf.getLength() ) )
973                 return false;
974             while( section_begin != section_end )
975             {
976                 // write 20 char entry of form
977                 // 0000offset 00gen n\r\n
978                 aBuf.setLength( 0 );
979                 OString aOffset( OString::valueOf( sal_Int64(section_begin->second.second ) ) );
980                 int nPad = 10 - aOffset.getLength();
981                 for( int i = 0; i < nPad; i++ )
982                     aBuf.append( '0' );
983                 aBuf.append( aOffset );
984                 aBuf.append( ' ' );
985                 OString aGeneration( OString::valueOf( sal_Int32(section_begin->second.first ) ) );
986                 nPad = 5 - aGeneration.getLength();
987                 for( int i = 0; i < nPad; i++ )
988                     aBuf.append( '0' );
989                 aBuf.append( aGeneration );
990                 aBuf.append( " n\r\n" );
991                 if( ! rWriteContext.write( aBuf.getStr(), 20 ) )
992                     return false;
993                 ++section_begin;
994             }
995         }
996     }
997     if( ! rWriteContext.write( "trailer\n", 8 ) )
998         return false;
999     if( ! emitSubElements( rWriteContext ) )
1000         return false;
1001     if( ! rWriteContext.write( "startxref\n", 10 ) )
1002         return false;
1003     rtl::OString aOffset( rtl::OString::valueOf( sal_Int32(nXRefPos) ) );
1004     if( ! rWriteContext.write( aOffset.getStr(), aOffset.getLength() ) )
1005         return false;
1006     return rWriteContext.write( "\n%%EOF\n", 7 );
1007 }
1008 
clone() const1009 PDFEntry* PDFTrailer::clone() const
1010 {
1011     PDFTrailer* pNewTr = new PDFTrailer();
1012     cloneSubElements( pNewTr->m_aSubElements );
1013     unsigned int nEle = m_aSubElements.size();
1014     for( unsigned int i = 0; i < nEle; i++ )
1015     {
1016         if( m_aSubElements[i] == m_pDict )
1017         {
1018             pNewTr->m_pDict = dynamic_cast<PDFDict*>(pNewTr->m_aSubElements[i]);
1019             break;
1020         }
1021     }
1022     return pNewTr;
1023 }
1024 
1025 #define ENCRYPTION_KEY_LEN 16
1026 #define ENCRYPTION_BUF_LEN 32
1027 
1028 namespace pdfparse {
1029 struct PDFFileImplData
1030 {
1031     bool        m_bIsEncrypted;
1032     bool        m_bStandardHandler;
1033     sal_uInt32  m_nAlgoVersion;
1034     sal_uInt32  m_nStandardRevision;
1035     sal_uInt32  m_nKeyLength;
1036     sal_uInt8   m_aOEntry[32];
1037     sal_uInt8   m_aUEntry[32];
1038     sal_uInt32  m_nPEntry;
1039     OString     m_aDocID;
1040     rtlCipher   m_aCipher;
1041     rtlDigest   m_aDigest;
1042 
1043     sal_uInt8   m_aDecryptionKey[ENCRYPTION_KEY_LEN+5]; // maximum handled key length
1044 
PDFFileImplDatapdfparse::PDFFileImplData1045     PDFFileImplData() :
1046         m_bIsEncrypted( false ),
1047         m_bStandardHandler( false ),
1048         m_nAlgoVersion( 0 ),
1049         m_nStandardRevision( 0 ),
1050         m_nKeyLength( 0 ),
1051         m_nPEntry( 0 ),
1052         m_aCipher( NULL ),
1053         m_aDigest( NULL )
1054     {
1055         rtl_zeroMemory( m_aOEntry, sizeof( m_aOEntry ) );
1056         rtl_zeroMemory( m_aUEntry, sizeof( m_aUEntry ) );
1057         rtl_zeroMemory( m_aDecryptionKey, sizeof( m_aDecryptionKey ) );
1058     }
1059 
~PDFFileImplDatapdfparse::PDFFileImplData1060     ~PDFFileImplData()
1061     {
1062         if( m_aCipher )
1063             rtl_cipher_destroyARCFOUR( m_aCipher );
1064         if( m_aDigest )
1065             rtl_digest_destroyMD5( m_aDigest );
1066     }
1067 };
1068 }
1069 
~PDFFile()1070 PDFFile::~PDFFile()
1071 {
1072     if( m_pData )
1073         delete m_pData;
1074 }
1075 
isEncrypted() const1076 bool PDFFile::isEncrypted() const
1077 {
1078     return impl_getData()->m_bIsEncrypted;
1079 }
1080 
decrypt(const sal_uInt8 * pInBuffer,sal_uInt32 nLen,sal_uInt8 * pOutBuffer,unsigned int nObject,unsigned int nGeneration) const1081 bool PDFFile::decrypt( const sal_uInt8* pInBuffer, sal_uInt32 nLen, sal_uInt8* pOutBuffer,
1082                        unsigned int nObject, unsigned int nGeneration ) const
1083 {
1084     if( ! isEncrypted() )
1085         return false;
1086 
1087     if( ! m_pData->m_aCipher )
1088         m_pData->m_aCipher = rtl_cipher_createARCFOUR( rtl_Cipher_ModeStream );
1089 
1090     // modify encryption key
1091     sal_uInt32 i = m_pData->m_nKeyLength;
1092     m_pData->m_aDecryptionKey[i++] = sal_uInt8(nObject&0xff);
1093     m_pData->m_aDecryptionKey[i++] = sal_uInt8((nObject>>8)&0xff);
1094     m_pData->m_aDecryptionKey[i++] = sal_uInt8((nObject>>16)&0xff);
1095     m_pData->m_aDecryptionKey[i++] = sal_uInt8(nGeneration&0xff);
1096     m_pData->m_aDecryptionKey[i++] = sal_uInt8((nGeneration>>8)&0xff);
1097 
1098     sal_uInt8 aSum[ENCRYPTION_KEY_LEN];
1099     rtl_digest_updateMD5( m_pData->m_aDigest, m_pData->m_aDecryptionKey, i );
1100     rtl_digest_getMD5( m_pData->m_aDigest, aSum, sizeof( aSum ) );
1101 
1102     if( i > 16 )
1103         i = 16;
1104 
1105     rtlCipherError aErr = rtl_cipher_initARCFOUR( m_pData->m_aCipher,
1106                                                   rtl_Cipher_DirectionDecode,
1107                                                   aSum, i,
1108                                                   NULL, 0 );
1109     if( aErr == rtl_Cipher_E_None )
1110         aErr = rtl_cipher_decodeARCFOUR( m_pData->m_aCipher,
1111                                          pInBuffer, nLen,
1112                                          pOutBuffer, nLen );
1113     return aErr == rtl_Cipher_E_None;
1114 }
1115 
1116 static const sal_uInt8 nPadString[32] =
1117 {
1118     0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41, 0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08,
1119     0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80, 0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A
1120 };
1121 
pad_or_truncate_to_32(const OString & rStr,sal_Char * pBuffer)1122 static void pad_or_truncate_to_32( const OString& rStr, sal_Char* pBuffer )
1123 {
1124     int nLen = rStr.getLength();
1125     if( nLen > 32 )
1126         nLen = 32;
1127     const sal_Char* pStr = rStr.getStr();
1128     rtl_copyMemory( pBuffer, pStr, nLen );
1129     int i = 0;
1130     while( nLen < 32 )
1131         pBuffer[nLen++] = nPadString[i++];
1132 }
1133 
1134 // pass at least pData->m_nKeyLength bytes in
password_to_key(const OString & rPwd,sal_uInt8 * pOutKey,PDFFileImplData * pData,bool bComputeO)1135 static sal_uInt32 password_to_key( const OString& rPwd, sal_uInt8* pOutKey, PDFFileImplData* pData, bool bComputeO )
1136 {
1137     // see PDF reference 1.4 Algorithm 3.2
1138     // encrypt pad string
1139     sal_Char aPadPwd[ENCRYPTION_BUF_LEN];
1140     pad_or_truncate_to_32( rPwd, aPadPwd );
1141     rtl_digest_updateMD5( pData->m_aDigest, aPadPwd, sizeof( aPadPwd ) );
1142     if( ! bComputeO )
1143     {
1144         rtl_digest_updateMD5( pData->m_aDigest, pData->m_aOEntry, 32 );
1145         sal_uInt8 aPEntry[4];
1146         aPEntry[0] = static_cast<sal_uInt8>(pData->m_nPEntry & 0xff);
1147         aPEntry[1] = static_cast<sal_uInt8>((pData->m_nPEntry >> 8 ) & 0xff);
1148         aPEntry[2] = static_cast<sal_uInt8>((pData->m_nPEntry >> 16) & 0xff);
1149         aPEntry[3] = static_cast<sal_uInt8>((pData->m_nPEntry >> 24) & 0xff);
1150         rtl_digest_updateMD5( pData->m_aDigest, aPEntry, sizeof(aPEntry) );
1151         rtl_digest_updateMD5( pData->m_aDigest, pData->m_aDocID.getStr(), pData->m_aDocID.getLength() );
1152     }
1153     sal_uInt8 nSum[RTL_DIGEST_LENGTH_MD5];
1154     rtl_digest_getMD5( pData->m_aDigest, nSum, sizeof(nSum) );
1155     if( pData->m_nStandardRevision == 3 )
1156     {
1157         for( int i = 0; i < 50; i++ )
1158         {
1159             rtl_digest_updateMD5( pData->m_aDigest, nSum, sizeof(nSum) );
1160             rtl_digest_getMD5( pData->m_aDigest, nSum, sizeof(nSum) );
1161         }
1162     }
1163     sal_uInt32 nLen = pData->m_nKeyLength;
1164     if( nLen > RTL_DIGEST_LENGTH_MD5 )
1165         nLen = RTL_DIGEST_LENGTH_MD5;
1166     rtl_copyMemory( pOutKey, nSum, nLen );
1167     return nLen;
1168 }
1169 
check_user_password(const OString & rPwd,PDFFileImplData * pData)1170 static bool check_user_password( const OString& rPwd, PDFFileImplData* pData )
1171 {
1172     // see PDF reference 1.4 Algorithm 3.6
1173     bool bValid = false;
1174     sal_uInt8 aKey[ENCRYPTION_KEY_LEN];
1175     sal_uInt8 nEncryptedEntry[ENCRYPTION_BUF_LEN];
1176     rtl_zeroMemory( nEncryptedEntry, sizeof(nEncryptedEntry) );
1177     sal_uInt32 nKeyLen = password_to_key( rPwd, aKey, pData, false );
1178     // save (at this time potential) decryption key for later use
1179     rtl_copyMemory( pData->m_aDecryptionKey, aKey, nKeyLen );
1180     if( pData->m_nStandardRevision == 2 )
1181     {
1182         // see PDF reference 1.4 Algorithm 3.4
1183         // encrypt pad string
1184         rtl_cipher_initARCFOUR( pData->m_aCipher, rtl_Cipher_DirectionEncode,
1185                                 aKey, nKeyLen,
1186                                 NULL, 0 );
1187         rtl_cipher_encodeARCFOUR( pData->m_aCipher, nPadString, sizeof( nPadString ),
1188                                   nEncryptedEntry, sizeof( nEncryptedEntry ) );
1189         bValid = (rtl_compareMemory( nEncryptedEntry, pData->m_aUEntry, 32 ) == 0);
1190     }
1191     else if( pData->m_nStandardRevision == 3 )
1192     {
1193         // see PDF reference 1.4 Algorithm 3.5
1194         rtl_digest_updateMD5( pData->m_aDigest, nPadString, sizeof( nPadString ) );
1195         rtl_digest_updateMD5( pData->m_aDigest, pData->m_aDocID.getStr(), pData->m_aDocID.getLength() );
1196         rtl_digest_getMD5( pData->m_aDigest, nEncryptedEntry, sizeof(nEncryptedEntry) );
1197         rtl_cipher_initARCFOUR( pData->m_aCipher, rtl_Cipher_DirectionEncode,
1198                                 aKey, sizeof(aKey), NULL, 0 );
1199         rtl_cipher_encodeARCFOUR( pData->m_aCipher,
1200                                   nEncryptedEntry, 16,
1201                                   nEncryptedEntry, 16 ); // encrypt in place
1202         for( int i = 1; i <= 19; i++ ) // do it 19 times, start with 1
1203         {
1204             sal_uInt8 aTempKey[ENCRYPTION_KEY_LEN];
1205             for( sal_uInt32 j = 0; j < sizeof(aTempKey); j++ )
1206                 aTempKey[j] = static_cast<sal_uInt8>( aKey[j] ^ i );
1207 
1208             rtl_cipher_initARCFOUR( pData->m_aCipher, rtl_Cipher_DirectionEncode,
1209                                     aTempKey, sizeof(aTempKey), NULL, 0 );
1210             rtl_cipher_encodeARCFOUR( pData->m_aCipher,
1211                                       nEncryptedEntry, 16,
1212                                       nEncryptedEntry, 16 ); // encrypt in place
1213         }
1214         bValid = (rtl_compareMemory( nEncryptedEntry, pData->m_aUEntry, 16 ) == 0);
1215     }
1216     return bValid;
1217 }
1218 
setupDecryptionData(const OString & rPwd) const1219 bool PDFFile::setupDecryptionData( const OString& rPwd ) const
1220 {
1221     if( !impl_getData()->m_bIsEncrypted )
1222         return rPwd.getLength() == 0;
1223 
1224     // check if we can handle this encryption at all
1225     if( ! m_pData->m_bStandardHandler ||
1226         m_pData->m_nAlgoVersion < 1 ||
1227         m_pData->m_nAlgoVersion > 2 ||
1228         m_pData->m_nStandardRevision < 2 ||
1229         m_pData->m_nStandardRevision > 3 )
1230         return false;
1231 
1232     if( ! m_pData->m_aCipher )
1233         m_pData->m_aCipher = rtl_cipher_createARCFOUR(rtl_Cipher_ModeStream);
1234     if( ! m_pData->m_aDigest )
1235         m_pData->m_aDigest = rtl_digest_createMD5();
1236 
1237     // first try user password
1238     bool bValid = check_user_password( rPwd, m_pData );
1239 
1240     if( ! bValid )
1241     {
1242         // try owner password
1243         // see PDF reference 1.4 Algorithm 3.7
1244         sal_uInt8 aKey[ENCRYPTION_KEY_LEN];
1245         sal_uInt8 nPwd[ENCRYPTION_BUF_LEN];
1246         rtl_zeroMemory( nPwd, sizeof(nPwd) );
1247         sal_uInt32 nKeyLen = password_to_key( rPwd, aKey, m_pData, true );
1248         if( m_pData->m_nStandardRevision == 2 )
1249         {
1250             rtl_cipher_initARCFOUR( m_pData->m_aCipher, rtl_Cipher_DirectionDecode,
1251                                     aKey, nKeyLen, NULL, 0 );
1252             rtl_cipher_decodeARCFOUR( m_pData->m_aCipher,
1253                                       m_pData->m_aOEntry, 32,
1254                                       nPwd, 32 );
1255         }
1256         else if( m_pData->m_nStandardRevision == 3 )
1257         {
1258             rtl_copyMemory( nPwd, m_pData->m_aOEntry, 32 );
1259             for( int i = 19; i >= 0; i-- )
1260             {
1261                 sal_uInt8 nTempKey[ENCRYPTION_KEY_LEN];
1262                 for( unsigned int j = 0; j < sizeof(nTempKey); j++ )
1263                     nTempKey[j] = sal_uInt8(aKey[j] ^ i);
1264                 rtl_cipher_initARCFOUR( m_pData->m_aCipher, rtl_Cipher_DirectionDecode,
1265                                         nTempKey, nKeyLen, NULL, 0 );
1266                 rtl_cipher_decodeARCFOUR( m_pData->m_aCipher,
1267                                           nPwd, 32,
1268                                           nPwd, 32 ); // decrypt inplace
1269             }
1270         }
1271         bValid = check_user_password( OString( (sal_Char*)nPwd, 32 ), m_pData );
1272     }
1273 
1274     return bValid;
1275 }
1276 
getDecryptionKey() const1277 rtl::OUString PDFFile::getDecryptionKey() const
1278 {
1279     rtl::OUStringBuffer aBuf( ENCRYPTION_KEY_LEN * 2 );
1280     if( impl_getData()->m_bIsEncrypted )
1281     {
1282         for( sal_uInt32 i = 0; i < m_pData->m_nKeyLength; i++ )
1283         {
1284             static const sal_Unicode pHexTab[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
1285                                                      '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
1286             aBuf.append( pHexTab[(m_pData->m_aDecryptionKey[i] >> 4) & 0x0f] );
1287             aBuf.append( pHexTab[(m_pData->m_aDecryptionKey[i] & 0x0f)] );
1288         }
1289 
1290     }
1291     return aBuf.makeStringAndClear();
1292 }
1293 
impl_getData() const1294 PDFFileImplData* PDFFile::impl_getData() const
1295 {
1296     if( m_pData )
1297         return m_pData;
1298     m_pData = new PDFFileImplData();
1299     // check for encryption dict in a trailer
1300     unsigned int nElements = m_aSubElements.size();
1301     while( nElements-- > 0 )
1302     {
1303         PDFTrailer* pTrailer = dynamic_cast<PDFTrailer*>(m_aSubElements[nElements]);
1304         if( pTrailer && pTrailer->m_pDict )
1305         {
1306             // search doc id
1307             PDFDict::Map::iterator doc_id = pTrailer->m_pDict->m_aMap.find( "ID" );
1308             if( doc_id != pTrailer->m_pDict->m_aMap.end() )
1309             {
1310                 PDFArray* pArr = dynamic_cast<PDFArray*>(doc_id->second);
1311                 if( pArr && pArr->m_aSubElements.size() > 0 )
1312                 {
1313                     PDFString* pStr = dynamic_cast<PDFString*>(pArr->m_aSubElements[0]);
1314                     if( pStr )
1315                         m_pData->m_aDocID = pStr->getFilteredString();
1316                     #if OSL_DEBUG_LEVEL > 1
1317                     fprintf( stderr, "DocId is <" );
1318                     for( int i = 0; i < m_pData->m_aDocID.getLength(); i++ )
1319                         fprintf( stderr, "%.2x", (unsigned int)sal_uInt8(m_pData->m_aDocID.getStr()[i]) );
1320                     fprintf( stderr, ">\n" );
1321                     #endif
1322                 }
1323             }
1324             // search Encrypt entry
1325             PDFDict::Map::iterator enc =
1326                 pTrailer->m_pDict->m_aMap.find( "Encrypt" );
1327             if( enc != pTrailer->m_pDict->m_aMap.end() )
1328             {
1329                 PDFDict* pDict = dynamic_cast<PDFDict*>(enc->second);
1330                 if( ! pDict )
1331                 {
1332                     PDFObjectRef* pRef = dynamic_cast<PDFObjectRef*>(enc->second);
1333                     if( pRef )
1334                     {
1335                         PDFObject* pObj = findObject( pRef );
1336                         if( pObj && pObj->m_pObject )
1337                             pDict = dynamic_cast<PDFDict*>(pObj->m_pObject);
1338                     }
1339                 }
1340                 if( pDict )
1341                 {
1342                     PDFDict::Map::iterator filter = pDict->m_aMap.find( "Filter" );
1343                     PDFDict::Map::iterator version = pDict->m_aMap.find( "V" );
1344                     PDFDict::Map::iterator len = pDict->m_aMap.find( "Length" );
1345                     PDFDict::Map::iterator o_ent = pDict->m_aMap.find( "O" );
1346                     PDFDict::Map::iterator u_ent = pDict->m_aMap.find( "U" );
1347                     PDFDict::Map::iterator r_ent = pDict->m_aMap.find( "R" );
1348                     PDFDict::Map::iterator p_ent = pDict->m_aMap.find( "P" );
1349                     if( filter != pDict->m_aMap.end() )
1350                     {
1351                         m_pData->m_bIsEncrypted = true;
1352                         m_pData->m_nKeyLength = 5;
1353                         if( version != pDict->m_aMap.end() )
1354                         {
1355                             PDFNumber* pNum = dynamic_cast<PDFNumber*>(version->second);
1356                             if( pNum )
1357                                 m_pData->m_nAlgoVersion = static_cast<sal_uInt32>(pNum->m_fValue);
1358                         }
1359                         if( m_pData->m_nAlgoVersion >= 3 )
1360                             m_pData->m_nKeyLength = 16;
1361                         if( len != pDict->m_aMap.end() )
1362                         {
1363                             PDFNumber* pNum = dynamic_cast<PDFNumber*>(len->second);
1364                             if( pNum )
1365                                 m_pData->m_nKeyLength = static_cast<sal_uInt32>(pNum->m_fValue) / 8;
1366                         }
1367                         PDFName* pFilter = dynamic_cast<PDFName*>(filter->second);
1368                         if( pFilter && pFilter->getFilteredName().equalsAscii( "Standard" ) )
1369                             m_pData->m_bStandardHandler = true;
1370                         if( o_ent != pDict->m_aMap.end() )
1371                         {
1372                             PDFString* pString = dynamic_cast<PDFString*>(o_ent->second);
1373                             if( pString )
1374                             {
1375                                 OString aEnt = pString->getFilteredString();
1376                                 if( aEnt.getLength() == 32 )
1377                                     rtl_copyMemory( m_pData->m_aOEntry, aEnt.getStr(), 32 );
1378                                 #if OSL_DEBUG_LEVEL > 1
1379                                 else
1380                                 {
1381                                     fprintf( stderr, "O entry has length %d, should be 32 <", (int)aEnt.getLength() );
1382                                     for( int i = 0; i < aEnt.getLength(); i++ )
1383                                         fprintf( stderr, " %.2X", (unsigned int)sal_uInt8(aEnt.getStr()[i]) );
1384                                     fprintf( stderr, ">\n" );
1385                                 }
1386                                 #endif
1387                             }
1388                         }
1389                         if( u_ent != pDict->m_aMap.end() )
1390                         {
1391                             PDFString* pString = dynamic_cast<PDFString*>(u_ent->second);
1392                             if( pString )
1393                             {
1394                                 OString aEnt = pString->getFilteredString();
1395                                 if( aEnt.getLength() == 32 )
1396                                     rtl_copyMemory( m_pData->m_aUEntry, aEnt.getStr(), 32 );
1397                                 #if OSL_DEBUG_LEVEL > 1
1398                                 else
1399                                 {
1400                                     fprintf( stderr, "U entry has length %d, should be 32 <", (int)aEnt.getLength() );
1401                                     for( int i = 0; i < aEnt.getLength(); i++ )
1402                                         fprintf( stderr, " %.2X", (unsigned int)sal_uInt8(aEnt.getStr()[i]) );
1403                                     fprintf( stderr, ">\n" );
1404                                 }
1405                                 #endif
1406                             }
1407                         }
1408                         if( r_ent != pDict->m_aMap.end() )
1409                         {
1410                             PDFNumber* pNum = dynamic_cast<PDFNumber*>(r_ent->second);
1411                             if( pNum )
1412                                 m_pData->m_nStandardRevision = static_cast<sal_uInt32>(pNum->m_fValue);
1413                         }
1414                         if( p_ent != pDict->m_aMap.end() )
1415                         {
1416                             PDFNumber* pNum = dynamic_cast<PDFNumber*>(p_ent->second);
1417                             if( pNum )
1418                                 m_pData->m_nPEntry = static_cast<sal_uInt32>(static_cast<sal_Int32>(pNum->m_fValue));
1419                             #if OSL_DEBUG_LEVEL > 1
1420                             fprintf( stderr, "p entry is %p\n", (void*)m_pData->m_nPEntry );
1421                             #endif
1422                         }
1423                         #if OSL_DEBUG_LEVEL > 1
1424                         fprintf( stderr, "Encryption dict: sec handler: %s, version = %d, revision = %d, key length = %d\n",
1425                                  pFilter ? OUStringToOString( pFilter->getFilteredName(), RTL_TEXTENCODING_UTF8 ).getStr() : "<unknown>",
1426                                  (int)m_pData->m_nAlgoVersion, (int)m_pData->m_nStandardRevision, (int)m_pData->m_nKeyLength );
1427                         #endif
1428                         break;
1429                     }
1430                 }
1431             }
1432         }
1433     }
1434 
1435     return m_pData;
1436 }
1437 
emit(EmitContext & rWriteContext) const1438 bool PDFFile::emit( EmitContext& rWriteContext ) const
1439 {
1440     setEmitData(  rWriteContext, new EmitImplData( this ) );
1441 
1442     OStringBuffer aBuf( 32 );
1443     aBuf.append( "%PDF-" );
1444     aBuf.append( sal_Int32( m_nMajor ) );
1445     aBuf.append( '.' );
1446     aBuf.append( sal_Int32( m_nMinor ) );
1447     aBuf.append( "\n" );
1448     if( ! rWriteContext.write( aBuf.getStr(), aBuf.getLength() ) )
1449         return false;
1450     return emitSubElements( rWriteContext );
1451 }
1452 
clone() const1453 PDFEntry* PDFFile::clone() const
1454 {
1455     PDFFile* pNewFl = new PDFFile();
1456     pNewFl->m_nMajor = m_nMajor;
1457     pNewFl->m_nMinor = m_nMinor;
1458     cloneSubElements( pNewFl->m_aSubElements );
1459     return pNewFl;
1460 }
1461 
~PDFPart()1462 PDFPart::~PDFPart()
1463 {
1464 }
1465 
emit(EmitContext & rWriteContext) const1466 bool PDFPart::emit( EmitContext& rWriteContext ) const
1467 {
1468     return emitSubElements( rWriteContext );
1469 }
1470 
clone() const1471 PDFEntry* PDFPart::clone() const
1472 {
1473     PDFPart* pNewPt = new PDFPart();
1474     cloneSubElements( pNewPt->m_aSubElements );
1475     return pNewPt;
1476 }
1477 
1478