%   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 } ifelsepdfdict 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