hexapdf 0.32.2 → 0.34.0

data/lib/hexapdf/encryption/security_handler.rb

@@ -47,12 +47,12 @@ module HexaPDF
     # Contains entries common to all encryption dictionaries. If a specific security handler
     # needs further fields it should derive a new subclass and add the new fields there.
     #
-    # See: PDF1.7 s7.6.1
+    # See: PDF2.0 s7.6.2
     class EncryptionDictionary < Dictionary
 
       define_field :Filter,    type: Symbol, required: true
       define_field :SubFilter, type: Symbol, version: '1.3'
-      define_field :V,         type: Integer, required: true
+      define_field :V,         type: Integer, required: true, allowed_values: [0, 1, 2, 3, 4, 5]
       define_field :Lenth,     type: Integer, default: 40, version: '1.4'
       define_field :CF,        type: Dictionary, version: '1.5'
       define_field :StmF,      type: Symbol, default: :Identity, version: '1.5'
@@ -70,12 +70,8 @@ module HexaPDF
       # Ensures that the encryption dictionary's content is valid.
       def perform_validation
         super
-        unless [1, 2, 4, 5].include?(value[:V])
-          yield("Value of /V is not one of 1, 2, 4 or 5", false)
-          return
-        end
-        if value[:V] == 2 && (!key?(:Length) || value[:Length] < 40 ||
-          value[:Length] > 128 || value[:Length] % 8 != 0)
+        length = self[:Length]
+        if self[:V] == 2 && (!key?(:Length) || length < 40 || length > 128 || length % 8 != 0)
           yield("Invalid value for /Length field when /V is 2", false)
         end
       end
@@ -94,8 +90,8 @@ module HexaPDF
     # * The method ::set_up_decryption is used when a security handler should be created from the
     #   document's encryption dictionary.
     #
-    # Security handlers could also be created with the ::new method but this is discouraged because
-    # the above methods provide the correct handling in both cases.
+    # It is *not* recommended to create security handlers manually but only with those two methods
+    # listed above.
     #
     #
     # == Using SecurityHandler Instances
@@ -107,12 +103,16 @@ module HexaPDF
     # * #encrypt_string
     # * #encrypt_stream
     #
-    # How the decryption/encryption key is actually computed is deferred to a sub class.
+    # How the decryption/encryption key is actually computed is deferred to a sub class, as per the
+    # PDF specification.
     #
     # Additionally, the #encryption_key_valid? method can be used to check whether the
     # SecurityHandler instance is built from/built for the current version of the encryption
     # dictionary.
     #
+    # Note that any manual changes to the encryption dictionary will invalidate the key and lead to
+    # an error!
+    #
     #
     # == Implementing a SecurityHandler Class
     #
@@ -151,8 +151,8 @@ module HexaPDF
         # The encryption algorithm.
         attr_reader :algorithm
 
-        # Creates a new encrypted stream data object by utilizing the given stream data object as
-        # template. The arguments +key+ and +algorithm+ are used for decrypting purposes.
+        # Creates a new encrypted stream data object by utilizing the given stream data object +obj+
+        # as template. The arguments +key+ and +algorithm+ are used for decrypting purposes.
         def initialize(obj, key, algorithm)
           obj.instance_variables.each {|v| instance_variable_set(v, obj.instance_variable_get(v)) }
           @key = key
@@ -214,7 +214,7 @@ module HexaPDF
 
         handler = handler.new(document)
         dict = document.trailer[:Encrypt] = handler.set_up_decryption(dict, **options)
-        HexaPDF::Object.make_direct(dict.value)
+        HexaPDF::Object.make_direct(dict.value, document)
         document.revisions.current.update(dict)
         document.revisions.each do |r|
           loader = r.loader
@@ -264,7 +264,7 @@ module HexaPDF
       # Decrypts the strings and the possibly attached stream of the given indirect object in
       # place.
       #
-      # See: PDF1.7 s7.6.2
+      # See: PDF2.0 s7.6.3
       def decrypt(obj)
         return obj if @is_encrypt_dict[obj] || obj.type == :XRef
 
@@ -292,7 +292,7 @@ module HexaPDF
       # Note that some strings won't be encrypted as per the specification. The returned string,
       # however, is always a different object.
       #
-      # See: PDF1.7 s7.6.2
+      # See: PDF2.0 s7.6.3
       def encrypt_string(str, obj)
         return str.dup if str.empty? || obj == document.trailer[:Encrypt] || obj.type == :XRef ||
           (obj.type == :Sig && obj[:Contents].equal?(str))
@@ -302,6 +302,9 @@ module HexaPDF
       end
 
       # Returns a Fiber that encrypts the contents of the given stream object.
+      #
+      # Note that some streams *must not be* encrypted. For those, their standard stream encoding
+      # fiber is returned.
       def encrypt_stream(obj)
         return obj.stream_encoder if obj.type == :XRef
 
@@ -321,8 +324,8 @@ module HexaPDF
         end
       end
 
-      # Computes the encryption key and sets up the algorithms for encrypting the document based on
-      # the given options, and returns the corresponding encryption dictionary.
+      # Computes the encryption key, sets up the algorithms for encrypting the document based on the
+      # given options, and returns the corresponding encryption dictionary.
       #
       # The security handler specific +options+ as well as the +algorithm+ argument are passed on to
       # the #prepare_encryption method.
@@ -340,7 +343,7 @@ module HexaPDF
       # force_v4::
       #   Forces the use of protocol version 4 when key_length=128 and algorithm=:arc4.
       #
-      # See: PDF1.7 s7.6.1, PDF2.0 s7.6.1
+      # See: PDF2.0 s7.6.2
       def set_up_encryption(key_length: 128, algorithm: :aes, force_v4: false, **options)
         @dict = document.wrap({}, type: encryption_dictionary_class)
 
@@ -382,9 +385,13 @@ module HexaPDF
       #
       # The security handler specific +options+ are passed on to the #prepare_decryption method.
       #
-      # See: PDF1.7 s7.6.1, PDF2.0 s7.6.1
+      # See: PDF2.0 s7.6.2
       def set_up_decryption(dictionary, **options)
         @dict = document.wrap(dictionary, type: encryption_dictionary_class)
+        @dict.validate do |msg, correctable, obj|
+          next if correctable
+          raise HexaPDF::Error, "Validation error for encryption dictionary (#{obj.oid},#{obj.gen}): #{msg}"
+        end
 
         case dict[:V]
         when 1, 2
@@ -495,7 +502,7 @@ module HexaPDF
 
       # Computes the key for decrypting the indirect object with the given algorithm.
       #
-      # See: PDF1.7 s7.6.2 (algorithm 1), PDF2.0 s7.6.2.2 (algorithm 1.A)
+      # See: PDF2.0 s7.6.3.2 (algorithm 1), PDF2.0 s7.6.3.3 (algorithm 1.A)
       def object_key(oid, gen, algorithm)
         key = encryption_key
         return key if dict[:V] == 5
@@ -508,13 +515,13 @@ module HexaPDF
 
       # Returns the length of the encryption key in bytes based on the security handlers version.
       #
-      # See: PDF1.7 s7.6.1, PDF2.0 s7.6.1
+      # See: PDF2.0 s7.6.2
       def key_length
         case dict[:V]
         when 1 then 5
         when 2 then dict[:Length] / 8
-        when 4 then 16 # PDF2.0 s7.6.1 specifies that a /V of 4 is equal to length of 128bit
-        when 5 then 32 # PDF2.0 s7.6.1 specifies that a /V of 5 is equal to length of 256bit
+        when 4 then 16 # PDF2.0 s7.6.2 specifies that a /V of 4 is equal to length of 128bit
+        when 5 then 32 # PDF2.0 s7.6.2 specifies that a /V of 5 is equal to length of 256bit
         end
       end
 

data/lib/hexapdf/encryption/standard_security_handler.rb

@@ -47,7 +47,7 @@ module HexaPDF
     # the encryption key and a set of permissions.
     class StandardEncryptionDictionary < EncryptionDictionary
 
-      define_field :R,               type: Integer, required: true
+      define_field :R,               type: Integer, required: true, allowed_values: [2, 3, 4, 5, 6]
       define_field :O,               type: PDFByteString, required: true
       define_field :OE,              type: PDFByteString, version: '2.0'
       define_field :U,               type: PDFByteString, required: true
@@ -71,12 +71,16 @@ module HexaPDF
             yield("Value of /OE, /UE or /Perms is missing for dictionary revision 6", false)
             return
           end
-          if value[:U].length != 48 || value[:O].length != 48 || value[:UE].length != 32 ||
-              value[:OE].length != 32 || value[:Perms].length != 16
-            yield("Invalid size for /U, /O, /UE, /OE or /Perms values for revisions 6", false)
+          [:U, :O].each do |f|
+            if value[f].length != 48
+              yield("Invalid size (#{value[f].length} instead of 48) for /#{f} for revisions 6",
+                    value[f].length > 48 && value[f][48..-1].squeeze("\x00").length == 1)
+              value[f].slice!(48..-1)
+            end
+          end
+          if value[:UE].length != 32 || value[:OE].length != 32 || value[:Perms].length != 16
+            yield("Invalid size for /UE, /OE or /Perms values for revisions 6", false)
           end
-        else
-          yield("Value of /R is not one of 2, 3, 4 or 6", false)
         end
       end
 
@@ -87,11 +91,13 @@ module HexaPDF
     #
     # == Overview
     #
-    # The PDF specification defines one security handler that should be implemented by all PDF
-    # conform libraries and applications. This standard security handler allows access permissions
-    # and a user password as well as an owner password to be set. See
-    # StandardSecurityHandler::EncryptionOptions for all valid options that can be used with this
-    # security handler.
+    # The PDF specification defines one security handler that should be implemented by all
+    # conforming PDF libraries and applications. This standard security handler allows access
+    # permissions and a user password as well as an owner password to be set.
+    #
+    # See StandardSecurityHandler::EncryptionOptions for all valid options that can be used with
+    # this security handler when encrypting a document. And see #prepare_decryption for all allowed
+    # options when decrypting a document.
     #
     # The access permissions (see StandardSecurityHandler::Permissions) can be used to restrict what
     # a user is allowed to do with a PDF file.
@@ -100,7 +106,7 @@ module HexaPDF
     # password is supplied. To open such an encrypted PDF file, the +decryption_opts+ provided to
     # HexaPDF::Document.new needs to contain a :password key with the password.
     #
-    # See: PDF1.7 s7.6.3, PDF2.0 s7.6.3
+    # See: PDF2.0 s7.6.4
     class StandardSecurityHandler < SecurityHandler
 
       # Defines all available permissions.
@@ -109,13 +115,13 @@ module HexaPDF
       # permission set. The used symbols are the lower case versions of the constants, i.e. the
       # symbol for MODIFY_CONSTANT would be :modify_constant.
       #
-      # See: PDF1.7 s7.6.3.2
+      # See: PDF2.0 s7.6.4.2
       module Permissions
 
         # Printing (if HIGH_QUALITY_PRINT is also set, then high quality printing is allowed)
         PRINT = 1 << 2
 
-        # Modification of the content by operations that are different from those controller by
+        # Modification of the content by operations that are different from those controlled by
         # MODIFY_ANNOTATION, FILL_IN_FORMS and ASSEMBLE_DOCUMENT
         MODIFY_CONTENT = 1 << 3
 
@@ -129,6 +135,9 @@ module HexaPDF
         FILL_IN_FORMS = 1 << 8
 
         # Extracting content
+        #
+        # PDF 2.0 specifies that this bit should always be set by writers and should be ignored by
+        # readers. Therefore this is part of the RESERVED constant.
         EXTRACT_CONTENT = 1 << 9
 
         # Assembling of the document (inserting, rotating or deleting of pages and creation of
@@ -142,8 +151,8 @@ module HexaPDF
         ALL = PRINT | MODIFY_CONTENT | COPY_CONTENT | MODIFY_ANNOTATION | FILL_IN_FORMS |
           EXTRACT_CONTENT | ASSEMBLE_DOCUMENT | HIGH_QUALITY_PRINT
 
-        # Reserved permission bits
-        RESERVED = 0xFFFFF000 | 0b11000000
+        # Reserved permission bits that should always be set
+        RESERVED = 0xFFFFF000 | 0b11000000 | EXTRACT_CONTENT
 
         # Maps permission symbols to their respective value
         SYMBOL_TO_PERMISSION = {
@@ -213,7 +222,7 @@ module HexaPDF
 
         # Maps the permissions to an integer for use by the standard security handler.
         #
-        # See: PDF1.7 s7.6.3.2, ADB1.7 3.5.2 (table 3.20 and the paragraphs before)
+        # See: PDF2.0 s7.6.4.2, ADB1.7 3.5.2 (table 3.20 and the paragraphs before)
         def process_permissions(perms)
           if perms.kind_of?(Array)
             perms = perms.inject(0) do |result, perm|
@@ -363,7 +372,7 @@ module HexaPDF
 
       # The padding used for passwords with fewer than 32 bytes. Only used for revisions <= 4.
       #
-      # See: PDF1.7 s7.6.3.3
+      # See: PDF2.0 s7.6.4.3
       PASSWORD_PADDING = "\x28\xBF\x4E\x5E\x4E\x75\x8A\x41\x64\x00\x4E\x56\xFF\xFA\x01\x08" \
         "\x2E\x2E\x00\xB6\xD0\x68\x3E\x80\x2F\x0C\xA9\xFE\x64\x53\x69\x7A".b
 
@@ -376,7 +385,7 @@ module HexaPDF
       # with the user password. If the password is the owner password,
       # #compute_owner_encryption_key has to be used instead.
       #
-      # See: PDF1.7 s7.6.3.3 (algorithm 2), PDF2.0 s7.6.3.3.2 (algorithm 2.A (a)-(b),(e))
+      # See: PDF2.0 s7.6.4.3.2 (algorithm 2), PDF2.0 s7.6.4.3.3 (algorithm 2.A (a)-(b),(e))
       def compute_user_encryption_key(password)
         if dict[:R] <= 4
           data = password
@@ -403,11 +412,11 @@ module HexaPDF
       # For revisions <= 4 this is done by first retrieving the user password through the use of
       # the owner password and then using the #compute_user_encryption_key method.
       #
-      # For revision 6 file encryption key is a string of random bytes that has been encrypted
-      # with the owner password. If the password is the user password,
-      # #compute_user_encryption_key has to be used.
+      # For revision 6 the file encryption key is a string of random bytes that has been encrypted
+      # with the owner password. If the password is the user password, #compute_user_encryption_key
+      # has to be used.
       #
-      # See: PDF2.0 s7.6.3.3.2 (algorithm 2.A (a)-(d))
+      # See: PDF2.0 s7.6.4.3.2 (algorithm 2.A (a)-(d))
       def compute_owner_encryption_key(password)
         if dict[:R] <= 4
           compute_user_encryption_key(user_password_from_owner_password(password))
@@ -426,7 +435,7 @@ module HexaPDF
       # *Attention*: If revision 6 is used, the /U value has to be computed and set before this
       # method is used, otherwise the return value is incorrect!
       #
-      # See: PDF1.7 s7.6.3.4 (algorithm 3), PDF2.0 s7.6.3.4.7 (algorithm 9 (a))
+      # See: PDF2.0 s7.6.4.4.2 (algorithm 3), PDF2.0 s7.6.4.4.8 (algorithm 9 (a))
       def compute_o_field(owner_password, user_password)
         if dict[:R] <= 4
           data = Digest::MD5.digest(owner_password)
@@ -454,7 +463,7 @@ module HexaPDF
       # Short explanation: Encrypts the file encryption key with a key based on the password and
       # the /O and /U values.
       #
-      # See: PDF2.0 s7.6.3.4.7 (algorithm 9 (b))
+      # See: PDF2.0 s7.6.4.4.8 (algorithm 9 (b))
       def compute_oe_field(password, file_encryption_key)
         key = compute_hash(password, dict[:O][40, 8], dict[:U])
         aes_algorithm.new(key, "\0" * 16, :encrypt).process(file_encryption_key)
@@ -466,8 +475,8 @@ module HexaPDF
       # based on the user password. For revision 6 the /U value is a hash computed from the
       # password with added validation and key salts.
       #
-      # See: PDF1.7 s7.6.3.4 (algorithm 4 for R=2, algorithm 5 for R=3 and R=4)
-      #      PDF2.0 s7.6.3.4.6 (algorithm 8 (a) for R=6)
+      # See: PDF2.0 s7.6.4.4.3 (algorithm 4 for R=2), PDF s7.6.4.4.4 (algorithm 5 for R=3 and R=4)
+      #      PDF2.0 s7.6.4.4.7 (algorithm 8 (a) for R=6)
       def compute_u_field(password)
         if dict[:R] == 2
           key = compute_user_encryption_key(password)
@@ -491,7 +500,7 @@ module HexaPDF
       # Short explanation: Encrypts the file encryption key with a key based on the password and
       # the /U value.
       #
-      # See: PDF2.0 s7.6.3.4.6 (algorithm 8 (b))
+      # See: PDF2.0 s7.6.4.4.7 (algorithm 8 (b))
       def compute_ue_field(password, file_encryption_key)
         key = compute_hash(password, dict[:U][40, 8])
         aes_algorithm.new(key, "\0" * 16, :encrypt).process(file_encryption_key)
@@ -501,7 +510,7 @@ module HexaPDF
       #
       # Uses /P and /EncryptMetadata values, so these have to be set beforehand.
       #
-      # See: PDF2.0 s7.6.3.4.8 (algorithm 10)
+      # See: PDF2.0 s7.6.4.4.9 (algorithm 10)
       def compute_perms_field(file_encryption_key)
         data = [dict[:P]].pack('V')
         data << [0xFFFFFFFF].pack('V')
@@ -513,7 +522,7 @@ module HexaPDF
 
       # Authenticates the user password, i.e. decides whether the given user password is valid.
       #
-      # See: PDF1.7 s7.6.3.4 (algorithm 6), PDF2.0 s7.6.3.4.9 (algorithm 11)
+      # See: PDF2.0 s7.6.4.4.5 (algorithm 6), PDF2.0 s7.6.4.4.10 (algorithm 11)
       def user_password_valid?(password)
         if dict[:R] == 2
           compute_u_field(password) == dict[:U]
@@ -526,7 +535,7 @@ module HexaPDF
 
       # Authenticates the owner password, i.e. decides whether the given owner password is valid.
       #
-      # See: PDF1.7 s7.6.3.4 (algorithm 7), PDF2.0 s7.6.3.4.10 (algorithm 12)
+      # See: PDF2.0 s7.6.4.4.6 (algorithm 7), PDF2.0 s7.6.4.4.11 (algorithm 12)
       def owner_password_valid?(password)
         if dict[:R] <= 4
           user_password_valid?(user_password_from_owner_password(password))
@@ -539,7 +548,7 @@ module HexaPDF
       #
       # This method can only be used for revision 6.
       #
-      # See: PDF2.0 s7.6.3.4.11 (algorithm 13)
+      # See: PDF2.0 s7.6.4.4.12 (algorithm 13)
       def check_perms_field(encryption_key)
         decrypted = aes_algorithm.new(encryption_key, "\0" * 16, :decrypt).process(dict[:Perms])
         if decrypted[9, 3] != "adb"
@@ -553,7 +562,7 @@ module HexaPDF
 
       # Returns the user password when given the owner password for revisions <= 4.
       #
-      # See: PDF1.7 s7.6.3.4 (algorithm 7 (a) and (b))
+      # See: PDF2.0 s7.6.4.4.6 (algorithm 7 (a) and (b))
       def user_password_from_owner_password(owner_password)
         data = Digest::MD5.digest(owner_password)
         if dict[:R] >= 3
@@ -578,7 +587,7 @@ module HexaPDF
       # "#{password}#{salt}#{user_key}" where +user_key+ has to be empty when doing operations
       # with the user password.
       #
-      # See: PDF2.0 s7.6.3.3.3 (algorithm 2.B)
+      # See: PDF2.0 s7.6.4.3.4 (algorithm 2.B)
       def compute_hash(password, salt, user_key = '')
         k = Digest::SHA256.digest("#{password}#{salt}#{user_key}")
         e = ''
@@ -606,8 +615,8 @@ module HexaPDF
       # * For revision 6 the password is converted into UTF-8 encoding that is normalized
       #   according to the PDF2.0 specification.
       #
-      # See: PDF1.7 s7.6.3.3 (algorithm 2 step a)),
-      #      PDF2.0 s7.6.3.3.2 (algorithm 2.A steps a) and b))
+      # See: PDF2.0 s7.6.4.3.2 (algorithm 2 step a)),
+      #      PDF2.0 s7.6.4.3.3 (algorithm 2.A steps a) and b))
       def prepare_password(password)
         if dict[:R] <= 4
           password.to_s[0, 32].encode(Encoding::ISO_8859_1).force_encoding(Encoding::BINARY).

data/lib/hexapdf/encryption.rb

@@ -41,7 +41,7 @@ module HexaPDF
   # A PDF document may be encrypted so that
   #
   # * certain permissions are respected when the document is opened,
-  # * a password must be specified so that a document can be openend or so that
+  # * a password must be specified so that a document can be openend, or so that
   # * a password must be specified to remove the restrictions and allow full access.
   #
   # This module contains all encryption and security related code to facilitate PDF encryption.
@@ -61,6 +61,9 @@ module HexaPDF
   # additionally allows setting permission information. This security handler is implemented by
   # the Encryption::StandardSecurityHandler class.
   #
+  # There is also a certificate-based security handler defined by the PDF specification. However,
+  # that handler is not implemented.
+  #
   #
   # === Encryption Algorithms
   #
@@ -78,8 +81,10 @@ module HexaPDF
   #   Pure Ruby implementations of the algorithms which are naturally much slower than the OpenSSL
   #   based ones. However, these implementation can be used on any Ruby implementation.
   #
+  # The ARC4 algorithm is deprecated with PDF 2.0 and should not be used when creating new
+  # documents.
   #
-  # See: PDF1.7 s7.6
+  # See: PDF2.0 s7.6
   module Encryption
 
     autoload(:ARC4, 'hexapdf/encryption/arc4')

data/lib/hexapdf/error.rb

@@ -82,4 +82,22 @@ module HexaPDF
   # Raised when the encryption method is not supported.
   class UnsupportedEncryptionError < EncryptionError; end
 
+  # Raised when a font wrapper implementation should encode a missing glyph.
+  class MissingGlyphError < Error
+
+    # Returns the glyph object that contains the information about the missing glyph.
+    attr_reader :glyph
+
+    # Creates a new MissingGlyphError for the given +glyph+.
+    def initialize(glyph)
+      @glyph = glyph
+    end
+
+    def message # :nodoc:
+      "No glyph for #{glyph.str.inspect} in font '#{glyph.font.full_name}' found. \n\n" \
+        "Use the configuration option 'font.on_missing_glyph' to customize missing glyph handling."
+    end
+
+  end
+
 end

data/lib/hexapdf/filter/ascii85_decode.rb

@@ -45,7 +45,7 @@ module HexaPDF
     # This filter module implements the ASCII-85 filter which can encode arbitrary data into an
     # ASCII compatible format that expands the original data only by a factor of 4:5.
     #
-    # See: HexaPDF::Filter, PDF1.7 s7.4.2
+    # See: HexaPDF::Filter, PDF2.0 s7.4.2
     module ASCII85Decode
 
       VALUE_TO_CHAR = {} #:nodoc:

data/lib/hexapdf/filter/ascii_hex_decode.rb

@@ -44,7 +44,7 @@ module HexaPDF
     # This filter module implements the ASCII hex decode/encode filter which can encode arbitrary
     # data into the two byte ASCII hex format that expands the original data by a factor of 1:2.
     #
-    # See: HexaPDF::Filter, PDF1.7 s7.4.2
+    # See: HexaPDF::Filter, PDF2.0 s7.4.2
     module ASCIIHexDecode
 
       # See HexaPDF::Filter

data/lib/hexapdf/filter/flate_decode.rb

@@ -45,7 +45,7 @@ module HexaPDF
 
     # Implements the Deflate filter using the Zlib library.
     #
-    # See: HexaPDF::Filter, PDF1.7 s7.4.4
+    # See: HexaPDF::Filter, PDF2.0 s7.4.4
     module FlateDecode
 
       # See HexaPDF::Filter

data/lib/hexapdf/filter/lzw_decode.rb

@@ -48,7 +48,7 @@ module HexaPDF
     # not aligned to byte boundaries, this filter is not as fast as the other filters. If speed is
     # a concern, the FlateDecode filter should be used instead.
     #
-    # See: HexaPDF::Filter, PDF1.7 s7.4.4
+    # See: HexaPDF::Filter, PDF2.0 s7.4.4
     module LZWDecode
 
       CLEAR_TABLE = 256 # :nodoc:

data/lib/hexapdf/filter/pass_through.rb

@@ -40,7 +40,7 @@ module HexaPDF
     # The PassThrough filter just passes the source on unmodified. This is enough for basic
     # read-write capabilities but not if the unfiltered bytes are needed.
     #
-    # See: HexaPDF::Filter, PDF1.7 s7.4
+    # See: HexaPDF::Filter, PDF2.0 s7.4
     module PassThrough
 
       # See HexaPDF::Filter

data/lib/hexapdf/filter/predictor.rb

@@ -47,7 +47,7 @@ module HexaPDF
     # Although a predictor isn't a full PDF filter, it is implemented as one in HexaPDF terms to
     # allow easy chaining of the predictor.
     #
-    # See: PDF1.7 s7.4.4.3, s7.4.4.4, https://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf
+    # See: PDF2.0 s7.4.4.3, s7.4.4.4, https://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf
     # (p64f), http://www.w3.org/TR/PNG-Filters.html
     #
     #-- Implemenation notes:

data/lib/hexapdf/filter/run_length_decode.rb

@@ -43,7 +43,7 @@ module HexaPDF
 
     # Implements the run length filter.
     #
-    # See: HexaPDF::Filter, PDF1.7 s7.4.5
+    # See: HexaPDF::Filter, PDF2.0 s7.4.5
     module RunLengthDecode
 
       EOD = 128.chr #:nodoc:

data/lib/hexapdf/filter.rb

@@ -48,6 +48,8 @@ module HexaPDF
     attr_reader :length
 
     # Initializes the Fiber and sets the +length+.
+    #
+    # A +length+ of +nil+ is equal to -1.
     def initialize(length, &block)
       super(&block)
       @length = length || -1
@@ -55,6 +57,47 @@ module HexaPDF
 
   end
 
+  # Implements part of the Fiber interface so that it can be used instead of a Fiber by HexaPDF
+  # when only a single string should be returned.
+  class FiberDoubleForString
+
+    # Creates a new FiberDoubleForString instance for the given string +str+ or for the string
+    # returned by invoking the block.
+    def initialize(str = nil, &block)
+      @block = block
+      @str = str
+      @block_used = false
+    end
+
+    # Returns the length of the wrapped string.
+    #
+    # May only be called before #resume!
+    def length
+      str.length
+    end
+
+    # Returns +true+ if #resume has not yet been called.
+    def alive?
+      !str.nil?
+    end
+
+    # Returns the wrapped string on the first invocation, +nil+ otherwise.
+    def resume
+      tmp = str
+      @str = nil
+      tmp
+    end
+
+    private
+
+    # Sets the string to the return value of the initially provided block if no string has been
+    # provided.
+    def str
+      @str ||= @block_used || @block.nil? ? nil : (@block_used = true; @block.call)
+    end
+
+  end
+
   # == Overview
   #
   # A stream filter is used to compress a stream or to encode it in an ASCII compatible way; or
@@ -83,7 +126,7 @@ module HexaPDF
   #
   # Such a fiber should *not* return +nil+ unless this signifies that no more data is coming!
   #
-  # See: PDF1.7 s7.4
+  # See: PDF2.0 s7.4
   module Filter
 
     autoload(:ASCII85Decode, 'hexapdf/filter/ascii85_decode')
@@ -99,10 +142,16 @@ module HexaPDF
 
     autoload(:PassThrough, 'hexapdf/filter/pass_through')
 
-    # Returns a Fiber that can be used as a source for decoders/encoders and that is based on a
-    # String object.
+    # Returns a FiberDoubleForString that uses the string returned by the provided block and can be
+    # used as a source for decoders/encoders.
+    def self.source_from_proc(&block)
+      FiberDoubleForString.new(&block)
+    end
+
+    # Returns a FiberDoubleForString that returns the given string and can be used as a source for
+    # decoders/encoders.
     def self.source_from_string(str)
-      FiberWithLength.new(str.length) { str.dup }
+      FiberDoubleForString.new(str.dup)
     end
 
     # Returns a Fiber that can be used as a source for decoders/encoders and that reads chunks of
@@ -149,7 +198,7 @@ module HexaPDF
     # Note that there will be a problem if the size of the file changes between the invocation of
     # this method and the actual consumption of the file!
     #
-    # See ::source_from_io for a description of the available options.
+    # See ::source_from_io for a description of the +pos+, +length+ and +chunk_size+ options.
     def self.source_from_file(filename, pos: 0, length: -1, chunk_size: 0)
       fib_length = (length < 0 ? File.stat(filename).size - pos : length)
       FiberWithLength.new(fib_length) do
@@ -165,7 +214,7 @@ module HexaPDF
     # Returns the concatenated string chunks retrieved by resuming the given source Fiber until it
     # is dead.
     #
-    # The returned string is always a string with +BINARY+ (= +ASCII-8BIT+) encoding.
+    # The returned string is always a string with binary (= +ASCII-8BIT+) encoding.
     def self.string_from_source(source)
       str = ''.b
       while source.alive? && (data = source.resume)

data/lib/hexapdf/font/cmap/parser.rb

@@ -146,10 +146,10 @@ module HexaPDF
         # Parses the "bfrange" operator at the current position.
         #
         #--
-        # PDF1.7 s9.10.3 and Adobe Technical Note #5411 have different views as to how "bfrange"
+        # PDF2.0 s9.10.3 and Adobe Technical Note #5411 have different views as to how "bfrange"
         # operators of the form "startCode endCode codePoint" should be handled.
         #
-        # PDF1.7 mentions that the last byte of "codePoint" should be incremented, up to a maximum
+        # PDF2.0 mentions that the last byte of "codePoint" should be incremented, up to a maximum
         # of 255. However #5411 has the range "<1379> <137B> <90FE>" as example which contradicts
         # this.
         #

data/lib/hexapdf/font/cmap.rb

@@ -43,7 +43,7 @@ module HexaPDF
     # Represents a CMap, a mapping from character codes to CIDs (character IDs) or to their Unicode
     # value.
     #
-    # See: PDF1.7 s9.7.5, s9.10.3; Adobe Technical Notes #5014 and #5411
+    # See: PDF2.0 s9.7.5, s9.10.3; Adobe Technical Notes #5014 and #5411
     class CMap
 
       autoload(:Parser, 'hexapdf/font/cmap/parser')

data/lib/hexapdf/font/encoding/difference_encoding.rb

@@ -42,7 +42,7 @@ module HexaPDF
 
       # The difference encoding uses a base encoding that can be overlayed with additional mappings.
       #
-      # See: PDF1.7 s9.6.6.1
+      # See: PDF2.0 s9.6.5.1
       class DifferenceEncoding < Base
 
         # The base encoding.