hexapdf 0.17.2 → 0.19.1

data/lib/hexapdf/dictionary.rb

@@ -318,8 +318,8 @@ module HexaPDF
             value[name] = document.add(obj)
           elsif !field.indirect && obj.kind_of?(HexaPDF::Object) && obj.indirect?
             yield("Field #{name} needs to be a direct object", true)
-            document.delete(obj)
             value[name] = obj.value
+            document.delete(obj)
           end
         end
       end

data/lib/hexapdf/dictionary_fields.rb

@@ -293,7 +293,7 @@ module HexaPDF
       end
 
       # :nodoc:
-      DATE_RE = /\AD:(\d{4})(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([Z+-])?(?:(\d\d)(?:'|'(\d\d)'?|\z)?)?\z/n
+      DATE_RE = /\AD:(\d{4})(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([Z+-])?(?:(\d\d)(?:'|'([0-5]\d)'?|\z)?)?\z/n
 
       # Checks if the given object is a string and converts into a Time object if possible.
       # Otherwise returns +nil+.

data/lib/hexapdf/document/signatures.rb

@@ -0,0 +1,221 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2021 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'openssl'
+
+module HexaPDF
+  class Document
+
+    # This class provides methods for interacting with digital signatures of a PDF file.
+    class Signatures
+
+      # This is the default signing handler which provides the ability to sign a document with a
+      # provided certificate using the adb.pkcs7.detached algorithm.
+      class DefaultHandler
+
+        # Creates a new DefaultHandler with the given signing certificate, the associated signing
+        # key and an optional array of certificates that should also be present in the signature.
+        def initialize(certificate, key, certificate_chain = [])
+          @certificate = certificate
+          @key = key
+          @certificate_chain = certificate_chain
+        end
+
+        # Returns the name to be set on the /Filter key when using this signing handler.
+        def filter_name
+          :"Adobe.PPKLite"
+        end
+
+        # Returns the name to be set on the /SubFilter key when using this signing handler.
+        def sub_filter_name
+          :"adbe.pkcs7.detached"
+        end
+
+        # Returns the size of the signature that would be created.
+        def signature_size
+          sign("").size
+        end
+
+        # Returns the DER serialized OpenSSL::PKCS7 structure containing the signature for the given
+        # data.
+        def sign(data)
+          OpenSSL::PKCS7.sign(@certificate, @key, data, @certificate_chain,
+                              OpenSSL::PKCS7::DETACHED | OpenSSL::PKCS7::BINARY).to_der
+        end
+
+      end
+
+      include Enumerable
+
+      # Creates a new Signatures object for the given PDF document.
+      def initialize(document)
+        @document = document
+      end
+
+      # Adds a signature to the document and returns the corresponding signature object.
+      #
+      # This method will add a new signature to the document and write the updated document to the
+      # given file or IO stream. Afterwards the document can't be modified anymore and still retain
+      # a correct digital signature; create a new document based on the file or IO stream instead.
+      #
+      # +signature+::
+      #     Can either be a signature object or +nil+. Providing a signature object provides for
+      #     more control, e.g.:
+      #
+      #     * Setting values for optional fields like /Reason and /Location.
+      #     * Indirectly specifying which signature field should be used.
+      #
+      #     If the +signature+ is not associated with an AcroForm signature field, a new signature
+      #     field is created and added to the main AcroForm object, creating that if necessary.
+      #
+      #     If the associated signature field doesn't have a widget, a non-visible one is created on
+      #     the first page.
+      #
+      # +handler+::
+      #     The signature handler that provides the necessary methods for signing, see
+      #     DefaultHandler.
+      #
+      # +write_options+::
+      #     These options will be passed on to the HexaPDF::Document#write command. Note that
+      #     +incremental+ will be automatically set if signing an already existing file.
+      def add(file_or_io, handler, signature: nil, **write_options)
+        signature ||= @document.add({Type: :Sig})
+        signature[:Filter] = handler.filter_name
+        signature[:SubFilter] = handler.sub_filter_name
+        signature[:ByteRange] = [0, 1_000_000_000_000, 1_000_000_000_000, 1_000_000_000_000]
+        signature[:Contents] = '00' * handler.signature_size # twice the size due to hex encoding
+
+        # Prepare signature field
+        form = @document.acro_form(create: true)
+        form.signature_flag(:signatures_exist)
+
+        signature_field = each.find {|value| value == signature }
+        unless signature_field
+          signature_field = form.create_signature_field(generate_field_name)
+          signature_field.field_value = signature
+        end
+
+        if signature_field.each_widget.to_a.empty?
+          signature_field.create_widget(@document.pages[0], Rect: [0, 0, 0, 0])
+        end
+
+        io = if file_or_io.kind_of?(String)
+               File.open(file_or_io, 'w+')
+             else
+               file_or_io
+             end
+
+        # Save the current state so that we can determine the correct /ByteRange value and set the
+        # values
+        section = @document.write(io, incremental: true, **write_options)
+        data = section.map {|oid, _gen, entry| [entry.pos.to_i, oid] }.sort
+        index = data.index {|_pos, oid| oid == signature.oid }
+        signature_offset = data[index][0]
+        signature_length = data[index + 1][0] - data[index][0]
+        io.pos = signature_offset
+        signature_data = io.read(signature_length)
+
+        io.rewind
+        file_data = io.read
+
+        # Calculate the offsets for the /ByteRange
+        contents_offset = signature_offset + signature_data.index('Contents(') + 8
+        offset2 = contents_offset + signature[:Contents].size + 2 # +2 because of the needed < and >
+        length2 = file_data.size - offset2
+        signature[:ByteRange] = [0, contents_offset, offset2, length2]
+
+        # Set the correct /ByteRange value
+        signature_data.sub!(/ByteRange\[0 1000000000000 1000000000000 1000000000000\]/) do |match|
+          length = match.size
+          result = "ByteRange[0 #{contents_offset} #{offset2} #{length2}]"
+          result.ljust(length)
+        end
+
+        # Now everything besides the /Contents value is correct, so we can read the contents for
+        # signing
+        file_data[signature_offset, signature_length] = signature_data
+        signed_contents = file_data[0, contents_offset] << file_data[offset2, length2]
+        signature[:Contents] = handler.sign(signed_contents)
+
+        # Set the correct /Contents value as hexstring
+        signature_data.sub!(/Contents\(0+\)/) do |match|
+          length = match.size
+          result = "Contents<#{signature[:Contents].unpack1('H*')}"
+          "#{result.ljust(length - 1, '0')}>"
+        end
+
+        io.pos = signature_offset
+        io.write(signature_data)
+
+        signature
+      ensure
+        io.close if io && io != file_or_io
+      end
+
+      # :call-seq:
+      #   signatures.each {|signature| block }   -> signatures
+      #   signatures.each                        -> Enumerator
+      #
+      # Iterates over all signatures in the order they are found.
+      def each
+        return to_enum(__method__) unless block_given?
+
+        return [] unless (form = @document.acro_form)
+        form.each_field do |field|
+          yield(field.field_value) if field.field_type == :Sig && field.field_value
+        end
+      end
+
+      # Returns the number of signatures in the PDF document. May be zero if the document has no
+      # signatures.
+      def count
+        each.to_a.size
+      end
+
+      private
+
+      # Generates a field name for a signature field.
+      def generate_field_name
+        index = (@document.acro_form.each_field.
+                 map {|field| field.full_field_name.scan(/\ASignature(\d+)/).first&.first.to_i }.
+                 max || 0) + 1
+        "Signature#{index}"
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/encryption/security_handler.rb

@@ -213,7 +213,9 @@ module HexaPDF
         end
 
         handler = handler.new(document)
-        document.trailer[:Encrypt] = handler.set_up_decryption(dict, **options)
+        dict = document.trailer[:Encrypt] = handler.set_up_decryption(dict, **options)
+        HexaPDF::Object.make_direct(dict.value)
+        document.revisions.current.update(dict)
         document.revisions.each do |r|
           loader = r.loader
           r.loader = lambda do |xref_entry|

data/lib/hexapdf/layout/style.rb

@@ -1069,7 +1069,8 @@ module HexaPDF
 
       # The font size scaled appropriately.
       def scaled_font_size
-        @scaled_font_size ||= calculated_font_size / 1000.0 * scaled_horizontal_scaling
+        @scaled_font_size ||= calculated_font_size * font.pdf_object.glyph_scaling_factor *
+          scaled_horizontal_scaling
       end
 
       # The character spacing scaled appropriately.

data/lib/hexapdf/object.rb

@@ -141,6 +141,24 @@ module HexaPDF
       end
     end
 
+    # Makes sure that the object itself as well as all nested values are direct objects.
+    #
+    # If an indirect object is found, it is turned into a direct object and the indirect object is
+    # deleted from the document.
+    def self.make_direct(object)
+      if object.kind_of?(HexaPDF::Object) && object.indirect?
+        object_to_delete = object
+        object = object.value
+        object_to_delete.document.delete(object_to_delete)
+      end
+      if object.kind_of?(Hash)
+        object.transform_values! {|val| make_direct(val) }
+      elsif object.kind_of?(Array)
+        object.map! {|val| make_direct(val) }
+      end
+      object
+    end
+
     # The wrapped HexaPDF::PDFData value.
     #
     # This attribute is not part of the public API!

data/lib/hexapdf/parser.rb

@@ -404,6 +404,7 @@ module HexaPDF
     def reconstruct_revision
       return if @in_reconstruct_revision
       @in_reconstruct_revision = true
+      @header_offset = 0
 
       raise unless @document.config['parser.try_xref_reconstruction']
       msg = "#{$!} - trying cross-reference table reconstruction"
@@ -428,8 +429,10 @@ module HexaPDF
           elsif gen.kind_of?(Integer) && tok.kind_of?(Tokenizer::Token) && tok == 'obj'
             xref.add_in_use_entry(token, gen, pos)
             if linearized.nil?
+              pos = @tokenizer.pos
               obj = @tokenizer.next_object rescue nil
               linearized = obj.kind_of?(Hash) && obj.key?(:Linearized)
+              @tokenizer.pos = pos
             end
             @tokenizer.scan_until(/(?:\n|\r\n?)endobj\b/)
           end

data/lib/hexapdf/serializer.rb

@@ -35,6 +35,8 @@
 #++
 
 require 'time'
+require 'hexapdf/object'
+require 'hexapdf/stream'
 require 'hexapdf/tokenizer'
 require 'hexapdf/filter'
 require 'hexapdf/utils/lru_cache'

data/lib/hexapdf/task/optimize.rb

@@ -72,8 +72,19 @@ module HexaPDF
       #   Compresses the content streams of all pages if set to +true+. Note that this can take a
       #   *very* long time because each content stream has to be unfiltered, parsed, serialized
       #   and then filtered again.
+      #
+      # prune_page_resources::
+      #   Removes all unused XObjects from the resources dictionaries of all pages. It is
+      #   recommended to also set the +compact+ argument because otherwise the unused XObjects won't
+      #   be deleted from the document.
+      #
+      #   This is sometimes necessary after importing pages from other PDF files that use a single
+      #   resources dictionary for all pages.
       def self.call(doc, compact: false, object_streams: :preserve, xref_streams: :preserve,
-                    compress_pages: false)
+                    compress_pages: false, prune_page_resources: false)
+        used_refs = compress_pages(doc) if compress_pages
+        prune_page_resources(doc, used_refs) if prune_page_resources
+
         if compact
           compact(doc, object_streams, xref_streams)
         elsif object_streams != :preserve
@@ -83,8 +94,6 @@ module HexaPDF
         else
           doc.each(only_current: false, &method(:delete_fields_with_defaults))
         end
-
-        compress_pages(doc) if compress_pages
       end
 
       # Compacts the document by merging all revisions into one, deleting null and unused entries
@@ -214,12 +223,41 @@ module HexaPDF
 
       # Compresses the contents of all pages by parsing and then serializing again. The HexaPDF
       # serializer is already optimized for small output size so nothing else needs to be done.
+      #
+      # Returns a hash of the form key=>true where the keys are the used XObjects (for use with
+      # #prune_page_resources).
       def self.compress_pages(doc)
+        used_refs = {}
         doc.pages.each do |page|
           processor = SerializationProcessor.new
           HexaPDF::Content::Parser.parse(page.contents, processor)
           page.contents = processor.result
           page[:Contents].set_filter(:FlateDecode)
+          xobjects = page.resources[:XObject]
+          processor.used_references.each {|ref| used_refs[xobjects[ref]] = true }
+        end
+        used_refs
+      end
+
+      # Deletes all XObject entries from the resources dictionaries of all pages whose names do not
+      # match the keys in +used_refs+.
+      def self.prune_page_resources(doc, used_refs)
+        unless used_refs
+          used_refs = {}
+          doc.pages.each do |page|
+            xobjects = page.resources[:XObject]
+            HexaPDF::Content::Parser.parse(page.contents) do |op, operands|
+              used_refs[xobjects[operands[0]]] = true if op == :Do
+            end
+          end
+        end
+
+        doc.pages.each do |page|
+          xobjects = page.resources[:XObject]
+          xobjects.each do |key, obj|
+            next if used_refs[obj]
+            xobjects.delete(key)
+          end
         end
       end
 
@@ -228,14 +266,19 @@ module HexaPDF
 
         attr_reader :result #:nodoc:
 
+        # Contains all found references
+        attr_reader :used_references
+
         def initialize #:nodoc:
           @result = ''.b
           @serializer = HexaPDF::Serializer.new
+          @used_references = []
         end
 
         def process(op, operands) #:nodoc:
           @result << HexaPDF::Content::Operator::DEFAULT_OPERATORS[op].
             serialize(@serializer, *operands)
+          @used_references << operands[0] if op == :Do
         end
 
       end

data/lib/hexapdf/type/acro_form/appearance_generator.rb

@@ -227,8 +227,8 @@ module HexaPDF
         # Note: Rich text fields are currently not supported!
         def create_text_appearances
           default_resources = @document.acro_form.default_resources
-          font, font_size = retrieve_font_information(default_resources)
-          style = HexaPDF::Layout::Style.new(font: font)
+          font, font_size, font_color = retrieve_font_information(default_resources)
+          style = HexaPDF::Layout::Style.new(font: font, fill_color: font_color)
           border_style = @widget.border_style
           padding = [1, border_style.width].max
 
@@ -482,7 +482,7 @@ module HexaPDF
 
         # Returns the font wrapper and font size to be used for a variable text field.
         def retrieve_font_information(resources)
-          font_name, font_size = @field.parse_default_appearance_string
+          font_name, font_size, font_color = @field.parse_default_appearance_string
           font_object = resources.font(font_name) rescue nil
           font = font_object&.font_wrapper
           unless font
@@ -498,7 +498,7 @@ module HexaPDF
               raise(HexaPDF::Error, "Font #{font_name} of the AcroForm's default resources not usable")
             end
           end
-          [font, font_size]
+          [font, font_size, font_color]
         end
 
         # Calculates the font size for text fields based on the font and font size of the default

data/lib/hexapdf/type/acro_form/form.rb

@@ -157,8 +157,8 @@ module HexaPDF
         # The optional keyword arguments allow setting often used properties of the field:
         #
         # +font+::
-        #     The font that should be used for the text of the field. If +font_size+ or
-        #     +font_options+ is specified but +font+ isn't, the font Helvetica is used.
+        #     The font that should be used for the text of the field. If +font_size+, +font_options+
+        #     or +font_color+ is specified but +font+ isn't, the font Helvetica is used.
         #
         #     If no font is set on the text field, the default font properties of the AcroForm form
         #     are used. Note that field specific or form specific font properties have to be set.
@@ -169,15 +169,20 @@ module HexaPDF
         #     A hash with font options like :variant that should be used.
         #
         # +font_size+::
-        #     The font size that should be used. If +font+ or +font_options+ is specified but
-        #     +font_size+ isn't, font size defaults to 0 (= auto-sizing).
+        #     The font size that should be used. If +font+, +font_options+ or +font_color+ is
+        #     specified but +font_size+ isn't, font size defaults to 0 (= auto-sizing).
+        #
+        # +font_color+::
+        #     The font color that should be used. If +font+, +font_options+ or +font_size+ is
+        #     specified but +font_color+ isn't, font color defaults to 0 (i.e. black).
         #
         # +align+::
         #     The alignment of the text, either :left, :center or :right.
-        def create_text_field(name, font: nil, font_options: nil, font_size: nil, align: nil)
+        def create_text_field(name, font: nil, font_options: nil, font_size: nil, font_color: nil,
+                              align: nil)
           create_field(name, :Tx) do |field|
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -189,11 +194,11 @@ module HexaPDF
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
         def create_multiline_text_field(name, font: nil, font_options: nil, font_size: nil,
-                                        align: nil)
+                                        font_color: nil, align: nil)
           create_field(name, :Tx) do |field|
             field.initialize_as_multiline_text_field
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -208,11 +213,11 @@ module HexaPDF
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
         def create_comb_text_field(name, max_chars:, font: nil, font_options: nil, font_size: nil,
-                                   align: nil)
+                                   font_color: nil, align: nil)
           create_field(name, :Tx) do |field|
             field.initialize_as_comb_text_field
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
             field[:MaxLen] = max_chars
           end
         end
@@ -224,11 +229,12 @@ module HexaPDF
         #
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
-        def create_file_select_field(name, font: nil, font_options: nil, font_size: nil, align: nil)
+        def create_file_select_field(name, font: nil, font_options: nil, font_size: nil,
+                                     font_color: nil, align: nil)
           create_field(name, :Tx) do |field|
             field.initialize_as_file_select_field
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -239,11 +245,12 @@ module HexaPDF
         #
         # The optional keyword arguments allow setting often used properties of the field, see
         # #create_text_field for details.
-        def create_password_field(name, font: nil, font_options: nil, font_size: nil, align: nil)
+        def create_password_field(name, font: nil, font_options: nil, font_size: nil,
+                                  font_color: nil, align: nil)
           create_field(name, :Tx) do |field|
             field.initialize_as_password_field
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -280,13 +287,13 @@ module HexaPDF
         # +font+, +font_options+, +font_size+ and +align+::
         #     See #create_text_field
         def create_combo_box(name, option_items: nil, editable: nil, font: nil,
-                             font_options: nil, font_size: nil, align: nil)
+                             font_options: nil, font_size: nil, font_color: nil, align: nil)
           create_field(name, :Ch) do |field|
             field.initialize_as_combo_box
             field.option_items = option_items if option_items
             field.flag(:edit) if editable
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -306,13 +313,13 @@ module HexaPDF
         # +font+, +font_options+, +font_size+ and +align+::
         #     See #create_text_field.
         def create_list_box(name, option_items: nil, multi_select: nil, font: nil,
-                            font_options: nil, font_size: nil, align: nil)
+                            font_options: nil, font_size: nil, font_color: nil, align: nil)
           create_field(name, :Ch) do |field|
             field.initialize_as_list_box
             field.option_items = option_items if option_items
             field.flag(:multi_select) if multi_select
             apply_variable_text_properties(field, font: font, font_options: font_options,
-                                           font_size: font_size, align: align)
+                                           font_size: font_size, font_color: font_color, align: align)
           end
         end
 
@@ -322,13 +329,16 @@ module HexaPDF
                                       type: :XXResources)
         end
 
-        # Sets the global default appearance string using the provided values.
+        # Sets the global default appearance string using the provided values or the default values
+        # which provide a sane default.
         #
-        # The default argument values are a sane default. If +font_size+ is set to 0, the font size
-        # is calculated using the height/width of the field.
-        def set_default_appearance_string(font: 'Helvetica', font_size: 0)
-          name = default_resources.add_font(document.fonts.add(font).pdf_object)
-          self[:DA] = "0 g /#{name} #{font_size} Tf"
+        # See VariableTextField::create_appearance_string for information on the arguments.
+        def set_default_appearance_string(font: 'Helvetica', font_options: {}, font_size: 0,
+                                          font_color: 0)
+          self[:DA] = VariableTextField.create_appearance_string(document, font: font,
+                                                                 font_options: font_options,
+                                                                 font_size: font_size,
+                                                                 font_color: font_color)
         end
 
         # Sets the /NeedAppearances field to +true+.
@@ -420,11 +430,12 @@ module HexaPDF
 
         # Applies the given variable field properties to the field.
         def apply_variable_text_properties(field, font: nil, font_options: nil, font_size: nil,
-                                           align: nil)
-          if font || font_options || font_size
+                                           font_color: nil, align: nil)
+          if font || font_options || font_size || font_color
             field.set_default_appearance_string(font: font || 'Helvetica',
                                                 font_options: font_options || {},
-                                                font_size: font_size || 0)
+                                                font_size: font_size || 0,
+                                                font_color: font_color || 0)
           end
           field.text_alignment(align) if align
         end
@@ -437,7 +448,7 @@ module HexaPDF
               yield("When the field /DA is present, the field /DR must also be present")
               return
             end
-            font_name, _ = VariableTextField.parse_appearance_string(da)
+            font_name, = VariableTextField.parse_appearance_string(da)
             if font_name && !(self[:DR][:Font] && self[:DR][:Font][font_name])
               yield("The font specified in /DA is not in the /DR resource dictionary")
             end