hexapdf 0.19.0 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55ddbf5c737ab446c5793660957e64aaf6f8872c6bb1c4a76ba39a87193b951f
-  data.tar.gz: eb29fbb41cbb20c060c43cc80406bd4b11fa36b0d86a95daa9d1093d060ab89e
+  metadata.gz: 496c87d6cffcfde7b155fbfcdd78673fb34931d4d0fd997bcee934decfba175d
+  data.tar.gz: ce72598c9d33735c6ea4738c072b1f00202dc7bac24577c9c27a062add38ea8e
 SHA512:
-  metadata.gz: 28368cd415cd9adf28050df8812a0cda999b8140fcba4a9f307d7e37f6dc0254d99abf5173a81a1b2b59f9f6a658a46f6998d7834b93ffc19840d578e507ce92
-  data.tar.gz: b25e409653a4bd9359f3a39c2920187261a43151942c4120d2bd818886dbf236f77483a42ca7a7fb39ffbcdfc7da8cf9d7a87609a4f4af514cf7f93f495eb5ed
+  metadata.gz: cee5a6f86084490ba5602c40ec48945b9a3c0bdecb22fe03e2d7b8b6ad02c791900f9fd7354557a9ac3dfdebb4a8d95c7335fc329c0054156082853f33717144
+  data.tar.gz: eaed67cce68e703eddbbb357e790a9f0bc62083ff8ba0b0856aa360d499f75e0e022b1ccd41ebcdd53e2fe269a93b5f587c47db41311c3f6a0beb9ed293e02cd

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.19.1 - 2021-12-12
+
+### Added
+
+* [HexaPDF::Type::FontType3#bounding_box] to fix content stream processing error
+
+### Fixed
+
+* Calculation of scaled font size for [HexaPDF::Content::GraphicsState] and
+  [HexaPDF::Layout::Style] when Type3 fonts are used
+
+
 ## 0.19.0 - 2021-11-24
 
 ### Added

data/lib/hexapdf/content/graphics_state.rb

@@ -512,7 +512,7 @@ module HexaPDF
       attr_accessor :leading
 
       # The font for the text.
-      attr_accessor :font
+      attr_reader :font
 
       # The font size.
       attr_reader :font_size
@@ -552,9 +552,11 @@ module HexaPDF
 
       # The scaled font size used in glyph displacement calculations.
       #
-      # This returns the font size divided by 1000 multiplied by #scaled_horizontal_scaling.
+      # This returns the font size multiplied by the scaling factor from glyph space to text space
+      # (0.001 for all fonts except Type3 fonts or the scaling specified in /FontMatrix for Type3
+      # fonts) and multiplied by #scaled_horizontal_scaling.
       #
-      # See PDF1.7 s9.4.4
+      # See PDF1.7 s9.4.4, HexaPDF::Type::FontType3
       attr_reader :scaled_font_size
 
       # The scaled horizontal scaling used in glyph displacement calculations.
@@ -665,6 +667,15 @@ module HexaPDF
         self.fill_color = color_space.default_color
       end
 
+      ##
+      # :attr_writer: font
+      #
+      # Sets the font and updates the glyph space to text space scaling.
+      def font=(font)
+        @font = font
+        update_scaled_font_size
+      end
+
       ##
       # :attr_writer: character_spacing
       #
@@ -689,7 +700,7 @@ module HexaPDF
       # Sets the font size and updates the scaled font size.
       def font_size=(size)
         @font_size = size
-        @scaled_font_size = size / 1000.0 * @scaled_horizontal_scaling
+        update_scaled_font_size
       end
 
       ##
@@ -702,7 +713,15 @@ module HexaPDF
         @scaled_horizontal_scaling = scaling / 100.0
         @scaled_character_spacing = @character_spacing * @scaled_horizontal_scaling
         @scaled_word_spacing = @word_spacing * @scaled_horizontal_scaling
-        @scaled_font_size = @font_size / 1000.0 * @scaled_horizontal_scaling
+        update_scaled_font_size
+      end
+
+      private
+
+      # Updates the cached value for the scaled font size.
+      def update_scaled_font_size
+        @scaled_font_size = @font_size * (@font&.glyph_scaling_factor || 0.001) *
+          @scaled_horizontal_scaling
       end
 
     end

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/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/type/font.rb

@@ -98,6 +98,11 @@ module HexaPDF
         embedded?
       end
 
+      # Returns the glyph scaling factor for transforming from glyph space to text space.
+      def glyph_scaling_factor
+        0.001
+      end
+
       private
 
       # Parses and caches the ToUnicode CMap.

data/lib/hexapdf/type/font_type3.rb

@@ -41,6 +41,10 @@ module HexaPDF
 
     # Represents a Type 3 font.
     #
+    # Note: We assume the /FontMatrix is only used for scaling, i.e. of the form [x 0 0 +/-x 0 0].
+    # If it is of a different form, things won't work correctly. This will be handled once such a
+    # case is found.
+    #
     # See: PDF1.7 s9.6.5
     class FontType3 < FontSimple
 
@@ -51,6 +55,22 @@ module HexaPDF
       define_field :CharProcs,  type: Dictionary, required: true
       define_field :Resources,  type: Dictionary, version: '1.2'
 
+      # Returns the bounding box of the font.
+      def bounding_box
+        matrix = self[:FontMatrix]
+        bbox = self[:FontBBox].value
+        if matrix[3] < 0    # Some writers invert the y-axis
+          bbox = bbox.dup
+          bbox[1], bbox[3] = -bbox[3], -bbox[1]
+        end
+        bbox
+      end
+
+      # Returns the glyph scaling factor for transforming from glyph space to text space.
+      def glyph_scaling_factor
+        self[:FontMatrix][0]
+      end
+
       private
 
       def perform_validation

data/lib/hexapdf/type/signature/adbe_pkcs7_detached.rb

@@ -0,0 +1,125 @@
+# -*- 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'
+require 'hexapdf/type/signature'
+
+module HexaPDF
+  module Type
+    class Signature
+
+      # The signature handler for the adbe.pkcs7.detached sub-filter.
+      class AdbePkcs7Detached < Handler
+
+        # Creates a new signature handler for the given signature dictionary.
+        def initialize(signature_dict)
+          super
+          @pkcs7 = OpenSSL::PKCS7.new(signature_dict.contents)
+        end
+
+        # Returns the common name of the signer.
+        def signer_name
+          signer_certificate.subject.to_a.assoc("CN")&.[](1) || super
+        end
+
+        # Returns the time of signing.
+        def signing_time
+          signer_info.signed_time rescue super
+        end
+
+        # Returns the certificate chain.
+        def certificate_chain
+          @pkcs7.certificates
+        end
+
+        # Returns the signer certificate (an instance of OpenSSL::X509::Certificate).
+        def signer_certificate
+          info = signer_info
+          certificate_chain.find {|cert| cert.issuer == info.issuer && cert.serial == info.serial }
+        end
+
+        # Returns the signer information object (an instance of OpenSSL::PKCS7::SignerInfo).
+        def signer_info
+          @pkcs7.signers.first
+        end
+
+        # Verifies the signature using the provided OpenSSL::X509::Store object.
+        def verify(store, allow_self_signed: false)
+          result = VerificationResult.new
+
+          signer_info = self.signer_info
+          signer_certificate = self.signer_certificate
+          certificate_chain = self.certificate_chain
+
+          if certificate_chain.empty?
+            result.log(:error, "No certificates found in signature")
+            return result
+          end
+
+          if @pkcs7.signers.size != 1
+            result.log(:error, "Exactly one signer needed, found #{@pkcs7.signers.size}")
+          end
+
+          unless signer_certificate
+            result.log(:error, "Signer serial=#{signer_info.serial} issuer=#{signer_info.issuer} " \
+                       "not found in certificates stored in PKCS7 object")
+            return result
+          end
+
+          key_usage = signer_certificate.extensions.find {|ext| ext.oid == 'keyUsage' }
+          unless key_usage && key_usage.value.split(', ').include?("Digital Signature")
+            result.log(:error, "Certificate key usage is missing 'Digital Signature'")
+          end
+
+          verify_signing_time(result)
+
+          store.verify_callback = store_verification_callback(result,
+                                                              allow_self_signed: allow_self_signed)
+          if @pkcs7.verify(certificate_chain, store, signature_dict.signed_data,
+                           OpenSSL::PKCS7::DETACHED | OpenSSL::PKCS7::BINARY)
+            result.log(:info, "Signature valid")
+          else
+            result.log(:error, "Signature verification failed")
+          end
+
+          result
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.19.0'
+  VERSION = '0.19.1'
 
 end

data/test/hexapdf/content/test_graphics_state.rb

@@ -2,6 +2,7 @@
 
 require 'test_helper'
 require 'hexapdf/content/graphics_state'
+require 'ostruct'
 
 # Dummy class used as wrapper so that constant lookup works correctly
 class GraphicsStateWrapper < Minitest::Spec
@@ -146,6 +147,13 @@ class GraphicsStateWrapper < Minitest::Spec
     it "fails when restoring the graphics state if the stack is empty" do
       assert_raises(HexaPDF::Error) { @gs.restore }
     end
-  end
 
+    it "uses the correct glyph to text space scaling" do
+      font = OpenStruct.new
+      font.glyph_scaling_factor = 0.002
+      @gs.font = font
+      @gs.font_size = 10
+      assert_equal(0.02, @gs.scaled_font_size)
+    end
+  end
 end

data/test/hexapdf/content/test_operator.rb

@@ -4,6 +4,7 @@ require 'test_helper'
 require 'hexapdf/content/operator'
 require 'hexapdf/content/processor'
 require 'hexapdf/serializer'
+require 'ostruct'
 
 describe HexaPDF::Content::Operator::BaseOperator do
   before do
@@ -190,9 +191,11 @@ end
 
 describe_operator :SetGraphicsStateParameters, :gs do
   it "applies parameters from an ExtGState dictionary" do
+    font = OpenStruct.new
+    font.glyph_scaling_factor = 0.01
     @processor.resources[:ExtGState] = {Name: {LW: 10, LC: 2, LJ: 2, ML: 2, D: [[3, 5], 2],
                                                RI: 2, SA: true, BM: :Multiply, CA: 0.5, ca: 0.5,
-                                               AIS: true, TK: false, Font: [:Test, 10]}}
+                                               AIS: true, TK: false, Font: [font, 10]}}
     @processor.resources.define_singleton_method(:document) do
       Object.new.tap {|obj| obj.define_singleton_method(:deref) {|o| o } }
     end
@@ -210,7 +213,7 @@ describe_operator :SetGraphicsStateParameters, :gs do
     assert_equal(0.5, gs.stroke_alpha)
     assert_equal(0.5, gs.fill_alpha)
     assert(gs.alpha_source)
-    assert_equal(:Test, gs.font)
+    assert_equal(font, gs.font)
     assert_equal(10, gs.font_size)
     refute(gs.text_knockout)
   end
@@ -448,7 +451,9 @@ describe_operator :SetFontAndSize, :Tf do
       self[:Font] && self[:Font][name]
     end
 
-    @processor.resources[:Font] = {F1: :test}
+    font = OpenStruct.new
+    font.glyph_scaling_factor = 0.01
+    @processor.resources[:Font] = {F1: font}
     invoke(:F1, 10)
     assert_equal(@processor.resources.font(:F1), @processor.graphics_state.font)
     assert_equal(10, @processor.graphics_state.font_size)

data/test/hexapdf/layout/test_style.rb

@@ -597,6 +597,11 @@ end
 describe HexaPDF::Layout::Style do
   before do
     @style = HexaPDF::Layout::Style.new
+    @style.font = Object.new.tap do |obj|
+      obj.define_singleton_method(:pdf_object) do
+        Object.new.tap {|pdf| pdf.define_singleton_method(:glyph_scaling_factor) { 0.001 } }
+      end
+    end
   end
 
   it "can assign values on initialization" do
@@ -644,6 +649,7 @@ describe HexaPDF::Layout::Style do
   end
 
   it "has several simple and dynamically generated properties with default values" do
+    @style = HexaPDF::Layout::Style.new
     assert_raises(HexaPDF::Error) { @style.font }
     assert_equal(10, @style.font_size)
     assert_equal(0, @style.character_spacing)
@@ -725,6 +731,11 @@ describe HexaPDF::Layout::Style do
       font = Object.new
       font.define_singleton_method(:scaling_factor) { 1 }
       font.define_singleton_method(:wrapped_font) { wrapped_font }
+      font.define_singleton_method(:pdf_object) do
+        obj = Object.new
+        obj.define_singleton_method(:glyph_scaling_factor) { 0.001 }
+        obj
+      end
       @style.font = font
     end
 

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.19.0)>>
+      <</Producer(HexaPDF version 0.19.1)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.19.0)>>
+      <</Producer(HexaPDF version 0.19.1)>>
       endobj
       2 0 obj
       <</Length 10>>stream

data/test/hexapdf/type/test_font.rb

@@ -64,4 +64,8 @@ describe HexaPDF::Type::Font do
       assert_equal(5, @font.font_file)
     end
   end
+
+  it "returns the glyph scaling factor" do
+    assert_equal(0.001, @font.glyph_scaling_factor)
+  end
 end

data/test/hexapdf/type/test_font_type3.rb

@@ -9,10 +9,25 @@ describe HexaPDF::Type::FontType3 do
     @doc = HexaPDF::Document.new
     @font = @doc.add({Type: :Font, Subtype: :Type3, Encoding: :WinAnsiEncoding,
                       FirstChar: 32, LastChar: 34, Widths: [600, 0, 700],
-                      FontBBox: [0, 0, 100, 100], FontMatrix: [1, 0, 0, 1, 0, 0],
+                      FontBBox: [0, 100, 100, 0], FontMatrix: [0.002, 0, 0, 0.002, 0, 0],
                       CharProcs: {}})
   end
 
+  describe "bounding_box" do
+    it "returns the font's bounding box" do
+      assert_equal([0, 0, 100, 100], @font.bounding_box)
+    end
+
+    it "inverts the y-values if necessary based on /FontMatrix" do
+      @font[:FontMatrix][3] *= -1
+      assert_equal([0, -100, 100, 0], @font.bounding_box)
+    end
+  end
+
+  it "returns the glyph scaling factor" do
+    assert_equal(0.002, @font.glyph_scaling_factor)
+  end
+
   describe "validation" do
     it "works for valid objects" do
       assert(@font.validate)