hexapdf 0.1.0

data/test/hexapdf/content/test_processor.rb

@@ -0,0 +1,156 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/processor'
+require 'hexapdf/document'
+
+describe HexaPDF::Content::Processor::GlyphBox do
+  before do
+    @box = HexaPDF::Content::Processor::GlyphBox.new(5, "5", 1, 2, 3, 4, 5, 6)
+  end
+
+  it "returns the correct bounding box coordinates" do
+    assert_equal([1, 2], @box.lower_left)
+    assert_equal([3, 4], @box.lower_right)
+    assert_equal([5, 6], @box.upper_left)
+    assert_equal([7, 8], @box.upper_right)
+  end
+
+  it "returns all box corners in one array when using #points" do
+    assert_equal([1, 2, 3, 4, 7, 8, 5, 6], @box.points)
+  end
+end
+
+describe HexaPDF::Content::Processor::CompositeBox do
+  before do
+    @glyph_box1 = HexaPDF::Content::Processor::GlyphBox.new(4, "4", 1, 1, 2, 1, 1, 2)
+    @glyph_box2 = HexaPDF::Content::Processor::GlyphBox.new(2, "2", 3, 1, 7, 1, 3, 2)
+    @boxes = HexaPDF::Content::Processor::CompositeBox.new
+  end
+
+  it "allows appending and retrieving of glyph boxes" do
+    result = (@boxes << @glyph_box1)
+    assert_equal(@boxes, result)
+    assert_equal(@glyph_box1, @boxes[0])
+  end
+
+  it "allows iterating over the glyph boxes " do
+    @boxes << @glyph_box1 << @glyph_box2
+    assert_equal([@glyph_box1, @glyph_box2], @boxes.each.to_a)
+  end
+
+  it "returns the concatenated string of the individual boxes" do
+    @boxes << @glyph_box1 << @glyph_box2
+    assert_equal("42", @boxes.string)
+  end
+
+  it "returns the correct bounding box coordinates" do
+    @boxes << @glyph_box1 << @glyph_box2
+    assert_equal([1, 1], @boxes.lower_left)
+    assert_equal([7, 1], @boxes.lower_right)
+    assert_equal([1, 2], @boxes.upper_left)
+    assert_equal([7, 2], @boxes.upper_right)
+  end
+end
+
+describe HexaPDF::Content::Processor do
+  before do
+    @processor = HexaPDF::Content::Processor.new
+  end
+
+  describe "initialization" do
+    it "has a prepopulated operators mapping" do
+      assert_kind_of(HexaPDF::Content::Operator::BaseOperator, @processor.operators[:q])
+    end
+  end
+
+  describe "graphics_object" do
+    it "default to :none on initialization" do
+      assert_equal(:none, @processor.graphics_object)
+    end
+  end
+
+  describe "process" do
+    it "invokes the specified operator implementation" do
+      op = Minitest::Mock.new
+      op.expect(:invoke, nil, [@processor, :arg])
+      @processor.operators[:test] = op
+      @processor.process(:test, [:arg])
+      op.verify
+    end
+
+    it "invokes the mapped message name" do
+      val = nil
+      @processor.define_singleton_method(:save_graphics_state) { val = :arg }
+      @processor.process(:q)
+      assert_equal(:arg, val)
+    end
+  end
+
+  describe "paint_xobject" do
+    it "processes the contents of a Form xobject" do
+      test_case = self
+      invoked = false
+
+      @processor.define_singleton_method(:set_line_width) do |_width|
+        test_case.assert_equal([2, 0, 0, 2, 10, 10], graphics_state.ctm.to_a)
+        invoked = true
+      end
+      @processor.resources = resources = Object.new
+      @processor.resources.define_singleton_method(:xobject) do |_name|
+        obj = {Matrix: [2, 0, 0, 2, 10, 10], Subtype: :Form}
+        obj.define_singleton_method(:process_contents) {|processor| processor.process(:w, [10])}
+        obj
+      end
+
+      @processor.process(:Do, [:Name])
+      assert(invoked)
+      assert_equal([1, 0, 0, 1, 0, 0], @processor.graphics_state.ctm.to_a)
+      assert_same(resources, @processor.resources)
+    end
+  end
+
+  describe "text decoding" do
+    before do
+      @doc =  HexaPDF::Document.new
+      @processor.process(:BT)
+      @processor.graphics_state.font = @font = @doc.add(Type: :Font, Subtype: :Type1,
+                                                        Encoding: :WinAnsiEncoding,
+                                                        BaseFont: :"Times-Roman")
+      @processor.graphics_state.font_size = 10
+      @processor.graphics_state.text_rise = 10
+    end
+
+    describe "decode_text" do
+      it "decodes text provided via one or the other of the two show show text operators" do
+        assert_equal("Hülle", @processor.send(:decode_text, "Hülle".encode("Windows-1252")))
+        arr = ["Hül".encode("Windows-1252"), 20, "le".encode("Windows-1252")]
+        assert_equal("Hülle", @processor.send(:decode_text, arr))
+      end
+    end
+
+    describe "decode_text_with_positioning" do
+      it "returns a composite box with positioning information" do
+        lly = @font.bounding_box[1] / 1000.0 * @processor.graphics_state.font_size +
+          @processor.graphics_state.text_rise
+        lry = @font.bounding_box[3] / 1000.0 * @processor.graphics_state.font_size +
+          @processor.graphics_state.text_rise
+        arr = ["Hül".encode("Windows-1252"), 20, "le".encode("Windows-1252")]
+        width = "Hülle".encode("Windows-1252").codepoints.inject(0) {|s, cp| s + @font.width(cp)}
+        width = (width - 20) * @processor.graphics_state.font_size / 1000.0
+
+        box = @processor.send(:decode_text_with_positioning, arr)
+        assert_equal("Hülle", box.string)
+        assert_in_delta(0, box[0].lower_left[0])
+        assert_in_delta(lly, box[0].lower_left[1])
+        assert_in_delta(width, box[4].upper_right[0])
+        assert_in_delta(lry, box[4].upper_right[1])
+      end
+
+      it "fails if the current font is a vertical font" do
+        @processor.graphics_state.font.define_singleton_method(:writing_mode) { :vertical }
+        assert_raises(NotImplementedError) { @processor.send(:decode_text_with_positioning, "a") }
+      end
+    end
+  end
+end

data/test/hexapdf/content/test_transformation_matrix.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/transformation_matrix'
+
+describe HexaPDF::Content::TransformationMatrix do
+  before do
+    @matrix = HexaPDF::Content::TransformationMatrix.new
+  end
+
+  describe "initialize" do
+    it "initializes to the identity matrix" do
+      assert_equal(1, @matrix.a)
+      assert_equal(0, @matrix.b)
+      assert_equal(0, @matrix.c)
+      assert_equal(1, @matrix.d)
+      assert_equal(0, @matrix.e)
+      assert_equal(0, @matrix.f)
+    end
+
+    it "can use arbitrary values" do
+      @matrix = HexaPDF::Content::TransformationMatrix.new(2, 3, 4, 5, 6, 7)
+      assert_equal(2, @matrix.a)
+      assert_equal(3, @matrix.b)
+      assert_equal(4, @matrix.c)
+      assert_equal(5, @matrix.d)
+      assert_equal(6, @matrix.e)
+      assert_equal(7, @matrix.f)
+    end
+  end
+
+  it "correctly evaluates a point" do
+    assert_equal([2, 3], @matrix.evaluate(2, 3))
+  end
+
+  it "correctly translates the matrix" do
+    @matrix.translate(5, 10)
+    assert_equal([7, 13], @matrix.evaluate(2, 3))
+  end
+
+  it "correctly rotates the matrix" do
+    @matrix.rotate(90)
+    assert_equal([-3, 2], @matrix.evaluate(2, 3))
+  end
+
+  it "correctly scales the matrix" do
+    @matrix.scale(5, 10)
+    assert_equal([10, 30], @matrix.evaluate(2, 3))
+  end
+
+  it "correctly skews the matrix" do
+    assert_equal([2, 5], @matrix.dup.skew(45, 0).evaluate(2, 3))
+    assert_equal([5, 3], @matrix.dup.skew(0, 45).evaluate(2, 3))
+  end
+
+  it "can be compared to another matrix" do
+    assert_equal(HexaPDF::Content::TransformationMatrix.new, @matrix)
+    refute_equal(HexaPDF::Content::TransformationMatrix.new(5), @matrix)
+  end
+
+  it "allows the conversion of the matrix into an array" do
+    assert_equal([1, 0, 0, 1, 0, 0], @matrix.to_a)
+  end
+end

data/test/hexapdf/encryption/common.rb

@@ -0,0 +1,87 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+
+# Contains tests that validate that an encryption algorithm's class conforms to the general
+# interface.
+#
+# The algorithm class needs to be available in the @algorithm_class variable.
+module EncryptionAlgorithmInterfaceTests
+
+  def test_responds_to_necessary_methods
+    [:encrypt, :decrypt, :encryption_fiber, :decryption_fiber].each do |method|
+      assert_respond_to(@algorithm_class, method)
+      assert_equal(2, @algorithm_class.method(method).arity)
+    end
+  end
+
+end
+
+# Contains common tests for AES algorithms.
+#
+# The algorithm class needs to be available in the @algorithm_class variable.
+module AESEncryptionTests
+
+  include EncryptionAlgorithmInterfaceTests
+
+  TEST_VECTOR_FILES = Dir[File.join(TEST_DATA_DIR, 'aes-test-vectors', '*')]
+
+  def test_processes_the_aes_test_vectors
+    TEST_VECTOR_FILES.each do |filename|
+      name, size, mode = File.basename(filename, '.data.gz').split('-')
+      size = size.to_i / 8
+      data = Zlib::GzipReader.open(filename) {|io| io.read}.force_encoding(Encoding::BINARY)
+      data.scan(/(.{#{size}})(.{16})(.{16})(.{16})/m).each_with_index do |(key, iv, plain, cipher), index|
+        aes = @algorithm_class.new(key, iv, mode.intern)
+        assert_equal(cipher, aes.process(plain),
+                     "name: #{name}, size: #{size * 8}, mode: #{mode}, index: #{index}")
+      end
+    end
+  end
+
+  def test_can_accept_one_big_chunk_or_multiple_smaller_ones
+    big = @algorithm_class.new('t' * 16, '0' * 16, :encrypt)
+    small = @algorithm_class.new('t' * 16, '0' * 16, :encrypt)
+    assert_equal(big.process('some' * 16),
+                 small.process('some' * 8) << small.process('some' * 4) << small.process('some' * 4))
+  end
+
+  def test_raises_error_on_invalid_key_length
+    assert_raises(HexaPDF::EncryptionError) { @algorithm_class.new('t' * 7, '0' * 16, :encrypt) }
+  end
+
+  def test_raises_error_on_invalid_iv_length
+    assert_raises(HexaPDF::EncryptionError) { @algorithm_class.new('t' * 16, '0' * 7, :encrypt) }
+  end
+
+end
+
+# Contains common tests for AES algorithms.
+#
+# The algorithm class needs to be available in the @algorithm_class variable.
+module ARC4EncryptionTests
+
+  include EncryptionAlgorithmInterfaceTests
+
+  def setup
+    super
+    @encrypted = ['BBF316E8D940AF0AD3', '1021BF0420', '45A01F645FC35B383552544B9BF5'].
+      map {|c| [c].pack('H*')}
+    @plain = ['Plaintext', 'pedia', 'Attack at dawn'].each {|s| s.force_encoding('BINARY')}
+    @keys = ['Key', 'Wiki', 'Secret']
+  end
+
+  def test_processes_the_test_vectors_from_the_rc4_wikipeda_page
+    @keys.each_with_index do |key, i|
+      assert_equal(@encrypted[i], @algorithm_class.new(key).process(@plain[i]))
+    end
+  end
+
+  def test_can_accept_one_big_chunk_or_multiple_smaller_ones
+    big = @algorithm_class.new('key')
+    small = @algorithm_class.new('key')
+    assert_equal(big.process('some big data chunk'),
+                 small.process('some') << small.process(' big') << small.process(' data chunk'))
+  end
+
+end

data/test/hexapdf/encryption/test_aes.rb

@@ -0,0 +1,121 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/encryption/aes'
+
+describe HexaPDF::Encryption::AES do
+  include EncryptionAlgorithmInterfaceTests
+
+  before do
+    @algorithm_class = Class.new do
+      prepend HexaPDF::Encryption::AES
+
+      attr_reader :key, :iv, :mode
+
+      def initialize(key, iv, mode)
+        @key, @iv, @mode = key, iv, mode
+      end
+
+      def process(data)
+        raise "invalid data" if data.length == 0 || data.length % 16 != 0
+        data
+      end
+    end
+
+    @padding_data = (0..15).map do |length|
+      {plain: '5' * length, cipher_padding: '5' * length + (16 - length).chr * (16 - length), length: 32}
+    end
+    @padding_data << {plain: '5' * 16, cipher_padding: '5' * 16 + 16.chr * 16, length: 48}
+  end
+
+  describe "klass.encrypt/.decrypt" do
+    it "returns the padded result with IV on klass.encrypt" do
+      @padding_data.each do |data|
+        result = @algorithm_class.encrypt('some key' * 2, data[:plain])
+        assert_equal(data[:length], result.length)
+        assert_equal(data[:cipher_padding][-16, 16], result[-16, 16])
+      end
+    end
+
+    it "returns the decrypted result without padding and with IV removed on klass.decrypt" do
+      @padding_data.each do |data|
+        result = @algorithm_class.decrypt('some key' * 2, 'iv' * 8 + data[:cipher_padding])
+        assert_equal(data[:plain], result)
+      end
+    end
+
+    it "fails on decryption if the padding is invalid" do
+      assert_raises(HexaPDF::EncryptionError) do
+        @algorithm_class.decrypt('some' * 4, 'iv' * 8 + 'somedata' * 4)
+      end
+    end
+
+    it "fails on decryption if not enough bytes are provided" do
+      assert_raises(HexaPDF::EncryptionError) do
+        @algorithm_class.decrypt('some' * 4, 'no iv')
+      end
+    end
+  end
+
+  describe "klass.encryption_fiber/.decryption_fiber" do
+    before do
+      @fiber = Fiber.new { Fiber.yield('first'); 'second' }
+    end
+
+    it "returns the padded result with IV on encryption_fiber" do
+      @padding_data.each do |data|
+        result = @algorithm_class.encryption_fiber('some key' * 2, Fiber.new { data[:plain] })
+        result = TestHelper.collector(result)
+        assert_equal(data[:length], result.length)
+        assert_equal(data[:cipher_padding][-16, 16], result[-16, 16])
+      end
+    end
+
+    it "returns the decrypted result without padding and with IV removed on decryption_fiber" do
+      @padding_data.each do |data|
+        result = @algorithm_class.decryption_fiber('some key' * 2, Fiber.new {'iv' * 8 + data[:cipher_padding]})
+        result = TestHelper.collector(result)
+        assert_equal(data[:plain], result)
+      end
+    end
+
+    it "encryption works with multiple yielded strings" do
+      f = Fiber.new { Fiber.yield('a' * 40); Fiber.yield('test'); "b" * 20 }
+      result = TestHelper.collector(@algorithm_class.encryption_fiber('some key' * 2, f))
+      assert_equal('a' * 40 << 'test' << 'b' * 20, result[16..-17])
+    end
+
+    it "decryption works with multiple yielded strings" do
+      f = Fiber.new do
+        Fiber.yield('iv' * 4)
+        Fiber.yield('iv' * 4)
+        Fiber.yield('a' * 20)
+        Fiber.yield('a' * 20)
+        8.chr * 8
+      end
+      result = TestHelper.collector(@algorithm_class.decryption_fiber('some key' * 2, f))
+      assert_equal('a' * 40, result)
+    end
+
+    it "fails on decryption if the padding is invalid" do
+      assert_raises(HexaPDF::EncryptionError) do
+        TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, Fiber.new { 'a' * 32 }))
+      end
+    end
+
+    it "fails on decryption if not enough bytes are provided" do
+      [4, 20, 40].each do |length|
+        assert_raises(HexaPDF::EncryptionError) do
+          TestHelper.collector(@algorithm_class.decryption_fiber('some' * 4, Fiber.new { 'a' * length }))
+        end
+      end
+    end
+  end
+
+  it "does basic validation on initialization" do
+    assert_raises(HexaPDF::EncryptionError) { @algorithm_class.new('t' * 7, '0' * 16, :encrypt) }
+    assert_raises(HexaPDF::EncryptionError) { @algorithm_class.new('t' * 16, '0' * 7, :encrypt) }
+    obj = @algorithm_class.new('t' * 16, 'i' * 16, 'encrypt')
+    assert_equal(:encrypt, obj.mode)
+  end
+end

data/test/hexapdf/encryption/test_arc4.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/encryption/arc4'
+
+describe HexaPDF::Encryption::ARC4 do
+  include EncryptionAlgorithmInterfaceTests
+
+  before do
+    @algorithm_class = Class.new do
+      prepend HexaPDF::Encryption::ARC4
+
+      def initialize(key)
+        @data = key
+      end
+
+      def process(data)
+        raise if data.empty?
+        result = @data << data
+        @data = ''
+        result
+      end
+    end
+  end
+
+  it "correctly uses klass.encrypt and klass.decrypt" do
+    assert_equal('mykeydata', @algorithm_class.encrypt('mykey', 'data'))
+    assert_equal('mykeydata', @algorithm_class.decrypt('mykey', 'data'))
+  end
+
+  it "correctly uses klass.encryption_fiber and klass.decryption_fiber" do
+    f = Fiber.new { Fiber.yield('first'); Fiber.yield(''); 'second' }
+    assert_equal('mykeyfirstsecond',
+                 TestHelper.collector(@algorithm_class.encryption_fiber('mykey', f)))
+    f = Fiber.new { Fiber.yield('first'); 'second' }
+    assert_equal('mykeyfirstsecond',
+                 TestHelper.collector(@algorithm_class.decryption_fiber('mykey', f)))
+  end
+end

data/test/hexapdf/encryption/test_fast_aes.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/encryption/fast_aes'
+
+describe HexaPDF::Encryption::FastAES do
+  include AESEncryptionTests
+
+  before do
+    @algorithm_class = HexaPDF::Encryption::FastAES
+  end
+
+  it "uses a better random bytes generator" do
+    assert_equal(@algorithm_class.singleton_class, @algorithm_class.method(:random_bytes).owner)
+    assert_equal(16, @algorithm_class.random_bytes(16).length)
+  end
+end

data/test/hexapdf/encryption/test_fast_arc4.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/encryption/fast_arc4'
+
+describe HexaPDF::Encryption::FastARC4 do
+  include ARC4EncryptionTests
+
+  before do
+    @algorithm_class = HexaPDF::Encryption::FastARC4
+  end
+end

data/test/hexapdf/encryption/test_identity.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/encryption/identity'
+
+describe HexaPDF::Encryption::Identity do
+  include EncryptionAlgorithmInterfaceTests
+
+  before do
+    @algorithm_class = HexaPDF::Encryption::Identity
+  end
+
+  it "returns the data unmodified for encrypt/decrypt" do
+    assert_equal('data', @algorithm_class.encrypt('key', 'data'))
+  end
+
+  it "returns the source Fiber unmodified for encryption_fiber/decryption_fiber" do
+    f = Fiber.new {'data'}
+    assert_equal(f, @algorithm_class.encryption_fiber('key', f))
+  end
+end

data/test/hexapdf/encryption/test_ruby_aes.rb

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/encryption/ruby_aes'
+require 'hexapdf/encryption/fast_aes'
+
+describe HexaPDF::Encryption::RubyAES do
+  include AESEncryptionTests
+
+  before do
+    @algorithm_class = HexaPDF::Encryption::RubyAES
+  end
+
+  it "is compatible with the OpenSSL based FastAES implementation" do
+    sample = Random.new.bytes(1024)
+    key = Random.new.bytes(16)
+    iv = Random.new.bytes(16)
+    assert_equal(sample, HexaPDF::Encryption::FastAES.new(key, iv, :encrypt).
+                 process(HexaPDF::Encryption::RubyAES.new(key, iv, :decrypt).process(sample)))
+    assert_equal(sample, HexaPDF::Encryption::FastAES.new(key, iv, :decrypt).
+                 process(HexaPDF::Encryption::RubyAES.new(key, iv, :encrypt).process(sample)))
+  end
+end

data/test/hexapdf/encryption/test_ruby_arc4.rb

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+require 'hexapdf/encryption/ruby_arc4'
+require 'hexapdf/encryption/fast_arc4'
+
+describe HexaPDF::Encryption::RubyARC4 do
+  include ARC4EncryptionTests
+
+  before do
+    @algorithm_class = HexaPDF::Encryption::RubyARC4
+  end
+
+  it "is compatible with the OpenSSL based FastARC4 implementation" do
+    @keys.each_with_index do |key, i|
+      assert_equal(@plain[i], HexaPDF::Encryption::FastARC4.new(key).
+                   process(HexaPDF::Encryption::RubyARC4.new(key).process(@plain[i])))
+    end
+  end
+end