% Copyright (C) 1996-1998 Geoffrey Keating.

% Copyright (C) 2001 Artifex Software, Inc.

% This file may be freely distributed with or without modifications,
% so long as modified versions are marked as such and copyright notices are
% not removed.

% $Id: pdf_sec.ps,v 1.15 2004/03/12 01:55:58 dan Exp $

% Implementation of security hooks for PDF reader.

% This file contains the procedures that have to take encryption into
% account when reading a PDF file. It replaces the stub version of this
% file that is shipped with GhostScript. It requires GhostScript 7.01
% or later.

% Documentation for using this file is available at

% http://www.ozemail.com.au/%7Egeoffk/pdfencrypt/

% Modified by Alex Cherepanov to work with GS 6.60 and higher.

% New versions of GS require explicit checks for /true , /false, and /null
% in .decpdfrun . This fix is backward-compatible.

% Modified by Raph Levien and Ralph Giles to use the new C

% implementations of md5 and arcfour in ghostscript 7.01, and to
% be compatible with PDF 1.4 128-bit encryption.

/.setlanguagelevel where { pop 2 .setlanguagelevel } if

.currentglobal true .setglobal
/pdfdict where { pop } { /pdfdict 100 dict def } ifelse
pdfdict begin

% Older ghostscript versions do not have .pdftoken, so we use 'token' instead.

/.pdftoken where { pop } { /.pdftoken /token load def } ifelse

% take a stream and arc4 decrypt it.

% <stream> <key> arc4decodefilter <stream>
/arc4decodefilter {
1 dict begin
/Key exch def
currentdict end /ArcfourDecode filter
} bind def

% <ciphertext> <key> arc4decode <plaintext>

/arc4decode {
%(key: ) print dup == (ct: ) print 1 index ==
1 index length 0 eq {
pop
} {
1 index length string 3 1 roll arc4decodefilter exch readstring pop
} ifelse
} bind def

/md5 {
16 string dup /MD5Encode filter dup 4 3 roll writestring closefile
} bind def

/md5_trunk {
md5 0 pdf_key_length getinterval
} bind def
/pdf_padding_string
<28bf4e5e4e758a41 64004e56fffa0108
2e2e00b6d0683e80 2f0ca9fe6453697a>
def

% Pad a key out to 32 bytes.

/pdf_pad_key { % <key> pdf_pad_key <padded key>
dup length 32 gt { 0 32 getinterval } if
pdf_padding_string
0 32 3 index length sub getinterval
concatstrings
} bind def

/pdf_xorbytes { % <iter-num> <key> pdf_xorbytes <xored-key>

dup length dup string
exch 1 sub 0 1 3 2 roll {
% <iter-num> <key> <new-key> <byte-num>
dup 3 index exch get 4 index xor
% <iter-num> <key> <new-key> <byte-num> <byte>
3 copy put pop pop
} for
3 1 roll pop pop
} bind def

% Get length of encryption key in bytes

/pdf_key_length { % pdf_key_length <key_length>
Trailer /Encrypt oget /Length knownoget { -3 bitshift } { 5 } ifelse
} bind def

% Algorithm 3.2
/pdf_compute_encryption_key { % <password> pdf_compute_encryption_key <key>
% Step 1.
pdf_pad_key

% Step 2, 3.
Trailer /Encrypt oget dup /O oget
% <padded-key> <encrypt> <O>

% Step 4.
exch /P oget 4 string exch
2 copy 255 and 0 exch put
2 copy -8 bitshift 255 and 1 exch put
2 copy -16 bitshift 255 and 2 exch put
2 copy -24 bitshift 255 and 3 exch put pop
% <padded-key> <O> <P>

% Step 5.
Trailer /ID knownoget { 0 oget } {
()
( **** ID key in the trailer is required for encrypted files.\n)
pdfformaterror
} ifelse
3 { concatstrings } repeat
% We will finish step 5 after possibly including step 6.

% The following only executed for /R equal to 3 or more

Trailer /Encrypt oget dup /R oget dup 3 ge {
 % Step 6. If EncryptMetadata is false, pass 0xFFFFFFFF to md5 function
% The PDF 1.5 Spec says that EncryptMetadata is an undocumented
% feature of PDF 1.4. That implies that this piece of logic should
% be executed if R >= 3. However testing with Acrobat 5.0 and 6.0 shows
% that this step is not executed if R equal to 3. Thus we have a test for
% R being >= 4.
4 ge {
/EncryptMetadata knownoget % Get EncryptMetadata (if present)
not { true } if % Default is true
not { % If EncryptMetadata is false
<ff ff ff ff> concatstrings % Add 0xFFFFFFFF to working string
} if
} {
pop % Remove Encrypt dict
} ifelse
md5_trunk % Finish step 5 and 6.

% Step 7. Executed as part of step 6

% Step 8. (This step is defintely a part of PDF 1.4.)
50 { md5_trunk } repeat
} {
pop pop md5_trunk % Remove R, Encrypt dict, finish step 5
} ifelse

% Step 9 - Done in md5_trunk.

} bind def

% Algorithm 3.4
/pdf_gen_user_password_R2 { % <filekey> pdf_gen_user_password_R2 <U>

% Step 2.
pdf_padding_string exch arc4decode
} bind def

% Algorithm 3.5
/pdf_gen_user_password_R3 { % <filekey> pdf_gen_user_password_R3 <U>

% Step 2.
pdf_padding_string

% Step 3.
Trailer /ID knownoget { 0 oget } {
()
( **** ID key in the trailer is required for encrypted files.\n)
pdfformaterror
} ifelse
concatstrings md5

% Step 4.
1 index arc4decode

% Step 5.
1 1 19 {
2 index pdf_xorbytes arc4decode
} for
exch pop

} bind def
/pdf_gen_user_password { % <password> pdf_gen_user_password <filekey> <U>
% common Step 1 of Algorithms 3.4 and 3.5.
pdf_compute_encryption_key dup

Trailer /Encrypt oget

/R oget dup 2 eq {
pop pdf_gen_user_password_R2
} {
dup 3 eq {
pop pdf_gen_user_password_R3
} {
dup 4 eq { % 4 uses the algorithm as 3
pop pdf_gen_user_password_R3
} {
( **** This file uses an unknown standard security handler revision: )
exch =string cvs concatstrings pdfformaterror printProducer
/pdf_check_user_password cvx /undefined signalerror
} ifelse
} ifelse
} ifelse
} bind def

% Algorithm 3.6
/pdf_check_user_password { % <password> pdf_check_user_password <filekey> true
% <password> pdf_check_user_password false
pdf_gen_user_password

Trailer /Encrypt oget /U oget

0 2 index length getinterval eq {

true
} {
pop false
} ifelse
} bind def

% Compute an owner key, ie the result of step 4 of Algorithm 3.3

/pdf_owner_key % <password> pdf_owner_key <owner-key>
{
% Step 1.
pdf_pad_key

% Step 2.
md5_trunk

% 3.3 Step 3. Only executed for /R equal to 3 or more

Trailer /Encrypt oget /R oget 3 ge {
50 { md5_trunk } repeat
} if

% Step 4 - Done in md5_trunk.

} bind def

% Algorithm 3.7
/pdf_check_owner_password { % <password> pdf_check_owner_password <filekey> true
% <password> pdf_check_owner_password false
% Step 1.
pdf_owner_key
 % Step 2.
Trailer /Encrypt oget dup /O oget 2 index arc4decode
% <encryption-key> <encrypt-dict> <decrypted-O>

% Step 3. Only executed for /R equal to 3 or more

exch /R oget 3 ge {
1 1 19 {
2 index pdf_xorbytes arc4decode
} for
} if
exch pop
% <result-of-step-3>

pdf_check_user_password
} bind def

% Process the encryption information in the Trailer.

/pdf_process_Encrypt {
Trailer /Encrypt oget
/Filter oget /Standard eq not {
( **** This file uses an unknown security handler.\n) pdfformaterror
printProducer
/pdf_process_Encrypt cvx /undefined signalerror
} if
() pdf_check_user_password
{
/FileKey exch def
} {
/PDFPassword where {
pop PDFPassword pdf_check_user_password
{
/FileKey exch def
} {
PDFPassword pdf_check_owner_password
{
/FileKey exch def
} {
( **** Password did not work.\n) pdfformaterror
printProducer
/pdf_process_Encrypt cvx /invalidfileaccess signalerror
} ifelse
} ifelse
} {
( **** This file requires a password for access.\n) pdfformaterror
printProducer
/pdf_process_Encrypt cvx /invalidfileaccess signalerror
} ifelse
} ifelse

% Trailer /Encrypt oget /P oget 4 and 0 eq #? and

% { ( ****This owner of this file has requested you do not print it.\n)
% pdfformaterror printProducer
% /pdf_process_Encrypt cvx /invalidfileaccess signalerror
% }
% if
} bind def

% Calculate the key used to decrypt an object (to pass to .decpdfrun or

% put into a stream dictionary).
/computeobjkey % <object#> <generation#> computeobjkey <keystring>
{
exch
FileKey length 5 add string
dup 0 FileKey putinterval
exch
% stack: gen# string obj#
2 copy 255 and FileKey length exch put
2 copy -8 bitshift 255 and FileKey length 1 add exch put
2 copy -16 bitshift 255 and FileKey length 2 add exch put
pop exch
2 copy 255 and FileKey length 3 add exch put
2 copy -8 bitshift 255 and FileKey length 4 add exch put
pop md5 0 FileKey length 5 add 2 index length .min getinterval
} bind def

% As .pdfrun, but decrypt strings with key <key>.

/.decpdfrun % <file> <keystring> <opdict> .decpdfrun -
{ % Construct a procedure with the file, opdict and key bound into it.
2 index cvlit mark mark 5 2 roll
{ .pdftoken not { (%%EOF) cvn cvx } if
dup xcheck
{ PDFDEBUG { dup == flush } if
3 -1 roll pop
2 copy .knownget
{ exch pop exch pop exec
}
{ exch pop
dup /true eq
{ pop //true
}
{ dup /false eq
{ pop //false
}
{ dup /null eq
{ pop //null
}
{ ( **** Unknown operator: )
exch =string cvs concatstrings (\n) concatstrings
pdfformaterror
}
ifelse
}
ifelse
}
ifelse
}
ifelse
}
{ exch pop PDFDEBUG { dup ==only ( ) print flush } if
dup type /stringtype eq
{
% Check if we have encrypted strings R=4 allows for
% selection of encryption on streams and strings
Trailer /Encrypt oget % Get encryption dictionary
dup /R oget 4 lt % only 4 has selectable
{ % R < 4 --> encrypted strings
pop 1 index arc4decode % Decrypt string
 PDFDEBUG { (%Decrypted: ) print dup == flush } if
} { % Else R = 4
/StrF knownoget % Get StrF (if present)
{ % If StrF is present ...
/Identity eq not % Check if StrF != Identity
{ 1 index arc4decode % Decrypt string
PDFDEBUG { (%Decrypted: ) print dup == flush } if
}
if % If StrF != identity
}
if % If StrF is known
}
ifelse % Ifelse R < 4
}
if % If = stringtype
exch pop
}
ifelse
}
aload pop .packtomark cvx
/loop cvx 2 packedarray cvx
{ stopped /PDFsource } aload pop
PDFsource
{ store { stop } if } aload pop .packtomark cvx
/PDFsource 3 -1 roll store exec
} bind def

% Run the code to resolve an object reference.

/pdf_run_resolve
{ /FileKey where % Check if the file is encrypted
{ pop % File is encrypted
2 copy computeobjkey dup 4 1 roll
PDFfile exch resolveopdict .decpdfrun
dup dup dup 5 2 roll
% stack: object object key object object
{ % Use loop to provide an exitable context.
xcheck exch type /dicttype eq and % Check if executable dictionary
not { % If object is not ...
pop pop % ignore object
exit % Exit 'loop' context
} if % If not possible stream
% Starting with PDF 1.4 (R = 3), there are some extra features
% which control encryption of streams. The EncryptMetadata entry
% in the Encrypt dict controls the encryption of metadata streams.
Trailer /Encrypt oget % Get encryption dictionary
dup /R oget dup 3 lt % Only PDF 1.4 and higher has options
{ % R < 3 --> all streams encrypted
pop pop /StreamKey exch put % Insert StreamKey in dictionary
exit % Exit 'loop' context
} if
% Check EncryptMeta. stack: object object key Encrypt R
exch dup /EncryptMetadata knownoget % Get EncryptMetadata (if present)
not { true } if % If not present default = true
not % Check if EncryptMetadata = false
{ % if false we need to check the stream type
3 index /Type knownoget % Get stream type (if present)
not { //null } if % If type not present use fake name
/Metadata eq % Check if the type is Metadata
{ pop pop pop pop % Type == Metadata --> no encryption
 exit % Exit 'loop' context
} if
} if
% PDF 1.5 encryption (R == 4) has selectable encryption handlers. If
% this is not PDF 1.5 encryption (R < 4) then we are done checking and
% we need to decrypt the stream. stack: object object key R Encrypt
exch 4 lt % Check for less than PDF 1.5
{ pop /StreamKey exch put % Insert StreamKey in dictionary
exit % Exit 'loop' context
} if
% Check if the stream encryption handler (StmF) == Identity.
/StmF knownoget % Get StmF (if present)
not { /Identity } if % If StmF not present default = Identity
/Identity eq % Check if StmF == Identity
{ pop pop % Identity --> no encryption
exit % Exit 'loop' context
} if
% If we get here then we need to decrypt the stream.
/StreamKey exch put % Insert StreamKey into dictionary
exit % Exit 'loop' context, never loop
} loop % End of loop exitable context
} { % Else file is not encrypted
PDFfile resolveopdict .pdfrun
} ifelse % Ifelse encrypted
} bind def

% Prefix a decryption filter to a stream if needed.

% Stack: readdata? dict parms file/string filternames
% (both before and after).
/pdf_decrypt_stream
{ 3 index /StreamKey known % Check if the file is encrypted
{
exch
% Stack: readdata? dict parms filternames file/string
3 index /Length oget
dup 0 eq {
% Handle Length=0 case specially to avoid SubFileDecode semantics
pop pop ()
} {
() /SubFileDecode filter
} ifelse
3 index /StreamKey get arc4decodefilter
exch
} if
} bind def

end % pdfdict
.setglobal